Arduinoblock by Enric Serra

Programación Arduino con Ardublock

PROGRAMACIÓN ARDUINO CON ARDUBLOCK

+ Ardublock A GRAPHICAL PROGRAMMING LANGUAGE FOR ARDUINO

Enric Serra 2014

Programación Arduino con Ardublock

Contenidos 1.Introducción.......................................................................................................................... 3 2. Instalación............................................................................................................................. 5 3. El entorno Ardublock.......................................................................................................... 8 4. Los bloques de Ardublock............................................................................................... 11 5. Conceptos básicos............................................................................................................. 14 6. 'Hola Mundo'...................................................................................................................... 17 7. Jugando con LED's............................................................................................................ 20 8. Entradas digitales.............................................................................................................. 27 9. Entradas analógicas.......................................................................................................... 32 10. Salidas PWM..................................................................................................................... 38 11. Diagramas de flujo.......................................................................................................... 41 12. Estructuras de control.................................................................................................... 42 13 Relés................................................................................................................................... 46 14 Uso del transistor para el control de corrientes elevadas........................................51 15 Servomotores: Control con Arduino.............................................................................58

Programación Arduino con Ardublock

1.Introducción. Arduino [1] es una plataforma de desarrollo de circuitos electrónicos basada en los microcontroladores ATMega [2], su filosofia Open Source [3] su facilidad de programación y su precio ha hecho que este dispositivo sea muy popular no sólo entre la comunidad electrónica sino que se ha extendido al mundo de la educación, el arte y en definitiva a todas las personas interesadas en realizar proyectos electrónicos DIY (Házlo tu mismo)[4]. Por otra parte, auque está muy bien documentado el lenguaje de programación de Arduino, la abstracción de los comandos frena en muchos casos a las personas neófitas en lenguajes de programación, por lo que en los últimos años han aparecido herramientas visuales como Scratch, LogoBlocks, Alice, Appinventor y otros que muestran una nueva forma de enseñar y aprender programación. Ardublock http://blog.ardublock.com/ es una herramienta de programación visual por bloques para Arduino, funciona como un rompecabezas de bloques funcionales de distintos colores y genera de forma fácil y sencilla el código en el entorno de programación de Arduino (Arduino IDE).

(Imagen 1) Ardublock integrado en Arduino IDE

Programaci贸n Arduino con Ardublock

Ardublock es una herramienta que acerca el mundo de la programaci贸n de Arduino a estudiantes y aficionados de una forma f谩cil y sencilla. Links. [1] http://arduino.cc/ [2] http://www.atmel.com/products/microcontrollers/avr/megaavr.aspx [3] http://es.wikipedia.org/wiki/C%C3%B3digo_abierto [4] http://es.wikipedia.org/wiki/H%C3%A1galo_usted_mismo ___________________________________________________________________________

Programación Arduino con Ardublock

2. Instalación. Ardublock es un applet de java que se integra como una herramienta de Arduino IDE. • Necesitamos tener instalado el Arduino IDE que podemos descargar desde la web de arduino o a través de los repositorios de Linux.[5] http://arduino.cc/en/Main/Software Actualmente funciona con las plataformas Linux, Windows y Mac OS X. • Necesitamos tener Java instalado en el sistema (en Linux Open JDK Java) • Descargamos el fichero ardublock-all.jar desde la web de Ardublock [6]http://blog.ardublock.com/engetting-started-ardublockzhardublock/ • Desde Arduino IDE abrimos el menú Archivo → Preferencias y vemos donde guarda Arduino los 'sketchs' • En MAC Documents/Arduino • En Windows Documents\Arduino • En Linux /home/usuario/sketchbook • Cerramos Arduino IDE despues de marcar la casilla Verificar actualizaciones al iniciar.

(Imagen 2)

• • • •

Preferencias en Arduino IDE

Creamos la carpeta tools dentro de la carpeta sketchbook Creamos la carpeta ArduBlockTool Creamos la carpeta tool Y finalmente copiamos el fichero ardublock-all.jar allí. Quedará de la siguiente forma (para un sistema linux por ejemplo) /home/usuario/sketchbook/tools/ArduBlockTool/tool/ardublock-all.jar

Programación Arduino con Ardublock

Para iniciar Arbublock arrancamos Arduino IDE y en el menú de Herramientas seleccionamos Ardublock.

(Imagen 3)

Iniciando Ardublock.

Si todo está correcto aparecerá una nueva ventana emergente con el entorno de programación de Ardublock. Ardublock tiene varias actualizaciones (updates) y ramas (branches) de forma que tenemos varios ficheros jar donde elegir. En este documentos utilizaremos la versión beta ardublock-beta-20131126.jar que se puede descargar desde sourceforge [7] http://sourceforge.net/projects/ardublock/files/ Esta versión tiene incorporada cantidad de módulos electrónicos de los fabricantes Tinkerkit [8], DFRobot [9], Seed Studio groove [10] y Adafruit [11] de forma que en nuestro sistema quedará de la siguiente forma: /home/usuario/sketchbook/tools/ArduBlockTool/tool/ardublock-beta20131126.jar

Programaci贸n Arduino con Ardublock

Una vez tenemos Ardublock funcionando ya podemos programar el sistema Arduino por bloques, y generar el c贸digo en el IDE de Arduino.

(Imagen 4)

Ardublock.

Links. [5] http://arduino.cc/en/Main/Software [6] http://blog.ardublock.com/engetting-started-ardublockzhardublock/ [7] http://sourceforge.net/projects/ardublock/files/ [8] http://www.tinkerkit.com/ [9] http://www.dfrobot.com/index.php [10] http://www.seeedstudio.com/depot/ [11] http://www.adafruit.com/ ___________________________________________________________________________

Programación Arduino con Ardublock

3. El entorno Ardublock. El entorno de Ardublock está formado por tres áreas principales: – La biblioteca. – El menú principal. – El área de programación. Además encontramos diferentes elementos que nos ayudarán a la organización y navegación por las diversas secciones del entorno. Entre estos elementos tenemos el icono de minimizar, la ventana de navegación, así como el menú de imagen.

(Imagen 5) Entorno Ardublock. La biblioteca de bloques. En ella encontramos los diferentes bloques divididos en secciones que nos ayudarán a realizar el puzzle de programación. Los bloques más importantes son CONTROL, PINS, OPERADORES MATEMÁTICOS,OPERADORES LÓGICOS Y EL BLOQUE DE VARIABLES Y CONSTANTES. Además encontraremos utilidades y bloques creados por fabricantes de sensores y actuadores para conectar a Arduino.

