parametertransfer.h

/*******************************************************************************
 * Copyright (c) 2024 Allied Vision Technologies GmbH
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *******************************************************************************/
 
#ifndef VISIONTRANSFER_PARAMETERTRANSFER_H
#define VISIONTRANSFER_PARAMETERTRANSFER_H
 
#include "visiontransfer/common.h"
#include "visiontransfer/types.h"
#include "visiontransfer/parameterinfo.h"
#include "visiontransfer/parameterset.h"
#include "visiontransfer/internal/tokenizer.h"
#include "visiontransfer/internal/networking.h"
 
#include <map>
#include <set>
#include <memory>
#include <thread>
#include <condition_variable>
#include <functional>
 
namespace visiontransfer {
namespace internal {
 
class ParameterTransfer {
public:
    ParameterTransfer(const char* address, const char* service = "7683");
    ~ParameterTransfer();
 
    bool isConnected() const;
 
    int readIntParameter(const char* id);
 
    double readDoubleParameter(const char* id);
 
    bool readBoolParameter(const char* id);
 
    void writeIntParameter(const char* id, int value);
 
    void writeDoubleParameter(const char* id, double value);
 
    void writeBoolParameter(const char* id, bool value);
 
    template<typename T>
    void writeParameter(const char* id, const T& value, bool synchronous=true);
 
    template<typename T>
    void writeParameterTransactionGuarded(const char* id, const T& value);
 
    template<typename T>
    void writeParameterTransactionUnguarded(const char* id, const T& value);
 
    std::map<std::string, ParameterInfo> getAllParameters();
    
    bool hasParameter(const std::string& uid) const;
 
    param::Parameter getParameter(const std::string& uid) const;
 
    param::Parameter pollParameter(const std::string& uid, bool blockingCall);
 
    param::ParameterSet& getParameterSet();
 
    param::ParameterSet const& getParameterSet() const;
 
    void setParameterUpdateCallback(std::function<void(const std::string& uid)> callback, bool threaded);
 
    void transactionStartQueue();
 
    void transactionCommitQueue(int maxWaitMilliseconds);
 
    void persistParameters(const std::vector<std::string>& uids, bool synchronous=true);
 
    void setConnectionStateChangeCallback(std::function<void(visiontransfer::ConnectionState)> callback);
 
private:
    static constexpr int SOCKET_TIMEOUT_MS = 500;
    static constexpr int SOCKET_RECONNECT_INTERVAL_MS = 2000;
 
    // Message types
    static constexpr unsigned char MESSAGE_READ_INT = 0x01;
    static constexpr unsigned char MESSAGE_READ_DOUBLE = 0x02;
    static constexpr unsigned char MESSAGE_READ_BOOL = 0x03;
    static constexpr unsigned char MESSAGE_WRITE_INT = 0x04;
    static constexpr unsigned char MESSAGE_WRITE_DOUBLE = 0x05;
    static constexpr unsigned char MESSAGE_WRITE_BOOL = 0x06;
    static constexpr unsigned char MESSAGE_ENUMERATE_PARAMS = 0x07;
 
    SOCKET socket;
 
    std::string address; // for reconnection
    std::string service;
 
    static constexpr unsigned int RECV_BUF_SIZE = 1024*1024;
    char recvBuf[RECV_BUF_SIZE];
    unsigned int recvBufBytes;
    unsigned int pollDelay;
    bool networkError; // background thread exception flag
    std::string networkErrorString;
    bool networkReady; // after protocol check and initial update
 
    // Fallback handling for connecting to out-of-date firmware versions
    bool featureDisabledTransactions;
 
    bool threadRunning;
    std::shared_ptr<std::thread> receiverThread;
 
    Tokenizer tabTokenizer;
    Tokenizer spaceTokenizer;
    Tokenizer slashTokenizer;
 
    param::ParameterSet paramSet;
 
    mutable std::mutex readyMutex;
    mutable std::condition_variable readyCond;
    mutable std::mutex mapMutex;
    std::mutex socketModificationMutex;
    std::mutex callbackMutex;
    std::map<int, std::condition_variable> waitConds;
    std::map<int, std::mutex> waitCondMutexes;
    std::map<int, std::pair<bool, std::string> > lastSetRequestResult;
    std::map<int, std::string> waitCondClasses;
 
    std::function<void(const std::string&)> parameterUpdateCallback;
    bool parameterUpdateCallbackThreaded;
 
    thread_local static bool transactionInProgress;
    thread_local static std::vector<std::pair<std::string, std::string> > transactionQueuedWrites;
 
    thread_local static bool writingProhibited;
 
    std::function<void(visiontransfer::ConnectionState)> connectionStateChangeCallback;
 
    void attemptConnection();
 
    void waitNetworkReady() const;
 
    int getThreadId();
 
    void blockingCallThisThread(std::function<void()>, int waitMaxMilliseconds=1000, const std::string& waitClass="");
 
    void receiverRoutine();
    void process();
 
    void readParameter(unsigned char messageType, const char* id, unsigned char* dest, int length);
    void recvData(unsigned char* dest, int length);
 
    std::map<std::string, ParameterInfo> recvEnumeration();
 
    template<typename T>
    void writeParameterTransactionGuardedImpl(const char* id, const T& value);
 
    template<typename T>
    void writeParameterTransactionUnguardedImpl(const char* id, const T& value);
 
    void sendNetworkCommand(const std::string& cmdline, const std::string& diagStr);
 
};
 
}} // namespace
 
#endif