Every great project begins with a single challenge. For the GUCHI NANO, the goal was clear: design a compact, desktop-friendly mini robot that packs rich, menu-driven interactive modes and essential robotics sensors into an affordable, consumer-ready footprint.
Robotics education shouldn't cost a fortune. To make this accessible to students, schools, and hobbyists, I purposefully selected highly cost-effective, standard components. The true engineering feat was optimizing the software and hardware harmony so that every single feature, sensor sweep, screen asset, and mechanical action ran seamlessly under a single, unified firmware package.
The journey from concept to final product evolved through dedicated engineering steps:
- The Zero-PCB Baseline: The very first prototype was hand-wired on a blank prototyping matrix board. The structural footprint was tightly engineered around the largest onboard component: a high-capacity 18650 Li-ion rechargeable battery. This integration eliminated the hassle of changing traditional AA batteries.
- The Physical Constraint Challenge: Every component was packed like a puzzle, ensuring the final robot remained pocket-sized while still housing an OLED display, structural keypad inputs, and multiple proximity sensors.
Overcoming the Motion Control Myth
In industrial robotics, standard protocol dictates that a machine cannot achieve precise mechanical movement without expensive closed-loop hardware feedback (such as active optical encoders or magnetic motor feedback loops). I took this industry limitation as a personal challenge.
Through rigorous bench testing and math calibration, I successfully bypassed the need for expensive encoders. The secret lies in a custom-developed, dual-phase hardware calibration engine:
- Linear Time-and-Distance Compensation: The software systematically isolates the left and right N20 micro motors, tuning their performance separately for identical forward and backward trajectory tracking.
- Angular Auto-Rotation Tuning: The chassis undergoes a software-guided self-rotation phase to establish exactly how many milliseconds of motor burst equates to absolute rotational angles.
Precise Geometric Execution
Because of this calibration grid, the robot's physical movement is converted into easily understandable software units. Instead of guessing raw motor runtimes, the movements are driven by fixed programmatic steps and precise angular degrees:
- Linear Steps: forward(0, 0, oneStepTime); // onestep time is calibrated to 10cm.
- Angular Turns: rightTurn(0, 0, degToTime(30)); // Instantly turns exactly 30 degrees
This high level of software precision allows GUCHI NANO to physically trace clean, recognizable geometric shapes—including squares, circles, triangles, and intricate star patterns—on flat surfaces using its own tire tracks. It stands as definitive proof that smart code can successfully solve costly hardware challenges.
However, real-world physics constantly interacts with open-loop systems. A variety of environmental and mechanical factors—such as structural gear backlash, robot body inertia during sudden stops, variations in wheel friction, accumulated desktop dirt, and normal wear and tear over extended usage—can gradually distort physical tracking over time. When these physical deviations begin to alter your geometric paths, running the built-in calibration sequence will instantly restore the robot's baseline spatial accuracy.
The core philosophy of GUCHI NANO is interactivity. Controlled entirely by the 6-button direct keypad, the user can navigate through an on-screen menu displayed on the crisp SH1106 OLED screen. Each mode transforms the robot into a completely different interactive tool.
🕹️ Mode 1: Line Follower Mode
In this mode, the robot tracks a path autonomously. It uses a front-mounted array of three TCRT5000 IR sensors to follow a track (like a black line drawn on a white floor).
- How it works: The code constantly reads the left, center, and right sensors.
- Screen feedback: The OLED display shows you the live sensor data thresholds and the active direction commands (like MOVING FORWARD or CORRECTING LEFT). This helps kids instantly see how sensor inputs change the motor movements.
🦇 Mode 2: Obstacle Avoidance Mode
This turns the robot into an explorer that avoids bumping into things using its front HC-SR04 ultrasonic sonar sensor.
- How it works: The sensor pings the area in front of it to calculate exactly how many centimeters away the nearest object is.
- Screen feedback: The OLED screen shows the live distance calculation in real-time. If the robot gets too close to a wall, it stops its inertia, turns at a precise angle using the calibration engine, and keeps driving forward.
🏃♂️ Mode 3: Obstacle Follow Mode
Instead of running away from objects, the robot uses the HC-SR04 sonar sensor to lock onto a target—like your hand or your foot—and follows it around smoothly like a pet.
- How it works: The code sets a tracking "sweet spot" zone. If you move your hand further away, the robot speeds up its motors to catch up. If you push your hand closer to the robot, it automatically reverses to maintain its distance.
- Screen feedback: The OLED monitors the target lock status and displays live distance alerts.
📐 Mode 4: Draw Shapes Mode
This is the mode where the robot shows off its precision steps by drawing geometric art on paper or a whiteboard.
- How it works: You enter the mode and select your shape from the sub-menu (like a circle, star, or square). The screen will display a preview of the shape.
- Interaction: The user inserts a sketch pen or marker right into the center axis holder of the chassis and presses the play button.
- The Delay: The moment you hit play, the robot waits for 3 seconds while showing a countdown animation on the screen. This gives you plenty of time to take your hands off the robot before it starts drawing the selected shape out on the paper.
🏡 Mode 5: Path Follow & Return to Home Mode
This mode is an introduction to path planning and memory mapping. You plan a custom route directly on the Screen using the physical tactile arrow buttons, and the robot drives the course before navigating back on its own.
- How it works: The code stores your button presses into a memory array as step vectors. When you press play, Guchi reads this data sequentially to follow your path and reach the goal. Once at the destination, the internal navigation engine instantly flips the coordinate map, automatically calculates the shortest reverse path, executes a precise 180-degree U-turn, and retraces its steps back to the start.
- Screen feedback: The OLED screen draws your custom route line-by-line as you click the arrow keys.
👀 Mode 6: Guchi Eyes
This mode brings the robot to life by transforming the screen into an animated EYE character that reacts dynamically to its surroundings using the sonar sensor.
- How it works: The code continuously reads distance data from the front HC-SR04 sonar sensor. If it detects any object entering its field of view, it immediately reacts to it.
- Screen feedback: The OLED screen entirely dedicates itself to rendering expressive, smooth-moving digital eyes, shifting shapes and expressions to bring the Guchi character to life.
🔧 Mode 6: Calibrating Your GUCHI NANO (Advanced Tuning)
Because real-world factors like gear backlash, wheel wear, and surface friction will affect physical movement over time, your robot may occasionally drift. This step covers how to use the built-in calibration menus to rewrite the system memory and restore factory-straight movement.
Step 1: Straight Line Calibration (Forward & Backward)
This sequence balances the power output between the left and right N20 micro motors so the robot drives down a dead-straight trajectory without veering.
- Set Up the Canvas: Insert a fine sketch pen or marker into the center axis holder of the chassis and place the robot down on a clean sheet of paper.
- Test Forward Motion: Use the keypad to navigate to the Forward Calibration option on the screen menu and press the > (Next) button. Guchi will immediately execute a 2-step forward drive sequence and return.
- Adjust the Trims: Inspect the ink lines drawn on your paper. If the robot drifts to one side, use the arrow buttons to tweak the left (Lf) or right (Rf) trim values. (Note: Focus only on making the forward-bound lines perfectly straight; ignore the return path lines for this step). Press the > button to re-run the test drive after making adjustments.
- Commit to Storage: Once the lines are perfectly straight and identical in length, press the PLAY button. The code will instantly commit these trim settings to the Arduino's non-volatile EEPROM memory so they stay saved even when powered off.
- Calibrate Backward Motion: Switch your menu selection to Backward Calibration and repeat this exact drawing and trimming process to lock in your Lb and Rb reverse baseline vectors.
Step 2: Rotational Angle Calibration
This sequence syncs the auto-rotation engine so the firmware knows exactly how many milliseconds of motor pulse equates to an absolute 90-degree or 180-degree turn.
- Set Up the Target Track: Secure a straight strip of standard black electrical tape onto a flat floor or table surface.
- Position the Robot: Open the Angle Calibration menu on the OLED display. Manually place the robot down so its center TCRT5000 IR sensor sits directly over the center axis of the black tape.
- Trigger Auto-Calibration: Press the selection button. The robot will automatically engage its motors to rotate left and right, actively reading the contrast changes to calculate its own rotational physics dynamically.
- Save and Lock: Keep your hands clear of the chassis during the automated sweep. Wait until the onboard LED indicator transitions from flashing to a solid, steady glow. Once lit, press the PLAY button to flash the new timing parameters directly into the internal EEPROM. Your GUCHI NANO is now fully calibrated!
📊 Mode 8: Guchi Stats
To move accurately without expensive feedback encoders, Guchi relies entirely on its pre-calibrated time and distance configuration array. This mode turns the OLED display into a real-time diagnostic dashboard, showing you the exact values driving the motion algorithms.
- How it works: The code pauses all autonomous tracking modes and prints the raw system variables directly to the screen. This allows you to monitor the internal mathematics of the robot, track live power levels, and see exactly when the robot needs a mechanical tune-up due to normal gear or wheel wear.
- Screen feedback: The screen maps out your entire core telemetry layout on a single page:
- Lf / Rf / Lb / Rb (Motor Trims): These are the baseline offset values used to balance the two motors so the chassis drives in a perfectly straight line. Lf/Rf handle forward correction, while Lb/Rb handle backward correction. For example, if you see Rb:-2, it means the right motor's reverse power is micro-adjusted down by 2 points to perfectly match the physical output of the left motor.
- T90 (969ms): The exact duration in milliseconds that the software pulses the motors to execute a perfect, crisp 90-degree turn.
- 1step (1292) & 1/2 (646): The calculated timing pulses in milliseconds required for the chassis to travel one full structural grid step (1292ms) and exactly one-half step (646ms).
- Speed (80): The core motor speed baseline driven via Pulse Width Modulation (PWM). Note: Because DC motor curves are non-linear, changing this base speed value will require a complete recalibration of your step and turn times.
- SON (7cm): A real-time, active distance stream from the front ultrasonic sonar module.
- LiPo (3.83V): The live voltage reading of your rechargeable 18650 cell. To prevent deep-discharge damage to the battery chemistry, the code is gated with a safety trigger—the moment this value drops to 3.7V, Guchi will immediately lock out functions and flash a Battery Low warning on the screen.
Core Microcontroller: ATmega328P (Arduino Nano architecture)
Operating Voltage: 5.0V (System Logic) | 3.3V (Display Logic)
Display Screen: 128x64 Monochrome OLED (SH1106 I2C Driver)
Sound: Direct-drive Piezo Acoustic Buzzer (Pin A1)
Lighting: 4x Programmable WS2812B RGB Neo Pixels (Pin D13)
Controls: 6-Button Keypad Input Matrix (2col x 3row)
DC Motor Drives:
Left Motor: Forward = D11 | Backward = D3
Right Motor: Forward = D9 | Backward = D10
Infrared Tracker Array: Left = A6 | Centre = A2 | Right = A7
Ultrasonic Sonar Module: Trigger = D12 | Echo = D6
Display Bus (I2C): SDA = A4 | SCL = A5
System Diagnostics: Battery Reference Input = A0
Comments