Proyecto 3: Efecto Fade

Hoy os traigo un proyecto muy facil de hacer y que podremos usar en cualquier proyecto que incluya indicadores LED y queramos darle un toque diferente. Vamos a conseguir el efecto fade, esto es el encendido y/o apagado progresivo de un led.

Material:

- Arduino UNO

- LED

- Resistencia 1k

Teoría:

La teoría es la misma que la del proyecto 2 donde controlábamos la cantidad de brillo que nos entregaba el led mediante un potenciómetro. Aqui la única teoría nueva será la de como conseguimos que tanto el apagado como el encendido sea progresivo sin necesidad de variar nosotros el brillo mediante un potenciómetro y que además sea un incremento/decremento a ritmo constante. Muy sencillo.

Como vimos en el proyecto 2, una salida PWM de arduino tiene un rango entre 0 y 255, asi que al igual que haciamos con el potenciómetro, lo que debemos hacer es que nuestra salida varíe entre este rango, siendo 0 apagado y 255 el máximo brillo.

Montaje:

Simple como siempre, la resistencia a la salida PWM que hayais puesto en el código, la patilla positiva del led (la más larga)  al otro lado de la resistencia, y la patilla negativa (la más corta) a cualquier toma GND de nuestro Arduino. Ojo con que la salida sea PWM, si no es asi, el montaje no funcionará.

  

 Código:

Aquí es donde está el grueso del montaje. Como ya se ha comentado, el efecto fade lo vamos a conseguir variando el valor de una salida PWM, la cual tiene un rango entre 0 y 255. Para esto, vamos a definir tres variables:

   - pinLed: Aquí definiremos el pin que utilizaremos para controlar el led. Debe ser PWM.

   - brillo: Aquí se irá guardando el valor actual de brillo del led. Será el valor de la salida PWM, osea, que siempre será un valor entre 0 y 255 (recordemos, 0 apagado, 255 máximo brillo).

   - fade: Aquí definiremos la cantidad en que variará cada salto el valor de brillo.

Ahora vamos a explicar un poco más a fondo todo esto:

La variable "brillo", que será el valor de salida, siempre irá entre 0 y 255 por lo que a la variable "fade", que es la cantidad de ese rango en el que "brillo" varía cada vez, debe ser coherente con el efecto que queremos conseguir. Esto es, si pusiésemos un valor a "fade" de por ejemplo, 128, que es la mitad del rango, nuestro led iría cambiando desde 0, hasta 127 (mitad de brillo) y 255 (máximo brillo), y luego hacia atrás, 127, 0, 127,255, etc... En definitiva, que no habría efecto fade. Asi que si hicieramos todo lo contrario, es decir, poner un valor muy pequeño, se conseguiría este efecto. No hace falta darle de valor 1 para que se vea este efecto, de hecho, cada uno sois libres de ir probando valores hasta que encontreis el que os de el efecto que más os guste.

La variación la conseguiremos sumandole en cada vuelta el valor de "fade" al valor anterior de "brillo". Es decir, si brillo empieza con el valor 0 (apagado) y "fade" con 5, la siguiente vuelta se hará "brillo" + "fade" y se guardará en "brillo", osea 0 + 5 = 5. La siguiente vez se hará lo mismo, pero "brillo" ahora valdrá 5, por lo que 5 + 5 = 10, la siguiente vez será 10 + 5 = 15, etc... 

He puesto un "if" donde se detecta cuando la variable "brillo" se ha pasado del máximo o del mínimo, para cambiar de signo la variable "fade" y así seguir sin problema (de 0 a 255 será +5 y de 255 a + será -5).

Por último incluyo un delay para que sea visible el efecto, ya que sino se haría tan rápidamente que casi no se apreciaría.

Sin más, el código:

int pinLed = 9;   // salida PWM donde conectaremos la resistencia
int brillo = 0;   // el valor del brillo (salida) en cada momento
int fade = 5;     // incremento de brillo en cada vuelta

void setup()  
  { 
  pinMode(pinLed, OUTPUT); // definimos el pin como salida
  } 

void loop() 
  { 
  analogWrite(pinLed, brillo); // cambiamos el valor de salida  
  brillo = brillo + fade;      // siguiente valor de brillo

  
  if (brillo <= 0 || brillo >= 255)// Control de rango
    {
    fade = -fade;      // incremento/decremento
    }     
    
  delay(30);           // delay para que el efecto sea visible
  }

