ST / X_NUCLEO_NFC01A1

Firmware library for the X-NUCLEO-NFC01A1 Dynamic NFC Tag board.

Dependencies:   M24SR

Dependents:   NFC M2M_2016_STM32 MyongjiElec_capstone1 IDW01M1_Cloud_IBM ... more

Fork of X_NUCLEO_NFC01A1 by ST Expansion SW Team

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@35:7b2b4dbed7ae, 2017-07-13 (annotated)

Committer:
Davidroid
Date:
Thu Jul 13 08:50:50 2017 +0000
Revision:
35:7b2b4dbed7ae
Parent:
34:b76765d2cc68 
Control code added to the "M24SR_SendSelectNDEFfile()" function.

Who changed what in which revision?

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