Archives/Farm-Data-Relay-System
2
0
Fork 0
mirror of https://github.com/timmbogner/Farm-Data-Relay-System synced 2024-11-10 07:10:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added example from @Devilbinder to the repo

Browse Source 
Added the example sketch.
At the moment this resides in a separate folder but after the Universal_Gateway has been finished this could be moved into the Full_System_Example or a generic Gateway_Examples folder.
This commit is contained in:
Sascha 2022-07-11 16:47:15 +02:00
parent 9ab5be2258
commit 0d7c767070
5 changed files with 1022 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
examples/UG_ESPNOW_2_MQTT/UG_ESPNOW_2_MQTT.ino Normal file
View File

@ -0,0 +1,44 @@
#include "fdrs_gateway_config.h"
#include "fdrs_gateway.h"
std::vector<DataReading_t> espnow_peer_unknown_data;
std::vector<DataReading_t> espnow_peer_1_data;
std::vector<DataReading_t> espnow_peer_2_data;
uint8_t selfAddress[6] = {MAC_PREFIX, UNIT_MAC};
uint8_t ESPNOW1[] = {MAC_PREFIX, ESPNOW_PEER_1};
uint8_t ESPNOW2[] = {MAC_PREFIX, ESPNOW_PEER_2};
// ToDo: include global configuration values and use them here
//MQTT_FDRSGateWay MQTT(FDRS_WIFI_SSID,FDRS_WIFI_PASS,FDRS_MQTT_ADDR,FDRS_MQTT_PORT);
MQTT_FDRSGateWay MQTT(WIFI_SSID,WIFI_PASS,MQTT_ADDR,MQTT_PORT);
ESP_FDRSGateWay ESPNow;
void setup() {
MQTT.init();
ESPNow.init(selfAddress);
ESPNow.add_peer(ESPNOW1);
ESPNow.add_peer(ESPNOW2);
}
void loop() {
espnow_peer_unknown_data = ESPNow.get_unkown_peer_data();
espnow_peer_1_data = ESPNow.get_peer_data(ESPNOW1);
espnow_peer_2_data = ESPNow.get_peer_data(ESPNOW2);
MQTT.release(espnow_peer_unknown_data);
MQTT.release(espnow_peer_1_data);
MQTT.release(espnow_peer_2_data);
ESPNow.flush();
ESPNow.flush(ESPNOW1);
ESPNow.flush(ESPNOW2);
MQTT.flush();
delay(1000);
}

687
examples/UG_ESPNOW_2_MQTT/fdrs_gateway.cpp Normal file
View File

