====== Arduino koolituse harjutuste lahendused ======
 \\ 
 \\ 
 \\ 
 \\ 
 \\ 
 \\ 
 \\ 
====== Harjutus #1.1 ======
Modifitseerida näiteprogrammi nii, et nupule vajutades vilgub LED kolm korda
<code c>
/*
Nimetus: Harjutus #1.1 Digitaalsed sisend-väljundid
Kirjeldus: Modifitseerida programmi nii, et nupule vajutades vilgub LED kolm korda
Autor: Rain Ellermaa
Kuupäev: 05.06.2014
Versioon: 1.0
*/

// Konstandid
const int nupp = A0; // Viik kuhu on ühendatud nupp
const int rohelineLED = 13; // Viik kuhu on ühendatud nupp roheline LED 
// Globaalsed muutujad
int NupuOlek = 0; // Nupu oleku muutuja

void setup() 
{ 
  pinMode(rohelineLED, OUTPUT); // algväärtustame LED viigu väljundiks 
  pinMode(nupp, INPUT); // algväärtustame nupu viigu sisendiks 
  digitalWrite(nupp, HIGH); // turn on internal pull-up resistor on button pin
}

void loop()
{
  // Kui nupu olek on madal (GND) e nupp alla vajutatud
  if (digitalRead(nupp) == LOW) 
  {
    // Lihtne variant, kirjutame kolm korda üht sama asja 
    digitalWrite(rohelineLED, HIGH); // süütame LED-i 
    delay(500); // ootame 0.5 sekundi (500 millisekundit)
    digitalWrite(rohelineLED, LOW); // kustutame LED-i 
    delay(500); // ootame 0.5 sekundi (500 millisekundit)
    digitalWrite(rohelineLED, HIGH); // süütame LED-i 
    delay(500); // ootame 0.5 sekundi (500 millisekundit)
    digitalWrite(rohelineLED, LOW); // kustutame LED-i 
    delay(500); // ootame 0.5 sekundi (500 millisekundit)
    digitalWrite(rohelineLED, HIGH); // süütame LED-i 
    delay(500); // ootame 0.5 sekundi (500 millisekundit)
	digitalWrite(rohelineLED, LOW); // kustutame LED-i 
    delay(500); // ootame 0.5 sekundi (500 millisekundit)
    
    // Keeruline variant, kasutame tingimustsüklit, et korrata sama tegevust 3 korda
    for(int kordaja = 0; kordaja < 3; kordaja++)
    {
      digitalWrite(rohelineLED, HIGH); // süütame LED-i 
      delay(500); // ootame 0.5 sekundi (500 millisekundit)
      digitalWrite(rohelineLED, LOW); // kustutame LED-i 
      delay(500); // ootame 0.5 sekundi (500 millisekundit)
    }
    
  } 
}




</code>
====== Harjutus #1.2 ======

Modifitseerida näiteprogrammi nii, et nupule vajutades hakkab led konstantselt vilkuma 1 sek intervalliga ja teine nupule vajutus katkestab vilkumise
<code c>
/*
Nimetus: Harjutus #1.2 Digitaalsed sisend-väljundid
Kirjeldus: Modifitseerida programmi nii, et nupule vajutades hakkab led konstantselt 
           vilkuma 1 sek intervalliga ja teine nupule vajutus katkestab vilkumise
Autor: Rain Ellermaa
Kuupäev: 16.01.2013
Versioon: 1.0
*/

// Konstandid
const int nupp = A0; // Viik kuhu on ühendatud nupp
const int rohelineLED = 13; // Viik kuhu on ühendatud nupp roheline LED 
// Globaalsed muutujad
int VilkumiseOlek = 0; // Nupu oleku muutuja

void setup() 
{ 
  pinMode(rohelineLED, OUTPUT); // algväärtustame LED viigu väljundiks 
  pinMode(nupp, INPUT); // algväärtustame nupu viigu sisendiks 
  digitalWrite(nupp, HIGH); 
}

