nrf52810蓝牙芯片led应用组件，句柄操作led 亮灭，包括大数据传输和flash读写操作

#include  "uart_big_data.h"
#include  "ble_nus.h"  




#define  BIG_DATA_HEADER     0x48
#define  UART_FRAME_LENTH    20
#define  SERIAL_NUM_SIZE     2
#define  HEADER_SIZE         1
#define  START_SERIAL_NUM    1
#define  FILL_BOX_NUM        100
#define  START_MAX_SERIAL    100
#define  BIG_DATA_RX_CMD     BIG_DATA_HEADER
#define  BIG_DATA_START_CMD    0x4A
#define  BIG_DATA_END_CMD      0x49
#define  FRAME_PUT_IN_MAX_NUM  100


static  uint8_t  BigDataRxStatus = 0;
static  uint8_t  FrameFillSerial = START_SERIAL_NUM;  
static  uint8_t  FrameFillIndex  = 0;


static  uint8_t  InvalidUartFrameNum;
static  uint8_t  InvalidUartFramePos[FILL_BOX_NUM];
static  uint8_t  BigDataCmdSta;
static  bool  BigDataBleTxStart;




#define  BLE_TX_DATA_MAX_SIZE    20
#define  BLE_REPLY_SIZE          15


#define  CENTRAL_BIG_DATA_RX_START_CMD    0x4D
#define  CENTRAL_BIG_DATA_RX_END_CMD      0x4E
#define  CENTRAL_BIG_DATA_RX_PROGRE_CMD   0x4F




#define  BIG_DATA_START_EVT    1
#define  BIG_DATA_SEND_EVT     2




typedef  struct
{
uint8_t  CentralBleBigDataRxCmdType;
    uint8_t  CentralBleTxStoreBuf[BLE_TX_DATA_MAX_SIZE];
 uint16_t CentralBleRxBytes;
 uint8_t  CentralBleReply[BLE_REPLY_SIZE];
 uint8_t  CentralReplyLenth;
}BleBigDataTx_t;


static BleBigDataTx_t   BleBigDataTx;




void  UartBigDataRxHandle(uint8_t *UartFrameData, uint8_t *RxStaCtrlType)
{
   uint8_t   i;
   uint16_t  CurSerialNum;
   bool  IsFrameHeadOk = true;
   uint8_t  UartBigDataFrame[UART_FRAME_LENTH];
   
   if(UartFrameData[0] != BIG_DATA_HEADER)
{
printf("\r\nbig data frame header error  0x48 is ok\r\n");
 IsFrameHeadOk  = false;
}


i = 0;
      while(UartFrameData[i] != '\n')
      {
i++;
}


      if(i != (GetUartFrameDataLenth() + SERIAL_NUM_SIZE + HEADER_SIZE))
      {
printf("\r\n uart frame lenth error  23 bytes is ok\r\n");
 return;
}

if(IsFrameHeadOk == false)
{
return;
}

CurSerialNum = (((uint16_t)UartFrameData[1]) << 8) | ((uint16_t)UartFrameData[2]);

switch(BigDataRxStatus)
      {
case  0: 
if(CurSerialNum != FrameFillSerial)
{
printf("\r\nstart frame serial number error\r\n");
   return;
}
else
{
   printf("\r\nUart frame buffer fill in ok\r\n");
   SetUartFrameInvalidPosSeriNum(FrameFillIndex, CurSerialNum);
   memcpy(UartBigDataFrame, &UartFrameData[3], sizeof(UartBigDataFrame));
   FillUartFrameToCorrectAdd(FrameFillIndex, UartBigDataFrame);
   SetCurMaxFrameSeriNum(CurSerialNum);
   SetCurTxFrameSerial(START_SERIAL_NUM);
   
   FrameFillIndex++;
   FrameFillSerial++;
   
   if(FrameFillIndex >= FILL_BOX_NUM)
{
FrameFillIndex  = 0;
 FrameFillSerial = START_SERIAL_NUM;
 BigDataRxStatus = 1;
 SetCurMaxFrameSeriNum(START_MAX_SERIAL);
 SetCurTxFrameSerial(START_SERIAL_NUM);
 *RxStaCtrlType  = 2;
}
}
break;
 
case  1:
 
  if(GetCurMaxFrameSeriNum() >= GetUartFrameMaxRxSeri())
{
printf("\r\nUart frame Rx  should be end\r\n");
   *RxStaCtrlType  = 1;
   break;
}
memset(InvalidUartFramePos, 0, sizeof(InvalidUartFramePos));
  InvalidUartFrameNum  = 0;
GetUartFrameTransferInPrama(&InvalidUartFrameNum, InvalidUartFramePos);

  if(InvalidUartFrameNum > 0)
{
if(CurSerialNum == (GetCurMaxFrameSeriNum()+1))
{
 printf("\r\nUart Rx Handle Enable\r\n");
SetCurMaxFrameSeriNum(CurSerialNum);
 SetUartFrameInvalidPosSeriNum(InvalidUartFramePos[0],CurSerialNum); 
 InvalidUartFrameNum--;
 memcpy(UartBigDataFrame, &UartFrameData[3], sizeof(UartBigDataFrame));
 FillUartFrameToCorrectAdd(InvalidUartFramePos[0], UartBigDataFrame);
 if(InvalidUartFrameNum != 0)
{
BigDataRxStatus  = 2;
 for(i = 0; i < InvalidUartFrameNum; i++)
 {
InvalidUartFramePos[i] = InvalidUartFramePos[i+1];
}
}
}
else
{
printf("\r\nUart frame serial number error\r\n");
}
}
else
{
   prinrf("\r\nNo Memory for Uart Rx, Tx On Busy\r\n");
}
break;  
 
case  2:
 
   if(GetCurMaxFrameSeriNum() >= GetUartFrameMaxRxSeri())
{
printf("\r\nUart frame Rx  should be end\r\n");
 *RxStaCtrlType  = 1;
   break;
}
 
if(CurSerialNum == (GetCurMaxFrameSeriNum()+1))
{
printf("\r\nUart Rx Handle Enable\r\n");
SetCurMaxFrameSeriNum(CurSerialNum);
 SetUartFrameInvalidPosSeriNum(InvalidUartFramePos[InvalidUartFrameNum - 1],CurSerialNum); 
 memcpy(UartBigDataFrame, &UartFrameData[3], sizeof(UartBigDataFrame));
 FillUartFrameToCorrectAdd(InvalidUartFramePos[InvalidUartFrameNum - 1], UartBigDataFrame);
 InvalidUartFrameNum--;
 if(InvalidUartFrameNum == 0)
{
BigDataRxStatus  = 1;
}
}
else
{
printf("\r\nUart frame serial number error\r\n");
}
break;
}
}








void   BigDataHandleInit(void)
{
BigDataRxStatus   = 0;
   FrameFillSerial   = START_SERIAL_NUM;
   FrameFillIndex    = 0;
   BigDataBleTxStart = false;
}








void   UartBigDataCmdProcess(const uint8_t *UartFrameCmdDat)
{
   uint8_t  RxStaCtrlType = 0;
   uint8_t  i;
   

   switch(BigDataCmdSta)
{
case  0:
if(UartFrameCmdDat[0] == BIG_DATA_START_CMD)
{
   if((CurUartFrameCanPutInNum() == FRAME_PUT_IN_MAX_NUM) && (GetLastUartFrameTxSta()))
{
BigDataCmdSta  = 1;
printf("\r\nBig data Uart frame can start rx\r\n");
InitUartBigDataAppParma();
BigDataHandleInit();
}
else
{
printf("\r\nBig data buffer busy on tx\r\n");
}
}
else
{
printf("\r\nBig data start rx cmd error\r\n");
}
break;
 
case  1:
if(UartFrameCmdDat[0] == BIG_DATA_RX_CMD)
{
UartBigDataRxHandle(UartFrameCmdDat, &RxStaCtrlType);
 
   if(RxStaCtrlType == 1)
{
BigDataCmdSta  = 2;
   printf("\r\nPlease let rx end\r\n");
   SetUartFrameRxFinish();
 }
else if(RxStaCtrlType == 2)
{
//启动蓝牙向手机发送大数据命令
 BigDataBleTxStart  = true;
 BigDataTaskAction(BIG_DATA_START_EVT, 10);
}
}
else if(UartFrameCmdDat[0] == BIG_DATA_END_CMD)
{
   if(UartFrameCmdDat[1] == 0)
{
SetLastUartFrameTxSta(1);
}
else if((UartFrameCmdDat[1] != 0) && (UartFrameCmdDat[1] <= GetUartFrameDataLenth()))
{
StoreLastUartFrameTxData(UartFrameCmdDat[1], &UartFrameCmdDat[2]);
 SetLastUartFrameTxSta(0);
}
BigDataCmdSta = 0;
SetUartFrameRxFinish();

if(BigDataBleTxStart == false)
{
 //启动蓝牙向手机发送大数据命令
BigDataBleTxStart  = true;
 BigDataTaskAction(BIG_DATA_START_EVT, 10);
}
}
else
{
printf("\r\nbig data frame header error  0x48 is ok\r\n");
}
break;
 
case  2:
if(UartFrameCmdDat[0] == BIG_DATA_END_CMD)
{
if(UartFrameCmdDat[1] == 0)
{
SetLastUartFrameTxSta(1);
}
else if((UartFrameCmdDat[1] != 0) && (UartFrameCmdDat[1] <= GetUartFrameDataLenth()))
{
StoreLastUartFrameTxData(UartFrameCmdDat[1], &UartFrameCmdDat[2]);
   SetLastUartFrameTxSta(0);
}
BigDataCmdSta = 0;
}
else
{
printf("\r\nbig data end command error \r\n");
}
break;
}
}








