Discussion :

[cobra38]

Bonjour à Tous

Mon projet est le suivant :
Une serrure électronique avec

Arduino UNO + RFID RC522 + Clavier souple 4x4

Le programme actuel fonctionne mais j'ai du programmer les N° UID autorisés de type ( FF.FF.FF.FF )
L'idée serait donc de pouvoir sauvegarder ces N° ( après validation ) dans l'EEPROM de l'Arduino
Mais je ne sais comment m'y prendre
tableau , structure bref j'ai donc besoin votre aide

merci par avance

[jpbbricole]

Bonsoir cobra38

Les mettre en tableau s'il n'y a que l'UID à sauver. Si d'autres valeurs attenantes à l'UID, dans une structure en tableau, sauver le tableau ou la structure avec un EEPROM.put et restaurer les données avec un EEPROM.get
EEPROM.put fait un EEPROM.update ce qui "économise" l'EEPROM

Cordialement
jpbbricole

[cobra38]

Merci d'avoir répondu jpbbricole

ok pour le tableau mais doit-on faire la sauvegarde dans ce tableau, octet par octet ou l'ensemble de la chaine ?

Cordialement

[jpbbricole]

Bonsoir cobra38

ok pour le tableau mais doit-on faire la sauvegarde dans ce tableau, octet par octet ou l'ensemble de la chaine ?

Put et Get "s'occupent de tout"
Une petite recherche chez Google.

Cordialement
jpbbricole

[cobra38]

Bonsoir ( et Joyeuses Fêtes),

J'ai attentivement lu tout ce que je pouvais comprendre et tenté quelques essais
avec EEPROM.put () et EEPROM.get()
mais j'ai besoin de votre aide car j'ai constaté par ex la chose suivante :

N° UID en DEC lu sur une carte : tag ="135 120 254 36"

soit donc EEPROM.put (1000,tag)
et
EEPROM.get(1000,tag)

En lisant l'EEPROM j'aurai normalement du avoir mes valeurs enregistrées à partir de l'adresse 1000
mais au lieu de çà, je retrouve des valeurs incohérentes peut-être des adresses de pointeurs
j'ai donc tente de modifier et mis :

EEPROM.put (1000,sizeof(tag))
mais sans résultat

une petite piste me serait alors salutaire

merci par avance
Cordialement

[jpbbricole]

Bonjour cobra38 et bonnes fêtes également.

EEPROM.put (1000,tag)

EEPROM.get(1000,tag)

Attention, un UNO c'est 1024 "cases" EEPROM maximum!

Voici 2 exemples, pour écrire et pour lire.

Ecrire

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
#include <EEPROM.h>
 
const int tagNbr = 5;                  // Nombre de TAG
String tagTableau[tagNbr];             // Tableau des TAG
int eepromAdresseTag = 0;              // Adresse de depart en EEPROM
 
void setup()
{
	Serial.begin(115200);
 
	tagTableau[0] = "135 120 254 01";
	tagTableau[1] = "135 120 254 02";
	tagTableau[2] = "135 120 254 03";
	tagTableau[3] = "135 120 254 04";
	tagTableau[4] = "135 120 254 05";
 
	EEPROM.put(eepromAdresseTag, tagTableau);
}
 
void loop()
{
 
 
}

Lire

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
#include <EEPROM.h>
 
const int tagNbr = 5;                  // Nombre de TAG
String tagTableau[tagNbr];             // Tableau des TAG
int eepromAdresseTag = 0;              // Adresse de depart en EEPROM
 
void setup()
{
	Serial.begin(115200);
 
	EEPROM.get(eepromAdresseTag, tagTableau);
 
	for (int i=0; i < tagNbr; i ++)
	{
		Serial.println("TAG #" + String(i+1) + " = " + tagTableau[i]);
	}
}
 
void loop()
{
 
}

Cordialement
jpbbricole

[cobra38]

Mille mercis jpbbricole

j'ai bien noté qu'il n'y avait que 1024 octets , mais mon projet ne devrait utiliser que 5 cartes
et un tableau [5] est donc parfait

j'ai hésité à commencer la numérotation à 0 car j'ai constaté lors d'un dump de l'EEPROM des valeurs à des endroits disparates
peut-être des restes d'autres prgs

