ST / X_NUCLEO_NFC01A1

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

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@29:7a2dfd06cb29, 2017-04-28 (annotated)

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