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

一 背景
串口是我接触到最多的一种通信方式，在自动化测试领域发挥了很大的作用，通过串口与上位机交互完成自动测试、自动控制、自动监控等功能，常用的波特率有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);

}

4.3 输出结果

五 总结
这里只是实现了基本的发送字节、发送字符串，接收单个字节的功能，后续还可以加入环形队列，在主循环读取每一个字节，这样就不会丢包，可保证数据的可靠性。
在自动化领域中，串口通信只是其中的一种，还有更多的更可靠的通信方式同样可以使用lua来实现。