j'ai fait l'essai tel que décrit avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
const int tagNbr = 5;                  // Nombre de TAG
String tagTableau[tagNbr];             // Tableau des TAG
int eepromAdresseTag = 0;              // Adresse de depart en EEPROM

puis dans :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void loop 
 
 // Enregistrement dans EEPROM 
     eepromAdresseTag = 0;
     tagTableau[eepromAdresseTag] = tag;
     // vidage EEPROM après ecriture
    for (int i = 0; i < 6; i++) {
    byte valeur = EEPROM.read(i);
    Serial.print(i);
    Serial.print(" = ");
    Serial.println(valeur);

avec : tag = "135 120 254 36"
je me retrouve avec une valeur enregistrée à l'adresse 0 telle que :

0 = 2    <= ???
1 = 143
2 = 186
3 = 105
4 = 151
5 = 21

pour quelle raison et c'est là que je bute en fait ...

pascal

[jpbbricole]

Bonjour Pascal

J'ai l'impression qu'il y a confusion entre l'adresse mémoire EEPROM (eepromAdresseTag) et l'indice du tableau tagTableau (tagTableau[indice]).
Il n'y a aucun lien entre les 2. On sauve le tableau tagTableau (donc tout les indices, chaque indice contenant un TAG de 4 chiffres séparés par un espace, de 0 à 4 dans cet exemple) à l'adresse EEPROM eepromAdresseTag.
Pour sauver ce tableau d'un bloc, on utilise EEPROM.put(eepromAdresseTag, tagTableau); Donc, dans ce cas, il faut "oublier" EEPROM.write et EEPROM.read qui ne s'occupent que d'un octet.

Dans l'exemple suivant, j'ai réaménagé le nom des variables afin de permettee une meilleur compréhension (je l'espère) de cette "mécanique";

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
#include <EEPROM.h>
 
const int tagNbr = 5;                  // Nombre de TAG
 
String tag;
int tagTableauIndice;                  // Indice dans tagTableau
String tagTableau[tagNbr];             // Tableau des TAG
int eepromAdresseTagTableau;           // Adresse de depart de l'enregistrement en EEPROM
 
void setup()
{
	Serial.begin(115200);
 
	eepromAdresseTagTableau = 0;            // Position en EEPROM du tableau des TAG tagTableau
 
	tag = "135 120 254 36";                 // tag introduit
	tagTableauIndice = 2;                   // Indice de 0 a tagNbr-1 donc 2 = 3eme position dans le tableau
	tagTableau[tagTableauIndice] = tag;     // Mettre le tag dans une case du tableau des TAG tagTableau
 
	tag = "135 120 254 44";                 // tag introduit
	tagTableauIndice = 4;                   // Indice de 0 a tagNbr-1 donc 2 = 3eme position dans le tableau
	tagTableau[tagTableauIndice] = tag;     // Mettre le tag dans une case du tableau des TAG tagTableau
 
	// Enregistrement du tableau (donc de tout les indices) des TAG dans EEPROM
	EEPROM.put(eepromAdresseTagTableau, tagTableau);
 
	// Lecture de l'EEPROM pour "regeneration" tableau tagTableau depuis
	EEPROM.get(eepromAdresseTagTableau, tagTableau);       // On "regenere" le tasbleau tagTableau depuis l'EEPROM
	for (int i = 0; i < tagNbr; i++) 
	{
		Serial.println("TAG #" + String(i) + " = " + tagTableau[i]);
	}
}
 
void loop()
{
}

Une petite remarque, tu as mis ton exemple dans void loop. Or cette loop "tourne" en permanence, il est préférable de mettre ceci en fin de void setup.

A+
Cordialement
jpbbricole

[cobra38]

Grand Merci pour ta patience jpbbricole

Une petite remarque, tu as mis ton exemple dans void loop. Or cette loop "tourne" en permanence, il est préférable de mettre ceci en fin de void setup.

En effet, mais je suis obligé ( du moins je le pense) car mon prg teste en permanence le RFID
car dans le projet
1) je teste le clavier
2) le RFID
3) je me sers aussi du clavier pour entrer dans le prg ADMIN qui permet l'enregistrement la carte