Programación Arduino con Ardublock

(Imagen 6) Biblioteca de bloques. El menú principal. Dentro del menú principal encontraremos unos botones que cada uno de ellos realiza una función específica.

(Imagen 7) Botones menú principal. BOTÓN

FUNCIÓN

Nuevo

Crearemos un nuevo archivo Ardublock

Guardar

Guardamos fichero Ardublock con extensión .abp

Grabar como

La misma función que guardar con la posibilidad de cambiar el nombre

Abrir

Podemos abrir archivos Ardublock con extensión .abp

Cargar a Arduino

Pasamos la información a Arduino IDE para su compilación.

Monitor Puerto Serie

Abre una ventana con el monitor del puerto serial.

Programación Arduino con Ardublock

El área de programación. Por último el área de programación es el espacio donde arrastraremos los bloques de programación para realizar nuestro programa.

(Imagen 7) Área programación.

Programación Arduino con Ardublock

4. Los bloques de Ardublock. Ardublock tiene una serie de bibliotecas principales que abarcan una buena parte del lenguaje de programación de Arduino. Otras bibliotecas son componentes de distintos fabricantes.

(Imagen 7) Biblioteca de bloques. Veamos algunas de ellas: Control. Son las estructuras básicas de programación (Void Setup, Void loop) y las estructuras de control y flujo (if – else, while, for, do – while, switch)

(Imagen 8) Biblioteca Control. 11

Programación Arduino con Ardublock

Pins. Asigna las entradas y salidas de Arduino (pinmode, DigitalRead, DigitalWrite, AnalogRead, AnalogWrite...)

(Imagen 9) Biblioteca Pins. Test. Son los operadores de relacción (mayor que, menor que, igual a …)

(Imagen 9) Biblioteca Test. 12

Programación Arduino con Ardublock

Tenemos bibliotecas para operaciones matemáticas (Math Operators), para trabajar con variables y constantes (Variables/Constants), comunicaciones con el puerto serie (Comunication) etc. Algunos fabricantes de componentes para Arduino como Tinkerkit, DFRobot, Adafruit han incorporado sus bibliotecas al entorno de Ardublock de forma que su programación y uso es muy sencilla.

(Imagen 11) Biblioteca DFRobot. Cada biblioteca tiene unos bloques que arrastraremos al área de programación. Si queremos borrar algo, lo seleccionamos con el ratón y lo arrastramos a la sección de bibliotecas. Con el botón derecho del ratón podemos clonar partes de los bloques de programación o añadir comentarios a nuestro programa (llamado sketch en Arduino).

Uso: http://youtu.be/oHmYygP4R-I 13

Programación Arduino con Ardublock

5. Conceptos básicos. Antes de empezar nuestro primer programa, es necesario introducir unos conceptos básicos sobre electrónica y Arduino. Arduino es una computadora física que recibe entradas del mundo real y las procesa para mostrar el resultado por las salidas.

(Imagen 12) Arduino y el mundo real. Arduino tiene una serie de PINS (patillas, conectores, clavijas) que alimentan los circuitos (+5V , 3,3V y GND), pins de entradas analógicas, digitales y salidas digitales. Hay unas salidas especiales llamadas PWM (Pulse Wide Modulation) que son salidas digitales de amplitud variable.

(Imagen 13) Pins Arduino

Programación Arduino con Ardublock

Algunas abreviaturas convencionales en electrónica usadas en Arduino. GND Terminal de 0 Voltios, Tierra, Masa (GrouND en Inglés) IN Terminal de entrada de señal. (INput) OUT Terminal de salida (OUTput) IN/OUT Terminal que puede ser de entrada o salida. POWER , PWR Terminal de alimentación, Tensión. A0, A1, ---- A5 Terminales Analógicos. (En Arduino siempre son Entradas) D0,D1, … D13 Terminales Digitales (En Arduino pueden ser Entradas o Salidas) RX Terminal para recibir datos (Receive) En comunicaciones serie. TX Terminal para enviar datos (Transmit) AREF Tensión analógica de referencia. (Analog REFerence)

(Imagen 14) PINES en Arduino

Programación Arduino con Ardublock

Tipos de señales: En Arduino manejamos 3 tipos de señales: DIGITALES: Son señales de 5V o 0V (1 y 0). Este tipo de señales las encontramos en interruptores (Conectado, desconectado), pulsadores (pulsado no-pulsado) y en sensores digitales (TILT, PIR digital, Presencia etc). En Arduino pueden ser Entradas o Salidas. ANALÓGICAS: Son señales que cambian con el tiempo, por ejemplo un sensor de temperatura (dependiendo de la temperatura tendrá diversas tensiones de salida), sensor de iluminación, distancia etc. En Arduino son siempre Entradas. PWM: Señales de salida en Arduino que son digitales pero de amplitud variable, imaginemos que queremos regular la iluminación de un LED, la velocidad de un motor etc. usaremos una señal PWM

(Imagen 15) Tipos de señales.

Programación Arduino con Ardublock

6. 'Hola Mundo'. Hola Mundo es el programa mas empleado como introducción a cualquier lenguaje de programación. En lenguajes empleados en los microcontroladores (Arduino en nuestro caso) se suele utilizar un LED intermitente, de forma que se asignan estados altos '1' y bajos '0' alternativamente por un puerto de salida al que conectaremos un LED. El efecto es ver como se enciende y se apaga un LED. Un LED [11] (Ligth Emitting Diode) es un dispositivo electrónico (diodo) que emite luz. Actualmente podemos encontrar LEDs de diferentes colores, LED's RGB y su utilización se extiende desde un simple indicador hasta las mas modernas tecnologías de iluminación, en pantallas y paneles indicadores.

(Imagen 16) Circuito LED's. Hay que tener en cuenta que los Led tienen polarización (es decir tienen un terminal + llamado ánodo y uno negativo – llamado cátodo) por lo tanto tendremos que tener cuidado cómo lo colocamos. Vamos a implementar un sencillo circuito intermitente con nuestro Arduino.

Programación Arduino con Ardublock

LED Intermitente. Materiales: 1 Arduino. 1 LED 1 Resistencia 470 Ω (Amarillo Violeta Marrón Oro) cables y una Protoboard (placa de conexiones para realizar prototipos electrónicos) El circuito eléctrico realizado con el software Fritzing [12] es el siguiente:

(Imagen 17) Circuito Led con Fritzing. Utilizaremos los Pins GND y D7 (Salida digital 7) en Arduino. Programa: Iniciamos el entorno de programación Arduino IDE y en el menú de Herramientas pulsamos sobre Ardublock. Dibujamos muestro programa y una vez revisado el código pulsamos sobre el botón Upload to Arduino, el programa aparecerá en el entorno de programación, se compilará* y se cargará en la placa Arduino. Si conectamos el circuito correctamente el LED empezará a parpadear con 1 segundo de retardo. * Compilar significa traducir el lenguaje del programa a un lenguaje que la máquina (en este caso Arduino) pueda entender.

(Imagen 18) Programa LED Blink 18

Programaci贸n Arduino con Ardublock

V铆deo sobre la programaci贸n LED Blink con tiempos de reatrdo (delay) de medio segundo. http://www.youtube.com/watch?v=Zzh2e00Ukjc Links: [11] http://es.wikipedia.org/wiki/Led [12] http://fritzing.org/home/

Programación Arduino con Ardublock

7. Jugando con LED's. Podemos controlar LED's con Arduino de forma creativa, veamos un ejemplo: 2 LED's controlados con 1 salida. 1 Arduino. 2 LED 2 Resistencia 330 Ω (Naranja Naranja Marrón Oro) cables y una Protoboard (placa de conexiones para realizar prototipos electrónicos)

(Imagen 19) 2 Led's con 1 Salida. El circuito anterior permite conmutar 2 LED's de forma que mientras el primero está a nivel bajo, el otro estará a nivel alto. Podemos controlar el tiempo que está cada uno encendido mediante la instrucción delay. El tiempo generalmente se indica en milisegundos excepto cuando utilizamos otra escala en microsegundos, así delay (1000); indica un retardo de 1 segundo. Vamos a realizar una secuencia de 1 segundo cada led, 2 segundos cada led y 3 segundos led1 y 1 segundo led 2. Utilizaremos el bloque [delay MILIS miliseconds] Vamos a conectar nuestros LED's a la salida D7 de Arduino. Necesitamos conectar a +5V del Arduino nuestro circuito de LED's y la señal de control estará conectada en la unión de los LED's. Recordar que estos diodos Led tienen polaridad, así que sólo recordar que la patilla más larga es + (ánodo).

Programaci贸n Arduino con Ardublock

Programa en Ardublock:

(Imagen 20) 2 Leds El programa es muy simple y s贸lo enviamos por el pin D7 se帽ales ON y OFF con los retardos (delays) correspondientes. PROGRAMA 2LEDS.ino void setup()

// CONFIGURACION ENTRADAS Y SALIDAS

{ pinMode( 7 , OUTPUT);

// PIN7 COMO SALIDA

} void loop()

// INICIO SECUENCIAL

{ digitalWrite( 7 , HIGH );

// SALIDA A '1'

delay( 1000 );

// RETARDO DE 1 SEG

digitalWrite( 7 , LOW );

// SALIDA PUESTA A '0'

delay( 1000 );

// RETARDO 1 SEG

digitalWrite( 7 , HIGH ); delay( 2000 );

// RETARDO 2 SEGUNDOS

digitalWrite( 7 , LOW ); delay( 2000 ); digitalWrite( 7 , HIGH ); delay( 3000 );

// RETARDO 3 SEGUNDOS

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

} 21

Programación Arduino con Ardublock

Circuito:

(Imagen 21) 2LEDS protoboard. Esquema:

(Imagen 22) Esquema eléctrico 2 LEDS 1 Salida. Vídeo youtube http://youtu.be/KILIg76Q9SM LED'S RGB Un diodo led RGB [14] realmente es un dispositivo electrónico con 3 leds de diferentes colores en la misma cápsula. Los LED's son R(Red) G(Green) B (Blue) es decir Rojo, Verde y Azul. Hay de cátodo comúm (-) o de ánodo común (+). Necesitaremos 3 pins de salida en Arduino para poder activar cada uno de los LED. D8 Rojo, D9 Verde y D10 Azul.

Programación Arduino con Ardublock

(Imagen 23) LED RGB Cátodo comúm. Vamos a implementar un sencillo secuenciador de colores para un LED RGB de cátodo común, utilizaremos las salidas D8,D9,D10 LED RGB Materiales: 1 Arduino. 1 LED RGB 3 Resistencias 330 Ω (Naranja Naranja Marrón Oro) cables y una Protoboard (placa de conexiones para realizar prototipos electrónicos) Circuito:

(Imagen 24) RGB LED Vamos a realizar una secuencia de colores Rojo, Verde, Azul con un delay de 1 segundo entre cada transición. Utilizaremos un nuevo concepto en Ardublock, utilizaremos tres subrutinas[13], una para cada color. Vamos a utilizar subrutinas, básicamente son subprogramas que llamamos cuando los necesitamos y los desarrollamos como bloques aparte. 23

Programaci贸n Arduino con Ardublock

(Imagen 25) Uso de subrutinas Programa:

(Imagen 26)Programa principal

(Imagen 27) Subrutinas reset,verde y azul. 24

Programaci贸n Arduino con Ardublock

(Imagen 28) Subrutina rojo. C贸digo RGB.ino //-------------- programa RGB secuencial -----------------------------------void reset(); //SUBRUTINA RESET void verde(); //SUBRUTINA VERDE void azul(); //SUBRUTINA AZUL void rojo(); //SUBRUTINA ROJO void setup() //CONFIGURA PINS SALIDA { pinMode( 8 , OUTPUT); pinMode( 9 , OUTPUT); pinMode( 10 , OUTPUT); } void loop() { reset(); //LLAMADA SUBRUTINA RESET rojo(); // LAMADA SUBRUTINA ROJO delay( 1000 ); //PAUSA 1 SEGUNDO reset(); verde(); delay( 1000 ); reset(); azul(); delay( 1000 ); }

Programaci贸n Arduino con Ardublock

// SUBRUTINAS QUE DEFINEN LOS COLORES void rojo() // ROJO 100 { digitalWrite( 8 , HIGH ); digitalWrite( 9 , LOW ); digitalWrite( 10 , LOW ); } void azul() //SUBRUTINA AZUL 001 { digitalWrite( 8 , LOW ); digitalWrite( 9 , LOW ); digitalWrite( 10 , HIGH ); } void reset() //SUBRUTINA RESET SALIDA 000 { digitalWrite( 8 , HIGH ); digitalWrite( 9 , LOW ); digitalWrite( 10 , LOW ); } void verde() //SUBRUTINA VERDE 010 { digitalWrite( 8 , LOW ); digitalWrite( 9 , HIGH ); digitalWrite( 10 , LOW ); } [13] http://arduino.cc/es/Reference/FunctionDeclaration [14] https://www.sparkfun.com/products/105 [15] http://youtu.be/KILIg76Q9SM 2 Leds [16] http://youtu.be/ZBSirFV-SYE Led RGB Secuencial

