Diff: Bluetooth/IHM_Bluetooth.cpp

Revision:

2:1103f5d61035

Child:

3:07109a6bb472

diff -r a9af73d5abd4 -r 1103f5d61035 Bluetooth/IHM_Bluetooth.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Bluetooth/IHM_Bluetooth.cpp	Wed Mar 11 14:24:48 2020 +0000
@@ -0,0 +1,230 @@
+#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
+}