LAB03 Arduino PROC1 2019

UNIVERSIDAD NACIONAL DE SAN LUIS
Facultad de Ciencias Físico Matemática y Naturales –Dpto. de Electrónica

Técnico Universitario en Microprocesadores
Ingeniería Electrónica Orientación Sistemas Digitales 2019
PROCESADORES I
LABORATORIO 3: Programación en Lenguaje Processing - Arduino
“Este Material de basa, en gran parte, al aporte brindado por la Ing. Andrada Tivani Astri Edith, docente de la
cátedra Procesadores II”
1. Objetivos
Los objetivos del presente laboratorio son:
 Profundizar el manejo de las herramientas de desarrollo de la plataforma Arduino y Proteus ISIS.
 Estudiar ejemplos del IDE Arduino
 Manejo de placa Arduino UNO
2. Material de Referencia
 Arduino Curso práctico de formación - Óscar Torrente Artero
 Manual de uso de Proteus
 Hoja de datos Arduino
3. Instructivo de carga de programa en placa Arduino
Para proceder a realizar la carga del programa verificado en la placa Arduino escogida, debe tener en cuenta
los siguientes pasos:
A. Conectar la placa Arduino al pc desde la que se está trabajando.

B. Seleccionar el tipo de placa desde Herramientas->Placa
C. Seleccionar el puerto USB que utiliza la placa desde Herramientas->Puerto
D. Realizar la Verificación (Botón Check )
E. Luego la Carga a la placa (Botón Subida )
En las figuras 1 y 2 se observa el caso de utilizar la Placa Arduino UNO en el puerto COM3:
Figura 1 Selección de placa
Laboratorio N° 3 Página 1
Figura 2 Selección de puerto
4. Características generales de un sketch Arduino

4.1.1 Secciones de sketch
Un programa diseñado para ejecutarse sobre un Arduino (un sketch) siempre se compone de tres secciones:
Sección de declaraciones de variables globales: ubicada directamente al principio del sketch. No tiene
ningún tipo de símbolo delimitador de inicio o de final. Está reservada para escribir, tal como su nombre
indica, las diferentes declaraciones de variables que se requieran.
Sección llamada “void setup()”: delimitada por llaves de apertura y cierre. Se escriben las instrucciones que
se ejecutan una única vez, en el momento de encender (o resetear) la placa Arduino. Sirven para realizar
preconfiguraciones iniciales.
Sección llamada “void loop()”: delimitada por llaves de apertura y cierre. Se escriben las instrucciones que se
ejecutan justo después de la sección “void setup()” infinitas veces hasta que la placa se apague (o se resetee).
Es decir, el contenido de “void loop()” se ejecuta desde la 1ª instrucción hasta la última, indefinidamente. En
definitiva, es el programa que está funcionando continuamente.
4.1.2 Detalles importantes
Para tener en cuenta a la hora de escribir los sketches y evitar inconvenientes:

 El lenguaje Arduino es “case-sensitive”. Esto quiere decir que es totalmente diferente escribir una
letra en mayúscula que en minúscula. Dicho de otra forma: para el lenguaje Arduino “HolA” y “hOLa” son dos
palabras distintas. Esto tiene una implicación muy importante: no es lo mismo escribir por ejemplo
“Serial.begin(9600);” que “serial.begin(9600);”. En el primer caso la instrucción estaría correctamente escrita,
pero en el segundo, en el momento de compilar el código el IDE se quejaría porque para él “serial” (con “s”
minúscula) no tiene ningún sentido. Así que hay que vigilar mucho con respetar esta distinción en los códigos
que se escriban.
 Las tabulaciones de las instrucciones contenidas dentro de las secciones “void setup()” y “void loop()”
no son en absoluto necesarias para que la compilación del sketch se produzca con éxito. Simplemente son
una manera de escribir el código de forma ordenada, clara y cómoda para el programador, facilitándole la
tarea de leer código ya escrito y mantener una cierta estructura a la hora de escribirlo.
 Todas las instrucciones (incluyendo también las declaraciones de variables) acaban con un punto y
