Proyecto control de chimenea (Parte II)

Hola a todos, vengo con la continuación (o mas bien culminación) del proyecto que inicié hace unos 6 años (ahí es nada, que malo es no tener tiempo :pensive:), dejo el link por si sirve como antecedentes Proyecto control de chimenea (ampliable)

Ha pasado mucho desde que comencé a domotizar la vivienda, y han cambiado mucho las cosas desde entonces, aquellos "nodos" que pretendía hacer se quedaron en el cajón de los recuerdos y fueron sustituidos por sensores comerciales para evitar el engorro del cableado físico, al final encontré la combinación "casi" perfecta para domotización de vivienda: mini-pc + Home Assistant + MQTT + Node-RED + dispositivos zigbee / WiFi / ESP32.
He dicho lo de "casi" porque sigo opinando que como los dispositivos cableados no hay nada, de vez en cuando me toca volver a "emparejar" algún dispositivo zigbee, pero son pequeños problemas con los que se puede convivir mientras no sean elementos críticos.

Toca ahora meter mano al meollo del asunto, que es la chimenea y calefacción; ha estado funcionando estos años con dos termostatos digitales sin problemas, pero el sistema tiene sus carencias, como son el no estar integrado en el sistema domótico, el control de zonas y la estratificación térmica.

El objetivo base sigue siendo similar al inicial, controlar el distribuidor de aire de la chimenea (turbina) y controlar cada una de las salidas de aire mediante una válvula o compuerta que permita regular el flujo de aire que entra a cada habitación; modificando en parte la instalación actual, ya que en su día cometí algunos errores que solo ves después de...

El primero de ellos (por si le sirve a alguno la experiencia) fue colocar una turbina de poca potencia, pese a ser la recomendada, ya que el aire caliente al llegar a las diferentes habitaciones y salir con poca fuerza se queda "pegado" en el techo y cuesta muchísimo alcanzar la temperatura de confort; el segundo error fue usar las mismas salidas del sistema de aire climatización para conectar el conducto procedente de la chimenea, (digamos que cada salida / rejilla es una "Y" en la que desembocan los 2 sistemas), y el problema es que parte del aire caliente que llega de la chimenea se "escapa" por el otro conducto antes de salir por la rejilla.

(Adjunto una imagen de lo que sería un sistema de este tipo por ilustrar el tema)

Estos detalles los he detectado al comparar ambos sistemas; con la calefacción por bomba de calor el aire sale a unos 40-50º en las bocas de salida con una fuerza considerable y el "chorro" alcanza sin problemas la zona media de altura provocando una recirculación del aire que reduce la estratificación y calentando rápidamente las estancias; en cambio con el sistema de la chimenea, el aire es impulsado a bastante mas temperatura, 60-90º, pero al no salir con fuerza va formando capas de diferente temperatura llegando a tener hasta 9º de diferencia entre suelo y techo (2,5m), una barbaridad !!

Llevo como un mes dándole vueltas al tema, haciendo pruebas, estudiando diferentes opciones, buscando información de lo que me puede hacer falta y como instalarlo / programarlo y he llegado a algunas conclusiones, pero pese a tener algunas cosas claras me quedan dudas de otras.

La primera modificación va a ser el equipo impulsor, pasando de 400m3/hora a uno de 990m3/h, esto implica tener que poder regular la potencia del mismo por si el nuevo fuese demasiado, hay que tener en cuenta que a mas flujo de aire, este se calentara a menor temperatura.

La segunda será eliminar las salidas combinadas y colocar salidas individuales para la chimenea con difusores circulares de conos en el centro de las habitaciones, esto unido a mayor flujo de aire creo que solucionará en gran parte la estratificación.

En caso de que lo anterior no solucione el problema de estratificación, tengo pensado un plan "B" mas complejo que si toca explicaré mas adelante.

Decía antes que el objetivo sigue siendo el inicial, y no es cierto del todo; ahora lleva una modificación importante, que es regular la cantidad de aire que entra en la cámara de combustión de la chimenea, sería algo similar a regular la salida del tiro, pero a la inversa.

