¿Necesitas librerías para Arduino y no sabes cómo ni dónde encontrarlas?

Hoy vengo a ofreceros una manera de buscar librerías para Arduino desde su propio programa.

Lo primero que tendremos que hacer una vez abierto el programa de Arduino será irnos al apartado de «Programa» y en el desplegable que nos aparecerá haremos click en «incluir librería», como se muestra en la siguiente ilustración:

Una vez aquí, nos aparecerá de nuevo otro desplegable, donde ahora nos tendremos que ir al apartado que nos dice «Gestionar librerías», como aparece en la siguiente imagen:

Ahora, nos aparecerá una ventana donde podremos buscar y descargar las librerías que deseemos, para hacer una demostración yo he probado a buscar «Dallas», para quien no lo conozca es un sensor de temperatura, a continuación se muestra el resultado mediante una imagen:

Cuando nos muestra los resultados solo tendremos que hacer click encima de la librería que deseemos obtener y darle a «Instalar».

Para finalizar, nos aparecerá una barra en la parte inferior de la ventana anterior que nos dirá lo que se muestra a continuación:

Cuando la barra se complete ya estará todo correcto y por lo tanto, dispondremos de nuestra libería.

El articulo Cómo buscar librerías en Arduino esta en Alexalt. Por José Alejandro

¿Te gustaría saber como guardar datos en tu tarjeta SD automáticamente con Arduino? 

En este post se va a explicar como hacer un guardado automático pero con un módulo SD o micro SD, ya se explicó como hacer esto mismo pero con la memoria EEPROM de Arduino.

Y bien, ¿Qué se necesita para hacer este proyecto?

• Pila RTC DS1307 Comprar en Amazon (Este  nos mantendrá nuestro Arduino en tiempo real)
• Sensor Comprar en Amazon ( En este caso es un sensor de temperatura DS18B20 Dallas)
• Placa Arduino Comprar en Amazon (En este caso Arduino Uno) 
• Módulo SD o micro SD Comprar en Amazon (La función de este será, la de almacenar los datos cada cierto tiempo automáticamente).

Pero, ¿Qué es exactamente lo que hace nuestro código?

Bien, la función del código que hay a continuación, es la de realizar un guardado automático tanto a las 12:00 como a las 18:00.

Cuando llegue una de estas dos horas definidas, guardará automáticamente los datos que está recogiendo en ese mismo momento el sensor de temperatura y lo almacenará en la tarjeta SD que tengamos insertada en el módulo SD o micro SD, el archivo que creará será nombrado como «datos.txt» (este se puede modificar).

Si hemos borrado el archivo «datos.txt» de la memoria SD, no hay ningún problema, ya que, cuando llegue la siguiente hora volverá a crear uno con el mismo nombre.

Por lo tanto, el código es el siguiente:

#include <OneWire.h> 
#include <DallasTemperature.h>
#include <Time.h>
#include <DS1307RTC.h>
#include <SPI.h>
#include <SD.h>

OneWire ourWire(2);
DallasTemperature sensors(&ourWire);

//Ahora empezamos a declarar las variables:
const int chipSelect = 4; // En el pin 4 de nuestro Arduino se conectará el módulo SD.
bool escritura = 0; //Nos ayudará a que no hayan varias grabaciones en un mismo segundo.
 
void setup ()
  {
    pinMode(chipSelect, OUTPUT); //Indicamos que el pin del modulo SD es de salida.
   
    sensors.begin();//Inicia los sensores
    sensors.requestTemperatures();
    SD.begin(chipSelect); //Inicia el módulo SD
   
  }

