Simulador de ECU S V.1.3

2017
Jorge Vázquez Nuño
---------------------------
[SIMULADOR DE ECU´S]
Con este banco se pretende hacer funcionar una centralita de motor como si estuviera en un
vehículo, permite simular las señales de diferentes sensores y actuadores más importantes del
vehículo.
INDICE
1 Introdución ...................................................................................................... 2
2 Conceptos básicos .......................................................................................... 5
2.1 Tutorial RTC DS1307 ............................................................................... 5
2.1.1 Conexiones entre Modulo RTC DS1307 y Arduino ............................. 6
2.1.2 Librería para el RTC DS1307 .............................................................. 7
2.1.3 Actualizando la Hora y fecha de nuestro DS1307 ............................... 7
2.1.4 Obteniendo Hora y Fecha del DS1307 ................................................ 9
2.2 Tutorial LCD con I2C, controla un LCD con solo dos pines .....................13
2.2.1 Conexiones entre Arduino y Módulo adaptador LCD a I2C ................14
2.2.2 Librería LiquidCrystal_I2C para Arduino.............................................15
2.2.3 1. Un Hola mundo con Arduino y LCD ...............................................16
2.2.4 2. Desplazando el texto en el LCD .....................................................17
2.2.5 3. Mostrando datos de sensores o variables en el LCD .....................19
2.2.6 4. Agregando nuevos caracteres a nuestro LCD ................................20
3 Esquemas ......................................................................................................26
4 Lista de componentes ....................................................................................27
4.1 Placa display ...........................................................................................27
4.2 Placaprincipal..........................................................................................28
4.3 Placa para el cuerpo de Mariposa y Pedal acelerador ............................29
5 Conexiones ....................................................................................................30
6 Programa arduino (Generador señal CKP-CMP)............................................32
7 Planos ............................................................................................................57
1
1 INTRODUCIÓN
El objetivo de este proyecto es poder simular las señales de los diferentes sensores
y actuadores más importantes que necesita una ECU para que pueda funcionar, para ello
se necesitará que la ECU este sin inmovilizador.
El simulador cuenta con una toma EOBD para poder conectar un equipo de
diagnosis y así poder realizar un diagnóstico de la ECU.
Este simulador también podrá utilizarse para hacer funcionar la ECU para la
reparación de las ECU´s en el caso de que estas tengan alguna avería.
2
3
4
2 CONCEPTOS BÁSICOS
2.1 Tutorial RTC DS1307
En este tutorial trabajaremos con el Modulo RTC (Real Time Clock) DS1307,
podremos saber la hora exacta, día mes año e incluso el día de la semana, a su vez gracias
a una EEPROM que trae el modulo podemos guardar los datos sin que se borren al apagar
el Arduino.
Agregando el modulo El RTC a nuestro Arduino es como darle un reloj y un
calendario, con el DS1307 nuestro Arduino sabrá la hora exacta como segundos, minutos
y horas. También podremos saber el día del mes, día de la semana, mes, y año. EL ds1307
tiene implementado su calendario hasta el 2100 y tiene en cuenta también los años
bisiestos.
La comunicación entre el Arduino y el

