Lectura practica2 digitales_arduino_puerto_serial

Aprende ARDUINO
28 Guía Teórico Práctica
3. Introducción a la programación de
ARDUINO
Como se mencionó anteriormente Arduino es un entorno completo para desarrollo de aplicación de
Computación Física, este entorno está formado por la tarjeta Arduino (Hardware) y por el IDE Arduino
(Software), por lo que para el diseño de alguna aplicación específica se deben realizar el diseño de ambas
partes Hardware y Software.
El poder del Microcontrolador dentro de una tarjeta Arduino radica en la capacidad de programarlo para que
controle estados de dispositivos conectados a sus salidas a partir de los estados de sensores conectados a sus
entradas, esta capacidad se le brinda a partir del diseño del Firmware o Software de aplicación a ser grabado
en la memoria interna de Arduino y que será ejecutado dentro de la tarjeta. A continuación se describirá una
breve introducción al diseño del Firmware, también llamado SKETCH en jerga Arduino, dejando para las
secciones posteriores el estudio específico de instrucciones destinadas a ser usadas con sensores o actuadores
puntuales.
Conceptos Básicos de Programación
Antes de iniciar el estudio de instrucciones y de cómo realizar programas para la Arduino, vale la pena hacer
un repaso a conceptos básicos sobre la programación:
Programación (Programar): Acción de diseñar e implementar una solución a un problema usando un
lenguaje de programación para ser ejecutado en un dispositivo digital programable: Microcontrolador (uC) o
Microprocesador (uP).
Algoritmo: Secuencia ordenada de pasos a seguir para resolver un problema o tarea, expresado es lenguaje
natural.
Lenguaje de programación: Conjunto de instrucciones con los que se pueden escribir los algoritmos para
ser interpretados por un dispositivo computacional.
Programa (Firmware o Sketch): Secuencia de instrucciones (comandos - código) escritas en un Lenguaje
de Programación con el objetivo de ser ejecutadas en un procesador (Arduino).
Lenguaje Maquina: Conjunto de instrucciones en binario que puede interpretar y ejecutar la CPU de un Up
o Uc.

Aprende ARDUINO
Instrucciones: Sentencias u oraciones escritas en lenguaje de programación y que conforman un listado de
programa o sketch.
Sintaxis: Forma correcta de escribir las instrucciones dentro del lenguaje de programación.
Estructura de control: Sentencias que permiten conjuntar instrucciones dentro de un Sketch para una mejor
estructuración y lectura del Sketch.
Tipo de Datos: Dentro todo lenguaje de programación a usar, los tipos de datos reconocidos son importantes
ya que nos indican con que tipos de números y/o letras podemos trabajar, algunos ejemplos son: Entero,
Decimal, Caracter, Cadenas de Caracteres, etc . Más adelante se estudiaran con detalle estos tipos de datos.
Variable: Una variable se entiende como un espacio en memoria que se le asigna un nombre y puede
almacenar un dato que puede cambiar o no dentro la ejecución del Sketch.
Periféricos: Se le conoce a bloques de hardware que dispone la tarjeta Arduino y que son los dispositivos
que ejecutaran las acciones indicadas por el Sketch.
Función: En el lenguaje de programación de Arduino, se entiende como una instrucción ejecutable por el
CPU y que al mismo tiempo es un subconjunto de instrucciones que se pueden repetir dentro de un sketch,
posteriormente se tocara más acerca de las funciones propias de Arduino y como el usuario puede también
crear sus propias funciones.
Un Sketch es un programa diseñado para ser ejecutado por la CPU de Arduino para manipular sus entadas y
salidas, el diseño de este es básicamente como realizar un programa para una computadora de escritorio, se
reconocen algunos pasos o etapas a considerar en el proceso de diseño de un sistema integrado de
computación física basado en Arduino, a continuación se describen:
Proceso de diseño de un Sistema con Arduino
Cuando se inicia un el diseño de un proyecto, es posible que se esté tentado a querer escribir el código del
programa inmediatamente después de que se nos ocurre una idea, sin embargo, antes de comenzar a codificar,
es necesario definir algunos aspectos de diseño previo, a modo de plan detallado como fundación para el
desarrollo de un proyecto exitoso, se recomienda que cuando se inicie un proyecto nuevo, se sigan los
siguientes pasos:
Necesidad o Problema a resolver: es la situación real que necesita ser solventada, esta necesidad puede ser
de casi cualquier naturaleza, por ejemplo: la necesidad de activación sincronizada del timbre en un colegio, el
conteo automático de los pasajeros de un autobús, el aviso remoto de alguna situación de peligro en nuestro
hogar, permitir la entrada a un recinto a personas autorizadas, etc.
Idea de solución de una necesidad: este paso implica la decisión de aplicar una solución basada en un
sistema de Computación Física basada en Arduino, además de analizar diferentes opciones de hardware
electrónico a utilizar es decir realizar una factibilidad tanto económica como técnica.

