UNIDAD DIDACTICA ARDUINO - · PDF fileProgramar un seguidor solar con 3 sensores de luz y...

UNIDAD DIDACTICA ARDUINO. ROBOTICA 4 ESO

Versión: 1.0

Creado por: Guillermo Pacheco

INDICE

INDICE ........................................................................................................................................... 2

PRESENTACIÓN ........................................................................................................................... 3

ESQUEMA DE FUNCIONAMIENTO DE UN PROYECTO CON ARDUINO. ........................ 3

CARACTERÍSTICAS GENERALES DE LA PLACA ................................................................. 4

Vista general. ............................................................................................................................... 4

Componentes: .............................................................................................................................. 5

EL ENTORNO DE PROGRAMACIÓN DE ARDUINO .............................................................. 6

Vista general ................................................................................................................................ 6

Estructura básica de un programa de Arduino ............................................................................ 7

ACCESORIOS DE ARDUINO: SENSORES Y ACTUADORES ................................................ 8

Sensores ....................................................................................................................................... 8

Funcionamiento de los sensores. ............................................................................................. 8

Actuadores ................................................................................................................................. 10

COMUNICACIONES ................................................................................................................... 11

Conector USB ........................................................................................................................... 11

Pines de comunicación .............................................................................................................. 11

Librería serial ........................................................................................................................ 11

PASOS PARA LA REALIZACIÓN Y EJECUCIÓN DE UN PROGRAMA EN ARDUINO: .. 12

ACTIVIDADES ............................................................................................................................ 18

Actividad 1: ............................................................................................................................... 18

Actividad 2: ............................................................................................................................... 19

PROYECTOS CON ARDUINO ................................................................................................... 20

Ejercicio 1: Encendido de diodo a través de pin 13. ................................................................. 21

Cableado ................................................................................................................................ 21

Estructura del programa ........................................................................................................ 22

Elementos del programa utilizados en este ejercicio ............................................................ 22

Otros elementos que aparecen ............................................................................................... 23

Ejercicio 2: Encender 5 leds imitando luces del coche de la serie “El coche fantástico” ......... 24


Ejercicio 3: Encender led apretando interruptor exterior .......................................................... 25


Elementos del programa utilizados en este ejercicio: ........................................................... 27

Ejercicio 4. Encender 1 led por medio de la función termostato .............................................. 28


Elementos del programa utilizados en este ejercicio ............................................................ 29

Ejercicio 5. Programar un seguidor solar con 3 sensores de luz y activar cuatro leds diferentes

según posición de la luz. ........................................................................................................... 31

Orientación Elevación ........................................................................................................... 32

Elementos utilizados ............................................................................................................. 32


PRESENTACIÓN

Arduino es una plataforma de hardware y software de código abierto (opensource), basada en

una sencilla placa con entradas y salidas, tanto analógicas como digitales, en un entorno de

desarrollo que está basado en el lenguaje de programación muy similar al C y al Java como es

Processing. Este dispositivo, que conecta el mundo analógico con el digital, esta diseñado para

que de forma fácil y sin tener que bajar a bajo nivel podamos prototipar y construir robots y

artilugios electrónicos.

ESQUEMA DE FUNCIONAMIENTO DE UN PROYECTO CON ARDUINO.

El ciclo de vida de un programa. El siguiente esquema muestra el ciclo de vida de un proyecto

realizado con Arduino. Los pasos que normalmente se dan en el son los siguientes:

1. El usuario creara un conjunto de instrucciones (o programa) que quiere que se ejecuten

en la placa controladora. Dicho conjunto de instrucciones será escrito con ayuda de un

ordenador

2. El conjunto de instrucciones se enviaran a la controladora (Arduino) vía puerto serie

(USB) para su ejecución

3. Las instrucciones se ejecutaran en Arduino

4. Desde Arduino se podrán leer datos de sensores conectados a la placa

5. Desde Arduino se podrán activar actuadotes conectados a la placa

6. Para monitorizar la ejecución del programa se podrá enviar información al ordenador (vía

USB) para su visualización.

SENSORES - Temperatura

- Sonido

- Tacto - Distancia

- infrarrojos

- humedad

- etc..

ACTUADORES - Servos

- Motores

- Leds

