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

use handles for sx127x

Browse Source
This commit is contained in:
Alex Mikhalev 2018-12-31 13:13:05 -07:00
parent 2f008797f0
commit 2cffb1c80b
6 changed files with 172 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
components/sx127x_driver/sx127x_driver.c
View File

@ -17,45 +17,45 @@ sx127x_config_t sx127x_config_default() {
return config; return config;
} }
static esp_err_t sx127x_write_config(sx127x_t *handle) { static esp_err_t sx127x_write_config(sx127x_t *hndl) {
esp_err_t ret; esp_err_t ret;
const sx127x_config_t *config = &handle->config; const sx127x_config_t *config = &hndl->config;
ret = sx127x_sleep(handle); ret = sx127x_sleep(hndl);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_set_frequency(handle, config->frequency); ret = sx127x_set_frequency(hndl, config->frequency);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_write_register(handle, REG_FIFO_TX_BASE_ADDR, 0); ret = sx127x_write_register(hndl, REG_FIFO_TX_BASE_ADDR, 0);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
sx127x_write_register(handle, REG_FIFO_RX_BASE_ADDR, 0); sx127x_write_register(hndl, REG_FIFO_RX_BASE_ADDR, 0);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
uint8_t reg_lna; uint8_t reg_lna;
ret = sx127x_read_register(handle, REG_LNA, &reg_lna); ret = sx127x_read_register(hndl, REG_LNA, &reg_lna);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
reg_lna |= 0x03; // set LNA boost reg_lna |= 0x03; // set LNA boost
ret = sx127x_write_register(handle, REG_LNA, reg_lna); ret = sx127x_write_register(hndl, REG_LNA, reg_lna);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
// set auto AGC // set auto AGC
ret = sx127x_write_register(handle, REG_MODEM_CONFIG_3, CONFIG3_AUTO_AGC); ret = sx127x_write_register(hndl, REG_MODEM_CONFIG_3, CONFIG3_AUTO_AGC);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_set_tx_power(handle, config->tx_power, true); ret = sx127x_set_tx_power(hndl, config->tx_power, true);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_set_spreading_factor(handle, config->spreading_factor); ret = sx127x_set_spreading_factor(hndl, config->spreading_factor);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_set_sync_word(handle, config->sync_word); ret = sx127x_set_sync_word(hndl, config->sync_word);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_set_crc(handle, config->crc); ret = sx127x_set_crc(hndl, config->crc);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
ret = sx127x_standby(handle); ret = sx127x_standby(hndl);
ESP_ERROR_CHECK(ret); ESP_ERROR_CHECK(ret);
return ESP_OK; return ESP_OK;
@ -63,12 +63,12 @@ static esp_err_t sx127x_write_config(sx127x_t *handle) {
esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_t **handle_ptr) { esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_t **handle_ptr) {
esp_err_t ret; esp_err_t ret;
sx127x_t *handle = malloc(sizeof(sx127x_t)); sx127x_t *hndl = malloc(sizeof(sx127x_t));
SX127X_CHECK(handle != NULL, "malloc error", ESP_ERR_NO_MEM); SX127X_CHECK(hndl != NULL, "malloc error", ESP_ERR_NO_MEM);
handle->task_handle = NULL; hndl->task_handle = NULL;
handle->task_state = SX127X_TASK_STOPPED; hndl->task_state = SX127X_TASK_STOPPED;
memcpy(&handle->config, config, sizeof(sx127x_config_t)); memcpy(&hndl->config, config, sizeof(sx127x_config_t));
ret = gpio_set_direction(config->rst_io_num, GPIO_MODE_OUTPUT); ret = gpio_set_direction(config->rst_io_num, GPIO_MODE_OUTPUT);
SX127X_ERROR_CHECK2(ret, gpio_set_direction) SX127X_ERROR_CHECK2(ret, gpio_set_direction)
@ -108,46 +108,46 @@ esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_t **handle_ptr) {
.post_cb = NULL, .post_cb = NULL,
}; };
ret = spi_bus_add_device(config->spi_host, &device_config, ret = spi_bus_add_device(config->spi_host, &device_config,
&handle->device_handle); &hndl->device_handle);
SX127X_ERROR_CHECK2(ret, spi_bus_add_device) SX127X_ERROR_CHECK2(ret, spi_bus_add_device)
// read version and check that it is compatible // read version and check that it is compatible
uint8_t version; uint8_t version;
ret = sx127x_read_register(handle, REG_VERSION, &version); ret = sx127x_read_register(hndl, REG_VERSION, &version);
SX127X_ERROR_CHECK2(ret, sx127x_read_register); SX127X_ERROR_CHECK2(ret, sx127x_read_register);
SX127X_CHECK(version == 0x12, "unsupported version %#x", SX127X_CHECK(version == 0x12, "unsupported version %#x",
ESP_ERR_INVALID_VERSION, version); ESP_ERR_INVALID_VERSION, version);
ret = sx127x_write_config(handle); ret = sx127x_write_config(hndl);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
*handle_ptr = handle; *handle_ptr = hndl;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_free(sx127x_t *handle) { esp_err_t sx127x_free(sx127x_t *hndl) {
esp_err_t ret; esp_err_t ret;
if (handle->task_handle) { if (hndl->task_handle) {
ret = sx127x_stop(handle); ret = sx127x_stop(hndl);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
} }
ret = spi_bus_remove_device(handle->device_handle); ret = spi_bus_remove_device(hndl->device_handle);
SX127X_ERROR_CHECK2(ret, spi_bus_remove_device) SX127X_ERROR_CHECK2(ret, spi_bus_remove_device)
ret = spi_bus_free(handle->config.spi_host); ret = spi_bus_free(hndl->config.spi_host);
SX127X_ERROR_CHECK2(ret, spi_bus_free) SX127X_ERROR_CHECK2(ret, spi_bus_free)
free(handle); free(hndl);
return ESP_OK; return ESP_OK;
} }
void IRAM_ATTR sx127x_isr(void *arg) { void IRAM_ATTR sx127x_isr(void *arg) {
sx127x_t * handle = (sx127x_t *)arg; sx127x_t * hndl = (sx127x_t *)arg;
BaseType_t hpTaskWoken; BaseType_t hpTaskWoken;
xSemaphoreGiveFromISR(handle->intr_semaphore, &hpTaskWoken); xSemaphoreGiveFromISR(hndl->intr_semaphore, &hpTaskWoken);
if (hpTaskWoken) { if (hpTaskWoken) {
portYIELD_FROM_ISR(); portYIELD_FROM_ISR();
} }
@ -159,11 +159,11 @@ void IRAM_ATTR sx127x_isr(void *arg) {
goto error; \ goto error; \
} }
static void sx127x_do_tx(sx127x_t *handle, sx127x_packet_t *packet) { static void sx127x_do_tx(sx127x_t *hndl, sx127x_packet_t *packet) {
esp_err_t ret; esp_err_t ret;
uint8_t op_mode, irq_flags, config_2; uint8_t op_mode, irq_flags, config_2;
while (handle->task_state == SX127X_TASK_RUNNING) { while (hndl->task_state == SX127X_TASK_RUNNING) {
_TX_CHECK(sx127x_read_register(handle, REG_OP_MODE, &op_mode)); _TX_CHECK(sx127x_read_register(hndl, REG_OP_MODE, &op_mode));
uint8_t mode = op_mode & SX127X_MODE; uint8_t mode = op_mode & SX127X_MODE;
if (mode != SX127X_MODE_TX && mode != SX127X_MODE_FS_TX) { if (mode != SX127X_MODE_TX && mode != SX127X_MODE_FS_TX) {
break; break;
@ -171,41 +171,41 @@ static void sx127x_do_tx(sx127x_t *handle, sx127x_packet_t *packet) {
vTaskDelay(1); // wait for finish transmitting vTaskDelay(1); // wait for finish transmitting
} }
_TX_CHECK(sx127x_standby(handle)); _TX_CHECK(sx127x_standby(hndl));
_TX_CHECK(sx127x_read_register(handle, REG_IRQ_FLAGS, &irq_flags)); _TX_CHECK(sx127x_read_register(hndl, REG_IRQ_FLAGS, &irq_flags));
if (irq_flags & IRQ_TX_DONE_MASK) { if (irq_flags & IRQ_TX_DONE_MASK) {
// clear tx done bit // clear tx done bit
_TX_CHECK(sx127x_write_register(handle, REG_IRQ_FLAGS, IRQ_TX_DONE_MASK)); _TX_CHECK(sx127x_write_register(hndl, REG_IRQ_FLAGS, IRQ_TX_DONE_MASK));
} }
_TX_CHECK(sx127x_read_register(handle, REG_MODEM_CONFIG_2, &config_2)); _TX_CHECK(sx127x_read_register(hndl, REG_MODEM_CONFIG_2, &config_2));
config_2 &= ~0x01; // set explicit header mode TODO: implicit header? config_2 &= ~0x01; // set explicit header mode TODO: implicit header?
_TX_CHECK(sx127x_write_register(handle, REG_MODEM_CONFIG_2, config_2)); _TX_CHECK(sx127x_write_register(hndl, REG_MODEM_CONFIG_2, config_2));
_TX_CHECK(sx127x_write_register(handle, REG_FIFO_ADDR_PTR, 0)); _TX_CHECK(sx127x_write_register(hndl, REG_FIFO_ADDR_PTR, 0));
_TX_CHECK(sx127x_write_register(handle, REG_PAYLOAD_LENGTH, 0)); _TX_CHECK(sx127x_write_register(hndl, REG_PAYLOAD_LENGTH, 0));
_TX_CHECK(sx127x_write_fifo(handle, packet->data, packet->data_len)); _TX_CHECK(sx127x_write_fifo(hndl, packet->data, packet->data_len));
_TX_CHECK( _TX_CHECK(
sx127x_write_register(handle, REG_PAYLOAD_LENGTH, packet->data_len)); sx127x_write_register(hndl, REG_PAYLOAD_LENGTH, packet->data_len));
_TX_CHECK(sx127x_write_register(handle, REG_OP_MODE, _TX_CHECK(sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_FS_TX)); SX127X_LONG_RANGE | SX127X_MODE_FS_TX));
vTaskDelay(pdMS_TO_TICKS(1)); vTaskDelay(pdMS_TO_TICKS(1));
_TX_CHECK(sx127x_write_register(handle, REG_OP_MODE, _TX_CHECK(sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_TX)); SX127X_LONG_RANGE | SX127X_MODE_TX));
// wait for transmission to finish // wait for transmission to finish
while (true) { while (true) {
_TX_CHECK(sx127x_read_register(handle, REG_IRQ_FLAGS, &irq_flags)); _TX_CHECK(sx127x_read_register(hndl, REG_IRQ_FLAGS, &irq_flags));
if (irq_flags & IRQ_TX_DONE_MASK) { // if the transmission is done if (irq_flags & IRQ_TX_DONE_MASK) { // if the transmission is done
break; break;
} }
vTaskDelay(1); vTaskDelay(1);
} }
// clear tx done bit // clear tx done bit
_TX_CHECK(sx127x_write_register(handle, REG_IRQ_FLAGS, IRQ_TX_DONE_MASK)); _TX_CHECK(sx127x_write_register(hndl, REG_IRQ_FLAGS, IRQ_TX_DONE_MASK));
error: error:
if (ret != ESP_OK) { if (ret != ESP_OK) {
@ -213,19 +213,19 @@ error:
ESP_LOGE(SX127X_TAG, "tx error: %s (%d)", error_name, ret); ESP_LOGE(SX127X_TAG, "tx error: %s (%d)", error_name, ret);
} }
// go back to rx mode // go back to rx mode
sx127x_write_register(handle, REG_OP_MODE, sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_RX_CONT); SX127X_LONG_RANGE | SX127X_MODE_RX_CONT);
} }
static void sx127x_do_rx(sx127x_t *handle) { static void sx127x_do_rx(sx127x_t *hndl) {
uint8_t irq_flags, packet_len; uint8_t irq_flags, packet_len;
sx127x_rx_packet_t packet; sx127x_rx_packet_t packet;
esp_err_t ret; esp_err_t ret;
BaseType_t pdRet; BaseType_t pdRet;
_TX_CHECK(sx127x_read_register(handle, REG_IRQ_FLAGS, &irq_flags)); _TX_CHECK(sx127x_read_register(hndl, REG_IRQ_FLAGS, &irq_flags));
// clear irq flags // clear irq flags
_TX_CHECK(sx127x_write_register(handle, REG_IRQ_FLAGS, irq_flags)); _TX_CHECK(sx127x_write_register(hndl, REG_IRQ_FLAGS, irq_flags));
if (irq_flags & IRQ_PAYLOAD_CRC_ERROR_MASK) { if (irq_flags & IRQ_PAYLOAD_CRC_ERROR_MASK) {
ESP_LOGW(SX127X_TAG, "rx crc error"); ESP_LOGW(SX127X_TAG, "rx crc error");
@ -236,12 +236,12 @@ static void sx127x_do_rx(sx127x_t *handle) {
goto error; goto error;
} }
sx127x_write_register(handle, REG_OP_MODE, sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_STDBY); SX127X_LONG_RANGE | SX127X_MODE_STDBY);
// TODO: implicit header receive? // TODO: implicit header receive?
_TX_CHECK(sx127x_read_register(handle, REG_RX_NB_BYTES, &packet_len)); _TX_CHECK(sx127x_read_register(hndl, REG_RX_NB_BYTES, &packet_len));
_TX_CHECK(sx127x_write_register(handle, REG_FIFO_ADDR_PTR, _TX_CHECK(sx127x_write_register(hndl, REG_FIFO_ADDR_PTR,
REG_FIFO_RX_CURRENT_ADDR)); REG_FIFO_RX_CURRENT_ADDR));
packet.data_len = packet_len; packet.data_len = packet_len;
@ -251,12 +251,12 @@ static void sx127x_do_rx(sx127x_t *handle) {
ESP_LOGE(SX127X_TAG, "malloc error"); ESP_LOGE(SX127X_TAG, "malloc error");
goto error; goto error;
} }
_TX_CHECK(sx127x_read_fifo(handle, packet.data, packet.data_len)); _TX_CHECK(sx127x_read_fifo(hndl, packet.data, packet.data_len));
sx127x_read_pkt_rssi(handle, &packet.rssi); sx127x_read_pkt_rssi(hndl, &packet.rssi);
sx127x_read_pkt_snr(handle, &packet.snr); sx127x_read_pkt_snr(hndl, &packet.snr);
pdRet = xQueueSend(handle->rx_packet_queue, &packet, 0); pdRet = xQueueSend(hndl->rx_packet_queue, &packet, 0);
if (pdRet != pdTRUE) { if (pdRet != pdTRUE) {
ESP_LOGE(SX127X_TAG, "rx queue full"); ESP_LOGE(SX127X_TAG, "rx queue full");
free(packet.data); free(packet.data);
@ -268,73 +268,73 @@ error:
const char *error_name = esp_err_to_name(ret); const char *error_name = esp_err_to_name(ret);
ESP_LOGE(SX127X_TAG, "rx error: %s (%d)", error_name, ret); ESP_LOGE(SX127X_TAG, "rx error: %s (%d)", error_name, ret);
} }
sx127x_write_register(handle, REG_FIFO_ADDR_PTR, 0); sx127x_write_register(hndl, REG_FIFO_ADDR_PTR, 0);
// go back to rx mode // go back to rx mode
sx127x_write_register(handle, REG_OP_MODE, sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_RX_CONT); SX127X_LONG_RANGE | SX127X_MODE_RX_CONT);
} }
void sx127x_task(void *arg) { void sx127x_task(void *arg) {
sx127x_t * handle = (sx127x_t *)arg; sx127x_t * hndl = (sx127x_t *)arg;
TickType_t delay_time = portMAX_DELAY; TickType_t delay_time = portMAX_DELAY;
QueueSetHandle_t qSet = xQueueCreateSet(8); QueueSetHandle_t qSet = xQueueCreateSet(8);
xQueueAddToSet(handle->intr_semaphore, qSet); xQueueAddToSet(hndl->intr_semaphore, qSet);
xQueueAddToSet(handle->tx_packet_queue, qSet); xQueueAddToSet(hndl->tx_packet_queue, qSet);
sx127x_packet_t packet; sx127x_packet_t packet;
// be in rx mode by default // be in rx mode by default
sx127x_write_register(handle, REG_OP_MODE, sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_RX_CONT); SX127X_LONG_RANGE | SX127X_MODE_RX_CONT);
while (handle->task_state == SX127X_TASK_RUNNING) { while (hndl->task_state == SX127X_TASK_RUNNING) {
QueueSetMemberHandle_t queue = xQueueSelectFromSet(qSet, delay_time); QueueSetMemberHandle_t queue = xQueueSelectFromSet(qSet, delay_time);
if (queue == handle->intr_semaphore) { if (queue == hndl->intr_semaphore) {
BaseType_t didRecv = xSemaphoreTake(handle->intr_semaphore, 0); BaseType_t didRecv = xSemaphoreTake(hndl->intr_semaphore, 0);
if (didRecv) { if (didRecv) {
ESP_LOGV(SX127X_TAG, "recv from isr"); ESP_LOGV(SX127X_TAG, "recv from isr");
sx127x_do_rx(handle); sx127x_do_rx(hndl);
} }
} else if (queue == handle->tx_packet_queue) { } else if (queue == hndl->tx_packet_queue) {
BaseType_t didRecv = xQueueReceive(handle->tx_packet_queue, &packet, 0); BaseType_t didRecv = xQueueReceive(hndl->tx_packet_queue, &packet, 0);
if (didRecv) { if (didRecv) {
ESP_LOGV(SX127X_TAG, "tx packet: %.*s", packet.data_len, packet.data); ESP_LOGV(SX127X_TAG, "tx packet: %.*s", packet.data_len, packet.data);
sx127x_do_tx(handle, &packet); sx127x_do_tx(hndl, &packet);
free(packet.data); free(packet.data);
} }
} }
} }
ESP_LOGI(SX127X_TAG, "sx127x_task exiting"); ESP_LOGI(SX127X_TAG, "sx127x_task exiting");
handle->task_state = SX127X_TASK_STOPPED; hndl->task_state = SX127X_TASK_STOPPED;
vTaskDelete(NULL); // must delete own task vTaskDelete(NULL); // must delete own task
} }
esp_err_t sx127x_start(sx127x_t *handle) { esp_err_t sx127x_start(sx127x_t *hndl) {
esp_err_t ret; esp_err_t ret;
SX127X_CHECK(handle->task_handle == NULL, "task already running", SX127X_CHECK(hndl->task_handle == NULL, "task already running",
ESP_ERR_INVALID_STATE); ESP_ERR_INVALID_STATE);
handle->intr_semaphore = xSemaphoreCreateBinary(); hndl->intr_semaphore = xSemaphoreCreateBinary();
handle->tx_packet_queue = xQueueCreate(TX_QUEUE_LEN, sizeof(sx127x_packet_t)); hndl->tx_packet_queue = xQueueCreate(TX_QUEUE_LEN, sizeof(sx127x_packet_t));
handle->rx_packet_queue = hndl->rx_packet_queue =
xQueueCreate(RX_QUEUE_LEN, sizeof(sx127x_rx_packet_t)); xQueueCreate(RX_QUEUE_LEN, sizeof(sx127x_rx_packet_t));
handle->task_state = SX127X_TASK_RUNNING; hndl->task_state = SX127X_TASK_RUNNING;
BaseType_t pdRet = BaseType_t pdRet =
xTaskCreate(sx127x_task, "sx127x_task", TASK_STACK_SIZE, (void *)handle, xTaskCreate(sx127x_task, "sx127x_task", TASK_STACK_SIZE, (void *)hndl,
TASK_PRIORITY, &handle->task_handle); TASK_PRIORITY, &hndl->task_handle);
SX127X_CHECK(pdRet == pdPASS, "failed to create task", ESP_FAIL); SX127X_CHECK(pdRet == pdPASS, "failed to create task", ESP_FAIL);
ret = sx127x_write_register(handle, REG_DIO_MAPPING_1, 0x00); ret = sx127x_write_register(hndl, REG_DIO_MAPPING_1, 0x00);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
gpio_config_t irq_io_config; gpio_config_t irq_io_config;
irq_io_config.intr_type = GPIO_INTR_POSEDGE; irq_io_config.intr_type = GPIO_INTR_POSEDGE;
irq_io_config.mode = GPIO_MODE_INPUT; irq_io_config.mode = GPIO_MODE_INPUT;
irq_io_config.pin_bit_mask = (1ULL << handle->config.irq_io_num); irq_io_config.pin_bit_mask = (1ULL << hndl->config.irq_io_num);
irq_io_config.pull_down_en = 0; irq_io_config.pull_down_en = 0;
irq_io_config.pull_up_en = 0; irq_io_config.pull_up_en = 0;
ret = gpio_config(&irq_io_config); ret = gpio_config(&irq_io_config);
@ -342,36 +342,36 @@ esp_err_t sx127x_start(sx127x_t *handle) {
ret = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL1); ret = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL1);
SX127X_ERROR_CHECK2(ret, gpio_install_isr_service); SX127X_ERROR_CHECK2(ret, gpio_install_isr_service);
ret = gpio_isr_handler_add(handle->config.irq_io_num, sx127x_isr, ret = gpio_isr_handler_add(hndl->config.irq_io_num, sx127x_isr,
(void *)handle); (void *)hndl);
SX127X_ERROR_CHECK2(ret, gpio_isr_handler_add); SX127X_ERROR_CHECK2(ret, gpio_isr_handler_add);
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_stop(sx127x_t *handle) { esp_err_t sx127x_stop(sx127x_t *hndl) {
esp_err_t ret; esp_err_t ret;
SX127X_CHECK(handle->task_handle != NULL, "task has not been started", SX127X_CHECK(hndl->task_handle != NULL, "task has not been started",
ESP_ERR_INVALID_STATE); ESP_ERR_INVALID_STATE);
handle->task_state = SX127X_TASK_STOPPING; hndl->task_state = SX127X_TASK_STOPPING;
xTaskNotifyGive(handle->task_handle); xTaskNotifyGive(hndl->task_handle);
ret = gpio_isr_handler_remove(handle->config.irq_io_num); ret = gpio_isr_handler_remove(hndl->config.irq_io_num);
SX127X_ERROR_CHECK2(ret, gpio_isr_handler_remove); SX127X_ERROR_CHECK2(ret, gpio_isr_handler_remove);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
while (handle->task_state != SX127X_TASK_STOPPED) { while (hndl->task_state != SX127X_TASK_STOPPED) {
vTaskDelay(10); vTaskDelay(10);
} }
handle->task_handle = NULL; hndl->task_handle = NULL;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data, esp_err_t sx127x_send_packet(sx127x_t *hndl, const char *data,
size_t data_len, TickType_t ticks_to_wait) { size_t data_len, TickType_t ticks_to_wait) {
SX127X_CHECK(handle->task_state == SX127X_TASK_RUNNING, "task not running", SX127X_CHECK(hndl->task_state == SX127X_TASK_RUNNING, "task not running",
ESP_ERR_INVALID_STATE); ESP_ERR_INVALID_STATE);
SX127X_CHECK(data_len < SX127_MAX_PACKET_LEN, "packet len too long: %d", SX127X_CHECK(data_len < SX127_MAX_PACKET_LEN, "packet len too long: %d",
ESP_ERR_INVALID_ARG, data_len); ESP_ERR_INVALID_ARG, data_len);
@ -382,16 +382,16 @@ esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data,
SX127X_CHECK(packet.data != NULL, "malloc error", ESP_ERR_NO_MEM); SX127X_CHECK(packet.data != NULL, "malloc error", ESP_ERR_NO_MEM);
memcpy(packet.data, data, data_len); memcpy(packet.data, data, data_len);
BaseType_t pdRet = BaseType_t pdRet =
xQueueSend(handle->tx_packet_queue, &packet, ticks_to_wait); xQueueSend(hndl->tx_packet_queue, &packet, ticks_to_wait);
SX127X_CHECK(pdRet == pdTRUE, "tx queue full", ESP_ERR_TIMEOUT); SX127X_CHECK(pdRet == pdTRUE, "tx queue full", ESP_ERR_TIMEOUT);
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_recv_packet(sx127x_t *handle, sx127x_rx_packet_t *packet, esp_err_t sx127x_recv_packet(sx127x_t *hndl, sx127x_rx_packet_t *packet,
TickType_t ticks_to_wait) { TickType_t ticks_to_wait) {
SX127X_CHECK(packet != NULL, "packet must not be NULL", ESP_ERR_INVALID_ARG); SX127X_CHECK(packet != NULL, "packet must not be NULL", ESP_ERR_INVALID_ARG);
BaseType_t pdRet = BaseType_t pdRet =
xQueueReceive(handle->rx_packet_queue, packet, ticks_to_wait); xQueueReceive(hndl->rx_packet_queue, packet, ticks_to_wait);
if (pdRet != pdTRUE) { if (pdRet != pdTRUE) {
ESP_LOGV(SX127X_TAG, "timeout on recv_packet"); ESP_LOGV(SX127X_TAG, "timeout on recv_packet");
return ESP_ERR_TIMEOUT; return ESP_ERR_TIMEOUT;
@ -399,6 +399,6 @@ esp_err_t sx127x_recv_packet(sx127x_t *handle, sx127x_rx_packet_t *packet,
return ESP_OK; return ESP_OK;
} }
QueueHandle_t sx127x_get_recv_queue(sx127x_t *handle) { return handle->rx_packet_queue; } QueueHandle_t sx127x_get_recv_queue(sx127x_t *hndl) { return hndl->rx_packet_queue; }
void sx127x_packet_rx_free(sx127x_rx_packet_t *packet) { free(packet->data); } void sx127x_packet_rx_free(sx127x_rx_packet_t *packet) { free(packet->data); }

16
components/sx127x_driver/sx127x_driver.h
View File

@ -79,24 +79,24 @@ typedef struct sx127x_packet_rx {
int8_t snr; int8_t snr;
} sx127x_rx_packet_t; } sx127x_rx_packet_t;
typedef struct sx127x sx127x_t; typedef struct sx127x* sx127x_hndl;
sx127x_config_t sx127x_config_default(); sx127x_config_t sx127x_config_default();
esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_t **handle_ptr); esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_hndl *hndl_ptr);
esp_err_t sx127x_free(sx127x_t *handle); esp_err_t sx127x_free(sx127x_hndl hndl);
esp_err_t sx127x_start(sx127x_t *handle); esp_err_t sx127x_start(sx127x_hndl hndl);
esp_err_t sx127x_stop(sx127x_t *handle); esp_err_t sx127x_stop(sx127x_hndl hndl);
esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data, esp_err_t sx127x_send_packet(sx127x_hndl hndl, const char *data,
size_t data_len, TickType_t ticks_to_wait); size_t data_len, TickType_t ticks_to_wait);
esp_err_t sx127x_recv_packet(sx127x_t *handle, sx127x_rx_packet_t *packet_out, esp_err_t sx127x_recv_packet(sx127x_hndl hndl, sx127x_rx_packet_t *packet_out,
TickType_t ticks_to_wait); TickType_t ticks_to_wait);
QueueHandle_t sx127x_get_recv_queue(sx127x_t *handle); QueueHandle_t sx127x_get_recv_queue(sx127x_hndl hndl);
void sx127x_packet_rx_free(sx127x_rx_packet_t *packet); void sx127x_packet_rx_free(sx127x_rx_packet_t *packet);

4
components/sx127x_driver/sx127x_internal.h
View File

@ -124,7 +124,7 @@ typedef enum sx127x_task_state {
SX127X_TASK_STOPPING = 2, SX127X_TASK_STOPPING = 2,
} sx127x_task_state_t; } sx127x_task_state_t;
struct sx127x { typedef struct sx127x {
sx127x_config_t config; sx127x_config_t config;
spi_device_handle_t device_handle; spi_device_handle_t device_handle;
TaskHandle_t task_handle; TaskHandle_t task_handle;
@ -136,6 +136,6 @@ struct sx127x {
QueueHandle_t rx_packet_queue; QueueHandle_t rx_packet_queue;
// queue of packets to send to the radio // queue of packets to send to the radio
QueueHandle_t tx_packet_queue; QueueHandle_t tx_packet_queue;
}; } sx127x_t;
const char *SX127X_TAG; const char *SX127X_TAG;

98
components/sx127x_driver/sx127x_registers.c
View File

@ -3,15 +3,15 @@
#include <string.h> #include <string.h>
esp_err_t sx127x_read_register(sx127x_t *handle, uint8_t reg, uint8_t *value) { esp_err_t sx127x_read_register(sx127x_t *hndl, uint8_t reg, uint8_t *value) {
return sx127x_single_transfer(handle, reg & 0x7f, 0x00, value); return sx127x_single_transfer(hndl, reg & 0x7f, 0x00, value);
} }
esp_err_t sx127x_write_register(sx127x_t *handle, uint8_t reg, uint8_t value) { esp_err_t sx127x_write_register(sx127x_t *hndl, uint8_t reg, uint8_t value) {
return sx127x_single_transfer(handle, reg | 0x80, value, NULL); return sx127x_single_transfer(hndl, reg | 0x80, value, NULL);
} }
esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr, esp_err_t sx127x_single_transfer(sx127x_t *hndl, uint8_t addr,
uint8_t to_slave, uint8_t *from_slave) { uint8_t to_slave, uint8_t *from_slave) {
spi_transaction_t trans; spi_transaction_t trans;
memset(&trans, 0, sizeof(trans)); memset(&trans, 0, sizeof(trans));
@ -21,7 +21,7 @@ esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr,
trans.rxlength = 8; trans.rxlength = 8;
trans.tx_data[0] = to_slave; trans.tx_data[0] = to_slave;
esp_err_t ret = spi_device_transmit(handle->device_handle, &trans); esp_err_t ret = spi_device_transmit(hndl->device_handle, &trans);
SX127X_ERROR_CHECK2(ret, spi_device_transmit); SX127X_ERROR_CHECK2(ret, spi_device_transmit);
if (from_slave) { if (from_slave) {
*from_slave = trans.rx_data[0]; *from_slave = trans.rx_data[0];
@ -31,34 +31,34 @@ esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr,
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_sleep(sx127x_t *handle) { esp_err_t sx127x_sleep(sx127x_t *hndl) {
return sx127x_write_register(handle, REG_OP_MODE, return sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_SLEEP); SX127X_LONG_RANGE | SX127X_MODE_SLEEP);
} }
esp_err_t sx127x_standby(sx127x_t *handle) { esp_err_t sx127x_standby(sx127x_t *hndl) {
return sx127x_write_register(handle, REG_OP_MODE, return sx127x_write_register(hndl, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_STDBY); SX127X_LONG_RANGE | SX127X_MODE_STDBY);
} }
esp_err_t sx127x_set_frequency(sx127x_t *handle, uint64_t frequency) { esp_err_t sx127x_set_frequency(sx127x_t *hndl, uint64_t frequency) {
uint64_t frf = ((uint64_t)frequency << 19) / 32000000; uint64_t frf = ((uint64_t)frequency << 19) / 32000000;
esp_err_t ret; esp_err_t ret;
ret = sx127x_write_register(handle, REG_FRF_MSB, (uint8_t)(frf)); ret = sx127x_write_register(hndl, REG_FRF_MSB, (uint8_t)(frf));
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
frf >>= 8; frf >>= 8;
ret = sx127x_write_register(handle, REG_FRF_MID, (uint8_t)(frf)); ret = sx127x_write_register(hndl, REG_FRF_MID, (uint8_t)(frf));
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
frf >>= 8; frf >>= 8;
ret = sx127x_write_register(handle, REG_FRF_LSB, (uint8_t)(frf)); ret = sx127x_write_register(hndl, REG_FRF_LSB, (uint8_t)(frf));
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
handle->config.frequency = frequency; hndl->config.frequency = frequency;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power, esp_err_t sx127x_set_tx_power(sx127x_t *hndl, uint8_t tx_power,
sx127x_pa_boost_t pa_boost) { sx127x_pa_boost_t pa_boost) {
esp_err_t ret; esp_err_t ret;
if (pa_boost == SX127X_PA_BOOST_ENABLED) { if (pa_boost == SX127X_PA_BOOST_ENABLED) {
@ -66,20 +66,20 @@ esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power,
SX127X_CHECK(tx_power >= 2 && tx_power <= 20, "invalid tx_power: %d", SX127X_CHECK(tx_power >= 2 && tx_power <= 20, "invalid tx_power: %d",
ESP_ERR_INVALID_ARG, tx_power); ESP_ERR_INVALID_ARG, tx_power);
ret = ret =
sx127x_write_register(handle, REG_PA_CONFIG, PA_BOOST | (tx_power - 2)); sx127x_write_register(hndl, REG_PA_CONFIG, PA_BOOST | (tx_power - 2));
} else { } else {
// RFO // RFO
SX127X_CHECK(tx_power <= 14, "invalid tx_power: %d", ESP_ERR_INVALID_ARG, SX127X_CHECK(tx_power <= 14, "invalid tx_power: %d", ESP_ERR_INVALID_ARG,
tx_power); tx_power);
ret = sx127x_write_register(handle, REG_PA_CONFIG, 0x70 | tx_power); ret = sx127x_write_register(hndl, REG_PA_CONFIG, 0x70 | tx_power);
} }
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
handle->config.tx_power = tx_power; hndl->config.tx_power = tx_power;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_spreading_factor(sx127x_t *handle, esp_err_t sx127x_set_spreading_factor(sx127x_t *hndl,
uint8_t spreading_factor) { uint8_t spreading_factor) {
SX127X_CHECK(spreading_factor >= 6 && spreading_factor <= 12, SX127X_CHECK(spreading_factor >= 6 && spreading_factor <= 12,
"invalid spreading_factor", ESP_ERR_INVALID_ARG); "invalid spreading_factor", ESP_ERR_INVALID_ARG);
@ -92,53 +92,53 @@ esp_err_t sx127x_set_spreading_factor(sx127x_t *handle,
detection_optimize = 0xc3; detection_optimize = 0xc3;
detection_threshold = 0x0a; detection_threshold = 0x0a;
} }
SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_DETECTION_OPTIMIZE, SX127X_ERROR_CHECK(sx127x_write_register(hndl, REG_DETECTION_OPTIMIZE,
detection_optimize)); detection_optimize));
SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_DETECTION_THRESHOLD, SX127X_ERROR_CHECK(sx127x_write_register(hndl, REG_DETECTION_THRESHOLD,
detection_threshold)); detection_threshold));
uint8_t modem_config_3; uint8_t modem_config_3;
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_read_register(handle, REG_MODEM_CONFIG_3, &modem_config_3)); sx127x_read_register(hndl, REG_MODEM_CONFIG_3, &modem_config_3));
modem_config_3 = (modem_config_3 & 0x03) | ((spreading_factor << 4) & 0xf0); modem_config_3 = (modem_config_3 & 0x03) | ((spreading_factor << 4) & 0xf0);
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_3, modem_config_3)); sx127x_write_register(hndl, REG_MODEM_CONFIG_3, modem_config_3));
handle->config.spreading_factor = spreading_factor; hndl->config.spreading_factor = spreading_factor;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle, esp_err_t sx127x_set_signal_bandwidth(sx127x_t *hndl,
uint64_t signal_bandwidth) { uint64_t signal_bandwidth) {
uint8_t bw_reg = sx127x_bw_to_reg(signal_bandwidth); uint8_t bw_reg = sx127x_bw_to_reg(signal_bandwidth);
uint8_t modem_config_1; uint8_t modem_config_1;
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_read_register(handle, REG_MODEM_CONFIG_1, &modem_config_1)); sx127x_read_register(hndl, REG_MODEM_CONFIG_1, &modem_config_1));
modem_config_1 = (modem_config_1 & 0x0f) | (bw_reg << 4); modem_config_1 = (modem_config_1 & 0x0f) | (bw_reg << 4);
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_1, modem_config_1)); sx127x_write_register(hndl, REG_MODEM_CONFIG_1, modem_config_1));
handle->config.signal_bandwidth = signal_bandwidth; hndl->config.signal_bandwidth = signal_bandwidth;
// set low data rate optimization flag // set low data rate optimization flag
uint64_t bw = sx127x_reg_to_bw(bw_reg); uint64_t bw = sx127x_reg_to_bw(bw_reg);
uint8_t sf = handle->config.spreading_factor; uint8_t sf = hndl->config.spreading_factor;
// section 4.1.1.5 // section 4.1.1.5
uint64_t symbol_duration_ms = 1000 / (bw / (1L << sf)); uint64_t symbol_duration_ms = 1000 / (bw / (1L << sf));
// section 4.1.1.6 // section 4.1.1.6
bool must_have_ldo = (symbol_duration_ms > 16); bool must_have_ldo = (symbol_duration_ms > 16);
bool ldo = must_have_ldo || (handle->config.ldo == SX127X_LDO_ENABLED); bool ldo = must_have_ldo || (hndl->config.ldo == SX127X_LDO_ENABLED);
uint8_t modem_config_3; uint8_t modem_config_3;
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_read_register(handle, REG_MODEM_CONFIG_3, &modem_config_3)); sx127x_read_register(hndl, REG_MODEM_CONFIG_3, &modem_config_3));
if (ldo) { if (ldo) {
modem_config_3 |= (1 << 3); modem_config_3 |= (1 << 3);
} else { } else {
modem_config_3 &= ~(1 << 3); modem_config_3 &= ~(1 << 3);
} }
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_3, modem_config_3)); sx127x_write_register(hndl, REG_MODEM_CONFIG_3, modem_config_3));
return ESP_OK; return ESP_OK;
} }
@ -183,48 +183,48 @@ uint64_t sx127x_reg_to_bw(uint8_t bandwidth_reg) {
} }
} }
esp_err_t sx127x_set_sync_word(sx127x_t *handle, uint8_t sync_word) { esp_err_t sx127x_set_sync_word(sx127x_t *hndl, uint8_t sync_word) {
SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_SYNC_WORD, sync_word)); SX127X_ERROR_CHECK(sx127x_write_register(hndl, REG_SYNC_WORD, sync_word));
handle->config.sync_word = sync_word; hndl->config.sync_word = sync_word;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_crc(sx127x_t *handle, sx127x_crc_t crc) { esp_err_t sx127x_set_crc(sx127x_t *hndl, sx127x_crc_t crc) {
uint8_t modem_config_2; uint8_t modem_config_2;
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_read_register(handle, REG_MODEM_CONFIG_2, &modem_config_2)); sx127x_read_register(hndl, REG_MODEM_CONFIG_2, &modem_config_2));
if (crc == SX127X_CRC_ENABLED) { if (crc == SX127X_CRC_ENABLED) {
modem_config_2 |= CONFIG2_CRC; modem_config_2 |= CONFIG2_CRC;
} else { } else {
modem_config_2 &= ~CONFIG2_CRC; modem_config_2 &= ~CONFIG2_CRC;
} }
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_2, modem_config_2)); sx127x_write_register(hndl, REG_MODEM_CONFIG_2, modem_config_2));
handle->config.crc = crc; hndl->config.crc = crc;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_read_pkt_rssi(sx127x_t *handle, int32_t *rssi) { esp_err_t sx127x_read_pkt_rssi(sx127x_t *hndl, int32_t *rssi) {
SX127X_CHECK(rssi != NULL, "rssi can not be NULL", ESP_ERR_INVALID_ARG); SX127X_CHECK(rssi != NULL, "rssi can not be NULL", ESP_ERR_INVALID_ARG);
uint8_t rssi_val; uint8_t rssi_val;
uint64_t freq = handle->config.frequency; uint64_t freq = hndl->config.frequency;
int32_t min_rssi = (freq < 868E6) ? -164 : -157; int32_t min_rssi = (freq < 868E6) ? -164 : -157;
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_read_register(handle, REG_PKT_RSSI_VALUE, &rssi_val)) sx127x_read_register(hndl, REG_PKT_RSSI_VALUE, &rssi_val))
*rssi = min_rssi + rssi_val; *rssi = min_rssi + rssi_val;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_read_pkt_snr(sx127x_t *handle, int8_t *snr) { esp_err_t sx127x_read_pkt_snr(sx127x_t *hndl, int8_t *snr) {
SX127X_CHECK(snr != NULL, "rssi can not be NULL", ESP_ERR_INVALID_ARG); SX127X_CHECK(snr != NULL, "rssi can not be NULL", ESP_ERR_INVALID_ARG);
int8_t snr_val; int8_t snr_val;
SX127X_ERROR_CHECK( SX127X_ERROR_CHECK(
sx127x_read_register(handle, REG_PKT_SNR_VALUE, (uint8_t *)&snr_val)) sx127x_read_register(hndl, REG_PKT_SNR_VALUE, (uint8_t *)&snr_val))
*snr = snr_val; *snr = snr_val;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_write_fifo(sx127x_t *handle, const char *data, esp_err_t sx127x_write_fifo(sx127x_t *hndl, const char *data,
size_t data_len) { size_t data_len) {
spi_transaction_t trans; spi_transaction_t trans;
memset(&trans, 0, sizeof(trans)); memset(&trans, 0, sizeof(trans));
@ -235,13 +235,13 @@ esp_err_t sx127x_write_fifo(sx127x_t *handle, const char *data,
trans.rxlength = 0; trans.rxlength = 0;
trans.rx_buffer = NULL; trans.rx_buffer = NULL;
esp_err_t ret = spi_device_transmit(handle->device_handle, &trans); esp_err_t ret = spi_device_transmit(hndl->device_handle, &trans);
SX127X_ERROR_CHECK2(ret, spi_device_transmit); SX127X_ERROR_CHECK2(ret, spi_device_transmit);
ESP_LOGV(SX127X_TAG, "sx127x_write_fifo(%.*s)", data_len, data); ESP_LOGV(SX127X_TAG, "sx127x_write_fifo(%.*s)", data_len, data);
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_read_fifo(sx127x_t *handle, char *data_out, size_t data_len) { esp_err_t sx127x_read_fifo(sx127x_t *hndl, char *data_out, size_t data_len) {
spi_transaction_t trans; spi_transaction_t trans;
memset(&trans, 0, sizeof(trans)); memset(&trans, 0, sizeof(trans));
trans.flags = 0; trans.flags = 0;
@ -251,7 +251,7 @@ esp_err_t sx127x_read_fifo(sx127x_t *handle, char *data_out, size_t data_len) {
trans.rxlength = 0; // match length trans.rxlength = 0; // match length
trans.rx_buffer = data_out; trans.rx_buffer = data_out;
esp_err_t ret = spi_device_transmit(handle->device_handle, &trans); esp_err_t ret = spi_device_transmit(hndl->device_handle, &trans);
SX127X_ERROR_CHECK2(ret, spi_device_transmit); SX127X_ERROR_CHECK2(ret, spi_device_transmit);
ESP_LOGV(SX127X_TAG, "sx127x_read_fifo(%.*s)", data_len, data_out); ESP_LOGV(SX127X_TAG, "sx127x_read_fifo(%.*s)", data_len, data_out);
return ESP_OK; return ESP_OK;

30
components/sx127x_driver/sx127x_registers.h
View File

@ -1,34 +1,34 @@
#include "sx127x_driver.h" #include "sx127x_driver.h"
esp_err_t sx127x_read_register(sx127x_t *handle, uint8_t reg, uint8_t *value); esp_err_t sx127x_read_register(sx127x_hndl hdnl, uint8_t reg, uint8_t *value);
esp_err_t sx127x_write_register(sx127x_t *handle, uint8_t reg, uint8_t value); esp_err_t sx127x_write_register(sx127x_hndl hdnl, uint8_t reg, uint8_t value);
esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr, esp_err_t sx127x_single_transfer(sx127x_hndl hdnl, uint8_t addr,
uint8_t to_slave, uint8_t *from_slave); uint8_t to_slave, uint8_t *from_slave);
esp_err_t sx127x_sleep(sx127x_t *handle); esp_err_t sx127x_sleep(sx127x_hndl hdnl);
esp_err_t sx127x_standby(sx127x_t *handle); esp_err_t sx127x_standby(sx127x_hndl hdnl);
esp_err_t sx127x_set_frequency(sx127x_t *handle, uint64_t frequency); esp_err_t sx127x_set_frequency(sx127x_hndl hdnl, uint64_t frequency);
esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power, esp_err_t sx127x_set_tx_power(sx127x_hndl hdnl, uint8_t tx_power,
sx127x_pa_boost_t pa_boost); sx127x_pa_boost_t pa_boost);
esp_err_t sx127x_set_spreading_factor(sx127x_t *handle, esp_err_t sx127x_set_spreading_factor(sx127x_hndl hdnl,
uint8_t spreading_factor); uint8_t spreading_factor);
esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle, esp_err_t sx127x_set_signal_bandwidth(sx127x_hndl hdnl,
uint64_t signal_bandwidth); uint64_t signal_bandwidth);
uint8_t sx127x_bw_to_reg(uint64_t bandwidth); uint8_t sx127x_bw_to_reg(uint64_t bandwidth);
uint64_t sx127x_reg_to_bw(uint8_t bandwidth_reg); uint64_t sx127x_reg_to_bw(uint8_t bandwidth_reg);
esp_err_t sx127x_set_sync_word(sx127x_t *handle, uint8_t sync_word); esp_err_t sx127x_set_sync_word(sx127x_hndl hdnl, uint8_t sync_word);
esp_err_t sx127x_set_crc(sx127x_t *handle, sx127x_crc_t crc); esp_err_t sx127x_set_crc(sx127x_hndl hdnl, sx127x_crc_t crc);
esp_err_t sx127x_read_pkt_rssi(sx127x_t *handle, int32_t *rssi); esp_err_t sx127x_read_pkt_rssi(sx127x_hndl hdnl, int32_t *rssi);
esp_err_t sx127x_read_pkt_snr(sx127x_t *handle, int8_t *snr); esp_err_t sx127x_read_pkt_snr(sx127x_hndl hdnl, int8_t *snr);
esp_err_t sx127x_write_fifo(sx127x_t *handle, const char *data, size_t data_len); esp_err_t sx127x_write_fifo(sx127x_hndl hdnl, const char *data, size_t data_len);
esp_err_t sx127x_read_fifo(sx127x_t *handle, char *data_out, esp_err_t sx127x_read_fifo(sx127x_hndl hdnl, char *data_out,
size_t data_len); size_t data_len);

2
main/ugv_main.c
View File

@ -31,7 +31,7 @@ u8g2_t u8g2;
uint16_t packet_num; uint16_t packet_num;
sx127x_t *lora; sx127x_hndl lora;
void loraOnReceive(int packetSize); void loraOnReceive(int packetSize);
void loraTask(void *params); void loraTask(void *params);