21ic电子技术开发论坛 › › 技术圈 › vsf › VSF应用实例--解析蓝牙串口HCI（3）代码
返回列表 发新帖

VSF应用实例--解析蓝牙串口HCI（3）代码

[复制链接]
925|0
 楼主| vsf 发表于 2018-4-16 14:23 | 显示全部楼层 |阅读模式
蓝牙串口, HC, 代码, 应用实例, ST
本帖最后由 vsf 于 2018-4-17 13:55 编辑
复制
  1. static struct vsfsm_state_t *hci_transport_h4_evt_handler(struct vsfsm_t *sm,
    

  2.                 vsfsm_evt_t evt)
    

  3. {
    

  4.         struct hci_transport_h4_param_t *h4param =
    

  5.                         (struct hci_transport_h4_param_t *)sm->user_data;
    

  6.         struct vsf_bufstream_t *bufstream;
    

  7.         uint8_t *ptr;
    


  8. 

  9.         switch (evt)
    

  10.         {
    

  11.         case VSFSM_EVT_INIT:
    

  12.                 {
    

  13.                         struct usart_stream_t *usart_stream = h4param->usart_stream;
    

  14.                         struct vsf_stream_t *stream;
    


  15. 

  16.                         h4param->rx.stream.mem.read = false;
    

  17.                         stream = usart_stream->stream_rx = &h4param->rx.stream.stream;
    

  18.                         stream->op = &bufstream_op;
    

  19.                         stream->callback_rx.param = h4param;
    

  20.                         stream->callback_rx.on_inout = hci_transport_h4_on_in;
    


  21. 

  22.                         usart_stream_init(usart_stream);
    

  23.                         stream_connect_rx(usart_stream->stream_rx);
    

  24.                 }
    

  25.                 break;
    

  26.         case HCI_EVT_IN:
    

  27.                 if (h4param->rx.state == HCI_RX_RECEIVED)
    

  28.                 {
    

  29.                         bufstream = &h4param->rx.stream;
    

  30.                         ptr = &h4param->rx.buffer[HCI_INCOMING_PRE_SIZE];
    

  31.                         h4param->packet_handler(ptr[0], &ptr[1],
    

  32.                                 (bufstream->mem.buffer.buffer - ptr) + bufstream->mem.buffer.size - 1);
    


  33. 

  34.                         h4param->rx.state = HCI_RX_IDLE;
    

  35.                         hci_transport_h4_on_in(h4param);
    

  36.                 }
    

  37.                 break;
    

  38.         }
    

  39.         return NULL;
    

  40. }
这里是任务的事件驱动代码，INIT事件中，初始化了接收流，类型是bufstream。对于bufstream，可以自己看VSF中，component/fundation/stream里的代码。
然后初始化串口流，对于接收串口数据来说，串口流模块是发送端，因为串口流模块在接收到串口数据的时候，会写入到流，发送端可以写数据到流。
串口流初始化后，实际上接收流的发送端就连接上了，后面就是连接接收端，这样流就可以运行了。

这里一个关键的函数是：hci_transport_h4_on_in，在接收流收到数据的时候被调用，注意，这个函数是可能在中断中被调用的。
复制
  1. static void hci_transport_h4_on_in(void *param)
    

  2. {
    

  3.         struct hci_transport_h4_param_t *h4param =
    

  4.                         (struct hci_transport_h4_param_t *)param;
    

  5.         struct vsf_bufstream_t *bufstream = &h4param->rx.stream;
    

  6.         uint8_t *ptr = &h4param->rx.buffer[0];
    

  7.         struct vsf_buffer_t buffer;
    


  8. 

  9.         if (h4param->opened)
    

  10.         {
    

  11.                 if (STREAM_GET_FREE_SIZE(bufstream))
    

  12.                         return;
    


  13. 

  14.                 switch (h4param->rx.state)
    

  15.                 {
    

  16.                 case HCI_RX_IDLE:
    

  17.                 hci_transport_h4_idle:
    

  18.                         h4param->rx.state++;
    

  19.                         buffer.buffer = ptr;
    

  20.                         buffer.size = 1;
    

  21.                         break;
    

  22.                 case HCI_RX_TYPE:
    

  23.                         h4param->rx.state++;
    

  24.                         buffer.buffer = &ptr[1];
    

  25.                         switch (ptr[0])
    

  26.                         {
    

  27.                         case HCI_ACL_DATA_PACKET:
    

  28.                                 buffer.size = HCI_ACL_HEADER_SIZE;
    

  29.                                 break;
    

  30.                         case HCI_SCO_DATA_PACKET:
    

  31.                                 buffer.size = HCI_SCO_HEADER_SIZE;
    

  32.                                 break;
    

  33.                         case HCI_EVENT_PACKET:
    

  34.                                 buffer.size = HCI_EVENT_HEADER_SIZE;
    

  35.                                 break;
    

  36.                         default:
    

  37.                         hci_transport_h4_reset:
    

  38.                                 h4param->rx.state = HCI_RX_IDLE;
    

  39.                                 goto hci_transport_h4_idle;
    

  40.                         }
    

  41.                         break;
    

  42.                 case HCI_RX_HEADER:
    

  43.                         switch (ptr[0])
    

  44.                         {
    

  45.                         case HCI_ACL_DATA_PACKET:
    

  46.                                 buffer.size = GET_LE_U16(&ptr[3]);
    

  47.                                 buffer.buffer = &ptr[1 + HCI_ACL_HEADER_SIZE];
    

  48.                                 if (HCI_ACL_HEADER_SIZE + buffer.size > HCI_PACKET_BUFFER_SIZE)
    

  49.                                         goto hci_transport_h4_reset;
    

  50.                                 break;
    

  51.                         case HCI_SCO_DATA_PACKET:
    

  52.                                 buffer.size = ptr[3];
    

  53.                                 buffer.buffer = &ptr[1 + HCI_SCO_HEADER_SIZE];
    

  54.                                 break;
    

  55.                         case HCI_EVENT_PACKET:
    

  56.                                 buffer.size = ptr[2];
    

  57.                                 buffer.buffer = &ptr[1 + HCI_EVENT_HEADER_SIZE];
    

  58.                                 break;
    

  59.                         }
    


  60. 

  61.                         h4param->rx.state++;
    

  62.                         if (buffer.size)
    

  63.                                 break;
    

  64.                 case HCI_RX_DATA:
    

  65.                         h4param->rx.state++;
    

  66.                         vsfsm_post_evt_pending(&h4param->sm, HCI_EVT_IN);
    

  67.                 case HCI_RX_RECEIVED:
    

  68.                         return;
    

  69.                 }
    

  70.                 STREAM_READ(bufstream, &buffer);
    

  71.         }
    

  72. }
在启动的时候，会调用一次hci_transport_h4_on_in，这时候，rx.state是IDLE，会设置buffer接收1个字节报文类型（通过调用STREAM_READ）。
然后，这里就是一个状态机了，在RX_DATA接受完数据后，就发送HCI_EVT_IN事件，并且进入RECEIVED状态，等到高层处理完事件后，重新初始化接收状态机启动接收。
回复

收藏 举报

相关帖子
返回列表 发新帖
vsf

27

主题

60

帖子

6

粉丝
快速回复 在线客服 返回列表 返回顶部