Nombre de la propuesta: Aprendemos a programar y utilizar la placa Arduino

Introducción
En los últimos años se han producido grandes cambios culturales, atravesados por las
tecnologías de la información y la comunicación, que transformaron sustancialmente las
formas en las cuales el conocimiento se produce, circula y se distribuye. A partir de los
desarrollos tecnológicos, aparecen nuevas formas o fenómenos u objetos culturales que se
constituyen en tendencias y a través de los cuales se interpreta, comprende y apropia el
mundo. En este sentido, proponemos trabajar con Arduino, una placa electrónica que se
puede programar.

Sobre la propuesta
A partir de un abordaje interdisciplinar esta propuesta busca aprender a programar y utilizar
la placa Arduino para el desarrollo de proyectos de robótica y control, mediante el uso de
distintos sensores y actuadores.
En ésta primera etapa se hará uso solamente de las entradas y salidas digitales.
 ENCUENTRO 1
Actividades

Momento 1: ¿Qué es Arduino?

Se entregará a cada alumno una placa Arduino UNO, para que la observe y reconozca los
componentes que la forman a medida que se desarrolla su descripción.

Arduino es una placa electrónica, que posee un microcontrolador, el cual se puede

programar. El microcontrolador es una microcomputadora en un chip.
Dispone de un procesador, un kilobyte de RAM (memoria de acceso aleatorio) para
contener datos, unos cuantos kilobytes de memoria EPROM (ROM programable borrable)
o de memoria Flash para contener nuestros programas, y tiene pines de entrada y salida.
Estos pines de entrada/salida son los que conectan el microcontrolador con el resto de
nuestra electrónica. Esto nos permite conectar innumerables tipos de sensores de luz,
temperatura, sonido, etc. Las salidas pueden encender o apagar LED directamente, o se
pueden usar para controlar dispositivos más potentes, como motores. También pueden
proporcionar tensión de salida analógica.
El resto de la placa se ocupa de facilitar la alimentación eléctrica y permitir que se
comunique con el ordenador al que está conectado.
Momento 2: Otros elementos en la placa Arduino UNO
Directamente debajo del conector USB se encuentra el regulador de tensión de 5 V.
Regula a 5 V estabilizados cualquier tensión (entre 7 y 12 voltios) que se suministre desde
el conector de alimentación.
Directamente debajo del conector USB se encuentra el regulador de tensión de 5 V.
Regula a 5 V estabilizados cualquier tensión (entre 7 y 12 voltios) que se suministre desde
el conector de alimentación.
Veamos los conectores de la parte inferior de la placa Arduino. Como se puede ver, cada
pin o patilla está identificada con su nombre impreso junto a cada uno de los pines. El
primero es IOREF y a su lado RESET, que cumple la misma función que el botón RESET de
Arduino. Es decir, permite reiniciar el microcontrolador momentáneamente estableciendo
este pin alto (conectándolo a +5V), haciendo que comience su programa desde el
principio.
El resto de los pines de esta sección proporcionan distintas tensiones (3.3 V, 5 V, GND, y 9
V), tal como aparece indicado. GND, o tierra, significa cero voltios. Es la tensión de
referencia con la que se comparan de forma relativa el resto de tensiones de la placa y los
elementos conectados a ella.
La siguiente sección de conexiones analógicas, ANALOG IN , está marcada con los números
0 a 5. Estos seis pines se pueden utilizar para medir la tensión o voltaje que se les ha
conectado, de forma que el valor se pueda utilizar en los sketches (programas). Observe
que miden una tensión y no una corriente. Si bien aparecen etiquetadas como entradas
analógicas, estas conexiones pueden utilizarse también como entradas o salidas
digitales, aunque, por defecto, son entradas analógicas.
Cambiamos ahora al conector superior y comenzamos por el lado derecho. Tenemos pines
denominados Digital 0 a 13. Estos se pueden utilizar como entradas o salidas. Cuando se
utilizan como salida, se pueden activar o desactivar desde nuestro sketch. Por tanto, si los
activamos desde nuestro sketch tendrán 5 V y si los desactivamos, tendrán 0 V. Al igual
que con los pines de alimentación, debemos tener cuidado de no exceder su máxima
capacidad de corriente. Estas conexiones pueden suministrar 40 mA a 5 V. Eso es más que
suficiente para encender un LED estándar, pero no para manejar directamente un motor
eléctrico.
También podemos configurar una de estas conexiones digitales para que sea una entrada,
en cuyo caso, su funcionamiento será parecido a una entrada analógica, salvo que nos
indicará si la tensión en el pin está o no por encima de un cierto umbral
(aproximadamente 2,5 V).
Algunas de las conexiones digitales (3, 5, 6, 9, 10 y 11) están rotuladas PWM. Estas se
pueden utilizar para proporcionar una tensión de salida variable, en lugar de simplemente
5 V o 0 V. En el lado izquierdo del conector superior, hay otra conexión GND y una
conexión denominada AREF. AREF se puede utilizar para escalar las lecturas de las
entradas analógicas.
Momento 3: Conociendo el entorno de programación de Arduino
Para poder realizar los programas (sketches), se necesita de un entorno de programación
(IDE) con el cual podremos realizar nuestro programa y transferirlo a la placa Arduino.
Este IDE se puede descargar de internet.
Este entorno nos permite corregir errores en el programa y depurarlo adecuadamente.
Se mostrará el entorno de programación y se indicará como se procede a utilizarlo.
 ENCUENTRO 2
