Nuevas variables a telemetría añadidas

Firmware/G26-Telemetria/G26-Telemetria.ino

@@ -6,29 +6,43 @@ DataProcessor dataProcessor;
 CAN canController;
 
 // Objeto UDP para manejar la conexión UDP
-WiFiUDP udp; 
+WiFiUDP udp;
 
 //Envio de datos a través de UDP
 void TaskUdpSender(void *pvParameters){
 
-  Serial.println("Iniciando tarea de envío..."); 
+  Serial.println("Iniciando tarea de envío...");
 
   while (true){
     if(WiFi.status() == WL_CONNECTED){
 
-      //Obtenemos el dato actual
+      //Obtenemos los datos actuales
-      int tempActual = dataProcessor.current_ect_value; 
+      int tempActual = dataProcessor.current_ect_value;
       int rpmActual = dataProcessor.current_rpm_value;
       float battActual = dataProcessor.current_vbatt_value;
 
-      //Pasamos el dato actual a mensaje para enviarlo 
+      float tpsActual = dataProcessor.current_tps_value;
-      String mensaje = String(tempActual) + "|" + String(rpmActual) + "|" + String(battActual, 1);
+      int marchaActual = dataProcessor.current_marcha_value;
+      float pcombActual = dataProcessor.current_pcomb_value;
+      float taceiteActual = dataProcessor.current_taceite_value;
+      float paceiteActual = dataProcessor.current_paceite_value;
+      float mapActual = dataProcessor.current_map_value;
+      float lambdaActual = dataProcessor.current_lambda_value;
+      float lambdaObjActual = dataProcessor.current_lambda_obj_value;
+
+      //Formato "clave=valor" separado por ';'
+      char mensaje[256];
+      snprintf(mensaje, sizeof(mensaje),
+               "ect=%d;rpm=%d;vbatt=%.2f;tps=%.1f;marcha=%d;"
+               "pcomb=%.2f;taceite=%.1f;paceite=%.2f;map=%.1f;lambda=%.3f;lambda_obj=%.3f",
+               tempActual, rpmActual, battActual, tpsActual, marchaActual,
+               pcombActual, taceiteActual, paceiteActual, mapActual, lambdaActual, lambdaObjActual);
 
       //Enviamos el paquete por broadcast a toda la red local (no hace falta conocer la IP del portátil)
       udp.beginPacket(IPAddress(255,255,255,255), UDP_PORT);
       udp.print(mensaje);
       udp.endPacket();
-      
+
       //Para comprobar que el paquete se está enviado correctamente podemos usar estos prints
       //Serial.print("UDP Enviado: ");
       //Serial.println(mensaje);

Firmware/G26-Telemetria/include/data_processor.hpp

@@ -10,19 +10,29 @@ class DataProcessor {
 public:
     DataProcessor() = default;
 
-    //Variable publica para el CAN
+    //Variables publicas para el CAN
-    volatile int current_ect_value = 0; 
+    //Confirmadas: llegan en la trama 0
+    volatile int current_ect_value = 0;
     volatile int current_rpm_value = 0;
     volatile float current_vbatt_value = 0.0;
 
+    volatile float current_tps_value = 0.0;
+    volatile int current_marcha_value = 0;
+    volatile float current_pcomb_value = 0.0;      // bar
+    volatile float current_taceite_value = 0.0;    // grados C
+    volatile float current_paceite_value = 0.0;    // bar
+    volatile float current_map_value = 0.0;        // kPa
+    volatile float current_lambda_value = 0.0;
+    volatile float current_lambda_obj_value = 0.0;
+
+
     //Métodos de recepción de CAN
-   
+
     void send_serial_frame_0(int rpmh, int rpml, int tpsh, int tpsl, int vbatth, int vbattl, int ect);
     void send_serial_frame_1(int lmbh, int lmbl, int lmbth, int lmbtl, int fuelh, int fuell, int gear);
     void send_serial_frame_2(int shut, int fan, int lmbch, int lmbcl, int brakeh, int brakel, int aux1);
     void send_serial_frame_3(int aux3, int aux4, int aux5, int aux6, int aux7, int aux8, int dig1);
     void send_serial_frame_4(int dig3, int dig4, int dig5, int dig6, int dig7, int dig8, int dig9);
-    
 
     //Métodos extras
     void send_serial(byte type, unsigned int value);
@@ -32,4 +42,4 @@ public:
 private:
 };
 
-#endif
+#endif

Firmware/G26-Telemetria/src/can.cpp

@@ -6,6 +6,12 @@
 
 #include "../include/can.hpp"
 
+// Volcado en crudo de TODOS los mensajes del bus, a la velocidad a la que
+// llegan. Satura los 115200 baudios y frena la tarea de escucha, asi que solo
+// debe activarse para depurar el bus. Con esto a 1 no se leen las lineas
+// [TRAMA n] del data_processor, que son las utiles para localizar canales
+#define VOLCADO_CRUDO_CAN 0
+
 static bool driver_installed = false;
 
 void CAN::start() {
@@ -174,36 +180,44 @@ void CAN::listen() {
                 }
                 
                 if (all_zeros) {
+#if VOLCADO_CRUDO_CAN
                     Serial.println("Ignoring message with all zero data");
+#endif
                     taskYIELD();
                     continue;
                 }
-                
+
+#if VOLCADO_CRUDO_CAN
                 if (message.extd) {
                     Serial.println("Extended Format");
                 } else {
                     Serial.println("Standard Format");
                 }
                 Serial.printf("ID: %lx\nByte:", message.identifier);
+                for (int i = 0; i < message.data_length_code && !(message.rtr); i++) {
+                    Serial.printf(" %d = %02x,", i, message.data[i]);
+                }
+                Serial.println("");
+#endif
                 if (!(message.rtr)) {
-                    for (int i = 0; i < message.data_length_code; i++) {
+
-                        Serial.printf(" %d = %02x,", i, message.data[i]);
-                    }
-                    Serial.println("");
-                    
                     // Send to data processor based on first byte (maintaining original logic)
                     switch (message.data[0]) {
                         case 0:
                             _data_processor->send_serial_frame_0(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
                             break;
                         case 1:
-                            //_data_processor->send_serial_frame_1(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
+                            _data_processor->send_serial_frame_1(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
                             break;
                         case 2:
-                             //_data_processor->send_serial_frame_2(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
+                            _data_processor->send_serial_frame_2(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
-                             break;
+                            break;
-                        case 3: 
+                        case 3:
-                            //_data_processor->send_serial_frame_3(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
+                            _data_processor->send_serial_frame_3(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
+                            break;
+                        case 4:
+                            _data_processor->send_serial_frame_4(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]);
+                            break;
                         default:
                             break;
                     }

Firmware/G26-Telemetria/src/data_processor.cpp

@@ -1,5 +1,6 @@
 #include "../include/data_processor.hpp"
 
+
 char* DataProcessor::process(std::vector<float> data) {
     // Implementación del procesamiento de datos si es necesario
     return nullptr; // Placeholder
@@ -14,40 +15,47 @@ void DataProcessor::send_serial(byte type, unsigned int value) {
     Serial.write(dato, 8);                                              //Se envía serialmente el mensaje, indicando su longituden bytes para ello.
 }
 
+/*
+    
+    this->current_marcha_value
+    this->current_pcomb_value
+    this->current_taceite_value
+    this->current_paceite_value
+    this->current_map_value
+    this->current_lambda_value
+    this->current_lambda_obj_value
+*/
+
+
 //RPM + TPS + vBatt + ECT
 void DataProcessor::send_serial_frame_0(int rpmh, int rpml, int tpsh, int tpsl, int vbatth, int vbattl, int ect){
 
     //Calculos necesarios para obtener bien el formato de los valores necesarios
     int rpm = (rpmh * 256) + rpml;
     double vbatt = ((vbatth * 256) + vbattl) / 100.0;
-
+    int tps = (tpsh * 256) + tpsl; 
-    Serial.println("send_serial_frame_0");
 
     // Actualizamos las variables globales para que puedan ser leidas por el protocolo UDP
-    this->current_ect_value = ect; 
+    this->current_ect_value = ect;
     this->current_rpm_value = rpm;
     this->current_vbatt_value = vbatt;
-
+    this->current_tps_value = tps;
-    Serial.printf("CAN RX -> ECT: %d | RPM: %d | BATT: %.1f \n", ect, rpm, vbatt);;
 }
 
 
-//LAMB + LAMBTRG + FUEL + GEAR
 void DataProcessor::send_serial_frame_1(int lmbh, int lmbl, int lmbth, int lmbtl, int fuelh, int fuell, int gear){
 
 }
 
-
 void DataProcessor::send_serial_frame_2(int shut, int fan, int lmbch, int lmbcl, int brakeh, int brakel, int aux1){
 
 }
 
 void DataProcessor::send_serial_frame_3(int aux3, int aux4, int aux5, int aux6, int aux7, int aux8, int dig1){
 
+
 }
 
 void DataProcessor::send_serial_frame_4(int dig3, int dig4, int dig5, int dig6, int dig7, int dig8, int dig9){
-   
+
 }
-
-