Je viens de vérifier le relais et l'alimentation se fait sur la ligne 3 et 4 et non 1 et 5 comme tu as mis sur le schéma.
Je vais acheter le relais déja fait 
Bonsoir blazerwood
Tu deviens raisonnable 
Bonne soirée
jpbbricole
Oui je voulais essayer. Mais rien a faire. Je suis pas doué 
Allé, Bonne soirée
Bonjour jpbbricole
Alors j'ai bien reçu le relais déjà fait. Malheureusement, une fois tout bien branché, sans avoir appuyé sur le bouton, la radio est immédiatement enclenchée. Ci je débranche le pin9 elle ce coupe. le bouton n'est pas en cour circuit, j'ai vérifié. Même ci je débranche, le bouton et que je fait contact de la commande sur n’importe quel pin de l’Arduino, ça enclenche la radio.
Bonjour blazerwood
Pas bien grave
Ca vient du fait que certains relais tirent avec un HIGH et d'autres avec un LOW, le tiens tire avec un LOW.
Il faut inverser cette variable:
de
const int radioCommandeEtatOn = HIGH; // Etat pour faire tirer le relais
à
const int radioCommandeEtatOn = LOW; // Etat pour faire tirer le relais
`
A+
jpbbricole
Voici le dernier code avec les changements effectués.
/*
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) // Lire la carte retourne le UID
{
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);
}
}
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);
}
}
Mais le problème est que ni la lecture des cartes ne fonctionne, et même les commandes "Serial.println" ne fonctionnent plus pour celles-ci. Je ne comprends pas, sachant que je n'ai pas touché à celles-ci. Peux-tu me dire où est mon erreur ? Et quand je coupe le fil explosion, l'explosion se fait en boucle. ça me demande le badge, et sans le mettre ça relance le timer ou il c'etais arreté. Merci.
Bonsoir blazerwood
Concernant le relais de la radio, il est bien sur un autre Arduino?
Il devrait être câblé ainsi:
et initialisé ainsi:
const int radioCommandeEtatOn = HIGH; // Etat pour faire tirer le relais
Au lancement du programme il doit avoir, dans le moniteur (115200):
Airsoft commande radio
A la pression du bouton de commande:
Debut commande
Relais ON
et, ensuite, périodiquement,
Periode 100000
Periode 95000
Periode 90000
Periode 85000
le décompte du chrono (il peut y avoir d'autres valeurs)
Tout les radioRefreshTempo millisecondes, il y a un refresh de la commande radio:
Radio refresh
Relais OFF
Relais ON
me fait douter que se soit un problème de programme 
S'il n'y a rien dans le moniteur, c'est la première chose que tu as à régler.
A+
Bonne soirée
jpbbricole
Je n'ai pas compris 
.Tout ce que je peut te dire, c'est qu'avec une vieille version, ça fonctionne.
Oui sur le nano et tout ce que tu a mis est correct. Mais il s’enclenche directement.
Quel texte as tu dans la console, sans toucher le bouton de commande?
Periode 85001
Periode 80001
Bouton pressé. Début de la commande radio.
Et pour l'autre script, tu as trouvé des erreurs ?
et ceci d'entrée sans que tu ne fasses quoi que soit?
Je cherche
Super merci
non j'appuie
Quoi que tu fasses, le relais tire ?
oui, dès que je lance l'alimentation, il claque directement.
Déconnectes le fil de la pin 9 de l'Arduino, est ce que le relais tire toujours?
Si non, en mettant alternativement ce fil sur +5v et sur GND est ce que le relais tire et tombe?
Si je le déconnecte, il tombe, oui. Il claque sur absolument toutes les pins sauf RST et RAW.