¿Es posible emular una centralita con Arduino?

[amikoj]

Barrigo,

Felicidades, a ver si vemos 

Salud y Kms

[Barrigo]

Buenas,

Os pongo unas fotos de la controladora y el esquema. Como veis encaja perfectamente en el hueco de la controladora original.
El programa os lo pondré dentro de poco, pues aun estoy depurandolo.
En el esquema vereis que hay un bloque que se llama arduino nano, es el arduino que venden sin puerto USB, aunque podeis usar el que querais, falta en el esquema el sensor de temperatura exterior y anular el interior (lm35) que al final no he usado para nada, el exterior se conecta a un pin digital (yo elegí el D7) ya que se comunica con arduino mediante OneWire.

Tambien en el programa esta implementada una pantalla I2C de 128x64 pixeles, podeis o no ponerla, ya que solo da info de temperaturas y demás
La calefacción esta preparada para usarse con el control original webasto, tiene una entrada para el regulador de potencia y otra para el interruptor de puesta en marcha.

https://dl.dropboxusercontent.com/u/14680273/Webasto/esquema_webasto.pdf

Un saludo

[Barrigo]

Os pongo el código de arranque de la calefacción, aun tengo que depurarlo pero funciona y arranca bien.

Código [Seleccionar] Expandir

void Arranque()
{
  for(int s = 0; s <= 110; s++)
  {
    analogWrite(ventilador,s); //enciendo el ventilador poco a poco hasta el 50% para limpiar la caldera
    delay(10);                 //durante unos 5 segundos
  }
  analogWrite(ventilador,110);
  for(int s = 0; s <= 100; s++)  //retraso de 2seg, se puede poner dentro orden de paro o algo asi
  {
    delay(20);
    datos();
  }
  for(int s = 0; s <= 16; s++)  //Enciendo bujia poco a poco hasta los 16V
  {
    dato2=s;
    BUJIA();
    delay(500);
  }
  t_off=5;                     ///******************************************************************************************Cinco pulsos de bomba, probar
  MsTimer2::start();            ///
  while(pulsos<=5){}            ///
  pulsos=0;
  t_off=20;                     //Toff de la bomba de gasoil a 2000ms
  MsTimer2::start();            //activo el timer que activa la bomba
  PTc();                         //Leo la temperatura de la caldera (si enciendo es porque esta apagada)
  while(Temp_cald2 <= 5)          //Espero que suba la temperatura de la caldera
  {                              //Leo temperatura de la caldera para comprobarla
    datos();
    delay(200);
    leerpare();
    if(pare>=1){break;}
    PTc();
  }
  analogWrite(bujia,0);
  analogWrite(ventilador,130);
  PWM_ventilador=130;
  arrancada = 1;
}

void PTc()        ///// Temperatura del quemador, como no se las temperaturas de dentro, he considerado lo siguiente:
{                      // Un valor 3, significa la caldera encendida pero muy poca temperatura
  valor = analogRead(6);  //Un valor 4, 5 y 6, temperatura ideal de funcionamiento
  Temp_cald2 = valor;      // Valor 7 es temperatura algo elevada, no he visto necesario que la temperatura suba más
}


Este es el que hace funcionar la bomba de gasoil y el que calcula la tensión que le llega a la bujia de incandescencia

Código [Seleccionar] Expandir

void gasoil()
{
  veces_bomba++;
  if (estado_bomba==HIGH)
  {
    estado_bomba=LOW;
  }
  else if (veces_bomba >= t_off)
  {
    estado_bomba=HIGH;
    veces_bomba=0;
    pulsos++;
  }
  digitalWrite( bomba, estado_bomba);
}

void BUJIA()
{
  Tension();                              //Leo la tension de alimentacion Vin2.
  pwm_punto=(dato2/Vin)*255.00;           //Calculo el dato pwm necesario para la tension solicitada
  PWM_bujia=pwm_punto;
  if(PWM_bujia>=255) {PWM_bujia=255;}     //Limito el dato pwm a 255
  if(Vin2>=20 & PWM_bujia>=191)           //Si la tension de alimentación es mayor de 20V y el pwm mayor de 191
  {
    PWM_bujia=191;                        //Limito el pwm a 191 que son los 18V que aguanta maximo
  }
  analogWrite(bujia,PWM_bujia);
}

