Paso 21: Mi programa
/*11/11/2012 Rayo McQueen
Línea LCD 1 día y hora
Lecturas temporales de la línea 2 LCD
6 botones en analógico A0
Cualquier activación de botón se enciende luz de 2 minutos posterior.
El fresco de la configuración del botón es
cualquier botón puede configurarse al botón 1, 2, 3, 4, 5 o 6.
Se utilizan sensores de temperatura LM335 y LM334Z.
Compensación de temperatura es regulable.
*/
//
//
Const int
//
const int lcd_datapin = 6; 74HC164 pin 1
const int lcd_clk = 5; 74HC164 pin 8
const int lcd_E = 4; Línea LCD E
const int lcd_RS = 3; Línea RS del LCD
const int luz = 2; / / salida de la luz trasera
//
Materia análoga
//
A0-botones
A1 - en el tablero sensor de temperatura.
A2 - interior sensor de temperatura.
A3 - fuera sensor de temperatura.
//
//
COSAS DE RELOJ
NO HAY NÚMEROS NEGATIVOS
time_begin largo sin firmar;
time_duration largo sin firmar;
time_remain largo sin firmar;
time_val largo sin firmar;
unsigned int time_seconds = 0; / / almacena el número de segundos
unsigned int time_minutes = 0; / / almacena el número de minutos. El
reloj se iniciará en el número de minutos guardadas aquí reset.
unsigned int time_hours = 12; / / almacena el número de horas. El reloj
se iniciará en el número de horas guardadas aquí de descanso.
unsigned int time_days = 0; / / almacena el número de días
Utilizado para contar a un evento determinado.
unsigned int event_seconds1 = 0; / / almacenamiento de segundos contar
//
//
Cosas de LCD
//
int lcd_C = 0; Carácter de ser cambiado de puesto
int lcd_D = 0; Carácter de ser cambiado de puesto
int lcd_N = 0; Número de caracteres a enviar a la lcd
int lcd_i = 0; Utilizado para la colocación
int lcd_set = 0; / / se utiliza para almacenar que configuración para obtener
int lcd_A = 0; / / solía elegir la aray a utilizar
int lcd_Z = 0; Utilizado en char lcd prueba
//
//
Utilizado por cracker
//
int val1000s = 0; / / registro para mantener cuenta de 1000
int val100s = 0; / / registro para la cuenta 100
int val10s = 0; / / registro para mantener el conteo de 10
int val1s = 0; / / registro de 1 cuenta
int test_test = 0; / / registro para almacenar el número de pruebas y la hora también
//
Utilizado para las lecturas de sensor
sensor flotador = 0; / / almacenamiento de información para el nivel de sensor
copia de int = 0; / / copia de lo que ponga en él y tiempo también
//
int back_lit = 0; / / luz de fondo encendido/apagado
//
//
//
COSAS DE BOTÓN
int btn_read = 0; / / lectura de la línea analógica
int btn_read2 = 0; / / la copia de la lectura
int btn_pressed = 0; / / botón fue presionado
int btn_number = 1; / / siempre comenzar con el botón #1
int btn_copy = 0; / / copia del botón para con_fig.
int bucle = 0; / / para mi los bucles
//*****************
Tienda la gama alta y baja de un valor analógico de botones
//
int btn_1hi; / / alta gama botón #1
int btn_1lo; / / botón #1 de gama baja
int btn_2hi; / / botón 2 alta gama
int btn_2lo; / / botón 2 baja gama
int btn_3hi; / / tecla #3 alta gama
int btn_3lo; / / tecla #3 gama baja
int btn_4hi; / / tecla #4 alta gama
int btn_4lo; / / tecla #4 baja gama
int btn_5hi; / / tecla #5 alta gama
int btn_5lo; / / tecla #5 baja gama
int btn_6hi; / / alta gama botón #6
int btn_6lo; / / botón #6 baja gama
//
//
int offset_sensor_1 = 257; / / Start offset en voltios 2,57 = LM334Z
int offset_sensor_2 = 273; / / Start offset en voltios 2,73
int offset_sensor_3 = 273; / / Start offset en voltios 2,73
int offset_A = 0; / / 0 no = ajustes.
1 = sensor 1 ajuste.
2 = sensor 2 ajustar.
3 = 3 sensor de ajuste.
LM335 2,73 voltios de salida en cero grados C
LM334Z aproximadamente 2.57 voltios de salida en cero grados C
//
//
ARREGLOS DE DISCOS ***
Conteo de arreglos de discos se inicia en 0 no 1 y va para arriba
//
carácter de 16-24 2 línea lcd
int aray_set_up [] = {}
56, 12, 6, 1}; Personajes de configuración LCD
//
Puntos de inicio para el LCD
int aray_lines [] = {}
132 = 5 carácter de la posición de inicio izquierdo, línea 1
196 = 5 carácter de la posición de inicio izquierdo, línea 2
128 = línea 1
192 = línea 2
128, 192, 132, 196};
//
Utiliza un espacio en blanco en el primer lugar para no mostrar la
anteriores ceros.
int aray_hunds [] = {}
' ', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
"0" en la primera ubicación con el fin de mostrar la
cualquier precceding cero
int aray_tens [] = {}
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
La primera matriz por lo que yo puedo poner el nombre en la pantalla lcd al inicio
Matriz sólo aparece al principio para arriba.
lcd_Z = qué matriz utilizar
int aray0 [] = {}
'F', 'u', 'n', ' ', 'S', 'h', 'w', 'a', 'y', ' ', 'D', 'i', 's', 'p', 'l', 'a', 'y', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
//
Sólo 4 de estos personajes son enviados pero su izquierda en el 5 sin ejecuta más
int aray1 [] = {}
' ', 'I', 'n', ' ', ' ' };
Sólo 4 de estos personajes son enviados pero su izquierda en el 5 sin ejecuta más
int aray2 [] = {}
'O', 'u', 't', ' ', ' ' };
Dejo a continuación para espacios en blanco
int aray3 [] = {}
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
No utilizados aún
int aray4 [] = {}
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
El tiempo de palabra
int aray5 [] = {}
'T', 'i', 'm', 'e', ' ' };
No utilizados aún
int aray6 [] = {}
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' , ' ', ' ', ' ', ' ', ' ', ' ' };
//
ARREGLOS DE DISCOS PARA LOS DÍAS DE LA SEMANA
//
int aray7 [] = {}
'M', 'o', 'n', ' ', ' ', ' ' };
//
int aray8 [] = {}
'T', 'u', 'e', ' ', ' ', ' ' };
//
int aray9 [] = {}
'W', 'e', 'd', ' ', ' ', ' ' };
//
int aray10 [] = {}
'T', 'h', 'u', ' ', ' ', ' ' };
//
int aray11 [] = {}
'F', 'r', 'i', ' ', ' ', ' ' };
//
int aray12 [] = {}
'S', 'a', 't', ' ', ' ', ' ' };
//
int aray13 [] = {}
'S', 'u', 'n', ' ', ' ', ' ' };
//
MATRICES PARA BOTÓN CONFIG
//
int aray14 [] = {}
'B', 'u', 't', 't', 'o', 'n', ' ', 'C', 'o', 'n', 'f', 'i', 'g', '.', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
//
int aray15 [] = {}
'P', 'r', 'e', 's', 's', ' ', ' ', ' ', ' ', ' ' };
//
int aray16 [] = {}
'R', 'e', 'l', 'e', 'a', 's', 'e', ' ', ' ', ' ' };
//
int aray17 [] = {}
' ', 'F', 'a', 'i', 'l', 'e', 'd', ' ', ' ', ' ' };
//
int aray18 [] = {}
' ', 'S', 'e', 't', ' ' };
//
//
//
void setup() {}
pinMode (lcd_datapin, salida); Definir como salida
pinMode (lcd_clk, salida); Definir como salida
pinMode (lcd_E, salida); Definir (línea E) como salida
pinMode (lcd_RS, salida); Definir (línea RS) como salida
pinMode (ligero, salida); Definir (luz trasera) como salida
//
digitalWrite (lcd_E, HIGH); / / traer la línea de control de lcd alta
digitalWrite (lcd_RS, HIGH); / / traer la línea de control de lcd alta
//
digitalWrite (light, LOW); / / enciende la luz para pantalla trasera
//
Instalación de LCD
lcd_init(); / / inicializar el lcd para el uso
//
lcd_set = 0; / / primera linea
lcd_line();
Delay(5);
Añadido para displays de líneas una pantalla ***
Sólo se muestra una vez al principio para arriba ***
//
lcd_Z = 0; / / una cadena de caracteres de la línea de LCD
lcd_N = 24; / / enviar todos los 24 caracteres
lcd_char();
//
Delay(10000); / / demora 10 segundos para que pueda ver el nombre del programa.
//
Dejar libre la línea de la LCD antes de escribir en él por lo que no queda más
lcd_set = 0; / / LCD línea uno
//
lcd_line_clear(); / / borra la línea de lcd para espacios en blanco
//
//
Configurar los botones en la línea analógica
Esto se hace una vez antes del bucle principal
//
btn_config(); / / rutina de configuración de botón.
//
digitalWrite (luz, HIGH); / / apaga la luz para pantalla trasera
event_seconds1 = 0; / / claro el evento de segundos registrarse.
back_lit = 0; / / borrar el registro de luz de fondo.
//
/////////////////
FIN DE CONFIGURAR / /
/////////////////
//
}
//
////////////////////////
INICIO PRINCIPAL LAZO / /
////////////////////////
//
//
void loop() {}
//
Debe hacerse al principio para el reloj funcionan bien.
time_begin = millis(); / / lugar en el principio
//
lcd_timeDisp(); / / Mostrar el día y hora en la línea 1
//
lcd_tempDisp(); / / Mostrar la temp en/fuera de línea 2
//
//**************************
TIEMPO MATERIAL PARA ACTUALIZAR REGISTROS
//
time_val = (time_remain + time_duration);
Si el tiempo a través de (intervalo) ha sido menos de un segundo
Mantenga la adición encima de.
Si (time_val < 1000) {}
time_remain = time_val;
}
Si el tiempo a través de (intervalo) ha sido más de un segundo
contar cuántos segundos.
Si (time_val > = 1000) {}
mientras que (time_val > = 1000) {}
time_val = time_val - 1000;
time_seconds ++;
event_seconds1 ++; / / incrementar event_seconds1 por uno
}
time_remain = time_val;
}
//
Si (time_seconds > = 60) {}
time_minutes ++; / / incrementar minutos por una
time_remain = (time_remain + 1); / / añadido por pérdida de señal de tiempo en el tiempo.
time_seconds = (time_seconds - 60);
}
Si (time_minutes > = 60) {}
time_hours ++; / / incrementar por 1
time_minutes = (time_minutes - 60);
}
Si (time_hours > = 24) {}
time_days ++; / / incrementar por 1
time_hours = (time_hours - 24);
}
Si (time_days > = 7) {}
time_days = (time_days - 7);
}
//
//
Comprobar si se presiona un botón.
No Debounce fue lastimado en la realización de este programa.
//
btn_read = analogRead(A0);
Si (btn_read > 50 & & back_lit == 0) {}
digitalWrite (light, LOW); / / enciende la luz trasera para cualquier
activación del botón. Hacer cualquier acción de botón aún.
event_seconds1 = 0; / / borrar el generador del evento de segundos.
back_lit = 1; / / la pulsación siguiente es válido para hacer algo.
Delay(2000); / / antes de buscar otro botón.
//
}
//
//
btn_read = analogRead(A0); / /
Si (btn_read > 50 & & back_lit == 1) {}
//
Lectura válida es algo grande de 50.
Una lectura válida y luz trasera = 1 para hacer las cosas de botón.
50 es mi de gama (desactivar) para botones mal.
Un botón es apretado.
button_pressed (); //Figure que se
}
Compruebe para ver si se suelta un botón.
btn_read = analogRead(A0); / /
Si (btn_read == 0 & & back_lit == 1) {}
Se suelta el botón.
button_released(); / / averiguar que uno
}
//
Temporizador para apagar la luz trasera
Si (event_seconds1 > = 120) {}
digitalWrite (luz, HIGH); / / apaga la luz trasera.
back_lit = 0; / / Borrar registro para LCD luz de fondo.
offset_A = 0; / / Borrar registro para compensar temps.
}
//
//
Delay(100); / / para la estabilidad
//
//************************************
ESTO VA EN EL EXTREMO DE LA CAÑERÍA DE
Error corrige cuando rollos de millis
Simplemente establece dos lecturas a 0 y vuelve a.
Si (millis() < time_begin) {}
time_duration = 0; / / colocar al final
time_begin = 0; / / lugar en final
}
//
Si (millis() > time_begin) {}
time_duration = (millis() - time_begin) ;// lugar al final
}
//
/////////////////////////
FIN DE BUCLE PRINCIPAL / /
/////////////////////////
//
}
//
//
//
//
//
//*********************
RUTINAS DE INICIO **
//*********************
//
//
/////////////////////
RUTINAS DE LCD / /
/////////////////////
//
//
Rutina para inicializar el lcd.
//
void lcd_init() {}
digitalWrite (lcd_E, LOW); / / borrar la línea E
digitalWrite (lcd_RS, LOW); / / borrar línea RS
delayMicroseconds(125); / / retraso más largo entonces necesario pero funciona
para (int lcd_i = 0; lcd_i < 4; lcd_i ++) {}
//
lcd_C = (aray_set_up[lcd_set]);
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_C);
E_line();
lcd_set = lcd_set + 1;
}
Delay(5);
}
//
//**********
Rutina para elegir que información de la línea debe ser exhibido en.
lcd_set = 0 para la línea uno.
lcd_set = 1 para la línea dos.
lcd_set debe establecerse antes de llegar aquí.
//
void lcd_line() {}
lcd_C = (aray_lines[lcd_set]); aray_lines [lcd_set] si lcd_set = 0 = línea uno
aray_lines [lcd_set] si lcd_set = 1 = línea dos.
digitalWrite (lcd_E, LOW); Línea E inferior
digitalWrite (lcd_RS, LOW); Línea inferior de RS
delayMicroseconds(125); Pequeña demora
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_C);
E_line();
digitalWrite (lcd_RS, HIGH);
delayMicroseconds(125);
}
//
//**********
Rutina para enviar caracteres a la pantalla.
lcd_N debe ser cargado con el número de caracteres a enviar
antes de llegar aquí.
//
void lcd_char() {}
lcd_D = 0;
//
Ajustar lcd_N para el número de caracteres a enviar
para (lcd_i = 0; lcd_i < lcd_N; lcd_i ++) {}
//
interruptor (lcd_Z) {}
caso 0: / / 1 º char string Fun_Shway_Display
lcd_A = (aray0[lcd_D]);
rotura;
caso 1: / 2 char cadena _In_
lcd_A = (aray1[lcd_D]);
rotura;
caso 2: / 3 char cadena Out_
lcd_A = (aray2[lcd_D]);
rotura;
caso 3: / 4 cadena char utiliza cortes de
lcd_A = (aray3[lcd_D]);
rotura;
caso 4: / / 5 cadena char no utilizado todavía. espacios en blanco.
lcd_A = (aray4[lcd_D]);
rotura;
caso 5: / / char 6 cuerdas Time_
lcd_A = (aray5[lcd_D]);
rotura;
caso 6: / / 7 string char no utilizado todavía. Espacios en blanco.
lcd_A = (aray6[lcd_D]);
rotura;
caso 7: / / 8 char cadena. Mon_
lcd_A = (aray7[lcd_D]);
rotura;
caso 8: / / 9 de char a string. Tue_
lcd_A = (aray8[lcd_D]);
rotura;
caso 9: / / 10 char cadena. Wed_
lcd_A = (aray9[lcd_D]);
rotura;
caso 10: / / 11 char cadena. Thu_
lcd_A = (aray10[lcd_D]);
rotura;
caso 11: / / 12 de char a string. Vie_
lcd_A = (aray11[lcd_D]);
rotura;
caso 12: / / 13 de char a string. Sat_
lcd_A = (aray12[lcd_D]);
rotura;
caso 13: / / 14 de char a string. Sun_
lcd_A = (aray13[lcd_D]);
rotura;
caso 14: / / 15 de char a string. Button_Config. _
lcd_A = (aray14[lcd_D]);
rotura;
caso 15: / / 16 char cadena. Press_
lcd_A = (aray15[lcd_D]);
rotura;
caso 16: / / 17 char cadena. Release_
lcd_A = (aray16[lcd_D]);
rotura;
caso 17: / / 18 de char a string. _Failed_
lcd_A = (aray17[lcd_D]);
rotura;
caso 18: / / 19 char cadena. _Set_
lcd_A = (aray18[lcd_D]);
rotura;
}
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_A);
E_line();
lcd_D = lcd_D + 1;
}
}
//
//**********
La rutina es para la prueba de registro.
lcd_A debe establecerse en qué enviar antes de llegar aquí
lcd_A puede = val1000s o val100s
thous_out los resultados en un if en blanco el primer número = 0
//
void thous_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, aray_hunds[lcd_A]);
E_line();
//
}
//
//**********
La rutina es para la prueba de registro.
lcd_A debe establecerse antes de llegar aquí.
lcd_A puede = val10s o val1s
tens_out resultados adentro un cero si el primer número = 0
//
void tens_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, aray_tens[lcd_A]);
E_line();
//
}
//
//**********
Rutina para el envío de caracteres individuales para la pantalla lcd
ejemplo ":" utiliza en la separación de horas a minutos
//
void car_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_A); Esto se establece en
E_line();
//
}
//
//**********
Rutina para hacer la línea E de la pantalla lcd
//
void E_line() {}
digitalWrite (lcd_E, HIGH);
delayMicroseconds(1);
digitalWrite (lcd_E, LOW);
delayMicroseconds(125);
}
//
//**********
Rutina para enviar los espacios en blanco a la pantalla lcd.
lcd_set debe establecerse antes de llegar aquí.
lcd_set = 0; //lcd línea uno
lcd_set = 1; //lcd línea dos
//
void lcd_line_clear() {}
Dejar libre la línea de la lcd antes de escribir en él
lcd_line();
Delay(5);
//
lcd_Z = 3; / / cadena de caracteres de espacios
lcd_N = 24; / / enviar todos los 24 caracteres
lcd_char();
Delay(5);
//
}
//
//**********
Rutina para mostrar la hora en la pantalla LCD.
Tiempo se muestra en la primera línea.
//
void lcd_timeDisp() {}
//
lcd_set = 0; / / LCD línea uno
lcd_line();
Delay(5);
//
lcd_Z = (time_days + 7); / / cadena para el día de la semana
Más 7 es para saltar sobre las cadenas de caracteres de días no
lcd_N = 4; / / enviar 4 caracteres = día más espacio
lcd_char();
//
test_test = time_hours; / / hacer una copia para pruebas
Cracker(); / / salir horas
//
lcd_A = val10s; / / ahora tiene los 10s en la hora
thous_out(); / / enviar a un espacio en blanco si no hay decenas
//
lcd_A = val1s; / / ahora tiene los 1s en la hora
tens_out(); / / enviar el número de 1s en hora
//
//
lcd_A = ':'; / /
car_out(); / / enviar un caracter individual
//
//
test_test = time_minutes; / / hacer una copia para pruebas
Cracker(); / / salir minutos.
//
lcd_A = val10s; / / ahora tiene los 10s en el Acta.
tens_out(); / / enviar el número de 10s en el Acta.
//
lcd_A = val1s; / / ahora tiene el 1s en el Acta.
tens_out(); / / enviar el número de 1s en el Acta.
//
lcd_A = ' '; / / Añadir un espacio
car_out(); / / enviar un caracter individual.
//
test_test = offset_A; / / hacer una copia de prueba.
Cracker(); Salir registro.
//
lcd_A = val1s; / / ahora tiene el sensor # siendo ajustados.
thous_out(); / / enviar a un espacio en blanco si no hay ningún sensor se ajusta.
//
}
//
//**********
Rutina para mostrar a la temperatura en la pantalla LCD.
Temperatura se muestra en la segunda línea.
//
void lcd_tempDisp() {}
//
//
lcd_set = 1; //LCD línea dos
lcd_line();
Delay(5);
//
lcd_Z = 1; / / dentro de cadena de caracteres
lcd_N = 4; / / Enviar sólo 4 caracteres
lcd_char();
Delay(5);
//
Obtener el valor de dentro de sensor de temperatura en la línea analógica 2
sensor = analogRead(A2); / /
Yo estoy viendo en grados F
Esto se parece con ninguna compensación
sensor = (((sensor * (5.0/1023.0)) * 100) - 273) * 1.8) + 32);
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_2) * 1.8) + 32);
//
test_test = sensor; / / no le interesa los números después de decimal.
//
Cracker se utiliza después de cualquier lectura sobre cualquier línea de analoge
que la lectura por lo que puede visualizarse en la pantalla LCD
Cracker(); / / convertir la lectura
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
lcd_A = ' '; / / da un espacio
car_out(); / / envía cada carácter en lugar de una cadena
//
lcd_Z = 2; / / fuera de cadena de caracteres
lcd_N = 4; / / Enviar sólo 4 caracteres
lcd_char();
Delay(5);
//
Obtener el valor del sensor de temperatura exterior en la línea analógica 3
sensor = analogRead(A3);
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_3) * 1.8) + 32);
//
test_test = sensor; / / no le interesa los números después de decimal.
//
Cracker se utiliza después de cualquier lectura sobre cualquier línea de analoge
para hacer la lectura por lo que puede visualizarse en la pantalla LCD.
Cracker(); / / convertir la lectura
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
lcd_A = ' ';
car_out();
//
lcd_A = ' ';
car_out();
//
lcd_A = ' ';
car_out();
//
lcd_A = ' ';
car_out();
//
lcd_A = ' ';
car_out();
//
Obtener el valor de a bordo el sensor de temperatura analógico línea 1
sensor = analogRead(A1); / / obtener el valor de la línea analógica 1
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_1) * 1.8) + 32);
//
test_test = sensor; / / no le interesa los números después de decimal.
//
Cracker se utiliza después de cualquier lectura sobre cualquier línea analógica
que la lectura por lo que puede visualizarse en la pantalla LCD
Cracker(); / / convertir la lectura.
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
//
}
//
////////////////
CRACKER / /
////////////////
//
//**********
Rutina rompe números en algo que se puede mostrar
en la pantalla lcd.
test_test debe tener una copia de lo que para antes de llegar aquí.
//
void cracker() {}
//
Prueba 1000s
val1000s = 0; / / 1000 claro registro
mientras que (test_test > = 1000) {}
test_test = test_test - 1000;
val1000s ++;
}
Prueba 100s
val100s = 0; / / Borrar registro 100
mientras que (test_test > = 100) {}
test_test = test_test - 100;
val100s ++;
}
Prueba de 10s
val10s = 0; / / claro 10 registro
mientras que (test_test > = 10) {}
test_test = test_test - 10;
val10s ++;
}
Resto es el 1
val1s = test_test;
//
La prueba final
El número almacenado en test_test ahora es ser roto
a registro de cuatro
val1000s = el número de miles de personas en el número de prueba
val100s = el número de centenas en el número de prueba
val10s = el número de decenas del número de prueba
val1s = resto, el número de unos en el número
//
}
//
//
///////////////////////////////
BOTONES DE LÍNEA ANALÓGICA / /
///////////////////////////////
//
//**********
Rutina para el botón 1 cosas.
//
void btn_1() {}
time_days = (time_days + 1);
Delay(100);
}
//
//**********
Rutina para el botón 2 cosas.
//
void btn_2() {}
time_hours = (time_hours + 1);
Delay(100);
}
//
//**********
Rutina para el botón 3 cosas.
//
void btn_3() {}
time_minutes = (time_minutes + 1);
Delay(100);
}
//
//**********
Rutina para el botón 4 cosas.
//
void btn_4() {}
interruptor (offset_A) {}
caso 0: / / desplazamiento fue 0
offset_A = 1; / / hacer sensor 1
rotura;
caso 1: / / Offset 1
offset_A = 2; / / se que sensor 2
rotura;
caso 2: / / Offset 2
offset_A = 3; / / se que sensor 3
rotura;
caso 3: / / Offset fue 3
offset_A = 0; / / que sea 0 no = ningún ajuste del sensor.
rotura;
}
}
//
//**********
Rutina para el botón 5 cosas.
Aumento compensaciones de sensor.
void btn_5() {}
//
Si (offset_A == 1) {}
offset_sensor_1 ++; / / incrementar el ajuste para el sensor 1
}
//
Si (offset_A == 2) {}
offset_sensor_2 ++; / / incrementar el ajuste para el sensor 2
}
//
Si (offset_A == 3) {}
offset_sensor_3 ++; / / incrementar el desplazamiento de sensor 3
}
//
}
//
//**********
Rutina para el botón 6 cosas.
Disminución de desplazamientos del sensor.
void btn_6() {}
//
Si (offset_A == 1) {}
offset_sensor_1--; / / disminución el ajuste para el sensor 1
}
//
Si (offset_A == 2) {}
offset_sensor_2--; / / disminución el ajuste para el sensor 2
}
//
Si (offset_A == 3) {}
offset_sensor_3--; / / disminuir el desplazamiento de sensor 3
}
//
}
//
//
////////////////////////
Botón / /
////////////////////////
//
//**********
Rutina para cuando se pulsa un botón.
El botón no se cuenta hasta que suelte.
//
void button_pressed() {}
//
btn_read2 = (btn_read) ;// haga una copia de la lectura para la prueba
//
Si los valores de botón son entre ciertos niveles
es igual a su botón.
Botón de valores adquiridos de btn_config
//
Si (btn_read > = btn_1lo & & btn_read2 < = btn_1hi) {}
btn_pressed = 1; / / 1 registro = botón 1
}
//
Si (btn_read > = btn_2lo & & btn_read2 < = btn_2hi) {}
btn_pressed = 2; / / 2 en registro = botón 2
}
//
Si (btn_read > = btn_3lo & & btn_read2 < = btn_3hi) {}
btn_pressed = 3; / / 3 registro = botón 3
}
//
Si (btn_read > = btn_4lo & & btn_read2 < = btn_4hi) {}
btn_pressed = 4; / / 4 registro = botón 4.
}
//
Si (btn_read > = btn_5lo & & btn_read2 < = btn_5hi) {}
btn_pressed = 5; / / 5 registro = botón 5.
}
//
Si (btn_read > = btn_6lo & & btn_read2 < = btn_6hi) {}
btn_pressed = 6; / / 6 de registro = botón 6.
}
//
}
//
//
/////////////////////////
Botón liberado / /
/////////////////////////
//
//**********
Rutina para cuando se suelta un botón.
Esto es cuando se realiza el evento de botón
//
void button_released() {}
Esto cuenta como una prensa del botón una vez despejada.
Si (btn_read == 0 & & btn_pressed == 1) {}
btn_pressed = 0; / / borrar el registro
btn_1(); / / Do el botón 1 cosas.
}
//
Esto cuenta como una prensa del botón una vez despejada.
Si (btn_read == 0 & & btn_pressed == 2) {}
btn_pressed = 0; / / borrar el registro
btn_2(); / / Do el botón 2 cosas.
}
//
Esto cuenta como una prensa del botón una vez despejada.
Si (btn_read == 0 & & btn_pressed == 3) {}
btn_pressed = 0; / / borrar el registro
btn_3(); / / Do el botón 3 cosas.
}
//
Esto cuenta como una prensa del botón una vez despejada.
Si (btn_read == 0 & & btn_pressed == 4) {}
btn_pressed = 0; / / borrar el registro
btn_4(); / / Do el botón 4 cosas.
}
//
Esto cuenta como una prensa del botón una vez despejada.
Si (btn_read == 0 & & btn_pressed == 5) {}
btn_pressed = 0; / / borrar el registro
btn_5(); / / Do el botón 5 cosas.
}
//
Esto cuenta como una prensa del botón una vez despejada.
Si (btn_read == 0 & & btn_pressed == 6) {}
btn_pressed = 0; / / borrar el registro
btn_6(); / / Do el botón 6 cosas.
}
//
}
//
//
/////////////////////////////////
BOTÓN CONFIGURAR RUTINA / /
/////////////////////////////////
//
//**********
Rutina para obtener los valores y hacer una gama para los botones.
Rutina se ejecuta una vez antes del bucle principal.
Botones de línea analógica 0
Botones pueden usarse en cualquier orden.
//
void btn_config() {}
Configurar los botones en la línea analógica A0
//
lcd_set = 1; / / LCD línea dos
lcd_line_clear; / / borrar la línea de la pantalla lcd
//
lcd_set = 0; / / LCD línea uno
lcd_line_clear(); / / borrar la línea de la pantalla lcd
lcd_set = 0; / / ya no hecho necesidad de repetir
lcd_line(); / / escribir en la línea de lcd
Delay(5);
Mostrar botón de configuración en línea uno
lcd_Z = 14; / botón configuración
lcd_N = 24; / / enviar todos los 24 caracteres
lcd_char();
Delay(10000); / / darle tiempo a leer
//
//
6 botones = 6 lazos alrededor.
//
para (bucle = 0; bucle < 6; bucle ++) {}
btn_btn(); / / prueba de botones
btn_number ++; / / incrementar el botón de prueba de 1.
}
//
btn_number == 1; / / Set volver a 1 cuando haya terminado.
//
}
//
////////////////
btn_btn / /
////////////////
//
//**********
Rutina para decirle qué botón pulsar
//
void btn_btn() {}
Prueba de botones
lcd_set = 0; / / LCD línea uno
lcd_line();
Delay(5);
//
lcd_Z = 15; / /
lcd_N = 6; / / enviar 6 caracteres = Press_
lcd_char();
lcd_Z = 14; / /
lcd_N = 7; / / enviar 7 caracteres = Button_
lcd_char();
//
lcd_A = btn_number; / / inicia el botón 1
tens_out(); / / enviar los dígitos
//
Delay(5000); / / darle tiempo a leer
//
btn_read = analogRead(A0); / / botones analógicos 0
//
lcd_set = 0; / / LCD línea uno
lcd_line();
Delay(5);
//
lcd_Z = 16; / botón configuración
lcd_N = 8; / / enviar 8 caracteres = Release_
lcd_char();
lcd_Z = 14; / botón configuración
lcd_N = 7; / / enviar 7 caracteres = Button_
lcd_char();
lcd_A = btn_number; / / inicia el botón 1
tens_out(); / / enviar los dígitos
//
Delay(5000); / / darle tiempo a leer.
//
lcd_set = 0; / / línea uno
lcd_line_clear(); / / borrar la línea de lcd
//
Probar los resultados
Botón estaba bueno ir aquí
Si (btn_read > 0) {}
btn_copy = btn_number; / / hacer una copia. Fue buena
btn_con_fig();
Hacer las cosas si fue una buena lectura
//
lcd_line(); / / ya establecido para la línea 1
Delay(5);
//
lcd_Z = 14; / botón configuración
lcd_N = 7; / / enviar 7 caracteres = Button_
lcd_char();
lcd_A = btn_number; / / inicia el botón 1
tens_out(); / / enviar los dígitos
lcd_Z = 18; / / cadena para "Set"
lcd_N = 4; / / enviar 4 caracteres = _Establecer
lcd_char(); / / enviar
//
//
}
//
//
Probar los resultados
Botón no pudo ir aquí
Si (btn_read < = 50) {}
btn_copy = (btn_number + 6); / / el botón trabajando en + 6
saltar sobre las lecturas buenas y los malos
btn_con_fig();
Hacer las cosas si fue una mala lectura
//
lcd_line(); / / ya establecido para la línea 1
Delay(5);
//
lcd_Z = 14; / / cadena para Button_
lcd_N = 7; / / enviar 7 caracteres = Button_
lcd_char();
lcd_A = btn_number; / / inicia el botón 1
tens_out(); / / enviar los dígitos
lcd_Z = 17; / /
lcd_N = 7; / / enviar 7 caracteres = _Failed
lcd_char();
//
}
btn_read = 0; / / borrar la lectura analógica
Delay(5000); / /
//
lcd_set = 0; / / línea uno
lcd_line_clear(); / / borrar la línea de lcd
//
}
//
////////////////////
btn_con_fig / /
////////////////////
//
//**********
Rutina que establece los rangos de botón para ver.
//
void btn_con_fig() {}
//
Número 1-6 son para la buena lectura
Números 7-12 son de mala lectura
//
interruptor (btn_copy) {}
caso 0: / / No número debe ser cero. error
break; / / retroceso de aquí
//
caso 1: / / botón número 1 fue buena
btn_1hi = (btn_read + 2); / / realizar los ajustes adecuados
btn_1lo = (btn_read - 2); / / realizar los ajustes adecuados
rotura;
//
caso 2: / / botón número 2 fue buena
btn_2hi = (btn_read + 2); / / realizar los ajustes adecuados
btn_2lo = (btn_read - 2); / / realizar los ajustes adecuados
rotura;
//
caso 3: / / botón número 3 fue buena
btn_3hi = (btn_read + 2); / / realizar los ajustes adecuados
btn_3lo = (btn_read - 2); / / realizar los ajustes adecuados
rotura;
//
caso 4: / / botón número 4 fue buena
btn_4hi = (btn_read + 2); / / realizar los ajustes adecuados
btn_4lo = (btn_read - 2); / / realizar los ajustes adecuados
rotura;
//
caso 5: / / botón número 5 fue buena
btn_5hi = (btn_read + 2); / / realizar los ajustes adecuados
btn_5lo = (btn_read - 2); / / realizar los ajustes adecuados
rotura;
//
caso 6: / / tecla número 6 fue buena
btn_6hi = (btn_read + 2); / / realizar los ajustes adecuados
btn_6lo = (btn_read - 2); / / realizar los ajustes adecuados
rotura;
//
////////////////////
Botones mal / /
////////////////////
//
caso 7: / / botón número 1 fue malo
btn_1hi = 100; / / false carga números para botones no
btn_1lo = 100; / / actuar erróneamente
rotura;
//
caso 8: / / botón número 2 fue mala
btn_2hi = 100; / / false carga números para botones no
btn_2lo = 100; / / actuar erróneamente
rotura;
//
caso 9: / / botón número 3 fue mala
btn_3hi = 100; / / false carga números para botones no
btn_3lo = 100; / / actuar erróneamente
rotura;
//
caso 10: / / botón número 4 era mala
btn_4hi = 100; / / false carga números para botones no
btn_4lo = 100; / / actuar erróneamente
rotura;
//
caso 11: / / botón número 5 era malo
btn_5hi = 100; / / false carga números para botones no
btn_5lo = 100; / / actuar erróneamente
rotura;
//
caso 12: / / tecla número 6 fue mala
btn_6hi = 100; / / false carga números para botones no
btn_6lo = 100; / / actuar erróneamente
rotura;
//
}
}
//
//
//
//