@ -0,0 +1,687 @@
#include "fdrs_gateway.h"
// #define ESP8266
// #define ESP32
// #define USE_WIFI
bool ESP_FDRSGateWay::is_init = false;
std::vector<Peer_t> ESP_FDRSGateWay::_peer_list;
std::vector<Peer_t> ESP_FDRSGateWay::_unknow_peer;
std::vector<DataReading_t> MQTT_FDRSGateWay::_buffer;
std::vector<DataReading_t> Serial_FDRSGateWay::_buffer;
// Set ESP-NOW send and receive callbacks for either ESP8266 or ESP32
void ESP_FDRSGateWay::OnDataRecv(uint8_t * mac, const uint8_t *incomingData, int len){
DataReading_t data;
uint32_t i = 0;
uint32_t j = 0;
uint8_t d = len / sizeof(DataReading_t);
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),mac,6) == 0){
for(j = 0; j < d; j++){
memcpy(&data,&incomingData[j*sizeof(DataReading_t)],sizeof(DataReading_t));
_peer_list[i].buffer.push_back(data);
memset(&data,0,sizeof(DataReading_t));
}
return;
}
}
for(uint32_t i = 0; i < _unknow_peer.size();i++){
if(memcmp(_unknow_peer[i]._get_peer(),mac,6) == 0){
for(j = 0; j < d; j++){
memcpy(&data,&incomingData[j*sizeof(DataReading_t)],sizeof(DataReading_t));
_unknow_peer[i].buffer.push_back(data);
memset(&data,0,sizeof(DataReading_t));
}
return;
}
}
Peer_t peer;
peer._set_peer(mac);
_unknow_peer.push_back(peer);
for(j = 0; j < d; j++){
memcpy(&data,&incomingData[j*sizeof(DataReading_t)],sizeof(DataReading_t));
_unknow_peer.back().buffer.push_back(data);
memset(&data,0,sizeof(DataReading_t));
}
}
#if defined(ESP8266)
void ESP8266OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {
}
void ESP8266OnDataRecv(uint8_t* mac, uint8_t *incomingData, uint8_t len) {
ESP_FDRSGateWay::OnDataRecv((uint8_t*)mac,*(const uint8_t *)incomingData,len);
}
#endif
#if defined(ESP32)
void ESP32OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
}
void ESP32OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
ESP_FDRSGateWay::OnDataRecv((uint8_t*)mac,incomingData,len);
}
#endif
FDRSGateWayBase::FDRSGateWayBase(){
}
FDRSGateWayBase::~FDRSGateWayBase(){
}
void FDRSGateWayBase::release(std::vector<DataReading_t> data,uint8_t *peer_mac){
if(peer_mac == NULL){
send(data);
}
forward(peer_mac ,data);
}
ESP_FDRSGateWay::ESP_FDRSGateWay(void)
{
memset(_broadcast_mac,0xFF,6);
memset(_inturnal_mac,0,6);
}
void ESP_FDRSGateWay::init(uint8_t inturnal_mac[5]){
memcpy(_inturnal_mac,inturnal_mac,6);
#if defined(ESP8266)
wifi_set_macaddr(STATION_IF, _inturnal_mac);
#endif
#if defined(ESP32)
esp_wifi_set_mac(WIFI_IF_STA, &_inturnal_mac[0]);
#endif
ESP_FDRSGateWay::setup();
#if defined(ESP32)
esp_now_peer_info_t peerInfo;
memset(&peerInfo, 0, sizeof(peerInfo));
peerInfo.channel = 0;
peerInfo.encrypt = false;
// Register first peer
memcpy(peerInfo.peer_addr, _broadcast_mac, 6);
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
DBG("Failed to add peer bcast");
return;
}
#endif
}
void ESP_FDRSGateWay::setup(void){
if(is_init){
return;
}
is_init = true;
WiFi.mode(WIFI_STA);
WiFi.disconnect();
#if defined(ESP8266)
if (esp_now_init() != 0) {
return;
}
esp_now_set_self_role(ESP_NOW_ROLE_COMBO);
esp_now_register_send_cb(ESP8266OnDataSent);
esp_now_register_recv_cb(ESP8266OnDataRecv);
#endif
#if defined(ESP32)
if(esp_now_init() != ESP_OK) {
DBG("Error initializing ESP-NOW");
return;
}
esp_now_register_send_cb(ESP32OnDataSent);
esp_now_register_recv_cb(ESP32OnDataRecv);
#endif
DBG("ESP-NOW Initialized.");
}
void ESP_FDRSGateWay::add_peer(uint8_t peer_mac[6]){
uint32_t i = 0;
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),peer_mac,6) == 0){
return;
}
}
list_peer(peer_mac);
Peer_t peer;
peer._set_peer(peer_mac);
//esp_now_del_peer(NEWPEER);
_peer_list.push_back(peer);
}
void ESP_FDRSGateWay::remove_peer(uint8_t peer_mac[6]){
unlist_peer(peer_mac);
if(_peer_list.size() == 0){
return;
}
Peer_t peer;
peer._set_peer(peer_mac);
_peer_list.erase(std::find(_peer_list.begin(),_peer_list.end(),peer));
}
void ESP_FDRSGateWay::list_peer(uint8_t peer_mac[6]){
#if defined(ESP8266)
esp_now_add_peer(peer_mac, ESP_NOW_ROLE_COMBO, 0, NULL, 0);
#endif
#if defined(ESP32)
esp_now_peer_info_t peerInfo;
memset(&peerInfo, 0, sizeof(peerInfo));
peerInfo.channel = 0;
peerInfo.encrypt = false;
memcpy(peerInfo.peer_addr, peer_mac, 6);
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
DBG("Failed to add peer 1");
return;
}
#endif
}
void ESP_FDRSGateWay::unlist_peer(uint8_t peer_mac[6]){
esp_now_del_peer(peer_mac);
}
std::vector<DataReading_t> ESP_FDRSGateWay::get_peer_data(uint8_t *peer_mac){
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),peer_mac,6) == 0){
return _peer_list[i].buffer;
}
}
return std::vector<DataReading_t>();
}
std::vector<DataReading_t> ESP_FDRSGateWay::get_unkown_peer_data(void){
std::vector<DataReading_t> data;
for(uint32_t i = 0; i < _unknow_peer.size(); i++){
data.insert(data.end(),_unknow_peer[i].buffer.begin(),_unknow_peer[i].buffer.end());
}
return data;
}
void ESP_FDRSGateWay::flush(uint8_t *peer_mac){
if(peer_mac == NULL){
for(uint32_t i = 0; i < _unknow_peer.size(); i++){
_unknow_peer[i].buffer.clear();
return;
}
}
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),peer_mac,6) == 0){
_peer_list[i].buffer.clear();
return;
}
}
}
void ESP_FDRSGateWay::send(std::vector<DataReading_t> data){
const uint8_t espnow_size = 250 / sizeof(DataReading_t);
uint32_t i = 0;
for(i = 0; i < _unknow_peer.size(); i++){
list_peer(_unknow_peer[i]._get_peer());
}
uint8_t d = data.size() / espnow_size;
DataReading_t buffer1[d * sizeof(DataReading_t)];
memset(buffer1,0,d * sizeof(DataReading_t));
uint32_t j = 0;
for(i = 0; i < data.size(); i++){
buffer1[j++] = data[i];
if(j >= d){
esp_now_send(NULL, (uint8_t *) buffer1, d * sizeof(DataReading_t));
memset(buffer1,0,d * sizeof(DataReading_t));
j = 0;
delay(10);
}
}
if(j != 0){
esp_now_send(NULL, (uint8_t *) buffer1, j * sizeof(DataReading_t));
}
for(i = 0; i < _unknow_peer.size(); i++){
unlist_peer(_unknow_peer[i]._get_peer());
}
_unknow_peer.clear();
}
void ESP_FDRSGateWay::forward(uint8_t *peer_mac ,std::vector<DataReading_t> data){
const uint8_t espnow_size = 250 / sizeof(DataReading_t);
uint8_t d = data.size() / espnow_size;
uint32_t i = 0;
DataReading_t buffer1[d * sizeof(DataReading_t)];
memset(buffer1,0,d * sizeof(DataReading_t));
uint32_t j = 0;
for(i = 0; i < data.size(); i++){
buffer1[j++] = data[i];
if(j >= d){
esp_now_send(NULL, (uint8_t *) buffer1, d * sizeof(DataReading_t));
memset(buffer1,0,d * sizeof(DataReading_t));
j = 0;
delay(10);
}
}
if(j != 0){
esp_now_send(NULL, (uint8_t *) buffer1, j * sizeof(DataReading_t));
}
esp_now_send(peer_mac, (uint8_t *) buffer1, d * sizeof(DataReading_t));
}
MQTT_FDRSGateWay::MQTT_FDRSGateWay(const char *ssid, const char *password, const char *server,int port):
_ssid(ssid),
_password(password),
_server(server),
_port(port)
{
_client = new PubSubClient(espClient);
}
MQTT_FDRSGateWay::~MQTT_FDRSGateWay(void){
delete _client;
}
void MQTT_FDRSGateWay::mqtt_callback(char* topic, byte * message, unsigned int length){
//No point in reading topics that are not data.
if(strcmp(TOPIC_DATA,topic) != 0){
return;
}
String incomingString;
DBG(topic);
for (int i = 0; i < length; i++) {
incomingString += (char)message[i];
}
StaticJsonDocument<2048> doc;
DeserializationError error = deserializeJson(doc, incomingString);
if (error) { // Test if parsing succeeds.
DBG("json parse err");
DBG(incomingString);
return;
}
int s = doc.size();
//UART_IF.println(s);
DataReading_t data;
memset(&data,0,sizeof(DataReading_t));
for (int i = 0; i < s; i++) {
data.id = doc[i]["id"];
data.type = doc[i]["type"];
data.data = doc[i]["data"];
_buffer.push_back(data);
memset(&data,0,sizeof(DataReading_t));
}
DBG("Incoming MQTT.");
}
void MQTT_FDRSGateWay::init(void){
delay(10);
WiFi.begin(_ssid, _password);
while (WiFi.status() != WL_CONNECTED) {
DBG("Connecting to WiFi... ");
DBG(_ssid);
delay(500);
}
DBG("WiFi Connected");
_client->setServer(_server, _port);
if (!_client->connected()) {
DBG("Connecting MQTT...");
reconnect();
}
DBG("MQTT Connected");
_client->setCallback(MQTT_FDRSGateWay::mqtt_callback);
_client->publish(TOPIC_STATUS, "FDRS initialized");
}
void MQTT_FDRSGateWay::reconnect() {
// Loop until reconnected
while (!_client->connected()) {
// Attempt to connect
if (_client->connect("FDRS_GATEWAY")) {
// Subscribe
_client->subscribe(TOPIC_COMMAND);
break;
}
DBG("Connecting MQTT.");
delay(5000);
}
}
void MQTT_FDRSGateWay::send(std::vector<DataReading_t> data) {
DBG("Releasing MQTT.");
DynamicJsonDocument doc(24576);
for (int i = 0; i < data.size(); i++) {
doc[i]["id"] = data[i].id;
doc[i]["type"] = data[i].type;
doc[i]["data"] = data[i].data;
}
String outgoingString;
serializeJson(doc, outgoingString);
_client->publish(TOPIC_DATA, (char*) outgoingString.c_str());
reconnect();
_client->loop();
}
void MQTT_FDRSGateWay::forward(uint8_t *peer_mac ,std::vector<DataReading_t> data){
//does nothing. just here implement the pure virtule from the base class.
send(data);
}
std::vector<DataReading_t> MQTT_FDRSGateWay::get_data(void){
return _buffer;
}
void MQTT_FDRSGateWay::flush(uint8_t *peer_mac){
_buffer.clear();
}
Serial_FDRSGateWay::Serial_FDRSGateWay(HardwareSerial *serial, uint32_t baud):
_serial(serial),
_baud(baud)
{
}
void Serial_FDRSGateWay::init(void){
_serial->begin(_baud);
}
#if defined(ESP32)
void Serial_FDRSGateWay::init(int mode, int rx_pin, int tx_pin){
_serial->begin(_baud,mode,rx_pin,tx_pin);
}
#endif
void Serial_FDRSGateWay::pull(void){
//TDDO: This is blocking. Some method of escaping is required.
// At the momment we are just hoping we get a \n
String incomingString = _serial->readStringUntil('\n');
DynamicJsonDocument doc(24576);
DeserializationError error = deserializeJson(doc, incomingString);
// Test if parsing succeeds.
if (error) {
// DBG("json parse err");
// DBG(incomingString);
return;
}
int s = doc.size();
//UART_IF.println(s);
DataReading_t data;
memset(&data,0,sizeof(DataReading_t));
for (int i = 0; i < s; i++) {
data.id = doc[i]["id"];
data.type = doc[i]["type"];
data.data = doc[i]["data"];
_buffer.push_back(data);
memset(&data,0,sizeof(DataReading_t));
}
DBG("Incoming Serial.");
}
std::vector<DataReading_t> Serial_FDRSGateWay::get_data(void){
return _buffer;
}
void Serial_FDRSGateWay::get(void){
while(_serial->available()){
pull();
}
}
void Serial_FDRSGateWay::send(std::vector<DataReading_t> data){
DBG("Releasing Serial.");
DynamicJsonDocument doc(24576);
for (int i = 0; i < data.size(); i++) {
doc[i]["id"] = data[i].id;
doc[i]["type"] = data[i].type;
doc[i]["data"] = data[i].data;
}
serializeJson(doc, *_serial);
_serial->println();
}
void Serial_FDRSGateWay::forward(uint8_t *peer_mac ,std::vector<DataReading_t> data){
//does nothing. just here implement the pure virtule from the base class.
}
void Serial_FDRSGateWay::flush(uint8_t *peer_mac){
_buffer.clear();
}
LoRa_FDRSGateWay::LoRa_FDRSGateWay(uint8_t miso,uint8_t mosi,uint8_t sck, uint8_t ss,uint8_t rst,uint8_t dio0,double band,uint8_t sf):
_miso(miso),
_mosi(mosi),
_sck(sck),
_ss(ss),
_rst(rst),
_dio0(dio0),
_band(band),
_sf(sf)
{
memset(_mac,0,6);
_peer_list.clear();
}
void LoRa_FDRSGateWay::init(uint8_t mac[6]){
memcpy(_mac,mac,6);
DBG("Initializing LoRa!");
#ifdef ESP32
SPI.begin(_sck, _miso, _mosi);
#endif
LoRa.setPins(_ss, _rst, _dio0);
if (!LoRa.begin(_band)) {
DBG(" LoRa initialize failed");
return;
}
LoRa.setSpreadingFactor(_sf);
DBG(" LoRa initialized.");
}
void LoRa_FDRSGateWay::add_peer(uint8_t peer_mac[6]){
uint32_t i = 0;
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),peer_mac,6) == 0){
return;
}
}
Peer_t peer;
peer._set_peer(peer_mac);
_peer_list.push_back(peer);
}
void LoRa_FDRSGateWay::remove_peer(uint8_t peer_mac[6]){
if(_peer_list.size() == 0){
return;
}
Peer_t peer;
peer._set_peer(peer_mac);
_peer_list.erase(std::find(_peer_list.begin(),_peer_list.end(),peer));
}
void LoRa_FDRSGateWay::get(void){
int packetSize = LoRa.parsePacket();
if (packetSize== 0) {
return;
}
uint8_t packet[packetSize];
uint8_t incLORAMAC[2];
LoRa.readBytes((uint8_t *)&packet, packetSize);
// for (int i = 0; i < packetSize; i++) {
// UART_IF.println(packet[i], HEX);
// }
//Check if addressed to this device
if (memcmp(&packet, &_mac[3], 3) != 0) {
return;
}
uint8_t theData[packetSize - 5];
memcpy(&incLORAMAC, &packet[3], 2); //Split off address portion of packet
memcpy(&theData, &packet[5], packetSize - 5); //Split off data portion of packet
//Check if it is from a registered sender
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(&_peer_list[i].peer[3],incLORAMAC,2) == 0){
DataReading_t data;
uint32_t i = 0;
uint8_t d = packetSize / sizeof(DataReading_t);
memset(&data,0,sizeof(DataReading_t));
for(uint32_t j = 0; j < d; j++){
memcpy(&data,&theData[j*sizeof(DataReading_t)],sizeof(DataReading_t));
_peer_list[i].buffer.push_back(data);
memset(&data,0,sizeof(DataReading_t));
}
return;
}
}
DBG("Incoming LoRa.");
}
std::vector<DataReading_t> LoRa_FDRSGateWay::get_peer_data(uint8_t *peer_mac){
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),peer_mac,6) == 0){
return _peer_list[i].buffer;
}
}
return std::vector<DataReading_t>();
}
void LoRa_FDRSGateWay::send(std::vector<DataReading_t> data){
const uint8_t espnow_size = 250 / sizeof(DataReading_t);
uint32_t i = 0;
uint8_t d = data.size() / espnow_size;
DataReading_t buffer1[d];
for(i = 0; i < d; i++){
buffer1[i] = data[i];
}
transmit(buffer1, d * sizeof(DataReading_t));
}
void LoRa_FDRSGateWay::forward(uint8_t *peer_mac ,std::vector<DataReading_t> data){
//TODO: add peer forwading.
}
void LoRa_FDRSGateWay::transmit(DataReading_t *packet, uint8_t len) {
DBG("Transmitting LoRa.");
uint8_t pkt[5 + (len * sizeof(DataReading_t))];
memcpy(&pkt, _mac, 3);
memcpy(&pkt[3], &_mac[4], 2);
memcpy(&pkt[5], packet, len * sizeof(DataReading_t));
LoRa.beginPacket();
LoRa.write((uint8_t*)&pkt, sizeof(pkt));
LoRa.endPacket();
}
void LoRa_FDRSGateWay::flush(uint8_t *peer_mac){
if(peer_mac == NULL){
return;
}
for(uint32_t i = 0; i < _peer_list.size();i++){
if(memcmp(_peer_list[i]._get_peer(),peer_mac,6) == 0){
_peer_list[i].buffer.clear();
return;
}
}
}

