Englebert
6 years ago
6 changed files with 1706 additions and 26 deletions
-
681LoRa_E32.cpp
-
298LoRa_E32.h
-
3OpenFlightTX.h
-
296OpenFlightTX.ino
-
2README.md
-
452statesNaming.h
@ -0,0 +1,681 @@ |
|||
#include "LoRa_E32.h"
|
|||
|
|||
LoRa_E32::LoRa_E32(HardwareSerial hs) { |
|||
/**** For RX ****
|
|||
this->auxPin = 4; |
|||
this->m0Pin = 18; |
|||
this->m1Pin = 5; |
|||
*/ |
|||
|
|||
this->auxPin = 4; |
|||
this->m0Pin = 2; |
|||
this->m1Pin = 5; |
|||
|
|||
this->hs = &Serial2; |
|||
this->bpsRate = UART_BPS_RATE_9600; |
|||
// this->bpsRate = UART_BPS_RATE_115200;
|
|||
} |
|||
|
|||
bool LoRa_E32::begin(){ |
|||
pinMode(this->auxPin, INPUT); |
|||
pinMode(this->m0Pin, OUTPUT); |
|||
pinMode(this->m1Pin, OUTPUT); |
|||
digitalWrite(this->m0Pin, HIGH); |
|||
digitalWrite(this->m1Pin, HIGH); |
|||
|
|||
if (this->hs){ |
|||
this->serialDef.begin(*this->hs, this->bpsRate, this->serialConfig); |
|||
while (!this->hs) { |
|||
} |
|||
} |
|||
|
|||
this->serialDef.stream->setTimeout(1000); |
|||
Status status = setMode(MODE_0_NORMAL); |
|||
return status==SUCCESS; |
|||
} |
|||
|
|||
/*
|
|||
* Utility method to wait until module is doen tranmitting |
|||
* a timeout is provided to avoid an infinite loop |
|||
*/ |
|||
Status LoRa_E32::waitCompleteResponse(unsigned long timeout, unsigned int waitNoAux) { |
|||
Status result = SUCCESS; |
|||
|
|||
unsigned long t = millis(); |
|||
|
|||
// make darn sure millis() is not about to reach max data type limit and start over
|
|||
if (((unsigned long) (t + timeout)) == 0){ |
|||
t = 0; |
|||
} |
|||
|
|||
// if AUX pin was supplied and look for HIGH state
|
|||
// note you can omit using AUX if no pins are available, but you will have to use delay() to let module finish
|
|||
if (this->auxPin != -1) { |
|||
while (digitalRead(this->auxPin) == LOW) { |
|||
if ((millis() - t) > timeout){ |
|||
result = ERR_TIMEOUT; |
|||
// DEBUG_PRINTLN(F("LORA: Timeout error!"));
|
|||
return result; |
|||
} |
|||
} |
|||
// DEBUG_PRINTLN("AUX HIGH!");
|
|||
} else { |
|||
// if you can't use aux pin, use 4K7 pullup with Arduino
|
|||
// you may need to adjust this value if transmissions fail
|
|||
this->managedDelay(waitNoAux); |
|||
// DEBUG_PRINTLN(F("Wait no AUX pin!"));
|
|||
} |
|||
|
|||
// per data sheet control after aux goes high is 2ms so delay for at least that long)
|
|||
// this->managedDelay(20);
|
|||
this->managedDelay(3); |
|||
// DEBUG_PRINTLN(F("Complete!"));
|
|||
return result; |
|||
} |
|||
|
|||
/*
|
|||
* delay() in a library is not a good idea as it can stop interrupts |
|||
* just poll internal time until timeout is reached |
|||
*/ |
|||
void LoRa_E32::managedDelay(unsigned long timeout) { |
|||
unsigned long t = millis(); |
|||
// make darn sure millis() is not about to reach max data type limit and start over
|
|||
if(((unsigned long) (t + timeout)) == 0) { |
|||
t = 0; |
|||
} |
|||
|
|||
while((millis() - t) < timeout) { |
|||
} |
|||
} |
|||
|
|||
/*
|
|||
* Method to indicate availability |
|||
*/ |
|||
int LoRa_E32::available(unsigned long timeout) { |
|||
// unsigned long t = millis();
|
|||
//
|
|||
// // make darn sure millis() is not about to reach max data type limit and start over
|
|||
// if (((unsigned long) (t + timeout)) == 0){
|
|||
// t = 0;
|
|||
// }
|
|||
//
|
|||
// if (this->auxPin != 0) {
|
|||
// if (digitalRead(this->auxPin) == HIGH){
|
|||
// return 0;
|
|||
// }else{
|
|||
// while (digitalRead(this->auxPin) == LOW) {
|
|||
// if ((millis() - t) > timeout){
|
|||
// DEBUG_PRINTLN("Timeout error!");
|
|||
// return 0;
|
|||
// }
|
|||
// }
|
|||
// DEBUG_PRINTLN("AUX HIGH!");
|
|||
// return 2;
|
|||
// }
|
|||
// }else{
|
|||
return this->serialDef.stream->available(); |
|||
// }
|
|||
} |
|||
|
|||
/*
|
|||
* Method to indicate availability |
|||
*/ |
|||
void LoRa_E32::flush() { |
|||
this->serialDef.stream->flush(); |
|||
} |
|||
|
|||
|
|||
void LoRa_E32::cleanUARTBuffer() { |
|||
// bool IsNull = true;
|
|||
while (this->available()) { |
|||
// IsNull = false;
|
|||
this->serialDef.stream->read(); |
|||
} |
|||
} |
|||
|
|||
|
|||
/*
|
|||
* Method to send a chunk of data provided data is in a struct--my personal favorite as you |
|||
* need not parse or worry about sprintf() inability to handle floats |
|||
* |
|||
* TTP: put your structure definition into a .h file and include in both the sender and reciever |
|||
* sketches |
|||
* |
|||
* NOTE: of your sender and receiver MCU's are different (Teensy and Arduino) caution on the data |
|||
* types each handle ints floats differently |
|||
* |
|||
*/ |
|||
Status LoRa_E32::sendStruct(void *structureManaged, uint16_t size_) { |
|||
if(size_ > MAX_SIZE_TX_PACKET){ |
|||
return ERR_PACKET_TOO_BIG; |
|||
} |
|||
|
|||
Status result = SUCCESS; |
|||
|
|||
uint8_t len = this->serialDef.stream->write((uint8_t *) structureManaged, size_); |
|||
if(len!=size_){ |
|||
/*
|
|||
DEBUG_PRINT(F("Send... len:")) |
|||
DEBUG_PRINT(len); |
|||
DEBUG_PRINT(F(" size:")) |
|||
DEBUG_PRINT(size_); |
|||
*/ |
|||
if(len==0){ |
|||
result = ERR_NO_RESPONSE_FROM_DEVICE; |
|||
} else { |
|||
result = ERR_DATA_SIZE_NOT_MATCH; |
|||
} |
|||
} |
|||
if(result != SUCCESS) return result; |
|||
|
|||
result = this->waitCompleteResponse(1000); |
|||
if(result != SUCCESS) return result; |
|||
// DEBUG_PRINT(F("Clear buffer..."))
|
|||
this->cleanUARTBuffer(); |
|||
|
|||
// DEBUG_PRINTLN(F("ok!"))
|
|||
|
|||
return result; |
|||
} |
|||
|
|||
|
|||
/*
|
|||
* |
|||
* Method to get a chunk of data provided data is in a struct--my personal favorite as you |
|||
* need not parse or worry about sprintf() inability to handle floats |
|||
* |
|||
* TTP: put your structure definition into a .h file and include in both the sender and reciever |
|||
* sketches |
|||
* |
|||
* NOTE: of your sender and receiver MCU's are different (Teensy and Arduino) caution on the data |
|||
* types each handle ints floats differently |
|||
* |
|||
*/ |
|||
Status LoRa_E32::receiveStruct(void *structureManaged, uint16_t size_) { |
|||
Status result = SUCCESS; |
|||
|
|||
uint8_t len = this->serialDef.stream->readBytes((uint8_t *) structureManaged, size_); |
|||
|
|||
DEBUG_PRINT("Available buffer: "); |
|||
DEBUG_PRINT(len); |
|||
DEBUG_PRINT(" structure size: "); |
|||
DEBUG_PRINTLN(size_); |
|||
|
|||
if(len!=size_){ |
|||
if(len==0){ |
|||
result = ERR_NO_RESPONSE_FROM_DEVICE; |
|||
} else { |
|||
result = ERR_DATA_SIZE_NOT_MATCH; |
|||
} |
|||
} |
|||
if(result != SUCCESS) |
|||
return result; |
|||
|
|||
result = this->waitCompleteResponse(1000); |
|||
|
|||
if(result != SUCCESS) |
|||
return result; |
|||
|
|||
return result; |
|||
} |
|||
|
|||
/*
|
|||
* method to set the mode (program, normal, etc.) |
|||
*/ |
|||
Status LoRa_E32::setMode(MODE_TYPE mode) { |
|||
// data sheet claims module needs some extra time after mode setting (2ms)
|
|||
// most of my projects uses 10 ms, but 40ms is safer
|
|||
this->managedDelay(40); |
|||
|
|||
if (this->m0Pin == -1 && this->m1Pin == -1) { |
|||
DEBUG_PRINTLN(F("The M0 and M1 pins is not set, this mean that you are connect directly the pins as you need!")) |
|||
}else{ |
|||
switch (mode) |
|||
{ |
|||
case MODE_0_NORMAL: |
|||
// Mode 0 | normal operation
|
|||
digitalWrite(this->m0Pin, LOW); |
|||
digitalWrite(this->m1Pin, LOW); |
|||
DEBUG_PRINTLN(F("MODE NORMAL!")); |
|||
break; |
|||
case MODE_1_WAKE_UP: |
|||
digitalWrite(this->m0Pin, HIGH); |
|||
digitalWrite(this->m1Pin, LOW); |
|||
DEBUG_PRINTLN(F("MODE WAKE UP!")); |
|||
break; |
|||
case MODE_2_POWER_SAVING: |
|||
digitalWrite(this->m0Pin, LOW); |
|||
digitalWrite(this->m1Pin, HIGH); |
|||
DEBUG_PRINTLN(F("MODE POWER SAVING!")); |
|||
break; |
|||
case MODE_3_SLEEP: |
|||
// Mode 3 | Setting operation
|
|||
digitalWrite(this->m0Pin, HIGH); |
|||
digitalWrite(this->m1Pin, HIGH); |
|||
DEBUG_PRINTLN(F("MODE PROGRAM/SLEEP!")); |
|||
break; |
|||
default: |
|||
return ERR_INVALID_PARAM; |
|||
} |
|||
} |
|||
// data sheet says 2ms later control is returned, let's give just a bit more time
|
|||
// these modules can take time to activate pins
|
|||
this->managedDelay(40); |
|||
|
|||
// wait until aux pin goes back low
|
|||
Status res = this->waitCompleteResponse(1000); |
|||
|
|||
if(res == SUCCESS){ |
|||
this->mode = mode; |
|||
} |
|||
|
|||
return res; |
|||
} |
|||
|
|||
MODE_TYPE LoRa_E32::getMode(){ |
|||
return this->mode; |
|||
} |
|||
|
|||
void LoRa_E32::writeProgramCommand(PROGRAM_COMMAND cmd){ |
|||
uint8_t CMD[3] = {cmd, cmd, cmd}; |
|||
uint8_t size = this->serialDef.stream->write(CMD, 3); |
|||
DEBUG_PRINTLN(size); |
|||
this->managedDelay(50); //need ti check
|
|||
} |
|||
|
|||
ResponseStructContainer LoRa_E32::getConfiguration(){ |
|||
ResponseStructContainer rc; |
|||
|
|||
rc.status.code = checkUARTConfiguration(MODE_3_PROGRAM); |
|||
if (rc.status.code!=SUCCESS) return rc; |
|||
|
|||
MODE_TYPE prevMode = this->mode; |
|||
|
|||
rc.status.code = this->setMode(MODE_3_PROGRAM); |
|||
if (rc.status.code!=SUCCESS) return rc; |
|||
|
|||
this->writeProgramCommand(READ_CONFIGURATION); |
|||
|
|||
rc.data = malloc(sizeof(Configuration)); |
|||
rc.status.code = this->receiveStruct((uint8_t *)rc.data, sizeof(Configuration)); |
|||
|
|||
#ifdef LoRa_E32_DEBUG
|
|||
this->printParameters((Configuration *)rc.data); |
|||
#endif
|
|||
|
|||
if (rc.status.code!=SUCCESS) { |
|||
this->setMode(prevMode); |
|||
return rc; |
|||
} |
|||
|
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
DEBUG_PRINT(F("HEAD BIN INSIDE: ")); DEBUG_PRINT(((Configuration *)rc.data)->HEAD, BIN);DEBUG_PRINT(" ");DEBUG_PRINT(((Configuration *)rc.data)->HEAD, DEC);DEBUG_PRINT(" ");DEBUG_PRINTLN(((Configuration *)rc.data)->HEAD, HEX); |
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
|
|||
rc.status.code = this->setMode(prevMode); |
|||
if (rc.status.code!=SUCCESS) return rc; |
|||
|
|||
// this->printParameters(*configuration);
|
|||
|
|||
if (0xC0 != ((Configuration *)rc.data)->HEAD && 0xC2 != ((Configuration *)rc.data)->HEAD){ |
|||
rc.status.code = ERR_HEAD_NOT_RECOGNIZED; |
|||
} |
|||
|
|||
// rc.data = configuration;
|
|||
return rc; |
|||
} |
|||
|
|||
RESPONSE_STATUS LoRa_E32::checkUARTConfiguration(MODE_TYPE mode){ |
|||
if (mode==MODE_3_PROGRAM && this->bpsRate!=UART_BPS_RATE_9600){ |
|||
return ERR_WRONG_UART_CONFIG; |
|||
} |
|||
return SUCCESS; |
|||
} |
|||
|
|||
ResponseStatus LoRa_E32::setConfiguration(Configuration configuration, PROGRAM_COMMAND saveType){ |
|||
ResponseStatus rc; |
|||
|
|||
rc.code = checkUARTConfiguration(MODE_3_PROGRAM); |
|||
if (rc.code!=SUCCESS) return rc; |
|||
|
|||
MODE_TYPE prevMode = this->mode; |
|||
|
|||
rc.code = this->setMode(MODE_3_PROGRAM); |
|||
if (rc.code!=SUCCESS) return rc; |
|||
|
|||
this->writeProgramCommand(READ_CONFIGURATION); |
|||
|
|||
configuration.HEAD = saveType; |
|||
|
|||
rc.code = this->sendStruct((uint8_t *)&configuration, sizeof(Configuration)); |
|||
if (rc.code!=SUCCESS) { |
|||
this->setMode(prevMode); |
|||
return rc; |
|||
} |
|||
|
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
DEBUG_PRINT(F("HEAD BIN INSIDE: ")); DEBUG_PRINT(configuration.HEAD, BIN);DEBUG_PRINT(" ");DEBUG_PRINT(configuration.HEAD, DEC);DEBUG_PRINT(" ");DEBUG_PRINTLN(configuration.HEAD, HEX); |
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
|
|||
rc.code = this->setMode(prevMode); |
|||
if (rc.code!=SUCCESS) return rc; |
|||
|
|||
// this->printParameters(*configuration);
|
|||
|
|||
if (0xC0 != configuration.HEAD && 0xC2 != configuration.HEAD){ |
|||
rc.code = ERR_HEAD_NOT_RECOGNIZED; |
|||
} |
|||
|
|||
return rc; |
|||
} |
|||
|
|||
ResponseStructContainer LoRa_E32::getModuleInformation(){ |
|||
ResponseStructContainer rc; |
|||
|
|||
rc.status.code = checkUARTConfiguration(MODE_3_PROGRAM); |
|||
if (rc.status.code!=SUCCESS) return rc; |
|||
|
|||
MODE_TYPE prevMode = this->mode; |
|||
|
|||
rc.status.code = this->setMode(MODE_3_PROGRAM); |
|||
if (rc.status.code!=SUCCESS) return rc; |
|||
|
|||
this->writeProgramCommand(READ_MODULE_VERSION); |
|||
|
|||
struct ModuleInformation *moduleInformation = (ModuleInformation *)malloc(sizeof(ModuleInformation)); |
|||
rc.status.code = this->receiveStruct((uint8_t *)moduleInformation, sizeof(ModuleInformation)); |
|||
if (rc.status.code!=SUCCESS) { |
|||
this->setMode(prevMode); |
|||
return rc; |
|||
} |
|||
|
|||
rc.status.code = this->setMode(prevMode); |
|||
if (rc.status.code!=SUCCESS) return rc; |
|||
|
|||
// this->printParameters(*configuration);
|
|||
|
|||
if (0xC3 != moduleInformation->HEAD){ |
|||
rc.status.code = ERR_HEAD_NOT_RECOGNIZED; |
|||
} |
|||
|
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
DEBUG_PRINT(F("HEAD BIN INSIDE: ")); DEBUG_PRINT(moduleInformation->HEAD, BIN);DEBUG_PRINT(" ");DEBUG_PRINT(moduleInformation->HEAD, DEC);DEBUG_PRINT(" ");DEBUG_PRINTLN(moduleInformation->HEAD, HEX); |
|||
|
|||
DEBUG_PRINT(F("Freq.: ")); DEBUG_PRINTLN(moduleInformation->frequency, HEX); |
|||
DEBUG_PRINT(F("Version : ")); DEBUG_PRINTLN(moduleInformation->version, HEX); |
|||
DEBUG_PRINT(F("Features : ")); DEBUG_PRINTLN(moduleInformation->features, HEX); |
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
|
|||
rc.data = moduleInformation; // malloc(sizeof (moduleInformation));
|
|||
|
|||
return rc; |
|||
} |
|||
|
|||
|
|||
ResponseStatus LoRa_E32::resetModule(){ |
|||
ResponseStatus status; |
|||
|
|||
status.code = checkUARTConfiguration(MODE_3_PROGRAM); |
|||
if (status.code!=SUCCESS) return status; |
|||
|
|||
MODE_TYPE prevMode = this->mode; |
|||
|
|||
status.code = this->setMode(MODE_3_PROGRAM); |
|||
if (status.code!=SUCCESS) return status; |
|||
|
|||
this->writeProgramCommand(WRITE_RESET_MODULE); |
|||
|
|||
status.code = this->waitCompleteResponse(1000); |
|||
if (status.code!=SUCCESS) { |
|||
this->setMode(prevMode); |
|||
return status; |
|||
} |
|||
|
|||
|
|||
status.code = this->setMode(prevMode); |
|||
if (status.code!=SUCCESS) return status; |
|||
|
|||
return status; |
|||
} |
|||
|
|||
ResponseContainer LoRa_E32::receiveMessage(){ |
|||
ResponseContainer rc; |
|||
rc.status.code = SUCCESS; |
|||
rc.data = this->serialDef.stream->readString(); |
|||
this->cleanUARTBuffer(); |
|||
if (rc.status.code!=SUCCESS) { |
|||
return rc; |
|||
} |
|||
|
|||
// rc.data = message; // malloc(sizeof (moduleInformation));
|
|||
|
|||
return rc; |
|||
} |
|||
ResponseContainer LoRa_E32::receiveMessageUntil(char delimiter){ |
|||
ResponseContainer rc; |
|||
rc.status.code = SUCCESS; |
|||
rc.data = this->serialDef.stream->readStringUntil(delimiter); |
|||
// this->cleanUARTBuffer();
|
|||
if (rc.status.code!=SUCCESS) { |
|||
return rc; |
|||
} |
|||
|
|||
// rc.data = message; // malloc(sizeof (moduleInformation));
|
|||
|
|||
return rc; |
|||
} |
|||
ResponseStructContainer LoRa_E32::receiveMessage(const uint8_t size){ |
|||
ResponseStructContainer rc; |
|||
|
|||
rc.data = malloc(size); |
|||
rc.status.code = this->receiveStruct((uint8_t *)rc.data, size); |
|||
this->cleanUARTBuffer(); |
|||
if (rc.status.code!=SUCCESS) { |
|||
return rc; |
|||
} |
|||
|
|||
return rc; |
|||
} |
|||
|
|||
ResponseStatus LoRa_E32::sendMessage(const void *message, const uint8_t size){ |
|||
ResponseStatus status; |
|||
status.code = this->sendStruct((uint8_t *)message, size); |
|||
if (status.code!=SUCCESS) return status; |
|||
|
|||
return status; |
|||
} |
|||
ResponseStatus LoRa_E32::sendMessage(const String message){ |
|||
DEBUG_PRINT(F("Send message: ")); |
|||
DEBUG_PRINT(message); |
|||
byte size = message.length(); // sizeof(message.c_str())+1;
|
|||
DEBUG_PRINT(F(" size: ")); |
|||
DEBUG_PRINTLN(size); |
|||
char messageFixed[size]; |
|||
memcpy(messageFixed,message.c_str(),size); |
|||
|
|||
ResponseStatus status; |
|||
status.code = this->sendStruct((uint8_t *)&messageFixed, size); |
|||
if (status.code!=SUCCESS) return status; |
|||
|
|||
return status; |
|||
} |
|||
|
|||
ResponseStatus LoRa_E32::sendFixedMessage(byte ADDH, byte ADDL, byte CHAN, const String message){ |
|||
// DEBUG_PRINT("String/size: ");
|
|||
// DEBUG_PRINT(message);
|
|||
// DEBUG_PRINT("/");
|
|||
byte size = message.length(); // sizeof(message.c_str())+1;
|
|||
// DEBUG_PRINTLN(size);
|
|||
//
|
|||
// #pragma pack(push, 1)
|
|||
// struct FixedStransmissionString {
|
|||
// byte ADDH = 0;
|
|||
// byte ADDL = 0;
|
|||
// byte CHAN = 0;
|
|||
// char message[];
|
|||
// } fixedStransmission;
|
|||
// #pragma pack(pop)
|
|||
//
|
|||
// fixedStransmission.ADDH = ADDH;
|
|||
// fixedStransmission.ADDL = ADDL;
|
|||
// fixedStransmission.CHAN = CHAN;
|
|||
// char* msg = (char*)message.c_str();
|
|||
// memcpy(fixedStransmission.message, (char*)msg, size);
|
|||
//// fixedStransmission.message = message;
|
|||
//
|
|||
// DEBUG_PRINT("Message: ");
|
|||
// DEBUG_PRINTLN(fixedStransmission.message);
|
|||
//
|
|||
// ResponseStatus status;
|
|||
// status.code = this->sendStruct((uint8_t *)&fixedStransmission, sizeof(fixedStransmission));
|
|||
// if (status.code!=SUCCESS) return status;
|
|||
//
|
|||
// return status;
|
|||
char messageFixed[size]; |
|||
memcpy(messageFixed,message.c_str(),size); |
|||
return this->sendFixedMessage(ADDH, ADDL, CHAN, (uint8_t *)messageFixed, size); |
|||
} |
|||
ResponseStatus LoRa_E32::sendBroadcastFixedMessage(byte CHAN, const String message){ |
|||
return this->sendFixedMessage(0xFF, 0xFF, CHAN, message); |
|||
} |
|||
|
|||
typedef struct fixedStransmission |
|||
{ |
|||
byte ADDH = 0; |
|||
byte ADDL = 0; |
|||
byte CHAN = 0; |
|||
unsigned char message[]; |
|||
}FixedStransmission; |
|||
|
|||
FixedStransmission *init_stack(int m){ |
|||
FixedStransmission *st = (FixedStransmission *)malloc(sizeof(FixedStransmission)+m*sizeof(int)); |
|||
return st; |
|||
} |
|||
|
|||
ResponseStatus LoRa_E32::sendFixedMessage( byte ADDH,byte ADDL, byte CHAN, const void *message, const uint8_t size){ |
|||
// #pragma pack(push, 1)
|
|||
// struct FixedStransmission {
|
|||
// byte ADDH = 0;
|
|||
// byte ADDL = 0;
|
|||
// byte CHAN = 0;
|
|||
// unsigned char message[];
|
|||
// } fixedStransmission;
|
|||
// #pragma pack(pop)
|
|||
|
|||
|
|||
FixedStransmission *fixedStransmission = init_stack(size); |
|||
|
|||
// STACK *resize_stack(STACK *st, int m){
|
|||
// if (m<=st->max){
|
|||
// return st; /* Take sure do not kill old values */
|
|||
// }
|
|||
// STACK *st = (STACK *)realloc(sizeof(STACK)+m*sizeof(int));
|
|||
// st->max = m;
|
|||
// return st;
|
|||
// }
|
|||
|
|||
fixedStransmission->ADDH = ADDH; |
|||
fixedStransmission->ADDL = ADDL; |
|||
fixedStransmission->CHAN = CHAN; |
|||
// fixedStransmission.message = &message;
|
|||
|
|||
memcpy(fixedStransmission->message,(unsigned char*)message,size); |
|||
|
|||
ResponseStatus status; |
|||
status.code = this->sendStruct((uint8_t *)fixedStransmission, size+3); |
|||
|
|||
free(fixedStransmission); |
|||
|
|||
// if (status.code!=SUCCESS) return status;
|
|||
|
|||
return status; |
|||
} |
|||
ResponseStatus LoRa_E32::sendBroadcastFixedMessage(byte CHAN, const void *message, const uint8_t size){ |
|||
return this->sendFixedMessage(0xFF, 0xFF, CHAN, message, size); |
|||
} |
|||
|
|||
ResponseContainer LoRa_E32::receiveInitialMessage(uint8_t size){ |
|||
ResponseContainer rc; |
|||
rc.status.code = SUCCESS; |
|||
char buff[size]; |
|||
uint8_t len = this->serialDef.stream->readBytes(buff, size); |
|||
if (len!=size) { |
|||
if (len==0){ |
|||
rc.status.code = ERR_NO_RESPONSE_FROM_DEVICE; |
|||
}else{ |
|||
rc.status.code = ERR_DATA_SIZE_NOT_MATCH; |
|||
} |
|||
return rc; |
|||
} |
|||
|
|||
rc.data = buff; |
|||
|
|||
return rc; |
|||
} |
|||
|
|||
#define KeeLoq_NLF 0x3A5C742E
|
|||
|
|||
unsigned long LoRa_E32::encrypt(unsigned long data) |
|||
{ |
|||
unsigned long x = data; |
|||
unsigned long r; |
|||
int keyBitNo, index; |
|||
unsigned long keyBitVal,bitVal; |
|||
|
|||
for (r = 0; r < 528; r++) |
|||
{ |
|||
keyBitNo = r & 63; |
|||
if(keyBitNo < 32) |
|||
keyBitVal = bitRead(this->halfKeyloqKey,keyBitNo); // key low
|
|||
else |
|||
keyBitVal = bitRead(this->halfKeyloqKey, keyBitNo - 32);// key hight
|
|||
index = 1 * bitRead(x,1) + 2 * bitRead(x,9) + 4 * bitRead(x,20) + 8 * bitRead(x,26) + 16 * bitRead(x,31); |
|||
bitVal = bitRead(x,0) ^ bitRead(x, 16) ^ bitRead(KeeLoq_NLF,index) ^ keyBitVal; |
|||
x = (x>>1) ^ bitVal<<31; |
|||
} |
|||
return x; |
|||
} |
|||
|
|||
unsigned long LoRa_E32::decrypt(unsigned long data) |
|||
{ |
|||
unsigned long x = data; |
|||
unsigned long r; |
|||
int keyBitNo, index; |
|||
unsigned long keyBitVal,bitVal; |
|||
|
|||
for (r = 0; r < 528; r++) |
|||
{ |
|||
keyBitNo = (15-r) & 63; |
|||
if(keyBitNo < 32) |
|||
keyBitVal = bitRead(this->halfKeyloqKey,keyBitNo); // key low
|
|||
else |
|||
keyBitVal = bitRead(this->halfKeyloqKey, keyBitNo - 32); // key hight
|
|||
index = 1 * bitRead(x,0) + 2 * bitRead(x,8) + 4 * bitRead(x,19) + 8 * bitRead(x,25) + 16 * bitRead(x,30); |
|||
bitVal = bitRead(x,31) ^ bitRead(x, 15) ^ bitRead(KeeLoq_NLF,index) ^ keyBitVal; |
|||
x = (x<<1) ^ bitVal; |
|||
} |
|||
return x; |
|||
} |
|||
#ifdef LoRa_E32_DEBUG
|
|||
void LoRa_E32::printParameters(struct Configuration *configuration) { |
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
|
|||
DEBUG_PRINT(F("HEAD : ")); DEBUG_PRINT(configuration->HEAD, BIN);DEBUG_PRINT(" ");DEBUG_PRINT(configuration->HEAD, DEC);DEBUG_PRINT(" ");DEBUG_PRINTLN(configuration->HEAD, HEX); |
|||
DEBUG_PRINTLN(F(" ")); |
|||
DEBUG_PRINT(F("AddH : ")); DEBUG_PRINTLN(configuration->ADDH, DEC); |
|||
DEBUG_PRINT(F("AddL : ")); DEBUG_PRINTLN(configuration->ADDL, DEC); |
|||
DEBUG_PRINT(F("Chan : ")); DEBUG_PRINT(configuration->CHAN, DEC); DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->getChannelDescription()); |
|||
DEBUG_PRINTLN(F(" ")); |
|||
DEBUG_PRINT(F("SpeedParityBit : ")); DEBUG_PRINT(configuration->SPED.uartParity, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->SPED.getUARTParityDescription()); |
|||
DEBUG_PRINT(F("SpeedUARTDatte : ")); DEBUG_PRINT(configuration->SPED.uartBaudRate, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->SPED.getUARTBaudRate()); |
|||
DEBUG_PRINT(F("SpeedAirDataRate : ")); DEBUG_PRINT(configuration->SPED.airDataRate, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->SPED.getAirDataRate()); |
|||
|
|||
DEBUG_PRINT(F("OptionTrans : ")); DEBUG_PRINT(configuration->OPTION.fixedTransmission, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->OPTION.getFixedTransmissionDescription()); |
|||
DEBUG_PRINT(F("OptionPullup : ")); DEBUG_PRINT(configuration->OPTION.ioDriveMode, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->OPTION.getIODroveModeDescription()); |
|||
DEBUG_PRINT(F("OptionWakeup : ")); DEBUG_PRINT(configuration->OPTION.wirelessWakeupTime, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->OPTION.getWirelessWakeUPTimeDescription()); |
|||
DEBUG_PRINT(F("OptionFEC : ")); DEBUG_PRINT(configuration->OPTION.fec, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->OPTION.getFECDescription()); |
|||
DEBUG_PRINT(F("OptionPower : ")); DEBUG_PRINT(configuration->OPTION.transmissionPower, BIN);DEBUG_PRINT(" -> "); DEBUG_PRINTLN(configuration->OPTION.getTransmissionPowerDescription()); |
|||
|
|||
DEBUG_PRINTLN("----------------------------------------"); |
|||
} |
|||
#endif
|
|||
@ -0,0 +1,298 @@ |
|||
/* |
|||
* EBYTE LoRa E32 Series |
|||
*/ |
|||
#ifndef LoRa_E32_h |
|||
#define LoRa_E32_h |
|||
|
|||
#ifdef ESP32 |
|||
#define HARDWARE_SERIAL_SELECTABLE_PIN |
|||
#endif |
|||
|
|||
#ifdef ACTIVATE_SOFTWARE_SERIAL |
|||
#include <SoftwareSerial.h> |
|||
#endif |
|||
|
|||
#include "statesNaming.h" |
|||
|
|||
#if ARDUINO >= 100 |
|||
#include "Arduino.h" |
|||
#else |
|||
#include "WProgram.h" |
|||
#endif |
|||
|
|||
#define MAX_SIZE_TX_PACKET 58 |
|||
|
|||
// Uncomment to enable printing out nice debug messages. |
|||
// #define LoRa_E32_DEBUG |
|||
|
|||
// Operating Freq |
|||
#define FREQUENCY_915 |
|||
|
|||
// Define where debug output will be printed. |
|||
#define DEBUG_PRINTER Serial |
|||
|
|||
// Setup debug printing macros. |
|||
#ifdef LoRa_E32_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_1_WAKE_UP = 1, |
|||
MODE_2_POWER_SAVING = 2, |
|||
MODE_3_SLEEP = 3, |
|||
MODE_3_PROGRAM =3, |
|||
MODE_INIT = 0xFF |
|||
}; |
|||
|
|||
enum PROGRAM_COMMAND |
|||
{ |
|||
WRITE_CFG_PWR_DWN_SAVE = 0xC0, |
|||
READ_CONFIGURATION = 0xC1, |
|||
WRITE_CFG_PWR_DWN_LOSE = 0xC2, |
|||
READ_MODULE_VERSION = 0xC3, |
|||
WRITE_RESET_MODULE = 0xC4 |
|||
}; |
|||
|
|||
#pragma pack(push, 1) |
|||
struct Speed { |
|||
uint8_t airDataRate : 3; //bit 0-2 |
|||
String getAirDataRate() { |
|||
return getAirDataRateDescriptionByParams(this->airDataRate); |
|||
} |
|||
|
|||
uint8_t uartBaudRate: 3; //bit 3-5 |
|||
String getUARTBaudRate() { |
|||
return getUARTBaudRateDescriptionByParams(this->uartBaudRate); |
|||
} |
|||
|
|||
uint8_t uartParity: 2; //bit 6-7 |
|||
String getUARTParityDescription() { |
|||
return getUARTParityDescriptionByParams(this->uartParity); |
|||
} |
|||
}; |
|||
|
|||
struct Option { |
|||
byte transmissionPower : 2; //bit 0-1 |
|||
String getTransmissionPowerDescription() { |
|||
return getTransmissionPowerDescriptionByParams(this->transmissionPower); |
|||
} |
|||
|
|||
byte fec : 1; //bit 2 |
|||
String getFECDescription() { |
|||
return getFECDescriptionByParams(this->fec); |
|||
} |
|||
|
|||
byte wirelessWakeupTime : 3; //bit 3-5 |
|||
String getWirelessWakeUPTimeDescription() { |
|||
return getWirelessWakeUPTimeDescriptionByParams(this->wirelessWakeupTime); |
|||
} |
|||
|
|||
byte ioDriveMode : 1; //bit 6 |
|||
String getIODroveModeDescription() { |
|||
return getIODriveModeDescriptionDescriptionByParams(this->ioDriveMode); |
|||
} |
|||
|
|||
byte fixedTransmission : 1; //bit 7 |
|||
String getFixedTransmissionDescription() { |
|||
return getFixedTransmissionDescriptionByParams(this->fixedTransmission); |
|||
} |
|||
|
|||
}; |
|||
|
|||
struct Configuration { |
|||
byte HEAD = 0; |
|||
byte ADDH = 0; |
|||
byte ADDL = 0; |
|||
struct Speed SPED; |
|||
byte CHAN = 0; |
|||
String getChannelDescription() { |
|||
return String(this->CHAN + OPERATING_FREQUENCY) + F("MHz") ; |
|||
} |
|||
struct Option OPTION; |
|||
}; |
|||
|
|||
struct ModuleInformation { |
|||
byte HEAD = 0; |
|||
byte frequency = 0; |
|||
byte version = 0; |
|||
byte features = 0; |
|||
}; |
|||
|
|||
struct ResponseStatus { |
|||
Status code; |
|||
String getResponseDescription() { |
|||
return getResponseDescriptionByParams(this->code); |
|||
} |
|||
}; |
|||
|
|||
struct ResponseStructContainer { |
|||
void *data; |
|||
ResponseStatus status; |
|||
void close() { |
|||
free(this->data); |
|||
} |
|||
}; |
|||
struct ResponseContainer { |
|||
String data; |
|||
ResponseStatus status; |
|||
}; |
|||
//struct FixedStransmission { |
|||
// byte ADDL = 0; |
|||
// byte ADDH = 0; |
|||
// byte CHAN = 0; |
|||
// void *message; |
|||
//}; |
|||
#pragma pack(pop) |
|||
|
|||
class LoRa_E32 { |
|||
public: |
|||
LoRa_E32(HardwareSerial hs); |
|||
|
|||
/* |
|||
#ifdef ACTIVATE_SOFTWARE_SERIAL |
|||
LoRa_E32(byte txE32pin, byte rxE32pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
LoRa_E32(byte txE32pin, byte rxE32pin, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
LoRa_E32(byte txE32pin, byte rxE32pin, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
#endif |
|||
|
|||
LoRa_E32(HardwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
LoRa_E32(HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
LoRa_E32(HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
|
|||
#ifdef HARDWARE_SERIAL_SELECTABLE_PIN |
|||
LoRa_E32(byte txE32pin, byte rxE32pin, HardwareSerial* serial, UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1); |
|||
LoRa_E32(byte txE32pin, byte rxE32pin, HardwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1); |
|||
LoRa_E32(byte txE32pin, byte rxE32pin, HardwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate, uint32_t serialConfig = SERIAL_8N1); |
|||
#endif |
|||
|
|||
#ifdef ACTIVATE_SOFTWARE_SERIAL |
|||
LoRa_E32(SoftwareSerial* serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
LoRa_E32(SoftwareSerial* serial, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
LoRa_E32(SoftwareSerial* serial, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); |
|||
#endif |
|||
|
|||
// LoRa_E32(byte txE32pin, byte rxE32pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, MODE_TYPE mode = MODE_0_NORMAL); |
|||
// LoRa_E32(HardwareSerial* serial = &Serial, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600, MODE_TYPE mode = MODE_0_NORMAL); |
|||
// LoRa_E32(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); |
|||
ResponseStructContainer receiveMessage(const uint8_t size); |
|||
|
|||
ResponseStatus sendMessage(const String message); |
|||
ResponseContainer receiveMessage(); |
|||
|
|||
ResponseStatus sendFixedMessage(byte ADDH,byte ADDL, byte CHAN, const String message); |
|||
ResponseStatus sendBroadcastFixedMessage(byte CHAN, const 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 ); |
|||
|
|||
ResponseContainer receiveInitialMessage(const uint8_t size); |
|||
ResponseContainer receiveMessageUntil(char delimiter = '\0'); |
|||
|
|||
int available(unsigned long timeout = 1000); |
|||
private: |
|||
HardwareSerial* hs; |
|||
|
|||
#ifdef ACTIVATE_SOFTWARE_SERIAL |
|||
SoftwareSerial* ss; |
|||
#endif |
|||
|
|||
bool isSoftwareSerial = true; |
|||
|
|||
int8_t txE32pin = -1; |
|||
int8_t rxE32pin = -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, int baud){ |
|||
DEBUG_PRINTLN("Begin "); |
|||
t.setTimeout(500); |
|||
t.begin(baud); |
|||
stream = &t; |
|||
} |
|||
|
|||
#ifdef HARDWARE_SERIAL_SELECTABLE_PIN |
|||
// template< typename T > |
|||
// void begin( T &t, int baud, SerialConfig config ){ |
|||
// DEBUG_PRINTLN("Begin "); |
|||
// t.setTimeout(500); |
|||
// t.begin(baud, config); |
|||
// stream = &t; |
|||
// } |
|||
// |
|||
template< typename T > |
|||
void begin( T &t, int baud, uint32_t config ){ |
|||
DEBUG_PRINTLN("Begin "); |
|||
t.setTimeout(500); |
|||
t.begin(baud, config); |
|||
stream = &t; |
|||
} |
|||
|
|||
template< typename T > |
|||
void begin( T &t, int baud, uint32_t config, int8_t txE32pin, int8_t rxE32pin ){ |
|||
DEBUG_PRINTLN("Begin "); |
|||
t.setTimeout(500); |
|||
t.begin(baud, config, txE32pin, rxE32pin); |
|||
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_); |
|||
void writeProgramCommand(PROGRAM_COMMAND cmd); |
|||
|
|||
RESPONSE_STATUS checkUARTConfiguration(MODE_TYPE mode); |
|||
|
|||
#ifdef LoRa_E32_DEBUG |
|||
void printParameters(struct Configuration *configuration); |
|||
#endif |
|||
}; |
|||
|
|||
#endif |
|||
@ -0,0 +1,452 @@ |
|||
#include "Arduino.h" |
|||
|
|||
#define FREQUENCY_915 |
|||
|
|||
#ifdef FREQUENCY_433 |
|||
#define OPERATING_FREQUENCY 410 |
|||
#elif defined(FREQUENCY_170) |
|||
#define OPERATING_FREQUENCY 130 |
|||
#elif defined(FREQUENCY_470) |
|||
#define OPERATING_FREQUENCY 370 |
|||
#elif defined(FREQUENCY_868) |
|||
#define OPERATING_FREQUENCY 862 |
|||
#elif defined(FREQUENCY_915) |
|||
#define OPERATING_FREQUENCY 900 |
|||
#else |
|||
#define OPERATING_FREQUENCY 410 |
|||
#endif |
|||
|
|||
#define BROADCAST_ADDRESS 0xFF |
|||
|
|||
typedef enum RESPONSE_STATUS { |
|||
SUCCESS = 1, |
|||
ERR_UNKNOWN, /* something shouldn't happened */ |
|||
ERR_NOT_SUPPORT, |
|||
ERR_NOT_IMPLEMENT, |
|||
ERR_NOT_INITIAL, |
|||
ERR_INVALID_PARAM, |
|||
ERR_DATA_SIZE_NOT_MATCH, |
|||
ERR_BUF_TOO_SMALL, |
|||
ERR_TIMEOUT, |
|||
ERR_HARDWARE, |
|||
ERR_HEAD_NOT_RECOGNIZED, |
|||
ERR_NO_RESPONSE_FROM_DEVICE, |
|||
ERR_WRONG_UART_CONFIG, |
|||
ERR_PACKET_TOO_BIG |
|||
} Status; |
|||
|
|||
static String getResponseDescriptionByParams(byte status){ |
|||
switch (status) |
|||
{ |
|||
case SUCCESS: |
|||
return F("Success"); |
|||
break; |
|||
case ERR_UNKNOWN: |
|||
return F("Unknown"); |
|||
break; |
|||
case ERR_NOT_SUPPORT: |
|||
return F("Not support!"); |
|||
break; |
|||
case ERR_NOT_IMPLEMENT: |
|||
return F("Not implement"); |
|||
break; |
|||
case ERR_NOT_INITIAL: |
|||
return F("Not initial!"); |
|||
break; |
|||
case ERR_INVALID_PARAM: |
|||
return F("Invalid param!"); |
|||
break; |
|||
case ERR_DATA_SIZE_NOT_MATCH: |
|||
return F("Data size not match!"); |
|||
break; |
|||
case ERR_BUF_TOO_SMALL: |
|||
return F("Buff too small!"); |
|||
break; |
|||
case ERR_TIMEOUT: |
|||
return F("Timeout!!"); |
|||
break; |
|||
case ERR_HARDWARE: |
|||
return F("Hardware error!"); |
|||
break; |
|||
case ERR_HEAD_NOT_RECOGNIZED: |
|||
return F("Save mode returned not recognized!"); |
|||
break; |
|||
case ERR_NO_RESPONSE_FROM_DEVICE: |
|||
return F("No response from device! (Check wiring)"); |
|||
break; |
|||
case ERR_WRONG_UART_CONFIG: |
|||
return F("Wrong UART configuration! (BPS must be 9600 for configuration)"); |
|||
break; |
|||
case ERR_PACKET_TOO_BIG: |
|||
return F("The device support only 58byte of data transmission!"); |
|||
break; |
|||
default: |
|||
return F("Invalid status!"); |
|||
} |
|||
} |
|||
|
|||
enum UART_PARITY |
|||
{ |
|||
MODE_00_8N1 = B00, |
|||
MODE_01_8O1 = B01, |
|||
MODE_10_8E1 = B10, |
|||
MODE_11_8N1 = B11 |
|||
}; |
|||
|
|||
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"); |
|||
break; |
|||
default: |
|||
return F("Invalid UART Parity!"); |
|||
} |
|||
} |
|||
|
|||
enum UART_BPS_TYPE |
|||
{ |
|||
UART_BPS_1200 = B000, |
|||
UART_BPS_2400 = B001, |
|||
UART_BPS_4800 = B010, |
|||
UART_BPS_9600 = B011, |
|||
UART_BPS_19200 = B100, |
|||
UART_BPS_38400 = B101, |
|||
UART_BPS_57600 = B110, |
|||
UART_BPS_115200 = B111 |
|||
}; |
|||
|
|||
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_03 = B000, |
|||
AIR_DATA_RATE_001_12 = B001, |
|||
AIR_DATA_RATE_010_24 = B010, |
|||
AIR_DATA_RATE_011_48 = B011, |
|||
AIR_DATA_RATE_100_96 = B100, |
|||
AIR_DATA_RATE_101_192 = B101, |
|||
AIR_DATA_RATE_110_192 = B110, |
|||
AIR_DATA_RATE_111_192 = B111 |
|||
}; |
|||
|
|||
|
|||
static String getAirDataRateDescriptionByParams(byte airDataRate) |
|||
{ |
|||
switch (airDataRate) |
|||
{ |
|||
case AIR_DATA_RATE_000_03: |
|||
return F("0.3kbps"); |
|||
break; |
|||
case AIR_DATA_RATE_001_12: |
|||
return F("1.2kbps"); |
|||
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_192: |
|||
return F("19.2kbps"); |
|||
break; |
|||
case AIR_DATA_RATE_111_192: |
|||
return F("19.2kbps"); |
|||
break; |
|||
default: |
|||
return F("Invalid Air Data Rate!"); |
|||
} |
|||
} |
|||
|
|||
|
|||
enum FIDEX_TRANSMISSION |
|||
{ |
|||
FT_TRANSPARENT_TRANSMISSION = B0, |
|||
FT_FIXED_TRANSMISSION = B1 |
|||
}; |
|||
|
|||
|
|||
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!"); |
|||
} |
|||
} |
|||
|
|||
|
|||
enum IO_DRIVE_MODE |
|||
{ |
|||
IO_D_MODE_OPEN_COLLECTOR = B0, |
|||
IO_D_MODE_PUSH_PULLS_PULL_UPS = B1 |
|||
}; |
|||
|
|||
|
|||
static String getIODriveModeDescriptionDescriptionByParams(byte ioDriveMode) |
|||
{ |
|||
switch (ioDriveMode) |
|||
{ |
|||
case IO_D_MODE_OPEN_COLLECTOR: |
|||
return F("TXD, RXD, AUX are open-collectors"); |
|||
break; |
|||
case IO_D_MODE_PUSH_PULLS_PULL_UPS: |
|||
return F("TXD, RXD, AUX are push-pulls/pull-ups"); |
|||
break; |
|||
default: |
|||
return F("Invalid IO drive mode!"); |
|||
} |
|||
} |
|||
|
|||
enum WIRELESS_WAKE_UP_TIME |
|||
{ |
|||
WAKE_UP_250 = B000, |
|||
WAKE_UP_500 = B001, |
|||
WAKE_UP_750 = B010, |
|||
WAKE_UP_1000 = B011, |
|||
WAKE_UP_1250 = B100, |
|||
WAKE_UP_1500 = B101, |
|||
WAKE_UP_1750 = B110, |
|||
WAKE_UP_2000 = B111 |
|||
}; |
|||
|
|||
|
|||
static String getWirelessWakeUPTimeDescriptionByParams(byte wirelessWakeUPTime) |
|||
{ |
|||
switch (wirelessWakeUPTime) |
|||
{ |
|||
case WAKE_UP_250: |
|||
return F("250ms (default)"); |
|||
break; |
|||
case WAKE_UP_500: |
|||
return F("500ms"); |
|||
break; |
|||
case WAKE_UP_750: |
|||
return F("750ms"); |
|||
break; |
|||
case WAKE_UP_1000: |
|||
return F("1000ms"); |
|||
break; |
|||
case WAKE_UP_1250: |
|||
return F("1250ms"); |
|||
break; |
|||
case WAKE_UP_1500: |
|||
return F("1500ms"); |
|||
break; |
|||
case WAKE_UP_1750: |
|||
return F("1750ms"); |
|||
break; |
|||
case WAKE_UP_2000: |
|||
return F("2000ms"); |
|||
break; |
|||
default: |
|||
return F("Invalid wireless wake-up mode!"); |
|||
} |
|||
} |
|||
enum FORWARD_ERROR_CORRECTION_SWITCH |
|||
{ |
|||
FEC_0_OFF = B0, |
|||
FEC_1_ON = B1 |
|||
}; |
|||
|
|||
|
|||
static String getFECDescriptionByParams(byte fec) |
|||
{ |
|||
switch (fec) |
|||
{ |
|||
case FEC_0_OFF: |
|||
return F("Turn off Forward Error Correction Switch"); |
|||
break; |
|||
case FEC_1_ON: |
|||
return F("Turn on Forward Error Correction Switch (Default)"); |
|||
break; |
|||
default: |
|||
return F("Invalid FEC param"); |
|||
} |
|||
} |
|||
|
|||
#ifdef E32_TTL_100 |
|||
enum TRANSMISSION_POWER |
|||
{ |
|||
POWER_20 = B00, |
|||
POWER_17 = B01, |
|||
POWER_14 = B10, |
|||
POWER_10 = B11 |
|||
|
|||
}; |
|||
|
|||
static String getTransmissionPowerDescriptionByParams(byte transmissionPower) |
|||
{ |
|||
switch (transmissionPower) |
|||
{ |
|||
case POWER_20: |
|||
return F("20dBm (Default)"); |
|||
break; |
|||
case POWER_17: |
|||
return F("17dBm"); |
|||
break; |
|||
case POWER_14: |
|||
return F("14dBm"); |
|||
break; |
|||
case POWER_10: |
|||
return F("10dBm"); |
|||
break; |
|||
default: |
|||
return F("Invalid transmission power param"); |
|||
} |
|||
} |
|||
#elif defined(E32_TTL_500) |
|||
enum TRANSMISSION_POWER |
|||
{ |
|||
POWER_27 = B00, |
|||
POWER_24 = B01, |
|||
POWER_21 = B10, |
|||
POWER_18 = B11 |
|||
|
|||
}; |
|||
|
|||
static String getTransmissionPowerDescriptionByParams(byte transmissionPower) |
|||
{ |
|||
switch (transmissionPower) |
|||
{ |
|||
case POWER_27: |
|||
return F("27dBm (Default)"); |
|||
break; |
|||
case POWER_24: |
|||
return F("24dBm"); |
|||
break; |
|||
case POWER_21: |
|||
return F("21dBm"); |
|||
break; |
|||
case POWER_18: |
|||
return F("18dBm"); |
|||
break; |
|||
default: |
|||
return F("Invalid transmission power param"); |
|||
} |
|||
} |
|||
#elif defined(E32_TTL_1W) |
|||
enum TRANSMISSION_POWER |
|||
{ |
|||
POWER_30 = B00, |
|||
POWER_27 = B01, |
|||
POWER_24 = B10, |
|||
POWER_21 = B11 |
|||
|
|||
}; |
|||
|
|||
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_20 = B00, |
|||
POWER_17 = B01, |
|||
POWER_14 = B10, |
|||
POWER_10 = B11 |
|||
|
|||
}; |
|||
|
|||
static String getTransmissionPowerDescriptionByParams(byte transmissionPower) |
|||
{ |
|||
switch (transmissionPower) |
|||
{ |
|||
case POWER_20: |
|||
return F("20dBm (Default)"); |
|||
break; |
|||
case POWER_17: |
|||
return F("17dBm"); |
|||
break; |
|||
case POWER_14: |
|||
return F("14dBm"); |
|||
break; |
|||
case POWER_10: |
|||
return F("10dBm"); |
|||
break; |
|||
default: |
|||
return F("Invalid transmission power param"); |
|||
} |
|||
} |
|||
#endif |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue