Todos los micros van ejecutando un programa, esto es, una serie de instrucciones para realizar la tarea encomendada. Las instrucciones se organizan en renglones, uno debajo del otro. Se ejecuta primero la instrucción de más arriba y luego la siguiente y la siguiente y así sucesivamente, y hay órdenes para alterar esta secuencia de arriba hacia abajo.

Las instrucciones son específicas de cada “familia de microcontroladores” (familia: micros similares que comparten las mismas instrucciones).

El microcontrolador (o microprocesador) entiende un solo lenguaje de programación: el propio, llamado “código máquina”. Es un lenguaje muy rápido, pero bastante difícil de programar. Se dice que el código máquina es un “lenguaje de bajo nivel”: es “cercano” al hardware, pero “lejano” para el humano. Cada familia de micros tiene su propio lenguaje.

Para facilitar las cosas, lo que se puede hacer es, primero programar en otro lenguaje más sencillo de entender para el humano, en un “lenguaje de alto nivel” (se dice que es “código fuente”). Éste se escribe en una computadora, luego con ayuda de la misma se compila, o sea, se traduce el código fuente (escrito por el humano) al lenguaje máquina que es lo único que entiende el micro. Un mismo lenguaje de alto nivel se puede compilar para las distintas familias de micros.

En el caso de Arduino, una vez compilado, con un simple cable USB se transfiere el programa a la placa, al microcontrolador. Otros micros requieren de un hardware extra, un dispositivo programador.

Diagramas de flujo

Conocido un lenguaje de programación, se puede empezar a programar directamente escribiendo las órdenes, o bien, se puede hacer un paso previo que es dibujar el diagrama de flujo. A veces esto ayuda a ser más ordenado.

El diagrama de flujo o flujograma o diagrama de actividades es la representación gráfica de un algoritmo o proceso.

Un diagrama de flujo ayuda a solucionar un problema de forma estructurada. Describe en forma gráfica los pasos de un proceso, permite comprobar visualmente si se han cubierto todos los caminos que el proceso puede tomar.

Con el uso de diagramas de flujo se puede llegar a conseguir que el alumno tenga pensamiento lógico o computacional antes de programar en algún lenguaje.

El diagrama de flujo se lee desde arriba hacia abajo, se compone de símbolos. Cada símbolo representa una operación específica y se conectan entre ellos mediante flechas que indican la secuencia de la operación.

El conector (con un número adentro) se usa para unir partes de un diagrama de flujo que está en más de una hoja.

Diagrama de flujo de una situación cotidiana:

Ejercicio 3

Tachá lo que no corresponda de lo que está separado por barras entre paréntesis. Completá en los espacios en blanco.

1. El micro entiende las instrucciones solo en lenguaje _______________________ que es un lenguaje de (alto/bajo) nivel.
2. Para facilidad de programación, el programador humano suele escribir en lenguaje de (alto/bajo) nivel que es más (fácil/difícil) que el lenguaje propio del micro.
3. Para programar una placa Arduino (se necesita/no se necesita) un dispositivo programador externo.
4. ¿Qué es un diagrama de flujo? Pensá un ejemplo de un diagrama de flujo de una situación cotidiana, por ejemplo, de levantarse y venir a la escuela (hora de alarma, desayuno, elección de medio de transporte).

Tipos de microcontroladores

Existen muchas categorías de microcontroladores, en este apunte se hará una introducción a las placas ARDUINO.

ARDUINO

Arduino es una plataforma de electrónica cuya principal característica es que pretende facilitar el uso de la electrónica y los dispositivos programables y se fundamenta en la filosofía del software libre y el código abierto.

Una placa Arduino tiene todos los elementos necesarios para conectar periféricos a las entradas y salidas de un microcontrolador. Es una placa impresa con los componentes necesarios para que funcione el microcontrolador y su comunicación con una computadora a través de la comunicación serial (USB).

Existen varios tipos de placas Arduino, veremos la placa Arduino UNO que es muy fácil de usar, con muchísima información disponible, y por eso es adecuada para el principiante.

Placa ARDUINO UNO R3

La placa Arduino UNO tiene un microcontrolador Atmega 328p de 8 bits funcionando a una velocidad 16 MHz (16 megaHertz), cuenta con una memoria Flash para almacenar el programa de 32KB (32 kilobytes) de los cuales 0,5KB están ocupados por el bootloader. Tiene 1KB (un kilobyte) de memoria EEPROM y tiene 2KB (dos kilobytes:2048 bytes) de memoria RAM. Son características que, si bien son modestas, resultan más que suficientes para muchas aplicaciones de electrónica.

