CC254x蓝牙4.0BLE协议栈开发（连载）

HAL_UART=TRUE

HAL_UART_USB=FALSE

uint8 HalUARTOpen(uint8 port, halUARTCfg_t *config);

typedef struct

{

  bool                configured;               // 配置与否

  uint8               baudRate;                 // 波特率

  bool                flowControl;              // 流控制

  uint16              flowControlThreshold;

  uint8               idleTimeout;              // 空闲时间

  halUARTBufControl_t rx;                       // 接收

  halUARTBufControl_t tx;                       // 发送

  bool                intEnable;                // 中断使能

  uint32              rxChRvdTime;              // 接收数据时间

  halUARTCBack_t      callBackFunc;             // 回调函数     

}halUARTCfg_t;

void Serial_Init(void)

{

    halUARTCfg_t SerialCfg = {0};



    SerialCfg.baudRate = HAL_UART_BR_115200;    // 波特率

    SerialCfg.flowControl = HAL_UART_FLOW_OFF;  // 流控制



    SerialCfg.callBackFunc = SerialCb;          // 回调函数

    SerialCfg.intEnable    = TRUE;

    SerialCfg.configured   = TRUE;

    HalLcdWriteString( "Open Uart0", HAL_LCD_LINE_5 );    // 在第5行显示启动信息

    HalUARTOpen(HAL_UART_PORT_0, &SerialCfg);

    HalUARTWrite(HAL_UART_PORT_0, "Hello MT254xBoard\r\n", osal_strlen("Hello MT254xBoard\r\n"));

}

static void SerialCb( uint8 port, uint8 events )

{

    uint8 RxBuf[64]={0};

    if((events & HAL_UART_TX_EMPTY)||( events & HAL_UART_TX_FULL ))  // 发送区满或者空

    {

        return;

    }



    uint16 usRxBufLen = Hal_UART_RxBufLen(HAL_UART_PORT_0);  // 读取接收据量

    usRxBufLen = MIN(64,usRxBufLen);

    uint16 readLen = HalUARTRead(HAL_UART_PORT_0, RxBuf, usRxBufLen);

    HalUARTWrite(HAL_UART_PORT_0, RxBuf, usRxBufLen);

}

static void SerialCb( uint8 port, uint8 events )

{

    if((events & HAL_UART_TX_EMPTY)||( events & HAL_UART_TX_FULL ))  // 发送区满或者空

    {

        return;

    }

    uint16 usRxBufLen = Hal_UART_RxBufLen(HAL_UART_PORT_0);  // 读取接收据量

    if(usRxBufLen)

    {

        usRxBufLen = MIN(128,usRxBufLen);

        uint16 readLen = HalUARTRead(HAL_UART_PORT_0, &SerialRxBuf[RxIndex], usRxBufLen);   // 读取数据到缓冲区

        RxIndex += readLen;

        readLen %= 128;

        osal_start_timerEx(simpleBLEPeripheral_TaskID, UART_EVENT, 5);  // 启动定时器

    }

}

  if ( events & UART_EVENT )

  {

    HalLcdWriteString( (char*)SerialRxBuf, HAL_LCD_LINE_6 );    // 在第5行显示启动信息

    HalUARTWrite(HAL_UART_PORT_0, SerialRxBuf, osal_strlen(SerialRxBuf));

    osal_memset(SerialRxBuf, 0, 128);

    return (events ^ UART_EVENT);

  }

int SerialPrintf(const char*fmt, ...)

{

    uint32  ulLen;

    va_list ap;



    char *pBuf = (char*)osal_mem_alloc(PRINT_BUF_LEN);  // 开辟缓冲区

    va_start(ap, fmt);

    ulLen = vsprintf(pBuf, fmt, ap);        // 用虚拟打印函数实现

    va_end(ap);



    HalUARTWrite(HAL_UART_PORT_0, (uint8*)pBuf, ulLen); // 从串口0输出

    osal_mem_free(pBuf);    // 释放内存空间

    return ulLen;

}

uint8 halGetJoyKeyInput(void)

{

  /* The joystick control is encoded as an analog voltage.

   * Read the JOY_LEVEL analog value and map it to joy movement.

   */

  uint16 adc;

  uint8 ksave0 = 0;

  uint8 ksave1;



  /* Keep on reading the ADC until two consecutive key decisions are the same. */

  do

  {

    ksave1 = ksave0;    /* save previouse key reading */



    adc = HalAdcRead (HAL_KEY_JOY_CHN, HAL_ADC_RESOLUTION_10);



    if ((adc >= 2) && (adc <= 95))  // 85 right

    {

      ksave0 |= HAL_KEY_RIGHT;

    }

    else if ((adc >= 96) && (adc <= 110))    // 101 cent

    {

       ksave0 |= HAL_KEY_CENTER;

    }

    else if ((adc >= 111) && (adc <= 140))    // 127 up

    {

       ksave0 |= HAL_KEY_UP;

    }

    else if ((adc >= 141) && (adc <= 200))    // 170 left

    {

      ksave0 |= HAL_KEY_LEFT;

    }

    else if ((adc >= 201) && (adc <= 300))   // 257 down

    {

     ksave0 |= HAL_KEY_DOWN;

    }

  } while (ksave0 != ksave1);



  return ksave0;

}

