From 9c054f3865670bb305d203276a13734640dc3989 Mon Sep 17 00:00:00 2001
From: Harald Wolff <haraldwolff@pc-harald.waldrennach.l--n.de>
Date: Mon, 21 Dec 2020 23:02:06 +0100
Subject: [PATCH] Still early alpha, controller works, stupidremote working

---
 libecmbind/ecmbind.h                          |   2 +-
 libecmbind/libecmbind.c                       |  12 +
 libecmbind/libecmbind_descriptors.c           |   4 +-
 ln.ethercat.service/EthercatService.cs        |  14 +-
 .../MainAxFeederControllerLogic.cs            |  63 +++
 ln.ethercat.service/Program.cs                |  46 ++
 .../api/v1/ControllerApiController.cs         | 134 ++---
 .../api/v1/ControllerWebSocket.cs             | 115 +++++
 .../api/v1/EthercatApiController.cs           |  15 -
 .../api/v1/EthercatWebSocket.cs               |  67 ++-
 ln.ethercat.service/www/html/spa.html         |   6 +-
 ln.ethercat.service/www/static/css/spa.css    |   6 +-
 ln.ethercat.service/www/static/js/ecapp.js    |   6 +
 ln.ethercat.service/www/static/js/pdopanel.js |  18 +-
 ln.ethercat.service/www/static/js/sdopanel.js |  22 +-
 .../www/static/js/sdoselect.js                |  19 +-
 .../www/static/pages/controller.html          |  11 +-
 ln.ethercat.service/www/static/pages/pdo.html |   4 +-
 .../www/static/pages/slave.html               |   5 +-
 ln.ethercat/ECDataTypeConverter.cs            |   2 +-
 ln.ethercat/ECMBind.cs                        |   8 +-
 ln.ethercat/ECMaster.cs                       | 465 +++++++++++++-----
 ln.ethercat/ECSlave.cs                        |  10 +-
 ln.ethercat/controller/Controller.cs          | 244 ++++++---
 ln.ethercat/controller/ControllerRemote.cs    | 105 ++++
 .../controller/drives/CIA402Controller.cs     | 162 +++---
 .../controller/drives/DriveController.cs      |  50 +-
 .../controller/remote/StupidSerialRemote.cs   | 171 +++++++
 ln.ethercat/lib/libecmbind.so                 | Bin 179424 -> 179512 bytes
 ln.ethercat/ln.ethercat.csproj                |   1 +
 30 files changed, 1387 insertions(+), 400 deletions(-)
 create mode 100644 ln.ethercat.service/MainAxFeederControllerLogic.cs
 create mode 100644 ln.ethercat.service/api/v1/ControllerWebSocket.cs
 create mode 100644 ln.ethercat/controller/ControllerRemote.cs
 create mode 100644 ln.ethercat/controller/remote/StupidSerialRemote.cs

diff --git a/libecmbind/ecmbind.h b/libecmbind/ecmbind.h
index 77a8087..641f6e1 100644
--- a/libecmbind/ecmbind.h
+++ b/libecmbind/ecmbind.h
@@ -27,7 +27,7 @@ typedef struct {
 } dto_servicedescriptor_t;
 
 typedef void (*cb_enum_indeces_t)(int slave, int index);
-typedef void (*cb_enum_sdo_descriptors_t)(int slave, int index, uint16_t dataType, uint16_t objectCode, int sub, char *name);
+typedef void (*cb_enum_sdo_descriptors_t)(int slave, int index, uint16_t dataType, uint16_t objectCode, int sub, ushort bitlength, char *name);
 typedef void (*cb_enum_pdo)(uint16_t slave, uint16_t index, char subindex, int addr_offset, int addr_bit, int bitlength);
 
 extern ecd_pdo_entry_t ecd_pdo_map[1024];
diff --git a/libecmbind/libecmbind.c b/libecmbind/libecmbind.c
index 7029373..2b0ca6a 100644
--- a/libecmbind/libecmbind.c
+++ b/libecmbind/libecmbind.c
@@ -181,6 +181,18 @@ int ecmbind_sdo_write(int slave, int index, int subindex, char* buffer, int size
     return ec_SDOwrite(slave, index, subindex, FALSE, size, buffer, 250000L);
 }
 
+int ecmbind_sdo_read_ca(int slave, int index, int subindex, char* buffer, int size)
+{
+    int wkc = ec_SDOread(slave, index, subindex, TRUE, &size, buffer, 250000L);
+    if (wkc <= 0)
+        return wkc;
+    return size;
+}
+int ecmbind_sdo_write_ca(int slave, int index, int subindex, char* buffer, int size)
+{
+    return ec_SDOwrite(slave, index, subindex, TRUE, size, buffer, 250000L);
+}
+
 /*
 typedef void (*cb_enum_pdo)(int slave, int index, int subindex, int addr_offset, int addr_bit, int bitlength);
 */
diff --git a/libecmbind/libecmbind_descriptors.c b/libecmbind/libecmbind_descriptors.c
index 34a0ca7..fa588a4 100644
--- a/libecmbind/libecmbind_descriptors.c
+++ b/libecmbind/libecmbind_descriptors.c
@@ -189,7 +189,7 @@ int ecmbind_read_objectdescription(int Slave, int index, cb_enum_sdo_descriptors
             strncpy(temp , (char *)&aSDOp->bdata[6], n);
             temp[n] = 0x00;
 
-            cb(Slave, index, etohs(aSDOp->wdata[1]), aSDOp->bdata[5], aSDOp->bdata[4], temp);
+            cb(Slave, index, etohs(aSDOp->wdata[1]), aSDOp->bdata[5], aSDOp->bdata[4], 0, temp);
          }
          /* got unexpected response from slave */
          else
