UNIDAD DIDACTICA ARDUINO.

ROBOTICA 4 ESO

Versión: 1.0
Creado por: Guillermo Pacheco
INDICE

INDICE ........................................................................................................................................... 2
PRESENTACIÓN ........................................................................................................................... 3
ESQUEMA DE FUNCIONAMIENTO DE UN PROYECTO CON ARDUINO. ........................ 3
CARACTERÍSTICAS GENERALES DE LA PLACA ................................................................. 4
Vista general. ............................................................................................................................... 4
Componentes: .............................................................................................................................. 5
EL ENTORNO DE PROGRAMACIÓN DE ARDUINO .............................................................. 6
Vista general ................................................................................................................................ 6
Estructura básica de un programa de Arduino ............................................................................ 7
ACCESORIOS DE ARDUINO: SENSORES Y ACTUADORES ................................................ 8
Sensores ....................................................................................................................................... 8
Funcionamiento de los sensores. ............................................................................................. 8
Actuadores ................................................................................................................................. 10
COMUNICACIONES ................................................................................................................... 11
Conector USB ........................................................................................................................... 11
Pines de comunicación .............................................................................................................. 11
Librería serial ........................................................................................................................ 11
PASOS PARA LA REALIZACIÓN Y EJECUCIÓN DE UN PROGRAMA EN ARDUINO: .. 12
ACTIVIDADES ............................................................................................................................ 18
Actividad 1: ............................................................................................................................... 18
Actividad 2: ............................................................................................................................... 19
PROYECTOS CON ARDUINO ................................................................................................... 20
Ejercicio 1: Encendido de diodo a través de pin 13. ................................................................. 21
Cableado ................................................................................................................................ 21
Estructura del programa ........................................................................................................ 22
Elementos del programa utilizados en este ejercicio ............................................................ 22
Otros elementos que aparecen ............................................................................................... 23
Ejercicio 2: Encender 5 leds imitando luces del coche de la serie “El coche fantástico” ......... 24
Estructura del programa ........................................................................................................ 24
Ejercicio 3: Encender led apretando interruptor exterior .......................................................... 25
Estructura del programa ........................................................................................................ 27
Elementos del programa utilizados en este ejercicio: ........................................................... 27
Ejercicio 4. Encender 1 led por medio de la función termostato .............................................. 28
Estructura del programa ........................................................................................................ 29
Elementos del programa utilizados en este ejercicio ............................................................ 29
Ejercicio 5. Programar un seguidor solar con 3 sensores de luz y activar cuatro leds diferentes
según posición de la luz. ........................................................................................................... 31
Orientación Elevación ........................................................................................................... 32
Elementos utilizados ............................................................................................................. 32
Estructura del programa ........................................................................................................ 33
PRESENTACIÓN
Arduino es una plataforma de hardware y software de código abierto (opensource), basada en
una sencilla placa con entradas y salidas, tanto analógicas como digitales, en un entorno de
desarrollo que está basado en el lenguaje de programación muy similar al C y al Java como es
Processing. Este dispositivo, que conecta el mundo analógico con el digital, esta diseñado para
que de forma fácil y sin tener que bajar a bajo nivel podamos prototipar y construir robots y
artilugios electrónicos.

ESQUEMA DE FUNCIONAMIENTO DE UN PROYECTO CON

ARDUINO.
El ciclo de vida de un programa. El siguiente esquema muestra el ciclo de vida de un proyecto
realizado con Arduino. Los pasos que normalmente se dan en el son los siguientes:
1. El usuario creara un conjunto de instrucciones (o programa) que quiere que se ejecuten
en la placa controladora. Dicho conjunto de instrucciones será escrito con ayuda de un
ordenador
2. El conjunto de instrucciones se enviaran a la controladora (Arduino) vía puerto serie
(USB) para su ejecución
3. Las instrucciones se ejecutaran en Arduino
4. Desde Arduino se podrán leer datos de sensores conectados a la placa
5. Desde Arduino se podrán activar actuadotes conectados a la placa
6. Para monitorizar la ejecución del programa se podrá enviar información al ordenador (vía
USB) para su visualización.

