Home-IoT/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-11-24 16:08:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Very basic start

Browse source
This commit is contained in:
Daniël Koek 2024-01-30 18:24:17 +00:00
parent 92798751c2
commit b70d44e6c2
5 changed files with 1887 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

0
esphome/components/ebyte_lora_e220/__init__.py Normal file
View file

41
esphome/components/ebyte_lora_e220/ebyte_lora_e220.h Normal file
View file

@ -0,0 +1,41 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/text_sensor/text_sensor.h"
#include <HardwareSerial.h>
#include "esphome/core/helpers.h"
#include "lora_e220.h"
namespace esphome {
namespace ebyte_lora_e220 {
// there are 3 UART ports, we are going to be using 0, which is D6 and D7
HardwareSerial LoraSerial(0);
LoRa_E220 e220ttl(&LoraSerial, D2, D0, D1); // SERIAL AUX M0 M1
class LoRaSensors : public text_sensor::TextSensor, public PollingComponent {
public:
LoRaSensors() : PollingComponent(4000) {}
void setup() override { e220ttl.begin(); }
void update() override {
// This will be called by App.loop()
if (e220ttl.available() > 1) {
// read the String message
ResponseContainer rc = e220ttl.receiveMessageRSSI();
// Is something goes wrong print error
if (rc.status.code != 1) {
this->publish_state(rc.status.getResponseDescription());
} else {
// Print the data received
this->publish_state(rc.status.getResponseDescription());
this->publish_state(rc.data);
this->publish_state(rc.rssi + "");
}
}
}
};
} // namespace ebyte_lora_e220
} // namespace esphome

1022
esphome/components/ebyte_lora_e220/lora_e220.cpp Normal file
View file

File diff suppressed because it is too large Load diff

361
esphome/components/ebyte_lora_e220/lora_e220.h Normal file
View file