El sistema va a estar controlado por ESP32, la cantidad es una de las dudas, por el momento ya veo la necesidad de al menos dos de ellos por las pruebas que estoy haciendo, ya que necesito:

  • Temperaturas de la chimenea (recuperador de calor, campana de chimenea y tubo de salida de humos).
  • Temperaturas del equipo impulsor (temperatura de entrada de aire y del propio equipo).
  • Temperatura del aire en las distintas bocas de salida repartidas por la casa.
  • Actuar sobre la entrada de aire exterior a la cámara de combustión de la chimenea.
  • Actuar sobre unos extractores ubicados en la campana de la chimenea para sacar el aire caliente cuando sea necesario.
  • Actuar sobre el propio equipo impulsor para encenderlo o apagarlo en función de la temperatura del aire que llega de la chimenea y la temperatura de las estancias.
  • Regular la velocidad del motor del equipo impulsor para que el aire caliente no se "enfríe" demasiado al llegar a las estancias y permita adaptarse a la temperatura a la que entra el aire al equipo.
  • Actuar sobre una válvula maestra que permita mezclar aire mas frío cuando el que llega de la chimenea esté muy caliente (>120º) y, haga de by-pass en caso de corte de electricidad para que el equipo no se sobrecalliente.
  • Actuar sobre cada una de las salidas de aire mediante válvulas regulables para poder priorizar zonas, regular temperaturas de forma independiente en cada estancia o cerrar alguna de ellas que no sea necesaria.

El proyecto (esta vez si !!), está ya en fase de pruebas, por el momento he modificado la instalación de la propia chimenea llevando la entrada de aire exterior a una válvula controlada por un servo y programados varios modos de funcionamiento de forma similar a los dispositivos comerciales que existen de este tipo, salvo que añadiendo alguno mas en función de mis necesidades, estos son: modo encendido, modo automático, modo noche, modo manual y modo apagar; todo ello controlado en la mayor parte por PID. Me falta pulir algunas cosas para, por ejemplo, poder mantener en el modo noche la calefacción "funcionando" el mayor tiempo posible, pero de momento pinta bien el tema.

Por otro lado me llegó hace unos de días la turbina nueva de 990m3/h, y me topé con un pequeño problema; la que tengo actualmente funciona con un motor a 220v que se puede regular fácilmente con un dimmer; la nueva lleva motor tipo brushless con lo que no es posible usar el dimmer previsto.
Afortunadamente el mismo equipo lleva integrado un sistema de 0-10v bastante típico en la industria y me he decantado por el, aunque me he llevado alguna sorpresa al tocar por primera vez el tema de PWM, y aquí empieza mi primera duda.

He visto muchos tutoriales sobre el pwm y muchos de ellos lo explican con la típica regulación del brillo de un led; no he montado el circuito del led pero si he usado el ejemplo del led para poder medir la salida pwm y ver si me servía para regular la velocidad a través de una placa "pwm to 0-10v"

La primera sorpresa ha sido al meter las puntas del tester en los pines pwm, el circuito es el que se muestra en la imagen inferior, vamos, mas simple que el mecanismo de un chicle...

image

... pues bien, al testear los valores de la salida, con la punta negativa del tester en GND y la positiva en el pin de salida pwm obtengo el valor en negativo cuando, entiendo, debería ser al revés (en mi caso es un ESP32-S con pin 33 como salida pwm), pero eso no es todo, también tengo el valor pwm invertido, es decir, cuando hago ledcWrite(canal, 255) debería obtener 3,3v y sin embargo es al revés, obtengo los 3.3 al escribir un valor de 0 en el pwm; no se si estoy haciendo algo mal o me he perdido en algún punto.

El código no tiene ningún misterio, lo pongo para que nadie tenga que andar buscando el ejemplo:

// Pin pwm
const int ledPin = 33;

//Propiedades PWM
const int frecuencia = 2000;
const int canal = 0;
const int resolucion = 8;


void setup()
{
  Serial.begin(115200);
  
  // Configurar pwm
  ledcSetup(canal, frecuencia, resolucion);

  // Asociar pin
  ledcAttachPin(ledPin , canal);
}