void loop()
{
  // Kui nupu olek on madal (GND) ja LED vilgub
  if ((digitalRead(nupp) == LOW) && (VilkumiseOlek == 1))
  {
    VilkumiseOlek = 0;	// Lõpetame vilkumise
    while((digitalRead(nupp) == LOW));	// ootame nupu lahti laskmist
    delay(100);
  }
  // Kui nupu olek on madal (GND) ja LED ei vilgu
  else if ((digitalRead(nupp) == LOW) && (VilkumiseOlek == 0))
  {
    VilkumiseOlek = 1;	// Alustame vilkumisega
    while((digitalRead(nupp) == LOW));	// ootame nupu lahti laskmist
    delay(100);
  }
  
  // Kui vilkumine on lubatud, vilguta LEDi
  if(VilkumiseOlek == 1)
  {  
    digitalWrite(rohelineLED, LOW); // kustutame LED-i 
    delay(500); // ootame 1 sekundi (1000 millisekundit)
    digitalWrite(rohelineLED, HIGH); // süütame LED-i 
    delay(500); // ootame 1 sekundi (1000 millisekundit) 
  } 
}








</code>
====== Harjutus #2 ======

Modifitseerida programmi nii, et potentsiomeetriga määratakse LED-i heledus, kasutades selleks delay funktsioone.
<code c>
/*
Nimetus: Näide #2 Analoog sisend 
Kirjeldus: Modifitseerida programmi nii, et potentsiomeetriga määratakse LED-i heledus, kasutades selleks delayMicroseconds funktsioone.
Autor: Rain Ellermaa
Kuupäev: 05.06.2014
Versioon: 1.0
*/

int pote_sisend = A1; // määrame potentsiomeetri sisendviigu
int led_roheline = 13; // määrame rohelise LEDi ühendusviigu

int pote = 0; // muutuja potentsiomeetri väärtuse salvestamiseks

void setup() 
{
  pinMode(led_roheline, OUTPUT); // algväärtustame LED viigu väljundiks 
}

void loop() 
{
  pote = analogRead(pote_sisend)+1;  // loeme analoogsisendi väärtuse 1 liidetakse, et ei tekiks 0 viide

  // Vilgutame LEDi väga kõrgel sagedusel, et paistaks tuhmim
  digitalWrite(led_roheline, HIGH);  // süütame LED-i 
  delayMicroseconds(pote);           // Ootame potensiomeetriga määratud mikrosekundid
  digitalWrite(led_roheline, LOW);   // kustutame LED-i
  delayMicroseconds(1026-pote);      // Ootame ülejäänud mikrosekundid. Peab olema suurem, kui max muutuja pote väärtus (pote+1)
}

</code>

====== Harjutus #3.1 ======
Koostada programm, mis trükib potentsiomeetri väärtuse rea algusesse. Vajutades nupule vahetatakse rida ja jooksev väärtus kirjutatakse uuele reale. Vajutades uuesti nuppu vahetatakse aktiivse kirjutamise rida tagasi.

<code c>
#include <LiquidCrystal.h> // include needed library
 
// Initialize LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
const int nupp = A0; // Viik kuhu on ühendatud nupp
int pote_sisend = A1; // set potentiometer pin
int y=0;
 
void setup() {
  lcd.begin(16, 2); // set LCD column and row
  pinMode(nupp, INPUT); // define button pin as input
  digitalWrite(nupp, HIGH); // turn on internal pull-up resistor on button pin
}
 
void loop() {

  if (digitalRead(nupp) == LOW) { // if button pressed 
   while (digitalRead(nupp) == LOW){} // wait for button release
   if (y) y=0; else y=1;
  } 
  lcd.setCursor(0, y); //set cursor position first row and column 0 (1. rida on indeksiga 0)
  lcd.print(analogRead(pote_sisend)); //Print out potentiometer value to LCD
  lcd.print("    "); //Print out empty spaces 
  delay (100);  
}
</code>

====== Harjutus #4.1 ======

Modifitseerida programmi nii, et potentsiomeetriga määratakse temperatuuri nivoo, mis salvestatakse nupuga programmi mällu ja selle nivoo hilisemal ületamisel käivitatakse täiturmehhanism (milleks on LED).
<code c>
/*
Nimetus: Näide #3 Takistuslikud andurid
Kirjeldus: Modifitseerida programmi nii, et potentsiomeetriga määratakse temperatuuri nivoo, mis salvestatakse 
           nupuga programmi mällu ja selle nivoo hilisemal ületamisel käivitatakse täiturmehhanism (milleks on LED).

Autor: Rain Ellermaa
Kuupäev: 05.06.2014
Versioon: 1.0
*/
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
#include <math.h>

