Unidad 2 Arduino

Arduino U2
Presentación - Unidad 2
En esta unidad daremos los pasos básicos de programación en C, C++
dentro de la plataforma del Arduino, analizaremos la estructura del
programa, la declaración de variables, los tipos de variables, concep-
tos como: array, aritméticas , asignaciones compuestas, operadores de
comparación, operadores lógicos, constantes, directivas condicionales,
manejo de los pines del Arduino, lógicos o analógicos, he integraremos
los conocimientos utilizando un programa estructurado de manera
diferente al primer programa de la clase anterior.
Objetivos:
• FAMILIARIZARNOS CON EL LENGUAJE DE C, C++
Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Introducción
01
SECCIÓN
Estructructura
Variables
Tipos de datos
01
SECCIÓN INTRODUCCIÓN
LENGUAJE DE PROGRAMACIÓN
El IDE de Arduino se programa en una variante de C++ , que es un lenguaje muy exten-
dido por sus características, aunque no es un lenguaje sencillo, C++ fija reglas estrictas
de cómo escribir estas instrucciones.
Un programa es una serie de instrucciones que se ejecutan en secuencia (salvo que indi-
quemos expresamente condiciones precisas, en las que esta secuencia se altera).
Un programa interno comprueba que la sintaxis de nuestro programa es acorde a la

norma de C++, y si hay cualquier cosa que no le convence dará un error y finalizará la
comprobación obligándonos a revisar lo que hemos escrito.
Cuando el compilador acepta nuestro programa, invoca otro programa que traduce lo
que hemos escrito a instrucciones comprensibles para el procesador de nuestro Arduino.
A este nuevo programa se le llama compilado.
El programa que generamos en el sketch se convierte en lenguaje de máquina, que está

dentro de la memoria del programa del arduino en forma de ceros y unos, que es la única
forma que tiene el micro para seguir las instrucciones que le piden.
ANÁLISIS DE ESTRUCTURA DE PROGRAMA
Analizaremos el programa que realizamos la clase anterior desde el software. La estruc-

tura 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() //Primera Parte

{
código;
}
void loop() //Segunda Parte
{
código;
}

8
En donde setup() es la parte encargada de recoger la configuración y loop() es la que
contiene el programa que se ejecutará cíclicamente (de ahí el término loop –bucle-). Am-
bas funciones son necesarias para que el programa trabaje.
La función de configuración setup debe contener la declaración de las variables. Es la

primera función a ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para confi-
gurar o inicializar pinMode (modo de trabajo de las E/S), configuración de la comunica-
ción en serie y otras.
La función bucle loop que se encuentra a continuación, contiene el código que se eje-
cutara 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.
¿Un momento, que es una función y que es un bucle?
A estas alturas para nosotros una función es como una caja negra que no sabe-
mos lo que tiene dentro, simplemente sabemos que le damos unos parámetros de
entrada, con los cuales esta caja negra realiza alguna rutina, como podría ser
sumar, restar, realizar algún calculo, etc.
La palabra bucle, como se comenta en el mismo parrafo nos esta indicando algo
que se ejecuta una y otra vez de forma indefinida en este caso, pero que podría
poseer una condición que lo haga detenerse, como podría ser que el bucle se
ejecute hasta que una variable supere cierto valor.
¿Qué es una variable?
Un poco más adelante aclararemos este término, hasta aquí tomemoslo como
que es un nombre al cual le podemos asociar diferentes valores como números,
cadenas de texto, caracteres, etc.
Un momento, una pregunta más. ¿Qué representa la palabra void que se

encuentra antes de setup() y de loop()?
La palabra void está indicando que tanto setup como loop no retorna un valor,
es decir se ejecutan, realizan la rutina que tienen encargada pero no dan un
resultado de salida.

9
setup()
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. Así mismo se puede utilizar para
establecer el estado inicial de las salidas de la placa.
void setup()
{
pinMode(pin, OUTPUT); // configura el ‘pin’ como salida
}
loop()
Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su

nombre, se ejecuta de forma cíclica, lo que posibilita que el programa esté respondiendo
continuamente ante los eventos que se produzcan en la placa.
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el ‘pin’
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el ‘pin’
delay(1000);
}
NOTA: Podemos ver como dentro de loop() se ejecutan dos funciones, digitalWrite() y de-
lay(), algo interesante y que hay que tener presente con el uso de delay() es que arduino no
ejecuta ninguna rutina durante este tiempo muerto de 1segundo (mil milisegundos), esto en
principio parecería que no ser relevante, pero tiene una gran importancia ya que si estu-
vieramos controlando la temperatura de un horno, el estado de una maquina u otro tipo
de registro, no podríamos pasar a medir otro aparato o tomar otra medida hasta que este
tiempo termine de transcurrir.
Podriamos preguntar ¿A mí que me importa? en definitiva es solo 1 segundo!
Sin embargo pensemos en un caso en el cual tengamos que relevar 3000 componentes, con
un delay de 1segundo, ¿cuánto tardaríamos en pasar nuevamente por uno de ellos?
¿Sería relevante en este caso? ¿Se le ocurre algún caso en el cual si lo fuera?

10
VARIABLE
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. El
siguiente código de ejemplo declara una variable llamada variableEntrada y luego le asig-
na el valor obtenido en la entrada analógica del PIN2:
int variableEntrada = 0; // declara una variable y le asigna el

valor 0
variableEntrada = analogRead(2);// la variable recoge el valor
analógico del PIN2
variableEntrada //es la variable en sí.
La primera línea declara que será de tipo entero “int”. La segunda línea fija a la variable
el valor correspondiente a la entrada analógica PIN2. Esto hace que el valor de PIN2 sea
accesible en otras partes del código.
NOTA: La asignación se realiza mediante el símbolo de igual.
Una vez que una variable ha sido asignada, o re-asignada, se puede probar su valor para
ver si cumple ciertas condiciones (instrucciones if..), o se puede utilizar directamente su
valor.
Como ejemplo ilustrativo veamos tres operaciones útiles con variables: el siguiente códi-
go prueba si la variable “entradaVariable” es inferior a 100, si es cierto se asigna el valor
100 a entradaVariable” “y, a continuación, establece un retardo (delay) utilizando como
valor “entradaVariable” que ahora será como mínimo de valor 100:
if (entradaVariable < 100) // pregunta si la variable es menor de

100
{
entradaVariable = 100; // si es cierto asigna el valor 100 a
esta
}
delay(entradaVariable); // usa el valor como retardo

11
NOTA: Las variables deben tomar nombres descriptivos, para hacer el código más legible.
Nombres de variables pueden ser “contactoSensor” o “pulsador”, para ayudar al progra-
mador y a cualquier otra persona a leer el código y entender lo que representa la variable.
Una variable puede ser cualquier nombre o palabra que no sea una palabra reservada en el
entorno de Arduino.
NOTA: Se pueden usar guiones bajos o números en las variables, pero no se deben usar
como primer caracter.
NOTA: La estructura if(){} es lo que se llama una condición, nos extenderemos en su es-
tructura y uso más adelante por ahora es suficiente con que conozca su existencia.
TIPO DE DATOS EN ARDUINO
El siguente cuadro es un resumen de los tipos de datos que podemos encontrar en Ar-
duino, a continaución entraremos en detalle en cada uno de ellos.
TIPO Cantidad de Rango de valores