- Pantalla LC, TFT, etc.

- Sonidos

- Envío de señales digitales

- Etc..

ARDUINO

1. El usuario crea el programa

en un ordenador mediante un

entorno de programación

2. El programa se envía a la

controladora Arduino para su

ejecución

3. El programa se

ejecuta en Arduino

4. El programa lee

datos de sensores

5. El programa

pone en marcha

los actuadores

6. El programa envía datos al

ordenador para su monitorización

CARACTERÍSTICAS GENERALES DE LA PLACA

Vista general.

A continuación se muestra una fotografía de la placa con una descripción de cada uno de sus

componentes

Figura 1. Aspecto de la placa Arduino UNO.

Componentes:

- El microcontrolador ATMEGA 328p. Se trata de un chip que posee un CPU, una memoria y

otros periféricos como temporizadores internos, unidad de transmisión serial, etc.

El microcontrolador se puede programar, es decir enviarle un conjunto de instrucciones

realizadas por el usuario para que las ejecute. Dichas instrucciones serán escritas por el usuario

en un entorno grafico en el PC, en un lenguaje fácilmente entendible (en este caso Processing) y

posteriormente traducidas por dicho entorno al lenguaje maquina y posteriormente enviadas vía

puerto serie a la placa para su ejecución.

- Los pines o patas del Arduino

El atmega 328p posee pines o patas para poder interactuar con el exterior. Pueden ser pines

digitales o analógicos.

- Los pines digitales:

Dichos pines pueden funcionar como entradas o salidas dependiendo de la configuración que se

haga mediante nuestra programación. Es decir, nosotros podemos elegir que un determinado pin

funcione como entrada o salida. (Si es entrada, recibirá 5v o 0v y si es salida aplicará 5v o 0v a

una carga).

- Los pines analógicos:

Los pines analógicos son o bien entradas o bien salidas. Las entradas analógicas nos permiten

trabajar con señales de naturaleza analógica (el voltaje que hay en un potenciómetro es una señal

analógica). Debemos recordar que muchos sensores nos entregan información de magnitudes

físicas como temperatura, presión, caudal etc. en forma de señales de voltaje. De manera que el

voltaje a la salida de un sensor de temperatura es proporcional a la magnitud física que mide el

sensor. Por ello, los pines de entrada analógica son importantes pues nos permiten interactuar

con los sensores.

- Conector usb tipo B

El conector USB tipo B, que encontramos en la placa Arduino permite poder grabar nuestros

programas en la placa. Adicionalmente, también podemos usar este conector para alimentar

nuestra placa directamente del puerto USB de la computadora.

- Conector de alimentación

El jack DC nos sirve para alimentar nuestra placa Arduino desde una fuente externa. La tensión

de alimentación puede ser por ejemplo 12v.

EL ENTORNO DE PROGRAMACIÓN DE ARDUINO

Vista general

A continuación mostramos una captura del entorno de desarrollo (IDE). Es una aplicación que

corre en el PC que permitirá:

- Escribir las instrucciones

- Corregir errores

- Transformar las instrucciones a código máquina

- Enviarlas a la tarjeta Arduino

- Visualizar mensajes desde la placa Arduino hasta el PC vía puerto serie

Estructura básica de un programa de Arduino

Como se ve en la figura la estructura de un programa contendrá las siguientes partes bien

diferenciadas:

- Declaración de variables. Es la parte donde se definen los valores tanto

constantes como variables que se irán utilizando en el resto del programa

- Setup. Es la parte donde configuraremos la placa. Es aquí donde por ejemplo

diremos que pines vamos a utilizar y si estos serán de salida o de entrada

- Loop. Es el conjunto de instrucciones que se han de ejecutar de modo continuo.

Es decir se trata de un bucle que se repetirá de modo infinito.

ACCESORIOS DE ARDUINO: SENSORES Y ACTUADORES

Sensores

Los sensores son dispositivos que envían a la placa información acerca de parámetros físicos

exteriores como

- Temperatura

- Humedad

- Distancia

- Luminosidad

- Sonido

- Infrarrojos

- etc.

Existe una infinidad de dichos sensores que se incorporaran en función de las necesidades del

proyecto. Así si queremos hacer un termostato tendremos que incorporar un sensor que nos mida

