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

[mmuukkii]

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)::

[mmuukkii]

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

[hek]

enclose between 4 back-ticks ````

[mmuukkii]

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   

}

[mmuukkii]

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.

[mmuukkii]

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.

[hek]

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.

[mmuukkii]

@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.

[tetenfer]

hello all ,

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