LedWiz.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;


namespace DirectOutput.Cab.Out.LW
{
    public class LedWiz : OutputControllerBase, IOutputController, IDisposable
    {
        #region Number


        private object NumberUpdateLocker = new object();
        private int _Number = -1;

        public int Number
        {
            get { return _Number; }
            set
            {
                if (!value.IsBetween(1, 16))
                {
                    throw new Exception("LedWiz Numbers must be between 1-16. The supplied number {0} is out of range.".Build(value));
                }
                lock (NumberUpdateLocker)
                {
                    if (_Number != value)
                    {

                        if (Name.IsNullOrWhiteSpace() || Name == "LedWiz {0:00}".Build(_Number))
                        {
                            Name = "LedWiz {0:00}".Build(value);
                        }

                        _Number = value;

                    }
                }
            }
        }

        #endregion


        private int _MinCommandIntervalMs = 1;
        private bool MinCommandIntervalMsSet = false;
        public int MinCommandIntervalMs
        {
            get { return _MinCommandIntervalMs; }
            set
            {
                _MinCommandIntervalMs = value.Limit(0, 1000);
                MinCommandIntervalMsSet = true;
            }
        }




        #region IOutputcontroller implementation
        public override void Update()
        {
            LedWizUnits[Number].TriggerLedWizUpdaterThread();
        }


        public override void Init(Cabinet Cabinet)
        {
            Log.Debug("Initializing LedWiz Nr. {0:00}".Build(Number));
            AddOutputs();
            if (!MinCommandIntervalMsSet && Cabinet.Owner.ConfigurationSettings.ContainsKey("LedWizDefaultMinCommandIntervalMs") && Cabinet.Owner.ConfigurationSettings["LedWizDefaultMinCommandIntervalMs"] is int)
            {
                MinCommandIntervalMs = (int)Cabinet.Owner.ConfigurationSettings["LedWizDefaultMinCommandIntervalMs"];
            }

            LedWizUnits[Number].Init(Cabinet, MinCommandIntervalMs);

            Log.Write("LedWiz Nr. {0:00} initialized and updater thread initialized.".Build(Number));

        }

        public override void Finish()
        {
            Log.Debug("Finishing LedWiz Nr. {0:00}".Build(Number));
            LedWizUnits[Number].Finish();
            LedWizUnits[Number].ShutdownLighting();
            Log.Write("LedWiz Nr. {0:00} finished and updater thread stopped.".Build(Number));

        }
        #endregion



        #region Outputs



        private void AddOutputs()
        {
            for (int i = 1; i <= 32; i++)
            {
                if (!Outputs.Any(x => ((LedWizOutput)x).LedWizOutputNumber == i))
                {
                    Outputs.Add(new LedWizOutput(i) { Name = "{0}.{1:00}".Build(Name, i) });
                }
            }
        }


        protected override void OnOutputValueChanged(IOutput Output)
        {
            if (!(Output is LedWizOutput))
            {
                throw new Exception("The OutputValueChanged event handler for LedWiz {0:00} has been called by a sender which is not a LedWizOutput.".Build(Number));
            }
            LedWizOutput LWO = (LedWizOutput)Output;

            if (!LWO.LedWizOutputNumber.IsBetween(1, 32))
            {
                throw new Exception("LedWiz output numbers must be in the range of 1-32. The supplied output number {0} is out of range.".Build(LWO.LedWizOutputNumber));
            }

            LedWizUnit S = LedWizUnits[this.Number];
            S.UpdateValue(LWO);
        }



        //private void OutputValueChanged(object sender, OutputEventArgs e)
        //{

        //    if (!(e.Output is LedWizOutput))
        //    {
        //        throw new Exception("The OutputValueChanged event handler for LedWiz {0:00} has been called by a sender which is not a LedWizOutput.".Build(Number));
        //    }
        //    LedWizOutput LWO = (LedWizOutput)e.Output;

        //    if (!LWO.LedWizOutputNumber.IsBetween(1, 32))
        //    {
        //        throw new Exception("LedWiz output numbers must be in the range of 1-32. The supplied output number {0} is out of range.".Build(LWO.LedWizOutputNumber));
        //    }

        //    LedWizUnit S = LedWizUnits[this.Number];
        //    S.UpdateValue(LWO);
        //}
        #endregion



