path: root/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c

/*
 * NFC.c
 *
 *  Created on: Jan 19, 2020
 *      Author: avi
 */

#include <stdint.h>
#include <stdbool.h>
#include <string.h> //memset
#include <DataDef.h>
#include "datadef.h"
#include <Utilities/delay.h>
#include "drivers/I2C_Communication/I2C.h"
#include "drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h"
#include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
#include "drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"

#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
#include <Drivers/I2C_Communication/RFID_NFC/NFC.h>
#include <Drivers/I2C_Communication/RFID_NFC/RFID_Settings.h>
#include <Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h>
#include <Drivers/I2C_Communication/RFID_NFC/RFID_IFS.h>
#include <Drivers/I2C_Communication/RFID_NFC/RFID_Waste.h>
#include <Drivers/I2C_Communication/I2C_RFID_Dispenser_Task/I2C_RFID_Disp_Task.h>

uint8_t RFID_Discovery_TimeOut[3] = {RFID_Discovery_TimeOut_Limit,RFID_Discovery_TimeOut_Limit,RFID_Discovery_TimeOut_Limit};
bool RequestForDiscovery[3] = {false,false,false};//request from WHS logic
bool DiscoverRFIDTagEvery100mSec[3] = {false,false,false};

RFID_TAG_State_Machine    TagStage[3] = {Tag_Idle,Tag_Idle,Tag_Idle};

NxpNci_RfIntf_t tagInfo;

RFID_STATUS RFID_Status_Words[Max_Readers];

bool  Init_RFID_Reader(RFID_READER_ID Reader_ID)//0-2
{
    static bool firstTime = true;
    RFID_RETURN_CODE RFIDRetCode;

    if(firstTime)
    {
        InitFields();
        firstTime = false;
    }

    RFIDRetCode = RFID_Connect(Reader_ID);//0-2 - > Active_RFID_Reader = Cart_ID;//1-3   - verify using scope/ fluke

    if(RFIDRetCode == SUCCESS)
    {
        return OK;
    }
    else
    {
        return ERROR;
    }

}

uint8_t RFID_Print_Errors(uint8_t readerID, RFID_RETURN_CODE Err_Code)
{
    uint8_t Status = ERROR;

    switch(Err_Code)
    {
        case SUCCESS:
            Status = OK;
        break;
        case ERR_UNDEFINED_READER:
                LOG_ERROR (readerID, "RFID - ERR_UNDEFINED_READER");
            break;
        case ERR_NOT_INITIALIZED:
                LOG_ERROR (readerID, "RFID - ERR_NOT_INITIALIZED");
            break;
        case ERR_CONNECTION:
                LOG_ERROR (readerID, "RFID - ERR_CONNECTION");
            break;
        case ERR_CONFIG_SETTINGS:
                LOG_ERROR (readerID, "RFID - ERR_CONFIG_SETTINGS");
            break;
        case ERR_CONFIG_MODE:
                LOG_ERROR (readerID, "RFID - ERR_CONFIG_MODE");
            break;
        case ERR_START_DISCOVERY:
                LOG_ERROR (readerID, "RFID - ERR_START_DISCOVERY");
            break;
        case ERR_STOP_DISCOVERY:
                LOG_ERROR (readerID, "RFID - ERR_STOP_DISCOVERY");
            break;
        case ERR_LENGTH:
                LOG_ERROR (readerID, "RFID - ERR_LENGTH");
            break;
        case ERR_TAG_MEMORY_READ:
                LOG_ERROR (readerID, "RFID - ERR_TAG_MEMORY_READ");
            break;
        case ERR_TAG_MEMORY_WRITE:
                LOG_ERROR (readerID, "RFID - ERR_TAG_MEMORY_WRITE");
            break;
        case TAG_NOT_DETECTED:
                LOG_ERROR (readerID, "RFID - TAG_NOT_DETECTED");
            break;
        case UNSUPPORTED_PROTOCOL:
                LOG_ERROR (readerID, "RFID - UNSUPPORTED_PROTOCOL");
            break;
        default:
                LOG_ERROR (readerID, "RFID - ERR_UNKNOWN");
            break;
    }

    return Status;
}

uint8_t uid[7] = {0};
RFID_RETURN_CODE RFID_Status = 0;

uint8_t Connect_to_RFID_Reder(uint8_t readerID)//2
{
    RFID_RETURN_CODE RFIDRetValue;
    uint8_t Status = OK;
/*
    bool isTagValid;
    uint32_t newPwd;
    uint32_t newPACK;
    uint32_t counter;
    int PwdRetVal;
*/
    static uint32_t nop = 0;

    RFID_StartDiscovery(readerID);

    while(1)//only for testing -  stub call the function
    {

        if(RFID_WaitForDiscoveryNotification(readerID, &tagInfo) == SUCCESS)
        {
            RFIDRetValue = getUID( readerID, &tagInfo, uid );
            RFID_Status = RFIDRetValue;
            Status |= RFID_Print_Errors(readerID, RFIDRetValue);
    /*
            //password authentication
            PwdRetVal = checkPwd( newPwd, newPACK );

            if(PwdRetVal == 1)
            {
                //OK
            }
            else if(PwdRetVal == -1)
            {
                LOG_ERROR (readerID, "RFID - checkPwd: wrong Pwd");//wrong value
                Status |= ERROR;
            }
            else if(PwdRetVal == -2)
            {
                LOG_ERROR (readerID, "RFID - checkPwd: wrong pack value");//wrong pack value
                Status |= ERROR;
            }

            counter = GetCounter (readerID, &tagInfo);
            isTagValid = IsTagValid(readerID, &tagInfo);
            */
            break;
        }
        else
        {
            nop++;

        }
        //Task_sleep (1000);
        delayms(1000);
    }

    RFID_StopDiscovery(readerID);

    return Status;
}