void Tension()      //Leo la tensión de alimentación.
{
  valor = analogRead(1);
  Vo = (valor*5.00)/1023.00;
  Vin = Vo*5.00;
  Vin2 = Vin;
}


Para el funcionamiento de la bomba he usado el Timer2 con la libreria <MsTimer2.h> y activo la interrupcion para que entre en la rutina cada 100mS, de modo que consigo controlar el tiempo en On a 100mS y el off de 100ms en 100ms con un minimo de 900mS y un maximo de 3400mS

[Barrigo]

Aqui os traigo el programa completo funcionando a la perfección, el mando de ruleta original webasto controla la temperatura entre 5ºC y 27ºC.
He programado un regulador simple que según la diferencia de temperatura que haya en la sonda y en el mando hace que aumente o disminuya la frecuencia de los pulsos de la bomba entre 1Hz y 0.33Hz, y por lo tanto la potencia de la calefacción entre 2kw y 660w aprox. Cuando la temperatura sobrepasa la marcada la calefacción se para, y vuelve otra vez a funcionar cuando hay una diferencia de 3ºC.

El ventilador lo controlo con la temperatura de la calefacción y la temperatura del interior de la caldera, para cuando la calefacción esta a menos de 80ºC mantengo la temperatura de dentro de la caldera al maximo, cuando está entre 80 y 115 bajo un poco la temperatura aumentando la velocidad del ventilador y así sucesivamente.
Aqui si que he usado un control PID que da buen resultado.
De esta manera ajusto de forma automatica la mezcla de gasoil y aire de tal forma que no le afecta la altura ya que siempre va a intentar mantener la temperatura de la caldera lo más alta posible aumentando o disminuyendo la cantidad de aire para una misma cantidad de gasoil. (probado una noche a 2000m de altura y perfecto)

El arranque tambien lo he optimizado para que arranque lo antes posible y de la manera más economica en cuanto a energia electrica se refiere.

Medí en una webasto 24V con centralita original la tensión con la que alimentan a la bujia y salia una tensión media de 12V !!!!! Así que para la bujia se puede hacer una toma directa de 12V y usar un relé en vez de un mosfet y la electrónica que conlleva.

Bueno, aqui el código despues de tanto rollo 

Código [Seleccionar] Expandir

/**************************Controladora para calefacción Webasto air top 2000 ST*********************************************
/////////*********************Diseñada y programada por Rodrigo González Navas*********************************\\\\\\\\\\\\\\
*/

#include <MsTimer2.h>

//En que pin está conectado cada dispositivo
#define ventilador 9
#define bujia 10      //Encendido
#define bomba 8
#define onoff 12
#define temp 0
#define pt2000 7
#define PTC 6        //Sensor de llama
//Variables que se usan en el programa
boolean estado_bomba = LOW;
int veces_bomba = 0;
int t_off = 14;        //Cantidad de gasoil adecuado para arranque, ventilador 60%
int dato1=0;
int dato2=0;
unsigned long tant=0;

int valor=0;
float Vo=0.00;
float Rpt2000=0.00;
float Temp_aire=0.00;
int Temp_aire2=0;
float Vin = 0.00;
int Vin2 = 0;
float RPTc = 0.00;
float Temp_cald = 0.00;
int Temp_cald2 = 0;
float tantoporuno = 0.00;
float dato = 0.00;
int PWM_bujia=0;
float pwm_punto=0.00;
int Vbujia=0;
int pare=0;
int PWM_ventilador=0;
int arrancada=0;
int mando=0;
unsigned long tiempo_arranque=0;
boolean fallo=LOW;
boolean ya=LOW;
int intentos=0;

int Tempmando=0;
int Tempmando2=0;

//Fin variables