A modo de comparación, una placa ESP32 es mucho más poderosa, tiene un microprocesador de 32 bits Xtensa LX6 funcionando a 160 MHz o 240 MHz, con 520 KB de memoria RAM y 4 MB (u 8 MB) de memoria FLASH. En el mismo chip (SoC, sistema en un chip) tiene integrado el microprocesador, la memoria Flash, bluetooth, wifi, entre muchas otras cosas (fig. de la derecha).

Alimentación de la placa Arduino

Se recomienda alimentar por USB o bien alimentar con una fuente de entre 6 y 12V aplicada en el jack de alimentación de la placa. También (¡con mucho cuidado!) se puede:

• Aplicar 6-12V entre el pin GND y el pin RAW (pin Vin en Arduino Mini)
• Aplicar 5V (¡regulados y estables!) en el pin 5V (3,3V en ciertos modelos)

Driver para placa Arduino

Para que la computadora reconozca la placa Arduino que se conecta a un puerto USB, hay que instalar antes, por única vez, el driver correspondiente a la placa.

En muchas placas no originales, económicas, chinas genéricas, el driver es USB-SERIAL CH340. Buscalo y descargalo de Internet.

La siguiente figura muestra los pines con mucho más detalle, es altamente recomendable que se imprima en color.

Fuente: bq – www.bq.com, CC BY-SA 4.0, https://bit.ly/3xMD0ur

Aplicación “IDE Arduino”

Para programar Arduino con lenguaje de alto nivel se necesita ejecutar la aplicación Arduino IDE (IDE: entorno de desarrollo). Para instalar por primera vez Arduino IDE siga estos pasos:

• • • • • • • Ir a Microsoft Store
            • Buscar Arduino IDE
            • Instalar
            • Ejecutar

Para programar ARDUINO se debe conectar la placa a un puerto USB de una computadora que tenga el driver correspondiente a la placa y ejecutar la aplicación IDE Arduino, (IDE: entorno de desarrollo).

Se programa en lenguaje C++ (se lee “ce plus plus”). Arduino llama “sketch” al programa. El archivo que contiene el programa tiene extensión .ino. Para que funcione el sketch, el nombre del fichero debe estar en una carpeta con el mismo nombre que el sketch.

Tanto para comenzar a programar como para ver las características del hardware se recomienda visitar https://www.arduino.cc/. Hay infinidad de páginas para consultar, pruebe con https://aprendiendoarduino.wordpress.com/

Arduino y su programación

El siguiente esquema muestra una notebook conectada a una placa Arduino.

Para programar una placa Arduino, los pasos a seguir son:

1. Escribimos el programa (que se llama sketch) en una computadora de escritorio PC o notebook (Figura 1) usando la aplicación Arduino IDE o similar (se escribe el “código fuente”).
2. Escribir sketch
3. Compilar
4. Subir

Luego se compila (Figura 2) con lo que se genera un programa ejecutable para el micro (código máquina). Es decir, a partir del código fuente se obtiene el código máquina. Finalmente se transfiere (Subir) desde la PC a la placa (Figura 3).De esta manera la placa Arduino queda programada con nuestro programa. Se puede desconectar de la PC, alimentar con una fuente, y queda lista para funcionar.

Figura 1

Figura 2

Figura 3

Nota: cuando cargamos un programa en Arduino desde el USB con el IDE, estamos haciendo uso del bootloader, se trata de un pequeño programa que ha sido guardado previamente en el microcontrolador de la placa y que nos permite cargar código sin necesidad de hardware adicional.

Como vemos, ARDUINO se puede programar directamente desde la placa, conectándola con un cable a un puerto USB de una computadora, sin la necesidad de un programador externo; esto encarece el valor de cada placa, pero la hace más accesible al hobbista, ya que no se necesita un programador externo.

Sketch arduino

La estructura mínima de un sketch (programa) de Arduino se compone de dos secciones: setup y loop.

setup() : todo lo que se escriba en esta sección se ejecuta una sola vez al arrancar Arduino. Se pone la configuración de cómo se van a usar los pines, se inicializa la comunicación serie, se establecen los valores iniciales de las variables.

loop(): las instrucciones escritas dentro de la sección “void loop()” se ejecutan infinitas veces hasta que la placa se apague. Es decir, el contenido de “void loop()” se ejecuta desde la 1ª instrucción hasta la última, luego se vuelve a la 1ª instrucción, y así sucesivamente una y otra vez.

El diagrama de flujo de la figura de la derecha explica cómo es la ejecución del código desde el momento que se enciende Arduino, se ve que el setup se ejecuta al principio por única vez, y luego el loop en forma repetitiva, siempre.

Además de setup y loop (son dos “funciones”) un sketch Arduino puede tener también:

