.. _program_listing_file_include_depthai_device_DeviceBootloader.hpp:

Program Listing for File DeviceBootloader.hpp
=============================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_depthai_device_DeviceBootloader.hpp>` (``include/depthai/device/DeviceBootloader.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   // std
   #include <string>
   #include <thread>
   #include <type_traits>
   
   // project
   #include "CallbackHandler.hpp"
   #include "DataQueue.hpp"
   #include "depthai/common/UsbSpeed.hpp"
   #include "depthai/pipeline/Pipeline.hpp"
   #include "depthai/xlink/XLinkConnection.hpp"
   #include "depthai/xlink/XLinkStream.hpp"
   
   // shared
   #include "depthai-bootloader-shared/Config.hpp"
   #include "depthai-bootloader-shared/Memory.hpp"
   #include "depthai-bootloader-shared/Section.hpp"
   #include "depthai-bootloader-shared/Type.hpp"
   
   namespace dai {
   
   // DeviceBootloader (RAII), connects to device and maintains watchdog ...
   
   class DeviceBootloader {
      public:
       // Alias
       using Type = dai::bootloader::Type;
       using Memory = dai::bootloader::Memory;
       using Section = dai::bootloader::Section;
       using UsbConfig = dai::bootloader::UsbConfig;
       using NetworkConfig = dai::bootloader::NetworkConfig;
   
       // Derive and extend bootloader::Config for easier usage
       struct Config : public bootloader::Config {
           void setStaticIPv4(std::string ip, std::string mask, std::string gateway);
           void setDynamicIPv4(std::string ip, std::string mask, std::string gateway);
           bool isStaticIPV4();
           std::string getIPv4();
           std::string getIPv4Mask();
           std::string getIPv4Gateway();
           void setDnsIPv4(std::string dns, std::string dnsAlt = "");
           std::string getDnsIPv4();
           std::string getDnsAltIPv4();
   
           void setUsbTimeout(std::chrono::milliseconds ms);
           std::chrono::milliseconds getUsbTimeout();
   
           void setNetworkTimeout(std::chrono::milliseconds ms);
           std::chrono::milliseconds getNetworkTimeout();
   
           void setMacAddress(std::string mac);
           std::string getMacAddress();
   
           void setUsbMaxSpeed(UsbSpeed speed);
           UsbSpeed getUsbMaxSpeed();
   
           nlohmann::json toJson() const;
   
           static Config fromJson(nlohmann::json);
   
          private:
           nlohmann::json data;
       };
   
       // Add an alias to Version
       using Version = dai::Version;
   
       struct ApplicationInfo {
           Memory memory;
           bool hasApplication;
           std::string firmwareVersion;
           std::string applicationName;
       };
   
       struct MemoryInfo {
           bool available;
           std::int64_t size;
           std::string info;
       };
   
       // constants
   
       static constexpr const Type DEFAULT_TYPE{Type::USB};
   
       // Static API
       static std::tuple<bool, DeviceInfo> getFirstAvailableDevice();
   
       static std::vector<DeviceInfo> getAllAvailableDevices();
   
       static std::vector<uint8_t> createDepthaiApplicationPackage(
           const Pipeline& pipeline, const dai::Path& pathToCmd = {}, bool compress = false, std::string applicationName = "", bool checkChecksum = false);
   
       static std::vector<uint8_t> createDepthaiApplicationPackage(const Pipeline& pipeline,
                                                                   bool compress,
                                                                   std::string applicationName = "",
                                                                   bool checkChecksum = false);
   
       static void saveDepthaiApplicationPackage(const dai::Path& path,
                                                 const Pipeline& pipeline,
                                                 const dai::Path& pathToCmd = {},
                                                 bool compress = false,
                                                 std::string applicationName = "",
                                                 bool checkChecksum = false);
   
       static void saveDepthaiApplicationPackage(
           const dai::Path& path, const Pipeline& pipeline, bool compress, std::string applicationName = "", bool checkChecksum = false);
   
       static Version getEmbeddedBootloaderVersion();
   
       static std::vector<std::uint8_t> getEmbeddedBootloaderBinary(Type type = DEFAULT_TYPE);
   
       DeviceBootloader() = delete;
   
       explicit DeviceBootloader(const DeviceInfo& devInfo);
   
       template <typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
       DeviceBootloader(const DeviceInfo& devInfo, T allowFlashingBootloader);
   
       DeviceBootloader(const DeviceInfo& devInfo, Type type, bool allowFlashingBootloader = false);
   
       DeviceBootloader(const DeviceInfo& devInfo, const dai::Path& pathToBootloader, bool allowFlashingBootloader = false);
   
       DeviceBootloader(std::string nameOrDeviceId, bool allowFlashingBootloader = false);
   
       ~DeviceBootloader();
   
       std::tuple<bool, std::string> flash(std::function<void(float)> progressCallback,
                                           const Pipeline& pipeline,
                                           bool compress = false,
                                           std::string applicationName = "",
                                           Memory memory = Memory::AUTO,
                                           bool checkChecksum = false);
   
       std::tuple<bool, std::string> flash(
           const Pipeline& pipeline, bool compress = false, std::string applicationName = "", Memory memory = Memory::AUTO, bool checkChecksum = false);
   
       ApplicationInfo readApplicationInfo(Memory memory);
   
       std::tuple<bool, std::string> flashDepthaiApplicationPackage(std::function<void(float)> progressCallback,
                                                                    std::vector<uint8_t> package,
                                                                    Memory memory = Memory::AUTO);
   
       std::tuple<bool, std::string> flashDepthaiApplicationPackage(std::vector<uint8_t> package, Memory memory = Memory::AUTO);
   
       std::tuple<bool, std::string> flashClear(Memory memory = Memory::AUTO);
   
       std::tuple<bool, std::string> flashBootloader(std::function<void(float)> progressCallback, const dai::Path& path = {});
   
       std::tuple<bool, std::string> flashBootloader(Memory memory, Type type, std::function<void(float)> progressCallback, const dai::Path& path = {});
   
       std::tuple<bool, std::string> flashUserBootloader(std::function<void(float)> progressCallback, const dai::Path& path = {});
   
       std::tuple<bool, std::string> flashGpioModeBootHeader(Memory memory, int gpioMode);
   
       std::tuple<bool, std::string> flashUsbRecoveryBootHeader(Memory memory);
   
       std::tuple<bool, std::string> flashBootHeader(Memory memory, int32_t frequency = -1, int64_t location = -1, int32_t dummyCycles = -1, int64_t offset = -1);
   
       std::tuple<bool, std::string> flashFastBootHeader(
           Memory memory, int32_t frequency = -1, int64_t location = -1, int32_t dummyCycles = -1, int64_t offset = -1);
   
       std::tuple<bool, std::string> flashCustom(Memory memory, size_t offset, const std::vector<uint8_t>& data, std::function<void(float)> progressCb = nullptr);
       std::tuple<bool, std::string> flashCustom(Memory memory, size_t offset, const uint8_t* data, size_t size, std::function<void(float)> progressCb = nullptr);
       std::tuple<bool, std::string> flashCustom(Memory memory, size_t offset, std::string filename, std::function<void(float)> progressCb = nullptr);
   
       std::tuple<bool, std::string> readCustom(
           Memory memory, size_t offset, size_t size, std::vector<uint8_t>& data, std::function<void(float)> progressCb = nullptr);
       std::tuple<bool, std::string> readCustom(Memory memory, size_t offset, size_t size, uint8_t* data, std::function<void(float)> progressCb = nullptr);
       std::tuple<bool, std::string> readCustom(Memory memory, size_t offset, size_t size, std::string filename, std::function<void(float)> progressCb = nullptr);
       std::tuple<bool, std::string, std::vector<uint8_t>> readCustom(Memory memory, size_t offset, size_t size, std::function<void(float)> progressCb = nullptr);
   
       nlohmann::json readConfigData(Memory memory = Memory::AUTO, Type type = Type::AUTO);
   
       std::tuple<bool, std::string> flashConfigData(nlohmann::json configData, Memory memory = Memory::AUTO, Type type = Type::AUTO);
   
       std::tuple<bool, std::string> flashConfigFile(const dai::Path& configPath, Memory memory = Memory::AUTO, Type type = Type::AUTO);
   
       std::tuple<bool, std::string> flashConfigClear(Memory memory = Memory::AUTO, Type type = Type::AUTO);
   
       Config readConfig(Memory memory = Memory::AUTO, Type type = Type::AUTO);
   
       std::tuple<bool, std::string> flashConfig(const Config& config, Memory memory = Memory::AUTO, Type type = Type::AUTO);
   
       MemoryInfo getMemoryInfo(Memory memory);
   
       bool isUserBootloaderSupported();
   
       bool isUserBootloader();
   
       void bootMemory(const std::vector<uint8_t>& fw);
   
       void bootUsbRomBootloader();
   
       Version getVersion() const;
   
       tl::optional<Version> getFlashedVersion() const;
   
       bool isEmbeddedVersion() const;
   
       Type getType() const;
   
       bool isAllowedFlashingBootloader() const;
   
       void close();
   
       bool isClosed() const;
   
      private:
       // private static
   
       // private methods
       void init(bool embeddedMvcmd, const dai::Path& pathToMvcmd, tl::optional<bootloader::Type> type, bool allowBlFlash);
       template <typename T>
       bool sendRequest(const T& request);
       template <typename T>
       void sendRequestThrow(const T& request);
       bool receiveResponseData(std::vector<uint8_t>& data);
       template <typename T>
       bool parseResponse(const std::vector<uint8_t>& data, T& response);
       template <typename T>
       bool receiveResponse(T& response);
       template <typename T>
       void receiveResponseThrow(T& response);
       Version requestVersion();
       std::tuple<bool, std::string> flashCustom(
           Memory memory, size_t offset, const uint8_t* data, size_t size, std::string filename, std::function<void(float)> progressCb);
       std::tuple<bool, std::string> readCustom(
           Memory memory, size_t offset, size_t size, uint8_t* data, std::string filename, std::function<void(float)> progressCb);
   
       void createWatchdog();
       void destroyWatchdog();
   
       // private variables
       std::shared_ptr<XLinkConnection> connection;
       DeviceInfo deviceInfo = {};
   
       bool isEmbedded = false;
       Type bootloaderType;
       tl::optional<Version> flashedVersion;
   
       // closed
       std::atomic<bool> closed{false};
   
       // Watchdog thread
       std::thread watchdogThread;
       std::atomic<bool> watchdogRunning{true};
   
       // Monitor thread
       std::thread monitorThread;
       std::mutex lastWatchdogPingTimeMtx;
       std::chrono::steady_clock::time_point lastWatchdogPingTime;
   
       // bootloader stream
       std::unique_ptr<XLinkStream> stream;
   
       // Allow flashing bootloader flag
       bool allowFlashingBootloader = false;
   
       // Current connected bootloader version
       Version version{0, 0, 2};
   };
   
   }  // namespace dai
   
   // Global namespace
   inline std::ostream& operator<<(std::ostream& out, const dai::DeviceBootloader::Type& type) {
       switch(type) {
           case dai::DeviceBootloader::Type::AUTO:
               out << "AUTO";
               break;
           case dai::DeviceBootloader::Type::USB:
               out << "USB";
               break;
           case dai::DeviceBootloader::Type::NETWORK:
               out << "NETWORK";
               break;
       }
       return out;
   }
   
   inline std::ostream& operator<<(std::ostream& out, const dai::DeviceBootloader::Memory& memory) {
       switch(memory) {
           case dai::DeviceBootloader::Memory::AUTO:
               out << "AUTO";
               break;
           case dai::DeviceBootloader::Memory::FLASH:
               out << "FLASH";
               break;
           case dai::DeviceBootloader::Memory::EMMC:
               out << "EMMC";
               break;
       }
       return out;
   }
   
   inline std::ostream& operator<<(std::ostream& out, const dai::DeviceBootloader::Section& type) {
       switch(type) {
           case dai::DeviceBootloader::Section::AUTO:
               out << "AUTO";
               break;
           case dai::DeviceBootloader::Section::HEADER:
               out << "HEADER";
               break;
           case dai::DeviceBootloader::Section::BOOTLOADER:
               out << "BOOTLOADER";
               break;
           case dai::DeviceBootloader::Section::USER_BOOTLOADER:
               out << "USER_BOOTLOADER";
               break;
           case dai::DeviceBootloader::Section::BOOTLOADER_CONFIG:
               out << "BOOTLOADER_CONFIG";
               break;
           case dai::DeviceBootloader::Section::APPLICATION:
               out << "APPLICATION";
               break;
       }
       return out;
   }
   
   inline std::ostream& operator<<(std::ostream& out, const dai::DeviceBootloader::Version& v) {
       return out << v.toString();
   }