Bytes
void 0 Descriptor que indica que la función no retorna
valor
boolean 1 true o false
char 1 -127 a 128
unsigned char 1 0 a 255
byte 1 1 a 255
int 2 -32.768 a 32.767
unsigned int 2 0 a 65.535
word 2 1 a 65.535
short 2 -32.768 a 32.767
long 4 –2.147.483.648 a 2.147.483.647
unsigned long 4 0 a 4.294.967.295
float 4 –3.4028235E+38 to 3.4028235E+38
double 4 –3.4028235E+38 to 3.4028235E+39
array --- Secuencia de valores entre comillas separados por
comas
string - char --- Array de caracteres con un término final núlo
String - object --- Objeto de una clase de C++

12
void
La palabra reservada void se utiliza sólo en la declaración de funciones para indicar que
la función no retorna valor. Ya hemos visto su implementación, en setup() y loop().
void setup() //Primera Parte

{
código;
}
void loop() //Segunda Parte
{
código;
}
NOTA: La segunda columna de la tabla anterior, indica la cantidad de bytes que posee la
variable, pero ¿Qué es un byte?
Un byte es un indicador de la cantidad memoria utilizada, la información es almacenada

en ceros y unos, en donde cada elemento cero o uno es denominado bite. En la conven-
ción que vamos a ver, un byte podemos tomarlo como 8 bits. Dado que un bite posee
solo dos estados (cero o uno) se utiliza con ellos aritmética de base 2. Antes de seguír
con la definición de tipos de variables detengamonos un momento y aprendamos un
poco sobre números binarios.
NÚMEROS BINARIOS
Los números binarios se conforman con ceros y unos (0,1), en un circuito de lógica binaria
un cero significa voltaje cero, y un uno voltaje máximo donde podemos simbolizar como
apagado y prendido.
Los números son representados por potencia de dos (2), y veremos cómo se transforman
estos en decimales. Partamos por escribir las potencias de dos en una tabla:
2 e+7 2 e+6 2 e+5 2 e+4 2 e+3 2 e+2 2 e+1 2 e+0 VALOR

128 64 32 16 8 4 2 0
128 64 32 16 8 4 2 1
SUPONGAMOS QUE QUEREMOS CONVERTIR EL NÚMERO 220.
Colocaremos un 1 en el lugar de mayor valor que podamos sin pasarnos del valor pedido
en este caso 2^7 =128, seguimos poniendo un 1 en el lugar de mayor valor siempre que no

13
supere su suma 128+64=192, si colocamos un 1 en la columna de 2^5 =32 nos pasaremos
del valor pedido 128+64+32=224, por lo tanto colocaremos un cero, tomamos el siguiente
valor 16, su suma no alcanza el valor, su suma 128+64+16=208 por lo tanto colocamos un 1,
sumaremos la siguiente columna 8 tendremos 128+64+16+8=216 no superamos el numero
colocamos un 1, el próximo es 4 sumándolo tendremos 128+64+16+8+4=220 ya obtuvimos
el valor no necesitamos sumar ningún valor, colocaremos un cero en la potencias siguientes.
2 e+7 2 e+6 2 e+5 2 e+4 2 e+3 2 e+2 2 e+1 2 e+0 VALOR

128 64 32 16 8 4 2 0
1 1 0 1 1 1 0 0 220
A continuación podemos ver cuatro ejemplos:
2 e+7 2 e+6 2 e+5 2 e+4 2 e+3 2 e+2 2 e+1 2 e+0 VALOR

128 64 32 16 8 4 2 0
1 0 0 1 0 1 1 0 150
0 1 1 1 0 0 0 1 113
1 0 1 1 0 1 1 1 183
0 0 1 0 0 1 0 1 37
Primer fila 128+16+4+2=150

Segunda fila 64+32+16+1=113
Tercera fila 128+32+16+4+2+1=183
Cuarta fila 32+4+1=37
Otra manera de obtener el binario es el siguiente, dividimos por dos el número y colocamos
el resto (que puede ser cero o uno) a la derecha se repite la operación hasta que quede el
ultimo resto que puede ser uno o cero.
220 0
110 0
55 1
27 1 El número binario se lee de abajo hacia arriba
13 1 11011100
6 0
3 1
1 1
NOTA: En internet podremos encontrar varios programa que convierten valores binarios a
decimales, o decimales a binarios.

14
Veremos ahora como basado en la numeración binaria transformaremos estos para hacer
una conversión hexadecimal. Partamos de la siguiente tabla en donde tenemos una equiva-
lencia entre los números hexadecimales básicos y sus correspondientes números.
binario hexadecimal
0 0
1 1
10 2
11 3
100 4
101 5
110 6
111 7
1000 8
1001 9
1010 A
1011 B
1100 C
1101 D
1110 E
1111 F
Para formar el número hexadecimal a partir de un número binario, agruparemos el binario

de a cuatro, veamos aprovechando los valores anteriores como quedaría su representación en
hexadecimal:
02aaa4 Binario Hexadecimal

150 10010110 96 H
113 01110001 71 H
183 10110111 B7 H
37 00100101 25 H
TAREA
Convertir los siguientes números a binario y hexadecimal

324, 1028, 667, 8547

15
Ahora que tenemos una idea de como trabajar con número binarios sigamos viendo los
distintos tipos de variables dentro de Arduino.
boolean
Los número booleanos son true (verdadero) o false (falso) y ocupan un byte de memoria.
Cuando nos referimos al estado de las salidas digitales podemos definir los niveles HIGH
(alto) y LOW (bajo). 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 también se definen como TRUE. (Esto es importante tenerlo en
cuanta)
Veamos un ejemplo de su uso:
if (b == TRUE);{
ejecutar las instrucciones;
}
NOTA: El doble igual en lugar de asignar un valor lo utilizamos para comparar. Lo que
estamos haciendo es consultando si el valor de la varialbe b es igual a TRUE.
NOTA: Las constantes HIGH/LOW 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.
digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)
char
Son un tipo de datos que ocupan 1 byte de memoria y almacenan un caracter. Los carac-
teres literales se deben escribir entre comillas simples ‘A’ para el uso de multiples carac-
ters se utilizan doble comillas “ABC”. Los caracteres son guardados como números de
acuerdo a la tabla ASCII de caracteres.
Detengamosnos nuevamente y veamos como aprender a pertir de la plataforma de Ar-

duino. La plataforma trae muchos ejemplos los cuales se pueden encontrar en el margen
superior izquierdo en: Archivo > Ejemplos.
Vamos a continuación a ejecutar uno de ellos e introducirnos en el conocimiento del

monitor que Arduino trae incorporado.

16
USO DEL MONITOR
Veamos mediante un ejercicio, una función del sketch llamada Monitor que nos permite co-
municarnos con el arduino al cual se le podrán enviar y recibir datos, estos datos se envían
en serie y a una velocidad definida en baudios por segundo.
ABRIMOS EL MONITOR
Como primer paso conectamos el arduino si ya no lo tenemos conectado y vamos a “Herra-

mientas > Puerto > COMx (Arduino Leonardo)”, en donde seleccionamos el puerto USB de
forma que presente el tilde de selección que se muestra en la siguiente figura:
Luego vamos a “Herramientas > Monitor Serie” y damos click.

17
Esto nos abre el monitor según se ve a continuación:
Aparecerá en muestra pantalla la imagen de la consola donde en el extremo inferior dere-

