249 lines
7.5 KiB
C++
249 lines
7.5 KiB
C++
/*
|
|
* ATmega controller for MiCS-6814 gas sensor - I2C Adapter
|
|
*
|
|
* Adapted from Firmware for Groove Multichannel Gas Sensor
|
|
* Using ATmega core from:
|
|
* https://raw.githubusercontent.com/carlosefr/atmega/master/package_carlosefr_atmega_index.json
|
|
*
|
|
* Pin mapping:
|
|
* Heater Enable (out): PB0 / Digital 8 (Inverted logic)
|
|
* NH3 resistance (in): PC0 / Analog 0
|
|
* CO resistance (in): PC1 / Analog 1
|
|
* NO2 resistance (in): PC2 / Analog 2
|
|
* SDA: PC4
|
|
* SCL: PC5
|
|
*/
|
|
|
|
#include <Wire.h>
|
|
#include <EEPROM.h>
|
|
|
|
// Pin Constants
|
|
#define HEATER_EN 8
|
|
#define NH3_IN A0
|
|
#define CO_IN A1
|
|
#define NO2_IN A2
|
|
|
|
// I2C Communication (Taken from Groove sensor, hoping to use the same library on client side)
|
|
#define DEFAULT_I2C_ADDR 0x04
|
|
#define CMD_ADC_NH3 1 // NH3 channel
|
|
#define CMD_ADC_CO 2 // CO channel
|
|
#define CMD_ADC_NO2 3 // NO2 channel
|
|
#define CMD_ADC_ALL 4 // All channels
|
|
#define CMD_CHANGE_I2C 5 // I2C address change
|
|
#define CMD_READ_EEPROM 6 // Read stored data from EEPROM as unsigned int
|
|
#define CMD_SET_R0_ADC 7 // Set R0 ADC value
|
|
#define CMD_GET_R0_ADC 8 // Get R0 ADC value
|
|
#define CMD_GET_R0_ADC_DEFAULT 9 // Get factory R0 ADC value
|
|
#define CMD_CONTROL_LED 10 // Control LED (no LED on my board, but Groove supports is, so ... meh!)
|
|
#define CMD_CONTROL_PWR 11 // Heater control
|
|
|
|
// EEPROM Addresses (Match Groove addresses)
|
|
#define EEPROM_INIT_DONE 0
|
|
#define EEPROM_DEFAULT_ADC_NH3 2
|
|
#define EEPROM_DEFAULT_ADC_CO 4
|
|
#define EEPROM_DEFAULT_ADC_NO2 6
|
|
#define EEPROM_ADC_NH3 8
|
|
#define EEPROM_ADC_CO 10
|
|
#define EEPROM_ADC_NO2 12
|
|
#define EEPROM_I2C_ADDR 20
|
|
|
|
|
|
// Runtime storage for data
|
|
uint32_t timer; // Timer value of last update
|
|
uint8_t adcData[6]; // Storage for the current resistance values
|
|
uint8_t i2CCmd; // Current command passed from onReceive to onRequest
|
|
uint8_t i2CData; // Command parameters
|
|
uint8_t i2CResp[6]; // Buffer for I2C response
|
|
|
|
/**
|
|
* EEPROM helper function to write a single uint16_t value
|
|
* to two adjacient eeprom cells.
|
|
* The upper half (MSB) will be written to the given address,
|
|
* the lower half (LSB) will be written to the next address.
|
|
*
|
|
* @param addr
|
|
* The eeprom addr to store the MSB in.
|
|
* The next eeprom address will be used for the LSB.
|
|
* @param value
|
|
* The uint16_t value to store.
|
|
*/
|
|
void eeprom_write16(uint16_t addr, uint16_t value) {
|
|
// Store MSB in address, shift value and mask
|
|
EEPROM.write(addr, (value >> 8) & 0xFF);
|
|
// Store LSB in next address
|
|
EEPROM.write(addr + 1, value & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* EEPROM helper function to read a single uint16_t value
|
|
* from two adjacient eeprom cells.
|
|
*
|
|
* @param addr
|
|
* The eeprom addr to read the MSB from.
|
|
* The the LSB will be read from the next eeprom address.
|
|
* @return The stored uint16_t value.
|
|
*/
|
|
uint16_t eeprom_read16(uint16_t addr) {
|
|
// Read two bytes separately
|
|
uint8_t msb = EEPROM.read(addr);
|
|
uint8_t lsb = EEPROM.read(addr + 1);
|
|
|
|
// Combine through shifting and bitwise-or
|
|
return (msb << 8) | lsb;
|
|
}
|
|
|
|
/**
|
|
* Initialize EEPROM values if not already written
|
|
*/
|
|
void eeprom_init() {
|
|
// Check if data has already been stored in EEPROM
|
|
if (eeprom_read16(EEPROM_INIT_DONE)) {
|
|
eeprom_write16(EEPROM_INIT_DONE, 1126);
|
|
eeprom_write16(EEPROM_I2C_ADDR, DEFAULT_I2C_ADDR);
|
|
eeprom_write16(EEPROM_DEFAULT_ADC_NH3, 123);
|
|
eeprom_write16(EEPROM_DEFAULT_ADC_CO, 123);
|
|
eeprom_write16(EEPROM_DEFAULT_ADC_NO2, 123);
|
|
eeprom_write16(EEPROM_ADC_NH3, 123);
|
|
eeprom_write16(EEPROM_ADC_CO, 123);
|
|
eeprom_write16(EEPROM_ADC_NO2, 123);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read the analog pin repeatedly and return the average value.
|
|
*
|
|
* @param pin
|
|
* The (analog) pin to read from.
|
|
* @return The average value read.
|
|
*/
|
|
uint16_t analogReadAvg(uint8_t pin) {
|
|
// Analog read returns value between 0 and 1024, so at most 10 bits are needed.
|
|
// If we read 64 times we can just store that in 16 bits of a uint16_t.
|
|
|
|
uint16_t sum = 0;
|
|
for (int c = 0; c < 16; ++c) {
|
|
sum += analogRead(pin);
|
|
}
|
|
|
|
// Shift 6 bits right to calculate average (div by 64)
|
|
return (sum >> 4);
|
|
}
|
|
|
|
/**
|
|
* Reads the current values from the sensor
|
|
* and stores the values in the global data.
|
|
*/
|
|
void updateValues() {
|
|
uint16_t adcNH3 = analogReadAvg(NH3_IN);
|
|
uint16_t adcCO = analogReadAvg(CO_IN);
|
|
uint16_t adcNO2 = analogReadAvg(NO2_IN);
|
|
|
|
adcData[0] = adcNH3 >> 8; // MSB of NH3 value
|
|
adcData[1] = adcNH3 & 0xFF; // LSB of NH3 value
|
|
adcData[2] = adcCO >> 8; // MSB of CO value
|
|
adcData[3] = adcCO & 0xFF; // LSB of CO value
|
|
adcData[4] = adcNO2 >> 8; // MSB of NO2 value
|
|
adcData[5] = adcNO2 & 0xFF; // LSB of NO2 value
|
|
}
|
|
|
|
/**
|
|
* Handler for data received from the master.
|
|
*/
|
|
void receiveCallback(uint16_t availData) {
|
|
// Check possible package sizes
|
|
if (availData == 1) {
|
|
// Store command for the requestCallback
|
|
i2CCmd = Wire.read();
|
|
} else if (availData == 2) {
|
|
// Command and one byte of data
|
|
i2CCmd = Wire.read();
|
|
i2CData = Wire.read();
|
|
|
|
// Process direct commands
|
|
if (i2CCmd == CMD_CHANGE_I2C) {
|
|
// Store new address in eeprom and restart Wire library with new address
|
|
eeprom_write16(EEPROM_I2C_ADDR, i2CData);
|
|
Wire.begin(i2CData);
|
|
} else if (i2CCmd == CMD_CONTROL_PWR) {
|
|
if (i2CData) {
|
|
// Turn heater on
|
|
digitalWrite(HEATER_EN, LOW);
|
|
} else {
|
|
// Turn heater off
|
|
digitalWrite(HEATER_EN, HIGH);
|
|
}
|
|
}
|
|
} else if (availData == 7) {
|
|
// Lots of data, only happens for new calilbration data
|
|
i2CCmd = Wire.read();
|
|
uint16_t newADCData[3];
|
|
|
|
// Read all three channels
|
|
for (int i = 0; i < 3; ++i) {
|
|
uint8_t msb = Wire.read();
|
|
uint8_t lsb = Wire.read();
|
|
newADCData[i] = (msb << 8) | lsb;
|
|
}
|
|
|
|
// Check if command valid
|
|
|
|
if (i2CCmd == CMD_SET_R0_ADC) {
|
|
eeprom_write16(EEPROM_ADC_NH3, newADCData[0]);
|
|
eeprom_write16(EEPROM_ADC_CO, newADCData[1]);
|
|
eeprom_write16(EEPROM_ADC_NO2, newADCData[2]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handler for sending data to the master.
|
|
* Requires command to be set by receiveCallback.
|
|
*/
|
|
void requestCallback() {
|
|
switch (i2CCmd) {
|
|
// Resistor data
|
|
case CMD_ADC_NH3:
|
|
Wire.write(&adcData[0], 2);
|
|
break;
|
|
case CMD_ADC_CO:
|
|
Wire.write(&adcData[2], 2);
|
|
break;
|
|
case CMD_ADC_NO2:
|
|
Wire.write(&adcData[4], 2);
|
|
break;
|
|
case CMD_ADC_ALL:
|
|
Wire.write(adcData, 6);
|
|
break;
|
|
|
|
case CMD_READ_EEPROM:
|
|
i2CResp[0] = EEPROM.read(i2CData);
|
|
i2CResp[1] = EEPROM.read(i2CData + 1);
|
|
Wire.write(i2CResp, 2);
|
|
break;
|
|
|
|
case CMD_GET_R0_ADC:
|
|
i2CResp[0] = EEPROM.read(EEPROM_ADC_NH3);
|
|
i2CResp[1] = EEPROM.read(EEPROM_ADC_NH3 + 1);
|
|
i2CResp[2] = EEPROM.read(EEPROM_ADC_CO);
|
|
i2CResp[3] = EEPROM.read(EEPROM_ADC_CO + 1);
|
|
i2CResp[4] = EEPROM.read(EEPROM_ADC_NO2);
|
|
i2CResp[5] = EEPROM.read(EEPROM_ADC_NO2 + 1);
|
|
Wire.write(i2CResp, 6);
|
|
break;
|
|
|
|
case CMD_GET_R0_ADC_DEFAULT:
|
|
i2CResp[0] = EEPROM.read(EEPROM_DEFAULT_ADC_NH3);
|
|
i2CResp[1] = EEPROM.read(EEPROM_DEFAULT_ADC_NH3 + 1);
|
|
i2CResp[2] = EEPROM.read(EEPROM_DEFAULT_ADC_CO);
|
|
i2CResp[3] = EEPROM.read(EEPROM_DEFAULT_ADC_CO + 1);
|
|
i2CResp[4] = EEPROM.read(EEPROM_DEFAULT_ADC_NO2);
|
|
i2CResp[5] = EEPROM.read(EEPROM_DEFAULT_ADC_NO2 + 1);
|
|
Wire.write(i2CResp, 6);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|