main.cpp

00001 #include "mbed.h"
00002 #include "ble/BLE.h"
00003 #include "ble/services/UARTService.h"
00004 #include "Serial.h"
00005 #include "LIS3DH.h"
00006 #include "stdlib.h"
00007 
00008 #define UART_BUFFER (UARTService::BLE_UART_SERVICE_MAX_DATA_LEN)
00009 
00010 
00011 const static char DEVICE_NAME[] = "ObCP";
00012 UARTService *uartServicePtr;
00013 
00014 //PWM output
00015 PwmOut PWMoutput(PB_1);          //Main PWM output
00016 PwmOut Green(PC_8);              //PWM Red LED
00017 PwmOut Red(PC_6);                //PWM Green LED
00018 PwmOut Blue(PC_9);               //PWM Blue LED
00019 
00020 //Accelerometer
00021 
00022 #define MOSI PC_12
00023 #define MISO PC_11
00024 #define CS PC_5
00025 #define SCLK PC_10
00026 
00027 // Def Peripheriques
00028 DigitalIn myButton(PC_13);    // USER BUTTON
00029 //Init accelerometer
00030 LIS3DH      acc(MOSI, MISO, SCLK, CS, LIS3DH_DR_NR_LP_50HZ, LIS3DH_FS_2G);
00031 
00032 Ticker Acceleration;
00033 
00034 // Tableau et index de communication avec UART
00035 static char uartBuff[UART_BUFFER];
00036 // Variables contenant accelerations
00037 double accX, accY, accZ;
00038 // Routine de traitement des erreurs
00039 void onBleError(ble_error_t error);
00040 
00041 /****************************************************/
00042 /* Ticker actif lorsque la connexion BLE est présente */
00043 /****************************************************/
00044 void ConnectedBLE(void)
00045 {
00046     // Signal de vie: allumer et éteindre la LED
00047     Green.period(1.0f);  // période = 1 seconde
00048     Green.write(0.01f);  // élaire 1% de la période
00049 }
00050 
00051 void AccMeasurement(void)
00052 {
00053     char outstrX[5];
00054     char outstrY[5];
00055     char outstrZ[5];
00056 
00057     // Mesure des accélérations sur les 3 axes
00058     accX = float(short((acc.read_reg(LIS3DH_OUT_X_H) << 8) | acc.read_reg(LIS3DH_OUT_X_L))) * 0.001F / 15;
00059     accY = float(short((acc.read_reg(LIS3DH_OUT_Y_H) << 8) | acc.read_reg(LIS3DH_OUT_Y_L))) * 0.001F / 15;
00060     accZ = float(short((acc.read_reg(LIS3DH_OUT_Z_H) << 8) | acc.read_reg(LIS3DH_OUT_Z_L))) * 0.001F / 15;
00061 
00062     //Transformation des valeurs numeriques en chaine de caracteres
00063     sprintf(outstrX,"%5.2f",accX);
00064     sprintf(outstrY,"%5.2f",accY);
00065     sprintf(outstrZ,"%5.2f",accZ);
00066     //Integre les trois chaines de caractere contenant les accelerations dans la chaine uartBuff
00067     sprintf(uartBuff, "X%s Y%s Z%s", outstrX, outstrY, outstrZ) ;
00068     //Envoie la chaine uartBuff sur le sevice TX UART BLE
00069     uartServicePtr->write(uartBuff, UARTService::BLE_UART_SERVICE_MAX_DATA_LEN);
00070     // Réinitialiser la chaîne uartBuff en entrant 0 dans les premiers caractères UART_BUFFER
00071     memset(uartBuff, 0, UART_BUFFER);
00072 
00073 }
00074 
00075 /*************************/
00076 /* Connexion BLE réussie */
00077 /*************************/
00078 void BleConnectionCallback(const Gap::ConnectionCallbackParams_t *params)
00079 {
00080     // Signal de connexion BLE: allume / éteint la LED avec une période de 1 seconde
00081     ConnectedBLE();
00082     Acceleration.attach(AccMeasurement, 1);
00083 }
00084 
00085 /*****************************/
00086 /* Déconnexion du client BLE */
00087 /*****************************/
00088 void BleDisconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
00089 {
00090     (void)params;
00091     // Redémarrer la publicité
00092     Acceleration.detach();
00093     BLE::Instance().gap().startAdvertising();
00094     
00095     PWMoutput.write(0.0f);
00096     Green.write(0.0f);
00097     Red.write(0.0f);
00098     Blue.write(0.0f);
00099 }
00100 
00101 /***************************/
00102 /* Rx de BLE et Rx vers USB*/
00103 /***************************/
00104 void BleOnDataWrittenCallback(const GattWriteCallbackParams *params)
00105 {
00106     char reception[UART_BUFFER];
00107     char commande[2];
00108     float valeur;
00109 
00110     // Reçoit une chaîne de BLE
00111     if (params->handle == uartServicePtr->getTXCharacteristicHandle()) {
00112         // Copie de la chaine reçue dans reception
00113         sprintf(reception,"%s", params->data);
00114         // Copie dans la chaine commande des deux premier caracteres de la chaine reception
00115         sprintf(commande,"%c%c", reception[0], reception[1]);
00116         // Transformation des 3 caracteres suivants en valeur numerique
00117         valeur = ((reception[2] - '0')* 100 + (reception[3] - '0')* 10 +(reception[4] - '0')) ;
00118         valeur = valeur/255;
00119                 
00120         if( strcmp(commande, "LR")==0) {
00121             Red.period(0.01f);
00122             Red.write(valeur);
00123         }
00124         if( strcmp(commande, "LV")==0) {
00125             Green.period(0.01f);
00126             Green.write(valeur);
00127         }
00128         if( strcmp(commande, "LB")==0) {
00129             Blue.period(0.01f);
00130             Blue.write(valeur);
00131         }
00132         if( strcmp(commande, "PW")==0) {
00133             PWMoutput.period(0.001f);
00134             PWMoutput.write(valeur);
00135         }
00136 
00137     }
00138 }
00139 
00140 /***************************/
00141 /* Erreur sur le canal BLE */
00142 /***************************/
00143 
00144 void onBleError(ble_error_t error)
00145 {
00146     Red.period(0.8f);  // période = 0.8 seconde
00147     Red.write(0.10f);  // élaire 10% de la période
00148     /* Entrer le traitement des erreurs */
00149 }
00150 
00151 /**************************************/
00152 /* Initialisation du service BLE UART */
00153 /**************************************/
00154 
00155 void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
00156 {
00157     BLE&        ble   = params->ble;
00158     ble_error_t error = params->error;
00159 
00160     if (error != BLE_ERROR_NONE) {
00161 
00162         /* En cas d'erreur, transmettez le traitement d'erreur à onBleInitError*/
00163         onBleError(error);
00164         return;
00165     }
00166 
00167     /* Assurez-vous qu'il s'agit de l'instance par défaut de BLE */
00168     if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
00169         return;
00170     }
00171 
00172     ble.gap().onConnection(BleConnectionCallback);
00173     ble.gap().onDisconnection(BleDisconnectionCallback);
00174     ble.gattServer().onDataWritten(BleOnDataWrittenCallback);
00175 
00176     /* Configuration du service primaire. */
00177     UARTService uartService(ble);
00178     uartServicePtr = &uartService;
00179 
00180     /* Configurer la publicité */
00181     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
00182     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));
00183     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
00184     ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
00185     ble.gap().setAdvertisingInterval(500); /* 500ms. */
00186     ble.gap().startAdvertising();
00187 
00188     // Attend les événements sur BLE
00189     while (true) {
00190         ble.waitForEvent();
00191     }
00192 }
00193 
00194 /********/
00195 /* MAIN */
00196 /********/
00197 int main(void)
00198 {
00199     //Définit le fonctionnement du bouton sur "PullDown": Open = '0'. L’autre mode de fonctionnement est PullUp
00200     myButton.mode(PullDown);
00201 
00202     // Initialiser LED
00203     Green.write(0.0f);
00204     Red.write(0.0f);
00205     Blue.write(0.0f);
00206 
00207     /****** START Initialiser BLE **********/
00208     BLE &ble = BLE::Instance();
00209     ble.init(bleInitComplete);
00210     /******* FIN initialise BLE ***********/
00211 
00212 }
00213