cho tendremos la velocidad de la trasmisión 9600 baudios y Ambos NL & CR eso significa
en castellano retorno de carro y nueva línea que la consola aplicara automáticamente en la
trasmisión en el renglón.
Si ahora Cargamos el Ejemplo: Archivo > Ejemplos > 0.4.Comunication > ASCIITable
Y lo ejecutamos presionando el botón con la flecha que apunta hacia la derecha.

18
El código es compilado (asumimos que no tiene errores ya que cargamos un programa ya
testeado por la gente de arduino, de otra forma deberiamos haber chequedo si hay errores
presionando el botón con el tilde que se encuentra a la izquierda del anterior) y enviado al
arduino, el resultado se presenta dentro del monitor.
En esta tabla podemos ver la representación de los cararacteres ASCII en decimales, hexade-
cimales, octales y binarios.
La forma de referirnos a tipo de dato char es anteponiendo este nombre reservado al

nombre de la variable, en el ejemplo siguiente que es el que se obtiene de la referencia
oficial, como el valor del ASCII ‘A’ es 65, al sumarle a ‘A’ el valor de 1 da 66.
void setup() {
char caracter1 = ‘A’;
Serial.begin(9600);
while (!Serial) {; }
Serial.println(caracter1);
Serial.println(caracter1+1);
}
void loop() {
}
NOTA : Para ver el resultado debemos trabajar con el monitor.

19
NOTA: Observar el uso de char para definir el tipo de dato caracter y eluso de comillas
simples en lugar de comillas dobles.
NOTA: Estamos utilizando la función println() para imprimir los datos en el minitor, dado
que por ahora no hemos hablado de funciones, tomemos como que con la escritura anterior
podemos imprimir datos en el monitor y aguardemos al análisis de funciones para com-
prender la notación.
unsigned char
Un tipo de dato del tipo unisgne char ocupa 1 byte de memoria, es igual al uso de de tipo
de datos byte, sin embargo por consistencia con el estilo de programación de Arduino es
preferible el uso de byte. El tipo de datos unsigned char codifica los números de 0 a 255.
unsigned char myChar = 240;
byte
El tipo de datos byte ocupa 1 byte de memoria, codificando los números desde 0 a 255.
byte b = B10010;
int
En el Arduino Uno (y otras placas basadas ATMega) un int almacena un valor de 16 bits
(2 bytes). Esto produce una gama de -32 768 a 32.767 (valor mínimo de -2 ^ 15 y un
valor máximo de (2 ^ 15) - 1).
NOTA: En notación exponencial, cuando vemos un número elevado a un exponente se sue-

le poner por ejemplo 2 E3 o sea dos elevado a la tres que daría 8, cuando leemos la referen-
cia de Arduino lo escriben como 2 ^ 3 ya que utilizan el símbolo circunflejo que es utilizado
para programar. En definitiva es lo mismo por lo que no debe conducir a confución.
int b = 34;
NOTA: Para obtener números negativos se utiliza la tecnica de complemento a dos

20
COMPLEMENTO A 1
El complementoa 1 se define como: C1 =(2 ^d) - N -1, en donde d es el número de digitos y

N el número al cual le queremos encontrar el complemento.
Por ejemplo, para encontrar el complemetno a 1 del número 4 en 8 bit debemos hacer:
(2 ^8) - 4 -1 = 256 -4 -1 = 251
Es decir que el número 4 que en binario es 00000100 tiene un complemento a uno que es
igual a 11111011.
Notar que el complemento a uno es igual a cambiar los ceros por uno y los unos por cero.
COMPLEMENTO A 2
El complemento a 2 posee una formula similar al complemento a 1 y es C2 =(2 ^d) - N,

notemos que lo podemos expresar a partir del complemento a uno si utilizamos el siguiente
truco:
C2 =(2 ^d) - N = (2 ^d) - N -1 +1 = C1 +1
De esta forma el complemento a dos del número 4 con 8 bits es igual a:
11111011
+ 1
11111100
Este complemento a dos de cuatro representa el número -4.
unsigned int
Un tipo de dato del tipo unisgne int ocupa 2 byte de memoria, es igual al uso de de tipo
de datos int, pero en este caso solo se consideran números positivos en el rango de 0 a
65.535.
unsigned int ledPin = 13;

21
word
Es similar al tipo de datos del tipo unsigned int en cuanto al espacio que ocupa y al rango
, se suele preferir al manipular numeros hexadecimales en lugar de decimales o cuando
trabajamos con bits.
word w = 10000;
long
El formato de variable numérica de tipo extendido “long” se refiere a números ente-

ros que ocupan 4 bytes de memoria, sin decimales que se encuentran dentro del rango
-2.147.483.648 a 2.147.483.647.
long unaVariable = 90000; // declara ‘unaVariable’ como tipo long
unsigned long
Un tipo de dato del tipo unisgne long ocupa 4 byte de memoria, es igual al uso de de tipo
de datos long, pero en este caso solo se consideran números positivos en el rango de 0 a
4.294.967.295 .
short
Un short es un tipo de datos de 16-bit. En todos los Arduinos (ATMega y basados en

ARM) un short almacena un valor de 16-bit (2-byte). Esto produce un rango de -32,768
to 32,767 (valor mínimo de -2^15 y un valor máximo de (2^15) - 1).
NOTA: short es igual a int, es preferible usarlo para especificar los 2 byte de almacena-
miento ya que en otros lenguajes int puede representar 4 bytes de almacenamiento y si no
tenemos en consideración esto puede llevarnos errores.
short ledPin = 13;

22
float y double
El formato de dato del tipo “punto flotante” “float” se aplica a los números con decimales.
Los números de punto flotante ocupan 4 bytes y ocupan un rango de mayor resolución
qu va de –3.4028235E+38 to 3.4028235E+38
NOTA: En arduino la presición es de solamente 6 o 7 digitos despues de la coma.
NOTA: Los números de punto flotante pueden dar resultados extraños, como ser que 6/3
sea diferente de 2.
NOTA: Los calculos con números de punto flotante son más lentos que los calculos que
utilizan int.
NOTA: En arduino float y double son exactamente iguales, sin existir una ganancia o
perdida de presición.
float variable = 13,345;
array
Un 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...}
Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamaño y
posteriormente, asignar valores a una posición especifica:
int miArray[5]; // declara un array de enteros de 6 posiciones

miArray[3] = 10; // asigna l valor 10 a la posición 4

23
Para leer de un array basta con escribir el nombre y la posición a leer:
x = miArray[3]; // x ahora es igual a 10 que está en la

