¿Qué es un módulo HC-05 ó HC-06?

Los módulos HC-05 y HC-06 son módulos de Bluetooth que podemos usar para conectar comunicar con Arduino por Bluetooth.

Mucha gente puede tener la impresión de que el Bluetooth es una tecnología anticuada, que se usaba para trasmitir datos entre dispositivos, y que actualmente está en desuso. Nada más lejos de la realidad.

Bluetooth tiene la enorme ventaja de estar integrado de fábrica en la mayoría de dispositivos. Portátiles, Tablets, y Smartphones llevan integrado Bluetooth. Además, su uso es independiente del sistema operativo (Windows, Linux, Mac o Android).

Esto convierte a la tecnología Bluetooth en uno de los mejores medios para comunicarnos de forma inalámbrica con Arduino. Por ejemplo, podemos emplearlo para controlar un robot desde el móvil o Tablet, o recibir mediciones en un ordenador para registrarlas en un servidor web.

Incluso es posible programar Arduino de forma inalámbrica a través de Bluetooth, como veremos en una entrada posterior.

Los dos módulos, HC-05 y HC-06, nos permiten conectar de forma sencilla un Arduino por Bluetooth. La diferencia entre ambos módulos es que el HC-06 sólo permite recibir comunicaciones (slave) mientras que el HC-05 puede recibirlas e iniciarlas (master and server). Por tanto el módulo HC-05 es superior en características técnicas.

Precio

En la actualidad podemos encontrar tanto el HC-05 como el HC-06 por unos 2,75€, en vendedores internacionales de Ebay y Aliexpress.

Antiguamente el precio del HC-05 era bastante superior al del HC-06. Pero, dado que en la actualidad ambos módulos cuestan lo mismo y que el HC-05 es superior en características, lo normal es que siempre querremos comprar el módulo HC-05.

Como advertencia, ambos módulos (HC-05 y HC-06) están formados por dos componentes. El módulo de Bluetooth en sí, y una base a la que va soldado y que contiene el resto de circuitería. Tener cuidado de no comprar sólo la base o el módulo sueltos, que también se venden a un precio inferior.

¿Cómo funcionan los módulos HC-05 y HC-06?

La comunicación Bluetooth es similar al uso del puerto de serie normal, que vimos en esta entrada. Por tanto, resulta muy versátil y muy sencillo de usar.

La diferencia principal es que, en lugar de un conectar un cable, tendremos que emparejar el módulo con nuestro dispositivo. El proceso de emparejado depende del sistema operativo (y la versión del mismo) pero es, en general, un proceso sencillo.

Para establecer la comunicación desde el dispositivo, podemos usar el propio Serial Monitor del Arduino IDE. También encontraremos en todos los sistemas (Windows, Linux, Mac, o Android) encontraremos aplicaciones para establecer la comunicación por el puerto de serie.

Por último, resulta muy sencillo integrar en nuestros programas el uso del puerto de serie (y por tanto del Bluetooth), en una gran variedad de lenguajes de programación, incluidos Java, C#, VB .Net, o Python, que disponen de funciones específicas para ellos.

Esquema eléctrico

Utilizar el módulo de Bluetooth requiere el uso de un puerto de serie de nuestra placa Arduino. Por tanto, mientras usemos el módulo de Bluetooth no podremos usar el puerto de serie en las placas modelo Uno, Mini, y Nano. En el modelo Mega no tiene este problema, ya que incorpora 4 puertos de serie.

Si realmente necesitamos ambas comunicaciones podemos emplear la librería SoftSerial para establecer una comunicación de puerto de serie por cualquier pareja de pins digitales, aunque ello supondrá un coste adicional de tiempo de proceso en Arduino.

La conexión es sencilla. Alimentamos mediante Vcc y GND. Posteriormente conectamos el TXD (pin de transmisión) y RXD (pin de recepción) a los opuestos de la placa Arduino (cada TXD a un RXD). Así quedarían las conexiones del módulo, con los pines de Arduino.

Mientras que el esquema visto desde Arduino queda así.

Ejemplos de código

Como hemos dicho, el uso del módulo Bluetooth es idéntico al uso de puerto de serie, que vimos en esta entrada. Por tanto, todos los códigos de uso de puerto de serie que vimos en esta y otras entradas de este blog funcionan igualmente por Bluetooth.

Por ejemplo, el siguiente código envía un número a Arduino por Bluetooth y hace parpadear el Led integrado en la pláca el número de veces que hemos enviado.

const int led = 13;

int option;
 
void setup(){
  Serial.begin(9600);
  pinMode(led, OUTPUT); 
}0