#define BLE_NVID_USER_CFG_START         0x80  //!< Start of the USER Configuration NV IDs

#define BLE_NVID_USER_CFG_END           0x89  //!< End of the USER Configuration NV IDs

bStatus_t GAPRole_SetParameter( uint16 param, uint8 len, void *pValue );

    uint8 initial_advertising_enable = TRUE;

GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &initial_advertising_enable );

static void simpleProfileChangeCB( uint8 paramID );

static void simpleBLECentral_HandleKeys( uint8 shift, uint8 keys )

{

  (void)shift;  // Intentionally unreferenced parameter



  if ( keys & HAL_KEY_UP )      // 向上

  {

    // Start or stop discovery

    if ( simpleBLEState != BLE_STATE_CONNECTED )    // 如果没有连接，开始扫描

    {

      if ( !simpleBLEScanning )

      {

        simpleBLEScanning = TRUE;

        simpleBLEScanRes = 0;



        LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );

        LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );



        GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,

                                       DEFAULT_DISCOVERY_ACTIVE_SCAN,

                                       DEFAULT_DISCOVERY_WHITE_LIST );

      }

      else

      {

        GAPCentralRole_CancelDiscovery();

      }

    }

    else if ( simpleBLEState == BLE_STATE_CONNECTED && // 如果连接并且发现Handle进行读写操作

              simpleBLECharHdl != 0 &&

              simpleBLEProcedureInProgress == FALSE )

    {

      uint8 status;



      // Do a read or write as long as no other read or write is in progress

      if ( simpleBLEDoWrite )

      {

        // Do a write

        attWriteReq_t req;



        req.handle = simpleBLECharHdl;

        req.len = 1;

        req.value[0] = simpleBLECharVal;

        req.sig = 0;

        req.cmd = 0;

        status = GATT_WriteCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );

      }

      else

      {

        // Do a read

        attReadReq_t req;



        req.handle = simpleBLECharHdl;

        status = GATT_ReadCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );

      }



      if ( status == SUCCESS )

      {

        simpleBLEProcedureInProgress = TRUE;

        simpleBLEDoWrite = !simpleBLEDoWrite;

      }

    }

  }



  if ( keys & HAL_KEY_LEFT )    // 左

  {

    // Display discovery results

    if ( !simpleBLEScanning && simpleBLEScanRes > 0 )   // 显示扫描到的设备

    {

        // Increment index of current result (with wraparound)

        simpleBLEScanIdx++;

        if ( simpleBLEScanIdx >= simpleBLEScanRes )

        {

          simpleBLEScanIdx = 0;

        }



        LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1,

                                10, HAL_LCD_LINE_1 );

        LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ),

                          HAL_LCD_LINE_2 );

    }

  }



  if ( keys & HAL_KEY_RIGHT )   // 右

  {

    // Connection update

    if ( simpleBLEState == BLE_STATE_CONNECTED )    // 如果连接，则更新连接

    {

      GAPCentralRole_UpdateLink( simpleBLEConnHandle,

                                 DEFAULT_UPDATE_MIN_CONN_INTERVAL,

                                 DEFAULT_UPDATE_MAX_CONN_INTERVAL,

                                 DEFAULT_UPDATE_SLAVE_LATENCY,

                                 DEFAULT_UPDATE_CONN_TIMEOUT );

    }

  }



  if ( keys & HAL_KEY_CENTER )  // 中间键

  {

    uint8 addrType;

    uint8 *peerAddr;



    // Connect or disconnect

    if ( simpleBLEState == BLE_STATE_IDLE )     // 空闲则连接

    {

      // if there is a scan result

      if ( simpleBLEScanRes > 0 )

      {

        // connect to current device in scan result

        peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr;

        addrType = simpleBLEDevList[simpleBLEScanIdx].addrType;



        simpleBLEState = BLE_STATE_CONNECTING;



        GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,

                                      DEFAULT_LINK_WHITE_LIST,

                                      addrType, peerAddr );



        LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 );

        LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );

      }

    }

    else if ( simpleBLEState == BLE_STATE_CONNECTING ||     // 连接则断开连接

              simpleBLEState == BLE_STATE_CONNECTED )

    {

      // disconnect

      simpleBLEState = BLE_STATE_DISCONNECTING;



      gStatus = GAPCentralRole_TerminateLink( simpleBLEConnHandle );



      LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 );

    }

  }



  if ( keys & HAL_KEY_DOWN )        // 下

  {

    // Start or cancel RSSI polling

    if ( simpleBLEState == BLE_STATE_CONNECTED )    // 连接则读取RSSi的值

    {

      if ( !simpleBLERssi )

      {

        simpleBLERssi = TRUE;

        GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD );

      }

      else

      {

        simpleBLERssi = FALSE;

        GAPCentralRole_CancelRssi( simpleBLEConnHandle );



        LCD_WRITE_STRING( "RSSI Cancelled", HAL_LCD_LINE_1 );

      }

    }

  }

}