嵌入式开发之lua串口通信嵌入式串口实验代码

liuian 2024-12-25 13:59 55 浏览

一背景
串口是我接触到最多的一种通信方式，在自动化测试领域发挥了很大的作用，通过串口与上位机交互完成自动测试、自动控制、自动监控等功能，常用的波特率有9600bps、38400bps、115200bps，我们可以把串口相关的API加进去满足这些有通信需求的应用场景。

二实现串口相关API
2.1 C底层串口的实现
暂时没有开发板，先在codeblocks上模拟一个串口功能

HANDLE hCom;
uint32_t wCount;//读取的字节数
uint8_t bReadStat;
COMMTIMEOUTS TimeOuts;
#define DEVICE_UART_BUF_SIZE 32768
void __SendByte(int8_t ucData)
{
int8_t tempbuf[2]={0};
uint32_t write_len = 0;
tempbuf[0] = ucData;
WriteFile(hCom,tempbuf,1,&write_len,NULL);
}
void __SendString(int8_t *str)
{
while(*str != '\0')
{
__SendByte(*str);
str++;
}
}

2.2 uart库

static const luaL_Reg uartlib[] =
{
{"open", uart_open},
{"UART_PORT_1", NULL},
{"UART_PORT_2", NULL},
{"UART_PORT_3", NULL},
{NULL, NULL}
};
int luaopen_uart (lua_State *L)
{
luaL_newlib(L, uartlib);
lua_pushnumber(L, UART_PORT_1);
lua_setfield(L, -2, "UART_PORT_1");
lua_pushnumber(L, UART_PORT_2);
lua_setfield(L, -2, "UART_PORT_2");
lua_pushnumber(L, UART_PORT_3);
lua_setfield(L, -2, "UART_PORT_3");
return 1;
}
static int uart_open (lua_State *L)
{
lua_lock(L);
csp_uart_t *p_uart = (csp_uart_t *)lua_newuserdata(L, sizeof(csp_uart_t));
if (!p_uart)
{
goto err;
}
lua_getfield(L,1,"port");//第一个是port类型是int
uint32_t get_port = lua_tointeger(L, -1);
lua_pop(L, 1);
if (get_port>=UART_PORT_MAX)
{
goto err;
}
lua_getfield(L,1,"baudrate");//第二是baudrate类型是int
uint32_t get_baudrate= lua_tointeger(L, -1);
lua_pop(L, 1);
if ((get_baudrate>115200) || (get_baudrate<9600))
{
goto err;
}
p_uart->port = get_port;
p_uart->baudrate = get_baudrate;
p_uart->p_read_callback = uart_irq_handler;
char set_port[10];
sprintf(set_port,"COM%d",p_uart->port);
hCom=CreateFile(TEXT(set_port),GENERIC_READ|GENERIC_WRITE, 0, NULL,OPEN_EXISTING,0, NULL);
SetupComm(hCom,DEVICE_UART_BUF_SIZE,DEVICE_UART_BUF_SIZE);
luaL_newmetatable(L, TNAMESTR_UART);
luaL_newlib(L, uart_userdata);
lua_setfield(L, -2, "__index");
lua_setmetatable(L, -2);
lua_unlock(L);
return 1;
err:
lua_pushnil(L);
lua_unlock(L);
return 1;
}

2.2.1 uart userdata

typedef enum
{
UART_PORT_1 = 1,
UART_PORT_2,
UART_PORT_3,
UART_PORT_MAX
} Uart_Comport;
typedef enum
{
UART_BAUDRATE_9600 = 9600,
UART_BAUDRATE_19200 = 19200,
UART_BAUDRATE_38400 = 38400,
UART_BAUDRATE_57600 = 57600,
UART_BAUDRATE_115200 = 115200,
UART_BAUDRATE_MAX
} Uart_Baudrate;
typedef enum
{
UART_DATABITS_5 = 5,
UART_DATABITS_6,
UART_DATABITS_7,
UART_DATABITS_8,
UART_DATABITS_MAX
} Uart_Databits;
typedef void(*uart_receive_callback_t)(uint8_t _data);
typedef struct
{
uint8_t port;//uart0,uart1,uart2...
volatile uint32_t baudrate;
volatile uint8_t databits; //**Default:** `8`.
uart_receive_callback_t p_read_callback;
} csp_uart_t;
#define TNAMESTR_UART "g_utype_uart"

