add free memory command

add read and write nfc commands fix function sending
add support for mfrc proxyies
2022-03-25 13:41:02 +01:00 · 2022-03-21 21:22:18 +01:00 · 2022-03-15 22:41:06 +01:00 · 2022-03-15 22:40:37 +01:00 · 2022-03-15 22:40:07 +01:00 · 2022-03-15 22:39:13 +01:00
27 changed files with 1027 additions and 225 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -17,7 +17,18 @@ set(PORT_SPEED "57600" CACHE STRING "Serial Port Speed")
 set(PROGRAMMER "stk500v1" CACHE STRING "Programmer Type")
 set(COMPILE_FLAGS "" CACHE STRING "Additional Compiler Flags")

-set(SRC_FILES  main.cpp serial.cpp  train.cpp item.cpp turnout.cpp signal.cpp softspim.cpp nfcbord.cpp mfrc522.cpp)
+set(SRC_FILES
+	main.cpp
+	serial.cpp
+	train.cpp
+	item.cpp
+	turnout.cpp
+	signal.cpp
+	softspim.cpp
+	nfcbord.cpp
+	mfrc522.cpp
+	placementnew.cpp
+	mfrcproxy.cpp)

 # Compiler suite specification
 set(CMAKE_C_COMPILER /usr/bin/avr-gcc)
--- a/defines.h
+++ b/defines.h
@ -0,0 +1,10 @@
+#pragma once
+
+static constexpr int COMMAND_BUFFER_SIZE = 64;
+static constexpr int SNPRINTF_BUFFER_SIZE = 128;
+static constexpr int EPPROM_SIZE = 1024;
+
+static constexpr int EEPROM_RESERVE = 32;
+static constexpr int BLOCK = 4;
+
+static constexpr int NFC_PORTS = 8;
--- a/inputshiftreg.h
+++ b/inputshiftreg.h
@ -22,6 +22,12 @@ public:
 		const unsigned char clk, const unsigned char serOut, const unsigned char parallelLoad):
 		_port(portReg), _pin(pinReg), _pinSerOut(serOut), _pinClk(clk), _pinParallelLoad(parallelLoad)
 	{
+		if constexpr(invert)
+			*_port &= ~(1<<_pinParallelLoad);
+		else
+			*_port |= (1<<_pinParallelLoad);
+		
+		read();
 	}
 	bool getBit(unsigned char bit)
 	{
@ -34,13 +40,11 @@ public:
 	{
 		if constexpr(invert)
 		{
-			*_port &= ~(1<<_pinParallelLoad);
 			*_port |= (1<<_pinParallelLoad);
 			*_port &= ~(1<<_pinParallelLoad);
-
+			
 			for(unsigned char i = 0; i < BITS; ++i)
 			{
-				*_port &= ~(1 << _pinClk);
 				bool value = *_pin & (1 << _pinSerOut);
 				if constexpr(invertInput)
 					value = !value;
@ -48,14 +52,13 @@ public:
 					data[i/8] |= (1<<(i%8));
 				else
 					data[i/8] &= ~(1<<(i%8));
+				*_port &= ~(1 << _pinClk);
 				*_port |= (1 << _pinClk);
 			}
 		}
 		else
 		{
-			*_port |= (1<<_pinParallelLoad);
 			*_port &= ~(1<<_pinParallelLoad);
-			*_port |= (1<<_pinParallelLoad);

 			for(unsigned char i = 0; i < BITS; ++i)
 			{
@ -69,6 +72,7 @@ public:
 					data[i/8] &= ~(1<<(i%8));
 				*_port &= ~(1 << _pinClk);
 			}
+			*_port |= (1<<_pinParallelLoad);
 		}
 		return data;
 	}
--- a/item.cpp
+++ b/item.cpp
@ -74,7 +74,7 @@ void Item::sendAddress(uint8_t address)
 }


-void Item::sendRawAddr(const uint8_t address, const uint16_t data)
+void Item::sendRawAddr(const uint8_t address, const uint16_t data, bool single)
 {
    for(uint8_t j = 0; j < SEND_COUNT; j++)
    {
@ -83,11 +83,13 @@ void Item::sendRawAddr(const uint8_t address, const uint16_t data)
        {
            sendBit(data & (1 << i));
        }
+        if(single || SEND_COUNT == 1)
+            return;
        _delay_ms(1);
    }
 }

-void Item::sendRaw(const uint16_t data)
+void Item::sendRaw(const uint16_t data, bool single)
 {
-    sendRawAddr(_address, data);
+    sendRawAddr(_address, data, single);
 }
--- a/item.h
+++ b/item.h
@ -40,8 +40,8 @@ public:

 	Item(const uint8_t address);

-	void sendRaw(const uint16_t data);
-	static void sendRawAddr(const uint8_t address, const uint16_t data);
+	void sendRaw(const uint16_t data, bool single = false);
+	static void sendRawAddr(const uint8_t address, const uint16_t data, bool single = false);
 	
 	void setAddress(const uint8_t address);
 	uint8_t getAddress();
--- a/main.cpp
+++ b/main.cpp
@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
+#include <avr/interrupt.h>
 #include "serial.h"
 #include "writepin.h"
 #include "train.h"
@ -22,7 +23,6 @@ char buffer[SNPRINTF_BUFFER_SIZE];
 SVector<Train, 32> trains;
 SVector<Turnout, 32> turnouts;
 SVector<Signal, 32> signals;
-NfcBoard nfcBoard;

 bool autoff = true;
 bool powerIsOn = true;
@ -127,6 +127,13 @@ void restore_state()
 	}
 }

+int freeRAM()
+{
+	extern int __heap_start, *__brkval;
+	int v;
+	return (int) &v - (__brkval == 0 ? (int) &__heap_start: (int) __brkval);
+}
+
 inline static void printHelp(Serial* serial)
 {
 	serial->write_p(PSTR("Available Commands: \n\
@ -145,13 +152,19 @@ inline static void printHelp(Serial* serial)
 				turnout [nn] delete                         :  Delete Turnout\n\
 				signal add [address] [subaddress] [type]    :  Add a signal\n\
 				signal list                                 :  List signal\n\
-				signal [nn] set [status]                    :  Set signal direction\n\
-				signal [nn] delete                          :  Delete signal\n\
+				signal [nn] set [status]                    :  Set signal status\n\
+				nfc probe                                   :  Detect newly added nfc reader\n\
+				nfc list                                    :  List nfc readers\n\
+				nfc debug                                   :  Enable nfc debug output\n\
+				nfc quiet                                   :  Disable nfc debug output\n\
+				nfc enable                                  :  Enable tag detection\n\
+				nfc disable                                 :  Disable tag detection\n\
 				stop                                        :  stop all trains\n\
 				power off                                   :  power off the rail\n\
 				power on                                    :  power on the rail\n\
 				power auto                                  :  power off the rail when no trains are moveing\n\
 				dump                                        :  prints epprom contence\n\
+				free                                        :  show amount of free ram\n\
 				erase                                       :  Erase epprom.\n"));
 }

@ -253,7 +266,7 @@ void serialDispatch(Serial* serial)
 			{
 				token = strtok(NULL, " ");
 				if(token != NULL)
-					ret = nfcBoard.dispatch(token, serial);
+					ret = nfcBoard.dispatch(token);
 			}
 			else if(strncmp(token, "erase", 4) == 0)
 			{
@ -294,6 +307,13 @@ void serialDispatch(Serial* serial)
 				printHelp(serial);
 				ret = 0;
 			}
+			else if(strcmp(token, "free") == 0)
+            {
+                serial->write_p(PSTR("Free Ram: "));
+				serial->write(freeRAM());
+				serial->write_p(PSTR(" Bytes.\n"));
+				ret = 0;
+            }
 			else
 			{
 				serial->putChar('\"');
@ -347,26 +367,35 @@ int main()

 	sei();

-	Serial serial;
+	Serial* serial = Serial::getInstance();

-	serial.write_p(PSTR("TrainController v0.5 starting\n"));
+	serial->write_p(PSTR("TrainController v0.5 starting\n"));
+	
+	uint8_t repeatCount = 0;

 	while(true)
 	{        
 		if(resendEvent && (trains.count() || turnouts.count() || signals.count())) 
 		{
-			timer0InterruptEnable(false);
 			if(itemToResend < trains.count())
-				trains[itemToResend].sendData();
+				trains[itemToResend].sendData(true);
 			else if(itemToResend < trains.count() + turnouts.count())
-				turnouts[itemToResend-trains.count()].sendData();
+				turnouts[itemToResend-trains.count()].sendData(true);
 			else if(itemToResend < trains.count() + turnouts.count()+signals.count())
-				signals[itemToResend-trains.count()-turnouts.count()].sendData();
-			itemToResend++;
-			if(trains.count()+turnouts.count()+signals.count() <= itemToResend)
-				itemToResend = 0;
+				signals[itemToResend-trains.count()-turnouts.count()].sendData(true);
 			resendEvent = false;
-			timer0InterruptEnable(true);
+			if(repeatCount == 0)
+			{
+				TCNT0 = 190;
+				repeatCount = 1;
+			}
+			else
+			{
+				itemToResend++;
+				if(trains.count()+turnouts.count()+signals.count() <= itemToResend)
+					itemToResend = 0;
+				repeatCount = 0;
+			}
 		}
 		
 		if(autoff) 
@ -381,7 +410,9 @@ int main()
 				Train::setOutput(Train::OFF);
 			}
 		}
-		serialDispatch(&serial);
+
+		serialDispatch(serial);
+		nfcBoard.poll(serial);
 	}
 	return 0;
 }