coma. Es indispensable añadir siempre este signo para no tener errores de compilación, ya que el compilador
necesita localizarlo para poder detectar el final de cada instrucción escrita en el sketch. Si se olvida, se
mostrará un texto de error que puede ser obvio (“falta un punto y coma”) o no. Si el texto del error es muy
oscuro o sin lógica, es buena idea comprobar que la causa no sea la falta de un punto y coma en las líneas
justamente anteriores a la marcada por el compilador como causante del problema.
4.1.3 Tipos de una variable en sketch Arduino
El tipo “boolean”
Las variables de este tipo solo pueden tener dos valores: cierto o falso. Se utilizan para almacenar un estado
de entre esos dos posibles, y así hacer que el sketch reaccione según detecte en ellas uno u otro. Por
ejemplo, las variables booleanas se pueden usar para comprobar si se han recibido datos de un sensor
(cierto) o no (falso), para comprobar si algún actuador está disponible (cierto) o no (falso), para comprobar si
el valor de otra variable diferente cumple una determinada condición como por ejemplo la de ser mayor que
un número concreto (cierto) o no (falso). El valor guardado en una variable booleana ocupa siempre un byte
de memoria.
Para asignar explícitamente a una variable de tipo “boolean” el valor de cierto, se puede utilizar la palabra
especial true o bien el valor 1, y para asignarle el valor de falso se puede utilizar la palabra especial false o
bien el valor 0.
El tipo “char”
El valor que puede tener una variable de este tipo es siempre un solo carácter (una letra, un dígito, un signo
de puntuación). Si se quiere almacenar una cadena de caracteres (es decir, una palabra o una frase) el tipo
“char” no sirve, se debe usar otro tipo explicado posteriormente. Para asignar explícitamente a una variable
de tipo “char” un determinado valor (es decir, un carácter), se debe tener la precaución de escribir ese
carácter entre comillas simples. Por tanto, si se tiene una variable “mivariable” tipo “char” para asignarle el
valor de la letra A se tendría que escribir una línea char mivariable='A';. En realidad, los caracteres se
almacenan internamente como números ya que los dispositivos electrónicos son incapaces de trabajar con
“letras” directamente: las han de “traducir” siempre primero a números para entonces poderlas almacenar y
procesar. Cada variable de tipo carácter ocupa 8 bits (un byte) de memoria para almacenar su valor.
El tipo “byte”
El valor que puede tener una variable de este tipo es siempre un número entero entre 0 y 255. Al igual que
las variables de tipo “char”, las de tipo “byte” utilizan un byte (8 bits) para almacenar su valor y, por tanto,
tienen el mismo número de combinaciones numéricas posibles diferentes (256), los valores de una variable
“byte” no pueden ser negativos.
El tipo “int”
El valor que puede tener una variable de este tipo es un número entero entre -32768 (-215) y 32767 (215-1),
gracias a que utilizan 2 bytes (16 bits) de memoria para almacenarse. Esto es así para todas las placas Arduino
excepto para la Due: en este modelo de placa el tipo “int” utiliza 4 bytes, y por tanto, su valor puede estar
dentro de un rango mayor.
El tipo “word”
Las variables de tipo “word” en la placa basadas en microcontroladores de tipo AVR ocupan un espacio de
memoria de 2 bytes. Los valores no pueden ser negativos.
El tipo “short”
El valor que puede tener una variable de este tipo para todos los modelos de placa (ya sean basadas en
microcontroladores de tipo AVR –la mayoría– o de tipo ARM –la Due–) es un número entero entre -32768 (-
215) y 32767 (215-1), gracias a que utilizan 2 bytes (16 bits) de memoria para almacenarse. En este sentido,
los tipos “short” e “int” para placas de la familia AVR son equivalentes, pero para la placa Arduino Due el tipo
“short” es el único que utiliza 16 bits.
El tipo “long”
microcontroladores de tipo AVR o de tipo ARM) es un número entero entre -2.147.483.648 y 2.147.483.647
gracias a que utilizan 4 bytes (32 bits) de memoria para almacenarse. En este sentido, los tipos “long” e “int”
para placas de la familia ARM son equivalentes.
El tipo “unsigned long”
microcontroladores de tipo AVR o ARM) es un número entero entre 0 y 4.294.967.295 (232-1). Al igual que
las variables de tipo “long”, las de tipo “unsigned long” utilizan 4 bytes (32 bits) para almacenar su valor, y,
por tanto, tienen el mismo número de combinaciones numéricas posibles diferentes (232), pero a diferencia
de aquellas, los valores de una variable “unsigned long” no pueden ser negativos (tal como ya indica su
propio nombre).
El tipo “float”
El valor que puede tener una variable de este tipo es un número decimal. Los valores “float” posibles pueden
ir desde el número -3,4028235x1038 hasta el número 3,4028235x1038. Debido a su rango de valores posibles,
los números decimales son usados frecuentemente para aproximar valores analógicos continuos. No
obstante, solo tienen 6 o 7 dígitos en total de precisión. Es decir, los valores “float” no son exactos, y pueden
producir resultados inesperados, como por ejemplo que, 6.0/3.0 no dé exactamente 2.0.
El tipo “double”
Es un sinónimo exactamente equivalente del tipo “float”, y por tanto no aporta ningún aumento de precisión
respecto a este (a diferencia de lo que pasa en otros lenguajes, donde “double” sí que aporta el doble de
precisión). Tanto una variable de tipo “double” como una de tipo “float” ocupan cuatro bytes de memoria.
El tipo “array”
Este tipo de datos en realidad no existe como tal. Lo que existen son arrays de variables de tipo “boolean”,
arrays de variables de tipo “int”, arrays de variables de tipo “float”, etc. En definitiva: arrays de variables de
cualquier tipo de los mencionados hasta ahora. Un array (también llamado “vector”) es una colección de
variables de un tipo concreto que tienen todas el mismo y único nombre, pero que pueden distinguirse entre
sí por un número a modo 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 un único array 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 del array cada una está identificada mediante un índice
numérico, escrito entre corchetes (varChar[0], varChar[1], varChar[2]...). Los arrays sirven para ganar claridad
y simplicidad en el código, además de facilitar la programación.
Constantes
Es posible declarar una variable de tal forma que consigamos que su valor (del tipo que sea) permanezca
siempre inalterado. Es decir, que su valor no se pueda modificar nunca porque esté marcado como de “solo
lectura”. De hecho, a este tipo de variables ya no se les llama así por motivos obvios, sino “constantes”.
Las constantes se pueden utilizar como cualquier variable de su mismo tipo, pero si se
intenta cambiar su valor, el compilador lanzará un error.
Para convertir una variable (sea global o local) en constante, lo único que hay que hacer es preceder la
declaración de esa variable con la palabra clave const. Por ejemplo, para convertir en constante una variable
llamada “sensor” de tipo “byte”,
simplemente se ha de declarar así: const byte sensor; .
Existe otra manera de declarar constantes en el lenguaje Arduino, que es utilizando la directiva especial
#define (heredada del lenguaje C).
4.1.4 Instrucciones de gestión de tiempo
millis()
Devuelve el número de milisegundos (ms) desde que la placa Arduino empezó a ejecutar el sketch actual.
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, que es “unsigned long”). No tiene parámetros.
micros()
Devuelve el número de microsegundos (µs) desde que la placa Arduino empezó a ejecutar el sketch actual.
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.
delay()
Pausa el sketch durante la cantidad de milisegundos especificados como parámetro –de tipo “unsigned
long”–. No tiene valor de retorno.
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.
4.1.5 Operadores aritméticos
Además de las instrucciones matemáticas, el lenguaje Arduino dispone de varios operadores aritméticos,
algunos de los cuales ya han ido apareciendo en algunos códigos de ejemplo. Estos operadores funcionan
tanto para números enteros como decimales y son los mencionados en la figura 3.
Figura 3 Operadores aritméticos
El operador módulo sirve para obtener el resto de una división. Por ejemplo: 27%5=2 . Es el único operador
que no funciona con “floats”.
4.1.6 Bloques condicionales
Los bloques if y if/else
Un bloque “if” sirve para comprobar si una condición determinada es cierta (“true”,1) o falsa (“false”,0). Si la
condición es cierta, se ejecutarán las instrucciones escritas en su interior (es decir, dentro de las llaves de
apertura y cierre). Si no se cumple, puede no pasar nada, o bien, si existe tras el bloque “if” un bloque “else”
(opcional), se ejecutarán las instrucciones escritas en el interior de ese bloque “else”. Es decir, si solo se
escribe el bloque “if”, el sketch tendrá respuesta solamente para cuando se cumpla la condición; pero si
además escribimos un bloque “else”, el sketch tendrá respuesta para cuando sí se cumple la condición y para
cuando no se cumple también. También existe la posibilidad de incluir una o varias secciones “else if”, siendo
en este caso también opcional el bloque “else” final.
if (condición) {
//Instrucciones –una o más– que se ejecutan si la condición es cierta
} else if (otra_condición) {
/*Instrucciones –una o más– que se ejecutan si la condición del anterior “if” es falsa pero la actual es cierta */
} else if (otra_condición) {
/*Instrucciones –una o más– que se ejecutan si la condición del anterior “if” es falsa pero la actual es cierta */
} else {
//Instrucción(es) que se ejecutan si todas las condiciones anteriores eran falsas
}
Para escribir correctamente en el sketch las condiciones de los bloques vistos anteriormente, se requiere
utilizar alguno de los llamados operadores de comparación, que son los presentes en la figura 4.
Figura 4 Operadores de comparación
El bloque “switch”
Como se ha podido ver en el apartado anterior, los bloques “else if” se tienen en cuenta siempre y cuando las
condiciones evaluadas hasta entonces hayan sido falsas, y la condición del propio “else if” sea la cierta. Es
decir, un bloque if(condicion1){}else if(condicion2){} se puede leer como “si ocurre condicion1, ejecute el
interior del primer if, y si no, observe si ocurre la condicion2, y (solo) si es así, ejecute entonces el interior del
elseif”. Esta es una manera válida de hacer comprobaciones de condiciones múltiples, pero existe otra forma
más elegante, cómoda y fácil de hacer lo mismo: utilizar el bloque “switch”.
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
}
Un bloque “switch” es como una especie de “if else” escrito de manera compacta. Como se puede ver, consta
en su interior de una serie de secciones “case” y, opcionalmente, de una sección “default”. Al llegar a la
primera línea del “switch”, primero se comprueba el valor de la variable o expresión que haya entre sus
paréntesis (siguiendo las mismas reglas y operadores posibles usados en un “if” estándar). Si el resultado es
igual al valor especificado en la primera sección “case”, se ejecutarán las instrucciones del interior de la
misma y se dará por finalizado el “switch”, continuando la ejecución del sketch por la primera línea después
de la llave de cierre. En caso de no ser igual el resultado de la expresión a lo especificado en el primer “case”
se pasará a comprobarlo con el segundo “case”, y si no con el tercero, etc. Por último, si existe una sección
“default” (opcional) y el resultado de la expresión no ha coincidido con ninguna de las secciones “case”,
entonces se ejecutarán las sentencias de la sección “default”.
4.1.7 Bloques repetitivos
El bloque “while”
El bloque “while” (“mientras”, en inglés) 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. No se especifica la cantidad de
repeticiones, pero las instrucciones del bucle se repetirán mientras la condición especificada entre sus
paréntesis sea cierta (“true”,1). Su sintaxis es muy sencilla:
while (condición) {
//Instrucciones que se repetirán mientras la condición sea cierta –”true”,1–
}
La condición escrita entre paréntesis sigue las mismas reglas y puede utilizar los mismos operadores vistos
con el bloque “if”. Nada más llegar a la línea donde aparece escrita esta condición, esta se comprobará; si
resulta cierta, se ejecutarán las sentencias interiores, y si no, la ejecución del programa continuará a partir de
la línea siguiente a la llave de cierre. En el primer caso (cuando la condición es cierta), una vez ejecutadas
todas las instrucciones del interior del bloque “while”, se volverá a comprobar de nuevo la condición, y si esta
continúa siendo cierta, se realizará otra iteración (es decir: se volverán a ejecutar las sentencias interiores).
Cuando se llegue de nuevo al final de esas instrucciones anteriores, se volverá a evaluar la condición, y si
sigue siendo cierta, se volverán a ejecutar. Este proceso continuará hasta que, en un momento dado, al
comprobarse la condición del “while”, esta resulte falsa. Si se llega por primera vez a una sentencia “while” y
la condición resulta falsa directamente, no se ejecutarán las sentencias interiores ninguna vez. Este detalle es
importante tenerlo en cuenta. Las sentencias interiores a un bucle “while” pueden ser tantas como se
quieran y de cualquier tipo, incluyendo, por supuesto, nuevos bucles “while”.
El bloque “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, se usa el bucle “for” para ejecutar un conjunto de instrucciones
(escritas dentro de llaves de apertura y cierre) 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í se escribe x=0, se fijará la variable “x” a cero al inicio
del bucle. A partir de entonces, a cada repetición del bucle, esta variable “x” irá aumentando (o
disminuyendo) progresivamente de valor.
Condición final del bucle: en esta parte se especifica una condición (del estilo de las utilizadas en un bucle
“while”). 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 “for”, continuando el programa
tras su llave de cierre. Por ejemplo, si allí se escribe x continuando el programa tras su llave de cierre. Por
ejemplo, si allí se escribe x<10, el grupo interior de sentencias se ejecutará únicamente cuando la variable “x”
valga menos de 10 (es decir, mientras x<10 sea cierto).
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 se estaría 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.
5. Ejercicios
Ejercicio N° 1
Realice la carga del ejemplo 0.1 Basic-Blink en la placa Arduino UNO. Modifique el código para que cambie la
velocidad de encendido y apago del led.
- ¿Observa diferencias con la simulación de Proteus del mismo sketch? ¿Por qué?
Ejercicio Nº 2
Tome el ejemplo 0.1 Basic-Fade. Realice la simulación del mismo en Proteus. Modifique lo que crea
conveniente para realizar la carga en la placa Arduino UNO y se pueda visualizar el funcionamiento. Conteste:
- ¿Qué realiza el código?
- ¿Posee variables globales?
- ¿Tuvo que modificar algo en código para la implementación en la placa evitando el uso de hardware
extra?
- Reemplace el bloque condicional del sketch por otro.
Ejercicio Nº 3
Observe el sketch del ejemplo 03.Analog-Fading:
- ¿Qué realiza el código?
- ¿Por qué motivo no posee ninguna línea de código la función void setup()?
- ¿Posee estructuras condicionales o de repetición?
Ejercicio Nº 4
Observe el sketch 05.Control-Arrays:
- ¿Cuál es el uso del array global?
- ¿Qué realiza la función void loop()?
- ¿Podría utilizarse otro tipo de estructura? ¿Por qué?
Ejercicio N°5
Teniendo en cuenta el ejemplo 05.Control.switchCase2:
- Explique para qué se usa la estructura condicional.
- El bloque for, ¿se encuentra dentro de la estructura switch? ¿Qué finalidad posee?
Ejercicio N° 6
¿Cómo se puede realizar la utilización de bloques if anidados? ¿En qué casos y de qué manera se pueden
reemplazar por el bloque switch?
Ejercicio N°7
Investigue qué hace el bloque repetitivo “do”. Ejemplifique.
Investigue cuál es la finalidad de las instrucciones matemáticas, trigonométricas y pseudoaletoriedad. De dos
ejemplos de cada una.
Proyecto
Realice un sketch donde resuelva la siguiente inquietud y simule en Proteus:
- Una cinta transportadora posee dos motores, para realizar el movimiento hacia delante y hacia atrás.
- Se tienen 3 sensores con los cuales se controla la cinta:
o 1° sensor controla la presencia del primer producto y hace funcionar un motor.
o 2° sensor controla que hayan pasado 9 productos, sin tener en cuenta el detectado por el
primer sensor. Una vez que llega el 9°, se frena la cinta. Transcurridos unos 500ms se procede
a realizar el apagado del motor encendido anteriormente.
o 3° sensor indica si ya no hay productos (teniendo en cuenta que ya han pasado los 9
detectados y los 500ms) y hace girar la cinta transportadora en el sentido inverso con el otro
motor.
- ¿Qué estructuras condicionales puede utilizar?
- ¿Requiere estructuras iterativas?
Para aprobar debe mostrar la totalidad de los ejercicios al docente a cargo.

Realizar la entrega de las respuestas de los ejercicios y el Proyecto en un informe, con capturas de pantalla
en caso de ser necesarias.

LAB03 Arduino PROC1 2019

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

LAB03 Arduino PROC1 2019

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE SAN LUIS

Facultad de Ciencias Físico Matemática y Naturales –Dpto. de Electrónica

3. Instructivo de carga de programa en placa Arduino

A. Conectar la placa Arduino al pc desde la que se está trabajando.

Figura 1 Selección de placa

Figura 2 Selección de puerto

4. Características generales de un sketch Arduino

4.1.2 Detalles importantes

Para tener en cuenta a la hora de escribir los sketches y evitar inconvenientes:

4.1.3 Tipos de una variable en sketch Arduino

4.1.4 Instrucciones de gestión de tiempo

Figura 3 Operadores aritméticos

4.1.6 Bloques condicionales

Los bloques if y if/else

Figura 4 Operadores de comparación

4.1.7 Bloques repetitivos

Para aprobar debe mostrar la totalidad de los ejercicios al docente a cargo.

También podría gustarte