Control e robótica: Arduino

1. Introdución

Arduino é unha plataforma de electrónica aberta para a creación de prototipos baseada en software e
hardware libres. Creouse para calquera persoa interesada en crear contornas ou obxectos interactivos.

Arduino pode tomar información da contorna a través dos seus pins de entrada de toda unha gama de
sensores e pode afectar aquilo que lle rodea controlando luces, motores e outros actuadores.

O microcontrolador na placa Arduino se programa mediante a linguaxe

de programación Arduino e a contorna de desenvolvemento Arduino. O
software pode ser descargado de forma gratuíta desde http://arduino.cc/

2. Descrición da placa Arduino UNO

2.1 Microcontrolador:
É o cerebro da tarxeta controladora arduino.

2.2 Porto USB

Conecta a tarxeta arduino co ordenador para gravar o programa na memoria ou para enviar datos.
Tamén alimenta a placa.

2.3 Alimentación da tarxeta

Para que funcione a tarxeta sen tela conectada co USB ao ordenador, necesitamos conectar unha
pila ou unha batería cunha tensión comprendida entre os 7 e os 12V.

2.4 Botón RESET

Serve para reiniciar o sistema ou a execución dun programa.

2.5 Entradas e saídas dixitais

• Pins 0 -> 13 : Pins dixitais de entrada e saída

• Pin 0 (Rx): Recepción serie de datos

• Pin 1 (Tx): Transmisión serie de datos

• Pins ~ (3, 5, 6, 9, 10, 11): Pódense usar como saídas de sinal PWM

• GND: Conexión a terra ou 0V

1
2.6 Entradas analóxicas
Pins A0 -> A5: Permiten conectar ata 6 periféricos analóxicos de entrada

2.7 Entradas e saídas de alimentación

Permiten alimentar compoñentes, sensores, etc.

• IOREF: Saída coa tensión á que traballa a tarxeta

• 3,3V: Saída a 3,3V

• 5V: Saída a 5V

• GND: Conexión a terra ou 0V

• Vin: Entrada de alimentación entre 7 e 12 V

2.8 LEDs
A tarxeta arduino Uno incorpora 4 LEDs: Un que indica que a placa está acesa, outro conectado ao pin 13
para comprobar o funcionamento da placa, e os LEDs que indican que se están transmitindo ou recibindo
datos entre a tarxeta arduino e o ordenador.

3. Contorna de
programación

Para programar o Arduino podemos

empregar o Arduino IDE. O IDE é unha
Contorna de Desenvolvemento Integrado,
é dicir, unha aplicación que ten o
necesario para poder crear programas,
cargalos na tarxeta Arduino e analizar os
resultados.
Podes instalalo no teu ordenador indo a
http://arduino.cc/en/Main/Software ou
instalalo directamente desde os
repositorios en Ubuntu ou Linux Mint.

2
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

3.1 Configuración
Conecta a tarxeta arduino ao ordenador mediante un cable USB.

Abre o Arduino IDE e busca o teu modelo de arduino. No noso caso é Arduino Uno. Pode ser que o
programa xa a detectara automaticamente.

Podes necesitar configurar tamén o porto serie no que está conectada a tarxeta arduino:

Se tes problemas para comunicarte co porte serie pode deberse á falta de permisos. En Linux, como
administrador, conecta a placa, abre un terminal e escribe o seguinte. Despois reinicia o equipo para que
os cambios fagan efecto permanentemente:

• Incluír os usuarios no grupo dialout: sudo usermod -a -G dialout <NomeDeUsuario>

• Dar permisos para comunicarse co porto serie tyACM0: sudo chmod 777 /dev/ttyACM0

• Crear un enlace simbólico ao porto: sudo ln -sf /dev/ttyACM0

3.2 Proba a tarxeta: Blink

Abre o programa “Blink” en Arquivo -> Exemplos ->
Básicos -> Blink

Descárgao na tarxeta arduino.

Observarás que escintila o LED conectado ao pin 13. Iso
significa que a placa funciona ben e se conecta
perfectamente co ordenador, así que xa podemos
comezar a programar.

3
4. Estrutura básica dun programa

4.1 Comentarios:
Utilizamos /* … */ para engadir un parágrafo
con varias liñas.
Utilizamos // … para engadir un comentario
dunha liña.

4.2 Declaración de
variables e funcións:
No inicio definimos as constantes, variables e
funcións que utilizaremos posteriormente no
programa. Por exemplo, indicamos que temos
un LED conectado ao pin 13 da placa arduino.
int led=13;

4.3 Configuración:
Aquí introducimos o código de configuración
inicial. Execútase unha soa vez.
Por exemplo aquí indicamos que o pin 13 é un
pin de saída: pinMode(led, OUTPUT);
Tamén introducimos aquí as instrucións que
queremos que se executen unha soa vez no
inicio do programa.

