CRAC Team
Programme carte strategie (disco)
Dependencies: mbed SerialHalfDuplex SDFileSystem DISCO-F469NI_portrait liaison_Bluetooth ident_crac
Diff: Strategie/Strategie.cpp
- 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
+}