par exemple :
1) j'introduis par le clavier un mdp particulier qui me donne accès au mode ADMIN
2) je scanne la carte par le RFID => N° UID => Enr EEPROM
3) si je présente cette carte , elle me donne l'accès autorisée


j'arrive maintenant à inscrire le N° UID dans l'EEPROM
or lorsque je procède dans le prg à la comparaison des chaines suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if (tag.substring(1) ==(tagTableau[0])) ...

il ne trouve pas la carte et refuse l'accès
aurai-je oublié quelque chose et surtout ai-je le droit de comparer ces 2 chaînes de cette façon ?

Cordialement
pascal

[jpbbricole]

Bonsoir Pascal

En effet, mais je suis obligé ( du moins je le pense) car mon prg teste en permanence le RFID
car dans le projet
1) je teste le clavier
2) le RFID
3) je me sers aussi du clavier pour entrer dans le prg ADMIN qui permet l'enregistrement la carte

par exemple :
1) j'introduis par le clavier un mdp particulier qui me donne accès au mode ADMIN
2) je scanne la carte par le RFID => N° UID => Enr EEPROM
3) si je présente cette carte , elle me donne l'accès autorisée

En fonction de ce qui est ci-dessus, j'ai un peu remanié le tout, surtout que je me suis un peu planté dès le départ en déclarant le tableau en String, c'était pour simplifier, et bien ça ne fonctionne pas très bien, il est nettement plus sûre de le déclarer en char, et en déclarant la longueure du'un TAG (tagSize), ça facilite les EEPROM.put et EEPROM.get.
J'ai, ainsi restructuré le tout, en créant des fonctions, ce qui "aére" le programme.

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
#include <EEPROM.h>
 
String tag;
 
int tagTableauIndice;                  // Indice dans tagTableau
const int tagNbr = 5;                  // Nombre de TAG
const int tagSize = 15;                // Taille d'un TAG
char tagTableau[tagNbr][tagSize];      // Tableau des TAG, 14+1 pour format "135 120 254 01" par ex.
int eepromAdresseTagTableau;           // Adresse de depart de l'enregistrement en EEPROM
 
void setup()
{
	Serial.begin(115200);
 
	eepromAdresseTagTableau = 0;       // Position en EEPROM du tableau des TAG tagTableau
 
	// Mettre ces lignes en remarque  quand tableau en EEPROM
	tagEnregistrer("135 120 254 44", 0);
	tagEnregistrer("135 120 254 43", 1);
	tagEnregistrer("135 120 254 42", 2);
	tagEnregistrer("135 120 254 41", 3);
	tagEnregistrer("135 120 254 40", 4);
 
	tagRestaurer();
	tagListe();
 
	//--------------------------------- Tester si TAG existe
	tag = "135 120 254 41";
	if (tagSiExiste(tag) > -1)
	{Serial.println("TAG " + tag + " connu");}
	else
	{Serial.println("TAG " + tag + " INCONNU");}
 
	tag = "135 120 254 30";
	if (tagSiExiste(tag) > -1)
	{Serial.println("TAG " + tag + " connu");}
	else
	{Serial.println("TAG " + tag + " INCONNU");}
}
 
void loop()
{
	//tester le clavier
	//	si mdp
	//	Si introduction nouveau PID
 
	//Lire lecteur RFID
	//	PID lu?
	//		PID connu?
}
 
//------------------------------------- Enregistrer un TAG en EEPROM
void tagEnregistrer(String tagNouveau, int tagIndex)       
{
	tagNouveau.toCharArray(tagTableau[tagIndex], tagSize);
	EEPROM.put(eepromAdresseTagTableau, tagTableau);
}
 
//------------------------------------- Restaurer les TAG
void tagRestaurer()
{
	EEPROM.get(eepromAdresseTagTableau, tagTableau);       // On "regenere" le tasbleau tagTableau depuis l'EEPROM
}
 
