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.
349 lines
11 KiB
349 lines
11 KiB
// -----------------------------------------------------------------------------
|
|
// PMS Dust Sensor
|
|
// Uses SoftwareSerial library
|
|
// Contribution by Òscar Rovira López
|
|
// Refine to support PMS5003T/PMS5003ST by Yonsm Guo
|
|
// -----------------------------------------------------------------------------
|
|
|
|
#if SENSOR_SUPPORT && PMSX003_SUPPORT
|
|
|
|
#pragma once
|
|
|
|
#include "Arduino.h"
|
|
#include "BaseSensor.h"
|
|
#include <SoftwareSerial.h>
|
|
|
|
// Generic data
|
|
#define PMS_BAUD_RATE 9600
|
|
|
|
// Type of sensor
|
|
#define PMS_TYPE_X003 0
|
|
#define PMS_TYPE_X003_9 1
|
|
#define PMS_TYPE_5003T 2
|
|
#define PMS_TYPE_5003ST 3
|
|
|
|
// Sensor type specified data
|
|
#define PMS_SLOT_MAX 4
|
|
#define PMS_DATA_MAX 17
|
|
const static struct {
|
|
const char *name;
|
|
unsigned char data_count;
|
|
unsigned char slot_count;
|
|
unsigned char slot_types[PMS_SLOT_MAX];
|
|
} pms_specs[] = {
|
|
{"PMSX003", 13, 3, {MAGNITUDE_PM1dot0, MAGNITUDE_PM2dot5, MAGNITUDE_PM10}},
|
|
{"PMSX003_9", 9, 3, {MAGNITUDE_PM1dot0, MAGNITUDE_PM2dot5, MAGNITUDE_PM10}},
|
|
{"PMS5003T", 13, 3, {MAGNITUDE_PM2dot5, MAGNITUDE_TEMPERATURE, MAGNITUDE_HUMIDITY}},
|
|
{"PMS5003ST", 17, 4, {MAGNITUDE_PM2dot5, MAGNITUDE_TEMPERATURE, MAGNITUDE_HUMIDITY, MAGNITUDE_HCHO}}
|
|
};
|
|
|
|
// [MAGIC][LEN][DATA9|13|17][SUM]
|
|
#define PMS_PACKET_SIZE(data_count) ((data_count + 3) * 2)
|
|
#define PMS_PAYLOAD_SIZE(data_count) ((data_count + 1) * 2)
|
|
|
|
|
|
// PMS sensor utils
|
|
// Command functions copied from: https://github.com/fu-hsi/PMS/blob/master/src/PMS.cpp
|
|
// Reading function is rewrited to support flexible reading for PMS5003T/PMS5003ST
|
|
class PMSX003 {
|
|
|
|
protected:
|
|
Stream *_serial = NULL; // Should initialized by child class
|
|
|
|
public:
|
|
|
|
// Standby mode. For low power consumption and prolong the life of the sensor.
|
|
inline void sleep() {
|
|
uint8_t command[] = { 0x42, 0x4D, 0xE4, 0x00, 0x00, 0x01, 0x73 };
|
|
_serial->write(command, sizeof(command));
|
|
}
|
|
|
|
// Operating mode. Stable data should be got at least 30 seconds after the sensor wakeup from the sleep mode because of the fan's performance.
|
|
inline void wakeUp() {
|
|
uint8_t command[] = { 0x42, 0x4D, 0xE4, 0x00, 0x01, 0x01, 0x74 };
|
|
_serial->write(command, sizeof(command));
|
|
}
|
|
|
|
// Active mode. Default mode after power up. In this mode sensor would send serial data to the host automatically.
|
|
inline void activeMode() {
|
|
uint8_t command[] = { 0x42, 0x4D, 0xE1, 0x00, 0x01, 0x01, 0x71 };
|
|
_serial->write(command, sizeof(command));
|
|
}
|
|
|
|
// Passive mode. In this mode, sensor would send serial data to the host only for request.
|
|
inline void passiveMode() {
|
|
uint8_t command[] = { 0x42, 0x4D, 0xE1, 0x00, 0x00, 0x01, 0x70 };
|
|
_serial->write(command, sizeof(command));
|
|
}
|
|
|
|
// Request read, ONLY needed in Passive Mode!!
|
|
inline void requestRead() {
|
|
uint8_t command[] = { 0x42, 0x4D, 0xE2, 0x00, 0x00, 0x01, 0x71 };
|
|
_serial->write(command, sizeof(command));
|
|
}
|
|
|
|
// Read sensor's data
|
|
bool readData(uint16_t data[], unsigned char data_count) {
|
|
|
|
do {
|
|
|
|
int avail = _serial->available();
|
|
#if SENSOR_DEBUG
|
|
//debugSend("[SENSOR] PMS: Packet available = %d\n", avail);
|
|
#endif
|
|
if (avail < PMS_PACKET_SIZE(data_count)) {
|
|
break;
|
|
}
|
|
|
|
if (_serial->read() == 0x42 && _serial->read() == 0x4D) {
|
|
|
|
uint16_t sum = 0x42 + 0x4D;
|
|
uint16_t size = read16(sum);
|
|
if (size != PMS_PAYLOAD_SIZE(data_count)) {
|
|
#if SENSOR_DEBUG
|
|
debugSend(("[SENSOR] PMS: Payload size: %d != %d.\n"), size, PMS_PAYLOAD_SIZE(data_count));
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
for (int i = 0; i < data_count; i++) {
|
|
data[i] = read16(sum);
|
|
#if SENSOR_DEBUG
|
|
//debugSend(("[SENSOR] PMS: data[%d] = %d\n"), i, data[i]);
|
|
#endif
|
|
}
|
|
|
|
uint16_t checksum = read16();
|
|
if (sum == checksum) {
|
|
return true;
|
|
} else {
|
|
#if SENSOR_DEBUG
|
|
debugSend(("[SENSOR] PMS checksum: %04X != %04X\n"), sum, checksum);
|
|
#endif
|
|
}
|
|
break;
|
|
}
|
|
|
|
} while (true);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
// Read 16-bit
|
|
inline uint16_t read16() {
|
|
return ((uint16_t) _serial->read()) << 8 | _serial->read();
|
|
}
|
|
|
|
// Read 16-bit and calculate checksum
|
|
uint16_t read16(uint16_t &checksum) {
|
|
uint8_t high = _serial->read();
|
|
uint8_t low = _serial->read();
|
|
checksum += high;
|
|
checksum += low;
|
|
return ((uint16_t) high) << 8 | low;
|
|
}
|
|
|
|
};
|
|
|
|
class PMSX003Sensor : public BaseSensor, PMSX003 {
|
|
|
|
public:
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Public
|
|
// ---------------------------------------------------------------------
|
|
|
|
PMSX003Sensor(): BaseSensor() {
|
|
_count = pms_specs[_type].slot_count;
|
|
_sensor_id = SENSOR_PMSX003_ID;
|
|
}
|
|
|
|
~PMSX003Sensor() {
|
|
if (_serial) delete _serial;
|
|
}
|
|
|
|
void setRX(unsigned char pin_rx) {
|
|
if (_pin_rx == pin_rx) return;
|
|
_pin_rx = pin_rx;
|
|
_dirty = true;
|
|
}
|
|
|
|
void setTX(unsigned char pin_tx) {
|
|
if (_pin_tx == pin_tx) return;
|
|
_pin_tx = pin_tx;
|
|
_dirty = true;
|
|
}
|
|
|
|
void setSerial(HardwareSerial * serial) {
|
|
_soft = false;
|
|
_serial = serial;
|
|
_dirty = true;
|
|
}
|
|
|
|
// Should call setType after constructor immediately to enable corresponding slot count
|
|
void setType(unsigned char type) {
|
|
_type = type;
|
|
_count = pms_specs[_type].slot_count;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
unsigned char getRX() {
|
|
return _pin_rx;
|
|
}
|
|
|
|
unsigned char getTX() {
|
|
return _pin_tx;
|
|
}
|
|
|
|
unsigned char getType() {
|
|
return _type;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// Sensor API
|
|
// ---------------------------------------------------------------------
|
|
|
|
// Initialization method, must be idempotent
|
|
void begin() {
|
|
|
|
if (!_dirty) return;
|
|
|
|
if (_soft) {
|
|
if (_serial) delete _serial;
|
|
_serial = new SoftwareSerial(_pin_rx, _pin_tx, false, 64);
|
|
static_cast<SoftwareSerial*>(_serial)->enableIntTx(false);
|
|
}
|
|
|
|
if (_soft) {
|
|
static_cast<SoftwareSerial*>(_serial)->begin(PMS_BAUD_RATE);
|
|
} else {
|
|
static_cast<HardwareSerial*>(_serial)->begin(PMS_BAUD_RATE);
|
|
}
|
|
|
|
passiveMode();
|
|
|
|
_startTime = millis();
|
|
_ready = true;
|
|
_dirty = false;
|
|
}
|
|
|
|
// Descriptive name of the sensor
|
|
String description() {
|
|
char buffer[28];
|
|
if (_soft) {
|
|
snprintf(buffer, sizeof(buffer), "%s @ SwSerial(%u,%u)", pms_specs[_type].name, _pin_rx, _pin_tx);
|
|
} else {
|
|
snprintf(buffer, sizeof(buffer), "%s @ HwSerial", pms_specs[_type].name);
|
|
}
|
|
|
|
return String(buffer);
|
|
}
|
|
|
|
// Descriptive name of the slot # index
|
|
String slot(unsigned char index) {
|
|
char buffer[36] = {0};
|
|
if (_soft) {
|
|
snprintf(buffer, sizeof(buffer), "%d @ %s @ SwSerial(%u,%u)", int(index + 1), pms_specs[_type].name, _pin_rx, _pin_tx);
|
|
} else {
|
|
snprintf(buffer, sizeof(buffer), "%d @ %s @ HwSerial", int(index + 1), pms_specs[_type].name);
|
|
}
|
|
return String(buffer);
|
|
}
|
|
|
|
// Address of the sensor (it could be the GPIO or I2C address)
|
|
String address(unsigned char index) {
|
|
char buffer[6];
|
|
snprintf(buffer, sizeof(buffer), "%u:%u", _pin_rx, _pin_tx);
|
|
return String(buffer);
|
|
}
|
|
|
|
// Type for slot # index
|
|
unsigned char type(unsigned char index) {
|
|
return pms_specs[_type].slot_types[index];
|
|
}
|
|
|
|
void pre() {
|
|
|
|
if (millis() - _startTime < 30000) {
|
|
_error = SENSOR_ERROR_WARM_UP;
|
|
return;
|
|
}
|
|
|
|
_error = SENSOR_ERROR_OK;
|
|
|
|
#if PMS_SMART_SLEEP
|
|
unsigned int readCycle;
|
|
if (_readCount++ > 30) {
|
|
readCycle = _readCount % 30;
|
|
if (readCycle == 0) {
|
|
#if SENSOR_DEBUG
|
|
debugSend("[SENSOR] %s: Wake up: %d\n", pms_specs[_type].name, _readCount);
|
|
#endif
|
|
wakeUp();
|
|
return;
|
|
} else if (readCycle == 1) {
|
|
requestRead();
|
|
} else if (readCycle > 6) {
|
|
return;
|
|
}
|
|
} else {
|
|
readCycle = -1;
|
|
}
|
|
#endif
|
|
|
|
uint16_t data[PMS_DATA_MAX];
|
|
if (readData(data, pms_specs[_type].data_count)) {
|
|
if (_type == PMS_TYPE_5003ST) {
|
|
_slot_values[0] = data[4];
|
|
_slot_values[1] = (double)data[13] / 10;
|
|
_slot_values[2] = (double)data[14] / 10;
|
|
_slot_values[3] = (double)data[12] / 1000;
|
|
} else if (_type == PMS_TYPE_5003T) {
|
|
_slot_values[0] = data[4];
|
|
_slot_values[1] = (double)data[10] / 10;
|
|
_slot_values[2] = (double)data[11] / 10;
|
|
} else {
|
|
_slot_values[0] = data[3];
|
|
_slot_values[1] = data[4];
|
|
_slot_values[2] = data[5];
|
|
}
|
|
}
|
|
|
|
#if PMS_SMART_SLEEP
|
|
if (readCycle == 6) {
|
|
sleep();
|
|
#if SENSOR_DEBUG
|
|
debugSend("[SENSOR] %s: Enter sleep mode: %d\n", pms_specs[_type].name, _readCount);
|
|
#endif
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
requestRead();
|
|
|
|
}
|
|
|
|
// Current value for slot # index
|
|
double value(unsigned char index) {
|
|
return _slot_values[index];
|
|
}
|
|
|
|
protected:
|
|
bool _soft = true;
|
|
unsigned int _pin_rx;
|
|
unsigned int _pin_tx;
|
|
unsigned long _startTime;
|
|
unsigned char _type = PMS_TYPE_X003;
|
|
double _slot_values[PMS_SLOT_MAX] = {0};
|
|
|
|
#if PMS_SMART_SLEEP
|
|
unsigned int _readCount = 0;
|
|
#endif
|
|
|
|
};
|
|
|
|
#endif // SENSOR_SUPPORT && PMSX003_SUPPORT
|