upgrade_controller.h

Go to the documentation of this file.

#ifndef VITROIO_SDK_UPGRADE_CONTROLLER_H
#define VITROIO_SDK_UPGRADE_CONTROLLER_H
 
#include <mbed.h>
 
#include <vitroio-sdk/utils/impl/scoped_ptr.h>
#include <vitroio-sdk/utils/impl/buffer.h>
 
#include <vitroio-sdk/types.h>
 
namespace vitroio
{
 
namespace sdk
{
 
namespace impl
{
 
#define VITROIO_UPGRADE_CONTROLLER_DEFAULT_EVENT_QUEUE_SIZE 32
 
class FlashInterface;
 
class UpgradeController : private NonCopyable<UpgradeController>
{
public:
    typedef Callback<void()> OnNewFirmwareAvailableCallback;
 
    explicit UpgradeController(
        FlashInterface* flash,
        FirmwareId fwId,
        Version fwVersion,
        OnNewFirmwareAvailableCallback callback,
        EventQueue* eventQueue
    );
 
    ~UpgradeController();
 
    bool isValid() const;
 
    void configure(FlashSpace flashSpace);
 
    void processData(const uint8_t* data, uint32_t size);
 
private:
    class SegmentDecoder
    {
    public:
        static SegmentDecoder* create(const uint8_t* data, uint32_t size);
 
        ~SegmentDecoder();
 
        uint32_t segment();
        uint32_t segmentsCount();
        uint8_t* data();
        const uint8_t* data() const;
        uint32_t dataSize();
 
        bool setBuffer(const uint8_t* data, uint32_t size);
 
        static uint32_t allocated();
        static uint32_t deleted();
 
    private:
        SegmentDecoder();
 
        static const uint8_t dataOffset_ = 4;
        static uint32_t allocated_;
        static uint32_t deleted_;
 
        Buffer buffer_;
    };
 
    bool valid_;
 
    FlashInterface* flash_;
    FirmwareId fwId_;
    Version fwVersion_;
    FlashSpace flashSpace_;
    OnNewFirmwareAvailableCallback onNewFirmwareAvailableCallback_;
 
    EventQueue* eventQueue_;
    Mutex mutex_;
 
    uint32_t nextSegment_;
    Buffer sectorBuffer_;
    FlashSpace currentFlashSpace_;
    uint32_t flashedBytes_;
    bool upgradeProcessRunning_;
    bool breakIncorrectUpdate;
    //
    // TODO:
    // - consider make sizes of these queues configurable
    //
    Queue<SegmentDecoder, 64> segmentsToProcessQueue_;
    Queue<SegmentDecoder, 64> notUsedSegmentsQueue_;
 
    void processSegments();
    bool processSegment(SegmentDecoder* sd);
 
    void cleanup();
 
    bool writeSectorBufferToFlash();
 
    //
    // Inserts segment into notUsedSegmentsQueue_ or deletes it
    // when the queue is full.
    //
    void setSegmentNotUsed(SegmentDecoder* segment);
 
    //
    // Returns not used segment or NULL when there aren't not used segments.
    //
    SegmentDecoder* getNotUsedSegment();
 
    //
    // Inserts segment to segmentsToProcessQueue_.
    // Returns true on success or false when the queue is full.
    //
    bool setSegmentToProcess(SegmentDecoder* segment);
 
    //
    // Returns segment from segmentsToProcessQueue_ or NULL when the queue
    // is empty.
    //
    SegmentDecoder* getSegmentToProcess();
};
 
} // namespace impl
 
} // namespace sdk
 
} // namespace vitroio
 
#endif // VITROIO_SDK_UPGRADE_CONTROLLER_H