Tema 6

Reparación y Puesta en Servicio de Sistemas ESP32

ESP32 - Reparación y Restauración

Duración: 17 horas | Evaluación: 2ª Evaluación

Resultados de Aprendizaje y Criterios de Evaluación

RA 6: Restablece el funcionamiento de equipos de radiocomunicaciones, reparando disfunciones y averías.

Criterios de Evaluación:

Puntuación Total RA 6: 1,6 puntos

6.1 Planificación de Reparación

6.1.1 Secuencia de Montaje y Desmontaje

Planificación sistemática del proceso de reparación:

#include "ArduinoJson.h" struct PlanReparacion { String id_reparacion; String fecha_inicio; String tecnico_responsable; String descripcion_avaria; String componentes_afectados; String herramientas_necesarias; String materiales_necesarios; int tiempo_estimado; String pasos_secuenciales; String verificaciones_requeridas; }; void planificarReparacion() { Serial.println("=== Planificación de Reparación ==="); PlanReparacion plan; // Llenar información básica plan.id_reparacion = "REP_" + String(millis()); plan.fecha_inicio = "2025-01-01"; plan.tecnico_responsable = "Carlos Víllora"; plan.descripcion_avaria = "Fallo en módulo WiFi, RSSI bajo"; plan.componentes_afectados = "Antena WiFi, módulo ESP32"; plan.herramientas_necesarias = "Soldador, multímetro, osciloscopio"; plan.materiales_necesarios = "Antena WiFi 2.4GHz, cable coaxial"; plan.tiempo_estimado = 120; // minutos // Definir pasos secuenciales plan.pasos_secuenciales = generarPasosSecuenciales(); // Definir verificaciones plan.verificaciones_requeridas = generarVerificaciones(); // Mostrar plan mostrarPlanReparacion(plan); // Guardar plan guardarPlanReparacion(plan); } String generarPasosSecuenciales() { String pasos = ""; pasos += "1. Desconectar alimentación del sistema\n"; pasos += "2. Retirar cubierta del equipo\n"; pasos += "3. Identificar módulo WiFi defectuoso\n"; pasos += "4. Desoldar conexiones del módulo\n"; pasos += "5. Retirar módulo defectuoso\n"; pasos += "6. Preparar nuevo módulo\n"; pasos += "7. Soldar nuevo módulo\n"; pasos += "8. Verificar conexiones\n"; pasos += "9. Montar cubierta\n"; pasos += "10. Conectar alimentación\n"; pasos += "11. Realizar pruebas funcionales\n"; pasos += "12. Documentar intervención"; return pasos; } String generarVerificaciones() { String verificaciones = ""; verificaciones += "• Verificar continuidad de conexiones\n"; verificaciones += "• Medir impedancia de antena\n"; verificaciones += "• Verificar potencia de transmisión\n"; verificaciones += "• Comprobar sensibilidad de recepción\n"; verificaciones += "• Realizar test de conectividad\n"; verificaciones += "• Verificar estabilidad del sistema"; return verificaciones; } void mostrarPlanReparacion(PlanReparacion plan) { Serial.println("=== Plan de Reparación ==="); Serial.println("ID: " + plan.id_reparacion); Serial.println("Fecha: " + plan.fecha_inicio); Serial.println("Técnico: " + plan.tecnico_responsable); Serial.println("Avaría: " + plan.descripcion_avaria); Serial.println("Componentes: " + plan.componentes_afectados); Serial.println("Herramientas: " + plan.herramientas_necesarias); Serial.println("Materiales: " + plan.materiales_necesarios); Serial.println("Tiempo estimado: " + String(plan.tiempo_estimado) + " minutos"); Serial.println("\nPasos secuenciales:"); Serial.println(plan.pasos_secuenciales); Serial.println("\nVerificaciones requeridas:"); Serial.println(plan.verificaciones_requeridas); } void guardarPlanReparacion(PlanReparacion plan) { DynamicJsonDocument doc(2048); doc["id_reparacion"] = plan.id_reparacion; doc["fecha_inicio"] = plan.fecha_inicio; doc["tecnico_responsable"] = plan.tecnico_responsable; doc["descripcion_avaria"] = plan.descripcion_avaria; doc["componentes_afectados"] = plan.componentes_afectados; doc["herramientas_necesarias"] = plan.herramientas_necesarias; doc["materiales_necesarios"] = plan.materiales_necesarios; doc["tiempo_estimado"] = plan.tiempo_estimado; doc["pasos_secuenciales"] = plan.pasos_secuenciales; doc["verificaciones_requeridas"] = plan.verificaciones_requeridas; String planJson; serializeJson(doc, planJson); // Guardar en SPIFFS if (SPIFFS.begin(true)) { String nombreArchivo = "/plan_" + plan.id_reparacion + ".json"; File file = SPIFFS.open(nombreArchivo, "w"); if (file) { file.println(planJson); file.close(); Serial.println("Plan guardado: " + nombreArchivo); } } }