Actividades
Momento 1: Se abre el entorno de programación y se analiza la estructura de un sketch
Estructura de un programa (sketch)
La estructura básica del lenguaje de programación de Arduino es bastante simple y se
compone de al menos dos partes.
Estas dos partes necesarias, o funciones, encierran bloques que contienen declaraciones,
estamentos o instrucciones.
void setup()
{
estamentos;
}
void loop()
{
estamentos;
}
En donde setup() es la parte encargada de recoger la configuración y loop() es la que
contiene el programa que se ejecuta cíclicamente (de ahí el término loop –bucle-). Ambas
funciones son necesarias para que el programa trabaje. La función de configuración debe
contener la declaración de las variables. Es la primera función a ejecutar en el programa,
se ejecuta sólo una vez. La función bucle (loop) siguiente contiene el código que se
ejecutará continuamente (lectura de entradas, activación de salidas, etc) Esta función es el
núcleo de todos los programas de Arduino y la que realiza la mayor parte del trabajo. La
función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para
inicializar los modos de
trabajo de los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya
declaración que ejecutar.
{} llaves: Las llaves sirven para definir el principio y el final de un bloque de instrucciones.
Se utilizan para los bloques de programación setup(), loop(), if.., etc.
Una llave de apertura “{“siempre debe ir seguida de una llave de cierre “}”, si no es así el
programa dará errores. El entorno de programación de Arduino incluye una herramienta
de gran utilidad para comprobar el total de llaves. Sólo tienes que hacer click en el punto
de inserción de una llave abierta e inmediatamente se marca el correspondiente cierre de
ese bloque (llave cerrada).
Punto y coma: El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de
programación de Arduino. También se utiliza para separar elementos en una instrucción
de tipo “bucle for”. Olvidarse de poner fin a una línea con un punto y coma se traducirá en
un error de compilación. El texto de error puede ser obvio, y se referirá a la falta de una
coma, o puede que no. Si se produce un error raro y de difícil detección lo primero que
debemos hacer es comprobar que los puntos y comas están colocados al final de las
instrucciones.
/* ... */ bloque de comentarios: Los bloques de comentarios, o multi-línea de
comentarios, son áreas de texto ignoradas por el programa que se utilizan para las
descripciones del código o comentarios que ayudan a comprender el programa.
Comienzan con / * y terminan con * / y pueden abarcar varias líneas.
// línea de comentarios: Una línea de comentario empieza con / / y terminan con la
siguiente línea de código. Al igual que los comentarios de bloque, los de línea son
ignorados por el programa y no ocupan espacio en la memoria.
Una línea de comentario se utiliza a menudo después de una instrucción, para
proporcionar más información acerca de lo que hace esta o para recordarla más adelante.

Momento 2: Realización del primer programa

Se realizará un programa que consiste en hacer parpadear el led que viene incorporado en
la placa Arduino, en el pin número 13.
Antes vamos a definir algunas instrucciones que utilizaremos para nuestros programas.
pinMode (pin,mode): Esta instrucción es utilizada en la parte de configuración setup () y
sirve para configurar el modo de trabajo de un PIN pudiendo ser INPUT (entrada) u
OUTPUT (salida).
Los pines configurados como OUTPUT (salida) se dice que están en un estado de baja
impedancia y pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos
y circuitos. Esta corriente es suficiente para alimentar un diodo LED (no olvidando poner
una resistencia en serie), pero no es lo suficiente grande como para alimentar cargas de
mayor consumo como relés, solenoides, o motores. Un cortocircuito en las patillas
Arduino provocará una corriente elevada que puede dañar o destruir el chip Atmega. A
menudo es una buena idea conectar en la OUTUPT (salida) una resistencia externa de 470
o de 1000 Ω.
digitalRead (pin): Lee el valor de un pin (definido como digital) dando un resultado HIGH
(alto) o LOW bajo). El pin se puede especificar ya sea como una variable o una constante
(0-13).
digitalWrite(pin, value): Envía al ́pin ́ definido previamente como OUTPUT el valor HIGH
o LOW (poniendo en 1 ó 0 la salida). El pin se puede especificar ya sea como una variable
o como una constante (0-13).
delay(ms): Detiene la ejecución del programa la cantidad de tiempo en milisegundos que
se indica en la propia instrucción. De tal manera que 1000 equivale a 1seg.
Nuestro primer programa es el siguiente:
void setup() {
pinMode(13, OUTPUT); //establece el pin 13 como salida
}
void loop() {
digitalWrite(13, HIGH); //pone en alto el pin 13
delay(1000); //retardo de 1000 ms (1s)
digitalWrite(13,LOW); //pone en bajo el pin 13
delay(1000); //retardo de 1s
}

