/// <summary> /// Attempt to parse input as a distance. Text inputs must be a number, followed by an optional unit, to be parsed as /// a distance. /// </summary> /// <param name="text">Input to parse</param> /// <param name="mob"></param> /// <param name="distance">Distance to move, in millimeters. If -1, then parsing failed.</param> /// <param name="startIndex">Where the distance is expected to be.</param> /// <returns>Number of words successfully parsed. 0 if failed, up to 2 if succeeded. </returns> public static int ParseAsDistance(StringWords text, out int distance, out MovementUnit unit, int startIndex = 0, int endIndex = 0) { distance = -1; unit = MovementUnit.NoDistance; if (startIndex >= text.Segments.Length) { return(0); } string firstWord, secondWord = null; firstWord = text.Segments[startIndex]; if (startIndex < text.Segments.Length - 1) { secondWord = text.Segments[startIndex + 1]; } int magnitude, distanceType; if (!int.TryParse(firstWord, out magnitude)) { if (secondWord == null || !int.TryParse(secondWord, out magnitude)) { return(0); } //firstWord MUST be a valid distance enum. if (FindAPreposition(text, typeof(Distances), out distanceType, startIndex, startIndex + 1) == -1) { return(0); } } else { if (secondWord == null || FindAPreposition(text, typeof(Distances), out distanceType, startIndex + 1, startIndex + 2) == -1) { distanceType = (int)Distances.Default; secondWord = null; } } if (distanceType >= (int)Distances.Default) { distance = magnitude; unit = distanceType == (int)Distances.Default ? MovementUnit.Unspecified : distanceType == (int)Distances.Step ? MovementUnit.Step : MovementUnit.NoDistance; } else { distance = (int)((magnitude * (long)distanceConversions[distanceType]) / 10); unit = MovementUnit.Absolute; } return(secondWord == null ? 2 : 1); }
private void Move(double amount, MovementUnit unit, int[][] sequences) { //1revolution = 512steps int steps = (int)Math.Floor(amount * (unit == MovementUnit.Step ? 1 : 512)); for (int step = 0; step < steps; step++) { foreach (var sequence in sequences) { for (int i = 0; i < Pins.Length; i++) { Pins[i].Write(sequence[i] == 0 ? GpioPinValue.Low : GpioPinValue.High); } Task.Delay(1).Wait(); //Sleep(0.001) } } }
/// <summary> /// Attempt to parse user's input text as a direction / distance. /// </summary> /// <param name="text">Full input to parse</param> /// <param name="startIndex">Index of first word to try to parse (inclusive). </param> /// <param name="endIndex">Index of last word to try to parse (exclusive). If the text is found, this will be updated /// to after the last word found (first index not belonging to the MovementDirection)</param> /// <param name="requireDirection">If true, parsing will return failure if no direction component is found.</param> /// <param name="requireDistance">If true, parsing will return failure if no distance component is found.</param> /// <param name="getDistance">If true, distance may be parsed. This is ignored (assumed true) if requireDistance is true.</param> /// <returns>The direction and distance parsed from the input text.</returns> public static MovementDirection ParseAsDirection(StringWords text, int startIndex, ref int endIndex, bool requireDirection = false, bool requireDistance = false, bool getDirection = true, bool getDistance = true) { text.ValidateEndIndex(ref endIndex); getDistance |= requireDistance; Directions foundDirection = Directions.NoDirection; //List<Directions> directions = new List<Directions>(); KeyValuePair <string[][], Directions[]> directionOptions = DirectionCommand.GetDirectionOptions(); string[][] directionStrings = directionOptions.Key; Directions[] directionValues = directionOptions.Value; int foundDistance = -1; MovementUnit foundUnit = MovementUnit.NoDistance; int i = startIndex; for (; i < endIndex; i++) { string word = text.Segments[i]; if (foundDirection == Directions.NoDirection) { int found = MatchString(directionStrings, text.Segments, ref i); if (found != -1) { foundDirection = directionValues[found]; //Loop will increment but i is already the correct value after MatchString, i--; //decrement here to 'skip' the increment. continue; } } if (getDistance && foundUnit == MovementUnit.NoDistance) { int distanceWords = ParseAsDistance(text, out foundDistance, out foundUnit, i, Math.Min(i + 1, endIndex - 1)); if (distanceWords != 0) { if (distanceWords == 2) { i++; } continue; } } break; } if (foundDirection == Directions.NoDirection && requireDirection) { return(null); } if (foundUnit == MovementUnit.NoDistance && requireDistance) { return(null); } if (foundDirection == Directions.NoDirection && foundUnit == MovementUnit.NoDistance) { return(null); } endIndex = i; return(new MovementDirection() { direction = foundDirection, distanceCount = foundDistance, distanceUnit = foundUnit }); }
public void Forward(double amount, MovementUnit unit) { Move(amount < 0 ? 0 : amount, unit, ClockwiseSequences); }
public void Backward(double amount, MovementUnit unit) { Move(amount > 0 ? 0 : amount, unit, AntiClockwiseSequences); }