Je ne vois pas trop le problème.
Jusqu'à présent on avait une liste de badges pour ouvrir une poubelle, et maintenant il y a plusieurs poubelles ?
Qu'est ce que cela veut dire ? Un lecteur RFID par poubelle ?
Oui mon projet est fais sur une poubelle et il y a un lecteur RFID sur (chaque) poubelle. Je dois donc faire
en sorte que chaque badge appartient a une poubelle
Est ce que cela veut dire que :
- il y a plusieurs cartes ARDUINO avec chacune un lecteur RFID ?
- il y a plusieurs lecteurs sur une seule carte ARDUINO ?
Dans le premier cas il faudra charger un sketch ayant chacun sa liste de cartes.
Dans le deuxième cas, il faut multiplier le nombre d'instances :
Il faut une broche PN532_SS par lecteur.
Pour trois poubelles :
Adafruit_PN532 nfc1(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS1);
Adafruit_PN532 nfc2(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS2);
Adafruit_PN532 nfc3(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS3);
// ou (si tu as utilisé le SPI hardware (SCK = 13, MOSI = 11, MISO = 12)
Adafruit_PN532 nfc(PN532_SS1);
Adafruit_PN532 nfc(PN532_SS2);
Adafruit_PN532 nfc(PN532_SS3);
Ensuite dans le setup() il faut initialiser chaque lecteur.
Ensuite dans la loop() if faut lire chaque lecteur.
Et bien entendu il faut 3 listes de cartes.
Dans mon projet je n'ai que une carte Arduino Uno , un shield RFID (PN532) en I2C ainsi que des cartes mifare.
Mais dans le contexte du projet il y aurai plusieurs poubelle, je dois donc faire en sorte que ma poubelle est
un identifiant ou un badge pourra y accéder. Es-ce donc le code que tu m'a dit ?
Il faudrait être un peut plus clair.
Donc on résume :
- 1 ARDUINO
- 1 lecteur RFID
- plusieurs cartes
- chaque carte ouvre une poubelle
Dans ce cas il faut associer chaque carte avec une poubelle :
uint32_t knownCards[] = {0xB8312200, 0xCBC3F5A4, 0xA01A2300, 0xDBCDF695};
int nCards = (sizeof(knownCards) / sizeof(knownCards[0]));
int checkCardUID(uint32_t uid)
{
for (int n = 0 ; n < nCards ; n++) {
if (uid == knownCards[n]) {
return n;
}
}
return -1;
}
// ... dans loop() :
int poubelle = checkCardUID(cardid);
if (poubelle >= 0) {
Serial.println("carte reconnue");
Serial.print("N°"); Serial.println(poubelle);
// ouvrir telle ou telle poubelle en fonction du N°
}
else {
Serial.println("carte NON reconnue");
}
checkCardUID retourne le N° de poubelle.
Ensuite tu ouvres la poubelle 0, 1, 2 ou 3.
Je pense t'avoir un peu embrouillé mais je vais essayé d’être plus claire.
Oui j'ai bien :
1 ARDUINO
- 1 lecteur RFID
- plusieurs cartes
Enfaîte dans mon programme il faut juste que si le badge appartient a l'identifiant de la poubelle la
poubelle s'ouvre et si il n'y appartient pas elle ne s'ouvre pas
exemple : pour poubelle N°1
la carte 0xDBCDF695 appartient a la poubelle N°1 donc l'acces est autorisée
la carte 0xA01A2300 appartient a la poubelle N°3 donc l'acces est refusée
Il faut juste faire comme je disais précédemment.
Ensuite je ne connais pas la méthode utilisée pour ouvrir la bonne poubelle (solénoïde, relais, etc.). Je peux difficilement en dire plus.
D'accord Merci beaucoup pour ton aide.
Une derniere chose (je l'espere ^^) dans ce code :
uint32_t knownCards[] = {0xB8312200, 0xCBC3F5A4, 0xA01A2300, 0xDBCDF695};
int nCards = (sizeof(knownCards) / sizeof(knownCards[0]));
int checkCardUID(uint32_t uid)
{
for (int n = 0 ; n < nCards ; n++) {
if (uid == knownCards[n]) {
return n;
}
}
return -1;
}
// ... dans loop() :
int poubelle = checkCardUID(cardid);
if (poubelle >= 0) {
Serial.println("carte reconnue");
Serial.print("N°"); Serial.println(poubelle);
// ouvrir telle ou telle poubelle en fonction du N°
}
else {
Serial.println("carte NON reconnue");
}
apres plusieurs essai, je ne vois pas ou mettre le numero de la poubelle que je veux, Cela m'ecris
toujours Carte reconnu avec le numero mais jamais carte non reconnu car ce n'est pas la bonne carte
pour la bonne poubelle
A partir du moment où la carte figure dans la liste l'affichage de "carte reconnue" est normal.
Simplement, le N° affiché doit différer en fonction de la carte.
Ensuite à toi d'ouvrir la poubelle N° 0, 1, 2 ou 3 en fonction du N°.
Je peux difficilement deviner comment ouvrir la poubelle. Qu'utilises tu comme matériel pour l'ouverture ?
Rappel de la question #26 :
Ensuite je ne connais pas la méthode utilisée pour ouvrir la bonne poubelle (solénoïde, relais, etc.). Je peux difficilement en dire plus.
Il doit bien exister un moyen physique pour l'ouverture ?
c'est assez dur a expliquer,
On va dire que j'ai la poubelle N°2 et bien seul le badge qui lui appartient pourra y accedé, mais si
le badge n'appartient pas a cette poubelle il devra simplement dire accès refusé et nous dire qu'il
n'appartient pas a la bonne poubelle (ex : poubelle N°3)
Dans mon projet nous somme plusieurs et chacun a sa partie, moi je doit identifier le propriétaire
de la poubelle, je devrai par la suite mettre des led... mais ce n'est pas moi qui m'occupe de
l'ouverture physique
On va résumer :
- 1 ARDUINO
- 1 lecteur RFID
- plusieurs cartes
- plusieurs poubelles
L'usager présente sa carte.
La carte est reconnue comme faisant partie de la liste des cartes autorisées ou pas.
Si la carte est reconnue, le système déverrouille la poubelle correspondant à la carte.
Ce que tu veux est que le système affiche "CARTE REFUSÉE" en reconnaissant la carte N°1, sachant que l'usager veut ouvrir la poubelle N°3.
Bien, mais comment informes-tu le système que l'usager veut ouvrir la poubelle N°3 ? ? ?
La répartition des tâches c'est bien, mais le partage des informations, c'est mieux, et les réunions d'avancement c'est encore mieux.
En tant que développeur sur systèmes monétiques je peut te dire que :
Un système monétique possède :
- un interface homme-machine qui permet de sélectionner le produit à délivrer
- un organe de paiement (monnayeur, carte à puce, RFID, etc.)
- des moyens de paiement (monnaie, carte bancaire, carte abonné, etc.)
Ici le produit à délivrer est l'ouverture d'une poubelle parmi N.
L'organe de paiement est le lecteur RFID.
Le moyen de paiement est une carte abonné RFID.
S'il faut sélectionner le N° de poubelle à ouvrir avant de présenter la carte cela suppose un organe de saisie (clavier, écran tactile, etc.).
Le lecteur RFID peut aussi faire partie de l'interface homme-machine car il est possible d'associer N° de carte / produit à délivrer.
Donc la solution la plus simple est de :
- lire la carte
- si la carte est valide :
- ouvrir la poubelle correspondant au N° de carte
- signaler quelle est la poubelle ouverte (le couvercle se lève, une LED s'allume, etc.)
- sinon
- afficher "CARTE INVALIDE", allumer éventuellement une LED rouge, etc.
Non, je n'ai qu'une poubelle, il y a un lecteur RFID sur chaque poubelle car c'est une poubelle personnel.
exemple:
l'utilisateur passe sa carte si elle appartient a cette poubelle la poubelle s'ouvre mais il ne faut pas
que le badge de quelqu'un d'autre puisse l'ouvrir même si il ont le même lecteur RFID
On passe de contradiction en contradiction : post #25
ox00:
Je pense t'avoir un peu embrouillé mais je vais essayé d’être plus claire.Oui j'ai bien :
1 ARDUINO
- 1 lecteur RFID
- plusieurs cartes
Enfaîte dans mon programme il faut juste que si le badge appartient a l'identifiant de la poubelle la
poubelle s'ouvre et si il n'y appartient pas elle ne s'ouvre pas
exemple : pour poubelle N°1
la carte 0xDBCDF695 appartient a la poubelle N°1 donc l'acces est autorisée
la carte 0xA01A2300 appartient a la poubelle N°3 donc l'acces est refusée
Je vais te poser une dernière question :
- combien de poubelles en tout ?
- combien d'ARDUINO en tout ?
- combien de lecteurs RFID en tout ?
Parc que là on tourne franchement en rond ...
Si cela continue ce sera sans moi 
Sorry 
, meme-moi j'ai l'impression de m'embrouiller.
je vais te resumé :
- 1 ARDUINO
- 1 lecteur RFID
- plusieurs cartes
- 1 poubelle personnel
Je doit choisir et mettre en œuvre un système d'identification de l'utilisateur à des fins d'autorisation d'accès.
L'utilisateur va venir jeté ses déchets, il va donc déverrouillé SA poubelle mais il ne faut pas que
quelqu'un qui a le même lecteur RFID chez lui puisse déverrouillé MA poubelle (ce n'est pas un endroit a
local a poubelle, c'est un poubelle personnel par maison, pour chaque client).
Il suffit donc d'avoir une seule carte acceptée dans la liste :
uint32_t knownCards[] = {0xB8312200};
A la limite la liste ne sert plus à rien s'il y a une seule carte acceptée par lecteur.
if (cardid == 0xB8312200) {
Serial.println(F("carte reconnue"));
// ACTION : ouvrir poubelle
}
else {
Serial.println(F("carte non reconnue"));
}
Et donc il y aura pour chaque client un sketch différent.
D'accord mercii 
voici donc mon programme actuel :
#include <Wire.h>
#include <Adafruit_PN532.h>
// If using the breakout or shield with I2C, define just the pins connected
// to the IRQ and reset lines. Use the values below (2, 3) for the shield!
#define PN532_IRQ (2)
#define PN532_RESET (3) // Not connected by default on the NFC Shield
// Or use this line for a breakout or shield with an I2C connection:
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);
int led_rouge = 13;
void setup(void) {
pinMode(led_rouge, OUTPUT);
Serial.begin(115200);
Serial.println("Hello!");
nfc.begin();
// configure board to read RFID tags
nfc.SAMConfig();
}
void loop(void) {
uint8_t success;
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer to store the returned UID
uint8_t uidLength; // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
// Wait for an ISO14443A type cards (Mifare, etc.). When one is found
// 'uid' will be populated with the UID, and uidLength will indicate
// if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength);
if (success) {
Serial.print(" UID Value: "); // Display some basic information about the card
nfc.PrintHex(uid, uidLength);
if (uidLength == 4)
{
// We probably have a Mifare Classic card ...
uint32_t cardid = uid[0];
cardid <<= 8;
cardid |= uid[1];
cardid <<= 8;
cardid |= uid[2];
cardid <<= 8;
cardid |= uid[3];
Serial.print("Seems to be a Mifare Classic card #");
Serial.println(cardid);
if (checkCardUID(cardid) == true) {
Serial.println("ACCES AUTORISE"); // ACTION : ouvrir poubelle
// programme Alan
}
else {
Serial.println("ACCES REFUSE"); // ACTION : sinon ne pas ouvrir poubelle
digitalWrite(led_rouge, HIGH); // allumer la led
delay(500);
digitalWrite(led_rouge, LOW); // éteindre la led
}
}
}
delay(500);
}
uint32_t knownCards[] = {0xB8312200, 0xCBC3F5A4};
int nCards = (sizeof(knownCards) / sizeof(knownCards[0]));
bool checkCardUID(uint32_t uid)
{
for (int n = 0 ; n < nCards ; n++) {
if (uid == knownCards[n]) {
return true;
}
}
return false;
}
Je doit le diviser en plusieurs fonction (sur plusieurs onglet) une qui renvoie le code de la carte
et une autre qui l'accepte ou la refuse, après de nombreuses tentative je n'y arrive
toujours pas. Quelqu'un sait comment faire ?
Plusieurs fichiers pour si peu ?
Si tu y tiens voilà le principe :
uid.h
#include <Arduino.h>
extern bool checkCardUID(uint32_t uid);
uid.cpp
#include "uid.h"
uint32_t knownCards[] = {0xB8312200, 0xCBC3F5A4};
int nCards = (sizeof(knownCards) / sizeof(knownCards[0]));
bool checkCardUID(uint32_t uid)
{
for (int n = 0 ; n < nCards ; n++) {
if (uid == knownCards[n]) {
return true;
}
}
return false;
}
Au début du sketch, il faut inclure uid.h :
#include "uid.h"
Et bien entendu tu retires du sketch le code de uid.cpp
Je suppose que tu sais créer un onglet (petit bouton en haut à droite) ?