posición 3 del array
Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que la variable de
incremento del contador del bucle se utiliza como índice o puntero del array. El siguien-
te ejemplo usa una matriz para el parpadeo de un LED. Utilizando un bucle tipo for, el
contador comienza en cero 0 y escribe el valor que figura en la posición de índice 0 en
la serie que hemos escrito dentro del array parpadeo[], en este caso 180, que se envía a
la salida analógica tipo PWM configurada en el PIN10, se hace una pausa de 200 ms y a
continuación se pasa al siguiente valor que asigna el índice “i”.
int ledPin = 10; // Salida LED en el PIN 10
byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array
de 8 valores diferentes.
void setup()
{
//configura la salida PIN 10
pinMode(ledPin, OUTPUT);
}
// bucle del programa
void loop(){
// crea un bucle tipo for utilizando la variable i de 0 a 7
for(int i=0; i<8; i++){
// escribe en la salida PIN 10 el valor al
//que apunta i dentro del array parpadeo[]
analogWrite(ledPin, parpadeo[i]);
delay(200); // espera 200ms
}

24
string
Los strings pueden ser representados de dos formas diferentes, la primera que vamos a
ver es como un array de caracteres.
Para definir un string de esta forma podemos hacerlo de la siguiente forma:
char miString[7];
Esto equivale a un string de seis carecteres, ya que el número 7 es un carecter nulo '\0'
que se ubica al final del array de caracteres para realizar la compilación que indica donde
se encuentra el final del string.
NOTA: El string de caracteres por lo tanto debe poseer un espacio más que la cantidad de
elementos del string.
NOTA: En este caso cada caracter debe indicarse entre comillas simples.
Si no especificamos el número de elementos del array, estamos dejando que el compi-

lador de Arduino decida el espacio de memoria y la cantidad de caracteres que debe
asignar.
char miString[] = "Hola";
NOTA: En este caso un string se define entre comillas dobles.
Algunos ejemplos de definición de strings, podrian ser los siguientes.
char miString1[] = "Hola";
char miString2[] = "Primer línea"

"segunda línea";
char miString3[] = {'H', 'o', 'l', 'a'}
char miString4[5] = {'H', 'o', 'l', 'a'}

25
String
El tipo de datos 'String', es en realidad una clase de C++ que es construida a partir del
tipo de datos 'string', pero que es tratado como como un objeto (estos son conceptos de
la Programación Orientada a Objetos, en los cuales no vamos a entrar en detalles)
Por tanto dado un string podemos alterarlo utilizando 'metodos', para no complicar
aquí el estudio, tomemos los métodos como palabras que colocamos a continuación del
nombre del array concatenandolo con un punto para alterar el string original. Veamos
un ejemplo en donde definimos un string y luego transformamos todos sus componentes
a mayúscula.
String miString = "Hola";

miString.ToUpperCase();
NOTA: El trabajar con 'String' es muy fácil y útil, sin embargo tiene un costo de almacena-
miento en memoria mayor al 40% que utilizando 'string'.
Otros ejemplos
String miString1 = "Hola"; // Constante

String miString2 = String('a'); //convertir un caracter a String
String miString3 = String("Hola") // convertimos un string a
String
String miString4 = String(miString1 + " Juan"); // concatena-
mos dos Strings
String miString5 = String(13); // Usamos una constante de tipo
integer
String miString6 = String(analogRead(0), DEC); // usamos un int
y la base
String miString7 = String(45, HEX);
String miString8 = String(255, BIN);
String miString9 = String(5.698, 3); // usamos
un flotante indicando los lugares luego de la coma.
Podemos encontrar una referencia completa en:
http://www.arduino.cc/en/Reference/StringObject

26
27
Operadores y con-
02
SECCIÓN
trol de flujo
Lógicos
Aritméticos
De comparación
Booleanos
OPERADORES ARITMÉTICOS
Los operadores aritméticos que se incluyen en el entorno de programación son suma,

resta, multiplicación y división. Estos devuelven la suma, diferencia, producto, o cociente
(respectivamente) de dos operandos.
y = y + 3;
x = x - 7;
i = j * 6;
r = r / 5;
La operaciones se efectúa teniendo en cuanta el tipo de datos que hemos definido para
los operandos (int, dbl, float, etc..), por lo que, por ejemplo, si definimos 9 y 4 como
enteros “int”, 9 / 4 devuelve de resultado 2 en lugar de 2,25 ya que el 9 y 4 se valores de
tipo entero “int” (enteros) y no se reconocen los decimales con este tipo de datos. Esto
también significa que la operación puede sufrir un desbordamiento si el resultado es más
grande que lo que puede ser almacenada en el tipo de datos. Recordemos el alcance de
los tipos de datos numéricos que ya hemos explicado anteriormente. Si los operandos
son de diferentes tipos, para el cálculo se utilizará el tipo más grande de los operandos
en juego. Por ejemplo, si uno de los números (operandos) es del tipo float y otra de tipo
integer, para el cálculo se utilizará el método de float es decir el método de coma flotante.
Elija el tamaño de las variables de tal manera que sea lo suficientemente grande como
para que los resultados sean lo precisos que usted desea. Para las operaciones que requie-
ran decimales utilice variables tipo float, pero sea consciente de que las operaciones con
este tipo de variables son más lentas a la hora de realizarse el computo..
Nota: Utilice el operador (int) myFloat para convertir un tipo de variable a otro sobre
la marcha. Por ejemplo, i = (int) 3,6 establecerá i igual a 3.
ASIGNACIÓN COMPUESTA
Las asignaciones compuestas combinan una operación aritmética con una variable asig-
nada. Estas son comúnmente utilizadas en los bucles tal como se describe más adelante.
Estas asignaciones compuestas pueden ser:
x ++ // igual que x = x + 1, o incrementar x en + 1

x -- // igual que x = x - 1, o decrementar x en -1
x += y // igual que x = x + y, o incrementra x en +y
x -= y // igual que x = x - y, o decrementar x en -y
x *= y // igual que x = x * y, o multiplicar x por y
x /= y // igual que x = x / y, o dividir x por y

30
Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo valor x y por lo
tanto x es reasignada al nuevo valor .
OPERADORES DE COMPARACIÓN
Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las
estructuras condicionales del tipo if.. para testear si una condición es verdadera. En los
ejemplos que siguen en las próximas páginas se verá su utilización práctica usando los
siguientes tipo de condicionales:
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y
OPERADORES LÓGICOS
Los operadores lógicos son usualmente una forma de comparar dos expresiones y devol-
ver un VERDADERO o FALSO dependiendo del operador. Existen tres operadores lógi-
cos, AND (&&), OR (||) y NOT (!), que a menudo se utilizan en estamentos de tipo if..:
Logical AND:
if (x > 0 && x < 5) // cierto sólo si las dos expresiones son
ciertas
Logical OR:
if (x > 0 || y > 0) // cierto si una cualquiera de las expresio-
nes
es cierta
Logical NOT:
if (!x > 0) // cierto solo si la expresión es falsa

31
CONTROL DE FLUJO
if
if es un estamento que se utiliza para probar si una determinada condición se ha alcan-

zado, como por ejemplo averiguar si un valor analógico está por encima de un cierto
número, y ejecutar una serie de declaraciones (operaciones) que se escriben dentro de
llaves, si es verdad. Si es falso (la condición no se cumple) el programa salta y no ejecuta
las operaciones que están dentro de las llaves, El formato para if es el siguiente:
if (unaVariable ?? valor){
ejecutaInstrucciones;
}
En el ejemplo anterior se compara una variable con un valor, el cual puede ser una varia-
ble o constante. Si la comparación, o la condición entre paréntesis se cumple (es cierta),
las declaraciones dentro de los corchetes se ejecutan. Si no es así, el programa salta sobre
ellas y sigue.
Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x = 10), podría
parecer que es válido pero sin embargo no lo es ya que esa expresión asigna el valor 10 a
la variable x, por eso dentro de la estructura if se utilizaría X==10 que en este caso lo que
hace el programa es comprobar si el valor de x es 10.. Ambas cosas son distintas por lo tanto
dentro de las estructuras if, cuando se pregunte por un valor se debe poner el signo doble de
igual “==”
If…else
if… else viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cum-
ple haz esto otro”. Por ejemplo, si se desea probar una entrada digital, y hacer una cosa
si la entrada fue alto o hacer otra cosa si la entrada es baja, usted escribiría que de esta
manera:
// si el valor de la entrada inputPin es alto

if (inputPin == HIGH) {
instruccionesA; //ejecuta si se cumple la condición
}else{
instruccionesB; //ejecuta si no se cumple la condición
}