NFC_Tag NFC_Tag_R[Max_Readers];//read
NFC_Tag NFC_Tag_W[Max_Readers];//write (for testing / stub)
NFC_Tag NFC_Tag_U[Max_Readers];//read with updates

//NFCTag_t NFC_Tag_W_Struct;


RFID_RETURN_CODE  TagWriteData(RFID_READER_ID readerID)
{
    //uint8_t index = 0;
    uint32_t dummy = 0;
    uint32_t Tuint32 = 0;
    //uint16_t Tuint16 = 0;
    //uint8_t Tuint8 = 0;
    RFID_RETURN_CODE RFIDRetValue;

    //NxpNci_RfIntf_t TagInfo;

    uint8_t tagMemory[256];

//    uint8_t Serial[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G'};

    //RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1);

//    for(index = 0; index < sizeof(Serial); index++)
//    {
//        Serial[index] = 'a'+index;
//    }
///*
//    for(index = 0; index < sizeof(NFC_Tag_W_Struct.CartSN); index++)
//    {
//        NFC_Tag_W_Struct.CartSN[index] = 'M'+index;
//    }
//
//    RFIDRetValue = WriteValue( readerID, &TagInfo, NFC_Tag_W_Struct.CartSN, 0, dummy );
//    */
//    /*
//    for(index = 0; index < sizeof(NFC_Tag_W[readerID].Struct.CartSN); index++)
//    {
//        NFC_Tag_W[readerID].Struct.CartSN[index] = 'c'+index;
//    }
//
//    RFIDRetValue = WriteValue( readerID, &TagInfo, NFC_Tag_W[readerID].Struct.CartSN, 0, dummy );
//     */
//    RFIDRetValue = WriteValue( readerID, &tagInfo, Serial, 0, dummy );

    //Serial
    strcpy(NFC_Tag_W[readerID].Struct.Serial, "123456789abcdefg");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.Serial, 0, dummy );

    //factory id
    strcpy(NFC_Tag_W[readerID].Struct.factoryID, "FID");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.factoryID, 1, dummy );
/*
    //////////////////
    //uint8_t fillingSystem[2] = {0xab, 0xcd};
    uint16_t fillingSystem = 50;//50 -> write 0x3035 ASCII 35 00
    //filling system
    //RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, fillingSystem );
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, fillingSystem );
*/
    //filling system
    NFC_Tag_W[readerID].Struct.fillingSystem = 50;
    Tuint32 = NFC_Tag_W[readerID].Struct.fillingSystem;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, Tuint32 );
    //work order
    strcpy(NFC_Tag_W[readerID].Struct.workOrder, "WORK-ORDER");

    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.workOrder, 3, dummy );
    //color name
    strcpy(NFC_Tag_W[readerID].Struct.colorName, "-COLOR-NAME-");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.colorName, 4, dummy );

    //category
    strcpy(NFC_Tag_W[readerID].Struct.catagory, "CY");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.catagory, 5, dummy );

    //type
    NFC_Tag_W[readerID].Struct.type = 4321;
    Tuint32 = NFC_Tag_W[readerID].Struct.type;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 6, Tuint32 );

    delayms(2);

    //cartSize
    NFC_Tag_W[readerID].Struct.cartSize = 8765;
    Tuint32 = NFC_Tag_W[readerID].Struct.cartSize;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 7, Tuint32 );

    delayms(2);

    /////////////////

    //inkVolume
    NFC_Tag_W[readerID].Struct.inkVolume = 9696;
    Tuint32 = NFC_Tag_W[readerID].Struct.inkVolume;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 8, Tuint32 );

    delayms(2);
    //inkBatch

    strcpy(NFC_Tag_W[readerID].Struct.inkBatch, "-inkBatch-");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.inkBatch, 9, dummy );
    delayms(2);
    //inkMfgDate
    strcpy(NFC_Tag_W[readerID].Struct.inkMfgDate, "inkMfgDa");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.inkMfgDate, 10, dummy );
    delayms(2);
    //inkEolDate
    strcpy(NFC_Tag_W[readerID].Struct.inkEolDate, "31/12/21");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.inkEolDate, 11, dummy );
    delayms(2);
    //CartFillDate
    strcpy(NFC_Tag_W[readerID].Struct.CartFillDate, "CarFDate");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.CartFillDate, 12, dummy );
    delayms(2);
    //WasteFillDate
    strcpy(NFC_Tag_W[readerID].Struct.WasteFillDate, "WastDate");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.WasteFillDate, 13, dummy );
    delayms(2);
    //Misc
    NFC_Tag_W[readerID].Struct.Misc = 1234;
    Tuint32 = NFC_Tag_W[readerID].Struct.Misc;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 14, Tuint32 );
    delayms(2);
    //pluginCounter
    NFC_Tag_W[readerID].Struct.pluginCounter = 56;
    Tuint32 = NFC_Tag_W[readerID].Struct.pluginCounter;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 15, Tuint32 );
    delayms(2);
    //inkFill
    NFC_Tag_W[readerID].Struct.inkFill = 7;
    Tuint32 = NFC_Tag_W[readerID].Struct.inkFill;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 16, Tuint32 );
    delayms(2);
    //inkUsed
    NFC_Tag_W[readerID].Struct.inkUsed = 8;
    Tuint32 = NFC_Tag_W[readerID].Struct.inkUsed;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 17, Tuint32 );
    delayms(2);
    //inkEmpty
    NFC_Tag_W[readerID].Struct.inkEmpty = 9;
    Tuint32 = NFC_Tag_W[readerID].Struct.inkEmpty;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 18, Tuint32 );
    //wasteEmpty
    NFC_Tag_W[readerID].Struct.wasteEmpty = 1;
    Tuint32 = NFC_Tag_W[readerID].Struct.wasteEmpty;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 19, Tuint32 );
    //wasteFilling
    NFC_Tag_W[readerID].Struct.wasteFilling = 2;
    Tuint32 = NFC_Tag_W[readerID].Struct.wasteFilling;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 20, Tuint32 );
    //wasteFull
    NFC_Tag_W[readerID].Struct.wasteFull = 3;
    Tuint32 = NFC_Tag_W[readerID].Struct.wasteFull;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 21, Tuint32 );
    //blocked
    NFC_Tag_W[readerID].Struct.blocked = TAG_NOT_BLOCKED;
    Tuint32 = NFC_Tag_W[readerID].Struct.blocked;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 22, Tuint32 );
    //fail
    NFC_Tag_W[readerID].Struct.fail = 5;
    Tuint32 = NFC_Tag_W[readerID].Struct.fail;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 23, Tuint32 );
    //wasteCounter
    NFC_Tag_W[readerID].Struct.wasteCounter = 0;
    Tuint32 = NFC_Tag_W[readerID].Struct.wasteCounter;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 24, Tuint32 );
    //MachineIdInl
    strcpy(NFC_Tag_W[readerID].Struct.MachineIdInl, "MachineIdInl1234");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.MachineIdInl, 25, dummy );
    //WasteFillDate
    strcpy(NFC_Tag_W[readerID].Struct.MachineIdWst, "MachineIdWst1234");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.MachineIdWst, 26, dummy );
    //WasteFillDate
    strcpy(NFC_Tag_W[readerID].Struct.reserved, "reserved12345");
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.reserved, 27, dummy );
    //counter
    NFC_Tag_W[readerID].Struct.counter = 1;//5678;
    Tuint32 = NFC_Tag_W[readerID].Struct.counter;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 28, Tuint32 );
    //tagValid
    NFC_Tag_W[readerID].Struct.tagValid = TAG_VALID;
    Tuint32 = NFC_Tag_W[readerID].Struct.tagValid;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 29, Tuint32 );

    //hash
    calcHash( tagInfo.Info.NFC_VPP.ID, sizeof(tagInfo.Info.NFC_VPP.ID), NFC_Tag_W[readerID].Struct.HashValue );//read the UID, calculate Hash and write the hash
    RFIDRetValue = WriteValue( readerID, &tagInfo, NFC_Tag_W[readerID].Struct.HashValue, 30, dummy );

    //crc
    //crc_ccitt_init();
    NFC_Tag_W[readerID].Struct.Checksum_CRC16 = crc_ccitt_update(NFC_Tag_W[readerID].Buf,(sizeof(NFC_Tag_W[readerID].Buf) - sizeof(NFC_Tag_W[readerID].Struct.Checksum_CRC16)));//calculate the crc without tag id and without crc fields
    Tuint32 = NFC_Tag_W[readerID].Struct.Checksum_CRC16;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 31, Tuint32 );


    return RFIDRetValue;
}


