שירים להורדה מיוטיוב למחשב
kottik.xyz
תרגום מילון
брокеры бинарных опционов
קמגרה
алекс экспресс одежда

Tag Archives: Arduino

Regando la plantita

Ya se me va el año y ni cerca estuve de escribir las publicaciones mensuales que me había autoimpuesto. Cerquísima estuve del otro objetivo, conquistar a Nati, pero no puedo adelantar nada, porque lo estoy cocinando a fuego lento y ya vieron el puterío que arman los medios: Ley de medios ya!!

Me quedan 3 escritos a medio terminar, así que voy a tratar de tenerlos antes que empiece el 2015. Uno sobre Arduino, otro sobre Software Libre y finalmente uno sobre distintas tecnologías para escribir. Acá va la primera entrega, regando la plantita.

Desde hace mas o menos 25 años una de mis abuelas me regala calzoncillos para navidad, lo que no era un inconveniente, hasta que en los últimos 5 le sumó una planta. La poca vida vegetal que habita mi depto tiene que ver con verduras fuera de estado y con las plantas que me va regalando la querida octogenaria. El drama es que irremediablemente se me mueren (las plantas che!). Durante el año las revivo mil veces y van zafando, pero luego en enero, no hay reanimación que dé resultado.

muerta_vivaAl frente, la viva, cuidando sus espaldas, fiambre vegetal!

De los miles de misterios que han cautivado a la humanidad, el que más intriga me produce es ver cómo carajo crece un arbusto en la pared de una casa abandonada o el capricho de una planta vigorosa asomando de las ínfimas grietas de una cochera. Einstein ya nos anticipaba que dios juega a los dados, pero nunca imaginé que así de gracioso iba a ser con esta cuestión. Con mi máxima dedicación por mantenerlas vivas, amasacro mono y di-cotiledóneas a mansalva y resulta que las que andan por ahí sin el más mínimo cuidado crecen y de repente se convierten en frondosos árboles, lrpmqlrmp!!  no es justo!

Esta injusticia de la vida, en la que vengo sumando numerosos decesos, además de convertirme en agnóstico-ateo, me motivó a buscar una solución que no requiera de intervención humana (ni divina).

20141217_092638La última plantita con vida

Incansablemente me ofrecieron cuidarla, que la riegan, que la llevan, que no se que más. Que me convenía usar esto y lo otro, que por capilaridad, que con unas esponjas mojadas, y bla bla bla. Toda alternativa donde no había que programar ni jugar con Arduino me servía. Entonces, mi proyecto fue hacer un regador automático!!

Resumiendo, ¿en qué consiste?
Agarrás un sensor de humedad de suelo y lo ensartás en la tierra de la maseta, por otro lado usás una bomba diminuta de agua sumergida en un balde, todo eso lo combinás con algo más de electrónica y un pequeño software encargado de encender la bomba una vez que el suelo esté muy seco o apagarla en caso contrario. Una pavada, vió!

Componentes

  • Sensor de humedad de suelo: FC28 y placa YL-38
  • Placa Arduino UNO
  • Bomba de agua 12V
  • Un electrónico amigo
  • Opcional: Shield RTC + datalogger

Receta

Conectás el sensor de humedad de suelo en las entradas analógicas de tu Arduino UNO, regás la planta y la dejás unos días secándose, hasta cuando vos consideres que ya necesita agua. Ahí te fijás el valor que arroja el sensor. En este caso, el sensor da valores entre 0 y 1024, de mojado a  seco (esto en realidad se infiere ya que 0 significa que no hay resistencia eléctrica, y esto sucede porque el agua es conductora, y 1024 cuando la resistencia eléctrica es alta, o sea, crocante de seco!).

Dejé almacenando los valores en una memoria SD porque quería observar la dinámica del proceso, esto se hace con un shield datalogger, que además de tener una ranura para tarjeta SD cuenta con un reloj que nos permite acceder a la hora, finalmente encontré que un valor umbral cercano a 400 era el correcto para empezar a regar. En la siguiente gráfica se observan los valores de resitsencia en el tiempo:

humedadLo que sigue es poner un pin digital del Arduino en alto cuando el valor de resistencia alcance ese umbral, una verdadera pavada en el mundo de Arduino.

