Unit 5: Control and Programming Elements - Subjective Questions

Open-loop control: An open-loop system produces a control action without measuring the output. The controller assumes that the system behaves as expected.

• Example: A robot arm moves a motor for a fixed amount of time to reach a position without checking its actual position.
• Advantages: Simple, inexpensive, and fast.
• Limitations: Inaccurate when disturbances, load changes, or mechanical errors occur.

Closed-loop control: A closed-loop system measures the output and compares it with the desired reference value. The difference is called the error, and the controller uses this error to adjust the input.

• Example: A mobile robot uses wheel encoders to compare its actual position with the target position.
• Advantages: Better accuracy, disturbance rejection, and adaptability.
• Limitations: More expensive and complex because sensors and feedback-processing hardware are required.

The main differences are:

Open-loop control is suitable for predictable tasks, while closed-loop control is preferred when accurate positioning, speed regulation, or force control is required.

Feedback provides information about the actual state of a robot and allows the controller to correct deviations from the desired state.

A basic feedback loop contains:

• Reference input: The desired position, velocity, orientation, or force.
• Comparator: Compares the reference input with the measured output.
• Error signal: The difference between the desired and actual values, given by .
• Controller: Processes the error and generates a control command.
• Actuator: Converts the control command into mechanical motion.
• Plant: The physical robot or mechanism being controlled.
• Sensor: Measures the robot's actual output.
• Feedback path: Sends the sensor measurement back to the comparator.

Feedback improves accuracy, compensates for disturbances, and enables the robot to respond to changes in its environment.

Positive feedback adds the feedback signal to the reference signal. It increases the system response and can make the system unstable if not carefully designed.

Negative feedback subtracts the measured output from the reference signal. The error is therefore calculated as .

Negative feedback is commonly used in robotics because it:

• Reduces position and speed errors.
• Improves system accuracy.
• Compensates for variations in load and friction.
• Reduces sensitivity to disturbances and changes in system parameters.
• Improves repeatability.

However, excessive controller gain or unsuitable time delays can cause oscillations or instability. Therefore, the feedback controller must be properly tuned.

A PID controller combines proportional, integral, and derivative actions to regulate a robot variable such as position, velocity, or temperature.

Let the error be , where is the desired value and is the measured value. The control output is:

The three terms are:

• Proportional term: produces an output proportional to the present error. It gives a faster response but may leave a steady-state error.
• Integral term: accumulates past errors and removes steady-state error. Excessive integral action can cause overshoot and slow settling.
• Derivative term: predicts the future trend of the error and improves damping. It is sensitive to sensor noise.

The controller gains , , and must be selected carefully to achieve a stable and responsive robot.

Effect of proportional gain :

• Increases response speed.
• Reduces position error.
• Excessive values may produce oscillations and instability.

Effect of integral gain :

• Eliminates accumulated steady-state error.
• Improves accuracy for constant disturbances such as load torque.
• Excessive values can cause overshoot, oscillation, and integral windup.

Effect of derivative gain :

• Anticipates changes in error.
• Improves damping and reduces overshoot.
• Can make the system sensitive to measurement noise.

A practical PID design seeks a suitable balance among response time, overshoot, stability, and steady-state accuracy. Integral anti-windup and derivative filtering are often added in real robotic systems.

Motion planning is the process of finding a collision-free and feasible path for a robot to move from an initial configuration to a desired goal configuration.

The main stages are:

• Environment representation: Model the robot, obstacles, workspace, and target.
• Configuration-space representation: Represent each possible robot posture as a configuration. For a robot with several joints, the configuration is described by joint variables.
• Collision checking: Determine whether a configuration or path intersects an obstacle.
• Path generation: Find a sequence of collision-free configurations from start to goal.
• Trajectory generation: Assign time, velocity, and acceleration values to the path.
• Constraint checking: Ensure that joint limits, velocity limits, acceleration limits, and actuator capabilities are respected.
• Execution and feedback: Execute the trajectory while using sensors and controllers to correct errors.

The final motion should be safe, smooth, efficient, and physically achievable.

A path is a geometric sequence of robot configurations between a start point and a goal point. It describes where the robot should move but does not specify when each point should be reached.

A trajectory is a time-dependent path. It specifies position, velocity, and acceleration as functions of time, such as , , and .

Time parameterization is necessary because:

• Motors have maximum velocity and acceleration limits.
• Sudden changes in velocity can cause mechanical shock.
• Smooth motion is required for safety and accurate manipulation.
• The robot must coordinate multiple joints.
• Energy consumption and cycle time depend on the timing of movement.

