Laola.New/WpfTest1/ComAgent/ComAgent.cs

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Linq;
using System.Collections.Concurrent;
using System.Runtime.InteropServices;
using WpfTest1.SmallDialogs.Debug;

namespace WpfTest1.ComAgent
{
    public interface ComAgentListener
    {
        void comAgentReceiveData(byte[] data);
        void comAgentConnected();
        void comAgentDisconnected(Exception e);
    }

    public struct TreatmentStep
    {
        public ushort Hz { get; set; }
        public byte T { get; set; }
        public byte P { get; set; }
        public ushort S { get; set; }

        public TreatmentStep(ushort hz, byte t, byte p, ushort s)
        {
            Hz = hz;
            T = t;
            P = p;
            S = s;
        }

        public TreatmentStep(double hz, byte t, double p, ushort s)
        {
            Hz = (ushort)(hz * 10.0);
            T = t;
            P = (byte)(p);
            S = s;
        }
    }

    public class SingleInstance<T> where T : new()
    {
        private static T instance;

        private static object lck = new object();

        public static T getInstance(Func<T> allocator = null)
        {
            lock (lck)
            {
                if (instance != null) return instance;
                instance = allocator != null ? allocator() : new T();
                return instance;
            }
        }
    }

    public class ComAgent
    {
        public static byte[] createAnswerCommand(bool status) => 0x00.b().pack(status ? 0x54.b() : 0x46.b());
        public static byte[] createHandshakeCommand() => 0x4B.b().pack(0x00.b());
        public static byte[] createShutdownCommand() => 0x47.b().pack(0x00.b());
        public static byte[] createIdleCommand() => 0x49.b().pack(0x00.b());
        public static byte[] createChangeStrongthCommand(byte strongth) => 0x40.b().pack(strongth);

        public static byte getTCIDByIndex(int index)
        {
            switch (index)
            {
                case 0: return 0x10;
                case 1: return 0x11;
                case 2: return 0x12;
                case 3: return 0x13;
                case 4: return 0x14;
                case 5: return 0x25;
                case 6: return 0x26;
                case 7: return 0x27;
                case 8: return 0x28;
                case 9: return 0x29;
                default: throw new ComException($"Invaild mode {index}");
            }
        }

        public static byte[] createStartDefinedCommand(int mode, short time, byte strongth)
        {
            List<byte> buff = new List<byte>();
            buff.Add(getTCIDByIndex(mode));
            buff.Add(0x53);
            buff.AddRange(time.buff());
            buff.AddRange(strongth.buff());
            buff.Add(0x00);
            return buff.ToArray();
        }

        public static byte[] createStartManualCommand(short time, byte strongth, params TreatmentStep[] steps)
        {
            List<byte> buff = new List<byte>();
            buff.Add(48);
            buff.Add(83);
            buff.AddRange(time.buff());
            buff.AddRange(strongth.buff());
            buff.AddRange(((byte)steps.Length).buff());
            for (int i = 0; i < steps.Length; i++)
            {
                TreatmentStep step = steps[i];
                buff.AddRange(step.Hz.buff());
                buff.AddRange(step.T.buff());
                buff.AddRange(step.P.buff());
                buff.AddRange(step.S.buff());
            }
            return buff.ToArray();
        }

        public static byte[] createStopCommand(byte mode = 0x30) => mode.pack(0x73.b());

        private AutoReleaseObject<SerialPort> serial;
        private Thread sendThread_, recvThread_;
        private List<ComAgentListener> listeners;
        public string[] blockingSerialPorts { get; set; }

        public void addListener(ComAgentListener listener)
        {
            listeners.Add(listener);
        }

#if DEBUG
        private SerialPortLogWindow window => SingleInstance<SerialPortLogWindow>.getInstance(() =>
        {
            SerialPortLogWindow win = null;
            App.Current.Dispatcher.Invoke(() =>
            {
                win = new SerialPortLogWindow();
                win.Show();
            });
            return win;
        });

        private SerialPortSetup setupWindow = SingleInstance<SerialPortSetup>.getInstance(() =>
        {
            SerialPortSetup win = null;
            bool cont = false;
            App.Current.Dispatcher.Invoke(() =>
            {
                while (win == null || win.result == null)
                {
                    win = new SerialPortSetup();
                    win.ShowDialog();
                }
                cont = true;
            });
            while (!cont) Thread.Sleep(10);
            return win;
        });
#endif

        void Log(string msg)
        {
#if DEBUG
            window.Log($"[{DateTime.Now}] ${msg}");
            Console.WriteLine(msg);
#endif
        }

        public ComAgent()
        {
            reconnect();
        }

        private byte[] readPackage(SerialPort sp)
        {
            byte[] buff = new byte[2];
            List<byte> data = new List<byte>();
            while (true)
            {
                sp.read(buff, 1);
                if (buff[0] != 0x10) continue;
                sp.read(buff, 1);
                if (buff[0] != 0x02) continue;
                data.AddRange(new byte[2] { 0x10, 0x02 });
                break;
            }
            while (true)
            {
                sp.read(buff, 1);
                data.Add(buff[0]);
                if (buff[0] == 0x10)
                {
                    sp.read(buff, 1);
                    data.Add(buff[0]);
                    if (buff[0] == 0x03) break;
                }
            }
            return data.ToArray();
        }