Lo que requiere mayor complejidad es realizar una interfaz para que el arduino pueda activar la bomba con ese valor alto. La interfaz consiste en un relé, un transistor y una fuente de 12V. Con el valor alto (5 volts) del pin previamente mencionado, lo que haremos será activar el relé de modo tal que al switchear, permita alimentar a la bomba y por ende se encienda. Cuando el pin esté en estado bajo (0 volts) se abrirá el circuito del relé y la bomba quedará desconectada.

Esta parte que explico no fue de mi autoría, sino que acá es donde entró en juego la inestimable ayuda del electrónico que les mencionaba arriba. También podrías adquirir un shield y sale con fritas, pero es gastar plata, así que hacete amigo de un electrónico!

Acá se observa la bomba conectada al relé, con un transistor y una resistencia, todo acoplado en una mini protoboard que es una paquetería. rele_bomaAcá el Arduino UNO r3, con el shield de datalogger, y adherida otra miniprotoboard donde conecto los 5V y el GND, para dejarlos más accesibles al resto de los componentes.arduino_dataloggerFinalmente, el sensor de humedad mas todo lo demás, formando un hermoso combo navideño.comboAhora, un video que muestra su funcionamiento.

El código correspondiente no lo voy a compartir porque no quiero que me lo copien y se hagan multimillonarios regando plantas automáticamente. Acá va el código para que todo funcione:

#include <Wire.h>           // Libs
#include "RTClib.h"         
#include <SD.h>

RTC_DS1307 RTC;             // instancias
File fhumedad;

int umbral = 400;           // valor umbral

void setup(){
  pinMode(10, OUTPUT);      // Para la SD
  pinMode(4, OUTPUT);       // Pin Digi. 4 de Salida: activa el rele
  Serial.begin(9600);
  Wire.begin();             
  RTC.begin();              
    
  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
  }
  if (!SD.begin()) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");
  delay(2000);
}
 
void loop(){
    DateTime now = RTC.now();
    int yyyy = now.year();
    int mm = now.month();
    int dd = now.day();
    int hh = now.hour();
    int mi = now.minute();
    int se = now.second();
    
    int resistencia = analogRead(A0);        // Pin analog. 0: sensor de hum.
    
    fhumedad = SD.open("humedad.txt", FILE_WRITE);
    if (fhumedad){
      imprimir(yyyy,mm,dd,hh,mi,se,resistencia);
      fhumedad.print(yyyy);
      fhumedad.print('-');
      fhumedad.print(mm);
      fhumedad.print('-');
      fhumedad.print(dd);
      fhumedad.print(' ');
      fhumedad.print(hh);
      fhumedad.print(':');
      fhumedad.print(mi);
      fhumedad.print(':');
      fhumedad.print(se);
      fhumedad.print(' ');
      fhumedad.print(resistencia);
      fhumedad.print(' ');

      if (resistencia >= umbral){
        digitalWrite(4, HIGH);          // supero umbral-> pin 4 en alto
        fhumedad.print("1");
        Serial.println(" 1");
        delay(300);                     // espero 300 miliseg y...
        digitalWrite(4, LOW);           // pin 4 en bajo
        fhumedad.print("0");
        Serial.println(" 0");
        delay(700)
      }
      fhumedad.println();
      fhumedad.close();
    }else {
       Serial.println("error opening file");
    }
   delay(500);
}

void imprimir(int y,int m,int d,int hh,int mi,int se,int val){
  // imprime en pantalla timestamp y valor
  Serial.print(y);
  Serial.print('-');
  Serial.print(m);
  Serial.print('-');
  Serial.print(d);
  Serial.print(' ');
  Serial.print(hh);
  Serial.print(':');
  Serial.print(mi);
  Serial.print(':');
  Serial.print(se);
  Serial.print(' ');
  Serial.print(val);
}

Tal como se preguntará el lector despierto, faltan los equemáticos que indiquen cómo conectar cada cosa, sin embargo, se me complicó con el fritzing, así que lean los comentarios del código que ahí se explica.

Ahora sí, lo que realmente todos estábamos esperando:

Internet de las cosas

Así se refieren ahora al envío y recepción de información a Internet por aparatos. Es un concepto algo viejo pero que en los últimos años vino tomando fuerza. Asusta un poco que los aparatos tomen decisiones en forma autónoma, y nos termine pasando lo de Matrix, tranqui, mientras podamos programarlos todavía tenemos el poder.

A causa del tsunami de 2011, que devastó gran parte de Japón, incluyendo la planta nuclear de Fukushima, pasó a tener vital importancia la medición de radioactividad por parte de instrumentos Geiger que subían automáticamente los valores registrados a la web, específicamente a Pachube. Según leo por ahí, a los pocos días, miles de personas conectaron dispositivos de este tipo para que suban los valores de radiación detectados.