setup() { … }

4.4 Programa:
As instrucións contidas dentro da función loop execútanse indefinidamente, ata que se desconecte a placa
arduino. Por exemplo, facemos que o LED se acenda e se apague en determinados intervalos de tempo.

Loop() { … }

4
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

5. Entradas e saídas dixitais

5.1 Guía de programación:

Definir variables: int
Por exemplo, definimos o nome “ledVerde” para un LED e indicamos que está int ledVerde=9;
conectado ao pin9
No caso anterior, como non varía ao longo do programa, podemos definir const int ledVerde=9;
ledVerde como unha constante:

Configuración: pinMode(pin,modo)
Debemos indicar se os pins que imos Configuración como saída: Configuración como entrada:
utilizar son de saída ou de entrada.
void setup() { void setup() {
Por defecto os pins están
pinMode(ledVerde, OUTPUT); pinMode(pulsador, INPUT);
configurados como entradas, polo
que non faría falta indicar as } }
entradas, só as saídas.

Función dixital: digitalWrite(pin,estado)

Envía un sinal dixital ao pin de HIGH ou 1: LOW ou 0:
saída indicado: envía 5V ao pin de saída envía 0V ao pin de saída
digitalWrite(9, HIGH); digitalWrite(13, LOW);

digitalWrite(9, 1); digitalWrite(13, 0);

Función dixital: digitalRead(pin)

Permite ler 0 ou 1 nun pin dixital de entrada.

int a=digitalRead(2); Exemplo 1: Define a variable “a” coa lectura (0 ou 1) no pin 2

int estado=digitalRead(pulsador); Exemplo 2: Define a variable estado coa lectura no pulsador

digitalWrite(led, digitalRead(pulsador)); Exemplo 3: Transmitimos ao LED o valor do pulsador

5
Operadores booleanos:

digitalRead(2) && digitalRead(3) A saída é 1 cando os dous pins (2 e 3) dan 1

AND: &&
simultaneamente

digitalRead(2) || digitalRead(3) A saída é 1 cando calquera dos pins valen 1, ou ambos á

OR: ||
vez

NOT: ! ! digitalRead(2) A saída é 1 cando o pin 2 dá 0

6
5.2 Práctica 1: LEDs intermitentes
Imos facer que un LED conectado no pin 13 luza durante un tempo
determinado e se apague durante outro tempo de maneira cíclica.

Montaxe:
Debemos conectar entre o pin 13 e a masa (GND) un LED e unha resistencia
de 270Ω . A pata máis longa debe ir conectada ao pin 13.

Programa:

// Declaración de variables:
const int led = 13; // LED conectado no pin 13

// Configuración:
void setup()
{
pinMode(led, OUTPUT); // Configuramos o pin 13 como saída
}

// Programa:
void loop() // O programa execútase repetidamente
{
digitalWrite(led, HIGH); // Envía 5V ao pin de saída 13
delay(500); // Agarda 500ms = 0,5s
digitalWrite(led, LOW); // Envía 0V ao pin de saída 13
delay(100); // Agarda 100ms = 0,1s
}

Propostas:
• Práctica 1-a. Cambiando a frecuencia: Modifica os intervalos de espera para obter outras
frecuencias de intermitencia.
• Práctica 1-b. Variable tempo: Crea unha variable no inicio do programa co valor do tempo de
acendido e outra co valor do tempo de apagado e fai que o programa se comporte en función de
ditos valores.
• Práctica 1-c. Ambulancia: Conecta dous LEDs, cada un nun pin dixital diferente coa súa
resistencia de protección. Modifica o programa de xeito que se acendan e apaguen de forma
alternada simulando as luces dunha ambulancia.

7
5.3 Práctica 2: Pulsadores controlando LEDs.
Imos ver como controlar o acendido e apagado dun LED premendo en pulsadores.

Material:
• 2 LEDs,
• 2 Pulsadores de contacto
• Resistencias: Para os LEDs: 270Ω (ou outro valor menor que 1kΩ) Para os pulsadores:10kΩ

Montaxe:
Conectaremos un LED cunha resistencia de 560Ω en serie igual que fixemos na primeira práctica.

O pulsador conectarémolo na parte central da protoboard, segundo o seguinte esquema (pin 2):

8
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

Programa:
Pulsador normalmente aberto: Cando prememos nun pulsador o LED acéndese e cando o soltamos
apágase. Definimos unha variable “estado” que le o valor do pulsador (o ou 1). O programa escribirá no
LED o valor que toma esta variable

// Declaración de variables:
const int led = 13; // Pin 13 asignado a un LED
const int pulsador = 2; // Pin 2 asignado a un pulsador
int estado = 0; // Variable na que apuntamos o estado do pulsador
// Configuración:
void setup() {
pinMode(led, OUTPUT); // Configuramos o LED como saída
}
// Programa:
void loop()
{
estado=digitalRead(pulsador); // Lemos 0 ou 1 do pulsador e gardámolo na variable "estado"
digitalWrite(led,estado); // Transmitimos ese valor ao LED
}

