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

use google code style

Browse Source
This commit is contained in:
Alex Mikhalev 2018-12-31 01:40:41 -07:00
parent 845459fe5b
commit 4c6dbb76c1
9 changed files with 420 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
.clang-format
View File

@ -1,11 +1,11 @@
--- ---
Language: Cpp Language: Cpp
# BasedOnStyle: LLVM # BasedOnStyle: Google
AccessModifierOffset: -2 AccessModifierOffset: -1
AlignAfterOpenBracket: Align AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: true AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true AlignConsecutiveDeclarations: true
AlignEscapedNewlines: Right AlignEscapedNewlines: Left
AlignOperands: true AlignOperands: true
AlignTrailingComments: true AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true
@ -13,13 +13,13 @@ AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: true AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: false AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: MultiLine AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: false BinPackArguments: true
BinPackParameters: false BinPackParameters: true
BraceWrapping: BraceWrapping:
AfterClass: false AfterClass: false
AfterControlStatement: false AfterControlStatement: false
@ -45,14 +45,14 @@ BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true BreakStringLiterals: true
ColumnLimit: 120 ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:' CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4 ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4 ContinuationIndentWidth: 4
Cpp11BracedListStyle: true Cpp11BracedListStyle: true
DerivePointerAlignment: false DerivePointerAlignment: true
DisableFormat: false DisableFormat: false
ExperimentalAutoDetectBinPacking: false ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true FixNamespaceComments: true
@ -62,25 +62,27 @@ ForEachMacros:
- BOOST_FOREACH - BOOST_FOREACH
IncludeBlocks: Preserve IncludeBlocks: Preserve
IncludeCategories: IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/' - Regex: '^<ext/.*\.h>'
Priority: 2 Priority: 2
- Regex: '^(<|"(gtest|gmock|isl|json)/)' - Regex: '^<.*\.h>'
Priority: 3
- Regex: '.*'
Priority: 1 Priority: 1
IncludeIsMainRegex: '(Test)?$' - Regex: '^<.*'
IndentCaseLabels: false Priority: 2
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '([-_](test|unittest))?$'
IndentCaseLabels: true
IndentPPDirectives: None IndentPPDirectives: None
IndentWidth: 2 IndentWidth: 2
IndentWrappedFunctionNames: false IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave JavaScriptQuotes: Leave
JavaScriptWrapImports: true JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: '' MacroBlockBegin: ''
MacroBlockEnd: '' MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1 MaxEmptyLinesToKeep: 1
NamespaceIndentation: None NamespaceIndentation: None
ObjCBinPackProtocolList: Auto ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2 ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true ObjCSpaceBeforeProtocolList: true
@ -91,8 +93,36 @@ PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000 PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10 PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000 PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60 PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Right PointerAlignment: Left
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
CanonicalDelimiter: ''
BasedOnStyle: google
ReflowComments: true ReflowComments: true
SortIncludes: true SortIncludes: true
SortUsingDeclarations: true SortUsingDeclarations: true
@ -105,13 +135,13 @@ SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1 SpacesBeforeTrailingComments: 2
SpacesInAngles: false SpacesInAngles: false
SpacesInContainerLiterals: true SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false SpacesInCStyleCastParentheses: false
SpacesInParentheses: false SpacesInParentheses: false
SpacesInSquareBrackets: false SpacesInSquareBrackets: false
Standard: Cpp11 Standard: Auto
TabWidth: 8 TabWidth: 8
UseTab: Never UseTab: Never
... ...

64
components/sx127x_driver/sx127x_driver.c
View File

