Started working on SerialOTA implementation

Author: AGlass0fMilk

.gitignore

@@ -13,4 +13,5 @@ mbed_config.h
 *.hex
 *.pem
 signing_keys.c
-mbed-os/*
+mbed-os/*
+mcuboot/*

SerialOTA.cpp

@@ -0,0 +1,77 @@
+/*
+ * SerialOTA.cpp
+ *
+ *  Created on: Jul 31, 2020
+ *      Author: gdbeckstein
+ */
+
+#include "SerialOTA.h"
+#include "drivers/MbedCRC.h"
+
+#define OTA_DONE_SEQ_NUM 0xFFFF
+
+SerialOTA::SerialOTA(mbed::FileHandle& serial, mbed::BlockDevice& update_bd) : _serial(serial),
+                     _update_bd(update_bd), _current_seq(0) {
+}
+
+SerialOTA::ota_error_t SerialOTA::begin(void) {
+
+    mbed::MbedCRC<POLY_16BIT_CCITT, 16> ct;
+    uint32_t bytes_collected = 0;
+    packet_header_t header = { 0 };
+    uint32_t crc;
+
+    // Initialize the secondary block device
+    _update_bd.init();
+
+    // Erase the entire secondary block device
+    _update_bd.erase(0x0, _update_bd.size());
+
+    _serial.set_blocking(true);
+
+    // Tell the serial bootloader host application to begin :)
+    _serial.write("GO", 2);
+
+    while(true) {
+
+        // Read a packet from the FileHandle
+        _serial.read(_payload_buffer, OTA_PAYLOAD_BUFFER_SIZE);
+
+        // The first bytes will be the header
+        memcpy(&header, _payload_buffer, sizeof(packet_header_t));
+
+        // If the sequence number is OTA_DONE_SEQ_NUM we're done!
+        if(header.sequence_num == OTA_DONE_SEQ_NUM) {
+            return OTA_SUCCESS;
+        }
+
+        // Check the sequence number
+        if(_current_seq != header.sequence_num) {
+            return OTA_OUT_OF_SYNC;
+        }
+
+        // Check the make sure the update_bd can fit the bytes
+        if((bytes_collected + header.payload_size) > _update_bd.size()) {
+            return OTA_OUT_OF_SPACE;
+        }
+
+        // Check the CRC16 to make sure the data is not corrupt
+        ct.compute(&_payload_buffer[2],
+                (header.payload_size+sizeof(packet_header_t)-sizeof(uint16_t)),
+                &crc);
+
+        if(crc != header.crc16) {
+            return OTA_CRC_ERROR;
+        }
+
+        // Everything checks out, proceed to writing the bytes to the update_bd
+        _update_bd.program(&_payload_buffer[sizeof(packet_header_t)],
+                bytes_collected,
+                header.payload_size);
+
+        // Update sequence number and bytes_collected
+        _current_seq++;
+        bytes_collected += header.payload_size;
+
+    }
+}

SerialOTA.h

@@ -8,13 +8,58 @@
 #ifndef SERIALOTA_H_
 #define SERIALOTA_H_
 
-#include "Stream.h"
+#include "platform/FileHandle.h"
+#include "BlockDevice.h"
+
+#define OTA_PAYLOAD_BUFFER_SIZE 384
 
 class SerialOTA
 {
+
+public:
+
+    typedef struct {
+        uint16_t crc16;             /** CRC16 of entire packet */
+        uint16_t sequence_num;      /** Sequence number of the OTA update, the special value 0xFFFF means the transfer is over. Wraps at 0xFFFE */
+        uint16_t payload_size;      /** Payload size of this packet in bytes */
+    } packet_header_t;
+
+    typedef enum {
+        OTA_SUCCESS         = 0x0,  /** success */
+        OTA_OUT_OF_SPACE    = 0x1,  /** update_bd has run out of space for the update */
+        OTA_CRC_ERROR       = 0x2,  /** CRC error on last packet */
+        OTA_OUT_OF_SYNC     = 0x3,  /** Sequence number received out of sync */
+    } ota_error_t;
+
 public:
 
-    SerialOTA();
+    /**
+     * Instantiate a SerialOTA interface
+     *
+     * @param[in] serial Serial FileHandle reference to use
+     * @param[in] update_bd BlockDevice to store the update in
+     */
+    SerialOTA(mbed::FileHandle& serial, mbed::BlockDevice& update_bd);
+
+    /**
+     * Begins the SerialOTA update process
+     *
+     * This is a blocking function call and will only
+     * exit upon error or completion
+     *
+     * @retval error
+     */
+    ota_error_t begin(void);
+
+protected:
+
+    mbed::FileHandle& _serial;
+
+    mbed::BlockDevice& _update_bd;
+
+    uint16_t _current_seq;
+
+    uint8_t _payload_buffer[OTA_PAYLOAD_BUFFER_SIZE];
 
 };
 

