Francis CHATAIN / Mbed 2 deprecated MSNV2-Terminal_V1-6

Version FC

Dependencies:   DmTftLibrary eeprom SX1280Lib filesystem mbed

Fork of MSNV2-Terminal_V1-5 by Francis CHATAIN

COMPONENTS/bme280_component.hpp@41:5a436163dddf, 2018-10-22 (annotated)

Committer:
FCH_31
Date:
Mon Oct 22 09:37:50 2018 +0000
Revision:
41:5a436163dddf
Parent:
34:aa6d3a83dafc 
avec radio;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
lo 32:3bef9b81f639 1 /*
lo 32:3bef9b81f639 2 * bme280_component.hpp
lo 32:3bef9b81f639 3 *
lo 32:3bef9b81f639 4 * Created on: 17 sept. 2018
lo 32:3bef9b81f639 5 * Author: hoel
lo 32:3bef9b81f639 6 */
lo 32:3bef9b81f639 7
lo 32:3bef9b81f639 8 #ifndef BME280_COMPONENT_HPP_
lo 32:3bef9b81f639 9 #define BME280_COMPONENT_HPP_
lo 32:3bef9b81f639 10
lo 32:3bef9b81f639 11 #include <iostream>
lo 32:3bef9b81f639 12 #include <cstdlib>
lo 32:3bef9b81f639 13 #include "mbed.h"
lo 32:3bef9b81f639 14 #include "Context.h"
lo 32:3bef9b81f639 15 #include "Service.hpp"
lo 32:3bef9b81f639 16 #include "Component.hpp"
lo 32:3bef9b81f639 17
lo 32:3bef9b81f639 18 using namespace std;
lo 32:3bef9b81f639 19 using namespace misnet;
lo 32:3bef9b81f639 20
lo 32:3bef9b81f639 21 #define DEF_SLAVE_ADDR (0x77 << 1) // SDO low
lo 32:3bef9b81f639 22 //#define _DEBUG
lo 32:3bef9b81f639 23 #ifdef _DEBUG
lo 32:3bef9b81f639 24 extern Serial pc2;
lo 32:3bef9b81f639 25 #define DEBUG_PRINT(...) pc2.printf(__VA_ARGS__)
lo 32:3bef9b81f639 26 #else
lo 32:3bef9b81f639 27 #define DEBUG_PRINT(...)
lo 32:3bef9b81f639 28 #endif
lo 32:3bef9b81f639 29
lo 32:3bef9b81f639 30 class bme280_component : public Component{
lo 32:3bef9b81f639 31
lo 32:3bef9b81f639 32 private:
lo 32:3bef9b81f639 33 I2C *i2c_p;
lo 32:3bef9b81f639 34 I2C &i2c;
lo 32:3bef9b81f639 35 char address;
lo 32:3bef9b81f639 36 uint16_t dig_T1=0;
lo 32:3bef9b81f639 37 int16_t dig_T2=0, dig_T3=0;
lo 32:3bef9b81f639 38 uint16_t dig_P1=0;
lo 32:3bef9b81f639 39 int16_t dig_P2=0, dig_P3=0, dig_P4=0, dig_P5=0, dig_P6=0, dig_P7=0, dig_P8=0, dig_P9=0;
lo 32:3bef9b81f639 40 uint16_t dig_H1=0, dig_H3=0;
lo 32:3bef9b81f639 41 int16_t dig_H2=0, dig_H4=0, dig_H5=0, dig_H6=0;
lo 32:3bef9b81f639 42 int32_t t_fine;
lo 32:3bef9b81f639 43 PinName sda = I2C_SDA; // TODO : clean
lo 32:3bef9b81f639 44 PinName scl = I2C_SCL; // TODO : clean
lo 32:3bef9b81f639 45 char slave_adr = DEF_SLAVE_ADDR; // TODO : clean
lo 32:3bef9b81f639 46
lo 32:3bef9b81f639 47 public:
lo 32:3bef9b81f639 48 bme280_component(COMPONENT_ID id, std::vector<Service*>& services):
patrick_duc 34:aa6d3a83dafc 49 Component(id, services),
lo 32:3bef9b81f639 50 // TODO : implement peripheral pin arguments
lo 32:3bef9b81f639 51 // BME280_component(PinName sda, PinName scl, char slave_adr,COMPONENT_ID id, std::vector<Service*>& services):
lo 32:3bef9b81f639 52 i2c_p(new I2C(sda, scl)),
lo 32:3bef9b81f639 53 i2c(*i2c_p),
lo 32:3bef9b81f639 54 address(slave_adr),
lo 32:3bef9b81f639 55 t_fine(0)//,
lo 32:3bef9b81f639 56 {
lo 32:3bef9b81f639 57 }
lo 32:3bef9b81f639 58 ~bme280_component(){
lo 32:3bef9b81f639 59 if (NULL != bme280_component::i2c_p)
lo 32:3bef9b81f639 60 delete bme280_component::i2c_p;
lo 32:3bef9b81f639 61 }
lo 32:3bef9b81f639 62 bool init(void){
lo 32:3bef9b81f639 63
lo 32:3bef9b81f639 64 char cmd[18];
lo 32:3bef9b81f639 65
lo 32:3bef9b81f639 66 cmd[0] = 0xf2; // ctrl_hum
lo 32:3bef9b81f639 67 cmd[1] = 0x01; // Humidity oversampling x1
lo 32:3bef9b81f639 68 i2c.write(address, cmd, 2);
lo 32:3bef9b81f639 69
lo 32:3bef9b81f639 70 cmd[0] = 0xf4; // ctrl_meas
lo 32:3bef9b81f639 71 cmd[1] = 0x27; // Temperature oversampling x1, Pressure oversampling x1, Normal mode
lo 32:3bef9b81f639 72 i2c.write(address, cmd, 2);
lo 32:3bef9b81f639 73
lo 32:3bef9b81f639 74 cmd[0] = 0xf5; // config
lo 32:3bef9b81f639 75 cmd[1] = 0xa0; // Standby 1000ms, Filter off
lo 32:3bef9b81f639 76 i2c.write(address, cmd, 2);
lo 32:3bef9b81f639 77
lo 32:3bef9b81f639 78 cmd[0] = 0x88; // read dig_T regs
lo 32:3bef9b81f639 79 i2c.write(address, cmd, 1);
lo 32:3bef9b81f639 80 i2c.read(address, cmd, 6);
lo 32:3bef9b81f639 81
lo 32:3bef9b81f639 82 dig_T1 = (cmd[1] << 8) | cmd[0];
lo 32:3bef9b81f639 83 dig_T2 = (cmd[3] << 8) | cmd[2];
lo 32:3bef9b81f639 84 dig_T3 = (cmd[5] << 8) | cmd[4];
lo 32:3bef9b81f639 85
lo 32:3bef9b81f639 86 DEBUG_PRINT("dig_T = 0x%x, 0x%x, 0x%x\n", dig_T1, dig_T2, dig_T3);
lo 32:3bef9b81f639 87
lo 32:3bef9b81f639 88 cmd[0] = 0x8E; // read dig_P regs
lo 32:3bef9b81f639 89 i2c.write(address, cmd, 1);
lo 32:3bef9b81f639 90 i2c.read(address, cmd, 18);
lo 32:3bef9b81f639 91
lo 32:3bef9b81f639 92 dig_P1 = (cmd[ 1] << 8) | cmd[ 0];
lo 32:3bef9b81f639 93 dig_P2 = (cmd[ 3] << 8) | cmd[ 2];
lo 32:3bef9b81f639 94 dig_P3 = (cmd[ 5] << 8) | cmd[ 4];
lo 32:3bef9b81f639 95 dig_P4 = (cmd[ 7] << 8) | cmd[ 6];
lo 32:3bef9b81f639 96 dig_P5 = (cmd[ 9] << 8) | cmd[ 8];
lo 32:3bef9b81f639 97 dig_P6 = (cmd[11] << 8) | cmd[10];
lo 32:3bef9b81f639 98 dig_P7 = (cmd[13] << 8) | cmd[12];
lo 32:3bef9b81f639 99 dig_P8 = (cmd[15] << 8) | cmd[14];
lo 32:3bef9b81f639 100 dig_P9 = (cmd[17] << 8) | cmd[16];
lo 32:3bef9b81f639 101
lo 32:3bef9b81f639 102 DEBUG_PRINT("dig_P = 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", dig_P1, dig_P2, dig_P3, dig_P4, dig_P5, dig_P6, dig_P7, dig_P8, dig_P9);
lo 32:3bef9b81f639 103
lo 32:3bef9b81f639 104 cmd[0] = 0xA1; // read dig_H regs
lo 32:3bef9b81f639 105 i2c.write(address, cmd, 1);
lo 32:3bef9b81f639 106 i2c.read(address, cmd, 1);
lo 32:3bef9b81f639 107 cmd[1] = 0xE1; // read dig_H regs
lo 32:3bef9b81f639 108 i2c.write(address, &cmd[1], 1);
lo 32:3bef9b81f639 109 i2c.read(address, &cmd[1], 7);
lo 32:3bef9b81f639 110
lo 32:3bef9b81f639 111 dig_H1 = cmd[0];
lo 32:3bef9b81f639 112 dig_H2 = (cmd[2] << 8) | cmd[1];
lo 32:3bef9b81f639 113 dig_H3 = cmd[3];
lo 32:3bef9b81f639 114 dig_H4 = (cmd[4] << 4) | (cmd[5] & 0x0f);
lo 32:3bef9b81f639 115 dig_H5 = (cmd[6] << 4) | ((cmd[5]>>4) & 0x0f);
lo 32:3bef9b81f639 116 dig_H6 = cmd[7];
lo 32:3bef9b81f639 117
lo 32:3bef9b81f639 118 DEBUG_PRINT("dig_H = 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", dig_H1, dig_H2, dig_H3, dig_H4, dig_H5, dig_H6);
lo 32:3bef9b81f639 119 return false;
lo 32:3bef9b81f639 120 }
patrick_duc 34:aa6d3a83dafc 121
patrick_duc 34:aa6d3a83dafc 122 /*
lo 32:3bef9b81f639 123 void readValues(void){
lo 32:3bef9b81f639 124 for (std::vector<misnet::Service*>::iterator
lo 32:3bef9b81f639 125 srvIt = this->getServices().begin();
lo 32:3bef9b81f639 126 srvIt != this->getServices().end();
lo 32:3bef9b81f639 127 srvIt++) {
lo 32:3bef9b81f639 128 (*srvIt)->readValue();
lo 32:3bef9b81f639 129 }
lo 32:3bef9b81f639 130 }
patrick_duc 34:aa6d3a83dafc 131 */
lo 32:3bef9b81f639 132
lo 32:3bef9b81f639 133 class bme280_temperature : public Service {
lo 26:271d2d510f6c 134
patrick_duc 34:aa6d3a83dafc 135 public:
lo 32:3bef9b81f639 136 bme280_temperature(
patrick_duc 34:aa6d3a83dafc 137 DEVICE_TYPE type,
patrick_duc 34:aa6d3a83dafc 138 MISNET_CODE misnet_code,
patrick_duc 34:aa6d3a83dafc 139 STATE state,
patrick_duc 34:aa6d3a83dafc 140 ACCESS_TYPE access_type,
patrick_duc 34:aa6d3a83dafc 141 REQUEST_MODE request_mode,
patrick_duc 34:aa6d3a83dafc 142 UP_MODE up_mode,
patrick_duc 34:aa6d3a83dafc 143 ACCESS_PIN access_pins[6],
patrick_duc 34:aa6d3a83dafc 144 uint32_t subsample_rate,
patrick_duc 34:aa6d3a83dafc 145 ACTION action,
patrick_duc 34:aa6d3a83dafc 146 OUTPUT_MODE output_mode,
patrick_duc 34:aa6d3a83dafc 147 string comment,
patrick_duc 34:aa6d3a83dafc 148 bme280_component* parent ):
patrick_duc 34:aa6d3a83dafc 149 Service(type, misnet_code, state, access_type, request_mode,
patrick_duc 34:aa6d3a83dafc 150 up_mode, access_pins, subsample_rate, action, output_mode, comment, parent)
lo 32:3bef9b81f639 151 {
lo 32:3bef9b81f639 152 }
patrick_duc 34:aa6d3a83dafc 153
lo 32:3bef9b81f639 154 virtual ~bme280_temperature() {}
lo 32:3bef9b81f639 155
lo 32:3bef9b81f639 156 bool readValue(void) {
lo 32:3bef9b81f639 157 uint32_t temp_raw;
lo 32:3bef9b81f639 158 float tempf;
lo 32:3bef9b81f639 159 char cmd[4];
lo 32:3bef9b81f639 160
lo 32:3bef9b81f639 161 cmd[0] = 0xfa; // temp_msb
lo 32:3bef9b81f639 162 parent->i2c.write(parent->address, cmd, 1);
lo 32:3bef9b81f639 163 parent->i2c.read(parent->address, &cmd[1], 3);
lo 32:3bef9b81f639 164 temp_raw = (cmd[1] << 12) | (cmd[2] << 4) | (cmd[3] >> 4);
lo 32:3bef9b81f639 165 int32_t temp;
lo 32:3bef9b81f639 166 temp =
lo 32:3bef9b81f639 167 (((((temp_raw >> 3) - (parent->dig_T1 << 1))) * parent->dig_T2) >> 11) +
lo 32:3bef9b81f639 168 ((((((temp_raw >> 4) - parent->dig_T1) * ((temp_raw >> 4) - parent->dig_T1)) >> 12) * parent->dig_T3) >> 14);
lo 32:3bef9b81f639 169 parent->t_fine = temp;
lo 32:3bef9b81f639 170 temp = (temp * 5 + 128) >> 8;
lo 32:3bef9b81f639 171 tempf = (float)temp;
lo 32:3bef9b81f639 172 this->getValueAddress().setFloatValue(tempf/100.0f);
lo 32:3bef9b81f639 173 this->savePreviousValue();
lo 32:3bef9b81f639 174 return false;
lo 32:3bef9b81f639 175 }
patrick_duc 34:aa6d3a83dafc 176
patrick_duc 34:aa6d3a83dafc 177 bool readValue(std::vector<misnet::Service*> servicesWithAsynchronousRead) {
patrick_duc 34:aa6d3a83dafc 178 return this->readValue();
patrick_duc 34:aa6d3a83dafc 179 }
lo 32:3bef9b81f639 180 };
lo 32:3bef9b81f639 181
lo 32:3bef9b81f639 182 class bme280_humidity : public Service {
lo 32:3bef9b81f639 183
patrick_duc 34:aa6d3a83dafc 184 public:
lo 32:3bef9b81f639 185 bme280_humidity(
patrick_duc 34:aa6d3a83dafc 186 DEVICE_TYPE type,
patrick_duc 34:aa6d3a83dafc 187 MISNET_CODE misnet_code,
patrick_duc 34:aa6d3a83dafc 188 STATE state,
patrick_duc 34:aa6d3a83dafc 189 ACCESS_TYPE access_type,
patrick_duc 34:aa6d3a83dafc 190 REQUEST_MODE request_mode,
patrick_duc 34:aa6d3a83dafc 191 UP_MODE up_mode,
patrick_duc 34:aa6d3a83dafc 192 ACCESS_PIN access_pins[6],
patrick_duc 34:aa6d3a83dafc 193 uint32_t subsample_rate,
patrick_duc 34:aa6d3a83dafc 194 ACTION action,
patrick_duc 34:aa6d3a83dafc 195 OUTPUT_MODE output_mode,
patrick_duc 34:aa6d3a83dafc 196 string comment,
patrick_duc 34:aa6d3a83dafc 197 bme280_component* parent) :
lo 32:3bef9b81f639 198 Service(type, misnet_code, state, access_type, request_mode,
patrick_duc 34:aa6d3a83dafc 199 up_mode, access_pins, subsample_rate, action, output_mode, comment, parent)
patrick_duc 34:aa6d3a83dafc 200 {
patrick_duc 34:aa6d3a83dafc 201 }
patrick_duc 34:aa6d3a83dafc 202
lo 32:3bef9b81f639 203 virtual ~bme280_humidity() {}
lo 32:3bef9b81f639 204
lo 32:3bef9b81f639 205 bool readValue(void){
patrick_duc 34:aa6d3a83dafc 206 printf(" ID %d,", this->getMisnetCode());
patrick_duc 34:aa6d3a83dafc 207 uint32_t hum_raw;
patrick_duc 34:aa6d3a83dafc 208 float humf;
patrick_duc 34:aa6d3a83dafc 209 char cmd[4];
lo 32:3bef9b81f639 210
patrick_duc 34:aa6d3a83dafc 211 cmd[0] = 0xfd; // hum_msb
patrick_duc 34:aa6d3a83dafc 212 parent->i2c.write(parent->address, cmd, 1);
patrick_duc 34:aa6d3a83dafc 213 parent->i2c.read(parent->address, &cmd[1], 2);
patrick_duc 34:aa6d3a83dafc 214 // TODO return true if reading result is invalid
patrick_duc 34:aa6d3a83dafc 215 hum_raw = (cmd[1] << 8) | cmd[2];
patrick_duc 34:aa6d3a83dafc 216 int32_t v_x1;
patrick_duc 34:aa6d3a83dafc 217 v_x1 = parent->t_fine - 76800;
patrick_duc 34:aa6d3a83dafc 218 v_x1 = (((((hum_raw << 14) -(((int32_t)parent->dig_H4) << 20) - (((int32_t)parent->dig_H5) * v_x1)) +
patrick_duc 34:aa6d3a83dafc 219 ((int32_t)16384)) >> 15) * (((((((v_x1 * (int32_t)parent->dig_H6) >> 10) *
patrick_duc 34:aa6d3a83dafc 220 (((v_x1 * ((int32_t)parent->dig_H3)) >> 11) + 32768)) >> 10) + 2097152) *
patrick_duc 34:aa6d3a83dafc 221 (int32_t)parent->dig_H2 + 8192) >> 14));
patrick_duc 34:aa6d3a83dafc 222 v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * (int32_t)parent->dig_H1) >> 4));
patrick_duc 34:aa6d3a83dafc 223 v_x1 = (v_x1 < 0 ? 0 : v_x1);
patrick_duc 34:aa6d3a83dafc 224 v_x1 = (v_x1 > 419430400 ? 419430400 : v_x1);
patrick_duc 34:aa6d3a83dafc 225 humf = (float)(v_x1 >> 12);
patrick_duc 34:aa6d3a83dafc 226 this->getValueAddress().setFloatValue(humf/1024.0f);
patrick_duc 34:aa6d3a83dafc 227 this->savePreviousValue();
patrick_duc 34:aa6d3a83dafc 228 return false;
patrick_duc 34:aa6d3a83dafc 229 }
patrick_duc 34:aa6d3a83dafc 230
patrick_duc 34:aa6d3a83dafc 231 bool readValue(std::vector<misnet::Service*> servicesWithAsynchronousRead) {
patrick_duc 34:aa6d3a83dafc 232 return this->readValue();
patrick_duc 34:aa6d3a83dafc 233 }
lo 32:3bef9b81f639 234 };
lo 32:3bef9b81f639 235
lo 32:3bef9b81f639 236 class bme280_pressure : public Service {
lo 32:3bef9b81f639 237
patrick_duc 34:aa6d3a83dafc 238 public:
lo 32:3bef9b81f639 239 bme280_pressure(
patrick_duc 34:aa6d3a83dafc 240 DEVICE_TYPE type,
patrick_duc 34:aa6d3a83dafc 241 MISNET_CODE misnet_code,
patrick_duc 34:aa6d3a83dafc 242 STATE state,
patrick_duc 34:aa6d3a83dafc 243 ACCESS_TYPE access_type,
patrick_duc 34:aa6d3a83dafc 244 REQUEST_MODE request_mode,
patrick_duc 34:aa6d3a83dafc 245 UP_MODE up_mode,
patrick_duc 34:aa6d3a83dafc 246 ACCESS_PIN access_pins[6],
patrick_duc 34:aa6d3a83dafc 247 uint32_t subsample_rate,
patrick_duc 34:aa6d3a83dafc 248 ACTION action,
patrick_duc 34:aa6d3a83dafc 249 OUTPUT_MODE output_mode,
patrick_duc 34:aa6d3a83dafc 250 string comment,
patrick_duc 34:aa6d3a83dafc 251 bme280_component* parent) :
lo 32:3bef9b81f639 252 Service(type, misnet_code, state, access_type, request_mode,
patrick_duc 34:aa6d3a83dafc 253 up_mode, access_pins, subsample_rate, action, output_mode, comment, parent)
lo 32:3bef9b81f639 254 {
lo 32:3bef9b81f639 255 }
lo 32:3bef9b81f639 256 virtual ~bme280_pressure() {}
lo 32:3bef9b81f639 257
patrick_duc 34:aa6d3a83dafc 258 bool readValue(void) {
patrick_duc 34:aa6d3a83dafc 259 uint32_t press_raw;
patrick_duc 34:aa6d3a83dafc 260 float pressf;
patrick_duc 34:aa6d3a83dafc 261 char cmd[4];
lo 32:3bef9b81f639 262
patrick_duc 34:aa6d3a83dafc 263 cmd[0] = 0xf7; // press_msb
patrick_duc 34:aa6d3a83dafc 264 parent->i2c.write(parent->address, cmd, 1);
patrick_duc 34:aa6d3a83dafc 265 parent->i2c.read(parent->address, &cmd[1], 3);
patrick_duc 34:aa6d3a83dafc 266 // TODO return true if reading result is invalid
patrick_duc 34:aa6d3a83dafc 267 press_raw = (cmd[1] << 12) | (cmd[2] << 4) | (cmd[3] >> 4);
patrick_duc 34:aa6d3a83dafc 268 int32_t var1, var2;
patrick_duc 34:aa6d3a83dafc 269 uint32_t press;
patrick_duc 34:aa6d3a83dafc 270 var1 = (parent->t_fine >> 1) - 64000;
patrick_duc 34:aa6d3a83dafc 271 var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * parent->dig_P6;
patrick_duc 34:aa6d3a83dafc 272 var2 = var2 + ((var1 * parent->dig_P5) << 1);
patrick_duc 34:aa6d3a83dafc 273 var2 = (var2 >> 2) + (parent->dig_P4 << 16);
patrick_duc 34:aa6d3a83dafc 274 var1 = (((parent->dig_P3 * (((var1 >> 2)*(var1 >> 2)) >> 13)) >> 3) + ((parent->dig_P2 * var1) >> 1)) >> 18;
patrick_duc 34:aa6d3a83dafc 275 var1 = ((32768 + var1) * parent->dig_P1) >> 15;
patrick_duc 34:aa6d3a83dafc 276 if (var1 == 0) {
patrick_duc 34:aa6d3a83dafc 277 return 0;
patrick_duc 34:aa6d3a83dafc 278 }
patrick_duc 34:aa6d3a83dafc 279 press = (((1048576 - press_raw) - (var2 >> 12))) * 3125;
patrick_duc 34:aa6d3a83dafc 280 if(press < 0x80000000) {
patrick_duc 34:aa6d3a83dafc 281 press = (press << 1) / var1;
patrick_duc 34:aa6d3a83dafc 282 } else {
patrick_duc 34:aa6d3a83dafc 283 press = (press / var1) * 2;
patrick_duc 34:aa6d3a83dafc 284 }
patrick_duc 34:aa6d3a83dafc 285 var1 = ((int32_t)parent->dig_P9 * ((int32_t)(((press >> 3) * (press >> 3)) >> 13))) >> 12;
patrick_duc 34:aa6d3a83dafc 286 var2 = (((int32_t)(press >> 2)) * (int32_t)parent->dig_P8) >> 13;
patrick_duc 34:aa6d3a83dafc 287 press = (press + ((var1 + var2 + parent->dig_P7) >> 4));
patrick_duc 34:aa6d3a83dafc 288 pressf = (float)press;
patrick_duc 34:aa6d3a83dafc 289 this->getValueAddress().setFloatValue(pressf/100.0f);
patrick_duc 34:aa6d3a83dafc 290 this->savePreviousValue();
patrick_duc 34:aa6d3a83dafc 291 return false;
patrick_duc 34:aa6d3a83dafc 292 }
patrick_duc 34:aa6d3a83dafc 293
patrick_duc 34:aa6d3a83dafc 294 void readValue(std::vector<misnet::Service*> servicesWithAsynchronousRead) {
patrick_duc 34:aa6d3a83dafc 295
patrick_duc 34:aa6d3a83dafc 296 // -----------------------------------------------------------------------
patrick_duc 34:aa6d3a83dafc 297 // On suppose que ce capteur de pression nécessite une lecture asynchrone.
patrick_duc 34:aa6d3a83dafc 298 // C'est juste pour l'exemple bien sur.
patrick_duc 34:aa6d3a83dafc 299 // -----------------------------------------------------------------------
lo 32:3bef9b81f639 300
patrick_duc 34:aa6d3a83dafc 301 // La première chose consiste à placer le pointeur sur ce service dans le vecteur passé en argument.
patrick_duc 34:aa6d3a83dafc 302 // Ceci permettra au controleur de savoir si le service necessitera une lecture asynchrone,
patrick_duc 34:aa6d3a83dafc 303 // et donc il pourra gerer :
patrick_duc 34:aa6d3a83dafc 304 // . l'occurrence d'une commande de lecture asynchrone (TerminalAsyncReadCommand)
patrick_duc 34:aa6d3a83dafc 305 // . le décompte des services encore à lire de manière asynchrone (une fois que le décompte indiquera 0,
patrick_duc 34:aa6d3a83dafc 306 // alors le controleur pourra generer un message radio et l'envoyer a la fonction radio).
patrick_duc 34:aa6d3a83dafc 307 servicesWithAsynchronousRead.push_back(this);
patrick_duc 34:aa6d3a83dafc 308
patrick_duc 34:aa6d3a83dafc 309 // Il faut ensuite armer un timer avec une durée adaptée à ce capteur.
patrick_duc 34:aa6d3a83dafc 310 // Genre utilisation d'un Timeout auquel est attachée une callback, comme pour le composant DS18B20.
patrick_duc 34:aa6d3a83dafc 311 // La callback doit créer une commande TerminalAsyncReadCommand avec comme argument un pointeur vers le service
patrick_duc 34:aa6d3a83dafc 312 // en question, et l'inserer dans la file des commandes a traiter par le controleur.
patrick_duc 34:aa6d3a83dafc 313 // Cette insertion dans la file est accessible au travers de la methode addCommandInQueue() du singleton
patrick_duc 34:aa6d3a83dafc 314 // permettant d'acceder au controleur (pas encore fait, je fais ça demain ou ce qweek-end).
patrick_duc 34:aa6d3a83dafc 315 // La methode readValue() sans argument, celle qui fait la lecture effective, sera
patrick_duc 34:aa6d3a83dafc 316 // invoquee par la methode execute() de la commande TerminalAsyncReadCommand (c'est dans le code
patrick_duc 34:aa6d3a83dafc 317 // du controleur, tu ne le verras pas).
patrick_duc 34:aa6d3a83dafc 318 // Bien entendu, cette execution est faite de maniere parfaitement generique, sans
patrick_duc 34:aa6d3a83dafc 319 // que le controleur ait connaissance de la classe derivee de Service en question, ce qui
patrick_duc 34:aa6d3a83dafc 320 // permet de pouvoir ajouter de nouveaux composants sans impacter le code generique.
patrick_duc 34:aa6d3a83dafc 321 // C'est cette meme mecanique de file de commandes qui permet de gerer les autres evenements asynchrones
patrick_duc 34:aa6d3a83dafc 322 // comme le heartbeat de la plateforme (niveau batterie, etc.) et les IRQ.
patrick_duc 34:aa6d3a83dafc 323 int delay = parent->convertTemperature(false, this_device);
patrick_duc 34:aa6d3a83dafc 324 reader.attach(callback(this, &bme280_component::bme280_pressure::la_callback), delay + 50);
patrick_duc 34:aa6d3a83dafc 325 }
patrick_duc 34:aa6d3a83dafc 326
patrick_duc 34:aa6d3a83dafc 327 void la_callback() {
patrick_duc 34:aa6d3a83dafc 328 // Creer une instance de commande pour traiter la lecture asynchrone.
patrick_duc 34:aa6d3a83dafc 329 Controller::getInstance().addCommandInQueue(new TerminalAsyncReadCommand(this));
patrick_duc 34:aa6d3a83dafc 330
patrick_duc 34:aa6d3a83dafc 331 // Tu noteras que la lecture ne doit pas etre effectuee dans la callback, a la difference de
patrick_duc 34:aa6d3a83dafc 332 // ce qui est fait dans la callback du composant DS18B20, car sinon le controleur ne saura pas
patrick_duc 34:aa6d3a83dafc 333 // quelles valeurs ont ete lues ou pas, et ne saura donc pas quand le message peut etre construit
patrick_duc 34:aa6d3a83dafc 334 // et envoye au module radio.
patrick_duc 34:aa6d3a83dafc 335 // Par ailleurs, c'est tres rapide car il y a peu de traitements, et donc on reste tres peu de temps dans la callback.
patrick_duc 34:aa6d3a83dafc 336
patrick_duc 34:aa6d3a83dafc 337 // Juste pour info, si ça t'intéresse...
patrick_duc 34:aa6d3a83dafc 338 // -------------------------------------
patrick_duc 34:aa6d3a83dafc 339 // A l'issue du traitement de la callback, le controleur sera reveille, il ira lire la file des commandes
patrick_duc 34:aa6d3a83dafc 340 // (file triee par priorite pour ne pas avoir a gerer d'etats, je t'expliquerai de vive voix si tu veux).
patrick_duc 34:aa6d3a83dafc 341 // Une fois cette commande extraite de la file des commandes, sa methode execute() sera invoquee, qui se traduira
patrick_duc 34:aa6d3a83dafc 342 // par l'appel de la methode readValue() - sans argument donc - du service correspondant au pointeur pâsse en argument
patrick_duc 34:aa6d3a83dafc 343 // du constructeur. Ainsi, la lecture effective sera realisee et la valeur placee dans la database. Et bien sur le pointeur
patrick_duc 34:aa6d3a83dafc 344 // sur le service sera retire du vecteur des services avec lecture asnchrone.
patrick_duc 34:aa6d3a83dafc 345 // Quand il n'y aura plus de pointeur sur service dans le vecteur, cela voudra dire que toutes les valeurs auront ete lues,
patrick_duc 34:aa6d3a83dafc 346 // et donc que le message pourra etre construit et envoye au module radio.
patrick_duc 34:aa6d3a83dafc 347 }
patrick_duc 34:aa6d3a83dafc 348
patrick_duc 34:aa6d3a83dafc 349 private:
patrick_duc 34:aa6d3a83dafc 350 Timeout reader;
lo 32:3bef9b81f639 351 };
lo 32:3bef9b81f639 352 };
lo 32:3bef9b81f639 353
lo 32:3bef9b81f639 354 #endif /* BME280_COMPONENT_HPP_ */