Etape 21 : Mon programme
/*11/11/2012 Ray McQueen
Ligne de LCD 1 jour et l’heure
LCD 2 temporaires lectures en ligne
6 boutons sur analogique A0
Toute activation de la touche s’allume contre-jour pendant 2 minutes.
La partie cool sur le bouton config est celle
n’importe quel bouton peut être défini sur la touche 1, 2, 3, 4, 5 ou 6.
Les capteurs de température LM335 et LM334Z sont utilisés.
Écart de température est réglable.
*/
//
//
Const int
//
const int lcd_datapin = 6 ; 74HC164 broche 1
const int lcd_clk = 5 ; 74HC164 Broche 8
const int lcd_E = 4 ; Ligne E de LCD
const int lcd_RS = 3 ; Écran LCD RS line
const int lumière = 2; / / sortie du rétro éclairage
//
Commandes analogiques
//
A0-boutons
A1 - le Conseil capteur de température.
A2 - à l’intérieur de capteur de température.
A3 - à l’extérieur du capteur de température.
//
//
TRUCS DE L’HORLOGE
AUCUN DES NOMBRES NÉGATIFS
unsigned long time_begin ;
unsigned long time_duration ;
unsigned long time_remain ;
unsigned long time_val ;
unsigned int time_seconds = 0; / / stocke le nombre de secondes
unsigned int time_minutes = 0; / / stocke le nombre de minutes. Le
horloge commencera par le nombre de minutes stockés ici sur reset.
unsigned int time_hours = 12; / / stocke le nombre d’heures. L’horloge
va commencer au nombre d’heures reste stockée ici.
unsigned int time_days = 0; / / stocke le nombre de jours
Utilisé pour le comptage vers le haut à un événement de jeu.
unsigned int event_seconds1 = 0; / / stockage de secondes count
//
//
Trucs de LCD
//
int lcd_C = 0 ; Personnage à déplacer
int lcd_D = 0 ; Personnage à déplacer
int lcd_N = 0 ; Nombre de caractères à envoyer à l’écran lcd
int lcd_i = 0 ; Utilisé pour une boucle
int lcd_set = 0; / / permettant de mémoriser quelle configuration pour obtenir
int lcd_A = 0; / / permet de choisir le maton à utiliser
int lcd_Z = 0 ; Utilisé en char lcd stable
//
//
Utilisés par le cracker
//
int val1000s = 0; / / s’inscrire pour tenir compte de 1000
int val100s = 0; / / s’inscrire pour contenir le nombre 100
int val10s = 0; / / s’inscrire pour tenir comte 10
int val1s = 0; / / s’inscrire à 1 chef
int test_test = 0; / / s’inscrire pour stocker le nombre de tests/heure aussi
//
Utilisé pour la lecture de la sonde
capteur de flotteur = 0; / / stockage de niveau capteur
copie int = 0; / / copie de tout ce que j’ai mis dedans / temps aussi
//
int back_lit = 0; / / rétro-éclairage marche/arrêt
//
//
//
TRUCS DE BOUTON
int btn_read = 0; / / lecture de la ligne analogique
int btn_read2 = 0; / / copier de la lecture
int btn_pressed = 0; / / bouton a été activé
int btn_number = 1; / / Allways commencent par la touche #1
int btn_copy = 0; / / copier du bouton pour con_fig.
une boucle int = 0; / / pour mes boucles
//*****************
Magasin la gamme haute et basse d’une valeur analogique de boutons
//
int btn_1hi; / / bouton #1 haute gamme
int btn_1lo; / / bouton #1 basse gamme
int btn_2hi; / / bouton #2 haute gamme
int btn_2lo; / / bouton #2 basse gamme
int btn_3hi; / / bouton #3 haut de gamme
int btn_3lo; / / bouton #3 bas de gamme
int btn_4hi; / / bouton #4 haut de gamme
int btn_4lo; / / bouton #4 basse gamme
int btn_5hi; / / bouton #5 haut de gamme
int btn_5lo; / / bouton #5 bas de gamme
int btn_6hi; / / haut de gamme touche #6
int btn_6lo; / / bouton #6 basse gamme
//
//
int offset_sensor_1 = 257; / / Start offset à 2,57 volts = LM334Z
int offset_sensor_2 = 273; / / Start offset à 2,73 volts
int offset_sensor_3 = 273; / / Start offset à 2,73 volts
int offset_A = 0; / / 0 ne = aucun réglage.
1 = 1 capteur ajuster.
2 = capteur 2 ajuster.
3 = capteur 3 ajuster.
LM335 2,73 volts sortie à zéro degrés C
LM334Z environ 2,57 volts sortie à zéro degrés C
//
//
LES TABLEAUX ***
Les tableaux compteur démarre à 0 pas 1 et va vers le haut
//
16-24 caractères 2 line lcd
int aray_set_up [] = {}
56, 12, 6, 1} ; Personnages de configuration LCD
//
Lieux de départ pour l’écran LCD
int aray_lines [] = {}
132 = 5 caractères de la position de départ gauche, ligne 1
196 = 5 caractères de la position de départ gauche, ligne 2
128 = ligne 1
192 = ligne 2
128, 192, 132, 196} ;
//
Utilise un cache dans le premier emplacement de manière à ne pas afficher
précédant zéros.
int aray_hunds [] = {}
' ', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
« 0 » dans le premier lieu afin d’afficher
tout précédant zéro
int aray_tens [] = {}
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
Le premier tableau, si je peux mettre le nom sur l’écran lcd au début vers le haut
Tableau ne s’affiche au début vers le haut.
lcd_Z = quel tableau utiliser
int aray0 [] = {}
'F', 'u', 'n', ' ', 'S', 'h', 'w', 'a', 'y', ' ', 'D', 'i', 's', 'p', 'l', 'a', 'y', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
//
Seulement 4 de ces caractères sont envoyés, mais sa gauche à 5 donc pas exécuter plus
int aray1 [] = {}
' ', 'I', 'n', ' ', ' ' };
Seulement 4 de ces caractères sont envoyés, mais sa gauche à 5 donc pas exécuter plus
int aray2 [] = {}
'O', 'u', 't', ' ', ' ' };
Laisser ci-dessous pour flans
int aray3 [] = {}
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
Pas encore utilisé
int aray4 [] = {}
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
Le temps de parole
int aray5 [] = {}
'T', 'i', 'm', 'e', ' ' };
Pas encore utilisé
int aray6 [] = {}
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' , ' ', ' ', ' ', ' ', ' ', ' ' };
//
TABLEAUX POUR LES JOURS DE LA SEMAINE
//
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', ' ', ' ', ' ' };
//
TABLEAUX POUR BOUTON 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, sortie) ; Définir comme sortie
pinMode (lcd_clk, sortie) ; Définir comme sortie
pinMode (lcd_E, sortie) ; Qualifier de sortie (ligne E)
pinMode (lcd_RS, sortie) ; Définir (RS line) en sortie
pinMode (lumière, sortie) ; Qualifier de sortie (rétro-éclairage)
//
digitalWrite (lcd_E, HIGH); / / Bring de ligne de commande lcd haute
digitalWrite (lcd_RS, HIGH); / / Bring de ligne de commande lcd haute
//
digitalWrite (lumière, LOW); / / tourner sur le dos léger pour l’affichage
//
Configuration de l’écran LCD
lcd_init(); / / Initialise l’écran lcd pour une utilisation
//
lcd_set = 0; / / la première ligne
lcd_line() ;
Delay(5) ;
Ajouté pour ligne un écrans de démarrage écran ***
Elle affiche uniquement cette fois au départ place ***
//
lcd_Z = 0; / / LCD line une chaîne de caractères
lcd_N = 24; / / envoyer tous les 24 caractères
lcd_char() ;
//
Delay(10000); / / retard de 10 secondes donc je peux voir le nom du programme.
//
Effacer la ligne de l’écran LCD avant d’écrire sur elle, donc il n’y a pas de gauche sur
lcd_set = 0; / / LCD line un
//
lcd_line_clear(); / / efface la ligne lcd en espaces
//
//
Configurer les boutons sur la ligne analogique
Cela se fait une fois avant la boucle principale
//
btn_config(); / / bouton la routine de configuration.
//
digitalWrite (lumière, HIGH); / / arrête le dos léger pour l’affichage
event_seconds1 = 0; / / claire enregistrer l’événement secondes.
back_lit = 0; / / efface le registre rétro-éclairage.
//
/////////////////
FIN DE LA MISE EN PLACE / /
/////////////////
//
}
//
////////////////////////
BOUCLE PRINCIPALE BEGIN / /
////////////////////////
//
//
void loop() {}
//
Doit être fait au début de l’horloge pour travailler à droite.
time_begin = millis(); / / placer au tout début
//
lcd_timeDisp(); / / affiche le jour et l’heure sur la ligne 1
//
lcd_tempDisp(); / / affichage de la température in/out sur la ligne 2
//
//**************************
DU TEMPS TRUCS AUX REGISTRES DE LA MISE À JOUR
//
time_val = (time_remain + time_duration) ;
Si le temps à travers (intervalle) a été moins d’une seconde
Continuez à ajouter il vers le haut.
Si {(time_val < 1000)
time_remain = time_val ;
}
Si le temps à travers (intervalle) a été plus d’une seconde
compter le nombre de secondes.
Si (time_val > = 1000) {}
tandis que (time_val > = 1000) {}
time_val = time_val - 1000 ;
time_seconds ++ ;
event_seconds1 ++; / / augmenter event_seconds1 d’un
}
time_remain = time_val ;
}
//
Si (time_seconds > = 60) {}
time_minutes ++; / / augmenter les minutes d’un
time_remain = (time_remain + 1); / / ajout de perte de temps tique au fil du temps.
time_seconds = (time_seconds - 60) ;
}
Si (time_minutes > = 60) {}
time_hours ++; / / augmentent de 1
time_minutes = (time_minutes - 60) ;
}
Si (time_hours > = 24) {}
time_days ++; / / augmentent de 1
time_hours = (time_hours - 24) ;
}
Si (time_days > = 7) {}
time_days = (time_days - 7) ;
}
//
//
Vérifier si une touche est pressée.
Aucun Debounce n’a nui à la réalisation de ce programme.
//
btn_read = analogRead(A0) ;
Si (btn_read > 50 & & back_lit == 0) {}
digitalWrite (lumière, LOW); / / allumer le contre-jour pour tout
activation du bouton. Ne pas encore faire toute action de bouton.
event_seconds1 = 0; / / efface le générateur d’événement secondes.
back_lit = 1; / / la presse bouton suivante est valable de faire quelque chose.
Delay(2000); / / avant à la recherche d’un autre bouton pressé.
//
}
//
//
btn_read = analogRead(A0); / /
Si (btn_read > 50 & & back_lit == 1) {}
//
Lecture valide est quelque chose de grand à 50.
Une lecture valide et le rétro-éclairage = 1 pour faire les trucs de bouton.
50 est mon sort d’une gamme (disable) pour mauvais boutons.
Un bouton est enfoncé.
button_pressed (); //Figure sur laquelle on
}
Vérifier si un bouton est relâché.
btn_read = analogRead(A0); / /
Si (btn_read == 0 & & back_lit == 1) {}
Bouton a été relâché.
button_released(); / / comprendre que l'on
}
//
Minuterie pour éteindre le rétro-éclairage
Si (event_seconds1 > = 120) {}
digitalWrite (lumière, HIGH); / / désactiver le rétro-éclairage.
back_lit = 0; / / efface le registre pour écran LCD rétro-éclairage.
offset_A = 0; / / cle Registre pour compenser le temps.
}
//
//
Delay(100); / / pour la stabilité
//
//************************************
CELA VA À LA FIN DE LA BOUCLE PRINCIPALE
Erreur corrige quand millis roule
Simplement, définit les deux lectures à 0 et recommence.
Si (millis() < time_begin) {}
time_duration = 0; / / Place à la fin
time_begin = 0; / / Place à toute fin
}
//
Si (millis() > time_begin) {}
time_duration = (millis() - time_begin);// Place à la fin
}
//
/////////////////////////
FIN DE LA BOUCLE PRINCIPALE / /
/////////////////////////
//
}
//
//
//
//
//
//*********************
BEGIN ROUTINES **
//*********************
//
//
/////////////////////
ROUTINES DE LCD / /
/////////////////////
//
//
Routine d’initialisation de l’écran lcd.
//
lcd_init() Sub {}
digitalWrite (lcd_E, LOW); / / efface la ligne E
digitalWrite (lcd_RS, LOW); / / efface la ligne RS
delayMicroseconds(125); / / plus long délai nécessaire puis mais fonctionne
pour (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) ;
}
//
//**********
Routine de choisir quelle ligne info doit être affichée sur.
lcd_set = 0 pour la ligne.
lcd_set = 1 pour la ligne 2.
lcd_set doit être définie avant d’arriver ici.
//
void lcd_line() {}
lcd_C = (aray_lines[lcd_set]) ; aray_lines [lcd_set] si lcd_set = 0 = ligne
aray_lines [lcd_set] si lcd_set = 1 = ligne deux.
digitalWrite (lcd_E, basse) ; Ligne E inférieure
digitalWrite (lcd_RS, basse) ; Ligne inférieure du RS
delayMicroseconds(125) ; Petit retard
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_C) ;
E_line() ;
digitalWrite (lcd_RS, HIGH) ;
delayMicroseconds(125) ;
}
//
//**********
Routine d’envoyer des chaînes de caractères à l’écran.
lcd_N doit être chargé avec le nombre de caractères à envoyer
avant d’arriver ici.
//
void lcd_char() {}
lcd_D = 0 ;
//
Ajuster les lcd_N pour le nombre de caractères à envoyer
pour (lcd_i = 0; lcd_i < lcd_N ; lcd_i ++) {}
//
Switch (lcd_Z) {}
case 0: / / 1er char string Fun_Shway_Display
lcd_A = (aray0[lcd_D]) ;
rupture ;
cas 1: / / 2e char string _In_
lcd_A = (aray1[lcd_D]) ;
rupture ;
case 2: / / 3ème char string Out_
lcd_A = (aray2[lcd_D]) ;
rupture ;
case 3: / / 4ème chaîne de char utilisé pour flans
lcd_A = (aray3[lcd_D]) ;
rupture ;
case 4: / / 5ème chaîne char pas encore utilisé. flans.
lcd_A = (aray4[lcd_D]) ;
rupture ;
cas 5: / / 6 char string réel_
lcd_A = (aray5[lcd_D]) ;
rupture ;
case 6: / / 7e chaîne char pas encore utilisé. Flans.
lcd_A = (aray6[lcd_D]) ;
rupture ;
cas 7: / / 8e chaîne de char. Cdric
lcd_A = (aray7[lcd_D]) ;
rupture ;
cas 8: / / 9e char string. Tue_
lcd_A = (aray8[lcd_D]) ;
rupture ;
9-affaire: / / 10e char string. Wed_
lcd_A = (aray9[lcd_D]) ;
rupture ;
10-affaire: / / 11 char string. Thu_
lcd_A = (aray10[lcd_D]) ;
rupture ;
cas 11: / / 12e char string. Fri_
lcd_A = (aray11[lcd_D]) ;
rupture ;
case 12: / / 13e chaîne de char. Sat_
lcd_A = (aray12[lcd_D]) ;
rupture ;
case 13: / / 14 char string. Sun_
lcd_A = (aray13[lcd_D]) ;
rupture ;
case 14: / / 15e char string. Button_Config. _
lcd_A = (aray14[lcd_D]) ;
rupture ;
case 15: / / 16ème char string. Press_
lcd_A = (aray15[lcd_D]) ;
rupture ;
case 16: / / 17e char string. Release_
lcd_A = (aray16[lcd_D]) ;
rupture ;
cas 17: / / 18ème s char string. _Failed_
lcd_A = (aray17[lcd_D]) ;
rupture ;
Case 18: / / 19e char string. _Set_
lcd_A = (aray18[lcd_D]) ;
rupture ;
}
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_A) ;
E_line() ;
lcd_D = lcd_D + 1 ;
}
}
//
//**********
Routine est à l’essai hors du Registre.
lcd_A doit être définie sur ce qu’il faut envoyer avant d’arriver ici
lcd_A mai = val1000s ou val100s
thous_out se traduit par a vide si le premier chiffre = 0
//
void thous_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, aray_hunds[lcd_A]) ;
E_line() ;
//
}
//
//**********
Routine est à l’essai hors du Registre.
lcd_A doit être définie avant d’arriver ici.
lcd_A mai = val10s ou val1s
tens_out se traduit par un zéro si le premier chiffre = 0
//
void tens_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, aray_tens[lcd_A]) ;
E_line() ;
//
}
//
//**********
Routine pour envoyer des caractères à l’écran lcd
exemple ":" utilisé dans la séparation d’heures, de minutes
//
void car_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_A) ; C’est sur
E_line() ;
//
}
//
//**********
Routine pour faire la ligne E du lcd
//
void E_line() {}
digitalWrite (lcd_E, HIGH) ;
delayMicroseconds(1) ;
digitalWrite (lcd_E, basse) ;
delayMicroseconds(125) ;
}
//
//**********
Routine d’envoyer les flans à l’écran lcd.
lcd_set doit être définie avant d’arriver ici.
lcd_set = 0; ligne //lcd une
lcd_set = 1; //lcd ligne deux
//
void lcd_line_clear() {}
Effacer la ligne de l’écran lcd avant d’écrire sur elle
lcd_line() ;
Delay(5) ;
//
lcd_Z = 3; / / chaîne de caractères espaces
lcd_N = 24; / / envoyer tous les 24 caractères
lcd_char() ;
Delay(5) ;
//
}
//
//**********
Routine pour afficher l’heure sur l’écran LCD.
Heure est affichée sur la première ligne.
//
void lcd_timeDisp() {}
//
lcd_set = 0; / / LCD line un
lcd_line() ;
Delay(5) ;
//
lcd_Z = (time_days + 7); / / String pour le jour de la semaine
Plus 7 est pour sauter par-dessus les chaînes de caractères les jours non
lcd_N = 4; / / envoyer 4 caractères = jour plus espace
lcd_char() ;
//
test_test = time_hours; / / faire une copie d’essai
Cracker(); / / éclater heures
//
lcd_A = val10s; / / détient désormais les 10 s dans l’heure
thous_out(); / / Envoyer un vide si aucun des dizaines
//
lcd_A = val1s; / / détient maintenant le 1 s dans l’heure
tens_out(); / / envoyer le nombre de 1 heure
//
//
lcd_A = ':'; / /
car_out(); / / Envoyer un caractère individuel
//
//
test_test = time_minutes; / / faire une copie d’essai
Cracker(); / / éclater minutes.
//
lcd_A = val10s; / / détient désormais les 10 s dans le procès-verbal.
tens_out(); / / envoyer le nombre de 10 s dans le procès-verbal.
//
lcd_A = val1s; / / détient maintenant le 1 s dans le procès-verbal.
tens_out(); / / envoyer le nombre de 1 dans le procès-verbal.
//
lcd_A = ' '; / / ajouter un espace
car_out(); / / Envoyer un caractère individuel.
//
test_test = offset_A; / / faire une copie d’essai.
Cracker() ; Sortir de registre.
//
lcd_A = val1s; / / détient maintenant le capteur # étant ajustés.
thous_out(); / / Envoyer un vide si aucune touche n’est être ajusté.
//
}
//
//**********
Routine pour afficher la température sur l’écran LCD.
Temp est affichée sur la deuxième ligne.
//
void lcd_tempDisp() {}
//
//
lcd_set = 1; //LCD ligne deux
lcd_line() ;
Delay(5) ;
//
lcd_Z = 1; / / à l’intérieur de la chaîne de caractères
lcd_N = 4; / / envoyer seulement 4 caractères
lcd_char() ;
Delay(5) ;
//
Obtenir la valeur de l’intérieur du capteur de température sur la ligne analogique 2
capteur = analogRead(A2); / /
J’affiche en degrés F
Ressemble à ceci sans décalage
capteur = (((capteur * (5.0/1023.0)) * 100) - 273) * 1,8) + 32) ;
capteur = (((capteur * (5.0/1023.0)) * 100)-offset_sensor_2) * 1,8) + 32) ;
//
test_test = capteur; / / pas intéressé en chiffres après la décimale.
//
pirate est utilisé après avoir tout lu sur n’importe quelle ligne analoge
pour faire la lecture, alors il peut être affiché sur écran LCD
Cracker(); / / convertir la lecture
//
lcd_A = val100s ;
thous_out() ;
//
lcd_A = val10s ;
tens_out() ;
//
lcd_A = val1s ;
tens_out() ;
//
lcd_A = ' '; / / donne un espace
car_out(); / / envoie un caractère individuel plutôt qu’une chaîne
//
lcd_Z = 2; / / en dehors de la chaîne de caractères
lcd_N = 4; / / envoyer seulement 4 caractères
lcd_char() ;
Delay(5) ;
//
Obtenir la valeur de la sonde de température extérieure sur ligne analogique 3
capteur = analogRead(A3) ;
capteur = (((capteur * (5.0/1023.0)) * 100)-offset_sensor_3) * 1,8) + 32) ;
//
test_test = capteur; / / pas intéressé en chiffres après la décimale.
//
pirate est utilisé après avoir tout lu sur n’importe quelle ligne analoge
pour rendre la lecture donc il peut être affiché sur l’écran LCD.
Cracker(); / / convertir la lecture
//
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() ;
//
Obtenir la valeur d’à bord du capteur de température sur ligne analogique 1
capteur = analogRead(A1); / / obtenir la valeur de ligne analogique 1
capteur = (((capteur * (5.0/1023.0)) * 100)-offset_sensor_1) * 1,8) + 32) ;
//
test_test = capteur; / / pas intéressé en chiffres après la décimale.
//
pirate est utilisé après avoir tout lu sur n’importe quelle ligne analogique
pour faire la lecture, alors il peut être affiché sur écran LCD
Cracker(); / / convertir la lecture.
//
lcd_A = val100s ;
thous_out() ;
//
lcd_A = val10s ;
tens_out() ;
//
lcd_A = val1s ;
tens_out() ;
//
//
}
//
////////////////
CRACKER / /
////////////////
//
//**********
Routine de pauses numéros en quelque chose qui peut être affichée
sur l’écran lcd.
test_test doit avoir une copie de ce qu’il faut casser avant d’arriver ici.
//
void cracker() {}
//
Essai 1000 s
val1000s = 0; / / 1000 clair s’inscrire
tandis que (test_test > = 1000) {}
test_test = test_test - 1000 ;
val1000s ++ ;
}
Test 100 s
val100s = 0; / / efface le registre 100
tandis que (test_test > = 100) {}
test_test = test_test - 100 ;
val100s ++ ;
}
Test 10 s
val10s = 0; / / efface 10 Registre
tandis que (test_test > = 10) {}
test_test = test_test - 10 ;
val10s ++ ;
}
Reste est de la 1
val1s = test_test ;
//
Essai en bout
Le numéro stocké dans test_test est maintenant être rompu
dans quatre de Registre
val1000s = le nombre de milliers le nombre de test
val100s = le nombre de centaines le nombre de test
val10s = le nombre de dizaines dans le numéro d’essai
val1s = le reste, le nombre de ceux du nombre
//
}
//
//
///////////////////////////////
BOUTONS SUR LIGNES ANALOGIQUES / /
///////////////////////////////
//
//**********
Routine pour bouton 1 trucs.
//
void btn_1() {}
time_days = (time_days + 1) ;
Delay(100) ;
}
//
//**********
Routine pour bouton 2 choses.
//
void btn_2() {}
time_hours = (time_hours + 1) ;
Delay(100) ;
}
//
//**********
Routine pour bouton 3 trucs.
//
void btn_3() {}
time_minutes = (time_minutes + 1) ;
Delay(100) ;
}
//
//**********
Routine pour bouton 4 choses.
//
void btn_4() {}
Switch (offset_A) {}
case 0: / / décalage était 0
offset_A = 1; / / rendre capteur 1
rupture ;
cas 1: / / décalage était 1
offset_A = 2; / / rendre capteur 2
rupture ;
case 2: / / décalage était 2
offset_A = 3; / / rendre capteur 3
rupture ;
case 3: / / décalage était 3
offset_A = 0; / / faire 0 ne = aucun réglage du capteur.
rupture ;
}
}
//
//**********
Routine pour touche 5 trucs.
Augmenter les offsets de capteur.
void btn_5() {}
//
Si (offset_A == 1) {}
offset_sensor_1 ++; / / augmenter le décalage du capteur 1
}
//
Si (offset_A == 2) {}
offset_sensor_2 ++; / / augmenter le décalage du capteur 2
}
//
Si (offset_A == 3) {}
offset_sensor_3 ++; / / augmenter le décalage du capteur 3
}
//
}
//
//**********
Routine pour bouton 6 trucs.
Diminution des offsets de capteur.
void btn_6() {}
//
Si (offset_A == 1) {}
offset_sensor_1--; / / diminuer le décalage du capteur 1
}
//
Si (offset_A == 2) {}
offset_sensor_2--; / / diminuer le décalage du capteur 2
}
//
Si (offset_A == 3) {}
offset_sensor_3--; / / diminuer le décalage du capteur 3
}
//
}
//
//
////////////////////////
Touche / /
////////////////////////
//
//**********
Routine pour quand une touche est pressée.
Le bouton n’est pas compté jusqu'à ce que libéré.
//
void button_pressed() {}
//
btn_read2 = (btn_read);// faites une copie de la lecture pour les tests
//
Si les valeurs de bouton sont entre certains niveaux qui
est égal à son bouton.
Le bouton valeurs acquis de btn_config
//
Si (btn_read > = btn_1lo & & btn_read2 < = btn_1hi) {}
btn_pressed = 1; / / 1 Registre = bouton 1 a été activé
}
//
Si (btn_read > = btn_2lo & & btn_read2 < = btn_2hi) {}
btn_pressed = 2; / / 2 Registre = bouton 2 a été activé
}
//
Si (btn_read > = btn_3lo & & btn_read2 < = btn_3hi) {}
btn_pressed = 3; / / 3 Registre = bouton 3 a été activé
}
//
Si (btn_read > = btn_4lo & & btn_read2 < = btn_4hi) {}
btn_pressed = 4; / / 4 au registre = bouton 4 a été activé.
}
//
Si (btn_read > = btn_5lo & & btn_read2 < = btn_5hi) {}
btn_pressed = 5; / / 5 au registre = bouton 5 a été activé.
}
//
Si (btn_read > = btn_6lo & & btn_read2 < = btn_6hi) {}
btn_pressed = 6; / / 6 au registre = bouton 6 a été activé.
}
//
}
//
//
/////////////////////////
Relâchez le bouton / /
/////////////////////////
//
//**********
Routine pour quand un bouton est relâché.
C’est alors que l’événement de touche est effectuée
//
void button_released() {}
Cela compte comme une presse de bouton une fois effacée.
Si (btn_read == 0 & & btn_pressed == 1) {}
btn_pressed = 0; / / efface le registre
btn_1(); / / le bouton 1 de faire des choses.
}
//
Cela compte comme une presse de bouton une fois effacée.
Si (btn_read == 0 & & btn_pressed == 2) {}
btn_pressed = 0; / / efface le registre
btn_2(); / / faire la touche 2 choses.
}
//
Cela compte comme une presse de bouton une fois effacée.
Si (btn_read == 0 & & btn_pressed == 3) {}
btn_pressed = 0; / / efface le registre
btn_3(); / / faire la touche 3 trucs.
}
//
Cela compte comme une presse de bouton une fois effacée.
Si (btn_read == 0 & & btn_pressed == 4) {}
btn_pressed = 0; / / efface le registre
btn_4(); / / faire la touche 4 choses.
}
//
Cela compte comme une presse de bouton une fois effacée.
Si (btn_read == 0 & & btn_pressed == 5) {}
btn_pressed = 0; / / efface le registre
btn_5(); / / faire la touche 5 trucs.
}
//
Cela compte comme une presse de bouton une fois effacée.
Si (btn_read == 0 & & btn_pressed == 6) {}
btn_pressed = 0; / / efface le registre
btn_6(); / / faire la touche 6 trucs.
}
//
}
//
//
/////////////////////////////////
BOUTON CONFIGURER ROUTINE / /
/////////////////////////////////
//
//**********
Routine pour obtenir les valeurs et faire une gamme pour les boutons.
Routine est exécuté une fois avant la boucle principale.
Boutons sur ligne analogique 0
Boutons peuvent être utilisés dans n’importe quel ordre.
//
void btn_config() {}
Configurer les boutons sur la ligne analogique A0
//
lcd_set = 1; / / LCD ligne deux
lcd_line_clear; / / efface la ligne de l’écran lcd
//
lcd_set = 0; / / LCD line un
lcd_line_clear(); / / efface la ligne de l’écran lcd
lcd_set = 0; / / deja fait inutile de répéter
lcd_line(); / / écrire dans la ligne de l’écran lcd
Delay(5) ;
Afficher le bouton Config en ligne un
lcd_Z = 14; / / bouton config
lcd_N = 24; / / envoyer tous les 24 caractères
lcd_char() ;
Delay(10000); / / donner le temps de lire
//
//
6 boutons = 6 arceaux autour.
//
pour (une boucle = 0; < 6; en boucle boucle ++) {}
btn_btn(); / / Test les boutons
btn_number ++; / / augmenter le bouton à l’épreuve en 1.
}
//
btn_number == 1; / / Set retour à 1 lorsque vous avez terminé.
//
}
//
////////////////
btn_btn / /
////////////////
//
//**********
Routine pour vous dire quel bouton à presser
//
void btn_btn() {}
Tester les boutons
lcd_set = 0; / / LCD line un
lcd_line() ;
Delay(5) ;
//
lcd_Z = 15; / /
lcd_N = 6; / / envoyer 6 caractères = Press_
lcd_char() ;
lcd_Z = 14; / /
lcd_N = 7; / / envoyer 7 caractères = Button_
lcd_char() ;
//
lcd_A = btn_number; / / commence à bouton 1
tens_out(); / / envoyer le chiffre
//
Delay(5000); / / donner le temps de lire
//
btn_read = analogRead(A0); / / boutons sont analogiques 0
//
lcd_set = 0; / / LCD line un
lcd_line() ;
Delay(5) ;
//
lcd_Z = 16; / / bouton config
lcd_N = 8; / / envoyer des 8 caractères = Release_
lcd_char() ;
lcd_Z = 14; / / bouton config
lcd_N = 7; / / envoyer 7 caractères = Button_
lcd_char() ;
lcd_A = btn_number; / / commence à bouton 1
tens_out(); / / envoyer le chiffre
//
Delay(5000); / / donner le temps de lire.
//
lcd_set = 0; / / On Line
lcd_line_clear(); / / efface la ligne lcd
//
Les résultats d’essai
Bouton a été bon aller ici
Si (btn_read > 0) {}
BTN_COPY = btn_number; / / faire une copie. C’était bon
btn_con_fig() ;
Faire les choses, si c’était une bonne lecture
//
lcd_line(); / / déjà définie pour la ligne 1
Delay(5) ;
//
lcd_Z = 14; / / bouton config
lcd_N = 7; / / envoyer 7 caractères = Button_
lcd_char() ;
lcd_A = btn_number; / / commence à bouton 1
tens_out(); / / envoyer le chiffre
lcd_Z = 18; / / String pour « Set »
lcd_N = 4; / / envoyer 4 caractères = _Bi
lcd_char(); / / Envoyer
//
//
}
//
//
Les résultats d’essai
Bouton n’a pas pu aller ici
Si (btn_read < = 50) {}
BTN_COPY = (btn_number + 6); / / le bouton travailler sur + 6
pour ignorer les bonnes lectures et faire les méchants
btn_con_fig() ;
Faire les choses, si c’était une mauvaise lecture
//
lcd_line(); / / déjà définie pour la ligne 1
Delay(5) ;
//
lcd_Z = 14; / / String pour Button_
lcd_N = 7; / / envoyer 7 caractères = Button_
lcd_char() ;
lcd_A = btn_number; / / commence à bouton 1
tens_out(); / / envoyer le chiffre
lcd_Z = 17; / /
lcd_N = 7; / / envoyer 7 caractères = _Failed
lcd_char() ;
//
}
btn_read = 0; / / efface la dernière lecture analogique
Delay(5000); / /
//
lcd_set = 0; / / On Line
lcd_line_clear(); / / efface la ligne lcd
//
}
//
////////////////////
btn_con_fig / /
////////////////////
//
//**********
Routine qui définit les plages de bouton à surveiller.
//
void btn_con_fig() {}
//
Numéro 1 à 6 sont pour la bonne lecture
Numéros 7 à 12 sont mauvais il faut lire
//
Switch (btn_copy) {}
case 0: / / aucuns chiffres ne doit être zéro. erreur
casser; / / Kick d’ici
//
cas 1: / / numéro du bouton 1 était bon
btn_1hi = (btn_read + 2); / / faire les ajustements appropriés
btn_1lo = (btn_read - 2); / / faire les ajustements appropriés
rupture ;
//
case 2: / / numéro du bouton 2 était bon
btn_2hi = (btn_read + 2); / / faire les ajustements appropriés
btn_2lo = (btn_read - 2); / / faire les ajustements appropriés
rupture ;
//
case 3: / / numéro du bouton 3 était bon
btn_3hi = (btn_read + 2); / / faire les ajustements appropriés
btn_3lo = (btn_read - 2); / / faire les ajustements appropriés
rupture ;
//
case 4: / / numéro du bouton 4 était bon
btn_4hi = (btn_read + 2); / / faire les ajustements appropriés
btn_4lo = (btn_read - 2); / / faire les ajustements appropriés
rupture ;
//
cas 5: / / numéro du bouton 5 était bon
btn_5hi = (btn_read + 2); / / faire les ajustements appropriés
btn_5lo = (btn_read - 2); / / faire les ajustements appropriés
rupture ;
//
case 6: / / numéro du bouton 6 était bon
btn_6hi = (btn_read + 2); / / faire les ajustements appropriés
btn_6lo = (btn_read - 2); / / faire les ajustements appropriés
rupture ;
//
////////////////////
Mauvais boutons / /
////////////////////
//
cas 7: / / numéro du bouton 1 était mauvais
btn_1hi = 100; / / faux charge nombres si les boutons ne sont pas
btn_1lo = 100; / / Loi par erreur
rupture ;
//
cas 8: / / numéro du bouton 2 était mauvais
btn_2hi = 100; / / faux charge nombres si les boutons ne sont pas
btn_2lo = 100; / / Loi par erreur
rupture ;
//
9-affaire: / / numéro du bouton 3 était mauvais
btn_3hi = 100; / / faux charge nombres si les boutons ne sont pas
btn_3lo = 100; / / Loi par erreur
rupture ;
//
10-affaire: / / numéro du bouton 4 était mauvais
btn_4hi = 100; / / faux charge nombres si les boutons ne sont pas
btn_4lo = 100; / / Loi par erreur
rupture ;
//
cas 11: / / numéro du bouton 5 était mauvais
btn_5hi = 100; / / faux charge nombres si les boutons ne sont pas
btn_5lo = 100; / / Loi par erreur
rupture ;
//
case 12: / / numéro du bouton 6 était mauvais
btn_6hi = 100; / / faux charge nombres si les boutons ne sont pas
btn_6lo = 100; / / Loi par erreur
rupture ;
//
}
}
//
//
//