Modulo RTC es por I2C (pines SDA y SCL),
También tiene un pin (SQ) que envía un pulso
cada segundo (1 Hz), que nos puede servir
para sincronizar otros componentes o para
realizar un contador de segundos. A su vez, el
modulo tiene un espacio para soldar un
DS18B20 (sensor de temperatura) y acceder a
este a través del pin DS
5
Al reverso tiene un socket para insertar
una batería de 3V, que le permite al RTC
mantener en funcionamiento la hora y fecha
cuando se apague el Arduino o se le quiete la
alimentación principal. Esta batería
dependiendo de la marca y del tiempo
apagado, puede durar desde los 3 hasta los 10
años aproximadamente.
Este módulo también trae una memoria no volátil, una EEPROM AT24C32 con capacidad
para 32Kbit o 4Kbytes y también se comunica con el Arduino a través del bus I2C, bus que
comparte con el DS1307, de esta forma solo necesitamos 2 pines del Arduino para
controlar el RTC y EEPROM del Módulo.
2.1.1 Conexiones entre Modulo RTC DS1307 y Arduino
Adaptador LCD a I2C Arduino Uno, Nano, Mini. Arduino Mega , DUE Arduino Leonardo
SCL A5 21 3
SDA A4 20 2
VCC 5V 5V 5V
GND GND GND GND
SCL A5 21 3
Como se observa la conexión es como cualquier conexión I2C.
6
2.1.2 Librería para el RTC DS1307
Para este ejemplo usaremos la librería RTClib de Adafruit, librería que pueden descargarlo
en:
https://github.com/adafruit/RTClib
Necesitamos descargar e importar dicha librería al IDE de Arduino.
2.1.3 Actualizando la Hora y fecha de nuestro DS1307
Cuando adquirimos un DS1307, al no traer su pila, no tiene la hora actualizada, cada vez
que quitamos la pila el DS1307 pierde la hora, estableciéndose como hora 0:0:0 y fecha
00/00/00,
Este ejemplo solo se utiliza para poner a la hora nuestro DS1307:
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
void setup () {
Serial.begin(9600);
rtc.begin(); //Inicializamos el RTC
Serial.println("Estableciendo Hora y fecha...");
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
Serial.println("DS1307 actualizado con la hora y fecha que se compilo este prog
rama:");
Serial.print("Fecha = ");
Serial.print(__DATE__);
Serial.print(" Hora = ");
Serial.println(__TIME__);
}
void loop () {
}
7
De esta forma cada vez que el Arduino se enciende o se reinicia, el Arduino
actualizara al DS1307 con la hora que fue compilado el programa.
Después de cargar el código anterior, tan pronto termine la carga Arduino
actualizará la hora, pero cada vez que se habré el monitor serial o se reinicie el Arduino,
nuevamente vuelve a actualizase con la misma hora de compilación.
El monitor serial solo nos sirve para verificar que nuestro programa es correcto. Después
de esto hay que compilarlo y cargarlo de nuevo, para que tenga la hora correcta.
Después de cargar este programa se debe cargar otro distinto, o uno en blanco, para evitar
que se esté actualizando con la misma hora de compilación cada vez que se reinicia o
enciende el Arduino.
Si deseamos actualizar a una hora y fecha en específico deben de modificar a la
siguiente línea de código:
rtc.adjust(DateTime(2016,6,10,18,29,0));//2016,Junio,10,18 h,29 min,0 seg
8
2.1.4 Obteniendo Hora y Fecha del DS1307
En este ejemplo realizaremos la lectura de los segundos, minutos y horas del DS1307, y a
su vez también obtendremos la fecha.
Para realizar este ejemplo usamos el siguiente código:
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
int segundo,minuto,hora,dia,mes;
long anio; //variable año
DateTime HoraFecha;
void setup () {
Serial.begin(9600);
}
void loop () {
HoraFecha = rtc.now(); //obtenemos la hora y fecha actual
segundo=HoraFecha.second();
minuto=HoraFecha.minute();
hora=HoraFecha.hour();
dia=HoraFecha.day();
mes=HoraFecha.month();
anio=HoraFecha.year();
//Enviamos por el puerto serie la hora y fecha.

Serial.print("hora = ");
Serial.print(hora);
Serial.print(":");
Serial.print(minuto);
Serial.print(":");
Serial.print(segundo);
Serial.print(" Fecha = ");
Serial.print(dia);
Serial.print("/");
9
Serial.print(mes);
Serial.print("/");
Serial.print(anio);
Serial.println();
delay(1000);
}
Como se observa el código es simple y fácil de entender

En el void Setup solamente inicializamos el RTC y en void loop() realizamos la
lectura del DS1307, esto se hace en una sola línea de código:
Cada vez que se llama a rtc.now se actualiza la hora y se guarda en el objeto

HoraFecha que es de la clase DateTime propia de la librería RTClib
Seguidamente guardamos la hora y fecha en variables separadas, pero también
podemos trabajar directamente con el objeto HoraFecha si lo deseamos por ejemplo:
HoraFecha. minute()
A continuación mostramos el monitor serial de este ejemplo:
10
A este ejemplo, podemos agregar variables tipo cadena para mostrar o tener la
fecha en formato de texto, por ejemplo para el nombre de los días de la semana y los
nombres del mes.
El ejemplo muestra los cambios para mostrar la fecha de forma textual:
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
char nombreDia[7][12] = {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Vi

ernes", "Sabado"};
char nombreMes[12][12]= {"Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "
Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre"};
int segundo,minuto,hora,dia,mes,diaDeLaSemana;
long anio; //variable año
DateTime HoraFecha;
void setup () {
Serial.begin(9600);
}
void loop () {
segundo=HoraFecha.second();
minuto=HoraFecha.minute();
hora=HoraFecha.hour();
dia=HoraFecha.day();
mes=HoraFecha.month();
anio=HoraFecha.year();
diaDeLaSemana=HoraFecha.dayOfTheWeek();
//Enviamos por el puerto serie la hora y fecha.

Serial.print(hora);
Serial.print(":");
Serial.print(minuto);
Serial.print(":");
Serial.print(segundo);
11
Serial.print(" , ");
Serial.print(nombreDia[diaDeLaSemana]);
Serial.print(" ");
Serial.print(dia);
Serial.print(" de ");
Serial.print(nombreMes[mes-1]);
Serial.print(" del ");
Serial.print(anio);
Serial.println();
delay(1000);
}
La salida del monitor serial es el siguiente:
12
2.2 Tutorial LCD con I2C, controla un LCD con solo dos pines
En este tutorial usaremos un módulo adaptador de LCD a I2C para poder controlar
nuestro LCD con solo dos pines de nuestro Arduino
EL Módulo adaptador LCD a I2C que

usaremos está basado en el controlador I2C
PCF8574, el cual es un expansor de entrada y
salidas digitales controlado por I2C, que en
este módulo se usa para controlar un LCD.
La dirección del módulo I2C que viene
por defeco es 0x27, pero podemos cambiarlo
soldando los puentes A0,A1y A2; quedando la
dirección en binario de la siguiente forma
:0|0|1|0|0|A2|A1|A0. Por defecto A0,A2,A1
valen 1 pero si soldamos los puentes, estos se
conectan a tierra teniendo un valor 0, por
ejemplo si soldamos los tres puentes la
dirección seria 0|0|1|0|0|0|0|0 (0x20).
*También existen módulos con dirección por defecto 0x3F cuyos bits de
configuración son 0|0|1|1|1|A2|A1|A0
13
Para controlar el contraste solo necesitamos variar el potenciómetro que se
encuentra en el módulo.
La luz de fondo se controla por software, desde el Arduino; pero el modulo tiene un
Jumper para desconectar el Led de la luz de fondo.
2.2.1 Conexiones entre Arduino y Módulo adaptador LCD a I2C
El adaptador LCD a i2C tiene los pines

ordenados para solo conectar al LCD, esto lo
podemos hacer a través de un protoboard o
soldando directamente al LCD
Para conectar con el Arduino solo
utilizamos los pines I2C del Arduino y
alimentación
Adaptador LCD a I2C Arduino Uno, Nano, Mini. Arduino Mega , DUE Arduino Leonardo
GND GND GND GND
VCC 5V 5V 5V
SDA A4 20 2
SCL A5 21 3
14
* Las conexiones para el LCD de 20 x 4 son las mismas.
2.2.2 Librería LiquidCrystal_I2C para Arduino

Existen diferentes tipos y versiones de la librería para LCD I2C, información más
completa pueden encontrar en: http://playground.arduino.cc/Code/LCDi2c ,
nosotros usaremos la librería LiquidCrystal_I2C
Las funciones que utiliza esta librería son similares a la librería LiquidCrystal de
Arduino, pero volveremos a explicaremos las funciones principales.
✓ LiquidCrystal_I2C(lcd_Addr, lcd_cols, lcd_rows)

Función constructor, crea una variable de la clase LiquidCrystal_I2C, con dirección,
columnas y filas indicadas.
✓ init()
Inicializa el modulo adaptador LCD a I2C, esta función internamente configura e
inicializa el I2C y el LCD.
✓ clear()
Borra la pantalla LCD y posiciona el cursor en la esquina superior izquierda
(posición (0,0)).
✓ setCursor(col, row)
Posiciona el cursor del LCD en la posición indicada por col y row(x,y); es decir,
establecer la ubicación en la que se mostrará posteriormente texto escrito para la pantalla
LCD.
15
✓ print()
Escribe un texto o mensaje en el LCD, su uso es similar a un Serial.print
✓ scrollDisplayLeft()
Se desplaza el contenido de la pantalla (texto y el cursor) un espacio hacia la
izquierda.
✓ scrollDisplayRight()
Se desplaza el contenido de la pantalla (texto y el cursor) un espacio a la derecha.
✓ backlight();
Enciende la Luz del Fondo del LCD
✓ noBacklight();
Apaga la Luz del Fondo del LCD
✓ createChar (num, datos)
Crea un carácter personalizado para su uso en la pantalla LCD. Se admiten hasta
ocho caracteres de 5x8 píxeles (numeradas del 0 al 7). Dónde: num es el número de
carácter y datos es una matriz que contienen los pixeles del carácter. Se verá un ejemplo
de esto más adelante.
Explicado la librería veamos unos ejemplos:
2.2.3 1. Un Hola mundo con Arduino y LCD

Mostraremos texto y un valor numérico en el LCD, para esto cargamos el siguiente
sketch:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
//Crear el objeto lcd dirección 0x27 y 16 columnas x 2 filas

LiquidCrystal_I2C lcd(0x27,16,2); //
void setup() {
// Inicializar el LCD
lcd.init();
//Encender la luz de fondo.
lcd.backlight();
// Escribimos el Mensaje en el LCD.
lcd.print("Hola Mundo");
}
void loop() {
16
// Ubicamos el cursor en la primera posición(columna:0) de la segunda línea(fila:1)
lcd.setCursor(0, 1);
// Escribimos el número de segundos trascurridos
lcd.print(millis()/1000);
lcd.print(" Segundos");
delay(100);
}
Después de cargar, en su LCD deben obtener el siguiente resultado
La programación es similar para un LCD de 20x4, solo hay que modificar en:
LiquidCrystal_I2C lcd(0x27,20,4);
2.2.4 2. Desplazando el texto en el LCD

En este ejemplo para desplazar el texto usaremos la función scrollDisplayLeft(). El
codigo es el siguiente:
#include <Wire.h>
17
void setup() {
lcd.init();
lcd.backlight();
// Escribimos el Mensaje en el LCD en una posición central.
lcd.print("WWW.NAYLAMPMECHATRONICS.COM");
lcd.print("Tutorial LCD, Test de desplazamiento ");
}
void loop() {
//desplazamos una posición a la izquierda
lcd.scrollDisplayLeft();
delay(500);
}
EL resultado será el texto desplazándose de derecha a izquierda.
18
2.2.5 3. Mostrando datos de sensores o variables en el LCD
En este ejemplo mostramos en el LCD variables, que pueden representar valores
de sensores u otros datos. Para simular los sensores usaremos potenciómetros
conectados a los puertos analógicos.
#include <Wire.h>

void setup() {
lcd.init();
lcd.backlight();
}
void loop() {
int sen1=analogRead(A0);
float sen2=analogRead(A1)*(5.0 / 1023.0);
float sen3=analogRead(A2)*(100.0 / 1023.0);
int tiempo=millis()/1000;
// Cursor en la primera posición de la primera fila
lcd.setCursor(0,0);
lcd.print("ADC:");
lcd.print(sen1);
lcd.print(" ");
// Cursor en la 11° posición de la primera fila
lcd.setCursor(10,0);
lcd.print("V:");
lcd.print(sen2,1);//1 decimal
lcd.print("V ");
// Cursor en la primera posición de la 2° fila
lcd.setCursor(0,1);
lcd.print("T:");
lcd.print(sen3,1); //1 decimal
lcd.print("337C "); // "337" -> "°"
// Cursor en la 11° posición de la 2° fila
19
lcd.setCursor(10,1);
lcd.print("t:");
lcd.print(tiempo);
lcd.print(" s ");
delay(200);
}
Su resultado debe ser el siguiente.
2.2.6 4. Agregando nuevos caracteres a nuestro LCD

En algunos casos el LCD no tiene los caracteres que deseamos, o necesitamos
dibujar caracteres personalizados, en este caso usamos la función createChar () pero
antes expliquemos como está constituido un carácter:
Un carácter está formado por 5x8 pixeles los cuales se representan por 8 bytes,
uno para cada fila, los 5 bits menos significativos representan los pixeles del carácter
20
Como máximo podemos crear 8
caracteres nuevos.
Para este ejemplo crearemos los siguientes caracteres:
21
A continuación se muestra el código para implementar los nuevos caracteres.
#include <Wire.h>

byte N[8] = {
B11111,
B10001,
B10001,
B10001,
B10001,
B10001,
B10001,
B00000,
};
byte A[8] = {
B11111,
B10001,
B10001,
B10001,
B10001,
B11111,
B10001,
B00000,
};
byte Y[8] = {
B10001,
B10001,
B10001,
B10001,
B11111,
B00100,
B00100,
B00000,
};
byte L[8] = {
B10000,
B10000,
B10000,
22
B10000,
B10000,
B10000,
B11111,
B00000,
};
byte M[8] = {
B11111,
B10101,
B10101,
B10101,
B10101,
B10101,
B10101,
B00000,
};
byte P[8] = {
B11111,
B10001,
B10001,
B10001,
B11111,
B10000,
B10000,
B00000,
};
byte cara[8] = {
B00000,
B10001,
B00000,
B00000,
B10001,
B01110,
B00000,
};
byte cuerpo[8] = {
B01110,
B01110,
B00100,
B11111,
23
B00100,
B01010,
B10001,
B00000,
};
void setup() {
lcd.init();

lcd.backlight();
//creamos los nuevos caracteres

lcd.createChar (0,N);
lcd.createChar (1,A);
lcd.createChar (2,Y);
lcd.createChar (3,L);
lcd.createChar (4,M);
lcd.createChar (5,P);
lcd.createChar (6,cara);
lcd.createChar (7,cuerpo);
// Escribimos el texto en el LCD
lcd.print("Tutorial LCD_I2C");
lcd.write (byte (7));
lcd.print(" ");
lcd.print(" ");
lcd.print(" ");
lcd.print(" ");
24
}
void loop () {}
El resultado del ejemplo anterior es el siguiente:
25
3 ESQUEMAS
26
4 LISTA DE COMPONENTES
4.1 Placa display
27
4.2 Placaprincipal
28
4.3 Placa para el cuerpo de Mariposa y Pedal acelerador
Para poder adaptar los voltajes que genera el microcontrolador (arduino) y que
estas señales puedan ser reconocidas por la ECU, se ha de intercalar este circuito con el
fin de elevar la señal (intensidad) ya que la señal del arduino es débil.
Básicamente este circuito es un adaptador o interfase que mediante las señales
que son generadas por el arduino va a microcontrolar la tensión variable que generará el
LM317 (regulador variable de tensión).
Mediante el siguiente esquema se ha incorporado dos relés que conectan y
desconectan automáticamente cuando se conecta la clavija externa del cuerpo de
mariposa y el del acelerador, si está no se conecta la señal pasará por el interface.
29
5 CONEXIONES
Dado que el corazón del proyecto es el microcontrolador basado en un arduino y
sus conexiones de entras y salidas, en la siguiente imagen se puede apreciar de una forma
más reducida montada directamente sobre una placa de arduino uno, aunque en nuestro
proyecto en la placa principal se ha insertado el microcontrolador de arduino con el fin de
optimizar el espacio.
En cuanto a las conexiones exteriores del comprobador son las siguientes, consta
de 4 conexiones, 2 de ellas que van directamente a la ECU, otra para poder conectar un
cuerpo de mariposa y acelerador exterior y otra que nos permitirá modificar el programa de
arduino sin necesidad de extraer el microcontrolador.
30
31
6 PROGRAMA ARDUINO (GENERADOR SEÑAL CKP-CMP)
/********************************************************************************************
* Proyecto: Generador de señal CKP y CMP con ajuste de avance y RPM *
* Autor : Jorge Vázquez *
* Fecha : 27/11/2016 *
* Versión : 1.3 Arduino UNO *
* Notas : Se añade configuración para pedal de acelerador *
* Pines : LCD= I2C (4 y 5) S. Señal CKP= 5 S. Señal CMP= 6 S. Señal Acel 1= 3 *
* S. Señal Acel 2= 9 Potenciómetro Acelerador= A2 Potenciómetro RPM= A1 *
* Pulsadores= A3 *
********************************************************************************************/
// Declaración de librerías
#include <Wire.h> // Declaración de la librería para comunicar con dispositivos I2C / TWI (SDA y SCL)
#include <LiquidCrystal_I2C.h> // Declaración de la librería I2C
// Definir los caracteres del logotipo (JVN)

byte caracter0[8] = {
B00111,B00111,B00111,B00111,B00111,B00111,B00111,B00111};
B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100};
B11100,B11100,B11100,B11100,B11110,B11111,B11111,B11111};
B11100,B11100,B11100,B11110,B01111,B00111,B00011,B00001};
B00111,B00111,B00111,B01111,B11110,B11100,B11000,B10000};
B11111,B11111,B11111,B01111,B00111,B00111,B00111,B00111};
B00000,B00111,B00111,B01111,B01111,B11111,B01100,B01100};
B00000,B10000,B10000,B11110,B11110,B11111,B00110,B00110};
// Declaramos el LCD (dirección: 0x20)

