Accede a apuntes, guías, libros y más de tu carrera

programa-simulador-de-ecu-v13

74 pag.

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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.

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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.

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 3

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 4

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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.

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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 () {
}

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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);
rtc.begin(); //Inicializamos el RTC
}

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("/");

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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:

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

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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);
rtc.begin(); //Inicializamos el RTC
}

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();
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 * 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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

✓ 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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 // 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>
#include <LiquidCrystal_I2C.h>
//Crear el objeto lcd dirección 0x27 y 16 columnas x 2 filas
LiquidCrystal_I2C lcd(0x27,16,2); //

17

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

void setup() {
// Inicializar el LCD
lcd.init();
//Encender la luz de fondo.
lcd.backlight();
// Escribimos el Mensaje en el LCD en una posición central.
lcd.setCursor(10, 0);
lcd.print("WWW.NAYLAMPMECHATRONICS.COM");
lcd.setCursor(4, 1);
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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>
#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();
}

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 Como máximo podemos crear 8
caracteres nuevos.

Para este ejemplo crearemos los siguientes caracteres:

21

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

A continuación se muestra el código para implementar los nuevos caracteres.

#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); //
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

B00100,
B01010,
B10001,
B00000,
};

void setup() {
// Inicializar el LCD
lcd.init();

//Encender la luz de fondo.

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.setCursor(0, 0);
lcd.print("Tutorial LCD_I2C");
lcd.setCursor(0, 1);
lcd.write (byte (7));
lcd.print(" ");
lcd.write (byte (6));
lcd.print(" ");
lcd.write (byte (0));
lcd.write (byte (1));
lcd.write (byte (2));
lcd.write (byte (3));
lcd.write (byte (1));
lcd.write (byte (4));
lcd.write (byte (5));
lcd.print(" ");
lcd.write (byte (6));
lcd.print(" ");

24

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 lcd.write (byte (7));
}

void loop () {}

El resultado del ejemplo anterior es el siguiente:

25

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

3 ESQUEMAS

26

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

4 LISTA DE COMPONENTES

4.1 Placa display

27

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

4.2 Placaprincipal

28

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 31

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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};
byte caracter1[8] = {
B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100};
byte caracter2[8] = {
B11100,B11100,B11100,B11100,B11110,B11111,B11111,B11111};
byte caracter3[8] = {
B11100,B11100,B11100,B11110,B01111,B00111,B00011,B00001};
byte caracter4[8] = {
B00111,B00111,B00111,B01111,B11110,B11100,B11000,B10000};
byte caracter5[8] = {
B11111,B11111,B11111,B01111,B00111,B00111,B00111,B00111};
byte caracter6[8] = {
B00000,B00111,B00111,B01111,B01111,B11111,B01100,B01100};
byte caracter7[8] = {
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

lcd.createChar (1, caracter1); // Asignación al Byte 1 el carácter 1
lcd.createChar (2, caracter2); // Asignación al Byte 2 el carácter 2
lcd.createChar (3, caracter3); // Asignación al Byte 3 el carácter 3
lcd.createChar (4, caracter4); // Asignación al Byte 4 el carácter 4
lcd.createChar (5, caracter5); // Asignación al Byte 5 el carácter 5
lcd.createChar (6, caracter6); // Asignación al Byte 6 el carácter 6
lcd.createChar (7, caracter7); // Asignación al Byte 7 el carácter 7

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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Se posiciona en la segunda línea, primer carácter
lcd.print ("Comprobador ECUs"); // Se escribe el nombre del proyecto y versión
lcd.setCursor (5,1); // Se posiciona en la segunda línea, primer carácter
lcd.print ("v.1.3"); // Se escribe el nombre del proyecto y versión
delay (1500); // Se pausa 2seg.
lcd.clear (); // Se limpia el lcd
} // Fin del Setup
//**************************************** Fin del Setup *******************************************

33

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

//**************************************** 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.setCursor (13,0); // Posicionamos el texto en la 14ª posición de la 1ª fila
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
adc_key_in = analogRead (Boton); // Se lee el valor de la pulsación
key = get_key(adc_key_in); // Se obtiene el valor pulsado
} // 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.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila
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
Menu_2 (); // Se ejecuta el bloque de Menú_2
/////////////////////////////////////////////

////////// Menú 3 (Rueda fónica) ///////////

