public ScriptRunner(String base_path, ISerial serial_device, String script_path) { Script script = new Script(); XmlSerializer s = new XmlSerializer(typeof(Script)); try { using (StreamReader streamReader = new StreamReader(script_path)) { string fileContent = streamReader.ReadToEnd(); using (StringReader reader = new StringReader(fileContent)) { script = (Script)s.Deserialize(reader); } } buildScriptActions(base_path, serial_device, script); } catch (Exception e) { throw new MtuLoadException("Error loading Script file"); } }
public void ParseScriptAndRun(String base_path, ISerial serial_device, String script_stream, int stream_size) { // Script file is empty if (string.IsNullOrEmpty(script_stream.Trim())) { Errors.LogErrorNowAndContinue(new ScriptEmptyException()); this.OnError(); return; } Script script = new Script(); XmlSerializer s = new XmlSerializer(typeof(Script)); try { using (StringReader reader = new StringReader(script_stream.Substring(0, stream_size))) { script = (Script)s.Deserialize(reader); } buildScriptActions(base_path, serial_device, script); } catch (Exception e) { // Script file has invalid format or structure Errors.LogErrorNowAndContinue(new ScriptWrongStructureException()); this.OnError(); return; } this.Run(); }
public Service() { var kernel = new StandardKernel(new YouCNC_Serial.DiModule.DiModule()); kernel.Load(Assembly.GetExecutingAssembly()); this.serial = kernel.Get <ISerial>(); }
public TesterContext(Card card, ISerial serialPort) { this.card = card; this.serialPort = serialPort; this.readThread = new ReadThread(serialPort); this.command = new Command(serialPort); }
public static async Task <Eeprom> ReadEepromAsync(this ISerial serial) { uint[] values = await serial.GetEpromValuesAsync(SerialExtension.DefaultEpromTimeout); if (values != null) { var ee = new EepromV1 { Values = values }; if (ee.IsValid) { File.WriteAllLines(Environment.ExpandEnvironmentVariables(@"%TEMP%\EepromRead.nc"), ee.ToGCode()); byte numAxis = ee[EepromV1.EValueOffsets8.NumAxis]; var eeprom = Eeprom.Create(ee[EepromV1.EValueOffsets32.Signature], numAxis); eeprom.Values = values; eeprom.ReadFrom(ee); return(eeprom); } } return(null); }
private SimWorker() { _serial = new UsbSerial(); _serial.ReceiveHandler += SerialPort_ReceiveHandler; _waitForSendDirectives = new ConcurrentQueue <CompositeDirective>(); Init().IgnorCompletion(); }
/// <summary> /// Send commands stored in a file. Wait until the commands are transferred and we got a reply (no command pending) /// </summary> /// <param name="serial"></param> /// <param name="filename">used for a StreamReader</param> /// <param name="waitForMilliseconds"></param> public static async Task <IEnumerable <SerialCommand> > SendFileAsync(this ISerial serial, string filename, int waitForMilliseconds = DefaultTimeout) { var list = await serial.QueueFileAsync(filename); await serial.WaitUntilQueueEmptyAsync(waitForMilliseconds); return(list); }
public void disconnect() { if (connected != null) { ISerial tmp = connected; connected = null; tmp.disconnect(); } }
/// <summary> /// write all pending (command with no reply) to file /// Intended to be used if user abort queue because of an error /// </summary> /// <param name="serial"></param> /// <param name="filename"></param> public static void WritePendingCommandsToFile(this ISerial serial, string filename) { using (var sw = new StreamWriter(Environment.ExpandEnvironmentVariables(filename))) { foreach (SerialCommand cmd in serial.PendingCommands) { sw.WriteLine(cmd.CommandText); } } }
public static async Task <uint[]> GetEpromValuesAsync(this ISerial serial, int waitForMilliseconds) { var cmd = (await serial.SendCommandAsync("$?", waitForMilliseconds)).FirstOrDefault(); if (cmd != null && string.IsNullOrEmpty(cmd.ResultText) == false) { string[] separators = { "\n", "\r" }; string[] lines = cmd.ResultText.Split(separators, StringSplitOptions.RemoveEmptyEntries); var intValues = new Dictionary <int, uint>(); int maxSlot = -1; foreach (var line in lines) { // e.g. $1=65535(ffff) string[] assign = line.Split('='); int slot; if (assign.Length == 2 && assign[0].StartsWith("$") && int.TryParse(assign[0].TrimStart('$'), out slot)) { uint slotValue; string valueStr = assign[1]; int idx1 = valueStr.IndexOf('('); if (idx1 > 0) { valueStr = valueStr.Substring(0, idx1); } if (uint.TryParse(valueStr, out slotValue)) { intValues[slot] = slotValue; if (maxSlot < slot) { maxSlot = slot; } } } } if (maxSlot > 0) { var ret = new uint[maxSlot + 1]; for (int i = 0; i <= maxSlot; i++) { if (intValues.ContainsKey(i)) { ret[i] = intValues[i]; } } return(ret); } } return(null); }
public void GetLastLogQueryResult(ISerial serial, int timeout) { List <byte> list = new List <byte>(5); list.Add(37); list.Add(254); list.Add(21); list.Add(0); list.Add(GetChecksum(list)); byte[] stream = list.ToArray(); serial.Write(stream, 0, stream.Length); byte[] rawBuffer = new byte[10]; int response_offest = 0; if (serial.isEcho()) { response_offest = stream.Length; } Array.Resize(ref rawBuffer, (int)(response_offest + 5)); long timeout_limit = DateTimeOffset.Now.ToUnixTimeMilliseconds() + (timeout); while (serial.BytesToRead() < rawBuffer.Length) { if (DateTimeOffset.Now.ToUnixTimeMilliseconds() > timeout_limit) { //if even no data response no puck error.. if (serial.BytesToRead() <= response_offest) { throw new IOException(); } else { throw new TimeoutException(); } } Thread.Sleep(10); } serial.Read(rawBuffer, 0, rawBuffer.Length); byte[] response = new byte[5]; Array.Copy(rawBuffer, response.Length, response, 0, response.Length); if (response[0] != 0x06) { throw new LexiWriteException(response); } }
public Action(Configuration config, ISerial serial, ActionType type, String user = "", String outputfile = "") { // outputfile = new FileInfo ( outputfile ).Name; // NO // System.IO.Path.GetFileName(outputfile)); // NO configuration = config; logger = new Logger(config, outputfile.Substring(outputfile.LastIndexOf('\\') + 1)); comm = new MTUComm(serial, config); this.type = type; this.user = user; comm.OnError += Comm_OnError; }
public static void WriteCommandHistory(this ISerial serial, string filename) { using (var sr = new StreamWriter(Environment.ExpandEnvironmentVariables(filename))) { foreach (SerialCommand cmds in serial.CommandHistoryCopy) { sr.Write(cmds.SentTime); sr.Write(":"); sr.Write(cmds.CommandText); sr.Write(" => "); sr.WriteLine(cmds.ResultText); } } }
public static async Task <bool> SendProbeCommandAsync(this ISerial serial, string axisName, decimal probeSize, decimal probeDist, decimal probeDistUp, decimal probeFeed) { var result = await serial.SendCommandAsync($"g91 g31 {axisName}-{probeDist.ToString(CultureInfo.InvariantCulture)} F{probeFeed.ToString(CultureInfo.InvariantCulture)} g90", GCodeSerial.DefaultProbeTimeout); if (result?.LastOrDefault()?.ReplyType.HasFlag(EReplyType.ReplyError) == false) { serial.QueueCommand($"g92 {axisName}{(-probeSize).ToString(CultureInfo.InvariantCulture)}"); serial.QueueCommand($"g91 g0 {axisName}{probeDistUp.ToString(CultureInfo.InvariantCulture)} g90"); return(true); } return(false); }
/// <summary> /// Send commands stored in a file. Wait until the commands are transferrd and we got a reply (no command pending) /// </summary> /// <param name="filename">used for a StreamReader</param> public static async Task <IEnumerable <SerialCommand> > QueueFileAsync(this ISerial serial, string filename) { using (var sr = new StreamReader(filename)) { string line; var lines = new List <string>(); while ((line = sr.ReadLine()) != null) { lines.Add(line); } return(await serial.QueueCommandsAsync(lines.ToArray())); } }
/// <summary> /// Send a command to the arduino and wait until a (OK) reply /// Queue must be empty /// </summary> /// <param name="line">command line</param> /// <param name="waitForMilliseconds"></param> /// <returns>ok result from arduino or empty(if error)</returns> public static async Task <string> SendCommandAndReadOKReplyAsync(this ISerial serial, string line, int waitForMilliseconds) { var ret = await serial.SendCommandAsync(line, waitForMilliseconds); if (ret.Any()) { var last = ret.Last(); if (last.ReplyType.HasFlag(EReplyType.ReplyOK)) { return(last.ResultText); } } return(null); }
public static async Task <IEnumerable <IEnumerable <decimal> > > GetPosition(this ISerial serial, string commandPrefix) { string message = await serial.SendCommandAndReadOKReplyAsync($"{commandPrefix}?", 10 * 1000); var ret = new List <IEnumerable <decimal> >(); if (!string.IsNullOrEmpty(message)) { if (message.Contains("MPos:")) { // new or grbl format message = message.Replace("ok", "").Replace("<", "").Replace(">", "").Trim(); string[] tags = message.Split('|'); var mPos = TryConvert(tags, "MPos:"); if (mPos != null) { ret.Add(mPos.ToArray()); var wco = TryConvert(tags, "WCO:"); if (wco != null) { for (int i = 0; i < wco.Length; i++) { mPos[i] -= wco[i]; } } ret.Add(mPos); } } else { decimal[] mPos = Convert(message, "dummy"); ret.Add(mPos); message = await serial.SendCommandAndReadOKReplyAsync($"{commandPrefix}m114 s1", 10 * 1000); if (!string.IsNullOrEmpty(message)) { decimal[] rPos = Convert(message, "dummy"); ret.Add(rPos); } } } return(ret); }
public static async Task <decimal?> GetParameterValueAsync(this ISerial serial, int parameter, string commandPrefix) { string message = await serial.SendCommandAndReadOKReplyAsync($"{commandPrefix}(print, #{parameter})", 10 * 1000); if (!string.IsNullOrEmpty(message)) { // expected response : 0\nok string pos = message.Split('\n').FirstOrDefault(); if (decimal.TryParse(pos, NumberStyles.Any, CultureInfo.InvariantCulture, out decimal val)) { return(val); } } return(null); }
private EventCalls SubscribeForEventCall(ISerial serial) { var eventcounts = new EventCalls(); serial.WaitForSend += (sender, e) => eventcounts.EventWaitForSend++; serial.CommandSending += (sender, e) => eventcounts.EventCommandSending++; serial.CommandSent += (sender, e) => eventcounts.EventCommandSent++; serial.WaitCommandSent += (sender, e) => eventcounts.EventWaitCommandSent++; serial.ReplyReceived += (sender, e) => eventcounts.EventReplyReceived++; serial.ReplyOK += (sender, e) => eventcounts.EventReplyOK++; serial.ReplyError += (sender, e) => eventcounts.EventReplyError++; serial.ReplyInfo += (sender, e) => eventcounts.EventReplyInfo++; serial.ReplyUnknown += (sender, e) => eventcounts.EventReplyUnknown++; serial.CommandQueueChanged += (sender, e) => eventcounts.EventCommandQueueChanged++; serial.CommandQueueEmpty += (sender, e) => eventcounts.EventCommandQueueEmpty++; return(eventcounts); }
private ISerialPort CreateSerialPortMock(ISerial serial, string[] responsstrings) { var serialport = Substitute.For <ISerialPort>(); var basestream = Substitute.For <MemoryStream>(); serialport.BaseStream.ReturnsForAnyArgs(basestream); Encoding encoding = Encoding.GetEncoding(1200); serialport.Encoding.ReturnsForAnyArgs(encoding); Tools.Dependency.Dependency.Container.ResetContainer(); Tools.Dependency.Dependency.Container.RegisterInstance(serialport); int resultidx = 0; bool sendReply = false; basestream.WriteAsync(Arg.Any <byte[]>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <System.Threading.CancellationToken>()). ReturnsForAnyArgs(async x => { sendReply = true; await Task.FromResult(0); }); basestream.ReadAsync(Arg.Any <byte[]>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <System.Threading.CancellationToken>()). ReturnsForAnyArgs(async x => { if (sendReply) { await Task.Delay(10); sendReply = false; byte[] encodedStr = encoding.GetBytes(responsstrings[resultidx++]); for (int i = 0; i < encodedStr.Length; i++) { ((byte[])x[0])[i] = encodedStr[i]; } return(encodedStr.Length); } await Task.Delay(10); return(0); }); return(serialport); }
public void ParseScriptAndRun(ISerial serial_device, String script_stream, int stream_size) { XmlSerializer s = null; try { // Script file is empty if (string.IsNullOrEmpty(script_stream.Trim())) { throw new ScriptEmptyException(); } Script script = new Script(); s = new XmlSerializer(typeof(Script)); // Register unknown elements ( not present in Script class ) as additional parameters s.UnknownElement += this.UnknownElementEvent; using (StringReader reader = new StringReader(script_stream.Substring(0, stream_size))) { script = ( Script )s.Deserialize(reader); } BuildScriptActions(serial_device, script); } catch (Exception e) { if (!Errors.IsOwnException(e)) { Errors.LogErrorNowAndContinue(new ScriptWrongStructureException()); // Script file has invalid format or structure } else { Errors.LogErrorNowAndContinue(e); // ScriptLogfileInvalidException, ScriptActionTypeInvalidException } this.OnError(); return; } finally { s.UnknownElement -= this.UnknownElementEvent; } this.Run(); }
public void Cancel() { if (_cancelTokenSource != null) { if (!_cancelTokenSource.IsCancellationRequested) { _cancelTokenSource.Cancel(); } } if (_serialPort != null) { _serialPort.ReceiveHandler -= SpHelper_ReceiveHandler; _serialPort = null; } _waitForFeedbackDirectives.Clear(); }
public static async Task <bool> WriteEepromAsync(this ISerial serial, Eeprom eepromValue) { var ee = new EepromV1 { Values = eepromValue.Values }; if (ee.IsValid) { eepromValue.WriteTo(ee); File.WriteAllLines(Environment.ExpandEnvironmentVariables(@"%TEMP%\EepromWrite.nc"), ee.ToGCode()); await serial.WriteEepromValuesAsync(ee); return(true); } return(false); }
public static async Task <bool> SendProbeCommandAsync(this ISerial serial, Machine machine, int axisIndex) { string axisName = machine.GetAxisName(axisIndex); decimal probeSize = machine.GetProbeSize(axisIndex); string probDist = machine.ProbeDist.ToString(CultureInfo.InvariantCulture); string probDistUp = machine.ProbeDistUp.ToString(CultureInfo.InvariantCulture); string probFeed = machine.ProbeFeed.ToString(CultureInfo.InvariantCulture); var result = await serial.SendCommandAsync("g91 g31 " + axisName + "-" + probDist + " F" + probFeed + " g90", DefaultProbeTimeout); if (result?.LastOrDefault()?.ReplyType.HasFlag(EReplyType.ReplyError) == false) { serial.QueueCommand("g92 " + axisName + (-probeSize).ToString(CultureInfo.InvariantCulture)); serial.QueueCommand("g91 g0" + axisName + probDistUp + " g90"); return(true); } return(false); }
public void ParseScriptAndRun(ISerial serial_device, String script_stream, int stream_size) { // Script file is empty if (string.IsNullOrEmpty(script_stream.Trim())) { Errors.LogErrorNowAndKill(new ScriptEmptyException()); //this.OnError (); return; } Script script = new Script(); XmlSerializer s = new XmlSerializer(typeof(Script)); try { using (StringReader reader = new StringReader(script_stream.Substring(0, stream_size))) { script = (Script)s.Deserialize(reader); } buildScriptActions(serial_device, script); } catch (Exception e) { if (!Errors.IsOwnException(e)) { Errors.LogErrorNowAndKill(new ScriptWrongStructureException()); // Script file has invalid format or structure } else { Errors.LogErrorNowAndKill(e); // ScriptLogfileInvalidException, ScriptActionTypeInvalidException } //this.OnError (); return; } this.Run(); }
public Action(Configuration config, ISerial serial, ActionType type, String user = "", String outputfile = "") { // outputfile = new FileInfo ( outputfile ).Name; // NO // System.IO.Path.GetFileName(outputfile)); // NO configuration = config; logger = new Logger(outputfile.Substring(outputfile.LastIndexOf('\\') + 1)); comm = new MTUComm(serial, config); this.type = type; this.user = user; comm.OnError += Comm_OnError; this.config = Singleton.Get.Configuration; // Only save reference for the current action, // not for nested or auxiliary actions ( as BasicRead ) if (this.type != ActionType.BasicRead && !Singleton.Has <Action> ()) { Singleton.Set = this; } }
public static async Task SendMacroCommandAsync(this ISerial serial, Machine machine, string commandString) { string[] separators = { @"\n" }; string[] cmds = commandString.Split(separators, StringSplitOptions.RemoveEmptyEntries); foreach (string s in cmds) { string[] infos = s.Split(':'); int axis; if (infos.Length > 1 && string.Compare(infos[0], @";probe", true) == 0 && -1 != (axis = GCodeHelper.AxisNameToIndex(infos[1]))) { if (false == await serial.SendProbeCommandAsync(machine, axis)) { break; } } else if (infos.Length == 1 && string.Compare(infos[0], @";beep", true) == 0) { SystemSounds.Beep.Play(); } else { if (s.TrimEnd().EndsWith("?")) { var result = await serial.SendCommandAsync(s.TrimEnd().TrimEnd('?'), GCodeSerial.DefaultTimeout); if (result?.LastOrDefault()?.ReplyType.HasFlag(EReplyType.ReplyError) == false) { return; } } else { await serial.SendCommandAsync(s, GCodeSerial.DefaultTimeout); } } } }
public Requests(ISerial serial) { Serial = serial; Serial.DataReceived += data => { //Очень не уверен, что это заработает. Надо дебажить! if (data.Length != 9) { return; } if ((data[0] != 0xAA) || (data[1] != 0xAB) || (data[2] != 0xAC) || (data[7] != 0x55) || (data[8] != 0x55)) { return; } var adc_data = new int[2]; adc_data[0] = (data[4] << 16) + (data[3] << 8); adc_data[1] = (data[6] << 16) + (data[5] << 8); MeasureDataHandler?.Invoke(adc_data); }; }
/**************************External interaction stuff*****************/ //connect an interface to a slot public void connect(ISerial toConnect, int slot) { CPU.SerialInterfaces[slot].disconnect(); CPU.SerialInterfaces[slot].connect(toConnect); toConnect.connect(CPU.SerialInterfaces[slot]); }
public SLIP(ISerial dev) { this.Device = dev; }
public void SetCurrent(string portName) { Current = portName.StartsWith("com") ? LocalCom : RemoteCom; }
/// <summary> /// Initializes a new instance of the <see cref="Lexi.Lexi" /> class. /// </summary> /// <param name="serial"></param> /// <param name="timeout"></param> public Lexi(ISerial serial, int timeout) { m_serial = serial; m_timeout = timeout; }
public void disconnect() { connected = null; }
public void connect(ISerial sBus) { connected = sBus; }
//TODO: //make interact with memory, sending/receiving bits etc. // 0: flags register // bits: 0: interrupt enable // 1: output buffer empty // 2: input buffer full // 3: sending // 4: receiving // 5: recipient ready // 1: receive reg // 2: send reg // 3: reserved public SerialBus(UInt16 memLocation, Int32[] mem) { memPointer = memLocation; localMemRef = mem; connected = null; }