Eso es todo, a probar!

 

Proyecto 2: Control PWM de un LED

Este nuevo proyecto es continuación del anterior, ya que el montaje es muy similar. Sin embargo, aqui conseguiremos regular la intensidad con la que luce un led a nuestro antojo.

Material:

- Arduino UNO
- LED
- Resistencia 1K
- Potenciómetro 1K

Teoría:

Como habreis deducido es imposible conseguir, al menos a priori, que una saliga digital nos permita variar una señal de la manera que queremos hacerlo, esto es, de forma analógica ya que una salida digital solo tiene dos estados, 1 (5V) y 0 (0V).

Afortunadamente, existe una característica llamada PWM la cual nos permite justo eso, conseguir una señal analógica en una salida digital.

PWM son las siglas de "Pulse-width modulation", esto es, se modula la anchura de cada pulso digital. No voy a entrar a explicar los fundamentos teóricos de esta técnica porque son extensos y creo que innecesarios para lo que aqui pretendemos, que es la sencillez. Basicamente se basa en que si en un corto periodo de tiempo (muy corto), encendemos y apagamos repetidas veces el led, por ejemplo en una proporción 50/50 (50% del tiempo encendido y 50% apagado) lo que se apreciará es que solo se ilumina un 50% de su capacidad lumínica. Si este proceso se hiciera de forma lenta, simplemente veriamos el LED parpadeando.

Una vez explicado esto, que como digo no es necesario (el que quiera saber más hay infinidad de información en google y wikipedia), podemos explicar como variamos la cantidad de luz a nuestro antojo, lo cual es más interesante ya que es un tipo de control aplicable a cualquier proyecto Arduino que queramos hacer.

Usaremos un potenciómetro para variar la cantidad de luz que queremos que emita el led. El de la figura es el tipo que yo uso porque debido a las prácticas de la facultad tengo muchos como ese. Igualmente podeis usar cualquier otro, el funcionamiento es el mismo.

Estos componentes constan de 3 patillas, para saber cual es cual debeis buscar las especificaciones de vuestro modelo pero la configuración que aqui voy a explicar es la misma prácticamente para todos.

Las patillas suelen estar alineadas, o casi alineadas, asi que nos ayudará a identificarlas. Las patillas de los extremos son iguales, asi que una la conectais a 5V y la otra a 0V (lo único que cambiará es el sentido de giro del potenciómetro, cosa que es indiferente ahora mismo). Al estar asi conectado, lo que tendremos será un divisor de tensión, esto es, girando el potenciómetro modificaremos la resistencia a un lado y a otro de la patilla central, por lo que la tensión que encontraremos en la patilla central variará entre 5V (potenciómetro a tope en un sentido) y 0V (potenciómetro a tope en el otro sentido).

Como ya os habreis dado cuenta, la patilla central de nuestro potenciómetro deberá ir conectada a una entrada analógica de nuestro Arduino. 

Hasta aqui hemos visto los dos conceptos claves para este proyecto: el PWM y el potenciómetro.

Es fácil deducir la combinación que vamos a realizar, ¿verdad? Nuestro potenciómetro nos dará una señal entre 0 y 5V, es decir, 0% y 100%. Esto lo interpretará nuestra salida PWM como 0% y 100% de capacidad lumínica.

Montaje:

Muy, muy sencillo, no tiene pérdida. Solo hay que asegurarse de la polaridad del led y de que la salida digital que utilicemos sea PWM. Esto podemos saberlo mirando las salidas digitales de nuestro Arduino ya que las salidas PWM tienen un "~" al lado del número. En Arduino UNO las salidas 3, 5, 6, 9, 10, 11 son PWM.

Código:

El código necesita alguna explicación que os será útil conocer para futuros proyectos ya que como he dicho, este proyecto es tan sencillo como útil para cualquier proyecto.

Por una parte se hace la lectura de la entrada analógica A0, lo cual internamente hace una transformación de una señal analógica (entre 0 y 5V) a un dato digital (entre 0 y 1023). Esto es importante tenerlo en cuenta, ya que la salida PWM nos dará un valor entre 0 y 255 (recordemos que es un dato digital). Entonces, el problema es: ¿Cómo pasamos un dato de rango 0-1023 a un dato de rango 0-255? 

