Airsoft Krispies

Bonjour à tous et bienvenue


    [Droop] Respawn type Battlefield flag (arduino)

    Partagez
    avatar
    k-oui
    vis rouillée
    vis rouillée

    Messages : 23
    Date d'inscription : 23/08/2014
    Age : 51
    Localisation : Eure et Loir

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par k-oui le Mer 22 Oct - 21:32

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

    Messages : 17
    Date d'inscription : 08/10/2014
    Age : 36
    Localisation : USA

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Blacksheep2 le Jeu 23 Oct - 22:16

    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.
    avatar
    obelix21
    ecrou argent
    ecrou argent

    Messages : 351
    Date d'inscription : 06/05/2013

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par obelix21 le Ven 24 Oct - 6:51

    du code, du code, on veut du code.... Razz
    avatar
    k-oui
    vis rouillée
    vis rouillée

    Messages : 23
    Date d'inscription : 23/08/2014
    Age : 51
    Localisation : Eure et Loir

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par k-oui le Ven 24 Oct - 14:16

    Pas de soucis je vous donne cela le plus vite possible
    avatar
    k-oui
    vis rouillée
    vis rouillée

    Messages : 23
    Date d'inscription : 23/08/2014
    Age : 51
    Localisation : Eure et Loir

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par k-oui le Mar 28 Oct - 10:09

    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;
              }
           }
    }  

    avatar
    obelix21
    ecrou argent
    ecrou argent

    Messages : 351
    Date d'inscription : 06/05/2013

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par obelix21 le Mar 28 Oct - 19:02

    oh c'est gentil, merci, merci
    avatar
    Blacksheep2

    Messages : 17
    Date d'inscription : 08/10/2014
    Age : 36
    Localisation : USA

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Blacksheep2 le Ven 14 Nov - 2:10

    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.   Embarassed

    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.
    avatar
    droopaille
    boulon platine
    boulon platine

    Messages : 2510
    Date d'inscription : 03/04/2011
    Age : 42
    Localisation : Vitré (35)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par droopaille le Ven 14 Nov - 13:01

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


    _________________
    Toutes mes créations
    avatar
    Blacksheep2

    Messages : 17
    Date d'inscription : 08/10/2014
    Age : 36
    Localisation : USA

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Blacksheep2 le Ven 14 Nov - 14:57

    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. :-)
    avatar
    droopaille
    boulon platine
    boulon platine

    Messages : 2510
    Date d'inscription : 03/04/2011
    Age : 42
    Localisation : Vitré (35)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par droopaille le Ven 14 Nov - 17:57

    great, it is really bigger than i imagine first


    _________________
    Toutes mes créations
    avatar
    Blacksheep2

    Messages : 17
    Date d'inscription : 08/10/2014
    Age : 36
    Localisation : USA

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Blacksheep2 le Ven 14 Nov - 19:19

    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.
    avatar
    Blacksheep2

    Messages : 17
    Date d'inscription : 08/10/2014
    Age : 36
    Localisation : USA

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Blacksheep2 le Dim 16 Nov - 1:13

    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...

    avatar
    Krispies
    Admin

    Messages : 3834
    Date d'inscription : 16/08/2009
    Age : 50
    Localisation : VERS-Pont du gard

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Krispies le Mar 18 Nov - 18:53

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

    avatar
    Blacksheep2

    Messages : 17
    Date d'inscription : 08/10/2014
    Age : 36
    Localisation : USA

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Blacksheep2 le Mar 18 Nov - 19:50

    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.
    avatar
    fs57
    ecrou argent
    ecrou argent

    Messages : 413
    Date d'inscription : 30/01/2012
    Age : 27
    Localisation : Région Sarregueminoise

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par fs57 le Lun 2 Fév - 20:33

    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?
    avatar
    droopaille
    boulon platine
    boulon platine

    Messages : 2510
    Date d'inscription : 03/04/2011
    Age : 42
    Localisation : Vitré (35)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par droopaille le Lun 2 Fév - 20:49

    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.


    _________________
    Toutes mes créations
    avatar
    fs57
    ecrou argent
    ecrou argent

    Messages : 413
    Date d'inscription : 30/01/2012
    Age : 27
    Localisation : Région Sarregueminoise

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par fs57 le Lun 2 Fév - 21:10

    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.
    avatar
    droopaille
    boulon platine
    boulon platine

    Messages : 2510
    Date d'inscription : 03/04/2011
    Age : 42
    Localisation : Vitré (35)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par droopaille le Lun 2 Fév - 22:52

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


    _________________
    Toutes mes créations
    avatar
    Krispies
    Admin

    Messages : 3834
    Date d'inscription : 16/08/2009
    Age : 50
    Localisation : VERS-Pont du gard

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Krispies le Lun 23 Fév - 23:29

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




    avatar
    Naudnaud
    ecrou argent
    ecrou argent

    Messages : 404
    Date d'inscription : 30/08/2011
    Age : 27
    Localisation : Metabief

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Naudnaud le Mar 24 Fév - 2:01

    LA classe !!!!!!!!
    avatar
    pic-pac
    ecrou or
    ecrou or

    Messages : 663
    Date d'inscription : 20/06/2011
    Age : 36
    Localisation : Issoire (63)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par pic-pac le Mar 24 Fév - 7:51

    j'adore!!!
    avatar
    Wood
    boulon d'argent
    boulon d'argent

    Messages : 1110
    Date d'inscription : 03/06/2011
    Age : 39
    Localisation : Liré

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Wood le Mar 24 Fév - 9:55

    Beau travail comme d'habitude
    avatar
    Krispies
    Admin

    Messages : 3834
    Date d'inscription : 16/08/2009
    Age : 50
    Localisation : VERS-Pont du gard

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Krispies le Mar 24 Fév - 10:46

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

    avatar
    droopaille
    boulon platine
    boulon platine

    Messages : 2510
    Date d'inscription : 03/04/2011
    Age : 42
    Localisation : Vitré (35)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par droopaille le Mar 24 Fév - 19:33

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


    _________________
    Toutes mes créations
    avatar
    droopaille
    boulon platine
    boulon platine

    Messages : 2510
    Date d'inscription : 03/04/2011
    Age : 42
    Localisation : Vitré (35)

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par droopaille le Sam 7 Mar - 20:25

    Arrivée des premiers composants ...



    _________________
    Toutes mes créations

    Contenu sponsorisé

    Re: [Droop] Respawn type Battlefield flag (arduino)

    Message par Contenu sponsorisé


      La date/heure actuelle est Mar 17 Oct - 15:17