Momento 3: Transferencia del programa a la placa Arduino

Para transferir el sketch al microcontrolador de la placa Arduino, debemos conectar la
misma a la PC por medio del cable USB. Una vez conectada, debemos asegurarnos que la
placa sea reconocida, para ello nos dirigimos a la pestaña Herramientas del IDE de
Arduino y nos aseguramos que la placa seleccionada sea Arduino UNO y el puerto sea
ttyACM0.
Antes de transferir el programa podemos verificar su correcta escritura y estructura,
dirigiéndonos a la pestaña Programa y el apartado Verificar/Compilar, o en su defecto ir
hasta su ícono. Una vez verificado y corregido, de ser necesario, procederemos a
transferirlo al microcontrolador.
Para transferirlo, vamos a la pestaña Programa y luego a Subir, o en su defecto al ícono
subir. Después de un tiempo el programa ya se hallará alojado en el microcontrolador y se
comenzará a ejecutar.

Momento 4: Variables
Una variable es una manera de nombrar y almacenar un valor numérico para su uso
posterior por el programa. Como su nombre indica, las variables son números que se
pueden variar continuamente en contra de lo que ocurre con las constantes cuyo valor
nunca cambia. Una variable debe ser declarada y, opcionalmente, asignarle un valor.
Como ejemplo, declaramos una variable en el programa anterior.
Vamos a declarar la variable “led” como un entero, y le asignaremos el valor 13. De ésta
manera, cada vez que escribamos “led”, el programa lo entiende como 13.

int led=13; //declara la variable led como entero y le asigna el valor 13

void setup() {
pinMode(led, OUTPUT); //establece led (pin 13) como salida
}
void loop() {
digitalWrite(led, HIGH); //pone en alto al pin 13
 delay(1000); //retardo de 1 s
digitalWrite(led,LOW); //pone en bajo al pin 13
delay(1000); //retardo de 1 s
}

Volvemos a ejecutar los pasos para transferir el programa y observamos los resultados.
Las variables deben tomar nombres descriptivos, es decir, nombres que ayuden a
identificar lo que representan, para hacer el código más legible.
Declaración de variables
Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para declarar
una variable se comienza por definir su tipo como int (entero), long (largo), float (coma
flotante), etc, asignándoles siempre un nombre, y, opcionalmente, un valor inicial. Esto
sólo debe hacerse una vez en un programa, pero el valor se puede cambiar en cualquier
momento usando aritmética y reasignaciones diversas.
Utilización de una variable
Una variable puede ser declarada al inicio del programa antes de la parte de configuración
setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque.
En función del lugar de declaración de la variable así se determinara el ámbito de
aplicación, o la capacidad de ciertas partes de un programa para hacer uso de ella. Una
variable global es aquella que puede ser vista y utilizada por cualquier función y
estamento de un programa. Esta variable se declara al comienzo del programa, antes de
setup(). Una variable local es aquella que se define dentro de una función o como parte de
un bucle. Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró.
Por lo tanto, es posible tener dos o más variables del mismo nombre en diferentes partes
del mismo programa que pueden contener valores diferentes. La garantía de que sólo una
función tiene acceso a sus variables dentro del programa simplifica y reduce el potencial
de errores de programación.
Los tipos de variables se pueden declarar como:
byte: almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255.
int: enteros, son un tipo de datos primarios que almacenan valores numéricos de 16 bits
sin decimales comprendidos en el rango 32.767 a -32.768.
long: el formato de variable numérica de tipo extendido “long” se refiere a números
enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -2147483648 a
2147483647.
float: el formato de dato del tipo “punto flotante” “float” se aplica a los números con
decimales. Los números de punto flotante tienen una mayor resolución que los de 32 bits
con un rango comprendido 3,4028235 10 +38 a -3.4028235 10+38
array: es un conjunto de valores a los que se accede con un número índice. Cualquier
valor puede ser recogido haciendo uso del nombre de la matriz y el número del índice. El
primer valor de la matriz es el que está indicado con el índice 0, es decir el primer valor
 del conjunto es el de la posición 0. Un array tiene que ser declarado y opcionalmente