//Variables regulador 1 de la temperatura de la caldera
#define Muestreo 500 //muestreo en milisegundos
#define ki 0.08
#define kp 0.9
#define IntegralMax 5
#define IntegralMin -5
#define SalidaMax 20
#define SalidaMin -20

unsigned long Ahora=0;
int TiempoCambio=0;
unsigned long TiempoAnterior=0;
int Referencia = 6;
int Entrada = 0;
float TerminoIntegral = 0;
float error;
float DEntrada=0;
int EntradaAnterior=0;
float Salida = 0;
int PWM_ventiladorMAX = 150;
int PWM_ventiladorMIN = 110;
int PWM_ventiladorAVG = 130;
//Fin variables regulador

//Variables regulador temperatura furgo
int diferencia=0;
unsigned long TiempoAnterior2=0;
#define Muestreo2 2000
int PWM_ventiladorAnterior = 0;

//Variables sensor temperatura exterior
#include <OneWire.h>
OneWire ds(7);
byte i;
byte type_s;
byte data[12];
byte addr[8];
float celsius =0;
byte dir[8]={0x28,0xAA,0xEE,0xEB,0x3,0x0,0x0,0xCC};
byte present = 0;
int temp_furgo = 0;
//Fin variables sensor temperatura exterior

void setup()
{
  // codigo para modificar la frecuencia del PWM salida 9 y 10
  TCCR1A = 0x00;  // esto es para setear el timer en uno de los modos de generación de PWM
  TCCR1B = 0x11; // esto setea el "prescaler" (N), de la siguiente manera:
  // TCCR1B=0x11 -->N=1;  TCCR1B=0x12 -->N=8;  TCCR1B=0x13 -->N=64, etc.
  // N, el famoso "prescaler", es un divisor del clock de la Arduino (16MHz)
  ICR1 = 255; //  ICR1 es el valor máximo del analogWrite, lo que le llaman el "TOP" 
  // fin codigo pwm
//  Serial.begin(9600);            //Activo el puerto serie para comunicarme con la calefacción
  MsTimer2::set(100, gasoil);    //Timer 2, activa la interrupción cada 100mS
  pinMode(ventilador,OUTPUT);
  pinMode(bujia,OUTPUT);
  pinMode(bomba,OUTPUT);
  pinMode(onoff,INPUT);
  digitalWrite(bujia,LOW);
  digitalWrite(bomba,LOW);
  digitalWrite(ventilador,LOW);
}


void loop()
{
    PTc();
  if ((digitalRead(onoff)==HIGH) && arrancada==0 && fallo==LOW) //si esta apagada y el interruptor de encendido esta activo
  {
    temperatura();                                      //Leo la temperatura de la furgo
    mandoTemp();                                        //Leo la posicion del mando de regulacion
    if((temp_furgo >= Tempmando) && (Temp_aire2 >= 55))  //Si la temperatura de la furgo es mayor o igual a la del mando de regulacion, Y la temperatura dentro de la calefacción es mayor a 55º, apago la calefacción
    {
      parada();
    }
    else if(Tempmando - temp_furgo >= 3)                  //Si la temperatura del mando menos la temperatura de la furgo es mayor o igual que 5, enciendo la calefacción.
    {
      pare=0;
      ya=LOW;
      Arranque();
    }
  }
  else if ((Temp_cald2 >= 4)&&(arrancada == 1)) //Caldera encendida, entonces regulo la cantidad de gasoil y ventilador segun el mando de potencia
  {
    regulador2();
    seleccion();
    regulador();
    analogWrite(ventilador,PWM_ventilador);
    if(temp_furgo >= Tempmando + 2)            //Cuando la temperatura de la furgo suba 2ºC más de la marcada, paro.
    {
      parada();
    }
  }
 
  else if (digitalRead(onoff)==HIGH && fallo==HIGH)
  {
    //Que hacer en caso de error
  }
 
  if ((digitalRead(onoff)==LOW)&&(arrancada==1)) //Apago la caldera, si esta encendida y el interruptor esta desactivado
  {
    parada();
  }
  else if (digitalRead(onoff)==LOW && fallo==HIGH)
  {
    fallo=LOW;                                         //Si doy al boton de apagar y la calefacción tenia error, lo reseteo para intentar arrancar sabiendo que no va bien.
    intentos=0;
  }
 
  if ((Temp_cald2 >= 4)&&(arrancada == 0)) //Caldera apagandose, Si la calefacción esta caliente y debería estar apagada, enciendo ventilador para refrigerar y apago todo.
  {
    PWM_ventilador=60;
    parada();
  }
 
  if ((Temp_cald2 <= 2)&&(arrancada == 1)&&(fallo==LOW)) //Caldera se apagó, Si la calefacción se ha apagado cuando debería estar encendida, intento encenderla de nuevo
  {
    Arranque();
  }
}


