Kul Shway Display (21 / 21 steg)

Steg 21: Mitt program

11-11-2012 stråle McQueen

LCD linje 1 dag och tid
LCD linje 2 temp avläsningar

6 knappar på analoga A0
Någon knapp aktiveringen vänder sig på rygg ljus i 2 minuter.
Den svala delen om knappen config är att
valfri knapp kan anges på knapp 1, 2, 3, 4, 5 eller 6.

LM335 och LM334Z temp givare används.
Temperaturkompensationen är justerbar.

*/
//
//
CONST int
//
CONST int lcd_datapin = 6; 74HC164 stift 1
CONST int lcd_clk = 5; 74HC164 stift 8
CONST int lcd_E = 4; LCD E line
CONST int lcd_RS = 3; LCD-RS linje
CONST int ljus = 2; / / Back light output
//
Analoga grejer
//
A0-knappar
A1 - On board tempsensor.
A2 - inne temp sensor.
A3 - Outside temp sensor.
//
//
KLOCKAN GREJER
INGA NEGATIVA TAL
osignerade långa time_begin;
osignerade långa time_duration;
osignerade långa time_remain;
osignerade långa time_val;
unsigned int time_seconds = 0; / / butiker antalet sekunder
unsigned int time_minutes = 0; / / butiker i minuter. Den
klockan startar på antalet minuter lagrat här reset.
unsigned int time_hours = 12; / / butiker antalet timmar. Klockan
startar på antalet timmar lagrad här på resten.
unsigned int time_days = 0; / / butiker antalet dagar
Används för att räkna upp till en uppsättning händelse.
unsigned int event_seconds1 = 0; / / lagring av sekunder räkna
//
//
LCD grejer
//
int lcd_C = 0; Karaktär som ska skiftas
int lcd_D = 0; Karaktär som ska skiftas
int lcd_N = 0; Antalet tecken att skicka till lcd
int lcd_i = 0; Används för looping
int lcd_set = 0; / / används för att lagra vilken setup för att få
int lcd_A = 0; / / används för att välja aray att använda
int lcd_Z = 0; Används i LCD-char testning
//
//
Används av cracker
//
int val1000s = 0; / / registrera dig för att hålla 1000 greve
int val100s = 0; / / registrera dig för att hålla 100 count
int val10s = 0; / / registrera dig för att hålla 10 count
int val1s = 0; / / Register för 1 räkna
int test_test = 0; / / registrera dig för att lagra nummer för testning/tid också
//
Används för sensormätningar
float sensor = 0; / / lagring för sensorn nivå
int kopia = 0; / / kopia av vad jag lägga i den / tid också
//
int back_lit = 0; / / tillbaka ljus på/av
//
//
//
KNAPPEN GREJER
int btn_read = 0; / / läsa från analog linje
int btn_read2 = 0; / / kopia av läsningen
int btn_pressed = 0; / / knappen trycktes
int btn_number = 1; / / alltid börja med knappen #1
int btn_copy = 0; / / kopia av knapp för con_fig.
int looping = 0; / / för min slingor
//*****************
Store hög- och spänna av ett knappar analoga värde
//
int btn_1hi; / / knappen #1 stort omfång
int btn_1lo; / / knappen #1 låg utbud
int btn_2hi; / / knappen #2 hög räckvidd
int btn_2lo; / / knappen #2 låg utbud
int btn_3hi; / / knapp #3 kick spänner
int btn_3lo; / / knapp #3 låg utbud
int btn_4hi; / / knapp #4 hög räckvidd
int btn_4lo; / / knapp #4 låg utbud
int btn_5hi; / / knapp #5 hög räckvidd
int btn_5lo; / / knapp #5 låg utbud
int btn_6hi; / / knapp #6 hög range
int btn_6lo; / / knapp #6 låg utbud
//
//
int offset_sensor_1 = 257; / / Start offset vid 2.57 volt = LM334Z
int offset_sensor_2 = 273; / / Start offset på 2,73 volt
int offset_sensor_3 = 273; / / Start offset på 2,73 volt
int offset_A = 0; / / 0 = inga justeringar.
1 = sensor 1 Justera.
2 = givare 2 justera.
3 = sensor 3 justera.
LM335 2,73 volt output på noll grader C
LM334Z ungefär 2.57 volt output på noll grader C
//
//
MATRISER ***
Matriser räkningen startar på 0 inte 1 och går upp
//
16-24 tecken 2 linje lcd
int aray_set_up [] = {
56, 12, 6, 1}; LCD setup tecken
//
Startplatser för LCD
int aray_lines [] = {
132 = 5: e tecknet från vänster startposition, linje 1
196 = 5: e tecknet från vänster startposition, linje 2
128 = linje 1
192 = linje 2
128, 192, 132, 196};
//
Använder en tom på första plats så att inte Visa
föregående nollor.
int aray_hunds [] = {
' ', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
"0" i den första loaction så att
någon precceding noll
int aray_tens [] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
Den första matrisen så jag kan sätta namn på lcd början
Matris visas bara i början upp.
lcd_Z = vilken matris att använda
int aray0 [] = {
'F', 'u', 'n', ' ', 'S', 'h', 'w', 'a', 'y', ' ', 'D', 'i', 's', 'p', 'l', 'a', 'y', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
//
Endast 4 av dessa tecken skickas men vänster vid 5 så ingen kör över
int aray1 [] = {
' ', 'I', 'n', ' ', ' ' };
Endast 4 av dessa tecken skickas men vänster vid 5 så ingen kör över
int aray2 [] = {
'O', 'u', 't', ' ', ' ' };
Lämna nedan för tomma celler
int aray3 [] = {
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
Inte används ännu
int aray4 [] = {
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
Ordet tiden
int aray5 [] = {
'T', 'i', 'm', 'e', ' ' };
Inte används ännu
int aray6 [] = {
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' , ' ', ' ', ' ', ' ', ' ', ' ' };
//
MATRISER FÖR VECKANS DAGAR
//
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', ' ', ' ', ' ' };
//
MATRISER FÖR KNAPPEN 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, produktionen); Definiera som utdata
pinMode (lcd_clk, produktionen); Definiera som utdata
pinMode (lcd_E, produktionen); Definiera (E-linjen) som utdata
pinMode (lcd_RS, produktionen); Definiera (RS linje) som utdata
pinMode (ljus, OUTPUT); Definiera (motljus) som utdata
//
digitalWrite (lcd_E, hög); / / Bring lcd manöverledningen hög
digitalWrite (lcd_RS, hög); / / Bring lcd manöverledningen hög
//
digitalWrite (ljus, låg); / / slå på baksidan ljus för visning
//
LCD-setup
lcd_init(); / / initiera lcd för användning
//
lcd_set = 0; / / första linje
lcd_line();
Delay(5);
Lagt till så linje en visar starta skärmen ***
Det visar bara denna enda gång från början upp ***
//
lcd_Z = 0; / / LCD linje en teckensträng
lcd_N = 24; / / skicka alla 24 tecken
lcd_char();
//
Delay(10000); / / fördröjning 10 sekunder så jag kan se programnamnet.
//
Tydlig LCD linje innan du skriver det så det finns inga kvar över
lcd_set = 0; / / LCD linje en
//
lcd_line_clear(); / / Clear LCD-linjen till tomma
//
//
Konfigurera knapparna på det analoga nätet
Detta blir gjort en gång tidigare huvudloop
//
btn_config(); / / knappen konfiguration rutin.
//
digitalWrite (ljus, hög); / / slå på baksidan ljus för visning
event_seconds1 = 0; / / klart händelsen sekunder register.
back_lit = 0; / / rensa registret bakgrundsbelysning.
//
/////////////////
SLUTET AV INRÄTTATS / /
/////////////////
//
}
//
////////////////////////
BEGIN MAIN LOOP / /
////////////////////////
//
//
void loop() {
//
Måste göras i början att klockan fungerar rätt.
time_begin = millis(); / / plats i början
//
lcd_timeDisp(); / / Visa dag och tidpunkt på linje 1
//
lcd_tempDisp(); / / Visa temp in/ut på linje 2
//
//**************************
TID SAKER ATT UPPDATERA REGISTER
//
time_val = (time_remain + time_duration);
Om tiden genom (intervall) har varit mindre än en sekund
fortsätta att lägga till det.
om (time_val < 1000) {
time_remain = time_val;
}
Om tiden genom (intervall) har varit mer än en sekund
räkna ut hur många sekunder.
om (time_val > = 1000) {
medan (time_val > = 1000) {
time_val = time_val - 1000;
time_seconds ++;
event_seconds1 ++; / / öka event_seconds1 av en
}
time_remain = time_val;
}
//
om (time_seconds > = 60) {
time_minutes ++; / / öka minuter av en
time_remain = (time_remain + 1); / / lagt tid fästingen förlust över tiden.
time_seconds = (time_seconds - 60);
}
om (time_minutes > = 60) {
time_hours ++; / / ökning av 1
time_minutes = (time_minutes - 60);
}
om (time_hours > = 24) {
time_days ++; / / ökning av 1
time_hours = (time_hours - 24);
}
om (time_days > = 7) {
time_days = (time_days - 7);
}
//
//
Kontrollera om en knapp trycks.
Ingen Debounce var skadas i skapandet av detta program.
//
btn_read = analogRead(A0);
om (btn_read > 50 & & back_lit == 0) {
digitalWrite (ljus, låg); / / slå på baksidan ljus för någon
knappen aktivering. Dont göra någon knappåtgärder ännu.
event_seconds1 = 0; / / rensa sekunder event generator.
back_lit = 1; / / nästa knappen pressen är giltigt att göra något.
Delay(2000); / / innan letar du efter en annan knapp intryckt.
//
}
//
//
btn_read = analogRead(A0); / /
om (btn_read > 50 & & back_lit == 1) {
//
Giltigt läsning är något bra än 50.
En giltig behandlingen och tillbaka ljus = 1 om du vill göra knappen saker.
50 är min intervall (inaktivera) för dålig knappar.
En knapp trycks.
button_pressed (); //Figure ut som en
}
Kontrollera om en knapp är släppt.
btn_read = analogRead(A0); / /
om (btn_read == 0 & & back_lit == 1) {
Knappen släpptes.
button_released(); / / räkna ut som en
}
//
Timer för att stänga av bakgrundsbelysningen
om (event_seconds1 > = 120) {
digitalWrite (ljus, hög); / / stänga av bakgrundsbelysningen.
back_lit = 0; / / rensa registret för LCD-bakgrundsbelysning.
offset_A = 0; / / rensa registret för motbokning temps.
}
//
//
Delay(100); / / för stabilitet
//
//************************************
DETTA GÅR I SLUTET AV MAIN LOOP
Fel korrigeras när millis rullar
Helt enkelt ställer båda avläsningar till 0 och startar över.
om (millis() < time_begin) {
time_duration = 0; / / plats i slutet
time_begin = 0; / / plats på slutet
}
//
om (millis() > time_begin) {
time_duration = (millis() - time_begin) ;// plats i slutet
}
//
/////////////////////////
SLUTET AV MAIN LOOP / /
/////////////////////////
//
}
//
//
//
//
//
//*********************
BEGIN RUTINER **
//*********************
//
//
/////////////////////
LCD-RUTINER / /
/////////////////////
//
//
Rutinen att initiera lcd.
//
void lcd_init() {
digitalWrite (lcd_E, låg); / / rensa E line
digitalWrite (lcd_RS, låg); / / rensa RS linje
delayMicroseconds(125); / / längre dröjsmål sedan behövs men fungerar
för (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);
}
//
//**********
Rutin för att välja vilken linje info är att visas på.
lcd_set = 0 för fodra en.
lcd_set = 1 för rad två.
lcd_set måste anges innan det blir här.
//
void lcd_line() {
lcd_C = (aray_lines[lcd_set]); aray_lines [lcd_set] om lcd_set = 0 = fodra en
aray_lines [lcd_set] om lcd_set = 1 = linje två.
digitalWrite (lcd_E, låg); Lägre E line
digitalWrite (lcd_RS, låg); Lägre RS linje
delayMicroseconds(125); Liten fördröjning
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_C);
E_line();
digitalWrite (lcd_RS, hög);
delayMicroseconds(125);
}
//
//**********
Rutinen att skicka strängar till displayen.
lcd_N måste laddas med antalet tecken att skicka
innan jag här.
//
void lcd_char() {
lcd_D = 0;
//
Justera lcd_N för antalet tecken att skicka
för (lcd_i = 0; lcd_i < lcd_N; lcd_i ++) {
//
växel (lcd_Z) {
fall 0: / / 1 char string Fun_Shway_Display
lcd_A = (aray0[lcd_D]);
bryta;
fall 1: / / 2: a röding string _In_
lcd_A = (aray1[lcd_D]);
bryta;
fall 2: / / 3rd char string Out_
lcd_A = (aray2[lcd_D]);
bryta;
fall 3: / / 4 char sträng används för tomma celler
lcd_A = (aray3[lcd_D]);
bryta;
fall 4: / / 5 char sträng används inte ännu. tomma celler.
lcd_A = (aray4[lcd_D]);
bryta;
fall 5: / / 6 röding string Time_
lcd_A = (aray5[lcd_D]);
bryta;
efter några behandlingen på vilken linje som helst analogt används knäckt
att göra behandlingen så att den kan visas på LCD-
Cracker(); / / konvertera läsning
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
lcd_A = ""; / / ger ett utrymme
car_out(); / / skickar enskilda tecken i stället för en sträng
//
lcd_Z = 2; / / utanför teckensträng
lcd_N = 4; / / Skicka endast 4 tecken
lcd_char();
Delay(5);
//
Hämta värdet på utanför tempsensor på analog linje 3
sensor = analogRead(A3);
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_3) * 1,8) + 32);
//
test_test = sensor; / / inte intresserad av siffror efter decimal.
//
efter några behandlingen på vilken linje som helst analogt används knäckt
för att göra läsningen så den kan visas på LCD-skärmen.
Cracker(); / / konvertera läsning
//
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();
//
Hämta värdet på ombord tempsensor på analog linje 1
sensor = analogRead(A1); / / få värdet av analog linje 1
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_1) * 1,8) + 32);
//
test_test = sensor; / / inte intresserad av siffror efter decimal.
//
efter några behandlingen på vilken analog linje används knäckt
att göra behandlingen så att den kan visas på LCD-
Cracker(); / / konvertera behandlingen.
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
//
}
//
////////////////
CRACKER / /
////////////////
//
//**********
Rutinen bryts nummer i något som kan visas
på LCD-skärmen.
test_test måste ha en kopia av vad att knäcka innan det blir här.
//
void cracker() {
//
Test 1000s
val1000s = 0; / / klart 1000 register
medan (test_test > = 1000) {
test_test = test_test - 1000;
val1000s ++;
}
Test 100s
val100s = 0; / / Clear 100 register
medan (test_test > = 100) {
test_test = test_test - 100.
val100s ++;
}
Test 10s
val10s = 0; / / rensa 10 register
medan (test_test > = 10) {
test_test = test_test - 10.
val10s ++;
}
Resten är 1
val1s = test_test;
//
Slutet testning
De tal som lagras med test_test är nu brytas
ut i fyra register
val1000s = antalet tusentals i den test nummer
val100s = antalet hundratals i den test nummer
val10s = antalet TEN i den test nummer
val1s = resten, antalet ettor i numret
//
}
//
//
///////////////////////////////
KNAPPAR PÅ ANALOG LINJE / /
///////////////////////////////
//
//**********
Rutin för att knappen 1 grejer.
//
void btn_1() {
time_days = (time_days + 1);
Delay(100);
}
//
//**********
Rutin för att knappen 2 saker.
//
void btn_2() {
time_hours = (time_hours + 1);
Delay(100);
}
//
//**********
Rutin för att knappen 3 grejer.
//
void btn_3() {
time_minutes = (time_minutes + 1);
Delay(100);
}
//
//**********
Rutin för att knappen 4 saker.
//
void btn_4() {
växel (offset_A) {
fall 0: / / Offset var 0
offset_A = 1; / / göra det sensor 1
bryta;
fall 1: / / Offset var 1
offset_A = 2; / / göra det sensor 2
bryta;
fall 2: / / Offset var 2
offset_A = 3; / / göra det sensor 3
bryta;
fall 3: / / Offset var 3
offset_A = 0; / / göra det 0 = ingen justering av sensorn.
bryta;
}
}
//
//**********
Rutin för att knappen 5 grejer.
Öka sensor förskjutningar.
void btn_5() {
//
om (offset_A == 1) {
offset_sensor_1 ++; / / öka förskjutningen för sensor 1
}
//
om (offset_A == 2) {
offset_sensor_2 ++; / / öka förskjutningen för sensor 2
}
//
om (offset_A == 3) {
offset_sensor_3 ++; / / öka förskjutningen för sensor 3
}
//
}
//
//**********
Rutin för att knappen 6 grejer.
Minska sensor förskjutningar.
void btn_6() {
//
om (offset_A == 1) {
offset_sensor_1--; / / minskning förskjutningen för sensor 1
}
//
om (offset_A == 2) {
offset_sensor_2--; / / minskning förskjutningen för sensor 2
}
//
om (offset_A == 3) {
offset_sensor_3--; / / minskning förskjutningen för sensor 3
}
//
}
//
//
////////////////////////
Knappen intryckt / /
////////////////////////
//
//**********
Rutin för när en knapp trycks.
Knappen är inte räknas till befriaren.
//
void button_pressed() {
//
btn_read2 = (btn_read) ;// Make en kopia av läsning för testning
//
Om knappen värdena är mellan vissa nivåer som
är lika med dess knapp.
Knappen värden förvärvat från btn_config
//
om (btn_read > = btn_1lo & & btn_read2 < = btn_1hi) {
btn_pressed = 1; / / 1 i register = knappen 1 trycktes
}
//
om (btn_read > = btn_2lo & & btn_read2 < = btn_2hi) {
btn_pressed = 2; / / 2 i register = knappen 2 trycktes
}
//
om (btn_read > = btn_3lo & & btn_read2 < = btn_3hi) {
btn_pressed = 3; / / 3 i register = knappen 3 trycktes
}
//
om (btn_read > = btn_4lo & & btn_read2 < = btn_4hi) {
btn_pressed = 4; / / 4 i register = knapp 4 trycktes.
}
//
om (btn_read > = btn_5lo & & btn_read2 < = btn_5hi) {
btn_pressed = 5; / / 5 i register = knapp 5 trycktes.
}
//
om (btn_read > = btn_6lo & & btn_read2 < = btn_6hi) {
btn_pressed = 6; / / 6 i register = knappen 6 trycktes.
}
//
}
//
//
/////////////////////////
Knappen släpps / /
/////////////////////////
//
//**********
Rutin för när en knapp är släppt.
Detta är när händelsen knappen utförs
//
void button_released() {
Räknas detta som en knapptryckning när rensat.
om (btn_read == 0 & & btn_pressed == 1) {
btn_pressed = 0; / / rensa registret
btn_1(); / / göra knappen 1 grejer.
}
//
Räknas detta som en knapptryckning när rensat.
om (btn_read == 0 & & btn_pressed == 2) {
btn_pressed = 0; / / rensa registret
btn_2(); / / göra knappen 2 saker.
}
//
Räknas detta som en knapptryckning när rensat.
om (btn_read == 0 & & btn_pressed == 3) {
btn_pressed = 0; / / rensa registret
btn_3(); / / göra knappen 3 grejer.
}
//
Räknas detta som en knapptryckning när rensat.
om (btn_read == 0 & & btn_pressed == 4) {
btn_pressed = 0; / / rensa registret
btn_4(); / / göra knappen 4 saker.
}
//
Räknas detta som en knapptryckning när rensat.
om (btn_read == 0 & & btn_pressed == 5) {
btn_pressed = 0; / / rensa registret
btn_5(); / / göra knappen 5 grejer.
}
//
Räknas detta som en knapptryckning när rensat.
om (btn_read == 0 & & btn_pressed == 6) {
btn_pressed = 0; / / rensa registret
btn_6(); / / göra knappen 6 grejer.
}
//
}
//
//
/////////////////////////////////
KNAPPEN KONFIGURERA RUTIN / /
/////////////////////////////////
//
//**********
Rutinen att få värdena och gör ett utbud för knapparna.
Rutinen körs en gång innan den viktigaste loopen.
Knappar på analog linje 0
Knapparna kan användas i valfri ordning.
//
void btn_config() {
Konfigurera knapparna på raden analoga A0
//
lcd_set = 1; / / LCD linje två
lcd_line_clear; / / tydlig linje av LCD-
//
lcd_set = 0; / / LCD linje en
lcd_line_clear(); / / tydlig linje av LCD-
lcd_set = 0; / / redan gjort utan att behöva upprepa
lcd_line(); / / Skriv till LCD-linje
Delay(5);
Visa knappen Config på fodra en
lcd_Z = 14. / / config-knappen
lcd_N = 24; / / skicka alla 24 tecken
lcd_char();
Delay(10000); / / ge tid att läsa
//
//
6 knappar = 6 slingor runt.
//
för (looping = 0; looping < 6; looping ++) {
btn_btn(); / / testa knappar
btn_number ++; / / öka på knappen för att testa genom att 1.
}
//
btn_number == 1; / / ändra till 1 när du är klar.
//
}
//
////////////////
btn_btn / /
////////////////
//
//**********
Rutin för att berätta vilken knapp att trycka på
//
void btn_btn() {
Testa knappar
lcd_set = 0; / / LCD linje en
lcd_line();
Delay(5);
//
lcd_Z = 15. / /
lcd_N = 6; / / skicka 6 tecken = Press_
lcd_char();
lcd_Z = 14. / /
lcd_N = 7; / / skicka 7 tecken = Button_
lcd_char();
//
lcd_A = btn_number; / / startar på knapp 1
tens_out(); / / skicka siffran
//
Delay(5000); / / ge tid att läsa
//
btn_read = analogRead(A0); / / knappar på analoga 0
//
lcd_set = 0; / / LCD linje en
lcd_line();
Delay(5);
//
lcd_Z = 16. / / config-knappen
lcd_N = 8; / / skicka 8 tecken = Release_
lcd_char();
lcd_Z = 14. / / config-knappen
lcd_N = 7; / / skicka 7 tecken = Button_
lcd_char();
lcd_A = btn_number; / / startar på knapp 1
tens_out(); / / skicka siffran
//
Delay(5000); / / ge tid att läsa.
//
lcd_set = 0; / / Line en
lcd_line_clear(); / / Clear LCD-linjen
//
Testa resultat
Knappen var god gå här
om (btn_read > 0) {
btn_copy = btn_number; / / göra en kopia. Det var bra
btn_con_fig();
Göra saker om det var en bra läsning
//
lcd_line(); / / redan set för linje 1
Delay(5);
//
lcd_Z = 14. / / config-knappen
lcd_N = 7; / / skicka 7 tecken = Button_
lcd_char();
lcd_A = btn_number; / / startar på knapp 1
tens_out(); / / skicka siffran
lcd_Z = 18; / / String för "Set"
lcd_N = 4; / / skicka 4 tecken = _Ange
lcd_char(); / / skicka det
//
//
}
//
//
Testa resultat
Knappen kunde inte gå här
om (btn_read < = 50) {
btn_copy = (btn_number + 6); / / knappen arbetar på + 6
att hoppa över de bra avläsningarna och göra dåliga
btn_con_fig();
Göra saker om det var en dålig behandling
//
lcd_line(); / / redan set för linje 1
Delay(5);
//
lcd_Z = 14. / / String för Button_
lcd_N = 7; / / skicka 7 tecken = Button_
lcd_char();
lcd_A = btn_number; / / startar på knapp 1
tens_out(); / / skicka siffran
lcd_Z = 17; / /
lcd_N = 7; / / skicka 7 tecken = _Failed
lcd_char();
//
}
btn_read = 0; / / rensa den sista analoga behandlingen
Delay(5000); / /
//
lcd_set = 0; / / Line en
lcd_line_clear(); / / Clear LCD-linjen
//
}
//
////////////////////
btn_con_fig / /
////////////////////
//
//**********
Rutin som sätter knappen spänner att titta på.
//
void btn_con_fig() {
//
Nummer 1-6 är för bra läsning
Nummer 7-12 är för dålig Läs
//
växel (btn_copy) {
fall 0: / / inga nummer ska vara noll. fel
bryta; / / Kick härifrån
//
fall 1: / / knappen nummer 1 var bra
btn_1hi = (btn_read + 2); / / gör om korrekt anpassning
btn_1lo = (btn_read - 2); / / gör om korrekt anpassning
bryta;
//
fall 2: / / knappen nummer 2 var bra
btn_2hi = (btn_read + 2); / / gör om korrekt anpassning
btn_2lo = (btn_read - 2); / / gör om korrekt anpassning
bryta;
//
fall 3: / / knappen nummer 3 var bra
btn_3hi = (btn_read + 2); / / gör om korrekt anpassning
btn_3lo = (btn_read - 2); / / gör om korrekt anpassning
bryta;
//
fall 4: / / knappen nummer 4 var bra
btn_4hi = (btn_read + 2); / / gör om korrekt anpassning
btn_4lo = (btn_read - 2); / / gör om korrekt anpassning
bryta;
//
fall 5: / / knappen nummer 5 var bra
btn_5hi = (btn_read + 2); / / gör om korrekt anpassning
btn_5lo = (btn_read - 2); / / gör om korrekt anpassning
bryta;
//
mål 6: / / knappen nummer 6 var bra
btn_6hi = (btn_read + 2); / / gör om korrekt anpassning
btn_6lo = (btn_read - 2); / / gör om korrekt anpassning
bryta;
//
////////////////////
Dålig knappar / /
////////////////////
//
fall 7: / / knappen nummer 1 var dålig
btn_1hi = 100; / / belastning falskt tal så att knapparna inte
btn_1lo = 100; / / lag felaktigt
bryta;
//
mål 8: / / knappen nummer 2 var dålig
btn_2hi = 100; / / belastning falskt tal så att knapparna inte
btn_2lo = 100; / / lag felaktigt
bryta;
//
mål 9: / / knappen nummer 3 var dålig
btn_3hi = 100; / / belastning falskt tal så att knapparna inte
btn_3lo = 100; / / lag felaktigt
bryta;
//
mål 10: / / knappen nummer 4 var dålig
btn_4hi = 100; / / belastning falskt tal så att knapparna inte
btn_4lo = 100; / / lag felaktigt
bryta;
//
mål 11: / / knappen nummer 5 var dålig
btn_5hi = 100; / / belastning falskt tal så att knapparna inte
btn_5lo = 100; / / lag felaktigt
bryta;
//
ärende 12: / / knappen nummer 6 var dålig
btn_6hi = 100; / / belastning falskt tal så att knapparna inte
btn_6lo = 100; / / lag felaktigt
bryta;
//
}
}
//
//
//
//