if (a == 1 && key == 2 && P == 1) { // Estamos en el menú de Rueda fónica
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila
lcd.print (" Rueda fonica "); // Se escribe el texto
a = 9; // Se cambia el valor de la variable A para no entrar en el
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
Menu_3 (); // Se ejecuta el bloque de Menú_3
/////////////////////////////////////////////

34

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 ////////// Menú 4 (Ajuste Acelerador) ///////
if (a == 2 && key == 2 && P == 1){ // Estamos en el menú de Ajuste de Hora
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila
lcd.print (" Ajuste Acel. "); // Se escribe el texto
a = 9; // Se cambia el valor de la variable A para no entrar en el
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
Menu_4 (); // Se ejecuta el bloque de Menú_4
/////////////////////////////////////////////

////////// Menú 5 (Ajuste de Hora) /////////

if (a == 3 && key == 2 && P == 1){ // Estamos en el menú de Ajuste de Hora
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila
lcd.print (" Ajuste Reloj "); // Se escribe el texto
a = 9; // Se cambia el valor de la variable A para no entrar en el
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
Menu_5 (); // Se ejecuta el bloque de Menú_5
/////////////////////////////////////////////

////////// Menú 6 (Confirmar cambio F y H) /

if (e == 1 && key == 2 && P == 2){ // Estamos en el menú de Confirmar cambio Hora
lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" "); // Se escribe el texto
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

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" "); // Se escribe el texto
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
Menu_6 (); // Se ejecuta el bloque de Menú_6
/////////////////////////////////////////////

//////// 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (EDC15P) "); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 8 (Simulación CKP-CMP EDC15C2) /

if (b == 2 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila

35

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (EDC15C2)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 9 (Simulación CKP-CMP EDC16C4) /

if (b == 3 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (EDC16C4)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

/////// Menú 10 (Simulación CKP-CMP Simos 3) /

if (b == 4 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print ("Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (Simos 3)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 11 (Simulación CKP-CMP ME7.2) /

if (b == 5 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (ME7.2) "); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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

36

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 11 (Simulación CKP-CMP ME7.4.4) /

if (b == 6 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (ME7.4.4)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 12 (Simulación CKP-CMP ME7.5.10) /

if (b == 7 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print ("Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (ME7.5.10)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 13 (Simulación CKP-CMP ME9.2.xx) /

if (b == 8 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print ("Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (ME9.2.xx)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7

37

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 /////////////////////////////////////////////

//////// Menú 14 (Simulación CKP-CMP S2000PM2) /

if (b == 9 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print ("Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al (S2000PM2)"); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 101 (Simulación CKP-CMP 33-1) /

if (c == 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al Config. "); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (D); // Se escribe la variable
lcd.print ("-"); // Se escribe el texto
lcd.print (H); // Se escribe la variable
lcd.print (" sin fase "); // Se escribe el texto
Sonido_Accion(); // Se ejecuta el bloque de Sonido_Accion
c = 9; // Se cambia el valor de la variable C 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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 102 (Simulación CKP-CMP 33-2) /

if (c == 2 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al Config. "); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (D); // Se escribe la variable
lcd.print ("-"); // Se escribe el texto
lcd.print (H); // Se escribe la variable
lcd.print (" sin fase "); // Se escribe el texto
Sonido_Accion(); // Se ejecuta el bloque de Sonido_Accion
c = 9; // Se cambia el valor de la variable C 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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 103 (Simulación CKP-CMP 44-2) /

if (c == 3 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al Config. "); // Se escribe el texto

38

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (D); // Se escribe la variable
lcd.print ("-"); // Se escribe el texto
lcd.print (H); // Se escribe la variable
lcd.print (" sin fase "); // Se escribe el texto
Sonido_Accion(); // Se ejecuta el bloque de Sonido_Accion
c = 9; // Se cambia el valor de la variable C 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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 104 (Simulación CKP-CMP 60-2) /

if (c == 4 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al Config. "); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (D); // Se escribe la variable
lcd.print ("-"); // Se escribe el texto
lcd.print (H); // Se escribe la variable
lcd.print (" sin fase "); // Se escribe el texto
Sonido_Accion(); // Se ejecuta el bloque de Sonido_Accion
c = 9; // Se cambia el valor de la variable C 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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

//////// Menú 105 (Simulación CKP-CMP Personalizada) /

if (c == 5 && 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.clear (); // Se limpia el lcd
lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al Config. "); // Se escribe el texto
lcd.setCursor (2,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (D); // Se escribe la variable
lcd.print ("-"); // Se escribe el texto
lcd.print (H); // Se escribe la variable
lcd.print (" sin fase "); // Se escribe el texto
Sonido_Accion(); // Se ejecuta el bloque de Sonido_Accion
c = 9; // Se cambia el valor de la variable C 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
Menu_7 (); // Se ejecuta el bloque de Menú_7
/////////////////////////////////////////////

////////// 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
lcd.clear (); // Se limpia el lcd
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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
case 3: // Si es el diente 3 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
case 11: // Si es el diente 11 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 12: // Si es el diente 12 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF

/* if (j == 1){ // Si es la ECU EDC15 (Variable Y = 1)

switch (count){ // Se ejecuta el bloque Switch
case 0: // Si es el diente 0 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 1: // Si es el diente 1 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF
break;*/ // Salimos del SWITCH

case 2: // Cilindro Nº 2
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
case 3: // Si es el diente 3 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
case 5: // Si es el diente 5 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 6: // Si es el diente 6 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF

/* if (j == 1){ // Si es la ECU EDC15 (Variable Y = 1)

switch (count){ // Se ejecuta el bloque Switch
case 0: // Si es el diente 0 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 1: // Si es el diente 1 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto

40

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

case 3: // Cilindro Nº 3
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
case 3: // Si es el diente 3 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF

/* if (j == 1){ // Si es la ECU EDC15 (Variable Y = 1)

switch (count){ // Se ejecuta el bloque Switch
case 0: // Si es el diente 0 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 1: // Si es el diente 1 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF
break;*/ // Salimos del SWITCH

case 4: // Cilindro Nº 4
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
case 3: // Si es el diente 3 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
case 8: // Si es el diente 8 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 9: // Si es el diente 9 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF

/* if (j == 1){ // Si es la ECU EDC15 (Variable Y = 1)

switch (count){ // Se ejecuta el bloque Switch
case 0: // Si es el diente 0 del CKP
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
break; // Salimos del SWITCH
case 1: // Si es el diente 1 del CKP
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
break; // Salimos del SWITCH
} // Fin del SWITCH
} // Fin del IF
break;*/ // Salimos del SWITCH

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
delayMicroseconds(duration); // Se genera una pausa según la variable DURATION
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){
digitalWrite(CMP, LOW); // Se pone la salida digital CMP en estado bajo
} // Fin del IF
delayMicroseconds(duration); // Se genera una pausa según la variable DURATION
digitalWrite(CMP, HIGH); // Se pone la salida digital CMP en estado alto
} // Fin del IF

41

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

//**************************************** Logotipo ************************************************
void Logo (){
lcd.createChar (0, caracter0); // Se crea el caracter especial "caracter0" y se guarda en el
byte 0
lcd.createChar (1, caracter1); // Se crea el caracter especial "caracter1" y se guarda en el
byte 1
lcd.createChar (2, caracter2); // Se crea el caracter especial "caracter2" y se guarda en el
byte 2
lcd.createChar (3, caracter3); // Se crea el caracter especial "caracter3" y se guarda en el
byte 3
lcd.createChar (4, caracter4); // Se crea el caracter especial "caracter4" y se guarda en el
byte 4
lcd.createChar (5, caracter5); // Se crea el caracter especial "caracter5" y se guarda en el
byte 5
lcd.createChar (6, caracter6); // Se crea el caracter especial "caracter6" y se guarda en el
byte 6
lcd.createChar (7, caracter7); // Se crea el caracter especial "caracter7" y se guarda en el
byte 7

Sonido_Confirmacion(); // Se confirma mediante sonido

lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila

lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
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.write (byte(1)); // Se escribe el contenido del byte 1
lcd.write (byte(0)); // Se escribe el contenido del byte 0
lcd.write (byte(2)); // Se escribe el contenido del byte 2
lcd.write (byte(0)); // Se escribe el contenido del byte 0
lcd.print (" "); // Se escribe 1 espacio en blanco
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila

lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print (" "); // Se escribe 1 espacio en blanco
lcd.write (byte(3)); // Se escribe el contenido del byte 3
lcd.write (byte(4)); // Se escribe el contenido del byte 4
lcd.write (byte(3)); // Se escribe el contenido del byte 3
lcd.write (byte(4)); // Se escribe el contenido del byte 4
lcd.write (byte(1)); // Se escribe el contenido del byte 1
lcd.write (byte(5)); // Se escribe el contenido del byte 5
lcd.print (" "); // Se escribe 1 espacio en blanco
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto
lcd.print ("*"); // Se escribe el texto

delay (2000); // Se pausa 2seg.

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

lcd.setCursor (0,0); // Posicionamos el texto en la 1ª posición de la 1ª fila

lcd.write (byte(6)); // Se escribe el contenido del byte 6
lcd.write (byte(7)); // Se escribe el contenido del byte 7
lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.write (byte(6)); // Se escribe el contenido del byte 6
lcd.write (byte(7)); // Se escribe el contenido del byte 7
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 case 0: // Tipo de señal
lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
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
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // 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
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 1: // Tipo de señal

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" Confg. Se"); // Se escribe el texto
lcd.print (char(238)); // Escribimos el carácter "ñ"
lcd.print ("al "); // 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
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
a--; // Se cambia el valor de la variable D para pasar al siguiente
Item
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del SWITCH

case 2: // Tipo de señal

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print ("Ajuste Aceler."); // 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++; // Se cambia el valor de la variable A para pasar al siguiente
Item
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
a--; // Se cambia el valor de la variable A para pasar al siguiente
Item
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 3: // Tipo de señal

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" Ajuste Reloj "); // Se escribe el texto
if (key == 0){ // Si se pulsa la tecla de la derecha
a=3; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
a--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 200mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch
} // 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
lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila

43

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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
Pista2Min = 0.00; // Valor en tensión mínimo de la pista 2
Pista2Max = 0.00; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b=1; // Se cambia el valor de la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 2: // Rueda Fónica 33-1

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" EDC15C2 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.50; // Valor en tensión mínimo de la pista 1
Pista1Max = 1.70; // Valor en tensión máximo de la pista 1
Pista2Min = 0.80; // Valor en tensión mínimo de la pista 2
Pista2Max = 3.70; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 3: // Rueda Fónica 44-2

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" EDC16C4 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.30; // Valor en tensión mínimo de la pista 1
Pista1Max = 2.00; // Valor en tensión máximo de la pista 1
Pista2Min = 0.60; // Valor en tensión mínimo de la pista 2
Pista2Max = 4.00; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 4: // Rueda Fónica 60-2

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" Simos 3 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.35; // Valor en tensión mínimo de la pista 1
Pista1Max = 4.85; // Valor en tensión máximo de la pista 1
Pista2Min = 0.75; // Valor en tensión mínimo de la pista 2
Pista2Max = 4.85; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha

44

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 5: // Rueda Fónica 60-2

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" MP7.2 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.50; // Valor en tensión mínimo de la pista 1
Pista1Max = 4.40; // Valor en tensión máximo de la pista 1
Pista2Min = 0.00; // Valor en tensión mínimo de la pista 2
Pista2Max = 0.00; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 6: // Rueda Fónica Personalizada

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" ME7.4.4 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.60; // Valor en tensión mínimo de la pista 1
Pista1Max = 4.00; // Valor en tensión máximo de la pista 1
Pista2Min = 0.30; // Valor en tensión mínimo de la pista 2
Pista2Max = 2.00; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 7: // Rueda Fónica Personalizada

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" ME7.5.10 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos.
Pista1Min = 0.10; // Valor en tensión mínimo de la pista 1
Pista1Max = 4.60; // Valor en tensión máximo de la pista 1
Pista2Min = 0.10; // Valor en tensión mínimo de la pista 2
Pista2Max = 2.30; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item

45

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 8: // Rueda Fónica Personalizada

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" ME9.2.xx "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.00; // Valor en tensión mínimo de la pista 1
Pista1Max = 0.00; // Valor en tensión máximo de la pista 1
Pista2Min = 0.00; // Valor en tensión mínimo de la pista 2
Pista2Max = 0.00; // Valor en tensión máximo de la pista 2
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
b++; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 9: // Rueda Fónica Personalizada

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" S2000PM2 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
Pista1Min = 0.80; // Valor en tensión mínimo de la pista 1
Pista1Max = 4.60; // Valor en tensión máximo de la pista 1
Pista2Min = 0.00; // Valor en tensión mínimo de la pista 2
Pista2Max = 0.00; // Valor en tensión máximo de la pista 2
if (key == 0){ // Si se pulsa la tecla de la derecha
b=9; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
b--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

} // 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" ....
case 1: // Rueda Fónica 33-1
lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" 33-1 "); // Se escribe el texto
D=33; // Se indica en la variable D los dientes
H=1; // Se indica en la variable H los huecos
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
c++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
c=1; // Se cambia el valor de la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 2: // Rueda Fónica 33-1

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda

46

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 lcd.print (" 30-2 "); // Se escribe el texto
D=30; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
c++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
c--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 3: // Rueda Fónica 44-2

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" 44-2 "); // Se escribe el texto
D=44; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
c++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
c--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 4: // Rueda Fónica 60-2

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" 60-2 "); // Se escribe el texto
D=60; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
lcd.print (char(126)); // Se escribe la flecha a la derecha
if (key == 0){ // Si se pulsa la tecla de la derecha
c++; // Incrementamos 1 unidad la variable D para pasar al
siguiente Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
c--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 5: // Rueda Fónica Personalizada

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" Personalizar "); // Se escribe el texto
D=50; // Se indica en la variable D los dientes
H=2; // Se indica en la variable H los huecos
if (key == 0){ // Si se pulsa la tecla de la derecha
c=5; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
c--; // Decrecemos 1 unidad la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch
} // Fin del SWITCH
} // Fin del Menu_3
//**************************************************************************************************

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

void Menu_4(){ // Ajuste pedal acelerador

47

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 if (d == 1){ // Se ajusta los valores de la pista 1
if (x==0) { // Si la variable X=0
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
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.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila.
lcd.print ("Volt: "); // Se escribe el texto
lcd.setCursor (10,1); // Posicionamos el texto en la 11ª posición de la 2ª fila.
lcd.print (char(126)); // Se escribe la flecha a la derecha
lcd.setCursor (15,1); // Posicionamos el texto en la 6ª posición de la 2ª fila.
lcd.print ("V "); // Se escribe el texto

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
if (d == 1 && P == 1){ // Esta en la posición del valor Pista1Min
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (Pista1Min); // Se escribe el valor de la variable Pista1Min
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista1Max); // Se escribe el valor de la variable Pista1Max
} // Fin del IF
if (d == 1 && P == 2){ // Esta en la posición del valor Pista1Max
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (Pista1Min); // Se escribe el valor de la variable Pista1Min
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista1Max); // Se escribe el valor de la variable
Pista1Max
} // Fin del IF
} // Fin del IF
else { // Y sino ....
if (d == 1 && P == 1){ // Esta en la posición del valor Pista1Min
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (" "); // Se escribe el texto
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista1Max); // Se escribe el valor de la variable Pista1Max
} // Fin del IF
if (d == 1 && P == 2){ // Esta en la posición del valor Pista1Max
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (Pista1Min); // Se escribe el valor de la variable Pista1Min
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (" "); // Se escribe el texto
} // Fin del IF
Parpadeo = true ; // La variable Parpadeo pasa a valor Verdadero
} // 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
lcd.print (Pista1Min); // Se escribe el valor de la variable Pista1Min
} // 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
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista1Min < 0.0) Pista1Min=5.0; // Si el valor de la variable Pista1Min menor de 0.0 pasamos
al valor 5.0
lcd.print (Pista1Min); // Se escribe el valor de la variable Pista1Min
} // Fin del IF
if (key == 0 && P == 2){ // Si se pulsa el botón de la derecha
Pista1Max = Pista1Max + 0.1; // Incrementamos 0.1 unidad la variable Pista1Max
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)

48

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 if (Pista1Max > 5.0) Pista1Max=0.0; // Si el valor de la variable Pista1Max mayor de 5.0 pasamos
al valor 0.0
lcd.print (Pista1Max); // Se escribe el valor de la variable Pista1Max
} // Fin del IF
if (key == 3 && P == 2){ // Si pulsamos el botón de la izquierda
Pista1Max = Pista1Max - 0.1; // Decrecemos 0.1 unidad la variable Pista1Max
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista1Max < 0.0) Pista1Max=5.0; // Si el valor de la variable Pista1Max menor de 0.0 pasamos
al valor 5.0
lcd.print (Pista1Max); // Se escribe el valor de la variable Pista1Max
} // Fin del IF

//#### Confirmación del Voltaje Pista 1 ####//

if (key == 2 && P == 3){ // Confirmamos el cambio del valor Pista1Max
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (Pista1Max); // Se escribe el valor de la variable 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
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista2Max); // Se escribe el valor de la variable Pista2Max
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 2"); // Se escribe el texto
lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila.
lcd.print ("Volt: "); // Se escribe el texto
lcd.setCursor (10,1); // Posicionamos el texto en la 11ª posición de la 2ª fila.
lcd.print (char(126)); // Se escribe la flecha a la derecha
lcd.setCursor (15,1); // Posicionamos el texto en la 6ª posición de la 2ª fila.
lcd.print ("V "); // Se escribe el texto

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
if (d == 2 && P == 3){ // Esta en la posición del valor Pista2Min
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (Pista2Min); // Se escribe el valor de la variable Pista2Min
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista2Max); // Se escribe el valor de la variable Pista2Max
} // Fin del IF
if (d == 2 && P == 4){ // Esta en la posición del valor Pista2Max
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (Pista2Min); // Se escribe el valor de la variable Pista2Min
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista2Max); // Se escribe el valor de la variable Pista2Max
} // Fin del IF
} // Fin del IF
else { // Y sino ....
if (d == 2 && P == 3){ // Esta en la posición del valor Pista2Min
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (" "); // Se escribe el texto
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (Pista2Max); // Se escribe el valor de la variable Pista2Max
} // Fin del IF
if (d == 2 && P == 4){ // Esta en la posición del valor Pista2Max
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 1ª fila
lcd.print (Pista2Min); // Se escribe el valor de la variable Pista2Min
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
lcd.print (" "); // Se escribe el texto
} // Fin del IF
Parpadeo = true ; // La variable Parpadeo pasa a valor Verdadero

49

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

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

//#### Modificación del Voltaje Min y Max Pista 2 ####//

if (key == 0 && P == 3){ // Si se pulsa el botón de la derecha
Pista2Min = Pista2Min + 0.1; // Incrementamos 0.1 unidad la variable Pista2Min
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista2Min > 5.0) Pista2Min=0.0; // Si el valor de la variable Pista2Min mayor de 5.0 pasamos
al valor 0.0
lcd.print (Pista2Min); // Se escribe el valor de la variable Pista2Min
} // Fin del IF
if (key == 3 && P == 3){ // Si pulsamos el botón de la izquierda
Pista2Min = Pista2Min - 0.1; // Decrecemos 1 unidad la variable Pista2Min
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista2Min < 0.0) Pista2Min=5.0; // Si el valor de la variable Pista2Min menor de 0.0 pasamos
al valor 5.0
lcd.print (Pista2Min); // Se escribe el valor de la variable Pista2Min
} // Fin del IF
if (key == 0 && P == 4){ // Si se pulsa el botón de la derecha
Pista2Max = Pista2Max + 0.1; // Incrementamos 1 unidad la variable Pista2Max
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista2Max > 5.0) Pista2Max=0.0; // Si el valor de la variable Pista2Max mayor de 5.0 pasamos
al valor 0.0
lcd.print (Pista2Max); // Se escribe el valor de la variable Pista2Max
} // Fin del IF
if (key == 3 && P == 4){ // Si pulsamos el botón de la izquierda
Pista2Max = Pista2Max - 0.1; // Decrecemos 1 unidad la variable Pista2Max
delay (Intervalo); // Se pausa por el valor del intervalo (Evitar rebotes de
pulsador)
if (Pista2Max < 0.0) Pista2Max=5.0; // Si el valor de la variable Pista2Max menor de 0.0 pasamos
al valor 5.0
lcd.print (Pista2Max); // Se escribe el valor de la variable Pista2Max
} // Fin del IF

