Home-IoT/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-12-29 17:01:43 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

and this

Browse source
This commit is contained in:
Daniël Koek 2024-03-25 14:34:36 +00:00
parent 6617baeae6
commit 6b7e92b80f
4 changed files with 62 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
esphome/components/lora/gpio/gpio_lora.cpp
View file

@ -2,11 +2,11 @@
namespace esphome {
namespace lora {
static const char *const TAGPin = "lora.pin";
static const char *const TAG_PIN = "lora.pin";
void LoraGPIOPin::setup() { pin_mode(flags_); }
void LoraGPIOPin::pin_mode(gpio::Flags flags) {
if (flags != gpio::FLAG_OUTPUT) {
ESP_LOGD(TAGPin, "Output only supported");
ESP_LOGD(TAG_PIN, "Output only supported");
}
}
bool LoraGPIOPin::digital_read() { return false; }

1
esphome/components/lora/gpio/gpio_lora.h
View file

@ -16,7 +16,6 @@ class LoraGPIOPin : public GPIOPin {
bool digital_read() override;
void digital_write(bool value) override;
std::string dump_summary() const override;
void set_parent(Lora *parent) { parent_ = parent; }
void set_pin(uint8_t pin) { pin_ = pin; }
void set_inverted(bool inverted) { inverted_ = inverted; }

90
esphome/components/lora/lora.cpp
View file

@ -3,69 +3,70 @@
namespace esphome {
namespace lora {
void Lora::update() {
if (this->rssi_sensor != nullptr)
this->rssi_sensor->publish_state(this->rssi_);
if (this->rssi_sensor_ != nullptr)
this->rssi_sensor_->publish_state(this->rssi_);
// raw info
if (this->message_text_sensor != nullptr)
this->message_text_sensor->publish_state(this->raw_message_);
if (this->message_text_sensor_ != nullptr)
this->message_text_sensor_->publish_state(this->raw_message_);
}
void Lora::setup() {
this->pin_aux->setup();
this->pin_m0->setup();
this->pin_m1->setup();
if (this->pin_aux != nullptr) {
this->pin_aux->pin_mode(gpio::FLAG_INPUT);
this->pin_aux_->setup();
this->pin_m0_->setup();
this->pin_m1_->setup();
if (this->pin_aux_ != nullptr) {
this->pin_aux_->pin_mode(gpio::FLAG_INPUT);
ESP_LOGD(TAG, "Init AUX pin!");
}
if (this->pin_m0 != nullptr) {
this->pin_m0->pin_mode(gpio::FLAG_OUTPUT);
if (this->pin_m0_ != nullptr) {
this->pin_m0_->pin_mode(gpio::FLAG_OUTPUT);
ESP_LOGD(TAG, "Init M0 pin!");
this->pin_m0->digital_write(true);
this->pin_m0_->digital_write(true);
}
if (this->pin_m1 != nullptr) {
this->pin_m1->pin_mode(gpio::FLAG_OUTPUT);
if (this->pin_m1_ != nullptr) {
this->pin_m1_->pin_mode(gpio::FLAG_OUTPUT);
ESP_LOGD(TAG, "Init M1 pin!");
this->pin_m1->digital_write(true);
this->pin_m1_->digital_write(true);
}
bool status = setMode(MODE_0_NORMAL);
if (status)
bool status = set_mode_(MODE_0_NORMAL);
if (status) {
ESP_LOGD(TAG, "Setup success");
else
} else {
ESP_LOGD(TAG, "Something went wrong");
}
}
bool Lora::setMode(MODE_TYPE mode) {
bool Lora::set_mode_(ModeType mode) {
// data sheet claims module needs some extra time after mode setting (2ms)
// most of my projects uses 10 ms, but 40ms is safer
delay(40);
if (this->pin_m0 == nullptr && this->pin_m1 == nullptr) {
if (this->pin_m0_ == nullptr && this->pin_m1_ == nullptr) {
ESP_LOGD(TAG, "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
this->pin_m0->digital_write(false);
this->pin_m1->digital_write(false);
this->pin_m0_->digital_write(false);
this->pin_m1_->digital_write(false);
ESP_LOGD(TAG, "MODE NORMAL!");
break;
case MODE_1_WOR_TRANSMITTER:
this->pin_m0->digital_write(true);
this->pin_m1->digital_write(false);
this->pin_m0_->digital_write(true);
this->pin_m1_->digital_write(false);
ESP_LOGD(TAG, "MODE WOR!");
break;
case MODE_2_WOR_RECEIVER:
// case MODE_2_PROGRAM:
this->pin_m0->digital_write(false);
this->pin_m1->digital_write(true);
this->pin_m0_->digital_write(false);
this->pin_m1_->digital_write(true);
ESP_LOGD(TAG, "MODE RECEIVING!");
break;
case MODE_3_CONFIGURATION:
// Mode 3 | Setting operation
this->pin_m0->digital_write(true);
this->pin_m1->digital_write(true);
this->pin_m0_->digital_write(true);
this->pin_m1_->digital_write(true);
ESP_LOGD(TAG, "MODE SLEEP CONFIG!");
break;
@ -78,10 +79,10 @@ bool Lora::setMode(MODE_TYPE mode) {
delay(40);
// wait until aux pin goes back low
bool result = this->waitCompleteResponse(1000);
bool result = this->wait_complete_response_(1000);
if (result) {
this->mode = mode;
this->mode_ = mode;
ESP_LOGD(TAG, "Mode set");
return true;
} else {
@ -89,18 +90,18 @@ bool Lora::setMode(MODE_TYPE mode) {
return false;
}
}
bool Lora::waitCompleteResponse(unsigned long timeout, unsigned int waitNoAux) {
unsigned long t = millis();
bool Lora::wait_complete_response_(uint32_t timeout, uint32_t wait_no_aux) {
uint32_t t = millis();
// make darn sure millis() is not about to reach max data type limit and start over
if (((unsigned long) (t + timeout)) == 0) {
if ((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->pin_aux != nullptr) {
while (this->pin_aux->digital_read() == false) {
if (this->pin_aux_ != nullptr) {
while (this->pin_aux_->digital_read() == false) {
if ((millis() - t) > timeout) {
ESP_LOGD(TAG, "Timeout error!");
return false;
@ -110,7 +111,7 @@ bool Lora::waitCompleteResponse(unsigned long timeout, unsigned int waitNoAux) {
} else {
// if you can't use aux pin, use 4K7 pullup with Arduino
// you may need to adjust this value if transmissions fail
delay(waitNoAux);
delay(wait_no_aux);
ESP_LOGD(TAG, "Wait no AUX pin!");
}
@ -120,12 +121,12 @@ bool Lora::waitCompleteResponse(unsigned long timeout, unsigned int waitNoAux) {
}
void Lora::dump_config() {
ESP_LOGCONFIG(TAG, "Ebyte Lora E220");
LOG_PIN("Aux pin:", this->pin_aux);
LOG_PIN("M0 Pin:", this->pin_m0);
LOG_PIN("M1 Pin:", this->pin_m1);
LOG_PIN("Aux pin:", this->pin_aux_);
LOG_PIN("M0 Pin:", this->pin_m0_);
LOG_PIN("M1 Pin:", this->pin_m1_);
};
void Lora::digital_write(uint8_t pin, bool value) { this->sendPinInfo(pin, value); }
bool Lora::sendPinInfo(uint8_t pin, bool value) {
void Lora::digital_write(uint8_t pin, bool value) { this->send_pin_info_(pin, value); }
bool Lora::send_pin_info_(uint8_t pin, bool value) {
uint8_t data[3];
data[1] = 0xA5; // just some bit to indicate, yo this is pin info
data[1] = pin; // Pin to send
@ -156,14 +157,15 @@ void Lora::loop() {
data.push_back(c);
}
}
ESP_LOGD(TAG, "Got %s", buffer);
if (data.size() != 0) {
ESP_LOGD(TAG, "Got %s", buffer.c_str());
if (!data.empty()) {
ESP_LOGD(TAG, "Found pin data!");
ESP_LOGD(TAG, "PIN: %u ", data[1]);
ESP_LOGD(TAG, "VALUE: %u ", data[2]);
}
char *ptr;
// set the rssi
rssi_ = atoi(buffer.substr(buffer.length() - 1, 1).c_str());
rssi_ = strtol(buffer.substr(buffer.length() - 1, 1).c_str(), &ptr, 2);
ESP_LOGD(TAG, "RSSI: %u ", rssi_);
// set the raw message
raw_message_ = buffer.substr(0, buffer.length() - 1);

28
esphome/components/lora/lora.h
View file

@ -14,7 +14,7 @@ namespace lora {
static const char *const TAG = "lora";
static const uint8_t MAX_SIZE_TX_PACKET = 200;
// the mode the receiver is in
enum MODE_TYPE {
enum ModeType {
MODE_0_NORMAL = 0,
MODE_0_TRANSMISSION = 0,
MODE_1_WOR_TRANSMITTER = 1,
@ -40,29 +40,29 @@ class Lora : public PollingComponent, public uart::UARTDevice {
/// Helper function to set the pin mode of a pin.
void pin_mode(uint8_t pin, gpio::Flags flags);
void set_message_sensor(text_sensor::TextSensor *s) { message_text_sensor = s; }
void set_rssi_sensor(sensor::Sensor *s) { rssi_sensor = s; }
void set_pin_aux(GPIOPin *s) { pin_aux = s; }
void set_pin_m0(GPIOPin *s) { pin_m0 = s; }
void set_pin_m1(GPIOPin *s) { pin_m1 = s; }
void set_rssi_sensor(sensor::Sensor *s) { rssi_sensor_ = s; }
void set_pin_aux(GPIOPin *s) { pin_aux_ = s; }
void set_pin_m0(GPIOPin *s) { pin_m0_ = s; }
void set_pin_m1(GPIOPin *s) { pin_m1_ = s; }
private:
MODE_TYPE mode = MODE_0_NORMAL;
ModeType mode_ = MODE_0_NORMAL;
// set WOR mode
bool setMode(MODE_TYPE type);
bool set_mode_(ModeType type);
// checks the aux port to see if it is done setting
bool waitCompleteResponse(unsigned long timeout = 1000, unsigned int waitNoAux = 100);
bool sendPinInfo(uint8_t pin, bool value);
bool wait_complete_response_(uint32_t timeout = 1000, uint32_t waitNoAux = 100);
bool send_pin_info_(uint8_t pin, bool value);
protected:
int rssi_ = 0;
float latitude_ = -1;
float longitude_ = -1;
std::string raw_message_;
text_sensor::TextSensor *message_text_sensor{nullptr};
sensor::Sensor *rssi_sensor{nullptr};
GPIOPin *pin_aux{nullptr};
GPIOPin *pin_m0{nullptr};
GPIOPin *pin_m1{nullptr};
text_sensor::TextSensor *message_text_sensor_{nullptr};
sensor::Sensor *rssi_sensor_{nullptr};
GPIOPin *pin_aux_{nullptr};
GPIOPin *pin_m0_{nullptr};
GPIOPin *pin_m1_{nullptr};
};
} // namespace lora