amikhalev
/
uas-ugv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

add oled support

ugv_io
Alex Mikhalev 6 years ago
parent
5cfd7a513f
commit
923bdbf7b8
9 changed files with 459 additions and 113 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      .gitignore
  2. 3
      .gitmodules
  3. 1
      components/u8g2
  4. 8
      main/CMakeLists.txt
  5. 23
      main/sx127x_driver/sx127x_driver.c
  6. 4
      main/sx127x_driver/sx127x_driver.h
  7. 272
      main/u8g2_esp32_hal.c
  8. 45
      main/u8g2_esp32_hal.h
  9. 215
      main/ugv_main.c

1
.gitignore vendored
Unescape View File

@ -1,4 +1,5 @@
/.vscode /.vscode
/sdkconfig /sdkconfig
/sdkconfig.old
/build /build
/cmake-build* /cmake-build*

3
.gitmodules vendored
Unescape View File

@ -0,0 +1,3 @@
[submodule "components/u8g2"]
path = components/u8g2
url = https://github.com/olikraus/u8g2.git

1
components/u8g2

@ -0,0 +1 @@
Subproject commit cd16a10d0ec85d6c6ddc3579a4e1456f08e10984

8
main/CMakeLists.txt
Unescape View File

@ -1,4 +1,8 @@
set(COMPONENT_SRCS "ugv_main.c" "sx127x_driver/sx127x_driver.c") set(COMPONENT_SRCS "ugv_main.c"
set(COMPONENT_ADD_INCLUDEDIRS "." "./sx127x_driver") "u8g2_esp32_hal.c"
"sx127x_driver/sx127x_driver.c")
set(COMPONENT_ADD_INCLUDEDIRS "."
"./sx127x_driver")
set(COMPONENT_REQUIRES "u8g2")
register_component() register_component()

23
main/sx127x_driver/sx127x_driver.c
Unescape View File

