Est ce que le GND du relais est connecté au GND de l'Arduino?
Non sur l'alimentation USB
Les GND doivent être tous ensemble.
Ok je test ça de suite
Aucun changement
d'après ta photo du post 271 ta commande de relais n'est pas sur la p
Sur ? je suis bien sur la pin 9
et j'ai passé le bouton sur la 5 pour faire un essaie(bien modifié le code)
On revoit ca demain.
Bonne nuit
Bonne nuit merci
Bonjour blazerwood
Ce n'est pas un Nano mais un Pro Micro.
D'après ta photo, le câblage est juste.
La liaison entre le GND du relais, de l'USB et de l'Arduino est indispensable.
Le bouton de commande (btnPressRadioPin) devrait être sur 2, la pin 5 que tu as utilisée est déjà occupée par:
const int radioCommandeEchoPin = 5; // Pour commande supplémentaire
et le paramétrage de la commande du relais,:
const int radioCommandeEtatOn = HIGH; // Etat pour faire tirer le relais
En mettant le bouton de commande sur 2, charges ce bout de programme afin de monitorer l'état du bouton et dis mois ce qui s'affiche.
const int btnPressRadioPin = 2; // Pin du bouton activation radio
void setup()
{
Serial.begin(115200);
pinMode(btnPressRadioPin, INPUT_PULLUP);
}
void loop()
{
int btnEtat = digitalRead(btnPressRadioPin);
Serial.println((btnEtat == LOW) ? "ON" : "OFF");
delay(1000);
}
Pour ce qui est du programme principal, dis moi quelle est la dernière version qui fonctionne chez toi?
A+
jpbbricole
Bonjour jppbricole
Oui mais comme dit dans le post 291
j'ai passé le bouton sur la 5 pour faire un essaie(bien modifié le code)
C'est le bon paramétrage.
Toute les masses sont sur le GND de l'arduino.
En gros, la phase d'explosion tourne en boucle : "explosion, attente du badge, le compte à rebours se lance pendant 1 seconde et explosion, etc..." Et la lecture du badge ne fonctionne plus. Plus rien ne se passe.
/*
Name: ARDFR_blazerwood_GameAirsoft_Desam.ino
Created: 19.01.2024
Author: jpbbricole/blazerwood
https://forum.arduino.cc/t/debutant-sur-un-gros-projet-de-b-dairsoft/1195777
19.01.2024 Ajout Ajout de désamorçage repris de #245 > 246
*/
#include <Wire.h>
#include <Keypad.h>
#include <Keypad_I2C.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
#include <MFRC522.h>
#include <SPI.h>
#include <I2C_eeprom.h> // https://github.com/RobTillaart/I2C_EEPROM
#define blazerwood // A mettre en remarque si jpbbricole
//------------------------------------- RFID
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);
//------------------------------------- Clavier
#ifdef blazerwood
const int keybI2cAddress = 0x25;
#else // jpbbricole
const int keybI2cAddress = 0x38;
#endif
const byte keybRowsNbr = 4;
const byte keybColsNbr = 4;
//------------------------------------- Désamorçage (desam)
const String desalFctLabel[] = {"Desamorcage", "Explosion", "Temps demi", "Temps cache", "OFF"};
enum {desamFctDesamorcage, desamFctExplosion, desamFctTempsDemi, desamFctTempsCache, desamFctOff};
int desamFonction = desamFctOff;
//const int desarmPin[] = {2, 3, A0, A1};
//const int desarmFctNombre = sizeof(desarmPin) / sizeof(desarmPin[0]);
//const int desarmEtatOn = LOW; // Etat quand fil interrompu
#ifdef blazerwood
const int desamPin[] = {2, 3, A0, A1};
const int desamEtatOn = HIGH; // Etat quand fil interrompu
#else // jpbbricole
const int desamPin[] = {2, 3, A0, A1};
const int desamEtatOn = LOW; // Etat quand fil interrompu
#endif
const int desamFctNombre = sizeof(desamPin) / sizeof(desamPin[0]);
int desamFct = desamFctOff; //Fonction de desamorçage en cours
//------------------------------------- Tableau de nombre au hasard
struct rndArrayDef {boolean sorti = false; int nombre = 0;};
rndArrayDef rndArray[desamFctNombre];
boolean rndArrayInTest = false; // Pour faciliter les test, sort toujours un tableau contenant 0, 1, 2, 3...
//------------------------------------- Temps, pour accélérer les delay()
#ifdef blazerwood
const int timeFactor = 1;
#else // jpbbricole
const int timeFactor = 5;
#endif
char keysMape[keybRowsNbr][keybColsNbr] =
{
#ifdef blazerwood
{'D', 'C', 'B', 'A'},
{'#', '9', '6', '3'},
{'0', '8', '5', '2'},
{'*', '7', '4', '1'}
#else
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
#endif
};
#ifdef blazerwood
byte keybRowPins[keybRowsNbr] = {3, 2, 1, 0};
byte keybColPins[keybColsNbr] = {7, 6, 5, 4};
#else
byte keybRowPins[keybRowsNbr] = {7, 6, 5, 4}; // Connexion des lignes
byte keybColPins[keybColsNbr] = {3, 2, 1, 0}; // Connexion des colonnes
#endif
Keypad_I2C customKeypad(makeKeymap(keysMape), keybRowPins, keybColPins, keybRowsNbr, keybColsNbr, keybI2cAddress);
//------------------------------------- Affichages LCD
#ifdef blazerwood
const int lcdAadresse = 0x26; // Adresse du premier écran
const int lcdBadresse = 0x27; // Adresse du second écran
#else
const int lcdAadresse = 0x26; // Adresse du premier écran
const int lcdBadresse = 0x3F; // Adresse du second écran
#endif
LiquidCrystal_I2C lcdA(lcdAadresse, 20, 4);
LiquidCrystal_I2C lcdB(lcdBadresse, 20, 4);
String gameModes[5] = {
"Search & destroy",
"Matchs a Mort",
"Dominations",
"Piratage",
"Decryptage",
};
//------------------------------------- LED
enum {ledColorGreen, ledColorYellow, ledColorRed};
const int ledColorIndex[] = {5, 6, 7};
const int ledNumber = sizeof(ledColorIndex) / sizeof(ledColorIndex[0]);
const int ledOn = HIGH;
//------------------------------------- Servo
const int servoPin = 8;
Servo myServo;
//------------------------------------- Etats du jeu
enum { jeuEtatDemarrage, jeuEtatSelMode, jeuEtatSelTime, jeuEtatSelCode, jeuEtatEnCours, jeuEtatBombeBoom, jeuEtatBombeToOff, jeuEtatAttNfc, jeuEtatFin, jeuEtatArrete};
const String jeuEtatLabel [] = {"Demarrage", "Select mode", "Select time", "Select code", "En cours", "Bombe BOOM", "Bombe desamorcee", "Att. NFC", "Fin", "Arrete"};
int jeuEtat;
int selectedMode;
int selectedTime;
//------------------------------------- Tableau des UID et pseudo
const int uidNombre = 20;
const int uidSize = 9;
const int uidNomSize = 10;
struct uidMemDef // Structure de données des UID pour mémoire EEPRROM
{
char uid[uidSize];
char nom[uidNomSize];
};
uidMemDef uidMem;
const int uidRecordSize = sizeof(uidMem);
struct uidWorkDef // Structure de données des UID pour travail
{
String uid;
String nom;
};
uidWorkDef uidWork;
//------------------------------------- EEPROM
I2C_eeprom eeprom24C(0x50, I2C_DEVICESIZE_24LC256);
const word eeprCheckWord = 0xCAFE; // Pour repérer si c'est un premier usage
const int eeprOffsetCheckWord = 0; // Adresse du début de la mémoire
const int eeprOffsetUid = eeprOffsetCheckWord + sizeof(eeprCheckWord); // Adresse du début de la mémoire des UID
//------------------------------------- Divers
unsigned long timerDuration;
unsigned long startTime;
bool bombExploded = false;
String disarmCode; // Variable pour stocker le code de désarmement
int disarmCodeLength = 4; // Longueur par défaut du code
void setup()
{
Serial.begin(115200);
Wire.begin();
customKeypad.begin();
jeuEtatSet(jeuEtatDemarrage, F("Setup()"));
//--------------------------------- Initialisation EEPROM
eeprom24C.begin();
word eeprCheck; // Mot de test
eeprom24C.readBlock(eeprOffsetCheckWord, (uint8_t *) &eeprCheck, sizeof(eeprCheck));
if (eeprCheck != eeprCheckWord) // Si premier usage
{
Serial.println(F("\n!!!! EEPROM PAS INITIALISEE !!!!"));
while(1)
{
// LED Warning
}; // Arrêt d programme
}
else
{
Serial.println(F("\tEEPROM OK"));
}
desamInitialisation();
SPI.begin();
mfrc522.PCD_Init();
myServo.attach(servoPin);
myServo.write(0);
for (int l = 0; l < ledNumber; l++)
{
pinMode(ledColorIndex[l], OUTPUT);
digitalWrite(ledColorIndex[l], !ledOn);
}
lcdA.init();
lcdB.init();
lcdA.backlight();
lcdB.backlight();
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("GEARS AIRSOFT");
delay(3000 / timeFactor);
lcdB.clear();
lcdB.setCursor(0, 0);
lcdB.print("Activation");
delay(2000 / timeFactor);
lcdB.clear();
lcdB.setCursor(0, 0);
lcdB.print("Activation OK");
digitalWrite(ledColorIndex[ledColorGreen], HIGH);
delay(3000 / timeFactor);
digitalWrite(ledColorIndex[ledColorGreen], !ledOn); // Éteindre la LED verte
}
void loop()
{
digitalWrite(ledColorIndex[ledColorYellow], HIGH);
selectedMode = selectGameMode();
selectedTime = selectGameTime();
disarmCode = selectDisarmCode(); // Appeler la configuration du code de désarmement après la sélection du temps
//selectedMode = 1;
//selectedTime = 1;
//disarmCodeLength = 4;
//disarmCode = "1111";
gameStart();
digitalWrite(ledColorIndex[ledColorYellow], !ledOn);
}
//------------------------------------- Désamorçage
void desamInitialisation()
{
for (int d = 0; d < desamFctNombre; d++)
{
pinMode(desamPin[d], INPUT_PULLUP); // Tout les boutons à GND d'un côté
}
}
void desamNewKeys(int dimArray) {
randomSeed(millis());
int rndCpt = 0; // Pour compter les chiffres
for (int r = 0; r < dimArray; r++) {
rndArray[r].sorti = false; // Reset flag
}
while (true) {
int rndNew = random(0, dimArray);
if (!rndArray[rndNew].sorti) // Si pas encore sorti
{
rndArray[rndNew].sorti = true; // Marquer chiffre sorti
rndArray[rndCpt].nombre = rndNew; // Enregistrer ce nombre
rndCpt++;
if (rndCpt >= dimArray) // Si tirage terminé
{
break; // While terminé
}
}
}
if (rndArrayInTest) // Si en test
{
for (int n = 0; n < dimArray; n++) // Mettre des nombres fixes
{
rndArray[n].nombre = n;
}
}
}
int desamFilLecture() // Lectute des fils de désamorçage
{
for (int f = 0; f < desamFctNombre; f++)
{
if (digitalRead(desamPin[f]) == desamEtatOn) // Si fil interrompu
{
return f;
}
}
return -1;
}
//------------------------------------- Début du jeux
void gameStart()
{
desamNewKeys(desamFctNombre); // Tirage d'une nouvelle table de hazard
timerDuration = selectedTime * 60L * (1000L / timeFactor);
startTime = millis();
bombExploded = false;
digitalWrite(ledColorIndex[ledColorRed], HIGH);
jeuEtatSet(jeuEtatEnCours, F("while (millis() - startTime"));
while (millis() - startTime < timerDuration && !bombExploded)
{
unsigned long remainingTime = timerDuration - (millis() - startTime);
unsigned long remainingMinutes = remainingTime / 1000 / 60;
unsigned long remainingSeconds = (remainingTime / 1000) % 60;
lcdB.clear();
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Temps restant:");
lcdA.setCursor(0, 1);
lcdA.print(remainingMinutes);
lcdA.print(" min ");
lcdA.print(remainingSeconds);
lcdA.print(" sec");
disarmBomb(); // Appeler la fonction de désamorçage à chaque itération de la boucle principale
checkRFIDCard(); // Vérifier la carte RFID à chaque itération
//----------------------------- Désamorçage
int desamFil = desamFilLecture(); // Lecture des fils
desamFct = rndArray[desamFil].nombre; // Fonction du fil déconnecté
if (desamFilLecture() != -1) // Si un fil interrompu
{
lcdA.setCursor(0, 3);
lcdA.print(desalFctLabel[desamFct]);
switch (desamFct) // Sölection des actions
{
case desamFctDesamorcage:
BombeDesamorcee();
break;
case desamFctExplosion:
gestionExplosion();
break;
case desamFctTempsDemi:
// Action TempsDemi
break;
case desamFctTempsCache:
// Action TempsCaché
break;
}
//while(desamFilLecture() != -1) {} // Tant que le fil est déconnecté
}
else
{
lcdA.setCursor(0, 3);
lcdA.print("- ");
}
delay(100);
}
if (!bombExploded && millis() - startTime >= timerDuration)
{
digitalWrite(ledColorIndex[ledColorGreen], !ledOn); // Éteindre la LED verte
myServo.write(90);
delay(2000);
myServo.write(0);
}
for (int l = 0; l < ledNumber; l++)
{
digitalWrite(ledColorIndex[l], !ledOn);
}
if (!bombExploded);
}
void gestionExplosion() {
digitalWrite(ledColorIndex[ledColorGreen], !ledOn); // Éteindre la LED verte
myServo.write(90);
delay(2000);
myServo.write(0);
for (int l = 0; l < ledNumber; l++)
{
digitalWrite(ledColorIndex[l], !ledOn);
}
jeuEtatSet(jeuEtatBombeBoom, F("Explosion détectée"));
digitalWrite(ledColorIndex[ledColorRed], HIGH);
lcdB.clear();
lcdB.setCursor(0, 0);
lcdB.print("BOOOOM !");
lcdB.setCursor(0, 1);
lcdB.print("Bombe Explosee !");
delay(3000);
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Veuillez contacter");
lcdA.setCursor(0, 1);
lcdA.print("votre ORGA.");
// Attendre la lecture du badge NFC avant de passer à la suite
waitForNFCCardOGA();
digitalWrite(ledColorIndex[ledColorGreen], !ledOn);
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Veuillez choisir");
lcdA.setCursor(0, 1);
lcdA.print("le mode de jeux");
digitalWrite(ledColorIndex[ledColorRed], !ledOn);
}
void displayMessage(LiquidCrystal_I2C& lcd, const String& line1, const String& line2, int delayTime = 1000)
{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(line1);
lcd.setCursor(0, 1);
lcd.print(line2);
delay(delayTime / timeFactor);
}
bool isRFIDCardPresent()
{
if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial())
{
return true;
}
return false;
}
void checkRFIDCard() {
if (isRFIDCardPresent())
{
digitalWrite(ledColorIndex[ledColorRed], HIGH);
delay(1000);
digitalWrite(ledColorIndex[ledColorRed], !ledOn);
}
}
String selectDisarmCode()
{
jeuEtatSet(jeuEtatSelCode, F("disarmCodeSetup()"));
String disarmCode = "";
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Longueur du code (4-8):");
int selectedLength = 0;
while (selectedLength < 4 || selectedLength > 8)
{
char key = customKeypad.getKey();
if (key >= '4' && key <= '8')
{
selectedLength = key - '0';
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Longueur choisie:");
lcdA.print(selectedLength);
delay(1000);
}
}
disarmCodeLength = selectedLength;
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Entrez le code:");
delay(1000);
disarmCode = "";
while (disarmCode.length() < disarmCodeLength)
{
char key = customKeypad.getKey();
if (((key >= '0' && key <= '9') || (key >= 'A' && key <= 'F')) && key != NO_KEY)
{
disarmCode += key;
lcdA.print('*');
}
else if (key == '#')
{
if (disarmCode.length() == disarmCodeLength)
{
// Code complet, sortir de la boucle
break;
}
}
delay(100);
}
jeuEtatSet(jeuEtatSelCode, String(disarmCode));
delay(1000);
digitalWrite(ledColorIndex[ledColorYellow], !ledOn); // Eteindre la LED Jaune
digitalWrite(ledColorIndex[ledColorGreen], ledOn); // Allumez la LED verte
displayMessage(lcdA, "Code valide:", disarmCode, 2000);
delay(2000);
digitalWrite(ledColorIndex[ledColorGreen], !ledOn); // Eteindre la LED Verte
return disarmCode;
}
void displayDisarmCode(const String& code)
{
lcdB.clear();
lcdB.setCursor(0, 0);
lcdB.print("Entrez le code:");
lcdB.setCursor(0, 1);
for (size_t i = 0; i < code.length(); ++i)
{
lcdB.print('*');
}
}
void disarmBomb()
{
static String enteredCode = ""; // Variable statique pour conserver sa valeur entre les appels
static unsigned long lastDisplayTime = 0;
char key = customKeypad.getKey();
if (key != NO_KEY && ((key >= '0' && key <= '9') || (key >= 'A' && key <= 'F')) && enteredCode.length() < disarmCodeLength && !bombExploded)
{
enteredCode += key;
lastDisplayTime = millis();
}
// Afficher le code pendant une période définie après chaque pression de touche
if (millis() - lastDisplayTime < 3000)
{
displayDisarmCode(enteredCode);
}
else
{
displayDisarmCode(""); // Effacer le code après la période définie
enteredCode = ""; // Réinitialiser le code pour la nouvelle partie
}
// Vérifier si le code a atteint la longueur spécifiée
if (enteredCode.length() == disarmCodeLength)
{
if (!bombExploded) // Vérifier si la bombe n'a pas encore explosé
{
if (enteredCode == disarmCode)
BombeDesamorcee();
}
}
}
void BombeDesamorcee() {
bombExploded = true;
digitalWrite(ledColorIndex[ledColorGreen], ledOn); // Allumez la LED verte
delay(2000);
digitalWrite(ledColorIndex[ledColorYellow], !ledOn); // Eteindre la LED Jaune
jeuEtatSet(jeuEtatBombeToOff, F("disarmBomb()"));
lcdB.clear();
lcdB.setCursor(0, 0);
lcdB.print("Bombe desamorcee !");
delay(3000);
// Attendre la lecture du badge NFC
waitForNFCCardOGA();
}
int selectGameMode()
{
jeuEtatSet(jeuEtatSelMode, F("selectGameMode()"));
int selectedMode = -1;
for (int i = 0; i < 5; i++)
{
displayMessage(lcdB, "Mode de Jeux (" + String(i + 1) + ")", gameModes[i], 1000);
}
displayMessage(lcdB, "Faites votre choix:", "(1-5)", 500);
while (selectedMode < 1 || selectedMode > 5)
{
char key = customKeypad.getKey();
if (key != NO_KEY && key >= '1' && key <= '5')
{
selectedMode = key - '0';
lcdB.clear();
lcdB.setCursor(0, 0);
lcdB.print("Mode choisi: ");
lcdB.print(selectedMode);
lcdB.setCursor(0, 1);
lcdB.print(" - ");
lcdB.print(gameModes[selectedMode - 1]);
delay(3000 / timeFactor);
}
}
jeuEtatSet(jeuEtatSelMode, gameModes[selectedMode - 1]);
return selectedMode;
}
int selectGameTime()
{
int inputTime = 0;
bool timeSelectionComplete = false;
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Temps (min):");
jeuEtatSet(jeuEtatSelTime, "Loop()");
while (!timeSelectionComplete)
{
char key = customKeypad.getKey();
if (key >= '0' && key <= '9')
{
inputTime = inputTime * 10 + (key - '0');
lcdA.print(key);
}
else if (key == '#')
{
timeSelectionComplete = true;
}
else if (key == '*')
{
if (inputTime > 0)
{
inputTime = inputTime / 10;
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Temps (min):");
lcdA.print(inputTime);
}
}
checkRFIDCard(); // Vérifier la carte RFID à chaque itération
delay(100);
}
jeuEtatSet(jeuEtatSelTime, String(inputTime));
return inputTime;
}
bool waitForNFCCardOGA()
{
jeuEtatSet(jeuEtatAttNfc, F("waitForNFCCardOGA()"));
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Veuillez contacter");
lcdA.setCursor(0, 1);
lcdA.print("votre ORGA...");
unsigned long startTime = millis(); // Enregistrez le temps au début
// La carte NFC a été détectée
digitalWrite(ledColorIndex[ledColorGreen], !ledOn); // Eteindre la LED verte
while (true) // Tant que le badge ORGA n'a pas été lu
{
String nomCarte = "-";
while (nomCarte == "-")
{
nomCarte = uidGetNameByCardRead();
digitalWrite(ledColorIndex[ledColorRed], ledOn); // Allumez la LED rouge
}
// Réinitialiser l'état du module RFID
digitalWrite(ledColorIndex[ledColorRed], ledOn); // Allumez la LED rouge
mfrc522.PICC_HaltA();
mfrc522.PCD_StopCrypto1();
//Serial.println(nomCarte);
if (nomCarte == "ORGA")
{
digitalWrite(ledColorIndex[ledColorGreen], ledOn); // Allumez la LED verte
delay(2000);
lcdA.clear();
lcdA.setCursor(0, 0);
lcdA.print("Veuillez choisir");
lcdA.setCursor(0, 1);
lcdA.print("le mode de jeux.");
jeuEtatSet(jeuEtatArrete, F("waitForNFCCard()"));
return true; // Si une carte est lue, retournez true
}
else
{
Serial.println("Carte " + nomCarte + " INVALIDE");
ledWarning(3, 400);
//return false;
}
}
}
//------------------------------------- Etats du jeu
void jeuEtatSet(int etat, String remarque)
{
jeuEtat = etat;
Serial.println("Etat " + jeuEtatLabel[etat]);
if (remarque != "")
{
Serial.println("\t" + remarque);
}
}
String uidGetNameByCardRead() // Retourne le nom via lecture badge
{
String uidCard = uidLireCarte(true);
int uidIndex = uidRecherche(uidCard);
//Serial.println(uidIndex);
if (uidIndex != -1) // Si UID trouvé
{
uidEeprLireUn(uidIndex);
return (String)uidMem.nom; // Retourne le nom
}
return "-"; // Pas trouvé
}
//------------------------------------- Rechercher UID
int uidRecherche(String uidRech)
{
for (int u = 0; u < uidNombre; u ++)
{
uidEeprLireUn(u);
if ((String)uidMem.uid == uidRech)
{
return u;
}
}
return -1; // Pas trouvé
}
String uidRechercheNameByUid(String uidRech)
{
int uidIndex = uidRecherche(uidRech);
if (uidIndex != -1) // Si UID trouvé
{
uidEeprLireUn(uidIndex);
return (String)uidMem.nom; // Retourne le nom
}
return "-"; // Pas trouvé
}
//------------------------------------- Rechercher UID NOM
int uidRechercheNom(String uidNomRech)
{
for (int u = 0; u < uidNombre; u ++)
{
uidEeprLireUn(u);
if ((String)uidMem.nom == uidNomRech)
{
return u;
}
}
return -1; // Pas trouvé
}
//------------------------------------- lire 1 UID depuis EEPROM dans uidWork
void uidEeprLireUn(int uidIndex)
{
int eeprAddress = eeprOffsetUid + (uidRecordSize * uidIndex);
eeprom24C.readBlock(eeprAddress, (uint8_t *) &uidMem, sizeof(uidMem));
}
//------------------------------------- Lister les UID dans l'EEPROM
void uidEeprList()
{
Serial.println(F("Contenu de l'EEPROM"));
for (int a = eeprOffsetUid; a < eeprOffsetUid + (uidNombre * uidRecordSize); a += uidRecordSize)
{
eeprom24C.readBlock(a, (uint8_t *) &uidMem, sizeof(uidMem));
Serial.println((String)uidMem.uid + "\t" + (String)uidMem.nom);
}
}
String uidLireCarte(boolean echo) {
String uid = "";
if (mfrc522.PICC_IsNewCardPresent() && mfrc522.PICC_ReadCardSerial()) {
for (int i = 0; i < mfrc522.uid.size; i++) {
uid.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : ""));
uid.concat(String(mfrc522.uid.uidByte[i], HEX));
}
uid.toUpperCase();
if (echo) {
Serial.print(F("\nUID : "));
Serial.println(uid);
}
// Ajout de messages de débogage pour vérifier l'état du module RFID
Serial.println(F("Carte détectée et lue avec succès."));
} else {
// Ajout de messages de débogage pour vérifier l'état du module RFID
Serial.println(F("Aucune carte détectée ou erreur de lecture."));
}
return uid;
}
void ledWarning(int loop, unsigned long time)
{
for (int l = 0; l < loop; l ++)
{
digitalWrite(ledColorIndex[ledColorRed], ledOn);
delay(time);
digitalWrite(ledColorIndex[ledColorRed], !ledOn);
delay(time);
}
}
OFF
OFF
Bouton pressé. Début de la commande radio.
ON
Periode 85998
OFF
Maintenant, tu déconnectes le fil sur la pin 9.
Le relais tire toujours?
Avec ce paramètre:
const int radioCommandeEtatOn = HIGH; // Etat pour faire tirer le relais
Mets un voltmètre entre GND et la pin 9
Tu fais un reset de l'Arduino
Tu dois mesurer 0v. sur 9
Tu presses le bouton sur pin 2
tu dois mesurer 5V. sur 9
Comment je fait ça ?
Pour le moment 3.3V
Oui il tire toujours
En pressant le bouton sur l'Arduino.
Si tu presses le bouton qui est sur pin2 est ce que ca passe à à peu près 0v., toujours fil déconnecté.?
Si le fil est déconnecté, cela laisse supposer que ton module relais est out 
Non le module relais fonctionne bien. Ci le fil est déconnecté, il est pas actif.
et la mesure au voltmètre?
C'est contradictoire avec:
Ba quand le pin 9 est relié, il tire. Une fois déconnecté, il ne tire pas. Et 3.3v non stop