State Machines in LabVIEW: Flexible Code for FRC Lifter Mechanisms

FRC robots use three main wire types: power (red/black), CAN (information), and Ethernet. The battery (12 amp hour) supplies all power through positive and negative terminals. The main breaker intercepts the positive line with a red disconnect button and black reconnect switch. The Power Distribution Panel (PDP) has 16 slots (8 for 40-amp, 8 for 30-amp) distributing power to components. Motor controllers (Talons, Victors) regulate power delivery based on CAN signals. The radio connects to the laptop like Wi-Fi, while the Voltage Regulator Module (VRM) provides stable 12-volt power. The RoboRIO is the robot's main brain where code is stored and executed. The Robot Signal Light (RSL) indicates RoboRIO power status. The Pneumatics Control Module (PCM) handles all pneumatic components. The CAN system distributes code to all components. The Inertial Measurement Unit (IMU) measures robot orientation and should be placed centrally. Encoders count ticks per motor shaft revolution for precise control. The Limelight vision system uses a green light to detect reflective tape and adjusts robot yaw for targeting.

Motors convert electrical energy into mechanical motion with specific characteristics including torque curves and current draw. When motors stall, they draw excessive current that can trip breakers and cause position loss. Encoders measure shaft rotations and come in optical and magnetic types. Magnetic encoders are preferred for FRC because they are contactless, resistant to dust, and provide LED alignment indicators. The Talon SRX is the recommended motor controller for FRC due to its onboard encoder port enabling precise closed-loop control. Other controllers like the Victor SPX lack onboard encoder ports and current sensing, making them unsuitable for systems requiring monitoring.

An FRC robot's electrical system manages power flow from the battery through the power distribution unit to motors and sensors, utilizing components like motor controllers (Spark Max for Neo motors, Talon for high-power applications), encoders for position feedback, IMU sensors for orientation, limit switches for safety, and CAN bus for communication between components, with proper cable management and pre-match electronic checklists being essential for reliable robot operation.

Motor controllers in FRC convert battery power into controlled motor output by receiving PWM signals from the Robo Rio, which vary pulse width to determine motor speed and direction; they enable precise control for robot subsystems like arms, wheels, and intakes, with brushed motors using two-wire controllers and brushless motors requiring three-wire controllers, while CAN-enabled controllers offer an alternative communication method.

The FRC robot system integrates multiple interconnected components: the RobotRIO processor, driver station with Xbox controllers, network table for bidirectional communication, field management system for mode control, and co-processors like Limelight for vision. The driver station interface enables viewing robot code, changing operation modes, and enabling/disabling the robot for safety. Hardware includes motor controllers (CAN Spark Max) connected to NEO motors with built-in encoders, the Power Distribution Panel for powering components, and sensors like gyroscopes and limit switches. Programming fundamentals involve dividing hardware into subsystems (drive, claw, pivot) for abstraction, using commands for coordinated actions, controller bindings for joystick inputs, and PID control for precise mechanism positioning. These foundational concepts enable safe, coordinated robot operation during competition.

This comprehensive section covers the theoretical foundations of state machines: states represent sequential actions, Moore automata have outputs dependent only on current state, state variables are boolean, and the number of possible states equals 2^n where n is the number of state variables. State diagrams use ellipses for states with outputs and directed arrows for transitions with input conditions. The initial state is marked with a special arrow. Input values are binary (0/1) with LSB on right, MSB on left. Output values appear inside state ellipses. The state transition function determines the next state based on current state and inputs.

A finite state machine consists of: (1) States (S): the possible configurations of the machine; (2) Inputs (Σ): the signals that trigger state transitions; (3) Outputs (Δ): the responses produced by the machine; (4) Initial state (q₀): the starting configuration; (5) Transition function (δ): maps current state and input to next state; (6) Output function (ω): maps current state and input to output.

A state machine is a computational model that processes inputs and produces outputs based on its internal state. The core concepts include: (1) Present state - the current condition of the machine; (2) Input - external signals that influence behavior; (3) Next state - the resulting condition after processing input; (4) Output - the result produced by the machine. State machines are essential for designing sequential circuits where output depends on past inputs through stored state information.

State machines have inputs (inputs) and outputs (outputs). The inputs are the signals that control state transitions, such as the start signal and input signals (اي 3, اي 4). The outputs are the signals that represent the current state, such as the state outputs (تي نوت, تي 1, تي 2). The state table shows how inputs affect state transitions and how outputs are generated.

This section covers the fundamental concepts of state machines including inputs and transitions. Inputs are the main drivers that move a state machine forward, functioning as switches, signals, or dials that determine when to change states. Four input types exist: Boolean for toggle actions, Event for instant triggers, Numeric for numerical values, and String for labels. Transitions carry the state machine between states based on input conditions. The global state serves as the initial state when managing multiple possibilities. Without proper conditions, states activate immediately upon playback rather than waiting for user input.

This section covers three essential LabVIEW data types. Enums appear like strings but store numeric values, useful for discrete states. Arrays are ordered collections of same-type elements, with dimensions identified by index displays (1D, 2D, 3D) and wire patterns. Clusters group different data types into single units, essential for organizing multiple inputs/outputs in sub-VIs. Each type has specific color coding and usage patterns.

Enumerated type controls (enums) in LabVIEW provide users with a list of selectable items, differing from ring controls in six key ways: (1) enums include data type information about numeric values and their corresponding strings, while ring controls are numeric-only; (2) enums use 8-, 16-, or 32-bit unsigned integers, while rings can use various numeric representations including signed and floating-point types; (3) enums cannot accept undefined user values or assign specific numeric values to items; (4) enum items can only be edited at edit time, while ring items can be modified at runtime using Property Nodes; (5) when wired to a Case structure, enums match cases to string values while rings match to numeric values; (6) arithmetic functions treat enums like unsigned integers, with Increment cycling from last to first value and Decrement cycling from first to last value. When coercing values to enums, negative numbers become the first value, out-of-range positives become the last value, and floating-point values are rounded to the nearest numeric value. When wiring enums to numeric indicators, the numeric value represents the item's position. To ensure consistency when modifying enum items, always create a type definition.

Enums (Enumerated Controls) in LabVIEW are a combination of numeric and string values that provide a more readable and user-friendly way to represent a fixed set of data options, such as months of the year, instead of using raw numeric values; they can be customized by editing items, adding or removing options, and selecting appropriate data representations (u8, u16, or u32) based on the required range.

LabVIEW includes additional data types beyond the basic ones: Waveforms (represented by brownish wires) for time-series data, and Clusters (represented by thicker, differently styled pink wires) for grouping multiple data types together. The video notes that enums have wire styling similar to integers but with different control and indicator appearances. Understanding these data types is essential for handling complex data structures in LabVIEW programs.

This section covers strings and enums as important data types in LabVIEW. Strings are sequences of ASCII characters providing platform-independent data handling, with four display formats: normal, big-endian code, password, and hex display. Enums (enumerated types) are created by right-clicking on the front panel and selecting 'Enum'. Each enum item represents a pair of values: a string value and a 16-bit integer number. Enums give users a list of items to select from and make strings equivalent to numbers, which are easier to manipulate on the block diagram. Users can rearrange enum items, disable or enable items as needed.