@ -1,6 +1,8 @@
#include "sx127x_driver.h" #include "sx127x_driver.h"
#include "esp_log.h" #include <string.h>
#include <freertos/task.h>
#include <esp_log.h>
const char *SX127X_TAG = "sx127x"; const char *SX127X_TAG = "sx127x";
@ -38,13 +40,21 @@ esp_err_t sx127x_init(sx127x_config_t *config, sx127x_t *handle)
{ {
esp_err_t ret; esp_err_t ret;
handle->rst_io_num = config->rst_io_num; memcpy(&handle->config, config, sizeof(sx127x_config_t));
handle->irq_io_num = config->irq_io_num;
ret = gpio_set_direction(handle->rst_io_num, GPIO_MODE_OUTPUT); ret = gpio_set_direction(config->rst_io_num, GPIO_MODE_OUTPUT);
SX127X_ERROR_CHECK(ret, "gpio_set_direction") SX127X_ERROR_CHECK(ret, "gpio_set_direction")
ret = gpio_set_direction(handle->irq_io_num, GPIO_MODE_OUTPUT); ret = gpio_set_direction(config->irq_io_num, GPIO_MODE_OUTPUT);
SX127X_ERROR_CHECK(ret, "gpio_set_direction") SX127X_ERROR_CHECK(ret, "gpio_set_direction")
gpio_set_level(config->cs_io_num, 1);
// perform reset
gpio_set_level(config->rst_io_num, 0);
vTaskDelay(pdMS_TO_TICKS(10));
gpio_set_level(config->rst_io_num, 1);
vTaskDelay(pdMS_TO_TICKS(10));
spi_bus_config_t bus_config = { spi_bus_config_t bus_config = {
.mosi_io_num = config->mosi_io_num, .mosi_io_num = config->mosi_io_num,
.miso_io_num = config->miso_io_num, .miso_io_num = config->miso_io_num,
@ -54,7 +64,6 @@ esp_err_t sx127x_init(sx127x_config_t *config, sx127x_t *handle)
.max_transfer_sz = SX127X_MAX_TRANSFER}; .max_transfer_sz = SX127X_MAX_TRANSFER};
ret = spi_bus_initialize(config->spi_host, &bus_config, 1); ret = spi_bus_initialize(config->spi_host, &bus_config, 1);
SX127X_ERROR_CHECK(ret, "spi_bus_initialize") SX127X_ERROR_CHECK(ret, "spi_bus_initialize")
handle->spi_host = config->spi_host;
spi_device_interface_config_t device_config = { spi_device_interface_config_t device_config = {
.command_bits = 0, .command_bits = 0,
@ -85,7 +94,7 @@ esp_err_t sx127x_free(sx127x_t *handle)
ret = spi_bus_remove_device(handle->device_handle); ret = spi_bus_remove_device(handle->device_handle);
SX127X_ERROR_CHECK(ret, "spi_bus_remove_device") SX127X_ERROR_CHECK(ret, "spi_bus_remove_device")
ret = spi_bus_free(handle->spi_host); ret = spi_bus_free(handle->config.spi_host);
SX127X_ERROR_CHECK(ret, "spi_bus_free") SX127X_ERROR_CHECK(ret, "spi_bus_free")
return ESP_OK; return ESP_OK;

4
main/sx127x_driver/sx127x_driver.h
Unescape View File

@ -31,10 +31,8 @@ typedef struct sx127x_config
typedef struct sx127x typedef struct sx127x
{ {
spi_host_device_t spi_host; sx127x_config_t config;
spi_device_handle_t device_handle; spi_device_handle_t device_handle;
gpio_num_t rst_io_num;
gpio_num_t irq_io_num;
} sx127x_t; } sx127x_t;
esp_err_t sx127x_init(sx127x_config_t *config, sx127x_t *handle); esp_err_t sx127x_init(sx127x_config_t *config, sx127x_t *handle);

272
main/u8g2_esp32_hal.c
Unescape View File

@ -0,0 +1,272 @@
#include <stdio.h>
#include <string.h>
#include "sdkconfig.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "u8g2_esp32_hal.h"
static const char *TAG = "u8g2_hal";
static const unsigned int I2C_TIMEOUT_MS = 1000;
static spi_device_handle_t handle_spi; // SPI handle.
static i2c_cmd_handle_t handle_i2c; // I2C handle.
static u8g2_esp32_hal_t u8g2_esp32_hal; // HAL state data.
#undef ESP_ERROR_CHECK
#define ESP_ERROR_CHECK(x) \
do \
{ \
esp_err_t rc = (x); \
if (rc != ESP_OK) \
{ \
ESP_LOGE("err", "esp_err_t = %d", rc); \
assert(0 && #x); \
} \
} while (0);
/*
* Initialze the ESP32 HAL.
*/
void u8g2_esp32_hal_init(u8g2_esp32_hal_t u8g2_esp32_hal_param)
{
u8g2_esp32_hal = u8g2_esp32_hal_param;
} // u8g2_esp32_hal_init
/*
* HAL callback function as prescribed by the U8G2 library. This callback is invoked
* to handle SPI communications.
*/
uint8_t u8g2_esp32_spi_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
ESP_LOGV(TAG, "spi_byte_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg, arg_int, arg_ptr);
switch (msg)
{
case U8X8_MSG_BYTE_SET_DC:
if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED)
{
gpio_set_level(u8g2_esp32_hal.dc, arg_int);
}
break;
case U8X8_MSG_BYTE_INIT:
{
if (u8g2_esp32_hal.clk == U8G2_ESP32_HAL_UNDEFINED ||
u8g2_esp32_hal.mosi == U8G2_ESP32_HAL_UNDEFINED ||
u8g2_esp32_hal.cs == U8G2_ESP32_HAL_UNDEFINED)
{
break;
}
spi_bus_config_t bus_config;
memset(&bus_config, 0, sizeof(spi_bus_config_t));
bus_config.sclk_io_num = u8g2_esp32_hal.clk; // CLK
bus_config.mosi_io_num = u8g2_esp32_hal.mosi; // MOSI
bus_config.miso_io_num = -1; // MISO
bus_config.quadwp_io_num = -1; // Not used
bus_config.quadhd_io_num = -1; // Not used
//ESP_LOGI(TAG, "... Initializing bus.");
ESP_ERROR_CHECK(spi_bus_initialize(HSPI_HOST, &bus_config, 1));
spi_device_interface_config_t dev_config;
dev_config.address_bits = 0;
dev_config.command_bits = 0;
dev_config.dummy_bits = 0;
dev_config.mode = 0;
dev_config.duty_cycle_pos = 0;
dev_config.cs_ena_posttrans = 0;
dev_config.cs_ena_pretrans = 0;
dev_config.clock_speed_hz = 10000;
dev_config.spics_io_num = u8g2_esp32_hal.cs;
dev_config.flags = 0;
dev_config.queue_size = 200;
dev_config.pre_cb = NULL;
dev_config.post_cb = NULL;
//ESP_LOGI(TAG, "... Adding device bus.");
ESP_ERROR_CHECK(spi_bus_add_device(HSPI_HOST, &dev_config, &handle_spi));
break;
}
case U8X8_MSG_BYTE_SEND:
{
spi_transaction_t trans_desc;
trans_desc.addr = 0;
trans_desc.cmd = 0;
trans_desc.flags = 0;
trans_desc.length = 8 * arg_int; // Number of bits NOT number of bytes.
trans_desc.rxlength = 0;
trans_desc.tx_buffer = arg_ptr;
trans_desc.rx_buffer = NULL;
//ESP_LOGI(TAG, "... Transmitting %d bytes.", arg_int);
ESP_ERROR_CHECK(spi_device_transmit(handle_spi, &trans_desc));
break;
}
}
return 0;
} // u8g2_esp32_spi_byte_cb
/*
* HAL callback function as prescribed by the U8G2 library. This callback is invoked
* to handle I2C communications.
*/
uint8_t u8g2_esp32_i2c_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
// ESP_LOGV(TAG, "i2c_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg, arg_int, arg_ptr);
switch (msg)
{
case U8X8_MSG_BYTE_SET_DC:
{
if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED)
{
gpio_set_level(u8g2_esp32_hal.dc, arg_int);
}
break;
}
case U8X8_MSG_BYTE_INIT:
{
if (u8g2_esp32_hal.sda == U8G2_ESP32_HAL_UNDEFINED ||
u8g2_esp32_hal.scl == U8G2_ESP32_HAL_UNDEFINED)
{
break;
}
i2c_config_t conf;
conf.mode = I2C_MODE_MASTER;
ESP_LOGD(TAG, "sda_io_num %d", u8g2_esp32_hal.sda);
conf.sda_io_num = u8g2_esp32_hal.sda;
conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
ESP_LOGD(TAG, "scl_io_num %d", u8g2_esp32_hal.scl);
conf.scl_io_num = u8g2_esp32_hal.scl;
conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
ESP_LOGD(TAG, "clk_speed %d", I2C_MASTER_FREQ_HZ);
conf.master.clk_speed = I2C_MASTER_FREQ_HZ;
ESP_LOGD(TAG, "i2c_param_config %d", conf.mode);
ESP_ERROR_CHECK(i2c_param_config(I2C_MASTER_NUM, &conf));
ESP_LOGD(TAG, "i2c_driver_install %d", I2C_MASTER_NUM);
ESP_ERROR_CHECK(i2c_driver_install(I2C_MASTER_NUM, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0));
break;
}
case U8X8_MSG_BYTE_SEND:
{
uint8_t *data_ptr = (uint8_t *)arg_ptr;
ESP_LOG_BUFFER_HEXDUMP(TAG, data_ptr, arg_int, ESP_LOG_VERBOSE);
while (arg_int > 0)
{
ESP_ERROR_CHECK(i2c_master_write_byte(handle_i2c, *data_ptr, ACK_CHECK_EN));
data_ptr++;
arg_int--;
}
break;
}
case U8X8_MSG_BYTE_START_TRANSFER:
{
uint8_t i2c_address = u8x8_GetI2CAddress(u8x8);
handle_i2c = i2c_cmd_link_create();
// ESP_LOGV(TAG, "Start I2C transfer to %02X.", i2c_address >> 1);
ESP_ERROR_CHECK(i2c_master_start(handle_i2c));
ESP_ERROR_CHECK(i2c_master_write_byte(handle_i2c, i2c_address | I2C_MASTER_WRITE, ACK_CHECK_EN));
break;
}
case U8X8_MSG_BYTE_END_TRANSFER:
{
// ESP_LOGV(TAG, "End I2C transfer.");
ESP_ERROR_CHECK(i2c_master_stop(handle_i2c));
ESP_ERROR_CHECK(i2c_master_cmd_begin(I2C_MASTER_NUM, handle_i2c, I2C_TIMEOUT_MS / portTICK_RATE_MS));
i2c_cmd_link_delete(handle_i2c);
break;
}
}
return 0;
} // u8g2_esp32_i2c_byte_cb
/*
* HAL callback function as prescribed by the U8G2 library. This callback is invoked
* to handle callbacks for GPIO and delay functions.
*/
uint8_t u8g2_esp32_gpio_and_delay_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
ESP_LOGV(TAG, "gpio_and_delay_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg, arg_int, arg_ptr);
switch (msg)
{
// Initialize the GPIO and DELAY HAL functions. If the pins for DC and RESET have been
// specified then we define those pins as GPIO outputs.
case U8X8_MSG_GPIO_AND_DELAY_INIT:
{
uint64_t bitmask = 0;
if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED)
{
bitmask = bitmask | (1ull << u8g2_esp32_hal.dc);
}
if (u8g2_esp32_hal.reset != U8G2_ESP32_HAL_UNDEFINED)
{
bitmask = bitmask | (1ull << u8g2_esp32_hal.reset);
}
if (u8g2_esp32_hal.cs != U8G2_ESP32_HAL_UNDEFINED)
{
bitmask = bitmask | (1ull << u8g2_esp32_hal.cs);
}
if (bitmask == 0)
{
break;
}
gpio_config_t gpioConfig;
gpioConfig.pin_bit_mask = bitmask;
gpioConfig.mode = GPIO_MODE_OUTPUT;
gpioConfig.pull_up_en = GPIO_PULLUP_DISABLE;
gpioConfig.pull_down_en = GPIO_PULLDOWN_ENABLE;
gpioConfig.intr_type = GPIO_INTR_DISABLE;
gpio_config(&gpioConfig);
break;
}
// Set the GPIO reset pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_RESET:
if (u8g2_esp32_hal.reset != U8G2_ESP32_HAL_UNDEFINED)
{
gpio_set_level(u8g2_esp32_hal.reset, arg_int);
}
break;
// Set the GPIO client select pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_CS:
if (u8g2_esp32_hal.cs != U8G2_ESP32_HAL_UNDEFINED)
{
gpio_set_level(u8g2_esp32_hal.cs, arg_int);
}
break;
// Set the Software I²C pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_I2C_CLOCK:
if (u8g2_esp32_hal.scl != U8G2_ESP32_HAL_UNDEFINED)
{
gpio_set_level(u8g2_esp32_hal.scl, arg_int);
// printf("%c",(arg_int==1?'C':'c'));
}
break;
// Set the Software I²C pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_I2C_DATA:
if (u8g2_esp32_hal.sda != U8G2_ESP32_HAL_UNDEFINED)
{
gpio_set_level(u8g2_esp32_hal.sda, arg_int);
// printf("%c",(arg_int==1?'D':'d'));
}
break;
// Delay for the number of milliseconds passed in through arg_int.
case U8X8_MSG_DELAY_MILLI:
vTaskDelay(arg_int / portTICK_PERIOD_MS);
break;
}
return 0;
} // u8g2_esp32_gpio_and_delay_cb

45
main/u8g2_esp32_hal.h
Unescape View File

@ -0,0 +1,45 @@
/*
* u8g2_esp32_hal.h
*
* Created on: Feb 12, 2017
* Author: kolban
*/
#ifndef U8G2_ESP32_HAL_H_
#define U8G2_ESP32_HAL_H_
#include "u8g2.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include "driver/i2c.h"
#define U8G2_ESP32_HAL_UNDEFINED (-1)
#define I2C_MASTER_NUM I2C_NUM_1 // I2C port number for master dev
#define I2C_MASTER_TX_BUF_DISABLE 0 // I2C master do not need buffer
#define I2C_MASTER_RX_BUF_DISABLE 0 // I2C master do not need buffer
#define I2C_MASTER_FREQ_HZ 50000 // I2C master clock frequency
#define ACK_CHECK_EN 0x1 // I2C master will check ack from slave
#define ACK_CHECK_DIS 0x0 // I2C master will not check ack from slave
typedef struct
{
gpio_num_t clk;
gpio_num_t mosi;
gpio_num_t sda; // data for I²C
gpio_num_t scl; // clock for I²C
gpio_num_t cs;
gpio_num_t reset;
gpio_num_t dc;
} u8g2_esp32_hal_t;
#define U8G2_ESP32_HAL_DEFAULT \
{ \
U8G2_ESP32_HAL_UNDEFINED, U8G2_ESP32_HAL_UNDEFINED, U8G2_ESP32_HAL_UNDEFINED, U8G2_ESP32_HAL_UNDEFINED, U8G2_ESP32_HAL_UNDEFINED, U8G2_ESP32_HAL_UNDEFINED, U8G2_ESP32_HAL_UNDEFINED \
}
void u8g2_esp32_hal_init(u8g2_esp32_hal_t u8g2_esp32_hal_param);
uint8_t u8g2_esp32_spi_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr);
uint8_t u8g2_esp32_i2c_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr);
uint8_t u8g2_esp32_gpio_and_delay_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr);
#endif /* U8G2_ESP32_HAL_H_ */