Sección de declaración de variables globales: al principio del sketch se declaran las variables que se pueden usar en cualquier parte del sketch. Una variable es un espacio de memoria con un determinado nombre donde se almacena un dato que pueden ir variando (se verá más adelante).

Funciones definidas por el usuario: son un trozo de código que puede ser usado/llamado desde cualquier parte del sketch. A una función se le puede llamar directamente o también se puede pasarle parámetros. Se verá más adelante.

Sintaxis:

Para que el IDE no dé error al momento de compilar, hay que seguir por lo menos las siguientes reglas de sintaxis:

• Un bloque de instrucciones se encierra entre llaves { }.
• El fin de cada instrucción se marca con punto y coma.
• Al momento de escribir el programa tenga especial cuidado en respetar las mayúsculas y minúsculas.
• Comentarios: en el sketch luego de escribir // (dos barras), a su derecha se puede escribir lo que sea, ya no es considerado parte del programa. Se pueden escribir comentarios que son fundamentales para documentar el proyecto.

• Las instrucciones generalmente tienen parámetros que se encierran entre paréntesis, y se separan con comas. Como excepción, la estructura for lleva parámetros separados por punto y coma (y también se usa coma para grupo de parámetros).
• Los espacios entre instrucciones no cuentan. Se puede escribir una sola instrucción por reglón o varias, cada una termina con punto y coma.

El IDE muestra con distintos colores según el tipo de contenido, eso ayuda mucho.

Ejemplo sketch Arduino

En casi todas las placas Arduino hay un pin que tiene conectado un led que se enciende con nivel alto y se apaga con nivel bajo, en muchas placas es en el pin 13. El siguiente sketch hace parpadear el led conectado al pin 13.

Una vez escrito el sketch:

• Hay que compilarlo
• Verificar que no haya dado error, si hay error, corregirlo y volver a compilar
• Conectar la placa Arduino con el cable USB a la computadora
• Apretar Subir
• Verificar abajo que no haya dado mensaje de error
• Si todo va bien, se verá un pequeño led en la placa parpadeando.

Se ejecutan las instrucciones de los renglones de a uno en el siguiente orden: 1,2,3,4,5,6,7,8,9,6,7,8,9,6,7,8,9,6,7,8,9………Vea que lo que se escribe dentro del setup se ejecuta una vez (2), mientras que lo encerrado en loop (6,7,8,9) se ejecuta una y otra vez.

Tiempo de ejecución: cada orden de Arduino demora unos microsegundos en ejecutarse, excepto las de demora.

Ejercicio 4

Tachá lo que no corresponda de lo que está separado por barras entre paréntesis. Completá en los espacios en blanco.

1. En Arduino IDE “compilar” lo que hace es
2. En Arduino IDE cuando se aprieta “Subir” lo que hace es
3. En el sketch Arduino lo que se escriba dentro del setup se ejecuta (una vez al principio / una vez al final / repetitivamente).
4. En el sketch Arduino lo que se escriba dentro del loop se ejecuta (una vez al principio / una vez al final / repetitivamente).
5. Sintaxis: Arduino se usa (punto / punto y coma / barra / coma) para marcar el final de cada instrucción y separarla de la siguiente.
6. Sintaxis: Arduino se usa (punto / punto y coma / dos barras / coma) para marcar el comienzo de un comentario.
7. Sintaxis: en un sketch Arduino da lo mismo si se escribe en mayúsculas que en minúsculas: (verdadero/falso).
8. Sintaxis: todo bloque de instrucciones se encierra entre (llaves / paréntesis / barras).

Instrucciones de programación

Como configurar el modo de trabajo de un pin digital

Los pines digitales del Arduino (0 al 13) son configurables, esto es, se pueden usar o bien como entradas digitales o bien como salidas digitales.

Atención. Los pines 0 y 1 no conviene usarlos ya que requieren especial atención (al momento de programar hay que desconectar el circuito externo que tenga conectado).El pin 13 generalmente tiene un led y una resistencia en la propia placa, se puede usar como salida, en cambio hay evitar usarlo como entrada (se necesita una resistencia pullup externa si o si).

Con la instrucción pinMode se establece como se va a usar un pin, si:

• Como entrada: INPUT
• Como salida: OUTPUT
• Como entrada con la resistencia interna pull-up habilitada: INPUT_PULLUP

pinMode(número de pin, tipo)

Si no se establece con pinMode el modo de funcionamiento de un pin, éste no se puede usar.

Las órdenes pinMode normalmente se escriben dentro de setup(), ya que los pines se deben configurar al principio, y por única vez. Por ejemplo:

Si se conecta un led a un pin, se lo debe definir como una salida digital.

Si se conecta un pulsador a un pin, se lo debe definir como una entrada digital, con dos posibilidades como se vio antes, con o sin resistencia pull-up habilitada.

