Arduino UNO V3 programkód

Itt megtalálja a könyvhöz tartozó összes programkódot

 

 

A könyvet megvásárolhatja az ePubli-ról:

https://www.epubli.de/preview/130629

 

Mert az ePubli előnézete nem működik túl jól – sajnálom, alacsony szénhidráttal vagy minek hívják ezeket a vegetáriánusokat, ehhez semmi közöm – itt egy kivonat:

 

Arduino1_részlet

 

Programletöltések (gépelés nem)

Arduino

 

Bennfenteseknek (Jelszóval védett)

Buch

 

Videók:

 

 

 

 

A kiemelés, a tökéletes óra (Ezt a tökéleteset most felejtsd el, benne van 100 év kb. 2 másodperc különbség)

/*
7-Szegmens LED kijelző piros
—A—
| |
F B
| |
—G—
| |
E C
| |
—D—

*/
//———————————————————- A nyilatkozat —————————————————————-
//Határozza meg a kijáratokat
#határozza meg A 6
#határozza meg B-t 5
#definiáld C-t 4
#meghatározott 3
#határozza meg E 2
#határozza meg az F-t 1
#határozza meg G 0
#határozza meg a DP-t 7 // Decimalpunk
#definiálja a közös_katódot 0
#definiálja a közös_anódot 1
bool segMode = közös_katód; // Negatív vagy pozitív reprezentáció (LCD vagy LED), a kijelző típusától függően (közös_katód vagy közös_anód)
ne feledd[] {A,B,C,D,E,F,G,DP}; // Szegmens-csapok 6 – 0
bájt karakter = 35; // A következő tömb karaktereinek száma