        private byte[] readPackageAndUnpack(SerialPort sp) => readPackage(sp).unpackData();

        private bool connect()
        {
#if DEBUG
            AutoReleaseObject<SerialPort> com3 = new SerialPort(setupWindow.result, 9600);
            com3.reference.Open();
            serial = com3;
            return true;
#endif
            string[] ports = (from it in SerialPort.GetPortNames()
                              where !blockingSerialPorts.Contains(it)
                              select it).ToArray();
            List<Thread> sps = new List<Thread>();
            for (int i = 0; i < ports.Length; i++)
            {
                string mport = ports[i];
                Thread mth = new Thread(() =>
                {
                    AutoReleaseObject<SerialPort> sp = new SerialPort(mport, 9600);
                    sp.reference.ReadTimeout = sp.reference.WriteTimeout = 1000;
                    try
                    {
                        sp.reference.Open();
                        sp.reference.send(createHandshakeCommand().packData());
                        byte[] resp = readPackageAndUnpack(sp);
                        if (serial != null) return;
                        if (resp.bEquals(new byte[1] { 0x4B }))
                            serial = sp;
                    }
                    catch (Exception e)
                    {
                        Log(e.ToString());
                        sp.reference.shutdown();
                    }
                })
                { IsBackground = true };
                sps.Add(mth);
                mth.Start();
            }
            while (true)
            {
                if ((from it in sps
                     where it.IsAlive
                     select it).Count() == 0) break;
                if (serial != null) break;
            }
            return serial != null;
        }

        private ConcurrentQueue<byte[]> sendQueue;
        private object serial_lock_w = new object(), serial_lock_r = new object();

        public void enqueueCommand(byte[] buff) => sendQueue.Enqueue(buff.packData());

        private void printBuff(string from, byte[] buff)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < buff.Length; i++)
            {
                sb.AppendFormat("{0:x2} ", buff[i]);
            }
            Log(from + " " + sb.ToString());
        }

        private void sendThread()
        {
            while (true)
            {
                lock (serial_lock_w)
                {
                    if (serial == null)
                    {
                        while (!connect()) Thread.Sleep(10);
                        listeners.ForEach(listener => listener.comAgentConnected());
                    }
                    try
                    {
                        if (!serial.reference.IsOpen) throw new ComException("Shutdown by client.");
#if !DEBUG
                        serial.reference.send(createIdleCommand());
#endif
                        while (sendQueue.TryDequeue(out byte[] buff))
                        {
                            serial.reference.send(buff);
                            printBuff("ME -> Client", buff);
                        }
                    }
                    catch (Exception e)
                    {
                        Log($"SendThread {e}");
                        if (serial != null) serial.reference.shutdown();
                        serial = null;
                        if (!sendedDisconnectedMessage)
                        {
                            listeners.ForEach(delegate (ComAgentListener listener)
                            {
                                listener.comAgentDisconnected(e);
                            });
                            sendedDisconnectedMessage = true;
                        }
                        break;
                    }
                }
                Thread.Sleep(10);
            }
        }

        private bool sendedDisconnectedMessage = false;
        private bool __sendThreadAct = false;
        private bool __recvThreadAct = false;

        public void reconnect()
        {
            sendedDisconnectedMessage = false;
            if (!__sendThreadAct)
            {
                __sendThreadAct = true;
                sendThread_ = new Thread(sendThread)
                {
                    IsBackground = true
                };
                sendThread_.Start();
            }
            if (!__recvThreadAct)
            {
                __recvThreadAct = true;
                recvThread_ = new Thread(recvThread)
                {
                    IsBackground = true
                };
                recvThread_.Start();
            }
            listeners = new List<ComAgentListener>();
            sendQueue = new ConcurrentQueue<byte[]>();
            blockingSerialPorts = new string[1] { "COM1" };
        }

        public void shutdown()
        {
            enqueueCommand(createShutdownCommand());
        }

        private void recvThread()
        {
            while (true)
            {
                lock (serial_lock_r)
                {
                    if (serial != null)
                    {
                        try
                        {
                            if (!serial.reference.IsOpen) throw new ComException("Shutdown by client.");
                            byte[] data = readPackage(serial);
                            printBuff("Client -> Me", data);
                            data = data.unpackData();
                            listeners.ForEach(listener => listener.comAgentReceiveData(data));
                        }
                        catch (Exception e)
                        {
                            Log($"RecvThread {e}");
#if !DEBUG
                            if (serial != null) serial.reference.shutdown();
                            serial = null;
                            listeners.ForEach(listener => listener.comAgentDisconnected(e));
#endif
                            if (!sendedDisconnectedMessage)
                            {
                                listeners.ForEach(delegate (ComAgentListener listener)
                                {
                                    listener.comAgentDisconnected(e);
                                });
                                sendedDisconnectedMessage = true;
                            }
                            break;
                        }
                    }
                }
                Thread.Sleep(10);
            }
        }
    }
}