Submódulo2 -Implementa circuitos en plataformas modulares con microcontroladores

Una plataforma entrenadora de microcontroladores es, a grandes rasgos, un micro controlador específico o una variedad de ellos, conectados a una serie de periféricos externos que permiten simular, en la misma plataforma, las diferentes operaciones a realizar con el propio µC.

Arduino es una plataforma para prototipado de electrónica basada en hardware y software libre y fácil de utilizar. Podemos construir circuitos electrónicos y programarlos con esta placa.

Realmente lo que estamos haciendo es programar un microcontrolador, estos dispositivos electrónicos programables nos rodean en nuestro día a día, en el coche, nuestra casa, el trabajo, etc…

Las principales características que podemos encontrar en nuestra placa de Arduino UNO son las siguientes:

• El microcontrolador es un circuito integrado programable capaz de realizar operaciones matemáticas complejas a gran velocidad.

• La alimentación de una placa de Arduino es mediante el puerto USB mientras se está programando. Una vez programado podemos desconectarlo del ordenador y que trabaje de forma autónoma y se alimenta Arduino mediante una fuente de alimentación o pila de 9V.

• Tanto las entradas como las salidas dotan al sistema de información y realizan diferentes actuaciones.

Arduino contiene la siguiente distribución de pines:

• Disponemos de 14 pines digitales que pueden ser configurados como entradas o salidas, de los cuales (serigrafiadas con el símbolo ~) pueden ser utilizados como señales digitales PWM 6 pines.

• Igualmente disponemos de 6 pines analógicos serigrafiadas desde A0 hasta A5 para las entradas analógicas.

• También disponemos de 3 pines GND para conectar a tierra nuestros circuitos. • Y por último 2 pines de

alimentación de 5V y 3.3V respectivamente.

Sensores

Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas, llamadas variables de instrumentación, y transformarlas en variables eléctricas.

• Las variables de instrumentación pueden ser por ejemplo: temperatura, intensidad lumínica, distancia, aceleración, inclinación, desplazamiento, presión, fuerza, torsión, humedad, movimiento, pH, etc.

• Una magnitud eléctrica puede ser una resistencia eléctrica (como en una RTD), una capacidad eléctrica (como en un sensor de humedad o un sensor capacitivo), una tensión eléctrica (como en un termopar), una corriente eléctrica (como en un fototransistor), etc.

Un sensor nos va a poder medir/leer las variables ambientales de nuestro entorno para poder tomar decisiones en función de los cambios en el entorno.

Actuadores

Un actuador es un dispositivo capaz de transformar energía hidráulica, neumática o eléctrica en la activación de un proceso con la finalidad de generar un efecto sobre elemento externo. Este recibe la orden de un regulador, controlador o en nuestro caso un Arduino y en función a ella genera la orden para activar un elemento final de control como, por ejemplo, una válvula.

Existen varios tipos de actuadores como son:

• Electrónicos • Hidráulicos • Neumáticos • Eléctricos • Motores • Bombas

En determinadas ocasiones, necesitamos un “driver” o manejador para poder mandar órdenes desde Arduino.

• Recordad que los pines de Arduino solo pueden manejar un máximo de 40mA y recomendable usar 20mA de forma continúa.

• Recordar que Arduino solo puede manejar un total de 200 mA de salida. Es decir que la corriente máxima que admite Vcc y GND son 200 mA.

Un actuador nos permite interactuar con el entorno.

Periféricos

Periférico es la denominación genérica para designar al aparato o dispositivo auxiliar e independiente conectado a la unidad central de procesamiento o en este caso a Arduino. Se consideran periféricos a las unidades o dispositivos de hardware a través de los cuales Arduino se comunica con el exterior, y también a los sistemas que almacenan o archivan la información, sirviendo de memoria auxiliar de la memoria principal.

Ejemplos de periféricos:

• Pantallas LCD • Teclados • Memorias externas • Cámaras • Micrófonos • Impresoras • Pantalla táctil • Displays numéricos • Zumbadores • Indicadores luminosos, etc…