asignados valores a cada posición antes de ser utilizado
int miArray[] = {valor0, valor1, valor2...}

Momento 5: constantes
El lenguaje de programación de Arduino tiene unos valores predeterminados, que son
llamados constantes. Se utilizan para hacer los programas más fáciles de leer. Las
constantes se clasifican en grupos.
Cierto/falso (TRUE/FALSE): Estas son constantes booleanas que definen los niveles HIGH
(alto) y LOW (bajo) cuando estos se refieren al estado de las salidas digitales. FALSE se
asocia con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE también puede ser
cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200 todos
también se definen como TRUE. (esto es importante tenerlo en cuenta).
HIGH/LOW: Estas constantes definen los niveles de salida altos o bajos y se utilizan para la
lectura o la escritura digital para las patillas. ALTO se define como en la lógica de nivel 1,
ON, ó 5 voltios, mientras que BAJO es lógica nivel 0, OFF, o 0 voltios.
INPUT/OUTPUT: Estas constantes son utilizadas para definir, al comienzo del programa, el
modo de funcionamiento de los pines mediante la instrucción pinMode de tal manera que
el pin puede ser una entrada INPUT o una salida OUTPUT.

ENCUENTRO 3
Actividades
Momento 1: Repaso de lo visto el día anterior. Conexión de elementos externos a la
placa Arduino.
Después de repasar la estructura de un sketch y de las instrucciones vistas, procedemos a
conectar un led con su respectiva resistencia a la placa Arduino.
El esquemático de conexión es el siguiente:

El programa a utilizar es igual al anterior (parpadeo del led), solo que ahora utilizamos un
led conectado a otra salida de Arduino. Aquí podemos ver la ventaja de utilizar la variable
led, que permite conectar al led a distintas salidas, modificando solamente el número de
pin.
Ejecutamos el programa, lo transferimos al microcontrolador y observamos sus
resultados.
Cambiamos los valores de tiempo de encendido y apagado y cambiamos el pin de salida,
haciendo las respectivas modificaciones en el sketch.
El esquema de conexión es el siguiente:

Momento: 2 Programación de un semáforo

Con los conocimientos adquiridos, realizaremos las conexiones y el programa para
controlar un pequeño semáforo.
El esquema de conexiones se muestra en la siguiente figura:

Una vez realizado el cableado, hacemos el siguiente programa:

//Programa para controlar un semáforo

 void setup() {
pinMode(8,OUTPUT); //definimos los pines 8,10 y 12 como salidas
pinMode(10,OUTPUT);
pinMode(12,OUTPUT);
}
void loop() {
digitalWrite(12,HIGH); //encendemos la luz roja
delay(1000); //esperamos un tiempo
digitalWrite(12,LOW); //apagamos la luz roja
digitalWrite(8,HIGH); //encendemos la luz verde
delay(1000); //esperamos un tiempo
digitalWrite(8,LOW); //apagamos la luz verde
digitalWrite(10,HIGH); //encendemos la luz amarilla
delay(1000); //esperamos un tiempo
digitalWrite(10,LOW); //apagamos la luz amarilla
}

Momento 3: Modificación del programa del semáforo.

Se propone modificar el sketch anterior, utilizando variables, en lugar de los números de
los pines de salida de Arduino y para cambiar el valor de los tiempos de encendido de las
distintas luces.

ENCUENTRO 4
Actividades
Momento 1: Conexión de una placa de 5 leds a Arduino
Se procederá a conectar la placa con 5 leds, de acuerdo a la siguiente figura:

Momento 2: Realización de un sketch para controlar una secuencia de 5 leds

Se realizará un sketch para encender los leds de forma secuencial, desde el número 1 al
número 5, con un intérvalo de 400 ms, luego se apagarán todos los leds y se repite el
ciclo.
El sketch sería el siguiente:
int led1=2; //nombramos cada salida como led y un número
 int led2=4;
int led3=6;
int led4=8;
int led5=10;