//RFID_RETURN_CODE Read_Tag_All_Data()
//{
//
//   // uint8_t index = 0;
//    uint32_t dummy = 0;
//    //uint8_t Tuint8 = 0;
//    //uint16_t Tuint16 = 0;
//    uint32_t Tuint32 = 0;
//    //uint64_t Tuint64 = 0;
//    //uint8_t Tuint8_buf10[10] = 0;
//    RFID_RETURN_CODE RFIDRetValue;
//
//    //NxpNci_RfIntf_t TagInfo;
//
//    uint8_t tagMemory[1024];
//
//    RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1);
//
//    //serial
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.Serial, 0, &dummy );
//    //factory id
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.factoryID, 1, &dummy );
//    //filling system
//    //RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, NFC_Tag_R[readerID].Struct.fillingSystem );
//    //RFIDRetValue = ReadValue( readerID, &tagInfo, &NFC_Tag_R[readerID].Struct.fillingSystem, 2, &dummy );//OK read hex (for writubg 50 read 0335 ASCII 0)
//    /*NFC_Tag_R[readerID].Struct.fillingSystem = ReadValue( readerID, &tagInfo, tagMemory, 2, &dummy );*/
//    //RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, NFC_Tag_R[readerID].Struct.fillingSystem );
//    /* working ok*/
//
//
//    Tuint32=0;
//    RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, &Tuint32 );
//    NFC_Tag_R[readerID].Struct.fillingSystem = (uint16_t)Tuint32;
//
//
//    //work order
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.workOrder, 3, &dummy );
//    //color name
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.colorName, 4, &dummy );
//    //category
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.catagory, 5, &dummy );
//    //type
//    Tuint32 = 0;
//    RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 6, &Tuint32 );
//    NFC_Tag_R[readerID].Struct.type = Tuint32;
//    //cartSize
//    Tuint32 = 0;
//    RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 7, &Tuint32 );
//    NFC_Tag_R[readerID].Struct.cartSize = Tuint32;
//    //inkVolume
//    Tuint32 = 0;
//    RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 8, &Tuint32 );
//    NFC_Tag_R[readerID].Struct.inkVolume = Tuint32;
//    //inkBatch
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.inkBatch, 9, &dummy );
//    //inkMfgDate
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.inkMfgDate, 10, &dummy );
//    //inkEolDate
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.inkEolDate, 11, &dummy );
//    //CartFillDate
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.CartFillDate, 12, &dummy );
//    //WasteFillDate
//    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.WasteFillDate, 13, &dummy );
//
//
//    //Misc
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 14, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.Misc = Tuint32;
//        //pluginCounter
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 15, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.pluginCounter = (uint16_t)Tuint32;
//
//        //inkFill
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 16, &Tuint32 );//FAIL
//        NFC_Tag_R[readerID].Struct.inkFill = (uint8_t)Tuint32;
//
//        //inkUsed
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 17, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.inkUsed = (uint8_t)Tuint32;
//
//        //inkEmpty
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 18, &Tuint32 );//FAIL
//        NFC_Tag_R[readerID].Struct.inkEmpty = (uint8_t)Tuint32;
//        //wasteEmpty
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 19, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.wasteEmpty = (uint8_t)Tuint32;
//        //wasteFilling
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 20, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.wasteFilling = (uint8_t)Tuint32;
//        //wasteFull
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 21, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.wasteFull = (uint8_t)Tuint32;
//        //blocked
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 22, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.blocked = (uint8_t)Tuint32;
//        //fail
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 23, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.fail = (uint8_t)Tuint32;
//        //wasteCounter
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 24, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.wasteCounter = (uint16_t)Tuint32;
//        //MachineIdInl
//        RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.MachineIdInl, 25, &dummy );
//        //MachineIdWst
//        RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.MachineIdWst, 26, &dummy );
//        //reserved
//        RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.reserved, 27, &dummy );
//        //counter
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 28, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.counter = Tuint32;
//        //tagValid
//        Tuint32 = 0;
//        RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 29, &Tuint32 );
//        NFC_Tag_R[readerID].Struct.tagValid = (uint8_t)Tuint32;
//        //hash
//        RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.HashValue, 30, &dummy );
//
//
//    //////////////
//
//    return RFIDRetValue;
//
//}


