ARDUINO

Estructura
 Estructura Programación Arduinos

• setup() recoge la configuración

• loop() contiene el programa que se ejecutara cíclicamente

void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
digitalWrite(pin, HIGH); // pone el ‘pin’ en estado HIGH
}
 Sintaxis
{} entre llaves: definir el principio y el final de un bloque de
instrucciones
type funcion()
{
instrucciones;
}

; punto y coma: Separa instrucciones en el lenguaje de

programación de Arduino
int x = 13; // declara la variable 'x' como tipo
// entero de valor 13
 Sintaxis

/*… */ bloque de comentarios

/* esto es un bloque de comentario no se debe olvidar

cerrar los comentarios estos deben estar equilibrados */

// línea de comentarios

// esto es un comentario
 Variables

Declaración de variables
Para declarar una variable se comienza por definir su tipo
como int (entero), long (largo), float (coma flotante), etc,
asignándoles siempre un nombre, y, opcionalmente, un valor
inicial.
Esto solo debe hacerse una vez en un programa

int entradaVariable = 0;
int value; // 'value' es visible para cualquier “Global”
función
void setup()
{
// no es necesario configurar nada en este ejemplo
}
void loop()
{
for (int i=0; i<20;) // 'i' solo es visible
{ // dentro del bucle for
i++
} // 'f' es visible solo
float f; // dentro de loop() “Local”
}
 Tipos de datos

Byte: Byte almacena un valor numérico de 8 bits sin

decimales. Tienen un rango entre 0 y 255.

Int: Enteros son un tipo de datos primarios que

almacenan valores numéricos de 16 bits sin decimales
comprendidos en el rango 32,767 to -32,768.

Long: El formato de variable numérica de tipo extendido

“long” se refiere a números enteros (tipo 32 bits) sin
decimales que se encuentran dentro del rango -
2147483648 a 2147483647.
 Tipos de datos

Float: El formato de dato del tipo “punto flotante” “float” se aplica a

los números con decimales. Los números de punto flotante tienen
una mayor resolución que los de 32 bits con un rango comprendido
3.4028235E +38 a +38-3.4028235E.

Arrays: Un array es un conjunto de valores a los que se accede con

un numero índice.
int miArray[] = {valor0, valor1, valor2...}

int miArray[5]; // declara un array de enteros de 6 posiciones

miArray[3] = 10; // asigna l valor 10 a la posición 4
x = miArray[3]; // x ahora es igual a 10 que está en
// la posición 3 del array
 Asignaciones compuestas

x ++ // igual que x = x +1, o incremento de x en +1

x -- // igual que x = x - 1, o decremento de x en -1
x += y // igual que x = x + y, o incremento de x en +y
x -= y // igual que x = x - y, o decremento de x en -y
x *= y // igual que x = x * y, o multiplica x por y
x /= y // igual que x = x / y, o divide x por y
 Operadores de comparación

x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
 Operadores lógicos
Logica AND:

if (x > 0 && x < 5) // cierto sólo si las dos expresiones son ciertas

Logica OR:

if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es

//cierta

Logica NOT:

if (!x > 0) // cierto solo si la expresión es falsa

 Constantes

high/low: niveles de salida altos o bajos

input/output: el pin puede ser una entrada

INPUT o una salida OUTPUT

Control de flujo

if (si condicional)

if… else (si….. sino ..)

 Control de flujo

for
La declaración for se usa para repetir un bloque de
sentencias encerradas entre llaves un numero determinado
de veces.

for (inicialización; condición; expresión)

{
Instrucciones;
}

for (int i=0; i<20; i++)

 Control de flujo

while
Un bucle del tipo while es un bucle de ejecución continua
mientras se cumpla la expresión

do… while
El bucle do while funciona de la misma manera que el
bucle while, con la salvedad de que la condición se prueba
al final del bucle, por lo que el bucle siempre se ejecutara
al menos una vez.

do
{
Instrucciones……
} while (x < 100);
 e/s digitales

pinMode(pin, mode)

pinMode(pin, OUTPUT); // configura

//‘pin’ como salida

digitalRead(pin)

valor = digitalRead(Pin); // hace que 'valor sea

//igual al estado leído en ´Pin´
 e/s digitales

digitalWrite(pin, value)

digitalWrite(pin, HIGH); // deposita en el 'pin' un

//valor HIGH (alto o 1)
 e/s analógicas