@ -18,7 +18,7 @@ sx127x_config_t sx127x_config_default() {
} }
static esp_err_t sx127x_write_config(sx127x_t *handle) { static esp_err_t sx127x_write_config(sx127x_t *handle) {
esp_err_t ret; esp_err_t ret;
const sx127x_config_t *config = &handle->config; const sx127x_config_t *config = &handle->config;
ret = sx127x_sleep(handle); ret = sx127x_sleep(handle);
@ -35,7 +35,7 @@ static esp_err_t sx127x_write_config(sx127x_t *handle) {
uint8_t reg_lna; uint8_t reg_lna;
ret = sx127x_read_register(handle, REG_LNA, &reg_lna); ret = sx127x_read_register(handle, 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(handle, REG_LNA, reg_lna);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
@ -99,7 +99,7 @@ esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_t **handle_ptr) {
.duty_cycle_pos = 0, .duty_cycle_pos = 0,
.cs_ena_pretrans = 0, .cs_ena_pretrans = 0,
.cs_ena_posttrans = 0, .cs_ena_posttrans = 0,
.clock_speed_hz = SPI_CLOCK_HZ, // 8mhz .clock_speed_hz = SPI_CLOCK_HZ, // 8mhz
.input_delay_ns = 0, .input_delay_ns = 0,
.spics_io_num = config->cs_io_num, .spics_io_num = config->cs_io_num,
.flags = 0, .flags = 0,
@ -107,14 +107,16 @@ esp_err_t sx127x_init(const sx127x_config_t *config, sx127x_t **handle_ptr) {
.pre_cb = NULL, .pre_cb = NULL,
.post_cb = NULL, .post_cb = NULL,
}; };
ret = spi_bus_add_device(config->spi_host, &device_config, &handle->device_handle); ret = spi_bus_add_device(config->spi_host, &device_config,
&handle->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(handle, REG_VERSION, &version);
SX127X_ERROR_CHECK2(ret, sx127x_read_register); SX127X_ERROR_CHECK2(ret, sx127x_read_register);
SX127X_CHECK(version == 0x12, "unsupported version %#x", ESP_ERR_INVALID_VERSION, version); SX127X_CHECK(version == 0x12, "unsupported version %#x",
ESP_ERR_INVALID_VERSION, version);
ret = sx127x_write_config(handle); ret = sx127x_write_config(handle);
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
@ -152,10 +154,10 @@ void sx127x_isr(void *arg) {
} }
} }
#define _TX_CHECK(_ret) \ #define _TX_CHECK(_ret) \
ret = (_ret); \ ret = (_ret); \
if (ret != ESP_OK) { \ if (ret != ESP_OK) { \
goto error; \ goto error; \
} }
void sx127x_do_tx(sx127x_t *handle, sx127x_packet_t *packet) { void sx127x_do_tx(sx127x_t *handle, sx127x_packet_t *packet) {
@ -167,7 +169,7 @@ void sx127x_do_tx(sx127x_t *handle, sx127x_packet_t *packet) {
if (mode != SX127X_MODE_TX && mode != SX127X_MODE_FS_TX) { if (mode != SX127X_MODE_TX && mode != SX127X_MODE_FS_TX) {
break; break;
} }
vTaskDelay(1); // wait for finish transmitting vTaskDelay(1); // wait for finish transmitting
} }
_TX_CHECK(sx127x_standby(handle)); _TX_CHECK(sx127x_standby(handle));
@ -179,23 +181,26 @@ void sx127x_do_tx(sx127x_t *handle, sx127x_packet_t *packet) {
} }
_TX_CHECK(sx127x_read_register(handle, REG_MODEM_CONFIG_2, &config_2)); _TX_CHECK(sx127x_read_register(handle, 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(handle, REG_MODEM_CONFIG_2, config_2));
_TX_CHECK(sx127x_write_register(handle, REG_FIFO_ADDR_PTR, 0)); _TX_CHECK(sx127x_write_register(handle, REG_FIFO_ADDR_PTR, 0));
_TX_CHECK(sx127x_write_register(handle, REG_PAYLOAD_LENGTH, 0)); _TX_CHECK(sx127x_write_register(handle, REG_PAYLOAD_LENGTH, 0));
_TX_CHECK(sx127x_write_fifo(handle, packet->data, packet->data_len)); _TX_CHECK(sx127x_write_fifo(handle, packet->data, packet->data_len));
_TX_CHECK(sx127x_write_register(handle, REG_PAYLOAD_LENGTH, packet->data_len)); _TX_CHECK(
sx127x_write_register(handle, REG_PAYLOAD_LENGTH, packet->data_len));
_TX_CHECK(sx127x_write_register(handle, REG_OP_MODE, SX127X_LONG_RANGE | SX127X_MODE_FS_TX)); _TX_CHECK(sx127x_write_register(handle, REG_OP_MODE,
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, SX127X_LONG_RANGE | SX127X_MODE_TX)); _TX_CHECK(sx127x_write_register(handle, REG_OP_MODE,
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(handle, 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);
@ -209,7 +214,8 @@ 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_LONG_RANGE | SX127X_MODE_RX_CONT); sx127x_write_register(handle, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_RX_CONT);
} }
void sx127x_task(void *arg) { void sx127x_task(void *arg) {
@ -239,13 +245,14 @@ void sx127x_task(void *arg) {
} }
ESP_LOGI(SX127X_TAG, "sx127x_task exiting"); ESP_LOGI(SX127X_TAG, "sx127x_task exiting");
handle->task_state = SX127X_TASK_STOPPED; handle->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 *handle) {
esp_err_t ret; esp_err_t ret;
SX127X_CHECK(handle->task_handle == NULL, "task already running", ESP_ERR_INVALID_STATE); SX127X_CHECK(handle->task_handle == NULL, "task already running",
ESP_ERR_INVALID_STATE);
handle->intr_semaphore = xSemaphoreCreateBinary(); handle->intr_semaphore = xSemaphoreCreateBinary();
// handle->recv_packet_queue = xQueueCreate(8, 10); // handle->recv_packet_queue = xQueueCreate(8, 10);
@ -253,7 +260,8 @@ esp_err_t sx127x_start(sx127x_t *handle) {
handle->task_state = SX127X_TASK_RUNNING; handle->task_state = SX127X_TASK_RUNNING;
BaseType_t pdRet = BaseType_t pdRet =
xTaskCreate(sx127x_task, "sx127x_task", TASK_STACK_SIZE, (void *)handle, TASK_PRIORITY, &handle->task_handle); xTaskCreate(sx127x_task, "sx127x_task", TASK_STACK_SIZE, (void *)handle,
TASK_PRIORITY, &handle->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(handle, REG_DIO_MAPPING_1, 0x00);
@ -270,7 +278,8 @@ 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, (void *)handle); ret = gpio_isr_handler_add(handle->config.irq_io_num, sx127x_isr,
(void *)handle);
SX127X_ERROR_CHECK2(ret, gpio_isr_handler_add); SX127X_ERROR_CHECK2(ret, gpio_isr_handler_add);
return ESP_OK; return ESP_OK;
@ -279,7 +288,8 @@ esp_err_t sx127x_start(sx127x_t *handle) {
esp_err_t sx127x_stop(sx127x_t *handle) { esp_err_t sx127x_stop(sx127x_t *handle) {
esp_err_t ret; esp_err_t ret;
SX127X_CHECK(handle->task_handle != NULL, "task has not been started", ESP_ERR_INVALID_STATE); SX127X_CHECK(handle->task_handle != NULL, "task has not been started",
ESP_ERR_INVALID_STATE);
handle->task_state = SX127X_TASK_STOPPING; handle->task_state = SX127X_TASK_STOPPING;
xTaskNotifyGive(handle->task_handle); xTaskNotifyGive(handle->task_handle);
@ -295,15 +305,19 @@ esp_err_t sx127x_stop(sx127x_t *handle) {
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data, size_t data_len, TickType_t ticks_to_wait) { esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data,
SX127X_CHECK(handle->task_state == SX127X_TASK_RUNNING, "task not running", ESP_FAIL); size_t data_len, TickType_t ticks_to_wait) {
SX127X_CHECK(data_len < SX127_MAX_PACKET_LEN, "packet len too long: %d", ESP_FAIL, data_len); SX127X_CHECK(handle->task_state == SX127X_TASK_RUNNING, "task not running",
ESP_FAIL);
SX127X_CHECK(data_len < SX127_MAX_PACKET_LEN, "packet len too long: %d",
ESP_FAIL, data_len);
sx127x_packet_t packet; sx127x_packet_t packet;
packet.data_len = data_len; packet.data_len = data_len;
packet.data = heap_caps_malloc(data_len, MALLOC_CAP_DMA); packet.data = heap_caps_malloc(data_len, MALLOC_CAP_DMA);
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 = xQueueSend(handle->tx_packet_queue, &packet, ticks_to_wait); BaseType_t pdRet =
xQueueSend(handle->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;
} }

3
components/sx127x_driver/sx127x_driver.h
View File

@ -82,4 +82,5 @@ esp_err_t sx127x_start(sx127x_t *handle);
esp_err_t sx127x_stop(sx127x_t *handle); esp_err_t sx127x_stop(sx127x_t *handle);
esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data, size_t data_len, TickType_t ticks_to_wait); esp_err_t sx127x_send_packet(sx127x_t *handle, const char *data,
size_t data_len, TickType_t ticks_to_wait);

66
components/sx127x_driver/sx127x_internal.h
View File

@ -71,42 +71,45 @@ typedef enum sx127x_op_mode {
#define IRQ_RX_DONE_MASK 0x40 #define IRQ_RX_DONE_MASK 0x40
#ifdef NODEBUG #ifdef NODEBUG
#define SX127X_CHECK(check, str, ret_val, ...) \ #define SX127X_CHECK(check, str, ret_val, ...) \
if (!(check)) { \ if (!(check)) { \
ESP_LOGE(SX127X_TAG, str, ##__VA_ARGS__); \ ESP_LOGE(SX127X_TAG, str, ##__VA_ARGS__); \
return (ret_val); \ return (ret_val); \
} }
#define SX127X_ERROR_CHECK(ret) \ #define SX127X_ERROR_CHECK(ret) \
{ \ { \
esp_err_t _error_code = (ret); \ esp_err_t _error_code = (ret); \
if (_error_code != ESP_OK) { \ if (_error_code != ESP_OK) { \
return _error_code; \ return _error_code; \
} \ } \
} }
#define SX127X_ERROR_CHECK2(ret, fun) SX127X_CHECK(ret) #define SX127X_ERROR_CHECK2(ret, fun) SX127X_CHECK(ret)
#else #else
#define SX127X_CHECK(check, str, ret_val, ...) \ #define SX127X_CHECK(check, str, ret_val, ...) \
if (!(check)) { \ if (!(check)) { \
ESP_LOGE(SX127X_TAG, "%s:%d: check %s failed: " str, __FUNCTION__, __LINE__, #check, ##__VA_ARGS__); \ ESP_LOGE(SX127X_TAG, "%s:%d: check %s failed: " str, __FUNCTION__, \
return (ret_val); \ __LINE__, #check, ##__VA_ARGS__); \
return (ret_val); \
} }
#define SX127X_ERROR_CHECK(ret) \ #define SX127X_ERROR_CHECK(ret) \
{ \ { \
esp_err_t _error_code = (ret); \ esp_err_t _error_code = (ret); \
if (_error_code != ESP_OK) { \ if (_error_code != ESP_OK) { \
const char *_error_name = esp_err_to_name(_error_code); \ const char *_error_name = esp_err_to_name(_error_code); \
ESP_LOGE(SX127X_TAG, "%s:%d: %s (%d)", __FUNCTION__, __LINE__, _error_name, _error_code); \ ESP_LOGE(SX127X_TAG, "%s:%d: %s (%d)", __FUNCTION__, __LINE__, \
return _error_code; \ _error_name, _error_code); \
} \ return _error_code; \
} \
} }
#define SX127X_ERROR_CHECK2(ret, fun) \ #define SX127X_ERROR_CHECK2(ret, fun) \
{ \ { \
esp_err_t _error_code = (ret); \ esp_err_t _error_code = (ret); \
if (_error_code != ESP_OK) { \ if (_error_code != ESP_OK) { \
const char *_error_name = esp_err_to_name(_error_code); \ const char *_error_name = esp_err_to_name(_error_code); \
ESP_LOGE(SX127X_TAG, "%s:%d: %s failed: %s (%d)", __FUNCTION__, __LINE__, #fun, _error_name, _error_code); \ ESP_LOGE(SX127X_TAG, "%s:%d: %s failed: %s (%d)", __FUNCTION__, \
return _error_code; \ __LINE__, #fun, _error_name, _error_code); \
} \ return _error_code; \
} \
} }
#endif #endif
@ -121,7 +124,8 @@ struct sx127x {
spi_device_handle_t device_handle; spi_device_handle_t device_handle;
TaskHandle_t task_handle; TaskHandle_t task_handle;
sx127x_task_state_t task_state; sx127x_task_state_t task_state;
// binary semaphore which is given when an interrupt is received from the radio // binary semaphore which is given when an interrupt is received from the
// radio
SemaphoreHandle_t intr_semaphore; SemaphoreHandle_t intr_semaphore;
// queue of packets received from the radio // queue of packets received from the radio
QueueHandle_t rx_packet_queue; QueueHandle_t rx_packet_queue;

87
components/sx127x_driver/sx127x_registers.c
View File

@ -11,7 +11,8 @@ esp_err_t sx127x_write_register(sx127x_t *handle, uint8_t reg, uint8_t value) {
return sx127x_single_transfer(handle, reg | 0x80, value, NULL); return sx127x_single_transfer(handle, reg | 0x80, value, NULL);
} }
esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr, uint8_t to_slave, uint8_t *from_slave) { esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr,
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));
trans.flags = SPI_TRANS_USE_RXDATA | SPI_TRANS_USE_TXDATA; trans.flags = SPI_TRANS_USE_RXDATA | SPI_TRANS_USE_TXDATA;
@ -25,16 +26,19 @@ esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr, uint8_t to_slav
if (from_slave) { if (from_slave) {
*from_slave = trans.rx_data[0]; *from_slave = trans.rx_data[0];
} }
ESP_LOGV(SX127X_TAG, "sx127x_single_transfer(%#x, %#x, %#x)", addr, trans.tx_data[0], trans.rx_data[0]); ESP_LOGV(SX127X_TAG, "sx127x_single_transfer(%#x, %#x, %#x)", addr,
trans.tx_data[0], trans.rx_data[0]);
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_sleep(sx127x_t *handle) { esp_err_t sx127x_sleep(sx127x_t *handle) {
return sx127x_write_register(handle, REG_OP_MODE, SX127X_LONG_RANGE | SX127X_MODE_SLEEP); return sx127x_write_register(handle, REG_OP_MODE,
SX127X_LONG_RANGE | SX127X_MODE_SLEEP);
} }
esp_err_t sx127x_standby(sx127x_t *handle) { esp_err_t sx127x_standby(sx127x_t *handle) {
return sx127x_write_register(handle, REG_OP_MODE, SX127X_LONG_RANGE | SX127X_MODE_STDBY); return sx127x_write_register(handle, REG_OP_MODE,
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 *handle, uint64_t frequency) {
@ -54,15 +58,19 @@ esp_err_t sx127x_set_frequency(sx127x_t *handle, uint64_t frequency) {
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power, sx127x_pa_boost_t pa_boost) { esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power,
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) {
// PA BOOST // PA BOOST
SX127X_CHECK(tx_power >= 2 && tx_power <= 20, "invalid tx_power: %d", ESP_ERR_INVALID_ARG, tx_power); SX127X_CHECK(tx_power >= 2 && tx_power <= 20, "invalid tx_power: %d",
ret = sx127x_write_register(handle, REG_PA_CONFIG, PA_BOOST | (tx_power - 2)); ESP_ERR_INVALID_ARG, tx_power);
ret =
sx127x_write_register(handle, 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, tx_power); SX127X_CHECK(tx_power <= 14, "invalid tx_power: %d", ESP_ERR_INVALID_ARG,
tx_power);
ret = sx127x_write_register(handle, REG_PA_CONFIG, 0x70 | tx_power); ret = sx127x_write_register(handle, REG_PA_CONFIG, 0x70 | tx_power);
} }
SX127X_ERROR_CHECK(ret); SX127X_ERROR_CHECK(ret);
@ -71,8 +79,10 @@ esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power, sx127x_pa_boos
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_spreading_factor(sx127x_t *handle, uint8_t spreading_factor) { esp_err_t sx127x_set_spreading_factor(sx127x_t *handle,
SX127X_CHECK(spreading_factor >= 6 && spreading_factor <= 12, "invalid spreading_factor", ESP_ERR_INVALID_ARG); uint8_t spreading_factor) {
SX127X_CHECK(spreading_factor >= 6 && spreading_factor <= 12,
"invalid spreading_factor", ESP_ERR_INVALID_ARG);
// section 4.1.1.2 in SX1276 datasheet // section 4.1.1.2 in SX1276 datasheet
uint8_t detection_optimize, detection_threshold; uint8_t detection_optimize, detection_threshold;
if (spreading_factor == 6) { if (spreading_factor == 6) {
@ -82,24 +92,31 @@ esp_err_t sx127x_set_spreading_factor(sx127x_t *handle, uint8_t spreading_factor
detection_optimize = 0xc3; detection_optimize = 0xc3;
detection_threshold = 0x0a; detection_threshold = 0x0a;
} }
SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_DETECTION_OPTIMIZE, detection_optimize)); SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_DETECTION_OPTIMIZE,
SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_DETECTION_THRESHOLD, detection_threshold)); detection_optimize));
SX127X_ERROR_CHECK(sx127x_write_register(handle, REG_DETECTION_THRESHOLD,
detection_threshold));
uint8_t modem_config_3; uint8_t modem_config_3;
SX127X_ERROR_CHECK(sx127x_read_register(handle, REG_MODEM_CONFIG_3, &modem_config_3)); SX127X_ERROR_CHECK(
sx127x_read_register(handle, 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_write_register(handle, REG_MODEM_CONFIG_3, modem_config_3)); SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_3, modem_config_3));
handle->config.spreading_factor = spreading_factor; handle->config.spreading_factor = spreading_factor;
return ESP_OK; return ESP_OK;
} }
esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle, uint64_t signal_bandwidth) { esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle,
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_read_register(handle, REG_MODEM_CONFIG_1, &modem_config_1)); SX127X_ERROR_CHECK(
sx127x_read_register(handle, 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_write_register(handle, REG_MODEM_CONFIG_1, modem_config_1)); SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_1, modem_config_1));
handle->config.signal_bandwidth = signal_bandwidth; handle->config.signal_bandwidth = signal_bandwidth;
// set low data rate optimization flag // set low data rate optimization flag
@ -110,16 +127,18 @@ esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle, uint64_t signal_bandwidt
// 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 || (handle->config.ldo == SX127X_LDO_ENABLED);
uint8_t modem_config_3; uint8_t modem_config_3;
SX127X_ERROR_CHECK(sx127x_read_register(handle, REG_MODEM_CONFIG_3, &modem_config_3)); SX127X_ERROR_CHECK(
sx127x_read_register(handle, 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_write_register(handle, REG_MODEM_CONFIG_3, modem_config_3)); SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_3, modem_config_3));
return ESP_OK; return ESP_OK;
} }
@ -150,17 +169,17 @@ 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) {
switch (bandwidth_reg) { switch (bandwidth_reg) {
case 0: return 7.8E3; case 0: return 7.8E3;
case 1: return 10.4E3; case 1: return 10.4E3;
case 2: return 15.6E3; case 2: return 15.6E3;
case 3: return 20.8E3; case 3: return 20.8E3;
case 4: return 31.25E3; case 4: return 31.25E3;
case 5: return 41.7E3; case 5: return 41.7E3;
case 6: return 62.5E3; case 6: return 62.5E3;
case 7: return 125E3; case 7: return 125E3;
case 8: return 250E3; case 8: return 250E3;
default: default:
case 9: return 500E3; case 9: return 500E3;
} }
} }
@ -172,13 +191,15 @@ esp_err_t sx127x_set_sync_word(sx127x_t *handle, uint8_t sync_word) {
esp_err_t sx127x_set_crc(sx127x_t *handle, sx127x_crc_t crc) { esp_err_t sx127x_set_crc(sx127x_t *handle, sx127x_crc_t crc) {
uint8_t modem_config_2; uint8_t modem_config_2;
SX127X_ERROR_CHECK(sx127x_read_register(handle, REG_MODEM_CONFIG_2, &modem_config_2)); SX127X_ERROR_CHECK(
sx127x_read_register(handle, 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_write_register(handle, REG_MODEM_CONFIG_2, modem_config_2)); SX127X_ERROR_CHECK(
sx127x_write_register(handle, REG_MODEM_CONFIG_2, modem_config_2));
handle->config.crc = crc; handle->config.crc = crc;
return ESP_OK; return ESP_OK;
} }

15
components/sx127x_driver/sx127x_registers.h
View File

@ -2,7 +2,8 @@
esp_err_t sx127x_read_register(sx127x_t *handle, uint8_t reg, uint8_t *value); esp_err_t sx127x_read_register(sx127x_t *handle, 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_t *handle, uint8_t reg, uint8_t value);
esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr, uint8_t to_slave, uint8_t *from_slave); esp_err_t sx127x_single_transfer(sx127x_t *handle, uint8_t addr,
uint8_t to_slave, uint8_t *from_slave);
esp_err_t sx127x_sleep(sx127x_t *handle); esp_err_t sx127x_sleep(sx127x_t *handle);
@ -10,11 +11,14 @@ esp_err_t sx127x_standby(sx127x_t *handle);
esp_err_t sx127x_set_frequency(sx127x_t *handle, uint64_t frequency); esp_err_t sx127x_set_frequency(sx127x_t *handle, uint64_t frequency);
esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power, sx127x_pa_boost_t pa_boost); esp_err_t sx127x_set_tx_power(sx127x_t *handle, uint8_t tx_power,
sx127x_pa_boost_t pa_boost);
esp_err_t sx127x_set_spreading_factor(sx127x_t *handle, uint8_t spreading_factor); esp_err_t sx127x_set_spreading_factor(sx127x_t *handle,
uint8_t spreading_factor);
esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle, uint64_t signal_bandwidth); esp_err_t sx127x_set_signal_bandwidth(sx127x_t *handle,
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);
@ -23,4 +27,5 @@ esp_err_t sx127x_set_sync_word(sx127x_t *handle, uint8_t sync_word);
esp_err_t sx127x_set_crc(sx127x_t *handle, sx127x_crc_t crc); esp_err_t sx127x_set_crc(sx127x_t *handle, sx127x_crc_t crc);
esp_err_t sx127x_write_fifo(sx127x_t *handle, char *data, size_t data_len); esp_err_t sx127x_write_fifo(sx127x_t *handle, char *data, size_t data_len);
esp_err_t sx127x_read_fifo(sx127x_t *handle, char *data_out, size_t *data_len_out); esp_err_t sx127x_read_fifo(sx127x_t *handle, char *data_out,
size_t *data_len_out);