void loop ()
   {       
     
    tmElements_t tm;
    if (RTC.read(tm)) {} //Iniciamos la pila DS1307 para que nos controle la hora que es.
 
 
  /*
   * En primer lugar hacemos cuatro comparaciones de modo que si se cumplen entrarán dentro de
   * nuestro if.
   * Por lo tanto, sí son las 12:00:00 y escritura es igual a 0 (Escritura será igual a 0 porque 
   * está definida al inicio del sketch). De esta manera hará lo que hay dentro del if que explicaré 
   * a continuación.
   */
 
    
  if ((tm.Hour==12) && (tm.Minute==0) && (tm.Second==0) && (escritura==0))
 { 
  
        /*
         * Lo que se muestra a continuación es el método de creación de archivo para el módulo,
         * si por lo contrario ya está creado lo que hará será ir escribiendo dentro de este,
         * escribiendo en él lo que aparacece a continuación:
         */
    
      File dataFile = SD.open("datos.txt", FILE_WRITE); //Si no existe el archivo "datos.txt" lo creará, y si existe, escribe dentro de él.
        
        if (dataFile) //Por lo tanto escribirá todo esto:
        {
          dataFile.print("Dia de la grabacion");dataFile.print(","); dataFile.print(tm.Day); dataFile.print("/"); dataFile.print(tm.Month);
          dataFile.print("/"); dataFile.print(tmYearToCalendar(tm.Year));  dataFile.print(",");  dataFile.print("Hora de la grabacion:");
          dataFile.print(tm.Hour); dataFile.print(":"); dataFile.print(tm.Minute);dataFile.print(":"); dataFile.print(tm.Second);
          dataFile.print(","); dataFile.print("Temperatura:");dataFile.print(sensors.getTempCByIndex(0)); dataFile.println("C");dataFile.close();
          escritura=1; //Ahora lo pondremos a 1 para que no haga varias grabaciones en el mismo segundo.
        } 
    
 }
 
   if ((tm.Hour==12) && (tm.Minute==1) && (tm.Second==0))
    { 
     escritura=0; // Cuando pase un minuto pondremos escritura a 0 para que esté preparado para la siguiente grabación.
    }

   
  if ((tm.Hour==18) && (tm.Minute==0) && (tm.Second==0) && (escritura==0))
 { 
  
        /*
         * Lo que se muestra a continuación es el método de creación de archivo para el módulo,
         * si por lo contrario ya está creado lo que hará será ir escribiendo dentro de este,
         * escribiendo en él lo que aparacece a continuación:
         */
    
      File dataFile = SD.open("datos.txt", FILE_WRITE);  //Si no existe lo crea, y si existe, escribe dentro de él.
        
        if (dataFile)
        {
          dataFile.print("Dia de la grabacion");dataFile.print(","); dataFile.print(tm.Day); dataFile.print("/"); dataFile.print(tm.Month);
          dataFile.print("/"); dataFile.print(tmYearToCalendar(tm.Year));  dataFile.print(",");  dataFile.print("Hora de la grabacion:");
          dataFile.print(tm.Hour); dataFile.print(":"); dataFile.print(tm.Minute);dataFile.print(":"); dataFile.print(tm.Second);
          dataFile.print(","); dataFile.print("Temperatura:");dataFile.print(sensors.getTempCByIndex(0)); dataFile.println("C");dataFile.close();
          escritura=1; //Ahora lo pondremos a 1 para que no haga varias grabaciones en el mismo segundo.
        } 
        
 

 }
 
   if ((tm.Hour==18) && (tm.Minute==1) && (tm.Second==0))
    { 
     escritura=0; // Cuando pase un minuto pondremos escritura a 0 para que esté preparado para la siguiente grabación.
    }
    
   }

Para terminar este artículo me gustaría adjuntar un esquema de conexiones por si os sirve de ayuda, y es el siguiente:

El articulo Guardado automático en SD con Arduino. esta en Alexalt. Por José Alejandro

¿Estás interesado en hacer un control de riego automático o algo similar?

Si tu respuesta es sí, no dudes en detenerte a leer este artículo ya que solo te llevará unos minutos.

Por lo tanto, si estás interesado en llevar un control de las medidas que van recogiendo tus sensores y no quieres estar pendiente de ellos, solo necesitarás:

• Pila RTC DS1307 Comprar en Amazon (Este nos mantendrá nuestro Arduino en tiempo real)
• Sensor Comprar en Amazon ( En este caso es un sensor de temperatura DS18B20 Dallas)
• Placa Arduino. Comprar en Amazon

Solamente con esto, ya podrías tener tu control rutinario de medidas, para así luego implementar un control de riego o cualquier otra cosa.

La manera de la que se ha creado el código para el guardado automático, es mediante la memoria EEPROM.

Pero, ¿Qué es la memoria EEPROM?

Conocemos como EEPROM  a la memoria interna de Arduino, es decir, todo lo que se guarde aquí se quedará almacenado a no ser que se sobrescriba, por lo tanto, aunque nuestro Arduino se reiniciara no se borraría nada.

