File content as of revision 6:c1b8fb74072e:

/**
 ******************************************************************************
 * @file    CustomSensorService.h
 * @author  AST / EST
 * @version V0.0.1
 * @date    16-Dec-2015
 * @brief   Ble sensor service of Bluemicrosystem1 application
 ******************************************************************************
 * @attention
 *
 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright notice,
 *      this list of conditions and the following disclaimer in the documentation
 *      and/or other materials provided with the distribution.
 *   3. Neither the name of STMicroelectronics nor the names of its contributors
 *      may be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************
 */

#ifndef __CUSTOM_BLE_SENSORS_SERVICE_H__
#define __CUSTOM_BLE_SENSORS_SERVICE_H__

#include "BLE.h"

const LongUUIDBytes_t SENS_SERVICE_UUID_128 =                       {   0x1b,0xc5,0xa5,0xd5,0x02,0x00,0xb4,0x9a,0xe1,0x11,0x01,0x00,0x00,0x00,0x00,0x00}; // temp, pressure, humidity, 

const LongUUIDBytes_t SENS_TEMP_CHAR_UUID_128 =             {   0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0x04,0x00 };  
const LongUUIDBytes_t SENS_HUMI_CHAR_UUID_128 =                 {   0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0x08,0x00};  
const LongUUIDBytes_t SENS_PRES_CHAR_UUID_128 =                 { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0x10,0x00};  
const LongUUIDBytes_t SENS_MAGN_CHAR_UUID_128   =               { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0x20,0x00}; 
const LongUUIDBytes_t SENS_GYRO_CHAR_UUID_128   =                   { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0x40,0x00}; 
const LongUUIDBytes_t SENS_ACCE_CHAR_UUID_128   =                   { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0x80,0x00};
const LongUUIDBytes_t SENS_ACC_GYRO_MAG_CHAR_UUID_128 = { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x01,0x00,0x00,0x00,0xE0,0x00};


#define TEMP_DATA_LEN   2+2
#define HUM_DATA_LEN    2+2
#define PRES_DATA_LEN   2+4
#define ACC_DATA_LEN    6+2 
#define MAG_DATA_LEN    6+2
#define GYRO_DATA_LEN 6+2
#define ACCGYROMAG_DATA_LEN 2+3*3*2


/* Custom Sensors Service */
class CustomSensorService  {
public:
    CustomSensorService(BLE &_ble, CustomBleErrManagement * ErrMgr=NULL ) :
        ble(_ble),
                envTemperatureCharacteristic(SENS_TEMP_CHAR_UUID_128,envTemperature, TEMP_DATA_LEN, TEMP_DATA_LEN,
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),
                envHumidityCharacteristic(SENS_HUMI_CHAR_UUID_128, envHumidity, HUM_DATA_LEN, HUM_DATA_LEN,
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),
                envPressureCharacteristic(SENS_PRES_CHAR_UUID_128, envPressure, PRES_DATA_LEN, PRES_DATA_LEN,
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),               
                envMagnetometerCharacteristic(SENS_MAGN_CHAR_UUID_128,envMagn, MAG_DATA_LEN, MAG_DATA_LEN,                  
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),                                               
                envAccelerometerCharacteristic(SENS_ACCE_CHAR_UUID_128,envAcce, ACC_DATA_LEN, ACC_DATA_LEN,
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),                   
                envGyroCharacteristic(SENS_GYRO_CHAR_UUID_128,envGyro, GYRO_DATA_LEN, GYRO_DATA_LEN,
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),                   
                envAccGyroMagCharacteristic(SENS_ACC_GYRO_MAG_CHAR_UUID_128,envAccGyroMag, ACCGYROMAG_DATA_LEN, ACCGYROMAG_DATA_LEN,
                                                                        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY)
        {
 
        static bool serviceAdded = false; /* We should only ever need to add the env service once. */
        if (serviceAdded) {
            return;
        }
        bleErrMgr = ErrMgr;
        GattCharacteristic *charTable[] = {&envTemperatureCharacteristic, &envHumidityCharacteristic, &envPressureCharacteristic, &envMagnetometerCharacteristic,
                                                                             &envAccelerometerCharacteristic, &envGyroCharacteristic, &envAccGyroMagCharacteristic};                 
                                                                                                                                                         
        GattService   envService(SENS_SERVICE_UUID_128, charTable, sizeof(charTable) / sizeof(GattCharacteristic *));               
                
        ble.gattServer().addService(envService);             

        isEnabledTempNotify             = false;
        isEnabledHumNotify              = false;
        isEnabledPresNotify             = false;
        isEnabledGyroNotify             = false;            
        isEnabledAccNotify              = false;
        isEnabledMagNotify              = false;
        isEnabledAccGyroMagNotify       = false;                  
                                                                             
        isTempCalibrated                = false;
        isHumCalibrated                 = false;
        isPresCalibrated                = false;        
        isMagCalibrated                 = false;
        isAccCalibrated                 = false;        
        isAGyroCalibrated               = false;                

        memset (pastenvTemperature, 0, TEMP_DATA_LEN);  
        memset (pastenvHumidity,        0, HUM_DATA_LEN);           
        memset (pastenvPressure,        0, PRES_DATA_LEN);                          
                                                                         
        isBTLEConnected                 = DISCONNECTED;                                                                  
        serviceAdded                    = true;                                                                                                                                  
    }

