mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Tasmota/tasmota/tasmota_xsns_sensor/xsns_67_as3935.ino

858 lines
30 KiB
C++
Raw Blame History

/*
xsns_67_as3935.ino - AS3935 Franklin Lightning Sensor support for Tasmota
Copyright (C) 2021 Martin Wagner
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef USE_I2C
#ifdef USE_AS3935
/*********************************************************************************************\
* AS3935 Lightning Sensor
*
* I2C Address: 0x03
\*********************************************************************************************/
#define XSNS_67 67
#define XI2C_48 48 // See I2CDEVICES.md
#define D_NAME_AS3935 "AS3935"
#define AS3935_ADDR 0x03
// I2C Registers Reg mask shift
#define PWR_REG 0x00, 0x01, 0
#define AFE_GB 0x00, 0x3E, 0
#define WDTH 0x01, 0x0F, 0
#define NF_LEVEL 0x01, 0x70, 4
#define SPIKE_REJECT 0x02, 0x0F, 0
#define MIN_NUM_LIGH 0x02, 0x30, 4
#define DISTURBER 0x03, 0x20, 5
#define LCO_FDIV 0x03, 0xC0, 6
#define IRQ_TBL 0x03, 0x0F, 0
#define ENERGY_RAW_1 0x04, 0xFF, 0
#define ENERGY_RAW_2 0x05, 0xFF, 0
#define ENERGY_RAW_3 0x06, 0x1F, 0
#define LGHT_DIST 0x07, 0x3F, 0
#define DISP_TRCO 0x08, 0x20, 5 // should 31.250 kHz with devide 16
#define DISP_SRCO 0x08, 0x40, 6 // 1,1 MHz
#define DISP_LCO 0x08, 0x80, 7 // 32.768 kHz
#define TUNE_CAPS 0x08, 0x0F, 0
#define CAL_TRCO_NOK 0x3A, 0x40, 6 // 1 = NOK
#define CAL_TRCO_DONE 0x3A, 0x80, 7 // 0 = OK
#define CAL_SRCO_NOK 0x3B, 0x40, 6
#define CAL_SRCO_DONE 0x3B, 0x80, 7
// I2C Commands
#define RESET_DEFAULT 0x3C, 0x96
#define CALIBATE_RCO 0x3D, 0x96
// NF-Level
#define INDOORS 0x24
#define OUTDOORS 0x1C
// Load Settings Mask
#define SETREG00MASK 0x3E // For Power On
#define SETREG03MASK 0xF0 // For LCO and Disturber
// Http
const char HTTP_SNS_AS3935_ENERGY[] PROGMEM = "{s}" D_NAME_AS3935 " " D_AS3935_ENERGY " {m}%d{e}";
const char HTTP_SNS_AS3935_DISTANZ[] PROGMEM = "{s}" D_NAME_AS3935 " " D_AS3935_DISTANCE " {m}%u " D_UNIT_KILOMETER "{e}";
const char HTTP_SNS_AS3935_VRMS[] PROGMEM = "{s}" D_NAME_AS3935 " " D_AS3935_VRMS "{m}%#4u (%d){e}";
const char HTTP_SNS_AS3935_OUTDOORS[] PROGMEM = "{s}%s " D_AS3935_GAIN " {m}" D_AS3935_OUTDOORS " {e}";
const char HTTP_SNS_AS3935_INDOORS[] PROGMEM = "{s}%s " D_AS3935_GAIN " {m}" D_AS3935_INDOORS " {e}";
const char* const HTTP_SNS_AS3935_GAIN[] PROGMEM = {HTTP_SNS_AS3935_INDOORS, HTTP_SNS_AS3935_OUTDOORS};
const char HTTP_SNS_AS3935_DIST_ON[] PROGMEM = "{s}%s " D_AS3935_DISTURBER " {m}" D_AS3935_ON " {e}";
const char HTTP_SNS_AS3935_DIST_OFF[] PROGMEM = "{s}%s " D_AS3935_DISTURBER " {m}" D_AS3935_OFF " {e}";
const char* const HTTP_SNS_AS3935_DISTURBER[] PROGMEM = {HTTP_SNS_AS3935_DIST_OFF, HTTP_SNS_AS3935_DIST_ON};
// http Messages
const char HTTP_SNS_AS3935_EMPTY[] PROGMEM = "{s}%s " D_AS3935_NOMESS "{e}";
const char HTTP_SNS_AS3935_OUT[] PROGMEM = "{s}%s " D_AS3935_OUT "{e}";
const char HTTP_SNS_AS3935_NOT[] PROGMEM = "{s}%s " D_AS3935_NOT "{e}";
const char HTTP_SNS_AS3935_ABOVE[] PROGMEM = "{s}%s " D_AS3935_ABOVE "{e}";
const char HTTP_SNS_AS3935_NOISE[] PROGMEM = "{s}%s " D_AS3935_NOISE "{e}";
const char HTTP_SNS_AS3935_DISTURB[] PROGMEM = "{s}%s " D_AS3935_DISTDET "{e}";
const char HTTP_SNS_AS3935_INTNOEV[] PROGMEM = "{s}%s " D_AS3935_INTNOEV "{e}";
const char HTTP_SNS_AS3935_FLICKER[] PROGMEM = "{s}%s " D_AS3935_FLICKER "{e}";
const char HTTP_SNS_AS3935_POWEROFF[] PROGMEM = "{s}%s " D_AS3935_POWEROFF "{e}";
const char HTTP_SNS_AS3935_MSG[] PROGMEM = "{s}%s " D_AS3935_LIGHT " " D_AS3935_APRX " %d " D_UNIT_KILOMETER " " D_AS3935_AWAY "{e}";
const char* const HTTP_SNS_AS3935_TABLE_1[] PROGMEM = { HTTP_SNS_AS3935_EMPTY, HTTP_SNS_AS3935_MSG, HTTP_SNS_AS3935_OUT, HTTP_SNS_AS3935_NOT, HTTP_SNS_AS3935_ABOVE, HTTP_SNS_AS3935_NOISE, HTTP_SNS_AS3935_DISTURB, HTTP_SNS_AS3935_INTNOEV, HTTP_SNS_AS3935_FLICKER, HTTP_SNS_AS3935_POWEROFF };
// Json
const char JSON_SNS_AS3935_EVENTS[] PROGMEM = ",\"%s\":{\"" D_JSON_EVENT "\":%d,\"" D_JSON_DISTANCE "\":%d,\"" D_JSON_ENERGY "\":%u,\"" D_JSON_STAGE "\":%d}";
// Json Command
const char* const S_JSON_AS3935_COMMAND_ONOFF[] PROGMEM = {"\"" D_AS3935_OFF "\"","\"" D_AS3935_ON"\""};
const char* const S_JSON_AS3935_COMMAND_GAIN[] PROGMEM = {"\"" D_AS3935_INDOORS "\"", "\"" D_AS3935_OUTDOORS "\""};
const char* const S_JSON_AS3935_COMMAND_CAL[] PROGMEM = {"" D_AS3935_CAL_FAIL "","" D_AS3935_CAL_OK ""};
const char S_JSON_AS3935_COMMAND_STRING[] PROGMEM = "{\"" D_NAME_AS3935 "\":{\"%s\":%s}}";
const char S_JSON_AS3935_COMMAND_NVALUE[] PROGMEM = "{\"" D_NAME_AS3935 "\":{\"%s\":%d}}";
const char S_JSON_AS3935_COMMAND_SETTINGS[] PROGMEM = "{\"AS3935_Settings\":{\"Gain\":%s,\"NFfloor\":%d,\"uVrms\":%d,\"Tunecaps\":%d,\"MinNumLight\":%d,\"Rejection\":%d,\"Wdthreshold\":%d,\"MinNFstage\":%d,\"NFAutoTime\":%d,\"DisturberAutoTime\":%d,\"Disturber\":%s,\"NFauto\":%s,\"Disturberauto\":%s,\"NFautomax\":%s,\"Mqttlightevent\":%s,\"Mqttnoirqevent\":%s}}";
const char kAS3935_Commands[] PROGMEM = "power|setnf|setminstage|setml|default|setgain|settunecaps|setrej|setwdth|disttime|nftime|disturber|autonf|autodisturber|autonfmax|lightevent|noirqevent|settings|calibrate";
const uint8_t AS3935_VrmsIndoor[] PROGMEM = { 28, 45, 62, 78, 95, 112, 130, 146 };
const uint16_t AS3935_VrmsOutdoor[] PROGMEM = { 390, 630, 860, 1100, 1140, 1570, 1800, 2000 };
enum AS3935_Commands { // commands for Console
CMND_AS3935_POWER, // Power on/off the device (1 Bit)
CMND_AS3935_SET_NF, // Noise Floor Level, value from 0-7 (3 Bit)
CMND_AS3935_SET_MINNF, // Set Min Noise Floor Level when Autotune is active Value from 0-15
CMND_AS3935_SET_MINLIGHT, // Minimum number of lightning 0=1/1=5/2=9/3=16 Lightnings
CMND_AS3935_SET_DEF, // set default for Sensor and Settings
CMND_AS3935_SET_GAIN, // Set Inddoor/Outdoor
CMND_AS3935_SET_TUNE, // Internal Tuning Capacitors (from 0 to 120pF in steps of 8pf)
CMND_AS3935_SET_REJ, // Set Spike Rejection
CMND_AS3935_SET_WDTH, // Watchdog threshold
CMND_AS3935_DISTTIME, // Threshhold Time for Auto Disturber
CMND_AS3935_NFTIME, // Threshhold Time for NF-Autotune
CMND_AS3935_SET_DISTURBER, // Set Disturber on/off
CMND_AS3935_NF_AUTOTUNE, // Autotune the NF Noise
CMND_AS3935_DIST_AUTOTUNE, // Autotune Disturber on/off
CMND_AS3935_NF_ATUNE_BOTH, // Autotune over both Areas: INDOORS/OUDOORS
CMND_AS3935_MQTT_LIGHT_EVT, // mqtt only if lightning Irq
CMND_AS3935_MQTT_NO_IRQ_EVT, // suppress mqtt "IRQ with no Event"
CMND_AS3935_SETTINGS, // Json output of all settings
CMND_AS3935_CALIBRATE // caps autocalibrate
};
struct {
bool active = false;
bool http_count_start = false;
bool poweroff = false;
volatile bool detected = false;
volatile bool dispLCO = false;
volatile uint8_t icount = 0;
uint8_t irq = 0;
uint8_t mqtt_event = 0;
uint8_t http_event = 0;
uint8_t http_time = 0;
uint8_t http_count = 0;
int16_t http_distance = 0;
int16_t distance = 0;
uint16_t nftimer = 0;
uint16_t disttimer = 0;
uint32_t intensity = 0;
uint32_t http_intensity = 0;
volatile uint32_t pulse = 0;
} as3935_sensor;
static void IRAM_ATTR AS3935Isr(void) {
as3935_sensor.detected = true;
as3935_sensor.icount++;
}
// we have to store 5 Bytes in the eeprom. Register 8 is mapped to Byte 4
uint8_t AS3935ReadRegister(uint8_t reg, uint8_t mask, uint8_t shift) {
uint8_t data = I2cRead8(AS3935_ADDR, reg);
if (reg == 0x08) Settings->as3935_sensor_cfg[4] = data;
if (reg <= 0x03) Settings->as3935_sensor_cfg[reg] = data;
return ((data & mask) >> shift);
}
void AS3935WriteRegister(uint8_t reg, uint8_t mask, uint8_t shift, uint8_t data) {
uint8_t currentReg = I2cRead8(AS3935_ADDR, reg);
currentReg &= (~mask);
data <<= shift;
data &= mask;
data |= currentReg;
I2cWrite8(AS3935_ADDR, reg, data);
if (reg == 0x08) Settings->as3935_sensor_cfg[4] = I2cRead8(AS3935_ADDR, reg);
if (reg <= 0x03) Settings->as3935_sensor_cfg[reg] = I2cRead8(AS3935_ADDR, reg);
}
/********************************************************************************************/
// Autotune Caps
static void IRAM_ATTR AS3935CountFreq(void) {
if (as3935_sensor.dispLCO)
as3935_sensor.pulse++;
}
bool AS3935AutoTuneCaps(uint8_t irqpin) {
int32_t maxtune = 17500; // there max 3.5 % tol
uint8_t besttune;
uint8_t oldvalue = AS3935GetTuneCaps();
AS3935WriteRegister(LCO_FDIV, 0); // Fdiv 16
delay(2);
for (uint8_t tune = 0; tune < 16; tune++) {
AS3935WriteRegister(TUNE_CAPS, tune);
delay(2);
AS3935WriteRegister(DISP_LCO, 1);
delay(1);
as3935_sensor.dispLCO = true;
as3935_sensor.pulse = 0;
attachInterrupt(digitalPinToInterrupt(irqpin), AS3935CountFreq, RISING);
delay(50);
as3935_sensor.dispLCO = false;
detachInterrupt(irqpin);
AS3935WriteRegister(DISP_LCO, 0);
int32_t currentfreq = 500000 - ((as3935_sensor.pulse * 20) * 16);
if(currentfreq < 0) currentfreq = -currentfreq;
if(maxtune > currentfreq) {
maxtune = currentfreq;
besttune = tune;
}
}
if (maxtune >= 17500) { // max. 3.5%
AS3935SetTuneCaps(oldvalue);
return false;
}
AS3935SetTuneCaps(besttune);
return true;
}
/********************************************************************************************/
// functions
bool AS3935CalRCOResult(void) {
if(AS3935ReadRegister(CAL_SRCO_NOK) || AS3935ReadRegister(CAL_TRCO_NOK)) {
AddLog(LOG_LEVEL_INFO, PSTR("I2C: AS3935 Fatal Failure of TRCO or SRCO calibration"));
return false;
}
return true;
}
bool AS3935CalibrateRCO(void) {
detachInterrupt(Pin(GPIO_AS3935)); // Prevent AS3935Isr from RCO Calibration
I2cWrite8(AS3935_ADDR, CALIBATE_RCO); // Cal TRCO & SRCO
AS3935WriteRegister(DISP_TRCO, 1); // need for Power up
delay(2);
AS3935WriteRegister(DISP_TRCO, 0);
if(!AS3935CalRCOResult())
return false;
attachInterrupt(digitalPinToInterrupt(Pin(GPIO_AS3935)), AS3935Isr, RISING);
return true;
}
void AS3935Reset(void) {
I2cWrite8(AS3935_ADDR, RESET_DEFAULT);
delay(2);
}
void AS3935PwrDown(void) {
AS3935WriteRegister(PWR_REG ,1);
detachInterrupt(Pin(GPIO_AS3935));
as3935_sensor.poweroff = true;
as3935_sensor.mqtt_event = 9;
as3935_sensor.http_event = 9;
as3935_sensor.intensity = 0;
as3935_sensor.distance = 0;
}
void AS3935PwrUp(void) {
AS3935WriteRegister(PWR_REG ,0);
AS3935CalibrateRCO();
as3935_sensor.poweroff = false;
as3935_sensor.mqtt_event = 0;
as3935_sensor.http_event = 0;
}
uint8_t AS3935GetPwrStat(void) {
if (AS3935ReadRegister(PWR_REG))
return 0;
return 1;
}
uint8_t AS3935GetIRQ(void) {
delay(2);
return AS3935ReadRegister(IRQ_TBL);
}
uint8_t AS3935TranslIrq(uint8_t irq, uint8_t distance) {
switch(irq) {
case 0: return 7; // Interrupt with no IRQ
case 1: return 5; // Noise level too high
case 4: return 6; // Disturber detected
case 8:
if (distance == -1) return 2; // Lightning out of Distance
else if (distance == 0) return 3; // Distance cannot be determined
else if (distance == 1) return 4; // Storm is Overhead
else return 1; // Lightning with Distance detected
}
return 0; // Fix GCC 10.1 warning
}
uint8_t AS3935GetDistance(void) {
return AS3935ReadRegister(LGHT_DIST);
}
int16_t AS3935CalcDistance(void) {
uint8_t dist = AS3935GetDistance();
switch (dist) {
case 0x3F: return -1; // Out of Range
case 0x00: return 0; // Distance cannot be determined
case 0x01: return 1; // Storm is Overhead
default:
if (40 < dist) return 40; // limited because higher is not accurate
return dist;
}
}
uint32_t AS3935GetIntensity(void) {
uint32_t energy_raw = (AS3935ReadRegister(ENERGY_RAW_3) << 8);
energy_raw |= AS3935ReadRegister(ENERGY_RAW_2);
energy_raw <<= 8;
energy_raw |= AS3935ReadRegister(ENERGY_RAW_1);
return energy_raw;
}
uint8_t AS3935GetTuneCaps(void) {
return AS3935ReadRegister(TUNE_CAPS);
}
void AS3935SetTuneCaps(uint8_t tune) {
AS3935WriteRegister(TUNE_CAPS, tune);
delay(2);
AS3935CalibrateRCO();
}
uint8_t AS3935GetDisturber(void) {
return AS3935ReadRegister(DISTURBER);
}
void AS3935SetDisturber(uint8_t stat) {
AS3935WriteRegister(DISTURBER, stat);
}
uint8_t AS3935GetMinLights(void) {
return AS3935ReadRegister(MIN_NUM_LIGH);
}
void AS3935SetMinLights(uint8_t stat) {
AS3935WriteRegister(MIN_NUM_LIGH, stat);
}
uint8_t AS3935TransMinLights(uint8_t min_lights) {
if (5 > min_lights) return 0;
else if (9 > min_lights) return 1;
else if (16 > min_lights) return 2;
else return 3;
}
uint8_t AS3935TranslMinLightsInt(uint8_t min_lights) {
switch (min_lights) {
case 0: return 1;
case 1: return 5;
case 2: return 9;
case 3: return 16;
}
return 0; // Fix GCC 10.1 warning
}
uint8_t AS3935GetNoiseFloor(void) {
return AS3935ReadRegister(NF_LEVEL);
}
void AS3935SetNoiseFloor(uint8_t noise) {
AS3935WriteRegister(NF_LEVEL , noise);
}
uint8_t AS3935GetGain(void) {
if (AS3935ReadRegister(AFE_GB) == OUTDOORS)
return OUTDOORS;
return INDOORS;
}
void AS3935SetGain(uint8_t room) {
AS3935WriteRegister(AFE_GB, room);
}
uint8_t AS3935GetGainInt(void) {
if (AS3935ReadRegister(AFE_GB) == OUTDOORS)
return 1;
return 0;
}
void AS3935CalcVrmsLevel(uint16_t &vrms, uint8_t &stage) {
uint8_t room = AS3935GetGain();
uint8_t nflev = AS3935GetNoiseFloor();
if (room == INDOORS) {
vrms = pgm_read_byte(AS3935_VrmsIndoor + nflev);
stage = nflev;
} else {
vrms = pgm_read_word(AS3935_VrmsOutdoor + nflev);
stage = nflev + 8;
}
}
uint8_t AS3935GetSpikeRejection(void) {
return AS3935ReadRegister(SPIKE_REJECT);
}
void AS3935SetSpikeRejection(uint8_t rej) {
AS3935WriteRegister(SPIKE_REJECT, rej);
}
uint8_t AS3935GetWdth(void) {
return AS3935ReadRegister(WDTH);
}
void AS3935SetWdth(uint8_t wdth) {
AS3935WriteRegister(WDTH, wdth);
}
bool AS3935AutoTune(void) {
detachInterrupt(Pin(GPIO_AS3935));
bool result = AS3935AutoTuneCaps(Pin(GPIO_AS3935));
return result;
}
/********************************************************************************************/
// Noise Floor autofunctions
bool AS3935LowerNoiseFloor(void) {
uint16_t vrms;
uint8_t stage;
AS3935CalcVrmsLevel(vrms, stage);
if (Settings->as3935_functions.nf_autotune_both) {
if (stage == 8 && stage > Settings->as3935_parameter.nf_autotune_min) {
AS3935SetGain(INDOORS);
AS3935SetNoiseFloor(7);
return true;
}
}
uint8_t noise = AS3935GetNoiseFloor();
if (0 < noise && stage > Settings->as3935_parameter.nf_autotune_min) {
noise--;
AS3935SetNoiseFloor(noise);
return true;
}
return false;
}
bool AS3935RaiseNoiseFloor(void) {
uint8_t noise = AS3935GetNoiseFloor();
uint8_t room = AS3935GetGain();
if (Settings->as3935_functions.nf_autotune_both) {
if (7 == noise && room == INDOORS) {
AS3935SetGain(OUTDOORS);
AS3935SetNoiseFloor(0);
return true;
}
}
if (7 > noise) {
noise++;
AS3935SetNoiseFloor(noise);
return true;
}
return false;
}
/********************************************************************************************/
// init functions
bool AS3935SetDefault(void) {
AS3935Reset();
AS3935SetDisturber(1); // Disturber on by default
AS3935SetNoiseFloor(7); // NF High on by default
Settings->as3935_sensor_cfg[0] = I2cRead8(AS3935_ADDR, 0x00);
Settings->as3935_sensor_cfg[1] = I2cRead8(AS3935_ADDR, 0x01);
Settings->as3935_sensor_cfg[2] = I2cRead8(AS3935_ADDR, 0x02);
Settings->as3935_sensor_cfg[3] = I2cRead8(AS3935_ADDR, 0x03);
Settings->as3935_sensor_cfg[4] = I2cRead8(AS3935_ADDR, 0x08);
// set all eeprom functions and values to default
Settings->as3935_functions.data = 0x00;
Settings->as3935_parameter.nf_autotune_min = 0x00;
Settings->as3935_parameter.nf_autotune_time = 4;
Settings->as3935_parameter.dist_autotune_time = 1;
return true;
}
void AS3935InitSettings(void) {
if(Settings->as3935_functions.nf_autotune) {
if(Settings->as3935_parameter.nf_autotune_min) {
if (Settings->as3935_parameter.nf_autotune_min > 7) {
AS3935SetGain(OUTDOORS);
AS3935SetNoiseFloor(Settings->as3935_parameter.nf_autotune_min - 8);
} else {
AS3935SetGain(INDOORS);
AS3935SetNoiseFloor(Settings->as3935_parameter.nf_autotune_min);
}
}
}
I2cWrite8(AS3935_ADDR, 0x00, Settings->as3935_sensor_cfg[0] & SETREG00MASK);
I2cWrite8(AS3935_ADDR, 0x01, Settings->as3935_sensor_cfg[1]);
I2cWrite8(AS3935_ADDR, 0x02, Settings->as3935_sensor_cfg[2]);
I2cWrite8(AS3935_ADDR, 0x03, Settings->as3935_sensor_cfg[3] & SETREG03MASK);
I2cWrite8(AS3935_ADDR, 0x08, Settings->as3935_sensor_cfg[4]);
delay(2);
}
bool AS3935Setup(void) {
if (Settings->as3935_sensor_cfg[0] == 0x00) {
AS3935SetDefault();
} else {
AS3935InitSettings();
}
return AS3935CalibrateRCO();
}
bool AS3935init(void) {
AS3935Reset();
uint8_t afe_gb = I2cRead8(AS3935_ADDR, 0x00) & SETREG00MASK;
if(INDOORS == afe_gb)
return true;
return false;
}
void AS3935Detect(void) {
if (!I2cSetDevice(AS3935_ADDR)) return;
if (AS3935init()) {
I2cSetActiveFound(AS3935_ADDR, D_NAME_AS3935);
if (PinUsed(GPIO_AS3935)) {
pinMode(Pin(GPIO_AS3935), INPUT);
if (!AS3935Setup()) return;
as3935_sensor.active = true;
} else {
AddLog(LOG_LEVEL_INFO, PSTR("I2C: AS3935 GPIO Pin not defined!"));
}
}
}
void AS3935EverySecond(void) {
if (!as3935_sensor.poweroff) { // Power Off
if (as3935_sensor.detected) {
as3935_sensor.detected = false;
as3935_sensor.irq = AS3935GetIRQ(); // 1 = Noise, 4 = Disturber, 8 = storm
if (10 > as3935_sensor.icount) {
switch (as3935_sensor.irq) {
case 1:
if (Settings->as3935_functions.nf_autotune) {
if (AS3935RaiseNoiseFloor())
as3935_sensor.nftimer = 0;
}
break;
case 4:
if (Settings->as3935_functions.dist_autotune) {
AS3935SetDisturber(1);
}
break;
case 8:
as3935_sensor.intensity = AS3935GetIntensity();
as3935_sensor.distance = AS3935CalcDistance();
as3935_sensor.http_intensity = as3935_sensor.intensity;
as3935_sensor.http_distance = as3935_sensor.distance;
break;
}
// http show
as3935_sensor.http_event = AS3935TranslIrq(as3935_sensor.irq, as3935_sensor.distance);
} else {
as3935_sensor.http_event = 8; // flicker detected
}
// mqtt publish
as3935_sensor.mqtt_event = as3935_sensor.http_event;
switch (as3935_sensor.mqtt_event) {
case 5:
case 6:
if (!Settings->as3935_functions.mqtt_only_Light_Event) {
MqttPublishSensor();
as3935_sensor.http_time = 10;
}
break;
case 7:
if (!Settings->as3935_functions.suppress_irq_no_Event) {
MqttPublishSensor();
as3935_sensor.http_time = 10;
}
break;
default:
as3935_sensor.http_time = 30;
MqttPublishSensor();
}
as3935_sensor.irq = 0;
// clear mqtt events for Teleperiod
as3935_sensor.intensity = 0;
as3935_sensor.distance = 0;
as3935_sensor.mqtt_event = 0;
// start http times
as3935_sensor.http_count_start = true;
as3935_sensor.http_count = 0;
}
as3935_sensor.icount = 0;
// count http times
if (as3935_sensor.http_count_start)
as3935_sensor.http_count++;
// clear Http Event
if (as3935_sensor.http_count > as3935_sensor.http_time) {
as3935_sensor.http_count_start = false;
as3935_sensor.http_intensity = 0;
as3935_sensor.http_distance = 0;
as3935_sensor.http_event = 0;
}
// Noise Floor Autotune function
if (Settings->as3935_functions.nf_autotune) {
as3935_sensor.nftimer++;
if (as3935_sensor.nftimer > Settings->as3935_parameter.nf_autotune_time * 60) {
AS3935LowerNoiseFloor();
as3935_sensor.nftimer = 0;
}
}
// Disturber auto function
if (Settings->as3935_functions.dist_autotune) {
if (AS3935GetDisturber()) {
as3935_sensor.disttimer++;
}
if (as3935_sensor.disttimer >= Settings->as3935_parameter.dist_autotune_time * 60) {
AS3935SetDisturber(0);
as3935_sensor.disttimer = 0;
}
}
}
}
bool AS3935Cmd(void) {
char command[CMDSZ];
uint8_t name_len = strlen(D_NAME_AS3935);
if (!strncasecmp_P(XdrvMailbox.topic, PSTR(D_NAME_AS3935), name_len)) {
uint32_t command_code = GetCommandCode(command, sizeof(command), XdrvMailbox.topic + name_len, kAS3935_Commands);
switch (command_code) {
case CMND_AS3935_POWER:
if (XdrvMailbox.data_len) {
if (!XdrvMailbox.payload) {
AS3935PwrDown();
} else {
AS3935PwrUp();
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[AS3935GetPwrStat()]);
break;
case CMND_AS3935_SET_NF:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
AS3935SetNoiseFloor(XdrvMailbox.payload);
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, AS3935GetNoiseFloor());
break;
case CMND_AS3935_SET_MINNF:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
Settings->as3935_parameter.nf_autotune_min = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, Settings->as3935_parameter.nf_autotune_min);
break;
case CMND_AS3935_SET_MINLIGHT:
if (XdrvMailbox.data_len) {
AS3935SetMinLights(AS3935TransMinLights(XdrvMailbox.payload));
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, AS3935TranslMinLightsInt(AS3935GetMinLights()));
break;
case CMND_AS3935_SET_DEF:
if (!XdrvMailbox.data_len) {
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, AS3935SetDefault());
}
break;
case CMND_AS3935_SET_GAIN:
if (XdrvMailbox.data_len > 6) {
uint8_t data_len = strlen(D_AS3935_OUTDOORS);
if (!strncasecmp_P(XdrvMailbox.data, PSTR(D_AS3935_OUTDOORS), data_len)) {
AS3935SetGain(OUTDOORS);
} else {
AS3935SetGain(INDOORS);
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_GAIN[AS3935GetGainInt()]);
break;
case CMND_AS3935_SET_TUNE:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
AS3935SetTuneCaps(XdrvMailbox.payload);
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, AS3935GetTuneCaps());
break;
case CMND_AS3935_SET_REJ:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
AS3935SetSpikeRejection(XdrvMailbox.payload);
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, AS3935GetSpikeRejection());
break;
case CMND_AS3935_SET_WDTH:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
AS3935SetWdth(XdrvMailbox.payload);
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, AS3935GetWdth());
break;
case CMND_AS3935_DISTTIME:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
Settings->as3935_parameter.dist_autotune_time = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, Settings->as3935_parameter.dist_autotune_time);
break;
case CMND_AS3935_NFTIME:
if (XdrvMailbox.data_len) {
if (15 >= XdrvMailbox.payload) {
Settings->as3935_parameter.nf_autotune_time = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_NVALUE, command, Settings->as3935_parameter.nf_autotune_time);
break;
case CMND_AS3935_SET_DISTURBER:
if (XdrvMailbox.data_len) {
if (2 > XdrvMailbox.payload) {
AS3935SetDisturber(XdrvMailbox.payload);
if (!XdrvMailbox.payload) Settings->as3935_functions.dist_autotune = 0;
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[AS3935GetDisturber()]);
break;
case CMND_AS3935_NF_AUTOTUNE:
if (XdrvMailbox.data_len) {
if (2 > XdrvMailbox.payload) {
Settings->as3935_functions.nf_autotune = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[Settings->as3935_functions.nf_autotune]);
break;
case CMND_AS3935_DIST_AUTOTUNE:
if (XdrvMailbox.data_len) {
if (2 > XdrvMailbox.payload) {
Settings->as3935_functions.dist_autotune = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[Settings->as3935_functions.dist_autotune]);
break;
case CMND_AS3935_NF_ATUNE_BOTH:
if (XdrvMailbox.data_len) {
if (2 > XdrvMailbox.payload) {
Settings->as3935_functions.nf_autotune_both = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[Settings->as3935_functions.nf_autotune_both]);
break;
case CMND_AS3935_MQTT_LIGHT_EVT:
if (XdrvMailbox.data_len) {
if (2 > XdrvMailbox.payload) {
Settings->as3935_functions.mqtt_only_Light_Event = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[Settings->as3935_functions.mqtt_only_Light_Event]);
break;
case CMND_AS3935_MQTT_NO_IRQ_EVT:
if (XdrvMailbox.data_len) {
if (2 > XdrvMailbox.payload) {
Settings->as3935_functions.suppress_irq_no_Event = XdrvMailbox.payload;
}
}
Response_P(S_JSON_AS3935_COMMAND_STRING, command, S_JSON_AS3935_COMMAND_ONOFF[Settings->as3935_functions.suppress_irq_no_Event]);
break;
case CMND_AS3935_SETTINGS: {
if (!XdrvMailbox.data_len) {
uint8_t gain = AS3935GetGainInt();
uint16_t vrms;
uint8_t stage;
AS3935CalcVrmsLevel(vrms, stage);
uint8_t nf_floor = AS3935GetNoiseFloor();
uint8_t tunecaps = AS3935GetTuneCaps();
uint8_t minnumlight = AS3935TranslMinLightsInt(AS3935GetMinLights());
uint8_t disturber = AS3935GetDisturber();
uint8_t reinj = AS3935GetSpikeRejection();
uint8_t wdth = AS3935GetWdth();
uint8_t min_nf = Settings->as3935_parameter.nf_autotune_min;
uint8_t nf_time = Settings->as3935_parameter.nf_autotune_time;
uint8_t nfauto = Settings->as3935_functions.nf_autotune;
uint8_t nfautomax = Settings->as3935_functions.nf_autotune_both;
uint8_t distauto = Settings->as3935_functions.dist_autotune;
uint8_t jsonlight = Settings->as3935_functions.mqtt_only_Light_Event;
uint8_t jsonirq = Settings->as3935_functions.suppress_irq_no_Event;
uint8_t dist_time = Settings->as3935_parameter.dist_autotune_time;
Response_P(S_JSON_AS3935_COMMAND_SETTINGS, S_JSON_AS3935_COMMAND_GAIN[gain], nf_floor, vrms, tunecaps, minnumlight, reinj, wdth, min_nf, nf_time, dist_time, S_JSON_AS3935_COMMAND_ONOFF[disturber], S_JSON_AS3935_COMMAND_ONOFF[nfauto], S_JSON_AS3935_COMMAND_ONOFF[distauto], S_JSON_AS3935_COMMAND_ONOFF[nfautomax], S_JSON_AS3935_COMMAND_ONOFF[jsonlight], S_JSON_AS3935_COMMAND_ONOFF[jsonirq]);
}
}
break;
case CMND_AS3935_CALIBRATE: {
bool calreslt;
if (!XdrvMailbox.data_len) calreslt = AS3935AutoTune();
Response_P(S_JSON_AS3935_COMMAND_NVALUE, S_JSON_AS3935_COMMAND_CAL[calreslt], AS3935GetTuneCaps());
}
break;
default:
return false;
}
return true;
} else {
return false;
}
}
void AH3935Show(bool json) {
if (json) {
uint16_t vrms;
uint8_t stage;
AS3935CalcVrmsLevel(vrms, stage);
ResponseAppend_P(JSON_SNS_AS3935_EVENTS, D_SENSOR_AS3935, as3935_sensor.mqtt_event, as3935_sensor.distance, as3935_sensor.intensity, stage);
#ifdef USE_WEBSERVER
} else {
uint8_t gain = AS3935GetGainInt();
uint8_t disturber = AS3935GetDisturber();
uint16_t vrms;
uint8_t stage;
AS3935CalcVrmsLevel(vrms, stage);
WSContentSend_PD(HTTP_SNS_AS3935_TABLE_1[as3935_sensor.http_event], D_NAME_AS3935, as3935_sensor.http_distance);
WSContentSend_PD(HTTP_SNS_AS3935_DISTANZ, as3935_sensor.http_distance);
WSContentSend_PD(HTTP_SNS_AS3935_ENERGY, as3935_sensor.http_intensity);
WSContentSend_PD(HTTP_SNS_AS3935_GAIN[gain], D_NAME_AS3935);
WSContentSend_PD(HTTP_SNS_AS3935_DISTURBER[disturber], D_NAME_AS3935);
WSContentSend_PD(HTTP_SNS_AS3935_VRMS, vrms, stage);
#endif // USE_WEBSERVER
}
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xsns67(uint32_t function) {
if (!I2cEnabled(XI2C_48)) { return false; }
bool result = false;
if (FUNC_INIT == function) {
AS3935Detect();
}
else if (as3935_sensor.active) {
switch (function) {
case FUNC_EVERY_SECOND:
AS3935EverySecond();
break;
case FUNC_COMMAND:
result = AS3935Cmd();
break;
case FUNC_JSON_APPEND:
AH3935Show(1);
break;
#ifdef USE_WEBSERVER
case FUNC_WEB_SENSOR:
AH3935Show(0);
break;
#endif // USE_WEBSERVER
}
}
return result;
}
#endif // USE_AS3935
#endif // USE_I2C
Reference in New Issue View Git Blame Copy Permalink