加入升级代码，但是空间不够 先提交一下 改为分成两个app 由boot来进行跳转

WXK

2 天以前 da80b96a9d0f2f9dc6e23d1a1830cc2384f2bd0b

 keil/include/drivers/serial_at_cmd_app.c

@@ -275,226 +275,6 @@
    uart_send(UART_ID0, send_frame,8, NULL);   
}
uint16_t pack_checksum_test=0,test_calculate = 0; 
void Usart3ParseDataHandler(uint8_t data)//UART蓝牙数据分析处理
{
      // 全局变量
static Usart0ReceiveState usart0_receive_state = Usart0ReceiveWaitHead0;

static uint8_t index = 0;               // 缓冲区索引
static uint8_t pack_cmd_type = 0;       // 指令类型
static uint8_t pack_msg_type = 0;       // 消息类型
static uint8_t pack_data_len = 0;       // 数据长度
static uint8_t pack_param_addr = 0;     // 参数地址
static uint16_t pack_checksum = 0;      // 接收到的校验和
static uint16_t calculated_checksum = 0; // 计算得到的校验和
static uint8_t send_frame[256];  // 用于计算校验和的帧
static uint8_t frame_index = 0;  // 帧缓冲区索引
static uint8_t pack_datalen = 0;
    
    switch(usart0_receive_state) {
        case Usart0ReceiveWaitHead0:
            if(data == 0x55) {
                usart0_receive_state = Usart0ReceiveWaitHead1;
                // 初始化帧缓冲区
                frame_index = 0;
                send_frame[frame_index++] = data;
            }
            break;
            
        case Usart0ReceiveWaitHead1:
            if(data == 0xAA) {
                usart0_receive_state = Usart0ReceiveWaitCmdType;
                send_frame[frame_index++] = data;
            } else {
                usart0_receive_state = Usart0ReceiveWaitHead0;
            }
            break;
            
        case Usart0ReceiveWaitCmdType:
            if(data == 64) {
                pack_cmd_type = data;
                usart0_receive_state = Usart0ReceiveWaitMsgType;
                send_frame[frame_index++] = data;
            } else {
                usart0_receive_state = Usart0ReceiveWaitHead0;
            }
            break;
            
        case Usart0ReceiveWaitMsgType:
            if(data == 0x2||data==0x1||data==0x3) {  // 读写回复消息类型
                pack_msg_type = data;
                usart0_receive_state = Usart0ReceiveWaitDataLen;
                send_frame[frame_index++] = data;
            } else {
                usart0_receive_state = Usart0ReceiveWaitHead0;
            }
            break;
            
        case Usart0ReceiveWaitDataLen:
            pack_data_len = data;
            index = 0;
            usart0_receive_state = Usart0ReceiveWaitParamAddr;
            send_frame[frame_index++] = data;
            break;
            
        case Usart0ReceiveWaitParamAddr:
            pack_param_addr = data;
                  if(pack_msg_type==CMD_READ)
                  {
                     usart0_receive_state = Usart0ReceiveWaitChecksum1;
                     pack_datalen=pack_data_len-6;
                  }else{
                     usart0_receive_state = Usart0ReceiveWaitData;
                  }
            send_frame[frame_index++] = data;
            break;
            
        case Usart0ReceiveWaitData:
                     send_frame[frame_index++] = data;
                  mUsart2ReceivePack[index++] = data;
            
                     if(index == pack_data_len-6) {
                usart0_receive_state = Usart0ReceiveWaitChecksum1;
                        pack_datalen=pack_data_len-6;
              }
            break;
            
        case Usart0ReceiveWaitChecksum1:
            pack_checksum = data << 8;  // 高字节
                  pack_checksum_test = data << 8;  // 高字节
                  send_frame[frame_index++] = data;
               usart0_receive_state = Usart0ReceiveWaitChecksum2;
                  break;
            case Usart0ReceiveWaitChecksum2:
            pack_checksum |= data;  // 低字节
            pack_checksum_test |= data;  // 低字节
            // 计算校验和 (从第3个字节开始，长度为4+数据长度)
                  if(pack_msg_type!=CMD_READ)
            {
                  calculated_checksum = Checksum_u16(&send_frame[2],pack_datalen+4);
                  }else{
                  calculated_checksum = Checksum_u16(&send_frame[2],4);
                  }
            test_calculate=calculated_checksum;
            // 验证校验和
            if(pack_checksum == calculated_checksum) {
                // 校验通过，处理数据
                           switch(pack_msg_type)
                              {	
                              //case CMD_REPLY:
                              case CMD_WRITE:
                                 //从mUsartReceivePack中读取pack_length长度的字节，放到全局变量中,赋值保存的参数并且存入flash
										
                                 memcpy((uint8_t*)&g_com_map + pack_param_addr*2, mUsart2ReceivePack, pack_datalen);
										
                                 //返回一个error状态
                                 //SendComMap(pack_datalen,pack_index);
                                 save_com_map_to_flash();
                                 //delay_ms(100);
//                                 NVIC_SystemReset();
                                 break;
                              case CMD_READ:
                                       uart0_send_ComMap_to_BLE(pack_datalen,pack_param_addr);	
											
                                 break;
//                              case CMD_REPLY:
//                                 memcpy((uint8_t*)&g_com_map + pack_param_addr, mUsart2ReceivePack, pack_datalen);
//                                 save_com_map_to_flash();
//                                 break;
                              default:
                                 break;
                           }
            }
            
            // 重置状态机
            usart0_receive_state = Usart0ReceiveWaitHead0;
            index = 0;
            frame_index = 0;
            break;
            
        default:
            usart0_receive_state = Usart0ReceiveWaitHead0;
            index = 0;
            frame_index = 0;
            break;
    }

	
//   if(usart_receive_state == UsartReceiveWaitChecksum) {         //若收到校验和包
//      checksum = 0;
//      for(int i = 0; i<pack_length-5; i++) { 
//         checksum += mUsart2ReceivePack[i];
//      }
//      checksum += pack_cmd;
//      checksum += pack_length;
//      checksum += pack_index;
//      checksum += pack_datalen;
//      checksum += pack_msgtype;
//      if(((data + checksum)&0xff) == 0xFF)            //校验通过
//      {
//         switch(pack_cmd)
//         {
//            case CMD_WRITE:
//               //从mUsartReceivePack中读取pack_length长度的字节，放到全局变量中,赋值保存的参数并且存入flash
//            enable_sleep_count=0;
//               memcpy((uint8_t*)&g_com_map + pack_index, mUsart2ReceivePack, pack_datalen);
//				
//               if(mUsart2ReceivePack[0]==1)
//          UpdateProcess(pack_index);
//               //返回一个error状态
//               //SendComMap(pack_datalen,pack_index);
//               save_com_map_to_flash();
//               //delay_ms(100);
//               //NVIC_SystemReset();
//               break;
//            case CMD_READ:
//               //read包中data字节，即mUsartReceivePack[0]表示数据长度；
//            //从g_com_data结构体中的第index位置读取长度为mUsartReceivePack[0]的字节，发送出来
//               SendComMap0(pack_datalen,pack_index>>1);		
//               break;
//            default:
//               break;
//         }
//      }
//      usart_receive_state = UsartReceiveWaitHead0;
//      pack_index = 0;
//      pack_length = 0;
//      index=0;
//   } else if((usart_receive_state == UsartReceiveWaitData) ) {   //若果收到的是正常通讯包
//      mUsart2ReceivePack[index] = data;
//      index++;
//      if(index == pack_length-5) {      //如果收到的index与长度相等
//         usart_receive_state = UsartReceiveWaitChecksum;
//      }
//   } else if(usart_receive_state == UsartReceiveWaitDataLen) {                  //收到指令类型字节
//      pack_datalen = data;
//      usart_receive_state = UsartReceiveWaitData;
//   }else if(usart_receive_state == UsartReceiveWaitIndex) {                  //收到指令类型字节
//      pack_index = data;
//      usart_receive_state = UsartReceiveWaitDataLen;
//   } else if(usart_receive_state == UsartReceiveWaitCMD) {                     //收到指令类型字节
//      pack_cmd = data;
//      usart_receive_state = UsartReceiveWaitIndex;
//   } else if(usart_receive_state == UsartReceiveWaitLength) {                  //收到长度字节
//		
//         pack_length = data;
//         pack_index = 0;			
//         usart_receive_state = UsartReceiveWaitCMD;
//		
//   } else if((usart_receive_state == UsartReceiveWaitHead0) && (data == 0x55)) {   //收到第一个包头
//      usart_receive_state = UsartReceiveWaitHead1;
//   } else if((usart_receive_state == UsartReceiveWaitHead1) && (data == 0xAA)) {   //收到第二个包头
//      usart_receive_state = UsartReceiveWaitMsgType;
//   }else if ((usart_receive_state == UsartReceiveWaitMsgType) && (data == 0x3)) {
//      usart_receive_state = UsartReceiveWaitLength;
//      pack_msgtype = data;
//   }
//   else {
//      usart_receive_state = UsartReceiveWaitHead0;
//      pack_index = 0;
//      pack_length = 0;
//   }
}
extern uint16_t set_mk_time;
void Send_Reply_To_Ble(void)
{
@@ -525,6 +305,44 @@
   uart_send(UART_ID0, send_frame,12, NULL);   
   uart_send(UART_ID1, send_frame,12, NULL);
}
void mk_send_updata_to_BLE(void)
{
static uint8_t send_frame[100];
   uint16_t checksum = 0;
   send_frame[0] = 0x55;
   send_frame[1] = 0xAA;
   send_frame[2] = 0x40;
   send_frame[3] = CMD_MK_TO_BLE;
   send_frame[4]=8;//数据长度
   send_frame[5]=0xcc;
   send_frame[6]=0xcc;
   send_frame[7]=0;
   memcpy(&send_frame[8],&set_mk_time,2);
   checksum=Checksum_u16(&send_frame[2],8);
   memcpy(&send_frame[10],&checksum,2);
      //LOG_INFO(TRACE_MODULE_APP,"发给ble的checksum %#x\r\n",checksum);
   uart_send(UART_ID0, send_frame,12, NULL);	
   uart_send(UART_ID1, send_frame,12, NULL);
}
void mk_send_offupdata_to_BLE(void)
{
static uint8_t send_frame[100];
   uint16_t checksum = 0;
   send_frame[0] = 0x55;
   send_frame[1] = 0xAA;
   send_frame[2] = 0x40;
   send_frame[3] = CMD_MK_TO_BLE;
   send_frame[4]=8;//数据长度
   send_frame[5]=0xcc;
   send_frame[6]=0xcd;
   send_frame[7]=0;
   memcpy(&send_frame[8],&set_mk_time,2);
   checksum=Checksum_u16(&send_frame[2],8);
   memcpy(&send_frame[10],&checksum,2);
      //LOG_INFO(TRACE_MODULE_APP,"发给ble的checksum %#x\r\n",checksum);
   uart_send(UART_ID0, send_frame,12, NULL);	
   uart_send(UART_ID1, send_frame,12, NULL);
}
extern uint8_t bat_percent;
extern uint32_t dev_id;