Control de aire acondicionado (Automóvil)

[Swift]

Pues en principio en la consola serial del putty o la platformio no hay ningún problema la muestra en el mismo sitio, pero en la aplicación para android "ArduinoDroid" lo muestra con un salto de línea pero bueno eso no es problema aquí el video que lo demuestra aplicando sprintf, lo que se me paso por la cabeza al implementar eso que pasara cuando por ejemplo pasa de 1000 RPM a 800 RPM me lo mostrará así 1800 RPM jajaja.

Bien... tengo algunas sugerencias.
Creo que te estas complicando en algunos puntos. Hoy por hoy deberias considerar (pero hablo con alguna ligereza) leer datos del motor usando ODB2. No hay fallos, funciona perfecto. Y tienes eso y mas.
Temperatura, la tienes, RPM, lo tienes. No se que mas. Vale la pena vs lo que estas haciendo.... ya veremos.

El mayor problema de esto es que mi Corolla al ser un generación 9 (G9) no tiene el protocolo estándar que utiliza el OBD2  CAN-H y CAN-L (J-2284) sino utiliza una iso 9141-2 (K-line) o en el peor de los casos es una variante MOBD o EOBD del OBD1, según lo que e investigado ahora me parece que ELM327 soporta este protocolo según el datasheet voy a intentar conseguirme uno para hacer las pruebas y ver lo que sucede.
Gracias por la corrección y por la información adicional.

[surbyte]

que lo demuestra aplicando sprintf, lo que se me paso por la cabeza al implementar eso que pasara cuando por ejemplo pasa de 1000 RPM a 800 RPM me lo mostrará así 1800 RPM jajaja.

No se porque pensé que era una pantalla TFT, ya veo e imagino cualquier cosa. Disculpa.

de todas formas si tiene 4 digitos que mostrar con sprintf, puedes decirle que lo haga y si son 3,2 o 1 agregará 0 a la izquierda de este modo. Tienes dos maneras con 0s o sin 0s.

Sin 0s pero con 4 lugares fijos

Code: [Select]

sprintf(buffer, "RPM %4d", iRpm);

Esto daría resultados asi
RPM: __20
RPM: _120
RPM: 2030
olvida el _ es para mostrar el espacio, pero es lugar vacío

Con 0s y además 4 lugares fijos

Code: [Select]

sprintf(buffer, "RPM %04d", iRpm);

Esto daría resultados asi
RPM: 0020
RPM: 0120
RPM: 2030

[Swift]

Buenas a todos, se me presentó un problema:
No puedo leer ningún dato adicional al de las revoluciones por el puerto OBD, con el típico elm327, esto puede por ser 2 causas, o bien hay algún fallo en mi sistema eléctrico, o es algún protocolo especial, entonces para hacer las lecturas tanto de revoluciones, temperatura, velocidad tocará utilizar algun convertidor de frecuencia a voltaje como el LM2907 (que me parece que lo utilizan en velocimetros) y este voltaje leerlo por el puerto análogo y posteriormente transformarlo  o algún otro sistema creo que se podría leer las frecuencias con varios attiny2313 comunicados por SPI, IC2, o serial con el arduino mega, bueno solo es una idea, alguna sugerencia.
El código no a cambiado ya que estoy pensando como seria la mejor forma de enviar los datos a la aplicación de la pc, e intentado aplicar los tutoriales de Metaconta pero hay veces que la aplicación se me congela, puede ser un error de la aplicación, seguiré intentando buscar la solución.
Ahora la Aduana me entregó la pantalla se demoró menos de lo que esperaba jajajaj adjunto una imagen de como quedo instalada.  

[surbyte]

Vaya que ya tiene pinta de un TESLA-TOYOTA o a la inversa!!!

Bien Swift porque no medir esa frecuencia con el mismo Arduino antes de meter un elemento que introduzca error como un LM2907, lo recuerdo de mis comienzos en electrónica pero ahora?? Esta fuera de época.
Puedes medir frecuencia usando un pin dedicado a ello en el Arduino. Hay uno especial asociado con los timers. Se llama Input Capture Pin. Es el pin 8.

