Todo subido

Tiempo_por_vuelta/receptor_pruebas/acceleration.cpp

@@ -0,0 +1,33 @@
+#include <Arduino.h>
+
+#include "acceleration.hpp"
+
+void reiniciar_receptor_acceleration() {
+  // Acceleration no necesita variables persistentes en el receptor.
+}
+
+void procesar_acceleration(const paquete_datos& datos) {
+  switch (datos.estado) {
+    case 1:
+      Serial.println("Sensor final de Acceleration conectado. Sistema listo");
+      break;
+
+    case 2:
+      Serial.println("Acceleration iniciada");
+      break;
+
+    case 3:
+      Serial.print("Acceleration terminada: ");
+      Serial.print(datos.tiempo / 1000.0, 3);
+      Serial.println(" s");
+      break;
+
+    case 4:
+      Serial.println("ERROR: el sensor final de Acceleration no esta conectado");
+      break;
+
+    default:
+      Serial.println("Estado de Acceleration desconocido");
+      break;
+  }
+}

Tiempo_por_vuelta/receptor_pruebas/acceleration.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "configuracion.hpp"
+
+void procesar_acceleration(const paquete_datos& datos);
+void reiniciar_receptor_acceleration();

Tiempo_por_vuelta/receptor_pruebas/autox_endurance.cpp

@@ -0,0 +1,61 @@
+#include <Arduino.h>
+
+#include "autox_endurance.hpp"
+
+unsigned long tiempo_acumulado=0;
+int vueltas_total=0;
+
+void reiniciar_receptor_autox_endurance() {
+
+  if(tiempo_acumulado!=0 || vueltas_total!=0){
+
+    Serial.print("Tiempo total: ");
+    Serial.print(tiempo_acumulado/1000.0, 3);
+    Serial.println(" s");
+
+    unsigned long media_vueltas=tiempo_acumulado/vueltas_total;
+
+    Serial.print("Media de vueltas: ");
+    Serial.print(media_vueltas/1000.0, 3);
+    Serial.println(" s");
+
+    tiempo_acumulado=0;
+    vueltas_total=0;
+
+  }
+
+}
+
+void procesar_autox_endurance(const paquete_datos& datos) {
+  switch (datos.estado) {
+    case 1:
+      if (datos.vuelta == 1) {
+        Serial.println("Calentamiento: vuelta 1 iniciada");
+      } else {
+        Serial.print("Calentamiento: vuelta ");
+        Serial.print(datos.vuelta - 1);
+        Serial.print(" terminada, vuelta ");
+        Serial.print(datos.vuelta);
+        Serial.println(" iniciada");
+      }
+      break;
+
+    case 2:
+      Serial.println("Calentamiento terminado: primera vuelta oficial iniciada");
+      break;
+
+    case 3:
+      Serial.print("Vuelta ");
+      Serial.print(datos.vuelta);
+      Serial.print(": ");
+      Serial.print(datos.tiempo / 1000.0, 3);
+      tiempo_acumulado+=datos.tiempo;
+      vueltas_total=datos.vuelta;
+      Serial.println(" s");
+      break;
+
+    default:
+      Serial.println("Estado de Autocross / Endurance desconocido");
+      break;
+  }
+}

Tiempo_por_vuelta/receptor_pruebas/autox_endurance.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "configuracion.hpp"
+
+void procesar_autox_endurance(const paquete_datos& datos);
+void reiniciar_receptor_autox_endurance();

