TEMA 6: PROGRAMACIÓN ROBÓTICA.ARDUINO · 6 pines para salidas analógicas (salidas PWM) Los pines...

TECNOLOGÍA INDUSTRIAL 1. Departamento de Tecnología. IES Nuestra Señora de la Almudena Mª Jesús Saiz

1

TEMA 6: PROGRAMACIÓN ROBÓTICA.ARDUINO

1. Control de un robot:

Los sensores toman información del exterior y la mandan a la tarjeta controladora. La tarjeta la procesa y manda las ordenes de actuar a los actuadores. La tarjeta tiene que ser previamente programada mediante el ordenador.

La tarjeta controladora o microcontrolador es un miniordenador o chip programable que lleva una memoria interna y en la que se pueden conectar los sensores y actuadores de nuestro robot. Este microcontrolador se programa mediante un ordenador a través de un software de programación. Nosotros utilizaremos la tarjeta controladora Arduino.

Pines de alimentación: proporcionan la corriente continua necesaria para que funcionen los sensores y actuadores (motores,...)

Pines de alimentación positiva a 3,3 o 5 V Pines de alimentación negativa o tierra o GND a 0 V.

14 pines para entradas/salidas digitales (pines del 0-13). Trabajan con valores binarios (1 ó 0): "1" corresponde a 5V (ENCENDIDO) y "0" corresponde a 0V (APAGADO). Se puede ampliar 6 pines digitales más utilizando los pines de las entradas analógicas como digitales.

Entradas y Salidas Digitales PIN 0-13

Reset

Conector USB

PIN 13 LED

Conector para alimentación

externa 6-12 V

Entradas Analógicas PIN 0-5

Microcontrolador

PIN V IN PIN 5V

PIN 3,3V

PIN de tierra GND

PINES de alimentación

PIN de tierra GND Salidas Analógicas PIN 3,5,6,9,10,11

SENSORES:

Sensor de luz,Sensor de Tª, Pulsador,...

TARJETA CONTROLADORA

ORDENADOR

ACTUADORES:

MOTOR, Lámpara, Zumbador,...

CIRCUITOS ELECTRÓNICOS

PROGRAMACIÓN


2

6 pines para entradas analógicas (pines A0-A5). Los pines de entrada analógica reciben información en forma de voltaje con valores que pueden ir desde 0 V hasta 5 V. Utilizan un convertidor analógico/digital que traduce los 0-5 V a valores de 0-1023, (cuando se les da la orden analogRead).

6 pines para salidas analógicas (salidas PWM) Los pines 3, 5, 6, 9, 10 y 11 proporcionan una salida analógica y pueden tomar valores de 0 a 255 (cuando se les da la orden analogWrite). En otro caso serian entradas o salidas digitales.

Cada pin puede proporcionar o recibir como máximo una corriente 40 mA, por lo que no pueden mover un motor de CC. Será necesario amplificar la corriente mediante un transistor.

Es necesario conectar la placa mediante USB para cargar los programas. Después se puede desconectar el USB y alimentar la placa mediante una pila o fuente de alimentación.

2. Entorno software

Primero debemos seleccionar el tipo de dispositivo (Placa ó Board). Para ello pulsaremos en el menú "Herramientas" - "Placa" y seleccionaremos "Arduino Uno" (o el que hayamos adquirido). Seleccionaremos también el puerto serie asignado al controlador de Arduino (en nuestro caso COM3), para ello accederemos al menú "Herramientas" - "Puerto" - "COM3"

Verificar/Compilar. Chequea el código, identificando los errores. Cargar a la placa: Descarga el programa compilado desde el PC hasta la tarjeta arduino. Nuevo: crea un nuevo proyecto Abrir proyectos previamente guardados y también muestra los proyectos de ejemplos. Guarda el proyecto actual dentro de la carpeta Mis documentos /Arduino/sketchbook/.

Se puede guardarlo con un nombre distinto mediante el menú Archivo → Guardar como.

Realiza el monitoreo del puerto serial, abre una pantalla y muestra o visualiza

los datos enviados desde la tarjeta Arduino.