En ocasiones para usar un periférico con Arduino, necesitamos un “driver” o manejador para poder mandar órdenes desde Arduino.

Shields Arduino

Las Shields son placas de circuitos modulares que se montan unas encima de otras para dar funcionalidad extra a un Arduino. Esta Shields son apilables. Existen miles de Shields en función de lo que necesitemos: http://shieldlist.org/

Shields Educativos

Uno de los problemas que se encuentran a la hora de impartir un curso de electrónica y programación con Arduino en los colegios es la dificultad de comprobar los montajes de los circuitos de los alumnos. Sobre todo cuando se trata de los más pequeños. Existen Shields educativos que facilitan el trabajo en el aula. Son Shields que o bien permiten conectar y listo o bien tienen varios componente integrados que evitan hacer cableados y no tener que saber de electrónica.

Shield Educativo Multifunción

Echidna

Echidna Shield es un proyecto Open Source dirigido a facilitar el aprendizaje de la programación de sistemas físicos en los últimos cursos de Primaria y en Secundaria. Con este fin se ha diseñado un escudo para Arduino, pensando en su uso con entornos visuales de programación. El escudo está apoyado en una guía educativa con propuestas de actividades para el aula.

Makey Makey

Makey Makey es una placa de circuito impreso con un microcontrolador ATMega32u4 que ejecuta el firmware de Arduino Leonardo. Utiliza el protocolo de dispositivos de interfaz humana (HID) para comunicarse con el ordenador, y puede enviar pulsaciones de teclas, clics del mouse y movimientos. Para detectar un circuito cerrado en los pines de entrada digital, usa switches de alta resistencia para que sea posible cerrar un interruptor incluso a través de materiales como la piel, hojas y play-doh. Usa una resistencia de pull-up de 22 mega ohms. Esta técnica atrae el ruido en la entrada, pero usa promediador para reducir el ruido mediante software, ahorrando dinero en el filtrado por hardware. Hay seis entradas en la parte frontal de la placa, que se pueden unir a través de conectores tipo cocodrilo o cualquier otro método que se te ocurra. Hay otras 12 entradas en la parte posterior, 6 para las teclas del teclado y 6 para el movimiento del mouse, a las que se puede acceder usando jumpers, clips o conectores de tipo cocodrilo de forma creativa alrededor de los conectores.

Picuino Picuino es una plataforma de hardware y software que facilita el desarrollo sencillo de proyectos interactivos.

NanoPlayBoard NanoPlayBoard es un Shield educacional para Arduino Nano hecha en Almería. NanoPlayBoard tiene una librería ya configurada en la que está todo el código necesario para llevar a cabo esos experimentos básicos.

Little Bits

littleBits es una empresa con sede en la ciudad de Nueva York que hace una biblioteca de código abierto de electrónica modular, que consiste en juntar piezas con pequeños imanes para la creación de prototipos. El objetivo de la compañía es democratizar el hardware de la misma forma que el software y la impresión se han democratizado. La misión de littleBits es “poner el poder de la electrónica en manos de todos y analizar tecnologías complejas para que cualquiera pueda construir, crear prototipos e inventar”.

El kit de codificación little littlebits Arduino permite a los usuarios comenzar a crear inventos que se comunican con el software (Processing, MaxMSP, etc.), con el apoyo de instrucciones paso a paso, recursos útiles en línea y 8 bocetos de muestra (código prefabricado) incluido. Aprende las habilidades del futuro: codificación, ingeniería y creatividad.

Entender Arduino Arduino no solo es una placa azul muy popular con la que hacer semáforos, encender leds o usado en las impresoras 3D. Arduino va mucho más allá y vamos a verlo en este capítulo.

Primer Arduino:

Arduino simplifica el trabajo con microcontroladores y ofrece las siguientes ventajas: barato, multiplataforma, entorno de programación sencillo, software libre y extensible mediante librerías en C++, hardware libre y extensible.