//--------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------
/*
typedef union
{
    uint8_t  Byte[4];
    uint32_t Word;
}Word_to_Bytes;
*/
//typedef union
//{
//    uint8_t  Byte[4];
//    uint32_t Short;
//}Short_to_Bytes;

#define TagMaxFieldLength 16 // why 256? max is 16

#define Uartsize sizeof(NFC_Tag)


void Init_NFC_Tag_Union(RFID_READER_ID readerID)
{
    uint8_t i = 0;

    memset(NFC_Tag_R[readerID].Buf, 0, Uartsize);

    for(i=0;i<8;i++)//Copy UID
    {
        NFC_Tag_R[readerID].Struct.tagId[i]  = tagInfo.Info.NFC_VPP.ID[i];
    }

    //Padding fields:
    NFC_Tag_R[readerID].Struct.Padding_1_8bit = NFC_Tag_R[readerID].Struct.Paddind_2_8bit = NFC_Tag_R[readerID].Struct.Paddind_3_8bit = 0xFF;
    NFC_Tag_R[readerID].Struct.Paddind_1_16bit = NFC_Tag_R[readerID].Struct.Paddind_2_16bit = NFC_Tag_R[readerID].Struct.Paddind_3_16bit = NFC_Tag_R[readerID].Struct.Paddind_4_16bit = 0xFFFF;

}

RFID_RETURN_CODE Read_Tag_All_Data()
{
    uint32_t dummy = 0;
    RFID_RETURN_CODE RFIDRetValue = SUCCESS;
    uint8_t tagMemory[256];
    uint32_t valueNum = 0;
    uint8_t value[TagMaxFieldLength];
    uint32_t BufferIndex = 8;//start with Serial field
    uint8_t valueIndex, i;
    Word_to_Bytes Word2Bytes;

    RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1);

    Init_NFC_Tag_Union(readerID);

    for(valueIndex = 0; valueIndex < NUMBER_OF_FIELDS; valueIndex++)
    {
        delayms(5);// need to check without it sometimes read wrong values (0xFF... in Serial, MachineIdInl at MachineIdWst)

        while((NFC_Tag_R[readerID].Buf[BufferIndex] != 0x00) && (BufferIndex < (Uartsize-1)))
        {
            NFC_Tag_R[readerID].Buf[BufferIndex] = 0; // reset the padding fields in order to calculate the crc
            BufferIndex++; //Skip padding fields
        }

        if (Fields[valueIndex].isNum == true )//Number
        {
            valueNum = 0;
            RFIDRetValue |= ReadValue( readerID, &tagInfo, tagMemory, valueIndex, &valueNum );

            if(RFIDRetValue != SUCCESS)
            {
                RFIDRetValue = SUCCESS;
                delayms(5);
                RFIDRetValue |= ReadValue( readerID, &tagInfo, tagMemory, valueIndex, &valueNum );//try again
            }
            if(RFIDRetValue != SUCCESS)
            {
                RFIDRetValue = SUCCESS;
                delayms(5);
                RFIDRetValue |= ReadValue( readerID, &tagInfo, tagMemory, valueIndex, &valueNum );//try again
            }

            Word2Bytes.Word = valueNum;

            if(Fields[valueIndex].fieldLength == 1)
            {
                NFC_Tag_R[readerID].Buf[BufferIndex] = Word2Bytes.Byte[0];
                BufferIndex+=1;
            }
            else if(Fields[valueIndex].fieldLength == 2)
            {
                for ( i = 0; i < 2; i++)
                {
                    NFC_Tag_R[readerID].Buf[BufferIndex+i] = Word2Bytes.Byte[i];
                }
                BufferIndex+=2;
            }
            else if(Fields[valueIndex].fieldLength == 4)
            {
                for ( i = 0; i < 4; i++)
                {
                    NFC_Tag_R[readerID].Buf[BufferIndex+i] = Word2Bytes.Byte[i];
                }
                BufferIndex+=4;
            }
        }
        else// ASCI text
        {
            RFIDRetValue |= ReadValue( readerID, &tagInfo, value, valueIndex, &dummy );

            if(RFIDRetValue != SUCCESS)
            {
                RFIDRetValue = SUCCESS;
                delayms(5);
                RFIDRetValue |= ReadValue( readerID, &tagInfo, value, valueIndex, &dummy );//try again
            }
            if(RFIDRetValue != SUCCESS)
            {
                RFIDRetValue = SUCCESS;
                delayms(5);
                RFIDRetValue |= ReadValue( readerID, &tagInfo, value, valueIndex, &dummy );//try again
            }

            for ( i = 0; i < Fields[valueIndex].fieldLength; i++)
            {
                    NFC_Tag_R[readerID].Buf[BufferIndex] = value[i];
                    BufferIndex+=1;
            }
        }
    }

    return RFIDRetValue;
}

