Compteur Décompteur badge RFID

Bonjour,
je viens à vous en ce jour, âpres avoir utilisé un badge RFID pour incrémenter mon afficheur led 8*8 de la valeur 0 à 9. Etant 100%fonctionnel mon prof de programmation me demande de décrémenter l’afficheur dès que nous repassons une deuxième fois le même badge simulant une entrée et par la suite la sortie d’une porte.

Avez vous une idée pour réaliser cette décrémentation, mon prof me parle de tableau mais tout cela reste flou pour moi!

merci d’avance.

Melvin

Il va vous falloir mémoriser quel badge à déjà été présenté pour décider si vous incremetez ou décrémentez... où allez vous stocker les 9 informations?

justement nous ne savons pas ou stocker l’information, nous avons pensé à stocker les valeurs dans un tableau mais nous ne savons pas comment retourner piocher les valeurs dedans…

Avez vous un tableau qui liste tous les badges autorisés? Ou n'importe quel badge est OK?

En gros quand un badge se présente, vous le cherchez (une boucle en comparant l'identifiant du badge avec ceux connus autorisés) dans le tableau des badges autorisés et si vous le trouvez à l' index x alors vous allez regarder dans un second tableau à l'index x pour voir si la valeur est vrai ou faux. Sivrai vous passez à faux et décomptez (le badge était présent) si faux alors vous passez à vrai et incrémentez (le badge était absent)

Il faut bien sûr initialiser les deux tableaux correctement

Si vous n'avez pas une liste de badge autorisés et que tous les badges peuvent fonctionner alors quand un badge se présente vous vérifiez s'il est déjà dans un tableau si oui vous décomptez et vous l'effacez sinon vous le rajoutez dans le tableau dans une case vide ( si le nombre de badges peut-être illimité alors il faut gérer une liste chaînée par exemple plutôt qu'un tableau car vous ne saurez pas combien de mémoire allouer)

Voici le code comment intégrer la décrémentation par l’intermediaire du tableau, nous sommes bloqué…
La valeur est affiché sur une matrice de led 8*8 de 0 à 9 et l’incrémentation se fait bien…

code:

#include <SPI.h>
#include <RFID.h>
int nb_personne;
int identification[6];

int Max7219_pinCLK = A4;
int Max7219_pinCS = A2;
int Max7219_pinDIN = A5;

/* /////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////// */

RFID monModuleRFID(A1,2);
int UID[6]={};
int badgeRFID_1[6]= {39,115,30,95,21,0},
   badgeRFID_2[6]= {131,37,169,171,164,0},
   badgeRFID_3[6]= {18,250,216,53,5,0},
   badgeRFID_4[6]= {103,200,245,30,68,0},
   badgeRFID_5[6]= {244,209,94,13,118,0},
   badgeRFID_6[6]= {23,187,33,95,210,0},
   badgeRFID_7[6]= {33,146,216,53,94,0},
   badgeRFID_8[6]= {212,24,134,26,80,0},
   carteRFID_1[6]= {199,55,233,190,167,0},
   carteRFID_2[6]= {119,19,17,66,55,0};


   
