PacLed64.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Threading;
using System.Xml.Serialization;
using DirectOutput.General;

namespace DirectOutput.Cab.Out.Pac
{
    public class PacLed64 : OutputControllerBase, IOutputController
    {
        #region Id


        private object IdUpdateLocker = new object();
        private int _Id = -1;

        public int Id
        {
            get { return _Id; }
            set
            {
                if (!value.IsBetween(1, 4))
                {
                    throw new Exception("PacLed64 Ids must be between 1-4. The supplied Id {0} is out of range.".Build(value));
                }
                lock (IdUpdateLocker)
                {
                    if (_Id != value)
                    {

                        if (Name.IsNullOrWhiteSpace() || Name == "PacLed64 {0:0}".Build(_Id))
                        {
                            Name = "PacLed64 {0:0}".Build(value);
                        }

                        _Id = value;

                    }
                }
            }
        }

        #endregion

        private int _MinUpdateIntervalMs = 0;

        public int MinUpdateIntervalMs
        {
            get { return _MinUpdateIntervalMs; }
            set { _MinUpdateIntervalMs = value.Limit(0, 1000); }
        }


        private int _FullUpdateThreshold = 30;

        public int FullUpdateThreshold
        {
            get { return _FullUpdateThreshold; }
            set { _FullUpdateThreshold = value.Limit(0, 64); }
        }





        #region IOutputcontroller implementation
        public override void Update()
        {
            PacLed64Units[Id].TriggerPacLed64UpdaterThread();
        }


        public override void Init(Cabinet Cabinet)
        {
            AddOutputs();
            PacLed64Units[Id].FullUpdateThreshold = FullUpdateThreshold;
            PacLed64Units[Id].MinUpdateInterval = TimeSpan.FromMilliseconds(MinUpdateIntervalMs);
            PacLed64Units[Id].Init(Cabinet);
            Log.Write("PacLed64 Id:{0} initialized and updater thread started.".Build(Id));

        }

        public override void Finish()
        {
            PacLed64Units[Id].Finish();
            PacLed64Units[Id].ShutdownLighting();
            Log.Write("PacLed64 Id:{0} finished and updater thread stopped.".Build(Id));

        }
        #endregion



        #region Outputs


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




        protected override void OnOutputValueChanged(IOutput Output)
        {

            IOutput ON = Output;

            if (!ON.Number.IsBetween(1, 64))
            {
                throw new Exception("PacLed64 output numbers must be in the range of 1-64. The supplied output number {0} is out of range.".Build(ON.Number));
            }

            PacLed64Unit S = PacLed64Units[this.Id];
            S.UpdateValue(ON);
        }



        #endregion









        //~PacLed64()
        //{
        //    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)
        //    {
        //        // 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.

        //        TerminatePacLed64();


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

        //    }
        //}
        //private bool disposed = false;

        //#endregion



        #region Constructor


        static PacLed64()
        {

            PacLed64Units = new Dictionary<int, PacLed64Unit>();
            for (int i = 1; i <= 4; i++)
            {
                PacLed64Units.Add(i, new PacLed64Unit(i));

            }

        }

        public PacLed64()
        {

            Outputs = new OutputList();

        }



        public PacLed64(int Id)
            : this()
        {
            this.Id = Id;
        }

        #endregion






        #region Internal class for PacLed64 output states and update methods

        private static Dictionary<int, PacLed64Unit> PacLed64Units = new Dictionary<int, PacLed64Unit>();

        private class PacLed64Unit
        {
            //private Pinball Pinball;


            private const int MaxUpdateFailCount = 5;


            public int Id { get; private set; }

            public int FullUpdateThreshold { get; set; }
            public TimeSpan MinUpdateInterval { get; set; }

            private int Index { get; set; }

            private PacDriveSingleton PDSingleton;

            private byte[] NewValue = new byte[64];
            private byte[] CurrentValue = new byte[64];


            private byte[] LastValueSent = new byte[64];
            private bool[] LastStateSent = new bool[64];

            public bool UpdateRequired = true;

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

            public Thread PacLed64Updater;
            public bool KeepPacLed64UpdaterAlive = false;
            public object PacLed64UpdaterThreadLocker = new object();


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

