Arduino vihiku harjutuste lahendused

/*
Nimetus: Näide #1.1 Digitaalsed sisend-väljundid
Kirjeldus: Nuppu korraks vajutades vilgub LED 3 korda
*/
// Konstandid
const int nupp = A0; // Viik kuhu on ühendatud nupp
const int led = 13; // Viik kuhu on ühendatud roheline LED
// Globaalsed muutujad
int nupuOlek = 0; // Nupu oleku muutuja ja algväärtustamine
 
void setup() { 
  pinMode(led, OUTPUT); // algväärtustame LED viigu väljundiks 
  pinMode(nupp, INPUT_PULLUP); // algväärtustame nupu viigu sisendiks ja aktiveerime sisemise pull-up takisti
}
 
void loop(){
  nupuOlek = digitalRead(nupp); // salvestame muutujasse nupu hetke väärtuse
  if (nupuOlek == LOW) { // Kui nupu on alla vajutatud
    for(int i = 0; i < 3; i++){
      digitalWrite(led, HIGH); // süütame LED-i
      delay(200); //viide led põlemas hoidmiseks
      digitalWrite(led, LOW); //  kustutame LED-i
      delay(200); //viide led kustus hoidmiseks
    }
  }
}

NB! LED vilkumisel on sees pikad viited, mistõttu vilkumise välja lülitamiseks tuleb lülitit pikemalt all hoida.

/*
Nimetus: Näide #1.2 Digitaalsed sisend-väljundid
Kirjeldus: LED vilkumise sisse/välja lülitamine lülitiga
*/
// Konstandid
const int nupp = A0; // Viik kuhu on ühendatud nupp
const int led = 13; // Viik kuhu on ühendatud roheline LED
// Globaalsed muutujad
bool vilguta = false; //muutuja vilgutamise sisse välja lülitamiseks
 
void setup() { 
  pinMode(led, OUTPUT); // algväärtustame LED viigu väljundiks 
  pinMode(nupp, INPUT_PULLUP); // algväärtustame nupu viigu sisendiks ja aktiveerime sisemise pull-up takisti
}
 
// Algus identne näitega #1.1
void loop(){
  if(digitalRead(nupp) == LOW){ //kontrolli kas lülitit on vajutatud
    vilguta = !vilguta; //inverteerime vilgutamise muutuja, et vilkumine sisse/välja lülitada
    delay(50); //kontaktide värelemise viide (debounce)
    while(digitalRead(nupp) == LOW); //ootab kuni nupp lastakse lahti
  }
 
  if (vilguta == 1) { // Kui nupu olek on madal 
    delay(1000); //led kustus hoidmise viide
    digitalWrite(led, HIGH); // süütame LED-i 
    delay(1000); // led põlemas hoidmise viide
  } 
  digitalWrite(led, LOW); // kustutame LED-i 
}

/*
  Nimetus: Näide #1.3 Digitaalsed sisend-väljundid
  Kirjeldus: Iga nupu vajutusega vilgub LED aina rohkem kordi
*/
// Konstandid
const int nupp = A0; // Viik kuhu on ühendatud nupp
const int led = 13; // Viik kuhu on ühendatud roheline LED
// Globaalsed muutujad
int nupuVajutusi = 0;
 
void setup() {
  pinMode(led, OUTPUT); // algväärtustame LED viigu väljundiks
  pinMode(nupp, INPUT_PULLUP); // algväärtustame nupu viigu sisendiks ja aktiveerime sisemise pull-up takisti
}
 
void loop() {
  if (digitalRead(nupp) == LOW) { // kontrollib kas nupu olek on madal
    nupuVajutusi++; //liidame ühe muutuja väärtusele
    delay(50); //lüliti kontaktide värelemise (debounce) efekti mõju vähendamiseks väike viide
    while (digitalRead(nupp) == LOW) { //tsükkel jätkub lõputult kuni nupu olek on madal
      // Ootame nupu lahtilaskmist
    }
    for(int i = 0; i < nupuVajutusi*2;i++){
      digitalWrite(led, !digitalRead(led)); // LED viigu väljund inverteeritakse kasutades viigu hetke olekut
      delay(200); //viide, et hoida led kustus/põlemas
    }
    delay(50); //lüliti kontaktide värelemise (debounce) efekti mõju vähendamiseks väike viide
  }
}

