text: /*
   * Copyright (c) 2006-2021, RT-Thread Development Team
   *
   * SPDX-License-Identifier: Apache-2.0
   *
   * Change Logs:
   * Date           Author         Notes
   * 2020-11-29     bigmagic       first version
   */
  #include <rthw.h>
  #include <rtthread.h>
  
  #include "drv_bluetooth.h"
  #include "drv_uart.h"
  #include "raspi4.h"
  
  //https://github.com/RPi-Distro/bluez-firmware/tree/master/broadcom
  //arm-none-eabi-objcopy.exe -I binary -O elf32-littlearm -B arm driver\BCM4345C0.hcd driver\BCM4345C0.a
  
  #define BT_UART_NAME     "uart0"
  #define BT_TX_MAX        (256)
  #define BT_RX_MAX        (256)
  #define BT_HEAD_NUM      (4)
  #define BT_TRY_NUM_MAX   (3)
  #define BT_SEND_MIN_PACK (8)
  
  unsigned char lo(unsigned int val) { return (unsigned char)(val & 0xff); }
  unsigned char hi(unsigned int val) { return (unsigned char)((val & 0xff00) >> 8); }
  
  #define BT_THREAD_STACK_SIZE (2048)
  #define BT_THREAD_PRIORITY   (15)
  #define BT_THREAD_TICK       (10)
  
  enum
  {
      LE_EVENT_CODE = 0x3e,
      LE_CONNECT_CODE = 0x01,
      LE_ADREPORT_CODE = 0x02,
      HCI_ACL_PKT = 0x02,
      HCI_EVENT_PKT = 0x04
  };
  
  static char ch;
  static rt_sem_t bt_rx_sem = RT_NULL;
  static rt_device_t bt_device;
  
  static rt_uint8_t tx_buff[BT_TX_MAX];
  static rt_uint8_t rx_buff[BT_RX_MAX];
  
  static rt_err_t bt_rx_ind(rt_device_t dev, rt_size_t size)
  {
      rt_sem_release(bt_rx_sem);
      return RT_EOK;
  }
  
  int bt_uart_send_data(rt_device_t dev, rt_uint32_t *buf, int len)
  {
      return rt_device_write(dev, 0, buf, len);
  }
  
  
  void bt_uart_receive_flush(rt_device_t dev)
  {
      rt_device_read(dev, RT_NULL, rx_buff, BT_RX_MAX);
  }
  
  int bt_uart_receive_data(rt_device_t dev, rt_uint8_t *buf, rt_uint32_t *len, rt_int32_t time)
  {
      rt_uint16_t ii = 0;
  
      ii = rt_device_read(dev, 0, buf, BT_RX_MAX);
      *len = ii;
      return ii;
  }
  
  void bt_data_pack(rt_uint8_t *tx_buff, rt_uint8_t ogf, rt_uint8_t ocf, rt_uint32_t data_len)
  {
      tx_buff[0] = BT_HCI_COMMAND_PKT;
      tx_buff[1] = ogf; //hi(ogf << 10 | ocf);//opcode hi
      tx_buff[2] = ocf; //lo(ogf << 10 | ocf);//opcode lo
      tx_buff[3] = data_len;
  }
  
  rt_uint32_t bt_reply_check(const rt_uint8_t *buff, rt_uint16_t ogf, rt_uint16_t ocf, int pack_len)
  {
      //step 1
      if (buff[0] != BT_HCI_EVENT_PKT)
      {
          return 1;
      }
  
      //step2
      if (buff[1] == BT_CONNECT_COMPLETE_CODE)
      {
          if (buff[2] != 4)
          {
              return 2;
          }
  
          //err code
          if (buff[3] != 0)
          {
              rt_kprintf("Saw HCI COMMAND STATUS error:%d", buff[3]);
              return 12;
          }
  
          if (buff[4] == 0)
          {
              return 3;
          }
  
          if (buff[5] != ogf)
          {
              return 4;
          }
  
          if (buff[6] != ocf)
          {
              return 5;
          }
      }
      else if (buff[1] == BT_COMMAND_COMPLETE_CODE)
      {
          if (buff[2] != 4)
          {
              return 6;
          }
  
          if (buff[3] == 0)
          {
              return 7;
          }
  
          if (buff[4] != ogf)
          {
              return 8;
          }
  
          if (buff[5] != ocf)
          {
              return 9;
          }
  
          if (buff[6] == 0)
          {
              return 10;
          }
      }
      else
      {
          return 11;
      }
  
      return 0;
  }
  
  rt_err_t bt_loadfirmware(void)
  {
  
      int ii = 0;
      int ret = 0;
      int recv_len = BT_RX_MAX;
      int step = 0;
      rt_uint8_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_VENDOR << 10 | BT_COMMAND_LOAD_FIRMWARE);
      ocf = lo(BT_OGF_VENDOR << 10 | BT_COMMAND_LOAD_FIRMWARE);
  
      bt_data_pack(tx_buff, ogf, ocf, 0);
      int kk = 0;
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, BT_SEND_MIN_PACK);
          rt_thread_mdelay(5);
  
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 2000);
  
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  step = 1;
                  break;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
  
      if (step == 1)
      {
          extern unsigned char _binary_driver_BCM4345C0_hcd_size[];
          extern unsigned char _binary_driver_BCM4345C0_hcd_start[];
          unsigned int c = 0;
          unsigned int size = (long)&_binary_driver_BCM4345C0_hcd_size;
          while (c < size)
          {
              //unsigned char opcodebytes[] = {_binary_BCM4345C0_hcd_start[c], _binary_BCM4345C0_hcd_start[c + 1]};
              unsigned char length = _binary_driver_BCM4345C0_hcd_start[c + 2];
              unsigned char *data = &(_binary_driver_BCM4345C0_hcd_start[c + 3]);
              rt_memset(tx_buff, 0, BT_TX_MAX);
  
              ogf = _binary_driver_BCM4345C0_hcd_start[c + 1];
              ocf = _binary_driver_BCM4345C0_hcd_start[c];
              bt_data_pack(tx_buff, ogf, ocf, length);
  
              rt_memcpy(&tx_buff[BT_HEAD_NUM], data, length);
              int kk = 0;
              for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
              {
                  recv_len = BT_RX_MAX;
                  rt_memset(rx_buff, 0, BT_TX_MAX);
                  bt_uart_receive_flush(bt_device);
                  bt_uart_send_data(bt_device, tx_buff, length + BT_HEAD_NUM);
                  bt_uart_receive_flush(bt_device);
                  rt_thread_mdelay(5);
                  ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
  
                  if (ret > 0)
                  {
                      ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
                      if (ret == 0)
                      {
                          step = 2;
                          break;
                      }
                      else
                      {
                          rt_kprintf("err code is %d\n", ret);
                      }
                  }
              }
  
              if (ii >= 3)
              {
                  step = 3;
                  break;
              }
              c += 3 + length;
          }
  
          if (step != 3)
          {
              return RT_EOK;
          }
      }
      else
      {
          return RT_ERROR;
      }
  
      return RT_ERROR;
  }
  
  rt_err_t bt_setbaud(void)
  {
      static unsigned char params[] = {0, 0, 0x00, 0xc2, 0x01, 0x00}; // little endian, 115200
      int params_len = 6;
      int ii = 0;
      int ret = 0;
  
      int recv_len = BT_RX_MAX;
      rt_uint16_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_VENDOR << 10 | BT_COMMAND_SET_BAUD);
      ocf = lo(BT_OGF_VENDOR << 10 | BT_COMMAND_SET_BAUD);
  
      bt_data_pack(tx_buff, ogf, ocf, params_len);
  
      //rt_memcpy(&tx_buff[BT_HEAD_NUM], params, params_len);
      tx_buff[4] = 0x00;
      tx_buff[5] = 0x01;
      tx_buff[6] = 0xc2;
      tx_buff[7] = 0x00;
      tx_buff[8] = 0x00;
      tx_buff[9] = 0x00;
  
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, params_len + BT_HEAD_NUM);
          rt_thread_mdelay(5);
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  return RT_EOK;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
      return RT_ERROR;
  }
  
  rt_err_t setLEeventmask(unsigned char mask)
  {
      unsigned char params[] = {mask, 0, 0, 0, 0, 0, 0, 0};
  
      //static unsigned char params[] = { 0xee, 0xff, 0xc0, 0xee, 0xff, 0xc0 }; // reversed
      int params_len = 8;
      int ii = 0;
      int ret = 0;
  
      int recv_len = BT_RX_MAX;
      rt_uint16_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_LE_CONTROL << 10 | 0x01);
      ocf = lo(BT_OGF_LE_CONTROL << 10 | 0x01);
  
      bt_data_pack(tx_buff, ogf, ocf, params_len);
  
      //rt_memcpy(&tx_buff[BT_HEAD_NUM], params, params_len);
      tx_buff[4] = params[0];
      tx_buff[5] = params[1];
      tx_buff[6] = params[2];
      tx_buff[7] = params[3];
      tx_buff[8] = params[4];
      tx_buff[9] = params[5];
      tx_buff[10] = params[6];
      tx_buff[11] = params[7];
  
  
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, params_len + BT_HEAD_NUM);
          rt_thread_mdelay(5);
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  return RT_EOK;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
      return RT_ERROR;
  
      //if (hciCommand(OGF_LE_CONTROL, 0x01, params, 8)) uart_writeText("setLEeventmask failed\n");
  }
  
  rt_err_t bt_getbdaddr(unsigned char *bdaddr)
  {
      static unsigned char params[] = {0x00, 0x10, 0x09, BT_HCI_COMMAND_PKT}; //get bdaddr
      int params_len = 4;
      int recv_len = BT_RX_MAX;
  
      // rt_memcpy(tx_buff, params, 4);
      tx_buff[0] = BT_HCI_COMMAND_PKT;
      tx_buff[1] = 0x09;
      tx_buff[2] = 0x10;
      tx_buff[3] = 0x00;
  
      bt_uart_receive_flush(bt_device);
      bt_uart_send_data(bt_device, tx_buff, 4);
      rt_thread_mdelay(100);
      bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
      if (recv_len > 0)
      {
          if ((rx_buff[0] != BT_HCI_EVENT_PKT) || (rx_buff[1] != BT_COMMAND_COMPLETE_CODE))
          {
              return RT_ERROR;
          }
  
          if ((rx_buff[2] != 0x0a) || (rx_buff[3] != 0x01))
          {
              return RT_ERROR;
          }
  
          if ((rx_buff[4] != 0x09) || (rx_buff[5] != 0x10))
          {
              return RT_ERROR;
          }
          bdaddr[0] = rx_buff[7];
          bdaddr[1] = rx_buff[8];
          bdaddr[2] = rx_buff[9];
  
          bdaddr[3] = rx_buff[10];
          bdaddr[4] = rx_buff[11];
          bdaddr[5] = rx_buff[12];
  
      }
      else
      {
          return RT_ERROR;
      }
  
      return RT_EOK;
  }
  
  rt_err_t setLEscanenable(unsigned char state, unsigned char duplicates)
  {
      unsigned char params[] = {state, duplicates};
  
      //static unsigned char params[] = { 0xee, 0xff, 0xc0, 0xee, 0xff, 0xc0 }; // reversed
      int params_len = 2;
      int ii = 0;
      int ret = 0;
  
      int recv_len = BT_RX_MAX;
      rt_uint16_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_LE_CONTROL << 10 | 0x0c);
      ocf = lo(BT_OGF_LE_CONTROL << 10 | 0x0c);
  
      bt_data_pack(tx_buff, ogf, ocf, params_len);
      tx_buff[4] = params[0];
      tx_buff[5] = params[1];
  
      //rt_memcpy(&tx_buff[BT_HEAD_NUM], params, params_len);
  
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, params_len + BT_HEAD_NUM);
          rt_thread_mdelay(5);
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  return RT_EOK;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
      return RT_ERROR;
  }
  
  rt_err_t setLEscanparameters(unsigned char type, unsigned char linterval, unsigned char hinterval, unsigned char lwindow, unsigned char hwindow, unsigned char own_address_type, unsigned char filter_policy)
  {
      unsigned char params[] = {type, linterval, hinterval, lwindow, hwindow, own_address_type, filter_policy};
  
      int params_len = 7;
      int ii = 0;
      int ret = 0;
  
      int recv_len = BT_RX_MAX;
      rt_uint16_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_LE_CONTROL << 10 | 0x0b);
      ocf = lo(BT_OGF_LE_CONTROL << 10 | 0x0b);
  
      bt_data_pack(tx_buff, ogf, ocf, params_len);
      tx_buff[4] = params[0];
      tx_buff[5] = params[1];
      tx_buff[6] = params[2];
      tx_buff[7] = params[3];
      tx_buff[8] = params[4];
      tx_buff[9] = params[5];
      tx_buff[10] = params[6];
      //rt_memcpy(&tx_buff[BT_HEAD_NUM], params, params_len);
  
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, params_len + BT_HEAD_NUM);
          rt_thread_mdelay(5);
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  return RT_EOK;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
      return RT_ERROR;
  }
  
  rt_err_t startActiveScanning()
  {
      float BleScanInterval = 60; // every 60ms
      float BleScanWindow = 60;
      float BleScanDivisor = 0.625;
  
      unsigned int p = BleScanInterval / BleScanDivisor;
      unsigned int q = BleScanWindow / BleScanDivisor;
  
      if (setLEscanparameters(BT_LL_SCAN_ACTIVE, lo(p), hi(p), lo(q), hi(q), 0, 0) == RT_EOK)
      {
          rt_kprintf("setLEscanparameters ok!\n");
      }
      if (setLEscanenable(1, 0) == RT_EOK)
      {
          rt_kprintf("setLEscanenable ok!\n");
      }
  }
  
  rt_err_t bt_setbdaddr(void)
  {
      static unsigned char params[] = {0xee, 0xff, 0xc0, 0xee, 0xff, 0xc0}; // reversed
      int params_len = 6;
      int ii = 0;
      int ret = 0;
  
      int recv_len = BT_RX_MAX;
      rt_uint16_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_VENDOR << 10 | BT_COMMAND_SET_BDADDR);
      ocf = lo(BT_OGF_VENDOR << 10 | BT_COMMAND_SET_BDADDR);
  
      bt_data_pack(tx_buff, ogf, ocf, params_len);
  
      tx_buff[4] = 0xc0;
      tx_buff[5] = 0xff;
      tx_buff[6] = 0xee;
      tx_buff[7] = 0xc0;
      tx_buff[8] = 0xff;
      tx_buff[9] = 0xee;
  
      //rt_memcpy(&tx_buff[BT_HEAD_NUM], params, params_len);
  
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, params_len + BT_HEAD_NUM);
          rt_thread_mdelay(5);
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  return RT_EOK;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
      return RT_ERROR;
  }
  rt_err_t bt_reset(void)
  {
      int ii = 0;
      int ret = 0;
      int recv_len = BT_RX_MAX;
      rt_uint16_t ogf, ocf;
  
      rt_memset(tx_buff, 0, BT_TX_MAX);
  
      ogf = hi(BT_OGF_HOST_CONTROL << 10 | BT_COMMAND_RESET_CHIP);
      ocf = lo(BT_OGF_HOST_CONTROL << 10 | BT_COMMAND_RESET_CHIP);
  
      bt_data_pack(tx_buff, ogf, ocf, 0);
      for (ii = 0; ii < BT_TRY_NUM_MAX; ii++)
      {
          recv_len = BT_RX_MAX;
          bt_uart_receive_flush(bt_device);
          bt_uart_send_data(bt_device, tx_buff, 8);
          rt_thread_mdelay(5);
          ret = bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
          //rt_kprintf("recv_len is %d\n", recv_len);
          if (ret > 0)
          {
              ret = bt_reply_check(rx_buff, ogf, ocf, RT_NULL);
              if (ret == 0)
              {
                  return RT_EOK;
              }
              else
              {
                  rt_kprintf("err code is %d\n", ret);
              }
          }
      }
      return RT_ERROR;
  }
  
  rt_device_t bt_uart_init(const char *uartname)
  {
      rt_device_t dev = RT_NULL;
      if (strcmp(uartname, BT_UART_NAME) == 0)
      {
          bt_rx_sem = rt_sem_create("btbuf", 0, RT_IPC_FLAG_FIFO);
          dev = rt_device_find(uartname);
          if (dev == RT_NULL)
          {
              rt_kprintf("can no find dev %s\n", uartname);
              return dev;
          }
  
          if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) == RT_EOK)
          {
              rt_device_set_rx_indicate(dev, bt_rx_ind);
          }
          return dev;
      }
      return dev;
  }
  
  static void bt_task_entry(void *param)
  {
      while (1)
      {
          rt_thread_delay(1000);
      }
  }
  
  #define MAX_MSG_LEN 50
  #define MAX_READ_RUN 100
  
  unsigned char data_buf[MAX_MSG_LEN];
  unsigned int data_len;
  unsigned int messages_received = 0;
  unsigned int poll_state = 0;
  
  unsigned int got_echo_sid = 0;
  unsigned int got_echo_name = 0;
  unsigned char echo_addr[6];
  
  void hci_poll2(unsigned char byte)
  {
      switch (poll_state)
      {
      case 0:
          if (byte != HCI_EVENT_PKT)
              poll_state = 0;
          else
              poll_state = 1;
          break;
      case 1:
          if (byte != LE_EVENT_CODE)
              poll_state = 0;
          else
              poll_state = 2;
          break;
      case 2:
          if (byte > MAX_MSG_LEN)
              poll_state = 0;
          else
          {
              poll_state = 3;
              data_len = byte;
          }
          break;
      default:
          data_buf[poll_state - 3] = byte;
          if (poll_state == data_len + 3 - 1)
          {
              messages_received++;
              poll_state = 0;
          }
          else
              poll_state++;
      }
  }
  
  unsigned char *hci_poll()
  {
      int recv_len = 256;
      unsigned int goal = messages_received + 1;
      bt_uart_receive_data(bt_device, rx_buff, &recv_len, 1000);
      rt_thread_mdelay(10);
      if (recv_len > 0)
      {
          unsigned int run = 0;
          while (run < MAX_READ_RUN && messages_received < goal)
          {
  
              recv_len = recv_len - 1;
              hci_poll2(rx_buff[recv_len]);
              run++;
  
              if (recv_len == 0)
              {
                  break;
              }
          }
          if (run == MAX_READ_RUN)
              return 0;
          else
              return data_buf;
      }
      return 0;
  }
  
  void bt_search()
  {
      unsigned char *buf;
  
      while ((buf = hci_poll()))
      {
          if (data_len >= 2)
          {
              if (buf[0] == LE_ADREPORT_CODE)
              {
                  unsigned char numreports = buf[1];
  
                  if (numreports == 1)
                  {
                      unsigned char event_type = buf[2];
  
                      if (event_type == 0x00)
                      {
                          unsigned char buf_len = buf[10];
                          unsigned char ad_len = buf[11];
  
                          if (ad_len < data_len && buf_len + 11 == data_len - 1)
                          {
                              for (int c = 9; c >= 4; c--)
                                  echo_addr[9 - c] = buf[c];
                              buf += 11;
  
                              got_echo_sid = 0;
                              got_echo_name = 0; // Reset the search state machine
                              do
                              {
                                  ad_len = buf[0];
                                  unsigned char ad_type = buf[1];
                                  buf += 2;
  
                                  if (ad_len >= 2)
                                  {
                                      if (ad_type == 0x03)
                                      {
                                          unsigned int sid = 0;
  
                                          for (int d = 0; d < ad_len - 1; d += 2)
                                          {
                                              sid = buf[d] | (buf[d + 1] << 8);
                                              if (sid == 0xEC00)
                                              {
                                                  rt_kprintf("sid is %d\n", sid);
                                                  //uart_hex(sid); uart_writeText(" ");
                                                  got_echo_sid = 1;
                                              }
                                          }
                                      }
                                      else if (ad_type == 0x09)
                                      {
                                          char remote_name[ad_len - 1];
                                          unsigned int d = 0;
  
                                          while (d < ad_len - 1)
                                          {
                                              remote_name[d] = buf[d];
                                              d++;
                                          }
                                          if (!memcmp(remote_name, "echo", 4))
                                          {
                                              rt_kprintf("remote_name is %s\n", remote_name);
                                              got_echo_name = 1;
                                          }
                                      }
                                  }
  
                                  buf += ad_len - 1;
                              } while (buf[1]);
                          }
                      }
                  }
              }
          }
      }
  }
  
  void bt_uart_protocol_init()
  {
      rt_thread_t bt_tid = RT_NULL;
      bt_device = bt_uart_init(BT_UART_NAME);
      bt_tid = rt_thread_create("bt_task", bt_task_entry, RT_NULL, BT_THREAD_STACK_SIZE, BT_THREAD_PRIORITY, BT_THREAD_TICK);
      if (bt_tid == RT_NULL)
      {
          rt_kprintf("bt_task create err!\n");
          return 0;
      }
      rt_thread_startup(bt_tid);
  }
  
  int rt_hw_bluetooth_init(void)
  {
      bt_uart_protocol_init();
      if (bt_reset() == RT_EOK)
      {
          rt_kprintf("bluetooth reset ok!\n");
      }
      else
      {
          rt_kprintf("bluetooth reset err!\n");
      }
  
      rt_thread_delay(10);
      if (bt_loadfirmware() == RT_EOK)
      {
          rt_kprintf("loadfirmware ok!\n");
      }
      else
      {
          rt_kprintf("loadfirmware err!\n");
      }
      rt_thread_delay(10);
      if (bt_setbaud() == RT_EOK)
      {
          rt_kprintf("setbaud ok!\n");
      }
      else
      {
          rt_kprintf("setbaud err!\n");
      }
  
      rt_thread_delay(10);
      if (bt_setbdaddr() == RT_EOK)
      {
          rt_kprintf("setbdaddr ok!\n");
      }
      else
      {
          rt_kprintf("setbdaddr err!\n");
      }
      rt_thread_delay(100);
      rt_uint8_t bdaddr[6];
      if (bt_getbdaddr(bdaddr) == RT_EOK)
      {
          rt_kprintf("bdaddr :%02x:%02x:%02x:%02x:%02x:%02x\n", bdaddr[0], bdaddr[1], bdaddr[2], bdaddr[3], bdaddr[4], bdaddr[5]);
      }
      else
      {
          rt_kprintf("getbdaddr err!\n");
      }
  
      rt_thread_delay(100);
  
      if (setLEeventmask(0xff) == RT_EOK)
      {
          rt_kprintf("setLEeventmask ok!\n");
      }
      rt_thread_delay(100);
      startActiveScanning();
      rt_thread_delay(500);
      rt_kprintf("start!\n");
      while (1)
      {
          bt_search();
          if (got_echo_sid && got_echo_name)
          {
              break;
          }
          rt_thread_mdelay(10);
      }
      rt_kprintf("stop scan!\n");
  }
  