void loop()
{
  // Incrementar salida
  Serial.println("Incrementar");
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++)
  {
    ledcWrite(canal, dutyCycle);
    Serial.println(dutyCycle);
    delay(200);
  }

  // Decrementar salida
  Serial.println("Reducir");
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--)
  {
    ledcWrite(canal, dutyCycle);
    Serial.println(dutyCycle);
    delay(200);
  }
}

Vaya tochopost!, lo dejo aquí por ahora a ver si podéis iluminarme un poco con el tema pwm porque fijo que algo se me escapa.

En este link tienes un buen tutorial

Tu ejemplo es para cambiar brillo en el led de 0 a 255 y de 255 a 0 o sea de nada a maximo brillo y de maximo a 0.
Para hacer una prueba yo pondria

ledcWrite(canal, 0);  // y debería leer 0V
ledcWrite(canal, 255);  // y debería leer 3.3V

Dices que no es asi?
Ahora si eso no es asi no podemos pasar al siguiente punto que es atacar con esa salida a un Operacional que tenga a su salida un filtro pasabajos de manera de convertir todo en una salida 0-10V o bien poner un DAC (conversor digital analogico) y lograr lo mismo con algun operacionl tambien porquen ningún DAC tiene salida 0-10V

Hola Surbyte, a Luis Llamas lo he visitado cientos de veces, tiene buenísimos tutoriales bien explicados y esa página de hecho fué la primera que consulte al meterme con el pwm y ahora que la he vuelto a visitar me he dado cuenta que el ejemplo que he puesto es el mismo que tiene él.

Y si, es así y no lo entiendo, lo he comprobado 50 veces he incluso he modificado el loop para poder comprobarlo con valores estáticos por serial...

  if (Serial.available())
  {
    int value = Serial.readString().toInt();
    Serial.println(value );

    ledcWrite(canal, value );
  }

... con el mismo resultado; con valor 0 (cero) obtengo en la salida 3.3v, con valor 255 obtengo prácticamente cero

He ido un poco mas allá con las pruebas y he terminado usando lógica inversa para controlar el conversor DAC que estoy probando, concretamente éste

por un lado he tenido que invertir la señal de entrada pwm al módulo, ya que si lo conectaba como entiendo debe ser GND-PWM input- y pin33-PMW input+ el módulo no hace nada, en cambio si invierto la polaridad funciona!!

Aparte de eso, tengo que escribir un valor de 0 para que en la salida del modulo me entregue los 10v y viceversa que al final he mapeado con:

  if (Serial.available())
  {
    int value = Serial.readString().toInt();

    int out = map(value, 0, 100, 255, 0);

    Serial.println(out);
    ledcWrite(canal, out);
  }

y funciona perfectamente, metiendo por serial 100 obtengo los 10v en la salida del módulo, lo cual no tiene ningún sentido, -el map( 0-100,...) es porque quiero luego hacer el control de la turbina por medio de porcentajes, asi que ya de paso lo he probado-

Por cierto, el módulo ese terrible, linealidad nula, con un valor de 50% (127) me da 7,5v en la salida y con uno de 80% tengo salida de 9,7v !! fijo que tengo que buscar otra alternativa o... hacer una corrección por software.

Añado una imagen de lo que tengo ya hecho y probando en el ESP32 con la integracion en Home Assistant para poner el tema un poco mas en contexto.

Bueno centrémosnos en la salida PWM a una frecuencia dada que veo que has tomado 2khz y esta entre el 1-3Khz de la especificación del DAC que has comprado.
Luego.. deberia funcionar bien.
Sobre la linealidad no puedo decir nada. Pero vamos con lo mas simple.
Que el ESP32 te entregue una PWM como la que esperas. Entre 0 y 255, eso lo has podido verificar con un Osciloscopio?
De lo contrario habria que armar algo con un NANO o UNO que mida PWM. Hay un código de Nick Gammon que lo hace muy facil.
Dirás tanto rollo!! Y si.. hay que estar seguro que todo trabaja como se espera.
Luego con esa salida que sabes funciona bien revisas el conversor, pero bueno creo que todo eso ya lo has hecho. De ahi tus conclusiones de falta de linealidad.
Veremos que respondes.

