rfal_st25tb.cpp

00001 
00002 /******************************************************************************
00003   * @attention
00004   *
00005   * <h2><center>&copy; COPYRIGHT 2016 STMicroelectronics</center></h2>
00006   *
00007   * Licensed under ST MYLIBERTY SOFTWARE LICENSE AGREEMENT (the "License");
00008   * You may not use this file except in compliance with the License.
00009   * You may obtain a copy of the License at:
00010   *
00011   *        http://www.st.com/myliberty
00012   *
00013   * Unless required by applicable law or agreed to in writing, software 
00014   * distributed under the License is distributed on an "AS IS" BASIS, 
00015   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
00016   * AND SPECIFICALLY DISCLAIMING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
00017   * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
00018   * See the License for the specific language governing permissions and
00019   * limitations under the License.
00020   *
00021 ******************************************************************************/
00022 
00023 /*
00024  *      PROJECT:   ST25R391x firmware
00025  *      $Revision: $
00026  *      LANGUAGE:  ISO C99
00027  */
00028 
00029 /*! \file rfal_st25tb.c
00030  *
00031  *  \author Gustavo Patricio
00032  *
00033  *  \brief Implementation of ST25TB interface 
00034  *
00035  */
00036 
00037 /*
00038  ******************************************************************************
00039  * INCLUDES
00040  ******************************************************************************
00041  */
00042 #include "rfal_st25tb.h"
00043 #include "utils.h"
00044 #include "platform1.h"
00045 
00046 /*
00047  ******************************************************************************
00048  * ENABLE SWITCH
00049  ******************************************************************************
00050  */
00051 #ifndef RFAL_FEATURE_ST25TB
00052     #error " RFAL: Module configuration missing. Please enable/disable ST25TB module by setting: RFAL_FEATURE_ST25TB "
00053 #endif
00054 
00055 #if RFAL_FEATURE_ST25TB
00056 
00057 /*
00058  ******************************************************************************
00059  * GLOBAL DEFINES
00060  ******************************************************************************
00061  */
00062 
00063 #define RFAL_ST25TB_CMD_LEN          1                                 /*!< ST25TB length of a command                       */
00064 #define RFAL_ST25TB_SLOTS            16                                /*!< ST25TB number of slots                           */
00065 #define RFAL_ST25TB_SLOTNUM_MASK     0x0F                              /*!< ST25TB Slot Number bit mask on SlotMarker        */
00066 #define RFAL_ST25TB_SLOTNUM_SHIFT    4                                 /*!< ST25TB Slot Number shift on SlotMarker           */
00067 
00068 #define RFAL_ST25TB_INITIATE_CMD1    0x06                              /*!< ST25TB Initiate command byte1                    */
00069 #define RFAL_ST25TB_INITIATE_CMD2    0x00                              /*!< ST25TB Initiate command byte2                    */
00070 #define RFAL_ST25TB_PCALL_CMD1       0x06                              /*!< ST25TB Pcall16 command byte1                     */
00071 #define RFAL_ST25TB_PCALL_CMD2       0x04                              /*!< ST25TB Pcall16 command byte2                     */
00072 #define RFAL_ST25TB_SELECT_CMD       0x0E                              /*!< ST25TB Select command                            */
00073 #define RFAL_ST25TB_GET_UID_CMD      0x0B                              /*!< ST25TB Get UID command                           */
00074 #define RFAL_ST25TB_COMPLETION_CMD   0x0F                              /*!< ST25TB Completion command                        */
00075 #define RFAL_ST25TB_RESET_INV_CMD    0x0C                              /*!< ST25TB Reset to Inventory command                */
00076 #define RFAL_ST25TB_READ_BLOCK_CMD   0x08                              /*!< ST25TB Read Block command                        */
00077 #define RFAL_ST25TB_WRITE_BLOCK_CMD  0x09                              /*!< ST25TB Write Block command                       */
00078 
00079 
00080 #define RFAL_ST25TB_T0               2157                              /*!< ST25TB t0  159 us   ST25TB RF characteristics    */
00081 #define RFAL_ST25TB_T1               2048                              /*!< ST25TB t1  151 us   ST25TB RF characteristics    */
00082 
00083 #define RFAL_ST25TB_FWT             (RFAL_ST25TB_T0 + RFAL_ST25TB_T1)  /*!< ST25TB FWT  = T0 + T1                            */
00084 #define RFAL_ST25TB_TW              rfalConvMsTo1fc(7)                 /*!< ST25TB TW : Programming time for write max 7ms   */
00085 
00086 
00087 /*
00088  ******************************************************************************
00089  * GLOBAL MACROS
00090  ******************************************************************************
00091  */
00092 
00093 /*
00094 ******************************************************************************
00095 * GLOBAL TYPES
00096 ******************************************************************************
00097 */
00098 
00099 /*! Initiate Request */
00100 typedef struct
00101 {
00102     uint8_t  cmd1;                       /*!< Initiate Request cmd1: 0x06 */
00103     uint8_t  cmd2;                       /*!< Initiate Request cmd2: 0x00 */
00104 } rfalSt25tbInitiateReq;
00105 
00106 /*! Pcall16 Request */
00107 typedef struct
00108 {
00109     uint8_t  cmd1;                       /*!< Pcal16 Request cmd1: 0x06   */
00110     uint8_t  cmd2;                       /*!< Pcal16 Request cmd2: 0x04   */
00111 } rfalSt25tbPcallReq;
00112 
00113 
00114 /*! Select Request */
00115 typedef struct
00116 {
00117     uint8_t  cmd;                       /*!< Select Request cmd: 0x0E     */
00118     uint8_t  chipId;                    /*!< Chip ID                      */
00119 } rfalSt25tbSelectReq;
00120 
00121 /*! Read Block Request */
00122 typedef struct
00123 {
00124     uint8_t  cmd;                       /*!< Select Request cmd: 0x08     */
00125     uint8_t  address;                   /*!< Block address                */
00126 } rfalSt25tbReadBlockReq;
00127 
00128 /*! Write Block Request */
00129 typedef struct
00130 {
00131     uint8_t              cmd;           /*!< Select Request cmd: 0x09     */
00132     uint8_t              address;       /*!< Block address                */
00133     rfalSt25tbBlock  data;               /*!< Block Data                   */
00134 } rfalSt25tbWriteBlockReq;
00135 
00136 
00137 /*
00138 ******************************************************************************
00139 * LOCAL FUNCTION PROTOTYPES
00140 ******************************************************************************
00141 */
00142 
00143 
00144 /*
00145 ******************************************************************************
00146 * LOCAL VARIABLES
00147 ******************************************************************************
00148 */
00149 
00150 /*
00151 ******************************************************************************
00152 * GLOBAL FUNCTIONS
00153 ******************************************************************************
00154 */
00155 
00156 /*******************************************************************************/
00157 ReturnCode rfalSt25tbPollerInitialize( SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00158 {
00159     return rfalNfcbPollerInitialize( mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00160 }
00161 
00162 
00163 /*******************************************************************************/
00164 ReturnCode rfalSt25tbPollerCheckPresence( uint8_t *chipId, SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00165 {
00166     ReturnCode ret;
00167     uint8_t    chipIdRes;
00168 
00169     chipIdRes = 0x00;
00170    
00171     /* Send Initiate Request */
00172     ret = rfalSt25tbPollerInitiate( &chipIdRes, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00173     
00174     /*  Check if a transmission error was detected */
00175     if( (ret == ERR_CRC) || (ret == ERR_FRAMING) )
00176     {
00177         return ERR_NONE;
00178     }
00179     
00180     /* Copy chip ID if requested */
00181     if( chipId != NULL )
00182     {
00183         *chipId = chipIdRes;
00184     }
00185     
00186     return ret;
00187 }
00188 
00189 
00190 /*******************************************************************************/
00191 ReturnCode rfalSt25tbPollerInitiate( uint8_t *chipId,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00192 {
00193     ReturnCode            ret;
00194     uint16_t              rxLen;
00195     rfalSt25tbInitiateReq initiateReq;
00196     uint8_t               rxBuf[RFAL_ST25TB_CHIP_ID_LEN + RFAL_ST25TB_CRC_LEN]; /* In case we receive less data that CRC, RF layer will not remove the CRC from buffer */
00197     
00198     /* Compute Initiate Request */
00199     initiateReq.cmd1   = RFAL_ST25TB_INITIATE_CMD1;
00200     initiateReq.cmd2   = RFAL_ST25TB_INITIATE_CMD2;
00201     
00202     /* Send Initiate Request */
00203     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&initiateReq, sizeof(rfalSt25tbInitiateReq), (uint8_t*)rxBuf, sizeof(rxBuf), &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00204     
00205     /* Check for valid Select Response   */
00206     if( (ret == ERR_NONE) && (rxLen != RFAL_ST25TB_CHIP_ID_LEN) )
00207     {
00208         return ERR_PROTO;
00209     }
00210     
00211     /* Copy chip ID if requested */
00212     if( chipId != NULL )
00213     {
00214         *chipId = *rxBuf;
00215     }
00216     
00217     return ret;
00218 }
00219 
00220 
00221 /*******************************************************************************/
00222 ReturnCode rfalSt25tbPollerPcall( uint8_t *chipId,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00223 {
00224     ReturnCode         ret;
00225     uint16_t           rxLen;
00226     rfalSt25tbPcallReq pcallReq;
00227 
00228     /* Compute Pcal16 Request */
00229     pcallReq.cmd1   = RFAL_ST25TB_PCALL_CMD1;
00230     pcallReq.cmd2   = RFAL_ST25TB_PCALL_CMD2;
00231     
00232     /* Send Pcal16 Request */
00233     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&pcallReq, sizeof(rfalSt25tbPcallReq), (uint8_t*)chipId, RFAL_ST25TB_CHIP_ID_LEN, &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00234     
00235     /* Check for valid Select Response   */
00236     if( (ret == ERR_NONE) && (rxLen != RFAL_ST25TB_CHIP_ID_LEN) )
00237     {
00238         return ERR_PROTO;
00239     }
00240     
00241     return ret;
00242 }
00243 
00244 
00245 /*******************************************************************************/
00246 ReturnCode rfalSt25tbPollerSlotMarker( uint8_t slotNum, uint8_t *chipIdRes,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00247 {
00248     ReturnCode ret;
00249     uint16_t   rxLen;
00250     uint8_t    slotMarker;
00251 
00252     if( (slotNum == 0) || (slotNum > 15) )
00253     {
00254         return ERR_PARAM;
00255     }
00256     
00257     /* Compute SlotMarker */
00258     slotMarker = ( ((slotNum & RFAL_ST25TB_SLOTNUM_MASK) << RFAL_ST25TB_SLOTNUM_SHIFT) | RFAL_ST25TB_PCALL_CMD1 );
00259     
00260     
00261     /* Send SlotMarker */
00262     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&slotMarker, RFAL_ST25TB_CMD_LEN, (uint8_t*)chipIdRes, RFAL_ST25TB_CHIP_ID_LEN, &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00263     
00264     /* Check for valid ChipID Response   */
00265     if( (ret == ERR_NONE) && (rxLen != RFAL_ST25TB_CHIP_ID_LEN) )
00266     {
00267         return ERR_PROTO;
00268     }
00269     
00270     return ret;
00271 }
00272 
00273 
00274 /*******************************************************************************/
00275 ReturnCode rfalSt25tbPollerSelect( uint8_t chipId,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00276 {
00277     ReturnCode          ret;
00278     uint16_t            rxLen;    
00279     rfalSt25tbSelectReq selectReq;
00280     uint8_t             chipIdRes;
00281 
00282     /* Compute Select Request */
00283     selectReq.cmd    = RFAL_ST25TB_SELECT_CMD;
00284     selectReq.chipId = chipId;
00285     
00286     /* Send Select Request */
00287     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&selectReq, sizeof(rfalSt25tbSelectReq), (uint8_t*)&chipIdRes, RFAL_ST25TB_CHIP_ID_LEN, &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00288     
00289     /* Check for valid Select Response   */
00290     if( (ret == ERR_NONE) && ((rxLen != RFAL_ST25TB_CHIP_ID_LEN) || (chipIdRes != chipId)) )
00291     {
00292         return ERR_PROTO;
00293     }
00294     
00295     return ret;
00296 }
00297 
00298 
00299 /*******************************************************************************/
00300 ReturnCode rfalSt25tbPollerGetUID( rfalSt25tbUID  *UID,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00301 {
00302     ReturnCode ret;
00303     uint16_t   rxLen;
00304     uint8_t    getUidReq;
00305     
00306 
00307     /* Compute Get UID Request */
00308     getUidReq = RFAL_ST25TB_GET_UID_CMD;
00309     
00310     /* Send Select Request */
00311     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&getUidReq, RFAL_ST25TB_CMD_LEN, (uint8_t*)UID, sizeof(rfalSt25tbUID ), &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00312     
00313     /* Check for valid UID Response */
00314     if( (ret == ERR_NONE) && (rxLen != RFAL_ST25TB_UID_LEN) )
00315     {
00316         return ERR_PROTO;
00317     }
00318     
00319     return ret;
00320 }
00321 
00322 
00323 /*******************************************************************************/
00324 ReturnCode rfalSt25tbPollerCollisionResolution( uint8_t devLimit, rfalSt25tbListenDevice  *st25tbDevList, uint8_t *devCnt,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00325 {
00326     uint8_t    i;
00327     uint8_t    chipId;
00328     ReturnCode ret;
00329     bool       detected;  /* collision or device was detected */
00330     
00331     if( (st25tbDevList == NULL) || (devCnt == NULL) || (devLimit == 0) )
00332     {
00333         return ERR_PARAM;
00334     }
00335     
00336     *devCnt = 0;
00337     
00338     /* Step 1: Send Initiate */
00339     ret = rfalSt25tbPollerInitiate( &chipId, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00340     if( ret == ERR_NONE )
00341     {
00342         /* If only 1 answer is detected */
00343         st25tbDevList[*devCnt].chipID        = chipId;
00344         st25tbDevList[*devCnt].isDeselected  = false;
00345         
00346         /* Retrieve its UID and keep it Selected*/
00347         ret = rfalSt25tbPollerSelect( chipId, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00348         
00349         if( ERR_NONE == ret )
00350         {
00351             ret = rfalSt25tbPollerGetUID( &st25tbDevList[*devCnt].UID, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00352         }
00353         
00354         if( ERR_NONE == ret )
00355         {
00356             (*devCnt)++;
00357         }
00358     }
00359     /* Always proceed to Pcall16 anticollision as phase differences of tags can lead to no tag recognized, even if there is one */
00360     if( *devCnt < devLimit )
00361     {
00362         /* Multiple device responses */
00363         do
00364         {
00365             detected = false;
00366             
00367             for(i = 0; i < RFAL_ST25TB_SLOTS; i++)
00368             {
00369                 platformDelay(1);  /* Wait t2: Answer to new request delay  */
00370                 
00371                 if( i==0 )
00372                 {
00373                     /* Step 2: Send Pcall16 */
00374                     ret = rfalSt25tbPollerPcall( &chipId, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00375                 }
00376                 else
00377                 {
00378                     /* Step 3-17: Send Pcall16 */
00379                     ret = rfalSt25tbPollerSlotMarker( i, &chipId, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00380                 }
00381                 
00382                 if( ret == ERR_NONE )
00383                 {
00384                     /* Found another device */
00385                     st25tbDevList[*devCnt].chipID        = chipId;
00386                     st25tbDevList[*devCnt].isDeselected  = false;
00387                     
00388                     /* Select Device, retrieve its UID  */
00389                     ret = rfalSt25tbPollerSelect( chipId, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00390 
00391                     /* By Selecting this device, the previous gets Deselected */
00392                     if( (*devCnt) > 0 )
00393                     {
00394                         st25tbDevList[(*devCnt)-1].isDeselected  = true;
00395                     }
00396 
00397                     if( ERR_NONE == ret )
00398                     {
00399                         rfalSt25tbPollerGetUID( &st25tbDevList[*devCnt].UID, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00400                     }
00401 
00402                     if( ERR_NONE == ret )
00403                     {
00404                         (*devCnt)++;
00405                     }
00406                 }
00407                 else if( (ret == ERR_CRC) || (ret == ERR_FRAMING) )
00408                 {
00409                     detected = true;
00410                 }
00411                 
00412                 if( *devCnt >= devLimit )
00413                 {
00414                     break;
00415                 }
00416             }
00417         }
00418         while( (detected == true) && (*devCnt < devLimit) );
00419     }
00420 
00421     return ERR_NONE;
00422 }
00423 
00424 
00425 /*******************************************************************************/
00426 ReturnCode rfalSt25tbPollerReadBlock( uint8_t blockAddress, rfalSt25tbBlock  *blockData,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00427 {
00428     ReturnCode             ret;
00429     uint16_t               rxLen;
00430     rfalSt25tbReadBlockReq readBlockReq;
00431     
00432 
00433     /* Compute Read Block Request */
00434     readBlockReq.cmd     = RFAL_ST25TB_READ_BLOCK_CMD;
00435     readBlockReq.address = blockAddress;
00436     
00437     /* Send Read Block Request */
00438     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&readBlockReq, sizeof(rfalSt25tbReadBlockReq), (uint8_t*)blockData, sizeof(rfalSt25tbBlock ), &rxLen, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00439     
00440     /* Check for valid UID Response */
00441     if( (ret == ERR_NONE) && (rxLen != RFAL_ST25TB_BLOCK_LEN) )
00442     {
00443         return ERR_PROTO;
00444     }
00445     
00446     return ret;
00447 }
00448 
00449 
00450 /*******************************************************************************/
00451 ReturnCode rfalSt25tbPollerWriteBlock( uint8_t blockAddress, rfalSt25tbBlock  *blockData,SPI* mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00452 {
00453     ReturnCode              ret;
00454     uint16_t                rxLen;
00455     rfalSt25tbWriteBlockReq writeBlockReq;
00456     rfalSt25tbBlock          tmpBlockData; 
00457     
00458 
00459     /* Compute Write Block Request */
00460     writeBlockReq.cmd     = RFAL_ST25TB_WRITE_BLOCK_CMD;
00461     writeBlockReq.address = blockAddress;
00462     ST_MEMCPY( writeBlockReq.data, blockData, RFAL_ST25TB_BLOCK_LEN );
00463     
00464     /* Send Write Block Request */
00465     ret = rfalTransceiveBlockingTxRx( (uint8_t*)&writeBlockReq, sizeof(rfalSt25tbWriteBlockReq), tmpBlockData, RFAL_ST25TB_BLOCK_LEN, &rxLen, RFAL_TXRX_FLAGS_DEFAULT, (RFAL_ST25TB_FWT + RFAL_ST25TB_TW), mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00466     
00467     /* Check if an unexpected answer was received */
00468     if( ret == ERR_NONE )
00469     {
00470         return ERR_PROTO; 
00471     }
00472     /* Check there was any error besides Timeout*/
00473     else if( ret != ERR_TIMEOUT )
00474     {
00475         return ret;
00476     }
00477     
00478     ret = rfalSt25tbPollerReadBlock(blockAddress, &tmpBlockData, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00479     if( ret == ERR_NONE )
00480     {
00481         if( !ST_BYTECMP( tmpBlockData, blockData, RFAL_ST25TB_BLOCK_LEN ) )
00482         {
00483             return ERR_NONE;
00484         }
00485         return ERR_PROTO;
00486     }
00487     return ret;
00488 }
00489 
00490 
00491 /*******************************************************************************/
00492 ReturnCode rfalSt25tbPollerCompletion( SPI*  mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00493 {
00494     uint8_t  completionReq;
00495 
00496     /* Compute Completion Request */
00497     completionReq = RFAL_ST25TB_COMPLETION_CMD;
00498     
00499     /* Send Completion Request, no response is expected */
00500     return rfalTransceiveBlockingTxRx( (uint8_t*)&completionReq, RFAL_ST25TB_CMD_LEN, NULL, 0, NULL, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00501 }
00502 
00503 
00504 /*******************************************************************************/
00505 ReturnCode rfalSt25tbPollerResetToInventory( SPI*  mspiChannel, ST25R3911* mST25, DigitalOut* gpio_cs, InterruptIn* IRQ, DigitalOut* fieldLED_01, DigitalOut* fieldLED_02, DigitalOut* fieldLED_03, DigitalOut* fieldLED_04, DigitalOut* fieldLED_05, DigitalOut* fieldLED_06 )
00506 {
00507     uint8_t resetInvReq;
00508 
00509     /* Compute Completion Request */
00510     resetInvReq = RFAL_ST25TB_RESET_INV_CMD;
00511     
00512     /* Send Completion Request, no response is expected */
00513     return rfalTransceiveBlockingTxRx( (uint8_t*)&resetInvReq, RFAL_ST25TB_CMD_LEN, NULL, 0, NULL, RFAL_TXRX_FLAGS_DEFAULT, RFAL_ST25TB_FWT, mspiChannel, mST25, gpio_cs, IRQ, fieldLED_01, fieldLED_02, fieldLED_03, fieldLED_04, fieldLED_05, fieldLED_06 ) ;
00514 }
00515 
00516 #endif /* RFAL_FEATURE_ST25TB */