187
examples/UG_ESPNOW_2_MQTT/fdrs_gateway.h Normal file
View File

@ -0,0 +1,187 @@
/* FARM DATA RELAY SYSTEM
*
* "fdrs_sensor.h"
*
* Developed by Timm Bogner (timmbogner@gmail.com) for Sola Gratia Farm in Urbana, Illinois, USA.
* Condensed and refactored to a single file pair by Binder Tronics (info@bindertronics.com).
*/
#ifndef __FDRS_GATEWAY_H__
#define __FDRS_GATEWAY_H__
#include "HardwareSerial.h"
#include "fdrs_types.h"
#include <string.h>
#include <vector>
#include <memory>
#include <algorithm>
#include <esp_now.h>
#include <WiFi.h>
#include <esp_wifi.h>
#include "ArduinoJson.h"
#include "PubSubClient.h"
#include "LoRa.h"
#define USE_LORA
#define FDRS_DEBUG
#ifdef FDRS_DEBUG
#define DBG(a) (Serial.println(a))
#else
#define DBG(a)
#endif
class FDRSGateWayBase{
public:
FDRSGateWayBase();
~FDRSGateWayBase();
void release(std::vector<DataReading_t> data, uint8_t *peer_mac = NULL);
virtual void flush(uint8_t *peer_mac = NULL) = 0;
private:
static uint32_t peer_id;
virtual void send(std::vector<DataReading_t> data) = 0;
virtual void forward(uint8_t *peer_mac ,std::vector<DataReading_t> data) = 0;
};
class ESP_FDRSGateWay: public FDRSGateWayBase{
public:
ESP_FDRSGateWay(void);
static void OnDataRecv(uint8_t * mac, const uint8_t *incomingData, int len);
void init(uint8_t inturnal_mac[5]);
void add_peer(uint8_t peer_mac[6]);
void remove_peer(uint8_t peer_mac[6]);
std::vector<DataReading_t> get_peer_data(uint8_t peer_mac[6]);
std::vector<DataReading_t> get_unkown_peer_data(void);
void flush(uint8_t *peer_mac = NULL) override;
private:
static bool is_init;
uint8_t _broadcast_mac[6];
uint8_t _inturnal_mac[6];
static std::vector<Peer_t> _peer_list;
static std::vector<Peer_t> _unknow_peer;
static void setup(void);
void send(std::vector<DataReading_t> data) override;
void forward(uint8_t *peer_mac ,std::vector<DataReading_t> data) override;
void list_peer(uint8_t peer_mac[6]);
void unlist_peer(uint8_t peer_mac[6]);
};
class MQTT_FDRSGateWay: public FDRSGateWayBase{
public:
MQTT_FDRSGateWay(const char *ssid, const char *password, const char *server,int port = 1883);
~MQTT_FDRSGateWay(void);
void init(void);
std::vector<DataReading_t> get_data(void);
void flush(uint8_t *peer_mac = NULL) override;
private:
#define TOPIC_DATA "fdrs/data"
#define TOPIC_STATUS "fdrs/status"
#define TOPIC_COMMAND "fdrs/command"
static void mqtt_callback(char* topic, byte * message, unsigned int length);
const char *_ssid;
const char *_password;
const char *_server;
int _port;
WiFiClient espClient;
PubSubClient *_client;
static std::vector<DataReading_t> _buffer;
void reconnect();
void send(std::vector<DataReading_t> data) override;
void forward(uint8_t *peer_mac ,std::vector<DataReading_t> data) override;
};
class Serial_FDRSGateWay: public FDRSGateWayBase{
public:
Serial_FDRSGateWay(HardwareSerial *serial, uint32_t baud);
void init(void);
#if defined(ESP32)
void init(int mode, int rx_pin, int tx_pin);
#endif
void get(void);
std::vector<DataReading_t> get_data(void);
void flush(uint8_t *peer_mac = NULL) override;
private:
HardwareSerial *_serial;
uint32_t _baud;
static std::vector<DataReading_t> _buffer;
static void setup(void);
void pull(void);
void send(std::vector<DataReading_t> data) override;
void forward(uint8_t *peer_mac ,std::vector<DataReading_t> data) override;
};
class LoRa_FDRSGateWay: public FDRSGateWayBase{
public:
LoRa_FDRSGateWay(uint8_t miso,uint8_t mosi,uint8_t sck, uint8_t ss,uint8_t rst,uint8_t dio0,double band,uint8_t sf);
void init(uint8_t mac[6]);
void get(void);
void add_peer(uint8_t peer_mac[6]);
void remove_peer(uint8_t peer_mac[6]);
std::vector<DataReading_t> get_peer_data(uint8_t *peer_mac);
void flush(uint8_t *peer_mac = NULL) override;
private:
uint8_t _mac[6];
uint8_t _miso;
uint8_t _mosi;
uint8_t _sck;
uint8_t _ss;
uint8_t _rst;
uint8_t _dio0;
uint32_t _band;
uint8_t _sf;
std::vector<Peer_t> _peer_list;
void transmit(DataReading_t *packet, uint8_t len);
void send(std::vector<DataReading_t> data) override;
void forward(uint8_t *peer_mac ,std::vector<DataReading_t> data) override;
};
#endif

