1. Introduction and Motivation

The Line Bot is an autonomous, line-following mobile robot developed as the final project for the Fab Academy 2025 cycle. The motivation behind the project is to demonstrate how embedded systems, digital fabrication, and sensor-actuator integration can be combined into a compact, educational robotics platform.

Autonomous robots that can follow a designated path are often the first step in teaching robotic behavior, path planning, and feedback-based control systems. The project embodies this concept while enhancing it with modern tools like custom PCB design, ESP32-based microcontroller integration, and real-time data display through an OLED interface.

The bot showcases the fusion of mechanical, electrical, and programming skills required in modern embedded product development.

2. Project Objectives

The primary goals of the Line Bot project include:

• To design and fabricate a compact robot that can follow a line autonomously using IR sensors.
• To develop a custom microcontroller-based electronics system using the XIAO ESP32-C3.
• To fabricate a custom PCB integrating motor drivers and IR sensors.
• To implement reliable line-following logic using PWM and real-time feedback.
• To visualize sensor data using an onboard OLED display.
• To validate the system through performance testing in different conditions.
• To document all aspects of design, development, testing, and learning.

Line Follower Bot Gantt Chart

Subsystem 1: Mechanical Design and Fabrication

Subsystem 2: On-Bot PCB Design

Subsystem 3: Sensor + Line Following Logic

Subsystem 4: Bot Control Software

Subsystem 5: Testing and Final Tuning

3. Functional Requirements

4. Bill of Materials in $

5. System Architecture

All circuits share Common Ground to ensure stable logic references.

6. Mechanical Design

The body of the robot was designed in CAD and laser cut using 3mm acrylic sheet. The design considerations included:

• Adequate spacing between wheels and sensors.
• Firm placement of motor driver and MCU.
• Slots for wiring and connectors.
• Mounting holes for sensors to face the ground at a proper angle.

3D Design

Chassis Design and Sensor base plate attachment Design. I have designed the chassis and sensor base plate attachment using SolidWorks

Then I have imported the 3d Design which already exists in Online GrabCAD

7. Laser Cutting Process

The BO motors were mounted using acrylic brackets, and the IR sensor array was placed at the front underside. The final structure ensured good balance, durability, and access for debugging.

8. Electronics Design

A complete single-layer SMD PCB was designed:

• Schematic Diagram of my Circuit which mainly focused on the Sensor Array


• Power regulation input
• JST connectors for:
  • Motor control pins → L298N
  • Sensor digital inputs (5 signals)
  • 5V regulated output to sensors

Schematic to PCB design

Fabrication Process:

• Designed in KiCad
• Milled in FabLab PCB machine
• Fully SMD assembly performed manually

The system wiring was planned carefully to ensure minimal noise, secure connections, and clear power/data paths. The use of JST connectors simplified replacements and debugging.

Design decisions focused on minimizing space, ensuring low EMI, and clean signal routing. The board was fabricated using PCB milling tools in the Fab Lab, and then soldered by hand. Careful routing allowed a single-layer PCB, reducing cost and complexity.

Testing was conducted using multimeters, continuity tests, and live firmware to confirm all traces and headers were correctly connected before integration.

9. Assembly Process

The mechanical and electrical systems were integrated step-by-step:

• Chassis Construction: Laser-cut acrylic parts were assembled using bolts and plastic spacers to form the robot frame.
• Motor Mounting: BO motors were attached to the chassis using acrylic brackets and secured with fasteners.
• PCB Installation: The custom PCB was fixed to the frame with standoffs and screws to minimize vibration.
• Sensor and Display Setup: The IR sensor module was mounted at the front bottom, and the OLED was fixed on the top for easy visibility.
• Wiring and Connections: JST connectors and male-female headers were used for quick plug-and-play setup.
• Battery Housing: The Li-ion battery and its holder were placed centrally to maintain weight balance.

All systems were connected and verified using multimeter continuity checks and boot-time LED indicators.

Assembly Video

Some Failures occured in wheels while connecting the motors to the chassis. So I additionally attached the motors to the chassis using 3D printed brackets.