6.1.2 Verificación de Compatibilidad

Sistema de verificación de compatibilidad de componentes:

struct Componente { String tipo; String modelo; String fabricante; String especificaciones; bool compatible; String motivo_incompatibilidad; }; void verificarCompatibilidad() { Serial.println("=== Verificación de Compatibilidad ==="); // Componente original Componente original; original.tipo = "Módulo WiFi"; original.modelo = "ESP32-WROOM-32"; original.fabricante = "Espressif"; original.especificaciones = "WiFi 802.11 b/g/n, Bluetooth 4.2"; // Componente de reemplazo Componente reemplazo; reemplazo.tipo = "Módulo WiFi"; reemplazo.modelo = "ESP32-WROOM-32E"; reemplazo.fabricante = "Espressif"; reemplazo.especificaciones = "WiFi 802.11 b/g/n, Bluetooth 4.2, PSRAM"; // Verificar compatibilidad bool compatible = verificarCompatibilidadComponentes(original, reemplazo); // Mostrar resultados Serial.println("Componente original:"); Serial.println(" Tipo: " + original.tipo); Serial.println(" Modelo: " + original.modelo); Serial.println(" Fabricante: " + original.fabricante); Serial.println(" Especificaciones: " + original.especificaciones); Serial.println("\nComponente de reemplazo:"); Serial.println(" Tipo: " + reemplazo.tipo); Serial.println(" Modelo: " + reemplazo.modelo); Serial.println(" Fabricante: " + reemplazo.fabricante); Serial.println(" Especificaciones: " + reemplazo.especificaciones); Serial.println("\nCompatibilidad: " + String(compatible ? "COMPATIBLE" : "NO COMPATIBLE")); if (!compatible) { Serial.println("Motivo: " + reemplazo.motivo_incompatibilidad); } } bool verificarCompatibilidadComponentes(Componente original, Componente& reemplazo) { // Verificar tipo if (original.tipo != reemplazo.tipo) { reemplazo.compatible = false; reemplazo.motivo_incompatibilidad = "Tipo de componente diferente"; return false; } // Verificar fabricante if (original.fabricante != reemplazo.fabricante) { reemplazo.compatible = false; reemplazo.motivo_incompatibilidad = "Fabricante diferente"; return false; } // Verificar especificaciones básicas if (!verificarEspecificaciones(original.especificaciones, reemplazo.especificaciones)) { reemplazo.compatible = false; reemplazo.motivo_incompatibilidad = "Especificaciones incompatibles"; return false; } // Verificar dimensiones físicas if (!verificarDimensiones(original.modelo, reemplazo.modelo)) { reemplazo.compatible = false; reemplazo.motivo_incompatibilidad = "Dimensiones incompatibles"; return false; } reemplazo.compatible = true; return true; } bool verificarEspecificaciones(String espec_original, String espec_reemplazo) { // Verificar que las especificaciones básicas sean compatibles // En este caso, ambos tienen WiFi 802.11 b/g/n y Bluetooth 4.2 return espec_original.contains("WiFi 802.11") && espec_reemplazo.contains("WiFi 802.11"); } bool verificarDimensiones(String modelo_original, String modelo_reemplazo) { // Verificar que las dimensiones sean compatibles // ESP32-WROOM-32 y ESP32-WROOM-32E tienen las mismas dimensiones return modelo_original.startsWith("ESP32-WROOM-32") && modelo_reemplazo.startsWith("ESP32-WROOM-32"); }

6.2 Ajuste de Módulos Sustituidos

6.2.1 Ajuste de Módulos RF

Calibración y ajuste de módulos de radiofrecuencia:

#include "esp_wifi.h" struct AjusteRF { int8_t potencia_tx; uint8_t canal; uint8_t ancho_banda; float frecuencia_central; bool ajuste_completado; }; void ajustarModuloRF() { Serial.println("=== Ajuste de Módulo RF ==="); AjusteRF ajuste; ajuste.potencia_tx = 20; // dBm ajuste.canal = 6; ajuste.ancho_banda = 20; // MHz ajuste.frecuencia_central = 2437.0; // MHz ajuste.ajuste_completado = false; // Realizar ajustes realizarAjustesRF(ajuste); // Verificar ajustes verificarAjustesRF(ajuste); // Mostrar resultados mostrarResultadosAjuste(ajuste); } void realizarAjustesRF(AjusteRF& ajuste) { Serial.println("Realizando ajustes RF..."); // Configurar potencia de transmisión esp_wifi_set_max_tx_power(ajuste.potencia_tx); Serial.printf("Potencia TX configurada: %d dBm\n", ajuste.potencia_tx); // Configurar canal esp_wifi_set_channel(ajuste.canal, WIFI_SECOND_CHAN_NONE); Serial.printf("Canal configurado: %d\n", ajuste.canal); // Configurar ancho de banda esp_wifi_set_bandwidth(WIFI_IF_STA, WIFI_BW_HT20); Serial.printf("Ancho de banda configurado: %d MHz\n", ajuste.ancho_banda); // Configurar frecuencia central ajuste.frecuencia_central = 2412 + (ajuste.canal - 1) * 5; Serial.printf("Frecuencia central: %.1f MHz\n", ajuste.frecuencia_central); delay(1000); // Esperar estabilización } void verificarAjustesRF(AjusteRF& ajuste) { Serial.println("Verificando ajustes RF..."); // Verificar potencia int8_t potencia_verificada; esp_wifi_get_max_tx_power(&potencia_verificada); if (potencia_verificada == ajuste.potencia_tx) { Serial.println("✓ Potencia TX verificada"); } else { Serial.println("✗ Error en potencia TX"); ajuste.ajuste_completado = false; return; } // Verificar canal uint8_t canal_verificado = WiFi.channel(); if (canal_verificado == ajuste.canal) { Serial.println("✓ Canal verificada"); } else { Serial.println("✗ Error en canal"); ajuste.ajuste_completado = false; return; } // Verificar frecuencia float frecuencia_verificada = 2412 + (canal_verificado - 1) * 5; if (abs(frecuencia_verificada - ajuste.frecuencia_central) < 0.1) { Serial.println("✓ Frecuencia verificada"); } else { Serial.println("✗ Error en frecuencia"); ajuste.ajuste_completado = false; return; } ajuste.ajuste_completado = true; } void mostrarResultadosAjuste(AjusteRF ajuste) { Serial.println("=== Resultados del Ajuste ==="); Serial.printf("Potencia TX: %d dBm\n", ajuste.potencia_tx); Serial.printf("Canal: %d\n", ajuste.canal); Serial.printf("Ancho de banda: %d MHz\n", ajuste.ancho_banda); Serial.printf("Frecuencia central: %.1f MHz\n", ajuste.frecuencia_central); Serial.println("Estado: " + String(ajuste.ajuste_completado ? "COMPLETADO" : "ERROR")); }

6.2.2 Ajuste de Mezclador y Frecuencia Intermedia

Calibración de circuitos de mezclador y frecuencia intermedia:

struct AjusteMezclador { float frecuencia_local; float frecuencia_intermedia; float ganancia_mezclador; float ruido_mezclador; bool ajuste_completado; }; void ajustarMezclador() { Serial.println("=== Ajuste de Mezclador ==="); AjusteMezclador ajuste; ajuste.frecuencia_local = 2400.0; // MHz ajuste.frecuencia_intermedia = 10.7; // MHz ajuste.ganancia_mezclador = 15.0; // dB ajuste.ruido_mezclador = 8.0; // dB ajuste.ajuste_completado = false; // Realizar ajustes realizarAjustesMezclador(ajuste); // Verificar ajustes verificarAjustesMezclador(ajuste); // Mostrar resultados mostrarResultadosMezclador(ajuste); } void realizarAjustesMezclador(AjusteMezclador& ajuste) { Serial.println("Realizando ajustes de mezclador..."); // Ajustar frecuencia local ajustarFrecuenciaLocal(ajuste.frecuencia_local); Serial.printf("Frecuencia local ajustada: %.1f MHz\n", ajuste.frecuencia_local); // Ajustar frecuencia intermedia ajustarFrecuenciaIntermedia(ajuste.frecuencia_intermedia); Serial.printf("Frecuencia intermedia ajustada: %.1f MHz\n", ajuste.frecuencia_intermedia); // Ajustar ganancia ajustarGananciaMezclador(ajuste.ganancia_mezclador); Serial.printf("Ganancia ajustada: %.1f dB\n", ajuste.ganancia_mezclador); // Ajustar ruido ajustarRuidoMezclador(ajuste.ruido_mezclador); Serial.printf("Ruido ajustado: %.1f dB\n", ajuste.ruido_mezclador); delay(1000); // Esperar estabilización } void ajustarFrecuenciaLocal(float frecuencia) { // Simulación del ajuste de frecuencia local Serial.printf("Ajustando frecuencia local a %.1f MHz...\n", frecuencia); // En la práctica, esto requeriría control de PLL } void ajustarFrecuenciaIntermedia(float frecuencia) { // Simulación del ajuste de frecuencia intermedia Serial.printf("Ajustando frecuencia intermedia a %.1f MHz...\n", frecuencia); // En la práctica, esto requeriría ajuste de filtros } void ajustarGananciaMezclador(float ganancia) { // Simulación del ajuste de ganancia Serial.printf("Ajustando ganancia a %.1f dB...\n", ganancia); // En la práctica, esto requeriría control de amplificadores } void ajustarRuidoMezclador(float ruido) { // Simulación del ajuste de ruido Serial.printf("Ajustando ruido a %.1f dB...\n", ruido); // En la práctica, esto requeriría optimización de circuitos } void verificarAjustesMezclador(AjusteMezclador& ajuste) { Serial.println("Verificando ajustes de mezclador..."); // Verificar frecuencia local float frecuencia_verificada = medirFrecuenciaLocal(); if (abs(frecuencia_verificada - ajuste.frecuencia_local) < 0.1) { Serial.println("✓ Frecuencia local verificada"); } else { Serial.println("✗ Error en frecuencia local"); ajuste.ajuste_completado = false; return; } // Verificar frecuencia intermedia float fi_verificada = medirFrecuenciaIntermedia(); if (abs(fi_verificada - ajuste.frecuencia_intermedia) < 0.1) { Serial.println("✓ Frecuencia intermedia verificada"); } else { Serial.println("✗ Error en frecuencia intermedia"); ajuste.ajuste_completado = false; return; } // Verificar ganancia float ganancia_verificada = medirGananciaMezclador(); if (abs(ganancia_verificada - ajuste.ganancia_mezclador) < 1.0) { Serial.println("✓ Ganancia verificada"); } else { Serial.println("✗ Error en ganancia"); ajuste.ajuste_completado = false; return; } ajuste.ajuste_completado = true; } float medirFrecuenciaLocal() { // Simulación de medición de frecuencia local return 2400.0; // MHz } float medirFrecuenciaIntermedia() { // Simulación de medición de frecuencia intermedia return 10.7; // MHz } float medirGananciaMezclador() { // Simulación de medición de ganancia return 15.0; // dB } void mostrarResultadosMezclador(AjusteMezclador ajuste) { Serial.println("=== Resultados del Ajuste de Mezclador ==="); Serial.printf("Frecuencia local: %.1f MHz\n", ajuste.frecuencia_local); Serial.printf("Frecuencia intermedia: %.1f MHz\n", ajuste.frecuencia_intermedia); Serial.printf("Ganancia: %.1f dB\n", ajuste.ganancia_mezclador); Serial.printf("Ruido: %.1f dB\n", ajuste.ruido_mezclador); Serial.println("Estado: " + String(ajuste.ajuste_completado ? "COMPLETADO" : "ERROR")); }

6.3 Verificación de Parámetros de Funcionamiento

6.3.1 Verificación de Potencia de Transmisión

Medición y verificación de la potencia de transmisión:

struct VerificacionTX { int8_t potencia_configurada; float potencia_medida; float potencia_esperada; float error_potencia; bool potencia_ok; }; void verificarPotenciaTransmision() { Serial.println("=== Verificación de Potencia de Transmisión ==="); VerificacionTX verificacion; verificacion.potencia_configurada = 20; // dBm verificacion.potencia_esperada = 20.0; // dBm verificacion.potencia_ok = false; // Medir potencia verificacion.potencia_medida = medirPotenciaTransmision(); // Calcular error verificacion.error_potencia = abs(verificacion.potencia_medida - verificacion.potencia_esperada); // Evaluar resultado if (verificacion.error_potencia < 1.0) { verificacion.potencia_ok = true; } // Mostrar resultados Serial.printf("Potencia configurada: %d dBm\n", verificacion.potencia_configurada); Serial.printf("Potencia medida: %.2f dBm\n", verificacion.potencia_medida); Serial.printf("Potencia esperada: %.2f dBm\n", verificacion.potencia_esperada); Serial.printf("Error: %.2f dB\n", verificacion.error_potencia); Serial.println("Resultado: " + String(verificacion.potencia_ok ? "OK" : "ERROR")); // Recomendar acciones if (!verificacion.potencia_ok) { recomendarAccionesPotencia(verificacion); } } float medirPotenciaTransmision() { // Simulación de medición de potencia // En la práctica, esto requeriría un medidor de potencia return 19.8; // dBm } void recomendarAccionesPotencia(VerificacionTX verificacion) { Serial.println("=== Recomendaciones ==="); if (verificacion.potencia_medida < verificacion.potencia_esperada) { Serial.println("• Verificar amplificador de potencia"); Serial.println("• Comprobar alimentación del amplificador"); Serial.println("• Verificar atenuadores"); } else { Serial.println("• Verificar limitador de potencia"); Serial.println("• Comprobar calibración del medidor"); Serial.println("• Verificar configuración del sistema"); } }

6.3.2 Verificación de Sensibilidad de Recepción

Medición de la sensibilidad de recepción:

struct VerificacionRX { float sensibilidad_medida; float sensibilidad_esperada; float error_sensibilidad; bool sensibilidad_ok; }; void verificarSensibilidadRecepcion() { Serial.println("=== Verificación de Sensibilidad de Recepción ==="); VerificacionRX verificacion; verificacion.sensibilidad_esperada = -90.0; // dBm verificacion.sensibilidad_ok = false; // Medir sensibilidad verificacion.sensibilidad_medida = medirSensibilidadRecepcion(); // Calcular error verificacion.error_sensibilidad = abs(verificacion.sensibilidad_medida - verificacion.sensibilidad_esperada); // Evaluar resultado if (verificacion.error_sensibilidad < 3.0) { verificacion.sensibilidad_ok = true; } // Mostrar resultados Serial.printf("Sensibilidad medida: %.2f dBm\n", verificacion.sensibilidad_medida); Serial.printf("Sensibilidad esperada: %.2f dBm\n", verificacion.sensibilidad_esperada); Serial.printf("Error: %.2f dB\n", verificacion.error_sensibilidad); Serial.println("Resultado: " + String(verificacion.sensibilidad_ok ? "OK" : "ERROR")); // Recomendar acciones if (!verificacion.sensibilidad_ok) { recomendarAccionesSensibilidad(verificacion); } } float medirSensibilidadRecepcion() { // Simulación de medición de sensibilidad // En la práctica, esto requeriría un generador de señales return -88.5; // dBm } void recomendarAccionesSensibilidad(VerificacionRX verificacion) { Serial.println("=== Recomendaciones ==="); if (verificacion.sensibilidad_medida > verificacion.sensibilidad_esperada) { Serial.println("• Verificar amplificador de bajo ruido (LNA)"); Serial.println("• Comprobar filtros de entrada"); Serial.println("• Verificar ruido del sistema"); } else { Serial.println("• Verificar calibración del generador"); Serial.println("• Comprobar atenuadores"); Serial.println("• Verificar configuración del sistema"); } }

6.4 Herramientas Software de Verificación

6.4.1 Sistema de Testing Automático

Implementación de pruebas automáticas de verificación:

#include "ArduinoJson.h" struct TestResultado { String nombre_test; bool resultado; float valor_medido; float valor_esperado; float tolerancia; String mensaje; }; void ejecutarTestsAutomaticos() { Serial.println("=== Ejecutando Tests Automáticos ==="); TestResultado tests[5]; int total_tests = 5; int tests_exitosos = 0; // Ejecutar tests tests[0] = testPotenciaTransmision(); tests[1] = testSensibilidadRecepcion(); tests[2] = testFrecuenciaCentral(); tests[3] = testAnchoBanda(); tests[4] = testConectividad(); // Mostrar resultados for (int i = 0; i < total_tests; i++) { Serial.printf("Test %d: %s - %s\n", i+1, tests[i].nombre_test.c_str(), tests[i].resultado ? "PASS" : "FAIL"); Serial.printf(" Medido: %.2f, Esperado: %.2f, Tolerancia: %.2f\n", tests[i].valor_medido, tests[i].valor_esperado, tests[i].tolerancia); Serial.printf(" Mensaje: %s\n", tests[i].mensaje.c_str()); if (tests[i].resultado) { tests_exitosos++; } } // Resumen Serial.printf("\nResumen: %d/%d tests exitosos\n", tests_exitosos, total_tests); if (tests_exitosos == total_tests) { Serial.println("ESTADO: Todos los tests pasaron"); } else { Serial.println("ESTADO: Algunos tests fallaron"); generarReporteFallas(tests, total_tests); } } TestResultado testPotenciaTransmision() { TestResultado test; test.nombre_test = "Potencia de Transmisión"; test.valor_esperado = 20.0; // dBm test.tolerancia = 1.0; // dB // Medir potencia test.valor_medido = medirPotenciaTransmision(); // Evaluar resultado float error = abs(test.valor_medido - test.valor_esperado); test.resultado = (error <= test.tolerancia); if (test.resultado) { test.mensaje = "Potencia dentro de tolerancia"; } else { test.mensaje = "Potencia fuera de tolerancia"; } return test; } TestResultado testSensibilidadRecepcion() { TestResultado test; test.nombre_test = "Sensibilidad de Recepción"; test.valor_esperado = -90.0; // dBm test.tolerancia = 3.0; // dB // Medir sensibilidad test.valor_medido = medirSensibilidadRecepcion(); // Evaluar resultado float error = abs(test.valor_medido - test.valor_esperado); test.resultado = (error <= test.tolerancia); if (test.resultado) { test.mensaje = "Sensibilidad dentro de tolerancia"; } else { test.mensaje = "Sensibilidad fuera de tolerancia"; } return test; } TestResultado testFrecuenciaCentral() { TestResultado test; test.nombre_test = "Frecuencia Central"; test.valor_esperado = 2437.0; // MHz test.tolerancia = 0.1; // MHz // Medir frecuencia test.valor_medido = medirFrecuenciaCentral(); // Evaluar resultado float error = abs(test.valor_medido - test.valor_esperado); test.resultado = (error <= test.tolerancia); if (test.resultado) { test.mensaje = "Frecuencia dentro de tolerancia"; } else { test.mensaje = "Frecuencia fuera de tolerancia"; } return test; } TestResultado testAnchoBanda() { TestResultado test; test.nombre_test = "Ancho de Banda"; test.valor_esperado = 20.0; // MHz test.tolerancia = 1.0; // MHz // Medir ancho de banda test.valor_medido = medirAnchoBanda(); // Evaluar resultado float error = abs(test.valor_medido - test.valor_esperado); test.resultado = (error <= test.tolerancia); if (test.resultado) { test.mensaje = "Ancho de banda dentro de tolerancia"; } else { test.mensaje = "Ancho de banda fuera de tolerancia"; } return test; } TestResultado testConectividad() { TestResultado test; test.nombre_test = "Conectividad"; test.valor_esperado = 1.0; // Conectado test.tolerancia = 0.0; // Exacto // Verificar conectividad test.valor_medido = (WiFi.status() == WL_CONNECTED) ? 1.0 : 0.0; // Evaluar resultado test.resultado = (test.valor_medido == test.valor_esperado); if (test.resultado) { test.mensaje = "Conectividad OK"; } else { test.mensaje = "Conectividad fallida"; } return test; } float medirFrecuenciaCentral() { // Simulación de medición de frecuencia central return 2437.0; // MHz } float medirAnchoBanda() { // Simulación de medición de ancho de banda return 20.0; // MHz } void generarReporteFallas(TestResultado* tests, int total) { Serial.println("=== Reporte de Fallas ==="); for (int i = 0; i < total; i++) { if (!tests[i].resultado) { Serial.printf("FALLA: %s\n", tests[i].nombre_test.c_str()); Serial.printf(" Motivo: %s\n", tests[i].mensaje.c_str()); Serial.printf(" Valor medido: %.2f\n", tests[i].valor_medido); Serial.printf(" Valor esperado: %.2f\n", tests[i].valor_esperado); Serial.printf(" Tolerancia: %.2f\n", tests[i].tolerancia); } } }

6.5 Integración del Equipo en el Sistema

6.5.1 Verificación de Integración

Verificación de la integración del equipo reparado en el sistema:

struct VerificacionIntegracion { bool conectividad_ok; bool comunicacion_ok; bool sincronizacion_ok; bool configuracion_ok; bool integracion_completa; }; void verificarIntegracionSistema() { Serial.println("=== Verificación de Integración del Sistema ==="); VerificacionIntegracion verificacion; verificacion.conectividad_ok = false; verificacion.comunicacion_ok = false; verificacion.sincronizacion_ok = false; verificacion.configuracion_ok = false; verificacion.integracion_completa = false; // Verificar conectividad verificacion.conectividad_ok = verificarConectividad(); Serial.println("Conectividad: " + String(verificacion.conectividad_ok ? "OK" : "ERROR")); // Verificar comunicación verificacion.comunicacion_ok = verificarComunicacion(); Serial.println("Comunicación: " + String(verificacion.comunicacion_ok ? "OK" : "ERROR")); // Verificar sincronización verificacion.sincronizacion_ok = verificarSincronizacion(); Serial.println("Sincronización: " + String(verificacion.sincronizacion_ok ? "OK" : "ERROR")); // Verificar configuración verificacion.configuracion_ok = verificarConfiguracion(); Serial.println("Configuración: " + String(verificacion.configuracion_ok ? "OK" : "ERROR")); // Evaluar integración completa verificacion.integracion_completa = (verificacion.conectividad_ok && verificacion.comunicacion_ok && verificacion.sincronizacion_ok && verificacion.configuracion_ok); // Mostrar resultado final Serial.println("Integración completa: " + String(verificacion.integracion_completa ? "OK" : "ERROR")); // Recomendar acciones if (!verificacion.integracion_completa) { recomendarAccionesIntegracion(verificacion); } } bool verificarConectividad() { Serial.println("Verificando conectividad..."); // Verificar WiFi if (WiFi.status() != WL_CONNECTED) { Serial.println(" WiFi: Desconectado"); return false; } Serial.println(" WiFi: Conectado"); // Verificar ping if (!pingGateway()) { Serial.println(" Ping: Fallido"); return false; } Serial.println(" Ping: OK"); return true; } bool verificarComunicacion() { Serial.println("Verificando comunicación..."); // Verificar HTTP if (!testHTTP()) { Serial.println(" HTTP: Fallido"); return false; } Serial.println(" HTTP: OK"); // Verificar MQTT if (!testMQTT()) { Serial.println(" MQTT: Fallido"); return false; } Serial.println(" MQTT: OK"); return true; } bool verificarSincronizacion() { Serial.println("Verificando sincronización..."); // Verificar sincronización de tiempo if (!sincronizarTiempo()) { Serial.println(" Tiempo: Fallido"); return false; } Serial.println(" Tiempo: OK"); // Verificar sincronización de datos if (!sincronizarDatos()) { Serial.println(" Datos: Fallido"); return false; } Serial.println(" Datos: OK"); return true; } bool verificarConfiguracion() { Serial.println("Verificando configuración..."); // Verificar configuración de red if (!verificarConfiguracionRed()) { Serial.println(" Red: Fallido"); return false; } Serial.println(" Red: OK"); // Verificar configuración de sistema if (!verificarConfiguracionSistema()) { Serial.println(" Sistema: Fallido"); return false; } Serial.println(" Sistema: OK"); return true; } bool pingGateway() { // Simulación de ping al gateway return true; } bool testHTTP() { // Simulación de test HTTP return true; } bool testMQTT() { // Simulación de test MQTT return true; } bool sincronizarTiempo() { // Simulación de sincronización de tiempo return true; } bool sincronizarDatos() { // Simulación de sincronización de datos return true; } bool verificarConfiguracionRed() { // Simulación de verificación de configuración de red return true; } bool verificarConfiguracionSistema() { // Simulación de verificación de configuración de sistema return true; } void recomendarAccionesIntegracion(VerificacionIntegracion verificacion) { Serial.println("=== Recomendaciones ==="); if (!verificacion.conectividad_ok) { Serial.println("• Verificar configuración de red"); Serial.println("• Comprobar conectores y cables"); Serial.println("• Verificar alcance de la red"); } if (!verificacion.comunicacion_ok) { Serial.println("• Verificar protocolos de comunicación"); Serial.println("• Comprobar configuración de servidores"); Serial.println("• Verificar firewall y puertos"); } if (!verificacion.sincronizacion_ok) { Serial.println("• Verificar servidor de tiempo"); Serial.println("• Comprobar sincronización de datos"); Serial.println("• Verificar protocolos de sincronización"); } if (!verificacion.configuracion_ok) { Serial.println("• Verificar configuración de red"); Serial.println("• Comprobar configuración de sistema"); Serial.println("• Verificar parámetros de configuración"); } }

6.6 Documentación de la Intervención

6.6.1 Generación de Documentación

Generación automática de documentación de la intervención:

#include "ArduinoJson.h" #include "SPIFFS.h" struct DocumentoIntervencion { String id_intervencion; String fecha_inicio; String fecha_fin; String tecnico_responsable; String descripcion_avaria; String componentes_reemplazados; String herramientas_utilizadas; String materiales_utilizados; float costo_materiales; float costo_mano_obra; float costo_total; String pasos_realizados; String verificaciones_realizadas; String resultados_pruebas; bool intervencion_exitosa; String observaciones; String recomendaciones; }; void generarDocumentoIntervencion() { Serial.println("=== Generando Documento de Intervención ==="); DocumentoIntervencion documento; // Llenar información básica documento.id_intervencion = "INT_" + String(millis()); documento.fecha_inicio = "2025-01-01 10:00:00"; documento.fecha_fin = "2025-01-01 12:00:00"; documento.tecnico_responsable = "Carlos Víllora"; documento.descripcion_avaria = "Fallo en módulo WiFi, RSSI bajo, desconexiones intermitentes"; documento.componentes_reemplazados = "Antena WiFi 2.4GHz, módulo ESP32-WROOM-32E"; documento.herramientas_utilizadas = "Soldador, multímetro, osciloscopio, analizador de espectro"; documento.materiales_utilizados = "Antena WiFi 2.4GHz, cable coaxial, estaño, flux"; // Calcular costos documento.costo_materiales = 35.50; documento.costo_mano_obra = 60.00; documento.costo_total = documento.costo_materiales + documento.costo_mano_obra; // Llenar pasos realizados documento.pasos_realizados = generarPasosRealizados(); // Llenar verificaciones realizadas documento.verificaciones_realizadas = generarVerificacionesRealizadas(); // Llenar resultados de pruebas documento.resultados_pruebas = generarResultadosPruebas(); // Resultado de la intervención documento.intervencion_exitosa = true; // Llenar observaciones documento.observaciones = "Sistema funcionando correctamente después de la intervención. Todos los parámetros dentro de especificaciones."; // Llenar recomendaciones documento.recomendaciones = generarRecomendaciones(); // Generar documento JSON String documentoJson = generarDocumentoJSON(documento); // Guardar documento guardarDocumento(documentoJson); // Mostrar resumen mostrarResumenIntervencion(documento); } String generarPasosRealizados() { String pasos = ""; pasos += "1. Desconexión de alimentación del sistema\n"; pasos += "2. Retirada de cubierta del equipo\n"; pasos += "3. Identificación del módulo WiFi defectuoso\n"; pasos += "4. Desoldado de conexiones del módulo\n"; pasos += "5. Retirada del módulo defectuoso\n"; pasos += "6. Preparación del nuevo módulo\n"; pasos += "7. Soldado del nuevo módulo\n"; pasos += "8. Verificación de conexiones\n"; pasos += "9. Montaje de cubierta\n"; pasos += "10. Conexión de alimentación\n"; pasos += "11. Realización de pruebas funcionales\n"; pasos += "12. Documentación de la intervención"; return pasos; } String generarVerificacionesRealizadas() { String verificaciones = ""; verificaciones += "• Verificación de continuidad de conexiones\n"; verificaciones += "• Medición de impedancia de antena\n"; verificaciones += "• Verificación de potencia de transmisión\n"; verificaciones += "• Comprobación de sensibilidad de recepción\n"; verificaciones += "• Realización de test de conectividad\n"; verificaciones += "• Verificación de estabilidad del sistema"; return verificaciones; } String generarResultadosPruebas() { String resultados = ""; resultados += "• Potencia de transmisión: 19.8 dBm (OK)\n"; resultados += "• Sensibilidad de recepción: -88.5 dBm (OK)\n"; resultados += "• Frecuencia central: 2437.0 MHz (OK)\n"; resultados += "• Ancho de banda: 20.0 MHz (OK)\n"; resultados += "• Conectividad: OK\n"; resultados += "• Estabilidad: OK"; return resultados; } String generarRecomendaciones() { String recomendaciones = ""; recomendaciones += "• Realizar mantenimiento preventivo cada 6 meses\n"; recomendaciones += "• Monitorear parámetros RF regularmente\n"; recomendaciones += "• Verificar conexiones periódicamente\n"; recomendaciones += "• Mantener documentación actualizada"; return recomendaciones; } String generarDocumentoJSON(DocumentoIntervencion documento) { DynamicJsonDocument doc(4096); doc["id_intervencion"] = documento.id_intervencion; doc["fecha_inicio"] = documento.fecha_inicio; doc["fecha_fin"] = documento.fecha_fin; doc["tecnico_responsable"] = documento.tecnico_responsable; doc["descripcion_avaria"] = documento.descripcion_avaria; doc["componentes_reemplazados"] = documento.componentes_reemplazados; doc["herramientas_utilizadas"] = documento.herramientas_utilizadas; doc["materiales_utilizados"] = documento.materiales_utilizados; doc["costos"]["materiales"] = documento.costo_materiales; doc["costos"]["mano_obra"] = documento.costo_mano_obra; doc["costos"]["total"] = documento.costo_total; doc["pasos_realizados"] = documento.pasos_realizados; doc["verificaciones_realizadas"] = documento.verificaciones_realizadas; doc["resultados_pruebas"] = documento.resultados_pruebas; doc["intervencion_exitosa"] = documento.intervencion_exitosa; doc["observaciones"] = documento.observaciones; doc["recomendaciones"] = documento.recomendaciones; String documentoJson; serializeJson(doc, documentoJson); return documentoJson; } void guardarDocumento(String documento) { if (!SPIFFS.begin(true)) { Serial.println("Error montando SPIFFS"); return; } String nombreArchivo = "/intervencion_" + String(millis()) + ".json"; File file = SPIFFS.open(nombreArchivo, "w"); if (file) { file.println(documento); file.close(); Serial.println("Documento guardado: " + nombreArchivo); } else { Serial.println("Error guardando documento"); } } void mostrarResumenIntervencion(DocumentoIntervencion documento) { Serial.println("=== Resumen de Intervención ==="); Serial.println("ID: " + documento.id_intervencion); Serial.println("Fecha inicio: " + documento.fecha_inicio); Serial.println("Fecha fin: " + documento.fecha_fin); Serial.println("Técnico: " + documento.tecnico_responsable); Serial.println("Avaría: " + documento.descripcion_avaria); Serial.println("Componentes: " + documento.componentes_reemplazados); Serial.println("Herramientas: " + documento.herramientas_utilizadas); Serial.println("Materiales: " + documento.materiales_utilizados); Serial.printf("Costo total: %.2f €\n", documento.costo_total); Serial.println("Resultado: " + String(documento.intervencion_exitosa ? "Exitoso" : "Fallido")); Serial.println("Observaciones: " + documento.observaciones); Serial.println("Recomendaciones: " + documento.recomendaciones); }

Materiales Necesarios

Actividades Teóricas

Prácticas de Laboratorio

Práctica 6.1: Planificación de Reparación

Objetivo: Planificar la secuencia de montaje y desmontaje de componentes.

Duración: 2 horas

Entregables: Plan de reparación, verificación de compatibilidad, informe técnico

Práctica 6.2: Ajuste de Módulos

Objetivo: Ajustar módulos RF, mezclador y frecuencia intermedia.

Duración: 3 horas

Entregables: Módulos ajustados, mediciones, informe técnico

Práctica 6.3: Verificación de Parámetros

Objetivo: Verificar potencia de transmisión, sensibilidad y calidad de señal.

Duración: 3 horas

Entregables: Mediciones de parámetros, análisis de resultados, informe técnico

Práctica 6.4: Testing Automático

Objetivo: Implementar sistema de testing automático de parámetros.

Duración: 3 horas

Entregables: Sistema de testing, resultados de pruebas, informe técnico

Práctica 6.5: Integración del Sistema

Objetivo: Integrar el equipo reparado en el sistema completo.

Duración: 3 horas

Entregables: Sistema integrado, verificaciones, informe técnico

Práctica 6.6: Documentación de Intervención

Objetivo: Generar documentación completa de la intervención.

Duración: 3 horas

Entregables: Documento de intervención, valoración económica, informe final

Criterios de Evaluación

Instrumentos de evaluación:

Entregables obligatorios:

Recursos Adicionales