Garden Cultivation Robot

GCR

Senior Engineering Capstone Project – Texas A&M University

The Garden Cultivation Robot, GCR was developed to address the physical challenges associated with home gardening, especially for elderly and mobility-limited individuals. The team's goal was to create a modular, remotely-controlled robot capable of traversing a 50-foot garden row while delivering water and fertilizer to plants. Key design goals included modularity, maneuverability, durability, and ease of use. The final prototype successfully achieved its core objectives. The robot features a modular aluminum 8020 chassis with ABS and PETG enclosures, a twin DC motor drivetrain using chain and sprocket assemblies, and two modular subsystems for watering and fertilizing. The electronic control system was built around a dual-Arduino master-slave architecture, ensuring responsive wireless remote control with minimal signal latency. Failure risk assessments, including FMECA and Fault Tree Analysis, identified drivetrain misalignment and battery depletion as key concerns; these risks were addressed through design modifications, rigorous mechanical assembly, and iterative electronic debugging. The robot met major performance targets, including a 0.01 m turning radius, a 26% improvement in consumable volume, and a final project cost of $2,301.97, remaining within the approved contingency budget.

View Full Project Report (PDF)

| My Role & Scope

• Worked from concept to field-ready prototype, covering CAD, electronics, code, and testing.
• Designed modular 8020 aluminum chassis.
• Developed entire CAD assembly from concept to detailed drawings.
• Developed dual-Arduino master-slave firmware with 2.4 GHz RF link for low-latency remote control.

| System Architecture

| Electronics & Control

Dual-Arduino architecture, wiring schematic, and custom RC remote.

A custom electronics housing was designed and 3D printed to securely mount the battery and electronic components within the chassis. The housing features dedicated compartments for the battery, Arduino controllers, and power distribution boards, improving cable organization and preventing interference with the moving chain drive system. The design incorporates mounting points for secure attachment to the 8020 frame and includes ventilation slots for thermal management.

CAD design and implementation of the custom electronics housing showing component layout and mounting features.

| Watering & Fertilizing Modules

| Manufacturing & Drivetrain

| Arduino Firmware Overview

The firmware is split across two sketches – Master_Code.ino on an Arduino Uno and Slave_Code.ino on an Arduino Nano. The Uno reads raw PWM signals from the FlySky FS-i6X receiver, steers the drivetrain at 75 Hz, and forwards any plant-care commands to the Nano over a 400 kHz I²C bus (address 0×08). The Nano in turn drives the high-current actuator, pumps, and conveyor motor so power wiring stays short and serviceable.

