jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-26 04:06: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)) { if (!strncmp(vname,"pd[",3)) {
GetNumericResult(vname+3,OPER_EQU,&fvar,0); GetNumericResult(vname+3,OPER_EQU,&fvar,0);
uint8_t gpiopin=fvar; 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) {
if (Pin(i)==gpiopin) { if (Pin(i)==gpiopin) {
fvar=i; fvar=i;

4
tasmota/xnrg_01_hlw8012.ino
View File

@ -249,8 +249,6 @@ void HlwDrvInit(void)
{ {
Hlw.model_type = 0; // HLW8012 Hlw.model_type = 0; // HLW8012
if (PinUsed(GPIO_HJL_CF)) { 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(Pin(GPIO_HJL_CF), GPIO_HLW_CF);
SetPin(99, GPIO_HJL_CF); SetPin(99, GPIO_HJL_CF);
Hlw.model_type = 1; // HJL-01/BL0937 Hlw.model_type = 1; // HJL-01/BL0937
@ -260,8 +258,6 @@ void HlwDrvInit(void)
Hlw.ui_flag = true; // Voltage on high Hlw.ui_flag = true; // Voltage on high
if (PinUsed(GPIO_NRG_SEL_INV)) { 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(Pin(GPIO_NRG_SEL_INV), GPIO_NRG_SEL);
SetPin(99, GPIO_NRG_SEL_INV); SetPin(99, GPIO_NRG_SEL_INV);
Hlw.ui_flag = false; // Voltage on low 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) void HxInit(void)
{ {
Hx.type = 0; Hx.type = 0;
if ((pin[GPIO_HX711_DAT] < 99) && (pin[GPIO_HX711_SCK] < 99)) { if (PinUsed(GPIO_HX711_DAT) && PinUsed(GPIO_HX711_SCK)) {
Hx.pin_sck = pin[GPIO_HX711_SCK]; Hx.pin_sck = Pin(GPIO_HX711_SCK);
Hx.pin_dout = pin[GPIO_HX711_DAT]; Hx.pin_dout = Pin(GPIO_HX711_DAT);
pinMode(Hx.pin_sck, OUTPUT); pinMode(Hx.pin_sck, OUTPUT);
pinMode(Hx.pin_dout, INPUT); 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); delayMicroseconds(TX2X_BIT_TIME / 2);
for (int32_t bitcount = 41; bitcount > 0; bitcount--) { 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 #ifdef USE_TX23_WIND_SENSOR
dpin ^= 1; dpin ^= 1;
#endif // USE_TX23_WIND_SENSOR #endif // USE_TX23_WIND_SENSOR
@ -263,7 +263,7 @@ void TX2xStartRead(void)
// Must clear this bit in the interrupt register, // Must clear this bit in the interrupt register,
// it gets set even when interrupts are disabled // 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) bool Tx2xAvailable(void)
@ -338,13 +338,13 @@ void Tx2xRead(void)
// TX23 start transmission by pulling down TxD line for at minimum 500ms // TX23 start transmission by pulling down TxD line for at minimum 500ms
// so we pull TxD signal to low every 3 seconds // so we pull TxD signal to low every 3 seconds
tx23_stage = 0; tx23_stage = 0;
pinMode(pin[GPIO_TX2X_TXD_BLACK], OUTPUT); pinMode(Pin(GPIO_TX2X_TXD_BLACK), OUTPUT);
digitalWrite(pin[GPIO_TX2X_TXD_BLACK], LOW); digitalWrite(Pin(GPIO_TX2X_TXD_BLACK), LOW);
} else if ((uptime % TX23_READ_INTERVAL)==1) { } else if ((uptime % TX23_READ_INTERVAL)==1) {
// after pulling down TxD: pull-up TxD every x+1 seconds // after pulling down TxD: pull-up TxD every x+1 seconds
// to trigger TX23 start transmission // to trigger TX23 start transmission
tx23_stage = 1; // first rising signal is invalid 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 #endif // USE_TX23_WIND_SENSOR
if (Tx2xAvailable()) { if (Tx2xAvailable()) {
@ -465,12 +465,12 @@ void Tx2xInit(void)
#endif // USE_TX2X_WIND_SENSOR_NOSTATISTICS #endif // USE_TX2X_WIND_SENSOR_NOSTATISTICS
#ifdef USE_TX23_WIND_SENSOR #ifdef USE_TX23_WIND_SENSOR
tx23_stage = 0; tx23_stage = 0;
pinMode(pin[GPIO_TX2X_TXD_BLACK], OUTPUT); pinMode(Pin(GPIO_TX2X_TXD_BLACK), OUTPUT);
digitalWrite(pin[GPIO_TX2X_TXD_BLACK], LOW); digitalWrite(Pin(GPIO_TX2X_TXD_BLACK), LOW);
#else // USE_TX23_WIND_SENSOR #else // USE_TX23_WIND_SENSOR
pinMode(pin[GPIO_TX2X_TXD_BLACK], INPUT); pinMode(Pin(GPIO_TX2X_TXD_BLACK), INPUT);
#endif // USE_TX23_WIND_SENSOR #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) int32_t Tx2xNormalize(int32_t value)
@ -582,7 +582,7 @@ bool Xsns35(uint8_t function)
{ {
bool result = false; bool result = false;
if (pin[GPIO_TX2X_TXD_BLACK] < 99) { if (PinUsed(GPIO_TX2X_TXD_BLACK)) {
switch (function) { switch (function) {
case FUNC_INIT: case FUNC_INIT:
Tx2xInit(); Tx2xInit();

12
tasmota/xsns_36_mgc3130.ino
View File

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

10
tasmota/xsns_37_rfsensor.ino
View File

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

4
tasmota/xsns_38_az7798.ino
View File

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

24
tasmota/xsns_39_max31855.ino
View File

@ -34,13 +34,13 @@ void MAX31855_Init(void){
return; return;
// Set GPIO modes for SW-SPI // Set GPIO modes for SW-SPI
pinMode(pin[GPIO_MAX31855CS], OUTPUT); pinMode(Pin(GPIO_MAX31855CS), OUTPUT);
pinMode(pin[GPIO_MAX31855CLK], OUTPUT); pinMode(Pin(GPIO_MAX31855CLK), OUTPUT);
pinMode(pin[GPIO_MAX31855DO], INPUT); pinMode(Pin(GPIO_MAX31855DO), INPUT);
// Chip not selected / Clock low // Chip not selected / Clock low
digitalWrite(pin[GPIO_MAX31855CS], HIGH); digitalWrite(Pin(GPIO_MAX31855CS), HIGH);
digitalWrite(pin[GPIO_MAX31855CLK], LOW); digitalWrite(Pin(GPIO_MAX31855CLK), LOW);
initialized = true; initialized = true;
} }
@ -99,22 +99,22 @@ float MAX31855_GetReferenceTemperature(int32_t RawData){
int32_t MAX31855_ShiftIn(uint8_t Length){ int32_t MAX31855_ShiftIn(uint8_t Length){
int32_t dataIn = 0; 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 delayMicroseconds(1); // CS fall to output enable = max. 100ns
for (uint32_t i = 0; i < Length; i++) 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 delayMicroseconds(1); // CLK pulse width low = min. 100ns / CLK fall to output valid = max. 40ns
dataIn <<= 1; dataIn <<= 1;
if(digitalRead(pin[GPIO_MAX31855DO])) if(digitalRead(Pin(GPIO_MAX31855DO)))
dataIn |= 1; dataIn |= 1;
digitalWrite(pin[GPIO_MAX31855CLK], HIGH); digitalWrite(Pin(GPIO_MAX31855CLK), HIGH);
delayMicroseconds(1); // CLK pulse width high = min. 100ns delayMicroseconds(1); // CLK pulse width high = min. 100ns
} }
digitalWrite(pin[GPIO_MAX31855CS], HIGH); // CS = HIGH -> End SPI communication digitalWrite(Pin(GPIO_MAX31855CS), HIGH); // CS = HIGH -> End SPI communication
digitalWrite(pin[GPIO_MAX31855CLK], LOW); digitalWrite(Pin(GPIO_MAX31855CLK), LOW);
return dataIn; return dataIn;
} }
@ -151,7 +151,7 @@ void MAX31855_Show(bool Json){
bool Xsns39(uint8_t function) bool Xsns39(uint8_t function)
{ {
bool result = false; 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) { switch (function) {
case FUNC_INIT: 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) void PN532_Init(void)
{ {
if ((pin[GPIO_PN532_RXD] < 99) && (pin[GPIO_PN532_TXD] < 99)) { if (PinUsed(GPIO_PN532_RXD9) && PinUsed(GPIO_PN532_TXD)) {
PN532_Serial = new TasmotaSerial(pin[GPIO_PN532_RXD], pin[GPIO_PN532_TXD], 1); PN532_Serial = new TasmotaSerial(Pin(GPIO_PN532_RXD), Pin(GPIO_PN532_TXD), 1);
if (PN532_Serial->begin(115200)) { if (PN532_Serial->begin(115200)) {
if (PN532_Serial->hardwareSerial()) { ClaimSerial(); } if (PN532_Serial->hardwareSerial()) { ClaimSerial(); }
PN532_wakeup(); 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 // The settling times here were determined using a single unit hooked to a scope
int hreReadBit() int hreReadBit()
{ {
digitalWrite(pin[GPIO_HRE_CLOCK], HIGH); digitalWrite(Pin(GPIO_HRE_CLOCK), HIGH);
delay(1); delay(1);
int bit = digitalRead(pin[GPIO_HRE_DATA]); int bit = digitalRead(Pin(GPIO_HRE_DATA));
digitalWrite(pin[GPIO_HRE_CLOCK], LOW); digitalWrite(Pin(GPIO_HRE_CLOCK), LOW);
delay(1); delay(1);
return bit; return bit;
} }
@ -110,12 +110,12 @@ void hreInit(void)
hre_read_errors = 0; hre_read_errors = 0;
hre_good = false; hre_good = false;
pinMode(pin[GPIO_HRE_CLOCK], OUTPUT); pinMode(Pin(GPIO_HRE_CLOCK), OUTPUT);
pinMode(pin[GPIO_HRE_DATA], INPUT); pinMode(Pin(GPIO_HRE_DATA), INPUT);
// Note that the level shifter inverts this line and we want to leave it // Note that the level shifter inverts this line and we want to leave it
// high when not being read. // high when not being read.
digitalWrite(pin[GPIO_HRE_CLOCK], LOW); digitalWrite(Pin(GPIO_HRE_CLOCK), LOW);
hre_state = hre_sync; hre_state = hre_sync;
} }
@ -260,8 +260,7 @@ void hreShow(boolean json)
bool Xsns43(byte function) bool Xsns43(byte function)
{ {
// If we don't have pins assigned give up quickly. // If we don't have pins assigned give up quickly.
if (pin[GPIO_HRE_CLOCK] >= 99 || pin[GPIO_HRE_DATA] >= 99) if (!PinUsed(GPIO_HRE_CLOCK) || !PinUsed(GPIO_HRE_DATA)) { return false; }
return false;
switch (function) switch (function)
{ {

12
tasmota/xsns_47_max31865.ino
View File

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

4
tasmota/xsns_51_rdm6300.ino
View File

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

4
tasmota/xsns_52_ibeacon.ino
View File

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

5
tasmota/xsns_53_sml.ino
View File

@ -1831,8 +1831,9 @@ uint8_t *script_meter;
#endif #endif
bool Gpio_used(uint8_t gpiopin) { bool Gpio_used(uint8_t gpiopin) {
for (uint16_t i=0;i<GPIO_SENSOR_END;i++) { 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) {
if (Pin(i)==gpiopin) {
return true; return true;
} }
} }

4
tasmota/xsns_56_hpma.ino
View File

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

4
tasmota/xsns_60_GPS.ino
View File

@ -354,8 +354,8 @@ void UBXTriggerTele(void)
void UBXDetect(void) void UBXDetect(void)
{ {
UBX.mode.init = 0; UBX.mode.init = 0;
if ((pin[GPIO_GPS_RX] < 99) && (pin[GPIO_GPS_TX] < 99)) { 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 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)) { if (UBXSerial->begin(9600)) {
DEBUG_SENSOR_LOG(PSTR("UBX: started serial")); DEBUG_SENSOR_LOG(PSTR("UBX: started serial"));
if (UBXSerial->hardwareSerial()) { if (UBXSerial->hardwareSerial()) {

60
tasmota/xsns_61_MI_NRF24.ino
View File

@ -27,10 +27,10 @@
0.9.4.0 20200304 integrate - sensor types can be ignored (default for LYWSD03), 0.9.4.0 20200304 integrate - sensor types can be ignored (default for LYWSD03),
add CGD1 (Alarm clock), correct PDU-types for LYWSD02 add CGD1 (Alarm clock), correct PDU-types for LYWSD02
--- ---
0.9.3.0 20200222 integrate - use now the correct id-word instead of MAC-OUI, 0.9.3.0 20200222 integrate - use now the correct id-word instead of MAC-OUI,
add CGG1 add CGG1
--- ---
0.9.2.0 20200212 integrate - "backports" from MI-HM10, change reading pattern, 0.9.2.0 20200212 integrate - "backports" from MI-HM10, change reading pattern,
add missing PDU-types, renaming driver add missing PDU-types, renaming driver
--- ---
0.9.1.0 20200117 integrate - Added support for the LYWSD02 0.9.1.0 20200117 integrate - Added support for the LYWSD02
@ -176,7 +176,7 @@ struct {
uint8_t packetMode; // 0 - normal BLE-advertisements, 1 - 6 "special" sensor packets uint8_t packetMode; // 0 - normal BLE-advertisements, 1 - 6 "special" sensor packets
uint8_t perPage = 4; uint8_t perPage = 4;
uint8_t firstUsedPacketMode = 1; uint8_t firstUsedPacketMode = 1;
FIFO_t buffer; FIFO_t buffer;
struct { struct {
@ -232,16 +232,16 @@ static union{
/********************************************************************************************/ /********************************************************************************************/
/** /**
* @brief * @brief
* *
* @param _mode Packet mode 0-6 * @param _mode Packet mode 0-6
* @return true If no error occured * @return true If no error occured
* @return false If NRF24L01 is not connected * @return false If NRF24L01 is not connected
*/ */
bool MINRFinitBLE(uint8_t _mode) bool MINRFinitBLE(uint8_t _mode)
{ {
if (MINRF.timer%1000 == 0){ // only re-init every 20 seconds 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.setAutoAck(false);
NRF24radio.setDataRate(RF24_1MBPS); NRF24radio.setDataRate(RF24_1MBPS);
NRF24radio.disableCRC(); NRF24radio.disableCRC();
@ -264,7 +264,7 @@ bool MINRFinitBLE(uint8_t _mode)
/** /**
* @brief cycle through the channels 37-39, skip ignored channel * @brief cycle through the channels 37-39, skip ignored channel
* *
*/ */
void MINRFhopChannel() void MINRFhopChannel()
{ {
@ -405,19 +405,19 @@ bool MINRFhandleBeacon(scan_entry_t * entry, uint32_t offset);
/** /**
* @brief handle a generic BLE-packet in the scan process * @brief handle a generic BLE-packet in the scan process
* *
*/ */
void MINRFhandleScan(void){ void MINRFhandleScan(void){
if(MINRFscanResult.size()>20 || MINRF.stopScan) { if(MINRFscanResult.size()>20 || MINRF.stopScan) {
MINRF.activeScan=false; MINRF.activeScan=false;
MINRFcomputefirstUsedPacketMode(); MINRFcomputefirstUsedPacketMode();
uint32_t i = 0; // pass counter as reference to lambda uint32_t i = 0; // pass counter as reference to lambda
MINRFscanResult.erase(std::remove_if(MINRFscanResult.begin(), MINRFscanResult.erase(std::remove_if(MINRFscanResult.begin(),
MINRFscanResult.end(), MINRFscanResult.end(),
[&i](scan_entry_t e) { [&i](scan_entry_t e) {
if(e.showedUp>2) AddLog_P2(LOG_LEVEL_INFO,PSTR("MINRF: Beacon %02u: %02X%02X%02X%02X%02X%02X Cid: %04X Svc: %04X UUID: %04X"),i,e.mac[0],e.mac[1],e.mac[2],e.mac[3],e.mac[4],e.mac[5],e.cid,e.svc,e.uuid); if(e.showedUp>2) AddLog_P2(LOG_LEVEL_INFO,PSTR("MINRF: Beacon %02u: %02X%02X%02X%02X%02X%02X Cid: %04X Svc: %04X UUID: %04X"),i,e.mac[0],e.mac[1],e.mac[2],e.mac[3],e.mac[4],e.mac[5],e.cid,e.svc,e.uuid);
i++; i++;
return ((e.showedUp < 3)); return ((e.showedUp < 3));
}), }),
MINRFscanResult.end()); MINRFscanResult.end());
MINRF.stopScan=false; MINRF.stopScan=false;
@ -447,7 +447,7 @@ void MINRFhandleScan(void){
/** /**
* @brief start beacon mode, can co-exist with Mijia-sniffing * @brief start beacon mode, can co-exist with Mijia-sniffing
* *
* @param entry number of entry in scan list * @param entry number of entry in scan list
*/ */
void MINRFstartBeacon(uint16_t entry){ void MINRFstartBeacon(uint16_t entry){
@ -459,7 +459,7 @@ void MINRFstartBeacon(uint16_t entry){
/** /**
* @brief semi-generic BLE-ADV-parser * @brief semi-generic BLE-ADV-parser
* *
* @param entry Entry of scan list * @param entry Entry of scan list
* @param offset Depends on the reading mode: 0->regular BLE-ADV, 6->"cutted" BLE-ADV with MAC as PDU * @param offset Depends on the reading mode: 0->regular BLE-ADV, 6->"cutted" BLE-ADV with MAC as PDU
* @return true - when name, cid, uuid or svc is found with any value * @return true - when name, cid, uuid or svc is found with any value
@ -536,7 +536,7 @@ bool MINRFhandleBeacon(scan_entry_t * entry, uint32_t offset){
/** /**
* @brief increase beacon timer every second and process the result * @brief increase beacon timer every second and process the result
* *
*/ */
void MINRFbeaconCounter(void){ void MINRFbeaconCounter(void){
if(MINRF.beacon.active) { if(MINRF.beacon.active) {
@ -550,7 +550,7 @@ void MINRFbeaconCounter(void){
/** /**
* @brief compute "PDU" from MAC for each possible channel and store it globally * @brief compute "PDU" from MAC for each possible channel and store it globally
* *
*/ */
void MINRFcomputeBeaconPDU(void){ void MINRFcomputeBeaconPDU(void){
for (uint32_t i = 0; i<3; i++){ for (uint32_t i = 0; i<3; i++){
@ -570,7 +570,7 @@ void MINRFcomputeBeaconPDU(void){
/** /**
* @brief reverse 6-byte-array, hard-coded size of 6 * @brief reverse 6-byte-array, hard-coded size of 6
* *
* @param _mac pass an uint_t[6] * @param _mac pass an uint_t[6]
*/ */
void MINRFreverseMAC(uint8_t _mac[]){ void MINRFreverseMAC(uint8_t _mac[]){
@ -582,8 +582,8 @@ void MINRFreverseMAC(uint8_t _mac[]){
} }
/** /**
* @brief * @brief
* *
* @param _string input string in format: AABBCCDDEEFF (upper case!) * @param _string input string in format: AABBCCDDEEFF (upper case!)
* @param _mac target byte array with fixed size of 6 * @param _mac target byte array with fixed size of 6
*/ */
@ -594,7 +594,7 @@ void MINRFMACStringToBytes(char* _string, uint8_t _mac[]) { //uppercase
uint8_t value = 0; uint8_t value = 0;
if(c >= '0' && c <= '9') if(c >= '0' && c <= '9')
value = (c - '0'); value = (c - '0');
else if (c >= 'A' && c <= 'F') else if (c >= 'A' && c <= 'F')
value = (10 + (c - 'A')); value = (10 + (c - 'A'));
_mac[(index/2)] += value << (((index + 1) % 2) * 4); _mac[(index/2)] += value << (((index + 1) % 2) * 4);
index++; index++;
@ -604,7 +604,7 @@ void MINRFMACStringToBytes(char* _string, uint8_t _mac[]) { //uppercase
/** /**
* @brief helper function, to avoid to start with an ignored sensor type * @brief helper function, to avoid to start with an ignored sensor type
* *
*/ */
void MINRFcomputefirstUsedPacketMode(void){ void MINRFcomputefirstUsedPacketMode(void){
for (uint32_t i = 0; i<CGD1; i++){ for (uint32_t i = 0; i<CGD1; i++){
@ -675,7 +675,7 @@ uint32_t MINRFgetSensorSlot(uint8_t (&_serial)[6], uint16_t _type){
} }
} }
if(!_success) return 0xff; if(!_success) return 0xff;
DEBUG_SENSOR_LOG(PSTR("MINRF: vector size %u"), MIBLEsensors.size()); DEBUG_SENSOR_LOG(PSTR("MINRF: vector size %u"), MIBLEsensors.size());
for(uint32_t i=0; i<MIBLEsensors.size(); i++){ for(uint32_t i=0; i<MIBLEsensors.size(); i++){
if(memcmp(_serial,MIBLEsensors[i].serial,sizeof(_serial))==0){ if(memcmp(_serial,MIBLEsensors[i].serial,sizeof(_serial))==0){
@ -724,7 +724,7 @@ uint32_t MINRFgetSensorSlot(uint8_t (&_serial)[6], uint16_t _type){
void MINRFpurgeFakeSensors(void){ void MINRFpurgeFakeSensors(void){
for(uint32_t i=0; i<MIBLEsensors.size(); i++){ for(uint32_t i=0; i<MIBLEsensors.size(); i++){
DEBUG_SENSOR_LOG(PSTR("MINRF: remove FAKE %s at slot: %u"),kMINRFSlaveType[MIBLEsensors[i].type-1], i); DEBUG_SENSOR_LOG(PSTR("MINRF: remove FAKE %s at slot: %u"),kMINRFSlaveType[MIBLEsensors[i].type-1], i);
MIBLEsensors.erase(std::remove_if(MIBLEsensors.begin(), MIBLEsensors.erase(std::remove_if(MIBLEsensors.begin(),
MIBLEsensors.end(), MIBLEsensors.end(),
[](mi_sensor_t i) { return ((i.showedUp < 3 || bitRead(MINRF.ignore,i.type))); }), [](mi_sensor_t i) { return ((i.showedUp < 3 || bitRead(MINRF.ignore,i.type))); }),
MIBLEsensors.end()); MIBLEsensors.end());
@ -747,7 +747,7 @@ void MINRFconfirmSensors(void){
/** /**
* @brief generic MiBeacon parser * @brief generic MiBeacon parser
* *
*/ */
void MINRFhandleMiBeaconPacket(void){ void MINRFhandleMiBeaconPacket(void){
MINRFreverseMAC(MINRF.buffer.miBeacon.Mac); MINRFreverseMAC(MINRF.buffer.miBeacon.Mac);
@ -784,7 +784,7 @@ void MINRFhandleMiBeaconPacket(void){
case 0x07: case 0x07:
_sensorVec->lux=MINRF.buffer.miBeacon.lux & 0x00ffffff; _sensorVec->lux=MINRF.buffer.miBeacon.lux & 0x00ffffff;
DEBUG_SENSOR_LOG(PSTR("Mode 7: U24: %u Lux"), MINRF.buffer.miBeacon.lux & 0x00ffffff); DEBUG_SENSOR_LOG(PSTR("Mode 7: U24: %u Lux"), MINRF.buffer.miBeacon.lux & 0x00ffffff);
break; break;
case 0x08: case 0x08:
_tempFloat =(float)MINRF.buffer.miBeacon.moist; _tempFloat =(float)MINRF.buffer.miBeacon.moist;
if(_tempFloat<100){ if(_tempFloat<100){
@ -881,7 +881,7 @@ void MINRFhandleCGD1Packet(void){ // no MiBeacon
\*********************************************************************************************/ \*********************************************************************************************/
void MINRF_EVERY_50_MSECOND() { // Every 50mseconds void MINRF_EVERY_50_MSECOND() { // Every 50mseconds
if(MINRF.timer>6000){ // happens every 6000/20 = 300 seconds if(MINRF.timer>6000){ // happens every 6000/20 = 300 seconds
DEBUG_SENSOR_LOG(PSTR("MINRF: check for FAKE sensors")); DEBUG_SENSOR_LOG(PSTR("MINRF: check for FAKE sensors"));
MINRFpurgeFakeSensors(); MINRFpurgeFakeSensors();
@ -890,7 +890,7 @@ void MINRF_EVERY_50_MSECOND() { // Every 50mseconds
MINRF.timer++; MINRF.timer++;
if (!MINRFreceivePacket()){ if (!MINRFreceivePacket()){
// DEBUG_SENSOR_LOG(PSTR("MINRF: nothing received")); // DEBUG_SENSOR_LOG(PSTR("MINRF: nothing received"));
} }
else { else {
@ -1057,7 +1057,7 @@ void MINRFShow(bool json)
} }
ResponseAppend_P(PSTR(",\"%s-%02x%02x%02x\":{"),kMINRFSlaveType[MIBLEsensors[i].type-1],MIBLEsensors[i].serial[3],MIBLEsensors[i].serial[4],MIBLEsensors[i].serial[5]); ResponseAppend_P(PSTR(",\"%s-%02x%02x%02x\":{"),kMINRFSlaveType[MIBLEsensors[i].type-1],MIBLEsensors[i].serial[3],MIBLEsensors[i].serial[4],MIBLEsensors[i].serial[5]);
if (MIBLEsensors[i].type==FLORA && !isnan(MIBLEsensors[i].temp)){ if (MIBLEsensors[i].type==FLORA && !isnan(MIBLEsensors[i].temp)){
char stemp[FLOATSZ]; char stemp[FLOATSZ];
dtostrfd(MIBLEsensors[i].temp, Settings.flag2.temperature_resolution, stemp); dtostrfd(MIBLEsensors[i].temp, Settings.flag2.temperature_resolution, stemp);
ResponseAppend_P(PSTR("\"" D_JSON_TEMPERATURE "\":%s"), stemp); ResponseAppend_P(PSTR("\"" D_JSON_TEMPERATURE "\":%s"), stemp);
@ -1074,7 +1074,7 @@ void MINRFShow(bool json)
} }
ResponseJsonEnd(); ResponseJsonEnd();
} }
if (MIBLEsensors[i].type>FLORA){ if (MIBLEsensors[i].type>FLORA){
if(!isnan(MIBLEsensors[i].temp) && !isnan(MIBLEsensors[i].hum)){ if(!isnan(MIBLEsensors[i].temp) && !isnan(MIBLEsensors[i].hum)){
ResponseAppendTHD(MIBLEsensors[i].temp,MIBLEsensors[i].hum); ResponseAppendTHD(MIBLEsensors[i].temp,MIBLEsensors[i].hum);
} }
@ -1112,7 +1112,7 @@ void MINRFShow(bool json)
continue; continue;
} }
WSContentSend_PD(HTTP_MINRF_HL); WSContentSend_PD(HTTP_MINRF_HL);
WSContentSend_PD(HTTP_MINRF_MAC, kMINRFSlaveType[MIBLEsensors[i].type-1], D_MAC_ADDRESS, MIBLEsensors[i].serial[0], MIBLEsensors[i].serial[1],MIBLEsensors[i].serial[2],MIBLEsensors[i].serial[3],MIBLEsensors[i].serial[4],MIBLEsensors[i].serial[5]); WSContentSend_PD(HTTP_MINRF_MAC, kMINRFSlaveType[MIBLEsensors[i].type-1], D_MAC_ADDRESS, MIBLEsensors[i].serial[0], MIBLEsensors[i].serial[1],MIBLEsensors[i].serial[2],MIBLEsensors[i].serial[3],MIBLEsensors[i].serial[4],MIBLEsensors[i].serial[5]);
if (MIBLEsensors[i].type==FLORA){ if (MIBLEsensors[i].type==FLORA){
if(!isnan(MIBLEsensors[i].temp)){ if(!isnan(MIBLEsensors[i].temp)){
char temperature[FLOATSZ]; char temperature[FLOATSZ];
@ -1139,7 +1139,7 @@ void MINRFShow(bool json)
if(MINRF.beacon.active){ if(MINRF.beacon.active){
WSContentSend_PD(HTTP_MINRF_HL); WSContentSend_PD(HTTP_MINRF_HL);
WSContentSend_PD(HTTP_MINRF_HL); WSContentSend_PD(HTTP_MINRF_HL);
WSContentSend_PD(HTTP_MINRF_MAC, F("Beacon"), D_MAC_ADDRESS, MINRF.beacon.mac[0], MINRF.beacon.mac[1],MINRF.beacon.mac[2],MINRF.beacon.mac[3],MINRF.beacon.mac[4],MINRF.beacon.mac[5]); WSContentSend_PD(HTTP_MINRF_MAC, F("Beacon"), D_MAC_ADDRESS, MINRF.beacon.mac[0], MINRF.beacon.mac[1],MINRF.beacon.mac[2],MINRF.beacon.mac[3],MINRF.beacon.mac[4],MINRF.beacon.mac[5]);
WSContentSend_PD(PSTR("{s}Beacon Time{m}%u seconds{e}"),MINRF.beacon.time); WSContentSend_PD(PSTR("{s}Beacon Time{m}%u seconds{e}"),MINRF.beacon.time);
} }
if(counter>3) { if(counter>3) {

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) { void HM10SerialInit(void) {
HM10.mode.init = false; HM10.mode.init = false;
HM10.serialSpeed = HM10_BAUDRATE; 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)) { if (HM10Serial->begin(HM10.serialSpeed)) {
AddLog_P2(LOG_LEVEL_DEBUG, PSTR("%s start serial communication fixed to 115200 baud"),D_CMND_HM10); AddLog_P2(LOG_LEVEL_DEBUG, PSTR("%s start serial communication fixed to 115200 baud"),D_CMND_HM10);
if (HM10Serial->hardwareSerial()) { if (HM10Serial->hardwareSerial()) {
@ -1257,7 +1257,7 @@ bool Xsns62(uint8_t function)
{ {
bool result = false; 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) { switch (function) {
case FUNC_INIT: case FUNC_INIT:
HM10SerialInit(); // init and start communication HM10SerialInit(); // init and start communication

7
tasmota/xsns_64_hrxl.ino
View File

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

10
tasmota/xsns_67_as3935.ino
View File

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