La machine dtat

Introduction
La machine dtat dans notre programme permet de crer et de grer le menu
pour lutilisateur. Elle indique le lien entre les diffrents tats afin que le menu
soit cohrent. Chaque tat est li une fonction ou un texte ou encore rien du tout.
Le clavier 4x4 permettra de passer dun tat un autre en fonction de la touche
appuye.
Un tat est dfini par cette structure :
typedef struct PROGMEM
{
unsigned char state; // Nom de ltat
PGM_P pText; // Texte associ
char (*pFunc)(char input); // Son pointeur de fonction
} MENU_STATE ;

Ltat suivant dpend de ltat o lon se situe et de lentre modifie. Elle aura
donc pour structure:
typedef struct PROGMEM
{
unsigned char state; // Nom de ltat
unsigned char input; // Entre permettant la modification
unsigned char nextstate; // Nom du prochain tat
} MENU_NEXTSTATE ;

Quand on a lensemble des tats, il est ncessaire dimplmenter les liens quils
existent entre eux. Pour cela, on utilise la structure de type NEXTSTATE. Elle
ressemble ceci :
const MENU_NEXTSTATE menu_nextstate[] PROGMEM = {
{Nom de ltat, Entre, Nom de ltat suivant associ,},
};
On peut donc constater que pour une entre partir dun tat, il ne peut y avoir
quun unique tat suivant. Mais cela nempche pas davoir plusieurs entres
diffrentes partir dun tat.
Dit prcdemment, chaque tat ne peut tre combin soit un texte, soit une
fonction, il est donc ncessaire de dvelopper cette ide en crant la table
explicitant ces proprits :
const MENU_STATE Menu_State[] PROGMEM = {
{STATE, STATE TEXT, STATE_FUNC,},

};
Logigramme machine dtats
Accueil

1. Auto 2. Manu 3. Parametres

1.
Consigne 2. Out 4. Rglage 5.
Identificatio 1. Capteur 2. Sortie 3. Alarme
(affichage) (affichage) rgulateur Date/Heure
n

1. PWM 1. Set
Changer Changer 1. 3.
1. Set High 1. Rcurrence 2. PID Heure
consigne out Temprature 2. Relais Hysteresis
2. Set Low 2. Set Date
2. Luminosit 3.
Analogique 3. Stop
3. Humidit
4. ADC
1. BP 1. Set High
2.TI 2. Set Low
3. TD
4. TE
5. OUT0

Remarque :
- Pour chaque tat part les 3 premiers, il est possible de revenir ltat prcdent avec le bouton B signifiant BACK .
- Pour la partie alarme, au dpart il montre la valeur actuelle et demande ensuite si on veut vraiment la changer ou pas.
Ce principe est appliqu galement le rglage du rgulateur en mode PID et Hystrse.
Logique du systme
La logique de notre machine dtat est assez simple comprendre. Il tait
ncessaire que notre menu ne bloque pas lalgorithme sil devait attendre une
information de lutilisateur ou autre. La rgulation du moteur doit fonctionner
sans cesse en mode automatique.
Pour raliser cela, on a cr deux tats diffrents pour le mme point :

ST_ nom de ltat : Etat ne possdant ni de texte et ni de fonctions