Aprende ARDUINO
Diseño del hardware electrónico del sistema: en este paso nos encargamos de tomar los componentes,
analizar sus hojas técnicas y datos de conexión, para diseñar el circuito electrónico completo de nuestro
sistema.
Implementación del hardware: basado en el diseño anterior se implementa el circuito real, ya sea en
cualquiera de las formas disponibles: breadboard, tarjetas perforadas o circuito impreso (PCB), listo para
recibir el programa que lo hará funcionar.
Diseño del firmware o Sketch: implica la creación del código en lenguaje de programación para ser grabado
en la memoria interna del Arduino, se pueden diferenciar 3 sub-etapas, la primera el Análisis que requiere el
conocimiento de las necesidades de funcionamiento del sistema además de las características del lenguaje de
programación a utilizar, una segunda etapa es el Diseño que implica la creación de un Algoritmo y
Flujograma respectivo del programa de solución y por último la Codificación que requiere la transformación
del Flujograma en código fuente en lenguaje de programación Arduino utilizando el IDE. Generalmente en
aplicaciones de computación física basada en Arduino es muy común realizar la Codificación como primer
paso del diseño del Sketch, pero se recomienda siempre al menos realizar un Algoritmo como guía.
Compilar y descargar: En esta etapa se utiliza el IDE Arduino para compilar el código, transformarlo a
código binario que entiende el CPU de Arduino, y luego descargarlo a través del puerto USB hacia el
Arduino.
Integración y pruebas: Se considera la etapa final que implica la puesta en funcionamiento del sistema
dentro del escenario real de la aplicación, y realizar las pruebas necesarias de verificación, si algo no funciona
como se espera se debe volver al diseño del Sketch para realizar las modificaciones necesarias.
En resumen, todo programa (Firmware o Sketch) intenta resolver un problema (tarea o necesidad), al
comenzar un programa, lo primero es definir el procedimiento general que este debe seguir, un algoritmo, el
algoritmo se transforma en flujograma, y este se debe codificar en un listado escrito código en un lenguaje de
programación especifico, este código debe transformase en lenguaje que interpreta la CPU, lenguaje maquina
1s y 0s, este proceso de conversión se denomina compilar.
Un Sketch para Arduino debe seguir una estructura específica, además de una serie de componentes
programáticos que los conforman, a continuación se describirán las diversas partes que todo Sketch debe
tener y conforman su estructura funcional.
Estructura básica de un Sketch
Todo programa en el lenguaje de programación Arduino, se divide en varios bloques principales y
dependientes el uno del otro. El primer gran bloque de programación es el lugar donde vamos a declarar los
recursos utilizados en el programa principal. En este bloque declararemos todas las variables que vamos a
utilizar, estableceremos el nombre que le asignamos a cada terminal de la tarjeta Arduino, constantes, etc.
Luego está el bloque de configuración, Setup, y luego el bloque de instrucciones, Loop, luego de describirán
estos ampliamente, en la figura siguiente se puede observar un Sketch con su estructura identificada.

Aprende ARDUINO
Figura 3-2. Bloques de un Sketch en lenguaje Arduino (ladyada.net)
El segundo gran bloque de programación es el programa principal; se puede encontrar en un programa a
partir de la sentencia void setup(). A partir de aquí, podemos distinguir otras dos partes, una que solo
se ejecutara una sola vez al iniciar el programa y otra parte en la que se generará un bucle infinito.
La parte que solo se ejecuta una vez suele ser utilizada para iniciar comunicaciones serie, i2c, isp, etc.
declarar la función de las terminales de la tarjeta Arduino: entradas o salidas, y también este bloque se
instrucciones puede ser utilizada para asignar valores predefinidos a variables.
El bucle infinito el cual se encuentra a partir de void loop() abarca el programa que se ejecutará en el
microprocesador de la tarjeta Arduino. También podemos observar que cada grupo de bloques se encuentra
comprendido entre 2 llaves que los delimita, que cada sentencia acaba con punto y coma y que se pueden
agregar comentarios al programa sin que afecte a este añadiendo 2 barras laterales.