la temperatura externa

Funcionamiento de los sensores.

Un sensor debe ser capaz de transformar una magnitud física (tan variable como temperatura,

luminosidad o humedad) y transformarla en una magnitud eléctrica de forma que el programa

que corre en Arduino sea capaz de interpretarla. En el caso de Arduino esta magnitud debe ser un

voltaje que será medido desde una de las entradas digitales o analógicas de la placa Arduino.

Vamos a poner como ejemplo la medida de la temperatura por medio de una sonda NTC:

La sonda NTC es una resistencia que cambia con la temperatura

Aquí tenemos su símbolo

Al variar su resistencia con la temperatura podemos diseñar un pequeño circuito como el que

sigue:

En este circuito hemos puesto una resistencia conocida (Rbajo) en serie con la resistencia

variable con la temperatura creando un divisor de tensión.

En este circuito variaciones en la temperatura implica variaciones en la resistencia lo que a su

vez implica finalmente variaciones en el voltaje Vout que será medido desde una de las entradas

analógicas de Arduino (analog Pin0..5)

A0

A1 A2

A3

A4

A5

ARDUINO

Actuadores

Los actuadotes son dispositivos controlados por la placa controladora. Pueden llevar a cabo

movimientos (motores y servos), activar luces (leds), sonidos (timbres y buzzers), circuitos

(relés) así como enviar información a dispositivos para representar información (pantallas LCD,

TFT etc.).

Funcionamiento.

Al igual que con los sensores existe gran variedad entre los tipos de actuadotes así como su

funcionamiento. En la mayoría de los casos estos estarán controlados mediante las salidas

digitales (Digital 1..13)con un nivel de voltaje indicando una salida de voltaje alto(ON) o

bajo(OFF).

Como ejemplo vamos a ver como se activa un led desde Arduino desde la salida digital 5. En la

siguiente figura se ha conectado un led al pin nº 5. Una vez conectado, para encender el led solo

habrá que activar a ON la salida utilizada (ON = 5 voltios). Dicha activación se hace mediante

las instrucciones que componen el programa. Para apagar el led tan solo hay que poner la salida

a OFF (0 voltios)

ARDUINO

0

1

2

3

4

6

7

8

9

10

11

13

12

5

COMUNICACIONES

Arduino tiene un puerto de comunicaciones serie

Para la comunicación entre la placa Arduino y un ordenador u otros dispositivos se utiliza un

puerto serie. Todas las placas Arduino tienen al menos un puerto serie (también conocido como

UART o USART).

A nivel hardware existen varias posibilidades:

- Conector USB

- Pines digitales 0 (RX) y 1 (TX)

Conector USB

Mediante este conector se establecerá una comunicación serie con el ordenador:

- Para carga del programa en Arduino desde el PC. (PCArduino)

- Para monitorización: Envío de información desde Arduino al PC (ArduinoPC)

Antes de establecer la comunicación habrá que configurar tanto el PC como la placa:

- Configurando para que conecten a la misma velocidad

- Creando un puerto COM virtual de comunicaciones en el PC

Pines de comunicación

Se utilizan para la comunicación de Arduino con otra placa o con otros dispositivos. El chip

ATmega328 ofrece comunicación en serie UART TTL (5V ), que está disponible en los pines

digitales 0 ( RX ) y 1 ( TX) .

Librería serial

La comunicación en serie bien a trabes del puerto USB o bien a través de los pines 0 y 1 se hará

con ayuda de las funciones de la librería serial que se utilizarán a la hora de escribir el programa

y de las cuales podemos destacar:

- Serial.begin(9600); // Función para configurar el puerto de comunicaciones a 9600 baudios

- Serial.write(“información a enviar”); // Para enviar información a través del puerto

- Serial read(); // Para leer la información que este disponible en el puerto de comunicaciones

PASOS PARA LA REALIZACIÓN Y EJECUCIÓN DE UN PROGRAMA EN ARDUINO:

1. Bajar la última versión del entorno de desarrollo (IDE) desde la página oficial de Arduino

http://arduino.cc/en/Main/Software e instalarla en el ordenador.

2. Arrancar la aplicación que tendrá el siguiente aspecto:

http://arduino.cc/en/Main/Software

