forked from airgradienthq/arduino
502 lines
12 KiB
C++
502 lines
12 KiB
C++
#include "BoardDef.h"
|
|
#if defined(ESP32)
|
|
#include "esp32-hal-log.h"
|
|
#endif
|
|
|
|
const BoardDef bsps[_BOARD_MAX] = {
|
|
/** DIY_BASIC */
|
|
[DIY_BASIC] =
|
|
{
|
|
.SenseAirS8 =
|
|
{
|
|
.uart_tx_pin = 2,
|
|
.uart_rx_pin = 0,
|
|
#if defined(ESP8266)
|
|
.supported = true,
|
|
#else
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.Pms5003 =
|
|
{
|
|
.uart_tx_pin = 14,
|
|
.uart_rx_pin = 12,
|
|
#if defined(ESP8266)
|
|
.supported = true,
|
|
#else
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.I2C =
|
|
{
|
|
.sda_pin = 4,
|
|
.scl_pin = 5,
|
|
#if defined(ESP8266)
|
|
.supported = true,
|
|
#else
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.SW =
|
|
{
|
|
.pin = -1, /** Not supported */
|
|
.activeLevel = 0, /** Don't care */
|
|
.supported = false, /** Not supported */
|
|
},
|
|
.LED =
|
|
{
|
|
.pin = -1,
|
|
.rgbNum = 0,
|
|
.onState = 0,
|
|
.supported = false,
|
|
.rgbSupported = false,
|
|
},
|
|
.OLED =
|
|
{
|
|
#if defined(ESP8266)
|
|
.width = 64,
|
|
.height = 48,
|
|
.addr = 0x3C,
|
|
.supported = true,
|
|
#else
|
|
.width = 0,
|
|
.height = 0,
|
|
.addr = 0,
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.WDG =
|
|
{
|
|
.resetPin = -1,
|
|
.supported = false,
|
|
},
|
|
.name = "DIY_BASIC",
|
|
},
|
|
/** DIY_PRO_INDOOR_V4_2 */
|
|
[DIY_PRO_INDOOR_V4_2] =
|
|
{
|
|
.SenseAirS8 =
|
|
{
|
|
.uart_tx_pin = 2,
|
|
.uart_rx_pin = 0,
|
|
#if defined(ESP8266)
|
|
.supported = true,
|
|
#else
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.Pms5003 =
|
|
{
|
|
.uart_tx_pin = 14,
|
|
.uart_rx_pin = 12,
|
|
#if defined(ESP8266)
|
|
.supported = true,
|
|
#else
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.I2C =
|
|
{
|
|
.sda_pin = 4,
|
|
.scl_pin = 5,
|
|
#if defined(ESP8266)
|
|
.supported = true,
|
|
#else
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.SW =
|
|
{
|
|
#if defined(ESP8266)
|
|
.pin = 13, /** D7 */
|
|
.activeLevel = 0,
|
|
.supported = true,
|
|
#else
|
|
.pin = -1,
|
|
.activeLevel = 1,
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.LED =
|
|
{
|
|
.pin = -1,
|
|
.rgbNum = 0,
|
|
.onState = 0,
|
|
.supported = false,
|
|
.rgbSupported = false,
|
|
},
|
|
.OLED =
|
|
{
|
|
#if defined(ESP8266)
|
|
.width = 128,
|
|
.height = 64,
|
|
.addr = 0x3C,
|
|
.supported = true,
|
|
#else
|
|
.width = 0,
|
|
.height = 0,
|
|
.addr = 0,
|
|
.supported = false,
|
|
#endif
|
|
},
|
|
.WDG =
|
|
{
|
|
.resetPin = -1,
|
|
.supported = false,
|
|
},
|
|
.name = "DIY_PRO_INDOOR_V4_2",
|
|
},
|
|
/** ONE_INDOOR */
|
|
[ONE_INDOOR] =
|
|
{
|
|
.SenseAirS8 =
|
|
{
|
|
.uart_tx_pin = 1,
|
|
.uart_rx_pin = 0,
|
|
#if defined(ESP8266)
|
|
.supported = false,
|
|
#else
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
/** Use UART0 don't use define pin number */
|
|
.Pms5003 =
|
|
{
|
|
.uart_tx_pin = -1,
|
|
.uart_rx_pin = -1,
|
|
#if defined(ESP8266)
|
|
.supported = false,
|
|
#else
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.I2C =
|
|
{
|
|
.sda_pin = 7,
|
|
.scl_pin = 6,
|
|
#if defined(ESP8266)
|
|
.supported = false,
|
|
#else
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.SW =
|
|
{
|
|
#if defined(ESP8266)
|
|
.pin = -1,
|
|
.activeLevel = 1,
|
|
.supported = false,
|
|
#else
|
|
.pin = 9,
|
|
.activeLevel = 0,
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.LED =
|
|
{
|
|
#if defined(ESP8266)
|
|
.pin = -1,
|
|
.rgbNum = 0,
|
|
.onState = 0,
|
|
.supported = false,
|
|
.rgbSupported = false,
|
|
#else
|
|
.pin = 10,
|
|
.rgbNum = 11,
|
|
.onState = 1,
|
|
.supported = true,
|
|
.rgbSupported = true,
|
|
#endif
|
|
},
|
|
.OLED =
|
|
{
|
|
#if defined(ESP8266)
|
|
.width = 0,
|
|
.height = 0,
|
|
.addr = 0,
|
|
.supported = false,
|
|
#else
|
|
.width = 128,
|
|
.height = 64,
|
|
.addr = 0x3C,
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.WDG =
|
|
{
|
|
#if defined(ESP8266)
|
|
.resetPin = -1,
|
|
.supported = false,
|
|
#else
|
|
.resetPin = 2,
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.name = "ONE_INDOOR",
|
|
},
|
|
/** OPEN_AIR_OUTDOOR */
|
|
[OPEN_AIR_OUTDOOR] = {
|
|
.SenseAirS8 =
|
|
{
|
|
.uart_tx_pin = 1,
|
|
.uart_rx_pin = 0,
|
|
#if defined(ESP8266)
|
|
.supported = false,
|
|
#else
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
/** Use UART0 don't use define pin number */
|
|
.Pms5003 =
|
|
{
|
|
.uart_tx_pin = -1,
|
|
.uart_rx_pin = -1,
|
|
#if defined(ESP8266)
|
|
.supported = false,
|
|
#else
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.I2C =
|
|
{
|
|
.sda_pin = 7,
|
|
.scl_pin = 6,
|
|
#if defined(ESP8266)
|
|
.supported = false,
|
|
#else
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.SW =
|
|
{
|
|
#if defined(ESP8266)
|
|
.pin = -1,
|
|
.activeLevel = 1,
|
|
.supported = false,
|
|
#else
|
|
.pin = 9,
|
|
.activeLevel = 0,
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.LED =
|
|
{
|
|
#if defined(ESP8266)
|
|
.pin = -1,
|
|
.rgbNum = 0,
|
|
.onState = 0,
|
|
.supported = false,
|
|
.rgbSupported = false,
|
|
#else
|
|
.pin = 10,
|
|
.rgbNum = 0,
|
|
.onState = 1,
|
|
.supported = true,
|
|
.rgbSupported = false,
|
|
#endif
|
|
},
|
|
.OLED =
|
|
{
|
|
#if defined(ESP8266)
|
|
.width = 0,
|
|
.height = 0,
|
|
.addr = 0,
|
|
.supported = false,
|
|
#else
|
|
.width = 128,
|
|
.height = 64,
|
|
.addr = 0x3C,
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.WDG =
|
|
{
|
|
#if defined(ESP8266)
|
|
.resetPin = -1,
|
|
.supported = false,
|
|
#else
|
|
.resetPin = 2,
|
|
.supported = true,
|
|
#endif
|
|
},
|
|
.name = "OPEN_AIR_OUTDOOR",
|
|
}};
|
|
|
|
/**
|
|
* @brief Get Board Support Package
|
|
*
|
|
* @param def Board define @ref BoardType
|
|
* @return const BoardDef*
|
|
*/
|
|
const BoardDef *getBoardDef(BoardType def) {
|
|
if (def >= _BOARD_MAX) {
|
|
return NULL;
|
|
}
|
|
return &bsps[def];
|
|
}
|
|
|
|
#if defined(ESP8266)
|
|
#define bspPrintf(c, ...) \
|
|
if (_debug != nullptr) { \
|
|
_debug->printf("[BSP] " c "\r\n", ##__VA_ARGS__); \
|
|
}
|
|
#else
|
|
#define bspPrintf(c, ...) log_i(c, ##__VA_ARGS__)
|
|
#endif
|
|
|
|
/**
|
|
* @brief Print list of support Board and sensor
|
|
*
|
|
* @param _debug Serial debug
|
|
*/
|
|
void printBoardDef(Stream *_debug) {
|
|
#if defined(ESP8266)
|
|
if (_debug == NULL) {
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
for (int i = 0; i < _BOARD_MAX; i++) {
|
|
bspPrintf("Board name: %s", bsps[i].name);
|
|
bspPrintf("\tSensor CO2 S8:");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].SenseAirS8.supported);
|
|
if (bsps[i].SenseAirS8.supported) {
|
|
bspPrintf("\t\tUART Tx: %d", bsps[i].SenseAirS8.uart_tx_pin);
|
|
bspPrintf("\t\tUART Rx: %d", bsps[i].SenseAirS8.uart_rx_pin);
|
|
}
|
|
|
|
bspPrintf("\tSensor PMS5003:");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].Pms5003.supported);
|
|
if (bsps[i].Pms5003.supported) {
|
|
bspPrintf("\t\tUART Tx: %d", bsps[i].Pms5003.uart_tx_pin);
|
|
bspPrintf("\t\tUART Rx: %d", bsps[i].Pms5003.uart_rx_pin);
|
|
}
|
|
|
|
bspPrintf("\tI2C");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].I2C.supported);
|
|
if (bsps[i].I2C.supported) {
|
|
bspPrintf("\t\tI2C SCL: %d", bsps[i].I2C.scl_pin);
|
|
bspPrintf("\t\tI2C SDA: %d", bsps[i].I2C.sda_pin);
|
|
}
|
|
|
|
bspPrintf("\tSwitch");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].SW.supported);
|
|
if (bsps[i].SW.supported) {
|
|
bspPrintf("\t\tPin : %d", bsps[i].SW.pin);
|
|
bspPrintf("\t\tActive Level: %d", bsps[i].SW.activeLevel);
|
|
}
|
|
|
|
bspPrintf("\tLED");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].LED.supported);
|
|
if (bsps[i].LED.supported) {
|
|
bspPrintf("\t\tPin : %d", bsps[i].LED.pin);
|
|
bspPrintf("\t\tRGB : %d", bsps[i].LED.rgbSupported);
|
|
if (bsps[i].LED.rgbSupported) {
|
|
bspPrintf("\t\tNumber of RGB: %d", bsps[i].LED.rgbNum);
|
|
} else {
|
|
bspPrintf("\t\tLED state ON: %d (Single LED)", bsps[i].LED.onState);
|
|
}
|
|
}
|
|
|
|
bspPrintf("\tOLED");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].OLED.supported);
|
|
if (bsps[i].OLED.supported) {
|
|
bspPrintf("\t\tWidth : %d", bsps[i].OLED.width);
|
|
bspPrintf("\t\tHeigth : %d", bsps[i].OLED.height);
|
|
bspPrintf("\t\tI2C Addr: %d", bsps[i].OLED.addr);
|
|
}
|
|
|
|
bspPrintf("\tWatchDog");
|
|
bspPrintf("\t\tSupported: %d", bsps[i].WDG.supported);
|
|
if (bsps[i].OLED.supported) {
|
|
bspPrintf("\t\tReset Pin: %d", bsps[i].WDG.resetPin);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool getBoardDef_I2C_Supported(const BoardDef *bsp) {
|
|
if (bsp == nullptr) {
|
|
return false;
|
|
}
|
|
return bsp->I2C.supported;
|
|
}
|
|
|
|
int getBoardDef_I2C_SDA(const BoardDef *bsp) {
|
|
if ((bsp == nullptr) || (bsp->I2C.supported == false)) {
|
|
return -1;
|
|
}
|
|
return bsp->I2C.sda_pin;
|
|
}
|
|
|
|
int getBoardDef_I2C_SCL(const BoardDef *bsp) {
|
|
if ((bsp == nullptr) || (bsp->I2C.supported == false)) {
|
|
return -1;
|
|
}
|
|
return bsp->I2C.scl_pin;
|
|
}
|
|
|
|
bool getBoardDef_SW_Supported(const BoardDef *bsp) {
|
|
if (bsp == nullptr) {
|
|
return false;
|
|
}
|
|
return bsp->SW.supported;
|
|
}
|
|
|
|
int getBoardDef_SW_Pin(const BoardDef *bsp) {
|
|
if ((bsp == nullptr) || (bsp->SW.supported == false)) {
|
|
return -1;
|
|
}
|
|
return bsp->SW.supported;
|
|
}
|
|
|
|
int getBoardDef_SW_ActiveLevel(const BoardDef *bsp) {
|
|
if (bsp == nullptr) {
|
|
return 0;
|
|
}
|
|
return bsp->SW.activeLevel;
|
|
}
|
|
|
|
void AirGradientBspWdgInit(const BoardDef *bsp) {
|
|
if (bsp == nullptr) {
|
|
return;
|
|
}
|
|
if (bsp->WDG.supported) {
|
|
pinMode(bsp->WDG.resetPin, OUTPUT);
|
|
digitalWrite(bsp->WDG.resetPin, LOW);
|
|
delay(25); // Delay 25ms
|
|
digitalWrite(bsp->WDG.resetPin, HIGH);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Begin reset external watchdog. Must call @ref AirGradientBspWdgFeedEnd
|
|
* after 20 ms
|
|
*
|
|
* @param bsp
|
|
*/
|
|
void AirGradientBspWdgFeedBegin(const BoardDef *bsp) {
|
|
if (bsp == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (bsp->WDG.supported) {
|
|
digitalWrite(bsp->WDG.resetPin, HIGH);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Call this function to finish watchdog feed after call @ref
|
|
* AirGradientBspWdgFeedBegin 25 ms
|
|
*
|
|
* @param bsp
|
|
*/
|
|
void AirGradientBspWdgFeedEnd(const BoardDef *bsp) {
|
|
if (bsp == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (bsp->WDG.supported) {
|
|
digitalWrite(bsp->WDG.resetPin, LOW);
|
|
}
|
|
}
|