fixing memory leaks and Veto mechanics

.vscode/settings.json

@@ -15,5 +15,6 @@
     "idf.toolsPathWin": "C:\\Tools\\ESP",
     "idf.flashType": "UART",
     "C_Cpp.autoAddFileAssociations": false,
-    "project.deviceIp": "172.16.17.56"
+    "project.deviceIp": "172.16.17.56",
+    "sonarlint.pathToCompileCommands": "${workspaceFolder}\\build\\compile_commands.json",
 }

components/spit/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "src" "src/esp"
+    INCLUDE_DIRS "include"
+    REQUIRES esp_system esp_netif freeRtosApi
+)

components/spit/Notes.md

@@ -0,0 +1,11 @@
+# SPIT 
+
+Original implementation from Hag seem to be not suited for Embedded devices.
+
+- Supports IPv4 only
+- Reduced Threads to a minimum
+- Then reduced usage of Mutexes to a minimum
+- Reduced Sockets to a minimum
+- Introduced containers and removed plain new and delete
+- Removed UUID-Generation because SPIT-Types never change on embedded devices
+- Callbacks instead of interfaces where suitable

components/spit/include/SAD_DetectedServer.hpp

@@ -0,0 +1,150 @@
+#pragma once
+
+#include <list>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+using namespace std;
+
+class SAD_DetectedServer;
+class I_SAD_Client {
+  public:
+    virtual void eventServerDetected(SAD_DetectedServer &server) = 0;
+    virtual void eventServerChanged(SAD_DetectedServer &server) = 0;
+    virtual void eventServerLost(SAD_DetectedServer &server) = 0;
+};
+
+class SAD_DetectedServer {
+  public:
+    SAD_DetectedServer(string p_Name, string p_ID, string p_ComputerName,
+                       string p_IP, string p_Port, string p_ClientIP,
+                       string p_Additions, string projName)
+        : m_Name(p_Name),
+          m_ID(p_ID),
+          m_ComputerName(p_ComputerName),
+          m_IP(p_IP),
+          m_Port(p_Port),
+          m_ClientIP(p_ClientIP),
+          m_Additions(p_Additions),
+          m_ServerProjectName(projName) {
+    }
+
+  private:
+    string m_Name{};
+    string m_ID{};
+    string m_ComputerName{};
+    string m_IP{};
+    string m_Port{};
+    string m_ClientIP{};
+    string m_Additions{};
+    string m_ServerProjectName{};
+    bool m_New{true};
+    bool m_Changed{};
+    bool m_FoundAgain{};
+
+  public:
+    string getID() const { return m_ID; }
+    string getName() const { return m_Name; }
+    string getComputerName() const { return m_ComputerName; }
+    string getIP() const { return m_IP; }
+    string getPort() const { return m_Port; }
+    string getClientIP() const { return m_ClientIP; }
+    string getAdditions() const { return m_Additions; }
+    string getProjectName() const { return m_ServerProjectName; }
+    bool getNew() const { return m_New; }
+    bool getChanged() const { return m_Changed; }
+    bool getFoundAgain() const { return m_FoundAgain; }
+
+    void setChanged() { m_Changed = true; }
+    void setKnown() { m_New = false; }
+    void setFoundAgain() { m_FoundAgain = true; }
+    void updateProjectName(string newProjectName) {
+        m_ServerProjectName = newProjectName;
+        if (m_ServerProjectName != newProjectName) {
+            m_Changed = true;
+        }
+    }
+
+    // SAD_Client m_ThreadSend will send to Multicast addresses
+    void resetFlags() {
+        m_Changed = false;
+        m_FoundAgain = false;
+        m_New = false;
+    }
+
+  private:
+    static unordered_map<string, unique_ptr<SAD_DetectedServer>> sKnownServers;
+
+  public:
+    static constexpr int PARAMINDEX_PRECODE = 0;
+    static constexpr int PARAMINDEX_SPITTASKID = 1;
+    static constexpr int PARAMINDEX_NAME = 2;
+    static constexpr int PARAMINDEX_ID = 3;
+    static constexpr int PARAMINDEX_COMPUTERNAME = 4;
+    static constexpr int PARAMINDEX_PORT = 5;
+    static constexpr int PARAMINDEX_CLIENTIP = 6;
+    static constexpr int PARAMINDEX_ADDITIONS = 7;
+    static constexpr int PARAMINDEX_SERVERPROJECTNAME = 8;
+    static constexpr int PARAMINDEX_IP = 9;
+
+    /**
+     * Used by SAD_Client to add a found SPITServer - don't use this manually
+     * @param id the id of the server, every instance of a SPITServer has an own id
+     * @param p_ServerParams the server's parameter
+     */
+    static void addDetectedServer(unique_ptr<SAD_DetectedServer> detected) {
+        if (auto i = sKnownServers.find(detected->getID()); i != sKnownServers.end()) {
+            auto &known = *(i->second.get());
+            known.setFoundAgain();
+            if (detected->getProjectName() != known.getProjectName()) {
+                known.updateProjectName(detected->getProjectName());
+            }
+            return;
+        }
+        sKnownServers[detected->getID()] = move(detected);
+    }
+    static void removeDetectedServer(SAD_DetectedServer &server) {
+        auto i = sKnownServers.find(server.getID());
+        if (i != sKnownServers.end()) {
+            sKnownServers.erase(i);
+        }
+    }
+    static void clearDetectedServers() {
+        sKnownServers.clear();
+    }
+
+    static void resetServerFlags() {
+        for (auto &srv : sKnownServers) {
+            srv.second->resetFlags();
+        }
+    }
+    /**
+     * Used by SAD_Client internally -don't use this manually
+     * @param p_SADClientInterface
+     */
+    static void evaluateDetectedServers(I_SAD_Client &sadClient) {
+        for (auto &srv : sKnownServers) {
+            SAD_DetectedServer &known = *srv.second;
+            if (known.getNew()) {
+                known.setKnown();
+                sadClient.eventServerDetected(known);
+            } else if (known.getChanged()) {
+                sadClient.eventServerChanged(known);
+            } else if (known.getFoundAgain() == false) {
+                sadClient.eventServerLost(known);
+                removeDetectedServer(known);
+            }
+        }
+    }
+
+    /**
+     * Returns a reference of the DetectedServer with the id p_ServerID.<br>
+     * If no DetectedServer is found an eyception is thrown.
+     * @param p_ServerID the id of the SPITServer
+     * @return the reference of the SAD_DetectedServer instance with getID() == p_ServerID
+     */
+    static const SAD_DetectedServer &getRefDetectedServer(const string &id) {
+        return *sKnownServers.at(id);
+    }
+};

components/spit/include/SPITObject.h

@@ -0,0 +1,146 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * File:   SPITObject.h
+ * Author: Hagi
+ *
+ * Created on 9. April 2019, 12:11
+ */
+
+#ifndef SPITOBJECT_H
+#define SPITOBJECT_H
+
+#include "SPITType.h"
+#include "SPIT_Message.h"
+#include "SpitRepo.hpp"
+
+using namespace std;
+
+class SPITObjectListener;
+
+class SPITObject {
+  public:
+    static void clearUnconfirmedSPITObjects(SpitRepo<SPITObject> &repo);
+    static void setConfirmedFalse(SpitRepo<SPITObject> &repo);
+    static void eventProjectClosed(SpitRepo<SPITObject> &repo, SpitRepo<SPITObject> &remoteRepo);
+
+    SPITObject(string p_ID);
+
+  private:
+    string m_ID;
+    string m_Name{};
+    string m_SPITTypeID{};
+    string m_ServerParams{};
+    string m_Remark{};
+    bool m_Confirmed{};
+    bool m_Fixed{};
+    bool m_CreatedByClient{};
+    bool m_ServerRemote{};
+    bool m_ActionAssigned{};
+    bool m_ActionAssignedType{}; // Virtual construct
+    long long m_FrameStart{};
+    long long m_FrameLength{};
+    long long m_FrameFadeInLength{};
+    long long m_FrameFadeOutLength{};
+    char m_ValueUse{0x01};
+    int m_ValueFactor{1000000}; // Values are given in ppm -> 1000000 = 1/1;
+    int m_Track{};
+    long long m_Delay{};
+    long long m_Duration{};
+
+    bool m_PlayPrePosition;
+    long long m_PlayTimeInsideFrames;
+    int m_PlayValue;
+    char m_PlayValueFlag;
+
+  public:
+    string getID() const { return m_ID; }
+    string getName() const { return m_Name; }
+    string getRemark() const { return m_Remark; }
+    string getSPITTypeID() const { return m_SPITTypeID; }
+    string getServerParams() const { return m_ServerParams; }
+
+    /**
+     * Returns if the SPITType triggers an action on the Server or on the client.
+     * @return false = the action is triggered on the client The client waits for the server to play objects of this SPITType
+     * true = the action is triggered on the server. The server waits for the client to play objects of this SPITType.
+     */
+    bool getServerRemote() const { return m_ServerRemote; }
+
+    /**
+     * This is used by the server and client to tell if the other side has registered the changes.
+     * @return true = other side has registered the changes.
+     */
+    bool getConfirmed() const { return m_Confirmed; }
+    bool getFixed() const { return m_Fixed; }
+    bool getCreatedByClient() const { return m_CreatedByClient; }
+    /**
+     * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
+     * This is used when an action is associated with a SPITType.
+     * Then this action is done for every SPITObject with the SPITType.
+     * @return true = an action is assigned for the SPITType.
+     */
+    bool getActionAssignedType() const { return m_ActionAssignedType; }
+    /** Returns if this SPITObject has an associated action or not.
+     * @return true = the user has asscociated an action with this SPITObject or
+     *  the user has asscociated an action with the SPITType of this SPITObject
+     */
+    bool getActionAssigned() const { return m_ActionAssigned || m_ActionAssignedType; }
+
+    long long getFrameStart() const { return m_FrameStart; }
+    // contains the length of the SPITObject
+    long long getFrameLength() const { return m_FrameLength; }
+    long long getFrameFadeInLength() const { return m_FrameFadeInLength; }
+    long long getFrameFadeOutLength() const { return m_FrameFadeOutLength; }
+    char getValueUse() const { return m_ValueUse; }
+    int getValueFactor() const { return m_ValueFactor; }
+    int getTrack() const { return m_Track; }
+
+    long long getDelay() const { return m_Delay; }
+    long long getDuration() const { return m_Duration; }
+
+    bool getProjectIndepended(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo) const {
+        SPITType *ptrSPITType;
+        if (m_ServerRemote == false) {
+            ptrSPITType = repo.getEntry(m_SPITTypeID);
+            if (ptrSPITType == nullptr)
+                return true;
+            return ptrSPITType->getProjectIndepended();
+        } else {
+            ptrSPITType = remoteRepo.getEntry(m_SPITTypeID);
+            if (ptrSPITType == nullptr)
+                return true;
+            return ptrSPITType->getProjectIndepended();
+        }
+    };
+
+    bool setConfirmed(bool p_Confirmed);
+    void setCreatedByClient(bool p_CreatedByClient) { m_CreatedByClient = p_CreatedByClient; }
+    bool setName(string p_Name);
+    bool setRemark(string p_Remark);
+    bool setServerParams(string p_ServerParams);
+    bool setSPITTypeID(string p_GroupName);
+    bool setServerRemote(bool p_BelongstoServer);
+    bool setActionAssignedType(bool p_ActionAssigned);
+    bool setActionAssigned(bool p_ActionAssigned);
+    bool setFixed(bool p_Fixed);
+    bool setFrameStart(long long p_FrameStart);
+    bool setFrameLength(long long p_FrameLength);
+    bool setFrameFadeInLength(long long p_FrameFadeInLength);
+    bool setFrameFadeOutLength(long long p_FrameFadeOutLength);
+    bool setValueUse(char p_ValueUse);
+    bool setValueFactor(int p_ValueFactor);
+    bool setTrack(int p_Track);
+    bool setDelay(long long p_Delay);
+    bool setDuration(long long p_Duration);
+
+    bool setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject);
+    void fillMessageOP(SPIT_Message::ReportSPITObject &p_ReportSPITObject);
+    void fillMessageOP(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject);
+};
+
+#endif /* SPITOBJECT_H */

components/spit/include/SPITPlayer.h

@@ -0,0 +1,92 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * File:   SPITPLayer.h
+ * Author: Hagi
+ *
+ * Created on 30. April 2019, 11:44
+ */
+
+#ifndef SPITPLAYER_H
+#define SPITPLAYER_H
+
+#include "SPITObject.h"
+#include <unordered_map>
+
+class SPITPlayer {
+
+    //----- PlayObject used in PlaySequences: PlaySPITStart, PlaySPITObject,..., PlaySPITEnd ------
+  public:
+    class PlaySPITType {
+      public:
+        PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITObjectID);
+        PlaySPITType(const PlaySPITType &orig);
+
+        string getSPITTypeID() const { return m_SPITTypeID; }
+
+        void startPlaySequence();
+        bool getIsNew() const { return m_IsNew; }
+        void setIsNew(bool p_IsNew) { m_IsNew = p_IsNew; }
+        bool getIsPlayed() const { return m_IsPlayed; }
+        void setIsPlayed(bool p_IsFound) { m_IsPlayed = p_IsFound; }
+        string getPlayerID() const { return m_PlayerID; }
+        string getPlayerName() const { return m_PlayerName; }
+        bool getPlayerIsRunning() const { return m_PlayerRuns; }
+        void setPlayerIsRunning(bool p_PlayerRuns) { m_PlayerRuns = p_PlayerRuns; }
+        void setValue(double p_Value) { m_Value = p_Value; }
+        void addValue(double p_Value, double p_ValueFactor) { m_Value += (p_Value * p_ValueFactor); }
+        double getValue() const { return m_Value; }
+
+      private:
+        string m_PlayerID;
+        string m_PlayerName;
+        bool m_PlayerRuns;
+        string m_SPITTypeID;
+        bool m_IsPlayed;
+        bool m_IsNew;
+        double m_Value;
+    };
+
+    //----- SPITPlayer ------
+  public:
+    // list the SPITPlayers
+    static unordered_map<string, unique_ptr<SPITPlayer>> s_SPITPlayers; // all actual played objects
+    static SPITPlayer &getSPITPlayer(string p_PlayerID);      // if a player does not exist creates a new one
+    static void clearPlayers() { s_SPITPlayers.clear(); }
+
+    SPITPlayer(string p_PlayerID);
+    virtual ~SPITPlayer();
+
+    void startPlaySequence();                               // called by SPIT_Client::parsePlaySPITStart
+    PlaySPITType *addSPITType_Playing(string p_SPITTypeID); // called by SPIT_Client::parsePlaySPITStart
+    void endPlaySequence();                                 // called by SPIT_Client::parsePlaySPITEnd
+
+    string getID() {
+        return m_ID;
+    }
+
+    unordered_map<string, unique_ptr<PlaySPITType>> &getPlaySPITTypes() { return m_PlaySPITTypes; }
+    void setIsRunning(bool p_IsRunning) { m_IsRunning = p_IsRunning; }
+    void setName(string p_Name) { m_Name = p_Name; }
+    void setType(char p_Type) { m_Type = p_Type; }
+    void setTime(long long p_Frames) { m_TimeFrames = p_Frames; }
+    bool getIsRunning() const { return m_IsRunning; }
+    string getName() const { return m_Name; }
+    char getType() const { return m_Type; }
+    long long getTime() const { return m_TimeFrames; }
+
+  private:
+    string m_ID;
+    string m_Name;
+    char m_Type;
+    unordered_map<string, unique_ptr<PlaySPITType>> m_PlaySPITTypes;
+
+    bool m_IsRunning;
+    long long m_TimeFrames;
+};
+
+#endif /* SPITPLAYER_H */

components/spit/include/SPITSocket.h

@@ -0,0 +1,149 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * SPITSocket is the base class for WindowsSocket, UnixSocket,.
+ * Used by SPIT_Client and SAD_Client.
+ * File:   SPITSocket.h
+ * Author: Hagi
+ *
+ * Created on 12. April 2019, 15:40
+ */
+
+#ifndef SPITSOCKET_H
+#define SPITSOCKET_H
+
+#include "Task.hpp"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <sys/socket.h>
+#include <unistd.h>
+
+using namespace std;
+
+/** Returns an guid */
+string createGUID();
+/** Returns the name of the client's host computer*/
+string getClientHostName();
+
+class SPITSocket {
+  public:
+    static const int FAMILY_IP4 = AF_INET;
+
+    /**
+     * IPAddress class is used to fetch all available IP addresses of the computer
+     * This is for internal usage
+     */
+    struct IPAddress {
+      public:
+        IPAddress(const string &p_IPAddress, const string &p_SubnetMask)
+            : m_IPAddress(p_IPAddress), m_SubnetMask(p_SubnetMask) {}
+        const string m_IPAddress;
+        const string m_SubnetMask;
+
+        /**
+         * Calculates the broadcast address from a ip4 address
+         * @param p_IPAddress the ip4 address
+         * @return returns the broadcast address
+         */
+        string getBroadcastIP4() const {
+            struct in_addr broadcast;
+            unsigned long ulIPAddress;
+            unsigned long ulSubnetMask;
+
+            ulIPAddress = inet_addr(m_IPAddress.data());
+            ulSubnetMask = inet_addr(m_SubnetMask.data());
+            broadcast.s_addr = ulIPAddress | ~ulSubnetMask;
+
+            return inet_ntoa(broadcast);
+        }
+    };
+    const IPAddress mOwnIp;
+    static IPAddress getAdaptersInfo();
+    bool createSocket_UDP();
+    static const int INVALID_SOCKET = -1;
+
+  private:
+    int m_UDPSocketIP4;
+
+  public:
+    //-------- class --------------
+    SPITSocket(IPAddress ip) : mOwnIp(ip) {
+        m_UDPSocketIP4 = INVALID_SOCKET;
+        createSocket_UDP();
+    }
+    virtual ~SPITSocket() {
+        ESP_LOGD("UDP", "Shutting down ...");
+
+        if (m_UDPSocketIP4 != INVALID_SOCKET) {
+            shutdown(m_UDPSocketIP4, 2);
+            close(m_UDPSocketIP4);
+            m_UDPSocketIP4 = INVALID_SOCKET;
+        }
+        fos::Task::delayMs(100);
+        m_IsBound = false;
+    }
+
+  private:
+    string m_ServerIP{};
+    string m_ServerPort{};
+    string m_ClientIP{};
+    string m_ClientPort{};      // port given by the user maybe "0"
+    string m_BoundClientPort{}; // port set after bind
+    bool m_IsBound{};
+
+  public:
+    // Sets the ip address and port for server and client.
+    void setConnectionParams(const string &serverIp, const string &serverPort, const string &clientIp, const string &clientPort) {
+        m_ServerIP = serverIp;
+        m_ServerPort = serverPort;
+        m_ClientIP = clientIp;
+        m_ClientPort = clientPort;
+    }
+
+    /**
+     * Send a message to the server as set by setConnectionParams
+     * @param message  byte buffer containing the message
+     * @param length length of the message
+     * @return
+     */
+    int sendMessage(const char *message, int length) {
+        if (m_ServerPort.length() <= 0) {
+            return -1;
+        }
+
+        if (m_IsBound == false) {
+            return -1;
+        }
+        int intResult = sendMessageTo(m_ServerIP, m_ServerPort, message, length);
+        return intResult;
+    }
+
+    int receiveMessage(char *p_Buffer, int p_BufferLength, string *serverIp) const;
+    int setBroadcast(bool p_Broadcast) const;
+    int bindSocket(string clientIp, string clientPort);
+
+    int sendMessageTo(const string &ip, const string &port, const char *message, int msgLength);
+
+    string getServerIP() const { return m_ServerIP; }
+    string getServerPort() const { return m_ServerPort; }
+    string getClientIP() const { return m_ClientIP; }
+    string getClientPort() const { return m_ClientPort; }
+    string getBoundClientPort() const { return m_BoundClientPort; }
+    void setBoundClientPort(const string &p_Port) { m_BoundClientPort = p_Port; }
+    void setIsBound(bool p_IsBound) { m_IsBound = p_IsBound; }
+    bool getIsBound() const { return m_IsBound; }
+
+  private:
+};
+
+#endif /* SPITSOCKET_H */

