File content as of revision 2:1103f5d61035:

#include "mbed.h"
#include "math.h"
#include "IHM_Bluetooth.h"                                                                //ticker pour gérer la frequence d'appelle d'une fonction

extern Serial bt;

// Constructeur
IHM_Bluetooth::IHM_Bluetooth() : /*blueTxBuffer{STARTBYTE,0,0,0,0,STOPBYTE}, paramRx{1, 0, 0, 0},*/ cb_lm(0), cb_rm(0), cb_err(0), cb_cerr(0), cb_speed(0)
{
    unsigned int tab1[6] = {STARTBYTE,0,0,0,0,STOPBYTE}, tab2[4] = {1, 0, 0, 0};
    
    for(int i=0; i<6; ++i)
        blueRxBuffer[i] = tab1[i];
        
    for(int i=0; i<4; ++i)
        paramRx[i] = tab2[i];
}

/********************************** Main *************************************/

void IHM_Bluetooth::run(void)
{
    bt.attach(this, &IHM_Bluetooth::receptionBlu, Serial::RxIrq);                               //Creation interruption de reception
    bt.printf("Hello world");                                              //message de test
    timer.attach(this, &IHM_Bluetooth::automate_Tx,0.015);
}


/******************************* Fonctions de transmission *****************************/

void IHM_Bluetooth::transmitBlu(void)
{
    static short i = 0;
    if(bt.writable())                                                      //fonctionne si la liaison est libre
    {
       bt.putc(blueTxBuffer[i]);                                           //transmission de la trame de 6 octets
       i++;
    }
    if(i>5)
    {
        i=0;
        bt.attach(NULL, Serial::TxIrq);                                    // Arret de la transmission lorsqu une trame est envoyee
    }
}

void IHM_Bluetooth::formatTrameT(short reg, int val)
{   
    val=val*10000;
    blueTxBuffer[1]=(char)reg;
    blueTxBuffer[2]=(char)((val&0xFF0000)>>16);                                //Conversion sur trois octets independants
    blueTxBuffer[3]=(char)((val&0x00FF00)>>8);
    blueTxBuffer[4]=(char)((val&0x0000FF));
                                                                               // La trame a envoyer est realisee
    bt.attach(this, &IHM_Bluetooth::transmitBlu, Serial::TxIrq);                                // Ouverture de l'interruption de transmission 
}

void IHM_Bluetooth::TrameCAM( int CAM1, int CAM2)
{
    blueTxBuffer[1]=(char)CAMXBYTE;
    blueTxBuffer[2]=(char)1;                                                   //Conversion sur trois octets independants
    blueTxBuffer[3]=(char)CAM1;
    blueTxBuffer[4]=(char)CAM2;
                                                                               // La trame a envoyer est realisee
    bt.attach(this, &IHM_Bluetooth::transmitBlu, Serial::TxIrq);                                // Ouverture de l'interruption de transmission 
}

void IHM_Bluetooth::TramePos(int left, int barc, int right)
{
    blueTxBuffer[1]=(char)POSBYTE;
    blueTxBuffer[2]=(char)left;                                                //Conversion sur trois octets independants
    blueTxBuffer[3]=(char)barc;
    blueTxBuffer[4]=(char)right;
                                                                               // La trame a envoyer est realisee
    bt.attach(this, &IHM_Bluetooth::transmitBlu, Serial::TxIrq);                                // Ouverture de l'interruption de transmission 
}