// ───────── Motor Pins ─────────
                #include 

                    // Define Motor A (Right Motor) Pins
                    #define PWM_A 9
                    #define A1 7
                    #define A2 6
                    
                    // Define Motor B (Left Motor) Pins
                    #define PWM_B 10
                    #define B1 11
                    #define B2 12
                    
                    // Receiver input pins for motor control
                    const int steeringPin = 2;
                    const int throttlePin = 3;
                    
                    // RC input channels
                    #define CHANNEL_PIN 5   // FS-i6X channel for pump control
                    const int actuatorPin = 13; // Actuator control signal
                    const int motorPin = 4;     // 12V motor control signal
                    
                    // Input pulse range (FS-i6X default)
                    #define PULSE_MIN 980
                    #define PULSE_MAX 1980
                    
                    // Motor speed range
                    #define SPEED_MIN -255
                    #define SPEED_MAX 255
                    
                    // Deadzone threshold
                    #define DEADZONE 20
                    
                    // Timing for non-blocking execution
                    unsigned long lastUpdate = 0;
                    const int updateInterval = 50;
                    
                    // === Latency Testing Variables ===
                    unsigned long lastSignalTime = 0;
                    float latencySum = 0;
                    unsigned long latencyCount = 0;
                    float maxLatency = 0;
                    unsigned long startTime = 0;
                    const unsigned long loggingDurationMs = 30000; // Log for 30 seconds
                    bool latencyDone = false;
                    
                    
                    void setup() {
                        startTime = millis();
                        Serial.println("Time(ms),Latency(ms)");
                    
                    
                        Serial.begin(9600);
                        Wire.begin();  // Start I2C as master
                    
                        // Set motor control pins as outputs
                        pinMode(PWM_A, OUTPUT);
                        pinMode(A1, OUTPUT);
                        pinMode(A2, OUTPUT);
                        pinMode(PWM_B, OUTPUT);
                        pinMode(B1, OUTPUT);
                        pinMode(B2, OUTPUT);
                    
                        // Set receiver input pins
                        pinMode(steeringPin, INPUT);
                        pinMode(throttlePin, INPUT);
                        pinMode(CHANNEL_PIN, INPUT);
                        pinMode(actuatorPin, INPUT);
                        pinMode(motorPin, INPUT);
                    }
                    
                    void loop() {
                        if (!latencyDone) {
                          pulseIn(steeringPin, HIGH);
                          unsigned long now = micros();
                          float latency = (now - lastSignalTime) / 1000.0;
                          lastSignalTime = now;
                    
                        if (latencyCount > 0) {
                          latencySum += latency;
                          if (latency > maxLatency) maxLatency = latency;
                    
                          Serial.print(millis());
                          Serial.print(",");
                          Serial.println(latency, 3);
                        }
                    
                        latencyCount++;
                    
                        if (millis() - startTime >= loggingDurationMs) {
                          latencyDone = true;
                          float averageLatency = latencySum / (latencyCount - 1);
                          Serial.println();
                          Serial.println("=== Summary ===");
                          Serial.print("Average Latency (ms): ");
                          Serial.println(averageLatency, 3);
                          Serial.print("Max Latency (ms): ");
                          Serial.println(maxLatency, 3);
                          Serial.println("================");
                        }
                      }
                    
                        if (millis() - lastUpdate >= updateInterval) {
                            lastUpdate = millis();
                    
                            int throttle, steering, pumpSignal;
                            readInputs(throttle, steering, pumpSignal);
                    
                            int rightMotorSpeed, leftMotorSpeed;
                            calculateMotorSpeeds(throttle, steering, rightMotorSpeed, leftMotorSpeed);
                    
                            applyMotorSpeeds(rightMotorSpeed, leftMotorSpeed);
                    
                            // Read signals and send to slave arduino
                            int actuatorSignal = pulseIn(actuatorPin, HIGH);
                            int motorSignal = pulseIn(motorPin, HIGH);
                            sendToSlave(actuatorSignal, motorSignal, pumpSignal);
                    
                            debugOutput(throttle, steering, rightMotorSpeed, leftMotorSpeed, pumpSignal, actuatorSignal, motorSignal);
                        }
                    }
                    
                    void readInputs(int &throttle, int &steering, int &pumpSignal) {
                        throttle = pulseIn(throttlePin, HIGH);
                        steering = pulseIn(steeringPin, HIGH);
                        pumpSignal = pulseIn(CHANNEL_PIN, HIGH);
                    
                        throttle = map(throttle, PULSE_MIN, PULSE_MAX, SPEED_MIN, SPEED_MAX);
                        steering = map(steering, PULSE_MIN, PULSE_MAX, SPEED_MIN, SPEED_MAX);
                    
                        throttle = (abs(throttle) < DEADZONE) ? 0 : throttle;
                        steering = (abs(steering) < DEADZONE) ? 0 : steering;
                    }
                    
                    void calculateMotorSpeeds(int throttle, int steering, int &rightMotorSpeed, int &leftMotorSpeed) {
                        if (throttle == 0) {
                            rightMotorSpeed = -steering;
                            leftMotorSpeed = steering;
                        } else {
                            rightMotorSpeed = constrain(throttle - steering / 2, SPEED_MIN, SPEED_MAX);
                            leftMotorSpeed  = constrain(throttle + steering / 2, SPEED_MIN, SPEED_MAX);
                    
                            if (steering == 0) {
                                rightMotorSpeed = leftMotorSpeed = throttle;
                            }
                        }
                    }
                    
                    void applyMotorSpeeds(int rightMotorSpeed, int leftMotorSpeed) {
                        setMotorSpeed(PWM_A, A1, A2, rightMotorSpeed);
                        setMotorSpeed(PWM_B, B1, B2, -leftMotorSpeed);  // Inverted for tank drive
                    }
                    
                    void setMotorSpeed(int pwmPin, int pin1, int pin2, int speed) {
                        digitalWrite(pin1, speed > 0);
                        digitalWrite(pin2, speed < 0);
                        analogWrite(pwmPin, abs(speed));
                    }
                    
                    // NEW: Send actuator, motor, and pump signals to slave arduino
                    void sendToSlave(int actuatorSignal, int motorSignal, int pumpSignal) {
                        Wire.beginTransmission(8); // Slave address
                    
                        Wire.write((byte)(actuatorSignal >> 8));
                        Wire.write((byte)(actuatorSignal & 0xFF));
                        Wire.write((byte)(motorSignal >> 8));
                        Wire.write((byte)(motorSignal & 0xFF));
                        Wire.write((byte)(pumpSignal >> 8));
                        Wire.write((byte)(pumpSignal & 0xFF));
                    
                        Wire.endTransmission();
                    }
                    
                    void debugOutput(int throttle, int steering, int rightMotorSpeed, int leftMotorSpeed,
                                     int pumpSignal, int actuatorSignal, int motorSignal) {
                        Serial.print("Throttle: "); Serial.print(throttle);
                        Serial.print(" | Steering: "); Serial.print(steering);
                        Serial.print(" | Left Motor: "); Serial.print(leftMotorSpeed);
                        Serial.print(" | Right Motor: "); Serial.print(rightMotorSpeed);
                        Serial.print(" | Pump: "); Serial.print(pumpSignal);
                        Serial.print(" | Actuator: "); Serial.print(actuatorSignal);
                        Serial.print(" | Motor: "); Serial.println(motorSignal);
                    }
}

