mirror of https://github.com/arendst/Tasmota.git
Merge pull request #5434 from Frogmore42/development
preliminary SCD30 support
This commit is contained in:
Theo Arends
GitHub
commit
7488a49ba9
|
|
@ -0,0 +1,653 @@
|
|||
/*
|
||||
# Copyright (c) 2019 Frogmore42
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
#include <Wire.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <twi.h>
|
||||
#include <FrogmoreScd30.h>
|
||||
|
||||
#define COMMAND_SCD30_CONTINUOUS_MEASUREMENT 0x0010
|
||||
#define COMMAND_SCD30_MEASUREMENT_INTERVAL 0x4600
|
||||
#define COMMAND_SCD30_GET_DATA_READY 0x0202
|
||||
#define COMMAND_SCD30_READ_MEASUREMENT 0x0300
|
||||
#define COMMAND_SCD30_CALIBRATION_TYPE 0x5306
|
||||
#define COMMAND_SCD30_FORCED_RECALIBRATION_FACTOR 0x5204
|
||||
#define COMMAND_SCD30_TEMPERATURE_OFFSET 0x5403
|
||||
#define COMMAND_SCD30_ALTITUDE_COMPENSATION 0x5102
|
||||
#define COMMAND_SCD30_SOFT_RESET 0xD304
|
||||
#define COMMAND_SCD30_GET_FW_VERSION 0xD100
|
||||
#define COMMAND_SCD30_STOP_MEASUREMENT 0x0104
|
||||
|
||||
#define SCD30_DATA_REGISTER_BYTES 2
|
||||
#define SCD30_DATA_REGISTER_WITH_CRC 3
|
||||
#define SCD30_MEAS_BYTES 18
|
||||
|
||||
#ifdef SCD30_DEBUG
|
||||
enum LoggingLevels {LOG_LEVEL_NONE, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_DEBUG_MORE, LOG_LEVEL_ALL};
|
||||
char scd30log_data[180];
|
||||
#endif
|
||||
|
||||
void FrogmoreScd30::begin(TwoWire *pWire, uint8_t i2cAddress)
|
||||
{
|
||||
this->i2cAddress = i2cAddress;
|
||||
if (pWire == NULL)
|
||||
{
|
||||
this->pWire = &Wire;
|
||||
}
|
||||
else
|
||||
{
|
||||
this->pWire = pWire;
|
||||
}
|
||||
|
||||
co2NewDataLocation = -1; // indicates there is no data, so the 1st data point needs to fill up the median filter
|
||||
this->pWire->setClockStretchLimit(200000);
|
||||
this->ambientPressure = 0;
|
||||
}
|
||||
|
||||
void FrogmoreScd30::begin(uint8_t i2cAddress)
|
||||
{
|
||||
begin(NULL, i2cAddress);
|
||||
}
|
||||
|
||||
void FrogmoreScd30::begin(TwoWire *pWire)
|
||||
{
|
||||
begin(pWire, SCD30_ADDRESS);
|
||||
}
|
||||
|
||||
void FrogmoreScd30::begin(void)
|
||||
{
|
||||
begin(NULL, SCD30_ADDRESS);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
Function : opt_med5() In : pointer to array of 5 values
|
||||
Out : a uint16_t which is the middle value of the sorted array
|
||||
Job : optimized search of the median of 5 values
|
||||
Notice : found on sci.image.processing cannot go faster unless assumptions are made on the nature of the input signal.
|
||||
---------------------------------------------------------------------------*/
|
||||
#define PIX_SORT(a,b) { if ((a)>(b)) PIX_SWAP((a),(b)); }
|
||||
#define PIX_SWAP(a,b) { uint16_t temp=(a);(a)=(b);(b)=temp; }
|
||||
|
||||
uint16_t opt_med5(uint16_t * p)
|
||||
{
|
||||
PIX_SORT(p[0], p[1]);
|
||||
PIX_SORT(p[3], p[4]);
|
||||
PIX_SORT(p[0], p[3]);
|
||||
PIX_SORT(p[1], p[4]);
|
||||
PIX_SORT(p[1], p[2]);
|
||||
PIX_SORT(p[2], p[3]);
|
||||
PIX_SORT(p[1], p[2]);
|
||||
return(p[2]);
|
||||
}
|
||||
|
||||
// twi_status() attempts to read out any data left that is holding SDA low, so a new transaction can take place
|
||||
// something like (http://www.forward.com.au/pfod/ArduinoProgramming/I2C_ClearBus/index.html)
|
||||
int FrogmoreScd30::clearI2CBus(void)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "clearI2CBus");
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
return (twi_status());
|
||||
}
|
||||
|
||||
#ifdef SCD30_DEBUG
|
||||
void FrogmoreScd30::AddLog(uint8_t loglevel)
|
||||
{
|
||||
if (loglevel <= LOG_LEVEL_INFO)
|
||||
{
|
||||
Serial.printf("%s\r\n", scd30log_data);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
uint8_t FrogmoreScd30::computeCRC8(uint8_t data[], uint8_t len)
|
||||
// Computes the CRC that the SCD30 uses
|
||||
{
|
||||
uint8_t crc = 0xFF; //Init with 0xFF
|
||||
|
||||
for (uint8_t x = 0 ; x < len ; x++)
|
||||
{
|
||||
crc ^= data[x]; // XOR-in the next input byte
|
||||
for (uint8_t i = 0 ; i < 8 ; i++)
|
||||
{
|
||||
if ((crc & 0x80) != 0)
|
||||
crc = (uint8_t)((crc << 1) ^ 0x31);
|
||||
else
|
||||
crc <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
return crc; //No output reflection
|
||||
}
|
||||
|
||||
// Sends stream of bytes to device
|
||||
int FrogmoreScd30::sendBytes(void *pInput, uint8_t len)
|
||||
{
|
||||
uint8_t *pBytes = (uint8_t *) pInput;
|
||||
int result;
|
||||
uint8_t errorBytes = 0; // number of bytes that had an error in transmission
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30SendBytes: data: 0x %02X %02X %02X | 0x %02X %02X %02X | 0x %02X %02X %02X", pBytes[0], pBytes[1], pBytes[2], pBytes[3], pBytes[4], pBytes[5], pBytes[6], pBytes[7], pBytes[8]);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
pWire->beginTransmission(this->i2cAddress);
|
||||
errorBytes = len - (pWire->write(pBytes, len));
|
||||
result = pWire->endTransmission();
|
||||
if (errorBytes || result)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30SendBytes: errorBytes: %d | Wire.end: %d", errorBytes, result);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
}
|
||||
|
||||
result <<= 8; // leave room for error bytes number
|
||||
result |= errorBytes; // low byte has number of bytes that were not written correctly
|
||||
return (result);
|
||||
}
|
||||
|
||||
// Gets a number of bytes from device
|
||||
int FrogmoreScd30::getBytes(void *pOutput, uint8_t len)
|
||||
{
|
||||
uint8_t *pBytes = (uint8_t *) pOutput;
|
||||
uint8_t result;
|
||||
|
||||
result = pWire->requestFrom(this->i2cAddress, len);
|
||||
if (len != result)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30GetBytes: wire request expected %d got: %d", len, result);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (ERROR_SCD30_NOT_ENOUGH_BYTES_ERROR);
|
||||
}
|
||||
|
||||
if (pWire->available())
|
||||
{
|
||||
for (int x = 0; x < len; x++)
|
||||
{
|
||||
pBytes[x] = pWire->read();
|
||||
}
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30GetBytes: data: 0x %02X %02X %02X | 0x %02X %02X %02X | 0x %02X %02X %02X", pBytes[0], pBytes[1], pBytes[2], pBytes[3], pBytes[4], pBytes[5], pBytes[6], pBytes[7], pBytes[8]);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
return (ERROR_SCD30_UNKNOWN_ERROR);
|
||||
}
|
||||
|
||||
//Sends just a command, no arguments, no CRC
|
||||
int FrogmoreScd30::sendCommand(uint16_t command)
|
||||
{
|
||||
uint8_t data[2];
|
||||
data[0] = command >> 8;
|
||||
data[1] = command & 0xFF;
|
||||
int error = sendBytes(data, sizeof(data));
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30SendCommand: Scd30SendBytes failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
//Sends a command along with arguments and CRC
|
||||
int FrogmoreScd30::sendCommandArguments(uint16_t command, uint16_t arguments)
|
||||
{
|
||||
uint8_t data[5];
|
||||
data[0] = command >> 8;
|
||||
data[1] = command & 0xFF;
|
||||
data[2] = arguments >> 8;
|
||||
data[3] = arguments & 0xFF;
|
||||
data[4] = computeCRC8(&data[2], 2); //Calc CRC on the arguments only, not the command
|
||||
int error = sendBytes(data, sizeof(data));
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30SendCommandArguments: Scd30SendBytes failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::get16BitRegCheckCRC(void* pInput, uint16_t *pData)
|
||||
{
|
||||
uint8_t *pBytes = (uint8_t *) pInput;
|
||||
uint8_t expectedCRC = computeCRC8(pBytes, SCD30_DATA_REGISTER_BYTES);
|
||||
if (expectedCRC != pBytes[SCD30_DATA_REGISTER_BYTES])
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30get16BitRegCheckCRC: expected: 0x%02X, but got: 0x%02X", expectedCRC, pBytes[SCD30_DATA_REGISTER_BYTES]);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30get16BitRegCheckCRC: data: 0x%02X, 0x%02X, 0x%02X", pBytes[0], pBytes[1], pBytes[2]);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (ERROR_SCD30_CRC_ERROR);
|
||||
}
|
||||
*pData = (uint16_t) pBytes[0] << 8 | pBytes[1]; // data from SCD30 is Big-Endian
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
// gets 32 bits, (2) 16-bit chunks, and validates the CRCs
|
||||
//
|
||||
int FrogmoreScd30::get32BitRegCheckCRC(void *pInput, float *pData)
|
||||
{
|
||||
uint16_t tempU16High;
|
||||
uint16_t tempU16Low;
|
||||
uint8_t *pBytes = (uint8_t *) pInput;
|
||||
uint32_t rawInt = 0;
|
||||
|
||||
int error = get16BitRegCheckCRC(pBytes, &tempU16High);
|
||||
if (error) {
|
||||
return (error);
|
||||
}
|
||||
|
||||
error = get16BitRegCheckCRC(pBytes + SCD30_DATA_REGISTER_WITH_CRC, &tempU16Low);
|
||||
if (error) {
|
||||
return (error);
|
||||
}
|
||||
|
||||
// data from SCD is Big-Endian
|
||||
rawInt |= tempU16High;
|
||||
rawInt <<= 16;
|
||||
rawInt |= tempU16Low;
|
||||
|
||||
*pData = * (float *) &rawInt;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "get32BitRegCheckCRC: got: tempUs 0x%lX, %lX", tempU16High, tempU16Low);
|
||||
AddLog(LOG_LEVEL_DEBUG);
|
||||
#endif
|
||||
|
||||
if (isnan(*pData) || isinf(*pData))
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "get32BitRegCheckCRC: not a floating point number: rawInt 0x%lX", rawInt);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (ERROR_SCD30_NOT_A_NUMBER_ERROR);
|
||||
}
|
||||
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
//Gets two bytes (and check CRC) from SCD30
|
||||
int FrogmoreScd30::readRegister(uint16_t registerAddress, uint16_t* pData)
|
||||
{
|
||||
int error = sendCommand(registerAddress);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadRegister: SendCommand error: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
delay(1); // the SCD30 uses clock streching to give it time to prepare data, waiting here makes it work
|
||||
uint8_t data[SCD30_DATA_REGISTER_WITH_CRC];
|
||||
error = getBytes(data, sizeof(data));
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadRegister: Scd30GetBytes error: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
uint16 regValue;
|
||||
error = get16BitRegCheckCRC(data, ®Value);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadRegister: Scd30get16BitRegCheckCRC error: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
|
||||
*pData = regValue;
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::softReset(void)
|
||||
{
|
||||
return (sendCommand(COMMAND_SCD30_SOFT_RESET));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getAltitudeCompensation(uint16_t *pHeight_meter)
|
||||
{
|
||||
return (readRegister(COMMAND_SCD30_ALTITUDE_COMPENSATION, pHeight_meter));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getAmbientPressure(uint16_t *pAirPressure_mbar)
|
||||
{
|
||||
*pAirPressure_mbar = ambientPressure;
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getCalibrationType(uint16_t *pIsAuto)
|
||||
{
|
||||
uint16_t value = 0;
|
||||
int error = readRegister(COMMAND_SCD30_CALIBRATION_TYPE, &value);
|
||||
if (!error)
|
||||
{
|
||||
*pIsAuto = value != 0;
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getFirmwareVersion(uint8_t *pMajor, uint8_t *pMinor)
|
||||
{
|
||||
uint16_t value;
|
||||
int error = readRegister(COMMAND_SCD30_GET_FW_VERSION, &value);
|
||||
if (!error)
|
||||
{
|
||||
*pMajor = value >> 8;
|
||||
*pMinor = value & 0xFF;
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getForcedRecalibrationFactor(uint16_t *pCo2_ppm)
|
||||
{
|
||||
return (readRegister(COMMAND_SCD30_FORCED_RECALIBRATION_FACTOR, pCo2_ppm));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getMeasurementInterval(uint16_t *pTime_sec)
|
||||
{
|
||||
return (readRegister(COMMAND_SCD30_MEASUREMENT_INTERVAL, pTime_sec));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getTemperatureOffset(float *pOffset_degC)
|
||||
{
|
||||
uint16_t value;
|
||||
int error = readRegister(COMMAND_SCD30_TEMPERATURE_OFFSET, &value);
|
||||
if (!error)
|
||||
{
|
||||
// result is in centi-degrees, need to convert to degrees
|
||||
*pOffset_degC = (float) value / 100.0;
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::getTemperatureOffset(uint16_t *pOffset_centiDegC)
|
||||
{
|
||||
uint16_t value;
|
||||
int error = readRegister(COMMAND_SCD30_TEMPERATURE_OFFSET, &value);
|
||||
if (!error)
|
||||
{
|
||||
// result is in centi-degrees, need to convert to degrees
|
||||
*pOffset_centiDegC = value;
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setAltitudeCompensation(uint16_t height_meter)
|
||||
{
|
||||
return (sendCommandArguments(COMMAND_SCD30_ALTITUDE_COMPENSATION, height_meter));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setAmbientPressure(uint16_t airPressure_mbar)
|
||||
{
|
||||
ambientPressure = airPressure_mbar;
|
||||
return (beginMeasuring(ambientPressure));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setAutoSelfCalibration(void)
|
||||
{
|
||||
bool isAuto = true;
|
||||
return (setCalibrationType(isAuto));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setCalibrationType(bool isAuto)
|
||||
{
|
||||
bool value = !!isAuto; // using NOT operator twice makes sure value is 0 or 1
|
||||
return (sendCommandArguments(COMMAND_SCD30_CALIBRATION_TYPE, value));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setForcedRecalibrationFactor(uint16_t co2_ppm)
|
||||
{
|
||||
return (sendCommandArguments(COMMAND_SCD30_FORCED_RECALIBRATION_FACTOR, co2_ppm));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setManualCalibration(void)
|
||||
{
|
||||
bool isAuto = false;
|
||||
return (setCalibrationType(isAuto));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setMeasurementInterval(uint16_t time_sec)
|
||||
{
|
||||
if (time_sec < 2) time_sec = 2;
|
||||
if (time_sec > 1800) time_sec = 1800;
|
||||
return (sendCommandArguments(COMMAND_SCD30_MEASUREMENT_INTERVAL, time_sec));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setTemperatureOffset(float offset_degC)
|
||||
{
|
||||
uint16_t offset_centiDegC;
|
||||
if (offset_degC >= 0)
|
||||
{
|
||||
offset_centiDegC = (uint16_t) offset_degC * 100;
|
||||
return (sendCommandArguments(COMMAND_SCD30_TEMPERATURE_OFFSET, offset_centiDegC));
|
||||
}
|
||||
else
|
||||
{
|
||||
return (ERROR_SCD30_INVALID_VALUE);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int FrogmoreScd30::setTemperatureOffset(uint16_t offset_centiDegC)
|
||||
{
|
||||
return (sendCommandArguments(COMMAND_SCD30_TEMPERATURE_OFFSET, offset_centiDegC));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::beginMeasuring(void)
|
||||
{
|
||||
return (beginMeasuring(ambientPressure));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::beginMeasuring(uint16_t airPressure_mbar)
|
||||
{
|
||||
ambientPressure = airPressure_mbar;
|
||||
return(sendCommandArguments(COMMAND_SCD30_CONTINUOUS_MEASUREMENT, ambientPressure));
|
||||
}
|
||||
|
||||
int FrogmoreScd30::isDataAvailable(bool *pIsAvailable)
|
||||
{
|
||||
uint16_t isDataAvailable = false;
|
||||
int error = readRegister(COMMAND_SCD30_GET_DATA_READY, &isDataAvailable);
|
||||
if (!error)
|
||||
{
|
||||
*pIsAvailable = isDataAvailable != 0;
|
||||
}
|
||||
return (error);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::readMeasurement(
|
||||
uint16 *pCO2_ppm,
|
||||
uint16 *pCO2EAvg_ppm,
|
||||
float *pTemperature,
|
||||
float *pHumidity
|
||||
)
|
||||
{
|
||||
bool isAvailable = false;
|
||||
int error = 0;
|
||||
float tempCO2;
|
||||
float tempHumidity;
|
||||
float tempTemperature;
|
||||
|
||||
error = isDataAvailable(&isAvailable);
|
||||
if (error)
|
||||
{
|
||||
return (error);
|
||||
}
|
||||
|
||||
if (!isAvailable)
|
||||
{
|
||||
return (ERROR_SCD30_NO_DATA);
|
||||
}
|
||||
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: have data");
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
|
||||
error = sendCommand(COMMAND_SCD30_READ_MEASUREMENT);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: send command failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
delay(1); // the SCD30 uses clock streching to give it time to prepare data, waiting here makes it work
|
||||
|
||||
uint8_t bytes[SCD30_MEAS_BYTES];
|
||||
// there are (6) 16-bit values, each with a CRC in the measurement data
|
||||
// the chip does not seem to like sending this data, except all at once
|
||||
error = getBytes(bytes, SCD30_MEAS_BYTES);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: Scd30GetBytes command failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: Scd30GetBytes data: 0x %02X %02X %02X | 0x %02X %02X %02X | 0x %02X %02X %02X", bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], bytes[8]);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: Scd30GetBytes data: 0x %02X %02X %02X | 0x %02X %02X %02X | 0x %02X %02X %02X", bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15], bytes[16], bytes[17]);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
|
||||
error = get32BitRegCheckCRC(&bytes[0], &tempCO2);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: Scd30Get32BitsCheckCRC 1st command failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
|
||||
error = get32BitRegCheckCRC(&bytes[6], &tempTemperature);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: Scd30Get32BitsCheckCRC 2nd command failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
|
||||
error = get32BitRegCheckCRC(&bytes[12], &tempHumidity);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: Scd30Get32BitsCheckCRC 3rd command failed: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
|
||||
if (tempCO2 == 0)
|
||||
{
|
||||
return (ERROR_SCD30_CO2_ZERO);
|
||||
}
|
||||
|
||||
if (co2NewDataLocation < 0)
|
||||
{
|
||||
co2EAverage = tempCO2;
|
||||
for (int x = 0; x < SCD30_MEDIAN_FILTER_SIZE; x++)
|
||||
{
|
||||
co2History[x] = tempCO2;
|
||||
co2NewDataLocation = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
co2History[co2NewDataLocation++] = tempCO2;
|
||||
if (co2NewDataLocation >= SCD30_MEDIAN_FILTER_SIZE)
|
||||
{
|
||||
co2NewDataLocation = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: co2History: %ld, %ld, %ld, %ld, %ld", co2History[0], co2History[1], co2History[2], co2History[3], co2History[4]);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
// copy array since the median filter function will re-arrange it
|
||||
uint16_t temp[SCD30_MEDIAN_FILTER_SIZE];
|
||||
for (int x = 0; x < SCD30_MEDIAN_FILTER_SIZE; x++)
|
||||
{
|
||||
temp[x] = co2History[x];
|
||||
}
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: temp: %ld, %ld, %ld, %ld, %ld", temp[0], temp[1], temp[2], temp[3], temp[4]);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
|
||||
*pCO2_ppm = opt_med5(temp);
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(scd30log_data, sizeof(scd30log_data), "Scd30ReadMeasurement: CO2_ppm: %ld", *pCO2_ppm);
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE);
|
||||
#endif
|
||||
if (pCO2EAvg_ppm)
|
||||
{
|
||||
int16_t delta = (int16_t) *pCO2_ppm - (int16_t) co2EAverage;
|
||||
int16_t change = delta / 32;
|
||||
co2EAverage += change;
|
||||
#if 0
|
||||
uint16_t remain = co2EAverage % 5;
|
||||
uint16_t dividend = co2EAverage / 5;
|
||||
uint16_t co2EAReported = dividend * 5;
|
||||
if (remain > 2)
|
||||
{
|
||||
co2EAReported += 5;
|
||||
}
|
||||
*pCO2EAvg_ppm = co2EAReported;
|
||||
#else
|
||||
*pCO2EAvg_ppm = co2EAverage;
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
*pTemperature = tempTemperature;
|
||||
*pHumidity = tempHumidity;
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
int FrogmoreScd30::stopMeasuring(void)
|
||||
{
|
||||
return (sendCommand(COMMAND_SCD30_STOP_MEASUREMENT));
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
# Copyright (c) 2019 Frogmore42
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include "Arduino.h"
|
||||
|
||||
//#define SCD30_DEBUG
|
||||
|
||||
#define SCD30_ADDRESS 0x61
|
||||
#define ERROR_SCD30_NO_ERROR 0
|
||||
#define ERROR_SCD30_NO_DATA 0x80000000
|
||||
#define ERROR_SCD30_CO2_ZERO 0x90000000
|
||||
#define ERROR_SCD30_UNKNOWN_ERROR 0x1000000
|
||||
#define ERROR_SCD30_CRC_ERROR 0x2000000
|
||||
#define ERROR_SCD30_NOT_ENOUGH_BYTES_ERROR 0x3000000
|
||||
#define ERROR_SCD30_NOT_FOUND_ERROR 0x4000000
|
||||
#define ERROR_SCD30_NOT_A_NUMBER_ERROR 0x5000000
|
||||
#define ERROR_SCD30_INVALID_VALUE 0x6000000
|
||||
|
||||
#define SCD30_MEDIAN_FILTER_SIZE 5
|
||||
|
||||
class FrogmoreScd30
|
||||
{
|
||||
public:
|
||||
FrogmoreScd30() {};
|
||||
// Constructors
|
||||
// the SCD30 only lists a single i2c address, so not necesary to specify
|
||||
//
|
||||
void begin(void);
|
||||
void begin(uint8_t _i2cAddress);
|
||||
void begin(TwoWire *pWire);
|
||||
void begin(TwoWire *pWire, uint8_t _i2cAddress);
|
||||
|
||||
int softReset(void);
|
||||
int clearI2CBus(void); // this is a HARD reset of the IC2 bus to restore communication, it will disrupt the bus
|
||||
|
||||
int getAltitudeCompensation(uint16_t *pHeight_meter);
|
||||
int getAmbientPressure(uint16_t *pAirPressure_mbar);
|
||||
int getCalibrationType(uint16_t *pIsAuto);
|
||||
int getFirmwareVersion(uint8_t *pMajor, uint8_t *pMinor);
|
||||
int getForcedRecalibrationFactor(uint16_t *pCo2_ppm);
|
||||
int getMeasurementInterval(uint16_t *pTime_sec);
|
||||
int getTemperatureOffset(float *pOffset_degC);
|
||||
int getTemperatureOffset(uint16_t *pOffset_centiDegC);
|
||||
|
||||
int setAltitudeCompensation(uint16_t height_meter);
|
||||
int setAmbientPressure(uint16_t airPressure_mbar);
|
||||
int setAutoSelfCalibration(void);
|
||||
int setCalibrationType(bool isAuto);
|
||||
int setForcedRecalibrationFactor(uint16_t co2_ppm);
|
||||
int setManualCalibration(void);
|
||||
int setMeasurementInterval(uint16_t time_sec);
|
||||
int setTemperatureOffset(float offset_degC);
|
||||
int setTemperatureOffset(uint16_t offset_centiDegC);
|
||||
|
||||
int beginMeasuring(void);
|
||||
int beginMeasuring(uint16_t airPressure_mbar); // also sets ambient pressure offset in mbar/hPascal
|
||||
int isDataAvailable(bool *pIsAvailable);
|
||||
int readMeasurement(
|
||||
uint16 *pCO2_ppm,
|
||||
uint16 *pCO2EAvg_ppm,
|
||||
float *pTemperature,
|
||||
float *pHumidity
|
||||
);
|
||||
int stopMeasuring(void);
|
||||
|
||||
private:
|
||||
uint8_t i2cAddress;
|
||||
TwoWire *pWire;
|
||||
uint16_t ambientPressure;
|
||||
uint16_t co2AvgExtra;
|
||||
uint16_t co2History[SCD30_MEDIAN_FILTER_SIZE];
|
||||
uint16_t co2EAverage;
|
||||
int8_t co2NewDataLocation; // location to put new CO2 data for median filter
|
||||
|
||||
uint8_t computeCRC8(uint8_t data[], uint8_t len);
|
||||
int sendBytes(void *pInput, uint8_t len);
|
||||
int getBytes(void *pOutput, uint8_t len);
|
||||
int sendCommand(uint16_t command);
|
||||
int sendCommandArguments(uint16_t command, uint16_t arguments);
|
||||
int get16BitRegCheckCRC(void* pInput, uint16_t* pData);
|
||||
int get32BitRegCheckCRC(void* pInput, float* pData);
|
||||
int readRegister(uint16_t registerAddress, uint16_t* pData);
|
||||
#ifdef SCD30_DEBUG
|
||||
void AddLog(uint8_t loglevel);
|
||||
#endif
|
||||
};
|
||||
|
|
@ -568,9 +568,13 @@ const char HTTP_SNS_SEAPRESSURE[] PROGMEM = "%s{s}%s " D_PRESSUREATSEALEVEL "{m}
|
|||
const char HTTP_SNS_ANALOG[] PROGMEM = "%s{s}%s " D_ANALOG_INPUT "%d{m}%d{e}"; // {s} = <tr><th>, {m} = </th><td>, {e} = </td></tr>
|
||||
const char HTTP_SNS_ILLUMINANCE[] PROGMEM = "%s{s}%s " D_ILLUMINANCE "{m}%d " D_UNIT_LUX "{e}"; // {s} = <tr><th>, {m} = </th><td>, {e} = </td></tr>
|
||||
|
||||
#if defined(USE_MHZ19) || defined(USE_SENSEAIR) || defined(USE_AZ7798)
|
||||
#if defined(USE_MHZ19) || defined(USE_SENSEAIR) || defined(USE_AZ7798) || defined(USE_SCD30)
|
||||
const char HTTP_SNS_CO2[] PROGMEM = "%s{s}%s " D_CO2 "{m}%d " D_UNIT_PARTS_PER_MILLION "{e}"; // {s} = <tr><th>, {m} = </th><td>, {e} = </td></tr>
|
||||
#endif // USE_WEBSERVER
|
||||
#endif // USE_MHZ19
|
||||
|
||||
#if defined(USE_SCD30)
|
||||
const char HTTP_SNS_CO2EAVG[] PROGMEM = "%s{s}%s " D_ECO2 "{m}%d " D_UNIT_PARTS_PER_MILLION "{e}"; // {s} = <tr><th>, {m} = </th><td>, {e} = </td></tr>
|
||||
#endif // USE_SCD30
|
||||
|
||||
const char S_MAIN_MENU[] PROGMEM = D_MAIN_MENU;
|
||||
const char S_CONFIGURATION[] PROGMEM = D_CONFIGURATION;
|
||||
|
|
|
|||
|
|
@ -95,6 +95,7 @@ void KNX_CB_Action(message_t const &msg, void *arg);
|
|||
//#define USE_MAX44009 // Enable MAX44009 Ambient Light sensor (I2C addresses 0x4A and 0x4B) (+0k8 code)
|
||||
#define USE_MHZ19 // Add support for MH-Z19 CO2 sensor (+2k code)
|
||||
#define USE_SENSEAIR // Add support for SenseAir K30, K70 and S8 CO2 sensor (+2k3 code)
|
||||
#define USE_SCD30 // Add support for Sensiron SCd30 CO2 sensor (+3k6 code)
|
||||
#ifndef CO2_LOW
|
||||
#define CO2_LOW 800 // Below this CO2 value show green light (needs PWM or WS2812 RG(B) led and enable with SetOption18 1)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -0,0 +1,505 @@
|
|||
/*
|
||||
xdrv_92_scd30.ino - SC30 CO2 sensor support for Sonoff-Tasmota
|
||||
|
||||
Copyright (C) 2019 Frogmore42
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
*/
|
||||
#ifdef USE_I2C
|
||||
#ifdef USE_SCD30
|
||||
|
||||
#define XDRV_92 92
|
||||
#define XSNS_92 92
|
||||
#define SCD30_MAX_MISSED_READS 3
|
||||
#define SONOFF_SCD30_STATE_NO_ERROR 0
|
||||
#define SONOFF_SCD30_STATE_ERROR_DATA_CRC 1
|
||||
#define SONOFF_SCD30_STATE_ERROR_READ_MEAS 2
|
||||
#define SONOFF_SCD30_STATE_ERROR_SOFT_RESET 3
|
||||
#define SONOFF_SCD30_STATE_ERROR_I2C_RESET 4
|
||||
#define SONOFF_SCD30_STATE_ERROR_UNKNOWN 5
|
||||
|
||||
#include "Arduino.h"
|
||||
#include <FrogmoreScd30.h>
|
||||
|
||||
#define D_CMND_SCD30 "SCD30"
|
||||
|
||||
const char S_JSON_SCD30_COMMAND_NVALUE[] PROGMEM = "{\"" D_CMND_SCD30 "%s\":%d}";
|
||||
const char S_JSON_SCD30_COMMAND_NFW_VALUE[] PROGMEM = "{\"" D_CMND_SCD30 "%s\":%d.%d}";
|
||||
const char S_JSON_SCD30_COMMAND[] PROGMEM = "{\"" D_CMND_SCD30 "%s\"}";
|
||||
const char kSCD30_Commands[] PROGMEM = "Alt|Auto|Cal|FW|Int|Pres|TOff";
|
||||
|
||||
/*********************************************************************************************\
|
||||
* enumerationsines
|
||||
\*********************************************************************************************/
|
||||
|
||||
enum SCD30_Commands { // commands useable in console or rules
|
||||
CMND_SCD30_ALTITUDE,
|
||||
CMND_SCD30_AUTOMODE,
|
||||
CMND_SCD30_CALIBRATE,
|
||||
CMND_SCD30_FW,
|
||||
CMND_SCD30_INTERVAL,
|
||||
CMND_SCD30_PRESSURE,
|
||||
CMND_SCD30_TEMPOFFSET
|
||||
};
|
||||
|
||||
|
||||
|
||||
FrogmoreScd30 scd30;
|
||||
|
||||
bool scd30Found = false;
|
||||
bool scd30IsDataValid = false;
|
||||
int scd30ErrorState = SONOFF_SCD30_STATE_NO_ERROR;
|
||||
uint16_t scd30Interval_sec;
|
||||
int scd30Loop_count = 0;
|
||||
int scd30DataNotAvailable_count = 0;
|
||||
int scd30GoodMeas_count = 0;
|
||||
int scd30Reset_count = 0;
|
||||
int scd30CrcError_count = 0;
|
||||
int scd30Co2Zero_count = 0;
|
||||
int i2cReset_count = 0;
|
||||
uint16_t scd30_CO2 = 0;
|
||||
uint16_t scd30_CO2EAvg = 0;
|
||||
float scd30_Humid = 0.0;
|
||||
float scd30_Temp = 0.0;
|
||||
|
||||
bool Scd30Init()
|
||||
{
|
||||
int error;
|
||||
bool i2c_flg = ((pin[GPIO_I2C_SCL] < 99) && (pin[GPIO_I2C_SDA] < 99));
|
||||
if (i2c_flg)
|
||||
{
|
||||
uint8_t major = 0;
|
||||
uint8_t minor = 0;
|
||||
uint16_t interval_sec;
|
||||
scd30.begin();
|
||||
error = scd30.getFirmwareVersion(&major, &minor);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: did not find an SCD30: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_DEBUG);
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: found an SCD30: FW v%d.%d", major, minor);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
}
|
||||
|
||||
error = scd30.getMeasurementInterval(&scd30Interval_sec);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: error getMeasurementInterval: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
error = scd30.beginMeasuring();
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "Error: Scd30BeginMeasuring: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// gets data from the sensor every 3 seconds or so to give the sensor time to gather new data
|
||||
int Scd30Update()
|
||||
{
|
||||
int error = 0;
|
||||
int16_t delta = 0;
|
||||
scd30Loop_count++;
|
||||
|
||||
if (!scd30Found)
|
||||
{
|
||||
scd30Found = Scd30Init();
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "Scd30Update: found: %d ", scd30Found);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
if (!scd30Found)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "Scd30Update: found: %d ", scd30Found);
|
||||
AddLog(LOG_LEVEL_INFO);
|
||||
#endif
|
||||
return (ERROR_SCD30_NOT_FOUND_ERROR);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (scd30Loop_count > (scd30Interval_sec - 1))
|
||||
{
|
||||
switch (scd30ErrorState)
|
||||
{
|
||||
case SONOFF_SCD30_STATE_NO_ERROR:
|
||||
{
|
||||
error = scd30.readMeasurement(&scd30_CO2, &scd30_CO2EAvg, &scd30_Temp, &scd30_Humid);
|
||||
switch (error)
|
||||
{
|
||||
case ERROR_SCD30_NO_ERROR:
|
||||
scd30Loop_count = 0;
|
||||
scd30IsDataValid = true;
|
||||
scd30GoodMeas_count++;
|
||||
break;
|
||||
|
||||
case ERROR_SCD30_NO_DATA:
|
||||
scd30DataNotAvailable_count++;
|
||||
break;
|
||||
|
||||
case ERROR_SCD30_CRC_ERROR:
|
||||
scd30ErrorState = SONOFF_SCD30_STATE_ERROR_DATA_CRC;
|
||||
scd30CrcError_count++;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: CRC error, CRC error: %ld, CO2 zero: %ld, good: %ld, no data: %ld, sc30_reset: %ld, i2c_reset: %ld", scd30CrcError_count, scd30Co2Zero_count, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
break;
|
||||
|
||||
case ERROR_SCD30_CO2_ZERO:
|
||||
scd30Co2Zero_count++;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: CO2 zero, CRC error: %ld, CO2 zero: %ld, good: %ld, no data: %ld, sc30_reset: %ld, i2c_reset: %ld", scd30CrcError_count, scd30Co2Zero_count, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
break;
|
||||
|
||||
default:
|
||||
{
|
||||
scd30ErrorState = SONOFF_SCD30_STATE_ERROR_READ_MEAS;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: Update: ReadMeasurement error: 0x%lX, counter: %ld", error, scd30Loop_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
return (error);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case SONOFF_SCD30_STATE_ERROR_DATA_CRC:
|
||||
{
|
||||
//scd30IsDataValid = false;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld", scd30ErrorState, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: got CRC error, try again, counter: %ld", scd30Loop_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
scd30ErrorState = ERROR_SCD30_NO_ERROR;
|
||||
}
|
||||
break;
|
||||
|
||||
case SONOFF_SCD30_STATE_ERROR_READ_MEAS:
|
||||
{
|
||||
//scd30IsDataValid = false;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld", scd30ErrorState, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: not answering, sending soft reset, counter: %ld", scd30Loop_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
scd30Reset_count++;
|
||||
error = scd30.softReset();
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: resetting got error: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
error >>= 8;
|
||||
if (error == 4)
|
||||
{
|
||||
scd30ErrorState = SONOFF_SCD30_STATE_ERROR_SOFT_RESET;
|
||||
}
|
||||
else
|
||||
{
|
||||
scd30ErrorState = SONOFF_SCD30_STATE_ERROR_UNKNOWN;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
scd30ErrorState = ERROR_SCD30_NO_ERROR;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case SONOFF_SCD30_STATE_ERROR_SOFT_RESET:
|
||||
{
|
||||
//scd30IsDataValid = false;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: in error state: %d, good: %ld, no data: %ld, sc30 reset: %ld, i2c reset: %ld", scd30ErrorState, scd30GoodMeas_count, scd30DataNotAvailable_count, scd30Reset_count, i2cReset_count);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: clearing i2c bus");
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
i2cReset_count++;
|
||||
error = scd30.clearI2CBus();
|
||||
if (error)
|
||||
{
|
||||
scd30ErrorState = SONOFF_SCD30_STATE_ERROR_I2C_RESET;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: error clearing i2c bus: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
scd30ErrorState = ERROR_SCD30_NO_ERROR;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
{
|
||||
//scd30IsDataValid = false;
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: unknown error state: 0x%lX", scd30ErrorState);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
scd30ErrorState = SONOFF_SCD30_STATE_ERROR_SOFT_RESET; // try again
|
||||
}
|
||||
}
|
||||
|
||||
if (scd30Loop_count > (SCD30_MAX_MISSED_READS * scd30Interval_sec))
|
||||
{
|
||||
scd30IsDataValid = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return (ERROR_SCD30_NO_ERROR);
|
||||
}
|
||||
|
||||
|
||||
int Scd30GetCommand(int command_code, uint16_t *pvalue)
|
||||
{
|
||||
switch (command_code)
|
||||
{
|
||||
case CMND_SCD30_ALTITUDE:
|
||||
return scd30.getAltitudeCompensation(pvalue);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_AUTOMODE:
|
||||
return scd30.getCalibrationType(pvalue);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_CALIBRATE:
|
||||
return scd30.getForcedRecalibrationFactor(pvalue);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_INTERVAL:
|
||||
return scd30.getMeasurementInterval(pvalue);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_PRESSURE:
|
||||
return scd30.getAmbientPressure(pvalue);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_TEMPOFFSET:
|
||||
return scd30.getTemperatureOffset(pvalue);
|
||||
break;
|
||||
|
||||
default:
|
||||
// else for Unknown command
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int Scd30SetCommand(int command_code, uint16_t value)
|
||||
{
|
||||
switch (command_code)
|
||||
{
|
||||
case CMND_SCD30_ALTITUDE:
|
||||
return scd30.setAltitudeCompensation(value);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_AUTOMODE:
|
||||
return scd30.setCalibrationType(value);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_CALIBRATE:
|
||||
return scd30.setForcedRecalibrationFactor(value);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_INTERVAL:
|
||||
{
|
||||
int error = scd30.setMeasurementInterval(value);
|
||||
if (!error)
|
||||
{
|
||||
scd30Interval_sec = value;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
break;
|
||||
|
||||
case CMND_SCD30_PRESSURE:
|
||||
return scd30.setAmbientPressure(value);
|
||||
break;
|
||||
|
||||
case CMND_SCD30_TEMPOFFSET:
|
||||
return scd30.setTemperatureOffset(value);
|
||||
break;
|
||||
|
||||
default:
|
||||
// else for Unknown command
|
||||
break;
|
||||
}
|
||||
}
|
||||
/*********************************************************************************************\
|
||||
* Command Sensor92
|
||||
\*********************************************************************************************/
|
||||
|
||||
bool Scd30CommandSensor()
|
||||
{
|
||||
char command[CMDSZ];
|
||||
bool serviced = true;
|
||||
uint8_t prefix_len = strlen(D_CMND_SCD30);
|
||||
|
||||
if (!strncasecmp_P(XdrvMailbox.topic, PSTR(D_CMND_SCD30), prefix_len)) { // prefix
|
||||
int command_code = GetCommandCode(command, sizeof(command), XdrvMailbox.topic + prefix_len, kSCD30_Commands);
|
||||
|
||||
switch (command_code) {
|
||||
case CMND_SCD30_ALTITUDE:
|
||||
case CMND_SCD30_AUTOMODE:
|
||||
case CMND_SCD30_CALIBRATE:
|
||||
case CMND_SCD30_INTERVAL:
|
||||
case CMND_SCD30_PRESSURE:
|
||||
case CMND_SCD30_TEMPOFFSET:
|
||||
{
|
||||
uint16_t value = 0;
|
||||
if (XdrvMailbox.data_len > 0)
|
||||
{
|
||||
value = XdrvMailbox.payload16;
|
||||
Scd30SetCommand(command_code, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
Scd30GetCommand(command_code, &value);
|
||||
}
|
||||
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_SCD30_COMMAND_NVALUE, command, value);
|
||||
}
|
||||
break;
|
||||
|
||||
case CMND_SCD30_FW:
|
||||
{
|
||||
uint8_t major = 0;
|
||||
uint8_t minor = 0;
|
||||
int error;
|
||||
error = scd30.getFirmwareVersion(&major, &minor);
|
||||
if (error)
|
||||
{
|
||||
#ifdef SCD30_DEBUG
|
||||
snprintf_P(log_data, sizeof(log_data), "SCD30: error getting FW version: 0x%lX", error);
|
||||
AddLog(LOG_LEVEL_ERROR);
|
||||
#endif
|
||||
serviced = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), S_JSON_SCD30_COMMAND_NFW_VALUE, command, major, minor);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
// else for Unknown command
|
||||
serviced = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return serviced;
|
||||
}
|
||||
|
||||
void Scd30Show(bool json)
|
||||
{
|
||||
char humidity[10];
|
||||
char temperature[10];
|
||||
|
||||
if (scd30Found && scd30IsDataValid)
|
||||
{
|
||||
dtostrfd(scd30_Humid, Settings.flag2.humidity_resolution, humidity);
|
||||
dtostrfd(ConvertTemp(scd30_Temp), Settings.flag2.temperature_resolution, temperature);
|
||||
if (json) {
|
||||
//snprintf_P(mqtt_data, sizeof(mqtt_data), PSTR("%s,\"SCD30\":{\"" D_JSON_CO2 "\":%d,\"" D_JSON_TEMPERATURE "\":%s,\"" D_JSON_HUMIDITY "\":%s}"), mqtt_data, scd30_CO2, temperature, humidity);
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), PSTR("%s,\"SCD30\":{\"" D_JSON_CO2 "\":%d,\"" D_JSON_ECO2 "\":%d,\"" D_JSON_TEMPERATURE "\":%s,\"" D_JSON_HUMIDITY "\":%s}"), mqtt_data, scd30_CO2, scd30_CO2EAvg, temperature, humidity);
|
||||
#ifdef USE_DOMOTICZ
|
||||
if (0 == tele_period) DomoticzSensor(DZ_AIRQUALITY, scd30_CO2);
|
||||
#endif // USE_DOMOTICZ
|
||||
#ifdef USE_WEBSERVER
|
||||
} else {
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), HTTP_SNS_CO2EAVG, mqtt_data, "SCD30", scd30_CO2EAvg);
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), HTTP_SNS_CO2, mqtt_data, "SCD30", scd30_CO2);
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), HTTP_SNS_TEMP, mqtt_data, "SCD30", temperature, TempUnit());
|
||||
snprintf_P(mqtt_data, sizeof(mqtt_data), HTTP_SNS_HUM, mqtt_data, "SCD30", humidity);
|
||||
#endif // USE_WEBSERVER
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*********************************************************************************************\
|
||||
* Interface
|
||||
\*********************************************************************************************/
|
||||
|
||||
bool Xdrv92(byte function)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
if (i2c_flg) {
|
||||
switch (function) {
|
||||
case FUNC_COMMAND:
|
||||
result = Scd30CommandSensor();
|
||||
break;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool Xsns92(byte function)
|
||||
{
|
||||
bool result = false;
|
||||
|
||||
if (i2c_flg) {
|
||||
switch (function) {
|
||||
case FUNC_EVERY_SECOND:
|
||||
Scd30Update();
|
||||
break;
|
||||
case FUNC_JSON_APPEND:
|
||||
Scd30Show(1);
|
||||
break;
|
||||
#ifdef USE_WEBSERVER
|
||||
case FUNC_WEB_APPEND:
|
||||
Scd30Show(0);
|
||||
break;
|
||||
#endif // USE_WEBSERVER
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif // USE_SCD30
|
||||
#endif // USE_I2C
|
||||
Loading…
Reference in New Issue