LiquidCrystal_I2C lcd(0x21,16,2);
// Declaramos la fecha, hora como variables

int seconds; // 00-59
int minutes; // 00-59
int hours; // 00-23
int day; // 1-7
int date; // 01-31
int month; // 01-12
int year; // 0-99
// Configuración del teclado serie y del LCD [pulsadores A3],

int adc_key_val[5] = {
50,200,400,600,800};
int NUM_KEYS = 5;
int adc_key_in;
int key = -1;
int oldekey = -1;
// Declaramos las variables y las inicializamos con el valor 0

int a = 0; // Menú 1 (Menú Principal)
int b = 0; // Menú 5 (Dientes Rueda)
int c = 0; // Menú 6 (Personalizar dientes)
int d = 0; // Menú 3 (Ajuste Pedal acelerador)
int e = 0; // Menú 4 (Ajuste de Hora)
int N = 0; // Menú 7 (donde se ejecuta la salida del pedal del
acelerador)
int y = 0; // Variable para indicar si la ECU tiene diferentes señales de
CKP y CMP según el número de cilindro (por ejemplo EDC15P)
int j = 0; // Variable para ejecutar la señal del CKP y CMP
int D = 50; // Indicamos los Dientes

int H = 2; // Indicamos los Huecos
int HF = 0; // Confirmación de ajuste de Hora y Fecha
int P = 0; // Variable que indica el número de pulsaciones de la tecla OK
float Pista1Min = 0.50; // Valor en tensión mínimo de la pista 1
float Pista1Max = 4.50; // Valor en tensión máximo de la pista 1
float Pista2Min = 4.50; // Valor en tensión mínimo de la pista 2
32
float Pista2Max = 0.50; // Valor en tensión máximo de la pista 2
float PistaAMin; // Valor en PWM mínimo de la pista 1
float PistaAMax; // Valor en PWM máximo de la pista 1
float PistaBMin; // Valor en PWM mínimo de la pista 2
float PistaBMax; // Valor en PWM máximo de la pista 2
int Pista1; // Salida de tensión de la pista 1 del acelerador (este
oscilara entre los valores indicados en Pista1Min y Pista1Max)
int Pista2; // Salida de tensión de la pista 2 del acelerador (este
oscilara entre los valores indicados en Pista2Min y Pista2Max)
int Beep = 1; // Variable que indica si funciona o no el sonido
int LCD_ON = 1; // Variable que indica si la luz del LCD está encendida
int Cilindro = 1; // Variable para indicar el cilindro inicial
int RPM; // Variable de la señal RPM
int Acelerador; // Variable de la señal del Acelerador
int oldkey; // Variable del valor del pulsador (en serie)