9. Pin Connection Details

Common Ground between all modules

10. Software Development

Programming Platform: Arduino IDE
Control Algorithm: PID-based differential drive

Key logic:

• Line array outputs 5 digital signals
• Weighted error calculated for correction
• Motor speeds varied accordingly:
  • Left fast / Right slow → Turn right
  • Right fast / Left slow → Turn left

Sensor Calibration

I have used a code to calibrate the sensors. which shows the output as when the sensor is on the line it keeps on.

                        
                            #define S1 D0
                            #define S2 D1
                            #define S3 D2
                            #define S4 D3
                            #define S5 D4

                            void setup() {
                            Serial.begin(115200);
                            pinMode(S1, INPUT);
                            pinMode(S2, INPUT);
                            pinMode(S3, INPUT);
                            pinMode(S4, INPUT);
                            pinMode(S5, INPUT);
                            }

                            void loop() {
                            Serial.print(digitalRead(S1)); Serial.print(" ");
                            Serial.print(digitalRead(S2)); Serial.print(" ");
                            Serial.print(digitalRead(S3)); Serial.print(" ");
                            Serial.print(digitalRead(S4)); Serial.print(" ");
                            Serial.println(digitalRead(S5));
                            delay(200);
                            }

                        
                    

Motor Testing and Calibration

To know the motor maximum consumption I have tested motor at various PWM values and then and that supports the pin connection I have given to the code

                        
                            #define ENA D6
                            #define IN1 D7
                            #define IN2 D5
                            #define ENB D10
                            #define IN3 D9
                            #define IN4 D8

                            int testSpeed = 120;   // Safe test speed

                            void setup() {
                            Serial.begin(115200);
                            Serial.println("Motor Test Starting...");

                            pinMode(ENA, OUTPUT);
                            pinMode(IN1, OUTPUT);
                            pinMode(IN2, OUTPUT);

                            pinMode(ENB, OUTPUT);
                            pinMode(IN3, OUTPUT);
                            pinMode(IN4, OUTPUT);
                            }

                            void forward(int speedL, int speedR) {
                            digitalWrite(IN1, HIGH);
                            digitalWrite(IN2, LOW);
                            digitalWrite(IN3, HIGH);
                            digitalWrite(IN4, LOW);

                            analogWrite(ENA, speedR);
                            analogWrite(ENB, speedL);
                            }

                            void backward(int speedL, int speedR) {
                            digitalWrite(IN1, LOW);
                            digitalWrite(IN2, HIGH);
                            digitalWrite(IN3, LOW);
                            digitalWrite(IN4, HIGH);

                            analogWrite(ENA, speedR);
                            analogWrite(ENB, speedL);
                            }

                            void leftTurn() {
                            digitalWrite(IN1, LOW);
                            digitalWrite(IN2, HIGH);
                            digitalWrite(IN3, HIGH);
                            digitalWrite(IN4, LOW);

                            analogWrite(ENA, testSpeed);
                            analogWrite(ENB, testSpeed);
                            }

                            void rightTurn() {
                            digitalWrite(IN1, HIGH);
                            digitalWrite(IN2, LOW);
                            digitalWrite(IN3, LOW);
                            digitalWrite(IN4, HIGH);

                            analogWrite(ENA, testSpeed);
                            analogWrite(ENB, testSpeed);
                            }

                            void stopMotor() {
                            analogWrite(ENA, 0);
                            analogWrite(ENB, 0);
                            }

                            void loop() {

                                Serial.println("Forward");
                                forward(testSpeed, testSpeed);
                                delay(2000);

                                Serial.println("Backward");
                                backward(testSpeed, testSpeed);
                                delay(2000);

                                Serial.println("Left");
                                leftTurn();
                                delay(2000);

                                Serial.println("Right");
                                rightTurn();
                                delay(2000);

                                Serial.println("Stop");
                                stopMotor();
                                delay(2000);
                            }
                        
                    

