Curso Basico de Arduino

Pag 1 – Curso Basico de Arduino
Curso básico de Arduino

Instalar el IDE (Entorno de desarrollo integrado)
El primer paso para realizar nuestros programas en Arduino es descargarnos el IDE (Entorno de
Desarrollo Integrado), que como hemos dicho es la aplicación que nos permite programar y descargar
el programa a nuestra placa Arduino, estos programas son llamados sketchs.
Lo podemos descargar de la web www.arduino.cc, y esta disponible para Windows, MAC OS X y Linux.
Seleccionemos nuestro sistema operativo y sigamos las indicaciones de instalación.
Una vez completemos la instalación podemos abrir el IDE. Al iniciarse se vera una pantalla
como esta:
Configurar el IDE
Solo debemos realizar un par de ajustes para poder comenzar a realizar nuestro primer
sketch. Pero primero debemos conectar la placa Arduino al ordenador por un puerto USB.
1. En el menú ―Herramientas/Placa‖ seleccionamos la placa Arduino que tengamos conectada al

ordenador.
2. Y luego volvemos al menú ―Herramientas/Puerto‖ y seleccionamos el puerto que nos indica el
IDE que esta conectada la placa.
Debe quedar algo así:
Una vez que tengamos seleccionada la placa y el puerto podremos subir un sketch a la
placa.
Estructura básica de un Sketch

Como podemos apreciar al abrir el IDE se muestra la estructura básica de un sketch. Esta
estructura comprende las funcion setup() y loop(), estas dos funciones son indispensables a
la hora de escribir un sketch.
La función setup() se ejecuta una vez al iniciarse el programa, y se ejecutaran una vez las
instrucciones que se encuentran entre sus llaves.
 Y la función loop() de ejecutara de forma continua, de esa forma las instrucciones que se
encuentren entre sus llaves se repetirán indefinidamente.
En el sketch también podremos notar algo de texto en color gris. Estos son comentarios del
programa, y hay dos formas de escribir comentarios:
1. Usando barras dobles nos permite hacer comentarios en una sola linea: //Este es el comentario
2. O usando barra-asterisco, que nos permite hacer comentarios de varias lineas: /*Este es el
comentario*/
Los comentarios son muy útiles para documentar nuestros programas, con el fin de que lo
utilicen otras personas o como recordatorio de lo que hemos realizado.
Mi primer programa con Arduino

Ejemplo 1 : encender y apagar el LED

En esta ocasión estuve conectando un led rojo directamente sobre la placa como se muestra en el siguiente diagrama. El ánodo (la patica
mas larga del LED, que se ve más delgada en el interior del led), se conecta al PIN DIGITAL 13, y la patica más corta (el cátodo) se conecta al
PIN denominado como GND (Ground). En esta ocasión no es necesario usar ninguna resistencia pues la placa ARDUINO trae una incorporada
para este pin (resistencia entre pin 13 y pin GND)
Como puede observarse en la primera parte se define el LED que se empleará, en este caso el 13. Luego
se configura en modo salida y en el tercer bloque de código el led enciende durante un segundo, luego se
apaga durante dos segundos y repite este ciclo (loop).
Variables y operadores
¿Qué es una Variable?
Una variable es un elemento de nuestro sketch que guarda un determinado contenido. Ese
contenido (el valor de la variable) se podrá modificar en cualquier momento de la ejecución
del sketch. Lo podemos imaginar como un recipiente: al recipiente le podemos dar un
nombre y podemos elegir su tamaño.
Declaración e inicialización
En Arduino antes de poder utilizar una variable debemos crearla, a esto se llama declarar
una variable, y también podríamos asignarle un valor inicial, y a esto le llamamos inicializar
la variable. A continuación unos ejemplos de cómo podemos hacerlo.
Ejemplo 1
int nombreVariable1, nombreVariable2, nombreVariable3; //Crea 3 variables de tipo int
long nombreVariable; //Crea una variable de tipo long
float nombreVariable = 2.1; //Crea una variable tipo float con el valor inicial de 2.1
Asignación
Para cambiar el valor de una variable, que esté o no inicializada, usaremos el operador de
igualdad “=” de acuerdo al siguiente ejemplo.
Ejemplo 2
nombreVariable = 22; //Se asigna 22 a la variable nombreVariable
x=y+25; //Se asigna el valor de la variable y + 25 a la variable x
valorPrevio=valorActual; //El valor de la variable valorActual es copiado a la variable valorPrevio
¿Qué es el ámbito de una variable?

El ámbito de una variable las define como globales o locales, las variables globales son las
son definidas antes y fuera de las secciones de void setup(), void loop() u otra función en
nuestro sketch. Y las locales son todas las que están definidas dentro de alguna función. Las
variables globales reservan un espacio de memoria RAM permanentemente, y las locales lo
hacen solo mientras se ejecute la función, liberando el espacio de memoria al terminarse de
ejecutar la función. Por esto, las variables globales las podemos modificar desde cualquier
punto del sketch, y las locales solo dentro de las funciones dentro de las cuales está
declarada.
Tipos de Variables
Hay muchos tipos de variables en Arduino. El tipo de cada una lo definiremos de acuerdo a
los datos que vamos a guardar en la variable.
Nombre Tamaño Rango Ejemplo

boolean 1 bit 1o0 boolean bitEncendido=0;
byte 8 bit 0 a 255 byte valor=20;
char 8 bit -128 a 127 char código=′B′;
int 16 bit -32,768 a 32,767 int val1=30000;
long 32 bit -2,147,483,648 a 2,147,483,647 long suma=100000;
float 32 bit -3.4028235E+38 a 3.4028235E+38 float constanteA = 5.235;
unsigned char 8 bit 0 a 255 unsigned char letra1=′A′;
unsigned int 16 bit 0 a 65,535 unsigned int sensor=50000;
unsigned long 32 bit 0 a 4,294,967,295 unsigned long conteo10=1;
Conversión de variables (Cast)