2. El programa se envía a la
controladora Arduino para su
ejecución 4. El programa lee
datos de sensores SENSORES
- Temperatura
ARDUINO - Sonido
- Tacto
3. El programa se - Distancia
ejecuta en Arduino - infrarrojos
- humedad
6. El programa envía datos al - etc..
ordenador para su monitorización
5. El programa
pone en marcha
los actuadores

ACTUADORES
- Servos
1. El usuario crea el programa
- Motores
en un ordenador mediante un
- Leds
entorno de programación
- Pantalla LC, TFT, etc.
- Sonidos
- Envío de señales
digitales
- Etc..
CARACTERÍSTICAS GENERALES DE LA PLACA

Vista general.
A continuación se muestra una fotografía de la placa con una descripción de cada uno de sus
componentes

Figura 1. Aspecto de la placa Arduino UNO.

Componentes:

- El microcontrolador ATMEGA 328p. Se trata de un chip que posee un CPU, una memoria y
otros periféricos como temporizadores internos, unidad de transmisión serial, etc.
El microcontrolador se puede programar, es decir enviarle un conjunto de instrucciones
realizadas por el usuario para que las ejecute. Dichas instrucciones serán escritas por el usuario
en un entorno grafico en el PC, en un lenguaje fácilmente entendible (en este caso Processing) y
posteriormente traducidas por dicho entorno al lenguaje maquina y posteriormente enviadas vía
puerto serie a la placa para su ejecución.
- Los pines o patas del Arduino
El atmega 328p posee pines o patas para poder interactuar con el exterior. Pueden ser pines
digitales o analógicos.
- Los pines digitales:

Dichos pines pueden funcionar como entradas o salidas dependiendo de la configuración que se
haga mediante nuestra programación. Es decir, nosotros podemos elegir que un determinado pin
funcione como entrada o salida. (Si es entrada, recibirá 5v o 0v y si es salida aplicará 5v o 0v a
una carga).

- Los pines analógicos:

Los pines analógicos son o bien entradas o bien salidas. Las entradas analógicas nos permiten
trabajar con señales de naturaleza analógica (el voltaje que hay en un potenciómetro es una señal
analógica). Debemos recordar que muchos sensores nos entregan información de magnitudes
físicas como temperatura, presión, caudal etc. en forma de señales de voltaje. De manera que el
voltaje a la salida de un sensor de temperatura es proporcional a la magnitud física que mide el
sensor. Por ello, los pines de entrada analógica son importantes pues nos permiten interactuar
con los sensores.

- Conector usb tipo B

El conector USB tipo B, que encontramos en la placa Arduino permite poder grabar nuestros
programas en la placa. Adicionalmente, también podemos usar este conector para alimentar
nuestra placa directamente del puerto USB de la computadora.

- Conector de alimentación

El jack DC nos sirve para alimentar nuestra placa Arduino desde una fuente externa. La tensión
de alimentación puede ser por ejemplo 12v.
EL ENTORNO DE PROGRAMACIÓN DE ARDUINO

Vista general
A continuación mostramos una captura del entorno de desarrollo (IDE). Es una aplicación que
corre en el PC que permitirá:
- Escribir las instrucciones
- Corregir errores
- Transformar las instrucciones a código máquina
- Enviarlas a la tarjeta Arduino
- Visualizar mensajes desde la placa Arduino hasta el PC vía puerto serie
Estructura básica de un programa de Arduino

Como se ve en la figura la estructura de un programa contendrá las siguientes partes bien

diferenciadas:

- Declaración de variables. Es la parte donde se definen los valores tanto

constantes como variables que se irán utilizando en el resto del programa
- Setup. Es la parte donde configuraremos la placa. Es aquí donde por ejemplo
diremos que pines vamos a utilizar y si estos serán de salida o de entrada
- Loop. Es el conjunto de instrucciones que se han de ejecutar de modo continuo.
Es decir se trata de un bucle que se repetirá de modo infinito.
ACCESORIOS DE ARDUINO: SENSORES Y ACTUADORES

Sensores

Los sensores son dispositivos que envían a la placa información acerca de parámetros físicos
exteriores como
- Temperatura
- Humedad
- Distancia
- Luminosidad
- Sonido
- Infrarrojos
- etc.