void setup() {
pinMode(led1,OUTPUT); //definimos cada pin como salida
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
pinMode(led4,OUTPUT);
pinMode(led5,OUTPUT);
}
void loop() {
digitalWrite(led1,HIGH); //encendemos el led1
delay(400); //esperamos 400 ms
digitalWrite(led2,HIGH); //encendemos el led2
delay(400); //esperamos 400 ms
digitalWrite(led3,HIGH); //encendemos el led3
delay(400); //esperamos 400 ms
digitalWrite(led4,HIGH); //encendemos el led4
delay(400); //esperamos 400 ms
digitalWrite(led5,HIGH); //encendemos el led5
delay(400); //esperamos 400 ms
digitalWrite(led1,LOW); //apagamos led1
digitalWrite(led1,LOW); //apagamos led2
digitalWrite(led1,LOW); //apagamos led3
digitalWrite(led1,LOW); //apagamos led4
digitalWrite(led1,LOW); //apagamos led5
}

Momento 3: Modificamos el sketch para que enciendan los leds, de a uno por vez, desde
el led 1 al led 5 y luego en sentido contrario. El tiempo de encendido de cada led será de
500 ms y el tiempo de espera para que encienda el próximo led será de 200 ms.
El sketch será el siguiente:
int led1=2; //nombramos cada salida como led y un número
int led2=4;
int led3=6;
int led4=8;
int led5=10;

void setup() {
 pinMode(led1,OUTPUT); //definimos cada pin como salida
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
pinMode(led4,OUTPUT);
pinMode(led5,OUTPUT);
}
void loop() {
digitalWrite(led1,HIGH); //encendemos el led1
delay(500); //esperamos 500 ms
digitalWrite(led1,LOW); //apagamos el led1
delay(200); //esperamos 200 ms
digitalWrite(led2,HIGH); //encendemos el led2
delay(500); //esperamos 500 ms
digitalWrite(led2,LOW); //apagamos el led2
delay(200); //esperamos 200 ms
digitalWrite(led3,HIGH); //encendemos el led3
delay(500); //esperamos 500 ms
digitalWrite(led3,LOW); //apagamos el led3
delay(200); //esperamos 200 ms
digitalWrite(led4,HIGH); //encendemos el led4
delay(500); //esperamos 500 ms
digitalWrite(led4,LOW); //apagamos el led4
delay(200); //esperamos 200 ms
digitalWrite(led5,HIGH); //encendemos el led5
delay(500); //esperamos 500 ms
digitalWrite(led5,LOW); //apagamos el led5
delay(200); //esperamos 200 ms
digitalWrite(led4,HIGH); //encendemos el led4
delay(500); //esperamos 500 ms
digitalWrite(led4,LOW); //apagamos el led4
delay(200); //esperamos 200 ms
digitalWrite(led3,HIGH); //encendemos el led3
delay(500); //esperamos 500 ms
digitalWrite(led3,LOW); //apagamos el led3
delay(200); //esperamos 200 ms
digitalWrite(led2,HIGH); //encendemos el led2
delay(500); //esperamos 500 ms
digitalWrite(led2,LOW); //apagamos el led2
delay(200); //esperamos 200 ms
}
Momento 4: Modificación del sketch anterior utilizando arreglos y la función for
Funciones
Una función es un bloque de código que tiene un nombre y un conjunto de estamentos
que son ejecutados cuando se llama a la función. Son funciones setup() y loop() de las que
ya se ha hablado. Las funciones de usuario pueden ser escritas para realizar tareas
repetitivas y para reducir el tamaño de un programa. Las funciones se declaran asociadas
a
un tipo de valor “type”. Este valor será el que devolverá la función, por ejemplo 'int' se
utilizará cuando la función devuelva un dato numérico de tipo entero. Si la función no
devuelve ningún valor entonces se colocará delante la palabra “void”, que significa
“función vacía”. Después de declarar el tipo de dato que devuelve la función se debe
escribir el nombre de la función y entre paréntesis se escribirán, si es necesario, los
parámetros que se deben pasar a la función para que se ejecute.
tipo nombreFunción(parámetros)
{
estamentos;
}

for: La declaración for se usa para repetir un bloque de sentencias encerradas entre
llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del
bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;)
vemos el ejemplo de su sintaxis:
for (inicialización; condición; expresión)
{
Instrucciones;
}
La inicialización de una variable local se produce una sola vez y la condición se testea cada
vez que se termina la ejecución de las instrucciones dentro del bucle. Si la condición sigue
cumpliéndose, las instrucciones del bucle se vuelven a ejecutar.
Cuando la condición no se cumple, el bucle termina. El siguiente ejemplo inicia el entero i
en 0, y la condición es probar que el valor es inferior a 20 y si es cierto i se incrementa en
1 y se vuelven a ejecutar las instrucciones que hay dentro de las llaves:
for (int i=0; i<20; i++) //declara i, prueba que es menor que 20, incrementa i en 1
{
digitalWrite(13, HIGH); // envía un 1 al pin 13
delay(250); // espera 1⁄4 seg.
digitalWrite(13, LOW); // envía un 0 al pin 13
delay(250); // espera 1⁄4 de seg.
}
 Si en el sketch anterior, utilizamos variables, arreglos y la función for, nuestro sketch se
