Not working code. Where is the error? (NFC gate opener)



  • Hello All!

    I have a problem what makes my hair gray...

    I have a working MYSENSORS network with VERA3 at home.
    I have found out that our electronic gate should be controlled by NFC cards and/or VERA.
    I did my hardware which was actually not difficult.
    I used a Mini Pro 5V + Radio with step down regulator + RGB LED + RFID reader.+ relay.

    I used 2 sketches to integrate in one solution.
    The first one is from webnology and the another one is from here sample sketch.
    I uploaded both, and they worked without problem.
    Then I tried to integrate, and together they do not want to work, providing very strange result on the serial interface.

    The software should do the followings:

    • store the card data in the EEPROM of the Arduino
    • with master card it is possible to store new athorized cards and delet cards from eeprom
    • relay state should be represented in Vera
    • relay state should be changeable by Vera
    • relay should be closed for a given period (1 minute)
    • RGB LED is a common Anode LED

    In the future I would like to solve that VERA should be able to handle card info (delete or add).

    And now the working code (I marked out the problematic codes what makes the connection to VERA)::



  • Sorry for the code format, but can somebody explain me how to include the whole code in readable format?


  • Admin

    enclose between 4 back-ticks ````



  • My code between 4 backticks:

    /***********************************************************************************************************************************************/
    /*
        @file     RfidAccessControlWithEepromStorage.ino
        @author   webnology gmbh
        @license  GPL v2 or later (see  ---> http://www.gnu.org/licenses/gpl-2.0.txt )
        The sketch is an RFID (access) control system that stores RFIDs to EEPROM.
        All RFID cards stored in EEPROM will be granted access, all others will be denied access.	
        It is designed to work with Mifare Classic and Mifare Ultralight cards (no other cards have been tested).
        To store or delete RFIDs from EEPROM a 'MASTER' card is used. The UID of the master card 
        is hardcoded in the sketch. It has to be a Mifare Classic 4 byte card. When the MASTER card is read by 
        the reader the application will remain in MASTER MODE for 30 sec. It will include or exclude the next 
        RFID card that is read. If the RFID is already stored in the EEPROM it will be erased (excluded), if the 
        RFID is not in the EEPROM it will be stored (included) into the EEPROM.
        
        The EEPROM rfid storage is organised as following (example):
        
        |uidLength|uid byte|uid byte|uid byte|uid byte|uidLength|uid byte|uid byte|uid byte|uid byte|uidLength
        |   4     |   BE   |    23  |    2D  |   DE   |    4    |    AB  |    20  |   FE   |   2D   |   7     
        
        |uid byte|uid byte|uid byte|uid byte|uid byte|uid byte|uid byte|uidLength|....|  end  |
        |    2B  |   BE   |    88  |    FE  |    20  |   EC   |   EC   |   4     |....|   0   |
        
        
        IMPORTANT: Set the EEPROMSize constant to your EEPROM size!!
                   Go to the setup() section and uncomment initializeEeprom(); Run the sketch and than comment again
                   the initializeEeprom();
        
        Note that you need the baud rate to be 115200 because we need to
        print out the data and read from the card at the same time! 
    	webnology gmbh invests time and resources to provide open source software,
    	please refer to our website to support us.
    	  ----> http://www.webnology.ch
    	This sketch depends on the following library:
    	  ----> https://github.com/adafruit/Adafruit-PN532
    	Acknowledgements:
    	This is a sketch developed to work with the Adafruit PN532 NFC/RFID breakout board,
            the wiring is explained at: ----> http://learn.adafruit.com/adafruit-pn532-rfid-nfc/breakout-wiring
    	you can buy it at the Adafruit store:
    	  ----> https://www.adafruit.com/products/364
    	 
    */
    /***********************************************************************************************************************************************/
    
    
    /***********************************************************************************************************************************************/
    //INIT VARS
    /***********************************************************************************************************************************************/
    #include <MySensor.h>  
    #include <SPI.h>
    #include <Wire.h>
    #include <PN532_I2C.h>
    #include <PN532.h>
    
    // COMMON ANODE LEDs to indicate the status
    const uint8_t led_red = 6;
    const uint8_t led_green = 7;
    const uint8_t led_blue = 8;
    const boolean OFF = HIGH; 
    const boolean ON = LOW; 
    
    // Drived Pin definition
    const int lockPin = 5;           // (Digital 5) The pin that activates the relay/solenoid lock.
    boolean lockStatus;              // The Status will be stored here
    const int gateTime = 1000;       // Open time for circuit in milliseconds
    const int messageTime = 500;     // Message time (lit time for LED)
    
    //---------------------------------------------
    // EEPROM
    //---------------------------------------------
    
    const uint32_t EEPROMSize = 1023; //BE CAREFULL NOT TO EXCEED EEPROM SIZE OF YOUR ARDUINO 
                                //TO AVOID DAMAGING YOUR EEPROM!!!!!!!
    const uint32_t memBase = 512; // Start the storage of RFID from this address
    
    //---------------------------------------------
    // MYSENSORS NETWORK SETUP
    //---------------------------------------------
    
    #define CHILD_ID 1   // Id of the sensor child
    MySensor gw;
    //MyMessage lockMsg(CHILD_ID, V_LOCK_STATUS);
    
    
    //---------------------------------------------
    // RFID MASTER, HARDCODED
    //---------------------------------------------
    
    uint32_t uid_master = 347364468;
    
    uint32_t master_mode = 0;  
    uint32_t master_mode_counter = 0;
    
    PN532_I2C pn532i2c(Wire);
    PN532 nfc(pn532i2c);
    
    //---------------------------------------------
    // DEBUG
    //---------------------------------------------
    
    boolean debug = true;
    //boolean debug = false;
    
    
    /***********************************************************************************************************************************************/
    // Functions
    /***********************************************************************************************************************************************/
    //---------------------------------------------
    // set LEDs
    //---------------------------------------------
    void led(uint8_t status=1){
      switch (status) {
        case 1:
          // error connecting pn532,	red green
          // error reading RFID
          digitalWrite(led_blue, OFF);
          digitalWrite(led_red, ON);
          digitalWrite(led_green, ON);
          break;
        case 2:
          // storage full			red green blue
          digitalWrite(led_blue, ON);
          digitalWrite(led_red, ON);
          digitalWrite(led_green, ON);      
          break;
        case 3:
          // ready to read RFID		none
          digitalWrite(led_blue, OFF);
          digitalWrite(led_red, OFF);
          digitalWrite(led_green, OFF);      
          break;
        case 4:
          // RFID authorized		green
          digitalWrite(led_blue, OFF);
          digitalWrite(led_red, OFF);
          digitalWrite(led_green, ON);      
          break; 
         case 5:
          // RFID not authorized		red 
          digitalWrite(led_blue, OFF);
          digitalWrite(led_red, ON);
          digitalWrite(led_green, OFF);      
          break;    
         case 6:
          // RFID read MASTER		blue
          // inclusion/exclusion MODE
          digitalWrite(led_blue, ON);
          digitalWrite(led_red, OFF);
          digitalWrite(led_green, OFF);      
          break; 
         case 7:
          // RFID included			blue green
          digitalWrite(led_blue, ON);
          digitalWrite(led_red, OFF);
          digitalWrite(led_green, ON);      
          break;        
          case 8:
          // RFID excluded			blue red
          digitalWrite(led_blue, ON);
          digitalWrite(led_red, ON);
          digitalWrite(led_green, OFF);      
          break;  
      }
    }
    
    //---------------------------------------------
    //get RFID as int
    //---------------------------------------------
    uint64_t getCardIdAsInt(uint8_t uid[],uint8_t uidLength){
      
      if (uidLength == 4) {
        // We probably have a Mifare Classic card ... 
        uint32_t cardid = uid[0];
        cardid <<= 8;
        cardid |= uid[1];
        cardid <<= 8;
        cardid |= uid[2];  
        cardid <<= 8;
        cardid |= uid[3]; 
        if(debug) {
          Serial.print("Seems to be a Mifare Classic card #");
          Serial.println(cardid);
        }
        return cardid;
      }
      
      else if (uidLength == 7)
      {
        // We probably have a Mifare Ultralight card ... 
        uint64_t cardid = 0;
        memcpy(&cardid, uid, sizeof(uid)); 
        
        if(debug) {  
          Serial.println("Seems to be a Mifare Ultralight card #");
          // Print function does not support 64 bit
        }
        if(debug) {
          for(uint8_t i = 0; i < uidLength; i++) {
            Serial.print(" byte ");Serial.print(i);Serial.print(" = ");
            Serial.print(uid[i],HEX);
            Serial.println(" ");
          }  
        }
        return cardid;
      }  
    }
    
    //-------------------------------------------------------------------------------------------------------
    // EEPROM Functions
    //-------------------------------------------------------------------------------------------------------
    
    //---------------------------------------------------------------
    // erase EEPROM
    //---------------------------------------------------------------
    void initializeEeprom() { 
      Serial.println("------------------------------------------------------");     
      Serial.println("Initializing EEPROM by erasing all RFIDs              ");
      Serial.println("Setting values of EEPROM addresses to 0               "); 
      Serial.println("EEPROM max memory size:                               ");
      Serial.println(EEPROMSize);  
      Serial.println("------------------------------------------------------");    
      
      byte zero  = 0;
      
      for(uint32_t adr = memBase; adr <= EEPROMSize; adr++) {
        gw.saveState(adr, zero);
      }
    }
    
    //---------------------------------------------------------------
    // printEeprom()
    // Print the EEPROM to serial output
    // for debugging
    //---------------------------------------------------------------
    
    void printEeprom(){
      uint32_t ads = memBase;
      while(ads <= EEPROMSize) {   
        byte output = gw.loadState(ads);
        if((ads % 10) == 0  ) Serial.println(" "); 
        Serial.print(ads);Serial.print(" => ");Serial.print(output,HEX); Serial.print("   "); 
        ads++;
      }
      Serial.println(" ");
    }
    
    //---------------------------------------------------------------
    // findRfidInEeprom(uidLength, uid)
    // looks for matching RFID
    // returns the address of the first byte of RFID (length indication) if found
    // returns -1 if NOT found
    // returns -2 if error
    //---------------------------------------------------------------
    
    int32_t findRfidInEeprom(uint8_t uidLength, uint8_t uid[]) {
      uint32_t key = memBase;
      byte val = gw.loadState(key);
      boolean match = false; 
      
      if(debug) Serial.print(" key ");Serial.println(key);
      if(debug) Serial.print(" val ");Serial.println(val);
      
      if(debug) Serial.println(" Finding in EEPROM ...  ");
      
      if(val == 0 && key == 0) {
        if(debug) Serial.println("EEPROM is empty ");
        return -1;
      }
      else {
        if(debug) Serial.println("in else ");
        while(val != 0)
        {
          if(debug) Serial.print(" key ");Serial.println(key);
          if(debug) Serial.print(" val ");Serial.println(val);
          if(key >= EEPROMSize) 
          {
            if(debug) Serial.println("ERROR: EEPROM STORAGE MESSED UP! Return -2");//this should not happen! If so initialize EEPROM
            return -2; 
          }
          if(val == uidLength) {
            // check if uid match the uid in EEPROM		
            uint32_t uidAddress = key + 1;
            match = true;     
            //compare uid bytes  
            for(byte i = 0; i < uidLength; i++) {
              byte uidVal = gw.loadState(( uidAddress + i));
              //the first byte of uidVal is the next address
              if(uidVal != uid[i]) {
                //got to next key
                match = false;
    	    // in case no break => all bytes same
                break;
              }
            }
          
            if(match) {
              if(debug) {Serial.println("RFID uid matching in Address = "); Serial.println(key);}
              return key;
            }
          }
          
          key = key + val + 1; 
          val = gw.loadState(key);
        }
      }  
      if(debug) { Serial.println("No RFID match in EEPROM, returning -1"); }
      return -1;
    }
    
    //---------------------------------------------------------------
    // deleteRfidfromEeprom(address, uidLength)
    // delete the RFID from EEPROM
    // sets the UID values to 0
    // in the EEPROM structure there will be a "hole" with zeroes
    // we are not shifting the addresses to avoid unnecessary writes
    // to the EEPROM. The 'hole' will be filled with next RFID 
    // storage that has the same uidLength
    //
    //
    //  BUG if rfid was last rfid in eeprom, length is not set to 0 => not needed because by formatting eeprom all is set to 0
    //---------------------------------------------------------------
    void deleteRfidfromEeprom(uint32_t address, uint8_t uidLength) {
      byte zero = 0; 
      if(debug) Serial.println("Erasing RFID");
      for(uint8_t m = 1; m <= uidLength; m++) {
        uint32_t adr = address + m;
        if(debug) {
          Serial.print("Address: ");
          Serial.print(adr);
          Serial.println(" ");
        }
        gw.saveState(adr, zero);
      }
      if(debug) { printEeprom(); }
    }
    
    //---------------------------------------------------------------
    // getEndOfRfidsChainInEeprom(uidLength)
    // returns the address of the end of the Rfids chain stored in the EEPROM
    // returns -1 if no space left
    // returns -2 if unexpected error
    //---------------------------------------------------------------
    int32_t getEndOfRfidsChainInEeprom(uint8_t uidLength) {
      uint32_t key = memBase;
      byte val = gw.loadState(key);
      
      if(val == 0 && key == 0) {
        if(debug) Serial.println("EEPROM is empty ");
        return key;
      }
      else {
        // if length byte indicator is 0 it means it is the end of the RFIDs stored, last RFID stored
        while(val != 0) {
          //this should not happen! If so initialize EEPROM
          if(key > EEPROMSize) {
            Serial.println("ERROR: EEPROM STORAGE MESSED UP! EXITING STORAGE READ");
            return -2;
          }
          key = key + val +1; 
          val = gw.loadState(key);
        }
        if((key + uidLength) > EEPROMSize) {
          Serial.println("Not enough space left in EEPROM to store RFID");//the RFID to be appended at the end of the storage chain exeeds the EEPROM length
          return -1;
        }
        else return key; 
      }  
    }
    
    
    //---------------------------------------------------------------
    // getFreeEepromStorageFragment(uint8_t uidLength)
    // return the address where to store the RFID 
    // with the rfidLength specified.
    // Instead of just appending the RFID to the end of 
    // the storage we look for an erased RFID space and 
    // fill this
    // return address
    // return -2 if error
    // return -1 if no free storage address found
    //---------------------------------------------------------------
    int32_t getFreeEepromStorageFragment(uint8_t uidLength) {
      uint32_t key = memBase;
      byte val = gw.loadState(key); //holds the uidLength stored in EEPROM
      boolean free = false; 
    
      if(val == 0 && key == 0) {
        // EEPROM empty, use the address at key = memBase
        return key;
      }
      else {
        //loop till the end of storage chain indicated by a zero value in the key position
        while(val != 0) {
          //this should not happen! If so initialize EEPROM
          if(key > EEPROMSize) {
            Serial.println("ERROR: EEPROM STORAGE MESSED UP! EXITING STORAGE READ");
            return -2; 
          }
          // check if uidLength  match the uidLength in EEPROM
          if(val == uidLength) {     
            uint32_t uidAddress = key +1;
            free = true;
            //check if uid bytes are all zero => free storage fragment
            for(uint8_t i = 0; i < uidLength; i++) {
              byte uidVal = gw.loadState(( uidAddress + i));         
              if(uidVal != 0) {
                //got to next key
                free = false;
                break;
              }
            }
            // in case no break => all bytes have zero value => free fragment
            if(free) {
              return key;
            }
          }    
          key = key + val + 1; 
          val = gw.loadState(key);
        } 
        return -1;    
      }
    }
    
    //---------------------------------------------------------------
    // getEepromStorageAddress(uint8_t uidLength)
    // combination of getFreeEepromStorageFragment
    // and getEndOfRfidsChainInEeprom
    // return address
    // return -1 if no free storage address found
    // return -2 if error
    //---------------------------------------------------------------
    int32_t getEepromStorageAddress(uint8_t uidLength) {
      int32_t fragment = getFreeEepromStorageFragment(uidLength);
      if(debug) {
        Serial.print("getFreeEepromStorageFragment returned ");Serial.print(fragment);
        Serial.println(" ");
      }  
      // free fragment found
      if(fragment >= 0) {
        return fragment;
      }
      // error returned
      else if (fragment == -2) {
        return fragment;
      }
      // no free fragment available
      // check if space available at end of rfid storage chain
      else if (fragment == -1) {
        int32_t append = getEndOfRfidsChainInEeprom(uidLength);
        if(debug) {
          Serial.print("getEndOfRfidsChainInEeprom returned ");Serial.print(append);
          Serial.println(" ");
        }     
          return append;
        }
      // should never occur, return error
      else {
        return -2;
      }  
    }
    
    //---------------------------------------------------------------
    // writeRfidToEeprom(addrees,uidlength,uid)
    // write RFID to EEPROM
    //---------------------------------------------------------------
    void writeRfidToEeprom(uint32_t StoragePositionAddress, uint8_t uidLength, uint8_t uid[]) {
      // Writing into first free address the length of the RFID uid
      gw.saveState(StoragePositionAddress, uidLength); 
      // Writing into the following addresses the RFID uid values (byte per byte)
      uint32_t uidBytePosition = StoragePositionAddress +1; //next position after addressByte which contains the uidLength
      for(uint8_t r=0; r < uidLength; r++) {
        gw.saveState(uidBytePosition, uid[r]);   
        uidBytePosition++;
      } 
      if(debug) { printEeprom(); }
    }
    
    //---------------------------------------------------------------
    // setLockState(state, send)
    // unlocks the door
    //---------------------------------------------------------------
    void setLockState(bool state, bool send){
      if (state) 
         if(debug) Serial.println("open lock");
      else
         if(debug) Serial.println("close lock");
      if (send)
    //    gw.send(lockMsg.set(state));
      digitalWrite(lockPin, state);
    }
    
    //---------------------------------------------------------------
    // incomingMessage(MyMessage)
    // handling incoming message
    //---------------------------------------------------------------
    void incomingMessage(const MyMessage &message) {
      // We only expect one type of message from controller. But we better check anyway.
      if (message.type==V_LOCK_STATUS) {
    
        // Change relay state
         setLockState(message.getBool(), false); 
      
         if(debug) {// Write some debug info
           Serial.print("Incoming lock status:");
           Serial.println(message.getBool());
         }
       } 
    }
    
    
    /***********************************************************************************************************************************************/
    // SETUP
    /***********************************************************************************************************************************************/
    void setup(void) {
     
      pinMode(led_blue,  OUTPUT);
      pinMode(led_red,   OUTPUT);
      pinMode(led_green, OUTPUT); 
      pinMode(lockPin,   OUTPUT);
      
      Serial.begin(115200);
      if(debug) Serial.println("Hello!");
    
      nfc.begin();   
      if(debug) Serial.println("nfc.begin OK");
      uint32_t versiondata = nfc.getFirmwareVersion();
      if (! versiondata) {
        led(1);
        if(debug) Serial.print("Didn't find PN53x board");
        while (1);
      }
      if(debug) {
        Serial.print("Found chip PN5"); Serial.println((versiondata>>24) & 0xFF, HEX); 
        Serial.print("Firmware ver. "); Serial.print((versiondata>>16) & 0xFF, DEC); 
        Serial.print('.'); Serial.println((versiondata>>8) & 0xFF, DEC);
      }
      // Set the max number of retry attempts to read from a card
      // This prevents us from waiting forever for a card, which is
      // the default behaviour of the PN532.
      nfc.setPassiveActivationRetries(0x3);
      
      //*******************************************************
      // Befor you run this sketch the first time
      // uncoment the following initializeEeprom(); 
      // to clear the EEPROM neccessary to be shure
      // that all EEPROM values used for the RFID 
      // storage are initialized with 0.
      // Connect to the serial to check if all values are 0,
      // then comment the functions again and start using
      // the Rfid access control system
      //********************************************************
      //initializeEeprom();
      if(debug) { printEeprom(); }
      
      // configure board to read RFID tags
      nfc.SAMConfig();
      
      // Init mysensors library
    //  gw.begin(incomingMessage);
      
    //  gw.sendSketchInfo("RFID Makkai Gate Lock", "1.0");
    //  gw.present(CHILD_ID, S_LOCK);
      
      lockStatus = true;               // this is the default mode
      setLockState( lockStatus, true); // Now set the state and send it to controller
      
      led(3);
      if(debug) Serial.println("Waiting for an ISO14443A Card ...");
      if(debug) Serial.println("Setup finished.");
    
    }
    
    
    
    
    /***********************************************************************************************************************************************/
    //MAIN
    /***********************************************************************************************************************************************/
    void loop(void) {
    
    //  gw.process(); // Process incomming messages
      
      uint8_t success;
      uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID, 7 bit max
      uint8_t uidLength;                        // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
      uint64_t cardid;                          // UID as int
        
      // Wait for an ISO14443A type cards (Mifare, etc.).  When one is found
      // 'uid' will be populated with the UID, and uidLength will indicate
      // if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
      success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
      
      
       
      // MASTER MODE?  
      if(master_mode == 1) {
        //stay in master mode for max 30 seconds
        master_mode_counter = master_mode_counter + 1;
        if(master_mode_counter >= 60) {//reset master mode after 30 sec no RFID was inserted
          master_mode= 0; 
          master_mode_counter = 0;
        }
        if(debug) {Serial.print("MASTER MODE "); Serial.println(master_mode_counter);}
        led(6);
        delay(200);   
      }
    
      //got rfid?
      if (success) {
          // Display some basic information about the card
          if(debug) {
            Serial.println("Found an ISO14443A card");
            Serial.print("  UID Length: ");Serial.print(uidLength, DEC);Serial.println(" bytes");
            Serial.print("  UID Value: ");nfc.PrintHex(uid, uidLength);
          }
    
          cardid = getCardIdAsInt(uid,uidLength);
          
          //is MASTER
          if (cardid == uid_master) { 
            master_mode = 1;
            master_mode_counter = 0;
            led(6);
            if(debug) Serial.println("MASTER detected, going into MASTER MODE  ");
          } 
          // is not MASTER
          else {       
            int32_t findUid = findRfidInEeprom( uidLength, uid);
            
            // is MASTER MODE, include or exclude RFID from storage
            if(master_mode == 1) {
              // card rfid already exists so exlude it from storage    
              if( findUid != -1) {
                if(debug) {Serial.println("removing card from eeprom"); Serial.println(" ");}
                deleteRfidfromEeprom(findUid, uidLength);
                led(8);
                delay(messageTime);               
              }
              // card rfid not found in storage so include it
              else if (findUid == -1) {
                // check if space to store rfid available
                int32_t storageAddress = getEepromStorageAddress(uidLength);
              
                // storage available
                if(storageAddress >= 0) {
                  if(debug) {Serial.print("storing card in position = ");Serial.print(storageAddress);Serial.println(" ");}
                  // storing card
                  writeRfidToEeprom( storageAddress, uidLength, uid);  
                  led(7);
                  delay(messageTime);              
                }         
                else { // no storage space available or error
                  if(debug) Serial.println("memory full or error");
                  led(2);
                  delay(messageTime);      
                }
              }
              master_mode = 0;
            }
            // no MASTER MODE, authorise or deny door access
            else {
              // card authorised
              if( findUid != -1) {
               
                // open door and green light on for a short period
               if(debug) Serial.println("Card authorised, open door");
               setLockState(!lockStatus, true);
               led(4); 
               delay(gateTime);
               setLockState(lockStatus, true);      
               if(debug) Serial.println("Close door");
          
              }
              else {
                // deny access and red light on
                if(debug) Serial.println("Card not authorised, access denied");
                led(5);
                delay(messageTime);            
              }          
            }
          }
        }     
    led(3);    
    //did not get RFID, looping till RFID inserted   
    
    }
    
    


  • This code is working now, but does not make any connection to the Gateway. Moreover, if I uncomment the neccessary lines, it starts to provide strange behaviour on the serial port.



  • So more info:

    1. I run 1.0.5 Arduino on WIN7
    2. HW:
    • Arduino Mini Pro 5V/16MHz powering from PC via USB and with a good quality step-down regulator (12V->5V) at the gate
    • Mifare RFID reader from ELECHOUSE using SDA -> A4 & SCL -> A5 connections
    • Radio: NRF24L01+ with adapter on normal mysensor radio connections
    • 2 Relay Module on D4 & D5
    • Common Anode RGB LED with 220 Ohm resistors on D6, D7 and D8
    1. I have a MiCasaVerde Vera3 with UI7
    2. MySensor Gateway: Arduino UNO + high gain antenna radio modul + ethernet shield
    3. My MySensor network works fine, I have humidity and temp sensor separately and a switch. actuator. All sensors and Gateway uses v1.41 sketches.

    This project would be an extra control for the electronic gate opener what I have already installed on the garden gate. First I downloaded the RFID sketch from MySensors.org, tried and it worked fine. Without any problem I could immediately include into my network after a short setup, and I could use the card to open and to close.

    Next I had to modify the code a bit to close back automatically after a given time (200 ms), because the gate controlling system require only a shor momentary switch, an impulse. It took 10 minutes, worked, I was happy.

    Than I realised that I can not manage the cards so easy, and found a skech on the net (see reference in the beginning of the attached code) for storing the card data in the eeprom. Fortunately this Arduino has 1 KB, that is far enough for card data AND MySensor's data.

    First I edited and modified a bit of this, the EEPROM user RFID sketch, what was really worked perfectly without using the MySensors network. The problems started when I tried to merege the two sketches. First I had to cut off eeprom.h; and all related functions had to be changed to the MySensors functions for using EEPROM.

    I could follow up everything in the SERIAL PORT. Both sketches separately were running without error. They open and closed, read the cards how I wanted. After integrating the two sketches I could not use it anymore. So I commented out all MySensor related row, then I tried to row-by-row find solution for problem, but no result.

    The above code now working for the NFC part with small eeprom related problem, but does not connect to the MySensors Gateway. Serial monitor showed strange behaviour: It should start normaly with "Hello", but if I uncomment gw lines, it start to put out a lot of HHHHHHHH with strange periodicity.

    I also tried to switch the DEBUGGER on in the MyConfig.h but it is not clear for me what to do, because at the moment I have #define DEBUG there without commenting, but there is no more info on the serial.

    I just wonder If I can manage a real nice system, where

    • I can include and delete cards remotely (using VERA3),
    • I can control the gate remotely, and
    • the system remains work if the Gateway or Vera is down.

  • Admin

    A wild guess is that you're running out of stack-space == Hell breaks lose.

    See if you can optimize code and reduce the allocations where possible.

    You can start by moving all static strings to PROGSPACE.



  • @hek
    That hint was working. After I reduced the code cutting out memory eaters, the code now works !!!

    This was the first time when I run into such problem. However I wanted to expand the code more putting additional functionalities.

    I will publish the final version here when it will be ready.



  • hello all ,

    @mmuukkii your code really looks fantastic , but you said that bug , had you finished? I am not able to fix it. thx


Log in to reply
 

Suggested Topics

  • 3
  • 15
  • 4
  • 2
  • 3
  • 2

25
Online

11.2k
Users

11.1k
Topics

112.5k
Posts