analogRead(pin)

valor = analogRead(pin); // asigna a valor lo

//que lee en la entrada ´pin‘

analogWrite(pin, value)
Esta instruccion sirve para escribir un pseudo-
valor analogico utilizando el procedimiento de
modulacion por ancho de pulso (PWM) a uno de
los pin´s de Arduino marcados como “pin PWM”.
0-255
analogWrite(pin, valor);
 Control del tiempo

delay(ms)

delay(1000); // espera 1 segundo

millis()
Devuelve el numero de milisegundos transcurrido
desde el inicio del programa en Arduino hasta el
momento actual.

valor = millis();

Nota: Este numero se desbordara (si no se resetea de

nuevo a cero), después de aproximadamente 9 horas.
Led parpadeante.
Se trata de conectar un led al pin13, haciendo que luzca durante 500 ms y que se apague
durante 100 ms, este proceso se repetirá cíclicamente.
Objetivos:
· Reconocer partes de la placa.
· Aprender a conexionar leds a la placa.
· Familiarizarse con el entorno de programación.
· Reconocer las partes de un programa de arduino.
· Conocer órdenes como: pinMode, digitalWrite y delay.
CÓDIGO

void setup() { //comienza la configuracion

pinMode(13, OUTPUT); //configura el pin 13 como de salida
} //termina la configuracion

void loop() { //comienza el bucle principal del programa

digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (500); //espera 500 ms pin 13 con 5V
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (100); //espera 100 ms pin 13 con 0V
}
Secuencia de leds.
Se trata de encender y apagar 4 leds secuencialmente. Los leds deben estar conectados
a los pines 5,6,7 y 8.
Se deben encender y posteriormente apagar los leds desde el pin 5 al 8, con un tiempo
de duración de encendido y apagado de 200 milisegundos.
Nota: la secuencia principal del programa debe estar reproducida en una función a la
que llamará el programa principal.
Objetivos:
· Familiarizarse con el entorno de programación.
· Aprender a declarar variables tipo lista de valores.
· Aprender a declarar una función y llamarla cuando sea necesario.
Solución 1:

int tiempo=200; //declara una variable como entero y de valor 200

void setup() { //comienza la configuracion
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
}
void loop() { //comienza el bucle principal del programa
digitalWrite(5,HIGH);
delay(tiempo);
digitalWrite(5,LOW);
delay(tiempo);
digitalWrite(6,HIGH);
delay(tiempo);
digitalWrite(6,LOW);
delay(tiempo);
digitalWrite(7,HIGH);
delay(tiempo);
digitalWrite(7,LOW);
delay(tiempo);
digitalWrite(8,HIGH);
delay(tiempo);
digitalWrite(8,LOW);
delay(tiempo);
}
Solución 2:

int tiempo=200;
int n;
void setup() { //comienza la configuracion
for (n=5;n<9;n++) {
pinMode (n, OUTPUT);
}}
void secuencia() {
for (n=5;n<9;n++) {
digitalWrite (n, HIGH);
delay (tiempo);
digitalWrite (n, LOW);
delay (tiempo);
}}
void loop() {
secuencia();
}
 Solución 3:

int leds[]={5,6,7,8};// Declara variables tipo lista de valores

int tiempo=200;
int n=0;
void setup() { //comienza la configuracion
for (n=0;n<4;n++) {
pinMode (leds[n], OUTPUT);
}}
void secuencia() {
for (n=0;n<4;n++) {
digitalWrite (leds[n], HIGH);
delay (tiempo);
digitalWrite (leds[n], LOW);
delay (tiempo);
}}
void loop() {
secuencia();
}
Cruce de semáforos.
Se trata de un cruce de semáforos controlado por arduino, para ello
utilizaremos en el primer semáforo los pines 3 (led rojo), 4 (led amarillo), 5
(led verde), en el segundo semáforo utilizaremos los pines 6 (led rojo), 7
(led amarillo) y 8 (led verde). La secuencia de funcionamiento debe ser : rojo 1
– verde 2 durante 3 segundos, rojo 1 – amarillo 2 durante 500 ms, verde 1 –
rojo 2 durante 3 segundos, amarillo 1 - , rojo 2 durante 500 ms.

Objetivos:
· Familiarizarse con el entorno de programación.
· Aprender a declarar variables tipo lista de valores.