Cómo establecer el valor de una salida digital

Dado un pin definido como salida digital, con la instrucción digitalWrite se establece su valor, que puede ser a nivel alto HIGH o a nivel bajo LOW (5 voltios ‘o 0 voltios respectivamente).

Hay que especificar el número de pin y el valor HIGH o LOW (también se puede escribir 1 o 0 respectivamente):

Ejemplos:

Eléctricamente hablando, lo que sucede es:

Un nivel ALTO (HIGH, 5 voltios) en el pin 5 de salida, significa que el pin está internamente conectado a la alimentación positiva 5V (proveniente de la conexión USB o de una fuente externa).

Un nivel BAJO (LOW, 0 voltios) en el pin 4 de salida, significa que el pin está internamente conectado a la alimentación negativa GND.

Con digitalWrite se puede ir cambiando las conexiones internas de las salidas, conectado a 5V o a GND.

Esperas o pausas

Con la instrucción delay() se hacen pausas en Arduino. El micro se queda esperando un tiempo predeterminado, sin hacer otra cosa más que esperar. Importante: el programa queda bloqueado mientras dure la pausa hecha con delay(), no se puede hacer otra cosa mientras tanto.

Hay que especificar el tiempo en milisegundos, puede ser un número o una variable (tipo unsigned long, que permite números desde 0 hasta 232-1).

Ejemplo: delay(2000); //espera dos segundos sin hacer nada

Circuito 1: Manejo de dos leds

Quiero controlar el encendido/apagado de dos leds L1 y L2 en forma individual, entonces debo usar un pin de salida para cada led, como en la figura de abajo.

En el pin 3 conecto L1 con su correspondiente resistencia a masa GND, en el pin 4 conecto L2 con su resistencia en serie a masa.

Debemos notar que el cátodo (negativo, terminal más corto) de los leds va al negativo (GND, masa) de la fuente (GND de Arduino), mientras que el ánodo de cada led (terminal más largo) va a un pin a través de una resistencia. 

Recordemos que masa (GND = ground = tierra) está conectado al negativo de la fuente de alimentación de 5 voltios.

Un nivel alto (positivo) en el pin hará que el led encienda.

Los cables de conexión pueden ser cables de conexión macho-macho Dupont. Vienen de distintas longitudes. En este caso se necesita que sean macho-macho, vienen también macho-hembra y hembra-hembra. Estos cables vienen de 10 o 20 o 30 cm. Por su longitud son adecuados para conectar el Arduino con el protoboard (Figura 4). Para hacer conexiones con cables dentro de un protoboard, es más conveniente tener cables de menor longitud, como los siguientes:

Figura 4. Cables Dupont. Fuente: By oomlout – A few Jumper Wires, CC BY-SA 2.0, https://bit.ly/3OhugDp

Se recomienda usar cables negros o azules para ir conectando GND, masa.

¿Cómo quedaría armado el circuito en un protoboard 170 puntos y en un protoboard 830 puntos? Recordemos antes como es la conexión interna de los protoboards:

Una manera de armar el circuito 1 en protoboard mini 170 puntos es la siguiente:

Nota: no se muestra la alimentación del Arduino

Una forma de armar el circuito 1 en protoboard 830 puntos es la siguiente:

Nota: no se muestra la alimentación del Arduino

Los cables negros de la figura van uniendo la masa (GND=ground=tierra=negativo de la fuente) con los cátodos de los leds. Los cables verdes unen las salidas 3 y 4 de Arduino con las resistencias en serie con los leds. El color del cable es indiferente., aunque se recomienda cable negro (o azul) para masa GND. ¿De qué otra forma podría conectar los cables de negativo, cables negros?

Ejemplos de digitalWrite que actúan sobre el circuito 1:

Instrucciones para apagar ambos leds:

El led L1 recibe 0V (LOW) en su ánodo y también 0V en su cátodo (está conectado a GND), entonces el led L1 no se enciende ya que no hay diferencia de potencial entre sus terminales. Pasa lo mismo con el led L2.

Instrucciones para prender el led conectado en el pin 3 y apagar el led conectado al pin 4.

El led L1 recibe nivel alto 5 voltios en su ánodo (a través de una resistencia) y 0 voltios en su cátodo (está conectado a GND), entonces hay diferencia de potencial por lo que enciende. En cambio, el led L2 recibe GND de ambos lados por lo que no prende.

Instrucciones para apagar el led conectado en el pin 3 y prender el led conectado al pin 4.

Instrucciones para prender ambos leds:

Sketch completo 1A para circuito 1:

Las instrucciones se ejecutan de izquierda a derecha, luego pasa al siguiente renglón. En 2 renglones se han escrito 6 instrucciones. Se podría haber escrito una instrucción por renglón, ocupándose entonces 6 renglones.

