barback32/main/main.c

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "driver/uart.h"
#include "esp_log.h"
#include "esp_debug_helpers.h"

#include "esp32-lora.h"
#include "console.h"

static const char *TAG = "lora-bigbin";

// disable memory alignment
#pragma pack(push, 1)
typedef struct {
  uint8_t src[3];
  uint8_t dst[3];
  uint8_t type;
  void *payload;
} lora_packet;

// this is wrong, why is working correctly? should be 7
#define LORA_PACKET_HEADER_SIZE (8)

typedef struct {
  uint8_t length;
  char *msg;
} lora_msg;

#define LORA_MSG_HEADER_SIZE (1)

typedef struct {
  uint8_t origin[3];
  uint8_t type; // same as packet type
  void *payload;
} lora_routing;

#define LORA_ROUTING_HEADER_SIZE (4)

#pragma pack(pop)

enum lora_msg_type {
  TEXT = 0,
  ROUTING,
};

static lora32_cfg_t lora;

uint8_t mac[6] = {0};

static void handle_lora_txdone() {
  ESP_LOGI(TAG, "txdone: enabling continuous RX");

  lora32_enable_continuous_rx(&lora);
}

void handle_lora_caddone(bool detected) {
  //ESP_LOGI(TAG, "CAD done: detected? %s", detected ? "true" : "false");

  if(detected) {
    lora32_enable_cad(&lora);
  } else {
    ESP_LOGI(TAG, "candone (no channel activity): enabling continuous RX");

    lora32_enable_continuous_rx(&lora);
  }
}

static void handle_lora_receive(uint8_t size) {
  printf("packet size: %d\n", size);

  uint8_t *buf = malloc(size);
  lora_packet *packet = malloc(sizeof(lora_packet));

  // get data from the lora driver
  lora32_read_data(&lora, buf);

  // copy buffer onto message headers
  memcpy(packet, buf, LORA_PACKET_HEADER_SIZE);
  ESP_LOGI(TAG, "[%02X:%02X:%02X] type: %02X", packet->src[0], packet->src[1], packet->src[2], packet->type);

  if(memcmp(packet->src, &mac[3], 3) == 0) {
    ESP_LOGI(TAG, "received own packet, done");
    goto receive_cleanup;
  }

  if(packet->type == TEXT) {
    lora_msg *msg = malloc(sizeof(lora_msg));
    memcpy(msg, buf + LORA_PACKET_HEADER_SIZE, LORA_MSG_HEADER_SIZE);

    // allocate memory for message payload
    msg->msg = malloc(msg->length);

    memcpy(msg->msg, buf + LORA_PACKET_HEADER_SIZE + LORA_MSG_HEADER_SIZE, msg->length);

    ESP_LOGI(TAG, "msg (len: %d): %s", msg->length, msg->msg);

    free(msg->msg);
    msg->msg = NULL;
    free(msg);
  } else if(packet->type == ROUTING) {
    // future stuff
  } else if((char*)packet[0] >= 32 && (char*)packet[0] <= 126) {
    // mostly for dumping purposes
    ((char*)packet)[size] = '\0';
    ESP_LOGI(TAG, "%s", (char*)packet);

    goto receive_cleanup;
  } else {
    ESP_LOGW(TAG, "Unknown packet type: %02X", packet->type);

    goto receive_cleanup;
  }

  vTaskDelay(3000/portTICK_PERIOD_MS);
  ESP_LOGI(TAG, "relaying message");

  lora32_send(&lora, buf, size);

receive_cleanup:
  free(buf);

  lora32_enable_continuous_rx(&lora);
}

void send_message(lora32_cfg_t *lora, char *text) {
  uint8_t len = strlen(text) + 1;
  lora_packet packet = { 0 };
  lora_msg msg = { 0 };

  memcpy(packet.src, &mac[3], 3);
  memset(packet.dst, 0xFF, 3);
  packet.type = TEXT;
  packet.payload = malloc(LORA_PACKET_HEADER_SIZE + len);

  msg.length = len;
  msg.msg = malloc(LORA_MSG_HEADER_SIZE + len);
  memcpy(msg.msg, text, len);

  uint8_t buf_len = LORA_PACKET_HEADER_SIZE + LORA_MSG_HEADER_SIZE + len;
  uint8_t *send_buf = malloc(buf_len);
  ESP_LOGI(TAG, "packet length: %d", buf_len);

  // set src, dst, length
  memcpy(send_buf, (uint8_t*)&packet, LORA_PACKET_HEADER_SIZE);
  memcpy((uint8_t*)(send_buf + LORA_PACKET_HEADER_SIZE), (void*)&msg, LORA_MSG_HEADER_SIZE);
  memcpy((uint8_t*)(send_buf + LORA_PACKET_HEADER_SIZE + LORA_MSG_HEADER_SIZE), (void*)msg.msg, len);

  ESP_LOGI(TAG, "src: [%02X:%02X:%02X]", packet.src[0], packet.src[1], packet.src[2]);
  ESP_LOGI(TAG, "dst: [%02X:%02X:%02X]", packet.dst[0], packet.dst[1], packet.dst[2]);

  lora32_send(lora, send_buf, buf_len);

  free(packet.payload);
  packet.payload = NULL;

  free(msg.msg);
  msg.msg = NULL;

  free(send_buf);
}

void app_main(void) {
  esp_efuse_mac_get_default((uint8_t*)&mac);

  ESP_LOGI(TAG, "MAC: [%02X:%02X:%02X:%02X:%02X:%02X]", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  lora.bandwidth = B250;
  lora.codingRate = DEFAULT_CR;
  lora.dio0 = CONFIG_LORA32_DIO0_PIN;
  lora.implicitHeader = false;
  lora.nss = CONFIG_LORA32_NSS_PIN;
  lora.reset = CONFIG_LORA32_RESET_PIN;
  lora.frequency = 866000000;
  lora.preamble = DEFAULT_PREAMBLE;
  lora.spreadingFactor = DEFAULT_SF;
  lora.receive = NULL;
  lora.useCRC = false;
  lora.fifoIdx = 0;
  lora.receive = &handle_lora_receive;
  lora.tx_done = &handle_lora_txdone;
  lora.cad_done = &handle_lora_caddone;
  //lora.cad_detected = &handle_lora_caddetected;

  lora32_init(&lora);

  xTaskCreate(console_task, "console", 4048, &lora, tskIDLE_PRIORITY + 3, NULL);

  send_message(&lora, "hi\0");
  double dr = lora32_calc_datarate(&lora);
  ESP_LOGI(TAG, "data rate: %fbps", dr);

  while(1) {
    vTaskDelay(100 / portTICK_PERIOD_MS);
  }
}