void mandoTemp()
{
  mando=analogRead(3);
  mando=constrain(mando,130,700);
  Tempmando=map(mando,130,700,5,27);
  Tempmando=constrain(Tempmando,5,27);
}



int retraso=400;
void parada()        //Rutina de parada
{
  MsTimer2::stop();
  digitalWrite(bomba, LOW);
  analogWrite(bujia,0);
  analogWrite(ventilador,PWM_ventilador);
  retraso=14000/(PWM_ventilador-60);
  PTc();
  if(Temp_cald2>=3)
  {
    for(int s = PWM_ventilador; s >= 60; s--)
    {
      analogWrite(ventilador,s);
      delay(retraso);
    }
  }
  analogWrite(ventilador,60);
  while(Temp_aire2>=50)
  {
    PT2000();
  }
  analogWrite(ventilador,0);
  arrancada=0;
}

void leerpare()
{
  if(digitalRead(onoff)==LOW)
  {
    parada();
    pare=1;
  }
}


void regulador()
{
  Ahora = millis();
  TiempoCambio = (Ahora - TiempoAnterior);
  if(TiempoCambio >= Muestreo)
  {
    PT2000();
    if(Temp_aire2 < 80)
    {
      Referencia = 7;
    }
    else if(Temp_aire2 >= 80 && Temp_aire2 < 115)
    {
      Referencia = 6;
    }
    else if(Temp_aire2 >= 115 && Temp_aire2 < 140)
    {
      Referencia = 5;
    }
    else if(Temp_aire2 >= 140)
    {
      parada();
    }
    PTc();
    Entrada = Temp_cald2;
    /*Calculamos todas las variables de error*/
    error = Entrada - Referencia;
    TerminoIntegral += (ki * error);
   
    if(TerminoIntegral > IntegralMax) TerminoIntegral = IntegralMax;
    else if(TerminoIntegral < IntegralMin) TerminoIntegral= IntegralMin;

    /*Calculamos la salida del PID*/
    Salida = kp * error + TerminoIntegral;
    if(Salida > SalidaMax) Salida = SalidaMax;
    else if(Salida < SalidaMin) Salida = SalidaMin;

    /*Actualizamos las variables "anteriores"*/
    EntradaAnterior = Entrada;
    TiempoAnterior = Ahora;
    PWM_ventilador = PWM_ventiladorAVG + Salida;
    if(PWM_ventilador > PWM_ventiladorMAX ) PWM_ventilador = PWM_ventiladorMAX;
    else if(PWM_ventilador < PWM_ventiladorMIN ) PWM_ventilador = PWM_ventiladorMIN;
  }
}

void regulador2()
{
  Ahora = millis();
  TiempoCambio = (Ahora - TiempoAnterior2); 
  if(TiempoCambio >= Muestreo2)
  {
    temperatura();
    mandoTemp();
    diferencia=Tempmando-temp_furgo;
    if(diferencia >= 21){t_off=9;}
    else if(diferencia >= 19 && diferencia < 21){t_off=11;}
    else if(diferencia >= 17 && diferencia < 19){t_off=13;}
    else if(diferencia >= 15 && diferencia < 17){t_off=15;}
    else if(diferencia >= 13 && diferencia < 15){t_off=17;}
    else if(diferencia >= 11 && diferencia < 13){t_off=19;}
    else if(diferencia >= 9 && diferencia < 11){t_off=21;}
    else if(diferencia >= 7 && diferencia < 9){t_off=23;}
    else if(diferencia >= 5 && diferencia < 7){t_off=25;}
    else if(diferencia >= 3 && diferencia < 5){t_off=27;}
    else if(diferencia < 3){t_off=29;}
    TiempoAnterior2 = Ahora;
  }
}

