🔌 Raspberry Pi conversa com o ESP32

python3 -m venv --system-site-packages ~/robo-venv   # só se ainda não criou no módulo 3.1
source ~/robo-venv/bin/activate
pip install pyserial
python -c "import serial; s=serial.Serial('/dev/serial0',115200,timeout=1); s.write(b'ola\n'); print(s.readline())"

// Recebe comandos do Raspberry Pi pela UART2 e move os motores (ESP32, pacote esp32 3.x)
// Protocolo: "$M,esq,dir*HH\n"  "$S*53\n"  "$P*50\n"   (HH = XOR do corpo em hexadecimal)
const int PINO_RX = 16, PINO_TX = 17;        // RX (GPIO16) recebe do pino 8 do Pi; TX (GPIO17) vai ao pino 10
const int PWMA = 25, AIN1 = 26, AIN2 = 27;    // TB6612FNG: motor esquerdo
const int PWMB = 33, BIN1 = 32, BIN2 = 4;     // motor direito (mesmos pinos do rover da Trilha 1)
const int STBY = 13;                         // HIGH = ponte H ligada
const unsigned long TIMEOUT_MS = 300;         // sem comando de motor por 300 ms: para
const int MAX_LINHA = 40;

char linha[MAX_LINHA + 1];
int tam = 0;
bool descartando = false, andando = false;
unsigned long ultimoComando = 0;

uint8_t xorDe(const char *s, int n) { uint8_t x = 0; for (int i = 0; i < n; i++) x ^= (uint8_t)s[i]; return x; }

void responde(const char *corpo) {           // envia "$corpo*HH\n" ao Pi
  char buf[56];
  snprintf(buf, sizeof(buf), "$%s*%02X\n", corpo, xorDe(corpo, strlen(corpo)));
  Serial2.print(buf);
}

void motor(int pwm, int in1, int in2, int v) {
  v = constrain(v, -255, 255);
  digitalWrite(in1, v > 0 ? HIGH : LOW);
  digitalWrite(in2, v < 0 ? HIGH : LOW);
  ledcWrite(pwm, abs(v));                      // API 3.x: ledcWrite recebe o pino
}
void mover(int esq, int dir) { motor(PWMA, AIN1, AIN2, esq); motor(PWMB, BIN1, BIN2, dir); }
void parar() { mover(0, 0); andando = false; }

void trata(char *l) {                         // l = "$M,120,-80*5B" (sem o \n)
  char *estrela = strrchr(l, '*');
  if (l[0] != '$' || estrela == NULL || strlen(estrela) != 3) { responde("ERR,FORMATO"); return; }
  char *corpo = l + 1;
  int n = estrela - corpo;
  if (xorDe(corpo, n) != (uint8_t)strtol(estrela + 1, NULL, 16)) { responde("ERR,CHK"); return; }
  *estrela = '\0';                             // corta o checksum: sobra só o corpo
  if (corpo[0] == 'M' && corpo[1] == ',') {
    int esq, dir;
    if (sscanf(corpo + 2, "%d,%d", &esq, &dir) != 2) { responde("ERR,ARG"); return; }
    mover(esq, dir); andando = true; ultimoComando = millis();
    responde("OK,M");
  } else if (strcmp(corpo, "S") == 0) { parar(); responde("OK,S"); }
  else if (strcmp(corpo, "P") == 0) { responde("OK,P"); }
  else responde("ERR,CMD");
}

void setup() {
  Serial.begin(115200);                        // USB: mensagens para você
  Serial2.begin(115200, SERIAL_8N1, PINO_RX, PINO_TX); // UART2 com pinos explícitos
  int saidas[] = { AIN1, AIN2, BIN1, BIN2, STBY };
  for (int p : saidas) pinMode(p, OUTPUT);
  ledcAttach(PWMA, 20000, 8);                  // 20 kHz, 8 bits (0 a 255)
  ledcAttach(PWMB, 20000, 8);
  parar();
  digitalWrite(STBY, HIGH);
  responde("OK,BOOT");                         // avisa o Pi que (re)iniciou
  Serial.println("Pronto: esperando comandos na UART2");
}

void loop() {
  while (Serial2.available()) {
    char c = Serial2.read();
    if (c == '\r') continue;
    if (c == '\n') {
      linha[tam] = '\0';
      if (descartando) responde("ERR,LONGA"); else if (tam > 0) trata(linha);
      tam = 0; descartando = false;
    } else if (tam < MAX_LINHA) linha[tam++] = c;
    else descartando = true;                    // linha grande demais: joga fora até o \n
  }
  if (andando && millis() - ultimoComando > TIMEOUT_MS) {   // parada segura
    parar();
    responde("ERR,TIMEOUT");
    Serial.println("Sem comandos: motores parados");
  }
}

#!/usr/bin/env python3
"""Link serial Pi -> ESP32 (protocolo do módulo 3.5). Requer: pip install pyserial"""
import time
import serial

PORTA = "/dev/serial0"   # UART dos pinos 8/10; pelo cabo USB use "/dev/ttyACM0"
BAUD = 115200


def checksum(corpo):
    x = 0
    for b in corpo.encode("ascii"):
        x ^= b
    return f"{x:02X}"


class Link:
    def __init__(self, porta=PORTA, baud=BAUD):
        self.porta, self.baud, self.ser = porta, baud, None
        self.abrir()

    def abrir(self):
        self.ser = serial.Serial(self.porta, self.baud, timeout=0.05)
        self.ser.reset_input_buffer()

    def ler_resposta(self):
        bruto = self.ser.readline().decode("ascii", errors="replace").strip()
        if not bruto.startswith("$") or "*" not in bruto:
            return None
        corpo, chk = bruto[1:].rsplit("*", 1)
        return corpo if chk.upper() == checksum(corpo) else None

    def enviar(self, corpo):
        try:
            self.ser.write(f"${corpo}*{checksum(corpo)}\n".encode("ascii"))
            return self.ler_resposta()
        except (serial.SerialException, OSError) as e:
            print("link caiu:", e, "- tentando reabrir")
            time.sleep(0.5)
            try:
                self.ser.close()
                self.abrir()
            except (serial.SerialException, OSError):
                pass
            return None

    def motores(self, esq, drt):
        esq = max(-255, min(255, int(esq)))
        drt = max(-255, min(255, int(drt)))
        return self.enviar(f"M,{esq},{drt}")

    def parar(self):
        return self.enviar("S")

    def ping(self):
        return self.enviar("P")

    def fechar(self):
        try:
            self.parar()
        finally:
            self.ser.close()


if __name__ == "__main__":
    link = Link()
    try:
        print("ping ->", link.ping())
        for nome, esq, drt, segundos in [("frente", 150, 150, 1.0), ("gira", 120, -120, 0.8), ("re", -150, -150, 1.0)]:
            print(nome)
            fim = time.monotonic() + segundos
            while time.monotonic() < fim:
                r = link.motores(esq, drt)   # repetir a 20 Hz mantém o ESP32 andando
                if r != "OK,M":
                    print("resposta:", r)
                time.sleep(0.05)
        print("parar ->", link.parar())
    except KeyboardInterrupt:
        print("interrompido")
    finally:
        link.fechar()                        # sempre manda "S" ao sair