void loop(){
  //si existe información pendiente
  if (Serial.available()>0){
    //leeemos la opcion
    char option = Serial.read();
    //si la opcion esta entre '1' y '9'
    if (option >= '1' && option <= '9')
    {
      //restamos el valor '0' para obtener el numero enviado
      option -= '0';
      for(int i=0;i

Ya podemos usar Bluetooth en todos nuestros proyectos. Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

¿Qué es un magnetic reed?

Una magnetic reed es un dispositivo electromecánico que se comporta como un interruptor que se activa ante la presencia de un imán.

Los sensores magnetic reed son ampliamente utilizados. Por ejemplo, muchas alarmas de puertas y ventanas funcionan ubicando un imán en el elemento, y detectando la apertura con un magnetic reed. También podemos ubicar el imán en una puerta, o vitrina, para encender una luz, etc.

Como un magnetic reed no deja de ser un interruptor, podemos emplear este dispositivo para encender o apagar un dispositivo directamente. Por supuesto, también podemos emplear las entradas digitales de Arduino para leer el estado del magnetic reed, de forma similar a como vimos en la entrada leer un pulsador con Arduino.

Los interruptores magnéticos tienen la ventaja de ser baratos, sencillos y no requieren corriente para su funcionamiento. Además, funcionan tanto en corriente alterna como continua.

Por el contrario, al ser dispositivos electro mecánicos, el tiempo de conmutación es relativamente alto, del orden de 1-5 ms. Si nuestra aplicación tiene una velocidad de conmutación superior (por ejemplo, para hacer un tacómetro), deberemos emplear un sensor Hall, como vimos en esta entrada.

Además, los magnetic reed tienen una vida útil limitada, es decir, hay un número de conmutaciones que puede realizar antes de dañarse. No obstante, en algunos dispositivos puede ser hasta 100 millones de conmutaciones, lo cual es suficiente para la mayoría de aplicaciones. Por último, la presencia de vibraciones o movimientos bruscos puede alterar su funcionamiento, y dar lugar a mediciones erróneas.

Precio

Los interruptores magnetic reed son dispositivos muy baratos. Podemos encontrar magnetic reed desde 0,10€ en vendedores internacionales de Ebay o AliExpress.

El precio depende de la intensidad y tensión máxima, la potencia máxima que pueden gestionar, y de la velocidad de conmutación y vida útil.

¿Cómo funciona un magnetic reed?

Físicamente un magnetic reed está constituido por dos elementos ferromagnéticos de níquel, ubicados en el interior de una ampolla de vidrio sellada.

Al acercar un campo magnético la fuerza generada provoca que ambos elementos entren en contacto, cerrando el circuito eléctrico.

También existen magnetic reed cuyo estado es normalmente cerrado, y abren el circuito eléctrico en presencia del campo magnético. Incluso encontramos magnetic reed que disponen ambas salidas, una normalmente abierta y otra normalmente cerrada, en el mismo dispositivo.

El campo magnético requerido para activar el interruptor es típicamente del orden de 50 Gauss.

Esquema eléctrico

El esquema eléctrico es sencillo. Vamos a usar las resistencias internas de pull-up de Arduino, por lo que simplemente conectamos el magnetic reed entre GND y la entrada digital que queramos emplear.

Esquema de montaje

Mientras que el montaje en una protoboard sería el siguiente.

Ejemplos de código

El siguiente código muestra un ejemplo sencillo. Usamos una entrada digital, con la resistencia pull-up interna, para leer el estado del magnetic reed. Si el sensor está activado, la entrada leerá LOW, y en ese caso encendemos el LED integrado en la placa. Por supuesto, en un proyecto real, en lugar de encender el LED integrado ejecutaríamos las acciones que quisiéramos.

const int pinSensor = 2;
const int pinLED = 13;

void setup() {
  //configurar pin como entrada con resistencia pull-up interna
  pinMode(pinSensor, INPUT_PULLUP);
  pinMode(pinLED, OUTPUT);
}

void loop() {
  int value = digitalRead(pinSensor);

  if (value == LOW) {
    digitalWrite(pinLED, HIGH);
  } else {
    digitalWrite(pinLED, LOW);
  }

  delay(1000);
}

Por supuesto en un proyecto real, en lugar de encender el LED integrado, ejecutaríamos las acciones que quisiéramos.

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

En esta entrada anterior vimos como emplear las salidas PWM para simular una salida analógica de tensión.

Sin embargo, dejamos bien claro que una salida PWM no es una señal analógica de tensión, sino una señal digital pulsada cuyo valor promedio es el valor deseado. Desconocer esto puede provocar comportamientos inesperados en los componentes que conectemos a la señal PWM, o incluso dañarlos.

Para que sirva de analogía, que un componente espere una señal analógica de tensión y reciba un PWM, es similar a pedir que nos den un suave masaje en la cabeza, y que nos den un martillazo cada 20 segundos. El promedio será el mismo pero… No es lo mismo.

Hay varios mecanismos que podemos emplear para mejorar la respuesta de nuestro PWM, de forma que se aproxime mejor a una señal analógica auténtica. Una de las más sencillas es emplear un filtro de paso bajo para “suavizar” la señal.

En esta entrada veremos cómo incorporar un filtro de paso bajo a una salida PWM para mejorar su comportamiento y que la salida obtenida se aproxime mejor a una señal analógica auténtica.

Incorporar un filtro de paso bajo

Una salida PWM es un mecanismo que incorporan frecuentemente los autómatas para emular una señal analógica. Consiste en proporcionar una señal pulsada a una frecuencia determinada, cuyo valor promedio es el valor analógico deseado. Pero el valor de tensión aplicado realmente es, en todo momento, una señal digital entre -Vcc y +Vcc.

Por ejemplo, si con una tensión Vcc de 5V queremos una señal PWM de 1V, se generará una señal que el 20% del tiempo valdrá 5V y el 80% restante 0V.

Si la respuesta del sistema es lenta en comparación con la frecuencia del PWM, la salida PWM puede ser suficiente. Por contra en otros casos no será así, e incluso podemos dañar el componente alimentado si la tensión Vcc es superior a la tensión máxima admisible por el componente.

Para mejorar la respuesta de la salida analógica tenemos varias opciones, y la más sencilla es incorporar un filtro de paso bajo pasivo mediante una red RC.

El esquema eléctrico es el siguiente, donde vemos que hemos superpuesto la red RC de filtrado entre la salida PWM y la señal filtrada, que es la que recibe la carga.

Como habíamos delantado, la respuesta del sistema es una señal amortiguada de la señal PWM, pero que sigue sin ser una señal analógica perfecta. Un ejemplo de respuesta es el siguiente:

Debemos observar que la señal producida tiene dos parámetros relevantes.

• Tiempo de respuesta: El tiempo le cuesta la señal el estado estacionario (un tanto por ciento de la señal deseada)
• Rizado: La pequeña oscilación que se mantiene tras el filtro.

Estos dos efectos son “opuestos” entre sí. Es decir:

• Si intentamos reducir el rizado, necesitaremos tiempos de respuesta muy largos.
• Si intentamos reducir el tiempo de respuesta, debemos admitir un mayor rizado.

Por tanto, no existe un único filtro y una señal optimos. Tendremos que tomar una decisión de diseño y aceptar un compromiso entre un determinado valor de rizado y un tiempo de respuesta.

Ajustar R y C en el filtro paso bajo

Las características de la respuesta dependerá de:

• La frecuencia del PWM
• Las tensiones de la señal filtrada y la señal deseada
• Los valores de R y C elegidos

Para calcular estos parámetros, y visualizar gráficamente la respuesta obtenida, podemos usar la calculadora de redes RC disponible en este enlace.

Limitaciones de un filtro pasivo

El filtro de paso bajo planteado resulta útil para proporcionar un valor te tensión casi analógico, e incluso alimentar pequeñas cargas. Sin embargo, no sirve para alimentar grandes cargas..

Las cagas de potencia superior tienen impedancias inferiores. Cuando esta impedancia es inferior a la de la red RC, el consumo de la carga produce que la señal obtenida se aleje de la teórica.

Una forma sencilla de evitar esto es emplear un amplificador operacional para hacer un seguidor de tensión, que aísla la influencia de la carga del funcionamiento de la red RC.

No obstante, ya que vamos a emplear un amplificador operacional, podríamos unificar ambos componentes empleando un filtro activo.

Por último, otra opción muy recomendable es emplear directamente alguno de los muchos conversores ADC comerciales disponibles.

Veremos estas soluciones en futuras entradas. Mientras, si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Comparto esta imagen que me encanta, porque describe a la perfección la que para mí es una de las mayores dificultades que encontramos al realizar mejoras de procesos en negocios y empresas.

Podréis encontrar la misma imagen en muchos formatos distintos (hay una con muñecos de lego muy graciosa), pero todas son igualmente ciertas.

La imagen es bastante auto descriptiva. Todas las empresas tienen, en mayor o menor medida, un lógico interés en mejorar sus procesos, aumentar su eficiencia, y reducir sus costes.

Al menos esto es lo que cualquier persona o compañía afirmará rotundamente, pero la realidad no es tan sencilla como la teoría. A la hora implantar mejoras o soluciones, lo que realmente encontramos con frecuencia son frases como:

• “No he podido probar eso, es que he estado muy ocupado”
• “Deberíamos mejorar los procesos, pero es que nunca hay tiempo”
• “No sé por qué hay que cambiarlo, siempre lo hemos hecho así”

Es cierto que todos tenemos siempre mucho trabajo y es difícil encontrar tiempo para probar cosas nuevas. Igualmente es cierto que ciertas personas muestran una predisposición en contra de los cambios, que pueden provocar reticencia e incomodidad.

Sin embargo, debemos acostumbrarnos a que toda mejora es necesariamente un cambio, y la única forma de mejorar es abrazar los cambios, aunque ello signifique abandonar nuestra zona de confort. Por otro lado, tu trabajo y tus tareas diarias nunca te va a dar tiempo para probar y realizar mejoras si tú no haces el esfuerzo por encontrarlo.

Así que ya sabéis, ni la falta de tiempo, ni estar demasiado ocupado, ni que te asuste dejar tu zona de confort, son excusas válidas para no intentar mejorar. Precisamente, cuanto mayor es la carga de tabajo, mayor es la necesidad de probar nuevos métodos y mejorar procesos.

¡¡Os deseamos Feliz Navidad, y próspero año nuevo!!

Que paséis muy buenos días en compañía de vuestra familia y amigos, y que el año que viene esté lleno de Felicidad, Amor, Salud y…  ¡un montón de cosas Frikys para jugar!

¡Un abrazo!

Si usáis frecuentemente Arduino encontrarás el IDE más que limitado, y carente de la mayoría de funciones que son de esperar en un IDE moderno.

En esta entrada anterior vimos como configurar Eclipse como una buena alternativa para desarrollar en Arduino bajo entorno Linux.

Sin embargo la mejor opción disponible para desarrollar en Arduino es usar Windows y Visual Studio, su todo poderoso IDE insignia. Con una gran diferencia, aunque sea difícil de oír para los amantes del Open Source.

Para poder compilar y subir programas a Arduino desde Visual Studio es necesario añadir una extensión llamada Visual Micro. Esta extensión también permite trabajar con una gran variedad de placas de desarrollo además de, por supuesto, todos los modelos de Arduino.

Antes de que tengas tiempo de preocuparte por su precio, nos falta por decir la mejor parte. Ambos programas, Visual Studio 2015 y Visual Micro, disponen de versiones gratuitas para uso no profesional.

Si realmente queréis sacar todo el potencial de Arduino y convertiros en desarrolladores expertos es recomendable (y casi obligatorio) que probéis las ventajas de usar Visual Studio y Visual Micro con Arduino. Vamos a repasar algunas de estas ventajas.

Ventajas de Visual Studio y Visual Micro

Formatos y colores

Colores para los distintos tipos de objetos, librerías, y variables. Se acabó dejarte los ojos en los sosos colores del IDE de Arduino. Distingue de un vistazo las partes principales de tu código.

Tabulaciones automático

Si sois puristas de la programación, os pondrá nervioso las líneas descuadradas y las tabulaciones con espaciados distintos. Visual Studio se encarga de arreglar esto por nosotros, indentando automáticamente las líneas.

Intellisense

Intellisense, el sistema de asistencia a la escritura para el programador, es uno de los mayores aciertos de Microsoft en Visual Studio. Nos permite completar el nombre de variables, obtener los métodos de un objeto, emplear atajos para escribir rápidamente estructuras básicas como bucles y condicionales. Simplemente una función imprescindible en cualquier IDE moderno.

Varios proyectos en soluciones

Por fin un poco de orden en nuestros proyectos de Arduino. Gracias a Visual Studio podemos crear soluciones formadas por más de un proyecto como, por ejemplo, el código de un sketch y sus librerías y clases asociadas.

Código en auténtico C++

Otra enorme ventaja, se acabó tener que pegarse con el IDE y sus “interpretaciones” de C++. Se acabó tener que sacar la mayor parte del código como librerías para poder usar objetos. Con Visual Studio y Visual Micro puedes usar toda la potencia de C++ para programar tus Arduino.

Compilación ultra rápida

La compilación desde Visual Studio es realmente rápida, en torno al doble de velocidad que el IDE estándar de Arduino en Windows (que, por otro lado, es terriblemente lento). El código generado es exactamente igual, y tiene las mismas optimizaciones, por lo que ocupa la misma memoria en Arduino. Simplemente, Visual Studio es más rápido.

Control de errores

El IDE Standard es bastante parco en palabras a la hora de indicarnos los errores en nuestros programas. Visual Studio no solo nos indicará los errores y la línea en la que ocurren tras la compilación, si no que nos subrayará los errores mientras los escribimos.

Gestor de librerías

Visual Micro dispone de un explorador que permite instalar y gestionar las librerías de forma sencilla. También permite gestionar las distintas placas de desarrollo disponibles, y los ejemplos.

Debug (sólo versión Pro)

Visual Micro dispone de una versión Pro, de pago, que permite debugear Arduino desde Visual Studio. Una función muy potente, que resulta una ayuda impagable para profesionales.

Sin embargo, si sois aficionados y no deseáis pagar la versión Pro, no es os preocupéis. La función Debug es muy específica para profesionales, y la versión gratuita es perfectamente funcional para la gran mayoría.

Cómo instalar Visual Studio y Visual Micro

Instalar Visual Studio es sencillo. Simplemente accedemos a la página de descarga, y bajamos la versión CommunityE dition.

Lanzamos el instalador y nos aseguramos de marcar la instalación del lenguaje C++.

Cuando se termine la instalación (es un proceso que tarda bastante) accedemos a la página de descarga de Visual Micro e instalamos la extensión.

Por último, resulta conveniente entrar en “Options/Text Editor/C++/Advanced” y activar la localización de Fallback, para evitar que se cree siempre un directorio ipch en cada solución, un proceso que cuesta tiempo y espacio y no aporta nada.

Listo, ya podéis usar Visual Studio y Visual Micro para compilar y subir vuestros programas a Arduino, y otras muchas placas de desarrollo. ¡Es como pasar de usar una bicicleta vieja y oxidada a un Ferrari!

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Cuando vimos el uso del puerto de serie en Arduino en esta entrada, ya adelantamos que era el medio principal del que disponíamos para comunicación con Arduino con otros dispositivos.

Esta comunicación tienen la ventaja de que puede ser realizada con gran variedad de dispositivos (como un ordenador, un tablet, un móvil), es independiente del sistema operativo (incluyendo Windows, Linux, Mac y Android) y puede realizarse en multitud de lenguajes de programación.

En esta entrada vamos a aprender a conectar Arduino con C#, el popular lenguaje de programación de Microsoft, que dispone de forma nativa objetos para usar de forma muy sencilla los puertos de serie.

Para ello es necesario tener instalado Visual Studio, el IDE de Microsoft. La versión “Community” es gratuita para uso personal, y puede ser descargada desde este enlace.

Para ver la forma de conectar Arduino con C# vamos a ver dos ejemplos sencillos, los mismos que vimos en la entrada Comunicación de Arduino con puerto de serie. Pero esta vez realizaremos la comunicación desde un programa desarrollado en C#, en lugar de usar el Serial Monitor del IDE de Arduino.

El código de C# que vamos a mostrar es muy sencillo (casi me da vergüenza publicarlo) porque son ejemplos para ilustrar lo fácil que es usar el puerto de serie para conectar Arduino con C#. Pero tener en cuenta que en un proyecto real deberíamos incluir algunas mejoras.

Por ejemplo, el uso del puerto de serie estaría integrado en nuestros objetos y tendríamos independencia entre capa visual y modelo. Además, normalmente transmitiríamos bytes en lugar de texto, e incluiríamos verificaciones para asegurar que la transmisión se ha realizado correctamente.

Vemos esto en futuras entradas pero, de momento, nos conformamos con aprender a usar lo básico de los puertos de serie para comunicar Arduino con C#.

Encender y apagar un LED

En este ejemplo vamos a hacer un formulario simple con dos botones de ON y OFF, que nos permitirán encender el LED integrado en la placa de Arduino, conectado al Pin13.

En primer lugar arrancamos Visual Studio, y creamos un nuevo proyecto de C#. Para ello pulsamos en File/New/Project.

Elegimos el template “Windows Form Application”, la ubicación en la que queremos guardarlo en nuestro disco duro y como nombre del proyecto “BasicSerialPort”.

Se abrirá un formulario vacio, que será la ventana principal de nuestro ejemplo. Arrastramos desde el Toolbox dos botones hasta nuestro formulario, y los ponemos uno encima del otro.

Ahora empleamos la barra de propiedades para cambiar el texto y el nombre tanto de los botones como del formulario.

Dejamos los valores como muestra la siguiente tabla.

Ahora, pulsamos F7 encima del formulario para acceder al código (o pulsamos con el botón derecho y elegimos “View code”).

Reemplazamos todo el código por el siguiente.

using System;
using System.Windows.Forms;

namespace BasicSerialPort
{
    public partial class frmMain : Form
    {
        System.IO.Ports.SerialPort ArduinoPort;

        public frmMain()
        {
            InitializeComponent();

            //crear Serial Port
            ArduinoPort = new System.IO.Ports.SerialPort();
            ArduinoPort.PortName = "COM4";  //sustituir por vuestro 
            ArduinoPort.BaudRate = 9600;
            ArduinoPort.Open();

            //vincular eventos
            this.FormClosing += FrmMain_FormClosing;
            this.btOFF.Click += BtOFF_Click;
            this.btON.Click += BtON_Click;
        }

        private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            //cerrar puerto
            if (ArduinoPort.IsOpen) ArduinoPort.Close();
        }

        private void BtOFF_Click(object sender, EventArgs e)
        {
            ArduinoPort.Write("a");
        }

        private void BtON_Click(object sender, EventArgs e)
        {
            ArduinoPort.Write("b");
        }
    }
}

Ahora cargamos este programa en Arduino.

const int pinLED = 13;

void setup()
{
	Serial.begin(9600);
	pinMode(pinLED, OUTPUT);
}

void loop() {
	if (Serial.available() > 0)
	{
		int option = Serial.read();
		if (option == 'a')
		{
			digitalWrite(pinLED, LOW);		
		}
		if (option == 'b')
		{
			digitalWrite(pinLED, HIGH);
		}
	}
}

Ejecutamos el programa pulsando F5. Pulsamos los botones, y veremos que se enciende y se apaga el LED integrado de Arduino.

Hacer parpadear un LED

Vamos a modificar el programa anterior para enviar un número de 0 a 9 a Arduino. Arduino recibirá ese número, y hará parpadear el LED integrado el número de veces recibido.

Para ello comenzamos modificando el formulario del ejemplo anterior. Eliminamos uno de los dos botones y arrastramos desde la Toolbox un nuevo Textbox.

Usamos la paleta de propiedades para modificar las propiedades del Textbox y el botón restante. Dejamos los valores según la siguiente tabla.

Ahora editamos el código del formulario, y lo sustituimos por el siguiente.

using System;
using System.Windows.Forms;

namespace BasicSerialPort
{
    public partial class frmMain : Form
    {
        System.IO.Ports.SerialPort ArduinoPort;

        public frmMain()
        {
            InitializeComponent();

            //crear Serial Port
            ArduinoPort = new System.IO.Ports.SerialPort();
            ArduinoPort.PortName = "COM4"; //sustituir por vuestro 
            ArduinoPort.BaudRate = 9600;
            ArduinoPort.Open();

            //vincular eventos
            this.FormClosing += FrmMain_FormClosing;
            this.btSend.Click += BtSend_Click;
        }

        private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            //cerrar puerto
            if(ArduinoPort.IsOpen) ArduinoPort.Close();
        }

        private void BtSend_Click(object sender, EventArgs e)
        {
            //convertir texto de Textbox en integer
            int value;
            bool rst = Int32.TryParse(txNumber.Text, out value);

            //si la conversion es válida, y número entre 0 y 9, enviar el número como texto
            if (rst == true && value > 0 && value < 9 )
            {
                ArduinoPort.Write(value.ToString());
            }
        }
    }
}

Cargamos este programa en Arduino.

const int pinLED = 13;

void setup() 
{
	Serial.begin(9600);
	pinMode(pinLED, OUTPUT);
}

void loop()
{
	if (Serial.available()>0) 
	{
		char option = Serial.read();
		if (option >= '1' && option <= '9')
		{
			option -= '0';
			for (int i = 0;i


Ejecutamos el programa en Visual Studio pulsando F5. Al introducir un número entre 0 y 9, veremos como el LED de la placa parpadea el número de veces indicado.


Hasta aquí una primera presentación de comunicación de Arduino con C#. En el futuro emplearemos métodos más avanzados para manejar servos y robots.

 Mientras tanto, si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Python es uno de los lenguajes que más popularidad ha obtenido en los últimos tiempos. Su sencillez de uso ha atraído a gran cantidad de usuarios, y generado una importante comunidad que le da soporte, generando una gran cantidad de librerías, documentación y tutoriales.

Python es un lenguaje interpretado con tipado dinámico, orientado a objetos y multiplataforma, existiendo intérpretes para distintos sistemas operativos, incluidos Windows, MAC, Linux y Android.

Por sus características técnicas Python tiene limitaciones en cuanto a eficiencia y escalabilidad. Por tanto, no resulta un lenguaje apropiado para proyectos medios o grandes, donde deberíamos optar por lenguajes más avanzados, como C# o Java.

Sin embargo, Python resulta útil para hacer pequeños programas o scripts donde prima más desarrollar de forma rápida y sencilla, que el tiempo de ejecución del programa.

Python también ocupa un lugar destacado en el IoT (el internet de las cosas), por lo sencillo que es comunicar con dispositivos como Arduino o interactuar a través de Internet.

En cualquier caso es un lenguaje interesante que conviene conocer. En esta entrada veremos cómo instalar y empezar a usar Python en nuestros proyectos, así como una serie de ejemplos básicos para empezar su uso.

Cómo instalar Python

Instalar Python es en general sencillo. Muchas distribuciones de Linux lo traen incluido de serie.

En Windows, debemos bajar e ejecutar el instalador desde esta dirección. Descargaremos e instalamos la última versión disponible.

Para el resto de sistemas operativos, consultar la guía de instalación disponible en este enlace.

Cómo ejecutar código en Python

Tenemos dos formas principales de ejecutar código en Python.

La primera es lanzar el intérprete de Python. En este, escribiremos el código y al pulsar “Enter”, el intérprete ejecutará las instrucciones que hayamos introducido.

Sin embargo, la forma habitual es crear un archivo de texto con la extensión “.py” donde escribiremos el código de nuestro script. Al hacer doble click sobre él, se llamará al intérprete automáticamente y se ejecutarán las acciones de nuestro archivo.

Ejemplos de código

Python tiene numerosas particularidades en la forma de realizar algunas de las tareas habituales en programación, destinadas a hacer el código más sencillo de leer y más rápido de escribir.

Alguna de las más destacadas es el empleo del indentado (tabulaciones) para definir bloques de código en condicionales y bucles, y el uso avanzado que hace vectores, listas, y textos.

Para imprimir un número o texto en pantalla, usamos la función Print

print(‘Hola mundo’)

Para recibir un texto por el usuario, empleamos la función Input

texto=input('Introduzca un numero: '))

Si queremos recibir un número, tenemos que convertirlo con la función Int

num = int(input('Introduzca un numero: '))

Las estructuras condicionales se realizan de forma similar a casi todos los lenguajes de programación. Por ejemplo, el siguiente código recibe un número del usuario, e dice si es par o impar.

### Introducir un numero por teclado y decir si es par o impar
num = int(input('Introduzca un numero: '))
ifnum % 2 == 0:
print('Par')
else:
print('Impar')

El bucle de tipo for si tiene ciertas particularidades. El siguiente ejemplo, muestra como imprimir en pantalla los 20 primeros números

###Ejemplo for, imprime los 20 primeros numeros en una linea
for i in range(20):
print(i, end=" ") #imprimir numero, sin salto linea
print() #lineavacia

Por su parte, un “equivalente” a un bucle de tipo foreach tendría la siguiente pinta

###Ejemplo foreach, imprime los numeros de la lista
for i in [1, 5, 7]:
print(i, end=" ") #imprimir numero, sin salto linea
print() #lineavacia

Si ejecutamos el código en un texto, se ejecuta la acción para cada letra

###Ejemplo foreach, imprime las letras TEXTO
for i in "TEXTO":
print(i)

El bucle while se ejecutaría de la siguiente forma

###Ejemplo while, imprime los primeros 20 numeros
i = 1
while i <= 25: 
print(i),
i += 1

Por último para definir una función usamos la palabra reservada Def. El siguiente ejemplo defina una función que calcula el máximo de dos números, y cómo usarla para calcular el máximo entre 100 y 50.

###Ejemplo de función
defmax (n1, n2):
if n1 < n2:
return n2
elif n2 < n1:
return n1
else:
return n1

print(max(100, 50))

Hasta aquí los ejemplos básicos. Con esto tenéis los elementos básicos para empezar a probar el lenguaje. En futuras entradas ampliaremos el uso de este lenguaje, y lo emplearemos en aplicaciones de Arduino y IoT.

¿Qué es un higrómetro FC-28?

Un higrómetro de suelo FC-28 es un sensor que mide la humedad del suelo. Son ampliamente empleados en sistemas automáticos de riego para detectar cuando es necesario activar el sistema de bombeo.

El FC-28 es un sensor sencillo que mide la humedad del suelo por la variación de su conductividad. No tiene la precisión suficiente para realizar una medición absoluta de la humedad del suelo, pero tampoco es necesario para controlar un sistema de riego.

El FC-28 se distribuye con una placa de medición estándar que permite obtener la medición como valor analógico o como una salida digital, activada cuando la humedad supera un cierto umbral.

Los valores obtenidos van desde 0 sumergido en agua, a 1023 en el aire (o en un suelo muy seco). Un suelo ligeramente húmero daría valores típicos de 600-700. Un suelo seco tendrá valores de 800-1023.

La salida digital dispara cuando el valor de humedad supera un cierto umbral, que ajustamos mediante el potenciómetro. Por tanto, obtendremos una señal LOW cuando el suelo no está húmedo, y HIGH cuando la humedad supera el valor de consigna.

El valor concreto dependerá del tipo de suelo y la presencia de elementos químicos, como fertilizantes. Además, no todas las plantas requieren la misma humedad, por lo que lo mejor es que hagáis una pequeña calibración en el terreno real.

Precio

El sensor de humedad FC-28 es realmente barato. Podemos encontrarlo por 0,85€ en vendedores internacionales de Ebay y Aliexpress.

Esquema de montaje

El esquema eléctrico es sencillo. Alimentamos el módulo conectando GND y 5V a los pines correspondientes de Arduino.

Ahora si queremos usar la lectura analógica, conectamos la salida A0 a una de las entradas analógicas de Arduino.

Mientras que la conexión vista desde Arduino quedaría así,

Si quisiéramos emplear el valor digital, que se ajusta con el potenciómetro de la placa, en su lugar conectaríamos la salida D0 del sensor a una entrada digital de Arduino.

Ejemplos de código

El código necesario es realmente sencillo. Si estamos empleando la señal analógica A0, leemos el valor mediante la entrada analógica, y usamos el puerto de serie para mostrar el valor por pantalla. En un caso real, este valor se emplearía para ejecutar acciones, en lugar de mostrar el valor.

const int sensorPin = A0;

void setup() {
   Serial.begin(9600);
}

void loop() 
{
   int humedad = analogRead(sensorPin);
   Serial.print(humedad);
  
   if(humedad < 500)
   {
      Serial.println("Encendido");  
      //hacer las acciones necesarias
   }
   delay(1000);
}

Si estamos empleando la señal digital, empleamos una entrada digital para leer el estado. En el ejemplo mostramos un mensaje por la pantalla, pero igualmente en un caso real ejecutaríamos las acciones oportunas.

const int sensorPin = 10;

void setup()
{
   Serial.begin(9600);
   pinMode(sensorPin, INPUT);
}

void loop()
{
   int humedad = digitalRead(sensorPin);

   //mandar mensaje a puerto serie en función del valor leido
   if (humedad == HIGH)
   {
      Serial.println("Encendido");   
      //aquí se ejecutarían las acciones
   }
   delay(1000);
}

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Python es uno de los lenguajes de programación que mayor auge han experimentado en los últimos tiempos. Su sencillez de uso permite hacer rápidamente pequeños programas y scripts, con tiempos de desarrollo muy cortos.

Esta sencillez ha hecho que Python se gane un hueco en el Internet de las cosas (IoT), donde destaca por la facilidad para comunicar con diferentes dispositivos (ordenadores, tablet, smarthones), tanto por cable, bluetooth, o Internet.

Por supuesto, el mundo de Arduino no resulta una excepción y resulta muy sencillo conectar Arduino con Python, empleando el puerto de serie y la librería PySerial.

En esta entrada veremos cómo conectar Arduino con Python y la librería PySerial, para emplearlo en nuestros proyectos de electrónica, robótica e IoT.

La comunicación por puerto de serie puede realizarse tanto por cable, como de forma inalámbrica por bluetooth, como vimos en la entrada Conectar Arduino por Bluetooth con los módulos HC-05 ó HC-06

Para esta entrada emplearemos el puerto de Arduino. Si aún no estás familiarizado con el puerto de serie, puedes leer la entrada Comunicación de Arduino con puerto de serie.

Instalar Python y PySerial

Lo primero que necesitamos es tener instalado Python en nuestro dispositivo. Si aún no te has iniciado con Python puedes consultar la entrada Nuestro primer programa en Python donde vimos cómo instalar Python en Windows y Linux, y unos ejemplos básicos para introducir su uso.

Una vez que tengamos Python instalado para poder comunicarnos con Arduino necesitamos la librería PySerial, que nos permite emplear de forma sencilla el puerto de serie. La librería PySerial está disponible en este enlace https://github.com/pyserial/pyserial

Descargamos y ejecutamos el instalador, para añadir la librería PySerial a nuestra instalación de Python.

También podemos instalar la librería PySerial directamente desde Python, escribiendo el siguiente comando desde una consola.

python -m pip install PySerial

Con cualquiera de los dos métodos, al final tendremos la librería PySerial instalada y lista para ser utilizada en nuestros proyectos.

Ejemplos de código

A continuación vamos a ver un par de ejemplos sencillos para empezar a probar y usar la librería PySerial junto con Arduino.

Recibir información desde Arduino

En este primer ejemplo vamos a leer información enviada por Arduino, y capturada y mostrada en pantalla por Python.

Para ello empezamos cargamos en Arduino el siguiente sketch, que simplemente envía continuamente una vez por segundo el texto “Hola Mundo”.

void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println("Hola mundo");
delay(1000);
}

Dejamos el sketch funcionando en Arduino, y vamos a realizar el script en Python. Creamos un nuevo archivo de texto vacio, que guardamos con el nombre “read.py”. En su interior copiamos el siguiente código.

import serial, time
arduino = serial.Serial('COM4', 9600)
time.sleep(2)
rawString = arduino.readline()
print(rawString)
arduino.close()

Lo que hacemos es importar la librería Serial (PySerial) e instanciar un objeto PySerial, que hemos llamado “arduino”. En el constructor del objeto Serial pasamos los parámetros del puerto de serie que estemos empleado.

A continuación, empleamos la orden “readline()” del objeto Serial para leer una línea enviada por Arduino. Mostramos la línea en pantalla mediante la orden “Print()”

Finalmente mediante la orden “close()” cerramos el puerto de serie.

Como vemos, emplear el puerto de serie con PySerial es realmente sencillo. Lo único que puede parecer extraño es por qué hemos tenido que importar la librería “time”.

El motivo es que desde que creamos el objeto Serial hasta realmente está disponible para ser usado, se necesita un cierto tiempo para abrir el puerto de serie. Por tanto, tenemos que introducir una espera mediante la función “Sleep”, que pertenece a la librería “time”.

Enviar información a Arduino

En este segundo ejemplo vamos a enviar datos a Arduino desde Python. Para ello vamos a usar el siguiente sketch que vimos en la entrada Comunicación de Arduino con puerto de serie.

Este sketch recibe un número desde 1 a 9 y hace parpadear el LED integrado, conectado al PIN13, el número de veces recibido. Cargamos el sketch en Arduino, e igual que antes lo dejamos funcionado.

const int pinLED = 13;

void setup() 
{
	Serial.begin(9600);
	pinMode(pinLED, OUTPUT);
}

void loop()
{
	if (Serial.available()>0) 
	{
		char option = Serial.read();
		if (option >= '1' && option <= '9')
		{
			option -= '0';
			for (int i = 0;i


En la parte de Python necesitaremos un nuevo script que llamaremos, por ejemplo “write.py”. En su interior pegamos el siguiente código.

import serial, time
arduino = serial.Serial("COM4", 9600)
time.sleep(2)
arduino.write(b'9')
arduino.close()


Como vemos la escritura es muy similar a la lectura. En primer lugar importamos la librería PySerial y creamos un nuevo objeto de tipo Serial, indicando los valores del puerto de serie que estemos empleando.


En esta ocasión, escribimos el valor mediante la función “write” (en el ejemplo, 9). La función “Write” envía bytes, por lo que es necesario convertir el valor a bytes antecediendo una b al valor enviado (en el ejemplo b’9’).


Por último, cerramos el puerto de serie con la función “close()”.


Nuevamente hemos tenido que importar la librería time, para poder usar la función Sleep, y dar un tiempo entre el inicio de la conexión del puerto de serie y el envío de datos.


Con esto ya tenemos las funciones básicas para enviar y recibir información a Arduino desde Python, empleando la librería PySerial para controlar el puerto de serie. Resulta sencillo integrar estas funciones en nuestros programas.

En el futuro emplearemos estas funciones en proyectos más complejos. Mientras tanto, si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Actualización tras actualización Autodesk parece dispuesto a hacer más lento y pesado AutoCAD, un programa que, en principio, debería destacar por la rapidez de dibujo, sin aportar al usuario mejoras o novedades reales que justifiquen esta pérdida de rendimiento.

La versión AutoCAD 2016 no solo no ha sido una excepción en esta triste tendencia, sino que además ha eliminado casi por completo el tradicional estilo visual clásico, al que los usuarios más veteranos estábamos acostumbrados, y al que nos negamos a renunciar por la lentitud que supone el nuevo interfaz y el Ribbon.

Si sois de esos usuarios de AutoCAD expertos que personalizan el interfaz para manejarlo con teclas, que os gusta exprimir toda la velocidad, y no os resignáis a usar el nuevo (y terriblemente lento) estilo visual de AutoCAD en esta entrada veremos cómo recuperar el estilo clásico en AutoCAD 2016.

Activar el estilo clásico en AutoCAD 2016

En primer lugar creamos un nuevo estilo visual, que es el que vamos a configurar a nuestro gusto. Para ello, en la barra de espacios de trabajo, seleccionamos “Guardar actual como…”.

Damos un nombre a nuestro estilo visual, por ejemplo “Clásico”.

A continuación, nuevamente en la barra de herramientas de espacio de trabajo, pulsamos en “Parámetro del espacio de trabajo”.

Nos aseguramos de tener activo nuestro espacio de trabajo “Clásico”, y activamos la opción “Guardar automáticamente los cambios en el estilo visual” para que se conserven todas las personalizaciones que haremos a continuación.

En la consola de comandos escribimos “RIBBONCLOSE” para cerrar de forma definitiva el Ribbon.

Seguidamente activamos las barras de herramientas tradicionales desde el menú superior de AutoCAD.

Finalmente, activamos las barras de herramientas que deseemos. En mi caso, elijo “Normal”, “Estilos y “Cotas”, porque el resto de comandos los tengo asociados a teclas. Vosotros personalizarlo a vuestro gusto.

Adicionalmente, hay otras opciones que podemos desactivar para hacer AutoCAD 2016 más parecido a las versiones anteriores. Algunos las encontraréis interesantes, y otros molestas. Dejo a vuestra elección desactivarlas.

Una de estas novedades ha sido la nueva visualización suavizada de líneas. Al principio no me gustaba especialmente el nuevo aspecto difuso de las líneas, pero por otro lado se ha resuelto el problema de tener que regenerar las vistas, así personalmente no lo desactivo. Aun así, si queréis desactivarlo, en primer lugar apagamos la representación de geometría de alta calidad, poniendo la variable HQGEOM a 0, y a continuación desactivamos el suavizado de líneas poniendo la variable LINESMOOTHING a 0.

Otra novedad ha sido el resaltado de las líneas seleccionadas mediante un halo de color. No lo encuentro especialmente molesto, es cuestión de acostumbrarse. Pero si aun así queréis desactivarlo, poner la variable SELECTIONEFFECT a 0.

Listo, con eso tenemos restaurado el estilo clásico en AutoCAD 2016.

Aprovechar porque, visto la trayectoria de Autodesk, seguramente en las próximas versiones cada vez será más difícil activar el estilo clásico, hasta que sea imposible y tengamos forzosamente que usar el Ribbon.

¿Qué es un WS2812B?

Los WS2811, WS2812 y WS2812B son LED que disponen de lógica integrada, por lo que es posible variar el color de cada LED de forma individual (a diferencia de las tiras RGB convencionales en las que todos los LED cambian de color de forma simultánea).

Están basados en el LED 5050, llamado así porque tiene un tamaño de 5.0 x 5.0 mm. Es un LED de bajo consumo y alto brillo, que incorpora en un único encapsulado los 3 colores RGB.

La genial novedad del WS2812B (y resto de familia) es añadir un integrado dentro de cada LED, que permite acceder a cada pixel de forma individual. Por este motivo este tipo de LED se denominan “individual addressable”.

Esto abre la puerta a un sinfín de aplicaciones y combinaciones, que van desde dotar de iluminaciones distintas zonas con una única tira, animaciones complejas, o incluso generar pantallas enteras de alta luminosidad.

Precio

Podemos encontrar conjuntos de WS2812B en una gran variedad de formaciones, incluidas tiras, paneles, y anillos.

Encontramos tiras de distintas longitudes, que van desde 1 a 5m. En cuanto a densidad, podemos encontrar tiras de 30, 60, y 144 LED por metro. Además, existen tiras no impermeables (IP30), y tiras impermeables (IP67), que envuelven un plástico protector el PCB. Los precios varían enormemente entre estos factores, desde unos 5€ por una tira LED de 1m IP30 de 30 LED/m, a 30€ por una tira de 5M IP67 de 60 LED/metro.

En cuanto a disposición en anillo, podemos encontrar anillos de 16 LED por 3€ y de 24 LED por 4€.

En paneles, encontraremos tanto paneles flexibles como no flexibles. Podemos encontrar paneles flexibles de 8×8 por 15€, 16×16 por 35€, de 8×32 por 50€.

¿Cómo funciona un WS2812b?

El funcionamiento de un WS2812b es realmente ingenioso. Cada LED dispone de un integrado que almacena 3 bytes (24 bits), que corresponden con los 3 colores del RGB. Cada pixel puede tener 256 niveles en 3 colores, lo que supone un total de 16.777.216 posibles colores.

Cuando un LED recibe un flujo de bytes, almacena los últimos bytes recibidos y trasmite los que contenía al siguiente LED. Finalmente, con una señal de “resetcode” cada LED muestra el último valor almacenado.

Esta genial idea permite hacer configuraciones de múltiples LED, en los que únicamente tenemos que comunicarnos con el primero de ellos y cada LED se actúa de transmisor de la secuencia a los LED posteriores. Además permite que podamos encadenar o dividir tiras de LED y cualquier fragmento seguirá funcionando porque todos los LED tienen exactamente el mismo comportamiento.

Cada vez que un punto trasmite al siguiente una señal, realiza una reconstrucción de forma que la distorsión y el ruido no se acumulan. Esto permite alimentar tiras de más de 5m sin necesidad de dispositivos adicionales.

La transmisión de 0 y 1 y resetcode se realiza mediante señales pulsadas temporizadas.

• Un 0 se realiza por un pulso HIGH de 0,35 us, seguido de un periodo LOW de 0,9.
• Un 1 se realiza por un pulso HIGH de 0,9us y LOW 0,35us.
• El “resetcode” se manda como una señal LOW de 50us.

La frecuencia de funcionamiento es superior a 400Hz/s. Esto permite que se puedan animar más de 1024 puntos a una tasa refresco de 30fps.

Para más información y detalles sobre su funcionamiento, os aconsejamos consultar el Datasheet del WS2182B.

Esquema eléctrico

El esquema eléctrico para conectar LED WS2812b es sencillo. Cada LED alimenta al siguiente, por lo cual solo tendremos que conectar con el primer elemento de la formación.

Disponemos de 3 pines, 2 de alimentación (5V y GND) y entrada de datos (Din) para recibir los datos desde Ardunino.

La alimentación de la tira LED tiene que realizarse desde una fuente de alimentación externa de 5V, dado que Arduino no dispone de potencia suficiente. La referencia GND será común.

Cada LED WS2182b consume unos 60mA (0,3W), dando color blanco intenso (20mA por cada componente de color) Esto supone un consumo de 9W para 30 LED, y 18W para 60 LED, lo que es mucha potencia en una fuente de 5V.

Afortundamante, no siempre vamos a iluminar todos los LED de forma simultánea con blanco a máxima intensidad. Dependiendo del programa y efectos que hagamos la potencia requerida será mucho menor.

En casos de mucho consumo y gran número de LED también puede ser necesario alimentar por más de un punto a la vez (por ejemplo, cabeza y cola de la tira). De lo contrario, la caida de tensión hará que los últimos LED viren a rojo.

Podéis emplear la fuente de 5V para alimentar el propio Arduino. Lo que no podéis es alimentar la tira desde la salida de 5V de Arduino.

Recordar, la referencia GND siempre debe ser común.

En cuanto al pin de señal, podemos emplear cualquiera de las salidas digitales de Arduino. Es necesario emplear una resistencia de 470 ohmios entre el pin digital y el pin de señal del WS2818b, o podéis dañar los primeros LED.

También se aconseja instalar un condensador de al menos 1000 uF entre GND y 5V (aunque en los montajes que yo he probado nunca la he puesto y ha funcionado correctamente).

Ejemplos de código

Podemos mandar la señal directamente controlando adecuadamente los timings necesarios. Sin embargo, lo normal es que empleemos una librería existente que se encargue de esta tarea por nosotros. Tenemos varias librerías disponibles para manejar WS2812b desde Arduino.

Por un lado tenemos la librería NeoPixel de Adafruit que es sencilla de usar pero relativamente lenta, lo que la hace inadecuada para efectos complejos.

Por otro lado, tenemos la librería FastLED, algo más difícil pero a cambio permite patrones mucho más complejos.

Bajaros ambas bibliotecas y probar los ejemplos que vienen incluidas, para que decidáis que tipos de efectos necesitáis y con librería estáis más agusto.

A partir de aquí, depende de vuestra imaginación y del efecto que queráis conseguir. No hay límites, y la cantidad de combinaciones es infinita. Animaros a programar vuestros propios efectos y animaciones.

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino.

¿Qué es un sensor de lluvia?

Este tipo de sensores detectan la presencia de lluvia por la variación de conductividad del sensor al entrar en contacto con el agua. Existen varios modelos de sensores similares, como el FC-37 y el YL-83.

Constructivamente son sensores sencillos. Se dispone de dos contactos, unidos a unas pistas conductoras entrelazadas entre sí a una pequeña distancia, sin existir contacto entre ambas. Al depositarse agua sobre la superficie, se pone en contacto eléctrico ambos conductores, lo que puede ser detectado por un sensor.

Ambos modelos se envían con una placa de medición estándar, que permite obtener la lectura tanto como un valor analógico como de forma digital cuando se supera un cierto umbral, que se regula a través de un potenciómetro.

Los valores analógicos medidos varían desde 0 para una placa totalmente empapada, a 1023 para una placa totalmente seca.

La salida digital dispara cuando el valor de humedad supera un cierto valor, que ajustamos mediante el potenciómetro. Por tanto, obtendremos una señal LOW en ausencia de lluvia, y HIGH con presencia de lluvia.

En el caso del sensor de lluvia la señal analógica carece de interés, ya que el sensor no dispone de la precisión necesaria para medir la cantidad de agua acumulada. En cualquier caso, sería difícil extrapolar la medición a un valor de litros hora. Es decir, no podemos medir la cantidad de lluvia, solo su presencia.

El sensor de lluvia puede ser empleado, por ejemplo, para extender un toldo o activar algún otro mecanismo, hacer sonar una alarma, o registrar la cantidad de tiempo (días, horas) en el que se producen precipitaciones en una determinada zona.

El sensor de lluvia también puede ser empleado para detectar inundaciones, colocándolo en el suelo de un sótano o sala de calderas, por ejemplo. También puede ser útil para detectar cuando el agua de un depósito sobrepasa un determinado nivel.

Precio

Los sensores de lluvia son realmente baratos. Podemos encontrar un sensor de tipo YL-83 o FC-37, incluida la placa de medición, por 0,65€ en vendedores internacionales de Ebay y Aliexpress.

Ambos modelos, YL-80 y FC-37 se venden en pequeñas variaciones de geometría (más grandes, más pequeños) y de color. Pero más allá de estas diferencias, todas las variantes que veáis son idénticas en comportamiento.

Esquema eléctrico

El esquema eléctrico es sencillo. Conectamos el sensor a la placa de medición. El sensor no tiene polaridad, por lo que puede ser conectada en cualquier sentido.

Por otro lado, alimentamos la placa de medición conectando los pines GND y 5V a los pines correspondientes de Arduino.

Finalmente, conectamos la salida digital del sensor a una entrada digital para leer el estado del sensor, como vimos en la entrada Entradas digitales en Arduino.

Si quisieramos obtener el valor analógico de la medición, conectaríamos la salida analógica del sensor a una entrada analógica de Arduino, aunque como hemos dicho este sensor no dispone de la precisión suficiente para que el valor analógico sea realmente de utilidad.

Ejemplos de código

El código es igualmente sencillo. Simplemente leemos el estado de la entrada digital, tal y como vimos en la entrada.

Si el sensor se dispara, ejecutamos las acciones necesarias.

const int sensorPin = 9;

void setup() {
  Serial.begin(9600);   //iniciar puerto serie
  pinMode(pin, INPUT);  //definir pin como entrada
}
 
void loop(){
  int value = 0;
  value = digitalRead(sensorPin );  //lectura digital de pin
 
  if (value == LOW) {
      Serial.println("Detectada lluvia");
  }
  delay(1000);
}

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Projecting Mapping es una técnica consistente en proyectar imágenes sobre un objeto tridimensional. Los videos proyectados se deforman para adaptarse a la superficie de objeto real.

Es una técnica que recientemente ha alcanzado una gran popularidad. y que podemos ver con frecuencia en salas de espectáculos, conciertos, inauguraciones de edificios, e incluso en televisión. Una búsqueda en YouTube os mostrara una gran cantidad de ejemplos de Projecting Mapping, algunos de ellos con efectos realmente espectaculares.

Tradicionalmente realizar un Projecting Mapping era un proceso complejo que implicaba dibujar el objeto en 3D, renderizar el video sobre las caras del mismo, y un costoso proceso de calibración del proyector para cuadrar la escena virtual y real.

Sin embargo, el auge de esta técnica ha generado la aparición de software específico que hace que emplear esta técnica sea mucho más sencillo. Estos programas se basan en deformar dinámicamente los vídeos proyectados para adaptarse al objeto. No es necesario dibujar el objeto en 3D y calibrar la cámara. El ajuste se hace rápidamente “in situ”.

La mayoría de estos software son comerciales y están destinados a salas de conciertos, DJ, y otros espectáculos que combinan luz, vídeo y sonido. Afortunadamente también han aparecido aplicaciones gratuitas que permiten realizar Projecting Mapping desde un ordenador personal, e incluso desde un Tablet.

Una de estas aplicaciones gratuitas para hacer Projecting Mapping es el programa VPT, un programa de proyección en tiempo real creado por HC Gilje, disponible para Mac y Windows, y totalmente gratuito.

VPT está disponible en esta dirección. Requiere la instalación de QuickTime Player.

Usando VPT 7

Para empezar VPT comenzamos añadiendo capas que, en general, corresponderán con cada uno de los videos que queremos proyectar.

A continuación, seleccionamos los videos o imágenes (sources) que queremos proyectar, y los asignamos a las distintas capas.

Empleamos los puntos de ancla para deformar cada capa, hasta hacerla cuadrar con nuestro objeto real. También podemos crear máscaras para ocultar parte de la proyección, o deformar el vídeo mediante una rejilla de control, para adaptarlo a geometrías más complejas o curvas.

Guardamos cada configuración de capas y fuentes como una “Preset”. Empleamos la “Cuelist” para definir temporalmente los cambios y transiciones entre distintas “Preset”.

Finalmente, también podemos controlar el puerto de serie para conectar VPT7 con Arduino. Podemos, por ejemplo, usar las entradas para controlar la presentación desde un mando a distancia, o sensores de movimiento o presencia. O, podemos emplear las salidas para encender luces o motores, y generar efectos llamativos.

Como veis, VTP7 es un programa gratuito y muy potente que permite hacer Projecting Mapping complejos de forma sencilla. Incluso podemos enviar y recibir señales para comunicarnos con otros dispositivos, empleando Arduino y el puerto de serie.

A partir de aquí, el único límite es vuestra imaginación. Con un poco de trabajo de edición de video (inevitable en cualquiera de las soluciones), podemos conseguir efectos de Projecting Mapping realmente espectaculares.

¿Qué es una matriz LED?

Una matriz LED es un display formado por múltiples LED en distribución rectangular. Existen distintos tamaños, siendo el más habitual los cuadrados de 8×8 LED.

Podemos combinar varios módulos para formar un display mucho mayor. En estos display podemos mostrar textos, dibujos o animaciones, como desplazar un texto (scroll).

Encender una matriz de LED directamente con Arduino requiere emplear una gran cantidad de pines, lo cuál supondría un gran desperdicio de recursos. Por este motivo, lo normal es que siempre empleemos un controlador específicamente diseñado para esta función.

Un controlador habitualmente empleado por ser barato y sencillo es el integrado MAX7219.

Precio

Las matrices LED monocromo (rojas o verdes) son componentes baratos. Se venden tanto junto al controlador MAX7219, como ambos componentes por separado. Lo normal es que queramos comprarlos en conjunto.

Podemos encontrar un conjunto de Matriz LED de 8×8 + controlador MAX7129 por 1,27€ en vendedores internacionales de Ebay o Aliexpress.

Además estos módulos incorporan pines de entrada y salida, por lo que es sencillo unir varios módulos para formar un display mayor, simplemente usando unos jumpers de conexión.

¿Cómo funciona un matriz LED?

Una matriz de LED está formado por diferentes LED, cableados de forma conjunta por filas y columnas. Podemos encender un LED determinado de la matriz aplicando correctamente los valores HIGH y LOW a su respectiva fila y columna.

Si aplicamos valores HIGH y LOW a varias filas y columnas de forma simultánea se encenderán todos los LED de las intersecciones. De esta forma, resulta casi imposible generar gráficos complejos.

Para poder hacer gráficos el procedimiento consiste en hacer un barrido por filas (o columnas). Encendemos todos los LED de una única fila (o columna), y a continuación cambiamos a la siguiente. Sólo una fila (o columna) está encendida cada instante pero, al hacerlo rápidamente, el efecto en nuestra visión es ver toda la imagen formada de forma simultánea.

Encender una matriz de 8×8 LED requeriría 16 señales digitales y un trabajo constante del procesador para refrescar la imagen. Eso es una cantidad enorme de recursos para cualquier autómata, que estaríamos mal aprovechando para simplemente encender un display.

Por este motivo, empleamos un controlador como el MAX7219 que está especialmente diseñado para encender displays de 7 segmentos y matrices de led, y libera a nuestro procesador para hacer tareas mucho más valiosas.

La comunicación con el MAX7219 se realiza a través de SPI por lo que sólo se requieren 3 pines de Arduino (SS, MOSI y SCK). Además ni siquiera “ocupamos” del todo estos pines, ya que con el mismo bus podemos controlar múltiples dispositivos.

Por último, las propias placas MAX7219 generalmente incorporan un puerto de entrada y salida, de forma que podemos combinar múltiples controladores sin ninguna dificultad.

Esquema eléctrico

El esquema eléctrico es sencillo. Alimentamos el módulo a través de Vcc y Gnd, y conectamos los pines correspondientes para la comunicación SPI.

En caso de usar más de un módulo, conectaríamos las salidas de cada módulo con las entradas del siguiente, y conectaríamos el primero a Arduino.

La conexión vista desde el lado de Arduino quedaría así.

Ejemplos de código

Existen varias librerías para comunicar Arduino con un controlador MAX7219. Por ejemplo, tenemos la librería Max72xxPanel, que requiere el uso de la librería Adafruit-GFX.

El siguiente código de ejemplo emplea estas dos librerías para mostrar un texto que se desplaza a lo largo de 9 matriz LED unidas. Modificar el código para adaptarse a vuestra configuración y necesidades.

#include 
#include 
#include 

//Vcc - Vcc
//Gnd - Gnd
//Din - Mosi (Pin 11)
//Cs  - SS (Pin 10)
//Clk - Sck (Pin 13)

const int pinCS = 10;
const int numberOfHorizontalDisplays = 9;
const int numberOfVerticalDisplays = 1;

Max72xxPanel matrix = Max72xxPanel(pinCS, numberOfHorizontalDisplays, numberOfVerticalDisplays);

String tape = "www.luisllamas.es";  //text

const int wait = 100; // In milliseconds

const int spacer = 1;
const int width = 5 + spacer; // The font width is 5 pixels

void setup() {
	matrix.setIntensity(7); // Use a value between 0 and 15 for brightness

	// Adjust to your own needs
	matrix.setPosition(0, 0, 0); // The first display is at <0, 0>
	matrix.setPosition(1, 1, 0); // The second display is at <1, 0>
	matrix.setPosition(2, 2, 0); // The third display is at <2, 0>
	matrix.setPosition(3, 3, 0); // And the last display is at <3, 0>
	matrix.setPosition(4, 4, 0); // And the last display is at <3, 0>
	matrix.setPosition(5, 5, 0); // And the last display is at <3, 0>
	matrix.setPosition(6, 6, 0); // And the last display is at <3, 0>
	matrix.setPosition(7, 7, 0); // And the last display is at <3, 0>
	matrix.setPosition(8, 8, 0); // And the last display is at <3, 0>
	matrix.setPosition(9, 9, 0); // And the last display is at <3, 0>

	matrix.setRotation(0, 1);    // Display is position upside down
	matrix.setRotation(1, 1);    // Display is position upside down
	matrix.setRotation(2, 1);    // Display is position upside down
	matrix.setRotation(3, 1);    // Display is position upside down
	matrix.setRotation(4, 1);    // Display is position upside down
	matrix.setRotation(5, 1);    // Display is position upside down
	matrix.setRotation(6, 1);    // Display is position upside down
	matrix.setRotation(7, 1);    // Display is position upside down
	matrix.setRotation(8, 1);    // Display is position upside down
	matrix.setRotation(9, 1);    // Display is position upside down
}

void loop() {
	for (int i = 0; i < width * tape.length() + matrix.width() - 1 - spacer; i++) {

		matrix.fillScreen(LOW);

		int letter = i / width;
		int x = (matrix.width() - 1) - i % width;
		int y = (matrix.height() - 8) / 2; // center the text vertically

		while (x + width - spacer >= 0 && letter >= 0) {
			if (letter < tape.length()) {
				matrix.drawChar(x, y, tape[letter], HIGH, LOW, 1);
			}

			letter--;
			x -= width;
		}
		matrix.write(); // Send bitmap to display

		delay(wait);
	}
}

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

A medida que os aventuréis en el mundo de Arduino, de la robótica y de la automatización, tarde o temprano os surgirá la necesidad de alimentar vuestro Arduino desde una batería.

Bien sea porque estáis haciendo un robot, un quadricóptero o cualquier otro tipo de vehículo, o porque queréis dejar conectado un monitor que registre la temperatura, o el consumo eléctrico, entre otros muchos ejemplos, lo cierto es que no siempre vais a disponer de un cable para alimentar a nuestro Arduino. En estos casos, y especialmente en el caso de vehículos, necesitaremos proporcionar baterías a nuestro proyecto.

Por otro lado, nuestras baterías no deberán proveer de alimentación a Arduino. En proyectos con baterías deberemos estudiar si estas resultan adecuadas para alimentar el resto de componentes de nuestro proyecto, como motores, servos, sensores.

Disponemos de una gran cantidad de opciones para alimentar nuestros proyectos con baterías. En esta entrada vamos a hacer un repaso de las principales, indicando las ventajas y desventajas de cada una, para que podáis elegir la que mejor se adapte a vuestro proyecto.

¿Cómo alimentar Arduino?

Antes, de ver las opciones que tenemos para alimentar nuestro proyecto con baterías vamos a ver, a modo de resumen, los dos puntos principales por los que podemos alimentar Arduino.

En general podemos:

• Emplear el regulador de voltaje integrado en la placa.
• Aplicar directamente un voltaje regulado a la tensión nominal de la placa.

Emplear el regulador de voltaje

Todas las placas Arduino disponen de un regulador de voltaje. Este regulador supone una pequeña caída de tensión, por lo que deberemos proporcionar una tensión de al menos 6V. Por debajo de esa tensión, lo más probable es que Arduino se apague.

Por otro lado, cuanto mayor sea el voltaje, mayor será el calor que el regulador debe disipar. No este recomendado aplicar más de 12V al regulador porque supone un esfuerzo excesivo. Proporcionar más de 20V dañará el regulador inmediatamente.

Aplicar un voltaje regulado

También podemos aplicar la tensión nominal (5V o 3,3V, según el modelo) directamente a la placa sin emplear el regulador. Es decir, podemos alimentar suministrando 5V al pin 5V de Arduino. Por ejemplo, es lo que estamos haciendo cuando alimentamos Arduino desde el USB.

En el caso de aplicar el voltaje directamente la fuente de alimentación que empleemos tendrá que estar regulada a la tensión nominal con un alto grado de precisión. Una variación o un pico de tensión dañará Arduino, ya que no estamos empleando el regulador de voltaje.

En resumen

De forma resumida, para alimentar Arduino podemos:

• Aplicar 6-12V en la clavija jack que disponen Arduino UNO, Mega, entre otros modelos
• Aplicar 6-12V entre el pin GND y el pin RAW (pin Vin en Arduino Mini)
• Alimentar mediante USB
• Aplicar 5V (¡regulados y estables!) en el pin 5V (3,3V en ciertos modelos)

Para más información sobre limitaciones de alimentación en Arduino, y puntos de entrada en los distintos modelos, consultar la entrada Esquema de patillaje en Arduino.

Opciones para alimentar Arduino por batería

Ahora que hemos visto que opciones tenemos para alimentar Arduino, podemos ver las distintas soluciones que tenemos para alimentar nuestros proyectos con baterías.

Una pila de 9V

Usar una pila de 9V es una de las opciones más extendidas, especialmente para usuarios que se están iniciando y en proyectos de pequeño tamaño. El voltaje de 9V es apropiado para alimentar Arduino.

Tienen la ventaja de ser fáciles de encontrar y usar. Además hay disponibles cables y portapilas, que incluso incorporan un conector jack tipo Arduino, lo que hace que sean fáciles de usar.

Como desventajas, las pilas de 9V disponen de baja densidad energética. Una pila tiene una capacidad típica de 500-600mAh. Además, son proporcionan una intensidad de corriente máxima muy baja, en torno a 300mA, útil solo para proyectos pequeños.

Por otro lado, 9V es una tensión inadecuada para la mayoría de accionadores. Resulta excesiva para la mayoría de motores DC y servos, mientras que no es suficiente para grandes motores brushless y paso a paso, que funcionan con 12V y, además, requieren mucho más intensidad.

El precio es reducido, pero tienen la gran desventaja de no ser dispositivos recargables, lo que, unido a su baja carga, hacen que a largo plazo no resulten económicas.

En resumen, una opción para pequeños montajes o pruebas sencillas, pero que en seguida queda corto en características, por lo que requeriremos opciones superiores.

4 pilas AA de 1.5V

Emplear cuatro pilas AA en serie, proporcionando un total de 6V, es otra opción sencilla y ampliamente usado en pequeños proyectos y proyectos de iniciación.

Podemos encontrar con facilidad porta pilas, cables y otras soluciones para incorporar cuatro pilas AA como forma de alimentación en nuestros proyectos.

Las pilas AA tienen la ventaja de ser fáciles de encontrar. Además, el voltaje de 6V es perfecto para alimentar motores de DC y servos.

La carga es superior a las pilas de 9V. Cuatro pilas AA convencionales proporcionan 800-1500 mAh mientras que, en el caso de usar pilas AA alcalinas la capacidad es de 1700-2800mA.

La intensidad máxima que podemos obtener supera 1A, pudiendo llegar a extraer hasta 2A. Pero debemos tener en cuenta que, debido a las curvas de descarga, la cantidad de carga que podemos extraer de la pila se reduce cuanto más rápido la drenamos.

El precio de las pilas es barato, pero al no ser recargables a largo plazo no resulta económico.

En resumen, otra opción sencilla, válida para pequeños proyectos y robots.

5 baterias recargables de AA de 1.2V

Similar al caso anterior, pero esta vez con baterías recargables. Podemos usar baterías de NiCd (en desuso) o NiMh. El voltaje es un poco inferior, 1.2V por bateria, por lo que necesitaremos 5 baterías para conseguir los 6V.

De forma similar a las opciones anteriores, podemos encontrar fácilmente porta baterías para 5 baterías AA, así como todo tipo accesorios y cables para conectar de forma sencilla a Arduino.

Las pilas recargables AA son fáciles de encontrar, pero son más caras que las pilas no recargables. A esto debemos añadir la necesidad de un cargador. Pese a ello, estos sobre costes se compensan rápidamente, resultando más económico que comprar pilas constantemente.

La carga de las pilas recargables también es algo inferior a las no recargables. Las baterías de NiCd tienen una carga de entre 500-1000 mAh. Las baterías de NiMh tienen capacidades de entre 600-2500 mAh.

La intensidad máxima es similar, aproximadamente 1A de forma sostenible, lo cuál es suficiente para proyectos y robots pequeños.

Por tanto, usar 5 baterías recargables de NiMh es es la opción recomendada para proyectos pequeños, que no requieran grandes necesidades de intensidad eléctrica ni capacidad, pero que usaremos frecuentemente, por lo que sale rentable usar una solución recargable..

2 baterías de Litio 18650 de 3,7V

Las baterías de litio 18650 son conocidas por alimentar linternas y láser de mano. Aunque no son tan conocidas como solución de alimentación para Arduino, en realidad son una gran opción a tener en cuenta.

Dos baterías de litio 18650 puestas en serie proporcionan 7.4-8.2V, que es un voltaje perfecto para alimentar Arduino. También encontramos porta baterías que permiten incorporar con facilidad estas baterías a nuestros proyectos.

Las baterías de litio 18650 tienen la ventaja de proporcionar una alta capacidad de carga. Las baterías de primeras marcas proporcionan hasta 4800 mAh. (Las baterías “chinas” ofrecen capacidades muy superiores, aunque en realidad entregan entre 1500-2500).

Proporcionan una capacidad de descarga de entre 1C – 2C, según modelos. Esto supone una intensidad máxima de hasta 10A, aunque por seguridad no resulta aconsejable drenar más de 2-4 A sin estar muy seguros de la calidad y características de vuestra batería.

Por supuesto, las baterías de litio 18650 son recargables. Aunque se requiere un cargador especial para baterías 18650, son baratos y se amortizan rápidamente.

Como desventajas, son una opción algo más cara que las anteriores, especialmente si compramos baterías buenas (algo que es recomendable). Además, su manipulación debe ser más cuidadosa, dado que el uso incorrecto de baterías de litio puede ser peligroso, causando sobrecalentamientos o incluso incendios.

Por otro lado el voltaje es algo elevado para motores DC y servos, aunque podemos reducirlo insertando un par de diodos, que de paso servirán como protección adicional a las baterías.

En resumen, una opción más avanzada que las anteriores interesante para proyectos y robots de tamaño medio, con mayores requisitos de capacidad y corriente.

Bancos de baterías USB de 5V

Emplear una batería USB, de las que se usan para alargar la batería de los móviles, es una opción interesante para incorporar en nuestros proyectos.

Tienen como ventaja que proporcionan 5V regulados, por lo que podemos alimentar Arduino a través del USB, sin preocuparnos de la necesidad de regular el voltaje.

Muchos de estos bancos, de hecho, incorporan una única batería de litio 18650, más un pequeño circuito que eleva y regula el voltaje a 5V. En estos casos podemos incluso sustituir una batería por otra, empleando la misma caja, mientras cargamos la batería descargada.

El voltaje de 5V es adecuado para alimentar una gran variedad de componentes, como motores DC, servos, así como una gran cantidad de dispositivos (sensores, tiras LED, displays… ).

Estos bancos son, por supuesto, recargables. La capacidad de energía es alta, pudiendo encontrar bancos de hasta 17.000 mAh (aunque nuevamente no os creáis por completo las capacidades que ponen en los anuncios).

Como desventaja, es una opción algo cara frente a otras opciones disponibles. Además, la intensidad máxima es reducida, típicamente inferior a 2A, lo que le hace inviable para proyectos grandes.

En resumen, un banco de baterías USB es una buena solución de movilidad, como batería para llevar encima que nos permita hacer pruebas y montajes de forma sencilla (y mucho mejor que una batería de 9V).

Incluso es una opción que podríamos plantearnos en proyectos y robots medianos, siempre que podamos reaprovechar y rotar la misma batería entre los distintos proyectos para aprovechar su coste.

Baterías de Niquel-metalhidruro (NiMh)

Esta es la primera solución “pro” que planteamos. Es similar al caso de las baterías AA de NiMh, pero integradas como una única batería de mayor o menos tamaño, y con conectores.

Las baterías de NiMh tienen, en general, 5 celdas co una tensión de 6V, o 8 celdas con una tensión de 9.6V. Las baterías de 5 celdas a 6V, son excelentes para proyectos y robots con servos y motores DC.

Las baterías NiMh tienen una densidad de energía media-alta. Podemos encontrar baterías con capacidades desde 300 a 5000 mAh, con un peso moderado.

Las baterías NiMh pueden proporcionar una considerable cantidad de energía. Dependiendo de la calidad del modelo pueden proporcionar entre 3-4C, lo que puede significar hasta 15A en el caso de grandes baterías.

Por contra, las baterías de NiMh son relativamente caras, y además exigen el uso de un cargador especial, que también es costoso. Las conexiones y cables requeridos, para corrientes altas, también encarecen los montajes.

Las baterías de NiMh resultan adecuadas para proyectos medios y grandes en los que se requiere una gran capacidad y corrientes medias, especialmente en aquellos que emplean servos (brazos robóticos, hexápodos, robots bípedos), ya que el voltaje de 6V resulta idóneo.

Baterías de Polimero Litio (Lipo)

Las baterías de Polimero Litio (Lipo) son la opción más avanzada para alimentar nuestros proyectos.

Las baterías LiPo se presentan en varios voltajes, en función del número de celdas. Así las LiPo de 2 celdas (2S) proporcionan 7.4V-8.4, y las de 3 celdas (3S) proporcionan 11.1-12.6V. Ambos voltajes son adecuados para alimentar un Arduino.

Las baterías de 2S (7.4-8.4V) pueden emplearse para alimentar servos y motores DC, aunque es una tensión algo excesiva y conviene reducirla hasta los 6-7V. Las baterías de 3S (11.1-12.6V) son adecuadas para accionar grandes motores paso a paso, y motores brushless.

Las baterías LiPo presentan la densidad de energía más alta de las opciones planteadas. Podemos encontrar baterías con capacidades desde 500 a 5000mAh.

Además, las baterías LiPo tienen la ventaja de proporcionar enormes intensidades. Es posible encontrar baterías 20-25C, lo que se traduce en intensidades de descarga de 50 a 100A, requerida por los motores más grandes.

Las baterías LiPo también son la opción más cara, aunque al ser recargables resultan económicas a largo plazo, más aún si tenemos en cuenta sus características eléctricas.

La mayor desventaja de estas baterías es la dificultad y cuidado que hay que tener en su uso. Manipular de forma indebida una batería LiPo puede ser extremadamente peligroso, por las gran cantidad de energía que almacenan.

La carga de este tipo de baterías tiene que realizarse mediante cargadores especiales, y no deberían dejarse sin supervisión durante el proceso. Hasta el almacenamiento de estas baterías debe realizarse en condiciones controladas.

En resumen, las baterías LiPo son la solución más potente para alimentar nuestros proyectos, pero los requisitos de manipulación y carga la hacen adecuada sólo para usuarios avanzados y los proyectos complejos, como grandes robots, quadricópteros, y otro tipo de grandes vehículos.

Conclusión

Hemos repasado distintas formas de alimentar Arduino por batería. Resulta aconsejable optar por una solución recargable porque a la larga resulta más económico.

Para empezar, 5 baterías de mAh son apropiadas para robots pequeños y pequeños proyectos. Para montajes intermedios, una combinación de baterías de litio 18650 puede ser una opción interesante. Los montajes más grandes necesitarán baterías de NiMh, para montajes de 6V (en especial proyectos con servos) o LiPo, en 2S o 3S (motores paso a paso, o brushless).

También puede resultar interesante tener un banco de 5V, como opción portátil para pruebas in situ, o estemos fuera de casa.

Y por último, no os creáis las capacidades (mAh) que indican los fabricantes de marcas no reconocidas, porque no están ni remotamente cerca de la realidad. (Lo cuál no significa que no la compréis, solo que no creáis la capacidad que dicen)

Ya tenemos la mayoría de opciones para alimentar nuestros proyectos de Arduino con batería, y podemos empezar a usarlo en nuestros proyectos de robótica.

Mientras, si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Desarrollar plugins para WordPress puede ser un auténtico infierno si no nos proveemos de las herramientas adecuadas.

Escribir “a pelo” los plugins en un editor de texto resulta viable para pequeños desarrollos pero. a medida que su extensión y complejidad aumenta, se hace patente la necesidad de un IDE en condiciones.

Afortunadamente podemos configurar PhpStorm, uno de los mejores IDE disponibles para PHP, para desarrollar cómodamente plugins en WordPress.

Supongamos que tenemos instalado nuestra versión de JetBrains PhpStorm, y una instalación de pruebas de WordPress en XAMPP o en otro servidor similar.

Para empezar creamos un nuevo proyecto. Definimos la dirección del proyecto, su nombre, y elegimos como tipo de proyecto “Wordpress Plugin”

En la siguiente pantalla, elegimos la ubicación de la instalación de WordPress (por ejemplo, C:\xampp\htdocs\wordpress)

Con esto hemos creado el proyecto, pero aún es necesario configurar la instalación de WordPress como librerías externas. Para eso hacemos doble click sobre “External libraries”

En la siguiente ventana, pulsamos el botón de “añadir” y agregamos la ubicación de red de nuestro WordPress de pruebas.

Finalmente, nos metemos en “File/Settings” y verificamos que la opción de “Wordpress Integration” está correctamente configurada.

Si vamos a trabajar en un proyecto existente, sin pasar por el Wizard de creación de proyecto, debemos configurar la integración desde esta última ventana.

Comprobamos que todo funciona correctamente, probando las sugerencias y el autocompletado de palabras. Por ejemplo, si escribimos “add_action”, PhpStorm nos sugiere los comandos disponibles. Podemos desplazarnos entre las opciones con las teclas arriba y abajo, y aceptar una con la tecla tabulación.

Si ahora escribimos, dentro de “add_action(‘ ’)” la palabra “footer”, y pulsamos control+space, PhpStorm nos sugiere los posibles hooks de WordPress.

Con esto ya tenemos PhpStorm configurado para programar plugins para WordPress en un entorno cómodo y rápido, que hará las delicias para los desarrolladores más exigentes y los proyectos más complejos.

Históricamente el Arduino Mini Pro ha sido uno de los modelos favoritos para los usuarios expertos de Arduino. Su bajo coste y reducido tamaño lo hacía el modelo perfecto para proyectos donde Arduino pasaba a ser parte del montaje de forma permanente.

Sin embargo, su pequeño coste y tamaño tenían su lado negativo, y es que el Arduino Mini Pro carece de circuito de USB. Como consecuencia, los Arduino Mini Pro tienen que ser programados mediante un conversor USB-TTL externo.

Actualmente, ante la bajada precio del Arduino Nano el interés en los Arduino Mini Pro ha descendido notablemente. Arduino Nano sí incorpora un puerto Micro USB y resulta mucho más sencillo y rápido de usar (en serio, compraros Arduino Nano, ganaréis salud mental).

Pero por si aún tenéis algún día os toca lidiar con un Arduino Mini, o si tenéis alguno guardado en un cajón o, sobre todo, porque resulta interesante para profundizar en el funcionamiento interno de Arduino, vamos a ver cómo programar un Arduino Mini Pro.

¿Qué es el FTDI FT232R?

Para poder programar un Arduino Mini Pro necesitamos un dispositivo que supla el circuito USB que tienen la mayoría de modelos Arduino.

El programador más habitual es el modelo FT232R de la compañía FTDI (Future Technology Devices International) con un coste entorno a 1,5€.

Instalar los Driver

La mayoría de distribuciones Linux incluidos los driver para del FTDI FT232R. Sin embargo, esto no es así en ninguna de las versiones de Windows.

Afortunadamente, en caso de usar un sistema operativo Windows (o una distribución Linux que no incluya los driver) la solución es tan sencilla como bajar e instalar los driver desde la página web del fabricante.

Aquí seleccionamos VPC Drivers (Virtual COM Ports) y seleccionamos el driver más actual disponible. En el caso de Windows aseguraros de bajar el instalador ejecutable, en lugar del archivo comprimido, ya que la instalación es más sencilla.

Tras instalar el driver, conectamos el FTDI FT232R. Vamos a dispositivos, y en puertos COM localizamos el correspondiente al FTDI FT232R. Pulsamos con el botón derecho y elegimos “Propiedades”

Aquí, en opciones avanzadas activamos la opción “RST alto al cerrar”. Esto reiniciará Arduino al cargar el programa, algo necesario para el proceso de programación de Arduino.

Conectar Arduino Mini Pro y FTDI FT232R

Conectar Arduino Mini Pro al FTDI Pro es sencillo. Simplemente tenemos que conectar frontalmente los 6 conectores de FTDI FT232R a los 6 pines frontales del interfaz FTDI de Arduino Mini Pro.

La conexión podemos realizarla mediante conductores normales con terminales dupont hembra o, incluso, para pruebas rápidas podemos conectar ambos frontales directamente en una protoboad, poniéndolos uno frente al otro.

A continuación conectamos el FTDI FT232R al ordenador mediante USB. En el entorno de Arduino seleccionamos el puerto COM correspondiente, el modelo de placa Mini Pro, y como programador dejamos el que usamos habitualmente “AVRISP mkII”.

Listo, podemos cargar programas con normalidad y usar el puerto de serie como en cualquier otro modelo de Arduino.

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

¿Qué es un DHT11 / DHT22?

El DHT11 y el DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad.

Estos sensores disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino.

Ambos sensores presentan un encapsulado de plástico similar. Podemos distinguir ambos modelos por el color del mismo. El DHT11 presenta una carcasa azul, mientras que en el caso del sensor DHT22 el exterior es blanco.

De ambos modelos, el DHT11 es el hermano pequeño de la familia, y cuenta peores características técnicas. El DHT22 es el modelo superior pero, por contra, tiene un precio superior.

Las características del DHT11 son realmente escasas, especialmente en rango de medición y precisión.

• Medición de temperatura entre 0 a 50, con una precisión de 2ºC
• Medición de humedad entre 20 a 80%, con precisión del 5%.
• Frecuencia de muestreo de 1 muestras por segundo (1 Hz)

El DHT11 es un sensor muy limitado que podemos usar con fines de formación, pruebas, o en proyectos que realmente no requieran una medición precisa.

Por el contrario, el modelo DHT22 tiene unas características mucho más aceptables.

• Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
• Medición de humedad entre 0 a 100%, con precisión del 2-5%.
• Frecuencia de muestreo de 2 muestras por segundo (0.5 Hz)

EL DHT22 (sin llegar a ser en absoluto un sensor de alta precisión) tiene unas características aceptables para que sea posible emplearlo en proyectos reales de monitorización o registro, que requieran una precisión media.

Precio

El DHT11, el modelo inferior en características, es realmente barato. Podemos encontrarlo en vendedores internacionales en Ebay y AliExpress por 0,70€.

Mientras, podemos encontrar el modelo superior DHT22 por 2,40€, considerablemente más caro que su hermano pequeño, pero aún relativamente barato.

Esquema eléctrico

La conexión del DH11 y el DHT22 son idénticas, ya que como hemos comentado la única diferencia entres modelos son sus prestaciones. En ambos casos, disponemos de 4 patillas, de las cuales usaremos 3, Vcc, Output y GND.

Conectar el sensor es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino. Necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El esquema eléctrico queda como la siguiente imagen

Mientras que el montaje en una breadboard sería el siguiente.

Ejemplos de código

Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único conductor, empleando señales temporizadas.

En cada envío de medición el sensor envía un total de 40bits, en 4ms. Estos 40 bits corresponden con 2 Bytes para la medición de humedad, 2 Bytes para la medición de temperatura, más un Byte final para la comprobación de errores (8bit integral RH data + 8bit decimal RH data + 8bit integral T data + 8bit decimal T data + 8bit check sum)

Podemos leer los datos del sensor directamente generando y leyendo las señales temporizadas según el protocolo del DHTXX. En general, lo normal es que empleemos una librería existente para simplificar el proceso.

Existen varias librerías disponibles. Por ejemplo, podemos usar la librería de Adafruit disponible en este enlace.

Descargamos e instalamos la librería y cargamos el código de ejemplo, o la siguiente versión simplificada

#include "DHT.h"

// Uncomment whatever type you're using!
//#define DHTTYPE DHT11   // DHT 11
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

const int DHTPin = 5;     // what digital pin we're connected to

DHT dht(DHTPin, DHTTYPE);

void setup() {
	Serial.begin(9600);
	Serial.println("DHTxx test!");

	dht.begin();
}

void loop() {
	// Wait a few seconds between measurements.
	delay(2000);

	// Reading temperature or humidity takes about 250 milliseconds!
	float h = dht.readHumidity();
	float t = dht.readTemperature();

	if (isnan(h) || isnan(t)) {
		Serial.println("Failed to read from DHT sensor!");
		return;
	}


	Serial.print("Humidity: ");
	Serial.print(h);
	Serial.print(" %\t");
	Serial.print("Temperature: ");
	Serial.print(t);
	Serial.print(" *C ");
}

Cargamos el programa en Arduino, y empezaremos a recibir por el puerto de serie los valores de temperatura y humedad.

Si te ha gustado esta entrada y quieres leer más puedes consultar el resto de tutoriales de Arduino

Desde las primeras versiones de Windows siempre ha sido posible acceder a la carpeta que contiene los accesos directos del menú de inicio.

De esta forma resultaba sencillo crear carpetas, crear o eliminar accesos y, en definitiva, organizar el menú de inicio a nuestro gusto.

Sin embargo, Microsoft está decidido a ponernos las cosas más escondidas versión tras versión. En Windows 10, aunque esta misma carpeta existe, ya no es tan sencilla de encontrar como pulsar con el botón derecho, como pasaba en versiones anteriores.

Para tranquilos sigue siendo posible acceder mediante el comando Ejecutar (tecla Windows + R)

Ejecutando “Shell:startup” accedemos a la carpeta del menú de inicio del usuario local.

Mientras que ejecutando “Shell:common startup” accederemos a la carpeta de del menú de inicio de todos los usuarios.