[Droop] Respawn type Battlefield flag (arduino)

Ok dac je programmerais cela ce week end et je vous montrerais le résultat

k-yes would you please share your Arduino Code? I want to do the same thing with NeoPixels just with more rows. Your code would help me a lot.

du code, du code, on veut du code....

Pas de soucis je vous donne cela le plus vite possible

Comme demandé voici le code de la version 1.3 des KGM (K-oui Game Module)
Si vous avez des questions n'hésitez surtout pas

Code:


// Code Original Droop Juillet 2014
// test Aout 2014 modification pour prise en charge du shield LCD KeyPAD
// Version 1.0 : amélioration du code
// version 1.1 : correction bug affichage mode drapeau (passage en base Neutre)
//               Passage en module signalisation de 10 Pixels
// version 1.2 : Evolution du systeme de signalisation
// version 1.3 : Ajout du mode Girophare au système de signalisation
//               Ajout du choix du mode de signalisation

// Déclaration du matériel (écran)
#include <LiquidCrystal.h>

#define DEBUG_KOUI       1 // Debug Active pas de Pub au début du lancement

// declaration pour l'afficheur lcd
LiquidCrystal lcd(7,6, 5, 4, 3, 2);

// declaration pour le ruban NeoPixel
#include <Adafruit_NeoPixel.h>
#define PIN 9

// Pour les KGM avec module de signalisation de 5 Pixels
//Adafruit_NeoPixel strip = Adafruit_NeoPixel(5, PIN, NEO_GRB + NEO_KHZ800);  

// Pour les KGM avec module de signalisation de 10 Pixels
Adafruit_NeoPixel strip = Adafruit_NeoPixel(10, PIN, NEO_GRB + NEO_KHZ800);  

// Variables pour les tempos
    long TTflag;  // Temps TOTAL basculement base
    long TTamorc;  // Temps TOTAL amorçage bombe
    long TTdesamorc;  // Temps TOTAL desamorcage bombe
    float Tflag;  // Temps barre basculement base    
    float Tamorc;  // Temps barre amorçage bombe
    float Tdesamorc;  // Temps barre désamorçage bombe

    // Définition des pin pour les boutons
    const int BP_PinR = 11;
    const int BP_PinB = 12;      

    // Variable générales
    char szLigne[17];                                 // pour le formattage de la ligne LCD
    char szLigneVide[17]="                ";          // pour effacer une ligne du LCD
    int nIndice;
    // variable pour la gestion du mode de jeu
    char * tszTitreJeu[] = { "","DRAPEAUX        ","BOMBE           "};   // pour afficher le titre du mode de jeu
    unsigned int nNombreJeu=2;                                            // Nombre de Modes de Jeux déclarés
    // Les modes de Jeu
    #define JEU_AUCUN     0
    #define JEU_DRAPEAUX  1
    #define JEU_BOMBE     2
    byte nModeJeu=JEU_AUCUN; // suit le mode de jeu par défaut le mode est aucun
    
    // Ajout version 1.3
    // Variables pour la gestion du mode de signalisation
    char * tszModeSignalisation[] = { "","FIXE            ","GLIGNOTANT      ","GIROPHARE       "};  // pour afficher le titre du mode de signalisation
    unsigned int tNombreEtapeSignalisation[]={0,0,2,10};                                             // Le nombre d'étape dans le mode de signalisation
    unsigned long tTempsEtapeAffichage[]={0,0,250,60};                                               // Temps en milliseonde pour changer d'étape
    unsigned int nNombreSignalisation=3;                                                             // Nombre de Modes de signalisation déclarés
    // Les define pour la programmation des modes de signalisation dans la fonction affiche_couleurAvecEtape();
    #define SIGNALISATION_AUCUN 0
    #define SIGNALISATION_FIXE 1
    #define SIGNALISATION_GLIGNOTANT 2
    #define SIGNALISATION_GIROPHARE 3
    byte nModeSignalisation=SIGNALISATION_FIXE; // suit le mode de jeu par défaut le mode est SIGNALISATION_FIXE

    unsigned long ulDernierTempsAffichage=0;    // utilisée pour gérer l'affichage de la signalisation
    byte nIndiceEtapeAffichage=0;               // Indice de l'étape de signalisation en cours

    // les différents état de la base
    #define BASE_NEUTRE 0
    #define BASE_BLEUE  1
    #define BASE_ROUGE  2    
    byte nEtatBase=BASE_NEUTRE; // suit l'état de la base par défaut la base est neutre
 

    int etat_boutonR;
    int etat_boutonB;
    
    int rouge;
    int bleu;

    // Variables Compteurs Drapeaux
    unsigned long compteurB; unsigned long compteurR;
    unsigned long TinitB; unsigned long TinitR;
    unsigned long TinterB; unsigned long TinterR;
 
 
    // Variables Compteur Bombe
    unsigned long timeCalcVar;
    unsigned long minutes;
    unsigned long secondes;
    unsigned long TimeInit;

    // Création des caractères pour la barre de défilement
    byte bar0[8] = {B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000};
    byte bar1[8] = {B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000};
    byte bar2[8] = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000};
    byte bar3[8] = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100};
    byte bar4[8] = {B11110,B11110,B11110,B11110,B11110,B11110,B11110,B11110};
    byte bar5[8] = {B11111,B11111,B11111,B11111,B11111,B11111,B11111,B11111};
    byte bar6[8] = {B00001,B00001,B00001,B00001,B00001,B00001,B00001,B00001};