// Initsialiseerime LCD koos vastavate viikude ühendamisega
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

int pote_sisend = A1;  // määrame potentsiomeetri sisendviigu
int NTC_sisend  = A2;  // määrame temperatuurianduri sisendviigu
int led 	= 13;  // määrame LED ühendusviigu
int nupp 	= A0;  // määrame nupu ühendusviigu

// muutujad potentsiomeetri ja temperatuuri väärtuse salvestamiseks
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
  lcd.setCursor(0, 1); lcd.print("Seade:    ");
  lcd.setCursor(7, 1); lcd.print(seade);
}

void loop() 
{
  pote = map(analogRead(pote_sisend),0,1023,-20,100);  // loeme potensiomeetri väärtuse ja teisendame vahemikku -20C - 100C
  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 vajutatud
  if((temperatuur > seade) && (digitalRead(nupp) == HIGH))
  {
    digitalWrite(led, HIGH); // süütame LED-i
  }
  else 
  {
    digitalWrite(led, LOW); // vastasel korral kustutame LED-i
  }
}
</code>
====== Harjutus #4.2 ======

Kombineerida LED-i heleduse programm ja eelnev temperatuuri juhtimise programm, kus LED-i heledus sõltub sellest, kui palju nivootemperatuuri ületati (1 kraad: heledus 25 %, 2 kraadi: heledus 50 %, 3 kraadi: heledus 75 % ja 5 kraadi: heledus 100 %)
<code c>
/*
Nimetus: Näide #3 Takistuslikud andurid
Kirjeldus: Kombineerida LED-i heleduse programm ja eelnev temperatuuri juhtimise programm, kus LED-i heledus 
           sõltub sellest, kui palju nivootemperatuuri ületati: 
             kuni 1 kraad: heledus 25 % 
             kuni 2 kraadi: heledus 50 % 
             kuni 3 kraadi: heledus 75 % 
             üle selle: heledus 100 %

Autor: Rain Ellermaa
Kuupäev: 05.06.2014
Versioon: 1.0
*/
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
#include <math.h>
#include <SoftPWM.h>

// Initsialiseerime LCD koos vastavate viikude ühendamisega
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

int pote_sisend = A5;  // määrame potentsiomeetri sisendviigu
int NTC_sisend  = A3;  // määrame temperatuurianduri sisendviigu
int led 	= 13;  // määrame LED ühendusviigu
int nupp 	= A0;  // määrame nupu ühendusviigu

// muutujad potentsiomeetri ja temperatuuri väärtuse salvestamiseks
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
  lcd.setCursor(0, 1); lcd.print("Seade:    ");
  lcd.setCursor(7, 1); lcd.print(seade);
  
  SoftPWMBegin();
}

void loop() 
{
  pote = map(analogRead(pote_sisend),0,1023,-20,100);  // loeme potensiomeetri väärtuse ja teisendame vahemikku -20C - 100C
  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 vajutatud
  if((temperatuur > seade) && (digitalRead(nupp) == HIGH))
  {
    int vahe = temperatuur - seade;
    switch(vahe)
    {
      case 0: DimLED(led, 25); break;
      case 1: DimLED(led, 50); break;
      case 2: DimLED(led, 75); break;
      default: DimLED(led, 100); break;
    }
  }
  else 
  {
    DimLED(led, 0); // vastasel korral kustutame LED-i
  }
}

void DimLED(int led, int value)
{
/*  digitalWrite(led, HIGH);        // süütame LED-i 
  delayMicroseconds((value*10)+1);     // Ootame potensiomeetriga määratud mikrosekundid
  digitalWrite(led, LOW);         // kustutame LED-i
  delayMicroseconds(1001-(value*10));  // Ootame ülejäänud mikrosekundid  
*/  
  SoftPWMSetPercent(led, value);
}
</code>



====== Harjutus #5.1 ======