3. Escribir el código del programa, manteniendo la estructura mostrada en el apartado

anterior. A continuación se muestra el ejemplo de un simple programa que hará

parpadear un led.

4. Verificar el programa. El programa se verifica al seleccionar la opción “Verificar”. La

aplicación procederá a hacer un análisis del código realizado por el usuario e indicará en

la ventana inferior los posibles errores encontrados para que el alumno los pueda

corregir.

Botón de verificación

Ventana inferior de mensajes de error

5. Corregir los errores y volver a verificar hasta que el programa esté libre de errores.

6. Conectar la placa Arduino al ordenador mediante el cable USB

7. Seleccionar el tipo de placa Arduino con la que estamos trabajando desde el IDE:

“HerramientasTarjetaArduino Uno” (En nuestro caso seleccionaremos “Arduino

)Uno”

8. Seleccionar el puerto serie por el cual vamos a enviar el programa al Arduino:

“HerramientasPuerto SerialCOMX”, donde COMX es el puerto que se ha creado al

conectar el Arduino por medio del cable USB. Si hay varios puertos COM el alumno

podrá desenchufar la placa Arduino del ordenador y ver cual de ellos ha desaparecido

9. Enviar programa al Arduino. Una vez que tenemos el programa corregido y compilado, y

la tarjeta Arduino correctamente conectada al ordenador podemos proceder a cargar en

ella el programa. Para ello seleccionaremos el botón “enviar”

10. Si todo ha ido bien, el breves segundos el programa estará ejecutándose en el Arduino

realizando las instrucciones que el alumno haya programado

Enviar programa a tarjeta

ACTIVIDADES

Actividad 1:

Queremos simular el funcionamiento de un semáforo. Y para ello te vamos a pedir que realices el siguiente montaje con Arduino.

1. Conecta a. un led verde al pin digital número 2, b. un led amarillo al pin digital número 3, c. un led rojo al pin 4 (recuerda conectar la resistencia de 200 a 400 ohms delante

de cada led, para no quemarlo). 2. Conecta un zumbador al pin 5 (se puede conectar directo, sin necesidad de resistencia).

Nuestro semáforo debería seguir la secuencia verde, amarillo, rojo. Al ser un semáforo deberíamos vigilar que en ningún momento estén las 3 luces apagadas, para no generar confusión. Elige cual de estas implementaciones se adapta mejor al comportamiento deseado (opción A, opción B u opción C):

Opción A) Opción B)

Opción C)

Actividad 2:

Ahora queremos hacer que el altavoz suene intermitentemente mientras el led verde esta encendido. ¿Sería la mejor opción A, B o C?: Elige cual de estas implementaciones se adapta mejor al comportamiento deseado (opción A, opción B u opción C):

Opción A)

Opción B)

Opción C)

PROYECTOS CON ARDUINO

La metodología a seguir será el aprendizaje mediante la realización de pequeños proyectos o

ejercicios:

1. Encender diodo a través de pin 13.

2. Encender 5 led imitando luces del coche de la serie “El coche fantástico”

3. Encender led apretando interruptor exterior

4. Encender 1 led por medio de la función termostato

5. Programar un seguidor solar con 3 sensores de luz y activar cuatro leds diferentes según

posición de la luz.

.

Ejercicio 1: Encendido de diodo a través de pin 13.

Cableado: El alumno dispondrá los elementos necesarios con arreglo al siguiente esquema

Y para realizar este esquema utilizaremos la portoboard como sigue:

Nota importante: Las altas corrientes causadas por cortocircuitos o por el uso

de resistencias pequeñas pueden llegar a DAÑAR de forma irremediable la

placa Arduino. Es por ello que utilicemos una resistencia de 220 Ohmn en

serie al LED puesto que así disminuimos la corriente que sale del Arduino

Estructura del programa. A continuación ponemos la estructura del programa:

/*

Programa de Parpadeo

*/

// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

int led = 13;

// the setup routine runs once when you press reset:

void setup() {

// initialize the digital pin as an output.

pinMode(led, OUTPUT);

}

// the loop routine runs over and over again forever:

void loop() {

digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for a second

}

Elementos del programa utilizados en este ejercicio:

Int Led = 13;

Es la variable que utilizamos para designar el pin de salida