Busca como usarlo pero es tu solución.

[Swift]

Segun busque del Input Capture Pin en el caso del arduino uno es el 8 incluso en la respuesta número 12 de Nick Gammon ponen un ejemplo:

Code: [Select]


// Frequency timer using input capture unit
// Author: Nick Gammon
// Date: 31 August 2013

// Input: Pin D8

volatile boolean first;
volatile boolean triggered;
volatile unsigned long overflowCount;
volatile unsigned long startTime;
volatile unsigned long finishTime;

// timer overflows (every 65536 counts)
ISR (TIMER1_OVF_vect)
{
  overflowCount++;
}  // end of TIMER1_OVF_vect

ISR (TIMER1_CAPT_vect)
  {
  // grab counter value before it changes any more
  unsigned int timer1CounterValue;
  timer1CounterValue = ICR1;  // see datasheet, page 117 (accessing 16-bit registers)
  unsigned long overflowCopy = overflowCount;
  
  // if just missed an overflow
  if ((TIFR1 & bit (TOV1)) && timer1CounterValue < 0x7FFF)
    overflowCopy++;
  
  // wait until we noticed last one
  if (triggered)
    return;

  if (first)
    {
    startTime = (overflowCopy << 16) + timer1CounterValue;
    first = false;
    return;  
    }
    
  finishTime = (overflowCopy << 16) + timer1CounterValue;
  triggered = true;
  TIMSK1 = 0;    // no more interrupts for now
  }  // end of TIMER1_CAPT_vect
  
void prepareForInterrupts ()
  {
  noInterrupts ();  // protected code
  first = true;
  triggered = false;  // re-arm for next time
  // reset Timer 1
  TCCR1A = 0;
  TCCR1B = 0;
  
  TIFR1 = bit (ICF1) | bit (TOV1);  // clear flags so we don't get a bogus interrupt
  TCNT1 = 0;          // Counter to zero
  overflowCount = 0;  // Therefore no overflows yet
  
  // Timer 1 - counts clock pulses
  TIMSK1 = bit (TOIE1) | bit (ICIE1);   // interrupt on Timer 1 overflow and input capture
  // start Timer 1, no prescaler
  TCCR1B =  bit (CS10) | bit (ICES1);  // plus Input Capture Edge Select (rising on D8)
  interrupts ();
  }  // end of prepareForInterrupts
  

void setup ()
  {
  Serial.begin(115200);      
  Serial.println("Frequency Counter");
  // set up for interrupts
  prepareForInterrupts ();  
  } // end of setup

void loop ()
  {
  // wait till we have a reading
  if (!triggered)
    return;
 
  // period is elapsed time
  unsigned long elapsedTime = finishTime - startTime;
  // frequency is inverse of period, adjusted for clock period
  float freq = F_CPU / float (elapsedTime);  // each tick is 62.5 ns at 16 MHz
  
  Serial.print ("Took: ");
  Serial.print (elapsedTime);
  Serial.print (" counts. ");

  Serial.print ("Frequency: ");
  Serial.print (freq);
  Serial.println (" Hz. ");

  // so we can read it  
  delay (500);

  prepareForInterrupts ();  
}   // end of loopel cual mide correctamente hasta 200 kHz a partir de es frecuencia empieza a fallar, ahora en mi caso necesitaria 3 pines para leer las 3 frecuencias que tengo(Velocidad, Revoluciones, y temperatura) por lo que, en el arduino mega que tengo para controlar los servos de la calefacción y  posición de ventanas y diferentes relés, tienes dos pines que son 48(ICP5) 49(ICP4) que son con los timers 5 y 4 y utilizar también el timer 1 con alguna interrupción no se si esto sea posible ya que tambien tendria que realizar conversiones de temperatura tanto del ambiente como del evaporador que son termistores, también al utilizar el timer 5 tendría no estoy muy seguro si funcionaran los servos ya que la librería de los servos en el mega utiliza el timer 5 y en el arduino uno utiliza el timer 1, no se si estoy errando en algo o estoy en lo correcto.
lo otro sería utilizar los atmega328 uno para cada frecuencia, y que estos se comuniquen con el mega que controla servos, termistor, y protecciones del aire acondicionado, creo que seria lo mas facil.