Luua programm, mis võimaldab servomootori positsiooni muuta vastavalt nuppudega seadistatud suurusele.
<code c>
// Kaasame vajalikud teegid
#include <Servo.h>
 
Servo myservo;  // create servo object to control a servo 
int nupud = A0; // määrame potentsiomeetri sisendviigu
int pos = 0;    // variable to store the servo position 
 
void setup() {
  myservo.attach(A2);  // attaches the servo on pin A2 to the servo object
}
 
void loop() {
  if (analogRead(nupud) <= 90) // Kui on vajutatud parem nupp
  {
    pos++;  // Suurendame positsiooni kuni maksimumväärtuseni
    if (pos > 180)
      pos = 170;
  }
  else if ((analogRead(nupud) >= 450) && (analogRead(nupud) <= 550)) // Kui on vajutatud vasak nupp
  {
    pos--;  // Vähendame positsiooni kuni miinimumväärtuseni
    if (pos < 1)
      pos = 1;
  }
  myservo.write(pos);              // annabe servole uue positsiooni
  delay(15);                       // oota 15ms servo liikumiseks
}
</code>
====== Harjutus #5.2 ======

Luua programm, mis servomootori baasil ehitatud radariga ja fotoanduriga leiaks ruumist kõige eredama punkti.
<code c>
// Kaasame vajalikud teegid
#include <Servo.h>
 
Servo myservo;  // create servo object to control a servo 
int nupud = A0; // määrame potentsiomeetri sisendviigu
int andur = A3; // valgusanduri määramine

int pos = 0;        // variable to store the servo position
int pos_max = 0;    // variable to store the servo position bi max light
int lugemMax = 0;   //suurim väärtus
int andur_vaartus=0;//vahemuutuja anduri väärtus ejaoks
 
void setup() 
{
  myservo.attach(A2);  // attaches the servo on pin A2 to the servo object
  Serial.begin(9600);
}
 
void loop() 
{
  if (analogRead(nupud) <= 90){ //tehakse läbi nupu vajutamisel
    lugemMax = 0;    //suurima väärtuse nullimine
    pos_max = 0;

    //algasendisse keeramine
    myservo.write(0);  
    delay(500);
    
    //suurima valguskoha otsimine
    for(pos = 50; pos < 140; pos += 1)  // Liigutame servot 50'st 140'ni
    {                                    
      myservo.write(pos);              // liigutame servot
      delay(50);                       // ootame servo liikumist
      andur_vaartus=analogRead(andur); // anduri väärtuse lugemine
      Serial.print("pos: ");
      Serial.print(pos);
      Serial.print(" - ");
      Serial.println(andur_vaartus);
      if (andur_vaartus > lugemMax)    // kas anduri väärtus on suuremim
      {
        lugemMax = andur_vaartus;      // suurima väärtuse salvestamine
        pos_max = pos;                 // vastava positsiooni meelde jätmine
      }
    }
    //Pärast skännimist eredaimasse punkti paika keeramine
    myservo.write(pos_max);
  }
}
</code>
====== Harjutus #6 ======

Luua programm, mis jadaliidesest saadetud teksti kirjutaks LCD ekraanile. Märk „+“ vahetab rida ning märk „-“ kustutab kogu ekraani.
<code c>
/*
Nimetus: Näide #4.1 Jadaliides
*/
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Globaalsed muutujad
char data;
char rida = 0;

void setup() 
{
	Serial.begin(9600);	// Seadistame Serial ühenduse 9600 baudrate'ga
	lcd.begin(16, 2); 	// Määrame LCD read ja veerud
}

void loop() 
{
 if(Serial.available())	// Kontrollime, kas on Serial ühendusest tulnud andmeid
 {
   data = Serial.read(); 	// Loeme tulnud andmed muutujasse "data"
   if(data == '+')			// Kontrollime kas saadeti '+' märk
   {  
     rida ^= 1;				// Vahetame rida 0 ja 1 vahel
     lcd.setCursor(0, rida);// Liigutame kursorit
   }
   else if (data == '-')	// Kontrollime kas saadeti '-' märk
   {
     lcd.clear();			// Puhastame ekraani
     lcd.setCursor(0, rida);// Liigutame kursori tagasi olnud reale
   }
   else		// Muul juhul
   {
     lcd.print(data);		// Kirjutame saadud sümboli LCDle
   }
 }
}
</code>
====== Praktiline projekt #1 ======

