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

m24sr/M24SR.cpp@31:85fdf6fd3da5, 2017-05-15 (annotated)

Committer:: giovannivisentini
Date:: Mon May 15 13:47:03 2017 +0000
Revision:: 31:85fdf6fd3da5
Parent:: 29:7a2dfd06cb29

remove M24SR_IO_PollI2C function

Who changed what in which revision?

User	Revision	Line number	New contents of line
giovannivisentini	29:7a2dfd06cb29	1	/**
giovannivisentini	29:7a2dfd06cb29	2	******************************************************************************
giovannivisentini	29:7a2dfd06cb29	3	* @file m24sr_class.cpp
giovannivisentini	29:7a2dfd06cb29	4	* @author ST Central Labs
giovannivisentini	29:7a2dfd06cb29	5	* @version V2.0.0
giovannivisentini	29:7a2dfd06cb29	6	* @date 28 Apr 2017
giovannivisentini	29:7a2dfd06cb29	7	* @brief This file provides a set of functions to interface with the M24SR
giovannivisentini	29:7a2dfd06cb29	8	* device.
giovannivisentini	29:7a2dfd06cb29	9	******************************************************************************
giovannivisentini	29:7a2dfd06cb29	10	* @attention
giovannivisentini	29:7a2dfd06cb29	11	*
giovannivisentini	29:7a2dfd06cb29	12	* <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
giovannivisentini	29:7a2dfd06cb29	13	*
giovannivisentini	29:7a2dfd06cb29	14	* Redistribution and use in source and binary forms, with or without modification,
giovannivisentini	29:7a2dfd06cb29	15	* are permitted provided that the following conditions are met:
giovannivisentini	29:7a2dfd06cb29	16	* 1. Redistributions of source code must retain the above copyright notice,
giovannivisentini	29:7a2dfd06cb29	17	* this list of conditions and the following disclaimer.
giovannivisentini	29:7a2dfd06cb29	18	* 2. Redistributions in binary form must reproduce the above copyright notice,
giovannivisentini	29:7a2dfd06cb29	19	* this list of conditions and the following disclaimer in the documentation
giovannivisentini	29:7a2dfd06cb29	20	* and/or other materials provided with the distribution.
giovannivisentini	29:7a2dfd06cb29	21	* 3. Neither the name of STMicroelectronics nor the names of its contributors
giovannivisentini	29:7a2dfd06cb29	22	* may be used to endorse or promote products derived from this software
giovannivisentini	29:7a2dfd06cb29	23	* without specific prior written permission.
giovannivisentini	29:7a2dfd06cb29	24	*
giovannivisentini	29:7a2dfd06cb29	25	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
giovannivisentini	29:7a2dfd06cb29	26	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
giovannivisentini	29:7a2dfd06cb29	27	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
giovannivisentini	29:7a2dfd06cb29	28	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
giovannivisentini	29:7a2dfd06cb29	29	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
giovannivisentini	29:7a2dfd06cb29	30	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
giovannivisentini	29:7a2dfd06cb29	31	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
giovannivisentini	29:7a2dfd06cb29	32	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
giovannivisentini	29:7a2dfd06cb29	33	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
giovannivisentini	29:7a2dfd06cb29	34	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
giovannivisentini	29:7a2dfd06cb29	35	*
giovannivisentini	29:7a2dfd06cb29	36	******************************************************************************
giovannivisentini	29:7a2dfd06cb29	37	*/
giovannivisentini	29:7a2dfd06cb29	38
giovannivisentini	29:7a2dfd06cb29	39
giovannivisentini	29:7a2dfd06cb29	40
giovannivisentini	29:7a2dfd06cb29	41	/* Includes ------------------------------------------------------------------*/
giovannivisentini	29:7a2dfd06cb29	42	#include "m24sr_def.h"
giovannivisentini	29:7a2dfd06cb29	43	#include "M24SR.h"
giovannivisentini	29:7a2dfd06cb29	44	#include "NDefNfcTagM24SR.h"
giovannivisentini	29:7a2dfd06cb29	45
giovannivisentini	29:7a2dfd06cb29	46	#ifdef GPIO_PIN_RESET
giovannivisentini	29:7a2dfd06cb29	47	#undef GPIO_PIN_RESET
giovannivisentini	29:7a2dfd06cb29	48	#endif
giovannivisentini	29:7a2dfd06cb29	49	#define GPIO_PIN_RESET (0)
giovannivisentini	29:7a2dfd06cb29	50
giovannivisentini	29:7a2dfd06cb29	51	#ifdef GPIO_PIN_SET
giovannivisentini	29:7a2dfd06cb29	52	#undef GPIO_PIN_SET
giovannivisentini	29:7a2dfd06cb29	53	#endif
giovannivisentini	29:7a2dfd06cb29	54	#define GPIO_PIN_SET (1)
giovannivisentini	29:7a2dfd06cb29	55
giovannivisentini	29:7a2dfd06cb29	56	#define M24SR_MAX_BYTE_OPERATION_LENGHT (246)
giovannivisentini	29:7a2dfd06cb29	57
giovannivisentini	31:85fdf6fd3da5	58	#define M24SR_MAX_I2C_ACCESS_TRY 1000
giovannivisentini	31:85fdf6fd3da5	59
giovannivisentini	29:7a2dfd06cb29	60	/**
giovannivisentini	29:7a2dfd06cb29	61	* default password, also used to enable super user mode through the I2C channel
giovannivisentini	29:7a2dfd06cb29	62	*/
giovannivisentini	29:7a2dfd06cb29	63	const uint8_t M24SR::DEFAULT_PASSWORD[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
giovannivisentini	29:7a2dfd06cb29	64	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
giovannivisentini	29:7a2dfd06cb29	65
giovannivisentini	29:7a2dfd06cb29	66	/** @addtogroup M24SR_Driver
giovannivisentini	29:7a2dfd06cb29	67	* @{
giovannivisentini	29:7a2dfd06cb29	68	* @brief <b>This folder contains the driver layer of M24SR family (M24SR64, M24SR16, M24SR04, M24SR02)</b>
giovannivisentini	29:7a2dfd06cb29	69	*/
giovannivisentini	29:7a2dfd06cb29	70
giovannivisentini	29:7a2dfd06cb29	71	/** @defgroup drv_M24SR
giovannivisentini	29:7a2dfd06cb29	72	* @{
giovannivisentini	29:7a2dfd06cb29	73	* @brief This file contains the driver which implements all the M24SR commands.
giovannivisentini	29:7a2dfd06cb29	74	*/
giovannivisentini	29:7a2dfd06cb29	75
giovannivisentini	29:7a2dfd06cb29	76	#ifndef errchk
giovannivisentini	29:7a2dfd06cb29	77
giovannivisentini	29:7a2dfd06cb29	78	/** value returned by the NFC chip when a command is successfully completed */
giovannivisentini	29:7a2dfd06cb29	79	#define NFC_COMMAND_SUCCESS 0x9000
giovannivisentini	29:7a2dfd06cb29	80
giovannivisentini	29:7a2dfd06cb29	81	/** call the fCall function and check that the return status is M24SR_SUCCESS,
giovannivisentini	29:7a2dfd06cb29	82	* otherwise return the error status*/
giovannivisentini	29:7a2dfd06cb29	83	#define errchk(fCall) {\
giovannivisentini	29:7a2dfd06cb29	84	const int status = (int) (fCall); \
giovannivisentini	29:7a2dfd06cb29	85	if((status!=M24SR_SUCCESS)){ \
giovannivisentini	29:7a2dfd06cb29	86	return (M24SR::StatusTypeDef)status; \
giovannivisentini	29:7a2dfd06cb29	87	}\
giovannivisentini	29:7a2dfd06cb29	88	}
giovannivisentini	29:7a2dfd06cb29	89	#endif
giovannivisentini	29:7a2dfd06cb29	90
giovannivisentini	29:7a2dfd06cb29	91	/**
giovannivisentini	29:7a2dfd06cb29	92	* @brief This function updates the CRC
giovannivisentini	29:7a2dfd06cb29	93	* @param None
giovannivisentini	29:7a2dfd06cb29	94	* @retval None
giovannivisentini	29:7a2dfd06cb29	95	*/
giovannivisentini	29:7a2dfd06cb29	96	static uint16_t M24SR_UpdateCrc(uint8_t ch, uint16_t *lpwCrc) {
giovannivisentini	29:7a2dfd06cb29	97	ch = (ch ^ (uint8_t) ((*lpwCrc) & 0x00FF));
giovannivisentini	29:7a2dfd06cb29	98	ch = (ch ^ (ch << 4));
giovannivisentini	29:7a2dfd06cb29	99	lpwCrc = (lpwCrc >> 8) ^ ((uint16_t) ch << 8) ^ ((uint16_t) ch << 3)
giovannivisentini	29:7a2dfd06cb29	100	^ ((uint16_t) ch >> 4);
giovannivisentini	29:7a2dfd06cb29	101
giovannivisentini	29:7a2dfd06cb29	102	return (*lpwCrc);
giovannivisentini	29:7a2dfd06cb29	103	}
giovannivisentini	29:7a2dfd06cb29	104
giovannivisentini	29:7a2dfd06cb29	105	/**
giovannivisentini	29:7a2dfd06cb29	106	* @brief This function returns the CRC 16
giovannivisentini	29:7a2dfd06cb29	107	* @param Data : pointer on the data used to compute the CRC16
giovannivisentini	29:7a2dfd06cb29	108	* @param Length : number of bytes of the data
giovannivisentini	29:7a2dfd06cb29	109	* @retval CRC16
giovannivisentini	29:7a2dfd06cb29	110	*/
giovannivisentini	29:7a2dfd06cb29	111	static uint16_t M24SR_ComputeCrc(uint8_t *Data, uint8_t Length) {
giovannivisentini	29:7a2dfd06cb29	112	uint8_t chBlock;
giovannivisentini	29:7a2dfd06cb29	113	uint16_t wCrc = 0x6363; // ITU-V.41
giovannivisentini	29:7a2dfd06cb29	114
giovannivisentini	29:7a2dfd06cb29	115	do {
giovannivisentini	29:7a2dfd06cb29	116	chBlock = *Data++;
giovannivisentini	29:7a2dfd06cb29	117	M24SR_UpdateCrc(chBlock, &wCrc);
giovannivisentini	29:7a2dfd06cb29	118	} while (--Length);
giovannivisentini	29:7a2dfd06cb29	119
giovannivisentini	29:7a2dfd06cb29	120	return wCrc;
giovannivisentini	29:7a2dfd06cb29	121	}
giovannivisentini	29:7a2dfd06cb29	122
giovannivisentini	29:7a2dfd06cb29	123	/**
giovannivisentini	29:7a2dfd06cb29	124	* @brief This function computes the CRC16 residue as defined by CRC ISO/IEC 13239
giovannivisentini	29:7a2dfd06cb29	125	* @param DataIn : input data
giovannivisentini	29:7a2dfd06cb29	126	* @param Length : Number of bits of DataIn
giovannivisentini	29:7a2dfd06cb29	127	* @retval Status (SW1&SW2) : CRC16 residue is correct
giovannivisentini	29:7a2dfd06cb29	128	* @retval M24SR_ERROR_CRC : CRC16 residue is false
giovannivisentini	29:7a2dfd06cb29	129	*/
giovannivisentini	29:7a2dfd06cb29	130	static M24SR::StatusTypeDef M24SR_IsCorrectCRC16Residue(uint8_t *DataIn, uint8_t Length) {
giovannivisentini	29:7a2dfd06cb29	131	uint16_t ResCRC = 0x0000;
giovannivisentini	29:7a2dfd06cb29	132	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	133	/* check the CRC16 Residue */
giovannivisentini	29:7a2dfd06cb29	134	if (Length != 0)
giovannivisentini	29:7a2dfd06cb29	135	ResCRC = M24SR_ComputeCrc(DataIn, Length);
giovannivisentini	29:7a2dfd06cb29	136
giovannivisentini	29:7a2dfd06cb29	137	if (ResCRC == 0x0000) {
giovannivisentini	29:7a2dfd06cb29	138	/* Good CRC, but error status from M24SR */
giovannivisentini	29:7a2dfd06cb29	139	status = (M24SR::StatusTypeDef) (((DataIn[Length - UB_STATUS_OFFSET] << 8)
giovannivisentini	29:7a2dfd06cb29	140	& 0xFF00) \| (DataIn[Length - LB_STATUS_OFFSET] & 0x00FF));
giovannivisentini	29:7a2dfd06cb29	141	} else {
giovannivisentini	29:7a2dfd06cb29	142	ResCRC = 0x0000;
giovannivisentini	29:7a2dfd06cb29	143	ResCRC = M24SR_ComputeCrc(DataIn, 5);
giovannivisentini	29:7a2dfd06cb29	144	if (ResCRC != 0x0000) {
giovannivisentini	29:7a2dfd06cb29	145	/* Bad CRC */
giovannivisentini	29:7a2dfd06cb29	146	return M24SR::M24SR_IO_ERROR_CRC;
giovannivisentini	29:7a2dfd06cb29	147	} else {
giovannivisentini	29:7a2dfd06cb29	148	/* Good CRC, but error status from M24SR */
giovannivisentini	29:7a2dfd06cb29	149	status= (M24SR::StatusTypeDef) (((DataIn[1] << 8) & 0xFF00)
giovannivisentini	29:7a2dfd06cb29	150	\| (DataIn[2] & 0x00FF));
giovannivisentini	29:7a2dfd06cb29	151	}
giovannivisentini	29:7a2dfd06cb29	152	}
giovannivisentini	29:7a2dfd06cb29	153	if(status==NFC_COMMAND_SUCCESS) status = M24SR::M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	154	return status;
giovannivisentini	29:7a2dfd06cb29	155	}
giovannivisentini	29:7a2dfd06cb29	156
giovannivisentini	29:7a2dfd06cb29	157	/**
giovannivisentini	29:7a2dfd06cb29	158	* @brief This functions creates an I block command according to the structures CommandStructure and Command.
giovannivisentini	29:7a2dfd06cb29	159	* @param Command : structure which contains the field of the different parameters
giovannivisentini	29:7a2dfd06cb29	160	* @param CommandStructure : structure of the command
giovannivisentini	29:7a2dfd06cb29	161	* @param NbByte : number of bytes of the command
giovannivisentini	29:7a2dfd06cb29	162	* @param pCommand : pointer to the command created
giovannivisentini	29:7a2dfd06cb29	163	*/
giovannivisentini	29:7a2dfd06cb29	164	static void M24SR_BuildIBlockCommand(uint16_t CommandStructure, C_APDU *Command,
giovannivisentini	29:7a2dfd06cb29	165	uint8_t uDIDbyte, uint16_t NbByte, uint8_t pCommand) {
giovannivisentini	29:7a2dfd06cb29	166	uint16_t uCRC16;
giovannivisentini	29:7a2dfd06cb29	167	static uint8_t BlockNumber = 0x01;
giovannivisentini	29:7a2dfd06cb29	168
giovannivisentini	29:7a2dfd06cb29	169	(*NbByte) = 0;
giovannivisentini	29:7a2dfd06cb29	170
giovannivisentini	29:7a2dfd06cb29	171	/* add the PCD byte */
giovannivisentini	29:7a2dfd06cb29	172	if ((CommandStructure & M24SR_PCB_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	173	/* toggle the block number */
giovannivisentini	29:7a2dfd06cb29	174	BlockNumber = TOGGLE(BlockNumber);
giovannivisentini	29:7a2dfd06cb29	175	/* Add the I block byte */
giovannivisentini	29:7a2dfd06cb29	176	pCommand[(*NbByte)++] = 0x02 \| BlockNumber;
giovannivisentini	29:7a2dfd06cb29	177	}
giovannivisentini	29:7a2dfd06cb29	178
giovannivisentini	29:7a2dfd06cb29	179	/* add the DID byte */
giovannivisentini	29:7a2dfd06cb29	180	if ((BlockNumber & M24SR_DID_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	181	/* Add the I block byte */
giovannivisentini	29:7a2dfd06cb29	182	pCommand[(*NbByte)++] = uDIDbyte;
giovannivisentini	29:7a2dfd06cb29	183	}
giovannivisentini	29:7a2dfd06cb29	184
giovannivisentini	29:7a2dfd06cb29	185	/* add the Class byte */
giovannivisentini	29:7a2dfd06cb29	186	if ((CommandStructure & M24SR_CLA_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	187	pCommand[(*NbByte)++] = Command->Header.CLA;
giovannivisentini	29:7a2dfd06cb29	188	}
giovannivisentini	29:7a2dfd06cb29	189	/* add the instruction byte byte */
giovannivisentini	29:7a2dfd06cb29	190	if ((CommandStructure & M24SR_INS_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	191	pCommand[(*NbByte)++] = Command->Header.INS;
giovannivisentini	29:7a2dfd06cb29	192	}
giovannivisentini	29:7a2dfd06cb29	193	/* add the Selection Mode byte */
giovannivisentini	29:7a2dfd06cb29	194	if ((CommandStructure & M24SR_P1_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	195	pCommand[(*NbByte)++] = Command->Header.P1;
giovannivisentini	29:7a2dfd06cb29	196	}
giovannivisentini	29:7a2dfd06cb29	197	/* add the Selection Mode byte */
giovannivisentini	29:7a2dfd06cb29	198	if ((CommandStructure & M24SR_P2_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	199	pCommand[(*NbByte)++] = Command->Header.P2;
giovannivisentini	29:7a2dfd06cb29	200	}
giovannivisentini	29:7a2dfd06cb29	201	/* add Data field lengthbyte */
giovannivisentini	29:7a2dfd06cb29	202	if ((CommandStructure & M24SR_LC_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	203	pCommand[(*NbByte)++] = Command->Body.LC;
giovannivisentini	29:7a2dfd06cb29	204	}
giovannivisentini	29:7a2dfd06cb29	205	/* add Data field */
giovannivisentini	29:7a2dfd06cb29	206	if ((CommandStructure & M24SR_DATA_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	207	memcpy(&(pCommand[(*NbByte)]), Command->Body.pData, Command->Body.LC);
giovannivisentini	29:7a2dfd06cb29	208	(*NbByte) += Command->Body.LC;
giovannivisentini	29:7a2dfd06cb29	209	}
giovannivisentini	29:7a2dfd06cb29	210	/* add Le field */
giovannivisentini	29:7a2dfd06cb29	211	if ((CommandStructure & M24SR_LE_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	212	pCommand[(*NbByte)++] = Command->Body.LE;
giovannivisentini	29:7a2dfd06cb29	213	}
giovannivisentini	29:7a2dfd06cb29	214	/* add CRC field */
giovannivisentini	29:7a2dfd06cb29	215	if ((CommandStructure & M24SR_CRC_NEEDED) != 0) {
giovannivisentini	29:7a2dfd06cb29	216	uCRC16 = M24SR_ComputeCrc(pCommand, (uint8_t) (*NbByte));
giovannivisentini	29:7a2dfd06cb29	217	/* append the CRC16 */
giovannivisentini	29:7a2dfd06cb29	218	pCommand[(*NbByte)++] = GETLSB(uCRC16);
giovannivisentini	29:7a2dfd06cb29	219	pCommand[(*NbByte)++] = GETMSB(uCRC16);
giovannivisentini	29:7a2dfd06cb29	220	}
giovannivisentini	29:7a2dfd06cb29	221
giovannivisentini	29:7a2dfd06cb29	222	}
giovannivisentini	29:7a2dfd06cb29	223
giovannivisentini	29:7a2dfd06cb29	224
giovannivisentini	29:7a2dfd06cb29	225
giovannivisentini	29:7a2dfd06cb29	226
giovannivisentini	29:7a2dfd06cb29	227	/**
giovannivisentini	29:7a2dfd06cb29	228	* @brief This function returns M24SR_STATUS_SUCCESS if the pBuffer is an s-block
giovannivisentini	29:7a2dfd06cb29	229	* @param pBuffer : pointer to the data
giovannivisentini	29:7a2dfd06cb29	230	* @retval M24SR_SUCCESS : the data is a S-Block
giovannivisentini	29:7a2dfd06cb29	231	* @retval NFC_ERROR : the data is not a S-Block
giovannivisentini	29:7a2dfd06cb29	232	*/
giovannivisentini	29:7a2dfd06cb29	233	static M24SR::StatusTypeDef IsSBlock(uint8_t *pBuffer) {
giovannivisentini	29:7a2dfd06cb29	234
giovannivisentini	29:7a2dfd06cb29	235	if ((pBuffer[M24SR_OFFSET_PCB] & M24SR_MASK_BLOCK) == M24SR_MASK_SBLOCK) {
giovannivisentini	29:7a2dfd06cb29	236	return M24SR::M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	237	} else {
giovannivisentini	29:7a2dfd06cb29	238	return M24SR::M24SR_ERROR;
giovannivisentini	29:7a2dfd06cb29	239	}
giovannivisentini	29:7a2dfd06cb29	240
giovannivisentini	29:7a2dfd06cb29	241	}
giovannivisentini	29:7a2dfd06cb29	242
giovannivisentini	29:7a2dfd06cb29	243
giovannivisentini	29:7a2dfd06cb29	244	M24SR::M24SR(const uint8_t address, I2C &I2C,gpoEventCallback eventCallback, const PinName& GPOPinName,
giovannivisentini	29:7a2dfd06cb29	245	const PinName& RFDISPinName) :
giovannivisentini	29:7a2dfd06cb29	246	who_am_i(0),
giovannivisentini	29:7a2dfd06cb29	247	type(0),
giovannivisentini	29:7a2dfd06cb29	248	address(address),
giovannivisentini	29:7a2dfd06cb29	249	dev_I2C(I2C),
giovannivisentini	29:7a2dfd06cb29	250	GPOPin(GPOPinName),
giovannivisentini	29:7a2dfd06cb29	251	RFDisablePin(RFDISPinName),
giovannivisentini	29:7a2dfd06cb29	252	mCommunicationType(SYNC),
giovannivisentini	29:7a2dfd06cb29	253	mLastCommandSend(NONE),
giovannivisentini	29:7a2dfd06cb29	254	mGpoEventInterrupt(GPOPinName),
giovannivisentini	29:7a2dfd06cb29	255	mCallback(&defaultCallback),
giovannivisentini	29:7a2dfd06cb29	256	mComponentCallback(NULL),
giovannivisentini	29:7a2dfd06cb29	257	mNDefTagUtil(new NDefNfcTagM24SR(*this)),
giovannivisentini	29:7a2dfd06cb29	258	mManageGPOCallback(*this),
giovannivisentini	29:7a2dfd06cb29	259	mReadIDCallback(*this){
giovannivisentini	29:7a2dfd06cb29	260	//mNDefTagUtil(NULL){
giovannivisentini	29:7a2dfd06cb29	261	memset(uM24SRbuffer, 0, 0xFF * sizeof(int8_t));
giovannivisentini	29:7a2dfd06cb29	262	uDIDbyte = 0;
giovannivisentini	29:7a2dfd06cb29	263	if(RFDisablePin.is_connected()!=0)
giovannivisentini	29:7a2dfd06cb29	264	RFDisablePin = 0;
giovannivisentini	29:7a2dfd06cb29	265	if(GPOPin.is_connected()!=0){
giovannivisentini	29:7a2dfd06cb29	266	if(eventCallback!=NULL)
giovannivisentini	29:7a2dfd06cb29	267	mGpoEventInterrupt.fall(eventCallback);
giovannivisentini	29:7a2dfd06cb29	268	mGpoEventInterrupt.mode(PullUp);
giovannivisentini	29:7a2dfd06cb29	269	mGpoEventInterrupt.disable_irq();
giovannivisentini	29:7a2dfd06cb29	270	}
giovannivisentini	29:7a2dfd06cb29	271	}
giovannivisentini	29:7a2dfd06cb29	272
giovannivisentini	29:7a2dfd06cb29	273	M24SR::~M24SR(){
giovannivisentini	29:7a2dfd06cb29	274	delete mNDefTagUtil;
giovannivisentini	29:7a2dfd06cb29	275	}
giovannivisentini	29:7a2dfd06cb29	276
giovannivisentini	29:7a2dfd06cb29	277	/**
giovannivisentini	29:7a2dfd06cb29	278	* @brief This function sends the FWT extension command (S-Block format)
giovannivisentini	29:7a2dfd06cb29	279	* @param FWTbyte : FWT value
giovannivisentini	29:7a2dfd06cb29	280	* @return M24SR_SUCCESS if no errors
giovannivisentini	29:7a2dfd06cb29	281	*/
giovannivisentini	29:7a2dfd06cb29	282	M24SR::StatusTypeDef M24SR::M24SR_SendFWTExtension(uint8_t FWTbyte) {
giovannivisentini	29:7a2dfd06cb29	283	uint8_t pBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	284	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	285	uint8_t NthByte = 0;
giovannivisentini	29:7a2dfd06cb29	286	uint16_t uCRC16;
giovannivisentini	29:7a2dfd06cb29	287
giovannivisentini	29:7a2dfd06cb29	288	/* create the response */
giovannivisentini	29:7a2dfd06cb29	289	pBuffer[NthByte++] = 0xF2;
giovannivisentini	29:7a2dfd06cb29	290	pBuffer[NthByte++] = FWTbyte;
giovannivisentini	29:7a2dfd06cb29	291	/* compute the CRC */
giovannivisentini	29:7a2dfd06cb29	292	uCRC16 = M24SR_ComputeCrc(pBuffer, 0x02);
giovannivisentini	29:7a2dfd06cb29	293	/* append the CRC16 */
giovannivisentini	29:7a2dfd06cb29	294	pBuffer[NthByte++] = GETLSB(uCRC16);
giovannivisentini	29:7a2dfd06cb29	295	pBuffer[NthByte++] = GETMSB(uCRC16);
giovannivisentini	29:7a2dfd06cb29	296
giovannivisentini	29:7a2dfd06cb29	297	/* send the request */
giovannivisentini	29:7a2dfd06cb29	298	status = M24SR_IO_SendI2Ccommand(NthByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	299	if(status != M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	300	return status;
giovannivisentini	29:7a2dfd06cb29	301
giovannivisentini	29:7a2dfd06cb29	302	mLastCommandSend=UPDATE;
giovannivisentini	29:7a2dfd06cb29	303
giovannivisentini	29:7a2dfd06cb29	304	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	305	return M24SR_ReceiveUpdateBinary();
giovannivisentini	29:7a2dfd06cb29	306	}//if
giovannivisentini	29:7a2dfd06cb29	307
giovannivisentini	29:7a2dfd06cb29	308	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	309	}
giovannivisentini	29:7a2dfd06cb29	310
giovannivisentini	29:7a2dfd06cb29	311	/**
giovannivisentini	29:7a2dfd06cb29	312	* @brief This function initialize the M24SR device
giovannivisentini	29:7a2dfd06cb29	313	* @retval None
giovannivisentini	29:7a2dfd06cb29	314	*/
giovannivisentini	29:7a2dfd06cb29	315	M24SR::StatusTypeDef M24SR::M24SR_Init(M24SR_InitTypeDef *notUsed) {
giovannivisentini	29:7a2dfd06cb29	316	(void) notUsed;
giovannivisentini	29:7a2dfd06cb29	317	//force to open a i2c session
giovannivisentini	29:7a2dfd06cb29	318	StatusTypeDef status = M24SR_ForceSession();
giovannivisentini	29:7a2dfd06cb29	319	if(status!= M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	320	return status;
giovannivisentini	29:7a2dfd06cb29	321	//leave the gpo always up
giovannivisentini	31:85fdf6fd3da5	322
giovannivisentini	29:7a2dfd06cb29	323	if(GPOPin.is_connected()!=0){
giovannivisentini	29:7a2dfd06cb29	324	status = M24SR_ManageI2CGPO(DEFAULT_GPO_STATUS);
giovannivisentini	29:7a2dfd06cb29	325	if(status!= M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	326	return status;
giovannivisentini	29:7a2dfd06cb29	327	}
giovannivisentini	31:85fdf6fd3da5	328
giovannivisentini	29:7a2dfd06cb29	329	if(RFDisablePin.is_connected()!=0){
giovannivisentini	29:7a2dfd06cb29	330	status = M24SR_ManageRFGPO(DEFAULT_GPO_STATUS);
giovannivisentini	29:7a2dfd06cb29	331	if(status!= M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	332	return status;
giovannivisentini	29:7a2dfd06cb29	333	}
giovannivisentini	31:85fdf6fd3da5	334
giovannivisentini	29:7a2dfd06cb29	335	//close the session
giovannivisentini	29:7a2dfd06cb29	336	status = M24SR_Deselect();
giovannivisentini	29:7a2dfd06cb29	337	if(status!= M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	338	return status;
giovannivisentini	31:85fdf6fd3da5	339
giovannivisentini	29:7a2dfd06cb29	340	if(GPOPin.is_connected()!=0){
giovannivisentini	29:7a2dfd06cb29	341	mGpoEventInterrupt.enable_irq();
giovannivisentini	29:7a2dfd06cb29	342	}
giovannivisentini	29:7a2dfd06cb29	343	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	344	}
giovannivisentini	29:7a2dfd06cb29	345
giovannivisentini	29:7a2dfd06cb29	346
giovannivisentini	29:7a2dfd06cb29	347	/**
giovannivisentini	29:7a2dfd06cb29	348	* @brief This function sends the KillSession command to the M24SR device
giovannivisentini	29:7a2dfd06cb29	349	* @param None
giovannivisentini	29:7a2dfd06cb29	350	* @return M24SR_SUCCESS if no errors
giovannivisentini	29:7a2dfd06cb29	351	*/
giovannivisentini	29:7a2dfd06cb29	352	M24SR::StatusTypeDef M24SR::M24SR_ForceSession(void) {
giovannivisentini	29:7a2dfd06cb29	353	uint8_t commandBuffer[] = M24SR_KILLSESSION_COMMAND;
giovannivisentini	29:7a2dfd06cb29	354	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	355	status = M24SR_IO_SendI2Ccommand(sizeof(commandBuffer), commandBuffer);
giovannivisentini	29:7a2dfd06cb29	356	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	357	mCallback->on_session_open(this,status);
giovannivisentini	29:7a2dfd06cb29	358	return status;
giovannivisentini	29:7a2dfd06cb29	359	}
giovannivisentini	29:7a2dfd06cb29	360
giovannivisentini	29:7a2dfd06cb29	361	/* Insure no access will be done just after open session */
giovannivisentini	29:7a2dfd06cb29	362	/* The only way here is to poll I2C to know when M24SR is ready */
giovannivisentini	29:7a2dfd06cb29	363	/* GPO can not be use with KillSession command */
giovannivisentini	31:85fdf6fd3da5	364	//status = M24SR_IO_PollI2C();
giovannivisentini	29:7a2dfd06cb29	365
giovannivisentini	29:7a2dfd06cb29	366	getCallback()->on_session_open(this,status);
giovannivisentini	29:7a2dfd06cb29	367	return status;
giovannivisentini	29:7a2dfd06cb29	368
giovannivisentini	29:7a2dfd06cb29	369	}
giovannivisentini	29:7a2dfd06cb29	370
giovannivisentini	29:7a2dfd06cb29	371	/**
giovannivisentini	29:7a2dfd06cb29	372	* @brief This function sends the Deselect command (S-Block format)
giovannivisentini	29:7a2dfd06cb29	373	* @return M24SR_SUCCESS if no errors
giovannivisentini	29:7a2dfd06cb29	374	*/
giovannivisentini	29:7a2dfd06cb29	375	M24SR::StatusTypeDef M24SR::M24SR_Deselect(void) {
giovannivisentini	29:7a2dfd06cb29	376	uint8_t pBuffer[] = M24SR_DESELECTREQUEST_COMMAND;
giovannivisentini	29:7a2dfd06cb29	377	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	378	/* send the request */
giovannivisentini	29:7a2dfd06cb29	379	status = M24SR_IO_SendI2Ccommand(sizeof(pBuffer), pBuffer);
giovannivisentini	29:7a2dfd06cb29	380	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	381	getCallback()->on_deselect(this,status);
giovannivisentini	29:7a2dfd06cb29	382	}
giovannivisentini	29:7a2dfd06cb29	383
giovannivisentini	29:7a2dfd06cb29	384	mLastCommandSend=DESELECT;
giovannivisentini	29:7a2dfd06cb29	385
giovannivisentini	29:7a2dfd06cb29	386	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	387	return M24SR_ReceiveDeselect();
giovannivisentini	31:85fdf6fd3da5	388	}//if
giovannivisentini	29:7a2dfd06cb29	389
giovannivisentini	29:7a2dfd06cb29	390	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	391	}
giovannivisentini	29:7a2dfd06cb29	392
giovannivisentini	29:7a2dfd06cb29	393	M24SR::StatusTypeDef M24SR::M24SR_ReceiveDeselect(void){
giovannivisentini	29:7a2dfd06cb29	394	uint8_t pBuffer[4];
giovannivisentini	29:7a2dfd06cb29	395	M24SR::StatusTypeDef status;
giovannivisentini	31:85fdf6fd3da5	396
giovannivisentini	31:85fdf6fd3da5	397	mLastCommandSend=NONE;
giovannivisentini	31:85fdf6fd3da5	398
giovannivisentini	29:7a2dfd06cb29	399	status = M24SR_IO_ReceiveI2Cresponse(sizeof(pBuffer), pBuffer);
giovannivisentini	29:7a2dfd06cb29	400	getCallback()->on_deselect(this,status);
giovannivisentini	29:7a2dfd06cb29	401	return status;
giovannivisentini	29:7a2dfd06cb29	402	}
giovannivisentini	29:7a2dfd06cb29	403
giovannivisentini	29:7a2dfd06cb29	404
giovannivisentini	29:7a2dfd06cb29	405
giovannivisentini	29:7a2dfd06cb29	406	/**
giovannivisentini	29:7a2dfd06cb29	407	* @brief This function sends the GetSession command to the M24SR device
giovannivisentini	29:7a2dfd06cb29	408	* @retval M24SR_SUCCESS the function is successful.
giovannivisentini	29:7a2dfd06cb29	409	* @retval Status (SW1&SW2) if operation does not complete.
giovannivisentini	29:7a2dfd06cb29	410	*/
giovannivisentini	29:7a2dfd06cb29	411	M24SR::StatusTypeDef M24SR::M24SR_GetSession(void) {
giovannivisentini	29:7a2dfd06cb29	412	uint8_t commandBuffer[] = M24SR_OPENSESSION_COMMAND;
giovannivisentini	29:7a2dfd06cb29	413
giovannivisentini	29:7a2dfd06cb29	414	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	415	status = M24SR_IO_SendI2Ccommand(sizeof(commandBuffer), commandBuffer);
giovannivisentini	29:7a2dfd06cb29	416	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	417	getCallback()->on_session_open(this,status);
giovannivisentini	29:7a2dfd06cb29	418	return status;
giovannivisentini	29:7a2dfd06cb29	419	}
giovannivisentini	29:7a2dfd06cb29	420
giovannivisentini	29:7a2dfd06cb29	421	/* Insure no access will be done just after open session */
giovannivisentini	29:7a2dfd06cb29	422	/* The only way here is to poll I2C to know when M24SR is ready */
giovannivisentini	29:7a2dfd06cb29	423	/* GPO can not be use with KillSession command */
giovannivisentini	31:85fdf6fd3da5	424	//status = M24SR_IO_PollI2C();
giovannivisentini	29:7a2dfd06cb29	425
giovannivisentini	29:7a2dfd06cb29	426	getCallback()->on_session_open(this,status);
giovannivisentini	29:7a2dfd06cb29	427	return status;
giovannivisentini	29:7a2dfd06cb29	428	}
giovannivisentini	29:7a2dfd06cb29	429
giovannivisentini	29:7a2dfd06cb29	430	/**
giovannivisentini	29:7a2dfd06cb29	431	* @brief This function sends the SelectApplication command
giovannivisentini	29:7a2dfd06cb29	432	* @return M24SR_SUCCESS if no errors
giovannivisentini	29:7a2dfd06cb29	433	*/
giovannivisentini	29:7a2dfd06cb29	434	M24SR::StatusTypeDef M24SR::M24SR_SendSelectApplication(void) {
giovannivisentini	29:7a2dfd06cb29	435
giovannivisentini	29:7a2dfd06cb29	436	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	437	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	438	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	439	uint8_t pDataOut[] = M24SR_SELECTAPPLICATION_COMMAND;
giovannivisentini	29:7a2dfd06cb29	440	uint8_t uLe = 0x00;
giovannivisentini	29:7a2dfd06cb29	441	uint16_t uP1P2 =0x0400, NbByte;
giovannivisentini	29:7a2dfd06cb29	442
giovannivisentini	29:7a2dfd06cb29	443	/* build the command */
giovannivisentini	29:7a2dfd06cb29	444	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	445	command.Header.INS = C_APDU_SELECT_FILE;
giovannivisentini	29:7a2dfd06cb29	446	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	447	command.Header.P1 = GETMSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	448	command.Header.P2 = GETLSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	449	/* copy the number of byte of the data field */
giovannivisentini	29:7a2dfd06cb29	450	command.Body.LC = sizeof(pDataOut);
giovannivisentini	29:7a2dfd06cb29	451	/* copy the data */
giovannivisentini	29:7a2dfd06cb29	452	command.Body.pData = pDataOut;
giovannivisentini	29:7a2dfd06cb29	453	/* copy the number of byte to read */
giovannivisentini	29:7a2dfd06cb29	454	command.Body.LE = uLe;
giovannivisentini	29:7a2dfd06cb29	455	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	456	M24SR_BuildIBlockCommand( M24SR_CMDSTRUCT_SELECTAPPLICATION, &command,
giovannivisentini	29:7a2dfd06cb29	457	uDIDbyte, &NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	458
giovannivisentini	29:7a2dfd06cb29	459	/* send the request */
giovannivisentini	29:7a2dfd06cb29	460	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	461	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	462	getCallback()->on_selected_application(this,status);
giovannivisentini	29:7a2dfd06cb29	463	return status;
giovannivisentini	29:7a2dfd06cb29	464	}
giovannivisentini	29:7a2dfd06cb29	465
giovannivisentini	29:7a2dfd06cb29	466	mLastCommandSend=SELECT_APPLICATION;
giovannivisentini	29:7a2dfd06cb29	467
giovannivisentini	29:7a2dfd06cb29	468	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	469	return M24SR_ReceiveSelectApplication();
giovannivisentini	29:7a2dfd06cb29	470	}//if
giovannivisentini	29:7a2dfd06cb29	471
giovannivisentini	29:7a2dfd06cb29	472	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	473	}
giovannivisentini	29:7a2dfd06cb29	474
giovannivisentini	29:7a2dfd06cb29	475	M24SR::StatusTypeDef M24SR::M24SR_ReceiveSelectApplication(void) {
giovannivisentini	29:7a2dfd06cb29	476
giovannivisentini	29:7a2dfd06cb29	477	uint8_t pDataIn[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	478	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	479
giovannivisentini	29:7a2dfd06cb29	480	mLastCommandSend = NONE;
giovannivisentini	29:7a2dfd06cb29	481
giovannivisentini	29:7a2dfd06cb29	482	status = M24SR_IO_ReceiveI2Cresponse(sizeof(pDataIn), pDataIn);
giovannivisentini	29:7a2dfd06cb29	483	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	484	getCallback()->on_selected_application(this,status);
giovannivisentini	29:7a2dfd06cb29	485	return status;
giovannivisentini	29:7a2dfd06cb29	486	}//else
giovannivisentini	29:7a2dfd06cb29	487	status= M24SR_IsCorrectCRC16Residue(pDataIn, sizeof(pDataIn));
giovannivisentini	29:7a2dfd06cb29	488	getCallback()->on_selected_application(this,status);
giovannivisentini	29:7a2dfd06cb29	489	return status;
giovannivisentini	29:7a2dfd06cb29	490
giovannivisentini	29:7a2dfd06cb29	491	}
giovannivisentini	29:7a2dfd06cb29	492
giovannivisentini	29:7a2dfd06cb29	493
giovannivisentini	29:7a2dfd06cb29	494
giovannivisentini	29:7a2dfd06cb29	495	M24SR::StatusTypeDef M24SR::M24SR_ReadID(uint8_t *nfc_id) {
giovannivisentini	29:7a2dfd06cb29	496	if (!nfc_id) {
giovannivisentini	29:7a2dfd06cb29	497	return M24SR_ERROR;
giovannivisentini	29:7a2dfd06cb29	498	}
giovannivisentini	29:7a2dfd06cb29	499
giovannivisentini	29:7a2dfd06cb29	500	//enable the callback for change the gpo
giovannivisentini	29:7a2dfd06cb29	501	mComponentCallback = &mReadIDCallback;
giovannivisentini	29:7a2dfd06cb29	502	mReadIDCallback.read_id_on(nfc_id);
giovannivisentini	29:7a2dfd06cb29	503
giovannivisentini	29:7a2dfd06cb29	504	//start the readID procedure
giovannivisentini	29:7a2dfd06cb29	505	return M24SR_SendSelectApplication();
giovannivisentini	29:7a2dfd06cb29	506	}
giovannivisentini	29:7a2dfd06cb29	507
giovannivisentini	29:7a2dfd06cb29	508	/**
giovannivisentini	29:7a2dfd06cb29	509	* @brief This function sends the SelectCCFile command
giovannivisentini	29:7a2dfd06cb29	510	* @retval M24SR_SUCCESS the function is successful.
giovannivisentini	29:7a2dfd06cb29	511	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	512	* @retval Status (SW1&SW2) if operation does not complete for another reason.
giovannivisentini	29:7a2dfd06cb29	513	*/
giovannivisentini	29:7a2dfd06cb29	514	M24SR::StatusTypeDef M24SR::M24SR_SendSelectCCfile(void) {
giovannivisentini	29:7a2dfd06cb29	515	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	516	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	517	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	518	uint8_t pDataOut[] = CC_FILE_ID_BYTES;
giovannivisentini	29:7a2dfd06cb29	519	uint16_t uP1P2 =0x000C,
giovannivisentini	29:7a2dfd06cb29	520	NbByte;
giovannivisentini	29:7a2dfd06cb29	521
giovannivisentini	29:7a2dfd06cb29	522	/* build the command */
giovannivisentini	29:7a2dfd06cb29	523	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	524	command.Header.INS = C_APDU_SELECT_FILE;
giovannivisentini	29:7a2dfd06cb29	525	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	526	command.Header.P1 = GETMSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	527	command.Header.P2 = GETLSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	528	/* copy the number of byte of the data field */
giovannivisentini	29:7a2dfd06cb29	529	command.Body.LC = sizeof(pDataOut);
giovannivisentini	29:7a2dfd06cb29	530	command.Body.pData = pDataOut;
giovannivisentini	29:7a2dfd06cb29	531	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	532	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_SELECTCCFILE, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	533	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	534
giovannivisentini	29:7a2dfd06cb29	535	/* send the request */
giovannivisentini	29:7a2dfd06cb29	536	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	537	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	538	getCallback()->on_selected_CC_file(this,status);
giovannivisentini	29:7a2dfd06cb29	539	return status;
giovannivisentini	29:7a2dfd06cb29	540	}//else
giovannivisentini	29:7a2dfd06cb29	541
giovannivisentini	29:7a2dfd06cb29	542
giovannivisentini	29:7a2dfd06cb29	543	mLastCommandSend=SELECT_CC_FILE;
giovannivisentini	29:7a2dfd06cb29	544
giovannivisentini	29:7a2dfd06cb29	545	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	546	return M24SR_ReceiveSelectCCfile();
giovannivisentini	29:7a2dfd06cb29	547	}//if
giovannivisentini	29:7a2dfd06cb29	548
giovannivisentini	29:7a2dfd06cb29	549	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	550	}
giovannivisentini	29:7a2dfd06cb29	551
giovannivisentini	29:7a2dfd06cb29	552	M24SR::StatusTypeDef M24SR::M24SR_ReceiveSelectCCfile(void){
giovannivisentini	29:7a2dfd06cb29	553
giovannivisentini	29:7a2dfd06cb29	554	uint8_t pDataIn[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	555	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	556
giovannivisentini	29:7a2dfd06cb29	557	mLastCommandSend = NONE;
giovannivisentini	29:7a2dfd06cb29	558
giovannivisentini	29:7a2dfd06cb29	559	status = M24SR_IO_ReceiveI2Cresponse(sizeof(pDataIn), pDataIn);
giovannivisentini	29:7a2dfd06cb29	560	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	561	getCallback()->on_selected_CC_file(this,status);
giovannivisentini	29:7a2dfd06cb29	562	return status;
giovannivisentini	29:7a2dfd06cb29	563	}//else
giovannivisentini	29:7a2dfd06cb29	564	status= M24SR_IsCorrectCRC16Residue(pDataIn, sizeof(pDataIn));
giovannivisentini	29:7a2dfd06cb29	565	getCallback()->on_selected_CC_file(this,status);
giovannivisentini	29:7a2dfd06cb29	566	return status;
giovannivisentini	29:7a2dfd06cb29	567
giovannivisentini	29:7a2dfd06cb29	568	}
giovannivisentini	29:7a2dfd06cb29	569
giovannivisentini	29:7a2dfd06cb29	570	/**
giovannivisentini	29:7a2dfd06cb29	571	* @brief This function sends the SelectSystemFile command
giovannivisentini	29:7a2dfd06cb29	572	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	573	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	574	*/
giovannivisentini	29:7a2dfd06cb29	575	M24SR::StatusTypeDef M24SR::M24SR_SendSelectSystemfile(void) {
giovannivisentini	29:7a2dfd06cb29	576	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	577
giovannivisentini	29:7a2dfd06cb29	578	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	579	uint8_t pDataOut[] = SYSTEM_FILE_ID_BYTES;
giovannivisentini	29:7a2dfd06cb29	580	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	581	uint16_t uP1P2 =0x000C, NbByte;
giovannivisentini	29:7a2dfd06cb29	582
giovannivisentini	29:7a2dfd06cb29	583	/* build the command */
giovannivisentini	29:7a2dfd06cb29	584	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	585	command.Header.INS = C_APDU_SELECT_FILE;
giovannivisentini	29:7a2dfd06cb29	586	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	587	command.Header.P1 = GETMSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	588	command.Header.P2 = GETLSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	589	/* copy the number of byte of the data field */
giovannivisentini	29:7a2dfd06cb29	590	command.Body.LC = sizeof(pDataOut);
giovannivisentini	29:7a2dfd06cb29	591	command.Body.pData = pDataOut;
giovannivisentini	31:85fdf6fd3da5	592	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	593	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_SELECTCCFILE, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	594	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	595
giovannivisentini	29:7a2dfd06cb29	596	/* send the request */
giovannivisentini	29:7a2dfd06cb29	597	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	598	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	599	getCallback()->on_selected_system_file(this,status);
giovannivisentini	29:7a2dfd06cb29	600	return status;
giovannivisentini	29:7a2dfd06cb29	601	}//else
giovannivisentini	29:7a2dfd06cb29	602
giovannivisentini	29:7a2dfd06cb29	603	mLastCommandSend=SELECT_SYSTEM_FILE;
giovannivisentini	29:7a2dfd06cb29	604
giovannivisentini	29:7a2dfd06cb29	605	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	606	return M24SR_ReceiveSelectSystemfile();
giovannivisentini	29:7a2dfd06cb29	607	}//if
giovannivisentini	29:7a2dfd06cb29	608
giovannivisentini	29:7a2dfd06cb29	609	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	610	}
giovannivisentini	29:7a2dfd06cb29	611
giovannivisentini	29:7a2dfd06cb29	612	M24SR::StatusTypeDef M24SR::M24SR_ReceiveSelectSystemfile(){
giovannivisentini	29:7a2dfd06cb29	613
giovannivisentini	29:7a2dfd06cb29	614	uint8_t pDataIn[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	615	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	616
giovannivisentini	29:7a2dfd06cb29	617	mLastCommandSend = NONE;
giovannivisentini	29:7a2dfd06cb29	618
giovannivisentini	29:7a2dfd06cb29	619	status = M24SR_IO_ReceiveI2Cresponse(sizeof(pDataIn), pDataIn);
giovannivisentini	29:7a2dfd06cb29	620	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	621	getCallback()->on_selected_system_file(this,status);
giovannivisentini	29:7a2dfd06cb29	622	return status;
giovannivisentini	29:7a2dfd06cb29	623	}//else
giovannivisentini	29:7a2dfd06cb29	624	status= M24SR_IsCorrectCRC16Residue(pDataIn, sizeof(pDataIn));
giovannivisentini	29:7a2dfd06cb29	625	getCallback()->on_selected_system_file(this,status);
giovannivisentini	29:7a2dfd06cb29	626	return status;
giovannivisentini	29:7a2dfd06cb29	627
giovannivisentini	29:7a2dfd06cb29	628	}
giovannivisentini	29:7a2dfd06cb29	629
giovannivisentini	29:7a2dfd06cb29	630	/**
giovannivisentini	29:7a2dfd06cb29	631	* @brief This function sends the SelectNDEFfile command
giovannivisentini	29:7a2dfd06cb29	632	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	633	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	634	*/
giovannivisentini	29:7a2dfd06cb29	635	M24SR::StatusTypeDef M24SR::M24SR_SendSelectNDEFfile(uint16_t NDEFfileId) {
giovannivisentini	29:7a2dfd06cb29	636	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	637	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	638	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	639	uint8_t pDataOut[] = { GETMSB(NDEFfileId), GETLSB(NDEFfileId) };
giovannivisentini	29:7a2dfd06cb29	640	uint16_t uP1P2 = 0x000C, NbByte;
giovannivisentini	29:7a2dfd06cb29	641
giovannivisentini	29:7a2dfd06cb29	642	/* build the command */
giovannivisentini	29:7a2dfd06cb29	643	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	644	command.Header.INS = C_APDU_SELECT_FILE;
giovannivisentini	29:7a2dfd06cb29	645	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	646	command.Header.P1 = GETMSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	647	command.Header.P2 = GETLSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	648	/* copy the number of byte of the data field */
giovannivisentini	29:7a2dfd06cb29	649	command.Body.LC = sizeof(pDataOut);
giovannivisentini	29:7a2dfd06cb29	650	command.Body.pData = pDataOut;
giovannivisentini	29:7a2dfd06cb29	651	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	652	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	653	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_SELECTNDEFFILE, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	654	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	655
giovannivisentini	29:7a2dfd06cb29	656	/* send the request */
giovannivisentini	29:7a2dfd06cb29	657	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	658	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	659
giovannivisentini	29:7a2dfd06cb29	660	}
giovannivisentini	29:7a2dfd06cb29	661
giovannivisentini	29:7a2dfd06cb29	662	mLastCommandSend=SELECT_NDEF_FILE;
giovannivisentini	29:7a2dfd06cb29	663
giovannivisentini	29:7a2dfd06cb29	664	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	665	return M24SR_ReceiveSelectNDEFfile();
giovannivisentini	29:7a2dfd06cb29	666	}
giovannivisentini	29:7a2dfd06cb29	667
giovannivisentini	29:7a2dfd06cb29	668	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	669
giovannivisentini	29:7a2dfd06cb29	670	}
giovannivisentini	29:7a2dfd06cb29	671
giovannivisentini	29:7a2dfd06cb29	672	M24SR::StatusTypeDef M24SR::M24SR_ReceiveSelectNDEFfile(){
giovannivisentini	29:7a2dfd06cb29	673
giovannivisentini	29:7a2dfd06cb29	674	uint8_t pDataIn[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	675	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	676
giovannivisentini	29:7a2dfd06cb29	677	mLastCommandSend = NONE;
giovannivisentini	29:7a2dfd06cb29	678
giovannivisentini	29:7a2dfd06cb29	679	status = M24SR_IO_ReceiveI2Cresponse(sizeof(pDataIn), pDataIn);
giovannivisentini	29:7a2dfd06cb29	680	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	681	getCallback()->on_selected_NDEF_file(this,status);
giovannivisentini	29:7a2dfd06cb29	682	return status;
giovannivisentini	29:7a2dfd06cb29	683	}//else
giovannivisentini	29:7a2dfd06cb29	684	status= M24SR_IsCorrectCRC16Residue(pDataIn, sizeof(pDataIn));
giovannivisentini	29:7a2dfd06cb29	685	getCallback()->on_selected_NDEF_file(this,status);
giovannivisentini	29:7a2dfd06cb29	686	return status;
giovannivisentini	29:7a2dfd06cb29	687
giovannivisentini	29:7a2dfd06cb29	688	}
giovannivisentini	29:7a2dfd06cb29	689
giovannivisentini	29:7a2dfd06cb29	690	/**
giovannivisentini	29:7a2dfd06cb29	691	* @brief This function sends a read binary command
giovannivisentini	29:7a2dfd06cb29	692	* @param Offset first byte to read
giovannivisentini	29:7a2dfd06cb29	693	* @param NbByteToRead number of bytes to read
giovannivisentini	29:7a2dfd06cb29	694	* @param pBufferRead pointer to the buffer read from the M24SR device
giovannivisentini	29:7a2dfd06cb29	695	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	696	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	697	*/
giovannivisentini	29:7a2dfd06cb29	698	M24SR::StatusTypeDef M24SR::M24SR_SendReadBinary(uint16_t Offset, uint8_t NbByteToRead,
giovannivisentini	29:7a2dfd06cb29	699	uint8_t *pBufferRead) {
giovannivisentini	29:7a2dfd06cb29	700	//clamp the buffer to the max size
giovannivisentini	29:7a2dfd06cb29	701	if(NbByteToRead>M24SR_MAX_BYTE_OPERATION_LENGHT)
giovannivisentini	29:7a2dfd06cb29	702	NbByteToRead=M24SR_MAX_BYTE_OPERATION_LENGHT;
giovannivisentini	29:7a2dfd06cb29	703
giovannivisentini	29:7a2dfd06cb29	704	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	705	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	706	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	707	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	708
giovannivisentini	29:7a2dfd06cb29	709	/* build the command */
giovannivisentini	29:7a2dfd06cb29	710	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	711	command.Header.INS = C_APDU_READ_BINARY;
giovannivisentini	29:7a2dfd06cb29	712	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	713	command.Header.P1 = GETMSB(Offset);
giovannivisentini	29:7a2dfd06cb29	714	command.Header.P2 = GETLSB(Offset);
giovannivisentini	29:7a2dfd06cb29	715	/* copy the number of byte to read */
giovannivisentini	29:7a2dfd06cb29	716	command.Body.LE = NbByteToRead;
giovannivisentini	29:7a2dfd06cb29	717
giovannivisentini	29:7a2dfd06cb29	718	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_READBINARY, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	719	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	720
giovannivisentini	29:7a2dfd06cb29	721	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	722	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	723	getCallback()->on_read_byte(this,status,Offset,pBufferRead,NbByteToRead);
giovannivisentini	29:7a2dfd06cb29	724	return status;
giovannivisentini	29:7a2dfd06cb29	725	}
giovannivisentini	29:7a2dfd06cb29	726
giovannivisentini	29:7a2dfd06cb29	727	mLastCommandSend=READ;
giovannivisentini	29:7a2dfd06cb29	728	mLastCommandData.data=pBufferRead;
giovannivisentini	29:7a2dfd06cb29	729	mLastCommandData.length=NbByteToRead;
giovannivisentini	29:7a2dfd06cb29	730	mLastCommandData.offset=Offset;
giovannivisentini	29:7a2dfd06cb29	731
giovannivisentini	29:7a2dfd06cb29	732	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	733	return M24SR_ReceiveReadBinary();
giovannivisentini	29:7a2dfd06cb29	734	}//if
giovannivisentini	29:7a2dfd06cb29	735
giovannivisentini	29:7a2dfd06cb29	736	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	737	}
giovannivisentini	29:7a2dfd06cb29	738
giovannivisentini	29:7a2dfd06cb29	739	M24SR::StatusTypeDef M24SR::M24SR_ReceiveReadBinary(){
giovannivisentini	29:7a2dfd06cb29	740
giovannivisentini	29:7a2dfd06cb29	741	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	742	const uint16_t length = mLastCommandData.length;
giovannivisentini	29:7a2dfd06cb29	743	const uint16_t offset = mLastCommandData.offset;
giovannivisentini	29:7a2dfd06cb29	744	uint8_t *data = mLastCommandData.data;
giovannivisentini	29:7a2dfd06cb29	745
giovannivisentini	29:7a2dfd06cb29	746	mLastCommandSend=NONE;
giovannivisentini	29:7a2dfd06cb29	747
giovannivisentini	29:7a2dfd06cb29	748	status = M24SR_IO_ReceiveI2Cresponse (length + M24SR_STATUSRESPONSE_NBBYTE , uM24SRbuffer );
giovannivisentini	29:7a2dfd06cb29	749	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	750	getCallback()->on_read_byte(this,status,offset,data,length);
giovannivisentini	29:7a2dfd06cb29	751	return status;
giovannivisentini	29:7a2dfd06cb29	752	}
giovannivisentini	29:7a2dfd06cb29	753	status = M24SR_IsCorrectCRC16Residue(uM24SRbuffer, length + M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	754	if(status != M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	755	getCallback()->on_read_byte(this,status,offset,data,length);
giovannivisentini	29:7a2dfd06cb29	756	else{
giovannivisentini	29:7a2dfd06cb29	757	/* retrieve the data without SW1 & SW2 as provided as return value of the function */
giovannivisentini	29:7a2dfd06cb29	758	memcpy(mLastCommandData.data, &uM24SRbuffer[1], length);
giovannivisentini	29:7a2dfd06cb29	759	getCallback()->on_read_byte(this,status,offset,data,length);
giovannivisentini	29:7a2dfd06cb29	760	}
giovannivisentini	29:7a2dfd06cb29	761	return status;
giovannivisentini	29:7a2dfd06cb29	762
giovannivisentini	29:7a2dfd06cb29	763	}
giovannivisentini	29:7a2dfd06cb29	764
giovannivisentini	29:7a2dfd06cb29	765	/**
giovannivisentini	29:7a2dfd06cb29	766	* @brief This function sends a ST read binary command (no error if access is not inside NDEF file)
giovannivisentini	29:7a2dfd06cb29	767	* @param Offset first byte to read
giovannivisentini	29:7a2dfd06cb29	768	* @param NbByteToRead number of bytes to read
giovannivisentini	29:7a2dfd06cb29	769	* @param pBufferRead pointer to the buffer read from the M24SR device
giovannivisentini	29:7a2dfd06cb29	770	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	771	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	772	*/
giovannivisentini	29:7a2dfd06cb29	773	M24SR::StatusTypeDef M24SR::M24SR_SendSTReadBinary(uint16_t Offset,
giovannivisentini	29:7a2dfd06cb29	774	uint8_t NbByteToRead, uint8_t *pBufferRead) {
giovannivisentini	29:7a2dfd06cb29	775	//clamp the buffer to the max size
giovannivisentini	29:7a2dfd06cb29	776	if(NbByteToRead>M24SR_MAX_BYTE_OPERATION_LENGHT)
giovannivisentini	29:7a2dfd06cb29	777	NbByteToRead=M24SR_MAX_BYTE_OPERATION_LENGHT;
giovannivisentini	29:7a2dfd06cb29	778
giovannivisentini	29:7a2dfd06cb29	779	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	780	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	781	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	782	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	783
giovannivisentini	29:7a2dfd06cb29	784	/* build the command */
giovannivisentini	29:7a2dfd06cb29	785	command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini	29:7a2dfd06cb29	786	command.Header.INS = C_APDU_READ_BINARY;
giovannivisentini	29:7a2dfd06cb29	787	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	788	command.Header.P1 = GETMSB(Offset);
giovannivisentini	29:7a2dfd06cb29	789	command.Header.P2 = GETLSB(Offset);
giovannivisentini	29:7a2dfd06cb29	790	/* copy the number of byte to read */
giovannivisentini	29:7a2dfd06cb29	791	command.Body.LE = NbByteToRead;
giovannivisentini	29:7a2dfd06cb29	792
giovannivisentini	29:7a2dfd06cb29	793	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_READBINARY, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	794	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	795
giovannivisentini	29:7a2dfd06cb29	796	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	797	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	798	getCallback()->on_read_byte(this,status,Offset,pBufferRead,NbByteToRead);
giovannivisentini	29:7a2dfd06cb29	799	return status;
giovannivisentini	29:7a2dfd06cb29	800	}
giovannivisentini	29:7a2dfd06cb29	801
giovannivisentini	29:7a2dfd06cb29	802	mLastCommandSend=READ;
giovannivisentini	29:7a2dfd06cb29	803	mLastCommandData.data=pBufferRead;
giovannivisentini	29:7a2dfd06cb29	804	mLastCommandData.length=NbByteToRead;
giovannivisentini	29:7a2dfd06cb29	805
giovannivisentini	29:7a2dfd06cb29	806	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	807	return M24SR_ReceiveReadBinary();
giovannivisentini	29:7a2dfd06cb29	808	}//if
giovannivisentini	29:7a2dfd06cb29	809
giovannivisentini	29:7a2dfd06cb29	810	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	811	}
giovannivisentini	29:7a2dfd06cb29	812
giovannivisentini	29:7a2dfd06cb29	813	/**
giovannivisentini	29:7a2dfd06cb29	814	* @brief This function sends a Update binary command
giovannivisentini	29:7a2dfd06cb29	815	* @param Offset first byte to read
giovannivisentini	29:7a2dfd06cb29	816	* @param NbByteToWrite number of bytes to write
giovannivisentini	29:7a2dfd06cb29	817	* @param pBufferRead pointer to the buffer read from the M24SR device
giovannivisentini	29:7a2dfd06cb29	818	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	819	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	820	*/
giovannivisentini	29:7a2dfd06cb29	821	M24SR::StatusTypeDef M24SR::M24SR_SendUpdateBinary(uint16_t Offset,
giovannivisentini	29:7a2dfd06cb29	822	uint8_t NbByteToWrite, uint8_t *pDataToWrite) {
giovannivisentini	29:7a2dfd06cb29	823	//clamp the buffer to the max size
giovannivisentini	29:7a2dfd06cb29	824	if(NbByteToWrite>M24SR_MAX_BYTE_OPERATION_LENGHT)
giovannivisentini	29:7a2dfd06cb29	825	NbByteToWrite=M24SR_MAX_BYTE_OPERATION_LENGHT;
giovannivisentini	29:7a2dfd06cb29	826
giovannivisentini	29:7a2dfd06cb29	827	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	828	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	829	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	830	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	831
giovannivisentini	29:7a2dfd06cb29	832	/* build the command */
giovannivisentini	29:7a2dfd06cb29	833	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	834	command.Header.INS = C_APDU_UPDATE_BINARY;
giovannivisentini	29:7a2dfd06cb29	835	/* copy the offset */
giovannivisentini	29:7a2dfd06cb29	836	command.Header.P1 = GETMSB(Offset);
giovannivisentini	29:7a2dfd06cb29	837	command.Header.P2 = GETLSB(Offset);
giovannivisentini	29:7a2dfd06cb29	838	/* copy the number of byte of the data field */
giovannivisentini	29:7a2dfd06cb29	839	command.Body.LC = NbByteToWrite;
giovannivisentini	29:7a2dfd06cb29	840	command.Body.pData = pDataToWrite;
giovannivisentini	29:7a2dfd06cb29	841	/* copy the File Id */
giovannivisentini	29:7a2dfd06cb29	842	//memcpy(command.Body.pData ,pDataToWrite, NbByteToWrite );
giovannivisentini	29:7a2dfd06cb29	843	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_UPDATEBINARY, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	844	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	845
giovannivisentini	29:7a2dfd06cb29	846	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	847	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	848	getCallback()->on_updated_binary(this,status,Offset,pDataToWrite,NbByteToWrite);
giovannivisentini	29:7a2dfd06cb29	849	return status;
giovannivisentini	29:7a2dfd06cb29	850	}
giovannivisentini	29:7a2dfd06cb29	851
giovannivisentini	29:7a2dfd06cb29	852	mLastCommandSend=UPDATE;
giovannivisentini	29:7a2dfd06cb29	853	mLastCommandData.data=pDataToWrite;
giovannivisentini	29:7a2dfd06cb29	854	mLastCommandData.length=NbByteToWrite;
giovannivisentini	29:7a2dfd06cb29	855	mLastCommandData.offset=Offset;
giovannivisentini	29:7a2dfd06cb29	856
giovannivisentini	29:7a2dfd06cb29	857	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	858	return M24SR_ReceiveUpdateBinary();
giovannivisentini	29:7a2dfd06cb29	859	}
giovannivisentini	29:7a2dfd06cb29	860
giovannivisentini	29:7a2dfd06cb29	861	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	862	}
giovannivisentini	29:7a2dfd06cb29	863
giovannivisentini	29:7a2dfd06cb29	864	M24SR::StatusTypeDef M24SR::M24SR_ReceiveUpdateBinary() {
giovannivisentini	29:7a2dfd06cb29	865
giovannivisentini	29:7a2dfd06cb29	866	uint8_t respBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	867	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	868	const uint16_t length = mLastCommandData.length;
giovannivisentini	29:7a2dfd06cb29	869	uint8_t *data = mLastCommandData.data;
giovannivisentini	29:7a2dfd06cb29	870	const uint16_t offset = mLastCommandData.offset;
giovannivisentini	29:7a2dfd06cb29	871
giovannivisentini	29:7a2dfd06cb29	872	mLastCommandSend=NONE;
giovannivisentini	29:7a2dfd06cb29	873
giovannivisentini	29:7a2dfd06cb29	874	status= M24SR_IO_ReceiveI2Cresponse (sizeof(respBuffer) , respBuffer);
giovannivisentini	29:7a2dfd06cb29	875	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	876	getCallback()->on_updated_binary(this,status,offset,data,length);
giovannivisentini	29:7a2dfd06cb29	877	return status;
giovannivisentini	29:7a2dfd06cb29	878	}
giovannivisentini	29:7a2dfd06cb29	879
giovannivisentini	29:7a2dfd06cb29	880	if (IsSBlock(respBuffer) == M24SR_SUCCESS) {
giovannivisentini	29:7a2dfd06cb29	881	/check the CRC /
giovannivisentini	29:7a2dfd06cb29	882	status =M24SR_IsCorrectCRC16Residue(respBuffer,
giovannivisentini	29:7a2dfd06cb29	883	M24SR_WATINGTIMEEXTRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	884	// TODO: why if we check ==NFC_Commandsuccess it fail?
giovannivisentini	29:7a2dfd06cb29	885	if (status != M24SR_IO_ERROR_CRC) {
giovannivisentini	29:7a2dfd06cb29	886	/* send the FrameExension response*/
giovannivisentini	29:7a2dfd06cb29	887	status = M24SR_SendFWTExtension(respBuffer[M24SR_OFFSET_PCB + 1]);
giovannivisentini	29:7a2dfd06cb29	888	if(status!=M24SR_SUCCESS){ //something get wrong -> abort the update
giovannivisentini	29:7a2dfd06cb29	889	getCallback()->on_updated_binary(this,status,offset,data,length);
giovannivisentini	29:7a2dfd06cb29	890	}//status
giovannivisentini	29:7a2dfd06cb29	891	}//if
giovannivisentini	29:7a2dfd06cb29	892	} else { //isSBlock
giovannivisentini	29:7a2dfd06cb29	893	status = M24SR_IsCorrectCRC16Residue(respBuffer,
giovannivisentini	29:7a2dfd06cb29	894	M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	895	getCallback()->on_updated_binary(this,status,offset,data,length);
giovannivisentini	29:7a2dfd06cb29	896	}//if else
giovannivisentini	29:7a2dfd06cb29	897	return status;
giovannivisentini	29:7a2dfd06cb29	898	}//M24SR_ReceiveUpdateBinary
giovannivisentini	29:7a2dfd06cb29	899
giovannivisentini	29:7a2dfd06cb29	900
giovannivisentini	29:7a2dfd06cb29	901	/**
giovannivisentini	29:7a2dfd06cb29	902	* @brief This function sends the Verify command
giovannivisentini	29:7a2dfd06cb29	903	* @param uPwdId PasswordId ( 0x0001 : Read NDEF pwd or 0x0002 : Write NDEF pwd or 0x0003 : I2C pwd)
giovannivisentini	29:7a2dfd06cb29	904	* @param NbPwdByte Number of bytes ( 0x00 or 0x10)
giovannivisentini	29:7a2dfd06cb29	905	* @param pPwd pointer to the password
giovannivisentini	29:7a2dfd06cb29	906	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	907	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	908	*/
giovannivisentini	29:7a2dfd06cb29	909	M24SR::StatusTypeDef M24SR::M24SR_SendVerify(uint16_t uPwdId, uint8_t NbPwdByte,
giovannivisentini	29:7a2dfd06cb29	910	const uint8_t *pPwd) {
giovannivisentini	29:7a2dfd06cb29	911	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	912	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	913	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	914	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	915
giovannivisentini	29:7a2dfd06cb29	916	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	917	if ((uPwdId > 0x0003)\|\| ((NbPwdByte != 0x00) && (NbPwdByte != 0x10))) {
giovannivisentini	29:7a2dfd06cb29	918	getCallback()->on_verified(this,M24SR_IO_ERROR_PARAMETER,constToPasswordType(uPwdId),pPwd);
giovannivisentini	29:7a2dfd06cb29	919	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	920	}
giovannivisentini	29:7a2dfd06cb29	921
giovannivisentini	29:7a2dfd06cb29	922	/* build the command */
giovannivisentini	29:7a2dfd06cb29	923	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	924	command.Header.INS = C_APDU_VERIFY;
giovannivisentini	29:7a2dfd06cb29	925	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	926	command.Header.P1 = GETMSB(uPwdId);
giovannivisentini	29:7a2dfd06cb29	927	command.Header.P2 = GETLSB(uPwdId);
giovannivisentini	29:7a2dfd06cb29	928	/* copy the number of bytes of the data field */
giovannivisentini	29:7a2dfd06cb29	929	command.Body.LC = NbPwdByte;
giovannivisentini	29:7a2dfd06cb29	930
giovannivisentini	29:7a2dfd06cb29	931	if (NbPwdByte == 0x10) {
giovannivisentini	29:7a2dfd06cb29	932	/* copy the password */
giovannivisentini	29:7a2dfd06cb29	933	command.Body.pData = pPwd;
giovannivisentini	29:7a2dfd06cb29	934	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	935	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_VERIFYBINARYWITHPWD, &command,
giovannivisentini	29:7a2dfd06cb29	936	uDIDbyte, &NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	937	} else {
giovannivisentini	29:7a2dfd06cb29	938	command.Body.pData = NULL;
giovannivisentini	29:7a2dfd06cb29	939	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	940	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_VERIFYBINARYWOPWD, &command,
giovannivisentini	29:7a2dfd06cb29	941	uDIDbyte, &NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	942	}
giovannivisentini	29:7a2dfd06cb29	943
giovannivisentini	29:7a2dfd06cb29	944	/* send the request */
giovannivisentini	29:7a2dfd06cb29	945	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	946	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	947	getCallback()->on_verified(this,status,constToPasswordType(uPwdId),pPwd);
giovannivisentini	29:7a2dfd06cb29	948	return status;
giovannivisentini	29:7a2dfd06cb29	949	}
giovannivisentini	29:7a2dfd06cb29	950	mLastCommandSend=VERIFY;
giovannivisentini	29:7a2dfd06cb29	951
giovannivisentini	29:7a2dfd06cb29	952	mLastCommandData.data=(uint8_t*)pPwd;
giovannivisentini	29:7a2dfd06cb29	953	mLastCommandData.offset=uPwdId;
giovannivisentini	29:7a2dfd06cb29	954
giovannivisentini	29:7a2dfd06cb29	955	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	956	return M24SR_ReceiveVerify();
giovannivisentini	29:7a2dfd06cb29	957	}
giovannivisentini	29:7a2dfd06cb29	958
giovannivisentini	29:7a2dfd06cb29	959	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	960	}
giovannivisentini	29:7a2dfd06cb29	961
giovannivisentini	29:7a2dfd06cb29	962	M24SR::StatusTypeDef M24SR::M24SR_ReceiveVerify(){
giovannivisentini	29:7a2dfd06cb29	963	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	964	uint8_t respBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	965	mLastCommandSend=NONE;
giovannivisentini	29:7a2dfd06cb29	966
giovannivisentini	29:7a2dfd06cb29	967	const uint8_t *data = mLastCommandData.data;
giovannivisentini	29:7a2dfd06cb29	968	const PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini	29:7a2dfd06cb29	969
giovannivisentini	29:7a2dfd06cb29	970	status=M24SR_IO_ReceiveI2Cresponse (sizeof(respBuffer),respBuffer);
giovannivisentini	29:7a2dfd06cb29	971
giovannivisentini	29:7a2dfd06cb29	972	if(status !=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	973	getCallback()->on_verified(this,status,type,data);
giovannivisentini	29:7a2dfd06cb29	974	return status;
giovannivisentini	29:7a2dfd06cb29	975	}
giovannivisentini	29:7a2dfd06cb29	976	status = M24SR_IsCorrectCRC16Residue(respBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	977	getCallback()->on_verified(this,status,type,data);
giovannivisentini	29:7a2dfd06cb29	978	return status;
giovannivisentini	29:7a2dfd06cb29	979	}
giovannivisentini	29:7a2dfd06cb29	980
giovannivisentini	29:7a2dfd06cb29	981	/**
giovannivisentini	29:7a2dfd06cb29	982	* @brief This function sends the ChangeReferenceData command
giovannivisentini	29:7a2dfd06cb29	983	* @param uPwdId PasswordId ( 0x0001 : Read NDEF pwd or 0x0002 : Write NDEF pwd or 0x0003 : I2C pwd)
giovannivisentini	29:7a2dfd06cb29	984	* @param pPwd pointer to the passwaord
giovannivisentini	29:7a2dfd06cb29	985	* @retval Status (SW1&SW2) Satus of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	986	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	987	*/
giovannivisentini	29:7a2dfd06cb29	988	M24SR::StatusTypeDef M24SR::M24SR_SendChangeReferenceData(uint16_t uPwdId,
giovannivisentini	29:7a2dfd06cb29	989	uint8_t *pPwd) {
giovannivisentini	29:7a2dfd06cb29	990	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	991	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	992	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	993	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	994
giovannivisentini	29:7a2dfd06cb29	995	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	996	if (uPwdId > 0x0003) {
giovannivisentini	29:7a2dfd06cb29	997	getCallback()->on_change_reference_data(this,M24SR_IO_ERROR_PARAMETER,
giovannivisentini	29:7a2dfd06cb29	998	constToPasswordType(uPwdId), pPwd);
giovannivisentini	29:7a2dfd06cb29	999	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1000	}
giovannivisentini	29:7a2dfd06cb29	1001
giovannivisentini	29:7a2dfd06cb29	1002	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1003	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	1004	command.Header.INS = C_APDU_CHANGE;
giovannivisentini	29:7a2dfd06cb29	1005	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1006	command.Header.P1 = GETMSB(uPwdId);
giovannivisentini	29:7a2dfd06cb29	1007	command.Header.P2 = GETLSB(uPwdId);
giovannivisentini	29:7a2dfd06cb29	1008	/* copy the number of byte of the data field */
giovannivisentini	29:7a2dfd06cb29	1009	command.Body.LC = M24SR_PASSWORD_NBBYTE;
giovannivisentini	29:7a2dfd06cb29	1010	/* copy the password */
giovannivisentini	29:7a2dfd06cb29	1011	command.Body.pData = pPwd;
giovannivisentini	29:7a2dfd06cb29	1012	/* build the IÃƒâ€šÃ‚Â²C command */
giovannivisentini	29:7a2dfd06cb29	1013	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_CHANGEREFDATA, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	1014	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1015
giovannivisentini	29:7a2dfd06cb29	1016	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1017	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1018	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1019	getCallback()->on_change_reference_data(this,status,
giovannivisentini	29:7a2dfd06cb29	1020	constToPasswordType(uPwdId), pPwd);
giovannivisentini	29:7a2dfd06cb29	1021	return status;
giovannivisentini	29:7a2dfd06cb29	1022	}
giovannivisentini	29:7a2dfd06cb29	1023
giovannivisentini	29:7a2dfd06cb29	1024	mLastCommandSend = CHANGE_REFERENCE_DATA;
giovannivisentini	29:7a2dfd06cb29	1025	mLastCommandData.data = pPwd;
giovannivisentini	29:7a2dfd06cb29	1026	//use the offset filed for store the pwd id;
giovannivisentini	29:7a2dfd06cb29	1027	mLastCommandData.offset = (uint8_t)uPwdId;
giovannivisentini	29:7a2dfd06cb29	1028
giovannivisentini	29:7a2dfd06cb29	1029	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	1030	return M24SR_ReceiveChangeReferenceData();
giovannivisentini	29:7a2dfd06cb29	1031	}//if
giovannivisentini	29:7a2dfd06cb29	1032
giovannivisentini	29:7a2dfd06cb29	1033	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1034	}
giovannivisentini	29:7a2dfd06cb29	1035
giovannivisentini	29:7a2dfd06cb29	1036	M24SR::StatusTypeDef M24SR::M24SR_ReceiveChangeReferenceData(){
giovannivisentini	29:7a2dfd06cb29	1037	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1038	//TODO the size is 3?
giovannivisentini	29:7a2dfd06cb29	1039	uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	1040
giovannivisentini	29:7a2dfd06cb29	1041	PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini	29:7a2dfd06cb29	1042	uint8_t *data = mLastCommandData.data;
giovannivisentini	29:7a2dfd06cb29	1043
giovannivisentini	29:7a2dfd06cb29	1044	status =M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
giovannivisentini	29:7a2dfd06cb29	1045	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1046	getCallback()->on_change_reference_data(this,status,type,data);
giovannivisentini	29:7a2dfd06cb29	1047	return status;
giovannivisentini	29:7a2dfd06cb29	1048	}//else
giovannivisentini	29:7a2dfd06cb29	1049
giovannivisentini	29:7a2dfd06cb29	1050	status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1051	getCallback()->on_change_reference_data(this,status,type,data);
giovannivisentini	29:7a2dfd06cb29	1052	return status;
giovannivisentini	29:7a2dfd06cb29	1053	}
giovannivisentini	29:7a2dfd06cb29	1054
giovannivisentini	29:7a2dfd06cb29	1055	/**
giovannivisentini	29:7a2dfd06cb29	1056	* @brief This function sends the EnableVerificationRequirement command
giovannivisentini	29:7a2dfd06cb29	1057	* @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini	29:7a2dfd06cb29	1058	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	1059	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	1060	*/
giovannivisentini	29:7a2dfd06cb29	1061	M24SR::StatusTypeDef M24SR::M24SR_SendEnableVerificationRequirement(
giovannivisentini	29:7a2dfd06cb29	1062	uint16_t uReadOrWrite) {
giovannivisentini	29:7a2dfd06cb29	1063	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	1064	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1065	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	1066	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	1067
giovannivisentini	29:7a2dfd06cb29	1068	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	1069	if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
giovannivisentini	29:7a2dfd06cb29	1070	getCallback()->on_enable_verification_requirement(this,M24SR_IO_ERROR_PARAMETER,
giovannivisentini	29:7a2dfd06cb29	1071	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1072	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1073	}
giovannivisentini	29:7a2dfd06cb29	1074
giovannivisentini	29:7a2dfd06cb29	1075	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1076	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	1077	command.Header.INS = C_APDU_ENABLE;
giovannivisentini	29:7a2dfd06cb29	1078	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1079	command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1080	command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1081	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	1082	M24SR_BuildIBlockCommand( M24SR_CMDSTRUCT_ENABLEVERIFREQ, &command,
giovannivisentini	29:7a2dfd06cb29	1083	uDIDbyte, &NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1084
giovannivisentini	29:7a2dfd06cb29	1085	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1086	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1087	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1088	getCallback()->on_enable_verification_requirement(this,status,
giovannivisentini	29:7a2dfd06cb29	1089	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1090	return status;
giovannivisentini	29:7a2dfd06cb29	1091	}//if
giovannivisentini	29:7a2dfd06cb29	1092
giovannivisentini	29:7a2dfd06cb29	1093	mLastCommandSend = ENABLE_VERIFICATION_REQUIREMENT;
giovannivisentini	29:7a2dfd06cb29	1094	//use the offset filed for store the pwd id;
giovannivisentini	29:7a2dfd06cb29	1095	mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini	29:7a2dfd06cb29	1096
giovannivisentini	29:7a2dfd06cb29	1097	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	1098	return M24SR_ReceiveEnableVerificationRequirement();
giovannivisentini	29:7a2dfd06cb29	1099	}//if
giovannivisentini	29:7a2dfd06cb29	1100
giovannivisentini	29:7a2dfd06cb29	1101	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1102	}
giovannivisentini	29:7a2dfd06cb29	1103
giovannivisentini	29:7a2dfd06cb29	1104	M24SR::StatusTypeDef M24SR::M24SR_ReceiveEnableVerificationRequirement(){
giovannivisentini	29:7a2dfd06cb29	1105	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1106	//TODO the size is 3?
giovannivisentini	29:7a2dfd06cb29	1107	uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	1108
giovannivisentini	29:7a2dfd06cb29	1109	const PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini	29:7a2dfd06cb29	1110
giovannivisentini	29:7a2dfd06cb29	1111	status =M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
giovannivisentini	29:7a2dfd06cb29	1112	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1113	getCallback()->on_enable_verification_requirement(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1114	return status;
giovannivisentini	29:7a2dfd06cb29	1115	}//else
giovannivisentini	29:7a2dfd06cb29	1116
giovannivisentini	29:7a2dfd06cb29	1117	status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1118	getCallback()->on_enable_verification_requirement(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1119	return status;
giovannivisentini	29:7a2dfd06cb29	1120	}
giovannivisentini	29:7a2dfd06cb29	1121
giovannivisentini	29:7a2dfd06cb29	1122
giovannivisentini	29:7a2dfd06cb29	1123	/**
giovannivisentini	29:7a2dfd06cb29	1124	* @brief This function sends the DisableVerificationRequirement command
giovannivisentini	29:7a2dfd06cb29	1125	* @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini	29:7a2dfd06cb29	1126	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	1127	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	1128	*/
giovannivisentini	29:7a2dfd06cb29	1129	M24SR::StatusTypeDef M24SR::M24SR_SendDisableVerificationRequirement(
giovannivisentini	29:7a2dfd06cb29	1130	uint16_t uReadOrWrite) {
giovannivisentini	29:7a2dfd06cb29	1131	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	1132	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1133	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	1134	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	1135
giovannivisentini	29:7a2dfd06cb29	1136	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	1137	if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
giovannivisentini	29:7a2dfd06cb29	1138	getCallback()->on_disable_verification_requirement(this,M24SR_IO_ERROR_PARAMETER,
giovannivisentini	29:7a2dfd06cb29	1139	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1140	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1141	}
giovannivisentini	29:7a2dfd06cb29	1142
giovannivisentini	29:7a2dfd06cb29	1143	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1144	command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini	29:7a2dfd06cb29	1145	command.Header.INS = C_APDU_DISABLE;
giovannivisentini	29:7a2dfd06cb29	1146	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1147	command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1148	command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1149	/* build the IÃƒâ€šÃ‚Â²C command */
giovannivisentini	29:7a2dfd06cb29	1150	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_DISABLEVERIFREQ, &command,
giovannivisentini	29:7a2dfd06cb29	1151	uDIDbyte, &NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1152
giovannivisentini	29:7a2dfd06cb29	1153	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1154	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1155	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1156	getCallback()->on_disable_verification_requirement(this,status,
giovannivisentini	29:7a2dfd06cb29	1157	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1158	return status;
giovannivisentini	29:7a2dfd06cb29	1159	}
giovannivisentini	29:7a2dfd06cb29	1160
giovannivisentini	29:7a2dfd06cb29	1161	mLastCommandSend = DISABLE_VERIFICATION_REQUIREMENT;
giovannivisentini	29:7a2dfd06cb29	1162	//use the offset filed for store the pwd id;
giovannivisentini	29:7a2dfd06cb29	1163	mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini	29:7a2dfd06cb29	1164
giovannivisentini	29:7a2dfd06cb29	1165	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	1166	return M24SR_ReceiveDisableVerificationRequirement();
giovannivisentini	29:7a2dfd06cb29	1167	}
giovannivisentini	29:7a2dfd06cb29	1168
giovannivisentini	29:7a2dfd06cb29	1169	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1170
giovannivisentini	29:7a2dfd06cb29	1171	}
giovannivisentini	29:7a2dfd06cb29	1172
giovannivisentini	29:7a2dfd06cb29	1173	M24SR::StatusTypeDef M24SR::M24SR_ReceiveDisableVerificationRequirement(){
giovannivisentini	29:7a2dfd06cb29	1174	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1175	//TODO the size is 3?
giovannivisentini	29:7a2dfd06cb29	1176	uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	1177
giovannivisentini	29:7a2dfd06cb29	1178	PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini	29:7a2dfd06cb29	1179
giovannivisentini	29:7a2dfd06cb29	1180	status =M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
giovannivisentini	29:7a2dfd06cb29	1181	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1182	getCallback()->on_disable_verification_requirement(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1183	return status;
giovannivisentini	29:7a2dfd06cb29	1184	}//else
giovannivisentini	29:7a2dfd06cb29	1185
giovannivisentini	29:7a2dfd06cb29	1186	status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1187	getCallback()->on_disable_verification_requirement(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1188	return status;
giovannivisentini	29:7a2dfd06cb29	1189	}
giovannivisentini	29:7a2dfd06cb29	1190
giovannivisentini	29:7a2dfd06cb29	1191
giovannivisentini	29:7a2dfd06cb29	1192	/**
giovannivisentini	29:7a2dfd06cb29	1193	* @brief This function sends the EnablePermananentState command
giovannivisentini	29:7a2dfd06cb29	1194	* @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini	29:7a2dfd06cb29	1195	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	1196	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	1197	*/
giovannivisentini	29:7a2dfd06cb29	1198	M24SR::StatusTypeDef M24SR::M24SR_SendEnablePermanentState(uint16_t uReadOrWrite) {
giovannivisentini	29:7a2dfd06cb29	1199	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	1200	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1201
giovannivisentini	29:7a2dfd06cb29	1202	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	1203	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	1204
giovannivisentini	29:7a2dfd06cb29	1205	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	1206	if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
giovannivisentini	29:7a2dfd06cb29	1207	getCallback()->on_enable_permanent_state(this,M24SR_IO_ERROR_PARAMETER,
giovannivisentini	29:7a2dfd06cb29	1208	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1209	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1210	}
giovannivisentini	29:7a2dfd06cb29	1211
giovannivisentini	29:7a2dfd06cb29	1212	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1213	command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini	29:7a2dfd06cb29	1214	command.Header.INS = C_APDU_ENABLE;
giovannivisentini	29:7a2dfd06cb29	1215	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1216	command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1217	command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1218	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	1219	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_ENABLEVERIFREQ, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	1220	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1221
giovannivisentini	29:7a2dfd06cb29	1222	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1223	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1224	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1225	getCallback()->on_enable_permanent_state(this,status,
giovannivisentini	29:7a2dfd06cb29	1226	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1227	return status;
giovannivisentini	29:7a2dfd06cb29	1228	}
giovannivisentini	29:7a2dfd06cb29	1229
giovannivisentini	29:7a2dfd06cb29	1230	mLastCommandSend = ENABLE_PERMANET_STATE;
giovannivisentini	29:7a2dfd06cb29	1231	//use the offset filed for store the pwd id;
giovannivisentini	29:7a2dfd06cb29	1232	mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini	29:7a2dfd06cb29	1233
giovannivisentini	29:7a2dfd06cb29	1234	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	1235	return M24SR_ReceiveEnablePermanentState();
giovannivisentini	29:7a2dfd06cb29	1236	}
giovannivisentini	29:7a2dfd06cb29	1237
giovannivisentini	29:7a2dfd06cb29	1238	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1239	}
giovannivisentini	29:7a2dfd06cb29	1240
giovannivisentini	29:7a2dfd06cb29	1241	M24SR::StatusTypeDef M24SR::M24SR_ReceiveEnablePermanentState(){
giovannivisentini	29:7a2dfd06cb29	1242	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1243	//TODO the size is 3?
giovannivisentini	29:7a2dfd06cb29	1244	uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	1245
giovannivisentini	29:7a2dfd06cb29	1246	PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini	29:7a2dfd06cb29	1247
giovannivisentini	29:7a2dfd06cb29	1248	status =M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
giovannivisentini	29:7a2dfd06cb29	1249	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1250	getCallback()->on_enable_permanent_state(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1251	return status;
giovannivisentini	29:7a2dfd06cb29	1252	}//else
giovannivisentini	29:7a2dfd06cb29	1253
giovannivisentini	29:7a2dfd06cb29	1254	status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1255	getCallback()->on_enable_permanent_state(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1256	return status;
giovannivisentini	29:7a2dfd06cb29	1257	}
giovannivisentini	29:7a2dfd06cb29	1258
giovannivisentini	29:7a2dfd06cb29	1259
giovannivisentini	29:7a2dfd06cb29	1260	/**
giovannivisentini	29:7a2dfd06cb29	1261	* @brief This function sends the DisablePermanentState command
giovannivisentini	29:7a2dfd06cb29	1262	* @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini	29:7a2dfd06cb29	1263	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	1264	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	1265	*/
giovannivisentini	29:7a2dfd06cb29	1266	M24SR::StatusTypeDef M24SR::M24SR_SendDisablePermanentState(uint16_t uReadOrWrite) {
giovannivisentini	29:7a2dfd06cb29	1267	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	1268	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1269	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	1270	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	1271
giovannivisentini	29:7a2dfd06cb29	1272	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	1273	if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
giovannivisentini	29:7a2dfd06cb29	1274	getCallback()->on_disable_permanent_state(this,M24SR_IO_ERROR_PARAMETER,
giovannivisentini	29:7a2dfd06cb29	1275	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1276	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1277	}
giovannivisentini	29:7a2dfd06cb29	1278
giovannivisentini	29:7a2dfd06cb29	1279	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1280	command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini	29:7a2dfd06cb29	1281	command.Header.INS = C_APDU_DISABLE;
giovannivisentini	29:7a2dfd06cb29	1282	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1283	command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1284	command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini	29:7a2dfd06cb29	1285	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	1286	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_DISABLEVERIFREQ, &command,
giovannivisentini	29:7a2dfd06cb29	1287	uDIDbyte, &NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1288
giovannivisentini	29:7a2dfd06cb29	1289	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1290	status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1291	if(status != M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1292	getCallback()->on_enable_permanent_state(this,status,
giovannivisentini	29:7a2dfd06cb29	1293	constToPasswordType(uReadOrWrite));
giovannivisentini	29:7a2dfd06cb29	1294	return status;
giovannivisentini	29:7a2dfd06cb29	1295	}
giovannivisentini	29:7a2dfd06cb29	1296
giovannivisentini	29:7a2dfd06cb29	1297	mLastCommandSend = DISABLE_PERMANET_STATE;
giovannivisentini	29:7a2dfd06cb29	1298	//use the offset filed for store the pwd id;
giovannivisentini	29:7a2dfd06cb29	1299	mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini	29:7a2dfd06cb29	1300
giovannivisentini	29:7a2dfd06cb29	1301	if(mCommunicationType==M24SR::SYNC){
giovannivisentini	31:85fdf6fd3da5	1302	return M24SR_ReceiveDisablePermanentState();
giovannivisentini	29:7a2dfd06cb29	1303	}
giovannivisentini	29:7a2dfd06cb29	1304
giovannivisentini	29:7a2dfd06cb29	1305	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1306	}
giovannivisentini	29:7a2dfd06cb29	1307
giovannivisentini	29:7a2dfd06cb29	1308	M24SR::StatusTypeDef M24SR::M24SR_ReceiveDisablePermanentState(){
giovannivisentini	29:7a2dfd06cb29	1309	M24SR::StatusTypeDef status;
giovannivisentini	29:7a2dfd06cb29	1310	//TODO the size is 3?
giovannivisentini	29:7a2dfd06cb29	1311	uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini	29:7a2dfd06cb29	1312
giovannivisentini	29:7a2dfd06cb29	1313	PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini	29:7a2dfd06cb29	1314
giovannivisentini	29:7a2dfd06cb29	1315	status =M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
giovannivisentini	29:7a2dfd06cb29	1316	if(status!=M24SR_SUCCESS){
giovannivisentini	29:7a2dfd06cb29	1317	getCallback()->on_disable_permanent_state(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1318	return status;
giovannivisentini	29:7a2dfd06cb29	1319	}//else
giovannivisentini	29:7a2dfd06cb29	1320
giovannivisentini	29:7a2dfd06cb29	1321	status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1322	getCallback()->on_disable_permanent_state(this,status,type);
giovannivisentini	29:7a2dfd06cb29	1323	return status;
giovannivisentini	29:7a2dfd06cb29	1324	}
giovannivisentini	29:7a2dfd06cb29	1325
giovannivisentini	29:7a2dfd06cb29	1326	/**
giovannivisentini	29:7a2dfd06cb29	1327	* @brief This function generates an interrupt on GPO pin
giovannivisentini	29:7a2dfd06cb29	1328	* @param None
giovannivisentini	29:7a2dfd06cb29	1329	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	1330	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	1331	*/
giovannivisentini	29:7a2dfd06cb29	1332	M24SR::StatusTypeDef M24SR::M24SR_SendInterrupt(void) {
giovannivisentini	29:7a2dfd06cb29	1333	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	1334
giovannivisentini	29:7a2dfd06cb29	1335	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	1336	uint16_t uP1P2 = 0x001E;
giovannivisentini	29:7a2dfd06cb29	1337	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	1338
giovannivisentini	29:7a2dfd06cb29	1339
giovannivisentini	29:7a2dfd06cb29	1340	StatusTypeDef status = M24SR_ManageI2CGPO(INTERRUPT);
giovannivisentini	29:7a2dfd06cb29	1341	if(status!=M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	1342	return status;
giovannivisentini	29:7a2dfd06cb29	1343
giovannivisentini	29:7a2dfd06cb29	1344	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1345	command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini	29:7a2dfd06cb29	1346	command.Header.INS = C_APDU_INTERRUPT;
giovannivisentini	29:7a2dfd06cb29	1347	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1348	command.Header.P1 = GETMSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	1349	command.Header.P2 = GETLSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	1350	command.Body.LC = 0x00;
giovannivisentini	29:7a2dfd06cb29	1351	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	1352	M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_SENDINTERRUPT, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	1353	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1354
giovannivisentini	29:7a2dfd06cb29	1355	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1356	errchk(M24SR_IO_SendI2Ccommand(NbByte, pBuffer));
giovannivisentini	31:85fdf6fd3da5	1357	//errchk(M24SR_IO_PollI2C());
giovannivisentini	29:7a2dfd06cb29	1358	/* read the response */
giovannivisentini	29:7a2dfd06cb29	1359	errchk(
giovannivisentini	29:7a2dfd06cb29	1360	M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , pBuffer ));
giovannivisentini	29:7a2dfd06cb29	1361
giovannivisentini	29:7a2dfd06cb29	1362	return M24SR_IsCorrectCRC16Residue(pBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1363
giovannivisentini	29:7a2dfd06cb29	1364	}
giovannivisentini	29:7a2dfd06cb29	1365
giovannivisentini	29:7a2dfd06cb29	1366	/**
giovannivisentini	29:7a2dfd06cb29	1367	* @brief This function forces GPO pin to low state or high Z
giovannivisentini	29:7a2dfd06cb29	1368	* @param uSetOrReset select if GPO must be low (reset) or HiZ
giovannivisentini	29:7a2dfd06cb29	1369	* @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini	29:7a2dfd06cb29	1370	* @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini	29:7a2dfd06cb29	1371	*/
giovannivisentini	29:7a2dfd06cb29	1372	M24SR::StatusTypeDef M24SR::M24SR_StateControl(uint8_t uSetOrReset) {
giovannivisentini	29:7a2dfd06cb29	1373	C_APDU command;
giovannivisentini	29:7a2dfd06cb29	1374	uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini	29:7a2dfd06cb29	1375	uint16_t uP1P2 = 0x001F;
giovannivisentini	29:7a2dfd06cb29	1376	uint16_t NbByte;
giovannivisentini	29:7a2dfd06cb29	1377
giovannivisentini	29:7a2dfd06cb29	1378	/check the parameters /
giovannivisentini	29:7a2dfd06cb29	1379	if ((uSetOrReset != 0x01) && (uSetOrReset != 0x00)) {
giovannivisentini	29:7a2dfd06cb29	1380	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1381	}
giovannivisentini	29:7a2dfd06cb29	1382
giovannivisentini	29:7a2dfd06cb29	1383
giovannivisentini	29:7a2dfd06cb29	1384	StatusTypeDef status = M24SR_ManageI2CGPO(STATE_CONTROL);
giovannivisentini	29:7a2dfd06cb29	1385	if(status == M24SR_SUCCESS)
giovannivisentini	29:7a2dfd06cb29	1386	return status;
giovannivisentini	29:7a2dfd06cb29	1387
giovannivisentini	29:7a2dfd06cb29	1388	/* build the command */
giovannivisentini	29:7a2dfd06cb29	1389	command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini	29:7a2dfd06cb29	1390	command.Header.INS = C_APDU_INTERRUPT;
giovannivisentini	29:7a2dfd06cb29	1391	/* copy the Password Id */
giovannivisentini	29:7a2dfd06cb29	1392	command.Header.P1 = GETMSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	1393	command.Header.P2 = GETLSB(uP1P2);
giovannivisentini	29:7a2dfd06cb29	1394	command.Body.LC = 0x01;
giovannivisentini	29:7a2dfd06cb29	1395	command.Body.pData = &uSetOrReset;
giovannivisentini	29:7a2dfd06cb29	1396	/* copy the data */
giovannivisentini	29:7a2dfd06cb29	1397	//memcpy(command.Body.pData , &uSetOrReset, 0x01 );
giovannivisentini	29:7a2dfd06cb29	1398	//command.Body.LE = 0x00 ;
giovannivisentini	29:7a2dfd06cb29	1399	/* build the I2C command */
giovannivisentini	29:7a2dfd06cb29	1400	M24SR_BuildIBlockCommand( M24SR_CMDSTRUCT_GPOSTATE, &command, uDIDbyte,
giovannivisentini	29:7a2dfd06cb29	1401	&NbByte, pBuffer);
giovannivisentini	29:7a2dfd06cb29	1402
giovannivisentini	29:7a2dfd06cb29	1403	/* send the request */
giovannivisentini	29:7a2dfd06cb29	1404	errchk(M24SR_IO_SendI2Ccommand(NbByte, pBuffer));
giovannivisentini	31:85fdf6fd3da5	1405	//errchk(M24SR_IO_PollI2C());
giovannivisentini	29:7a2dfd06cb29	1406	/* read the response */
giovannivisentini	29:7a2dfd06cb29	1407	errchk(
giovannivisentini	29:7a2dfd06cb29	1408	M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , pBuffer ));
giovannivisentini	29:7a2dfd06cb29	1409
giovannivisentini	29:7a2dfd06cb29	1410	return M24SR_IsCorrectCRC16Residue(pBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini	29:7a2dfd06cb29	1411
giovannivisentini	29:7a2dfd06cb29	1412	}
giovannivisentini	29:7a2dfd06cb29	1413
giovannivisentini	29:7a2dfd06cb29	1414
giovannivisentini	29:7a2dfd06cb29	1415	M24SR::StatusTypeDef M24SR::M24SR_ManageI2CGPO(NFC_GPO_MGMT GPO_I2Cconfig) {
giovannivisentini	29:7a2dfd06cb29	1416
giovannivisentini	29:7a2dfd06cb29	1417	if(GPOPin.is_connected()==0){
giovannivisentini	29:7a2dfd06cb29	1418	return M24SR_IO_PIN_NOT_CONNECTED;
giovannivisentini	29:7a2dfd06cb29	1419	}
giovannivisentini	29:7a2dfd06cb29	1420	if (GPO_I2Cconfig > STATE_CONTROL) {
giovannivisentini	29:7a2dfd06cb29	1421	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1422	}
giovannivisentini	29:7a2dfd06cb29	1423	//enable the callback for change the gpo
giovannivisentini	29:7a2dfd06cb29	1424	mComponentCallback = &mManageGPOCallback;
giovannivisentini	29:7a2dfd06cb29	1425	mManageGPOCallback.set_new_GPO_config(true,GPO_I2Cconfig);
giovannivisentini	29:7a2dfd06cb29	1426
giovannivisentini	29:7a2dfd06cb29	1427	//start the manageGPO procedure
giovannivisentini	29:7a2dfd06cb29	1428	return M24SR_SendSelectApplication();
giovannivisentini	29:7a2dfd06cb29	1429	}
giovannivisentini	29:7a2dfd06cb29	1430
giovannivisentini	29:7a2dfd06cb29	1431	M24SR::StatusTypeDef M24SR::M24SR_ManageRFGPO(NFC_GPO_MGMT GPO_I2Cconfig) {
giovannivisentini	29:7a2dfd06cb29	1432
giovannivisentini	29:7a2dfd06cb29	1433	if(RFDisablePin.is_connected()==0){
giovannivisentini	29:7a2dfd06cb29	1434	return M24SR_IO_PIN_NOT_CONNECTED;
giovannivisentini	29:7a2dfd06cb29	1435	}
giovannivisentini	29:7a2dfd06cb29	1436	if (GPO_I2Cconfig > STATE_CONTROL) {
giovannivisentini	29:7a2dfd06cb29	1437	return M24SR_IO_ERROR_PARAMETER;
giovannivisentini	29:7a2dfd06cb29	1438	}
giovannivisentini	29:7a2dfd06cb29	1439
giovannivisentini	29:7a2dfd06cb29	1440	//enable the callback for change the gpo
giovannivisentini	29:7a2dfd06cb29	1441	mComponentCallback = &mManageGPOCallback;
giovannivisentini	29:7a2dfd06cb29	1442	mManageGPOCallback.set_new_GPO_config(false,GPO_I2Cconfig);
giovannivisentini	29:7a2dfd06cb29	1443
giovannivisentini	29:7a2dfd06cb29	1444	//start the manageGPO procedure
giovannivisentini	29:7a2dfd06cb29	1445	return M24SR_SendSelectApplication();
giovannivisentini	29:7a2dfd06cb29	1446	}
giovannivisentini	29:7a2dfd06cb29	1447
giovannivisentini	29:7a2dfd06cb29	1448	M24SR::StatusTypeDef M24SR::M24SR_RFConfig(uint8_t OnOffChoice) {
giovannivisentini	29:7a2dfd06cb29	1449	if(RFDisablePin.is_connected()==0){
giovannivisentini	29:7a2dfd06cb29	1450	return M24SR_IO_PIN_NOT_CONNECTED;
giovannivisentini	29:7a2dfd06cb29	1451	}
giovannivisentini	29:7a2dfd06cb29	1452	/* Disable RF */
giovannivisentini	29:7a2dfd06cb29	1453	if (OnOffChoice != 0) {
giovannivisentini	29:7a2dfd06cb29	1454	M24SR_IO_RFDIS_WritePin(GPIO_PIN_RESET);
giovannivisentini	29:7a2dfd06cb29	1455	} else {
giovannivisentini	29:7a2dfd06cb29	1456	M24SR_IO_RFDIS_WritePin(GPIO_PIN_SET);
giovannivisentini	29:7a2dfd06cb29	1457	}
giovannivisentini	29:7a2dfd06cb29	1458	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1459	}
giovannivisentini	29:7a2dfd06cb29	1460
giovannivisentini	29:7a2dfd06cb29	1461	M24SR::StatusTypeDef M24SR::M24SR_IO_SendI2Ccommand(uint8_t NbByte,
giovannivisentini	29:7a2dfd06cb29	1462	uint8_t *pBuffer) {
giovannivisentini	31:85fdf6fd3da5	1463
giovannivisentini	31:85fdf6fd3da5	1464	int nTry = 0;
giovannivisentini	31:85fdf6fd3da5	1465	int status =1;
giovannivisentini	31:85fdf6fd3da5	1466	while (status != 0 && (nTry++)<M24SR_MAX_I2C_ACCESS_TRY) {
giovannivisentini	31:85fdf6fd3da5	1467	status = dev_I2C.write(address, (char*) pBuffer, NbByte);
giovannivisentini	31:85fdf6fd3da5	1468
giovannivisentini	31:85fdf6fd3da5	1469	}
giovannivisentini	31:85fdf6fd3da5	1470	if (status == 0)
giovannivisentini	29:7a2dfd06cb29	1471	return M24SR_SUCCESS;
giovannivisentini	31:85fdf6fd3da5	1472
giovannivisentini	29:7a2dfd06cb29	1473	return M24SR_IO_ERROR_I2CTIMEOUT;
giovannivisentini	31:85fdf6fd3da5	1474
giovannivisentini	29:7a2dfd06cb29	1475	}
giovannivisentini	29:7a2dfd06cb29	1476
giovannivisentini	29:7a2dfd06cb29	1477	M24SR::StatusTypeDef M24SR::M24SR_IO_ReceiveI2Cresponse(uint8_t NbByte,
giovannivisentini	29:7a2dfd06cb29	1478	uint8_t *pBuffer) {
giovannivisentini	31:85fdf6fd3da5	1479
giovannivisentini	31:85fdf6fd3da5	1480	int nTry = 0;
giovannivisentini	31:85fdf6fd3da5	1481	int status =1;
giovannivisentini	31:85fdf6fd3da5	1482	while (status != 0 && (nTry++)<M24SR_MAX_I2C_ACCESS_TRY) {
giovannivisentini	31:85fdf6fd3da5	1483	status = dev_I2C.read(address, (char*) pBuffer, NbByte);
giovannivisentini	31:85fdf6fd3da5	1484	}
giovannivisentini	31:85fdf6fd3da5	1485	if (status == 0)
giovannivisentini	29:7a2dfd06cb29	1486	return M24SR_SUCCESS;
giovannivisentini	31:85fdf6fd3da5	1487
giovannivisentini	29:7a2dfd06cb29	1488	return M24SR_IO_ERROR_I2CTIMEOUT;
giovannivisentini	29:7a2dfd06cb29	1489	}
giovannivisentini	29:7a2dfd06cb29	1490
giovannivisentini	29:7a2dfd06cb29	1491
giovannivisentini	29:7a2dfd06cb29	1492	M24SR::StatusTypeDef M24SR::manage_event(void){
giovannivisentini	29:7a2dfd06cb29	1493
giovannivisentini	29:7a2dfd06cb29	1494	switch(mLastCommandSend){
giovannivisentini	29:7a2dfd06cb29	1495	case SELECT_APPLICATION:
giovannivisentini	29:7a2dfd06cb29	1496	return M24SR_ReceiveSelectApplication();
giovannivisentini	29:7a2dfd06cb29	1497	case SELECT_CC_FILE:
giovannivisentini	29:7a2dfd06cb29	1498	return M24SR_ReceiveSelectCCfile();
giovannivisentini	29:7a2dfd06cb29	1499	case SELECT_NDEF_FILE:
giovannivisentini	29:7a2dfd06cb29	1500	return M24SR_ReceiveSelectNDEFfile();
giovannivisentini	29:7a2dfd06cb29	1501	case SELECT_SYSTEM_FILE:
giovannivisentini	29:7a2dfd06cb29	1502	return M24SR_ReceiveSelectSystemfile();
giovannivisentini	29:7a2dfd06cb29	1503	case READ:
giovannivisentini	29:7a2dfd06cb29	1504	return M24SR_ReceiveReadBinary();
giovannivisentini	29:7a2dfd06cb29	1505	case UPDATE:
giovannivisentini	29:7a2dfd06cb29	1506	return M24SR_ReceiveUpdateBinary();
giovannivisentini	29:7a2dfd06cb29	1507	case VERIFY:
giovannivisentini	29:7a2dfd06cb29	1508	return M24SR_ReceiveVerify();
giovannivisentini	29:7a2dfd06cb29	1509	case DESELECT:
giovannivisentini	29:7a2dfd06cb29	1510	return M24SR_ReceiveDeselect();
giovannivisentini	29:7a2dfd06cb29	1511	case CHANGE_REFERENCE_DATA:
giovannivisentini	29:7a2dfd06cb29	1512	return M24SR_ReceiveChangeReferenceData();
giovannivisentini	29:7a2dfd06cb29	1513	case ENABLE_VERIFICATION_REQUIREMENT:
giovannivisentini	29:7a2dfd06cb29	1514	return M24SR_ReceiveEnableVerificationRequirement();
giovannivisentini	29:7a2dfd06cb29	1515	case DISABLE_VERIFICATION_REQUIREMENT:
giovannivisentini	29:7a2dfd06cb29	1516	return M24SR_ReceiveDisableVerificationRequirement();
giovannivisentini	29:7a2dfd06cb29	1517	case ENABLE_PERMANET_STATE:
giovannivisentini	29:7a2dfd06cb29	1518	return M24SR_ReceiveEnablePermanentState();
giovannivisentini	29:7a2dfd06cb29	1519	case DISABLE_PERMANET_STATE:
giovannivisentini	29:7a2dfd06cb29	1520	return M24SR_ReceiveDisablePermanentState();
giovannivisentini	29:7a2dfd06cb29	1521
giovannivisentini	29:7a2dfd06cb29	1522	default:
giovannivisentini	29:7a2dfd06cb29	1523	return M24SR_SUCCESS;
giovannivisentini	29:7a2dfd06cb29	1524	}//switch
giovannivisentini	29:7a2dfd06cb29	1525	}//manageInterrupt
giovannivisentini	29:7a2dfd06cb29	1526
giovannivisentini	29:7a2dfd06cb29	1527	NDefLib::NDefNfcTag& M24SR::get_NDef_tag(){
giovannivisentini	29:7a2dfd06cb29	1528	return *mNDefTagUtil;
giovannivisentini	29:7a2dfd06cb29	1529	}
giovannivisentini	29:7a2dfd06cb29	1530
giovannivisentini	29:7a2dfd06cb29	1531	/***************** (C) COPYRIGHT 2013 STMicroelectronics *END OF FILE**/

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	03 Feb 2016
Imports:	153
Forks:	1
Commits:	38
Dependents:	13
Dependencies:	1
Followers:	409

The code in this repository is Apache licensed.

Components

X-NUCLEO-NFC01A1 Dynamic NFC Tag