/*
Nimetus: Näide #2.1 LED juhtimine potentsiomeetriga 
Kirjeldus: Potentsiomeetri pööramisel üle etteantud piiri süttib LED
*/
const int pote = A0; // määrame potentsiomeetri ühendusviigu (sisend)
const int led = 13; // määrame LED ühendusviigu (väljund)
int poteOlek = 0; // muutuja potentsiomeetri väärtuse salvestamiseks
 
void setup() {
  //mikrokontrolleri viigud on tavaolekus sisendid
  pinMode(led, OUTPUT); // algväärtustame LED viigu väljundiks
}
void loop() {
  poteOlek = analogRead(pote); // loeme anduri väärtuse
  if(poteOlek >= 1023 || poteOlek <= 0)digitalWrite(led, HIGH); // kustutame LED-i
  else digitalWrite(led, LOW); // süütame LED-i
}

/*
Nimetus: Näide #2.2 LED juhtimine potentsiomeetriga
Kirjeldus: Potentsiomeetri asendist sõltub LED vilkumise sagedus
*/
 
const int pote = A0; // määrame potentsiomeetri ühendusviigu (sisend)
const int led = 13; // määrame LED ühendusviigu (väljund)
const int fikseeritud_viide = 512;
int poteOlek = 0; // muutuja potentsiomeetri väärtuse salvestamiseks
 
void setup() {
  //mikrokontrolleri viigud on tavaolekus sisendid
  pinMode(led, OUTPUT); // algväärtustame LED viigu väljundiks
}
void loop() {
  poteOlek = analogRead(pote); // loeme anduri väärtuse
  digitalWrite(led, HIGH); // kustutame LED-i
  if(poteOlek > 512) delay(1023 - poteOlek); // tekitame viite <poteOlek> millisekundit
  else delay(fikseeritud_viide); // tekitame viite <poteOlek> millisekundit
  digitalWrite(led, LOW); // süütame LED-i
  if(poteOlek < 512) delay(poteOlek); // tekitame viite <poteOlek> millisekundit
  else delay(fikseeritud_viide); // tekitame viite <poteOlek> millisekundit
}

/*
  Nimetus: Näide #2.3 LED juhtimine potentsiomeetriga
  Kirjeldus: Potentsiomeetri asendi muutuse kiiruse järgi LED heleduse reguleerimine
*/
 
//Konstandid
const int pote = A0; // määrame potentsiomeetri ühendusviigu (sisend)
const int led = 13; // määrame LED ühendusviigu (väljund)
const int maxLoendurVaartus = 150;
//Globaalsed muutujad
int poteOlek = 0;
int viimanePoteOlek = 0;
int kiirus = 0;
int loendur = 0;
 