//--------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------

RFID_RETURN_CODE  TagReadData()
{
    uint32_t dummy = 0;
    RFID_RETURN_CODE RFIDRetValue;

    RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1);

    RFIDRetValue = ReadValue( readerID, &tagInfo, NFC_Tag_R[readerID].Struct.Serial, 0, &dummy );
    return RFIDRetValue;
}

RFID_RETURN_CODE  WriteWCounter(RFID_READER_ID readerID)
{
    RFID_RETURN_CODE RFIDRetValue = SUCCESS;

    RFIDRetValue = incrementCounter( readerID, &tagInfo);//every time updating data

    return RFIDRetValue;
}

RFID_RETURN_CODE  WriteCRCValue(RFID_READER_ID readerID)
{
    uint32_t Tuint32 = 0;
    uint8_t tagMemory[256];
    RFID_RETURN_CODE RFIDRetValue = SUCCESS;

    //RFIDRetValue = incrementCounter( readerID, &tagInfo);//every time updating data

    //crc_ccitt_init();
    NFC_Tag_U[readerID].Struct.Checksum_CRC16 =  crc_ccitt_update(NFC_Tag_U[readerID].Buf,(sizeof(NFC_Tag_U[readerID].Buf) - sizeof(NFC_Tag_U[readerID].Struct.Checksum_CRC16)));//calculate the crc without tag id and without crc fields
    Tuint32 = NFC_Tag_U[readerID].Struct.Checksum_CRC16;
    RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 31, Tuint32 );

    return RFIDRetValue;
}

bool NFC_Check_CRC(RFID_READER_ID readerID)//after reading all data from tag
{
    bool status = ERROR;
    uint32_t CRC;

    //crc_ccitt_init();
    CRC = crc_ccitt_update(NFC_Tag_R[readerID].Buf,(sizeof(NFC_Tag_R[readerID].Buf) - sizeof(NFC_Tag_R[readerID].Struct.Checksum_CRC16)));

    if(NFC_Tag_R[readerID].Struct.Checksum_CRC16 == CRC)
    {
        status =  OK;
    }

    return status;

}
uint8_t counterd_dis = 0;

bool follow_stages[MAX_TAG_State_Machine] = {ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR};
uint32_t RFIDTagComm_StateMachine(RFID_READER_ID readerID, StateMachineMode Mode)
{
    uint32_t Status = OK;
    RFID_RETURN_CODE RFIDRetValue;
    //RFID_READER_ID readerID = (RFID_READER_ID)(Active_RFID_Reader -1);
    uint8_t i = 0;
    //uint8_t ReadingCounter;
    int RetValue = 0;


    switch(TagStage[readerID])
    {
        case Tag_Idle:
        //Tag Not Active
            follow_stages[TagStage[readerID]] = OK;
        break;
        case Tag_PrepareForDiscovery:



                RFIDRetValue = RFID_StartDiscovery(readerID);

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.ReaderPreDiscovery = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_Indetification;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.ReaderPreDiscovery = S_FAILED;

                }

                delayms(1);
                if(Mode == OneStep)
                {
                    break;
                }
        case Tag_Indetification:



                //RFIDRetValue = RFID_WaitForDiscoveryNotification(readerID, &tagInfo);
                do
                {
                    RFIDRetValue = RFID_WaitForDiscoveryNotification(readerID, &tagInfo);
                    delayms(100);
                    counterd_dis++;



                }while((RFIDRetValue != SUCCESS)&&(counterd_dis<10));

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagDiscovery = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_GetUid;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagDiscovery = S_FAILED;
                    TagStage[readerID] = Tag_Idle;
                }
                delayms(1);
                if(Mode == OneStep)
                {
                    break;
                }
        case Tag_GetUid:
                RFIDRetValue = getUID( readerID, &tagInfo, uid );

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagGetUID = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_WriteValue;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagGetUID = S_FAILED;
                    //while(1);
                }

//                memset(NFC_Tag_R[readerID].Buf,0,sizeof(NFCTag_t));
//
//                for(i=0;i<8;i++)//Copy UID
//                {
//                    NFC_Tag_R[readerID].Struct.tagId[i]  = tagInfo.Info.NFC_VPP.ID[i];
//                }
                delayms(1);

                if(Mode == OneStep)
                {
                    break;
                }
/*        case Tag_CheckPwd:
        break;
        */

/*        case Tag_InvalidLock:
        break;*/

#ifndef RFID_READ_ONLY
        case Tag_WriteValue:

                RFIDRetValue = TagWriteData(readerID);

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagwriteData = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_ReadValue;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagwriteData = S_FAILED;
                    while(1);
                }
                delayms(1);

                if(Mode == OneStep)
                {
                    break;
                }