AYUDA:
int leds[]={3,4,5,6,7,8};
int tiempo1=3000;
int tiempo2=500;
int n;
void setup() {
for (n=0;n<6;n++) {
pinMode (leds[n],OUTPUT);
}}

void loop () { }
Auto Fantástico.
Se trata de encender y apagar 7 leds secuencialmente. Los leds deben estar
conectados a los pines 5,6,7,8,9,10 y 11.
Se deben encender y apagar los leds desde el pin 5 al 11, con un tiempo de
encendido y apagado de 50 ms, más tarde se deben encender y apagar los
leds desde el pin 11 al 5, con un tiempo de encendido y apagado de
50 ms. La secuencia se debe repetir indefinidamente.

Objetivos:
· Familiarizarse con el entorno de programación.
· Repasar declaración de variables tipo lista de valores.
· Repasar órdenes de control de programa como: for.
Secuencia de leds con pulsador.
Se trata de encender y apagar 4 leds secuencialmente al accionar un pulsador. El
pulsador debe estar conectado al pin 4, y los leds a los pines 5,6,7 y 8.
Se deben encender y posteriormente apagar los leds desde el pin 5 al 8, con un
tiempo de duración de encendido y apagado de 200 milisegundos.
Nota: la secuencia principal del programa debe estar reproducida en una
función a la que llamará el programa principal.

Objetivos:
· Familiarizarse con el entorno de programación.
· Aprender a conectar una entrada digital a arduino (pulsador).
· Aprender a declarar variables tipo lista de valores.
· Aprender a declarar una función y llamarla cuando sea necesario.
· Conocer órdenes como: digitalRead.
· Conocer órdenes de control de programa como: If.
 CODIGO
int cadenaleds[]={5,6,7,8};
int pulsador=4;
int tiempo=200;
int n=0;
void setup() {
for(n=0;n<4;n++) {
pinMode (cadenaleds[n],OUTPUT);
}
pinMode (pulsador,INPUT);
}
void flash() {
for (n=0;n<4;n++) {
digitalWrite (cadenaleds[n],HIGH);
delay (tiempo);
digitalWrite (cadenaleds[n],LOW);
delay (tiempo);
}}
void loop() {
if (digitalRead(pulsador)==HIGH) {
flash ();
}}
Ruleta de la fortuna.
Se trata de cinco leds que se van encendiendo y apagando
formando una secuencia, el jugador debe dar al pulsador cuando
el led intermedio se enciende, si acierta funciona un zumbador y
la velocidad de la secuencia aumenta.
Los leds deben estar conectados de los pines 5 a 9 (inclusives), el
zumbador al pin 10, el pulsador al pin 11.
El tiempo inicial entre encendido y encendido de leds debe ser
200 ms, si se acierta se decrementa el tiempo en 20 ms, si el
tiempo entre encendidos llegase a 10 ms, se devuelve el tiempo a
200 ms.

Objetivos:
· Repaso de conexión de entrada digital a arduino (pulsador).
· Repaso de variables tipo lista de valores.
· Repaso de declarar una función y llamarla cuando sea necesario.
· Repaso de órdenes como: digitalRead.
· Repaso de órdenes de control de programa como: For, If.
 analogWrite(pin, value)
Escribe un valor pseudo analógico usando modulación por ancho de pulso
(PWM en inglés) a un pin de salida marcado como PWM.

El valor puede ser especificado como una variable o constante con un valor
de 0 a 255.

analogWrite(pin, value); //escribe 'value' al 'pin' analogico

int led = 10; //LED con una resistencia
de 220ohm en el pin 10
int pin = 0; //potenciometro en el pin
analogico 0
int value; //valor para lectura
void setup(){} //setup no es necesario
void loop()
{
value = analogRead(pin); //ajusta
'value' igual a 'pin'
value /= 4; //convierte 0-1023 a 0-255
analogWrite(led, value); //saca la
señal PWM al led
}
Termostato.

Se trata de un dispositivo que haga funcionar un motor y un led

cuando la temperatura supera cierto umbral.
Para ello conectaremos una ntc a la entrada analógica 0, un led al pin
5 y un motor de corriente continua al pin 10. Cuando la temperatura
llegue a cierto umbral de voltaje (entre 0 y 1024) que nosotros
decidamos, se conectarán a la vez el diodo led y el motor que puede
tener unas aspas de ventilador en su eje para enfriar la ntc. Además se
deberá visionar el valor de voltaje en la entrada analógica (valor entre
0 y 1024) en una consola en el PC.