Hablando coloquialmente, la memoria EEPROM de Arduino UNO (Es el que se utiliza en nuestro código), sería como un armario, el cual tendría 1024 cajones, cada cajón será una posición para ocupar, depende del tipo de placa la memoria EEPROM será de mayor o menor capacidad.

En el siguiente post, podremos ver como hacer esto mismo, pero en vez de guardar en la memoria EEPROM de Arduino, lo guardaremos en un módulo SD, ya que nos puede ser de mayor utilidad.

El siguiente código muestra como se haría una grabación a las 12:00:00 y otra a las 18:00:00:

#include <EEPROM.h>
#include <OneWire.h> 
#include <DallasTemperature.h>
#include <Time.h>
#include <DS1307RTC.h>

OneWire ourWire(2); // Definimos como salida para el sensor de temperaturas Dallas DS18B20 el pin 4.
DallasTemperature sensors(&ourWire);

//Ahora empezamos a declarar las variables que las iremos viendo a lo largo del código:

int contador = 2; // Aquí empezará a guardar los datos del sensor de temperatura
int comprobacion = 1; //Esta va a ser la posición 1 de la memoria EEPROM, donde se gurdará la posición por donde va contador para así tener constancia y que no se pise las grabaciones.
bool escritura = 0; //Nos ayudará a que no hayan varias grabaciones en un mismo segundo.

 
void setup ()
  {
    /* 
     *  Iniciamos nuestro sensor de temperatura:
     */
    sensors.begin();
    sensors.requestTemperatures();
      
  }

void loop ()
   {
 
     /*
      * Ahora lo que tendremos que hacer es inicializar el reloj DS1307 para poder utilizarlo
      * posteriormente.
      */
      
  tmElements_t tm;
  if (RTC.read(tm)) {}
 
 
  /*
   * Ya podemos ir a la parte importante, y es la de hacer nuestro guardado automático.
   * En primer lugar hacemos cuatro comparaciones de modo que si se cumplen entrarán dentro de
   * nuestro if.
   * Por lo tanto, sí son las 12:00:00 y escritura es igual a 0 (Escritura será igual a 0 porque 
   * está definida al inicio del sketch). De esta manera hará lo que hay dentro del if que explicaré 
   * a continuación.
   */
 
 
    
  if ((tm.Hour==12) && (tm.Minute==0) && (tm.Second==0) && (escritura==0))
 { 
       if(contador != EEPROM.read(comprobacion)) // Si cuando alimentamos arduino contador(Posicion 2 de memoria EEPROM) es diferente al valor de comprobación(posición 1 de memoria EEPROM).
        {
          contador= EEPROM.read(comprobacion)+1; //Entonces igualará la variable contador a comprobación y sumarará 1 para que así no pise lo que se ha ido guardando anteriormente.
          EEPROM.write(contador, 1111); // Después en la posición actual de contador pondrá 1111 para nosotros saber que ahí hemos tenido un error y así tener constancia.
          contador++; //Contador sumará 1
          EEPROM.write(comprobacion, contador); // Por último en comprobación escribirá la posición que ahora hay en contador.
        }
        
     
    
           
           EEPROM.write(contador, sensors.getTempCByIndex(0)); // En la posición contador guardará el valor del sensor
           contador++;//Aumentará 1 el contador, para que la siguiente grabación sea por la posición que vendría a continuación.
           EEPROM.write(comprobacion, contador);// Guardamos en comprobación (Posición 1 de la memoria EEPROM) la posición por la que va contador,
           //  de esta manera cuando haya una pérdida de corriente, podremos averiguarlo.
           
           escritura=1;//Ahora igualaremos escritura a 1 para evitar que en el segundo que se hace el guardado automático guarde varios datos.
    
    
 
 if (contador == 1024)//Si la variable contador llega a 1024 posiciones:
   {
    contador = 1010;// Contador se igualará a 1010 para que no se pisen las últimas grabaciones.
   }
 }
   if ((tm.Hour==12) && (tm.Minute==1) && (tm.Second==0)) //Cuando pase un minutos entrarará aqui y hará lo siguiente:
    { 
     escritura=0; // Volverá a igualar escritura a 0, de tal manera que cuando lleguen las 18:00:00 que es cuando queremos que haga la siguiente grabación, puede hacerlo con normalidad.
    }

     
  if ((tm.Hour==18) && (tm.Minute==0) && (tm.Second==0) && (escritura==0)) // Aquí hará exactamente lo mismo que antes pero a las 18:00:00.
  {
      if(contador != EEPROM.read(comprobacion)) // Si cuando alimentamos arduino contador(Posicion 2 de memoria EEPROM) es diferente al valor de comprobación(posición 1 de memoria EEPROM).
        {
          contador= EEPROM.read(comprobacion)+1; //Entonces igualará la variable contador a comprobación y sumarará 1 para que así no pise lo que se ha ido guardando anteriormente.
          EEPROM.write(contador, 1111);// Después en la posición actual de contador pondrá 1111 para nosotros saber que ahí hemos tenido un error y así tener constancia.
          contador++; //Contador sumará 1
          EEPROM.write(comprobacion, contador); // Por último en comprobación escribirá la posición que ahora hay en contador.
        }
        
     
    
           
           EEPROM.write(contador, sensors.getTempCByIndex(0));
           contador++;          
           EEPROM.write(comprobacion, contador);   
           
           escritura=1;//Ahora igualaremos escritura a 1 para evitar que en el segundo que se hace el guardado automático guarde varios datos.
    
              
           EEPROM.write(contador, sensors.getTempCByIndex(0)); // En la posición contador guardará el valor del sensor
           contador++;//Aumentará 1 el contador, para que la siguiente grabación sea por la posición que vendría a continuación.
           EEPROM.write(comprobacion, contador);// Guardamos en comprobación (Posición 1 de la memoria EEPROM) la posición por la que va contador,
           //  de esta manera cuando haya una pérdida de corriente, podremos averiguarlo.
           
           escritura=1;//Ahora igualaremos escritura a 1 para evitar que en el segundo que se hace el guardado automático guarde varios datos.
    
    
 
 
    if (contador == 1024)//Si la variable contador llega a 1024 posiciones:
   {
    contador = 1010;// Contador se igualará a 1010 para que no se pisen las últimas grabaciones.
   }
 }
   if ((tm.Hour==12) && (tm.Minute==1) && (tm.Second==0)) //Cuando pase un minutos entrarará aqui y hará lo siguiente:
    { 
     escritura=0; // Volverá a igualar escritura a 0, de tal manera que cuando lleguen las 18:00:00 que es cuando queremos que haga la siguiente grabación, puede hacerlo con normalidad.
    }

   }