// Fonctions pour la gestions du ruband Led

// affiche une couleur sur toutes les led
void affiche_couleur(uint32_t c) {
    uint16_t i;
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
    }
    strip.show();
}
// Fonction qui confirme la prise en compte d'un appui de bouton pendant le paramétrage
void Confirmation(){
  uint16_t i;
  for(i=0; i<2; i++) {
    affiche_couleur( strip.Color(0,255, 0));
    delay(50);
    affiche_couleur( strip.Color(0,0, 0));
    delay(40);
  }
}

// Gere l'affichage du module de signalisation en fonction du numéro d'étape en cours
void affiche_couleurAvecEtape(uint32_t c, byte nEtape) {
  uint16_t i;

  switch (nModeSignalisation) {
    case SIGNALISATION_FIXE :{
        // Dans ce mode la couleur est fixe
        // le numéro de l'étape n'est pas utilisé
        affiche_couleur(c);
        break;
    }
    case SIGNALISATION_GLIGNOTANT : {
        // Dans ce mode à chauqe étape on alterne l'affichage des pixels paires et impaires
      
        // reset de toutes les pixels
        for(i=0; i<strip.numPixels(); i++) {
            strip.setPixelColor(i, 0);
          }  
        switch (nEtape){
          case 1 : { // affichage en couleur des pixels pairs
            for(i=0; i<strip.numPixels(); i=i+2) {
              strip.setPixelColor(i, c);
              }
              break;
          }  
          case 2 : // affichage en couleur des pixels impairs
            for(i=1; i<strip.numPixels(); i=i+2) {
              strip.setPixelColor(i, c);
              }
              break;
          }
          strip.show();
          break;
    }
    
    case SIGNALISATION_GIROPHARE :{
        // Dans ce mode on affiche deux pixels contigues
        // et à chaque étape on se décale de une pixel  
        
        // reset de toutes les pixels  
        for(i=0; i<strip.numPixels(); i++) {
            strip.setPixelColor(i, 0);
          }  
        if (nEtape==1) {
          strip.setPixelColor(nEtape-1, c);
          strip.setPixelColor(0, c);
        }
        else {
          strip.setPixelColor(nEtape-1, c);
          strip.setPixelColor(nEtape, c);
        }
        strip.show();
        break;
    }
  }
}

// eteint toutes les led
void blackout()
{
  uint16_t i;
  for (int i = 0 ; i < strip.numPixels(); i++)
    strip.setPixelColor(i, 0, 0, 0);
    
  strip.show();
}
// Affiche les leds les unes apres les autres avec la couleurs de la variable uCouleur
void colorWipe(uint32_t uCouleur, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, uCouleur);
      strip.show();
      delay(wait);
  }
}

// Partie de l'affichage de la base pour le LCD
void AffichageLcdBaseDrapeaux(unsigned int nEtat){
  lcd.setCursor (0,0);
  switch (nEtat){
    case BASE_NEUTRE : {
      lcd.print ( "  BASE  NEUTRE  ");
      affiche_couleurAvecEtape(strip.Color(0, 0, 0),nIndiceEtapeAffichage);
      break;
    }
    case BASE_BLEUE : {
      lcd.print ( "  RESPAWN BLEU  ");
      affiche_couleurAvecEtape(strip.Color(0, 0, 255),nIndiceEtapeAffichage);
      break;
    }
    case BASE_ROUGE : {
      lcd.print ( " RESPAWN  ROUGE ");
      affiche_couleurAvecEtape(strip.Color(255, 0, 0),nIndiceEtapeAffichage);
      break;
    }
  }  

}
// Partie de l'affichage de la base pour la partie signalisation
void AffichageSignalisationBase(unsigned int nEtat){
  
  // Gestion du changement de l'étape de signalisation
  if (nIndiceEtapeAffichage==0) {
    // debut d'un nouvel affichage on force la première étape
      nIndiceEtapeAffichage=1;
      ulDernierTempsAffichage=millis();
    }
  else {
    // On regarde si on change d'étape de signalisation
    if ((millis()-ulDernierTempsAffichage)>tTempsEtapeAffichage[nModeSignalisation]) {
      nIndiceEtapeAffichage++;
      if (nIndiceEtapeAffichage>tNombreEtapeSignalisation[nModeSignalisation])      
        nIndiceEtapeAffichage=1;
        
        ulDernierTempsAffichage=millis();
    }
  }
  switch (nEtat){
    case BASE_NEUTRE : {
      affiche_couleurAvecEtape(strip.Color(0, 0, 0),nIndiceEtapeAffichage);
      break;
    }
    case BASE_BLEUE : {
      affiche_couleurAvecEtape(strip.Color(0, 0, 255),nIndiceEtapeAffichage);
      break;
    }
    case BASE_ROUGE : {
      affiche_couleurAvecEtape(strip.Color(255, 0, 0),nIndiceEtapeAffichage);
      break;
    }
  }
}