@@ -265,7 +265,7 @@ int ecmbind_read_objectdescription_entry(uint16_t slave, uint16_t index, uint16_
             strncpy(temp , (char *)&aSDOp->wdata[5], n);
             temp[n] = 0x00; /* string terminator */
 
-            cb(slave, index, (ushort)etohs(aSDOp->wdata[2]), 0, sub, temp);
+            cb(slave, index, (ushort)etohs(aSDOp->wdata[2]), 0, sub, (ushort)etohs(aSDOp->wdata[3]), temp);
 
 /*
             pOElist->ValueInfo[sub] = aSDOp->bdata[3];
diff --git a/ln.ethercat.service/EthercatService.cs b/ln.ethercat.service/EthercatService.cs
index e32dc06..feca0ee 100644
--- a/ln.ethercat.service/EthercatService.cs
+++ b/ln.ethercat.service/EthercatService.cs
@@ -17,8 +17,6 @@ namespace ln.ethercat.service
     {
 
         public ECMaster ECMaster { get; private set; }
-        public Controller Controller { get; private set; }
-
 
         [StaticArgument(Option = 'i', LongOption = "interface")]
         public string EthercatInterfaceName { get; set; }
@@ -72,14 +70,9 @@ namespace ln.ethercat.service
             httpServer = new HTTPServer(httpLoggingRouter);
             httpServer.AddEndpoint(new Endpoint(IPv6.ANY, 7676));
 
-            Controller = new Controller();
-            Controller.Add(new CIA402Controller(ECMaster, 1));
-            Controller.Add(new CIA402Controller(ECMaster, 2));
-
-            controllerApiController = new ControllerApiController(Controller);
+            controllerApiController = new ControllerApiController(ECMaster.Controller);
             httpRouter.AddSimpleRoute("/api/v1/*", controllerApiController);
 
-
             timerWebsockets = new System.Timers.Timer(250);
             timerWebsockets.Elapsed += WebSocketTimerMethod;
         }
@@ -97,6 +90,7 @@ namespace ln.ethercat.service
         {
             try{
                 EthercatWebSocket.SendProcessData(ECMaster);
+                ControllerWebSocket.SendUpdates(ECMaster.Controller);
             } catch (Exception ex)
             {
                 Logging.Log(ex);
@@ -108,10 +102,10 @@ namespace ln.ethercat.service
             switch (newState)
             {
                 case ECSlaveState.OPERATIONAL:
-                    Controller.Start();
+                    //Controller.Start();
                     break;
                 default:
-                    Controller.Stop();
+                    //Controller.Stop();
                     break;
             }
         }
diff --git a/ln.ethercat.service/MainAxFeederControllerLogic.cs b/ln.ethercat.service/MainAxFeederControllerLogic.cs
new file mode 100644
index 0000000..7393ebe
--- /dev/null
+++ b/ln.ethercat.service/MainAxFeederControllerLogic.cs
@@ -0,0 +1,63 @@
+
+using System;
+using System.IO;
+using ln.ethercat.controller;
+using ln.json;
+using ln.json.mapping;
+
+namespace ln.ethercat.service
+{
+
+    public class MainAxFeederControllerLogic
+    {
+        public MyParameters Parameters { get; set; }
+
+        ECMaster ECMaster;
+
+        SDOValue svRelais;
+        SDOValue svEnable;
+
+        public MainAxFeederControllerLogic(ECMaster ecMaster)
+        {
+            ECMaster = ecMaster;
+
+            Parameters = new MyParameters();
+            if (File.Exists("mafcl.json"))
+            {
+                JSONValue configValue = JSONParser.ParseFile("mafcl.json");
+                JSONMapper.DefaultMapper.Apply(configValue as JSONObject, Parameters);
+            }
+        }
+
+        public void Save()
+        {
+            if (JSONMapper.DefaultMapper.Serialize(Parameters, out JSONValue configObject))
+            {
+                using (StreamWriter sw = new StreamWriter("mafcl.json"))
+                {
+                    sw.Write(configObject.ToString());
+                    sw.Flush();
+                }
+            }
+        }
+
+        public void Initialize()
+        {
+            if (!(
+                ECMaster.GetSDOValue(1, 0x2012, 31, out svRelais) &&
+                ECMaster.GetSDOValue(1, 0x2012, 32, out svEnable)
+            ))
+                throw new Exception("could not retrieve needed SDOValues");
+        }
+
+        public void ControllerLogic(Controller contreller)
+        {
+        }
+
+
+        public class MyParameters {
+
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/ln.ethercat.service/Program.cs b/ln.ethercat.service/Program.cs
index 6c74019..c3e5be2 100644
--- a/ln.ethercat.service/Program.cs
+++ b/ln.ethercat.service/Program.cs
@@ -1,9 +1,11 @@
 using System;
+using System.Data;
 using System.Text;
 using System.Threading;
 using ln.application;
 using ln.ethercat.controller;
 using ln.ethercat.controller.drives;
+using ln.ethercat.controller.remote;
 using ln.logging;
 using ln.type;
 
@@ -11,6 +13,9 @@ namespace ln.ethercat.service
 {
     class Program
     {
+        [StaticArgument(LongOption = "serial-remote")]
+        static string SerialRemotePort { get; set; }
+
         static void Main(string[] args)
         {
             Logging.Log(LogLevel.INFO, ".NET EtherCAT service host");
@@ -23,11 +28,52 @@ namespace ln.ethercat.service
             EthercatService ethercatService = new EthercatService(args[0]);
 
             ArgumentContainer argumentContainer = new ArgumentContainer();
+            argumentContainer.AddStaticOptions<Program>();
             argumentContainer.AddOptions(ethercatService);
             argumentContainer.Parse(ref args);
 
             ethercatService.Initialize();
+            ethercatService.ECMaster.OnStateChange += (ECMaster ECMaster, ECSlaveState newState) => {
+                if (newState == ECSlaveState.OPERATIONAL)
+                {
+                    ECMaster.DriveControllers[1].IgnoredByController = true;
+
+                    if (ECMaster.GetSDOValue(1, 0x2012, 32, out SDOValue svEnableDrives))
+                    {
+                        svEnableDrives.SetValue((byte)0x00);
+                    }
+
+                } else if (newState == ECSlaveState.PRE_OP)
+                {
+                    ECMaster.RequestPDOMapping(1, 0x2012, 31, true);
+                    ECMaster.RequestPDOMapping(1, 0x2012, 32, true);
+                }
+            };
+
+            ethercatService.ECMaster.Controller.OnStateChanged += (controller, state) => {
+                Logging.Log(LogLevel.DEBUG, "ControllerState=={0}", state);
+
+                if (state == ControllerStates.NOTREADY)
+                {
+                    if (controller.ECMaster.GetSDOValue(1, 0x2012, 32, out SDOValue svEnableDrives))
+                    {
+                        Logging.Log(LogLevel.DEBUG, "ControllerState=={0} powering up enable signals", state);
+                        svEnableDrives.SetValue((byte)0x01);
+                    }
+                } else if (state == ControllerStates.READY)
+                {
+                    controller.ECMaster.DriveControllers[1].DriveMode = DriveMode.TORQUE;
+                }
+            };
+
             ethercatService.Start();
+
+
+            if (SerialRemotePort != null)
+            {
+                StupidSerialRemote stupidSerialRemote = new StupidSerialRemote(ethercatService.ECMaster.Controller, SerialRemotePort);
+                stupidSerialRemote.Start();
+            }
         }
     }
 }
diff --git a/ln.ethercat.service/api/v1/ControllerApiController.cs b/ln.ethercat.service/api/v1/ControllerApiController.cs
index 722e06f..1e157ea 100644
--- a/ln.ethercat.service/api/v1/ControllerApiController.cs
+++ b/ln.ethercat.service/api/v1/ControllerApiController.cs
@@ -1,5 +1,3 @@
-
-
 using System;
 using System.Globalization;
 using System.Linq;
@@ -30,93 +28,61 @@ namespace ln.ethercat.service.api.v1
 
 
         [GET("/sockets/controller")]
-        public HttpResponse GetControllerSocket()
-        {
-            Timer timer = new Timer(250);
-            JSONWebSocketResponse websocket = new JSONWebSocketResponse();
-            websocket.OnWebSocketStateChanged += (Socket, newstate) => {
-                if (newstate == WebSocketState.CLOSED)
-                {
-                    timer.Stop();
-                    timer.Dispose();
-                }
-            };
+        public HttpResponse GetControllerSocket() => new ControllerWebSocket(Controller);
 
-            timer.Elapsed += (s,e) => {
-                try{
-                    JSONObject controllerState = new JSONObject()
-                        .Add("DriveControllers", new JSONArray().Add(Controller.DriveControllers.Select((dc=> new JSONObject()
-                                                                                                                    .Add("slave", dc.Slave)
-                                                                                                                    .Add("DriveController", dc.GetType().Name)
-                                                                                                                    .Add("DriveState", dc.DriveState.ToString())
-                                                                                                                    ))))
-                        .Add("DrivesState", Controller.DrivesState.ToString())
-                        .Add("IsRunning", Controller.IsRunning)
-                    ;
-                    websocket.Send(controllerState);
-                } catch (Exception ex)
-                {
-                    Logging.Log(ex);
-                }
-            };
+        // [GET("/sockets/controller/drives/:drive")]
+        // public HttpResponse GetDriveControllerSocket(int drive)
+        // {
+        //     DriveController driveController = Controller.DriveControllers[drive];
 
-            timer.Start();
-            return websocket;
-        }
+        //     Timer timer = new Timer(250);
+        //     JSONWebSocketResponse websocket = new JSONWebSocketResponse();
+        //     websocket.OnWebSocketStateChanged += (Socket, newstate) => {
+        //         if (newstate == WebSocketState.CLOSED)
+        //         {
+        //             timer.Stop();
+        //             timer.Dispose();
+        //         }
+        //     };
 
-        [GET("/sockets/controller/drives/:drive")]
-        public HttpResponse GetDriveControllerSocket(int drive)
-        {
-            DriveController driveController = Controller.DriveControllers[drive];
+        //     websocket.OnWebSocketReceivedText += (s,text) => {
+        //         JSONObject message = (JSONObject)JSONParser.Parse(text);
+        //         switch (message["event"].ToNative().ToString())
+        //         {
+        //             case "action":
+        //             Logging.Log(LogLevel.DEBUG, "DriveControllerSocket: action: {0}", message["value"].ToNative().ToString());
+        //                 driveController.GetType().GetMethod(message["value"].ToNative().ToString()).Invoke(driveController, new object[0]{});
+        //                 break;
+        //             case "set":
+        //                 JSONObject jsonSet = (message["value"] as JSONObject);
+        //                 foreach (string key in jsonSet.Keys)
+        //                 {
+        //                     PropertyInfo propertyInfo = driveController.GetType().GetProperty(key);
+        //                     propertyInfo.SetValue(driveController, Cast.To(jsonSet[key].ToNative(), propertyInfo.PropertyType));
+        //                 }
+        //                 break;
+        //         }
+        //     };
 
-            Timer timer = new Timer(250);
-            JSONWebSocketResponse websocket = new JSONWebSocketResponse();
-            websocket.OnWebSocketStateChanged += (Socket, newstate) => {
-                if (newstate == WebSocketState.CLOSED)
-                {
-                    timer.Stop();
-                    timer.Dispose();
-                }
-            };
+        //     timer.Elapsed += (s,e) => {
+        //         try{
+        //             JSONObject driveControllerState = new JSONObject()
+        //                 .Add("id", drive)
+        //                 .Add("DriveState", driveController.DriveState.ToString())
+        //                 .Add("OEMDriveState", driveController.OEMDriveState)
+        //                 .Add("DriveMode", driveController.DriveMode)
+        //                 .Add("OEMDriveMode", driveController.OEMDriveMode)
+        //                 ;
+        //             websocket.Send(driveControllerState);
+        //         } catch (Exception ex)
+        //         {
+        //             Logging.Log(ex);
+        //         }
+        //     };
 
-            websocket.OnWebSocketReceivedText += (s,text) => {
-                JSONObject message = (JSONObject)JSONParser.Parse(text);
-                switch (message["event"].ToNative().ToString())
-                {
-                    case "action":
-                    Logging.Log(LogLevel.DEBUG, "DriveControllerSocket: action: {0}", message["value"].ToNative().ToString());
-                        driveController.GetType().GetMethod(message["value"].ToNative().ToString()).Invoke(driveController, new object[0]{});
-                        break;
-                    case "set":
-                        JSONObject jsonSet = (message["value"] as JSONObject);
-                        foreach (string key in jsonSet.Keys)
-                        {
-                            PropertyInfo propertyInfo = driveController.GetType().GetProperty(key);
-                            propertyInfo.SetValue(driveController, Cast.To(jsonSet[key].ToNative(), propertyInfo.PropertyType));
-                        }
-                        break;
-                }
-            };
-
-            timer.Elapsed += (s,e) => {
-                try{
-                    JSONObject driveControllerState = new JSONObject()
-                        .Add("id", drive)
-                        .Add("DriveState", driveController.DriveState.ToString())
-                        .Add("OEMDriveState", driveController.OEMDriveState)
-                        .Add("DriveMode", driveController.DriveMode)
-                        .Add("OEMDriveMode", driveController.OEMDriveMode)
-                        ;
-                    websocket.Send(driveControllerState);
-                } catch (Exception ex)
-                {
-                    Logging.Log(ex);
-                }
-            };
-
-            timer.Start();
-            return websocket;
-        }
+        //     timer.Start();
+        //     return websocket;
+        // }
         
 
     }
diff --git a/ln.ethercat.service/api/v1/ControllerWebSocket.cs b/ln.ethercat.service/api/v1/ControllerWebSocket.cs
new file mode 100644
index 0000000..1707f79
--- /dev/null
+++ b/ln.ethercat.service/api/v1/ControllerWebSocket.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using ln.ethercat.controller;
+using ln.ethercat.controller.drives;
+using ln.http.websocket;
+using ln.json;
+using ln.logging;
+
+namespace ln.ethercat.service.api.v1
+{
+    public class ControllerWebSocket : WebSocketResponse
+    {
+        static List<ControllerWebSocket> webSockets = new List<ControllerWebSocket>();
+        static bool sendingUpdates;
+        public static void SendUpdates(Controller controller)
+        {
+            lock (webSockets)
+            {
+                if (sendingUpdates)
+                    return;
+                sendingUpdates = true;
+            }
+
+            try
+            {
+
+                JSONArray jsonDriveControllers = new JSONArray();
+
+                foreach (DriveController driveController in controller.ECMaster.DriveControllers)
+                {
+                    JSONObject jsonDriveController =
+                        new JSONObject()
+                        .Add("DriveState", driveController.DriveState.ToString())
+                        .Add("OEMState", driveController.OEMDriveState)
+                        .Add("DriveMode", driveController.DriveMode.ToString())
+                        .Add("TargetValue", driveController.TargetValue)
+                        .Add("ActualSpeed", driveController.ActualSpeed)
+                        .Add("ActualTorque", driveController.ActualTorque)
+                        .Add("ActualLoad", driveController.ActualLoad)
+                        ;
+                    
+                    jsonDriveControllers.Add(jsonDriveController);
+                }
+
+                JSONObject jsonController = 
+                    new JSONObject()
+                    .Add("State", controller.ControllerState.ToString())
+                    .Add("Drives", jsonDriveControllers)
+                    .Add("CycleCounter", controller.CycleCounter)
+                    ;
+
+
+                JSONObject jsonMessage =
+                    new JSONObject()
+                    .Add("event", "update")
+                    .Add("value", jsonController)
+                    ;
+
+                string jsonMessageText = jsonMessage.ToString();
+
+                ControllerWebSocket[] currentSockets;
+                lock (webSockets)
+                    currentSockets = webSockets.ToArray();
+
+                foreach (ControllerWebSocket webSocket in currentSockets)
+                {
+                    if (webSocket.Controller.Equals(controller) && (webSocket.State == WebSocketState.OPEN))
+                        webSocket.Send(jsonMessageText);
+                }
+            } catch (Exception e)
+            {
+                Logging.Log(e);
+            } finally
+            {
+                sendingUpdates = false;
+            }
+        }
+
+        Controller Controller;
+
+        public ControllerWebSocket(Controller controller)
+        {
+            Controller = controller;
+            OnWebSocketStateChanged += (WebSocketResponse webSocket, WebSocketState newState) => {
+                switch (newState)
+                {
+                    case WebSocketState.OPEN:
+                        lock (webSockets)
+                            webSockets.Add(this);
+                        break;
+                    default:
+                        lock (webSockets)
+                            webSockets.Remove(this);
+                        break;
+                }
+            };
+        }
+
+
+        public override void Received(string textMessage)
+        {
+            base.Received(textMessage);
+
+            JSONValue jsonTextValue = JSONParser.Parse(textMessage);
+            if (jsonTextValue is JSONObject jsonMessage)
+            {
+                string eventName = jsonMessage["event"].ToNative().ToString();
+            }
+        }
+
+
+
+    }
+}
\ No newline at end of file
diff --git a/ln.ethercat.service/api/v1/EthercatApiController.cs b/ln.ethercat.service/api/v1/EthercatApiController.cs
index e5a8b0f..37b4226 100644
--- a/ln.ethercat.service/api/v1/EthercatApiController.cs
+++ b/ln.ethercat.service/api/v1/EthercatApiController.cs
@@ -1,18 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Timers;
 using ln.http;
 using ln.http.api;
 using ln.http.api.attributes;
-using ln.http.websocket;
 using ln.json;
-using ln.json.mapping;
-using ln.logging;
 
 namespace ln.ethercat.service.api.v1
 {
-
     public class EthercatApiController : WebApiController
     {
         ECMaster ECMaster => EthercatService.ECMaster;
@@ -51,14 +44,6 @@ namespace ln.ethercat.service.api.v1
         [GET("/slaves/:slave/state")]
         public HttpResponse GetEthercatState(int slave) => HttpResponse.OK().Content(ECMaster.ReadSlaveState(slave).ToString());
 
-        [POST("/slaves/:slave/state")]
-        public HttpResponse RequestEthercatState(int slave, ECSlaveState state)
-        {
-            if (ECMaster.RequestSlaveState(slave, state) > 0)
-                return HttpResponse.NoContent();
-            return HttpResponse.GatewayTimeout();
-        }
-
 
         [GET("/master/state")]
         public HttpResponse GetFullState()
diff --git a/ln.ethercat.service/api/v1/EthercatWebSocket.cs b/ln.ethercat.service/api/v1/EthercatWebSocket.cs
index 8f20d31..23218af 100644
--- a/ln.ethercat.service/api/v1/EthercatWebSocket.cs
+++ b/ln.ethercat.service/api/v1/EthercatWebSocket.cs
@@ -10,6 +10,7 @@ using ln.http.websocket;
 using ln.json;
 using ln.json.mapping;
 using ln.logging;
+using ln.type;
 
 namespace ln.ethercat.service.api.v1
 {
@@ -17,9 +18,19 @@ namespace ln.ethercat.service.api.v1
     {
         /************** Static ***************************************************************************/
         static List<EthercatWebSocket> activeWebSockets = new List<EthercatWebSocket>();
+        static bool broadcastActive;
 
         public static void SendProcessData(ECMaster ecMaster)
         {
+            lock (activeWebSockets)
+            {
+                if (broadcastActive)
+                    return;
+                broadcastActive = true;
+            }
+
+            try{
+
             JSONArray jsonPDOList = new JSONArray();
 
             foreach (PDO pdo in ecMaster.GetPDOMap())
@@ -49,11 +60,29 @@ namespace ln.ethercat.service.api.v1
                 );
             string stateMessageText = stateMessage.ToString();
 
-            foreach (EthercatWebSocket webSocket in activeWebSockets)
+            EthercatWebSocket[] sockets;
+            lock(activeWebSockets)
+                sockets = activeWebSockets.ToArray();
+
+            foreach (EthercatWebSocket webSocket in sockets)
             {
-                webSocket.Send(messageText);
-                webSocket.Send(stateMessageText);
-                webSocket.SendSubscribedSDOs();
+                if (webSocket.State != WebSocketState.OPEN)
+                {
+                    lock (activeWebSockets)
+                        activeWebSockets.Remove(webSocket);
+                } else 
+                {
+                    webSocket.Send(messageText);
+                    webSocket.Send(stateMessageText);
+                    webSocket.SendSubscribedSDOs();
+                }
+            }
+            } catch (Exception e)
+            {
+                Logging.Log(e);
+            } finally
+            {
+                broadcastActive = false;
             }
         }
 
