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@34:b76765d2cc68, 2017-07-12 (annotated)

Committer:
Davidroid
Date:
Wed Jul 12 14:22:19 2017 +0000
Revision:
34:b76765d2cc68
Parent:
33:e6b7e74be1d5
Child:
35:7b2b4dbed7ae
Updated to fit ARM coding style.

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 33:e6b7e74be1d5 679 if (status!=M24SR_SUCCESS) {}
giovannivisentini 29:7a2dfd06cb29 680
giovannivisentini 29:7a2dfd06cb29 681 mLastCommandSend=SELECT_NDEF_FILE;
giovannivisentini 29:7a2dfd06cb29 682
Davidroid 33:e6b7e74be1d5 683 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 684 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 685 if (status==M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 686 return M24SR_ReceiveSelectNDEFfile();
Davidroid 33:e6b7e74be1d5 687 } else {
giovannivisentini 29:7a2dfd06cb29 688 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 689 getCallback()->on_selected_NDEF_file(this,status);
giovannivisentini 29:7a2dfd06cb29 690 return status;
giovannivisentini 29:7a2dfd06cb29 691 }
giovannivisentini 29:7a2dfd06cb29 692 }
giovannivisentini 29:7a2dfd06cb29 693
giovannivisentini 29:7a2dfd06cb29 694 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 695
giovannivisentini 29:7a2dfd06cb29 696 }
giovannivisentini 29:7a2dfd06cb29 697
Davidroid 34:b76765d2cc68 698 M24SR::StatusTypeDef M24SR::M24SR_ReceiveSelectNDEFfile(){
giovannivisentini 29:7a2dfd06cb29 699
giovannivisentini 29:7a2dfd06cb29 700 uint8_t pDataIn[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 701 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 702
giovannivisentini 29:7a2dfd06cb29 703 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 704
giovannivisentini 29:7a2dfd06cb29 705 status = M24SR_IO_ReceiveI2Cresponse(sizeof(pDataIn), pDataIn);
Davidroid 33:e6b7e74be1d5 706 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 707 getCallback()->on_selected_NDEF_file(this,status);
giovannivisentini 29:7a2dfd06cb29 708 return status;
giovannivisentini 29:7a2dfd06cb29 709 }//else
giovannivisentini 29:7a2dfd06cb29 710 status= M24SR_IsCorrectCRC16Residue(pDataIn, sizeof(pDataIn));
giovannivisentini 29:7a2dfd06cb29 711 getCallback()->on_selected_NDEF_file(this,status);
Davidroid 33:e6b7e74be1d5 712
giovannivisentini 29:7a2dfd06cb29 713 return status;
giovannivisentini 29:7a2dfd06cb29 714 }
giovannivisentini 29:7a2dfd06cb29 715
giovannivisentini 29:7a2dfd06cb29 716 /**
giovannivisentini 29:7a2dfd06cb29 717 * @brief This function sends a read binary command
giovannivisentini 29:7a2dfd06cb29 718 * @param Offset first byte to read
giovannivisentini 29:7a2dfd06cb29 719 * @param NbByteToRead number of bytes to read
giovannivisentini 29:7a2dfd06cb29 720 * @param pBufferRead pointer to the buffer read from the M24SR device
giovannivisentini 29:7a2dfd06cb29 721 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 722 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 723 */
Davidroid 34:b76765d2cc68 724 M24SR::StatusTypeDef M24SR::M24SR_SendReadBinary(uint16_t Offset, uint8_t NbByteToRead, uint8_t *pBufferRead) {
giovannivisentini 29:7a2dfd06cb29 725 //clamp the buffer to the max size
Davidroid 33:e6b7e74be1d5 726 if (NbByteToRead>M24SR_MAX_BYTE_OPERATION_LENGHT) {
giovannivisentini 29:7a2dfd06cb29 727 NbByteToRead=M24SR_MAX_BYTE_OPERATION_LENGHT;
Davidroid 33:e6b7e74be1d5 728 }
giovannivisentini 29:7a2dfd06cb29 729
giovannivisentini 29:7a2dfd06cb29 730 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 731 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 732 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 733 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 734
giovannivisentini 29:7a2dfd06cb29 735 /* build the command */
giovannivisentini 29:7a2dfd06cb29 736 command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini 29:7a2dfd06cb29 737 command.Header.INS = C_APDU_READ_BINARY;
giovannivisentini 29:7a2dfd06cb29 738 /* copy the offset */
giovannivisentini 29:7a2dfd06cb29 739 command.Header.P1 = GETMSB(Offset);
giovannivisentini 29:7a2dfd06cb29 740 command.Header.P2 = GETLSB(Offset);
giovannivisentini 29:7a2dfd06cb29 741 /* copy the number of byte to read */
giovannivisentini 29:7a2dfd06cb29 742 command.Body.LE = NbByteToRead;
giovannivisentini 29:7a2dfd06cb29 743
Davidroid 33:e6b7e74be1d5 744 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_READBINARY, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 745
giovannivisentini 29:7a2dfd06cb29 746 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 747 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 748 getCallback()->on_read_byte(this,status,Offset,pBufferRead,NbByteToRead);
giovannivisentini 29:7a2dfd06cb29 749 return status;
giovannivisentini 29:7a2dfd06cb29 750 }
giovannivisentini 29:7a2dfd06cb29 751
giovannivisentini 29:7a2dfd06cb29 752 mLastCommandSend=READ;
giovannivisentini 29:7a2dfd06cb29 753 mLastCommandData.data=pBufferRead;
giovannivisentini 29:7a2dfd06cb29 754 mLastCommandData.length=NbByteToRead;
giovannivisentini 29:7a2dfd06cb29 755 mLastCommandData.offset=Offset;
giovannivisentini 29:7a2dfd06cb29 756
Davidroid 33:e6b7e74be1d5 757 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 758 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 759 if (status==M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 760 return M24SR_ReceiveReadBinary();
Davidroid 33:e6b7e74be1d5 761 } else {
giovannivisentini 29:7a2dfd06cb29 762 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 763 getCallback()->on_read_byte(this,status,Offset,pBufferRead,NbByteToRead);
giovannivisentini 29:7a2dfd06cb29 764 return status;
giovannivisentini 29:7a2dfd06cb29 765 }//if-else
giovannivisentini 29:7a2dfd06cb29 766 }//if
giovannivisentini 29:7a2dfd06cb29 767
giovannivisentini 29:7a2dfd06cb29 768 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 769 }
giovannivisentini 29:7a2dfd06cb29 770
Davidroid 34:b76765d2cc68 771 M24SR::StatusTypeDef M24SR::M24SR_ReceiveReadBinary() {
giovannivisentini 29:7a2dfd06cb29 772 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 773 const uint16_t length = mLastCommandData.length;
giovannivisentini 29:7a2dfd06cb29 774 const uint16_t offset = mLastCommandData.offset;
giovannivisentini 29:7a2dfd06cb29 775 uint8_t *data = mLastCommandData.data;
giovannivisentini 29:7a2dfd06cb29 776
Davidroid 33:e6b7e74be1d5 777 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 778
giovannivisentini 29:7a2dfd06cb29 779 status = M24SR_IO_ReceiveI2Cresponse (length + M24SR_STATUSRESPONSE_NBBYTE , uM24SRbuffer );
Davidroid 33:e6b7e74be1d5 780 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 781 getCallback()->on_read_byte(this,status,offset,data,length);
giovannivisentini 29:7a2dfd06cb29 782 return status;
giovannivisentini 29:7a2dfd06cb29 783 }
giovannivisentini 29:7a2dfd06cb29 784 status = M24SR_IsCorrectCRC16Residue(uM24SRbuffer, length + M24SR_STATUSRESPONSE_NBBYTE);
Davidroid 33:e6b7e74be1d5 785 if (status != M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 786 getCallback()->on_read_byte(this,status,offset,data,length);
Davidroid 33:e6b7e74be1d5 787 } else{
giovannivisentini 29:7a2dfd06cb29 788 /* retrieve the data without SW1 & SW2 as provided as return value of the function */
giovannivisentini 29:7a2dfd06cb29 789 memcpy(mLastCommandData.data, &uM24SRbuffer[1], length);
giovannivisentini 29:7a2dfd06cb29 790 getCallback()->on_read_byte(this,status,offset,data,length);
giovannivisentini 29:7a2dfd06cb29 791 }
Davidroid 33:e6b7e74be1d5 792
giovannivisentini 29:7a2dfd06cb29 793 return status;
giovannivisentini 29:7a2dfd06cb29 794 }
giovannivisentini 29:7a2dfd06cb29 795
giovannivisentini 29:7a2dfd06cb29 796 /**
giovannivisentini 29:7a2dfd06cb29 797 * @brief This function sends a ST read binary command (no error if access is not inside NDEF file)
giovannivisentini 29:7a2dfd06cb29 798 * @param Offset first byte to read
giovannivisentini 29:7a2dfd06cb29 799 * @param NbByteToRead number of bytes to read
giovannivisentini 29:7a2dfd06cb29 800 * @param pBufferRead pointer to the buffer read from the M24SR device
giovannivisentini 29:7a2dfd06cb29 801 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 802 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 803 */
Davidroid 34:b76765d2cc68 804 M24SR::StatusTypeDef M24SR::M24SR_SendSTReadBinary(uint16_t Offset, uint8_t NbByteToRead, uint8_t *pBufferRead) {
giovannivisentini 29:7a2dfd06cb29 805 //clamp the buffer to the max size
Davidroid 33:e6b7e74be1d5 806 if (NbByteToRead>M24SR_MAX_BYTE_OPERATION_LENGHT) {
giovannivisentini 29:7a2dfd06cb29 807 NbByteToRead=M24SR_MAX_BYTE_OPERATION_LENGHT;
Davidroid 33:e6b7e74be1d5 808 }
giovannivisentini 29:7a2dfd06cb29 809
giovannivisentini 29:7a2dfd06cb29 810 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 811 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 812 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 813 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 814
giovannivisentini 29:7a2dfd06cb29 815 /* build the command */
giovannivisentini 29:7a2dfd06cb29 816 command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini 29:7a2dfd06cb29 817 command.Header.INS = C_APDU_READ_BINARY;
giovannivisentini 29:7a2dfd06cb29 818 /* copy the offset */
giovannivisentini 29:7a2dfd06cb29 819 command.Header.P1 = GETMSB(Offset);
giovannivisentini 29:7a2dfd06cb29 820 command.Header.P2 = GETLSB(Offset);
giovannivisentini 29:7a2dfd06cb29 821 /* copy the number of byte to read */
giovannivisentini 29:7a2dfd06cb29 822 command.Body.LE = NbByteToRead;
giovannivisentini 29:7a2dfd06cb29 823
Davidroid 33:e6b7e74be1d5 824 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_READBINARY, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 825
giovannivisentini 29:7a2dfd06cb29 826 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 827 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 828 getCallback()->on_read_byte(this,status,Offset,pBufferRead,NbByteToRead);
giovannivisentini 29:7a2dfd06cb29 829 return status;
giovannivisentini 29:7a2dfd06cb29 830 }
giovannivisentini 29:7a2dfd06cb29 831
giovannivisentini 29:7a2dfd06cb29 832 mLastCommandSend=READ;
giovannivisentini 29:7a2dfd06cb29 833 mLastCommandData.data=pBufferRead;
giovannivisentini 29:7a2dfd06cb29 834 mLastCommandData.length=NbByteToRead;
giovannivisentini 29:7a2dfd06cb29 835
Davidroid 33:e6b7e74be1d5 836 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 837 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 838 if (status==M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 839 return M24SR_ReceiveReadBinary();
Davidroid 33:e6b7e74be1d5 840 } else {
giovannivisentini 29:7a2dfd06cb29 841 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 842 getCallback()->on_read_byte(this,status,Offset,pBufferRead,NbByteToRead);
giovannivisentini 29:7a2dfd06cb29 843 return status;
giovannivisentini 29:7a2dfd06cb29 844 }//if-else
giovannivisentini 29:7a2dfd06cb29 845 }//if
giovannivisentini 29:7a2dfd06cb29 846
giovannivisentini 29:7a2dfd06cb29 847 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 848 }
giovannivisentini 29:7a2dfd06cb29 849
giovannivisentini 29:7a2dfd06cb29 850 /**
giovannivisentini 29:7a2dfd06cb29 851 * @brief This function sends a Update binary command
giovannivisentini 29:7a2dfd06cb29 852 * @param Offset first byte to read
giovannivisentini 29:7a2dfd06cb29 853 * @param NbByteToWrite number of bytes to write
giovannivisentini 29:7a2dfd06cb29 854 * @param pBufferRead pointer to the buffer read from the M24SR device
giovannivisentini 29:7a2dfd06cb29 855 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 856 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 857 */
Davidroid 34:b76765d2cc68 858 M24SR::StatusTypeDef M24SR::M24SR_SendUpdateBinary(uint16_t Offset, uint8_t NbByteToWrite, uint8_t *pDataToWrite) {
giovannivisentini 29:7a2dfd06cb29 859 //clamp the buffer to the max size
Davidroid 33:e6b7e74be1d5 860 if (NbByteToWrite>M24SR_MAX_BYTE_OPERATION_LENGHT) {
giovannivisentini 29:7a2dfd06cb29 861 NbByteToWrite=M24SR_MAX_BYTE_OPERATION_LENGHT;
Davidroid 33:e6b7e74be1d5 862 }
giovannivisentini 29:7a2dfd06cb29 863
giovannivisentini 29:7a2dfd06cb29 864 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 865 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 866 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 867 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 868
giovannivisentini 29:7a2dfd06cb29 869 /* build the command */
giovannivisentini 29:7a2dfd06cb29 870 command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini 29:7a2dfd06cb29 871 command.Header.INS = C_APDU_UPDATE_BINARY;
giovannivisentini 29:7a2dfd06cb29 872 /* copy the offset */
giovannivisentini 29:7a2dfd06cb29 873 command.Header.P1 = GETMSB(Offset);
giovannivisentini 29:7a2dfd06cb29 874 command.Header.P2 = GETLSB(Offset);
giovannivisentini 29:7a2dfd06cb29 875 /* copy the number of byte of the data field */
giovannivisentini 29:7a2dfd06cb29 876 command.Body.LC = NbByteToWrite;
giovannivisentini 29:7a2dfd06cb29 877 command.Body.pData = pDataToWrite;
giovannivisentini 29:7a2dfd06cb29 878 /* copy the File Id */
giovannivisentini 29:7a2dfd06cb29 879 //memcpy(command.Body.pData ,pDataToWrite, NbByteToWrite );
Davidroid 33:e6b7e74be1d5 880 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_UPDATEBINARY, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 881
giovannivisentini 29:7a2dfd06cb29 882 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 883 if (status!=M24SR_SUCCESS){
giovannivisentini 29:7a2dfd06cb29 884 getCallback()->on_updated_binary(this,status,Offset,pDataToWrite,NbByteToWrite);
giovannivisentini 29:7a2dfd06cb29 885 return status;
giovannivisentini 29:7a2dfd06cb29 886 }
giovannivisentini 29:7a2dfd06cb29 887
giovannivisentini 29:7a2dfd06cb29 888 mLastCommandSend=UPDATE;
giovannivisentini 29:7a2dfd06cb29 889 mLastCommandData.data=pDataToWrite;
giovannivisentini 29:7a2dfd06cb29 890 mLastCommandData.length=NbByteToWrite;
giovannivisentini 29:7a2dfd06cb29 891 mLastCommandData.offset=Offset;
giovannivisentini 29:7a2dfd06cb29 892
Davidroid 33:e6b7e74be1d5 893 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 894 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 895 if (status==M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 896 return M24SR_ReceiveUpdateBinary();
Davidroid 33:e6b7e74be1d5 897 } else {
giovannivisentini 29:7a2dfd06cb29 898 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 899 getCallback()->on_updated_binary(this,status,Offset,pDataToWrite,NbByteToWrite);
giovannivisentini 29:7a2dfd06cb29 900 return status;
giovannivisentini 29:7a2dfd06cb29 901 }//if-else
giovannivisentini 29:7a2dfd06cb29 902 }
giovannivisentini 29:7a2dfd06cb29 903
giovannivisentini 29:7a2dfd06cb29 904 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 905 }
giovannivisentini 29:7a2dfd06cb29 906
Davidroid 34:b76765d2cc68 907 M24SR::StatusTypeDef M24SR::M24SR_ReceiveUpdateBinary() {
giovannivisentini 29:7a2dfd06cb29 908 uint8_t respBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 909 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 910 const uint16_t length = mLastCommandData.length;
giovannivisentini 29:7a2dfd06cb29 911 uint8_t *data = mLastCommandData.data;
giovannivisentini 29:7a2dfd06cb29 912 const uint16_t offset = mLastCommandData.offset;
giovannivisentini 29:7a2dfd06cb29 913
giovannivisentini 29:7a2dfd06cb29 914 mLastCommandSend=NONE;
giovannivisentini 29:7a2dfd06cb29 915
giovannivisentini 29:7a2dfd06cb29 916 status= M24SR_IO_ReceiveI2Cresponse (sizeof(respBuffer) , respBuffer);
giovannivisentini 29:7a2dfd06cb29 917 if(status != M24SR_SUCCESS){
giovannivisentini 29:7a2dfd06cb29 918 getCallback()->on_updated_binary(this,status,offset,data,length);
giovannivisentini 29:7a2dfd06cb29 919 return status;
giovannivisentini 29:7a2dfd06cb29 920 }
giovannivisentini 29:7a2dfd06cb29 921
giovannivisentini 29:7a2dfd06cb29 922 if (IsSBlock(respBuffer) == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 923 /*check the CRC */
Davidroid 33:e6b7e74be1d5 924 status = M24SR_IsCorrectCRC16Residue(respBuffer, M24SR_WATINGTIMEEXTRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 925 // TODO: why if we check ==NFC_Commandsuccess it fail?
giovannivisentini 29:7a2dfd06cb29 926 if (status != M24SR_IO_ERROR_CRC) {
giovannivisentini 29:7a2dfd06cb29 927 /* send the FrameExension response*/
giovannivisentini 29:7a2dfd06cb29 928 status = M24SR_SendFWTExtension(respBuffer[M24SR_OFFSET_PCB + 1]);
giovannivisentini 29:7a2dfd06cb29 929 if(status!=M24SR_SUCCESS){ //something get wrong -> abort the update
giovannivisentini 29:7a2dfd06cb29 930 getCallback()->on_updated_binary(this,status,offset,data,length);
giovannivisentini 29:7a2dfd06cb29 931 }//status
giovannivisentini 29:7a2dfd06cb29 932 }//if
giovannivisentini 29:7a2dfd06cb29 933 } else { //isSBlock
Davidroid 33:e6b7e74be1d5 934 status = M24SR_IsCorrectCRC16Residue(respBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 935 getCallback()->on_updated_binary(this,status,offset,data,length);
giovannivisentini 29:7a2dfd06cb29 936 }//if else
Davidroid 33:e6b7e74be1d5 937
giovannivisentini 29:7a2dfd06cb29 938 return status;
giovannivisentini 29:7a2dfd06cb29 939 }//M24SR_ReceiveUpdateBinary
giovannivisentini 29:7a2dfd06cb29 940
giovannivisentini 29:7a2dfd06cb29 941 /**
giovannivisentini 29:7a2dfd06cb29 942 * @brief This function sends the Verify command
giovannivisentini 29:7a2dfd06cb29 943 * @param uPwdId PasswordId ( 0x0001 : Read NDEF pwd or 0x0002 : Write NDEF pwd or 0x0003 : I2C pwd)
giovannivisentini 29:7a2dfd06cb29 944 * @param NbPwdByte Number of bytes ( 0x00 or 0x10)
giovannivisentini 29:7a2dfd06cb29 945 * @param pPwd pointer to the password
giovannivisentini 29:7a2dfd06cb29 946 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 947 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 948 */
Davidroid 34:b76765d2cc68 949 M24SR::StatusTypeDef M24SR::M24SR_SendVerify(uint16_t uPwdId, uint8_t NbPwdByte, const uint8_t *pPwd) {
giovannivisentini 29:7a2dfd06cb29 950 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 951 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 952 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 953 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 954
giovannivisentini 29:7a2dfd06cb29 955 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 956 if ((uPwdId > 0x0003)|| ((NbPwdByte != 0x00) && (NbPwdByte != 0x10))) {
giovannivisentini 29:7a2dfd06cb29 957 getCallback()->on_verified(this,M24SR_IO_ERROR_PARAMETER,constToPasswordType(uPwdId),pPwd);
giovannivisentini 29:7a2dfd06cb29 958 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 959 }
giovannivisentini 29:7a2dfd06cb29 960
giovannivisentini 29:7a2dfd06cb29 961 /* build the command */
giovannivisentini 29:7a2dfd06cb29 962 command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini 29:7a2dfd06cb29 963 command.Header.INS = C_APDU_VERIFY;
giovannivisentini 29:7a2dfd06cb29 964 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 965 command.Header.P1 = GETMSB(uPwdId);
giovannivisentini 29:7a2dfd06cb29 966 command.Header.P2 = GETLSB(uPwdId);
giovannivisentini 29:7a2dfd06cb29 967 /* copy the number of bytes of the data field */
giovannivisentini 29:7a2dfd06cb29 968 command.Body.LC = NbPwdByte;
giovannivisentini 29:7a2dfd06cb29 969
giovannivisentini 29:7a2dfd06cb29 970 if (NbPwdByte == 0x10) {
giovannivisentini 29:7a2dfd06cb29 971 /* copy the password */
giovannivisentini 29:7a2dfd06cb29 972 command.Body.pData = pPwd;
giovannivisentini 29:7a2dfd06cb29 973 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 974 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_VERIFYBINARYWITHPWD, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 975 } else {
giovannivisentini 29:7a2dfd06cb29 976 command.Body.pData = NULL;
giovannivisentini 29:7a2dfd06cb29 977 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 978 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_VERIFYBINARYWOPWD, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 979 }
giovannivisentini 29:7a2dfd06cb29 980
giovannivisentini 29:7a2dfd06cb29 981 /* send the request */
giovannivisentini 29:7a2dfd06cb29 982 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 983 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 984 getCallback()->on_verified(this,status,constToPasswordType(uPwdId),pPwd);
giovannivisentini 29:7a2dfd06cb29 985 return status;
giovannivisentini 29:7a2dfd06cb29 986 }
giovannivisentini 29:7a2dfd06cb29 987 mLastCommandSend=VERIFY;
giovannivisentini 29:7a2dfd06cb29 988 mLastCommandData.data=(uint8_t*)pPwd;
giovannivisentini 29:7a2dfd06cb29 989 mLastCommandData.offset=uPwdId;
giovannivisentini 29:7a2dfd06cb29 990
Davidroid 33:e6b7e74be1d5 991 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 992 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 993 if(status == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 994 return M24SR_ReceiveVerify();
Davidroid 33:e6b7e74be1d5 995 } else {
giovannivisentini 29:7a2dfd06cb29 996 mLastCommandSend = NONE;
giovannivisentini 29:7a2dfd06cb29 997 getCallback()->on_verified(this,status,constToPasswordType(uPwdId),pPwd);
giovannivisentini 29:7a2dfd06cb29 998 return status;
giovannivisentini 29:7a2dfd06cb29 999 }
giovannivisentini 29:7a2dfd06cb29 1000 }
giovannivisentini 29:7a2dfd06cb29 1001
giovannivisentini 29:7a2dfd06cb29 1002 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1003 }
giovannivisentini 29:7a2dfd06cb29 1004
Davidroid 34:b76765d2cc68 1005 M24SR::StatusTypeDef M24SR::M24SR_ReceiveVerify() {
giovannivisentini 29:7a2dfd06cb29 1006 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1007 uint8_t respBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 1008 mLastCommandSend=NONE;
giovannivisentini 29:7a2dfd06cb29 1009
giovannivisentini 29:7a2dfd06cb29 1010 const uint8_t *data = mLastCommandData.data;
giovannivisentini 29:7a2dfd06cb29 1011 const PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini 29:7a2dfd06cb29 1012
giovannivisentini 29:7a2dfd06cb29 1013 status=M24SR_IO_ReceiveI2Cresponse (sizeof(respBuffer),respBuffer);
giovannivisentini 29:7a2dfd06cb29 1014
Davidroid 33:e6b7e74be1d5 1015 if (status !=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1016 getCallback()->on_verified(this,status,type,data);
giovannivisentini 29:7a2dfd06cb29 1017 return status;
giovannivisentini 29:7a2dfd06cb29 1018 }
giovannivisentini 29:7a2dfd06cb29 1019
giovannivisentini 29:7a2dfd06cb29 1020 status = M24SR_IsCorrectCRC16Residue(respBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1021 getCallback()->on_verified(this,status,type,data);
giovannivisentini 29:7a2dfd06cb29 1022 return status;
giovannivisentini 29:7a2dfd06cb29 1023 }
giovannivisentini 29:7a2dfd06cb29 1024
giovannivisentini 29:7a2dfd06cb29 1025 /**
giovannivisentini 29:7a2dfd06cb29 1026 * @brief This function sends the ChangeReferenceData command
giovannivisentini 29:7a2dfd06cb29 1027 * @param uPwdId PasswordId ( 0x0001 : Read NDEF pwd or 0x0002 : Write NDEF pwd or 0x0003 : I2C pwd)
giovannivisentini 29:7a2dfd06cb29 1028 * @param pPwd pointer to the passwaord
giovannivisentini 29:7a2dfd06cb29 1029 * @retval Status (SW1&SW2) Satus of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1030 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1031 */
Davidroid 34:b76765d2cc68 1032 M24SR::StatusTypeDef M24SR::M24SR_SendChangeReferenceData(uint16_t uPwdId, uint8_t *pPwd) {
giovannivisentini 29:7a2dfd06cb29 1033 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1034 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1035 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1036 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1037
giovannivisentini 29:7a2dfd06cb29 1038 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 1039 if (uPwdId > 0x0003) {
Davidroid 33:e6b7e74be1d5 1040 getCallback()->on_change_reference_data(this,M24SR_IO_ERROR_PARAMETER, constToPasswordType(uPwdId), pPwd);
giovannivisentini 29:7a2dfd06cb29 1041 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1042 }
giovannivisentini 29:7a2dfd06cb29 1043
giovannivisentini 29:7a2dfd06cb29 1044 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1045 command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini 29:7a2dfd06cb29 1046 command.Header.INS = C_APDU_CHANGE;
giovannivisentini 29:7a2dfd06cb29 1047 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1048 command.Header.P1 = GETMSB(uPwdId);
giovannivisentini 29:7a2dfd06cb29 1049 command.Header.P2 = GETLSB(uPwdId);
giovannivisentini 29:7a2dfd06cb29 1050 /* copy the number of byte of the data field */
giovannivisentini 29:7a2dfd06cb29 1051 command.Body.LC = M24SR_PASSWORD_NBBYTE;
giovannivisentini 29:7a2dfd06cb29 1052 /* copy the password */
giovannivisentini 29:7a2dfd06cb29 1053 command.Body.pData = pPwd;
giovannivisentini 29:7a2dfd06cb29 1054 /* build the I²C command */
Davidroid 33:e6b7e74be1d5 1055 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_CHANGEREFDATA, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1056
giovannivisentini 29:7a2dfd06cb29 1057 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1058 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 1059 if (status != M24SR_SUCCESS) {
Davidroid 33:e6b7e74be1d5 1060 getCallback()->on_change_reference_data(this,status, constToPasswordType(uPwdId), pPwd);
giovannivisentini 29:7a2dfd06cb29 1061 return status;
giovannivisentini 29:7a2dfd06cb29 1062 }
giovannivisentini 29:7a2dfd06cb29 1063
giovannivisentini 29:7a2dfd06cb29 1064 mLastCommandSend = CHANGE_REFERENCE_DATA;
giovannivisentini 29:7a2dfd06cb29 1065 mLastCommandData.data = pPwd;
giovannivisentini 29:7a2dfd06cb29 1066 //use the offset filed for store the pwd id;
giovannivisentini 29:7a2dfd06cb29 1067 mLastCommandData.offset = (uint8_t)uPwdId;
giovannivisentini 29:7a2dfd06cb29 1068
Davidroid 33:e6b7e74be1d5 1069 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 1070 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 1071 if (status == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1072 return M24SR_ReceiveChangeReferenceData();
Davidroid 33:e6b7e74be1d5 1073 } else {
giovannivisentini 29:7a2dfd06cb29 1074 mLastCommandSend = NONE;
Davidroid 33:e6b7e74be1d5 1075 getCallback()->on_change_reference_data(this, status, constToPasswordType(uPwdId), pPwd);
giovannivisentini 29:7a2dfd06cb29 1076 return status;
giovannivisentini 29:7a2dfd06cb29 1077 }//if-else
giovannivisentini 29:7a2dfd06cb29 1078 }//if
giovannivisentini 29:7a2dfd06cb29 1079
giovannivisentini 29:7a2dfd06cb29 1080 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1081 }
giovannivisentini 29:7a2dfd06cb29 1082
Davidroid 34:b76765d2cc68 1083 M24SR::StatusTypeDef M24SR::M24SR_ReceiveChangeReferenceData(){
giovannivisentini 29:7a2dfd06cb29 1084 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1085 //TODO the size is 3?
giovannivisentini 29:7a2dfd06cb29 1086 uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 1087
giovannivisentini 29:7a2dfd06cb29 1088 PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini 29:7a2dfd06cb29 1089 uint8_t *data = mLastCommandData.data;
giovannivisentini 29:7a2dfd06cb29 1090
Davidroid 33:e6b7e74be1d5 1091 status = M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
Davidroid 33:e6b7e74be1d5 1092 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1093 getCallback()->on_change_reference_data(this,status,type,data);
giovannivisentini 29:7a2dfd06cb29 1094 return status;
giovannivisentini 29:7a2dfd06cb29 1095 }//else
giovannivisentini 29:7a2dfd06cb29 1096
giovannivisentini 29:7a2dfd06cb29 1097 status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1098 getCallback()->on_change_reference_data(this,status,type,data);
giovannivisentini 29:7a2dfd06cb29 1099 return status;
giovannivisentini 29:7a2dfd06cb29 1100 }
giovannivisentini 29:7a2dfd06cb29 1101
giovannivisentini 29:7a2dfd06cb29 1102 /**
giovannivisentini 29:7a2dfd06cb29 1103 * @brief This function sends the EnableVerificationRequirement command
giovannivisentini 29:7a2dfd06cb29 1104 * @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini 29:7a2dfd06cb29 1105 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1106 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1107 */
Davidroid 34:b76765d2cc68 1108 M24SR::StatusTypeDef M24SR::M24SR_SendEnableVerificationRequirement(uint16_t uReadOrWrite) {
giovannivisentini 29:7a2dfd06cb29 1109 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1110 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1111 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1112 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1113
giovannivisentini 29:7a2dfd06cb29 1114 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 1115 if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
Davidroid 33:e6b7e74be1d5 1116 getCallback()->on_enable_verification_requirement(this,M24SR_IO_ERROR_PARAMETER, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1117 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1118 }
giovannivisentini 29:7a2dfd06cb29 1119
giovannivisentini 29:7a2dfd06cb29 1120 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1121 command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini 29:7a2dfd06cb29 1122 command.Header.INS = C_APDU_ENABLE;
giovannivisentini 29:7a2dfd06cb29 1123 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1124 command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1125 command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1126 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 1127 M24SR_BuildIBlockCommand( M24SR_CMDSTRUCT_ENABLEVERIFREQ, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1128
giovannivisentini 29:7a2dfd06cb29 1129 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1130 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 1131 if (status != M24SR_SUCCESS) {
Davidroid 33:e6b7e74be1d5 1132 getCallback()->on_enable_verification_requirement(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1133 return status;
giovannivisentini 29:7a2dfd06cb29 1134 }//if
giovannivisentini 29:7a2dfd06cb29 1135
giovannivisentini 29:7a2dfd06cb29 1136 mLastCommandSend = ENABLE_VERIFICATION_REQUIREMENT;
giovannivisentini 29:7a2dfd06cb29 1137 //use the offset filed for store the pwd id;
giovannivisentini 29:7a2dfd06cb29 1138 mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini 29:7a2dfd06cb29 1139
Davidroid 33:e6b7e74be1d5 1140 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 1141 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 1142 if (status == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1143 return M24SR_ReceiveEnableVerificationRequirement();
Davidroid 33:e6b7e74be1d5 1144 } else {
giovannivisentini 29:7a2dfd06cb29 1145 mLastCommandSend = NONE;
Davidroid 33:e6b7e74be1d5 1146 getCallback()->on_enable_verification_requirement(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1147 return status;
giovannivisentini 29:7a2dfd06cb29 1148 }//if-else
giovannivisentini 29:7a2dfd06cb29 1149 }//if
giovannivisentini 29:7a2dfd06cb29 1150
giovannivisentini 29:7a2dfd06cb29 1151 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1152 }
giovannivisentini 29:7a2dfd06cb29 1153
Davidroid 34:b76765d2cc68 1154 M24SR::StatusTypeDef M24SR::M24SR_ReceiveEnableVerificationRequirement(){
giovannivisentini 29:7a2dfd06cb29 1155 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1156 //TODO the size is 3?
giovannivisentini 29:7a2dfd06cb29 1157 uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 1158
giovannivisentini 29:7a2dfd06cb29 1159 const PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini 29:7a2dfd06cb29 1160
Davidroid 33:e6b7e74be1d5 1161 status = M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
Davidroid 33:e6b7e74be1d5 1162 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1163 getCallback()->on_enable_verification_requirement(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1164 return status;
giovannivisentini 29:7a2dfd06cb29 1165 }//else
giovannivisentini 29:7a2dfd06cb29 1166
giovannivisentini 29:7a2dfd06cb29 1167 status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1168 getCallback()->on_enable_verification_requirement(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1169 return status;
giovannivisentini 29:7a2dfd06cb29 1170 }
giovannivisentini 29:7a2dfd06cb29 1171
giovannivisentini 29:7a2dfd06cb29 1172 /**
giovannivisentini 29:7a2dfd06cb29 1173 * @brief This function sends the DisableVerificationRequirement command
giovannivisentini 29:7a2dfd06cb29 1174 * @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini 29:7a2dfd06cb29 1175 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1176 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1177 */
Davidroid 34:b76765d2cc68 1178 M24SR::StatusTypeDef M24SR::M24SR_SendDisableVerificationRequirement(uint16_t uReadOrWrite) {
giovannivisentini 29:7a2dfd06cb29 1179 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1180 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1181 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1182 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1183
giovannivisentini 29:7a2dfd06cb29 1184 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 1185 if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
Davidroid 33:e6b7e74be1d5 1186 getCallback()->on_disable_verification_requirement(this,M24SR_IO_ERROR_PARAMETER, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1187 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1188 }
giovannivisentini 29:7a2dfd06cb29 1189
giovannivisentini 29:7a2dfd06cb29 1190 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1191 command.Header.CLA = C_APDU_CLA_DEFAULT;
giovannivisentini 29:7a2dfd06cb29 1192 command.Header.INS = C_APDU_DISABLE;
giovannivisentini 29:7a2dfd06cb29 1193 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1194 command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1195 command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1196 /* build the I²C command */
Davidroid 33:e6b7e74be1d5 1197 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_DISABLEVERIFREQ, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1198
giovannivisentini 29:7a2dfd06cb29 1199 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1200 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 1201 if (status != M24SR_SUCCESS) {
Davidroid 33:e6b7e74be1d5 1202 getCallback()->on_disable_verification_requirement(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1203 return status;
giovannivisentini 29:7a2dfd06cb29 1204 }
giovannivisentini 29:7a2dfd06cb29 1205
giovannivisentini 29:7a2dfd06cb29 1206 mLastCommandSend = DISABLE_VERIFICATION_REQUIREMENT;
giovannivisentini 29:7a2dfd06cb29 1207 //use the offset filed for store the pwd id;
giovannivisentini 29:7a2dfd06cb29 1208 mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini 29:7a2dfd06cb29 1209
Davidroid 33:e6b7e74be1d5 1210 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 1211 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 1212 if (status==M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1213 return M24SR_ReceiveDisableVerificationRequirement();
Davidroid 33:e6b7e74be1d5 1214 } else {
giovannivisentini 29:7a2dfd06cb29 1215 mLastCommandSend = NONE;
Davidroid 33:e6b7e74be1d5 1216 getCallback()->on_disable_verification_requirement(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1217 return status;
giovannivisentini 29:7a2dfd06cb29 1218 }//if-else
giovannivisentini 29:7a2dfd06cb29 1219 }
giovannivisentini 29:7a2dfd06cb29 1220
giovannivisentini 29:7a2dfd06cb29 1221 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1222 }
giovannivisentini 29:7a2dfd06cb29 1223
Davidroid 34:b76765d2cc68 1224 M24SR::StatusTypeDef M24SR::M24SR_ReceiveDisableVerificationRequirement() {
giovannivisentini 29:7a2dfd06cb29 1225 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1226 //TODO the size is 3?
giovannivisentini 29:7a2dfd06cb29 1227 uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 1228
giovannivisentini 29:7a2dfd06cb29 1229 PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini 29:7a2dfd06cb29 1230
Davidroid 33:e6b7e74be1d5 1231 status = M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
Davidroid 33:e6b7e74be1d5 1232 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1233 getCallback()->on_disable_verification_requirement(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1234 return status;
giovannivisentini 29:7a2dfd06cb29 1235 }//else
giovannivisentini 29:7a2dfd06cb29 1236
giovannivisentini 29:7a2dfd06cb29 1237 status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1238 getCallback()->on_disable_verification_requirement(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1239 return status;
giovannivisentini 29:7a2dfd06cb29 1240 }
giovannivisentini 29:7a2dfd06cb29 1241
giovannivisentini 29:7a2dfd06cb29 1242 /**
giovannivisentini 29:7a2dfd06cb29 1243 * @brief This function sends the EnablePermananentState command
giovannivisentini 29:7a2dfd06cb29 1244 * @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini 29:7a2dfd06cb29 1245 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1246 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1247 */
Davidroid 34:b76765d2cc68 1248 M24SR::StatusTypeDef M24SR::M24SR_SendEnablePermanentState(uint16_t uReadOrWrite) {
giovannivisentini 29:7a2dfd06cb29 1249 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1250 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1251
giovannivisentini 29:7a2dfd06cb29 1252 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1253 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1254
giovannivisentini 29:7a2dfd06cb29 1255 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 1256 if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
Davidroid 33:e6b7e74be1d5 1257 getCallback()->on_enable_permanent_state(this, M24SR_IO_ERROR_PARAMETER, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1258 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1259 }
giovannivisentini 29:7a2dfd06cb29 1260
giovannivisentini 29:7a2dfd06cb29 1261 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1262 command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini 29:7a2dfd06cb29 1263 command.Header.INS = C_APDU_ENABLE;
giovannivisentini 29:7a2dfd06cb29 1264 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1265 command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1266 command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1267 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 1268 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_ENABLEVERIFREQ, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1269
giovannivisentini 29:7a2dfd06cb29 1270 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1271 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 1272 if (status != M24SR_SUCCESS) {
Davidroid 33:e6b7e74be1d5 1273 getCallback()->on_enable_permanent_state(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1274 return status;
giovannivisentini 29:7a2dfd06cb29 1275 }
giovannivisentini 29:7a2dfd06cb29 1276
giovannivisentini 29:7a2dfd06cb29 1277 mLastCommandSend = ENABLE_PERMANET_STATE;
giovannivisentini 29:7a2dfd06cb29 1278 //use the offset filed for store the pwd id;
giovannivisentini 29:7a2dfd06cb29 1279 mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini 29:7a2dfd06cb29 1280
Davidroid 33:e6b7e74be1d5 1281 if (mCommunicationType==M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 1282 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 1283 if (status == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1284 return M24SR_ReceiveEnablePermanentState();
Davidroid 33:e6b7e74be1d5 1285 } else {
giovannivisentini 29:7a2dfd06cb29 1286 mLastCommandSend = NONE;
Davidroid 33:e6b7e74be1d5 1287 getCallback()->on_enable_permanent_state(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1288 return status;
giovannivisentini 29:7a2dfd06cb29 1289 }//if-else
giovannivisentini 29:7a2dfd06cb29 1290 }
giovannivisentini 29:7a2dfd06cb29 1291
giovannivisentini 29:7a2dfd06cb29 1292 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1293 }
giovannivisentini 29:7a2dfd06cb29 1294
Davidroid 34:b76765d2cc68 1295 M24SR::StatusTypeDef M24SR::M24SR_ReceiveEnablePermanentState() {
giovannivisentini 29:7a2dfd06cb29 1296 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1297 //TODO the size is 3?
giovannivisentini 29:7a2dfd06cb29 1298 uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 1299
giovannivisentini 29:7a2dfd06cb29 1300 PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini 29:7a2dfd06cb29 1301
Davidroid 33:e6b7e74be1d5 1302 status = M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
Davidroid 33:e6b7e74be1d5 1303 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1304 getCallback()->on_enable_permanent_state(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1305 return status;
giovannivisentini 29:7a2dfd06cb29 1306 }//else
giovannivisentini 29:7a2dfd06cb29 1307
giovannivisentini 29:7a2dfd06cb29 1308 status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1309 getCallback()->on_enable_permanent_state(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1310 return status;
giovannivisentini 29:7a2dfd06cb29 1311 }
giovannivisentini 29:7a2dfd06cb29 1312
giovannivisentini 29:7a2dfd06cb29 1313 /**
giovannivisentini 29:7a2dfd06cb29 1314 * @brief This function sends the DisablePermanentState command
giovannivisentini 29:7a2dfd06cb29 1315 * @param uReadOrWrite enable the read or write protection ( 0x0001 : Read or 0x0002 : Write )
giovannivisentini 29:7a2dfd06cb29 1316 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1317 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1318 */
Davidroid 34:b76765d2cc68 1319 M24SR::StatusTypeDef M24SR::M24SR_SendDisablePermanentState(uint16_t uReadOrWrite) {
giovannivisentini 29:7a2dfd06cb29 1320 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1321 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1322 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1323 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1324
giovannivisentini 29:7a2dfd06cb29 1325 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 1326 if ((uReadOrWrite != 0x0001) && (uReadOrWrite != 0x0002)) {
Davidroid 33:e6b7e74be1d5 1327 getCallback()->on_disable_permanent_state(this, M24SR_IO_ERROR_PARAMETER, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1328 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1329 }
giovannivisentini 29:7a2dfd06cb29 1330
giovannivisentini 29:7a2dfd06cb29 1331 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1332 command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini 29:7a2dfd06cb29 1333 command.Header.INS = C_APDU_DISABLE;
giovannivisentini 29:7a2dfd06cb29 1334 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1335 command.Header.P1 = GETMSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1336 command.Header.P2 = GETLSB(uReadOrWrite);
giovannivisentini 29:7a2dfd06cb29 1337 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 1338 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_DISABLEVERIFREQ, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1339
giovannivisentini 29:7a2dfd06cb29 1340 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1341 status = M24SR_IO_SendI2Ccommand(NbByte, pBuffer);
Davidroid 33:e6b7e74be1d5 1342 if (status != M24SR_SUCCESS) {
Davidroid 33:e6b7e74be1d5 1343 getCallback()->on_enable_permanent_state(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1344 return status;
giovannivisentini 29:7a2dfd06cb29 1345 }
giovannivisentini 29:7a2dfd06cb29 1346
giovannivisentini 29:7a2dfd06cb29 1347 mLastCommandSend = DISABLE_PERMANET_STATE;
giovannivisentini 29:7a2dfd06cb29 1348 //use the offset filed for store the pwd id;
giovannivisentini 29:7a2dfd06cb29 1349 mLastCommandData.offset = (uint8_t)uReadOrWrite;
giovannivisentini 29:7a2dfd06cb29 1350
Davidroid 33:e6b7e74be1d5 1351 if (mCommunicationType == M24SR::SYNC) {
giovannivisentini 29:7a2dfd06cb29 1352 status = M24SR_IO_PollI2C();
Davidroid 33:e6b7e74be1d5 1353 if (status == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1354 return M24SR_ReceiveDisablePermanentState();
Davidroid 33:e6b7e74be1d5 1355 } else {
giovannivisentini 29:7a2dfd06cb29 1356 mLastCommandSend = NONE;
Davidroid 33:e6b7e74be1d5 1357 getCallback()->on_disable_permanent_state(this, status, constToPasswordType(uReadOrWrite));
giovannivisentini 29:7a2dfd06cb29 1358 return status;
giovannivisentini 29:7a2dfd06cb29 1359 }//if-else
giovannivisentini 29:7a2dfd06cb29 1360 }
giovannivisentini 29:7a2dfd06cb29 1361
giovannivisentini 29:7a2dfd06cb29 1362 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1363 }
giovannivisentini 29:7a2dfd06cb29 1364
Davidroid 34:b76765d2cc68 1365 M24SR::StatusTypeDef M24SR::M24SR_ReceiveDisablePermanentState() {
giovannivisentini 29:7a2dfd06cb29 1366 M24SR::StatusTypeDef status;
giovannivisentini 29:7a2dfd06cb29 1367 //TODO the size is 3?
giovannivisentini 29:7a2dfd06cb29 1368 uint8_t rensponseBuffer[M24SR_STATUSRESPONSE_NBBYTE];
giovannivisentini 29:7a2dfd06cb29 1369
giovannivisentini 29:7a2dfd06cb29 1370 PasswordType_t type = constToPasswordType(mLastCommandData.offset);
giovannivisentini 29:7a2dfd06cb29 1371
Davidroid 33:e6b7e74be1d5 1372 status = M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , rensponseBuffer );
Davidroid 33:e6b7e74be1d5 1373 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1374 getCallback()->on_disable_permanent_state(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1375 return status;
giovannivisentini 29:7a2dfd06cb29 1376 }//else
giovannivisentini 29:7a2dfd06cb29 1377
giovannivisentini 29:7a2dfd06cb29 1378 status = M24SR_IsCorrectCRC16Residue(rensponseBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1379 getCallback()->on_disable_permanent_state(this,status,type);
giovannivisentini 29:7a2dfd06cb29 1380 return status;
giovannivisentini 29:7a2dfd06cb29 1381 }
giovannivisentini 29:7a2dfd06cb29 1382
giovannivisentini 29:7a2dfd06cb29 1383 /**
giovannivisentini 29:7a2dfd06cb29 1384 * @brief This function generates an interrupt on GPO pin
giovannivisentini 29:7a2dfd06cb29 1385 * @param None
giovannivisentini 29:7a2dfd06cb29 1386 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1387 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1388 */
Davidroid 34:b76765d2cc68 1389 M24SR::StatusTypeDef M24SR::M24SR_SendInterrupt(void) {
giovannivisentini 29:7a2dfd06cb29 1390 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1391
giovannivisentini 29:7a2dfd06cb29 1392 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1393 uint16_t uP1P2 = 0x001E;
giovannivisentini 29:7a2dfd06cb29 1394 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1395
giovannivisentini 29:7a2dfd06cb29 1396
giovannivisentini 29:7a2dfd06cb29 1397 StatusTypeDef status = M24SR_ManageI2CGPO(INTERRUPT);
Davidroid 33:e6b7e74be1d5 1398 if (status!=M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1399 return status;
Davidroid 33:e6b7e74be1d5 1400 }
giovannivisentini 29:7a2dfd06cb29 1401
giovannivisentini 29:7a2dfd06cb29 1402 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1403 command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini 29:7a2dfd06cb29 1404 command.Header.INS = C_APDU_INTERRUPT;
giovannivisentini 29:7a2dfd06cb29 1405 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1406 command.Header.P1 = GETMSB(uP1P2);
giovannivisentini 29:7a2dfd06cb29 1407 command.Header.P2 = GETLSB(uP1P2);
giovannivisentini 29:7a2dfd06cb29 1408 command.Body.LC = 0x00;
giovannivisentini 29:7a2dfd06cb29 1409 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 1410 M24SR_BuildIBlockCommand(M24SR_CMDSTRUCT_SENDINTERRUPT, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1411
giovannivisentini 29:7a2dfd06cb29 1412 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1413 errchk(M24SR_IO_SendI2Ccommand(NbByte, pBuffer));
giovannivisentini 29:7a2dfd06cb29 1414 errchk(M24SR_IO_PollI2C());
giovannivisentini 29:7a2dfd06cb29 1415 /* read the response */
Davidroid 33:e6b7e74be1d5 1416 errchk(M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , pBuffer ));
giovannivisentini 29:7a2dfd06cb29 1417
giovannivisentini 29:7a2dfd06cb29 1418 return M24SR_IsCorrectCRC16Residue(pBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1419
giovannivisentini 29:7a2dfd06cb29 1420 }
giovannivisentini 29:7a2dfd06cb29 1421
giovannivisentini 29:7a2dfd06cb29 1422 /**
giovannivisentini 29:7a2dfd06cb29 1423 * @brief This function forces GPO pin to low state or high Z
giovannivisentini 29:7a2dfd06cb29 1424 * @param uSetOrReset select if GPO must be low (reset) or HiZ
giovannivisentini 29:7a2dfd06cb29 1425 * @retval Status (SW1&SW2) Status of the operation to complete.
giovannivisentini 29:7a2dfd06cb29 1426 * @retval M24SR_ERROR_I2CTIMEOUT I2C timeout occurred.
giovannivisentini 29:7a2dfd06cb29 1427 */
Davidroid 34:b76765d2cc68 1428 M24SR::StatusTypeDef M24SR::M24SR_StateControl(uint8_t uSetOrReset) {
giovannivisentini 29:7a2dfd06cb29 1429 C_APDU command;
giovannivisentini 29:7a2dfd06cb29 1430 uint8_t *pBuffer = uM24SRbuffer;
giovannivisentini 29:7a2dfd06cb29 1431 uint16_t uP1P2 = 0x001F;
giovannivisentini 29:7a2dfd06cb29 1432 uint16_t NbByte;
giovannivisentini 29:7a2dfd06cb29 1433
giovannivisentini 29:7a2dfd06cb29 1434 /*check the parameters */
giovannivisentini 29:7a2dfd06cb29 1435 if ((uSetOrReset != 0x01) && (uSetOrReset != 0x00)) {
giovannivisentini 29:7a2dfd06cb29 1436 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1437 }
giovannivisentini 29:7a2dfd06cb29 1438
giovannivisentini 29:7a2dfd06cb29 1439
giovannivisentini 29:7a2dfd06cb29 1440 StatusTypeDef status = M24SR_ManageI2CGPO(STATE_CONTROL);
Davidroid 33:e6b7e74be1d5 1441 if (status == M24SR_SUCCESS) {
giovannivisentini 29:7a2dfd06cb29 1442 return status;
Davidroid 33:e6b7e74be1d5 1443 }
giovannivisentini 29:7a2dfd06cb29 1444
giovannivisentini 29:7a2dfd06cb29 1445 /* build the command */
giovannivisentini 29:7a2dfd06cb29 1446 command.Header.CLA = C_APDU_CLA_ST;
giovannivisentini 29:7a2dfd06cb29 1447 command.Header.INS = C_APDU_INTERRUPT;
giovannivisentini 29:7a2dfd06cb29 1448 /* copy the Password Id */
giovannivisentini 29:7a2dfd06cb29 1449 command.Header.P1 = GETMSB(uP1P2);
giovannivisentini 29:7a2dfd06cb29 1450 command.Header.P2 = GETLSB(uP1P2);
giovannivisentini 29:7a2dfd06cb29 1451 command.Body.LC = 0x01;
giovannivisentini 29:7a2dfd06cb29 1452 command.Body.pData = &uSetOrReset;
giovannivisentini 29:7a2dfd06cb29 1453 /* copy the data */
giovannivisentini 29:7a2dfd06cb29 1454 //memcpy(command.Body.pData , &uSetOrReset, 0x01 );
giovannivisentini 29:7a2dfd06cb29 1455 //command.Body.LE = 0x00 ;
giovannivisentini 29:7a2dfd06cb29 1456 /* build the I2C command */
Davidroid 33:e6b7e74be1d5 1457 M24SR_BuildIBlockCommand( M24SR_CMDSTRUCT_GPOSTATE, &command, uDIDbyte, &NbByte, pBuffer);
giovannivisentini 29:7a2dfd06cb29 1458
giovannivisentini 29:7a2dfd06cb29 1459 /* send the request */
giovannivisentini 29:7a2dfd06cb29 1460 errchk(M24SR_IO_SendI2Ccommand(NbByte, pBuffer));
giovannivisentini 29:7a2dfd06cb29 1461 errchk(M24SR_IO_PollI2C());
giovannivisentini 29:7a2dfd06cb29 1462 /* read the response */
Davidroid 33:e6b7e74be1d5 1463 errchk(M24SR_IO_ReceiveI2Cresponse (M24SR_STATUSRESPONSE_NBBYTE , pBuffer ));
giovannivisentini 29:7a2dfd06cb29 1464
giovannivisentini 29:7a2dfd06cb29 1465 return M24SR_IsCorrectCRC16Residue(pBuffer, M24SR_STATUSRESPONSE_NBBYTE);
giovannivisentini 29:7a2dfd06cb29 1466 }
giovannivisentini 29:7a2dfd06cb29 1467
Davidroid 34:b76765d2cc68 1468 M24SR::StatusTypeDef M24SR::M24SR_ManageI2CGPO(NFC_GPO_MGMT GPO_I2Cconfig) {
giovannivisentini 29:7a2dfd06cb29 1469
Davidroid 33:e6b7e74be1d5 1470 if (GPOPin.is_connected() == 0) {
giovannivisentini 29:7a2dfd06cb29 1471 return M24SR_IO_PIN_NOT_CONNECTED;
giovannivisentini 29:7a2dfd06cb29 1472 }
giovannivisentini 29:7a2dfd06cb29 1473 if (GPO_I2Cconfig > STATE_CONTROL) {
giovannivisentini 29:7a2dfd06cb29 1474 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1475 }
giovannivisentini 29:7a2dfd06cb29 1476
giovannivisentini 29:7a2dfd06cb29 1477 //enable the callback for change the gpo
giovannivisentini 29:7a2dfd06cb29 1478 mComponentCallback = &mManageGPOCallback;
giovannivisentini 29:7a2dfd06cb29 1479 mManageGPOCallback.set_new_GPO_config(true,GPO_I2Cconfig);
giovannivisentini 29:7a2dfd06cb29 1480
giovannivisentini 29:7a2dfd06cb29 1481 //start the manageGPO procedure
giovannivisentini 29:7a2dfd06cb29 1482 return M24SR_SendSelectApplication();
giovannivisentini 29:7a2dfd06cb29 1483 }
giovannivisentini 29:7a2dfd06cb29 1484
Davidroid 34:b76765d2cc68 1485 M24SR::StatusTypeDef M24SR::M24SR_ManageRFGPO(NFC_GPO_MGMT GPO_I2Cconfig) {
giovannivisentini 29:7a2dfd06cb29 1486
Davidroid 33:e6b7e74be1d5 1487 if(RFDisablePin.is_connected()==0) {
giovannivisentini 29:7a2dfd06cb29 1488 return M24SR_IO_PIN_NOT_CONNECTED;
giovannivisentini 29:7a2dfd06cb29 1489 }
giovannivisentini 29:7a2dfd06cb29 1490 if (GPO_I2Cconfig > STATE_CONTROL) {
giovannivisentini 29:7a2dfd06cb29 1491 return M24SR_IO_ERROR_PARAMETER;
giovannivisentini 29:7a2dfd06cb29 1492 }
giovannivisentini 29:7a2dfd06cb29 1493
giovannivisentini 29:7a2dfd06cb29 1494 //enable the callback for change the gpo
giovannivisentini 29:7a2dfd06cb29 1495 mComponentCallback = &mManageGPOCallback;
giovannivisentini 29:7a2dfd06cb29 1496 mManageGPOCallback.set_new_GPO_config(false,GPO_I2Cconfig);
giovannivisentini 29:7a2dfd06cb29 1497
giovannivisentini 29:7a2dfd06cb29 1498 //start the manageGPO procedure
giovannivisentini 29:7a2dfd06cb29 1499 return M24SR_SendSelectApplication();
giovannivisentini 29:7a2dfd06cb29 1500 }
giovannivisentini 29:7a2dfd06cb29 1501
Davidroid 34:b76765d2cc68 1502 M24SR::StatusTypeDef M24SR::M24SR_RFConfig(uint8_t OnOffChoice) {
Davidroid 33:e6b7e74be1d5 1503 if (RFDisablePin.is_connected()==0) {
giovannivisentini 29:7a2dfd06cb29 1504 return M24SR_IO_PIN_NOT_CONNECTED;
giovannivisentini 29:7a2dfd06cb29 1505 }
giovannivisentini 29:7a2dfd06cb29 1506 /* Disable RF */
giovannivisentini 29:7a2dfd06cb29 1507 if (OnOffChoice != 0) {
giovannivisentini 29:7a2dfd06cb29 1508 M24SR_IO_RFDIS_WritePin(GPIO_PIN_RESET);
giovannivisentini 29:7a2dfd06cb29 1509 } else {
giovannivisentini 29:7a2dfd06cb29 1510 M24SR_IO_RFDIS_WritePin(GPIO_PIN_SET);
giovannivisentini 29:7a2dfd06cb29 1511 }
giovannivisentini 29:7a2dfd06cb29 1512 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1513 }
giovannivisentini 29:7a2dfd06cb29 1514
Davidroid 34:b76765d2cc68 1515 M24SR::StatusTypeDef M24SR::M24SR_IO_SendI2Ccommand(uint8_t NbByte, uint8_t *pBuffer) {
giovannivisentini 29:7a2dfd06cb29 1516 int ret = dev_I2C.write(address, (char*) pBuffer, NbByte);
Davidroid 33:e6b7e74be1d5 1517 if (ret == 0) {
giovannivisentini 29:7a2dfd06cb29 1518 return M24SR_SUCCESS;
Davidroid 33:e6b7e74be1d5 1519 }
giovannivisentini 29:7a2dfd06cb29 1520 return M24SR_IO_ERROR_I2CTIMEOUT;
giovannivisentini 29:7a2dfd06cb29 1521 }
giovannivisentini 29:7a2dfd06cb29 1522
Davidroid 34:b76765d2cc68 1523 M24SR::StatusTypeDef M24SR::M24SR_IO_ReceiveI2Cresponse(uint8_t NbByte, uint8_t *pBuffer) {
giovannivisentini 29:7a2dfd06cb29 1524 int ret = dev_I2C.read(address, (char*) pBuffer, NbByte);
Davidroid 33:e6b7e74be1d5 1525 if (ret == 0) {
giovannivisentini 29:7a2dfd06cb29 1526 return M24SR_SUCCESS;
Davidroid 33:e6b7e74be1d5 1527 }
giovannivisentini 29:7a2dfd06cb29 1528
giovannivisentini 29:7a2dfd06cb29 1529 return M24SR_IO_ERROR_I2CTIMEOUT;
giovannivisentini 29:7a2dfd06cb29 1530 }
giovannivisentini 29:7a2dfd06cb29 1531
Davidroid 34:b76765d2cc68 1532 M24SR::StatusTypeDef M24SR::M24SR_IO_PollI2C(void) {
giovannivisentini 29:7a2dfd06cb29 1533
giovannivisentini 30:68fa3accb6b4 1534 int status = 1;
giovannivisentini 30:68fa3accb6b4 1535 while (status != 0 ) {
giovannivisentini 30:68fa3accb6b4 1536 //send the device address and wait to recevie an ack bit
giovannivisentini 30:68fa3accb6b4 1537 status = dev_I2C.write(address,NULL,0);
giovannivisentini 30:68fa3accb6b4 1538 }
giovannivisentini 30:68fa3accb6b4 1539 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1540 }
giovannivisentini 29:7a2dfd06cb29 1541
Davidroid 34:b76765d2cc68 1542 M24SR::StatusTypeDef M24SR::manage_event(void){
giovannivisentini 29:7a2dfd06cb29 1543
Davidroid 33:e6b7e74be1d5 1544 switch(mLastCommandSend) {
giovannivisentini 29:7a2dfd06cb29 1545 case SELECT_APPLICATION:
giovannivisentini 29:7a2dfd06cb29 1546 return M24SR_ReceiveSelectApplication();
giovannivisentini 29:7a2dfd06cb29 1547 case SELECT_CC_FILE:
giovannivisentini 29:7a2dfd06cb29 1548 return M24SR_ReceiveSelectCCfile();
giovannivisentini 29:7a2dfd06cb29 1549 case SELECT_NDEF_FILE:
giovannivisentini 29:7a2dfd06cb29 1550 return M24SR_ReceiveSelectNDEFfile();
giovannivisentini 29:7a2dfd06cb29 1551 case SELECT_SYSTEM_FILE:
giovannivisentini 29:7a2dfd06cb29 1552 return M24SR_ReceiveSelectSystemfile();
giovannivisentini 29:7a2dfd06cb29 1553 case READ:
giovannivisentini 29:7a2dfd06cb29 1554 return M24SR_ReceiveReadBinary();
giovannivisentini 29:7a2dfd06cb29 1555 case UPDATE:
giovannivisentini 29:7a2dfd06cb29 1556 return M24SR_ReceiveUpdateBinary();
giovannivisentini 29:7a2dfd06cb29 1557 case VERIFY:
giovannivisentini 29:7a2dfd06cb29 1558 return M24SR_ReceiveVerify();
giovannivisentini 29:7a2dfd06cb29 1559 case DESELECT:
giovannivisentini 29:7a2dfd06cb29 1560 return M24SR_ReceiveDeselect();
giovannivisentini 29:7a2dfd06cb29 1561 case CHANGE_REFERENCE_DATA:
giovannivisentini 29:7a2dfd06cb29 1562 return M24SR_ReceiveChangeReferenceData();
giovannivisentini 29:7a2dfd06cb29 1563 case ENABLE_VERIFICATION_REQUIREMENT:
giovannivisentini 29:7a2dfd06cb29 1564 return M24SR_ReceiveEnableVerificationRequirement();
giovannivisentini 29:7a2dfd06cb29 1565 case DISABLE_VERIFICATION_REQUIREMENT:
giovannivisentini 29:7a2dfd06cb29 1566 return M24SR_ReceiveDisableVerificationRequirement();
giovannivisentini 29:7a2dfd06cb29 1567 case ENABLE_PERMANET_STATE:
giovannivisentini 29:7a2dfd06cb29 1568 return M24SR_ReceiveEnablePermanentState();
giovannivisentini 29:7a2dfd06cb29 1569 case DISABLE_PERMANET_STATE:
giovannivisentini 29:7a2dfd06cb29 1570 return M24SR_ReceiveDisablePermanentState();
giovannivisentini 29:7a2dfd06cb29 1571 default:
giovannivisentini 29:7a2dfd06cb29 1572 return M24SR_SUCCESS;
giovannivisentini 29:7a2dfd06cb29 1573 }//switch
giovannivisentini 29:7a2dfd06cb29 1574 }//manageInterrupt
giovannivisentini 29:7a2dfd06cb29 1575
Davidroid 33:e6b7e74be1d5 1576 NDefLib::NDefNfcTag&M24SR::get_NDef_tag(){
Davidroid 33:e6b7e74be1d5 1577 return *mNDefTagUtil;
giovannivisentini 29:7a2dfd06cb29 1578 }
giovannivisentini 29:7a2dfd06cb29 1579
Davidroid 33:e6b7e74be1d5 1580
giovannivisentini 29:7a2dfd06cb29 1581 /******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/