            public void Finish()
            {

                TerminatePacLed64UpdaterThread();
                ShutdownLighting();

            }

            public void UpdateValue(IOutput Output)
            {
                //Skip update on output numbers which are out of range
                if (!Output.Number.IsBetween(1, 64)) return;

                int ZeroBasedOutputNumber = Output.Number - 1;
                lock (ValueChangeLocker)
                {
                    if (NewValue[ZeroBasedOutputNumber] != Output.Value)
                    {
                        NewValue[ZeroBasedOutputNumber] = Output.Value;
                        UpdateRequired = true;
                    }
                }

            }
            private void CopyNewToCurrent()
            {
                lock (ValueChangeLocker)
                {
                    Array.Copy(NewValue, CurrentValue, NewValue.Length);

                }
            }

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

            public void StartPacLed64UpdaterThread()
            {
                lock (PacLed64UpdaterThreadLocker)
                {
                    if (!IsUpdaterThreadAlive)
                    {
                        KeepPacLed64UpdaterAlive = true;
                        PacLed64Updater = new Thread(PacLed64UpdaterDoIt);
                        PacLed64Updater.Name = "PacLed64 {0:0} updater thread".Build(Id);
                        PacLed64Updater.Start();
                    }
                }
            }
            public void TerminatePacLed64UpdaterThread()
            {
                lock (PacLed64UpdaterThreadLocker)
                {
                    if (PacLed64Updater != null)
                    {
                        try
                        {
                            KeepPacLed64UpdaterAlive = false;
                            TriggerPacLed64UpdaterThread();
                            if (!PacLed64Updater.Join(1000))
                            {
                                PacLed64Updater.Abort();
                            }

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

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


            //TODO: Check if thread should really terminate on failed updates
            private void PacLed64UpdaterDoIt()
            {
                //Pinball.ThreadInfoList.HeartBeat("PacLed64 {0:0}".Build(Id));

                try
                {
                    ResetFadeTime();

                }
                catch (Exception E)
                {
                    Log.Exception("A exception occured while setting the fadetime for pacled64 {0} to 0.".Build(Index), E);
                    throw;
                }
                int FailCnt = 0;
                while (KeepPacLed64UpdaterAlive)
                {
                    try
                    {
                        if (IsPresent)
                        {

                            SendPacLed64Update();

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

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

                        }

                    }
                    TriggerUpdate = false;
                }
                //Pinball.ThreadInfoList.ThreadTerminates();
            }




            private bool ForceFullUpdate = true;
            private void SendPacLed64Update()
            {
                if (IsPresent)
                {

                    lock (PacLed64UpdateLocker)
                    {
                        lock (ValueChangeLocker)
                        {
                            if (!UpdateRequired && !ForceFullUpdate) return;

                            CopyNewToCurrent();

                            UpdateRequired = false;
                        }

                        byte IntensityUpdatesRequired = 0;
                        byte StateUpdatesRequired = 0;
                        if (!ForceFullUpdate)
                        {

                            for (int g = 0; g < 8; g++)
                            {

                                bool StateUpdateRequired = false;
                                for (int p = 0; p < 8; p++)
                                {
                                    int o = g << 3 | p;
                                    if (CurrentValue[o] > 0)
                                    {
                                        if (CurrentValue[o] != LastValueSent[o])
                                        {
                                            IntensityUpdatesRequired++;
                                        }
                                        else if (!LastStateSent[o])
                                        {
                                            StateUpdateRequired = true;
                                        }
                                    }
                                    else if (LastStateSent[o])
                                    {
                                        StateUpdateRequired = true;
                                    }

                                }
                                if (StateUpdateRequired) StateUpdatesRequired++;
                                StateUpdateRequired = false;
                            }
                        }
                        if (ForceFullUpdate || (IntensityUpdatesRequired + StateUpdatesRequired) >= FullUpdateThreshold)
                        {
                            //more than FullUpdateThreshold update calls required. Will send intensity updates for all outputs.
                            EnforceMinUpdateInterval();
                            PDSingleton.PacLed64SetLEDIntensities(Index, CurrentValue);
                            Array.Copy(CurrentValue, LastValueSent, CurrentValue.Length);
                            for (int i = 0; i < 64; i++)
                            {
                                LastStateSent[i] = (LastValueSent[i] > 0);
                            }
                        }
                        else
                        {
                            //Will send separate intensity and state updates.
                            for (int g = 0; g < 8; g++)
                            {
                                int Mask = 0;
                                bool StateUpdateRequired = false;
                                for (int p = 0; p < 8; p++)
                                {
                                    int o = g << 3 | p;
                                    if (CurrentValue[o] > 0)
                                    {
                                        if (CurrentValue[o] != LastValueSent[o])
                                        {
                                            EnforceMinUpdateInterval();
                                            PDSingleton.PacLed64SetLEDIntensity(Index, o, CurrentValue[o]);
                                            LastStateSent[o] = true;
                                            LastValueSent[o] = CurrentValue[o];
                                        }
                                        else if (!LastStateSent[o])
                                        {

                                            StateUpdateRequired = true;
                                            LastStateSent[o] = true;
                                        }
                                        Mask |= (1 << p);
                                    }
                                    else if (LastStateSent[o])
                                    {
                                        StateUpdateRequired = true;
                                        LastStateSent[o] = false;
                                        LastValueSent[o] = 0;
                                    }

                                }
                                if (StateUpdateRequired)
                                {
                                    EnforceMinUpdateInterval();
                                    PDSingleton.PacLed64SetLEDStates(Index, g + 1, (byte)Mask);
                                    StateUpdateRequired = false;
                                }

                            }
                        }


                    }
                    ForceFullUpdate = false;
                }
                else
                {
                    ForceFullUpdate = true;
                }
            }


            public void ShutdownLighting()
            {
                for (int g = 0; g <= 8; g++)
                {
                    EnforceMinUpdateInterval();
                    PDSingleton.PacLed64SetLEDStates(0, g, 0);
                }

                LastStateSent.Fill(false);
            }

            private void ResetFadeTime()
            {
                EnforceMinUpdateInterval();
                PDSingleton.PacLed64SetLEDFadeTime(Index, 0);

            }


            DateTime LastCommand = DateTime.MinValue;
            private void EnforceMinUpdateInterval()
            {
                if (MinUpdateInterval != TimeSpan.Zero)
                {
                    TimeSpan Interval = DateTime.Now - LastCommand;
                    LastCommand = DateTime.Now;
                    if (Interval < MinUpdateInterval)
                    {
                        int Sleepperiod = ((int)(MinUpdateInterval - Interval).TotalMilliseconds).Limit(0,1000);
                        if (Sleepperiod > 0)
                        {
                            Thread.Sleep(Sleepperiod);
                        }
                    }
                }
            }



            private bool IsPresent
            {
                get
                {
                    if (!Id.IsBetween(1, 4)) return false;
                    return Index >= 0;
                }
            }


            void Instance_OnPacRemoved(int Index)
            {
                this.Index = PDSingleton.PacLed64GetIndexForDeviceId(Id);
            }

            void Instance_OnPacAttached(int Index)
            {
                this.Index = PDSingleton.PacLed64GetIndexForDeviceId(Id);
                InitUnit();
                TriggerPacLed64UpdaterThread();
            }

            private void InitUnit()
            {
                if (Index >= 0)
                {
                    LastValueSent.Fill((byte)0);

                    PDSingleton.PacLed64SetLEDIntensities(Index, LastValueSent);
                    LastStateSent.Fill(false);
                    LastValueSent.Fill((byte)0);
                }
            }


            public PacLed64Unit(int Id)
            {
                this.Id = Id;

                PDSingleton = PacDriveSingleton.Instance;
                PDSingleton.OnPacAttached += new PacDriveSingleton.PacAttachedDelegate(Instance_OnPacAttached);
                PDSingleton.OnPacRemoved += new PacDriveSingleton.PacRemovedDelegate(Instance_OnPacRemoved);

                this.Index = PacDriveSingleton.Instance.PacLed64GetIndexForDeviceId(Id);

                NewValue.Fill((byte)0);

                InitUnit();


            }


        }



        #endregion




    }
}