Si tenés los componentes, armá el circuito y cargá el siguiente sketch. Observá qué sucede.

En las líneas 3 y 4 se definen los pines 3 y 4 como salidas digitales (se escriben en el setup).

En el loop se prende el led L1 durante un segundo, luego lo apaga, y prende el led L2 durante dos segundos, luego lo apaga. Espera 5 segundos, y se vuelve a repetir todo una y otra vez. 

El orden de ejecución es el siguiente: 1,2,3,4,5,6,7,8,9,10,11,12,8,9,10,11,12,8,9….. Lo que está encerrado entre llaves en el setup se ejecuta una sola vez al inicio apenas se enciende Arduino (1 al 5). La parte encerrada en el loop se repite una y otra vez hasta que se apague Arduino (8 al 12).

El diagrama de flujo de los renglones 9, 10,11 (loop), a grandes rasgos, es:

Es una estructura de programación tipo secuencia. Se realizan tres acciones. Primero se hace la primera, luego la siguiente y así.

Luego, como las tres acciones están dentro del loop, se vuelven a repetir una y otra vez.

Con más detalle, los pasos a seguir para prender L1 durante un segundo son:

Ejemplo completo 1B

A continuación, se muestra otro sketch actuando sobre el circuito 1. Veamos qué hace.

Usa constantes en vez de número de pines

Es más ordenado, permite mayor flexibilidad y se identifican mejor los elementos de hardware, si se usan constantes con nombres más significativos que hagan referencia a los pines.

Por ejemplo,

const int L1=3; //significa: constante entera llamada L1 con el valor 3.

const int L2=4; //significa: constante entera llamada L2 con el valor 4.

Estamos diciendo que L1 vale 3 y que L2 vale 4. Luego en el sketch, cada vez que se escriba L1, el compilador IDE lo reemplaza por el número 3, y L2 se reemplaza por 4.

L1 y L2 son los nombres de dos contantes enteras (const int). Constante significa que no va a cambiar de valor durante la ejecución del sketch. Int es el tipo: número entero, la constante puede valer entre -32768 y 32767. Estos números no son “caprichosos”, se forman con 16 bits, un bit de signo y 15 bits para el número sin signo.

El nombre de una constante debe comenzar con una letra, luego letras o números, no debe coincidir con una palabra reservada.

Sintaxis: El nombre de la constante se debe escribir a la izquierda y el valor a la derecha del símbolo =.

Note que const int 3=L1; está mal escrito. Lo correcto es: const int L1=3; . El símbolo igual = significa “asignación”: lo que está a la derecha se asigna a la variable que está a la izquierda.

La definición de constantes se hace al principio, por arriba del setup y del loop para que valga para todo el programa. Si las constantes se escriben dentro del loop, solo sirven dentro del mismo. En cambio, escribiendo las constantes al principio, por afuera del setup y del loop, sirven para ambos (es lo que se quiere). El sketch anterior quedaría así:

Nota: en vez de las líneas 1 y 2, se podría haber escrito: const int L1=3, L2=4; (separadas por coma se pueden definir varias constantes del mismo tipo).

Ejercicio 5

Tachá lo que no corresponda de lo que está separado por barras entre paréntesis. Completar en los espacios en blanco.

1. Las tres formas de pinMode significan:

_______________ define el pin como: ___________________________________

_______________ define el pin como: ___________________________________

_______________ define el pin como: ___________________________________

2. Un pin que tiene conectado un led se define con pinMode como ___________

3. Un pin que tiene conectado un pulsador se define con pinMode como _________________

4. Un pin que tiene conectado un circuito de potencia para comandar un motor hay que definirlo con pinMode como_____________

5. Normalmente las órdenes pinMode se escribe en el (setup/loop)

6. La instrucción pinMode (3,OUTPUT); sirve para _______________________________________.

7. La instrucción digitalWrite(3,HIGH); sirve para ________________________________________ entonces en el pin____ aparece una tensión cercana a (0V/5V).

Escribir las instrucciones para:

Circuito 2

El circuito 2 se muestra en la figura de la derecha. En los pines 8 al 11 se han conectado cuatro leds, cada uno con su correspondiente resistencia en serie para ajustar el valor de la corriente de manera que los leds enciendan con el brillo adecuado. Con un nivel alto de tensión proporcionado por Arduino, enciende cada led, con un nivel bajo, se apaga.

En los pines 2,3,4 se han conectado tres pulsadores que dan nivel bajo al apretarse. Por software, hay que habilitar la resistencia pullup interna en cada pin.

Abajo se muestra una vista bastante realista del circuito armado en protoboard.

Los cables negros son de masa GND, los verdes de salidas hacia los leds, los azules de entradas desde los pulsadores.