--- a/mfrc522.cpp
+++ b/mfrc522.cpp
@ -1,6 +1,7 @@
 #include "mfrc522.h"

-
+Serial *Mfrc522::serial = nullptr;
+uint8_t Mfrc522::reponseBuffer[Mfrc522::reponseBufferLen];

 uint8_t Mfrc522::read(uint8_t addr)
 {
@ -58,25 +59,34 @@ void Mfrc522::updateBit(uint8_t addr, uint8_t bit, bool value)
 void (*_tagEnterdCb)(Mfrc522*, void*);
 void* _userData;

-Mfrc522::Mfrc522(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin,
-	void (*tagEnterdCb)(Mfrc522*, void*), void* userData):
-	_csReg(csReg), _spi(spi), _csPin(csPin), _tagEnterdCb(tagEnterdCb), _userData(userData)
+Mfrc522::Mfrc522(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin):
+	_csReg(csReg), _spi(spi), _csPin(csPin)
+{
+	reset();
+}
+
+void Mfrc522::reset()
 {
 	write(CommandReg, SOFTRESET);
 	_delay_ms(100);

+	mode = MODE_IDLE;
+	irqDetect = false;
+
 	write(TModeReg, 0x80);
-	write(TPrescalerReg, 0xA9);
-	write(TReloadRegH, 0x03);
-	write(TReloadRegL, 0xE8);
+	write(TPrescalerReg, PRESCALLER);
+	write(TReloadRegH, POLL_TIMER >> 8);
+	write(TReloadRegL, POLL_TIMER & 0x0F);
 	write(ModWidthReg, 0x26);

-	write(RFCfgReg, 0b111 << 4); //set gain to 48dB
+	write(RFCfgReg, 0b01110100); //set gain to 48dB
 	
 	write(TxAutoReg, 0x40); // Default 0x00. Force a 100 % ASK modulation independent of the ModGsPReg register setting
+	updateBit(RxModeReg, 3, true);
 	write(ModeReg, 0x3D); // Default 0x3F. Set the preset value for the CRC coprocessor for the CalcCRC command to 0x6363 (ISO 14443-3 part 6.2.4)
-	//write(DivIEnReg, 0b10010000); // enable MfinActIrq as push-pull
-	//write(ComIEnReg, 0b00100000); // enable Rx irq
+	write(ComIrqReg, 0b01111111);
+	write(ComIEnReg, 0); // invert irq pin (high is active)
+	write(DivIEnReg, 1 << 7); // enable MfinActIrq as push-pull

 	setRf(true);
 }
@ -98,32 +108,17 @@ uint8_t Mfrc522::calculateCrc(uint8_t *data, uint8_t length, uint16_t *result)
 		return ERR;
 	write(CommandReg, IDLE);
 	
-	if(serial)
-	{
-		serial->write_p(PSTR("Calculated CRC "));
-		serial->write((int)read(CRCResultRegL));
-		serial->putChar(' ');
-		serial->write((int)read(CRCResultRegH));
-		serial->putChar('\n');
-	}
-	
 	*result = read(CRCResultRegL);
 	*result |= read(CRCResultRegH) << 8;
 	return 0;
 }