Tiempo_por_vuelta/receptor_pruebas/configuracion.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <Arduino.h>
+
+/* MAC del emisor de pruebas */
+static const uint8_t ESPNOW_MAC_EMISOR_PRUEBAS[6] = {
+    0x28, 0x05, 0xA5, 0xE1, 0xCF, 0x90
+};
+
+enum tipo_prueba : uint8_t {
+    PRUEBA_NINGUNA = 0,
+    PRUEBA_ACCELERATION = 1,
+    PRUEBA_SKIDPAD = 2,
+    PRUEBA_AUTOX_ENDURANCE = 3
+};
+
+enum tipo_comando : uint8_t {
+    COMANDO_NINGUNO = 0,
+    COMANDO_SELECCIONAR_PRUEBA = 1,
+    COMANDO_REINICIAR_PRUEBA = 2
+};
+
+struct paquete_control {
+    uint8_t comando;
+    uint8_t prueba;
+};
+
+struct paquete_datos {
+    uint8_t prueba;
+    uint8_t estado;
+    uint16_t vuelta;
+    unsigned long tiempo;
+    unsigned long laptime_derecha;
+    unsigned long laptime_izquierda;
+    unsigned long average;
+};

Tiempo_por_vuelta/receptor_pruebas/receptor_pruebas.ino

