Sélectionner un enregistrement dans une matrice

Version imprimable

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:

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:

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.:calim2:

merci par avance pour votre aide

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.:calim2: HELP ME

Code:

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();*/
  }
}

Bonsoir,

Pour l'initialisation, essaie plutôt :

Code:

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:

1
2
  Serial.println(maListe[i].nomcarte);
  Serial.println(maListe[i].idcarte);

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:

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:

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:

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

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:

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:

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:

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();*/
  }
}

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:

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

25/03/2020, 18h49
hugobeauce

Ca fonctionne merci beaucoup.
30/03/2020, 17h38
hugobeauce

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

sans doute votre

Code:

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:

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); }

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:

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)

30/03/2020, 18h48
Jay M

Citation:

Envoyé par hugobeauce

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)