-uint8_t Mfrc522::commuicateWithTag(uint8_t command, uint8_t waitIrq,
-	uint8_t *sendData, uint8_t sendLen,
-	uint8_t *recvData, uint8_t *recvLen,
-	uint8_t validBits, uint8_t rxAlign,
-	uint8_t *rxValidBits)
+void Mfrc522::setupTransceive(uint8_t *sendData, uint8_t sendLen, uint8_t validBits, uint8_t rxAlign)
 {
-	write(CommandReg, IDLE);
-	write(ComIrqReg, 0b01111111); // clear irqs
 	write(FIFOLevelReg, 1 << 7);			// Flush fifo Buffer;
 	write(FIFODataReg, sendData, sendLen);	 // Fill fifo
 	write(BitFramingReg, (rxAlign << 4) + validBits);
-	write(CommandReg, command);				// Execute the command
+	write(CommandReg, TRANSCEIVE);	// Execute the command
 	
 	if(serial)
 	{
@ -140,14 +135,82 @@ uint8_t Mfrc522::commuicateWithTag(uint8_t command, uint8_t waitIrq,
 		serial->write((int)read(BitFramingReg));
 		serial->putChar('\n');
 	}
+
+	updateBit(BitFramingReg, 7, true);
+}
+
+uint8_t Mfrc522::transceiveAsync(void (*transceiveCb)(uint8_t, Mfrc522*, uint8_t*, uint8_t, void*), void* userData,
+								 uint8_t *sendData, uint8_t sendLen, uint8_t validBits, uint8_t rxAlign)
+{
+	if(mode != MODE_IDLE)
+		return BUSY;
 	
+	mode = MODE_TRANSCEIVE;
 	
-	if (command == TRANSCEIVE)
-		updateBit(BitFramingReg, 7, true);
+	_transceiveCb = transceiveCb;
+	_transceiveUserData = userData;
+	
+	write(CommandReg, IDLE);
+
+	write(ComIrqReg, 0b01111111); // clear irqs
+	write(ComIEnReg, (1 << 5) | (1 << 0));
+
+	setupTransceive(sendData, sendLen, validBits, rxAlign);
+
+	return 0;
+}
+
+void Mfrc522::transceiveAsyncFinish(uint8_t irq)
+{
+	write(ComIEnReg, 0); // disable irqs
+
+	if(irq & 1)
+	{
+		mode = MODE_IDLE;
+		_transceiveCb(TIMEOUT, this, nullptr, 0, _transceiveUserData);
+		return;
+	}
+
+	if(!_transceiveCb)
+	{
+		mode = MODE_IDLE;
+		updateBit(FIFOLevelReg, 7, true);
+		return;
+	}
+
+	uint8_t errorRegValue = read(ErrorReg);
+	if (errorRegValue & 0b00010011) // BufferOvfl ParityErr ProtocolErr
+	{
+		mode = MODE_IDLE;
+		_transceiveCb(ERR, this, nullptr, 0, _transceiveUserData);
+		return;
+	}
+
+	uint8_t fifoBites = read(FIFOLevelReg);
+
+	if(fifoBites > reponseBufferLen)
+		_transceiveCb(LEN, this, nullptr, 0, _transceiveUserData);
+	read(FIFODataReg, reponseBuffer, fifoBites);
+	mode = MODE_IDLE;
+	if(errorRegValue & 0x08)
+		_transceiveCb(COLLISION, this, reponseBuffer, fifoBites, _transceiveUserData);
+	else
+		_transceiveCb(0, this, reponseBuffer, fifoBites, _transceiveUserData);
+	
+}
+
+uint8_t Mfrc522::transceive(uint8_t *sendData, uint8_t sendLen,
+	uint8_t *recvData, uint8_t *recvLen,
+	uint8_t validBits, uint8_t rxAlign,
+	uint8_t *rxValidBits)
+{
+	write(CommandReg, IDLE);
+	write(ComIrqReg, 0b01111111); // clear irqs
+	setupTransceive(sendData, sendLen, validBits, rxAlign);
 	
 	uint16_t i = 2000;
 	uint8_t irq = read(ComIrqReg);
-	while(irq & waitIrq)
+	while(!(irq & 0x30)) // RxIRq and IdleIRq
 	{
 		irq = read(ComIrqReg);
 		if(irq & 0x01 || --i == 0)
@ -200,13 +263,6 @@ uint8_t Mfrc522::commuicateWithTag(uint8_t command, uint8_t waitIrq,
 	return 0;
 }

-uint8_t Mfrc522::transceive(uint8_t *sendData, uint8_t sendLen, uint8_t *recvData, uint8_t *recvLen,
-					uint8_t validBits, uint8_t rxAlign, uint8_t *rxValidBits)
-{
-	uint8_t waitIRq = 0x30; // RxIRq and IdleIRq
-	return commuicateWithTag(TRANSCEIVE, waitIRq, sendData, sendLen, recvData,
-								recvLen, validBits, rxAlign, rxValidBits);
-}

 uint8_t Mfrc522::wakeupTag(uint8_t* bufferATQA,	uint8_t *bufferLen)
 {
@ -234,14 +290,13 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 	uint8_t index;
 	uint8_t uidIndex;					// The first index in uid->uidByte[] that is used in the current Cascade Level.
 	int8_t currentLevelKnownBits;		// The number of known UID bits in the current Cascade Level.
-	uint8_t buffer[9];					// The SELECT/ANTICOLLISION commands uses a 7 uint8_t standard frame + 2 uint8_ts CRC_A
 	uint8_t bufferUsed;				// The number of uint8_ts used in the buffer, ie the number of uint8_ts to transfer to the FIFO
 	uint8_t txLastBits;				// Used in BitFramingReg. The number of valid bits in the last transmitted uint8_t. 
-	uint8_t *responseBuffer;
+	uint8_t *responseBufferPtr;
 	uint8_t responseLength;
 	
 	if(serial)
-			serial->write_p(PSTR("Select\n"));
+		serial->write_p(PSTR("Select\n"));
 	
 	// Description of buffer structure:
 	//		Byte 0: SEL 				Indicates the Cascade Level: PICC_CMD_SEL_CL1, PICC_CMD_SEL_CL2 or PICC_CMD_SEL_CL3
@ -277,17 +332,17 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 		switch(cascadeLevel)
 		{
 			case 0:
-				buffer[0] = PICC_CMD_SEL_CL1;
+				reponseBuffer[0] = PICC_CMD_SEL_CL1;
 				uidIndex = 0;
 				break;
 			
 			case 1:
-				buffer[0] = PICC_CMD_SEL_CL2;
+				reponseBuffer[0] = PICC_CMD_SEL_CL2;
 				uidIndex = 3;
 				break;
 			
 			case 2:
-				buffer[0] = PICC_CMD_SEL_CL3;
+				reponseBuffer[0] = PICC_CMD_SEL_CL3;
 				uidIndex = 6;
 				break;
 			
@ -309,7 +364,7 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 			if (bytesToCopy > maxBytes)
 				bytesToCopy = maxBytes;
 			for (count = 0; count < bytesToCopy; count++)
-				buffer[index++] = uid->uidByte[uidIndex + count];
+				reponseBuffer[index++] = uid->uidByte[uidIndex + count];
 		}
 		
 		// Repeat anti collision loop until we can transmit all UID bits + BCC and receive a SAK - max 32 iterations.
@ -319,11 +374,11 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 			// Find out how many bits and bytes to send and receive.
 			if (currentLevelKnownBits >= 32) // All UID bits in this Cascade Level are known. This is a SELECT.
 			{ 
-				buffer[1] = 0x70; // NVB - Number of Valid Bits: Seven whole bytes
+				reponseBuffer[1] = 0x70; // NVB - Number of Valid Bits: Seven whole bytes
 				// Calculate BCC - Block Check Character
-				buffer[6] = buffer[2] ^ buffer[3] ^ buffer[4] ^ buffer[5];
+				reponseBuffer[6] = reponseBuffer[2] ^ reponseBuffer[3] ^ reponseBuffer[4] ^ reponseBuffer[5];
 				// Calculate CRC_A
-				result = calculateCrc(buffer, 7, reinterpret_cast<uint16_t*>(&buffer[7]));
+				result = calculateCrc(reponseBuffer, 7, reinterpret_cast<uint16_t*>(&reponseBuffer[7]));
 				if (result != 0)
 				{
 					if(serial)
@ -333,7 +388,7 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 				txLastBits		= 0; // 0 => All 8 bits are valid.
 				bufferUsed		= 9;
 				// Store response in the last 3 bytes of buffer (BCC and CRC_A - not needed after tx)
-				responseBuffer	= &buffer[6];
+				responseBufferPtr	= &reponseBuffer[6];
 				responseLength	= 3;
 			}
 			else // This is an ANTICOLLISION.
@ -341,31 +396,20 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 				txLastBits		= currentLevelKnownBits % 8;
 				count			= currentLevelKnownBits / 8;	// Number of whole bytes in the UID part.
 				index			= 2 + count;					// Number of whole bytes: SEL + NVB + UIDs
-				buffer[1]		= (index << 4) + txLastBits;	// NVB - Number of Valid Bits
+				reponseBuffer[1]		= (index << 4) + txLastBits;	// NVB - Number of Valid Bits
 				bufferUsed		= index + (txLastBits ? 1 : 0);
 				// Store response in the unused part of buffer
-				responseBuffer	= &buffer[index];
-				responseLength	= sizeof(buffer) - index;
+				responseBufferPtr	= &reponseBuffer[index];
+				responseLength	= sizeof(reponseBuffer) - index;
 			}

 			// Set bit adjustments
 			uint8_t rxAlign = txLastBits;
 			// RxAlign = BitFramingReg[6..4]. TxLastBits = BitFramingReg[2..0]
 			write(BitFramingReg, (rxAlign << 4) + txLastBits);
-			
-			if(serial)
-			{
-				serial->write_p(PSTR("entering transceive "));
-				serial->write((int)responseLength);
-				serial->putChar(' ');
-				serial->write((int)txLastBits);
-				serial->putChar(' ');
-				serial->write((int)currentLevelKnownBits);
-				serial->putChar('\n');
-			}

 			// Transmit the buffer and receive the response.
-			result = transceive(buffer, bufferUsed, responseBuffer, &responseLength, txLastBits, rxAlign, &txLastBits);			
+			result = transceive(reponseBuffer, bufferUsed, responseBufferPtr, &responseLength, txLastBits, rxAlign, &txLastBits);			
 			if (result == COLLISION) // More than one PICC in the field => collision.
 			{
 				result = read(CollReg); // CollReg[7..0] bits are: ValuesAfterColl reserved CollPosNotValid CollPos[4:0]
@ -381,8 +425,6 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 				}
 				if (collisionPos <= currentLevelKnownBits) // No progress - should not happen 
 				{ 
-					if(serial)
-						serial->write_p(PSTR("err No progress\n"));
 					return ERR;
 				}
 				// Choose the PICC with the bit set.
@ -390,7 +432,7 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 				count			= currentLevelKnownBits % 8; // The bit to modify
 				checkBit		= (currentLevelKnownBits - 1) % 8;
 				index			= 1 + (currentLevelKnownBits / 8) + (count ? 1 : 0); // First byte is index 0.
-				buffer[index]	|= (1 << checkBit);
+				reponseBuffer[index]	|= (1 << checkBit);
 			}
 			else if (result != 0)
 			{
@ -410,11 +452,11 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 		// We do not check the CBB - it was constructed by us above.
 		
 		// Copy the found UID bytes from buffer[] to uid->uidByte[]
-		index			= (buffer[2] == PICC_CMD_CT) ? 3 : 2; // source index in buffer[]
-		bytesToCopy		= (buffer[2] == PICC_CMD_CT) ? 3 : 4;
+		index			= (reponseBuffer[2] == PICC_CMD_CT) ? 3 : 2; // source index in buffer[]
+		bytesToCopy		= (reponseBuffer[2] == PICC_CMD_CT) ? 3 : 4;
 		for (count = 0; count < bytesToCopy; count++)
 		{
-			uid->uidByte[uidIndex + count] = buffer[index++];
+			uid->uidByte[uidIndex + count] = reponseBuffer[index++];
 		}
 		
 		// Check response SAK (Select Acknowledge)
@ -431,19 +473,19 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 			return ERR;
 		}
 		// Verify CRC_A - do our own calculation and store the control in buffer[2..3] - those bytes are not needed anymore.
-		result = calculateCrc(responseBuffer, 1, reinterpret_cast<uint16_t*>(&buffer[2]));
+		result = calculateCrc(responseBufferPtr, 1, reinterpret_cast<uint16_t*>(&reponseBuffer[2]));
 		if (result != 0)
 			return result;
-		if ((buffer[2] != responseBuffer[1]) || (buffer[3] != responseBuffer[2]))
+		if ((reponseBuffer[2] != responseBufferPtr[1]) || (reponseBuffer[3] != responseBufferPtr[2]))
 			return CRC;
-		if (responseBuffer[0] & 0x04) // Cascade bit set - UID not complete yes
+		if (responseBufferPtr[0] & 0x04) // Cascade bit set - UID not complete yes
 		{ 
 			cascadeLevel++;
 		}
 		else
 		{
 			uidComplete = true;
-			uid->sak = responseBuffer[0];
+			uid->sak = responseBufferPtr[0];
 		}
 	} // End of while ( ! uidComplete)
 	
@ -453,9 +495,65 @@ uint8_t Mfrc522::selectTag(Uid *uid)
 	return 0;
 }

+uint8_t Mfrc522::getUid(Uid *uid)
+{
+	uint8_t bufferOut[2];
+	uint8_t reponseBuffer[5];
+
+	bufferOut[0] = PICC_CMD_SEL_CL1;
+	bufferOut[1] = 2 << 4;
+
+	uint8_t rxLen = sizeof(reponseBuffer);
+
+	uint8_t ret = transceive(bufferOut, 2, reponseBuffer, &rxLen);
+	if(ret != 0)
+		return ret;
+
+	if(rxLen != 5)
+		return ERR;
+
+	uid->size = 4;
+
+	for(uint8_t i = 0; i < uid->size; ++i)
+	{
+		uid->uidByte[i] = reponseBuffer[i+1];
+	}
+
+	return 0;
+}
+
 void Mfrc522::irq()
 {
+	if(mode == MODE_TRANSCEIVE)
+	{
+		uint8_t irqs = read(ComIrqReg);

+		if(irqs)
+		{
+			if(serial)
+			{
+				serial->write("IRQS: ");
+				serial->write((int)irqs);
+				serial->putChar('\n');
+			}
+			write(ComIrqReg, 0b01111111); // clear irqs
+			transceiveAsyncFinish(irqs);
+		}
+	}
+	else if(mode == MODE_TIMEOUT)
+	{
+		write(ComIrqReg, 0b01111111); // clear irqs
+		write(TReloadRegH, POLL_TIMER >> 8);
+		write(TReloadRegL, POLL_TIMER & 0x0F);
+		mode = MODE_IDLE;
+		if(_transceiveCb)
+			_transceiveCb(TIMEOUT, this, nullptr, 0, _transceiveUserData);
+	}
+	else if(serial)
+	{
+		write(ComIrqReg, 0b01111111);
+		serial->write("IRQ wrong mode\n");
+	}
 }

 void Mfrc522::setRf(bool on)
@ -469,9 +567,8 @@ void Mfrc522::setRf(bool on)

 bool Mfrc522::cardPresent()
 {
-	uint8_t bufferATQA[2];
-	uint8_t bufferLen = sizeof(bufferATQA);
-	uint8_t ret = wakeupTag(bufferATQA, &bufferLen);
+	uint8_t bufferLen = sizeof(reponseBuffer);
+	uint8_t ret = wakeupTag(reponseBuffer, &bufferLen);
 	return ret == 0 || ret == COLLISION;
 }

@ -480,30 +577,79 @@ bool Mfrc522::probe(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin)
 	csReg->setBit(csPin, false);
 	spi->readWrite((VersionReg << 1) | (1 << 7));
 	uint8_t version = spi->readWrite();
+	if(serial)
+	{
+		serial->write_p(PSTR("Got version register: "));
+		serial->write((int)version);
+		serial->putChar('\n');
+	}
 	csReg->setBit(csPin, true);
 	return version == 0x91 || version == 0x92;
 }