Pachube ahora se llama Xively, y provee una plataforma (PaaS, del inglés Platform as a service) para subir datos en tiempo real, además de una API disponible para varios lenguajes -entre ellos python- como así también a través de la amada consola usando curl (command line tool for transferring data with URL syntax).

Si bien la API está en github con licencia BSD, no estoy seguro que tan libre es la plataforma. Más allá de esto, uno puede elegir compartir sus datos, y según leo en sus FAQs la info ahora también será de ellos, cosa que no me molesta, “compartí con tus hermanos me decía mi vieja”:

I’m concerned about my data, who owns it?

We are too, that’s why Xively’s Terms of Service put you in control! You own your data. You choose whether to share all, part, or none of it. You choose who you want to share it with. You choose the terms that you want to share it under. You can view our terms of service here: https://secure.logmein.com/policies/privacy.aspx
 

Entonces, supongamos que hasta tanto no armemos nuestro propio servidor para atender esta info usamos xively. Supongamos que tenemos un arduino midiendo alguna variable. Supongamos que Sabella no nos considera argentinos. Supongamos que aún no mandamos a Internet directamente desde arduino porque no lo probamos y también te pido que supongas que usamos un router liberado con OpenWRT para agarrar estas medidas que nos escupe arduino. Entonces, conectamos el router y la placa arduino mediante USB y ahora, cazamos esto haciendo uso de pyserial, y lo mostramos en pantalla, para ver qué llega:

#!/usr/bin/env python
import sys, serial
import time
import datetime
 
port = '/dev/ttyACM0'
ser = serial.Serial(port, 9600)
while True:
    try:
        line = ser.readline()
        print datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S'), line
        print line
    except KeyboardInterrupt:
        print 'exiting'
        break

Fijate que ahí estoy usando un timestamp generado desde python que NO es lo recomendado, pero como aún no tengo un RTC en arduino que me tire la hora, lo uso para probar. Ojo, capaz no te anda el diálogo entre los dos aparatos, te está faltanto instalar en OWRT:

opkg install python pyserial kmod-usb-acm

Ahora voy a dejar para el lector entusiasta y aplicado que con esos datos leídos por el puerto genere un JSON llamado update_feed_historical.json, que por ejemplo contenga datos históricos de un mismo sensor. Se tendría que verse algo así:

{
  "version":"1.0.0",
   "datastreams" : [ {
        "id" : "sensor1",
        "datapoints":[
        {"at":"2014-05-01T19:35:43Z","value":"42"},
        {"at":"2013-04-01T19:40:43Z","value":"84"},
        {"at":"2013-04-01T19:45:43Z","value":"41"},
        {"at":"2013-04-01T19:50:43Z","value":"83"}
        ],
        "current_value" : "40"
    }
  ]
}

Ahora, nuestro router podría ejecutar un script desde el cron, ponele una vez por día, y me sube todo lo registrado a xively. Entonces, el contenido del script bash tendría algo así:

curl --request PUT \
     --data-binary @update_feed_historical.json \
     --header "X-ApiKey: TU_KEY" https://api.xively.com/v2/feeds/TU_FEED

Bien, muy domingo es hoy y me estoy recuperando de una migraña terrible, razón por la cual escribí esto a las apuradas y con poca claridad. Pero resumamos para que lo entienda alguien más que yo.

  • Leemos con Arduino el valor de sus sensores y lo escupo por el puerto USB (pendiente de publicar acá, ya se viene, en breve, NO seas ansiosa!)
  • Conecto un router SOHO al que previamente le reemplazamos el firmware con una distro de GNU/Linux llamada OpenWRT.
  • Programamos un script python dentro del router, que agarre cada tanto lo que reciba por USB y lo vaya agregando a un archivo JSON con la estructura que necesita xively (ver en el sitio oficial)
  • Cada otro tanto, mas espaciado que el tanto previo, ejecutamos un script bash que usa curl para subir el bloque de datos a xively

Por último, supongamos que me creés que todo esto anda 20 puntos!

Y ahora sí, lo que todos estábamos esperando:

Te encontrare donde pueda,
me llevarás hasta el cielo,
perdurarás en el aire
mientras te vuelvo un sueño

Social Widgets powered by AB-WebLog.com.

Social Widgets powered by AB-WebLog.com.

Social Widgets powered by AB-WebLog.com.