Al trabajar con Arduino, se manejan conceptos de diferentes tecnologías que a priori no tienen nada que ver entre ellos pero que los unifica: electrónica digital y analógica, electricidad, programación, microcontroladores, tratamiento de señales, protocolos de comunicación, arquitectura de procesadores, mecánica, motores, diseño de placas electrónicas etc…

HW Arduino

El HW de Arduino es básicamente una placa con un microcontrolador. Un microcontrolador (abreviado µC, UC o MCU) es un circuito integrado programable, capaz de ejecutar las órdenes grabadas en su memoria. Está compuesto de varios bloques funcionales, los cuales cumplen una tarea específica. Un microcontrolador incluye en su interior las tres principales unidades funcionales de una computadora: unidad central de procesamiento, memoria y periféricos de entrada/salida.

Características de un Microcontrolador:

• Velocidad del reloj u oscilador • Tamaño de palabra • Memoria: SRAM, Flash, EEPROM, ROM, etc. • I/O Digitales • Entradas Analógicas • Salidas analógicas (PWM) • DAC (Digital to Analog Converter) • ADC (Analog to Digital Converter) • Buses • UART • Otras comunicaciones.

Arduino dispone de una amplia variedad de placas y Shields para usar dependiendo de nuestras necesidades.

Un shield es una placa compatible que se puede colocar en la parte superior de los arduinos y permite extender las capacidades del Arduino.

Qué es Arduino

Arduino es un dispositivo programable como es un ordenador, un móvil, un tablet o un PLC, es decir, se puede cambiar el comportamiento o la funcionalidad del dispositivo mediante unas órdenes en un lenguaje concreto que es capaz de ser interpretado por el dispositivo y seguir esas órdenes con el fin de realizar una tarea automática o resolver un problema.

En el caso de los ordenadores, móviles o tablets, la entrada de los datos y la interacción con las personas es a través del teclado, ratón, pantalla táctil o incluso la posición GPS o la inclinación del móvil y la salida de los resultados o visualización por las personas es a través de la pantalla. Sin embargo un PLC/Autómata o un Arduino, la interacción con el humano o con el entorno no está tan limitada como en el caso de un Ordenador o un tablet, los interfaces de comunicación (entrada/salida) son ilimitados y consisten en ciertos componentes hardware (transductores) que convierten los cambios de energía producidos por las alteraciones en el medio físico, en señales eléctricas entendibles por las máquinas. Por lo tanto las entradas a estos dispositivos son los sensores y las salidas son los actuadores que convierten las señales eléctricas en magnitudes físicas. Arduino es un dispositivo programable que nos permite interactuar con el entorno, pudiendo leer la temperatura de una sala, el deslizamiento de una rueda o el ángulo de inclinación de una plataforma y escribir/actuar sobre el encendido de una caldera, los frenos del coche o un motor para nivelar una plataforma.

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

Arduino es una plataforma abierta que facilita la programación de un microcontrolador. Los microcontroladores nos rodean en nuestra vida diaria, usan los sensores para escuchar el mundo físico y los actuadores para interactuar con el mundo físico. Los microcontroladores leen sobre los sensores y escriben sobre los actuadores.

“Actualmente todo lo que nos rodea en la vida es digital (entendido como hacer operaciones matemáticas complejas y comunicar con otros dispositivos), cualquier cosa lleva un microchip, desde el

microondas a un coche. Arduino lleva uno de esos microchips y te permite aprender a manejar cómo funciona el mundo en el que vivimos hoy en día y cómo interactúa el hombre con el mundo digital. Arduino es la puerta hacia tomar control de cómo funcionan las cosas actualmente y en el futuro. Así que encender el ordenador y empezar a programar.”

Arduino es una tecnología que tiene una rápida curva de aprendizaje con básicos conocimientos de programación y electrónica, que permite desarrollar proyectos en el ámbito de las Smart Cities, el Internet de las cosas, dispositivos wearables, salud, ocio, educación, robótica, etc…:

¿Para qué sirve Arduino?