32
else puede ir precedido de otra condición de manera que se pueden establecer varias
estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que
sean mutuamente excluyentes pudiéndose ejecutar a la vez. Es incluso posible tener un
número ilimitado de estos condicionales. Recuerde sin embargo qué sólo un conjunto de
declaraciones se llevará a cabo dependiendo de la condición probada:
if (inputPin < 500){

instruccionesA; // ejecuta las operaciones A
}else if (inputPin >= 1000){
instruccionesB; // ejecuta las operacione B
}else{
instruccionesC; // ejecuta las operaciones C
}
Nota: Un estamento de tipo if prueba simplemente si la condición dentro del paréntesis es

verdadera o falsa. Esta declaración puede ser cualquier declaración válida. En el anterior
ejemplo, si cambiamos y ponemos (inputPin == HIGH). En este caso, el estamento if sólo
chequearía si la entrada especificado esta en nivel alto (HIGH), o +5v.
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){

ejecutaInstrucciones;
}
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 condi-
ción no se cumple, el bucle termina.

33
El siguiente ejemplo inicia el entero i en el 0, y la condición es probar que el valor es in-
ferior a 20 y si es cierto i se incrementa en 1 y se vuelven a ejecutar las instrucciones que
hay dentro de las llaves:
// declara i, prueba que es menor que 20, incrementa i en 1

for (int i=0; i<20; i++){
digitalWrite(13, HIGH); // envía un 1 al pin 13
delay(250); // espera ¼ seg.
digitalWrite(13, LOW); // envía un 0 al pin 13
delay(250); // espera ¼ de seg.
}
Nota: El bucle en el lenguaje C es mucho más flexible que otros bucles encontrados en
algunos otros lenguajes de programación, incluyendo BASIC. Cualquiera de los tres
elementos de cabecera puede omitirse, aunque el punto y coma es obligatorio. También
las declaraciones de inicialización, condición y expresión puede ser cualquier estamento
válido en lenguaje C sin relación con las variables declaradas. Estos tipos de estados son
raros pero permiten disponer soluciones a algunos problemas de programación raras.
while
Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expre-
sión colocada entre paréntesis en la cabecera del bucle. La variable de prueba tendrá que
cambiar para salir del bucle. La situación podrá cambiar a expensas de una expresión
dentro el código del bucle o también por el cambio de un valor en una entrada de un
sensor
while(unaVariable ?? valor){
Ejecutar sentencias;
}
El siguiente ejemplo testea si la variable "unaVariable” es inferior a 200 y, si es verdad,

ejecuta las declaraciones dentro de los corchetes y continuará ejecutando el bucle hasta
que 'unaVariable' no sea inferior a 200.
// testea si es menor que 200

while (unaVariable < 200){
instrucciones; // ejecuta las instrucciones entre llaves
unaVariable++; // incrementa la variable en 1
}

34
do….. while
El bucle do while funciona de la misma manera que el bucle while, con la salvedad de
que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al
menos una vez.
do{
Instrucciones;
}while(unaVariable ?? valor);
El siguiente ejemplo asigna el valor leído leeSensor() a la variable 'x', espera 50 milise-
gundos, y luego continua mientras que el valor de la 'x' sea inferior a 100:
do{
x = leeSensor();
delay(50);
} while (x < 100);

35
Funciones
03
SECCIÓN
03
SECCIÓN FUNCIONES
FUNCIONES
Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones

que son ejecutadas 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 devuelve 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 “fun-
ció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.
type nombreFunción(parámetros)
{
instrucción;
}
La función siguiente devuelve un número entero, delayVal() se utiliza para poner un

valor de retraso en un programa que lee una variable analógica de un potenciómetro (Un
potenciómetro es un resistor cuyo valor de resistencia es variable.) conectado a una en-
trada de Arduino. Al principio se declara como una variable local, 'v' recoge el valor leído
del potenciómetro que estará comprendido entre 0 y 1023, luego se divide el valor por 4
para ajustarlo a un margen comprendido entre 0 y 255, finalmente se devuelve el valor 'v'
y se retornaría al programa principal. Esta función cuando se ejecuta devuelve el valor de
tipo entero 'v'.
int delayVal(){
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potenciómetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}

38
laves {}
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utili-
zan para los bloques de programación setup(), loop(), if.., etc.
type funcion()
{
instrucciones;
}
Una llave de apertura “{“ siempre debe poseer una llave de cierre “}”, si no es así el pro-
grama 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”.
int x = 13; /* declara la variable 'x' como tipo entero de valor 13 */
A continuación modificaremos el ejemplo dejado como tarea en la unidad anterior:
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
digitalWrite(12, LOW);
delay(1000);
delay(1000); }

39
para darle una estructura diferente ya comenzaremos a pensar los programa como la
construcción de bloques llamados funciones que ejecutan un determinada rutina.
¿Qué ventaja tenemos al estructurar de esta forma los programas?
Los bloques pueden ser llamados desde cualquier parte del programa.
Para modificar un programa no necesitamos cambiar toda su estructura pode-

mos modificar un módulo.
Agregar líneas de comando dentro del módulo.
Podemos agregar módulos que nos indique el comportamiento del sistema que
luego los eliminaremos
Si un programa no cumple con nuestros objetivos podremos determinar con más facili-
dad donde y que rutina modificar, en un programa escrito en forma continua se compli-
ca, y si escribiéramos la misma rutina cientos de veces en un programa, la probabilidades
de error se multiplican.
Veamos el ejemplo.
void setup() {
}
void loop() {
primer_semaforo();
delay(1000);
segundo_semaforo();
delay(1000);
}
void primer_semaforo(){
return();
/*delay(1000); */
}
void segundo_semaforo(){
return();
/* delay(1000); */
}

40
FUNCIONES PROPIAS
Entradas/Salidas digitales.
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).
pinMode(pin, OUTPUT); // configura ‘pin’ como salida
Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto
no es necesario definirlos en el caso de que vayan a trabajar como entradas. Los pines
configurados como entrada quedan, bajo el punto de vista eléctrico, como entradas en
estado de alta impedancia. Estos pines tienen a nivel interno una resistencia de 20 K a
las que se puede acceder mediante software. Estas resistencias se acceden de la siguiente
manera:
pinMode(pin, INPUT); // configura el ‘pin’ como entrada

digitalWrite(pin, HIGH); // activa las resistencias internas
Las resistencias internas normalmente se utilizan para conectar las entradas a interrup-
tores. En el ejemplo anterior no se trata de convertir un pin en salida, es simplemente un
método para activar las resistencias interiores.
Los pins configurado como OUTPUT (salida) se dice que están en un estado de baja
impedancia estado 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 ohm.

41
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).
pinMode(pin, OUTPUT); // configura ‘pin’ como salida
digitalWrite(pin,value)
Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo
en 1 o 0 la salida). El pin se puede especificar ya sea como una variable o como una cons-
tante (0-13).
digitalWrite(pin, HIGH); // deposita en el 'pin' un valor HIGH

(alto o 1)
El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo

escribe en el ´pin´de salida LED:
int led = 13; // asigna a LED el valor 13

int boton = 7; // asigna a botón el valor 7
int valor = 0; // define el valor y le asigna el valor 0
void setup(){
pinMode(led, OUTPUT);// configura el led (pin13) como salida
pinMode(boton, INPUT); // configura botón (pin7) como entrada
}
void loop(){
valor = digitalRead(boton);//lee el estado de la entrada botón
digitalWrite(led, valor); // envía a la salida ´led´el valor
leído
}