    void sendEnvTemperature (int16_t Temp, uint16_t TimeStamp) {
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        }             
        STORE_LE_16(envTemperature,TimeStamp);
        STORE_LE_16(envTemperature+2,Temp);
        PRINTF("sendEnvTemperature!!  handle: %d\n\r",   envTemperatureCharacteristic.getValueAttribute().getHandle());
        memcpy (pastenvTemperature, envTemperature, TEMP_DATA_LEN);
        uint32_t err = ble.gattServer().write(envTemperatureCharacteristic.getValueAttribute().getHandle(), envTemperature, TEMP_DATA_LEN, 0);         
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }
    }               
        
    /**
     * Update the temperature with a new value. Valid values range from
     * 0..100. Anything outside this range will be ignored.
     * @param newLevel New level. */
    void updateEnvTemperature (int16_t Temp, uint16_t TimeStamp) {
        if (isTempNotificationEn()){    
                if (memcmp (&pastenvTemperature[2], &Temp, 2) != 0) {
                    sendEnvTemperature (Temp,  TimeStamp);              
                }
        }
    }
                
    void sendEnvHumidity(uint16_t Hum, uint16_t TimeStamp) {
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        }                     
        STORE_LE_16(envHumidity,TimeStamp);
        STORE_LE_16(envHumidity+2,Hum);
        memcpy (pastenvHumidity, envHumidity, HUM_DATA_LEN);                
        uint32_t err = ble.gattServer().write(envHumidityCharacteristic.getValueAttribute().getHandle(), envHumidity, HUM_DATA_LEN, 0);            
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }        
    }
        
    void updateEnvHumidity(uint16_t Hum, uint16_t TimeStamp) {
        if (isHumNotificationEn()){
                if (memcmp (&pastenvHumidity[2], &Hum, 2) != 0) {               
                    sendEnvHumidity(Hum, TimeStamp);
                }
        }
    }       
                
    void sendEnvPressure(uint32_t Press, uint16_t TimeStamp) {
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        }             
        STORE_LE_16(envPressure,TimeStamp);         
        STORE_LE_32(envPressure+2,Press);
        memcpy (pastenvPressure, envPressure, PRES_DATA_LEN);                           
        uint32_t err=ble.gattServer().write(envPressureCharacteristic.getValueAttribute().getHandle(), envPressure, PRES_DATA_LEN, 0); 
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }                      
    }
        
    void updateEnvPressure(uint32_t Press, uint16_t TimeStamp) {
        if (isPresNotificationEn()){
                if (memcmp (&pastenvPressure[2], &Press, 2) != 0) {             
                    sendEnvPressure(Press, TimeStamp);
            }
        }
    }       
    
    void sendEnvMagnetometer(AxesRaw_TypeDef *Magn, uint16_t TimeStamp, osxMFX_calibFactor magOffset) {   
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        } 
        STORE_LE_16(envMagn,TimeStamp);
        STORE_LE_16(envMagn+2,(Magn->AXIS_X - magOffset.magOffX));
        STORE_LE_16(envMagn+4,(Magn->AXIS_Y - magOffset.magOffY));
        STORE_LE_16(envMagn+6,(Magn->AXIS_Z - magOffset.magOffZ));          
        uint32_t err = ble.gattServer().write(envMagnetometerCharacteristic.getValueAttribute().getHandle(), envMagn, MAG_DATA_LEN, 0);
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }
    }
        
    void updateEnvMagnetometer(AxesRaw_TypeDef *Magn, uint16_t TimeStamp, osxMFX_calibFactor magOffset) {   
            if (isMagNotificationEn()) sendEnvMagnetometer(Magn, TimeStamp, magOffset);
    }               
        
    void sendEnvAccelerometer (AxesRaw_TypeDef *Acc, uint16_t TimeStamp) {          
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        }     
        STORE_LE_16(envAcce,TimeStamp);
        STORE_LE_16(envAcce+2,Acc->AXIS_X);
        STORE_LE_16(envAcce+4,Acc->AXIS_Y);
        STORE_LE_16(envAcce+6,Acc->AXIS_Z);
        uint32_t err = ble.gattServer().write(envAccelerometerCharacteristic.getValueAttribute().getHandle(), envAcce, ACC_DATA_LEN, 0);           
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }
            
    }
        
    void updateEnvAccelerometer (AxesRaw_TypeDef *Acc, uint16_t TimeStamp) {            
            if (isAccNotificationEn()) sendEnvAccelerometer (Acc, TimeStamp);
    }                       

    void sendEnvGyroscope (AxesRaw_TypeDef *Gyro, uint16_t TimeStamp) {     
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        } 
        STORE_LE_16(envGyro,TimeStamp);
        STORE_LE_16(envGyro+2,Gyro->AXIS_X);
        STORE_LE_16(envGyro+4,Gyro->AXIS_Y);
        STORE_LE_16(envGyro+6,Gyro->AXIS_Z);
        uint32_t err = ble.gattServer().write(envGyroCharacteristic.getValueAttribute().getHandle(), envGyro, GYRO_DATA_LEN, 0);
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }                       
    }       
        
    void updateEnvGyroscope (AxesRaw_TypeDef *Gyro, uint16_t TimeStamp) {       
            if (isGyroNotificationEn()) sendEnvGyroscope (Gyro, TimeStamp);             
    }                       

    void sendEnvAccGyroMag (AxesRaw_TypeDef *Acc, AxesRaw_TypeDef *Gyro, AxesRaw_TypeDef *Magn, uint16_t TimeStamp, osxMFX_calibFactor magOffset) {
        if (bleErrMgr != NULL) {
            if (!bleErrMgr->isBleTxChannelOk()){
                bleErrMgr->signalBleTxOk();  // skip tx because of previous error
                return;
            }
        }             
        STORE_LE_16(envAccGyroMag,TimeStamp);
        STORE_LE_16(envAccGyroMag+2,Acc->AXIS_X);
        STORE_LE_16(envAccGyroMag+4,Acc->AXIS_Y);
        STORE_LE_16(envAccGyroMag+6,Acc->AXIS_Z);
            
        STORE_LE_16(envAccGyroMag+8,Gyro->AXIS_X);
        STORE_LE_16(envAccGyroMag+10,Gyro->AXIS_Y);
        STORE_LE_16(envAccGyroMag+12,Gyro->AXIS_Z);
            
        STORE_LE_16(envAccGyroMag+14,(Magn->AXIS_X  - magOffset.magOffX));
        STORE_LE_16(envAccGyroMag+16,(Magn->AXIS_Y  - magOffset.magOffY));
        STORE_LE_16(envAccGyroMag+18,(Magn->AXIS_Z  - magOffset.magOffZ));                      
        uint32_t err = ble.gattServer().write(envAccGyroMagCharacteristic.getValueAttribute().getHandle(), envAccGyroMag, ACCGYROMAG_DATA_LEN, 0);         
        if (!err) {
             bleErrMgr->signalBleTxOk();
        }else{
            bleErrMgr->signalBleTxErr(err);
        }    
    }
        
    void updateEnvAccGyroMag (AxesRaw_TypeDef *Acc, AxesRaw_TypeDef *Gyro, AxesRaw_TypeDef *Magn, uint16_t TimeStamp, osxMFX_calibFactor magOffset) {       
            if (isAccGyroMagNotificationEn())sendEnvAccGyroMag (Acc, Gyro, Magn, TimeStamp, magOffset);              
    }                               
        
    void enNotify (Gap::Handle_t handle) {
            if (isTempHandle(handle)) { isEnabledTempNotify = true; memset(pastenvTemperature,0,TEMP_DATA_LEN); return; }
            if (isHumHandle(handle))  { isEnabledHumNotify  = true; memset(pastenvHumidity,0,HUM_DATA_LEN);       return; }           
            if (isPresHandle(handle)) { isEnabledPresNotify = true; memset(pastenvPressure,0,PRES_DATA_LEN);      return; }                       
            if (isGyroHandle(handle)) { isEnabledGyroNotify = true; return; } 
            if (isAccHandle(handle))  { isEnabledAccNotify  = true; return; } 
            if (isMagHandle(handle))  { isEnabledMagNotify  = true; return; } 
            if (isAccGyroMagHandle(handle)) { isEnabledAccGyroMagNotify = true; return; }             
    }

    void disNotify (Gap::Handle_t handle) {
            if (isTempHandle(handle)) { isEnabledTempNotify = false; memset(pastenvTemperature,0,TEMP_DATA_LEN); return; }        
            if (isHumHandle(handle))  { isEnabledHumNotify  = false; memset(pastenvHumidity,0,HUM_DATA_LEN);       return; }      
            if (isPresHandle(handle)) { isEnabledPresNotify = false; memset(pastenvPressure,0,PRES_DATA_LEN);      return; }                                  
            if (isGyroHandle(handle)) { isEnabledGyroNotify = false; return; }    
            if (isAccHandle(handle))  { isEnabledAccNotify  = false; return; }    
            if (isMagHandle(handle))  { isEnabledMagNotify  = false; return; }    
            if (isAccGyroMagHandle(handle)) { isEnabledAccGyroMagNotify = false; return; }                
    }
        
    bool isTempNotificationEn (void) {
            return isEnabledTempNotify;
    }
        
    bool isHumNotificationEn (void) {
            return isEnabledHumNotify;
    }

    bool isPresNotificationEn (void) {
            return isEnabledPresNotify;
    }

    bool isGyroNotificationEn (void) {
            return isEnabledGyroNotify;
    }   

    bool isAccNotificationEn (void) {
            return isEnabledAccNotify;
    }   
        
    bool isMagNotificationEn (void) {
            return isEnabledMagNotify;
    }   
            
    bool isAccGyroMagNotificationEn (void) {
            return isEnabledAccGyroMagNotify;
    }           
        
    bool isTempHandle (Gap::Handle_t handle) {
            if (handle == envTemperatureCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }

    bool isHumHandle (Gap::Handle_t handle) {
            if (handle == envHumidityCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }
    
    bool isPresHandle (Gap::Handle_t handle) {
            if (handle == envPressureCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    } 

    bool isMagHandle (Gap::Handle_t handle) {
            if (handle == envMagnetometerCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }
    bool isAccHandle (Gap::Handle_t handle) {
            if (handle == envAccelerometerCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }
    bool isGyroHandle (Gap::Handle_t handle) {
            if (handle == envGyroCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }
    bool isAccGyroMagHandle (Gap::Handle_t handle) {
            if (handle == envAccGyroMagCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }
        
    void updateConnectionStatus(ConnectionStatus_t status) {   
            isEnabledTempNotify             = false;
            isEnabledHumNotify              = false;
            isEnabledPresNotify             = false;
            isEnabledGyroNotify             = false;            
            isEnabledAccNotify              = false;
            isEnabledMagNotify              = false;
            isEnabledAccGyroMagNotify = false;                  
                                                                             
            isTempCalibrated                = false;
            isHumCalibrated                 = false;
            isPresCalibrated                = false;        
            isMagCalibrated                 = false;
            isAccCalibrated                 = false;        
            isAGyroCalibrated               = false;            
            
            memset (pastenvTemperature, 0, TEMP_DATA_LEN);  
            memset (pastenvHumidity, 0, HUM_DATA_LEN);          
            memset (pastenvPressure, 0, PRES_DATA_LEN);                     
            isBTLEConnected = status; 
    }
                
        
private:
    BLE                  &ble;
    CustomBleErrManagement *bleErrMgr;
    uint8_t              envTemperature     [TEMP_DATA_LEN];                /* in C  */
    uint8_t              pastenvTemperature [TEMP_DATA_LEN];        
    uint8_t              envHumidity        [HUM_DATA_LEN];                     /* in %  */
    uint8_t              pastenvHumidity    [HUM_DATA_LEN];             
    uint8_t              envPressure        [PRES_DATA_LEN];                        /* in mBar */
    uint8_t              pastenvPressure    [PRES_DATA_LEN];            
    uint8_t              envMagn            [MAG_DATA_LEN];         
    uint8_t              envGyro            [GYRO_DATA_LEN];
    uint8_t              envAcce            [ACC_DATA_LEN];
    uint8_t              envAccGyroMag      [ACCGYROMAG_DATA_LEN];

    GattCharacteristic   envTemperatureCharacteristic;     
    GattCharacteristic   envHumidityCharacteristic;   
    GattCharacteristic   envPressureCharacteristic;

    GattCharacteristic   envMagnetometerCharacteristic;
    GattCharacteristic   envAccelerometerCharacteristic;
    GattCharacteristic   envGyroCharacteristic;
    GattCharacteristic   envAccGyroMagCharacteristic;

    ConnectionStatus_t   isBTLEConnected;

    bool                 isEnabledTempNotify;
    bool                 isEnabledHumNotify;
    bool                 isEnabledPresNotify;
    bool                 isEnabledGyroNotify;           
    bool                 isEnabledAccNotify;
    bool                 isEnabledMagNotify;
    bool                 isEnabledAccGyroMagNotify;                 
        
    bool                 isTempCalibrated;
    bool                 isHumCalibrated;
    bool                 isPresCalibrated;      
    bool                 isMagCalibrated;
    bool                 isAccCalibrated;       
    bool                 isAGyroCalibrated;             
               
};

#endif /* #ifndef __CUSTOM_BLE_SENSORS_SERVICE_H__*/