Luua programm, mis temperatuurinivoo ületamisel muudab õhuklapi asendit (servo mootor). Temperatuurinivoo määratakse potentsiomeetriga. Õhuklapi asend sõltub temperatuuri erinevusest. Iga temperatuuri kraad, mis ületab nivood lisab klapi nurga 25%. Lüliti katkestab igal ajahetkel süsteemi töö (hädastop) ja viib klapi algasendisse tagasi, jättes punase LED-i vilkuma. Edasijõudnud võivad kasutada katkestust.
<code c>
/*
Nimetus: Projekt #1
 Luua programm, mis temperatuurinivoo ületamisel muudab õhuklapi asendit (servo mootor).
 Temperatuurinivoo määratakse potentsiomeetriga.
 Õhuklapi asend sõltub temperatuuri erinevusest.
 Iga temperatuuri kraad, mis ületab nivood lisab klapi nurga 25%.
 Lüliti katkestab igal ajahetkel süsteemi töö (hädastop) ja viib klapi algasendisse tagasi,
 jättes punase LED-i vilkuma. Edasijõudnud võivad kasutada katkestust. 
 
Kirjeldus: 
          Kasutab Steinhart-Hart termistori valemit:
          temperatuur kelvinites = 1 / {A + B[ln(R)] + C[ln(R)]^3}
          kus A = 0.001129148, B = 0.000234125 ja C = 8.76741E-08
Autor: Rain Ellermaa
Kuupäev: 10.06.2014
Versioon: 1.1
*/
 
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
#include <math.h>
#include <Servo.h>
 
// Initsialiseerime LCD koos vastavate viikude ühendamisega
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
Servo myservo;      // Servo objekt
 
int pote_sisend = A5;  // määrame potentsiomeetri sisendviigu
int NTC_sisend  = A3;  // määrame temperatuurianduri sisendviigu
int led 	= 13;  // määrame LED ühendusviigu
int nupp 	= A0;  // määrame nupu ühendusviigu
 
// muutujad potentsiomeetri ja temperatuuri väärtuse salvestamiseks
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
  lcd.setCursor(0, 1); lcd.print("Seade:    ");
  lcd.setCursor(7, 1); lcd.print(seade);
 
  myservo.attach(A2);   // Seadistame servo A2's
}
 
void loop() 
{
  pote = map(analogRead(pote_sisend),0,1023,-20,100);  // loeme potensiomeetri väärtuse ja teisendame vahemikku -20C - 100C
  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 vajutatud
  if((temperatuur > seade) && (digitalRead(nupp) == HIGH))
  {
    int vahe = temperatuur - seade;
    switch(vahe)
    {
      case 0: myservo.write(50);   break;
      case 1: myservo.write(90);   break;
      case 2: myservo.write(130);  break;
      default: myservo.write(180); break;
    }
  }
  else 
  {
    myservo.write(0); // vastasel korral kustutame LED-i
  }
  delay(100);
}

</code>
====== Praktiline projekt #2 ======

Ventilaatori juhtimine XRF kaudu.
Luua programm, mis suudab XRF raadiomooduliga lugeda kaugmoodulilt temperatuuri ning kui temperatur ületab kohalikul kontrolleril seatud nivoo käivitatakse kaugmoodulil asetsev ventilaator. Suhtkuseks kaugmooduliga tuleb kasutada allolevat protokolli:
xTEMP – tagastab kümnekordse temperatuuri Celsiuse kraadides (24,5C puhul saadetakse 245)
vastus: xNNNN
xFANn – FAN1 käivitab ventilaatori, FAN0 peatab ventilaatori
vastus xFANn

Protokollis tähistab „x“ kohaliku seadme numbrit, mille annab juhendaja igale tiimile erineva.
<code c>
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
#include <math.h>
#include <Servo.h>
 
// Initsialiseerime LCD koos vastavate viikude ühendamisega
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
Servo myservo;      // Servo objekt
 