associes. Cest un tat dattente mais ne bloquant pas le systme.
FCT_ nom de ltat : Etat possdant une fonction associe renvoyant
vers ltat ST correspondant la fin.
Ainsi partir du menu principal, si on choisit loption 1. Automatique , la
machine dtat renvoie vers la fonction auto et pas le state auto. Dans cette
fonction, il va inscrire du texte lcran et indiquer la consigne actuelle et ds
que le travail est fini, il renvoie vers la state auto qui elle ne fait rien du tout
part attendre lappui dune touche du clavier. Bien sr, on ne regarde pas
constamment si on a appuy sur une touche. Le bouton B ne sert qu revenir en
arrire dans le menu.
Exemple machine tat
const MENU_NEXTSTATE menu_nextstate[] PROGMEM = {
// STATE INPUT NEXT STATE
// MENUS

{ST_MENU, BOUTON_1, FCT_AUTO},

{ST_MENU, BOUTON_2, FCT_MANU},
{ST_MENU, BOUTON_3, FCT_PARAMETERS},

{ST_AUTO, BOUTON_B, FCT_MENU},

{ST_AUTO, BOUTON_A, FCT_AUTO_CONSIGNE_CHANGE},

La fonction auto
char Fct_auto(char input)
{
automatique=1;
EEPROM_read_consigne();
char buffer[20];
LCD_clr();
LCD_setCursorXY(45,0);
LCD_puts ((uint8_t*)"CONSIGNE");
LCD_setCursorXY(0,20);
itoa(consigne[0],buffer,10);
LCD_puts (buffer);
LCD_puts ((uint8_t*)".");
itoa(consigne[1],buffer,10);
LCD_puts (buffer);
itoa(consigne[2],buffer,10);
LCD_puts (buffer);
LCD_setCursorXY(3,40);
LCD_puts ((uint8_t*)" A : Reglage");
LCD_setCursorXY(3,60);
LCD_puts ((uint8_t*)" B : BACK");
 return ST_AUTO;
}

Lintroduction des paramtres

La partie la plus gnante tait celle de lintroduction des paramtres. Le fait de
rentrer plusieurs chiffres la suite pour indiquer la constante dintgration par
exemple tait un problme auquel nous avons d palier. Car le temps que
lutilisateur indique la valeur quil souhaitait, le programme se serait bloqu en
attente.
Notre choix sest donc porter sur limposition envers lutilisateur dinscrire un
nombre 6 chiffres. Chaque chiffre inscrit incrmente un compteur de position et
un callback permet de faire clignoter lemplacement du chiffre dans le nombre
pour que lutilisateur puisse visualiser au fur et mesure ce quil inscrit.
chaque chiffre inscrit, la fonction Fct_pid_ti_change renvoie vers le state
ST_PID_TI_CHANGEE tant que les 6 chiffres ne sont pas inscrits. Lorsque la
condition est vraie, la fonction renvoie enfin vers le state ST_PID_TI qui indique la
valeur.
Cette logique est utilise un peu partout dans le programme. Notamment pour
inscrire la constante de drivation, la priode dchantillonnage, le OUT0 (reset
manuel), la valeur haute et basse dhystrsis, lheure et la date.
Fonction dtat
{ST_PID_TI, BOUTON_B, FCT_PID},
{ST_PID_TI, BOUTON_A, FCT_PID_TI_CHANGE},

{ST_PID_TI_CHANGE, BOUTON_0, FCT_PID_TI_CHANGE},

{ST_PID_TI_CHANGE, BOUTON_1, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_2, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_3, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_4, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_5, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_6, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_7, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_8, FCT_PID_TI_CHANGE},
{ST_PID_TI_CHANGE, BOUTON_9, FCT_PID_TI_CHANGE},

Fonction PID TI Change

char Fct_pid_ti_change(char input)
{
input=Previous_Button;

char buffer[20];
itoa(input,buffer,10);
Usart_Tx_String(buffer);
Usart_Tx_String("\n");
if(position!=0)
{
ti[position-1]=input-1;
}
else IDCB_Clignotement_ti =
OSEnregistrerCB_TIMER(clignotementti,500);
LCD_clr();
LCD_setCursorXY(2,0);
LCD_puts ((uint8_t*)"Constante integration:");
LCD_setCursorXY(0,20);
 itoa(ti[0],buffer,10);
LCD_puts (buffer);
itoa(ti[1],buffer,10);
LCD_puts (buffer);
itoa(ti[2],buffer,10);
LCD_puts (buffer);
itoa(ti[3],buffer,10);
LCD_puts (buffer);
itoa(ti[4],buffer,10);
LCD_puts (buffer);

position++;
if(position==6)
{
position=0;
EEPROM_save_ti();
ti_int = (int)ti[4]+(10*((int)ti[3]))+(100*((int)ti[2]))
+(1000*((int)ti[1]))+(10000*((int)ti[0]));
itoa(ti_int,buffer,10);
Usart_Tx_String("Constante integration:");
Usart_Tx_String(buffer);
Usart_Tx_String("\n");

OSRetirerCB_TIMER(IDCB_Clignotement_ti);
return FCT_PID_TI;
}
else return ST_PID_TI_CHANGE;

Liste des fonctions EEPROM utilises

Voici une description dtaille des diffrentes fonctions utilises dans les
fonctions de la machine dtats dans notre programme :
void EEPROM_read_consigne(void) : Fonction permettant de lire la valeur de
la consigne depuis l'EEPROM
void EEPROM_read_out(void) : Fonction permettant de lire la valeur de out
depuis l'EEPROM
void EEPROM_read_alarme_high(void) :Fonction permettant de lire la valeur
haute de l'alarme depuis l'EEPROM
void EEPROM_read_alarme_low(void) : Fonction permettant de lire la valeur
basse de l'alarme depuis l'EEPROM
void EEPROM_read_hysteresis_high(void) : Fonction permettant de lire la
valeur haute de l'hystrse depuis l'EEPROM
void EEPROM_read_hysteresis_low(void) : Fonction permettant de lire la
valeur basse de l'hystrse depuis l'EEPROM
void EEPROM_read_bp(void) : Fonction permettant de lire la valeur de la
bande proportionnelle depuis l'EEPROM
void EEPROM_read_ti(void) : Fonction permettant de lire la valeur de la
constante d'intgration depuis l'EEPROM
void EEPROM_read_td(void) : Fonction permettant de lire la valeur de la
constante de drivation depuis l'EEPROM
void EEPROM_read_te(void) : Fonction permettant de lire la valeur de la
priode d'chantillonnage depuis l'EEPROM
void EEPROM_read_out0(void) : Fonction permettant de lire la valeur de la
commande rsiduelle depuis l'EEPROM
void EEPROM_read_recurrence_a(void) : Fonction permettant de lire la valeur
des coefficients A de la rcurrence depuis l'EEPROM
void EEPROM_read_recurrence_b(void) : Fonction permettant de lire la valeur
des coefficients B de la rcurrence depuis l'EEPROM

unsigned char EEPROM_read( unsigned char, unsigned char, unsigned

char ) : Fonction de lecture dans l'eeprom bas niveau
unsigned char EEPROM_write( unsigned char, unsigned char, unsigned
char ) : Fonction d'criture dans l'eeprom bas niveau

void EEPROM_save_consigne(void) : Fonction permettant d'crire la valeur de

la consigne dans l'EEPROM
void EEPROM_save_out(void) : Fonction permettant d'crire la valeur de out
dans l'EEPROM
void EEPROM_save_alarme_high(void) : Fonction permettant d'crire la
valeur haute de l'alarme dans l'EEPROM
void EEPROM_save_alarme_low(void) : Fonction permettant d'crire la valeur
basse de l'alarme dans l'EEPROM
void EEPROM_save_hysteresis_high(void) : Fonction permettant d'crire la
valeur haute de l'hystrse dans l'EEPROM
void EEPROM_save_hysteresis_low(void) : Fonction permettant d'crire la
valeur basse de l'hystrse dans l'EEPROM
void EEPROM_save_bp(void) : Fonction permettant d'crire la valeur la bande
proportionnelle dans l'EEPROM
void EEPROM_save_ti(void) : Fonction permettant d'crire la valeur de la
constante d'intgration dans l'EEPROM
void EEPROM_save_td(void) : Fonction permettant d'crire la valeur de la
constante de drivation dans l'EEPROM
void EEPROM_save_te(void) : Fonction permettant d'crire la valeur de la
priode d'chantillonnage dans l'EEPROM
void EEPROM_save_out0(void) : Fonction permettant d'crire la valeur de la
commande rsiduelle dans l'EEPROM
void EEPROM_save_recurrence_a(void) : Fonction permettant d'crire la
valeur des coefficients A de la rcurrence dans l'EEPROM
void EEPROM_save_recurrence_b(void) : Fonction permettant d'crire la
valeur des coefficients B de la rcurrence dans l'EEPROM

unsigned char i2c_start(void) : Fonction qui envoi la condition de START (IC)

unsigned char i2c_repeatStart(void) : Fonction qui envoi la condition de
RESTART (IC)
unsigned char i2c_sendAddress(unsigned char) : Fonction permettant
denvoyer ladresse de lesclave avec laquelle on souhaite communiquer (IC)
unsigned char i2c_sendData(unsigned char) : Fonction permettant
d'envoyer un octet de donnes l'esclave (IC)
unsigned char i2c_receiveData_ACK(void) : Fonction permettant la rception
d'un octet de donnes depuis l'esclave et d'envoi d'un ACK (acknowledge) quand
celui-ci est reu (IC)
unsigned char i2c_receiveData_NACK(void) : Fonction permettant la
rception d'un octet de donnes depuis l'esclave et d'envoi d'un NACK (no
acknowledge) une fois que celui-ci est reu (IC)
void i2c_stop(void) : Fonction qui envoi la condition de STOP (IC)
void twi_init(void) : Fonction d'initialisation de l'IC