components/spit/include/SPITType.h

@@ -0,0 +1,104 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * File:   SPITType.h
+ * Author: Hagi
+ *
+ * Created on 8. April 2019, 08:40
+ */
+
+#ifndef SPITTYPE_H
+#define SPITTYPE_H
+
+#include "SPITSocket.h"
+#include "SPIT_Message.h"
+#include "SpitRepo.hpp"
+
+using namespace std;
+
+class SPITTypeListener;
+
+class SPITType {
+  public:
+    static void setConfirmedFalse(SpitRepo<SPITType> &repo);
+    static void eventProjectClosed(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo);
+
+    SPITType(string p_ID);
+    SPITType(string p_ID, string p_GroupName, string p_Name, bool p_Fixed, bool p_ProjectIndepended, long long p_DefaultDelay, long long p_DefaultDuration);
+
+  private:
+    bool m_Confirmed{};
+    string m_ID;
+    bool m_Fixed{};
+    bool m_ServerRemote{};
+    bool m_ServerProjectIndepended{};
+    string m_GroupName{};
+    string m_Name{};
+    long long m_DefaultDelay{};
+    long long m_DefaultDuration{};
+
+    bool m_CreatedByClient; // flag true = the SPITTyype is created by the client
+                            // false = the SPITType is received from the server
+
+    bool m_ActionAssigned; // This is a virtual flag if user associates an action with a SPITType.
+                           // Can be used to setActionAssigned for all SPITObjects with this SPITType
+
+  public:
+    string getID() const { return m_ID; }
+    string getGroupName() const { return m_GroupName; }
+    string getName() const { return m_Name; }
+    /**
+     * Returns if the SPITType triggers an action on the Server or on the client.
+     * @return false = the action is triggered on the client The client waits for the server to play objects of this SPITType
+     * true = the action is triggered on the server. The server waits for the client to play objects of this SPITType.
+     */
+    bool getServerRemote() const { return m_ServerRemote; }
+    bool getProjectIndepended() const { return m_ServerProjectIndepended; }
+    /**
+     * This is used by the server and client to tell if the other side has registered the changes.
+     * @return true = other side has registered the changes.
+     */
+    bool getConfirmed() const { return m_Confirmed; }
+    bool getFixed() const { return m_Fixed; }
+    long long getDefaultDelay() const { return m_DefaultDelay; }
+    long long getDefaultDuration() const { return m_DefaultDuration; }
+    bool getCreatedByClient() const { return m_CreatedByClient; }
+
+    /**
+     * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
+     * This can used to setActionAssigned to all SPITObjects with this SPITType.
+     * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
+     * @return true = the user has associated an action with this SPITType.
+     */
+    bool getActionAssigned() const {
+        return m_ActionAssigned;
+    }
+
+    bool setGroupName(const string &p_GroupName);
+    bool setName(const string &p_Name);
+    bool setServerRemote(bool p_BelongstoServer);
+    bool setProjectIndepended(bool p_ProjectIndepeneded);
+    bool setConfirmed(bool p_Confirmed);
+    bool setFixed(bool p_Fixed);
+    bool setDefaultDelay(long long p_Delay);
+    bool setDefaultDuration(long long p_Duration);
+    void setCreatedByClient(bool p_CreatedByClient);
+
+    /**
+     * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
+     * This can used to setActionAssigned to all SPITObjects with this SPITType.
+     * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
+     * @return true = the m_ActionAssigned has changed.
+     */
+    bool setActionAssigned(bool p_ActionAssigned);
+
+    bool setMessageOP(SPIT_Message::ReportSPITType &reportSpitType);
+    void fillMessageOP(SPIT_Message::ReportSPITType &smReportSpitType) const;
+    void fillMessageOP(SPIT_Message::RemoveSPITType &smRemoveSpitType) const;
+};
+
+#endif /* SPITTYPE_H */

components/spit/include/SPIT_Client.h

@@ -0,0 +1,349 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * File:   SPIT_Client.h
+ * Author: Hagi
+ *
+ * Created on 7. April 2019, 08:50
+ */
+
+#ifndef SPIT_CLIENT_H
+#define SPIT_CLIENT_H
+
+#include "SAD_DetectedServer.hpp"
+#include "SPITObject.h"
+#include "SPITPlayer.h"
+#include "SPITSocket.h"
+#include "SPITType.h"
+#include "SPIT_Message.h"
+#include "SpitRepo.hpp"
+#include <memory>
+#include <vector>
+
+using namespace std;
+
+class SPIT_Client : I_SAD_Client {
+
+  public:
+    /** Maximal length of a SPITMessage*/
+    static const int MAXSPITMESSAGEBYTECOUNT = 512;
+
+    enum class ProjUpdate {
+        ServerLoaded,
+        StartTransfer,
+        EndTransfer,
+        ServerClosed,
+    };
+    enum class ServerEvent {
+        Detect,
+        Lost,
+        Changed,
+    };
+    enum class ObjectEvent {
+        Created,
+        Changed,
+        Deleted
+    };
+    enum class Connection {
+        None = 0,          // No Connection established.<br>Either no connect tried or disconnected
+        NoneServer = 1,    // Server has disconnected
+        Lost = 2,          // The connection is lost<br>Either because of a network crash or because the server no longer responds.
+        Ok = 3,            // Connection to the serv er is established.
+        TryConnection = 4, // A connection to the server is tried.
+    };
+
+    struct Callbacks {
+        void (*onServerEvent)(ServerEvent event, const SAD_DetectedServer &p_DetectedServer){};
+        void (*onConnectionStatus)(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime, Connection p_ConnectionStatus, Connection p_OldConnectionStatus){};
+        void (*onProjectUpdate)(ProjUpdate state, string projectId){};
+        void (*onSpitType)(ObjectEvent event, bool isRemote, const SPITType &p_SPITType){};
+        void (*onSpitObject)(ObjectEvent event, bool isRemote, const SPITType &p_SPITType, const SPITObject &p_SPITObject){};
+
+        void (*onPlay)(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames){};
+        void (*onPlaySpitType)(string p_PlayerID, string p_SPITTypeID, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value){};
+        void (*onPlayRemoteObjectStatus)(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value){};
+        bool (*onCheckSpitTypeVeto)(bool knownType, bool createdByClient){};
+        bool (*onCheckSpitObjectVeto)(bool knownType){};
+    };
+
+    //------ PlayerType ------
+  public:
+    /** continous main player, time value can be used like a timecode.<br>The time value is the position in server's project.<br>A server should use only one main player.*/
+    static constexpr char PLAYERTYPE_MAIN = 0x02;
+    /** continous player. This player plays SPIT objects sometime during the project.*/
+    static constexpr char PLAYERTYPE_CONTINOUS = 0x01;
+    /** diescrete player. This player is used to transmit single discrete values.*/
+    static constexpr char PLAYERTYPE_DISCRETE = 0x00;
+
+    //------ Value Flag ------
+    //------ used by sendRemoteObject
+  public:
+    /**Set the given value directly*/
+    static constexpr char VALUEFLAG_DIRECT = 0x00;
+    /**Increase the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
+    static constexpr char VALUEFLAG_INCREASE = 0x01;
+    /**Decrease the existing value by the given value.<br>This is usefull e.g. when instead of a fader a endless wheel is used*/
+    static constexpr char VALUEFLAG_DECREASE = 0x02;
+    static constexpr int MAX_OVERTAKING_SPIT_MESSAGES = 10;
+
+    //----- SPIT_Client -----
+  public:
+    SPIT_Client(string name, string projName, Callbacks calls);
+    virtual ~SPIT_Client();
+
+  private:
+    Callbacks mCallbacks;
+
+    fos::TaskT<SPIT_Client &> *m_ThreadReceive{};
+    bool m_StopReceiveSPITMessages{};
+
+    Connection m_ConnectionStatus{Connection::None};
+    bool m_DisconnectedByServer{}; // flag true = when server disconnects
+    string m_ID;
+    string m_Name;
+    string m_ProjName;
+    string m_ComputerName;
+
+    string m_ClientProjectName;
+
+    uint8_t m_MessageNumber_Send{1};
+    int m_MessageNumber_Received{-1}; // set to -1 because the first received message will set the number (1..255)
+    vector<unique_ptr<SPIT_Message>> m_OvertakingSPIT_Messages;
+
+    // Server's info filled by parseConnectAnswer
+    string m_ServerID{};
+    string m_ServerName{};
+    string m_ServerComputerName{};
+    int m_ServerStepTime{-1};
+
+    //--- Server Project ---
+    string m_ServerProjectID;
+    string m_ServerProjectName;
+    int m_ServerFramesPerSecond;
+
+  public:
+    /** The ID of the client.<br>Every client instance should set an unique id*/
+    string getID() { return m_ID; }
+    /** The name of the client, should be set by the user app*/
+    string getName() { return m_Name; }
+    //----- Computer Params -----
+    /** The name of the client's host computer*/
+    string getComputerName() { return m_ComputerName; }
+    void setClientProjectName(string p_ClientProjectName) { m_ClientProjectName = p_ClientProjectName; }
+    string getClientProjectName() { return m_ClientProjectName; }
+
+    // connected Server Infos
+    /** The ID of the connected SPITServer*/
+    string getServerID() { return m_ServerID; }
+    /** The host computername of the connected SPITServer*/
+    string getServerComputerName() { return m_ServerComputerName; }
+    /** The name of the connected SPITServer*/
+    string getServerName() { return m_ServerName; }
+
+    /** Expected Refreah Rate of the connectd SPITServer.<br>
+     * When the server plays objects, it will do so at discrete time steps.<br>
+     * Play events will take place in these time steps..
+     */
+    int getServerStepTime() { return m_ServerStepTime; }
+
+    /** Should be called when the client wants to close his project*/
+    void clientProjectClose();
+    /**
+     * Should be called whenever the client has a project loaded
+     */
+    void clientProjectLoaded();
+
+    /**
+     *
+     * @param p_SPITTypeID
+     * @param p_ActionAssigned
+     */
+    void setActionSPITType(string p_SPITTypeID, bool p_ActionAssigned);
+    void setActionSPITObject(string p_SPITObjectID, bool p_ActionAssigned);
+
+    //--------------- SPITMessage ---------------
+  private:
+    bool startReceiveSPITMessages();
+    void stopReceiveSPITMessages();
+    static void receiveSPITMessage(SPIT_Client &rM);
+    // Reconnect to the server when connection is lost see eventConnectionStatus and eventServerDetected
+    bool _doReconnect{}; // true = on eventServerDetected connect to the server identified by m_ServerID
+  public:
+    int sendSPITMessage(SPIT_Message::OPPart & spitMessageOPPart);
+
+    //--------------- ServerAutoDetection SAD ---------------
+  public:
+    /** Starts the autodetection of SPITServers in the local network. If a connection is tried, the autodetection should be stopped before.*/
+    void startServerAutoDetect();
+    /** Stops the autodetection of SPITServers in the local network*/
+    void stopServerAutoDetect();
+    /** Called every time a new SPITServer is detetced in the local network */
+    void eventServerDetected(SAD_DetectedServer &server);
+    /** Called every time a prior detected SPITServer is is no longer found.*/
+    void eventServerLost(SAD_DetectedServer &server);
+    void eventServerChanged(SAD_DetectedServer &server);
+
+    //--------------- Connection ---------------
+  public:
+    /**
+     * Tries a connection to the SPITServer
+     * @param p_ServerIP ip address of the SPITServer
+     * @param p_ServerPort port of the SPITServer
+     * @param p_ClientIP IP of the client
+     * @param p_ClientPort if "0" any free port will be used
+     * @param p_LoginName maybe some SPITServer need a login - liveSHOWsoftware will not.
+     * @param p_LoginPassword maybe some SPITServer need a login - liveSHOWsoftware will not
+     * @return true = the connection try is ok, SPITServer will answer with COnnectAnswer and an eventConnectionStatus will occur.<br>
+     * false = something is going wrong. (client could not bind)
+     */
+    bool connect(string p_ServerIP, string p_ServerPort, string p_ClientIP, string p_ClientPort, string p_LoginName = "", string p_LoginPassword = "");
+    /**
+     * Terminates the connection to the SPITServer.
+     */
+    void disconnect();
+
+  private:
+    void disconnectInternal(Connection p_Cause);
+    void resetMessageNumberReceived();
+    void parseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
+    void checkParseSPIT_Message(unique_ptr<SPIT_Message> p_SPITMessage);
+    void addOvertakingSPIT_Message(unique_ptr<SPIT_Message> p_SPIT_Message);
+    void parseConnectAnswer(SPIT_Message::ConnectAnswer &p_ConnectAnswer);
+    void parseDisconnect(SPIT_Message::Disconnect &p_Disconnect);
+    void parseWatchdog(SPIT_Message::Watchdog &p_Watchdog);
+    void parseWatchdogAnswer(SPIT_Message::WatchdogAnswer &p_WatchdogAnswer);
+
+  public:
+    /** Used internally*/
+    void sendWatchdog();
+    /** Used internally. When the connection to the SPITServer is lost an eventConnectionStatus will occur*/
+    void eventWatchdogLost();
+    //--------------- SPIT Project ---------------
+  private:
+    void parseReportSPITProject(SPIT_Message::ReportSPITProject &p_ReportSPITProject);
+    void parseCloseSPITProject(SPIT_Message::CloseSPITProject &p_CloseSPITProject);
+
+  public:
+    /** Returns the SPITServer's project ID - may be the same as the project's name*/
+    string getServerProjectID();
+    /** Returns the SPITServer's project name*/
+    string getServerProjectName();
+    /** Returns frame rate per second. This is the time resolution in which the server transmits time data. The unit of time data is always frames.*/
+    int getServerFramesPerSecond();
+
+  private:
+    void parseRequestProjectTransfer(SPIT_Message::RequestProjectTransfer &p_RequestProjectTransfer);
+    void parseStartProjectTransfer(SPIT_Message::StartProjectTransfer &p_StartProjectTransfer);
+    void parseEndProjectTransfer(SPIT_Message::EndProjectTransfer &p_EndProjectTransfer);
+
+  public:
+    static void sendProject(SPIT_Client *p_PtrSPIT_Client);
+
+    // --------------- SPIT Types ---------------
+  public:
+    /**
+     * Creates a fixed SPITType for application actions that are always present and project independent.<br>
+     * Fixed SPIT types cannot be changed or deleted by the server.<br>
+     * These SPITTypes will be automatically added to the SPITType-List and sended to the server.
+     * @param p_ID an unique of the SPITType, these are always the same per client approach. Different client approaches should use different ids.
+     * @param p_GroupName a name which groups the actions/SPITTypes
+     * @param p_Name the name of the Action/SPITType
+     * @param p_DefaultDelay maybe there is an default delay until the action starts, this is only used for graphical representations, 0 is allowd
+     * @param p_DefaultDuration maybe the action has a default duration, this is only used for graphical representations, 0 is allowd
+     * @return the pointer to the new SPITType.
+     */
+    SPITType *createSPITTypeFixed(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration);
+
+    /**
+     * Creates a SPITType for application actions.<br>
+     * These SPITTypes will be automatically added to the SPITType-List and sended to the server.
+     * @param p_ID an unique of the SPITType, these are always the same per client approach. Different client approaches should use different ids.
+     * @param p_GroupName a name which groups the actions/SPITTypes
+     * @param p_Name the name of the Action/SPITType
+     * @param p_DefaultDelay maybe there is an default delay until the action starts, this is only used for graphical representations, 0 is allowd
+     * @param p_DefaultDuration maybe the action has a default duration, this is only used for graphical representations, 0 is allowd
+     * @param p_Fixed true = the server is not allowed to change this SPITType, false = the server may change or delete this SPITType
+     * @param p_ProjectIndepended true = the SPITType belongs to a specific project, false = the SpitType always exists for every project
+     * @return the pointer to the new SPITType.
+     */
+    SPITType *createSPITType(string p_ID, string p_GroupName, string p_Name, long long p_DefaultDelay, long long p_DefaultDuration, bool p_Fixed, bool p_ProjectIndepended);
+
+  private:
+    // receive SPITTypes
+    void parseReportSPITType(SPIT_Message::ReportSPITType &p_ReportSPITType);
+    void parseRemoveSPITType(SPIT_Message::RemoveSPITType &p_RemoveSPITType);
+    int sendSPITTypeInternal(SPITType &p_SPITType);
+
+  public:
+    /**
+     * If a client wants to change a SPITType, he should send it to the server.<br>
+     * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the change.<br>
+     * @param p_SPITTypeID the id of the SPITType to remove.
+     * @return 0 = is sended, -1 = is not sended
+     */
+    bool changeSPITType(SPITType *p_SPITType);
+    /**
+     * If a client wants to remove a SPITType, he should send it to the server.<br>
+     * If the SPITTye is a fixed one and not created by the client himself, then an eventSPITType can be sent from the server, which cancels the deletion.<br>
+     * @param p_SPITTypeID the id of the SPITType to remove.
+     * @return 0 = is sended, -1 = is not sended
+     */
+    int removeSPITType(string p_SPITTypeID);
+
+  public:
+    //--------------- SPIT Objects ---------------
+  private:
+    void parseReportSPITObject(SPIT_Message::ReportSPITObject &p_ReportSPITObject);
+    void parseRemoveSPITObject(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject);
+    int sendSPITObjectInternal(SPITObject *ptrSPITObject);
+
+  public:
+    /**
+     * When the client changes a SPITObject (normally the client should not do this), then it should send the changes to the SPITServer.<br>
+     * The SPITServer may discard the changes and an eventSPITObject occurs.<br>
+     * @param p_SPITObject the pointer to the changed SPITObject.
+     * @return 0 = sended, -1 = not sended
+     */
+    bool changeSPITObject(SPITObject *p_SPITObject);
+    /**
+     * When the client removes a SPITObject (normally the client should not do this), then he should send it to the SPITServer.<br>
+     * The SPITServer may discard the deletion and an eventSPITObject occurs.<br>
+     * @param p_SPITObjectID the id of the SPITObject to remove.
+     * @return 0 = sended, -1 = not sended
+     */
+    int removeSPITObject(string p_SPITObjectID);
+
+  public:
+    //--------------- Play SPIT Objects ---------------
+  private:
+    void parsePlaySPITStart(SPIT_Message::PlaySPITStart &p_PlaySPITStart);
+    void parsePlaySPITObject(SPIT_Message::PlaySPITObject &p_PlaySPITObject);
+    void parsePlaySPITEnd(SPIT_Message::PlaySPITEnd &p_PlaySPITEnd);
+    void parseReportPlayStatus(SPIT_Message::ReportPlayStatus &p_ReportPlayStatus);
+
+  public:
+    //--------- Remote ----------
+    void sendRemoteObject(string p_SPITObjectID, int p_Valueppm = 0, char p_ValueFlag = 0x00);
+
+  private:
+    static void processSocketTask(SPIT_Client &instance);
+    fos::TaskT<SPIT_Client &> *sThread{};
+    bool mAbortSearch{};
+    bool sAnswered{};
+    static fos::Semaphore sStartSad;
+    SPITSocket *mSPITSocket;
+    void answerWatchdog() {
+        sAnswered = true;
+    }
+
+    SpitRepo<SPITObject> mSpitObjects;
+    SpitRepo<SPITObject> mRemoteSpitObjects;
+    SpitRepo<SPITType> mSpitTypes;
+    SpitRepo<SPITType> mRemoteSpitTypes;
+};
+
+#endif /* SPIT_CLIENT_H */

components/spit/include/SPIT_Message.h