void AffichageEtatBaseDrapeaux(unsigned int nEtat){
  AffichageLcdBaseDrapeaux(nEtat);
  AffichageSignalisationBase(nEtat);
}

// Affichage de la barre pleine
void Barre() {
    for (int i=0;i<16;i++) {
      lcd.setCursor(i,1);
      lcd.print ((char)255);
    }  
}  

void menu(){
  // CHOIX JEU
  Tflag = 0;
  Tamorc = 0;
  Tdesamorc = 0;
  minutes = 1;

  // CHOIX du mode de jeu du KGM (K-oui Game Module)
  unsigned int nIndiceJeu;
  unsigned int nIndiceSignalisation;
  #ifdef DEBUG_KOUI
  unsigned int nIndiceJeuLast;
  unsigned int nIndiceSignalisationLast;
  #endif
  
  lcd.clear();
  lcd.setCursor(0, 0 );lcd.write("Choix du JEU    ");
  delay (1200);
  lcd.clear();

  nIndiceJeu=1;
  while (1) {
    #ifdef DEBUG_KOUI
    nIndiceJeuLast=nIndiceJeu;
    #endif
    // etat des boutons
    etat_boutonB = digitalRead(BP_PinB);
    etat_boutonR = digitalRead(BP_PinR);    
    
    // On affiche le choix Suivant
    if (etat_boutonB == HIGH ) {
      nIndiceJeu ++;
      if (nIndiceJeu>nNombreJeu) {nIndiceJeu=1;}
      delay (200);
    }
    
    #ifdef DEBUG_KOUI
    if (nIndiceJeuLast!=nIndiceJeu) {
      Serial.print("Indice :");Serial.println(nIndiceJeu);}
    #endif
      
    // Le jeu est selectionné  
    if (etat_boutonR == HIGH ) {
      Confirmation();
      nModeJeu = nIndiceJeu;
      // Confirmation du Jeu
/*      for (nIndice=1 ; nIndice<3 ; nIndice++) {
        lcd.clear();
        delay (500);
        lcd.setCursor(0, 0);
        lcd.print("JEU :");
        lcd.setCursor(6, 0);
        lcd.print(tszTitreJeu[nModeJeu]);    
        delay (500);
      }*/
      // le mode de jeu est choisi
      break;
    }
    lcd.setCursor(0, 0);
    lcd.print("JEU :");
    lcd.setCursor(6, 0);
    lcd.print(tszTitreJeu[nIndiceJeu]);    
    lcd.setCursor(0, 1);    
    lcd.print("(B)-Suiv. (R)-OK");
  }
 
  // on selectionne le mode de signalisation
  lcd.clear();
  lcd.setCursor(0, 0 );lcd.write("Choix de l'AFF  ");
  delay (1200);
  
  nIndiceSignalisation=1;
  nEtatBase=BASE_BLEUE;
  nIndiceEtapeAffichage=0;
  while (1) {
    #ifdef DEBUG_KOUI
    nIndiceSignalisationLast=nIndiceSignalisation;
    #endif
    // etat des boutons
    etat_boutonB = digitalRead(BP_PinB);
    etat_boutonR = digitalRead(BP_PinR);    
    
    // On affiche le choix Suivant
    if (etat_boutonB == HIGH ) {
      nIndiceSignalisation ++;
      if (nIndiceSignalisation>nNombreSignalisation) {nIndiceSignalisation=1;}
      
      // on affiche le mode de signalisation selectionné
      nModeSignalisation = nIndiceSignalisation;
      nEtatBase=BASE_BLEUE;
      nIndiceEtapeAffichage=0;
      AffichageSignalisationBase(nEtatBase);
      delay (200);
    }
    
    #ifdef DEBUG_KOUI
    if (nIndiceSignalisationLast!=nIndiceSignalisation) {
      Serial.print("Indice :");Serial.println(nIndiceSignalisation);}
    #endif
      
    // Le jeu est selectionné  
    if (etat_boutonR == HIGH ) {
      Confirmation();
      // On eteint la signalisation
      blackout();  
      nModeSignalisation = nIndiceSignalisation;
      // Confirmation du Jeu
      for (nIndice=1 ; nIndice<4 ; nIndice++) {
        lcd.clear();
        delay (500);
        lcd.setCursor(0, 0);
        lcd.print(tszTitreJeu[nIndiceJeu]);
        lcd.setCursor(0, 1);
        lcd.print(tszModeSignalisation[nModeSignalisation]);    
        delay (500);
      }
      // le mode de jeu est choisi
      break;
    }
    lcd.setCursor(0, 0);
    lcd.print("AFF :");
    lcd.setCursor(6, 0);  
    lcd.print(tszModeSignalisation[nIndiceSignalisation]);    
    lcd.setCursor(0, 1);    
    lcd.print("(B)-Suiv. (R)-OK");
    
    // on simule le mode de signalisation
    AffichageSignalisationBase(nEtatBase);    
  }
  
  // affichage du titre du jeu sélectionné
  lcd.clear();
  lcd.setCursor(0, 0);    
  lcd.write("PARAM. ");
  lcd.setCursor(7, 0);  
  lcd.write(tszTitreJeu[nModeJeu]);  
  delay(500);                  

  // Saisie des informations pour CAPTURE DRAPEAUX
  if (nModeJeu == JEU_DRAPEAUX){
      // Temps de prise du drapeau
      while (1){
          if (digitalRead(BP_PinB) == HIGH) {
            TTflag = TTflag + 5;
            
            // version 1.2 On boucle par pas de 5 secondes sur 1 minute
            if (TTflag>60) TTflag=0; // gestion du temps maxi
            delay(300);}
            
          if (digitalRead(BP_PinR) == HIGH)
            {Confirmation();Tflag = TTflag *1000 /16; delay(500);break;}
            
          lcd.setCursor(0, 1 );lcd.print("TEMPS : "); lcd.print (TTflag);lcd.print ("sec  ");
      }
    }


  // Saisie des informations pour BOMBE
  if (nModeJeu == JEU_BOMBE){
      // Temps Compte à Rebour Bombe
      while (1){
        if (digitalRead(BP_PinB) == HIGH) {
          minutes ++;
          if (minutes>60) minutes=1; // gestion du temps maxi
          delay(300);
        }
        if (digitalRead(BP_PinR) == HIGH) {Confirmation(); delay(200);break;}
        
        lcd.setCursor(0, 1 );lcd.print("DUREE : "); lcd.print (minutes);lcd.print ("min  ");
      }

      // Temps Amorçage Bombe
      while (1){
        if (digitalRead(BP_PinB) == HIGH) {
          TTamorc = TTamorc + 5;
          if (TTamorc>60) TTamorc=0; // gestion du temps maxi
          delay(300);
        }
        if (digitalRead(BP_PinR) == HIGH)
          {Confirmation();Tamorc = TTamorc *1000 /16; delay(200); break;}
          
        lcd.setCursor(0, 1 );lcd.print("AMORCAGE : "); lcd.print (TTamorc);lcd.print ("sec  ");
      }

      // Temps Désamorçage Bombe
      while (1){
        if (digitalRead(BP_PinB) == HIGH) {
          TTdesamorc = TTdesamorc + 5;
          if (TTdesamorc>60) TTdesamorc=0; // gestion du temps maxi
          delay(300);
        }
        if (digitalRead(BP_PinR) == HIGH)
          {Confirmation();Tdesamorc = TTdesamorc *1000 /16; break;}
          
        lcd.setCursor(0, 1 );lcd.print("DESAMORC.: "); lcd.print (TTdesamorc);lcd.print ("sec  ");
      }
   }
}