pinMode(led, OUTPUT);

Con la función “pinMode” le decimos a la placa que vamos a utilizar el pin 13 (variable Led)

como pin de salida (OUTPU)

digitalWrite(led, HIGH);

Con digitalWrite enviamos al pin 13 (led) un valor de voltaje alto (HIGH)

delay(1000);

Le decimos a la placa que no haga nada durante 1000 ms (1 segundo)

digitalWrite(led, LOW);

Con digitalWrite enviamos al pin 13 (led) un valor de voltaje bajo (LOW) o cero voltios

Otros elementos que aparecen:

“;” Punto y coma: Cada sentencia que aparece en este lenguaje viene finalizada por un punto y

coma

// Cualquier palabra después de este símbolo es ignorada por el traductor del lenguaje.. es decir

se utiliza para comentar el programa

/*…*/ Cualquier palabra en medio de estos símbolos es ignorada por el traductor del lenguaje..

es decir se utiliza para comentar el programa

{..} se utilizan para los bloques de programa (setup y loop)

Ejercicio 2: Encender 5 leds imitando luces del coche de la

serie “El coche fantástico”

Utilizando y ampliando el esquema del ejercicio anterior el alumno encenderá y apagará cada

uno de los leds secuencial mente siguiendo el siguiente esquema con la protoboard

Estructura del programa

La estructura de este programa utilizara los mismos elementos que en el ejercicio anterior.

Ejercicio 3: Encender led apretando interruptor exterior

En este ejercicio el alumno hará un programa que haga encender un led conectado al pin

13cada vez que pulse un interruptor de tipo switch conectado en el pin 2 de acuerdo al

siguiente esquema. Por claridad no mostraremos la conexión del led que será idéntica a la del

ejercicio nº 1.

Las conexiones en la protoboard serán como se muestra en la siguiente figura

Elementos utilizados:

- un botón switch

- una resistencia de 1M

- 1 led

- 1 resistencia 220 Ohm


const int buttonPin = 2; // the number of the pushbutton pin

const int ledPin = 13; // the number of the LED pin

// variables will change:

int buttonState = 0; // variable for reading the pushbutton status

