main.cpp

00001 #include <events/mbed_events.h>
00002 #include <mbed.h>
00003 #include "ble/BLE.h"
00004 #include "Sensorservice.h"
00005 #include "stm32l475e_iot01_tsensor.h"
00006 #include "stm32l475e_iot01_hsensor.h"
00007 #include "stm32l475e_iot01_magneto.h"
00008 #include "stm32l475e_iot01_gyro.h"
00009 #include "stm32l475e_iot01_accelero.h"
00010 #include "stm32l475e_iot01_psensor.h"
00011 
00012 
00013 EnvironmentalService *SensorPtr;
00014 static float currentTemperature   = 0.0;
00015 static float currentHumidity   = 0.0;
00016 static float currentPressure   = 0.0;
00017 static int16_t      MagnetoXYZ[3]     ={0};
00018 static int16_t     AcceleroXYZ[3]     ={0};
00019 static float           GyroXYZ[3]     ={0};
00020 
00021 Serial pc(USBTX,USBRX);
00022 
00023 DigitalOut alivenessLED(LED1, 0);
00024 DigitalOut actuatedLED(LED2, 0);
00025 DigitalOut led(LED1, 1);
00026 uint16_t customServiceUUID  = 0xA000; /*Service*/
00027 uint16_t readCharUUID       = 0xA001; /*Read*/
00028 uint16_t writeCharUUID      = 0xA002; /*Write*/
00029 
00030 const static char     DEVICE_NAME[]        = "Projet";
00031 static const uint16_t uuid16_list[]        = {GattService::UUID_ENVIRONMENTAL_SERVICE}; 
00032 
00033 
00034 static uint8_t writeValue[10] = {0};
00035 WriteOnlyArrayGattCharacteristic<uint8_t, sizeof(writeValue)> writeChar(writeCharUUID, writeValue);
00036 
00037 
00038 GattCharacteristic *characteristics[] = {&writeChar};
00039 GattService        customService(customServiceUUID, characteristics, sizeof(characteristics) / sizeof(GattCharacteristic *));
00040 
00041 static EventQueue eventQueue(10 * EVENTS_EVENT_SIZE);
00042 
00043 
00044 void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
00045 {
00046     (void) params;
00047     BLE::Instance().gap().startAdvertising();
00048 }
00049 
00050   
00051 void updateTSensorValue(void) {
00052     currentTemperature = BSP_TSENSOR_ReadTemp();
00053     currentHumidity =    BSP_HSENSOR_ReadHumidity();
00054     currentPressure   =  BSP_PSENSOR_ReadPressure();
00055     BSP_MAGNETO_GetXYZ(MagnetoXYZ);
00056     BSP_GYRO_GetXYZ(GyroXYZ);
00057     BSP_ACCELERO_AccGetXYZ(AcceleroXYZ);
00058     SensorPtr->updateTemperature(currentTemperature);
00059     SensorPtr->updateHumidity(currentHumidity);
00060     SensorPtr->updatePressure(currentPressure);
00061     SensorPtr->updateAccelero(AcceleroXYZ);
00062     SensorPtr->updateMagneto(MagnetoXYZ);
00063     SensorPtr->updateGyro(GyroXYZ);
00064 }
00065 
00066 
00067 void blinkCallback(void)
00068 {
00069     alivenessLED = !alivenessLED; 
00070         if (BLE::Instance().gap().getState().connected) {
00071         eventQueue.call(updateTSensorValue);
00072     }
00073 }
00074 
00075 /********Lecture des donées et traitement selon leurs taille*******/
00076 void onDataWrittenCallback(const GattWriteCallbackParams *params) {
00077     if ((params->handle == writeChar.getValueHandle())) {
00078         if(params->len == 1) {
00079             actuatedLED = *(params->data);
00080             pc.printf("Data received: length = %d\n\r",params->len);
00081             if(actuatedLED == 1){
00082               pc.printf("LED is on\n\r");
00083             }
00084             else{
00085                 pc.printf("LED is off\n\r");
00086             }
00087             for(int x=0; x < params->len; x++) {
00088                 pc.printf("%x", params->data[x]);
00089                 pc.printf("\n\r");
00090             }
00091         }
00092         else {
00093             pc.printf("Data received: length = %d, data = 0x",params->len);
00094             for(int x=0; x < params->len; x++) {
00095                 pc.printf("%x", params->data[x]);
00096             }
00097             pc.printf("\n\r");
00098         }
00099         
00100     }
00101 }
00102 
00103 
00104 void onBleInitError(BLE &ble, ble_error_t error)
00105 {
00106     pc.printf("Erreur\n\r");
00107 }
00108 
00109 
00110 void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
00111 {
00112     BLE&        ble   = params->ble;
00113     ble_error_t error = params->error;
00114 
00115     if (error != BLE_ERROR_NONE) {
00116         onBleInitError(ble, error);
00117         return;
00118     }
00119 
00120     if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
00121         return;
00122     }
00123 
00124     ble.gap().onDisconnection(disconnectionCallback);
00125     SensorPtr = new EnvironmentalService(ble);
00126     ble.gattServer().onDataWritten(onDataWrittenCallback);
00127 
00128 
00129 /************************** advertising***********************/
00130     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
00131     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
00132     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
00133     ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
00134     ble.gap().setAdvertisingInterval(1000); /* 1000ms. */
00135     ble.addService(customService);
00136     ble.gap().startAdvertising();
00137 }
00138 
00139 void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) {
00140     BLE &ble = BLE::Instance();
00141     eventQueue.call(Callback<void()>(&ble, &BLE::processEvents));
00142 }
00143 
00144 /******************************MAIN*******************************/
00145 
00146 int main()
00147 {
00148     BSP_TSENSOR_Init();
00149     BSP_HSENSOR_Init();
00150     BSP_PSENSOR_Init();
00151     BSP_MAGNETO_Init();
00152     BSP_GYRO_Init();
00153     BSP_ACCELERO_Init();
00154     pc.printf("BLE is Working\n\r");
00155     eventQueue.call_every(500, blinkCallback);
00156     
00157 
00158     BLE &ble = BLE::Instance();
00159     ble.onEventsToProcess(scheduleBleEventsProcessing);
00160     ble.init(bleInitComplete);
00161 
00162     eventQueue.dispatch_forever();
00163 
00164     return 0;
00165 }