@@ -0,0 +1,728 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * File:   SPIT_Message.h
+ * Author: Hagi
+ *
+ * Created on 3. April 2019, 08:51
+ */
+
+#ifndef SPIT_MESSAGE_H
+#define SPIT_MESSAGE_H
+
+#include <cstdlib>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+using namespace std;
+
+static const string SPITID = "#spit#";
+
+class SPIT_Message {
+    //----------- Header -----------
+  public:
+    class Header {
+      public:
+        static constexpr int BYTESLENGTH = 99;
+        Header(const Header &orig);
+        Header();
+
+      private:
+        string m_SPITID;
+        int m_SPITVersion{SPITVERSION};
+        unsigned char m_MessageNumber{};
+        int m_BytesCount{BYTESLENGTH};
+        string m_ServerID{};
+        string m_ClientID{};
+        int m_OPFlag{-1};
+        int m_ParseOffset{};
+
+      public:
+        string getSPITID() const { return m_SPITID; }
+        int getSPITVersion() const { return m_SPITVersion; }
+        unsigned char getMessageNumber() const { return m_MessageNumber; }
+        int getBytesCount() const { return m_BytesCount; }
+        string getServerID() const { return m_ServerID; }
+        string getClientID() const { return m_ClientID; }
+        int getOPFlag() const { return m_OPFlag; }
+
+        // Receive
+        bool parse(const std::vector<char> &message);
+
+        // Send
+        Header(int p_SPITVersion, int p_OPFlag);
+        void setMessageNumber(unsigned char p_MessageNumber) { m_MessageNumber = p_MessageNumber; }
+        void setServerID(string p_ID) { m_ServerID = p_ID; }
+        void setClientID(string p_ID) { m_ClientID = p_ID; }
+        void setOPFlag(int p_OPFlag) { m_OPFlag = p_OPFlag; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- OPPart -----------
+  public:
+    class OPPart {
+
+        // Members
+      protected:
+        unique_ptr<Header> m_Header{};
+        int m_ParseOffset{};
+        int m_BytesCount;
+
+      public:
+     		virtual ~OPPart();
+
+        Header *getHeader() const { return m_Header.get(); }
+        int getBytesCount() const { return m_BytesCount; }
+        void setServerInfoInHeader(string clientId, string serverId) {
+            if (!m_Header)
+                return;
+            m_Header->setClientID(clientId);
+            m_Header->setServerID(serverId);
+        }
+        void setMessageNumber(uint8_t no) {
+            if (!m_Header)
+                return;
+            m_Header->setMessageNumber(no);
+        }
+
+        const string getServerID() const {
+            if (!m_Header) {
+                return "";
+            }
+            return m_Header->getServerID();
+        }
+        const string getClientID() const {
+            if (!m_Header) {
+                return "";
+            }
+            return m_Header->getClientID();
+        }
+
+        int getOPFlag() const {
+            if (!m_Header) {
+                return -1;
+            }
+            return m_Header->getOPFlag();
+        }
+
+        // Receive
+        OPPart(unique_ptr<Header> p_Header, int p_OPFlag, int size);
+        void setHeader(int opFlag);
+        virtual bool parse(const std::vector<char> &message) = 0;
+
+        // Send
+        OPPart(int size);
+        virtual bool fillBytes(std::vector<char> &message) = 0;
+    };
+
+    //----------- SPIT_Message -----------
+
+  public:
+    static constexpr int SPITVERSION = 1;
+
+    // SPIT_Object value usage
+    static constexpr char VALUEUSE_DISCARD = 0x00;  // value of SPITObejct is not used
+    static constexpr char VALUEUSE_INRANGE = 0x01;  // value of SPITOBject in range 0 - 1000000ppm
+    static constexpr char VALUEUSE_OVERRIDE = 0x02; // value can be overridden
+
+    // SPIT Player type
+    static constexpr char PLAYERTYPE_MAIN = 0x02;
+    static constexpr char PLAYERTYPE_CONTINIOUS = 0x01;
+    static constexpr char PLAYERTYPE_DISCRETE = 0x00;
+
+    // PlayObject value usage
+    static constexpr char VALUEFLAG_DIRECT = 0x00;   // use the vlue direct
+    static constexpr char VALUEFLAG_INCREASE = 0x01; // increase the value
+    static constexpr char VALUEFLAG_DECREASE = 0x02; // decrease the value
+
+    SPIT_Message() = default;
+
+    // Members
+  private:
+    unique_ptr<OPPart> m_OPPart{};
+
+    // Receive
+  public:
+    SPIT_Message(std::vector<char> message);
+
+    const Header *getHeader() const { return m_OPPart->getHeader(); }
+    int getOPFlag() const {
+        if (!m_OPPart || !m_OPPart->getHeader()) {
+            return -1;
+        }
+        return m_OPPart->getHeader()->getOPFlag();
+    }
+    const OPPart *getOPPart() const { return m_OPPart.get(); }
+    template<typename T>
+    T &getOPPartAs() const { return *reinterpret_cast<T *>(m_OPPart.get()); }
+
+  private:
+    bool parse(std::vector<char> message);
+
+    // Send
+  public:
+    static std::vector<char> createMessage(OPPart & p_OPPart);
+
+    //------------------------------ Connection ----------------------------------
+
+    //----------- Connect -----------
+  public:
+    class Connect : public OPPart {
+      public:
+        static constexpr int OPFLAG = 1;
+        static constexpr int BYTESLENGTH = 304;
+
+      private:
+        string m_ClientComputerName{};
+        string m_ClientName{};
+        string m_LoginName{};
+        string m_LoginPassword{};
+        string m_ServerIP{};
+        int m_ServerPort{};
+
+      public:
+        // Receive
+        Connect(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        string getClientComputerName() const { return m_ClientComputerName; }
+        string getClientName() const { return m_ClientName; }
+        string getLoginName() const { return m_LoginName; }
+        string getLoginPassword() const { return m_LoginPassword; }
+        string getServerIP() const { return m_ServerIP; }
+        int getServerPort() const { return m_ServerPort; }
+
+        // Send
+        Connect(string p_ComputerName, string p_ClientName);
+
+        void setLoginName(string p_LoginName) { m_LoginName = p_LoginName; }
+        void setLoginPassword(string p_LoginPassword) { m_LoginPassword = p_LoginPassword; }
+        void setServerIP(string p_ServerIP) { m_ServerIP = p_ServerIP; }
+        void setServerPort(int p_ServerPort);
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- ConnectAnswer -----------
+
+    class ConnectAnswer : public OPPart {
+      public:
+        static constexpr int OPFLAG = 2;
+        static constexpr int BYTESLENGTH = 137;
+
+      private:
+        string m_ServerComputerName{};
+        string m_ServerName{};
+        bool m_Connected{};
+        int m_StepTime{40}; // ms step size the Server will send play sequences
+
+      public:
+        ConnectAnswer(const ConnectAnswer &orig);
+        // Receive
+        ConnectAnswer(unique_ptr<Header> p_Header);
+
+        bool parse(const std::vector<char> &message);
+
+        const string getServerComputerName() const { return m_ServerComputerName; }
+        const string getServerName() const { return m_ServerName; }
+        bool getConnected() const { return m_Connected; }
+        int getStepTime() const { return m_StepTime; }
+
+        // Send
+        ConnectAnswer();
+        void setServerComputerName(string p_ServerComputerName) { m_ServerComputerName = p_ServerComputerName; }
+        void setServerName(string p_ServerName) { m_ServerName = p_ServerName; }
+        void setConnected(bool p_Connected) { m_Connected = p_Connected; }
+        void setStepTime(int p_StepTime_ms);
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- Disconnect -----------
+
+    class Disconnect : public OPPart {
+      public:
+        static constexpr int OPFLAG = 3;
+        static constexpr int BYTESLENGTH = 4;
+
+        Disconnect(const Disconnect &orig);
+        // Receive
+        Disconnect(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        // Send
+        Disconnect();
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- Watchdog -----------
+
+    class Watchdog : public OPPart {
+      public:
+        static constexpr int OPFLAG = 8;
+        static constexpr int BYTESLENGTH = 4;
+
+        Watchdog(const Watchdog &orig);
+        // Receive
+        Watchdog(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        // Send
+        Watchdog();
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- WatchdogAnswer -----------
+
+    class WatchdogAnswer : public OPPart {
+      public:
+        static constexpr int OPFLAG = 9;
+        static constexpr int BYTESLENGTH = 4;
+
+        // Receive
+        WatchdogAnswer(const WatchdogAnswer &orig);
+        WatchdogAnswer(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        // Send
+        WatchdogAnswer();
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //------------------------------ SPITProject ----------------------------------
+
+    //----------- ReportSPITProject -----------
+
+    class ReportSPITProject : public OPPart {
+      public:
+        static constexpr int OPFLAG = 11;
+        static constexpr int BYTESLENGTH = 113;
+
+      private:
+        string m_ProjectID{};
+        string m_ProjectName{};
+        int m_FramesPerSecond{1000}; // Frames per second
+
+        // Receive
+      public:
+        ReportSPITProject(const ReportSPITProject &orig);
+        ReportSPITProject(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+        const string getProjectID() const { return m_ProjectID; }
+        const string getProjectName() const { return m_ProjectName; }
+        int getFramesPerSecond() const { return m_FramesPerSecond; }
+        // Send
+        ReportSPITProject(string p_ProjectID, string p_ProjectName);
+
+        void setFramesPerSecond(const int p_FramesPerSecond) { m_FramesPerSecond = p_FramesPerSecond; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- CloseSPITProject -----------
+
+    class CloseSPITProject : public OPPart {
+      public:
+        static constexpr int OPFLAG = 13;
+        static constexpr int BYTESLENGTH = 45;
+
+      private:
+        string m_ProjectID{};
+
+      public:
+        CloseSPITProject(const CloseSPITProject &orig);
+        // Receive
+        CloseSPITProject(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+        const string getProjectID() const {
+            return m_ProjectID;
+        }
+        // Send
+        CloseSPITProject(string projectID);
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- StartProjectTransfer -----------
+    class RequestProjectTransfer : public OPPart {
+      public:
+        static constexpr int OPFLAG = 15;
+        static constexpr int BYTESLENGTH = 4;
+
+        RequestProjectTransfer(const RequestProjectTransfer &orig);
+        // Receive
+        RequestProjectTransfer(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+        // Send
+        RequestProjectTransfer();
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- StartProjectTransfer -----------
+
+    class StartProjectTransfer : public OPPart {
+      public:
+        static constexpr int OPFLAG = 16;
+        static constexpr int BYTESLENGTH = 4;
+
+        StartProjectTransfer(const StartProjectTransfer &orig);
+        // Receive
+        StartProjectTransfer(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+        // Send
+        StartProjectTransfer();
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- EndProjectTransfer -----------
+    class EndProjectTransfer : public OPPart {
+      public:
+        static constexpr int OPFLAG = 17;
+        static constexpr int BYTESLENGTH = 4;
+
+        EndProjectTransfer(const EndProjectTransfer &orig);
+        // Receive
+        EndProjectTransfer(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+        // Send
+        EndProjectTransfer();
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //---------------------------- SPIT_Types ----------------------------------
+
+    //----------- ReportSPITType -----------
+    class ReportSPITType : public OPPart {
+      public:
+        static constexpr int OPFLAG = 21;
+        static constexpr int BYTESLENGTH = 168;
+
+      private:
+        bool m_Confirmed{};
+        string m_SPITTypeID{};
+        bool m_Fixed{};
+        bool m_ServerRemote{};
+        bool m_ServerProjectIndepended{};
+        string m_SPITTypeGroupName{};
+        string m_SPITTypeName{};
+        long long m_Delay{};
+        long long m_Duration{};
+
+      public:
+        ReportSPITType(const ReportSPITType &orig);
+        // Receive
+        ReportSPITType(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        bool getConfirmed() const { return m_Confirmed; }
+        const string getID() const { return m_SPITTypeID; }
+        bool getFixed() const { return m_Fixed; }
+        bool getServerRemote() const { return m_ServerRemote; }
+        bool getServerProjectIndepended() const { return m_ServerProjectIndepended; }
+        const string getGroupName() const { return m_SPITTypeGroupName; }
+        const string getName() const { return m_SPITTypeName; }
+        long long getDelay() const { return m_Delay; }
+        long long getDuration() const { return m_Duration; }
+        // Send
+
+        ReportSPITType();
+        void setConfirmed(bool p_Confirmed) { m_Confirmed = p_Confirmed; }
+        void setID(string p_ID) { m_SPITTypeID = p_ID; }
+        void setFixed(bool p_Fixed) { m_Fixed = p_Fixed; }
+        void setServerRemote(bool p_IsServerRemote) { m_ServerRemote = p_IsServerRemote; }
+        void setServerProjectIndepended(bool p_ProjectIndpended) { m_ServerProjectIndepended = p_ProjectIndpended; }
+        void setGroupName(string p_GroupName) { m_SPITTypeGroupName = p_GroupName; }
+        void setName(string p_Name) { m_SPITTypeName = p_Name; }
+        void setDelay(long long p_Delay) { m_Delay = p_Delay; }
+        void setDuration(long long p_Duration) { m_Duration = p_Duration; }
+
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- RemoveSPITType -----------
+
+    class RemoveSPITType : public OPPart {
+      public:
+        static constexpr int OPFLAG = 23;
+        static constexpr int BYTESLENGTH = 45;
+
+      private:
+        string m_SPITTypeID{};
+
+      public:
+        RemoveSPITType(const RemoveSPITType &orig);
+        // Receive
+        RemoveSPITType(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        const string getID() const { return m_SPITTypeID; }
+
+        // Send
+        RemoveSPITType();
+        void setID(string p_ID) { m_SPITTypeID = p_ID; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //---------------------------- SPITObjects ----------------------------------
+
+    //----------- ReportSPITObject -----------
+
+    class ReportSPITObject : public OPPart {
+      public:
+        static constexpr int OPFLAG = 31;
+        static constexpr int BYTESLENGTH = 339;
+
+      private:
+        bool m_Confirmed{};
+        string m_SPITObjectID{};
+        bool m_Fixed{};
+        bool m_ServerRemote{};
+        string m_SPITObjectName{};
+        string m_SPITTypeID{};
+        string m_ServerParams{};
+        long long m_FrameStart{};
+        long long m_FrameLength{};
+        long long m_FrameFadeInLength{};
+        long long m_FrameFadeOutLength{};
+        int m_ValueFactor{};
+        char m_ValueUse{VALUEUSE_DISCARD};
+        int m_Track{};
+        string m_Remark{};
+        long long m_Delay{};
+        long long m_Duration{};
+        bool m_ActionAssigned{};
+
+      public:
+        ReportSPITObject(const ReportSPITObject &orig);
+        // Receive
+        ReportSPITObject(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        bool getConfirmed() const { return m_Confirmed; }
+        const string getID() const { return m_SPITObjectID; }
+        bool getFixed() const { return m_Fixed; }
+        bool getServerRemote() const { return m_ServerRemote; }
+        const string getName() const { return m_SPITObjectName; }
+        const string getSPITTypeID() const { return m_SPITTypeID; }
+        const string getServerParams() const { return m_ServerParams; }
+        long long getFrameStart() const { return m_FrameStart; }
+        long long getFrameLength() const { return m_FrameLength; }
+        long long getFrameFadeInLength() const { return m_FrameFadeInLength; }
+        long long getFrameFadeOutLength() const { return m_FrameFadeOutLength; }
+        int getValueFactor() const { return m_ValueFactor; }
+        char getValueUse() const { return m_ValueUse; }
+        int getTrack() const { return m_Track; }
+        const string getRemark() const { return m_Remark; }
+        long long getDelay() const { return m_Delay; }
+        long long getDuration() const { return m_Duration; }
+        bool getActionAssigned() const { return m_ActionAssigned; }
+        // Send
+      public:
+        ReportSPITObject();
+
+        void setConfirmed(bool p_Confirmed) { m_Confirmed = p_Confirmed; };
+        void setID(string p_ID) { m_SPITObjectID = p_ID; };
+        void setFixed(bool p_Fixed) { m_Fixed = p_Fixed; };
+        void setServerRemote(bool p_IsRemote) { m_ServerRemote = p_IsRemote; };
+        void setName(string p_Name) { m_SPITObjectName = p_Name; };
+        void setSPITTypeID(string p_ID) { m_SPITTypeID = p_ID; };
+        void setServerParams(string p_Parameters) { m_ServerParams = p_Parameters; };
+        void setFrameStart(long long p_StartTime) { m_FrameStart = p_StartTime; };
+        void setFrameLength(long long p_Length) { m_FrameLength = p_Length; };
+        void setFrameFadeInLength(long long p_FadeInTime) { m_FrameFadeInLength = p_FadeInTime; };
+        void setFrameFadeOutLength(long long p_FadeOutTime) { m_FrameFadeOutLength = p_FadeOutTime; };
+        void setValueFactor(int p_Volume) { m_ValueFactor = p_Volume; };
+        void setValueUse(char p_ValueUse) { m_ValueUse = p_ValueUse; };
+        void setTrack(int p_Track) { m_Track = p_Track; };
+        void setRemark(string p_Description) { m_Remark = p_Description; };
+        void setDelay(long long p_Delay);
+        void setDuration(long long p_Duration);
+        void setActionAssigned(bool p_ActionAssigned) { m_ActionAssigned = p_ActionAssigned; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- RemoveSPITObject -----------
+
+    class RemoveSPITObject : public OPPart {
+      public:
+        static constexpr int OPFLAG = 33;
+        static constexpr int BYTESLENGTH = 45;
+
+      private:
+        string m_SPITObjectID{};
+
+      public:
+        RemoveSPITObject(const RemoveSPITObject &orig);
+        // Receive
+        RemoveSPITObject(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        const string getID() const { return m_SPITObjectID; }
+        // Send
+      public:
+        RemoveSPITObject();
+        void setID(string p_ID) { m_SPITObjectID = p_ID; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //---------------------------- SPITPlayer ----------------------------------
+
+    //----------- PlaySPITStart -----------
+
+    class PlaySPITStart : public OPPart {
+      public:
+        static constexpr int OPFLAG = 37;
+        static constexpr int BYTESLENGTH = 119;
+
+      private:
+        string m_PlayerID{};
+        string m_PlayerName{};
+        char m_PlayerType{};
+        bool m_PlayerIsRunning{};
+        long long m_Time; // Frames
+
+      public:
+        PlaySPITStart(const PlaySPITStart &orig);
+        // Receive
+        PlaySPITStart(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        const string getPlayerID() const { return m_PlayerID; }
+        const string getPlayerName() const { return m_PlayerName; }
+        char getPlayerType() const { return m_PlayerType; }
+        bool getPlayerIsRunning() const { return m_PlayerIsRunning; }
+        long long getTime() const { return m_Time; }
+
+        // Send
+        PlaySPITStart(string p_PlayerID, string p_PlayerName, char p_PlayerType);
+        void setPlayerIsRunning(bool p_IsPlaying) { m_PlayerIsRunning = p_IsPlaying; }
+        void setTime(long long p_Time) { m_Time = p_Time; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- PlaySPITObject -----------
+
+    class PlaySPITObject : public OPPart {
+      public:
+        static constexpr int OPFLAG = 38;
+        static constexpr int BYTESLENGTH = 100;
+
+      private:
+        string m_PlayerID{};
+        string m_SPITObjectID{};
+        long long m_FrameInsideObject{}; // Frames
+        bool m_PlayPrePosition{};
+        int m_Value{};
+        char m_ValueFlag{VALUEFLAG_DIRECT};
+
+      public:
+        PlaySPITObject(const PlaySPITObject &orig);
+        // Receive
+        PlaySPITObject(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        const string getPlayerID() const { return m_PlayerID; }
+        const string getSPITObjectID() const { return m_SPITObjectID; }
+        long long getFrameInsideObject() const { return m_FrameInsideObject; }
+        bool getPlayPrePosition() const { return m_PlayPrePosition; }
+        int getValue() const { return m_Value; }
+        char getValueFlag() const { return m_ValueFlag; }
+        // Send
+        PlaySPITObject();
+
+        void setPlayerID(string p_PlayerID) { m_PlayerID = p_PlayerID; }
+        void setID(string p_ID) { m_SPITObjectID = p_ID; }
+        void setFrameInsideObject(long long p_TimeInside) { m_FrameInsideObject = p_TimeInside; }
+        void setPlayPrePosition(bool p_PlayOldPosition) { m_PlayPrePosition = p_PlayOldPosition; }
+        void setValue(int p_Value) { m_Value = p_Value; }
+        void setValueFlag(char p_ValueFlag) { m_ValueFlag = p_ValueFlag; }
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- PlaySPITEnd -----------
+    class PlaySPITEnd : public OPPart {
+      public:
+        static constexpr int OPFLAG = 39;
+        static constexpr int BYTESLENGTH = 45;
+
+      private:
+        string m_PlayerID{};
+
+      public:
+        PlaySPITEnd(const PlaySPITEnd &orig);
+        // Receive
+        PlaySPITEnd(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+        const string getPlayerID() const { return m_PlayerID; }
+
+        // Send
+        PlaySPITEnd(string p_PlayerID);
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------- ReportPlayStatus -----------
+
+    class ReportPlayStatus : public OPPart {
+      public:
+        static constexpr int OPFLAG = 40;
+        static constexpr int BYTESLENGTH = 57;
+
+      private:
+        string m_SPITObjectID{};
+        long long m_FrameInsideObject{}; // Frames
+        int m_Value{};
+
+      public:
+        ReportPlayStatus(const ReportPlayStatus &orig);
+        // Receive
+        ReportPlayStatus(unique_ptr<Header> p_Header);
+        bool parse(const std::vector<char> &message);
+
+        const string getID() const { return m_SPITObjectID; }
+        long long getFrameInsideObject() const { return m_FrameInsideObject; }
+        int getValue() const { return m_Value; }
+        // Send
+        ReportPlayStatus();
+
+        void setID(string p_ID);
+        void setFrameInsideObject(long long p_TimeInside);
+        void setValue(int p_Value);
+        bool fillBytes(std::vector<char> &message);
+    };
+
+    //----------------------- static helper functions ----------------------------
+  public:
+    static bool isSystemLittleEndian();
+    static optional<int> getInt(const std::vector<char> &message, int &offset);
+    static optional<long long> getLong(const std::vector<char> &message, int &offset);
+    static optional<bool> getBoolean(const std::vector<char> &message, int &offset);
+    static optional<char> getByte(const std::vector<char> &message, int &offset);
+    static int setInt(int value, std::vector<char> &message, int offset);
+    static int setLong(long long value, std::vector<char> &message, int offset);
+    static int setBoolean(bool value, std::vector<char> &message, int offset);
+    static int setByte(int value, std::vector<char> &message, int offset);
+
+    /**
+     * Returns the string char* of the part of the byte sequence (0x00 null terminated).
+     * @param p_Bytes the byte array
+     * @param offset the startposition of strings bytes
+     * @param p_Length the length of the string included the null terminate byte (0x00).
+     * The length of the string will be p_Length -1.
+     */
+    static optional<string> getString(const std::vector<char> &message, int &offset, int maxLength);
+
+    /**
+     * Fill the p_String in the byte array.
+     * If p_String length is greater than p_Length -1, the p_String will be truncated.
+     * CAUTION the return value should be freed after use.
+     * @param p_String the string
+     * @param p_Length the maximal length of the string included the null character.
+     * @throws Exception if p_String == nullptr, p_Bytes == nullptr
+     * p_Offset less than 0
+     * p_ByteCount less than p_Offset + p_Length
+     * @return p_Length
+     */
+    static int setString(string p_String, std::vector<char> &message, int p_Offset, int p_Length);
+};
+#endif /* SPIT_MESSAGE_H */

components/spit/include/SpitRepo.hpp

@@ -0,0 +1,68 @@
+#pragma once
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+template <typename T>
+class SpitRepo {
+  public:
+    bool hasEntry(const string &id) {
+        return mEntries.contains(id); 
+    }
+    
+    T *getEntry(const string &id) {
+        auto i = mEntries.find(id);
+        if (i == mEntries.end()) {
+            return nullptr;
+        }
+        return i->second.get();
+    }
+
+    const T &getEntryRef(const string &id) {
+        return *mEntries.at(id);
+    }
+
+    T *getEntry(int index) {
+        if (index >= 0 && index < mEntries.size()) {
+            return next(mEntries.begin(), index)->second.get();
+        }
+        return nullptr;
+    }
+    const T &getEntryRef(int index) {
+        if (index >= 0 && index < mEntries.size()) {
+            auto i = next(mEntries.begin(), index);
+            return *i->second;
+        } else {
+            throw "SPITObject index out of range";
+        }
+    }
+
+    void addEntry(unique_ptr<T> entry) {
+        mEntries[entry->getID()] = move(entry);
+    }
+    bool removeEntry(const T &entry) {
+        return removeEntry(entry.getID());
+    }
+    bool removeEntry(const string &id) {
+        auto i = mEntries.find(id);
+        if (i == mEntries.end()) {
+            return false;
+        }
+        mEntries.erase(i);
+        return true;
+    }
+    int getEntryCount() {
+        return mEntries.size();
+    }
+
+    unordered_map<string, unique_ptr<T>> &getRepo() {
+        return mEntries;
+    }
+
+    void clearEntries() {
+        mEntries.clear();
+    }
+
+  private:
+    unordered_map<string, unique_ptr<T>> mEntries;
+};

components/spit/src/SPITObject.cpp

@@ -0,0 +1,364 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * SPITObject describes a SPIT Object
+ * File:   SPITObject.cpp
+ * Author: Hagi
+ *
+ * Created on 9. April 2019, 12:11
+ */
+
+#include "SPITObject.h"
+#include "SPITSocket.h"
+#include "esp_log.h"
+
+/**
+ * clears all unconfirmed SPITObjects not created by this SPIT_Client.
+ */
+void SPITObject::clearUnconfirmedSPITObjects(SpitRepo<SPITObject> &repo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end();) {
+        SPITObject *ptrSPITObject = i->second.get();
+        if (ptrSPITObject->getCreatedByClient() == false && ptrSPITObject->getConfirmed() == false) {
+            i = entries.erase(i);
+        } else {
+            i++;
+        }
+    }
+}
+
+void SPITObject::eventProjectClosed(SpitRepo<SPITObject> &repo, SpitRepo<SPITObject> &remoteRepo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end(); ) {
+        SPITObject *ptrSPITObject = i->second.get();
+        if (ptrSPITObject->getCreatedByClient() == true) {
+            i++;
+            continue;
+        }
+        i = entries.erase(i);
+    }
+    // Remote
+    remoteRepo.clearEntries();
+}
+/**
+ * sets confirmed = false for all SPITObjects.
+ * This should be called when the client has loaded a project.
+ */
+void SPITObject::setConfirmedFalse(SpitRepo<SPITObject> &repo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end(); i++) {
+        i->second->setConfirmed(false);
+    }
+}
+
+SPITObject::SPITObject(string p_ID) {
+    m_ID = p_ID;
+}
+
+bool SPITObject::setMessageOP(SPIT_Message::ReportSPITObject *p_ReportSPITObject) {
+    bool boolChangeAllowed;
+    bool boolChanged = false;
+
+    if (m_CreatedByClient == true && m_Fixed == true) {
+        boolChangeAllowed = false;
+    } else {
+        boolChangeAllowed = true;
+    }
+
+    // Confirmation should be changable
+    if (m_CreatedByClient) {
+        // Server reports a client created SPITType -> the type is confirmed
+        m_Confirmed = true;
+    } else {
+        // type is NOT client created -> the client has to confirm the SPITtype
+        m_Confirmed = p_ReportSPITObject->getConfirmed();
+    }
+
+    if (m_Delay != p_ReportSPITObject->getDelay()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Delay = p_ReportSPITObject->getDelay();
+        boolChanged = true;
+    }
+    if (m_Duration != p_ReportSPITObject->getDuration()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Duration = p_ReportSPITObject->getDuration();
+        boolChanged = true;
+    }
+    if (m_Fixed != p_ReportSPITObject->getFixed()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Fixed = p_ReportSPITObject->getFixed();
+        boolChanged = true;
+    }
+    if (m_FrameFadeInLength != p_ReportSPITObject->getFrameFadeInLength()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_FrameFadeInLength = p_ReportSPITObject->getFrameFadeInLength();
+        boolChanged = true;
+    }
+    if (m_FrameFadeOutLength != p_ReportSPITObject->getFrameFadeOutLength()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_FrameFadeOutLength = p_ReportSPITObject->getFrameFadeOutLength();
+        boolChanged = true;
+    }
+    if (m_FrameLength != p_ReportSPITObject->getFrameLength()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_FrameLength = p_ReportSPITObject->getFrameLength();
+        boolChanged = true;
+    }
+    if (m_FrameStart != p_ReportSPITObject->getFrameStart()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_FrameStart = p_ReportSPITObject->getFrameStart();
+        boolChanged = true;
+    }
+    if (m_Remark != p_ReportSPITObject->getRemark()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Remark = p_ReportSPITObject->getRemark();
+        boolChanged = true;
+    }
+    if (m_ID != p_ReportSPITObject->getID()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ID = p_ReportSPITObject->getID();
+        boolChanged = true;
+    }
+    if (m_Name != p_ReportSPITObject->getName()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Name = p_ReportSPITObject->getName();
+        boolChanged = true;
+    }
+    if (m_SPITTypeID != p_ReportSPITObject->getSPITTypeID()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_SPITTypeID = p_ReportSPITObject->getSPITTypeID();
+        boolChanged = true;
+    }
+    if (m_ServerParams != p_ReportSPITObject->getServerParams()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ServerParams = p_ReportSPITObject->getServerParams();
+        boolChanged = true;
+    }
+    if (m_ServerRemote != p_ReportSPITObject->getServerRemote()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ServerRemote = p_ReportSPITObject->getServerRemote();
+        boolChanged = true;
+    }
+    if (m_Track != p_ReportSPITObject->getTrack()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Track = p_ReportSPITObject->getTrack();
+        boolChanged = true;
+    }
+    if (m_ValueFactor != p_ReportSPITObject->getValueFactor()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ValueFactor = p_ReportSPITObject->getValueFactor();
+        boolChanged = true;
+    }
+    if (m_ValueUse != p_ReportSPITObject->getValueUse()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ValueUse = p_ReportSPITObject->getValueUse();
+        boolChanged = true;
+    }
+    return boolChanged;
+}
+
+void SPITObject::fillMessageOP(SPIT_Message::ReportSPITObject &p_ReportSPITObject) {
+    p_ReportSPITObject.setActionAssigned(getActionAssigned()); // Action can be assigned to type or to this object
+    p_ReportSPITObject.setConfirmed(m_Confirmed);
+    p_ReportSPITObject.setDelay(m_Delay);
+    p_ReportSPITObject.setDuration(m_Duration);
+    p_ReportSPITObject.setFixed(m_Fixed);
+    p_ReportSPITObject.setFrameFadeInLength(m_FrameFadeInLength);
+    p_ReportSPITObject.setFrameFadeOutLength(m_FrameFadeOutLength);
+    p_ReportSPITObject.setFrameLength(m_FrameLength);
+    p_ReportSPITObject.setFrameStart(m_FrameStart);
+    p_ReportSPITObject.setID(m_ID);
+    p_ReportSPITObject.setName(m_Name);
+    p_ReportSPITObject.setRemark(m_Remark);
+    p_ReportSPITObject.setSPITTypeID(m_SPITTypeID);
+    p_ReportSPITObject.setServerParams(m_ServerParams);
+    p_ReportSPITObject.setServerRemote(m_ServerRemote);
+    p_ReportSPITObject.setTrack(m_Track);
+    p_ReportSPITObject.setValueFactor(m_ValueFactor);
+    p_ReportSPITObject.setValueUse(m_ValueUse);
+}
+void SPITObject::fillMessageOP(SPIT_Message::RemoveSPITObject &p_RemoveSPITObject) {
+    p_RemoveSPITObject.setID(m_ID);
+}
+
+/**
+ * This is used by the server and client to tell if the other side has registered the changes.
+ * @param p_Confirmed
+ * @return if m_Confirmed has changed
+ */
+bool SPITObject::setConfirmed(bool p_Confirmed) {
+    if (m_Confirmed == p_Confirmed)
+        return false;
+    m_Confirmed = p_Confirmed;
+    return true;
+}
+
+bool SPITObject::setName(string p_Name) {
+    if (m_Name == p_Name)
+        return false;
+    m_Name = p_Name;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setRemark(string p_Remark) {
+    if (m_Remark == p_Remark)
+        return false;
+    m_Remark = p_Remark;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setServerParams(string p_ServerParams) {
+    if (m_ServerParams == p_ServerParams)
+        return false;
+    m_ServerParams = p_ServerParams;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setSPITTypeID(string p_SPITTypeID) {
+    if (m_SPITTypeID == p_SPITTypeID)
+        return false;
+    m_SPITTypeID = p_SPITTypeID;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setServerRemote(bool p_BelongstoServer) {
+    if (m_ServerRemote == p_BelongstoServer)
+        return false;
+    m_ServerRemote = p_BelongstoServer;
+    m_Confirmed = false;
+    return true;
+}
+/**
+ * This is a virtual construct - ActionAssignedType is not implemented in the SPITProtocol.
+ * This is used when an action is associated with a SPITType.
+ * Then this action is done for every SPITObject with the SPITType.
+ * @return true = an action is assigned for the SPITType.
+ */
+bool SPITObject::setActionAssignedType(bool p_ActionAssigned) {
+    if (m_ActionAssignedType == p_ActionAssigned)
+        return false;
+    bool boolOldActionAssigend;
+    boolOldActionAssigend = getActionAssigned();
+    m_ActionAssignedType = p_ActionAssigned;
+    if (getActionAssigned() == boolOldActionAssigend)
+        return false;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setActionAssigned(bool p_ActionAssigned) {
+    if (m_ActionAssigned == p_ActionAssigned)
+        return false;
+    bool boolOldActionAssigend;
+    boolOldActionAssigend = getActionAssigned();
+    m_ActionAssigned = p_ActionAssigned;
+    if (getActionAssigned() == boolOldActionAssigend)
+        return false;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setFixed(bool p_Fixed) {
+    if (m_Fixed == p_Fixed)
+        return false;
+    m_Fixed = p_Fixed;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setFrameStart(long long p_FrameStart) {
+    if (m_FrameStart == p_FrameStart)
+        return false;
+    m_FrameStart = p_FrameStart;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setFrameLength(long long p_FrameLength) {
+    if (m_FrameLength == p_FrameLength)
+        return false;
+    m_FrameLength = p_FrameLength;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setFrameFadeInLength(long long p_FrameFadeInLength) {
+    if (m_FrameFadeInLength == p_FrameFadeInLength)
+        return false;
+    m_FrameFadeInLength = p_FrameFadeInLength;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setFrameFadeOutLength(long long p_FrameFadeOutLength) {
+    if (m_FrameFadeOutLength == p_FrameFadeOutLength)
+        return false;
+    m_FrameFadeOutLength = p_FrameFadeOutLength;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setValueUse(char p_ValueUse) {
+    if (m_ValueUse == p_ValueUse)
+        return false;
+    m_ValueUse = p_ValueUse;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setValueFactor(int p_ValueFactor) {
+    if (m_ValueFactor == p_ValueFactor)
+        return false;
+    m_ValueFactor = p_ValueFactor;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setTrack(int p_Track) {
+    if (m_Track == p_Track)
+        return false;
+    m_Track = p_Track;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setDelay(long long p_Delay) {
+    if (m_Delay == p_Delay)
+        return false;
+    m_Delay = p_Delay;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITObject::setDuration(long long p_Duration) {
+    if (m_Duration == p_Duration)
+        return false;
+    m_Duration = p_Duration;
+    m_Confirmed = false;
+    return true;
+}

components/spit/src/SPITPlayer.cpp

@@ -0,0 +1,102 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * SPITPlayer describes a virtual SPIT Player.
+ * File:   SPITPLayer.cpp
+ * Author: Hagi
+ *
+ * Created on 30. April 2019, 11:44
+ */
+
+#include "SPITPlayer.h"
+#include "esp_log.h"
+#include <memory>
+#include <vector>
+
+using namespace std;
+
+unordered_map<string, unique_ptr<SPITPlayer>> SPITPlayer::s_SPITPlayers;
+
+SPITPlayer &SPITPlayer::getSPITPlayer(string p_PlayerID) {
+    auto i = s_SPITPlayers.find(p_PlayerID);
+    if (i == s_SPITPlayers.end()) {
+        s_SPITPlayers[p_PlayerID] = make_unique<SPITPlayer>(p_PlayerID);
+    }
+    return *s_SPITPlayers.at(p_PlayerID);
+}
+
+SPITPlayer::SPITPlayer(string p_PlayerID) {
+    m_ID = p_PlayerID;
+}
+
+SPITPlayer::~SPITPlayer() {
+    m_PlaySPITTypes.clear();
+}
+
+/**
+ *
+ * @param p_SPITObjectID
+ * @return true = new PlayObject added<br>
+ * false = PlayObject exists
+ */
+SPITPlayer::PlaySPITType *SPITPlayer::addSPITType_Playing(string p_SPITTypeID) {
+    PlaySPITType *ptrPlaySPITType;
+    auto i = m_PlaySPITTypes.find(p_SPITTypeID);
+    if (i == m_PlaySPITTypes.end()) {
+        auto playSpitType = make_unique<PlaySPITType>(this, p_SPITTypeID);
+        ptrPlaySPITType = playSpitType.get();
+        m_PlaySPITTypes[p_SPITTypeID] = move(playSpitType);
+    } else {
+        ptrPlaySPITType = i->second.get();
+    }
+    ptrPlaySPITType->setIsPlayed(true);
+    return ptrPlaySPITType;
+}
+
+void SPITPlayer::startPlaySequence() {
+    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end(); i++) {
+        PlaySPITType *ptrPlaySPITType = i->second.get();
+        ptrPlaySPITType->startPlaySequence();
+    }
+}
+
+void SPITPlayer::endPlaySequence() {
+    for (auto i = m_PlaySPITTypes.begin(); i != m_PlaySPITTypes.end();) {
+        if (i->second.get()->getIsPlayed() == false) {
+            i = m_PlaySPITTypes.erase(i);
+        } else {
+            ++i;
+        }
+    }
+}
+
+SPITPlayer::PlaySPITType::PlaySPITType(SPITPlayer *p_SPITPlayer, string p_SPITTypeID) {
+    m_IsNew = true;
+
+    m_SPITTypeID = p_SPITTypeID;
+    m_PlayerID = p_SPITPlayer->getID();
+    m_PlayerName = p_SPITPlayer->getName();
+    startPlaySequence();
+    m_IsNew = true;
+}
+SPITPlayer::PlaySPITType::PlaySPITType(const PlaySPITType &orig) {
+    m_SPITTypeID = orig.getSPITTypeID();
+    m_IsPlayed = orig.getIsPlayed();
+    m_IsNew = orig.getIsNew();
+
+    m_PlayerID = orig.getPlayerID();
+    m_PlayerName = orig.getPlayerName();
+    m_PlayerRuns = orig.getPlayerIsRunning();
+
+    m_Value = orig.getValue();
+}
+void SPITPlayer::PlaySPITType::startPlaySequence() {
+    m_IsPlayed = false;
+    m_IsNew = false;
+
+    m_Value = 0;
+}

components/spit/src/SPITSocket.cpp

@@ -0,0 +1,223 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * Unix implementation of a SPITSocket.
+ *
+ * File:   UnixSocket.cpp
+ * Author: Hagi
+ *
+ * Created on 12. April 2019, 15:58
+ */
+
+#include "SPITSocket.h"
+#include "Task.hpp"
+#include "esp/uuid.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include <string>
+#include <unistd.h>
+using namespace std;
+
+/**
+ * Creates socket. If there exist some, they will be closed.
+ * @return
+ */
+bool SPITSocket::createSocket_UDP() {
+    if (m_UDPSocketIP4 != INVALID_SOCKET) {
+        close(m_UDPSocketIP4);
+        m_UDPSocketIP4 = INVALID_SOCKET;
+    }
+
+    m_UDPSocketIP4 = socket(AF_INET, SOCK_DGRAM, 0);
+    int intResult = -1;
+    bool success = true;
+    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+        success = false;
+    } else {
+        int intOptionValue4 = 1;
+        intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_REUSEADDR, (void *)&intOptionValue4, sizeof(intOptionValue4));
+    }
+    if (intResult < 0) {
+        success = false;
+    }
+
+    if (success == true) {
+        struct timeval tv;
+        tv.tv_sec = 1;  // seconds
+        tv.tv_usec = 0; // microseconds (0.0 sec)
+        // This sets the receive timeout
+        setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+
+        // set the m_UDPSocketIP4 in NON BLOCKING mode because
+        // if the UDPSockets are in blocking mode the receiveMessage does not return in every constellation
+        // int intFlags;
+        // intFlags = fcntl(m_UDPSocketIP4, F_GETFL);
+        // fcntl(m_UDPSocketIP4, F_SETFL, intFlags | O_NONBLOCK);
+
+        // int intBufferSize = 2046 * 512;
+        // intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_RCVBUF, (void*)&intBufferSize, sizeof(intBufferSize));
+        // intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_SNDBUF, (void*)&intBufferSize, sizeof(intBufferSize));
+    }
+    return success;
+}
+
+/**
+ * Binds the socket to the client's ip address and port. The socket option SO_REUSEADDR is set to true.
+ * @param clientIp ip address of the client
+ * @param clientPort port of the client.
+ * if p_Port == "0" any free port will be used
+ * @return -1 id bind fails, o if bind is ok
+ *
+ */
+int SPITSocket::bindSocket(string clientIp, string clientPort) {
+    string stringClientPort;
+    if (clientPort.length() <= 0)
+        stringClientPort = "0";
+    else
+        stringClientPort = clientPort;
+    addrinfo *clientAI;
+    if (getaddrinfo(clientIp.data(), clientPort.data(), nullptr, &clientAI) != 0) {
+        return -1;
+    }
+    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+        return -1;
+    }
+    auto *socketAdr = (sockaddr_in *)(clientAI->ai_addr);
+    int intSocklen = sizeof(*socketAdr);
+    // copy the socketAdr, may be not filled correct by getaddrinfo
+    sockaddr_in o_IP4SocketAddress;
+    memset(&o_IP4SocketAddress, 0, intSocklen);
+    o_IP4SocketAddress.sin_addr = socketAdr->sin_addr;
+    o_IP4SocketAddress.sin_family = socketAdr->sin_family;
+    o_IP4SocketAddress.sin_port = socketAdr->sin_port;
+    int intResult = bind(m_UDPSocketIP4, (const sockaddr *)(socketAdr), (socklen_t)intSocklen);
+    if (intResult < 0) {
+        return intResult;
+    }
+    if ((intResult == 0) &&
+        (getsockname(m_UDPSocketIP4, (sockaddr *)socketAdr, (socklen_t *)&intSocklen) != -1)) {
+        setBoundClientPort(to_string((int)socketAdr->sin_port));
+    }
+    freeaddrinfo(clientAI);
+
+    setIsBound(intResult != -1);
+    return intResult;
+}
+
+/**
+ * Set whether the socket are broadcast sockets or not. Set the sockopt SO_BROADCAST to 0 or 1
+ * @param p_Broadcast true SO_BROADCAST is set
+ * false = SO_BROADCAST is not set
+ * @return 0 = ok, -1 = error
+ */
+int SPITSocket::setBroadcast(bool broadcast) const {
+    int intOptionValue = broadcast ? 1 : 0;
+    int intResult = setsockopt(m_UDPSocketIP4, SOL_SOCKET, SO_BROADCAST, &intOptionValue, sizeof(int));
+    return intResult;
+}
+/**
+ * @param ip the ip address of the server
+ * @param port the port of the server
+ * @param msg buffer containing the message
+ * @param msgLength the length of the message
+ * @return -1 send fails
+ * 0 send is done
+ */
+int SPITSocket::sendMessageTo(const string &ip, const string &port, const char *message, int msgLength) {
+    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+        return -1;
+    }
+
+    // prepare AddressInfo
+    int intResult = -1;
+    addrinfo *ptrAddressInfo;
+    if (getaddrinfo(ip.data(), port.data(), nullptr, &ptrAddressInfo) != 0) {
+        return intResult;
+    }
+
+    auto *ptrIP4SocketAddress = (sockaddr_in *)(ptrAddressInfo->ai_addr);
+    int intSocklen = sizeof(*ptrIP4SocketAddress);
+    if (m_UDPSocketIP4 != INVALID_SOCKET) {
+        // copy the ptrIP4SocketAddress, may be not filled correct by getaddrinfo
+        sockaddr_in o_IP4SocketAddress;
+        memset(&o_IP4SocketAddress, 0, intSocklen);
+        o_IP4SocketAddress.sin_addr = ptrIP4SocketAddress->sin_addr;
+        o_IP4SocketAddress.sin_family = ptrIP4SocketAddress->sin_family;
+        o_IP4SocketAddress.sin_port = ptrIP4SocketAddress->sin_port;
+        intResult = sendto(m_UDPSocketIP4, message, msgLength, 0, (const sockaddr *)&o_IP4SocketAddress, (socklen_t)intSocklen);
+        if (intResult < 0) {
+            ESP_LOGE("SPIT", "sendMessageTo IP4 sendto %s FAILED %s\n", ip.data(), strerror(errno));
+            ESP_LOGE("SPIT", "sendMessageTo ret=%d %s / %s / %d\n", intResult, port.data(), message, msgLength);
+        }
+        freeaddrinfo(ptrAddressInfo);
+    }
+    if (intResult < 0) {
+        return -1;
+    }
+    return 0;
+}
+/**
+ * Call this for receiving a message
+ * This will block until a message is received or the underlying socket is closed
+ * @param p_Buffer the buffer containing the received message later.
+ * @param p_BufferLength the size of the buffer
+ * @param p_ServerIP a pointer to a string, when a messages is received the string will contain the ip address of the sender/server
+ * if p_ServerIP is NULL - no detection of the server will be done.
+ * @return
+ */
+int SPITSocket::receiveMessage(char *p_Buffer, int p_BufferLength, string *serverIp) const {
+    int intResult = -1;
+    if (m_UDPSocketIP4 == INVALID_SOCKET) {
+        return intResult;
+    }
+    sockaddr_in o_IP4SocketAddress;
+    int intSocklen = sizeof(o_IP4SocketAddress);
+    memset(&o_IP4SocketAddress, 0, intSocklen);
+    intResult = recvfrom(m_UDPSocketIP4, (void *)p_Buffer, p_BufferLength, 0, (sockaddr *)&o_IP4SocketAddress, (socklen_t *)&intSocklen);
+    if (intResult >= 0 && serverIp != nullptr) {
+        char bufferIP4[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &(o_IP4SocketAddress.sin_addr), bufferIP4, intSocklen);
+        *serverIp = bufferIP4;
+    }
+    return intResult;
+}
+
+SPITSocket::IPAddress SPITSocket::getAdaptersInfo() {
+    // iterate over active interfaces, and print out IPs
+    esp_netif_t *netif = nullptr;
+    if ((netif = esp_netif_next_unsafe(netif)) != nullptr) {
+        ESP_LOGI("SPIT", "Connected to %s", esp_netif_get_desc(netif));
+        esp_netif_ip_info_t ip;
+        ESP_ERROR_CHECK(esp_netif_get_ip_info(netif, &ip));
+        ESP_LOGI("SPIT", "- IPv4 address: " IPSTR ",", IP2STR(&ip.ip));
+        ESP_LOGI("SPIT", "- IPv4 netmask: " IPSTR ",", IP2STR(&ip.netmask));
+        char buffer[64];
+        sprintf(buffer, IPSTR, IP2STR(&ip.ip));
+        string stringIP4 = buffer;
+        sprintf(buffer, IPSTR, IP2STR(&ip.netmask));
+        string stringSubnet = buffer;
+        return {stringIP4, stringSubnet};
+    }
+    return {"0.0.0.0", "0.0.0.0"};
+}
+
+string createGUID() {
+    uuid_t uu;
+    uuid_generate(uu);
+    char uu_str[UUID_STR_LEN];
+    uuid_unparse(uu, uu_str);
+    return {uu_str};
+}
+
+string getClientHostName() {
+    const char *hostname;
+    esp_netif_get_hostname(esp_netif_get_default_netif(), &hostname);
+    if (hostname != nullptr) {
+        return {hostname};
+    }
+    return "";
+}

components/spit/src/SPITType.cpp

@@ -0,0 +1,237 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/*
+ * SPITType describes a SPIT Type
+ * File:   SPITType.cpp
+ * Author: Hagi
+ *
+ * Created on 8. April 2019, 08:40
+ */
+
+#include "SPITType.h"
+#include "esp_log.h"
+
+static const char *TAG = "SPIT";
+
+void SPITType::eventProjectClosed(SpitRepo<SPITType> &repo, SpitRepo<SPITType> &remoteRepo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end();) {
+        SPITType *ptrSPITType = i->second.get();
+        if (ptrSPITType->getCreatedByClient() == true) {
+            i++;
+            continue;
+        }
+        i = entries.erase(i);
+    }
+    // Remote
+    remoteRepo.clearEntries();
+}
+
+/**
+ * Sets confirmed = false for all SPITTypes.
+ * This should be called when the client has loaded a project.
+ */
+void SPITType::setConfirmedFalse(SpitRepo<SPITType> &repo) {
+    auto &entries = repo.getRepo();
+    for (auto i = entries.begin(); i != entries.end(); i++) {
+        i->second->setConfirmed(false);
+    }
+}
+
+SPITType::SPITType(string p_ID) {
+    m_ID = p_ID;
+}
+
+SPITType::SPITType(string id, string grpName, string name, bool fixed, bool projectIndependent, long long defaultDelay, long long defaultDuration) {
+    m_ActionAssigned = false;
+    m_Confirmed = false;
+    m_ID = id;
+    m_GroupName = grpName;
+    m_Name = name;
+    m_Fixed = fixed;
+    m_ServerProjectIndepended = projectIndependent;
+    m_DefaultDelay = defaultDelay;
+    m_DefaultDuration = defaultDuration;
+}
+
+void SPITType::setCreatedByClient(bool p_CreatedByClient) {
+    m_CreatedByClient = p_CreatedByClient;
+}
+
+/**
+ * This is used by the server and client to tell if the other side has registered the changes.
+ * @param p_Confirmed
+ * @return if m_Confirmed has changed
+ */
+bool SPITType::setConfirmed(bool p_Confirmed) {
+    if (m_Confirmed == p_Confirmed)
+        return false;
+    m_Confirmed = p_Confirmed;
+    return true;
+}
+
+bool SPITType::setGroupName(const string &p_GroupName) {
+    if (m_GroupName == p_GroupName)
+        return false;
+    m_GroupName = p_GroupName;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITType::setName(const string &p_Name) {
+    if (m_Name == p_Name)
+        return false;
+    m_Name = p_Name;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITType::setServerRemote(bool p_BelongstoServer) {
+    if (m_ServerRemote == p_BelongstoServer)
+        return false;
+    m_ServerRemote = p_BelongstoServer;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITType::setProjectIndepended(bool p_ProjectIndepended) {
+    if (m_ServerProjectIndepended == p_ProjectIndepended)
+        return false;
+    m_ServerProjectIndepended = p_ProjectIndepended;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITType::setFixed(bool p_Fixed) {
+    if (m_Fixed == p_Fixed)
+        return false;
+    m_Fixed = p_Fixed;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITType::setDefaultDelay(long long p_Delay) {
+    if (m_DefaultDelay == p_Delay)
+        return false;
+    m_DefaultDelay = p_Delay;
+    m_Confirmed = false;
+    return true;
+}
+bool SPITType::setDefaultDuration(long long p_Duration) {
+    if (m_DefaultDuration == p_Duration)
+        return false;
+    m_DefaultDuration = p_Duration;
+    m_Confirmed = false;
+    return true;
+}
+
+/**
+ * Virtual construct - means ActionAssigned for SPITTypes is is not implemented in SPITProtocol.
+ * This can used to setActionAssigned to all SPITObjects with this SPITType.
+ * This may be used in the case when the same action should be done for every SPITObject with this SPITType associated.
+ * @return true = the m_ActionAssigned has changed.
+ */
+bool SPITType::setActionAssigned(bool p_ActionAssigned) {
+    if (m_ActionAssigned == p_ActionAssigned)
+        return false;
+    m_ActionAssigned = p_ActionAssigned;
+    m_Confirmed = false;
+    return true;
+}
+
+/**
+ * Set the content of the SPITType as received from the server
+ * @param p_ReportSPITType
+ * @return true = the SPITType is changed
+ * false = the SPITType is NOT changed, because it is not allowed to change.
+ */
+bool SPITType::setMessageOP(SPIT_Message::ReportSPITType &reportSpitType) {
+    bool boolChangeAllowed;
+    bool boolChanged = false;
+
+    if (m_CreatedByClient == true && m_Fixed == true) {
+        boolChangeAllowed = false;
+    } else {
+        boolChangeAllowed = true;
+    }
+
+    // Confirmation should be changeable
+    if (m_CreatedByClient) {
+        // Server reports a client created SPITType -> the type is confirmed
+        m_Confirmed = true;
+    } else {
+        // type is NOT client created -> the client has to confirm the SPITtype
+        m_Confirmed = reportSpitType.getConfirmed();
+    }
+    if (m_DefaultDelay != reportSpitType.getDelay()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_DefaultDelay = reportSpitType.getDelay();
+        boolChanged = true;
+    }
+    if (m_DefaultDuration != reportSpitType.getDuration()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_DefaultDuration = reportSpitType.getDuration();
+        boolChanged = true;
+    }
+    if (m_Fixed != reportSpitType.getFixed()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Fixed = reportSpitType.getFixed();
+        boolChanged = true;
+    }
+    if (m_GroupName != reportSpitType.getGroupName()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_GroupName = reportSpitType.getGroupName();
+        boolChanged = true;
+    }
+    if (m_ID != reportSpitType.getID()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ID = reportSpitType.getID();
+        boolChanged = true;
+    }
+    if (m_Name != reportSpitType.getName()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_Name = reportSpitType.getName();
+        boolChanged = true;
+    }
+    if (m_ServerProjectIndepended != reportSpitType.getServerProjectIndepended()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ServerProjectIndepended = reportSpitType.getServerProjectIndepended();
+        boolChanged = true;
+    }
+    if (m_ServerRemote != reportSpitType.getServerRemote()) {
+        if (boolChangeAllowed == false) {
+            return false;
+        }
+        m_ServerRemote = reportSpitType.getServerRemote();
+        boolChanged = true;
+    }
+    return boolChanged;
+}
+
+void SPITType::fillMessageOP(SPIT_Message::ReportSPITType &smReportSpitType) const {
+    smReportSpitType.setConfirmed(m_Confirmed);
+    smReportSpitType.setDelay(m_DefaultDelay);
+    smReportSpitType.setDuration(m_DefaultDuration);
+    smReportSpitType.setFixed(m_Fixed);
+    smReportSpitType.setGroupName(m_GroupName);
+    smReportSpitType.setID(m_ID);
+    smReportSpitType.setName(m_Name);
+    smReportSpitType.setServerProjectIndepended(m_ServerProjectIndepended);
+    smReportSpitType.setServerRemote(m_ServerRemote);
+}
+void SPITType::fillMessageOP(SPIT_Message::RemoveSPITType &smRemoveSpitType) const {
+    smRemoveSpitType.setID(m_ID);
+}

components/spit/src/esp/from

@@ -0,0 +1 @@
+https://github.com/typester/esp32-uuid/tree/master

components/spit/src/esp/license

@@ -0,0 +1,7 @@
+Copyright 2019 Daisuke Murase (typester)
+
+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.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

components/spit/src/esp/uuid.c

@@ -0,0 +1,84 @@
+#include "uuid.h"
+
+#include <string.h>
+
+#include "esp_system.h"
+#include "esp_random.h"
+
+void uuid_generate(uuid_t out)
+{
+    esp_fill_random(out, sizeof(uuid_t));
+
+    /* uuid version */
+    out[6] = 0x40 | (out[6] & 0xF);
+
+    /* uuid variant */
+    out[8] = (0x80 | out[8]) & ~0x40;
+}
+
+static uint8_t unhex_char(unsigned char s)
+{
+    if (0x30 <= s && s <= 0x39) { /* 0-9 */
+        return s - 0x30;
+    } else if (0x41 <= s && s <= 0x46) { /* A-F */
+        return s - 0x41 + 0xa;
+    } else if (0x61 <= s && s <= 0x69) { /* a-f */
+        return s - 0x61 + 0xa;
+    } else {
+        /* invalid string */
+        return 0xff;
+    }
+}
+
+static int unhex(unsigned char *s, size_t s_len, unsigned char *r)
+{
+    int i;
+
+    for (i = 0; i < s_len; i += 2) {
+        uint8_t h = unhex_char(s[i]);
+        uint8_t l = unhex_char(s[i + 1]);
+        if (0xff == h || 0xff == l) {
+            return -1;
+        }
+        r[i / 2] = (h << 4) | (l & 0xf);
+    }
+
+    return 0;
+}
+
+int uuid_parse(const char *in, uuid_t uu)
+{
+    const char *p = in;
+    uint8_t *op = (uint8_t *)uu;
+
+    if (0 != unhex((unsigned char *)p, 8, op)) {
+        return -1;
+    }
+    p += 8;
+    op += 4;
+
+    for (int i = 0; i < 3; i++) {
+        if ('-' != *p++ || 0 != unhex((unsigned char *)p, 4, op)) {
+            return -1;
+        }
+        p += 4;
+        op += 2;
+    }
+
+    if ('-' != *p++ || 0 != unhex((unsigned char *)p, 12, op)) {
+        return -1;
+    }
+    p += 12;
+    op += 6;
+
+    return 0;
+}
+
+void uuid_unparse(const uuid_t uu, char *out)
+{
+    snprintf(out, UUID_STR_LEN,
+             "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
+             "%02x%02x-%02x%02x%02x%02x%02x%02x",
+             uu[0], uu[1], uu[2], uu[3], uu[4], uu[5], uu[6], uu[7], uu[8], uu[9], uu[10], uu[11],
+             uu[12], uu[13], uu[14], uu[15]);
+}

components/spit/src/esp/uuid.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef uint8_t uuid_t[16];
+
+#define UUID_STR_LEN 37
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void uuid_generate(uuid_t out);
+int uuid_parse(const char *in, uuid_t uu);
+void uuid_unparse(const uuid_t uu, char *out);
+#ifdef __cplusplus
+}
+#endif

components/watchFace/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(
+    INCLUDE_DIRS "."
+    REQUIRES devHal
+)

components/watchFace/watchFace.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "StepperDrv8833.hpp"
+#include "stepperMotor.hpp"
+#include <cmath>
+
+class WatchMotor {
+    static constexpr uint8_t Positions = 6;
+
+  public:
+    WatchMotor(StepperMotor &stepper, OutputPort &sleep)
+        : _stepper(stepper),
+          _motorSleep(sleep) {
+        _motorSleep.write(false);
+    }
+
+    void moveTo(uint8_t sign, uint8_t profile = 0) {
+        sign = sign % 6;
+
+        float delta = 2.0F * std::numbers::pi;
+        float corr = 0.0F;
+        float currentPos = _stepper.getScaledPos() * 6;
+        if ((_currentIndex > 4) && (currentPos < 2)) {
+            corr = 6 - _currentIndex - currentPos;
+        } else if ((_currentIndex < 2) && (currentPos > 2)) {
+            corr = _currentIndex + 6 - currentPos;
+        } else {
+            corr = _currentIndex - currentPos;
+        }
+
+        // stepper.getScaledPos() * 6
+        if (_currentIndex < sign) {
+            delta = delta / 6 * (sign - _currentIndex);
+        } else if (_currentIndex > sign) {
+            delta = delta / 6 * (sign + 6 - _currentIndex);
+        }
+        ESP_LOGD("MV", "Moving to %d by %.2f + %.2f", sign, delta, corr);
+
+        _stepper.moveBy(delta + corr, profile);
+        _currentIndex = sign;
+    }
+
+    float getScaled() { return _stepper.getScaledPos() * 6; }
+    uint8_t getIndex() { return _currentIndex; }
+
+  private:
+    StepperMotor &_stepper;
+    OutputPort &_motorSleep;
+    uint8_t _currentIndex{};
+};

doc/InitRun.md

@@ -0,0 +1,188 @@
+I (23) boot: ESP-IDF v5.3 2nd stage bootloader
+I (24) boot: compile time Feb 15 2025 17:51:30
+I (24) boot: chip revision: v0.0
+I (26) boot.esp32c6: SPI Speed      : 80MHz
+I (31) boot.esp32c6: SPI Mode       : DIO
+I (36) boot.esp32c6: SPI Flash Size : 8MB
+I (41) boot: Enabling RNG early entropy source...
+I (46) boot: Partition Table:
+I (50) boot: ## Label            Usage          Type ST Offset   Length
+I (57) boot:  0 nvs              WiFi data        01 02 00009000 00006000
+I (64) boot:  1 phy_init         RF data          01 01 0000f000 00001000
+I (72) boot:  2 factory          factory app      00 00 00010000 00100000
+I (79) boot: End of partition table
+I (83) esp_image: segment 0: paddr=00010020 vaddr=42070020 size=2b2e0h (176864) map
+I (128) esp_image: segment 1: paddr=0003b308 vaddr=40800000 size=04d10h ( 19728) load
+I (134) esp_image: segment 2: paddr=00040020 vaddr=42000020 size=6bfe0h (442336) map
+I (226) esp_image: segment 3: paddr=000ac008 vaddr=40804d10 size=094b0h ( 38064) load
+I (235) esp_image: segment 4: paddr=000b54c0 vaddr=4080e1c0 size=01bd0h (  7120) load
+I (241) boot: Loaded app from partition at offset 0x10000
+I (242) boot: Disabling RNG early entropy source...
+I (256) cpu_start: Unicore app
+I (265) cpu_start: Pro cpu start user code
+I (265) cpu_start: cpu freq: 160000000 Hz
+I (265) app_init: Application information:
+I (268) app_init: Project name:     X_WatchController_FW
+I (274) app_init: App version:      858b7d8-dirty
+I (279) app_init: Compile time:     Apr  8 2025 22:42:59
+I (285) app_init: ELF file SHA256:  ab11b461f...
+I (290) app_init: ESP-IDF:          v5.3
+I (295) efuse_init: Min chip rev:     v0.0
+I (300) efuse_init: Max chip rev:     v0.99
+I (305) efuse_init: Chip rev:         v0.0
+I (309) heap_init: Initializing. RAM available for dynamic allocation:
+I (317) heap_init: At 40812120 len 0006A4F0 (425 KiB): RAM
+I (323) heap_init: At 4087C610 len 00002F54 (11 KiB): RAM
+I (329) heap_init: At 50000000 len 00003FE8 (15 KiB): RTCRAM
+I (336) spi_flash: detected chip: generic
+I (340) spi_flash: flash io: dio
+I (345) sleep: Configure to isolate all GPIO pins in sleep state
+I (351) sleep: Enable automatic switching of GPIO sleep configuration
+I (358) coexist: coex firmware version: dab85ae96
+I (385) coexist: coexist rom version 5b8dcfa
+I (386) main_task: Started on CPU0
+I (386) main_task: Calling app_main()
+I (396) esp_eth.netif.netif_glue: 42:4c:ca:ff:fe:4e
+I (396) esp_eth.netif.netif_glue: ethernet attached to netif
+I (406) Watch: Ethernet Started
+I (406) Watch: Start Lighting
+I (406) gpio: GPIO[10]| InputEn: 1| OutputEn: 1| OpenDrain: 1| Pullup: 1| Pulldown: 0| Intr:0 
+I (416) gpio: GPIO[11]| InputEn: 1| OutputEn: 1| OpenDrain: 1| Pullup: 1| Pulldown: 0| Intr:0
+I (426) Watch: Start Stepper
+I (426) gpio: GPIO[18]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
+I (436) gpio: GPIO[8]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
+I (446) gpio: GPIO[15]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
+I (456) TMR: Create timer handle
+I (456) TMR: Setup timer
+I (456) Stepper: Find Home
+I (466) Stepper: Homing ...
+I (466) Stepper: Fast find right side of home sensor
+I (486) gpio: GPIO[1]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
+I (2206) Stepper: Find right side of home sensor
+I (2376) Stepper: Find end of sensor
+I (2406) Watch: Ethernet Link Up
+I (2406) Watch: Ethernet Link Up
+I (2406) Watch: Ethernet HW Addr 00:00:00:00:00:00
+I (3406) esp_netif_handlers: eth ip: 172.16.17.56, mask: 255.255.0.0, gw: 172.16.0.1
+I (3406) Watch: Ethernet Got IP Address
+I (3406) Watch: ~~~~~~~~~~~
+I (3406) Watch: ETHIP:172.16.17.56
+I (3416) Watch: ETHMASK:255.255.0.0
+I (3416) Watch: ETHGW:172.16.0.1
+I (3416) Watch: ~~~~~~~~~~~
+I (5186) Stepper: Find left side of home sensor
+I (5646) Stepper: Move back to mid position 116
+I (6806) Stepper: Reset position
+I (7086) Stepper: Got to 1
+I (7086) Watch: Fist Position is 0.03
+I (7106) Watch: Changing picto-Illum to pos = 0
+I (7106) Watch: Current color set r128 g128 b128 
+I (13426) Watch: Start net services
+I (13426) Watch: Starting Telnet task
+I (13426) TCP: Socket created
+I (13426) Watch: Starting ArtNet task
+I (13426) TCP: Socket bound, port 23
+I (13426) Watch: Starting SPIT task
+I (13426) UDP: Starting syslog session to 172.16.16.10
+I (13426) UDP: Socket bound, port 6454
+I (13436) Telnet: Socket waiting for connect
+I (13436) SPIT: Connected to eth
+I (13456) SPIT: - IPv4 address: 172.16.17.56,
+I (13456) SPIT: - IPv4 netmask: 255.255.0.0,
+I (13446) SysLog: Starting Syslog Task
+I (13466) Watch: NEW SPIT-Type ID: ActionStartShuffle GroupName: CatasWatchMovement Name: ActionStartShuffle confirmed: 0
+I (13466) UDP: Socket bound, port 514
+I (13486) Watch: NEW SPIT-Type ID: ActionMoveTo1 GroupName: CatasWatchMovement Name: ActionMoveTo1 confirmed: 0
+I (13496) Watch: NEW SPIT-Type ID: ActionMoveTo2 GroupName: CatasWatchMovement Name: ActionMoveTo2 confirmed: 0
+I (13506) Watch: NEW SPIT-Type ID: ActionMoveTo3 GroupName: CatasWatchMovement Name: ActionMoveTo3 confirmed: 0
+I (13516) Watch: NEW SPIT-Type ID: ActionMoveTo4 GroupName: CatasWatchMovement Name: ActionMoveTo4 confirmed: 0
+I (13526) Watch: NEW SPIT-Type ID: ActionMoveTo5 GroupName: CatasWatchMovement Name: ActionMoveTo5 confirmed: 0
+I (13536) Watch: NEW SPIT-Type ID: ActionMoveTo6 GroupName: CatasWatchMovement Name: ActionMoveTo6 confirmed: 0
+I (13546) SPIT: Starting Socket managing
+I (17656) Watch: SERVER DETECTED
+I (17656) Watch:  Name: liveShowSPIT
+I (17656) Watch:  ID: 698a3e4f-1ae9-4dd8-9015-29332d29629e
+I (17656) Watch:  Computer: GgP17
+I (17656) Watch:  IP: 172.16.16.10
+I (17666) Watch:  Port: 15120
+I (17666) Watch:  Addition:
+I (17666) Watch:  ClientIP: 172.16.17.56
+I (17676) SPIT: connect to 172.16.16.10 / 15120
+I (17676) Watch: MySPITApp: eventConnectionStatus 0->0
+I (17686) Watch: MySPITApp: eventConnectionStatus 0->4
+I (18196) Watch: eventProjectReport ID: CatasWatchProject 
+I (18196) Watch: eventStartProjectTransfer
+W (18306) SPIT: TypeVeto e019646a-4e24-4608-954e-da4ca6761bb6 / ToIgnore 43
+I (18326) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002sb0va8bom Name:  -> SPITType: ActionStartShuffle
+I (18336) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002rd0va8bom Name:  -> SPITType: ActionMoveTo1
+I (18356) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002vl0va8bom Name:  -> SPITType: ActionMoveTo2
+I (18366) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002wh0va8bom Name:  -> SPITType: ActionMoveTo3
+I (18386) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002yl0va8bom Name:  -> SPITType: ActionMoveTo4
+I (18396) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002tc0va8bom Name:  -> SPITType: ActionMoveTo5
+I (18416) Watch: NEW SPIT-Object ID: 00000m8uedyyt0000000000000002zi0va8bom Name:  -> SPITType: ActionMoveTo6
+I (18446) Watch: Min heap size: 297568 / FreeHeap 299880
+I (18446) Watch: NEW SPIT-REMOTE-Type ID: playControlStart GroupName: Playcontrol Name: start confirmed: 1
+I (18466) Watch: NEW SPIT-REMOTE-Type ID: playControlPause GroupName: Playcontrol Name: pause confirmed: 1
+I (18476) Watch: NEW SPIT-REMOTE-Type ID: nextSceneBridge GroupName: Playcontrol Name: next scene confirmed: 1
+I (18496) Watch: NEW SPIT-REMOTE-Type ID: nextMainSceneBridge GroupName: Playcontrol Name: next main scene confirmed: 1
+I (18506) Watch: NEW SPIT-REMOTE-Type ID: previuosSceneBridge GroupName: Playcontrol Name: previous scene confirmed: 1
+I (18526) Watch: NEW SPIT-REMOTE-Type ID: previousMainSceneBridge GroupName: Playcontrol Name: previous main scene confirmed: 1
+I (18546) Watch: NEW SPIT-REMOTE-Type ID: mainmixerSound_Volume00 GroupName: Main Mixer Name: Sound confirmed: 1
+I (18556) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_Dimmer00 GroupName: Main Mixer Name:  confirmed: 1
+I (18566) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_RGB00 GroupName: Main Mixer Name:  confirmed: 1
+I (18586) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_RGB10 GroupName: Main Mixer Name:  confirmed: 1
+I (18606) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_RGB20 GroupName: Main Mixer Name:  confirmed: 1
+I (18616) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_RGB30 GroupName: Main Mixer Name:  confirmed: 1
+I (18636) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_RGB40 GroupName: Main Mixer Name:  confirmed: 1
+I (18646) Watch: NEW SPIT-REMOTE-Type ID: mainmixerDMX_RGB50 GroupName: Main Mixer Name:  confirmed: 1
+I (18666) Watch: NEW SPIT-REMOTE-Type ID: mainmixerMedia_SoundVolume00 GroupName: Main Mixer Name: Media confirmed: 1
+I (18686) Watch: NEW SPIT-REMOTE-Type ID: mainmixerMedia_Transparency00 GroupName: Main Mixer Name: Media confirmed: 1
+I (18696) Watch: NEW SPIT-REMOTE-Type ID: selectedJingles GroupName: Playcontrol Name: selected Jingles confirmed: 1
+I (18716) Watch: NEW SPIT-REMOTE-Type ID: selectedJingleGroups GroupName: Playcontrol Name: selected Jinglegroups confirmed: 1
+I (18726) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000lo0va8bom GroupName: MainScene Name: ChangingPositionScene confirmed: 1
+I (18746) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000m70va8bom GroupName: MainScene Name: InPosition1Scene confirmed: 1
+I (18756) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000mh0va8bom GroupName: MainScene Name: InPosition2Scene confirmed: 1
+I (18776) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000mr0va8bom GroupName: MainScene Name: InPosition3Scene confirmed: 1
+I (18786) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000nk0va8bom GroupName: MainScene Name: InPosition4Scene confirmed: 1
+I (18806) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000nu0va8bom GroupName: MainScene Name: InPosition5Scene confirmed: 1
+I (18826) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000000o40va8bom GroupName: MainScene Name: InPosition6Scene confirmed: 1
+I (18836) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000001au0va8bom GroupName: MainScene Name: StartShuffle confirmed: 1
+I (18856) Watch: NEW SPIT-REMOTE-Type ID: 00000m8uedyyt0000000000000001fj0va8bom GroupName: MainScene Name: Fence confirmed: 1
+I (18866) Watch: NEW SPIT-REMOTE-Object ID: playControlStart Name: start -> SPITType: start
+I (18886) Watch: NEW SPIT-REMOTE-Object ID: playControlPause Name: pause -> SPITType: pause
+I (18906) Watch: NEW SPIT-REMOTE-Object ID: nextSceneBridge Name: next scene -> SPITType: next scene
+I (18916) Watch: NEW SPIT-REMOTE-Object ID: nextMainSceneBridge Name: next main scene -> SPITType: next main scene
+I (18936) Watch: NEW SPIT-REMOTE-Object ID: previuosSceneBridge Name: previous scene -> SPITType: previous scene
+I (18946) Watch: NEW SPIT-REMOTE-Object ID: previousMainSceneBridge Name: previous main scene -> SPITType: previous main scene
+I (18966) Watch: NEW SPIT-REMOTE-Object ID: mainmixerSound_Volume00 Name: Sound Volume -> SPITType: Sound
+I (18976) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_Dimmer00 Name: Dimmer -> SPITType: 
+I (18996) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_RGB00 Name: Red -> SPITType: 
+I (19006) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_RGB10 Name: Green -> SPITType: 
+I (19026) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_RGB20 Name: Blue -> SPITType: 
+I (19036) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_RGB30 Name: Cyan -> SPITType: 
+I (19056) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_RGB40 Name: Magenta -> SPITType: 
+I (19076) Watch: NEW SPIT-REMOTE-Object ID: mainmixerDMX_RGB50 Name: Yellow -> SPITType: 
+I (19086) Watch: NEW SPIT-REMOTE-Object ID: mainmixerMedia_SoundVolume00 Name: Sound Volume -> SPITType: Media
+I (19106) Watch: NEW SPIT-REMOTE-Object ID: mainmixerMedia_Transparency00 Name: Media Transparency -> SPITType: Media
+I (19116) Watch: NEW SPIT-REMOTE-Object ID: selectedJinglesps Name: Play / Stop -> SPITType: selected Jingles
+I (19136) Watch: NEW SPIT-REMOTE-Object ID: selectedJinglespf Name: Play / Fade Out -> SPITType: selected Jingles
+I (19146) Watch: NEW SPIT-REMOTE-Object ID: selectedJingleGroupsps Name: Play / Stop -> SPITType: selected Jinglegroups
+I (19166) Watch: NEW SPIT-REMOTE-Object ID: selectedJingleGroupspf Name: Play / Fade Out -> SPITType: selected Jinglegroups
+I (19176) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000lo0va8bom Name: play -> SPITType: ChangingPositionScene
+W (19196) SPIT: Finished searching
+W (19196) SPIT: Start working
+I (19196) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000m70va8bom Name: play -> SPITType: InPosition1Scene
+I (19216) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000mh0va8bom Name: play -> SPITType: InPosition2Scene
+I (19226) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000mr0va8bom Name: play -> SPITType: InPosition3Scene
+I (19246) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000nk0va8bom Name: play -> SPITType: InPosition4Scene
+I (19256) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000nu0va8bom Name: play -> SPITType: InPosition5Scene
+I (19276) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000000o40va8bom Name: play -> SPITType: InPosition6Scene
+I (19286) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000001au0va8bom Name: play -> SPITType: StartShuffle
+I (19306) Watch: NEW SPIT-REMOTE-Object ID: 00000m8uedyyt0000000000000001fj0va8bom Name: play -> SPITType: Fence
+I (19316) Watch: eventEndProjectTransfer
+I (19316) Watch: eventProjectReport ID: CatasWatchProject Name:  FramesPerSecond: 44100
+I (23446) Watch: Min heap size: 278024 / FreeHeap 282460
+I (28446) Watch: Min heap size: 278024 / FreeHeap 282460
+I (33446) Watch: Min heap size: 278024 / FreeHeap 282460
+I (38446) Watch: Min heap size: 278024 / FreeHeap 282460
+I (43446) Watch: Min heap size: 278024 / FreeHeap 282460

doc/LiveShowProject/CatasWatchProject.rtf

@@ -0,0 +1,5 @@
+{\rtf1\ansi
+{\fonttbl\f0\fnil Monospaced;}
+
+\par
+}

main/watchMain.cpp

@@ -6,15 +6,18 @@
  * @copyright Copyright (c) 2024
  */
 
-// Conig-Key:
+/* Watchface
-//
+        6/
-//
+    5   /   1
-//
+    4       2
+        3
+*/
 
 struct {
     const char *syslogDest = "syslogDst";  // example: "172.16.16.10"
-    const char *mqttBroker = "mqttBroker"; // example: "172.16.17.62"
+    const char *mqttBroker = "mqttBroker"; // example: "172.16.16.10"
     const char *mqttPrefix = "mqttPrefix"; // example: "SomeTag"
+    const char *spitServer = "spitServer"; // example: "172.16.16.10"
 } ConfigKeys;
 
 // MQTT Topics
@@ -27,6 +30,33 @@ struct {
     const char *changingPosition = /* <mqttPrefix>/ */ "watch/changingPosition";
 } MqttTopics;
 
+struct {
+    const char *expectedServer = "";
+    struct {
+        const char *group = "CatasWatchMovement";
+        const char *startShuffle = "ActionStartShuffle";
+        const char *moveToX[6] = {
+            "ActionMoveTo1",
+            "ActionMoveTo2",
+            "ActionMoveTo3",
+            "ActionMoveTo4",
+            "ActionMoveTo5",
+            "ActionMoveTo6",
+        };
+    } Provided;
+    struct {
+        const char *changingPos = "ChangingPositionScene";
+        const char *inPosX[6] = {
+            "InPosition1Scene",
+            "InPosition2Scene",
+            "InPosition3Scene",
+            "InPosition4Scene",
+            "InPosition5Scene",
+            "InPosition6Scene",
+        };
+    } Expected;
+} SpitTypes;
+
 // ToDo:
 // - MQTT Integration
 // - OTA
@@ -36,6 +66,9 @@ struct {
 
 #include "watchMain.hpp"
 
+string ClientName = "CatasWatchDev";
+string ProjectName = "CatastrphicProj";
+
 extern "C" { // This switch allows the ROS C-implementation to find this main
 void app_main(void);
 }
@@ -44,20 +77,29 @@ struct DeviceState {
     uint8_t minJumps{6};
     uint8_t maxJumps{32};
     uint8_t profile{};
-    uint8_t restTime{};
+    uint8_t shuffleRate{};
     float speed = 1.0; // Rad/sec
     float accel = 1.0; // Rad/sec^2
     Color color{0x80, 0x80, 0x80};
-    uint8_t pictogram{}; // 0..5 active Pictogramm
 };
 
 enum class MoveType {
     StepTo,
+    Demo,
     Shuffle,
-    Demo
+};
+enum class ResponseType {
+    StepAt,
+    StartMoving,
 };
 struct MoveCommand {
     MoveType type;
+    // 1..6
+    uint8_t pos;
+};
+struct WatchIndex {
+    ResponseType type;
+    // 1..6
     uint8_t pos;
 };
 struct PictoIllumCommand {
@@ -65,6 +107,7 @@ struct PictoIllumCommand {
 };
 
 static fos::Queue<MoveCommand> commandQueue(8);
+static fos::Queue<WatchIndex> responseQueue(8);
 static fos::Queue<PictoIllumCommand> pictoIllumQue(2);
 
 DeviceState activeState;
@@ -242,7 +285,7 @@ static void UniverseCallback(const uint8_t *data, const uint16_t size) {
     Syslog::logv(Syslog::Severity::Debug, "Got DMX: r%0x g%0x b%0x i%0x  m%i M%i p%i a%i w%i r%i",
                  /* RGB*/ data[0], data[1], data[2], /*Intens*/ data[3],
                  /* MinMaxJumps */ data[4], data[5], /*profile*/ data[6], /*accel/speed*/ data[7], data[8],
-                 /*RestTime*/ data[9]);
+                 /*shuffleRate*/ data[9]);
 
     float intens = (float)data[3] / UINT8_MAX;
     activeState.color = Color{
@@ -260,7 +303,7 @@ static void UniverseCallback(const uint8_t *data, const uint16_t size) {
     activeState.accel = (float)accel / 100 + 0.5; // min .5 / max 3
     activeState.speed = (float)velo / 100 + 0.5;  // min .5 / max 3
 
-    activeState.restTime = data[9];
+    activeState.shuffleRate = data[9];
 }
 
 void moveToSubs(std::string data) {
@@ -343,6 +386,7 @@ static void dmxSocketTask(int addrFamily) {
 }
 
 fos::Semaphore etherActive;
+fos::Semaphore spitProjectFinish;
 
 /** Event handler for IP_EVENT_ETH_GOT_IP */
 static void got_ip_event_handler(void *arg, esp_event_base_t event_base,
@@ -434,7 +478,7 @@ namespace Effect {
     };
 
     const Macro macDemoFlicker = {
-        {64, 1, &InitSlopeWave, StateMachine::UpdateWave, 0xFF},
+        {16, 1, &InitSlopeWave, StateMachine::UpdateWave, 0xFF},
         {32, 1, StateMachine::UpdateFlicker, 0xFF},
     };
 }
@@ -469,14 +513,23 @@ void LightingTask() {
     processors[5].setEffect(Effect::macDark, &colorSource, 0);
 
     const std::array<Effect::Macro, 6> PictoEffects{
+        Effect::macDemoPulse, // 1
         Effect::macDemoPulse,
         Effect::macDemoPulse,
         Effect::macDemoPulse,
-        Effect::macDemoPulse,
+        Effect::macStartFlicker,
-        Effect::macDemoPulse,
+        Effect::macDemoPulse}; // 6
-        Effect::macStartFlicker};
 
-    uint8_t lastPicto = 0;
+    uint8_t lastPicto = 1;
+
+    std::array<uint16_t *, 6> startPoints{
+        &(values[0][4]), // 1
+        &(values[1][12]),
+        &(values[1][8]),
+        &(values[1][4]),
+        &(values[0][12]),
+        &(values[0][8]), // 6
+    };
 
     while (true) {
         auto onPos = pictoIllumQue.dequeue(0);
@@ -501,14 +554,6 @@ void LightingTask() {
             }
         }
 
-        std::array<uint16_t *, 6> startPoints{
-            &(values[0][4]),
-            &(values[0][8]),
-            &(values[0][12]),
-            &(values[1][4]),
-            &(values[1][8]),
-            &(values[1][12]),
-        };
         for (size_t i = 0; i < processors.size(); i++) {
             auto col = processors[i].tick();
             auto sp = startPoints[i];
@@ -530,7 +575,7 @@ void MovementTask() {
     StepperDriverDrv8833::Pins stepperPins{
         LEDC_TIMER_0,
         {LEDC_CHANNEL_0, LEDC_CHANNEL_1, LEDC_CHANNEL_2, LEDC_CHANNEL_3},
-        {GPIO_NUM_23, GPIO_NUM_22, GPIO_NUM_21, GPIO_NUM_20},
+        {GPIO_NUM_21, GPIO_NUM_20, GPIO_NUM_23, GPIO_NUM_22},
     };
     StepperDriverDrv8833 stepperDriver(stepperPins, MicroSteps, 0.25F);
     stepperDriver.setPos(0);
@@ -546,25 +591,34 @@ void MovementTask() {
 
     StepperMotor stepper(stepperCfg, stepperDriver, initSens);
 
+    WatchMotor watch(stepper, motorSleep);
+
     ESP_LOGI("Stepper", "Find Home");
     stepper.findRef();
-    // Illum 1
+    // Todo Set by User-Interface
-    pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(1));
+    for (size_t i = 0; i < 7; i++) {
+        stepper.fullStep(1);
+        fos::Task::delayMs(40);
+    }
+    (void)stepper.zeroPosition();
+    while (!stepper.isIdle()) {
+        fos::Task::delayMs(40);
+    }
+    // watch.moveTo(1, ProfileGenerator::Unitform);
+    ESP_LOGI("Stepper", "Got to 1");
+    // Illum 6
+    pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(0));
 
-    ESP_LOGI(TAG, "Fist Position is %f.2", stepper.getScaledPos() * 6);
+    ESP_LOGI(TAG, "Fist Position is %.2f", watch.getScaled());
     fos::Task::delayMs(1000);
 
-    activeState.pictogram = 0;
-
     while (true) {
         ESP_LOGD(TAG, "Waiting for command");
         auto cmd = commandQueue.dequeue();
         if (cmd->type == MoveType::StepTo) {
             if (stepper.isIdle()) {
-                pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(0));
                 int newPos = cmd->pos;
                 if ((newPos >= 1) && (newPos <= 6)) {
-                    auto idx = newPos - 1;
                     Syslog::logv(Syslog::Severity::Informational,
                                  "Triggered movement to picto pos:%i ", newPos);
                 } else {
@@ -572,47 +626,322 @@ void MovementTask() {
                                  "Got invalid index for illuminated pictogram =%i ", newPos);
                     continue;
                 }
-                int delta = newPos - activeState.pictogram;
+
-                if (delta <= 0) {
+                int jumps = newPos - watch.getIndex();
-                    delta += 6;
+                if (jumps <= 0) {
+                    jumps += 6;
                 }
-                delta = delta + (activeState.minJumps % 6) * 6;
+                jumps = jumps + (activeState.minJumps % 6) * 6;
-                if (delta < activeState.minJumps) {
+                if (jumps < activeState.minJumps) {
-                    delta += 6;
+                    jumps += 6;
                 }
                 Syslog::logv(Syslog::Severity::Notice,
                              "Running Stepper by %i steps with prof=%i a=%.2f w=%.2f",
-                             delta, activeState.profile, activeState.accel, activeState.speed);
+                             jumps, activeState.profile, activeState.accel, activeState.speed);
                 pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(0));
-                stepper.moveBy(delta * std::numbers::pi / 3,
+                responseQueue.enqueue(std::make_unique<WatchIndex>(ResponseType::StartMoving, 0));
-                               activeState.profile, activeState.accel, activeState.speed);
+                watch.moveTo(newPos, activeState.profile);
+
                 pictoIllumQue.enqueue(std::make_unique<PictoIllumCommand>(newPos));
-                activeState.pictogram = newPos;
+                responseQueue.enqueue(std::make_unique<WatchIndex>(ResponseType::StepAt, newPos));
             }
         } else if (cmd->type == MoveType::Demo) {
-            int i = 0;
+            ESP_LOGI(TAG, "Running Demo");
-            while (i++ < 80) {
+            for (size_t i = ProfileGenerator::Smooth; i < ProfileGenerator::NumProfiles; i++) {
-                stepperDriver.step(1);
+                ESP_LOGI(TAG, "Running Profile %d ", i);
-                stepperDriver.getSubPos();
+                fos::Task::delayMs(1000);
-                fos::Task::delayMs(100);
+                int steps[3]{4, 2, 0};
-            }
+                for (size_t j = 0; j < 3; j++) {
-            ESP_LOGI("Stepper", "Find Home");
+                    watch.moveTo(steps[j], i);
-            stepper.findRef();
+                    fos::Task::delayMs(1000);
-            activeState.pictogram = -1;
-            stepper.findRef();
-            fos::Task::delayMs(1000);
-            for (size_t i = 0; i < 6; i++) {
-                stepper.moveBy(std::numbers::pi / 3);
-                while (!stepper.isIdle()) {
-                    fos::Task::delayMs(100);
                 }
-                ESP_LOGI(TAG, "Position is %f.2", stepper.getScaledPos() * 6);
             }
         } else {
             fos::Task::delayMs(100);
         }
     }
 }
+struct LocalSpitObj {
+    string iD;
+    string groupName;
+    string name;
+};
+std::map<string, MoveCommand> ProvidedSpitActions;
+std::map<string, string> ExpectedObjects;
+
+void onServerEvent(SPIT_Client::ServerEvent event, const SAD_DetectedServer &p_DetectedServer) {
+    switch (event) {
+    case SPIT_Client::ServerEvent::Detect:
+        ESP_LOGI(TAG, "SERVER DETECTED");
+        ESP_LOGI(TAG, " Name: %s", p_DetectedServer.getName().data());
+        ESP_LOGI(TAG, " ID: %s", p_DetectedServer.getID().data());
+        ESP_LOGI(TAG, " Computer: %s", p_DetectedServer.getComputerName().data());
+        ESP_LOGI(TAG, " IP: %s", p_DetectedServer.getIP().data());
+        ESP_LOGI(TAG, " Port: %s", p_DetectedServer.getPort().data());
+        ESP_LOGI(TAG, " Addition: %s", p_DetectedServer.getAdditions().data());
+        ESP_LOGI(TAG, " ClientIP: %s", p_DetectedServer.getClientIP().data());
+        break;
+    case SPIT_Client::ServerEvent::Lost:
+        ESP_LOGW(TAG, "Server lost Name: %s  IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
+
+        break;
+    case SPIT_Client::ServerEvent::Changed:
+        ESP_LOGW(TAG, "Server lost Name: %s  IP: %s", p_DetectedServer.getName().data(), p_DetectedServer.getIP().data());
+        break;
+
+    default:
+        break;
+    }
+}
+
+void onConnectionStatus(string p_ServerID, string p_ServerComputerName, string p_ServerName, int p_ServerStepTime,
+                        SPIT_Client::Connection p_ConnectionStatus, SPIT_Client::Connection p_OldConnectionStatus) {
+    ESP_LOGI(TAG, "MySPITApp: eventConnectionStatus %d->%d ", (int)p_OldConnectionStatus, (int)p_ConnectionStatus);
+}
+
+// The transfer of the server's SPITTypes and SPITObjects is finished.
+void onProjectUpdate(SPIT_Client::ProjUpdate state, string projectId) {
+
+    switch (state) {
+    case SPIT_Client::ProjUpdate::ServerLoaded:
+        ESP_LOGI(TAG, "eventProjectReport ID: %s ", projectId.data());
+        break;
+    case SPIT_Client::ProjUpdate::StartTransfer:
+        ESP_LOGI(TAG, "eventStartProjectTransfer");
+        break;
+    case SPIT_Client::ProjUpdate::EndTransfer:
+        ESP_LOGI(TAG, "eventEndProjectTransfer");
+        spitProjectFinish.give();
+        break;
+    case SPIT_Client::ProjUpdate::ServerClosed:
+        ESP_LOGI(TAG, "eventProjectClosed ID: %s", projectId.data());
+        // If we don't save SPITServer's project specific information
+        // perhaps close all SPITObjects and RemoteSPITObjects to avoid conflicts, when the SPITServer loads a new project
+        // SPITObject::clearSPITObjects();
+        // SPITObject::clearSPITObjectsRemote();
+        break;
+
+    default:
+        break;
+    }
+}
+
+bool onCheckSpitTypeVeto(bool knownType, bool createdByClient) {
+    if (!knownType || !createdByClient) { // Don't allow foreign SPITTypes
+        return false;
+    }
+
+    return true;
+}
+
+bool onCheckSpitObjectVeto(bool knownType) {
+    return true; // Bypass veto
+    if (!knownType) { // Don't allow objects of unregistered SPITTypes
+        return false;
+    }
+    
+    return true;
+}
+
+// Called when the server has created, loaded, changed or deleted a (Remote) SPITType.
+// Remote SPITType are used in Remote SPITObjects. A Remote SPITObject is used to remote control the SPITServer.
+// May also occur when the server confirms a SPITType created or changed by the client.
+void onSpitType(SPIT_Client::ObjectEvent event, bool isRemote, const SPITType &p_SPITType) {
+    if (isRemote) {
+        if (event == SPIT_Client::ObjectEvent::Created) {
+            ESP_LOGI(TAG, "NEW SPIT-REMOTE-Type ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
+            auto typeName = p_SPITType.getName();
+            if (ExpectedObjects.contains(typeName)) {
+                ExpectedObjects[typeName] = p_SPITType.getID();
+            }
+        } else if (event == SPIT_Client::ObjectEvent::Changed) {
+            // we had to inform all Remote SPITObjects using the p_SPITType
+            // perhaps the SPITObject uses information from the SPITType
+            // SPITObject *ptrSPITObject;
+            // int intSPITObjectCount;
+            // intSPITObjectCount = SPITObject::getSPITObjectRemoteCount();
+            // for (int intObject = 0; intObject < intSPITObjectCount; intObject++) {
+            //     ptrSPITObject = SPITObject::getSPITObjectRemote(intObject);
+            //     if (ptrSPITObject == nullptr)
+            //         continue;
+            //     if (ptrSPITObject->getSPITTypeID() == p_SPITType.getID()) {
+            //         // call ecentSPITObjectRemote
+            //         // onSpitObjectRemote(SPIT_Client::ObjectEvent::Changed, p_SPITType, *ptrSPITObject);
+            //     }
+            // }
+            ESP_LOGI(TAG, "SPIT-REMOTE-Type CHANGED ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
+        } else if (event == SPIT_Client::ObjectEvent::Deleted) {
+            ESP_LOGD(TAG, "SPIT-REMOTE-Type Removed ID: %s GroupName: %s Name: %s\n", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data());
+        }
+    } else {
+        if (event == SPIT_Client::ObjectEvent::Created) {
+            // Whenever you provide an action for this SPITType take this over in your code.
+            // call _SpitClient.setActionSPITType(p_SPITType.getID(), true);
+            ESP_LOGI(TAG, "NEW SPIT-Type ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
+        } else if (event == SPIT_Client::ObjectEvent::Changed) {
+            ESP_LOGI(TAG, "SPIT-Type CHANGED ID: %s GroupName: %s Name: %s confirmed: %d", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data(), p_SPITType.getConfirmed());
+        } else if (event == SPIT_Client::ObjectEvent::Deleted) {
+            ESP_LOGI(TAG, "SPIT-Type Removed ID: %s GroupName: %s Name: %s\n", p_SPITType.getID().data(), p_SPITType.getGroupName().data(), p_SPITType.getName().data());
+        }
+    }
+}
+
+// Called when the server has created, loaded or changed a SPITObject.
+// A Remote SPITObject is used to remote control the SPITServer.
+// May also occur when the server confirms a SPITObject created by the client, what the client should never do!!.
+// false = server changed a existing SPITObject
+// @param p_SPITType a reference to a copy of the associated SPITType instance.
+// @param p_SPITObject a reference to a copy of the SPITObject instance.
+void onSpitObject(SPIT_Client::ObjectEvent event, bool isRemote, const SPITType &p_SPITType, const SPITObject &p_SPITObject) {
+    if (isRemote) {
+        if (event == SPIT_Client::ObjectEvent::Created) {
+            ESP_LOGI(TAG, "NEW SPIT-REMOTE-Object ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
+            // This is a remote SPITObject which can be used to remote control the server.
+            // If you want you can list this for later use
+        } else if (event == SPIT_Client::ObjectEvent::Changed) {
+            ESP_LOGI(TAG, "SPIT-REMOTE-Object CHANGED ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
+        } else if (event == SPIT_Client::ObjectEvent::Deleted) {
+            ESP_LOGD(TAG, "SPIT-REMOTE-Object Removed ID: %s Name: %s\n", p_SPITObject.getID().data(), p_SPITObject.getName().data());
+            // This is a remote SPITObject
+            // If you have listet this prior you should remove it from the list
+        }
+    } else {
+        if (event == SPIT_Client::ObjectEvent::Created) {
+            ESP_LOGI(TAG, "NEW SPIT-Object ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
+            // check your actions
+            // Whenever you provide an action for this SPITObject take this over in your code.
+            // call _SpitClient.setActionSPITObject(p_SPITObject.getID(), true);
+
+            // for our little excample as described in loadClientProject:
+            // We have only actions for SPITTypes - means every SPITObject with the associated "Actionx"-SPITTypes will trigger the action when it is played
+            //-> no need to do something here, because setActionSPITType has been set prior and the SPITObject will automatically inherits this
+            // SPITObjects with other SPITTypes asscciated will trigger no actions
+
+        } else if (event == SPIT_Client::ObjectEvent::Changed) {
+            ESP_LOGI(TAG, "SPIT-Object CHANGED ID: %s Name: %s -> SPITType: %s", p_SPITObject.getID().data(), p_SPITObject.getName().data(), p_SPITType.getName().data());
+        } else if (event == SPIT_Client::ObjectEvent::Deleted) {
+            ESP_LOGD(TAG, "SPIT-Object Removed ID: %s Name: %s\n", p_SPITObject.getID().data(), p_SPITObject.getName().data());
+            // Check your actions
+            // take the removal of the SPITObject over in your code
+
+            // CAUTION: Deleted SPITObjects can be added later again (perhaps per UNDO on the SPITServer)
+            //-> don't remove your assigned action immediately - keep it to reassign it later
+        }
+    }
+}
+
+// SPITServer may use several methods for playing SPITObjects.
+// e.g. liveSHOWsoftware has the timeline and jingles which plays objects, where the timeline the main player is.
+// SPIT distinguishes between the different players. All eventPlay... functions contain the information which player plays the SPIT object.
+void onPlay(string p_PlayerID, string p_PlayerName, char p_PlayerType, bool p_PlayerIsRunning, long long p_TimeFrames) {
+    ESP_LOGD(TAG, "eventPlay Player: %s Runs: %d Time: %lld", p_PlayerName.data(), p_PlayerIsRunning, p_TimeFrames);
+
+    switch (p_PlayerType) {
+    case SPIT_Client::PLAYERTYPE_MAIN:
+        // p_FrameTimes contains the position inside the server's project, we can use it like a timecode
+        // int intMilliseconds = (int)(((double)p_TimeFrames / (double)m_ServerFramesPerSecond) * 1000);
+        break;
+    case SPIT_Client::PLAYERTYPE_CONTINOUS:
+        // The olayer is playing only single Object sequences sometime during the project
+        break;
+    case SPIT_Client::PLAYERTYPE_DISCRETE:
+        // Only discrete values where submitted, e.g the fader position of remote faders.
+        break;
+    }
+}
+
+/**
+ * Called when the SPITServer plays a SPITObject. For every played SPITObject one eventPlayObject is called.
+ * You can decide here which action should be done or not.
+ */
+void onPlaySpitType(string p_PlayerID, string spitTypeId, bool p_PlayerIsRunning, bool p_Started, bool p_Ended, double p_Value) {
+    // double doubleValue = ((double)p_PlayObject.getValue() / 1000000) * ((double)p_PlayObject.getValueFactor() / 1000000);
+
+    ESP_LOGD(TAG, "eventPlayObject Player: %s is running: %d Object Started: %d Stopped: %d", p_PlayerID.data(), p_PlayerIsRunning, p_Started, p_Ended);
+    // ESP_LOGD(TAG, "      SPITType: %s SPITObject: %s Position: %lld Value: %f\n", spitTypeId.data(), p_SPITObject.getName().data(), p_PlayObject.getFrameInside(), doubleValue);
+    ESP_LOGD(TAG, "      SPITType: %s Value: %f\n", spitTypeId.data(), p_Value);
+
+    if (!ProvidedSpitActions.contains(spitTypeId)) {
+        ESP_LOGE(TAG, "SPIT ID %s is not accepted", spitTypeId.c_str());
+        return;
+    }
+    if (p_Started == true) {
+        auto command = ProvidedSpitActions[spitTypeId];
+        ESP_LOGI(TAG, "Player: %s is running: %s Object", p_PlayerID.data(), spitTypeId.c_str());
+        commandQueue.enqueue(std::make_unique<MoveCommand>(command));
+        Syslog::logv(Syslog::Severity::Informational, "Got SPIT command for move ot : r%d", command.pos);
+    }
+}
+
+/**
+ * Called when a remote SpitObject which value function is changed by the server.
+ * This allows the Client to adjust its display for the remote command.
+ * @param p_SPITType the assigned remote SPITType of p_SPITObject
+ * @param p_SPITObject the remote SPITObject which is changed
+ * @param p_FrameInsideObject can be discarded
+ * @param p_Value the new value
+ */
+void onPlayRemoteObjectStatus(const SPITType &p_SPITType, const SPITObject &p_SPITObject, long long p_FrameInsideObject, int p_Value) {
+    ESP_EARLY_LOGD(TAG, "eventPlayRemoteObjectStatus RemoteSPITType: %s RemoteSPITObject: %s Position: %lld Value: %d", p_SPITType.getName().data(), p_SPITObject.getName().data(), p_FrameInsideObject, p_Value);
+}
+
+void SpitClientApp() {
+    ESP_LOGI(TAG, "Starting SPIT task");
+
+    auto &provided = SpitTypes.Provided;
+    auto &expected = SpitTypes.Expected;
+    std::vector<LocalSpitObj> ProvidedObj;
+    ProvidedSpitActions[provided.startShuffle] = MoveCommand{.type = MoveType::Shuffle, .pos = 0};
+    ProvidedObj.push_back(LocalSpitObj{.iD = provided.startShuffle, .groupName = provided.group, .name = provided.startShuffle});
+    ExpectedObjects[expected.changingPos] = "";
+    for (size_t i = 0; i < 6; i++) {
+        ProvidedObj.push_back(LocalSpitObj{.iD = provided.moveToX[i], .groupName = provided.group, .name = provided.moveToX[i]});
+        ProvidedSpitActions[provided.moveToX[i]] = MoveCommand{.type = MoveType::StepTo, .pos = (uint8_t)(i + 1)};
+        ExpectedObjects[expected.inPosX[i]] = "";
+    }
+
+    SPIT_Client spitClient(ClientName, ProjectName,
+                           {
+                               .onServerEvent = onServerEvent,
+                               .onConnectionStatus = onConnectionStatus,
+                               .onProjectUpdate = onProjectUpdate,
+                               .onSpitType = onSpitType,
+                               .onSpitObject = onSpitObject,
+                               .onPlay = onPlay,
+                               .onPlaySpitType = onPlaySpitType,
+                               .onPlayRemoteObjectStatus = onPlayRemoteObjectStatus,
+                               .onCheckSpitTypeVeto = onCheckSpitTypeVeto,
+                               .onCheckSpitObjectVeto = onCheckSpitObjectVeto,
+                           });
+
+    for (auto &obj : ProvidedObj) {
+        SPITType *ptrSPITType1Fix = spitClient.createSPITTypeFixed(obj.iD, obj.groupName, obj.name, 0, 0);
+        spitClient.setActionSPITType(ptrSPITType1Fix->getID(), true); // should be executed whenever a SPITObject with this SPITType is played
+    }
+    spitClient.clientProjectLoaded();
+    spitClient.startServerAutoDetect();
+
+    spitProjectFinish.take();
+    string serverProjectID = spitClient.getServerProjectID();
+    string serverProjectName = spitClient.getClientProjectName();
+    int serverFramesPerSecond = spitClient.getServerFramesPerSecond(); // set when the server reports his project, see eventProjectReport
+    ESP_LOGI(TAG, "eventProjectReport ID: %s Name: %s FramesPerSecond: %d", serverProjectID.data(), serverProjectName.data(), serverFramesPerSecond);
+
+    for (auto &&obj : ExpectedObjects) {
+        if (obj.second == "") {
+            ESP_LOGE(TAG, "No matching Remote ID for %s", obj.first.c_str());
+        }
+    }
+
+    while (true) {
+        auto res = responseQueue.dequeue();
+        if (res->type == ResponseType::StartMoving) {
+            spitClient.sendRemoteObject(ExpectedObjects[expected.changingPos]);
+        } else if (res->type == ResponseType::StepAt) {
+            spitClient.sendRemoteObject(ExpectedObjects[expected.inPosX[res->pos - 1]]);
+        }
+    }
+}
 
 void app_main(void) {
     esp_err_t ret = nvs_flash_init();
@@ -623,16 +952,18 @@ void app_main(void) {
     ESP_ERROR_CHECK(ret);
     initialize_ethernet();
     NvsApi::init();
-    static fos::Task lightingTask(LightingTask, "Lights", 0x4000uL);
+    static fos::Task lightingTask(LightingTask, "Lights", 0x8000uL);
-    static fos::Task movementTask(MovementTask, "Motor", 0x4000uL);
+    static fos::Task movementTask(MovementTask, "Motor", 0x8000uL);
 
     etherActive.take();
+    fos::Task::delayMs(10000);
     ESP_LOGI(TAG, "Start net services");
 
     static int ipVersion = AF_INET;
     static fos::TaskT<int> telnetSocket(telnetSocketTask, ipVersion, "tcpServer", 4096);
     static fos::TaskT<int> dmxNode(dmxSocketTask, ipVersion, "dmxNode", 4096);
     // static Task otaUpdate(SystemFunctions::OtaTaskEntry, "otaTask", 8192);
+    static fos::Task spit(SpitClientApp, "SpitClient");
 
     auto &store = NvsApi::getInstance();
     auto logger = store.getValue(ConfigKeys.syslogDest);
@@ -640,21 +971,25 @@ void app_main(void) {
         Syslog::setupTask(IpAdr{logger, 0});
     }
 
-    auto broker = store.getValue(ConfigKeys.mqttBroker);
+    // auto broker = store.getValue(ConfigKeys.mqttBroker);
-    if (broker != "") {
+    // if (broker != "") {
-        ESP_LOGI(TAG, "Initializing MQTT");
+    //     ESP_LOGI(TAG, "Initializing MQTT");
-        auto prefix = store.getValue(ConfigKeys.mqttPrefix);
+    //     auto prefix = store.getValue(ConfigKeys.mqttPrefix);
-        auto &client = MqttClient::init(broker, prefix);
+    //     auto &client = MqttClient::init(broker, prefix);
-        if (!client.isRunning()) {
+    //     if (!client.isRunning()) {
-            client.addSubscription(MqttTopics.moveTo, [](std::string d) { moveToSubs(d); });
+    //         client.addSubscription(MqttTopics.moveTo, [](std::string d) { moveToSubs(d); });
-            client.addSubscription(MqttTopics.startShuffle, [](std::string d) { startShuffle(d); });
+    //         client.addSubscription(MqttTopics.startShuffle, [](std::string d) { startShuffle(d); });
-            client.start();
+    //         client.start();
-        }
+    //     }
-    }
+    // }
 
     while (true) {
         fos::Task::delayMs(5000);
         // ToDo send
         Syslog::logv(Syslog::Severity::Notice, "Health state");
+        // ESP_LOGI(TAG, "Min heap size: %" PRIu32 " / FreeHeap %" PRIu32 "\n",
+        ESP_LOGI(TAG, "Min heap size: %u / FreeHeap %lu",
+                 heap_caps_get_minimum_free_size(MALLOC_CAP_DEFAULT),
+                 esp_get_free_heap_size());
     }
 }

main/watchMain.hpp

@@ -7,8 +7,9 @@
 #pragma once
 
 
-#include <string.h>
+#include <cstring>
-#include <stdlib.h>
+#include <cstdlib>
+#include <cmath>
 #include "sdkconfig.h"
 #include "esp_event.h"
 #include "esp_log.h"
@@ -36,6 +37,7 @@
 #include "Processor.hpp"
 #include "nvsFunctions.hpp"
 #include "mqttClient.hpp"
+#include "watchFace.hpp"
 
 // #include "esp_chip_info.h"
 // #include "esp_flash.h"
@@ -50,4 +52,13 @@
 // #include "systemFunctions.hpp"
 // #include <inttypes.h>
 // #include <sys/param.h>
-// #include <unistd.h>
+// #include <unistd.h>
+
+#include "SAD_DetectedServer.hpp"
+#include "SPITObject.h"
+#include "SPITPlayer.h"
+#include "SPITType.h"
+#include "SPIT_Client.h"
+#include <chrono>
+#include <string>
+#include <map>

test/integration/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.16)
+
+set(EXTRA_COMPONENT_DIRS 
+    "../../core/components" 
+    "../../core/managed_components"
+    "../../components" 
+    # "../../managed_components"
+)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(INTEGRATION_TESTS_FW)
+

test/integration/main/CMakeLists.txt

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "movementTests.cpp"
+                       INCLUDE_DIRS ".")

test/integration/main/movementTests.cpp

@@ -0,0 +1,322 @@
+/**
+ * @file watchMain.cpp
+ * @author Gustice
+ * @brief ChaosWatch Application
+ *
+ * @copyright Copyright (c) 2024
+ */
+
+/// NOTE: Create IDF shell navigate to directory ("test/integration")
+//          and run "idf.py -p COM9 flash monitor"
+
+#include "Processor.hpp"
+#include "PwmExpanderPca9685.hpp"
+#include "StepperDrv8833.hpp"
+#include "Task.hpp"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "sdkconfig.h"
+#include "stepperMotor.hpp"
+#include "watchFace.hpp"
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+
+/* Watchface        Indicies
+        6/                  5/
+    5   /   1           4   /   0
+    4       2           3       1
+        3                   2
+*/
+
+extern "C" { // This switch allows the ROS C-implementation to find this main
+void app_main(void);
+}
+
+static const char *TAG = "IT";
+
+struct DeviceState {
+    uint8_t minJumps{6};
+    uint8_t maxJumps{32};
+    uint8_t profile{};
+    uint8_t restTime{};
+    float speed = 1.0; // Rad/sec
+    float accel = 1.0; // Rad/sec^2
+    Color color{0x80, 0x80, 0x80};
+    uint8_t pictogram{}; // 0..5 active Pictogramm
+};
+
+class IndexIllumination {
+  public:
+    IndexIllumination()
+        : master(I2C_NUM_0, /*sda=*/GPIO_NUM_10, /*scl=*/GPIO_NUM_11),
+          ledDriver1(master, /*iverted=*/false),
+          ledDriver2(master, /*iverted=*/false, 0x41),
+          pwmEnable(GPIO_NUM_1, GpioPort::Logic::Inverted),
+          RED{CRed.getColor<Color::Rgbw>()},
+          GREEN{CGreen.getColor<Color::Rgbw>()},
+          BLUE{CBlue.getColor<Color::Rgbw>()} {
+        pwmEnable.write(true);
+        clearColorData();
+        syncToDevice();
+    }
+
+    void clearColorData() {
+        for (size_t i = 0; i < 2; i++) {
+            for (size_t j = 0; j < PmwExpanderPca9685::PwmChannels; j++) {
+                Values[i][j] = 0;
+            }
+        }
+    }
+
+    void setColorOfIndexTo(uint8_t idx, Color::Rgbw color) {
+        if (idx >= 6) {
+            return;
+        }
+        auto sp = LedStartPoints[idx];
+        sp[0] = (uint16_t)(color.white) << 5;
+        sp[1] = (uint16_t)(color.blue) << 5;
+        sp[2] = (uint16_t)(color.green) << 5;
+        sp[3] = (uint16_t)(color.red) << 5;
+    }
+
+    void syncToDevice() {
+        ledDriver1.sendImage(Values[0]);
+        ledDriver2.sendImage(Values[1]);
+    }
+
+    void flashAll(Color::Rgbw color, int duration = 200) {
+        clearColorData();
+        for (size_t i = 0; i < 6; i++) {
+            setColorOfIndexTo(i, color);
+        }
+        syncToDevice();
+        fos::Task::delayMs(duration);
+        clearColorData();
+        syncToDevice();
+    }
+
+  private:
+    PmwExpanderPca9685::GrayValues Values[2]{};
+    std::array<uint16_t *, 6> LedStartPoints{
+        &(Values[0][4]), // 1
+        &(Values[1][12]),
+        &(Values[1][8]),
+        &(Values[1][4]),
+        &(Values[0][12]),
+        &(Values[0][8]), // 6
+    };
+
+    I2cMaster master;
+    PmwExpanderPca9685 ledDriver1;
+    PmwExpanderPca9685 ledDriver2;
+    OutputPort pwmEnable;
+    const Color::Rgbw RED;
+    const Color::Rgbw GREEN;
+    const Color::Rgbw BLUE;
+};
+
+DeviceState activeState;
+
+void IndexColorSweep(IndexIllumination &illum) {
+    const auto RED = CRed.getColor<Color::Rgbw>();
+    const auto GREEN = CGreen.getColor<Color::Rgbw>();
+    const auto BLUE = CBlue.getColor<Color::Rgbw>();
+
+    illum.flashAll(RED);
+    fos::Task::delayMs(200);
+    illum.flashAll(GREEN);
+    fos::Task::delayMs(200);
+    illum.flashAll(BLUE);
+    fos::Task::delayMs(200);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(0, GREEN);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(0, RED);
+    illum.setColorOfIndexTo(1, GREEN);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(1, RED);
+    illum.setColorOfIndexTo(2, GREEN);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(2, RED);
+    illum.setColorOfIndexTo(3, GREEN);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(3, RED);
+    illum.setColorOfIndexTo(4, GREEN);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(4, RED);
+    illum.setColorOfIndexTo(5, GREEN);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(5, RED);
+    illum.syncToDevice();
+    fos::Task::delayMs(500);
+
+    illum.clearColorData();
+    illum.setColorOfIndexTo(0, GREEN);
+    illum.syncToDevice();
+}
+
+constexpr bool DoFlushAtBeginning = false;
+constexpr bool DoFullTurns = false;
+constexpr bool DoTurnSteps = false;
+constexpr bool DoTurnProfiles = true;
+
+void testMovementTask() {
+    esp_log_level_set(TAG, ESP_LOG_DEBUG);
+    esp_log_level_set("STP", ESP_LOG_DEBUG);
+    ESP_LOGD(TAG, "Init Lights for signaling");
+
+    IndexIllumination illum;
+
+    if constexpr (DoFlushAtBeginning) {
+        IndexColorSweep(illum);
+    }
+    const auto BLUE = CBlue.getColor<Color::Rgbw>();
+
+    ESP_LOGD(TAG, "Init Stepper");
+
+    constexpr int MicroSteps = 32;
+    constexpr float Intensity = 0.25;
+    constexpr float StepWidth = 1.8;
+    StepperDriverDrv8833::Pins stepperPins({LEDC_TIMER_0,
+                                            {LEDC_CHANNEL_0, LEDC_CHANNEL_1, LEDC_CHANNEL_2, LEDC_CHANNEL_3},
+                                            {GPIO_NUM_21, GPIO_NUM_20, GPIO_NUM_23, GPIO_NUM_22}});
+    StepperDriverDrv8833 stepperDriver(stepperPins, MicroSteps, Intensity);
+    StepperConfig stepperCfg(StepWidth, MicroSteps);
+    InputPort initSens(GPIO_NUM_18);
+    OutputPort motorSleep(GPIO_NUM_15, GpioPort::Logic::Inverted);
+    StepperMotor stepper(stepperCfg, stepperDriver, initSens);
+
+    WatchMotor watch(stepper, motorSleep);
+
+    ///
+    /// Full Turns with full steps
+    ///
+    if constexpr (DoFullTurns) {
+        ESP_LOGD(TAG, "Find Home");
+        stepper.findRef();
+        ESP_LOGD(TAG, "Fist Position is %3d / %.2f / Micro %d", stepper.getQuanted(), stepper.getScaledPos() * 6, stepper.getSubPos());
+        fos::Task::delayMs(2000);
+
+        ESP_LOGD(TAG, "Make one turns with full steps");
+        // stepper.setPos(0);
+        illum.flashAll(BLUE);
+        int i = 0;
+
+        ESP_LOGD(TAG, "Position at begin is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+        while (i++ < 200) {
+            stepper.fullStep(1);
+            fos::Task::delayMs(100);
+            ESP_LOGD(TAG, "Position is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+        }
+        fos::Task::delayMs(2000);
+
+        int spB = stepper.getSubPos();
+        stepper.demoFullTurn();
+        int spE = stepper.getSubPos();
+        ESP_LOGD(TAG, "Fullsteps SubPos begin %d / end %d", spB, spE);
+        fos::Task::delayMs(2000);
+
+        ESP_LOGD(TAG, "Position at begin is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+        i = 0;
+        while (i++ < 64) {
+            stepper.step(1);
+            fos::Task::delayMs(100);
+            ESP_LOGD(TAG, "Position is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+        }
+    }
+
+    ///
+    /// Homing
+    ///
+    ESP_LOGD(TAG, "Find Home");
+    stepper.findRef();
+    ESP_LOGD(TAG, "Fist Position is %3d / %.2f / Micro %d", stepper.getQuanted(), stepper.getScaledPos() * 6, stepper.getSubPos());
+    for (size_t i = 0; i < 7; i++) {
+        stepper.fullStep(1);
+        fos::Task::delayMs(40);
+    }
+    illum.flashAll(BLUE);
+    fos::Task::delayMs(1000);
+
+    auto ref = stepper.zeroPosition();
+    ESP_LOGD(TAG, "Reference saved at %.2f ", ref);
+    ESP_LOGD(TAG, "Correct Home");
+
+    ///
+    /// Multiple Turns continuous
+    ///
+    if constexpr (DoTurnSteps) {
+
+        ESP_LOGD(TAG, "Fist Position is %3d / %.2f / Micro %d", stepper.getQuanted(), stepper.getScaledPos() * 6, stepper.getSubPos());
+        fos::Task::delayMs(1000);
+        ESP_LOGI(TAG, "Move to each index multiple times");
+        illum.flashAll(BLUE);
+        for (size_t i = 1; i <= 2 * 3; i++) {
+            watch.moveTo(3 * i);
+            ESP_LOGD(TAG, "Position is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+        }
+
+        ESP_LOGI(TAG, "Move to each index multiple times");
+        illum.flashAll(BLUE);
+        for (size_t i = 1; i <= 6 * 3; i++) {
+            watch.moveTo(i);
+            ESP_LOGD(TAG, "Position is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+        }
+    }
+
+    ///
+    /// All other Profiles
+    ///
+    if constexpr (DoTurnProfiles) {
+        for (size_t i = ProfileGenerator::Smooth; i < ProfileGenerator::NumProfiles; i++) {
+        // for (size_t i = ProfileGenerator::JumpIn; i < ProfileGenerator::NumProfiles; i++) { // If only part is needed
+            ESP_LOGI(TAG, "Running Profile %d ", i);
+            ESP_LOGD(TAG, "Fist Position is %3d / %.2f / Micro %d", stepper.getQuanted(), stepper.getScaledPos() * 6, stepper.getSubPos());
+            fos::Task::delayMs(1000);
+            illum.flashAll(BLUE);
+            int steps[3]{4, 2, 0};
+            for (size_t j = 0; j < 3; j++) {
+                watch.moveTo(steps[j], i);
+                ESP_LOGI(TAG, "Last position is %3d / %.2f", stepper.getQuanted(), stepper.getScaledPos() * 6);
+                fos::Task::delayMs(1000);
+            }
+        }
+    }
+
+    while (true) {
+        ESP_LOGI(TAG, "Finish");
+        fos::Task::delayMs(60000);
+    }
+}
+
+void app_main(void) {
+    ESP_LOGI(TAG, "Start Movement Integration Tests");
+
+    static fos::Task movementTest(testMovementTask, "Move", fos::Task::DefaultStackSize * 8);
+
+    while (true) {
+        fos::Task::delayMs(5000);
+        // ESP_LOGI(TAG, "Finish");
+    }
+}

test/integration/sdkconfig.defaults

@@ -0,0 +1,18 @@
+#
+# Compiler options
+#
+CONFIG_COMPILER_CXX_EXCEPTIONS=y
+
+#
+# Serial flasher config
+#
+CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
+CONFIG_ESPTOOLPY_FLASHSIZE="8MB"
+
+#
+# Log output
+#
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+CONFIG_LOG_DEFAULT_LEVEL=3
+CONFIG_LOG_MAXIMUM_LEVEL_DEBUG=y
+CONFIG_LOG_MAXIMUM_LEVEL=4

test/unitOnHost/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "cmake.cmakePath": "C:/msys64/usr/bin/cmake.exe"
+}

test/unitOnHost/CMakeLists.txt

@@ -20,7 +20,7 @@ project(UnitTests)
 find_package(doctest REQUIRED PATHS "/mingw64/lib/cmake")
 # target_link_libraries(${PROJECT_NAME} PRIVATE doctest::doctest)
 
-addSubDirs_ofRoot("${CMAKE_CURRENT_LIST_DIR}/../components")
+addSubDirs_ofRoot("${CMAKE_CURRENT_LIST_DIR}/../../components")
 
 
 

test/unitOnTarget/CMakeLists.txt

@@ -3,7 +3,10 @@ cmake_minimum_required(VERSION 3.16)
 
 # Include the components directory of the main application:
 #
-set(EXTRA_COMPONENT_DIRS "../components ../managed_components")
+set(EXTRA_COMPONENT_DIRS 
+    "../../components"
+    # "../../managed_components"
+)
 
 # Set the components to include the tests for.
 # This can be overriden from CMake cache:

test/unitOnTarget/dependencies.lock

@@ -0,0 +1,9 @@
+dependencies:
+  idf:
+    component_hash: null
+    source:
+      type: idf
+    version: 5.3.0
+manifest_hash: c4f4ec05313d427eb56c633f78ce213e553379725bf2af3c511665f930571beb
+target: esp32c6
+version: 1.0.0