int pote_sisend = A5;  // määrame potentsiomeetri sisendviigu
int NTC_sisend  = A3;  // määrame temperatuurianduri sisendviigu
int led 	= 13;  // määrame LED ühendusviigu
int nupp 	= A0;  // määrame nupu ühendusviigu
 
// muutujad potentsiomeetri ja temperatuuri väärtuse salvestamiseks
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
  lcd.setCursor(0, 1); lcd.print("Seade:    ");
  lcd.setCursor(7, 1); lcd.print(seade);
 
  myservo.attach(A2);   // Seadistame servo A2's
  Serial.begin(9600);
}
 
char temp1; 
char temp2;
char temp3;
char temp4;
 
void loop() 
{
  // Loeme temperatuuri
  temperatuur = -100;
  Serial.println("0TEMP");
  while(temperatuur == -100)
  {
    while(Serial.available() < 5); // Oota, kuni saabub vastuse pakett
    if(Serial.read() == '0')       // Kontrollime, kas vastus on mõeldud "meile"
    {
      // Loeme sisse temperatuuri
      // (vaja on lahutada ASCII 0, et saada ASCII koodist number)
      temp1 = Serial.read()-'0'; // Sajalised 
      temp2 = Serial.read()-'0'; // Kümnelised
      temp3 = Serial.read()-'0'; // Ühelised
      temp4 = Serial.read()-'0'; // Kümnendikud

      // Arvutame temperatuuri
      temperatuur = temp1*100 + temp2*10 + temp3;
      temperatuur += temp4 * 0.1;
    }
  }
  
  // Mõõdame seadesuuruse
  pote = map(analogRead(pote_sisend),0,1023,-20,100);  // loeme potensiomeetri väärtuse ja teisendame vahemikku -20C - 100C

  // 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 vajutatud
  if((temperatuur > seade) && (digitalRead(nupp) == HIGH))
  {
    int vahe = temperatuur - seade;
    switch(vahe)
    {
      case 0: myservo.write(50);   break;
      case 1: myservo.write(90);   break;
      case 2: myservo.write(130);  break;
      default: myservo.write(180); break;
    }
  }
  else 
  {
    myservo.write(0); // vastasel korral kustutame LED-i
  }
  delay(100);
}
</code>

Kaugseadme kood:
<code c>
/*
Nimetus: Näide #4.1 Jadaliides
*/
#include <LiquidCrystal.h> // Kaasame vajaliku teegi
#include <math.h>
int NTC_sisend = A4; // määrame temperatuurianduri sisendviigu
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

const int mAIN1  = 12;
const int mAIN2  = 11;

void setup() 
{
  Serial.begin(9600);
  lcd.begin(16, 2); //Määrame LCD read ja veerud
  pinMode(3,OUTPUT);
  pinMode(mAIN1, OUTPUT);
  pinMode(mAIN2, OUTPUT);
  digitalWrite(mAIN1,HIGH);
  digitalWrite(mAIN2,LOW);
}

char data;
char rida = 0;
String string;
char stringpos;

void loop() 
{
 if(Serial.available() >= 5)
 {
   data = Serial.read();
   
   if((data >= '0') && (data <= '9'))
   {  
     lcd.setCursor(0,0);
     lcd.print(data);
     string = String("");
     while(Serial.peek() != '\r')
     {
       string += (char)Serial.read();
       while(!Serial.available());
     }
     if(string == "FAN1")
     {
       Serial.print(data);
       Serial.println(string);
       digitalWrite(3,HIGH);
       
     }
     else if(string == "FAN0")
     {
       Serial.print(data);
       Serial.println(string);      
       digitalWrite(3,LOW);
     }
     else if(string == "TEMP")
     {
       Serial.print(data);
       int tempr = Termistor(analogRead(NTC_sisend))*10;
       if(tempr < 1000)
         Serial.print("0");
       Serial.println(tempr);
       lcd.setCursor(0,1);
       lcd.print(tempr);
     }
   }
   else
     Serial.flush();
 }
}
double Termistor(long RawADC) 
{
  double Temp;
 
  Temp = log(((10240000/RawADC) - 10000));
  Temp = 1/(0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp))* Temp);
  Temp = Temp - 273.15; // Konverteeri Kelvinid Celciustesse
  
  return Temp;
}
</code>