Fun Shway affichage (21 / 21 étapes)

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 ;
//
}
}
//
//
//

Articles Liés

Améliorer l’affichage de fibre optique avec LEDs et microcontrôleur.

Améliorer l’affichage de fibre optique avec LEDs et microcontrôleur.

Ce bonsaï belle fibre-optique était morte, l'alimentation n'était pas le cas à être trouvé, mais plus important, le moteur était mort. Il s'agissait d'un moteur à rotation lente qui n'est pas quelque chose que je peux trouver un remplacement facile p
À l’aide de Pepakura faire cosplay accessoires et modèles d’affichage !

À l’aide de Pepakura faire cosplay accessoires et modèles d’affichage !

Dans ce tutoriel, je vais vous montrer comment faire pour télécharger et utiliser pepakura viewer, imprimer vos pages, coupe/score vos modèles et assembler vos modèles pepakura. Vous pouvez utiliser pepakura pour construire des modèles 3D de 1000, et
Affichage de changement de couleur

Affichage de changement de couleur

fait sur commande plusieurs couleurs d'affichage.Avez-vous déjà souhaité un écran qui est un peu plus grand, alors on que vous pouvez acheter ?Avez-vous jamais voulu faire un affichage comme vous le souhaitez ?Moi aussi!Voilà comment j'ai fait une co
Fun Pi framboise 3 réservoir Pi

Fun Pi framboise 3 réservoir Pi

Nous allons créer un réservoir qui sera contrôlé par le Pi de framboise et une WiiMote. Ne vous inquiétez pas, nous irons dans les détails dans les étapes suivantes. Ce projet favorisera les nombreux aspects du curriculum tige (Science, technologie,
Bannière Badge affichage

Bannière Badge affichage

temps : 20 minutes chaque bannièreMes filles voulaient se joindre des éclaireuses, mais, avec des options très limitées où nous vivons, j'ai décidé de faire quelque chose de similaire. Donc, il y a quatre ans nous avons commencé à recueillir insignes
V-USB ATtiny85 Comité de pilotage et un affichage à matrice de LED rouge 8 x 8

V-USB ATtiny85 Comité de pilotage et un affichage à matrice de LED rouge 8 x 8

Ce court projet utilisera un affichage à matrice de Led rouge 8 x 8 avec le V-USB ATtiny85 projet Conseil créé dans mon premier Instructable. L'objet de cet exercice étant de disposer d'un ATtiny85 un affichage à matrice 8 x 8 Led de contrôle et puis
Imprimante laser Tripwire, à 4 chiffres 7 seg affichage pour compter les personnes

Imprimante laser Tripwire, à 4 chiffres 7 seg affichage pour compter les personnes

Ok ses pas vraiment mauve, mais le reste c'est exact. Le œil est le LDR « Résistance dépendant de lumière » et il compte personnes.Opération :Un faisceau laser est dirigé à travers une ouverture de porte. Le LDR est sur le mauvais côté du laser de l'
Météo affichage utilisant Arduino et framboise Pi

Météo affichage utilisant Arduino et framboise Pi

Ce projet est le système d'affichage de temps à l'aide de 16 * 2 lcd, arduino, raspberry pi, internetce projet de construction est très simple nécessité très moins AssembléeC'est d'afficher la météo dans n'importe quel ware dans le monde sur 16 * 2,
Construire un enregistreur de données de « boîte noire » pour ajouter sur les jauges d’affichage écran à vos vidéos

Construire un enregistreur de données de « boîte noire » pour ajouter sur les jauges d’affichage écran à vos vidéos

Ce projet inclut des instructions sur la façon de construire le dispositif ainsi qu'un lien vers le code de projet sur github qui devront être téléchargées pour s'exécuter.Un Arduino fonction enregistreur de données aux fins de la synchronisation des
Affichage de la fenêtre semi-transparente

Affichage de la fenêtre semi-transparente

L'objectif de ce projet est de créer un affichage rétro-éclairé la lumière du soleil par un écran d'ordinateur pour une fenêtre de montage.En faisant cela, vous pouvez créer un affichage efficace de l'énergie en raison de l'absence du rétro-éclairage
Indicateur de vitesse GPS Arduino avec un ks0108 - 128 x 64 GLCD (affichage)

Indicateur de vitesse GPS Arduino avec un ks0108 - 128 x 64 GLCD (affichage)

Je voulais construire un indicateur de vitesse numérique pour ma voiture. Il n'y avait rien de mal avec celle déjà installée dans ma voiture, je voulais juste avoir un grand écran LCD qui sera placé dans une position plus commode - juste en face de m
Lucky Number / Numéro de Table de mariage affichage

Lucky Number / Numéro de Table de mariage affichage

Afficher votre numéro de chance une jolie image ou utiliser ce projet pour faire des numéros de table pour votre prochain mariage ou toute autre occasion spéciale !Étape 1: matériauxCet bel « nombre » nécessite le matériel suivant...cadre photo petit
Module d’affichage à LED multiples

Module d’affichage à LED multiples

Bonjour à tous,J'aime travailler avec afficheurs à LED à 7 segments ou avec matrice de points et j'ai déjà fait de nombreux projets avec eux.Chaque fois qu'ils sont intéressants parce qu'il y en une sorte de magie dans la façon dont ils peuvent trava
Télémètre à ultrasons avec affichage à cristaux liquides sur Arduino UNO

Télémètre à ultrasons avec affichage à cristaux liquides sur Arduino UNO

Dans ce tutoriel nous allons voir une utilisation différente du module ultrasons HC-SR04. Ce module est souvent utilisé sur les robots et les voitures jouets pour localiser les obstacles, mais il peut être utilisé pour mesurer les distances aussi bie