SALIDAS PWM

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

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).

Comportamiento de las señales PWM

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:

LED Fade IN Fade OUT

Programa:

 Fade IN Fade OUT

Código:

fadein.ino

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,

El circuito en funcionamiento

Señal PWM en el Osciloscopio

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

E.Serra

Entradas analógicas.

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

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.

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¹⁰) 

ENTRADAS ANALÓGICAS POR 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:

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.

Programa:

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
}

DETECCIÓN DE 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:

Potenciómetro entrada Analógica.

Esquema:

Esquema Potenciómetro entrada Analógica.

Programa:

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.

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.

El circuito en funcionamiento.

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

E.Serra

Entradas Digitales

8. Entradas digitales.
Arduino tiene 14 entradas digitales. Están numeradas desde D0 a D13.

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.

Entrada pulsador.

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.

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 

Circuito:

AND

Esquema:

Esquema AND

Programa:

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' }

El sistema en acción.

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

[20] http://youtu.be/zJFAtYXUDgY

Jugando con LED's

7 JUGANDO CON LED'S

Podemos controlar LED's con Arduino de forma creativa, veamos un ejemplo:

DOS LED's CONTROLADOS CON 1 SALIDA

Materiales:
1 Arduino.
2 LED
2 Resistencia 330 Ω (Naranja Naranja Marrón Oro)
cables y una Protoboard (placa de conexiones para realizar prototipos electrónicos)

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).

Programa en Ardublock:

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 );
}
Circuito:

2LEDS protoboard.

Esquema:

Esquema eléctrico 2 LEDS 1 Salida.

Vídeo youtube 

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.

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:

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.

Uso de subrutinas

Programa:

Programa principal

 Subrutinas reset,verde y azul.

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 );
}
// 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

Hola Mundo

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.

 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.

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:

 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.

Programa LED Blink

Vídeo sobre la programación LED Blink con tiempos de reatrdo (delay) de medio segundo y 300 ms.

http://www.youtube.com/watch?v=Zzh2e00Ukjc

Links:
[11] http://es.wikipedia.org/wiki/Led

[12] http://fritzing.org/home/

Conceptos básicos

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.

Arduino y el mundo real.

Aduino puede controlar señales analógicas (entradas) y Digitales (analógicas y digitales)

Entradas y Salidas en Arduino.

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.

Pins Arduino

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)

PINES en Arduino

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

Tipos de señales.

Uso de 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.

 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)

 Biblioteca Control.

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

Biblioteca Pins.

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

Biblioteca Test.

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.

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.

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

Podemos buscar nuevas librerias o instalar Ardublock con distintas versiones.

http://sourceforge.net/projects/ardublock/files/?source=navbar

Instalación 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).

 Ardublock integrado en Arduino IDE

 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

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.

 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

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

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 

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

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/

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. 

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.

Biblioteca de bloques.

El menú principal.

Dentro del menú principal encontraremos unos botones que cada uno de ellos realiza una función específica.

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.

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.

Área programación.

Una vez instalado Ardublock ya estamos en condiciones de empezar a programar nuestro Arduino de foma visual con bloques.