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: [email protected]

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

mailto:[email protected]

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. <String miNombre = Serial.readString();>

Serial.parseInt()

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

Serial.parseFloat()

Leer un valor numérico con punto decimal proveniente del Monitor Serial, devuelve un tipo Float. p.e. <float miFloat = Serial.parseFloat();>

EJEMPLOS Se recomienda realizar en su placa el siguiente ejemplo:

/*

*

* ********************************************************

* ********************************************************

* *** ***

* *** Ejemplo Serial.readString() ***

* *** Serial.parseInt(), Serial.parseFloat() ***

* ********************************************************

* ********************************************************

*

* Código Ejemplo de uso de la comunicación

* Serial entre Arduino y la PC

*

* ****************************************************

* * Fecha: 27/03/2015 *

* * Autor: Otoniel FLores *

* * Mail: [email protected] *

* * Licencia: GNU General Public License v3 or later *

* ****************************************************

*/

/******************************************************************

* Inicialización *

******************************************************************/

String miNombre; // variable cadena de caracteres

int edad; // variable entera

float altura; // variable decimal

/******************************************************************

* Configuración *

******************************************************************/

void setup() {

Serial.begin(9600); // configura la vel. del puerto USB

}

/******************************************************************

* Loop Principal *

******************************************************************/

void loop() {

Serial.println("BIenvenido ... ");

Serial.println("Ingresa tu Nombre : "); //pedir al usuario una entrada

while (Serial.available()==0) { //esperar por la respuesta del usuario

// mientras el usuario no ingrese, no se hace nada

}

miNombre=Serial.readString(); //Leer el Nombre del usuario

Serial.println("Que edad tienes? "); //pedir al usuario una entrada

while (Serial.available()==0) {

}

edad=Serial.parseInt(); //leer la edad del usuario

Serial.println("Que estatura tienes, en metros? "); //pedir una entrada

while (Serial.available()==0) {

}

estatura=Serial.parseFloat(); //leer la estatura

Serial.print("Hola "); //Imprimir un saludo y datos

Serial.print(miNombre);

Serial.print(", tu tienes ");

Serial.print(edad);

Serial.println(" años,");

Serial.print("y tienes ");

Serial.print(estatura);

Serial.println(" mts de alto.");

Serial.println("");

}

// FIN DEL CODIGO

lectura practica2 digitales_arduino_puerto_serial

Technology