X-NUCLEO-NFC01A1 Dynamic NFC Tag Expansion Board Firmware Package

Introduction

This firmware package includes Components Device Drivers, Board Support Package and example applications for STMicroelectronics X-NUCLEO-NFC01A1 Dynamic NFC Tag Expansion Board based on M24SR.

Firmware Library

Class X_NUCLEO_NFC01A1 is intended to represent the Dynamic NFC Tag Expansion Board with the same name.
It provides an API to access to the M24SR component and to the three onboard LEDs.
It is intentionally implemented as a singleton because only one X_NUCLEO_NFC01A1 at a time might be deployed in a HW component stack.
The library also provides an implementation of the NDEF library API for M24SR, providing an simple way to read/write NDEF formatted messages from/to the M24SR dynamic NFC tag.

Example applications

1. Hello World
2. Asynchronous Hello World

Diff: m24sr/NDefNfcTagM24SR.cpp

Revision:: 19:0b65a5813059
Parent:: 16:b0d62f4b185a
Child:: 20:aad5727cb8c6

--- a/m24sr/NDefNfcTagM24SR.cpp	Fri Jan 22 09:04:51 2016 +0000
+++ b/m24sr/NDefNfcTagM24SR.cpp	Thu Jan 28 14:01:18 2016 +0000
@@ -2,7 +2,7 @@
   ******************************************************************************
   * @file       NdefNfcTagSTM24SR.cpp
   * @author  	ST Central Labs
-  * @version 	V1.0.0 
+  * @version 	V1.0.0
   * @date       05 Nov 2015
   * @brief      wrapper class for use the NDefLib library for write/read ndef message
   ******************************************************************************
@@ -34,128 +34,163 @@
   *
   ******************************************************************************
   */
-#include "mbed.h"
+
+#include <cmath>
 
 #include "NDefNfcTagM24SR.h"
 
+
 /* wait 1sec, driver is configured to let 200ms for command to complete */
 /* which is enough for all commands except GetSession if RF session is already opened */
 /* Smartphone generally releases the session within the second, anyway the user can modify this value */
 #define OPENSESSION_NTRIALS 5
 
 #define CC_FILE_LENGTH_BYTE 15