// ───── Pin Map ─────
                #include 

                    // === Pin Definitions ===
                    // Linear Actuator (L298N Driver 2)
                    #define ACTUATOR_PWM 9
                    #define ACTUATOR_IN1 7
                    #define ACTUATOR_IN2 12  
                    
                    // 12V Motor (L298N Driver 2)
                    #define MOTOR_IN1 4
                    #define MOTOR_IN2 2
                    #define MOTOR_ENA 8
                    
                    // Pumps (Motor Driver 1)
                    #define PUMP_A_ENA 10
                    #define PUMP_B_ENB 6
                    
                    // === State Variables ===
                    int prevActSignal = -1;
                    const int deadzone = 10;
                    
                    void setup() {
                      Serial.begin(9600);
                      Wire.begin(8); // I2C Slave Address
                      Wire.onReceive(receiveEvent);
                    
                      // Set pin modes
                      pinMode(ACTUATOR_PWM, OUTPUT);
                      pinMode(ACTUATOR_IN1, OUTPUT);
                      pinMode(ACTUATOR_IN2, OUTPUT);
                      pinMode(MOTOR_IN1, OUTPUT);
                      pinMode(MOTOR_IN2, OUTPUT);
                      pinMode(MOTOR_ENA, OUTPUT);
                      pinMode(PUMP_A_ENA, OUTPUT);
                      pinMode(PUMP_B_ENB, OUTPUT);
                    
                      // Initialize outputs to LOW
                      digitalWrite(MOTOR_IN1, LOW);
                      digitalWrite(MOTOR_IN2, LOW);
                      analogWrite(MOTOR_ENA, 0);
                      digitalWrite(ACTUATOR_IN1, LOW);
                      digitalWrite(ACTUATOR_IN2, LOW);
                      analogWrite(ACTUATOR_PWM, 0);
                      analogWrite(PUMP_A_ENA, 0);
                      analogWrite(PUMP_B_ENB, 0);
                    }
                    
                    void loop() {
                      // I2C events handled in receiveEvent()
                    }
                    
                    void receiveEvent(int howMany) {
                      if (howMany >= 6) {
                        int actSignal = (Wire.read() << 8) | Wire.read();
                        int motorSignal = (Wire.read() << 8) | Wire.read();
                        int pumpSignal = (Wire.read() << 8) | Wire.read();
                    
                        // === Debug Print ===
                        Serial.print("Received | Actuator: ");
                        Serial.print(actSignal);
                        Serial.print(" | Motor: ");
                        Serial.print(motorSignal);
                        Serial.print(" | Pump: ");
                        Serial.println(pumpSignal);
                    
                        // === Motor Control ===
                        if (motorSignal > 1500) {
                          Serial.println("Motor ON");
                          digitalWrite(MOTOR_IN1, HIGH);
                          digitalWrite(MOTOR_IN2, LOW);
                          analogWrite(MOTOR_ENA, 255);
                        } else {
                          Serial.println("Motor OFF");
                          digitalWrite(MOTOR_IN1, LOW);
                          digitalWrite(MOTOR_IN2, LOW);
                          analogWrite(MOTOR_ENA, 0);
                        }
                    
                        // === Pump Control ===
                        if (pumpSignal > 1500) {
                          Serial.println("Pumps ON");
                          analogWrite(PUMP_A_ENA, 255);
                          analogWrite(PUMP_B_ENB, 255);
                        } else {
                          Serial.println("Pumps OFF");
                          analogWrite(PUMP_A_ENA, 0);
                          analogWrite(PUMP_B_ENB, 0);
                        }
                    
                        // === Actuator Control ===
                        if (actSignal < 1010) {
                          Serial.println("Actuator FULL Retract");
                          digitalWrite(ACTUATOR_IN1, LOW);
                          digitalWrite(ACTUATOR_IN2, HIGH);
                          analogWrite(ACTUATOR_PWM, 255);
                        } else if (actSignal > 1980) {
                          Serial.println("Actuator FULL EXTEND");
                          digitalWrite(ACTUATOR_IN1, HIGH);
                          digitalWrite(ACTUATOR_IN2, LOW);
                          analogWrite(ACTUATOR_PWM, 255);
                        } else {
                          int delta = 0;
                    
                          if (prevActSignal == -1) {
                            prevActSignal = actSignal;
                            Serial.println("Actuator INIT");
                          } else {
                            delta = actSignal - prevActSignal;
                    
                            if (delta > deadzone) {
                              Serial.println("Actuator Extending");
                              digitalWrite(ACTUATOR_IN1, HIGH);
                              digitalWrite(ACTUATOR_IN2, LOW);
                              analogWrite(ACTUATOR_PWM, 255);
                            } else if (delta < -deadzone) {
                              Serial.println("Actuator Retracting");
                              digitalWrite(ACTUATOR_IN1, LOW);
                              digitalWrite(ACTUATOR_IN2, HIGH);
                              analogWrite(ACTUATOR_PWM, 255);
                            } else {
                              Serial.println("Actuator STOPPED");
                              digitalWrite(ACTUATOR_IN1, LOW);
                              digitalWrite(ACTUATOR_IN2, LOW);
                              analogWrite(ACTUATOR_PWM, 0);
                            }
                    
                            prevActSignal = actSignal;
                          }
                        }
                      }
                    }
}