[surbyte]

Creo que solo hay un INPUT CAPTURE, no hay 2 ni 3. Reviso y te confirmo.

el cual mide correctamente hasta 200 kHz a partir de es frecuencia empieza a fallar

Vaya no hubiera imaginado que estuvieran a una frecuencia mayor a esa.

[Swift]

Creo que no me explique bien, utilice un generador de señal, para comprobar la frecuencia que lograba leer, para que llegue a esa frecuencia tendría que superar las 11.000rpm y no creo que aguante mi motor.

[surbyte]

Si te explicaste bien y yo leí pero comprendí mal. Disculpas.

[Swift]

Buenas a todos, una pequeña actualización, e estado trabajando en la interfaz del corolla, el problema que detecté es que  si el usuario presiona el botón seguido el arduino o bien realiza la acción o aveces no, por lo que tendría que implementar en el código alguna opción para que una vez que realice la acción cambie el comando que envía el botón de la interfaz mientras tanto no cambie la opción.
No tengo idea cómo enviar del arduino a la interfaz los datos de la temperatura, pero que esto puede ser la solución: Comunicación avanzada por puerto serie o me recomiendan alguna otra forma de comunicarlo. La aplicacion la estoy haciendo en C# wpf adjunto todo el código de la interfaz como el de arduino.

Interfaz

Código Arduino

Como esta la interfaz por ahora


Video en funcionamiento

[surbyte]

Espectacularrrrrrrrrrr!!!!!!!

[Swift]

Buenas a todos tengo una pequeña duda acerca de parseInt(), al utilizarla a esta debe lee el primer entero valido, ahora por ejemplo en este código

Code: [Select]

char
comando = ' ';
int
valor = 0;
void setup() {
 Serial.begin(115200);

}
void loop() {
 while (Serial.available()>0) {
 comando = Serial.read();
 valor = Serial.parseInt();
 Serial.print("Comando: ");
 Serial.println(comando);
 Serial.print("Valor: ");
 Serial.println(valor);
 }
}

Al yo enviar por el monitor serie: B.54. me imaginaba que solo entraba una vez y asignaba a comando = B y en valor = 54 pero al imprimir por monitor serie me muestras 2 veces.

y al enviar repetidamente el mismo valor ya no asigna la B a comando solo el número, porque  sucede esto?.

[surbyte]

Y el . decimal? Lo olvidaste.
Lee el 1ero, lee de nuevo y descarta su valor porque sera el punto decimal y finalmente lee el entero.

[Swift]

Bueno después de un tiempo probando con lo instalado, al principio funcionaba bien, pero ahora en las últimas semanas la temperatura muestra 20° por encima de lo que debería, esto sucede con la pc que se encuentra instalada dentro del automóvil, pero conectado con la portátil muestra correctamente la temperatura, cosa rara que a pasado ultimamente. Puede que sea una conexión que se soltó o algo que falló.
Continuando el proyecto tengo dos señales (velocidad y RPM ) las cuales las leo individualmente correctamente, ahora me falta una última que es la temperatura del motor, esto es como esta en mi vehiculo:

Ahora como mencionó @surbyte en el post #24 es exactamente lo mismo.

Esta seria una señal análoga la cual seria fácil de leer si supiera la resistencia que se encuentra conectada a los 5v, creo que esta es posible calcularla ya que es un divisor de tensión.Además tengo los valores de la resistencia que está a cada temperatura:

Esto seria un equivalente, la resistencia varía según el año del sensor pero puede ser una referencia.
Ahora viene lo complicado la señal que le llegaba a lo anterior que controlaba el aire acondicionado es esta:

la cual va al tablero de instrumentos y al aire acondicionado, pero esta señal no es la misma que recibe desde el sensor sino esto:

Esto lo encontre en foro además el autor mencionó esto (traducido al Españo):

esta tarde se realizó una comprobación rápida del ZZE122, la salida de THWO al grupo del tablero tenía una frecuencia de 2.393Hz, el período de 418mS y el ciclo de trabajo pasó de 96% a 43% a la temperatura de zoperación.

Eso es todo lo que e encontrado con respecto a esa "señal" por que todavia no lo tengo muy claro de lo que sea.
Ahora otra duda que se me presento con respecto a la programación en algún post me parece que @ArduMyth mencionó que no es correcto encender un relay desde un switch por ejemplo:

Code: [Select]


switch (comando){
case 'a':
 if (estado == 1)
 {
 digitalWrite(relay, HIGH);
 }
}
 ya que este no entraría en cada loop por lo cual el estado del relay quedaría en el "aire" o no estaría definido en el siguiente ciclo, verdad?

[Swift]

Hola a  todos, ahora se cumple un año exactamente desde que se actualizo el proyecto y pues la verdad no e avanzado mucho jajajajaja.
Cosas que e echo hasta ahora, e mejorado la interfaz de usuario:

El código en su mayoría sigue igual no a cambiado la gran cosa,intente aplicar una maquina de estados hace un buen tiempo cosa que funciona, pero creo que se puede mejorar:

Code: [Select]