simplifica y queda de la siguiente manera:
int led[]={2,4,6,8,10,}; //nombramos cada salida como led y un número
int tencendido=500;
int tapagado=200;
void setup() {
for(int i=0;i<5;i++) {
pinMode(led[i],OUTPUT); //definimos cada pin como salida
}
}
void loop() {
for(int i=0;i<5;i++) {
digitalWrite(led[i],HIGH); //encendemos el led
delay(tencendido); //esperamos medio segundo
digitalWrite(led[i],LOW); //apagamos el led
delay(tapagado);
}
for(int i=3;i>=1;i--) {
digitalWrite(led[i],HIGH); //encendemos el led
delay(tencendido); //esperamos medio segundo
digitalWrite(led[i],LOW); //apagamos el led
delay(tapagado);
}
}

ENCUENTRO 5
Actividades
Momento 1: Utilización de pulsador y display 7 segmentos.Conexiones.
La conexión de un pulsador o interruptor a una entrada digital se realiza como indica el
esquemático:

La resistencia es necesaria para que el pin de entrada tenga un valor de 0 Volts cuando se
abre el pulsador o interruptor. Si se requiere 5 Volts cuando el pulsador o interruptor se
abre, se intercambia la conexión entre el pulsador y la resistencia.
Realizaremos un sketch que muestre en el display el conteo de las veces que se pulsa el
pulsador, hasta llegar a 9.
Por medio de otro pulsador, se reiniciará el conteo a partir de cero, independientemente
del estado de la cuenta.
Además un buzzer, indicará cuando la cuenta pasa nuevamente a cero.
El diagrama de conexiones es el siguiente:

Momento 2: Realización del programa

Nos valeremos de funciones para realizar nuestro programa. La idea es que cada vez que
se oprime el pulsador, se llame a una función que encenderá al display mostrando el
número correspondiente.
El programa es el siguiente:
// Programa para controlar un Display 7 segmentos con un pulsador

// Cada vez que se oprime el pulsador, cambia la cuenta del display

// Cuando se oprime el pulsador de reset, la cuenta vuelve a cero, independientemente
del estado de la cuenta
// Cada vez que la cuenta pasa de 9 a cero, suena el buzzer

int numero[]= {2,3,4,5,6,7,8}; //pines de Arduino para conectar el display (a,b,c,d,e,f,g)

int pulsador= 10; //pin de entrada del pulsador
int i; //varaiable para conteo
int estado; //variable para guardar estado del pulsador
int contador; //lleva la cuenta de las veces que se oprime el pulsador
#define buzzer 11 //pin 11 salida buzzer
void setup() {
for(i=0; i<=6; i++){
pinMode(numero[i],OUTPUT); //se definen como salidas los pines del display
}
pinMode(pulsador, INPUT); //pin del pulsador como entrada
pinMode(buzzer,OUTPUT); //pin de buzzer como salida
cero();
}

void loop() {
estado = digitalRead(pulsador); //se lee el valor del pulsador y se guarda en estado
while(estado == HIGH){ //mientras estado esté en alto, se ejecuta lo siguiente
delay(150); //retardo para evitar rebotes
estado = digitalRead(pulsador); //se lee nuevamente el estado del pulsador
if(estado == 0){ //si el estado es cero
contador++; //se incrementa el contador
if(contador >9){ //si contador es mayor a 9
contador = 0; //se pone encero contador
tone(buzzer,1500,500); //se produce un tono de 1500 Hz durante medio segundo
cero(); //se llama a la función cero
}
}
}
int reinicio; //declaración de la variable reinicio
reinicio= digitalRead (0); //lectura del valor del pulsador de reinicio
if(reinicio == HIGH){ //si se oprimió el pulsador
cero(); //reiniciar el conteo (puesta a cero)
contador=0; //poner en cero la variable contador
}
if(contador==1){ //preguntar por contador y llamar a la función del número
uno ();
}
if(contador==2){
dos ();
}
if(contador==3){
 tres ();
}
if(contador==4){
cuatro ();
}
if(contador==5){
cinco ();
}
if(contador==6){
seis ();
}
if(contador==7){
siete ();
}
if(contador==8){
ocho ();
}
if(contador==9){
nueve ();
}
}