Aprende ARDUINO
En conclusión todo Sketch posee tres partes bien definidas: Declaraciones, Inicializaciones (Setup) y
Programa Principal (Loop).
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-). 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, y se utiliza para configurar o inicializar pinMode (modo de trabajo de
las E/S), configuración de la comunicación en serie y otras.
La función principal repetitiva infinita contiene el código que se ejecutara 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.
Aspectos de programación del Lenguaje Arduino.
Dentro de todo lenguaje de programación existen ciertos aspectos de sintaxis que todo programa debe
cumplir y que son generales a cualquier Sketch sea cual sea su función, a continuación se describirán estos
aspectos a considerar:
Comentarios.
Los comentarios son una parte importante de todo lenguaje de programación, un comentario es una línea de
texto explicativo acerca de la función de una línea de código, permiten al programador llevar una secuencia
informativa acerca de las instrucciones, y además permiten a un usuario externo una mejor comprensión
acerca de la función de cada estamento, para indicar que una línea de programa es un comentario se precede
con el símbolo // y cabe mencionar que los comentarios de un programa no ocupan espacio en memoria ya
que son ignorados por el compilador, la sintaxis general de un comentario es la siguiente:
// Este es un comentario
Entre llaves.
Las llaves {} sirven para definir el principio y el final de un bloque de instrucciones, dentro de una estructura
de control y se utilizan para los bloques de programación setup(), loop(), if.., etc. Una llave de apertura “{“
siempre debe tener una llave de cierre “}”, si no es así, al momento de compilar el código este indicara
errores.
Punto y coma
El punto y coma “;” se utiliza para separar o terminar una línea de instrucción en el lenguaje de
programación de Arduino. Si olvidas poner fin a una línea con un punto y coma se producirá en un error de

Aprende ARDUINO
compilación. El texto de error puede ser obvio, y se referirá a la falta de un punto y 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.
Tipos de Datos
Al momento de diseñar un programa utilizando cualquier lenguaje de programación es de suma importancia
el conociendo de los tipos de datos soportados, para poder hacer las declaraciones necesarios según el dato a
usar, Arduino permite manejar los siguientes tipos de datos:
Byte – tipo de dato Entero, almacena un valor numérico de 8 bits. Tiene un rango de 0-255.
Int - almacena un valor entero de 16 bits con un rango de 32,767 a -32,768.
Long - valor entero almacenado en 32 bits con un rango de 2,147,483,647 a -2,147,483,648.
Float - tipo coma flotante almacenado en 32 bits con un rango de 3.4028235E+38 a -
3.4028235E+38.
Char – permite almacenar un único dato alfanumérico, es decir una letra, su valor numérico es el
código ASCII de ese carácter alfanumérico.
String – es una variable que permite guardar una cadena de caracteres alfanuméricos
Arrays - se trata de una colección de valores que pueden ser accedidos con un número de índice
Variables en Lenguaje Arduino.
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 asigna el valor de 58:
int variableEntrada = 0; // declara una variable y le
// asigna el valor 0
variableEntrada = 58; // se asigna el valor 58 al contenido de la variable
'variableEntrada' es el nombre de la variable en sí, la primera línea declara que será de tipo entero “int”.
La segunda línea fija a la variable en un valor numérico de 58. Una vez que una variable ha sido asignada, o
re-asignada, usted puede probar su valor para ver si cumple ciertas condiciones (instrucciones if..), o puede
utilizar directamente su valor.
Nota: Las variables deben tomar nombres descriptivos, para hacer el código más legible. Los nombres de
variables pueden ser “contactoSensor” o “pulsador”, para ayudar al programador y a cualquier otra persona a
leer el código y entender lo que representa la variable. Nombres de variables como “var” o “valor”, facilitan
muy poco que el código sea inteligible. Una variable puede ser cualquier nombre o palabra que no sea una
palabra reservada en el entorno de Arduino.

Aprende ARDUINO
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.
El siguiente ejemplo declara la variable 'entradaVariable' como una variable de tipo entero “int”, y
asignándole un valor inicial igual a cero.
int entradaVariable = 0;
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 configuració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 determinará 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 la función o bloque de instrucciones
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.
Partes funcionales de un Sketch en Arduino.
1. Expresiones
Una expresión es una combinación de operadores y operando, también se le conoce como Instrucciones para
operaciones Matemáticas, Comparación y/o Lógicas entre datos numéricos y/o variables.
Ejemplos de expresiones:
5+k*2
(10*var1)/var2
Como se mencionó estas expresiones pueden ser operaciones Aritméticas, Comparaciones y/o Lógicas, a
continuación un resumen de los operadores que se utilizan en el IDE Arduino.

Aprende ARDUINO
Operadores Aritméticos.
En el lenguaje de programación de Arduino, se reconocen los siguientes operadores aritméticos:
= (Asignación): usado para asignar algún valor numérico o alfanumérico a una variable o asignar el resultado
de una operación previa a una variable.
var1 = 123
+ (Suma): utilizado para indicar la realización de una adición entre operandos numéricos o variables con
contenidos numéricos.
var2 = 123 + var1
- (Resta): este operador se aplica para realizar una sustracción entre operandos numéricos o variables con
contenidos numéricos.
var3 = var1 - 100
* (Multiplicación): al igual que los anteriores indica la realización de la operación multiplicación entre dos o
más operandos numéricos y/o variables numéricas.
var4 = var3 * 4 * var2
/ (División): este operador sirve para realizar una división entre dos operandos, cabe destacar que esta
operación devuelve el cociente de la división, por ejemplo en la operación siguiente la variable llamada var5
valdrá 3.
var5 = 14 / 4
% (Módulo): con este operador se puede obtener el Residuo o Resto de una división, por ejemplo en la
operación siguiente la variable llamada var6 valdrá 5.
var6 = 14 % 4
Operadores de Comparación.
En el lenguaje de programación de Arduino, se reconocen los siguientes operadores usados para realizar una
Comparación, estos operadores son muy útiles en las estructuras de control decisivas en las cuales se necesita
evaluar una comparación entre variables del mismo tipo, recordar que estos operadores solo devuelven uno
de dos resultados: verdadero o falso.
= = (Igual a): cuando se necesita verificar la igualdad entre operandos numéricos o con el contenido de
alguna variable.
x == y; (x es igual a y)

