Projects

AFROBOT: Autonomous Drive Pet

AFROBOT is more than a class project, it’s the system I spent the most time thinking about, breaking, rebuilding, and refining.

Designed as an autonomous drive “pet,” AFROBOT follows a dark-green object using a Pixy2 vision sensor while continuously protecting itself from obstacles through infrared distance sensing. Under the hood, it combines analog signal conditioning, PWM motor control, and a subsumption-based behavior architecture that allows safety behaviors to override goal-driven motion in real time.

What makes this project special to me is not just that it worked, it’s how much time went into making it work. I spent months thinking through the architecture, behavior priorities, and circuit design long before final assembly, and even more time debugging real-world failures like wiring issues and damaged sensors near the deadline.

AFROBOT successfully demonstrated stable cruising, reliable obstacle detection at approximately 11 cm, and smooth object tracking up to one meter. Despite late-stage rebuilds and component replacements, the final system operated reliably and met all performance requirements.

This project also became the heart of this portfolio website. I revisited AFROBOT while designing this site, using it as a benchmark for how I want to present my engineering work: clearly, honestly, and with enough depth to show the thinking behind every decision.

Methods

I- IR Sensor & Amplifier Circuit

The infrared distance sensors output a nonlinear voltage that varies with distance, which makes them unreliable if connected directly to the microcontroller. To address this, non-inverting LM324 op-amp circuits were used to amplify and stabilize the signals.

Each sensor outputs approximately 0.03 V to 3.1 V depending on distance. The amplifier gain was tuned so that obstacles at roughly 11 cm reliably crossed the escape threshold, enabling consistent obstacle avoidance behavior without false triggers.

II- Pixy2 Tracking Circuit

III- Motor Control & PWM

DC motors were driven through an H-bridge using PWM signals generated by the microcontroller. During testing, mechanical differences between motors caused noticeable drift, even under identical PWM commands.

Rather than treating this as a flaw, asymmetric PWM tuning was intentionally introduced to compensate for hardware imbalance a practical reminder that real systems rarely behave like ideal models.

Control Code

AFROBOT’s behavior is implemented using a layered subsumption controller. Each behavior independently evaluates sensor inputs and proposes motor commands, while higher-priority behaviors override lower-priority ones in real time. The control loop is fully non-blocking and executes continuously.

                    /// --- Sensor reads ---
                    int adcPixyL = analogRead(PIXY_LEFT_A);
                    int adcPixyR = analogRead(PIXY_RIGHT_A);
                    int adcIRL   = analogRead(IR_LEFT_A);
                    int adcIRR   = analogRead(IR_RIGHT_A);
                    bool pixyPresent = (digitalRead(PIXY_PRESENT_D) == HIGH);

                    // Convert ADC to voltage
                    float vPixyL = adcToVoltage(adcPixyL);
                    float vPixyR = adcToVoltage(adcPixyR);

                    float adcToVoltage(int adc) {
                      return ((float)adc / (float)ADC_MAX) * ADC_REF_V;
                    }
      

                    // --- Emergency detection ---
                    if (!inEmergency) {
                      if (adcIRL >= IR_EMERGENCY_ADC && adcIRR >= IR_EMERGENCY_ADC) {
                        inEmergency = true;
                        emergencyStartTS = millis();
                      }
                    } else {
                      if ((millis() - emergencyStartTS) >= EMERGENCY_DURATION_MS) {
                        inEmergency = false;
                      }
                    }

                    // Emergency action: clockwise pivot
                    leftPWM  = clampPWM(BASE_SPEED + MAX_DELTA_ESCAPE);
                    rightPWM = clampPWM(0);

          

                    bool leftEscape  = (adcIRL >= IR_ESCAPE_ADC);
                    bool rightEscape = (adcIRR >= IR_ESCAPE_ADC);

                    float nIRL = irNormalized(adcIRL);
                    float nIRR = irNormalized(adcIRR);

                    // Both sides blocked → force clockwise turn
                    if (leftEscape && rightEscape) {
                      leftPWM  = clampPWM(BASE_SPEED + MAX_DELTA_ESCAPE);
                      rightPWM = clampPWM(BASE_SPEED - MAX_DELTA_ESCAPE);
                    } else {
                      float turnNorm = (nIRR - nIRL);
                      float d = turnNorm * MAX_DELTA_ESCAPE;
                      leftPWM  = clampPWM(BASE_SPEED - d);
                      rightPWM = clampPWM(BASE_SPEED + d);
                    }

      

                  float pixyTurnNormalized(float vL, float vR) {
                    float diff = vR - vL;
                    float norm = diff / (2.0 * PIXY_HALF_SPAN);
                    return constrain(norm, -1.0, 1.0);
                  }

                  // Symmetric wheel control
                  float turnNorm = pixyTurnNormalized(vPixyL, vPixyR);
                  float d = turnNorm * MAX_DELTA_TRACK;
                  leftPWM  = clampPWM(BASE_SPEED - d);
                  rightPWM = clampPWM(BASE_SPEED + d);

      

                  leftPWM  = BASE_SPEED;
                  rightPWM = BASE_SPEED;
      

                void setMotorPWMs(int leftPWM, int rightPWM) {
                  analogWrite(PWM_LEFT_D, leftPWM);
                  analogWrite(PWM_RIGHT_D, rightPWM);
                }

                void setModeLEDs(Behavior b) {
                  digitalWrite(LED_MODE0_D, b & 0x01);
                  digitalWrite(LED_MODE1_D, b & 0x02);
                }

      