//------------------------------------- Tester si TAG existe
int tagSiExiste(String tagTest)                            // Retourne > -1 si tag recherche est dans le tableau
{
	int tagIndex = -1;                                     // -1 = n'existe pas
 
	for (int i = 0; i < tagNbr; i++)
	{
		if ((String)tagTableau[i] == tagTest)
		{
			tagIndex = i;                                  // Memoriser l'index et quitter la boucle
			break;
		}
	}
	return tagIndex;                                       // On retourne l'index du tag teste
}
 
//------------------------------------- Lister les TAG
void tagListe()                                            
{
	Serial.println("\nListe des TAG (" + String(tagNbr) + ")");
	for (int i = 0; i < tagNbr; i++)
	{
		Serial.println("TAG #" + String(i) + " = " + tagTableau[i]);
	}
	Serial.println("");
}

A+
Cordialement
jpbbricole

[Jay M]

La classe String est sans doute superflue.

Vous pouvez déclarer votre tableau de UID connus sous forme de tableau de caractères

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
const char tableau[][15] {
  "135 120 254 44",
  "135 120 254 43",
  "135 120 254 42",
  "135 120 254 41",
  "135 120 254 40"
};

Et on le stocke en EEPROM par un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
const uint16_t adresseDebut = 0;
EEPROM.put(adresseDebut, tableau);

Si on veut remplir dynamiquement un UID on peut utiliser strcpy() ou strncpy(), par exemple en case 0

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

strcpy(tableau[0], “135 246 221 22”); // s’assurer de ne pas avoir plus de 14 caractères !!!

[cobra38]

merci Jay M et jpbbricole
pour vos precieuses infos

j'aurai juste une question à laquelle je ne trouve pas de réponse

on dimensionne
const int tagSize = 15; // Taille d'un TAG
soit une longueur de 15 caractères
or les N° UID font au max : "255 255 255 255" soit 15 avec les espaces
le test que j'ai effectué à partir du tableau suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
  tagEnregistrer("255 255 255 255", 0);
  tagEnregistrer("255 255 255 255", 1);
  tagEnregistrer("255 255 255 255", 2);
  tagEnregistrer("255 255 255 255", 3);
  tagEnregistrer("255 255 255 255", 4);

me donne après enregistrement la liste suivante pour un tag = "135 120 254 36"

Liste des TAG (5)
TAG #0 = 135 120 254 3
TAG #1 = 255 255 255 25
TAG #2 = 255 255 255 25
TAG #3 = 255 255 255 25
TAG #4 = 255 255 255 25

soit un décalage pourtant avec tagSize = 15

ne serait-il pas plus simple de passer en HEX soit :
tagSize = 12

cordialement
pascal

[jpbbricole]

Bonjour Pascal

Ne cherche pas le coupable trop loin!!! , j'avais bêtement copié et collé l'exemple de l'article #5
Tu as raison, un UID 255 255 255 255 ce qui fait 15 caractères donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int tagSize = 16;                // 15+1 pour la terminaison de la variable, un octet à 0

A+
Cordialement
jpbbricole

[cobra38]

Bonjour jpbbricole

le coupable c'est bien moi , j'aurai du vérifier
car pour l'instant je sui repassé en HEX mais j'ai le même problè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
 
MDP ADMIN
Scanner une Nouvelle Carte
Carte detectée
UID de tag : BA 69 97 15
N° Carte à enregistrer :  BA 69 97 15
TAG  BA 69 97 15 INCONNU
 
Liste des TAG (5)
TAG #0 =  BA 69 97 1
TAG #1 = FF FF FF FF
TAG #2 = FF FF FF FF
TAG #3 = FF FF FF FF
TAG #4 = FF FF FF FF