Facilísimo. Rápidamente nos damos cuenta de que la salida es 1/4 de la entrada, asi que lo que escribiremos en la salida PWM será la señal analógica medida en la entrada A0 pero dividida entre 4.

Ahí va el código:

int pinEntrada = A0;                  //Pin de entrada analogica
int pinLed = 9;                       //Pin de salida PWM
int resultado = 0;                    /*Variable que almacena la 
                                      conversion analog/digital*/
 
void setup() 
  {
  pinMode(pinLed, OUTPUT);            /*Definimos pinLed 
                                      como salida*/
  }
 
void loop() 
  {
  resultado = analogRead(pinEntrada); /*Lectura analogica de 
                                      nuestro potenciometro*/
  analogWrite(pinLed, resultado/4);   /*Escritura analogica en 
                                      salida PWM (resultado/4)*/
  }

Y hasta aquí! A probarlo!

Proyecto 1: Encender/apagar un LED

Este es el proyecto más básico, y por tanto, el primero que se debería hacer si eres nuevo en esto de Arduino.

El propósito es crear el parpadeo de un LED mediante nuestro Arduino UNO. Tras esto  haremos variaciones, como poder variar en vivo la frecuencia de parpadeo o hacer lo anterior con varios LEDs.

El material que necesitaremos será:

- Arduino UNO
- LED

Teoría:

Vamos a controlar el estado del LED haciendo uso de las salidas digitales de nuestro Arduino. Estas, como sabreis, tienen dos estados lógicos en los que se pueden encontrar, estos son 1 o 0. El 1 lógico corresponderá a un valor de 5V, mientras que el 0 lógico corresponderá a 0V.

Sabiendo esto, podemos deducir que conectándo el ánodo del LED (patilla larga) a una salida digital del Arduino y la otra patilla a tierra, cada vez que tengamos un uno lógico en la salida digital (recordamos, 5V), el LED se encenderá ya que circulará corriente a través de el debido a la diferencia de potencial.

Para evitar que el exceso de corriente pueda dañar nuestro LED debemos incluir en serie una resistencia que haga disminuir la corriente que circule por el LED. En este caso, y para simplificar (más aun) el montaje, hemos hecho uso de la resistencia que lleva incorporada la salida digital 13 de nuestro Arduino Uno, por lo que aunque no conectemos ninguna resistencia externa, hay que tener en cuenta que ya está incluida en nuestro Arduino Uno (solo en la salida 13).



Montaje:

El montaje es tremendamente simple, perfecto para un primer proyecto ya que hay pocas cosas en las que equivocarnos. A continuación podeis ver el circuito que debeis hacer para este proyecto:

Recordad, el ánodo del LED (patilla larga) debe ir conectado a la salida digital 13 de nuestro Arduino, y el cátodo (patilla corta) a la tierra.

Viendo el circuito podemos apreciar que el uso de la salida 13 tiene dos ventajas. La primera es la comentada anteriormente, es decir, la inclusión de una resistencia en serie. La segunda ventaja es que dispone de una toma de tierra (GND en Arduino) justo en el pin siguiente, por lo que no serán necesarios cables.

Código:

int pinLED = 13;

void setup() 
  {                
  pinMode(pinLED, OUTPUT);     
  }


void loop() 
  {
  digitalWrite(pinLED, HIGH);   // Enciende el LED
  delay(1000);                  // Espera 1000ms (1 segundo)
  digitalWrite(pinLED, LOW);    // Apaga el LED
  delay(1000);                  // Espera 1000ms (1 segundo)
  }

Ya solo queda escribir el código y cargarlo en nuestro Arduino. Como veis, yo he puesto un segundo (1000ms) entre encendido y apagado, pero vosotros podeis cambiarlo a vuestro antojo simplemente cambiando el valor 1000 por el que vosotros querais, teniendo siempre en cuenta que está en milisegundos.

Hasta el siguiente invento!

Como empezar

Esta introducción consta de 3 pasos:

1. Que Arduino comprar
2. Instalación
3. Entorno de programación

                                                                                                                                  

Paso 1: Que Arduino comprar

Esta parte puede ser tan extensa como paciencia tengamos, o sencilla como querer lo más estandar que exista. Yo opto por la segunda ya que si estás leyendo esto es porque eres un principiante y es muy posible que no sepas hasta donde quieres llegar con tu Arduino. Por esto mismo para empezar, yo recomiendo decantarse por el Arduino UNO.