370
main/u8g2_esp32_hal.c
View File

@ -12,19 +12,19 @@
static const char * TAG = "u8g2_hal"; static const char * TAG = "u8g2_hal";
static const unsigned int I2C_TIMEOUT_MS = 10; static const unsigned int I2C_TIMEOUT_MS = 10;
static spi_device_handle_t handle_spi; // SPI handle. static spi_device_handle_t handle_spi; // SPI handle.
static i2c_cmd_handle_t handle_i2c; // I2C handle. static i2c_cmd_handle_t handle_i2c; // I2C handle.
static u8g2_esp32_hal_t u8g2_esp32_hal; // HAL state data. static u8g2_esp32_hal_t u8g2_esp32_hal; // HAL state data.
#undef ESP_ERROR_CHECK #undef ESP_ERROR_CHECK
#define ESP_ERROR_CHECK(x) \ #define ESP_ERROR_CHECK(x) \
do { \ do { \
esp_err_t _rc = (x); \ esp_err_t _rc = (x); \
if (_rc != ESP_OK) { \ if (_rc != ESP_OK) { \
const char *_error_name = esp_err_to_name(_rc); \ const char *_error_name = esp_err_to_name(_rc); \
ESP_LOGE(TAG, "%s failed: %s (%d)", #x, _error_name, _rc); \ ESP_LOGE(TAG, "%s failed: %s (%d)", #x, _error_name, _rc); \
return 0; \ return 0; \
} \ } \
} while (0); } while (0);
/* /*
@ -32,219 +32,229 @@ static u8g2_esp32_hal_t u8g2_esp32_hal; // HAL state data.
*/ */
void u8g2_esp32_hal_init(u8g2_esp32_hal_t u8g2_esp32_hal_param) { void u8g2_esp32_hal_init(u8g2_esp32_hal_t u8g2_esp32_hal_param) {
u8g2_esp32_hal = u8g2_esp32_hal_param; u8g2_esp32_hal = u8g2_esp32_hal_param;
} // u8g2_esp32_hal_init } // u8g2_esp32_hal_init
/* /*
* HAL callback function as prescribed by the U8G2 library. This callback is * HAL callback function as prescribed by the U8G2 library. This callback is
* invoked to handle SPI communications. * 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) { uint8_t u8g2_esp32_spi_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
ESP_LOGV(TAG, "spi_byte_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg, arg_int, arg_ptr); 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) { switch (msg) {
case U8X8_MSG_BYTE_SET_DC: case U8X8_MSG_BYTE_SET_DC:
if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED) {
gpio_set_level(u8g2_esp32_hal.dc, arg_int); gpio_set_level(u8g2_esp32_hal.dc, arg_int);
} }
break; 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));
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; break;
} }
spi_bus_config_t bus_config; case U8X8_MSG_BYTE_SEND: {
memset(&bus_config, 0, sizeof(spi_bus_config_t)); spi_transaction_t trans_desc;
bus_config.sclk_io_num = u8g2_esp32_hal.clk; // CLK trans_desc.addr = 0;
bus_config.mosi_io_num = u8g2_esp32_hal.mosi; // MOSI trans_desc.cmd = 0;
bus_config.miso_io_num = -1; // MISO trans_desc.flags = 0;
bus_config.quadwp_io_num = -1; // Not used trans_desc.length = 8 * arg_int; // Number of bits NOT number of bytes.
bus_config.quadhd_io_num = -1; // Not used trans_desc.rxlength = 0;
// ESP_LOGI(TAG, "... Initializing bus."); trans_desc.tx_buffer = arg_ptr;
ESP_ERROR_CHECK(spi_bus_initialize(HSPI_HOST, &bus_config, 1)); trans_desc.rx_buffer = NULL;
spi_device_interface_config_t dev_config; // ESP_LOGI(TAG, "... Transmitting %d bytes.", arg_int);
dev_config.address_bits = 0; ESP_ERROR_CHECK(spi_device_transmit(handle_spi, &trans_desc));
dev_config.command_bits = 0; break;
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; return 0;
} // u8g2_esp32_spi_byte_cb } // u8g2_esp32_spi_byte_cb
/* /*
* HAL callback function as prescribed by the U8G2 library. This callback is * HAL callback function as prescribed by the U8G2 library. This callback is
* invoked to handle I2C communications. * 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) { uint8_t u8g2_esp32_i2c_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
void *arg_ptr) {
#define TXBUF_SIZE 32 #define TXBUF_SIZE 32
static uint8_t txbuf[TXBUF_SIZE]; static uint8_t txbuf[TXBUF_SIZE];
static uint8_t *txbuf_ptr; static uint8_t *txbuf_ptr;
// ESP_LOGV(TAG, "i2c_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg, // ESP_LOGV(TAG, "i2c_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg,
// arg_int, arg_ptr); // arg_int, arg_ptr);
switch (msg) { switch (msg) {
case U8X8_MSG_BYTE_SET_DC: { case U8X8_MSG_BYTE_SET_DC: {
if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED) {
gpio_set_level(u8g2_esp32_hal.dc, arg_int); 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; break;
} }
i2c_config_t conf; case U8X8_MSG_BYTE_INIT: {
conf.mode = I2C_MODE_MASTER; if (u8g2_esp32_hal.sda == U8G2_ESP32_HAL_UNDEFINED ||
conf.sda_io_num = u8g2_esp32_hal.sda; u8g2_esp32_hal.scl == U8G2_ESP32_HAL_UNDEFINED) {
conf.sda_pullup_en = GPIO_PULLUP_ENABLE; break;
conf.scl_io_num = u8g2_esp32_hal.scl; }
conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
ESP_LOGV(TAG, "clk_speed %d", I2C_MASTER_FREQ_HZ);
conf.master.clk_speed = I2C_MASTER_FREQ_HZ;
ESP_ERROR_CHECK(i2c_param_config(I2C_MASTER_NUM, &conf));
ESP_ERROR_CHECK(i2c_driver_install(I2C_MASTER_NUM,
conf.mode,
I2C_MASTER_RX_BUF_DISABLE,
I2C_MASTER_TX_BUF_DISABLE,
ESP_INTR_FLAG_IRAM | ESP_INTR_FLAG_LEVEL1));
break;
}
case U8X8_MSG_BYTE_SEND: { i2c_config_t conf;
uint8_t *data_ptr = (uint8_t *)arg_ptr; conf.mode = I2C_MODE_MASTER;
size_t data_len = (size_t)arg_int; conf.sda_io_num = u8g2_esp32_hal.sda;
// ESP_LOGV(TAG, "U8x8_MSG_BYTE_SEND. txbuf len: %d", txbuf_ptr - txbuf); conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
// ESP_LOG_BUFFER_HEXDUMP(TAG, data_ptr, data_len, ESP_LOG_VERBOSE); conf.scl_io_num = u8g2_esp32_hal.scl;
conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
if (txbuf_ptr + data_len >= txbuf_ptr + TXBUF_SIZE) { ESP_LOGV(TAG, "clk_speed %d", I2C_MASTER_FREQ_HZ);
ESP_LOGE(TAG, "txbuf overflow"); conf.master.clk_speed = I2C_MASTER_FREQ_HZ;
return 0; ESP_ERROR_CHECK(i2c_param_config(I2C_MASTER_NUM, &conf));
ESP_ERROR_CHECK(i2c_driver_install(
I2C_MASTER_NUM, conf.mode, I2C_MASTER_RX_BUF_DISABLE,
I2C_MASTER_TX_BUF_DISABLE,
ESP_INTR_FLAG_IRAM | ESP_INTR_FLAG_LEVEL1));
break;
} }
memcpy(txbuf_ptr, data_ptr, data_len);
txbuf_ptr += data_len;
break;
}
case U8X8_MSG_BYTE_START_TRANSFER: { case U8X8_MSG_BYTE_SEND: {
uint8_t i2c_address = u8x8_GetI2CAddress(u8x8); uint8_t *data_ptr = (uint8_t *)arg_ptr;
handle_i2c = i2c_cmd_link_create(); size_t data_len = (size_t)arg_int;
// ESP_LOGV(TAG, "Start I2C transfer to %02X.", i2c_address >> 1); // ESP_LOGV(TAG, "U8x8_MSG_BYTE_SEND. txbuf len: %d", txbuf_ptr - txbuf);
ESP_ERROR_CHECK(i2c_master_start(handle_i2c)); // ESP_LOG_BUFFER_HEXDUMP(TAG, data_ptr, data_len, ESP_LOG_VERBOSE);
ESP_ERROR_CHECK(i2c_master_write_byte(handle_i2c, i2c_address | I2C_MASTER_WRITE, ACK_CHECK_EN));
txbuf_ptr = txbuf;
break;
}
case U8X8_MSG_BYTE_END_TRANSFER: { if (txbuf_ptr + data_len >= txbuf_ptr + TXBUF_SIZE) {
ESP_LOGV(TAG, "end I2C transfer. txbuf len: %d", txbuf_ptr - txbuf); ESP_LOGE(TAG, "txbuf overflow");
// ESP_LOG_BUFFER_HEXDUMP(TAG, txbuf, txbuf_ptr - txbuf, ESP_LOG_VERBOSE); return 0;
ESP_ERROR_CHECK(i2c_master_write(handle_i2c, txbuf, txbuf_ptr - txbuf, ACK_CHECK_EN)); }
ESP_ERROR_CHECK(i2c_master_stop(handle_i2c)); memcpy(txbuf_ptr, data_ptr, data_len);
ESP_ERROR_CHECK(i2c_master_cmd_begin(I2C_MASTER_NUM, handle_i2c, I2C_TIMEOUT_MS / portTICK_RATE_MS)); txbuf_ptr += data_len;
i2c_cmd_link_delete(handle_i2c); break;
break; }
}
default: return 0; 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));
txbuf_ptr = txbuf;
break;
}
case U8X8_MSG_BYTE_END_TRANSFER: {
ESP_LOGV(TAG, "end I2C transfer. txbuf len: %d", txbuf_ptr - txbuf);
// ESP_LOG_BUFFER_HEXDUMP(TAG, txbuf, txbuf_ptr - txbuf, ESP_LOG_VERBOSE);
ESP_ERROR_CHECK(
i2c_master_write(handle_i2c, txbuf, txbuf_ptr - txbuf, ACK_CHECK_EN));
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;
}
default: return 0;
} }
return 1; return 1;
} // u8g2_esp32_i2c_byte_cb } // u8g2_esp32_i2c_byte_cb
/* /*
* HAL callback function as prescribed by the U8G2 library. This callback is * HAL callback function as prescribed by the U8G2 library. This callback is
* invoked to handle callbacks for GPIO and delay functions. * 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) { uint8_t u8g2_esp32_gpio_and_delay_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
ESP_LOGV(TAG, "gpio_and_delay_cb: Received a msg: %d, arg_int: %d, arg_ptr: %p", msg, arg_int, arg_ptr); 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) { switch (msg) {
// Initialize the GPIO and DELAY HAL functions. If the pins for DC and // 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. // RESET have been specified then we define those pins as GPIO outputs.
case U8X8_MSG_GPIO_AND_DELAY_INIT: { case U8X8_MSG_GPIO_AND_DELAY_INIT: {
uint64_t bitmask = 0; uint64_t bitmask = 0;
if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.dc != U8G2_ESP32_HAL_UNDEFINED) {
bitmask = bitmask | (1ull << u8g2_esp32_hal.dc); bitmask = bitmask | (1ull << u8g2_esp32_hal.dc);
} }
if (u8g2_esp32_hal.reset != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.reset != U8G2_ESP32_HAL_UNDEFINED) {
bitmask = bitmask | (1ull << u8g2_esp32_hal.reset); bitmask = bitmask | (1ull << u8g2_esp32_hal.reset);
} }
if (u8g2_esp32_hal.cs != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.cs != U8G2_ESP32_HAL_UNDEFINED) {
bitmask = bitmask | (1ull << u8g2_esp32_hal.cs); bitmask = bitmask | (1ull << u8g2_esp32_hal.cs);
} }
if (bitmask == 0) { 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; 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. // Set the GPIO reset pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_RESET: case U8X8_MSG_GPIO_RESET:
if (u8g2_esp32_hal.reset != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.reset != U8G2_ESP32_HAL_UNDEFINED) {
gpio_set_level(u8g2_esp32_hal.reset, arg_int); gpio_set_level(u8g2_esp32_hal.reset, arg_int);
} }
break; break;
// Set the GPIO client select pin to the value passed in through arg_int. // Set the GPIO client select pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_CS: case U8X8_MSG_GPIO_CS:
if (u8g2_esp32_hal.cs != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.cs != U8G2_ESP32_HAL_UNDEFINED) {
gpio_set_level(u8g2_esp32_hal.cs, arg_int); gpio_set_level(u8g2_esp32_hal.cs, arg_int);
} }
break; break;
// Set the Software I²C pin to the value passed in through arg_int. // Set the Software I²C pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_I2C_CLOCK: case U8X8_MSG_GPIO_I2C_CLOCK:
if (u8g2_esp32_hal.scl != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.scl != U8G2_ESP32_HAL_UNDEFINED) {
gpio_set_level(u8g2_esp32_hal.scl, arg_int); gpio_set_level(u8g2_esp32_hal.scl, arg_int);
// printf("%c",(arg_int==1?'C':'c')); // printf("%c",(arg_int==1?'C':'c'));
} }
break; break;
// Set the Software I²C pin to the value passed in through arg_int. // Set the Software I²C pin to the value passed in through arg_int.
case U8X8_MSG_GPIO_I2C_DATA: case U8X8_MSG_GPIO_I2C_DATA:
if (u8g2_esp32_hal.sda != U8G2_ESP32_HAL_UNDEFINED) { if (u8g2_esp32_hal.sda != U8G2_ESP32_HAL_UNDEFINED) {
gpio_set_level(u8g2_esp32_hal.sda, arg_int); gpio_set_level(u8g2_esp32_hal.sda, arg_int);
// printf("%c",(arg_int==1?'D':'d')); // printf("%c",(arg_int==1?'D':'d'));
} }
break; break;
// Delay for the number of milliseconds passed in through arg_int. // Delay for the number of milliseconds passed in through arg_int.
case U8X8_MSG_DELAY_MILLI: vTaskDelay(arg_int / portTICK_PERIOD_MS); break; case U8X8_MSG_DELAY_MILLI: vTaskDelay(arg_int / portTICK_PERIOD_MS); break;
default: return 0; default: return 0;
} }
return 1; return 1;
} // u8g2_esp32_gpio_and_delay_cb } // u8g2_esp32_gpio_and_delay_cb

35
main/u8g2_esp32_hal.h
View File

@ -15,31 +15,36 @@
#define U8G2_ESP32_HAL_UNDEFINED (-1) #define U8G2_ESP32_HAL_UNDEFINED (-1)
#define I2C_MASTER_NUM I2C_NUM_1 // I2C port number for master dev #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_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_RX_BUF_DISABLE 0 // I2C master do not need buffer
#define I2C_MASTER_FREQ_HZ 400000 // I2C master clock frequency #define I2C_MASTER_FREQ_HZ 400000 // I2C master clock frequency
#define ACK_CHECK_EN 0x1 // I2C master will check ack from slave #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 #define ACK_CHECK_DIS 0x0 // I2C master will not check ack from slave
typedef struct { typedef struct {
gpio_num_t clk; gpio_num_t clk;
gpio_num_t mosi; gpio_num_t mosi;
gpio_num_t sda; // data for I²C gpio_num_t sda; // data for I²C
gpio_num_t scl; // clock for I²C gpio_num_t scl; // clock for I²C
gpio_num_t cs; gpio_num_t cs;
gpio_num_t reset; gpio_num_t reset;
gpio_num_t dc; gpio_num_t dc;
} u8g2_esp32_hal_t; } u8g2_esp32_hal_t;
#define U8G2_ESP32_HAL_DEFAULT \ #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, 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); 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_spi_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int,
uint8_t u8g2_esp32_i2c_byte_cb(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr); void *arg_ptr);
uint8_t u8g2_esp32_gpio_and_delay_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_ */ #endif /* U8G2_ESP32_HAL_H_ */

30
main/ugv_main.c
View File

@ -59,7 +59,8 @@ void setup_oled(void) {
}; };
u8g2_esp32_hal_init(u8g2_hal_config); 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_Setup_ssd1306_i2c_128x64_noname_f(&u8g2, U8G2_R0, u8g2_esp32_i2c_byte_cb,
u8g2_esp32_gpio_and_delay_cb);
u8g2_InitDisplay(&u8g2); u8g2_InitDisplay(&u8g2);
u8g2_ClearDisplay(&u8g2); u8g2_ClearDisplay(&u8g2);
u8g2_SetPowerSave(&u8g2, false); u8g2_SetPowerSave(&u8g2, false);
@ -120,9 +121,11 @@ void loraTask(void *params) {
struct 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;
BaseType_t didReceive = xQueueReceive(lora_packet_isr_queue, &packet_len, delay_ticks); BaseType_t didReceive =
xQueueReceive(lora_packet_isr_queue, &packet_len, delay_ticks);
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;
@ -134,13 +137,15 @@ void loraTask(void *params) {
} }
current_time = xTaskGetTickCount(); current_time = xTaskGetTickCount();
if (current_time >= next_send) { if (current_time >= next_send) {
int written_bytes = snprintf(tx_buf, tx_buf_len, "hello world %d", packet_num); int written_bytes =
snprintf(tx_buf, tx_buf_len, "hello world %d", packet_num);
if (written_bytes < 0) { if (written_bytes < 0) {
ESP_LOGE(TAG, "snprintf error: %d", written_bytes); ESP_LOGE(TAG, "snprintf error: %d", written_bytes);
continue; continue;
} }
packet_num++; packet_num++;
esp_err_t ret = sx127x_send_packet(lora, tx_buf, written_bytes, 0); // 0 means error if queue full esp_err_t ret = sx127x_send_packet(lora, tx_buf, written_bytes,
0); // 0 means error if queue full
if (ret != ESP_OK) { if (ret != ESP_OK) {
ESP_LOGE(TAG, "error sending packet: %d", ret); ESP_LOGE(TAG, "error sending packet: %d", ret);
} else { } else {
@ -166,16 +171,13 @@ void loop(void) {
u8g2_DrawStr(&u8g2, 4, 8, "Hello World!"); u8g2_DrawStr(&u8g2, 4, 8, "Hello World!");
char buf[32]; char buf[32];
memset(buf, 0, 32); memset(buf, 0, 32);
snprintf(buf, 32, "heap allc/free %d/%d", heap_info.total_allocated_bytes, heap_info.total_free_bytes); snprintf(buf, 32, "heap allc/free %d/%d", heap_info.total_allocated_bytes,
heap_info.total_free_bytes);
u8g2_DrawStr(&u8g2, 4, 8 + 8, buf); u8g2_DrawStr(&u8g2, 4, 8 + 8, buf);
if (packet.buffer_len) { if (packet.buffer_len) {
ESP_LOGI(TAG, ESP_LOGI(TAG, "lora received packet (len %d, rssi: %d, snr: %f): %s\n",
"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, u8g2_font_4x6_mf); u8g2_SetFont(&u8g2, u8g2_font_4x6_mf);
snprintf(buf, 40, "lora pkt(rssi: %d, snr: %f)", packet.rssi, packet.snr); snprintf(buf, 40, "lora pkt(rssi: %d, snr: %f)", packet.rssi, packet.snr);
u8g2_DrawStr(&u8g2, 4, 8 + 8 + 8, buf); u8g2_DrawStr(&u8g2, 4, 8 + 8 + 8, buf);
@ -193,4 +195,6 @@ void loopTask(void *pvUser) {
} }
} }
void app_main() { xTaskCreatePinnedToCore(loopTask, "loopTask", 8192, NULL, 1, NULL, 1); } void app_main() {
xTaskCreatePinnedToCore(loopTask, "loopTask", 8192, NULL, 1, NULL, 1);
}