@@ -93,11 +122,13 @@ namespace ln.ethercat.service.api.v1
             {
                 case WebSocketState.OPEN:
                     Logging.Log(LogLevel.DEBUG, "EthercatWebSocket -> active");
-                    activeWebSockets.Add(this);
+                    lock(activeWebSockets)
+                        activeWebSockets.Add(this);
                     break;
-                case WebSocketState.CLOSED:
+                default:
                     Logging.Log(LogLevel.DEBUG, "EthercatWebSocket -> inactive");
-                    activeWebSockets.Remove(this);
+                    lock(activeWebSockets)
+                        activeWebSockets.Remove(this);
                     break;
             }
         }
@@ -127,6 +158,28 @@ namespace ln.ethercat.service.api.v1
                         break;
                     case "action":
 
+                        break;
+                    case "sdowrite":
+                        if (jsonMessage["value"] is JSONObject jsonValue)
+                        {
+                            UInt16 slave_id, index;
+                            byte subindex;
+                            object value;
+
+                            slave_id = Cast.To<UInt16>(jsonValue["Slave"].ToNative());
+                            index = Cast.To<UInt16>(jsonValue["Index"].ToNative());
+                            subindex = Cast.To<byte>(jsonValue["SubIndex"].ToNative());
+                            value = jsonValue["Value"].ToNative();
+
+                            if (EthercatService.ECMaster.GetSDOValue(slave_id, index, subindex, out SDOValue sdoValue))
+                            {
+                                sdoValue.SetValue(value);
+                            } else
+                            {
+                                Logging.Log(LogLevel.DEBUG, "EthercatWebSocket: event sdowrite: could not find SDOValue {0}:{1:X4}.{2}", slave_id, index, subindex);
+                            }
+                        }
+
                         break;
                 }
             }
diff --git a/ln.ethercat.service/www/html/spa.html b/ln.ethercat.service/www/html/spa.html
index 5676f8c..db0a1d8 100644
--- a/ln.ethercat.service/www/html/spa.html
+++ b/ln.ethercat.service/www/html/spa.html
@@ -50,7 +50,11 @@
                     <router-view></router-view>
                 </div>
                 <aside class="right">
-                    <pdo-panel id="pdopanel" :processdata="processdata"></pdo-panel>
+                    <pdo-panel
+                        id="pdopanel"
+                        :processdata="processdata"
+                        @write="$ECAPP.sendMessage('sdowrite', $event);"
+                        ></pdo-panel>
                 </aside>
             </main>
             <footer>
diff --git a/ln.ethercat.service/www/static/css/spa.css b/ln.ethercat.service/www/static/css/spa.css
index 07c54c4..3991bb6 100644
--- a/ln.ethercat.service/www/static/css/spa.css
+++ b/ln.ethercat.service/www/static/css/spa.css
@@ -49,13 +49,13 @@ fieldset {
     display: flex;
 }
 
-fieldset > input {
-    flex-grow: 1;
-}
 fieldset > label {
     flex-grow: 0;
 }
 
+fieldset > input, fieldset > .value {
+    flex-grow: 1;
+}
 
 .panel {
     padding: 6px;
diff --git a/ln.ethercat.service/www/static/js/ecapp.js b/ln.ethercat.service/www/static/js/ecapp.js
index 3c71602..6ec5730 100644
--- a/ln.ethercat.service/www/static/js/ecapp.js
+++ b/ln.ethercat.service/www/static/js/ecapp.js
@@ -24,6 +24,10 @@ class EthercatApplication
         this.base_url = scheme + "//" + host;
 
         this.connectMainSocket();
+
+        window.onunload = () => {
+            this.closeWebSockets();
+        };
     }
 
     connectMainSocket(){
@@ -49,6 +53,7 @@ class EthercatApplication
         this.socket.onerror = (evt)=>{
             console.log("weboscket error: ", evt);
             this.socket.close();
+            this.socket = null;
         };
         this.socket.onclose = (evt)=>{
             console.log("weboscket closed: ", evt);
@@ -72,6 +77,7 @@ class EthercatApplication
         {
             let ws = this.ac_sockets.pop();
             console.log("disposing:", ws);
+            ws.onclose = null;
             ws.close();
         }
     }
diff --git a/ln.ethercat.service/www/static/js/pdopanel.js b/ln.ethercat.service/www/static/js/pdopanel.js
index e52b9a7..d0109e2 100644
--- a/ln.ethercat.service/www/static/js/pdopanel.js
+++ b/ln.ethercat.service/www/static/js/pdopanel.js
@@ -12,12 +12,26 @@
         data: function(){
             return {}
         },
+        methods: {
+            promptNewValue: function(slave, index, subindex, datatype, initialValue){
+                console.log(index, subindex, datatype, initialValue);
+                let newValue = window.prompt(`new value for ${slave}:${index.toString(16)}.${subindex}`, initialValue);
+                console.log(newValue);
+                if (newValue)
+                {
+                    this.$emit("write", { Slave: slave, Index: index, SubIndex: subindex, Value: newValue});
+                }
+            }
+        },
         template: `
 <div class="panel">
     <h2>Prozessdaten</h2>
     <article v-for="sdo,key in processdata">
-        <div>{{sdo.Descriptor.Index.toString(16).toUpperCase()}}.{{sdo.SubIndex}} {{ sdo.Name }}</div>
-        <div class="value">{{ sdo.Value }}</div>
+        <div>{{sdo.Descriptor.SlaveId}}:{{sdo.Descriptor.Index.toString(16).toUpperCase()}}.{{sdo.SubIndex}} {{ sdo.Name }} ({{sdo.DataType}})</div>
+        <div
+            class="value"
+            @dblclick="promptNewValue(sdo.Descriptor.SlaveId, sdo.Descriptor.Index, sdo.SubIndex, sdo.DataType, sdo.Value);"
+            >{{ sdo.Value }}</div>
     </article>
 </div>
     `,
diff --git a/ln.ethercat.service/www/static/js/sdopanel.js b/ln.ethercat.service/www/static/js/sdopanel.js
index 23b2d81..d049a5a 100644
--- a/ln.ethercat.service/www/static/js/sdopanel.js
+++ b/ln.ethercat.service/www/static/js/sdopanel.js
@@ -13,18 +13,32 @@
         data: function(){
             return {}
         },
+        methods: {
+            promptNewValue: function(slave, index, subindex, datatype, initialValue){
+                console.log(index, subindex, datatype, initialValue);
+                let newValue = window.prompt(`new value for ${slave}:${index.toString(16)}.${subindex}`, initialValue);
+                console.log(newValue);
+                if (newValue)
+                {
+                    this.$emit("write", { Slave: slave, Index: index, SubIndex: subindex, Value: newValue});
+                }
+            }
+        },
         template: `
 <div class="panel">
     <h2>SDO Panel</h2>
     <article v-for="sdo,key in subscribed">
         <h2>{{sdo.Index.toString(16).toUpperCase()}} {{ sdo.Name }} ({{ sdo.DataType}} / M:{{ sdo.MaxSubIndex }})</h2>
         <ul>
-            <div
+            <fieldset
                 v-for="sdovalue in sdo.Values"
                 >
-                <span>.{{sdovalue.SubIndex}} {{ sdovalue.Name }} ({{ sdo.DataType}})</span>
-                <input :disabled="(sdovalue.DataType == 'NONE')" type="text" :value="sdovalue.Value">
-            </div>
+                <span>.{{sdovalue.SubIndex}} {{ sdovalue.Name }} ({{ sdovalue.DataType}})</span>
+                <div
+                    class="value"
+                    @dblclick="promptNewValue(sdo.SlaveId, sdo.Index, sdovalue.SubIndex, sdovalue.DataType, sdovalue.Value);"
+                    >{{ sdovalue.Value }}</div>
+            </fieldset>
         </ul>
     </article>
 </div>
diff --git a/ln.ethercat.service/www/static/js/sdoselect.js b/ln.ethercat.service/www/static/js/sdoselect.js
index a1acb25..1567ad2 100644
--- a/ln.ethercat.service/www/static/js/sdoselect.js
+++ b/ln.ethercat.service/www/static/js/sdoselect.js
@@ -16,20 +16,35 @@
                     datatype: null,
                 },
                 selectedIndex: null,
+                manualIndex: "",
             };
         },
         methods: {
             getFilteredDescriptors: function(){
-                return this.descriptors.filter((sdo)=>
-                    (!this.filters.name || sdo.name.toLowerCase().includes(this.filters.name.toLowerCase())) ); // &&
+                if (this.filters.name)
+                    return this.descriptors.filter((sdo)=>(sdo.name.toLowerCase().includes(this.filters.name.toLowerCase())) );
+                else
+                    return this.descriptors;
+                    
+                    // &&
                     // (!this.filters.index || sdo.index.toString(16).toLowerCase().includes(this.filters.index.toLowerCase())) &&
                     // (!this.filters.datatype || sdo.datatype.toLowerCase().includes(this.filters.datatype.toLowerCase())) &&
                     // (!this.filters.slave || sdo.address.slave.toLowerCase().includes(this.filters.slave.toLowerCase()))
                     // );
             },
+            addManualIndex: function(){
+                if (this.manualIndex)
+                {
+                    this.$emit("selected", parseInt(this.manualIndex, 16));
+                }
+            }
         },
         template: `
 <sdoselect class="flex" style="flex-direction: column;">
+    <fieldset>
+        <input type="text" pattern="[a-fA-F0-9]{4}" v-model="manualIndex">
+        <button @click="addManualIndex();">+</button>
+    </fieldset>
     <input type="text" v-model="filters.name">
     <select size="15" v-model="selectedIndex" @dblclick="if (selectedIndex>=0) $emit('selected', selectedIndex);">
         <option
diff --git a/ln.ethercat.service/www/static/pages/controller.html b/ln.ethercat.service/www/static/pages/controller.html
index add9687..1e8382a 100644
--- a/ln.ethercat.service/www/static/pages/controller.html
+++ b/ln.ethercat.service/www/static/pages/controller.html
@@ -3,11 +3,6 @@
     <p>
         {{ controller }}
     </p>
-    <div>
-        <router-link
-            v-for="dc,idx in controller.DriveControllers"
-            :to="'/controller/drives/' + idx">Drive Controller {{ idx }}</router-link>
-    </div>
     <div v-if="drive_controller">
         <h2>Drive Controller</h2>
         <button @click="drive_poweroff">Power Off</button>
@@ -27,9 +22,9 @@
         <div>
             <fieldset>
                 <label>Target Torque:</label>
-                <input type="range" min="-1000" max="1000" v-model="targetTorque" id="targetTorque" @input="setProperty('TargetTorque', targetTorque);">
-                <input type="number" v-model="targetTorque" @change="setProperty('TargetTorque', targetTorque);">
-                <button @click="targetTorque = 0; setProperty('TargetTorque', targetTorque);">ZERO</button>
+                <input type="range" min="-1000" max="1000" v-model="targetTorque" id="targetTorque" @input="setProperty('TargetValue', targetTorque);">
+                <input type="number" v-model="targetTorque" @change="setProperty('TargetValue', targetTorque);">
+                <button @click="targetTorque = 0; setProperty('TargetValue', targetTorque);">ZERO</button>
             </fieldset>
         </div>
 
diff --git a/ln.ethercat.service/www/static/pages/pdo.html b/ln.ethercat.service/www/static/pages/pdo.html
index 3933e26..b96898f 100644
--- a/ln.ethercat.service/www/static/pages/pdo.html
+++ b/ln.ethercat.service/www/static/pages/pdo.html
@@ -1,4 +1,6 @@
 <div>
     <h1>Prozessdaten</h1>
-    <sdo-table :sdolist="this.processdata"></sdo-table>
+    <sdo-table
+        :sdolist="this.processdata"
+        ></sdo-table>
 </div>
\ No newline at end of file
diff --git a/ln.ethercat.service/www/static/pages/slave.html b/ln.ethercat.service/www/static/pages/slave.html
index 3c06145..e1174de 100644
--- a/ln.ethercat.service/www/static/pages/slave.html
+++ b/ln.ethercat.service/www/static/pages/slave.html
@@ -7,6 +7,9 @@
                 @selected="$ECAPP.subscribe(slave_id, $event);"
                 ></sdo-select>
         </div>
-        <sdo-panel :subscribed="$ECAPP.subscribed.sdo"></sdo-panel>
+        <sdo-panel
+            :subscribed="$ECAPP.subscribed.sdo"
+            @write="$ECAPP.sendMessage('sdowrite', $event);"
+            ></sdo-panel>
     </div>
 </div>
\ No newline at end of file
diff --git a/ln.ethercat/ECDataTypeConverter.cs b/ln.ethercat/ECDataTypeConverter.cs
index 15de7d3..2665381 100644
--- a/ln.ethercat/ECDataTypeConverter.cs
+++ b/ln.ethercat/ECDataTypeConverter.cs
@@ -159,7 +159,7 @@ namespace ln.ethercat
                 ));
 
             AddConverter(ECDataTypes.NONE, new ECValueConverterAdapter(
-                typeof(byte[]),
+                typeof(string),
                 (object value, out byte[] ethercatBytes) => { ethercatBytes = Extensions.BytesFromHexString(value as string); return true; },
                 (byte[] ethercatBytes, out object value) => { value = ethercatBytes.ToHexString(); return true; }
                 ));
