• Arduino IDE 2.x or PlatformIO.
• Board: Arduino Mega or Mega 2560, processor ATmega2560.
• Libraries: built-in Wire and Servo; add sensor libraries only after confirming exact breakout variants.
• Raspberry Pi communicates using the Mega USB Serial port.
• GPS uses Serial1 on pins 19/18.

Cpp
#include <Arduino.h>
#include <Wire.h>
#include <Servo.h>

constexpr uint8_t PIN_LEFT_PWM       = 2;
constexpr uint8_t PIN_LEFT_DIR       = 22;
constexpr uint8_t PIN_LEFT_EN        = 30;
constexpr uint8_t PIN_LEFT_FAULT_N   = 32;
constexpr uint8_t PIN_RIGHT_PWM      = 3;
constexpr uint8_t PIN_RIGHT_DIR      = 23;
constexpr uint8_t PIN_RIGHT_EN       = 31;
constexpr uint8_t PIN_RIGHT_FAULT_N  = 33;
constexpr uint8_t PIN_PUMP           = 4;
constexpr uint8_t PIN_SOLENOID       = 5;
constexpr uint8_t PIN_ACT_PWM        = 6;
constexpr uint8_t PIN_ACT_DIR        = 24;
constexpr uint8_t PIN_ACT_EN         = 25;
constexpr uint8_t PIN_ACT_FAULT_N    = 34;
constexpr uint8_t PIN_LIMIT_UP_N     = 26;
constexpr uint8_t PIN_LIMIT_DOWN_N   = 27;
constexpr uint8_t PIN_ESTOP_OK       = 28;
constexpr uint8_t PIN_SERVO          = 7;
constexpr uint8_t PIN_US_TRIG        = 8;
constexpr uint8_t PIN_US_ECHO        = 9;
constexpr uint8_t PIN_DHT_DATA       = 10;
constexpr uint8_t PIN_SOIL_A0        = A0;

Servo soilServo;

bool safetyOK() {
  return digitalRead(PIN_ESTOP_OK) == HIGH &&
         digitalRead(PIN_LEFT_FAULT_N) == HIGH &&
         digitalRead(PIN_RIGHT_FAULT_N) == HIGH &&
         digitalRead(PIN_ACT_FAULT_N) == HIGH;
}

void allOutputsOff() {
  analogWrite(PIN_LEFT_PWM, 0);
  analogWrite(PIN_RIGHT_PWM, 0);
  analogWrite(PIN_ACT_PWM, 0);
  digitalWrite(PIN_LEFT_EN, LOW);
  digitalWrite(PIN_RIGHT_EN, LOW);
  digitalWrite(PIN_ACT_EN, LOW);
  digitalWrite(PIN_PUMP, LOW);
  digitalWrite(PIN_SOLENOID, LOW);
}

long readUltrasonicMicros() {
  digitalWrite(PIN_US_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_US_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_US_TRIG, LOW);
  return pulseIn(PIN_US_ECHO, HIGH, 30000UL);
}

void setup() {
  allOutputsOff();

  pinMode(PIN_LEFT_PWM, OUTPUT);
  pinMode(PIN_LEFT_DIR, OUTPUT);
  pinMode(PIN_LEFT_EN, OUTPUT);
  pinMode(PIN_RIGHT_PWM, OUTPUT);
  pinMode(PIN_RIGHT_DIR, OUTPUT);
  pinMode(PIN_RIGHT_EN, OUTPUT);
  pinMode(PIN_PUMP, OUTPUT);
  pinMode(PIN_SOLENOID, OUTPUT);
  pinMode(PIN_ACT_PWM, OUTPUT);
  pinMode(PIN_ACT_DIR, OUTPUT);
  pinMode(PIN_ACT_EN, OUTPUT);
  pinMode(PIN_US_TRIG, OUTPUT);

  pinMode(PIN_LEFT_FAULT_N, INPUT);
  pinMode(PIN_RIGHT_FAULT_N, INPUT);
  pinMode(PIN_ACT_FAULT_N, INPUT);
  pinMode(PIN_LIMIT_UP_N, INPUT);
  pinMode(PIN_LIMIT_DOWN_N, INPUT);
  pinMode(PIN_ESTOP_OK, INPUT);
  pinMode(PIN_US_ECHO, INPUT);
  pinMode(PIN_DHT_DATA, INPUT);

  Serial.begin(115200);       // Raspberry Pi USB link / debug
  Serial1.begin(9600);        // NEO-6M default UART rate
  Wire.begin();               // Mega is I2C master
  Wire.setClock(100000UL);    // conservative for rover wiring

  soilServo.attach(PIN_SERVO, 1000, 2000);
  soilServo.write(90);
  delay(250);
  allOutputsOff();
}

void loop() {
  if (!safetyOK()) {
    allOutputsOff();
  }

  const int soilRaw = analogRead(PIN_SOIL_A0);
  const long echoUs = readUltrasonicMicros();

  // Basic GPS forwarding to the Pi/debug console.
  while (Serial1.available()) {
    Serial.write(Serial1.read());
  }

  // Minimal command channel from Pi. Keep outputs disabled unless safetyOK().
  if (Serial.available()) {
    const char cmd = static_cast<char>(Serial.read());
    if (cmd == 'X') {
      allOutputsOff();
    } else if (cmd == 'P' && safetyOK()) {
      digitalWrite(PIN_PUMP, HIGH);
    } else if (cmd == 'p') {
      digitalWrite(PIN_PUMP, LOW);
    } else if (cmd == 'S' && safetyOK()) {
      digitalWrite(PIN_SOLENOID, HIGH);
    } else if (cmd == 's') {
      digitalWrite(PIN_SOLENOID, LOW);
    }
  }

  static uint32_t lastReport = 0;
  if (millis() - lastReport >= 1000) {
    lastReport = millis();
    Serial.print(F("STATUS estop="));
    Serial.print(digitalRead(PIN_ESTOP_OK));
    Serial.print(F(" soil="));
    Serial.print(soilRaw);
    Serial.print(F(" echo_us="));
    Serial.println(echoUs);
  }
}

• Confirm QMC5883L and MPU-6050 I2C addresses by scanning the bus before selecting libraries.
• Confirm DHT11 is a bare sensor or module; modules may already include a pull-up.
• Add debouncing and plausibility checks for limit switches and E-stop.
• Add motion commands only after wheel-off-ground testing and current measurement.
• Enforce actuator direction against the corresponding active-low limit switch.
• Implement watchdog, command timeout, and heartbeat from Raspberry Pi before autonomous operation.