215
main/ugv_main.c
Unescape View File

@ -1,15 +1,22 @@
#include <Arduino.h> #define U8X8_USE_PINS
#include <U8g2lib.h> // #include <Arduino.h>
#include <SPI.h> #include <u8g2.h>
#include <LoRa.h> // #include <SPI.h>
#include <FreeRTOS.h> // #include <LoRa.h>
#include <freertos/FreeRTOS.h>
#include <freertos/queue.h>
#include <esp_log.h> #include <esp_log.h>
#include <driver/uart.h>
#include <string.h>
#include "u8g2_esp32_hal.h"
const char *TAG = "uas-ugv"; const char *TAG = "uas-ugv";
class U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, 16, 15, 4); // U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, 16, 15, 4);
u8g2_t u8g2;
class SPIClass lora_spi(VSPI); // SPIClass lora_spi(VSPI);
#define LORA_SCK 5 #define LORA_SCK 5
#define LORA_MISO 19 #define LORA_MISO 19
@ -37,87 +44,84 @@ uint16_t packet_num;
void loraTask(void *params); void loraTask(void *params);
void loraOnReceive(int packetSize); void loraOnReceive(int packetSize);
xTaskHandle lora_task_hndl; TaskHandle_t lora_task_hndl;
xQueueHandle lora_packet_recv_queue; // packets recieved (type Packet) QueueHandle_t lora_packet_recv_queue; // packets recieved (type Packet)
xQueueHandle lora_packet_isr_queue; // packet lengths from the recieve isr (type int) QueueHandle_t lora_packet_isr_queue; // packet lengths from the recieve isr (type int)
Packet packet; struct Packet packet;
void setup_serial(void)
{
const uart_port_t uart_num = UART_NUM_2;
uart_config_t uart_config = {
.baud_rate = 115200,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_CTS_RTS,
.rx_flow_ctrl_thresh = 122,
};
// Configure UART parameters
ESP_ERROR_CHECK(uart_param_config(uart_num, &uart_config));
}
void setup_oled(void)
{
u8g2_esp32_hal_t u8g2_hal_config = {
.scl = 15,
.sda = 4,
.reset = 16,
};
u8g2_esp32_hal_init(u8g2_hal_config);
u8g2_Setup_ssd1306_i2c_128x64_noname_f(&u8g2,
U8G2_R0,
u8g2_esp32_i2c_byte_cb,
u8g2_esp32_gpio_and_delay_cb);
u8g2_InitDisplay(&u8g2);
u8g2_ClearDisplay(&u8g2);
u8g2_SetPowerSave(&u8g2, false);
}
void setup(void) void setup(void)
{ {
Serial.begin(115200); setup_serial();
while (!Serial)
{
delay(10);
}
ESP_LOGI(TAG, "setup"); ESP_LOGI(TAG, "setup");
Serial.println("setup");
lora_packet_recv_queue = xQueueCreate(4, sizeof(Packet)); setup_oled();
lora_packet_recv_queue = xQueueCreate(4, sizeof(struct Packet));
lora_packet_isr_queue = xQueueCreate(4, sizeof(int)); lora_packet_isr_queue = xQueueCreate(4, sizeof(int));
configASSERT(lora_packet_recv_queue != 0); configASSERT(lora_packet_recv_queue != 0);
configASSERT(lora_packet_isr_queue != 0); configASSERT(lora_packet_isr_queue != 0);
lora_spi.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS); // lora_spi.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
LoRa.setSPI(lora_spi); // LoRa.setSPI(lora_spi);
LoRa.setPins(LORA_CS, LORA_RST, LORA_IRQ); // LoRa.setPins(LORA_CS, LORA_RST, LORA_IRQ);
int res = LoRa.begin(LORA_FREQ); // 433MHz // int res = LoRa.begin(LORA_FREQ); // 433MHz
if (!res) // if (!res)
{ // {
Serial.println("LoRa init failed"); ESP_LOGE(TAG, "LoRa init failed");
} // }
LoRa.setTxPower(17); // LoRa.setTxPower(17);
LoRa.setSpreadingFactor(11); // LoRa.setSpreadingFactor(11);
LoRa.setSignalBandwidth(125E3); // LoRa.setSignalBandwidth(125E3);
LoRa.setSyncWord(0x34); // LoRa.setSyncWord(0x34);
LoRa.enableCrc(); // LoRa.enableCrc();
LoRa.onReceive(loraOnReceive); // LoRa.onReceive(loraOnReceive);
LoRa.receive(0); // LoRa.receive(0);
// LoRa.dumpRegisters(Serial); // LoRa.dumpRegisters(Serial);
u8g2.beginSimple(); /* Do not clear the display, wake is not required */
u8g2.clearDisplay();
u8g2.setPowerSave(false);
packet_num = 0; packet_num = 0;
xTaskCreate(loraTask, "loraTask", 1024 * 10, NULL, 2, &lora_task_hndl); xTaskCreate(loraTask, "loraTask", 1024 * 10, NULL, 2, &lora_task_hndl);
memset(&packet, 0, sizeof(Packet)); memset(&packet, 0, sizeof(struct Packet));
} }
#define XO 10 #define XO 10
void drawLogo(void)
{
u8g2.setFontMode(1); // Transparent
u8g2.setFontDirection(0);
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(0 + XO, 30, "U");
u8g2.setFontDirection(1);
u8g2.setFont(u8g2_font_inb30_mn);
u8g2.drawStr(21 + XO, 8, "8");
u8g2.setFontDirection(0);
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(51 + XO, 30, "g");
u8g2.drawStr(67 + XO, 30, "\xb2");
u8g2.drawHLine(2 + XO, 35, 47);
u8g2.drawHLine(3 + XO, 36, 47);
u8g2.drawVLine(45 + XO, 32, 12);
u8g2.drawVLine(46 + XO, 33, 12);
}
void drawURL(void)
{
u8g2.setFont(u8g2_font_6x12_tr);
u8g2.drawStr(1 + XO, 54, "github.com/olikraus/u8g2");
}
void loraOnReceive(int packetSize) void loraOnReceive(int packetSize)
{ {
if (packetSize == 0) if (packetSize == 0)
@ -134,7 +138,7 @@ void loraTask(void *params)
TickType_t send_period = pdMS_TO_TICKS(2000); TickType_t send_period = pdMS_TO_TICKS(2000);
TickType_t current_time = xTaskGetTickCount(); TickType_t current_time = xTaskGetTickCount();
TickType_t next_send = current_time + send_period; TickType_t next_send = current_time + send_period;
Packet recvd_packet; struct Packet recvd_packet;
while (true) while (true)
{ {
TickType_t delay_ticks = next_send - current_time; TickType_t delay_ticks = next_send - current_time;
@ -142,25 +146,26 @@ void loraTask(void *params)
if (didReceive) if (didReceive)
{ {
int packetSize = (packet_len > LORA_BUF_LEN - 1) ? (LORA_BUF_LEN - 1) : (packet_len); int packetSize = (packet_len > LORA_BUF_LEN - 1) ? (LORA_BUF_LEN - 1) : (packet_len);
LoRa.setTimeout(50); // LoRa.setTimeout(50);
LoRa.readBytes(recvd_packet.buffer, packetSize); // LoRa.readBytes(recvd_packet.buffer, packetSize);
recvd_packet.buffer_len = packetSize; recvd_packet.buffer_len = packetSize;
recvd_packet.buffer[packetSize - 1] = '\0'; recvd_packet.buffer[packetSize - 1] = '\0';
recvd_packet.rssi = LoRa.packetRssi(); // recvd_packet.rssi = LoRa.packetRssi();
recvd_packet.snr = LoRa.packetSnr(); // recvd_packet.snr = LoRa.packetSnr();
xQueueSend(lora_packet_recv_queue, &recvd_packet, 10); xQueueSend(lora_packet_recv_queue, &recvd_packet, 10);
} }
current_time = xTaskGetTickCount(); current_time = xTaskGetTickCount();
if (current_time >= next_send) { if (current_time >= next_send)
{
sprintf(outBuf, "hello world %d", packet_num); sprintf(outBuf, "hello world %d", packet_num);
packet_num++; packet_num++;
LoRa.beginPacket(); // LoRa.beginPacket();
size_t written = LoRa.write((uint8_t *)outBuf, outBufLen - 1); // size_t written = LoRa.write((uint8_t *)outBuf, outBufLen - 1);
LoRa.endPacket(); // LoRa.endPacket();
Serial.printf("lora wrote %d bytes\n", written); // ESP_LOGI(TAG, "lora wrote %d bytes\n", written);
LoRa.receive(0); // go back to receive mode // LoRa.receive(0); // go back to receive mode
current_time = xTaskGetTickCount(); current_time = xTaskGetTickCount();
next_send = current_time + send_period; next_send = current_time + send_period;
} }
@ -169,36 +174,44 @@ void loraTask(void *params)
void loop(void) void loop(void)
{ {
Serial.println("loop"); ESP_LOGI(TAG, "loop");
u8g2.firstPage(); u8g2_FirstPage(&u8g2);
bool recieved_packet = xQueueReceive(lora_packet_recv_queue, &packet, 10); bool recieved_packet = xQueueReceive(lora_packet_recv_queue, &packet, 10);
do do
{ {
// drawLogo(); u8g2_DrawRFrame(&u8g2, 0, 0, OLED_W, OLED_H, 4);
// drawURL();
u8g2.drawRFrame(0, 0, OLED_W, OLED_H, 4);
uint32_t free_heap = xPortGetFreeHeapSize(); uint32_t free_heap = xPortGetFreeHeapSize();
u8g2.setFont(u8g2_font_4x6_mf); u8g2_SetFont(&u8g2, u8g2_font_4x6_mf);
u8g2.drawStr(4, 8, "Hello World!"); u8g2_DrawStr(&u8g2, 4, 8, "Hello World!");
u8g2.setCursor(4, 8 + 8); char buf[40];
u8g2.printf("free heap: %d", free_heap); snprintf(buf, 40, "free heap: %d", free_heap);
u8g2_DrawStr(&u8g2, 4, 8 + 8, buf);
if (packet.buffer_len) if (packet.buffer_len)
{ {
Serial.printf("lora received packet (len %d, rssi: %d, snr: %f): %s\n", ESP_LOGI(TAG, "lora received packet (len %d, rssi: %d, snr: %f): %s\n",
packet.buffer_len, packet.rssi, packet.snr, packet.buffer); packet.buffer_len, packet.rssi, packet.snr, packet.buffer);
u8g2.setFont(u8g2_font_4x6_mf); u8g2_SetFont(&u8g2, u8g2_font_4x6_mf);
u8g2.setCursor(4, 8 + 8 + 8); snprintf(buf, 40, "lora pkt(rssi: %d, snr: %f)", packet.rssi, packet.snr);
u8g2.printf("lora pkt(rssi: %d, snr: %f)", packet.rssi, packet.snr); u8g2_DrawStr(&u8g2, 4, 8 + 8 + 8, buf);
u8g2.setCursor(4, 8 + 8 + 8 + 8); snprintf(buf, 40, "%s", packet.buffer);
u8g2.printf("%s", packet.buffer); u8g2_DrawStr(&u8g2, 4, 8 + 8 + 8 + 8, buf);
} }
} while (u8g2_NextPage(&u8g2));
vTaskDelay(pdMS_TO_TICKS(1000));
}
void loopTask(void *pvUser)
{
setup();
while (1)
{
loop();
}
}
/* draw a frame around the picture */ void app_main()
// u8g2.drawFrame(0,0,OLED_W,OLED_H); {
// u8g2.drawFrame(1,1,384-2,240-2); xTaskCreatePinnedToCore(loopTask, "loopTask", 8192, NULL, 1, NULL, 1);
} while (u8g2.nextPage());
delay(1000);
} }

Write Preview
Loading…
Cancel
Save