Full source code is available on GitHub. This section highlights the architectural logic and behavior arbitration strategy.

Engineering Challenges

The development of AfroBot presented several real-world engineering challenges that required troubleshooting, redesign, and iterative testing. These issues ultimately strengthened the reliability of the final system and demonstrated the importance of resilience in this project.

Wiring Failures & Full System Rebuild

Early testing revealed Late in the project, the primary control board experienced intermittent power loss caused by loose jumper connections and overused breadboard contacts. Symptoms included:

The system was rewired with shorter signal paths, improved strain relief, and cleaner separation between analog and digital subsystems. This significantly improved:

Lesson learned: Physical robustness is a core part of autonomous system reliability, and slow relearning of the wiring layout is a necessary trade-off for improved system stability.

IR Sensor Damage & Signal Protection

Multiple infrared distance sensors failed during prototyping due to wiring mistakes and insufficient electrical protection.

Faulty sensors were replaced and signal conditioning was redesigned using buffered inputs and controlled voltage ranges.

Lesson learned: Sensors are fragile dependencies and must be electrically protected.

Motor Drift & Mechanical Asymmetry

Despite identical PWM commands, the robot exhibited directional drift during straight-line motion due to mechanical differences between DC motors.

Asymmetric PWM tuning was implemented in software to compensate for hardware imbalance.

Lesson learned: Software compensation is often required for real-world hardware imperfections.

Behavior Priority Conflicts

Early implementations produced unstable behavior when tracking and avoidance routines attempted to control the motors simultaneously.

A strict subsumption hierarchy was enforced to ensure higher-priority safety behaviors always override goal-directed behaviors.

Lesson learned: Explicit behavior arbitration improves predictability and safety.

Conclusion

AFROBOT demonstrates the successful integration of sensing, analog signal conditioning, and behavior-based control into a cohesive autonomous system. By leveraging a subsumption architecture, the robot achieves responsive, reliable operation while prioritizing safety-critical behaviors in dynamic environments. Beyond functional performance, this project emphasized real-world engineering challenges such as wiring robustness, hardware variability, and behavior arbitration — lessons that cannot be learned from simulation alone. More than anything, AFROBOT represents how I approach engineering: build, test, fail, fix, and iterate until the system works not just once, but reliably.