bool RFID_Validation()
{
if (monModuleRFID.isCard()) {
   if (monModuleRFID.readCardSerial()) {        
       for(int i=0;i<=4;i++)
           {
             UID[i]=monModuleRFID.serNum[i];
             identification[i]=UID[i];
           }
       }
  
     if ((UID[0] == badgeRFID_1[0] && UID[1] == badgeRFID_1[1] && UID[2] == badgeRFID_1[2] && UID[3] == badgeRFID_1[3] && UID[4] == badgeRFID_1[4])||
         (UID[0] == badgeRFID_2[0] && UID[1] == badgeRFID_2[1] && UID[2] == badgeRFID_2[2] && UID[3] == badgeRFID_2[3] && UID[4] == badgeRFID_2[4])||
         (UID[0] == badgeRFID_3[0] && UID[1] == badgeRFID_3[1] && UID[2] == badgeRFID_3[2] && UID[3] == badgeRFID_3[3] && UID[4] == badgeRFID_3[4])||
         (UID[0] == badgeRFID_4[0] && UID[1] == badgeRFID_4[1] && UID[2] == badgeRFID_4[2] && UID[3] == badgeRFID_4[3] && UID[4] == badgeRFID_4[4])||
         (UID[0] == badgeRFID_5[0] && UID[1] == badgeRFID_5[1] && UID[2] == badgeRFID_5[2] && UID[3] == badgeRFID_5[3] && UID[4] == badgeRFID_5[4])||
         (UID[0] == badgeRFID_6[0] && UID[1] == badgeRFID_6[1] && UID[2] == badgeRFID_6[2] && UID[3] == badgeRFID_6[3] && UID[4] == badgeRFID_6[4])||
         (UID[0] == badgeRFID_7[0] && UID[1] == badgeRFID_7[1] && UID[2] == badgeRFID_7[2] && UID[3] == badgeRFID_7[3] && UID[4] == badgeRFID_7[4])||
         (UID[0] == badgeRFID_8[0] && UID[1] == badgeRFID_8[1] && UID[2] == badgeRFID_8[2] && UID[3] == badgeRFID_8[3] && UID[4] == badgeRFID_8[4])||
         (UID[0] == carteRFID_1[0] && UID[1] == carteRFID_1[1] && UID[2] == carteRFID_1[2] && UID[3] == carteRFID_1[3] && UID[4] == carteRFID_1[4])||
         (UID[0] == carteRFID_2[0] && UID[1] == carteRFID_2[1] && UID[2] == carteRFID_2[2] && UID[3] == carteRFID_2[3] && UID[4] == carteRFID_2[4]))
         {
             return 1;
             delay(1000);
             
         }
      else
         {
             return 0;
             delay(1000);
         }          
       monModuleRFID.halt();
 }

 
}

/* /////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////// */

suite code :

void Affichage_matricielle(int nb_personne)
{
switch (nb_personne) {

  
   case 0:                              // affiche la valeur 0
          Write_Max7219(1,B00111100);
          Write_Max7219(2,B01000010);
          Write_Max7219(3,B01000010);
          Write_Max7219(4,B01000010);
          Write_Max7219(5,B01000010);
          Write_Max7219(6,B01000010);
          Write_Max7219(7,B01000010);
          Write_Max7219(8,B00111100);
          
      break;

    
   case 1:                              // affiche la valeur 1
          Write_Max7219(1,B00001000);
          Write_Max7219(2,B00011000);
          Write_Max7219(3,B00101000);
          Write_Max7219(4,B01001000);
          Write_Max7219(5,B00001000);
          Write_Max7219(6,B00001000);
          Write_Max7219(7,B00001000);
          Write_Max7219(8,B00001000);
          
      break;

    
   case 2:                              // affiche la valeur 2    
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B00000010);
          Write_Max7219(3,B00000010);
          Write_Max7219(4,B01111110);
          Write_Max7219(5,B01000000);
          Write_Max7219(6,B01000000);
          Write_Max7219(7,B01000000);
          Write_Max7219(8,B01111110);
         
    break;

    
   case 3:                              // affiche la valeur 3
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B00000010);
          Write_Max7219(3,B00000010);
          Write_Max7219(4,B01111110);
          Write_Max7219(5,B00000010);
          Write_Max7219(6,B00000010);
          Write_Max7219(7,B00000010);
          Write_Max7219(8,B01111110);
          
    break;

    
   case 4:                              // affiche la valeur 4       
          Write_Max7219(1,B00001000);
          Write_Max7219(2,B00011000);
          Write_Max7219(3,B00101000);
          Write_Max7219(4,B01001000);
          Write_Max7219(5,B11111110);
          Write_Max7219(6,B00001000);
          Write_Max7219(7,B00001000);
          Write_Max7219(8,B00001000);
          
    break;

    
   case 5:                              // affiche la valeur 5
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B01000000);
          Write_Max7219(3,B01000000);
          Write_Max7219(4,B01111110);
          Write_Max7219(5,B00000010);
          Write_Max7219(6,B00000010);
          Write_Max7219(7,B00000010);
          Write_Max7219(8,B01111110);
          
    break;

    
   case 6:                              // affiche la valeur 6
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B01000000);
          Write_Max7219(3,B01000000);
          Write_Max7219(4,B01111110);
          Write_Max7219(5,B01000010);
          Write_Max7219(6,B01000010);
          Write_Max7219(7,B01000010);
          Write_Max7219(8,B01111110);
          
    break;


   case 7:                              // affiche la valeur 7
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B01000010);
          Write_Max7219(3,B00000100);
          Write_Max7219(4,B00001000);
          Write_Max7219(5,B00001000);
          Write_Max7219(6,B00001000);
          Write_Max7219(7,B00001000);
          Write_Max7219(8,B00001000);
          
    break;


   case 8:                              // affiche la valeur 8
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B01000010);
          Write_Max7219(3,B01000010);
          Write_Max7219(4,B01111110);
          Write_Max7219(5,B01000010);
          Write_Max7219(6,B01000010);
          Write_Max7219(7,B01000010);
          Write_Max7219(8,B01111110);
    break;


   case 9:                              // affiche la valeur 9
          Write_Max7219(1,B01111110);
          Write_Max7219(2,B01000010);
          Write_Max7219(3,B01000010);
          Write_Max7219(4,B01111110);
          Write_Max7219(5,B00000010);
          Write_Max7219(6,B00000010);
          Write_Max7219(7,B00000010);
          Write_Max7219(8,B01111110);
    break;




    
  }
}

