Planned maintenance has been done but it did not solve the problem. So work will continue on this and a new time for trying updates will be announced asap.

Problème en lecture/écriture de badge RFID mifare classic avec Raspberry et CR038



  • Bonjour à tous,

    je travaille actuellement sur la lecture/écriture de badges RFID mifare classic et pour cela j'ai à ma disposition une Raspberry pi 4 sous raspbian et un module RFID le CR058 (les deux sont reliés en série via un ftdi usb pour convertir les niveaux en tension).

    lien module RFID CR038 :

    Pour finir je programme une application C++ via QTcreator car la lecture badge rfid fait partie d'un projet plus grand déja initié sous QTcreator.

    Pour réaliser le code, je me suis beaucoup inspiré du code arduino fourni par le constructeur :

    char button_1 = 10;  //Define pin 10 as button_1
    char button_2 = 11;  //Define pin 11 as button_2
     
    /*****MiFare commands*****/
    char LED_ON[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x07,0x01,0x01,0x07};  //Command to turn on MiFare module onboard LED
    char LED_OFF[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x07,0x01,0x00,0x06}; //Command to turn off MiFare module onboard LED
    char ANTENNA_ON[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x0C,0x01,0x01,0x0C};  //Command to turn off MiFare module onboard antenna
    char READ_DEV[] = {0xAA,0xBB,0x05,0x00,0x00,0x00,0x03,0x01,0x02};  //Command to read MiFare module device number
    char CARD_REQ[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x01,0x02,0x52,0x51};  //Command to request card type of MiFare card 
    char ANTI_COL[] = {0xAA,0xBB,0x05,0x00,0x00,0x00,0x02,02,00};  //Command for anti-collision
    char CARD_SEL[] = {0xAA,0xBB,0x09,0x00,0x00,0x00,0x03,0x02,0x00,0x00,0x00,0x00,0x00};  //Command to select specific MiFare card for access
                                                                                           //Byte 0 to byte 12 of this command is initialized with 0x00, since have to obtain the NUID of the MiFare card scanned 
                                                                                           //Byte 8 to byte 11 of this command will filled with NUID (started with the lowest byte) of the MiFare card desire to access
                                                                                           //Byte 12 of this command is checksum from byte 4 to byte 11 of this command may change for NUID different from that in this case
                                                                                           //This array will be filled during the subroutine of the get_nuid() in this program       
    char AUTHEN_SEC0[] = {0xAA,0xBB,0x0D,0x00,0x00,0x00,0x07,0x02,0x60,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x65};  //Command to authenticate Sector 0 in memory of MiFare card
    char AUTHEN_SEC1[] = {0xAA,0xBB,0x0D,0x00,0x00,0x00,0x07,0x02,0x60,0x04,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x61};  //Command to authenticate Sector 1 in memory of MiFare card
    char READ_0[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x08,0x02,0x00,0x0A};  //Command to read Block 0 (manufacturer block in Sector 0) in memory of MiFare card
    char WRITE_4[] = {0xAA,0xBB,0x16,0x00,0x00,0x00,0x09,0x02,0x04,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x0F}; //Command to write data into Block 4 (in Sector 1) in memory of MiFare card
                                                                                                                                                          //Data to be written (started with the lowest byte) is from byte 9 to 24, 
                                                                                                                                                          //total of 16 bytes data
                                                                                                                                                          //Data is 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A
                                                                                                                                                          //0x0B,0x0C,0x0D,0x0E,0x0F in this case
                                                                                                                                                          //The last checksum byte of this command may change for data to written different from 
                                                                                                                                                          //that in this case
    char READ_4[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x08,0x02,0x04,0x0E};  //Command to read data in Block 4 (in Sector 1) in memory of MiFare card
    /*****************************/
     
    unsigned char reply_buffer[26]; //Buffer to store data received from MiFare module when a certain command is sent (maximum is 26 bytes in this case)
    unsigned char NUID[4];  //Array for storing NUID of a MiFare card
    char mode = 0;  //Variable storing current mode of the program 
     
    void setup()
    {
      pinMode(button_1,INPUT);  //Configure pins button_1 & button_2 as inputs
      pinMode(button_2,INPUT); 
      digitalWrite(button_1,HIGH);  //Pull-up pins button_1 & button_2 
      digitalWrite(button_2,HIGH);  
     
      Serial.begin(19200);  //Initiallize UART serial communication with baudrate = 19200bps (default baudrate of MiFare module)
      lcd.begin(8,2);  //Initialize the lcd object created as type 2 rows x 8 column
     
      lcd.print("MiFare");  //Print welcome message "MiFare Demo" on LCD  
      lcd.setCursor(0,1);
      lcd.print("Demo");
      delay(2000);
      lcd.clear();
    }
     
    void loop()
    {
      lcd.setCursor(0,0);
      switch(mode)  
      {
         case 0:
         //Blinking of the MiFare module onboard LED in at rate of 0.5 Hertz
           lcd.print("0.LED    ");
           if(!digitalRead(button_2))
           {
               while(!digitalRead(button_2));  
               while(1)
               {
                 lcd.setCursor(0,1);
                 lcd.print("LED ON ");
                 led_on();      
                 delay(1000);  
                 lcd.setCursor(0,1);
                 lcd.print("LED OFF");
                 led_off();
                 delay(1000); 
               }
            }
            break;
     
          case 1:
          //Read the device number of MiFare module
            lcd.print("1.DEV NO"); 
            if(!digitalRead(button_2))
            {
                while(!digitalRead(button_2));
                read_dev();
                lcd.setCursor(0,1);
                lcd_to_hex(reply_buffer[10]);  //Byte 9 and byte 10 of replied bytes (started with lowest byte)contains MiFare module device number
                lcd_to_hex(reply_buffer[9]);
                while(1);
            }
            break;
     
           case 2:
           //Read the NUID of MiFare card 
             lcd.print("2.NUID    ");
             if(!digitalRead(button_2))
             {
                while(!digitalRead(button_2));
                get_nuid();  //NUID of MiFare card  is stored in NUID[] array after execution of this subroutine 
                             //There is total of 4 bytes started with the lowest byte
                lcd.setCursor(0,1);
                for(int i = 3; i>=0; i--)
                {
                   lcd_to_hex(NUID[i]);  //Print out the NUID obtained on LCD
                }
                while(1);
             }
             break;
     
           case 3:
           //Read the data stored in Block 0 in Sector 0 in memory of MiFare card 
             lcd.print("3.READ0   ");
             if(!digitalRead(button_2))
             {
                while(!digitalRead(button_2));
                read_0();
                while(1)
                {
                  //Byte 9 to byte 24  of the replied bytes contains data (started with the lowest byte) read from Block 0 in Sector 0
                  //Due to the small screen of the LCD used, the data is printed on LCD for twice. The lower 8 bytes (started with lowest byte of the lower 8 bytes) is printed at the first time
                  //While the upper 8 bytes (started with lowest byte of the upper 8 bytes)is printed at the second time.
                  lcd.clear();
                  lcd.setCursor(0,0);
                  lcd.print("0 to 7");
                  lcd.setCursor(0,1);
                  lcd.print("byte");
                  delay(2000);
                  lcd.clear();
                  lcd.setCursor(0,0);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[9+i]); 
                  }
                  lcd.setCursor(0,1);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[13+i]); 
                  }
                  delay(5000); 
                  lcd.clear();
                  lcd.setCursor(0,0);
                  lcd.print("8 to 15");
                  lcd.setCursor(0,1);
                  lcd.print("byte");
                  delay(2000);
                  lcd.clear();
                  lcd.setCursor(0,0);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[17+i]); 
                  }
                  lcd.setCursor(0,1);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[21+i]); 
                  }
                  delay(5000);
                }
             }
             break;
           case 4:
           //Write data into Block 4 in Sector 1 in memory of MiFare card 
             lcd.print("4.WRT_4 ");
             if(!digitalRead(button_2))
             {
                while(!digitalRead(button_2));
                write_4();
                lcd.setCursor(0,1);
                lcd.print("Success!");  //Print "Success" on LCD to indicate a success write
                while(1);
             }
             break;
           case 5:
           //Read the data stored in Block 4 in Sector 1 in memory of MiFare card 
             lcd.print("5.READ_4");
             if(!digitalRead(button_2))
             {
                while(!digitalRead(button_2));
                read_4();
                while(1)
                {
                  //Byte 9 to byte 24  of the replied bytes contains data (started with the lowest byte) read from Block 4 in Sector 1
                  //Due to the small screen of the LCD used, the data is printed on LCD for twice. The lower 8 bytes (started with lowest byte of the lower 8 bytes) is printed at the first time
                  //While the upper 8 bytes (started with lowest byte of the upper 8 bytes) is printed at the second time
                  lcd.clear();
                  lcd.setCursor(0,0);
                  lcd.print("0 to 7");
                  lcd.setCursor(0,1);
                  lcd.print("byte");
                  delay(2000);
                  lcd.clear();
                  lcd.setCursor(0,0);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[9+i]); 
                  }
                  lcd.setCursor(0,1);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[13+i]); 
                  }
                  delay(5000);
                  lcd.clear();
                  lcd.setCursor(0,0);
                  lcd.print("8 to 15");
                  lcd.setCursor(0,1);
                  lcd.print("byte");
                  delay(2000);
                  lcd.clear();
                  lcd.setCursor(0,0);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[17+i]); 
                  }
                  lcd.setCursor(0,1);
                  for(int i = 0; i<4; i++)
                  {
                     lcd_to_hex(reply_buffer[21+i]); 
                  }
                  delay(5000);
                }
             }
             break;
           default: break;      
      }
     
      if(!digitalRead(button_1))  //Detect the pressing down of button_1, change mode accordingly 
      {
         while(!digitalRead(button_1));
         mode++;
         if(mode > 5)  
         {
           mode = 0;
         } 
      }
    }
     
    //Turn on MiFare module LED subroutine
    void led_on(void)
    {
      for(int i = 0; i<10; i++)
      {
        Serial.write(LED_ON[i]); 
      }
     
      for(int i = 0; i<10; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      } 
    }
     
    //Turn on MiFare module LED subroutine
    void led_off(void)
    {
      for(int i = 0; i<10; i++)
      {
        Serial.write(LED_OFF[i]); 
      }
     
      for(int i = 0; i<10; i++)
      {
        while(!Serial.available());
        reply_buffer[i] = Serial.read();
      }
    }
     
    //Read MiFare device number subroutine
    void read_dev(void)
    {
      for(int i = 0; i<9; i++)
      {
        Serial.write(READ_DEV[i]); 
      }
     
      for(int i = 0; i<12; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }    
    }
     
    //Turn on antenna of MiFare module subroutine
    void antenna_on(void)
    {
      for(int i = 0; i<10; i++)
      {
        Serial.write(ANTENNA_ON[i]); 
      }
     
      for(int i = 0; i<10; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }  
    }
     
    //Request MiFare card type subroutine
    void card_req(void)
    {
      for(int i = 0; i<10; i++)
      {
        Serial.write(CARD_REQ[i]); 
      }
     
      for(int i = 0; i<12; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }   
    }
     
    //Perform Anti-Collison subroutine
    void anti_col(void)
    {
      for(int i = 0; i<9; i++)
      {
        Serial.write(ANTI_COL[i]); 
      }
     
      for(int i = 0; i<14; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      } 
     
      //Byte 9 to byte 12 of replied bytes contains NUID of the MiFare card 
      //Store them in NUID[] array
      for(int i = 0; i<4; i++)
      {
          NUID[i] = reply_buffer[9+i];
      }
    }
     
    //Select MiFare card subroutine
    void card_sel(void)
    {
      for(int i = 0; i<13; i++)
      {
        Serial.write(CARD_SEL[i]); 
      }
     
      for(int i = 0; i<11; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }   
    }
     
    //Authenticate Sector 0 in memory of MiFare card subroutine
    void authen_sec0(void)
    {
      for(int i = 0; i<17; i++)
      {
        Serial.write(AUTHEN_SEC0[i]); 
      }
     
      for(int i = 0; i<10; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }   
    }
     
    //Authenticate Sector 1 in memory of MiFare card subroutine
    void authen_sec1(void)
    {
      for(int i = 0; i<17; i++)
      {
        Serial.write(AUTHEN_SEC1[i]); 
      }
     
      for(int i = 0; i<10; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }   
    }
     
    //Read data from Block 0 (manufaturer block) in memory of MiFare card subroutine
    void read_0 (void)
    {
      get_nuid();
      card_sel();  //Select MiFare card 
      authen_sec0();  //Authenticate Sector 0 in memory of MiFare card
      for(int i = 0; i<10; i++)
      {
        Serial.write(READ_0[i]); 
      }
     
      for(int i = 0; i<26; i++)
      {
        while(!Serial.available());
        reply_buffer[i] = Serial.read(); 
      }
    }
     
    //Read data from Block 4 in memory of MiFare card subroutine
    void read_4(void)
    {
      get_nuid(); 
      card_sel();  //Select MiFare card 
      authen_sec1();  //Authenticate Sector 0 in memory of MiFare card
      for(int i = 0; i<10; i++)
      {
        Serial.write(READ_4[i]); 
      }
     
      for(int i = 0; i<26; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }  
    }
     
    //Write data into from Block 4 in memory of MiFare card subroutine
    void write_4(void)
    {
      get_nuid();
      card_sel();  //Select MiFare card 
      authen_sec1();  //Authenticate Sector 0 in memory of MiFare card
      for(int i = 0; i<26; i++)
      {
        Serial.write(WRITE_4[i]); 
      }
     
      for(int i = 0; i<10; i++)
      {
         while(!Serial.available());
         reply_buffer[i] = Serial.read();
      }   
    }
     
    //Get NUID of MiFare card subroutine
    void get_nuid(void)
    {
      unsigned char xor_temp = 0;
      antenna_on();  //On the MiFare module onboard antenna
      card_req();  //Request card type of MiFare card 
      anti_col();  //Perform anti-collision
     
      for(int i = 0; i<4; i++)  //Fill up byte 8 to byte 11 of CARD_SEL[] with NUID 
      {
         CARD_SEL[i+8] = NUID[i]; 
      }
     
      for(int i = 0; i<8; i++)  //Calculate the checksum of byte 4 to byte 11 of the CARD_SEL[] 
      {
        xor_temp ^= CARD_SEL[4+i];
      }
      CARD_SEL[12] = xor_temp; //Fill the checksum in byte 12 of CARD_SEL[]
    }
     
    //Print byte as hex numbers on LCD subroutine
    void lcd_to_hex(unsigned char byte_receive)
    {
      unsigned char byte_temp = 0;
      byte_temp = (byte_receive>>4) & 0x0F;
      lcd.print(byte_temp,HEX);
      byte_temp = byte_receive & 0x0F;
      lcd.print(byte_temp,HEX);
    }
    

    Dans les fonctions de base tels éteindre et allumer les leds fonctionnent bien ! Donc la communication fonctionne !

    j'ai écris les fonctions de la manière suivante :

    //*******************************************
    //Select MiFare card subroutine
    void card_sel(void)
    {
      QByteArray da(CARD_SEL, sizeof(CARD_SEL));
      serialRFID->write(da);
      //delay(200)
     
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception CARD_SEL :" << ba;
     
     
    }
     
    //*******************************************
    //Authenticate Sector 0 in memory of MiFare card subroutine
    void authen_sec0(void)
    {
      QByteArray da(AUTHEN_SEC0, sizeof(AUTHEN_SEC0));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception AUTHEN_SEC0 :" << ba;
     
    }
     
    //*******************************************
    //Authenticate Sector 1 in memory of MiFare card subroutine
    void authen_sec1(void)
    {
      QByteArray da(AUTHEN_SEC1, sizeof(AUTHEN_SEC1));
      serialRFID->write(da);
      //delay(200)
     
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception AUTHEN_SEC1 :" << ba;
     
     
    }
     
    //*******************************************
    //Read data from Block 0 (manufaturer block) in memory of MiFare card subroutine
    void read_0 (void)
    {
      get_nuid();
      card_sel();  //Select MiFare card
      authen_sec0();  //Authenticate Sector 0 in memory of MiFare card
     
      QByteArray da(READ_0, sizeof(READ_0));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception READ_0 :" << ba;
     
    }
    

    Et le problème que j'ai c'est que vu j'utilise la fonction QTserialport "readAll()", je n'ai aucun moyen de fixer la taille de ce que je veux récupérer et du coup je reçoit que certaines réponses à mes commandes et bien souvent pas la correspondante à ma commande. Car les commandes sont souvent envoyé rapidement à la suite (exemple: read_0 envoi 5 commandes) et du coup cela mets le bazard... et je ne reçois qu'une réponse à la dernière lecture de réponse....

    Du coup j'aimerai créer des fonctions Qt plus proches de celles utiliser par l'arduino donc en lisant et écrivant caractère par caractère....

    Y-a t'il un moyen pour lire les caractère un par un sur le port série ? existe t-il une alternatve à "readAll" ?

    Avez-vous déja utiliser un module RFID mifare sous Qt en c++ ?

    Avez-vous des idées pour résoudre mon problème ?

    Merci d'avance pour réponses !

    ps: n'hésitez à me demander des précisions si besoin ;)


  • Lifetime Qt Champion

    Bonjour et bienvenue sur devnet,

    Le fonctionnement par défauts de QSerialPort est asynchrone et là il est utilisé de manière synchrone.

    Je recommande d'aller lire les examples de QSerialPort en particulier ceux notés "blocking".



  • Bonjour et merci de ta réponse !

    j'ai essayé de mettre en place le fonctionnement synchrone avec un thread, je bataille toujours dessus mais cela me semble très compliqué pour pas grand chose....

    En effet utilisé un thread et une une manière synchrone de lecture de port série pour lire une réponse à une commande qu'on envoi de manière périodique dont on connait la taille ne devrait pas être si complexe...

    A noter: la lecture RFID avec ce module a déjà était mise en place sous Arduino et sous PIC via une simple communication série asynchrone avec une lecture des réponses caractères par caractères !

    Pour ma part je suis issue du monde de l'embarqué et la commande " ReadAll() ", qui lit tout le contenu reçu sans s'occuper ou même si le port série est dispo ou si il reçoit encore des choses me parait trop simpliste pour le coup ....

    Y'aurai pas un entre deux ? basé sur une communication asynchrone mais qui vérifie que le port série est bien dispo et que personne n'écrit dedans ?
    et si possible avec une lecture caractère par caractère...

    Je m'excuse pour mes questions mais je suis un peux neuf dans le domaine QT ;)

    après si vous avez d'autres idées pour résoudre mon problème je suis preneur !

    merci d'avance !



  • @jym92 Bonjour, je comprends tout à fait ce sentiment, quand on travaille surtout sur des "systèmes restreints", et je présume essentiellement en C ANSI, le fait d'utiliser une API C++ comme Qt peut surprendre.
    QSerialPort::readAll() est capable de savoir tout seul que je port est ouvert et que des données sont présentes.

    La base de Qt est la notion de Signals/Slots, et tout repose la dessus. C'est très important à comprendre. C'est un pli à prendre, et après tout roule (plus ou moins ;) ).

    Pour que la classe QSerialPort fonctionne, il faut laisser la possibilité de traiter les signaux en attente, on ne peut pas boucler comme une brute, c'est contraire au mode de fonctionnement de Qt tout simplement.
    Il faut "donner du temp" pour traiter les événements, par exemple avec un appel du type:

    QThread::currentThread()->eventDispatcher()->processEvents(QEventLoop::AllEvents);
    

    Est-ce que vous avez un extrait de code à monter pour nous détailler ce qui ne vas pas?



  • bonjour,

    effectivement je travaille souvent en C embarqué ou alors carrement en c#(application mobile) ...

    ok je vois donc je devrais pouvoir utilisé readAll() pour faire ce dont j'ai besoin.

    Mais repartons depuis le debut pour expliquer ce que je recherche...

    Je voudrais mettre au point un Thread RFID indépendant qui aurait pour de rôle de scanner en permanence la présence de carte RFID et de remonter leurs contenus grâce a des variables globales dans le reste du projet.
    Sur le papier ça devrait fonctionner parfaitement surtout en mode asynchrone vu le peu de chose qu'il y a à faire....

    donc voila le code de mon Thread RFID :

    /*********************************************************************
                        RFID THRED In I2C mode
    ********************************************************************/
    #include <QtGui>
    #include <string.h>
    #include "RFIDthread.h"
    #include <wiringPi.h>
    #include "global.h"
    #include <QDebug>
    #include <math.h>
    #include <iostream>
    #include <cstdint>
    #include <cstring>
    #include <stdio.h>
    #include <stdint.h>
    #include <stdbool.h>
    #include <QtSerialPort/QSerialPort>
    #include <QSerialPortInfo>
    
    #include <mainwindow.h>
    
    
    static QSerialPort* serialRFID;
    
    /***********************************************  MiFare commands  *********************************************************/
    static char INIT_BAUD[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x01,0x01,0x03,0x03}; // init command to set baud at 19200
    static char LED_ON[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x07,0x01,0x01,0x07};  //Command to turn on MiFare module onboard LED
    static char LED_OFF[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x07,0x01,0x00,0x06}; //Command to turn off MiFare module onboard LED
    static char ANTENNA_ON[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x0C,0x01,0x01,0x0C};  //Command to turn off MiFare module onboard antenna
    static char READ_DEV[] = {0xAA,0xBB,0x05,0x00,0x00,0x00,0x03,0x01,0x02};  //Command to read MiFare module device number
    static char CARD_REQ[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x01,0x02,0x52,0x51};  //Command to request card type of MiFare card
    static char ANTI_COL[] = {0xAA,0xBB,0x05,0x00,0x00,0x00,0x02,02,00};  //Command for anti-collision
    static char CARD_SEL[] = {0xAA,0xBB,0x09,0x00,0x00,0x00,0x03,0x02,0x00,0x00,0x00,0x00,0x00};  //Command to select specific MiFare card for access
                                                                                           //Byte 0 to byte 12 of this command is initialized with 0x00, since have to obtain the NUID of the MiFare card scanned
                                                                                           //Byte 8 to byte 11 of this command will filled with NUID (started with the lowest byte) of the MiFare card desire to access
                                                                                           //Byte 12 of this command is checksum from byte 4 to byte 11 of this command may change for NUID different from that in this case
                                                                                           //This array will be filled during the subroutine of the get_nuid() in this program
    //static char AUTHEN_SEC0[] = {0xAA,0xBB,0x0D,0x00,0x00,0x00,0x07,0x02,0x60,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x65};  //Command to authenticate Sector 0 in memory of MiFare card
    //static char AUTHEN_SEC1[] = {0xAA,0xBB,0x0D,0x00,0x00,0x00,0x07,0x02,0x60,0x04,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x61};  //Command to authenticate Sector 1 in memory of MiFare card
    
    static char AUTHEN_SEC0[] = {0xAA,0xBB,0x0D,0x00,0x00,0x00,0x07,0x02,0x60,0x00,0x45,0x52,0x41,0x46,0x49,0x4D,0x65};  //Command to authenticate Sector 0 in memory of MiFare card
    static char AUTHEN_SEC1[] = {0xAA,0xBB,0x0D,0x00,0x00,0x00,0x07,0x02,0x60,0x04,0x4D,0x49,0x46,0x41,0x52,0x45,0x61};
    
    static char READ_0[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x08,0x02,0x00,0x0A};  //Command to read Block 0 (manufacturer block in Sector 0) in memory of MiFare card
    static char WRITE_4[] = {0xAA,0xBB,0x16,0x00,0x00,0x00,0x09,0x02,0x04,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x0F}; //Command to write data into Block 4 (in Sector 1) in memory of MiFare card
                                                                                                                                                          //Data to be written (started with the lowest byte) is from byte 9 to 24,
                                                                                                                                                          //total of 16 bytes data
                                                                                                                                                          //Data is 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A
                                                                                                                                                          //0x0B,0x0C,0x0D,0x0E,0x0F in this case
                                                                                                                                                          //The last checksum byte of this command may change for data to written different from
                                                                                                                                                          //that in this case
    static char READ_4[] = {0xAA,0xBB,0x06,0x00,0x00,0x00,0x08,0x02,0x04,0x0E};  //Command to read data in Block 4 (in Sector 1) in memory of MiFare card
    /*************************************************************************************************************************/
    static BYTE Key_A[]={0x4D,0x49,0x46,0x41,0x52,0x45};   //MIFARE 4D4946415245  identique pour toutes les machines
    
    static unsigned char reply_buffer[26]; //Buffer to store data received from MiFare module when a certain command is sent (maximum is 26 bytes in this case)
    //static unsigned char NUID[4];  //Array for storing NUID of a MiFare card //déja déclaré en global.... à verif !
    static char mode = 0;  //Variable storing current mode of the program
    static bool Rfid_wrtitting = false;
    
    
    // pour appel clase //
    RFIDthread::RFIDthread(QObject *parent) :
        QThread(parent)
    {
    }
    RFIDthread::~RFIDthread()
    {
        m_mutex.lock();
        m_quit = true;
        m_cond.wakeOne();
        m_mutex.unlock();
        wait();
    }
    
    
    //*************************************** SETUP FOR INFORMATION TRANSACTION *********************//
    void RFIDthread::transaction(const QString &portName, int waitTimeout, const QString &request)
    {
    //! [1]
        const QMutexLocker locker(&m_mutex);
        m_portName = portName;
        m_waitTimeout = waitTimeout;
        m_request = request;
    //! [3]
        if (!isRunning())
            start();
        else
            m_cond.wakeOne();
    }
    
    
    
    
    /*******************************************************************************************************
    * *************                    ---- Main de RFIDthread ----	                  ************         *
    *******************************************************************************************************/
    void RFIDthread::run()
    {
    
        bool Rfid_justarrived = true;
        int count_rfid_abs = 0;
        qDebug() << " Init thread RFID :";
    
        //----------------------- Parametrage de la liaison serie -------------------------------------- //
        QList<QSerialPortInfo> listPsi; // liste des ports série existant
        listPsi = QSerialPortInfo::availablePorts(); // récupère les ports série disponibles
    
        serialRFID = new QSerialPort(this);
    
        // ----- INIT SERIAL RFID ----//
        serialRFID->setPortName("ttyUSB0");
        serialRFID->setBaudRate(QSerialPort::Baud19200);
        serialRFID->setDataBits(QSerialPort::Data8);
        serialRFID->setParity(QSerialPort::NoParity);
        serialRFID->setStopBits(QSerialPort::OneStop);
        serialRFID->setFlowControl(QSerialPort::NoFlowControl);
        serialRFID->open(QIODevice::ReadWrite);
    
        if (serialRFID->isOpen() == true)
        {
            qDebug() << "Serial ttyUSB0(USB0) is opened";
        }
        else
        {
            qDebug() << "Connexion impossible RFID ! ";
        }
    
        qDebug() << " Thread RFID lancé !";
    
        // boucle principale du Thread :
        while(1)
        {
            led_on();
            delay(1000);
    
            led_off();
            delay(1000);
    
            /*
            // read dev num ;
            read_dev();
            delay(1000);
    
            // read 4 ;
            read_4();
            delay(1000);
            */
        }
    }
    
    
    /************************************************************************************************************************
    ********************                     ---- FIN du Main de RFIDthread ----	                   ***********************
    **************************************************************************************************************************/
    
    //======================================================================
    //************             RFID CR038 fonctions :               ****** //
    //======================================================================
    
    
    //******************************************
    //Turn on MiFare module LED subroutine
    void led_on(void)
    {
      // on envoit tout d'un coup !
      QByteArray da(LED_ON, sizeof(LED_ON));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception LED_ON :" << ba;
    }
    
    //*******************************************
    //Turn on MiFare module LED subroutine
    void led_off(void)
    {
    
       QByteArray da(LED_OFF, sizeof(LED_OFF));
       serialRFID->write(da);
       QByteArray ba;
       //delay(200)
       while(!serialRFID->isOpen());
       ba = serialRFID->readAll();
       qDebug() << "reception LED_OFF :" << ba;
    }
    
    //*******************************************
    //Read MiFare device number subroutine
    void read_dev(void)
    {
      serialRFID->open(QIODevice::ReadWrite);
      QByteArray da(READ_DEV, sizeof(READ_DEV));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception READ_DEV :" << ba;
    }
    
    //*******************************************
    //Turn on antenna of MiFare module subroutine
    void antenna_on(void)
    {
       QByteArray da(ANTENNA_ON, sizeof(ANTENNA_ON));
       serialRFID->write(da);
       //delay(200);
    
       QByteArray ba;
       while(!serialRFID->isOpen());
       ba = serialRFID->readAll();
       qDebug() << "reception ANTENNA_ON :" << ba;
    
    
    }
    
    //*******************************************
    //Request MiFare card type subroutine
    void card_req(void)
    {
      QByteArray da(CARD_REQ, sizeof(CARD_REQ));
      serialRFID->write(da);
      //delay()200
    
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception CARD_REQ :" << ba;
    
    }
    
    //*******************************************
    //Perform Anti-Collison subroutine
    void anti_col(void)
    {
    
      QByteArray da(ANTI_COL, sizeof(ANTI_COL));
      serialRFID->write(da);
      //delay()200
    
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception ANTI_COL :" << ba;
    
      //Byte 9 to byte 12 of replied bytes contains NUID of the MiFare card
      //Store them in NUID[] array
      for(int i = 0; i<4; i++)
      {
          NUID[i] = ba[9+i];
      }
    
    }
    
    //*******************************************
    //Select MiFare card subroutine
    void card_sel(void)
    {
      QByteArray da(CARD_SEL, sizeof(CARD_SEL));
      serialRFID->write(da);
      //delay(200)
    
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception CARD_SEL :" << ba;
    
    
    }
    
    //*******************************************
    //Authenticate Sector 0 in memory of MiFare card subroutine
    void authen_sec0(void)
    {
      QByteArray da(AUTHEN_SEC0, sizeof(AUTHEN_SEC0));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception AUTHEN_SEC0 :" << ba;
    
    }
    
    //*******************************************
    //Authenticate Sector 1 in memory of MiFare card subroutine
    void authen_sec1(void)
    {
      QByteArray da(AUTHEN_SEC1, sizeof(AUTHEN_SEC1));
      serialRFID->write(da);
      //delay(200)
    
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception AUTHEN_SEC1 :" << ba;
    
    
    }
    
    //*******************************************
    //Read data from Block 0 (manufaturer block) in memory of MiFare card subroutine
    void read_0 (void)
    {
      get_nuid();
      card_sel();  //Select MiFare card
      authen_sec0();  //Authenticate Sector 0 in memory of MiFare card
    
      QByteArray da(READ_0, sizeof(READ_0));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception READ_0 :" << ba;
    
    }
    
    //*******************************************
    // init Read data  of MiFare card subroutine
    void init_read(void)
    {
      get_nuid();
      card_sel();  //Select MiFare card
    }
    
    //*******************************************
    //quick Read data from Block 4
    void read_4_quick(void)
    {
    
      authen_sec1();  //Authenticate Sector 0 in memory of MiFare card
    
      QByteArray da(READ_4, sizeof(READ_4));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception READ_4 :" << ba;
    }
    //*******************************************
    //Read data from Block 4 in memory of MiFare card subroutine
    void read_4(void)
    {
      get_nuid();
      card_sel();  //Select MiFare card
      authen_sec1();  //Authenticate Sector 0 in memory of MiFare card
    
      QByteArray da(READ_4, sizeof(READ_4));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception READ_4 :" << ba;
    }
    
    //*******************************************
    //Write data into from Block 4 in memory of MiFare card subroutine
    void write_4(void)
    {
      get_nuid();
      card_sel();  //Select MiFare card
      authen_sec1();  //Authenticate Sector 0 in memory of MiFare card
    
      QByteArray da(WRITE_4, sizeof(WRITE_4));
      serialRFID->write(da);
      //delay(200)
      QByteArray ba;
      while(!serialRFID->isOpen());
      ba = serialRFID->readAll();
      qDebug() << "reception WRITE_4 :" << ba;
    }
    
    //*******************************************
    //Get NUID of MiFare card subroutine
    void get_nuid(void)
    {
      unsigned char xor_temp = 0;
      antenna_on();  //On the MiFare module onboard antenna
      card_req();  //Request card type of MiFare card
      anti_col();  //Perform anti-collision
    
      for(int i = 0; i<4; i++)  //Fill up byte 8 to byte 11 of CARD_SEL[] with NUID
      {
         CARD_SEL[i+8] = NUID[i];
      }
      //delay(200)
      for(int i = 0; i<8; i++)  //Calculate the checksum of byte 4 to byte 11 of the CARD_SEL[]
      {
        xor_temp ^= CARD_SEL[4+i];
      }
      CARD_SEL[12] = xor_temp; //Fill the checksum in byte 12 of CARD_SEL[]
    }
    

    Cependant après avoir bataillé plusieurs jours je me suis rendu compte que pour que mon port série fonctionne je devais le déclarer et interagir depuis mon fichier mainwindow.cpp mais du coup on perdrais tout l’intérêt d'un Thread ...

    Voyez-vous une déclaration que j'aurais pu oublier dans mon Thread pour que celui-ci fonctionne de manière autonome ?
    (sans déclaration du port dans mainwindow...)

    Sinon j'ai déjà réussi à mettre au point un port série dans mainwindow pour communiquer avec un DSPIC33 de manière synchrone et cela marche très bien avec ça :

    if (serial->isOpen() == true)
        {
            qDebug() << "Serial ttyAMA2(uart5) is opened";
            connect(serial, SIGNAL(readyRead()),this,SLOT(on_Received_Data()));
        }
        else
        {
            qDebug() << "Connexion impossible PIC ! ";
        }
    

    et

    //----- for serial port !! ------
    
    // boucle activé sur reception de données serie :
    void MainWindow::on_Received_Data()
    {
        // ------- choses à faire - RX side -------
        qDebug() << "reception données :";
        QByteArray ba;
        ba = serial->readAll();
        ui->label_uart_pic->setText("Données reçues : " + ba );
        qDebug() << ba;
    
    }
        
    

    Cependant je n'arrive pas à mettre au point ce même fonctionnement dans mon Thread RFID ....

    Vous avez des Idées ?

    merci ;)



  • @jym92 Ohlala, je vois très bien le soucis... Dans Qt, il y a plusieurs règles "de base" à respecter pour éviter les ennuis, et l'une d'elle c'est de ne jamais utiliser QThread comme classe de base, mais de créer une "worker class" que l'on va faire travailler dans un thread dédié.

    Il y a plusieurs bonnes raisons à cela, et ce serait trop long a expliquer comme ça, je vous conseille d'aller lire les article suivants:

    Pour résumer, je dirais:
    a. créer une classe RfidReader qui va faire la gestion du port série / lecture du RFID
    b. créer une instance de cette classe
    c. créer une instance de QThread et "déplacé" l'instance de la worker class vers ce thread
    d. utiliser des connection signals/slots pour transférer les données du thread de travail vers le thread principal, comme ça c'est Qt qui s'occupe de faire les copies et vous éviter de devoir gérer les accès multi-thread.

    Autres règles de base pour Qt

    • ne jamais bloquer le thread principal, sinon votre IHM devient inutilisable!!
    • toutes les actions IHM/graphique doivent être exécutées dans le thread principale


  • Ok je regarde ça et j'essaye de le mettre en place !

    Oui je connais bien ces règles principales, ce sont les mêmes qu'en C# d'où pour la nécessité de faire fonctionner le RFID de manière indépendante dans son propre Thread.

    merci !



  • Bonjour @KroMignon ,

    j'ai crée la classe RFIDreader(cpp + h) dans la laquelle j'ai rangé toutes mes fonctions de base RFID telles que LedOn, LedOff, read, write....

    et j'ai fait du coup du ménage dans mon thread RFID ;)

    par contre j'ai une question, j'ai commencé à mettre en place ce qui est indiqué dans ce tuto : https://hub.packtpub.com/multithreading-qt/

    cependant j'ai plusieures questions :

    1- dans mon Thread RFID j'aurai ma déclaration de port série, les routines d’exécution RFID qui y seront appelées ainsi que ceci :

    class Thread : public QThread
    {
    Q_OBJECT
    protected:
        void run() 
        {
            Object* myObject = new Object();
            connect(myObject, &Object::started, 
                    this, &Thread::doWork);
            exec();
        }
    
    private slots:
        void doWork();
    };
    

    C'est bien ça ? (bien-sur j'adapterai les noms...)

    2- Pour ce qui est de la classe worker , je suis censé le mettre où ?
    (fichier indépendant RfidWorker(cpp+h) ou dans RFIDThread )

    class Worker : public QObject
    {
        Q_OBJECT
    public slots:
        void doWork() 
        {
            emit result("workers are the best");
        }
    
    signals:
        void result(QString data);
    };
    

    D'ailleurs cette classe worker ne sert qu'a faire le lien ou bien c'est la que je dois implémenté le déroulement de mon thread ?

    3- ça sert à quoi ça ?

    connect(thread, &QThread::finished, 
            worker, &QObject::deleteLater);
    connect(this, &MainWindow::startWork, 
            worker, &Worker::doWork);
    connect(worker, &Worker::resultReady, 
            this, handleResult);
    

    Sachant que dans mon cas, mon Thread a seulement pour role d'indiquer si un badge et son montant ... donc je pensais passer ces 2 infos au Thread principal (mainwindow) via 2 variables globales (un bool et un int)...

    merci d'avance si tu peux à toutes mes interrogations ;)



  • @jym92 Bonjour, hmm je ne sais pas si j'ai bien compris la structure que vous avez décidé d'implémenter...
    Je vais broder autour de ce que j'ai cru comprendre... désolé si je suis à côté de la plaque

    Pour moi, il suffit de créer une seule classe qui va faire la gestion du port série, la fameuse "RfidWorker".
    Cette classe va avoir un signal "newTag" et des slots "start" et "stop", quelque chose comme ça:

    class RfIdWorker : public QObject
    {
        Q_OBJECT
    
    public:
        explicit RfIdWorker (QObject * parent);
    ...
    
    public slots:
        void start();
        void stop();
    
    signals:
        void newTag(QString tagID, int tagValue);
    
    };
    

    Après pour démarrer l'utilisation du Rfid:

      auto * rfWorker = new RfIdWorker();
      auto* rfThread = new QThread();
    
      // start RF ID Reader on thread start
      connect(rfThread, &QThread::started, rfWorker , &RfIdWorker::start);
      // stop RF ID Reader on main application exit
      connect(qApp, &QApplication::aboutToQuit, rfWorker, &QObject::deleteLater);
      // delete thread on worker end
      connect(rfWorker, &QObject::destroyed, rfThread, [rfThread](QObject *) 
              {
                  if(rfThread.isRunning())
                  {
                       rfThread.quit();
                       rfThread.wait();
                  }
                  rfThread.deleteLater();
              }
              , Qt::DirectConnection);  // needs "DirectConnection" to work
    
        // to be informed about new RF ID tag
        connect(rfWorker,  &RfIdWorker::newTag, this, &MyMainClass::newRfIdTag);
        // move worker object to worker  thread
        rfWorker.moveToThread(rfThread);
        // last but not least, start worker thread
        rfThread.start();
    

    Dans le slot start, le port série est initialisé et démarré.
    Dans le slot stop; le port série est fermé.

    En gros, voici comment je ferai.



  • Ok je vois c'est déja un peu plus clair pour moi ...

    Donc j'aurai juste une classe "RFIDworker" et un thread "RFIDThread", et mes fonctions de base pour le RFID seront contenu et appelée dans la classe "RFIDworker".

    J'ai bien saisi pour l'initialisation de port série ainsi que pour l'init du thread et du Qobject qui se feront dans mainwindow.

    Cependant j'aurai besoin de mettre en place une boucle infini ou un timer me permettant de scanner en boucle si il y a un new tag...
    Je dois mettre ça en place dans la classe RFIDworker en créant un slot "onWork" qui contiendra une boucle infini qui scannera puis déclenchera le signal Newtag ?
    ou je ma boucle déclenchant newtag devrait etre dans le fichier RFIDThread ?

    désolé pour mes questions mais je suis un peu neuf avec genre de fonctionnement à cheval entre l'embarqué et la création d'application ....

    Un grand merci pour ton aide !



  • @jym92 Pour moi, il suffit de créer une classe qui sait décoder les trames de ton (c'est au moins mon 3ème message... je passe au tutoiement ;-) ) récepteur RFID.

    Je continue sur l'exemple d'avant:

    class RfIdWorker : public QObject
    {
        Q_OBJECT
    
    public:
        explicit RfIdWorker (QObject * parent);
    ...
    
    public slots:
        void start();
        void stop();
    
    private slots:
       void checkRFID();
    
    signals:
        void newTag(QString tagID, int tagValue);
    
    private:
        QSerialPort *m_serial;
    };
    

    Et du côté C++

    RfIdWorker:RfIdWorker (QObject *parent): QObject(parent), m_serial(Q_NULLPTR)
    {
    }
    
    void RfIdWorker::start()
    {
        if(!m_serial)
        {
            m_serial = new QSerialPort(this);
            // serial port initialistion
            ...
            connect(m_serial, &QSerialPort::readyRead, this, &RfIdWorker::checkRFID);
        }
        m_serial.open();
    }
    
    void RfIdWorker::stop()
    {
        if(m_serial && m_serial.isOpen())
        {
            m_serial.close();
        }
    }
    
    void RfIdWorker::checkRFID()
    {
        while(!m_serial->atEnd())
        {
            QByteArray rfIdRaw = m_serial->readAll();
            // process data
            ...
            if(!tag.isEmpty())
                emit newTag(tag, value);
        }
    }
    

    Ce n'est qu'un squelette, mais ça donne une idée de l'architecture



  • Oui tu fais bien d'utiliser le tutoiement au vu de ton implication ;)

    Ok je vois à peu près le squelette, j'essaye de mettre tout ça en place et je reviens vers toi !

    merci



  • Alors il me semble avoir bien suivi tes consignes, le Thread se lance puis le worker et tout semble bien tourner au vu du debug ...
    Cependant comme auparavant il semblerait que lorsque j'essaye d'envoyer des commandes par le port série rien ne se passe(une led sur mon ftdi devrait indiquer l'émission de données).

    Je ne comprends pas pourquoi mon worker ne pourrait pas interagir avec mon port série "ttyusb0"...

    voici ce que j'ai fait :

    RFIDThread.cpp:

    /*********************************************************************
                        RFID THRED In I2C mode
    ********************************************************************/
    #include <QtGui>
    #include "RFIDthread.h"
    #include "global.h"
    #include <QDebug>
    #include <mainwindow.h>
    #include "RFIDworker.h"
    
    //static unsigned char NUID[4];  //Array for storing NUID of a MiFare card //déja déclaré en global.... à verif !
    static char mode = 0;  //Variable storing current mode of the program
    static bool Rfid_wrtitting = false;
    
    
    // pour appel clase //
    RFIDthread::RFIDthread(QObject *parent) :
        QThread(parent)
    {
    }
    
    /*******************************************************************************************************
    * *************                    ---- Main de RFIDthread ----	                  ************         *
    *******************************************************************************************************/
    void RFIDthread::run()
    {
    
        qDebug() << " Thread RFID lancé !";
    
    }
    
    
    /************************************************************************************************************************
    ********************                     ---- FIN du Main de RFIDthread ----	                   ***********************
    **************************************************************************************************************************/
    

    Pour ce qui est RFIDworker :

    
    static QSerialPort *serialRFID;
    
    //RFIDworker :: RFIDworker (QObject *parent): QObject(parent), serialRFID(Q_NULLPTR)
    RFIDworker::RFIDworker(QObject *parent): QObject(parent)
    {
    }
    
    void RFIDworker::start()
    {
        if(!serialRFID)
        {
            serialRFID = new QSerialPort(this);
            // serial port initialistion
            // ----- INIT SERIAL RFID ----//
            serialRFID->setPortName("ttyUSB0");
            serialRFID->setBaudRate(QSerialPort::Baud19200);
            serialRFID->setDataBits(QSerialPort::Data8);
            serialRFID->setParity(QSerialPort::NoParity);
            serialRFID->setStopBits(QSerialPort::OneStop);
            serialRFID->setFlowControl(QSerialPort::NoFlowControl);
            serialRFID->open(QIODevice::ReadWrite);
    
            connect(serialRFID, &QSerialPort::readyRead, this, &RFIDworker::checkRFID);
    
            if (serialRFID->isOpen() == true)
            {
                qDebug() << "Serial ttyUSB0(USB0) is opened";
            }
            else
            {
                qDebug() << "Connexion impossible RFID ! ";
            }
    
            // lancement de la routine recherche badge
            checkRFID();
        }
    }
    
    void RFIDworker::stop()
    {
        if(serialRFID && serialRFID->isOpen())
        {
            serialRFID->close();
        }
    }
    
    void RFIDworker::checkRFID()
    {
        while(1)
        {
            led_on();
            delay(400);
            led_off();
            delay(400);
    
        }
    }
    
    

    et enfin voila comment je démarre le tout dans mainwindow :

    // ------------ Lancement du Thread RFID et du worker lié -----------------//
        auto* rfWorker = new RFIDworker();
        auto* rfThread = new RFIDthread();
    
        // start RF ID Reader on thread start
        connect(rfThread, &QThread::started, rfWorker , &RFIDworker::start);
        // stop RF ID Reader on main application exit
        connect(qApp, &QApplication::aboutToQuit, rfWorker, &QObject::deleteLater);
        // delete thread on worker end
        connect(rfWorker, &QObject::destroyed, rfThread, [rfThread](QObject *)
        {
            if(rfThread->isRunning())
            {
                 rfThread->quit();
                 rfThread->wait();
            }
            rfThread->deleteLater();
        }
        , Qt::DirectConnection);  // needs "DirectConnection" to work
        // to be informed about new RF ID tag
        //connect(rfWorker,  &RFIDworker::newTag, this, &MyMainClass::newRfIdTag);
        // move worker object to worker  thread
        rfWorker->moveToThread(rfThread);
        // last but not least, start worker thread
        rfThread->start();
    

    remarque : ce morceau de code est situé dans le init de mainwindow.cpp.

    Enfin j'ai également noté que le fait de déclarer un second port série dans un Thread différent semble brouiller mon premier port série lorsque celui-ci essaye d’émettre des données, il croit voir une réponse (il s'agit du port série réserver au PIC et les fils sont en l'air ...).

    Une idée pour que je puisse interagir avec le port série depuis mon worker ?

    Une idée d'ou peut venir le conflit entre les 2 ports séries ?

    merci d'avance ;)


  • Lifetime Qt Champion

    La variable static QSerialPort est une mauvaise idée. Il n'y a aucune raison qu'elle soit déclarée static. Elle devrait être un membre du worker object.



  • merci de ta réponse @SGaist , je viens de le paramètre extern dans mon fichier global avec :

    //global.h
    extern QSerialPort* serialRFID;
    extern QSerialPort* serial;
    
    //global.cpp
    QSerialPort* serial;
    QSerialPort* serialRFID;
    

    Mais cela ne change rien, j'ai pas de réaction sur le port série ....

    Comment je peux ajouter mon port série à Qserialport serialRFID à mon worker object ?



  • @jym92 Comme l'a déjà souligné @SGaist, l'utilisation de la variables statiques est en générale une très mauvaise idée en C++. A moins de vouloir partager une variable entre plusieurs instances de cette classe, mais c'est un cas d'usage très particulier.

    Encore une fois, il n'est pas utile de créer une classe dérivée de QThread!. De plus, je fait de faire une propre implémentation du slot run() fait en sorte de ne pas créer, ni démarrer une EventQueue pour ce thread, donc le mécanisme de signals/slots de Qt ne fonctionnera pas avec ce thread!

    Après, à quoi sert RFIDworker::checkRFID()? A part bloquer le thread dans une boucle infinie ;-)
    Bref là également une très mauvaise idée, je veut dire par là, pas 'Qt Conforme'.
    Pour que le mécanisme signals/slots fonctionne, il faut une EventQueue et ne faut pas bloquer le thread dans une boucle infinie!

    Je reprends mon exemple de WorkerClass

    class RfIdWorker : public QObject
    {
        Q_OBJECT
    
    public:
        explicit RfIdWorker (QObject * parent);
    ...
    
    public slots:
        void start();
        void stop();
    
    private slots:
       void checkRFID();
        void ledTimer();
    
    signals:
        void newTag(QString tagID, int tagValue);
    
    private:
        QSerialPort *m_serial;
        QTimer *m_timer;
        bool m_ledState;
    };
    

    Pour le C++:

    RfIdWorker:RfIdWorker (QObject *parent)
        : QObject(parent)
        , m_serial(Q_NULLPTR)
        , m_timer(Q_NULLPTR)
        , m_ledState(false)
    {
    }
    
    void RfIdWorker::start()
    {
        if(!m_ledTimer)
        {
            m_ledTimer = new QTimer(this);
            m_ledTimer->setSingleShot(false);
            m_ledTiler->setInterval(400);
            connect(m_ledTimer, &QTimer::timeout, this, &RfIdWorker::ledTimer);
        }
    
        if(!m_serial)
        {
            m_serial = new QSerialPort(this);
            // serial port initialistion
            ...
            connect(m_serial, &QSerialPort::readyRead, this, &RfIdWorker::checkRFID);
        }
        m_serial>open();
        m_ledTimer->start();
    }
    
    void RfIdWorker::stop()
    {
        if(m_serial && m_serial->isOpen())
        {
            m_serial->close();
        }
        if(m_ledTimer && m_ledTimer->isActive())
            m_ledTimer->stop();
    }
    
    void RfIdWorker::ledTimer()
    {
        if(m_ledState)
            led_on();
        else
            led_off();
        m_ledState = !m_ledState;
    }
    
    void RfIdWorker::checkRFID()
    {
        while(!m_serial->atEnd())
        {
            QByteArray rfIdRaw = m_serial->readAll();
            // process data
            ...
            if(!tag.isEmpty())
                emit newTag(tag, value);
        }
    }
    
    
    


  • Bonjour,

    Tout d'abord je vous remercie pour vos conseils et je commence à petit à petit à saisir la logique un peu tordu de Qt ;p

    J'ai du coup modifier mon worker pour passer le port serie en private à la classe et j'ai mis en place le fonctionnement via le timer au lieu de la boucle infini.

    Cependant le timer ne démarre pas alors qu'au vu des lignes de debug tout semble bien se lancer sauf le timer ...

    voici le code du worker.h :

    #ifndef RFIDworker_H
    #define RFIDworker_H
    
    #include <QObject>
    #include <QtSerialPort>
    
    
    
    class RFIDworker : public QObject
    {
        Q_OBJECT
    
    public:
        explicit RFIDworker(QObject *parent= nullptr);
    
    
    public slots:
        void start();
        void stop();
    
    private slots:
       void checkRFID();
       void ledTimer();
    
    signals:
        void newTag(QString tagID, int tagValue);
    
    private:
       QSerialPort *RFIDserial;
       QTimer *m_timer;
       bool m_ledState;
    };
    
    //======================================================================
    //************             RFID CR038 fonctions :               ****** //
    //======================================================================
    
    //*******************************************//
    //Turn on MiFare module LED subroutine
    void led_on(QSerialPort *RFIDport);
    
    //*******************************************//
    //Turn on MiFare module LED subroutine
    void led_off(QSerialPort *RFIDport);
    

    et du worker.cpp :

    RFIDworker::RFIDworker(QObject *parent): QObject(parent)
        , RFIDserial(Q_NULLPTR)
        , m_timer(Q_NULLPTR)
        , m_ledState(false)
    {
    }
    
    void RFIDworker::start()
    {
        if(!m_timer)
            {
                m_timer = new QTimer(this);
                m_timer->setSingleShot(false);
                m_timer->setInterval(400);
                connect(m_timer, &QTimer::timeout, this, &RFIDworker::ledTimer);
            }
    
        if(!RFIDserial)
        {
            RFIDserial = new QSerialPort(this);
            // serial port initialistion
            // ----- INIT SERIAL RFID ----//
            RFIDserial->setPortName("ttyUSB0");
            RFIDserial->setBaudRate(QSerialPort::Baud19200);
            RFIDserial->setDataBits(QSerialPort::Data8);
            RFIDserial->setParity(QSerialPort::NoParity);
            RFIDserial->setStopBits(QSerialPort::OneStop);
            RFIDserial->setFlowControl(QSerialPort::NoFlowControl);
            RFIDserial->open(QIODevice::ReadWrite);
    
            connect(RFIDserial, &QSerialPort::readyRead, this, &RFIDworker::checkRFID);
    
            if (RFIDserial->isOpen() == true)
            {
                qDebug() << "Serial ttyUSB0(USB0) is opened";
            }
            else
            {
                qDebug() << "Connexion impossible RFID ! ";
            }
            // lancement timer
            m_timer->start();
    
    
        }
    }
    
    void RFIDworker::stop()
    {
        if(serialRFID && serialRFID->isOpen())
        {
            serialRFID->close();
        }
        if(m_timer && m_timer->isActive())
                m_timer->stop();
    }
    
    void RFIDworker::ledTimer()
    {
        if(m_ledState)
            led_on(RFIDserial);
        else
            led_off(RFIDserial);
        m_ledState = !m_ledState;
        qDebug() << "passage dans Ledtimer";
    }
    
    void RFIDworker::checkRFID()
    {
        while(!RFIDserial->atEnd())
            {
                qDebug() << "passage dans checkRFID";
                //QByteArray rfIdRaw = RFIDserial->readAll();
                // process data
                /*
                if(!tag.isEmpty())
                    emit newTag(tag, value);
                */
            }
    }
    
    
    //======================================================================
    //************             RFID CR038 fonctions :               ****** //
    //======================================================================
    
    
    //******************************************
    //Turn on MiFare module LED subroutine
    void led_on(QSerialPort *RFIDport)
    {
      // on envoit tout d'un coup !
      QByteArray da(LED_ON, sizeof(LED_ON));
      RFIDport->write(da);
      //delay(200)
      QByteArray ba;
      while(!RFIDport->isOpen());
      ba = RFIDport->readAll();
      qDebug() << "reception LED_ON :" << ba;
    }
    
    //*******************************************
    //Turn on MiFare module LED subroutine
    void led_off(QSerialPort *RFIDport)
    {
    
       QByteArray da(LED_OFF, sizeof(LED_OFF));
       RFIDport->write(da);
       QByteArray ba;
       //delay(200)
       while(!RFIDport->isOpen());
       ba = RFIDport->readAll();
       qDebug() << "reception LED_OFF :" << ba;
    }
    
    

    Coté init dans le mainwindow j'ai rien changé ....

    en réponse console j'ai :

    Serial ttyUSB0(USB0) is opened
     Thread RFID lancé !
    

    donc le worker a bien été lancé ainsi que le thread RFID.

    Une idée ? J'ai oublié un truc ?

    J'ai essayé d'échanger Tx et Rx coté connectique mais rien ne se passe...
    et je devrais quand même avoir des lignes de debug coté worker qui indique le déroulement du ledtimer...

    J'essaye de coller au mieu à la "QT conforme" mais vu que mon projet est a cheval entre une IHM et de l'embarqué pur c'est pas simple...

    Merci pour votre aide ;)



  • @jym92 said in Problème en lecture/écriture de badge RFID mifare classic avec Raspberry et CR038:

    Coté init dans le mainwindow j'ai rien changé ....

    Le problème est là à mon avis, est-ce ton thread est une instance de QThread?
    Est-ce que tu as bien supprimé ta classe RFIDthread qui ne sert à rien?

    //auto* rfThread = new RFIDthread();
    auto* rfThread = new QThread();
    


  • @jym92 said in Problème en lecture/écriture de badge RFID mifare classic avec Raspberry et CR038:

    'essaye de coller au mieu à la "QT conforme" mais vu que mon projet est a cheval entre une IHM et de l'embarqué pur c'est pas simple...

    Le mode de fonctionnement de Qt peut sembler à première vue un peu étrange, mais c'est en fait très performant. Donc, pour de l'embarquer pas un soucis, bien au contraire.
    Je te conseille vivement de prendre le temps de lire et comprendre les articles suivants:

    Ceci va t'aider à mieux cerner la philosophie de Qt et le pourquoi comment du mécanisme signals/slots.



  • Effectivement tu avais raison, je n'avais pas supprimé mon fichier RFIDThread car je pensais qu'il été utile a lancement de la classe et l'appel au niveau du mainwindow était faux...

    voila mon appel au niveau de mainwindow :

    // ------------ Lancement du Thread RFID worker -----------------//
        auto* rfThread = new QThread();
        auto* rfWorker = new RFIDworker();
    
        // start RF ID Reader on thread start
        connect(rfThread, &QThread::started, rfWorker , &RFIDworker::start);
        // stop RF ID Reader on main application exit
        connect(qApp, &QApplication::aboutToQuit, rfWorker, &QObject::deleteLater);
        // delete thread on worker end
        connect(rfWorker, &QObject::destroyed, rfThread, [rfThread](QObject *)
        {
            if(rfThread->isRunning())
            {
                 rfThread->quit();
                 rfThread->wait();
            }
            rfThread->deleteLater();
        }
        , Qt::DirectConnection);  // needs "DirectConnection" to work
        // to be informed about new RF ID tag
        //connect(rfWorker,  &RFIDworker::newTag, this, &MyMainClass::newRfIdTag);
        // move worker object to worker  thread
        rfWorker->moveToThread(rfThread);
        // last but not least, start worker thread
        rfThread->start();
    

    Du coup dans mon Thread tout fonctionne comme je le veux, à savoir j'envois des commandes via le Timer et je reçois automatiquement mes réponses dans CheckRFID ;)

    Cependant un autre problème apparaît que je suspectais déjà,à savoir l'envoi et la réception de données sur mon port série USB0 brouille ma réception de donnés sur le port UART5 qui est en l'air mais normalement relié à un PIC.

    Voila comment je déclare la communication série avec le PIC dans mon mainwindow :

    //----------------------- Parametrage de la liaison serie -------------------------------------- //
        QList<QSerialPortInfo> listPsi; // liste des ports série existant
        listPsi = QSerialPortInfo::availablePorts(); // récupère les ports série disponibles
    
        for(int i=0 ; i<listPsi.size() ; i++)
         qDebug() << "Communiquer : " << listPsi.at(i).portName() <<" " << listPsi.at(i).description();
    
        serial = new QSerialPort(this);
    
        // se connecte au port série déja existant nommé "ttyAMA0"
    
        // remarque port serie (si uart0, uart4 et uart5 activé via config):
        // uart 0 = Ama0 pin8(tx) et 10(Rx)
        // USB0  // RFID PN532
        // uart 5 = Ama2 pin32 et 33 // PIC
        // ----- INIT SERIAL PIC ----//
        serial->setPortName("ttyAMA2");
        serial->setBaudRate(QSerialPort::Baud115200);
        serial->setDataBits(QSerialPort::Data8);
        serial->setParity(QSerialPort::NoParity);
        serial->setStopBits(QSerialPort::OneStop);
        serial->setFlowControl(QSerialPort::NoFlowControl);
        serial->open(QIODevice::ReadWrite);
    
        if (serial->isOpen() == true)
        {
            qDebug() << "Serial ttyAMA2(uart5) is opened";
            connect(serial, SIGNAL(readyRead()),this,SLOT(on_Received_Data()));
        }
        else
        {
            qDebug() << "Connexion impossible PIC ! ";
        }
    
    

    et la reception des données je fais :

    // boucle activé sur reception de données serie :
    void MainWindow::on_Received_Data()
    {
        // ------- choses à faire - RX side -------
        qDebug() << "reception données :";
        QByteArray ba;
        ba = serial->readAll();
        ui->label_uart_pic->setText("Données reçues : " + ba );
        qDebug() << ba;
    
    }
    

    Le fonctionnement est quasi le meme que pour le rfid j'ai un timer qui tourne qui vérifie l'état d'un bouton poussoir et qui suivant son état allume une led et envoie un une commande au Pic qui lui répond.

    Une idée pour résoudre ce conflit au niveau des port séries ?
    Y'a pas moyen de d'interdire au mainwindow l'accés au port USB0 ?

    ce genre de problème est juste impensable coté C embarqué classique ;)
    ( on envoi/reçoit sur un port et un port en l'air reçoit des données...)

    Un grand merci pour ton aide @KroMignon !



  • @jym92 said in Problème en lecture/écriture de badge RFID mifare classic avec Raspberry et CR038:

    ce genre de problème est juste impensable coté C embarqué classique ;)
    ( on envoi/reçoit sur un port et un port en l'air reçoit des données...)

    Ca n'a rien à voir avec le langage de programmation C ANSI ou C++, c'est une question d'organisation du code...
    Tu auras le même type de problème quelque soit le langage utilisé (même C#).
    Si tu autorises tout le monde à accéder à tous les ports série, et bien c'est la cacophonie assurée!

    Pour ton projet, il te faut définir:

    • une classe qui va s'occuper du dialogue avec ton lecture RFID
    • une classe qui va s'occuper du dialogue avec ton PIC

    Après tu fais le lien entre tes instances avec l'aide de signaux et slots.

    En gros, dans ta classe RFID (RFIDworker) tu ajoutes un signal pour demander le contrôle de la LED (par exemple setLedState(bool state)):

    class RFIDworker : public QObject
    {
        Q_OBJECT
    
    public:
        explicit RFIDworker(QObject *parent= nullptr);
    ...
    
    signals:
        void setLedState(bool state);
    ...
    };
    

    comme ça tu peux demander d'allumer ou éteindre la LED avec emit setLedState(true);/emit setLedState(false);
    Dans ta classe PIC (PicManager), tu vas créer un slot pour la commande de la LED RFID:

    class PicManager: public QObject
    {
        Q_OBJECT
    
    public:
        explicit PicManager(QObject *parent= nullptr);
    ...
    
    public:
        void setRfidLedState(bool state);
    ...
    };
    

    Chaque class va s'occuper de son port série et tout le monde sera content.

    Bref, comme écrit plus haut, c'est une question d'organisation du code. Le C++ permet de simplement cloisonner tout le monde, encore faut-il le faire, ça c'est à la charge du développeur!



  • OK ok je vois du coup c'est juste un problème d'organisation du code, il faut à chaque fois définir une classe spécifique au port Série utilisé...

    Et si jamais j'ai besoin j'ai besoin d'écrire ou de lancer des commandes sur l'un des ports séries depuis le mainwindows, j'appelle alors des fonctions de cette classe.

    OK je mets en place une classe spécifique pour la gestion du port série de mon PIC sur le même modèle que celle utilisée par le RFID.

    Je vous tiens au jus si tout ça fonctionne, merci ;)



  • @jym92 Exactement, et dans l'absolue tu pourrais utiliser plusieurs lecteurs RFID ou PIC, il te suffit de créer autant d'instances des classes correspondantes.
    Et c'est là que le C++ (ou C#) prends largement l'avantage sur la programmation en C ANSI.



  • @jym92 Autre info au passage, rien ne t'oblige à faire du multi-threading avec ton application. Je pense que tu devrais largement t'en sortir uniquement avec le thread principal.
    Dans ce cas, il te suffit de légèrement modifier ta séquence d'init:

        auto* rfWorker = new RFIDworker();
    
        // stop RF ID Reader on main application exit
        connect(qApp, &QApplication::aboutToQuit, rfWorker, &QObject::deleteLater);
    
    #if USE_MULTITHREAD
        auto* rfThread = new QThread();
        // start RF ID Reader on thread start
        connect(rfThread, &QThread::started, rfWorker , &RFIDworker::start);
        // delete thread on worker end
        connect(rfWorker, &QObject::destroyed, rfThread, [rfThread](QObject *)
        {
            if(rfThread->isRunning())
            {
                 rfThread->quit();
                 rfThread->wait();
            }
            rfThread->deleteLater();
        }
        , Qt::DirectConnection);  // needs "DirectConnection" to work
        // to be informed about new RF ID tag
        //connect(rfWorker,  &RFIDworker::newTag, this, &MyMainClass::newRfIdTag);
        // move worker object to worker  thread
        rfWorker->moveToThread(rfThread);
        // last but not least, start worker thread
        rfThread->start();
    #else
        rfWorker->start();
    #endif
    

    Et de même pour l'instance de ta classe de gestion du PIC.



  • Grande nouvelle ! Tout fonctionne comme je le souhaite !

    j'ai même essayé de saturé le port série lié au PIC en lui envoyant des commandes depuis une Arduino vers la Raspberry en même temps que le RFID fonctionne et je n'ai vu aucun problème ;)

    Je suis parti sur un Thread/Worker spécifique à chaque port série car pour le moment je n'ai qu'un PIC et un RFID mais je vais devoir ajouter encore 2 port séries pour un gprs et un monnayeur.
    Je pense que dans mon cas ce cloisonnement par Thread pour chaque port série évite tout risque de débordement ou de paralysie de l'IHM.

    Je vais maintenant continuer à travailler sur l’accès aux données de mon RFID(acces block).

    Un grand merci pour votre aide ! ;)



  • @jym92 said in Problème en lecture/écriture de badge RFID mifare classic avec Raspberry et CR038:

    Je pense que dans mon cas ce cloisonnement par Thread pour chaque port série évite tout risque de débordement ou de paralysie de l'IHM.

    Très bonne nouvelle :)

    Mais je te conseille quand même de faire un test en mono-threading, je suis persuadé que le multi-threading avec des ports séries à seulement 115200 bauds c'est donner de la confiture aux cochons.
    Mais c'est à toi de voir.

    Sinon, pour compléter un peu ta "culture Qt", voici un autre article pour mieux comprendre les QObject, QThread et le mécanisme signal/slots => Threads and QObjects


  • Lifetime Qt Champion

    @jym92 said in Problème en lecture/écriture de badge RFID mifare classic avec Raspberry et CR038:

    Je pense que dans mon cas ce cloisonnement par Thread pour chaque port série évite tout risque de débordement ou de paralysie de l'IHM.

    La première chose à faire quand on commence à penser à ajouter des threads dans une application est de bien valider la nécessiter d'utiliser des threads et de laisser passer une nuit avant de s'y attaquer.

    La nature asynchrone de Qt permet souvent de s'en passer. Cela est spécialement vrai pour les ports séries qui sont généralement lents par rapport au reste du système.

    En ce qui concerne le design de l'application, comme @KroMignon l'a déjà écrit, le mieux est d'encapsuler chaque élément communicant avec un port série de sorte qu'il soit bien indépendant du reste. Comme cela, si la nécessité de thread se fait réellement sentir, leur mise en application sera plus aisée.


Log in to reply