-bool Mfrc522::testFifo()
+bool Mfrc522::testFifo(Serial* serial)
 {
 	uint8_t buffer[8] = {42, 43, 44, 45, 46, 47, 48, 49};
-	uint8_t buffer2[8] = {};
 	write(FIFOLevelReg, 1 << 7);			// Flush fifo Buffer;
 	write(FIFODataReg, buffer, sizeof(buffer));	 // Fill fifo
 	
-	if(serial)
-		serial->write_p(PSTR("Fifo buffer contains: "));
+	serial->write_p(PSTR("Fifo buffer contains: "));
 	
 	uint8_t len = read(FIFOLevelReg);
-	read(FIFODataReg, buffer2, len);
+	if(len > 8)
+	{
+		serial->write_p(PSTR("FIFOLevelReg to long\n"));
+		return false;
+	}
+	read(FIFODataReg, reponseBuffer, len);
 	bool ret = true;
 	for(uint8_t i = 0; i < len; ++i)
 	{
-		if(buffer[i] != buffer2[i])
+		if(buffer[i] != reponseBuffer[i])
 			ret = false;
-		serial->write((int)buffer2[i]);
+		serial->write((int)reponseBuffer[i]);
 		serial->putChar(' ');
 	}
 	serial->putChar('\n');
 	return ret;
 }
+
+bool Mfrc522::detectAsync(void (*tagEnterdCb)(Mfrc522*, void*), void* userData)
+{
+	if(irqDetect)
+		return false;
+	_tagEnterdCb = tagEnterdCb;
+	_userData = userData;
+	irqDetect = true;
+	updateBit(CollReg, 7, false);
+	uint8_t data = PICC_CMD_WUPA;
+	if(transceiveAsync(&detectAsyncCb, nullptr, &data, 1, 7) != 0)
+	{
+		irqDetect = false;
+		return false;
+	}
+	return true;
+}
+
+void Mfrc522::stopAsync()
+{
+	write(CommandReg, IDLE);
+	write(FIFOLevelReg, 1 << 7);
+	mode = MODE_IDLE;
+	irqDetect = false;
+	write(ComIrqReg, 0b01111111);
+}
+
+void Mfrc522::detectAsyncCb(uint8_t ret, Mfrc522* reader, uint8_t* response, uint8_t responseLen, void* userData)
+{
+	if((ret == 0 || ret == COLLISION) && reader->_tagEnterdCb)
+	{
+		reader->stopAsync();
+		reader->_tagEnterdCb(reader, reader->_userData);
+	}
+	else
+	{
+		reader->irqDetect = false;
+		reader->detectAsync(reader->_tagEnterdCb, reader->_userData);
+	}
+}
--- a/mfrc522.h
+++ b/mfrc522.h
@ -3,10 +3,19 @@
 #include "softspim.h"
 #include "defines.h"
 #include "serial.h"
+#include "uid.h"

 class Mfrc522
 {
 public:
+	
+	static constexpr uint32_t POLL_OUT_US = 15000;
+	static constexpr uint8_t PRESCALLER = 169;
+	static constexpr uint16_t POLL_TIMER = (POLL_OUT_US*1.0E-6)/((2*PRESCALLER+1)/13.56E6);
+	
+	static constexpr uint32_t TIMEOUT_US = 1000000;
+	static constexpr uint16_t TIMEOUT_TIMER = (TIMEOUT_US*1.0E-6)/((2*169.0+1)/13.56E6);
+	
 	// Error codes.
 	static constexpr uint8_t OK = 0;        // Everything A-OK.
 	static constexpr uint8_t NOTAGERR = 1;  // No tag error
@ -14,7 +23,8 @@ public:
 	static constexpr uint8_t LEN = 3;       // Buffer length error
 	static constexpr uint8_t COLLISION = 4; // Chip collision
 	static constexpr uint8_t CRC = 5;       // CRC incorrect collision
-	static constexpr uint8_t ERR = 6;       // General error
+	static constexpr uint8_t BUSY = 6;       // System is busy
+	static constexpr uint8_t ERR = 7;       // General error

 	// Command words
 	static constexpr uint8_t IDLE       = 0x00; // NO action; Cancel the current command
@ -132,13 +142,10 @@ public:
 	// The PICC_CMD_MF_READ and PICC_CMD_MF_WRITE can also be used for MIFARE Ultralight.
 	static constexpr uint8_t PICC_CMD_UL_WRITE		= 0xA2;		// Writes one 4 byte page to the PICC
 	
-	typedef struct
-	{
-		uint8_t size; // Number of bytes in the UID. 4, 7 or 10.
-		uint8_t uidByte[10];
-		uint8_t sak;  // The SAK (Select acknowledge) byte returned from the PICC after successful selection.
-	} Uid;
-
+	// Modes
+	static constexpr uint8_t MODE_IDLE = 0;
+	static constexpr uint8_t MODE_TRANSCEIVE = 1;
+	static constexpr uint8_t MODE_TIMEOUT = 2;

 private:
 	ShiftReg<NFC_PORTS>*  _csReg;
@ -146,44 +153,78 @@ private:

 	uint8_t _csPin;

+	void (*_tagEnterdCb)(Mfrc522*, void*);
+	void* _userData;
+	
+	void (*_transceiveCb)(uint8_t ret, Mfrc522* reader, uint8_t* response, uint8_t responseLen, void* userData);
+	void* _transceiveUserData;
+
+	static constexpr uint8_t reponseBufferLen = 16;
+	static uint8_t reponseBuffer[reponseBufferLen];
+
+	volatile uint8_t mode = MODE_IDLE;
+	
+	volatile bool irqDetect = false;
+	
+	void setupTransceive(uint8_t *sendData, uint8_t sendLen, uint8_t validBits = 0, uint8_t rxAlign = 0);
+	
+	uint8_t transceiveAsync(void (*transceiveCb)(uint8_t, Mfrc522*, uint8_t*, uint8_t, void*), void* userData, uint8_t *sendData,
+	                        uint8_t sendLen, uint8_t validBits = 0, uint8_t rxAlign = 0);
+	void transceiveAsyncFinish(uint8_t irq);
+
+	uint8_t transceive(uint8_t *sendData, uint8_t sendLen, uint8_t *recvData, uint8_t *recvLen,
+	                   uint8_t validBits= 0, uint8_t rxAlign = 0, uint8_t *rxValidBits = nullptr);
+	
+	static void detectAsyncCb(uint8_t ret, Mfrc522* reader, uint8_t* response, uint8_t responseLen, void* userData);
+
+public:
 	uint8_t read(uint8_t addr);
 	void read(uint8_t addr, uint8_t* data, uint8_t datalen, uint8_t rxAlign = 0);
 	void write(uint8_t addr, uint8_t data);
 	void write(uint8_t addr, uint8_t* data, uint8_t datalen);
 	void updateBit(uint8_t addr, uint8_t bit, bool value);
-
-	void (*_tagEnterdCb)(Mfrc522*, void*);
-	void* _userData;
-
-public:
+	static Serial* serial;
 	
-	inline static Serial* serial = nullptr;
-	
-	Mfrc522(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin,
-	        void (*tagEnterdCb)(Mfrc522*, void*) = nullptr, void* userData = nullptr);
+	Mfrc522(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin);
 	
 	uint8_t calculateCrc(uint8_t *data, uint8_t length, uint16_t *result);

-	uint8_t commuicateWithTag(uint8_t command, uint8_t waitIrq,
-	                          uint8_t *sendData, uint8_t sendLen,
-	                          uint8_t *recvData, uint8_t *recvLen,
-	                          uint8_t validBits = 0, uint8_t rxAlign = 0,
-	                          uint8_t *rxValidBits = nullptr);
-
-	uint8_t transceive(uint8_t *sendData, uint8_t sendLen, uint8_t *recvData, uint8_t *recvLen,
-	                   uint8_t validBits = 0, uint8_t rxAlign = 0, uint8_t *rxValidBits = nullptr);
-
 	uint8_t wakeupTag(uint8_t* bufferATQA,	uint8_t *bufferLen);

 	uint8_t selectTag(Uid *uid);

+	uint8_t getUid(Uid *uid);
+
+	uint8_t getCs(){return _csPin;}
+
+	void reset();
+
 	void irq();

 	void setRf(bool on);
 	
+	bool detectAsync(void (*tagEnterdCb)(Mfrc522*, void*) = nullptr, void* userData = nullptr);
+	
+	void stopAsync();
+	
 	bool cardPresent();

-	bool testFifo();
+	bool testFifo(Serial* serial);
+	
+	bool startTimeout(void (transceiveCb)(uint8_t, Mfrc522*, uint8_t*, uint8_t, void*), void* userData)
+	{
+		_transceiveCb = transceiveCb;
+		_transceiveUserData = userData;
+		if(mode != MODE_IDLE)
+			return false;
+		mode = MODE_TIMEOUT;
+		write(TReloadRegH, TIMEOUT_TIMER >> 8);
+		write(TReloadRegL, TIMEOUT_TIMER & 0x0F);
+		write(ComIrqReg, 0b01111111); // clear irqs
+		write(ComIEnReg, (1 << 0));
+		updateBit(ControlReg, 6, true);
+		return true;
+	}

 	static bool probe(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin);
 };
