Firefly | 让科技更简单，让生活更智能

前言

本项目为技术案例中串口透传的源码解析，希望关注FireBLE的朋友都能够在本篇文章中获得启发。

串口透传本身还未完善，许多冗余处和缺陷、排版都有待整理，希望大家不要见怪。

首先介绍串口透传固件的功能(有一些技术案例未展示出来):

在140个字符内任意长度数据透传。
串口波特率可配置，默认9600，8位传输，1位停止位，无校验，无流控。
支持串口AT命令，通过IO口切换AT模式以及传输模式。AT命令可实现一些基本配置（获取版本、设备名、设备地址。。）、基本操作（开启广播、关闭广播、断开连接。。。）以及一些基本驱动命令（PWM、GPIO、I2C、SPI）。
配套APP（Android以及IOS），支持APP端AT命令。
固件空中升级。

防丢器中最主要是采用了proxr的协议来实现，防丢器包含以下功能

开启/关闭广播
断开后自动广播
报警
反向报警

基础例程

拷贝一个qpps的例程过来，做基础例程，拷贝过来后可以做如下操作。

修改文件夹名称、工程文件以及工程配置文件名称
进入例程，修改工程名，修改输出文件名。
先编译一次，产生链接文件

例程修改

串口透传相对于qpps就是增加了串口的功能，将串口接收到的数据透传到主机，将主机透传过来的数据发送到串口。

对于qpps部分，我们做了如下修改：

修改UUID。
修改notify特征数为1。

对于串口部分：

保留串口0作为串口调试信息打印，用串口1作为透传串口。可在usr_config.h中配置和转换。
添加串口1的接收、发送。
增加串口AT命令。

对于fireble部分：

一个服务，包含一个可写属性特征、可notify属性特征。
能接收AT命令并且处理，返回处理结果。

添加OTA升级

QPPS修改

详细修改请查看源码，本文最后会对这些修改用到的概念进行一些分析。

串口功能添加

串口功能要实现收和发，可以先从收入手。在例程client中，有进行串口接收输入命令并且打印命令反馈的例程，可供参考。

首先对串口1初始化

将串口1中断打开

#define CONFIG_ENABLE_DRIVER_UART1                      TRUE        /*!< Enable/Disable UART Driver */
#define CONFIG_UART1_TX_DEFAULT_IRQHANDLER              TRUE       /*!< Enable/Disable UART1 TX Default IRQ Handler */
#define CONFIG_UART1_RX_DEFAULT_IRQHANDLER              TRUE       /*!< Enable/Disable UART1 RX Default IRQ Handler */
#define CONFIG_UART1_TX_ENABLE_INTERRUPT                TRUE       /*!< Enable/Disable(Polling) UART1 TX Interrupt */
#define CONFIG_UART1_RX_ENABLE_INTERRUPT                TRUE       /*!< Enable/Disable(Polling) UART1 RX Interrupt */

不使用ROM中的UART驱动

#define CONFIG_ENABLE_ROM_DRIVER_UART                   FALSE       /*!< Enable/Disable UART ROM Driver */

开启串口中断唤醒

#define UART_RX_ACTIVE_BIT_EN                           TRUE       /*!< Enable/Disable uart rx active bit set */

配置串口GPIO引脚复用功能

对于GPIO的引脚复用，可能很多朋友都不习惯用QBlue中的QBueDriverTool这个工具去自动配置，喜欢直接修改GPIO，在配置串口1的时候，如果例程选用不当，那么就会出问题，以下第二段如果经过工具配置是将0赋值到PMCR2寄存器，如果采用qpps的自带例程的配置，串口1的功能使用将会出现问题，因为这个引脚也是配置引脚复用功能的。

#if (!QN_COM)
                    | P10_GPIO_8_PIN_CTRL
                    | P11_GPIO_9_PIN_CTRL
#else
                    | P10_UART1_RXD_PIN_CTRL
                    | P11_UART1_TXD_PIN_CTRL
#endif

    // pin select
    syscon_SetPMCR2(QN_SYSCON, 0);

串口驱动初始化

串口初始化函数和中断开启，这里一共配置了2次，一次在system.c的SystemInit中，一次在usr_sleep_restore中。usr_sleep_restore中需要重新配置的原因是sleep后外设时钟都会停止掉，需要再启动一遍，中断也需要重新开启。