mbed_app.json

@@ -1,5 +1,5 @@
 {
-    "requires": ["bare-metal", "mbedtls", "mcuboot", "flashiap-block-device", "spif-driver", "qspif", "mbed-trace"],
+    "requires": ["bare-metal", "mbedtls", "mcuboot", "flashiap-block-device", "spif-driver", "qspif", "mbed-trace", "serialcobs"],
     "target_overrides": {
         "*": {
             "target.restrict_size": "0x20000",

tinycbor.lib

@@ -1 +1 @@
-https://github.com/EmbeddedPlanet/tinycbor/#c49bb8f5f158c9f37b7cef5bb9eb7ee0a9eb6707
+https://github.com/EmbeddedPlanet/tinycbor/#6f4953e3c00afe6cb1677b9dd28bd0c4ad43b6ab

user_main.cpp

@@ -5,29 +5,91 @@
  *      Author: gdbeckstein
  */
 
-#include "BlockDevice.h"
+#include "PinNames.h"
 
 /** Enable serial bootloader feature by default */
 #ifndef MBED_CONF_APP_SERIAL_BOOTLOADER_ENABLE
 #define MBED_CONF_APP_SERIAL_BOOTLOADER_ENABLE 1
 #endif
 
+#ifndef MBED_CONF_APP_SERIAL_BOOTLOADER_BAUD
+#define MBED_CONF_APP_SERIAL_BOOTLOADER_BAUD 115200
+#endif
+
 #if MBED_CONF_APP_SERIAL_BOOTLOADER_ENABLE
 
+#include "secondary_bd.h"
+
+#include "SerialOTA.h"
+
 #include "rtos/ThisThread.h"
+#include "rtos/Kernel.h"
 #include <chrono>
 
+#include "drivers/BufferedSerial.h"
+#include "drivers/DigitalIn.h"
+#include "SerialCOBS.h"
+
 #define BOOT_WAIT_TIMEOUT 5s
 
 using namespace std::chrono;
 
+mbed::DigitalIn button(BUTTON1);
+
+// TODO - add led status indicator?
+
 #endif // MBED_CONF_APP_SERIAL_BOOTLOADER_ENABLE
 
 void mbed_mcuboot_user_init(void) {
 
 #if MBED_CONF_APP_SERIAL_BOOTLOADER_ENABLE
 
-    // Set up the serial bootloader
+    // If the button is held down upon bootup, start the serial bootloader
+    if(button) {
+       return;
+    }
+
+    // Set up the serial interface
+    mbed::BufferedSerial pc(STDIO_UART_TX, STDIO_UART_RX, MBED_CONF_APP_SERIAL_BOOTLOADER_BAUD);
+
+    // Wait for a specified timeout until just booting
+    rtos::Kernel::Clock::duration time_waited = 0ms;
+    bool timed_out = true;
+    uint8_t c = 1;
+    while(time_waited < BOOT_WAIT_TIMEOUT) {
+        // The serial bootloader should send 0-bytes until we respond we're ready, look for that
+        if(pc.readable()) {
+            if(pc.read(&c, 1)) {
+                if(c == 0) {
+                    timed_out = false;
+                    break;
+                }
+            }
+        }
+
+        // Otherwise, keep waiting
+        rtos::ThisThread::sleep_for(100ms);
+        time_waited += 100ms;
+    }
+
+    // Serial bootloader timed out, boot the main application
+    if(timed_out) {
+        return;
+    }
+
+    // Serial bootloader connected, send an acknowledgement
+    c = 1;
+    pc.write(&c, 1);
+
+    // Wrap it with COBS-R encoding (0-byte delimeters)
+    SerialCOBS serial_cobs(pc);
+
+    // Create the SerialOTA object and let it do its thing
+    SerialOTA ota(serial_cobs, *get_secondary_bd());
+
+    SerialOTA::ota_error_t error = ota.begin();
+
+    // TODO - check error?
 
 #endif // MBED_CONF_APP_SERIAL_BOOTLOADER_ENABLE