void  big_data_evt_create(void)
{
uint32_t err_code;

   err_code = app_timer_create(&BigDataClock, APP_TIMER_MODE_SINGLE_SHOT, BigDataStartHandle);
   APP_ERROR_CHECK(err_code);

   err_code = app_timer_create(&BigDataTxClock, APP_TIMER_MODE_SINGLE_SHOT, BigDataTxProgreHandle);
   APP_ERROR_CHECK(err_code);
}






void  BigDataTaskAction(uint8_t TaskId, uint16_t TaskDelay)
{
   uint32_t err_code;
switch(TaskId)
{
 case  BIG_DATA_START_EVT:
 err_code = app_timer_start(BigDataClock, APP_TIMER_TICKS(TaskDelay), NULL);
     APP_ERROR_CHECK(err_code);
 break;

case  BIG_DATA_SEND_EVT:
 err_code = app_timer_start(BigDataTxClock, APP_TIMER_TICKS(TaskDelay), NULL);
     APP_ERROR_CHECK(err_code);
 break;
}
}






void  BigDataTaskStop(uint8_t TaskId)
{
uint32_t err_code;
   switch(TaskId)
{
case  BIG_DATA_START_EVT:
err_code  = app_timer_stop(&BigDataClock);
   APP_ERROR_CHECK(err_code);
   break;

case  BIG_DATA_SEND_EVT:
 err_code  = app_timer_stop(&BigDataTxClock);
   APP_ERROR_CHECK(err_code);
   break;
}
}








void BigDataStartHandle(void * p_context)
{
   uint32_t err_code;

   BleBigDataTx.CentralBleBigDataRxCmdType  = CENTRAL_BIG_DATA_RX_START_CMD;
memset(BleBigDataTx.CentralBleTxStoreBuf, 0, sizeof(BleBigDataTx.CentralBleTxStoreBuf));
BleBigDataTx.CentralBleTxStoreBuf[0] = BleBigDataTx.CentralBleBigDataRxCmdType;
   BleBigDataTx.CentralBleRxBytes  =  1;

   if(Tx_Rx_Nux.conn_handle != BLE_CONN_HANDLE_INVALID)
{
err_code = BleAirDataTxStartCmdSend(&BleBigDataTx);

 if ( (err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY) )
{
APP_ERROR_CHECK(err_code);
}

if(err_code  == NRF_SUCCESS)
{
BigDataTaskAction(BIG_DATA_START_EVT, 10000);
 FillBigDataReplyString("startcmdok",  sizeof("startcmdok") - 1);
}
   else if(err_code == NRF_ERROR_BUSY)
{
BigDataTaskAction(BIG_DATA_START_EVT, 10);
}
}
else
{
BigDataTaskAction(BIG_DATA_START_EVT, 5000);
}
}