#if defined(QN_COM_UART)
    // Initialize User UART port
    uart_init(QN_COM_UART, USARTx_CLK(0), UART_9600);
    uart_tx_enable(QN_COM_UART, MASK_ENABLE);
    uart_rx_enable(QN_COM_UART, MASK_ENABLE);
#endif

com_env

串口1的全局变量较多，我们把这些公用的属性整合进com_env中方便管理。

struct com_env_tag
{
		uint8_t com_conn;
    uint8_t com_mode;
    ///Message id
    uint8_t msg_id;
 
    ///UART TX parameter 
    uint8_t tx_state;       //either transmitting or done.
    struct co_list queue_tx;///Queue of kernel messages corresponding to packets sent through HCI
    struct co_list queue_rx;///Queue of kernel messages corresponding to packets sent through HCI
 
    ///UART RX parameter 
    uint8_t com_rx_len;
		uint8_t com_at_len;
    uint8_t com_rx_buf[QPPS_VAL_CHAR_NUM_MAX*QPP_DATA_MAX_LEN];
    uint8_t com_at_buf[COM_AT_COMM_BUF];
		bool		auto_line_feed;
 
};

串口app的初始化，初始化了三个事件，分别为发送完毕、接收帧满和接收超时。

void com_init(void)
{
    //for com uart tx
    com_env.tx_state = COM_UART_TX_IDLE;	//initialize tx state
    com_env.com_conn = COM_DISCONN;
    com_env.com_mode = COM_MODE_IDLE;
    com_env.auto_line_feed = COM_NO_LF;
    co_list_init(&com_env.queue_tx);			//init TX queue
    co_list_init(&com_env.queue_rx);			//init RX queue
 
    com_gpio_init();
 
		show_com_mode(com_env.com_mode);
 
    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_UART_TX_ID, com_tx_done))
        ASSERT_ERR(0);
    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_UART_RX_FRAME_ID, com_event_uart_rx_frame_handler))
        ASSERT_ERR(0);
    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_UART_RX_TIMEOUT_ID, com_event_uart_rx_timeout_handler))
        ASSERT_ERR(0);
 
}

这是AT部分的初始化，使用了GPIO来产生中断切换AT模式与传输模式，还设置了两个事件。

void com_gpio_init(void)
{
    //set wakeup config,when GPIO low and trigger interrupt
    gpio_wakeup_config(COM_AT_ENABLE,GPIO_WKUP_BY_LOW);
    gpio_enable_interrupt(COM_AT_ENABLE);
 
 
    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_AT_ENABLE_PRESS_ID,
                                          app_event_at_enable_press_handler))
    {
        ASSERT_ERR(0);
    }
 
    if(KE_EVENT_OK != ke_evt_callback_set(EVENT_AT_COMMAND_PROC_ID,
                                          app_com_at_command_handler))
    {
        ASSERT_ERR(0);
    }
 
}

串口接收

串口接收首先清楚当前寄存器内容和中断标志位，防止错误输入。然后开始读取，设置回调函数。每次接收一个字符。

void	com_uart_rx_start(void)
{
    uart_uart_ClrIntFlag(CFG_COM_UART,0x1ff);
    uart_uart_GetRXD(CFG_COM_UART);
		com_env.com_rx_len = 0;
		uart_read(QN_COM_UART, &com_env.com_rx_buf[com_env.com_rx_len],1, com_uart_rx);
}

串口接收数据满了，就发出帧满的事件；如果接收未满，则读取下一个字符，并且设定超时事件。

void com_uart_rx(void)
{
    //continue receive the data for RX
    com_env.com_rx_len++;
    //set pt gpio state
    if(com_env.com_rx_len == QPPS_VAL_CHAR_NUM_MAX*QPP_DATA_MAX_LEN)  //receive data buf is full, should sent them to ble
    {
        ke_evt_set(1UL << EVENT_UART_RX_FRAME_ID);
    }
    else
    {
        uart_read(QN_COM_UART, &com_env.com_rx_buf[com_env.com_rx_len], 1, com_uart_rx);
        ke_evt_set(1UL << EVENT_UART_RX_TIMEOUT_ID);
    }
}