42
Entrada/Salidas. Analógicas.
analogRead(pin)
Lee el valor de un determinado pin definido como entrada analógica con una resolución
de 10 bits. Esta instrucción sólo funciona en los pines (0-5). El rango de valor que pode-
mos leer oscila de 0 a 1023.
valor = analogRead(pin); // asigna a valor lo que lee en la en-

trada ´pin'
Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser declara-
dos como INPUT u OUPUT ya que son siempre INPUT´s.
analogWrite(pin, valor)
Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedi-

miento de modulación por ancho de pulso (PWM) a uno de los pin´s de Arduino mar-
cados como “pin PWM”. El más reciente Arduino, que implementa el chip ATmega168,
permite habilitar como salidas analógicas tipo PWM los pines 3, 5, 6, 9, 10 y 11. Los mo-
delos de Arduino más antiguos que implementan el chip ATmega8, solo tiene habilitadas
para esta función los pines 9, 10 y 11. El valor que se puede enviar a estos pines de salida
analógica puede darse en forma de variable o constante, pero siempre con un margen de
0-255.
analogWrite(pin, valor); // escribe 'valor' en el 'pin' defi-

nido como analogico
Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de

255 genera una salida de 5 voltios de salida en el pin especificado. Para valores de entre
0 y 255, el pin saca tensiones entre 0 y 5 voltios - el valor HIGH de salida equivale a 5v
(5 voltios). Teniendo en cuenta el concepto de señal PWM , por ejemplo, un valor de
64 equivaldrá a mantener 0 voltios de tres cuartas partes del tiempo y 5 voltios a una
cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida en 0 la mitad
del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192 equivaldrá a mantener
en la salida 0 voltios una cuarta parte del tiempo y de 5 voltios de tres cuartas partes del
tiempo restante.
Debido a que esta es una función de hardware, en el pin de salida analógica (PWN) se
generará una onda constante después de ejecutada la instrucción analogWrite hasta que
se llegue a ejecutar otra instrucción analogWrite (o una llamada a digitalRead o digi-
talWrite en el mismo pin).

43
NOTA: Las salidas analógicas a diferencia de las digitales, no necesitan ser declaradas
como INPUT u OUTPUT.
El siguiente ejemplo lee un valor analógico de un pin de entrada analógica, convierte el

valor dividiéndolo por 4, y envía el nuevo valor convertido a una salida del tipo PWM o
salida analógica:
int led = 10; // define el pin 10 como ´led´

int analog = 0; // define el pin 0 como ´analog´
int valor; // define la variable ´valor´
void setup(){} // no es necesario configurar entradas y salidas
void loop(){
valor = analogRead(analog); // lee el pin 0 y lo asocia a la
variable valor
valor /= 4; // divide valor entre 4 y lo reasigna a valor
analogWrite(led, value); // escribe en el pin10 valor
}
Tiempos.
delay(ms)
Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia

instrucción. De tal manera que 1000 equivale a 1seg.
delay(1000); // espera 1 segundo
millis()
Devuelve el número de milisegundos transcurrido desde el inicio del programa en

Arduino hasta el momento actual. Normalmente será un valor grande (dependiendo del
tiempo que este en marcha la aplicación después de cargada o después de la última vez
que se pulsó el botón “reset” de la tarjeta).
valor = millis(); // valor recoge el número de milisegundos
Nota: Este número se desbordará (si no se resetea de nuevo a cero), después de aproximada-
mente 9 horas.

44
Matemáticas.
min(x,y)
Calcula el mínimo de dos números para cualquier tipo de datos devolviendo el número
más pequeño.
valor = min(valor, 100); // asigna a valor el más pequeños de

los dos números especificados.
Si 'valor' es menor que 100 valor recogerá su propio valor si ´valor´ es mayor que 100
valor pasara a valer 100.
max(x,y)
Calcula el máximo de dos números para cualquier tipo de datos devolviendo el número
mayor de los dos.
valor = max(valor, 100); // asigna a valor el mayor de los dos

números 'valor' y 100
De esta manera nos aseguramos de que valor será como mínimo 100.
Aleatoreo.
randomSeed(seed)
Establece un valor, o semilla, como punto de partida para la función random().
randomSeed(valor); // hace que valor sea la semilla del random
Debido a que Arduino es incapaz de crear un verdadero número aleatorio, randomSeed

le permite colocar una variable, constante, u otra función de control dentro de la función
random, lo que permite generar números aleatorios "al azar". Hay una variedad de semi-
llas, o funciones, que pueden ser utilizados en esta función, incluido millis () o incluso
analogRead () que permite leer ruido eléctrico a través de un pin analógico.

45
Randon(max), random(max.max)
La función random devuelve un número aleatorio entero de un intervalo de valores espe-

cificado entre los valores min y max.
valor = random(100, 200); // asigna a la variable 'valor' un nu-

mero aleatorio comprendido entre 100-200
NOTA: Use esta función después de usar el randomSeed().
El siguiente ejemplo genera un valor aleatorio entre 0-255 y lo envía a una salida analógi-
ca PWM :
int randNumber; // variable que almacena el valor aleatorio

int led = 10; // define led como 10
void setup(){} // no es necesario configurar nada
void loop(){
randomSeed(millis()); // genera una semilla para aleatorio
a partir de la función millis()
randNumber = random(255); // genera número aleatorio entre
0-255
analogWrite(led, randNumber); // envía a la salida led de
tipo PWM el valor
delay(500); // espera 0,5 seg.
}
PUERTO SERIE
serial.begin(rate)
Abre el puerto serie y fija la velocidad en baudios para la transmisión de datos en serie.
El valor típico de velocidad para comunicarse con el ordenador es 9600, aunque otras
velocidades pueden ser soportadas.
void setup(){
// abre el Puerto serie configurando la velocidad en 9600 bps
Serial.begin(rate9600);
}
NOTA: Cuando se utiliza la comunicación serie los pins digital 0 (RX) y 1 (TX) no puede

46
utilizarse al mismo tiempo.
Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro automático y salto
de línea. Este comando toma la misma forma que Serial.print (), pero es más fácil para la
lectura de los datos en el Monitor Serie del software.
Serial.println(analogValue); // envía el valor 'analogValue'

al puerto
NOTA: Para obtener más información sobre las distintas posibilidades de Serial.println ()y
Serial.print () puede consultarse el sitio web de Arduino.
El siguiente ejemplo toma de una lectura analógica pin0 y envía estos datos al ordenador
cada 1 segundo.
void setup(){
Serial.begin(9600); // configura el puerto serie a 9600bps
}
void loop(){
Serial.println(analogRead(0)); // envía valor analógico
delay(1000); // espera 1 segundo
}
Serial.printnl(data,data type)
Vuelca o envía un número o una cadena de carateres al puerto serie, seguido de un carac-
ter de retorno de carro "CR" (ASCII 13, or '\r') y un caracter de salto de línea "LF"(ASCII
10, or '\n'). Toma la misma forma que el comando Serial.print()
Serial.println(b) vuelca o envía el valor de b como un número decimal en caracteres

ASCII seguido de "CR" y "LF".
Serial.println(b, DEC) vuelca o envía el valor de b como un número decimal en

caracteres ASCII seguido de "CR" y "LF".
Serial.println(b, HEX) vuelca o envía el valor de b como un número hexdecimal en

