carte_strategie_2019

Dependencies:   mbed SerialHalfDuplex SDFileSystem DISCO-F469NI_portrait liaison_Bluetooth ident_crac

Revision:
29:41e02746041d
Parent:
28:acd18776ed2d
Child:
30:a1e37af4bbde
--- a/Strategie/Strategie.cpp	Sat May 27 05:40:26 2017 +0000
+++ b/Strategie/Strategie.cpp	Fri Apr 06 13:47:19 2018 +0000
@@ -1,49 +1,86 @@
- #include "Strategie.h"
- #define M_PI           3.14159265358979323846
+#include "global.h"
+
+//#include "StrategieManager.h"
+
+
+
+#define M_PI 3.14159265358979323846
+#define BLEU 0xFF1467E5
+#define ROUGE 0xFFFF0000
+#define VERT 0xFF00FF00
+#define JAUNE 0xFFFEFE00
+#define BLANC 0xFF000000
+#define DIY_GREY 0xFFDFDFDF 
 
-E_stratGameEtat     gameEtat  = ETAT_CHECK_CARTE_SCREEN;
-E_stratGameEtat     lastEtat  = ETAT_CHECK_CARTE_SCREEN;
-unsigned char screenChecktry = 0;
+char tableau_aff[10][50];
+char tableau_etat[22][50]=
+{
+    "Check_carte_screen",
+    "Check_carte_screen_wait_ack",
+    "Check_cartes",
+    "Check_cartes_wait_ack",
+    "Wait_force",
+    "Config",
+    "Game_init",
+    "Game_wait_for_jack",
+    "Game_start",
+    "Game_next_instruction",
+    "Game_instruction",
+    "Game_wait_ack",
+    "Game_jump_time",
+    "Game_jump_config",
+    "Game_jump_position",
+    "Game_wait_end_instruction",
+    "Warning_timeout",
+    "Waring_end_balise_wait",
+    "Warning_end_last_instruction",
+    "Warning_switch_strategie",
+    "End",
+    "End_loop",
+};
+
+
+
+Ticker ticker;
+TS_DISCO_F469NI ts;
+LCD_DISCO_F469NI lcd;
+
+TS_StateTypeDef TS_State;
+
+Ticker chrono;
+Timeout AffTime;
+Timer timer;
 Timer cartesCheker;//Le timer pour le timeout de la vérification des cartes
-Timer fakeJack;
 Timer gameTimer;
 Timer debugetatTimer;
 Timer timeoutWarning;
 Timer timeoutWarningWaitEnd;
 Timeout chronoEnd;//permet d'envoyer la trame CAN pour la fin 
 
-unsigned short waitingAckID = 0;//L'id du ack attendu
-unsigned short waitingAckFrom = 0;//La provenance du ack attendu
-char modeTelemetre; // Si à 1, indique que l'on attend une reponse du telemetre 
-unsigned short telemetreDistance = 0;
+unsigned char screenChecktry = 0;
+unsigned char test[32] = {32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32};
+
+char counter = 0;
+char check;
+char Jack = 1;
+
+int flag = 0, flag_strat = 0, flag_timer;
+char Ack_strat = 0;
+signed char Strat = 0;
 signed char FIFO_lecture=0;//Position du fifo de lecture des messages CAN
 
 signed short x_robot,y_robot,theta_robot;//La position du robot
 signed short target_x_robot, target_y_robot, target_theta_robot;
 E_InstructionType actionPrecedente;
 signed short start_move_x,start_move_y,start_move_theta;//La position du robot lors du début d'un mouvement, utilisé pour reprendre le mouvement apres stop balise
-
-#ifdef ROBOT_BIG
-//unsigned short id_check[NOMBRE_CARTES]= {CHECK_BALISE,CHECK_MOTEUR,CHECK_ACTIONNEURS,CHECK_AX12,CHECK_POMPES};
-//unsigned short id_alive[NOMBRE_CARTES]= {ALIVE_BALISE,ALIVE_MOTEUR,ALIVE_ACTIONNEURS,ALIVE_AX12,ALIVE_POMPES};
-
-unsigned short id_check[NOMBRE_CARTES]= {CHECK_MOTEUR,CHECK_BALISE,CHECK_ACTIONNEURS_AVANT,CHECK_ACTIONNEURS_ARRIERE};
-unsigned short id_alive[NOMBRE_CARTES]= {ALIVE_MOTEUR,ALIVE_BALISE,ALIVE_ACTIONNEURS_AVANT,ALIVE_ACTIONNEURS_ARRIERE};
+//unsigned char FIFO_ecriture=0; //Position du fifo pour la reception CAN
+int flagSendCan=1;
+unsigned char Cote = 0; //0 -> bleu | 1 -> jaune
 
-InterruptIn jack(p25); //  entrée analogique en interruption pour le jack
-#else
-//unsigned short id_check[NOMBRE_CARTES]= {CHECK_BALISE,CHECK_MOTEUR,CHECK_ACTIONNEURS};
-//unsigned short id_alive[NOMBRE_CARTES]= {ALIVE_BALISE,ALIVE_MOTEUR,ALIVE_ACTIONNEURS};
-
-unsigned short id_check[NOMBRE_CARTES]= {CHECK_MOTEUR};
-unsigned short id_alive[NOMBRE_CARTES]= {ALIVE_MOTEUR};
-
-InterruptIn jack(p25); //  entrée analogique en interruption pour le jack
-#endif
 unsigned char checkCurrent = 0;
 unsigned char countAliveCard = 0; 
 
-unsigned char InversStrat = 1;//Si à 1, indique que l'on part de l'autre cote de la table(inversion des Y)
+signed char Strategie = 0; //N° de la strategie (1-10)
 
 unsigned char ModeDemo = 0; // Si à 1, indique que l'on est dans le mode demo
 
@@ -55,6 +92,61 @@
 
 struct S_Instruction instruction;
 
