jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-27 12:46:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change pin handling part 4/4

Browse Source
This commit is contained in:
Theo Arends 2020-04-27 16:47:29 +02:00
parent c939077514
commit 86f801c349
20 changed files with 105 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tasmota/xdrv_10_scripter.ino
View File

@ -1582,7 +1582,7 @@ chknext:
if (!strncmp(vname,"pd[",3)) {
GetNumericResult(vname+3,OPER_EQU,&fvar,0);
uint8_t gpiopin=fvar;
for (uint8_t i=0;i<GPIO_SENSOR_END;i++) {
for (uint8_t i=0;i<GPIO_SENSOR_END;i++) { // Theo/Gemu: This needs to change when pin[] becomes real pin array
// if (pin[i]==gpiopin) {
if (Pin(i)==gpiopin) {
fvar=i;

4
tasmota/xnrg_01_hlw8012.ino
View File

@ -249,8 +249,6 @@ void HlwDrvInit(void)
{
Hlw.model_type = 0; // HLW8012
if (PinUsed(GPIO_HJL_CF)) {
// pin[GPIO_HLW_CF] = pin[GPIO_HJL_CF];
// pin[GPIO_HJL_CF] = 99;
SetPin(Pin(GPIO_HJL_CF), GPIO_HLW_CF);
SetPin(99, GPIO_HJL_CF);
Hlw.model_type = 1; // HJL-01/BL0937
@ -260,8 +258,6 @@ void HlwDrvInit(void)
Hlw.ui_flag = true; // Voltage on high
if (PinUsed(GPIO_NRG_SEL_INV)) {
// pin[GPIO_NRG_SEL] = pin[GPIO_NRG_SEL_INV];
// pin[GPIO_NRG_SEL_INV] = 99;
SetPin(Pin(GPIO_NRG_SEL_INV), GPIO_NRG_SEL);
SetPin(99, GPIO_NRG_SEL_INV);
Hlw.ui_flag = false; // Voltage on low

6
tasmota/xsns_34_hx711.ino
View File

@ -282,9 +282,9 @@ long HxWeight(void)
void HxInit(void)
{
Hx.type = 0;
if ((pin[GPIO_HX711_DAT] < 99) && (pin[GPIO_HX711_SCK] < 99)) {
Hx.pin_sck = pin[GPIO_HX711_SCK];
Hx.pin_dout = pin[GPIO_HX711_DAT];
if (PinUsed(GPIO_HX711_DAT) && PinUsed(GPIO_HX711_SCK)) {
Hx.pin_sck = Pin(GPIO_HX711_SCK);
Hx.pin_dout = Pin(GPIO_HX711_DAT);
pinMode(Hx.pin_sck, OUTPUT);
pinMode(Hx.pin_dout, INPUT);

20
tasmota/xsns_35_tx20.ino
View File

@ -206,7 +206,7 @@ void TX2xStartRead(void)
delayMicroseconds(TX2X_BIT_TIME / 2);
for (int32_t bitcount = 41; bitcount > 0; bitcount--) {
uint32_t dpin = (digitalRead(pin[GPIO_TX2X_TXD_BLACK]));
uint32_t dpin = (digitalRead(Pin(GPIO_TX2X_TXD_BLACK)));
#ifdef USE_TX23_WIND_SENSOR
dpin ^= 1;
#endif // USE_TX23_WIND_SENSOR
@ -263,7 +263,7 @@ void TX2xStartRead(void)
// Must clear this bit in the interrupt register,
// it gets set even when interrupts are disabled
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1 << pin[GPIO_TX2X_TXD_BLACK]);
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1 << Pin(GPIO_TX2X_TXD_BLACK));
}
bool Tx2xAvailable(void)
@ -338,13 +338,13 @@ void Tx2xRead(void)
// TX23 start transmission by pulling down TxD line for at minimum 500ms
// so we pull TxD signal to low every 3 seconds
tx23_stage = 0;
pinMode(pin[GPIO_TX2X_TXD_BLACK], OUTPUT);
digitalWrite(pin[GPIO_TX2X_TXD_BLACK], LOW);
pinMode(Pin(GPIO_TX2X_TXD_BLACK), OUTPUT);
digitalWrite(Pin(GPIO_TX2X_TXD_BLACK), LOW);
} else if ((uptime % TX23_READ_INTERVAL)==1) {
// after pulling down TxD: pull-up TxD every x+1 seconds
// to trigger TX23 start transmission
tx23_stage = 1; // first rising signal is invalid
pinMode(pin[GPIO_TX2X_TXD_BLACK], INPUT_PULLUP);
pinMode(Pin(GPIO_TX2X_TXD_BLACK), INPUT_PULLUP);
}
#endif // USE_TX23_WIND_SENSOR
if (Tx2xAvailable()) {
@ -465,12 +465,12 @@ void Tx2xInit(void)
#endif // USE_TX2X_WIND_SENSOR_NOSTATISTICS
#ifdef USE_TX23_WIND_SENSOR
tx23_stage = 0;
pinMode(pin[GPIO_TX2X_TXD_BLACK], OUTPUT);
digitalWrite(pin[GPIO_TX2X_TXD_BLACK], LOW);
pinMode(Pin(GPIO_TX2X_TXD_BLACK), OUTPUT);
digitalWrite(Pin(GPIO_TX2X_TXD_BLACK), LOW);
#else // USE_TX23_WIND_SENSOR
pinMode(pin[GPIO_TX2X_TXD_BLACK], INPUT);
pinMode(Pin(GPIO_TX2X_TXD_BLACK), INPUT);
#endif // USE_TX23_WIND_SENSOR
attachInterrupt(pin[GPIO_TX2X_TXD_BLACK], TX2xStartRead, RISING);
attachInterrupt(Pin(GPIO_TX2X_TXD_BLACK), TX2xStartRead, RISING);
}
int32_t Tx2xNormalize(int32_t value)
@ -582,7 +582,7 @@ bool Xsns35(uint8_t function)
{
bool result = false;
if (pin[GPIO_TX2X_TXD_BLACK] < 99) {
if (PinUsed(GPIO_TX2X_TXD_BLACK)) {
switch (function) {
case FUNC_INIT:
Tx2xInit();

12
tasmota/xsns_36_mgc3130.ino
View File

@ -39,14 +39,11 @@
#define MGC3130_I2C_ADDR 0x42
#define MGC3130_xfer pin[GPIO_MGC3130_XFER]
#define MGC3130_reset pin[GPIO_MGC3130_RESET]
uint8_t MGC3130_xfer = 0;
uint8_t MGC3130_reset = 0;
bool MGC3130_type = false;
char MGC3130stype[] = "MGC3130";
#define MGC3130_SYSTEM_STATUS 0x15
#define MGC3130_REQUEST_MSG 0x06
#define MGC3130_FW_VERSION 0x83
@ -478,6 +475,9 @@ void MGC3130_detect(void)
{
if (MGC3130_type || I2cActive(MGC3130_I2C_ADDR)) { return; }
MGC3130_xfer = Pin(GPIO_MGC3130_XFER);
MGC3130_reset = Pin(GPIO_MGC3130_RESET);
pinMode(MGC3130_xfer, INPUT_PULLUP);
pinMode(MGC3130_reset, OUTPUT);
digitalWrite(MGC3130_reset, LOW);
@ -588,7 +588,7 @@ bool Xsns36(uint8_t function)
bool result = false;
if ((FUNC_INIT == function) && (pin[GPIO_MGC3130_XFER] < 99) && (pin[GPIO_MGC3130_RESET] < 99)) {
if ((FUNC_INIT == function) && PinUsed(GPIO_MGC3130_XFER) && PinUsed(GPIO_MGC3130_RESET)) {
MGC3130_detect();
}
else if (MGC3130_type) {

10
tasmota/xsns_37_rfsensor.ino
View File

@ -607,9 +607,9 @@ void RfSnsInit(void)
RfSnsInitAlectoV2();
#endif
if (rfsns_any_sensor) {
rfsns_rf_bit = digitalPinToBitMask(pin[GPIO_RF_SENSOR]);
rfsns_rf_port = digitalPinToPort(pin[GPIO_RF_SENSOR]);
pinMode(pin[GPIO_RF_SENSOR], INPUT);
rfsns_rf_bit = digitalPinToBitMask(Pin(GPIO_RF_SENSOR));
rfsns_rf_port = digitalPinToPort(Pin(GPIO_RF_SENSOR));
pinMode(Pin(GPIO_RF_SENSOR), INPUT);
} else {
free(rfsns_raw_signal);
rfsns_raw_signal = nullptr;
@ -654,14 +654,14 @@ bool Xsns37(uint8_t function)
{
bool result = false;
if ((pin[GPIO_RF_SENSOR] < 99) && (FUNC_INIT == function)) {
if (PinUsed(GPIO_RF_SENSOR) && (FUNC_INIT == function)) {
RfSnsInit();
}
else if (rfsns_raw_signal) {
switch (function) {
case FUNC_LOOP:
if ((*portInputRegister(rfsns_rf_port) &rfsns_rf_bit) == rfsns_rf_bit) {
if (RfSnsFetchSignal(pin[GPIO_RF_SENSOR], HIGH)) {
if (RfSnsFetchSignal(Pin(GPIO_RF_SENSOR), HIGH)) {
RfSnsAnalyzeRawSignal();
}
}

4
tasmota/xsns_38_az7798.ino
View File

@ -267,8 +267,8 @@ void AzEverySecond(void)
void AzInit(void)
{
az_type = 0;
if ((pin[GPIO_AZ_RXD] < 99) && (pin[GPIO_AZ_TXD] < 99)) {
AzSerial = new TasmotaSerial(pin[GPIO_AZ_RXD], pin[GPIO_AZ_TXD], 1);
if (PinUsed(GPIO_AZ_RXD) && PinUsed(GPIO_AZ_TXD)) {
AzSerial = new TasmotaSerial(Pin(GPIO_AZ_RXD), Pin(GPIO_AZ_TXD), 1);
if (AzSerial->begin(9600)) {
if (AzSerial->hardwareSerial()) { ClaimSerial(); }
az_type = 1;

24
tasmota/xsns_39_max31855.ino
View File

@ -34,13 +34,13 @@ void MAX31855_Init(void){
return;
// Set GPIO modes for SW-SPI
pinMode(pin[GPIO_MAX31855CS], OUTPUT);
pinMode(pin[GPIO_MAX31855CLK], OUTPUT);
pinMode(pin[GPIO_MAX31855DO], INPUT);
pinMode(Pin(GPIO_MAX31855CS), OUTPUT);
pinMode(Pin(GPIO_MAX31855CLK), OUTPUT);
pinMode(Pin(GPIO_MAX31855DO), INPUT);
// Chip not selected / Clock low
digitalWrite(pin[GPIO_MAX31855CS], HIGH);
digitalWrite(pin[GPIO_MAX31855CLK], LOW);
digitalWrite(Pin(GPIO_MAX31855CS), HIGH);
digitalWrite(Pin(GPIO_MAX31855CLK), LOW);
initialized = true;
}
@ -99,22 +99,22 @@ float MAX31855_GetReferenceTemperature(int32_t RawData){
int32_t MAX31855_ShiftIn(uint8_t Length){
int32_t dataIn = 0;
digitalWrite(pin[GPIO_MAX31855CS], LOW); // CS = LOW -> Start SPI communication
digitalWrite(Pin(GPIO_MAX31855CS), LOW); // CS = LOW -> Start SPI communication
delayMicroseconds(1); // CS fall to output enable = max. 100ns
for (uint32_t i = 0; i < Length; i++)
{
digitalWrite(pin[GPIO_MAX31855CLK], LOW);
digitalWrite(Pin(GPIO_MAX31855CLK), LOW);
delayMicroseconds(1); // CLK pulse width low = min. 100ns / CLK fall to output valid = max. 40ns
dataIn <<= 1;
if(digitalRead(pin[GPIO_MAX31855DO]))
if(digitalRead(Pin(GPIO_MAX31855DO)))
dataIn |= 1;
digitalWrite(pin[GPIO_MAX31855CLK], HIGH);
digitalWrite(Pin(GPIO_MAX31855CLK), HIGH);
delayMicroseconds(1); // CLK pulse width high = min. 100ns
}
digitalWrite(pin[GPIO_MAX31855CS], HIGH); // CS = HIGH -> End SPI communication
digitalWrite(pin[GPIO_MAX31855CLK], LOW);
digitalWrite(Pin(GPIO_MAX31855CS), HIGH); // CS = HIGH -> End SPI communication
digitalWrite(Pin(GPIO_MAX31855CLK), LOW);
return dataIn;
}
@ -151,7 +151,7 @@ void MAX31855_Show(bool Json){
bool Xsns39(uint8_t function)
{
bool result = false;
if((pin[GPIO_MAX31855CS] < 99) && (pin[GPIO_MAX31855CLK] < 99) && (pin[GPIO_MAX31855DO] < 99)){
if(PinUsed(GPIO_MAX31855CS) && PinUsed(GPIO_MAX31855CLK) && PinUsed(GPIO_MAX31855DO)){
switch (function) {
case FUNC_INIT:

4
tasmota/xsns_40_pn532.ino
View File

@ -66,8 +66,8 @@ uint8_t pn532_newdata_len = 0;
void PN532_Init(void)
{
if ((pin[GPIO_PN532_RXD] < 99) && (pin[GPIO_PN532_TXD] < 99)) {
PN532_Serial = new TasmotaSerial(pin[GPIO_PN532_RXD], pin[GPIO_PN532_TXD], 1);
if (PinUsed(GPIO_PN532_RXD9) && PinUsed(GPIO_PN532_TXD)) {
PN532_Serial = new TasmotaSerial(Pin(GPIO_PN532_RXD), Pin(GPIO_PN532_TXD), 1);
if (PN532_Serial->begin(115200)) {
if (PN532_Serial->hardwareSerial()) { ClaimSerial(); }
PN532_wakeup();

15
tasmota/xsns_43_hre.ino
View File

@ -71,10 +71,10 @@ bool hre_good = false;
// The settling times here were determined using a single unit hooked to a scope
int hreReadBit()
{
digitalWrite(pin[GPIO_HRE_CLOCK], HIGH);
digitalWrite(Pin(GPIO_HRE_CLOCK), HIGH);
delay(1);
int bit = digitalRead(pin[GPIO_HRE_DATA]);
digitalWrite(pin[GPIO_HRE_CLOCK], LOW);
int bit = digitalRead(Pin(GPIO_HRE_DATA));
digitalWrite(Pin(GPIO_HRE_CLOCK), LOW);
delay(1);
return bit;
}
@ -110,12 +110,12 @@ void hreInit(void)
hre_read_errors = 0;
hre_good = false;
pinMode(pin[GPIO_HRE_CLOCK], OUTPUT);
pinMode(pin[GPIO_HRE_DATA], INPUT);
pinMode(Pin(GPIO_HRE_CLOCK), OUTPUT);
pinMode(Pin(GPIO_HRE_DATA), INPUT);
// Note that the level shifter inverts this line and we want to leave it
// high when not being read.
digitalWrite(pin[GPIO_HRE_CLOCK], LOW);
digitalWrite(Pin(GPIO_HRE_CLOCK), LOW);
hre_state = hre_sync;
}
@ -260,8 +260,7 @@ void hreShow(boolean json)
bool Xsns43(byte function)
{
// If we don't have pins assigned give up quickly.
if (pin[GPIO_HRE_CLOCK] >= 99 || pin[GPIO_HRE_DATA] >= 99)
return false;
if (!PinUsed(GPIO_HRE_CLOCK) || !PinUsed(GPIO_HRE_DATA)) { return false; }
switch (function)
{

12
tasmota/xsns_47_max31865.ino
View File

@ -51,10 +51,10 @@ void MAX31865_Init(void){
return;
max31865.setPins(
pin[GPIO_SSPI_CS],
pin[GPIO_SSPI_MOSI],
pin[GPIO_SSPI_MISO],
pin[GPIO_SSPI_SCLK]
Pin(GPIO_SSPI_CS),
Pin(GPIO_SSPI_MOSI),
Pin(GPIO_SSPI_MISO),
Pin(GPIO_SSPI_SCLK)
);
if(max31865.begin(PTD_WIRES))
@ -110,8 +110,8 @@ void MAX31865_Show(bool Json){
bool Xsns47(uint8_t function)
{
bool result = false;
if((pin[GPIO_SSPI_MISO] < 99) && (pin[GPIO_SSPI_MOSI] < 99) &&
(pin[GPIO_SSPI_SCLK] < 99) && (pin[GPIO_SSPI_CS] < 99)) {
if (PinUsed(GPIO_SSPI_MISO) && PinUsed(GPIO_SSPI_MOSI) &&
PinUsed(GPIO_SSPI_SCLK) && PinUsed(GPIO_SSPI_CS)) {
switch (function) {
case FUNC_INIT:

4
tasmota/xsns_51_rdm6300.ino
View File

@ -36,8 +36,8 @@ uint8_t rdm_blcnt;
TasmotaSerial *RDM6300_Serial = nullptr;
void RDM6300_Init() {
if (pin[GPIO_RDM6300_RX] < 99) {
RDM6300_Serial = new TasmotaSerial(pin[GPIO_RDM6300_RX],-1,1);
if (PinUsed(GPIO_RDM6300_RX)) {
RDM6300_Serial = new TasmotaSerial(Pin(GPIO_RDM6300_RX),-1,1);
if (RDM6300_Serial->begin(RDM6300_BAUDRATE)) {
if (RDM6300_Serial->hardwareSerial()) {
ClaimSerial();

4
tasmota/xsns_52_ibeacon.ino
View File

@ -95,8 +95,8 @@ void IBEACON_Init() {
hm17_found=0;
// actually doesnt work reliably with software serial
if ((pin[GPIO_IBEACON_RX] < 99) && (pin[GPIO_IBEACON_TX] < 99)) {
IBEACON_Serial = new TasmotaSerial(pin[GPIO_IBEACON_RX], pin[GPIO_IBEACON_TX],1);
if (PinUsed(GPIO_IBEACON_RX) && PinUsed(GPIO_IBEACON_TX)) {
IBEACON_Serial = new TasmotaSerial(Pin(GPIO_IBEACON_RX), Pin(GPIO_IBEACON_TX),1);
if (IBEACON_Serial->begin(HM17_BAUDRATE)) {
if (IBEACON_Serial->hardwareSerial()) {
ClaimSerial();

5
tasmota/xsns_53_sml.ino
View File

@ -1831,8 +1831,9 @@ uint8_t *script_meter;
#endif
bool Gpio_used(uint8_t gpiopin) {
for (uint16_t i=0;i<GPIO_SENSOR_END;i++) {
if (pin[i]==gpiopin) {
for (uint16_t i=0;i<GPIO_SENSOR_END;i++) { // Theo/Gemu: This needs to change when pin[] has becomes real pin array
// if (pin[i]==gpiopin) {
if (Pin(i)==gpiopin) {
return true;
}
}

4
tasmota/xsns_56_hpma.ino
View File

@ -64,8 +64,8 @@ void HpmaSecond(void) // Every second
void HpmaInit(void)
{
hpma_type = 0;
if (pin[GPIO_HPMA_RX] < 99 && pin[GPIO_HPMA_TX] < 99) {
HpmaSerial = new TasmotaSerial(pin[GPIO_HPMA_RX], pin[GPIO_HPMA_TX], 1);
if (PinUsed(GPIO_HPMA_RX) && PinUsed(GPIO_HPMA_TX)) {
HpmaSerial = new TasmotaSerial(Pin(GPIO_HPMA_RX), Pin(GPIO_HPMA_TX), 1);
hpma115S0 = new HPMA115S0(*HpmaSerial);
if (HpmaSerial->begin(9600)) {

4
tasmota/xsns_60_GPS.ino
View File

@ -354,8 +354,8 @@ void UBXTriggerTele(void)
void UBXDetect(void)
{
UBX.mode.init = 0;
if ((pin[GPIO_GPS_RX] < 99) && (pin[GPIO_GPS_TX] < 99)) {
UBXSerial = new TasmotaSerial(pin[GPIO_GPS_RX], pin[GPIO_GPS_TX], 1, 0, UBX_SERIAL_BUFFER_SIZE); // 64 byte buffer is NOT enough
if (PinUsed(GPIO_GPS_RX) && PinUsed(GPIO_GPS_TX)) {
UBXSerial = new TasmotaSerial(Pin(GPIO_GPS_RX), Pin(GPIO_GPS_TX), 1, 0, UBX_SERIAL_BUFFER_SIZE); // 64 byte buffer is NOT enough
if (UBXSerial->begin(9600)) {
DEBUG_SENSOR_LOG(PSTR("UBX: started serial"));
if (UBXSerial->hardwareSerial()) {

2
tasmota/xsns_61_MI_NRF24.ino
View File

@ -241,7 +241,7 @@ static union{
bool MINRFinitBLE(uint8_t _mode)
{
if (MINRF.timer%1000 == 0){ // only re-init every 20 seconds
NRF24radio.begin(pin[GPIO_SPI_CS],pin[GPIO_SPI_DC]);
NRF24radio.begin(Pin(GPIO_SPI_CS),Pin(GPIO_SPI_DC));
NRF24radio.setAutoAck(false);
NRF24radio.setDataRate(RF24_1MBPS);
NRF24radio.disableCRC();

4
tasmota/xsns_62_MI_HM10.ino
View File

@ -403,7 +403,7 @@ uint32_t MIBLEgetSensorSlot(uint8_t (&_serial)[6], uint16_t _type){
void HM10SerialInit(void) {
HM10.mode.init = false;
HM10.serialSpeed = HM10_BAUDRATE;
HM10Serial = new TasmotaSerial(pin[GPIO_HM10_RX], pin[GPIO_HM10_TX], 1, 0, HM10_MAX_RX_BUF);
HM10Serial = new TasmotaSerial(Pin(GPIO_HM10_RX), Pin(GPIO_HM10_TX), 1, 0, HM10_MAX_RX_BUF);
if (HM10Serial->begin(HM10.serialSpeed)) {
AddLog_P2(LOG_LEVEL_DEBUG, PSTR("%s start serial communication fixed to 115200 baud"),D_CMND_HM10);
if (HM10Serial->hardwareSerial()) {
@ -1257,7 +1257,7 @@ bool Xsns62(uint8_t function)
{
bool result = false;
if ((pin[GPIO_HM10_RX] < 99) && (pin[GPIO_HM10_TX] < 99)) {
if (PinUsed(GPIO_HM10_RX) && PinUsed(GPIO_HM10_TX)) {
switch (function) {
case FUNC_INIT:
HM10SerialInit(); // init and start communication

7
tasmota/xsns_64_hrxl.ino
View File

@ -41,9 +41,9 @@ bool hrxl_found = false;
void HRXLInit(void)
{
hrxl_found = false;
if ((pin[GPIO_HRXL_RX] < 99))
if (PinUsed(GPIO_HRXL_RX))
{
HRXLSerial = new TasmotaSerial(pin[GPIO_HRXL_RX], -1, 1);
HRXLSerial = new TasmotaSerial(Pin(GPIO_HRXL_RX), -1, 1);
if (HRXLSerial->begin(9600))
{
if (HRXLSerial->hardwareSerial())
@ -100,8 +100,7 @@ void HRXLShow(bool json)
bool Xsns64(uint8_t function)
{
if (pin[GPIO_HRXL_RX] >= 99)
return false;
if (!PinUsed(GPIO_HRXL_RX)) { return false; }
switch (function)
{

10
tasmota/xsns_67_as3935.ino
View File

@ -401,9 +401,9 @@ void AS3935SetWdth(uint8_t wdth) {
}
bool AS3935AutoTune(){
detachInterrupt(pin[GPIO_AS3935]);
bool result = AS3935AutoTuneCaps(pin[GPIO_AS3935]);
attachInterrupt(digitalPinToInterrupt(pin[GPIO_AS3935]), AS3935Isr, RISING);
detachInterrupt(Pin(GPIO_AS3935));
bool result = AS3935AutoTuneCaps(Pin(GPIO_AS3935));
attachInterrupt(digitalPinToInterrupt(Pin(GPIO_AS3935)), AS3935Isr, RISING);
return result;
}
@ -497,8 +497,8 @@ void AS3935Detect(void) {
if (AS3935init())
{
I2cSetActiveFound(AS3935_ADDR, D_NAME_AS3935);
pinMode(pin[GPIO_AS3935], INPUT);
attachInterrupt(digitalPinToInterrupt(pin[GPIO_AS3935]), AS3935Isr, RISING);
pinMode(Pin(GPIO_AS3935), INPUT);
attachInterrupt(digitalPinToInterrupt(Pin(GPIO_AS3935)), AS3935Isr, RISING);
AS3935Setup();
as3935_active = 1;
}