Existe una infinidad de dichos sensores que se incorporaran en función de las necesidades del
proyecto. Así si queremos hacer un termostato tendremos que incorporar un sensor que nos mida
la temperatura externa

Funcionamiento de los sensores.

Un sensor debe ser capaz de transformar una magnitud física (tan variable como temperatura,
luminosidad o humedad) y transformarla en una magnitud eléctrica de forma que el programa
que corre en Arduino sea capaz de interpretarla. En el caso de Arduino esta magnitud debe ser un
voltaje que será medido desde una de las entradas digitales o analógicas de la placa Arduino.

Vamos a poner como ejemplo la medida de la temperatura por medio de una sonda NTC:

La sonda NTC es una resistencia que cambia con la temperatura

Aquí tenemos su símbolo

Al variar su resistencia con la temperatura podemos diseñar un pequeño circuito como el que
sigue:

ARDUINO

A5
A4
A3
A2
A1
A0

En este circuito hemos puesto una resistencia conocida (Rbajo) en serie con la resistencia
variable con la temperatura creando un divisor de tensión.

En este circuito variaciones en la temperatura implica variaciones en la resistencia lo que a su

vez implica finalmente variaciones en el voltaje Vout que será medido desde una de las entradas
analógicas de Arduino (analog Pin0..5)
Actuadores

Los actuadotes son dispositivos controlados por la placa controladora. Pueden llevar a cabo
movimientos (motores y servos), activar luces (leds), sonidos (timbres y buzzers), circuitos
(relés) así como enviar información a dispositivos para representar información (pantallas LCD,
TFT etc.).

Funcionamiento.
Al igual que con los sensores existe gran variedad entre los tipos de actuadotes así como su
funcionamiento. En la mayoría de los casos estos estarán controlados mediante las salidas
digitales (Digital 1..13)con un nivel de voltaje indicando una salida de voltaje alto(ON) o
bajo(OFF).

Como ejemplo vamos a ver como se activa un led desde Arduino desde la salida digital 5. En la
siguiente figura se ha conectado un led al pin nº 5. Una vez conectado, para encender el led solo
habrá que activar a ON la salida utilizada (ON = 5 voltios). Dicha activación se hace mediante
las instrucciones que componen el programa. Para apagar el led tan solo hay que poner la salida
a OFF (0 voltios)

ARDUINO

13
12
11
10
9
8
7
6
5
4
3
2
1
0
COMUNICACIONES
Arduino tiene un puerto de comunicaciones serie

Para la comunicación entre la placa Arduino y un ordenador u otros dispositivos se utiliza un

puerto serie. Todas las placas Arduino tienen al menos un puerto serie (también conocido como
UART o USART).

A nivel hardware existen varias posibilidades:

- Conector USB
- Pines digitales 0 (RX) y 1 (TX)

Conector USB
Mediante este conector se establecerá una comunicación serie con el ordenador:

- Para carga del programa en Arduino desde el PC. (PCArduino)

- Para monitorización: Envío de información desde Arduino al PC (ArduinoPC)

Antes de establecer la comunicación habrá que configurar tanto el PC como la placa:

- Configurando para que conecten a la misma velocidad

- Creando un puerto COM virtual de comunicaciones en el PC

Pines de comunicación
Se utilizan para la comunicación de Arduino con otra placa o con otros dispositivos. El chip
ATmega328 ofrece comunicación en serie UART TTL (5V ), que está disponible en los pines
digitales 0 ( RX ) y 1 ( TX) .

Librería serial

La comunicación en serie bien a trabes del puerto USB o bien a través de los pines 0 y 1 se hará
con ayuda de las funciones de la librería serial que se utilizarán a la hora de escribir el programa
y de las cuales podemos destacar:

- Serial.begin(9600); // Función para configurar el puerto de comunicaciones a 9600 baudios

- Serial.write(“información a enviar”); // Para enviar información a través del puerto
- Serial read(); // Para leer la información que este disponible en el puerto de comunicaciones
PASOS PARA LA REALIZACIÓN Y EJECUCIÓN DE UN
PROGRAMA EN ARDUINO:
1. Bajar la última versión del entorno de desarrollo (IDE) desde la página oficial de Arduino
http://arduino.cc/en/Main/Software e instalarla en el ordenador.

