aconnoHelpers.cpp

00001 /**
00002  * Made by Jurica @ aconno
00003  * jurica@aconno.de
00004  * More info @ aconno.de
00005  */
00006 
00007 #include "mbed.h"
00008 #include "ble/BLE.h"
00009 #include "acd52832_bsp.h"
00010 #include "GapAdvertisingData.h"
00011 #include "Si7006A20.h"
00012 #include "LSM9DS1.h"
00013 #include "math.h"
00014 #include "adc52832_common/utilities.h"
00015 #include "MPL115A1.h"
00016 #include "acd_nrf52_saadc.h"
00017 #include "aconnoConfig.h"
00018 #include <iostream>
00019 #include <cmath>
00020 
00021 NRF52_SAADC analogIn;
00022 extern DigitalOut lightPower;
00023 extern DigitalOut temperaturePower;
00024 extern DigitalOut shdn;
00025 extern DigitalOut power;
00026 vector3_s memsAccelerometerInit;
00027 vector3_s memsGyroscopeInit;
00028 vector3_s memsMagnetometerInit;
00029 extern GapAdvertisingData adv_data;
00030 extern advertising_packet advertisementPacket;
00031 DigitalOut cs(p7);
00032 
00033 I2C i2c(I2C_DATA, I2C_CLK);   
00034 Si7006 si(&i2c);
00035 SPI spi(SPI_MOSI, SPI_MISO, SPI_SCLK);
00036 MPL115A1 mpl115a1(spi, cs);
00037 LSM9DS1 mems(&i2c);
00038 
00039 float getLight(){
00040     return ((float)analogIn.getData()[1])/ADC_RESOLUTION * VALUE_TO_PERCENTAGE;
00041 }
00042 
00043 float voltage2temp(float vOut){
00044     return ((float)vOut - (float)V0)/((float)TC);
00045 }
00046 
00047 float getTemperature(){
00048     return voltage2temp(((float)analogIn.getData()[2])/ADC_RESOLUTION * (float)VCC);
00049 }
00050 
00051 uint8_t getBattery(){
00052     uint16_t batteryVoltage = analogIn.getData()[0];
00053     
00054     const uint16_t zero_percent_limit = 739;
00055     const uint16_t onehundred_percent_limit = 810;
00056     const uint16_t percentage_increments = 5;
00057     uint8_t percentage;
00058     
00059     if (batteryVoltage < zero_percent_limit)
00060     {
00061         percentage = 0;
00062     }
00063     else if(batteryVoltage > onehundred_percent_limit)
00064     {
00065         percentage = 100;
00066     }
00067     else
00068     {
00069         batteryVoltage -= zero_percent_limit;
00070         percentage = (batteryVoltage*100)/(onehundred_percent_limit - zero_percent_limit);
00071         percentage = percentage/percentage_increments*percentage_increments;
00072     }
00073     
00074     return percentage;
00075 }
00076 
00077 float getHumidity(){
00078     float result;
00079     si.getHumidity(&result);
00080     return result;
00081 }
00082 
00083 void readGyroscope(vector3_s *gyroscopeData){
00084     mems.readGyroscope((int16_t *)gyroscopeData);
00085     *gyroscopeData -= memsGyroscopeInit;
00086 }
00087 
00088 void readAccelerometer(vector3_s *accelerometerData){
00089     mems.readAccelerometer((int16_t *)accelerometerData);
00090     *accelerometerData -= memsAccelerometerInit;
00091 }
00092 
00093 void readMagnetometer(vector3_s *magnetometerData){
00094     mems.readMagnetometer((int16_t *)magnetometerData);
00095     *magnetometerData -= memsMagnetometerInit;
00096 }
00097 
00098 void calibrateAccelerometer(){
00099     vector3_s accelerometerData;
00100     for(uint8_t counter = 0; counter < CALIBRATION_STEPS; ++counter){
00101         readAccelerometer(&accelerometerData);
00102         memsAccelerometerInit += accelerometerData;
00103     }
00104     memsAccelerometerInit /= CALIBRATION_STEPS;
00105 }
00106 
00107 void calibrateGyroscope(){
00108     vector3_s gyroscopeData;
00109     for(uint8_t counter = 0; counter < CALIBRATION_STEPS; ++counter){
00110         readGyroscope(&gyroscopeData);
00111         memsGyroscopeInit += gyroscopeData;
00112     }
00113     memsGyroscopeInit /= CALIBRATION_STEPS;
00114 }
00115 
00116 void calibrateMag(){
00117     vector3_s magnetometerData;
00118     for(uint8_t counter = 0; counter < CALIBRATION_STEPS; ++counter){
00119         readMagnetometer(&magnetometerData);
00120         memsMagnetometerInit += magnetometerData;
00121     }
00122     memsMagnetometerInit /= CALIBRATION_STEPS;
00123 }
00124 
00125 float calculateDegree(float accX, float accY, float accZ){
00126     
00127     float degree;
00128     if (accX != 0.0f && accY != 0.0f && accZ != 0.0f) {
00129 
00130         float dnum = sqrt(accY * accY + accZ * accZ);
00131         degree = atan(accX / dnum);
00132 
00133         if ((accX < 0 && accY >= 0)) {
00134             degree = 360 + degree;
00135         }
00136         if (accX >= 0 && accY < 0)
00137             degree = 180 - degree;
00138 
00139         if (accX < 0 && accY < 0)
00140             degree = 180 - degree;
00141 
00142            //cout<<"degree: " << degree;
00143            
00144         }
00145     return degree;
00146     
00147 }
00148 void updateData()
00149 {
00150     //static uint8_t advertisementType = 0;
00151     int16_t temp_acc[3];
00152     BLE &ble = BLE::Instance();
00153 
00154     float result;
00155     mems.startAccelerometer();
00156    // advertisementPacket.type = 0x00;
00157     //Added for Angular sensa
00158      readAccelerometer((vector3_s *)temp_acc);
00159        float degreeValue = calculateDegree( (float) temp_acc[1],
00160         (float) temp_acc[0],
00161          (float) temp_acc[2]);
00162           
00163         advertisementPacket.degree = degreeValue;  
00164         
00165     /*if(advertisementType < 1)
00166     {
00167         power = 1;
00168         mems.startAccelerometer();
00169         mems.startGyroscope();
00170         mems.startMagnetometer();
00171         wait_ms(WAKEUP_TIME_DELAY_MS);
00172         advertisementPacket.type = 0x00;
00173         readGyroscope((vector3_s *)advertisementPacket.gyroscope);
00174         readAccelerometer((vector3_s *)temp_acc);
00175         readMagnetometer((vector3_s *)advertisementPacket.magnetometer);
00176         //advertisementPacket.acc_lsb_value = (0xF9E);//(0x3D80);
00177         //advertisementPacket.accelerometer[0] = temp_acc[1];
00178         //advertisementPacket.accelerometer[1] = temp_acc[0];
00179         //advertisementPacket.accelerometer[2] = temp_acc[2];
00180         
00181         float degreeValue = calculateDegree( (float) temp_acc[1],
00182         (float) temp_acc[0],
00183          (float) temp_acc[2]);
00184           
00185         cout<<"degree: " << degreeValue;  
00186         advertisementPacket.degree = degreeValue;  
00187         // ^--- That's in ug cuz MSB is 1
00188     }
00189     else
00190     {   
00191         NRF_SAADC->ENABLE = 1;
00192         power = 1;
00193         temperaturePower = 1;
00194         lightPower = 1;
00195         shdn = 1;
00196         analogIn.addChannel(9); // Set VDD  as source to SAADC
00197         analogIn.addChannel(6); // Light
00198         analogIn.addChannel(7); // Temp
00199         analogIn.calibrate();
00200         wait_ms(WAKEUP_TIME_DELAY_MS);
00201         analogIn.updateData();
00202         wait_ms(WAKEUP_TIME_DELAY_MS);
00203 
00204         advertisementPacket.type = 0x01;
00205         advertisementPacket.temperature = getTemperature();
00206         advertisementPacket.light       = getLight();
00207         advertisementPacket.humidity    = getHumidity();
00208         advertisementPacket.pressure    = mpl115a1.getPressure();
00209         advertisementPacket.battery     = getBattery();
00210     }
00211     */
00212     SPI dummySpi(SPI_MOSI, SPI_MISO, SPI_SCLK);
00213     power = 0;
00214     shdn = 0;
00215     temperaturePower = 0;
00216     lightPower = 0;
00217     NRF_SAADC->ENABLE = 0;
00218 
00219     //if(++advertisementType > 2) advertisementType = 0;    
00220     adv_data = ble.gap().getAdvertisingPayload();
00221     adv_data.updateData(adv_data.MANUFACTURER_SPECIFIC_DATA, 
00222                 (uint8_t *)&advertisementPacket, sizeof(advertisementPacket));
00223     ble.gap().setAdvertisingPayload(adv_data);
00224 }