void setup() {
  //mikrokontrolleri viigud on tavaolekus sisendid
  pinMode(led, OUTPUT); // algväärtustame LED viigu väljundiks
}
void loop() {
  poteOlek = analogRead(pote); // loeme anduri hetkeväärtuse
  //Arvutame kiiruse anduri hetkeväärtuse ja eelneva väärtuse lahutustehtena
  //Olenevalt kumb pidi potentsiomeetri liigutab on vaja ka tehe teha ühte
  //või teistpidi, et ei tekiks negatiivset arvu
  if(poteOlek > viimanePoteOlek) kiirus = poteOlek - viimanePoteOlek;
  else  kiirus = viimanePoteOlek - poteOlek;
 
  if(kiirus > 100) kiirus = 100; //piirab kiiruse väärtuse ära, et ei tekiks negatiivset viidet
  //kui potentsiomeetr ei liigu, siis võib siiski analoog-digitaal muunduri müra tõttu led tuhmilt põleda.
  //Selle olukorra eemaldamiseks seame minimaalse kiiruse väärtuse, millest alates LED põlema võib minna
  if(kiirus > 5){ 
    digitalWrite(led, HIGH); // süütab LED-i
    delayMicroseconds(kiirus); // hoia LED põlemas kiiruse väärtusega võrdne arv mikrosekundeid 
  }
  digitalWrite(led, LOW); //kustutab LED-i
  delayMicroseconds(100 - kiirus); // hoia LED kustus 100st mikrosekundist ülejäänud arv mikrosekundeid
 
  //Kuna PWM signaali ehk LED heleduse reguleerimiseks peab loop() tsükkel võimalikult kiirelt töötama,
  //siis ei saa lisanduvaid viiteid lubada, et led põleks võimalikult stabiilselt. Samas potentsiomeetri 
  //hetke väärtuse ja eelneva väärtuse uuendamise vahe on liiga väike, et tekiks adekvaatne kiiruse väärtus.
  //Probleemi lahenduseks on kasutatud viite tekitamiseks muutuja suurendamise meetodit, mis jõudes ette
  //antud väärtuseni teeb tegevuse ja nullib loenduri.
  loendur++; //suurenda muutujat loendur ühe võrra
  if(loendur >= maxLoendurVaartus){
    viimanePoteOlek = poteOlek; //uuenda eelmise potentsiomeetri väärtust
    loendur = 0; // nulli loendur
  }
}

/*
Nimetus: Näide #3.1 16x2 tähemärgilise LCD kasutamine
Kirjeldus:Kasutab LiquidCrystal.h teeki ja 2x16 täheärgilist LCD laiendusplaati
*/
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
 
// Initsialiseerime LCD koos vastavate viikude ühendamisega
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
void setup() {
  lcd.begin(16, 2); //Määrame LCD read ja veerud
  lcd.print("  Tere Tallinn! "); // Trükime tervitusteksti
}
void loop() {
  lcd.setCursor(7, 1); //Viime kursori teisele reale seitsmendale veerule (2. rida on indeksiga 1)
  lcd.print(millis()/1000); //Trükime loenduri väärtuse
}

#include <LiquidCrystal.h>
 
// initialize the library
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
//Erikujuliste tähemärkide 2-dimensiooniline massiiv
byte symbolid[8][8] = {
  {0b00100,0b00100,0b00000,0b00000,0b00000,0b00100,0b01110,0b10101},
  {0b00100,0b00000,0b00000,0b00000,0b00100,0b01110,0b10101,0b00100},
  {0b00000,0b00000,0b00000,0b00100,0b01110,0b10101,0b00100,0b00100},
  {0b00000,0b00000,0b00100,0b01110,0b10101,0b00100,0b00100,0b00000},
  {0b00000,0b00100,0b01110,0b10101,0b00100,0b00100,0b00000,0b00000},
  {0b00100,0b01110,0b10101,0b00100,0b00100,0b00000,0b00000,0b00000},
  {0b01110,0b10101,0b00100,0b00100,0b00000,0b00000,0b00000,0b00100},
  {0b10101,0b00100,0b00100,0b00000,0b00000,0b00000,0b00100,0b01110}};
 
void setup()
{
  for(int i = 0; i < 8; i++) lcd.createChar(i,symbolid[i]); // tekitab eriskujulised tähemärgid
  lcd.begin(16, 2); // seadistab ekraani suuruse
}
void loop()
{
  //tsükkel kuva järjest kõik 8 tekitautd erikujulist tähemärki
  for(int i = 0; i < 8; i++){
      lcd.setCursor(0,0); // seadistab kursori positsioon veerule 0 ja reale 0
      for(int k = 0; k < 16; k++) lcd.write((uint8_t)i); //kuvab erikujulise tähemärgid kogu esimesele reale
      lcd.setCursor(0,1); // seadista kursori positsioon veerule 0 ja reale 1
      for(int k = 0; k < 16; k++) lcd.write((uint8_t)i); // kuvab erikujulise tähemärgi kogu teisele reale
      delay(100); //viide et tähemärgid LCD-l ei uueneks liiga kiirelt
  }
}

