Programme pour communiquer avec le RFID

Dependencies:   mbed

Fork of CRIC_RFID by Anthony Goncalves

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "main.hpp"
00003 
00004 //------------------------ MAIN ------------------------
00005 bool infosDebug = false;
00006 bool readOrWriteMode = READ_MODE;
00007 DigitalOut myled(LED1);
00008 Serial debugPC(USBTX, USBRX);   // tx, rx   //Communication pour le debug entre le PC et le mbed
00009 
00010 //------------------------ RFID ------------------------
00011 //Variables globales
00012 struct DonneesTag structDonneesTag;
00013 struct DataTrame strucTrameRx;
00014 Serial comRFID(p13, p14);       // tx, rx   //Communication entre le mbed et le RFID SM130
00015 volatile bool frameRxComplete = false;
00016 
00017 
00018 //Main
00019 int main() {
00020     //Initialisation
00021     //debugPC.baud(19200);
00022     comRFID.baud(19200);
00023     comRFID.attach(&RxFrameInterrupt);
00024     
00025     debugPC.printf("\n\n\n\rAttente 2 secondes...");
00026     wait(2);    //Attente démarrage du mbed
00027     debugPC.printf("\n\rHello World!\n");
00028     
00029     while(1) {
00030         RFID_Module();
00031         //flashingLED();
00032     }
00033 }
00034 //------------------------ MAIN ------------------------
00035 void flashingLED() {
00036     myled = 1;
00037     wait(0.2);
00038     myled = 0;
00039     wait(0.2);
00040 } 
00041 
00042 //------------------------ RFID ------------------------
00043 void RFID_Module(){
00044     unsigned char static state = SET_RESET, stateTAG = SEEK;
00045     unsigned char tabDataTx[25];
00046     unsigned int valRetour;
00047     
00048     struct InfosTag structInfosTag;
00049     
00050     switch (state){
00051         case SET_RESET :
00052             if(infosDebug == true)
00053                 debugPC.printf("\n\rCase SET_RESET");
00054             TxFrame(RESET, 0x00, tabDataTx);      
00055             //debugPC.printf("\n\r\t\t\tframeRxComplete0 = %02x", frameRxComplete);
00056             while(frameRxComplete == false);
00057             frameRxComplete = false; 
00058             //debugPC.printf("\n\r\t\t\tframeRxComplete1 = %02x \tcmd = %02x", frameRxComplete, strucTrameRx.command);
00059             if(strucTrameRx.command == FIRMWARE)  //Response for reset = command response FIRMWARE
00060                 state = SET_ANTENNA_POWER;
00061             break;
00062             
00063         case SET_ANTENNA_POWER :
00064             if(infosDebug == true)
00065                 debugPC.printf("\n\rCase SET_ANTENNA_POWER");
00066             tabDataTx[0] = ANTENNA_SWITCH_ON;
00067             TxFrame(ANTENNA_POWER, 0x01, tabDataTx); 
00068             while(frameRxComplete == false); 
00069             frameRxComplete = false;      
00070             if((strucTrameRx.command == ANTENNA_POWER) & (strucTrameRx.data[0] == ANTENNA_SWITCH_ON)){
00071                 state = READ_TAG;
00072                 stateTAG = SEEK;
00073             }
00074             break;
00075             
00076         case READ_TAG :
00077             if(infosDebug == true)
00078                 debugPC.printf("\n\rCase READ_TAG");
00079             
00080             switch (stateTAG){
00081                 case SEEK :
00082                     if(infosDebug == true)
00083                         debugPC.printf("\tSEEK");
00084                     TxFrame(SEEK_FOR_TAG, 0x00, tabDataTx);      
00085                     while(frameRxComplete == false);
00086                     frameRxComplete = false; 
00087                     if(strucTrameRx.command == SEEK_FOR_TAG){
00088                         if((strucTrameRx.length == 0x02) & (strucTrameRx.data[0] == 0x55)){
00089                             state = SET_ANTENNA_POWER;
00090                             stateTAG = SEEK;
00091                         }
00092                         else if(strucTrameRx.length == 0x06){
00093                             structInfosTag.tagType = strucTrameRx.data[0];
00094                             for(unsigned int cpt = 1; cpt < strucTrameRx.length - 1; cpt++)
00095                                 structInfosTag.serialNumber[cpt-1] = strucTrameRx.data[cpt];
00096                             stateTAG = AUTHENTI;
00097                         }
00098                     }
00099                     break;
00100                 
00101                 case AUTHENTI :
00102                     if(infosDebug == true)
00103                         debugPC.printf("\tAUTHENTI");
00104                     tabDataTx[0] = 0x01;
00105                     tabDataTx[1] = 0xFF;
00106                     TxFrame(AUTHENTICATE, 0x02, tabDataTx);             
00107                     while(frameRxComplete == false);
00108                     frameRxComplete = false; 
00109                     if(strucTrameRx.command == AUTHENTICATE){
00110                         if(strucTrameRx.data[0] == 0x4C){   //Login Successful
00111                             if(readOrWriteMode == READ_MODE)
00112                                 stateTAG = READ;
00113                             else if (readOrWriteMode == WRITE_MODE)
00114                                 stateTAG = WRITE;
00115                         }
00116                         else 
00117                             stateTAG = SEEK;
00118                     }
00119                     else 
00120                         stateTAG = SEEK;
00121                     break;
00122                 
00123                 case READ :
00124                     if(infosDebug == true)
00125                         debugPC.printf("\tREAD");
00126                     tabDataTx[0] = 0x00;
00127                     TxFrame(READ_BLOCK, 0x01, tabDataTx);             
00128                     while(frameRxComplete == false); 
00129                     frameRxComplete = false; 
00130                     if(strucTrameRx.command == READ_BLOCK){
00131                         if(strucTrameRx.length == 0x12){   //Read SUCCESS
00132                             if(infosDebug == true)
00133                                 debugPC.printf("\tSUCCESS");
00134                             //on recupere les données du tag
00135                             structDonneesTag.typeTrajet = strucTrameRx.data[0];
00136                             structDonneesTag.direction = strucTrameRx.data[1];
00137                             structDonneesTag.distance = strucTrameRx.data[2];
00138                             structDonneesTag.position = strucTrameRx.data[4];
00139                             if(infosDebug == true){
00140                                 debugPC.printf("\r\nTypeTrajet :\t%02x", strucTrameRx.data[0]);
00141                                 debugPC.printf("\r\nDirection :\t%02x", strucTrameRx.data[1]);
00142                                 debugPC.printf("\r\nDistance :\t%02x", strucTrameRx.data[2]);
00143                                 debugPC.printf("\r\nPosition :\t%02x", strucTrameRx.data[4]);
00144                             }
00145                         }
00146                         else {
00147                             if(infosDebug == true)
00148                                 debugPC.printf("\tFAIL");
00149                         }
00150                     }
00151                     stateTAG = SEEK;
00152                     break;
00153                     
00154                 case WRITE :
00155                     if(infosDebug == true)
00156                         debugPC.printf("\tWRITE");
00157                         
00158                     tabDataTx[0] = 0x01;    //TYPE DE TRAJET
00159                     tabDataTx[1] = 0x00;    //Direction
00160                     tabDataTx[2] = 0x02;    //Distance
00161                     tabDataTx[3] = 0x00;    //Reserved
00162                     tabDataTx[4] = 0x05;    //Position
00163                     tabDataTx[5] = 0x00;
00164                     tabDataTx[6] = 0x00;
00165                     tabDataTx[7] = 0x00;
00166                     tabDataTx[8] = 0x00;
00167                     tabDataTx[9] = 0x00;
00168                     tabDataTx[10] = 0x00;   //Version
00169                     tabDataTx[11] = 0x02;   //Type carte
00170                     tabDataTx[12] = 'C';
00171                     tabDataTx[13] = 'R';
00172                     tabDataTx[14] = 'I';
00173                     tabDataTx[15] = 'C';
00174                     TxFrame(WRITE_BLOCK, 0x0F, tabDataTx);             
00175                     while(frameRxComplete == false);
00176                     frameRxComplete = false; 
00177                     if(strucTrameRx.command == WRITE_BLOCK){
00178                         if(strucTrameRx.length == 0x12){   //Read SUCCESS
00179                             if(infosDebug == true)
00180                                 debugPC.printf("\tSUCCESS");
00181                             //on recupere les données du tag
00182                             structDonneesTag.typeTrajet = strucTrameRx.data[0];
00183                             structDonneesTag.direction = strucTrameRx.data[1];
00184                             structDonneesTag.distance = strucTrameRx.data[2];
00185                             structDonneesTag.position = strucTrameRx.data[4];
00186                             if(infosDebug == true){
00187                                 debugPC.printf("\r\nTypeTrajet :\t%02x", strucTrameRx.data[0]);
00188                                 debugPC.printf("\r\nDirection :\t%02x", strucTrameRx.data[1]);
00189                                 debugPC.printf("\r\nDistance :\t%02x", strucTrameRx.data[2]);
00190                                 debugPC.printf("\r\nPosition :\t%02x", strucTrameRx.data[4]);
00191                             }
00192                         }
00193                         else {
00194                             if(infosDebug == true)
00195                                 debugPC.printf("\tFAIL");
00196                         }
00197                     }
00198                     stateTAG = SEEK;
00199                     break;
00200             }
00201             break;
00202     }
00203 }
00204 
00205 void TxFrame(unsigned char command, unsigned char lengthData, unsigned char *dataTx){
00206     unsigned int cpt = 0;
00207     unsigned char csum = 0;
00208     
00209     lengthData += 1;    // +1 pour ajout taille commande
00210     csum = calcCSUM(command, lengthData, dataTx);
00211     
00212     //Affiche debug __________________________________________
00213     debugPC.printf("\n\r\tTx : ");
00214     debugPC.printf("FF ");
00215     debugPC.printf("00 ");
00216     debugPC.printf("%02x ", lengthData );                          
00217     debugPC.printf("%02x ", command);   
00218     for(cpt = 0; cpt<lengthData-1; cpt++)
00219         debugPC.printf("%02x ", *(dataTx+cpt));  
00220     debugPC.printf("%02x ", csum);  
00221     //Affiche debug __________________________________________
00222     
00223     comRFID.putc(0xFF);                         //HEADER
00224     comRFID.putc(0x00);                         //RESERVED
00225     comRFID.putc(lengthData );                  //LENGTH
00226     comRFID.putc(command);                      //COMMAND
00227     for(cpt = 0; cpt<lengthData-1; cpt++){      //DATA
00228         comRFID.putc(*(dataTx+cpt));         
00229     }
00230     comRFID.putc(csum);                         //CSUM  
00231 }
00232 
00233 unsigned int RxFrame(unsigned char *dataRx){
00234     unsigned char command, length, csumRx, csumCalc;
00235     
00236     if(infosDebug == true)
00237         debugPC.printf("\n\r\tRx : ");
00238     
00239     for(unsigned int cpt = 0; comRFID.readable() == 1; cpt++){      //Ajouter un TIMEOUT
00240         dataRx[cpt] = comRFID.getc();
00241     }
00242     
00243     command = *(dataRx + 3);
00244     length = *(dataRx + 2);
00245     csumRx = *(dataRx + 3 + length);
00246     
00247     //Verification HEADER
00248     if(*(dataRx + 0) != HEADER)
00249         return 1;
00250     
00251     //Verification RESERVED    
00252     if(*(dataRx + 1) != RESERVED)
00253         return 1;
00254       
00255     //Verification csum
00256     csumCalc = calcCSUM(command, length, (dataRx + 4));
00257     if(csumCalc != csumRx)
00258         return 1;
00259         
00260     if(infosDebug == true){
00261         for(unsigned int cpt = 0; cpt < length + 4; cpt++)
00262             debugPC.printf("%02x ", dataRx[cpt]);
00263     }
00264     return 0;
00265 }
00266 
00267 unsigned char calcCSUM(unsigned char command, unsigned char lengthData, unsigned char *valData){
00268     unsigned char csum = 0;    
00269     
00270     csum += command;
00271     csum += lengthData;
00272     for(unsigned int cpt = 0; cpt<lengthData-1; cpt++)
00273         csum += *(valData + cpt);
00274     
00275     return csum;
00276 }     
00277 
00278 void RxFrameInterrupt() {
00279     static unsigned char cptDataRxFrame = 0;    //Compteur du nombres octets recu sur la liaison
00280     static unsigned char stateRxFrame = 1;      //Variable etat permetant de valider chaque octet d'une trame recue
00281     unsigned char byteRx;
00282     
00283     byteRx = comRFID.getc();                    //Variable qui stocke chaque octet recu
00284     //debugPC.printf("\n\rINTERRUPT");
00285     
00286     switch (stateRxFrame) {
00287         case 0 :
00288             //debugPC.printf("\n\rSTATE 0 : Attente frameRxComplete = false");
00289             if(frameRxComplete == false)
00290                 stateRxFrame = 1;
00291             else
00292                 break;
00293         
00294         case 1 :
00295             //debugPC.printf("\n\rSTATE 1 : Attente header");
00296             if (byteRx == HEADER){              //Attente et vérification de la réception du HEADER
00297                 strucTrameRx.header = byteRx;   //Reception HEADER
00298                 stateRxFrame = 2;   
00299             } 
00300             break;
00301         
00302         case 2 :
00303             //debugPC.printf("\n\rSTATE 2 : Attente reserved");
00304             if (byteRx == RESERVED){
00305                 strucTrameRx.reserved = byteRx; //Reception RESERVED
00306                 stateRxFrame = 3;               //Réception et vérification du RESERVED
00307             }
00308             break;
00309         
00310         case 3 :
00311             strucTrameRx.length = byteRx;       //Reception LENGTH
00312             //debugPC.printf("\n\rSTATE 3 : Reception length : %02x", strucTrameRx.length);
00313             stateRxFrame = 4;
00314             break;
00315         
00316         case 4 :
00317             strucTrameRx.command = byteRx;      //Reception COMMAND
00318             //debugPC.printf("\n\rSTATE 4 : Reception command : %02x", strucTrameRx.command);
00319             stateRxFrame = 5;
00320             break;
00321         
00322         case 5 :
00323             if(cptDataRxFrame < strucTrameRx.length - 1){           //On teste si il y a des données à recuperer, on retire 1 pour la COMMAND
00324                 strucTrameRx.data[cptDataRxFrame] = byteRx;         //Reception DATA
00325                 //debugPC.printf("\n\rSTATE 5 : Reception data : %02x", strucTrameRx.data[cptDataRxFrame]);
00326                 cptDataRxFrame++;
00327                 break;
00328             }
00329             else{
00330                 cptDataRxFrame = 0;             //RAZ du compteur pour le prochain passage
00331                 stateRxFrame = 6;
00332                 //debugPC.printf("\n\rSTATE 5 : Reception data OK");
00333             }
00334             // Pas de break, c'est normal car il faut récuperer le csum dans l'etat 6
00335             
00336         case 6 :
00337             //debugPC.printf("\n\rSTATE 6 : Attente csum");
00338             strucTrameRx.csum = byteRx;         //Reception checksum
00339             
00340             unsigned char csumCalc = calcCSUM(strucTrameRx.command, strucTrameRx.length, (unsigned char*) strucTrameRx.data);     //Verification csum
00341             //debugPC.printf("\n\rSTATE 6 : csum = %02x et csumCalc = %02x", strucTrameRx.csum, csumCalc);
00342             if(csumCalc == strucTrameRx.csum){
00343                 //debugPC.printf("\n\rSTATE 6 : csum OK");
00344                 frameRxComplete = true;
00345                 
00346                 debugPC.printf("\n\r\tRx : ");
00347                 debugPC.printf("%02x ", strucTrameRx.header);
00348                 debugPC.printf("%02x ", strucTrameRx.reserved);
00349                 debugPC.printf("%02x ", strucTrameRx.length);
00350                 debugPC.printf("%02x ", strucTrameRx.command);
00351                 for(unsigned int cpt = 0; cpt < strucTrameRx.length-1; cpt++)
00352                     debugPC.printf("%02x ", strucTrameRx.data[cpt]);
00353                 debugPC.printf("%02x ", strucTrameRx.csum);
00354                 
00355             }
00356             //debugPC.printf("\n\rSTATE 6 : OUT");
00357             stateRxFrame = 1;
00358             break;
00359     }
00360 }
00361 
00362 /*
00363 unsigned int RxFrame(unsigned char *dataRx){
00364     unsigned char csum;
00365     
00366     //Reception HEADER
00367     if(comRFID.readable() == 1)
00368         *(dataRx + 0) = comRFID.getc();
00369     else 
00370         return 1;
00371     if(*(dataRx + 0) != 0xFF)
00372         return 1;
00373     debugPC.printf("\n\r\tRx HEADER %02x", *(dataRx + 0));
00374     
00375     //Reception RESERVED    
00376     if(comRFID.readable() == 1)
00377         *(dataRx + 1) = comRFID.getc();
00378     else 
00379         return 1;
00380     if(*(dataRx + 1) != 0x00)
00381         return 1;
00382     debugPC.printf("\n\r\tRx RESERVED %02x", *(dataRx + 1));
00383     
00384     //Reception LENGTH    
00385     if(comRFID.readable() == 1)
00386         *(dataRx + 2) = comRFID.getc();
00387     debugPC.printf("\n\r\tRx LENGTH %02x", *(dataRx + 2));
00388     
00389     //Reception COMMAND    
00390     if(comRFID.readable() == 1)
00391         *(dataRx + 3) = comRFID.getc();
00392     debugPC.printf("\n\r\tRx COMMAND %02x\n\r\tRx BOUCLE", *(dataRx + 3));
00393     
00394     //Reception DATA
00395     for(unsigned char cpt = 4; cpt<*(dataRx + 2) - 1; cpt++){
00396         if(comRFID.readable() == 1){
00397             debugPC.printf(".");
00398             *(dataRx + cpt) = comRFID.getc();
00399             debugPC.printf(" (cpt : %02x) %02x .", cpt, *(dataRx + cpt));
00400         }
00401         else {
00402             debugPC.printf("\n\r\tRx BOUCLE OUT");
00403             return 1;
00404         }
00405     }  
00406     
00407     //Reception CSUM    
00408     if(comRFID.readable() == 1)
00409         *(dataRx + 2 + *(dataRx + 2)) = comRFID.getc();
00410     debugPC.printf("\n\r\tRx CSUM %02x", *(dataRx + 2 + *(dataRx + 2)));    
00411     
00412     
00413     csum = calcCSUM(*(dataRx+0), *(dataRx+1), (dataRx + 2));
00414     debugPC.printf("\n\r\tRx VAL CALC CSUM %02x\n\r\t", csum);
00415     if(csum != *(dataRx + *(dataRx+2) + 3))
00416         return 1;
00417          
00418     //Affiche debug __________________________________________
00419     debugPC.printf("\n\rRx :\t");
00420     for(unsigned char cpt = 0; cpt<*(dataRx + 2) + 2; cpt++)
00421         debugPC.printf("%02x ", *(dataRx+cpt));   
00422     
00423     return 0;
00424 }
00425 */