Final Working Code

                        
                            // Line Sensors
                            #define S1 D0   // GPIO2
                            #define S2 D1   // GPIO3
                            #define S3 D2   // GPIO4
                            #define S4 D3   // GPIO5
                            #define S5 D4   // GPIO6

                            // Motor Driver (L298N)
                            // Right Motor
                            #define ENA D6   // GPIO21 (PWM OK)
                            #define IN1 D7   // GPIO20
                            #define IN2 D5   // GPIO7

                            // Left Motor
                            #define ENB D10  // GPIO10 (PWM OK)
                            #define IN3 D9   // GPIO9
                            #define IN4 D8   // GPIO8

                       
                            int baseSpeed = 110;
                            int turnSpeed = 90;

           
                            void setup() {
                            Serial.begin(115200);

                            pinMode(ENA, OUTPUT);
                            pinMode(IN1, OUTPUT);
                            pinMode(IN2, OUTPUT);

                            pinMode(ENB, OUTPUT);
                            pinMode(IN3, OUTPUT);
                            pinMode(IN4, OUTPUT);

                            pinMode(S1, INPUT);
                            pinMode(S2, INPUT);
                            pinMode(S3, INPUT);
                            pinMode(S4, INPUT);
                            pinMode(S5, INPUT);

                            Serial.println("Line Follower Ready");
                            }

                      
                            void drive(int left, int right) {

                            if (right >= 0) {
                                digitalWrite(IN1, HIGH);
                                digitalWrite(IN2, LOW);
                            } else {
                                digitalWrite(IN1, LOW);
                                digitalWrite(IN2, HIGH);
                            }

                            if (left >= 0) {
                                digitalWrite(IN3, HIGH);
                                digitalWrite(IN4, LOW);
                            } else {
                                digitalWrite(IN3, LOW);
                                digitalWrite(IN4, HIGH);
                            }

                            analogWrite(ENA, abs(right));
                            analogWrite(ENB, abs(left));
                            }

                            void stopMotor() {
                            analogWrite(ENA, 0);
                            analogWrite(ENB, 0);
                            }

                            void loop() {

                            int s1 = digitalRead(S1);
                            int s2 = digitalRead(S2);
                            int s3 = digitalRead(S3);
                            int s4 = digitalRead(S4);
                            int s5 = digitalRead(S5);

                            Serial.print(s1); Serial.print(" ");
                            Serial.print(s2); Serial.print(" ");
                            Serial.print(s3); Serial.print(" ");
                            Serial.print(s4); Serial.print(" ");
                            Serial.println(s5);

                            if (s3 == 1) {
                                drive(baseSpeed, baseSpeed);
                            }
                            else if (s4 == 1 || s5 == 1) {
                                drive(baseSpeed - turnSpeed, baseSpeed + turnSpeed);
                            }
                            else if (s2 == 1 || s1 == 1) {
                                drive(baseSpeed + turnSpeed, baseSpeed - turnSpeed);
                            }
                            else {
                                stopMotor();
                            }

                            delay(5);
                            }

                        
                

11. Major Failures & Learnings

These failures significantly improved final performance.

12. Testing Procedure

Testing area: Smooth white floor with black electrical tape path

Track included:

• Straight paths
• Multiple turns
• Tight curves
• Cross-line situations

Tracking Performance:

• Fast speed with smooth corrections
• Accurately follows intersections by prioritizing center signal
• Recover behavior: realigns if line temporarily lost

13. Safety Measures

• Battery protection module for 18650 cells
• Proper insulation of high-current lines
• Chassis edges rounded during laser cutting

14. Final Results

15. Learning Outcomes

• Embedded control
• PCB design & manufacturing
• Motor actuation & differential drive
• Laser cutting + 3D printing
• Power distribution + EMI isolation
• PID control tuning
• System-level integration

16. Future Improvements

This prototype forms the foundation for a commercial mobile delivery robot.

17. Conclusion

The Line Bot successfully demonstrates a functional autonomous line-guided delivery robot. The custom electronics, tuned control system, and optimized mechanical design enabled high-speed and accurate tracking. This project meets the Fab Academy goal of designing, prototyping, and documenting a complete integrated system, while establishing a roadmap for real-world deployment.