3. Estructura básica de un programa

La estructura de programación de Arduino divide el programa en tres partes: definición de variables. setup y loop.

Lo primero será crear y definir las variables mediante el comando int. Tenemos que dar nombre a la variable e indicar el lugar o pin donde van.

int ledverde = 7; (le damos el nombre ledverde y lo colocamos en el pin 7)

Se prefiere no utilizar los pines 0 y 1, para no equivocarnos con los valores lógicos binarios 0 y 1

La función void setup() constituye la preparación del programa y aquí se configuran los pines digitales como de SALIDA o ENTRADA. usando la función pinMode y mediante la instrucción OUTPUT o INPUT.

pinMode(ledverde, OUTPUT); (establece el led del pin7 como salida)

También se escriben aquí las funciones qué solo se ejecutan una vez.

Co

mp

ilar

Carg

ar

a la p

lac

a

Nu

evo

Ab

rir

Gu

ard

ar

Zona para escribir el código

Zona de mensajes del software. Errores y acciones

Ab

rir

el m

on

ito

r p

uert

o s

eri

e


3

La función void loop() es la parte donde escribimos los programas que se ejecutan en forma de bucle (se ejecuta continuamente).

1ª 2ª

3ª

int ledverde = 12; //Pin donde va el led void setup()

pinMode(ledverde, OUTPUT);//Establece 'pin 12' como salida

void loop()

digitalWrite(ledverde, HIGH); // Enciende el led delay(1000); // Pausa un segundo

digitalWrite(ledverde, LOW); // Apaga el led delay(1000); // Pausa un segundo

Marcas de puntuación:

Las llaves . Se usan para indicar el principio y final de una función. Los paréntesis ( ) se utilizan para escribir funciones dentro de nuestros programas. Cada instrucción debe acabar con ;

Los comentarios se indican con //. Se pueden introducir bloques de comentarios con // ... . Los comentarios no son obligatorios.

4. Datos, variables y funciones

HIGH. Define el valor de entrada o salida del pin como ON (5 V o “1” en binario) LOW. Define el valor de entrada o salida del pin como OFF (0 V o “0” en binario)

Función pinMode(pin, mode) Función usada dentro de la función setup() para configurar como un pin debe comportarse, como entrada de información o salida de información a la placa Arduino (INPUT o OUTPUT).);

Ej. pinMode(ledPin, OUTPUT); // configura el ledPin como de salida.

INPUT. Se utiliza en la función pinMode() para definir la función del pin digital usado como entrada de datos (ej: pulsadores, sensores) OUTPUT. Se utiliza en la función pinMode() para definir la función del pin digital usado como salida de datos (ej: leds, motores)

Ej. pinMode(ledPin, OUTPUT);

Función digitalRead(pin) Lee el valor desde un pin digital específico. Devuelve un valor HIGH o LOW. El valor leído debemos almacenarlo en una variable

Ej. valorSensor = digitalRead(sensorPin);

Funcion digitalWrite(pin, valor) Introduce un valor (HIGH) o (LOW) en el pin digital especificado..

Ej. digitalWrite(ledPin, HIGH);

Función analogRead(pin) Lee el valor desde el pin analógico especificado . Esta función solo funciona en los pines analógicos (A0-A5). El valor resultante es un número entero de 0 a 1023. Los pines analógicos, a diferencia de los digitales no necesitan declararse previamente como INPUT o OUTPUT.

Ej. valorTemp = analogRead(sensorTempPin);

Función analogWrite(pin, valor) Escribe un valor analógico en un pin de salida marcado como PWM. Esta función está activa para los pines 3, 5, 6, 9, 10, 11.

Ej analogWrite(pin, 110); // escribe el valor '110' en el 'pin' analógico. Puede especificarse un valor de 0 - 255. Un valor 0 genera 0 V en el pin especificado y 255 genera 5 V.

delay(ms). Realiza una pausa en el programa la cantidad de tiempo va en milisegundos

Ej delay(5000); // Pausa 5 segundos


4

if (condición SI): Comprueba si una condición se cumple. La función se escribe entre llaves if (valorSensor > 120) digitalWrite (ledPin, HIGH);