int k = 0; // Variable (no hace nada)
int x=0; // Variable para entrar en un bucle determinado
//Pines (I/O)
int CMP = 6; // Pin de salida para la señal CMP
int CKP = 5; // Pin de salida para la señal CKP
int Buzzer = 7; // Pin Digital 7
int LCD = 4; // Pin Digital 4
int Acelerador1 = 3; // Pin de salida para la señal del acelerador (pista 1)
int Acelerador2 = 9; // Pin de salida para la señal del acelerador (pista 2)
int PontRPM = 16; // Pin de entrada para el potenciómetro RPM A2
int PontAcelerador = 15; // Pin de entrada para el potenciómetro del acelerador A1
int Boton = 17; // Pin de entrada para el Botón A3
boolean Parpadeo = true; // Variable que indica el ultimo estado del parpadeo
long HoraPrevia = 0; // Variable para indicar la hora de inicio desde que se
reinicio
long Intervalo = 480; // Variable para indicar el tiempo de retardo
//**************************************** Inicio del Setup ****************************************

void setup() {
pinMode (CKP, OUTPUT); // Indicamos que la variable CKP es un pin de salida
pinMode (CMP, OUTPUT); // Indicamos que la variable CMP es un pin de salida
pinMode (Acelerador1, OUTPUT); // Indicamos que la variable Acelerador1 es un pin de salida
pinMode (Acelerador2, OUTPUT); // Indicamos que la variable Acelerador2 es un pin de salida
pinMode (LCD, OUTPUT); // LCD desconexión sin uso
pinMode (Buzzer, OUTPUT); // Buzzer
digitalWrite(LCD, LOW); // Se activa la iluminación del LCD
Wire.begin (); // Inicializa la librería Wire y configura el bus I2C

lcd.begin (16,2); // Inicializa el LCD indicando el número de pixel y las filas
lcd.createChar (0, caracter0); // Asignación al Byte 0 el carácter 0

Logo(); // Se ejecutara el bloque de LOGO
// Se escribe el mensaje de inicio

lcd.clear (); // Se limpia el lcd
lcd.setCursor (1,0); // Se posiciona en la primera línea, primer carácter
lcd.print ("jvazquez.nuno"); // Se escribe el email
lcd.setCursor (3,1); // Se posiciona en la segunda línea, primer carácter
lcd.print ("@gmail.com"); // Se escribe el nombre del proyecto y versión
delay (2000); // Se pausa 2seg.
lcd.print ("Comprobador ECUs"); // Se escribe el nombre del proyecto y versión
lcd.print ("v.1.3"); // Se escribe el nombre del proyecto y versión
} // Fin del Setup
//**************************************** Fin del Setup *******************************************
33
//**************************************** Inicio del loop *****************************************
void loop() {
// if (key > -1) Sonido_Accion(); // Cada pulsación suena un pitido
Menus (); // Se ejecuta el bloque de Menú_0
if (a!= 9) { // Solamente aparece el menú 0 al iniciar (hora + Fecha)
get_time (); // Se ejecuta el bloque de Get_Time
get_date (); // Se ejecuta el bloque de Get_Date
display_time (); // Se ejecuta el bloque de Display_Time
display_date (); // Se ejecuta el bloque de Display_Date
unsigned long HoraActual = millis (); // A la variable HoraAtual se le graba el valor de tiempo de
ejecución desde el ultimo reset
if (HoraActual - HoraPrevia > Intervalo){// Si el valor de HoraActual - HoraPrevia > Intervalo entonces
....
HoraPrevia = HoraActual; // Se actualiza la variable HoraPrevia con el valor de
HoraActual
if (Parpadeo == true){ // Si el valor de Parpadeo es verdadero
Parpadeo = false ; // Se cambia el valor de Parpadeo a Falso
lcd.setCursor (13,0); // Posicionamos el texto en la 14ª posición de la 1ª fila
lcd.print (" "); // Se escribe el texto
} // Fin del IF
else { // Y sino ....
lcd.print (":"); // Se escribe el texto
Parpadeo = true ; // La variable Parpadeo pasa a valor Verdadero
} // Fin del IF
} // Fin del IF
Menus (); // Se ejecuta el bloque de Menú_0
} // Fin del IF
} // Fin del Loop
//**************************************** Fin del loop ********************************************
//**************************************** Menús ***************************************************

void Menus (){
adc_key_in = analogRead (Boton); // Se lee el valor de la pulsación
key = get_key(adc_key_in); // Se obtiene el valor pulsado
if (key!= oldkey){ // Detecta si se ha pulsado cualquier tecla

delay (50); // Espera 50ms para evitar rebotes del pulsador
} // Fin del IF
// Se contabiliza el número de pulsaciones del pulsador OK para evitar que se salten menús
if (key == 2) { // Si se pulsa la tecla OK
P=P++; // Se incrementa el valor de la variable P
delay (200); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
////////// Menú 1 (Menú principal) //////////

Menu_1 (); // Se ejecuta el bloque de Menú_1
/////////////////////////////////////////////
////////// Menú 2 (Tipo de ECU) /////////////

if (a == 0 && key == 2 && P == 1) { // Estamos en el menú de Rueda fónica
lcd.print (" Tipo de ECU "); // Se escribe el texto
a = 9; // Se cambia el valor de la variable A para no entrar en el
menú principal (Menú 1)
b = 1; // Se cambia la variable B para indicar que estamos en el menú
de Tipo de Señal
} // Fin del IF
/////////////////////////////////////////////
////////// Menú 3 (Rueda fónica) ///////////

if (a == 1 && key == 2 && P == 1) { // Estamos en el menú de Rueda fónica
lcd.print (" Rueda fonica "); // Se escribe el texto
menú principal (Menú 1)
c = 1; // Se cambia la variable B para indicar que estamos en el menú
de Tipo de Señal
} // Fin del IF
/////////////////////////////////////////////
34
////////// Menú 4 (Ajuste Acelerador) ///////
if (a == 2 && key == 2 && P == 1){ // Estamos en el menú de Ajuste de Hora
lcd.print (" Ajuste Acel. "); // Se escribe el texto
menú Principal (Menú 1)
d = 1; // Se cambia la variable I para indicar que estamos en el menú
de Ajuste de Acelerador
} // Fin del IF
/////////////////////////////////////////////
////////// Menú 5 (Ajuste de Hora) /////////

if (a == 3 && key == 2 && P == 1){ // Estamos en el menú de Ajuste de Hora
lcd.print (" Ajuste Reloj "); // Se escribe el texto
menú Principal (Menú 1)
e = 1; // Se cambia la variable I para indicar que estamos en el menú
de Ajuste de Hora
} // Fin del IF
/////////////////////////////////////////////
////////// Menú 6 (Confirmar cambio F y H) /

if (e == 1 && key == 2 && P == 2){ // Estamos en el menú de Confirmar cambio Hora
HF = 1; // Se cambia el valor de la variable HF para indicar que
modificamos la Hora
e = 3; // Se cambia la variable I para indicar que no entramos en el
menú de ajuste de hora
} // Fin del IF
if (e == 2 && key == 2 && P == 2){ // Estamos en el menú de Confirmar cambio Fecha

HF = 2; // Se cambia el valor de la variable HF para indicar que
modificamos la Fecha
e = 3; // Se cambia la variable I para indicar que no entramos en el
menú de ajuste de hora
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 7 (Simulación CKP-CMP EDC15P) /

if (b == 1 && key == 2 && P == 2){ // Estamos en el menú de Confirmar cambio Hora
digitalWrite(CMP, HIGH); // Se pone en estado ALTO la señal de CMP
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (EDC15P) "); // Se escribe el texto
lcd.print (D); // Se escribe la variable
lcd.print ("-"); // Se escribe el texto
lcd.print (H); // Se escribe la variable
lcd.print (" con fase "); // Se escribe el texto
D = D / 2; // Se indica en la variable D la mitad del valor indicado en
la variable D
H = H / 2; // Se indica en la variable H la mitad del valor indicado en
la variable H
Sonido_Accion(); // Se ejecuta el bloque de Sonido_Accion
y = 1; // Variable para ejecutar la señal del CKP y CMP
b = 9; // Se cambia el valor de la variable B para indicar que se
sale de este bucle
N = 1; // Se cambia la variable N para indicar que no entramos en el
menú de ajuste del pedal del acelerador
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 8 (Simulación CKP-CMP EDC15C2) /

35
lcd.print ("al (EDC15C2)"); // Se escribe el texto
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 9 (Simulación CKP-CMP EDC16C4) /

lcd.print ("al (EDC16C4)"); // Se escribe el texto
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
/////// Menú 10 (Simulación CKP-CMP Simos 3) /

lcd.print ("Se"); // Se escribe el texto
lcd.print ("al (Simos 3)"); // Se escribe el texto
// y = 1; // Variable para ejecutar la señal del CKP y CMP
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 11 (Simulación CKP-CMP ME7.2) /

lcd.print ("al (ME7.2) "); // Se escribe el texto
36
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 11 (Simulación CKP-CMP ME7.4.4) /

lcd.print ("al (ME7.4.4)"); // Se escribe el texto
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 12 (Simulación CKP-CMP ME7.5.10) /

lcd.print ("al (ME7.5.10)"); // Se escribe el texto
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 13 (Simulación CKP-CMP ME9.2.xx) /

lcd.print ("al (ME9.2.xx)"); // Se escribe el texto
sale de este bucle
} // Fin del IF
37
/////////////////////////////////////////////
//////// Menú 14 (Simulación CKP-CMP S2000PM2) /

lcd.print ("al (S2000PM2)"); // Se escribe el texto
// y = 1; // Variable para ejecutar la señal del CKP y CMP
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 101 (Simulación CKP-CMP 33-1) /

if (c == 1 && key == 2 && P == 2){ // Estamos en el menú de Confirmar cambio Hora
lcd.print ("al Config. "); // Se escribe el texto
lcd.print (" sin fase "); // Se escribe el texto
c = 9; // Se cambia el valor de la variable C para indicar que se
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////

sale de este bucle
} // Fin del IF
/////////////////////////////////////////////

38
sale de este bucle
} // Fin del IF
/////////////////////////////////////////////

sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
//////// Menú 105 (Simulación CKP-CMP Personalizada) /

sale de este bucle
} // Fin del IF
/////////////////////////////////////////////
////////// Menú Esc (Esc al menu inicial) ///

if (key == 1 && a!= 0){ // Estamos en el menú de Esc
Esc (); // Se ejecuta el bloque de Esc
} // Fin del IF
/////////////////////////////////////////////
} // Fin del bloque Menú
//**************************************** Fin Menús ***********************************************
//**************************************** Menú Esc (Esc al menu inicial) **************************