65
examples/UG_ESPNOW_2_MQTT/fdrs_gateway_config.h Normal file
View File

@ -0,0 +1,65 @@
// FARM DATA RELAY SYSTEM
//
// GATEWAY 2.000 Configuration
#include <fdrs_globals.h> // uncomment if you want to set specific values for this sensor in sensor_setup.h
#define FDRS_DEBUG
#define MAC_PREFIX 0xAA, 0xBB, 0xCC, 0xDD, 0xEE // Should only be changed if implementing multiple FDRS systems.
#define UNIT_MAC 0x03 // The address of this gateway
//Where we get the data from
#define LORA_GET
#define MQTT_GET
#define ESP_GET
#define SER_GET
//Where we send the data to
#define LORA_SEND
#define MQTT_SEND
#define ESP_SEND
#define SER_SEND
//#define USE_LORA
//#define USE_WIFI //Used only for MQTT gateway
// Peer addresses
#define LORA_PEER_1 0x0E // LoRa1 Address
#define LORA_PEER_2 0x0F // LoRa2 Address
#define ESPNOW_ALL //send to all know and unknow peers
#define ESPNOW_PEER_1 0x0C // ESPNOW1 Address
#define ESPNOW_PEER_2 0x0D // ESPNOW2 Address
// TODO: Needs to be commented out if FDRS_GLOBALS are assigned
//WiFi and MQTT Credentials -- Needed only for MQTT gateway
#define WIFI_SSID "Your SSID"
#define WIFI_PASS "Your Password"
#define MQTT_ADDR "192.168.0.8"
#define MQTT_PORT 1883
//Pins for UART data interface (ESP32 only)
#define RXD2 14
#define TXD2 15
//SPI Configuration -- Needed only on Boards with multiple SPI interfaces like the ESP32
#define SPI_SCK 5
#define SPI_MISO 19
#define SPI_MOSI 27
//LoRa Configuration -- Needed only if using LoRa
#define LORA_SS 18
#define LORA_RST 14
#define LORA_DIO0 26
//433E6 for Asia
//866E6 for Europe
//915E6 for North America
// TODO: Needs to be commented out if FDRS_GLOBALS are assigned
#define LORA_BAND 866E6
#define LORA_SF 7
//#define USE_LED //Not yet fully implemented
#define LED_PIN 32
#define NUM_LEDS 4

39
examples/UG_ESPNOW_2_MQTT/fdrs_types.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef __FDRS_TYPES_H__
#define __FDRS_TYPES_H__
#include <stdint.h>
#include <string.h>
#include <vector>
typedef struct __attribute__((packed)) DataReading_t {
float data;
uint16_t id;
uint8_t type;
DataReading_t(): data(0.0),id(0),type(0){
}
} DataReading_t;
typedef struct Peer_t{
uint8_t peer[6];
std::vector<DataReading_t> buffer;
Peer_t(){
memset(peer,0,6);
buffer.clear();
}
void _set_peer(uint8_t p[6]){
memcpy(peer,p,6);
}
uint8_t *_get_peer(void){
return peer;
}
bool operator==(Peer_t c){
return (memcmp(this->peer,c.peer,6) == 0);
}
}Peer_t;
#endif