Tal vez no te guste la idea pero que te parece esto?

En lugar de algo tan complicado como PWM a 0-10V una cosa mas simple como lo es I2C a 0-10V, no deberías tener problemas de linealidad y mas viniendo de DFRobot. Son responsables.

Tengo un osciloscopio de esos baratejos pero para el caso creo que puede servir, la señal es buena pero también indica que la polaridad está invertida. Adjunto un zip con un video del osciloscopio cambiando el delay a 10ms.

PWM osciloscopio.zip (4.6 MB)

Ojo!, esto de la polaridad igual es un problema mío por no saber que es lo que debe sacar realmente y donde, me baso en el ejemplo del led en el que la salida del pwm va al ánodo, la medición de voltaje que obtengo entre los pines GND y pin33 (con punta negativa del multímetro en GND) me da voltaje negativo, quizá la señal es negativa y la medición deba realizarse entre 3.3 y pin33, entonces todo cuadraría. En el video del osciloscopio la pinza va al pin33 y masa a GND.

Para descartar problema de hardware, he hecho la misma prueba con 3 esp32 distintos, uno de ellos de otro modelo y en los 3 el resultado es el mismo.

No descarto el modulo I2C, tengo pedidos a china otros 3 módulos diferentes pwm 0-10v a ver si van mejor linealmente, pero este tema me tiene intrigado por lo de la polaridad principalmente.

Esto esta bien.

Voy a probar lo del PWM porque me llama la atención.

Ok Surbyte, ya comentarás resultados.

Mientras haces las pruebas, expongo otro tema que me trae un poco de cabeza con las sondas de temperatura de humo.

Tengo actualmente 3 sondas colocadas (1, 2 y 3 en la imagen inferior), quiero dejar solo la 2 y 3 por redundancia ya que cuando cierre definitivamente la campana con pladur será bastante difícil acceder a ellas, la sonda 1 me di cuenta después de colocarla que es demasiado larga (100mm para un tubo de 200mm de diámetro) y me va a molestar mucho para pasar el erizo al limpiar el conducto de humos, las otras dos tienen 50mm; son termopares tipo K encapsulados en una funda de acero que van atornillados al mismo tubo, los cables de las sondas son de 3m cada uno.

Las sondas van con sus respectivos módulos MAX6675, al principio estaban en una protoboard y me daban unos errores terribles de lectura seguramente por falso contacto de los cables dupont, así que hice una pcb prototipo con todo soldado y es como están ahora con los MAX6675 atornillados a sus respectivos conectores , no pinchados simplemente.

La conexión de las 3 sondas la he hecho en el bus VSPI del ESP32 tal como muestra la imagen siguiente, VCC y GND proceden de alimentación externa de 5v 3A, el ESP va alimentado también externamente a través del pin 5V0 (Vin).

El código no tiene ningún misterio, declaro variables al inicio y en una función realizo la lectura de datos de las 3 sondas cada 10 segundos, no he aplicado ningún delay porque la propia librería MAX6675 ya lo hace. (pongo extractos porque el código en si es muy extenso a pesar de estar dividido en multiples archivos)


#include "max6675.h"

// Sondas de temperatura de humo MAX6675
int thermoSO = 23;
int thermoCLK = 18;
int thermoCS1 = 5;
int thermoCS2 = 17;
int thermoCS3 = 16;

MAX6675 sensorSmokeTemperature1(thermoCLK, thermoCS1, thermoSO);
MAX6675 sensorSmokeTemperature2(thermoCLK, thermoCS2, thermoSO);
MAX6675 sensorSmokeTemperature3(thermoCLK, thermoCS3, thermoSO);

la lectura la realiza la función siguiente, he comentado sobre la funcion algunas cosas para verla mejor:

