Diff: source/main.cpp

Revision:

39:ddabcba6eff1

Parent:

27:ff1fb7b5f9ee

diff -r 4bdc241ba9a6 -r ddabcba6eff1 source/main.cpp
--- a/source/main.cpp	Wed Jul 26 14:47:11 2017 +0200
+++ b/source/main.cpp	Wed Jul 10 20:09:49 2019 +0000
@@ -1,33 +1,45 @@
-/* mbed Microcontroller Library
- * Copyright (c) 2006-2013 ARM Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 #include <events/mbed_events.h>
 #include <mbed.h>
 #include "ble/BLE.h"
-#include "LEDService.h"
+#include "Sensorservice.h"
+#include "stm32l475e_iot01_tsensor.h"
+#include "stm32l475e_iot01_hsensor.h"
+#include "stm32l475e_iot01_magneto.h"
+#include "stm32l475e_iot01_gyro.h"
+#include "stm32l475e_iot01_accelero.h"
+#include "stm32l475e_iot01_psensor.h"
+
+
+EnvironmentalService *SensorPtr;
+static float currentTemperature   = 0.0;
+static float currentHumidity   = 0.0;
+static float currentPressure   = 0.0;
+static int16_t      MagnetoXYZ[3]     ={0};
+static int16_t     AcceleroXYZ[3]     ={0};
+static float           GyroXYZ[3]     ={0};
+
+Serial pc(USBTX,USBRX);
 
 DigitalOut alivenessLED(LED1, 0);
 DigitalOut actuatedLED(LED2, 0);
+DigitalOut led(LED1, 1);
+uint16_t customServiceUUID  = 0xA000; /*Service*/
+uint16_t readCharUUID       = 0xA001; /*Read*/
+uint16_t writeCharUUID      = 0xA002; /*Write*/
 
-const static char     DEVICE_NAME[] = "LED";
-static const uint16_t uuid16_list[] = {LEDService::LED_SERVICE_UUID};
+const static char     DEVICE_NAME[]        = "Projet";
+static const uint16_t uuid16_list[]        = {GattService::UUID_ENVIRONMENTAL_SERVICE}; 
+
 
-static EventQueue eventQueue(/* event count */ 10 * EVENTS_EVENT_SIZE);
+static uint8_t writeValue[10] = {0};
+WriteOnlyArrayGattCharacteristic<uint8_t, sizeof(writeValue)> writeChar(writeCharUUID, writeValue);
+
 
-LEDService *ledServicePtr;
+GattCharacteristic *characteristics[] = {&writeChar};
+GattService        customService(customServiceUUID, characteristics, sizeof(characteristics) / sizeof(GattCharacteristic *));
+
+static EventQueue eventQueue(10 * EVENTS_EVENT_SIZE);
+
 
 void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
 {
@@ -35,62 +47,92 @@
     BLE::Instance().gap().startAdvertising();
 }
 
-void blinkCallback(void)
-{
-    alivenessLED = !alivenessLED; /* Do blinky on LED1 to indicate system aliveness. */
+  
+void updateTSensorValue(void) {
+    currentTemperature = BSP_TSENSOR_ReadTemp();
+    currentHumidity =    BSP_HSENSOR_ReadHumidity();
+    currentPressure   =  BSP_PSENSOR_ReadPressure();
+    BSP_MAGNETO_GetXYZ(MagnetoXYZ);
+    BSP_GYRO_GetXYZ(GyroXYZ);
+    BSP_ACCELERO_AccGetXYZ(AcceleroXYZ);
+    SensorPtr->updateTemperature(currentTemperature);
+    SensorPtr->updateHumidity(currentHumidity);
+    SensorPtr->updatePressure(currentPressure);
+    SensorPtr->updateAccelero(AcceleroXYZ);
+    SensorPtr->updateMagneto(MagnetoXYZ);
+    SensorPtr->updateGyro(GyroXYZ);
 }
 
-/**
- * This callback allows the LEDService to receive updates to the ledState Characteristic.
- *
- * @param[in] params
- *     Information about the characterisitc being updated.
- */
-void onDataWrittenCallback(const GattWriteCallbackParams *params) {
-    if ((params->handle == ledServicePtr->getValueHandle()) && (params->len == 1)) {
-        actuatedLED = *(params->data);
+
+void blinkCallback(void)
+{
+    alivenessLED = !alivenessLED; 
+        if (BLE::Instance().gap().getState().connected) {
+        eventQueue.call(updateTSensorValue);
     }
 }
 
-/**
- * This function is called when the ble initialization process has failled
- */
+/********Lecture des donées et traitement selon leurs taille*******/
+void onDataWrittenCallback(const GattWriteCallbackParams *params) {
+    if ((params->handle == writeChar.getValueHandle())) {
+        if(params->len == 1) {
+            actuatedLED = *(params->data);
+            pc.printf("Data received: length = %d\n\r",params->len);
+            if(actuatedLED == 1){
+              pc.printf("LED is on\n\r");
+            }
+            else{
+                pc.printf("LED is off\n\r");
+            }
+            for(int x=0; x < params->len; x++) {
+                pc.printf("%x", params->data[x]);
+                pc.printf("\n\r");
+            }
+        }
+        else {
+            pc.printf("Data received: length = %d, data = 0x",params->len);
+            for(int x=0; x < params->len; x++) {
+                pc.printf("%x", params->data[x]);
+            }
+            pc.printf("\n\r");
+        }
+        
+    }
+}
+
+
 void onBleInitError(BLE &ble, ble_error_t error)
 {
-    /* Initialization error handling should go here */
+    pc.printf("Erreur\n\r");
 }
 
-/**
- * Callback triggered when the ble initialization process has finished
- */
+
 void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
 {
     BLE&        ble   = params->ble;
     ble_error_t error = params->error;
 
     if (error != BLE_ERROR_NONE) {
-        /* In case of error, forward the error handling to onBleInitError */
         onBleInitError(ble, error);
         return;
     }
 
-    /* Ensure that it is the default instance of BLE */
     if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
         return;
     }
 
     ble.gap().onDisconnection(disconnectionCallback);
+    SensorPtr = new EnvironmentalService(ble);
     ble.gattServer().onDataWritten(onDataWrittenCallback);
 
-    bool initialValueForLEDCharacteristic = false;
-    ledServicePtr = new LEDService(ble, initialValueForLEDCharacteristic);
 
-    /* setup advertising */
+/************************** advertising***********************/
     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
     ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
     ble.gap().setAdvertisingInterval(1000); /* 1000ms. */
+    ble.addService(customService);
     ble.gap().startAdvertising();
 }
 
@@ -99,9 +141,19 @@
     eventQueue.call(Callback<void()>(&ble, &BLE::processEvents));
 }
 
+/******************************MAIN*******************************/
+
 int main()
 {
+    BSP_TSENSOR_Init();
+    BSP_HSENSOR_Init();
+    BSP_PSENSOR_Init();
+    BSP_MAGNETO_Init();
+    BSP_GYRO_Init();
+    BSP_ACCELERO_Init();
+    pc.printf("BLE is Working\n\r");
     eventQueue.call_every(500, blinkCallback);
+    
 
     BLE &ble = BLE::Instance();
     ble.onEventsToProcess(scheduleBleEventsProcessing);