void setup() {

// initialize the LED pin as an output:

pinMode(ledPin, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(buttonPin, INPUT);

}

void loop(){

// read the state of the pushbutton value:

buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.

// if it is, the buttonState is HIGH:

if (buttonState == HIGH) {

// turn LED on:

digitalWrite(ledPin, HIGH);

}

else {

// turn LED off:

digitalWrite(ledPin, LOW);

}

}


pinMode(buttonPin, INPUT); Esta vez configure el pin 2 (button pin) para lectura

digitalRead(buttonPin); Lee el valor del voltaje del pin 2

if (buttonState == HIGH) { sentencias } Sentencia condicional: si la lectura del pin del botón 2

es alta (voltaje por encima de 3 voltios) entonces ejecuta las sentencias dentro de las llaves

siguientes.

Ejercicio 4. Encender 1 led por medio de la función

termostato

En este ejercicio el alumno hará encender un led cada vez que la temperatura que se lea por

medio de un sensor térmico NTC sea mayor que un valor determinado.

El esquema que utilizaremos será el siguiente (Por claridad no mostraremos la conexión del

led que será idéntica a la del ejercicio nº 1) :

Y el esquema en la protoboar será:


- una resistencia NTC

- una resistencia de 10k

- 1 led



int led=8;

int ntc=0;

int medida=0;

int temperatura;

int nivel=735; //variable que guarda el límite de temperatura al que se activa el led

void setup(){

pinMode(led,OUTPUT);

Serial.begin(9600);

}

void loop(){

medida=analogRead(ntc);

Serial.print("La medida es ...");

Serial.println(medida);

delay(1000); //para evitar saturar el puerto serie

if(medida>nivel){ //si la señal del sensor supera el nivel marcado:

digitalWrite(led,HIGH); //se enciende un aviso luminoso

}

else{ // si la señal está por debajo del nivel marcado

digitalWrite(led,LOW);

}

}


Serial.begin(9600);

Inicializa el Puerto serie con el PC para enviar mensajes al IDE a través de él

analogRead(ntc);

Lee el valor del voltaje en el pin ntc

Serial.print()

Envía por el puerto serie el contenido del paréntesis

Nota: Como acabamos de exponer enviaremos las lecturas del pin analógico por medio del

puerto de comunicaciones al PC. Para visualizar estos mensajes el alumno deberá abrir el

monitor del puerto serie desde “Herramientasmonitor serie”

Ejercicio 5. Programar un seguidor solar con 3 sensores de

luz y activar cuatro leds diferentes según posición de la luz.

Costa de dos partes:

- Lectura de sensores luminicos LDR o fotocelulas (I, D, A )

- Actuación sobre leds o relés: LI, LD, LAR, LAB (Izq, dcha, arrba, abjo)

1. Lectura:

Implementaremos el siguiente circuito divisor de tensión. En el veremos que al incidir la luz

sobre la fotocélula su resistencia disminuirá.

Se trata de una lectura analógica utilizando uno de los pines analógicos(A0..5):

Mediante el comando analogRead leemos el valor del voltaje que hay en el punto P1 y lo

almacenaremos en una variable definida previamente. ¿Qué valor obtenemos? Leemos un nivel

de voltaje que esta entre 0 y 5 voltios que al pasarlo a un conversor A/D de 10 bits nos dará un

numero entre 0 y 1023 (210

= 1024 niveles). Es decir, 0 corresponderá a 0 voltios y 1023 a 5

voltios.

2. Actuación sobre leds o relés:

Orientación Este-Oeste:

Compararemos el valor obtenido entre los sensores I y D. Si recibimos mas luz en el sensor I

activaremos el led LI y si es al contrario activaremos el sensor LD. La comparación se hará con

el siguiente comando:

if (lectura luz sensor I > lectura luz sensor D) {activar led LI}

else{ activar led LD}

Sensores I D

A

LI

LAR

LD

LAB

Leds

A

10K

5Vcc

GND

A0..5 P1

Orientación Elevación:

Compararemos el valor obtenido entre el sensor A y la media obtenida entre los sensores I y D.

Si recibimos mas luz en el sensor A activaremos el led LAR y si es al contrario activaremos el

sensor LAB

La activación se hará por medio de un pin digital como se indica en la siguiente figura:

Y en el programa utilizaremos el comando DigitalWrite(Nºpin, HIGH/LOW)

La conexión con la protoboard será como sigue:


- 3 resistencia LDR

- 3 resistencia de 10K

- 4 led


220 D0..13

GND


int arriba_LDR = 0;

int izqda_LDR = 1;

int dcha_LDR = 2;

int arriba_led = 8;

int abajo_led = 9;

int izda_led = 10;

int dcha_led = 11;

int arriba;

int izqda;

int dcha;

int media_izqda_dcha;

void setup() {

Serial.begin(9600); // initialize serial communicatión at 9600 bits per second:

}

void loop() {

arriba = analogRead(arriba_LDR); // reads the LDR (value between 0 and 1023)

izqda = analogRead(izqda_LDR); // reads the LDR (value between 0 and 1023)

dcha = analogRead(dcha_LDR); // reads the LDR (value between 0 and 1023) //

media_izqda_dcha = (izqda+dcha)/2; // hace la media

Serial.print("arriba: "); Serial.println(arriba);

Serial.print("izqda: "); Serial.println(izqda);

Serial.print("dcha: "); Serial.println(dcha);

// si el sensor de arriba esta mas iluminado se enciende el led arriba y sino el de abajo

if (arriba> (media_izqda_dcha )){

digitalWrite(arriba_led,HIGH);

digitalWrite(abajo_led,LOW);

}

else{

digitalWrite(arriba_led, LOW);

digitalWrite(abajo_led, HIGH);

}

if (dcha> (izqda)){

digitalWrite(dcha_led,HIGH);

digitalWrite(izda_led,LOW);

}

else{

digitalWrite(dcha_led, LOW);

digitalWrite(izda_led, HIGH);

}

delay(500);

}

UNIDAD DIDACTICA ARDUINO - · PDF fileProgramar un seguidor solar con 3 sensores de luz y...

Documents

Transcript of UNIDAD DIDACTICA ARDUINO - · PDF fileProgramar un seguidor solar con 3 sensores de luz y...