2. Arrancar la aplicación que tendrá el siguiente aspecto:

3. Escribir el código del programa, manteniendo la estructura mostrada en el apartado
anterior. A continuación se muestra el ejemplo de un simple programa que hará
parpadear un led.
4. Verificar el programa. El programa se verifica al seleccionar la opción “Verificar”. La
aplicación procederá a hacer un análisis del código realizado por el usuario e indicará en
la ventana inferior los posibles errores encontrados para que el alumno los pueda
corregir.

Botón de verificación

Ventana inferior de mensajes de error

5. Corregir los errores y volver a verificar hasta que el programa esté libre de errores.
6. Conectar la placa Arduino al ordenador mediante el cable USB
7. Seleccionar el tipo de placa Arduino con la que estamos trabajando desde el IDE:
“HerramientasTarjetaArduino Uno” (En nuestro caso seleccionaremos “Arduino
)Uno”
8. Seleccionar el puerto serie por el cual vamos a enviar el programa al Arduino:
“HerramientasPuerto SerialCOMX”, donde COMX es el puerto que se ha creado al
conectar el Arduino por medio del cable USB. Si hay varios puertos COM el alumno
podrá desenchufar la placa Arduino del ordenador y ver cual de ellos ha desaparecido
9. Enviar programa al Arduino. Una vez que tenemos el programa corregido y compilado, y
la tarjeta Arduino correctamente conectada al ordenador podemos proceder a cargar en
ella el programa. Para ello seleccionaremos el botón “enviar”

Enviar programa a tarjeta

10. Si todo ha ido bien, el breves segundos el programa estará ejecutándose en el Arduino
realizando las instrucciones que el alumno haya programado
ACTIVIDADES

Actividad 1:
Queremos simular el funcionamiento de un semáforo. Y para ello te vamos a pedir que realices
el siguiente montaje con Arduino.
1. Conecta
a. un led verde al pin digital número 2,
b. un led amarillo al pin digital número 3,
c. un led rojo al pin 4 (recuerda conectar la resistencia de 200 a 400 ohms delante
de cada led, para no quemarlo).
2. Conecta un zumbador al pin 5 (se puede conectar directo, sin necesidad de resistencia).

Nuestro semáforo debería seguir la secuencia verde, amarillo, rojo. Al ser un semáforo
deberíamos vigilar que en ningún momento estén las 3 luces apagadas, para no generar
confusión.

Elige cual de estas implementaciones se adapta mejor al comportamiento deseado (opción A,

opción B u opción C):

Opción A) Opción B) Opción C)

Actividad 2:

Ahora queremos hacer que el altavoz suene intermitentemente mientras el led verde esta
encendido. ¿Sería la mejor opción A, B o C?:
Elige cual de estas implementaciones se adapta mejor al comportamiento deseado (opción A,
opción B u opción C):

Opción A) Opción B) Opción C)

PROYECTOS CON ARDUINO
La metodología a seguir será el aprendizaje mediante la realización de pequeños proyectos o
ejercicios:

1. Encender diodo a través de pin 13.

2. Encender 5 led imitando luces del coche de la serie “El coche fantástico”
3. Encender led apretando interruptor exterior
4. Encender 1 led por medio de la función termostato
5. Programar un seguidor solar con 3 sensores de luz y activar cuatro leds diferentes según
posición de la luz.

.
Ejercicio 1: Encendido de diodo a través de pin 13.

Cableado: El alumno dispondrá los elementos necesarios con arreglo al siguiente esquema

Y para realizar este esquema utilizaremos la portoboard como sigue:

Nota importante: Las altas corrientes causadas por cortocircuitos o por el uso
de resistencias pequeñas pueden llegar a DAÑAR de forma irremediable la
placa Arduino. Es por ello que utilicemos una resistencia de 220 Ohmn en
serie al LED puesto que así disminuimos la corriente que sale del Arduino
Estructura del programa. A continuación ponemos la estructura del programa:

/*
Programa de Parpadeo
*/

// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

int led = 13;

// the setup routine runs once when you press reset:

void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}

Elementos del programa utilizados en este ejercicio:

Int Led = 13;

Es la variable que utilizamos para designar el pin de salida

pinMode(led, OUTPUT);

Con la función “pinMode” le decimos a la placa que vamos a utilizar el pin 13 (variable Led)
como pin de salida (OUTPU)

digitalWrite(led, HIGH);

Con digitalWrite enviamos al pin 13 (led) un valor de voltaje alto (HIGH)

delay(1000);

Le decimos a la placa que no haga nada durante 1000 ms (1 segundo)

digitalWrite(led, LOW);

Con digitalWrite enviamos al pin 13 (led) un valor de voltaje bajo (LOW) o cero voltios
Otros elementos que aparecen:

“;” Punto y coma: Cada sentencia que aparece en este lenguaje viene finalizada por un punto y
coma
// Cualquier palabra después de este símbolo es ignorada por el traductor del lenguaje.. es decir
se utiliza para comentar el programa

/*…*/ Cualquier palabra en medio de estos símbolos es ignorada por el traductor del lenguaje..
es decir se utiliza para comentar el programa

{..} se utilizan para los bloques de programa (setup y loop)

Ejercicio 2: Encender 5 leds imitando luces del coche de la
serie “El coche fantástico”

Utilizando y ampliando el esquema del ejercicio anterior el alumno encenderá y apagará cada
uno de los leds secuencial mente siguiendo el siguiente esquema con la protoboard

Estructura del programa

La estructura de este programa utilizara los mismos elementos que en el ejercicio anterior.
Ejercicio 3: Encender led apretando interruptor exterior
En este ejercicio el alumno hará un programa que haga encender un led conectado al pin
13cada vez que pulse un interruptor de tipo switch conectado en el pin 2 de acuerdo al
siguiente esquema. Por claridad no mostraremos la conexión del led que será idéntica a la del
ejercicio nº 1.

Las conexiones en la protoboard serán como se muestra en la siguiente figura

Elementos utilizados:
- un botón switch
- una resistencia de 1M
- 1 led
- 1 resistencia 220 Ohm
Estructura del programa. A continuación ponemos la estructura del programa:

const int buttonPin = 2; // the number of the pushbutton pin

const int ledPin = 13; // the number of the LED pin

// variables will change:

int buttonState = 0; // variable for reading the pushbutton status

void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}

void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.

// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}

Elementos del programa utilizados en este ejercicio:

pinMode(buttonPin, INPUT); Esta vez configure el pin 2 (button pin) para lectura

digitalRead(buttonPin); Lee el valor del voltaje del pin 2

if (buttonState == HIGH) { sentencias } Sentencia condicional: si la lectura del pin del botón 2
es alta (voltaje por encima de 3 voltios) entonces ejecuta las sentencias dentro de las llaves
siguientes.
Ejercicio 4. Encender 1 led por medio de la función
termostato

En este ejercicio el alumno hará encender un led cada vez que la temperatura que se lea por
medio de un sensor térmico NTC sea mayor que un valor determinado.
El esquema que utilizaremos será el siguiente (Por claridad no mostraremos la conexión del
led que será idéntica a la del ejercicio nº 1) :

Y el esquema en la protoboar será:

Elementos utilizados:
- una resistencia NTC
- una resistencia de 10k
 - 1 led
- 1 resistencia 220 Ohm

Estructura del programa. A continuación ponemos la estructura del programa:

int led=8;
int ntc=0;
int medida=0;
int temperatura;

int nivel=735; //variable que guarda el límite de temperatura al que se activa el led

void setup(){
pinMode(led,OUTPUT);
Serial.begin(9600);
}