Para terminar este artículo me gustaría adjuntar un esquema de conexiones por si os sirve de ayuda, y es el siguiente:

El articulo Programar horario de guardado automático en arduino esta en Alexalt. Por José Alejandro

¿Cuántas veces has escuchado hablar de Arduino?

Estoy seguro de que solo con el mero hecho de navegar por Internet habrás observado cantidad de noticias, foros, posts y un gran etcétera sobre Arduino.

¿Qué es Arduino?

Arduino es una compañía de hardware y software abierto encargada del diseño de placas de circuito impreso con un microcontrolador integrado, además está formado por un entorno de desarrollo integrado, y os preguntaréis,

¿Eso qué quiere decir?

Pues esto quiere decir que consta de una aplicación informática que proporciona servicios integrales con el fin de facilitarle al desarrollador, consumidor o programador el desarrollo software de Arduino, haciendo así que su lenguaje de programación, llamado Wiring esté al alcance de todos.

Otro factor importante a destacar, es el tema de la diversidad de placas, actualmente podemos encontrar incluso más de ocho tipos diferentes que tendremos que diferenciar por las siguientes características, según lo que se pretenda hacer:

• Pines de entradas y salidas.
• Memoria EEPROM (Factor importante, ya que esta determina la memoria interna de la placa).
• Velocidad del reloj (Velocidad con la que procesa los datos).
• SRAM (Conocida comúnmente como RAM estática).
• Corriente que puede soportar la placa tanto en general, como en cada pin.

Si lo que usted pretende es hacer simplemente una instalación con un par de sensores que sólo utilicen dos salidas digitales o analógicas,  podremos escoger un tipo de placa que carezca de pines como por ejemplo ATTINY85, esta placa posee 3 pines PWM, ni que decir tiene que dispone de sus debidos pines para la conexión USB, necesarios para hacer la transferencia de datos , además lo podremos obtener de la página aliexpress por sólo 1’40€.