//#### Confirmación del Voltaje Pista 2 ####//

if (key == 2 && P == 5){ // Confirmamos el cambio del valor Pista2Max
lcd.setCursor (11,1); // Posicionamos el texto en la 12ª posición de la 1ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (Pista2Max); // Se escribe el valor de la variable 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.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (" Hora "); // 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
e=2; // Se cambia el valor de la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
e=1; // Se cambia el valor de la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch

case 2: // Ajuste de Fecha

lcd.setCursor (0,1); // Posicionamos el texto en la 1ª posición de la 2ª fila
lcd.print (char(127)); // Se escribe la flecha a la izquierda
lcd.print (" Fecha "); // Se escribe el texto
if (key == 0){ // Si se pulsa la tecla de la derecha

50

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 e=2; // Se cambia el valor de la variable D para mantenerse en este
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
if (key == 3){ // Si se pulsa la tecla de la izquierda
e=1; // Se cambia el valor de la variable D para pasar al siguiente
Item
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
} // Fin del IF
break; // Salimos del switch
} // Fin del SWITCH
} // Fin del Menu_5
//**************************************************************************************************

//**************************************** Menú 6 (Confirmar cambio Fecha y Hora) ******************

void Menu_6(){ // Confirmar cambio Fecha y Hora
get_time (); // Se ejecuta el bloque de Get_Time
switch(HF){ // Bloque de Fecha/Hora
case 1: // Ajuste de Hora
get_time (); // Se ejecuta el bloque de Get_Time
lcd.setCursor (4,1); // Posicionamos el texto en la 5ª posición de la 2ª fila
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
delay (50); // Se pausa 50mseg. (Evitar rebotes de pulsador)

///// Modificación de Horas y Minutos /////

if (key == 0 && P == 2){ // Si se pulsa el botón de la derecha
hours++; // Incrementamos 1 unidad las horas
delay (500); // Se pausa 500mseg. (Evitar rebotes de pulsador)
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
if (key == 3 && P == 2){ // Si pulsamos el botón de la izquierda
hours--; // Decrecemos 1 unidad las horas
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
initChrono(); // Se ejecuta el bloque de InitChrono
} // Fin del IF

if (key == 0 && P == 3){ // Si se pulsa el botón de la derecha

minutes++; // Incrementamos 1 unidad los minutos
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
initChrono(); // Se ejecuta el bloque de InitChrono
} // Fin del IF
if (key == 3 && P == 3){ // Si pulsamos el botón de la izquierda
minutes--; // Decrecemos 1 unidad los minutos
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
initChrono(); // Se ejecuta el bloque de InitChrono
} // Fin del IF
///// Confirmación de Horas y Minutos /////
if (key == 2 && P == 3){ // Confirmamos el cambio de las Horas
lcd.setCursor (4,1); // Posicionamos el texto en la 5ª posición de la 2ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (" "); // Se escribe el texto
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
lcd.setCursor (7,1); // Posicionamos el texto en la 8ª posición de la 2ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (" "); // Se escribe el texto
delay (250); // Se pausa 250mseg. para que confirme el cambio de los Huecos

51

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 lcd.clear (); // Se limpia el lcd
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)
HF = 0; // Confirmación de ajuste de Hora y Fecha
P = 0; // Variable que indica el número de pulsaciones de la tecla OK
(se pone el contador a cero)
loop (); // Se ejecuta el bloque de Loop
} // Fin del IF
break; // Salimos del switch

case 2: // Ajuste de la fecha

lcd.setCursor (3,1); // Posicionamos el texto en la 4ª posición de la 2ª fila
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
break; // Salimos del switch
case 2: // 2
lcd.print ("Feb"); // Se escribe el texto
break; // Salimos del switch
case 3: // 3
lcd.print ("Mar"); // Se escribe el texto
break; // Salimos del switch
case 4: // 4
lcd.print ("Abr"); // Se escribe el texto
break; // Salimos del switch
case 5: // 5
lcd.print ("May"); // Se escribe el texto
break; // Salimos del switch
case 6: // 6
lcd.print ("Jun"); // Se escribe el texto
break; // Salimos del switch
case 7: // 7
lcd.print ("Jul"); // Se escribe el texto
break; // Salimos del switch
case 8: // 8
lcd.print ("Ago"); // Se escribe el texto
break; // Salimos del switch
case 9: // 9
lcd.print ("Sep"); // Se escribe el texto
break; // Salimos del switch
case 10: // 10
lcd.print ("Oct"); // Se escribe el texto
break; // Salimos del switch
case 11: // 11
lcd.print ("Nov"); // Se escribe el texto
break; // Salimos del switch
case 12: // 12
lcd.print ("Dic"); // Se escribe el texto
break; // Salimos del switch
} // Fin del SWITCH
lcd.print ("/"); // Se escribe el texto
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
lcd.print (" "); // Se escribe el texto
delay (50); // Se pausa 50mseg. (Evitar rebotes de pulsador)

///// Modificación de Día, Mes y Año /////

if (key == 0 && P == 2){ // Si se pulsa el botón de la derecha
date++; // Incrementamos 1 unidad los Días
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
if (key == 3 && P == 2){ // Si pulsamos el botón de la izquierda
date--; // Decrecemos 1 unidad los Días
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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

if (key == 0 && P == 3){ // Si se pulsa el botón de la derecha

52

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 month++; // Incrementamos 1 unidad del Mes
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
if (key == 3 && P == 3){ // Si pulsamos el botón de la izquierda
month--; // Decrecemos 1 unidad del Mes
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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

if (key == 0 && P == 4){ // Si se pulsa el botón de la derecha

year++; // Incrementamos 1 unidad el Año
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
if (key == 3 && P == 4){ // Si pulsamos el botón de la izquierda
year--; // Decrecemos 1 unidad el Año
delay (250); // Se pausa 250mseg. (Evitar rebotes de pulsador)
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
lcd.setCursor (3,1); // Posicionamos el texto en la 4ª posición de la 2ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (" "); // Se escribe el texto
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
lcd.setCursor (6,1); // Posicionamos el texto en la 7ª posición de la 2ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (" "); // Se escribe el texto
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
lcd.setCursor (10,1); // Posicionamos el texto en la 11ª posición de la 2ª fila
Sonido_Confirmacion(); // Se confirma mediante sonido
lcd.print (" "); // Se escribe el texto
delay (250); // Se pausa 250mseg. para que confirme el cambio del Año
initChrono(); // Se ejecuta el bloque de InitChrono
lcd.clear (); // Se limpia el lcd
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)
HF = 0; // Confirmación de ajuste de Hora y Fecha
P = 0; // Variable que indica el número de pulsaciones de la tecla OK
(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
adc_key_in = analogRead (Boton); // Se lee el valor de la pulsación
key = get_key(adc_key_in); // Se obtiene el valor pulsado
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

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 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
} // Fin del bucle FOR
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
} // Fin del bucle FOR
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];
lcd.setCursor (0,0); // Posicionamos el texto en la 0ª posición de la 1ª fila
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
lcd.print ("/"); // Se escribe el texto
switch (month){ // Si el valor del mes es....
case 1: // 1
lcd.print ("Ene"); // Se escribe el texto
break; // Salimos del switch
case 2: // 2
lcd.print ("Feb"); // Se escribe el texto
break; // Salimos del switch
case 3: // 3
lcd.print ("Mar"); // Se escribe el texto
break; // Salimos del switch
case 4: // 4
lcd.print ("Abr"); // Se escribe el texto
break; // Salimos del switch
case 5: // 5
lcd.print ("May"); // Se escribe el texto
break; // Salimos del switch
case 6: // 6
lcd.print ("Jun"); // Se escribe el texto
break; // Salimos del switch
case 7: // 7
lcd.print ("Jul"); // Se escribe el texto
break; // Salimos del switch
case 8: // 8
lcd.print ("Ago"); // Se escribe el texto
break; // Salimos del switch
case 9: // 9
lcd.print ("Sep"); // Se escribe el texto
break; // Salimos del switch
case 10: // 10
lcd.print ("Oct"); // Se escribe el texto
break; // Salimos del switch
case 11: // 11
lcd.print ("Nov"); // Se escribe el texto
break; // Salimos del switch
case 12: // 12
lcd.print ("Dic"); // Se escribe el texto

54

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 break; // Salimos del switch
} // 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. beginTransmission (104); // Empieza transmisión.
Wire. write (3); // Set register to 3 (day)
Wire. endTransmission (); // Termina transmisión
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. beginTransmission (104); // Empieza transmisión.
Wire. write ((byte)0); // Set register to 0
Wire. write (decToBcd(seconds));
Wire. write (decToBcd(minutes));
Wire. write (decToBcd(hours));
Wire. endTransmission (); // Termina transmisión
} // Fin del set_time

void get_time () {
Wire. beginTransmission (104); // Empieza transmisión.
Wire. write ((byte)0); // Set register to 0
Wire. endTransmission (); // Termina transmisión
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
delay(50); // Se pausa 50mseg.
digitalWrite(Buzzer, LOW); // Se ponen en estado BAJO el pin del buzzer

55

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 } // 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
digitalWrite(Buzzer, HIGH); // Se ponen en estado ALTO el pin del buzzer
delay(50); // Se pausa 50mseg.
digitalWrite(Buzzer, LOW); // Se ponen en estado BAJO el pin del buzzer
delay(150); // Se pausa 150mseg.
digitalWrite(Buzzer, HIGH); // Se ponen en estado ALTO el pin del buzzer
delay(50); // Se pausa 50mseg.
digitalWrite(Buzzer, LOW); // Se ponen en estado BAJO el pin del buzzer
} // Fin del IF
} // Fin del bucle Sonido Confirmación

56

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

7 PLANOS

57

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 58

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 59

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 60

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 61

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 62

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 63

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 64

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 65

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 66

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 67

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 68

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 69

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 70

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 71

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 72

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com

 73

Descargado por Gustavo Pedraza ([email protected])

Encuentra más documentos en www.udocz.com