// MODE CAPTURE DE DRAPEAUX
// Appui bouton BLEU
void blue(){
    if (etat_boutonB == HIGH ){
      // Ajout K-OUI : tant que le bouton Bleu est appuyé et que la base n'est pas bleue
      while(etat_boutonB == HIGH & bleu == 0 ) {
          // Base Neutre --> Base Bleue
          if (rouge == 0){
               lcd.setCursor(0,1); lcd.print(szLigneVide);
                 for (int i = 0; i<=15; i++){
                   for (int j = 1; j<=5; j++){
                       lcd.setCursor(i,1);
                       lcd.write((uint8_t) j);
                       delay (Tflag/5);
                       etat_boutonB = digitalRead(BP_PinB);
                       if (etat_boutonB == LOW){break;}
                       // Basculement Base Bleue
                       if (i == 15 && j == 5){
                           bleu = 1;
                           TinitB = millis();
                          
                           nEtatBase=BASE_BLEUE;
                           nIndiceEtapeAffichage=0;
                           AffichageEtatBaseDrapeaux(nEtatBase);
                       }
                       AffichageEtatBaseDrapeaux(nEtatBase);
                     }
                 if (etat_boutonB == LOW){break;}
               }  
            }                
            
            // Base Rouge --> Base Neutre
            if (rouge == 1){
                Barre();
                for (int i = 15; i>=0; i--){
                     for (int j = 5; j>=0; j--){
                         lcd.setCursor(i,1);
                         lcd.write((uint8_t) j);
                         delay (Tflag/5);
                         etat_boutonB = digitalRead(BP_PinB);
                         if (etat_boutonB == LOW){Barre(); break;}

                        // Basculement Base Neutre                            
                         if (i == 0 && j == 0){
                             rouge = 0;
                             TinterR = compteurR;
                             nEtatBase=BASE_NEUTRE;
                             nIndiceEtapeAffichage=0;
                             AffichageEtatBaseDrapeaux(nEtatBase);
                         }
                        AffichageEtatBaseDrapeaux(nEtatBase);  
                     }
                     if (etat_boutonB == LOW){Barre(); break;}
                }  
            }  
            etat_boutonB = digitalRead(BP_PinB);
            delay (Tflag);
       }  
    }  
}  