--- a/mfrcproxy.cpp
+++ b/mfrcproxy.cpp
@ -0,0 +1,52 @@
+#include "mfrcproxy.h"
+
+MfrcProxy::MfrcProxy(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin, void (detectCb)(MfrcProxy* proxy, Uid uid, void* data), void* userData):
+_csReg(csReg), _spi(spi), _detectCb(detectCb), _userData(userData), _csPin(csPin)
+{
+	
+}
+
+uint8_t MfrcProxy::read(uint8_t addr)
+{
+	_csReg->setBit(_csPin, false);
+	_delay_us(5);
+	_spi->readWrite(addr);
+	_delay_us(5);
+	uint8_t res = _spi->readWrite();
+	_csReg->setBit(_csPin, true);
+	return res;
+}
+
+void MfrcProxy::irq()
+{
+	if(read(REG_IRQ_BITS))
+	{
+		uint8_t len = read(REG_UID_LEN);
+		if(len > 0 && len < 11)
+		{
+			Uid uid;
+			for(uint8_t i = 0; i < len; ++i)
+			{
+				uid.uidByte[i] = read(REG_UID_START_REG+i);
+			}
+			uid.size = len;
+			_detectCb(this, uid, _userData);
+		}
+	}
+}
+
+bool MfrcProxy::probe(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin)
+{
+	csReg->setBit(csPin, false);
+	_delay_us(5);
+	spi->readWrite(REG_CHIP_ID);
+	_delay_us(5);
+	uint8_t version = spi->readWrite();
+	csReg->setBit(csPin, true);
+	return version == 0x87;
+}
+
+uint8_t MfrcProxy::getId()
+{
+	return read(REG_ID);
+}
--- a/mfrcproxy.h
+++ b/mfrcproxy.h
@ -0,0 +1,36 @@
+#pragma once
+#include <stdint.h>
+
+#include "shiftreg.h"
+#include "softspim.h"
+#include "defines.h"
+#include "serial.h"
+#include "uid.h"
+
+class MfrcProxy
+{
+public:
+	static constexpr uint8_t REG_CHIP_ID = 0xEE;
+	static constexpr uint8_t REG_ID = 0x01;
+	static constexpr uint8_t REG_IRQ_BITS = 0x02;
+	static constexpr uint8_t REG_UID_LEN = 0x04;
+	static constexpr uint8_t REG_UID_START_REG = 0x10;
+	
+private:
+	ShiftReg<NFC_PORTS>*  _csReg;
+	SpiMaster* _spi;
+	
+	void (*_detectCb)(MfrcProxy* proxy, Uid uid, void* data);
+	void* _userData;
+
+	uint8_t _csPin;
+
+
+public:
+	MfrcProxy(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin, void (detectCb)(MfrcProxy* proxy, Uid uid, void* data), void* userData = nullptr);
+	uint8_t read(uint8_t addr);
+	void irq();
+	static bool probe(SpiMaster* spi, ShiftReg<NFC_PORTS>*  csReg, uint8_t csPin);
+	uint8_t getId();
+	uint8_t getCs(){return _csPin;}
+};
--- a/nfcbord.cpp
+++ b/nfcbord.cpp
@ -4,121 +4,461 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
+#include <avr/wdt.h>
 #include <stdio.h>
 #include "writepin.h"
+#include "watchdog.h"
+
+NfcBoard nfcBoard(Serial::getInstance());

 extern char buffer[SNPRINTF_BUFFER_SIZE];