void loop(){
medida=analogRead(ntc);

Serial.print("La medida es ...");

Serial.println(medida);
delay(1000); //para evitar saturar el puerto serie

if(medida>nivel){ //si la señal del sensor supera el nivel marcado:

digitalWrite(led,HIGH); //se enciende un aviso luminoso
}
else{ // si la señal está por debajo del nivel marcado
digitalWrite(led,LOW);
}

Elementos del programa utilizados en este ejercicio:

Serial.begin(9600);

Inicializa el Puerto serie con el PC para enviar mensajes al IDE a través de él

analogRead(ntc);

Lee el valor del voltaje en el pin ntc

Serial.print()

Envía por el puerto serie el contenido del paréntesis

Nota: Como acabamos de exponer enviaremos las lecturas del pin analógico por medio del
puerto de comunicaciones al PC. Para visualizar estos mensajes el alumno deberá abrir el
monitor del puerto serie desde “Herramientasmonitor serie”
Ejercicio 5. Programar un seguidor solar con 3 sensores de
luz y activar cuatro leds diferentes según posición de la luz.

Costa de dos partes:

- Lectura de sensores luminicos LDR o fotocelulas (I, D, A )
- Actuación sobre leds o relés: LI, LD, LAR, LAB (Izq, dcha, arrba, abjo)

A LAR
Sensores Leds
I D LI LD

LAB

1. Lectura:
Implementaremos el siguiente circuito divisor de tensión. En el veremos que al incidir la luz
sobre la fotocélula su resistencia disminuirá.

5Vcc

P1
A0..5

GND 10K

Se trata de una lectura analógica utilizando uno de los pines analógicos(A0..5):

Mediante el comando analogRead leemos el valor del voltaje que hay en el punto P1 y lo
almacenaremos en una variable definida previamente. ¿Qué valor obtenemos? Leemos un nivel
de voltaje que esta entre 0 y 5 voltios que al pasarlo a un conversor A/D de 10 bits nos dará un
numero entre 0 y 1023 (210 = 1024 niveles). Es decir, 0 corresponderá a 0 voltios y 1023 a 5
voltios.

2. Actuación sobre leds o relés:

Orientación Este-Oeste:
Compararemos el valor obtenido entre los sensores I y D. Si recibimos mas luz en el sensor I
activaremos el led LI y si es al contrario activaremos el sensor LD. La comparación se hará con
el siguiente comando:
if (lectura luz sensor I > lectura luz sensor D)  {activar led LI}
else{ activar led LD}
Orientación Elevación:
Compararemos el valor obtenido entre el sensor A y la media obtenida entre los sensores I y D.
Si recibimos mas luz en el sensor A activaremos el led LAR y si es al contrario activaremos el
sensor LAB

La activación se hará por medio de un pin digital como se indica en la siguiente figura:

D0..13 220

GND
Y en el programa utilizaremos el comando DigitalWrite(Nºpin, HIGH/LOW)

La conexión con la protoboard será como sigue:

Elementos utilizados:
- 3 resistencia LDR
- 3 resistencia de 10K
- 4 led
- 4 resistencia 220 Ohm
Estructura del programa. A continuación ponemos la estructura del programa:

int arriba_LDR = 0;
int izqda_LDR = 1;
int dcha_LDR = 2;
int arriba_led = 8;
int abajo_led = 9;
int izda_led = 10;
int dcha_led = 11;

int arriba;
int izqda;
int dcha;
int media_izqda_dcha;

void setup() {
Serial.begin(9600); // initialize serial communicatión at 9600 bits per second:
}

void loop() {
arriba = analogRead(arriba_LDR); // reads the LDR (value between 0 and 1023)
izqda = analogRead(izqda_LDR); // reads the LDR (value between 0 and 1023)
dcha = analogRead(dcha_LDR); // reads the LDR (value between 0 and 1023) //

media_izqda_dcha = (izqda+dcha)/2; // hace la media

Serial.print("arriba: "); Serial.println(arriba);

Serial.print("izqda: "); Serial.println(izqda);
Serial.print("dcha: "); Serial.println(dcha);

// si el sensor de arriba esta mas iluminado se enciende el led arriba y sino el de abajo

if (arriba> (media_izqda_dcha )){

digitalWrite(arriba_led,HIGH);
digitalWrite(abajo_led,LOW);
}
else{
digitalWrite(arriba_led, LOW);
digitalWrite(abajo_led, HIGH);
}
if (dcha> (izqda)){
digitalWrite(dcha_led,HIGH);
digitalWrite(izda_led,LOW);
}
else{
digitalWrite(dcha_led, LOW);
digitalWrite(izda_led, HIGH);
}
delay(500);
}