IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
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

Arduino Discussion :

Problème de référence et arrêt du décompte


Sujet :

Arduino

  1. #1
    Nouveau membre du Club
    Homme Profil pro
    pompier
    Inscrit en
    janvier 2020
    Messages
    68
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Eure et Loir (Centre)

    Informations professionnelles :
    Activité : pompier

    Informations forums :
    Inscription : janvier 2020
    Messages : 68
    Points : 29
    Points
    29
    Par défaut Problème de référence et arrêt du décompte
    bonjour,

    j'ai un code de 3 jeux consécutifs.
    Lancement automatique du 1er et le second se déclenche à la réussite du premier et bis repetita.

    Lors du 3ème jeu, il s'agit de rentrer le code référence rouge, si ok idem pour un nouveau code où il faut donner la référence bleue.

    a la réussite du code rouge,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    if (color == "Red") {
          Serial.println("Code rouge ok");
          code_tape[4] = {0}; //on réinitialise le code_tape
          choisirCarteBleue();
          return INCHANGE;
        }
    Quand je fais un programme avec uniquement le jeu 3, le renvoi carte bleue fonctionne avec
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    return choisirCarteBleue();
    Faut-il créer un tableau du type
    t_taskColor ['Red','Blue'];

    et remplacer void ChoisirCarteRouge() par t_taskColorRed

    Sinon au lancement du jeu3, le decompte s'arrête et ne change que lorsqu'un code est tapé, je suppose que c'est normal, dommage. Peut-on y remédier???

    Merci par avance pour votre retour, il y a-t-il un cours pour le renvoi de tâche???

    le code complet
    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
    //***************************
    //Bibliotheques, variables...
    //***************************
     
     
    //initialisation du clavier
    #include <Keypad.h> //include keypad library - first you must install library (library link in the video description)
     
    //initialisation du LCD I2C
    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>
     
    LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display
     
    //Partie tableau des differents jeux
    typedef  int16_t t_taskID;
    const t_taskID INCHANGE = -1;
     
    typedef void (*t_setupFunc)();      // on défint le type t_setupFunc comme pointeur sur fonction retournant rien
    typedef t_taskID (*t_loopFunc)();  // on défint le type t_loopFunc comme pointeur sur fonction retournant un N°de tâche
    typedef void (*t_cleanupFunc)();    // on défint le type t_cleanupFunc comme pointeur sur fonction retournant rien
     
    // une tâche va consister en 3 pointeurs de fonctions
    struct t_task {
      t_setupFunc taskSetup;
      t_loopFunc taskLoop;
      t_cleanupFunc taskCleanUp;
    };
     
    // *********************************************
    // pour pouvoir définir le tableau des tâches
    // On pré-annonce les fonctions de nos tâches. (forward declaration)
    // Leur code viendra plus tard.
     
    // le Menu
    /*void setupMenu();
      t_taskID loopMenu();
      void finMenu();*/
     
    // le jeu 1
    void setupJeu1();
    t_taskID loopJeu1();
    void finJeu1();
     
    // le Jeu2
    void setupJeu2();
    t_taskID loopJeu2();
    void finJeu2();
     
    // le Jeu3
    void setupJeu3();
    t_taskID loopJeu3();
    void finJeu3();
     
    // la fin
    void setupEnd();
    t_taskID loopEnd();
    void finEnd();
     
    // *********************************************
     
    // définir le tableau des tâches
    t_task taskList[] = {
      //{setupMenu, loopMenu, finMenu},
      {setupJeu1, loopJeu1, finJeu1},
      {setupJeu2, loopJeu2, finJeu2},
      {setupJeu3, loopJeu3, finJeu3},
      {setupEnd, loopEnd, finEnd}
    };
     
    // définir les N° de nos tâches avec un nom parlant, ça simplifie la lecture du code.
    enum : t_taskID {JEU1, JEU2,JEU3, END};
     
    const byte rows = 4; //number of the keypad's rows and columns
    const byte cols = 4;
     
    char keyMap [rows] [cols] = { //define the cymbols on the buttons of the keypad
     
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };
     
     
    byte rowPins [rows] = {13, 12, 11, 10}; //pins of the keypad
    byte colPins [cols] = {9, 8, 7, 6};
     
    Keypad myKeypad = Keypad( makeKeymap(keyMap), rowPins, colPins, rows, cols);
     
    // ****************************
    //         UTILITAIRES
    // ****************************
     
    // on calcule le nombre de tâches définies
    uint16_t taskCount = sizeof(taskList) / sizeof(taskList[0]);
    t_taskID currentTask;
    uint32_t currentTaskStartTime;
     
    void etablirNouvelleTache(t_taskID nouvelleTache)
    {
      if (nouvelleTache >= taskCount) return;     // nouvelleTache n'existe pas
      currentTaskStartTime = millis();
      currentTask = nouvelleTache;
      taskList[currentTask].taskSetup();
    }
     
     
    void gestionEtat()
    {
      t_taskID nouvelleTache = taskList[currentTask].taskLoop();   // on fait un tour de loop de la tâche
     
      if (nouvelleTache != INCHANGE) {          // demande de changement
        taskList[currentTask].taskCleanUp();   // on termine la tâche en cours  proprement
        etablirNouvelleTache(nouvelleTache);    // on bascule vers la nouvelle tâche
      }
    }
     
     
    // ****************************
    //     TÂCHE GLOBALE
    // ****************************
    const uint16_t pulsation = 1000U; // mise à jour une fois par seconde
    const uint32_t  tempsTotal = 1000UL * 60UL * 60UL; // 60 minutes = 3 600 000 ms
    uint32_t chronometre = 0;
     
    void gestionGlobale()
    {
      //on regarde si la partie est gagnée
      if(currentTask == END) {
        ///Serial.print("stop decompte");
      } else {  //sinon,on affiche le décompte
        // pulsation pour montrer que tout va bien, on fait clignoter la LED
        if (millis() - chronometre >= pulsation) {
          if (millis() < tempsTotal) {  // si on considère que le début du jeu est au boot
            uint32_t tempsRestant = (tempsTotal - millis()) / 1000; // en secondes
            lcd.setCursor(0, 0); lcd.print(F("TEMPS:"));
            if (tempsRestant >= 60) {
              lcd.print(tempsRestant / 60); lcd.print("min");
            }
            lcd.print(tempsRestant % 60); lcd.print("s    ");
            // Serial.print('etablirNouvelleTache(t_taskID)');
          } else {
            // LE TEMPS EST EXPIRE. FAIRE CE QU'IL FAUT !
            lcd.setCursor(0, 0); lcd.print(F("VOUS AVEZ PERDU"));
          }
          chronometre += pulsation;
        }
      }
    }
     
     
    //je laisse juste le jeu 3
     
     
     
    //*****************************
    //        JEU 3
    //*****************************
     
    const char* password ;
    int passwordLength;
    char code_secret[] = {0}; //tableau contenant code
    String color;
    char* carteID;
     
    // 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 choisirCarteRouge()
    {
      long carteCrypto = random(0, 8); //on choisi une carte au hasard
     
      Serial.println(F("Crypto carte ROUGE: "));
      Serial.println(Code[carteCrypto].ID);
      carteID=Code[carteCrypto].ID;
      password = Code[carteCrypto].Red;
      passwordLength = strlen(password);
      Serial.println(F("Tapez le code"));
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(Code[carteCrypto].ID);lcd.setCursor(12, 1);lcd.print("Red");
      color = "Red";
    }
     
    void choisirCarteBleue()
    {
      long carteCrypto = random(0, 8);
     
      Serial.println(F("Crypto carte BLEUE: "));
      Serial.println(Code[carteCrypto].ID);
      carteID=Code[carteCrypto].ID;
      password = Code[carteCrypto].Blue;
      passwordLength = strlen(password);
      Serial.println(F("Tapez le code"));
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(Code[carteCrypto].ID);lcd.setCursor(12, 1);lcd.print("Blue");
     
      color = "Blue";
     
    }
    void   setupJeu3 () {
      Serial.begin(115200);
      // Pour activer l'état HOLD
      unsigned int time_hold = 4;
      //anti rebond à calibrer
      //setDebounceTime(unsigned int time)
     
      //Ecran
      lcd.init();
      // Print a message to the LCD.
      lcd.backlight();
      //pinMode(redLED, OUTPUT);  //set the LED as an output
      //pinMode(blueLED, OUTPUT);
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
      choisirCarteRouge();
    }
     
    t_taskID loopJeu3 () {
     
      char code_tape[passwordLength + 1] = {'\0'};          //tableau contenant la saisie
      uint8_t indice = 0;
     
      while (indice < passwordLength) {
        char whichKey = myKeypad.getKey(); //define which key is pressed with getKey
        if (whichKey) {
          code_tape[indice] = whichKey;
          Serial.print("*");
          lcd.setCursor(7+indice, 1);lcd.print("*");
          indice++;
        }
      }
      code_tape[passwordLength] = '\0'; // pour faire une cString bien formée (superflu car intialisé déjà avec des '\0', donc plus à titre de bonne pratique)
     
      if (strcmp(code_tape, password) == 0) { // on peut utilsier strcmp() car les deux paramètres sont des cStrings bien formées
        Serial.println(F("\ncode OK\n"));
        return INCHANGE;
     
        if (color == "Red") {
          Serial.println("Code rouge ok");
          code_tape[4] = {0}; //on réinitialise le code_tape
          choisirCarteBleue();
          return INCHANGE;
        }
        if (color == "Blue") {
          Serial.println("Code bleu ok");
          Serial.println("Partie terminée");
          lcd.setCursor(0, 1); lcd.print("  Partie finie  ");
          return END;
        }
      }else{
        Serial.println(F("\ncode faux\n"));
        lcd.setCursor(0, 1); lcd.print("Erreur code");
        Serial.print(carteID);
        delay(3000);
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(carteID);
      return INCHANGE;
      }
     
     
    }
     
    void finJeu3()
    {
      Serial.println(F("\tFIN JEU #3"));
      // nettoyage éventuel, ici rien de particulier à nettoyer
    }
     
    //*****************************
    //        FIN DU JEU
    //*****************************
    uint32_t tickEnd;
     
    void setupEnd ()
    {
      Serial.println(F("Partie terminée"));
      lcd.clear();
      lcd.setCursor(0, 0); lcd.print(" VOUS AVEZ GAGNE ");
      lcd.setCursor(0, 1); lcd.print("   Bravo a vous  ");
    }
    t_taskID loopEnd() {
      return INCHANGE;
    }
    void finEnd() {}
    // ****************************
    //     PROGRAMME PRINCIPAL
    // ****************************
     
    void setup()
    {
      Serial.begin(115200);
      pinMode(LED_BUILTIN, OUTPUT);
     
      // AUTRES INITIALISATIONS
     
      //decompte
      // Pour activer l'état HOLD
      unsigned int time_hold = 4;
     
      //Ecran
      lcd.init();
      // Print a message to the LCD.
      lcd.backlight();
      // On donne le point d'entrée de notre programme général
      etablirNouvelleTache(JEU3);
     
      //RFID
      SPI.begin();
      mfrc522.PCD_Init();
     
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
    }
     
     
    void loop()
    {
     
      gestionGlobale();
      gestionEtat();
     
    }

  2. #2
    Nouveau membre du Club
    Homme Profil pro
    pompier
    Inscrit en
    janvier 2020
    Messages
    68
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Eure et Loir (Centre)

    Informations professionnelles :
    Activité : pompier

    Informations forums :
    Inscription : janvier 2020
    Messages : 68
    Points : 29
    Points
    29
    Par défaut
    Je viens de trouver

    si vous avez une idée pour le decompte du temps qui se fige.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    Serial.println(F("\ncode OK\n"));
        return INCHANGE; // il ne fallait pas le mettre.

  3. #3
    Membre expert

    Homme Profil pro
    mad scientist :)
    Inscrit en
    septembre 2019
    Messages
    1 843
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : septembre 2019
    Messages : 1 843
    Points : 3 506
    Points
    3 506
    Par défaut
    ah oui le bout de code d'attente du code secret est bloquant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
      while (indice < passwordLength) {
        char whichKey = myKeypad.getKey(); //define which key is pressed with getKey
        if (whichKey) {
          code_tape[indice] = whichKey;
          Serial.print("*");
          lcd.setCursor(7+indice, 1);lcd.print("*");
          indice++;
        }
      }
    pour cela il faudrait que le code tapé soit rémanent il faudrait une petite machine à état pour gérer cela pour laisser votre loop tourner.. En mettant le code tapé en variable globale et en changeant le while en if on devrait s'en sortir
    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
     
    // on les passe en global
    code_tape[11] = {'\0'}; //tableau contenant la saisie pas plus de 10 caractères pour un code
    uint8_t indice = 0;
     
     
    void   setupJeu3() 
    {
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
      choisirCarteRouge();
     
      // on prépare la zone mémoire
      memset(code_tape, 0, sizeof(code_tape)); // on met à 0
      indice = 0;
    }
     
    t_taskID loopJeu3() 
    {
      if (indice < passwordLength) {
        char whichKey = myKeypad.getKey(); //define which key is pressed with getKey
        if (whichKey) {
          code_tape[indice] = whichKey;
          Serial.print("*");
          lcd.setCursor(7 + indice, 1); lcd.print("*");
          indice++;
        }
      } else {
        code_tape[passwordLength] = '\0'; // pour faire une cString bien formée (superflu car intialisé déjà avec des '\0', donc plus à titre de bonne pratique)
     
        if (strcmp(code_tape, password) == 0) { // on peut utiliser strcmp() car les deux paramètres sont des cStrings bien formées
          Serial.println(F("\ncode OK\n"));
          return INCHANGE;
     
          if (color == "Red") {
            Serial.println("Code rouge ok");
            code_tape[4] = {0}; //on réinitialise le code_tape
            choisirCarteBleue();
            return INCHANGE;
          }
          if (color == "Blue") {
            Serial.println("Code bleu ok");
            Serial.println("Partie terminée");
            lcd.setCursor(0, 1); lcd.print("  Partie finie  ");
            return END;
          }
        } else {
          Serial.println(F("\ncode faux\n"));
          lcd.setCursor(0, 1); lcd.print("Erreur code");
          Serial.print(carteID);
          delay(3000);
          lcd.setCursor(0, 1); lcd.print("Crypto"); lcd.setCursor(7, 1); lcd.print(carteID);
          return INCHANGE;
        }
      }
      return INCHANGE;
    }
    Sinon dans le setupJeu3() il ne faut pas faire des trucs globaux... (je l'ai déjà dit, ces trucs là doivent être dans le vrai setup). Donc il faut virerainsi queet la variable time_hold ne sert à rien...


    et il ne faut pas utiliser des Strings pour simplement faire un test sur "Rouge" ou "Bleu"...

    De plus dans ce 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
        if (strcmp(code_tape, password) == 0) { // on peut utilsier strcmp() car les deux paramètres sont des cStrings bien formées
          Serial.println(F("\ncode OK\n"));
          return INCHANGE;
     
          if (color == "Red") {
            Serial.println("Code rouge ok");
            code_tape[4] = {0}; //on réinitialise le code_tape
            choisirCarteBleue();
            return INCHANGE;
          }
          if (color == "Blue") {
            Serial.println("Code bleu ok");
            Serial.println("Partie terminée");
            lcd.setCursor(0, 1); lcd.print("  Partie finie  ");
            return END;
          }
        }
    vous ne ferez JAMAIS les test sur "Red" ou "Blue" puisqu'ils sont après le return INCHANGE (comme vous l'avez vu)

    vous pourriez avoir une variable globale de type uint8_t qui est un compteur. Vous l'incrémentez de 1 à chaque fois que vous passez dans la fonction choisirCarte() et suivant sa valeur vous décidez si vous prenez le code rouge ou bleu par exemple. c'est ce compteur qui pourra aussi vous dire quand vous avez fini cette partie.

  4. #4
    Nouveau membre du Club
    Homme Profil pro
    pompier
    Inscrit en
    janvier 2020
    Messages
    68
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Eure et Loir (Centre)

    Informations professionnelles :
    Activité : pompier

    Informations forums :
    Inscription : janvier 2020
    Messages : 68
    Points : 29
    Points
    29
    Par défaut
    Bon pour ce qui était des trucs qui ne servent à rien, je les avais supprimés.

    J'ai testé votre code, en fait toutes les 3 secondes ça affiche code erreur, et quand je veux saisir avec le clavier, aucun action "****".

    Citation Envoyé par Jay M Voir le message
    [CODE]

    De plus dans ce code
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
        if (strcmp(code_tape, password) == 0) { // on peut utilsier strcmp() car les deux paramètres sont des cStrings bien formées
          Serial.println(F("\ncode OK\n"));
          return INCHANGE;   // je l'ai supprimé et ça fait le test LOL
    
        }

  5. #5
    Membre expert

    Homme Profil pro
    mad scientist :)
    Inscrit en
    septembre 2019
    Messages
    1 843
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : septembre 2019
    Messages : 1 843
    Points : 3 506
    Points
    3 506
    Par défaut
    postez le code exact que vous avez...

  6. #6
    Nouveau membre du Club
    Homme Profil pro
    pompier
    Inscrit en
    janvier 2020
    Messages
    68
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Eure et Loir (Centre)

    Informations professionnelles :
    Activité : pompier

    Informations forums :
    Inscription : janvier 2020
    Messages : 68
    Points : 29
    Points
    29
    Par défaut
    voilà le code,
    j'ai retiré jeu 1 et 2 pour lire plus facilement , le jeu se lance directement dans le jeu3.

    le jeu se lance, va directement sur "Erreur code", aucune saisie possible. Le décompte temps, se fait toutes les 3 secondes, le temps du delay.

    Est-ce qu'il ne faudrait pas faire un previousmilli-currentmilli =3000 au lieu du delay?

    ou

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    if(indice < passwordLength) {
        char whichKey = myKeypad.getKey(); //define which key is pressed with getKey
        if (whichKey) {
          ...
        }
      }
    
    if(indice == passwordLength) {
      code_tape[passwordLength] = '\0'; ));
    …...
    le code, avec quelque petites modifes de rien, indice=indice+1 au lieu de indice++

    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
    //***************************
    //Bibliotheques, variables...
    //***************************  
     
     
    //initialisation du clavier
    #include <Keypad.h> //include keypad library - first you must install library (library link in the video description)
     
    //initialisation du LCD I2C
    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>
     
    LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display
     
    //Partie tableau des differents jeux
    typedef  int16_t t_taskID;
    const t_taskID INCHANGE = -1;
     
    typedef void (*t_setupFunc)();      // on défint le type t_setupFunc comme pointeur sur fonction retournant rien
    typedef t_taskID (*t_loopFunc)();  // on défint le type t_loopFunc comme pointeur sur fonction retournant un N°de tâche
    typedef void (*t_cleanupFunc)();    // on défint le type t_cleanupFunc comme pointeur sur fonction retournant rien
     
    // une tâche va consister en 3 pointeurs de fonctions
    struct t_task {
      t_setupFunc taskSetup;
      t_loopFunc taskLoop;
      t_cleanupFunc taskCleanUp;
    };
     
    // *********************************************
    // pour pouvoir définir le tableau des tâches
    // On pré-annonce les fonctions de nos tâches. (forward declaration)
    // Leur code viendra plus tard.
     
    // le Menu
    /*void setupMenu();
      t_taskID loopMenu();
      void finMenu();*/
     
    // le jeu 1
    void setupJeu1();
    t_taskID loopJeu1();
    void finJeu1();
     
    // le Jeu2
    void setupJeu2();
    t_taskID loopJeu2();
    void finJeu2();
     
    // le Jeu3
    void setupJeu3();
    t_taskID loopJeu3();
    void finJeu3();
     
    // la fin
    void setupEnd();
    t_taskID loopEnd();
    void finEnd();
     
    // *********************************************
     
    // définir le tableau des tâches
    t_task taskList[] = {
      //{setupMenu, loopMenu, finMenu},
      {setupJeu1, loopJeu1, finJeu1},
      {setupJeu2, loopJeu2, finJeu2},
      {setupJeu3, loopJeu3, finJeu3},
      {setupEnd, loopEnd, finEnd}
    };
     
    // définir les N° de nos tâches avec un nom parlant, ça simplifie la lecture du code.
    enum : t_taskID {JEU1, JEU2,JEU3, END};
     
    const byte rows = 4; //number of the keypad's rows and columns
    const byte cols = 4;
     
    char keyMap [rows] [cols] = { //define the cymbols on the buttons of the keypad
     
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };
     
     
    byte rowPins [rows] = {13, 12, 11, 10}; //pins of the keypad
    byte colPins [cols] = {9, 8, 7, 6};
     
    Keypad myKeypad = Keypad( makeKeymap(keyMap), rowPins, colPins, rows, cols);
     
    // ****************************
    //         UTILITAIRES
    // ****************************
     
    // on calcule le nombre de tâches définies
    uint16_t taskCount = sizeof(taskList) / sizeof(taskList[0]);
    t_taskID currentTask;
    uint32_t currentTaskStartTime;
     
    void etablirNouvelleTache(t_taskID nouvelleTache)
    {
      if (nouvelleTache >= taskCount) return;     // nouvelleTache n'existe pas
      currentTaskStartTime = millis();
      currentTask = nouvelleTache;
      taskList[currentTask].taskSetup();
    }
     
     
    void gestionEtat()
    {
      t_taskID nouvelleTache = taskList[currentTask].taskLoop();   // on fait un tour de loop de la tâche
     
      if (nouvelleTache != INCHANGE) {          // demande de changement
        taskList[currentTask].taskCleanUp();   // on termine la tâche en cours  proprement
        etablirNouvelleTache(nouvelleTache);    // on bascule vers la nouvelle tâche
      }
    }
     
     
    // ****************************
    //     TÂCHE GLOBALE
    // ****************************
    const uint16_t pulsation = 1000U; // mise à jour une fois par seconde
    const uint32_t  tempsTotal = 1000UL * 60UL * 60UL; // 60 minutes = 3 600 000 ms
    uint32_t chronometre = 0;
     
    // on les passe en global
    char code_tape[11] = {'\0'}; //tableau contenant la saisie pas plus de 10 caractères pour un code
    uint8_t indice = 0;
     
     
    void gestionGlobale()
    {
      //on regarde si la partie est gagnée
      if(currentTask == END) {
        ///Serial.print("stop decompte");
      } else {  //sinon,on affiche le décompte
        // pulsation pour montrer que tout va bien, on fait clignoter la LED
        if (millis() - chronometre >= pulsation) {
          if (millis() < tempsTotal) {  // si on considère que le début du jeu est au boot
            uint32_t tempsRestant = (tempsTotal - millis()) / 1000; // en secondes
            lcd.setCursor(0, 0); lcd.print(F("TEMPS:"));
            if (tempsRestant >= 60) {
              lcd.print(tempsRestant / 60); lcd.print("min");
            }
            lcd.print(tempsRestant % 60); lcd.print("s    ");
            // Serial.print('etablirNouvelleTache(t_taskID)');
          } else {
            // LE TEMPS EST EXPIRE. FAIRE CE QU'IL FAUT !
            lcd.setCursor(0, 0); lcd.print(F("VOUS AVEZ PERDU"));
          }
          chronometre += pulsation;
        }
      }
    }
    // ****************************
    //            JEU 1
    // ****************************
    uint32_t tickJeu1;
    void setupJeu1()
    {
    }
    t_taskID loopJeu1()
    {
    }
    void finJeu1()
    {
    }
     
     
    // ****************************
    //            JEU 2
    // ****************************
    uint32_t tickJeu2;
     
    #include <SPI.h>
    #include <MFRC522.h>
    #define RST_PIN 5
    #define SS_PIN 53
    MFRC522 mfrc522(SS_PIN, RST_PIN);
     
     
    void setupJeu2()
    {
     
    }
     
    t_taskID loopJeu2()
    {
     
    }
     
    void finJeu2()
    {
      Serial.println(F("\tFIN JEU #2"));
      // nettoyage éventuel, ici rien de particulier à nettoyer
    }
    //****************************
     
    //*****************************
    //        JEU 3
    //*****************************
     
    const char* password ;
    int passwordLength;
    char code_secret[] = {0}; //tableau contenant code
    String color;
    char* carteID;
     
    // 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 choisirCarteRouge()
    {
      long carteCrypto = random(0, 8); //on choisi une carte au hasard
     
      Serial.println(F("Crypto carte ROUGE: "));
      Serial.println(Code[carteCrypto].ID);
      carteID=Code[carteCrypto].ID;
      password = Code[carteCrypto].Red;
      passwordLength = strlen(password);
      Serial.println(F("Tapez le code"));
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(Code[carteCrypto].ID);lcd.setCursor(12, 1);lcd.print("Red");
      color = "Red";
    }
     
    void choisirCarteBleue()
    {
      long carteCrypto = random(0, 8);
     
      Serial.println(F("Crypto carte BLEUE: "));
      Serial.println(Code[carteCrypto].ID);
      carteID=Code[carteCrypto].ID;
      password = Code[carteCrypto].Blue;
      passwordLength = strlen(password);
      Serial.println(F("Tapez le code"));
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(Code[carteCrypto].ID);lcd.setCursor(12, 1);lcd.print("Blue");
     
      color = "Blue";
     
    }
    void   setupJeu3 () {
     
      // Pour activer l'état HOLD
      unsigned int time_hold = 4;
      //anti rebond à calibrer
      //setDebounceTime(unsigned int time)
     
        randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
      choisirCarteRouge();
     
       // on prépare la zone mémoire
      //memset(code_tape, 0, sizeof(code_tape)); // on met à 0
     // indice = 0;
    }
     
    t_taskID loopJeu3 () {
     
      //char code_tape[passwordLength + 1] = {'\0'};          //tableau contenant la saisie
      //uint8_t indice = 0;
     
      if(indice < passwordLength) {
        char whichKey = myKeypad.getKey(); //define which key is pressed with getKey
        if (whichKey) {
          code_tape[indice] = whichKey;
          Serial.print("*");
          lcd.setCursor(7+indice, 1);lcd.print("*");
          indice=indice+1;
        }
      }
      code_tape[passwordLength] = '\0'; // pour faire une cString bien formée (superflu car intialisé déjà avec des '\0', donc plus à titre de bonne pratique)
     
      if (strcmp(code_tape, password) == 0) { // on peut utilsier strcmp() car les deux paramètres sont des cStrings bien formées
        Serial.println(F("\ncode OK\n"));
        //return INCHANGE;
     
        if (color == "Red") {
          Serial.println("Code rouge ok");
          code_tape[4] = {0}; //on réinitialise le code_tape
          indice=0; // on réinitialise 
          choisirCarteBleue();
          return INCHANGE;
        }
        if (color == "Blue") {
          Serial.println("Code bleu ok");
          Serial.println("Partie terminée");
          lcd.setCursor(0, 1); lcd.print("  Partie finie  ");
          return END;
        }
      }else{
        Serial.println(F("\ncode faux\n"));
        lcd.setCursor(0, 1); lcd.print("Erreur code");
        Serial.print(carteID);
        delay(3000);
         lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(carteID);
         indice=0;
      return INCHANGE;
      }
     
     
    }
     
    void finJeu3()
    {
      Serial.println(F("\tFIN JEU #3"));
      // nettoyage éventuel, ici rien de particulier à nettoyer
    }
     
    //*****************************
    //        FIN DU JEU
    //*****************************
    uint32_t tickEnd;
     
    void setupEnd ()
    {
      Serial.println(F("Partie terminée"));
      lcd.clear();
      lcd.setCursor(0, 0); lcd.print(" VOUS AVEZ GAGNE ");
      lcd.setCursor(0, 1); lcd.print("   Bravo a vous  ");
    }
    t_taskID loopEnd() {
      return INCHANGE;
    }
    void finEnd() {}
    // ****************************
    //     PROGRAMME PRINCIPAL
    // ****************************
     
    void setup()
    {
      Serial.begin(115200);
      pinMode(LED_BUILTIN, OUTPUT);
     
      // AUTRES INITIALISATIONS
     
      //decompte
      // Pour activer l'état HOLD
      unsigned int time_hold = 4;
     
      //Ecran
      lcd.init();
      // Print a message to the LCD.
      lcd.backlight();
      // On donne le point d'entrée de notre programme général
      etablirNouvelleTache(JEU3);
     
      //RFID
      SPI.begin();
      mfrc522.PCD_Init();
     
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
    }
     
     
    void loop()
    {
     
      gestionGlobale();
      gestionEtat();
     
    }

  7. #7
    Nouveau membre du Club
    Homme Profil pro
    pompier
    Inscrit en
    janvier 2020
    Messages
    68
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Eure et Loir (Centre)

    Informations professionnelles :
    Activité : pompier

    Informations forums :
    Inscription : janvier 2020
    Messages : 68
    Points : 29
    Points
    29
    Par défaut
    bon,
    maintenant, le temps s'écoule gentiment, mais pas de prise en compte de la saisie du clavier.

    j'ai mis: if(indice == passwordLength) { pour bloquer le contrôle

    j'ai mis du texte de contrôle "ici" et "mm", seul "ici" s'affiche.

    si on remplace le If par While (saisie ok mais plus de décompte temps). un truc de ouf

    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
    //***************************
    //Bibliotheques, variables...
    //***************************  
     
     
    //initialisation du clavier
    #include <Keypad.h> //include keypad library - first you must install library (library link in the video description)
     
    //initialisation du LCD I2C
    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>
     
    LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display
     
    //Partie tableau des differents jeux
    typedef  int16_t t_taskID;
    const t_taskID INCHANGE = -1;
     
    typedef void (*t_setupFunc)();      // on défint le type t_setupFunc comme pointeur sur fonction retournant rien
    typedef t_taskID (*t_loopFunc)();  // on défint le type t_loopFunc comme pointeur sur fonction retournant un N°de tâche
    typedef void (*t_cleanupFunc)();    // on défint le type t_cleanupFunc comme pointeur sur fonction retournant rien
     
    // une tâche va consister en 3 pointeurs de fonctions
    struct t_task {
      t_setupFunc taskSetup;
      t_loopFunc taskLoop;
      t_cleanupFunc taskCleanUp;
    };
     
    // *********************************************
    // pour pouvoir définir le tableau des tâches
    // On pré-annonce les fonctions de nos tâches. (forward declaration)
    // Leur code viendra plus tard.
     
    // le Menu
    /*void setupMenu();
      t_taskID loopMenu();
      void finMenu();*/
     
    // le jeu 1
    void setupJeu1();
    t_taskID loopJeu1();
    void finJeu1();
     
    // le Jeu2
    void setupJeu2();
    t_taskID loopJeu2();
    void finJeu2();
     
    // le Jeu3
    void setupJeu3();
    t_taskID loopJeu3();
    void finJeu3();
     
    // la fin
    void setupEnd();
    t_taskID loopEnd();
    void finEnd();
     
    // *********************************************
     
    // définir le tableau des tâches
    t_task taskList[] = {
      //{setupMenu, loopMenu, finMenu},
      {setupJeu1, loopJeu1, finJeu1},
      {setupJeu2, loopJeu2, finJeu2},
      {setupJeu3, loopJeu3, finJeu3},
      {setupEnd, loopEnd, finEnd}
    };
     
    // définir les N° de nos tâches avec un nom parlant, ça simplifie la lecture du code.
    enum : t_taskID {JEU1, JEU2,JEU3, END};
     
    const byte rows = 4; //number of the keypad's rows and columns
    const byte cols = 4;
     
    char keyMap [rows] [cols] = { //define the cymbols on the buttons of the keypad
     
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };
     
     
    byte rowPins [rows] = {13, 12, 11, 10}; //pins of the keypad
    byte colPins [cols] = {9, 8, 7, 6};
     
    Keypad myKeypad = Keypad( makeKeymap(keyMap), rowPins, colPins, rows, cols);
     
    // ****************************
    //         UTILITAIRES
    // ****************************
     
    // on calcule le nombre de tâches définies
    uint16_t taskCount = sizeof(taskList) / sizeof(taskList[0]);
    t_taskID currentTask;
    uint32_t currentTaskStartTime;
     
    void etablirNouvelleTache(t_taskID nouvelleTache)
    {
      if (nouvelleTache >= taskCount) return;     // nouvelleTache n'existe pas
      currentTaskStartTime = millis();
      currentTask = nouvelleTache;
      taskList[currentTask].taskSetup();
    }
     
     
    void gestionEtat()
    {
      t_taskID nouvelleTache = taskList[currentTask].taskLoop();   // on fait un tour de loop de la tâche
     
      if (nouvelleTache != INCHANGE) {          // demande de changement
        taskList[currentTask].taskCleanUp();   // on termine la tâche en cours  proprement
        etablirNouvelleTache(nouvelleTache);    // on bascule vers la nouvelle tâche
      }
    }
     
     
    // ****************************
    //     TÂCHE GLOBALE
    // ****************************
    const uint16_t pulsation = 1000U; // mise à jour une fois par seconde
    const uint32_t  tempsTotal = 1000UL * 60UL * 60UL; // 60 minutes = 3 600 000 ms
    uint32_t chronometre = 0;
     
    // on les passe en global
    char code_tape[11] = {'\0'}; //tableau contenant la saisie pas plus de 10 caractères pour un code
    uint8_t indice = 0;
     
     
    void gestionGlobale()
    {
      //on regarde si la partie est gagnée
      if(currentTask == END) {
        ///Serial.print("stop decompte");
      } else {  //sinon,on affiche le décompte
        // pulsation pour montrer que tout va bien, on fait clignoter la LED
        if (millis() - chronometre >= pulsation) {
          if (millis() < tempsTotal) {  // si on considère que le début du jeu est au boot
            uint32_t tempsRestant = (tempsTotal - millis()) / 1000; // en secondes
            lcd.setCursor(0, 0); lcd.print(F("TEMPS:"));
            if (tempsRestant >= 60) {
              lcd.print(tempsRestant / 60); lcd.print("min");
            }
            lcd.print(tempsRestant % 60); lcd.print("s    ");
            // Serial.print('etablirNouvelleTache(t_taskID)');
          } else {
            // LE TEMPS EST EXPIRE. FAIRE CE QU'IL FAUT !
            lcd.setCursor(0, 0); lcd.print(F("VOUS AVEZ PERDU"));
          }
          chronometre += pulsation;
        }
      }
    }
    // ****************************
    //            JEU 1
    // ****************************
    uint32_t tickJeu1;
    void setupJeu1()
    {
    }
    t_taskID loopJeu1()
    {
    }
    void finJeu1()
    {
    }
     
     
    // ****************************
    //            JEU 2
    // ****************************
    uint32_t tickJeu2;
     
    #include <SPI.h>
    #include <MFRC522.h>
    #define RST_PIN 5
    #define SS_PIN 53
    MFRC522 mfrc522(SS_PIN, RST_PIN);
     
     
    void setupJeu2()
    {
     
    }
     
    t_taskID loopJeu2()
    {
     
    }
     
    void finJeu2()
    {
      Serial.println(F("\tFIN JEU #2"));
      // nettoyage éventuel, ici rien de particulier à nettoyer
    }
    //****************************
     
    //*****************************
    //        JEU 3
    //*****************************
     
    const char* password ;
    int passwordLength;
    char code_secret[] = {0}; //tableau contenant code
    String color;
    char* carteID;
     
    // 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 choisirCarteRouge()
    {
      long carteCrypto = random(0, 8); //on choisi une carte au hasard
     
      Serial.println(F("Crypto carte ROUGE: "));
      Serial.println(Code[carteCrypto].ID);
      carteID=Code[carteCrypto].ID;
      password = Code[carteCrypto].Red;
      passwordLength = strlen(password);
      Serial.println(F("Tapez le code"));
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(Code[carteCrypto].ID);lcd.setCursor(12, 1);lcd.print("Red");
      color = "Red";
    }
     
    void choisirCarteBleue()
    {
      long carteCrypto = random(0, 8);
     
      Serial.println(F("Crypto carte BLEUE: "));
      Serial.println(Code[carteCrypto].ID);
      carteID=Code[carteCrypto].ID;
      password = Code[carteCrypto].Blue;
      passwordLength = strlen(password);
      Serial.println(F("Tapez le code"));
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(Code[carteCrypto].ID);lcd.setCursor(12, 1);lcd.print("Blue");
     
      color = "Blue";
     
    }
    void   setupJeu3 () {
     
      // Pour activer l'état HOLD
      unsigned int time_hold = 4;
      //anti rebond à calibrer
      //setDebounceTime(unsigned int time)
     
        randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
      choisirCarteRouge();
     
       // on prépare la zone mémoire
     // memset(code_tape, 0, sizeof(code_tape)); // on met à 0
     //( indice = 0;
    }
     
    t_taskID loopJeu3 () {
     
      //char code_tape[passwordLength + 1] = {'\0'};          //tableau contenant la saisie
      //uint8_t indice = 0;
    Serial.println(indice);
    Serial.println(passwordLength);
      if(indice < passwordLength) {
         Serial.print("ici");
        char whichKey = myKeypad.getKey(); //define which key is pressed with getKey
        if (whichKey) {
          Serial.print("mm");
          code_tape[indice] = whichKey;
          Serial.print("*");
          lcd.setCursor(7+indice, 1);lcd.print("*");
          indice=indice+1;
          return INCHANGE;
        }
      }
      if(indice == passwordLength) {  
      code_tape[passwordLength] = '\0'; // pour faire une cString bien formée (superflu car intialisé déjà avec des '\0', donc plus à titre de bonne pratique)
     
      if (strcmp(code_tape, password) == 0) { // on peut utilsier strcmp() car les deux paramètres sont des cStrings bien formées
        Serial.println(F("\ncode OK\n"));
        //return INCHANGE;
     
        if (color == "Red") {
          Serial.println("Code rouge ok");
          code_tape[4] = {0}; //on réinitialise le code_tape
          indice=0;
          choisirCarteBleue();
          return INCHANGE;
        }
        if (color == "Blue") {
          Serial.println("Code bleu ok");
          Serial.println("Partie terminée");
          lcd.setCursor(0, 1); lcd.print("  Partie finie  ");
          return END;
        }
      }else{
        Serial.println(F("\ncode faux\n"));
        lcd.setCursor(0, 1); lcd.print("Erreur code");
        Serial.print(carteID);
        indice=0;
        delay(3000);
      lcd.setCursor(0, 1); lcd.print("Crypto");lcd.setCursor(7, 1);lcd.print(carteID);
      return INCHANGE;
      }
     
      }
    }
     
    void finJeu3()
    {
      //Serial.println(F("\tFIN JEU #3"));
      // nettoyage éventuel, ici rien de particulier à nettoyer
    }
     
    //*****************************
    //        FIN DU JEU
    //*****************************
    uint32_t tickEnd;
     
    void setupEnd ()
    {
      Serial.println(F("Partie terminée"));
      lcd.clear();
      lcd.setCursor(0, 0); lcd.print(" VOUS AVEZ GAGNE ");
      lcd.setCursor(0, 1); lcd.print("   Bravo a vous  ");
    }
    t_taskID loopEnd() {
      return INCHANGE;
    }
    void finEnd() {}
    // ****************************
    //     PROGRAMME PRINCIPAL
    // ****************************
     
    void setup()
    {
      Serial.begin(115200);
      pinMode(LED_BUILTIN, OUTPUT);
     
      // AUTRES INITIALISATIONS
     
      //decompte
      // Pour activer l'état HOLD
      unsigned int time_hold = 4;
     
      //Ecran
      lcd.init();
      // Print a message to the LCD.
      lcd.backlight();
      // On donne le point d'entrée de notre programme général
      etablirNouvelleTache(JEU3);
     
      //RFID
      SPI.begin();
      mfrc522.PCD_Init();
     
      randomSeed(analogRead(A0)); // génération d'un peu d'aléatoire
    }
     
     
    void loop()
    {
     
      gestionGlobale();
      gestionEtat();
     
    }

Discussions similaires

  1. Problème de référence de classe
    Par nmathon dans le forum Delphi
    Réponses: 7
    Dernier message: 21/06/2006, 17h46
  2. [FLASH MX2004] this et problème de référence
    Par cristolb dans le forum ActionScript 1 & ActionScript 2
    Réponses: 5
    Dernier message: 03/05/2006, 23h33
  3. [Web-App][Servlet][Axis] Problème lors de l'arrêt de la web-app
    Par c.tranquille dans le forum Tomcat et TomEE
    Réponses: 1
    Dernier message: 02/12/2005, 10h49
  4. Problème de référence de données circulaire
    Par Wismerhill50 dans le forum Langage
    Réponses: 3
    Dernier message: 23/10/2005, 23h38
  5. problème de références _ptr dans une map STL
    Par Mr_Tyu dans le forum CORBA
    Réponses: 1
    Dernier message: 10/08/2004, 11h39

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo