Beispiel #1
0
        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 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);
        }
Beispiel #3
0
        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);
                    }
                }
            }
        }
Beispiel #4
0
        /// <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);
        }
Beispiel #5
0
        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);
        }
Beispiel #6
0
        public static async Task EraseEepromValuesAsync(this ISerial serial)
        {
            await serial.SendCommandAsync(@"$!", DefaultEpromTimeout);

            await serial.SendCommandAsync(@"$0=0", DefaultEpromTimeout);
        }
Beispiel #7
0
        public static async Task WriteEepromValuesAsync(this ISerial serial, EepromV1 ee)
        {
            await serial.SendCommandAsync(@"$!", DefaultEpromTimeout);

            await serial.SendCommandsAsync(ee.ToGCode(), DefaultEpromTimeout);
        }