Las imágenes corresponden a un pulsador tipo tact switch de 6x6mm. Los de 12x12mm se conectan de la misma manera. Sólo difieren en que son más grandes.

Puede verificar con un tester en modo continuidad cómo funciona cada pulsador (para no ponerlo girado en el protoboard).

Pulsadores “provisorios”

En las entradas definidas con INPUT_PULLUP se pueden colocar pulsadores simulados con simple cables.

En el circuito anterior, en vez de tres pulsadores, se pueden conectar tres cables en los pines 2,3,4. Si se dejan sueltos equivalen a pulsador suelto, mientras que, si se quiere simular pulsador apretado, simplemente se toma el cable correspondiente y se lo conecta momentáneamente a cualquier pin GND disponible en la placa.

En la figura de la derecha se muestra que el pin 2 está a masa (GND), por lo que en la entrada 2 se recibe 0 voltios, 0=LOW=nivel bajo, y equivale a pulsador (con pullup) apretado. Desconectando la punta del cable que va a GND se simula pulsador suelto. Volviéndola a introducir en GND equivale a pulsador apretado.

Atención: no mezcles pulsador y led en la misma rama: el circuito de la figura está mal diseñado. Cada led se conecta a un pin de salida (excepto si se quieren manejar varios al mismo tiempo), cada pulsador a un pin de entrada.

Ejercicio 6

1. Dibujar el esquema de un circuito con Arduino que tenga dos leds L1 y L2 que enciendan con nivel alto, conectados en los pines 6 y 7, y con dos pulsadores P1 y P2 en los pines 8 y 9, con pullup´s internas.
2. Dibujar como quedaría armado el circuito en un protoboard.
3. Hacer un sketch que encienda ambos leds durante 2 segundos, los apague durante 6 segundos, y se vuelva a repetir.
4. Vea como simular los pulsadores P1 y P2 con dos cables.

Estructura if-then-else

La estructura if-then-else decide ejecutar o no ejecutar un trozo de código dependiendo de si se cumple una condición. Se dice que hay una ejecución condicional.

La estructura if-then-else puede usarse de dos modos: incluyendo o  no incluyendo la porción “else”.

Forma if-then (no incluye “else”)

La estructura es if condición acción. Si la condición es verdadera se ejecuta la acción, si no se cumple (la condición es falsa) no se ejecuta la acción (y el programa sigue con la siguiente instrucción que se escribe abajo).

“Si pasa algo entonces hago esto” (y si no pasa, no lo hago y continuo con la siguiente instrucción).

El diagrama de flujo puede ayudar a la comprensión de la estructura IF:

Se ejecutan los siguientes caminos según si la condición sea cierta o falsa:

Forma if-then-else (incluye “else”)

La estructura es if condición acción-1  else acción-2

Si la condición es verdadera se ejecuta la acción por SI, en cambio, si es falsa, se ejecuta la acción por NO.

“Si pasa algo hago esto, si no, hago aquello”

Nota: Si se tienen que ejecutar varias acciones, hay que encerrarlas entre llaves.

EJEMPLO: si A vale 5 entonces poner a nivel bajo la salida 4, sino poner a nivel alto la salida 4.

if (A==5) digitalWrite(4,LOW); else digitalWrite(4,HIGH);

Si A es realmente 5 se ejecuta lo pintado en amarillo:

En cambio, si A no es 5, se ejecuta lo que ahora es amarillo:

Nota: los espacios en blanco no cuentan, por ejemplo, las siguientes órdenes a,b,c son lo mismo, funcionan todas iguales:

Lectura de entradas digitales

La función digitalRead(pin) devuelve el valor que tiene la entrada digital en el pin indicado. Puede devolver nivel alto=”1” o bien nivel bajo=”0”. El nivel de tensión alto o bajo lo fija un circuito externo, el micro se limita a “leer” lo que sucede en el exterior, sin cambiarlo.

El valor que devuelve la función digitalRead se puede asignar a una variable, o bien compararlo en una instrucción if y hacer una cosa u otra según si la entrada está a nivel bajo o a nivel alto.

Si se conecta un pulsador en la entrada, se puede tomar distintas acciones según si está o no apretado.

Supongamos que se tienen definidas las constantes P1, L1 y L2 para los pines de un pulsador y de dos leds. Y queremos hacer lo siguiente: si (if) la entrada P1 está a nivel bajo, entonces poner a nivel alto las salidas L1 y L2 (son dos acciones, hay que ponerlas entre llaves). Si no (else), poner las salidas L1 y L2 a nivel bajo. Una solución:

Debemos notar que se ha definido una “variable” llamada estadoP1 del tipo int (número entero entre -32768 y 32767) que contiene el estado de la entrada digital P1. Vea el uso de las llaves que son necesarias para encerrar más de una orden,