void cero(){ //declaración función cero

for(i=0;i<=5;i++){
digitalWrite (numero[i],HIGH); //enciende los led a hasta f del display
}
digitalWrite (numero[6],LOW); //apaga el led h del display
}

void uno(){ //declaración de la función uno

digitalWrite (numero[0],LOW); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],LOW);
digitalWrite (numero[4],LOW);
digitalWrite (numero[5],LOW);
digitalWrite (numero[6],LOW);
}

void dos(){ //declaración de la función dos

 digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],LOW);
digitalWrite (numero[3],HIGH);
digitalWrite (numero[4],HIGH);
digitalWrite (numero[5],LOW);
digitalWrite (numero[6],HIGH);
}

void tres(){ //declaración de la función tres

digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],HIGH);
digitalWrite (numero[4],LOW);
digitalWrite (numero[5],LOW);
digitalWrite (numero[6],HIGH);
}

void cuatro(){ //declaración de la función cuatro

digitalWrite (numero[0],LOW); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],LOW);
digitalWrite (numero[4],LOW);
digitalWrite (numero[5],HIGH);
digitalWrite (numero[6],HIGH);
}

void cinco(){ //declaración de la función cinco

digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],LOW);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],HIGH);
digitalWrite (numero[4],LOW);
digitalWrite (numero[5],HIGH);
digitalWrite (numero[6],HIGH);
}

void seis(){ //declaración de la función seis

 digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],LOW);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],HIGH);
digitalWrite (numero[4],HIGH);
digitalWrite (numero[5],HIGH);
digitalWrite (numero[6],HIGH);
}

void siete(){ //declaración de la función siete

digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],LOW);
digitalWrite (numero[4],LOW);
digitalWrite (numero[5],LOW);
digitalWrite (numero[6],LOW);
}

void ocho(){ //declaración de la función ocho

digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],HIGH);
digitalWrite (numero[4],HIGH);
digitalWrite (numero[5],HIGH);
digitalWrite (numero[6],HIGH);
}

void nueve(){ //declaración de la función nueve

digitalWrite (numero[0],HIGH); //se encienden y se apagan los leds correspondientes
digitalWrite (numero[1],HIGH);
digitalWrite (numero[2],HIGH);
digitalWrite (numero[3],HIGH);
digitalWrite (numero[4],LOW);
digitalWrite (numero[5],HIGH);
digitalWrite (numero[6],HIGH);
}
 ENCUENTRO 6
Actividades
Momento 1: Manejo de salidas de alto consumo de corriente
A veces es necesario controlar cargas de más de los 40 mA que es capaz de suministrar la
tarjeta Arduino. En este caso se hace uso de un transistor BIPOLAR ó MOSFET que puede
alimentar cargas de mayor consumo de corriente.
La forma de conectarlo se muestra en el siguiente esquemático:

Si se envía HIGH al pin, el motor funciona. Por el contrario si se envía LOW al pin, el motor
deja de funcionar.

Momento 2: Conexión de un motor controlado por un transistor bipolar NPN

Realizaremos la conexión de un motor a la placa Arduino, para que sea controlado por
medio de un transistor TIP 41C.
El diagrama de conexiones es el siguiente:
Realizamos un pequeño programa para su control. El mismo consiste en encender durante
un tiempo el motor, y luego apagarlo durante otro tiempo. Esto se repetirá 5 veces y
luego se detiene.
El programa es el siguiente:

//Programa para controlar un motor mediante transistor