// Appui bouton ROUGE
void red(){

    if (etat_boutonR == HIGH ){
          // Ajout K-OUI tant que le bouton Rouge est appuyé et que la base n'est pas rouge
          while(etat_boutonR == HIGH & rouge == 0 ) {
 
                // Base Neutre --> Base Rouge
                if (bleu == 0){
                     lcd.setCursor(0,1); lcd.print(szLigneVide);
                    for (int i = 0; i<=15; i++){
                         for (int j = 1; j<=5; j++){
                             lcd.setCursor(i,1);
                             lcd.write((uint8_t) j);
                             delay (Tflag/5);
                             etat_boutonR = digitalRead(BP_PinR);
                         if (etat_boutonR == LOW){break;}
                            // Basculement Base Rouge
                            if (i == 15 && j == 5){
                               rouge = 1;
                               TinitR = millis();                                
                               nEtatBase=BASE_ROUGE;
                               nIndiceEtapeAffichage=0;
                               AffichageEtatBaseDrapeaux(nEtatBase);
                            }
                            AffichageEtatBaseDrapeaux(nEtatBase);
                         }
                    if (etat_boutonR == LOW){break;}
                    }  
                }                
                
                // Base Bleu --> Base Neutre
                if (bleu == 1){
                    Barre();
                    for (int i = 15; i>=0; i--){
                         for (int j = 5; j>=0; j--){
                             lcd.setCursor(i,1);
                             lcd.write((uint8_t) j);
                             delay (Tflag/5);
                             etat_boutonR = digitalRead(BP_PinR);
                             if (etat_boutonR == LOW){Barre(); break;}
                            
                             // Basculement Base Neutre                            
                             if (i == 0 && j == 0){
                                 bleu = 0;
                                 TinterB = compteurB;
                                 nEtatBase=BASE_NEUTRE;
                                 nIndiceEtapeAffichage=0;
                                 AffichageEtatBaseDrapeaux(nEtatBase);
                             }
                             AffichageEtatBaseDrapeaux(nEtatBase);
                         }
                       if (etat_boutonR == LOW){Barre(); break;}
                    }  
                }              

                etat_boutonR = digitalRead(BP_PinR);
                delay (Tflag);
          }  
    }  
}  

// Fonction Calcul Compte à Rebour de la Bombe
// Cette fonction formatte l'affichage de la deuxième ligne du lcd en mode drapeau.
void printCompteurs (unsigned long compteurB, unsigned long compteurR){
  unsigned long timeCalc;

// Affichage Compteur Bleu
  timeCalc = (compteurB/60000);
  lcd.setCursor(0,1); lcd.print("B ");
// Affichage Minutes Bleu
  if((timeCalc%60)<10){lcd.print("0"); lcd.print(timeCalc%60);}
    else {lcd.print(timeCalc%60);}
  lcd.print(":");
// Affichage Secondes Bleu
  timeCalc=(compteurB/1000);
  if((timeCalc%60)<10){lcd.print("0"); lcd.print(timeCalc%60);}
    else {lcd.print(timeCalc%60);}
  lcd.print(" ");

  // Affichage Compteur Rouge
  timeCalc=(compteurR/60000);
  lcd.write((uint8_t) 1);
  // Affichage Minutes Rouge
  if((timeCalc%60)<10){lcd.print("0"); lcd.print(timeCalc%60);}
    else {lcd.print(timeCalc%60);}
  lcd.print(":");
  // Affichage Secondes Rouge
  timeCalc=(compteurR/1000);
  if((timeCalc%60)<10){lcd.print("0"); lcd.print(timeCalc%60);}
    else {lcd.print(timeCalc%60);}
  lcd.print(" R");
}

void flag(){
  nEtatBase=BASE_NEUTRE;
  while(1){  

    //lecture de l'état des boutons
    etat_boutonB = digitalRead(BP_PinB);
    etat_boutonR = digitalRead(BP_PinR);
    if (etat_boutonB == HIGH ){blue();}
    if (etat_boutonR == HIGH ){red();}

    // positionnement de l'état de la base et des compteurs de prise de drapeaux
    nEtatBase=BASE_NEUTRE; // etat standard
    
    if (bleu==1) {
      // La base est bleue actuellement
      nEtatBase=BASE_BLEUE;
      compteurB = TinterB + millis() - TinitB;
    }
    if (rouge == 1) {
      // La base est rouge actuellement
      nEtatBase=BASE_ROUGE;
      compteurR = TinterR + millis() - TinitR;
    }
    AffichageEtatBaseDrapeaux(nEtatBase);
    printCompteurs (compteurB, compteurR);
  }
}  



