Home-IoT/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-11-28 17:54:13 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

loads more changes

Browse source
This commit is contained in:
Daniël Koek 2024-01-30 19:14:44 +00:00
parent b70d44e6c2
commit 7b55449229
4 changed files with 1246 additions and 1361 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
esphome/components/ebyte_lora_e220/ebyte_lora_e220.h
View file

@ -4,15 +4,18 @@
#include <HardwareSerial.h> #include <HardwareSerial.h>
#include "esphome/core/helpers.h" #include "esphome/core/helpers.h"
#include "lora_e220.h" #include "lora_e220.h"
#include "esphome/components/uart/uart.h"
namespace esphome { namespace esphome {
namespace ebyte_lora_e220 { namespace ebyte_lora_e220 {
static const char *const TAG = "ebyte_lora_e220";
// there are 3 UART ports, we are going to be using 0, which is D6 and D7 // there are 3 UART ports, we are going to be using 0, which is D6 and D7
HardwareSerial LoraSerial(0); HardwareSerial LoraSerial(0);
LoRa_E220 e220ttl(&LoraSerial, D2, D0, D1); // SERIAL AUX M0 M1 LoRa_E220 e220ttl(&LoraSerial, D2, D0, D1); // SERIAL AUX M0 M1
class LoRaSensors : public text_sensor::TextSensor, public PollingComponent { class LoRaSensors : public text_sensor::TextSensor, public PollingComponent, public uart::UARTDevice {
public: public:
LoRaSensors() : PollingComponent(4000) {} LoRaSensors() : PollingComponent(4000) {}

867
esphome/components/ebyte_lora_e220/lora_e220.cpp
View file

File diff suppressed because it is too large Load diff

172
esphome/components/ebyte_lora_e220/lora_e220.h
View file

@ -1,39 +1,23 @@
#ifndef LoRa_E220_h #ifndef LoRa_E220_h
#define LoRa_E220_h #define LoRa_E220_h
#if !USE_ESP32 && !defined(__STM32F1__) && !defined(__STM32F4__)
#define ACTIVATE_SOFTWARE_SERIAL
#endif
#ifdef USE_ESP32 #ifdef USE_ESP32
#define HARDWARE_SERIAL_SELECTABLE_PIN #define HARDWARE_SERIAL_SELECTABLE_PIN
#endif
#ifdef ACTIVATE_SOFTWARE_SERIAL
#include <SoftwareSerial.h>
#endif #endif
#include "state_naming.h" #include "state_naming.h"
#include "Arduino.h" #include "Arduino.h"
#define MAX_SIZE_TX_PACKET 200 #define MAX_SIZE_TX_PACKET 200
// Uncomment to enable printing out nice debug messages. // Uncomment to enable printing out nice debug messages.
//#define LoRa_E220_DEBUG // #define LoRa_E220_DEBUG
// Define where debug output will be printed. // Define where debug output will be printed.
#define DEBUG_PRINTER Serial #define DEBUG_PRINTER Serial
// Setup debug printing macros. static const char *const TAG = "ebyte_lora_e220";
#ifdef LoRa_E220_DEBUG
#define DEBUG_PRINT(...) { DEBUG_PRINTER.print(__VA_ARGS__); }
#define DEBUG_PRINTLN(...) { DEBUG_PRINTER.println(__VA_ARGS__); }
#else
#define DEBUG_PRINT(...) {}
#define DEBUG_PRINTLN(...) {}
#endif
enum MODE_TYPE { enum MODE_TYPE {
MODE_0_NORMAL = 0, MODE_0_NORMAL = 0,
MODE_0_TRANSMISSION = 0, MODE_0_TRANSMISSION = 0,
@ -71,7 +55,7 @@ enum PACKET_LENGHT {
PL_SPED = 0x01, PL_SPED = 0x01,
PL_OPTION = 0x01, PL_OPTION = 0x01,
PL_TRANSMISSION_MODE= 0x01, PL_TRANSMISSION_MODE = 0x01,
PL_CHANNEL = 0x01, PL_CHANNEL = 0x01,
PL_CRYPT = 0x02, PL_CRYPT = 0x02,
PL_PID = 0x03 PL_PID = 0x03
@ -79,63 +63,45 @@ enum PACKET_LENGHT {
#pragma pack(push, 1) #pragma pack(push, 1)
struct Speed { struct Speed {
uint8_t airDataRate :3; //bit 0-2 uint8_t airDataRate : 3; // bit 0-2
std::string getAirDataRateDescription() { std::string getAirDataRateDescription() { return getAirDataRateDescriptionByParams(this->airDataRate); }
return getAirDataRateDescriptionByParams(this->airDataRate);
}
uint8_t uartParity :2; //bit 3-4 uint8_t uartParity : 2; // bit 3-4
std::string getUARTParityDescription() { std::string getUARTParityDescription() { return getUARTParityDescriptionByParams(this->uartParity); }
return getUARTParityDescriptionByParams(this->uartParity);
}
uint8_t uartBaudRate :3; //bit 5-7
std::string getUARTBaudRateDescription() {
return getUARTBaudRateDescriptionByParams(this->uartBaudRate);
}
uint8_t uartBaudRate : 3; // bit 5-7
std::string getUARTBaudRateDescription() { return getUARTBaudRateDescriptionByParams(this->uartBaudRate); }
}; };
struct TransmissionMode { struct TransmissionMode {
byte WORPeriod :3; //bit 2,1,0 byte WORPeriod : 3; // bit 2,1,0
std::string getWORPeriodByParamsDescription() { std::string getWORPeriodByParamsDescription() { return getWORPeriodByParams(this->WORPeriod); }
return getWORPeriodByParams(this->WORPeriod); byte reserved2 : 1; // bit 3
} byte enableLBT : 1; // bit 4
byte reserved2 :1; //bit 3 std::string getLBTEnableByteDescription() { return getLBTEnableByteByParams(this->enableLBT); }
byte enableLBT :1; //bit 4 byte reserved : 1; // bit 5
std::string getLBTEnableByteDescription() {
return getLBTEnableByteByParams(this->enableLBT);
}
byte reserved :1; //bit 5
byte fixedTransmission :1; //bit 6 byte fixedTransmission : 1; // bit 6
std::string getFixedTransmissionDescription() { std::string getFixedTransmissionDescription() {
return getFixedTransmissionDescriptionByParams(this->fixedTransmission); return getFixedTransmissionDescriptionByParams(this->fixedTransmission);
} }
byte enableRSSI :1; //bit 7 byte enableRSSI : 1; // bit 7
std::string getRSSIEnableByteDescription() { std::string getRSSIEnableByteDescription() { return getRSSIEnableByteByParams(this->enableRSSI); }
return getRSSIEnableByteByParams(this->enableRSSI);
}
}; };
struct Option { struct Option {
uint8_t transmissionPower :2; //bit 0-1 uint8_t transmissionPower : 2; // bit 0-1
std::string getTransmissionPowerDescription() { std::string getTransmissionPowerDescription() {
return getTransmissionPowerDescriptionByParams(this->transmissionPower); return getTransmissionPowerDescriptionByParams(this->transmissionPower);
} }
uint8_t reserved :3; //bit 2-4 uint8_t reserved : 3; // bit 2-4
uint8_t RSSIAmbientNoise :1; //bit 5 uint8_t RSSIAmbientNoise : 1; // bit 5
std::string getRSSIAmbientNoiseEnable() { std::string getRSSIAmbientNoiseEnable() { return getRSSIAmbientNoiseEnableByParams(this->RSSIAmbientNoise); }
return getRSSIAmbientNoiseEnableByParams(this->RSSIAmbientNoise);
}
uint8_t subPacketSetting :2; //bit 6-7
std::string getSubPacketSetting() {
return getSubPacketSettingByParams(this->subPacketSetting);
}
uint8_t subPacketSetting : 2; // bit 6-7
std::string getSubPacketSetting() { return getSubPacketSettingByParams(this->subPacketSetting); }
}; };
struct Crypt { struct Crypt {
@ -155,9 +121,7 @@ struct Configuration {
struct Option OPTION; struct Option OPTION;
byte CHAN = 0; byte CHAN = 0;
std::string getChannelDescription() { std::string getChannelDescription() { return std::string(this->CHAN + OPERATING_FREQUENCY) + F("MHz"); }
return std::string(this->CHAN + OPERATING_FREQUENCY) + F("MHz");
}
struct TransmissionMode TRANSMISSION_MODE; struct TransmissionMode TRANSMISSION_MODE;
@ -176,18 +140,14 @@ struct ModuleInformation {
struct ResponseStatus { struct ResponseStatus {
std::std::string code; std::std::string code;
std::std::string getResponseDescription() { std::std::string getResponseDescription() { return getResponseDescriptionByParams(this->code); }
return getResponseDescriptionByParams(this->code);
}
}; };
struct ResponseStructContainer { struct ResponseStructContainer {
void *data; void *data;
byte rssi; byte rssi;
ResponseStatus status; ResponseStatus status;
void close() { void close() { free(this->data); }
free(this->data);
}
}; };
struct ResponseContainer { struct ResponseContainer {
std::string data; std::string data;
@ -195,50 +155,34 @@ struct ResponseContainer {
ResponseStatus status; ResponseStatus status;
}; };
struct ConfigurationMessage struct ConfigurationMessage {
{
byte specialCommand1 = 0xCF; byte specialCommand1 = 0xCF;
byte specialCommand2 = 0xCF; byte specialCommand2 = 0xCF;
unsigned char message[]; unsigned char message[];
}; };
//struct FixedStransmission { // struct FixedStransmission {
// byte ADDL = 0; // byte ADDL = 0;
// byte ADDH = 0; // byte ADDH = 0;
// byte CHAN = 0; // byte CHAN = 0;
// void *message; // void *message;
//}; // };
#pragma pack(pop) #pragma pack(pop)
class LoRa_E220 { class LoRa_E220 {
public: public:
#ifdef ACTIVATE_SOFTWARE_SERIAL LoRa_E220(HardwareSerial *serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(byte txE220pin, byte rxE220pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); LoRa_E220(HardwareSerial *serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(byte txE220pin, byte rxE220pin, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); LoRa_E220(HardwareSerial *serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(byte txE220pin, byte rxE220pin, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
#endif
LoRa_E220(HardwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
#ifdef HARDWARE_SERIAL_SELECTABLE_PIN #ifdef HARDWARE_SERIAL_SELECTABLE_PIN
LoRa_E220(byte txE220pin, byte rxE220pin, HardwareSerial* serial, UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1); LoRa_E220(byte txE220pin, byte rxE220pin, HardwareSerial *serial, UART_BPS_RATE bpsRate,
LoRa_E220(byte txE220pin, byte rxE220pin, HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1); uint32_t serialConfig = SERIAL_8N1);
LoRa_E220(byte txE220pin, byte rxE220pin, HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1); LoRa_E220(byte txE220pin, byte rxE220pin, HardwareSerial *serial, byte auxPin, UART_BPS_RATE bpsRate,
uint32_t serialConfig = SERIAL_8N1);
LoRa_E220(byte txE220pin, byte rxE220pin, HardwareSerial *serial, byte auxPin, byte m0Pin, byte m1Pin,
UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1);
#endif #endif
#ifdef ACTIVATE_SOFTWARE_SERIAL
LoRa_E220(SoftwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(SoftwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
LoRa_E220(SoftwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);
#endif
// LoRa_E220(byte txE220pin, byte rxE220pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, MODE_TYPE mode = MODE_0_NORMAL);
// LoRa_E220(HardwareSerial* serial = &Serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, MODE_TYPE mode = MODE_0_NORMAL);
// LoRa_E220(SoftwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, MODE_TYPE mode = MODE_0_NORMAL);
bool begin(); bool begin();
Status setMode(MODE_TYPE mode); Status setMode(MODE_TYPE mode);
MODE_TYPE getMode(); MODE_TYPE getMode();
@ -264,22 +208,19 @@ class LoRa_E220 {
ResponseStatus sendFixedMessage(byte ADDH, byte ADDL, byte CHAN, const std::string message); ResponseStatus sendFixedMessage(byte ADDH, byte ADDL, byte CHAN, const std::string message);
ResponseStatus sendFixedMessage(byte ADDH,byte ADDL, byte CHAN, const void *message, const uint8_t size); ResponseStatus sendFixedMessage(byte ADDH, byte ADDL, byte CHAN, const void *message, const uint8_t size);
ResponseStatus sendBroadcastFixedMessage(byte CHAN, const void *message, const uint8_t size); ResponseStatus sendBroadcastFixedMessage(byte CHAN, const void *message, const uint8_t size);
ResponseStatus sendBroadcastFixedMessage(byte CHAN, const std::string message); ResponseStatus sendBroadcastFixedMessage(byte CHAN, const std::string message);
ResponseContainer receiveInitialMessage(const uint8_t size); ResponseContainer receiveInitialMessage(const uint8_t size);
ResponseStatus sendConfigurationMessage( byte ADDH,byte ADDL, byte CHAN, Configuration *configuration, PROGRAM_COMMAND programCommand = WRITE_CFG_PWR_DWN_SAVE); ResponseStatus sendConfigurationMessage(byte ADDH, byte ADDL, byte CHAN, Configuration *configuration,
PROGRAM_COMMAND programCommand = WRITE_CFG_PWR_DWN_SAVE);
int available(); int available();
private: private:
HardwareSerial* hs; HardwareSerial *hs;
#ifdef ACTIVATE_SOFTWARE_SERIAL
SoftwareSerial* ss;
#endif
bool isSoftwareSerial = true; bool isSoftwareSerial = true;
int8_t txE220pin = -1; int8_t txE220pin = -1;
@ -300,34 +241,23 @@ class LoRa_E220 {
UART_BPS_RATE bpsRate = UART_BPS_RATE_9600; UART_BPS_RATE bpsRate = UART_BPS_RATE_9600;
struct NeedsStream { struct NeedsStream {
template<typename T> template<typename T> void begin(T &t, uint32_t baud) {
void begin(T &t, uint32_t baud) { ESP_LOGD(TAG, "Begin ");
DEBUG_PRINTLN("Begin ");
t.setTimeout(500); t.setTimeout(500);
t.begin(baud); t.begin(baud);
stream = &t; stream = &t;
} }
#ifdef HARDWARE_SERIAL_SELECTABLE_PIN #ifdef HARDWARE_SERIAL_SELECTABLE_PIN
// template< typename T > template<typename T> void begin(T &t, uint32_t baud, uint32_t config) {
// void begin( T &t, uint32_t baud, SerialConfig config ){ ESP_LOGD(TAG, "Begin ");
// DEBUG_PRINTLN("Begin ");
// t.setTimeout(500);
// t.begin(baud, config);
// stream = &t;
// }
//
template< typename T >
void begin( T &t, uint32_t baud, uint32_t config ) {
DEBUG_PRINTLN("Begin ");
t.setTimeout(500); t.setTimeout(500);
t.begin(baud, config); t.begin(baud, config);
stream = &t; stream = &t;
} }
template< typename T > template<typename T> void begin(T &t, uint32_t baud, uint32_t config, int8_t txE220pin, int8_t rxE220pin) {
void begin( T &t, uint32_t baud, uint32_t config, int8_t txE220pin, int8_t rxE220pin ) { ESP_LOGD(TAG, "Begin ");
DEBUG_PRINTLN("Begin ");
t.setTimeout(500); t.setTimeout(500);
t.begin(baud, config, txE220pin, rxE220pin); t.begin(baud, config, txE220pin, rxE220pin);
stream = &t; stream = &t;

309
esphome/components/ebyte_lora_e220/state_naming.h
View file

@ -1,19 +1,19 @@
#include "Arduino.h" #include "Arduino.h"
#ifdef FREQUENCY_433 #ifdef FREQUENCY_433
#define OPERATING_FREQUENCY 410 #define OPERATING_FREQUENCY 410
#elif defined(FREQUENCY_400) #elif defined(FREQUENCY_400)
#define OPERATING_FREQUENCY 410 #define OPERATING_FREQUENCY 410
#elif defined(FREQUENCY_230) #elif defined(FREQUENCY_230)
#define OPERATING_FREQUENCY 220 #define OPERATING_FREQUENCY 220
#elif defined(FREQUENCY_868) #elif defined(FREQUENCY_868)
#define OPERATING_FREQUENCY 850 #define OPERATING_FREQUENCY 850
#elif defined(FREQUENCY_900) #elif defined(FREQUENCY_900)
#define OPERATING_FREQUENCY 850 #define OPERATING_FREQUENCY 850
#elif defined(FREQUENCY_915) #elif defined(FREQUENCY_915)
#define OPERATING_FREQUENCY 900 #define OPERATING_FREQUENCY 900
#else #else
#define OPERATING_FREQUENCY 410 #define OPERATING_FREQUENCY 410
#endif #endif
#define BROADCAST_ADDRESS 255 #define BROADCAST_ADDRESS 255
@ -39,86 +39,77 @@ typedef enum RESPONSE_STATUS {
ERR_E220_PACKET_TOO_BIG ERR_E220_PACKET_TOO_BIG
} Status; } Status;
static String getResponseDescriptionByParams(byte status){ static std::string getResponseDescriptionByParams(byte status) {
switch (status) switch (status) {
{
case E220_SUCCESS: case E220_SUCCESS:
return F("Success"); return "Success";
break; break;
case ERR_E220_UNKNOWN: case ERR_E220_UNKNOWN:
return F("Unknown"); return "Unknown";
break; break;
case ERR_E220_NOT_SUPPORT: case ERR_E220_NOT_SUPPORT:
return F("Not support!"); return "Not support!";
break; break;
case ERR_E220_NOT_IMPLEMENT: case ERR_E220_NOT_IMPLEMENT:
return F("Not implement"); return "Not implement";
break; break;
case ERR_E220_NOT_INITIAL: case ERR_E220_NOT_INITIAL:
return F("Not initial!"); return "Not initial!";
break; break;
case ERR_E220_INVALID_PARAM: case ERR_E220_INVALID_PARAM:
return F("Invalid param!"); return "Invalid param!";
break; break;
case ERR_E220_DATA_SIZE_NOT_MATCH: case ERR_E220_DATA_SIZE_NOT_MATCH:
return F("Data size not match!"); return "Data size not match!";
break; break;
case ERR_E220_BUF_TOO_SMALL: case ERR_E220_BUF_TOO_SMALL:
return F("Buff too small!"); return "Buff too small!";
break; break;
case ERR_E220_TIMEOUT: case ERR_E220_TIMEOUT:
return F("Timeout!!"); return "Timeout!!";
break; break;
case ERR_E220_HARDWARE: case ERR_E220_HARDWARE:
return F("Hardware error!"); return "Hardware error!";
break; break;
case ERR_E220_HEAD_NOT_RECOGNIZED: case ERR_E220_HEAD_NOT_RECOGNIZED:
return F("Save mode returned not recognized!"); return "Save mode returned not recognized!";
break; break;
case ERR_E220_NO_RESPONSE_FROM_DEVICE: case ERR_E220_NO_RESPONSE_FROM_DEVICE:
return F("No response from device! (Check wiring)"); return "No response from device! (Check wiring)";
break; break;
case ERR_E220_WRONG_UART_CONFIG: case ERR_E220_WRONG_UART_CONFIG:
return F("Wrong UART configuration! (BPS must be 9600 for configuration)"); return "Wrong UART configuration! (BPS must be 9600 for configuration)";
break; break;
case ERR_E220_PACKET_TOO_BIG: case ERR_E220_PACKET_TOO_BIG:
return F("The device support only 200byte of data transmission!"); return "The device support only 200byte of data transmission!";
break; break;
default: default:
return F("Invalid status!"); return "Invalid status!";
} }
} }
enum E220_UART_PARITY enum E220_UART_PARITY { MODE_00_8N1 = 0b00, MODE_01_8O1 = 0b01, MODE_10_8E1 = 0b10, MODE_11_8N1 = 0b11 };
{
MODE_00_8N1 = 0b00,
MODE_01_8O1 = 0b01,
MODE_10_8E1 = 0b10,
MODE_11_8N1 = 0b11
};
static String getUARTParityDescriptionByParams(byte uartParity){ static std::string getUARTParityDescriptionByParams(byte uartParity) {
switch (uartParity) switch (uartParity) {
{
case MODE_00_8N1: case MODE_00_8N1:
return F("8N1 (Default)"); return "8N1 (Default)";
break; break;
case MODE_01_8O1: case MODE_01_8O1:
return F("8O1"); return "8O1";
break; break;
case MODE_10_8E1: case MODE_10_8E1:
return F("8E1"); return "8E1";
break; break;
case MODE_11_8N1: case MODE_11_8N1:
return F("8N1 (equal to 00"); return "8N1 (equal to 00";
break; break;
default: default:
return F("Invalid UART Parity!"); return "Invalid UART Parity!";
} }
} }
enum UART_BPS_TYPE enum UART_BPS_TYPE {
{
UART_BPS_1200 = 0b000, UART_BPS_1200 = 0b000,
UART_BPS_2400 = 0b001, UART_BPS_2400 = 0b001,
UART_BPS_4800 = 0b010, UART_BPS_4800 = 0b010,
@ -129,8 +120,7 @@ enum UART_BPS_TYPE
UART_BPS_115200 = 0b111 UART_BPS_115200 = 0b111
}; };
enum UART_BPS_RATE enum UART_BPS_RATE {
{
UART_BPS_RATE_1200 = 1200, UART_BPS_RATE_1200 = 1200,
UART_BPS_RATE_2400 = 2400, UART_BPS_RATE_2400 = 2400,
UART_BPS_RATE_4800 = 4800, UART_BPS_RATE_4800 = 4800,
@ -141,41 +131,38 @@ enum UART_BPS_RATE
UART_BPS_RATE_115200 = 115200 UART_BPS_RATE_115200 = 115200
}; };
static String getUARTBaudRateDescriptionByParams(byte uartBaudRate) static std::string getUARTBaudRateDescriptionByParams(byte uartBaudRate) {
{ switch (uartBaudRate) {
switch (uartBaudRate)
{
case UART_BPS_1200: case UART_BPS_1200:
return F("1200bps"); return "1200bps";
break; break;
case UART_BPS_2400: case UART_BPS_2400:
return F("2400bps"); return "2400bps";
break; break;
case UART_BPS_4800: case UART_BPS_4800:
return F("4800bps"); return "4800bps";
break; break;
case UART_BPS_9600: case UART_BPS_9600:
return F("9600bps (default)"); return "9600bps (default)";
break; break;
case UART_BPS_19200: case UART_BPS_19200:
return F("19200bps"); return "19200bps";
break; break;
case UART_BPS_38400: case UART_BPS_38400:
return F("38400bps"); return "38400bps";
break; break;
case UART_BPS_57600: case UART_BPS_57600:
return F("57600bps"); return "57600bps";
break; break;
case UART_BPS_115200: case UART_BPS_115200:
return F("115200bps"); return "115200bps";
break; break;
default: default:
return F("Invalid UART Baud Rate!"); return "Invalid UART Baud Rate!";
} }
} }
enum AIR_DATA_RATE enum AIR_DATA_RATE {
{
AIR_DATA_RATE_000_24 = 0b000, AIR_DATA_RATE_000_24 = 0b000,
AIR_DATA_RATE_001_24 = 0b001, AIR_DATA_RATE_001_24 = 0b001,
AIR_DATA_RATE_010_24 = 0b010, AIR_DATA_RATE_010_24 = 0b010,
@ -186,37 +173,34 @@ enum AIR_DATA_RATE
AIR_DATA_RATE_111_625 = 0b111 AIR_DATA_RATE_111_625 = 0b111
}; };
static std::string getAirDataRateDescriptionByParams(byte airDataRate) {
static String getAirDataRateDescriptionByParams(byte airDataRate) switch (airDataRate) {
{
switch (airDataRate)
{
case AIR_DATA_RATE_000_24: case AIR_DATA_RATE_000_24:
return F("2.4kbps"); return "2.4kbps";
break; break;
case AIR_DATA_RATE_001_24: case AIR_DATA_RATE_001_24:
return F("2.4kbps"); return "2.4kbps";
break; break;
case AIR_DATA_RATE_010_24: case AIR_DATA_RATE_010_24:
return F("2.4kbps (default)"); return "2.4kbps (default)";
break; break;
case AIR_DATA_RATE_011_48: case AIR_DATA_RATE_011_48:
return F("4.8kbps"); return "4.8kbps";
break; break;
case AIR_DATA_RATE_100_96: case AIR_DATA_RATE_100_96:
return F("9.6kbps"); return "9.6kbps";
break; break;
case AIR_DATA_RATE_101_192: case AIR_DATA_RATE_101_192:
return F("19.2kbps"); return "19.2kbps";
break; break;
case AIR_DATA_RATE_110_384: case AIR_DATA_RATE_110_384:
return F("38.4kbps"); return "38.4kbps";
break; break;
case AIR_DATA_RATE_111_625: case AIR_DATA_RATE_111_625:
return F("62.5kbps"); return "62.5kbps";
break; break;
default: default:
return F("Invalid Air Data Rate!"); return "Invalid Air Data Rate!";
} }
} }
@ -227,43 +211,36 @@ enum SUB_PACKET_SETTING {
SPS_032_11 = 0b11 SPS_032_11 = 0b11
}; };
static String getSubPacketSettingByParams(byte subPacketSetting) static std::string getSubPacketSettingByParams(byte subPacketSetting) {
{ switch (subPacketSetting) {
switch (subPacketSetting)
{
case SPS_200_00: case SPS_200_00:
return F("200bytes (default)"); return "200bytes (default)";
break; break;
case SPS_128_01: case SPS_128_01:
return F("128bytes"); return "128bytes";
break; break;
case SPS_064_10: case SPS_064_10:
return F("64bytes"); return "64bytes";
break; break;
case SPS_032_11: case SPS_032_11:
return F("32bytes"); return "32bytes";
break; break;
default: default:
return F("Invalid Sub Packet Setting!"); return "Invalid Sub Packet Setting!";
} }
} }
enum RSSI_AMBIENT_NOISE_ENABLE { enum RSSI_AMBIENT_NOISE_ENABLE { RSSI_AMBIENT_NOISE_ENABLED = 0b1, RSSI_AMBIENT_NOISE_DISABLED = 0b0 };
RSSI_AMBIENT_NOISE_ENABLED = 0b1, static std::string getRSSIAmbientNoiseEnableByParams(byte rssiAmbientNoiseEnabled) {
RSSI_AMBIENT_NOISE_DISABLED = 0b0 switch (rssiAmbientNoiseEnabled) {
};
static String getRSSIAmbientNoiseEnableByParams(byte rssiAmbientNoiseEnabled)
{
switch (rssiAmbientNoiseEnabled)
{
case RSSI_AMBIENT_NOISE_ENABLED: case RSSI_AMBIENT_NOISE_ENABLED:
return F("Enabled"); return "Enabled";
break; break;
case RSSI_AMBIENT_NOISE_DISABLED: case RSSI_AMBIENT_NOISE_DISABLED:
return F("Disabled (default)"); return "Disabled (default)";
break; break;
default: default:
return F("Invalid RSSI Ambient Noise enabled!"); return "Invalid RSSI Ambient Noise enabled!";
} }
} }
@ -278,186 +255,158 @@ enum WOR_PERIOD {
WOR_4000_111 = 0b111 WOR_4000_111 = 0b111
}; };
static String getWORPeriodByParams(byte WORPeriod) static std::string getWORPeriodByParams(byte WORPeriod) {
{ switch (WORPeriod) {
switch (WORPeriod)
{
case WOR_500_000: case WOR_500_000:
return F("500ms"); return "500ms";
break; break;
case WOR_1000_001: case WOR_1000_001:
return F("1000ms"); return "1000ms";
break; break;
case WOR_1500_010: case WOR_1500_010:
return F("1500ms"); return "1500ms";
break; break;
case WOR_2000_011: case WOR_2000_011:
return F("2000ms (default)"); return "2000ms (default)";
break; break;
case WOR_2500_100: case WOR_2500_100:
return F("2500ms"); return "2500ms";
break; break;
case WOR_3000_101: case WOR_3000_101:
return F("3000ms"); return "3000ms";
break; break;
case WOR_3500_110: case WOR_3500_110:
return F("3500ms"); return "3500ms";
break; break;
case WOR_4000_111: case WOR_4000_111:
return F("4000ms"); return "4000ms";
break; break;
default: default:
return F("Invalid WOR period!"); return "Invalid WOR period!";
} }
} }
enum LBT_ENABLE_BYTE { enum LBT_ENABLE_BYTE { LBT_ENABLED = 0b1, LBT_DISABLED = 0b0 };
LBT_ENABLED = 0b1, static std::string getLBTEnableByteByParams(byte LBTEnableByte) {
LBT_DISABLED = 0b0 switch (LBTEnableByte) {
};
static String getLBTEnableByteByParams(byte LBTEnableByte)
{
switch (LBTEnableByte)
{
case LBT_ENABLED: case LBT_ENABLED:
return F("Enabled"); return "Enabled";
break; break;
case LBT_DISABLED: case LBT_DISABLED:
return F("Disabled (default)"); return "Disabled (default)";
break; break;
default: default:
return F("Invalid LBT enable byte!"); return "Invalid LBT enable byte!";
} }
} }
enum RSSI_ENABLE_BYTE { enum RSSI_ENABLE_BYTE { RSSI_ENABLED = 0b1, RSSI_DISABLED = 0b0 };
RSSI_ENABLED = 0b1, static std::string getRSSIEnableByteByParams(byte RSSIEnableByte) {
RSSI_DISABLED = 0b0 switch (RSSIEnableByte) {
};
static String getRSSIEnableByteByParams(byte RSSIEnableByte)
{
switch (RSSIEnableByte)
{
case RSSI_ENABLED: case RSSI_ENABLED:
return F("Enabled"); return "Enabled";
break; break;
case RSSI_DISABLED: case RSSI_DISABLED:
return F("Disabled (default)"); return "Disabled (default)";
break; break;
default: default:
return F("Invalid RSSI enable byte!"); return "Invalid RSSI enable byte!";
} }
} }
enum FIDEX_TRANSMISSION enum FIDEX_TRANSMISSION { FT_TRANSPARENT_TRANSMISSION = 0b0, FT_FIXED_TRANSMISSION = 0b1 };
{
FT_TRANSPARENT_TRANSMISSION = 0b0,
FT_FIXED_TRANSMISSION = 0b1
};
static std::string getFixedTransmissionDescriptionByParams(byte fixedTransmission) {
static String getFixedTransmissionDescriptionByParams(byte fixedTransmission) switch (fixedTransmission) {
{
switch (fixedTransmission)
{
case FT_TRANSPARENT_TRANSMISSION: case FT_TRANSPARENT_TRANSMISSION:
return F("Transparent transmission (default)"); return "Transparent transmission (default)";
break; break;
case FT_FIXED_TRANSMISSION: case FT_FIXED_TRANSMISSION:
return F("Fixed transmission (first three bytes can be used as high/low address and channel)"); return "Fixed transmission (first three bytes can be used as high/low address and channel)";
break; break;
default: default:
return F("Invalid fixed transmission param!"); return "Invalid fixed transmission param!";
} }
} }
#ifdef E220_22 #ifdef E220_22
enum TRANSMISSION_POWER enum TRANSMISSION_POWER {
{
POWER_22 = 0b00, POWER_22 = 0b00,
POWER_17 = 0b01, POWER_17 = 0b01,
POWER_13 = 0b10, POWER_13 = 0b10,
POWER_10 = 0b11 POWER_10 = 0b11
}; };
static String getTransmissionPowerDescriptionByParams(byte transmissionPower) static std::string getTransmissionPowerDescriptionByParams(byte transmissionPower) {
{ switch (transmissionPower) {
switch (transmissionPower)
{
case POWER_22: case POWER_22:
return F("22dBm (Default)"); return "22dBm (Default)";
break; break;
case POWER_17: case POWER_17:
return F("17dBm"); return "17dBm";
break; break;
case POWER_13: case POWER_13:
return F("13dBm"); return "13dBm";
break; break;
case POWER_10: case POWER_10:
return F("10dBm"); return "10dBm";
break; break;
default: default:
return F("Invalid transmission power param"); return "Invalid transmission power param";
}
} }
}
#elif defined(E220_30) #elif defined(E220_30)
enum TRANSMISSION_POWER enum TRANSMISSION_POWER {
{
POWER_30 = 0b00, POWER_30 = 0b00,
POWER_27 = 0b01, POWER_27 = 0b01,
POWER_24 = 0b10, POWER_24 = 0b10,
POWER_21 = 0b11 POWER_21 = 0b11
}; };
static String getTransmissionPowerDescriptionByParams(byte transmissionPower) static std::string getTransmissionPowerDescriptionByParams(byte transmissionPower) {
{ switch (transmissionPower) {
switch (transmissionPower)
{
case POWER_30: case POWER_30:
return F("30dBm (Default)"); return "30dBm (Default)";
break; break;
case POWER_27: case POWER_27:
return F("27dBm"); return "27dBm";
break; break;
case POWER_24: case POWER_24:
return F("24dBm"); return "24dBm";
break; break;
case POWER_21: case POWER_21:
return F("21dBm"); return "21dBm";
break; break;
default: default:
return F("Invalid transmission power param"); return "Invalid transmission power param";
}
} }
}
#else #else
enum TRANSMISSION_POWER enum TRANSMISSION_POWER {
{
POWER_22 = 0b00, POWER_22 = 0b00,
POWER_17 = 0b01, POWER_17 = 0b01,
POWER_13 = 0b10, POWER_13 = 0b10,
POWER_10 = 0b11 POWER_10 = 0b11
}; };
static String getTransmissionPowerDescriptionByParams(byte transmissionPower) static std::string getTransmissionPowerDescriptionByParams(byte transmissionPower) {
{ switch (transmissionPower) {
switch (transmissionPower)
{
case POWER_22: case POWER_22:
return F("22dBm (Default)"); return "22dBm (Default)";
break; break;
case POWER_17: case POWER_17:
return F("17dBm"); return "17dBm";
break; break;
case POWER_13: case POWER_13:
return F("13dBm"); return "13dBm";
break; break;
case POWER_10: case POWER_10:
return F("10dBm"); return "10dBm";
break; break;
default: default:
return F("Invalid transmission power param"); return "Invalid transmission power param";
}
} }
}
#endif #endif