Example #1
0
        public SerialProcess(object settings)
        {
            var ss   = new SerialSettings(settings);
            var args = new StringBuilder();

            foreach (var p in ss.GetType().GetProperties())
            {
                if (args.Length > 0)
                {
                    args.Append(" ");
                }
                args.AppendFormat("{0}={1}", p.Name, p.GetValue(ss, null));
            }

            process           = new Process();
            process.StartInfo = new ProcessStartInfo
            {
                FileName               = typeof(SerialProcess).Assembly.Location,
                Arguments              = args.ToString(),
                CreateNoWindow         = true,
                UseShellExecute        = false,
                RedirectStandardInput  = true,
                RedirectStandardOutput = true,
                RedirectStandardError  = false
            };
            EnableStandardError(process.StartInfo);
            process.Start();
            Pid = process.Id;
            ForwardStandardError(process.StandardError);
        }
Example #2
0
        public SerialDevice(object settings)
        {
            buffer = new byte[256];
            list   = new List <byte>(256);
            queue  = new Queue <byte>(256);
            serial = new SerialPort();

            //init serial port and launch async reader
            SerialSettings.CopyProperties(settings, serial);
            serial.Open();
            //DiscardInBuffer not needed by FTDI and ignored by com0com
            var stream = serial.BaseStream;

            //unavailable after closed so pass it
            stream.BeginRead(buffer, 0, buffer.Length, ReadCallback, stream);
        }
Example #3
0
        private static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += Tools.ExceptionHandler;

            Stdio.EnableTrace(true, true);

            var settings = new SerialSettings();

            for (var i = 0; i < args.Length; i++)
            {
                var arg = args[i];
                Stdio.Trace("#Arg {0} {1}", i, arg);
                Tools.SetProperty(settings, arg);
            }

            using (var serial = new SerialDevice(settings))
            {
                var line = Stdio.ReadLine();
                while (line != null)
                {
                    Stdio.Trace("{0}", line);
                    if (line.StartsWith("$"))
                    {
                        var parts = line.Split(new[] { ',' });
                        switch (parts[0])
                        {
                        case "$r":
                            if (parts.Length != 4)
                            {
                                throw Tools.Make("Expected 4 parts in {0}", Tools.Readable(line));
                            }
                            var rSize    = ParseInt(line, parts[1], 1);
                            var rEop     = ParseInt(line, parts[2], 2);
                            var rToms    = ParseInt(line, parts[3], 3);
                            var rData    = serial.Read(rSize, rEop, rToms);
                            var response = Tools.StringHex(rData);
                            Stdio.Trace(response);
                            Stdio.WriteLine(response);
                            break;

                        default:
                            throw Tools.Make("Unknown command {0}", Tools.Readable(line));
                        }
                    }
                    else if (line.StartsWith(">"))
                    {
                        serial.Write(Tools.ParseHex(line));
                        Stdio.Trace("<ok");
                        Stdio.WriteLine("<ok");
                    }
                    else
                    {
                        throw Tools.Make("Unknown command {0}", Tools.Readable(line));
                    }

                    line = Stdio.ReadLine();
                }
            }

            Environment.Exit(0);
        }