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.

218 lines
6.2 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, 32);
  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(%u,%u)", _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), "%u:%u", _pin_rx, _pin_tx);
  77. return String(buffer);
  78. }
  79. // Type for slot # index
  80. unsigned char type(unsigned char index) {
  81. if (index == 0) return MAGNITUDE_CO2;
  82. return MAGNITUDE_NONE;
  83. }
  84. void pre() {
  85. _read();
  86. }
  87. // Current value for slot # index
  88. double value(unsigned char index) {
  89. if (index == 0) return _co2;
  90. return 0;
  91. }
  92. void calibrateAuto(boolean state){
  93. _write(state ? MHZ19_AUTOCALIB_ON : MHZ19_AUTOCALIB_OFF);
  94. }
  95. void calibrateZero() {
  96. _write(MHZ19_ZEROCALIB);
  97. }
  98. void calibrateSpan(unsigned int ppm) {
  99. if( ppm < 1000 ) return;
  100. unsigned char buffer[MHZ19_REQUEST_LEN] = {0};
  101. buffer[0] = 0xFF;
  102. buffer[1] = 0x01;
  103. buffer[2] = MHZ19_SPANCALIB >> 8;
  104. buffer[3] = ppm >> 8;
  105. buffer[4] = ppm & 0xFF;
  106. _write(buffer);
  107. }
  108. protected:
  109. // ---------------------------------------------------------------------
  110. // Protected
  111. // ---------------------------------------------------------------------
  112. void _write(unsigned char * command) {
  113. _serial->write(command, MHZ19_REQUEST_LEN);
  114. _serial->write(_checksum(command));
  115. _serial->flush();
  116. }
  117. void _write(unsigned int command, unsigned char * response) {
  118. unsigned char buffer[MHZ19_REQUEST_LEN] = {0};
  119. buffer[0] = 0xFF;
  120. buffer[1] = 0x01;
  121. buffer[2] = command >> 8;
  122. buffer[3] = command & 0xFF;
  123. _write(buffer);
  124. if (response != NULL) {
  125. unsigned long start = millis();
  126. while (_serial->available() == 0) {
  127. if (millis() - start > MHZ19_TIMEOUT) {
  128. _error = SENSOR_ERROR_TIMEOUT;
  129. return;
  130. }
  131. yield();
  132. }
  133. _serial->readBytes(response, MHZ19_RESPONSE_LEN);
  134. }
  135. }
  136. void _write(unsigned int command) {
  137. _write(command, NULL);
  138. }
  139. void _read() {
  140. unsigned char buffer[MHZ19_RESPONSE_LEN] = {0};
  141. _write(MHZ19_GETPPM, buffer);
  142. // Check response
  143. if ((buffer[0] == 0xFF)
  144. && (buffer[1] == 0x86)
  145. && (_checksum(buffer) == buffer[MHZ19_RESPONSE_LEN-1])) {
  146. unsigned int value = buffer[2] * 256 + buffer[3];
  147. if (0 <= value && value <= 5000) {
  148. _co2 = value;
  149. _error = SENSOR_ERROR_OK;
  150. } else {
  151. _error = SENSOR_ERROR_OUT_OF_RANGE;
  152. }
  153. } else {
  154. _error = SENSOR_ERROR_CRC;
  155. }
  156. }
  157. uint8_t _checksum(uint8_t * command) {
  158. uint8_t sum = 0x00;
  159. for (unsigned char i = 1; i < MHZ19_REQUEST_LEN-1; i++) {
  160. sum += command[i];
  161. }
  162. sum = 0xFF - sum + 0x01;
  163. return sum;
  164. }
  165. double _co2 = 0;
  166. unsigned int _pin_rx;
  167. unsigned int _pin_tx;
  168. SoftwareSerial * _serial = NULL;
  169. };
  170. #endif // SENSOR_SUPPORT && MHZ19_SUPPORT