caracteres ASCII seguido de "CR" y "LF".
Serial.println(b, OCT) vuelca o envía el valor de b como un número Octal en carac-

47
teres ASCII seguido de "CR" y "LF".
Serial.println(b, BIN) vuelca o envía el valor de b como un número binario en ca-

racteres ASCII seguido de "CR" y "LF".
Serial.print(b, BYTE) vuelca o envía el valor de b como un byteseguido de "CR" y

"LF".
Serial.println(str) vuelca o envía la cadena de caracteres como una cadena ASCII

seguido de "CR" y "LF".
Serial.println() sólo vuelca o envía "CR" y "LF". Equivaldría a printNewline().
Serial.available()
int Serial.available()
Obtiene un número entero con el número de bytes (caracteres) diponibles para leer o
capturar desde el puerto serie. Equivaldría a la función serialAvailable().
Devuelve un entero con el número de bytes disponibles para leer desde el buffer serie, o
0 si no hay ninguno. Si hay algún dato disponible, SerialAvailable() será mayor que 0.
El buffer serie puede almacenar como máximo 64 bytes.
Ejemplo
int incomingByte = 0; // almacena el dato serie
void setup() {
// abre el puerto serie, y le asigna la velocidad de 9600 Bps
Serial.begin(9600);
}
void loop() {
// envía datos sólo si los recibe:
if (Serial.available() > 0) {
// lee el byte de entrada:
incomingByte = Serial.read();
//lo vuelca a pantalla
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
}
}

48
Serial.Read()
int Serial.Read()
Lee o captura un byte (un caracter) desde el puerto serie. Equivaldría a la función serial-
Read().
Devuelve : El siguiente byte (carácter) desde el puerto serie, o -1 si no hay ninguno.
Ejemplo
int incomingByte = 0; // almacenar el dato serie

void setup(){
// abre el puerto serie,y le asigna la velocidad de 9600 bps
Serial.begin(9600);
}
void loop(){
// envía datos sólo si los recibe:
if (Serial.available() > 0) {
// lee el byte de entrada:
incomingByte = Serial.read();
//lo vuelca a pantalla
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
}

49
MÁS SOBRE VARIABLES
Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para de-
clarar 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 cual-
quier momento usando aritmética y reasignaciones diversas. El siguiente ejemplo declara
la variable entradaVariable como una variable de tipo entero “int”, y asignándole un valor
inicial igual a cero. Esto se llama una asignación.
int entradaVariable = 0;

Presentar el concepto de ámbito de una variable.
Una variable puede ser declarada en una serie de lugares del programa y en función del
lugar en donde se lleve a cabo la definición esto determinará en que partes del programa
se podrá hacer uso de ella.
Una variable puede ser declarada al inicio del programa antes de la parte de configura-
ción setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como
para los bucles del tipo if.. for.., etc. 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
Mostrar porque es necesario un ámbito de variable
Cuando trabajamos con variable, es necesario saber cual es su ámbito de uso, es decir
desde que zonas del programa son reconocidas, esto nos lleva a la definición de dos tipo
de variables, las del tipo global y las del tipo local.
Variables globales.
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().
Variables locales.
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.

50
Ejemplo de variables locales y globales.
El siguiente ejemplo muestra cómo declarar a unos tipos diferentes de variables y la visi-
bilidad de cada variable:
int value; // 'value' es visible para cualquier función

void setup()
{
// no es necesario configurar
}
void loop(){
for (int i=0; i<20;) { // 'i' solo es visible
// dentro del bucle for
i++;
}
float f; // 'f' es visible solo dentro del bucle
}
VARIABLES ESTÁTICAS: static
A veces puede darse el caso en el cual necesitamos que algunas variables locales recuer-
den el valor luego de salir de su ambito dentro de una function, en estos casos podemos
definir una variable del tipo estática (static), la cual solo será accesible desde esta fun-
ción, pero su valor no desaparecerá al salir de la misma, sino que persistirá en el tiempo,
mientras no cerremos el programa, conservando su último valor.
void loop()
{ if ( control)
{ Funcion1 (); // muestra 0
Funcion1 (); // muestra 1
}
control = false ;
}
void Funcion1 ()
{ int x = 0; // Declaramos x como local
Serial.println(x);
x = x + 1;
}

51
En la definición de Funcion1, declaramos x como int, sin más, el resultado será así:
0
0
0
Cuando entramos en Funcion1, la int x se declara, se crea sobre la marcha y se le asigna

el valor 0. Cada vez que salimos de Funcion1, la variable x se desvanece y se vuelve a
crear la próxima vez que entremos en ella, tal y como corresponde a una variable lo-
cal obediente. Y se repite el proceso. Pero si en la función definimos la x como static la
variable x no se desvanece ya al salir, sino que conserva su valor para la próxima vez que
volvemos a Funcion1. Sigue siendo una variable local, no puede ser usada por ningún
programa o función fuera de Funcion1, pero no desaparece al salir sino que persiste por
lo que el programa retorna.
void loop()
{ if ( control)
{ Funcion1 (); // muestra 0
}
control = false ;
}
void Funcion1 ()
{ static int x = 0; // Declaramos x como local
Serial.println(x);
x = x + 1;
}
RESULTADO
0
1
2

52
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 cons-
tantes se clasifican en grupos.
True/false
Representan cuando algo es verdadero o falso.

True es definido como generalmente como uno '1', sin embargo posee una definición
más amplia, ya que cualquier valor entero no definido como cero es considerado verda-
dero.
False por su parte se define como cero '0'
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.
digitalWrite(13, HIGH); // activa la salida 13 con un nivel

alto (5v.)
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.
pinMode(13, OUTPUT); // designamos que el PIN 13 es una sali-

da
True/false
Estas
True/false
Estas

53
EJERCICIOS
04
SECCIÓN
EJERCICIO 1 - USO DEL MONITOR
Veamos otro ejercicio utilizando el Monitor, para ello recordemos que como primer paso
conectamos el arduino si ya no lo tenemos conectado y vamos a “Herramientas > Puer-
to > COMx (Arduino Leonardo)”, en donde seleccionamos el puerto USB de forma que
presente el tilde de selección que se muestra en la siguiente figura:
Luego vamos a “Herramientas > Monitor Serie” y damos click.

56
Esto nos abre el monitor según se ve a continuación:
Aparecerá en muestra pantalla la imagen de la consola donde en el extremo inferior

derecho tendremos la velocidad de la trasmisión 9600 baudios y Ambos NL & CR eso
significa en castellano retorno de carro y nueva línea que la consola aplicara automá-
ticamente en la trasmisión en el renglón.
Escribimos un programa
Veamos ahora el programa, en el cual se indica por el momento solo la velocidad de

transmisión el resto queda controlado por el sistema
El listado del programa queda así:
//Declara puertos de entradas y salidas y variables

//--------------------------------------------------
int led = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez, apagado
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(led, OUTPUT); //Configurar el LED como una salida
}
//------------------------------------
//Función cíclica
//------------------------------------

57
// Esta función se mantiene ejecutando
// cuando este energizado el Arduino
//Guardar en una variable el valor de la consola serial
void loop(){
leer=Serial.read();
// Si es la letra 'a' y además el LED está apagado
if ( (leer=='a') && (prendido==false) ){
digitalWrite(led,HIGH); // Enciende el LED
prendido=true; // Actualiza el estado del LED
}
// Si es la letra 'a' y además el LED está encendido
else if ( (leer=='a') && (prendido==true) )
{
digitalWrite(led,LOW); // Apaga el LED
prendido=false; // Actualiza el estado del LED
}
}
//Fin programa
Nos comunicamos desde el monitor con el programa.
Nos comunicaremos con el programa mediante el monitor, para ello escribiremos en la