Objetivos:
· Conexión de entrada analógica a arduino (ntc).
· Órdenes como: analogRead.
· Visualizar datos en consola de puerto serie, con órdenes como:
Serial.begin, Serial.print.
· Repaso de órdenes de control de programa como: If else.
int led=5;
int ntc=0;
int motor=10; void loop(){
int medida=0; medida=analogRead(ntc);
int nivel=700; //variable que guarda el monitoriza();
límite //de temperatura al que se activa el if(medida>nivel){ //si la señal del sensor supera
ventilador //el nivel marcado:
digitalWrite(led,HIGH); //se enciende un aviso
void setup(){ //luminoso
pinMode(led,OUTPUT); digitalWrite(motor,HIGH); //arranca el motor
pinMode(motor,OUTPUT); }
Serial.begin(9600); else{ // si la señal está por debajo del nivel
} //marcado
void monitoriza(){ //procedimiento que envía al digitalWrite(led,LOW);
puerto serie, para ser leído en el monitor, digitalWrite(motor,LOW); // el motor se para
Serial.print("La medida es ..."); }}
Serial.println(medida);
delay(1000); //para evitar saturar el puerto
//serie
}
 AREF
13
PB5/SCK
12
PB4/MISO
RESET 11
~PB3/MOSI/OC2A
10
~ PB2/SS/OC1B
9
~ PB1/OC1A
8
PB0/ICP1/CLKO

1121
7
CTS
RTS
TXD
RXD

PD7/AIN1
6
A0 ~ PD6/AIN0
PC0/ADC0 5
A1 ~ PD5/T1

ATMEGA328P-PU
PC1/ADC1 4
A2 PD4/T0/XCK
PC2/ADC2 3

ANALOG IN
A3 ~ PD3/INT1
PC3/ADC3 2
A4 PD2/INT0
PC4/ADC4/SDA 1
DIGITAL (~PWM)

A5 TX PD1/TXD
PC5/ADC5/SCL 0
RX PD0/RXD
Xmodem, Ymodem, Zmodem
VT52, VT100, ANSI

ARD1
RV1(2)

ARDUINO UNO R3

69%
1k
RV1

D1
LED-BIBY
Un carro de tunnig tiene luces de neón en la parte de abajo, éste es la
sensación de la feria. El piloto controla las luces (tres LEDs) por medio
de un potenciómetro al lado de la palanca de cambios, él tiene tres
opciones de luces de acuerdo al valor de lectura del potenciómetro que
va de 0 a 1023:

0 - 350 Intermitencia de los 3 LED a 100ms

351 - 700 Intermitencia de los 3 LED a 500ms
701 - 1023 Intermitencia de los 3 LED a 1000ms
Aumentar luminosidad de led con pulsador
(fading).
Se trata de aumentar la luminosidad de un diodo led
conectado al pin 11 a través de la activación de un
pulsador. El pulsador debe estar conectado al pin 2.
Mientras el pulsador está conectado aumenta la
luminosidad del led hasta llegar a su valor máximo
(255), si el pulsador se desactiva se mantendrá su
luminosidad hasta que el valor de luminosidad
llegue a su máximo (255) pulsando nuevas veces, si
esto ocurre la luminosidad pasará a valor nulo (0).
/*
Ejemplo de uso de display LCD 16x2. Usando void loop() {
la librería LiquidCrystal // enviamos la posicion del cursor al display
*/ // (nota: fila columnas
lcd.setCursor(0, 0);
// incluimos la libreria LiquidCrystal // enviamos el mensaje a mostrar en el
#include <LiquidCrystal.h> display
lcd.print("prueba");
// inicializamos la librería con los numeros pins // mostramos el numero de segundos desde
del interfaz el inicio del programa
// cada LCD puede llevar sus propios numeros lcd.setCursor(0, 1);
// LiquidCrystal(rs, e, d4, d5, d6, d7) lcd.print(millis()/1000);
LiquidCrystal lcd(8, 9, 5, 6, 7, 3); }

void setup() {

VCC
// establecemos el numero de columnas y
filas del display AREF

LM016L
LCD1
lcd.begin(16, 2);
13
PB5/SCK
12 1
PB4/MISO VSS
RESET 11 2
~PB3/MOSI/OC2A VDD
10 3

}
~ PB2/SS/OC1B VEE
9
~ PB1/OC1A
8 4
PB0/ICP1/CLKO RS
5