Aprende ARDUINO
!= (Distinto de): utilizado para verificar si dos operando son diferentes entre sí, la operación será verdadera
si ambos números o contenidos de variables son diferentes.
x != y; (x no es igual a y)
< (Menor que): este operador se aplica para realizar una comparación que será verdadera siempre que el
primer operando sea menor que le segundo.
x < y; (x es menor a y)
> (Mayor que): al igual que la anterior, la comparación será verdadera si el primer operando es mayor al
segundo.
x > y; (x es mayor a y)
<= (Menor o igual que): la condición será verdadera cuando el primero operando sea menor o igual al
segundo operando.
x <= y; (x es menor o igual a y)
>= (Mayor o igual que): al igual que el anterior operador, la condición será verdadera si el primer operando
es mayor o igual al segundo operando.
x >= y; (x es mayor o igual a y)
Operadores Lógicos Booleanos.
En ocasiones es necesario la realización de operaciones lógica propias del algebra booleana, con la intención
de comprobar ciertas condiciones, muy utilizadas en las estructuras de control decisivas, estas operaciones
devuelven un Verdadero o Falso y son comparables con los resultados de las Compuertas Lógicas Digitales, a
continuación se describen los operando reconocidos por Arduino:
&& (AND lógico): esté operando implica la realización de una AND lógico entre los operandos, el resultado
es Verdadero sólo si ambos operadores son Verdaderos.
var1 == 2 && var3 == 8
|| (OR lógico): utilizado para realizar la operación OR entre operandos, el resultado de la expresión será Verdadero si
alguno de los dos operadores es Verdadero.
x > 0 || y > 0

Aprende ARDUINO
! (NOT): utilizado para realizar la operación NOT con un único operando, el resultado de la expresión será
Verdadero si el operando es Falso y viceversa.
y = !x
2. Estamentos o instrucciones
Se le llama a una línea del Sketch que es ejecutable por la CPU de Arduino, en otras palabras son comandos
que se ejecutaran y realizaran acciones internas o externas sobre los periféricos. Estos estamentos están
formados por Funciones o Instrucciones propias del lenguaje Arduino a las cuales se les indican parámetros
de funcionamiento externo sobre los periféricos de la Tarjeta Arduino, además Arduino reconoce como
estamento toda oración terminada en ; (punto y coma), si no se incluye esta puntuación al final de una línea,
el compilador retorna un error.
digitalWrite (13, HIGH);
analogRead (A0);
En los estamentos anteriores se usan dos funciones digitalWrite y analogRead , y los datos entre paréntesis se
les conoce como Parámetros de la función, más adelante se estudiaran las funciones específicas para manejar
dispositivos externos puntuales.
3. Estructuras de control
Son bloques de estamentos o grupos de instrucciones que se ejecutan según un ciclo, los tipos de estructuras
de control son Repetitivo o Decisivo, normalmente estas estructuras se utilizan cuando se desean ejecutar
instrucciones una serie de veces o en dependencia de una condición verificable, a continuación se describirán
los tipos de Estructuras de Control reconocidas por el lenguaje de programación Arduino.
Estructura Condicional IF-THEN-ELSE
Esta estructura se utiliza para probar si una determinada condición se ha alcanzado, es decir se prueba una
condición y dependiendo del resultado de esta se ejecutan una serie de estamentos solo si se cumple la
condición. Se pueden diferenciar 2 tipos de estructura IF más utilizadas, las estructuras Solo IF y la estructura
IF Completa,
En la estructura Solo IF se evalúa la condición y solo se ejecutan estamentos si la condición es verdadera, la
sintaxis de la estructura Solo If es la siguiente:
if (unaVariable == valor)
{
ejecutaInstrucciones;
}