j'avoue ne pas comprendre du tout le pb ....
( pour info j'ai mis : tagSize = 12 )

Cordialement
pascal

[jpbbricole]

Bonjour Pascal

cette valeur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int tagSize = 16;                // Taille d'un TAG16

n'est pas critique, même en diminuant la taille des TAG, tu peux laisser 16, comme ça tu est assez "large", au pire tu gaspilles quelques octets.
J'ai vérifié, en ayant un tagSize à 16 et un TAG à 11, il n'y a pas de caractère(s) "parasite(s)", en fin de variable à la lecture en EEPROM.
Pour tester j'ai légèrement modifié void tagList()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
//------------------------------------- Lister les TAG
void tagListe()                                            
{
	Serial.println("\nListe des TAG (" + String(tagNbr) + ")");
	for (int i = 0; i < tagNbr; i++)
	{
		Serial.println("TAG #" + String(i) + " = " + tagTableau[i] + "/");
	}
	Serial.println("");
}

A+
Cordialement
jpbbricole

[cobra38]

désolé jpbbricole


mais je reste toujours avec ce décalage inexpliqué ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
MDP ADMIN
Scanner une Nouvelle Carte
Carte detectée
UID de tag : BA 69 97 15
N° Carte à enregistrer :  BA 69 97 15
TAG  BA 69 97 15 INCONNU
 
Liste des TAG (5)
TAG #0 =  BA 69 97 1/
TAG #1 = FF FF FF FF/
TAG #2 = FF FF FF FF/
TAG #3 = FF FF FF FF/
TAG #4 = FF FF FF FF/

Cordialement
pascal

[jpbbricole]

Bonsoir Pascal

Mets tout ton programme en ligne

A+
Cordialement
jpbbricole

[cobra38]

Voilà

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
 
// ***************************************************************
// *RFID + Clavier 
// Version D du 20191228
// ***************************************************************
 
 
//****************************************************************
// -------------------- Bibliotheque -----------------------------
//****************************************************************
#include <EEPROM.h>
#include <Wire.h>  // i2C Conection Library
#include <LiquidCrystal_PCF8574.h>
#include <Password.h>
#include <Keypad.h>
#include <SPI.h>
#include <deprecated.h> // inclut dasn la Bibliotheque MFRC522
#include <MFRC522.h>
#include <MFRC522Extended.h> // inclut dasn la Bibliotheque MFRC522
#include <require_cpp11.h> // inclut dasn la Bibliotheque MFRC522
 
//****************************************************************
//------------------- Raccordements ------------------------------
//****************************************************************
 
 
// Sorties ------------------- ----------------------------------
// Buzzer : Pin 7 // buzzer passif en Pin D7 et GND
// Relais : Pin 8 // Pilote selenoid de verrouillage de porte / entrée relais en broches D8
//***************************************************************
 
 
// Connection Module RFID RC522 ----------------------------------
// MOSI: Pin 11
// MISO: Pin 12
// SCK : Pin 13
// SS/SDA: Pin 10
// RST: Pin 9
// RQ: NC
// ----------- Definition ---------------------------------------
#define SS_PIN 10
#define RST_PIN 9
MFRC522 rfid(SS_PIN, RST_PIN);
String tagUID  ="" ;
String tagUID1 = "BA 69 97 15";
String tagUID2 = "67 EA 6E 60";
//String tagUID3 = "87 78 FE 24";
//*****************************************************************
 
// Afficheur LCD I2C ----------------------------------------------
// SDA : Pin A4
// SCL : Pin A5
LiquidCrystal_PCF8574 lcd(0x27);
//*****************************************************************
 
// Clavier matrice 4x4 --------------------------------------------
const byte ROWS = 4; // Lignes
const byte COLS = 4; // Colonnes
byte rowPins[ROWS] = { 6, 5, 4, 3 }; // Connexion clavier Lignes 1, 2, 3, 4 à ces broches Arduino.
byte colPins[COLS] = { A3, A2, A1, A0 }; // Connexion clavier Colonnes 1, 2, 3, 4 à ces broches Arduino.
char keys[ROWS][COLS] = { // Definition Clavier
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); // Creation du clavier
Password password1 = Password("1234"); //<-- PASSWORD1
Password password2 = Password("4329"); //<-- PASSWORD2
//****************************************************************
 
//****************************************************************
//------------ Constantes & Variables ----------------------------
//****************************************************************
 
bool  access = false;
const int buzzer = 7;   // buzzer passif en Pin D7 et GND
const int doorLock = 8; // Pilote selenoid de verrouillage de porte / entrée relais en broches D8
 
int alarm = 0;
uint8_t alarmStat = 0;
uint8_t maxError = 3;
 
unsigned long previousMillis = 0;
const long interval = 1000;
uint8_t pwMode = 0;
uint8_t pwPos = 0; 
uint8_t adminMode = 0;
 
 
String tag = "";
 
/*
const int tagNbr = 5;               // Nombre de TAG
int tagTableauIndice;               // Indice dans tagTableau
String tagTableau[tagNbr];          // Tableau des TAG
int eepromAdresseTagTableau;        // Adresse de depart en EEPROM
*/
 
int tagTableauIndice;                  // Indice dans tagTableau
const int tagNbr = 5;                  // Nombre de TAG
const int tagSize = 12;                // Taille d'un TAG
char tagTableau[tagNbr][tagSize];      // Tableau des TAG 12
int eepromAdresseTagTableau;           // Adresse de depart de l'enregistrement en EEPROM
int tagIndex;
 
 
 
 
// ******************************************************************
// ------------------------ SETUP -----------------------------------
// ******************************************************************
 
void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.setBacklight(255);
  SPI.begin();
  rfid.PCD_Init();
  rfid.PCD_DumpVersionToSerial(); // Affichage des données de la bibliothèque
  Serial.println(F("Scan PICC to see UID, type, and data blocks..."));
  keypad.addEventListener(keypadEvent); // ajouter événement pour le clavier
 
  pinMode(doorLock, OUTPUT);
  digitalWrite(doorLock, LOW);
 
  tone (buzzer,1200,100);
  lcd.setCursor (0, 0);
  lcd.print(F(" - DOOR LOCK - "));
  lcd.setCursor (0, 1);
  lcd.print(F("   - INIT -   "));
  delay (2000);
  lcd.clear();
  noTone (buzzer);
 
  eepromAdresseTagTableau = 0;       // Position en EEPROM du tableau des TAG tagTableau
  // Mettre ces lignes en remarque  quand tableau en EEPROM
  tagEnregistrer("FF FF FF FF", 0);
  tagEnregistrer("FF FF FF FF", 1);
  tagEnregistrer("FF FF FF FF", 2);
  tagEnregistrer("FF FF FF FF", 3);
  tagEnregistrer("FF FF FF FF", 4);
 
  tagRestaurer();
  tagListe();
 
}
 