#define motor 12 //motor conectado al pin 12
int i;
void setup() {
pinMode(motor,OUTPUT); //definimos la pin 12 como salida

void loop() {
for(i=0; i<6; i++){ //repetimos 5 veces
digitalWrite(motor,HIGH); //encendemos motor
delay(1000); //esperamos 1 segundo
digitalWrite(motor,LOW); //apagamos motor
delay(1000); //esperamos 1 segundo
}

Momento 3: Funcionamiento del sensor infrarrojo

Con el objetivo de realizar más adelante un robot sigue líneas, estudiaremos el
funcionamiento del sensor CNY 70, que consiste de un diodo emisor infrarrojo, y de un
fototransistor. Su encapsulado se puede observar en la siguiente figura:
Al hacer circular una corriente por el led, éste emite un rayo de luz infrarroja (invisible al
ojo humano), y al rebotar en algún objeto, la recibe el fototransistor y de esa manera
obtenemos una señal que puede ser detectada por la placa Arduino.
Las conexiones serían las siguientes:

Un móvil sigue líneas, sigue una línea negra trazada sobre fondo claro, por medio de dos
sensores CNY 70 separados por el ancho de la línea y colocados en la parte frontal del
mismo. El móvil cuenta con dos motores (izquierdo y derecho), que permiten controlar su
movimiento.
Cada vez que un sensor detecta la zona clara, produce la detención del motor contrario al
sensor. Es decir, el sensor derecho detiene al motor izquierdo y el sensor izquierdo
detiene al motor derecho. Este comportamiento permite que el móvil pueda seguir la
trayectoria de la línea negra, ya que de estar ambos sensores detectando a la misma, los
dos motores continuarán funcionando.
ENCUENTRO 7
Actividades
Momento 1: Construcción de un móvil sigue líneas
Se entregará a cada participante una plataforma con los dos motores ya colocados, un
portapilas, un convertidor de tensión y una placa Arduino UNO.
Además se hará entrega de un experimentor, resistencias, transistores, diodos y un
conjunto de cables de conexión.

Momento 2: Armado del circuito sobre el experimentor

Se procederá a realizar el circuito de acuerdo a las conexiones mostradas en la siguiente
figura:
 Los sensores infrarrojos (represntados en la figura por dos leds, uno blanco y el otro gris),
se colocarán delante del móvil y a unos 3 mm por encima del piso.

Momento 3: Ensamble del móvil sigue línea

Se coloca el circuito armado en el experimentor sobre el móvil, se acoplan los sensores y
se los conecta al circuito. Se preparan los cables de alimentación para la placa Arduino.
Se deja todo armado para el próximo encuentro.

ENCUENTRO 8
Actividades
Momento 1: Programación del móvil sigue línea
Antes de realizar la programación, hay que tener en cuenta que los valores que recibe el
pin donde se conecta el sensor infrarrojo, están comprendidos entre 0 y 1024,
dependiendo de la cantidad de luz infrarroja que llegue al fototransistor. Es por ésto que
conectamos las salidas de los sensores a entradas analógicas de Arduino.
Cuando el sensor recibe el reflejo del haz infrarrojo, el valor que llega al pin de Arduino es
un valor alto, de lo contrario recibe un valor bajo, en éste caso está detectando la línea. La
idea es que cuando ambos sensores (derecha e izquierda) detecten la línea, pongan en
funcionamiento ambos motores. Cuando algún sensor no detecte la línea, detenga el
movimiento del motor opuesto al mismo, de tal manera que el auto retome su camino por
la línea.
Por lo tanto tendremos que determinar un umbral, para establecer cuando detecta la
línea y cuando no. Este umbral dependerá de la altura a la que se encuentran los sensores,
 de la cantidad de luz sobre la pista y del contraste entre la línea negra y sus alrededores.
El programa a realizar es el siguiente:
int umbral= 500; //umbral para determinar cuando está sobre la línea
int Sderecha = 3; //Salida para activar el motor derecho, pin 3
int Sizquierda = 11; //Salida para activar el motor izquierdo, pin 11
int valorSD; //valor del sensor derecho
int valorSI; //valor del sensor izquierdo

void setup() {
pinMode(Sderecha, OUTPUT); //Configuramos los pines 3 y 11 como salidas
pinMode(Sizquierda,OUTPUT);
}
//El sensor infrarrojo entrega un valor bajo si detecta la linea y un valor alto si no detecta

void loop() {
valorSD=analogRead(A5); //Leemos el sensor infrarrojo derecho y guardamos su valor
valorSI=analogRead(A0); //Leemos el sensor infrarrojo izquierdo y guardamos su valor

if(valorSD >= umbral){ //Si señal sensor derecho es mayor o igual a umbral
digitalWrite(Sizquierda,LOW); //Paramos motor izquierdo
}
else { //Si detecta línea
digitalWrite(Sizquierda,HIGH);//Encendemos motor izquierdo
}

if(valorSI >= umbral){ //Si señal sensor izquierdo es mayor o igual a umbral
digitalWrite(Sderecha,LOW); //Paramos motor derecho
}
else { //Si detecta línea
digitalWrite(Sderecha,HIGH); //Encendemos motor derecho
}

}
Se procede a cargar el programa a la placa Arduino y se verifica su funcionamiento.

ENCUENTRO 9
Actividades
Momento 1: Puesta a punto
 Los participantes buscarán optimizar el programa y el móvil para que funcione
correctamente.

Momento 2: Competencia
Los participantes competirán entre sí, buscando que el móvil no se desvíe de la línea y que
lo haga en el menor tiempo posible.
Para ello ajustarán las variables necesarias para el correcto funcionamiento del móvil
sigue línea.

Público objetivo: chicos entre 15 y 18 años.

Laboratorios involucrados : Fabricación
Duración: 8 ó 9 encuentros