Microwave_Manager/main/main.c

#include <stdio.h>
#include "sdkconfig.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/i2c_master.h"
#include "driver/uart.h"
#include "driver/gpio.h"
#include "cmd_parser.h"
#include <string.h>

#define I2C_PORT -1 // Auto selecting

#define I2C_MASTER_SCL_IO GPIO_NUM_9
#define I2C_MASTER_SDA_IO GPIO_NUM_8

// UART1
#define RX1_BUF_SIZE (1024)
#define TX1_BUF_SIZE (512)
#define TXD1_PIN (GPIO_NUM_21)
#define RXD1_PIN (GPIO_NUM_20)

// UART0
#define RX0_BUF_SIZE (1024)
#define TX0_BUF_SIZE (512)
#define TXD0_PIN (GPIO_NUM_1)
#define RXD0_PIN (GPIO_NUM_0)

// 任务句柄
static TaskHandle_t xHandleTaskUart0 = NULL;
static TaskHandle_t xHandleTaskUart1 = NULL;

static void vTaskUart0(void *pvParameters);
static void vTaskUart1(void *pvParameters);

static TaskHandle_t xHandleTaskDac = NULL;

uint8_t power = 0;  // 默认功率
int8_t cmd1[5] = {0xaf, 0x01, 0x01, 0x00, 0xfa};
char error_tag[] = "Error Command!\n";

// IIC任务
static void vTaskDac(void *pvParameter)
{
    i2c_master_bus_config_t i2c_mst_config = {
        .clk_source = I2C_CLK_SRC_DEFAULT,
        .i2c_port = I2C_PORT,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .glitch_ignore_cnt = 7,
        //.flags.enable_internal_pullup = true,
    };

    i2c_master_bus_handle_t bus_handle;
    ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_mst_config, &bus_handle));

    i2c_device_config_t dev_cfg = {
        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
        .device_address = 0x60,
        .scl_speed_hz = 100000,
    };

    i2c_master_dev_handle_t dev_handle;
    ESP_ERROR_CHECK(i2c_master_bus_add_device(bus_handle, &dev_cfg, &dev_handle));

    uint32_t dacv = 4095;
    uint8_t temp[3] = {0x40, 0x10, 0x00};
    temp[1] = dacv >> 4;
    temp[2] = (dacv & 0xF) << 4;

    i2c_master_transmit(dev_handle, temp, 3, -1);
    while (1)
    {
        for (int32_t i = 0; i <= 4095; i += 5)
        {
            dacv = i;
            temp[1] = dacv >> 4;
            temp[2] = (dacv & 0xF) << 4;

            i2c_master_transmit(dev_handle, temp, 3, -1);
            vTaskDelay(10 / portTICK_PERIOD_MS);
        }
        vTaskDelay(3000 / portTICK_PERIOD_MS);
    }
}

// 初始化串口
void uart_init(void)
{
    // 串口配置结构体
    uart_config_t uart0_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };

    uart_param_config(UART_NUM_0, &uart0_config); // 设置串口
    uart_set_pin(UART_NUM_0, TXD0_PIN, RXD0_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    uart_driver_install(UART_NUM_0, RX0_BUF_SIZE * 2, 0, 0, NULL, 0);

    // 串口参数配置->uart1
    uart_config_t uart1_config = {
        .baud_rate = 4800,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_APB,
    };

    uart_param_config(UART_NUM_1, &uart1_config); // 设置串口
    uart_set_pin(UART_NUM_1, TXD1_PIN, RXD1_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
    uart_driver_install(UART_NUM_1, RX1_BUF_SIZE * 2, 0, 0, NULL, 0);
}


// 读串口0，写串口1
static void vTaskUart0(void *pvParameters)
{
    uint8_t *data = (uint8_t *)malloc(RX0_BUF_SIZE + 1);
    for (;;)
    {
        // 获取串口1接收的数据
        int rxBytes = uart_read_bytes(UART_NUM_0, data, RX0_BUF_SIZE, 10 / portTICK_PERIOD_MS); // 10ms读一次，一个系统滴答
        if (rxBytes > 0)
        {
            data[rxBytes] = 0;
            int8_t cmd = parse_serial_command(data, rxBytes);
            // 将接收到的数据发出去
            // uart_write_bytes(UART_NUM_1, (char *)data, rxBytes);
            if(cmd == 0x01)
            {
                uart_write_bytes(UART_NUM_0, cmd1, 5);
            }else if(cmd == 0x02)
            {
                uint8_t power = data[5];

            }
            else
            {
                uart_write_bytes(UART_NUM_0, error_tag, strlen(error_tag));
            }
            
            // uart_write_bytes(UART_NUM_1, "UART0 Got Message!\n", strlen("UART0 Got Message!\n"));
            // printf("UART0: Got one message!\n");
        }
    }
    free(data);
}

// 读串口1，写串口0
static void vTaskUart1(void *pvParameters)
{
    uint8_t *data = (uint8_t *)malloc(RX1_BUF_SIZE + 1);
    for (;;)
    {
        int rxBytes = uart_read_bytes(UART_NUM_1, data, RX1_BUF_SIZE, 10 / portTICK_PERIOD_MS); // 10ms读一次，一个系统滴答
        if (rxBytes > 0)
        {
            data[rxBytes] = 0;
            // 将接收到的数据发出去
            uart_write_bytes(UART_NUM_0, (char *)data, rxBytes);
            // uart_write_bytes(UART_NUM_0, "UART1 Got Message!\n", strlen("UART1 Got Message!\n"));
            // printf("UART1: Got one message!\n");
        }
    }
    free(data);
}

void app_main(void)
{
    // 串口初始化
    uart_init();
    xTaskCreate(vTaskUart0,        // 任务函数
                "vTaskUart0",      // 任务名
                4096,              // 任务栈大小，单位 word， 4 字节
                NULL,              // 任务参数
                2,                 // 任务优先级
                xHandleTaskUart0); // 任务句柄

    // 创建串口1任务
    xTaskCreate(vTaskUart1,        // 任务函数
                "vTaskUart1",      // 任务名
                4096,              // 任务栈大小，单位 word， 4 字节
                NULL,              // 任务参数
                3,                 // 任务优先级
                xHandleTaskUart1); // 任务句柄
    xTaskCreate(vTaskDac,
                "vTaskDac",
                2048,
                NULL,
                2,
                xHandleTaskDac);
}