/*
Nimetus: Harjutus #3.3 16x2 tähemärgilise LCD kasutamine
Kirjeldus: Kasutab LiquidCrystal.h teeki ja ITEAD Studio 2x16 LCD teksti laiendusplaati
*/
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //tekitame objekti ja seome vastavad ühendusviigud sellega
 
//defineerime lihtsustamiseks konstandi igale nupule
#define nuppRIGHT  0
#define nuppUP     1
#define nuppDOWN   2
#define nuppLEFT   3
#define nuppSELECT 4
#define nuppNONE   5
 
int vajutatudNupp, nupuSisend, positsioon = 0;
int rida = 0, veerg = 0;
 
void setup() {
  lcd.begin(16, 2); //Määrame LCD read ja veerud
  lcd.print("ADC: "); //Trükime analoogsisendi väärtuse
  lcd.print(analogRead(A0));
}
void loop() {
  vajutatudNupp = kontrolliNuppe(); //võtab analoog mõõtmise ja võrdleb ette antud väärtustega
  //kontrollib kas mõni nupp on alla vajutatud 
  if(vajutatudNupp < 5){
    lcd.clear(); //puhastab ekraani ja liigutab kursori tagasi algasendisse
    //vastavalt vajutatud nupule muuda kursori asukohta enne teksti trükkimist ekraanile
    if(vajutatudNupp == 0) veerg =8;
    if(vajutatudNupp == 1) rida = 0;
    if(vajutatudNupp == 2) rida = 1;
    if(vajutatudNupp == 3) veerg = 0;
    lcd.setCursor(veerg, rida); //sead kursori positsiooni LCD-l
    lcd.print("ADC: "); //teksti kuvamine ekraanil
    lcd.print(nupuSisend); //muutuja väärtuse kuvamine ekraanil
    delay(200); //lühike viide, et ekraanil väärtust liiga kiirelt ei uuendataks
  }
}
//Funktsioon võtab analoog sisendi väärtuse ja võrdleb olemasolevate väärtustega.
//Tagastab arvu vahemikus 0 kuni 5 vastavalt defineeritud konstandile
int kontrolliNuppe()
{
 nupuSisend = analogRead(A0); //võtab analoog väärtuse viigult A0.    
 if (nupuSisend < 50)   return nuppRIGHT; //parem nupp
 if (nupuSisend < 195)  return nuppUP; //ülemine nupp
 if (nupuSisend < 380)  return nuppDOWN; //alumine nupp
 if (nupuSisend < 555)  return nuppLEFT; //vasak nupp
 if (nupuSisend < 790)  return nuppSELECT; //valiku nupp  
 return nuppNONE;  // kui ühtegi nuppu pole vajutatud, siis tagastatakse nuppNONE
}

/*
Nimetus: Näide #3 ...
Kirjeldus: 
*/
// Kaasame vajalikud teegid
#include <LiquidCrystal.h> 
#include <math.h>
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // Initsialiseerime LCD koos vastavate viikude ühendamisega
 
const int pote_sisend = A1;  // määrame potentsiomeetri sisendviigu
const int NTC_sisend  = A2;  // määrame temperatuurianduri sisendviigu
const int led   = 10;  // määrame LED ühendusviigu
const int nupp  = A0;  // määrame nupu ühendusviigu
 
// Globaalsed muutujad
int pote = 0; 
long ntc = 0;
double temperatuur = 0;
int seade = -1;
 