//********************************************************************
// ------------------------ LOOP  ------------------------------------
//********************************************************************
 
void loop() {
 
  keypad.getKey();  // Lecture du clavier
  // si nb de tentative max
  if (alarm >= maxError) {
    ALARME()  ;
  }
  // si tentative en cours
  if (alarmStat == 0 && pwMode == 0 && adminMode == 0) {
    //lcd.setCursor (0, 0);
    //Serial.print(" -Systeme OK-  ");
    unsigned long currentMillis = millis();
 
    if (currentMillis - previousMillis >= interval) {
      //previousMillis = currentMillis;
      lcd.setCursor (0, 0);
      lcd.print(F("Scannez         "));
      lcd.setCursor (0, 1);
      lcd.print(F("une Carte       "));
    }
 
    if (currentMillis - previousMillis >= (3 * interval)) {
      previousMillis = currentMillis;
      lcd.setCursor (0, 0);
      lcd.print(F("Tapez            "));
      lcd.setCursor (0, 1);
      lcd.print(F("un Code '****'   "));
    }
  }
 
  // Attente d'une carte
  if ( ! rfid.PICC_IsNewCardPresent()) {
    return;
  }
  if ( ! rfid.PICC_ReadCardSerial()) {
    return;
  }
  //Reading from the card
  Serial.println("Carte detectée");
  //rfid.PICC_DumpToSerial(&(rfid.uid));
  //delay(2000);
 
  Serial.print("UID de tag :");
  String tag = "";
  byte caractere;
  for (byte i = 0; i < rfid.uid.size; i++)
  {
    Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(rfid.uid.uidByte[i], HEX);
    tag.concat(String(rfid.uid.uidByte[i] < 0x10 ? " 0" : " "));
    tag.concat(String(rfid.uid.uidByte[i], HEX));
  }
  /*{
    Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
    Serial.print(rfid.uid.uidByte[i], DEC);
    tag.concat(String(rfid.uid.uidByte[i] < 0x10 ? " 0" : " "));
    tag.concat(String(rfid.uid.uidByte[i], DEC));
  }*/
  tag.toUpperCase();
 
  if (adminMode == 1) {
    Serial.println();
    Serial.print("N° Carte à enregistrer : ");
    Serial.print(tag);
    // Tester si TAG existe 
      Serial.println();
      if (tagSiExiste(tag) > -1) {
         {Serial.println("TAG " + tag + " connu");}
      } else {
         {Serial.println("TAG " + tag + " INCONNU");}
         // Enregistrement dans EEPROM 
         tagEnregistrer(String(tag),tagIndex) ;
         tagListe();
      }
    /*EEPROM.put(eepromAdresseTagTableau, tagTableau);
    for (int i = 0; i < tagNbr; i++) 
      {
      Serial.println("TAG #" + String(i) + " = " + tagTableau[i]);
      }
    Serial.println("Carte :"+tag+" enregistrée"); */       
    adminMode = 0;
    pwMode= 0;
   }
  else
  {   
     // vérifier l'autorisation
 
    tagUID = tagTableau[0][12] ;      
    if (tag.substring(1) ==(tagUID))
    {
      Serial.println("Bienvenue!");
      lcd.setCursor (3, 0);
      lcd.print(F("- ACCES OK -  "));
      lcd.setCursor (0, 1);
      lcd.print("Carte Reconnue");
      ACCEPT ();
    }
    else if (tag.substring(1) == tagUID2)
    {
      Serial.println("Bienvenue!");
      lcd.setCursor (3, 0);
      lcd.print(F("- ACCES OK -  "));
      lcd.setCursor (0, 1);
      lcd.print("Carte Reconnue");
      ACCEPT ();
    }
   else {
      alarm = alarm + 1;
      Serial.println("Non Autorise!");
      lcd.setCursor (0, 0);
      lcd.print(F(" -ACCES REFUSE-"));
      lcd.setCursor (0, 1);
      lcd.print  ("Carte Invalide");
      RIJECT ();
    }
  }
} // Fin Loop
 