Puede utilizarse con uno o más operadores de comparación:

Para unir varias condiciones utilizamos los operadores lógicos Y / O

if…else: SI…..SINO if (valorSensor > 120) digitalWrite (ledPin, HIGH); else digitalWrite (ledPin, LOW);

Podemos anidar varias sentencias if…else, siendo todas ellas, a su vez, mutuamente excluyentes:

if (valorSensor <= 0) delay(100); //se ejecuta con valores<0

else if (valorSensor < 100) delay(250); //se ejecuta con 0< valores>100

else if (valorSensor <= 200) delay(500); //se ejecuta con 100< valores>200

else delay(1000); //se ejecuta con valores>200

for (DURANTE): Repite un bloque encerrado entre llaves. permite indicar el número de iteraciones

o repeticiones Lleva 3 comandos: for ( declara la variable y la inicia ; condición ; incremento)

for (int i = 0; i <= 15; i ++) digitalWrite (ledPin, HIGH); //enciende y apaga el led 15 veces delay(100); digitalWrite (ledPin, LOW); delay(100);

Cada vez que se va a repetir el bucle, se revisa la condición, si es cierta, el bloque de funciones se ejecuta (en este caso, se suma), y la condición vuelve a ser comprobada de nuevo. Si la condición es falsa, el bucle termina

for (valorLDR = 0; valorLDR <= 255; valorLDR++) analogWrite (ledPin, valorLDR); delay(10); // Enciende el led de forma progresiva a intervalos

de 10 milisegundos

while (MIENTRAS): Se ejecuta continuamente hasta que la expresión de dentro del paréntesis

pasa a ser falsa. var = 0; while (var < 200) var++; // Hacer algo repetitivo 200 veces