void Write_Max7219_byte(unsigned char DATA) 
{   
          unsigned char i;
     digitalWrite(Max7219_pinCS,LOW);      
     for(i=8;i>=1;i--)
        {        
           digitalWrite(Max7219_pinCLK,LOW);
           digitalWrite(Max7219_pinDIN,DATA&0x80);// Extracting a bit data
           DATA = DATA<<1;
           digitalWrite(Max7219_pinCLK,HIGH);
         }                                 
}

void Write_Max7219(unsigned char address,unsigned char dat)
{
      digitalWrite(Max7219_pinCS,LOW);
      Write_Max7219_byte(address);           //address,code of LED
      Write_Max7219_byte(dat);               //data,figure on LED 
      digitalWrite(Max7219_pinCS,HIGH);
}

//Initialisation du module Max 7219 
void Init_MAX7219(void)
{
Write_Max7219(0x09, 0x00);       //decoding :BCD
Write_Max7219(0x0a, 0x03);       //brightness 
Write_Max7219(0x0b, 0x07);       //scanlimit;8 LEDs
Write_Max7219(0x0c, 0x01);       //power-down mode:0,normal mode:1
Write_Max7219(0x0f, 0x00);       //test display:1;EOT,display:0
}

void setup()
{
nb_personne=0;
pinMode(Max7219_pinCLK,OUTPUT);
pinMode(Max7219_pinCS,OUTPUT);
pinMode(Max7219_pinDIN,OUTPUT);
pinMode(7,INPUT);
delay(50);  //Initialiser
Init_MAX7219();

SPI.begin();
monModuleRFID.init();
}


void loop()
{
if(RFID_Validation() == 1)
  {
    nb_personne++;
    Affichage_matricielle(nb_personne);
    delay(1000);  
  }
if(digitalRead(7) == HIGH)
  {nb_personne--;
  delay(500);
  Affichage_matricielle(nb_personne);}

}