void Esc(){ // Esc al menu inicial
a = 0; // Menú 1 (Menú Principal)
b = 0; // Menú 5 (Dientes Rueda)
c = 0; // Menú 6 (Personalizar dientes)
d = 0; // Menú 3 (Ajuste Pedal acelerador)
e = 0; // Menú 4 (Ajuste de Hora)
N = 0; // Menú 7 (donde se ejecuta la salida del pedal acelerador)
39
y = 0; // Variable para indicar si la ECU tiene diferentes señales de
CKP y CMP según el número de cilindro (por ejemplo EDC15P)
j = 0; // Variable para ejecutar la señal del CKP y CMP
D = 50; // Indicamos los Dientes

H = 2; // Indicamos los Huecos
HF = 0; // Confirmación de ajuste de Hora y Fecha
P = 0; // Variable que indica el número de pulsaciones de la tecla OK
k = 0; // Variable (no hace nada)
Cilindro = 1; // Variable para indicar el cilindro inicial
digitalWrite (CMP, LOW); // Se desactiva la salida CMP

digitalWrite (CKP, LOW); // Se desactiva la salida CKP
digitalWrite (Acelerador1, LOW); // Se desactiva la salida Acelerador1
digitalWrite (Acelerador2, LOW); // Se desactiva la salida Acelerador2
} // Fin del Esc

//**************************************************************************************************
void triggerHigh(int duration, int count){

switch (Cilindro){ // Se tiene en cuanta el cilindro que está en explosión
case 1: // Cilindro Nº 1
if (y == 1){ // Si es la ECU EDC15 (Variable Y = 1)
switch (count){ // Se ejecuta el bloque Switch
case 2: // Si es el diente 2 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
} // Fin del SWITCH
} // Fin del IF
/* if (j == 1){ // Si es la ECU EDC15 (Variable Y = 1)

} // Fin del SWITCH
} // Fin del IF
break;*/ // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF

40
} // Fin del SWITCH
} // Fin del IF
} // Fin del SWITCH
} // Fin del IF

} // Fin del SWITCH
} // Fin del IF
} // Fin del SWITCH
} // Fin del IF

} // Fin del SWITCH
} // Fin del IF
digitalWrite(CKP, HIGH); // Se pone la salida digital CKP en estado alto

delayMicroseconds(duration); // Se genera una pausa según la variable DURATION
digitalWrite(CKP, LOW); // Se pone la salida digital CKP en estado bajo
if (Cilindro > 4) { // Si la variable cilindro es >4….
Cilindro = 1; // Pasa la variable cilindro a valor 1
} // Fin del SWITCH
} // Fin del IF
void triggerReference(int duration) {

if (j == 1){
} // Fin del IF
} // Fin del IF
41
//**************************************** Logotipo ************************************************
void Logo (){
lcd.createChar (0, caracter0); // Se crea el caracter especial "caracter0" y se guarda en el
byte 0
byte 1
byte 2
byte 3
byte 4
byte 5
byte 6
byte 7
Sonido_Confirmacion(); // Se confirma mediante sonido

lcd.print ("*"); // Se escribe el texto
lcd.print (" "); // Se escribe 2 espacio en blanco
lcd.write (byte(0)); // Se escribe el contenido del byte 0


lcd.clear (); // Se limpia el LCD

for (int positionCounter = 0; positionCounter < 16; positionCounter++) { // Se desplaza desde la
posición 0 hasta la posición 16
lcd.scrollDisplayRight(); // Se desplaza el contenido hacia la derecha
delay(500); // Se pausa 5mseg.
} // Fin del bucle FOR
} // Fin del menu LOGO
//**************************************** Fin Logotipo ********************************************
//**************************************** Menú 1 (Menú principal) *********************************

void Menu_1(){ // Menú principal
switch(a){ // Valor de la variable "a" ....
42
case 0: // Tipo de señal
lcd.print (" Tipo de ECU "); // Se escribe el texto
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
a++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
a=0; // Se cambia el valor de la variable D para pasar al siguiente
Item
} // Fin del IF
break; // Salimos del switch

lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" Confg. Se"); // Se escribe el texto
lcd.print ("al "); // Se escribe el texto
a++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
} // Fin del IF
a--; // Se cambia el valor de la variable D para pasar al siguiente
Item
} // Fin del IF

lcd.print ("Ajuste Aceler."); // Se escribe el texto
a++; // Se cambia el valor de la variable A para pasar al siguiente
Item
} // Fin del IF
a--; // Se cambia el valor de la variable A para pasar al siguiente
Item
} // Fin del IF

lcd.print (" Ajuste Reloj "); // Se escribe el texto
a=3; // Se cambia el valor de la variable D para mantenerse en este
Item
} // Fin del IF
a--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
} // Fin del IF
} // Fin del SWITCH
} // Fin del Menu_1
//**************************************************************************************************
//**************************************** Menú 2 (Tipo de ECU) ************************************

void Menu_2(){ // Tipo de señal
switch(b){ // Valor de la variable "b" ....
case 1: // Rueda Fónica 33-1
43
lcd.print (" EDC15P "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=4; // Se indica en la variable H los huecos
Pista1Min = 0.50; // Valor en tensión mínimo de la pista 1
Pista1Max = 4.50; // Valor en tensión máximo de la pista 1
b++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
} // Fin del IF
b=1; // Se cambia el valor de la variable D para pasar al siguiente
Item
} // Fin del IF

lcd.print (" EDC15C2 "); // Se escribe el texto
siguiente Item
} // Fin del IF
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
} // Fin del IF

lcd.print (" EDC16C4 "); // Se escribe el texto
siguiente Item
} // Fin del IF
Item
} // Fin del IF

lcd.print (" Simos 3 "); // Se escribe el texto
44
siguiente Item
} // Fin del IF
Item
} // Fin del IF

lcd.print (" MP7.2 "); // Se escribe el texto
siguiente Item
} // Fin del IF
Item
} // Fin del IF
case 6: // Rueda Fónica Personalizada

