Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Nouveau membre du Club
    Sélectionner un enregistrement dans une matrice
    bonjour,

    je fais un jeu , où j'utilise un module rfid rc-522.

    Pour le moment, je beug sur la sélection de façon aléatoire d'un enregistrement de la matrice

    chaque enregistrement a "nomcarte" (celui à qui appartient la carte rfid) et un "idcarte"(id de la carte, obtenu via programme Dumpinfo)

    voici mon code

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    //Je déclare un tableau qui contient les identifiants des cartes rfid et nol associé
    struct donnee_t {
      char nomcarte;
      char idcarte;
    } maListe[] = {
      {'colonnel', '9A 66 65 19'}, {'general', '0A 69 72 1A'}, {'President', 'FA 7A 6A 19'}, {'secrétaire', '7A 6C 5E 19'}, {'soldat', '1A 4B A9 19'},
      {'entretient', 'B7 BF A7 5F'}, {'administrator', '80 30 7A 2A'}
    };
    const size_t nombreDeDonnees = sizeof(maListe) / sizeof(maListe[0]);
     
    void imprime()
    {
      int i=random(5);
     
        Serial.println(i.nomcarte);
        Serial.println(i.idcarte);
      }
     
    }
    void setup() {
     
    Serial.begin(9600);
    imprime();
    //Serial.println(i);
     
    }


    J'ai un message d'erreur
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    request for member 'nomcarte' in 'i', which is of non-class type 'int'

    J'ai essayé
    Serial.print(maListe[i]); mais ça beug aussi

    j'ai beau fouiller le net, je n'arrive pas à trouver la solution.

    merci par avance pour votre aide

  2. #2
    Nouveau membre du Club
    problème de randomisation
    bonjour,
    j'ai contourné le problème en créant 2 tableaux, 1 pour le "nom du détenteur" et l'autre "UID de la carte".

    Je passe mes différents tags, et quand j'ai le bon, ça me mets bien "ACCES AUTORISE" mais je n'arrive pas à créer un nouveau random. HELP ME

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    #include <SPI.h>
    #include <MFRC522.h>
    /*#include <LiquidCrystal.h>
    LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
    */
    #define RST_PIN 5
    #define SS_PIN 53
    MFRC522 mfrc522(SS_PIN, RST_PIN);
     
    //Je déclare deux tableaux qui contient les identifiants des cartes rfid et nol associé
    char* tagNom[] = {"colonnel","general","President","secrétaire","soldat","entretient","administrator"};
    char* tagUID[]= {"9A 66 65 19","0A 69 72 1A", "FA 7A 6A 19", "7A 6C 5E 19", "1A 4B A9 19", "B7 BF A7 5F", "80 30 7A 2A"};
    int X;
     
    /*int buzzer = 8;
    int led_rouge = 14;
    int led_verte = 15;
    */
     
    void randoom(){ //on choisi aléatoirement un enregistrement dans les tableaux
     int X=random(5);
     Serial.println(tagNom[X]); 
     Serial.println(tagUID[X]); 
    }
    void setup() {
      Serial.begin(9600);
      while (!Serial);
      /*pinMode(led_rouge, OUTPUT);
      pinMode(led_verte, OUTPUT);
      pinMode(buzzer, OUTPUT);
      lcd.begin(16, 2);*/
      SPI.begin();
      mfrc522.PCD_Init();
      mfrc522.PCD_DumpVersionToSerial();
      Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
      randoom();
      /*lcd.print("Dispositif");
      lcd.setCursor(0, 1);
      lcd.print("d'identification");
      Serial.print("Dispositif d'identification");
      delay(3000);
      lcd.clear();*/
    }
     
    void loop() {
      /*lcd.print("Scannez votre");
      Serial.print("Scannez votre badge ou carte");
      lcd.setCursor(0, 1);
      lcd.print("carte ou badge..");
    */
      if ( ! mfrc522.PICC_IsNewCardPresent()) 
      {
        return;
      }
     
      if ( ! mfrc522.PICC_ReadCardSerial()) 
      {
        return;
      }
    //mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
      String UID = "";
     
      for (byte i = 0; i < mfrc522.uid.size; i++) {
        UID.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
        UID.concat(String(mfrc522.uid.uidByte[i], HEX));
      }
     
      UID.toUpperCase();
     
      if (UID.substring(1) == tagUID[X]) 
      {
        /*lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ACCES AUTORISE");*/
        Serial.print("ACCES AUTORISE");
     
        randoom();
        /*digitalWrite(led_verte, HIGH);
        tone(buzzer, 1200, 100);
        delay(125);
        tone(buzzer, 1200, 100);
        delay(2000);
        digitalWrite(led_verte, LOW);
        lcd.clear();*/
      }
     
      else {
       /* lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("ACCES REFUSE");*/
        Serial.print("STOP");
       /* digitalWrite(led_rouge, HIGH);
        tone(buzzer, 200, 750);
        delay(2000);
        digitalWrite(led_rouge, LOW);
        lcd.clear();*/
      }
    }

  3. #3
    Responsable Arduino et Systèmes Embarqués

    Bonsoir,

    Pour l'initialisation, essaie plutôt :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    struct donnee_t {
      char nomcarte[15];
      char idcarte[12];
    } maListe[] = {
      {"colonnel", "9A 66 65 19"}, {"general", "0A 69 72 1A"}, {"President", "FA 7A 6A 19"}, {"secrétaire", "7A 6C 5E 19"}, {"soldat", "1A 4B A9 19"},
      {"entretient", "B7 BF A7 5F"}, {"administrator", "80 30 7A 2A"}
    };


    Pour l'affichage :
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
      Serial.println(maListe[i].nomcarte);
      Serial.println(maListe[i].idcarte);

  4. #4
    Membre éprouvé
    Comme il semble que les noms utilisés dans les cartes sont fixes, on peut aussi utiliser des const char* au lieu d'un tableau de dimension statique qui sera forcément adapté au nom le plus long (donc on perd de la mémoire pour les autres).

    De plus les ID semblent être clairement un nombre en hexadécimal sur 4 octets que l'on peut stocker donc dans un uint32_t (unsigned long) ce qui a l'avantage de permettre ensuite une comparaison simple et super rapide avec ==. On gagne aussi énormément en mémoire, 4 octets par carte au lieu de 12 !

    voilà un petit code qui fait la définition du jeu de carte puis imprime une carte aléatoirement toute les secondes. Une fois la carte choisie, on va aussi regarder si cette carte tirée correspond au Colonel (avec un identifiant codé comme si on l'avait obtenu par lecture RFID pour vous montrer comment faire) et si oui on affiche un petit message
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    // On définit le type carte
    struct t_carte {
      const char* grade;
      const uint32_t identifiant;
    };
     
    t_carte jeuDeCartes[] = {   // préférer le nom du type sous forme t_xxx car le format xxx_t est réservé par la norme aux types officiels
      {"Colonel", 0x9A666519}, // Attention little Endian -> les octets de poids faibles seront en premier en mémoire
      {"General", 0x0A69721A},
      {"President", 0xFA7A6A19},
      {"Secrétaire", 0x7A6C5E19},
      {"Soldat", 0x1A4BA919},
      {"Entretien", 0xB7BFA75F},
      {"Administrateur", 0x80307A2A}
    };
     
    const uint8_t nombreDeCartes = sizeof(jeuDeCartes) / sizeof(jeuDeCartes[0]);
     
    void setup()
    {
      Serial.begin(115200); // on ouvre la console série à 115200 bauds
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
    }
     
    void loop()
    {
      uint8_t carteAleatoire = random(0, nombreDeCartes); // un nombre entier entre 0 et nombreDeCartes-1
      Serial.print(jeuDeCartes[carteAleatoire].grade);
      Serial.write("\tOx");
      Serial.println(jeuDeCartes[carteAleatoire].identifiant, HEX);
     
      // simulation d'une carte à trouver
      uint8_t uidByte[4] = {0x19, 0x65,  0x66, 0x9A}; // le Colonel
     
      if (jeuDeCartes[carteAleatoire].identifiant == *((uint32_t*) uidByte)) {
        Serial.println(F("\tBingo sur le Colonel!"));
      }
     
      delay(1000);
    }


    quand vous voudrez comparer une carte lue avec un élément du tableau, il faudra comparer ce qu'il y a en mémoire dans le tableau mfrc522.uid.uidByte[] avec votre uint32_t.
    Si vous avez bien pris soin d'ordonner les octets dans l'identifiant dans l'ordre où ils sont rangés dans le tableau alors un simple test comme cela devrait marcher
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    if (jeuDeCartes[i].identifiant == *((uint32_t*) mfrc522.uid.uidByte)) {
       // on a trouvé le bon code
    } else {
      // mauvais code
    }


    le format *((uint32_t*) mfrc522.uid.uidByte) semble un peu barbare, mais en gros on dit par (uint32_t*) que le type pointé par le tableau est des uint32_t et ensuite l'étoile devant dit d'aller chercher cet élément pointé. Ainsi au lieu d'aller juste chercher un octet, on va en chercher 4 ce qui permet la comparaison.

    L'architecture mémoire retenue sur Arduino est little Endian, c'est à dire qu'on range les octets de poids faible d'un nombre en premier en mémoire. Par exemple le nombre 0x12345678 sera représenté en mémoire par d'abord 78 puis 56 puis 34 et enfin 12. La lecture d'une carte RFID donne des octets dans un certain ordre, il faudra donc dans la définition des identifiants des cartes mettre le premier octet (mfrc522.uid.uidByte[0]) en octet de poids faible -> cf ce que j'ai fait pour le colonel.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
      {"Colonel", 0x9A666519}, // Attention little Endian -> les octets de poids faibles seront en premier en mémoire
    ...
      uint8_t uidByte[4] = {0x19, 0x65,  0x66, 0x9A}; // le Colonel

  5. #5
    Nouveau membre du Club
    Grrrr, transfert de variable entre fonction
    Bonjour Jay M et merci pour ta réponse toujours aussi claire;

    J'ai essayé d'adapter mon code avec le tient, mais ça beug toujours, par rapport au transfert de variable.
    J'ai mis l'ID des tag en char*, est ça fonctionne quand il y a concordance.

    En fonction d'où je mets
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
     uint8_t carteAleatoire = random(0, nombreDeCartes); // un nombre entier entre 0 et nombreDeCartes-1

    le code beug plus ou moins.
    Pour que ça fonctionne, il faut le mettre dans le loop(), mais ça change tout le temps
    et si je le mets ailleurs, ça beug quand le vérificateur arrive ici:
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
      if (UID.substring(1) == tagCartes[carteAleatoire].UID)

    Enfin, quand je le mets au début, c'est toujours la même carte qui sort.
    J'ai compris qu'une variable n'était définie que pour la fonction où elle est définie, c'est balo.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    #include <SPI.h>
    #include <MFRC522.h>
    /*#include <LiquidCrystal.h>
      LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
    */
    #define RST_PIN 5
    #define SS_PIN 53
    MFRC522 mfrc522(SS_PIN, RST_PIN);
     
    //Je déclare deux tableaux qui contient les identifiants des cartes rfid et nol associé
    // On définit le type carte
    struct t_carte {
      const char* nom;
      const char* UID;
    };
    t_carte tagCartes[] = {
      {"colonnel", "9A 66 65 19"},
      {"general", "0A 69 72 1A"},
      {"President", "FA 7A 6A 19"},
      {"secrétaire", "7A 6C 5E 19"},
      {"soldat", "1A 4B A9 19"},
      {"entretient", "B7 BF A7 5F"},
      {"administrator", "80 30 7A 2A"}
    };
     
    const uint8_t nombreDeCartes = sizeof(tagCartes) / sizeof(tagCartes[0]);
     
     
     
     
    /*int buzzer = 8;
      int led_rouge = 14;
      int led_verte = 15;
    */
     
    void setup() {
      Serial.begin(9600);
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
     
      while (!Serial);
      /*pinMode(led_rouge, OUTPUT);
        pinMode(led_verte, OUTPUT);
        pinMode(buzzer, OUTPUT);
        lcd.begin(16, 2);*/
      SPI.begin();
      mfrc522.PCD_Init();
      mfrc522.PCD_DumpVersionToSerial();
      //Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
     
      /*lcd.print("Dispositif");
        lcd.setCursor(0, 1);
        lcd.print("d'identification");
        Serial.print("Dispositif d'identification");
        delay(3000);
        lcd.clear();*/
      randoom();
     
    }
    void randoom(){
      uint8_t carteAleatoire = random(0, nombreDeCartes); // un nombre entier entre 0 et nombreDeCartes-1
      Serial.print(tagCartes[carteAleatoire].nom);
      Serial.write("\tOx");
      Serial.println(tagCartes[carteAleatoire].UID);
     
    }
    void loop() {
    randoom();
      /*lcd.print("Scannez votre");
        Serial.print("Scannez votre badge ou carte");
        lcd.setCursor(0, 1);
        lcd.print("carte ou badge..");
      */
      if ( ! mfrc522.PICC_IsNewCardPresent())
      {
        return;
      }
     
      if ( ! mfrc522.PICC_ReadCardSerial())
      {
        return;
      }
      //mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
      String UID = "";
     
      for (byte i = 0; i < mfrc522.uid.size; i++) {
        UID.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
        UID.concat(String(mfrc522.uid.uidByte[i], HEX));
      }
     
      UID.toUpperCase();
     
      if (UID.substring(1) == tagCartes[carteAleatoire].UID)
      {
        /*lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("ACCES AUTORISE");*/
        Serial.print("ACCES AUTORISE");
     
        /*digitalWrite(led_verte, HIGH);
          tone(buzzer, 1200, 100);
          delay(125);
          tone(buzzer, 1200, 100);
          delay(2000);
          digitalWrite(led_verte, LOW);
          lcd.clear();*/
      }
     
      else {
        /* lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("ACCES REFUSE");*/
        Serial.print("STOP");
        /* digitalWrite(led_rouge, HIGH);
          tone(buzzer, 200, 750);
          delay(2000);
          digitalWrite(led_rouge, LOW);
          lcd.clear();*/
      }
    }

  6. #6
    Membre éprouvé
    vous générez avec votre fonction une carte aléatoire qui n'est pas ne variable globale, ça ne doit même pas compiler sans doute...

    essayez avec ce bout de code
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    #include <SPI.h>
    #include <MFRC522.h>
    #define RST_PIN 5
    #define SS_PIN 53
    MFRC522 mfrc522(SS_PIN, RST_PIN);
     
    uint8_t carteAleatoire;
     
    //Je déclare deux tableaux qui contient les identifiants des cartes rfid et nol associé
    // On définit le type carte
    struct t_carte {
      const char* nom;
      uint32_t UID;
    };
     
    t_carte jeuDeCartes[] = {   // préférer le nom du type sous forme t_xxx car le format xxx_t est réservé par la norme aux types officiels
      {"Colonel", 0x1965669A}, // Attention little Endian -> les octets de poids faibles seront en premier en mémoire
      {"General", 0x1A72690A},
      {"President", 0x196A7AFA},
      {"Secrétaire", 0x195E6C7A},
      {"Soldat", 0x19A94BA1},
      {"Entretien", 0x5FA7BFB7},
      {"Administrateur", 0x2A7A3080}
    };
     
    const uint8_t nombreDeCartes = sizeof(jeuDeCartes) / sizeof(jeuDeCartes[0]);
     
    void choisirCarteAleatoire()
    {
      carteAleatoire = random(0, nombreDeCartes); // un nombre entier entre 0 et nombreDeCartes-1
      Serial.print(F("Nouvelle Carte Aleatoire: "));
      Serial.print(jeuDeCartes[carteAleatoire].nom);
      Serial.print(F("\t0x"));
      Serial.println(jeuDeCartes[carteAleatoire].UID, HEX);
    }
     
    void setup()
    {
      Serial.begin(115200);
      while (!Serial);
     
      SPI.begin();
      mfrc522.PCD_Init();
     
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
      choisirCarteAleatoire();
    }
     
     
    void loop()
    {
     
      if ( ! mfrc522.PICC_IsNewCardPresent()) return;
      if ( ! mfrc522.PICC_ReadCardSerial()) return;
      // on a une carte dont le N° est dans le tableau mfrc522.uid.uidByte
     
      if (jeuDeCartes[carteAleatoire].UID == *((uint32_t*) mfrc522.uid.uidByte)) {
        Serial.println("ACCES AUTORISE");
        choisirCarteAleatoire();
      } else {
        Serial.println("STOP");
      }
    }
    je vous déconseille de passer par la représentation chaîne de caractère et l'usage de la classe String pour fabriquer la représentation vraiment ce n'est pas du tout nécessaire.

    PS/ utilisez l'octograffe correcte pour les noms, ce sera mieux j'ai fait quelques corrections

  7. #7
    Nouveau membre du Club
    Ca fonctionne merci beaucoup.

  8. #8
    Nouveau membre du Club
    Première carte, toujours identique
    bonjour, le code fonctionne bien, à chaque réussite, le nom de la carte change, mais la première est toujours la même à savoir celle du colonel

  9. #9
    Membre éprouvé
    sans doute votre
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
    qui n'est pas très "random". vous avez quelque chose de connecté dans A0 ? mettez un fil qui pointe en l'air, ça fera antenne

    sinon appelez deux fois la fonction
    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    void choisirCarteAleatoire()
    {
      carteAleatoire = random(0, nombreDeCartes); // un nombre entier entre 0 et nombreDeCartes-1
      carteAleatoire = random(0, nombreDeCartes); // un nombre entier entre 0 et nombreDeCartes-1
      Serial.print(F("Nouvelle Carte Aleatoire: "));
      Serial.print(jeuDeCartes[carteAleatoire].nom);
      Serial.print(F("\t0x"));
      Serial.println(jeuDeCartes[carteAleatoire].UID, HEX);
    }

  10. #10
    Nouveau membre du Club
    Merci pour votre réponse
    Vous mettez "uint8_t carteAleatoire;"

    Dans le référentiel arduino, il est dit que random est de type long

    Du coup j'ai modifié dans mon code du moment et ça fonctionne.

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
     
    // On définit le type crypto
    struct t_crypto {
      const char* ID;
      const char* Red;
      const char* Blue;
    };
     
    t_crypto Code[] = {
      {"A1C2", "8AA4", "7C9A" },
      {"C312", "651A", "8A52"},
      {"AA98", "74A1", "8C8A"},
      {"7A54", "A35C", "55C2"},
      {"3A3C", "3A3C", "01A5"},
      {"3c5a", "aaaa", "80c4"},
      {"648C", "CC1C", "92C1"},
      {"9761", "C7A4", "3333"}
    };
     
    void choisirCarteAleatoire()
    {
       long carteCrypto = random(0,8);
     
      Serial.println(carteCrypto);
      Serial.println(F("Crypto carte: "));
      Serial.println(Code[carteCrypto].ID);
      Serial.println(Code[carteCrypto].Red);
      Serial.println(Code[carteCrypto].Blue);
    }
    void   setup () {
      Serial.begin(115200);
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
      choisirCarteAleatoire();
     
    }
     
    void loop () {
     //choisirCarteAleatoire();
    }


    Enfin un code propre qui fonctionne (merci JayM et jppbricole)

  11. #11
    Membre éprouvé
    Citation Envoyé par hugobeauce Voir le message
    Merci pour votre réponse
    Vous mettez "uint8_t carteAleatoire;"

    Dans le référentiel arduino, il est dit que random est de type long

    Du coup j'ai modifié dans mon code du moment et ça fonctionne.
    OUI c'est un long mais comme on génère un truc entre 0 et 6 ça tient dans un uint8_t et le long est converti automatiquement... bizarre à mon avis ça ne change rien. (vous avez aussi doublé l'appel ?) (dans le code d'origine avec le lecteur de carte)