import time
from datetime import datetime
import board
import adafruit_dht
import serial
import pynmea2
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Set up DHT22 sensor - connected to GPIO 18
dht_device = adafruit_dht.DHT22(board.D18)  # GPIO 18 for DHT-22

# Set up GPS - connected to GPIO 14 (TX) and 15 (RX)
# On newer Raspberry Pi models, the primary UART is often at /dev/serial0
gps_port = "/dev/serial0"  # Try this instead of /dev/ttyAMA0
# Alternative options if serial0 doesn't work:
# gps_port = "/dev/ttyS0"
# gps_port = "/dev/ttyUSB0"  # If using a USB-to-Serial adapter
gps_baudrate = 9600
try:
    ser = serial.Serial(gps_port, gps_baudrate, timeout=1)
    print(f"Successfully connected to GPS on {gps_port}")
except serial.SerialException as e:
    print(f"Error opening serial port {gps_port}: {e}")
    print("Available ports may include:")
    import glob
    available_ports = glob.glob("/dev/tty*")
    for port in available_ports:
        if "ttyS" in port or "ttyAMA" in port or "ttyUSB" in port or "serial" in port:
            print(f"  - {port}")
    raise

# Data storage
timestamps = []
temperature_data = []
humidity_data = []
latitude_data = []
longitude_data = []

# Plot setup
fig, (ax1, ax2) = plt.subplots(2, 1)
fig.suptitle("Real-Time Sensor Data")

