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:: 29:7a2dfd06cb29
Parent:: 27:3881985097bb
Child:: 31:85fdf6fd3da5
Child:: 33:e6b7e74be1d5

--- a/m24sr/NDefNfcTagM24SR.cpp	Thu Oct 27 07:38:00 2016 +0000
+++ b/m24sr/NDefNfcTagM24SR.cpp	Fri Apr 28 12:14:12 2017 +0000
@@ -2,8 +2,8 @@
   ******************************************************************************
   * @file       NdefNfcTagSTM24SR.cpp
   * @author  	ST Central Labs
-  * @version V1.1.0
-  * @date    30 Set 2016
+  * @version 	V2.0.0
+  * @date    	28 Apr 2017
   * @brief      Wrapper class of the NDefLib library to write/read NDEF messages
   ******************************************************************************
   * @attention
@@ -51,81 +51,81 @@
 	OpenSessionCallBack(NDefNfcTagM24SR& sender):
 		mSender(sender),mNTrials(OPENSESSION_NTRIALS){}
 
-void NDefNfcTagM24SR::OpenSessionCallBack::onSessionOpen(M24SR *nfc,
+void NDefNfcTagM24SR::OpenSessionCallBack::on_session_open(M24SR *nfc,
 		M24SR::StatusTypeDef status){
 	if(status==M24SR::M24SR_SUCCESS){
-		nfc->SelectApplication();
+		nfc->select_application();
 	}else{
-		mSender.mCallBack->onSessionOpen(&mSender,false);
+		mSender.mCallBack->on_session_open(&mSender,false);
 	}
 }
 
-void NDefNfcTagM24SR::OpenSessionCallBack::onSelectedApplication(M24SR *nfc,
+void NDefNfcTagM24SR::OpenSessionCallBack::on_selected_application(M24SR *nfc,
 		M24SR::StatusTypeDef status){
 	if(status==M24SR::M24SR_SUCCESS){
-		nfc->SelectCCfile();
+		nfc->select_CC_file();
 	}else{
 		if(mNTrials==0)
-			mSender.mCallBack->onSessionOpen(&mSender,false);
+			mSender.mCallBack->on_session_open(&mSender,false);
 		else{
 			mNTrials--;
-			nfc->SelectApplication();
+			nfc->select_application();
 		}//if-else
 	}//if-else
 }
 
-void NDefNfcTagM24SR::OpenSessionCallBack::onSelectedCCFile(M24SR *nfc,
+void NDefNfcTagM24SR::OpenSessionCallBack::on_selected_CC_file(M24SR *nfc,
 		M24SR::StatusTypeDef status){
 	if(status==M24SR::M24SR_SUCCESS){
-		nfc->ReadBinary(0x0000, CC_FILE_LENGTH_BYTE, CCFile);
+		nfc->read_binary(0x0000, CC_FILE_LENGTH_BYTE, CCFile);
 	}else{
-		mSender.mCallBack->onSessionOpen(&mSender,false);
+		mSender.mCallBack->on_session_open(&mSender,false);
 	}
 }
 
-void NDefNfcTagM24SR::OpenSessionCallBack::onReadByte(M24SR *nfc,
+void NDefNfcTagM24SR::OpenSessionCallBack::on_read_byte(M24SR *nfc,
 		M24SR::StatusTypeDef status,uint16_t offset,uint8_t *readByte, uint16_t nReadByte){
 	(void)offset;
 	if(status!=M24SR::M24SR_SUCCESS || nReadByte!=CC_FILE_LENGTH_BYTE){
-		return mSender.mCallBack->onSessionOpen(&mSender,false);
+		return mSender.mCallBack->on_session_open(&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);
+	nfc->select_NDEF_file(NDefFileId);
 }
 
-void NDefNfcTagM24SR::OpenSessionCallBack::onSelectedNDEFFile(M24SR *nfc,
+void NDefNfcTagM24SR::OpenSessionCallBack::on_selected_NDEF_file(M24SR *nfc,
 		M24SR::StatusTypeDef status){
 	(void)nfc;
 
 	mSender.mIsSessionOpen = status==M24SR::M24SR_SUCCESS;
-	mSender.mCallBack->onSessionOpen(&mSender,mSender.mIsSessionOpen);
+	mSender.mCallBack->on_session_open(&mSender,mSender.mIsSessionOpen);
 }
 ////////////////////////////END  OpenSessionCallBack/////////////////////////
 
-bool NDefNfcTagM24SR::openSession(bool force) {
+bool NDefNfcTagM24SR::open_session(bool force) {
 
-	if (isSessionOpen()){
-		mCallBack->onSessionOpen(this,true);
+	if (is_session_open()){
+		mCallBack->on_session_open(this,true);
 		return true;
 	}
 
-	mDevice.SetCallback(&mOpenSessionCallback);
+	mDevice.set_callback(&mOpenSessionCallback);
 	if(force)
-		return mDevice.ForceGetSession() == M24SR::M24SR_SUCCESS;
+		return mDevice.force_get_session() == M24SR::M24SR_SUCCESS;
 	else
-		return mDevice.GetSession() == M24SR::M24SR_SUCCESS;
+		return mDevice.get_session() == M24SR::M24SR_SUCCESS;
 
 
 }
 
-bool NDefNfcTagM24SR::closeSession() {
-	mDevice.SetCallback(&mCloseSessionCallback);
-	return mDevice.Deselect() == M24SR::M24SR_SUCCESS;
+bool NDefNfcTagM24SR::close_session() {
+	mDevice.set_callback(&mCloseSessionCallback);
+	return mDevice.deselect() == M24SR::M24SR_SUCCESS;
 }
 
-void NDefNfcTagM24SR::WriteByteCallback::onUpdatedBinary(M24SR *nfc,
+void NDefNfcTagM24SR::WriteByteCallback::on_updated_binary(M24SR *nfc,
 		M24SR::StatusTypeDef status,uint16_t startOffset, uint8_t *writeByte,uint16_t nWriteByte){
 
 	if(status!=M24SR::M24SR_SUCCESS){ // error -> finish to write
@@ -139,27 +139,27 @@
 	}else{ //else write another slice
 		uint16_t tempLenght = std::min(mSender.mMaxWriteBytes,
 				(uint16_t)(mNByteToWrite-mByteWrote));
-		nfc->UpdateBinary(startOffset+nWriteByte,tempLenght,writeByte+nWriteByte);
+		nfc->update_binary(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())
+	if(!is_session_open())
 		callback(callbackStatus,false,buffer,length);
 	//else
-	mWriteByteCallback.setTask(buffer,length,callback,callbackStatus);
-	mDevice.SetCallback(&mWriteByteCallback);
+	mWriteByteCallback.set_task(buffer,length,callback,callbackStatus);
+	mDevice.set_callback(&mWriteByteCallback);
 
 	if (length > mMaxWriteBytes) {
-		return mDevice.UpdateBinary(offset, mMaxWriteBytes,(uint8_t*) buffer) == M24SR::M24SR_SUCCESS;
+		return mDevice.update_binary(offset, mMaxWriteBytes,(uint8_t*) buffer) == M24SR::M24SR_SUCCESS;
 	}else{
-		return mDevice.UpdateBinary(offset,length,(uint8_t*)buffer) == M24SR::M24SR_SUCCESS;
+		return mDevice.update_binary(offset,length,(uint8_t*)buffer) == M24SR::M24SR_SUCCESS;
 	}//if-else
 
 }
 
-void NDefNfcTagM24SR::ReadByteCallback::onReadByte(M24SR *nfc,
+void NDefNfcTagM24SR::ReadByteCallback::on_read_byte(M24SR *nfc,
 		M24SR::StatusTypeDef status,uint16_t startOffset, uint8_t *readBffer,uint16_t nReadByte){
 
 	if(status!=M24SR::M24SR_SUCCESS){ // error -> finish to write
@@ -173,24 +173,24 @@
 	}else{ //else write another slice
 		uint16_t tempLenght = std::min(mSender.mMaxReadBytes,
 				(uint16_t)(mNByteToRead-mByteRead));
-		nfc->ReadBinary(startOffset+nReadByte,tempLenght,readBffer+nReadByte);
+		nfc->read_binary(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()){
+	if(!is_session_open()){
 		return callback(callbackStatus,false,buffer,length);
 	}
 	//else
-	mReadByteCallback.setTask(buffer,length,callback,callbackStatus);
-	mDevice.SetCallback(&mReadByteCallback);
+	mReadByteCallback.set_task(buffer,length,callback,callbackStatus);
+	mDevice.set_callback(&mReadByteCallback);
 
 	if (length > mMaxReadBytes) {
-		return mDevice.ReadBinary(byteOffset, mMaxReadBytes,buffer)== M24SR::M24SR_SUCCESS;;
+		return mDevice.read_binary(byteOffset, mMaxReadBytes,buffer)== M24SR::M24SR_SUCCESS;;
 	}else{
-		return mDevice.ReadBinary(byteOffset,length,buffer)== M24SR::M24SR_SUCCESS;;
+		return mDevice.read_binary(byteOffset,length,buffer)== M24SR::M24SR_SUCCESS;;
 	}//if-else
 
 }