lcd.print (" ME7.4.4 "); // Se escribe el texto
b++; // Se cambia el valor de la variable D para mantenerse en este
Item
} // Fin del IF
Item
} // Fin del IF

lcd.print (" ME7.5.10 "); // Se escribe el texto
H=2; // Se indica en la variable H los huecos.
Item
} // Fin del IF
Item
45
} // Fin del IF

lcd.print (" ME9.2.xx "); // Se escribe el texto
Item
} // Fin del IF
Item
} // Fin del IF

lcd.print (" S2000PM2 "); // Se escribe el texto
b=9; // Se cambia el valor de la variable D para mantenerse en este
Item
} // Fin del IF
Item
} // Fin del IF
} // Fin del SWITCH

} // Fin del Menu_2
//**************************************************************************************************
//**************************************** Menú 3 (Tipo de señal) **********************************

void Menu_3(){ // Tipo de señal
switch(c){ // Valor de la variable "b" ....
lcd.print (" 33-1 "); // Se escribe el texto
c++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
} // Fin del IF
c=1; // Se cambia el valor de la variable D para pasar al siguiente
Item
} // Fin del IF

46
siguiente Item
} // Fin del IF
c--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
} // Fin del IF

siguiente Item
} // Fin del IF
Item
} // Fin del IF

siguiente Item
} // Fin del IF
Item
} // Fin del IF

lcd.print (" Personalizar "); // Se escribe el texto
c=5; // Se cambia el valor de la variable D para mantenerse en este
Item
} // Fin del IF
Item
} // Fin del IF
} // Fin del SWITCH
} // Fin del Menu_3
//**************************************************************************************************
//**************************************** Menú 4 (Ajuste pedal acelerador) ************************

void Menu_4(){ // Ajuste pedal acelerador
47
if (d == 1){ // Se ajusta los valores de la pista 1
if (x==0) { // Si la variable X=0
lcd.print (Pista1Max); // Se escribe el valor de la variable Pista1Max
x=1; // Se cambia el valor de la variable X para no volver a
ejecutar el IF
} // Fin del IF
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila.

lcd.print ("Aceler. Pista 1"); // Se escribe el texto
lcd.print ("Volt: "); // Se escribe el texto
lcd.print ("V "); // Se escribe el texto
....
HoraActual
if (d == 1 && P == 1){ // Esta en la posición del valor Pista1Min
lcd.print (Pista1Min); // Se escribe el valor de la variable Pista1Min
} // Fin del IF
if (d == 1 && P == 2){ // Esta en la posición del valor Pista1Max
lcd.print (Pista1Max); // Se escribe el valor de la variable
Pista1Max
} // Fin del IF
} // Fin del IF
} // Fin del IF
} // Fin del IF
} // Fin del IF
} // Fin del IF
//#### Modificación del Voltaje Min y Max Pista 1 ####//

if (key == 0 && P == 1){ // Si se pulsa el botón de la derecha
Pista1Min = Pista1Min + 0.1; // Incrementamos 0.1 unidad la variable Pista1Min
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista1Min > 5.0) Pista1Min=0.0; // Si el valor de la variable Pista1Min mayor de 5.0 pasamos
al valor 0.0
} // Fin del IF
if (key == 3 && P == 1){ // Si pulsamos el botón de la izquierda
Pista1Min = Pista1Min - 0.1; // Decrecemos 0.1 unidad la variable Pista1Min
pulsador)
if (Pista1Min < 0.0) Pista1Min=5.0; // Si el valor de la variable Pista1Min menor de 0.0 pasamos
al valor 5.0
} // Fin del IF
Pista1Max = Pista1Max + 0.1; // Incrementamos 0.1 unidad la variable Pista1Max
pulsador)
48
if (Pista1Max > 5.0) Pista1Max=0.0; // Si el valor de la variable Pista1Max mayor de 5.0 pasamos
al valor 0.0
} // Fin del IF
Pista1Max = Pista1Max - 0.1; // Decrecemos 0.1 unidad la variable Pista1Max
pulsador)
if (Pista1Max < 0.0) Pista1Max=5.0; // Si el valor de la variable Pista1Max menor de 0.0 pasamos
al valor 5.0
} // Fin del IF
//#### Confirmación del Voltaje Pista 1 ####//

if (key == 2 && P == 3){ // Confirmamos el cambio del valor Pista1Max
delay (1000); // Se pausa 1000mseg. para visualizar los datos
x=0; // Se cambia la variable X para escribir el valor Pista2Max
d=2; // Se cambia la variable J para cambiar a los valores de la
pista 2
} // Fin del IF
} // Fin del IF
if (d == 2){ // Se ajusta los valores de la pista 2

if (x==0) { // Si la variable X=0
x=1; // Se cambia el valor de la variable X para no volver a
ejecutar el IF
} // Fin del IF

lcd.print ("Aceler. Pista 2"); // Se escribe el texto
lcd.print ("Volt: "); // Se escribe el texto
lcd.print ("V "); // Se escribe el texto
....
HoraActual
} // Fin del IF
} // Fin del IF
} // Fin del IF
} // Fin del IF
} // Fin del IF
49
} // Fin del IF
} // Fin del IF
//#### Modificación del Voltaje Min y Max Pista 2 ####//

Pista2Min = Pista2Min + 0.1; // Incrementamos 0.1 unidad la variable Pista2Min
pulsador)
if (Pista2Min > 5.0) Pista2Min=0.0; // Si el valor de la variable Pista2Min mayor de 5.0 pasamos
al valor 0.0
} // Fin del IF
Pista2Min = Pista2Min - 0.1; // Decrecemos 1 unidad la variable Pista2Min
pulsador)
if (Pista2Min < 0.0) Pista2Min=5.0; // Si el valor de la variable Pista2Min menor de 0.0 pasamos
al valor 5.0
} // Fin del IF
Pista2Max = Pista2Max + 0.1; // Incrementamos 1 unidad la variable Pista2Max
pulsador)
if (Pista2Max > 5.0) Pista2Max=0.0; // Si el valor de la variable Pista2Max mayor de 5.0 pasamos
al valor 0.0
} // Fin del IF
Pista2Max = Pista2Max - 0.1; // Decrecemos 1 unidad la variable Pista2Max
pulsador)
if (Pista2Max < 0.0) Pista2Max=5.0; // Si el valor de la variable Pista2Max menor de 0.0 pasamos
al valor 5.0
} // Fin del IF
//#### Confirmación del Voltaje Pista 2 ####//

if (key == 2 && P == 5){ // Confirmamos el cambio del valor Pista2Max
delay (1000); // Se pausa 1000mseg. para visualizar los datos
d=0; // Se resetean las variables
P=0; // Se resetean las variables
a=0; // Se resetean las variables
lcd.clear(); // Se limpia el lcd
} // Fin del IF
} // Fin del IF
} // Fin del Menu_4
//**************************************************************************************************
//**************************************** Menú 5 (Ajuste de Hora) *********************************

void Menu_5(){ // Ajuste de Hora
switch(e){ // Bloque de configuración
case 1: // Ajuste de Hora
lcd.print (" Hora "); // Se escribe el texto
e=2; // Se cambia el valor de la variable D para pasar al siguiente
Item
} // Fin del IF
Item
} // Fin del IF
case 2: // Ajuste de Fecha

lcd.print (" Fecha "); // Se escribe el texto
50
e=2; // Se cambia el valor de la variable D para mantenerse en este
Item
} // Fin del IF
Item
} // Fin del IF
} // Fin del SWITCH
} // Fin del Menu_5
//**************************************************************************************************
//**************************************** Menú 6 (Confirmar cambio Fecha y Hora) ******************