/**
 * @brief Obtiene la temperatura de la chimenea y guarda la anterior para uso posterior
 * DLOG es un debug que me muestra por serial o telnet los datos que necesito, basado en la libreria RemoteDebug
 * dumper y device son estructuras que uso para tener un código mas limpio
 * getAverage() y avgAddValue() son llamadas a funciones de una adaptación de la librería Mean Filter de Luis Llamas,
 * guardo los últimos 10 valores registrados y uso la media para estabilizar los datos obtenidos.
 *
 * En la funcion leo cada una de las sondas y compruebo que el valor sea correcto,
 * descartando la medida en caso de haberse estropeado y la reemplazo por la media del filtro en su caso.
*/
void getSmokeTemperature()
{
    double smoke_temperature;
    double smoke_temperature_1 = sensorSmokeTemperature1.readCelsius();
    double smoke_temperature_2 = sensorSmokeTemperature2.readCelsius();
    double smoke_temperature_3 = sensorSmokeTemperature3.readCelsius();

    DLOG("Temperatura Sonda 1: %f\n", smoke_temperature_1);
    DLOG("Temperatura Sonda 2: %f\n", smoke_temperature_2);
    DLOG("Temperatura Sonda 3: %f\n", smoke_temperature_3);

    if (dumper.test_mode)
    {
        dumper.smoke_temperature = dumper.fake_smoke_temperature;
    }
    else
    {
        // Control de errores
        if ( isnan(smoke_temperature_1) && (smoke_temperature_2 > 0 || smoke_temperature_3 > 0) )
        {
            device.state = "Error";
            device.last_error = "Error en sonda de temperatura de humo larga";

            smoke_temperature_1 = getAverage();
        }
        else if ( isnan(smoke_temperature_2) && (smoke_temperature_1 > 0 || smoke_temperature_3 > 0 ) )
        {
            device.state = "Error";
            device.last_error = "Error en sonda de temperatura de humo izquierda";

            smoke_temperature_2 = getAverage();
        }
        else if ( isnan(smoke_temperature_3) && (smoke_temperature_1 > 0 || smoke_temperature_2 > 0 ) )
        {
            device.state = "Error";
            device.last_error = "Error en sonda de temperatura de humo derecha";

            smoke_temperature_3 = getAverage();
        }
        else if ( isnan(smoke_temperature_1) && isnan(smoke_temperature_2) && isnan(smoke_temperature_3) )
        {
            device.state = "Error";
            device.last_error = "Error en sondas de temperatura de humo";

            dumper.smoke_temperature = getAverage();
            return;
        }
        else
        {
            // Si todas las sondas son correctas, calcula la media y añade el dato al registro
            smoke_temperature = (smoke_temperature_1 + smoke_temperature_2 + smoke_temperature_3) / 3;

            DLOG("Temperatura media: %f\n", smoke_temperature);

            dumper.smoke_temperature = avgAddValue(smoke_temperature);
        }
    }
        
    DLOG("Temperatura filtrada: %f\n", dumper.smoke_temperature);
}

El problema que tengo se expone a continuación, tengo una inestabilidad tremenda en las mediciones, las sondas están algo separadas pero creo que no es lo suficiente como para tener tanta diferencia entre ellas, ahora está la chimenea apagada, con lo que la lectura es de temperatura ambiente, pero con alta temperatura también obtengo el mismo error de hasta +- 15º de diferencia entre ellas, llegando a picos de 50º