void IHM_Bluetooth::automate_Tx(void)
{    
    static int etat_futur=POSBYTE, val=50;
    int etat;
    etat = etat_futur;
    
                                                                               // Transmission des donnees à l'application 
    switch(etat){                                                              // Il faut modifier toutes les valeurs VAL dans les fonctions
        case POSBYTE :                                                         
            TramePos(val+100, val+100, val+100);                               // Envoie de 3 octets de position par rapport aux lignes, respectivement : Gauche, barycentre (centre de gravite) et droit
            if (cb_lm == 1)etat_futur = LMBYTE;
            else if(cb_rm == 1)etat_futur=RMBYTE;                              // Si la checkbox de l'application autorise la transmission de cette donnee
            else if(cb_err == 1)etat_futur=ERRORBYTE;
            else if(cb_cerr == 1)etat_futur=CERRBYTE;
            else if(cb_speed == 1)etat_futur=SGRABYTE;
            else etat_futur=CAMXBYTE;
            break;
        
        case LMBYTE : // Moteur gauche
            formatTrameT(LMBYTE, val );
            if(cb_rm == 1)etat_futur=RMBYTE;
            else if(cb_err == 1)etat_futur=ERRORBYTE;
            else if(cb_cerr == 1)etat_futur=CERRBYTE;
            else if(cb_speed == 1)etat_futur=SGRABYTE;
            else etat_futur=CAMXBYTE;
            break;
        
        case RMBYTE : // Moteur droit
            formatTrameT(RMBYTE, val );
            if(cb_err == 1)etat_futur=ERRORBYTE;
            else if(cb_cerr == 1)etat_futur=CERRBYTE;
            else if(cb_speed == 1)etat_futur=SGRABYTE;
            else etat_futur=CAMXBYTE;
            break;
            
        case ERRORBYTE : // Erreur
            formatTrameT(ERRORBYTE, val );
            if(cb_cerr == 1)etat_futur=CERRBYTE;
            else if(cb_speed == 1)etat_futur=SGRABYTE;
            else etat_futur=CAMXBYTE;
            break;
            
        case CERRBYTE : // Correction d'erreur
            formatTrameT(CERRBYTE, val );
            if(cb_speed == 1)etat_futur=SGRABYTE;
            else etat_futur=CAMXBYTE;
            break;
            
        case SGRABYTE : // Vitesse du véhicule
            formatTrameT(SGRABYTE, val );
            etat_futur=CAMXBYTE;
            break;
        
        case CAMXBYTE : // Vecteur gauche et droit
            TrameCAM(val+100, val+100);                                        // Retour de la camera, respectivement vecteur Gauche et Droit
            etat_futur=POSBYTE;
            break;            
        }
}

/****************************** Fonctions de reception ******************************/

void IHM_Bluetooth::receptionBlu(void)
{
    static short j = 0;
    
    if(bt.readable())                                                      // Si la liaison est libre
    {
        blueRxBuffer[j]=(unsigned int)bt.getc();                           //reception des octets dans un tableau
        j++;
        if(j==6)                                                                        
        {
            if((blueRxBuffer[0]==STARTBYTE) && (blueRxBuffer[5]==STOPBYTE))    // Si la trame commence et termine par Start et Stop
            {
                switch(blueRxBuffer[1]){                                       // Automate en fonction de la valeur du registre
                    case KPBYTE :
                        paramRx[0] = ((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4])/10000;
                        break;
                    
                    case KIBYTE :
                        paramRx[1] = ((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4])/10000;   //decomposition du message
                        break;
                    
                    case KDBYTE :
                        paramRx[2] = ((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4])/10000;   //valeur envoyee dans un tableau
                        break;
                        
                    case SPCMDBYTE :
                        paramRx[3] = ((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4])/10000;
                        break;
                        
                    case ERRORBYTE :
                        if(((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4]) == 1)
                        {
                            if(cb_err == 0)cb_err=1;
                            else if(cb_err == 1)cb_err=0;
                        } 
                        break;
                    
                    case CERRBYTE :
                        if(((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4]) == 1)
                        {
                            if(cb_cerr == 0)cb_cerr=1;
                            else if(cb_cerr == 1)cb_cerr=0;
                        }
                        break;
                    
                    case LMBYTE :
                        if(((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4]) == 1)
                        {
                            if(cb_lm == 0)cb_lm=1;
                            else if(cb_lm == 1)cb_lm=0;
                        }
                        break;
                                                                               // Faire automate pour la transmission
                    case RMBYTE :
                        if(((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4]) == 1)
                        {
                            if(cb_rm == 0)cb_rm=1;
                            else if(cb_rm == 1)cb_rm=0;
                        }
                        break;
                        
                    case SGRABYTE :
                        if(((blueRxBuffer[2]<<16)+(blueRxBuffer[3]<<8)+blueRxBuffer[4]) == 1)
                        {
                            if(cb_speed == 0)cb_speed=1;
                            else if(cb_speed == 1)cb_speed=0;
                        }
                        break;
                }
                j=0;
            }else{                                                             //Si le message ne commence pas par start ou ne finit pas par stop
                for(int i = 0;i<5;i++){
                    blueRxBuffer[i]=blueRxBuffer[i+1];                         // On decale le msg reçu dans le buffer                         
                }
                j=5;
            }
        }
    }
}
                    
int IHM_Bluetooth::get_val_pc(short reg)                                                      // reg = entree de l'utilisateur pour connaitre une valeur
{
    short indice;
    
    if(reg == KPBYTE)indice = 0;
    else if(reg == KIBYTE)indice = 1;
    else if(reg == KDBYTE)indice = 2;
    else if(reg == SPCMDBYTE)indice = 3;
    
    return paramRx[indice];                                                    // Renvoie de la valeur souhaitee
}