void  BigDataTxProgreHandle(void * p_context)
{
   uint16_t  CurTxFrame;
      uint8_t   CurTxFrameOperaAddr;
      uint32_t  err_code;  

if(Tx_Rx_Nux.conn_handle != BLE_CONN_HANDLE_INVALID)
{
  if(!IsUartFrameArriveEnd())
{
  CurTxFrame  =  GetCurTxFrameSerial();
if(CurTxFrame <= GetCurMaxFrameSeriNum())
{
CurTxFrameOperaAddr  =  GetUartFrameDataTabOperaAddr(CurTxFrame);
   memset(BleBigDataTx.CentralBleTxStoreBuf, 0, sizeof(BleBigDataTx.CentralBleTxStoreBuf));
   GetUartFrameFromDataTab(CurTxFrameOperaAddr, BleBigDataTx.CentralBleTxStoreBuf);
   BleBigDataTx.CentralBleRxBytes  = sizeof(BleBigDataTx.CentralBleTxStoreBuf);
   err_code = BleAirDataTxStartCmdSend(&BleBigDataTx);
 
   if ( (err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY) )
{
APP_ERROR_CHECK(err_code);
}

if(err_code  ==  NRF_SUCCESS)
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 10000);
   FillBigDataReplyString("sendframeok",  sizeof("sendframeok") - 1);
}
else if(err_code  == NRF_ERROR_BUSY)
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 10);
}
}
else
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 300);
}
}
else
{
CurTxFrame  =  GetCurTxFrameSerial();
   if(CurTxFrame == (GetCurMaxFrameSeriNum()+1))
{
if(GetLastUartFrameTxSta() == 0)  //最后一帧有数据要发
{
memset(BleBigDataTx.CentralBleTxStoreBuf, 0, sizeof(BleBigDataTx.CentralBleTxStoreBuf));
   GetLastUartFrameTxParma(&BleBigDataTx.CentralBleRxBytes, BleBigDataTx.CentralBleTxStoreBuf);
   err_code = BleAirDataTxStartCmdSend(&BleBigDataTx);

   if ( (err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY) )
       {
     APP_ERROR_CHECK(err_code);
       }

if(err_code == NRF_SUCCESS)
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 10000);
 FillBigDataReplyString("endframeok",  sizeof("endframeok") - 1);
}
else if(err_code  == NRF_ERROR_BUSY)
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 10);
}
}
}
else
{
CurTxFrameOperaAddr  =  GetUartFrameDataTabOperaAddr(CurTxFrame);
   memset(BleBigDataTx.CentralBleTxStoreBuf, 0, sizeof(BleBigDataTx.CentralBleTxStoreBuf));
   GetUartFrameFromDataTab(CurTxFrameOperaAddr, BleBigDataTx.CentralBleTxStoreBuf);
   BleBigDataTx.CentralBleRxBytes  = sizeof(BleBigDataTx.CentralBleTxStoreBuf);
   err_code = BleAirDataTxStartCmdSend(&BleBigDataTx);
   
   if ( (err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY) )
 {
APP_ERROR_CHECK(err_code);
 }

if(err_code  ==  NRF_SUCCESS)
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 10000);
    FillBigDataReplyString("sendframeok",  sizeof("sendframeok") - 1);
}
else if(err_code  == NRF_ERROR_BUSY)
 {
BigDataTaskAction(BIG_DATA_SEND_EVT, 10);
 }
}
}
}
else
{
BigDataTaskAction(BIG_DATA_SEND_EVT, 2000);
}
}




void  FillBigDataReplyString(uint8_t *ReplyStr,  uint8_t FillSize)
{
   memset(BleBigDataTx.CentralBleReply, 0, sizeof(BleBigDataTx.CentralBleReply));
memcpy(BleBigDataTx.CentralBleReply, ReplyStr, FillSize);
   BleBigDataTx.CentralReplyLenth  = FillSize;
}






void  BleBigDataReplyProcess(void)
{
   uint16_t  CurTxFrame;

 if(strncmp(APP_ReceiveData, BleBigDataTx.CentralBleReply, BleBigDataTx.CentralReplyLenth) == 0)
{
if(strncmp(BleBigDataTx.CentralBleReply, "startcmdok", sizeof("startcmdok") - 1) == 0)
{