Arduino se puede utilizar para desarrollar elementos autónomos, conectándose a dispositivos e interactuar tanto con el hardware como con el software. Nos sirve tanto para controlar un elemento, pongamos por ejemplo un motor que nos suba o baje una persiana basada en la luz existente es una habitación, gracias a un sensor de luz conectado al Arduino, o bien para leer la información de una fuente, como puede ser un teclado, y convertir la información en una acción como puede ser encender una luz o mostrar por un display lo tecleado.

Con Arduino es posible automatizar cualquier cosa para hacer agentes autónomos (si queréis llamarles Robots también). Controlar luces y dispositivos, o cualquier otra cosa que se pueda imaginar, es posible optar por una solución basada en Arduino. Especialmente en desarrollos de dispositivos conectados a Internet, Arduino es una solución muy buena.

Raspberry Pi:

Es un ordenador del tamaño de una tarjeta de crédito. ... Consiste en una placa base que soporta distintos componentes de un ordenador como un procesador ARM de hasta 1500 MHz, un chip gráfico y una memoria RAM de hasta 8 GB

GPIO:

PRÁCTICAS CON ARDUINO

NOTA:

. Si tienes conectividad a internet y algún dispositivo electrónico para trabajar como celular o computadora podrás hacer todas tus prácticas trabajando en línea con el software Tinkercad el cual encontraras con la siguiente liga https://www.tinkercad.com/

. Si no tienes conectividad frecuente a internet pero si dispones de un celular, podrás descargar con play store la aplicación de Arduino, la cual no te consumirá datos al momento de usarla.

. Si no cuentas con internet ni equipo electrónico no te preocupes, podrás crear tus códigos y realizar tus prácticas tomando notas en tu libreta.

Práctica 1:

1. Intermitente Se trata de realizar un

ejercicio básico que

consiste en encender y

apagar un led que

conectamos en el PIN 13

de Arduino que lo

configuramos como

salida. El tiempo de

encendido y apagado es

de 1 segundo.

Obsérvese que se ha

colocado el diodo led sin

resistencia en serie dado que el PIN13 de Arduino ya lleva incorporada una resistencia interior, en el caso de

colocar el diodo LED en otra salida deberíamos colocar una resistencia de al entre 220 y 500 ohmios

dependiendo del consumo de corriente del diodo

Programa

int ledPin = 13; // Definición de la salida en el PIN 13

void setup() //Configuración

{

pinMode(ledPin, OUTPUT); // designa la salida digital al PIN 13

}

void loop() // bucle de funcionamiento

{

digitalWrite(ledPin, HIGH); // activa el LED

delay(1000); // espera 1 seg. (Tiempo encendido)

digitalWrite(ledPin, LOW); // desactiva el LED

delay(1000); // espera 1 seg. (Tiempo apagado)

}

PRÁCTICA 2. PULSADOR

int ledPin= 13; // choose the pin for the LED

int inPin= 5; // choose the input pin (for a pushbutton)

int val= 0; // variable for reading the pin status

void setup() {

pinMode(ledPin, OUTPUT); // declare LED as output

pinMode(inPin, INPUT); // declare pushbutton as input

}

void loop(){

val= digitalRead(inPin); // lee valor de entrada

if(val== HIGH) { // chequea si el valor leído es “1” (botón presionado)

digitalWrite(ledPin, LOW); // pone el LED en OFF

} else{

digitalWrite(ledPin, LOW); // parpadea el LED

delay(200);

digitalWrite(ledPin, HIGH);

delay(200);

}

}

/PRÁCTICA 3 Encendido y apagado de 3 LEDs

int ledPin1 = 6; // Define las salidas de los LED´s

int ledPin2 = 7;

int ledPin3 = 8;

void setup() { // Configura las SALIDAS

pinMode(ledPin1, OUTPUT); // declarar LEDs como SALIDAS

pinMode(ledPin2, OUTPUT);

Prácticas con Arduino Nivel I 9

pinMode(ledPin3, OUTPUT);

digitalWrite(ledPin1, LOW); // Apaga los LEDs

digitalWrite(ledPin2, LOW);

digitalWrite(ledPin3, LOW);

}