do…while (HACER….MIENTRAS: Trabaja de la misma manera que el bucle while, con la excepción de que la condición se comprueba al final del bucle, por lo que este bucle se ejecuta

"siempre" al menos una vez. var = 0; do var++; while (var < 200)

break (ROMPER): Es usado para salir de los bucles do, for, o while, pasando por alto la condición normal del bucle.

for (i = 0; i < 10; i++) Console.WriteLine("valor de i: 0", i); if (i > 4) break;

== igual que != diferente que

< menor que > mayor que

<= menor o igual que >= mayor o igual que

&& Y lógico Ej: if (valorSensor1 > 0 && valorSensor2 < 5)

|| O lógico Ej :if ( valorSensor1 > 0 || valorSensor2 > 0)


5

5. Ejercicios

1.- Encender un led de forma intermitente

2.- Encendido secuencial de 3 leds y un motor:

Encender 3 leds (V, R y A) de forma secuencial (primero un led rojo 2 segundos, luego el led amarillo 2 segundos y luego se enciende el led verde y gira el motor durante 4 segundos)., se apagan los 3 leds y el motor, y el programa vuelve a comenzar

3.1- Encendido de un zumbador durante 2 segundos al accionar un pulsador

int ledrojo = 7; // LED que se conecta al pin 7

void setup()

pinMode(ledrojo, OUTPUT); // El p1n 7 será una salida digital

void loop()

digitalWrite(ledrojo, HIGH); // Enciende el LED

delay(1000); // Pausa de 1 segundo

digitalWrite(ledrojo, LOW); // Apaga el LED delay(1000); // Pausa de 1 segundo

int zumbador = 4; // ZUMBADOR que se conecta al pin 4 int pulsador = 2; // PULSADOR que se conecta al pin 2

int valorPulsador = 0; // creamos una variable “valorPulsador” para almacenar el valor 0,1 del

pulsador y la iniciamos con valor cero

void setup()

pinMode(zumbador, OUTPUT); // El p1n 4 será una salida digital pinMode(pulsador, INPUT); // El p1n 2 será una entrada digital

El LED debe llevar una resistencia de protección de 100 a 220 Ω. A los actuadores la corriente + se la proporciona el pin de Arduino

ESQUEMA

Los pines de arduino no proporcionan suficiente corriente para mover el motor, por lo que es necesario amplificar esta corriente con un transistor (protegeremos la base con una resistencia de 1K)


6

3.2- Encendido de un zumbador 5 veces al accionar un pulsador

Haz que al pulsar el pulsador suene el zumbador de forma intermitente 5 veces (utiliza un bucle for: declara una variable contador que vaya de 0 a 5)

4.1- Sensores de proximidad PIR (infrarrojos)

Encender un led verde cuando el sensor detecte algo cerca. El azul de IR emite luz y cuando choca con algo, la luz rebota y el fototransistor blanco la recibe y se activa (HIGH)

void loop()

valorPulsador=digitalRead (pulsador); // creamos una variable

“valorpulsador” para saber si el pulsador está pulsado o no

if (valorPulsador == HIGH) // Si se activa el pulsador

digitalWrite (zumbador, HIGH); // suena el zumbador

delay(5000); // Pausa de 5 segundos

digitalWrite(lzumbador, LOW); // Apaga el zumbador delay(1000); // Pausa de 1 segundo

int ir = 2; int ledV = 8;

int irValor =0;

void setup()

pinMode(ledV, OUTPUT);

pinMode (ir, INPUT);

Minipulsador CI 4 patas

La conexión del pulsador debe hacerse conectando 2 patas en diagonal o 2 patas en horizontal

ESQUEMA

El pulsador debe llevar una resistencia de 10 K antes de llegar a negativo o GND

Conexión a 5V y GND


7

EJEMPLO

4.2- Sensores de proximidad PIR (infrarrojos)

Añade un motor que gire al detectar algo cerca y añade también un led rojo que luzca cuando no detecte algo y se apague al detectar una presencia

5.1-Sensor de luz LDR

Es un sensor analógico que nos permite detectar diferentes estados de luz a través de las entradas analógicas de nuestro Arduino (pines A0-A5).

void loop()

irValor= digitalRead (ir); if (irValor == HIGH)

digitalWrite(ledV, HIGH);

delay(2000);

else

digitalWrite(ledV, LOW);

int ledV= 2; int sensorLDR= A5;

int valorLDR=0;

void setup()

pinMode(ledV, OUTPUT); pinMode(sensorLDR, INPUT);

void loop()

valorLDR = analogRead(sensorLDR);

if (valorLDR < 200)

digitalWrite(ledV, HIGH);

delay(2000);

El sensor de IR no necesita resistencia de protección. Lleva 3 patillas: Vcc se conecta a 5V, GND se conecta a tierra y OUT es la patilla que irá al pin de arduino que transmita la señal.

El sensor formado por led IR y fototransistor deben llevar resistencias de protección de 100Ω y 10 K respectivamente antes de llegar a GND.

Vcc OUT GND

Vcc GND

GND Vcc

El sensor LDR debe llevar resistencia de protección de 1KΩ antes de llegar a GND.

En el ejemplo el valor de referencia para activar el sensor será de 550 (puede variar según la luz del edificio)


8

Si queremos saber el valor que toma la LDR según las condiciones de luz u oscuridad, debemos introducir las siguientes órdenes y abrir el monitor serie para poder verlo.

5.2-Sensor de luz LDR Encender 3 leds diferentes (verde, rojo y amarillo) según las condiciones de luz (oscuridad, luz

natural y linterna)

6.1- Cambio de giro del motor mediante chip L293D (puente de diodos)

Es un chip que podemos usar para gobernar uno o dos motores CC (cambio de giro y control de velocidad).

Pin 16: Vss = 5V con los que alimentamos el chip

Pin 8: Vs = tensión para alimentar el motor

Pines del 1 al 7: control del motor 1

Pin 1: activa el uso del motor 1 (con un valor HIGH el motor

puede girar dependiendo del pin 2 y 7, con un valor LOW el

motor se para independientemente del resto de pines. Se

suele conectar a positivo

Pines 2 y 7: pines de control del giro del motor 1, van

conectados a Arduino

Pines 3 y 6: son los pines que se conectan al motor 1

Pines 4 y 5: van a GND

Pines del 9 al 15: control del motor 2

else

digitalWrite(ledV, LOW);

void setup()

Serial.begin (9600); //inicia comunicación por el puerto serial

void loop()

valorLDR = analogRead(sensorLDR);

Serial.println (valorLDR); //escribe la luz medida por el

sensor en el monitor serie

delay (500); //tiempo para la siguiente medición

TABLA DE CONEXIÓN DE PINES

PIN L293D PIN ARDUINO DESCRIPCIÓN

1 + 5v Enable

2 2 Input 1

3 Motor1 +

4,5 GND GND

6 Motor1 –

7 7 Input 2

8 Vin Alimentación

del motor

TABLA DE CONTROL DEL MOTOR

ENABLE: Pin 1 Pin 2 Pin 7 MOTOR

LOW - - STOP

HIGH HIGH LOW GIRO HORARIO

HIGH LOW HIGH GIRO ANTIHORARIO

HIGH HIGH HIGH STOP

HIGH LOW LOW STOP


9

6.1- Cambio de giro del motor mediante chip L293D (puente de diodos) Añade un led verde y otro rojo que luzcan cuando el motor gira, cada uno luce con un sentido

de giro

7.-Movimiento de los motores de tu robot con los sensores de luz o sensores de IR

Diseña el programa que mueva los motores de tu coche-robot y móntalo en tu proyecto.

Puedes controlar tu robot con otro tipo de sensores:

Sensor de sonido

Sensor de llama

Sensor de temperatura

Sensor de agua (humedad)

8.1.- Encendido progresivo de un led

Encender un led aumentando su brillo hasta llegar al máximo.

Los pines de salida analógica son 3, 5, 6, 9, 10 y 11 y pueden tomar valores de 0 a 255

APERTURA Y CIERRE PUERTA CON DETECTOR IR

int irPin = 4;

int MDPin = 2;

int MIPin = 7;

int irValue =0;

void setup() pinMode(MDPin, OUTPUT); pinMode(MIPin, OUTPUT); pinMode (irPin, INPUT);

void loop() irValue= digitalRead (irPin); if (irValue == HIGH) digitalWrite(MDPin, HIGH); digitalWrite(MIPin, LOW); delay(5000); digitalWrite(MDPin, LOW); digitalWrite(MIPin, HIGH); delay(5000); else digitalWrite(MDPin, LOW); digitalWrite(MIPin, LOW);


10

La función for (DURANTE): ejecuta o repite una instrucción del programa encerrado entre llaves durante el tiempo que se cumple una condición Lleva 3 comandos: for ( declara la variable y la inicia ; condición ; incremento)

for (int i = 0; i <= 255; i ++) Cada vez que se va a repetir el bucle, se revisa la condición, si es cierta, el bloque de funciones se ejecuta (en este caso, se suma), y la condición vuelve a ser comprobada de nuevo. Si la condición es falsa, el bucle termina

8.2.- Encendido y apagado progresivo de un led Añade la parte de programación que hace que al accionar un pulsador se encienda el led de

forma progresiva, durante 2 segundos esté al máximo valor y después haga que el led se apague decreciendo de forma progresiva el valor del brillo

9.- Sensor de sonido:

Es un sensor analógico o digital que nos permite controlar circuitos a partir de sonido a través de las entradas analógicas de nuestro Arduino (pines A0-A5). O de las entradas digitales .

A0: irá a entrada de control analógico A0-A5 G : irá a GND + : irá a tensión de 5 V D0: irá a entrada de control digital

Utilizaremos control analógico o control digital, según queramos

El sensor tiene 2 leds y lleva un potenciómetro para controlar el nivel de entrada alto o bajo. Los 2 encendidos es HIGH y sólo uno encendido es LOW. Hay que ajustar el potenciómetro y colocarlo en el momento que cambia de HIGH a LOW

El sensor hay que regularlo en LOW y luego leer el valor de sonido que marca, para programar. El valor para programar el cambio de estado es muy similar (poca variación de número)

Si no sois capaces de encender el LED de una palmada, probad a pegar un silbido, un soplido o a hablar cerca del micrófono.

int led = 3;

void setup() pinMode(led OUTPUT);

void loop()

for (int luz=0; luz<=255; luz++)

analogWrite(led, luz); // Establece el brillo al valor luz

delay(100); // Pausa de 100 ms


11

10.- Sensores de llama

Son sensores infrarrojos de llamas. Funcionan detectando una

longitud de onda especifica (de unos 760 nm) que son características de las llamas, aunque son relativamente fáciles de engañar y pueden dar falsos positivos con ciertas luces.

int led = 2; int micro = A0;

int valorMicro = 0;

void setup() Serial.begin (9600);

pinMode(micro, INPUT);

pinMode(led, OUTPUT);

void loop()

valorMicro= analogRead(micro); Serial.println (valoMicro);

delay (50);

if (valorMicro >= 528)

digitalWrite(led, HIGH); delay (3000);

else

digitalWrite(led, LOW);

int sensorLlama = A0;

int led = 9; int valorSensor =0;

void setup()

Serial.begin (9600);

pinMode(led, OUTPUT); pinMode (sensorLlama, INPUT);

void loop() valorSensor= analogRead(sensorLlama) ; // lee el pin analógicoA0

Serial.println (valorSensor); delay (50);

if (valorSensor > 20) // si el valor anlógico del sensor de llama es >20

digitalWrite(led, HIGH); //enciende el led de forma intermitente delay(1000);

digitalWrite(led, LOW); delay(1000);

else // si el valor anlógico del sensor de llama es >20


12

11.-Sensor de temperatura ntc 500 Ω Son sensores analógicos que nos permiten detectar diferentes temperaturas a través de las entradas analógicas de nuestro Arduino (pines A0-A5).

- El valor de referencia para activar el sensor ntc será de 750 (puede variar según la

temperatura del edificio) - El valor para activar el sensor LM35 será la temperatura que deseemos multiplicada por 0,49

Si queremos saber el valor de temperatura que toma el sensor, debemos introducir las órdenes de lectura del puerto serie y abrir el monitor serie para poder verlo.

digitalWrite(led, LOW); // Apaga el led

int zumbador= 2; int sensorTemp= A5;

int valorNTC=0; ó int valorLM35=0;

void setup()

pinMode(zumbador, OUTPUT); pinMode(sensorTemp, INPUT);

void loop()

valorNTC = analogRead(sensorTemp); ó valorLM35 = analogRead(sensorTemp);

if (valorNTC > 750) ó if (valorLM35 > 22^0.49)

digitalWrite(zumbador, HIGH);

delay(2000);

else

digitalWrite(zumbador, LOW);

El sensor LM35 no necesita resistencia de protección. Lleva 3 patillas: Vcc se conecta a 5V, GND se conecta a tierra y OUT es la patilla que irá al pin de arduino que transmita la señal.

El sensor ntc debe llevar resistencia de protección de 1KΩ antes de llegar a GND.

Vcc OUT GND


13

12.- Sensor de agua: Es un sensor analógico que nos permite realizar medidas de niveles de agua de forma bastante precisa a través de las entradas analógicas de nuestro Arduino (pines A0-A5). El pin de control es una señal analógica, proporcional a la cantidad de agua que detecta. Los otros 2 pines irán a GND y a tensión de 5 V. PRECAUCIÓNES:

se recomiendan usar cables largos, para no acercar el agua a la placa arduino.

Si se inserta el sensor en agua, para usarlo como medidor de nivel, hay que tener mucho cuidado de no sumergir los pines de conexión a Arduino, o se provocará un corto

int sensorAgua = A0;

int valorSensor =0;

void setup() pinMode (sensorAgua, INPUT);

Serial.begin(9600);

void loop() valorSensor = (analogRead (sensorAgua);; Serial.println (valorSensor); //escribe la medida en el puerto serie delay (500);

TEMA 6: PROGRAMACIÓN ROBÓTICA.ARDUINO · 6 pines para salidas analógicas (salidas PWM) Los pines...

Documents

Transcript of TEMA 6: PROGRAMACIÓN ROBÓTICA.ARDUINO · 6 pines para salidas analógicas (salidas PWM) Los pines...