node_controller.h

Go to the documentation of this file.

#ifndef VITROIO_SDK_NODE_CONTROLLER_H
#define VITROIO_SDK_NODE_CONTROLLER_H
 
#include <mbed.h>
#include <functional>
 
#include <vitroio-sdk/control/node_controller.h>
#include <vitroio-sdk/communication/canbus_frame.h>
#include <vitroio-sdk/types.h>
 
#include <vitroio-sdk/utils/impl/scoped_ptr.h>
#include <vitroio-sdk/interfaces/impl/flash_interface.h>
#include <vitroio-sdk/interfaces/impl/environment_interface.h>
#include <vitroio-sdk/control/impl/upgrade_controller.h>
#include <vitroio-sdk/communication/transport_layer.h>
 
namespace vitroio
{
 
namespace sdk
{
 
#define VITROIO_NODE_CONTROLLER_DEFAULT_EVENT_QUEUE_SIZE 32
 
class Canbus;
 
class NodeController : private NonCopyable<NodeController>
{
public:
    explicit NodeController(
        Canbus* canbus,
        const FirmwareId& fwId,
        const Version& fwVersion, 
        FlashSpace environmentFlashSpace,
        FlashSpace regionAFlashSpace,
        FlashSpace regionBFlashSpace,
        EventQueue* targetQueue, 
        uint32_t eventQueueSize = VITROIO_NODE_CONTROLLER_DEFAULT_EVENT_QUEUE_SIZE);
 
    explicit NodeController(
        Canbus* canbus,
        const FirmwareId& fwId,
        const Version& fwVersion, 
        FlashSpace environmentFlashSpace,
        FlashSpace regionAFlashSpace,
        FlashSpace regionBFlashSpace,
        osPriority priority = osPriorityNormal, 
        uint32_t eventQueueSize = VITROIO_NODE_CONTROLLER_DEFAULT_EVENT_QUEUE_SIZE);
    
    NodeController(
        Canbus* canbus,
        const FirmwareId& fwId,
        const Version& fwVersion, 
        osPriority priority = osPriorityNormal, 
        uint32_t eventQueueSize = VITROIO_NODE_CONTROLLER_DEFAULT_EVENT_QUEUE_SIZE);
 
    NodeController(
        Canbus* canbus,
        const FirmwareId& fwId,
        const Version& fwVersion, 
        EventQueue* targetQueue, 
        uint32_t eventQueueSize = VITROIO_NODE_CONTROLLER_DEFAULT_EVENT_QUEUE_SIZE);
    
    ~NodeController();
 
    bool isValid();
 
    int initCommunication(Transport_layer* layer);
 
    int initCommunication(uint32_t sync_time, Transport_layer* layer);
 
    uint32_t nodeId();
 
    void setExternalFrameCallback(std::function<void(const CanbusFrame&)>);
 
private:
    bool valid_;
 
    EventQueue evQueue_;
    impl::ScopedPtr<Thread> evQueueThread_;
 
    impl::FlashInterface flash_;
    impl::EnvironmentInterface env_;
    impl::UpgradeController upg_;
    Canbus* canbus_;
    FirmwareId fwId_;
    Version fwVer_;
    uint64_t id_;
    uint32_t nodeId_;
    FlashSpace regionAFlashSpace_;
    FlashSpace regionBFlashSpace_;
 
    Mutex mutex_;
 
    //void (*externalFrameCallback)(const CanbusFrame&);
    std::function<void(const CanbusFrame&)> externalFrameCallback;
 
    void setNodeId(uint32_t id);
 
    int onFrameReceivedCallbackHandle_;
 
    void onFrameReceivedCallback(const CanbusFrame&);
 
    void handleNodeIdResponseFrame(const CanbusFrame& frame);
    void handleUpgradeFrame(const CanbusFrame& frame);
    void handleProvisioningFrame(const CanbusFrame& frame);
    void handleExternalFrame(const CanbusFrame& frame);
 
    void onNewFirmwareAvailableCallback();
 
    uint64_t getHardwareId();
};
 
} // namespace sdk
 
} // namespace vitroio
 
#endif // VITROIO_SDK_NODE_CONTROLLER_H