Cuando usamos las funciones de conversión, forzamos los cálculos a ejecutarse haciendo
una conversión en el tipo de variable, la variable nunca cambia su tipo. Las funciones de
conversión son las siguientes: char(), byte(), int(), word(), long() y float(), y como parámetro
pasamos la variable. Esto también es útil cuando queremos asignar una variable de un tipo a
otro tipo. Como ejemplo veamos el siguiente programa.
Ejemplo 3
float resultado; //Declara una variable de tipo float
int variable1=10; //Declara una variable de tipo int
void setup() {
Serial.begin(9600); //Inicializa la comunicación serial a 9600 baudios
resultado= variable1/ variable2; //El resultado de la división se asigna a resultado
Serial.print("El resultado es "); //Imprime en el monitor serie un texto
Serial.println(resultado); //Imprime en el monitor serial el valor de la variable resultado
void loop() {}
El resultado que tenemos no es el esperado, y es porque dado que sólo intervienen

variables tipo int en el cálculo, el resultado es guardado en una variable tipo int, antes de
asignarla a la variable tipo float. Por tanto si queremos resolver el problema usaremos una
de las funciones de conversión.
Ejemplo 4
void setup() {
resultado= float(variable1)/variable2; //usamos la función de conversión en una de las variables
void loop() {}
Al ser una de las variables de la división tratadas como float, el resultado es guardado
temporalmente en una variable float para luego asignarla a resultado.
Constantes
Las constantes se pueden entender como variables de solo lectura, cuando intentemos
modificarlas el compilador dará un error. Lo único que hay que hacer para definirla es
preceder la declaración de la variable con la palabra clave “const”. Por ejemplo:
void setup() {

resultado= float(variable1)/variable2; //usamos la función de conversión en una de las variables
void loop() {}
Al ser una de las variables de la división tratadas como float, el resultado es guardado temporalmente en una variable float para luego asignarla a resultado.
Constantes
Las constantes se pueden entender como variables de solo lectura, cuando intentemos modificarlas el compilador dará un
error. Lo único que hay que hacer para definirla es preceder la declaración de la variable con la palabra clave “const”. Por
ejemplo:
const int valor1=125;
Existen otras constantes definidas en el lenguaje Arduino. Las constantes true y false son unas de ellas, false es la más fácil
de definir y es igual a 0, y true aunque puede interpretarse como 1 correctamente, en un sentido más amplio es definida
como no 0.
Operadores aritméticos
Los operadores aritméticos empleados en lenguaje Arduino son los siguientes:
= operador de asignación
+ Operador suma
– Operador resta
* Operador multiplicación
/ Operador división
% Operador módulo
Operadores compuestos
Son aquellos que nos permiten abreviar código y los usados en Arduino son los siguientes
Símbolo Ejemplo y descripción

++ x++; // incrementa x en uno y retorna el valor anterior de x
— x– ; // decrementa x en uno y retorna el valor anterior de x
+= x += y; // equivalente a la expresión x = x + y;
-= x -= y; // equivalent to the expresión x = x – y;
*= x *= y; // equivalente a la expresión x = x * y;
/= x /= y; // equivalente a la expresión x = x / y;
%= x %= y; // equivalente a la expresión x = x % y;
Orden de las operaciones

Es importante que estemos claros con respecto al orden en que se ejecutan las operaciones
para evitar errores cuando usamos fórmulas, en la siguiente tabla se muestran de mayor a
menor prioridad.
Símbolo Descripción Ejemplos

() Paréntesis (x+y)*z
++ — Incremento, decremento x++, y–
*/% Multiplicación, división, modulo x * 1.5

Símbolo Descripción Ejemplos

+– Adición, sustracción y + 10
< > <= >= Comparaciones menor que, mayor que if (x < 255)
== != Igual o diferente if (x == HIGH)

&& AND lógico if (x == HIGH && x > y)
|| OR lógico if (x == HIGH || x > y)
= += -= *= /= Asignación y asignación compuesta x=y
Y nuestra lección del día de hoy no podría quedar completa si no realizamos algunos
ejercicios para practicar nuestros nuevos conocimientos.
Ejercicios
Ejercicio 1: Hola Mundo
Realizar un programa que imprima en el monitor serie el texto “Hola Mundo”.
Ejercicio 2: Suma de números

Realizar un programa que me permita sumar dos números, uno sera el valor 120 el cual
estará guardado en una variable, y el otro sera el numero 50, el cual lo escribiremos
directamente (sin guardarlo en una variable). Guardaremos el resultado en una variable y lo
imprimiremos en el monitor serie.
Ejercicio 3: Incremento de números

Realizar un programa que incremente e imprima el valor de una variable en el monitor serie
continuamente. La variable se inicializará en 30000. Observar el resultado por unos
segundos.
Ejercicio 4: Multiplicación de dos números

Realizar un programa que usando dos variables me permita multiplicar los números 100 y
1000, y guarde el resultado en una tercera variable. Debo visualizar el resultado en el
monitor serial y comprobar el resultado.
Ejercicio 5: División y modulo

Realizar un programa que usando dos variables me permita dividir el número 100 entre 30, y
guarde el resultado en una tercera variable. Debo visualizar el resultado de la división y el
modulo (resto) en el monitor serial y comprobar el resultado.
Aun no te has suscrito a nuestro boletín? Suscríbete y te mantendré informado de la ultimas

publicaciones y entregas especiales. Y si tienes alguna pregunta o comentario acerca del
post no dudes en hacerla.
Condicionales If y Switch
Los bloques condicionales permiten evaluar condiciones en una variable, y ejecutar algunas
instrucciones en caso de cumplirse o no cumplirse la condición, los bloques condicionales
son los if y los switch.
Bloques “if” y “if/else”

Un bloque if sirve para comprobar si una condición determinada es cierta (true) o falsa
(false). Si la condición es cierta, se ejecutan una o varias instrucciones. El bloque
if/else funciona igual que el if, pero adicionalmente ejecuta una o varias instrucciones
cuando la condición no es cierta. La sintaxis para el bloque if es la siguiente:
if (condición) {
//Instrucciones que se ejecutan si la condición es cierta –true–
Y la sintaxis para el bloque if/else será la siguiente:

if (condición) {
//Instrucciones que se ejecutan si la condición es cierta –true–
} else {
//Instrucciones que se ejecutan si la condición es falsa –false–
El else es opcional, puedes colocarlo o no según lo necesite tu programa. También se puede dar el caso que necesitamos evaluar varias condiciones a la vez,
los bloques if se pueden entonces anidar usando la expresión else if, y usando la siguiente sintaxis:
if (condición) {
//Instrucciones que se ejecutan si la condición es cierta
} else if (otra_condición) {
//Instrucciones que se ejecutan si la condición del anterior “if” es falsa pero la actual es cierta
} else if (otra_condición) {
//Instrucciones que se ejecutan si la condición del anterior “if” es falsa pero la actual es cierta
} else {
//Instrucciónes que se ejecutan si todas las condiciones anteriores eran falsas

No existe límite para la cantidad de condiciones que podemos evaluar, ni para el tipo de variable que podemos evaluar, pueden ser números enteros o
decimales.
Por otro lado, es bastante probable encontrar en algunos programas expresiones tales como if(mivariable) en vez de if(mivariable!=0), por ejemplo. Es decir,
“ifs” que solo incluyen una variable, pero no la condición para evaluarla. Esta forma de escribir los “ifs” es simplemente un atajo: si en el if solo aparece una
variable o expresión sin ningún tipo de comparación, es equivalente a comprobar si dicha variable o expresión es “true” (es decir, si es diferente de 0).
Ejemplo de uso de if
float temperatura=100; //Declaro una variable con un valor de 100
boolean alarma=0; //Declaro una variable con un valor de 0
int velocidadBomba=50; //Declara una variable
void setup() {
Serial.begin(9600); //Inicio la comunicación serial
void loop() {
if (Serial.available()>0){ //Consulta si hay datos en buffer de entrada serie
temperatura=Serial.parseFloat(); //Lee un numero decimal en el buffer serial y lo guarda en temperatura
Serial.print("La temperatura es "); //Imprime el texto en el monitor serie

Serial.println(temperatura); //Imprime el valor de la variable
if(temperatura<80) Serial.println("Temperatura normal"); //Si la temperatura es normal imprime un mensaje
if(temperatura>80&&temperatura<100) { //Si la temperatura sube mas de 80 imprime otro mensaje
velocidadBomba=85; //Ajusta la velocidad de la bomba
Serial.println("Alerta de temperatura");
if(temperatura>=100){ //Si la temperatura es mayor que 100 imprime un mensaje
alarma=1; //activa una alarma //Activa la alarma
Serial.println("Temperatura Alta"); //Imprime un mensaje de aviso
velocidadBomba=100; //Ajusta la velocidad de la bomba
}else {
alarma=0; //Desactiva la alarma cuando la temperatura baja de 100
Bloques “switch”
Una manera válida de hacer comprobaciones de condiciones múltiples, más elegante, cómoda y fácil es utilizar el bloque switch. Su sintaxis es la siguiente:
switch (expresión) {
case valor1:
//Instrucciones que se ejecutarán cuando “expresión” sea igual a “valor1”
break;
case valor2:
//Instrucciones que se ejecutarán cuando “expresión” sea igual a “valor2”
break;
//Puede haber los “case” que se deseen, y al final una sección “default” (opcional)//
default:
//Instrucciones que se ejecutan si no se ha ejecutado ningún “case” anterior
La única limitación que tiene el switch es que solo se pueden evaluar números enteros, y solo se evalúan las condiciones hasta que una sea cierta.
Ejemplo de uso de un switch
int x; //Declara una variable sin un valor inicial
void setup(){
Serial.begin(9600); //inicia la comunicación serial
void loop() {
if (Serial.available()>0){ //Consulta si hay datos en buffer de entrada serial
x=Serial.parseInt(); //Lee un numero entero en el buffer serial y lo guarda en x

switch (x) { //consulto el valor de la variable x
case 20:
Serial.println("x vale 20 exactamente"); //Imprime un mensaje si el valor de x es 20
break;
case 50:
Serial.println("x vale 50 exactamente"); //Imprime un mensaje si el valor de x es 50
break;
default:
Serial.println("x no vale ni 20 ni 50"); //Imprime un mensaje si no se cumplen las condiciones anteriores
Operadores lógicos
Además de los operadores de comparación, en las comparaciones también se pueden utilizar los operadores booleanos (también llamados lógicos), usados
para encadenar dos o más comprobaciones dentro de una condición. Estos son los siguientes:
&& Comprueba que dos condiciones sean ciertas (Operador AND)
|| Comprueba que, al menos, una de dos condiciones sea cierta (Operador OR)
! Comprueba que no se cumpla la condición a la que precede (Operador NOT)
Ejercicios
Ejercicio 1: Evaluar el valor de una variable
Realizar un programa que me indique si el valor de una variable es mayor a 10. Para ello vamos a declarar una variable y le daremos un valor cualquiera (por
ejemplo 20), luego compararemos el valor de la variable con 10 para saber si esta es mayor, si es mayor se imprimirá en el monitor serie un mensaje
indicándolo, y si no lo es también nos lo dirá con un mensaje.
Ejercicio 2: Verificar un número
Usando el monitor serie evaluar si el numero entero introducido es igual, menor o mayor a 22. Se debe recibir un mensaje de respuesta en el monitor serial
para cada caso.
Ejercicio 3: Uso de switch
Usando la función switch, verificar usando el monitor serial si el número introducido es igual a 17, 22 o 25, indicándolo mediante un mensaje.
Ejercicio 4: Comparaciones
Usando dos variables, una llamada presión y otra temperatura, hacer un programa que evalúe si la presión es menor a 7.5 y la temperatura mayor a 80, en
ese caso mandar una alerta por el monitor serial. Adicionalmente si la presión baja de 3.1 enviar una alarma también por el monitor serial.
Como usar las entradas y salidas digitales
Cuando iniciamos con Arduino nos preguntamos ¿Cómo usar las entradas y salidas digitales
en Arduino?
El uso de los puertos de entrada y salida digitales es bastante sencillo. Se usan básicamente
3 funciones.
Configura los pines con pinMode()
Con pinmode() configura un pin digital como entrada o como salida de corriente. Esto es
necesario ya que podemos decidir cómo funcionara cada pin, si como entrada o como
salida. Es por ello que esta función se suele escribir dentro de setup(). No tiene valor de
retorno. Y su sintaxis es muy sencilla:
pinMode(pin,tipo);
Donde
pin: es el número de pin digital (0,1,…13) o podemos usar los analógicos (A0, A1,…A5)
tipo: INPUT, OUTPUT, o INPUT_PULLUP
INPUT define el pin como entrada digital, OUTPUT como salida y adicionalmente tenemos la opción de usar un pin digital como entrada con una resistencia
resistencia pull-up de 20 KΩ que todo pin digital incorpora. Para ello, se ha de utilizar la constante predefinida INPUT_PULLUP en vez de INPUT.
Escribe en un pin de salida con digitalWrite()
La función digitalWrite() envía un valor ALTO (HIGH) o BAJO (LOW) a un pin digital. El pin al que se le envía la señal se especifica como primer parámetro
(escribiendo su número) y el valor concreto de esta señal se especifica como segundo parámetro (escribiendo las constantes predefinidas HIGH o LOW). La
sintaxis es como sigue:
digitalWrite(pin,valor);
Donde
valor: es HIGH (1) o LOW (0)
Si el pin especificado en digitalWrite() está configurado como salida, la constante HIGH equivale colocar en ese pin de salida 5 V (o bien 3,3 V en las placas
que trabajen a ese voltaje) y la constante LOW equivale a una señal de salida de 0 V. Cada pin digital tiene una capacidad de corriente de hasta 40mA.
Lee tus pines de entrada con digitalRead()
Y la función digitalRead() devuelve el valor leído de un pin digital. Este valor de retorno es de tipo int y puede tener dos únicos valores un 1 o un 0. La
sintaxis es la siguiente:
digitalRead(pin);
Donde
Si la entrada es de tipo INPUT, el valor HIGH se corresponde con una señal de entrada mayor de 3 V y el valor LOW con una señal menor de 2 V.
Si la entrada es de tipo INPUT_PULLUP, al tener la entrada conectada una resistencia “pull-up”, las lecturas son al revés: el valor HIGH indica que no se recibe
señal de entrada y el valor LOW que sí.
Configuración pull-up/pull-down
En la configuración pull-Up el voltaje de salida (Vout) es 1 (5V) cuando el pulsador no esta presionado, y 0 (0V) cuando si lo esta. Y en la configuracion Pull-
Down el voltaje de salida es 0 (0V) cuando no esta presionado el pulsador y 1 (5V) cuando si lo esta. Este voltaje de salida es el que leería el pin de entrada
digital.
Si configuramos una entrada como INPUT_PULLUP se activa una resistencia interna del
microcontrolador conectada entre el pin de entrada y 5V, similar a R1.
Configuración Sinking/Sourcing
La configuracion Sinking/Sourcing se refiere a si de la salida digital entra o sale corriente, en
la configuración Sourcing la corriente sale del pin digital, y en la configuracion Sinking la
corriente entra.
Veamos un par de ejemplos muy sencillos de cómo utilizar los pines de entrada y salida digitales.
Ejemplo 1
void setup(){
pinMode(4,OUTPUT); //Configuramos el pin 4 como salida, donde está conectado un LED.
void loop(){
digitalWrite(4,HIGH); //Decimos que se encienda el LED
delay(1000); //Esperamos un segundo (1000ms)
digitalWrite(4,LOW); //Decimos que se apague el LED
delay(1000); //Esperamos un segundo
Ejemplo 2
int estadoBoton=0; //Guardará el estado del botón (HIGH ó LOW)
void setup(){
pinMode(4,OUTPUT); //Donde está conectado el LED
pinMode(8,INPUT); //Donde está conectado el pulsador
}
void loop() {
estadoBoton=digitalRead(8); //Lee el estado del pin 8
if (estadoBoton == HIGH) { //Si se detecta que el botón está pulsado, se enciende el LED
digitalWrite(4,HIGH);
} else { //Si no esta pulsado lo apaga
digitalWrite(4,LOW);
Ejercicios
Para realizar los ejercicios utilizaremos el siguiente circuito

Ejercicio 1: Encender un led

Hacer que los tres leds se enciendan mientras este presionado el pulsador.
Ejercicio 2: Titilar
Hacer que uno o varios leds titilen una vez pulsado el botón.
Ejercicio 3: Rotando luces

Hacer que los leds se vayan encendiendo de forma secuencial (rojo, amarillo, verde, rojo amarillo,
verde,….) uno a la vez y de forma continua, se inicia cuando se presione el pulsador.
Ejercicio 4: Semáforo
Hacer que el conjunto de los tres leds se comporten como un semáforo.
Ejercicio 5: Cambio de estado

Hacer que los leds se enciendan al pulsar el botón, y se apaguen al volverlo a pulsar.
Como usar las entradas y salidas

analógicas
El uso de las entradas y salidas analógicas en Arduino, está basado en tres funciones
analogWrite(), analogRead() y analogReference(). Y podemos ayudarnos con dos funciones
adicionales que nos facilitan la interpretación de las lecturas analógicas que son las
funciónes map() y constrain().
Señales analógicas y señales digitales

Una señal analógica es un tipo de señal que cambia sus valores de forma continua a través
del tiempo. Y una señal digital puede representar cambios de valores pero no los realiza de
forma continua, sino que usa una codificación digital binaria (unos y ceros). Por lo que solo
representa algunos valores.
Señal analógica
Señal digital
Una señal analógica puede ser representada de forma digital, usando un procedimiento que
se denomina conversión analógico digital, este consiste en tomar medidas de la señal
analógica cada cierto tiempo y representar cada medida con valores digitales. Un ejemplo
sencillo lo podemos ver en la siguiente gráfica.
Conversión analógico-digital
Donde podemos representar los valores que tiene una señal analógica por medio de dos
bits, y de esa forma tendríamos una señal digital, que representa la señal analógica.
A medida que tengamos mas valores (bits) para representar la señal analógica, mas real
sera su representación.
Arduino usa 10 bits para realizar la conversión analógica digital de una señal analógica, y
convierte los valores de la señal de entrada entre 0 y 5 voltios, a valores entre 0-1023.
Lectura de valores analógicos en Arduino
La función analogRead()
Devuelve el valor leído del pin de entrada analógico (A0, A1,…A5) que se le ha indicado.
Este valor se obtiene mapeando proporcionalmente la entrada analógica obtenida (que
puede tener cualquier valor entre 0 y un voltaje llamado voltaje de referencia, el cual por
defecto es 5 V) a un valor entero entre 0 y 1023. Por lo que podríamos detectar cambios en
la señal analógica de entrada de hasta (resolución de lectura que es 5V/1024) 0,004883 V.
La sintaxis es la siguiente:
NombreVariable = analogRead(pin);
Donde
pin: es el pin analogico donde conectamos la señal A0, A1, A2, A3, A4, A5
La variable donde vamos a guardar el valor de la lectura debe ser una variable tipo entero (int).
Algo que debemos tener en cuenta en nuestros sketchs es que al microcontrolador le toma cerca de 100 microsegundos (0.0001 s) el leer un entrada
analógica, así que la máxima frecuencia de lectura es de 10,000 lecturas por segundo.
Ejemplo 1 – Leer un potenciómetro

int valorPot=0; //variable para guardar el valor leído del potenciómetro
void setup(){
Serial.begin(9600); //Inicio el monitor serial
void loop(){
valorPot=analogRead(A2); //Leo la entrada analógica A2
Serial.println(valorPot); //Imprimo el valor leído en el monitor serial
delay(1000); //Espero 1 segundo para hacer la siguiente lectura
Para que nos sirve la función analogReference()
Configura el voltaje de referencia usado por la entrada analógica, que por defecto está configurado a 5 voltios. Las opciones son, DEFAULT (ajusta el voltaje
de referencia a 5V), INTERNAL (ajusta el voltaje de referencia a 1.1V) y EXTERNAL (usa el voltaje aplicado al pin AREF como voltaje de referencia). La sintaxis
será la siguiente:
analogReference(tipo);
Donde
tipo: es DEFAULT (5V), INTERNAL (1,1V), EXTERNAL
Modificar el voltaje de referencia implica que la resolución de lectura será mayor, pero también que solo podemos leer señales analógicas dentro del rango
de voltaje definido por 0 y el voltaje de referencia. Por ejemplo, para un voltaje de referencia de 1.1V, la resolución de lectura será de 1.1V/1024, es decir,
de 0,001074 V.
Existen un par de funciones que resultan muy útiles cuando trabajamos con entradas analógicas, y estas son map() y Constrain().
La útil función map()
Escala un número de un rango a otro rango. Esto es, el valor fromLow será escalado a toLow, y el valor de fromHigh será escalado a toHigh, y todos los
valores entre estos límites, etc. Esta función no admite decimales, estos serán truncados. La sintaxis es la siguiente:
NombreVariable = map(value, fromLow, fromHigh, toLow, toHigh);
donde
value: es el número a escalar
fromLow: el límite inferior del actual rango de valores
fromHigh: el límite superior del actual rango de valores
toLow: el límite inferior del rango deseado de valores
toHigh: el límite superior del rango deseado de valores
Ejemplo 2 – Conversión de valor de voltaje
/* Escala un valor de entrada analógico 10bits (0 a 1023) a 0 a 500ºC
Un sensor de temperatura tiene una señal de salida de 0 a 5V que representa
una temperatura de 0 a 500ºC */

void setup() {
Serial.begin(9600);
void loop()
int valor = analogRead(A0); //Lee la entrada analógica y la guarda en la variable valor
delayMicroseconds(100); //Espera 100 microsegundos por la conversión analógica digital
Serial.print(valor); //Escribe la lectura
Serial.print(“ “); //Escribe un par de espacios
valor = map(valor, 0, 1023, 0, 500); //Escala la variable de 0-1023 a 0-500
Serial.println(valor); //Escribe el valor de la temperatura
Y la función constrain()
Limita un número a estar dentro de un rango. Si el valor a limitar es superior al límite superior b, entonces la función devuelve b, y si es inferior al límite
inferior a, entonces devuelve a. Esta función trabaja con todos los tipos de datos y la sintaxis es:
NombreVariable = Constrain(x,a,b);
donde
x: es el número a limitar
a: el límite inferior del rango
b: el límite superior del rango
Escritura de valores analógicos en Arduino
¿Como funciona analogWrite()?
Coloca en el pin seleccionado una señal equivalente a un voltaje. Esta señal equivalente, es una señal PWM, cuya magnitud podemos variar de acuerdo a un
parámetro de tipo “byte” (con valores entre 0 y 255). No todos los pines digitales pueden generar señales PWM: en la placa Arduino UNO por ejemplo solo
son los pines 3, 5, 6, 9, 10 y 11 (están marcados en la placa con el simbolo ᷉ al lado del número de la entrada digital). Cada vez que se ejecute esta función se
regenerará la señal. Esta función no tiene valor de retorno, y su sintaxis es muy sencilla:
analogWrite(pin,valorPWM);
Donde
pin: es el número de pin con capacidad para PWM 3, 5, 6, 9, 10, y 11 (en Arduino UNO)
valorPWM: es un numero entre 0 y 255

¿Y qué es PWM?
Una señal PWM es una señal digital cuadrada que simula ser una señal analógica. El valor simulado de la señal analógica dependerá de la duración que tenga
el pulso digital (es decir, el valor HIGH de la señal PWM). Si el segundo parámetro de esta función vale 0, significa que su pulso no dura nada (es decir, no hay
señal) y por tanto su valor analógico “simulado” será el mínimo (0V). Si vale 255, significa que su pulso dura todo el período de la señal (es decir, es una señal
continua) y por tanto su valor analógico “simulado” será el máximo ofrecido por la placa (5V). Cualquier otro valor entre estos dos extremos (0 y 255) implica
un pulso de una longitud intermedia (por ejemplo, el valor 128 generará una onda cuadrada cuyo pulso es de la misma longitud que la de su estado bajo) y
por tanto, un valor analógico “simulado” intermedio (en el caso anterior, 2,5 V).
Ejemplo 3 – Controlar el brillo de un LED

int brillo = 127;
void setup(){
pinMode(9, OUTPUT); //El LED está conectado al pin 9 (PWM)
analogWrite(9, brillo); //Enciende el LED a aproximadamente la mitad del voltaje
void loop(){}
Ejemplo 4 – Controlar el brillo de un LED con un potenciómetro
/* Escala un valor de entrada analógico 10bits (0 a 1023) a 8 bits (0 a 255) */
void setup() {}
void loop()
int valor = analogRead(A0); //Lee la entrada analógica y la guarda en la variable val
delayMicroseconds(100); //Espera por la conversión analógico digital
valor = map(valor, 0, 1023, 0, 255); //Escala la variable de 0-1023 a 0-255
analogWrite(9, valor); //Escribe el valor escalado en la salida analógica
---------------------------------------------------------------------------------------------------------------
Ejercicios
Para realizar los ejercicios utilizaremos el siguiente circuito
Ejercicio 1: Encender un led con voltaje variable

Hacer que uno o varios Leds se enciendan incrementando su brillo de cero al máximo de
forma cíclica. Para ello debemos usar la funcion de analogWrite(), para variar la señal PWM.
Ejercicio 2: Lectura analógica

Leer el voltaje del potenciómetro, y escalarlo de 0 a 100 y mostrar el valor antes de escalar y
después de escalado en el monitor serial.
Ejercicio 3: Encender un led y variar el brillo con el potenciómetro

Hacer que el Led se encienda incrementando su brillo dependiendo del valor del
potenciómetro. El brillo mínimo será de un 50% del máximo.
Ejercicio 4: Medidor de intensidad

Encender los leds de acuerdo al valor leído en el potenciómetro, y de acuerdo a las
siguientes premisas.
El led verde estará encendido cuando el valor de entrada se encuentre entre el 5 y el 50%.
El led amarillo se encenderá cuando el valor de entrada se encuentre entre el 51 y el 80%.
El led rojo se encenderá cuando el valor de entrada se encuentre entre el 81 y el 100%.
Y con los ejercicios hemos culminado la lección, espero te allá sido de provecho.
Como funciona un for y un while

Los bloques repetitivos permiten ejecutar ciertas instrucciones de forma cíclica siempre que la condición que evalúen sea cierta (true) estos bloques o
funciones son los while y los for.
¿Cómo funciona la función while?
La función while (mientras) es un bloque que implementa un bucle; es decir, repite la ejecución de las instrucciones que están dentro de sus llaves de
apertura y cierre mientras la condición especificada entre sus paréntesis sea cierta (true). Su sintaxis es muy sencilla:
while (condición) {
//Instrucciones que se repetirán mientras la condición sea cierta – true –
}
Si se llega por primera vez a una sentencia while y la condición resulta ser falsa, no se ejecutarán las sentencias interiores ninguna vez. Este detalle es
importante tenerlo en cuenta.
Ejemplo 1
byte x=1; //Declaro una variable tipo byte
void setup(){
Serial.begin(9600); //Inicio la comunicación serie a 9600 baudios
while (x <= 50){ //Mientras x sea menor o igual a 50 ejecuto las instrucciones
Serial.print(x); //Imprime en el monitor serie el valor de la variable x
Serial.println(" es menor de 50"); //Imprime un mensaje del valor de x
x=x+1; //Incrementa en uno el valor de x
Serial.println("x es mayor que 50"); //Imprime un mensaje del valor de x
void loop(){}
¿Y la función do while?
El bucle do funciona exactamente igual que el bucle while, con la excepción de que la condición es evaluada después de ejecutar las instrucciones escritas
dentro de las llaves. Esto hace que las instrucciones siempre sean ejecutadas como mínimo una vez, aun cuando la condición sea falsa. La sintaxis es de la
siguiente forma:
do {
//Instrucciones que se repetirán mientras la condición sea cierta – true –
} while (condición)
Repeticiones determinadas con la función for
La diferencia entre un bucle while y un bucle for está en que en el primero el número de iteraciones realizadas depende del estado de la condición definida,
pero en un bucle for el número de iteraciones se puede fijar a un valor exacto. Por tanto, usaremos el bucle for para ejecutar un conjunto de instrucciones
(escritas dentro de llaves) un número concreto de veces. La sintaxis general del bucle for es la siguiente:
for (valor_inicial_contador;condicion_final;incremento) {
//Instrucciones que se repetirán un número determinado de veces
Tal como se observa, entre paréntesis se deben escribir tres partes diferentes, separadas por puntos y coma. Estas tres partes son opcionales (pueden
omitirse cualquiera de ellas) y son las siguientes:
Valor inicial del contador: en esta parte se asigna el valor inicial de una variable entera que se utilizará como contador en las iteraciones del bucle. Por
ejemplo, si allí escribimos x=0, se fijará la variable x a cero al inicio del bucle.
Condición final del bucle: en esta parte se especifica una condición. Justo antes de cada iteración se comprueba que sea cierta para pasar a ejecutar el grupo
de sentencias internas. Si la condición se evalúa como falsa, se finaliza el bucle, y continúa el programa tras su llave de cierre.
Incremento del contador: en la última de las tres partes es donde se indica el cambio de valor que sufrirá al inicio de cada iteración del bucle la variable
usada como contador. Este cambio se expresa con una asignación. Por ejemplo, la sentencia x=x+1 le sumará 1 a la variable x antes de cada nueva iteración
del bucle, por lo que en realidad estaríamos haciendo un contador que aumenta de uno en uno a cada repetición. Este cambio se efectúa justo antes de
comprobar la condición de final del bucle.
Ejemplo 2
byte x; //Declaro una variable tipo byte
void setup(){
for (x=0;x<10;x=x+1){ //Imprime los números del 0 al 9 en el monitor serie
Serial.println(x); //Imprime en el monitor serie el valor de la variable x
void loop(){}
Las instrucciones break y continue
La instrucción break debe estar escrita dentro de las llaves que delimitan las sentencias internas de un bucle, y sirve para finalizar este inmediatamente. Es
decir, esta instrucción forzará al programa a seguir su ejecución a continuación de la llave de cierre del bucle.
La instrucción continue también debe estar escrita dentro de las llaves que delimitan las sentencias internas de un bucle y sirve para finalizar la iteración
actual y comenzar inmediatamente con la siguiente. Es decir, esta instrucción forzará al programa a “volver arriba” y comenzar la evaluación de la siguiente
iteración aun cuando todavía queden instrucciones pendientes de ejecutar en la iteración actual.
Ejemplo 3
byte x; //Declaro una variable tipo byte
void setup(){
for(x=0;x<16;x++){ //Imprime los números del 0 al 15 en el monitor serie
if (x==10) break; //interrumpe la ejecución del for cuando x es igual a 10
Serial.println(x); //Imprime en el monitor serie el valor de la variable x
void loop(){}
Ejercicios
Ejercicio 1: Números del 50 al 1
Imprimir en el monitor serial los números del 50 al 1.
Ejercicio 2: Números pares
Imprimir en el monitor serial los números pares del 0 al 50. Ordenados en 5 filas.
Ejercicio 3: Break o continue
Partiendo del ejercicio anterior usando las funciones “break” o “continue” evitar que se imprima el 20 y el
40.
Ejercicio 4: Variar los colores de un LED RGB
Probar todas las combinaciones de colores que podemos hacer con un LED RGB (rojo, verde y azul) usando
PWM con valores que vayan desde 150 hasta 255. Debemos tener en cuenta un tiempo de espera de 10ms
entre cada cambio de color.
Para ello es necesario montar el siguiente circuito:

Control de tiempo con millis()
Arduino cuenta con un conjunto básico de funciones para el manejo de tiempo, estas son: millis(), micros(), delay() y
delayMicroseconds(), a continuación las describimos:
La función millis()
Devuelve el número de milisegundos (ms) desde que la placa Arduino empezó a ejecutar el sketch. Este número se reseteará a
cero aproximadamente después de 50 días (cuando su valor supere el máximo permitido por su tipo de variable, que es “unsigned
long”). No tiene parámetros.
Y la función micros()
Devuelve el número de microsegundos (μs) desde que la placa Arduino empezó a ejecutar el sketch. Este número (de tipo
unsigned long) se reseteará a cero aproximadamente después de 70 minutos. Esta instrucción tiene una resolución de 4 μs (es
decir, que el valor retornado es siempre un múltiplo de cuatro). Recordar que 1000 μs es un milisegundo y por tanto, 1000000 μs es
un segundo. No tiene parámetros.
Ejemplo 1 – Conteo de tiempo en microsegundos

unsigned long time; //Declara un variable del mismo tipo que la que devuelve micros()
void setup(){
Serial.begin(9600); //Inicializa la comunicación serial
void loop(){
time = micros(); //Consulta los microsegundos que se inició el sketch
Serial.println(time); //Imprime el valor en el monitor serial
delay(1000); //Espera 1 segundo
La espera es con delay()

Pausa el sketch durante la cantidad de milisegundos especificados como parámetro (de tipo unsigned long). No tiene valor de
retorno.
Y la espera con delayMicroseconds()

Pausa el sketch durante la cantidad de microsegundos especificados como parámetro (de tipo unsigned long) . Actualmente el
máximo valor que se puede utilizar con precisión es de 16383. Para esperas mayores que esta, se recomienda usar la instrucción
delay(). El mínimo valor que se puede utilizar con precisión es de 3 μs. No tiene valor de retorno.
Ejemplo 2 – Como funciona millis()

unsigned long inicio, fin, transcurrido; // Declaramos 3 variables
void setup(){
Serial.begin(9600); //Inicializa la comunicación serial
void loop(){
inicio=millis(); //Consulta los milisegundos desde que se inició el

sketch
delay(1000); //espera un segundo
fin=millis(); //Consulta los milisegundos desde que se inició el

sketch
transcurrido=fin-inicio; //Calcula el tiempo desde la última lectura
Serial.println(transcurrido); //Imprime el valor en el monitor serial
delay(500); //espera 0.5 segundos
Las funciones delay() y delayMicroseconds() como lo mencionamos anteriormente, ponen en pausa el sketch, lo cual puede
resultar un problema cuando tenemos otras funciones que atender, y este problema se ve acentuado cuando los tiempos de espera
son largos. Para resolver esto es recomendable usar la funcion millis() para controlar esos tiempos. En el siguiente ejemplo
veremos como hacer parpadear un led usando millis(). Y podemos usar una programación similar para atender eventos periódicos.
Ejemplo 3 – Hacer parpadear un led con millis()

int estadoLed; //guarda el estado del led (encendido o apagado)
int periodo = 100; //
unsigned long tiempoAnterior = 0; //guarda tiempo de referencia para comparar

void setup() {
pinMode(13,OUTPUT); //configura la salida
void loop() {
if(millis()>tiempoAnterior+periodo){ //si ha transcurrido el periodo programado
estadoLed = !estadoLed; //cambia el estado del led cada 100ms
digitalWrite(13,estadoLed);
tiempoAnterior = millis(); //guarda el tiempo actual como referencia
Ejercicios
Para realizar algunos ejercicios es necesario que montemos el siguiente circuito:
Ejercicio 1: Medir tiempo

Medir cuanto tiempo le toma al microcontrolador ejecutar diferentes tipos de instrucciones. Y mostrar el resultado en el monitor
serial.
Ejercicio 2: Dos leds intermitentes

Hacer que un led parpadee, que se encienda por 600ms y este apagado por 600ms, y un segundo led también parpadeara pero
estará encendido por 300ms, usando la función delay().
Ejercicio 3: Led de tiempo programable

Hacer que un led encienda y apague a una velocidad variable, (entre 0.2s y 2s) usando un potenciómetro para ajustar esta
velocidad.
Ejercicio 4: Dos leds intermitentes con millis

Hacer que un led parpadee, que se encienda por 600ms y este apagado por 600ms, y un segundo led también parpadeara pero
estará encendido por 300ms y apagado por 300ms, usando la función millis().
Creación y uso de funciones en Arduino

¿Como Creamos una función en Arduino?
Una función es un conjunto de instrucciones al que se les identifica con un nombre. Usando posteriormente ese nombre, podemos
llamar a la función para que ejecute las instrucciones incluidas dentro de ella, simplemente escribiendo su nombre en el lugar
deseado de nuestro sketch.
Para crear una función propia, primero debemos declararla. Esto se hace en cualquier lugar fuera de setup() y loop(), antes o
después. Una función puede o no retornar valores, y también puede o no recibir parámetros, esto se hace siguiendo la sintaxis
marcada por la plantilla siguiente:
tipodeRetorno nombredeFuncion (tipodeparam1, tipodeparam2,...) {

// Código interno de la función
}
donde
tipodeRetorno: Indica el tipo de valor que la función devolverá al sketch principal una vez
ejecutada.
nombredefuncion: Es el nombre que le damos a la función
tipodeparam: son las declaraciones de los parámetros de la función, que no son más que variables
internas cuya existencia solo perdura mientras el código de esta se esté ejecutando.
Ejemplo 1
void blinkLED() { //Se declara la función, esta no devuelve ningún valor ni recibe parámetros
digitalWrite(13, HIGH); //Se enciende el led en el pin 13
delay(100); //Se espera 0,1 segundos

digitalWrite(13, LOW); //Se apaga el led en el pin 13
delay(100); //Se espera 0,1 segundos
void setup(){
pinMode(13,OUTPUT); //Se configura el pin 13 como salida
void loop(){
blinkLED(); //Se llama a la función
Ejemplo 2
int primerNumero=2; //Declaro e inicializo una variable global
int segundoNumero=3; //Declaro e inicializo una variable global
int recojoResultado; // Declaro e inicializo una variable global
int multiplicar(int x, int y){ // Se declara la función, retorna un valor y recibe dos
parámetros
int resultado; // Se declara la variable resultado, esta es interna de la

función
resultado = x*y; //Es la operación que realiza la función
return resultado; //retorna el valor de la variable resultado
void setup(){
Serial.begin(9600); //Inicializo el Puerto serial
recojoResultado=multiplicar(primerNumero,segundoNumero); //Llamo la función y tomo su valor de

retorno
Serial.println(recojoResultado); //Imprimo el resultado en el puerto serial
void loop(){}
Ejercicios
Para realizar los ejercicios podemos usar el siguiente circuito:
Ejercicio 1: Modificar función

Modificar la función blinkLED del ejemplo 1, para que podamos indicarle el tiempo en alto y en bajo que deseemos, como
parámetros de la función.
Ejercicio 2: Leer valor analógico

Crear una función que lea el valor del potenciómetro 5 veces y devuelva el promedio de las 5 lecturas.
Ejercicio 3: Leer valor analógico y encender LEDs

Modificar la función del ejercicio 2 para que adicionalmente encienda un led con el valor proporcional al valor leído del
potenciómetro.
Ejercicio 4: Crear una función que lea del puerto Serial

Crear una función que lea tres valores enteros del puerto serial y los sume, esta función debe retornar el valor de la suma después
de leídos los tres valores.
Como usar las matrices (arrays) en

Arduino
¿Que es una matriz?
Una matriz (array) es una colección de variables que tienen todas el mismo y único nombre, pero que pueden distinguirse entre sí
por un número de índice. Es decir: en vez de tener diferentes variables – por ejemplo de tipo “char” – cada una independiente de
las demás (varChar1, varChar2,varChar3…) podemos tener una única matriz que las agrupe todas bajo un mismo nombre (por
ejemplo, varChar), y que permita que cada variable pueda manipularse por separado gracias a que dentro de la matriz cada una
está identificada mediante un índice numérico, escrito entre corchetes (varChar[0], varChar[1], varChar[2]…).
Las matrices sirven para ganar claridad y simplicidad en el código, además de facilitar la programación.
Al utilizar matrices debemos tener presente que para consultar o asignar valores, debemos comenzar indexando el primer
elemento por el número cero, que será el primer elemento de la matriz.
Ejemplo 1 – Como declarar las matrices

int misEnteros[6]; //declara una matriz de 6 variables de tipo int
int misPines[] = {2, 4, 8, 3, 6}; //declara una matriz de 5 variables tipo int
float misSensores[5] = {2, 4, -8, 3.8, 2.1}; //declara una matriz de 5 variables tipo float
char mensaje[5] = "Hola"; //declara una matriz de 5 elementos tipo char

char mensaje [] = "Hola"; //declara una matriz de 5 elementos tipo char
char mensaje [5] = {'h','o','l','a'}; //declara una matriz de 5 elementos tipo char
Las matrices tipo char necesitan un carácter adicional para saber cuál es el fin de la matriz, esto debemos tenerlo en cuenta para el
tamaño de la matriz.
Asignar y tomar valores de una matriz

Para asignar y consultar los valores de una matriz se usa el operador de asignación (=).
misSensores[0] = 10; //asigna 10 al primer elemento de la matriz
x = misSensores[4]; //guarda el valor del quinto elemento de la matriz en la variable x
Ejemplo 2 – Encender en secuencia un conjunto de Leds

int pines[] = {2, 3, 4, 5, 6, 7}; //declaro una matriz con los numeros de pines a usar
int contador = 0; //Una variable contador
int tiempo = 100; //Una variable guarda el tiempo de activacion de los pines
void setup(){
for (contador=0; contador<6; contador++) { //Uso un for para declarar todos los pines
pinMode(pines[contador], OUTPUT); }
}
void loop() {
for (contador =0; contador <6; contador ++) { //Uso un for para encender leds conectados
digitalWrite(pines [contador], HIGH); //a los pines, y uso una matriz para acceder
delay(tiempo); //a ellos secuencialmente
digitalWrite(pines [contador], LOW);
delay(tiempo);
}
for (contador =5; contador >=0; contador --) {
digitalWrite(pines [contador], HIGH);
delay(tiempo);
digitalWrite(pines [contador], LOW);
delay(tiempo);
}
}
Matrices de cadenas de texto
Es posibles hacer matrices de cadenas de texto, este es un ejemplo de matrices de dos dimensiones, en el ejemplo siguiente el
asterisco después del tipo de dato “char*“ indica que esta es una matriz de punteros. Sin entrar en detalles que son los punteros
podemos ver como se usan.
Ejemplo 3 – Matrices de cadenas de texto

char* miscadenas[] = {" Esta es la cadena 1", " Esta es la cadena 2", " Esta es la cadena 3",
" Esta es la cadena 4"}; //declaro una matriz de cadenas de texto
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i = 0; i < 4; i++) { //imprimo todas las cadenas de la matriz
Serial.println(miscadenas [i]);
delay(500);
}
}
Ejercicios
Ejercicio 1: Consultar una matriz de números
Crear una matriz de 6 variables tipo int, asignarle los valores 10, 20, 30, 40, 50 y 60. Y luego imprimir estos valores en el monitor
serie usando un lazo “for”.
Ejercicio 2: Consultar una matriz de caracteres

Crear una matriz de caracteres que contenga el mensaje “Hola mundo”, e imprimir está en el monitor serie.
Ejercicio 3: Guardar y consultar valores

Hacer un programa que capture 6 valores enteros desde el pin A0, los guarde en una matriz, y luego imprima los valores de la
matriz en el monitor serie.
Ejercicio 4: Juego de luces

Probar el sketch del ejemplo 2. Podemos hacer alguna variación? Probemos algunas.
Ejercicio 5: Adivinador
Crear matriz con seis o mas mensajes diferentes que sirvan para responder una pregunta (por ejemplo: Si, No, Quizás, Nunca,
Siempre, algunas veces, etc). Conectaremos también un pulsador a la entrada digital 2. Cada vez que presionemos el pulsador
aparecerá en el monitor serie uno de los mensajes de forma aleatoria. Y de esta forma habremos creado un adivinador, haremos
una pregunta y al pulsar el botón este nos dará una respuesta. Para generar el numero aleatorio usar la función random().
Como usar una pantalla LCD con arduino

¿Qué es un LCD?
Una pantalla de cristal líquido o LCD (sigla del inglés liquid crystal display) es una pantalla delgada y plana formada por un número
de píxeles en color o monocromos colocados delante de una fuente de luz o reflectora. A menudo se utiliza en dispositivos
electrónicos de pilas, ya que utiliza cantidades muy pequeñas de energía eléctrica.
Estas pantallas nos sirven para mostrar caracteres y números, y en los modelos gráficos podremos mostrar gráficos o dibujos.
Usarlas en nuestros proyectos nos permite por tanto mostrar información. Unas de las más comunes son las de caracteres, las
cuales vienen de diferentes tamaños, denotados por el número de columnas y filas, son populares las de 16×2, las cuales tienen 16
columnas y 2 filas. A continuación veremos cómo conectarlas a Arduino y como mostrar información en ellas.
Conexión de un LCD 16×2 a Arduino

La conexión se muestra a continuación (gráfico y esquemático):
Como podemos ver requerimos de un mínimo de 6 pines digitales para conectar la pantalla. Y debemos también incorporar una
resistencia de 220 ohms para conectar el led de luz de fondo (background) y un potenciómetro para ajustar el contraste. Una vez
conectado el circuito ya podemos hacer algunas pruebas. Para ello nos serviremos de una librería.
Como usar la librería LiquidCrystal

Esta librería pertenece a las librerías estándar de Arduino ( incluidas en el IDE) y permite controlar las pantallas LCD basadas en el
controlador Hitachi HD44780 (o un chipset compatible), que se encuentra en la mayoría de las pantallas LCD basadas caracteres
alfanumericos. La librería funciona bien con una interface de 4 o 8 bits. (por ejemplo usando 4 o 8 líneas de datos más el rs y
el enable, y, opcionalmente la línea de control rw.
Las funciones de la librería son las siguientes (incluyen los enlaces a su descripción en el sitio web de arduino):
 LiquidCrystal()
 begin()
 clear()
 home()
 setCursor()
 write()
 print()
 cursor()
 noCursor()
 blink()
 noBlink()
 display()
 noDisplay()
 scrollDisplayLeft()
 scrollDisplayRight()
 autoscroll()
 noAutoscroll()
 leftToRight()
 rightToLeft()
 createChar()
A continuación vamos a explicar las de uso común,
LiquidCrystal()
Descripción
Crea una variable de tipo LiquidCrystal. La pantalla puede ser controlada usando 4 o 8 líneas de datos. Si se omiten los números
de pin para d0 hasta d3, se pueden dejar esos pines desconectados, o conectados a tierra, el pin RW también puede ser
conectado a tierra también en vez de conectarlo al Arduino.
Sintaxis
LiquidCrystal lcd(rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(rs, rw, enable, d4, d5, d6, d7)
LiquidCrystal lcd(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
LiquidCrystal lcd(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
Parámetros
lcd: una variable de tipo LiquidCrystal (el nombre que le das a tu LCD)
rs: el numero del pin de Arduino que es conectado a el pin RS del LCD
rw: el numero del pin de Arduino que es conectado a el pin RW del LCD (opcional)
enable: el numero del pin de Arduino que es conectado a el pin enable del LCD
d0, d1, d2, d3, d4, d5, d6, d7: los números de pines de Arduino que son conectados a los pines de datos correspondientes del
LCD. d0, d1, d2, y d3 son opcionales; si son omitidos, el LCD será controlado usando solo cuatro líneas de datos (d4, d5, d6, d7).
begin()
Descripción
Inicializa la interface de la pantalla LCD, y especifica las dimensiones de la pantalla (ancho y alto). begin() debe ser llamada antes
que cualquier otra función de la librería.
Sintaxis
lcd.begin(columnas, filas)
Parámetros
lcd: una variable de tipo LiquidCrystal
columnas: el numero de columnas que tiene la pantalla
filas: el numero de filas que tiene la pantalla

clear()
Descripción
Limpia la pantalla LCD y coloca el cursor en la esquina superior izquierda.
Sintaxis
lcd.clear()
Parámetros
setCursor()
Descripción
Posiciona el cursor de la pantalla LCD; esto es, define la ubicacion donde el texto escrito en la pantalla sera mostrado.
Sintaxis
lcd.setCursor(columna, fila)
Parámetros
columnas: la columna en la cual se posicionara el cursor (se comienza a contar en 0)
filas: la fila en la cual se posicionara el cursor (se comienza a contar en 0)
print()
Descripción
Imprime texto en el LCD.
Sintaxis
lcd.print(data)
lcd.print(data, BASE)
Parámetros
data: la información a imprimir (char, byte, int, long, or string)
BASE (optional): el formato en el cual imprimir los numeros: BIN para binario (base 2), DEC para decimal (base 10), OCT para octal
(base 8), HEX para hexadecimal (base 16).
La librería LiquidCristal trae números ejemplos los cuales podemos ver en el IDE. Veamos algunos de ellos.
Ejemplo 1 – Hola mundo

#include <LiquidCrystal.h> //debemos incluir la libreria
// Indicamos los pines a los cuales tenemos conectada la LCD

LiquidCrystal milcd(12, 11, 5, 4, 3, 2);
void setup() {
// Indicamos el numero de columnas y filas, he inicializamos la LCD
milcd.begin(16, 2);
// Imprimimos un mensaje en primera fila
milcd.print("Hola mundo!");
}
void loop() {
// colocamos el cursor en la columna 0 y fila 1
// notemos que la fila 1, es la segunda fila, ya que comenzamos a contarlas desde 0
milcd.setCursor(0, 1);
// Imprimimos el numero de segundos desde que se reinicio la placa
milcd.print(millis() / 1000);
}
Ejemplo 2 – Activar y desactivar el cursor
#include <LiquidCrystal.h> //debemos incluir la libreria

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// Indicamos el numero de columnas y filas, he inicializamos la LCD
lcd.begin(16, 2);
// Imprimimos un mensaje en primera fila
lcd.print("hello, world!");
}
void loop() {
// desactiva el cursor
lcd.noCursor();
delay(500);
// activa el cursor
lcd.cursor();
delay(500);
}
Algo que complementa los caracteres alfanuméricos en las pantallas LCDs es la posibilidad de imprimir caracteres especiales.
Para ello usaremos la función createChar() la cual explicaremos a continuación.
createChar()
Descripción
Crea un carácter personalizado para su uso en la pantalla LCD. Se admiten hasta ocho caracteres de 5×8 píxeles (numerados de 0
a 7). El aspecto de cada carácter personalizado se especifica mediante una matriz de ocho bytes, uno para cada fila. Los cinco bits
menos significativos de cada byte determinan los píxeles de esa fila. Para mostrar un carácter personalizado en la pantalla, se usa
la función write() con su número.
Importante! Cuando se hace referencia al carácter personalizado “0”, si no está en una variable, se debe convertir (cast) como byte,
de lo contrario el compilador arroja un error.
Sintaxis
Lcd.createChar (num, datos)
Parámetros
Lcd: una variable del tipo LiquidCrystal
Num: qué carácter crear (0 a 7)
Datos: los datos de píxeles del personaje
Ejemplo 3 – Imprimir caracteres especiales

#include <LiquidCrystal.h> //debemos incluir la librería

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// Declaramos una matriz e incializamos los elementos con

// los pixeles que queremos activar marcados con unos
byte feliz[8] = {
B00000,
B10001,
B00000,
B00000,
B10001,
B01110,
B00000,
};
void setup() {
lcd.createChar(0, feliz); // Creamos el caracter especial 0
lcd.begin(16, 2); // Indicamos el numero de columnas y filas, he inicializamos la LCD

lcd.write(byte(0)); //Imprimimos el caracter especial 0
}
void loop() {}
Ejercicios
Ejercicio 1 – Imprimir dos valores
Imprimir el valor de dos variables en la LCD, una en cada linea, identificandolas como variable 1 y variable 2, la variable 1 es un
contador que cambia de valor cada segundo y la variable 2 es un contador que cambia cada 3 segundos.
Ejercicio 2 – Caracteres especiales

Partiendo del ejercicio 1, hacer un carácter especial que identifique a cada variable, y sustituir la identificación de la variable por el
carácter especial.
Ejercicio 3 – Termometro
Usando un sensor de temperatura, visualizar la temperatura medida en la pantalla LCD.
¿Que es un servomotor?
Un servomotor (también llamado servo) es un dispositivo similar a un motor de corriente continua que tiene la capacidad de
ubicarse en cualquier posición dentro de su rango de operación, y mantenerse estable en dicha posición.
Está conformado por un motor, una caja reductora y un circuito de control.

¿Como controlar un servomotor?

A diferencia de los motores DC, los servomotores los controlamos con una señal periódica de 50Hz, de acuerdo al tiempo en alto
de esta señal de control el servo se ubicara en una u otra posición. Los servos estándar permiten controlar el movimiento de su eje
usualmente entre 0 y 180 grados. Y los servos de rotación continua permiten controlar la velocidad de rotación de su eje.
¿Como conecto un servomotor?

Los servomotores tienen tres cables, uno para la alimentación de 5V (usualmente de color rojo) otro para la conexión a tierra (de
color negro) y el de la señal de control (normalmente de color amarillo o blanco).
Libreria Servo.h
Esta librería permite a las placas Arduino controlar RC servos (hobby).
La librería servo soporta hasta 12 servomotores en la mayoría de las placas Arduino, y hasta 48 en la Arduino Mega. En todas las
placas menos en la Mega, el uso de la librería deshabilita el uso de analogWrite() (PWM) en los pines 9 y 10, tengan o no tengan
un servo conectado a esos pines.
Funciones de la libreria Servo.h

attach(pin,min,max) Convierte un pin en un controlador de servo. Retorna 0 en caso de falla.
detach() Libera un pin de ser un controlador de servo.
write(angulo) Fija el Angulo del servo en grados, 0 a 180.
writeMicroseconds(us) Fija el Angulo del servo en microsegundos.
read() Devuelve valor fijado con el ultimo write().
attached() Devuelve 1 si el servo esta actualmente “attached”.
Para mas información acerca de la librería Servo.h podemos visitar la web oficial de Arduino.
Ejemplo – Controlar un servo con un potenciometro
//Controla la posición de un servomotor de acuerdo a la posición de un potenciometro
#include <Servo.h> //Incluye la librería para controlar servos
Servo myservo; // Crea un objeto servo para controlar un servomotor
int potpin = 0; // Pin analógico usado para conectar el potenciometro

int val; // variable para leer el valor del pin analógico
void setup() {
myservo.attach(9); // "attach" el servomotor en el pin 9 al objeto servo
}
void loop() {
val = analogRead(potpin); // lee el valor del potentiometro (valor entre 0 y 1023)
val = map(val, 0, 1023, 0, 180); // escalo este para usarlo con el servo (valor entre 0 y 180)
myservo.write(val); // Indico la posición del servo de acuerdo al valor escalado
delay(15); // espero que el servo se mueva
}
SENSORES DE TEMPERATURA Y HUMEDAD

Pero en muchas ocasiones, y especialmente en la industria alimentaria, no basta con medir la temperatura, sino que la humedad relativa
es también un factor importante a tener en cuenta.
Por eso se desarrollaron los sensores de la familia DHT. Nos proporcionan de forma digital la temperatura y la humedad, con diferente
precisión según el modelo.
Básicamente hay dos variantes DHT11 y DHT22
Las características del DHT11 son:
 Muy barato,
 Funciona con 3,3 y 5V de alimentación
 Rango de temperatura: de 0º a 50º con 5% de precisión (pero solo mide por grados, no fracciones)
 Rango de humedad: de 20% al 80% con 5% de precisión
 1 Muestra por segundo (No es el más rápido del oeste)
 Bajo consumo
 Devuelva la medida en ºC
En cuanto al DHT22:
 Barato,
 Funciona con 3,3 y %V de alimentación
 Rango de temperatura: de -40º a 125º ±0.5°C

 Rango de humedad: de 0% al 100% con 5% de precisión.
 Lee 2 veces por segundo.
 Bajo consumo.
 Devuelva la medida en ºC
En cuanto a la forma de conectarlos y programarlos es la misma para ambos modelos y veremos que hay desarrolladas librerías para
Arduino que soportan los dos de una forma sencilla.
MATERIAL REQUERIDO.
Arduino UNO o equivalente.
Una Protoboard más cables.
Una resistencia de 330Ω.

Un sensor de temperatura DHT11.
DIAGRAMAS DEL CIRCUITO
La conexión es trivial, pero cabe destacar que se vende en dos encapsulados, uno de tres pines que son GND, Data y Vcc, y otro 4 pines
y uno de ellos, sencillamente sobra y no se conecta. Normalmente viene rotulado en el sensor el nombre de cada pin, y si no ya sabeis, a
buscar el manual en Google
Vamos con el esquema por cortesía de Fritzing:

Y aquí tenemos el esquema de protoboard.
EL PROGRAMA DE LECTURA DEL DHT11

En primer lugar, tenemos que descargar una librería para manejarlos cómodamente, DX11.zip e importarla. Aquí teneís la librería
http://www.prometec.net/wp-content/uploads/2014/10/DHT11.zip
Hacemos el importar la librería DHT11 que nos pondrá:
#include <DHT11.h>
Y definimos una instancia del sensor donde declaramos el pin al que esta conectado.
int pin=2;
DHT11 dht11(pin);
Leerlo ahora es muy sencillo:
int error ;
float temp, humi;
error = dht11.read(humi, temp)
El programa completo =
#include <DHT11.h>
int pin=2;
DHT11 dht11(pin);
void setup()
Serial.begin(9600);
}
void loop()
int err;
float temp, hum;
if((err = dht11.read(hum, temp)) == 0) // Si devuelve 0 es que ha leido bien
Serial.print("Temperatura: ");
Serial.print(temp);
Serial.print(" Humedad: ");
Serial.print(hum);
Serial.println();
else
Serial.println();
Serial.print("Error Num :");
Serial.print(err);
Serial.println();
delay(1000); //Recordad que solo lee una vez por segundo
El resultado se envía a la consola y aquí podéis ver una muestra.
Para hacer variar os valores, de humedad y temperatura y comprobar que todo funciona correctamente, podeis, sencillamente, enviar
vuestro aliento al sensor, y salvo que estéis en el trópico haréis subir tanto la temperatura como la humedad relativa.
SENSOR DE DISTANCIA
MATERIAL REQUERIDO.
Arduino Uno o similar.
 Esta sesión acepta cualquier otro modelo de Arduino.
Una Protoboard mas cables.
Sensor de distancia HC-SR04

Un diodo LED y una resistencia.
COMO FUNCIONA UN SENSOR ULTRASÓNICODE DISTANCIA
Hemos visto, en los documentales, que los murciélagos son capaces de volar en completa oscuridad y sin embargo, sortear obstáculos o
atrapar insectos en vuelo. Sabemos que lo hacen, pero rara vez pensamos como.
Tenemos una vaga idea de que se llama ecolocalización y que más o menos tiene que ver con unos sonidos agudos que emiten y que
después recogen con esas enormes orejas que Dios les ha dado, pero rara vez nos planteamos cómo es esto posible.
Delfines y ballenas utilizan un sistema similar para atrapar a sus presas, y hasta hemos visto que, en cualquier película de submarinos,
en el momento álgido el capitán ordena emitir un pulso único de sonar para localizar al enemigo.
El concepto básico, es siempre el mismo, sabiendo a qué velocidad viaja el sonido, si emitimos un pulso sónico corto y escuchamos
cuanto tiempo tarda en regresar el eco podemos calcular la distancia a la que se encuentra el objeto en el que ha rebotado la señal.
 El radar funciona de modo similar aunque usando ondas de radio frecuencia muy cortasy con una problemática propia descomunal. Un
pulso de radiofrecuencia se emite desde la antena y se recoge el eco que vuelve a la velocidad de la luz.
Lo que haremos en esta sesión es utilizar un sensor de distancia sencillo HC-SR04 (y muy parecido a los sensores de aparcamiento de
los coches modernos), que nos permite enviar estos pulsos ultrasónicos y escuchar el eco de retorno. Midiendo este tiempo, podemos
calcular la distancia hasta el obstáculo.
 El oído humano no percibe sonidos por encima de 20kHz. Por eso, a las ondas de mayor frecuencia las llamamos ultrasonidos ( mas allá
del sonido). Los sensores de ultrasonidos funcionan sobre los 40 kHz.
 No son perfectos, les influye la temperatura ambiente, la humedad y los materiales en los que reflejan, lo que genera una cierta
incertidumbre. Pero a cambio son baratos y efectivos hasta un poco más de 3 metros en condiciones normales si la precisión no es un
problema determinante
DIAGRAMA DE CONEXIÓN
Veamos como conectar uno de esto detectores a nuestros Duinos. Aquí está el esquema eléctrico y de protoboard por cortesía de
Fritzing:
Y de nuevo, el diagrama de conexión de la protoboard
EL PROGRAMA DE CONTROL
Vamos con el programa, empezamos definiendo algunos valores:
#define trigPin 13
#define echoPin 12
#define led 2
Hasta ahora habíamos visto que podíamos definir una variable como int, por ejemplo, y también como una constante (const int pin). Aquí
utilizamos otro método, el #define que es una directiva para el compilador.
Esto solo significa que el compilador (en rigor el pre procesador) cambiará todas las ocurrencias de estos #define en nuestro programa
por su valor antes de compilar. Esta es la forma clásica de C de hacer esto y tiene la virtud de que no ocupa memoria definiendo una
variable (y con un Arduino UNO, que va muy corto de memoria, esto puede ser crítico en ocasiones).
void setup()
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
Ya estamos más que habituados a la función delay(milis), pero el reloj interno de Arduino mide en microsegundos y tenemos otra función
parecida delayMicroseconds(µs) que simplemente congela Arduino el número especificado de microsegundos.
Para dar un pulso ultrasónico lo que hacemos es activar el pin Trigger durante unos microsegundos y para ello lo ponemos en HIGH,
antes de escuchar el eco:
digitalWrite(trigPin, LOW); // Nos aseguramos de que el trigger está desactivado
delayMicroseconds(2); // Para estar seguros de que el trigger ya está LOW
digitalWrite(trigPin, HIGH); // Activamos el pulso de salida
delayMicroseconds(10); // Esperamos 10µs. El pulso sigue active este tiempo

digitalWrite(trigPin, LOW); // Cortamos el pulso y a esperar el echo
Para escuchar el pulso vamos a usar otra función, pulseIn() ( Oh sí, hay muchas, muchísimas). Para leer el manual de pulseIn() buscad
en google Arduino pulseIn y vereis que pronto lo encontrais.
Básicamente lo que hace es escuchar el pin que le pasamos, buscando una señal que pase de LOW a HIGH ( si le pasamos HIGH como
parámetro) y cuenta el tiempo que tarda en volver a bajar desde que sube.
long duracion, distancia ;
duracion = pulseIn(echoPin, HIGH) ;
Ahora ya sabemos el tiempo que tarda en volver el eco en µs. Como la velocidad del sonido es de 343 metros / segundo, Necesitamos
1/343 = 0,00291 segundos para recorrer un metro.
Para usar una medida más cómoda podemos pasar esto a microsegundos por centímetro:
Como nuestro eco mide el tiempo que tarda el pulso en ir y venir la distancia recorrida será la mitad:
Así que el programa queda asi

#define trigPin 13
#define echoPin 12
#define led 2
void setup()
{ Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
void loop()
{ long duracion, distancia ;
digitalWrite(trigPin, LOW); // Nos aseguramos de que el trigger está desactivado
delayMicroseconds(2); // Para asegurarnos de que el trigger esta LOW

digitalWrite(trigPin, HIGH); // Activamos el pulso de salida
delayMicroseconds(10); // Esperamos 10µs. El pulso sigue active este tiempo
digitalWrite(trigPin, LOW); // Cortamos el pulso y a esperar el echo
duracion = pulseIn(echoPin, HIGH) ;
distancia = duracion / 2 / 29.1 ;
Serial.println(String(distancia) + " cm.") ;
int Limite = 200 ; // Medida en vacío del sensor
if ( distancia < Limite)
digitalWrite ( led , HIGH) ;
else
digitalWrite( led , LOW) ;
delay (500) ; // Para limitar el número de mediciones
Para convertir esto en un detector de movimiento hemos creado una variable un poco menor de la medida que el sensor recibe en vacio
(en mi caso unos 200 cm). Si la distancia medida cae por debajo este valor es que algo se ha interpuesto y por tanto encendemos una
alarma, en nuestro caso un humilde LED.
Después de este ejercicio de física y matemáticas, que sin duda causará furor entre los estudiantes aplicados, vamos a hacer el mismo
programa pero usando una librería externa, que alguien se ha molestado en escribir, paras esas pocas personas que no disfrutan de los
problemas de ciencias y que así, podamos ver la diferencia.
Podeís descargar la librería de aquí,
http://www.prometec.net/wp-content/uploads/2014/10/NewPing_v1.5.zip
, o bien de la web del autor en code.google.com/p/arduino-new-ping.

Para instalar una librería externa no incluida en el IDE de Arduino tenemos que importarla con el menú Programa \ Importar
librería\Añadir librería:
En la ventana que sale, buscad el fichero NewPing_v1.5.zip que habéis descargado y seleccionadlo.
Ya está. Arduino ha importado la librería y los ejemplos que incluye. Si ahora volvéis a Programa\ImportarLibrería, veréis que al final de
la lista ya está disponible como NewPing, y además el zip incluye varios ejemplos de uso. Vamos a cargar el equivalente del programa
anterior. Haced :
Archivo \ Ejemplos \ NewPing \ NewPingExample
Arduino cargara un programa de ejemplo. Las instrucciones claves son primero inicializar la librería con:
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE) ;
Y después medir la distancia:
unsigned int uS = sonar.ping() ;
Aqui os copio el ejemplo para vuestra referencia:

#include <NewPing.h>
#define TRIGGER_PIN 12 // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN 11 // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 200
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance
void setup()
Serial.begin(115200); // Open serial monitor at 115200 baud to see ping results.
void loop()
delay(50);
unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS)
Serial.print("Ping: ");
Serial.print(uS / US_ROUNDTRIP_CM);
Serial.println("cm");
Como veis la librería se encarga de inicializar los pines necesarios, enviar los pulsos, escuchar el eco de retorno y de hacer los cálculos.
No está mal.
MOTORES DE CORRIENTE CONTINUA

OBJETIVOS
o Presentar los motores de corriente contínua.

o Comprender las bases de funcionamiento.
o Montar un circuito típico de uso y control de los motores CC.
o Montar un variador de velocidad del motor
MATERIAL REQUERIDO.
MATERIAL REQUERIDO.
Arduino UNO o equivalente.
Una resistencia de 330 Ohmios.
Un diodo LED
Un potenciometro de 10k
Un motor de corriente continua CC, yo voy a usar una rueda para mostrar el giro
LOS MOTORES DE CORRIENTE CONTINUA, O MOTOR CC
Es difícil moverse por nuestro mundo sin tropezarte con motores eléctricos de todos los tipos y tamaños. Desde los pequeños con los
que arrancas el coche cada mañana a los muy pequeños que mueven tu reproductor de CDs o DVS, al que hace girar el microondas con
el que te calientas el café al levantarte, estamos rodeados de motores eléctricos.
Podemos comprar desde grandes motores trifásicos, de corriente alterna, de gran potencia para labores industriales hasta pequeños
motores de corriente continua para mover las ruedas de un pequeño coche de control remoto.
En sesiones previas, ya presentamos una introducción a como gobernar servos o pequeños motores de CC, pero ha llegado el
momento de dedicarles un poco más de tiempo y detalle a ver lo que son y cómo usarlos en nuestro proyectos de Arduino.
Y como siempre es preferible empezar por el principio vamos a comenzar con los motores de corriente continua y viendo cómo podemos
controlarlos.
Estoy seguro, de que todos estaréis familiarizados con el hecho de que los imanes tienen un polo positivo y otro negativo y que
mientras que los polos opuestos se atraen, los iguales se repelen.
Hay una relación muy estrecha entre la corriente eléctrica y los campos magnéticos que definen las ecuaciones de Maxwell (Ya estamos
otra vez) y resulta que cuando hacemos circular una corriente por un conductor que está inmerso en un campo magnético, este se ve
sometido a una fuerza mecánica, que llamamos electromotriz y que podemos usar como principio básico de funcionamiento de
un motor eléctrico
Desde un punto de vista práctico, si hacemos circular una corriente por un hilo que está entre los polos de un imán, aparecerá una fuerza
mecánica que se opondrá a los cambios de esta corriente e intentara hacer girar el conductor para compensarlos.
La fuerza que aparezca será proporcional a la intensidad del campo magnético, y a el número de conductores que sean recorridos por
la corriente, (por eso lo que hacemos es arrollar espiras de cobre o devanados alrededor de un núcleo, para que la fuerza aumente).
Todos los motores eléctricos disponen de dos partes básicas:
 El estator o parte inmóvil que por regla general incluye o bien imanes potentes fijos o generan un campo variable mediante corriente
alterna (Lo que nos llevaría a construir un motor de corriente alterna claro)
 El rotor, en el que disponemos espiras o arrollamientos de hilos de cobre alrededor de un núcleo, para que la fuerza que se ejerce sobre
el rotor se multiplique proporcionalmente a este número
La idea final es que podemos diseñar motores de corriente continua sencillos para que esta fuerza sea máxima.
Claro que a medida que la fuerza electromotriz hace girar una fracción de vuelta el rotor, al final nos encontraríamos que, llegaríamos a
una posición de equilibrio, lo que no nos conviene en absoluto porque se pararía el giro del motor.
Por eso tenemos que complicar un poco más el asunto y asegurarnos de que disponemos de múltiples grupos de espiras en distintas
posiciones, de forma que cuando un grupo alcance el equilibrio el otro tome el relevo y el motor siga girando.
Fijaros en los bloques negros marcados como + y – (Que llamamos escobillas) que se mantienen estáticos mientras alimentamos con
corriente eléctrica una pareja de espiras con devanados opuestos. Cuando llegan al punto de equilibrio, desconectan ese juego de
espiras y las escobillas alimentan el siguiente juego de espiras durante una fracción de vuelta… y vuelta a empezar.
De ese modo siempre hay un juego de espiras conductoras fuera de la posición de equilibrio que se ve sometido a la
fuerza electromotriz y obliga al motor a girar buscando un equilibrio (Como en el caso de los imanes) al que nunca le permitimos llegar.
En esta imagen izquierda podéis apreciar los arrollamientos de hilo conductor, para un pequeño motor de corriente continua. En la
animación de la derecha, podéis apreciar el conjunto girando, y donde Shaft, es el eje de giro. Brushes son las escobillas. Rotor coils son
los devanados de hilo conductor y Magnets son imanes.
CONTROLANDO UN MOTOR DE CC CON ARDUINO
En la sesión transistores, vimos que era muy fácil hacer girar un pequeño motor mediante un transistor que regulase la intensidad de
corriente que le entregamos.
En aquella sesión nos centramos casi en exclusiva en el transistor, para presentar este componente, que vamos a utilizar una y otra
vez, y prácticamente usamos el motor como excusa sin entrar en el tema. Pero en esta ocasión queremos poner el foco en el motorcito y
como lo controlamos y por eso vamos a volver a este ejemplo, pero complicándolo un poco más (Que le vamos a hacer), añadiendo
un potenciómetro que nos permita variar la velocidad de giro el motor.
Para ello usaremos un motor de continua, de 5V, con rueda, que podéis encontrar por muy poco dinero y que nos viene de perlas para
apreciar el de giro.
Como cualquier motor, por pequeño que sea consume más de lo que uno de los pines de nuestros Duinos pueden proporcionar,
necesitamos usar un transistor como el 2N2222 para alimentarlo. Y usaremos uno de los pines de Arduino para gobernar este
transistor.
Vamos a repetir el montaje que vimos en la sesión transistores con este motorcito. Os incluyo copia del esquema eléctrico que usamos
allí y del diagrama de pines del transistor.
Aquí tenéis el esquema inicial sin potenciómetro para que comprobéis las conexiones del motor y que funciona correctamente, antes de
seguir.
Para comprobar que el motor funciona, podéis cargar este pequeño programa, que simplemente varia la tensión que ponemos en el pin 9
para modificar la velocidad de giro del motor:
const int control = 9 ;
void setup()
{ pinMode(control, OUTPUT) ; }
void loop()
for ( int n = 0 ; n < 255 ; n++)
analogWrite (control, n) ;
delay(15) ;
Que como veréis, simplemente pone un valor analógico en el pin 9. Podemos controlar la velocidad del motor variando la intensidad de
tensión que ponemos en la base del transistor, ya que esta regula la resistencia que el transistor presenta entre emisor y colector.
A 0V el transistor entra en corte (Resistencia infinita) y a 5V está en saturación, con lo que presenta resistencia nula.
 No supongáis que podemos hacer que el motor gire de forma continua para todos los valores de tensión en la base. Por debajo de un
cierto umbral se parará y solo girará cuando este se supere.
 Al hacer crecer el valor de tensión que le damos al motor, la velocidad de giro, irá aumentando progresivamente.
MOTORES PASO A PASO: 28BYJ-48

OBJETIVOS
o Insistir con los motores paso a paso.

o Montar un pequeño motor 28BYJ-48 con su adaptador.
o Escribir un primer programa de control muy sencillo.
MATERIAL REQUERIDO.
Arduino UNO
Una Protoboard
4 x Cables Dupont Macho Hembra
Un pequeño motor 28BYJ-48 y su breakboard
VOLVIENDO CON LOS MOTORES PASO A PASO
En la sesión anterior dimos un pequeño repaso a la teoría que hay detrás de los motores paso a paso e intentamos sentar las cuatro
ideas importantes que debéis conocer para elegir y usar con éxito, uno de esto motores.
En esta sesión, vamos a usar un pequeño motor paso a paso unipolar, muy común en el mundo Arduino por su pequeño tamaño y bajo
coste, el 28BYJ-48 y el adaptador que suele venir con él, basado en el chip ULN2003A.
Veremos en primer lugar las características que presenta y después montaremos un pequeño circuito básico, para mover el motor. Como
siempre intentaremos que el ejemplo sea lo más simple posible para que en esta primera ocasión veáis con claridad la forma de
manejarlos.
Y poco más que decir en esta pequeña introducción. Vamos pues, a meternos directamente en harina.
EL MOTOR PASO A PASO 28BYJ-48
Este pequeño motor es muy habitual en los proyectos con pequeños robots y posicionadores caseros sencillos, porque aunque no es
demasiado potente, ni rápido tiene varias características más que simpáticas, además de ser muy barato (Unos pocos euros).
Y como no podía ser de otra manera, empezaremos por buscar su manual (Va que sí, que vosotros podéis encontrarlo en Internet).
Es un motorcito unipolar con las siguientes características:
 Tensión nominal de entre 5V y 12 V.

 4 Fases.
 Resistencia 50 Ω.
 Par motor de 34 Newton / metro más o menos 0,34 Kg por cm.
 Consumo de unos 55 mA.
 8 pasos por vuelta.
 Reductora de 1 / 64.
Traduciendo esto a cristiano, quiere decir que como es de 4 pasos (Steps), u 8 medios pasos (O half Steps) por vuelta y usa una
reductora de 1 /64, por lo que necesitamos dar 8 * 64 = 512 impulsos para completar un giro completo a medios pasos.
 Sé que parece confuso. Hay 4 bobinas, si las excitamos de una en una tenemos 4 pasos x 64=256 pasos por vuelta.
Pero también podemos excitar la bobina mediante medios pasos, como veíamos en las tablas de la sesión previa (que es
el ejemplo que vamos a hacer) y por eso a medios pasos una vuelta son 8 * 64 = 512 impulsos
Además si no recuerdo mal de mis lejanos días de universidad, un par de 0,34 Kg por cm, significa que con una polea de un 1cm de
diámetro colocado en el eje, este pequeño motor levantaría un peso de 350 gramos contra la gravedad, lo que no está mal.
Este es su diagrama de conexión de bobinas, y además marca los colores del cable en función de su conexión interna. El motor presenta
un conector al extremo en el que podemos pinchar cables de protoboard si hay que moverlo directamente, o bien para conectarlo a su
adaptador.
Fijaros que su consumo es muy bajo, de unos 55 mA, dentro del rango que nuestro USB proporciona a Arduino (Siempre que no
intentemos alimentarlo con un pin) y lo alimentaremos mediante la breakboard típica que le acompaña, que suele usar un integrado del
tipo ULN2003A que es un array de transistores Darlington, que soporta hasta 500 mA y que ya dispone de un conector para el motor y
de unos pines (IN1 – IN4) para conectar a nuestro Arduino.
 Sin entrar en muchos detalles, un Darlington suele ser un par de transistores bipolares colocados juntos y que se manejan como uno
único.
 La ventaja de este esquema es que aumenta mucho la ganancia del transistor resultante y además permite la conducción de grandes
corrientes y tensiones.
 Hemos usado uno de estos transistores para alimentar una tira Ed LEDS aquí.
CONECTANDO EL MOTOR 28BYJ-48
Pues usando la breakboard no tiene mucho mérito. Conectad el motor primero a su conector, que tiene una posición para impedir que lo
coloques al revés y después vamos a colocar las 4 fases a nuestro Arduino de modo que podamos excitarlas de forma independiente.
Es importante que entendáis la idea de que vamos a ir excitando cada una de las fases (O varias simultáneamente) en secuencia
levantando a HIGH el pin de Arduino correspondiente.
No merece la pena montar un esquema de protoboard para esto. Para conectar vuestro Arduino usad la siguiente tabla:
ARDUINO 12 11 10 9
BREAKOUT IN1 IN2 IN3 IN4
Conectad GND y Vcc a los pines correspondientes del adaptador y eso es todo (Gran ventaja cuando usas módulos a medida) vamos
con el programa.
Mientras que los motores CC normales, están diseñados para que al alimentarlos giren de forma continua, un motor paso a paso está
diseñado para girar un pasito cada vez que alimentas una de las fases.
Por eso nuestro programa tendrá que gestionar la secuencia en la que excitamos las bobinas para que el motor vaya avanzando de
forma continua.
En un motor de 4 fases como este que vamos a usar hay tres maneras de hacer esta secuencia como veíamos en la sesión anterior.
Excitando dos bobinas cada vez (Suele ser lo que recomienda el fabricante)
PASO BOBINA A BOBINA B BOBINA C BOBINA D
1 ON ON OFF OFF
2 OFF ON ON OFF
3 OFF OFF ON ON
4 ON OFF OFF ON
Tendríamos máximo par, buena velocidad y alto consumo.
Excitando solo una bobina cada vez (Se le llama wave drive):
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON
Que produciría un par menor (Porque solo se activa una bobina en lugar de dos) y consumo bajo.
O podríamos dar medios pasos así:
1 ON OFF OFF OFF
2 ON ON OFF OFF
3 OFF ON OFF OFF
4 OFF ON ON OFF
5 OFF OFF ON OFF
6 OFF OFF ON ON
7 OFF OFF OFF ON
8 ON OFF OFF ON
El movimiento es más suave y lento que con los métodos anteriores, y el consumo y el par es también intermedio.
Y naturalmente lo habituales, ya os habréis sospechado que vamos a definir unos arrays con estas tablas para secuenciar el movimiento.
Por ejemplo en el caso de usar medios pasos el array sería algo así:
int Paso [ 8 ][ 4 ] =
{ {1, 0, 0, 0},
{1, 1, 0, 0},
{0, 1, 0, 0},
{0, 1, 1, 0},
{0, 0, 1, 0},
{0, 0, 1, 1},
{0, 0, 0, 1},
{1, 0, 0, 1}
};
Y seguro que no tendréis problema en definir el array correspondiente a los otros dos tipos de movimiento
Nuestro programa Prog_98_1 recorrerá el array y alimentara las bobinas de acuerdo a los valores que presenta. Empecemos con
algunas definiciones:
#define IN1 12
#define IN2 11
#define IN3 10
#define IN4 9
int steps_left=4095;
boolean Direction = true;
int Steps = 0; // Define el paso actual de la secuencia
Los defines indican a que pines de nuestro Arduino vamos a conectar cada una de los terminales de las bobinas del motor. Después
algunas variables para control y un array que representa la secuencia. El setup es bastante sencillo
void setup()
{ pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
Vamos a definir una función llamada stepper() que avanza un paso cada vez que la invocamos, en realidad medio paso dada la matriz
de excitación y que controle en que punto de la secuencia estamos.
Así, el programa principal quedaría: Prog_98_1
void loop()
{ while(steps_left>0)
{
stepper() ; // Avanza un paso
steps_left-- ; // Un paso menos
delay (1) ;
delay(300);
Direction =! Direction; // Invertimos la direceccion de giro
steps_left = 4095;
Usamos Steps_left para definir el número de pasos que queremos girar, y por eso mientras queden pasos pendientes seguimos en el
while, que lo que hace es avanzar un paso, disminuir el número de pasos pendientes y hacer un delay que controla la velocidad de giro.
Cuando acaba el while, hacemos un delay para poder apreciar el final e invertimos el valor de direction para cambiar la dirección de
giro.Vamos con la funcion Stepper que parece más complicada:
void stepper() //Avanza un paso
{ digitalWrite( IN1, Paso[Steps][ 0] );
digitalWrite( IN2, Paso[Steps][ 1] );

SetDirection();
Lo se, da asco. Es tan fácil que aburre. Usamos la variable Steps para saber en cuál de los 8 estados posibles de la matriz estamos y
escribimos en las bobinas los valores que corresponden a esa situación.
Es SetDirection() quien va a controlar la dirección de giro y el valor de Steps, vamos a ver como:
void SetDirection()
if(Direction)
Steps++;
else
Steps--;
Steps = ( Steps + 8 ) % 8 ;
Es muy fácil ver que si giramos en la dirección digamos positiva, hay que ir incrementando Steps para mantener el giro. Y tampoco es
complicado ver que en el giro contrario hay que irlo decrementando para que lea el array al revés. Pero quizás la última línea merece una
explicación aparte.
A medida que vamos incrementando Steps, queremos que cuando pase de 7 vuelva a 0 y esto se consigue muy fácil haciendo
Steps = Steps % 8
Es decir tomando el modulo con respecto a 8, pero si lo vamos decrementando, alcanzaremos valores negativos, y el módulo de algo
negativo sigue siendo negativo, lo que no nos vale, porque necesitamos que el siguiente valor a 0 sea 7 y no -1.
Esto es lo que conseguimos de una tacada haciendo
Steps = ( Steps + 8 ) % 8 ;
Compruébalo si no me crees.
 He visto en Internet que esto lo hacen con un programita así:

 if (Steps>7)
 Steps=0 ;
 if (Steps<0)
Steps=7 ;
 Pero mi sentido de la estética y la vagancia me impiden escribir tanto y además son completamente equivalentes (Y además es
un código mas compacto y quedón el primero)
TECLADOS MATRICIALES
Arduino y los keypads de 4x4
OBJETIVOS
o Familiarizarnos con un teclado matricial de 4×4.

o Usar otra librería externa: KeyPad.
o Volver a revisar los arrays, esta vez de dos dimensiones.
MATERIAL REQUERIDO.
Arduino Uno o similar.Esta sesión acepta cualquier otro modelo de Arduino.

Un teclado matricial 4×4
COMO FUNCIONA UN TECLADO MATRICIAL
Un teclado no es más que una colección de botones, a cada uno de los cuales le asignamos un símbolo o una función determinada. Pero
botones al fin y al cabo.
Leer botones es algo que ya no tiene secretos para nosotros, pero si conectáramos cada tecla a un pin digital de nuestro Arduino, pronto
estaríamos en apuros.
El teclado de nuestro ordenador suele ser de alrededor de 106 teclas, así que el método de fuerza bruta va a entrar en apuros
rápidamente. Necesitamos otra solución.
Y como el mundo está lleno de gente ingeniosa se les ocurrió una solución de lo más elegante, una matriz de teclas.
Vamos a ver un ejemplo con un pequeño teclado numérico de 16 teclas tipo los de los teléfonos móviles o los de los cajeros
automáticos.
Para que nuestro Arduino pueda saber que tecla se pulsa, basta con poner tensión en las filas de forma secuencial y luego leer las
columnas para ver cuál de ellas tiene HIGH.Los teclados matriciales usan una combinación de filas y columnas para conocer el estado
de los botones. Cada tecla es un pulsador conectado a una fila y a una columna. Cuando se pulsa una de las teclas, se cierra una
conexión única entre una fila y una columna.
Por ejemplo, ponemos HIGH en la primera fila (hilo 8 en el diagrama de la derecha) y después leemos sucesivamente los hilos
correspondientes a las columnas (hilos 4, 3, 2,1). Si ninguno está en HIGH es que no se ha pulsado ninguna tecla de la primera fila.
Pasamos a la segunda fila (hilo 7) y ponemos HIGH, si al leer los hilos 4, 3, 2,1 encontramos que el hilo 1 está en HIGH, es que se ha
pulsado la tecla correspondiente a la “B”.
De este modo, para leer un teclado matricial de 4×4 necesitamos 8 hilos en lugar de 16, aunque nos dará un poco más de guerra a la
hora de programar. Para un teclado de PC 106 teclas bastaría una matriz de 10×11 o sea 21 hilos en vez de 106.
DIAGRAMA DE CONEXIÓN
Lo más práctico es conectar el teclado a Arduino directamente, podemos usar cables de protoboard, o bien con un peine de pines para
que no se suelte nada.
Esta es otra de esas raras ocasiones en que un esquema electrónico tendría poco sentido, así que pasaremos rápidamente a ver el tema
del programa.
 Un apunte rápido: Por comodidad en el diagrama, y porque en los ejemplos que vienen con Arduino utilizan estos mismos números de
pines del 0 al 7, los hemos mantenido. Pero conviene saber que Arduino usa los pines 0 y 1 para comunicarse a través del USB, por lo
que no es buena usarlos para otra cosa cuando vayamos a usar el puerto serie.
EL PROGRAMA DE LECTURA
Como ya dijimos, el programa ha de consistir en ir dando tensión consecutivamente a los pines de las filas 8, 7, 6, 5 y después ir leyendo
los valores de las columnas para detectar que teclas se han pulsado.
No es un programa complicado, pero antes de que el pánico se apodere de los que siguen la sesión con creciente temor (y recuerden
que tienen algo urgente e ineludible que hacer) comentaremos que alguien ha tenido este problema antes que nosotros y amablemente
ha puesto a nuestra disposición una librería llamada KeyPad ideal para leer este tipo de matrices sin complicaciones,.
 Lo que no quita para que podáis escribir un programa que lea directamente la matriz y reconozcáis las pulsaciones. Animo, no es difícil y
el ejercicio siempre es bueno.
Lo primero es descargar la librería e instalarla. La tenéis aquí Descargar, o bien en la página de Arduino
http://playground.arduino.cc/Code/Keypad#Download
Id a la sección de “Download, install and import” donde encontrareis keypad.zip. Descargadlo y para instalarla recordad que basta con
hacer:
En la ventana que sale, buscad el fichero Keypad.zip que habéis descargado, seleccionadlo y listo.
Una vez instalada para usarla basta con que le indiquéis que deseáis usarla. SI hacéis Programa\Importar Librería \ Keypad veréis que
incluye la siguiente línea en vuestro programa:
#include <Keypad.h>
Vamos a ver como usamos esta librería. Lo primero es definir un par de contantes
const byte Filas = 4; //KeyPad de 4 filas
const byte Cols = 4; //y 4 columnas
Y ahora una par de arrays para indicarle a la librería que pines de Arduino corresponden a las filas y cuales a las columnas del keypad:
byte Pins_Filas[] = {7, 6, 5, 4}; //Pines Arduino para las filas.
byte Pins_Cols[] = { 3, 2, 1, 0}; // Pines Arduino para las columnas.
Recordad que un array es una colección de elementos que pasamos entre llaves y separados por comas. Es más cómodo que andar
definiendo 8 variables.
Recordad lo que vimos en la sesión 9, que cuando definimos una array por enumeración de sus elementos, como en este caso, no
necesitamos pasar entre corchetes el número de elementos (Los cuenta el mismo C++ solito).
Tendremos que definirle, además, que símbolos corresponden a cada posición de las teclas. Una nueva oportunidad para disfrutar de
los arrays, pero esta vez de 2 dimensiones en vez de una.
char Teclas [ Filas ][ Cols ] =
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
 Definimos el array de 4×4 pasándole las dimensiones entre corchetes. Sus miembros van a ser 4 filas, cada una de las cuales es un
array de 4 elementos, y después enumeramos los cuatro arrays de 4 miembros.
 Fijaros en que cada array va entre llaves. Los elementos de un array se separan por comas, pero al final de las llaves exteriores va un
punto y coma porque toda el conjunto es una asignación.
 Los arrays siempre parecen complicados hasta que te acostumbras pero no es para tanto y este es un buen ejemplo para que
comprendéis la idea de un array de 2 dimensiones.
Una de las curiosidades de leer una matriz de teclas y después asignar un carácter contenido en un array es que podemos redefinir el
valor de las teclas sin más que cambiar el contenido del array.
 Si por lo que sea hubiéramos conectado mal los pines del keypad al Arduino, podríamos redefinir los valores del array para que
coincidan con lo que pone en las teclas. Puede ser más fácil que mover de sitio los cables.
 De hecho es esa capacidad de mapear la representación de un carácter a una posición en una tabla, es lo que permite que podamos
reconfigurar el mismo teclado a diferentes lenguas, sin más que cambiar los valores del array (aunque también ayudará mucho luego
cambiar los símbolos rotulados en el teclado).
Por ultimo tendremos que crear una instancia de Keypad que llamaremos Teclado1
Keypad Teclado1 = Keypad(makeKeymap(Teclas), Pins_Filas, Pins_Cols, Fils, Cols);
Que leído así asusta, pero que en realidad es una tontería. Traduciendo sería: Crea una instancia del tipo Keypad que llamaras Teclado1
y al que asignarás las teclas que tenemos en el array Teclas, y le decimos que hemos conectado las filas del keypad a los números de
pines que te indico en el array Pins_Filas y las columnas al array Pins_Cols.
 MakeKeymap (Teclas) es una función disponible en la librería y que nos permite asignar un array de valores a una matriz. Se hace solo
una vez al principio salvo que por lo que sea nos interese cambiarlo sobre la marcha.
Por ultimo para leer el keypad hacemos una llamada a otra función de la librería:
char pulsacion = Teclado1.getKey() ;
Por ultimo enviamos a la consola el carácter pulsado.
#include <Keypad.h> // Prog_19_1
const byte Filas = 4; //Cuatro filas
const byte Cols = 4; //Cuatro columnas
byte Pins_Filas[] = {7, 6, 5, 4}; //Pines Arduino para las filas
byte Pins_Cols[] = { 3, 2, 1, 0}; // Pines Arduinopara las columnas
char Teclas [ Filas ][ Cols ] =
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
Keypad Teclado1 = Keypad(makeKeymap(Teclas), Pins_Filas, Pins_Cols, Filas, Cols);
void setup()
{ Serial.begin(9600) ; }
void loop()
{ char pulsacion = Teclado1.getKey() ;
if (pulsacion != 0) // Si el valor es 0 es que no se
Serial.println(pulsacion); // se ha pulsado ninguna tecla
Por cierto, en C++ y en otros lenguajes es muy frecuente escribir la instrucción:
if (pulsación != 0)
De esta otra manera (más elegante) completamente equivalente:

if (pulsación )
Porque la condición del if debe evaluarse a TRUE o FALSE y para los ordenadores un 0 es FALSE sin remisión, pero cualquier otro valor
que no sea 0 es TRUE, incluyendo un carácter.
RESUMEN DE LA SESIÓN
o Hemos usado nuestro primer keypad hexadecimal

 Son prácticos y muy sencillos de usar en cuanto le pilléis el tranquillo.
 Están disponibles en múltiples formatos y tipos, Aquí hemos usado uno típico de 4×4, pero también los hay 4×3 y en diferentes
materiales y acabados
 Un antiguo teléfono móvil roto se puede desmontar y usar su teclado además de otras cosas, y se puede utilizar de la forma que hemos
descrito.
o Hemos usado la excusa del teclado para volver sobre los arrays. Vale la pena de que les dediquéis un poco de tiempo pues os ayudaran
a resolver cómodamente más de un problemas de programación, y no se merecen la fama de malotes que tienen.
o Hemos conocido otra librería externa, KeyPad. Os vendrá muy bien en vuestros proyectos. Más adelante confío en que podamos hacer
algún ejemplo más sofisticado con un keypad como hacer que una cierta combinación abra una cerradura de servo por ejemplo.

LOS SERVOS
OBJETIVOS
o Que es un servo.
o Comprender la diferencia con un motor normal.
o Introducir el concepto de librería en C++.
o La función map().
MATERIAL REQUERIDO.
Arduino Uno o similar.
 Esta sesión acepta cualquier otro modelo de Arduino.
Una Potenciómetro.
Un Servo con sus horns,
Esas pequeñas piezas de plástico que se ponen en el eje

QUE ES UN SERVO
.
Normalmente los motores habituales lo que hacen es transformar la energía eléctrica (O química) en un giro continuo que podemos usar
para desarrollar trabajo mecánico.
En la sesión 13 utilizamos un pequeño motor de corriente continua y regulamos la velocidad de giro mediante una
señal PWM de Arduino.
Los servos son también motores de corriente continua, pero en lugar de diseñarse para obtener un giro continuo que podamos
aprovechar (para mover una rueda por ejemplo), se diseñan para que se muevan un angulo fijo en respuesta a una señal de control, y se
mantengan fijos en esa posición.
Imaginad por ejemplo un timón de un avión o barco. No queremos un giro continuo, sino un motor al que le pueda indicar el ángulo que
deseamos en grados y que mantenga esa orientación hasta que le demos una orden en contrario.
Estos servos o servomotores son muy frecuentes en Aero modelismo y en robótica, por la capacidad que presentan para moverse a un
ángulo concreto y mantenerse allí. De hecho se suelen diseñar para que giren un ángulo proporcional a una señal PWM, de forma que
su control es muy preciso. Un servo suele estar formado por:
Un servo suele estar formado por:
 Una reductora.Un circuito de control..

 Un motor de CC.
 Un circuito de control
En la práctica se comporta como un bloque funcional que posiciona su eje en un ángulo preciso en función de la señal de control
Habitualmente los servos tiene un margen de operación, es decir, pueden moverse entre 0º y ángulo dado, que suele ser de 180º, pero
existen modelos comerciales de todas la características imaginables (incluyendo servos de 360º).
Normalmente estos pequeños servos funcionan sobre 5V y el control se realiza mediante una señal de control PWM, en la que el ancho
el pulso indica el ángulo que deseamos adopte el eje.
Un servo tiene un conector de 3 hilos, 5V (rojo), GND (negro o marrón) y el otro Control (amarillo o blanco).
Podríamos escribir un pequeño programa en Arduino que controle estos pulsos y los relacione con el ángulo buscado, pero antes de que
nadie se asuste, los servos (y otras cosas) son tan habituales, que ya ha habido gente que han escrito estos programas y los han puesto
a nuestra disposición.
De este modo podemos manejar un servo sin preocuparnos para nada de cómo realizar el control de las señales, o de la operación
interna, basta con instalar estos programas en una forma especial llamada librería.
 Una librería es un conjunto de definiciones y funciones escritas en C++ de Arduino, que podemos utilizar en nuestros programas.
Podemos ver el código de estos programas, aunque normalmente se requiere un nivel medio alto en C++ para comprender su
funcionamiento.
La ventaja de trabajar con una plataforma tan bien establecida como Arduino, es que hay cantidad de gente en el mundo desarrollando
librerías, casi para cualquier cosa que podáis imaginar.
Y aún hay algo mejor: Son gratis.

Veréis que en las próximas sesiones vamos a utilizar librerías para cantidad de cosas, pero hoy vamos a comenzar con la primera, la
librería servo.
USANDO NUESTRA PRIMERA LIBRERÍA: SERVO

.
Servo es una librería estándar en Arduino. Eso quiere decir que viene incluida cuando instaláis el IDE, a diferencia de otras librerías que
debemos buscar, descargar de Internet e instalar para poder usarlas.
Para usar una librería estándar, basta con pedirle al IDE que la incluya en nuestro programa. Id al menú Programa \ Importar Librería y
os saldrá un desplegable con todas las librerías que tenéis instaladas en el IDE.
Por ahora solo nos interesa la librería Servo. Pinchad en ella. Arduino incluirá una línea al principio de vuestro programa como esta:
#include <Servo.h>
A partir de ahora ya podemos utilizar las funciones disponibles en la librería.
 Normalmente para usar una librería hay que leer la documentación, en la que se detalla la forma de usarla, que funciones tenemos
disponibles, que parámetros pasarlas…etc.
 Como es vuestra primera librería, y nosotros ya nos hemos leído el manual, vamos a llevaros de la mano. Veréis que es de lo más fácil.
Vamos a montar un circuito en el que hagamos moverse al servo de forma controlada, e iremos viendo las instrucciones necesarias.
ESQUEMA ELECTRÓNICO DEL CIRCUITO

.
Vamos a conectar el servo primero a GND y 5V y luego el pin de control, a un pin de Arduino que permita PWM (Recordad esto o de lo
contrario os costara ver el problema). Recordad que es el ancho el pulso lo que controla el ángulo.
Vamos también a conectar un potenciómetro a la puerta A0 para jugar con el servo.
El diagrama de conexión para la protoboard es igual de sencillo:

Vamos a empezar con una línea que ya conocíamos el include y otra nueva:
#include <Servo.h>
Servo servo1;
Para poder utilizar la librería debemos crear, lo que se conoce como un objeto tipo Servo que llamamos servo1.
C++ es un lenguaje orientado a objetos, esto significa que podemos definir objetos tipo (como servos) sin más que declarar un nuevo
objeto del tipo que deseamos. En la jerga de la programación se llama crear una instancia, o instanciar un nuevo objeto.
Así, esa segunda línea significa que vamos a crear una nueva instancia de tipo Servo que llamamos servo1.
 Aunque ahora os pueda parecer una forma extraña de hacer las cosas, la programación orientada a objetos (OOP por sus siglas en
inglés), es una de las metodologías más potentes de las ciencias de computación actuales y todos los lenguajes de programación que se
precien, han incorporado las ideas de la OOP.
 Entrar en la teoría del OOP, desborda con mucho las pretensiones de este humilde tutorial de Arduino, por ahora nos limitaremos a
mostraros como usar los objetos.
Una vez creada la instancia del objeto (y podemos crear tantas como necesitemos, para manejar varios servos a la vez) tenemos que
incluir una línea en la función setup() para informar a C++ que vamos a conectar ese objeto abstracto que todavía es servo1 a un pin
físico del Arduino para controlarlo. En nuestro caso el pin 9:
servo1.attach(9);
Una vez cumplido el trámite para gobernar la posición del servo recurrimos a
servo1.write( angulo);
Donde Angulo es el valor en grados de la posición que deseamos. Fácil ¿No?
Vamos a escribir un programa que vaya barriendo un Angulo en grados y moviendo el servo a esa posición.
#include <Servo.h> // Incluir la librería Servo
Servo servo1; // Crear un objeto tipo Servo llamado servo1
int angulo = 0 ;
void setup()
servo1.attach(9) ; // Conectar servo1 al pin 9
void loop()
for(angulo = 0; angulo <= 180; angulo += 1) //incrementa angulo 1 grado
servo1.write(angulo);
delay(25);
for(angulo = 180; angulo >=0; angulo -=1 ) //decrementa angulo 1 grado
servo1.write( angulo );
delay(25);
Veréis como el servo se va moviendo primero hacia adelante y luego retrocede para volver a empezar.
Vamos ahora a hacer que el valor del potenciómetro represente la posición del servo de manera que el servo se mueva siguiendo al
potenciómetro. Para ello hay que entender que el valor que leamos en la puerta A0 está comprendido entre 0 y 1024, y que estos valores
tienen que distribuirse entre 0 y 180º. Así que para calcular el Angulo correspondiente basta con hacer:
Como la experiencia me ha demostrado, que los errores haciendo este tipo proporciones
tienden a infinito, voy a aprovechar para presentaros la función map(), que hace exactamente eso de un modo cómodo, librándonos de
los float ( aunque para aprender no os vendría mal hacer así el programa y luego usar el map()).
angulo = map( analogRead(A0), 0, 1024, 0, 180);
Traducido quiere decir: Haz la proporción de los valores que leas en A0, entre 0 y 1024, en un valor comprendido entre 0 y 180 y
asignale ese valor al ángulo. //Prog_16_2
#include <Servo.h> // Incluir la librería Servo
Servo servo1; // Crear un objeto tipo Servo llamado servo1
int angulo = 0 ;
void setup()
{
servo1.attach(9) ; // Conectar servo1 al pin 9
void loop()
angulo = map( analogRead(A0), 0, 1024, 0, 180);
servo1.write(angulo);
delay(250);
DETECTOR DE LLAMA
OBJETIVOS
o Presentar los sensores de llama.

o Montar un circuito de ejemplo.
o Ver sus características.
MATERIAL REQUERIDO.
Arduino UNO o similar.
Algunos cables de protoboard macho hembra.
Un buzzer piezoeléctrico
Un sensor de llama
SENSORES DE LLAMA
No resulta extraño que los sensores de llamas se encuentren entre los más vendidos. La industria los suministra de todos los tipos,
tamaños y precios, porque la idea de que se te queme la casa o la empresa es algo que ayuda mucho a sacar la cartera y buscar un
detector que sea capaz de avisarte con tiempo de que hay llamas cerca de tus cosas.
En realidad, es muy probable que tengas varios de estos detectores en tu casa. Imagínate, por ejemplo, los calentadores de gas, los
hornos domésticos de gas, o un sencillo calentador de agua y calefacción.
Todos ellos requieren una llama quemando gas. Si por cualquier motivo, la llama se extingue y no lo detectases, el gas seguiría fluyendo
y causando un embalsamiento, listo para causar un disgusto explosivo.
Por eso, todos estos electrodomésticos, y sus equivalentes industriales, incorporan por ley, un detector de llama, que pueda cortar el gas
en cuanto detecte falta de llama.
Lo sensores más sencillos (y baratos), suelen ser del tipo de detectores de ultravioletas, o sensores de infrarrojos.
 El mercado ofrece, también, un amplio espectro de sensores del tipo de detectores de humo y de gases nocivos como monóxido de
Carbono (CO) típico de la combustión,Dioxido de Carbono (CO2), detectores de humo, o de gases peligrosos libres, como hidrocarburos
(Propano, Butano y demás).
 Si tenemos ocasión en el futuro hablaremos de ellos.
En un entorno normal, la ignición de una llama provoca una ionización potente de gases comunes (En realidad un plasma ionizado,
similar al que ilumina una lámpara halógena), que generan un patrón típico de frecuencia en el rango del ultravioleta. El detector es un
semiconductor sensible a este rango de frecuencias.
Cuando la llama se estabiliza, es relativamente sencillo detectar su espectro infrarrojo, con una fotorresistencia LDR, pero diseñada para
ser específicamente sensible a un rango característico.
Nosotros vamos a usar un sensor muy sencillo y fácil de manejar que es un sensor infrarrojo de llamas. Funcionan detectando una
longitud de onda especifica (de unos 760 nm) que son características de las llamas, aunque son relativamente fáciles de engañar y
pueden dar falsos positivos con ciertas luces.
Como todo en la vida, es cuestión de precio, y el nuestro es barato, así que nos tendremos que apañar, pero a pesar de todo, confio, en
que el resultado de la sesión, sea satisfactorio.
Este sensor se encuentra muy frecuentemente encapsulado con un soporte y un potenciómetro para ajustar la sensibilidad, por poco
dinero. Incluso se vende en formato múltiple, con varias cabezas apuntando en distintas direcciones
En principio siempre es recomendable usar uno montado (Porque dan menos trabajo y a la hora de la verdad no se suelta un cable),
pero como me sobraba un detector independiente, por la mesa voy a montarlo en circuito de protoboard para ver qué pasa.
ESQUEMA DE CONEXIÓN
Lo normal para leer este sensor de llamas, seria usar un divisor de tensión como este:
Donde R1 debería tomar valores sobre 500k y como no tenía nada parecido, he usado 4 resistencias de 100k en serie, para tener
lecturas claras en la puerta A0 de Arduino. EL esquema eléctrico es algo así:
Y aquí tenemos el esquema de la protoboard:

PROGRAMA DE CONTROL
El programa es de lo más simple. Solo tenemos que leer la caída de tensión en el divisor y mandar una señal acústica con el buzzer en
cuanto el valor de la lectura en A0 sobrepase un cierto umbral.
Vamos a recuperar, además, la función Beep () que escribimos en la sesion Buzzers o zumbadores, para dar el tono de alarma cuando
se detecte una llama
void setup()
pinMode(9, OUTPUT);
void loop()
int v = analogRead(A0) ;
if ( v > 10)
beep(200) ;
void beep(unsigned char pausa)
analogWrite(9, 20);
delay(pausa); // Espera
analogWrite(9, 0); // Apaga
delay(pausa); // Espera
Lo que hace el programa es leer el pin A0 y si su valor sobrepasa un mínimo (para evitar los falsos positivos) llama a la función beep()
para dar la alarma.
 Nota: Normalmente hay que calibrar la sensibilidad del sensor. Para ello hay que ver que valores te devuelve en tu caso concreto y afinar
este valor umbral, para que no esté pitando continuamente.
 Los sensores en placa, suelen venir con un potenciómetro, que hay que ajustar para calibrar la sensibilidad el detector.
 Tambien convendría modificar el programa, para que el tono de la señal se hiciese mas agudo cuanto mas alto sea el valor de lectura en
A0
Como usar el monitor serie y el serial plotter
Monitor serie
El monitor serie es una de las herramientas de desarrollo mas interesantes que nos aporta el entorno arduino, mediante este
monitor podemos ver los valores de nuestras variables, así como mensajes de texto que nos permitirán conocer como esta
funcionando nuestro programa, o simplemente interactuar con el.
El monitor serie consiste en una consola de entrada y salida, esto quiere decir que podremos mostrar datos enviados por nuestra
placa arduino y también podremos enviar datos a nuestra placa. Podremos acceder a el a través del menú Herramientas/Monitor
serie o haciendo click en el icono que parece una lupa ubicado a la derecha en el IDE.
La comunicación serie se lleva a cabo por los pines TX / RX y usa niveles lógicos TTL (5V o 3.3V dependiendo de la placa). Esta
se utiliza para la comunicación entre la placa Arduino y una computadora u otros dispositivos. Todas las placas Arduino tienen al
menos un puerto serie (también conocido como UART o USART). Por lo tanto, si utilizamos esta función, no se pueden utilizar los
pines 0 y 1 para la entrada o salida digital.
Funciones básicas del Monitor serie

A continuación se muestran algunas de las funciones básicas que nos permiten comunicarnos usando el monitor serie
begin()
Establece la velocidad de datos en bits por segundo (baudios) para la transmisión de datos en serie. Para comunicarse con el
ordenador, utilice una de estas velocidades: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. Sin
embargo, se pueden especificar otras velocidades. Por tanto, su ejecución es imprescindible antes de realizar cualquier transmisión
por dicho canal. Se debe indicar la velocidad del canal como argumento.
Sintaxis
Serial.begin(velocidad)
Serial.begin(velocidad, configuracion)
Parametro
velocidad: es la velocidad de comunicación del puerto serie en bits por segundo (baudios)
Configuracion: selecciona el numero de datos, paridad y bits de parada. Los valores validos
son: SERIAL_5N1, SERIAL_6N1, SERIAL_7N1, SERIAL_8N1 (por defecto), SERIAL_5N2, SERIAL_6N2, SERIAL_7N2,
SERIAL_8N2, SERIAL_5E1, SERIAL_6E1, SERIAL_7E1, SERIAL_8E1, SERIAL_5E2, SERIAL_6E2, SERIAL_7E2, SERIAL_8E2,
SERIAL_5O1, SERIAL_6O1, SERIAL_7O1, SERIAL_8O1, SERIAL_5O2, SERIAL_6O2, SERIAL_7O2 y SERIAL_8O2.
end()
No tiene ningún argumento ni devuelve nada, y se encarga de cerrar el canal serie. Permitiendo que los pines RX y TX sean
usados para entradas y salidas generales.
Sintaxis
Serial.end()
print()
Envía a través del canal serie un dato (especificado como parámetro) desde la placa arduino hacia el exterior. Ese dato puede ser
de cualquier tipo: carácter, cadena, número entero, número decimal (por defecto de dos decimales), etc. Si el dato se especifica
explícitamente (en vez de a través de una variable), hay que recordar que los caracteres se han de escribir entre comillas simples y
las cadenas entre comillas dobles.
Sintaxis
Serial.print(valor, formato)
Parametros
valor: el valor a imprimir (cualquier tipo de dato)
formato: Especifica la base numérica (BIN (binario o base 2), OCT (octal o base 8), DEC (decimal o base 10), HEX (hexadecimal o
base 16)) o el número de decimales (para los datos float).
println()
Hace exactamente lo mismo que Serial.print(), pero además, añade automáticamente al final de los datos enviados dos caracteres
extra: el de retorno de carro (código ASCII nº 13)(\r) y el de nueva línea (código ASCII nº 10) (\n). La consecuencia es que al final
de la ejecución de Serial.println() se efectúa un salto de línea.
Sintaxis
Serial.println(valor, formato)
Parametros
valor: el valor a imprimir (cualquier tipo de dato)
formato: Especifica la base numérica (BIN (binario o base 2), OCT (octal o base 8), DEC (decimal o base 10), HEX (hexadecimal o
base 16)) o el número de decimales (para los datos float).
Ejemplo 1 – Hola monitor serie

void setup() {
Serial.begin(9600); //Inicia la comunicacion serie a 9600 baudios
Serial.println("Hola monitor serie"); //imprime una secuencia de texto
Serial.println("Asi se imprime texto"); //imprime una secuencia de texto
}
void loop() {}
Ejemplo 2 – Imprimir numero en diferentes formatos

int analogValue = 0; // variable para guardar el valor analogico
void setup() {
Serial.begin(9600); //Inicia la comunicacion serie a 9600 baudios
}
void loop() {
analogValue = analogRead(0); //lee el valor analogico en el pin A0
// Imprime el valor en varios formatos
Serial.println(analogValue); // Imprime el valor en decimal
Serial.println(analogValue, DEC); // Imprime el valor en decimal
Serial.println(analogValue, HEX); // Imprime el valor en hexadecimal
Serial.println(analogValue, OCT); // Imprime el valor en octal
Serial.println(analogValue, BIN); // Imprime el valor en binario
delay(100); //espera 100 millisegundos para la siguiente lectura
}
available()
Devuelve el número de bytes –caracteres– disponibles para ser leídos y que provienen del exterior a través del canal serie. Estos
bytes ya han llegado al microcontrolador y permanecen almacenados temporalmente en una pequeña memoria de 64 bytes que
tiene la placa arduino –llamada “buffer”– hasta que sean procesados mediante la instrucción Serial.read().
Esta función devuelve el numero de bytes para leer. Si no hay bytes para leer, esta instrucción devolverá un 0. No tiene
parámetros.
Sintaxis
Serial.available()
read()
Devuelve el primer byte aún no leído de los que estén almacenados en el buffer de entrada del chip TTL-UART. Al hacerlo, lo
elimina de ese buffer. Para leer el siguiente byte, se ha de volver a ejecutar Serial.read(). Y hacer así hasta que se hayan leído
todos. Cuando no haya más bytes disponibles, Serial.read() devolverá -1. Esta funcion no tiene parámetros.
Sintaxis
Serial.read()
Ejemplo 3 – Leer el puerto serie con la función read()

int byteEntrante = 0; // guarda los datos de entrada serial
void setup() {
Serial.begin(9600);// inicia la comunicación serie a 9600 baudios
}
void loop() {
// lee e imprime en el monitor serie cuando se reciben datos
if (Serial.available() > 0) {
byteEntrante = Serial.read(); // lee el byte entrante
Serial.print("He recibido: "); // imprime el byte entrante
Serial.println(byteEntrante, DEC);
}
}
Debemos notar que esta función nos devuelve el equivalente ASCII de los caracteres leidos. Para ver la tabla ASCII click aqui.
parseFloat()
Lee del buffer de entrada (eliminándolos de allí) todos los datos hasta que se encuentre con un número decimal. Su valor de
retorno – de tipo “float”– será entonces ese número decimal encontrado. Cuando detecte el primer carácter posterior no válido,
dejará de leer (y por tanto, no seguirá eliminando datos del buffer). Esta instrucción no tiene parámetros.
Sintaxis
Serial.parseFloat()
parseInt()
Lee del buffer de entrada (eliminándolos de allí) todos los datos hasta que se encuentre con un número entero. Su valor de retorno
–de tipo “long”– será entonces ese número entero encontrado. Cuando detecte el primer carácter posterior no válido, dejará de leer
(y por tanto, no seguirá eliminando datos del buffer). Esta instrucción no tiene parámetros.
Sintaxis
Serial.parseInt()
Ejemplo 4 – Leer un valor decimal

float numero; //Recibe la lectura del puerto serie
void setup(){
Serial.begin(9600); //inicia la comunicación serie a 9600 baudios
}
void loop(){
// lee e imprime en el monitor serie cuando se reciben datos
if(Serial.available()>0){
numero=Serial.parseFloat(); //lee un numero decimal
Serial.println(numero); //imprime el numero leido
}
}
write()
Envía a través del canal serie un dato (especificado como parámetro) desde el microcontrolador hacia el exterior. Pero a diferencia
de Serial.print(), el dato a enviar solo puede ocupar un byte. Por lo tanto, ha de ser básicamente de tipo “char” o “byte”. En realidad,
también es capaz de transmitir cadenas de caracteres porque las trata como una mera secuencia de bytes independientes uno tras
otro. Su valor de retorno es, al igual que en Serial.print(), un dato de tipo “byte” que vale el número de bytes enviados.
Sintaxis
Serial.write(valor)
Serial.write(cadena)
Serial.write(matriz, longitud)
Parametros
valor: valor a enviar como byte
cadena: cadena a enviar como una serie de bytes

matriz: matriz a enviar como una serie de bytes
longitud: longitud de la matriz
Ejemplo 5 – Uso de la función write()

void setup() {
Serial.begin(9600); //inicia la comunicación serie a 9600 baudios
Serial.write(45); //envia 45 al monitor serie, equivalente ASCII de "-"
int bytesEnviados = Serial.write("Hola"); //envia caracteres y devuelve el numero de caracteres enviados
Serial.println(); //hace un salto de linea
Serial.print("Se enviaron: "); //imprime texto
Serial.print(bytesEnviados); //imprime el numero de bytes enviados
Serial.print(" bytes"); //imprime texto
}
void loop() {}
Como podemos ver cuando usamos la función Serial.write el monitor serie nos imprime el equivalente ASCII del numero que
recibe.
Existen muchas mas funciones relacionadas con la comunicación serie, apenas hemos visto algunas de las mas importantes, para
mas información sobre esas funciones visitar el sitio web de arduino.cc.
Serial plotter
El serial plotter es una herramienta disponible en el IDE de arduino que nos permite visualizar de forma gráfica el valor de una
variable. Para hacerlo es tan fácil como enviar el valor a imprimir con la función Serial.println(), y luego ir al menú herramientas y
seleccionar serial plotter. A continuación un ejemplo.
Ejemplo 6 – Uso del plotter serial

void setup() {
Serial.begin(9600); //inicio la comunicacion serie
}
void loop() {
int analog1=analogRead(A1); //leo un valor analogico

Serial.println(analog1); //lo envio serialmente
delay(100); //espero 100 milisegundos para la siguiente lectura
}
Y se vera de la siguiente forma en el plotter serial
Ejercicios
Ejercicio 1 – Imprimir los numero del 1 al 10 en binario
Imprimir en el monitor serie los números del 1 al 10 en binario.
Ejercicio 2 – Leer dos números decimales

Leer por el monitor serie dos números decimales y asignar cada uno a una variable, luego imprimir en el monitor serie los valores
leídos. Los numeros seran ingresados al monitor serie los dos a la vez separados por un espacio.
Ejercicio 3 – Leer dos números

Leer por el monitor serie dos números, uno decimal y otro entero y asignar cada uno a una variable, luego imprimir en el monitor
serie los valores leídos. Los números serán ingresados al monitor serie los dos a la vez separados por un espacio, primero el
decimal y luego el entero.
Ejercicio 4 – Imprimir caracteres ASCII

Imprimir en el monitor serie la lista de caracteres ASCII y su equivalente en decimal de los valores que van desde el 33 al 126.

Curso Basico de Arduino

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Curso Basico de Arduino

Uploaded by

Copyright:

Available Formats

Pag 1 – Curso Basico de Arduino

Curso básico de Arduino

1. En el menú ―Herramientas/Placa‖ seleccionamos la placa Arduino que tengamos conectada al

Estructura básica de un Sketch

Mi primer programa con Arduino

Ejemplo 1 : encender y apagar el LED

long nombreVariable; //Crea una variable de tipo long

x=y+25; //Se asigna el valor de la variable y + 25 a la variable x

valorPrevio=valorActual; //El valor de la variable valorActual es copiado a la variable valorPrevio

¿Qué es el ámbito de una variable?

Nombre Tamaño Rango Ejemplo

Conversión de variables (Cast)

int variable1=10; //Declara una variable de tipo int

int variable2=4; //Declara una variable de tipo int

Serial.begin(9600); //Inicializa la comunicación serial a 9600 baudios

resultado= variable1/ variable2; //El resultado de la división se asigna a resultado

Serial.print("El resultado es "); //Imprime en el monitor serie un texto

Serial.println(resultado); //Imprime en el monitor serial el valor de la variable resultado

El resultado que tenemos no es el esperado, y es porque dado que sólo intervienen

int variable1=10; //Declara una variable de tipo int

int variable2=4; //Declara una variable de tipo int

Serial.begin(9600); //Inicializa la comunicación serial a 9600 baudios

resultado= float(variable1)/variable2; //usamos la función de conversión en una de las variables

Serial.print("El resultado es "); //Imprime en el monitor serie un texto

Serial.println(resultado); //Imprime en el monitor serial el valor de la variable resultado

int variable1=10; //Declara una variable de tipo int

int variable2=4; //Declara una variable de tipo int

Serial.begin(9600); //Inicializa la comunicación serial a 9600 baudios

resultado= float(variable1)/variable2; //usamos la función de conversión en una de las variables

Serial.print("El resultado es "); //Imprime en el monitor serie un texto

Serial.println(resultado); //Imprime en el monitor serial el valor de la variable resultado

const int valor1=125;

Símbolo Ejemplo y descripción

— x– ; // decrementa x en uno y retorna el valor anterior de x

Orden de las operaciones

Símbolo Descripción Ejemplos

*/% Multiplicación, división, modulo x * 1.5

Símbolo Descripción Ejemplos

== != Igual o diferente if (x == HIGH)

|| OR lógico if (x == HIGH || x > y)

= += -= *= /= Asignación y asignación compuesta x=y

Ejercicio 2: Suma de números

Ejercicio 3: Incremento de números

Ejercicio 4: Multiplicación de dos números

Ejercicio 5: División y modulo

Aun no te has suscrito a nuestro boletín? Suscríbete y te mantendré informado de la ultimas

Bloques “if” y “if/else”

//Instrucciones que se ejecutan si la condición es cierta –true–

Y la sintaxis para el bloque if/else será la siguiente:

//Instrucciones que se ejecutan si la condición es cierta –true–

//Instrucciones que se ejecutan si la condición es falsa –false–

//Instrucciones que se ejecutan si la condición es cierta

//Instrucciónes que se ejecutan si todas las condiciones anteriores eran falsas

float temperatura=100; //Declaro una variable con un valor de 100

boolean alarma=0; //Declaro una variable con un valor de 0

int velocidadBomba=50; //Declara una variable

Serial.begin(9600); //Inicio la comunicación serial

if (Serial.available()>0){ //Consulta si hay datos en buffer de entrada serie

temperatura=Serial.parseFloat(); //Lee un numero decimal en el buffer serial y lo guarda en temperatura

Serial.print("La temperatura es "); //Imprime el texto en el monitor serie

Serial.println(temperatura); //Imprime el valor de la variable

if(temperatura<80) Serial.println("Temperatura normal"); //Si la temperatura es normal imprime un mensaje

if(temperatura>80&&temperatura<100) { //Si la temperatura sube mas de 80 imprime otro mensaje

/% Multiplicación, división, modulo x 1.5