作為通用的物聯網設備，由于用戶需求各不相同，不少用戶有一些個性化的定制要求；

設備所對接的傳感器協議也多種多樣，比如Modbus讀寫參數的數據類型，某些物理量需要特殊的數據類型；

甚至可能還存在意想不到的bug。

因此，遠程升級的功能對于設備來說必不可少。

遠程固件升級需要解決以下問題：

1)設備的遠程訪問

當設備被安裝于局域網內部時，位于遠程的固件升級軟件工具無法穿透路由器訪問設備。

2)固件的分包以及傳送

由于設備的處理器資源有限，無法移植開源的http、FTP等協議棧，無法通過http、FTP等協議從服務器上下載固件，而需要自己實現代碼，采用TCP協議進行固件包的發送；

而且對于幾十k甚至上百k的固件，需要將固件拆成幾百個字節的數據包，逐一發給設備；

4)固件的有效性檢驗

固件在傳輸過程中，難免會出現錯誤。

比如WiFi模塊，或者是ethernet模塊將數據通過uart轉發給處理器時，如果有干擾、數據可能被破壞；

或者是處理器太忙，來不及接收數據，導致固件包丟失數據；

如果不對固件進行有效性檢驗，將被破壞的固件升級進控制器，會導致設備變磚而無法使用；

5)bootloader程序

bootloader程序需要下載固件的有效性檢驗，程序的擦除、固件數據從備份區到程序區的搬移。

6)處理器的固件升級軟件實現

軟件需要實現數據包接收，固件有效性驗證、存儲，數據應答等。

遠程固件升級系統架構

遠程固件升級系統架構

設備作為TCP客戶端連接到云服務器上的TCP服務端，定時發送心跳，維護連接，從而實現TCP的長鏈接。

在PC電腦上開發遠程升級工具，作為TCP客戶端與云服務器上的TCP服務器建立連接；

當需要遠程升級時，通過PC工具向云服務器發送消息，所發消息中包括了遠程設備的設備編號，以及PC工具的設備編號；

服務器收到消息之后，根據消息中的目標設備編號，從其維護的長鏈接中找到與該編號對應的鏈接，通過該鏈接向設備轉發該消息；

設備收到消息之后，對消息中的固件包進行有效性驗證，如果有效，則寫入到固件暫存區，并回復成功，否則回復失敗。

一些設計要點

處理器的存儲空間安排：

以STM32F103RCT6為例，該處理器有256KByte的FLASH空間；

4KByte的空間用于bootloader程序。

52KByte用于存儲用戶數據；

剩余的FLASH空間一半作為程序存儲區，一半作為固件暫存區，程序必須小于100KByte。

固件的生成與分包

在Keil中，將程序的memory的起始地址設置為0x8001000，大小設置為0x19000。

同時，設置運行fromelf.exe，使得編譯程序時自動生成用于固件升級的bin文件。

Keil設置

通過delphi將生成出來的bin文件讀入，并采用下述代碼進行發包，加上協議頭以及CRC32的校驗值。

pkgs := stream.Size div perpage;
  rem := stream.Size mod perpage;
  addr := 0;
  if(rem > 0) then
  begin
    pkgs := pkgs + 1;
  end;
  strcrc := '';
  for i:= 0 to (pkgs - 1) do
  begin
       curlen := perpage;
       if((i + 1) * perpage > bytecount) then
       begin
          curlen := bytecount - (i * perpage);
       end;
       payload :=  inttohex(i* perpage, 8)+inttohex(curlen, 8);      //
       stream.Position := i * perpage;
       k := 0;
       tmpstr := '';
       for j:= 0 to (curlen - 1) do
       begin
        stream.Read(val, 1);
        if((k and 1) = 0)  then
        begin
          tmpstr := inttohex(val, 2);
        end
        else
        begin
          tmpstr := inttohex(val, 2) + tmpstr;
        end;
        inc(k);
        if((k and 1) = 0)  then
        begin
          payload := payload + tmpstr;
        end;
       end;
       tempcrc :=  crc(payload);
       payload := tempcrc +payload;
       payload := inttohex((2 + 4 + 4 + perpage) * i, 8) + payload;
       payload := '01'+payload;
       strcrc := strcrc + tempcrc;
       payload := payload + crc(payload);;
       str := header+'&msgid='+inttostr(msgid)+'&length='+inttostr(1 + 2 + 4 + 4 + 4 + 2+ curlen)+'&cmd='+payload;
       inc(msgid);
       strcommands.Add(str);
  end;

固件的有效性驗證以及升級的可靠性保證

整個固件包根據處理器的資源拆分為500個byte一個數據包；

每一個數據包都計算CRC32的數值并加入數據包中；

所以CRC32的數值再計算一遍CRC32數值并放入開始升級的命令之中；

控制器收到固件之后，重新計算500個byte的CRC32的計算值并與收到的CRC32值進行比對，只有兩者相等時才存入暫存區；

當收到所有數據包時，從暫存區中按包讀出固件，計算CRC32值與同時存儲的CRC32值比對，同時計算所有CRC32數值的CRC32數值，與開始升級的命令中所攜帶的數值比對。