def update_plot(frame):
    global timestamps, temperature_data, humidity_data, latitude_data, longitude_data

    # Read DHT22 sensor
    try:
        temp = dht_device.temperature
        humidity = dht_device.humidity
    except RuntimeError as e:
        print(f"DHT error: {e}")
        temp, humidity = None, None

    # Read GPS data
    lat, lon = None, None
    try:
        line = ser.readline().decode('utf-8', errors='ignore')
        if line.startswith('$GPGGA'):
            msg = pynmea2.parse(line)
            lat, lon = msg.latitude, msg.longitude
    except Exception as e:
        print(f"GPS error: {e}")

    # Store values
    timestamps.append(time.time())
    temperature_data.append(temp)
    humidity_data.append(humidity)
    latitude_data.append(lat)
    longitude_data.append(lon)

    # Keep last 100 values for visualization
    timestamps, temperature_data, humidity_data = timestamps[-100:], temperature_data[-100:], humidity_data[-100:]
    latitude_data, longitude_data = latitude_data[-100:], longitude_data[-100:]

    # Update Temperature & Humidity Plot
    ax1.clear()
    ax1.plot(timestamps, temperature_data, label="Temperature (°C)", color='r')
    ax1.plot(timestamps, humidity_data, label="Humidity (%)", color='b')
    ax1.set_xlabel("Time")
    ax1.set_ylabel("Values")
    ax1.legend()
    ax1.grid()

    # Update GPS Plot
    ax2.clear()
    ax2.scatter(longitude_data, latitude_data, label="GPS Location", color='g')
    ax2.set_xlabel("Longitude")
    ax2.set_ylabel("Latitude")
    ax2.legend()
    ax2.grid()

# Start live update
ani = animation.FuncAnimation(fig, update_plot, interval=1000)
plt.show()

The code implements a robust control system with several key features:

• Master Controller (Uno)
  • Reads 5 RC channels (throttle, steering, pump, actuator, motor) at 20 Hz
  • Implements differential drive with deadzone compensation
  • Maps RC pulses (980-1980 µs) to motor speeds (-255 to 255)
  • Forwards actuator, motor, and pump commands to Slave Nano via I²C
  • Includes serial debug output for real-time monitoring and latency testing
• Slave Controller (Nano)
  • Receives commands from Master Uno via I²C
  • Controls high-current devices: linear actuator, conveyor motor, and dual pumps
  • Implements threshold-based control for binary devices (pumps, motor)
  • Uses position-based control with deadzone for the linear actuator
  • Includes serial debug output for received commands and device states
• Raspberry Pi (Sensor Visualization)
  • Interfaces with DHT22 sensor for temperature and humidity readings (via GPIO)
  • Connects to NEO-6M GPS module for location data (via Serial/UART)
  • Includes error handling for sensor and serial port connections
  • Stores the latest 100 readings for temperature, humidity, latitude, and longitude
  • Uses Matplotlib to generate real-time animated plots:
    • Temperature and humidity over time
    • GPS coordinates (latitude vs. longitude)
  • Updates plots at 1-second intervals

| Analysis & Verification

• Field trials – Completed 50-ft traversal & watering in 6 min with 0.01 m turn radius.
• Throughput testing – 26 % higher consumable capacity than initial design spec.
• Reliability – 60-hour endurance run with zero drivetrain or electronics failures.
• FEA – Aluminum 6061 Yield Strength: 5.515e7 Nsm. Horizontal load force: 83.4 lbf (equivalent to 10 gallon water weight). FOS: 3.78. 7 screw connections along 20 inch tank span length.

| Impact & Lessons Learned

Bringing GCR from blank sheet to field test deepened my appreciation for end-to-end systems thinking: translating user pain-points into requirements, validating them with FMECA, and closing the loop with instrumented field trials. I gained hands-on experience in design-for-assembly (8020 framing, chain alignment jigs) and design-for-serviceability (tool-free module swaps). Debugging the dual-Arduino firmware taught me the value of layered diagnostics and watchdog timers. Working with a cross-functional team hardened my soft skills—weekly design reviews, Gantt tracking, and rapid knowledge sharing turned five students into a cohesive engineering unit.

TL;DR – Built a modular dual-Arduino garden robot that waters & fertilizes 50 ft rows, hits 0.01 m turns, and boosts capacity by 26 % — all under budget.