-NfcBoard::NfcBoard():
+ISR(WDT_vect)
+{
+	for(uint8_t i = 0; i < nfcBoard.watchDogBits.count(); ++i)
+	{
+		if(nfcBoard.watchDogBits[i] == 0)
+			nfcBoard.watchDogBits[i] = 2;
+		else
+			nfcBoard.watchDogBits[i] = 0;
+	}
+}
+
+NfcBoard::NfcBoard(Serial* serialIn):
+serial(serialIn),
 csReg(&PORTC, PC1, PC2, PC0),
 irqReg(&PORTC, &PINB, PC5, PB1, PC4)
 {
-	DDRC = (1 << PC0) | (1 << PC1) | (1 << PC2) | (1 << PC4) | (1 << PC5);
-	DDRB = (1 << PB4) | (1 << PB3);
+	DDRC |= (1 << PC0) | (1 << PC1) | (1 << PC2) | (1 << PC4) | (1 << PC5);
+	DDRB |= (1 << PB4) | (1 << PB3);
 	csReg.clear(true);
+	irqReg.read();
 	probe();
+	setEnabled(true);
+}
+
+void NfcBoard::poll(Serial* serial)
+{
+	for(uint8_t i = 0; i < watchDogBits.count(); ++i)
+	{
+		if(watchDogBits[i] == 2 && readers[i].type == TYPE_MFRC522)
+		{
+			if(serial)
+			{
+				serial->write_p(PSTR("Warning reader watchdog timeout for reader "));
+				serial->write((int)i);
+				serial->putChar('\n');
+			}
+			readers[i].device.mfrc522.reset();
+			if(enabled_)
+				readers[i].device.mfrc522.detectAsync(detectCb, this);
+			watchDogBits[i] = 1;
+		}
+	}
+
+	if(readPin(&PINC, PC3))
+	{
+		uint8_t* data = irqReg.read();
+		for(uint8_t i = 0; i < NFC_PORTS; ++i)
+		{
+			if(*data & (1 << i))
+			{
+				for(uint8_t j = 0; j < readers.count(); ++j)
+				{
+					if(irqPins[j] == i)
+					{
+						if(readers[j].type == TYPE_MFRC522)
+						{
+							readers[j].device.mfrc522.irq();
+							watchDogBits[j] = 1;
+						}
+						else
+						{
+							readers[j].device.proxy.irq();
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void NfcBoard::setEnabled(bool enabled)
+{
+	if(enabled != enabled_)
+	{
+		enabled_ = enabled;
+		for(uint8_t i = 0; i < readers.count(); ++i)
+		{
+			if(readers[i].type == TYPE_MFRC522)
+			{
+				if(enabled)
+					readers[i].device.mfrc522.detectAsync(detectCb, this);
+				else
+					readers[i].device.mfrc522.stopAsync();
+				watchDogBits[i] = 0;
+			}
+		}
+		if(enabled)
+			wdt_set(WDTO_4S);
+		else
+			wdt_disable();
+	}
+}
+
+uint8_t NfcBoard::csToIrq(uint8_t cs)
+{
+	switch(cs)
+	{
+		case 0:
+			return 4;
+		case 1:
+			return 2;
+		case 2:
+			return 1;
+		case 3:
+			return 0;
+		case 4:
+			return 7;
+		case 5:
+			return 6;
+		case 6:
+			return 5;
+		case 7:
+			return 3;
+		default:
+			return 8;
+	}
 }

 void NfcBoard::probe()
 {
 	readers.clear();
 	irqPins.clear();
+	watchDogBits.clear();
 	for(uint8_t i = 0; i < NFC_PORTS; ++i)
 	{
 		if(Mfrc522::probe(&spim, &csReg, i))
 		{
-			irqPins.push_back(i);
+			NfcPort port(Mfrc522(&spim, &csReg, i));
+			readers.push_back(port);
+			irqPins.push_back(csToIrq(i));
+			watchDogBits.push_back(0);
+		}
+		else if(MfrcProxy::probe(&spim, &csReg, i))
+		{
+			NfcPort port(MfrcProxy(&spim, &csReg, i, proxyDetectCb, this));
+			readers.push_back(port);
+			irqPins.push_back(csToIrq(i));
+			watchDogBits.push_back(0);
 		}
-	}
-	for(uint8_t i = 0; i < irqPins.count(); ++i)
-	{
-		readers.push_back(Mfrc522(&spim, &csReg, irqPins[i]));
 	}
 }

-void NfcBoard::printNfcDevices(Serial* serial)
+void NfcBoard::printNfcDevices()
 {
 	serial->write_p(PSTR("NFC DEVICES:\n"));
 	for(uint8_t i = 0; i < readers.count(); ++i)
 	{
-		snprintf(buffer, SNPRINTF_BUFFER_SIZE, "NFC NUMBER: %u IRQ: %x\n", i, irqPins[i]);
+		uint8_t id = readers[i].type == TYPE_MFRC522 ? i+0x80 : readers[i].device.proxy.getId();
+		uint8_t cs = readers[i].type == TYPE_MFRC522 ?
+			readers[i].device.mfrc522.getCs() : readers[i].device.proxy.getCs();
+		snprintf_P(buffer, SNPRINTF_BUFFER_SIZE, PSTR("NFC NUMBER: %u CS: %x IRQ: %x TYPE: %d\n"),
+				id, cs, irqPins[i], readers[i].type);
 		serial->write(buffer, SNPRINTF_BUFFER_SIZE);
 	}
 }

-int NfcBoard::dispatch(char* inBuffer, Serial* serial)
-{
-	else if(strcmp(inBuffer, "detect") == 0 )
+int NfcBoard::dispatch(char* inBuffer)
+{ 
+	Mfrc522* mainReader = nullptr;
+	for(uint8_t i = 0; i < readers.count(); ++i)
 	{
-		serial->write_p(PSTR("Runing tag detection test\n"));
-		bool oldPresent = false;
+		if(readers[i].type == TYPE_MFRC522)
+		{
+			mainReader = &readers[i].device.mfrc522;
+		}
+	}
+	if(strcmp(inBuffer, "debug") == 0)
+	{
+		Mfrc522::serial = serial;
+		return 0;
+	}
+	else if(strcmp(inBuffer, "quiet") == 0 )
+	{
+		Mfrc522::serial = nullptr;
+		return 0;
+	}
+	else if(strcmp(inBuffer, "irqs") == 0 )
+	{
+		serial->write_p(PSTR("Irq pin detection test\n")); 
 		while(!serial->dataIsWaiting())
 		{
-			bool present = readers[0].cardPresent();
-			if(present && !oldPresent)
+			uint8_t* data = irqReg.read();
+			for(uint8_t i = 0; i < NFC_PORTS; ++i)
 			{
-				oldPresent = present;
-
-				Mfrc522::Uid uid;
-				//Mfrc522::serial = serial;
-				uint8_t res = readers[0].selectTag(&uid);
-				Mfrc522::serial = nullptr;
-				if(res != 0)
+				if(*data & (1 << i))
 				{
-					serial->write_p(PSTR("Select Failed with "));
-					serial->write((int)res);
+					serial->write("IRQ: ");
+					serial->write((int)i);
 					serial->putChar('\n');
-					continue;
 				}
-				serial->write_p(PSTR("Uid: "));
-				for(uint8_t i = 0; i < uid.size; ++i)
-				{
-					serial->write((int)uid.uidByte[i]);
-					serial->putChar(':');
-				}
-				serial->putChar('\n');
-				break;
 			}
-			else if(!present && oldPresent)
-			{
-				serial->write_p(PSTR("Tag lost\n"));
-				oldPresent = present;
-			}
-			_delay_ms(100);
 		}
 		serial->write_p(PSTR("Finished\n"));
 		return 0;
 	}
-	else if(strcmp(inBuffer, "tste") == 0 )
+	else if(strcmp(inBuffer, "select") == 0 )
 	{
-		serial->write_p(PSTR("Runing fifo test\n"));
-		Mfrc522::serial = serial;
-		readers[0].testFifo();
-		Mfrc522::serial = nullptr;
+		bool enabled = enabled_;
+		setEnabled(false);
+		if(!mainReader)
+		{
+			serial->write_p(PSTR("No nfc reader present\n"));
+			return -1;
+		}
+		serial->write_p(PSTR("Runing tag detection test\n")); 
+		while(!serial->dataIsWaiting())
+		{
+			bool present = mainReader->cardPresent();
+			if(present)
+			{
+				Uid uid;
+				uint8_t res = mainReader->selectTag(&uid);
+				if(res != 0)
+					continue;
+
+				serial->write_p(PSTR("Uid: "));
+				for(uint8_t i = 0; i < uid.size; ++i)
+				{
+					serial->write((int)uid.uidByte[i]);
+					if(i < uid.size-1)
+						serial->putChar(':');
+				}
+				serial->putChar('\n');
+			}
+			_delay_ms(100);
+		}
+		setEnabled(enabled);
 		serial->write_p(PSTR("Finished\n"));
 		return 0;
 	}
-	else if(strcmp(inBuffer, "status") == 0 )
+	else if(strcmp(inBuffer, "detect") == 0 )
 	{
-		printNfcDevices(serial);
+		bool enabled = enabled_;
+		setEnabled(false);
+		if(!mainReader)
+		{
+			serial->write_p(PSTR("No nfc reader present\n"));
+			return -1;
+		}
+		serial->write_p(PSTR("Runing fast tag detection test\n"));
+		while(!serial->dataIsWaiting())
+		{
+			bool present = mainReader->cardPresent();
+			if(present)
+			{
+				Uid uid;
+				uint8_t res = mainReader->getUid(&uid);
+				if(res != 0)
+					continue;
+				
+				serial->write_p(PSTR("Uid: "));
+				for(uint8_t i = 0; i < uid.size; ++i)
+				{
+					serial->write((int)uid.uidByte[i]);
+					if(i < uid.size-1)
+						serial->putChar(':');
+				}
+				serial->putChar('\n');
+			}
+		}
+		setEnabled(enabled);
+		serial->write_p(PSTR("Finished\n"));
 		return 0;
 	}
-	else if(strcmp(inBuffer, "wake") == 0 )
+	else if(strcmp(inBuffer, "enable") == 0 )
 	{
-		uint8_t bufferATQA[2];
-		uint8_t len = sizeof(bufferATQA);
-
-		uint8_t res = readers[0].wakeupTag(bufferATQA, &len);
-		snprintf(buffer, SNPRINTF_BUFFER_SIZE, "wakeupTag returned: %u Buffer: 0x%x 0x%x len %u\n",
-				 res, bufferATQA[0], bufferATQA[1], len);
-		serial->write(buffer, SNPRINTF_BUFFER_SIZE);
+		if(enabled_)
+		{
+			serial->write_p(PSTR("Nfc tag listening allready enabled\n"));
+			return -1;
+		}
+		setEnabled(true);
+		serial->write_p(PSTR("Nfc tag listening enabled\n"));
+		return 0;
+	}
+	else if(strcmp(inBuffer, "disable") == 0 )
+	{
+		if(!enabled_)
+		{
+			serial->write_p(PSTR("Nfc tag listening already disabled\n"));
+			return -1;
+		}
+		setEnabled(false);
+		serial->write_p(PSTR("Nfc tag listening disabled\n"));
+		return 0;
+	}
+	else if(strcmp(inBuffer, "list") == 0 )
+	{
+		printNfcDevices();
 		return 0;
 	}
 	else if(strcmp(inBuffer, "probe") == 0 )
 	{
+		bool enabled = enabled_;
+		setEnabled(false);
 		probe();
-		printNfcDevices(serial);
+		printNfcDevices();
+		setEnabled(enabled);
+		return 0;
+	}
+	else if(strcmp(inBuffer, "read") == 0 )
+	{
+		int16_t addr = -1;
+		int16_t csPin = -1;
+
+		char* token = strtok(NULL, " ");
+		if(token)
+			csPin = strtol(token, nullptr, 16);
+		if(csPin < 0 || csPin > 7)
+		{
+			serial->write_p(PSTR("A valid cs pin must be specified\n"));
+			return -1;
+		}
+		token = strtok(NULL, " ");
+		if(token)
+			addr = strtol(token, nullptr, 16);
+		if(addr < 0 || addr > 0xFF)
+		{
+			serial->write_p(PSTR("A address must be specified\n"));
+			return -1;
+		}
+		
+		uint8_t result = 0;
+		for(uint8_t i = 0; i < readers.count(); ++i)
+		{
+			if(readers[i].type == TYPE_MFRC522)
+			{
+				if(readers[i].device.mfrc522.getCs() == csPin)
+				{
+					result = readers[i].device.mfrc522.read(addr);
+					serial->write_p(PSTR("read sucessfull\n"));
+				}
+			}
+			else
+			{
+				if(readers[i].device.proxy.getCs() == csPin)
+				{
+					result = readers[i].device.proxy.read(addr);
+					serial->write_p(PSTR("read sucessfull\n"));
+				}
+			}
+		}
+
+		snprintf_P(buffer, SNPRINTF_BUFFER_SIZE, PSTR("Got: 0x%02x in return\n"), result);
+		serial->write(buffer, SNPRINTF_BUFFER_SIZE);
+		return 0;
+	}
+	else if(strcmp(inBuffer, "write") == 0 )
+	{
+		int16_t addr = -1;
+		int16_t csPin = -1;
+		int16_t data = -1;
+
+		char* token = strtok(NULL, " ");
+		if(token)
+			csPin = strtol(token, nullptr, 16);
+		if(csPin < 0 || csPin > 7)
+		{
+			serial->write_p(PSTR("A valid cs pin must be specified\n"));
+			return -1;
+		}
+		token = strtok(NULL, " ");
+		if(token)
+			addr = strtol(token, nullptr, 16);
+		if(addr < 0 || addr > 0xFF)
+		{
+			serial->write_p(PSTR("A address must be specified\n"));
+			return -1;
+		}
+		token = strtok(NULL, " ");
+		if(token)
+			data = strtol(token, nullptr, 16);
+		if(data < 0 || data > 0xFF)
+		{
+			serial->write_p(PSTR("Data must be specified\n"));
+			return -1;
+		}
+		
+		for(uint8_t i = 0; i < readers.count(); ++i)
+		{
+			if(readers[i].type == TYPE_MFRC522)
+			{
+				if(readers[i].device.mfrc522.getCs() == csPin)
+				{
+					readers[i].device.mfrc522.write(addr, data);
+					serial->write_p(PSTR("Write sucessfull\n"));
+				}
+			}
+			else
+			{
+				if(readers[i].device.proxy.getCs() == csPin)
+				{
+					serial->write_p(PSTR("Mfrc522 proxies are not writable\n"));
+					return -1;
+				}
+			}
+		}
 		return 0;
 	}
 	return -3;
 }
+
+void NfcBoard::printTag(const uint8_t id, const Uid& uid, Serial* serial)
+{
+	serial->write("NFC ");
+	serial->write((int)id);
+	serial->write(" TAG ");
+	for(uint8_t i = 0; i < uid.size; ++i)
+	{
+		serial->write((int)uid.uidByte[i]);
+		if(i < uid.size-1)
+			serial->putChar(':');
+	}
+	serial->putChar('\n');
+}
+
+void NfcBoard::proxyDetectCb(MfrcProxy* proxy, const Uid uid, void* data)
+{
+	NfcBoard* instance = reinterpret_cast<NfcBoard*>(data);
+
+	printTag(proxy->getId(), uid, instance->serial);
+}
+
+void NfcBoard::detectCb(Mfrc522* reader, void* data)
+{
+	NfcBoard* instance = reinterpret_cast<NfcBoard*>(data);
+	
+	Uid uid;
+	if(reader->getUid(&uid) == 0)
+	{
+		uint8_t i;
+		for(i = 0; i < instance->readers.count(); ++i)
+		{
+			if(&instance->readers[i].device.mfrc522 == reader)
+				break;
+		}
+		printTag(i+0x80, uid, instance->serial);
+		reader->startTimeout(&timeoutCb, data);
+	}
+	else
+	{
+		reader->detectAsync(detectCb, data);
+	}
+}
+
+void NfcBoard::timeoutCb(uint8_t ret, Mfrc522* reader, uint8_t* response, uint8_t responseLen, void* userData)
+{
+	reader->detectAsync(&detectCb, userData);
+}
--- a/nfcbord.h
+++ b/nfcbord.h
@ -1,4 +1,5 @@
 #pragma once
+#include "placementnew.h"
 #include "serial.h"
 #include "shiftreg.h"
 #include "inputshiftreg.h"
@ -6,21 +7,80 @@
 #include "softspim.h"
 #include "staticvector.h"
 #include "defines.h"
+#include "mfrcproxy.h"

 class NfcBoard
 {
-public:
-	ShiftReg<NFC_PORTS> csReg;
-	InputShiftReg<NFC_PORTS> irqReg;
-	SpiMaster spim;
-	SVector<Mfrc522, NFC_PORTS> readers;
-	SVector<uint8_t, NFC_PORTS> irqPins;
+private:
 	
-	NfcBoard();
+	static constexpr int TYPE_MFRC522 = 0;
+	static constexpr int TYPE_PROXY = 1;
+	
+	union PortDevice
+	{
+		Mfrc522 mfrc522;
+		MfrcProxy proxy;
+		PortDevice(const Mfrc522& mfrc522In)
+		{
+			new (&mfrc522) Mfrc522(mfrc522In);
+		}
+		PortDevice(const MfrcProxy& proxyIn)
+		{
+			new (&proxy) MfrcProxy(proxyIn);
+		}
+	};
+	
+	struct NfcPort
+	{
+		PortDevice device;
+		uint8_t type;
+		NfcPort(const Mfrc522& mfrc522): device(mfrc522)
+		{
+			type = TYPE_MFRC522;
+		}
+		NfcPort(const MfrcProxy& proxy): device(proxy)
+		{
+			type = TYPE_PROXY;
+		}
+		~NfcPort()
+		{
+			if(type == TYPE_MFRC522)
+				device.mfrc522.~Mfrc522();
+			else
+				device.proxy.~MfrcProxy();
+		}
+	};
+	
+	Serial* serial;
+	SpiMaster spim;
+	ShiftReg<NFC_PORTS> csReg;
+	bool enabled_ = false;
+	
+	static void printTag(const uint8_t id, const Uid& uid, Serial* serial);
+	
+public:
+	InputShiftReg<NFC_PORTS> irqReg;
+	SVector<uint8_t, NFC_PORTS> irqPins;
+	SVector<NfcPort, NFC_PORTS> readers;
+	SVector<volatile uint8_t, NFC_PORTS> watchDogBits;
+
+	static void detectCb(Mfrc522* reader, void* data);
+	static void timeoutCb(uint8_t ret, Mfrc522* reader, uint8_t* response, uint8_t responseLen, void* userData);
+	static void proxyDetectCb(MfrcProxy* proxy, const Uid uid, void* data);
+	
+	NfcBoard(Serial* serialIn);
 	
 	void probe();
 	
-	void printNfcDevices(Serial* serial);
+	void setEnabled(bool enabled);
 	
-	int dispatch(char* inBuffer, Serial* serial);
+	void poll(Serial* serial = nullptr);
+	
+	void printNfcDevices();
+	
+	int dispatch(char* inBuffer);
+	
+	uint8_t csToIrq(uint8_t cs);
 };
+
+extern NfcBoard nfcBoard;
--- a/placementnew.cpp
+++ b/placementnew.cpp
@ -0,0 +1,11 @@
+#include "placementnew.h"
+
+void* operator new(uint16_t, void* const buf)
+{
+  return buf;
+}
+
+void* operator new[](uint16_t, void* const buf)
+{
+  return buf;
+}
--- a/placementnew.h
+++ b/placementnew.h
@ -0,0 +1,5 @@
+#pragma once
+#include "stdint.h"
+
+void* operator new(uint16_t, void* const buf);
+void* operator new[](uint16_t, void* const buf);
--- a/serial.h
+++ b/serial.h
@ -2,7 +2,8 @@
 #define SERIAL_H

 #define BAUD 38400
-#define SERIAL_BUFFER_SIZE 384
+#define SERIAL_RX_BUFFER_SIZE 384
+#define SERIAL_TX_BUFFER_SIZE 128

 #include <util/setbaud.h>
 #include <avr/io.h>
@ -11,15 +12,25 @@
 #include <stdlib.h>
 #include <avr/pgmspace.h>

+#include "ringbuffer.h"
+
 const bool serialFlowControl = false;

 class Serial
 {
 private:
 	char _terminator = '\n';
+	Serial();
 	
 public:
-	Serial();
+
+	volatile RingBuffer<SERIAL_RX_BUFFER_SIZE, volatile uint8_t> rxBuffer;
+	volatile RingBuffer<SERIAL_TX_BUFFER_SIZE, volatile uint8_t> txBuffer;
+
+	bool stopped = false;
+	volatile bool transmitting = false;
+	
+	static Serial* getInstance();
 	void putChar(const char c);
 	void write(const char* in, const unsigned int length);
 	void write(const char in[]);
--- a/shiftreg.h
+++ b/shiftreg.h
@ -53,8 +53,8 @@ public:

 			for(unsigned char i = 0; i < BITS; ++i)
 			{
-				*_port |= (1 << _pinSerClk);
 				in[i/8] & (1<<(i%8)) ? (*_port &= ~(1 << _pinSer)) : (*_port |= (1 << _pinSer));
+				*_port |= (1 << _pinSerClk);
 				*_port &= ~(1 << _pinSerClk);
 			}
 			*_port &= ~(1<<_pinRClk);
--- a/signal.cpp
+++ b/signal.cpp
@ -40,9 +40,9 @@ uint16_t Signal::getPacket()
 	return data;
 }

-void Signal::sendData()
+void Signal::sendData(bool single)
 {
-	sendRaw(getPacket());
+	sendRaw(getPacket(), single);
 }

 uint8_t Signal::getType()
--- a/signal.h
+++ b/signal.h
@ -27,6 +27,6 @@ public:
 	uint8_t getState();
 	uint8_t getSubaddress();
 	uint16_t getPacket();
-	void sendData();
+	void sendData(bool single = false);
 	uint8_t getType();
 };
--- a/softspim.cpp
+++ b/softspim.cpp
@ -17,19 +17,19 @@ uint8_t SpiMaster::readWrite(uint8_t in)
 			writePin(_port, _pinOut, in & (1 << i));
 		else
 			writePin(_port, _pinOut, in & (1 << (7-i)));
-		if constexpr (CLOCK_PHASE == 0)
+		if constexpr (CLOCK_PHASE == 0 || CLOCK_PHASE == 2)
 			_delay_us(DELAY_TIME_US);
 		writePin(_port, _pinClock, !CLOCK_POLARITY);
-		if constexpr (CLOCK_PHASE == 1)
+		if constexpr (CLOCK_PHASE == 1 || CLOCK_PHASE == 2)
 			_delay_us(DELAY_TIME_US);
 		if constexpr (BIT_ORDER == 0)
 			recByte |= readPin(_pinReg, _pinIn) << i;
 		else
 			recByte |= readPin(_pinReg, _pinIn) << (7-i);
-		if constexpr (CLOCK_PHASE == 0)
+		if constexpr (CLOCK_PHASE == 0 || CLOCK_PHASE == 2)
 			_delay_us(DELAY_TIME_US);
 		writePin(_port, _pinClock, CLOCK_POLARITY);
-		if constexpr (CLOCK_PHASE == 1)
+		if constexpr (CLOCK_PHASE == 1 || CLOCK_PHASE == 2)
 			_delay_us(DELAY_TIME_US);
 	}
 	return recByte;
--- a/softspim.h
+++ b/softspim.h
@ -6,8 +6,8 @@ class SpiMaster
 {
 private:

-	static constexpr uint8_t CLOCK_POLARITY = 1;
-	static constexpr uint8_t CLOCK_PHASE    = 1;
+	static constexpr uint8_t CLOCK_POLARITY = 0;
+	static constexpr uint8_t CLOCK_PHASE    = 2;
 	static constexpr uint8_t BIT_ORDER      = 1;

 	volatile uint8_t * const _port        = &PORTB;
@ -16,7 +16,7 @@ private:
 	static constexpr uint8_t _pinOut      = PB4;
 	static constexpr uint8_t _pinClock    = PB3;

-	static constexpr uint8_t DELAY_TIME_US  = 10;
+	static constexpr uint8_t DELAY_TIME_US  = 0;


 public:
--- a/train.cpp
+++ b/train.cpp
@ -132,9 +132,9 @@ uint16_t Train::assembleSpeedPacket()
 	return packet;
 }

-void Train::sendData()
+void Train::sendData(bool single)
 {
-	sendRaw(assembleSpeedPacket());
+	sendRaw(assembleSpeedPacket(), single);
 	if(_functionmask)
 	{
 		uint8_t functionToResend = (_function & 0xF0) >> 4;
@ -144,7 +144,7 @@ void Train::sendData()
 		if(_functionmask & (1 << functionToResend))
 		{
 			_delay_ms(2);
-			sendRaw(packetAddSpeed() | packetAddFunction(functionToResend) | packetAddFunction(0));
+			sendRaw(packetAddSpeed() | packetAddFunction(functionToResend) | packetAddFunction(0), false);
 		}
 		_function &= ~0xF0;
 		_function |= functionToResend << 4;
@ -174,7 +174,7 @@ uint8_t Train::getFunctionMask()
 	return _functionmask;
 }

-void Train::sendFunction(const uint8_t function, bool enable)
+void Train::setFunction(const uint8_t function, bool enable)
 {
 	if(function > 3)
 		return;
--- a/train.h
+++ b/train.h
@ -20,7 +20,7 @@ public:
 	
 	Train(const uint8_t address, uint8_t functionmask = 0, uint8_t quirks = 0);

-	void sendData();
+	void sendData(bool single = false);
 	
 	void reverse();
 	void stop();
@ -34,7 +34,7 @@ public:
 	void setFunctionMask(uint8_t functionmask) {_functionmask = functionmask;}
 	uint8_t getFunctions();
 	uint8_t getFunctionMask();	
-	void sendFunction(const uint8_t function, bool enable = true);
+	void setFunction(const uint8_t function, bool enable = true);
 	
 	uint8_t getQuirks();
 	void setQuirks(uint8_t quirks);
--- a/traindispatch.h
+++ b/traindispatch.h
@ -103,7 +103,7 @@ int trainDispatch(char* inBuffer, Serial* serial)
 				{
 					uint8_t functionId = atoi(token);
 					bool on = (strcmp(boolToken, "on") == 0);
-					trains[id].sendFunction(functionId, on );
+					trains[id].setFunction(functionId, on );
 					serial->write_p(PSTR("Set Train function "));
 					serial->write(functionId);
 					serial->write(on ? " on\n" : " off\n");
--- a/turnout.cpp
+++ b/turnout.cpp
@ -33,7 +33,7 @@ uint16_t Turnout::getPacket()
 	return data;
 }

-void Turnout::sendData()
+void Turnout::sendData(bool single)
 {
-	sendRaw(getPacket());
+	sendRaw(getPacket(), single);
 }
--- a/turnout.h
+++ b/turnout.h
@ -18,5 +18,5 @@ public:
 	uint8_t getDirection();
 	uint8_t getSubaddress();
 	uint16_t getPacket();
-	void sendData();
+	void sendData(bool single = false);
 };
--- a/uid.h
+++ b/uid.h
@ -0,0 +1,24 @@
+#pragma once
+
+class Uid
+{
+public:
+	uint8_t size; // Number of bytes in the UID. 4, 7 or 10.
+	uint8_t uidByte[10];
+	uint8_t sak;  // The SAK (Select acknowledge) byte returned from the PICC after successful selection.
+	bool operator==(Uid& in)
+	{
+		if(size != in.size)
+			return false;
+		for(uint8_t i = 0; i < size; ++i)
+		{
+			if(uidByte[i] != in.uidByte[i])
+				return false;
+		}
+		return true;
+	}
+	bool operator!=(Uid& in)
+	{
+		return !operator==(in);
+	}
+};
--- a/watchdog.h
+++ b/watchdog.h
@ -0,0 +1,18 @@
+#pragma once
+#include <avr/wdt.h>
+
+#define wdt_set(value)   \
+    __asm__ __volatile__ (  \
+        "in __tmp_reg__,__SREG__" "\n\t"    \
+        "cli" "\n\t"    \
+        "wdr" "\n\t"    \
+        "sts %0,%1" "\n\t"  \
+        "out __SREG__,__tmp_reg__" "\n\t"   \
+        "sts %0,%2" \
+        :  \
+        : "M" (_SFR_MEM_ADDR(_WD_CONTROL_REG)), \
+        "r" (_BV(_WD_CHANGE_BIT) | _BV(WDE)), \
+                "r" ((uint8_t) ((value & 0x08 ? _WD_PS3_MASK : 0x00) | \
+                        _BV(WDIE) | (value & 0x07)) ) \
+        : "r0"  \
+    )
Author	SHA1	Message	Date
uvos	dca4421674	add free memory command add read and write nfc commands fix function sending	2022-03-25 13:41:02 +01:00
uvos	58fe96f8b7	add support for mfrc proxyies	2022-03-21 21:22:18 +01:00
uvos	36cc688479	softspim: allow phase mode 2 (safe phase)	2022-03-15 22:41:06 +01:00
uvos	50d233fdf7	finish single item resend	2022-03-15 22:40:37 +01:00
uvos	cf7e3f8e6b	serial: ajust rx buffer size	2022-03-15 22:40:07 +01:00
uvos	6d8baa50eb	implement single item resend	2022-03-15 22:39:13 +01:00
uvos	97aa264b54	IRQ based tag polling	2022-03-10 22:25:35 +01:00
uvos	b01caeda28	change some parameters in softspim	2022-03-10 22:25:18 +01:00
uvos	64dae0435b	change to new signelton method	2022-03-10 22:24:17 +01:00
uvos	071d13450d	fix input shift register reading	2022-03-10 22:23:38 +01:00