Proposta:
1. Práctica 2-a. Dous pulsadores: Conecta dous interruptores e dous LEDs con cadansúas
resistencias de protección e fai que cada pulsador controle un LED.

9
5.4 Práctica 3: Pulsadores e LEDs. Operacións lóxicas.
Pulsador normalmente pechado: En posición normal o LED está aceso, e cando prememos no
pulsador apágase. Operación booleana NOT.

// Declaración de variables :
const int led = 13; // Pin 13 asignado a un LED
const int pulsador = 2; // Pin 2 asignado a un pulsador
int estado = 0; // Variable na que apuntamos o estado do pulsador
// Configuración :
void setup() {
pinMode(led, OUTPUT); // Configuramos o LED como saída.
}
// Programa :
void loop()
{
estado=digitalRead(pulsador); // Lemos 0 ou 1 do pulsador e gardámolo na variable "estado”
digitalWrite(led,!estado); //Transmitimos ao LED o valor negado do pulsador
}

Función OR: Imos facer que un LED acenda cando prememos calquera dos pulsadores

// Declaración de variables
int led = 13; // Pin 13 asignado a un LED
int pulsador1 = 2; // Pin 2 asignado ao pulsador1
int pulsador2 = 3; // Pin 3 asignado ao pulsador2
int estado1; // Variable que le o estado do pulsador 1
int estado2; // Variable que le o estado do pulsador 2
// Configuración:
void setup() {
pinMode(led, OUTPUT); // Configuramos o LED como saída.
}
// Programa :
void loop()
{
estado1=digitalRead(pulsador1); // Asignamos a “estado1” a lectura (0 ou 1) do pulsador 1
estado2=digitalRead(pulsador2); // Asignamos a “estado2” a lectura (0 ou 1) do pulsador 2
digitalWrite(led, estado1 || estado2); // Transmitimos ao LED o valor do pulsador1 ou o do pulsador2
}

10
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

Propostas:
1. Práctica 3-a. Función AND: Fai que un LED acenda só no caso de que premamos os dous
pulsadores á vez (Función AND)
2. Práctica 3-b. Inversión: Inicialmente temos un LED aceso e outro LED apagado. Cando prememos
nun pulsador o primeiro LED acéndese e o segundo apágase.

6. Condicionais

Mediante as funcións condicionais engadiremos aos nosos proxectos capacidade de decisión facendo
que certas funcións ou programas se executen ou non se se dan determinadas condicións preestablecidas.

6.1 Funcións de control:

if(condición) { proceso }
Cando se cumpre a condición establecida execútanse as funcións
do proceso definido entre as chaves {…}. Cando non se cumpre a
condición non se executan e o programe segue o seu curso.
Exemplo: Se a entrada é menor que 500 execútase o proceso.