void Menu_6(){ // Confirmar cambio Fecha y Hora
switch(HF){ // Bloque de Fecha/Hora
case 1: // Ajuste de Hora
if (hours < 10) lcd.print ("0"); // Si Hora es menor de 10 se pone delante un 0
lcd. print (hours); // Se escribe la hora
lcd. print (":"); // Se escribe el texto
if (minutes < 10) lcd.print ("0"); // Si Minutos es menor de 10 se pone delante un 0
lcd. print (minutes); // Se escribe los minutos
lcd. print (":"); // Se escribe el texto
if (seconds < 10) lcd.print ("0"); // Si Segundos es menor de 10 se pone delante un 0
lcd. print (seconds); // Se escribe los segundos
lcd. print (" "); // Se escribe el texto
///// Modificación de Horas y Minutos /////

hours++; // Incrementamos 1 unidad las horas
if (hours > 23) hours=0; // Si el valor de las horas es mayor de 23 pasamos al valor 0
lcd.write (hours); // Se guarda el valor de las horas
initChrono(); // Se ejecuta el bloque de InitChrono
} // Fin del IF
hours--; // Decrecemos 1 unidad las horas
if (hours < 0) hours=23; // Si el valor de las horas es menor de 0 pasamos al valor 23
lcd.write (hours); // Se guarda el valor de las horas
} // Fin del IF

minutes++; // Incrementamos 1 unidad los minutos
if (minutes > 59) minutes=0; // Si el valor de los minutos es mayor de 59 pasamos al valor
0
lcd.write (minutes); // Se guarda el valor de los minutos
} // Fin del IF
minutes--; // Decrecemos 1 unidad los minutos
if (minutes < 0) minutes=59; // Si el valor de los minutos es menor de 0 pasamos al valor
59
lcd.write (minutes); // Se guarda el valor de los minutos
} // Fin del IF
///// Confirmación de Horas y Minutos /////
if (key == 2 && P == 3){ // Confirmamos el cambio de las Horas
delay (250); // Se pausa 250mseg. para que confirme el cambio de los
Dientes
} // Fin del IF
if (key == 2 && P == 4){ // Confirmamos el cambio de los Minutos
delay (250); // Se pausa 250mseg. para que confirme el cambio de los Huecos
51
a = 0; // Se cambia el valor de la variable A acceder al Menú 1 (Menú
Principal)
e = 0; // Se mantiene la variable I para estar en el Menú 10 (Ajuste
de Hora)
(se pone el contador a cero)
loop (); // Se ejecuta el bloque de Loop
} // Fin del IF
case 2: // Ajuste de la fecha

if (date < 10) lcd.print ("0"); // Si Día es menor de 10 se pone delante un 0
lcd. print (date); // Se escribe el día
lcd.print ("/"); // Se escribe el texto
switch (month){ // Si el valor del mes es....
case 1: // 1
lcd.print ("Ene"); // Se escribe el texto
case 2: // 2
lcd.print ("Feb"); // Se escribe el texto
case 3: // 3
lcd.print ("Mar"); // Se escribe el texto
case 4: // 4
lcd.print ("Abr"); // Se escribe el texto
case 5: // 5
lcd.print ("May"); // Se escribe el texto
case 6: // 6
lcd.print ("Jun"); // Se escribe el texto
case 7: // 7
lcd.print ("Jul"); // Se escribe el texto
case 8: // 8
lcd.print ("Ago"); // Se escribe el texto
case 9: // 9
lcd.print ("Sep"); // Se escribe el texto
case 10: // 10
lcd.print ("Oct"); // Se escribe el texto
case 11: // 11
lcd.print ("Nov"); // Se escribe el texto
case 12: // 12
lcd.print ("Dic"); // Se escribe el texto
} // Fin del SWITCH
lcd.print ("20"); // Se escribe el texto
if (year < 10) lcd.print ("0"); // Si Año es menor de 10 se pone delante un 0
lcd. print (year); // Se escribe el año
///// Modificación de Día, Mes y Año /////

date++; // Incrementamos 1 unidad los Días
if (date > 31) date=1; // Si el valor de los Días es mayor de 31 pasamos al valor 1
lcd.write (date); // Se guarda el valor de los Días
} // Fin del IF
date--; // Decrecemos 1 unidad los Días
if (date < 1) date=31; // Si el valor de los Días es menor de 1 pasamos al valor 31
lcd.write (date); // Se guarda el valor de los Días
} // Fin del IF
52
month++; // Incrementamos 1 unidad del Mes
if (month > 12) month=1; // Si el valor del Mes es mayor de 12 pasamos al valor 1
lcd.write (month); // Se guarda el valor del Mes
} // Fin del IF
month--; // Decrecemos 1 unidad del Mes
if (month < 1) month=12; // Si el valor del Mes es menor de 1 pasamos al valor 12
lcd.write (month); // Se guarda el valor del Mes
} // Fin del IF

year++; // Incrementamos 1 unidad el Año
if (year > 30) year=30; // Si el valor el Año es mayor de 30 pasamos al valor 30
lcd.write (year); // Se guarda el valor del Año
} // Fin del IF
year--; // Decrecemos 1 unidad el Año
if (year < 13) year=13; // Si el valor el Año es menor de 13 pasamos al valor 13
lcd.write (year); // Se guarda el valor el Año
} // Fin del IF
///// Confirmación de Día, Mes, Año /////

if (key == 2 && P == 3){ // Confirmamos el cambio del Día
delay (250); // Se pausa 250mseg. para que confirme el cambio del Día
} // Fin del IF
if (key == 2 && P == 4){ // Confirmamos el cambio del Mes
delay (250); // Se pausa 250mseg. para que confirme el cambio del Mes
} // Fin del IF
if (key == 2 && P == 5){ // Confirmamos el cambio del Año
delay (250); // Se pausa 250mseg. para que confirme el cambio del Año
a = 0; // Se cambia el valor de la variable A acceder al Menú 1 (Menú
Principal)
e = 0; // Se mantiene la variable I para estar en el Menú 10 (Ajuste
de Hora)
(se pone el contador a cero)
loop (); // Se ejecuta el bloque de Loop
} // Fin del IF
} // Fin del SWITCH
} // Fin del Menu_11
//**************************************************************************************************
//**************************************** Menú 7 (Menú principal) *********************************

