hexianglong/snapclient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

upgrade to IDF v5.1.1

Browse Source 
custom board driver ma120x0 is broken
esp dsp is now IDF managed component
mdns is now IDF managed component

Signed-off-by: Karl Osterseher <karli_o@gmx.at>
This commit is contained in:
Karl Osterseher
2024-01-08 22:49:11 +01:00
Unverified
parent 713cda5816
commit db0f9732b2
454 changed files with 29632 additions and 39819 deletions
Download Patch File Download Diff File Expand all files Collapse all files

440
components/esp_peripherals/periph_console.c
View File

@@ -6,10 +6,10 @@
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in
* which case, it is free of charge, to any person obtaining a copy of this
* software and associated documentation files (the "Software"), to deal in the
* Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* Software without restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
@@ -18,27 +18,24 @@
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "periph_console.h"
#include <string.h>
#include "argtable3/argtable3.h"
#include "audio_idf_version.h"
#include "audio_mem.h"
#include "driver/uart.h"
#include "esp_console.h"
#include "esp_log.h"
#include "esp_vfs_dev.h"
#include "sys/queue.h"
#include <string.h>
#if __has_include("esp_idf_version.h")
#include "esp_idf_version.h"
#else
#define ESP_IDF_VERSION_VAL(major, minor, patch) 1
#endif
#define CONSOLE_MAX_ARGUMENTS (5)
static const char *TAG = "PERIPH_CONSOLE";
@@ -46,8 +43,7 @@ static const int STOPPED_BIT = BIT1;
typedef struct periph_console *periph_console_handle_t;
typedef struct periph_console
{
typedef struct periph_console {
char *buffer;
int total_bytes;
bool run;
@@ -60,284 +56,250 @@ typedef struct periph_console
char *prompt_string;
} periph_console_t;
static char *
conslole_parse_arguments (char *str, char **saveptr)
{
static char *conslole_parse_arguments(char *str, char **saveptr) {
char *p;
if (str != NULL)
{
*saveptr = str;
}
if (str != NULL) {
*saveptr = str;
}
p = *saveptr;
if (!p)
{
return NULL;
}
if (!p) {
return NULL;
}
/* Skipping white space.*/
while (*p == ' ' || *p == '\t')
{
p++;
}
while (*p == ' ' || *p == '\t') {
p++;
}
if (*p == '"')
{
/* If an argument starts with a double quote then its delimiter is
* another quote.*/
p++;
*saveptr = strstr (p, "\"");
}
else
{
/* The delimiter is white space.*/
*saveptr = strpbrk (p, " \t");
}
if (*p == '"') {
/* If an argument starts with a double quote then its delimiter is another
* quote.*/
p++;
*saveptr = strstr(p, "\"");
} else {
/* The delimiter is white space.*/
*saveptr = strpbrk(p, " \t");
}
/* Replacing the delimiter with a zero.*/
if (*saveptr != NULL)
{
*(*saveptr)++ = '\0';
}
if (*saveptr != NULL) {
*(*saveptr)++ = '\0';
}
return *p != '\0' ? p : NULL;
}
bool
console_get_line (periph_console_handle_t console, unsigned max_size,
TickType_t time_to_wait)
{
bool console_get_line(periph_console_handle_t console, unsigned max_size,
TickType_t time_to_wait) {
char c;
char tx[3];
int nread = 0;
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0))
nread = uart_read_bytes (CONFIG_ESP_CONSOLE_UART_NUM, (uint8_t *)&c, 1,
time_to_wait);
nread = uart_read_bytes(CONFIG_ESP_CONSOLE_UART_NUM, (uint8_t *)&c, 1,
time_to_wait);
#else
nread = uart_read_bytes (CONFIG_CONSOLE_UART_NUM, (uint8_t *)&c, 1,
time_to_wait);
nread =
uart_read_bytes(CONFIG_CONSOLE_UART_NUM, (uint8_t *)&c, 1, time_to_wait);
#endif
if (nread <= 0)
{
return false;
}
if ((c == 8) || (c == 127))
{ // backspace or del
if (console->total_bytes > 0)
{
console->total_bytes--;
tx[0] = c;
tx[1] = 0x20;
tx[2] = c;
if (nread <= 0) {
return false;
}
if ((c == 8) || (c == 127)) { // backspace or del
if (console->total_bytes > 0) {
console->total_bytes--;
tx[0] = c;
tx[1] = 0x20;
tx[2] = c;
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0))
uart_write_bytes (CONFIG_ESP_CONSOLE_UART_NUM, (const char *)tx, 3);
uart_write_bytes(CONFIG_ESP_CONSOLE_UART_NUM, (const char *)tx, 3);
#else
uart_write_bytes (CONFIG_CONSOLE_UART_NUM, (const char *)tx, 3);
uart_write_bytes(CONFIG_CONSOLE_UART_NUM, (const char *)tx, 3);
#endif
}
return false;
}
if (c == '\n' || c == '\r')
{
tx[0] = '\r';
tx[1] = '\n';
return false;
}
if (c == '\n' || c == '\r') {
tx[0] = '\r';
tx[1] = '\n';
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0))
uart_write_bytes (CONFIG_ESP_CONSOLE_UART_NUM, (const char *)tx, 2);
uart_write_bytes(CONFIG_ESP_CONSOLE_UART_NUM, (const char *)tx, 2);
#else
uart_write_bytes (CONFIG_CONSOLE_UART_NUM, (const char *)tx, 2);
uart_write_bytes(CONFIG_CONSOLE_UART_NUM, (const char *)tx, 2);
#endif
console->buffer[console->total_bytes] = 0;
return true;
}
console->buffer[console->total_bytes] = 0;
return true;
}
if (c < 0x20)
{
return false;
}
if (c < 0x20) {
return false;
}
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0))
uart_write_bytes (CONFIG_ESP_CONSOLE_UART_NUM, (const char *)&c, 1);
uart_write_bytes(CONFIG_ESP_CONSOLE_UART_NUM, (const char *)&c, 1);
#else
uart_write_bytes (CONFIG_CONSOLE_UART_NUM, (const char *)&c, 1);
uart_write_bytes(CONFIG_CONSOLE_UART_NUM, (const char *)&c, 1);
#endif
console->buffer[console->total_bytes++] = (char)c;
if (console->total_bytes > max_size)
{
console->total_bytes = 0;
}
if (console->total_bytes > max_size) {
console->total_bytes = 0;
}
return false;
}
static bool
console_exec (esp_periph_handle_t self, char *cmd, int argc, char *argv[])
{
periph_console_handle_t console
= (periph_console_handle_t)esp_periph_get_data (self);
if (cmd == NULL)
{
return false;
}
static bool console_exec(esp_periph_handle_t self, char *cmd, int argc,
char *argv[]) {
periph_console_handle_t console =
(periph_console_handle_t)esp_periph_get_data(self);
if (cmd == NULL) {
return false;
}
int i;
for (i = 0; i < console->command_num; i++)
{
if (strcasecmp (cmd, console->commands[i].cmd) == 0)
{
if (console->commands[i].func)
{
console->commands[i].func (self, argc, argv);
return true;
}
int cmd_id = console->commands[i].id;
if (cmd_id == 0)
{
cmd_id = i;
}
esp_periph_send_event (self, cmd_id, argv, argc);
return true;
}
}
printf ("----------------------\r\n");
printf ("Perpheral console HELP\r\n");
printf ("----------------------\r\n");
for (i = 0; i < console->command_num; i++)
{
printf ("%s \t%s\r\n", console->commands[i].cmd,
console->commands[i].help);
for (i = 0; i < console->command_num; i++) {
if (strcasecmp(cmd, console->commands[i].cmd) == 0) {
if (console->commands[i].func) {
console->commands[i].func(self, argc, argv);
return true;
}
int cmd_id = console->commands[i].id;
if (cmd_id == 0) {
cmd_id = i;
}
esp_periph_send_event(self, cmd_id, argv, argc);
return true;
}
}
printf("----------------------\r\n");
printf("Perpheral console HELP\r\n");
printf("----------------------\r\n");
for (i = 0; i < console->command_num; i++) {
printf("%s \t%s\r\n", console->commands[i].cmd, console->commands[i].help);
}
return false;
}
static esp_err_t
_console_destroy (esp_periph_handle_t self)
{
periph_console_handle_t console
= (periph_console_handle_t)esp_periph_get_data (self);
static esp_err_t _console_destroy(esp_periph_handle_t self) {
periph_console_handle_t console =
(periph_console_handle_t)esp_periph_get_data(self);
console->run = false;
xEventGroupWaitBits (console->state_event_bits, STOPPED_BIT, false, true,
portMAX_DELAY);
vEventGroupDelete (console->state_event_bits);
if (console->prompt_string)
{
audio_free (console->prompt_string);
}
audio_free (console->buffer);
audio_free (console);
xEventGroupWaitBits(console->state_event_bits, STOPPED_BIT, false, true,
portMAX_DELAY);
vEventGroupDelete(console->state_event_bits);
if (console->prompt_string) {
audio_free(console->prompt_string);
}
audio_free(console->buffer);
audio_free(console);
return ESP_OK;
}
static void
_console_task (void *pv)
{
static void _console_task(void *pv) {
esp_periph_handle_t self = (esp_periph_handle_t)pv;
char *lp, *cmd, *tokp;
char *args[CONSOLE_MAX_ARGUMENTS + 1];
int n;
periph_console_handle_t console
= (periph_console_handle_t)esp_periph_get_data (self);
if (console->total_bytes >= console->buffer_size)
{
console->total_bytes = 0;
}
periph_console_handle_t console =
(periph_console_handle_t)esp_periph_get_data(self);
if (console->total_bytes >= console->buffer_size) {
console->total_bytes = 0;
}
console->run = true;
xEventGroupClearBits (console->state_event_bits, STOPPED_BIT);
xEventGroupClearBits(console->state_event_bits, STOPPED_BIT);
const char *prompt_string = CONSOLE_DEFAULT_PROMPT_STRING;
if (console->prompt_string)
{
prompt_string = console->prompt_string;
}
printf ("\r\n%s ", prompt_string);
while (console->run)
{
if (console_get_line (console, console->buffer_size,
10 / portTICK_RATE_MS))
{
if (console->total_bytes)
{
ESP_LOGD (TAG, "Read line: %s", console->buffer);
}
lp = conslole_parse_arguments (console->buffer, &tokp);
cmd = lp;
n = 0;
while ((lp = conslole_parse_arguments (NULL, &tokp)) != NULL)
{
if (n >= CONSOLE_MAX_ARGUMENTS)
{
printf ("too many arguments\r\n");
cmd = NULL;
break;
}
args[n++] = lp;
}
args[n] = NULL;
if (console->total_bytes > 0)
{
console_exec (self, cmd, n, args);
console->total_bytes = 0;
}
printf ("%s ", prompt_string);
if (console->prompt_string) {
prompt_string = console->prompt_string;
}
printf("\r\n%s ", prompt_string);
while (console->run) {
if (console_get_line(console, console->buffer_size,
10 / portTICK_RATE_MS)) {
if (console->total_bytes) {
ESP_LOGD(TAG, "Read line: %s", console->buffer);
}
lp = conslole_parse_arguments(console->buffer, &tokp);
cmd = lp;
n = 0;
while ((lp = conslole_parse_arguments(NULL, &tokp)) != NULL) {
if (n >= CONSOLE_MAX_ARGUMENTS) {
printf("too many arguments\r\n");
cmd = NULL;
break;
}
args[n++] = lp;
}
args[n] = NULL;
if (console->total_bytes > 0) {
console_exec(self, cmd, n, args);
console->total_bytes = 0;
}
printf("%s ", prompt_string);
}
xEventGroupSetBits (console->state_event_bits, STOPPED_BIT);
vTaskDelete (NULL);
}
xEventGroupSetBits(console->state_event_bits, STOPPED_BIT);
vTaskDelete(NULL);
}
static esp_err_t
_console_init (esp_periph_handle_t self)
{
periph_console_handle_t console
= (periph_console_handle_t)esp_periph_get_data (self);
static esp_err_t _console_init(esp_periph_handle_t self) {
periph_console_handle_t console =
(periph_console_handle_t)esp_periph_get_data(self);
setvbuf (stdin, NULL, _IONBF, 0);
setvbuf (stdout, NULL, _IONBF, 0);
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
/* Minicom, screen, idf_monitor send CR when ENTER key is pressed */
esp_vfs_dev_uart_set_rx_line_endings (ESP_LINE_ENDINGS_CR);
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0))
esp_vfs_dev_uart_port_set_rx_line_endings(CONFIG_ESP_CONSOLE_UART_NUM,
ESP_LINE_ENDINGS_CR);
#else
esp_vfs_dev_uart_set_rx_line_endings(ESP_LINE_ENDINGS_CR);
#endif
/* Move the caret to the beginning of the next line on '\n' */
esp_vfs_dev_uart_set_tx_line_endings (ESP_LINE_ENDINGS_CRLF);
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0))
esp_vfs_dev_uart_port_set_tx_line_endings(CONFIG_ESP_CONSOLE_UART_NUM,
ESP_LINE_ENDINGS_CRLF);
#else
esp_vfs_dev_uart_set_tx_line_endings(ESP_LINE_ENDINGS_CRLF);
#endif
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0))
uart_driver_install (CONFIG_ESP_CONSOLE_UART_NUM, console->buffer_size * 2,
0, 0, NULL, 0);
uart_driver_install(CONFIG_ESP_CONSOLE_UART_NUM, console->buffer_size * 2, 0,
0, NULL, 0);
#else
uart_driver_install (CONFIG_CONSOLE_UART_NUM, console->buffer_size * 2, 0, 0,
NULL, 0);
uart_driver_install(CONFIG_CONSOLE_UART_NUM, console->buffer_size * 2, 0, 0,
NULL, 0);
#endif
/* Tell VFS to use UART driver */
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0))
esp_vfs_dev_uart_use_driver (CONFIG_ESP_CONSOLE_UART_NUM);
esp_vfs_dev_uart_use_driver(CONFIG_ESP_CONSOLE_UART_NUM);
#else
esp_vfs_dev_uart_use_driver (CONFIG_CONSOLE_UART_NUM);
esp_vfs_dev_uart_use_driver(CONFIG_CONSOLE_UART_NUM);
#endif
console->buffer = (char *)audio_malloc (console->buffer_size);
AUDIO_MEM_CHECK (TAG, console->buffer, { return ESP_ERR_NO_MEM; });
console->buffer = (char *)audio_malloc(console->buffer_size);
AUDIO_MEM_CHECK(TAG, console->buffer, { return ESP_ERR_NO_MEM; });
if (xTaskCreate (_console_task, "console_task", console->task_stack, self,
console->task_prio, NULL)
!= pdTRUE)
{
ESP_LOGE (TAG, "Error create console task, memory exhausted?");
return ESP_FAIL;
}
if (xTaskCreate(_console_task, "console_task", console->task_stack, self,
console->task_prio, NULL) != pdTRUE) {
ESP_LOGE(TAG, "Error create console task, memory exhausted?");
return ESP_FAIL;
}
return ESP_OK;
}
esp_periph_handle_t
periph_console_init (periph_console_cfg_t *config)
{
esp_periph_handle_t periph
= esp_periph_create (PERIPH_ID_CONSOLE, "periph_console");
AUDIO_MEM_CHECK (TAG, periph, return NULL);
periph_console_t *console = audio_calloc (1, sizeof (periph_console_t));
AUDIO_MEM_CHECK (TAG, console, {
audio_free (periph);
esp_periph_handle_t periph_console_init(periph_console_cfg_t *config) {
esp_periph_handle_t periph =
esp_periph_create(PERIPH_ID_CONSOLE, "periph_console");
AUDIO_MEM_CHECK(TAG, periph, return NULL);
periph_console_t *console = audio_calloc(1, sizeof(periph_console_t));
AUDIO_MEM_CHECK(TAG, console, {
audio_free(periph);
return NULL;
});
console->commands = config->commands;
@@ -345,29 +307,25 @@ periph_console_init (periph_console_cfg_t *config)
console->task_stack = CONSOLE_DEFAULT_TASK_STACK;
console->task_prio = CONSOLE_DEFAULT_TASK_PRIO;
console->buffer_size = CONSOLE_DEFAULT_BUFFER_SIZE;
if (config->buffer_size > 0)
{
console->buffer_size = config->buffer_size;
}
if (config->task_stack > 0)
{
console->task_stack = config->task_stack;
}
if (config->task_prio)
{
console->task_prio = config->task_prio;
}
if (config->prompt_string)
{
console->prompt_string = audio_strdup (config->prompt_string);
AUDIO_MEM_CHECK (TAG, console->prompt_string, {
audio_free (periph);
audio_free (console);
return NULL;
});
}
console->state_event_bits = xEventGroupCreate ();
esp_periph_set_data (periph, console);
esp_periph_set_function (periph, _console_init, NULL, _console_destroy);
if (config->buffer_size > 0) {
console->buffer_size = config->buffer_size;
}
if (config->task_stack > 0) {
console->task_stack = config->task_stack;
}
if (config->task_prio) {
console->task_prio = config->task_prio;
}
if (config->prompt_string) {
console->prompt_string = audio_strdup(config->prompt_string);
AUDIO_MEM_CHECK(TAG, console->prompt_string, {
audio_free(periph);
audio_free(console);
return NULL;
});
}
console->state_event_bits = xEventGroupCreate();
esp_periph_set_data(periph, console);
esp_periph_set_function(periph, _console_init, NULL, _console_destroy);
return periph;
}