#endif
        case Tag_ReadValue:

                //RFIDRetValue = Read_Tag_All_Data();//TagReadData();

            //
           /* ReadingCounter = 0;
            do
            {
                RFIDRetValue = Read_Tag_All_Data();
                ReadingCounter++;
            }
            while ((NFC_Check_CRC() == ERROR) && (ReadingCounter < 1));//if the crc is wrong read the tag again (max 3 times)

            if(NFC_Check_CRC() == ERROR)
            {
                while(true);
            }*/

            RFIDRetValue = Read_Tag_All_Data();


            //

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagReadData = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_CheckUpdateBlocked;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagReadData = S_FAILED;
                }
                delayms(1);

                for(i = 0; i < sizeof(NFCTag_t); i++)
                {
                    NFC_Tag_U[readerID].Buf[i] = NFC_Tag_R[readerID].Buf[i];
                }

                if(Mode == OneStep)
                {
                    break;
                }
        case Tag_CheckCRC:
            if(NFC_Check_CRC(readerID) != OK)
            {
                RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_FAILED;
            }
            else
            {
                RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_SUCCEEDED;
            }
            if(Mode == OneStep)
            {
                break;
            }
        case Tag_CheckUpdateBlocked:

                RFIDRetValue = IsTagBlocked(readerID);//check blocked bit

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TAgCheckBlockedField = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_CheckHashValue;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TAgCheckBlockedField = S_FAILED;
                }
                #warning Add here blacklist functionality
                //check black list
                // update block bit + checsum  + block field for changing
                delayms(1);

                if(Mode == OneStep)
                {
                    break;
                }
        case Tag_CheckHashValue:
             RetValue = checkHashValue( readerID, &tagInfo);

             if(RetValue == 1)
             {
                 follow_stages[TagStage[readerID]] = OK;
                 RFID_Status_Words[readerID].errors.TagCheckHash = S_SUCCEEDED;
                 if(Mode == Auto)
                     TagStage[readerID] = Tag_CheckValidity;
             }
             else
             {
                 follow_stages[TagStage[readerID]] = ERROR;
                 RFID_Status_Words[readerID].errors.TagCheckHash = S_FAILED;
                 //while(1);
             }
             delayms(1);

             if(Mode == OneStep)
             {
                 break;
             }
        case Tag_CheckValidity:

                RFIDRetValue = IsTagValid(readerID);

                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagCheckValidity = S_SUCCEEDED;
                    if(Mode == Auto)
                        TagStage[readerID] = Tag_CheckUpdateCounter;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagCheckValidity = S_FAILED;
                    //while(1);
                }
                delayms(1);

                if(Mode == OneStep)
                {
                    break;
                }
#ifndef RFID_READ_ONLY
        case Tag_CheckUpdateCounter:
            RetValue = incrementCounterAndCompare( readerID, &tagInfo);

            if(RetValue == 1)
            {
                follow_stages[TagStage[readerID]] = OK;
                RFID_Status_Words[readerID].errors.TagCheckCounterLimit = S_SUCCEEDED;
                RFID_Status_Words[readerID].errors.TagUpdateCounters = S_SUCCEEDED;
                if(Mode == Auto)
                    TagStage[readerID] = Tag_UpdateCheckSum;
            }
            else if(RetValue == -1)
            {
                follow_stages[TagStage[readerID]] = ERROR;
                RFID_Status_Words[readerID].errors.TagCheckCounterLimit = S_FAILED;
            }
            else if(RetValue == -2)
            {
                follow_stages[TagStage[readerID]] = ERROR;
                RFID_Status_Words[readerID].errors.TagUpdateCounters = S_FAILED;
            }

            delayms(1);

        if(Mode == OneStep)
        {
            break;
        }
        case Tag_UpdateWCounter:

                RFIDRetValue = WriteWCounter(readerID);
                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagUpdateWriteCounter = S_SUCCEEDED;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagUpdateWriteCounter = S_FAILED;
                }
            break;

        case Tag_UpdateCRC:
/*
                RFIDRetValue = WriteCRCValue(readerID);
                if(RFIDRetValue == SUCCESS)
                {
                    follow_stages[TagStage[readerID]] = OK;
                    RFID_Status_Words[readerID].errors.TagUpdateCRC = S_SUCCEEDED;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagUpdateCRC = S_FAILED;
                }
            break;

            */
        case Tag_UpdateCheckSum://after updating the counter

            RFIDRetValue = WriteCRCValue(readerID);
            if(RFIDRetValue == SUCCESS)
            {
                follow_stages[TagStage[readerID]] = OK;
                RFID_Status_Words[readerID].errors.TagUpdateCRC = S_SUCCEEDED;
                if(Mode == Auto)
                    TagStage[readerID] = Tag_DisconnectComm;
            }
            else
            {
                follow_stages[TagStage[readerID]] = ERROR;
                RFID_Status_Words[readerID].errors.TagUpdateCRC = S_FAILED;
                //while(1);  /---------------------------------------------------------------------------------------------- ERROR
            }

            if(Mode == OneStep)
            {
                break;
            }
#endif
        case Tag_DisconnectComm:

                RFIDRetValue = RFID_StopDiscovery(readerID);

                if(RFIDRetValue == SUCCESS)
                {
                    TagStage[readerID] = Tag_Idle;
                    RFID_Status_Words[readerID].errors.TagDisconnect = S_SUCCEEDED;
                }
                else
                {
                    follow_stages[TagStage[readerID]] = ERROR;
                    RFID_Status_Words[readerID].errors.TagDisconnect = S_FAILED;
                    //while(1);  /---------------------------------------------------------------------------------------------- ERROR
                }

        break;
        default:
        break;
    }

    Status |= RFID_Print_Errors(readerID, RFIDRetValue);

    return Status;
}