Programación Arduino con Ardublock

8. Entradas digitales. Arduino tiene 14 entradas digitales. Van numeradas desde D0 a D13.

(Imagen 29) PINES entradas digitales. Los pines por defecto están configurados como entradas y en estado de alta impedancia, esto significa que circula muy poca corriente y por tanto no afecta al circuito que está conectado. Tambien cambiará de estado el pin con variaciones muy pequeñas de señal, por contra los PINEs al aire pueden ser afectados por variaciones de señal como el ruido radioeléctrico por lo que necesitaremos resistencias pullup (conectadas a 5V) o pulldown (conectadas a GND) para poder controlar las señales. [17]. Cualquier sensor digital, interruptor o pulsador lo conectaremos de la siguiente forma: Conexión de un pulsador como entrada digital.

(Imagen 30) Entrada pulsador.

Programación Arduino con Ardublock

En el caso anterior tenemos entrada '1' es decir 5V cuando pulsamos. Podemos realizar entradas a '0' o GND intercambiando el pulsador por la resistencia.

(Imagen 31) Entradas Digitales '0' Entradas digitales por pulsador. Vamos a implementar una función AND [18] de dos entradas(D2 y D3), de forma que cuando los dos pulsadores se activen, se iluminará un LED (D7), si no se produce este hecho el LED permanece apagado. Utilizamos un delay de 1 segundo despues de cada activación del LED. Utilizaremos la función IF – ELSE [19]. En Ardublock podemos encontrar esta estructura de control como IF - - TEST --- THEN – ELSE en el bloque de control. Materiales: 1 Arduino. 2 Pulsadores 2 Resistencias 10 kΩ (Marrón Negro Naranja Oro) 1 Resistencia 330 Ω (Naranja Naranja Marrón Oro) cables y una Protoboard

Programaci贸n Arduino con Ardublock

Circuito:

(Imagen 32) AND Esquema:

(Imagen 33) Esquema AND

Programación Arduino con Ardublock

Programa:

(Imagen 34) Ardublock NAND Código: // FUNCION AND DOS ENTRADAS PINES D2 Y D3 SALIDA LED D7 void setup() { pinMode( 2, INPUT); // PULSADOR 1 pinMode( 3, INPUT); // PULSADOR 2 pinMode( 7 , OUTPUT); // LED SALIDA } void loop() { if (( digitalRead(2) && digitalRead(3) )) // FUNCION IF … ELSE &&=AND { digitalWrite( 7 , HIGH ); // SI LOS 2 PULSADORES ESTADO = '1' delay( 1000 ); // RETRASO 1 SEGUNDO } else { digitalWrite( 7 , LOW ); // SINO ESTAN A '1' CUALQUIERA DE LOS 2 } // PULSADORES LED='0' }

Programaci贸n Arduino con Ardublock

Links: [17] http://arduino.cc/es/Tutorial/DigitalPins [18] http://es.wikipedia.org/wiki/Puerta_l%C3%B3gica [19] http://arduino.cc/en/Tutorial/IfStatement http://arduino.cc/es/Reference/Else V铆deo del sistema en funcionamiento. [20] http://youtu.be/zJFAtYXUDgY

Programación Arduino con Ardublock

9. Entradas analógicas. Arduino tiene 6 entradas analógicas numeradas desde A0 a A5.

(Imagen 35) Entradas analógicas Una entrada analógica es aquella que lee datos que varían con el tiempo, se asocian a estas entradas sensores de luz, temperatura, tensión, es decir señales físicas variables con el tiempo. Arduino permite además utilizar estas entradas como entradas/salidas digitales [21] Vamos a utilizar una resistencia variable (potenciómetro) para simular una señal analógica en Arduino y ver su valor a través del monitor de puerto serie de comunicaciones.

(Imagen 36) Potenciómetro. Un potenciómetro es una resistencia variable con un eje central. Tiene tres PINS de forma que conectando el PIN 2 a una entrada analógica y variando el eje tendremos valores entre 0 y Rmax, así si el potenciómetro es de 10KΩ los valores estarán entre 0 y 10000Ω. Los conversores A/D son de 10 bits, por lo tanto Arduino reconocerá valores entre 0 y 1023 (2¹⁰)

Programación Arduino con Ardublock

Entradas analógicas con potenciómetro. Vamos a implementar un circuito para leer entradas analógicas mediante un potenciómetro. Materiales: 1 Arduino. 1 Potenciómetro 10 kΩ cables y una Protoboard Para ello vamos a introducir dos conceptos nuevos en Ardublock, VARIABLES y SERIAL PRINT. Una variable es un espacio de memoria que asignamos para guardar valores que cambien durante la ejecución del programa. Utilizaremos una variable pot para guardar los valores leidos por la entrada analógica A1. [22] Por otra parte para poder visualizar los datos leídos a través de la entrada A1, vamos a utilizar SERIAL PRINT para imprimir los datos. [23] Desde el Arduino IDE abrimos el menú de herramientas y encontraremos la opción monitor serie. Circuito:

(Imagen 37) Potenciómetro entrada Analógica. Podemos ver como el PIN central que corresponde a un cursor que se mueve solidariamente con el eje lo conectados a A1. Los otros dos PINS los conectamos a +5V y GND de Arduino.

Programación Arduino con Ardublock

Programa:

(Imagen 38) Potenciómetro Ardublock Código: // LECTURA ANALÓGICA POTENCIÓMETRO int _ABVAR_1_pot = 0 ; // DEFINICIÓN VARIABLE POT void setup() { Serial.begin(9600); }

// ACTIVAMOS SERIAL PORT (VELOCIDAD 9600 BAUDIOS)

