From 5738a6c7d7f5bff969e5c22c7ada6e508a96edb4 Mon Sep 17 00:00:00 2001 From: adrigongv23 Date: Wed, 22 Jul 2026 12:14:10 +0200 Subject: [PATCH] =?UTF-8?q?Nuevas=20variables=20a=20telemetr=C3=ADa=20a?= =?UTF-8?q?=C3=B1adidas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Firmware/G26-Telemetria/G26-Telemetria.ino | 28 +++++++++++---- .../G26-Telemetria/include/data_processor.hpp | 20 ++++++++--- Firmware/G26-Telemetria/src/can.cpp | 36 +++++++++++++------ .../G26-Telemetria/src/data_processor.cpp | 28 +++++++++------ 4 files changed, 79 insertions(+), 33 deletions(-) diff --git a/Firmware/G26-Telemetria/G26-Telemetria.ino b/Firmware/G26-Telemetria/G26-Telemetria.ino index 0400fcd..60af807 100644 --- a/Firmware/G26-Telemetria/G26-Telemetria.ino +++ b/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 - int tempActual = dataProcessor.current_ect_value; + //Obtenemos los datos actuales + 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 - String mensaje = String(tempActual) + "|" + String(rpmActual) + "|" + String(battActual, 1); + float tpsActual = dataProcessor.current_tps_value; + 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); diff --git a/Firmware/G26-Telemetria/include/data_processor.hpp b/Firmware/G26-Telemetria/include/data_processor.hpp index 0a8e8f5..8cbb6ee 100644 --- a/Firmware/G26-Telemetria/include/data_processor.hpp +++ b/Firmware/G26-Telemetria/include/data_processor.hpp @@ -10,19 +10,29 @@ class DataProcessor { public: DataProcessor() = default; - //Variable publica para el CAN - volatile int current_ect_value = 0; + //Variables publicas para el CAN + //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 \ No newline at end of file +#endif diff --git a/Firmware/G26-Telemetria/src/can.cpp b/Firmware/G26-Telemetria/src/can.cpp index 5c6bf0c..a6b5d19 100644 --- a/Firmware/G26-Telemetria/src/can.cpp +++ b/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]); - break; - 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_2(message.data[1], message.data[2], message.data[3], message.data[4], message.data[5], message.data[6], message.data[7]); + break; + 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]); + 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; } diff --git a/Firmware/G26-Telemetria/src/data_processor.cpp b/Firmware/G26-Telemetria/src/data_processor.cpp index d9f15fe..81a5f78 100644 --- a/Firmware/G26-Telemetria/src/data_processor.cpp +++ b/Firmware/G26-Telemetria/src/data_processor.cpp @@ -1,5 +1,6 @@ #include "../include/data_processor.hpp" + char* DataProcessor::process(std::vector 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; - - Serial.println("send_serial_frame_0"); + int tps = (tpsh * 256) + tpsl; // 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; - - Serial.printf("CAN RX -> ECT: %d | RPM: %d | BATT: %.1f \n", ect, rpm, vbatt);; + this->current_tps_value = tps; } -//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){ - + } - -