Otra forma es usar el digitalRead directamente en la condición del if sin pasar por una variable:

Un error que no hay que cometer es preguntar por la variable o número de pin sin escribir digitalRead. Si P1 es el número de pin de la entrada, lo siguiente es un error: if (P1==LOW)…, pero cuidado, no es un error de sintaxis, así que al compilar el programa no da error, pero funciona mal.

Otro error es escribir un solo signo igual.

Otro error a evitar: if (digitalRead(P1==LOW)) es incorrecto. Debería ser: if (digitalRead(P1)==LOW)……¿nota la diferencia?

Tampoco tiene sentido usar digitalRead en forma aislada:

digitalRead(P1);

Sketch con el circuito 2

Sobre el circuito 2, se hace uso de la estructura de decisión if-else y de lectura de entradas digitales.

Se hacen dos acciones:

• Se lee la entrada que tiene conectada el pulsador P1, si P1 está apretado se prende el led 1, si no apaga el led 1.
• Si se aprieta el pulsador P2 se prende el led L3, y queda prendido, hasta que se apriete el pulsador P3, momento en que se apaga.

El diagrama de flujo correspondiente al loop() { } es:

Ejercicio 7

1. Escribir las instrucciones de programa para cada caso:

2. Hacer el sketch completo para la siguiente situación:

Se tiene un circuito Arduino con dos leds (L1 y L2) que encienden con nivel alto conectados en los pines 6 y 7, y con tres pulsadores (P1, P2, P3) en los pines 8, 9 y 10 con sus resistencias de pull-up interna.

L1 se maneja con los pulsadores P1 y P2, mientras que L2 se maneja con P3. L1 se enciende al pulsar momentáneamente P1 y se apaga al pulsar momentáneamente P2. En cambio, L2 se mantiene encendido mientras esté presionado P3, y se apaga al soltar P3 y se mantiene apagado mientras P3 esté suelto.

3. Tachá lo que no corresponda de lo que está separado por barras entre paréntesis

1. Para que el micro se entere del estado de un pulsador se usa la orden (digitalRead /digitalWrite/ pinMode/ninguna de las anteriores).
2. La condición en un if se pone entre paréntesis (verdadero/falso)
3. Si hay más de una instrucción a ejecutar en un if, hay que encerrarlas obligatoriamente entre llaves (verdadero/falso).
4. Para preguntar por igual se pone el signo =. Por ejemplo, para preguntar si A es 3 se pone (A=3) (verdadero/falso).

Operación lógica OR entre dos o más condiciones

Se tienen dos pulsadores P2 y P3 que entregan nivel bajo cuando están apretados y un led L3 que se prende con nivel alto.

Se quiere que si el pulsador P2 está apretado o si el pulsador P3 está apretado (o ambos) prenda L3, sino que se apague. Hay que usar la función lógica OR (o) que se escribe || como se muestra a continuación.

También se podría haber escrito así:

Por lo menos va un paréntesis abarcando toda la condición completa if (). También se puede poner () para cada condición individual. Ver jerarquía de las operaciones.

Operación lógica AND entre dos o más condiciones

Si se quiere preguntar por si el pulsador P2 está apretado y también si el pulsador P3 está apretado, hay que usar la función lógica AND (y) que se escribe && como se mues10) tra a continuación.

Se prende el led L2 si ambos pulsadores P2 y P3 están al mismo tiempo apretados, si no, lo apaga.

Cuidado: && es para unir condiciones con AND. Si se quiere realizar una acción y otra, por ejemplo, poner a HIGH los pines 3 y 4, lo que se hace es una secuencia, primero se pone a HIGH el pin 3 y luego el pin 4. No se confunda: no hay que poner && (y=and) entre cada digitalWrite.

Comandar más potencia con arduino

Con Arduino para manejar circuitos de más corriente y/o más tensión se pueden conectar relés a Arduino.

Manejo de una lámpara de 220VCA con Arduino a través de un módulo de relé

Se usa un módulo de un relé que tiene los contactos normal abierto NA (NO en inglés) y NC para encender/apagar relativamente grandes corrientes y cargas mediante una pequeña señal de control digital de corriente continua.

En este caso se va a controlar el encendido y apagado de una lámpara de 220VCA a través de Arduino.

Se conecta la lámpara a la alimentación de 220V pasando por un interruptor (cables rojos gruesos), que es el que está entre los bornes normal abierto NA (NormalOpen en inglés) y C (común) del relé del módulo, como se muestra en la figura.