bájt karakterek[35][9] {
{‘0',1,1,1,1,1,1,0,0}, //0
{‘1’,0,1,1,0,0,0,0,0}, //1
{"2",1,1,0,1,1,0,1,0}, //2
{"3",1,1,1,1,0,0,1,0}, //3
{‘4’,0,1,1,0,0,1,1,0}, //4
{"5",1,0,1,1,0,1,1,0}, //5
{"6",1,0,1,1,1,1,1,0}, //6
{"7",1,1,1,0,0,0,0,0}, //7
{"8",1,1,1,1,1,1,1,0}, //8
{‘9’,1,1,1,1,0,1,1,0}, //9
{‘a’,1,1,1,0,1,1,1,0},//A/10
{"b",0,0,1,1,1,1,1,0},//b/11
{"c",1,0,0,1,1,1,0,0},//C/12
{'d',0,1,1,1,1,0,1,0},//d/13
{"e",1,0,0,1,1,1,1,0},//E/14
{"f",1,0,0,0,1,1,1,0},//F/15
{"g",1,0,1,1,1,1,0,0},//G/16
{"h",0,1,1,0,1,1,1,0},//H/17
{'én',0,0,0,0,1,1,0,0},//I/18
{"j",0,1,1,1,1,0,0,0},//J/19
{‘én’,0,0,0,1,1,1,0,0},//L/20
{'n',0,0,1,0,1,0,1,0},//n/21
{'o',0,0,1,1,1,0,1,0},//o/22
{"p",1,1,0,0,1,1,1,0},//P/23
{'q',1,1,1,0,0,1,1,0},//q/24
{"r",0,0,0,0,1,0,1,0},//r/25
{„s”,1,0,1,1,0,1,1,0},//Az S/26 számnak tűnik 5
{"t",0,0,0,1,1,1,1,0},//t/27
{"u",0,1,1,1,1,1,0,0},//U/28
{'i',0,1,1,1,0,1,1,0},//y/29
{‘-’,0,0,0,0,0,0,1,0},//-/30
{‘.’,0,0,0,0,0,0,0,1},//./31
{‘]',1,1,1,1,0,0,0,0},//]/32
{‘[‘,1,0,0,1,1,1,0,0},//[/33
{‘_’,0,0,0,1,0,0,0,0},//_/34
};

unsigned long time_in_milliseconds = 0; //Zeitváltozó Millisben
unsigned long time_correction_millis = 0; //Korrekciós változó, az Arduino UNO óta kb azután 50 Napok a millis() tovább 0 visszaállítja
unsigned int plus_hours = 0; // Az idő beállítása aktuális időre
unsigned int plus_minutes = 0; // Időbeállítás az aktuális idő korrekciós percekre
unsigned int plus_seconds = 0; // Időbeállítás az aktuális idő korrekciós másodpercre
unsigned int plusz_ezredmásodperc = 0; // Időbeállítás az aktuális időre Korrekciós ezredmásodperc
aláíratlan óra = 0; // órákat az időért
aláíratlan perc perc = 0; // perc az idő
előjel nélküli int másodperc = 0; // másodperc az időért
előjel nélküli int ezredmásodperc = 0; // ezredmásodperc pl. stopperóra
char időbélyeg = “23:59:59:999”; // Összeállított időbélyeg
int x; // Funkcióhívás a globális idő beállításához
//const int kulcs[] = {8,9,10,11,12,13}; //Munka 0 a jobb szélen van
int count = 0;
long stay_on = 0;
unsigned long time_reset_key = 0;
int seg_pin[] = {8,9,10,11,12,13}; //Block-Nr, a következőket tartalmazza 2 számjegyek (7-szegmens hirdetéseket)
//int ziff_nr[] = {12,13}; //számjegyű szám 1 = elöl, 2 = hátsó
int key_analog_pin = A0;
int analóg_érték; //átadás áfás
int display_mode; //Választ, mi jelenik meg:
//0 = óra, 1 = korrekciós óra, 2 = korrekciós percek, 3 = korrekciós másodperc,
//4 = Edzett 5 = fény és mások (Kimenet 0 – 1024
//—————————————————— Nyilatkozat vége —————————————————-

//——————————————————– Inicializálás ——————————————————-
üres beállítás() {
// Határozza meg a tűket OUTPUT-ként
pinMode(maguk[0],KIMENET);
pinMode(maguk[1],KIMENET);
pinMode(maguk[2],KIMENET);
pinMode(maguk[3],KIMENET);
pinMode(maguk[4],KIMENET);
pinMode(maguk[5],KIMENET);
pinMode(maguk[6],KIMENET);
pinMode(maguk[7],KIMENET);
pinMode(seg_pin[0],KIMENET);
pinMode(seg_pin[1],KIMENET);
pinMode(seg_pin[2],KIMENET);
pinMode(seg_pin[3],KIMENET);
pinMode(seg_pin[4],KIMENET);
pinMode(seg_pin[5],KIMENET);

}
//—————————————————— Inicializálás befejezése ————————————————

//—————————————————— fő program ————————————————

üres hurok() {

x = get_time('összes'); // Töltse ki az összes globális változót
x = get_analog_value(); //kapja meg az analóg értéket
ha (display_mode == 0) {
Nyomtatás_Két_számjegy(órák, “órák”, hamis);
Nyomtatás_Két_számjegy(percek, “percek”, hamis);
Nyomtatás_Két_számjegy(másodpercig, “másodpercig”, hamis);
}

ha (display_mode == 4) {
x = skála_hőmérséklet();
x = nyomtatás_megjelenítésre(x);
}
ha (display_mode == 5) {
x = nyomtatás_megjelenítésre(analóg_érték); //visszaadja az analóg bemenet értékét
//x = nyomtatás_megjelenítésre(123456); //Teszt-karakterlánc, ha problémái lennének
}

ha (display_mode == 1) {
x = Nyomtatás_Két_számjegy(plusz_óra, “órák”, hamis);
}

ha (display_mode == 2) {
x = Nyomtatás_Két_számjegy(plusz_percek, “percek”, hamis);
}

ha (display_mode == 3) {
x = Nyomtatás_Két_számjegy(plusz_másodperc, “másodpercig”, hamis);
}

//Ellenőrizze a kulcs állapotát
x = change_analog_key_status();

}
//—————————————————— A főprogram vége ————————————————

//———————————————————- Funkciók ——————————————————
void setState(bool mód){ //Karakterek megjelenítése mód módban, azaz pozitív vagy negatív
számára(int i = 0;én<=6;i++)
{
digitalWrite(maguk[én],mód);
}
}

 

érvénytelen Nyomtatás(hogy vajon) // Kimenet a 7 szegmenses kijelzőre
{
setState(segMode);//Kapcsolja ki a szegmenst

ha(sz > karakterek || sz < 0 )// Ha a szám ill. a karakter nincs meghatározva…
{
számára(int i = 0;én <= 6;i++)
{
digitalWrite(maguk[én],MAGAS);
késleltetés(100);
digitalWrite(maguk[én],ALACSONY);
}
számára(int i = 0;én <= 2;i++)
{
késleltetés(10);
setState(MAGAS);
késleltetés(10);
setState(ALACSONY);
}
}más // másképp, ha jel vagy. szám meghatározott, akkor költsön
{
ha(segMode == 0){ //…ennek megfelelően adja ki a segMode-ot (pozitív vagy negatív)
számára(int i = 0;én<8;i++){
digitalWrite(maguk[én],Karakterek[sz][i+1]);
}

//Kontrast vagy How-To-Works
x = kontraszt(sz);

//Egyértelmű
számára(int i = 0;én<8;i++){
digitalWrite(maguk[én],ALACSONY);
}
}
más{
//setState(MAGAS);
számára(int i = 0;én<8;i++){
digitalWrite(maguk[én],!Karakterek[sz][i+1]);
digitalWrite(maguk[én],MAGAS);
}
}
}
}

kontraszt vagy(hogy vajon){
//A számok következetes megjelenítése, 7 és 1 csak néhány LED világít
ha (szám == 1 || szám == 7){
késleltetés(1);
Visszatérés;
}
késleltetés(3);

}

int Nyomtatás_Két_számjegy(int two_digits_wert, char mód[], logikai one_szegmens){
// modus = “semmi” –> nem jelenik meg az üzemmód
// mód = “órák”, “percek”, “másodpercig” megjelenik a kijelző előtt, melyik értéket adjuk ki
int digit_links = 0;
int digit_right = 0;
int modus_char = 30;
int seg_pin_out = 0; //A kimenet tűje

//Megjelenítés mód, ha megfelelt //h megjelenítése
ha (modus == “órák”) {
mode_char = 17;
seg_pin_out = seg_pin[4]; //Az első szegmens aktiválása
}
ha (modus == “percek”) { //Perelni, mivel m nem jeleníthető meg
mode_char = 21;
seg_pin_out = seg_pin[2];
}
ha (modus == “másodpercig”) { //mutat s
mode_char = 26;
seg_pin_out = seg_pin[0];
}

//Hirdetés megosztása 2 számjegyekkel feljebb
ha (two_digits_wert >= 10) {
digit_links = two_digits_wert / 10;
digit_right = két_számjegy_érték – digit_links * 10;
} más {
digit_right = két_számjegy_érték;
}

x = clear_all_seg();

//Két szám megjelenítése egy 7 szegmenses kijelzőn
ha (one_segment == igaz) { //Csak megjelenítés, ha csak egy számjegy jelenik meg
Nyomtatás(mode_char);
késleltetés(500);
}
digitalWrite(seg_pin_out + 1,MAGAS);
Nyomtatás(digit_links);
ha (one_segment == igaz) {
késleltetés(1000);
}
digitalWrite(seg_pin_out + 1,ALACSONY);

digitalWrite(seg_pin_out,MAGAS);

Nyomtatás(digit_right);

ha (one_segment == igaz) {
késleltetés(1000);
}
digitalWrite(seg_pin_out,ALACSONY);

//üres ill. Pont
ha (one_segment == igaz) {
digitalWrite(seg_pin_out,MAGAS);
Nyomtatás(31);
késleltetés(1000);
}
}

int clear_all_seg() {
digitalWrite(seg_pin[0] ,ALACSONY);
digitalWrite(seg_pin[1] ,ALACSONY);
digitalWrite(seg_pin[2] ,ALACSONY);
digitalWrite(seg_pin[3] ,ALACSONY);
digitalWrite(seg_pin[4] ,ALACSONY);
digitalWrite(seg_pin[5] ,ALACSONY);
}

int get_time(char mód[]) {
//korrekciós rutin, mert az Arduino UNO kb azután 50 Napok a millis() tovább 0 visszaállítja
//time_correction_millis = check_if_reset_time(time_in_imliseconds);
idő_ezredmásodpercben = millis() + time_in_millis(plusz_óra,”órák”) + time_in_millis(plusz_percek,”percek”) + time_in_millis(plusz_másodperc,”másodpercig”) + plusz_ezredmásodperc + time_correction_millis; // Töltse be az aktuális processzoridőt, beleértve a. javítás
óra = konvertálási_idő(time_in_imliseconds,”24_órák”);
perc = konvertálási_idő(time_in_imliseconds,”60_percek”);
másodperc = konvertálási_idő(time_in_imliseconds,”60_másodperc”);

visszatérési órák;
}

unsigned long time_in_millis(long time_value, char calc_modus[]) {
//átváltási tényező
hosszú t_millis = 0; //Alapértelmezés szerint ugyanazt az értéket adja vissza

ha (calc_modus == “órák”) {
// Átalakítsa az órákat ezredmásodpercekre
t_millis = idő_érték * 60 * 60 * 1000;
}
ha (calc_modus == “percek”) {
// A perceket ezredmásodpercekre konvertálja
t_millis = idő_érték * 60 * 1000;
}
ha (calc_modus == “másodpercig”) {
// A perceket ezredmásodpercekre konvertálja
t_millis = idő_érték * 1000;
}

return t_millis;
}

unsigned in convert_time(aláíratlan hosszú t_millis,char conv_modus[]) {
//Konvertálja az időt ezredmásodpercben módba: „napok” megjelölése, órák’ '24 óra', percek’ '60_perc', másodpercig’ '60_seconds', ‘millis’ ‘1000_millis’
// 60_ vagy. 1000_ csak az idő specifikációját adja vissza, ami helyes egy órára, szintén z.B. másodperc között 0 – 59

aláíratlan hosszú napok_tmp;
aláíratlan hosszú órák_tmp;
aláíratlan hosszú percek_tmp;
unsigned long seconds_tmp;
unsigned long conv_return; //visszatérési értéket

// napi óra max. 23 (:59:59:999)
ha (conv_modus == “órák”) {
conv_return = t_millis / 1000 / 60 / 60;
//Visszatérés 17; //vissza h
return conv_return;
}

ha (conv_modus == “percek”) {
conv_return = t_millis / 1000 / 60;
//Visszatérés 21; //m bzw. Visszatérés n percre
return conv_return;
}

ha (conv_modus == “másodpercig”) {
conv_return = t_millis / 1000;
//Visszatérés 26; //s másodpercig
return conv_return;
}

ha (conv_modus == “millis”) {
return t_millis;
}

ha (conv_modus == “napok”) {
conv_return = t_millis / 24 / 1000 / 60 / 60;
return conv_return;
}

ha (conv_modus == “24_órák”) { //Csak az aktuális órát adja vissza
days_tmp = konvertálási idő(t_millis, “napok”);
conv_return = t_millis – days_tmp * 24 * 1000 * 60 * 60;
conv_return = konvertálási_idő(conv_return,”órák”);
return conv_return;
}

ha (conv_modus == “60_percek”) { //Csak az aktuális perceket adja vissza
hours_tmp = konvertálási idő(t_millis, “órák”);
conv_return = t_millis – órák_tmp * 1000 * 60 * 60;
conv_return = konvertálási_idő(conv_return,”percek”);
return conv_return;
}

ha (conv_modus == “60_másodperc”) {
perc_tmp = konvertálási idő(t_millis,”percek”);
conv_return = t_millis – perc_tmp * 1000 * 60;
conv_return = konvertálási_idő(conv_return, “másodpercig”);
return conv_return;
}

ha (conv_modus == “1000_millis”) {
seconds_tmp = konvertálási idő(t_millis,”másodpercig”);
conv_return = t_millis – seconds_tmp * 1000;
conv_return = konvertálási_idő(conv_return, “millis”);
return conv_return;
}

Visszatérés 14; // E hiba miatt / kimeneti hibák

}

aláíratlan hosszú check_if_reset_time (unsigned long last_time_in_millis){
unsigned long time_correction = 0;

ha (last_time_in_millis > millis()) { //Ha Millis fel 0 halasztották
//Bővítési megjegyzés: Eltérés lehet az ezredmásodperces tartományban!!!!
time_correction = get_day_millis(last_time_in_millis);

//korrekciós idők 0 Visszaállítás, mert a korrekció benne van az idő_javításban
plusz_óra = 0;
plusz_perc = 0;
plusz_másodperc = 0;
plusz_ezredmásodperc = 0;

return time_correction;

} más {
return time_correction_millis; //Ha nincs korrekció, majd a meglévő korrekciót adja vissza értékként
}
}

unsigned long get_day_millis(unsigned long t_millis_total){
// Távolítsa el a teljes napokat 86 400 000 ezredmásodperc
long millis_pro_tag = 24 * 60 * 60 * 1000;
int egész_napok = t_millis_összesen / millis_pro_tag – 0.5; //Kerek egész napra, 40.5 napok tennék 41, is – 0.5. 40 a napok ilyenek lesznek 39.5 és fel fog állni 40 kerekítve
long millis_whole_days = teljes_napok * millis_pro_tag;
Visszatérés (t_millis_total – millis_egész_napok); //A visszatérési idő ezredmásodpercében a megkezdett naptól

}

logikai kulcs_lenyomva(int k_pin){
ha (digitalRead(k_pin) == ALACSONY) { //A gomb nincs megnyomva
ha (számol > 200) {
szám = 0;
maradj_on = 0;
}

} más { //Ha megnyomja a gombot, Pin kulcs[] magas / 5 Volt
maradj_on = 1;
számolni = számolni + 1;
time_reset_key = millis();
}

ha (time_reset_key + 1000 < millis()) {
szám = 0;
maradj_on = 0;
digitalWrite(3, ALACSONY);
}

ha (maradj_on == 2) {
digitalWrite(3, MAGAS);
vissza hamis; //Ha a gombot már megnyomta, Visszapattanás elnyomása és False visszaállítása
}

ha (maradj_on == 1) {
//digitalWrite(2, MAGAS);
maradj_on = 2;
igaznak adja vissza;
} más {
//digitalWrite(2, ALACSONY);
vissza hamis;
}

}

int get_analog_value() {
analóg_érték = analógRead(key_analog_pin); // Vannak 1024 értékek vissza (0 nincs áram – 1023 5V)
az analóg_értéket adja vissza; //A parancsikon visszatérési értéke, hanem globálisan is elérhető az analóg_értékben

}

int print_to_display(hosszú kimeneti_érték){
//a Print_Two_Digits használatával mindegyiket kinyomtathatja 6 Számjegyek
//Nyomtatás_Két_számjegy(órák, “órák”, hamis);
//Nyomtatás_Két_számjegy(percek, “percek”, hamis);
//Nyomtatás_Két_számjegy(másodpercig, “másodpercig”, hamis);

int jobb_két_számjegy;
int közép_két_számjegy;
int bal_két_számjegy;

//különítse el a bal oldali két számjegyet
x = kimeneti_érték / 100;
jobb_két_számjegy = kimeneti_érték – x * 100;

//különítse el a jobb oldali két számjegyet
bal_két_számjegy = kimeneti_érték / 10000;

//maradék elkülönítése = középső két számjegy
közép_két_számjegy = kimeneti_érték – bal_két_számjegy * 10000 – jobb_két_számjegy; //például 3200 32, még át kell menni 100 megosztani
mid_két_számjegy = közép_két_számjegy / 100;

//Nyomtatás_Két_számjegy(bal_két_számjegy, “órák”, hamis);
//Nyomtatás_Két_számjegy(közép_két_számjegy, “percek”, hamis);
//Nyomtatás_Két_számjegy(jobb_két_számjegy, “másodpercig”, hamis);

Nyomtatás_Két_számjegy(bal_két_számjegy, “órák”, hamis);
Nyomtatás_Két_számjegy(közép_két_számjegy, “percek”, hamis);
Nyomtatás_Két_számjegy(jobb_két_számjegy, “másodpercig”, hamis);

}

int change_analog_key_status() {

//A kettős támadások megelőzése, ha röviden analóg_érték == 0
ha (analóg_érték == 0) {
ha (maradni < 2 && maradni > 0) {
késleltetés(200);
maradj_on = maradj_on + 1;
Visszatérés;
} más {
maradj_on = 0;
}
}

//Falls SET-Taste, majd módot váltani
ha (analóg_érték > 1005 && maradj_on == 0) {
maradj_on = 1;
display_mode = display_mode + 1;
ha (megjelenítési mód > 5) {
display_mode = 0;
}
}

//A SET módtól függően változik
ha (analóg_érték > 600 && analóg_érték < 800 && maradj_on == 0) {
maradj_on = 1;

//helyes idő
ha (display_mode == 1) {
plusz_óra = plusz_óra + 1;
késleltetés(200);
ha (plusz_óra >= 23) {
plusz_óra = 0;
}
}
ha (display_mode == 2) {
plusz_perc = plusz_perc + 1;
késleltetés(200);
ha (plusz_percek >= 59) {
plusz_perc = 0;
}
}
ha (display_mode == 3) {
plusz_másodperc = plusz_másodperc + 1;
késleltetés(200);
ha (plusz_másodperc >=59) {
plusz_másodperc = 0;
}
}
}
}

int skála_hőmérséklet() {
//az értékek itt skálázhatók

belső hőm;
temp = analóg_érték / 3;
visszatérő hőm;
}

//———————————————————- végfunkciók —————————————————