只有所有CRC32的數值都相同的情況下，應用程序才將升級程序的標志位寫入到FLASH中，并重啟處理器進入bootloader程序。

bootloader程序從FLASH中讀取到升級程序的標志，則從暫存區中按包讀取數據，進行同樣的CRC32的驗證過程，確保無誤的情況下，將暫存區中的固件搬移到程序區。

全部程序搬移完之后，再逐個字節比較暫存區以及程序區的內容。

比對時，再檢驗CRC32是否正確。

只有CRC32數值正確并且與程序區的數據都相等的情況下，才清空升級程序的標志，完成升級過程。

升級程序的步驟及代碼

步驟1：PC工具發送清空暫存區的命令，將暫存區的內存都擦寫成0xff。

步驟2：PC工具發送寫固件數據包的命令，處理器收到之后，進行有效性驗證，并寫入暫存區，重復該過程，完成整個固件的發送。

步驟3：PC工具發送開始升級的命令，處理器收到之后，再進行一次有效性驗證，并重啟，進入bootloader程序。

步驟4：bootloader程序進行有效性驗證之后，將暫存區的固件搬移至程序區，完成升級；

代碼如下：

U32 data, value, dataB;
U8 res = FALSE;
U8 flag;
U16 pointer;
U16 len;

U8 *ins = lins + AP_ID_HEX_BYTE;

if(fnCRC16_Check(lins, llen)){
  len = 0;
  if(llen >= AP_ID_HEX_BYTE){
    len = llen - AP_ID_HEX_BYTE;
  }
  if(inscode == FM_OPERATECODE_START){
    if(fmups.m_uchState == FM_STATE_IDLE){
      if(len == (1 + 4 + FM_STARTCODE_LEN + 2 )){

        if(fnFM_IsStartStopValid(&ins[1 + 4])){
          data = (U32)ins[1] << 24;	
          data |= (U32)ins[2] << 16;
          data |= (U32)ins[3] << 8;
          data |= (U32)ins[4];
          if(data < FLASH_ROM_SIZE_FIRMWARE){
            fmups.m_uchState = FM_STATE_INIT;
            fmups.m_ulLen = data;
            fmups.m_uiTimer = FM_STATE_TIME;
            res = TRUE;
          }
        }
      }
    }
  }
  else if(inscode == FM_OPERATECODE_DOWNLOAD){

    if(fmups.m_uchState == FM_STATE_DOWNLOAD){

      if((len > (1 + 4 + 2 + 4 + 4 + 2))
         && (len <= (1 + 4 + 2 + 4 + 4 + 2 + FM_DOWNLOAD_EVERYMSG))){

        data = (U32)ins[1] << 24;	
        data |= (U32)ins[2] << 16;
        data |= (U32)ins[3] << 8;
        data |= (U32)ins[4];

        value = (U32)ins[7] << 24;	
        value |= (U32)ins[8] << 16;
        value |= (U32)ins[9] << 8;
        value |= (U32)ins[10];

        dataB = (U32)ins[11] << 24;	
        dataB |= (U32)ins[12] << 16;
        dataB |= (U32)ins[13] << 8;
        dataB |= (U32)ins[14];

        flag = TRUE;
        if(value != fmups.m_uchPointer){
          flag = FALSE;
          if((value + dataB) == fmups.m_uchPointer){
            res = TRUE;
          }
        }
        if(data >= (FLASH_ROM_SIZE_FIRMWARE - (FM_DOWNLOAD_EVERYMSG + 4+ 4 + 2))){
          flag = FALSE;
        }
        if(dataB > FM_DOWNLOAD_EVERYMSG){
          flag = FALSE;
        }
        if((fmups.m_uchPointer + dataB) > fmups.m_ulLen){
          flag = FALSE;
        }
        if(flag){
          if(value == fmups.m_uchPointer){
            res = fnFL_WriteBytesAndCheck(data + FLASH_ROM_ADDR_FIRMWARE, (2 + 4 + 4 + dataB), &ins[5]);
            if(res){
              fmups.m_uchPointer += dataB;
            }
          }else{
            res = TRUE;
          }
        }
      }
    }
  }
  else if(inscode == FM_OPERATECODE_STOP){
    if(len == (1 + 2 + 2 + FM_STARTCODE_LEN)){
      if(fnFM_IsStartStopValid(&ins[3])){
        if(fmups.m_uchState == FM_STATE_COMPLETE){
          if(fnFM_Check(ins[1], ins[2])){
            res = fnFM_ProCon(ins[1], ins[2]);
            if(res){
              fmups.m_uchReStartTimer = 10;
            }
          }

        }
      }
    }
  }
  else if(inscode == FM_OPERATECODE_RESET){
    if(len == (1 + 2 + FM_STARTCODE_LEN)){
      if(fnFM_IsStartStopValid(&ins[1])){
        res = TRUE;
        fmups.m_uchState = FM_STATE_IDLE;
        fmups.m_uiTimer = 0;
      }
    }
  }
}
ack[0] = inscode | 0x80;
ack[1] = res;
ack[2] = 0 ;
pointer = 3;
return(pointer);