De igual modo, pasaré a presentaros los distintos tipos de Arduino por los que podeis optar, teniendo en cuenta que los proyectos que aqui se realicen estarán hechos en Arduino UNO. La información que aqui os traigo esta completamente sacada de la web oficial de Arduino.

• UNO

Esta es la última revisión de la placa Arduino USB básica. Se conecta al ordenador con un cable USB estándar y contiene todo lo necesario para programar la placa. Se puede ampliar con gran variedad de shields. Tiene un ATmega328, también consta de 14 pines de entrada/salida de los cuales 6 se pueden usar como salidas PWM, 6 entradas analógicas, un velocidad de reloj de 16 MHz y un conector ICPS.

Existen varias revisiones de esta placa, en las cuales se suelen añadir nuevas funcionalidades más útiles. En la última revisión (R3) se han añadido unos pines llamados SDA y SCL cerca del pin AREF y 2 nuevos pines cerca del RESET. Además se ha sustituido el atmega 8U2 por un atmega 16u2.

Características:

Memoria Flash: 32 KB (ATmega328) de los cuales 0.5 KB usados por bootloader
SRAM: 2 KB (ATmega328)
EEPROM: 1 KB (ATmega328)

• Duemilanove

Versión anterior de Arduino Uno y presenta pocas diferencias con ese modelo. Basada en el ATmega168 o el ATmega328. Tiene 14 pines con entradas/salidas digitales (6 de las cuales pueden ser usadas como salidas PWM), 6 entradas analógicas, un reloj de 16Mhz, conexión USB, entrada de alimentación, una cabecera ISCP, y un botón de RESET. 

El Duemilanove automaticamente selecciona la fuente de alimentación adecuada (USB o externa), eliminando la necesidad de usar un jumper (especie de conmutador) de selección de fuente como ocurría en placas anteriores. Para que resulte comodo se puede cortar la pista para desabilitar el auto-reset y soldar un jumper en el corte para habilitarlo cuando sea necesario. 

Características:

Voltaje de funcionamiento: 5V
Voltaje de entrada (recomendado): 7-12V
Voltaje de entrada (limite): 6-20V
Intensidad por pin: 40 mA
Intensidad en pin: 3.3V50 mA
Memoria Flash: 16 KB (ATmega168) o 32 KB (ATmega328) de los cuales 2 KB de bootloader
SRAM: 1 KB (ATmega168) o 2 KB (ATmega328)
EEPROM: 512 bytes (ATmega168) o 1 KB (ATmega328)

• Diecimila

La Arduino Diecimila es una placa microcontroladora basada en el chip ATmega168. Tiene 14 E/S digitales (6 de las cuales se puedes utilizar como salidas PWM), 6 entradas analógicas, un cristal de 16MHz, conexión USB y botón de reseteo. Contiene todo lo necesario para el soporte del microcontrolador; simplemente conectala a un ordenador con un cable USB o alimentala con un adaptador AC/DC o una batería y comenzará a funcionar.

"Diecimila" significa "diez mil" en italiano y fue un nombrada de este modo para celebrar el hecho de que mas de 10.000 placas Arduino han sido ya fabricadas. La Diecimila es la última de la serie de placas USB

Características:

Voltaje de funcionamiento: 5V
Voltaje de entrada (recomendado): 7-12 V
Voltaje de entrada (limites): 6-20 V
Intensidad por pin de E/S: 40 mA
Intensidad por pin de 3.3V: 50 mA
Memoria Flash: 16 KB (2 KB reservados para el gestor de arranque)
SRAM: 1 KB
EEPROM: 512 bytes

• MEGA

El Arduino Mega es una placa microcontrolador basada ATmeg1280. Tiene 54 entradas/salidas digitales (de las cuales 14 proporcionan salida PWM), 16 entradas digitales, 4 UARTS (puertos serie por hardware), un cristal oscilador de 16MHz, conexión USB, entrada de corriente, conector ICSP y botón de reset. Contiene todo lo necesario para hacer funcionar el microcontrolador; simplemente conectálo al ordenador con el cable USB o aliméntalo con un trasformador o batería para empezar. El Mega es compatible con la mayoría de shields diseñados para el Arduino Duemilanove o Diecimila.

  

Características:

Voltaje de funcionamiento: 5V  

Voltaje de entrada (recomendado): 7-12V  