ATMEGA328P-PU
1121
RW

DIGITAL (~PWM)
7 6
ANALOG IN

PD7/AIN1 E
6
A0 ~ PD6/AIN0
PC0/ADC0 5 7
A1 ~ PD5/T1 D0
PC1/ADC1 4 8
A2 PD4/T0/XCK D1
PC2/ADC2 3 9
A3 ~ PD3/INT1 D2
PC3/ADC3 2 10
A4 PD2/INT0 D3
PC4/ADC4/SDA 1 11
A5 TX PD1/TXD D4
PC5/ADC5/SCL 0 12
RX PD0/RXD D5
13
D6
14
D7

ARDUINO UNO
ARD1
Termómetro de leds.
8 leds lucen o se apagan ejerciendo de escala termométrica.
En función de la temperatura lucen más cantidad de leds o
menos. También de debe observar su valor en una pantalla
de cristal, el valor de la temperatura en grados Celsius.
Como la escala de conversión A/D es de 0 a 1023. asumir
que cada 8 es un grado.
ARD1

VCC
AREF LCD1
13
VCC PB5/SCK
12 1
PB4/MISO VSS
RESET 11 2
~PB3/MOSI/OC2A VDD
10 3
~ PB2/SS/OC1B VEE
9
RV1 ~ PB1/OC1A
8 4
PB0/ICP1/CLKO RS
5
ATMEGA328P-PU
1121

RW
DIGITAL (~PWM)

7 6
ANALOG IN

PD7/AIN1 E
6
~ PD6/AIN0
29%

A0
PC0/ADC0 5 7
A1 ~ PD5/T1 D0
PC1/ADC1 4 8
A2 PD4/T0/XCK D1
PC2/ADC2 3 9
A3 ~ PD3/INT1 D2
1k PC3/ADC3 2 10
A4 PD2/INT0 D3
PC4/ADC4/SDA 1 11
A5 TX PD1/TXD D4
PC5/ADC5/SCL 0 12
RX PD0/RXD D5
13
D6
14
D7
ARDUINO UNO R3

LM016L

D8 D7 D6 D5 D1 D2 D3 D4
LED-BIRG LED-BIRG LED-BIRG LED-BIRG LED-BIRG LED-BIRG LED-BIRG LED-BIRG
TECLADO MATRICIAL
 TECLADO MATRICIAL char tecla;
// inicio configuracion teclado int numero;
#include <Keypad.h>
const byte filas=4; void setup(){
const byte columnas=3; Serial.begin(9600);
byte pinfilas[filas]={8,7,6,5}; // ORDEN F1,F2,F3,F4
byte pincolumnas[columnas]={4,3,2}; // ORDEN C1,C2,C3 }

char teclas[filas][columnas]={ void loop(){

tecla=teclado.getKey();
{'1','2','3'}, if(tecla != NO_KEY){
{'4','5','6'}, numero=tecla-48;
{'7','8','9'}, Serial.println(tecla);
{'*','0','#'} Serial.println(numero);

}; }
}

Keypad teclado =
Keypad(makeKeymap(teclas),pinfilas,pincolumnas,filas,columnas);

// fin configuracion teclado

 presionado

AREF
13
PB5/SCK
12
PB4/MISO
RESET 11
~PB3/MOSI/OC2A
10
~ PB2/SS/OC1B
9
~ PB1/OC1A
8
PB0/ICP1/CLKO

1121
7
PD7/AIN1
6
A0 ~ PD6/AIN0
PC0/ADC0 5
A1 ~ PD5/T1

ATMEGA328P-PU
PC1/ADC1 4
A2 PD4/T0/XCK
PC2/ADC2 3

ANALOG IN
A3 ~ PD3/INT1
PC3/ADC3 2
A4 PD2/INT0
PC4/ADC4/SDA 1

DIGITAL (~PWM)
A5 TX PD1/TXD
PC5/ADC5/SCL 0
RX PD0/RXD

ARD1
ARDUINO UNO R3
VCC

B
A

D
7 C
4
1

1
0
8
5
2

2
#
9
6
3

3
tecla en el display se visualice el numero que hemos
Se requiere programa el arduino, donde al presionar una