+float cptf; 
+int cpt,cpt1;  
+
+typedef enum {INIT, ATT, CHOIX, DEMO, DEMO_EN_COURS, SELECT_SIDE, TACTIQUE, DETAILS,LECTURE, LAUNCH, AFF_WAIT_JACK, WAIT_JACK, COMPTEUR, FIN} T_etat;
+T_etat etat = INIT;
+E_stratGameEtat     gameEtat  = ETAT_CHECK_CARTES;
+E_stratGameEtat     lastEtat  = ETAT_CHECK_CARTES;
+
+
+/////////////////DEFINITION DES BOUTONS////////////////////
+    Button COTE_BLEU(0, 25, 400, 300, "Bleu");
+    Button COTE_JAUNE(0, 350, 400, 300, "Jaune");
+    Button RETOUR  (0, 680, 400, 110, "--Precedent--");
+    Button LANCER  (0, 200, 400, 200, "--LANCER--");
+    Button CHECK (0, 420, 400, 200, "Valider");
+    Button MATCH (0, 50, 400, 320, "Match");
+    Button DEMONSTRATION (0, 400, 400, 320, "Demo");
+    Button TEST_MOTEUR(0, 25, 400, 200, "Moteur");
+    Button TEST_BRAS(0, 250, 400, 200, "Bras");
+    Button FORCE_LAUNCH(0, 50, 400, 320, "Force Launch");
+    Button SUIVANT(0,380,200,100,"Suivant");
+    ////////////////////////////////////////////////////////////
+
+void affichage_debug(char *bug);
+void SendRawId (unsigned short id);
+void SelectionStrat (unsigned char numeroStrat);
+void Setflag(void);
+void can2Rx_ISR(void);
+signed char Bouton_Strat (void);
+
+void print_segment(int nombre, int decalage);
+void affichage_compteur (int nombre);
+void effacer_segment(long couleur);
+
+
+#ifdef ROBOT_BIG
+
+
+unsigned short id_check[NOMBRE_CARTES]= {CHECK_MOTEUR,CHECK_BALISE,CHECK_ACTIONNEURS_AVANT,CHECK_ACTIONNEURS_ARRIERE};
+unsigned short id_alive[NOMBRE_CARTES]= {ALIVE_MOTEUR,ALIVE_BALISE,ALIVE_ACTIONNEURS_AVANT,ALIVE_ACTIONNEURS_ARRIERE};
+
+InterruptIn jack(PA_6); //  entrée analogique en interruption pour le jack
+#else
+
+
+unsigned short id_check[NOMBRE_CARTES]= {CHECK_MOTEUR};
+unsigned short id_alive[NOMBRE_CARTES]= {ALIVE_MOTEUR};
+
+
+#endif
+
+
+    
+    
+
 
 /****************************************************************************************/
 /* FUNCTION NAME: chronometre_ISR                                                       */
@@ -64,6 +156,7 @@
 {
     SendRawId(ASSERVISSEMENT_STOP);//On stope les moteurs
     SendRawId(GLOBAL_GAME_END);//Indication fin de match
+    etat=FIN;
     gameTimer.stop();//Arret du timer
 
 #ifdef ROBOT_BIG
@@ -74,6 +167,8 @@
     while(1);//On bloque la programme dans l'interruption
 }
 
+
+
 /****************************************************************************************/
 /* FUNCTION NAME: jack_ISR                                                              */
 /* DESCRIPTION  : Interruption en changement d'état sur le Jack                         */
@@ -81,17 +176,427 @@
 void jack_ISR (void)
 {
     if(gameEtat == ETAT_GAME_WAIT_FOR_JACK) {
-        led4=1;
         gameEtat = ETAT_GAME_START;//On débute le match
+        etat=COMPTEUR;
     }
 }
 
 /****************************************************************************************/