// JEU BOMBE

// Fonction Calcul Compte à Rebourd de la Bombe
void printTime(unsigned long minutes, unsigned long secondes){

    timeCalcVar=(minutes-secondes/60000);
    lcd.setCursor(0,1); lcd.print("     ");
    // Affichage Minutes
    if((timeCalcVar%60)<10){lcd.print("0");
      lcd.print(timeCalcVar%60);}
    else
      lcd.print(timeCalcVar%60);
    lcd.print(":");
    // Affichage Secondes
    timeCalcVar=(secondes/1000);
    if((59-(timeCalcVar%60))<10){lcd.print("0");
      lcd.print(59-(timeCalcVar%60));}
    else
      lcd.print(59-(timeCalcVar%60));
    lcd.print("      ");
}


// Fin Scénario Bombe : Bombe explose
void Boum(){
    lcd.clear();
    
    // la remanence du texte est réalisée par le LCD pas besoin de la faire à chaque boucle
    lcd.setCursor(0,0); lcd.print("      BOUM      ");
    if (bleu == 1){lcd.setCursor(0,1);lcd.print( "  BLEU   GAGNE  ");}
    if (rouge == 1){lcd.setCursor(0,1);lcd.print("  ROUGE  GAGNE  ");}
    while (1){
        // on affiche avec la couleur de l'équipe qui à gagnée
        if (bleu == 1)
          colorWipe(strip.Color(0, 0, 255), 50); // Blue
        if (rouge == 1)
          colorWipe(strip.Color(255, 0, 0), 50); // Rouge
        delay (200);
        blackout();
        delay (200);
    }
}


// Fin Scénario Bombe : Bombe désamorcée
void PasBoum(){
    lcd.clear();
    // la remanence du texte est réalisée par le LCD pas besoin de la faire à chaque boucle
    lcd.setCursor(0,0); lcd.print("BOMBE DESAMORCEE");
    if (bleu == 1){lcd.setCursor(0,1);lcd.print("  ROUGE  GAGNE  ");}
    if (rouge == 1){lcd.setCursor(0,1);lcd.print("   BLEU GAGNE   ");}
    while (1){
        // on fait clignoter selon la couleur qui à gagnée
        if (bleu == 1)
          colorWipe(strip.Color(255, 0, 0), 50); // Rouge
        if (rouge == 1)
          colorWipe(strip.Color(0, 0, 255), 50); // Bleu
        delay (200);
        blackout();
        delay (200);
    }
}


// Amorçage Bombe
void Amorcage(){

// --> BOMBE BLEU
    if (digitalRead(BP_PinB) == HIGH ){
        while(digitalRead(BP_PinB) == HIGH & bleu == 0 ) {
            lcd.print(szLigneVide);
            for (int i = 0; i<=15; i++){
                for (int j = 1; j<=5; j++){
                    lcd.setCursor(i,1);
                    lcd.write((uint8_t) j);
                    delay (Tamorc/5);                
                    if (digitalRead(BP_PinB) == LOW){break;}
                    // Amorçage complet
                    if (i == 15 && j == 5){
                        bleu = 1;
                        nEtatBase=BASE_BLEUE;
                        nIndiceEtapeAffichage=0;
                        AffichageSignalisationBase(nEtatBase);                      
                    }
                }
                
                if (digitalRead(BP_PinB) == LOW){break;}
            } // End for i
            if (digitalRead(BP_PinB) == LOW){break;}
            delay (Tamorc);
        }  //end while
    }  //end if
    
// --> BOMBE ROUGE
    if (digitalRead(BP_PinR) == HIGH ){
        while(digitalRead(BP_PinR) == HIGH & rouge == 0 ) {
            lcd.print(szLigneVide);
            for (int i = 0; i<=15; i++){
                for (int j = 1; j<=5; j++){
                    lcd.setCursor(i,1);
                    lcd.write((uint8_t) j);
                    delay (Tamorc/5);
                    if (digitalRead(BP_PinR) == LOW){break;}
                    // Amorçage complet
                    if (i == 15 && j == 5){
                        rouge = 1;
                        nEtatBase=BASE_ROUGE;
                        nIndiceEtapeAffichage=0;
                        AffichageSignalisationBase(nEtatBase);                          
                    }
                }
                if (digitalRead(BP_PinR) == LOW){break;}
            }
            if (digitalRead(BP_PinR) == LOW){break;}
            delay (Tamorc);
        }  
    }  
}