void seleccion()
{
  PWM_ventiladorAnterior = PWM_ventiladorAVG;
  if(t_off<30 && t_off>=28)
  {
    t_off = 29;
    PWM_ventiladorMAX = 100;
    PWM_ventiladorMIN = 60;
    PWM_ventiladorAVG = 80;
  }
  else if(t_off<28 && t_off>=26)
  {
    t_off = 27;
    PWM_ventiladorMAX = 110;
    PWM_ventiladorMIN = 70;
    PWM_ventiladorAVG = 90;
  }
  else if(t_off<26 && t_off>=24)
  {
    t_off = 25;
    PWM_ventiladorMAX = 120;
    PWM_ventiladorMIN = 80;
    PWM_ventiladorAVG = 100;
  }
  else if(t_off<24 && t_off>=22)
  {
    t_off = 23;
    PWM_ventiladorMAX = 130;
    PWM_ventiladorMIN = 90;
    PWM_ventiladorAVG = 110;
  }
  else if(t_off<22 && t_off>=20)
  {
    t_off = 21;
    PWM_ventiladorMAX = 140;
    PWM_ventiladorMIN = 100;
    PWM_ventiladorAVG = 120;
  }
  else if(t_off<20 && t_off>=18)
  {
    t_off = 19;
    PWM_ventiladorMAX = 150;
    PWM_ventiladorMIN = 110;
    PWM_ventiladorAVG = 130;
  }
  else if(t_off<18 && t_off>=16)
  {
    t_off = 17;
    PWM_ventiladorMAX = 162;
    PWM_ventiladorMIN = 122;
    PWM_ventiladorAVG = 142;
  }
  else if(t_off<16 && t_off>=14)
  {
    t_off = 15;
    PWM_ventiladorMAX = 175;
    PWM_ventiladorMIN = 135;
    PWM_ventiladorAVG = 155;
  }
  else if(t_off<14 && t_off>=12)
  {
    t_off = 13;
    PWM_ventiladorMAX = 190;
    PWM_ventiladorMIN = 150;
    PWM_ventiladorAVG = 170;
  }
  else if(t_off<12 && t_off>=10)
  {
    t_off = 11;
    PWM_ventiladorMAX = 205;
    PWM_ventiladorMIN = 165;
    PWM_ventiladorAVG = 185;
  }
  else if(t_off<10 && t_off>=9)
  {
    t_off = 9;
    PWM_ventiladorMAX = 220;
    PWM_ventiladorMIN = 180;
    PWM_ventiladorAVG = 200;
  }
 
  if (PWM_ventiladorAnterior != PWM_ventiladorAVG)
  {
    if(PWM_ventilador > PWM_ventiladorAVG)
    {
      for(int s = PWM_ventilador; s > PWM_ventiladorAVG; s--)
      {
        analogWrite(ventilador,s);
        //datos();
        delay(400);
      }
    }
    else if(PWM_ventilador < PWM_ventiladorAVG)
    {
      for(int s = PWM_ventilador; s < PWM_ventiladorAVG; s++)
      {
        analogWrite(ventilador,s);
        //datos();
        delay(400);
      }
    }
  }
}