+/* FUNCTION NAME: SelectionStrat                                                        */
+/* DESCRIPTION  : Affiche la Stratégie sélectionnée sur l'ihm                           */
+/****************************************************************************************/
+
+
+void SelectionStrat (unsigned char Strategie)
+{
+    lcd.SetBackColor(LCD_COLOR_WHITE);
+    lcd.SetTextColor(LCD_COLOR_BLACK);
+     
+    switch (Strategie+1)
+    {
+        case 0x1 :
+            //description de Strategie n°1
+            lcd.DisplayStringAt(150, 0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x2 :
+            //description de Strategie n°2
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x3 :
+            //description de Strategie n°3
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x4 :
+            //description de Strategie n°4
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x5 :
+            //description de Strategie n°5
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x6 :
+            //description de Strategie n°5
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x7 :
+            //description de Strategie n°5
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x8 :
+            //description de Strategie n°5
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0x9 :
+            //description de Strategie n°5
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+            
+        case 0xA :
+            //description de Strategie n°5
+            lcd.DisplayStringAt(150,0, (uint8_t *)strat_sd[Strategie], LEFT_MODE);
+            break;
+        }
+}
+
+void Setflag(void)
+{
+    flagSendCan = 1;
+}
+
+void affichage_debug(E_stratGameEtat Var){
+    int i;
+    int conv=(int)Var;
+    SUIVANT.Draw(ROUGE, 0);
+    for(i=0;i<9;i++){
+        strcpy(tableau_aff[i],"");
+        strcpy(tableau_aff[i],tableau_aff[i+1]);
+    }
+    strcpy(tableau_aff[9],tableau_etat[conv]);
+    for(i=0;i<10;i++){
+        lcd.SetBackColor(BLEU);
+        lcd.DisplayStringAt(0, LINE(20+i), (uint8_t *)tableau_aff[i], LEFT_MODE);
+    }  
+    while(!ack_bluetooth){
+        liaison_bluetooth();
+    }
+    ack_bluetooth=0;
+} 
+
+
+void automate_etat_ihm(void)
+{
+    int j;
+    if (j==0){
+        ts.Init(lcd.GetXSize(), lcd.GetYSize());
+        j++;
+    }
+    ts.GetState(&TS_State);       
+    switch (etat)
+    {
+        case INIT :
+            ts.GetState(&TS_State); 
+            canProcessRx();
+                
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+            lcd.Clear (LCD_COLOR_WHITE);
+            wait(0.15);
+            lcd.DisplayStringAt(0, 10, (uint8_t *)"Verification des cartes", LEFT_MODE);
+            //cartes non verifiées////////////////
+            lcd.SetTextColor(DIY_GREY);
+            lcd.FillRect(0,400,400,150); //carte moteur
+            lcd.FillRect(0,600,400,150); //Balise
+            
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+            lcd.SetBackColor(DIY_GREY);
+            lcd.DisplayStringAt(80, 450, (uint8_t *)"Carte Moteur", LEFT_MODE);
+            lcd.DisplayStringAt(110,650 , (uint8_t *)"Balise", LEFT_MODE);
+            ////////////////////////////////////////
+            
+            FORCE_LAUNCH.Draw(0xFFFF0000, 0);
+
+            /*while(flag == 0)
+            {
+                ts.GetState(&TS_State); 
+                canProcessRx();
+                if (FORCE_LAUNCH.Touched())
+                {
+                    etat = CHOIX;
+                    gameEtat = ETAT_CONFIG;
+                    flag = 1;
+                    while(FORCE_LAUNCH.Touched());
+                }
+            }*/ 
+            
+            etat=ATT;
+            break;
+            
+        case ATT :
+            if (flag==1){
+                etat = CHOIX;
+                gameEtat = ETAT_CONFIG;
+            }
+            else if (FORCE_LAUNCH.Touched()){
+                etat = CHOIX;
+                gameEtat = ETAT_CONFIG;
+            }
+                
+            break;
+         
+            
+        case CHOIX :
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+            lcd.Clear (LCD_COLOR_WHITE);
+            lcd.DisplayStringAt(0, LINE(0), (uint8_t *)"Match ou demonstration ?", LEFT_MODE);
+            DEMONSTRATION.Draw(LCD_COLOR_LIGHTGREEN, 0);
+            MATCH.Draw(0xFFF01010, 0);
+            while(etat == CHOIX)
+            {
+                canProcessRx();
+                if(DEMONSTRATION.Touched())
+                {
+                    etat = DEMO;
+                    while(DEMONSTRATION.Touched());
+                }
+                
+                if(MATCH.Touched())
+                {
+                    etat = SELECT_SIDE;
+                    while(MATCH.Touched());
+                }
+
+            }
+            break;
+        
+        case DEMO :                                  
+            lcd.Clear(LCD_COLOR_WHITE);
+
+            TEST_MOTEUR.Draw(0xFFF0F0F0, 0);
+            TEST_BRAS.Draw(0xFFF0F0F0, 0);
+            RETOUR.Draw(0xFFFF0000, 0);
+            if(gameEtat == ETAT_CONFIG) {//C'est bon on a le droit de modifier les config                                     //
+                InversStrat = 0;//Pas d'inversion de la couleur                                 // A changer , discussion avec l'ihm
+            }
+            while (etat == DEMO)
+            {
+                canProcessRx();
+                if(TEST_MOTEUR.Touched())
+                {
+                    Strat = 0x10;
+                    while(TEST_MOTEUR.Touched());
+                    TEST_MOTEUR.Draw(0xFFF0F0F0, 0);
+                    etat = DEMO_EN_COURS;
+                }
+                
+                if(TEST_BRAS.Touched())
+                {
+                    Strat = 0x11;                        
+                    while(TEST_BRAS.Touched());                 
+                    TEST_MOTEUR.Draw(0xFFF0F0F0, 0);
+                    etat = DEMO_EN_COURS;
+                }
+                
+                if(RETOUR.Touched())
+                {
+                    etat = CHOIX;
+                    while(RETOUR.Touched());
+                }
+                if(gameEtat == ETAT_CONFIG) {//C'est bon on a le droit de modifier les config
+                    if (Strat< 0x10){  // Si la strat est une strat de match, on desactive le mode demo
+                            ModeDemo = 0;
+                    }
+                    else {                                        // sinon, on active le mode demo, utile pour la fin de la demo
+                            ModeDemo = 1;
+                    }
+                    
+                    Ack_strat = 1;
+                    wait_ms(10);
+                    tactile_printf("Strat %d, Asser desactive",Strat);
+                }
+                SelectionStrat(Strategie);
+            }
+            break;
+            
+        case DEMO_EN_COURS:
+            lcd.Clear(LCD_COLOR_WHITE);
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.DisplayStringAt(20, LINE(10), (uint8_t *)"DEMONSTRATION EN COURS", LEFT_MODE);
+            
+            
+            while (etat == DEMO_EN_COURS) 
+            {
+                canProcessRx();
+                
+                if (Ack_strat == 1)
+                {
+                    if(gameEtat == ETAT_CONFIG) {
+                        gameEtat = ETAT_GAME_INIT;
+                    }              
+                    while (flag_strat != 1)
+                    {
+                      canProcessRx();
+                    }
+                    etat = DEMO;
+                    flag_strat = 0;  
+                }
+                  
+            }
+            Ack_strat = 0;
+            break;
+            
+        case SELECT_SIDE :
+            lcd.Clear(LCD_COLOR_WHITE);
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+             
+            lcd.DisplayStringAt(70, LINE(0), (uint8_t *)"Choisir le cote", LEFT_MODE);
+            COTE_BLEU.Draw(BLEU, 0);
+            COTE_JAUNE.Draw(JAUNE, 0);
+            RETOUR.Draw(LCD_COLOR_RED, 0);
+            
+                
+            while (etat == SELECT_SIDE) 
+            {
+                canProcessRx();
+                if(COTE_BLEU.Touched()) 
+                {
+                    Cote = 0x0;
+                    InversStrat = Cote;
+                    etat = TACTIQUE;
+                    while(COTE_BLEU.Touched());
+                    envoi_bluetooth(1,'9');
+                }
+                
+                if(COTE_JAUNE.Touched())
+                {
+                    Cote = 0x1;
+                    InversStrat= Cote;
+                    etat = TACTIQUE;
+                    while(COTE_JAUNE.Touched());
+                }
+                
+                if(RETOUR.Touched())
+                {
+                    etat = CHOIX;
+                    while(RETOUR.Touched());
+                }
+            }
+            
+            break;
+                
+        case TACTIQUE :
+            if (Cote == 0){
+                lcd.Clear(BLEU);
+                lcd.SetBackColor(BLEU);
+                }
+            else if (Cote == 1){
+                lcd.Clear(JAUNE);
+                lcd.SetBackColor(JAUNE);
+                }
+            else {
+                lcd.Clear(BLEU);
+                lcd.SetBackColor(BLEU);
+                }
+            
+            lcd.SetTextColor(LCD_COLOR_BLACK); 
+                
+            lcd.DisplayStringAt(20, LINE(0), (uint8_t *)"Choisir une strategie", LEFT_MODE);
+            
+            Strategie = Bouton_Strat(); // retourne valeur de Strategie si bouton strat renvoi -1 on reviens en arriere
+            if (Strategie == -1) 
+            {
+                etat = SELECT_SIDE;
+            }
+            else 
+            {
+                etat = DETAILS;
+            }  
+            wait(0.1);
+            break;
+        
+        case DETAILS :
+            lcd.Clear(LCD_COLOR_WHITE);
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+            CHECK.Draw(VERT);
+            RETOUR.Draw(LCD_COLOR_RED);
+            
+            SelectionStrat(Strategie);
+             
+            while (etat == DETAILS)
+            { 
+                canProcessRx();
+                if (CHECK.Touched())
+                    {
+                        if(gameEtat == ETAT_CONFIG) {
+                            gameEtat = ETAT_GAME_INIT;
+                            etat=LECTURE;
+                            
+                        }
+                        while(CHECK.Touched());
+                    }
+                
+                if(RETOUR.Touched())
+                    {
+                        etat = TACTIQUE;
+                        while(RETOUR.Touched());
+                    }
+            } 
+            break;
+        
+        
+        case LECTURE :
+            break;   
+        case AFF_WAIT_JACK : 
+            lcd.Clear(BLANC);
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+             
+            if (Cote == 0){
+                lcd.Clear(BLEU);
+                lcd.SetBackColor(BLEU);
+                }
+            else if (Cote == 1){
+                lcd.Clear(JAUNE);
+                lcd.SetBackColor(JAUNE);
+                }
+            else {
+                lcd.Clear(BLEU);
+                lcd.SetBackColor(BLEU);
+            }
+            canProcessRx();
+            lcd.DisplayStringAt(0, LINE(0), (uint8_t *)"En attente du Jack", CENTER_MODE); 
+            etat=WAIT_JACK;
+            break;
+            
+        case WAIT_JACK:
+            break;   
+            
+        case COMPTEUR: 
+            cptf=gameTimer.read();
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+            cpt=int(cptf);
+            if(cpt != cpt1){
+                lcd.Clear(BLEU);
+                affichage_compteur(90-cpt);
+            }
+            cpt1=cpt;
+            flag_timer=0;
+
+            affichage_debug(gameEtat);
+            
+            
+            break;
+            
+        case FIN :
+            lcd.Clear (LCD_COLOR_WHITE);
+            lcd.SetBackColor(LCD_COLOR_WHITE);
+            lcd.DisplayStringAt(120, 190, (uint8_t *)"LANCEMENT", LEFT_MODE);
+            lcd.SetTextColor(LCD_COLOR_BLACK);
+            lcd.DisplayStringAt(120, 210, (uint8_t *)"REDEMARAGE", LEFT_MODE);
+            lcd.DisplayStringAt(120, 230, (uint8_t *)"NECESSAIRE", LEFT_MODE);
+            while(1); // force le redemarage du robot  
+            //break;
+            
+    }    
+}
+
+
+
+/****************************************************************************************/
 /* FUNCTION NAME: automate_process                                                      */
 /* DESCRIPTION  : Automate de gestion de la stratégie du robot                          */
 /****************************************************************************************/
-void automate_process(void)
-{
+void automate_process(void){
     static unsigned char AX12_enchainement = 0;
     static unsigned char MV_enchainement = 0;
     signed char localData1 = 0;
@@ -104,6 +609,7 @@
         gameTimer.stop();
         gameTimer.reset();
         gameEtat = ETAT_END;//Fin du temps
+        etat=FIN;
     }
     
     if(lastEtat != gameEtat || debugetatTimer.read_ms() >= 1000) {
@@ -114,43 +620,7 @@
     
     switch(gameEtat)
     {
-        case ETAT_CHECK_CARTE_SCREEN:
-            /*
-            Verification de l'état de la carte ecran
-            */
-            waitingAckFrom = ALIVE_IHM;//On indique que l'on attend un ack de la carte IHM
-            SendRawId(CHECK_IHM);//On demande à la carte IHM d'insiquer ça présence
-            
-            screenChecktry++;//On incrèment le conteur de tentative de 1
-            cartesCheker.reset();//On reset le timeOut
-            cartesCheker.start();//On lance le timer pour le timeout
-            gameEtat = ETAT_CHECK_CARTE_SCREEN_WAIT_ACK;
-            
-            //gameEtat = ETAT_GAME_START;
-            
-        break;
-        case ETAT_CHECK_CARTE_SCREEN_WAIT_ACK:
-            /*
-            Attente du ALIVE de la carte écran.
-            
-            Si la carte ne répond pas apres 10ms, on retoune dans l'etat ETAT_CHECK_CARTE_SCREEN
-            maximum 3 tentatives
-            Si pas de réponse, clignotement de toutes les leds possible
-            */
-            if(waitingAckFrom == 0) {//C'est bon la carte est en ligne
-                cartesCheker.stop();
-                screenChecktry = 0;
-                gameEtat = ETAT_CHECK_CARTES;
-            } else if(cartesCheker.read_ms () > 100) {
-                cartesCheker.stop();
-                if(screenChecktry >=3) {
-                    errorLoop();//Erreur La carte IHM n'est pas en ligne
-                } else {
-                    gameEtat = ETAT_CHECK_CARTE_SCREEN;
-                }
-            }
-        break;
-        case ETAT_CHECK_CARTES:
+        case ETAT_CHECK_CARTES:                   
             /*
             Il faut faire une boucle pour verifier toutes les cartes les une apres les autres
             */
@@ -161,11 +631,8 @@
             cartesCheker.reset();//On reset le timeOut
             cartesCheker.start();//On lance le timer pour le timeout
             gameEtat = ETAT_CHECK_CARTES_WAIT_ACK;
-            
-            
+            break;
             
-            
-        break;
         case ETAT_CHECK_CARTES_WAIT_ACK:
             /*
             On attend l'ack de la carte en cours de vérification
@@ -177,41 +644,46 @@
                 countAliveCard++;
                 checkCurrent++;
                 if(checkCurrent >= NOMBRE_CARTES) {
-                    //printf("all card check, missing %d cards\n",(NOMBRE_CARTES-countAliveCard));
+                    printf("all card check, missing %d cards\n",(NOMBRE_CARTES-countAliveCard));
                     if(countAliveCard >= NOMBRE_CARTES) {
                         gameEtat = ETAT_CONFIG;
-                        SendRawId(ECRAN_ALL_CHECK);//On dit à l'IHM que toutes les cartes sont en ligne
+                        flag=1;
                         tactile_printf("Selection couleur et strategie");
-                    } else {
+                    } 
+                    else {
                         gameEtat = ETAT_WAIT_FORCE;//Passage en attente de forçage du lancement
                         waitingAckFrom = ECRAN_ALL_CHECK;
                     }
-                } else {
+                } 
+                else
                     gameEtat = ETAT_CHECK_CARTES;
-                }
-            } else if(cartesCheker.read_ms () > 100) {
+            } 
+            else if(cartesCheker.read_ms () > 100) {
                 cartesCheker.stop();
                 if(screenChecktry >=3) {
                     //printf("missing card %d\n",id_check[checkCurrent]);
                     screenChecktry = 0;
                     checkCurrent++;
                     
-                    if(checkCurrent >= NOMBRE_CARTES) {
-                        if(countAliveCard == NOMBRE_CARTES) {
+                    if(checkCurrent >= NOMBRE_CARTES){
+                        if(countAliveCard == NOMBRE_CARTES){
                             gameEtat = ETAT_CONFIG;
-                            SendRawId(ECRAN_ALL_CHECK);//On dit à l'IHM que toutes les cartes sont en ligne
-                        } else {
-                            gameEtat = ETAT_WAIT_FORCE;//Passage en attente de forçage du lancement
+                            flag=1; 
+                        } 
+                        else{
+                            gameEtat = ETAT_WAIT_FORCE;
                             waitingAckFrom = ECRAN_ALL_CHECK;
                         }
-                    } else {
+                    } 
+                    else
                         gameEtat = ETAT_CHECK_CARTES;
-                    }
-                } else {
+                    
+                } 
+                else
                     gameEtat = ETAT_CHECK_CARTES;
-                }
+                
             }
-        break;
+            break;
         case ETAT_WAIT_FORCE:
             /*
             Attente du forçage de la part de la carte IHM
@@ -219,7 +691,7 @@
             if(waitingAckFrom == 0) {
                 gameEtat = ETAT_CONFIG;
             }
-        break;
+            break;
         case ETAT_CONFIG:
             /*
             Attente de l'odre de choix de mode,
@@ -227,13 +699,22 @@
             Il est aussi possible d'envoyer les ordres de debug
             */
             modeTelemetre = 0;
-        break;
+            break;
         case ETAT_GAME_INIT:
             //On charge la liste des instructions
-            loadAllInstruction();//Mise en cache de toute les instructions
+            
+            loadAllInstruction(Strategie);//Mise en cache de toute les instructions
+            led3=1;
             
             gameEtat = ETAT_GAME_WAIT_FOR_JACK;
-            SendRawId(ECRAN_ACK_START_MATCH);
+            if (etat == DEMO_EN_COURS) 
+            {
+                SendRawId(DEBUG_FAKE_JAKE);
+            }
+            else
+            {
+                etat = AFF_WAIT_JACK;
+            }                          
             tactile_printf("Attente du JACK.");
             setAsservissementEtat(1);//On réactive l'asservissement
             jack.mode(PullDown); // désactivation de la résistance interne du jack
@@ -264,6 +745,7 @@
             //On attend le jack
         break;
         case ETAT_GAME_START:
+            
             gameEtat = ETAT_GAME_LOAD_NEXT_INSTRUCTION;
             
             if (ModeDemo == 0){
@@ -272,8 +754,9 @@
             } 
             gameTimer.reset();
             jack.fall(NULL);//On désactive l'interruption du jack
-            SendRawId(GLOBAL_START);
-            tactile_printf("Start");//Pas vraiment util mais bon
+            SendRawId(GLOBAL_START);  
+            Jack=0;                                          //à envoyer sur le CAN et en direct pour l'automate de l'ihm ou sur CANV
+            tactile_printf("Start");//Pas vraiment utile mais bon
         break;
         case ETAT_GAME_LOAD_NEXT_INSTRUCTION:
             /*
@@ -299,7 +782,6 @@
             //debug_Instruction(instruction);
             
             actionPrecedente = instruction.order;
-            
             switch(instruction.order)
             {
                 case MV_COURBURE://C'est un rayon de courbure
@@ -762,24 +1244,79 @@
             
         break;
     }       
-}           
-            
+}          
+
+
+
+
+
 /****************************************************************************************/
 /* FUNCTION NAME: canProcessRx                                                          */
-/* DESCRIPTION  : Fonction de traitement des messages CAN                               */
+/* DESCRIPTION  : Fait évoluer l'automate de l'IHM en fonction des receptions sur le CAN*/
 /****************************************************************************************/
 void canProcessRx(void)
-{           
+{
     static signed char FIFO_occupation=0,FIFO_max_occupation=0;
-    CANMessage msgTx=CANMessage();
+    char useless1 = 0;
+
     FIFO_occupation=FIFO_ecriture-FIFO_lecture;
     if(FIFO_occupation<0)
         FIFO_occupation=FIFO_occupation+SIZE_FIFO;
     if(FIFO_max_occupation<FIFO_occupation)
         FIFO_max_occupation=FIFO_occupation;
     if(FIFO_occupation!=0) {
-        
-        switch(msgRxBuffer[FIFO_lecture].id) {
+    int identifiant=msgRxBuffer[FIFO_lecture].id;
+        switch(identifiant) {
+            case ECRAN_PRINTF_1:
+                for(useless1 = 0; useless1 <8; useless1++) {
+                    test[useless1] = msgRxBuffer[FIFO_lecture].data[useless1];
+                }
+                break;
+            case ECRAN_PRINTF_2:
+                for(useless1 = 0; useless1 <8; useless1++) {
+                    test[useless1+8] = msgRxBuffer[FIFO_lecture].data[useless1];
+                }
+                break;
+            case ECRAN_PRINTF_3:
+                for(useless1 = 0; useless1 <8; useless1++) {
+                    test[useless1+2*8] = msgRxBuffer[FIFO_lecture].data[useless1];
+                }
+                break;
+            case ECRAN_PRINTF_4:
+                for(useless1 = 0; useless1 <8; useless1++) {
+                    test[useless1+3*8] = msgRxBuffer[FIFO_lecture].data[useless1];
+                }
+                break;
+            case ECRAN_PRINTF_CLEAR:
+                etat = CHOIX;
+                break;
+                
+            case ALIVE_MOTEUR:
+            if (etat == ATT) {
+                 
+                lcd.SetTextColor(LCD_COLOR_LIGHTGREEN);
+                lcd.FillRect(0,75,400,150); //carte moteur
+                lcd.SetTextColor(LCD_COLOR_BLACK);
+                lcd.SetBackColor(LCD_COLOR_LIGHTGREEN);
+                lcd.DisplayStringAt(80, 135, (uint8_t *)"Carte Moteur", LEFT_MODE);
+                }
+                break;
+                
+            case ALIVE_BALISE:
+            if (etat == ATT) {
+                 
+                lcd.SetTextColor(LCD_COLOR_LIGHTGREEN);
+                lcd.FillRect(0,250,400,150); //carte AX12
+                lcd.SetTextColor(LCD_COLOR_BLACK);
+                lcd.SetBackColor(LCD_COLOR_LIGHTGREEN);
+                lcd.DisplayStringAt(110, 310, (uint8_t *)"Balise", LEFT_MODE);
+                } 
+                break;
+
+            case RESET_IHM:
+                etat = CHOIX;
+                break;
+
             case DEBUG_FAKE_JAKE://Permet de lancer le match à distance
             case GLOBAL_JACK:
                 if(gameEtat == ETAT_GAME_WAIT_FOR_JACK) {
@@ -788,9 +1325,6 @@
                 }
             break;
             
-            case ALIVE_BALISE:
-            case ALIVE_MOTEUR:
-            case ALIVE_IHM:
             case ALIVE_ACTIONNEURS_AVANT:
             case ALIVE_ACTIONNEURS_ARRIERE:
             case ALIVE_AX12:
@@ -802,7 +1336,6 @@
             
             case ACKNOWLEDGE_BALISE:
             case ACKNOWLEDGE_MOTEUR:
-            case ACKNOWLEDGE_IHM:
             case ACKNOWLEDGE_TELEMETRE:
             case ACKNOWLEDGE_AX12:
             case INSTRUCTION_END_BALISE:
@@ -824,12 +1357,7 @@
                 y_robot=msgRxBuffer[FIFO_lecture].data[2]|((unsigned short)(msgRxBuffer[FIFO_lecture].data[3])<<8);
                 theta_robot=msgRxBuffer[FIFO_lecture].data[4]|((signed short)(msgRxBuffer[FIFO_lecture].data[5])<<8);
             break;
-            
-            case ECRAN_START_MATCH:
-                if(gameEtat == ETAT_CONFIG) {
-                    gameEtat = ETAT_GAME_INIT;
-                }
-            break;
+    
             case SERVO_AX12_SETGOAL:
                 //SendAck(0x114, SERVO_AX12_SETGOAL);
                 //if(AX12_isLocal(msgRxBuffer[FIFO_lecture].data[0]))
@@ -852,49 +1380,7 @@
                 waitingAckID = 0;*/
                 
             break;
-            case ECRAN_CHOICE_COLOR://Choix de la couleur
-                if(gameEtat == ETAT_CONFIG) {//C'est bon on a le droit de modifier les config
-                    if(msgRxBuffer[FIFO_lecture].data[0] == 0)
-                        InversStrat = 0;//Pas d'inversion de la couleur
-                    else
-                        InversStrat = 1;//Inversion de la couleur
-                        
-                    msgTx.id=ECRAN_ACK_COLOR; // tx ack de la couleur
-                    msgTx.len=1;
-                    msgTx.format=CANStandard;
-                    msgTx.type=CANData;
-                    // couleur sur 1 octet
-                    msgTx.data[0]=msgRxBuffer[FIFO_lecture].data[0];
-                    can1.write(msgTx);
-                    
-                }
-            break;
-            
-            case ECRAN_CHOICE_STRAT://Choix du fichier de stratégie à utiliser
-                if(gameEtat == ETAT_CONFIG) {//C'est bon on a le droit de modifier les config
-                    msgTx.id=ECRAN_ACK_STRAT; // tx ack de la couleur
-                    msgTx.len=1;
-                    msgTx.format=CANStandard;
-                    msgTx.type=CANData;
-                    if(SelectStrategy(msgRxBuffer[FIFO_lecture].data[0])) {
-                        // id de la stratégie sur 1 octet
-                        if (msgRxBuffer[FIFO_lecture].data[0] < 0x10){  // Si la strat est une strat de match, on desactive le mode demo
-                                ModeDemo = 0;
-                        } else {                                        // sinon, on active le mode demo, utile pour la fin de la demo
-                                ModeDemo = 1;
-                        }
-                        
-                        msgTx.data[0]=msgRxBuffer[FIFO_lecture].data[0];
-                    } else {
-                        //erreur sur 1 octet
-                        msgTx.data[0]=0;
-                    }
-                    can1.write(msgTx);
-                    wait_ms(10);
-                    //setAsservissementEtat(0);//Désactivation de l'asservissement pour repositionner le robot dans le zone de départ
-                    tactile_printf("Strat %d, Asser desactive",msgTx.data[0]);
-                }
-            break;
+    
             case BALISE_DANGER :
                 SendAck(ACKNOWLEDGE_BALISE, BALISE_END_DANGER);
             break;
@@ -954,8 +1440,289 @@
                     }
                 modeTelemetre = 0;
             break;
-        }        
-        
+            
+            
+            
+            
+        }
         FIFO_lecture=(FIFO_lecture+1)%SIZE_FIFO;
     }
 }
+
+
+
+
+
+/****************************************************************************************/
+/* FUNCTION NAME: Bouton_Strat                                                          */
+/* DESCRIPTION  : Sélection de la strat sur le lcd puis envoie sur CAN (à modifier!)    */
+/****************************************************************************************/
+signed char Bouton_Strat (void)
+{ 
+    Button STRAT_1 (0, 30, 190, 110, strat_sd[0]);
+    Button STRAT_2 (210, 30, 190, 110, strat_sd[1]);
+    Button STRAT_3 (0, 150, 190, 110, strat_sd[2]);
+    Button STRAT_4 (210, 150, 190, 110, strat_sd[3]);
+    Button STRAT_5 (0, 270, 190, 110,strat_sd[4]);
+    Button STRAT_6 (210, 270, 190, 110, strat_sd[5]);
+    Button STRAT_7 (0, 390, 190, 110, strat_sd[6]);
+    Button STRAT_8 (210, 390, 190, 110, strat_sd[7]);
+    Button STRAT_9 (0, 510, 190, 110, strat_sd[8]);
+    Button STRAT_10 (210, 510, 190, 110, strat_sd[9]);
+    Button RETOUR  (0, 680, 400, 110, "--Precedent--");
+    //Definition des boutons
+    
+    Ack_strat = 0;
+    Strat = 0;
+    STRAT_1.Draw(0xFFF0F0F0, 0);
+    STRAT_2.Draw(0xFFF0F0F0, 0);
+    STRAT_3.Draw(0xFFF0F0F0, 0);
+    STRAT_4.Draw(0xFFF0F0F0, 0);
+    STRAT_5.Draw(0xFFF0F0F0, 0);
+    STRAT_6.Draw(0xFFF0F0F0, 0);
+    STRAT_7.Draw(0xFFF0F0F0, 0);
+    STRAT_8.Draw(0xFFF0F0F0, 0);
+    STRAT_9.Draw(0xFFF0F0F0, 0);  
+    STRAT_10.Draw(0xFFF0F0F0, 0);              
+    RETOUR.Draw(0xFFFF0000, 0);
+                
+    while(Ack_strat == 0) 
+    {
+        canProcessRx();
+        CANMessage msgTx=CANMessage();
+        msgTx.id=ECRAN_CHOICE_STRAT;
+        if (RETOUR.Touched())
+            return -1;
+        while(RETOUR.Touched());
+                   //////////////////////////////STRATEGIE N°1
+                    if (STRAT_1.Touched()){
+                        Strat = 0;
+                        msgTx.data[0] = 0x1;
+                        can2.write(msgTx);
+                        while(STRAT_1.Touched());
+                        Ack_strat =1;
+                        }
+                    /////////////////////////////STRATEGIE N°2
+                     if (STRAT_2.Touched()){
+                        Strat = 1;
+                        msgTx.data[0] = 0x2;
+                        can2.write(msgTx);
+                        while(STRAT_2.Touched());
+                        Ack_strat =1;
+                        }
+                    //////////////////////////////STRATEGIE N°3
+                     if (STRAT_3.Touched()){
+                        Strat = 2;
+                        msgTx.data[0] = 0x3;
+                        can2.write(msgTx);
+                        while(STRAT_3.Touched());
+                        Ack_strat =1;
+                        }
+                    /////////////////////////////STRATEGIE N°4
+                     if (STRAT_4.Touched()){
+                        Strat = 3;
+                        msgTx.data[0] = 0x4;
+                        can2.write(msgTx);
+                        while(STRAT_4.Touched());
+                        Ack_strat =1;
+                        }
+                    ///////////////////////////////STRATEGIE N°5
+                     if (STRAT_5.Touched()){
+                        Strat = 4;
+                        msgTx.data[0] = 0x5;  
+                        can2.write(msgTx);                     
+                        while(STRAT_5.Touched());
+                        Ack_strat =1;
+                        }
+                    ////////////////////////////////STRATEGIE N°6
+                     if (STRAT_6.Touched()){
+                        Strat = 5;
+                        msgTx.data[0] = 0x6;
+                        can2.write(msgTx);
+                        while(STRAT_6.Touched());
+                        Ack_strat =1;
+                        }
+                    /////////////////////////////////STRATEGIE N°7
+                     if (STRAT_7.Touched()){
+                        Strat = 6;
+                        msgTx.data[0] = 0x7;
+                        can2.write(msgTx);
+                        while(STRAT_7.Touched());
+                        Ack_strat =1;
+                        }
+                    /////////////////////////////////STRATEGIE N°8
+                     if (STRAT_8.Touched()){
+                        Strat = 7;
+                        msgTx.data[0] = 0x8;
+                        can2.write(msgTx);
+                        while(STRAT_8.Touched());
+                        Ack_strat =1;
+                        }
+                    /////////////////////////////////STRATEGIE N°9
+                     if (STRAT_9.Touched()){
+                        Strat = 8;
+                        msgTx.data[0] = 0x9;
+                        can2.write(msgTx);
+                        while(STRAT_9.Touched());
+                        Ack_strat =1;
+                    }
+                    ///////////////////////////////////STRATEGIE N°10
+                     if (STRAT_10.Touched()){
+                        Strat = 9;
+                        msgTx.data[0] = 0xA;
+                        can2.write(msgTx);
+                        while(STRAT_10.Touched());
+                        Ack_strat =1;
+                    }
+     
+    }
+    return Strat;  
+    
+}
+
+void affichage_compteur (int nombre)
+{
+    int dizaine=0,unite=0;
+    dizaine = nombre/10;
+    unite = nombre-(10*dizaine);
+    print_segment(unite,0);
+    print_segment(dizaine,200);
+    
+}
+
+
+//****print_segment***
+//Dessine en 7 segment le nombre en parametre
+//        A 
+//      =====
+//     |     |
+//   B |  G  | E
+//     |=====|
+//   C |     | F
+//     |     |
+//      =====
+//        D
+/*
+position pour le chiffre des unites
+lcd.FillRect(460,75,120,25);//    A
+lcd.FillRect(435,100,25,120);//   B 
+lcd.FillRect(435,245,25,120);//   C
+lcd.FillRect(460,365,120,25);//   D
+lcd.FillRect(580,100,25,120);//   E
+lcd.FillRect(580,245,25,120);//   F
+lcd.FillRect(460,220,120,25);//   G
+
+position pour le chiffre des dizaines
+lcd.FillRect(260,75,120,25);//    A
+lcd.FillRect(235,100,25,120);//   B 
+lcd.FillRect(235,245,25,120);//   C
+lcd.FillRect(260,365,120,25);//   D
+lcd.FillRect(380,100,25,120);//   E
+lcd.FillRect(380,245,25,120);//   F
+lcd.FillRect(260,220,120,25);//   G
+*/
+        
+void print_segment(int nombre, int decalage)
+{   
+    switch(nombre)
+    {
+        case 0:
+        lcd.FillRect(240-decalage,75,120,25);
+        lcd.FillRect(215-decalage,100,25,120);
+        lcd.FillRect(215-decalage,245,25,120);
+        lcd.FillRect(360-decalage,245,25,120);
+        lcd.FillRect(360-decalage,100,25,120);
+        lcd.FillRect(240-decalage,365,120,25);
+        break;
+        
+        case 1:
+        lcd.FillRect(360-decalage,100,25,120);//   E
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        break;
+        
+        case 2:
+        lcd.FillRect(240-decalage,75,120,25);//    A 
+        lcd.FillRect(215-decalage,245,25,120);//   C
+        lcd.FillRect(240-decalage,365,120,25);//   D
+        lcd.FillRect(360-decalage,100,25,120);//   E
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        break;
+        
+        case 3:
+        lcd.FillRect(240-decalage,75,120,25);//    A
+        lcd.FillRect(360-decalage,100,25,120);//   E
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        lcd.FillRect(240-decalage,365,120,25);//   D
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        break;
+        
+        case 4:
+        lcd.FillRect(215-decalage,100,25,120);//   B 
+        lcd.FillRect(360-decalage,100,25,120);//   E
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        break;
+        
+        case 5:
+        lcd.FillRect(240-decalage,75,120,25);//    A
+        lcd.FillRect(215-decalage,100,25,120);//   B
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        lcd.FillRect(240-decalage,365,120,25);//   D
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        break;
+        
+        case 6:
+        lcd.FillRect(240-decalage,75,120,25);//    A
+        lcd.FillRect(215-decalage,100,25,120);//   B 
+        lcd.FillRect(215-decalage,245,25,120);//   C
+        lcd.FillRect(240-decalage,365,120,25);//   D
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        break;
+        
+        case 7:
+        lcd.FillRect(240-decalage,75,120,25);//    A
+        lcd.FillRect(360-decalage,100,25,120);//   E
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        break;
+        
+        case 8:
+        lcd.FillRect(240-decalage,75,120,25); //    A
+        lcd.FillRect(215-decalage,100,25,120);
+        lcd.FillRect(215-decalage,245,25,120);
+        lcd.FillRect(360-decalage,245,25,120);//...
+        lcd.FillRect(360-decalage,100,25,120);
+        lcd.FillRect(240-decalage,365,120,25);
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        break;
+        
+        case 9:
+        lcd.FillRect(240-decalage,75,120,25);//    A
+        lcd.FillRect(215-decalage,100,25,120);//   B 
+        lcd.FillRect(240-decalage,365,120,25);//   D
+        lcd.FillRect(360-decalage,100,25,120);//   E
+        lcd.FillRect(360-decalage,245,25,120);//   F
+        lcd.FillRect(240-decalage,220,120,25);//   G
+        break;
+    }
+}
+
+void effacer_segment(long couleur)
+{
+    lcd.SetTextColor(couleur);
+    lcd.FillRect(240-200,75,120,25); //    A
+    lcd.FillRect(215-200,100,25,120);
+    lcd.FillRect(215-200,245,25,120);
+    lcd.FillRect(360-200,245,25,120);//...
+    lcd.FillRect(360-200,100,25,120);
+    lcd.FillRect(240-200,365,120,25);
+    lcd.FillRect(240-200,220,120,25);//   G
+    
+    lcd.FillRect(240,75,120,25); //    A
+    lcd.FillRect(215,100,25,120);
+    lcd.FillRect(215,245,25,120);
+    lcd.FillRect(360,245,25,120);//...
+    lcd.FillRect(360,100,25,120);
+    lcd.FillRect(240,365,120,25);
+    lcd.FillRect(240,220,120,25);//   G
+}