sincèrement quand vous voyez cela, vous ne vous dites pas que c'est "chiant" de taper tout ce code?

 if ((UID[0] == badgeRFID_1[0] && UID[1] == badgeRFID_1[1] && UID[2] == badgeRFID_1[2] && UID[3] == badgeRFID_1[3] && UID[4] == badgeRFID_1[4]) ||
        (UID[0] == badgeRFID_2[0] && UID[1] == badgeRFID_2[1] && UID[2] == badgeRFID_2[2] && UID[3] == badgeRFID_2[3] && UID[4] == badgeRFID_2[4]) ||
        (UID[0] == badgeRFID_3[0] && UID[1] == badgeRFID_3[1] && UID[2] == badgeRFID_3[2] && UID[3] == badgeRFID_3[3] && UID[4] == badgeRFID_3[4]) ||
        (UID[0] == badgeRFID_4[0] && UID[1] == badgeRFID_4[1] && UID[2] == badgeRFID_4[2] && UID[3] == badgeRFID_4[3] && UID[4] == badgeRFID_4[4]) ||
        (UID[0] == badgeRFID_5[0] && UID[1] == badgeRFID_5[1] && UID[2] == badgeRFID_5[2] && UID[3] == badgeRFID_5[3] && UID[4] == badgeRFID_5[4]) ||
        (UID[0] == badgeRFID_6[0] && UID[1] == badgeRFID_6[1] && UID[2] == badgeRFID_6[2] && UID[3] == badgeRFID_6[3] && UID[4] == badgeRFID_6[4]) ||
        (UID[0] == badgeRFID_7[0] && UID[1] == badgeRFID_7[1] && UID[2] == badgeRFID_7[2] && UID[3] == badgeRFID_7[3] && UID[4] == badgeRFID_7[4]) ||
        (UID[0] == badgeRFID_8[0] && UID[1] == badgeRFID_8[1] && UID[2] == badgeRFID_8[2] && UID[3] == badgeRFID_8[3] && UID[4] == badgeRFID_8[4]) ||
        (UID[0] == carteRFID_1[0] && UID[1] == carteRFID_1[1] && UID[2] == carteRFID_1[2] && UID[3] == carteRFID_1[3] && UID[4] == carteRFID_1[4]) ||
        (UID[0] == carteRFID_2[0] && UID[1] == carteRFID_2[1] && UID[2] == carteRFID_2[2] && UID[3] == carteRFID_2[3] && UID[4] == carteRFID_2[4]))
    {

les boucles c'est quand même fait pour ça...

Tenez regardez un peu ce bout de code, exécutez le avec la console Série réglée à 115200 bauds

#define tailleBadgeCode 6

// on définit un nouveau type, tagID_t, qui décrit un identifiant de badge par son code
// c'est simplement un tableau de 6 octets

typedef  uint8_t tagID_t[tailleBadgeCode];

// on définit un nouveau type, badge_t, qui décrit un badge
// par son identifiant de badge
// et un booléen qui mémorise s'il est présent sur site ou pas

typedef  struct  {
  tagID_t code;
  boolean present;
} badge_t;


// on crée un tableau de badges, badgeAutorises, qui comprend tous les badges connus
// et on initialise la valeur du code des badges ainsi que leur absence du site (false)
// NOTE: L'initialisation sous cette forme n'est possible que lors de la déclaration des variables

badge_t badgeAutorises[] = {
  {{39, 115, 30, 95, 21, 0}, false},
  {{131, 37, 169, 171, 164, 0}, false},
  {{18, 250, 216, 53, 5, 0}, false},
  {{103, 200, 245, 30, 68, 0}, false},
  {{244, 209, 94, 13, 118, 0}, false},
  {{23, 187, 33, 95, 210, 0}, false},
  {{33, 146, 216, 53, 94, 0}, false},
  {{212, 24, 134, 26, 80, 0}, false},
  {{199, 55, 233, 190, 167, 0}, false},
  {{119, 19, 17, 66, 55, 0}, false}
};

// On calcule le nombre de badges connus
const uint8_t nbBadgesAutorises = sizeof(badgeAutorises) / sizeof(badgeAutorises[0]);

// ça c'est juste pour la démo, on crée 4 identifiants de badge comme s'ils avaient été
// passés sur le lecteur de badge pour simuler leur passage plus tard
// il y a 3 badges autorisés et un non connu
tagID_t badgeCorrect1   = {23, 187, 33, 95, 210, 0};
tagID_t badgeCorrect2   = {131, 37, 169, 171, 164, 0};
tagID_t badgeCorrect3   = {33, 146, 216, 53, 94, 0};
tagID_t badgeIncorrect  = {23, 187, 33, 95, 211, 0};

// -----------------------------------------------------
// fonction qui test un badge
// vérifie qu'il est autorisé et si oui inverse le booléen de présence
// retourne si un badge est autorisé et si oui initialise son index
// -----------------------------------------------------

boolean passeBadge(tagID_t & monBadgeID, uint8_t &index)
{
  boolean trouve;

  for (byte i = 0; i < nbBadgesAutorises; i++) {
    trouve = true;
    for (byte j = 0; trouve && (j < tailleBadgeCode); j++) {
      trouve = badgeAutorises[i].code[j] == monBadgeID[j];
    }
    if (trouve) {
      index = i;
      badgeAutorises[index].present = !badgeAutorises[index].present; // on inverse sa situation
      break;
    }
  }
  return trouve;
}


// -----------------------------------------------------
// fonction qui compte le nombre de badges présents sur site
// -----------------------------------------------------

uint8_t comptePresent()
{
  uint8_t compte = 0;
  for (byte i = 0; i < nbBadgesAutorises; i++)
    if (badgeAutorises[i].present) compte++;
  return compte;
}


// -----------------------------------------------------
void setup() {
  Serial.begin(115200);
  for (byte i = 0; i < nbBadgesAutorises; i++) {
    for (byte j = 0; j < tailleBadgeCode; j++) {
      Serial.print(badgeAutorises[i].code[j]); Serial.print(" ");
    }
    if (badgeAutorises[i].present) Serial.println("\t\tPresent");
    else Serial.println("\t\tAbsent");
  }

  Serial.println("\n --------- COMPTE DES PRESENTS --------");
  // ===== EXEMPLE DE COMMENT ON TRAITE UN BADGE ======
  uint8_t index;

  Serial.println(comptePresent());

  passeBadge(badgeCorrect1, index);   // ON EN PASSE UN DE CONNU
  Serial.println(comptePresent());

  passeBadge(badgeIncorrect, index); // ON EN PASSE UN DE PAS CONNU
  Serial.println(comptePresent());

  passeBadge(badgeCorrect2, index);   // ON EN PASSE UN AUTRE DE CONNU
  Serial.println(comptePresent());

  passeBadge(badgeCorrect3, index);   // ON EN PASSE UN AUTRE DE CONNU
  Serial.println(comptePresent());

  passeBadge(badgeCorrect2, index);   // Le second s'en va
  Serial.println(comptePresent());

  passeBadge(badgeCorrect1, index);   // Le premier s'en va
  Serial.println(comptePresent());

  passeBadge(badgeCorrect3, index);   // Le 3ème s'en va
  Serial.println(comptePresent());

}

// -----------------------------------------------------
void loop() {}

vous devriez avoir en sortie (console à 115200 bauds)

39 115 30 95 21 0 		Absent
131 37 169 171 164 0 		Absent
18 250 216 53 5 0 		Absent
103 200 245 30 68 0 		Absent
244 209 94 13 118 0 		Absent
23 187 33 95 210 0 		Absent
33 146 216 53 94 0 		Absent
212 24 134 26 80 0 		Absent
199 55 233 190 167 0 		Absent
119 19 17 66 55 0 		Absent

 --------- COMPTE DES PRESENTS --------
0
1
1
2
3
2
1
0

est-ce que ça vous donne une idée?

Ah oui effectivement!
je n'ais pas atteint un tel niveau de programmation pour sortir ce genre de code!
je testerai celui ci mercredi et vous tiens aux nouvelles.

merci encore et bonne soirée!

ne vous laissez pas impressionner par la définition des type (typedef) c'est juste pour simplifier l'écriture.

sinon ce ne sont "que" des boucles qui font des tests --> on parcourt chaque badges connu, pour chaque badge on regarde chacun des 6 codes pour voir s'ils sont identiques et si oui c'est qu'on a trouvé le bon.

Une struct c'est juste un moyen sympa de regrouper ensemble des choses qui vont ensemble. par exemple vous pourriez avoir

[color=red]typedef[/color] [color=blue]struct {[/color]
    byte [color=green]heure[/color];
    byte [color=green]minute[/color];
    byte [color=green]seconde[/color];
[color=blue]}[/color] [color=red]instant[/color];

ça veut dire je définis un nouveau type (avec le mot clé [color=red]typedef[/color]) qui va s'appeler instant et qui est composé du regroupement (une structure, d'ou le [color=blue]struct[/color]) de 3 attributs de type octet (byte) qui s'appellent heure, minute, seconde

comme ça si dans votre code vous voulez avoir deux variables qui représentent des instants, vous pouvez maintenant déclarer

instant t1, t2;

ensuite pour accéder au éléments de t1 ou t2 on fait simplement t1.heure ou t1.minute ou t1.seconde

ce n'est pas trop compliqué, hein ? et c'est quand même plus joli que de déclarer heure1, minute1, seconde1 et heure2, minute2, seconde2.

et si vous vouliez un tableau de 100 instants bien on fait

instant tableau[100]; // accès par tableau[n].heure, tableau[n].minute, tableau[n].seconde pour l'élément n

ça serait bcp plus galère de faire 300 variables à la main!