artnetcontroller.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External Includes
#include <rtti/factory.h>
#include <nap/device.h>
#include <future>
#include <nap/numeric.h>
#include <condition_variable>
#include <mutex>
#include <nap/timer.h>
 
namespace nap
{
    using ArtNetNode = void*;
    
    // Forward Declares
    class ArtNetService;
 
    namespace artnet
    {
        // This maximum is defined as the maximum refresh rate that can be achieved on the DMX512-A
        // physical layer with a full 512 channel(data slot) payload. The actual value is 44 packets per second.
        inline constexpr int refreshRate = 44;  
    }
 
 
    enum class EArtnetMode : int
    {
        Broadcast   = 0,            
        Unicast     = 1             
    };
 
 
    class NAPAPI ArtNetController : public Device
    {
        RTTI_ENABLE(Device)
 
    public:
        using ByteChannelData = std::vector<uint8>;
        using FloatChannelData = std::vector<float>;
        using Address = uint8;
 
        // Default constructor
        ArtNetController() = default;
 
        // Constructor used by factory
        ArtNetController(ArtNetService& service);
 
        virtual bool start(nap::utility::ErrorState& errorState) override;
 
        virtual void stop() override;
 
        void send(const FloatChannelData& channelData, int channelOffset = 0);
 
        void send(float channelData, int channel);
 
        void send(const ByteChannelData& channelData, int channelOffset = 0);
 
        void send(uint8 channelData, int channel);
 
        void clear();
 
        Address getAddress() const                                          { return createAddress(mSubnet, mUniverse); }
        
        static Address createAddress(uint8 subnet, uint8 universe);
 
        static void convertAddress(Address address, uint8& subnet, uint8& universe);
 
        uint8               mSubnet = 0;                                    
        uint8               mUniverse = 0;                                  
        int                 mUpdateFrequency = artnet::refreshRate;         
        float               mWaitTime = 2.0f;                               
        EArtnetMode         mMode = EArtnetMode::Broadcast;                 
        int                 mUnicastLimit = 10;                             
        bool                mVerbose = false;                               
        float               mReadTimeout = 2.0f;                            
        std::string         mIpAddress = "";                                
        uint16              mChannelCount = 512;                            
 
    private:
 
        friend class ArtNetService;
 
        ArtNetNode getNode() const { return mNode; }
 
        void exePollTask();
 
        void stopPolling();
 
        void startPolling();
 
        void poll();
 
        void update(double deltaTime);
 
        ArtNetService*              mService = nullptr;                             
        ArtNetNode                  mNode = nullptr;                                
        int                         mFoundNodes = 0;                                
        int                         mSocketDescriptor = -1;                         
 
        // Polling
        std::future<void>           mReadTask;                                      
        std::condition_variable     mConditionVar;                                  
        std::mutex                  mPollMutex;                                     
        nap::SystemTimer            mPollTimer;                                     
        bool                        mPoll = true;                                   
        std::atomic<bool>           mExit = { false };                              
    };
 
    using ArtNetNodeCreator = rtti::ObjectCreator<ArtNetController, ArtNetService>;
}