WS2811StripController.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DirectOutput.General.Generic;
using System.Threading;

namespace DirectOutput.Cab.Out.AdressableLedStrip
{

    public class WS2811StripController : OutputControllerBase, ISupportsSetValues
    {
        #region ISupportsSetValues Member

        public void SetValues(int FirstOutput, byte[] Values)
        {
            if (FirstOutput >= LedData.Length) return;
            if (FirstOutput < 0) return;
            int CopyLength = (LedData.Length - FirstOutput).Limit(0, Values.Length);
            if (CopyLength < 1) return;

            lock (UpdateLocker)
            {
                Buffer.BlockCopy(Values, 0, LedData, FirstOutput, CopyLength);
                UpdateRequired = true;
            }
        }

        #endregion


        private byte[] LedData = new byte[0];

        private byte[] OutputLedData = new byte[0];


        private int _ControllerNumber = 1;

        public int ControllerNumber
        {
            get { return _ControllerNumber; }
            set { _ControllerNumber = value; }
        }


        private int _NumberOfLeds = 1;

        public int NumberOfLeds
        {
            get { return _NumberOfLeds; }
            set
            {
                _NumberOfLeds = value.Limit(0, 4006);
                LedData = new byte[_NumberOfLeds * 3];
                OutputLedData = new byte[_NumberOfLeds * 3];
            }
        }




        private object UpdateLocker = new object();
        private bool UpdateRequired = true;






        private readonly int[] ColNrLookup = { 1, 0, 2 };
        protected override void OnOutputValueChanged(IOutput Output)
        {
            if (Output is IOutputNumbered)
            {
                IOutputNumbered ON = (IOutputNumbered)Output;
                int ByteNr = ON.Number - 1;
                ByteNr = (ByteNr / 3) * 3 + ColNrLookup[ByteNr % 3];


                try
                {

                    lock (UpdateLocker)
                    {
                        if (LedData[ByteNr] != ON.Value)
                        {
                            LedData[ByteNr] = ON.Value;
                            UpdateRequired = true;
                        }

                    }
                }
                catch (Exception E)
                {
                    Log.Exception("WS2811StripController {0} with number {1} has received a update with a illegal or to high output number ({2}).".Build(Name, ControllerNumber, ON.Number), E);
                }
            }

        }


        private void AddOutputs()
        {
            for (int i = 1; i <= NumberOfLeds * 3; i++)
            {
                if (!Outputs.Any(x => ((LedStripOutput)x).Number == i))
                {
                    Outputs.Add(new LedStripOutput() { Name = "{0}.{1}".Build(Name, i), Number = i });
                }
            }
        }



        public override void Init(Cabinet Cabinet)
        {
            AddOutputs();

            InitUpdaterThread();
            Log.Write("WS2811StripController {0} with number {1} initialized and updaterthread started.".Build(Name, ControllerNumber));

        }

        public override void Finish()
        {
            FinishUpdaterThread();
            Log.Write("WS2811StripController {0} with number {1} finished and updaterthread stopped.".Build(Name, ControllerNumber));
        }

        public override void Update()
        {
            if (UpdateRequired)
            {
                UpdaterThreadSignal();
            }
        }



        #region UpdaterThread




        private void InitUpdaterThread()
        {

            if (!UpdaterThreadIsActive)
            {
                KeepUpdaterThreadAlive = true;
                try
                {
                    UpdaterThread = new Thread(UpdaterThreadDoIt);
                    UpdaterThread.Name = "WS2811StripController {0} named {1} updater thread ".Build(ControllerNumber, Name);
                    UpdaterThread.Start();
                }
                catch (Exception E)
                {
                    Log.Exception("WS2811StripController {0} named {1} updater thread could not start.".Build(ControllerNumber, Name), E);
                    throw new Exception("WS2811StripController {0} named {1} updater thread could not start.".Build(ControllerNumber, Name), E);
                }
            }
        }

        private void FinishUpdaterThread()
        {
            if (UpdaterThread != null)
            {
                try
                {
                    KeepUpdaterThreadAlive = false;
                    lock (UpdaterThreadLocker)
                    {
                        Monitor.Pulse(UpdaterThreadLocker);
                    }
                    if (!UpdaterThread.Join(1000))
                    {
                        UpdaterThread.Abort();
                    }
                    UpdaterThread = null;
                }
                catch (Exception E)
                {
                    Log.Exception("A error occured during termination of WS2811StripController updater thread.", E);
                    throw new Exception("A error occured during termination of WS2811StripController updater thread.", E);
                }
            }
        }


        public bool UpdaterThreadIsActive
        {
            get
            {
                if (UpdaterThread != null)
                {
                    if (UpdaterThread.IsAlive)
                    {
                        return true;
                    }
                }
                return false;
            }
        }

        private void UpdaterThreadSignal()
        {

            lock (UpdaterThreadLocker)
            {
                Monitor.Pulse(UpdaterThreadLocker);
            }
        }


        private Thread UpdaterThread { get; set; }
        private object UpdaterThreadLocker = new object();
        private bool KeepUpdaterThreadAlive = true;




        private WS2811StripControllerApi Controller = null;

        private void UpdaterThreadDoIt()
        {
            if (Controller == null)
            {
                Controller = new WS2811StripControllerApi(ControllerNumber);
                if (!Controller.DeviceIsPresent)
                {
                    Log.Warning("WS2811 Strip Controller Nr. {0} is not present. Will not send updates.".Build(ControllerNumber));
                    Controller = null;
                }
            }


            OutputLedData.Fill((byte)0);
            if (Controller != null)
            {
                Controller.SetAndDisplayData(OutputLedData);
            }
            while (KeepUpdaterThreadAlive)
            {

                if (UpdateRequired)
                {
                    lock (UpdateLocker)
                    {
                        UpdateRequired = false;

                        Buffer.BlockCopy(LedData, 0, OutputLedData, 0, LedData.Length);
                    }

                    if (Controller != null)
                    {

                        Controller.SetAndDisplayData(OutputLedData);
                    }
                }

                if (KeepUpdaterThreadAlive)
                {
                    lock (UpdaterThreadLocker)
                    {
                        while (UpdateRequired == false && KeepUpdaterThreadAlive)
                        {
                            Monitor.Wait(UpdaterThreadLocker, 50);  // Lock is released while we’re waiting
                        }
                    }
                }

            }

            OutputLedData.Fill((byte)0);
            if (Controller != null)
            {
                Controller.SetAndDisplayData(OutputLedData);

                Controller.Close();
            }
            Controller = null;

        }
        #endregion

        public WS2811StripController()
        {
            Outputs = new OutputList();
        }


    }
}