// Fonction désamorçage de la Bombe
void Desamorcage(){

    // Si la Bombe est Bleu
    if (bleu == 1){
        Barre();
        while (bleu == 1 ){
            for (int i = 15; i>=0; i--){
                for (int j = 5; j>=0; j--){
                    lcd.setCursor(i,1);
                    lcd.write((uint8_t) j);
                    delay (Tdesamorc/5);
                    // Gestion de l'arret de l'appui sur le bouton
                    if (digitalRead(BP_PinR) == LOW){Barre();break;}
                    // Désamorcage Complet                            
                    if (i == 0 && j == 0)
                      PasBoum();
                      
                    // Permet de garder la signalisation pendant les appuis sur les boutons
                    AffichageSignalisationBase(nEtatBase);
  
                }
                // Gestion de l'arret de l'appui sur le bouton
                if (digitalRead(BP_PinR) == LOW){Barre();break;}

            }
            // Gestion de l'arret de l'appui sur le bouton
            if (digitalRead(BP_PinR) == LOW){Barre();break;}

        }
    }                

    // Si la Bombe est Rouge
    if (rouge == 1){
        Barre();
        while (rouge == 1 ){
            for (int i = 15; i>=0; i--){
                for (int j = 5; j>=0; j--){
                    lcd.setCursor(i,1);
                    lcd.write((uint8_t) j);
                    delay (Tdesamorc/5);
                    
                    // Gestion de l'arret de l'appui sur le bouton
                    if (digitalRead(BP_PinB) == LOW){Barre(); break;}
                    
                // Désamorcage Complet                            
                    if (i == 0 && j == 0){PasBoum();}
                } // End for j
                
                // Gestion de l'arret de l'appui sur le bouton
                if (digitalRead(BP_PinB) == LOW){Barre(); break;}
                
                // Permet de garder la signalisation pendant les appuis sur les boutons
                AffichageSignalisationBase(nEtatBase);

            }
            // Gestion de l'arret de l'appui sur le bouton
            if (digitalRead(BP_PinB) == LOW){Barre(); break;}
        }
    }                  
}


// Fonction principale du mode Bombe
void bombe(){
  
  lcd.clear();
  lcd.setCursor(0,0); lcd.print("     BOMBE     ");

  minutes = minutes - 1; // pourquoi ?
    
  while(1){
    if (digitalRead(BP_PinB) == HIGH ){Amorcage();}
    if (digitalRead(BP_PinR) == HIGH ){Amorcage();}
    
    // La Bombe est Bleu
    if (bleu == 1){
        TimeInit=millis(); //  initialTime in millisec
        while(bleu == 1){
          secondes=millis()- TimeInit;
          // Affichage Temps
          printTime(minutes, secondes);

          // Vérification désamorçage
          if (digitalRead(BP_PinR) == HIGH)
            Desamorcage();
            
          // Vérification fin compte à rebourd
          if(minutes-secondes/60000==0 && 59-((secondes/1000)%60)==0)
            Boum();
            
          AffichageSignalisationBase(nEtatBase);
        }
    }

    // La Bombe est Rouge    
    if (rouge == 1){
        TimeInit=millis(); //  initialTime in millisec
        while(rouge == 1){
          secondes=millis()- TimeInit;
          // Affichage Temps
          printTime(minutes, secondes);
          // Vérification désamorçage
          if (digitalRead(BP_PinB) == HIGH)
            Desamorcage();
          
          // Vérification fin compte à rebour
          if(minutes-secondes/60000==0 && 59-((secondes/1000)%60)==0)
            Boum();
          
          AffichageSignalisationBase(nEtatBase);
        }
    }

    if (bleu == 0 & rouge == 0)
        {lcd.setCursor(0,1); lcd.print(szLigneVide);}
  }
}  




void setup(){   
#ifdef DEBUG_KOUI
    // activage du mode Debug si il est demande
    Serial.begin(9600);
#endif

  // Initialisation du NeoPixal
    strip.begin();
    blackout();
    strip.show(); // Initialize all pixels to 'off'    
  
    // Déclaration des E/S des boutons
    pinMode(BP_PinR, INPUT);
    pinMode(BP_PinB, INPUT);

    // Affectation des positions des caractères de la barre de défilement
    lcd.createChar(0, bar0);
    lcd.createChar(1, bar1);
    lcd.createChar(2, bar2);
    lcd.createChar(3, bar3);
    lcd.createChar(4, bar4);
    lcd.createChar(5, bar5);
    lcd.createChar(6, bar6);
    


    lcd.begin(16, 2);
    lcd.clear();
    
#ifndef DEBUG_KOUI
    // L'introduction est affichee uniquement en mode release
    lcd.setCursor(5, 0 );
    lcd.print("K-OUI");
    lcd.setCursor(0, 1 );
    lcd.print( "  Game  Module  " );
    delay(1000);
    
    lcd.setCursor( 0, 0 );
    lcd.print( "    By K-OUI    " );
    lcd.setCursor( 0, 1 );
    lcd.print( " (version  1.3) " );
    delay(2000);
    lcd.clear();
#endif

    // Mise à zéro compteur
    TinitB = 0; TinitR = 0;  
    TinterB = 0; TinterR = 0;
    compteurB = 0; compteurR = 0;
    bleu = 0; rouge = 0;

    // Appel menu jeu
    menu();
    
    lcd.clear();
    delay (1000);
    
}