void loop(){ //Bucle de Funcionamiento

digitalWrite(ledPin1, HIGH); // Apaga y enciende los leds cada 200 ms

delay(200);

digitalWrite(ledPin1, LOW);

digitalWrite(ledPin2, HIGH);

delay(200);

digitalWrite(ledPin2, LOW);

digitalWrite(ledPin3, HIGH);

delay(200);

digitalWrite(ledPin3, LOW);

}

PRÁCTICA 4* Pulsador2 * --------

*

* Detecta si el botón ha sido presionado o no

* y enciende el LED en consecuencia.

*

*

*/

int ledPin = 13; // PIN del LED

int inPin = 10; // PIN del pulsador

int value = 0; // Valor del pulsador

void setup() {

pinMode(ledPin, OUTPUT); // Inicializa el pin 13 como salida digital

pinMode(inPin, INPUT); // Inicializa el pin 10 como entrada digital

}

void loop() {

value = digitalRead(inPin); // Lee el valor de la entrada digital

digitalWrite(ledPin, value);

}

PRÁCTICA 5 /* Sensor de Inclinación * -----------

* Detecta si el sensor ha sido inclinado o no y

* enciende la luz en consecuencia. Ten en cuenta que

* al utilizar la "activación a nivel bajo" (mediante

* una resistencia de pulls-up) la entrada se encuentra

* a nivel bajo cuando el sensor se activa.

*

*/

int ledPin = 13; // PIN del LED

int inPin = 7; // PIN del pulsador

int value = 0; // Valor del pulsador

void setup() {

pinMode(ledPin, OUTPUT); // Inicializa el pin 13 como salida digital

pinMode(inPin, INPUT); // Inicializa el pin 7 como entrada digital

}

void loop() {

value = digitalRead(inPin); // Lee el valor de la entrada digital

digitalWrite(ledPin, value);

}

PRÁCTICA 6 /* Potenciómetro * ------------------

*

* enciende y apaga un LED conectado al pin digital #13;

* La cantidad de tiempo que el LED parpadeará depende del

* valor obtenido mediante analogRead(). En este caso al pin 2 *

*

*

*/

int potPin = 2; // seleccionar el pin de entrada analógico para el potenciómetro

int ledPin = 13; // seleccionar el pin de salida digital para el LED

int val = 0; // variable para almacenar el valor capturado desde el sensor

void setup() {

pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida

}

void loop() {

val = analogRead(potPin); // lee el valor del sensor

digitalWrite(ledPin, HIGH); // enciende LED

delay(val); // detiene el programa por un tiempo “val”

digitalWrite(ledPin, LOW); // apaga el LED

delay(val); // detiene el programa por un tiempo “val”

}