(D p:^0000ms) _______
(D p:^0002ms) Temperatura Sonda 1: 14.500000
(D p:^0000ms) Temperatura Sonda 2: 16.500000
(D p:^0000ms) Temperatura Sonda 3: 18.000000
(D p:^0000ms) Temperatura media: 16.333333
(D p:^0001ms) Temperatura filtrada: 15.608333
(D p:^9471ms)
(D p:^0002ms) _______
(D p:^0001ms) Temperatura Sonda 1: 17.750000
(D p:^0000ms) Temperatura Sonda 2: 11.750000
(D p:^0000ms) Temperatura Sonda 3: 17.500000
(D p:^0000ms) Temperatura media: 15.666667
(D p:^0001ms) Temperatura filtrada: 15.775000
(D p:^9993ms)
(D p:^0002ms) _______
(D p:^0002ms) Temperatura Sonda 1: 14.750000
(D p:^0000ms) Temperatura Sonda 2: 12.500000
(D p:^0001ms) Temperatura Sonda 3: 18.250000
(D p:^0000ms) Temperatura media: 15.166667
(D p:^0000ms) Temperatura filtrada: 15.850000
(D p:^10511ms)
(D p:^0002ms) _______
(D p:^0002ms) Temperatura Sonda 1: 19.000000
(D p:^0000ms) Temperatura Sonda 2: 13.000000
(D p:^0001ms) Temperatura Sonda 3: 14.500000
(D p:^0000ms) Temperatura media: 15.500000
(D p:^0000ms) Temperatura filtrada: 15.841667
(D p:^9478ms)
(D p:^0003ms) _______
(D p:^0001ms) Temperatura Sonda 1: 13.750000
(D p:^0001ms) Temperatura Sonda 2: 12.000000
(D p:^0000ms) Temperatura Sonda 3: 14.750000
(D p:^0000ms) Temperatura media: 13.500000
(D p:^0001ms) Temperatura filtrada: 15.491667
(D p:^9992ms)
(D p:^0000ms) _______
(D p:^0002ms) Temperatura Sonda 1: 16.500000
(D p:^0000ms) Temperatura Sonda 2: 12.750000
(D p:^0000ms) Temperatura Sonda 3: 15.750000
(D p:^0000ms) Temperatura media: 15.000000
(D p:^0002ms) Temperatura filtrada: 15.408333
(D p:^10513ms)
(D p:^0003ms) _______
(D p:^0002ms) Temperatura Sonda 1: 14.250000
(D p:^0000ms) Temperatura Sonda 2: 17.000000
(D p:^0000ms) Temperatura Sonda 3: 19.250000
(D p:^0000ms) Temperatura media: 16.833333
(D p:^0001ms) Temperatura filtrada: 15.475000
(D p:^9473ms)
(D p:^0000ms) _______
(D p:^0002ms) Temperatura Sonda 1: 18.750000
(D p:^0003ms) Temperatura Sonda 2: 12.250000
(D p:^0000ms) Temperatura Sonda 3: 16.500000
(D p:^0000ms) Temperatura media: 15.833333
(D p:^0000ms) Temperatura filtrada: 15.366667

Y la pregunta es: ¿es normal que este tipo de sondas sean tan inestables?

No armes nada con DUPONT o protoboard, usa siempre placa expermitental soldada y aún asi experimentarás ruidos, etc.
Respecto de la disparidad de las sondas bienvenido al mundo de las mediciones!!
Cada sonda tiene una especificación y si son iguales bueno, te dice... que son de tanta precisión , que tiene tal repetibilidad, etc etc.

Tienes que hacer calibraciones, agua con hielo garantiza 4°C y agua en estado de ebullición normalmente son 100°C. Con esos puntos se supone linealidad. No siempre es el caso.
Si dispones de un buen termómetro podras sumar otros puntos intermedios.. temperatura ambiente, temperatura de algo caliente, tal vez una resistencia electrica controlada de algun modo.
Todos esos puntos debes registrarlos y luego armar una curva de corrección de errores.
Una tabla con la que entras y sales con el valor corregido.

Buff, deja deja que ya no los toco de donde están, con el filtro suavizo los valores y, en caso de algun pico, la variación no es mucha.

Me afecta en parte porque para detectar si se ha abierto la puerta de la chimenea para añadir leña, saco la diferencia entre el mínimo y máximo de los datos guardados y si son muy inestables puede dar falsas detecciones pero puedo vivir con ello.

Era por si se podría añadir algún componente que estabilizase un poco los datos aunque por lo que leido los modulos llevan ya algo de eso.

No entiendo nada...

Me han llegado un par de módulos mas de conversión pwm -> voltaje y me he lanzado a probarlos, (uno de ellos es decente y bastante lineal) pero me he llevado una sorpresa que no esperaba...

Al abrir el IDE 2.2.1 se ha quedado colgado y, impaciente que es uno, he abierto el 1.8.12 para flashear el esp32 y probar los nuevos módulos, y me he quedado a cuadros al ver que el PWM funcionaba como se espera, nada de polaridad ni señal invertida; GND negativo y 3.3v con pwm de 255, después de lo del otro día me he quedado alucinando.

