ArtNet.cs

Go to the documentation of this file.

using System;
using System.Threading;
using DirectOutput.Cab.Out.DMX.ArtnetEngine;
using System.Xml.Serialization;
using System.Linq;

namespace DirectOutput.Cab.Out.DMX
{
    public class ArtNet : OutputControllerBase, IOutputController
    {

        private Engine Engine = null;
        private byte[] DMXData = new byte[512];
        private int LastDMXChannel = 0;
        private bool UpdateRequired = true;
        private object UpdateLocker = new object();

        private short _Universe = 0;

        public short Universe
        {
            get { return _Universe; }
            set { _Universe = value; }
        }

        private string _BroadcastAddress="";

        public string BroadcastAddress
        {
            get { return _BroadcastAddress; }
            set { _BroadcastAddress = value; }
        }



        private void AddOutputs()
        {
            for (int i = 1; i <= 512; i++)
            {
                if (!Outputs.Any(x => ((DMXOutput)x).DmxChannel == i))
                {
                    Outputs.Add(new DMXOutput() { Name = "{0}.{1:000}".Build(Name, i), DmxChannel=i });
                }
            }
        }

        public override void OnOutputValueChanged(IOutput Output)
        {
            if (!(Output is DMXOutput))
            {
                throw new Exception("The OutputValueChanged event handler for ArtNet node {0} (controlling Dmx universe {1}) has been called by a sender which is not a DmxOutput.".Build(Name, Universe));
            }

            DMXOutput O = (DMXOutput)Output;

            if (!O.DmxChannel.IsBetween(1, 512))
            {
                Log.Exception("ArtNet node {0} has received a update for a illegal dmx channel number ({1}).".Build(Name, O.DmxChannel));
                throw new ArgumentOutOfRangeException("ArtNet node {0} has received a update for a illegal dmx channel number ({1}).".Build(Name, O.DmxChannel));

            }

            lock (UpdateLocker)
            {
                if (DMXData[O.DmxChannel - 1] != O.Value)
                {
                    DMXData[O.DmxChannel - 1] = O.Value;
                    if (O.DmxChannel > LastDMXChannel)
                    {
                        LastDMXChannel = O.DmxChannel;
                    }
                    UpdateRequired = true;
                }
            }
        }

      

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

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

   
            InitUpdaterThread();

            Log.Write("ArtNet node {0} (controlling universe {1}) initialized and updater thread started.".Build(Name,Universe));
        }

        public override void Finish()
        {
            FinishUpdaterThread();
            Log.Write("ArtNet node {0} (controlling universe {1}) finished and updater thread stopped.".Build(Name, Universe));

        }



        #region UpdaterThread




        private void InitUpdaterThread()
        {

            if (!UpdaterThreadIsActive)
            {
                KeepUpdaterThreadAlive = true;
                try
                {
                    UpdaterThread = new Thread(UpdaterThreadDoIt);
                    UpdaterThread.Name = "ArtNet node {0} updater thread ".Build(Name);
                    UpdaterThread.Start();
                }
                catch (Exception E)
                {
                    Log.Exception("Artnet node {0} updater thread could not start.".Build(Name), E);
                    throw new Exception("Artnet node {0} updater thread could not start.".Build(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 ArtNet updater thread.", E);
                    throw new Exception("A error occured during termination of ArtNet 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 void UpdaterThreadDoIt()
        {
            if (Engine == null)
            {
                Engine = Engine.Instance;
                
            }

            //Send all channels to ensure that there are defined values
            Engine.SendDMX(BroadcastAddress,Universe, DMXData, 512);

            while (KeepUpdaterThreadAlive)
            {

                if (UpdateRequired)
                {
                    lock (UpdateLocker)
                    {
                        UpdateRequired = false;
                        Engine.SendDMX(BroadcastAddress, Universe, DMXData, ((LastDMXChannel | 1) + 1).Limit(2, 512));
                    }

                }

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

            }
            if (Engine != null)
            {
               
                Engine = null;
            }

        }
        #endregion


        public ArtNet() {
            Outputs = new OutputList();

        }



    }
}