ESP32 Forum

Code: Select all

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/uart.h"
#include "driver/gpio.h"
#include "esp_err.h"
#include "sdkconfig.h"
#include "nvs_flash.h"
#include "esp_netif.h"
#include "esp_event.h"
#include "esp_log.h"

static const char *TAG = "App";

#define BUF_SIZE (1024)
#define GPIO_LED (33)

// Default is UART_PIN_NO_CHANGE
#define RS485TXD (17)
#define RS485RXD (16)
#define RS485RTS (4)
#define RS485BAUDRATE (115200)
#define UART_NUM (UART_NUM_2)

void uart_send(const int port, const char* str, size_t length);
void handle_command(const char* line);

void app_main()
{
	gpio_set_direction(GPIO_LED, GPIO_MODE_OUTPUT);
	gpio_set_level(GPIO_LED, 1);

	vTaskDelay(5000 / portTICK_PERIOD_MS);

	uart_config_t uart_config = {
		.baud_rate = RS485BAUDRATE,
		.data_bits = UART_DATA_8_BITS,
		.parity = UART_PARITY_DISABLE,
		.stop_bits = UART_STOP_BITS_1,
		.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
		.rx_flow_ctrl_thresh = 122,
	};
	// Configure UART parameters
	int intr_alloc_flags = 0;
	ESP_ERROR_CHECK(uart_driver_install(UART_NUM, BUF_SIZE * 2, 0, 0, NULL, intr_alloc_flags));
	ESP_ERROR_CHECK(uart_param_config(UART_NUM, &uart_config));
	ESP_ERROR_CHECK(uart_set_pin(UART_NUM, RS485TXD, RS485RXD, RS485RTS, UART_PIN_NO_CHANGE));
	ESP_ERROR_CHECK(uart_set_mode(UART_NUM, UART_MODE_RS485_HALF_DUPLEX));
	ESP_ERROR_CHECK(uart_set_rx_timeout(UART_NUM, 3));

	uart_send(UART_NUM, "Device ready.\r\n", 15);

	// Configure a temporary buffer for the incoming data
	uint8_t* data = (uint8_t*)malloc(BUF_SIZE);
	int usedData = 0;

	int count = 0;
	while (true)
	{
		// Read data from the UART
		int len = uart_read_bytes(UART_NUM, data + usedData, BUF_SIZE - 1 - usedData, 20 / portTICK_PERIOD_MS);
		if (len > 0)
		{
			usedData += len;
			for (int i = usedData - len; i < usedData; i++)
			{
				// Handle CR-LF
				if (i < usedData - 1 && data[i] == '\r' && data[i + 1] == '\n')
				{
					// Skip to LF
					data[i] = '\0';
					i++;
				}
				// Handle LF
				if (data[i] == '\n')
				{
					data[i] = '\0';
					ESP_LOGI(TAG, "Recv line: %s", (char*)data);
					uart_send(UART_NUM, "Recv line: ", 11);
					uart_send(UART_NUM, (char*)data, i);
					uart_send(UART_NUM, "\r\n", 2);
					handle_command((char*)data);
					for (int j = i + 1; j < usedData; j++)
					{
						data[j - (i + 1)] = data[j];
					}
					usedData -= (i + 1);
					i = -1;
				}
			}
		}

		vTaskDelay(2000 / portTICK_PERIOD_MS);
		ESP_LOGI(TAG, "Free memory: %d bytes", esp_get_free_heap_size());
		//ESP_LOGI(TAG, "IDF version: %s", esp_get_idf_version());
		ESP_LOGI(TAG, "Count: %d", count);
		char senddata[20] = {0};
		sprintf(senddata, "Count: %d\r\n", count);
		uart_send(UART_NUM, senddata, strlen(senddata));
		count++;

		if (count == 2)
		{
			gpio_set_level(GPIO_LED, 0);
		}
		else if (count > 2)
		{
			gpio_set_level(GPIO_LED, 1);
			vTaskDelay(10 / portTICK_PERIOD_MS);
			gpio_set_level(GPIO_LED, 0);
		}
	}
}

void uart_send(const int port, const char* str, size_t length)
{
	if (uart_write_bytes(port, str, length) != length)
	{
		ESP_LOGE(TAG, "Send data critical failure.");
		// add your code to handle sending failure here
		abort();
	}
}

void handle_command(const char* line)
{
	if (!strcmp(line, "free"))
	{
		ESP_LOGI(TAG, "Free memory: %d bytes", esp_get_free_heap_size());
		char data[40] = {0};
		sprintf(data, "Free memory: %d bytes\r\n", esp_get_free_heap_size());
		uart_send(UART_NUM, data, strlen(data));
	}
	else if (!strcmp(line, "ver"))
	{
		ESP_LOGI(TAG, "IDF version: %s", esp_get_idf_version());
		char data[40] = {0};
		sprintf(data, "IDF version: %s\r\n", esp_get_idf_version());
		uart_send(UART_NUM, data, strlen(data));
	}
	else
	{
		ESP_LOGE(TAG, "Unknown command: %s", line);
		char data[100] = {0};
		sprintf(data, "Unknown command: %s\r\n", line);
		uart_send(UART_NUM, data, strlen(data));
	}
}