/*
//-------------------------------------------------------------------------------
//every 1 sec

void RFIDCycleEvery1Sec()
{
    static RFID_READER_ID readerID;
    static bool FirstTime = true;

    for(readerID = READER_1; readerID < Max_Readers ; readerID++)
    {
        Active_RFID_Reader = readerID + 1;

        if (    (Is_Cartridge_Present(Active_RFID_Reader) == true)               &&
                (RFID_Status_Words[readerID].errors.ReaderInit   == S_SUCCEEDED) &&
                ( (FirstTime                     == true) ||
                  (RequestForDiscovery[readerID] == true)
                )
            )
        {
            if(RFID_Status_Words[readerID].errors.TagDiscovery   == S_SUCCEEDED)
            {
                FirstTime = false;
            }
            else
            {
                Trigger_RFID_TestTask(readerID);
            }

//            if(RFID_Status_Words[readerID].errors.TagDiscovery != S_SUCCEEDED)
//            {
//                DiscoverRFIDTagEvery100mSec[readerID] = true;
//                RFID_Discovery_TimeOut[readerID] = RFID_Discovery_TimeOut_Limit;
//            }
//            else if(TagStage[readerID] < Tag_DisconnectComm)
//            {
//                DiscoverRFIDTagEvery100mSec[readerID] = true;
//            }
//
        }
//        else if(Is_Cartridge_Present(Active_RFID_Reader) == false)
//        {
//            //Initial values
//            RFID_Status_Words[readerID].uint  &= 0x000F;//Reset status except ReaderAvailability  + ReaderInit
//            FirstTime = true;
//            RequestForDiscovery[readerID] = false;
//            DiscoverRFIDTagEvery100mSec[readerID] = false;
//        }
        else if (RFID_Status_Words[readerID].errors.TagDisconnect   == S_SUCCEEDED)
            {
                FirstTime = false;
            }

    }
//    FirstTime = false;
}
//---------------------------------------------------------------------------------
//every 100 m sec

void RFIDCallEvery100mSec(RFID_READER_ID readerID)
{
    if ((RFID_Status_Words[readerID].errors.TagDiscovery != S_SUCCEEDED) && (RFID_Discovery_TimeOut[readerID] > 0))
    {
        if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery != S_SUCCEEDED)
        {
            //call ReaderPreDiscovery[i]
            TagStage[readerID] = Tag_PrepareForDiscovery;
        }
        else
        {
            //call TagDiscovery[i]
            TagStage[readerID] = Tag_Indetification;
        }
        RFIDTagComm_StateMachine(readerID, OneStep);
        RFID_Discovery_TimeOut[readerID]--;
    }
    else if( (RFID_Discovery_TimeOut[readerID] == 0) && (RFID_Status_Words[readerID].errors.TagDiscovery != S_SUCCEEDED) )
    {
        //RFID_Discovery_TimeOut error
        DiscoverRFIDTagEvery100mSec[readerID] = false;
    }
    else if ((RFID_Status_Words[readerID].errors.TagDiscovery == S_SUCCEEDED) && (TagStage[readerID] < Tag_DisconnectComm))
    {
        DiscoverRFIDTagEvery100mSec[readerID] = false;
        TagStage[readerID]  = Tag_GetUid;
        //if(TagStage[readerID] < Tag_DisconnectComm)
        //    TagStage[readerID]++;
        RFIDTagComm_StateMachine(readerID, Auto);
    }
    else
    {
        DiscoverRFIDTagEvery100mSec[readerID] = false;
    }
}
//------------------------------------------------------------
*/

//-------------------------------------------------------------------------------
//every 1 sec

void RFIDCycleEvery1Sec()
{
    static RFID_READER_ID readerID;
    //static bool FirstTime = true;

    if(Is_AnyCartridge_presence() == true)//at least one is presence
    {
        for(readerID = READER_1; readerID < Max_Readers ; readerID++)
        {
            Active_RFID_Reader = readerID + 1;

            if (    (Is_Cartridge_Present(Active_RFID_Reader) == true)               &&
                    (RFID_Status_Words[readerID].errors.ReaderInit   == S_SUCCEEDED)
                )
            {
                //if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery   != S_SUCCEEDED)
                if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery   == S_NA)
                {
                    DiscoverRFIDTagEvery100mSec[readerID] = false;
                    Trigger_RFID_Prepare(readerID);//Send Commnd to start discovery
                    //Trigger_RFID_TestTask(readerID);
                }
                else if(RFID_Status_Words[readerID].errors.ReaderPreDiscovery   == S_FAILED)
                {
                    //IFS Error - Reader error!!!
                }
                else // S_SUCCEEDED - recieve the start discovery command
                {
                    if(RFID_Status_Words[readerID].errors.TagDiscovery   == S_NA)
                    {
                        Trigger_RFID_Discovery(readerID);//check if discovery
                    }
                    else if(RFID_Status_Words[readerID].errors.TagDiscovery   == S_FAILED)
                    {
                        //didn't find tag yet - TBD - Tag error after X cycles !!!!
                    }
                    else // S_SUCCEEDED
                    {
                        DiscoverRFIDTagEvery100mSec[readerID] = true;
                    }
                }
            }
            else
            {
                if(RFID_Status_Words[readerID].errors.ReaderInit   == S_FAILED)
                {
                    //IFS Error - Reader error!!!
                }
                else
                if(Is_Cartridge_Present(Active_RFID_Reader) == false)
                {
                    //Initial values
                    RFID_Status_Words[readerID].uint64bit  &= 0x000F;//Reset status except ReaderAvailability  + ReaderInit
                    DiscoverRFIDTagEvery100mSec[readerID] = false;
                }
            }
        }
    }
}
//---------------------------------------------------------------------------------
//every 100 m sec