For example, a path may be a straight line in workspace, while a trajectory defines whether the robot follows that line slowly, quickly, or with a trapezoidal velocity profile.

Common motion-planning methods include:

• Graph-search methods: The workspace or configuration space is divided into nodes and connections. Algorithms such as Dijkstra's algorithm or A* search find a route between the start and goal. These methods work well when a suitable discrete map is available.
• Potential-field method: The goal is treated as an attractive force and obstacles as repulsive forces. The robot moves in the direction of the combined force. It is computationally simple but may become trapped in local minima.
• Sampling-based methods: Algorithms such as Rapidly-exploring Random Trees and Probabilistic Roadmaps sample configurations in the configuration space and connect feasible samples. They are useful for robots with many degrees of freedom or complex obstacles.
• Interpolation methods: Joint or Cartesian points are connected using linear, polynomial, or spline interpolation. They are simple for small, known motions but do not automatically solve complex obstacle-avoidance problems.

The method is selected according to the complexity of the environment, robot degrees of freedom, real-time requirements, and available computation.

Important robot-programming concepts include:

• Joints: Individual rotary or linear axes that determine the robot configuration.
• Coordinate frames: Reference systems used to describe positions and orientations, such as the world frame, robot base frame, tool frame, and object frame.
• Waypoints: Stored positions or poses through which the robot is commanded to move.
• Variables: Data items used to store positions, velocities, sensor values, counters, and configuration settings.
• Motion commands: Instructions for joint, linear, or circular movement.
• Control structures: Conditional statements, loops, functions, and state machines used to organize task logic.
• Input and output operations: Communication with sensors, grippers, motors, and external equipment.
• Error handling: Detection of faults such as sensor failure, collision, excessive motor current, or unreachable targets, followed by a safe response.

Good robot programs are modular, readable, deterministic where required, and designed with safety checks.

Joint-space programming specifies the desired values of individual robot joints.

• Advantages: Simple inverse-kinematics requirements, direct control of actuators, and often efficient computation.
• Limitations: The end-effector path may be difficult to predict and may pass close to obstacles.
• Suitable for: Repetitive motions between known joint configurations.

Cartesian-space programming specifies the position and orientation of the end-effector in workspace coordinates.

• Advantages: The tool path is easier to understand and control, especially for welding, painting, and assembly.
• Limitations: The controller must solve inverse kinematics, and some target poses may have multiple or no valid joint solutions.
• Suitable for: Tasks requiring a specific tool orientation or geometric path.

Many industrial systems combine both approaches: Cartesian planning defines the task motion, while joint-space control executes the resulting joint trajectory.

Robotics uses several programming languages and approaches:

• C and C++: Used for real-time control, embedded systems, robot drivers, and ROS nodes because they provide high performance and low-level hardware access.
• Python: Used for prototyping, simulation, data processing, computer vision, artificial intelligence, and ROS application nodes because it supports rapid development.
• MATLAB and Simulink: Used for modeling, control-system design, simulation, and algorithm validation.
• PLC languages: Ladder Logic, Function Block Diagram, and Structured Text are used in industrial automation and safety-related machine control.
• Robot vendor languages: Manufacturer-specific languages are used to program industrial robot motion, tool actions, and production sequences.
• Assembly and low-level languages: Used when direct hardware control, very small memory usage, or strict timing is required.

Modern robotic applications commonly combine embedded C or C++, high-level Python software, simulation tools, and vendor-specific motion programs.

Embedded programming controls dedicated hardware such as a microcontroller, motor driver, or sensor interface.

A typical embedded robot program contains:

• Initialization: Configures pins, timers, analog-to-digital converters, communication interfaces, sensors, and actuators.
• Main loop: Repeatedly reads sensors, filters data, computes control actions, updates actuators, and checks system status.
• Interrupt service routines: Respond rapidly to events such as encoder pulses, timer events, communication reception, or emergency-stop signals.
• Timing control: Uses timers or a real-time scheduler to execute control tasks at a predictable sampling period.
• Communication: Exchanges data using interfaces such as UART, I2C, SPI, CAN, USB, or Ethernet.
• Safety handling: Detects overcurrent, overheating, invalid sensor data, communication loss, and limit-switch activation.

Embedded software must consider limited memory, processor speed, deterministic timing, electrical noise, and safe failure behavior.

Arduino is an open-source electronics platform based on microcontroller boards and a simplified programming environment.

Its main features include:

• A microcontroller for executing embedded programs.
• Digital input and output pins for switches, LEDs, motor drivers, and control signals.
• Analog input pins for sensors such as potentiometers and light sensors.
• Timers, pulse-width modulation, and serial communication interfaces.
• A USB connection for programming and serial monitoring.
• A large ecosystem of libraries, shields, and example programs.
• A programming environment based mainly on C and C++.

In robotics, Arduino is used for reading sensors, controlling servos and DC motors through drivers, operating small mobile robots, and testing control algorithms. It is inexpensive and easy to learn, but it has limited processing power, memory, and operating-system support compared with a single-board computer.

Raspberry Pi is a small single-board computer that can run a complete operating system such as Linux. It generally provides more processing capability and connectivity than a microcontroller board.

A common robotic architecture uses Arduino for low-level motor and sensor control and Raspberry Pi for high-level decision-making, image processing, communication, and user-interface functions.

Arduino and Raspberry Pi can be combined to divide robotic functions according to their strengths.

• The Arduino reads encoders, ultrasonic sensors, switches, and other low-level devices.
• The Arduino performs time-sensitive motor control and generates PWM signals through suitable motor drivers.
• The Raspberry Pi performs localization, mapping, image processing, navigation, task planning, and user-interface operations.
• The Raspberry Pi sends desired wheel velocities or motor commands to the Arduino through USB serial, UART, I2C, or another communication link.
• The Arduino returns measured velocities, encoder counts, battery status, and fault conditions.
• The Raspberry Pi uses this feedback to update its navigation and control decisions.

A reliable design defines a clear communication protocol containing message formats, timestamps, checksums where needed, command limits, and behavior for communication failure.

ROS, or Robot Operating System, is a software framework and collection of tools, libraries, and conventions for building robotic applications. It is not a traditional operating system; it provides communication and development infrastructure above an operating system such as Linux.

• Node: An executable process that performs a specific function, such as reading a camera or controlling a motor.
• Topic: A named communication channel used for asynchronous publish-subscribe data exchange.
• Message: A structured data type transmitted over a topic.
• Service: A request-response communication mechanism used for operations that require an immediate result.
• Action: A mechanism for long-running tasks that provides feedback and supports cancellation.
• Package: A unit containing related source code, configuration files, launch files, message definitions, and documentation.

ROS promotes modularity, code reuse, distributed processing, hardware abstraction, simulation, visualization, and integration of sensors and algorithms.

A typical ROS application is organized as a network of cooperating nodes.

1. A camera or lidar driver node acquires sensor data.
2. The driver publishes the data on a topic using a standard message type.
3. A perception node subscribes to the topic and identifies objects, obstacles, or robot features.
4. A localization or mapping node combines sensor data with odometry and publishes the robot pose or map.
5. A planner node uses the map, robot pose, and goal to generate a path or trajectory.
6. A controller node converts the trajectory into velocity or joint commands.
7. A hardware-interface node sends commands to the motors and publishes feedback such as encoder measurements.

Launch files, configuration parameters, transforms, and visualization tools help manage and inspect this distributed system. The system should also define appropriate update rates, timestamps, coordinate frames, and fault responses.

A coordinate frame is a reference system used to describe the position and orientation of an object. A robotic system may use frames such as:

• World or map frame.
• Odometry frame.
• Robot base frame.
• Sensor frame.
• End-effector or tool frame.

A transformation specifies the translation and rotation between two frames. If a point is represented in one frame, a transformation converts it into another frame so that data from different sensors and robot components can be combined.

Frames are important because:

• Sensor measurements must be related to the robot body.
• A target object must be expressed in a planning frame.
• Motion planners need consistent positions and orientations.
• Multiple sensors can be fused correctly.
• Incorrect transformations can cause inaccurate localization, collisions, or failed grasping.

In three-dimensional robotics, transformations are commonly represented using homogeneous transformation matrices, rotation matrices, quaternions, or equivalent pose representations.

A Human-Robot Interface is the hardware and software through which a person communicates with, supervises, or collaborates with a robot.

The major objectives are:

• Usability: Commands should be easy to understand and operate.
• Safety: The interface must help prevent unintended motion and provide emergency-stop access.
• Feedback: The robot should communicate its state, progress, warnings, and faults clearly.
• Predictability: The operator should understand what the robot will do after a command.
• Efficiency: Common tasks should require few steps and minimal unnecessary input.
• Accessibility: The system should support the abilities and needs of different users.
• Trust and transparency: The robot should indicate its intentions and limitations.
• Error recovery: Users should be able to pause, correct, undo, or safely restart tasks.

Examples include teach pendants, graphical interfaces, voice commands, gesture interfaces, mobile applications, and physical control panels.