PRÁCTICA 7 /* El coche fantástico int pinArray[] = {2, 3, 4, 5, 6, 7}; // Define el array de pines

int count = 0; // Contador

int timer = 100; // Temporizador

void setup(){

for (count=0;count<6;count++){ // Configuramos todos los PIN-es

pinMode(pinArray[count], OUTPUT);

}

}

void loop() { // Enciende y apaga secuencialmente los LED-s

for (count=0;count<6;count++) { // utilizando la secuencia de control for(;;)

digitalWrite(pinArray[count], HIGH); // Recorrido de ida

delay(timer);

digitalWrite(pinArray[count], LOW);

delay(timer);

}

for (count=5;count>=0;count--) {

digitalWrite(pinArray[count], HIGH); // Recorrido de vuelta

delay(timer);

digitalWrite(pinArray[count], LOW);

delay(timer);

}

}

Práctica 8 /* Estrella fugaz * Este programa es una variante del ejemplo del coche fantástico. Muestra mediante

* un loop una estrella fugaz que es dibujada en una línea de LED-s

* directamente conectados a la placa Arduino. Puedes controlar la velocidad a la que

* la estrella se mueve gracias a una variable llamada "waitNextLed". También

* puedes controlar la longitud de la cola de la estrella a través de la variable "tail

// Variable declaración

// Declaración de los PIN-es mediante un array

int pinArray [] = { 2,3,4,5,6,7,8,9,10,11,12 };

int controlLed = 13; // LED de control

int waitNextLed = 100; // Tiempo antes de encender el siguiente LED

// Número de LED-s que permanecen encendidos antes de empezar a apagarlos para

//formar la cola

int tailLength = 4;

// Número de LED-s conectados (que es también el tamaño del array)

int lineSize = 11;

void setup() // Configuración de los PIN-es como salida digital

{

int i;

pinMode (controlLed, OUTPUT);

for (i=0; i< lineSize; i++)

{

pinMode(pinArray[i], OUTPUT);

}

}

Práctica 9 /* Programa Contador * Detecta si el botón conectado a la entrada 7 ha sido presionado y enciende el LED

* Envía al PC el valor de la variable de cuenta ""Contador" vía puerto serie.

int LED = 13;

int Boton = 7;

int valor = 0;

int contador = 0;

int estadoanteriorboton = 0;

void setup()

{

beginSerial(9600); // Configura velocidad de transmisión a 9600

Prácticas con Arduino Nivel I

30

pinMode(LED, OUTPUT); // inicializa como salida digital el pin 13

pinMode(Boton, INPUT); // inicializa como entrada digital el 7

}

void loop()

{

valor = digitalRead(Boton); // lee el valor de la entrada digital pin 7

digitalWrite(LED, valor);

if(valor != estadoanteriorboton){

if(valor == 1){

contador++;

printInteger(contador);

serialWrite(10);

serialWrite(13);

}

}

estadoanteriorboton = valor;

}

Práctica 10 /* Programa Contador de 0 a 10 * Detecta si el botón conectado a la entrada 7 ha sido presionado y enciende el LED

int LED = 13;

int Boton = 7;

int valor = 0;

int contador = 0;

int estadoanteriorboton = 0;

void setup(){

beginSerial(9600); // Configura velocidad de transmisión a 9600

Prácticas con Arduino Nivel I

34

pinMode(LED, OUTPUT); // inicializa como salida digital el pin 13

pinMode(Boton, INPUT); // inicializa como entrada digital el 7}

void loop(){

valor = digitalRead(Boton); // lee el valor de la entrad digital pin 7

digitalWrite(LED, valor);

if(valor != estadoanteriorboton){

if(valor == 1){

contador++;

printInteger(contador);

serialWrite(10);

serialWrite(13);

if (contador==10) { // Limita la cuenta al valor 10

contador=0;}}}

estadoanteriorboton = valor;}

Práctica 11 /* Entrada Analógica */ int potPin = 5; // selecciona el pin de entrada para colocar el potenciómetro

int val = 0; // variable para almacenar el valor leído por la entrada analógica

void setup() {

beginSerial(9600);

}

void loop() {

val = analogRead(potPin); // lee el valor del canal de ENTRADA analógica

printInteger(val); // Envía al PC el valor analógico leído y lo muestra en pantalla

serialWrite(10);

delay(100);}

Práctica 12 Simulación de luz de vela

* Saca por una de las salidas del puerto PWM un valor aleatorio que activa un LED

int ledPin = 9; // selecciona el puerto PWM

int val = 0; // define y pone a cero la variable "brillo"

int delayval = 0; // define el intervalo de cambio de valor de salida

void setup() {

randomSeed(0); // inicializa el generador de números aleatorios

pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9

}

void loop() {

val = random(100,255); // genera un número aleatorio entre 100 y 255 que asigna

a la variable val

analogWrite(ledPin, val); // envía ese valor a la salida pin 9

delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo

asigna a la variable de temporización

delay(delayval); // espera un tiempo delayval medido en milisegundos

}

Ing Sergio Alberto De León Maldonado Estado: Nuevo León