parte superior la letra “a” que está esperando el programa y presionaremos en “Enviar”. Si
todo está bien conectado veremos como el led si esta prendido se apaga y en caso contra-
rio se enciende.

58
Luego de implementar el circuito anterior y de compilar el programa, podemos desde el
monitor introducir la variable “a” y enviar el dato al arduino mediante el botón de enviar
de forma que el led se prenda o apague.

59
EJERCICIO 2 - PROGRAMA DE APLICACIÓN
Implementemos ahora el siguiente circuito para realizar un ejercicio
Utilizaremos una resistencia de 1kΩ, un led y un pulsador.

60
Escribiremos el siguiente programa:
/*-----------------------------------
Encender LED con un pulsador
-----------------------------------
Oprimir un pulsador y mientras este se mantenga accionado
el LED se enciende*/
//------------------------------------
//Declara puertos de entradas y salidas
//------------------------------------
int pulsador=12; //Pin donde se encuentra el pulsador, entrada
int led=13; //Pin donde se encuentra el LED, salida
//------------------------------------
//Funcion principal
//------------------------------------
// Se ejecuta cada vez que el Arduino se inicia
void setup(){
pinMode(pulsador, INPUT); //Configurar el pulsador como una entra-
da
pinMode(led,OUTPUT); //Configurar el LED como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
// Esta funcion se mantiene ejecutando
// cuando este energizado el Arduino
void loop(){
//Condicional para saber estado del pulsador
if (digitalRead(pulsador)==HIGH){
//Pulsador oprimido
digitalWrite(led,HIGH); //Enciende el LED
}
else{
//Pulsador NO oprimido
digitalWrite(led,LOW); //Apaga el LED
}
}

61
BIBLIOGRAFÍA
LIBROS
Beginning C for Arduino, Second Edition - Jack Purdum, Ph.D. – 2015 – USA. – Edito-
rial: Apress.
Arduino Development Cookbook – Cornel Amariei. – 2015 – USA. Editorial: Pack Pu-
blishing.
Getting Started with Arduino – 3rd Edition – Massimo Banzi co-founder of Arduino &
Michael Shiloh – 2009 – USA. – Editorial: Make
Manual online
https://www.arduino.cc/en/Guide/HomePage

62
TEMAS DE LA UNIDAD
Vimos la estructura del lenguaje C, C++, que utilizamos para la progra-

mación de Arduino, no trate de memorizar todo el capítulo le resultara
tedioso y aburrido, el lenguaje se aprende con infinitas horas de práctica
y la necesidad de desarrollar una aplicación, y tenga en cuenta que esto es
solo una parte del lenguaje, más adelante veremos otras funciones.
No haremos un curso de programacon C pero veremos todas herramien-
tas que nos permita desarrollar toda la potencialidad de muestra placa.

63
TEMAS DE LA UNIDAD SIGUIENTE
En la siguiente unidad veremos lógica de Bool teoría binaria, aplicación

en un programa con entrada analógica, la potenciación de una salida.

64
DATOS FINALES
FORMA DE APROBACIÓN DEL CURSO
EL CURSO SE APRUEBA CON LA ENTREGA DE UN TRABAJO PROPIO, EXPLICA-

DO EN WORD, CON IMÁGENES Y EL PROGRAMA DESARROLLADO.
DATOS DEL DOCENTE
TÍTULO: MBA Ing.
NOMBRE: Juan M. Barreto R.
EMAIL: juanbarretor@gmail.com
DATOS UTN HAEDO
DIRECCIÓN: Párís 532 - Haedo
WEB: http://adistancia.frh.utn.edu.ar
TELÉFONO: + 54 11 4443-7466 // +54 11 4659-2575
E-MAIL: adistancia@frh.utn.edu.ar

65

Unidad 2 Arduino

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

Unidad 2 Arduino

Cargado por

Copyright:

Formatos disponibles

Arduino U2

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Un programa interno comprueba que la sintaxis de nuestro programa es acorde a la

El programa que generamos en el sketch se convierte en lenguaje de máquina, que está

ANÁLISIS DE ESTRUCTURA DE PROGRAMA

Analizaremos el programa que realizamos la clase anterior desde el software. La estruc-

void setup() //Primera Parte

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

La función de configuración setup debe contener la declaración de las variables. Es la

¿Un momento, que es una función y que es un bucle?

¿Qué es una variable?

Un momento, una pregunta más. ¿Qué representa la palabra void que se

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su

Podriamos preguntar ¿A mí que me importa? en definitiva es solo 1 segundo!

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

int variableEntrada = 0; // declara una variable y le asigna el

variableEntrada //es la variable en sí.

NOTA: La asignación se realiza mediante el símbolo de igual.

if (entradaVariable < 100) // pregunta si la variable es menor de

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

TIPO DE DATOS EN ARDUINO

TIPO Cantidad de Rango de valores

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

void setup() //Primera Parte

Un byte es un indicador de la cantidad memoria utilizada, la información es almacenada

2 e+7 2 e+6 2 e+5 2 e+4 2 e+3 2 e+2 2 e+1 2 e+0 VALOR

SUPONGAMOS QUE QUEREMOS CONVERTIR EL NÚMERO 220.

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

2 e+7 2 e+6 2 e+5 2 e+4 2 e+3 2 e+2 2 e+1 2 e+0 VALOR

A continuación podemos ver cuatro ejemplos:

2 e+7 2 e+6 2 e+5 2 e+4 2 e+3 2 e+2 2 e+1 2 e+0 VALOR

Primer fila 128+16+4+2=150

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Para formar el número hexadecimal a partir de un número binario, agruparemos el binario

02aaa4 Binario Hexadecimal

Convertir los siguientes números a binario y hexadecimal

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Veamos un ejemplo de su uso:

digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)

Detengamosnos nuevamente y veamos como aprender a pertir de la plataforma de Ar-

Vamos a continuación a ejecutar uno de ellos e introducirnos en el conocimiento del

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Como primer paso conectamos el arduino si ya no lo tenemos conectado y vamos a “Herra-

Luego vamos a “Herramientas > Monitor Serie” y damos click.

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

Aparecerá en muestra pantalla la imagen de la consola donde en el extremo inferior dere-

Y lo ejecutamos presionando el botón con la flecha que apunta hacia la derecha.

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

La forma de referirnos a tipo de dato char es anteponiendo este nombre reservado al

NOTA : Para ver el resultado debemos trabajar con el monitor.

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

unsigned char myChar = 240;

NOTA: En notación exponencial, cuando vemos un número elevado a un exponente se sue-

NOTA: Para obtener números negativos se utiliza la tecnica de complemento a dos

Cursos Semipresencial - UTN HAEDO MBA. Ing. Juan Barreto - adistancia@frh.utn.edu.ar

El complementoa 1 se define como: C1 =(2 ^d) - N -1, en donde d es el número de digitos y

(2 ^8) - 4 -1 = 256 -4 -1 = 251

El complemento a 2 posee una formula similar al complemento a 1 y es C2 =(2 ^d) - N,

C2 =(2 ^d) - N = (2 ^d) - N -1 +1 = C1 +1

De esta forma el complemento a dos del número 4 con 8 bits es igual a:

Este complemento a dos de cuatro representa el número -4.

unsigned int ledPin = 13;