const luaL_Reg uart_userdata[] =
{
{"put_char",uart_putchar},
{"put_str",uart_str},
{NULL,NULL}
};
static int uart_putchar (lua_State *L)
{
csp_uart_t *p_uart = (csp_gpio_t *)luaL_checkudata(L, 1,TNAMESTR_UART);
if (p_uart)
{
BOOLEAN get_ch = luaL_checkinteger(L, 2);
printf("getch=[%02x]\n",get_ch);
__SendByte(get_ch);
}
return 0;
}
static int uart_str (lua_State *L)
{
csp_uart_t *p_uart = (csp_gpio_t *)luaL_checkudata(L, 1,TNAMESTR_UART);
if (p_uart)
{
char *get_str = luaL_checkstring(L, 2);
printf("get_str=[%s]\n",get_str);
__SendString(get_str);
}
return 0;
}

2.2.2 定义uart回调函数

int uart1_callback_index;
lua_State *g_uart1_l;
int uart1_callback(lua_State *L)
{
int res = 0;
uint8_t ch;
{
int n = lua_gettop(L);
if(n<1)
{
lua_pushinteger(L, 0);
return 1;
}
ch = lua_tointeger(L,1);
lua_rawgeti(L, LUA_REGISTRYINDEX, uart1_callback_index);
lua_pushinteger(L, ch);
lua_pcall(L, 1, 1, 0);
}
return 1;
}
void uart_irq_handler(uint8_t rx_data)
{
//其它操作
if (g_uart1_l)
{
int top = lua_gettop(g_uart1_l);
lua_pushcfunction(g_uart1_l, &uart1_callback);
lua_pushinteger(g_uart1_l, rx_data);
lua_pcall(g_uart1_l, 1, 1, 0);
int res = lua_tointeger(g_uart1_l, -1);
lua_pop(g_uart1_l, 1);
lua_settop(g_uart1_l, top);
}
}

2.2.3 注册uart回调函数

if(LUA_TFUNCTION==lua_getglobal(g_l, "uart1_callback"))
{
uart1_callback_index = luaL_ref(g_l, LUA_REGISTRYINDEX);
g_uart1_l = lua_newthread(g_l);
}

三工具
3.1 虚拟串口

3.2 串口助手

配置为每隔1秒自动发送数字1到数字10

四测试程序
4.1 lua应用

print("hello lua")
--新建一个gpio设备，引脚编号为10，模式为推挽输出
pin_config = {pin=10,mode=gpio.MODE_OUT_PUSHPULL}
local led = gpio.open(pin_config)
led:write(gpio.HIGH_LEVEL)--输出高电平
led:read()--读取电平
led:write(gpio.LOW_LEVEL)--输出低电平
led:read()--读取电平
timer_config = {id=1,ivt_ms=1000}
local time1 = timer.open(timer_config)
time1:start()
function timer1_callback(id)
print("timerout with id:",id)
end
uart_config = {port=1,baudrate=115200}
local uart1 = uart.open(uart_config)
uart1:put_char(0x55)
uart1:put_str("hello uart")
function uart1_callback(rx_data)
print("rx_data:",rx_data)
end

4.2 c底层应用代码

uint32_t readCount=0,send_count=0;
BOOL bRet;
uint8_t send_char=0;
uint32_t receive_length=0;
COMSTAT ComStat;
uint32_t dwErrorFlags=0;
uint32_t dwCommModemStatus;
OVERLAPPED os;
lua_State *g_l= luaL_newstate();
if (g_l)
{
luaL_openlibs(g_l);
}
luaL_dofile(g_l, "G:\\temp.lua");
if(LUA_TFUNCTION==lua_getglobal(g_l, "timer1_callback"))
{
timer1_callback_index = luaL_ref(g_l, LUA_REGISTRYINDEX);
g_timer1_l = lua_newthread(g_l);
}
if(LUA_TFUNCTION==lua_getglobal(g_l, "uart1_callback"))
{
uart1_callback_index = luaL_ref(g_l, LUA_REGISTRYINDEX);
g_uart1_l = lua_newthread(g_l);
}
while(1)
{
bRet=ClearCommError(hCom,&dwErrorFlags,&ComStat);
receive_length = ComStat.cbInQue;
if(receive_length>0)
{
ReadFile(hCom,str,receive_length,&readCount,NULL);
if(readCount>0)
{
for(send_count=0;send_count<readCount;send_count++)
{
send_char = str[send_count];
//printf("%02x ",send_char);
uart_irq_handler(send_char);
}
}
}
Sleep(5);
}