//*********************************************************************
void keypadEvent(KeypadEvent eKey) {
  switch (keypad.getState()) {
    case PRESSED:
      Serial.print("Pressed: ");
      Serial.println(eKey);
      tone (buzzer,200,100);
      pwMode = 1;
      pwPos = pwPos + 1;
      if (pwPos == 1) {
        lcd.clear();
      }
      lcd.setCursor (0, 0);
      lcd.print(F("Validez avec '*'"));
      if (pwPos < 5) {
        lcd.setCursor (5 + pwPos, 1);
        lcd.print(F("*"));
      }
 
      switch (eKey) {
        case '*': checkPassword(); break;
        //case '#':
        //  Serial.print("    ");
        //  password1.reset();
        //  break;
        default:
        password1.append(eKey);
        password2.append(eKey);
 
      }
  }
}
 
//*************************************************************************
void checkPassword() 
   { // test si Mode Normal
   if (password1.evaluate()){
    Serial.println("MDP Correct");
    lcd.setCursor (0, 1);
    lcd.print(F("   -Accepte-   "));
     ACCEPT ();
     password1.reset();
     pwPos = 0;  
   } // test si mode ADMIN
   else if (password2.evaluate()) { 
    Serial.println("MDP ADMIN");
    lcd.setCursor (0, 1);
    lcd.print(F("   -Accepte-   "));
      //ADMIN ();
      lcd.clear();
      lcd.setCursor (0, 0);
      lcd.print(F(" -Mode ADMIN- "));
      Serial.println("Scanner une Nouvelle Carte");
      password2.reset();
      adminMode = 1;
      pwPos = 0;
    }
   else {
    Serial.println("MDP Incorrect");
    lcd.setCursor (0, 1);
    lcd.print(F("   -Rejete-   "));
    alarm = alarm + 1;
    RIJECT ();
    password1.reset();
    password2.reset();
    pwPos = 0;
   }
}
 