Aprende ARDUINO
Por el contrario la estructura IF Completa ejecuta bloques de estamentos para ambos resultados de la
condición. El formato de sintaxis para la estructura IF Completa es el siguiente:
if (inputPin == HIGH)
{
instruccionesA;
}
else
{
instruccionesB;
}
Esta estructura es muy útil cuando se trabaja con entradas analógicas o digitales provenientes de sensores
externos y así poder conocer el estado de parámetros físicos dentro de los programas Arduino.
Estructura Condicional SWITCH/CASE
Como las sentencias if, esta estructura controla el flujo de programas permitiendo a los programadores
especificar diferentes códigos que deberían ser ejecutados en función de varias condiciones. En particular,
una estructura switch compara el valor de una variable con el valor especificado en las sentencias case.
Cuando se encuentra una sentencia case cuyo valor coincide con dicha variable, el código de esa sentencia se
ejecuta.
La palabra clave break sale de la estructura switch, y es usada típicamente al final de cada case. Sin una
sentencia break, la sentencia switch continuaría ejecutando las siguientes expresiones hasta encontrar un
break, o hasta llegar al final de la sentencia switch.
La sintaxis general de esta estructura es la siguiente:
switch (var) {
case valor:
// sentencias a ejecutar
break;
case valor:
// sentencias a ejecutar
break;
default:
// sentencias a ejecutar por defecto si no se encuentra el valor
}
A continuación un pequeño ejemplo de uso de la estructura SWICTH/CASE, donde se evalúa el contenido de
la variable VAR y se ejecutan sentencias según el caso.
switch (var) {
case 1:
// sentencias hacer algo cuando sea igual a 1
break;
case 2:
// senstencias hacer algo cuando sea igual a 2
break;
default:
// si nada coincide, ejecuta el "default"
// el "default" es opcional
}

Aprende ARDUINO
Estructura Condicional WHILE
Una estructura de control del tipo while es un bucle de ejecución continua mientras se cumpla la expresió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, la sintaxis general es la siguiente:
while (unaVariable ?? valor)
{
ejecutarSentencias;
}
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.
while (unaVariable < 200) // testea si es menor que 200
{
instrucciones; // ejecuta las instrucciones
// entre llaves
unaVariable++; // incrementa la variable en 1
}
Estructura Condicional DO-WHILE
El bucle o estructura 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, la sintaxis
general es:
do
{
Instrucciones;
} while (unaVariable ?? valor);
El siguiente ejemplo asigna el valor leído leeSensor() a la variable x, espera 50 milisegundos y luego
continua mientras que el valor de la x sea inferior a 100.
do
{
x = leeSensor();
delay(50);
} while (x < 100);

