sora/metesp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[M] Fix Sensors

Browse Source
This commit is contained in:
choelzl 2022-05-28 15:06:59 +02:00
parent f05b6492b0
commit 58ba94a455
Signed by: sora
GPG Key ID: A362EA0491E2EEA0
39 changed files with 14135 additions and 14103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
metesp.ino
View File

@ -27,6 +27,10 @@
#define BUTTON_PIN_BITMASK 0x8000
void loop_DRAW(void * pvParameters );
void loop_TOUCH(void * pvParameters );
void loop_MEASURE(void * pvParameters );
/* Global Variables -----------------------------------------------------------*/
static WiFiMulti wifiMulti;
static TwoWire I2C = TwoWire(0);
@ -75,9 +79,9 @@ void IRAM_ATTR onSecondTimer() {
}
view_update = true;
time_update = true;
tf->minuteTick();
}
tf->tick();
}
void IRAM_ATTR onTouch(int8_t contacts, GTPoint *points) {
if(touch->dev.holding) return;
@ -109,18 +113,18 @@ void setup_TIMER(){
#define REGISTER_TIMEDFUN(name,code) static void name (){code;}
#define REGISTER_TIMEDFUN_CALL(name,min) tf->registerFun(name,min)
REGISTER_TIMEDFUN(SENSOR_MEASURE_TF, sensor->measure());
REGISTER_TIMEDFUN(SENSOR_MEASURE_TF, do{sensor->measure();view_update = true;}while(0));
REGISTER_TIMEDFUN(OWM_MEASURE_TF, do{uint8_t i = 0;while(owm && owm[i]){owm[i]->update(); ++i;}}while(0));
REGISTER_TIMEDFUN(RECORD_LOCAL_TF, iflx->record_local());
REGISTER_TIMEDFUN(RECORD_WEATHER_TF, iflx->record_weather());
REGISTER_TIMEDFUN(NTP_TF, ntp->updateNTPtime());
void setup_TIMEDFUN() {
REGISTER_TIMEDFUN_CALL(NTP_TF, 60);
REGISTER_TIMEDFUN_CALL(NTP_TF, 60*60);
REGISTER_TIMEDFUN_CALL(SENSOR_MEASURE_TF,5);
REGISTER_TIMEDFUN_CALL(OWM_MEASURE_TF,5);
REGISTER_TIMEDFUN_CALL(RECORD_LOCAL_TF,5);
REGISTER_TIMEDFUN_CALL(RECORD_WEATHER_TF,5);
REGISTER_TIMEDFUN_CALL(OWM_MEASURE_TF,5*60);
// REGISTER_TIMEDFUN_CALL(RECORD_LOCAL_TF,1*60);
// REGISTER_TIMEDFUN_CALL(RECORD_WEATHER_TF,5*60);
}
void setup_POWER() {
@ -140,11 +144,12 @@ void setup(){
setup_TOUCH();
setup_TIMER();
setup_TIMEDFUN();
sensor->init();
iflx->check();
Display::setViews(views,views_size);
tf->updateForce();
tf->setTick(ntp->dt.minute);
tf->setTick(ntp->dt.minute*60 + ntp->dt.second);
xTaskCreatePinnedToCore(
loop_MEASURE, "Task LMeasure",
@ -189,8 +194,7 @@ void loop_TOUCH(void * pvParameters ){
void loop_MEASURE(void * pvParameters ){
for(;;){
tf->update();
vTaskDelay(200);
vTaskDelay(500);
}
}

90
src/display/display.cpp
View File

@ -9,14 +9,14 @@ static int8_t view_curr = 0;
static DisplayWrapper** views = 0;
void DrawMain(bool v){
Paint_DrawIcon(89,36, ICON_LOGO, &FontIcon, BLACK, WHITE);
Paint_DrawString_EN(29, 0, "Helcel", &Font45, WHITE, BLACK);
if(v)
Paint_DrawString_EN(2,EPD_2IN13_V2_WIDTH - Font16.Height,"WESP-v0.1", &Font16, WHITE, BLACK);
void DrawMain(bool v) {
Paint_DrawIcon(89,36, ICON_LOGO, &FontIcon, BLACK, WHITE);
Paint_DrawString_EN(29, 0, "Helcel", &Font45, WHITE, BLACK);
if(v)
Paint_DrawString_EN(2,EPD_2IN13_V2_WIDTH - Font16.Height,"WESP-v0.1", &Font16, WHITE, BLACK);
}
void Display::setup(){
void Display::setup() {
DEV_Module_Init();
uint16_t Imagesize = ((EPD_2IN13_V2_WIDTH % 8 == 0) ? (EPD_2IN13_V2_WIDTH / 8 ) : (EPD_2IN13_V2_WIDTH / 8 + 1)) * EPD_2IN13_V2_HEIGHT;
@ -29,19 +29,19 @@ void Display::setup(){
EPD_2IN13_V2_DisplayPart(BlackImage);
}
void Display::clearTime(){
Paint_ClearWindows(170, EPD_2IN13_V2_WIDTH - Font24.Height+2, 170 + Font24.Width * 4.5, EPD_2IN13_V2_WIDTH, WHITE);
EPD_2IN13_V2_DisplayPart(BlackImage);
void Display::clearTime() {
Paint_ClearWindows(170, EPD_2IN13_V2_WIDTH - Font24.Height+2, 170 + Font24.Width * 4.5, EPD_2IN13_V2_WIDTH, WHITE);
EPD_2IN13_V2_DisplayPart(BlackImage);
}
void Display::drawTime(strDateTime* dt){
void Display::drawTime(strDateTime* dt) {
clearTime();
if (!dt->valid) return;
Paint_DrawTime(170, EPD_2IN13_V2_WIDTH - Font24.Height+2, dt, &Font24, WHITE, BLACK);
EPD_2IN13_V2_DisplayPart(BlackImage);
};
void Display::refresh(){
void Display::refresh() {
Paint_Clear(WHITE);
EPD_2IN13_V2_Init(EPD_2IN13_V2_FULL);
EPD_2IN13_V2_DisplayPartBaseImage(BlackImage);
@ -49,42 +49,48 @@ void Display::refresh(){
Paint_SelectImage(BlackImage);
};
void Display::update(){
void Display::update() {
Paint_ClearWindows(0, 0, EPD_2IN13_V2_HEIGHT, EPD_2IN13_V2_WIDTH - Font24.Height, WHITE);
Paint_ClearWindows(0, EPD_2IN13_V2_WIDTH - Font24.Height, 170, EPD_2IN13_V2_WIDTH, WHITE);
if(views && view_curr >=0)
views[view_curr]->drawDisplay();
views[view_curr]->drawDisplay();
EPD_2IN13_V2_DisplayPart(BlackImage);
}
void Display::setViews(DisplayWrapper** view_tab, int8_t size){
void Display::setViews(DisplayWrapper** view_tab, int8_t size) {
view_count = size;
views = view_tab;
};
void Display::nextView(){ view_curr++; view_curr = view_curr%view_count;}
void Display::prevView(){ view_curr--; view_curr = (view_curr+view_count) % view_count;}
void Display::nextView() {
view_curr++;
view_curr = view_curr%view_count;
}
void Display::prevView() {
view_curr--;
view_curr = (view_curr+view_count) % view_count;
}
ICON_tpe getWeatherIcon(int id){
if(id>=200 && id<300){ //Thunder
return ICON_CLOUD_THUNDER;
}else if(id>=300 && id<400){//Drizzle
return ICON_CLOUD_RAIN;
}else if(id>=500 && id<600){//Rain
return ICON_CLOUD_RAIN;
}else if(id>=600 && id<700){//Snow
return ICON_CLOUD_SNOW;
}else if(id>=700 && id<800){//Warning
return ICON_WARN;
}else if(id>=800 && id<900){//Clear & Cloudy
if(id==800) return ICON_SUN;
else if(id==801) return ICON_CLOUD_SUN;
else return ICON_CLOUD;
}else{
return ICON_WARN;
}
ICON_tpe getWeatherIcon(int id) {
if(id>=200 && id<300) { //Thunder
return ICON_CLOUD_THUNDER;
} else if(id>=300 && id<400) { //Drizzle
return ICON_CLOUD_RAIN;
} else if(id>=500 && id<600) { //Rain
return ICON_CLOUD_RAIN;
} else if(id>=600 && id<700) { //Snow
return ICON_CLOUD_SNOW;
} else if(id>=700 && id<800) { //Warning
return ICON_WARN;
} else if(id>=800 && id<900) { //Clear & Cloudy
if(id==800) return ICON_SUN;
else if(id==801) return ICON_CLOUD_SUN;
else return ICON_CLOUD;
} else {
return ICON_WARN;
}
}
void WeatherDisplay::drawDisplay() {
@ -107,7 +113,7 @@ void WeatherDisplay::drawDisplay() {
Paint_DrawTime(20, 76, &sunsetdt, &Font12, WHITE, BLACK);
}
void TempDisplay::drawDisplay() {
void TempDisplay::drawDisplay() {
Paint_DrawIcon(0,8, ICON_TEMPERATURE,&FontIcon, BLACK, WHITE);
Paint_DrawFltUnit(76,0,sensor->temp, "C", &Font24, BLACK, WHITE);
Paint_DrawFltUnit(186,6,sensor->heatidx, "C", &Font12, BLACK, WHITE);
@ -117,7 +123,7 @@ void TempDisplay::drawDisplay() {
Paint_DrawString_EN(2,EPD_2IN13_V2_WIDTH - Font16.Height,"Nominal", &Font16, WHITE, BLACK);
}
void AirDisplay::drawDisplay() {
void AirDisplay::drawDisplay() {
Paint_DrawIcon(0,8, ICON_POLUTION,&FontIcon, BLACK, WHITE);
Paint_DrawIntUnit(76,0,sensor->voci, "voci", &Font24, BLACK, WHITE);
@ -137,12 +143,12 @@ void AirDisplay::drawDisplay() {
// particles_50um, ///< 5.0um Particle Count
// particles_100um; ///< 10.0um Particle Count
Paint_DrawString_EN(2,EPD_2IN13_V2_WIDTH - Font16.Height,"Nominal", &Font16, WHITE, BLACK);
Paint_DrawString_EN(2,EPD_2IN13_V2_WIDTH - Font16.Height,"Nominal", &Font16, WHITE, BLACK);
}
void LightDisplay::drawDisplay() {
void LightDisplay::drawDisplay() {
Paint_DrawIcon(0,8, ICON_BULB,&FontIcon, BLACK, WHITE); //TODO BULB
Paint_DrawFltUnit(76,0,sensor->light_lux, "lux", &Font24, BLACK, WHITE);
@ -154,10 +160,10 @@ void LightDisplay::drawDisplay() {
}
void MainDisplay::drawDisplay() {
void MainDisplay::drawDisplay() {
DrawMain(true);
}
void CustomDisplay::drawDisplay() {
void CustomDisplay::drawDisplay() {
Paint_DrawString_EN(60,0,"CUSTOM", &Font24, WHITE, BLACK);
}

58
src/display/display.h
View File

@ -8,7 +8,7 @@
#include "../ntp/ntp.h"
#include "../owm/owm.h"
#include "../sensor/sensor.h"
#include "../sensor/sensor.h"
#include <Arduino.h>
@ -17,12 +17,12 @@
#include <WiFi.h>
#include <WiFiMulti.h>
class DisplayWrapper {
public:
public:
virtual void drawDisplay();
};
class Display {
public:
public:
static void setup();
static void clearTime();
static void drawTime(strDateTime* dt);
@ -33,51 +33,51 @@ class Display {
static void nextView();
static void prevView();
};
class WeatherDisplay: public DisplayWrapper {
public:
WeatherDisplay(OWM* o) : cowm(o){}
void drawDisplay();
private:
OWM* cowm;
public:
WeatherDisplay(OWM* o) : cowm(o) {}
void drawDisplay();
private:
OWM* cowm;
};
class TempDisplay: public DisplayWrapper {
public:
TempDisplay(Sensor* s) : sensor(s){}
void drawDisplay();
private:
Sensor* sensor;
public:
TempDisplay(Sensor* s) : sensor(s) {}
void drawDisplay();
private:
Sensor* sensor;
};
class AirDisplay: public DisplayWrapper {
public:
AirDisplay(Sensor* s) : sensor(s){}
void drawDisplay();
private:
Sensor* sensor;
public:
AirDisplay(Sensor* s) : sensor(s) {}
void drawDisplay();
private:
Sensor* sensor;
};
class LightDisplay: public DisplayWrapper {
public:
LightDisplay(Sensor* s) : sensor(s){}
void drawDisplay();
private:
Sensor* sensor;
public:
LightDisplay(Sensor* s) : sensor(s) {}
void drawDisplay();
private:
Sensor* sensor;
};
class MainDisplay: public DisplayWrapper {
public:
void drawDisplay();
public:
void drawDisplay();
};
class CustomDisplay: public DisplayWrapper {
public:
void drawDisplay();
public:
void drawDisplay();
};
#endif

4
src/epd/debug.h
View File

@ -5,9 +5,9 @@
#define USE_DEBUG 0
#if USE_DEBUG
#define Debug(__info) Serial.print(__info)
#define Debug(__info) Serial.print(__info)
#else
#define Debug(__info)
#define Debug(__info)
#endif
#endif

32
src/epd/epd_cfg.cpp
View File

@ -1,15 +1,15 @@
#include "epd_cfg.h"
void GPIO_Config(void){
void GPIO_Config(void) {
pinMode(EPD_BUSY_PIN, INPUT);
pinMode(EPD_RST_PIN , OUTPUT);
pinMode(EPD_DC_PIN , OUTPUT);
pinMode(EPD_RST_PIN, OUTPUT);
pinMode(EPD_DC_PIN, OUTPUT);
pinMode(EPD_SCK_PIN, OUTPUT);
pinMode(EPD_MOSI_PIN, OUTPUT);
pinMode(EPD_CS_PIN , OUTPUT);
pinMode(EPD_CS_PIN, OUTPUT);
digitalWrite(EPD_CS_PIN , HIGH);
digitalWrite(EPD_CS_PIN, HIGH);
digitalWrite(EPD_SCK_PIN, LOW);
}
/******************************************************************************
@ -17,29 +17,29 @@ function: Module Initialize, the BCM2835 library and initialize the pins, SPI p
parameter:
Info:
******************************************************************************/
uint8_t DEV_Module_Init(void){
GPIO_Config();
uint8_t DEV_Module_Init(void) {
GPIO_Config();
#ifdef USE_DEBUG
Serial.begin(115200);
#endif
#ifdef USE_DEBUG
Serial.begin(115200);
#endif
return 0;
return 0;
}
/******************************************************************************
function:
SPI read and write
******************************************************************************/
void DEV_SPI_WriteByte(uint8_t data){
void DEV_SPI_WriteByte(uint8_t data) {
digitalWrite(EPD_CS_PIN, GPIO_PIN_RESET);
for (int i = 0; i < 8; i++){
if ((data & 0x80) == 0) digitalWrite(EPD_MOSI_PIN, GPIO_PIN_RESET);
for (int i = 0; i < 8; i++) {
if ((data & 0x80) == 0) digitalWrite(EPD_MOSI_PIN, GPIO_PIN_RESET);
else digitalWrite(EPD_MOSI_PIN, GPIO_PIN_SET);
data <<= 1;
digitalWrite(EPD_SCK_PIN, GPIO_PIN_SET);
digitalWrite(EPD_SCK_PIN, GPIO_PIN_SET);
digitalWrite(EPD_SCK_PIN, GPIO_PIN_RESET);
}
digitalWrite(EPD_CS_PIN, GPIO_PIN_SET);

24
src/epd/epd_driver.cpp
View File

@ -92,7 +92,7 @@ const unsigned char EPD_2IN13_V2_lut_partial_update[]= { //20 bytes
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN13_V2_Reset(void){
static void EPD_2IN13_V2_Reset(void) {
DEV_Digital_Write(EPD_RST_PIN, 1);
delay(200);
DEV_Digital_Write(EPD_RST_PIN, 0);
@ -106,7 +106,7 @@ function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_2IN13_V2_SendCommand(uint8_t Reg){
static void EPD_2IN13_V2_SendCommand(uint8_t Reg) {
DEV_Digital_Write(EPD_DC_PIN, 0);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Reg);
@ -118,7 +118,7 @@ function : send data
parameter:
Data : Write data
******************************************************************************/
static void EPD_2IN13_V2_SendData(uint8_t Data){
static void EPD_2IN13_V2_SendData(uint8_t Data) {
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Data);
@ -129,7 +129,7 @@ static void EPD_2IN13_V2_SendData(uint8_t Data){
function : Wait until the busy_pin goes LOW
parameter:
******************************************************************************/
void EPD_2IN13_V2_ReadBusy(void){
void EPD_2IN13_V2_ReadBusy(void) {
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
delay(100);
@ -141,7 +141,7 @@ void EPD_2IN13_V2_ReadBusy(void){
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13_V2_TurnOnDisplay(void){
static void EPD_2IN13_V2_TurnOnDisplay(void) {
EPD_2IN13_V2_SendCommand(0x22);
EPD_2IN13_V2_SendData(0xC7);
EPD_2IN13_V2_SendCommand(0x20);
@ -152,7 +152,7 @@ static void EPD_2IN13_V2_TurnOnDisplay(void){
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13_V2_TurnOnDisplayPart(void){
static void EPD_2IN13_V2_TurnOnDisplayPart(void) {
EPD_2IN13_V2_SendCommand(0x22);
EPD_2IN13_V2_SendData(0x0C);
EPD_2IN13_V2_SendCommand(0x20);
@ -162,7 +162,7 @@ static void EPD_2IN13_V2_TurnOnDisplayPart(void){
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN13_V2_Init(uint8_t Mode){
void EPD_2IN13_V2_Init(uint8_t Mode) {
uint8_t count;
EPD_2IN13_V2_Reset();
@ -261,7 +261,7 @@ void EPD_2IN13_V2_Init(uint8_t Mode){
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN13_V2_Clear(void){
void EPD_2IN13_V2_Clear(void) {
uint16_t Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
@ -280,7 +280,7 @@ void EPD_2IN13_V2_Clear(void){
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13_V2_Display(uint8_t *Image){
void EPD_2IN13_V2_Display(uint8_t *Image) {
uint16_t Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
@ -299,7 +299,7 @@ function : The image of the previous frame must be uploaded, otherwise the
first few seconds will display an exception.
parameter:
******************************************************************************/
void EPD_2IN13_V2_DisplayPartBaseImage(uint8_t *Image){
void EPD_2IN13_V2_DisplayPartBaseImage(uint8_t *Image) {
uint16_t Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
@ -323,7 +323,7 @@ void EPD_2IN13_V2_DisplayPartBaseImage(uint8_t *Image){
}
void EPD_2IN13_V2_DisplayPart(uint8_t *Image){
void EPD_2IN13_V2_DisplayPart(uint8_t *Image) {
uint16_t Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
@ -341,7 +341,7 @@ void EPD_2IN13_V2_DisplayPart(uint8_t *Image){
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN13_V2_Sleep(void){
void EPD_2IN13_V2_Sleep(void) {
EPD_2IN13_V2_SendCommand(0x22); //POWER OFF
EPD_2IN13_V2_SendData(0xC3);
EPD_2IN13_V2_SendCommand(0x20);

254
src/epd/epd_paint.cpp
View File

@ -15,7 +15,7 @@
* V3.2(2020-07-23):
* 1. Change: Paint_SetScale(uint8_t scale)
* Add scale 7 for 5.65f e-Parper
* 2. Change: Paint_SetPixel(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color)
* 2. Change: Paint_SetPixel(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color)
* Add the branch for scale 7
* 3. Change: Paint_Clear(uint16_t Color)
* Add the branch for scale 7
@ -26,7 +26,7 @@
* 2. Add void Paint_SetScale(uint8_t scale);
*
* V3.0(2019-04-18):
* 1.Change:
* 1.Change:
* Paint_DrawPoint(..., DOT_STYLE DOT_STYLE)
* => Paint_DrawPoint(..., DOT_STYLE Dot_Style)
* Paint_DrawLine(..., LINE_STYLE Line_Style, DOT_PIXEL Dot_Pixel)
@ -43,16 +43,16 @@
* 2.add: Paint_SelectImage()
* Select the picture to be drawn
* 3.add: Paint_SetRotate()
* Set the direction of the cache
* 4.add: Paint_RotateImage()
* Can flip the picture, Support 0-360 degrees,
* Set the direction of the cache
* 4.add: Paint_RotateImage()
* Can flip the picture, Support 0-360 degrees,
* but only 90.180.270 rotation is better
* 4.add: Paint_SetMirroring()
* 4.add: Paint_SetMirroring()
* Can Mirroring the picture, horizontal, vertical, origin
* 5.add: Paint_DrawString_CN()
* Can display Chinese(GB1312)
* 5.add: Paint_DrawString_CN()
* Can display Chinese(GB1312)
*
* -----------------------------------------------------------------------------
* -----------------------------------------------------------------------------
* V1.0(2018-07-17):
* Create library
*
@ -94,20 +94,20 @@ parameter:
Height : The height of the picture
Color : Whether the picture is inverted
******************************************************************************/
void Paint_NewImage(uint8_t *image, uint16_t Width, uint16_t Height, uint16_t Rotate, uint16_t Color){
void Paint_NewImage(uint8_t *image, uint16_t Width, uint16_t Height, uint16_t Rotate, uint16_t Color) {
Paint.Image = NULL;
Paint.Image = image;
Paint.WidthMemory = Width;
Paint.HeightMemory = Height;
Paint.Color = Color;
Paint.Color = Color;
Paint.Scale = 2;
Paint.WidthByte = (Width % 8 == 0)? (Width / 8 ): (Width / 8 + 1);
Paint.HeightByte = Height;
Paint.HeightByte = Height;
Paint.Rotate = Rotate;
Paint.Mirror = MIRROR_NONE;
if(Rotate == ROTATE_0 || Rotate == ROTATE_180) {
Paint.Width = Width;
Paint.Height = Height;
@ -122,7 +122,7 @@ function: Select Image
parameter:
image : Pointer to the image cache
******************************************************************************/
void Paint_SelectImage(uint8_t *image){
void Paint_SelectImage(uint8_t *image) {
Paint.Image = image;
}
@ -131,7 +131,7 @@ function: Select Image Rotate
parameter:
Rotate : 0,90,180,270
******************************************************************************/
void Paint_SetRotate(uint16_t Rotate){
void Paint_SetRotate(uint16_t Rotate) {
if(Rotate == ROTATE_0 || Rotate == ROTATE_90 || Rotate == ROTATE_180 || Rotate == ROTATE_270) {
// Debug("Set image Rotate %d\r\n", Rotate);
Paint.Rotate = Rotate;
@ -145,27 +145,27 @@ function: Select Image mirror
parameter:
mirror :Not mirror,Horizontal mirror,Vertical mirror,Origin mirror
******************************************************************************/
void Paint_SetMirroring(uint8_t mirror){
if(mirror == MIRROR_NONE || mirror == MIRROR_HORIZONTAL ||
mirror == MIRROR_VERTICAL || mirror == MIRROR_ORIGIN) {
void Paint_SetMirroring(uint8_t mirror) {
if(mirror == MIRROR_NONE || mirror == MIRROR_HORIZONTAL ||
mirror == MIRROR_VERTICAL || mirror == MIRROR_ORIGIN) {
Paint.Mirror = mirror;
} else {
Debug("mirror should be MIRROR_NONE, MIRROR_HORIZONTAL, \
MIRROR_VERTICAL or MIRROR_ORIGIN\r\n");
}
}
}
void Paint_SetScale(uint8_t scale){
if(scale == 2){
void Paint_SetScale(uint8_t scale) {
if(scale == 2) {
Paint.Scale = scale;
Paint.WidthByte = (Paint.WidthMemory % 8 == 0)? (Paint.WidthMemory / 8 ): (Paint.WidthMemory / 8 + 1);
}else if(scale == 4) {
} else if(scale == 4) {
Paint.Scale = scale;
Paint.WidthByte = (Paint.WidthMemory % 4 == 0)? (Paint.WidthMemory / 4 ): (Paint.WidthMemory / 4 + 1);
}else if(scale == 7) {
} else if(scale == 7) {
Paint.Scale = 7;
Paint.WidthByte = (Paint.WidthMemory % 2 == 0)? (Paint.WidthMemory / 2 ): (Paint.WidthMemory / 2 + 1);
}else {
} else {
Debug("Set Scale Input parameter error\r\n");
Debug("Scale Only support: 2 4 7\r\n");
}
@ -177,16 +177,16 @@ parameter:
Ypoint : At point Y
Color : Painted colors
******************************************************************************/
void Paint_SetPixel(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color){
if(Xpoint > Paint.Width || Ypoint > Paint.Height){
void Paint_SetPixel(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color) {
if(Xpoint > Paint.Width || Ypoint > Paint.Height) {
Debug("Exceeding display boundaries\r\n");
return;
}
}
uint16_t X, Y;
switch(Paint.Rotate) {
case 0:
X = Xpoint;
Y = Ypoint;
Y = Ypoint;
break;
case 90:
X = Paint.WidthMemory - Ypoint - 1;
@ -203,7 +203,7 @@ void Paint_SetPixel(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color){
default:
return;
}
switch(Paint.Mirror) {
case MIRROR_NONE:
break;
@ -221,79 +221,79 @@ void Paint_SetPixel(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color){
return;
}
if(X > Paint.WidthMemory || Y > Paint.HeightMemory){
if(X > Paint.WidthMemory || Y > Paint.HeightMemory) {
Debug("Exceeding display boundaries\r\n");
return;
}
if(Paint.Scale == 2){
if(Paint.Scale == 2) {
uint32_t Addr = X / 8 + Y * Paint.WidthByte;
uint8_t Rdata = Paint.Image[Addr];
if(Color == BLACK)
Paint.Image[Addr] = Rdata & ~(0x80 >> (X % 8));
else
Paint.Image[Addr] = Rdata | (0x80 >> (X % 8));
}else if(Paint.Scale == 4){
} else if(Paint.Scale == 4) {
uint32_t Addr = X / 4 + Y * Paint.WidthByte;
Color = Color % 4;//Guaranteed color scale is 4 --- 0~3
uint8_t Rdata = Paint.Image[Addr];
Rdata = Rdata & (~(0xC0 >> ((X % 4)*2)));
Paint.Image[Addr] = Rdata | ((Color << 6) >> ((X % 4)*2));
}else if(Paint.Scale == 7){
uint16_t Width = Paint.WidthMemory*3%8 == 0 ? Paint.WidthMemory*3/8 : Paint.WidthMemory*3/8+1;
uint32_t Addr = (Xpoint * 3) / 8 + Ypoint * Width;
uint8_t shift, Rdata, Rdata2;
shift = (Xpoint+Ypoint*Paint.HeightMemory) % 8;
} else if(Paint.Scale == 7) {
uint16_t Width = Paint.WidthMemory*3%8 == 0 ? Paint.WidthMemory*3/8 : Paint.WidthMemory*3/8+1;
uint32_t Addr = (Xpoint * 3) / 8 + Ypoint * Width;
uint8_t shift, Rdata, Rdata2;
shift = (Xpoint+Ypoint*Paint.HeightMemory) % 8;
switch(shift) {
switch(shift) {
case 0 :
Rdata = Paint.Image[Addr] & 0x1f;
Rdata = Rdata | ((Color << 5) & 0xe0);
Paint.Image[Addr] = Rdata;
break;
Rdata = Paint.Image[Addr] & 0x1f;
Rdata = Rdata | ((Color << 5) & 0xe0);
Paint.Image[Addr] = Rdata;
break;
case 1 :
Rdata = Paint.Image[Addr] & 0xe3;
Rdata = Rdata | ((Color << 2) & 0x1c);
Paint.Image[Addr] = Rdata;
break;
Rdata = Paint.Image[Addr] & 0xe3;
Rdata = Rdata | ((Color << 2) & 0x1c);
Paint.Image[Addr] = Rdata;
break;
case 2 :
Rdata = Paint.Image[Addr] & 0xfc;
Rdata2 = Paint.Image[Addr + 1] & 0x7f;
Rdata = Rdata | ((Color >> 1) & 0x03);
Rdata2 = Rdata2 | ((Color << 7) & 0x80);
Paint.Image[Addr] = Rdata;
Paint.Image[Addr + 1] = Rdata2;
break;
Rdata = Paint.Image[Addr] & 0xfc;
Rdata2 = Paint.Image[Addr + 1] & 0x7f;
Rdata = Rdata | ((Color >> 1) & 0x03);
Rdata2 = Rdata2 | ((Color << 7) & 0x80);
Paint.Image[Addr] = Rdata;
Paint.Image[Addr + 1] = Rdata2;
break;
case 3 :
Rdata = Paint.Image[Addr] & 0x8f;
Rdata = Rdata | ((Color << 4) & 0x70);
Paint.Image[Addr] = Rdata;
break;
Rdata = Paint.Image[Addr] & 0x8f;
Rdata = Rdata | ((Color << 4) & 0x70);
Paint.Image[Addr] = Rdata;
break;
case 4 :
Rdata = Paint.Image[Addr] & 0xf1;
Rdata = Rdata | ((Color << 1) & 0x0e);
Paint.Image[Addr] = Rdata;
break;
Rdata = Paint.Image[Addr] & 0xf1;
Rdata = Rdata | ((Color << 1) & 0x0e);
Paint.Image[Addr] = Rdata;
break;
case 5 :
Rdata = Paint.Image[Addr] & 0xfe;
Rdata2 = Paint.Image[Addr + 1] & 0x3f;
Rdata = Rdata | ((Color >> 2) & 0x01);
Rdata2 = Rdata2 | ((Color << 6) & 0xc0);
Paint.Image[Addr] = Rdata;
Paint.Image[Addr + 1] = Rdata2;
break;
Rdata = Paint.Image[Addr] & 0xfe;
Rdata2 = Paint.Image[Addr + 1] & 0x3f;
Rdata = Rdata | ((Color >> 2) & 0x01);
Rdata2 = Rdata2 | ((Color << 6) & 0xc0);
Paint.Image[Addr] = Rdata;
Paint.Image[Addr + 1] = Rdata2;
break;
case 6 :
Rdata = Paint.Image[Addr] & 0xc7;
Rdata = Rdata | ((Color << 3) & 0x38);
Paint.Image[Addr] = Rdata;
break;
Rdata = Paint.Image[Addr] & 0xc7;
Rdata = Rdata | ((Color << 3) & 0x38);
Paint.Image[Addr] = Rdata;
break;
case 7 :
Rdata = Paint.Image[Addr] & 0xf8;
Rdata = Rdata | (Color & 0x07);
Paint.Image[Addr] = Rdata;
break;
}
Rdata = Paint.Image[Addr] & 0xf8;
Rdata = Rdata | (Color & 0x07);
Paint.Image[Addr] = Rdata;
break;
}
}
}
@ -302,30 +302,30 @@ function: Clear the color of the picture
parameter:
Color : Painted colors
******************************************************************************/
void Paint_Clear(uint16_t Color){
if(Paint.Scale == 2 || Paint.Scale == 4) {
for (uint16_t Y = 0; Y < Paint.HeightByte; Y++) {
for (uint16_t X = 0; X < Paint.WidthByte; X++ ) {//8 pixel = 1 byte
uint32_t Addr = X + Y*Paint.WidthByte;
Paint.Image[Addr] = Color;
}
void Paint_Clear(uint16_t Color) {
if(Paint.Scale == 2 || Paint.Scale == 4) {
for (uint16_t Y = 0; Y < Paint.HeightByte; Y++) {
for (uint16_t X = 0; X < Paint.WidthByte; X++ ) {//8 pixel = 1 byte
uint32_t Addr = X + Y*Paint.WidthByte;
Paint.Image[Addr] = Color;
}
}
}
}
if(Paint.Scale == 7) {
Color = (uint8_t)Color;
uint16_t Width = (Paint.WidthMemory * 3 % 8 == 0)? (Paint.WidthMemory * 3 / 8 ): (Paint.WidthMemory * 3 / 8 + 1);
for (uint16_t Y = 0; Y < Paint.HeightByte; Y++) {
for (uint16_t X = 0; X < Width; X++ ) {
uint32_t Addr = X + Y * Width;
if((X + Y * Width)%3 == 0)
Paint.Image[Addr] = ((Color<<5) | (Color<<2) | (Color>>1));
else if((X + Y * Width)%3 == 1)
Paint.Image[Addr] = ((Color<<7) | (Color<<4) | (Color<<1) | (Color>>2));
else if((X + Y * Width)%3 == 2)
Paint.Image[Addr] = ((Color<<6) | (Color<<3) | Color);
}
if(Paint.Scale == 7) {
Color = (uint8_t)Color;
uint16_t Width = (Paint.WidthMemory * 3 % 8 == 0)? (Paint.WidthMemory * 3 / 8 ): (Paint.WidthMemory * 3 / 8 + 1);
for (uint16_t Y = 0; Y < Paint.HeightByte; Y++) {
for (uint16_t X = 0; X < Width; X++ ) {
uint32_t Addr = X + Y * Width;
if((X + Y * Width)%3 == 0)
Paint.Image[Addr] = ((Color<<5) | (Color<<2) | (Color>>1));
else if((X + Y * Width)%3 == 1)
Paint.Image[Addr] = ((Color<<7) | (Color<<4) | (Color<<1) | (Color>>2));
else if((X + Y * Width)%3 == 2)
Paint.Image[Addr] = ((Color<<6) | (Color<<3) | Color);
}
}
}
}
}
/******************************************************************************
@ -337,7 +337,7 @@ parameter:
Yend : y end point
Color : Painted colors
******************************************************************************/
void Paint_ClearWindows(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t Yend, uint16_t Color){
void Paint_ClearWindows(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t Yend, uint16_t Color) {
uint16_t X, Y;
for (Y = Ystart; Y < Yend; Y++) {
for (X = Xstart; X < Xend; X++) {//8 pixel = 1 byte
@ -356,13 +356,13 @@ parameter:
Dot_Style : point Style
******************************************************************************/
void Paint_DrawPoint(uint16_t Xpoint, uint16_t Ypoint, uint16_t Color,
DOT_PIXEL Dot_Pixel, DOT_STYLE Dot_Style){
DOT_PIXEL Dot_Pixel, DOT_STYLE Dot_Style) {
if (Xpoint > Paint.Width || Ypoint > Paint.Height) {
Debug("Paint_DrawPoint Input exceeds the normal display range\r\n");
return;
}
int16_t XDir_Num , YDir_Num;
int16_t XDir_Num, YDir_Num;
if (Dot_Style == DOT_FILL_AROUND) {
for (XDir_Num = 0; XDir_Num < 2 * Dot_Pixel - 1; XDir_Num++) {
for (YDir_Num = 0; YDir_Num < 2 * Dot_Pixel - 1; YDir_Num++) {
@ -395,7 +395,7 @@ void Paint_DrawLine(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t Ye
uint16_t Color, DOT_PIXEL Line_width, LINE_STYLE Line_Style)
{
if (Xstart > Paint.Width || Ystart > Paint.Height ||
Xend > Paint.Width || Yend > Paint.Height) {
Xend > Paint.Width || Yend > Paint.Height) {
Debug("Paint_DrawLine Input exceeds the normal display range\r\n");
return;
}
@ -446,9 +446,9 @@ parameter:
Draw_Fill : Whether to fill the inside of the rectangle
******************************************************************************/
void Paint_DrawRectangle(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16_t Yend,
uint16_t Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill){
uint16_t Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill) {
if (Xstart > Paint.Width || Ystart > Paint.Height ||
Xend > Paint.Width || Yend > Paint.Height) {
Xend > Paint.Width || Yend > Paint.Height) {
Debug("Input exceeds the normal display range\r\n");
return;
}
@ -456,7 +456,7 @@ void Paint_DrawRectangle(uint16_t Xstart, uint16_t Ystart, uint16_t Xend, uint16
if (Draw_Fill) {
uint16_t Ypoint;
for(Ypoint = Ystart; Ypoint < Yend; Ypoint++) {
Paint_DrawLine(Xstart, Ypoint, Xend, Ypoint, Color , Line_width, LINE_STYLE_SOLID);
Paint_DrawLine(Xstart, Ypoint, Xend, Ypoint, Color, Line_width, LINE_STYLE_SOLID);
}
} else {
Paint_DrawLine(Xstart, Ystart, Xend, Ystart, Color, Line_width, LINE_STYLE_SOLID);
@ -478,7 +478,7 @@ parameter:
Draw_Fill : Whether to fill the inside of the Circle
******************************************************************************/
void Paint_DrawCircle(uint16_t X_Center, uint16_t Y_Center, uint16_t Radius,
uint16_t Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill){
uint16_t Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill) {
if (X_Center > Paint.Width || Y_Center >= Paint.Height) {
Debug("Paint_DrawCircle Input exceeds the normal display range\r\n");
return;
@ -545,7 +545,7 @@ parameter:
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawChar(uint16_t Xpoint, uint16_t Ypoint, const char Acsii_Char,
sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background){
sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background) {
uint16_t Page, Column;
if (Xpoint > Paint.Width || Ypoint > Paint.Height) {
@ -558,7 +558,7 @@ void Paint_DrawChar(uint16_t Xpoint, uint16_t Ypoint, const char Acsii_Char,
for (Page = 0; Page < Font->Height; Page ++ ) {
for (Column = 0; Column < Font->Width; Column ++ ) {
if (FONT_BACKGROUND == Color_Background) {
if (FONT_BACKGROUND == Color_Background) {
if (*ptr & (0x80 >> (Column % 8)))
Paint_SetPixel(Xpoint + Column, Ypoint + Page, Color_Foreground);
} else {
@ -576,7 +576,7 @@ void Paint_DrawChar(uint16_t Xpoint, uint16_t Ypoint, const char Acsii_Char,
}
void Paint_DrawIcon(uint16_t Xpoint, uint16_t Ypoint, const ICON_tpe icon,
sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background){
sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background) {
uint16_t Page, Column;
if (Xpoint > Paint.Width || Ypoint > Paint.Height) {
@ -589,7 +589,7 @@ void Paint_DrawIcon(uint16_t Xpoint, uint16_t Ypoint, const ICON_tpe icon,
for (Page = 0; Page < Font->Height; Page ++ ) {
for (Column = 0; Column < Font->Width; Column ++ ) {
if (FONT_BACKGROUND == Color_Background) {
if (FONT_BACKGROUND == Color_Background) {
if (*ptr & (0x80 >> (Column % 8)))
Paint_SetPixel(Xpoint + Column, Ypoint + Page, Color_Foreground);
} else {
@ -618,7 +618,7 @@ parameter:
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawString_EN(uint16_t Xstart, uint16_t Ystart, const char * pString,
sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background){
sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background) {
uint16_t Xpoint = Xstart;
uint16_t Ypoint = Ystart;
@ -656,8 +656,8 @@ parameter:
Color_Background : Select the background color
******************************************************************************/
#define ARRAY_LEN 255
void Paint_DrawIntUnit(uint16_t Xpoint, uint16_t Ypoint, int32_t Number,const char * pString, sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background){
int16_t Str_Bit = 0, Unit_Bit = 0;
void Paint_DrawIntUnit(uint16_t Xpoint, uint16_t Ypoint, int32_t Number,const char * pString, sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background) {
int16_t Str_Bit = 0, Unit_Bit = 0;
uint8_t Str_Array[ARRAY_LEN] = {0};
uint8_t *pStr = Str_Array;
@ -670,7 +670,7 @@ void Paint_DrawIntUnit(uint16_t Xpoint, uint16_t Ypoint, int32_t Number,const ch
while (Str_Array[Str_Bit] != '\0') {
++Str_Bit;
}
while (pString[Unit_Bit] != '\0') {
Str_Array[Str_Bit] = pString[Unit_Bit];
++Unit_Bit;
@ -680,8 +680,8 @@ void Paint_DrawIntUnit(uint16_t Xpoint, uint16_t Ypoint, int32_t Number,const ch
Paint_DrawString_EN(Xpoint, Ypoint, (const char*)pStr, Font, Color_Background, Color_Foreground);
}
void Paint_DrawFltUnit(uint16_t Xpoint, uint16_t Ypoint, float Number,const char * pString, sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background){
int16_t Str_Bit = 0, Unit_Bit = 0;
void Paint_DrawFltUnit(uint16_t Xpoint, uint16_t Ypoint, float Number,const char * pString, sFONT* Font, uint16_t Color_Foreground, uint16_t Color_Background) {
int16_t Str_Bit = 0, Unit_Bit = 0;
uint8_t Str_Array[ARRAY_LEN] = {0};
uint8_t *pStr = Str_Array;
@ -693,7 +693,7 @@ void Paint_DrawFltUnit(uint16_t Xpoint, uint16_t Ypoint, float Number,const char
while (Str_Array[Str_Bit] != '\0') {
++Str_Bit;
}
while (pString[Unit_Bit] != '\0') {
Str_Array[Str_Bit] = pString[Unit_Bit];
++Unit_Bit;
@ -716,15 +716,15 @@ parameter:
Color_Background : Select the background color
******************************************************************************/
void Paint_DrawTime(uint16_t Xstart, uint16_t Ystart, strDateTime *pTime, sFONT* Font,
uint16_t Color_Foreground, uint16_t Color_Background){
uint16_t Color_Foreground, uint16_t Color_Background) {
uint8_t value[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
uint16_t Dx = Font->Width;
//Write data into the cache
Paint_DrawChar(Xstart , Ystart, value[pTime->hour / 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx , Ystart, value[pTime->hour % 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx + Dx / 4 + Dx / 2 , Ystart, ':' , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 2 + Dx / 2 , Ystart, value[pTime->minute / 10] , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 3 + Dx / 2 , Ystart, value[pTime->minute % 10] , Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart, Ystart, value[pTime->hour / 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx, Ystart, value[pTime->hour % 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx + Dx / 4 + Dx / 2, Ystart, ':', Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 2 + Dx / 2, Ystart, value[pTime->minute / 10], Font, Color_Background, Color_Foreground);
Paint_DrawChar(Xstart + Dx * 3 + Dx / 2, Ystart, value[pTime->minute % 10], Font, Color_Background, Color_Foreground);
}

16
src/epd/epd_paint.h
View File

@ -64,13 +64,13 @@ typedef enum {
**/
typedef enum {
DOT_PIXEL_1X1 = 1, // 1 x 1
DOT_PIXEL_2X2 , // 2 X 2
DOT_PIXEL_3X3 , // 3 X 3
DOT_PIXEL_4X4 , // 4 X 4
DOT_PIXEL_5X5 , // 5 X 5
DOT_PIXEL_6X6 , // 6 X 6
DOT_PIXEL_7X7 , // 7 X 7
DOT_PIXEL_8X8 , // 8 X 8
DOT_PIXEL_2X2, // 2 X 2
DOT_PIXEL_3X3, // 3 X 3
DOT_PIXEL_4X4, // 4 X 4
DOT_PIXEL_5X5, // 5 X 5
DOT_PIXEL_6X6, // 6 X 6
DOT_PIXEL_7X7, // 7 X 7
DOT_PIXEL_8X8, // 8 X 8
} DOT_PIXEL;
#define DOT_PIXEL_DFT DOT_PIXEL_1X1 //Default dot pilex
@ -79,7 +79,7 @@ typedef enum {
**/
typedef enum {
DOT_FILL_AROUND = 1, // dot pixel 1 x 1
DOT_FILL_RIGHTUP , // dot pixel 2 X 2
DOT_FILL_RIGHTUP, // dot pixel 2 X 2
} DOT_STYLE;
#define DOT_STYLE_DFT DOT_FILL_AROUND //Default dot pilex

2672
src/epd/fonts/font12.cpp
View File

File diff suppressed because it is too large Load Diff

3432
src/epd/fonts/font16.cpp
View File

File diff suppressed because it is too large Load Diff

4188
src/epd/fonts/font20.cpp
View File

File diff suppressed because it is too large Load Diff

4948
src/epd/fonts/font24.cpp
View File

File diff suppressed because it is too large Load Diff

4376
src/epd/fonts/font45.cpp
View File

File diff suppressed because it is too large Load Diff

1912
src/epd/fonts/font8.cpp
View File

File diff suppressed because it is too large Load Diff

32
src/epd/fonts/fonts.h
View File

@ -40,7 +40,7 @@
#define __FONTS_H
#ifdef __cplusplus
extern "C" {
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
@ -48,11 +48,11 @@
//ASCII
typedef struct _tFont
{
const uint8_t *table;
uint16_t Width;
uint16_t Height;
{
const uint8_t *table;
uint16_t Width;
uint16_t Height;
} sFONT;
extern sFONT Font45;
@ -66,27 +66,27 @@ extern sFONT FontIcon;
typedef enum {
ICON_LOGO = 0,
ICON_WARN,
ICON_TEMPERATURE, ICON_DROP, ICON_SCALE, ICON_POLUTION,
ICON_LOGO = 0,
ICON_WARN,
ICON_TEMPERATURE, ICON_DROP, ICON_SCALE, ICON_POLUTION,
ICON_SUN,
ICON_SUN,
ICON_CLOUD, ICON_CLOUD_RAIN, ICON_CLOUD_SNOW,
ICON_CLOUD_THUNDER, ICON_CLOUD_SUN, ICON_CLOUD_SUNNYRAIN,
ICON_CLOUD, ICON_CLOUD_RAIN, ICON_CLOUD_SNOW,
ICON_CLOUD_THUNDER, ICON_CLOUD_SUN, ICON_CLOUD_SUNNYRAIN,
ICON_SUNSET, ICON_SUNRISE,
ICON_SUNSET, ICON_SUNRISE,
ICON_BULB
ICON_BULB
} ICON_tpe;
#ifdef __cplusplus
}
#endif
#endif /* __FONTS_H */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

2310
src/epd/fonts/icons.cpp
View File

File diff suppressed because it is too large Load Diff

1236
src/epd/icon.h
View File

File diff suppressed because it is too large Load Diff

238
src/influxdb/influx.h
View File

@ -41,143 +41,143 @@ oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq\n\
mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d\n\
emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=\n\
-----END CERTIFICATE-----\n\
";
";
class Influx {
public:
Influx(Sensor* _sensor, OWM* _owm[]): sensor(_sensor), owm(_owm) {}
public:
Influx(Sensor* _sensor, OWM* _owm[]): sensor(_sensor), owm(_owm) {}
void check(){
if (client.validateConnection()) {
Serial.print("Connected to InfluxDB: ");
Serial.println(client.getServerUrl());
} else {
Serial.print("InfluxDB connection failed: ");
Serial.println(client.getLastErrorMessage());
}
void check() {
if (client.validateConnection()) {
Serial.print("Connected to InfluxDB: ");
Serial.println(client.getServerUrl());
} else {
Serial.print("InfluxDB connection failed: ");
Serial.println(client.getLastErrorMessage());
}
}
void record() {
uint8_t i = 0;
while(owm && owm[i] != NULL) {
record_weather(owm[i]);
++i;
}
if(sensor) record_local();
}
void record(bool w, bool s) {
uint8_t i = 0;
while(w && owm && owm[i] != NULL) {
record_weather(owm[i]);
++i;
}
if(sensor && s) record_local();
}
void record_local() {
if(!sensor) return;
Serial.println("InfluxDB: Uploading Local Data");
dp.clearFields();
dp.clearTags();
dp.addTag("device", "WESP0");
dp.addTag("location", "local");
dp.addField("temperature", sensor->temp);
dp.addField("pressure", sensor->pres);
dp.addField("humidity", sensor->temp);
dp.addField("heat_index", sensor->heatidx);
dp.addField("light", sensor->light);
dp.addField("uv", sensor->uv);
dp.addField("uvi", sensor->uvi);
dp.addField("light_full", sensor->light_full);
dp.addField("light_vis", sensor->light_vis);
dp.addField("light_ir", sensor->light_ir);
dp.addField("light_lux", sensor->light_lux);
dp.addField("voc", sensor->voci);
dp.addField("pm10_standard", sensor->pmd.pm10_standard);
dp.addField("pm25_standard", sensor->pmd.pm25_standard);
dp.addField("pm100_standard", sensor->pmd.pm100_standard);
dp.addField("pm10_env", sensor->pmd.pm10_env);
dp.addField("pm25_env", sensor->pmd.pm25_env);
dp.addField("pm100_env", sensor->pmd.pm100_env);
dp.addField("particles_03um", sensor->pmd.particles_03um);
dp.addField("particles_05um", sensor->pmd.particles_05um);
dp.addField("particles_10um", sensor->pmd.particles_10um);
dp.addField("particles_25um", sensor->pmd.particles_25um);
dp.addField("particles_50um", sensor->pmd.particles_50um);
dp.addField("particles_100um", sensor->pmd.particles_100um);
client.writePoint(dp);
Serial.println("InfluxDB: OK");
}
void record_weather() {
record(true,false);
}
void record_weather(OWM* owm) {
if(!owm) return;
Serial.println("InfluxDB: Uploading OWM Data");
if(!owm->valid_weather) {
Serial.println("InfluxDB: Error, not valid weather");
return;
}
void record(){
uint8_t i = 0;
while(owm && owm[i] != NULL){
record_weather(owm[i]);
++i;
}
if(sensor) record_local();
}
JsonObject weather_0 = owm->weather["weather"][0];
JsonObject weather_main = owm->weather["main"];
JsonObject weather_sys = owm->weather["sys"];
if(!weather_0 || !weather_main || !weather_sys ) return;
void record(bool w, bool s){
uint8_t i = 0;
while(w && owm && owm[i] != NULL){
record_weather(owm[i]);
++i;
}
if(sensor && s) record_local();
}
dp.clearFields();
dp.clearTags();
dp.addTag("device", "WESP0");
dp.addTag("location", owm->location);
dp.addField("temperature", float(weather_main["temp"]));
dp.addField("temperature_feel",float(weather_main["feels_like"]));
dp.addField("pressure",int32_t(weather_main["pressure"]));
dp.addField("humidity",int32_t(weather_main["humidity"]));
void record_local(){
if(!sensor) return;
Serial.println("InfluxDB: Uploading Local Data");
JsonObject weather_wind = owm->weather["wind"];
dp.addField("wind_speed",weather_wind?float(weather_wind["speed"]):0.0);
dp.addField("wind_dir",weather_wind?float(weather_wind["deg"]):0.0);
dp.addField("wind_gust",weather_wind?float(weather_wind["gust"]):0.0);
dp.clearFields();
dp.clearTags();
dp.addTag("device", "WESP0");
dp.addTag("location", "local");
dp.addField("temperature", sensor->temp);
dp.addField("pressure", sensor->pres);
dp.addField("humidity", sensor->temp);
dp.addField("heat_index", sensor->heatidx);
dp.addField("light", sensor->light);
dp.addField("uv", sensor->uv);
dp.addField("uvi", sensor->uvi);
dp.addField("sunrise", uint64_t(weather_sys["sunrise"]));
dp.addField("sunset",uint64_t(weather_sys["sunset"]));
dp.addField("suntime",uint64_t(weather_sys["sunset"])-uint64_t(weather_sys["sunrise"]));
dp.addField("light_full", sensor->light_full);
dp.addField("light_vis", sensor->light_vis);
dp.addField("light_ir", sensor->light_ir);
dp.addField("light_lux", sensor->light_lux);
JsonObject weather_rain = owm->weather["rain"];
dp.addField("precipitation_rain_1h",weather_rain?float(weather_rain["1h"]):0.0);
dp.addField("precipitation_rain_3h",weather_rain?float(weather_rain["3h"]):0.0);
dp.addField("voc", sensor->voci);
JsonObject weather_snow = owm->weather["snow"];
dp.addField("precipitation_snow_1h",weather_snow?float(weather_snow["1h"]):0.0);
dp.addField("precipitation_snow_3h",weather_snow?float(weather_snow["3h"]):0.0);
dp.addField("pm10_standard", sensor->pmd.pm10_standard);
dp.addField("pm25_standard", sensor->pmd.pm25_standard);
dp.addField("pm100_standard", sensor->pmd.pm100_standard);
dp.addField("pm10_env", sensor->pmd.pm10_env);
dp.addField("pm25_env", sensor->pmd.pm25_env);
dp.addField("pm100_env", sensor->pmd.pm100_env);
dp.addField("particles_03um", sensor->pmd.particles_03um);
dp.addField("particles_05um", sensor->pmd.particles_05um);
dp.addField("particles_10um", sensor->pmd.particles_10um);
dp.addField("particles_25um", sensor->pmd.particles_25um);
dp.addField("particles_50um", sensor->pmd.particles_50um);
dp.addField("particles_100um", sensor->pmd.particles_100um);
client.writePoint(dp);
Serial.println("InfluxDB: OK");
}
void record_weather(){
record(true,false);
}
void record_weather(OWM* owm){
if(!owm) return;
Serial.println("InfluxDB: Uploading OWM Data");
if(!owm->valid_weather) {
Serial.println("InfluxDB: Error, not valid weather");
return;
}
JsonObject weather_0 = owm->weather["weather"][0];
JsonObject weather_main = owm->weather["main"];
JsonObject weather_sys = owm->weather["sys"];
if(!weather_0 || !weather_main || !weather_sys ) return;
dp.clearFields();
dp.clearTags();
dp.addTag("device", "WESP0");
dp.addTag("location", owm->location);
dp.addField("temperature", float(weather_main["temp"]));
dp.addField("temperature_feel",float(weather_main["feels_like"]));
dp.addField("pressure",int32_t(weather_main["pressure"]));
dp.addField("humidity",int32_t(weather_main["humidity"]));
client.writePoint(dp);
Serial.println("InfluxDB: OK");
}
JsonObject weather_wind = owm->weather["wind"];
dp.addField("wind_speed",weather_wind?float(weather_wind["speed"]):0.0);
dp.addField("wind_dir",weather_wind?float(weather_wind["deg"]):0.0);
dp.addField("wind_gust",weather_wind?float(weather_wind["gust"]):0.0);
private:
OWM** owm;
Sensor* sensor;
dp.addField("sunrise", uint64_t(weather_sys["sunrise"]));
dp.addField("sunset",uint64_t(weather_sys["sunset"]));
dp.addField("suntime",uint64_t(weather_sys["sunset"])-uint64_t(weather_sys["sunrise"]));
JsonObject weather_rain = owm->weather["rain"];
dp.addField("precipitation_rain_1h",weather_rain?float(weather_rain["1h"]):0.0);
dp.addField("precipitation_rain_3h",weather_rain?float(weather_rain["3h"]):0.0);
JsonObject weather_snow = owm->weather["snow"];
dp.addField("precipitation_snow_1h",weather_snow?float(weather_snow["1h"]):0.0);
dp.addField("precipitation_snow_3h",weather_snow?float(weather_snow["3h"]):0.0);
client.writePoint(dp);
Serial.println("InfluxDB: OK");
}
private:
OWM** owm;
Sensor* sensor;
InfluxDBClient client = InfluxDBClient(INFLUXDB_URL, INFLUXDB_ORG, INFLUXDB_BUCKET, INFLUXDB_TOKEN, cert);
Point dp = Point("environment");
InfluxDBClient client = InfluxDBClient(INFLUXDB_URL, INFLUXDB_ORG, INFLUXDB_BUCKET, INFLUXDB_TOKEN, cert);
Point dp = Point("environment");
};
#endif

324
src/ntp/ntp.cpp
View File

@ -20,84 +20,84 @@ String _NTPserver="";
// NTPserver is the name of the NTPserver
bool NTPtime::setSendInterval(unsigned long _sendInterval_) {
bool retVal = false;
if(_sendInterval_ <= MAX_SEND_INTERVAL) {
_sendInterval = _sendInterval_ * SEC_TO_MS;
retVal = true;
}
bool retVal = false;
if(_sendInterval_ <= MAX_SEND_INTERVAL) {
_sendInterval = _sendInterval_ * SEC_TO_MS;
retVal = true;
}
return retVal;
return retVal;
}
bool NTPtime::setRecvTimeout(unsigned long _recvTimeout_) {
bool retVal = false;
if(_recvTimeout_ <= MAC_RECV_TIMEOUT) {
_recvTimeout = _recvTimeout_ * SEC_TO_MS;
retVal = true;
}
bool retVal = false;
if(_recvTimeout_ <= MAC_RECV_TIMEOUT) {
_recvTimeout = _recvTimeout_ * SEC_TO_MS;
retVal = true;
}
return retVal;
return retVal;
}
NTPtime::NTPtime(String NTPserver) {
_NTPserver = NTPserver;
_sendPhase = true;
_sentTime = 0;
_sendInterval = SEND_INTRVL_DEFAULT * SEC_TO_MS;
_recvTimeout = RECV_TIMEOUT_DEFATUL * SEC_TO_MS;
_NTPserver = NTPserver;
_sendPhase = true;
_sentTime = 0;
_sendInterval = SEND_INTRVL_DEFAULT * SEC_TO_MS;
_recvTimeout = RECV_TIMEOUT_DEFATUL * SEC_TO_MS;
}
// Converts a unix time stamp to a strDateTime structure
strDateTime NTPtime::ConvertUnixTimestamp( unsigned long _tempTimeStamp) {
strDateTime _tempDateTime;
uint8_t _year, _month, _monthLength;
uint32_t _time;
unsigned long _days;
strDateTime _tempDateTime;
uint8_t _year, _month, _monthLength;
uint32_t _time;
unsigned long _days;
_time = (uint32_t)_tempTimeStamp;
_tempDateTime.second = _time % 60;
_time /= 60; // now it is minutes
_tempDateTime.minute = _time % 60;
_time /= 60; // now it is hours
_tempDateTime.hour = _time % 24;
_time /= 24; // now it is _days
_tempDateTime.dayofWeek = ((_time + 4) % 7) + 1; // Sunday is day 1
_time = (uint32_t)_tempTimeStamp;
_tempDateTime.second = _time % 60;
_time /= 60; // now it is minutes
_tempDateTime.minute = _time % 60;
_time /= 60; // now it is hours
_tempDateTime.hour = _time % 24;
_time /= 24; // now it is _days
_tempDateTime.dayofWeek = ((_time + 4) % 7) + 1; // Sunday is day 1
_year = 0;
_days = 0;
while ((unsigned)(_days += (LEAP_YEAR(_year) ? 366 : 365)) <= _time) {
_year++;
}
_tempDateTime.year = _year; // year is offset from 1970
_year = 0;
_days = 0;
while ((unsigned)(_days += (LEAP_YEAR(_year) ? 366 : 365)) <= _time) {
_year++;
}
_tempDateTime.year = _year; // year is offset from 1970
_days -= LEAP_YEAR(_year) ? 366 : 365;
_time -= _days; // now it is days in this year, starting at 0
_days -= LEAP_YEAR(_year) ? 366 : 365;
_time -= _days; // now it is days in this year, starting at 0
_days = 0;
_month = 0;
_monthLength = 0;
for (_month = 0; _month < 12; _month++) {
if (_month == 1) { // february
if (LEAP_YEAR(_year)) {
_monthLength = 29;
} else {
_monthLength = 28;
}
} else {
_monthLength = _monthDays[_month];
}
_days = 0;
_month = 0;
_monthLength = 0;
for (_month = 0; _month < 12; _month++) {
if (_month == 1) { // february
if (LEAP_YEAR(_year)) {
_monthLength = 29;
} else {
_monthLength = 28;
}
} else {
_monthLength = _monthDays[_month];
}
if (_time >= _monthLength) {
_time -= _monthLength;
} else {
break;
}
}
_tempDateTime.month = _month + 1; // jan is month 1
_tempDateTime.day = _time + 1; // day of month
_tempDateTime.year += 1970;
if (_time >= _monthLength) {
_time -= _monthLength;
} else {
break;
}
}
_tempDateTime.month = _month + 1; // jan is month 1
_tempDateTime.day = _time + 1; // day of month
_tempDateTime.year += 1970;
return _tempDateTime;
return _tempDateTime;
}
@ -106,134 +106,134 @@ strDateTime NTPtime::ConvertUnixTimestamp( unsigned long _tempTimeStamp) {
//
boolean NTPtime::summerTime(unsigned long _timeStamp ) {
strDateTime _tempDateTime;
_tempDateTime = ConvertUnixTimestamp(_timeStamp);
strDateTime _tempDateTime;
_tempDateTime = ConvertUnixTimestamp(_timeStamp);
if (_tempDateTime.month < 3 || _tempDateTime.month > 10) return false; // keine Sommerzeit in Jan, Feb, Nov, Dez
if (_tempDateTime.month > 3 && _tempDateTime.month < 10) return true; // Sommerzeit in Apr, Mai, Jun, Jul, Aug, Sep
if (_tempDateTime.month == 3 && (_tempDateTime.hour + 24 * _tempDateTime.day) >= (3 + 24 * (31 - (5 * _tempDateTime.year / 4 + 4) % 7)) || _tempDateTime.month == 10 && (_tempDateTime.hour + 24 * _tempDateTime.day) < (3 + 24 * (31 - (5 * _tempDateTime.year / 4 + 1) % 7)))
return true;
else
return false;
if (_tempDateTime.month < 3 || _tempDateTime.month > 10) return false; // keine Sommerzeit in Jan, Feb, Nov, Dez
if (_tempDateTime.month > 3 && _tempDateTime.month < 10) return true; // Sommerzeit in Apr, Mai, Jun, Jul, Aug, Sep
if (_tempDateTime.month == 3 && (_tempDateTime.hour + 24 * _tempDateTime.day) >= (3 + 24 * (31 - (5 * _tempDateTime.year / 4 + 4) % 7)) || _tempDateTime.month == 10 && (_tempDateTime.hour + 24 * _tempDateTime.day) < (3 + 24 * (31 - (5 * _tempDateTime.year / 4 + 1) % 7)))
return true;
else
return false;
}
boolean NTPtime::daylightSavingTime(unsigned long _timeStamp) {
strDateTime _tempDateTime;
_tempDateTime = ConvertUnixTimestamp(_timeStamp);
strDateTime _tempDateTime;
_tempDateTime = ConvertUnixTimestamp(_timeStamp);
if (_tempDateTime.month < 3 || _tempDateTime.month > 11) return false; //January, february, and december are out.
if (_tempDateTime.month > 3 && _tempDateTime.month < 11) return true; //April to October are in
int previousSunday = _tempDateTime.day - (_tempDateTime.dayofWeek - 1); // dow Sunday input was 1,
if (_tempDateTime.month < 3 || _tempDateTime.month > 11) return false; //January, february, and december are out.
if (_tempDateTime.month > 3 && _tempDateTime.month < 11) return true; //April to October are in
int previousSunday = _tempDateTime.day - (_tempDateTime.dayofWeek - 1); // dow Sunday input was 1,
// -------------------- March ---------------------------------------
//In march, we are DST if our previous Sunday was = to or after the 8th.
if (_tempDateTime.month == 3 ) { // in march, if previous Sunday is after the 8th, is DST
// unless Sunday and hour < 2am
if ( previousSunday >= 8 ) { // Sunday = 1
// return true if day > 14 or (dow == 1 and hour >= 2)
return ((_tempDateTime.day > 14) ||
((_tempDateTime.dayofWeek == 1 && _tempDateTime.hour >= 2) || _tempDateTime.dayofWeek > 1));
} // end if ( previousSunday >= 8 && _dateTime.dayofWeek > 0 )
else
{
// previousSunday has to be < 8 to get here
//return (previousSunday < 8 && (_tempDateTime.dayofWeek - 1) = 0 && _tempDateTime.hour >= 2)
return false;
} // end else
} // end if (_tempDateTime.month == 3 )
// -------------------- March ---------------------------------------
//In march, we are DST if our previous Sunday was = to or after the 8th.
if (_tempDateTime.month == 3 ) { // in march, if previous Sunday is after the 8th, is DST
// unless Sunday and hour < 2am
if ( previousSunday >= 8 ) { // Sunday = 1
// return true if day > 14 or (dow == 1 and hour >= 2)
return ((_tempDateTime.day > 14) ||
((_tempDateTime.dayofWeek == 1 && _tempDateTime.hour >= 2) || _tempDateTime.dayofWeek > 1));
} // end if ( previousSunday >= 8 && _dateTime.dayofWeek > 0 )
else
{
// previousSunday has to be < 8 to get here
//return (previousSunday < 8 && (_tempDateTime.dayofWeek - 1) = 0 && _tempDateTime.hour >= 2)
return false;
} // end else
} // end if (_tempDateTime.month == 3 )
// ------------------------------- November -------------------------------
// ------------------------------- November -------------------------------
// gets here only if month = November
//In november we must be before the first Sunday to be dst.
//That means the previous Sunday must be before the 2nd.
if (previousSunday < 1){
// is not true for Sunday after 2am or any day after 1st Sunday any time
return ((_tempDateTime.dayofWeek == 1 && _tempDateTime.hour < 2) || (_tempDateTime.dayofWeek > 1));
//return true;
}else{
// return false unless after first wk and dow = Sunday and hour < 2
return (_tempDateTime.day <8 && _tempDateTime.dayofWeek == 1 && _tempDateTime.hour < 2);
}
}
// gets here only if month = November
//In november we must be before the first Sunday to be dst.
//That means the previous Sunday must be before the 2nd.
if (previousSunday < 1) {
// is not true for Sunday after 2am or any day after 1st Sunday any time
return ((_tempDateTime.dayofWeek == 1 && _tempDateTime.hour < 2) || (_tempDateTime.dayofWeek > 1));
//return true;
} else {
// return false unless after first wk and dow = Sunday and hour < 2
return (_tempDateTime.day <8 && _tempDateTime.dayofWeek == 1 && _tempDateTime.hour < 2);
}
}
unsigned long NTPtime::adjustTimeZone(unsigned long _timeStamp, float _timeZone, byte _DayLightSaving) {
strDateTime _tempDateTime;
_timeStamp += (unsigned long)(_timeZone * 3600.0); // adjust timezone
if (_DayLightSaving ==1 && summerTime(_timeStamp)) _timeStamp += 3600; // European Summer time
if (_DayLightSaving ==2 && daylightSavingTime(_timeStamp)) _timeStamp += 3600; // US daylight time
return _timeStamp;
strDateTime _tempDateTime;
_timeStamp += (unsigned long)(_timeZone * 3600.0); // adjust timezone
if (_DayLightSaving ==1 && summerTime(_timeStamp)) _timeStamp += 3600; // European Summer time
if (_DayLightSaving ==2 && daylightSavingTime(_timeStamp)) _timeStamp += 3600; // US daylight time
return _timeStamp;
}
strDateTime NTPtime::getNTPtime(float _timeZone, boolean _DayLightSaving) {
strDateTime NTPtime::getNTPtime(float _timeZone, byte _DayLightSaving) {
Serial.println("NTP: Updating Time");
int cb;
strDateTime _dateTime;
unsigned long _unixTime = 0;
_dateTime.valid = false;
unsigned long _currentTimeStamp;
Serial.println("NTP: Updating Time");
int cb;
strDateTime _dateTime;
unsigned long _unixTime = 0;
_dateTime.valid = false;
unsigned long _currentTimeStamp;
if (_sendPhase) {
if (_sentTime && ((millis() - _sentTime) < _sendInterval)) {
if (_sendPhase) {
if (_sentTime && ((millis() - _sentTime) < _sendInterval)) {
Serial.println("NTP: Too Fast");
return _dateTime;
}
Serial.println("NTP: Too Fast");
return _dateTime;
}
_sendPhase = false;
UDPNTPClient.begin(1337); // Port for NTP receive
_sendPhase = false;
UDPNTPClient.begin(1337); // Port for NTP receive
memset(_packetBuffer, 0, NTP_PACKET_SIZE);
_packetBuffer[0] = 0b11100011; // LI, Version, Mode
_packetBuffer[1] = 0; // Stratum, or type of clock
_packetBuffer[2] = 6; // Polling Interval
_packetBuffer[3] = 0xEC; // Peer Clock Precision
_packetBuffer[12] = 49;
_packetBuffer[13] = 0x4E;
_packetBuffer[14] = 49;
_packetBuffer[15] = 52;
UDPNTPClient.beginPacket(_NTPserver.c_str(), 123);
UDPNTPClient.write(_packetBuffer, NTP_PACKET_SIZE);
UDPNTPClient.endPacket();
memset(_packetBuffer, 0, NTP_PACKET_SIZE);
_packetBuffer[0] = 0b11100011; // LI, Version, Mode
_packetBuffer[1] = 0; // Stratum, or type of clock
_packetBuffer[2] = 6; // Polling Interval
_packetBuffer[3] = 0xEC; // Peer Clock Precision
_packetBuffer[12] = 49;
_packetBuffer[13] = 0x4E;
_packetBuffer[14] = 49;
_packetBuffer[15] = 52;
UDPNTPClient.beginPacket(_NTPserver.c_str(), 123);
UDPNTPClient.write(_packetBuffer, NTP_PACKET_SIZE);
UDPNTPClient.endPacket();
_sentTime = millis();
} else {
cb = UDPNTPClient.parsePacket();
if (cb == 0) {
if ((millis() - _sentTime) > _recvTimeout) {
_sendPhase = true;
_sentTime = 0;
}
} else {
_sentTime = millis();
} else {
cb = UDPNTPClient.parsePacket();
if (cb == 0) {
if ((millis() - _sentTime) > _recvTimeout) {
_sendPhase = true;
_sentTime = 0;
}
} else {
UDPNTPClient.read(_packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer
unsigned long highWord = word(_packetBuffer[40], _packetBuffer[41]);
unsigned long lowWord = word(_packetBuffer[42], _packetBuffer[43]);
unsigned long secsSince1900 = highWord << 16 | lowWord;
const unsigned long seventyYears = 2208988800UL;
_unixTime = secsSince1900 - seventyYears;
if (_unixTime > 0) {
_currentTimeStamp = adjustTimeZone(_unixTime, _timeZone, _DayLightSaving);
_dateTime = ConvertUnixTimestamp(_currentTimeStamp);
_dateTime.valid = true;
} else
_dateTime.valid = false;
UDPNTPClient.read(_packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer
unsigned long highWord = word(_packetBuffer[40], _packetBuffer[41]);
unsigned long lowWord = word(_packetBuffer[42], _packetBuffer[43]);
unsigned long secsSince1900 = highWord << 16 | lowWord;
const unsigned long seventyYears = 2208988800UL;
_unixTime = secsSince1900 - seventyYears;
if (_unixTime > 0) {
_currentTimeStamp = adjustTimeZone(_unixTime, _timeZone, _DayLightSaving);
_dateTime = ConvertUnixTimestamp(_currentTimeStamp);
_dateTime.valid = true;
} else
_dateTime.valid = false;
_sendPhase = true;
}
}
_sendPhase = true;
}
}
Serial.println("NTP: OK");
Serial.println("NTP: OK");
return _dateTime;
return _dateTime;
}
void NTPtime::updateNTPtime(){
strDateTime ndt = getNTPtime(1.0f, true);
if(ndt.valid) dt = ndt;
void NTPtime::updateNTPtime() {
strDateTime ndt = getNTPtime(1.0f, 1);
if(ndt.valid) dt = ndt;
};

22
src/ntp/ntp.h
View File

@ -4,23 +4,23 @@
#include <WiFiUdp.h>
struct strDateTime {
byte hour;
byte minute;
byte second;
int year;
byte month;
byte day;
byte dayofWeek;
boolean valid;
byte hour;
byte minute;
byte second;
int year;
byte month;
byte day;
byte dayofWeek;
boolean valid;
};
class NTPtime {
public:
public:
NTPtime(String NTPtime);
strDateTime dt = {0};
strDateTime getNTPtime(float _timeZone, boolean _DayLightSaving);
strDateTime getNTPtime(float _timeZone, byte _DayLightSaving);
void updateNTPtime();
@ -32,7 +32,7 @@ class NTPtime {
static boolean daylightSavingTime(unsigned long _timeStamp);
static unsigned long adjustTimeZone(unsigned long _timeStamp, float _timeZone, byte _DayLightSavingSaving);
private:
private:
bool _sendPhase;
unsigned long _sentTime;

18
src/owm/owm.h
View File

@ -9,15 +9,15 @@
#define OPENWEATHER_URL(loc, api) ("https://api.openweathermap.org/data/2.5/weather?q=" + loc + "&appid=" + api + "&units=metric")
class OWM{
public:
OWM(){};
OWM(String l,String k) : location(l), key(k){}
class OWM {
public:
OWM() {};
OWM(String l,String k) : location(l), key(k) {}
StaticJsonDocument<1024> weather;
StaticJsonDocument<1024> weather;
bool valid_weather = false;
bool update(){
bool update() {
Serial.println("OWWM: Updating Data");
String response = httpGETRequest(OPENWEATHER_URL(location,key).c_str());
@ -30,7 +30,7 @@ class OWM{
}
if(weather["weather"]==NULL ||weather["main"]==NULL ||
weather["wind"]==NULL || weather["sys"]==NULL ){
weather["wind"]==NULL || weather["sys"]==NULL ) {
Serial.println("OWWM: Error, missing fields");
valid_weather = false;
return false;
@ -46,7 +46,7 @@ private:
String key;
String httpGETRequest(const char* serverName) {
HTTPClient http;
HTTPClient http;
http.begin(serverName,root_ca);
int httpResponseCode = http.GET();
String payload = "{}";
@ -59,7 +59,7 @@ private:
}
const char* root_ca= \
" -----BEGIN CERTIFICATE-----\n\
" -----BEGIN CERTIFICATE-----\n\
MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB\n\
iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl\n\
cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV\n\

415
src/sensor/dev/bme280.cpp
View File

@ -2,302 +2,301 @@
/****************************************************************/
bool BME280::Initialize(){
bool success(true);
bool BME280::Initialize() {
bool success(true);
success &= ReadChipID();
success &= ReadChipID();
if(success){
success &= ReadTrim();
//InitializeFilter(); //If Filter ON
WriteSettings();
}
m_initialized = success;
return m_initialized;
if(success) {
success &= ReadTrim();
//InitializeFilter(); //If Filter ON
WriteSettings();
}
m_initialized = success;
return m_initialized;
}
/****************************************************************/
bool BME280::ReadChipID(){
uint8_t id[1];
bool BME280::ReadChipID() {
uint8_t id[1];
ReadRegister(ID_ADDR, &id[0], 1);
ReadRegister(ID_ADDR, &id[0], 1);
switch(id[0]){
case ChipModel_BME280:
m_chip_model = ChipModel_BME280;
break;
case ChipModel_BMP280:
m_chip_model = ChipModel_BMP280;
break;
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
switch(id[0]) {
case ChipModel_BME280:
m_chip_model = ChipModel_BME280;
break;
case ChipModel_BMP280:
m_chip_model = ChipModel_BMP280;
break;
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
return true;
return true;
}
/****************************************************************/
void BME280::WriteSettings(){
// ctrl_hum register. (ctrl_hum[2:0] = Humidity oversampling rate.)
uint8_t ctrlHum = (uint8_t)OSR_X1;
// ctrl_meas register. (ctrl_meas[7:5] = temperature oversampling rate, ctrl_meas[4:2] = pressure oversampling rate, ctrl_meas[1:0] = mode.)
uint8_t ctrlMeas = ((uint8_t)OSR_X1 << 5) | ((uint8_t)OSR_X1 << 2) | (uint8_t)Mode_Forced;
// config register. (config[7:5] = standby time, config[4:2] = filter, ctrl_meas[0] = spi enable.)
uint8_t config = ((uint8_t)StandbyTime_1000ms << 5) | ((uint8_t)Filter_Off << 2) | 0;
void BME280::WriteSettings() {
// ctrl_hum register. (ctrl_hum[2:0] = Humidity oversampling rate.)
uint8_t ctrlHum = (uint8_t)OSR_X1;
// ctrl_meas register. (ctrl_meas[7:5] = temperature oversampling rate, ctrl_meas[4:2] = pressure oversampling rate, ctrl_meas[1:0] = mode.)
uint8_t ctrlMeas = ((uint8_t)OSR_X1 << 5) | ((uint8_t)OSR_X1 << 2) | (uint8_t)Mode_Forced;
// config register. (config[7:5] = standby time, config[4:2] = filter, ctrl_meas[0] = spi enable.)
uint8_t config = ((uint8_t)StandbyTime_1000ms << 5) | ((uint8_t)Filter_Off << 2) | 0;
WriteRegister(CTRL_HUM_ADDR, ctrlHum);
WriteRegister(CTRL_MEAS_ADDR, ctrlMeas);
WriteRegister(CONFIG_ADDR, config);
WriteRegister(CTRL_HUM_ADDR, ctrlHum);
WriteRegister(CTRL_MEAS_ADDR, ctrlMeas);
WriteRegister(CONFIG_ADDR, config);
}
/****************************************************************/
bool BME280::begin(){
bool success = Initialize();
success &= m_initialized;
return success;
bool BME280::begin() {
bool success = Initialize();
success &= m_initialized;
return success;
}
/****************************************************************/
bool BME280::reset(){
WriteRegister(RESET_ADDR, RESET_VALUE);
delay(2); //max. startup time according to datasheet
return(begin());
bool BME280::reset() {
WriteRegister(RESET_ADDR, RESET_VALUE);
delay(2); //max. startup time according to datasheet
return(begin());
}
/****************************************************************/
bool BME280::ReadTrim(){
uint8_t ord(0);
bool success = true;
bool BME280::ReadTrim() {
uint8_t ord(0);
bool success = true;
// Temp. Dig
success &= ReadRegister(TEMP_DIG_ADDR, &m_dig[ord], TEMP_DIG_LENGTH);
ord += TEMP_DIG_LENGTH;
// Temp. Dig
success &= ReadRegister(TEMP_DIG_ADDR, &m_dig[ord], TEMP_DIG_LENGTH);
ord += TEMP_DIG_LENGTH;
// Pressure Dig
success &= ReadRegister(PRESS_DIG_ADDR, &m_dig[ord], PRESS_DIG_LENGTH);
ord += PRESS_DIG_LENGTH;
// Pressure Dig
success &= ReadRegister(PRESS_DIG_ADDR, &m_dig[ord], PRESS_DIG_LENGTH);
ord += PRESS_DIG_LENGTH;
// Humidity Dig 1
success &= ReadRegister(HUM_DIG_ADDR1, &m_dig[ord], HUM_DIG_ADDR1_LENGTH);
ord += HUM_DIG_ADDR1_LENGTH;
// Humidity Dig 1
success &= ReadRegister(HUM_DIG_ADDR1, &m_dig[ord], HUM_DIG_ADDR1_LENGTH);
ord += HUM_DIG_ADDR1_LENGTH;
// Humidity Dig 2
success &= ReadRegister(HUM_DIG_ADDR2, &m_dig[ord], HUM_DIG_ADDR2_LENGTH);
ord += HUM_DIG_ADDR2_LENGTH;
// Humidity Dig 2
success &= ReadRegister(HUM_DIG_ADDR2, &m_dig[ord], HUM_DIG_ADDR2_LENGTH);
ord += HUM_DIG_ADDR2_LENGTH;
#ifdef DEBUG_ON
Serial.print("Dig: ");
for(int i = 0; i < 32; ++i){
Serial.print(m_dig[i], HEX);
Serial.print(" ");
}
Serial.println();
#endif
return success && ord == DIG_LENGTH;
return success && ord == DIG_LENGTH;
}
/****************************************************************/
bool BME280::ReadData(int32_t data[SENSOR_DATA_LENGTH]){
bool success;
uint8_t buffer[SENSOR_DATA_LENGTH];
bool BME280::ReadData(int32_t data[SENSOR_DATA_LENGTH]) {
bool success;
uint8_t buffer[SENSOR_DATA_LENGTH];
WriteSettings(); //IF Forced Mode
WriteSettings(); //IF Forced Mode
success = ReadRegister(PRESS_ADDR, buffer, SENSOR_DATA_LENGTH);
success = ReadRegister(PRESS_ADDR, buffer, SENSOR_DATA_LENGTH);
for(int i = 0; i < SENSOR_DATA_LENGTH; ++i){
data[i] = static_cast<int32_t>(buffer[i]);
}
return success;
for(int i = 0; i < SENSOR_DATA_LENGTH; ++i) {
data[i] = static_cast<int32_t>(buffer[i]);
}
return success;
}
/****************************************************************/
float BME280::CalculateTemperature(int32_t raw,int32_t& t_fine){
// Code based on calibration algorthim provided by Bosch.
int32_t var1, var2, final;
uint16_t dig_T1 = (m_dig[1] << 8) | m_dig[0];
int16_t dig_T2 = (m_dig[3] << 8) | m_dig[2];
int16_t dig_T3 = (m_dig[5] << 8) | m_dig[4];
var1 = ((((raw >> 3) - ((int32_t)dig_T1 << 1))) * ((int32_t)dig_T2)) >> 11;
var2 = (((((raw >> 4) - ((int32_t)dig_T1)) * ((raw >> 4) - ((int32_t)dig_T1))) >> 12) * ((int32_t)dig_T3)) >> 14;
t_fine = var1 + var2;
final = (t_fine * 5 + 128) >> 8;
return final/100.0;
float BME280::CalculateTemperature(int32_t raw,int32_t& t_fine) {
// Code based on calibration algorthim provided by Bosch.
int32_t var1, var2, final;
uint16_t dig_T1 = (m_dig[1] << 8) | m_dig[0];
int16_t dig_T2 = (m_dig[3] << 8) | m_dig[2];
int16_t dig_T3 = (m_dig[5] << 8) | m_dig[4];
var1 = ((((raw >> 3) - ((int32_t)dig_T1 << 1))) * ((int32_t)dig_T2)) >> 11;
var2 = (((((raw >> 4) - ((int32_t)dig_T1)) * ((raw >> 4) - ((int32_t)dig_T1))) >> 12) * ((int32_t)dig_T3)) >> 14;
t_fine = var1 + var2;
final = (t_fine * 5 + 128) >> 8;
return final/100.0;
}
/****************************************************************/
float BME280::CalculateHumidity
(
int32_t raw,
int32_t t_fine
int32_t raw,
int32_t t_fine
)
{
// Code based on calibration algorthim provided by Bosch.
int32_t var1;
uint8_t dig_H1 = m_dig[24];
int16_t dig_H2 = (m_dig[26] << 8) | m_dig[25];
uint8_t dig_H3 = m_dig[27];
int16_t dig_H4 = ((int8_t)m_dig[28] * 16) | (0x0F & m_dig[29]);
int16_t dig_H5 = ((int8_t)m_dig[30] * 16) | ((m_dig[29] >> 4) & 0x0F);
int8_t dig_H6 = m_dig[31];
// Code based on calibration algorthim provided by Bosch.
int32_t var1;
uint8_t dig_H1 = m_dig[24];
int16_t dig_H2 = (m_dig[26] << 8) | m_dig[25];
uint8_t dig_H3 = m_dig[27];
int16_t dig_H4 = ((int8_t)m_dig[28] * 16) | (0x0F & m_dig[29]);
int16_t dig_H5 = ((int8_t)m_dig[30] * 16) | ((m_dig[29] >> 4) & 0x0F);
int8_t dig_H6 = m_dig[31];
var1 = (t_fine - ((int32_t)76800));
var1 = (((((raw << 14) - (((int32_t)dig_H4) << 20) - (((int32_t)dig_H5) * var1)) +
((int32_t)16384)) >> 15) * (((((((var1 * ((int32_t)dig_H6)) >> 10) * (((var1 *
((int32_t)dig_H3)) >> 11) + ((int32_t)32768))) >> 10) + ((int32_t)2097152)) *
((int32_t)dig_H2) + 8192) >> 14));
var1 = (var1 - (((((var1 >> 15) * (var1 >> 15)) >> 7) * ((int32_t)dig_H1)) >> 4));
var1 = (var1 < 0 ? 0 : var1);
var1 = (var1 > 419430400 ? 419430400 : var1);
return ((uint32_t)(var1 >> 12))/1024.0;
var1 = (t_fine - ((int32_t)76800));
var1 = (((((raw << 14) - (((int32_t)dig_H4) << 20) - (((int32_t)dig_H5) * var1)) +
((int32_t)16384)) >> 15) * (((((((var1 * ((int32_t)dig_H6)) >> 10) * (((var1 *
((int32_t)dig_H3)) >> 11) + ((int32_t)32768))) >> 10) + ((int32_t)2097152)) *
((int32_t)dig_H2) + 8192) >> 14));
var1 = (var1 - (((((var1 >> 15) * (var1 >> 15)) >> 7) * ((int32_t)dig_H1)) >> 4));
var1 = (var1 < 0 ? 0 : var1);
var1 = (var1 > 419430400 ? 419430400 : var1);
return ((uint32_t)(var1 >> 12))/1024.0;
}
/****************************************************************/
float BME280::CalculatePressure(int32_t raw,int32_t t_fine,PresUnit unit){
// Code based on calibration algorthim provided by Bosch.
int64_t var1, var2, pressure;
float final;
float BME280::CalculatePressure(int32_t raw,int32_t t_fine,PresUnit unit) {
// Code based on calibration algorthim provided by Bosch.
int64_t var1, var2, pressure;
float final;
uint16_t dig_P1 = (m_dig[7] << 8) | m_dig[6];
int16_t dig_P2 = (m_dig[9] << 8) | m_dig[8];
int16_t dig_P3 = (m_dig[11] << 8) | m_dig[10];
int16_t dig_P4 = (m_dig[13] << 8) | m_dig[12];
int16_t dig_P5 = (m_dig[15] << 8) | m_dig[14];
int16_t dig_P6 = (m_dig[17] << 8) | m_dig[16];
int16_t dig_P7 = (m_dig[19] << 8) | m_dig[18];
int16_t dig_P8 = (m_dig[21] << 8) | m_dig[20];
int16_t dig_P9 = (m_dig[23] << 8) | m_dig[22];
uint16_t dig_P1 = (m_dig[7] << 8) | m_dig[6];
int16_t dig_P2 = (m_dig[9] << 8) | m_dig[8];
int16_t dig_P3 = (m_dig[11] << 8) | m_dig[10];
int16_t dig_P4 = (m_dig[13] << 8) | m_dig[12];
int16_t dig_P5 = (m_dig[15] << 8) | m_dig[14];
int16_t dig_P6 = (m_dig[17] << 8) | m_dig[16];
int16_t dig_P7 = (m_dig[19] << 8) | m_dig[18];
int16_t dig_P8 = (m_dig[21] << 8) | m_dig[20];
int16_t dig_P9 = (m_dig[23] << 8) | m_dig[22];
var1 = (int64_t)t_fine - 128000;
var2 = var1 * var1 * (int64_t)dig_P6;
var2 = var2 + ((var1 * (int64_t)dig_P5) << 17);
var2 = var2 + (((int64_t)dig_P4) << 35);
var1 = ((var1 * var1 * (int64_t)dig_P3) >> 8) + ((var1 * (int64_t)dig_P2) << 12);
var1 = (((((int64_t)1) << 47) + var1)) * ((int64_t)dig_P1) >> 33;
if (var1 == 0) { return NAN; } // Don't divide by zero.
pressure = 1048576 - raw;
pressure = (((pressure << 31) - var2) * 3125)/var1;
var1 = (((int64_t)dig_P9) * (pressure >> 13) * (pressure >> 13)) >> 25;
var2 = (((int64_t)dig_P8) * pressure) >> 19;
pressure = ((pressure + var1 + var2) >> 8) + (((int64_t)dig_P7) << 4);
var1 = (int64_t)t_fine - 128000;
var2 = var1 * var1 * (int64_t)dig_P6;
var2 = var2 + ((var1 * (int64_t)dig_P5) << 17);
var2 = var2 + (((int64_t)dig_P4) << 35);
var1 = ((var1 * var1 * (int64_t)dig_P3) >> 8) + ((var1 * (int64_t)dig_P2) << 12);
var1 = (((((int64_t)1) << 47) + var1)) * ((int64_t)dig_P1) >> 33;
if (var1 == 0) {
return NAN; // Don't divide by zero.
}
pressure = 1048576 - raw;
pressure = (((pressure << 31) - var2) * 3125)/var1;
var1 = (((int64_t)dig_P9) * (pressure >> 13) * (pressure >> 13)) >> 25;
var2 = (((int64_t)dig_P8) * pressure) >> 19;
pressure = ((pressure + var1 + var2) >> 8) + (((int64_t)dig_P7) << 4);
final = ((uint32_t)pressure)/256.0;
final = ((uint32_t)pressure)/256.0;
// Conversion units courtesy of www.endmemo.com.
switch(unit){
case PresUnit_hPa: /* hPa */
final /= 100.0;
break;
case PresUnit_atm: /* atm */
final /= 101324.99766353; /* final pa * 1 atm/101324.99766353Pa */
break;
case PresUnit_bar: /* bar */
final /= 100000.0; /* final pa * 1 bar/100kPa */
break;
default: /* Pa (case: 0) */
break;
}
return final;
// Conversion units courtesy of www.endmemo.com.
switch(unit) {
case PresUnit_hPa: /* hPa */
final /= 100.0;
break;
case PresUnit_atm: /* atm */
final /= 101324.99766353; /* final pa * 1 atm/101324.99766353Pa */
break;
case PresUnit_bar: /* bar */
final /= 100000.0; /* final pa * 1 bar/100kPa */
break;
default: /* Pa (case: 0) */
break;
}
return final;
}
/****************************************************************/
float BME280::temp(){
if(!m_initialized) return 0;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)){ return NAN; }
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
return CalculateTemperature(rawTemp, t_fine);
float BME280::temp() {
if(!m_initialized) return 0;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)) {
return NAN;
}
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
return CalculateTemperature(rawTemp, t_fine);
}
/****************************************************************/
float BME280::pres(PresUnit unit){
if(!m_initialized) return 0;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)){ return NAN; }
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
uint32_t rawPressure = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4);
CalculateTemperature(rawTemp, t_fine);
return CalculatePressure(rawPressure, t_fine);
float BME280::pres(PresUnit unit) {
if(!m_initialized) return 0;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)) {
return NAN;
}
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
uint32_t rawPressure = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4);
CalculateTemperature(rawTemp, t_fine);
return CalculatePressure(rawPressure, t_fine);
}
/****************************************************************/
float BME280::hum(){
if(!m_initialized) return 0;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)){ return NAN; }
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
uint32_t rawHumidity = (data[6] << 8) | data[7];
CalculateTemperature(rawTemp, t_fine);
return CalculateHumidity(rawHumidity, t_fine);
float BME280::hum() {
if(!m_initialized) return 0;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)) {
return NAN;
}
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
uint32_t rawHumidity = (data[6] << 8) | data[7];
CalculateTemperature(rawTemp, t_fine);
return CalculateHumidity(rawHumidity, t_fine);
}
/****************************************************************/
void BME280::read(float& pressure,float& temp,float& humidity,PresUnit presUnit){
if(!m_initialized) return;
void BME280::read(float& pressure,float& temp,float& humidity,PresUnit presUnit) {
if(!m_initialized) return;
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)){
pressure = temp = humidity = NAN;
return;
}
uint32_t rawPressure = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4);
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
uint32_t rawHumidity = (data[6] << 8) | data[7];
temp = CalculateTemperature(rawTemp, t_fine);
pressure = CalculatePressure(rawPressure, t_fine, presUnit);
humidity = CalculateHumidity(rawHumidity, t_fine);
int32_t data[8];
int32_t t_fine;
if(!ReadData(data)) {
pressure = temp = humidity = NAN;
return;
}
uint32_t rawPressure = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4);
uint32_t rawTemp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4);
uint32_t rawHumidity = (data[6] << 8) | data[7];
temp = CalculateTemperature(rawTemp, t_fine);
pressure = CalculatePressure(rawPressure, t_fine, presUnit);
humidity = CalculateHumidity(rawHumidity, t_fine);
}
/****************************************************************/
BME280::ChipModel BME280::chipModel(){
return m_chip_model;
BME280::ChipModel BME280::chipModel() {
return m_chip_model;
}
/****************************************************************/
bool BME280::WriteRegister(uint8_t addr, uint8_t data){
i2c->beginTransmission(BME280_ADDRESS);
i2c->write(addr);
i2c->write(data);
i2c->endTransmission();
bool BME280::WriteRegister(uint8_t addr, uint8_t data) {
i2c->beginTransmission(BME280_ADDRESS);
i2c->write(addr);
i2c->write(data);
i2c->endTransmission();
return true;
return true;
}
/****************************************************************/
bool BME280::ReadRegister
(
uint8_t addr,
uint8_t data[],
uint8_t length
uint8_t addr,
uint8_t data[],
uint8_t length
)
{
uint8_t ord(0);
uint8_t ord(0);
i2c->beginTransmission(BME280_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->beginTransmission(BME280_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->requestFrom(static_cast<uint8_t>(BME280_ADDRESS), length);
i2c->requestFrom(static_cast<uint8_t>(BME280_ADDRESS), length);
while(i2c->available())
{
data[ord++] = i2c->read();
}
while(i2c->available())
{
data[ord++] = i2c->read();
}
return ord == length;
return ord == length;
}

88
src/sensor/dev/bme280.h
View File

@ -13,57 +13,57 @@
/// Based on the data sheet provided by Bosch for
/// the Bme280 environmental sensor.
///
class BME280{
public:
class BME280 {
public:
enum PresUnit{
PresUnit_Pa,
PresUnit_hPa,
PresUnit_atm,
PresUnit_bar,
};
enum PresUnit {
PresUnit_Pa,
PresUnit_hPa,
PresUnit_atm,
PresUnit_bar,
};
enum OSR{
OSR_Off = 0,
OSR_X1 = 1,
OSR_X2 = 2,
OSR_X4 = 3,
OSR_X8 = 4,
OSR_X16 = 5
};
enum OSR {
OSR_Off = 0,
OSR_X1 = 1,
OSR_X2 = 2,
OSR_X4 = 3,
OSR_X8 = 4,
OSR_X16 = 5
};
enum Mode{
Mode_Sleep = 0,
Mode_Forced = 1,
Mode_Normal = 3
};
enum Mode {
Mode_Sleep = 0,
Mode_Forced = 1,
Mode_Normal = 3
};
enum StandbyTime{
StandbyTime_500us = 0,
StandbyTime_62500us = 1,
StandbyTime_125ms = 2,
StandbyTime_250ms = 3,
StandbyTime_50ms = 4,
StandbyTime_1000ms = 5,
StandbyTime_10ms = 6,
StandbyTime_20ms = 7
};
enum StandbyTime {
StandbyTime_500us = 0,
StandbyTime_62500us = 1,
StandbyTime_125ms = 2,
StandbyTime_250ms = 3,
StandbyTime_50ms = 4,
StandbyTime_1000ms = 5,
StandbyTime_10ms = 6,
StandbyTime_20ms = 7
};
enum Filter{
Filter_Off = 0,
Filter_2 = 1,
Filter_4 = 2,
Filter_8 = 3,
Filter_16 = 4
};
enum Filter {
Filter_Off = 0,
Filter_2 = 1,
Filter_4 = 2,
Filter_8 = 3,
Filter_16 = 4
};
enum ChipModel{
ChipModel_UNKNOWN = 0,
ChipModel_BMP280 = 0x58,
ChipModel_BME280 = 0x60
};
enum ChipModel {
ChipModel_UNKNOWN = 0,
ChipModel_BMP280 = 0x58,
ChipModel_BME280 = 0x60
};
BME280(TwoWire* i2c): m_initialized(false), i2c(i2c){}
BME280(TwoWire* i2c): m_initialized(false), i2c(i2c) {}
ChipModel chipModel();
bool begin();

165
src/sensor/dev/ltr390.cpp
View File

@ -2,136 +2,139 @@
/****************************************************************/
bool LTR390::Initialize(){
bool success(true);
bool LTR390::Initialize() {
bool success(true);
success &= ReadChipID();
success &= ReadChipID();
if(success){
WriteSettings();
}
m_initialized = success;
return m_initialized;
if(success) {
WriteSettings();
}
m_initialized = success;
return m_initialized;
}
/****************************************************************/
bool LTR390::ReadChipID(){
uint8_t id;
bool LTR390::ReadChipID() {
uint8_t id;
ReadRegister(ID_ADDR, &id, 1);
ReadRegister(ID_ADDR, &id, 1);
switch(id){
case ChipModel_LTR390_REV0:
m_chip_model = ChipModel_LTR390_REV0;
break;
case ChipModel_LTR390_REV1:
m_chip_model = ChipModel_LTR390_REV1;
break;
case ChipModel_LTR390_REV2:
m_chip_model = ChipModel_LTR390_REV2;
break;
case ChipModel_LTR390_REV3:
m_chip_model = ChipModel_LTR390_REV3;
break;
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
switch(id) {
case ChipModel_LTR390_REV0:
m_chip_model = ChipModel_LTR390_REV0;
break;
case ChipModel_LTR390_REV1:
m_chip_model = ChipModel_LTR390_REV1;
break;
case ChipModel_LTR390_REV2:
m_chip_model = ChipModel_LTR390_REV2;
break;
case ChipModel_LTR390_REV3:
m_chip_model = ChipModel_LTR390_REV3;
break;
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
return true;
return true;
}
/****************************************************************/
void LTR390::WriteSettings(){
uint8_t ctrlMeas = LTR390_RESOLUTION_16BIT | LTR390_RATE_1000;
uint8_t ctrlGain = LTR390_GAIN_3;
uint8_t ctrlMode = LTR390_ON | LTR390_MODE_UVS;
void LTR390::WriteSettings() {
WriteRegister(MAIN_CTRL, LTR390_ON | LTR390_MODE_UVS);
WriteRegister(MEAS_RATE, LTR390_RESOLUTION_16BIT | LTR390_RATE_1000);
WriteRegister(GAIN, LTR390_GAIN_18);
WriteRegister(MEAS_RATE, ctrlMeas);
WriteRegister(GAIN, ctrlGain);
WriteRegister(MAIN_CTRL, ctrlMode);
// WriteRegister(THRESH_LOW, 100);
// WriteRegister(THRESH_UP, 1000);
// WriteRegister(INT_CFG, 0x30 | 0x04);
}
/****************************************************************/
bool LTR390::begin(){
bool success = Initialize();
success &= m_initialized;
return success;
bool LTR390::begin() {
bool success = Initialize();
success &= m_initialized;
return success;
}
/****************************************************************/
bool LTR390::reset(){
WriteRegister(RESET_ADDR, RESET_VALUE);
delay(10); //max. startup time according to datasheet
return(begin());
bool LTR390::reset() {
WriteRegister(RESET_ADDR, RESET_VALUE);
delay(10); //max. startup time according to datasheet
return(begin());
}
/****************************************************************/
bool LTR390::ReadData(int32_t data[SENSOR_DATA_LENGTH], uint32_t addr){
bool success;
uint8_t buffer[SENSOR_DATA_LENGTH];
bool LTR390::ReadData(int32_t data[SENSOR_DATA_LENGTH], uint32_t addr) {
bool success;
uint8_t buffer[SENSOR_DATA_LENGTH];
// WriteSettings();
// WriteSettings();
success = ReadRegister(addr, buffer, SENSOR_DATA_LENGTH);
success = ReadRegister(addr, buffer, SENSOR_DATA_LENGTH);
for(int i = 0; i < SENSOR_DATA_LENGTH; ++i){
data[i] = static_cast<int32_t>(buffer[i]);
}
for(int i = 0; i < SENSOR_DATA_LENGTH; ++i) {
data[i] = static_cast<int32_t>(buffer[i]);
}
return success;
return success;
}
/****************************************************************/
uint32_t LTR390::uv(){
if(!m_initialized) return 0;
int32_t data[SENSOR_DATA_LENGTH];
if(!ReadData(data, UVSDATA)){ return 0; }
uint32_t rawUV = (data[2] << 16) | (data[1] << 8) | (data[0]);
return rawUV;
uint32_t LTR390::uv() {
if(!m_initialized) return 0;
int32_t data[SENSOR_DATA_LENGTH];
if(!ReadData(data, UVSDATA)) {
return 0;
}
uint32_t rawUV = (data[2] << 16) | (data[1] << 8) | (data[0]);
return rawUV;
}
void LTR390::read(uint32_t& uvs, uint32_t& uvi){
if(!m_initialized) return;
uvs = uv();
uvi = (uvs/ (3*0.25))*3;
void LTR390::read(uint32_t& uvs, uint32_t& uvi) {
if(!m_initialized) return;
uvs = uv();
uvi = (uvs/ 2300)*2;
}
/****************************************************************/
LTR390::ChipModel LTR390::chipModel(){
return m_chip_model;
LTR390::ChipModel LTR390::chipModel() {
return m_chip_model;
}
/****************************************************************/
bool LTR390::WriteRegister(uint8_t addr, uint8_t data){
i2c->beginTransmission(LTR390_ADDRESS);
i2c->write(addr);
i2c->write(data);
i2c->endTransmission();
bool LTR390::WriteRegister(uint8_t addr, uint8_t data) {
i2c->beginTransmission(LTR390_ADDRESS);
i2c->write(addr);
i2c->write(data);
i2c->endTransmission();
return true;
return true;
}
/****************************************************************/
bool LTR390::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length){
uint8_t ord(0);
bool LTR390::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length) {
uint8_t ord(0);
i2c->beginTransmission(LTR390_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->beginTransmission(LTR390_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->requestFrom(static_cast<uint8_t>(LTR390_ADDRESS), length);
i2c->requestFrom(static_cast<uint8_t>(LTR390_ADDRESS), length);
while(i2c->available()){
data[ord++] = i2c->read();
}
while(i2c->available()) {
data[ord++] = i2c->read();
}
return ord == length;
return ord == length;
}

10
src/sensor/dev/ltr390.h
View File

@ -11,8 +11,8 @@
///
/// Based on the data sheet provided
///
class LTR390{
public:
class LTR390 {
public:
typedef enum {
LTR390_ON = 0x2,
@ -51,15 +51,15 @@ class LTR390{
LTR390_RATE_2000 = 0x6,
} ltr390_rate_t;
enum ChipModel{
enum ChipModel {
ChipModel_UNKNOWN = 0,
ChipModel_LTR390_REV0 = 0xB0,
ChipModel_LTR390_REV1 = 0xB1,
ChipModel_LTR390_REV2 = 0xB2,
ChipModel_LTR390_REV3 = 0xB3,
};
};
LTR390(TwoWire* i2c): m_initialized(false),i2c(i2c){}
LTR390(TwoWire* i2c): m_initialized(false),i2c(i2c) {}
ChipModel chipModel();

155
src/sensor/dev/pmsa003.cpp
View File

@ -7,128 +7,129 @@
#define SENSOR_DATA_LENGTH 32
/****************************************************************/
bool PMSA003::Initialize(){
bool success(true);
bool PMSA003::Initialize() {
bool success(true);
success &= ReadChipID();
success &= ReadChipID();
if(success) success = WriteSettings();
m_initialized = success;
return m_initialized;
if(success) success = WriteSettings();
m_initialized = success;
return m_initialized;
}
/****************************************************************/
bool PMSA003::ReadChipID(){
uint8_t id = 0;
bool PMSA003::ReadChipID() {
uint8_t id = 0;
ReadRegister(REG_VERSION, &id, 1);
Serial.print("PMSSA DEV: ");Serial.println(id);
// switch(id){
// case ChipModel_PMSA003_REV0:
// m_chip_model = ChipModel_PMSA003_REV0;
// break;
// default:
// m_chip_model = ChipModel_UNKNOWN;
// return false;
// }
ReadRegister(REG_VERSION, &id, 1);
Serial.print("PMSSA DEV: ");
Serial.println(id);
// switch(id){
// case ChipModel_PMSA003_REV0:
// m_chip_model = ChipModel_PMSA003_REV0;
// break;
// default:
// m_chip_model = ChipModel_UNKNOWN;
// return false;
// }
return true;
return true;
}
/****************************************************************/
bool PMSA003::WriteSettings(){
return true; //No settings
bool PMSA003::WriteSettings() {
return true; //No settings
}
/****************************************************************/
bool PMSA003::begin(){
bool success = Initialize();
success &= m_initialized;
return success;
bool PMSA003::begin() {
bool success = Initialize();
success &= m_initialized;
return success;
}
/****************************************************************/
bool PMSA003::reset(){
return true; //Cannot be reset
bool PMSA003::reset() {
return true; //Cannot be reset
}
/****************************************************************/
bool PMSA003::ReadData(uint8_t data[SENSOR_DATA_LENGTH]){
bool PMSA003::ReadData(uint8_t data[SENSOR_DATA_LENGTH]) {
ReadRegister(REG_Char1,data,SENSOR_DATA_LENGTH);
if (data[0] != 0x42 || data[1] != 0x4d) return false;
ReadRegister(REG_Char1,data,SENSOR_DATA_LENGTH);
uint16_t sum = 0;
for (uint8_t i = 0; i < 30; i++) sum += data[i];
uint16_t checksum = data[30]<<8 | data[31];
if (sum != checksum) return false;
if (data[0] != 0x42 || data[1] != 0x4d) return false;
return true;
uint16_t sum = 0;
for (uint8_t i = 0; i < 30; i++) sum += data[i];
uint16_t checksum = data[30]<<8 | data[31];
if (sum != checksum) return false;
return true;
}
/****************************************************************/
void PMSA003::read(PM25_AQI_Data& data){
if(!m_initialized) return;
uint8_t rd[SENSOR_DATA_LENGTH];
if(!ReadData(rd)) return;
uint16_t md[16] = {0};
for (uint8_t i = 0; i < 15; i++) {
md[i] = rd[i * 2] << 8;
md[i] |= rd[i * 2 + 1];
}
void PMSA003::read(PM25_AQI_Data& data) {
if(!m_initialized) return;
uint8_t rd[SENSOR_DATA_LENGTH];
if(!ReadData(rd)) return;
uint16_t md[16] = {0};
for (uint8_t i = 0; i < 15; i++) {
md[i] = rd[i * 2] << 8;
md[i] |= rd[i * 2 + 1];
}
data.pm10_standard = md[2];
data.pm25_standard = md[3];
data.pm100_standard = md[4];
data.pm10_env = md[5];
data.pm25_env = md[6];
data.pm100_env = md[7];
data.particles_03um = md[8];
data.particles_05um = md[9];
data.particles_10um = md[10];
data.particles_25um = md[11];
data.particles_50um = md[12];
data.particles_100um = md[13];
data.pm10_standard = md[2];
data.pm25_standard = md[3];
data.pm100_standard = md[4];
data.pm10_env = md[5];
data.pm25_env = md[6];
data.pm100_env = md[7];
data.particles_03um = md[8];
data.particles_05um = md[9];
data.particles_10um = md[10];
data.particles_25um = md[11];
data.particles_50um = md[12];
data.particles_100um = md[13];
}
/****************************************************************/
PMSA003::ChipModel PMSA003::chipModel(){
return m_chip_model;
PMSA003::ChipModel PMSA003::chipModel() {
return m_chip_model;
}
/****************************************************************/
bool PMSA003::WriteRegister(uint16_t addr, uint8_t data){
i2c->beginTransmission(PMSA003_ADDRESS);
i2c->write(highByte(addr));
i2c->write(lowByte(addr));
i2c->write(data);
i2c->endTransmission();
bool PMSA003::WriteRegister(uint16_t addr, uint8_t data) {
i2c->beginTransmission(PMSA003_ADDRESS);
i2c->write(highByte(addr));
i2c->write(lowByte(addr));
i2c->write(data);
i2c->endTransmission();
return true;
return true;
}
/****************************************************************/
bool PMSA003::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length){
uint8_t ord(0);
bool PMSA003::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length) {
uint8_t ord(0);
i2c->beginTransmission(PMSA003_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->beginTransmission(PMSA003_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->requestFrom(static_cast<uint8_t>(PMSA003_ADDRESS), length);
i2c->requestFrom(static_cast<uint8_t>(PMSA003_ADDRESS), length);
while(i2c->available()){
data[ord++] = i2c->read();
}
while(i2c->available()) {
data[ord++] = i2c->read();
}
return ord == length;
return ord == length;
}

48
src/sensor/dev/pmsa003.h
View File

@ -9,18 +9,18 @@
typedef struct PMSAQIdata {
uint16_t pm10_standard, ///< Standard PM1.0
pm25_standard, ///< Standard PM2.5
pm100_standard; ///< Standard PM10.0
uint16_t pm10_env, ///< Environmental PM1.0
pm25_env, ///< Environmental PM2.5
pm100_env; ///< Environmental PM10.0
uint16_t particles_03um, ///< 0.3um Particle Count
particles_05um, ///< 0.5um Particle Count
particles_10um, ///< 1.0um Particle Count
particles_25um, ///< 2.5um Particle Count
particles_50um, ///< 5.0um Particle Count
particles_100um; ///< 10.0um Particle Count
uint16_t pm10_standard, ///< Standard PM1.0
pm25_standard, ///< Standard PM2.5
pm100_standard; ///< Standard PM10.0
uint16_t pm10_env, ///< Environmental PM1.0
pm25_env, ///< Environmental PM2.5
pm100_env; ///< Environmental PM10.0
uint16_t particles_03um, ///< 0.3um Particle Count
particles_05um, ///< 0.5um Particle Count
particles_10um, ///< 1.0um Particle Count
particles_25um, ///< 2.5um Particle Count
particles_50um, ///< 5.0um Particle Count
particles_100um; ///< 10.0um Particle Count
} PM25_AQI_Data;
//////////////////////////////////////////////////////////////////
@ -28,16 +28,16 @@ typedef struct PMSAQIdata {
///
/// Based on the data sheet provided
///
class PMSA003{
public:
class PMSA003 {
public:
enum ChipModel{
enum ChipModel {
ChipModel_UNKNOWN = 0,
ChipModel_PMSA003_REV0 = 0x10
};
};
PMSA003(TwoWire* i2c): m_initialized(false),i2c(i2c){}
PMSA003(TwoWire* i2c): m_initialized(false),i2c(i2c) {}
ChipModel chipModel();
@ -58,7 +58,7 @@ private:
static const uint8_t REG_Char1 = 0x00; // 0x42
static const uint8_t REG_Char2 = 0x01; // 0x4d
static const uint8_t REG_FrameH = 0x02; // Frame length = 2x13 + 2
static const uint8_t REG_FrameH = 0x02; // Frame length = 2x13 + 2
static const uint8_t REG_FrameL = 0x03; // --
static const uint8_t REG_d1h = 0x04; // PM1.0 ug/m3 (standard)
static const uint8_t REG_d1l = 0x05;
@ -72,17 +72,17 @@ private:
static const uint8_t REG_d5l = 0x0D;
static const uint8_t REG_d6h = 0x0E; // PM10 ug/m3 (atmospheric env)
static const uint8_t REG_d6l = 0x0F;
static const uint8_t REG_d7h = 0x10; // >0.3um/0.1L
static const uint8_t REG_d7h = 0x10; // >0.3um/0.1L
static const uint8_t REG_d7l = 0x11;
static const uint8_t REG_d8h = 0x12; // >0.5um/0.1L
static const uint8_t REG_d8h = 0x12; // >0.5um/0.1L
static const uint8_t REG_d8l = 0x13;
static const uint8_t REG_d9h = 0x14; // >1.0um/0.1L
static const uint8_t REG_d9h = 0x14; // >1.0um/0.1L
static const uint8_t REG_d9l = 0x15;
static const uint8_t REG_d10h = 0x16; // >2.5um/0.1L
static const uint8_t REG_d10h = 0x16; // >2.5um/0.1L
static const uint8_t REG_d10l = 0x17;
static const uint8_t REG_d11h = 0x18; // >5.0um/0.1L
static const uint8_t REG_d11h = 0x18; // >5.0um/0.1L
static const uint8_t REG_d11l = 0x19;
static const uint8_t REG_d12h = 0x1A; // >10.0um/0.1L
static const uint8_t REG_d12h = 0x1A; // >10.0um/0.1L
static const uint8_t REG_d12l = 0x1B;
static const uint8_t REG_VERSION = 0x1C; // Verion

156
src/sensor/dev/sgp40.cpp
View File

@ -1,40 +1,40 @@
#include "sgp40.h"
#include <Arduino.h>
#define SENSOR_DATA_LENGTH 3
/****************************************************************/
bool SGP40::Initialize(){
bool success(true);
bool SGP40::Initialize() {
bool success(true);
success &= ReadChipID();
success &= ReadChipID();
VocAlgorithm_init(&vocAlgorithmParameters);
VocAlgorithm_init(&vocAlgorithmParameters);
if(success) success = WriteSettings();
m_initialized = success;
return m_initialized;
if(success) success = WriteSettings();
m_initialized = success;
return m_initialized;
}
/****************************************************************/
bool SGP40::ReadChipID(){
uint8_t id = 0;
bool SGP40::ReadChipID() {
uint8_t id = 0;
//ReadRegister(ID_ADDR, &id, 1);
//ReadRegister(ID_ADDR, &id, 1);
switch(id){
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
switch(id) {
default:
m_chip_model = ChipModel_UNKNOWN;
//return false;
}
return true;
return true;
}
/****************************************************************/
bool SGP40::WriteSettings(){
bool SGP40::WriteSettings() {
uint8_t data[3];
uint8_t ord(0);
@ -47,7 +47,7 @@ bool SGP40::WriteSettings(){
i2c->requestFrom(static_cast<uint8_t>(SGP40_ADDRESS), uint8_t(3));
while(i2c->available()){
while(i2c->available()) {
data[ord++] = i2c->read();
}
if(ord != 3) return false;
@ -58,21 +58,21 @@ bool SGP40::WriteSettings(){
/****************************************************************/
bool SGP40::begin(){
bool success = Initialize();
success &= m_initialized;
return success;
bool SGP40::begin() {
bool success = Initialize();
success &= m_initialized;
return success;
}
/****************************************************************/
bool SGP40::reset(){
WriteRegister(RESET_ADDR, 0x02);
delay(10); //max. startup time according to datasheet
return(begin());
bool SGP40::reset() {
WriteRegister(RESET_ADDR, 0x02);
delay(10); //max. startup time according to datasheet
return(begin());
}
/****************************************************************/
bool SGP40::ReadData(uint8_t data[SENSOR_DATA_LENGTH], float RH, float T){
bool SGP40::ReadData(uint8_t data[SENSOR_DATA_LENGTH], float RH, float T) {
bool success;
uint8_t ord(0);
@ -81,7 +81,7 @@ bool SGP40::ReadData(uint8_t data[SENSOR_DATA_LENGTH], float RH, float T){
uint16_t RH_ticks = (uint16_t)(RH * 65535 / 100); // Convert RH from %RH to ticks
uint16_t T_ticks = (uint16_t)((T + 45) * 65535 / 175); // Convert T from DegC to ticks
i2c->beginTransmission(SGP40_ADDRESS);
i2c->write(highByte(REG_MEASURE_RAW));
i2c->write(lowByte(REG_MEASURE_RAW));
@ -100,7 +100,7 @@ bool SGP40::ReadData(uint8_t data[SENSOR_DATA_LENGTH], float RH, float T){
i2c->requestFrom(SGP40_ADDRESS, SENSOR_DATA_LENGTH);
while(i2c->available()){
while(i2c->available()) {
data[ord++] = i2c->read();
}
@ -109,73 +109,73 @@ bool SGP40::ReadData(uint8_t data[SENSOR_DATA_LENGTH], float RH, float T){
/****************************************************************/
int32_t SGP40::voc(float RH, float T){
if(!m_initialized) return 0;
uint8_t data[SENSOR_DATA_LENGTH];
ReadData(data, RH, T);
uint16_t results = (data[0]<<8) | data[1];
int32_t voci = 0;
VocAlgorithm_process(&vocAlgorithmParameters, results, &voci);
int32_t SGP40::voc(float RH, float T) {
if(!m_initialized) return 0;
uint8_t data[SENSOR_DATA_LENGTH];
ReadData(data, RH, T);
uint16_t results = (data[0]<<8) | data[1];
int32_t voci = 0;
VocAlgorithm_process(&vocAlgorithmParameters, results, &voci);
return voci;
return voci;
}
void SGP40::read(int32_t& voc, float RH, float T){
if(!m_initialized) return;
uint8_t data[SENSOR_DATA_LENGTH];
ReadData(data, RH, T);
uint16_t results = (data[0]<<8) | data[1];
VocAlgorithm_process(&vocAlgorithmParameters, results, &voc);
return;
void SGP40::read(int32_t& voc, float RH, float T) {
if(!m_initialized) return;
uint8_t data[SENSOR_DATA_LENGTH];
ReadData(data, RH, T);
uint16_t results = (data[0]<<8) | data[1];
VocAlgorithm_process(&vocAlgorithmParameters, results, &voc);
}
/****************************************************************/
SGP40::ChipModel SGP40::chipModel(){
return m_chip_model;
SGP40::ChipModel SGP40::chipModel() {
return m_chip_model;
}
/****************************************************************/
bool SGP40::WriteRegister(uint16_t addr, uint8_t data){
i2c->beginTransmission(SGP40_ADDRESS);
i2c->write(highByte(addr));
i2c->write(lowByte(addr));
i2c->write(data);
i2c->endTransmission();
bool SGP40::WriteRegister(uint16_t addr, uint8_t data) {
i2c->beginTransmission(SGP40_ADDRESS);
i2c->write(highByte(addr));
i2c->write(lowByte(addr));
i2c->write(data);
i2c->endTransmission();
return true;
return true;
}
/****************************************************************/
bool SGP40::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length){
uint8_t ord(0);
bool SGP40::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length) {
uint8_t ord(0);
i2c->beginTransmission(SGP40_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->beginTransmission(SGP40_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->requestFrom(static_cast<uint8_t>(SGP40_ADDRESS), length);
i2c->requestFrom(static_cast<uint8_t>(SGP40_ADDRESS), length);
while(i2c->available()){
data[ord++] = i2c->read();
}
while(i2c->available()) {
data[ord++] = i2c->read();
}
return ord == length;
return ord == length;
}
uint8_t SGP40::CRC8(uint16_t data){
uint8_t crc = 0xFF;
crc ^= (data >> 8);
for (uint8_t i = 0 ; i < 8 ; i++){
if ((crc & 0x80) != 0) crc = (uint8_t)((crc << 1) ^ 0x31);
else crc <<= 1;
}
crc ^= (uint8_t)data;
for (uint8_t i = 0 ; i < 8 ; i++){
if ((crc & 0x80) != 0) crc = (uint8_t)((crc << 1) ^ 0x31);
else crc <<= 1;
}
return crc;
uint8_t SGP40::CRC8(uint16_t data) {
uint8_t crc = 0xFF;
crc ^= (data >> 8);
for (uint8_t i = 0 ; i < 8 ; i++) {
if ((crc & 0x80) != 0) crc = (uint8_t)((crc << 1) ^ 0x31);
else crc <<= 1;
}
crc ^= (uint8_t)data;
for (uint8_t i = 0 ; i < 8 ; i++) {
if ((crc & 0x80) != 0) crc = (uint8_t)((crc << 1) ^ 0x31);
else crc <<= 1;
}
return crc;
}

13
src/sensor/dev/sgp40.h
View File

@ -1,7 +1,6 @@
#ifndef TG_SGP40_H
#define TG_SGP40_H
#include <Arduino.h>
#include <Wire.h>
#include "../voc.h"
@ -13,15 +12,15 @@
///
/// Based on the data sheet provided
///
class SGP40{
public:
class SGP40 {
public:
enum ChipModel{
enum ChipModel {
ChipModel_UNKNOWN = 0
};
};
SGP40(TwoWire* i2c): m_initialized(false),i2c(i2c){}
SGP40(TwoWire* i2c): m_initialized(false),i2c(i2c) {}
ChipModel chipModel();
@ -46,7 +45,7 @@ private:
static const uint16_t REG_MEASURE_TEST = 0x280E;
static const uint16_t REG_HEATER_OFF = 0x3615;
static const uint16_t RESET_ADDR = 0x0006;
static const uint16_t test_pass = 0xD400;
static const uint16_t test_fail = 0x4B00;

277
src/sensor/dev/tsl25911.cpp
View File

@ -1,16 +1,17 @@
#include "tsl25911.h"
#include <Arduino.h>
#define SENSOR_DATA_LENGTH 4
#define ENABLE_POWEROFF (0x00) ///< Flag for ENABLE register to disable
#define ENABLE_POWERON (0x01) ///< Flag for ENABLE register to enable
#define ENABLE_AEN (0x02) ///< ALS Enable. This field activates ALS function. Writing a one
///< activates the ALS. Writing a zero disables the ALS.
///< activates the ALS. Writing a zero disables the ALS.
#define ENABLE_AIEN (0x10) ///< ALS Interrupt Enable. When asserted permits ALS interrupts to be
///< generated, subject to the persist filter.
///< generated, subject to the persist filter.
#define ENABLE_NPIEN (0x80) ///< No Persist Interrupt Enable. When asserted NP Threshold conditions
///< will generate an interrupt, bypassing the persist filter
///< will generate an interrupt, bypassing the persist filter
#define LUX_DF (408.0F) ///< Lux cooefficient
#define LUX_COEFB (1.64F) ///< CH0 coefficient
@ -20,70 +21,67 @@
/****************************************************************/
bool TSL25911::Initialize(){
bool success(true);
bool TSL25911::Initialize() {
bool success(true);
success &= ReadChipID();
success &= ReadChipID();
if(success) WriteSettings();
m_initialized = success;
return m_initialized;
if(success) WriteSettings();
m_initialized = success;
return m_initialized;
}
/****************************************************************/
bool TSL25911::ReadChipID(){
uint8_t id;
ReadRegister(ID_ADDR, &id, 1);
switch(id){
case ChipModel_TSL25911_REV0:
m_chip_model = ChipModel_TSL25911_REV0;
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
return true;
bool TSL25911::ReadChipID() {
uint8_t id;
ReadRegister(ID_ADDR, &id, 1);
switch(id) {
case ChipModel_TSL25911_REV0:
m_chip_model = ChipModel_TSL25911_REV0;
break;
default:
m_chip_model = ChipModel_UNKNOWN;
return false;
}
return true;
}
/****************************************************************/
void TSL25911::WriteSettings(){
void TSL25911::WriteSettings() {
WriteRegister(REG_ENABLE, ENABLE_POWERON | ENABLE_AEN);
WriteRegister(REG_CTRL, integration | gain);
WriteRegister(REG_ENABLE,ENABLE_POWEROFF);
}
/****************************************************************/
bool TSL25911::begin(){
bool success = Initialize();
success &= m_initialized;
return success;
bool TSL25911::begin() {
bool success = Initialize();
success &= m_initialized;
return success;
}
/****************************************************************/
bool TSL25911::reset(){
bool TSL25911::reset() {
//Write RST REG ?
delay(10); //max. startup time according to datasheet
return(begin());
delay(10); //max. startup time according to datasheet
return(begin());
}
/****************************************************************/
bool TSL25911::ReadData(uint32_t data[SENSOR_DATA_LENGTH]){
bool success;
success &= WriteRegister(REG_ENABLE, ENABLE_POWERON | ENABLE_AEN);
bool TSL25911::ReadData(uint32_t* dataf) {
uint8_t* data = static_cast<uint8_t*>(static_cast<void*>(dataf));
bool success = WriteRegister(REG_ENABLE, ENABLE_POWERON | ENABLE_AEN);
delay((uint32_t)atime());
success &= ReadRegister(CHAN0_LOW,&data[0],2);
success &= ReadRegister(CHAN1_LOW,&data[2],2);
for (uint8_t d = 0; d <= integration; d++) // Wait x ms for ADC to complete
delay(120);
success &= ReadRegister(CHAN0_LOW,static_cast<uint8_t*>(static_cast<void*>(&data[0])),2);
success &= ReadRegister(CHAN1_LOW,static_cast<uint8_t*>(static_cast<void*>(&data[2])),2);
success &= WriteRegister(REG_ENABLE,ENABLE_POWEROFF);
return success;
@ -94,136 +92,135 @@ bool TSL25911::ReadData(uint32_t data[SENSOR_DATA_LENGTH]){
float ComputeLux(uint16_t ch0, uint16_t ch1, float atime, float again) {
float cpl, lux1, lux2, lux;
float cpl, lux1, lux2, lux;
if ((ch0 == 0xFFFF) | (ch1 == 0xFFFF)) return -1;
cpl = (atime * again) / LUX_DF;
lux = (((float)ch0 - (float)ch1)) * (1.0F - ((float)ch1 / (float)ch0)) / cpl;
return lux;
if ((ch0 == 0xFFFF) | (ch1 == 0xFFFF)) return -1;
cpl = (atime * again) / LUX_DF;
lux = (((float)ch0 - (float)ch1)) * (1.0F - ((float)ch1 / (float)ch0)) / cpl;
return lux;
}
uint16_t TSL25911::lumV(){
uint16_t TSL25911::lumV() {
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data))
return ((data & 0xFFFF) - (data >> 16));
return 0;
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data))
return ((data & 0xFFFF) - (data >> 16));
return 0;
}
uint16_t TSL25911::lumIR(){
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data))
return (data >> 16);
return 0;
uint16_t TSL25911::lumIR() {
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data))
return (data >> 16);
return 0;
}
uint16_t TSL25911::lumF(){
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data))
return (data & 0xFFFF);
return 0;
uint16_t TSL25911::lumF() {
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data))
return (data & 0xFFFF);
return 0;
}
float TSL25911::lumLux(){
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data)){
return ComputeLux(data&0xFFFF, data>>16,again(),atime());
}
return 0;
float TSL25911::lumLux() {
if(!m_initialized) return 0;
uint32_t data;
if(ReadData(&data)) {
return ComputeLux(data&0xFFFF, data>>16,again(),atime());
}
return 0;
}
void TSL25911::read(uint16_t& v, uint16_t& ir, uint16_t& f, float& lux){
if(!m_initialized) return;
uint32_t data;
if(ReadData(&data)){
v = ((data & 0xFFFF) - (data >> 16));
ir = (data >> 16);
f = (data & 0xFFFF);
lux = ComputeLux(data&0xFFFF,data>>16,again(),atime());
}
void TSL25911::read(uint16_t& v, uint16_t& ir, uint16_t& f, float& lux) {
if(!m_initialized) return;
uint32_t data;
if(!ReadData(&data)) return;
v = ((data & 0xFFFF) - (data >> 16));
ir = (data >> 16);
f = (data & 0xFFFF);
lux = ComputeLux(data&0xFFFF,data>>16,again(),atime());
}
/****************************************************************/
TSL25911::ChipModel TSL25911::chipModel(){
return m_chip_model;
TSL25911::ChipModel TSL25911::chipModel() {
return m_chip_model;
}
/****************************************************************/
bool TSL25911::WriteRegister(uint8_t addr, uint8_t data){
i2c->beginTransmission(TSL25911_ADDRESS);
i2c->write(addr);
i2c->write(data);
i2c->endTransmission();
return true;
bool TSL25911::WriteRegister(uint8_t addr, uint8_t data) {
i2c->beginTransmission(TSL25911_ADDRESS);
i2c->write(addr);
i2c->write(data);
i2c->endTransmission();
return true;
}
/****************************************************************/
bool TSL25911::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length){
uint8_t ord(0);
bool TSL25911::ReadRegister(uint8_t addr,uint8_t data[],uint8_t length) {
uint8_t ord(0);
i2c->beginTransmission(TSL25911_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->beginTransmission(TSL25911_ADDRESS);
i2c->write(addr);
i2c->endTransmission();
i2c->requestFrom(static_cast<uint8_t>(TSL25911_ADDRESS), length);
i2c->requestFrom(static_cast<uint8_t>(TSL25911_ADDRESS), length);
while(i2c->available()){
data[ord++] = i2c->read();
}
while(i2c->available()) {
data[ord++] = i2c->read();
}
return ord == length;
return ord == length;
}
float TSL25911::again(){
switch (gain) {
case TSL2591_GAIN_LOW:
return 1.0F;
break;
case TSL2591_GAIN_MED:
return 25.0F;
break;
case TSL2591_GAIN_HIGH:
return 428.0F;
break;
case TSL2591_GAIN_MAX:
return 9876.0F;
break;
default:
return 1.0F;
break;
}
float TSL25911::again() {
switch (gain) {
case TSL2591_GAIN_LOW:
return 1.0F;
break;
case TSL2591_GAIN_MED:
return 25.0F;
break;
case TSL2591_GAIN_HIGH:
return 428.0F;
break;
case TSL2591_GAIN_MAX:
return 9876.0F;
break;
default:
return 1.0F;
break;
}
}
float TSL25911::atime(){
switch (integration) {
case TSL2591_INTEGRATIONTIME_100MS:
return 100.0F;
break;
case TSL2591_INTEGRATIONTIME_200MS:
return 200.0F;
break;
case TSL2591_INTEGRATIONTIME_300MS:
return 300.0F;
break;
case TSL2591_INTEGRATIONTIME_400MS:
return 400.0F;
break;
case TSL2591_INTEGRATIONTIME_500MS:
return 500.0F;
break;
case TSL2591_INTEGRATIONTIME_600MS:
return 600.0F;
break;
default: // 100ms
return 100.0F;
break;
}
float TSL25911::atime() {
switch (integration) {
case TSL2591_INTEGRATIONTIME_100MS:
return 100.0F;
break;
case TSL2591_INTEGRATIONTIME_200MS:
return 200.0F;
break;
case TSL2591_INTEGRATIONTIME_300MS:
return 300.0F;
break;
case TSL2591_INTEGRATIONTIME_400MS:
return 400.0F;
break;
case TSL2591_INTEGRATIONTIME_500MS:
return 500.0F;
break;
case TSL2591_INTEGRATIONTIME_600MS:
return 600.0F;
break;
default: // 100ms
return 100.0F;
break;
}
}

10
src/sensor/dev/tsl25911.h
View File

@ -12,8 +12,8 @@
///
/// Based on the data sheet provided
///
class TSL25911{
public:
class TSL25911 {
public:
typedef enum {
TSL25911_FULL = 0x0,
@ -58,13 +58,13 @@ class TSL25911{
TSL2591_GAIN_MAX = 0x30, /// max gain (9876x)
} tsl2591Gain_t;
enum ChipModel{
enum ChipModel {
ChipModel_UNKNOWN = 0,
ChipModel_TSL25911_REV0 = 0x50
};
};
TSL25911(TwoWire* i2c): m_initialized(false), gain(TSL2591_GAIN_MED), integration(TSL2591_INTEGRATIONTIME_500MS),i2c(i2c){}
TSL25911(TwoWire* i2c): m_initialized(false), gain(TSL2591_GAIN_MED), integration(TSL2591_INTEGRATIONTIME_500MS),i2c(i2c) {}
TSL25911(TwoWire* i2c, tsl2591Gain_t _gain,tsl2591IntegrationTime_t _integration) : m_initialized(false),gain(_gain),integration(_integration),i2c(i2c) {}
ChipModel chipModel();

138
src/sensor/environment.cpp
View File

@ -12,7 +12,7 @@ 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/>.
Written: Dec 30 2015.
Last Updated: Dec 23 2017.
Last Updated: Dec 23 2017.
This header must be included in any derived code or copies of the code.
*/
#include "environment.h"
@ -31,83 +31,83 @@ This header must be included in any derived code or copies of the code.
#define hi_coeff9 -0.00000199
/****************************************************************/
float EnvironmentCalculations::Altitude(float pressure,float referencePressure,float outdoorTemp){
// Equation inverse to EquivalentSeaLevelPressure calculation.
float altitude = NAN;
if (!isnan(pressure) && !isnan(referencePressure) && !isnan(outdoorTemp)){
altitude = pow(referencePressure / pressure, 0.190234) - 1;
altitude *= ((outdoorTemp + 273.15) / 0.0065);
}
return altitude;
float EnvironmentCalculations::Altitude(float pressure,float referencePressure,float outdoorTemp) {
// Equation inverse to EquivalentSeaLevelPressure calculation.
float altitude = NAN;
if (!isnan(pressure) && !isnan(referencePressure) && !isnan(outdoorTemp)) {
altitude = pow(referencePressure / pressure, 0.190234) - 1;
altitude *= ((outdoorTemp + 273.15) / 0.0065);
}
return altitude;
}
/****************************************************************/
float EnvironmentCalculations::AbsoluteHumidity(float temperature, float humidity){
//taken from https://carnotcycle.wordpress.com/2012/08/04/how-to-convert-relative-humidity-to-absolute-humidity/
//precision is about 0.1°C in range -30 to 35°C
//August-Roche-Magnus 6.1094 exp(17.625 x T)/(T + 243.04)
//Buck (1981) 6.1121 exp(17.502 x T)/(T + 240.97)
//reference https://www.eas.ualberta.ca/jdwilson/EAS372_13/Vomel_CIRES_satvpformulae.html
float temp = NAN;
const float mw = 18.01534; // molar mass of water g/mol
const float r = 8.31447215; // Universal gas constant J/mol/K
float EnvironmentCalculations::AbsoluteHumidity(float temperature, float humidity) {
//taken from https://carnotcycle.wordpress.com/2012/08/04/how-to-convert-relative-humidity-to-absolute-humidity/
//precision is about 0.1°C in range -30 to 35°C
//August-Roche-Magnus 6.1094 exp(17.625 x T)/(T + 243.04)
//Buck (1981) 6.1121 exp(17.502 x T)/(T + 240.97)
//reference https://www.eas.ualberta.ca/jdwilson/EAS372_13/Vomel_CIRES_satvpformulae.html
float temp = NAN;
const float mw = 18.01534; // molar mass of water g/mol
const float r = 8.31447215; // Universal gas constant J/mol/K
if (isnan(temperature) || isnan(humidity) ){
return NAN;
}
temp = pow(2.718281828, (17.67 * temperature) / (temperature + 243.5));
//return (6.112 * temp * humidity * 2.1674) / (273.15 + temperature); //simplified version
return (6.112 * temp * humidity * mw) / ((273.15 + temperature) * r); //long version
if (isnan(temperature) || isnan(humidity) ) {
return NAN;
}
temp = pow(2.718281828, (17.67 * temperature) / (temperature + 243.5));
//return (6.112 * temp * humidity * 2.1674) / (273.15 + temperature); //simplified version
return (6.112 * temp * humidity * mw) / ((273.15 + temperature) * r); //long version
}
/****************************************************************/
//FYI: https://ehp.niehs.nih.gov/1206273/ in detail this flow graph: https://ehp.niehs.nih.gov/wp-content/uploads/2013/10/ehp.1206273.g003.png
float EnvironmentCalculations::HeatIndex(float temperature,float humidity){
float heatIndex(NAN);
float EnvironmentCalculations::HeatIndex(float temperature,float humidity) {
float heatIndex(NAN);
if ( isnan(temperature) || isnan(humidity) ) {
return heatIndex;
}
temperature = (temperature * (9.0 / 5.0) + 32.0); /*conversion to [°F]*/
// Using both Rothfusz and Steadman's equations
// http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
if (temperature <= 40) {
heatIndex = temperature; //first red block
}else{
heatIndex = 0.5 * (temperature + 61.0 + ((temperature - 68.0) * 1.2) + (humidity * 0.094)); //calculate A -- from the official site, not the flow graph
if (heatIndex >= 79) {
/*
* calculate B
* the following calculation is optimized. Simply spoken, reduzed cpu-operations to minimize used ram and runtime.
* Check the correctness with the following link:
* http://www.wolframalpha.com/input/?source=nav&i=b%3D+x1+%2B+x2*T+%2B+x3*H+%2B+x4*T*H+%2B+x5*T*T+%2B+x6*H*H+%2B+x7*T*T*H+%2B+x8*T*H*H+%2B+x9*T*T*H*H
*/
heatIndex = hi_coeff1
+ (hi_coeff2 + hi_coeff4 * humidity + temperature * (hi_coeff5 + hi_coeff7 * humidity)) * temperature
+ (hi_coeff3 + humidity * (hi_coeff6 + temperature * (hi_coeff8 + hi_coeff9 * temperature))) * humidity;
//third red block
if ((humidity < 13) && (temperature >= 80.0) && (temperature <= 112.0)) {
heatIndex -= ((13.0 - humidity) * 0.25) * sqrt((17.0 - abs(temperature - 95.0)) * 0.05882);
}else if ((humidity > 85.0) && (temperature >= 80.0) && (temperature <= 87.0)){
heatIndex += (0.02 * (humidity - 85.0) * (87.0 - temperature));
}
if ( isnan(temperature) || isnan(humidity) ) {
return heatIndex;
}
}
return (heatIndex - 32.0) * (5.0 / 9.0); /*conversion back to [°C]*/
temperature = (temperature * (9.0 / 5.0) + 32.0); /*conversion to [°F]*/
// Using both Rothfusz and Steadman's equations
// http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
if (temperature <= 40) {
heatIndex = temperature; //first red block
} else {
heatIndex = 0.5 * (temperature + 61.0 + ((temperature - 68.0) * 1.2) + (humidity * 0.094)); //calculate A -- from the official site, not the flow graph
if (heatIndex >= 79) {
/*
* calculate B
* the following calculation is optimized. Simply spoken, reduzed cpu-operations to minimize used ram and runtime.
* Check the correctness with the following link:
* http://www.wolframalpha.com/input/?source=nav&i=b%3D+x1+%2B+x2*T+%2B+x3*H+%2B+x4*T*H+%2B+x5*T*T+%2B+x6*H*H+%2B+x7*T*T*H+%2B+x8*T*H*H+%2B+x9*T*T*H*H
*/
heatIndex = hi_coeff1
+ (hi_coeff2 + hi_coeff4 * humidity + temperature * (hi_coeff5 + hi_coeff7 * humidity)) * temperature
+ (hi_coeff3 + humidity * (hi_coeff6 + temperature * (hi_coeff8 + hi_coeff9 * temperature))) * humidity;
//third red block
if ((humidity < 13) && (temperature >= 80.0) && (temperature <= 112.0)) {
heatIndex -= ((13.0 - humidity) * 0.25) * sqrt((17.0 - abs(temperature - 95.0)) * 0.05882);
} else if ((humidity > 85.0) && (temperature >= 80.0) && (temperature <= 87.0)) {
heatIndex += (0.02 * (humidity - 85.0) * (87.0 - temperature));
}
}
}
return (heatIndex - 32.0) * (5.0 / 9.0); /*conversion back to [°C]*/
}
/****************************************************************/
float EnvironmentCalculations::EquivalentSeaLevelPressure(float altitude,float temp,float pres){
float EnvironmentCalculations::EquivalentSeaLevelPressure(float altitude,float temp,float pres) {
float seaPress = NAN;
if(!isnan(altitude) && !isnan(temp) && !isnan(pres)){
if(!isnan(altitude) && !isnan(temp) && !isnan(pres)) {
seaPress = (pres / pow(1 - ((0.0065 *altitude) / (temp + (0.0065 *altitude) + 273.15)), 5.257));
}
return seaPress;
@ -115,15 +115,15 @@ float EnvironmentCalculations::EquivalentSeaLevelPressure(float altitude,float t
/****************************************************************/
float EnvironmentCalculations::DewPoint(float temp,float hum){
// Equations courtesy of Brian McNoldy from http://andrew.rsmas.miami.edu;
float dewPoint = NAN;
float EnvironmentCalculations::DewPoint(float temp,float hum) {
// Equations courtesy of Brian McNoldy from http://andrew.rsmas.miami.edu;
float dewPoint = NAN;
if(!isnan(temp) && !isnan(hum)){
dewPoint = 243.04 * (log(hum/100.0) + ((17.625 * temp)/(243.04 + temp)))
/(17.625 - log(hum/100.0) - ((17.625 * temp)/(243.04 + temp)));
}
if(!isnan(temp) && !isnan(hum)) {
dewPoint = 243.04 * (log(hum/100.0) + ((17.625 * temp)/(243.04 + temp)))
/(17.625 - log(hum/100.0) - ((17.625 * temp)/(243.04 + temp)));
}
return dewPoint;
return dewPoint;
}

90
src/sensor/environment.h
View File

@ -2,59 +2,59 @@
#ifndef TG_ENVIRONMENT_CALCULATIONS_H
#define TG_ENVIRONMENT_CALCULATIONS_H
namespace EnvironmentCalculations{
namespace EnvironmentCalculations {
/////////////////////////////////////////////////////////////////
/// Calculate the altitude based on the pressure and temperature
/// in temptUnit.
/// @param pressure at the station in any units.
/// @param altUnit meters or feet. default=AltitudeUnit_Meters
/// @param referencePressure (usually pressure on MSL)
/// in the same units as pressure. default=1013.25hPa (ISA)
/// @param outdoorTemp temperature at the station in tempUnit
/// default=15°C (ISA)
/// @return Calculated Altitude in meters.
float Altitude(
/////////////////////////////////////////////////////////////////
/// Calculate the altitude based on the pressure and temperature
/// in temptUnit.
/// @param pressure at the station in any units.
/// @param altUnit meters or feet. default=AltitudeUnit_Meters
/// @param referencePressure (usually pressure on MSL)
/// in the same units as pressure. default=1013.25hPa (ISA)
/// @param outdoorTemp temperature at the station in tempUnit
/// default=15°C (ISA)
/// @return Calculated Altitude in meters.
float Altitude(
float pressure,
float referencePressure = 1013.25, // [hPa] ....ISA value
float outdoorTemp = 15 // [°C] .... ISA value
);
);
/////////////////////////////////////////////////////////////////
/// Calculate the heatindex based on the humidity and temperature
/// in tempUnit.
/// The formula based on the Heat Index Equation of the US National Weather Service
/// http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
/// @param temperature in tempUnit
/// @param humidity in percentage
/// @return Calculated heatindex as float in TempUnit
float HeatIndex(float temperature,float humidity);
/////////////////////////////////////////////////////////////////
/// Calculate the heatindex based on the humidity and temperature
/// in tempUnit.
/// The formula based on the Heat Index Equation of the US National Weather Service
/// http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
/// @param temperature in tempUnit
/// @param humidity in percentage
/// @return Calculated heatindex as float in TempUnit
float HeatIndex(float temperature,float humidity);
/////////////////////////////////////////////////////////////////
/// Calculate the absolute humidity based on the relative humidity and temperature
/// in tempUnit.
/// the formula does work for values between -30°C and 35°C with 0.1°C precision
/// @param temperature in tempUnit
/// @param humidity in percentage
/// @return Calculated absolute humidity in grams/m³
float AbsoluteHumidity(float temperature, float humidity);
/////////////////////////////////////////////////////////////////
/// Calculate the absolute humidity based on the relative humidity and temperature
/// in tempUnit.
/// the formula does work for values between -30°C and 35°C with 0.1°C precision
/// @param temperature in tempUnit
/// @param humidity in percentage
/// @return Calculated absolute humidity in grams/m³
float AbsoluteHumidity(float temperature, float humidity);
/////////////////////////////////////////////////////////////////
/// Convert current pressure to equivalent sea-level pressure.
/// @param altitude in meters.
/// @param temp in tempUnit.
/// @param pressure at the station in any units.
/// @return Equivalent pressure at sea level. The input pressure
/// unit will determine the output
/// pressure unit.
float EquivalentSeaLevelPressure(float altitude,float temp,float pres);
/////////////////////////////////////////////////////////////////
/// Convert current pressure to equivalent sea-level pressure.
/// @param altitude in meters.
/// @param temp in tempUnit.
/// @param pressure at the station in any units.
/// @return Equivalent pressure at sea level. The input pressure
/// unit will determine the output
/// pressure unit.
float EquivalentSeaLevelPressure(float altitude,float temp,float pres);
/////////////////////////////////////////////////////////////////
/// Calculate the dew point based on the temperature in tempUnit
/// and humidity.
/// @param temp in tempUnit.
/// @param hum in %.
float DewPoint(float temp,float hum);
/////////////////////////////////////////////////////////////////
/// Calculate the dew point based on the temperature in tempUnit
/// and humidity.
/// @param temp in tempUnit.
/// @param hum in %.
float DewPoint(float temp,float hum);
}

36
src/sensor/sensor.cpp
View File

@ -4,7 +4,7 @@
#include "environment.h"
Sensor::Sensor(TwoWire* i2c){
Sensor::Sensor(TwoWire* i2c) {
bme = new BME280(i2c);
ltr = new LTR390(i2c);
tsl = new TSL25911(i2c);
@ -12,30 +12,40 @@ Sensor::Sensor(TwoWire* i2c){
pms = new PMSA003(i2c);
}
void Sensor::TSL_init(void){tsl->begin();}
void Sensor::BME_init(void){bme->begin();}
void Sensor::ICM_init(void){}//Nothing to do afaik
void Sensor::LTR_init(void){ltr->begin();}
void Sensor::SGP_init(void){sgp->begin();}
void Sensor::PMS_init(void){pms->begin();}
void Sensor::TSL_init(void) {
tsl->begin();
}
void Sensor::BME_init(void) {
bme->begin();
}
void Sensor::ICM_init(void) {} //Nothing to do afaik
void Sensor::LTR_init(void) {
ltr->begin();
}
void Sensor::SGP_init(void) {
sgp->begin();
}
void Sensor::PMS_init(void) {
pms->begin();
}
void Sensor::BME_measure(){
void Sensor::BME_measure() {
bme->read(pres, temp, hum);
heatidx = EnvironmentCalculations::HeatIndex(temp,hum);
}
void Sensor::LTR_measure(){
void Sensor::LTR_measure() {
ltr->read(uv, uvi);
}
void Sensor::TSL_measure(void){
void Sensor::TSL_measure(void) {
tsl->read(light_vis, light_ir, light_full, light_lux);
}
void Sensor::ICM_measure(void){
void Sensor::ICM_measure(void) {
//Do realy care about this ????
}
void Sensor::SGP_measure(void){
void Sensor::SGP_measure(void) {
sgp->read(voci, temp, hum);
}
void Sensor::PMS_measure(void){
void Sensor::PMS_measure(void) {
pms->read(pmd);
}

31
src/sensor/sensor.h
View File

@ -15,15 +15,15 @@
class Sensor
{
// user-accessible "public" interface
public:
// user-accessible "public" interface
public:
Sensor(TwoWire* i2c);
float temp = 0;
float pres = 0;
float hum = 0;
float heatidx = 0;
float light = 0;
uint32_t uv = 0;
uint32_t uvi = 0;
@ -50,16 +50,25 @@ class Sensor
void SGP_measure(void);
void PMS_measure(void);
void measure(){
TSL_measure();
BME_measure();
ICM_measure();
LTR_measure();
SGP_measure();
PMS_measure();
void init() {
BME_init();
LTR_init();
TSL_init();
SGP_init();
PMS_init();
ICM_init();
}
private:
void measure() {
BME_measure();
LTR_measure();
TSL_measure();
SGP_measure();
PMS_measure();
ICM_measure();
}
private:
BME280* bme = NULL;
LTR390* ltr = NULL;
TSL25911* tsl = NULL;

128
src/sensor/voc.cpp
View File

@ -251,9 +251,11 @@ static fix16_t fix16_exp(fix16_t x) {
// exp(x) for x = +/- {1, 1/8, 1/64, 1/512}
#define NUM_EXP_VALUES 4
static const fix16_t exp_pos_values[NUM_EXP_VALUES] = {
F16(2.7182818), F16(1.1331485), F16(1.0157477), F16(1.0019550)};
F16(2.7182818), F16(1.1331485), F16(1.0157477), F16(1.0019550)
};
static const fix16_t exp_neg_values[NUM_EXP_VALUES] = {
F16(0.3678794), F16(0.8824969), F16(0.9844964), F16(0.9980488)};
F16(0.3678794), F16(0.8824969), F16(0.9844964), F16(0.9980488)
};
const fix16_t* exp_values;
fix16_t res, arg;
@ -293,8 +295,8 @@ static void VocAlgorithm__mean_variance_estimator__set_parameters(
fix16_t tau_mean_variance_hours, fix16_t gating_max_duration_minutes);
static void
VocAlgorithm__mean_variance_estimator__set_states(VocAlgorithmParams* params,
fix16_t mean, fix16_t std,
fix16_t uptime_gamma);
fix16_t mean, fix16_t std,
fix16_t uptime_gamma);
static fix16_t
VocAlgorithm__mean_variance_estimator__get_std(VocAlgorithmParams* params);
static fix16_t
@ -311,16 +313,16 @@ static fix16_t VocAlgorithm__mean_variance_estimator___sigmoid__process(
VocAlgorithmParams* params, fix16_t sample);
static void VocAlgorithm__mox_model__init(VocAlgorithmParams* params);
static void VocAlgorithm__mox_model__set_parameters(VocAlgorithmParams* params,
fix16_t SRAW_STD,
fix16_t SRAW_MEAN);
fix16_t SRAW_STD,
fix16_t SRAW_MEAN);
static fix16_t VocAlgorithm__mox_model__process(VocAlgorithmParams* params,
fix16_t sraw);
fix16_t sraw);
static void VocAlgorithm__sigmoid_scaled__init(VocAlgorithmParams* params);
static void
VocAlgorithm__sigmoid_scaled__set_parameters(VocAlgorithmParams* params,
fix16_t offset);
fix16_t offset);
static fix16_t VocAlgorithm__sigmoid_scaled__process(VocAlgorithmParams* params,
fix16_t sample);
fix16_t sample);
static void VocAlgorithm__adaptive_lowpass__init(VocAlgorithmParams* params);
static void
VocAlgorithm__adaptive_lowpass__set_parameters(VocAlgorithmParams* params);
@ -354,7 +356,7 @@ static void VocAlgorithm__init_instances(VocAlgorithmParams* params) {
VocAlgorithm__mean_variance_estimator__get_mean(params));
VocAlgorithm__sigmoid_scaled__init(params);
VocAlgorithm__sigmoid_scaled__set_parameters(params,
params->mVoc_Index_Offset);
params->mVoc_Index_Offset);
VocAlgorithm__adaptive_lowpass__init(params);
VocAlgorithm__adaptive_lowpass__set_parameters(params);
}
@ -429,7 +431,7 @@ static void
VocAlgorithm__mean_variance_estimator__init(VocAlgorithmParams* params) {
VocAlgorithm__mean_variance_estimator__set_parameters(params, F16(0.),
F16(0.), F16(0.));
F16(0.), F16(0.));
VocAlgorithm__mean_variance_estimator___init_instances(params);
}
@ -459,9 +461,9 @@ static void VocAlgorithm__mean_variance_estimator__set_parameters(
VocAlgorithm_SAMPLING_INTERVAL) /
(VocAlgorithm_TAU_INITIAL_MEAN + VocAlgorithm_SAMPLING_INTERVAL)));
params->m_Mean_Variance_Estimator___Gamma_Initial_Variance = F16(
((VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING *
VocAlgorithm_SAMPLING_INTERVAL) /
(VocAlgorithm_TAU_INITIAL_VARIANCE + VocAlgorithm_SAMPLING_INTERVAL)));
((VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING *
VocAlgorithm_SAMPLING_INTERVAL) /
(VocAlgorithm_TAU_INITIAL_VARIANCE + VocAlgorithm_SAMPLING_INTERVAL)));
params->m_Mean_Variance_Estimator__Gamma_Mean = F16(0.);
params->m_Mean_Variance_Estimator__Gamma_Variance = F16(0.);
params->m_Mean_Variance_Estimator___Uptime_Gamma = F16(0.);
@ -471,8 +473,8 @@ static void VocAlgorithm__mean_variance_estimator__set_parameters(
static void
VocAlgorithm__mean_variance_estimator__set_states(VocAlgorithmParams* params,
fix16_t mean, fix16_t std,
fix16_t uptime_gamma) {
fix16_t mean, fix16_t std,
fix16_t uptime_gamma) {
params->m_Mean_Variance_Estimator___Mean = mean;
params->m_Mean_Variance_Estimator___Std = std;
@ -532,10 +534,10 @@ static void VocAlgorithm__mean_variance_estimator___calculate_gamma(
gating_threshold_mean =
(F16(VocAlgorithm_GATING_THRESHOLD) +
(fix16_mul(
F16((VocAlgorithm_GATING_THRESHOLD_INITIAL -
VocAlgorithm_GATING_THRESHOLD)),
VocAlgorithm__mean_variance_estimator___sigmoid__process(
params, params->m_Mean_Variance_Estimator___Uptime_Gating))));
F16((VocAlgorithm_GATING_THRESHOLD_INITIAL -
VocAlgorithm_GATING_THRESHOLD)),
VocAlgorithm__mean_variance_estimator___sigmoid__process(
params, params->m_Mean_Variance_Estimator___Uptime_Gating))));
VocAlgorithm__mean_variance_estimator___sigmoid__set_parameters(
params, F16(1.), gating_threshold_mean,
F16(VocAlgorithm_GATING_THRESHOLD_TRANSITION));
@ -553,16 +555,16 @@ static void VocAlgorithm__mean_variance_estimator___calculate_gamma(
gamma_variance =
(params->m_Mean_Variance_Estimator___Gamma +
(fix16_mul(
(params->m_Mean_Variance_Estimator___Gamma_Initial_Variance -
params->m_Mean_Variance_Estimator___Gamma),
(sigmoid_gamma_variance - sigmoid_gamma_mean))));
(params->m_Mean_Variance_Estimator___Gamma_Initial_Variance -
params->m_Mean_Variance_Estimator___Gamma),
(sigmoid_gamma_variance - sigmoid_gamma_mean))));
gating_threshold_variance =
(F16(VocAlgorithm_GATING_THRESHOLD) +
(fix16_mul(
F16((VocAlgorithm_GATING_THRESHOLD_INITIAL -
VocAlgorithm_GATING_THRESHOLD)),
VocAlgorithm__mean_variance_estimator___sigmoid__process(
params, params->m_Mean_Variance_Estimator___Uptime_Gating))));
F16((VocAlgorithm_GATING_THRESHOLD_INITIAL -
VocAlgorithm_GATING_THRESHOLD)),
VocAlgorithm__mean_variance_estimator___sigmoid__process(
params, params->m_Mean_Variance_Estimator___Uptime_Gating))));
VocAlgorithm__mean_variance_estimator___sigmoid__set_parameters(
params, F16(1.), gating_threshold_variance,
F16(VocAlgorithm_GATING_THRESHOLD_TRANSITION));
@ -578,11 +580,11 @@ static void VocAlgorithm__mean_variance_estimator___calculate_gamma(
F16((1. + VocAlgorithm_GATING_MAX_RATIO)))) -
F16(VocAlgorithm_GATING_MAX_RATIO)))));
if ((params->m_Mean_Variance_Estimator___Gating_Duration_Minutes <
F16(0.))) {
F16(0.))) {
params->m_Mean_Variance_Estimator___Gating_Duration_Minutes = F16(0.);
}
if ((params->m_Mean_Variance_Estimator___Gating_Duration_Minutes >
params->m_Mean_Variance_Estimator__Gating_Max_Duration_Minutes)) {
params->m_Mean_Variance_Estimator__Gating_Max_Duration_Minutes)) {
params->m_Mean_Variance_Estimator___Uptime_Gating = F16(0.);
}
}
@ -600,7 +602,7 @@ static void VocAlgorithm__mean_variance_estimator__process(
params->m_Mean_Variance_Estimator___Mean = F16(0.);
} else {
if (((params->m_Mean_Variance_Estimator___Mean >= F16(100.)) ||
(params->m_Mean_Variance_Estimator___Mean <= F16(-100.)))) {
(params->m_Mean_Variance_Estimator___Mean <= F16(-100.)))) {
params->m_Mean_Variance_Estimator___Sraw_Offset =
(params->m_Mean_Variance_Estimator___Sraw_Offset +
params->m_Mean_Variance_Estimator___Mean);
@ -610,8 +612,8 @@ static void VocAlgorithm__mean_variance_estimator__process(
VocAlgorithm__mean_variance_estimator___calculate_gamma(
params, voc_index_from_prior);
delta_sgp = (fix16_div(
(sraw - params->m_Mean_Variance_Estimator___Mean),
F16(VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING)));
(sraw - params->m_Mean_Variance_Estimator___Mean),
F16(VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING)));
if ((delta_sgp < F16(0.))) {
c = (params->m_Mean_Variance_Estimator___Std - delta_sgp);
} else {
@ -622,25 +624,25 @@ static void VocAlgorithm__mean_variance_estimator__process(
additional_scaling = F16(4.);
}
params->m_Mean_Variance_Estimator___Std = (fix16_mul(
fix16_sqrt((fix16_mul(
additional_scaling,
(F16(VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING) -
params->m_Mean_Variance_Estimator__Gamma_Variance)))),
fix16_sqrt((
(fix16_mul(
params->m_Mean_Variance_Estimator___Std,
(fix16_div(
params->m_Mean_Variance_Estimator___Std,
(fix16_mul(
F16(VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING),
additional_scaling)))))) +
(fix16_mul(
(fix16_div(
(fix16_mul(
params->m_Mean_Variance_Estimator__Gamma_Variance,
delta_sgp)),
additional_scaling)),
delta_sgp))))));
fix16_sqrt((fix16_mul(
additional_scaling,
(F16(VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING) -
params->m_Mean_Variance_Estimator__Gamma_Variance)))),
fix16_sqrt((
(fix16_mul(
params->m_Mean_Variance_Estimator___Std,
(fix16_div(
params->m_Mean_Variance_Estimator___Std,
(fix16_mul(
F16(VocAlgorithm_MEAN_VARIANCE_ESTIMATOR__GAMMA_SCALING),
additional_scaling)))))) +
(fix16_mul(
(fix16_div(
(fix16_mul(
params->m_Mean_Variance_Estimator__Gamma_Variance,
delta_sgp)),
additional_scaling)),
delta_sgp))))));
params->m_Mean_Variance_Estimator___Mean =
(params->m_Mean_Variance_Estimator___Mean +
(fix16_mul(params->m_Mean_Variance_Estimator__Gamma_Mean,
@ -686,15 +688,15 @@ static void VocAlgorithm__mox_model__init(VocAlgorithmParams* params) {
}
static void VocAlgorithm__mox_model__set_parameters(VocAlgorithmParams* params,
fix16_t SRAW_STD,
fix16_t SRAW_MEAN) {
fix16_t SRAW_STD,
fix16_t SRAW_MEAN) {
params->m_Mox_Model__Sraw_Std = SRAW_STD;
params->m_Mox_Model__Sraw_Mean = SRAW_MEAN;
}
static fix16_t VocAlgorithm__mox_model__process(VocAlgorithmParams* params,
fix16_t sraw) {
fix16_t sraw) {
return (fix16_mul((fix16_div((sraw - params->m_Mox_Model__Sraw_Mean),
(-(params->m_Mox_Model__Sraw_Std +
@ -709,13 +711,13 @@ static void VocAlgorithm__sigmoid_scaled__init(VocAlgorithmParams* params) {
static void
VocAlgorithm__sigmoid_scaled__set_parameters(VocAlgorithmParams* params,
fix16_t offset) {
fix16_t offset) {
params->m_Sigmoid_Scaled__Offset = offset;
}
static fix16_t VocAlgorithm__sigmoid_scaled__process(VocAlgorithmParams* params,
fix16_t sample) {
fix16_t sample) {
fix16_t x;
fix16_t shift;
@ -729,18 +731,18 @@ static fix16_t VocAlgorithm__sigmoid_scaled__process(VocAlgorithmParams* params,
} else {
if ((sample >= F16(0.))) {
shift = (fix16_div(
(F16(VocAlgorithm_SIGMOID_L) -
(fix16_mul(F16(5.), params->m_Sigmoid_Scaled__Offset))),
F16(4.)));
(F16(VocAlgorithm_SIGMOID_L) -
(fix16_mul(F16(5.), params->m_Sigmoid_Scaled__Offset))),
F16(4.)));
return ((fix16_div((F16(VocAlgorithm_SIGMOID_L) + shift),
(F16(1.) + fix16_exp(x)))) -
shift);
} else {
return (fix16_mul(
(fix16_div(params->m_Sigmoid_Scaled__Offset,
F16(VocAlgorithm_VOC_INDEX_OFFSET_DEFAULT))),
(fix16_div(F16(VocAlgorithm_SIGMOID_L),
(F16(1.) + fix16_exp(x))))));
(fix16_div(params->m_Sigmoid_Scaled__Offset,
F16(VocAlgorithm_VOC_INDEX_OFFSET_DEFAULT))),
(fix16_div(F16(VocAlgorithm_SIGMOID_L),
(F16(1.) + fix16_exp(x))))));
}
}
}

76
src/timedfun/timedfun.h
View File

@ -10,54 +10,54 @@
typedef void (*timedfun_ptr)();
class TimedFun {
public:
TimedFun(){};
public:
TimedFun() {};
void registerFun(timedfun_ptr p, uint64_t s){
funmap.push_back(std::pair<timedfun_ptr,uint64_t>(p,s));
};
void registerFun(timedfun_ptr p, uint64_t s) {
funmap.push_back(std::pair<timedfun_ptr,uint64_t>(p,s));
};
void registerFunCond(timedfun_ptr p, uint64_t s){
funmap.push_back(std::pair<timedfun_ptr,uint64_t>(p,s));
};
void registerFunCond(timedfun_ptr p, uint64_t s) {
funmap.push_back(std::pair<timedfun_ptr,uint64_t>(p,s));
};
void minuteTick(){
++counter;
}
void tick() {
++counter;
}
void minuteTick(int64_t m){
counter += m;
}
void tick(int64_t m) {
counter += m;
}
void setTick(int64_t m){
counter = m;
old_counter = m;
}
void setTick(int64_t m) {
counter = m;
old_counter = m;
}
void update(){
uint64_t ccounter = old_counter;
old_counter = counter;
for (const auto &e : funmap){
if( ((counter % e.second == 0) && (counter != ccounter)) ||
((counter-ccounter) >= e.second) || ((counter%e.second) < (ccounter%e.second))){
e.first();
}
}
old_counter = counter;
};
void updateForce(){
Serial.println("TF: Force updating all");
for (const auto &e : funmap){
void update() {
uint64_t ccounter = old_counter;
old_counter = counter;
for (const auto &e : funmap) {
if( ((counter % e.second == 0) && (counter != ccounter)) ||
((counter-ccounter) >= e.second) || ((counter%e.second) < (ccounter%e.second))) {
e.first();
}
Serial.println("TF: OK");
}
old_counter = counter;
};
private:
uint64_t counter = 0;
uint64_t old_counter = 0;
std::vector<std::pair<timedfun_ptr,uint64_t>> funmap;
void updateForce() {
Serial.println("TF: Force updating all");
for (const auto &e : funmap) {
e.first();
}
Serial.println("TF: OK");
}
private:
uint64_t counter = 0;
uint64_t old_counter = 0;
std::vector<std::pair<timedfun_ptr,uint64_t>> funmap;
};

152
src/touch/gt1151.cpp
View File

@ -3,114 +3,116 @@
volatile uint8_t gtIRQ = 0;
void IRAM_ATTR _gt_irq_handler() {
noInterrupts();
gtIRQ = 1;
interrupts();
noInterrupts();
gtIRQ = 1;
interrupts();
}
GT1151::GT1151(TwoWire* i2c){ wire = i2c;}
GT1151::GT1151(TwoWire* i2c) {
wire = i2c;
}
void GT1151::setHandler(void (*handler)(int8_t, GTPoint*)) {
touchHandler = handler;
touchHandler = handler;
}
void GT1151::armIRQ() {
attachInterrupt(GT1151_INT_PIN, _gt_irq_handler, RISING);
attachInterrupt(GT1151_INT_PIN, _gt_irq_handler, RISING);
}
void GT1151::onIRQ() {
GTPoint points[CT_MAX_TOUCH];
int16_t contacts = readInput((GTPoint *) &points);
dev.holding = contacts > 0 && dev.pressing;
dev.pressing = contacts > 0;
if(dev.holding){
dev.dx = points[0].x - dev.points[0].x;
dev.dy = points[0].y - dev.points[0].y;
}else if(dev.pressing){
memcpy(dev.points,points,sizeof(GTPoint)*CT_MAX_TOUCH);
}
if (contacts < 0) return;
if (contacts > 0) touchHandler(contacts, (GTPoint *)dev.points);
WriteRegister(GT1151_COORD_ADDR, 0x00);
GTPoint points[CT_MAX_TOUCH];
int16_t contacts = readInput((GTPoint *) &points);
dev.holding = contacts > 0 && dev.pressing;
dev.pressing = contacts > 0;
if(dev.holding) {
dev.dx = points[0].x - dev.points[0].x;
dev.dy = points[0].y - dev.points[0].y;
} else if(dev.pressing) {
memcpy(dev.points,points,sizeof(GTPoint)*CT_MAX_TOUCH);
}
if (contacts < 0) return;
if (contacts > 0) touchHandler(contacts, (GTPoint *)dev.points);
WriteRegister(GT1151_COORD_ADDR, 0x00);
}
int16_t GT1151::readInput(GTPoint* points) {
uint8_t* data = static_cast<uint8_t*>(static_cast<void*>(points));
int touch_num;
uint8_t regState;
int error = !ReadRegister(GT1151_COORD_ADDR, &regState, 1);
if ((regState & 0x80)==0) return -1;
touch_num = regState & 0x0f;
if(touch_num > 5) return -1;
if (touch_num <= 0) return touch_num;
uint8_t* data = static_cast<uint8_t*>(static_cast<void*>(points));
int touch_num;
uint8_t regState;
int error = !ReadRegister(GT1151_COORD_ADDR, &regState, 1);
if ((regState & 0x80)==0) return -1;
error = !ReadRegister(GT1151_COORD_ADDR, data, sizeof(GTPoint) * touch_num);
if (error) return -1;
return touch_num;
touch_num = regState & 0x0f;
if(touch_num > 5) return -1;
if (touch_num <= 0) return touch_num;
error = !ReadRegister(GT1151_COORD_ADDR, data, sizeof(GTPoint) * touch_num);
if (error) return -1;
return touch_num;
}
void GT1151::Reset(void){
pinMode(GT1151_RESET_PIN, OUTPUT);
pinMode(GT1151_INT_PIN, INPUT);
digitalWrite(GT1151_RESET_PIN, HIGH);
delay(100);
digitalWrite(GT1151_RESET_PIN, LOW);
delay(100);
digitalWrite(GT1151_RESET_PIN, HIGH);
delay(100);
void GT1151::Reset(void) {
pinMode(GT1151_RESET_PIN, OUTPUT);
pinMode(GT1151_INT_PIN, INPUT);
digitalWrite(GT1151_RESET_PIN, HIGH);
delay(100);
digitalWrite(GT1151_RESET_PIN, LOW);
delay(100);
digitalWrite(GT1151_RESET_PIN, HIGH);
delay(100);
}
void GT1151::ReadVersion(void){
uint8_t buf[4] = {};
ReadRegister(GT1151_REG_ID, buf, 4);
void GT1151::ReadVersion(void) {
uint8_t buf[4] = {};
ReadRegister(GT1151_REG_ID, buf, 4);
}
void GT1151::begin(void){
delay(500);
Reset();
ReadVersion();
armIRQ();
void GT1151::begin(void) {
delay(500);
Reset();
ReadVersion();
armIRQ();
}
void GT1151::update() {
noInterrupts();
uint8_t irq = gtIRQ;
gtIRQ = 0;
interrupts();
// Serial.printf("IRQ: %d\n",irq);
if (irq) onIRQ();
else dev.pressing = false;
noInterrupts();
uint8_t irq = gtIRQ;
gtIRQ = 0;
interrupts();
// Serial.printf("IRQ: %d\n",irq);
if (irq) onIRQ();
else dev.pressing = false;
}
bool GT1151::WriteRegister(uint16_t addr, uint8_t data){
wire->beginTransmission(GT1151_ADDRESS);
wire->write(highByte(addr));
wire->write(lowByte(addr));
wire->write(data);
wire->endTransmission();
return true;
bool GT1151::WriteRegister(uint16_t addr, uint8_t data) {
wire->beginTransmission(GT1151_ADDRESS);
wire->write(highByte(addr));
wire->write(lowByte(addr));
wire->write(data);
wire->endTransmission();
return true;
}
bool GT1151::ReadRegister(uint16_t addr,uint8_t data[],uint8_t length){
uint8_t ord(0);
bool GT1151::ReadRegister(uint16_t addr,uint8_t data[],uint8_t length) {
uint8_t ord(0);
wire->beginTransmission(GT1151_ADDRESS);
wire->write(highByte(addr));
wire->write(lowByte(addr));
wire->endTransmission();
wire->beginTransmission(GT1151_ADDRESS);
wire->write(highByte(addr));
wire->write(lowByte(addr));
wire->endTransmission();
wire->requestFrom(static_cast<uint8_t>(GT1151_ADDRESS), length);
wire->requestFrom(static_cast<uint8_t>(GT1151_ADDRESS), length);
while(wire->available()){
data[ord++] = wire->read();
}
while(wire->available()) {
data[ord++] = wire->read();
}
return ord == length;
return ord == length;
}

42
src/touch/gt1151.h
View File

@ -33,40 +33,40 @@ struct GTPoint {
uint16_t a;
};
typedef struct{
typedef struct {
bool holding;
bool pressing;
GTPoint points[CT_MAX_TOUCH];
int16_t dx,dy;
}GT1151_Dev;
} GT1151_Dev;
class GT1151{
public:
GT1151_Dev dev;
class GT1151 {
public:
GT1151_Dev dev;
GT1151(TwoWire* i2c);
GT1151(TwoWire* i2c);
void update(void);
void begin(void);
void Reset(void);
void Gesture(void);
void setHandler(void (*handler)(int8_t, GTPoint*));
void update(void);
void begin(void);
void Reset(void);
void Gesture(void);
void setHandler(void (*handler)(int8_t, GTPoint*));
private:
void (*touchHandler)(int8_t, GTPoint*);
TwoWire* wire;
private:
void (*touchHandler)(int8_t, GTPoint*);
TwoWire* wire;
void armIRQ(void);
void onIRQ(void);
int16_t readInput(GTPoint* points);
void armIRQ(void);
void onIRQ(void);
int16_t readInput(GTPoint* points);
void ReadVersion(void);
uint8_t Scan(void);
void ReadVersion(void);
uint8_t Scan(void);
bool WriteRegister(uint16_t addr, uint8_t data);
bool ReadRegister(uint16_t addr,uint8_t data[],uint8_t length);
bool WriteRegister(uint16_t addr, uint8_t data);
bool ReadRegister(uint16_t addr,uint8_t data[],uint8_t length);
};
#endif