Por otro lado, hay que conectar positivo de 5V (VCC) y negativo (GND) al módulo para alimentarlo. Y se controla poniendo nivel alto/bajo en el terminal IN del módulo. Por eso se conecta IN a una salida digital del Arduino (cable verde), en este caso, al pin 9.

Los bornes del contacto del relé están aislados de la parte que se conecta a Arduino, así que el vivo de 220V no llega a Arduino.

IMPORTANTE: al hacer conexiones a 220VCA (220 voltios de corriente alterna) no pueden cometerse errores. En caso de error, Ud. puede electrocutarse o quemar el Arduino. Extreme las precauciones.

Ejemplo de código

El siguiente código enciende y apaga la lámpara en intervalos de 10 segundos. Un nivel alto en el pin 9 hace conmutar el relé y entonces se cierra el circuito de la lámpara de 220V.

Ejercicio 8

1. Dibujar un circuito con Arduino y tres módulos de relés que controle a tres lámparas L1, L2, L3 de 220VCA. Tome como referencia el siguiente dibujo.

2. Hacer un sketch que encienda: L1 y L2 durante 10 segundos, L2 y L3 durante 10 segundos, L3 y L1 durante 10 segundos, (la otra lámpara apagada), luego vuelta a repetir.

3. Explique cómo circulan las corrientes por el circuito cuando se enciende la lámpara L2. ¿Qué voltajes hay?

Ejercicio 9

Completar con una cruz donde corresponda V/F (verdadero/falso)

ANEXO A: Más temas

Otra forma de definir los nombres de los pines:

Al principio del sketch se puede poner, por ejemplo:

#define L1 8

Lo que hace el compilador es reemplazar por 8 cada vez que aparezca L1. Esto reemplaza a const int L1=8; (tiene el mismo efecto).

No debemos poner el signo igual entre L1 y 8, tampoco poner signo punto y coma al final.

Esto es erróneo: 

Conexión de un led a una salida de un micro de manera que encienda con nivel bajo

Otra forma de conectar un led a una salida es como se muestra en la figura.

Con la salida a “1” el led no prende ya que recibe 5V de ambos lados, entonces no hay diferencia de potencial, por lo tanto, no hay corriente.

Con la salida a “0” el led prende ya que recibe cero voltios por el lado del micro y cinco voltios por el otro lado.

Lectura de una salida

Se puede leer el valor de una salida (pin que está configurado como salida) con digitalRead(pindesalida). Al ejecutarse digitalRead no se modifica el valor de la salida, solo se consulta preguntando si está a nivel alto o bajo.

Por ejemplo, estando definido en el setup(): pinMode(3, OUTPUT), se puede hacer:

If (digitalRead(3)==LOW)…… que significa: si la salida 3 está a nivel bajo, entonces hago……

Otra forma:

Circuito 1B (variante del circuito 1)

En lugar de conectar leds en los pines 3 y 4, se ha conectado un circuito de un transistor al corte y saturación para comandar una tira de leds de no más de un metro de longitud, con el pin 3, y se ha conectado un módulo relé para controlar una lámpara de 220 VCA con el pin 4.

Si se carga el sketch ejemplo 1b, veremos encender y apagar la lámpara y la tira de leds. Vemos que el mismo software actúa sobre diferente hardware.

Circuito 1C

A un relé se puede conectar un contactor que sirve para controlar el encendido y apagado de un motor trifásico. Vemos que colocando circuitos de potencia podemos encender y apagar dispositivos de más potencia (más intensidad de corriente y/o tensión).

Leds en serie o en paralelo. No se puede prenderlos de a uno

Si se conectan dos leds en serie con una resistencia en el mismo pin, o bien se encienden los dos leds juntos, o bien se apagan los dos juntos, o sea, no se puede hacer un control individual. Lo mismo sucede si se conectan dos leds en paralelo.

digitalWrite(11,HIGH); //prende L1 y L2 al mismo tiempo,

digitalWrite(11,LOW); //apaga L1 y L2,

pero no se puede prender solo L1 o solo L2.

Pines de entradas analógicas

Los 6 pines correspondientes a las entradas analógicas A0..A5 del Arduino UNO están preconfigurados de esa manera. Sin embargo, también se pueden usar como entradas y salidas digitales. Se pueden llamar A0..A5 y también pines 14..19.

En caso de que querer usarlos como entradas digitales, no se disponen de resistencias pullup internas, así que, de ser necesarias, habrá que agregarlas externamente (10K).

Ejercicio 14

Dibujar el hardware y confeccionar el sketch para controlar un semáforo de dos manos. Hay 6 lámparas LR1, LA1, LV1, LR2, LA2, LV2 (rojo, amarillo, verde, dos semáforos) de 220VCA que se controlan con 6 módulos relés. El rojo se prenderá durante 20 seg, el amarillo 1 seg y el verde 20 seg.