Stap 21: Mijn programma
/*11-11-2012 ray McQueen
LCD-regel 1 dag en tijd
LCD regel 2 temp lezingen
6 knoppen op analoge A0
Elke activering van de knop verandert op de achterkant licht gedurende 2 minuten.
Het koele deel over de config knop is die
een knop kan worden ingesteld op knop 1, 2, 3, 4, 5 of 6.
LM335 en LM334Z temp sensoren worden gebruikt.
De verschuiving van de temperatuur is instelbaar.
*/
//
//
Const int
//
Const int lcd_datapin = 6; 74HC164 pin 1
Const int lcd_clk = 5; 74HC164 pin 8
Const int lcd_E = 4; LCD E lijn
Const int lcd_RS = 3; LCD RS lijn
Const int licht = 2; / / rug lichtopbrengst
//
Analoge spullen
//
A0-knoppen
A1 - On board temp sensor.
A2 - binnen temp sensor.
A3 - buiten temp sensor.
//
//
KLOK STUFF
GEEN NEGATIEVE GETALLEN
unsigned long time_begin;
unsigned long time_duration;
unsigned long time_remain;
unsigned long time_val;
unsigned int time_seconds = 0; / / het aantal seconden worden opgeslagen
unsigned int time_minutes = 0; / / het aantal minuten wordt opgeslagen. De
klok zal beginnen om het aantal minuten hier opgeslagen op reset.
unsigned int time_hours = 12; / / het aantal uren worden opgeslagen. De klok
begint om het aantal uren rust hier opgeslagen.
unsigned int time_days = 0; / / het aantal dagen worden opgeslagen
Gebruikt voor de tot nu toe op een bepaalde gebeurtenis.
unsigned int event_seconds1 = 0; / / opslag van seconden tellen
//
//
LCD spullen
//
int lcd_C = 0; Teken worden verlegd
int lcd_D = 0; Teken worden verlegd
int lcd_N = 0; Aantal tekens te sturen naar lcd
int lcd_i = 0; Gebruikt voor de looping
int lcd_set = 0; / / gebruikt voor het opslaan van welke instelling te krijgen
int lcd_A = 0; / / gebruikt voor het kiezen van de aray te gebruiken
int lcd_Z = 0; Gebruikt in LCD-char testen
//
//
Gebruikt door cracker
//
int val1000s = 0; / / registreren om 1000 graaf
int val100s = 0; / / Registreer om 100 tellen
int val10s = 0; / / registreren om te houden van 10 tellen
int val1s = 0; / / registreren voor 1 telling
int test_test = 0; / / Registreer voor het opslaan van nummer voor testen/tijd ook
//
Gebruikt voor sensor lezingen
float sensor = 0; / / opslag voor sensor niveau
int kopie = 0; / / kopiëren van wat ik doe er in / tijd ook
//
int back_lit = 0; / / achtergrondverlichting in- / uitschakelen
//
//
//
KNOP STUFF
int btn_read = 0; / / lezen van de analoge lijn
int btn_read2 = 0; / / kopiëren van de lezing
int btn_pressed = 0; / / knop werd ingedrukt
int btn_number = 1; / / Allways start met knop #1
int btn_copy = 0; / / kopiëren van knop voor con_fig.
int looping = 0; / / voor mijn lussen
//*****************
Het bereik van het boven- en onderlimiet van een analoge waarde van knoppen Opslaan
//
int btn_1hi; / / knop #1 hoog bereik
int btn_1lo; / / knop #1 laag bereik
int btn_2hi; / / toets #2 hoog bereik
int btn_2lo; / / toets #2 laag bereik
int btn_3hi; / / knop #3 hoog bereik
int btn_3lo; / / knop #3 laag bereik
int btn_4hi; / / knop #4 hoog bereik
int btn_4lo; / / knop #4 laag bereik
int btn_5hi; / / knop #5 hoog bereik
int btn_5lo; / / knop #5 laag bereik
int btn_6hi; / / knop #6 hoog bereik
int btn_6lo; / / knop #6 laag bereik
//
//
int offset_sensor_1 = 257; / / Start offset op 2,57 volt = LM334Z
int offset_sensor_2 = 273; / / Start offset op 2.73 volt
int offset_sensor_3 = 273; / / Start offset op 2.73 volt
int offset_A = 0; / / 0 = geen aanpassingen.
1 = sensor 1 aanpassen.
2 = sensor 2 aanpassen.
3 = sensor 3 aanpassen.
LM335 2.73 volt output bij nul graden C
LM334Z ongeveer 2,57 volt output bij nul graden C
//
//
MATRICES ***
Matrices telling begint bij 0 niet 1 en gaat omhoog
//
16-24 karakter 2 regel lcd
int aray_set_up [] {} =
56 12, 6, 1}; LCD setup tekens
//
Start locaties voor het LCD-scherm
int aray_lines [] {} =
132 = 5e teken vanaf de linkerkant beginpositie, lijn 1
196 = 5e teken vanaf de linkerkant beginpositie, lijn 2
128 = lijn1
192 = lijn 2
128, 192, 132, 196};
//
Maakt gebruik van een leeg in de eerste plaats om niet weergeven
voorgaande nullen.
int aray_hunds [] {} =
' ', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
"0" in de eerste bent zodat weergeven
elke precceding nul
int aray_tens [] {} =
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', };
//
De eerste array zodat ik de naam op het LCD-scherm aan begin opgemaakt kan
Matrix wordt alleen weergegeven aan het begin van.
lcd_Z = welke array te gebruiken
int aray0 [] {} =
'F', 'u', 'n', ' ', 'S', 'h', 'w', 'a', 'y', ' ', 'D', 'i', 's', 'p', 'l', 'a', 'y', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
//
Slechts 4 van deze tekens worden verzonden maar zijn links op 5, dus geen lopen meer dan
int aray1 [] {} =
' ', 'I', 'n', ' ', ' ' };
Slechts 4 van deze tekens worden verzonden maar zijn links op 5, dus geen lopen meer dan
int aray2 [] {} =
'O', 'u', 't', ' ', ' ' };
Laat hieronder voor lege cellen
int aray3 [] {} =
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
Nog niet gebruikt
int aray4 [] {} =
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
Het word tijd
int aray5 [] {} =
'T', 'i', 'm', 'e', ' ' };
Nog niet gebruikt
int aray6 [] {} =
' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' , ' ', ' ', ' ', ' ', ' ', ' ' };
//
MATRICES VOOR DE DAGEN VAN DE WEEK
//
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', ' ', ' ', ' ' };
//
ARRAYS VOOR KNOP 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, OUTPUT); Definiëren als output
pinMode (lcd_clk, OUTPUT); Definiëren als output
pinMode (lcd_E, OUTPUT); Definiëren (de E-lijn) als output
pinMode (lcd_RS, OUTPUT); Definiëren (RS lijn) als output
pinMode (lichtopbrengst,); Definiëren (achtergrondlicht) als output
//
digitalWrite (lcd_E, hoge); / / lcd bedieningsleiding hoge brengen
digitalWrite (lcd_RS, hoge); / / lcd bedieningsleiding hoge brengen
//
digitalWrite (light, laag); / / inschakelen van de achterkant licht voor weergave
//
LCD setup
lcd_init(); / / initialiseren van het LCD-scherm voor gebruik
//
lcd_set = 0; / / eerste lijn
lcd_line();
delay(5);
Toegevoegd, zodat de regel met beeldschermen opstart scherm ***
Het toont alleen deze ene keer aan het begin van ***
//
lcd_Z = 0; / / LCD line één tekenreeks
lcd_N = 24; / / sturen alle 24 tekens
lcd_char();
//
delay(10000); / / vertraging 10 seconden zodat ik kan zien de programmanaam.
//
Wis de LCD regel voordat naar het schrijven, dus er is geen links over
lcd_set = 0; / / LCD lijn een
//
lcd_line_clear(); / / Hiermee wist u de lcd-lijn naar lege cellen
//
//
De knoppen op de analoge lijn configureren
Dit wordt gedaan eens eerder hoofdlus
//
btn_config(); / / knop configuratie routine.
//
digitalWrite (light, hoge); / / uitzetten van de achterkant licht voor weergave
event_seconds1 = 0; / / duidelijk de gebeurtenis seconden registreren.
back_lit = 0; / / Clear het terug licht register.
//
/////////////////
EINDE VAN DE SET UP / /
/////////////////
//
}
//
////////////////////////
BEGIN MAIN LOOP / /
////////////////////////
//
//
void loop {}
//
Moet gebeuren aan het begin van de klok recht op werk.
time_begin = millis(); / / plaatsen aan het begin
//
lcd_timeDisp(); / / de dag en de tijd weergeven op lijn 1
//
lcd_tempDisp(); / / Display de temp in/out op lijn 2
//
//**************************
DOEN TIJD DINGEN TE UPDATE REGISTERS
//
time_val = (time_remain + time_duration);
Als de tijd door (interval) is minder dan een seconde
het houden optellen.
Als (time_val < 1000) {}
time_remain = time_val;
}
Als de tijd door (interval) is meer dan een seconde
uit hoeveel seconden tellen.
Als (time_val > = 1000) {}
terwijl (time_val > = 1000) {}
time_val = time_val - 1000;
time_seconds ++;
event_seconds1 ++; / / event_seconds1 verhogen door een
}
time_remain = time_val;
}
//
Als (time_seconds > = 60) {}
time_minutes ++; / / verhoging minuten door een
time_remain = (time_remain + 1); / / toegevoegde voor tijd teek verlies na verloop van tijd.
time_seconds = (time_seconds - 60);
}
Als (time_minutes > = 60) {}
time_hours ++; / / verhoogd met 1
time_minutes = (time_minutes - 60);
}
Als (time_hours > = 24) {}
time_days ++; / / verhoogd met 1
time_hours = (time_hours - 24);
}
Als (time_days > = 7) {}
time_days = (time_days - 7);
}
//
//
Controleer om te zien als een knop wordt ingedrukt.
Geen ontdendering werd berokkend in het maken van dit programma.
//
btn_read = analogRead(A0);
Als (btn_read > 50 & & back_lit == 0) {}
digitalWrite (light, laag); / / schakelen de achterkant licht voor een
knop activeren. Dont elke knopacties nog.
event_seconds1 = 0; / / Clear de seconden gebeurtenis generator.
back_lit = 1; / / de volgende druk op de knop is geldig om iets te doen.
delay(2000); / / voordat op zoek naar een andere knop ingedrukt.
//
}
//
//
btn_read = analogRead(A0); / /
Als (btn_read > 50 & & back_lit == 1) {}
//
Geldige lezing is iets grote dan 50.
Een geldige lezing en achtergrondlicht = 1 hiervoor de knop spullen.
50 is mijn out van bereik (uitschakelen) instellen voor slechte knoppen.
Een knop wordt ingedrukt.
button_pressed (); //Figure komen tot welke rechtbank
}
Controleer om te zien als een knop wordt uitgebracht.
btn_read = analogRead(A0); / /
Als (btn_read == 0 & & back_lit == 1) {}
Knop werd uitgebracht.
button_released(); / / erachter te komen welke
}
//
Timer voor het uitschakelen van de achtergrondverlichting
Als (event_seconds1 > = 120) {}
digitalWrite (light, hoge); / / uitzetten van de achtergrondverlichting.
back_lit = 0; / / Clear register voor LCD-achtergrondverlichting.
offset_A = 0; / / Clear register compenseren temps.
}
//
//
delay(100); / / voor stabiliteit
//
//************************************
DIT GAAT AAN HET EIND VAN MAIN LOOP
Fout corrigeert als millis rolt
Gewoon beide lezingen op 0 ingesteld en opnieuw gestart.
Als (millis() < time_begin) {}
time_duration = 0; / / plaats aan het einde
time_begin = 0; / / plaats aan einde
}
//
Als (millis() > time_begin) {}
time_duration = (millis() - time_begin) ;// plaats aan het einde
}
//
/////////////////////////
EIND VAN MAIN LOOP / /
/////////////////////////
//
}
//
//
//
//
//
//*********************
BEGIN ROUTINES **
//*********************
//
//
/////////////////////
LCD-ROUTINES / /
/////////////////////
//
//
De routine voor het initialiseren van het LCD-scherm.
//
ongeldig lcd_init() {}
digitalWrite (lcd_E, laag); / / Clear E lijn
digitalWrite (lcd_RS, laag); / / Clear RS lijn
delayMicroseconds(125); / / langere vertraging dan nodig maar werkt
voor (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 om te kiezen welke info lijn moet worden weergegeven op.
lcd_set = 0 voor regel een.
lcd_set = 1 voor lijn twee.
lcd_set moet worden ingesteld voordat de heenreis.
//
ongeldig lcd_line() {}
lcd_C = (aray_lines[lcd_set]); aray_lines [lcd_set] als lcd_set = 0 = lijn een
aray_lines [lcd_set] als lcd_set = 1 = lijn twee.
digitalWrite (lcd_E, laag); Lagere E lijn
digitalWrite (lcd_RS, laag); Onderste regel van de RS
delayMicroseconds(125); Kleine vertraging
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_C);
E_line();
digitalWrite (lcd_RS, hoge);
delayMicroseconds(125);
}
//
//**********
De routine voor het verzenden van tekenreeksen aan de weergave.
lcd_N moet worden geladen met het aantal tekens te sturen
voordat je hier.
//
ongeldig lcd_char() {}
lcd_D = 0;
//
Lcd_N voor het te verzenden aantal tekens aanpassen
voor (lcd_i = 0; lcd_i < lcd_N; lcd_i ++) {}
//
schakelaar (lcd_Z) {}
geval van 0: / / 1e char string Fun_Shway_Display
lcd_A = (aray0[lcd_D]);
breken;
geval 1: / / 2e char string _In_
lcd_A = (aray1[lcd_D]);
breken;
geval 2: / / 3e char string Out_
lcd_A = (aray2[lcd_D]);
breken;
Case 3: / / 4e char tekenreeks gebruikt voor lege cellen
lcd_A = (aray3[lcd_D]);
breken;
geval 4: / / 5e char string nog niet gebruikt. lege cellen.
lcd_A = (aray4[lcd_D]);
breken;
geval 5: / / 6de char string Time_
lcd_A = (aray5[lcd_D]);
breken;
kast 6: / / 7e char string nog niet gebruikt. Lege cellen.
lcd_A = (aray6[lcd_D]);
breken;
geval 7: / / 8ste char tekenreeks. Mon_
lcd_A = (aray7[lcd_D]);
breken;
geval 8: / / 9th char tekenreeks. Tue_
lcd_A = (aray8[lcd_D]);
breken;
zaak 9: / / 10de char tekenreeks. Wed_
lcd_A = (aray9[lcd_D]);
breken;
zaak 10: / / 11th char tekenreeks. Thu_
lcd_A = (aray10[lcd_D]);
breken;
geval 11: / / 12th char tekenreeks. Fri_
lcd_A = (aray11[lcd_D]);
breken;
geval 12: / / 13 char tekenreeks. Sat_
lcd_A = (aray12[lcd_D]);
breken;
zaak 13: / / 14e char tekenreeks. Sun_
lcd_A = (aray13[lcd_D]);
breken;
geval 14: / / 15e char tekenreeks. Button_Config. _
lcd_A = (aray14[lcd_D]);
breken;
geval 15: / / 16e teken van de tekenreeks. Press_
lcd_A = (aray15[lcd_D]);
breken;
geval 16: / / 17e char tekenreeks. Release_
lcd_A = (aray16[lcd_D]);
breken;
kast 17: / / 18e char tekenreeks. _Failed_
lcd_A = (aray17[lcd_D]);
breken;
kast 18: / / 19e char tekenreeks. _Set_
lcd_A = (aray18[lcd_D]);
breken;
}
//
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_A);
E_line();
lcd_D = lcd_D + 1;
}
}
//
//**********
Routine is voor het testen uit het register.
lcd_A moet zijn ingesteld op wat moet worden verzonden voordat je hier
lcd_A kan = val1000s of val100s
thous_out resulteert in een leeg als het eerste getal = 0
//
ongeldig thous_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, aray_hunds[lcd_A]);
E_line();
//
}
//
//**********
Routine is voor het testen uit het register.
lcd_A moet worden ingesteld voordat de heenreis.
lcd_A kan = val10s of val1s
tens_out leidt tot een nul als het eerste getal = 0
//
ongeldig tens_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, aray_tens[lcd_A]);
E_line();
//
}
//
//**********
Routine voor het verzenden van afzonderlijke tekens naar het LCD-scherm
voorbeeld ":" gebruikt in de scheiding van uren van minuten
//
ongeldig car_out() {}
shiftOut (lcd_datapin, lcd_clk, MSBFIRST, lcd_A); deze optie is ingesteld op
E_line();
//
}
//
//**********
Routine te doen van de E-lijn van het LCD-scherm
//
VOID E_line() {}
digitalWrite (lcd_E, hoge);
delayMicroseconds(1);
digitalWrite (lcd_E, laag);
delayMicroseconds(125);
}
//
//**********
Routine te sturen van lege cellen naar het LCD-scherm.
lcd_set moet worden ingesteld voordat de heenreis.
lcd_set = 0; //lcd lijn een
lcd_set = 1; //lcd lijn twee
//
ongeldig lcd_line_clear() {}
Wis de lcd regel vóór het schrijven naar het
lcd_line();
delay(5);
//
lcd_Z = 3; / / ruimten karakter string
lcd_N = 24; / / sturen alle 24 tekens
lcd_char();
delay(5);
//
}
//
//**********
De routine voor het weergeven van de tijd op het LCD-scherm.
Tijd wordt weergegeven op de eerste regel.
//
ongeldig lcd_timeDisp() {}
//
lcd_set = 0; / / LCD lijn een
lcd_line();
delay(5);
//
lcd_Z = (time_days + 7); / / String voor dag van de week
Plus 7 is te springen over de tekenreeksen niet dagen
lcd_N = 4; / / sturen 4 tekens = dag plus ruimte
lcd_char();
//
test_test = time_hours; / / Maak een kopie voor het testen
cracker(); / / Break out uur
//
lcd_A = val10s; / / nu houdt de 10s in het uur
thous_out(); / / Stuur een blanco als geen tientallen
//
lcd_A = val1s; / / nu houdt de 1s in het uur
tens_out(); / / het aantal 1s in uur verzenden
//
//
lcd_A = ':'; / /
car_out(); / / Stuur een eigen karakter
//
//
test_test = time_minutes; / / Maak een kopie voor het testen
cracker(); / / Break out minuten.
//
lcd_A = val10s; / / nu houdt de 10s in de notulen.
tens_out(); / / het aantal 10s sturen in de notulen.
//
lcd_A = val1s; / / nu houdt de 1s in de notulen.
tens_out(); / / het aantal 1s verzenden in de notulen.
//
lcd_A = ""; / / Voeg een spatie toe
car_out(); / / Stuur een eigen karakter.
//
test_test = offset_A; / / Maak een kopie voor het testen.
cracker(); Register uitbreken.
//
lcd_A = val1s; / / nu houdt de sensor # wordt aangepast.
thous_out(); / / Stuur een blanco als geen sensor niet wordt aangepast.
//
}
//
//**********
Routine om de temperaturen op het LCD-scherm weer te geven.
Temp wordt op de tweede regel weergegeven.
//
ongeldig lcd_tempDisp() {}
//
//
lcd_set = 1; //LCD lijn twee
lcd_line();
delay(5);
//
lcd_Z = 1; / / binnen de tekenreeks
lcd_N = 4; / / verzenden slechts 4 tekens
lcd_char();
delay(5);
//
De waarde van te krijgen binnen de temp sensor op analoge lijn 2
sensor = analogRead(A2); / /
Ik ben weergeven in graden F
Het lijkt erop dat dit met geen offset
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; / / niet geïnteresseerd in cijfers achter komma.
//
cracker wordt gebruikt na iedere lezing op alle analoge lijnen
te maken van de lezing, zodat het kan worden weergegeven op het LCD
cracker(); / / converteren van de lezing
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
lcd_A = ""; / / geeft een spatie
car_out(); / / stuurt eigenheid in plaats van een tekenreeks
//
lcd_Z = 2; / / buiten tekenreeks
lcd_N = 4; / / verzenden slechts 4 tekens
lcd_char();
delay(5);
//
Krijgen de waarde van de buiten temp sensor op analoge lijn 3
sensor = analogRead(A3);
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_3) * 1.8) + 32);
//
test_test = sensor; / / niet geïnteresseerd in cijfers achter komma.
//
cracker wordt gebruikt na iedere lezing op alle analoge lijnen
om de lezing zodat het kan worden weergegeven op de LCD.
cracker(); / / converteren van de lezing
//
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();
//
Krijgen de waarde van aan boord van de temp sensor op analoge lijn 1
sensor = analogRead(A1); / / krijgen de waarde van analoge lijn 1
sensor = (((sensor * (5.0/1023.0)) * 100)-offset_sensor_1) * 1.8) + 32);
//
test_test = sensor; / / niet geïnteresseerd in cijfers achter komma.
//
cracker wordt gebruikt na iedere lezing op alle analoge lijnen
te maken van de lezing, zodat het kan worden weergegeven op het LCD
cracker(); / / converteren van de lezing.
//
lcd_A = val100s;
thous_out();
//
lcd_A = val10s;
tens_out();
//
lcd_A = val1s;
tens_out();
//
//
}
//
////////////////
CRACKER / /
////////////////
//
//**********
Routine breekt getallen in iets dat kan worden weergegeven
op het LCD-scherm.
test_test moeten een kopie van wat te kraken voordat je hier.
//
ongeldig cracker() {}
//
Test 1000s
val1000s = 0; / / duidelijk 1000 registreren
terwijl (test_test > = 1000) {}
test_test = test_test - 1000;
val1000s ++;
}
Test 100s
val100s = 0; / / Clear 100 register
terwijl (test_test > = 100) {}
test_test = test_test - 100;
val100s ++;
}
Test 10s
val10s = 0; / / Clear 10 register
terwijl (test_test > = 10) {}
test_test = test_test - 10;
val10s ++;
}
Rest is de 1
val1s = test_test;
//
Einde testen
Het getal dat is opgeslagen in test_test is nu gebroken worden
uit in vier register
val1000s = het aantal duizenden in het test-nummer
val100s = het aantal honderden in het test-nummer
val10s = het nummer van de trans-Europese netwerken in het test-nummer
val1s = rest, het aantal enen in het nummer
//
}
//
//
///////////////////////////////
KNOPPEN OP ANALOGE LIJN / /
///////////////////////////////
//
//**********
Routine te knop 1 spullen.
//
ongeldig btn_1() {}
time_days = (time_days + 1);
delay(100);
}
//
//**********
Routine te 2 dingen knop.
//
ongeldig btn_2() {}
time_hours = (time_hours + 1);
delay(100);
}
//
//**********
Routine te knop 3 spullen.
//
ongeldig btn_3() {}
time_minutes = (time_minutes + 1);
delay(100);
}
//
//**********
Routine te knop 4 spullen.
//
ongeldig btn_4() {}
schakelaar (offset_A) {}
geval van 0: / / Offset was 0
offset_A = 1; / / maakt het sensor 1
breken;
geval 1: / / Offset was 1
offset_A = 2; / / maakt het sensor 2
breken;
geval 2: / / Offset was 2
offset_A = 3; / / maakt het sensor 3
breken;
Case 3: / / Offset was 3
offset_A = 0; / / maken 0 = geen aanpassing van de sensor.
breken;
}
}
//
//**********
Routine te 5 dingen knop.
Sensor offsets vergroten
ongeldig btn_5() {}
//
Als (offset_A == 1) {}
offset_sensor_1 ++; / / verhoging van de verschuiving voor de meetcel 1
}
//
Als (offset_A == 2) {}
offset_sensor_2 ++; / / verhoging van de verschuiving voor sensor 2
}
//
Als (offset_A == 3) {}
offset_sensor_3 ++; / / verhoging van de verschuiving voor sensor 3
}
//
}
//
//**********
Routine te knop 6 spullen.
Verlagen sensor offsets.
ongeldig btn_6() {}
//
Als (offset_A == 1) {}
offset_sensor_1--; / / afname van de verschuiving voor de meetcel 1
}
//
Als (offset_A == 2) {}
offset_sensor_2--; / / afname van de verschuiving voor sensor 2
}
//
Als (offset_A == 3) {}
offset_sensor_3--; / / afname van de verschuiving voor sensor 3
}
//
}
//
//
////////////////////////
Ingedrukte knop / /
////////////////////////
//
//**********
Routine voor wanneer een knop wordt ingedrukt.
De knop wordt niet gerekend tot vrijgegeven.
//
ongeldig button_pressed() {}
//
btn_read2 = (btn_read) ;// Maak een kopie van de lezing voor het testen
//
Als de knop waarden tussen bepaalde liggen niveaus die
is gelijk aan de knop.
Knop waarden verworven van btn_config
//
Als (btn_read > = btn_1lo & & btn_read2 < = btn_1hi) {}
btn_pressed = 1; / / 1 in register = knop 1 werd ingedrukt
}
//
Als (btn_read > = btn_2lo & & btn_read2 < = btn_2hi) {}
btn_pressed = 2; / / 2 in register = knop 2 werd ingedrukt
}
//
Als (btn_read > = btn_3lo & & btn_read2 < = btn_3hi) {}
btn_pressed = 3; / / 3 in register = knop 3 werd ingedrukt
}
//
Als (btn_read > = btn_4lo & & btn_read2 < = btn_4hi) {}
btn_pressed = 4; / / 4 in register = knop 4 werd ingedrukt.
}
//
Als (btn_read > = btn_5lo & & btn_read2 < = btn_5hi) {}
btn_pressed = 5; / / 5 in register = 5 knop werd ingedrukt.
}
//
Als (btn_read > = btn_6lo & & btn_read2 < = btn_6hi) {}
btn_pressed = 6; / / 6 in register = 6 knop werd ingedrukt.
}
//
}
//
//
/////////////////////////
Knop uitgebracht / /
/////////////////////////
//
//**********
Routine voor wanneer een knop wordt losgelaten.
Dit is wanneer de gebeurtenis van de knop wordt uitgevoerd
//
ongeldig button_released() {}
Telt dit als een knooppers na verrekening.
Als (btn_read == 0 & & btn_pressed == 1) {}
btn_pressed = 0; / / Clear van het register
btn_1(); / / Do van de knop 1 spullen.
}
//
Telt dit als een knooppers na verrekening.
Als (btn_read == 0 & & btn_pressed == 2) {}
btn_pressed = 0; / / Clear van het register
btn_2(); / / Do toets 2 dingen.
}
//
Telt dit als een knooppers na verrekening.
Als (btn_read == 0 & & btn_pressed == 3) {}
btn_pressed = 0; / / Clear van het register
btn_3(); / / Do van de knop 3 spullen.
}
//
Telt dit als een knooppers na verrekening.
Als (btn_read == 0 & & btn_pressed == 4) {}
btn_pressed = 0; / / Clear van het register
btn_4(); / / Do van de knop 4 spullen.
}
//
Telt dit als een knooppers na verrekening.
Als (btn_read == 0 & & btn_pressed == 5) {}
btn_pressed = 0; / / Clear van het register
btn_5(); / / Do van de knop 5 spullen.
}
//
Telt dit als een knooppers na verrekening.
Als (btn_read == 0 & & btn_pressed == 6) {}
btn_pressed = 0; / / Clear van het register
btn_6(); / / Do van de knop 6 spullen.
}
//
}
//
//
/////////////////////////////////
KNOP CONFIGUREREN ROUTINE / /
/////////////////////////////////
//
//**********
Routine om de waarden en het maken van een bereik voor de knoppen.
Routine wordt één keer voordat de hoofdlus uitgevoerd.
Knoppen op analoge lijn 0
Knoppen kan gebruikt worden in willekeurige volgorde.
//
ongeldig btn_config() {}
De knoppen op de analoge lijn A0 configureren
//
lcd_set = 1; / / LCD lijn twee
lcd_line_clear; / / Clear regel van de lcd
//
lcd_set = 0; / / LCD lijn een
lcd_line_clear(); / / Clear regel van de lcd
lcd_set = 0; / / reeds gedaan hoeft te herhalen
lcd_line(); / / Schrijf naar lcd regel
delay(5);
Knop Config op regel een
lcd_Z = 14; / / config knop
lcd_N = 24; / / sturen alle 24 tekens
lcd_char();
delay(10000); / / geven van tijd om te lezen
//
//
6 knoppen = 6 lussen rond.
//
voor (lus = 0; < 6; looping looping ++) {}
btn_btn(); / / testen van knoppen
btn_number ++; / / verhogen van de knop om te testen door 1.
}
//
btn_number == 1; / / terug ingesteld op 1 wanneer u klaar bent.
//
}
//
////////////////
btn_btn / /
////////////////
//
//**********
Routine om u te vertellen welke knop te drukken
//
ongeldig btn_btn() {}
Testen van knoppen
lcd_set = 0; / / LCD lijn een
lcd_line();
delay(5);
//
lcd_Z = 15; / /
lcd_N = 6; / / 6 tekens sturen = Press_
lcd_char();
lcd_Z = 14; / /
lcd_N = 7; / / sturen van 7 tekens = Button_
lcd_char();
//
lcd_A = btn_number; / / begint bij de knop 1
tens_out(); / / sturen het cijfer
//
delay(5000); / / geven van tijd om te lezen
//
btn_read = analogRead(A0); / / knoppen zijn op analoge 0
//
lcd_set = 0; / / LCD lijn een
lcd_line();
delay(5);
//
lcd_Z = 16; / / config knop
lcd_N = 8; / / verzenden van 8 tekens = Release_
lcd_char();
lcd_Z = 14; / / config knop
lcd_N = 7; / / sturen van 7 tekens = Button_
lcd_char();
lcd_A = btn_number; / / begint bij de knop 1
tens_out(); / / sturen het cijfer
//
delay(5000); / / geven van tijd om te lezen.
//
lcd_set = 0; / / lijn een
lcd_line_clear(); / / Wis de regel van de LCD-
//
Test resultaten
Knop was goed gaan hier
Als (btn_read > 0) {}
BTN_COPY = btn_number; / / maken van een kopie. Het was goed
btn_con_fig();
De dingen doen als het was een goede lezing
//
lcd_line(); / / reeds set voor lijn 1
delay(5);
//
lcd_Z = 14; / / config knop
lcd_N = 7; / / sturen van 7 tekens = Button_
lcd_char();
lcd_A = btn_number; / / begint bij de knop 1
tens_out(); / / sturen het cijfer
lcd_Z = 18; / / String voor "Set"
lcd_N = 4; / / sturen 4 tekens = _Set
lcd_char(); / / verzenden
//
//
}
//
//
Test resultaten
Knop mislukt gaan hier
Als (btn_read < = 50) {}
BTN_COPY = (btn_number + 6); / / de knop bezig met + 6
overslaan van de goede lezingen en doen de slechte
btn_con_fig();
De dingen doen als het was een slechte lezing
//
lcd_line(); / / reeds set voor lijn 1
delay(5);
//
lcd_Z = 14; / / String voor Button_
lcd_N = 7; / / sturen van 7 tekens = Button_
lcd_char();
lcd_A = btn_number; / / begint bij de knop 1
tens_out(); / / sturen het cijfer
lcd_Z = 17; / /
lcd_N = 7; / / sturen van 7 tekens = _Failed
lcd_char();
//
}
btn_read = 0; / / Clear de laatste analoge lezing
delay(5000); / /
//
lcd_set = 0; / / lijn een
lcd_line_clear(); / / Wis de regel van de LCD-
//
}
//
////////////////////
btn_con_fig / /
////////////////////
//
//**********
Routine waarin de knop bereiken om naar te kijken voor.
//
ongeldig btn_con_fig() {}
//
Nummer 1-6 zijn voor goed te lezen
Nummers 7-12 zijn voor slecht lezen
//
schakelaar (btn_copy) {}
geval van 0: / / geen getallen moeten nul. fout
breken; / / Kick out of here
//
geval 1: / / knop nummer 1 was goed
btn_1hi = (btn_read + 2); / / de juiste aanpassingen te maken
btn_1lo = (btn_read - 2); / / de juiste aanpassingen te maken
breken;
//
geval 2: / / knop nummer 2 was goed
btn_2hi = (btn_read + 2); / / de juiste aanpassingen te maken
btn_2lo = (btn_read - 2); / / de juiste aanpassingen te maken
breken;
//
Case 3: / / knop nummer 3 was goed
btn_3hi = (btn_read + 2); / / de juiste aanpassingen te maken
btn_3lo = (btn_read - 2); / / de juiste aanpassingen te maken
breken;
//
geval 4: / / knop nummer 4 was goed
btn_4hi = (btn_read + 2); / / de juiste aanpassingen te maken
btn_4lo = (btn_read - 2); / / de juiste aanpassingen te maken
breken;
//
geval 5: / / knop nummer 5 was goed
btn_5hi = (btn_read + 2); / / de juiste aanpassingen te maken
btn_5lo = (btn_read - 2); / / de juiste aanpassingen te maken
breken;
//
kast 6: / / knop nummer 6 was goed
btn_6hi = (btn_read + 2); / / de juiste aanpassingen te maken
btn_6lo = (btn_read - 2); / / de juiste aanpassingen te maken
breken;
//
////////////////////
Slechte knoppen / /
////////////////////
//
geval 7: / / knop nummer 1 was slecht
btn_1hi = 100; / / Load onwaar getallen zodat knoppen niet
btn_1lo = 100; / / foutief handelen
breken;
//
geval 8: / / knop nummer 2 was slecht
btn_2hi = 100; / / Load onwaar getallen zodat knoppen niet
btn_2lo = 100; / / foutief handelen
breken;
//
zaak 9: / / knop nummer 3 was slecht
btn_3hi = 100; / / Load onwaar getallen zodat knoppen niet
btn_3lo = 100; / / foutief handelen
breken;
//
zaak 10: / / knop nummer 4 was slecht
btn_4hi = 100; / / Load onwaar getallen zodat knoppen niet
btn_4lo = 100; / / foutief handelen
breken;
//
geval 11: / / knop nummer 5 was slecht
btn_5hi = 100; / / Load onwaar getallen zodat knoppen niet
btn_5lo = 100; / / foutief handelen
breken;
//
geval 12: / / knop nummer 6 was slecht
btn_6hi = 100; / / Load onwaar getallen zodat knoppen niet
btn_6lo = 100; / / foutief handelen
breken;
//
}
}
//
//
//
//