if (entrada < 500) {// Proceso}

if(condición) { proceso 1 } else

{ proceso 2 }
Neste caso definimos dous procesos, un para
cando se cumpre a condición establecida, e
outro para cando non se cumpre.

Exemplo: Se a entrada é menor que 500

execútase o proceso 1, e se non execútase o
proceso 2.

if (entrada < 500) {// proceso1}

else {// proceso2}

11
6.2 Práctica 4: Condicional para acender e
apagar un LED
Imos ver como controlar o acendido e apagado dun LED premendo
pulsadores, pero establecendo condicións.
Utilizamos a montaxe da práctica anterior.

Programa:
Un LED acéndese ao premer nun pulsador e apágase ao soltalo.
Creamos unha variable “estado” que le o estado do pulsador e utilizamos un condicional if … else … para
indicar que cando o pulsador estea premido o LED deberá acenderse, e cando non deberá apagarse.
// Declaración de variables:
const int led = 13; // Pin 13 asignado a un LED
const int pulsador = 2; // Pin 2 asignado a un pulsador
int estado=0; // Variable coa que leremos o estado do pulsador.
// Configuración:
void setup() {
pinMode(led, OUTPUT); // Configuramos o LED como saída
}
// Programa:
void loop()
{
estado = digitalRead(pulsador); // Asignamos a "estado" o valor (0 ou 1) do pulsador
if (estado == 1) { // Se o pulsador esta premido (estado = 1)
digitalWrite(led, HIGH); // Acéndese o LED
}
else { // Se non
digitalWrite(led, LOW); // Apágase o LED
}
}

Propostas:
• Práctica 4-a. Acende un tempo: Cando prememos no pulsador un LED acéndese durante un
tempo determinado e despois apágase.

• Práctica 4-b. Operación lóxica AND: Fai que un LED acenda só no caso de que premamos dous
pulsadores á vez.

• Práctica 4-c. Unha función para cada pulsador: Temos dous pulsadores. Un encárgase de
acender un LED e o outro de apagalo.

12
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

7. Saídas dixitais PWM

O controlador arduino pode xerar sinais dixitais modulados en anchura “PWM”

(“Pulse Width Modulation”). Trátase dun sinal dixital periódico dunha determinada
frecuencia que pode ser asimétrico, é dicir, o tempo que está o sinal no nivel 1
pode ser diferente ao tempo no que está a nivel 0.

O valor do sinal PWM varía desde 0 (equivale a un

valor continuo de 0V) ata 255 (equivale a un valor
continuo de 5V).
Deste xeito podemos utilizar estes sinais para
controlar e regular a potencia de saída dun
dispositivo: Variar a luminosidade dunha lámpada ou
dun LED, regular a velocidade de xiro dun motor,
variar o posicionamento do eixe dun servo, etc.

Por exemplo, se temos un LED conectado a un pin

dixital PWM e enviamos un sinal PWM de valor 0 o
LED estará apagado, se enviamos un valor de 255
estará aceso completamente e se enviamos un valor
de 127 brillará a metade do que brillará no caso
anterior, pois só enviamos 5V na metade do ciclo útil.

7.1 Pins dixitais PWM no

arduino:
Na tarxeta Arduino Uno pódense usar como saídas de sinal PWM os pins marcados co símbolo ~ (3, 5, 6, 9,
10, 11)

7.2 Guía de programación:

O pin indica onde conectamos o dispositivo de saída (LED, motor, servo, etc.)
O valor permite axustar a duración do ciclo útil ao sinal PWM de saída. Está comprendido entre 0 (0% do
ciclo útil) e 255 (100% do ciclo útil)
Exemplos:

analogWrite(6, 127); Envía un sinal ao 50% do ciclo útil ao pin 6

analogWrite(led, brillo); Envía o valor da variable “brillo” ao pin no que está conectado o LED

13
7.3 Práctica 5: Luz gradual
Imos facer que un LED conectado no pin 9 (pin PWM) se acenda e se
apague gradualmente utilizando a función analogWrite().

Montaxe:
Conectamos un LED no pin dixital PWM 9 coa correspondente
resistencia de protección.

Programas:
1. Luz gradual: Imos facer que a luminosidade dun LED vaia
aumentando progresivamente enviando un valor de 0 a 255 a través da
variable brillo. Cando a variable brillo chega ao valor de 255, poñemos o
brillo a 0, apagamos o LED, agardamos uns segundos e volta e empezar.

// Declaración de variables:
int led = 9; // LED conectado no pin 9
int brillo = 0; // Indica a luminosidade do LED. Inicialmente poñemos un valor 0.
int variacion = 5; // Indica cantos puntos varía a luminosidade
// Configuración:
void setup() {
pinMode(led, OUTPUT); // Declaramos o pin 9 como de saída
}
// Programa:
void loop()
{
analogWrite(led, brillo); // Enviamos ao LED o valor da variable brillo
brillo = brillo + variacion; // Sumamos a variación ao valor do brillo
if (brillo == 255) // Cando o brillo vale 255
{
brillo = 0 ; // poñemos o brillo a 0
analogWrite(led, brillo); // apagamos o LED
delay(3000); // e agardamos 3 segundos
}
delay(100); //Retardo de 100ms para visualizar a variación
}

Propostas:
• Práctica 5-a. Aumenta e diminúe unha e outra vez. Agora facemos que a variación cambie de
signo cada vez que a variable brillo chegue a 255 ou a 0, conseguindo que primeiro aumente
progresivamente a luminosidade do LED e despois vaia esvaecendo.

14
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

8. Entradas analóxicas

8.1 Sinais analóxicos no arduino:

Os sinais analóxicos son sinais continuos, tanto no tempo como en amplitude, que poden tomar infinitos
valores.

No arduino podemos conectar periféricos analóxicos nas entradas analóxicas “Analog IN”. Non temos pins
de saída analóxicos, pero podemos utilizar os pins dixitais para enviar sinais PWM~

Pins de entrada analóxicos: Pins de saída PWM:

Pins A0 -> A5: Permiten conectar ata 6 Pins marcados co símbolo ~ (3, 5, 6, 9, 10, 11): saídas de sinal
periféricos analóxicos de entrada. PWM

8.2 Guía de programación:

Funcións analóxicas:
Le o valor dunha entrada analóxica. Pode tomar os valores entre 0 e 1023.
analogRead(pin);
Envía un sinal de saída PWM ao pin indicado, cun valor comprendido entre
analogWrite(pin, valor);
0 e 255.

Outras funcións:

valor2=map(valor1,min,max,Nmin,Nmax); Permite reasignar un valor comprendido entre un máximo

e un mínimo noutro valor comprendido entre outro
máximo e outro mínimo.
Exemplos:

a = analogRead(A2); // con esta función lemos o valor da entrada analóxica A2, que pode tomar valores
entre 0 e 1023.

b = map(a,0,1023,0,255); // Agora transformamos ese valor a nun valor b comprendido entre 0 e

255, para, por exemplo, poder envialo a través unha saía PWM.

15
Lectura serial
Imos ler unha entrada analóxica na que está conectado un potenciómetro, e mostrar na pantalla do
ordenador (monitor ou consola serie) o valor que toma entre 0 e 1023. Para iso utilizamos as funcións:

• Na configuración: Serial.begin(9600); Inicia a comunicación serial

• No programa: Serial.print(valor); Imprime na pantalla o valor lido nunha entrada
• No programa: Serial.println(valor); Imprime na pantalla o valor lido nunha entrada e pasa a unha
nova liña

Para ver a consola, unha vez cargado o programa no Arduíno, debemos premer na icona que aparece na
parte superior dereita:

16
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

8.3 Práctica 6: Movendo un potenciómetro.

Imos ler o valor enviado por un potenciómetro a unha entrada analóxica e, segundo o
resultado, executar unha serie de instrucións.

Montaxe:
Conectaremos un potenciómetro de 10kΩ de xeito que a patilla central c estea conectada á entrada
analóxica A0, outra patilla a 5V e a que queda a masa.

Conectamos tres LEDs coas súas resistencias de protección aos pins 11, 13 e 13.

Programas:
1. Lectura serial: Imos ler na consola serie o valor que nos dá un potenciómetro en función da posición
do cursor.

// Declaración de variables:
int valor=0; // variable que le o valor do potenciómetro, entre 0 e 1023
// Configuración:
void setup() {
Serial.begin(9600); // Inicia a comunicación serie
}
// Programa:
void loop()
{
valor = analogRead(A0); // Asignamos á variable "valor" o valor lido na entrada analóxica A0
Serial.println(valor); // Imprime no monitor serie dito valor
delay(200); //Retardo de 200ms para a visualización de datos na consola
}

17
2. Acender un LED cun potenciómetro: Podemos utilizar a información que lemos na consola sobre o
valor dun potenciómetro en función da posición do cursor para acender un LED cando o potenciómetro
supere un determinado valor.

// Declaración de variables
int valor=0; // variable que le o valor do potenciómetro, entre 0 e 1023
int led1=13;
// Configuración
void setup() {
Serial.begin(9600); // Inicia a comunicación serie
pinMode(led1, OUTPUT); // Configuramos o LED como saída
}
// Programa
void loop()
{
valor = analogRead(A0); // Asignamos á variable "valor" o valor lido na entrada analóxica A0
Serial.println(valor); //Imprime no monitor serie dito valor
if (valor >= 500) { // Cando a variable "valor" e maior ou igual que 500
digitalWrite(led1,HIGH); // acéndese o LED
}
else { // en caso contrario
digitalWrite(led1,LOW); // apágase
}
delay(100); // Retardo de 100ms para a visualización de datos na consola
}

Propostas:
1. Práctica 6-a. Cada LED nun rango: Conecta tres LEDs coas súas resistencias aos pins 11, 12 e 13.
O primeiro LED verde débese acender no rango de 100 a 350 da lectura do potenciómetro, o
segundo LED amarelo no rango 351-700 e o terceiro LED vermello no rango 701-1023.

2. Práctica 6-b. Cada vez máis LEDs: Agora fai que no inicio os tres LEDs estean apagados e a
medida que imos xirando o potenciómetro vanse acendendo cada vez máis LEDS.

18
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

8.4 Práctica 7. Conversión a PWM

Imos utilizar a función map(valor, min, max, Nmin, Nmax); para converter o valor lido na entrada
analóxica (que pode ser de 0 a 1023) a un valor que poidamos enviar a través dunha saída PWM (que ten
un rango de 0 a 255) -> pwm = map(valor,0,1023,0,255);
Despois enviamos ese valor a un LED conectado unha saída pwm, para que a súa luminosidade varíe en
función da posición do cursor do potenciómetro.
Asemade, na consola serie podemos visualizar o valor que teñen as variables “valor” e “pwm” en cada
momento.

Programa:

// Declaración de variables:
int valor=0; // variable que le o valor do potenciómetro, entre 0 e 1023
int pwm=0; // variable que enviamos a un pin pwm, entre 0 e 255
int led3=11;
// Configuración :
void setup() {
Serial.begin(9600); // Inicia a comunicación serie
pinMode(led3, OUTPUT); // Configuramos o LED como saída
}
// Programa :
void loop()
{
valor = analogRead(A0); // Asignamos á variable "valor" o valor lido na entrada analóxica A0
pwm = map(valor,0,1023,0,255); // Calculamos o valor correspondente pwm
analogWrite(led3,pwm); // Enviamos o valor pwm a un LED
Serial.print(valor); // Escribimos os valores das variables na consola serie
Serial.print(" ----> ");
Serial.println(pwm);
delay(200); // Agardamos 200ms
}

Propostas:
1. Práctica 7-a. Variando a frecuencia: Fai un programa no que un LED escintile cun intervalo de
100 ms entre acendido e apagado cando leamos un valor 0 no potenciómetro. A medida que
movemos o cursor vai aumentando o tempo ata que conseguimos que o LED escintile cun
intervalo de 500 ms cando lemos un valor de 1023 no potenciómetro.

19
9. Bucles

Xa coñecemos un bucle, que é o representado pola función loop() {programa} que encerra o programa.
Esta función fai que as instrucións que se atopan dentro do paréntese se executen indefinidamente,
mentres a tarxeta arduino estea conectada.
Pero en ocasións necesitamos que se repitan unha serie de instrucións un número determinado de veces,
ou queremos que se repitan mentres se cumpra unha condición determinada. Para estes casos utilizamos
os bucles for() e while().

9.1 Guía de programación: Funcións de control

for(inicio; condición; modificador) { proceso }

Esta función permite realizar bucles, para que as funcións

contidas entre os parénteses se executen un número determinado
de veces.

Exemplo: Executamos o proceso se se cumpre a condición de

que a<10 (desde a=0 ata a=9). Cando a=10 non se cumpre a
condición e sae do bucle. for(inicio,condición,modificador)
a++: incrementa 1

for( int a=0; a<10; a++)

{
// Proceso a repetir
}

while(condición) { proceso }

Mentres se cumpra a condición establecida entre parénteses

execútase o proceso encerrado baixo chaves. O bucle finaliza
cando se deixa de cumprir a condición.

Exemplo: Executamos un proceso 200 veces

var = 0;
while(var < 200) {
// acción a repetir
var++;
}

20
Operadores:
Operadores compostos

Operador Operación Exemplo Equivale a

++ Incrementa unha unidade n++ n=n+1

-- Decrementa unha unidade n- - n=n-1

+= Suma n+=3 n=n+3

-= Resta n-=3 n=n-3

*= Produto n*=3 n=n*3

/= División n/=3 n=n/3

9.2 Práctica 8: O faro.

Faro 1: Imos facer que un LED escintile 5 veces, descanse, e volva a empezar. Definimos a variable n para
realizar o reconto e contamos 5 empezando en n=0 e rematando en 4 (n<5).

// Declaración de variables
int led = 13; // LED conectado no pin 13
int tempo1 = 200; // Definimos a variable tempo entre acendido e apagado
int tempo2 = 2000; // Definimos a variable tempo entre secuencias
// Configuración
void setup() {
pinMode(led, OUTPUT); // Configuramos o pin 13 como saída
}
// Programa
void loop() // O programa execútase indefinidamente
{
for (int n=0; n<5; n++) { // Repítese 5 veces (desde 0 ata 4) o seguinte:
digitalWrite(led, HIGH);
delay(tempo1);
digitalWrite(led, LOW);
delay(tempo1);
}
delay(tempo2); // agarda o tempo2 antes de repetir de novo o proceso
}

Propostas:
1. Práctica 8-a. Contar 10: Fai que o LED se acenda e apague 10 veces en cada secuencia. Modifica o
valor das variables tempo1 e tempo2 para obter outras frecuencias.
2. Práctica 8-b. Cando pulsamos: Engade un pulsador coa súa resistencia de 10kΩ no pin 2 e fai que
cando prememos nel se acenda e apague o LED 5 veces.

21
10. Xogos de luces

10.1 Descrición:
Imos facer xogos de luces utilizando a función
for (inicio,condición,modificador) { proceso }

10.2 Material:
• 7 LEDs das cores que queiras conectados nos pins 7, 8, 9, 10, 11, 12 e 13
• 1 Pulsador de contacto no pin 2.
• Resistencias: Para os LEDs: 560Ω (ou outro valor menor que 1kΩ) Para o pulsador: 10kΩ

Montaxe:

22
10.3 Práctica 9: O coche fantástico.
Programas:
1. LEDs consecutivos: imos ordenar que se acendan e se apaguen os LEDs
un a un, de forma consecutiva. Tamén configuramos os LEDs como saída
mediante a función for.

// Declaración de variables:
int tempo = 200; // Definimos a variable tempo cun valor de 200ms
// Configuración:
void setup() {
for (int n=7; n<=13; n++) { // Repítese desde o 7 ata o 13 o seguinte:
pinMode(n, OUTPUT); // Imos configurando os pins como saída
}
}
// Programa
void loop() {
for (int n=7; n<=13; n++) { // Repítese desde 7 ata 13 o seguinte:
digitalWrite(n, HIGH); // Acende o LED n
delay(tempo); // Agarda o tempo marcado na variable tempo
digitalWrite(n, LOW); // Apaga o LED n
delay(tempo); // Agarda o tempo marcado na variable tempo
}
}
2. Coche fantástico: Para conseguir o efecto do coche fantástico engadimos un bucle descendente ao
programa anterior.

for (int n=12; n>=8; n--) { // Repítese desde 12 ata 8 o seguinte:

digitalWrite(n,HIGH);
delay(tempo);
digitalWrite(n,LOW);
delay(tempo);
}

Propostas:
1. Práctica 9-a. Fai un xogo de luces que quede chulo .
2. Práctica 9-b. Fai que se acendan e apaguen 5 LEDs secuencialmente de dento a fóra e despois de
fóra a dentro.

23
11. Motores e servos

Podemos conectar á nosa placa Arduino diversos tipos de motores. Imos ver as características de cada un.

11.1 Tipos de motores

Motores de corrente continua
Utilizaremos este motor se só necesitamos movemento pero non precisión, pois non
poderemos controlar a posición do eixe.
Estes motores en xeral non poden ser alimentados directamente a través dun pin de Arduino, xa que
necesitamos unha maior intensidade. Isto soluciónase conectando o motor a un circuíto amplificador cun
transistor.

Tamén podemos utilizar un circuíto integrado especial para o control de motores (Por exemplo L293D) O
que nos permite controlar facilmente a velocidade e o sentido de xiro.

Conexión: Teñen dous cables. Un debe conectarse a un pin arduino e outro a terra. Se cambiamos a orde
o motor xira en sentido contrario.

Servomotores
Os servomotores permiten controlar a posición angular do eixe, polo que
serán máis útiles cós anteriores cando necesitemos precisión nos
movementos. Este control é posible porque, ademais dun motor eléctrico de
corrente continua, os servomotores inclúen un sistema redutor da velocidade, un sensor de posición
(por exemplo, un potenciómetro) e un circuíto de control.

Conexión:
As cores dependerán de cada fabricante, polo que cómpre consultar as especificacións
técnicas, pero en xeral o cable vermello vai a 5V, o negro a terra e o branco ou
amarelo é o que recibe o sinal do pin arduino.

Tipos:

• Servo de rotación continua: permite controlar a velocidade e sentido de xiro, non tan rápido
coma os motores de cc, pero non necesita transistores.
• Servo de rotación estándar: pode xirar ata 180º e permite controlar a posición e o ángulo de xiro.

24
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

11.2 Práctica 10: A posición dun servo

Imos controlar a posición dun servo de rotación estándar mediante programación.

Montaxe:
Conexión: Aínda que depende de cada fabricante, en xeral o cable vermello vai a 5V,
o negro/marrón a terra (GND) e o branco/amarelo/laranxa é o que recibe o sinal do pin arduino. Imos
conectalo ao pin 9.

Control da posición:
A posición do servo contrólase a través do envío de pulsos en anchura (PWM).
Segundo a duración do pulso obtemos diferentes posicións do eixe do servo.
Porén, dependendo do servo que se utilice e do ciclo útil do mesmo, podemos
necesitar realizar cálculos para axustar a posición.

25
Programación:

#include <Servo.h> Inclúe a librería “servo” para poder utilizar as funcións que contén.
Sketch -> Importar Libraría -> Servo

Servo meuservo; Crea unha variable co nome do servo

meuservo.attach(Pin); Indica en que pin está conectado o servo.

meuservo.write(ángulo); Sitúa o eixe do servo na posición indicada.

Programas:
1. Xirar un ángulo determinado: Podemos controlar exactamente a posición (ángulo) que queremos que
teña o servo en cada momento

#include <Servo.h> // Importamos a librería servo

// Declaración de variables:
Servo meuservo; // poñémoslle nome ao servo: "meuservo"
// Configuración:
void setup() {
meuservo.attach(6); // Indicamos que está conectado no pin 6
}
// Programa:
void loop()
{
meuservo.write(0); // Móvese ata a posición de 0º
delay (2000);
meuservo.write(180); // Móvese ata a posición de 180º
delay (2000);
meuservo.write(90); // Móvese ata a posición de 90º
delay (2000);
}

Proba outras posicións entre 0 e 180 e observa o resultado.

26
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

2. Golpes: Imos facer que un servo xire lentamente ata unha posición e despois cambie rapidamente á
posición de partida.

#include <Servo.h> // Importamos a librería servo

// Declaración de variables:
Servo meuservo; // poñémoslle nome ao servo: "meuservo"
// Configuración:
void setup() {
meuservo.attach(6); // Indicamos que está conectado no pin 6
}
// Programa:
void loop()
{
meuservo.write(0); // Sitúase na posición de 0º
delay (2000);
for(int i=1;i<=120;i++) { // Móvese pouco a pouco ata 120º
meuservo.write(i);
delay (50);
}
delay (1000); // Agarda 1 segundo
}

Proposta:
1. Práctica 10-a. Lentamente: Modifica o programa anterior para que tamén volva lentamente ata a
posición de 0º
2. Práctica 10-b. Ao chou: Fai un programa de xeito que o servo xire a distintas posicións elixidas ao
chou. Utiliza a función random(0,180) para asignar un valor aleatorio entre 0 e 180 a unha variable
ángulo.
3. Práctica 10-c. Cal é a súa posición?: Engade o necesario ao programa anterior para visualizar na
consola a posición na que se atopa o servo.

27
11.3 Práctica 11. Control dun servo cun potenciómetro
Imos mover un servo en función da posición dun potenciómetro conectado a unha entrada analóxica.

Conectamos o servo ao pin 9 e un potenciómetro á entrada analóxica A0

Programa:
Imos transformar o valor lido na entrada analóxica (pot) nun valor de xiro para o servo.

#include <Servo.h> // Importamos a librería servo

// Declaración de variables
int pot=0; // variable que le o valor do potenciómetro, entre 0 e 1023
int xiro=0; // variable que enviamos ao servo, entre 0 e 180
Servo meuservo; // Poñémoslle nome ao servo
// Configuración
void setup() {
meuservo.attach(6); // Servo conectado no pin 6
meuservo.write(xiro); // Poñemos o servo inicialmente na posición de 0º
}
// Programa:
void loop() {
pot = analogRead(A0); // Asignamos a variable "pot" ao valor lido en A0
xiro = map(pot,0,1023,0,180); // Calculamos o valor correspondente para o xiro
meuservo.write(xiro); // facemos xirar o servo ata a posición xiro
delay(20); // Hai que introducir un pequeno tempo
}
1. Práctica 11-a. Outro rango: Fai que co xiro do potenciómetro o servo só se mova de 0 a 90º.

28
Introdución a Arduino. XIV Xornadas de tecnoloxía de Galicia. http://tecnoloxia.org

12. Xogando co son

Nesta sección imos facer que se emitan diferentes sons utilizando condicionais.

12.1 Funcións

12.2 Notas: 12.3 Material:

Nota Nome Frecuencia • LEDs (verdes, vermellos e amarelos) (pins 13, 12, ...)
Do C4 261.63 • 1 Pulsador de contacto (pin 2)
• Resistencias: Para os LEDs: 560Ω (ou outro valor menor que 1kΩ)
Re D4 293.67
Para os pulsadores:10kΩ
Mi E4 329.63 • Un zumbador piezoeléctrico ou no seu lugar un altofalante de 8Ω
Fa F4 349.23 de impedancia cunha resistencia de 100Ω conectada en serie con
el. (pin 4)
Sol G4 392.00

La A4 440.00

Si B4 493.88

12.4 Montaxe:

29
12.5 Práctica 12: Melodía
Imos facer que un altofalante conectado nunha saída dixital emita unha melodía

• Creamos unha variable para detectar o estado do pulsador

• Utilizamos a función tone(pin,frecuencia,duración) para definir o son

// Declaración de variables:
const int pulsador=2; // Definimos o pulsador no pin 2
const int altofalante=4; // Definimos o altofalante no pin 4
int estado=0; //Inicialmente o estado do pulsador é 0 (desactivado)
// Configuración:
void setup() {
pinMode(4,OUTPUT); // Configuramos o pin 4 como saída
}
// Programa:
void loop()
{
estado = digitalRead(pulsador);
if(estado==HIGH)
{
tone(4,1000,200); // 1000 Hz durante 0.2s
delay(400); // Agarda 0.4s
tone(4,1500,300); // 1500 Hz durante 0.3s
delay(400); // Agarda 0.4s
tone(4,2000,500); // 2000 Hz durante 0.5s
}
}

Propostas:
Conecta dous interruptores e dous LEDs, con cadansúas resistencias de protección e, utilizando as
funcións condicionais, resolve os seguintes problemas:

1. Práctica 12-a. Son e luces: Mellora do programa “Melodía”: Fai que ao premer un botón soe unha
melodía de maneira sincronizada co acendido e apagado duns LEDs.
2. Práctica 12-c. Sintetizador: Utiliza varios pulsadores para crear un sintetizador musical. Por
exemplo, con 2 pulsadores p1 e p2, ao premer no p1 prodúcese un ton de 400Hz cunha duración
de 100ms, e se prememos no p2 prodúcese un ton de 2600Hz cunha duración de 200ms.
3. Práctica 12-d. Variando as notas: Conecta un potenciómetro e fai que ao mover o cursor cambie
a frecuencia do ton emitido polo altofalante, desde a nota do a 261.63 Hz ata o si a 493.88Hz. (Mira
a conversión a PWM)

30