Para más información sobre esta placa:

http://es.aliexpress.com/store/product/Free-shipping-Digispark-ATTINY85-General-Micro-USB-Development-Board-for-Arduino-ATTINY85-usb-development-board/1201010_32426437222.html

Ahora, si en cambio lo que necesitamos es una placa que disponga de gran cantidad de pines para hacer una instalación amplia podremos adquirir la placa Arduino mega formada por  54 pines digitales que funcionan como entrada/salida y 16 entradas analógicas.

El problema de este es simplemente el precio, ya que si adquirimos la placa original su precio oscilará entre unos 60 €, pero también es verdad que tenemos la opción de comprar esta misma placa, pero de «imitación» que nos costaría alrededor de 5 €.

¿Suena mejor verdad?

Y es que este no tiene prácticamente nada que envidiarle a la placa original, y al igual que la placa ATTINY85, también podremos adquirirlo de páginas como aliexpress.

Me gustaría hacer una recomendación personal, y es la siguiente:

Si lo que buscas es una placa para hacer una instalación, tanto estándar, como amplia sin llegar a ser excesiva, recomiendo utilizar la placa Arduino UNO, formado por  14 pines digitales que funcionan como entrada/salida y 6 entradas analógicas.

El precio de este estará alrededor de unos 20€, hablando de la placa original, pero como en el caso anterior podremos adquirirlo de páginas como aliexpress, gearbest, etc.. también de «imitación» por un precio que oscila sobre los 3 €, a mi parecer, después de un año de uso sigue funcionando como el primer día.

A continuación podemos ver la placa arduino original:

De igual manera, ahora se observa al que me he referido como «imitación»:

¿Qué ventajas posee Arduino?

En ese caso me gustaría destacar las siguientes ventajas:

• Precio económico.
• Facilidad de uso.
• Ayudas y documentación en exceso, como he comentado antes, en Internet hay cantidad excesiva de información.
• Otra ventaja que se ha mencionado anteriormente es el tema de que sea de hardware y software abierto.
• Por último me gustaría destacar una gran ventaja llamada escalabilidad, con esto quiero decir que podremos ampliar nuestra instalación con facilidad.

La conclusión que podemos sacar de todo lo dicho anteriormente, es que Arduino es accesible para cualquier persona, por lo tanto, si necesitas hacer cualquier tipo de instalación, no dudes en recurrir a las placas de Arduino.

Puedes comprarlo en Amazon desde aquí

¿A qué estás esperando para tener tu placa?

El articulo Arduino al alcance de todos esta en Alexalt. Por José Alejandro

Raspberry Pi Foundation ha creado una nueva Raspberry que cuesta nada más 5 dólares, es un minipc con el cual está pensado para hacer proyectos, algo parecido a Arduino, pero esta es una opción más potente para hacer otros proyectos que requieran más potencial.

Este aparato tan pequeño cuenta con un procesador Broadcom BCM2835 que trabaja a un 1GHz(afirmando en el blog que es el 40 % más rápido), también cuenta de una memoria RAM de 512MB y de ranura para tarjetas microSD, un puerto mini-HDMI y dos puerto microUSB, uno para conectar cualquier periférico y otro para suministrarle energía. Cuenta con los mismos 40 pines del conector GPIO que son los mismos que las Rasberry Pi anteriores.

Sus medidas son de 65 x 30mm x 5mm es tan pequeña que podemos llegar hasta perderla.

En el envío de la Raspberry Pi Zero no viene incluido los adaptadores como el HDMI y los pines y así como el adaptador OTG USB, tenemos que comprarlo por separado y que en la tienda Swag Store esta por un precio de aproximadamente de 5,68 €.

Desde hoy ya está disponible la venta, incluso la revista “The MagPi” te regalan la Rasberry Pi Zero nada más por hacer la compra de dicha revista, que la cual se vende en todo Reino Unido.

Para más información visita el blog de Rasberry: https://www.raspberrypi.org/blog/raspberry-pi-zero/

Así que ya tenemos un «cacharrito» más para estar trasteando.

El articulo Raspberry Pi Zero, una Raspberry que solamente cuesta 5 dólares esta en Alexalt. Por José Alejandro