diff --git a/ln.ethercat/ECMBind.cs b/ln.ethercat/ECMBind.cs
index e0850a3..6f9f513 100644
--- a/ln.ethercat/ECMBind.cs
+++ b/ln.ethercat/ECMBind.cs
@@ -41,7 +41,7 @@ namespace ln.ethercat
     }
 
     public delegate void cb_enum_indeces(int slave, int index);
-    public delegate void cb_enum_sdo_descriptors(int slave, int index, ECDataTypes dataType, ECObjectCodes objectCode, int maxsub, String name);
+    public delegate void cb_enum_sdo_descriptors(int slave, int index, ECDataTypes dataType, ECObjectCodes objectCode, int maxsub, ushort bitlength, String name);
     public delegate void cb_enum_pdo(UInt16 slave, UInt16 index, byte subindex, int addr_offset, int addr_bit, int bitlength);
 
 
@@ -106,6 +106,12 @@ namespace ln.ethercat
         [DllImport("lib/libecmbind.so")]
         public static extern int ecmbind_sdo_write(int slave, int index, int subindex, byte[] buffer, int size);
 
+        [DllImport("lib/libecmbind.so")]
+        public static extern int ecmbind_sdo_read_ca(int slave, int index, int subindex, byte[] buffer, int size);
+
+        [DllImport("lib/libecmbind.so")]
+        public static extern int ecmbind_sdo_write_ca(int slave, int index, int subindex, byte[] buffer, int size);
+
 
 
         [DllImport("lib/libecmbind.so")]
diff --git a/ln.ethercat/ECMaster.cs b/ln.ethercat/ECMaster.cs
index ce352a1..f0711bf 100644
--- a/ln.ethercat/ECMaster.cs
+++ b/ln.ethercat/ECMaster.cs
@@ -1,13 +1,13 @@
 
 
 using System;
-using System.Buffers;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Reflection.Metadata;
-using System.Security.Cryptography.X509Certificates;
 using System.Threading;
+using ln.ethercat.controller;
+using ln.ethercat.controller.drives;
 using ln.logging;
 using ln.type;
 
@@ -21,6 +21,23 @@ namespace ln.ethercat
         RUNNING,
     }
 
+    public struct PDOMappingRequest
+    {
+        public ushort Slave;
+        public ushort Index;
+        public byte SubIndex;
+        public bool RxPDO;
+
+        public PDOMappingRequest(ushort slave,ushort index,byte subIndex,bool rxpdo)
+        {
+            Slave = slave;
+            Index = index;
+            SubIndex = subIndex;
+            RxPDO = rxpdo;
+        }
+
+    }
+
     public delegate void ECStateChange(ECMaster sender,ECSlaveState newState);
 
     public class ECMaster