+////////////////////////////START  OpenSessionCallBack/////////////////////////
+NDefNfcTagM24SR::OpenSessionCallBack::
+	OpenSessionCallBack(NDefNfcTagM24SR& sender):
+		mSender(sender),mNTrials(OPENSESSION_NTRIALS){}
+
+void NDefNfcTagM24SR::OpenSessionCallBack::onSessionOpen(Nfc *nfc,
+		NFC_StatusTypeDef status){
+	if(status==NFC_SUCCESS){
+		nfc->SelectApplication();
+	}else{
+		mSender.mCallBack->onSessionOpen(&mSender,false);
+	}
+}
+
+void NDefNfcTagM24SR::OpenSessionCallBack::onSelectedApplication(Nfc *nfc,
+		NFC_StatusTypeDef status){
+	if(status==NFC_SUCCESS){
+		nfc->SelectCCfile();
+	}else{
+		if(mNTrials==0)
+			mSender.mCallBack->onSessionOpen(&mSender,false);
+		else{
+			mNTrials--;
+			nfc->SelectApplication();
+		}//if-else
+	}//if-else
+}
+
+void NDefNfcTagM24SR::OpenSessionCallBack::onSelectedCCFile(Nfc *nfc,
+		NFC_StatusTypeDef status){
+	if(status==NFC_SUCCESS){
+		nfc->ReadBinary(0x0000, CC_FILE_LENGTH_BYTE, CCFile);
+	}else{
+		mSender.mCallBack->onSessionOpen(&mSender,false);
+	}
+}
+
+void NDefNfcTagM24SR::OpenSessionCallBack::onReadByte(Nfc *nfc,
+		NFC_StatusTypeDef status,uint16_t offset,uint8_t *readByte, uint16_t nReadByte){
+	(void)offset;
+	if(status!=NFC_SUCCESS || nReadByte!=CC_FILE_LENGTH_BYTE){
+		return mSender.mCallBack->onSessionOpen(&mSender,false);
+	}//else
+	uint16_t NDefFileId = (uint16_t) ((readByte[0x09] << 8) | readByte[0x0A]);
+	mSender.mMaxReadBytes = (uint16_t) ((readByte[0x03] << 8) | readByte[0x04]);
+	mSender.mMaxWriteBytes = (uint16_t) ((readByte[0x05] << 8) | readByte[0x06]);
+	nfc->SelectNDEFfile(NDefFileId);
+}
+
+void NDefNfcTagM24SR::OpenSessionCallBack::onSelectedNDEFFile(Nfc *nfc,
+		NFC_StatusTypeDef status){
+	(void)nfc;
+	mSender.mIsSessionOpen = status==NFC_SUCCESS;
+	mSender.mCallBack->onSessionOpen(&mSender,mSender.mIsSessionOpen);
+}
+////////////////////////////END  OpenSessionCallBack/////////////////////////
 
 bool NDefNfcTagM24SR::openSession(bool force) {
 
-	if (isSessionOpen())
+	if (isSessionOpen()){
+		mCallBack->onSessionOpen(this,true);
 		return true;
-	//else
-	if (force)
-		mDevice.KillSession();
-
-	int8_t nTrials = OPENSESSION_NTRIALS;
-	NFC_StatusTypeDef status = NFC_ERROR;
-	while (status != NFC_SUCCESS && nTrials) {
-		status = mDevice.GetSession();
-		nTrials--;
 	}
 
-	if (status != NFC_SUCCESS) {
-		return false;
-	} //else
-
-	//Select the NFC type 4 application
-	if (mDevice.SelectApplication() != NFC_SUCCESS){
-		return false;
-	}
-
-	if (mDevice.SelectCCfile() != NFC_SUCCESS){
-		return false;
-	}
+	mDevice.SetCallBack(&mOpenSessionCallback);
+	if(force)
+		return mDevice.KillSession() == NFC_SUCCESS;
+	else
+		return mDevice.GetSession() == NFC_SUCCESS;
 
-	uint8_t CCFile[CC_FILE_LENGTH_BYTE];
-	/* read the first 15 bytes of the CC file */
-	if (mDevice.ReadBinary(0x0000, CC_FILE_LENGTH_BYTE, CCFile) != NFC_SUCCESS)
-		return false;
 
-	//read the ndefFileId
-	uint16_t ndefFileId = (uint16_t) ((CCFile[0x09] << 8) | CCFile[0x0A]);
-	mMaxReadBytes = (uint16_t) ((CCFile[0x03] << 8) | CCFile[0x04]);
-	mMaxWriteBytes = (uint16_t) ((CCFile[0x05] << 8) | CCFile[0x06]);
-
-	//open it
-	if (mDevice.SelectNDEFfile(ndefFileId) != NFC_SUCCESS)
-		return false;
-
-	NDefNfcTag::openSession();
-	return true;
 }
 
 bool NDefNfcTagM24SR::closeSession() {
-
-	//no open session
-	if (!isSessionOpen())
-		return true;
-
-	//close the CC file
-	if (mDevice.Deselect() != NFC_SUCCESS)
-		return false;
-
-	NDefNfcTag::closeSession();
-	return true;
+	mDevice.SetCallBack(&mCloseSessionCallback);
+	return mDevice.Deselect() == NFC_SUCCESS;
 }
 
-bool NDefNfcTagM24SR::writeByte(const uint8_t *buffer, uint16_t length, uint16_t offset) {
+void NDefNfcTagM24SR::WriteByteCallback::onUpdatedBinary(Nfc *nfc,
+		NFC_StatusTypeDef status,uint16_t startOffset, uint8_t *writeByte,uint16_t nWriteByte){
 
-	//no open session
-	if (!isSessionOpen())
-		return false;
+	if(status!=NFC_SUCCESS){ // error -> finish to write
+		mCallback(mCallbackParam,false,mByteToWrite,mNByteToWrite);
+		return;
+	}//else
 
-	NFC_StatusTypeDef status = NFC_SUCCESS;
-	bool prevSessionStatus = isSessionOpen();
-	if (!prevSessionStatus) {
-		//try to acquire a session or fail
-		if (openSession(false))
-			return false;
-	} //if
+	mByteWrote+=nWriteByte;
+	if(mByteWrote==mNByteToWrite){ //write all -> finish
+		mCallback(mCallbackParam,true,mByteToWrite,mNByteToWrite);
+	}else{ //else write another slice
+		uint16_t tempLenght = std::min(mSender.mMaxWriteBytes,
+				(uint16_t)(mNByteToWrite-mByteWrote));
+		nfc->UpdateBinary(startOffset+nWriteByte,tempLenght,writeByte+nWriteByte);
+	}//if-else
+}
+
+bool NDefNfcTagM24SR::writeByte(const uint8_t *buffer, uint16_t length,uint16_t offset,
+		byteOperationCallback_t callback,CallbackStatus_t *callbackStatus){
+	if(!isSessionOpen())
+		callback(callbackStatus,false,buffer,length);
+	//else
+	mWriteByteCallback.setTask(buffer,length,callback,callbackStatus);
+	mDevice.SetCallBack(&mWriteByteCallback);
 
 	if (length > mMaxWriteBytes) {
-		do {
-			status = mDevice.UpdateBinary(offset, mMaxWriteBytes,(uint8_t*) buffer);
-			offset += mMaxWriteBytes;
-			buffer += mMaxWriteBytes;
-			length -= mMaxWriteBytes;
-		} while (length > mMaxWriteBytes && status == NFC_SUCCESS);
-	} //if
+		return mDevice.UpdateBinary(offset, mMaxWriteBytes,(uint8_t*) buffer) == NFC_SUCCESS;
+	}else{
+		return mDevice.UpdateBinary(offset,length,(uint8_t*)buffer) == NFC_SUCCESS;
+	}//if-else
 
-	//finish to write the buffer
-	if (status == NFC_SUCCESS && mMaxWriteBytes)
-		status = mDevice.UpdateBinary(offset, length,(uint8_t*) buffer);
-
-	return status==NFC_SUCCESS;
 }
 
-bool NDefNfcTagM24SR::readByte(uint16_t byteOffset, uint16_t byteLength,
-		uint8_t *buffer) {
-			
-	//no open session
-	if (!isSessionOpen())
-		return false;
-		
-	NFC_StatusTypeDef status = NFC_SUCCESS;
-	uint16_t offset = byteOffset;
-	if (byteLength > mMaxReadBytes) {
-		do {
-			status = mDevice.ReadBinary(offset, mMaxReadBytes, buffer);
-			offset += mMaxReadBytes;
-			buffer += mMaxReadBytes;
-			byteLength -= mMaxReadBytes;
-		} while (byteLength > mMaxWriteBytes && status == NFC_SUCCESS);
-	} //if
-	  //finish to write the buffer
-	if (status == NFC_SUCCESS && mMaxWriteBytes)
-		status = mDevice.ReadBinary(offset, byteLength, buffer);
+void NDefNfcTagM24SR::ReadByteCallback::onReadByte(Nfc *nfc,
+		NFC_StatusTypeDef status,uint16_t startOffset, uint8_t *readBffer,uint16_t nReadByte){
+
+	if(status!=NFC_SUCCESS){ // error -> finish to write
+		mCallback(mCallbackParam,false,mBuffer,mNByteToRead);
+		return;
+	}//else
 
-	return status == NFC_SUCCESS;
+	mByteRead += nReadByte;
+	if(mByteRead==mNByteToRead){ //read all -> finish
+		mCallback(mCallbackParam,true,mBuffer,mNByteToRead);
+	}else{ //else write another slice
+		uint16_t tempLenght = std::min(mSender.mMaxReadBytes,
+				(uint16_t)(mNByteToRead-mByteRead));
+		nfc->ReadBinary(startOffset+nReadByte,tempLenght,readBffer+nReadByte);
+	}//if-else
+
 }
 
+bool NDefNfcTagM24SR::readByte(const uint16_t byteOffset, const uint16_t length,
+		uint8_t *buffer, byteOperationCallback_t callback,CallbackStatus_t *callbackStatus){
+	if(!isSessionOpen()){
+		return callback(callbackStatus,false,buffer,length);
+	}
+	//else
+	mReadByteCallback.setTask(buffer,length,callback,callbackStatus);
+	mDevice.SetCallBack(&mReadByteCallback);
+
+	if (length > mMaxReadBytes) {
+		return mDevice.ReadBinary(byteOffset, mMaxReadBytes,buffer)== NFC_SUCCESS;;
+	}else{
+		return mDevice.ReadBinary(byteOffset,length,buffer)== NFC_SUCCESS;;
+	}//if-else
+
+}
+