Fork of the espurna firmware for `mhsw` switches
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

220 lines
6.3 KiB

6 years ago
  1. // -----------------------------------------------------------------------------
  2. // MHZ19 CO2 sensor
  3. // Based on: https://github.com/nara256/mhz19_uart
  4. // http://www.winsen-sensor.com/d/files/infrared-gas-sensor/mh-z19b-co2-ver1_0.pdf
  5. // Uses SoftwareSerial library
  6. // Copyright (C) 2017-2018 by Xose Pérez <xose dot perez at gmail dot com>
  7. // -----------------------------------------------------------------------------
  8. #if SENSOR_SUPPORT && MHZ19_SUPPORT
  9. #pragma once
  10. #include "Arduino.h"
  11. #include "BaseSensor.h"
  12. #include <SoftwareSerial.h>
  13. #define MHZ19_REQUEST_LEN 8
  14. #define MHZ19_RESPONSE_LEN 9
  15. #define MHZ19_TIMEOUT 1000
  16. #define MHZ19_GETPPM 0x8600
  17. #define MHZ19_ZEROCALIB 0x8700
  18. #define MHZ19_SPANCALIB 0x8800
  19. #define MHZ19_AUTOCALIB_ON 0x79A0
  20. #define MHZ19_AUTOCALIB_OFF 0x7900
  21. class MHZ19Sensor : public BaseSensor {
  22. public:
  23. // ---------------------------------------------------------------------
  24. // Public
  25. // ---------------------------------------------------------------------
  26. MHZ19Sensor(): BaseSensor() {
  27. _count = 1;
  28. _sensor_id = SENSOR_MHZ19_ID;
  29. }
  30. ~MHZ19Sensor() {
  31. if (_serial) delete _serial;
  32. }
  33. // ---------------------------------------------------------------------
  34. void setRX(unsigned char pin_rx) {
  35. if (_pin_rx == pin_rx) return;
  36. _pin_rx = pin_rx;
  37. _dirty = true;
  38. }
  39. void setTX(unsigned char pin_tx) {
  40. if (_pin_tx == pin_tx) return;
  41. _pin_tx = pin_tx;
  42. _dirty = true;
  43. }
  44. // ---------------------------------------------------------------------
  45. unsigned char getRX() {
  46. return _pin_rx;
  47. }
  48. unsigned char getTX() {
  49. return _pin_tx;
  50. }
  51. // ---------------------------------------------------------------------
  52. // Sensor API
  53. // ---------------------------------------------------------------------
  54. // Initialization method, must be idempotent
  55. void begin() {
  56. if (!_dirty) return;
  57. _dirty = false;
  58. if (_serial) delete _serial;
  59. _serial = new SoftwareSerial(_pin_rx, _pin_tx, false, 256);
  60. _serial->begin(9600);
  61. calibrateAuto(false);
  62. }
  63. // Descriptive name of the sensor
  64. String description() {
  65. char buffer[28];
  66. snprintf(buffer, sizeof(buffer), "MHZ19 @ SwSerial(%i,%i)", _pin_rx, _pin_tx);
  67. return String(buffer);
  68. }
  69. // Descriptive name of the slot # index
  70. String slot(unsigned char index) {
  71. return description();
  72. };
  73. // Address of the sensor (it could be the GPIO or I2C address)
  74. String address(unsigned char index) {
  75. char buffer[6];
  76. snprintf(buffer, sizeof(buffer), "%i:%i", _pin_rx, _pin_tx);
  77. return String(buffer);
  78. }
  79. // Type for slot # index
  80. unsigned char type(unsigned char index) {
  81. _error = SENSOR_ERROR_OK;
  82. if (index == 0) return MAGNITUDE_CO2;
  83. _error = SENSOR_ERROR_OUT_OF_RANGE;
  84. return MAGNITUDE_NONE;
  85. }
  86. void pre() {
  87. _read();
  88. }
  89. // Current value for slot # index
  90. double value(unsigned char index) {
  91. _error = SENSOR_ERROR_OK;
  92. if (index == 0) return _co2;
  93. _error = SENSOR_ERROR_OUT_OF_RANGE;
  94. return 0;
  95. }
  96. void calibrateAuto(boolean state){
  97. _write(state ? MHZ19_AUTOCALIB_ON : MHZ19_AUTOCALIB_OFF);
  98. }
  99. void calibrateZero() {
  100. _write(MHZ19_ZEROCALIB);
  101. }
  102. void calibrateSpan(unsigned int ppm) {
  103. if( ppm < 1000 ) return;
  104. unsigned char buffer[MHZ19_REQUEST_LEN] = {0};
  105. buffer[0] = 0xFF;
  106. buffer[1] = 0x01;
  107. buffer[2] = MHZ19_SPANCALIB >> 8;
  108. buffer[3] = ppm >> 8;
  109. buffer[4] = ppm & 0xFF;
  110. _write(buffer);
  111. }
  112. protected:
  113. // ---------------------------------------------------------------------
  114. // Protected
  115. // ---------------------------------------------------------------------
  116. void _write(unsigned char * command) {
  117. _serial->write(command, MHZ19_REQUEST_LEN);
  118. _serial->write(_checksum(command));
  119. _serial->flush();
  120. }
  121. void _write(unsigned int command, unsigned char * response) {
  122. unsigned char buffer[MHZ19_REQUEST_LEN] = {0};
  123. buffer[0] = 0xFF;
  124. buffer[1] = 0x01;
  125. buffer[2] = command >> 8;
  126. buffer[3] = command & 0xFF;
  127. _write(buffer);
  128. if (response != NULL) {
  129. unsigned long start = millis();
  130. while (_serial->available() == 0) {
  131. if (millis() - start > MHZ19_TIMEOUT) {
  132. _error = SENSOR_ERROR_TIMEOUT;
  133. return;
  134. }
  135. yield();
  136. }
  137. _serial->readBytes(response, MHZ19_RESPONSE_LEN);
  138. }
  139. }
  140. void _write(unsigned int command) {
  141. _write(command, NULL);
  142. }
  143. void _read() {
  144. unsigned char buffer[MHZ19_RESPONSE_LEN] = {0};
  145. _write(MHZ19_GETPPM, buffer);
  146. // Check response
  147. if ((buffer[0] == 0xFF)
  148. && (buffer[1] == 0x86)
  149. && (_checksum(buffer) == buffer[MHZ19_RESPONSE_LEN-1])) {
  150. unsigned int value = buffer[2] * 256 + buffer[3];
  151. if (0 <= value && value <= 5000) {
  152. _co2 = value;
  153. _error = SENSOR_ERROR_OK;
  154. } else {
  155. _error = SENSOR_ERROR_OUT_OF_RANGE;
  156. }
  157. }
  158. }
  159. uint8_t _checksum(uint8_t * command) {
  160. uint8_t sum = 0x00;
  161. for (unsigned char i = 1; i < MHZ19_REQUEST_LEN-1; i++) {
  162. sum += command[i];
  163. }
  164. sum = 0xFF - sum + 0x01;
  165. return sum;
  166. }
  167. double _co2 = 0;
  168. unsigned int _pin_rx;
  169. unsigned int _pin_tx;
  170. SoftwareSerial * _serial = NULL;
  171. };
  172. #endif // SENSOR_SUPPORT && MHZ19_SUPPORT