@ -0,0 +1,361 @@
#ifndef LoRa_E220_h
#define LoRa_E220_h
#if !USE_ESP32 && !defined(__STM32F1__) && !defined(__STM32F4__)
#define ACTIVATE_SOFTWARE_SERIAL
#endif
#ifdef USE_ESP32
#define HARDWARE_SERIAL_SELECTABLE_PIN
#endif
#ifdef ACTIVATE_SOFTWARE_SERIAL
#include <SoftwareSerial.h>
#endif
#include "state_naming.h"
#include "Arduino.h"
#define MAX_SIZE_TX_PACKET 200
// Uncomment to enable printing out nice debug messages.
//#define LoRa_E220_DEBUG
// Define where debug output will be printed.
#define DEBUG_PRINTER Serial
// Setup debug printing macros.
#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 {
MODE_0_NORMAL = 0,
MODE_0_TRANSMISSION = 0,
MODE_1_WOR_TRANSMITTER = 1,
MODE_1_WOR = 1,
MODE_2_WOR_RECEIVER = 2,
MODE_2_POWER_SAVING = 2,
MODE_3_CONFIGURATION = 3,
MODE_3_PROGRAM = 3,
MODE_3_SLEEP = 3,
MODE_INIT = 0xFF
};
enum PROGRAM_COMMAND {
WRITE_CFG_PWR_DWN_SAVE = 0xC0,
READ_CONFIGURATION = 0xC1,
WRITE_CFG_PWR_DWN_LOSE = 0xC2,
WRONG_FORMAT = 0xFF,
RETURNED_COMMAND = 0xC1,
SPECIAL_WIFI_CONF_COMMAND = 0xCF
};
enum REGISTER_ADDRESS {
REG_ADDRESS_CFG = 0x00,
REG_ADDRESS_SPED = 0x02,
REG_ADDRESS_TRANS_MODE = 0x03,
REG_ADDRESS_CHANNEL = 0x04,
REG_ADDRESS_OPTION = 0x05,
REG_ADDRESS_CRYPT = 0x06,
REG_ADDRESS_PID = 0x08
};
enum PACKET_LENGHT {
PL_CONFIGURATION = 0x08,
PL_SPED = 0x01,
PL_OPTION = 0x01,
PL_TRANSMISSION_MODE= 0x01,
PL_CHANNEL = 0x01,
PL_CRYPT = 0x02,
PL_PID = 0x03
};
#pragma pack(push, 1)
struct Speed {
uint8_t airDataRate :3; //bit 0-2
std::string getAirDataRateDescription() {
return getAirDataRateDescriptionByParams(this->airDataRate);
}
uint8_t uartParity :2; //bit 3-4
std::string getUARTParityDescription() {
return getUARTParityDescriptionByParams(this->uartParity);
}
uint8_t uartBaudRate :3; //bit 5-7
std::string getUARTBaudRateDescription() {
return getUARTBaudRateDescriptionByParams(this->uartBaudRate);
}
};
struct TransmissionMode {
byte WORPeriod :3; //bit 2,1,0
std::string getWORPeriodByParamsDescription() {
return getWORPeriodByParams(this->WORPeriod);
}
byte reserved2 :1; //bit 3
byte enableLBT :1; //bit 4
std::string getLBTEnableByteDescription() {
return getLBTEnableByteByParams(this->enableLBT);
}
byte reserved :1; //bit 5
byte fixedTransmission :1; //bit 6
std::string getFixedTransmissionDescription() {
return getFixedTransmissionDescriptionByParams(this->fixedTransmission);
}
byte enableRSSI :1; //bit 7
std::string getRSSIEnableByteDescription() {
return getRSSIEnableByteByParams(this->enableRSSI);
}
};
struct Option {
uint8_t transmissionPower :2; //bit 0-1
std::string getTransmissionPowerDescription() {
return getTransmissionPowerDescriptionByParams(this->transmissionPower);
}
uint8_t reserved :3; //bit 2-4
uint8_t RSSIAmbientNoise :1; //bit 5
std::string getRSSIAmbientNoiseEnable() {
return getRSSIAmbientNoiseEnableByParams(this->RSSIAmbientNoise);
}
uint8_t subPacketSetting :2; //bit 6-7
std::string getSubPacketSetting() {
return getSubPacketSettingByParams(this->subPacketSetting);
}
};
struct Crypt {
byte CRYPT_H = 0;
byte CRYPT_L = 0;
};
struct Configuration {
byte COMMAND = 0;
byte STARTING_ADDRESS = 0;
byte LENGHT = 0;
byte ADDH = 0;
byte ADDL = 0;
struct Speed SPED;
struct Option OPTION;
byte CHAN = 0;
std::string getChannelDescription() {
return std::string(this->CHAN + OPERATING_FREQUENCY) + F("MHz");
}
struct TransmissionMode TRANSMISSION_MODE;
struct Crypt CRYPT;
};
struct ModuleInformation {
byte COMMAND = 0;
byte STARTING_ADDRESS = 0;
byte LENGHT = 0;
byte model = 0;
byte version = 0;
byte features = 0;
};
struct ResponseStatus {
std::std::string code;
std::std::string getResponseDescription() {
return getResponseDescriptionByParams(this->code);
}
};
struct ResponseStructContainer {
void *data;
byte rssi;
ResponseStatus status;
void close() {
free(this->data);
}
};
struct ResponseContainer {
std::string data;
byte rssi;
ResponseStatus status;
};
struct ConfigurationMessage
{
byte specialCommand1 = 0xCF;
byte specialCommand2 = 0xCF;
unsigned char message[];
};
//struct FixedStransmission {
// byte ADDL = 0;
// byte ADDH = 0;
// byte CHAN = 0;
// void *message;
//};
#pragma pack(pop)
class LoRa_E220 {
public:
#ifdef ACTIVATE_SOFTWARE_SERIAL
LoRa_E220(byte txE220pin, byte rxE220pin, 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(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
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, 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
#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();
Status setMode(MODE_TYPE mode);
MODE_TYPE getMode();
ResponseStructContainer getConfiguration();
ResponseStatus setConfiguration(Configuration configuration, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);
ResponseStructContainer getModuleInformation();
ResponseStatus resetModule();
ResponseStatus sendMessage(const void *message, const uint8_t size);
ResponseContainer receiveMessageUntil(char delimiter = '\0');
ResponseStructContainer receiveMessage(const uint8_t size);
ResponseStructContainer receiveMessageRSSI(const uint8_t size);
ResponseStructContainer receiveMessageComplete(const uint8_t size, bool enableRSSI);
ResponseContainer receiveMessageComplete(bool enableRSSI);
ResponseStatus sendMessage(const std::string message);
ResponseContainer receiveMessage();
ResponseContainer receiveMessageRSSI();
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 sendBroadcastFixedMessage(byte CHAN, const void *message, const uint8_t size);
ResponseStatus sendBroadcastFixedMessage(byte CHAN, const std::string message);
ResponseContainer receiveInitialMessage(const uint8_t size);
ResponseStatus sendConfigurationMessage( byte ADDH,byte ADDL, byte CHAN, Configuration *configuration, PROGRAM_COMMAND programCommand = WRITE_CFG_PWR_DWN_SAVE);
int available();
private:
HardwareSerial* hs;
#ifdef ACTIVATE_SOFTWARE_SERIAL
SoftwareSerial* ss;
#endif
bool isSoftwareSerial = true;
int8_t txE220pin = -1;
int8_t rxE220pin = -1;
int8_t auxPin = -1;
#ifdef HARDWARE_SERIAL_SELECTABLE_PIN
uint32_t serialConfig = SERIAL_8N1;
#endif
int8_t m0Pin = -1;
int8_t m1Pin = -1;
unsigned long halfKeyloqKey = 0x06660708;
unsigned long encrypt(unsigned long data);
unsigned long decrypt(unsigned long data);
UART_BPS_RATE bpsRate = UART_BPS_RATE_9600;
struct NeedsStream {
template<typename T>
void begin(T &t, uint32_t baud) {
DEBUG_PRINTLN("Begin ");
t.setTimeout(500);
t.begin(baud);
stream = &t;
}
#ifdef HARDWARE_SERIAL_SELECTABLE_PIN
// template< typename T >
// void begin( T &t, uint32_t baud, SerialConfig config ){
// 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.begin(baud, config);
stream = &t;
}
template< typename T >
void begin( T &t, uint32_t baud, uint32_t config, int8_t txE220pin, int8_t rxE220pin ) {
DEBUG_PRINTLN("Begin ");
t.setTimeout(500);
t.begin(baud, config, txE220pin, rxE220pin);
stream = &t;
}
#endif
void listen() {}
Stream *stream;
};
NeedsStream serialDef;
MODE_TYPE mode = MODE_0_NORMAL;
void managedDelay(unsigned long timeout);
Status waitCompleteResponse(unsigned long timeout = 1000, unsigned int waitNoAux = 100);
void flush();
void cleanUARTBuffer();
Status sendStruct(void *structureManaged, uint16_t size_);
Status receiveStruct(void *structureManaged, uint16_t size_);
bool writeProgramCommand(PROGRAM_COMMAND cmd, REGISTER_ADDRESS addr, PACKET_LENGHT pl);
RESPONSE_STATUS checkUARTConfiguration(MODE_TYPE mode);
#ifdef LoRa_E220_DEBUG
void printParameters(struct Configuration *configuration);
#endif
};
#endif

463
esphome/components/ebyte_lora_e220/state_naming.h Normal file
View file

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