        #region LEDWIZ Static Private Methods & Properties
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct LWZDEVICELIST
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = LWZ_MAX_DEVICES)]
            public uint[] handles;
            public int numdevices;
        }

        [DllImport("LEDWiz", CallingConvention = CallingConvention.Cdecl)]
        private extern static void LWZ_SBA(uint device, uint bank0, uint bank1, uint bank2, uint bank3, uint globalPulseSpeed);

        [DllImport("LEDWiz", CallingConvention = CallingConvention.Cdecl)]
        private extern static void LWZ_PBA(uint device, uint brightness);

        [DllImport("LEDWiz", CallingConvention = CallingConvention.Cdecl)]
        private extern static void LWZ_REGISTER(uint h, uint hwnd);

        [DllImport("LEDWiz", CallingConvention = CallingConvention.Cdecl)]
        private extern static void LWZ_SET_NOTIFY(MulticastDelegate notifyProc, uint list);

        private delegate void NotifyDelegate(int reason, uint newDevice);

        private static IntPtr MainWindow = IntPtr.Zero;

        private static LWZDEVICELIST deviceList;

        private const int LWZ_MAX_DEVICES = 16;
        private const int LWZ_ADD = 1;
        private const int LWZ_DELETE = 2;

        private enum AutoPulseMode : int
        {
            RampUpRampDown = 129,    // /\/\
            OnOff = 130,      // _|-|_|-|
            OnRampDown = 131,     // -\|-\
            RampUpDown = 132     // /-|/-
        }



        private static void Notify(int reason, uint newDevice)
        {
            //TODO: Ledwizverhalten bei add und remove im laufenden betrieb prüfen
            if (reason == LWZ_ADD)
            {
                LWZ_REGISTER(newDevice, (uint)MainWindow.ToInt32());
            }
            if (reason == LWZ_DELETE)
            {
            }
        }



        private static int NumDevices
        {
            get { return deviceList.numdevices; }
        }

        private static uint[] DeviceHandles
        {
            get { return deviceList.handles; }
        }

        private static int StartedUp = 0;
        private static object StartupLocker = new object();
        private static void StartupLedWiz()
        {
            lock (StartupLocker)
            {
                if (StartedUp == 0)
                {
                    MainWindow = IntPtr.Zero;
                    deviceList.handles = new uint[LWZ_MAX_DEVICES] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                    deviceList.numdevices = 0;
                    try
                    {
                        NotifyDelegate del = new NotifyDelegate(Notify);

                        IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(LWZDEVICELIST)));
                        Marshal.StructureToPtr(deviceList, ptr, true);
                        LWZ_SET_NOTIFY(del, (uint)ptr.ToInt32());
                        deviceList = (LWZDEVICELIST)Marshal.PtrToStructure(ptr, typeof(LWZDEVICELIST));
                        Marshal.FreeCoTaskMem(ptr);
                        Log.Debug("Ledwiz devicelist content. Handles: {0}, Num devices: {1}".Build(string.Join(", ", deviceList.handles.Select(H => H.ToString())), deviceList.numdevices));
                    }
                    catch (Exception ex)
                    {
                        Log.Exception("Could not init LedWiz", ex);
                        throw new Exception("Could not init LedWiz", ex);
                    }

                }
                StartedUp++;
            }
        }

        private static void TerminateLedWiz()
        {
            lock (StartupLocker)
            {

                if (StartedUp > 0)
                {
                    StartedUp--;
                    if (StartedUp == 0)
                    {
                        foreach (LedWizUnit S in LedWizUnits.Values)
                        {
                            S.ShutdownLighting();
                        }
                        LWZ_SET_NOTIFY((System.MulticastDelegate)null, 0);
                    }
                }
            }
        }
        #endregion


        public static List<int> GetLedwizNumbers()
        {
            List<int> L = new List<int>();

            LedWiz LW = new LedWiz();
            for (int i = 0; i < LedWiz.NumDevices; i++)
            {
                L.Add((int)LedWiz.DeviceHandles[i]);
            }
            LW.Dispose();
            return L;
        }



        ~LedWiz()
        {

            Dispose(false);
        }

        #region Dispose



        public void Dispose()
        {

            Dispose(true);
            GC.SuppressFinalize(this); // remove this from gc finalizer list
        }
        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (!this.disposed)
            {
                try
                {
                    Log.Debug("Disposing LedWiz instance {0:00}.".Build(Number));
                }
                catch
                {
                }
                // If disposing equals true, dispose all managed
                // and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.

                }

                // Call the appropriate methods to clean up
                // unmanaged resources here.
                // If disposing is false,
                // only the following code is executed.

                TerminateLedWiz();


                // Note disposing has been done.
                disposed = true;

            }
        }
        private bool disposed = false;

        #endregion



        #region Constructor


        static LedWiz()
        {
            LedWizUnits = new Dictionary<int, LedWizUnit>();
            for (int i = 1; i <= 16; i++)
            {
                LedWizUnits.Add(i, new LedWizUnit(i));
            }
        }

        public LedWiz()
        {
            StartupLedWiz();

            Outputs = new OutputList();


        }



        public LedWiz(int Number)
            : this()
        {
            this.Number = Number;
        }

        #endregion






        #region Internal class for LedWiz output states and update methods

        private static Dictionary<int, LedWizUnit> LedWizUnits = new Dictionary<int, LedWizUnit>();

        private class LedWizUnit
        {
            //  private Pinball Pinball;


            //Used to convert the 0-255 range of output values to LedWiz values in the range of 0-48.
            //            private static readonly byte[] ByteToLedWizValue = { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 48, 48, 48, 48, 48 };

            private static readonly byte[] ByteToLedWizValue = { 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 48, 48, 48, 48, 48, 49 };
            private const int MaxUpdateFailCount = 5;


            public int Number { get; private set; }

            public byte[] NewOutputValues = new byte[32] { 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49 };
            public byte[] CurrentOuputValues = new byte[32];
            public byte[] NewAfterValueSwitches = new byte[4];
            public byte[] NewBeforeValueSwitches = new byte[4];
            public byte[] CurrentAfterValueSwitches = new byte[4];
            public byte[] CurrentBeforeValueSwitches = new byte[4];
            public bool NewValueUpdateRequired = true;
            public bool NewSwitchUpdateBeforeValueUpdateRequired = true;
            public bool NewSwitchUpdateAfterValueUpdateRequired = true;

            public bool CurrentValueUpdateRequired = true;
            public bool CurrentSwitchUpdateBeforeValueUpdateRequired = true;
            public bool CurrentSwitchUpdateAfterValueUpdateRequired = true;
            public bool UpdateRequired = true;

            public object LedWizUpdateLocker = new object();
            public object ValueChangeLocker = new object();

            public Thread LedWizUpdater;
            public bool KeepLedWizUpdaterAlive = false;
            public object LedWizUpdaterThreadLocker = new object();


            public void Init(Cabinet Cabinet, int MinCommandIntervalMs)
            {
                //this.Pinball = Cabinet.Pinball;
                //if (!Pinball.TimeSpanStatistics.Contains("LedWiz {0:00} update calls".Build(Number)))
                //{
                //    UpdateTimeStatistics = new TimeSpanStatisticsItem() { Name = "LedWiz {0:00} update calls".Build(Number), GroupName = "OutputControllers - LedWiz" };
                //    Pinball.TimeSpanStatistics.Add(UpdateTimeStatistics);
                //}
                //else
                //{
                //    UpdateTimeStatistics = Pinball.TimeSpanStatistics["LedWiz {0:00} update calls".Build(Number)];
                //}
                //if (!Pinball.TimeSpanStatistics.Contains("LedWiz {0:00} PWM updates".Build(Number)))
                //{
                //    PWMUpdateTimeStatistics = new TimeSpanStatisticsItem() { Name = "LedWiz {0:00} PWM updates".Build(Number), GroupName = "OutputControllers - LedWiz" };
                //    Pinball.TimeSpanStatistics.Add(PWMUpdateTimeStatistics);
                //}
                //else
                //{
                //    PWMUpdateTimeStatistics = Pinball.TimeSpanStatistics["LedWiz {0:00} PWM updates".Build(Number)];
                //}
                //if (!Pinball.TimeSpanStatistics.Contains("LedWiz {0:00} OnOff updates".Build(Number)))
                //{
                //    OnOffUpdateTimeStatistics = new TimeSpanStatisticsItem() { Name = "LedWiz {0:00} OnOff updates".Build(Number), GroupName = "OutputControllers - LedWiz" };
                //    Pinball.TimeSpanStatistics.Add(OnOffUpdateTimeStatistics);
                //}
                //else
                //{
                //    OnOffUpdateTimeStatistics = Pinball.TimeSpanStatistics["LedWiz {0:00} OnOff updates".Build(Number)];
                //}
                this.MinCommandIntervalMs = MinCommandIntervalMs;
                StartLedWizUpdaterThread();
            }

            public void Finish()
            {

                TerminateLedWizUpdaterThread();
                ShutdownLighting();
                //this.Pinball = null;

            }

            public void UpdateValue(LedWizOutput LedWizOutput)
            {
                byte V = ByteToLedWizValue[LedWizOutput.Value];
                bool S = (V != 0);

                int ZeroBasedOutputNumber = LedWizOutput.LedWizOutputNumber - 1;

                int ByteNr = ZeroBasedOutputNumber >> 3;
                int BitNr = ZeroBasedOutputNumber & 7;

                byte Mask = (byte)(1 << BitNr);

                lock (ValueChangeLocker)
                {
                    if (S != ((NewAfterValueSwitches[ByteNr] & Mask) != 0))
                    {
                        //Neeed to adjust switches
                        if (S == false)
                        {
                            //Output will be turned off
                            Mask = (byte)~Mask;
                            NewAfterValueSwitches[ByteNr] &= Mask;
                            NewBeforeValueSwitches[ByteNr] &= Mask;
                            NewSwitchUpdateBeforeValueUpdateRequired = true;
                            UpdateRequired = true;
                        }
                        else
                        {
                            //Output will be turned on
                            if (V != NewOutputValues[ZeroBasedOutputNumber])
                            {
                                //Need to change value before turing on
                                NewOutputValues[ZeroBasedOutputNumber] = V;
                                NewAfterValueSwitches[ByteNr] |= Mask;
                                NewValueUpdateRequired = true;
                                NewSwitchUpdateAfterValueUpdateRequired = true;
                                UpdateRequired = true;
                            }
                            else
                            {
                                //Value is correct, only need to turn on switch
                                NewAfterValueSwitches[ByteNr] |= Mask;
                                NewBeforeValueSwitches[ByteNr] |= Mask;
                                NewSwitchUpdateBeforeValueUpdateRequired = true;
                                UpdateRequired = true;
                            }
                        }
                    }
                    else
                    {
                        if (S == true && V != NewOutputValues[ZeroBasedOutputNumber])
                        {
                            //Only need to adjust value
                            NewOutputValues[ZeroBasedOutputNumber] = V;
                            NewValueUpdateRequired = true;
                            UpdateRequired = true;
                        }

                    }
                }
            }
            public void CopyNewToCurrent()
            {
                lock (ValueChangeLocker)
                {

                    CurrentValueUpdateRequired = NewValueUpdateRequired;
                    CurrentSwitchUpdateBeforeValueUpdateRequired = NewSwitchUpdateBeforeValueUpdateRequired;
                    CurrentSwitchUpdateAfterValueUpdateRequired = NewSwitchUpdateAfterValueUpdateRequired;


                    if (NewValueUpdateRequired)
                    {
                        Array.Copy(NewOutputValues, CurrentOuputValues, NewOutputValues.Length);
                        NewValueUpdateRequired = false;
                    }
                    if (NewSwitchUpdateAfterValueUpdateRequired || NewSwitchUpdateBeforeValueUpdateRequired)
                    {
                        Array.Copy(NewAfterValueSwitches, CurrentAfterValueSwitches, NewAfterValueSwitches.Length);
                        Array.Copy(NewBeforeValueSwitches, CurrentBeforeValueSwitches, NewBeforeValueSwitches.Length);
                        Array.Copy(CurrentAfterValueSwitches, NewBeforeValueSwitches, NewAfterValueSwitches.Length);
                        NewSwitchUpdateAfterValueUpdateRequired = false;
                        NewSwitchUpdateBeforeValueUpdateRequired = false;
                    }



                }
            }

            public bool IsUpdaterThreadAlive
            {
                get
                {
                    if (LedWizUpdater != null)
                    {
                        return LedWizUpdater.IsAlive;
                    }
                    return false;
                }
            }

            public void StartLedWizUpdaterThread()
            {
                lock (LedWizUpdaterThreadLocker)
                {
                    if (!IsUpdaterThreadAlive)
                    {
                        KeepLedWizUpdaterAlive = true;
                        LedWizUpdater = new Thread(LedWizUpdaterDoIt);
                        LedWizUpdater.Name = "LedWiz {0:00} updater thread".Build(Number);
                        LedWizUpdater.Start();
                    }
                }
            }
            public void TerminateLedWizUpdaterThread()
            {
                //  lock (LedWizUpdaterThreadLocker)
                //  {
                if (LedWizUpdater != null)
                {
                    try
                    {
                        KeepLedWizUpdaterAlive = false;
                        TriggerLedWizUpdaterThread();
                        if (!LedWizUpdater.Join(1000))
                        {
                            LedWizUpdater.Abort();
                        }

                    }
                    catch (Exception E)
                    {
                        Log.Exception("A error occurd during termination of {0}.".Build(LedWizUpdater.Name), E);
                        throw new Exception("A error occurd during termination of {0}.".Build(LedWizUpdater.Name), E);
                    }
                    LedWizUpdater = null;
                }
                // }
            }

            bool TriggerUpdate = false;
            public void TriggerLedWizUpdaterThread()
            {
                TriggerUpdate = true;
                lock (LedWizUpdaterThreadLocker)
                {
                    Monitor.Pulse(LedWizUpdaterThreadLocker);
                }
            }


            //TODO: Check if thread should really terminate on failed updates
            private void LedWizUpdaterDoIt()
            {
                Log.Write("Updater thread for LedWiz {0:00} started.".Build(Number));
                //Pinball.ThreadInfoList.HeartBeat("LedWiz {0:00}".Build(Number));


                int FailCnt = 0;
                while (KeepLedWizUpdaterAlive)
                {
                    try
                    {
                        if (IsPresent)
                        {

                            SendLedWizUpdate();

                        }
                        FailCnt = 0;
                    }
                    catch (Exception E)
                    {
                        Log.Exception("A error occured when updating LedWiz Nr. {0}".Build(Number), E);
                        //Pinball.ThreadInfoList.RecordException(E);
                        FailCnt++;

                        if (FailCnt > MaxUpdateFailCount)
                        {
                            Log.Exception("More than {0} consecutive updates failed for LedWiz Nr. {1}. Updater thread will terminate.".Build(MaxUpdateFailCount, Number));
                            KeepLedWizUpdaterAlive = false;
                        }
                    }
                    //Pinball.ThreadInfoList.HeartBeat();
                    if (KeepLedWizUpdaterAlive)
                    {
                        lock (LedWizUpdaterThreadLocker)
                        {
                            while (!TriggerUpdate && KeepLedWizUpdaterAlive)
                            {
                                Monitor.Wait(LedWizUpdaterThreadLocker, 50);  // Lock is released while we’re waiting
                                //Pinball.ThreadInfoList.HeartBeat();
                            }

                        }

                    }
                    TriggerUpdate = false;
                }
                //Pinball.ThreadInfoList.ThreadTerminates();
                Log.Write("Updater thread for LedWiz {0:00} terminated.".Build(Number));
            }



            private DateTime LastUpdate = DateTime.Now;
            public int MinCommandIntervalMs = 1;
            private void UpdateDelay()
            {
                int Ms = (int)DateTime.Now.Subtract(LastUpdate).TotalMilliseconds;
                if (Ms < MinCommandIntervalMs)
                {
                    Thread.Sleep((MinCommandIntervalMs - Ms).Limit(0, MinCommandIntervalMs));
                }
                LastUpdate = DateTime.Now;
            }

            private void SendLedWizUpdate()
            {
                if (Number.IsBetween(1, 16))
                {

                    lock (LedWizUpdateLocker)
                    {
                        lock (ValueChangeLocker)
                        {
                            if (!UpdateRequired) return;


                            CopyNewToCurrent();

                            UpdateRequired = false;
                        }


                        if (CurrentValueUpdateRequired)
                        {
                            if (CurrentSwitchUpdateBeforeValueUpdateRequired)
                            {
                                UpdateDelay();

                                SBA(CurrentBeforeValueSwitches[0], CurrentBeforeValueSwitches[1], CurrentBeforeValueSwitches[2], CurrentBeforeValueSwitches[3], 2);

                            }

                            UpdateDelay();

                            PBA(CurrentOuputValues);

                        }
                        if (CurrentSwitchUpdateAfterValueUpdateRequired || (CurrentSwitchUpdateBeforeValueUpdateRequired && !NewValueUpdateRequired))
                        {
                            UpdateDelay();

                            SBA(CurrentAfterValueSwitches[0], CurrentAfterValueSwitches[1], CurrentAfterValueSwitches[2], CurrentAfterValueSwitches[3], 2);

                        }

                    }
                }
            }


            public void ShutdownLighting()
            {
                SBA(0, 0, 0, 0, 2);
            }


            private void SBA(uint bank1, uint bank2, uint bank3, uint bank4, uint globalPulseSpeed)
            {
                if (IsPresent)
                {
                    LWZ_SBA((uint)Number, bank1, bank2, bank3, bank4, globalPulseSpeed);
                }
            }

            private void PBA(byte[] val)
            {
                if (IsPresent)
                {
                    IntPtr ptr = Marshal.AllocCoTaskMem(val.Length);
                    Marshal.Copy(val, 0, ptr, val.Length);
                    LWZ_PBA((uint)Number, (uint)ptr.ToInt32());
                    Marshal.FreeCoTaskMem(ptr);
                }
            }

            private bool IsPresent
            {
                get
                {
                    if (!Number.IsBetween(1, 16)) return false;
                    return DeviceHandles.Any(x => x == Number);
                }
            }


            public LedWizUnit(int Number)
            {
                this.Number = Number;



            }

        }



        #endregion




    }
}