void Con_EstComp() { // Funcion para el control del compresor del aire acondicionado
 static uint8_t
 Est_Comp = 0;
 /*
 BOOL1 = Control de compresor segun la temperatura del evaporador
 */
 static unsigned long
 Tie_AaAC = 0; // Variable para almacenar el tiempo de la anterior activacion de aire acondicionado
 /*
 Tiem_AaAC = Variable para almacenar el tiempo de la anterior activacion de aire acondicionado
 */

 switch (Est_AcAac) {

 case 0: // Desactivacion del sistema del compresor del aire acondicionado
 Est_AcAac = 255; // Cambia al siguiente estado
 digitalWrite(activatorAC, LOW); // Desactiva la salida para la ECU aumente el ralentí
 digitalWrite(cluchRelay, LOW); // Desactiva el embrague magnetico del compresor del aire acondicionado
 Est_RFan1 = 0; // Desactiva el relay del ventilador de refigeracion del radiador
#ifdef _DEBUG
 Serial.println("Compresor Apagado");
#endif // _DEBUG
 break;

 case 1: // Inicia la activacion del compresor del sistema del aire acondicionado
 Est_AcAac = 2; // Cambia al siguiente estado
 digitalWrite(activatorAC, HIGH); // Activa la salida para la ECU aumente el ralentí
 Tie_AaAC = Tie_Actu; // Actualiza el temporizador
 Est_RFan1 = 1; // Activa el relay del ventilador de refigeracion del radiador
#ifdef _DEBUG
 Serial.println("Compresor Estado 1");
#endif // _DEBUG
 break;

 case 2: // Espera de tiempo asignado a Tie_AaAC para la espera de encendido y comprobacion del compresor del aire acondicionado
 if (Tie_Actu - Tie_AaAC >= Int_ActE) {
 Est_Comp |= BOOL1; // Reinicia el estado de encendido del del compresor por temperatura
 Est_AcAac = 3;  // Cambia al siguiente estado
#ifdef _DEBUG
 Serial.println("Compresor Estado 2");
#endif // _DEBUG
 break;
 }
 else
 {
 break;
 }

 case 3:
 if (!digitalRead(dualAC)) // Lectura del interruptor doble del sistema del aire acondicionado (0 = Cerrado 1 = Abierto) Abierdo no debe encender el aire acondicionado
 {
 if (!digitalRead(singleAC))// Lectura del interruptor simple del sistema del aire acondicionado (1 = Cerrado 0 = Abierto) Abierdo no debe encender el aire acondicionado
 {
 if (digitalRead(ACT)) // Lectura de la señal de ECU para desactivacion del compresor del aire acondicionado  (1 = Funcionamineto normal 0 = Apagar compresor)
 {
 if (Est_Comp & BOOL1) // Control del encendido del compresor del aire acondicionado por umbral de temperatura del evaporador
 {
 if (tempEvaporador >= Val_UmAlt) // Control de encendido cuando la temperatura umbral es superior o igual a la definida
 {
 Est_Comp &= ~BOOL1; // Cambio de estado para la activacion de temperatura por debajo o igual al valor umbral
 digitalWrite(cluchRelay, HIGH); // Activa el embrague magnetico del compresor del aire acondicionado
#ifdef _DEBUG
 Serial.println("Compresor Estado 3 ON");
#endif // _DEBUG
 break;
 }
 break;
 }
 else
 {
 if (tempEvaporador <= Val_UmBaj)// Control de apagado cuando la temperatura umbral es inferior o igual a la definida
 {
 Est_Comp |= BOOL1; // Cambio de estado para la activacion de temperatura superior o igual al valor umbral
 digitalWrite(cluchRelay, LOW); // Desactiva el embrague magnetico del compresor del aire acondicionado
#ifdef _DEBUG
 Serial.println("Compresor Estado 3 OFF");
#endif // _DEBUG
 break;
 }
 break;
 }
 break;
 }
 else
 {
 Est_AcAac = 4;  // Cambia al siguiente estado
 break;
 }
 break;
 }
 else
 {
 Est_AcAac = 0; // Desactiva el compresor del aire acondicionado por falla del interruptor simple del sistema
 break;
 }

 break;
 }
 else
 {
 Est_AcAac = 0; // Desactiva el compresor del aire acondicionado por falla del interruptor doble del sistema
 break;
 }

 case 4: // Cuando la ECU ordena apagar el compresor del aire acondicionado
 digitalWrite(cluchRelay, LOW); // Desactiva el embrague magnetico del compresor del aire acondicionado
 Tie_AaAC = Tie_Actu; // Actualiza el temporizador
 Est_AcAac = 2; // Cambia al siguiente estado
#ifdef _DEBUG
 Serial.println("Compresor Estado 4");
#endif // _DEBUG
 break;

 default: // Caso por defecto no haga nada
 break;
 }
}
Ahora tenia una duda que me surgió cuando hacia esto, era las variables de tipo "boolean" tienen 8 bits de los cuales solo usamos uno, entonces se podría hacer lo siguiente para "ahorrar" memoria

Code: [Select]

#define BOOL1 0x01
#define BOOL2 0x02
#define BOOL3 0x04
#define BOOL4 0x08
#define BOOL5 0x10
#define BOOL6 0x20
#define BOOL7 0x40
#define BOOL8 0x80
/*
Para comprobar un estado:
if ( "nombre de variable" & BOOLX ){
// Ejecuta alguna instrucción
}
Establece el estado 1
"nombre de variable" |= BOOLX;

Limpia el estado BOOL1
"nombre de variable" &=~ BOOLX;
*/
Complica un poco el entendimiento del código, pero bueno.
Ahora con respecto al hardware en los inicios del proyecto utilice transistores tip122, encender y apagar réles del sistema, cosa que según e avanzado en mis estudios me di cuenta que son mucho para manejar apenas una carga de 100 mA, errores de novato en una próxima "mejora" los cambiare y dejare esos para otras funciones que se me ocurran

[surbyte]

Te has lucido Swift.
Inspirado por tu trabajo he considerado hacer algo similar en mi vehículo. Aun no lo decido porque tengo mas proyectos que tiempo.. jajaja