He pensado que podría ser cosa del IDE de Arduino, así que he conectado al puerto serie el otro esp32 flasheado con el IDE 2.2.1 y vaya.... el resultado es correcto.

Por indagar un poco mas, he abierto el IDE 2.2.1 y he vuelto a flashear el esp con el mismo sketch y todo perfecto, he realizado varias pruebas intentando volver a reproducir el fallo pero no lo he conseguido, así que no entiendo nada, las pruebas del otro día eran totalmente opuestas, ¿alguna idea del motivo?

Avanzando en el proyecto, tengo ya definido lo que debe hacer el primer esp32, posteriormente habrá un segundo esp32 para controlar válvulas de las salidas de aire mas distantes y temperaturas de salida. La opción de separarlo en 2 dispositivos son principalmente la distancia y el número de pines; posiblemente tendría suficientes pero tendría que hacer algunas tiradas de cable >15m y seguramente tendría problemas con los sensores DS18B20 por la longitud de cableados y la cantidad (>10).

Concretando el primer esp32 va a llevar:

  • 4 servomotores
  • 2 relés
  • 2 sondas de temperatura MAX6675 (2x3 metros)
  • 6 sensores de temperatura DS18B20 (4x3 metros + 2x10 metros), seguramente en diferentes buses One-Wire por separar longitudes de cableado
  • 1 módulo pwm -> 0-10v

Por otro lado me estoy planteando añadir un módulo step-down para alimentar todo con 12v y bajar a los 5v que necesito para el esp32, servos y sensores, ya que necesito los 12v para alimentar unos ventiladores que sacarán el aire de la campana de la chimenea cuando sea necesario. Otra opción es alimentar todo directamente a 5v y los 12v simplemente pasarlos a través del relé que activará los ventiladores, pero ya tendría que poner 2 fuentes de alimentación diferentes... tengo dudas.

Toca hacer la pcb para todo esto, los servos y sensores DS18B20 no tienen complicación, conectores de tornillo y una resistencia para los DS18B20, pero los MAX6675, el modulo PWM y relés en principio pensaba hacerlo con módulos separados pero me estoy planteando la opción de integrarlos en la PCB para prescindir de ellos, ¿sería complicado? (mis conocimientos de electrónica son mas bien limitados) ¿Cómo veis la opción de integrarlo todo en la pcb?

La opción es posible. El tema es que si no lo has hecho antes puedes tener problemas con la PCB por falta de experiencia.
De todos modos puedes consultar acá y entre todos te daremos nuestra opinión.
Si usas servicios como JLCPCB que tiene el servicio de prototipado barato de 5 USD mas envío, creo que podrias hacer una primer tanda solo para ver si funcionan bien y si fallan sabras que corregir.

Voy a optar por un "hibrido", una PCB con conectores para todas las salidas en la que pinchar los modulos, así en caso de tener que cambiar alguno es sencillo y reduzco mucho el espacio que ocupa el conjunto.

Respecto al esquema, no he añadido nada salvo las 2 resistencias para los DS18B20, veis necesario o recomendable añadir algún filtro u otra cosa?

Cambiaríais alguno de los pines del ESP32 elegidos? he descartado los que creo que son conflictivos en el arranque, pero me he podido equivocar

Cambiariais / añadiriais algo al esquema?

No hace falta poner nada con los DS18B20, salvo la R correspondiente.
Digo yo, y alguna de plascas de extensión de pines para ESP32 no te sirve? Supongo que no.
Por otro lado, usar una placa de extensión de pines de ESP32 y luego agregarle los conectores no facilitaría las cosas o solo las complica?

Algo asi por ejemplo

Claro que tus conectores son mejores.
esta no luce mal


Si conetas transversalmente los conectores ya tienes todo resuelto.
Es una idea.
Tal vez la tuya es mejor, hablo del PCB con los conectores MOLEX
Pero ves esta imagen
image
El hembra coincide con los pines de alguna de las placas como la 2da que los tiene a 100milesimas
Tal vez no quede tan firme como tener el macho y la hembra bien unidos.
Olvida el comentario.