如果接收数据满了，就停止接收，关闭接收中断，发送APP_COM_UART_RX_DONE_IND消息，然后将接收到的数据作为消息参数传递过去。记得要清除掉定时器和事件。

void com_event_uart_rx_frame_handler(void)
{
    uart_rx_int_enable(QN_COM_UART, MASK_DISABLE);  //disable uart rx interrupt
    struct app_uart_data_ind *com_data = ke_msg_alloc(APP_COM_UART_RX_DONE_IND,
                                         TASK_APP,
                                         TASK_APP,
                                         com_env.com_rx_len+1);
    com_data->len=com_env.com_rx_len;
    memcpy(com_data->data,com_env.com_rx_buf,com_env.com_rx_len);
    ke_msg_send(com_data);
 
    ke_timer_clear(APP_COM_RX_TIMEOUT_TIMER, TASK_APP);
    ke_evt_clear(1UL << EVENT_UART_RX_FRAME_ID);
}

设定一个定时器，当定时器发送时间为到来时下一个数据到达，则会覆盖掉当前的计时，重新开始下一轮定时器计时。如果到时间了下一个数据还没有到来，那么判断数据接收完成，发起定时器中断事件。

void com_event_uart_rx_timeout_handler(void)
{
    ke_timer_set(APP_COM_RX_TIMEOUT_TIMER, TASK_APP, COM_FRAME_TIMEOUT);
    ke_evt_clear(1UL << EVENT_UART_RX_TIMEOUT_ID);
}

定时器中断事件同样向APP_COM_UART_RX_DONE_IND发出了消息，并且把接收到的数据作为参数传递过去。

int app_com_rx_timeout_handler(ke_msg_id_t const msgid, void const *param,
                               ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
    uart_rx_int_enable(QN_COM_UART, MASK_DISABLE);  //disable uart rx interrupt
    struct app_uart_data_ind *com_data = ke_msg_alloc(APP_COM_UART_RX_DONE_IND,
                                         TASK_APP,
                                         TASK_APP,
                                         com_env.com_rx_len+1);
    com_data->len=com_env.com_rx_len;
    memcpy(com_data->data,com_env.com_rx_buf,com_env.com_rx_len);
    ke_msg_send(com_data);
 
    return (KE_MSG_CONSUMED);
}

由于数据长度大于20个字节，所以需要分包发送。分包发送主要使用了内核中的列表来作为缓存区存放数据，如果数据小于20字节，就直接将数据转换为消息参数，存入列表中，否则就以20字节为一包做分包存入。

void dev_send_to_app(struct app_uart_data_ind *param)
{
    uint8_t *buf_20;
    int16_t len = param->len;
    int16_t send_len = 0;
 
		uint8_t packet_len = get_bit_num(app_qpps_env->char_status)*20;
#ifdef	CATCH_LOG
	QPRINTF("\r\ntx len %d  data : ",len);
 
    for(uint8_t j = 0; j<len; j++)
        QPRINTF("%c",param->data[j]);
    QPRINTF("\r\n");
#endif
    if(app_qpps_env->char_status)
    {
        for(uint8_t i =0; send_len < len; i++)
        {
            if (len > packet_len) //Split data into package when len longger than 20
            {
                if (len - send_len > packet_len)	
                {
                    buf_20 = (uint8_t*)ke_msg_alloc(0, 0, 0, packet_len);
                    if(buf_20 != NULL)
                    {
                        memcpy(buf_20,param->data+send_len,packet_len);
                        send_len+=packet_len;
                    }
                }
                else
                {
                    buf_20 = (uint8_t *)ke_msg_alloc(0,0,0,len-send_len);
                    if (buf_20 != NULL)
                    {
                        memcpy(buf_20,param->data+send_len,len-send_len);
                        send_len = len;
                    }
                }
            }
            else	//not longger ther 20 send data directely
            {
								buf_20 = (uint8_t *)ke_msg_alloc(0,0,0,len);
								if (buf_20 != NULL)
								{
										memcpy(buf_20,param->data,len);
										send_len = len;
								}
                //app_qpps_data_send(app_qpps_env->conhdl,0,len,param->data);
            }
						//push the package to kernel queue.
						app_push(ke_param2msg(buf_20));
				}
    }
}