@@ -47,8 +64,8 @@ namespace ln.ethercat
 
         ECSlaveState ethercatState = ECSlaveState.NONE;
         public ECSlaveState EthercatState { 
-                get => UpdateEthercatState();
-                set {
+                get =>ethercatState;
+                private set {
                     if (value != ethercatState)
                     {
                         OnStateChange?.Invoke(this, value);
@@ -73,113 +90,168 @@ namespace ln.ethercat
             Logging.Log(LogLevel.INFO, "ecmbind_initialize({0}) = {1}", interfaceName, result);
             if (result<=0)
                 throw new Exception("ecmbind_initialize failed");
+
+            Controller = new Controller(this);
         }
 
-        bool stopProcessing;
-        public bool StopProccessing {
-            get => stopProcessing;
-            set => stopProcessing = value;
-        }
+        bool stopWatchdog;
+        bool stopProcessData;
 
         Thread threadProcessData;
         Thread threadWatchdog;
 
-        public bool Start()
+        public Controller Controller { get; }
+        List<DriveController> driveControllers = new List<DriveController>();
+        public DriveController[] DriveControllers => driveControllers.ToArray();
+
+
+        public void Start()
         {
-            if ((threadProcessData?.IsAlive ?? false) || (threadWatchdog?.IsAlive ?? false))
-                throw new Exception("already started");
-            
-            stopProcessing = false;
-
-            EthercatState = ECSlaveState.BOOT;
-            ExpectedWorkCounter = 0;
-
-            EthercatState = ECSlaveState.INIT;
             lock (this)
             {
-                CountSlaves = ECMBind.ecmbind_config_init();
-                if (CountSlaves <= 0)
-                {
-                    Logging.Log(LogLevel.DEBUG, "ECMaster: no slaves connected");
-                    return false;
-                }
+                if (threadWatchdog?.IsAlive ?? false)
+                    throw new Exception("already started");
 
-                if (!CheckState(ECSlaveState.PRE_OP, TIMEOUT_PREOP))
-                    return false;
+                ethercatState = ECSlaveState.NONE;
+                ExpectedWorkCounter = 0;
 
-                IOMapSize = ECMBind.ecmbind_config_map();
-                Logging.Log(LogLevel.DEBUG, "ECMaster: IOMapSize={0}", IOMapSize);
-
-                UpdatePDOMap();
-                
-                threadProcessData = new Thread(MasterThread);
-                threadProcessData.Start();
-
-                Thread.Sleep(20);
-
-                if (!RequestState(ECSlaveState.SAFE_OP, out ECSlaveState slaveState, TIMEOUT_SAFEOP))
-                {
-                    Stop();
-                    return false;
-                }
+                stopWatchdog = false;
 
                 threadWatchdog = new Thread(Watchdog);
                 threadWatchdog.Start();
-
             }
-            return true;
         }
 
         public void Stop()
         {                
-            if (threadProcessData?.IsAlive ?? false)
+            lock (this)
             {
-                stopProcessing = true;
-                ECMBind.ecmbind_request_state(0, ECSlaveState.SAFE_OP, TIMEOUT_BACKTO_SAFEOP);
-
-                threadProcessData.Join();
-                threadProcessData = null;
-
-                if (!Thread.CurrentThread.Equals(threadWatchdog))
+                if (threadWatchdog?.IsAlive ?? false)
                 {
-                    threadWatchdog?.Join();
-                    threadWatchdog = null;
+                    stopWatchdog = true;
+
+                    lock (this)
+                        Monitor.PulseAll(this);
+
+                    threadWatchdog.Join();
                 }
             }
         }
-        
-
-        object lockIOMap = new object();
-        byte[] iomap = new byte[8192];
 
         void Watchdog()
         {
-                // if (!ReadSDOIndeces())
-                // {
-                //     Logging.Log(LogLevel.WARNING, "ECMaster: could not read SDO indeces");
-                // }
-
-                if (!RequestState(ECSlaveState.OPERATIONAL, out ECSlaveState slaveState, TIMEOUT_SAFEOP))
+            while (!stopWatchdog)
+            {
+                IOMapSize = 0;
+                if (threadProcessData?.IsAlive ?? false)
                 {
-                    if (slaveState < ECSlaveState.SAFE_OP)
-                        Stop();
+                    stopProcessData = true;
+                    while (threadProcessData.IsAlive)
+                        threadProcessData.Join(250);
+                }
+                stopProcessData = false;
+
+                EthercatState = ECSlaveState.INIT;
+
+                CountSlaves = ECMBind.ecmbind_config_init();
+                if (CountSlaves <= 0)
+                {
+                    Logging.Log(LogLevel.DEBUG, "ECMaster: no slaves connected, scheduling restart...");
+                    Thread.Sleep(2500);
+                    continue;
                 }
 
-                while (!stopProcessing)
+
+                if (!WaitForState(ECSlaveState.PRE_OP, TIMEOUT_PREOP))
                 {
-                    UpdateEthercatState();
-                    Thread.Sleep(250);
+                    Logging.Log(LogLevel.DEBUG, "ECMaster: slaves did not reach PRE_OP. restart...");
+                    Thread.Sleep(2500);
+                    continue;
                 }
+
+
+                /* Bus State PRE_OP */
+                ScanControllers();
+
+                EthercatState = ECSlaveState.PRE_OP;
+
+                ConfigureProcessDataMappings();
+                SetupPDOMapping();
+                UpdatePDOMap();
+                
+                threadProcessData = new Thread(ProcessData);
+                threadProcessData.Start();
+
+                Thread.Sleep(20);
+                RequestSlaveState(0, ECSlaveState.SAFE_OP);
+
+                if (!WaitForState(ECSlaveState.SAFE_OP, TIMEOUT_SAFEOP))
+                {
+                    Logging.Log(LogLevel.DEBUG, "ECMaster: slaves did not reach SAFE_OP. restart...");
+                    Thread.Sleep(2500);
+                    continue;
+                }
+
+                EthercatState = ECSlaveState.SAFE_OP;
+
+                Thread.Sleep(20);
+                RequestSlaveState(0, ECSlaveState.OPERATIONAL);
+                
+                Thread.Sleep(250);
+                if (!WaitForState(ECSlaveState.OPERATIONAL, TIMEOUT_SAFEOP))
+                {
+                    Logging.Log(LogLevel.DEBUG, "ECMaster: slaves did not reach OPERATIONAL. restart...");
+                    Thread.Sleep(2500);
+                    continue;
+                }
+
+                EthercatState = ECSlaveState.OPERATIONAL;
+
+                /*****  we handle the controller cycle from here on *****/
+
+                Controller.Initialize();
+
+                DateTime nextControllerRun = DateTime.Now;
+                while (!stopWatchdog)
+                {
+                    EthercatState = IOLocked(()=>ECMBind.ecmbind_read_state());
+                    if (EthercatState != ECSlaveState.OPERATIONAL)
+                        break;
+
+                    DateTime currentTime = DateTime.Now;
+                    nextControllerRun += TimeSpan.FromSeconds(Controller.ControllerLoopInterval);
+                    if (currentTime > nextControllerRun)
+                    {
+                        Logging.Log(LogLevel.WARNING, "missed controller cycle");
+                        while (currentTime > nextControllerRun)
+                            nextControllerRun += TimeSpan.FromSeconds(Controller.ControllerLoopInterval);
+                    }
+                    TimeSpan timeToNextCycle = nextControllerRun - currentTime;
+                    try
+                    {
+                        Thread.Sleep(timeToNextCycle);
+                        Controller.Cycle();
+                    } catch (Exception e)
+                    {
+                        Logging.Log(e);
+                    }
+                }
+
+            }
+
         }
 
-        void MasterThread()
+        void ProcessData()
         {
-            ExpectedWorkCounter = ECMBind.ecmbind_get_expected_wkc_size();
+            int wkc;
 
-            while (!stopProcessing)
+            lock (lockIOMap)
+                ExpectedWorkCounter = ECMBind.ecmbind_get_expected_wkc_size();
+
+            Logging.Log(LogLevel.INFO, "ECMaster: ProcessData(): start");
+
+            while (!stopProcessData)
             {
-                int wkc;
-
                 lock (lockIOMap)
                 {
                     wkc = ECMBind.ecmbind_processdata2(iomap, iomap.Length);
@@ -187,26 +259,160 @@ namespace ln.ethercat
                     {
                         int success = ECMBind.ecmbind_recover();
                         if (success > 0)
-                            ExpectedWorkCounter = success;
-                        else
                         {
-                            RequestSlaveState(0, ECSlaveState.SAFE_OP);
+                            Logging.Log(LogLevel.ERROR, "ECMaster: bus recovery successfull...");
+                            ExpectedWorkCounter = success;
+                            //SetupPDOMapping();
+                        } else
+                        {
+                            RequestSlaveState(0, ECSlaveState.INIT);
+                            Logging.Log(LogLevel.ERROR, "ECMaster: bus recovery failed, scheduling restart...");
+                            ScheduleRestart();
+                            stopProcessData = true;
                         }
                     }
                 }
                 Thread.Sleep(INTERVALL_PROCESSDATA);
+            }
 
-/*
-                if (wkc != ExpectedWorkCounter)
+            Logging.Log(LogLevel.INFO, "ECMaster: ProcessData(): finished");
+        }
+
+        public void ScanControllers()
+        {
+            driveControllers.Clear();
+
+            for (UInt16 slave_id = 1; slave_id <= CountSlaves; slave_id++)
+            {
+                if (ReadSDO(slave_id, 0x1000, 0, out byte[] bDeviceType))
                 {
-                    ExpectedWorkCounter = ECMBind.ecmbind_recover();
-                    if (ExpectedWorkCounter < 0)
-                        break;
-                }
-*/
+                    ushort profilecode = BitConverter.ToUInt16(bDeviceType);
+                    Logging.Log(LogLevel.INFO, "ECMaster: ScanControllers: Slave {0} has DeviceType {1} [{2}]", slave_id, profilecode, bDeviceType.ToHexString());
 
+                    switch (profilecode)
+                    {
+                        case 402:
+                            driveControllers.Add(new CIA402Controller(this, slave_id));
+                            break;
+                    }
+                }
             }
         }
+
+
+        bool WaitForState(ECSlaveState expectedState, int timeout)
+        {
+            int waitIncrement = 100;
+
+            ECSlaveState currentState = IOLocked(()=>ECMBind.ecmbind_read_state());
+            while ((timeout > 0) && (currentState != expectedState))
+            {
+                Thread.Sleep(waitIncrement);
+                timeout -= waitIncrement;
+                currentState = IOLocked(()=>ECMBind.ecmbind_read_state());
+            }
+            return currentState == expectedState;
+        }
+
+
+
+        object lockIOMap = new object();
+        byte[] iomap = new byte[8192];
+
+        void SetupPDOMapping()
+        {
+                IOMapSize = ECMBind.ecmbind_config_map();
+                Logging.Log(LogLevel.DEBUG, "ECMaster: IOMapSize={0}", IOMapSize);
+                //UpdatePDOMap();
+        }
+
+        HashSet<PDOMappingRequest> mappingRequests = new HashSet<PDOMappingRequest>();
+
+        public void ConfigureProcessDataMappings()
+        {
+            Logging.Log(LogLevel.INFO, "configure PDO mappings");
+
+            for (UInt16 slave = 1; slave <= CountSlaves; slave++)
+            {
+                List<int> rxPDOs = new List<int>();
+                List<int> txPDOs = new List<int>();
+
+                foreach (PDOMappingRequest mappingRequest in mappingRequests)
+                {
+                    if (mappingRequest.Slave == slave)
+                    {
+                        if (GetSDOValue(mappingRequest.Slave, mappingRequest.Index, mappingRequest.SubIndex, out SDOValue sdoValue))
+                        {
+                            int mappingEntry = (mappingRequest.Index << 16) | (mappingRequest.SubIndex << 8) | sdoValue.BitLength;
+                            Logging.Log(LogLevel.DEBUG, "PDO mapping: {0:X8}", mappingEntry);
+                            
+                            if (mappingRequest.RxPDO)
+                                rxPDOs.Add(mappingEntry);
+                            else
+                                txPDOs.Add(mappingEntry);
+
+                        } else {
+                            Logging.Log(LogLevel.WARNING, "ECMaster: SetupProcessDataMappings(): could not retrieve SDOValue {0}:{1:X4}.{2}", mappingRequest.Slave, mappingRequest.Index, mappingRequest.SubIndex);
+                        }
+                    }
+                }
+
+                MemoryStream rxStream = new MemoryStream();
+                rxStream.WriteByte((byte)rxPDOs.Count);
+                rxStream.WriteByte(0);
+                foreach (int pdoMapping in rxPDOs)
+                    rxStream.WriteBytes(pdoMapping.GetBytes());
+
+                Logging.Log(LogLevel.DEBUG, "RxPDO mappings for slave {0} => {1}", slave, rxPDOs.Count);
+
+                if (!WriteSDOCA(slave, 0x1600, 0, rxStream.ToArray()))
+                {
+                    Logging.Log(LogLevel.WARNING, "ECMaster: SetupProcessDataMappings(): could not write RxPDO mappings for slave {0}", slave);
+                }
+
+                MemoryStream txStream = new MemoryStream();
+                txStream.WriteByte((byte)txPDOs.Count);
+                txStream.WriteByte(0);
+                foreach (int pdoMapping in txPDOs)
+                    txStream.WriteBytes(pdoMapping.GetBytes());
+
+                Logging.Log(LogLevel.DEBUG, "TxPDO mappings for slave {0} => {1}", slave, txPDOs.Count);
+
+                if (!WriteSDOCA(slave, 0x1A00, 0, txStream.ToArray()))
+                {
+                    Logging.Log(LogLevel.WARNING, "ECMaster: SetupProcessDataMappings(): could not write TxPDO mappings for slave {0}", slave);
+                }
+
+                if (!WriteSDOCA(slave, 0x1c12, 0, new byte[]{ 0x01, 0x00, 0x00, 0x16 }))
+                {
+                    Logging.Log(LogLevel.WARNING, "ECMaster: SetupProcessDataMappings(): could not configure syncmanager 2 PDO assignment for slave {0}", slave);
+                }
+                if (!WriteSDOCA(slave, 0x1c13, 0, new byte[]{ 0x01, 0x00, 0x00, 0x1A }))
+                {
+                    Logging.Log(LogLevel.WARNING, "ECMaster: SetupProcessDataMappings(): could not configure syncmanager 3 PDO assignment for slave {0}", slave);
+                }
+            }
+        }
+
+        public void RequestPDOMapping(UInt16 slave,UInt16 index,byte subIndex, bool RxPDO) => RequestPDOMapping(new PDOMappingRequest(slave,index,subIndex,RxPDO));
+        public void RequestPDOMapping(IEnumerable<PDOMappingRequest> mappingRequests) => RequestPDOMapping(mappingRequests.ToArray());
+        public void RequestPDOMapping(params PDOMappingRequest[] mappingRequests)
+        {
+            foreach (PDOMappingRequest mappingRequest in mappingRequests)
+                this.mappingRequests.Add(mappingRequest);
+        }
+
+
+        void ScheduleRestart()
+        {
+            ThreadPool.QueueUserWorkItem((o)=>{
+                Stop();
+                Thread.Sleep(500);
+                Start();
+            });
+        }
+
+
         
         public bool ReadSDO(UInt16 slave,UInt16 index, byte subIndex, out byte[] rawValue)
         {
@@ -220,7 +426,27 @@ namespace ln.ethercat
                     ECMBind.ecmbind_sdo_read(slave, index, subIndex, rawValue, rawValue.Length );
                 if (dataSize <= 0)
                 {
-                    Logging.Log(LogLevel.ERROR, "ECMBind.ecmbind_sdo_read({0},{1},{2},..,{3}) == {4}", slave, index, subIndex, rawValue.Length, rawValue.ToHexString());
+                    Logging.Log(LogLevel.ERROR, "ECMBind.ecmbind_sdo_read({0},{1},{2},..,{3}) [{5}] == {4}", slave, index, subIndex, rawValue.Length, rawValue.ToHexString(), dataSize);
+                    throw new IOException();
+                }
+            }
+            rawValue = rawValue.Slice(0, dataSize);
+            return true;
+        }
+
+        public bool ReadSDOCA(UInt16 slave,UInt16 index, byte subIndex, out byte[] rawValue)
+        {
+            rawValue =
+                new byte[128];
+            int dataSize;
+
+            lock (lockIOMap)
+            {
+                dataSize =
+                    ECMBind.ecmbind_sdo_read_ca(slave, index, subIndex, rawValue, rawValue.Length );
+                if (dataSize <= 0)
+                {
+                    Logging.Log(LogLevel.ERROR, "ECMBind.ecmbind_sdo_read_ca({0},{1},{2},..,{3}) == {4}", slave, index, subIndex, rawValue.Length, rawValue.ToHexString());
                     throw new IOException();
                 }
             }
@@ -233,41 +459,20 @@ namespace ln.ethercat
             int result;
             lock (lockIOMap)
                 result = ECMBind.ecmbind_sdo_write(slave, index, subIndex, rawValue, rawValue.Length);
-            Logging.Log(LogLevel.DEBUG, "ECMaster: WriteSDO({0},{1},{2},{3}) => {4}", slave, index, subIndex, rawValue.ToHexString(), result);
+            //Logging.Log(LogLevel.DEBUG, "ECMaster: WriteSDO({0},{1},{2},{3}) => {4}", slave, index, subIndex, rawValue.ToHexString(), result);
+            return result > 0;
+        }
+        public bool WriteSDOCA(UInt16 slave,UInt16 index, byte subIndex, byte[] rawValue)
+        {
+            int result;
+            lock (lockIOMap)
+                result = ECMBind.ecmbind_sdo_write_ca(slave, index, subIndex, rawValue, rawValue.Length);
+            //Logging.Log(LogLevel.DEBUG, "ECMaster: WriteSDOCA({0},{1},{2},{3}) => {4}", slave, index, subIndex, rawValue.ToHexString(), result);
             return result > 0;
         }
 
-        public ECSlaveState ReadSlaveState(int slave) => ECMBind.ecmbind_get_slave_state(slave);
-
-        private ECSlaveState UpdateEthercatState()
-        {
-            EthercatState = ECMBind.ecmbind_read_state();
-            return ethercatState;
-        }
-
-        public bool CheckState(ECSlaveState minimumState, int timeout)
-        {
-            for (; timeout > 0; timeout -= 10)
-            {
-                ECSlaveState state = ECMBind.ecmbind_read_state();
-                if (state >= minimumState)
-                {
-                    EthercatState = state;
-                    return true;
-                }
-                Thread.Sleep(10);
-            }
-            return false;
-        }
-        public bool RequestState(ECSlaveState requestedState, out ECSlaveState reachedState, int timeout)
-        {
-            reachedState = ECMBind.ecmbind_request_state(0, requestedState, timeout);
-            Logging.Log(LogLevel.DEBUG, "ECMaster.RequestState({1}): lowest slave state: {0}", reachedState, requestedState);
-            EthercatState = reachedState;
-            return (reachedState >= requestedState);
-        }
-
-        public int RequestSlaveState(int slave, ECSlaveState slaveState) => ECMBind.ecmbind_write_slave_state(slave, slaveState);        
+        public ECSlaveState ReadSlaveState(int slave) => IOLocked(()=>ECMBind.ecmbind_get_slave_state(slave));
+        int RequestSlaveState(int slave, ECSlaveState slaveState) => IOLocked(()=>ECMBind.ecmbind_write_slave_state(slave, slaveState));
 
 
         public bool GetSlave(UInt16 slave_id, out ECSlave slave)