void setup() 
{
  pinMode(led, OUTPUT); //Seadistame LED viigu väljundiks 
  pinMode(nupp, INPUT); //Algväärtustame nupu viigu sisendiks 
 
  lcd.begin(16, 2); //Määrame LCD read ja veerud
  //Kuvame ekraanile esialgse seade väärtuse
  lcd.setCursor(0, 1); lcd.print("Seade:    ");
  lcd.setCursor(7, 1); lcd.print(seade);
}
 
void loop() 
{
  //Loeme potensiomeetri väärtuse ja teisendame vahemikku -20 kuni 100
  pote = map(analogRead(pote_sisend),0,1023,-20,100);
  ntc = analogRead(NTC_sisend); //Loeme temperatuuri anduri väärtuse
 
  //Teisendame temperatuurianduri väärtuse temperatuuriks
  temperatuur = log(((10240000/ntc) - 10000));
  temperatuur = 1/(0.001129148 + (0.000234125 + (0.0000000876741 * temperatuur * temperatuur))* temperatuur);
  temperatuur = temperatuur - 273.15; //Konverteeri Kelvinid Celciustesse
 
  //Kuvame informatsiooni LCD ekraanile
  lcd.setCursor(0, 0);  lcd.print("Pot:    ");
  lcd.setCursor(4, 0);  lcd.print(pote);
  lcd.setCursor(8, 0);  lcd.print("Tmp:    ");
  lcd.setCursor(12, 0); lcd.print(temperatuur);
 
  //Kui nupule vajutatakse, salvesta seadesuurus
  if(digitalRead(nupp) == LOW)
  {
    seade = pote;
    lcd.setCursor(0, 1); lcd.print("Seade:    ");
    lcd.setCursor(7, 1); lcd.print(seade);
  }
 
  // Kui temperatuur on kõrgem potensiomeetriga seatud väärtusest ja nuppu pole alla vajutatud
  if((temperatuur > seade) && (digitalRead(nupp) == HIGH))
  {
    digitalWrite(led, HIGH); //Süütame LED-i
  }
  else 
  {
    digitalWrite(led, LOW); //Vastasel korral kustutame LED-i
  }
}

/*
Nimetus: Näide #3.2 Kaugusandurite lugemine
Kirjeldus: Kaugusandurite lugemine
*/
#include <LiquidCrystal.h> //Kaasame vajaliku teegi
 
// Initsialiseerime LCD koos vastavate viikude ühendamisega
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
//Määrame andurite ühendusviigud
const int analoogAndur = A2;
const int digiAndur = A3;
int analoogAndurVaartus, digitaalAndurVaartus;
 
void setup() 
{ 
  lcd.begin(16, 2); //Määrame LCD read ja veerud
  //kirjutame ekraanile selgitavad tekstid
  lcd.print("Analoog:");
  lcd.setCursor(0, 1);
  lcd.print("Digi:");
} 
void loop() 
{ 
  analoogAndurVaartus = analogRead(analoogAndur); //Loeme analoog kaugusanduri väärtuse
  // https://acroname.com/articles/linearizing-sharp-ranger-data
  analoogAndurVaartus = (6787/(analoogAndurVaartus-3)-4); //valemi järgi lineariseerimine ja konverteerimine sentimeetriteks
  digitaalAndurVaartus = digitalRead(digiAndur); //Loeme digitaalse lähedusanduri väärtuse
  lcd.setCursor(9, 0); //Nihutame kursori esimesele reale positsioonile 9
  lcd.print(analoogAndurVaartus); //Trükime ekraanile analoog anduri väärtuse
  lcd.print("   "); //Kirjutame üle järgnevad kolm ruutu tühikutega, et vana lugemi väärtus ei jääks näha
  lcd.setCursor(9, 1); //Nihutame kursori teisele reale positsioonile 9
  lcd.print(digitaalAndurVaartus); //Trükime ekraanile digitaal anduri väärtuse
  delay(200); // Lühike viide, et tekst ekraanil oleks loetav
}