void Arranque() //Arranque suave
{
  for(int s = 0; s <= 80; s++)
  {
    analogWrite(ventilador,s); //enciendo el ventilador poco a poco hasta el 50% para limpiar la caldera
    delay(20);   
  }
  analogWrite(ventilador,80);
  for(int s = 0; s <= 13; s++)  //Enciendo bujia poco a poco hasta los 13V
  {
    Vbujia=s;
    BUJIA();
    delay(200);
  }
  t_off=7;
  MsTimer2::start();            //activo el timer que activa la bomba
  for(int s = 0; s <= 9; s++)    // 7 Impulsos para purgar la caldera y llenarla de gasoil rapidamente
  {
    //datos();
    delay(500);
  }
  t_off=16;                     //Toff de la bomba de gasoil a 1900ms
  PTc();                         //Leo la temperatura de la caldera (si enciendo es porque esta apagada)
  tiempo_arranque=millis();
  while(Temp_cald2 <= 5)          //Espero que suba la temperatura de la caldera
  {                              //Leo temperatura de la caldera para comprobarla
    //datos();                      //Mando info de la calefacción a traves del puerto serie
    delay(100);
    leerpare();
    if(pare==1){break;}
    PTc();
    if(millis()-tiempo_arranque >= 120000)    //Si en 100 segundo no arranca algo va mal
    {
      parada();
      fallo=HIGH;
      break;
    }
    else if (Temp_cald2 >= 4 && ya==LOW)
    {
      for(int s = 80; s <= 100; s++)
      {
      analogWrite(ventilador,s);
      delay(60);   
      }
      ya=HIGH;
    }
  }
  if (fallo==LOW && pare==0)
  {
    analogWrite(bujia,0);
    Vbujia=0;
    t_off=19;
    for(int s = 100; s <= 120; s++)
    {
    analogWrite(ventilador,s);
    delay(60);   
    }
    analogWrite(ventilador,120);
    PWM_ventilador=120;
    arrancada = 1;
  }
  ya=LOW;
}

void temperatura() //Sonda de temperatura exterior (la de la furgoneta) DS18B20
{
  ds.reset();
  ds.select(dir);
  ds.write(0x44);
  delay(100);
  present = ds.reset();
  ds.select(dir);   
  ds.write(0xBE);
  for ( i = 0; i < 9; i++)
  {
    data[i] = ds.read();
  }

  int16_t raw = (data[1] << 8) | data[0];
  if (type_s)
  {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10)
    {
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  }
  else
  {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
  }
  celsius = (float)raw / 16.0;        //Dato con decimales ideal para mostrar en pantalla
  temp_furgo = celsius;                //Dato sin decimales para usar en el programa
}

void gasoil()
{
    veces_bomba++;
    if (estado_bomba==HIGH)
    {
      estado_bomba=LOW;
    }
    else if (veces_bomba >= t_off)
    {
      estado_bomba=HIGH;
      veces_bomba=0;
    }
    digitalWrite( bomba, estado_bomba);
}

void PT2000()
{
  valor = analogRead(7);
  Vo = (valor*5.00)/1023.00;
  Rpt2000 = (2200.00*Vo)/(5.00-Vo);
  Temp_aire = ((0.9*Rpt2000)-1802.00)/7.00;
  Temp_aire2 = Temp_aire;
}

void Tension()
{
  valor = analogRead(1);
  Vo = (valor*5.00)/1023.00;
  Vin = Vo*5.00;
  Vin2 = Vin;
}

void PTc()
{
  valor = analogRead(6);
  Temp_cald2 = valor;
}

void BUJIA()
{
  Tension();                              //Leo la tension de alimentacion Vin2.
  pwm_punto=(Vbujia/Vin)*255.00;           //Calculo el dato pwm necesario para la tension solicitada
  PWM_bujia=pwm_punto;
  if(PWM_bujia>=255) {PWM_bujia=255;}     //Limito el dato pwm a 255
  if(Vin2>=20 & PWM_bujia>=191)           //Si la tension de alimentación es mayor de 20V y el pwm mayor de 191
  {
    PWM_bujia=170;                        //Limito el pwm a 191 que son los 18V que aguanta maximo
  }
  analogWrite(bujia,PWM_bujia);
}



[amikoj]

Sin duda un gran trabajo. Ojalá yo supiese código como tu. Muchas felicidades.

[arkaizt]