void loop(){
  switch (nModeJeu)              
       {
         case JEU_DRAPEAUX:   // Jeu selectionné DRAPEAUX
          {
           flag(); break;
          }
         case JEU_BOMBE:      // Jeu selectionné BOMBE
          {
           bombe(); break;
          }
       }
}  



oh c'est gentil, merci, merci

Thank you for sharing your code.

I figured I would put up my project if anyone is interested in checking it out or contributing. My arduino skills are not as good as many of you.  

Blacksheep Prop on GitHub
I have up my whole current Arduino project including Frizing.

Also have some of my issues and features I am hoping to get working.
Any help would be greatly appreciated!

Here is my light display I plan to use with my prop using NeoPixels.

nice
is there several columns of led lighted at the same time ?

Actually its one continues strand of lights wound up a 2" piece of PVC pipe.  The LED's are addressable so I can program to do any number of animations.

It essentially ends up being 12 rows x 12 columns of lights (round), I basically tell the program to turn two lights on then skip a bunch then turn on two more and so on all the way up the strand.  Then animate it.

This is only a test script running included with neopixel library just to get an idea.  This will be the lighting display I use during the domination mode to show which side controls point.

I do want to add more animations for when a team is capturing, ect.  Will probably have it fill up the whole light like the loading bar on the LCD from top to bottom, not fully sure how I will or how to do it, yet.

Here is a descriptive video, sorry its in English but thats all this dumb american knows. :-)

great, it is really bigger than i imagine first

Total Height is 12 inches light section is about 6 inches.

The video I posted with lights on shows them only at half their brightness.

Our events are held in really large areas so we want these to be seen from far away.

I could really use some help with the Domination Game Coding if you have time and can take a look.

I cant get the Scores to update in real time and have kind of messed up the orignal code some messing around with it.

I also want to add in a menu for a return to neutral option. Since our games are 24 hours non-stop I want the control points to go back to neutral after a setable amount of time, say 30mins, this will keep guys moving and capturing points.

Here is my latest video....I got my timers close to how I want them thanks to looking at Droop's code for Battlefield and making some changes....still have much to do...

Alors moi j'aimerai avoir des plans de cablage complet à partir d'un arduino UNO si c'est possible?
Leds et buzzer compris, siouplait??

UNO is too small. Not enough memory and not enough RAM to run Neopixels.

Code and info:
https://github.com/BlacksheepMilSim/BSProp

Parts List
Schematic
Code
Info

Still very much a work in progress. Much left to do.
If any of you guys want to look at code and point out what Im doing wrong or want to help, I would appreciate it.

droopaille a écrit:et hop voici mon code.

http://droopaille.free.fr/Arduino/BattleField.zip

il faut copier le répertoire sur disque, l'ouvrir et double cliquer sur le fichier Battlefield.ino.
Il faut évidemment le logiciel Arduino. Ça ouvre le programme avec plusieurs onglets.

Pour les tests il faut brancher :
l'écran sur 6, 7, 8, 9, 10, 11
diode rouge sur 12
diode bleue sur 13
interrupteur rouge sur 3
interrupteur bleu sur 4

Je vous fais une vidéo qui explique tout ça.

Votre projet est intéressant. J'aimerais bien utiliser celui ci pour agrémenter des parties. Serait il possible d'avoir les schéma électrique?

il te faut juste une carte Arduino et tu câbles comme c'est précisé dans le quote et ça le fait. Les schémas élec c'est pour créer tes propres carte Arduino pour la fab en série.

droopaille a écrit:il te faut juste une carte Arduino et tu câbles comme c'est précisé dans le quote et ça le fait. Les schémas élec c'est pour créer tes propres carte Arduino pour la fab en série.

Pour savoir ou mettre les résistance et les différents composants. Afin d'éviter que sa crame. Les CI, je ne sais ni ou les faire, ni comment. Mais si vous en vendez je suis preneur de 3. Pour 3 points de prise, sur le terrain.

Ce que j'aurais souhaiter avoir : c'était un schéma ou même un dessin, détaillant le montage et lien entre composant (j'avais l'intention d'en faire 3 dans des caisses à munition).


Comme dit je suis débutant en Arduino (initiation rapide lors de mes études), et en électrique. Mon seul but étant de permettre un meilleur jeu à mon association.

oui je peux te vendre des cartes prête à souder, envoi ton mail en MP

Comme promis Droop voici des photos de ma base avec ton prog légèrement modifié et adapté a l'écran 20x4:

LA classe !!!!!!!!

j'adore!!!

Beau travail comme d'habitude

ouai bof, ce con de scotch qui à pas masqué comme je le voulais, du coup y a des bavures!!Pas beau!!

Fait chier, vous faites tous des plus beaux trucs que moi.
Et le mien qu'est toujours pas fini.

Arrivée des premiers composants ...