Aprende ARDUINO
Estructura Repetitiva 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 ';' , veamos 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 el 0, y la condición es probar que el valor es inferior a 20 y si es
cierto esto, 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 y prueba si es
{ // menor que 20, incrementa i.
digitalWrite(13, HIGH); // enciende el pin 13
delay(250); // espera ¼ seg.
digitalWrite(13, LOW); // apaga el 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 extraños pero permiten crear soluciones a algunos problemas de programación específicos.
4. Funciones.
El último bloque funcional de un Sketch lo componen las funciones, se puede decir que una función es un
bloque o conjunto de instrucciones destinadas a ejecutar una tarea específica. Normalmente en Arduino C,
algunas funciones ya están predefinidas y declaradas dentro del IDE, y en el Sketch solo será necesario
invocarlas.
digitalWrite (pin, estado)
En el estamento anterior la función digitalWrite es una función que “escribe” un estado valor de salida digital
en un pin del Arduino. / Maneja una salida (periférico) digital. Sera de mucha importancia aprender a usar
las FUNCIONES dependiendo del periférico que deseemos usar.
Es importante notar que el usuario también puede definir funciones propias, a modo de subrutinas, con
instrucciones que será necesario repetir en un sketch, segmentar el código en funciones permite al
programador crear piezas modulares de código que realizan una tarea definida y vuelven a la zona del
programa en la que fueron llamadas. El caso típico para crear una función es cuando uno necesita realizar la

Aprende ARDUINO
misma acción múltiples veces dentro de un mismo programa. Para programadores acostumbrados a utilizar
BASIC las funciones en Arduino permiten (y extienden) la utilidad de usar subrutinas (GOSUB en BASIC).
La estandarización de fragmentos de código en funciones tiene diversas ventajas:
 Las funciones ayudan al programador a ser organizado, además ayudan a conceptualizar el programa.
 Las funciones codifican una acción en un lugar, así que sólo deben ser depuradas de errores una vez.
 Reducen las posibilidades de error en modificaciones, si el código debe ser cambiado.
 Las funciones hacen el sketch pequeño y compacto por que las secciones de código se reutilizan
varias veces.
 Hacen más fácil la reutilización de código en otros programas por hacerlo modular y, como efecto
paralelo,
 Usando funciones se obtiene un código mas legible.
Pasos funcionales de un Sketch
Dentro de un Sketch es importante llevar una secuencia ordenada de los procesos a ejecutar, un buen diseño
de programa debe considerar los siguiente pasos dentro de la lógica o estructura, a continuación se
describieran estos cinco pasos.
Paso 1 – Inicialización: En este paso o etapa deben indicarse instrucciones que tiene por objetivo realizar tareas de
inicialización de variables, estados o acciones del controlador, además de la inicialización y configuración de algunos
dispositivos externos a usar conectados a nuestra placa Arduino.
Paso 2 – Entrada: Todo programa necesita datos o información con los que trabajar y procesar, por lo que en este paso
se deben declarar las instrucciones que se deben ejecutar para adquirir la información necesaria para solventar una tarea,
esta información puede ser externa proveniente de sensores o interna al Arduino.
Paso 3 – Procesamiento: Con la información recabada en el paso previo, en este paso se declaran las instrucciones o
estamentos que realizaran la tarea propiamente dicha, toman los datos de entrada y los procesan produciendo nuevos
datos.
Paso 4 – Salida: El producto del procesamiento produce nueva información que debe ser guardada y/o mostrada a un
usuario, en este paso se incluyen los estamentos que toman los datos del Procesamiento y los envían a salidas dentro o
fuera del Arduino.
Paso 5 – Finalización: Como paso final tenemos los estamentos para finalizar el programa y apagar el sistema / poco
utilizado en aplicaciones Arduino, se quiere que los sketches siempre estén «corriendo» y nunca dejen de funcionar.

Aprende ARDUINO
4. Comunicación serial en ARDUINO
Una de las ventajas de la tarjeta Arduino es la capacidad de comunicación a través del puerto USB dispuesto
en ella, esta comunicación es bidireccional y de tipo Serie, y sirve para dos propósitos, el principal es permitir
la descarga del Sketch desde el Arduino IDE hacia la memoria del Microcontrolador, y la segunda es la
transferencia de información desde el propio Sketch hacia la computadora, ya sea para visualizar datos
producidos por el Arduino o enviar información de configuración o funcionamiento hacia un Sketch.
Comunicación Serie en Arduino.
La comunicación o transmisión de información serial, a diferencia de la comunicación paralela, es aquella en
la cual se envía bit por bit a través del canal de comunicación, es decir los bits viajan en “serie”, es decir, uno
tras otro a través del medio de comunicación. Un puerto serie se entiende como los pines o terminales que
dispone un dispositivo para poder realizar una comunicación serie con otros dispositivos, el caso del
Microcontrolador ATMEGA328p presente en un Arduino UNO dispone de un puerto serie de tipo TTL-
UART (se deja al lector investigar significado) que permite comunicar la tarjeta Arduino con otros
dispositivos, ya sea otro Arduino o un PC, para así poder transferir datos entre ambos, el canal físico o puerto
de comunicación en el puerto USB de la tarjeta Arduino, pero también pueden ser los pines digitales 0 (Rx) y
1 (Tx) de la tarjeta.
Figura 4-1. Arduino se comunica por el puerto serie USB (ladyada.net).

Aprende ARDUINO
Figura 4-2. Arduino IDE y la aplicación Monitor Serial.
Para poder utilizar en los sketches de este tipo de comunicación se hace uso de un elemento del lenguaje
Arduino llamado Serial, se debe conocer entonces las funciones derivadas de Serial para poder realizar con
Arduino el envío o recepción de datos desde y hacia una PC.
Si se desea comunicar la tarjeta Arduino con la PC, se debe ejecutar en ella un software que permita
interactuar con el puerto serial de la computadora y así poder “ver” la comunicación con el Arduino, lo bueno
es que el IDE de Arduino ya trae incluido una aplicación para esto, llamada “Monitor Serial” y para
ejecutarlo basta con dar clic en el botón de la esquina superior.
Envío de datos desde Arduino hacia la PC.
Enviar datos desde nuestro Arduino a la PC es muy sencillo, no se hace uso de ninguna librería especial, y
algunas de las funciones a usar son:
Serial.begin(): esta instrucción abre y configura el puerto serie de Arduino para que pueda comenzar la
comunicación, esta función recibe como parámetro la velocidad de transmisión, normalmente 9600, esta
instrucción debe de ir dentro del bloque Setup() de nuestro Sketch. Por ejemplo: inicializamos la
comunicación serial con la sentencia Serial.begin(9600). El 9600 indica el baud rate, o la cantidad de
baudios por segundo que manejará el puerto serie. Se define baudio como una unidad de medida, usada en
telecomunicaciones, que representa el número de símbolos por segundo en un medio de transmisión.

Aprende ARDUINO
Serial.print(): envía a través del canal o puerto serie un dato desde el Arduino hacia el computador o
dispositivo conectado al puerto serie, este dato puede ser de cualquier tipo: carácter, cadena, numero entero,
decimal, etc. Por ejemplo:
Serial.print(“Hola”); //envía la palabra hola hacia el dispositivo
//conectado al puerto serial.
Serial.print(var); //envía el contenido de la variable var hacia
//el dispositivo conectado al puerto serial.
Serial.prinln(): hace exactamente lo mismo que Serial.print(), pero además añade automáticamente al final
de los datos enviados dos caracteres extra: retorno de carro y nueva línea. Para que el IDE Monitor Serial
imprima los siguientes datos en una línea nueva de la pantalla.
EJEMPLO SERIAL01: Demostración de envío de datos hacia la computador, el siguiente sketch envía una serie
de números y letras hacia el monitor serial usando el puerto USB del Arduino, note la diferencia entre
Serial.print y Serial.println. Recordando que se debe de abrir el Monitor Serial de IDE Arduino
para poder visualizar los datos enviados por nuestro Arduino.
/*
Sketch para demostrar el envio de datos desde Arduino
Envía números en secuencia hacia el Monitor Serial del IDE
Luego de descargado el sketch active el monitor serial.
Modificado por: otoniel.flores@mail.utec.edu.sv
Ejemplo de uso libre CC
*/
int variable = 0; //se crea una variable
void setup()
{
Serial.begin(9600); //activar el puerto serie del Arduino
delay(2000);
Serial.println(“esta es una prueba de la comunicación serie con Arduino”);
}
void loop()
{
Serial.print(“El valor de la variable es:”);
Serial.println(variable); //se manda el contenido de variable
delay(500);
variable++; //se incrementa el valor de variable en uno
}
//fin del sketch

Aprende ARDUINO
Figura 4-3. Resultado en el Monitor Serial del ejemplo 1.
Recibir datos desde la PC en Arduino.
Al igual que se pueden enviar datos hacia una PC, el Arduino también puede recibir datos provenientes de
una computadora a través de puerto serie, y así poder procesarlos y utilizarlos en nuestros sketches.
Desde el Monitor Serial enviar datos a la placa Arduino es muy sencillo: no hay más que escribir lo que
queramos en la caja de texto allí mostrada y pulsar el botón “Enviar”. No obstante si el sketch que se está
ejecutando en la placa no está preparado para recibir y procesar estos datos, esta transmisión no llegara a
ningún sitio. Por tanto, necesitamos recibir convenientemente en nuestros sketch los datos que lleguen a la
placa vía comunicación serie. Las funciones a utilizar para lograr recibir datos por el puerto serie se describen
a continuación.
Serial.available(): devuelve el número de bytes-caracteres-disponibles para ser leído que provienen a través
del canal serie (via USB o via pines Rx/Tx). Estos bytes ya han llegado al Microcontrolador y permanecen
almacenados temporalmente en una pequeña memoria o buffer de 64 bytes. Si no hay bytes para leer, esta
instrucción devolverá 0.
Serial.read(): devuelve el primer byte aun no leído de los que estén almacenados en el buffer de entrada,
para leer el siguiente byte se ha de volver a ejecutar de nuevo Serial.read().
Cabe destacar que el monitor serial “convierte” a su equivalente ASCII todo carácter eniado hacia Arduino,
esto quiere decir que el Sketch Arduino deberá reconvertir o trabajar con códigos ASCII de los respectivos
caracteres alfanuméricos, recordando que el lenguaje Arduino reconoce caracteres en código ASCII con la
sintaxis, entre comillas simple: „x‟.
EJEMPLO SERIAL02: En este ejemplo se ejecuta la comunicación con el puerto serie para recibir e interactuar
con la computadora. Recuerde que se debe ejecutar el Monitor Serial, y el envió de datos se realizara con el
botón Enviar.

Aprende ARDUINO
/*
Programa de uso de Monitor Serial del Arduino IDE
Se pide un número y el programa muestra
el nombre del número en letras
*/
int valor_ingresado; //se declara una variable entera
void setup()
{
Serial.begin(9600);
Serial.println("Ingrese un valor entre 0 y 9");
}
void loop() {
// verificar si hay un byte en el puerto serie
if (Serial.available() > 0)
{
//si es asi, leerlo y aignarlo a la variable
valor_ingresado=Serial.read();
//procesarlo
if (valor_ingresado=='0') Serial.println("***Ud. introdujo el numero CERO");
if (valor_ingresado=='1') Serial.println("***Ud. introdujo el numero UNO");
if (valor_ingresado=='2') Serial.println("***Ud. introdujo el numero DOS");
if (valor_ingresado=='3') Serial.println("***Ud. introdujo el numero TRES");
if (valor_ingresado=='4') Serial.println("***Ud. introdujo el numero CUATRO");
if (valor_ingresado=='5') Serial.println("***Ud. introdujo el numero CINCO");
if (valor_ingresado=='6') Serial.println("***Ud. introdujo el numero SEIS");
if (valor_ingresado=='7') Serial.println("***Ud. introdujo el numero SIETE");
if (valor_ingresado=='8') Serial.println("***Ud. introdujo el numero OCHO");
if (valor_ingresado=='9') Serial.println("***Ud. introdujo el numero NUEVE");
delay(1000);
Serial.println("");
Serial.println("Ingrese un valor entre 0 y 9");
}
}
//fin del sketch

Aprende ARDUINO
En el ejemplo anterior se recibía y procesa un solo dato o carácter enviado, pero que sucede si lo que
queremos es leer toda una cadena de caracteres, por ejemplo un nombre o edad?. Esto se logra leyendo por
medio de Serial.read() el carácter o letra disponible una por una de toda la frase ingresada desde el Monitor
serial.
EJEMPLOSERIAL03: El siguiente sketch leerá una frase o cadena de caracteres envía desde el Monitor Serial y
Arduino responderá con un saludo.
/*
Programa que usa el Monitor Serial del IDE Arduino
pide un nombre y regresa un saludo
*/
char letra; // variable para el carácter recibido.
String nombre; // variables para almacenar la cadena de caracteres
void setup()
{
Serial.begin(9600);
Serial.println("Cuál es tu nombre?");
}
void loop()
{
// verificar si hay un byte en el puerto serie
if (Serial.available() > 0)
{
//si es asi, leerlo y asignarlo a la variable
letra=Serial.read();
//procesarlo, solo se leera una letra a la vez, asi
//que se debe concatenar para formar todo el nombre ingresado
//estudie el uso de "concat"
nombre.concat(letra);
delay(100); //pausa para que Arduino lea la proxima letra
//verificar si ya no hay mas letras?
if (Serial.available()==0)
{
//si es asi, imprimir el saludo
Serial.print("Hola ");
Serial.print(nombre);
delay(1000);
Serial.print(", que tengas un buen dia!");
delay(1000);
Serial.println("");
Serial.print("Bye "); Serial.println(nombre);
letra = 0;
nombre = 0;
}
}
}
//Fin del sketch

Aprende ARDUINO
A partir de esto ejemplos de aplicación se recomienda el diseño de programas derivados, para la
comunicación serial con la computadora, por ejemplo el diseñar una “calculadora interactiva” o “el adivinar
un numero aleatorio”, más avanzado aun el desarrollar aplicación en Visual Basic que se comuniquen
directamente con Arduino sin necesidad del Monitor serial

Estudiar las siguientes instrucciones
extra en el manejo del puerto Serial de Arduino.

Serial.readString()

Leer una cadena de caracteres proveniente del Monitor Serial, devuelve un tipo String.
p.e. <StringmiNombre=Serial.readString();>

Serial.parseInt()

Leer un valor numérico entero proveniente del Monitor Serial, devuelve un tipo Int.
p.e. <intmiEntero=Serial.parseInt();>

Serial.parseFloat()

Leer un valor numérico con punto decimal proveniente del Monitor Serial, devuelve un tipo Float.
p.e. <floatmiFloat=Serial.parseFloat();>
EJEMPLOS
Se recomienda realizar en su placa el siguiente ejemplo:
/*
*
* ********************************************************
* ********************************************************
* *** ***
* *** EjemploSerial.readString() ***
* *** Serial.parseInt(),Serial.parseFloat() ***
* ********************************************************
* ********************************************************
*
* CódigoEjemplodeusodelacomunicación
* SerialentreArduinoylaPC
*
* ****************************************************
* *Fecha:27/03/2015 *
* *Autor:OtonielFLores *
* *Mail:otoniel.flores@mail.utec.edu.sv *
* *Licencia:GNUGeneralPublicLicensev3orlater*
* ****************************************************
*/

/******************************************************************
* Inicialización *
******************************************************************/
StringmiNombre; //variablecadenadecaracteres
intedad; //variableentera
floataltura; //variabledecimal
/******************************************************************
* Configuración *
******************************************************************/
voidsetup(){
Serial.begin(9600); //configuralavel.delpuertoUSB
}
/******************************************************************
* LoopPrincipal *
******************************************************************/
voidloop(){
Serial.println("BIenvenido...");
Serial.println("IngresatuNombre:"); //pediralusuariounaentrada
while(Serial.available()==0){ //esperarporlarespuestadelusuario
//mientraselusuarionoingrese,nosehacenada
}
miNombre=Serial.readString(); //LeerelNombredelusuario
Serial.println("Queedadtienes?"); //pediralusuariounaentrada
while(Serial.available()==0) {
}
edad=Serial.parseInt(); //leerlaedaddelusuario
Serial.println("Queestaturatienes,enmetros?"); //pedirunaentrada
while(Serial.available()==0) {
}
estatura=Serial.parseFloat(); //leerlaestatura
Serial.print("Hola"); //Imprimirunsaludoydatos
Serial.print(miNombre);
Serial.print(",tutienes");
Serial.print(edad);
Serial.println("años,");
Serial.print("ytienes ");
Serial.print(estatura);
Serial.println("mtsdealto.");
Serial.println("");
}
//FINDELCODIGO

Lectura practica2 digitales_arduino_puerto_serial

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Lectura practica2 digitales_arduino_puerto_serial

Similar a Lectura practica2 digitales_arduino_puerto_serial (20)

Último

Último (20)

Lectura practica2 digitales_arduino_puerto_serial