//***********************************************************************
void ACCEPT () {
  lcd.clear();
  digitalWrite(doorLock, HIGH);
  tone (buzzer, 900);
  delay(100);
  tone (buzzer, 1200);
  delay(100);
  tone (buzzer, 1800);
  delay(200);
  noTone(buzzer);
  delay(600);
  lcd.setCursor (0, 1);
  lcd.print(F("Verrouillage:"));
  for (int i = 9; i > 0; i--) {
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval) {
      lcd.setCursor (0, 0);
      lcd.print(F("-PORTE OUVERTE-"));
    }
    if (currentMillis - previousMillis >= (2 * interval)) {
      previousMillis = currentMillis;
      lcd.setCursor (0, 0);
      lcd.print(F("               "));
    }
    lcd.setCursor (14, 1); lcd.print(i); lcd.print("s");
    delay (1000);
  }
  digitalWrite(doorLock, LOW);
  pwMode = 0;
  lcd.clear();
}
 
//***********************************************************************
void RIJECT () {
  tone (buzzer, 900);
  delay(200);
  noTone(buzzer);
  delay(200);
  tone (buzzer, 900);
  delay(200);
  noTone (buzzer);
  delay(500);
  pwMode = 0;
 
}
 
 
//*************************************************************************
void ALARME() {
  lcd.clear();
  lcd.setCursor (0, 1);
  lcd.print(F(" Attendre => "));
  for (int i = 30; i > 0; i--) {
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= interval) {
      lcd.setCursor (0, 0);
      lcd.print(F("- VERROUILLE -"));
    }
    if (currentMillis - previousMillis >= (2 * interval)) {
      previousMillis = currentMillis;
      lcd.setCursor (0, 0);
      lcd.print(F("               "));
    }
    tone (buzzer, 200, 500);
    lcd.setCursor (13, 1); lcd.print(i);
    if (i < 10) {
      lcd.setCursor (14, 1);
      lcd.print(F("s "));
    } else {
      lcd.setCursor (15, 1);
      lcd.print(F("s"));
    }
 
    delay (1000);
  }
  noTone (buzzer);
  alarmStat = 0;
  alarm = 0;
  lcd.clear();
}
 
 
//***************************************************************************
 
void tagRestaurer()    {
     EEPROM.get(eepromAdresseTagTableau, tagTableau);       // On "regenere" le tableau tagTableau depuis l'EEPROM
   } 
 
//***************************************************************************
 
void tagListe() {
 
    Serial.println("\nListe des TAG (" + String(tagNbr) + ")");
    for (int i = 0; i < tagNbr; i++)
    {
        Serial.println("TAG #" + String(i) + " = " + tagTableau[i]);
    }
    Serial.println("");
  }
 
//***************************************************************************
void tagEnregistrer(String tagNouveau, int tagIndex)
{
  tagNouveau.toCharArray(tagTableau[tagIndex],tagSize);
  EEPROM.put(eepromAdresseTagTableau, tagTableau);
}
 
 
//***************************************************************************
int tagSiExiste(String tagTest)                            // Retourne > -1 si tag recherche est dans le tableau
{
  int tagIndex = -1;                                     // -1 = n'existe pas
 
  for (int i = 0; i < tagNbr; i++)
  {
    if ((String)tagTableau[i] == tagTest)
    {
      tagIndex = i;                                  // Memoriser l'index et quitter la boucle
      break;
    }
  }
  return tagIndex;                                       // On retourne l'index du tag teste

[jpbbricole]

Bonsoir Pascal

Et si tu mets

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int tagSize = 16;                // Taille d'un TAG

?

A+
Cordialement
jpbbricole

[cobra38]

Bonsoir Pascal

Et si tu mets

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int tagSize = 16;                // Taille d'un TAG

?

A+
Cordialement
jpbbricole

çà décale aussi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Scanner une Nouvelle Carte
Carte detectée
UID de tag : BA 69 97 15
N° Carte à enregistrer :  BA 69 97 15
TAG  BA 69 97 15 INCONNU
 
Liste des TAG (5)
TAG #0 =  BA 69 97 15/   <= 
TAG #1 = FF FF FF FF/
TAG #2 = FF FF FF FF/
TAG #3 = FF FF FF FF/
TAG #4 = FF FF FF FF/

la vitesse peut-être, je suis en 9600 ?

pascal


PS : c'est ok maintenant , il s'agissait
du terme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
tag.concat(String(rfid.uid.uidByte[i] < 0x10 ? " 0" : " "));

qui introduisait un caractere " " avant le tag , d'où le décalage