---
# System prepended metadata

title: UKR

---

# UKR vaje

Ip: 194.249.229.147

## vaja1:

```C#
int ledPin = 8; //tip, ime, vrednost
int buttonGreen = 2;



void setup() {
  // put your setup code here, to run once:
  pinMode(ledPin, OUTPUT); //določa vhod ai izhod
  pinMode(buttonGreen, INPUT);
}


//digitalRead: branje pina
//digitalWrite: pisanje na pin
void loop() {
  // put your main code here, to run repeatedly:
  if(digitalRead(buttonGreen) == HIGH) digitalWrite(ledPin, HIGH);
  else digitalWrite(ledPin, LOW);
}
```
![](https://hackmd.io/_uploads/BkdMFhCkT.png)




##  vaja 2

```C#
int ledPin = 8; //tip, ime, vrednost
int buttonGreen = 2;
bool buttonState;



void setup() {
  // put your setup code here, to run once:
  pinMode(ledPin, OUTPUT); //določa vhod ai izhod
  pinMode(buttonGreen, INPUT);
}


//digitalRead: branje pina
//digitalWrite: pisanje na pin
void loop() {
  // put your main code here, to run repeatedly:
  buttonState = digitalRead(buttonGreen);

  digitalWrite(ledPin, buttonState);
}
```
![](https://hackmd.io/_uploads/HyAHtnA1a.png)


## vaja3a
```C#
int ledPin = 8; //tip, ime, vrednost
int buttonGreen = 2;
int buttonRed = 3;
bool buttonState;



void setup() {
  // put your setup code here, to run once:
  pinMode(ledPin, OUTPUT); //določa vhod ai izhod
  pinMode(buttonGreen, INPUT);
  pinMode(buttonRed, INPUT);
}


//digitalRead: branje pina
//digitalWrite: pisanje na pin
void loop() {
  // put your main code here, to run repeatedly:
  if(digitalRead(buttonGreen) == true) buttonState = true;
  if(digitalRead(buttonRed) == true) buttonState = false;



  
  

  digitalWrite(ledPin, buttonState);
}
```
![](https://hackmd.io/_uploads/HJ4uFn016.png)


## vaja 3b
```C#
int ledPin = 8; //tip, ime, vrednost
int buttonGreen = 2;
int buttonRed = 3;



void setup() {
  // put your setup code here, to run once:
  pinMode(ledPin, OUTPUT); //določa vhod ai izhod
  pinMode(buttonGreen, INPUT);
  pinMode(buttonRed, INPUT);
}


//digitalRead: branje pina
//digitalWrite: pisanje na pin
void loop() {
  // put your main code here, to run repeatedly:
  static bool buttonState = false; //statična - lokalna spremenljivka
  if(digitalRead(buttonGreen) == true) buttonState = true;
  if(digitalRead(buttonRed) == true) buttonState = false;

  digitalWrite(ledPin, buttonState);
}
```
![](https://hackmd.io/_uploads/HJzmh3Aka.png)


## vaja 3c - input pullup
```C#
int ledPin = 8; //tip, ime, vrednost
int buttonGreen = 2;
int buttonRed = 3;



void setup() {
  // put your setup code here, to run once:
  pinMode(ledPin, OUTPUT); //določa vhod ai izhod
  pinMode(buttonGreen, INPUT_PULLUP);
  pinMode(buttonRed, INPUT_PULLUP);
}


//digitalRead: branje pina
//digitalWrite: pisanje na pin
void loop() {
  // put your main code here, to run repeatedly:
  static bool buttonState = false; //statična - lokalna spremenljivka
  if(digitalRead(buttonGreen) == false) buttonState = true;
  if(digitalRead(buttonRed) == false) buttonState = false;

  digitalWrite(ledPin, buttonState);
}
```
![](https://hackmd.io/_uploads/S1DtThCk6.png)


## vaja 4
```C#
int ledPin = 8; //tip, ime, vrednost
int buttonGreen = 2;



void setup() {
  pinMode(ledPin, OUTPUT); //določa vhod ai izhod
  pinMode(buttonGreen, INPUT_PULLUP);
}



void loop() {
  static bool ledLight = LOW; // ledica ne sveti
  static bool buttonState;
  buttonState = digitalRead(buttonGreen); //statična - lokalna spremenljivka
  if(buttonState == LOW & ledLight == LOW){
    ledLight = !ledLight; // ledica sveti; gre v HIGH
    digitalWrite(ledPin, HIGH);
    delay(500); //zakasnitev 500ms
  }

  else if(buttonState == LOW & ledLight == HIGH){
    ledLight = !ledLight;
    digitalWrite(ledPin, LOW);
    delay(500);
  }

}
```
![](https://hackmd.io/_uploads/rJ2HfaCk6.png)




## Vaja 5 - morsejeva abeceda
```C#
int ledPin = 4;
int button = 11;


void setup() {
  // put your setup code here, to run once:
  pinMode(ledPin, OUTPUT);
  pinMode(button, INPUT);
  Serial.begin(115200);
}

void loop() {
  // put your main code here, to run repeatedly:
  static bool btnState;
  btnState = digitalRead(button);
  if(btnState == HIGH){
    for(int x=0; x<3; x++){
      digitalWrite(ledPin, LOW);
      delay(300);
      digitalWrite(ledPin, HIGH);
      delay(200);
      Serial.println(x);
    }
  
    delay(400);
    for(int x=0; x<3; x++){
      digitalWrite(ledPin, LOW);
      delay(300);
      digitalWrite(ledPin, HIGH);
      delay(200);
    }
    delay(5000);
  }
}
```
![](https://hackmd.io/_uploads/BJwhMgOxa.png)


## Smerni registri 1.vaja
```C#
void setup() {
  DDRD = 0xFF; //0b11111111 ali 255 - smerni register, port D smo določili kot izhod
  // DDRD |= (1<<PD2) | (1<<PD3);
}

void loop() {
  // put your main code here, to run repeatedly:
  //PORTD = 255; //0xFF
  PORTD = (1<<PD3) | (1<<PD2) | (1<<PD1) | (1<<PD0);
  delay(500);
  //PORTD = 0; //0x00
  PORTD = (0 << PD3)| (0<<PD2) | (0<<PD1) | (0<<PD0);
  //PORTD = (~(1<<PD3)) | (~(1<<PD2)) | (~(1<<PD1)) | (~(1<<PD0));
  delay(500);
}
```
![](https://hackmd.io/_uploads/HJICoQSWa.png)


## Smerni registri 2.vaja
```C#
void setup() {
  DDRD = 0xFF; //0b11111111 ali 255 - smerni register, port D smo določili kot izhod => 1 operator |
  DDRD = DDRD & (0 << PD7); // DDRD &= (0<<PD7); PD7 je vhod => 0 operator &
  PORTD |= (1<<PD7);
}

void loop() {
  int pinButton = PIND & (1<<PD7);
  if(pinButton){
    PORTD |= (1<<PD3); //led PD3 sveti
  }
  else{
    PORTD &= (0<<PD3); // led PD3 ne sveti
  }
}



// DDRD => pinMode
// PORTD => digitalWrite
// PIND => digitalRead
```
![](https://hackmd.io/_uploads/SJE6bES-p.png)


## lightshow s smernimi registri
```C#
//napiši seznam števil od 1 do 15, ki se ciklično izpisuje preko serijskega porta
//za določiev števila elementov seznama uporabi funkicjo sizeof
//naredi light show na portu D.

int seznam[] = {1,2,4,8,16,32,64,128,255,0,255,0,255,0,255};

void setup() {
  // put your setup code here, to run once:
  //Serial.begin(115200);
  DDRD = 0xFF; //Vsi pini porta so izhod

}

void loop() {
  // put your main code here, to run repeatedly:
  for(int x=0; x<15;x++){
    //Serial.println(seznam[x]);
    PORTD = seznam[x];
    delay(300);
  } 
}
```
![image](https://hackmd.io/_uploads/H10PbENUT.png)


## brez ddrd
```C#
//napiši seznam števil od 1 do 15, ki se ciklično izpisuje preko serijskega porta
//za določiev števila elementov seznama uporabi funkicjo sizeof
//naredi light show na portu D.

int seznam[] = {1,2,4,8,16,32,64,128,255,0,255,0,255,0,255};


void setup() {
  // put your setup code here, to run once:
  //Serial.begin(115200);
  //DDRD = 0xFF; //Vsi pini porta so izhod
  for(int x = 0; x<8;x++){
    pinMode(x, OUTPUT);
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  static int index = 0;
  int i = seznam[index];
  for(int x=0; x<8;x++){
    int k = i & 0x01;
    digitalWrite(x,k);
    i = i >> 1;
  }
  index++;
  if (index > 14) index = 0;
  delay(300);
}
```

## z sizeof()
```C3
//napiši seznam števil od 1 do 15, ki se ciklično izpisuje preko serijskega porta
//za določiev števila elementov seznama uporabi funkicjo sizeof
//naredi light show na portu D.

int seznam[] = {1,2,4,8,16,32,64,128,255,0,255,0,255,0,255};
int pin[] = {12,11,2,3,4,5,8,9};

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  //DDRD = 0xFF; //Vsi pini porta so izhod
  for(int x = 0; x<8;x++){
    pinMode(pin[x], OUTPUT);
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  static int index = 0;
  int i = seznam[index];
  int m = sizeof(seznam)/sizeof(seznam[0]); //izračuna število elementov seznama
  Serial.println(m);

  for(int x=0; x<8;x++){
    int k = i & 0x01;
    digitalWrite(pin[x],k);
    i = i >> 1;
  }
  index++;
  if (index > m-1) index = 0;
  delay(300);
}
```
![image](https://hackmd.io/_uploads/S1ssnENL6.png)


## pull up
![slika](https://hackmd.io/_uploads/H1DdSgHIp.png)


## neka vaja da zamenaš seznam z buttonom
```C#
int ledPin[] = {1,2,4,8,16,32,64,128,255,0,255,128,64,32,16,8,4,2,1};
int ledPin1[] = {0x81, 0x42,0x24,0x18,0x24,0x42,0x81};
int tipka = 8;
char ledPriklop[] = {13, 9, 11, 3,4,5,6,7};


void setup() {
  // put your setup code here, to run once:
  for(int x = 0; x < 8; x++){
    pinMode(ledPriklop[x], OUTPUT);

  }
  pinMode(tipka, INPUT);
}

void loop() {
  if (digitalRead(tipka) == HIGH){
    for (int x = 0;x < (sizeof(ledPin) / sizeof(ledPin[0]));x++){
    int i = ledPin[x];
    for (int x = 0; x<8;x++){
      int k = i & 0x01;
      digitalWrite(ledPriklop[x], k);
      i = i >> 1;
    }
    delay(500);
  }
  }
  
  else{
    for (int x = 0;x < (sizeof(ledPin1) / sizeof(ledPin1[0]));x++){
    int i = ledPin1[x];
    for (int x = 0; x<8;x++){
      int k = i & 0x01;
      digitalWrite(ledPriklop[x], k);
      i = i >> 1;
    }
    delay(500);
  }
  }
}
```
![image](https://hackmd.io/_uploads/SknT1K6Ia.png)


## LCD 16x2
```C#
#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,10,9,8,7);

void setup() {
  
}

void loop() {
  lcd.clear();
  lcd.begin(16,2); //16 stolpcev, 2 vrstici
  lcd.setCursor(0,0);//1 stolpec, prva vrstica
  lcd.print("Asja<3");
  lcd.setCursor(0,1);
  lcd.print("Stevec: ");
  lcd.setCursor(10,1);
  lcd.print(5);
  lcd.setCursor(13,0);
  lcd.print(millis()/1000);
  int value=analogRead(A0);
  lcd.setCursor(8,0);
  lcd.print(value);
  delay(100);
}
```
![image](https://hackmd.io/_uploads/BkR7Rgrt6.png)

## izpisovanje znakov, številk, besedila
```C#
//funkcija za izpis besedila, števila, znaka

#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,10,9,8,7);

byte hertz[8] = {
  0b00000,
  0b01010,
  0b11111,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000
};

void setup() {
  lcd.begin(16,2);
  lcd.createChar(1,hertz);
}

void loop() {
  lcd.setCursor(4,0);
  lcd.write(1);
  tekstPrint("Asja");//funkcija
  steviloPrint(10);
}

void tekstPrint(char tekst[]){// * - kazalec (char *tekst) ali (String tekst)
  lcd.setCursor(0,0);
  lcd.print(tekst);
}

void steviloPrint(int x){
  lcd.setCursor(14,1);
  lcd.print(x);
}
```


##
```C#
//funkcija za izpis besedila, števila, znaka
#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,10,9,8,7);

//char ch_imena[3][10] = {"Asja", "ali", "Lucija?"};
String ch_imena[3] = {"Asja", "ali", "Lucija?"};

void setup() {
  lcd.begin(16,2);
}

void loop() {
  for(int x=0;x<3;x++){
    lcd.clear();
    //char *m = ch_imena[x];
    String m = ch_imena[x];
    tekstPrint(m, x);//funkcija za izpis
    delay(500);
  }
}

//void tekstPrint(char* tekst, int stevilo){
void tekstPrint(String tekst, int stevilo){
  lcd.setCursor(0,0);
  lcd.print(tekst);
  lcd.setCursor(0,1);
  lcd.print(stevilo);
}
```


## povečevanje stevila z gumbom na LCD displayu
```C#
//števec
#include <LiquidCrystal.h>
#define tipka 4
LiquidCrystal lcd(12,11,10,9,8,7);



void setup() {
  lcd.begin(16,2);
  lcd.print("hello world");
  pinMode(tipka, INPUT_PULLUP);
}

void loop() {
  static int stevec = 0;
  if(!digitalRead(tipka)){
    stevec++;
    lcd.setCursor(0,1);
    lcd.print(stevec);
    delay(100);
  }
}

```
![image](https://hackmd.io/_uploads/Sytdo-SFT.png)

## oblikovanje izpisa
```C#
#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,10,9,8,7); //RS, E, D4, D5, D6, D7

//String ch_imena[3] = {"Asja", "Lucija", "Anja"}; // seznam tipa string

char ch_imena[3][11] = { // seznam tipa char
  "Asja",
  "Lucija",
  "Anja"
};


void setup() {
  // put your setup code here, to run once:
  lcd.begin(16,2);

}

void loop() {
  // put your main code here, to run repeatedly:
  for(int x = 0;x<3;x++){
    lcd.clear();
    //String m = ch_imena[x];
    char *m = ch_imena[x];
    tekstPrint(m, x); // klic funkcije
    delay(500);
  }
}

/*oblikovanje izpisa
void tekstPrint(char *tekst, int stevilo){
  lcd.setCursor(0,0);
  lcd.print(tekst);
  lcd.setCursor(0,1);
  lcd.print(stevilo);
}
*/

//oblikovanje izpisa s funkcijo sprintf
void tekstPrint(char *tekst, int stevilo){
  char str[16]; //seznam za oblikovanje
  sprintf(str, "ime: %04s x=%03d \n ", tekst, stevilo);
  lcd.setCursor(0,0);
  lcd.print(str);
}

// d - celo število
// ld - celo število
// s - string
// c -char
// \n - skok v novo vrstico

```

## dtostrf funkcija
```C#
void setup() {
  /* funkcija sprintf ne pozna realnih števil. Realna števila moramo pretvoriti v string.
  // to naredimo s funkcijo dtostrf
*/
  Serial.begin(115200);
  double temp = 123.127;
  char strTemp[8];
  dtostrf(temp, 5, 1, strTemp); //5 število znakov za izpis, 1 - število dec. mest
  Serial.println(strTemp);
}


void loop() {

}
```

## povečevanje, nižanje, resetiranje števca
```C#
#include <LiquidCrystal.h>
#define tipka1 4
#define tipka2 3
#define tipka3 2
LiquidCrystal lcd(12,11,10,9,8,7); //RS, E, D4, D5, D6, D7

/*
LCD
3 tipke (notranji pull-up)
rdeča - stevec ++
zelena - stevec --
modra - stevec = 0
*/


void setup() {
  lcd.begin(16,2);
  pinMode(tipka1, INPUT_PULLUP);
  pinMode(tipka2, INPUT_PULLUP);
  pinMode(tipka3, INPUT_PULLUP);

}

void loop() {
  static int stevec = 0;
    if(!digitalRead(tipka1)){
      lcd.clear();
      stevec++;
      lcd.setCursor(0,1);
      lcd.print(stevec);
      delay(300);
    }
    else if(!digitalRead(tipka2)){
      lcd.clear();
      stevec = stevec - 1;
      lcd.setCursor(0,1);
      lcd.print(stevec);
      delay(300);
    }
    else if(!digitalRead(tipka3)){
      lcd.clear();
      stevec = 0;
      lcd.setCursor(0,1);
      lcd.print(stevec);
      delay(300);
    }
}
```
![image](https://hackmd.io/_uploads/Sk0lqrRYa.png)


# nigger
```C#
#define tipka 4
int stevec;
bool zadnjeStanje = HIGH;

unsigned long zadnjiOdboj = 0;
unsigned long zakasnitevOdboja = 300;

void setup() {
  Serial.begin(115200);
  pinMode(tipka, INPUT_PULLUP);

}

void loop() {
  int stanje = digitalRead(tipka);
  if(stanje != zadnjeStanje && (millis() - zadnjiOdboj) > zakasnitevOdboja){
    zadnjiOdboj = millis();
    zadnjeStanje = stanje;
    if(zadnjeStanje == HIGH){
      stevec++;
      Serial.println(stevec);
    }
  }
}
```
![image](https://hackmd.io/_uploads/S1cgMy5ja.png)

# primer uporabe zunanje prekinitve
```C#
int ledPin = 8;
int tipka = 2;

volatile byte stanje = LOW; // volatilnost omogoča direkten dostop do pomnilnik, kjer je shranjena spremenljivka

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(tipka, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(tipka), ISR_tipka, CHANGE);

}

void loop() {
  digitalWrite(ledPin, stanje);
}


//prekinitvena funkcija
void ISR_tipka(){
  stanje = !stanje;
}
```
![image](https://hackmd.io/_uploads/r1IwFk5ip.png)


```c#
#include <Bounce2.h>
#include <LiquidCrystal.h>
#define btnRed 4
#define btnGreen 3
#define btnBlue 5
#define iv 2
int ledPin = 10;
int stevec;
volatile byte stanje = LOW;
LiquidCrystal lcd(12,11,10,9,8,7);
Bounce2::Button tipka1, tipka2, tipka3 = Bounce2::Button();

void setup() {
  pinMode(ledPin, OUTPUT);
  lcd.begin(16,2);
  tipka2.attach(btnGreen, INPUT_PULLUP);
  tipka1.attach(btnRed, INPUT_PULLUP);
  tipka3.attach(btnBlue, INPUT_PULLUP);
  tipka1.interval(10);
  tipka2.interval(10);
  tipka3.interval(10);
  tipka1.setPressedState(LOW);
  tipka2.setPressedState(LOW);
  tipka3.setPressedState(LOW);
  attachInterrupt(digitalPinToInterrupt(iv), ISR_tipka, CHANGE);
  Serial.begin(115200);
}

void loop() {
  digitalWrite(ledPin, millis());
  tipka1.update();
  tipka2.update();
  tipka3.update();

  if(tipka1.pressed()){
    lcd.clear();
    stevec++;
    lcd.setCursor(0,1);
    lcd.print(stevec);
    Serial.println(stevec);
    delay(300);
  }

  if(tipka2.pressed()){
    lcd.clear();
    stevec--;
    lcd.setCursor(0,1);
    lcd.print(stevec);
    Serial.println(stevec);
    delay(300);
  }

  if(tipka3.pressed()){
    lcd.clear();
    stevec = 0;
    lcd.setCursor(0,1);
    lcd.print(stevec);
    Serial.println(stevec);
    delay(300);
  }
}


void ISR_tipka(){
  stanje = !stanje;
}
```
![image](https://hackmd.io/_uploads/H1_B2xcip.png)

# sedem segmentni display
```C#
int digit[] = {0x3F,0x06,0x5B,0x4F,0x66};

void setup(){
  for(int i = 0; i < 8; i++){
    pinMode(i, OUTPUT);
  }
}

void loop() {
  int a = digit[0];
  for(int i = 0; i < 8; i++){
    int k = a & 0x01;
    digitalWrite(i, k);
    a = a >> 1;
    delay(200);
  }
}
```
![image](https://hackmd.io/_uploads/rypmIU23T.png)


# ne dela pedri
```C#
#include <Bounce2.h>
#include <LiquidCrystal.h>
#define btnRed A4
#define btnGreen A3
#define btnBlue A5
int ones, tens = 0;
volatile byte stanje = LOW;

Bounce2::Button tipka1, tipka2, tipka3 = Bounce2::Button();

const int number[11] = {0b0111111, 0b0000110, 0b1011011, 0b1001111, 0b1100110, 0b1101101, 0b1111101, 0b0000111, 0b1111111, 0b1101111};

void setup() {
  tipka2.attach(btnGreen, INPUT_PULLUP);
  tipka1.attach(btnRed, INPUT_PULLUP);
  tipka3.attach(btnBlue, INPUT_PULLUP);
  tipka1.interval(10);
  tipka2.interval(10);
  tipka3.interval(10);
  tipka1.setPressedState(LOW);
  tipka2.setPressedState(LOW);
  tipka3.setPressedState(LOW);
  Serial.begin(115200);
  for (int i = 0; i <= 13; i++)
    pinMode(i, OUTPUT); //all pins Output
    delay(300);
}

void loop() {
  display_ones(0);
  display_tens(0);
  tipka1.update();
  tipka2.update();
  tipka3.update();

  if(tipka1.pressed()){
    tens++;
    delay(300);
    Serial.println(tens);
  }

  if(tipka2.pressed()){
    ones++;
    delay(300);
  }

  if(tipka3.pressed()){
    ones, tens = 0;
    delay(300);
  }
}



void display_tens(const int tens){
  int pin1, a;  
  for (pin1 = 0, a = 0; pin1 < 7; pin1++, a++) {
    digitalWrite(pin1, bitRead(number[tens], a));
  }
}

void display_ones(const int ones){
  int pin2, b;             
  for (pin2 = 7, b = 0; pin2 <= 13; pin2++, b++)  {
    digitalWrite(pin2, bitRead(number[ones], b));
  }

}
```
![image](https://hackmd.io/_uploads/S1LOuDn2a.png)


## Program prebere zaporedje števil, ki so ločena z vejico. Števila shrani v seznam in jih pretvori v integer. max 5000, drugače 0

```C=
// R1: https://wokwi.com/projects/392500222281499649
#define MAX_NUMBERS 10 // največje število števil v seznamu
#define BUFFER_SIZE 64 // velikost začasnega pomnilnika za branje iz serijskega porta

long numbers[MAX_NUMBERS]; // seznam za shranjevanje števil
int count = 0; // število trenutno shranjenih števil

void setup() {
  Serial.begin(9600);
  Serial.println("Vpiši število.");
}

void loop() {
  if (Serial.available() > 0) {
    char buffer[BUFFER_SIZE];
    memset(buffer, 0, sizeof(buffer)); // počisti vsebino seznama
    Serial.readBytesUntil('\n', buffer, BUFFER_SIZE); // preberi niz do znaka za novo vrstico

    
    Serial.println(buffer);
    // razdeli niz na števila in jih shranite v seznam
    char *token = strtok(buffer, ",");
    count = 0; // ponastavi števec števil
    while (token != NULL && count < MAX_NUMBERS) {
      numbers[count++] = atol(token); // pretvori niz v število in shrani v seznam
      //s funkcijo strtok() pridobimo naslednji podniz iz niza buffer. 
      //Kot prvi argument nastavimo na NULL, kar pomeni, da strtok() nadaljuje z razdeljevanjem istega niza,
      // kot je bil podan pri prvem klicu, vendar tokrat nadaljuje od prejšnjega mesta,
      // kjer je bila najdena vejica.
      token = strtok(NULL, ","); 
    }

    int max_number = 0;
    for (int i = 0; i < count; i++){
      if (numbers[i] > max_number){
        max_number = numbers[i];
      }
    }
    if (max_number > 5000){
      count = 1;
      numbers[0] = 0;
    }

    // izpiši vsebino seznama
    Serial.println("Seznam shranjenih števil:");
    for (int i = 0; i < count; i++) {
      Serial.print(numbers[i]);
      if (i < count - 1) {
        Serial.print(", ");
      }
    }
    Serial.println();
  }
}
/* Vrstica memset(buffer, 0, sizeof(buffer)); 
Tukaj je razlaga:
    memset je funkcija, ki se uporablja za postavitev bloka pomnilnika na določeno vrednost.
    buffer je ime spremenljivke ali kazalca na začetek bloka pomnilnika, ki ga želite izbrisati.
    0 je vrednost, ki jo želite nastaviti v celotnem bloku pomnilnika.
    sizeof(buffer) vrne velikost bloka pomnilnika, na katerega kaže buffer.
    To je koristno, ker se velikost bloka pomnilnika lahko spreminja, in ta izraz se prilagodi tem spremembam.

Skupaj ta vrstica postavi vrednost 0 v vseh bajtih bloka pomnilnika, na katerega kaže buffer. 

Vrstica Serial.readBytesUntil('\n', seznam, SEZNAM_SIZE); 
se uporablja za branje podatkov iz serijskega porta do določenega znaka 
(v tem primeru znak \n, kar je znak za novo vrstico ali "Enter" v ASCII kodiranju) 
ali do dosežene največje dolžine

Vrstica char *token = strtok(seznam, ","); 
uporablja funkcijo strtok() za razdelitev niza znakov na "tokene" glede na določen ločevalni znak 
(v tem primeru vejica, ,).

Tu je razlaga:

    strtok() je funkcija v jeziku C/C++, ki se uporablja za razdeljevanje nizov na podnize 
    ali "tokene" glede na določen ločevalni znak.
    seznam je niz znakov, iz katerega želimo izvleči "tokene".
    "," je niz znakov, ki določa, kako bomo razdelili seznam. V tem primeru uporabljamo vejico kot ločilo.
    token je kazalec na prvi podniz (token), ki ga vrne funkcija strtok().

Funkcija strtok() vrača naslednji podniz (token) iz niza seznam, ki je deljen glede na določen ločevalni znak. 
Ob vsakem klicu funkcije strtok() vrne naslednji token, dokler ne pride do konca niza ali dokler niso izčrpani vsi tokeni.

Pomembno je vedeti, da funkcija strtok() spreminja vhodni niz seznam.
Poleg tega, ko je strtok() prvič klican, se kot prvi argument poda niz, ki ga želite razdeliti. 
Za vsak naslednji klic strtok() kot prvi argument podate NULL, kar pomeni, da nadaljujete z delom na istem nizu.
*/
```

## program prebere znak iz serijskega predpomnilnika
```C=
#define LED 10

void setup() {
  Serial.begin(115200);
  Serial.println("Vpiši znak: ");
  pinMode(LED, OUTPUT);
}

void loop() {
  if(Serial.available()){
    char znak = Serial.read();
    switch(znak){
      case '1':
        Serial.println("utrip 1x");
        utripanje();
        break;
      case '2':
        Serial.println("utrip 2x");
        utripanje();
        utripanje();
        break;
      case '+':
        Serial.println("LED on");
        digitalWrite(LED, HIGH);
        break;
      case '-':
        Serial.println("LED off");
        digitalWrite(LED, LOW);
        break;
      default:
        Serial.println("Vpiši pravi znak.");
        break;
    }
  }
}

void utripanje(){
  digitalWrite(LED, HIGH);
  delay(300);
  digitalWrite(LED, LOW);
  delay(300);
}
```

## program prebere znake iz serijskega porta in jih pretvori v številčno vrednost, ki določa frekvenco utripanja LED diode



```C=
#define LED 10 // int LED = 10; const int LED = 10;
int vrednost = 0;

void setup(){
  Serial.begin(115200);
  Serial.println("Vpiši tri znake: ");
  pinMode(LED, OUTPUT);
}

void loop(){
  static int utrip = 0;
  if(Serial.available()){
    char znak = Serial.read();
    if(znak >= '0' && znak <= '9'){ // '0' = 48 '9' = 58
      vrednost = (vrednost * 10) + (znak - '0');
    }
    else if (znak == 10){ // enter je 10
      utrip = vrednost;
      Serial.println(utrip);
      vrednost = 0; // ponastavimo na 0
    }
  }
  utripanje(utrip);
}

void utripanje(int x){
  digitalWrite(LED, HIGH);
  delay(x);
  digitalWrite(LED, LOW);
  delay(x);
}

```

## Program prebere znake, ki so ločeni z vejico znake pretvori v celo število in jih zapiši v seznam tipa integer

```C=
#define SEZNAMstevil 3 //preberemo 3 stevila
int stevila[SEZNAMstevil];
int seznamIndex; //indeks seznama stevil


void setup() {
  Serial.begin(115200);
  Serial.println("Vpiši 3 števila, locena z vejico: "); //vpiši več znakov, ki so ločeni z vejico
}

void loop() {
  if(Serial.available()){
    char znak=Serial.read();
    if(znak>='0' && znak<='9'){
      stevila[seznamIndex] = (stevila[seznamIndex] * 10) + (znak-'0');
    }
    else if(znak == ','){
      if(seznamIndex < SEZNAMstevil) seznamIndex++;
    }
    else if(znak == 10){//znak za enter
      //izpis seznama številk na serijski port
      for(int i = 0; i < SEZNAMstevil; i++){
        Serial.print(stevila[i]);
        if(i<(SEZNAMstevil -1))Serial.print(",");
        else Serial.println();
      }
      //seznam ponastavimo na nič za vpis novih številk
      seznamIndex = 0;
      //ponastavimo seznam števil na 0
      //for(int i = 0; i < SEZNAMstevil; i++) stevila[i] = 0;
      memset(stevila, 0, sizeof(stevila));
      Serial.println("Vpiši 3 števila, locena z vejico: ");
    }
  }
}
```


## primer uporabe funkcije Serial.readBytesUntil(); naenkrat preberemo vse znake iz predpomnilnika

```C=
const int MAKSsteviloZnakov = 50; // #define
char seznam[MAKSsteviloZnakov]; //seznam v katerega vpišemo vse znake iz predpomnilnika

void setup(){
  Serial.begin(115200);
  Serial.println("Vpiši niz znakov: ");
}


void loop(){
  static bool novPodatek = false;
  if(Serial.available()){
    Serial.readBytesUntil('\n', seznam, MAKSsteviloZnakov);
    novPodatek = true;
  }
  if(novPodatek){
    //izpiši vsebino seznama na Serijski port
    Serial.println("Vpisani znaki so: ");
    Serial.println(seznam);
    novPodatek=false;
  }
}
```

## primer uporabe funkcije strtok() za razdelitev seznama na posamezne podsezname
```C=
char imena[] = "Hedvika, Anja? Rudolf, Anton! Zala, Lucija, Ema";
char deli[] = ",,!,?";

void setup(){
  Serial.begin(9600);
  Serial.println("Razdeli niz znakov na posamezne podnize");
  //kazalec token kaže na 
  char *token = strtok(imena, deli);
  while(token != NULL){
    Serial.println(token); //izpis podniza seznama imen
    token = strtok(NULL, deli);
  }
}

void loop(){
}
```

## KODA
```C=
#define LED 8
#define KODA 5461

void setup() {
  Serial.begin(115200);
  Serial.println("Vpiši kodo: ");
  pinMode(LED, OUTPUT);
}

void loop() {
  if(Serial.available()){
    char vpis[5];
    int steviloZnakovVpis = Serial.readBytes(vpis, 4); // preberemo 4 znakev seznam vpis
    if(steviloZnakovVpis == 4){
      vpis[4] = '\0'; // zaključni znak - terminator seznama tipa char
      int stevilka = atoi(vpis);
      if(stevilka == KODA){
        Serial.println("vklop LED");
        digitalWrite(LED,HIGH);
      }
      else{
        Serial.println("Poizkusi ponovno");
        digitalWrite(LED, LOW);
        while(Serial.available()){
          Serial.read();
        }
      }
    }
  }
  delay(500);
}
```

## KODA Switch case stavek
```C=
#define LED1 8
#define LED2 2
#define KODA1ON 5461
#define KODA2ON 1234
#define KODA1OFF 5460
#define KODA2OFF 1230

void setup() {
  Serial.begin(115200);
  Serial.println("Vpiši kodo: ");
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
}

void loop() {
  if(Serial.available()){
    char vpis[5];
    int steviloZnakovVpis = Serial.readBytes(vpis, 4); // preberemo 4 znakev seznam vpis
    if(steviloZnakovVpis == 4){
      vpis[4] = '\0'; // zaključni znak - terminator seznama tipa char
      int stevilka = atoi(vpis);

      switch(stevilka){
        case KODA1ON:
          Serial.println("vklop LED1");
          digitalWrite(LED1,HIGH);
          break;
        case KODA1OFF:
          Serial.println("izklop LED1");
          digitalWrite(LED1,LOW);
          break;
        case KODA2ON:
          Serial.println("vklop LED2");
          digitalWrite(LED2,HIGH);
          break;
        case KODA2OFF:
          Serial.println("izklop LED2");
          digitalWrite(LED2, LOW);
          break;
        default:
          Serial.println("Poizkusi ponovno.");
          break;
      }
    }
  }
  delay(500);
}
```

## z millis
```C=
#define LED1 8
#define LED2 2
#define LED3 5
#define KODA1ON 5461
#define KODA2ON 1234
#define KODA1OFF 5460
#define KODA2OFF 1230
#define KODA3UtripON 4545
#define KODA3UtripOFF 4540

unsigned long trenutniCas;
int zakasnitev = 200;

void setup() {
  Serial.begin(115200);
  Serial.println("Vpiši kodo: ");
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
}

void loop() {
  static bool UTRIP3 = false;
  if(Serial.available()){
    char vpis[5];
    int steviloZnakovVpis = Serial.readBytes(vpis, 4); // preberemo 4 znakev seznam vpis
    if(steviloZnakovVpis == 4){
      vpis[4] = '\0'; // zaključni znak - terminator seznama tipa char
      int stevilka = atoi(vpis);

      switch(stevilka){
        case KODA1ON:
          Serial.println("vklop LED1");
          digitalWrite(LED1,HIGH);
          break;
        case KODA1OFF:
          Serial.println("izklop LED1");
          digitalWrite(LED1,LOW);
          break;
        case KODA2ON:
          Serial.println("vklop LED2");
          digitalWrite(LED2,HIGH);
          break;
        case KODA2OFF:
          Serial.println("izklop LED2");
          digitalWrite(LED2, LOW);
          break;
        case KODA3UtripON:
          Serial.println("LED 3 utrip ON");
          UTRIP3 = true;
          break;
        case KODA3UtripOFF:
          Serial.println("LED 3 utrip OFF");
          UTRIP3 = false;
          break;
        default:
          Serial.println("Poizkusi ponovno.");
          while(Serial.available()){
            Serial.read();
          }
      }
    }
  }
  delay(500);
  static bool m = false;
  if (((millis() + trenutniCas) > zakasnitev) && UTRIP3){
    m = !m;
    digitalWrite(LED3, m);
    trenutniCas = millis();
  }
}
```

## na lcd i2c
```C=
/*Napiši program, ki prebere niz znakov iz serijskega porta.
Uporabi funkcijo Serial.readBytes(buffer, 4)
Če niz znakov ustereza številki 5461 se na serijskem portu izpiše vklop LED in 
prižge LED dioda na pinu 8
Uporabi switch case stavek:
- 5461 (vklop LED1)
- 1234 (Vklop LED2)
- 5460 (izklop LED1)
- 1230 (izklop LED2)
- 4545 (utripanje LED3 vklop)
- 4540 (utripanje LED3 izklop)
- drugo: na serijskem portu naj se izpiše: poskusi ponovno
*/
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,  16, 2);


#define LED1 8
#define LED2 9
#define LED3 10

#define KODA1_on 5461
#define KODA1_off 5460
#define KODA2_on 1234
#define KODA2_off 1230
#define KODA3_on 4545
#define KODA3_off 4540

 //_on 4545 //uporabi funkcijo milis

unsigned long trenutniCas;
int zakasnitev = 400;

void setup() {
  Serial.begin(9600);
  Serial.println("Vpiši kodo:");
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  trenutniCas = millis();
  lcd.init();
  lcd.backlight();
}

void loop() {
  delay(500);
  static bool UTRIP3 = false;
  if(Serial.available()){
    char vpis[5];
    int steviloZnakovVpis = Serial.readBytes(vpis, 4); // preberemo 4 znake v seznam vpis
    if(steviloZnakovVpis == 4){
      vpis[4] = '\0'; // zaključni znak - terminator seznam tipa char
      int stevilka = atoi(vpis);
      switch (stevilka) {
        case KODA1_on:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("LED1 vklop");
          Serial.println("LED1 vklop");
          digitalWrite(LED1, HIGH);
          break;
        case KODA1_off:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("LED1 izklop");
          Serial.println("LED1 izklop");
          digitalWrite(LED1, LOW);
          break;
        case KODA2_on:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("LED2 vklop");
          Serial.println("LED2 vklop");
          digitalWrite(LED2, HIGH);
          break;
        case KODA2_off:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("LED2 izklop");
          Serial.println("LED2 izklop");
          digitalWrite(LED2, LOW);
          break;
        case KODA3_on:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("utripanje vklop");
          Serial.println("utripanje vklop");
          UTRIP3 = true;
          break;
        case KODA3_off:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("utripanje izklop");
          Serial.println("utripanje izklop");
          UTRIP3 = false;
          digitalWrite(LED3,LOW);
          break;
        default:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("poskusi ponovno");
          Serial.println("poskusi ponovno");
          while(Serial.available()) {
            Serial.read();
          }
      }
    }
  }
static bool m = false; 
if (((millis() - trenutniCas) > zakasnitev) && UTRIP3){
  m = !m;
  digitalWrite(LED3,m);
  trenutniCas = millis();
}
}
```