Voltaje de entrada (limite): 6-20V  

Intensidad por pin: 40 mA  

Intensidad en pin 3.3V: 50 mA  

Memoria Flash: 128 KB de las cuales 4 KB las usa el gestor de arranque (bootloader) 

SRAM: 8 KB  

EEPROM: 4 KB

• Nano

El Arduino Nano es una pequeña y completa placa basada en el ATmega328 (Arduino Nano 3.0) o ATmega168 (Arduino Nano 2.x) que se usa conectándola a una protoboard. Tiene más o menos la misma funcionalidad que el Arduino Duemilanove, pero con una presentación diferente. No posee conector para alimentación externa, y funciona con un cable USB Mini-B en vez de el cable estandar. El nano fue diseñado y está siendo producido por Gravitech.

Características:

Pines E/S Digitales: 14 (de los cuales 6 proveen de salida PWM
Entradas Analógicas: 8
Corriente máx, PIN de E/S: 40 mA
Memoria Flash: 16 KB (ATmega168) o 32 KB (ATmega328) de los cuales 2KB para bootloader
SRAM: 1 KB (ATmega168) o 2 KB (ATmega328)
EEPROM: 512 bytes (ATmega168) o 1 KB (ATmega328)
Frecuencia de reloj: 16 MHz
Dimensiones: 18,5mm x 43.2mm

• Lilypad

 

El LilyPad Arduino es una placa con microcontrolador diseñado para prendas y e-textiles. Puede utilizar con complementos similares como fuentes de alimentación, sensores actuadores unidos por hilo conductor. La placa esta basada en el ARmega168V (la versión de baja consumo del ATmega168), o el ATmega328V. El LilyPad Arduino ha sido diseñado y desarrollado por Leah Buechley y SparkFun Electronics.

Características:

Operating Voltage: 2.7-5.5 V
Input Voltage: 2.7-5.5 V
Digital I/O Pins: 14 (of which 6 provide PWM output)
Analog Input Pins: 6
DC Current per I/O Pin: 40 mA
Flash Memory: 16 KB (of which 2 KB used by bootloader)
SRAM: 1 KB
EEPROM: 512 bytes
Clock Speed: 8 MHz

• FIO

 

El Arduino Fio is una placa para microcontrolador basada en el ATmega328P. Funciona a 3.3V y 8 MHz. Tiene 14 pines de E/S digitales (de los cuales 6 pueden usarse como salidas PWM), 8 entradas analógicas, un resonator en placa, un botón de reinicio (reset), y agujeros para montar conectores de pines. Tiene conexiones para una batería de polímero de Litio e incluye un circuito de carga a través de USB. En el reverso de la placa tiene disponible un zócalo para módulos XBee.

El Arduino FIO está diseñado para aplicaciones inalámbricas. El usuario puede subir sus sketches con un cable FTDI o una placa adicional adaptadora Sparkfun. Además, si utiliza un adaptador de USB a XBee modificado , como el USB Explorador de XBee, el usuario puede subir sketches de forma inalámbrica. La tarjeta viene sin conectores pre-montados, permitiendo el uso de diversos tipos de conectores o la soldadura directa de los cables.

Características:

Voltaje de trabajo 3.3V
Voltaje de Entrada 3.35 -12 V
Voltaje de Entrada en Carga 3.7 - 7 V
Corriente DC por pin E/S 40 mA
Memoria Flash 32 KB (de los cuales 2 KB usados por bootloader)
SRAM 2 KB
EEPROM 1 KB
Frecuencia de Reloj 8 MHz

• Mini

 

Arduino Mini es una placa con un pequeño microcontrolador basada en el ATmega168, pensada para ser usada en placas de prototipado y donde el espacio es un bien escaso. Cuenta con 14 entradas/salidas digitales (de las cuales 6 pueden ser usadas como salidas PWM ), 8 entradas analógicas y un cristal de 16 MHZ. Puede ser programada con el adaptador Mini USB u otros adpatadores USB o RS232 a TTL serial

Advertencia: No Alimente el Arduino mini con mas de 9 voltios, o conecte la alimentación al revés: probablemente acabará con él.

Características:

Voltaje de entrada 7-9 V
DC Corriente continua por pin E/S 40 mA
Memoria Flash 16 KB (de las cuales 2 KB son usadas por el bootloader)
SRAM 1 KB
EEPROM 512 bytes

                                                                                                                                 

Paso 2:  Instalación

Este paso cambia ligeramente según la placa Arduino que tengamos, pero básicamente es lo mismo para todas. Aqui asumiré que tienes un Arduino UNO aunque es perfectamente extrapolable a las demás. Aun así, consultar la web oficial de Arduino y seguir el proceso de instalación particular para tu placa.

Debes tener un cable USB para conectar tu Arduino al PC (si tu placa no tiene USB, consulta su propio manual).

Para empezar, debes descargarte el IDE de Arduino. La versión que descargues puede ser crucial para poder llevar a cabo unos proyectos u otros. Para seguir los proyectos que aqui os enseñare basta con descargar la última versión de Arduino. Aqui os dejo el enlace oficial:

http://arduino.cc/en/main/software

Una vez descargado el archivo, extraeis la carpeta que hay en su interior donde os apetezca en vuestro PC.

Tras esto, conectad vuestra placa al PC mediante el cable USB y vereis como quedará encendido el led verde de la placa nombrado como PWR.

Si trabajais con Windows 7 o Vista, los drivers se deberán descargar e instalar por si solos. Sin embargo, si trabajais con Windows XP, el proceso es el siguiente:

• Cuando te pregunten: ¿Puede Windows conectarse a Windows Update para buscar el software? selecciona No, no esta vez. Haz click en Siguiente.

• Selecciona Instalar desde una lista o localización específica (Avanzado) haz click en Siguiente. 

• Asegurate que Buscar los mejores drivers en estas localizaciones esté seleccionado; deselecciona Buscar en medios removibles; selecciona Incluye esta localización en la búsqueda y navega al directorio drivers/FTDI USB Drivers dentro de la carpeta de Arduino que has descomprimido previamente. (La versión más reciente de los drivers se puede encontrar en la página web del fabricante del chip FTDI.) Haz click en Siguiente.

• El asistente de instalación buscará los drivers y te anunciará que encontró un "USB Serial Converter" (se traduce por Conversor USB-Serie). Haz click en Finalizar.

• El asistente de instalación de hardware volverá a iniciarse. Repite los mismos pasos que antes y selecciona la misma carpeta de instalación de los drivers. Esta vez el sistema encontrará un "USB Serial Port" (o Puerto USB-Serie). 

Puedes comprobar que los drivers se han instalado correctamente abriendo la carpeta del Administrador del Dispositivos, en el grupo Dispositivos del panel de control del sistema. Busca "USB Serial Port" (o Puerto USB-Serie) en la sección de puertos; esa es tu placa Arduino. 

Cuando esto finalice, ya tendreis disponible vuestro Arduino para comunicarse con vuestro PC y asi poder cargarle los programas.

                                                                                                                                  

Paso 3: Entorno de programación

 Tras esto, podeis ir a la carpeta de Arduino, y creais un acceso directo al ejecutable de Arduino para colocarlo en el escritorio y acceder a el rapidamente.

Si ejecutas la aplicación te aparecerá el entorno de programación de nuestro Arduino. Uno de los puntos fuertes sin duda, es tan sencillo que es muy dificil equivocarse. Antes de empezar a programar debeis comprobar un par de cosas. Por un lado pinchamos en el menu "Herramientas" y despues en el apartado "Tarjeta" donde seleccionaremos el modelo de Arduino que dispongamos, en mi caso Arduino UNO. Por otra parte pinchamos de nuevo en el menu "Herramientas" y despues en el apartado "Puerto Serial", aqui debemos seleccionar el puerto donde se encuentre nuestro Arduino, el cual ya vimos al final del "Paso 2" de este tutorial.

Ahora si que si, ya esta todo listo para ponernos a programar nuestro Arduino y hacerle trabajar, ¿A que esperamos?

Presentación

Buenas a tod@s

Aqui os presentaré proyectos realizados con Arduino, desde los más sencillos hasta algunos más complejos que encuentre interesantes.

En la red existen multitud de sitios con información y proyectos basados en Arduino por lo que los primeros proyectos que incluiré no serán ninguna novedad para los familiarizados con el tema. Sin embargo, lo que pretendo es explicar estos proyectos de la manera más sencilla, de modo que cualquiera que este interesado en empezar a trabajar con Arduino, le sea facil y gratificante.

Espero que este blog os sea útil.

Un saludo