Tengo varias como la primera que has puesto, pero al usar varios modulos separados complica un poco el tema.

Quiero meter todo en una caja de empalmes de pared de modo mas compacto, la pcb que quiero hacer cumple esa función metiendo todo en 14x9cm

La tengo ya diseñada y debería quedar algo como esto:

A ver si mañana me puedo poner con la CNC a ello, no quedará como una profesional pero para hacer una sola puede servir

Esa placa luce bien

No queda tan bonita como una comercial pero es funcional 100%, lleva 2 capas de laca protectora aislante despues de soldar, me ha faltado serigrafiar en la cnc cada contacto de los terminales, tocara rotular a mano >.<

Al final los modulos van soldados directamente, excepto el esp32; al no ser algo que se vaya a desmontar frecuentemente no me he complicado poniendo zocalos... menos posibles fallos.

Mañana primeras pruebas del hard definitivo :laughing:

1 Like

Esta muy buena!!

Voy subiendo fotitos de como va quedando el sistema...

  1. Placa electrónica, 2. Sonda temperatura de campana (DS18B20), 3. Sonda temperatura de chimenea (cajón recuperador de calor, DS18B20), 4. Sondas de temperatura de humo (MAX6675), A. Tubos de absorción de aire caliente, B. Tubos entrada aire a la cámara de combustión.


Ventiladores de extracción de aire caliente de la campana


Cajón de fibra superior en el que se juntan los dos tubos de aspiración de aire caliente con su sonda de temperatura DS18B20


Equipo distribuidor de aire caliente, posiblemente le añada otra sonda de temperatura DS18B20


Válvula regulación de aire que entra a la cámara de combustión (impresión 3D), no me termina de convencer porque aunque llega a cerrar completamente la mariposa, permite que entre algo de aire al hacer succión el fuego, lo que anula parte del sistema; probablemente haga otra con formato de bola buscando mayor estanqueidad.


Circuito ya colocado en su lugar y cableado

Y como no, con algunos problemas...

Desde que monté todo llevo una semana volviéndome loco por un bug en las sondas de humo; de forma aleatoria ambas sondas devolvían un valor de 0.00ºC que provocaba que el regulador se abriese al 100%; este error no seguía ninguna lógica, tal cual como se producía volvía a desaparecer y podía durar desde segundos hasta mas de 1 hora.

Revisé la placa varias veces en busca de algún corto o fallo de pistas, cambié las placas de los MAX6675, modifique la colocación de cableado, comprobé voltajes cuando ocurría el fallo, fui eliminando librerías y código por si había alguna incompatibilidad hasta dejar solo lo relacionado con las sondas de humo... nada, no tenía ningún sentido.

Terminé sacando unas gráficas para intentar averiguar el motivo y descubrí que por la noche y cuando no había nadie en casa el error no ocurría, extraño pero interesante, ya que había un factor humano de por medio...

El detalle que me reveló el problema fue que todos los días por la mañana, sobre la misma hora ocurría el bug y casualmente coincidía con la hora en que alguien se levantaba de dormir... indagando mas en el tema y probando cosas descubrí que un determinado foco led de la cocina (downlight) era el causante del problema, cuando se encendía tumbaba el bus SPI de los MAX6675; hay 8 focos en 2 circuitos diferentes, pero solo uno de ellos causaba el problema, alucinante!!

En parte error mío, ya que durante la instalación, por no liarme mucho, tomé la alimentación de 220V del sistema de la línea de iluminación de la cocina y era por la que estaba entrando el ruido "gracias" al pu** foco led, la he llevado hasta el cuadro general con su correspondiente PIA y problema resuelto.

Dejo adjunto el código del proyecto en un zip (no lo posteo como code porque son bastantes archivos), pero aviso de que falta aun mucho trabajo, aunque como base creo que no va mal. Lo he comentado ampliamente para que sea legible.

Acepto correcciones, sugerencias o cualquier ayuda relacionada con el mismo, serán bien recibidas :grinning:

Code.zip (28.1 KB)

Increíble pero asi pasa en el mundo de la electrónica.