@@ -0,0 +1,153 @@
+#include <WiFi.h>
+#include <esp_now.h>
+
+#include "configuracion.hpp"
+#include "acceleration.hpp"
+#include "skidpad.hpp"
+#include "autox_endurance.hpp"
+
+paquete_datos datos;
+volatile bool datos_nuevos = false;
+tipo_prueba prueba_activa = PRUEBA_NINGUNA;
+
+static void mostrar_menu() {
+  Serial.println();
+  Serial.println("========================================");
+  Serial.println("       SELECCION DE PRUEBA - BOX");
+  Serial.println("========================================");
+  Serial.println("1 -> Acceleration");
+  Serial.println("2 -> Skidpad");
+  Serial.println("3 -> Autocross / Endurance");
+  Serial.println("0 -> Reiniciar prueba actual");
+  Serial.println("m -> Mostrar este menu");
+  Serial.println("========================================");
+}
+
+static void enviar_control(uint8_t comando, tipo_prueba prueba) {
+  paquete_control control;
+  control.comando = comando;
+  control.prueba = prueba;
+
+  esp_err_t resultado = esp_now_send(ESPNOW_MAC_EMISOR_PRUEBAS, (uint8_t*)&control, sizeof(control));
+  if (resultado != ESP_OK) Serial.println("Error enviando el comando al emisor");
+}
+
+static void reiniciar_procesadores() {
+  reiniciar_receptor_acceleration();
+  reiniciar_receptor_skidpad();
+
+  if(prueba_activa==PRUEBA_AUTOX_ENDURANCE) reiniciar_receptor_autox_endurance();
+
+}
+
+static void seleccionar_prueba(tipo_prueba nueva_prueba) {
+  prueba_activa = nueva_prueba;
+
+  memset(&datos, 0, sizeof(datos));
+  datos_nuevos = false;
+  reiniciar_procesadores();
+
+  Serial.println();
+
+  switch (prueba_activa) {
+    case PRUEBA_ACCELERATION: Serial.println("Seleccionando ACCELERATION..."); break;
+    case PRUEBA_SKIDPAD: Serial.println("Seleccionando SKIDPAD..."); break;
+    case PRUEBA_AUTOX_ENDURANCE: Serial.println("Seleccionando AUTOX / ENDURANCE..."); break;
+    default: return;
+  }
+
+  enviar_control(COMANDO_SELECCIONAR_PRUEBA, prueba_activa);
+}
+
+static void reiniciar_prueba() {
+  if (prueba_activa == PRUEBA_NINGUNA) {
+    Serial.println("Primero selecciona una prueba");
+    return;
+  }
+
+  memset(&datos, 0, sizeof(datos));
+  datos_nuevos = false;
+  reiniciar_procesadores();
+
+  enviar_control(COMANDO_REINICIAR_PRUEBA, prueba_activa);
+  Serial.println("Orden de reinicio enviada al emisor");
+}
+
+static void procesar_datos() {
+  if (datos.estado == 100) {
+    Serial.println("Prueba confirmada por el emisor");
+    return;
+  }
+
+  if (datos.estado == 101) {
+    Serial.println("El emisor ha reiniciado la prueba");
+    return;
+  }
+
+  switch ((tipo_prueba)datos.prueba) {
+    case PRUEBA_ACCELERATION: procesar_acceleration(datos); break;
+    case PRUEBA_SKIDPAD: procesar_skidpad(datos); break;
+    case PRUEBA_AUTOX_ENDURANCE: procesar_autox_endurance(datos); break;
+    default: Serial.println("Paquete recibido sin una prueba valida"); break;
+  }
+}
+
+static void recibir_datos(const esp_now_recv_info_t *info, const uint8_t *datos_emitidos, int longitud) {
+  if (memcmp(info->src_addr, ESPNOW_MAC_EMISOR_PRUEBAS, 6) != 0) return;
+  if (longitud != sizeof(paquete_datos)) return;
+
+  memcpy(&datos, datos_emitidos, sizeof(datos));
+  datos_nuevos = true;
+}
+
+static void leer_monitor_serie() {
+  while (Serial.available() > 0) {
+    char comando = Serial.read();
+
+    switch (comando) {
+      case '1': seleccionar_prueba(PRUEBA_ACCELERATION); break;
+      case '2': seleccionar_prueba(PRUEBA_SKIDPAD); break;
+      case '3': seleccionar_prueba(PRUEBA_AUTOX_ENDURANCE); break;
+      case '0': reiniciar_prueba(); break;
+      case 'm':
+      case 'M': mostrar_menu(); break;
+      case '\n':
+      case '\r': break;
+      default: Serial.println("Comando no valido. Escribe m para ver el menu"); break;
+    }
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+
+  if (esp_now_init() != ESP_OK) {
+    Serial.println("Error iniciando ESP-NOW");
+    return;
+  }
+
+  esp_now_peer_info_t emisor = {};
+  memcpy(emisor.peer_addr, ESPNOW_MAC_EMISOR_PRUEBAS, 6);
+  emisor.channel = 0;
+  emisor.encrypt = false;
+
+  esp_now_register_recv_cb(recibir_datos);
+
+  if (esp_now_add_peer(&emisor) != ESP_OK) {
+    Serial.println("Error anadiendo el emisor de pruebas");
+    return;
+  }
+
+  Serial.println("Receptor de pruebas del box listo");
+  mostrar_menu();
+}
+
+void loop() {
+  leer_monitor_serie();
+
+  if (datos_nuevos) {
+    datos_nuevos = false;
+    procesar_datos();
+  }
+}

Tiempo_por_vuelta/receptor_pruebas/skidpad.cpp

@@ -0,0 +1,48 @@
+#include <Arduino.h>
+
+#include "skidpad.hpp"
+
+static int ciclo = 0;
+
+void reiniciar_receptor_skidpad() {
+  ciclo = 0;
+}
+
+void procesar_skidpad(const paquete_datos& datos) {
+  switch (datos.estado) {
+    case 1:
+      ciclo = datos.vuelta;
+      Serial.print("\n===== Ciclo ");
+      Serial.print(ciclo);
+      Serial.println(" =====");
+      Serial.println("Primera activacion: nada");
+      break;
+
+    case 2:
+      Serial.println("Segunda activacion: inicia vuelta DERECHA");
+      break;
+
+    case 3:
+      Serial.print("Vuelta DERECHA terminada: ");
+      Serial.print(datos.laptime_derecha / 1000.0, 3);
+      Serial.println(" s");
+      break;
+
+    case 4:
+      Serial.println("Cuarta activacion: inicia vuelta IZQUIERDA");
+      break;
+
+    case 5:
+      Serial.print("Vuelta IZQUIERDA terminada: ");
+      Serial.print(datos.laptime_izquierda / 1000.0, 3);
+      Serial.println(" s");
+      Serial.print("Media de ambas vueltas: ");
+      Serial.print(datos.average / 1000.0, 3);
+      Serial.println(" s");
+      break;
+
+    default:
+      Serial.println("Estado de Skidpad desconocido");
+      break;
+  }
+}

Tiempo_por_vuelta/receptor_pruebas/skidpad.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "configuracion.hpp"
+
+void procesar_skidpad(const paquete_datos& datos);
+void reiniciar_receptor_skidpad();