@@ -297,6 +502,7 @@ namespace ln.ethercat
             if ((offset >= 0) && (length > 0) && (offset+length < iomap.Length))
             {
                 rawData = iomap.Slice(offset, length);
+                //Logging.Log(LogLevel.ERROR, "GetIOmapData({0},{1})", offset, length);
                 return true;
             }
             Logging.Log(LogLevel.ERROR, "GetIOmapData({0},{1}) failed", offset, length);
@@ -308,7 +514,7 @@ namespace ln.ethercat
             lock (lockIOMap)
             if ((offset >= 0) && (length > 0) && (offset+length < iomap.Length))
             {
-                Logging.Log(LogLevel.DEBUG, "ECMaster: SetIOmapData({0},{1},{2})", offset, length, rawData.ToHexString());
+                //Logging.Log(LogLevel.DEBUG, "ECMaster: SetIOmapData({0},{1},{2})", offset, length, rawData.ToHexString());
                 Buffer.BlockCopy(rawData, 0, iomap, offset, length);
                 return true;
             }
@@ -334,18 +540,19 @@ namespace ln.ethercat
         public void UpdatePDOMap()
         {
             List<PDO> pdoList = new List<PDO>();
-            ECMBind.ecmbind_pdo_enumerate((UInt16 slave, UInt16 index, byte subindex, int addr_offset, int addr_bit, int bitlength)=>{
-                if (addr_bit != 0)
-                    Logging.Log(LogLevel.WARNING, "currently only PDO mappings on byte boundaries are supported");
-                else
-                    pdoList.Add(new PDO(this,slave, index, subindex){
-                        AddressOffset = addr_offset,
-                        AddressBit = addr_bit,
-                        BitLength = bitlength
-                    });
+            lock (lockIOMap)
+                ECMBind.ecmbind_pdo_enumerate((UInt16 slave, UInt16 index, byte subindex, int addr_offset, int addr_bit, int bitlength)=>{
+            if (addr_bit != 0)
+                Logging.Log(LogLevel.WARNING, "currently only PDO mappings on byte boundaries are supported");
+            else
+                pdoList.Add(new PDO(this,slave, index, subindex){
+                    AddressOffset = addr_offset,
+                    AddressBit = addr_bit,
+                    BitLength = bitlength
+                });
             });
 
-            lock (this)
+            lock (lockIOMap)
             {
                 IOMapPtr = ECMBind.ecmbind_get_iomap();
                 pdoMap = pdoList;
diff --git a/ln.ethercat/ECSlave.cs b/ln.ethercat/ECSlave.cs
index 9341952..f0a0b05 100644
--- a/ln.ethercat/ECSlave.cs
+++ b/ln.ethercat/ECSlave.cs
@@ -58,7 +58,7 @@ namespace ln.ethercat
 
         public void Update()
         {
-                if (ECMBind.ecmbind_read_objectdescription(Slave.Id, Index, (int slave, int index, ECDataTypes dataType, ECObjectCodes objectCode, int maxsub, String name)=>{
+                if (ECMBind.ecmbind_read_objectdescription(Slave.Id, Index, (int slave, int index, ECDataTypes dataType, ECObjectCodes objectCode, int maxsub, ushort bitlength, String name)=>{
                     Name = name;
                     DataType = dataType;
                     ObjectCode = objectCode;
@@ -105,6 +105,7 @@ namespace ln.ethercat
     {
         public SDODescriptor Descriptor;
         public byte SubIndex { get; }
+        public ushort BitLength { get; private set; }
 
         public string Name { get; private set; }
         public ECDataTypes DataType { get; private set; }
@@ -114,13 +115,14 @@ namespace ln.ethercat
             Descriptor = descriptor;
             SubIndex = subIndex;
 
-            if (SubIndex == 0)
+            if ((Descriptor.MaxSubIndex > 0) && (SubIndex == 0))
             {
                 DataType = descriptor.DataType;
                 Name = descriptor.Name;
             } else {
-                if (ECMBind.ecmbind_read_objectdescription_entry(Descriptor.SlaveId, descriptor.Index, SubIndex, (int slave, int index, ECDataTypes dataType, ECObjectCodes objectCode, int si, String name)=>{
-                    Name = name;
+                if (ECMBind.ecmbind_read_objectdescription_entry(Descriptor.SlaveId, descriptor.Index, SubIndex, (int slave, int index, ECDataTypes dataType, ECObjectCodes objectCode, int si, ushort bitlength, String name)=>{
+                    Name = (SubIndex == 0) ? descriptor.Name : name;
+                    BitLength = bitlength;
                     DataType = dataType;
                 }) <= 0)
                 {
diff --git a/ln.ethercat/controller/Controller.cs b/ln.ethercat/controller/Controller.cs
index e044875..b9e82cc 100644
--- a/ln.ethercat/controller/Controller.cs
+++ b/ln.ethercat/controller/Controller.cs
@@ -1,4 +1,5 @@
 
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using ln.ethercat.controller.drives;
@@ -8,98 +9,225 @@ namespace ln.ethercat.controller
 {
 
     public delegate void ControllerLogicDelegate(Controller controller);
+    public delegate void ControllerStateChangeDelegate(Controller controller, ControllerStates newState);
+
+    public enum ControllerStates {
+        NONE,
+        NOTREADY,
+        FAULT,
+        READY,
+        DISABLING,
+        ENABLING,
+        OPERATIONAL
+    }
 
     public class Controller
     {
         public event ControllerLogicDelegate ControllerLogic;
+        public event ControllerStateChangeDelegate OnStateChanging;
+        public event ControllerStateChangeDelegate OnStateChanged;
 
+        public ECMaster ECMaster { get; }
 
-        List<DriveController> driveControllers = new List<DriveController>();
-        public DriveController[] DriveControllers => driveControllers.ToArray();
+        public bool IgnoreRemoteInterface { get; set; }
 
         List<ControlLoop> controlLoops = new List<ControlLoop>();
         public ControlLoop[] ControlLoops => controlLoops.ToArray();
 
-        public bool IsRunning => threadController?.IsAlive ?? false;
+        public ControllerStates ControllerState { get; private set; }
 
         public double ControllerLoopInterval { get; set; } = 0.1;
         public double ControllerLoopFrequency {
             get => 1.0 / ControllerLoopInterval;
             set => ControllerLoopInterval = 1.0 / value;
         }
+        public long CycleCounter { get; private set; }
 
-        bool stopRequested;
-        Thread threadController;
+        Thread threadWatchdog;
+        int wdogCounter;
+        public int WatchdogReset { get; set; } = 5;
 
-        public Controller()
+        public Controller(ECMaster ecMaster)
         {
+            ECMaster = ecMaster;
         }
 
-        public void Start()
-        {
-            if (threadController?.IsAlive ?? false)
-            {
-                Logging.Log(LogLevel.WARNING, "Controller; Start(): already started");
-            } else {
-                stopRequested = false;
-
-                foreach (DriveController driveController in driveControllers)
-                    driveController.Initialize();
-
-                threadController = new Thread(ControllerThread);
-                threadController.Start();
-            }
-        }
-
-        public void Stop()
-        {
-            if (threadController?.IsAlive ?? false)
-            {
-                stopRequested = true;
-                threadController.Join();
-                threadController = null;
-            }
-        }
-
-        public void Add(DriveController driveController) => driveControllers.Add(driveController);
-        public void Remove(DriveController driveController) => driveControllers.Remove(driveController);
-
         public void Add(ControlLoop controlLoop) => controlLoops.Add(controlLoop);
         public void Remove(ControlLoop controlLoop) => controlLoops.Remove(controlLoop);
 
-        public DriveStates DrivesState {
-            get {
-                DriveStates lowestState = DriveStates.OPERATIONAL;
-                foreach (DriveController driveController in driveControllers)
-                {
-                    DriveStates driveState = driveController.DriveState;
-                    if (driveState < lowestState)
-                        lowestState = driveState;
-                }
-                return lowestState;
-            }
-        }
-
-        void ControllerThread()
+        public void Initialize()
         {
-            while (!stopRequested)
+            CycleCounter = 0;
+
+            if (!(threadWatchdog?.IsAlive ?? false))
             {
-                foreach (DriveController driveController in driveControllers)
-                    driveController.UpdateStates();
+                threadWatchdog = new Thread(Watchdog);
+                threadWatchdog.Start();
+            }
 
-                foreach (ControlLoop controlLoop in controlLoops)
-                    controlLoop.Loop();
+            foreach (DriveController driveController in ECMaster.DriveControllers)
+                driveController.Initialize();
 
-                ControllerLogic?.Invoke(this);
+        }
 
-                foreach (DriveController driveController in driveControllers)
-                    driveController.UpdateDrive();
+        void UpdateControllerState()
+        {
+            ControllerStates nextState = ControllerStates.OPERATIONAL;
 
-                Thread.Sleep((int)(1000.0 * ControllerLoopInterval));
+            foreach (DriveController driveController in ECMaster.DriveControllers)
+            {
+                if (!driveController.IgnoredByController)
+                {
+                    ControllerStates driveState;
+                    switch (driveController.DriveState)
+                    {
+                        case DriveStates.OPERATIONAL:
+                            driveState = ControllerStates.OPERATIONAL;
+                            break;
+                        case DriveStates.ERROR:
+                            driveState = ControllerStates.FAULT;
+                            break;
+                        case DriveStates.INIT:
+                        case DriveStates.BOOT:
+                            driveState = ControllerStates.NOTREADY;
+                            break;
+                        default:
+                            driveState = ControllerStates.READY;
+                            break;
+                    }
+                    if (driveState < nextState)
+                        nextState = driveState;
+                }
+            }
+            ChangeState(nextState);
+        }
+
+        void ChangeState(ControllerStates newState)
+        {
+            if (newState == ControllerState)
+                return;
+
+            OnStateChanging?.Invoke(this, newState);
+
+            switch (newState)
+            {
+                case ControllerStates.FAULT:
+                    DisableDrives();
+                    break;
+                case ControllerStates.DISABLING:
+                    foreach (DriveController driveController in ECMaster.DriveControllers)
+                        driveController.DisableDrive();
+                    break;
+                case ControllerStates.ENABLING:
+                    foreach (DriveController driveController in ECMaster.DriveControllers)
+                        if (!driveController.IgnoredByController)
+                            driveController.EnableDrive();
+                    break;
+            }
+            
+            ControllerState = newState;
+            OnStateChanged?.Invoke(this, newState);
+        }
+
+        public void DisableDrives()
+        {
+            ChangeState(ControllerStates.DISABLING);
+        }
+
+        public void EnableDrives()
+        {
+            if (ControllerState == ControllerStates.READY)
+            {
+                ChangeState(ControllerStates.ENABLING);
+            } else {
+                Logging.Log(LogLevel.INFO, "Controller: EnableDrives(): Current ControllerState={0}. Refusing to enable drives", ControllerState.ToString());
+            }
+        }
+
+        public void ClearFaults()
+        {
+            foreach (DriveController driveController in ECMaster.DriveControllers)
+            {
+                if (driveController.DriveState == DriveStates.ERROR)
+                    driveController.ClearFault();
+            }
+        }
+
+        public void RemoteAction(CRActions action)
+        {
+            if (!IgnoreRemoteInterface)
+            {
+                switch (action)
+                {
+                    case CRActions.CLEARFAULT:
+                        ClearFaults();
+                        break;
+                    case CRActions.DISABLE:
+                        DisableDrives();
+                        break;
+                    case CRActions.ENABLE:
+                        EnableDrives();
+                        break;
+                }
+            }
+        }
+
+        public void RemoteUpdateTarget(int drive, double targetValue)
+        {
+            if (!IgnoreRemoteInterface)
+            {
+                targetValue = Math.Clamp(targetValue, 0, 1);
+
+                if (drive < 0)
+                    throw new ArgumentOutOfRangeException(nameof(targetValue));
+                if (drive > ECMaster.DriveControllers.Length)
+                {
+                    Logging.Log(LogLevel.WARNING, "Controller: RemoteUpdateTarget(): trying to update non-existent drive {0}", drive);
+                    return;
+                }
+
+                ECMaster.DriveControllers[drive].TargetValue = targetValue;
             }
         }
 
 
+        public void Cycle()
+        {
+            wdogCounter = WatchdogReset;
+            CycleCounter++;
+
+            foreach (DriveController driveController in ECMaster.DriveControllers)
+                driveController.UpdateStates();
+
+            UpdateControllerState();
+
+            foreach (ControlLoop controlLoop in controlLoops)
+                controlLoop.Loop();
+
+            ControllerLogic?.Invoke(this);
+
+            foreach (DriveController driveController in ECMaster.DriveControllers)
+                driveController.UpdateDrive();
+        }
+
+        void Watchdog()
+        {
+            while (true)
+            {
+                try
+                {
+                    Thread.Sleep(TimeSpan.FromSeconds(ControllerLoopInterval));
+                    if ((wdogCounter--) < 0)
+                    {
+                        ChangeState(ControllerStates.FAULT);
+                    }
+                } catch (Exception e)
+                {
+                    Logging.Log(e);
+                }
+            }
+
+        }
 
     }
 }
\ No newline at end of file
diff --git a/ln.ethercat/controller/ControllerRemote.cs b/ln.ethercat/controller/ControllerRemote.cs
new file mode 100644
index 0000000..7236748
--- /dev/null
+++ b/ln.ethercat/controller/ControllerRemote.cs
@@ -0,0 +1,105 @@
+
+
+using System;
+using System.Threading;
+using ln.ethercat.controller.drives;
+using ln.logging;
+
+namespace ln.ethercat.controller
+{
+    public enum CRActions {
+        NONE,           // No Action
+        ENABLE,         // Enable system (turn on)
+        DISABLE,        // Disable system (turn off)
+        CLEARFAULT,     // Clear fault state        
+    }
+
+    public abstract class ControllerRemote
+    {   
+        protected Controller Controller;
+
+        public double CycleIntervall { get; set; }
+        public double CycleFrequency {
+            get => 1.0 / CycleIntervall;
+            set => CycleIntervall = 1.0 / value;
+        }
+
+        public long CycleCounter { get; private set; }
+
+        public bool IsRunning => threadCycle?.IsAlive ?? false;
+
+        bool stopCycleThread;
+        Thread threadCycle;
+
+        public ControllerRemote(Controller controller)
+        {
+            Controller = controller;
+        }
+
+        public void Start()
+        {
+            lock (this)
+            {
+                if (threadCycle?.IsAlive ?? false)
+                    Stop();
+
+                threadCycle = new Thread(CycleThread);
+                threadCycle.Start();
+            }
+        }
+
+        public void Stop()
+        {
+            lock (this)
+            {
+                if (threadCycle?.IsAlive ?? false)
+                {
+                    stopCycleThread = true;
+                    threadCycle.Join(250);
+                    if (threadCycle.IsAlive)
+                        threadCycle.Abort();
+                    threadCycle = null;
+                }
+            }
+        }
+
+        public void SetTargetValue(int drive, double targetValue) => Controller.RemoteUpdateTarget( drive, targetValue );
+        public void Action(CRActions action) => Controller.RemoteAction(action);
+
+        protected abstract void Initialize();
+        protected abstract void Cycle();
+        protected abstract void Shutdown();
+
+        private void CycleThread()
+        {
+            CycleCounter = 0;
+            Initialize();
+
+            DateTime nextCycleRun = DateTime.Now;
+            while (!stopCycleThread)
+            {
+                DateTime currentTime = DateTime.Now;
+                nextCycleRun += TimeSpan.FromSeconds(CycleIntervall);
+                if (currentTime > nextCycleRun)
+                {
+                    Logging.Log(LogLevel.WARNING, "ControllerRemote: missed controller cycle");
+                    while (currentTime > nextCycleRun)
+                        nextCycleRun += TimeSpan.FromSeconds(CycleIntervall);
+                }
+                TimeSpan timeToNextCycle = nextCycleRun - currentTime;
+                try
+                {
+                    Thread.Sleep(timeToNextCycle);
+                    CycleCounter++;
+                    Cycle();
+                } catch (Exception e)
+                {
+                    Logging.Log(e);
+                }
+            }
+
+            Shutdown();
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/ln.ethercat/controller/drives/CIA402Controller.cs b/ln.ethercat/controller/drives/CIA402Controller.cs
index 43ed13e..cd9f04e 100644
--- a/ln.ethercat/controller/drives/CIA402Controller.cs
+++ b/ln.ethercat/controller/drives/CIA402Controller.cs
@@ -41,11 +41,30 @@ namespace ln.ethercat.controller.drives
         SDOValue svActualTorque;
         SDOValue svModesOfOperation;
         SDOValue svModesOfOperationDisplay;
+        SDOValue svActualCurrent;
 
+        SDOValue svMaxSpeed;
+
+        UInt32 MotorMaxSpeed = 1000;
         
         public CIA402Controller(ECMaster ecMaster,UInt16 slave)
         :base(ecMaster, slave)
         {
+            PDOMappingRequest[] mappingRequests = new PDOMappingRequest[]{
+                new PDOMappingRequest(slave, 0x603F, 0, false),
+                new PDOMappingRequest(slave, 0x6040, 0, true),
+                new PDOMappingRequest(slave, 0x6041, 0, false),
+                new PDOMappingRequest(slave, 0x607A, 0, true),
+                new PDOMappingRequest(slave, 0x60FF, 0, true),
+                new PDOMappingRequest(slave, 0x6071, 0, true),
+                new PDOMappingRequest(slave, 0x6064, 0, false),
+                new PDOMappingRequest(slave, 0x606C, 0, false),
+                new PDOMappingRequest(slave, 0x6077, 0, false),
+                new PDOMappingRequest(slave, 0x6060, 0, true),
+                new PDOMappingRequest(slave, 0x6061, 0, false),
+                new PDOMappingRequest(slave, 0x6078, 0, false)
+            };
+            ecMaster.RequestPDOMapping(mappingRequests);
         }
 
         public override void Initialize()
@@ -61,23 +80,82 @@ namespace ln.ethercat.controller.drives
                 ECMaster.GetSDOValue(Slave, 0x606C, 0, out svActualSpeed) &&
                 ECMaster.GetSDOValue(Slave, 0x6077, 0, out svActualTorque) &&
                 ECMaster.GetSDOValue(Slave, 0x6060, 0, out svModesOfOperation) &&
-                ECMaster.GetSDOValue(Slave, 0x6061, 0, out svModesOfOperationDisplay)
+                ECMaster.GetSDOValue(Slave, 0x6061, 0, out svModesOfOperationDisplay) &&
+                ECMaster.GetSDOValue(Slave, 0x6080, 0, out svMaxSpeed) &&
+                ECMaster.GetSDOValue(Slave, 0x6078, 0, out svActualCurrent)
             ))
                 throw new ArgumentOutOfRangeException("CIA402Controller could not retrieve SDOvalues for CiA402 profile");
         }
 
-        public override void UpdateStates() { }
-        public override void UpdateDrive() { }
+        public override void UpdateStates() {
+            CIA402State = GetCIA402State();
+        }
+        public override void UpdateDrive() {
+
+            if (CIA402State != CIA402TargetState)
+            {
+                switch (CIA402State)
+                {
+                    case CIA402States.NOT_READY_TO_SWITCH_ON:
+                        svControlWord.SetValue((ushort)0x0000);
+                        ModeOfOperation = CIA402ModesOfOperation.CYCLIC_SYNC_TORQUE;
+                        break;
+                    case CIA402States.SWITCH_ON_DISABLED:
+                        svControlWord.SetValue((ushort)0x0006);
+                        break;
+                    case CIA402States.READY_TO_SWITCH_ON:
+                        switch (CIA402TargetState)
+                        {
+                            case CIA402States.SWITCH_ON_DISABLED:
+                                svControlWord.SetValue((ushort)0x0000);
+                                break;
+                            case CIA402States.SWITCHED_ON:
+                            case CIA402States.OPERATION_ENABLED:
+                                svControlWord.SetValue((ushort)0x0007);
+                                break;
+                        }
+                        break;
+                    case CIA402States.SWITCHED_ON:
+                        switch (CIA402TargetState)
+                        {
+                            case CIA402States.SWITCH_ON_DISABLED:
+                            case CIA402States.READY_TO_SWITCH_ON:
+                                svControlWord.SetValue((ushort)0x0006);
+                                break;
+                            case CIA402States.OPERATION_ENABLED:
+                                svControlWord.SetValue((ushort)0x000F);
+                                break;
+                        }
+                        break;
+                    case CIA402States.OPERATION_ENABLED:
+                        switch (CIA402TargetState)
+                        {
+                            case CIA402States.SWITCH_ON_DISABLED:
+                            case CIA402States.READY_TO_SWITCH_ON:
+                                svControlWord.SetValue((ushort)0x0006);
+                                break;
+                            case CIA402States.SWITCHED_ON:
+                                svControlWord.SetValue((ushort)0x0007);
+                                break;
+                        }
+                        break;
+                }
+            }
+
+            if (DriveMode == DriveMode.UNDEFINED)
+                DriveMode = DriveMode.TORQUE;
+        }
 
         public override DriveStates DriveState 
         {
             get {
-                switch (GetCIA402State())
+                switch (CIA402State)
                 {
                     case CIA402States.NOT_READY_TO_SWITCH_ON:
+                        return DriveStates.INIT;
                     case CIA402States.SWITCH_ON_DISABLED:
                     case CIA402States.READY_TO_SWITCH_ON:
-                        return DriveStates.INIT;
+                        return DriveStates.READY;
                     case CIA402States.SWITCHED_ON:
                     case CIA402States.QUICK_STOP_ACTIVE:
                         return DriveStates.POWERED;
@@ -93,7 +171,7 @@ namespace ln.ethercat.controller.drives
         }
 
         public override string OEMDriveState {
-            get => GetCIA402State().ToString();
+            get => CIA402State.ToString();
         }
         public override string OEMDriveMode => ModeOfOperation.ToString();
 
@@ -135,26 +213,27 @@ namespace ln.ethercat.controller.drives
         public void SetDriveModeTorque() => DriveMode = DriveMode.TORQUE;
 
         public CIA402ModesOfOperation ModeOfOperation {
-            get => (CIA402ModesOfOperation)(svModesOfOperationDisplay.GetValue<sbyte>());
+            get => (ECMaster.EthercatState==ECSlaveState.OPERATIONAL) ? (CIA402ModesOfOperation)(svModesOfOperationDisplay?.GetValue<sbyte>() ?? 0) : CIA402ModesOfOperation.NO_MODE_CHANGE;
             set => svModesOfOperation.SetValue((sbyte)value);
         }
 
-        public override decimal ActualPosition => svActualPosition.GetValue<int>();
-        public override decimal ActualSpeed => svActualSpeed.GetValue<int>();
-        public override decimal ActualTorque => svActualTorque.GetValue<short>();
+        public override double ActualPosition => (svActualPosition?.GetValue<int>() ?? 0) ;
+        public override double ActualSpeed => (double)(svActualSpeed?.GetValue<int>() ?? 0) / (1000.0 * MotorMaxSpeed);
+        public override double ActualTorque => (double)(svActualTorque?.GetValue<short>() ?? 0)  / 1000.0;
+        public override double ActualLoad => (double)(svActualCurrent?.GetValue<short>() ?? 0)  / 1000.0;
 
-        public override decimal TargetPosition {
+        public override double TargetPosition {
             get => svTargetPosition.GetValue<int>();
             set => svTargetPosition.SetValue((int)value);
         }
 
-        public override decimal TargetSpeed {
-            get => svTargetSpeed.GetValue<int>();
-            set => svTargetSpeed.SetValue((int)value);
+        public override double TargetSpeed {
+            get => (double)svTargetSpeed.GetValue<int>() / (1000.0 * MotorMaxSpeed);
+            set => svTargetSpeed.SetValue((int)(value * (1000.0 * MotorMaxSpeed)));
         }
-        public override decimal TargetTorque {
-            get => svTargetTorque.GetValue<short>();
-            set => svTargetTorque.SetValue((short)value);
+        public override double TargetTorque {
+            get => (double)svTargetTorque.GetValue<short>() / 1000.0;
+            set => svTargetTorque.SetValue((short)(1000 * value));
         }
 
         public override int ErrorCode => svErrorCode.GetValue<int>();
@@ -163,51 +242,12 @@ namespace ln.ethercat.controller.drives
 
         public override void Enable(bool enable)
         {
-            if (enable)
-            {
-                switch (CIA402State)
-                {
-                    case CIA402States.SWITCHED_ON:
-                        svControlWord.SetValue((UInt16)0x000F);
-                        break;
-                    default:
-                        Logging.Log(LogLevel.WARNING, "CIA402Controller: EnableDrive(): current state is {0}, can't enable drive", CIA402State.ToString());
-                        break;
-                }
-            } else {
-                switch (CIA402State)
-                {
-                    case CIA402States.OPERATION_ENABLED:
-                        svControlWord.SetValue((UInt16)0x0007);
-                        break;
-                    default:
-                        Logging.Log(LogLevel.WARNING, "CIA402Controller: EnableDrive(): current state is {0}, can't disable drive", CIA402State.ToString());
-                        break;
-                }
-            }
+            CIA402TargetState = enable ? CIA402States.OPERATION_ENABLED : CIA402States.READY_TO_SWITCH_ON;
         }
 
         public override void Power(bool poweron)
         {
-            if (poweron)
-            {
-                switch (CIA402State)
-                {
-                    case CIA402States.FAULT:
-                    case CIA402States.FAULT_REACTION_ACTIVE:
-                        Logging.Log(LogLevel.WARNING, "CIA402Controller: Power(): Drive in fault state, not ready to switch power on");
-                        break;
-                    case CIA402States.NOT_READY_TO_SWITCH_ON:
-                        Logging.Log(LogLevel.WARNING, "CIA402Controller: Power(): Drive not ready to switch power on");
-                        break;
-                    case CIA402States.SWITCH_ON_DISABLED:    
-                    case CIA402States.READY_TO_SWITCH_ON:
-                        svControlWord.SetValue((UInt16)0x0007); // Switch ON
-                        break;
-                }
-            } else {
-                svControlWord.SetValue((UInt16)0x0006);
-            }
+            CIA402TargetState = poweron ? CIA402States.SWITCHED_ON : CIA402States.READY_TO_SWITCH_ON;
         }
 
         public override void ClearFault()
@@ -220,10 +260,12 @@ namespace ln.ethercat.controller.drives
             }
         }
 
-        CIA402States CIA402State => GetCIA402State();
+        public CIA402States CIA402State { get; private set; }
+        public CIA402States CIA402TargetState { get; private set; }
+
         public CIA402States GetCIA402State()
         {
-            UInt16 statusword = svStatusWord.GetValue<ushort>();
+            UInt16 statusword = svStatusWord?.GetValue<ushort>() ?? 0;
 
             if ((statusword & 0x004F)==0)
                 return CIA402States.NOT_READY_TO_SWITCH_ON;
diff --git a/ln.ethercat/controller/drives/DriveController.cs b/ln.ethercat/controller/drives/DriveController.cs
index 97120a8..427e8b8 100644
--- a/ln.ethercat/controller/drives/DriveController.cs
+++ b/ln.ethercat/controller/drives/DriveController.cs
@@ -1,6 +1,7 @@
 
 
 using System;
+using System.Net.Http.Headers;
 using System.Runtime;
 
 namespace ln.ethercat.controller.drives
@@ -9,6 +10,7 @@ namespace ln.ethercat.controller.drives
         UNDEFINED,
         BOOT,
         INIT,
+        READY,
         ERROR,
         POWERED,
         OPERATIONAL,
@@ -26,6 +28,9 @@ namespace ln.ethercat.controller.drives
         protected ECMaster ECMaster { get; }
         public UInt16 Slave { get; }
 
+        public bool IgnoredByController { get; set; }
+
+
         public DriveController(ECMaster ecMaster, UInt16 slave)
         {
             ECMaster = ecMaster;
@@ -57,13 +62,46 @@ namespace ln.ethercat.controller.drives
         public void DisableDrive() => Enable(false);
         public abstract void Enable(bool enabled);
 
-        public abstract decimal ActualPosition { get; }
-        public abstract decimal ActualSpeed { get; }
-        public abstract decimal ActualTorque { get; }
-        public abstract decimal TargetPosition { get; set; }
-        public abstract decimal TargetSpeed { get; set; }
-        public abstract decimal TargetTorque { get; set; }
+        public abstract double ActualPosition { get; }
+        public abstract double ActualSpeed { get; }
+        public abstract double ActualTorque { get; }
+        public abstract double TargetPosition { get; set; }
+        public abstract double TargetSpeed { get; set; }
+        public abstract double TargetTorque { get; set; }
+
+        public abstract double ActualLoad { get; }
                 
+        public virtual double TargetValue {
+            get {
+                switch (DriveMode)
+                {
+                    case DriveMode.POSITION:
+                        return TargetPosition;
+                    case DriveMode.SPEED:
+                        return TargetSpeed;
+                    case DriveMode.TORQUE:
+                        return TargetTorque;
+                    default:
+                        return 0;
+                }
+            }
+            set {
+                switch (DriveMode)
+                {
+                    case DriveMode.POSITION:
+                        TargetPosition = value;
+                        break;
+                    case DriveMode.SPEED:
+                        TargetSpeed = value;
+                        break;
+                    case DriveMode.TORQUE:
+                        TargetTorque = value;
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
 
     }
 
diff --git a/ln.ethercat/controller/remote/StupidSerialRemote.cs b/ln.ethercat/controller/remote/StupidSerialRemote.cs
new file mode 100644
index 0000000..977f23a
--- /dev/null
+++ b/ln.ethercat/controller/remote/StupidSerialRemote.cs
@@ -0,0 +1,171 @@
+
+
+using System;
+using System.IO.Ports;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using ln.logging;
+using ln.type;
+
+namespace ln.ethercat.controller.remote
+{
+    /*
+#define LED_ERROR		0x00
+#define LED_RUN			0x01
+#define LED_LOAD25		0x02
+#define LED_LOAD50		0x03
+#define LED_LOAD75		0x04
+#define LED_LOAD100		0x05
+#define LED_SERVICE		0x06
+#define LED_AUX			0x07
+*/
+
+    [Flags]
+    public enum StupidLEDs : int
+    {
+        NONE = 0,
+        ERROR = (1<<15),
+        RUN = (1<<1),
+        LOAD25 = (1<<2),
+        LOAD50 = (1<<3),
+        LOAD75 = (1<<4),
+        LOAD100 = (1<<15),
+        ALL = -1
+    }
+    public class StupidSerialRemote : ControllerRemote
+    {
+        public string SerialPortName { get; }
+
+        SerialPort serialPort;
+
+        bool stopReceiverThread;
+        Thread threadReceiver;
+
+        public StupidSerialRemote(Controller controller)
+            :this(controller, SerialPort.GetPortNames()[0]){}
+        public StupidSerialRemote(Controller controller, string serialDevice)
+            :base(controller)
+        {
+            SerialPortName = serialDevice;
+            CycleFrequency = 10.0;
+        }
+
+        protected override void Cycle()
+        {
+            byte cycleDisplayStep = (byte)(CycleCounter & 0x0F);
+
+            switch (Controller.ControllerState)
+            {
+                case ControllerStates.NOTREADY:
+                    SetLEDs(((cycleDisplayStep & 0x07) < 0x04) ? StupidLEDs.ALL : StupidLEDs.NONE);
+                    break;
+                case ControllerStates.FAULT:
+                    SetLEDs(((cycleDisplayStep & 0x07) < 0x04) ? StupidLEDs.ERROR : StupidLEDs.NONE);
+                    break;
+                case ControllerStates.READY:
+                    SetLEDs((cycleDisplayStep < 0x08) ? StupidLEDs.RUN : StupidLEDs.NONE);
+                    break;
+                case ControllerStates.OPERATIONAL:
+                    StupidLEDs leds = StupidLEDs.RUN;
+                    if (Controller.ECMaster.DriveControllers[0].ActualLoad >= 0.25)
+                        leds |= StupidLEDs.LOAD25;
+                    if (Controller.ECMaster.DriveControllers[0].ActualLoad >= 0.5)
+                        leds |= StupidLEDs.LOAD50;
+                    if (Controller.ECMaster.DriveControllers[0].ActualLoad >= 0.75)
+                        leds |= StupidLEDs.LOAD75;
+                    if (Controller.ECMaster.DriveControllers[0].ActualLoad >= 1)
+                        leds |= StupidLEDs.LOAD100;
+                    SetLEDs(leds);
+                    break;
+                case ControllerStates.ENABLING:
+                    break;
+                case ControllerStates.DISABLING:
+                    break;
+            }
+        }
+
+        void Receiver()
+        {
+            while (!stopReceiverThread)
+            {
+                string rxLine = serialPort.ReadLine();
+               //Logging.Log(LogLevel.DEBUGDETAIL, rxLine);
+               if (rxLine.Length >= 6)
+               {
+                    ushort av = ushort.Parse(rxLine.Substring(2,4), System.Globalization.NumberStyles.HexNumber);
+                    switch (rxLine[0])
+                    {
+                        case 'A':
+                            int drive = rxLine[1] - '0';
+                            if (drive == 0) drive = 1;
+                            else if (drive == 1) drive = 2;
+                            else if (drive == 2) drive = 0;
+                            double rel = (double)av / 65535;
+                            if ((drive >= 0) && (drive < Controller.ECMaster.DriveControllers.Length))
+                                Controller.RemoteUpdateTarget(drive, rel);
+                            break;
+                        case 'B':
+                            switch (rxLine[1])
+                            {
+                                case 'P':
+                                    switch (av)
+                                    {
+                                        case 0:
+                                            if (Controller.ControllerState == ControllerStates.FAULT)
+                                                Controller.RemoteAction(CRActions.CLEARFAULT);
+                                            else if (Controller.ControllerState == ControllerStates.READY)
+                                                Controller.RemoteAction(CRActions.ENABLE);
+                                            break;
+                                        case 1:
+                                            Controller.RemoteAction(CRActions.DISABLE);
+                                            break;
+                                        case 3:
+                                            // ToDo: Feeder left
+                                            break;
+                                        case 4:
+                                            // ToDo: Feeder right
+                                            break;
+                                        case 14:
+                                            // ToDo: cycle drilling
+                                            break;
+                                    }
+                                    break;
+                            }
+                            break;
+                    }
+               }
+            }
+        }
+
+        void SetLEDs(StupidLEDs leds)
+        {
+            serialPort.Write(string.Format("LS{0:X4}\r\n", (ushort)leds));
+        }
+
+
+        protected override void Initialize()
+        {
+            stopReceiverThread = false;
+
+            serialPort = new SerialPort(SerialPortName);
+            serialPort.BaudRate = 57600;
+            serialPort.Parity = Parity.None;
+            serialPort.DataBits = 8;
+            serialPort.StopBits = StopBits.One;
+            serialPort.Open();
+
+            if (!(threadReceiver?.IsAlive ?? false))
+            {
+                threadReceiver = new Thread(Receiver);
+                threadReceiver.Start();
+            }
+        }
+
+        protected override void Shutdown()
+        {
+            stopReceiverThread = true;
+            serialPort.Close();
+        }
+    }
+}
\ No newline at end of file
diff --git a/ln.ethercat/lib/libecmbind.so b/ln.ethercat/lib/libecmbind.so
index fcb653715dc2d845644c86909450fbdbb7f63527..512b1195fe32812fdc0d4cac81867e6afdf20068 100755
GIT binary patch
delta 32332
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
I_Ve)n10stezyJUM

delta 31923
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

diff --git a/ln.ethercat/ln.ethercat.csproj b/ln.ethercat/ln.ethercat.csproj
index 4a5a2af..8fe3848 100644
--- a/ln.ethercat/ln.ethercat.csproj
+++ b/ln.ethercat/ln.ethercat.csproj
@@ -16,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="System.IO.Ports" Version="5.0.0" />
     <PackageReference Include="ln.type" Version="0.1.7-ci" />
     <PackageReference Include="ln.logging" Version="1.0.2" />
     <PackageReference Include="ln.json" Version="1.0.6" />