一个特征值一次最多传输 20 个字节，如果在消息未确认发送完成的时候就继续填入消息，那么之前的消息会被覆盖，所以在第一次存入数据时，需检查app_qpps_env->char_status是否有空闲特征可以用于发送数据，如果有则发送出去，同时将app_qpps_env->char_status清 0 ，等到收到发送成功消息QPPS_DATA_SEND_CFM后，再将app_qpps_env->char_status置 1 ，防止发生消息覆盖。

void app_push(struct ke_msg *msg)
{
    // Push the message into the list of messages pending for transmission
    co_list_push_back(&com_env.queue_rx, &msg->hdr);
    //QPRINTF("\r\n@@@app_push:");
//    for (uint8_t i = 0; i<msg->param_len; i++)
//        QPRINTF("%c",((uint8_t *)&msg->param)[i]);
//    QPRINTF("\r\n");
 
		//only send in the first push.
		uint8_t *p_data = (uint8_t *)msg->param;
		uint8_t pack_nb = msg->param_len/QPP_DATA_MAX_LEN + 1;
		uint8_t pack_divide_len =  msg->param_len%QPP_DATA_MAX_LEN;
		for (uint8_t char_idx = 0,i = 0;((app_qpps_env->char_status & (~(QPPS_VALUE_NTF_CFG << (char_idx - 1) ))) && (char_idx < QPPS_VAL_CHAR_NUM ));char_idx++)
		{
			if (i < (pack_nb - 1))
			{
				app_qpps_env->char_status &= ~(QPPS_VALUE_NTF_CFG << char_idx);
				app_qpps_data_send(app_qpps_env->conhdl,char_idx,QPP_DATA_MAX_LEN,(uint8_t *)p_data);
				p_data += QPP_DATA_MAX_LEN;
			}
			else
			{
				if ((pack_divide_len != 0) && (i == (pack_nb - 1)))
				{
					app_qpps_env->char_status &= ~(QPPS_VALUE_NTF_CFG << char_idx);
					app_qpps_data_send(app_qpps_env->conhdl,char_idx,pack_divide_len,(uint8_t *)p_data);
					p_data += pack_divide_len;
				}
			}
			i++;
		}
}

接收到QPPS_DATA_SEND_CFM消息后，重置推送特征空闲状态的标志位，如果全部特征发送完毕，那么判断列表是否为空，如果为空则继续取包发送，此时取包发送时调用的是app_tx_done函数。

	case QPPS_DATA_SEND_CFM:
	{
		app_qpps_env->char_status |= (QPPS_VALUE_NTF_CFG << ((struct qpps_data_send_cfm *)param)->char_index);
#if QN_COM							
		uint8_t bit_num = get_bit_num(app_qpps_env->char_status);
		/// if com_mode is  COM_MODE_TRAN and data has send to client success,continiu receive data from com
		if (bit_num >= QPPS_VAL_CHAR_NUM)
		{										
			if (!co_list_is_empty(&com_env.queue_rx))
				app_tx_done();
			if(com_env.com_mode == COM_MODE_TRAN)
			{
				com_uart_rx_start();
			}
		}
#endif								
	}
	break;

void app_tx_done(void)
{
    struct ke_msg * msg;
    //release current message (which was just sent)
    msg = (struct ke_msg *)co_list_pop_front(&com_env.queue_rx);
    // Free the kernel message space
    ke_msg_free(msg);
    // Check if there is a new message pending for transmission
    if ((msg = (struct ke_msg *)co_list_pick(&com_env.queue_rx)) != NULL)
    {
        // Forward the message to the HCI UART for immediate transmission
//        QPRINTF("\r\napp_tx_done:");
//        for (uint8_t i = 0; i<msg->param_len; i++)
//            QPRINTF("%c",((uint8_t *)&msg->param)[i]);
//        QPRINTF("\r\n");
 
 
				uint8_t *p_data = (uint8_t *)msg->param;
				uint8_t pack_nb

算力服务器

云手机服务器

通用主机

小型主机

边缘计算

网关主机

行业通用

人脸平板

行业通用

全国产化

工业宽温

算力模组

通用主板

小型主板

AI摄像机

开发套件系列

配件系列