void Menu_7(){ // Menú principal
while (N==1){ // Bloque de control pedal acelerador
RPM = analogRead(PontRPM); // Se asigna a la variable RPM el valor del
potenciometro de entrada
RPM = map(RPM, 1023, 0, 150, 1000); // 150 uS a 1000 uS de 5000 a 800 rpm
Acelerador = analogRead (PontAcelerador); // Se asigna la variable a la entrada analógica

PistaAMin = (255*Pista1Min)/5; // Conversor del valor minimo de la pista 1 a
valor PWM
PistaAMax = (255*Pista1Max)/5; // Conversor del valor maximo de la pista 1 a
valor PWM
PistaBMin = (255*Pista2Min)/5; // Conversor del valor minimo de la pista 2 a
valor PWM
PistaBMax = (255*Pista2Max)/5; // Conversor del valor maximo de la pista 2 a
valor PWM
53
Pista1 = map (Acelerador,0,1023,PistaAMin,PistaAMax); // Mapeo de la pista 1 con los valores mínimos
y maximos prefijados
Pista2 = map (Acelerador,0,1023,PistaBMin,PistaBMax); // Mapeo de la pista 2 con los valores mínimos
y maximos prefijados
analogWrite(Acelerador1 ,Pista1); // Salida del voltaje de la pista 1
analogWrite(Acelerador2 ,Pista2); // Salida del voltaje de la pista 2
for (int w = 0; w <= (D-3); w++) { //

triggerHigh(RPM,w ); // Se ejecuta el bucle "triggerREference" con la
frecuencia que se ha indicado con la variable RPM
for (int z = 0; z <= H; z++) { //
triggerReference(RPM); // Se ejecuta el bucle "triggerREference" con la
frecuencia que se ha indicado con la variable RPM
Cilindro = Cilindro++ ; // Cuenta la posición de cada cilindro (en el
ECU EDC15P tiene una señal diferente por cada cilindro)
if (key == 1){ // Confirmamos la pulsación de ESC
Sonido_Accion(); // Confirmamos con un pitido
Esc (); // Se ejecuta el bloque de Esc
} // Fin del IF
} // Fin del WHILE
} // Fin del Menu_1
//**************************************************************************************************
void display_time (){

char buf [ 12 ] ;
lcd. setCursor (11,0) ; // Posicionamos el texto en la 12ª posición de la 1ª fila
if (hours < 10) lcd.print ("0"); // Si Hora es menor de 10 se pone delante un 0
lcd. print (itoa(hours,buf,10)); // Se escribe la hora
lcd. setCursor (14,0) ; // Posicionamos el texto en la 15ª posición de la 1ª fila
if (minutes < 10) lcd.print ("0"); // Si Minutos es menor de 10 se pone delante un 0
lcd. print (itoa(minutes,buf,10)); // Se escribe los minutos
} // Fin del Display_Time
void display_date (){

char buf [12];
if (date < 10) lcd.print ("0"); // Si Día es menor de 10 se pone delante un 0
lcd. print (itoa(date,buf,10)); // Se escribe el día
switch (month){ // Si el valor del mes es....
case 1: // 1
lcd.print ("Ene"); // Se escribe el texto
case 2: // 2
lcd.print ("Feb"); // Se escribe el texto
case 3: // 3
lcd.print ("Mar"); // Se escribe el texto
case 4: // 4
lcd.print ("Abr"); // Se escribe el texto
case 5: // 5
lcd.print ("May"); // Se escribe el texto
case 6: // 6
lcd.print ("Jun"); // Se escribe el texto
case 7: // 7
lcd.print ("Jul"); // Se escribe el texto
case 8: // 8
lcd.print ("Ago"); // Se escribe el texto
case 9: // 9
lcd.print ("Sep"); // Se escribe el texto
case 10: // 10
lcd.print ("Oct"); // Se escribe el texto
case 11: // 11
lcd.print ("Nov"); // Se escribe el texto
case 12: // 12
lcd.print ("Dic"); // Se escribe el texto
54
} // Fin del SWITCH
} // Fin del Display_Date
void initChrono (){ // Se graban los nuevos valores en la memoria del Reloj
set_time (); // Se registra en el RTC los nuevos valores (Hora y Minutos)
set_date (); // Se registra en el RTC los nuevos valores (Día, Mes y Año)
} // Fin del initChrono
void set_date (){

Wire. beginTransmission (104); // Empieza transmisión.
Wire. write (3); // Set register to 3 (day)
Wire. write (decToBcd(day));
Wire. write (decToBcd(date));
Wire. write (decToBcd(month));
Wire. write (decToBcd(year));
Wire. endTransmission (); // Termina transmisión
} // Fin del set_date
void get_date (){

Wire. write (3); // Set register to 3 (day)
Wire. requestFrom (104,4); // Get 5 bytes(day,date,month,year,control);
day = bcdToDec ( Wire. read ());
date = bcdToDec ( Wire. read());
month = bcdToDec ( Wire. read());
year = bcdToDec ( Wire. read());
} // Fin del get_date
void set_time () {
Wire. write ((byte)0); // Set register to 0
Wire. write (decToBcd(seconds));
Wire. write (decToBcd(minutes));
Wire. write (decToBcd(hours));
} // Fin del set_time
void get_time () {
Wire. write ((byte)0); // Set register to 0
Wire. requestFrom (104,3); // Get 3 bytes (seconds,minutes,hours);
seconds = bcdToDec ( Wire. read() & 0x7f );
minutes = bcdToDec ( Wire. read ());
hours = bcdToDec ( Wire. read () & 0x3f );
}
// Convierte números decimales normales a binario codificado decimal

byte decToBcd (byte val){
return ((val/10*16) + (val%10));
}
// Convierte binario codificado decimal a números decimales normales

byte bcdToDec (byte val) {
return ((val/16*10) + (val%16));
}
int get_key (unsigned int input){

int k;
for (k = 0; k < NUM_KEYS; k++){
if (input < adc_key_val [k]){
return k;
}
}
if (k >= NUM_KEYS) k = -1;
return k;
}
// Sonido cuando hay una acción

void Sonido_Accion() { // Bloque de Sonido Acción
if (Beep == 1){ // Si la variable Beep esta en 1 se ejecuta el
bucle
digitalWrite(Buzzer, HIGH); // Se ponen en estado ALTO el pin del buzzer
digitalWrite(Buzzer, LOW); // Se ponen en estado BAJO el pin del buzzer
55
} // Fin del IF
} // Fin del bucle Sonido Acción
// Sonido de confirmación
void Sonido_Confirmacion() { // Bloque de Sonido Confirmación
if (Beep == 1){ // Si la variable Beep está en 1 se ejecuta el
bucle
} // Fin del IF
} // Fin del bucle Sonido Confirmación
56
7 PLANOS
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

Simulador de ECU S V.1.3

Cargado por

Copyright:

Formatos disponibles

Simulador de ECU S V.1.3

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Simulador de ECU S V.1.3

Cargado por

Copyright:

Formatos disponibles

2017

Jorge Vázquez Nuño

2 Conceptos básicos .......................................................................................... 5

2.1 Tutorial RTC DS1307 ............................................................................... 5

2.1.1 Conexiones entre Modulo RTC DS1307 y Arduino ............................. 6

2.1.2 Librería para el RTC DS1307 .............................................................. 7

2.1.3 Actualizando la Hora y fecha de nuestro DS1307 ............................... 7

2.1.4 Obteniendo Hora y Fecha del DS1307 ................................................ 9

2.2.1 Conexiones entre Arduino y Módulo adaptador LCD a I2C ................14

2.2.2 Librería LiquidCrystal_I2C para Arduino.............................................15

2.2.3 1. Un Hola mundo con Arduino y LCD ...............................................16

2.2.4 2. Desplazando el texto en el LCD .....................................................17

2.2.5 3. Mostrando datos de sensores o variables en el LCD .....................19

2.2.6 4. Agregando nuevos caracteres a nuestro LCD ................................20

4 Lista de componentes ....................................................................................27

4.1 Placa display ...........................................................................................27

4.3 Placa para el cuerpo de Mariposa y Pedal acelerador ............................29

6 Programa arduino (Generador señal CKP-CMP)............................................32

2.1 Tutorial RTC DS1307

La comunicación entre el Arduino y el

2.1.1 Conexiones entre Modulo RTC DS1307 y Arduino

GND GND GND GND

Como se observa la conexión es como cualquier conexión I2C.

2.1.3 Actualizando la Hora y fecha de nuestro DS1307

rtc.adjust(DateTime(2016,6,10,18,29,0));//2016,Junio,10,18 h,29 min,0 seg

//Enviamos por el puerto serie la hora y fecha.

Como se observa el código es simple y fácil de entender

HoraFecha = rtc.now(); //obtenemos la hora y fecha actual

Cada vez que se llama a rtc.now se actualiza la hora y se guarda en el objeto

char nombreDia[7][12] = {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Vi

//Enviamos por el puerto serie la hora y fecha.

La salida del monitor serial es el siguiente:

EL Módulo adaptador LCD a I2C que

2.2.1 Conexiones entre Arduino y Módulo adaptador LCD a I2C

El adaptador LCD a i2C tiene los pines

GND GND GND GND

2.2.2 Librería LiquidCrystal_I2C para Arduino

✓ LiquidCrystal_I2C(lcd_Addr, lcd_cols, lcd_rows)

Explicado la librería veamos unos ejemplos:

2.2.3 1. Un Hola mundo con Arduino y LCD

//Crear el objeto lcd dirección 0x27 y 16 columnas x 2 filas

Después de cargar, en su LCD deben obtener el siguiente resultado

2.2.4 2. Desplazando el texto en el LCD

EL resultado será el texto desplazándose de derecha a izquierda.

//Crear el objeto lcd dirección 0x27 y 16 columnas x 2 filas

Su resultado debe ser el siguiente.

2.2.6 4. Agregando nuevos caracteres a nuestro LCD

Para este ejemplo crearemos los siguientes caracteres:

//Crear el objeto lcd dirección 0x27 y 16 columnas x 2 filas

//Encender la luz de fondo.

//creamos los nuevos caracteres

El resultado del ejemplo anterior es el siguiente:

4.1 Placa display

// Definir los caracteres del logotipo (JVN)

// Declaramos el LCD (dirección: 0x20)

// Declaramos la fecha, hora como variables

// Configuración del teclado serie y del LCD [pulsadores A3],

// Declaramos las variables y las inicializamos con el valor 0

// Inicio del Setup

// Menús ***********

// Fin Menús *******

//************** Menú Esc (Esc al menu inicial)

//******** Menú 1 (Menú principal) *

//**** Menú 2 (Tipo de ECU)

//****** Menú 3 (Tipo de señal)

//**************** Menú 4 (Ajuste pedal acelerador)