void RFIDCallEvery100mSec(RFID_READER_ID readerID)
{
    static uint16_t Offset = 0;
    STATUS_ENUM Status = 0;

    if (Is_Cartridge_Present(Active_RFID_Reader) == true)
    {
        Status = (RFID_Status_Words[readerID].uint64bit & (0x0300 << Offset))>>(8 + Offset);

        switch(Status)
        {
            case S_NA:
                switch (Offset)
                {
                    case 0x00:
                            Trigger_RFID_GetUid(readerID);
                        break;
                    case 0x02:
                        #ifdef RFID_NOTUSE_PASSWORD
                            RFID_Status_Words[readerID].errors.TagCheckPassword = S_NOTINUSE;
                        #else
                            Trigger_RFID_GetPassword(readerID);
                        #endif
                        break;
                    case 0x04:
                            Trigger_RFID_ReadData(readerID);
                        break;
                    case 0x06:
                        #ifdef RFID_NOTUSE_CRC
                            RFID_Status_Words[readerID].errors.TAgCheckDataCRC = S_NOTINUSE;
                        #else
                            Trigger_RFID_CheckCRC(readerID);
                        #endif
                        break;
                    case 0x08:
                        #ifdef  RFID_NOTUSE_HASHTABLE
                            RFID_Status_Words[readerID].errors.TagCheckHash = S_NOTINUSE;
                        #else
                            Trigger_RFID_CheckHash(readerID);
                        #endif
                        break;
                    case 0x0A:
                            #ifdef RFID_NOTUSE_VALIDITY
                                RFID_Status_Words[readerID].errors.TagCheckValidity = S_NOTINUSE;
                            #else
                                Trigger_RFID_CheckValid(readerID);
                            #endif
                        break;
                    case 0x0C:
                        #ifdef RFID_NOTUSE_COUNTER
                            RFID_Status_Words[readerID].errors.TagCounterLimit = S_NOTINUSE;
                        #else

                            #ifdef RFID_FORCE_READER2
                                RFID_Check_EOL_Date();
                            #endif

                            if(readerID != READER_1)
                            {
                                RFID_Update_Waste_Filled_Date(readerID);
                            }
                            else if(readerID == READER_1)
                            {
                                RFID_Check_EOL_Date();
                            }
                            Trigger_RFID_CheckCounter(readerID);
                        #endif
                        break;
                    case 0x0E:
                        #ifdef RFID_NOTUSE_BLACKLIST
                            RFID_Status_Words[readerID].errors.TAgCheckBlockedField = S_NOTINUSE;
                        #else
                            Trigger_RFID_CheckBlockedField(readerID);
                        #endif
                        break;
                    case 0x10:
                        //Trigger_RFID..
                        break;
                    case 0x12:
                        //Trigger_RFID..
                    break;

                    default:
                    break;

                }

            break;
            case S_FAILED:
            case 2:
                    //Tag Error;
                break;
            case S_SUCCEEDED:
            case S_NOTINUSE:
            case 3:
                    if(Offset < 0xC0000000)
                        Offset = Offset + 2;
                break;
        }
    }
    else
    {
        DiscoverRFIDTagEvery100mSec[readerID] = false;
    }


}

/*
void RFIDCallEvery100mSec(RFID_READER_ID readerID)
{
    if (Is_Cartridge_Present(Active_RFID_Reader) == true)
    {
                if(RFID_Status_Words[readerID].errors.TagGetUID   == S_NA)
                {
                    Trigger_RFID_GetUid(readerID);
                }
                else if(RFID_Status_Words[readerID].errors.TagGetUID   == S_FAILED)
                {
                    //Tag error!!!
                }
                else // S_SUCCEEDED
                {
                    if(RFID_Status_Words[readerID].errors.TagReadData   == S_NA)
                    {
                        Trigger_RFID_ReadData(readerID);// + CRC
                    }
                    else if(RFID_Status_Words[readerID].errors.TagReadData   == S_FAILED)
                    {
                        //Tag error!!!
                    }
                    else // TagReadData S_SUCCEEDED
                    {
                        #ifdef RFID_NOTUSE_CRC
                            RFID_Status_Words[readerID].errors.TAgCheckDataCRC =  S_NOTINUSE;
                        #endif

                        if((RFID_Status_Words[readerID].errors.TAgCheckDataCRC   == S_SUCCEEDED) || (RFID_Status_Words[readerID].errors.TAgCheckDataCRC   == S_NOTINUSE))
                        {
                            if(RFID_Status_Words[readerID].errors.TagCheckHash   == S_NA)
                            {
                                Trigger_RFID_CheckHash(readerID);
                            }
                            else if(RFID_Status_Words[readerID].errors.TagCheckHash   == S_FAILED)
                            {
                                //Tag error!!!
                            }
                            else // S_SUCCEEDED
                            {
                                DiscoverRFIDTagEvery100mSec[readerID] = false; // temporaray - move to the next stage
                            }
                        }
                        else
                        {
                            //Tag error!!!
                        }
                    }
                }
    }
    else
    {
        DiscoverRFIDTagEvery100mSec[readerID] = false;
    }

}
*/
//------------------------------------------------------------

void UpdateWCounterCRC(RFID_READER_ID readerID)//Call after any change in the tag  - to call from WriteValue function
{
    Trigger_RFID_UpdateWCounter(readerID);//Counts writes to the tag (not include this counter and CRC)
    Trigger_RFID_UpdateCRC(readerID);
}