void loop() { _ABVAR_1_pot = analogRead(1) ; // ASIGNAMOS VALOR LEIDO A1 A POT Serial.print("VALOR POT 0"); // ESCRIBIMOS EL MENSAJE VALOR POT 0 Serial.print(_ABVAR_1_pot); // ESCRIBIMOS EL VALOR DE LA VARIABLE Serial.println(); // SALTO DE LÍNEA }

Programación Arduino con Ardublock

Detección nivel por potenciómetro. Vamos a añadir un LED al ejemplo anterior, de forma que al pasar los 2/3 del valor se indique mediante un LED conectado a D8. Materiales: 1 Arduino. 1 Potenciómetro 10 kΩ 1 LED 1 Resistencia 330Ω cables y una Protoboard Circuito:

(Imagen 39) Potenciómetro entrada Analógica. Esquema:

(Imagen 40) Esquema Potenciómetro entrada Analógica.

Programación Arduino con Ardublock

Programa:

(Imagen 41) Activación LED con POT Analógico Código: int _ABVAR_1_pot = 0 ;

// ACTIVACION LED SI POT > 2/3 RECORRIDO

void setup() { Serial.begin(9600); pinMode( 8 , OUTPUT); } void loop() { _ABVAR_1_pot = analogRead(1) ; Serial.print("VALOR POT 0"); Serial.print(_ABVAR_1_pot); Serial.println(); if (( ( _ABVAR_1_pot ) > ( 680 ) )) // SI POT > 680 (2/3) entonces { digitalWrite( 8 , HIGH ); // ACTIVA LED } else { digitalWrite( 8 , LOW ); // SI POT <680 DESACTIVA LED } }

Código de programación SKETCH que aparece en Arduino IDE.

Programación Arduino con Ardublock

(Imagen 42) Monitor Puerto Serie. Podemos ver los diferentes valores leídos por el puerto analógico A1 mediante la herramienta Monitor Serie de Arduino IDE, Ardublock también puede lanzar el monitor mediante el botón Serial Monitor. Links: [21] http://arduino.cc/es/Tutorial/AnalogInputPins [22] http://arduino.cc/es/Tutorial/Variables http://es.wikipedia.org/wiki/Variable_(programaci%C3%B3n) [23]http://arduino.cc/es/Serial/Print [24] Potenciómetros: http://es.wikipedia.org/wiki/Potenci%C3%B3metro http://www.sparkfun.com/datasheets/Components/General/R12-0-.pdf http://es.rs-online.com/web/p/potenciometros/7899403/ Youtube : http://youtu.be/nEG5C2Z3o34

Programación Arduino con Ardublock

10. Salidas PWM. La Modulación por Ancho de Pulso (PWM en inglés) es una técnica para enviar señales cuadradas de la misma frecuencia pero de ancho variable de forma que podemos controlar el tiempo que se envía una señal a un dispositivo pero con la misma frecuencia. [25] Los PIN'S PWM en Arduino UNO son los siguientes, hay que tener en cuenta que diferentes modelos tendrán otros PIN'S PWM

(Imagen 43) Pines PWM en Arduino UNO El comando que controla esta señal es analogWrite(PIN,VALOR) donde PIN es un valor numérico (3,5,6,9,10,11) en la imagen anterior y VALOR puede ser desde 0 (apagado) hasta 255 (Valor máximo).

(Imagen 44) Comportamiento de las señales PWM

Programación Arduino con Ardublock

LED mediante PWM El concepto de FADE IN consiste en un fundido de entrada desde 0 al nivel máximo y FADE OUT es exactamente lo contrario, un efecto de desvanecimiento. Veamos como podemos realizar esto mediante señales PWM y un LED conectado al terminal D3. Materiales: 1 Arduino. 1 Resistencia 220 Ω 1 LED cables y una Protoboard Circuito:

(Imagen 45) LED Fade IN Fade OUTPrograma: Programa:

(Imagen 46) Fade IN Fade OUT 39

Programación Arduino con Ardublock

Código: int _ABVAR_1_fade = 0 ; void setup() { pinMode( 3 , OUTPUT); } void loop() { _ABVAR_1_fade = 0 ; for(_ABVAR_1_fade = 0; 0<=255?_ABVAR_1_fade <= 255:_ABVAR_1_fade >= 255; 0<=255?_ABVAR_1_fade = _ABVAR_1_fade + 1:_ABVAR_1_fade = _ABVAR_1_fade - 1) { analogWrite(3 , _ABVAR_1_fade); delay( 10 ); } for(_ABVAR_1_fade = 255; 255<=0?_ABVAR_1_fade <= 0:_ABVAR_1_fade >= 0; 255<=0?_ABVAR_1_fade = _ABVAR_1_fade + 1:_ABVAR_1_fade = _ABVAR_1_fade - 1) { analogWrite(3 , _ABVAR_1_fade); delay( 10 ); } } Las señales PWM se utilizan para controlar velocidades de motores, para controlar nivel de iluminación, controlar el flujo de fluidos, velocidad de ventiladores, Links: [25] http://arduino.cc/es/Tutorial/SecretsOfArduinoPWM http://arduino.cc/es/Reference/analogWrite [26] Youtube: Funcionamiento del sistema https://www.youtube.com/watch?v=qsT31l84N30 Señal PWM en un Osciloscopio. https://www.youtube.com/watch?v=uyYA3rvdv1c

Programación Arduino con Ardublock

11. Diagramas de flujo. Un flujograma es una representación gráfica de un programa, se recomienda antes de iniciar la programación, realizar el diagrama de flujo para organizar y aclarar las ideas sobre el programa que vamos a realizar. Veamos los símbolos mas comunes y algunos ejemplos.

(Imagen 47) Símbolos flujogramas. Ejemplo: Activar un led cuando se activa un pulsador con un retardo de un segundo.

(Imagen 48) Activar led con pulsador.

Links: [27] Diagramas de flujo http://es.wikipedia.org/wiki/Diagrama_de_flujo

Programación Arduino con Ardublock

12. Estructuras de control. Los programas en Arduino se ejecutan en bucle (loop do), es decir se ejecutan las instrucciones una detrás de otra y cuando llega al final, empieza de nuevo. Pero muchas veces necesitamos modificar el flujo secuencial del programa. Es decir se interrumpe el flujo original para realizar otras secuencias, por ejemplo si realizamos una alarma, tendremos que alterar la secuencia en el momento que un sensor se active para indicarnos que ha saltado la alarma. En programación se utilizan de forma habitual los contadores, son variables que se incrementan o se decrementan en función de unas entradas. Por ejemplo si diseñamos una empaquetadora de botes y queremos que cada caja contenga 12 elementos, necesitaremos un contador. Podemos necesitar que el programa se comporte de una forma si se cumplen unas condiciones y de otra si se cumplen otras, por ejemplo en el caso de que la temperatura esté por encima de los 20 grados y el sensor de luz se activa baja el toldo, y si no se cumple estas condiciones deja el toldo subido. También podemos encontrarnos en el caso que se tengan que ejecutar unas instrucciones hasta que se cumpla una condición. Por ejemplo: activa la bomba de agua del depósito y muestra el valor del nivel del depósito hasta que el sensor de llenado se active, en este momento para la bomba y muestra el mensaje 'depósito lleno'. Todas las estructuras pueden ser: 1. Secuenciales (se ejecutan las instrucciones en bucle) 2. Iteractivas (dependiendo de las entradas se ejecutan de una forma o de otra) 3. Estructuras avanzadas (son estructuras mas complejas) Las estructuras de control son fácilmente implementables con Ardublock.

(Imagen 49) Estructuras de control Ardublock.

Programación Arduino con Ardublock

Ardublock y las estructuras de control. Ardublock

Arduino

Función

void setup() { pinMode( 1 , INPUT); pinMode( 2 , OUTPUT); } void loop() { if (digitalRead(1)) { digitalWrite( 2 , HIGH ); } }

Entradas Pin 1 Salidas Pin 2

void setup() { pinMode( 1 , INPUT); pinMode( 2 , OUTPUT); } void loop() { if (digitalRead(1)) { digitalWrite( 2 , HIGH ); } else { digitalWrite( 2 , LOW ); } }

Entradas Pin 1 Salidas Pin 2

void setup() { pinMode( 1 , INPUT); pinMode( 2 , OUTPUT); } void loop() { digitalWrite( 2 , HIGH ); while ( digitalRead(1) ) { digitalWrite( 2 , LOW ); } }

Entradas Pin 1 Salidas Pin 2 Activamos la salida Pin 2, mientras esté activa la entrada 1, la salida 2 estará en OFF (El test se realiza antes de los comandos)

void setup() { pinMode( 1 , INPUT); pinMode( 2 , OUTPUT); } void loop() { digitalWrite( 2 , HIGH ); do { digitalWrite( 2 , LOW ); } while(digitalRead(1)); }

Entradas Pin 1 Salidas Pin 2 Activamos la salida Pin 2, mientras esté activa la entrada 1, la salida 2 estará en OFF (En este caso se realiza el test después de los comandos)

Si entrada 1 se activa,pondremos la salida 2 en ON

Si entrada 1 se activa,pondremos la salida 2 en ON sino, la salida 2 en OFF

Programación Arduino con Ardublock int _ABVAR_1_a; void setup() { pinMode( 1 , OUTPUT); pinMode( 2 , OUTPUT); } void loop() { for (_ABVAR_1_a=1; _ABVAR_1_a<= ( 5 ); ++_ABVAR_1_a ) { digitalWrite( 1 , HIGH ); delay( 1000 ); digitalWrite( 1 , LOW ); } digitalWrite( 2 , HIGH ); }

Entradas Pin 1 Salidas Pin 2 Se utiliza una variable Integer = ABVR_1_a Se repite 5 veces salida Pin 1 ON, Delay 1 seg Salida Pin 1 OFF, después salida 2 ON

int _ABVAR_1_v1 = 0 ; void setup() { pinMode( 1 , OUTPUT); } void loop() { for (_ABVAR_1_v1= 1; _ABVAR_1_v1<= ( 12 ); _ABVAR_1_v1+ +) { digitalWrite( 1 , HIGH ); delay( 1000 ); digitalWrite( 1 , LOW ); delay( 1000 ); } }

Salidas Pin 1 Se utiliza una variable Integer = ABVR_1_v1 Se repite la secuencia Pin 1 ON, Pin 1 OFF con un retardo de 1 seg y se incrementa la variable ABV_1_v1 cada vez. La repetición son 12 veces.

int _ABVAR_1_v1 = 0 ; void setup() { pinMode( 1 , OUTPUT); }

void loop() { for(_ABVAR_1_v1 = 1; 1<=12?_ABVAR_1_v1 <= 12:_ABVAR_1_v1 >= 12; 1<=12?_ABVAR_1_v1 = _ABVAR_1_v1 + 2:_ABVAR_1_v1 = _ABVAR_1_v1 - 2) { digitalWrite( 1 , HIGH ); delay( 1000 ); digitalWrite( 1 , LOW ); delay( 1000 ); } } for (x = 0; x < 255; x ++) { digitalWrite(PWMpin, x); sens = analogRead(sensorPin); if (sens > threshold){ // bail out on sensor detect x = 0; break; } delay(50); } * De arduino.cc

Sirve para salir de una secuencia

Programación Arduino con Ardublock

Subrutinas. Las subrutinas llamadas también subprogramas, procedimientos o funciones son trozos de programa separados del bloque principal y que podemos llamar cuando queramos, la subrutina devuelve el resultado y el programa continua su ejecución en el punto donde estaba. Imaginemos que queremos implementar un programa y que tenga una función que se repite muchas veces, podemos llamar a la subrutina en cada punto del programa que l necesitemos, con lo que nos ahorramos teclear el código de esta función cada vez. Sirve para estructurar y clarificar los programas. Ardublock

Arduino

Función Llamada a la subrutina. Subrutina con los comandos que ejecuta.

void blink(); void setup() { pinMode( 1 , OUTPUT); } void loop() { blink(); //llamada a la funcion }

Llamamos a la funcion blink que produce un parpadeo del led en el pin1 con un retrado de 1 segundo. Al terminar la subrutina, el programa sigue su curso normal.

void blink() //funcion { digitalWrite( 1 , HIGH ); delay( 1000 ); digitalWrite( 1 , LOW ); delay( 1000 ); }

Links: [28] Estructuras de control. http://es.wikipedia.org/wiki/Estructuras_de_control [29] Subrutinas. http://es.wikipedia.org/wiki/Subrutina [30] Referencia Arduino. http://arduino.cc/en/Reference/HomePage

Programación Arduino con Ardublock

13 Relés. Un relé es un interruptor controlado eléctricamente. Se utiliza para controlar dispositivos de mayor potencia. En el caso de Arduino la corriente máxima de cada pin de salida es de 40 mA para 5V y 50mA si trabajamos con 3,3.V, pero ¿qué ocurre si queremos conectar una lámpara de 220V y 500mA? La solución es utilizar un relé que activará Arduino y éste relé cerrará el circuito de alimentación de la lámpara. Si queremos utilizar dispositivos de potencia, podemos utilizar un relé.

Ejemplos de Relés. (wikipedia)

Simbología

Tipos.

Un relé está compuesto de una bobina (circuito electromagnético) y uno o varios contactos (circuito eléctrico).

(Imagen 50) Activación de una lámpara con un relé. Uno de los problemas de los relés es el tiempo de acionamiento y su vida útil. Son muy interesantes para cargas que consuman mucha intensidad. Actualmente existe una gran variedad de Relés y la tendencia es utilizar relés de estado sólido, donde el contacto se sustituye por un interruptor tipo transistor para DC y triac para AC. (DC Corriente contínua y AC Corriente Alterna) Tambien podemos encontrar relés reed que son un cilindro con unas láminas contacto y la bobina arrollada al cilindro, generalmente están integrados con forma de circuito integrado. 46

Programación Arduino con Ardublock

A la hora de elegir un relé tendremos que tener una serie de consideraciones. •

Tensión de funcionamiento de la bobina.

•

Intensidad consumida por la bobina.

•

Tiempo de operación (generalmente en ms)

•

Vida útil (número mínimo de aperturas y cerraduras del contacto)

•

Tensión máxima soportada por el contacto.

•

Intensidad máxima soportada por el contacto.

•

Resistencia y tensión máxima de aislamiento.

Datos de la bobina de un relé Omrom.

Tiempo de operación y vida útil de un relé OMROM.

Activación Relé con pulsador. Vamos a activar un relé mediante un pulsador de forma que realiza la función de telerruptor. (Un pulso se activa y el siguiente pulso desactiva). Vamos a colocar un led para determinar si está activo o no.

Programación Arduino con Ardublock

Materiales: 1 Arduino. 1 Resistencia 220 Ω 1 Resistencia 10KΩ 1 LED 1 Pulsador 1 Relé 5V compatible Arduino. cables y una Protoboard Circuito:

(Imagen 51) Circuito activación de una lámpara con un relé.

Es muy importante no confundir el circuito de mando del relé (5V DC) con el circuito de carga (220V AC), por lo que es recomendable probar su funcionamiento primero sin carga. Los circuito conectados a 220V AC tiene riesgo eléctrico, así que mucho cuidado. Esquema:

(Imagen 52) Esquema. Relé con Arduino.

Programaci贸n Arduino con Ardublock

Programa:

(Imagen 53) C贸digo Ardublock. Rel茅 con Arduino.

C贸digo: bool _ABVAR_1_valor= false ; void setup() { pinMode( 8 , INPUT); // entrada pulsador pinMode( 4 , OUTPUT); //salida led pinMode( 2 , OUTPUT); // salida rele } void loop() { if (digitalRead(8)) { _ABVAR_1_valor = !( _ABVAR_1_valor ) ; //cada vez que pulsamos cambiamos valor } // variable bool_ABVAR_1_valor digitalWrite( 4 , _ABVAR_1_valor ); //escribimos en el rele el valor de la variable digitalWrite( 2 , _ABVAR_1_valor ); delay( 300 ); //retardo para evitar cambios bruscos en la varible }

Programación Arduino con Ardublock

Links: [31] Relés Wikipedia. http://es.wikipedia.org/wiki/Rel%C3%A9 [32] Funcionamiento relé (youtube). http://www.youtube.com/watch?v=QjszJEncew8 [33] PDF Datasheet Relés OMROM http://docseurope.electrocomponents.com/webdocs/002b/0900766b8002b94f.pdf [34] Símbolos. http://www.simbologia-electronica.com/simbolos-electricoselectronicos/simbolos-reles.htm

Programación Arduino con Ardublock

14 Uso del transistor para el control de corrientes elevadas. Arduino puede entregar como máximo I=40 mA por cada pin de salida digital, si necesitamos controlar dispositivos con un consumo de corriente mayor debemos utilizar un transistor. Además mediante un transistor podemos manejar tensiones diferentes ( por ejemplo alimentar motores cc de 3V) por lo que nos permite más posibilidades. Hay básicamente dos tipos de transistores los transistores bipolares BJT, y los de efecto de campo MOS y JFET. [35] Además dentro de cada categoria podemos encontrar transistores NPN, PNP,JFET Canal P, N. Existen fototransistores, Transistores Darlington para grandes potencias y de otros tipos. Los transistores van encapsulados de distintas formas y mediante la hoja de características (datasheet) del fabricante obtenemos su patillaje y características. Símbolos

Pines PNP BCE (Base, Colector,Emisor) NPN BCE (Base, Colector,Emisor) Canal P GDS (Gate,Drain,Source) Canal N GDS (Gate,Drain,Source)

(Imagen 54) Símbolos

Pueden funcionar como interruptores o amplificadores, en nuestro caso utilizaremos un transistor de pequeña potencia, un BC547c, un transistor NPN funcionando como interruptor para el control de un relé y el control de un pequeño motor de CC. Transistor BC547B Encapsulado TO 92 (Los encapsulados son estándard) [37] 1. Colector 2.Base 3.Emisor (Imagen 55) Encapsulado

Como elemento de protección del circuito contra corrientes transitorias producidas por la bobina colocamos un diodo 1N4007 polarizado inversamente. [38]

Programación Arduino con Ardublock

(Imagen 55) Hoja de datos de BC547 de Fairchild [36]

Control de un relé mediante transistor. Mediante el pin digital 3 de Arduino saturamos la base del transistor, este actuará como un interruptor Materiales: 1 Arduino. 1 Transistor BC547B 1 Resistencia 1kΩ 1 Resistencia 330Ω 1 Diodo 1N4007 1 Relé 5V cables y una Protoboard

Programación Arduino con Ardublock

Circuito:

(Imagen 56) Control de Relé mediante transistor.

Esquema:

(Imagen 57) Esquema eléctrico.

Programa: Vamos a activar el pin 3 donde está colocada la base del transistor, al activar el pin 3 estará activo durante 5 segundos, luego se desactiv durante 5 segundos mas y comienza el bucle de nuevo. Según el fabricante de relé SONGLE RELAY [39] el consumo es de 71mA (por debajo de los 100mA del TRT) y puede soportar hasta 30 operaciones (ON/OFF) por minuto, dato importante a la hora de calcular la velocidad de conmutación.

Programaciรณn Arduino con Ardublock

(Imagen 58) Programa con 5 segundos entre transiciรณn.

Cรณdigo: void setup() { pinMode( 3 , OUTPUT); } void loop() { digitalWrite( 3 , HIGH ); delay( 5000 ); digitalWrite( 3 , LOW ); delay( 5000 ); } Control de un motor de DC mediante transistor. Vamos a controlar un motor mediante una salida PWM (3), para ello utilizamos un transistor BD137 [40] que puede soportar una corriente de colector de 1.5 Amperios. El motor de juguete funciona con 3V y consume un amperio. Vamos a controlar la velocidad automรกticamente. Materiales: 1 Arduino. 1 Transistor BD137 1 Resistencia 1kฮฉ 1 Diodo 1N4007 cables y una Protoboard

Programación Arduino con Ardublock

Circuito:

(Imagen 59) Motor de 3V DC alimentado a baterías.

Esquema:

(Imagen 60) Esquema .Control motor de 3V DC alimentado a baterías.

Programaci贸n Arduino con Ardublock

Programa:

(Imagen 61) Programa Ardublock

C贸digo: int _ABVAR_1_vel = 0 ; void setup() { pinMode( 3 , OUTPUT); Serial.begin(9600); } void loop() { _ABVAR_1_vel = 50 ; while ( ( ( _ABVAR_1_vel ) < ( 150 ) ) ) { _ABVAR_1_vel = ( _ABVAR_1_vel + 1 ) ; analogWrite(3 , _ABVAR_1_vel); Serial.print("vel ="); Serial.print(_ABVAR_1_vel); Serial.println(); delay( 100 ); } } Si queremos controlar el sentido de giro podemos utiliza un puente en H [41], podemos utilizar un Arduino motor shield (http://arduino.cc/en/Main/ArduinoMotorShieldR3) o otros circuitos como el Ardumoto (http://tienda.bricogeek.com/shields-arduino/429ardumoto-driver-de-motores-para-arduino.html)

Programaci贸n Arduino con Ardublock

Links: [35] Transistores. http://es.wikipedia.org/wiki/Transistor [36] Datasheet: https://www.fairchildsemi.com/datasheets/BC/BC547.pdf [37] Encapsuldos: http://bricotronika.blogspot.com.es/2013/04/identificacion-determinales-en-los.html [38] http://panamahitek.com/conceptos-basicos-de-electronica-el-diodo/ [39]https://www.ghielectronics.com/downloads/man/20084141716341001RelayX1.pdf [40]pdf.datasheetcatalog.com/datasheet/fairchild/BD137.pdf [41]http://es.wikipedia.org/wiki/Puente_H_%28electr%C3%B3nica%29 [42] V铆deo Youtube http://youtu.be/Rr8xFHyV-JI

Programación Arduino con Ardublock

15 Servomotores: Control con Arduino. Un servomotor es un motor de corriente continua que funciona mediante señales de ancho variable (PWM) y puede situarse dentro de su rango de funcionamiento, generalmente entre -90o y +90o (es decir un recorrido de 180 grados)

(Imagen 62) Servo SG-90

Está formado por un motor de DC, unos engranajes, un potenciómetro solidario con el eje de los engranajes del motor y un circuito electrónico. Tiene tres cables de conexión, dos de alimentación +Vcc y GND y uno de entrada de control mediante pulsos (PWM). Su funcionamiento es simple, al introducir una señal PWM, el circuito electrónico interno compara esta señal con la señal de posición del potenciómetro y mueve el motor hasta ajustar los grados requeridos y equilibrar las señales. Los parámetros más importantes del servo SG-90 [43] son: Tensión de funcionamiento: Entre 4,8 y 6 Volts. Torque [44] es el par motor o momento de fuerza sobre el eje de transmisión de potencia. Velocidad 0.1 m/s Peso 14,7 grm Conexionado: Rojo +Vcc, Marrón GND, Amarillo señal de control. Señal de control. El ancho de la señal de control PWM posicionará el servo de forma que para 1ms tenemos -90o ,1,5 ms son 0o y con 2ms tendremos 90o. Señales PWM Servomotor 0 Grados 90 Grados -90 Grados 0

Ciclos de 20 ms (50 Hz). Escala 0.5 ms /div

(Imagen 63) Diagrama de tiempos PWM Servomotor SG90

Programaciรณn Arduino con Ardublock

Control de un servomotor mediante potenciรณmetro. Materiales: 1 Arduino. 1 Servomotor SG90 1 Potenciรณmetro o resistencia variable de 10kฮฉ Cables y protoboard Circuito:

(Imagen 64) Servo controlado por Resistencia variable.

Esquema:

(Imagen 65) Esquema control servo mediante potenciรณmetro.

Programación Arduino con Ardublock

Programa:

(Imagen 66) Programa Ardublock

(Imagen 67) Pines y mapeado de la variable.

Código: Para realizar la programación utilizamos la librería Servo.h. Como tenemos la entrada analógica del potenciómetro que varía entre 0 y 1023, tenemos que ajustar estos valores a la salida PWM que está entre 0 y 180, para ello mapeamos la variable mediante el comando map cuya función es ajustar estos valores. Esto significa que cada 5,6 valores en la entrada analógica 1 tendremos un grado de desplazamiento en el servo.

Programaci贸n Arduino con Ardublock

//----------------------------------------------------------//Control servo mediante Potenci贸metro // In pot pin analogico 1 // OUT PWM servo pin digital 5 //-----------------------------------------------------------#include <Servo.h> int _ABVAR_1_valorpot = 0 ; Servo servo_pin_5; void setup() { servo_pin_5.attach(5); } void loop() { _ABVAR_1_valorpot = map ( analogRead(1) , 0 , 1023 , 0 , 180 ) ; servo_pin_5.write( _ABVAR_1_valorpot ); } Control de un servomotor mediante LDR (Resistencia dependiente de la luz). Una ligera variaci贸n del circuito anterior es utilizar una LDR como elemento de control. Podemos utilizar este circuito para realizar un seguimiento del sol para una placa solar controlada por un servo. Materiales: 1 Arduino. 1 Servomotor SG90 1 Resistencia de 10k惟 1 LDR Circuito:

(Imagen 68) Servo y LDR.

Programación Arduino con Ardublock

Esquema:

(Imagen 69) Esquema.

Programa: Vamos a utilizar la librería Servo.h y el sensor analógico de luz ambiente (LDR). La LDR se conectará al pin analógico 0 y la salida PWM del servo en el pin 10 digital.

(Imagen 70) LDR con otra variación del Servo.

Programaci贸n Arduino con Ardublock

C贸digo: //-------------------------------------------------// LDR controla Servomotor // Servo en pin 10 digital //LDR en analog 0 //-------------------------------------------------#include <Servo.h> int _ABVAR_1_ldr = 0 ; Servo servo_pin_10; void setup() { servo_pin_10.attach(10); } void loop() { _ABVAR_1_ldr = map ( analogRead(0) , 0 , 1023 , 0 , 255 ) ; servo_pin_10.write( _ABVAR_1_ldr ); } Links: [43] Servomotor SG90 http://abc-rc.pl/sg-90 [44] Par motor https://es.wikipedia.org/wiki/Par_motor [45] V铆deo https://www.youtube.com/watch?v=Iif9ZIY9jMU [46] Software generador diagrama tiempos Wavedrom http://wavedrom.com/ [47] https://es.wikipedia.org/wiki/Servomotor_de_modelismo