jo jo jo!! No habia visto esto, no se como es esa calefa pero deberias bañar esa placa en gel anticalorico como las originales. Por otro lado, enhorabuena, mañana con menos sueño me leo bien el programa y si nolo veo te pregunto una cosa sobre el tema ventilador.

[Barrigo]

Sin duda un gran trabajo. Ojalá yo supiese código como tu. Muchas felicidades.

Realmente el código es muy de andar por casa, mis conocimientos de programación son limitados y es lo que he ido aprendiendo yo solo a base de ver otros programas.
Muchas gracias, un saludo

jo jo jo!! No habia visto esto, no se como es esa calefa pero deberias bañar esa placa en gel anticalorico como las originales. Por otro lado, enhorabuena, mañana con menos sueño me leo bien el programa y si nolo veo te pregunto una cosa sobre el tema ventilador.

La original de esta no va bañada en nada, ya que va en una "caja" semi-hermetica, además está en la entrada del aire frio y no se calienta nada.
Y pregunta todo lo que quieras, incluso si podeis dar alguna idea o inovación será bien recibida.
Muchas gracias

Un saludo!

[arkaizt]

Aaa ok, en el caso de la webasto va bañada por que va dentro a pelo justo al lado de la carcasa de combustión.

Enviado desde mi Aquaris M5 mediante Tapatalk

[rovas]

Buauuu, soys unos maquinonessss, yo he trabajado algo con Arduino UNO y veo que aqui no os quedais nada cortossss!!!!!
Saludo maquinass

[carlos cortes]

Buenas,

Os pongo unas fotos de la controladora y el esquema. Como veis encaja perfectamente en el hueco de la controladora original.
El programa os lo pondré dentro de poco, pues aun estoy depurandolo.
En el esquema vereis que hay un bloque que se llama arduino nano, es el arduino que venden sin puerto USB, aunque podeis usar el que querais, falta en el esquema el sensor de temperatura exterior y anular el interior (lm35) que al final no he usado para nada, el exterior se conecta a un pin digital (yo elegí el D7) ya que se comunica con arduino mediante OneWire.

Tambien en el programa esta implementada una pantalla I2C de 128x64 pixeles, podeis o no ponerla, ya que solo da info de temperaturas y demás
La calefacción esta preparada para usarse con el control original webasto, tiene una entrada para el regulador de potenciales y otra para el interruptor de puesta en marcha.

https://dl.dropboxusercontent.com/u/14680273/Webasto/esquema_webasto.pdf

Un saludo





Alguien puede ayudarme con esto? El enlace no funciona y las fotos no se ven!!

Alguien que pueda ayudarme para hacerlo en una eberspacher??
Gracias

[Freview]

Buenas,

Os pongo unas fotos de la controladora y el esquema. Como veis encaja perfectamente en el hueco de la controladora original.
El programa os lo pondré dentro de poco, pues aun estoy depurandolo.
En el esquema vereis que hay un bloque que se llama arduino nano, es el arduino que venden sin puerto USB, aunque podeis usar el que querais, falta en el esquema el sensor de temperatura exterior y anular el interior (lm35) que al final no he usado para nada, el exterior se conecta a un pin digital (yo elegí el D7) ya que se comunica con arduino mediante OneWire.

Tambien en el programa esta implementada una pantalla I2C de 128x64 pixeles, podeis o no ponerla, ya que solo da info de temperaturas y demás
La calefacción esta preparada para usarse con el control original webasto, tiene una entrada para el regulador de potencia y otra para el interruptor de puesta en marcha.

https://dl.dropboxusercontent.com/u/14680273/Webasto/esquema_webasto.pdf

Un saludo

Hola compañero, hace ya bastante que subiste este esquema, pero tengo una pregunta a ver si puedes ayudarme. El componente U5 DRIVER MOSFET, que componente es? el mas parecido que he encontrado es el TC4422 pero no me funciona bien el PWM en el motor, depende de los mhz o hace zumbidos el motor, o si lo subo hasta 16khz los transistores se ponen achicharrando y estallan, aun tenido un buen disipador.