Domotiza tu casa – Día 7. Programador de riego Parte I

Bueno, bueno, bueno, ya estamos aquí otro día más.

Hacia tiempo que queria publicar el programador de riego, y alguno que otro direis ¿lo podrías haber publicado antes de vacaciones, no?

Pues no, porque imaginaros que por lo que sea al volver de las vacaciones os encontrais las plantas muertas, o peor aún, habeis utilizado el programador para regar un cuenco y dar agua al gato. Es demasiada responsabilidad, y cualquier fallo podría provocar mucho reencor hacia mi persona. Así que una vez pasadas las vacaciones empezamos con el tutorial del programador de riego.

Este tutorial constará de varias partes.

La primera, la de hoy, en que haremos el código básico para el funcionamiento del riego.

La segunda, donde montaremos el riego y probaremos el funcionamiento de lo que hemos hecho.

Y una tercera con mejoras que tengo previstas, mas las que podeis vosotros a partir de los comentarios sugerir.

Empecemos por lo primero. El código de hoy es sencillo, sin mucha complicación, breve, e interesante.

Constará de las siguientes partes importantes:

– En el setup, osease, lo que se ejecuta una única vez al iniciar arduino, vamos a sincronizar el reloj interno de arduino con la hora, y definiremos cada cuanto se ha de recalibrar el reloj.

– En el loop, o rutina que ejecutará infinitamente, comprobaremos si es hora de regar o no, y le pondremos un retardo de 10 segundos. Esta comprobación la realizará llamando a una función que nos dirá si es hora de regar o no.

– La función de riego que compara las horas de riego que tiene definidas con la hora actual y nos devuelve «true» o «verdadero» si es hora de regar, y «false» o «falso» si no es momento de regar.

– La función que obtiene la hora la ponemos también en una función aparte

Siempre tenemos que programar de la manera más limpia posible, separando en funciones, clases, etc… de esta manera nos quedará un codigo fácil de entender y de mantener.

 

El código sería el siguiente:

//Inclusión de librerías

#include <Time.h>
#include <SPI.h>
#include <Ethernet.h>
#include <Udp.h>

// MAC e IP de Arduino
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = {
192,168,1,40 };

unsigned int localPort = 8888;      // Puerto para escuchar los paquetes UDP

byte timeServer[] = {
192, 43, 244, 18}; // time.nist.gov el servidor NTP

const int NTP_PACKET_SIZE= 48; // Cuando el servidor nos devuelve la hora en el paquete UDP, La hora viene en los primeros 48 bytes del paquete

byte packetBuffer[ NTP_PACKET_SIZE]; //buffer para almacenar los paquetes entrantes y salientes

void setup()
{
// Inicializamos el Ethernet, el UDP y el Serial
Ethernet.begin(mac,ip);
Udp.begin(localPort);
Serial.begin(9600);

//función importante del dia. «setSyncProvider» selecciona cual es la función que utilizaremos para sincronizar la hora, y «setSyncInterval» define, en segundos, cada cuanto queremos sincronizar la hora.
setSyncProvider(getNtpTime);
//Hacemos que cada hora se sincronice la hora.
setSyncInterval(3600);

//almaceno la hora en la variable timestamp llamando a la función getNtpTime()
unsigned long timestamp = getNtpTime();
Serial.print(«Hora establecida Time:»);
Serial.println(timestamp);
//segunda función importante del día. setTime, asigna al reloj interno de arduino la hora que le indiquemos en la variable.
setTime(timestamp);

}

void loop()
{
//Muestro por el puerto serie la hora
Serial.print(«Son las: «);
Serial.println(String(hour()) + «:» + String(minute()));
//comprobamos si es la hora del riego
if(esHoraRiego()){
//Si es la hora del riego, mostramos un mensaje indicándolo por el puerto serie
Serial.println(«Es hora riego!!»);
} else {
//Si no es la hora del riego, mostramos un mensaje indicándolo por el puerto serie también
Serial.println(«No es hora riego»);
}
delay(10000);

}

boolean esHoraRiego(){
//Defino horas de riego Inicio a las 19:39 y termina a las 19:40 (poned las horas a las que hagais las pruebas)
byte horaInicio = 19;
byte minutoInicio = 39;
byte horaFin = 19;
byte minutoFin = 40;

//Para hacer las comparaciones de cuando empezar y cuando terminar, lo paso todo a minutos. Por eso la hora de inicio serian las (19 x 60) + 39 = 1.179 y la de fin 1.180. Esto lo hago porque el código de intentar comparar horas con horas es algo más complejo, y yo amo la simplicidad.

int momentoInicio = (horaInicio * 60) + minutoInicio;
int momentoFin = (horaFin * 60) + minutoFin;
int momentoAhora = (hour() * 60) + minute();

//Esto es que si hemos pasado o estamos en el momento de inicio , pero antes del momento del fin…
if((momentoInicio<=momentoAhora) && (momentoAhora<momentoFin)){
//devolver «Cierto» en esta función «esHoraRiego»
return true;
} else {
//devolver «Falso» en esta función «esHoraRiego»
return false;
}
}

unsigned long getNtpTime(){
sendNTPpacket(timeServer); // enviar paquete NTP al servidor de la hora

// esperar para ver si hay respuesta
delay(1000);
if ( Udp.available() ) {
Udp.readPacket(packetBuffer,NTP_PACKET_SIZE);  // leer el paquete

//Extraer la hora del paquete (Ya explicado en el tutorial del servidor NTP

unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);

// la hora obtenida son los segundos desde 1 de Enero de 1900
unsigned long secsSince1900 = highWord << 16 | lowWord;

//Convertir la hora recibida al formato en que trabajan las funciones (hora Unix, 1 de enero de 1970), En segundos, son 2208988800:
const unsigned long seventyYears = 2208988800UL;
//restar 70 años
unsigned long epoch = secsSince1900 – seventyYears;
// retornar Unix time: sumando dos horas por la diferencia horaria

return epoch+7200;

}
}

//Función para enviar el paquete NTP
unsigned long sendNTPpacket(byte *address)
{

memset(packetBuffer, 0, NTP_PACKET_SIZE);

packetBuffer[0] = 0b11100011;
packetBuffer[1] = 0;
packetBuffer[2] = 6;
packetBuffer[3] = 0xEC;

packetBuffer[12]  = 49;
packetBuffer[13]  = 0x4E;
packetBuffer[14]  = 49;
packetBuffer[15]  = 52;

Udp.sendPacket( packetBuffer,NTP_PACKET_SIZE,  address, 123);
}

 

Si teneis cualquier problema, adjunto os dejo el archivo.

Domotiza tu casa – Dia 7 – Programador de riego

Si os ha gustado, dadle al Me gusta del facebook o el linkedI!
Espero vuestros comentarios

Domotiza tu casa – Día 6. Leer Temperatura con Arduino

En el día de hoy vamos a trabajar con unos sensores sencillos de temperatura, montaremos un sencillo circuito y haremos que nuestro arduino lea la temperatura y la muestre en su aplicación.

En primer conozcamos el material:

– El sensor(<1€).

El sensor que utilizaré es el LM35 (ojo, no confundir con el LM335) del cual podemos tener su datasheet u hoja de especificaciones para los hispanohablantes en http://www.national.com/ds/LM/LM35.pdf.

OJO MUY IMPORTANTE. ¿Cómo saber qué pata es el positivo, cual el negativo y cual la señal? ¿Qué pensabais ir probando hasta que funcionara? Pues no, solo a alguien con el intelecto de un mosquito se le ocurría hacerlo así, y os explico porqué.

Si cambiais el positivo por el negativo y viceversa, en unos segundos se sobrecalienta el sensor, hasta el punto de poder quemarnos, y deja de funcionar.

De esta manera, aquí el menda del intelecto de mosquito, se cargó tres sensores. El primero por leer la especificación del LM335 y no del LM35, el segundo por ponerlo del revés, y el tercero por creer que el segundo estaba defectuoso y volverlo a probar en el mismo circuito….

Ahora que he captado vuestra atención para las próximas lineas, os enseñaré a identificar las patas del sensor correctamente. Cogiendo el sensor como muestro en la imagen

Cómo usar sensor LM35

Con la parte curva hacia abajo y las patas mirando hacia vosotros, el pin de la izquierda es el positivo, el de la derecha el negativo o tierra, y el del medio es la señal.

– Resistencia(<1€)

Para el circuito del sensor de temperatura necesitaremos una resistencia de 100K (o lo que es lo mismo una que tenga el código de colores marron, negro, amarillo, dorado)

– Protoboard o tabla de prototipos(<6€)

No es más que una tabla donde montar el circuito de manera provisional para hacer nuestras pruebas y experimentos.

Protoboard

– Accesorios(<3€)

Necesitaremos cables y alicates de corte de momento.

 

El circuito que montaremos tendrá el siguiente esquema:

Esquema circuito LM35

Y quedará en nuestra protoboard de la siguiente manera:

Circuito LM35 para Arduino

Al lado izquierdo queda el sensor LM35, el cual es alimentado por el cable rojo, que obtendrá la energía desde la salida de 5V de nuestra placa de Arduino, todo y que la alimentación también podría ser externa.

El cable de debajo del rojo es el cable de señal. Esta señal será analógica, es decir, a mayor temperatura mayor voltaje. Esta señal, ha de ser conectada a la entrada A0 de Arduino.

Finalmente, el último cable, el que corresponde a la pata de abajo del sensor en esta imagen, es el negativo o tierra, el cual irá conectado a la toma de tierra de la placa identificada con GND(GrouND o tierra en ingles).

Importante, conectar la resistencia entre la señal y la tierra, de esta manera podremos obtener valores de temperatura negativos (si teneis curiosidad, para más info ver el datasheet del sensor que he puesto en el link del principio de la entrada).

Como conectar circuito sensor LM35 a Arduino

Todo y que la imagen puede engañar el ángulo, vuelvo a destacar, que el cable rojo va conectado al 5V, el negro al GND, y el cable de señal al A0.

Una vez que está todo conectado como se indica en las imágenes anteriores, es momento de empezar a programar. Seguramente con todo lo que habreis hecho en las anteriores entradas del tutorial, lo que programaremos hoy os parecerá bien sencillo.

 

Para empezar, al principio de todo, en las definiciones, justo debajo de los # include y #define de la anterior sesión insertamos lo siguiente:

//Declaro las variables para leer la temperatura
int sensorTemperatura = 0; //Este será el PIN al que conectaré el sensor de temperatura LM35.
int temperatura = 0; //inicializamos el valor de la variable temperatura a cero.

Dentro del setup, incluyo lo siguiente:

//declaro que el pin de la entrada analogica será de lectura
pinMode(sensorTemperatura, INPUT);

Esta temperatura obtenida la quiero mostrar en el apartado de «Balcón», (por escoger alguno… si vosotros lo quereis colocar en otro sitio sois totalmente libres de hacerlo 🙂  ).

Por lo tanto, dentro de la función «body», justo después del

else if (modulo == «Balcon»){

colocamos lo siguiente:

float temperatura = getTemperatura(sensorTemperatura);//declaro la variable de tipo «float» (para que pueda tener decimales) y le asigno el valor que me devuelva la llamada a la función de obtener temperatura. Llamo a la función para obtener temperatura y le envio como parámetro el pin al que está conectado el sensor.

 

Ahora una vez que tengo el valor de la temperatura en la variable «temperatura» lo muestro en pantalla dentro de la web de la siguiente manera:

client.println(«<ul><li>Temperatura balc&oacute;n: «);
client.println(temperatura);

client.println(» oC</li><li>Luminosidad: XX</li><li>Humedad:XX</li><li>PH:XX</li><li>Riego programado de: XX a XX, y de YY a YY</li></ul>»);
}

Por lo tanto para no liaros, esto es lo que subtituiria el contenido del apartado de balcon del body:

float temperatura = getTemperatura(sensorTemperatura);
client.println(«<ul><li>Temperatura balc&oacute;n: «);
client.println(temperatura);
client.println(» oC</li><li>Luminosidad: XX</li><li>Humedad:XX</li><li>PH:XX</li><li>Riego programado de: XX a XX, y de YY a YY</li></ul>»);

Una vez que el cuerpo de la web hace la llamada para obtener la temperatura, vamos a realizar que lea el voltaje que nos llega en A0, y nos lo transforme a un número que será nuestra temperatura.

Al final del todo del Sketch (al final del todo del programa =) ), creamos la siguiente función:

float getTemperatura(int sensor){
int valorLectura = analogRead(sensor); //declaramos la variable valorLectura y le asignamos como valor la lectura del sensor que le hayamos dicho que lea.
float temperatura = (5.0 * valorLectura * 100.0)/1023.0; //conversión del voltaje (que va de 0V a 5V) a temperatura.
return temperatura;//retornar la temperatura
}

El factor de conversión sale de que a la entrada analógica le va a entrar un valor de tensión de entre 0 y 5V, lo cual arduino eso nos lo convierte en una escala del 0 al 1023.

¡¡Y con esto ya nuestra página web en la sección de «Balcón» ya nos daría la temperatura que esté captando nuestro sensor!!

Mejora posible:

Muy posiblemente, una de las primeras cosas que podeis el dedo en el sensor para que suba la temperatura y comprobar como sube la temperatura. Luego quitareis el dedo y volverá a a la temperatura ambiente. Luego probareis a soplarle, y también probareis a irle dando a actualizar a la web y vais viendo como a temperatura ambiente, va variando ligeramente la temperatura. Y os preguntareis, ¿Y esto porque es variable? Sencillo. La corriente no es completamente estable, el nivel de precisión del sensor es limitado, y la escala en la que lo mide arduino tampoco es para trabajar con elementos de precisión. Me explico.

Si el sensor abarca desde los -55ºC hasta los 150ºC, esto quiere decir que tenemos un rango de 205 grados por medir. Por lo tanto si esa escala que nos devuelve arduino va de 0 a 1023, quiere decir que 1023/205 = 4,99…  Es decir que de grado a grado solo nos puede dar esos aproximadamente 5 valores. Pero por ejemplo, si queremos captar decimales, de un grado a otro ¡tenemos 10 decimales! Por lo que por ejemplo si el valor 870 de la escala de arduino, corresponde a 25,5ºC, y el valor 871 corresponde a 25,7ºC,  si tenemos 25,6ºC la mas mínima fluctuación nos hará variar dos decimas, cuando sin embargo, la fluctuación es menor.

No puedo mejorar la precisión de arduino ni modificar las características de este sensor. Pero lo que sí que puedo hacer es realizar diversas mediciones y calcular su media. De esta manera, obtendré un valor más estable y más fiable que si solo tomo una lectura. Así que a continuación os pongo otro código para la función de obtener temperatura:

float getTemperaturaPro(int sensor){
int i = 0;
float temperaturas = 0;
float nTemperaturas = 5;

while(i< nTemperaturas){
temperaturas += (5.0 * analogRead(sensor) * 100.0)/1024.0;
i++;
delay(20);
}
return temperaturas/nTemperaturas;
}

Le podeis poner a nTemperaturas, que es el numero de lecturas a tomar, el valor que querais. Cuanto más alto sea nTemperaturas, mayor precisión, pero más se tardará en ejecutarse.

A continuación, si os habeis perdido en alguno de los capítulos anteriores, o teneis algún problema y quereis comparar con el programa del tutorial, os dejo un enlace para descargar el archivo:

houseboxmain-dia6

Espero que este tutorial os haya gustado y espero vuestros comentarios.

 

¡Hasta pronto!

Domotiza tu casa – Día 5. El tiempo, protocolo NTP

Ahora que ya hemos hecho una estructura sencilla para nuestra web (podeis irla decorando con vuestros colores etc mientras os preparo algo más bonito), vamos pronto a ir trabajando con los datos de los sensores.

Pero antes de empezar a recibir datos de los sensores, necesitaremos dos cosas, el tiempo y almacenamiento (el próximo tutorial).

Dado que cada vez que se ejecuta el código que tenemos en arduino se reinician todas las variables, necesitamos conocer el tiempo a través de un medio externo.

Por suerte, tenemos el protocolo NTP (Network Time Protocol), uno de los protocolos más antiguos de internet (estaba incluso antes del 1985), que se creó para sincronizar la hora de los sistemas informáticos.

Este protocolo nos dará una precisión de milisegundos. Esto es mucho más de lo que necesitamos para controlar el riego o programar tareas 🙂 Si quereis más información acerca de este protocolo, lo podeis encontrar aquí :http://es.wikipedia.org/wiki/Network_Time_Protocol

A lo que íbamos. Si queremos programar un riego, saber a qué hora ha saltado una alarma, y mil cosas más en las que tenemos que comprobar la hora, necesitamos esta función.

Esta función nos devolverá un número, este número a simple vista no nos permite saber qué hora es, ya que ese número son los segundos que han pasado desde el 1 de enero de 1900.

Por lo tanto utilizaremos la librería de tiempo Time, la cual debereis importar en Sketch>Import Library>Time

Libreria Time

Esta libreria consta de las funciones necesarias para manejar este número que a simple vista no sabríamos entender.

La idea entonces es la siguiente:

– Obtener la hora del servidor NTP

– Traducir la hora obtenida al formato humano

 

Empecemos a programar!!

Os pongo el código y lo voy comentando detalladamente:

//Declaramos las variables e incluimos librerias

 

#include <Time.h>

#include <SD.h>

#include <SPI.h>

#include <Udp.h>

#include <Ethernet.h>
#define BUFSIZ 100;

/************ ETHERNET CONFIG ************/
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //definimos la MAC
byte ip[] = { 192, 168, 1, 177 };//definimos la IP
String ipString = «192.168.1.177»; //IP en formato String (para pruebas)
Server server = Server(80);// definimos el puerto para las peticiones web
unsigned int localPort = 8888;
byte timeServer[] = {
192, 43, 244, 18}; // IP de time.nist.gov es el servidor NTP utilizado
const int NTP_PACKET_SIZE= 48; // El paquete de tiempo NTP  que recibimos está en los primeros 48 bytes del paquete como podreis ver en la wikipedia

byte packetBuffer[ NTP_PACKET_SIZE]; //buffer para paquetes entrantes y salientes

void setup() {
/* Inicializando Serial para debug */
Serial.begin(9600);
/* Inicialiciando ethernet y server */
Ethernet.begin(mac, ip);
server.begin();
Udp.begin(localPort);

}

void loop()
{

//Aquí va el código del anterior tutorial, el cual me saltaré para centrarnos en lo que nos interesa hoy
String clientline= «»;

…..

header(client, modulo);
body(client, modulo);
pie(client);
client.stop();
delay(1000);
}
}
}
}
void header(Client client, String title){
… el código de la cabecera…
}
String modulos(Client client){
…el código del menú lateral…
}
void body(Client client, String modulo){
… el código del cuerpo de la página…
}

void pie(Client client){
String hora = «»; //definimos la variable de la hora
hora = timestamp(); //llamamos a la función que nos devolverá la hora y asignamos el valor a la anterior variable
client.println(«la hora es: –>» + hora + «<–«); //Mostramos la hora en la web
client.print(«</body></html>»);//cerramos la estructura HTML
}

//Esta es la función para obtener el tiempo y entregar la hora

String timestamp(){
String timestamp = «»;
sendNTPpacket(timeServer); // enviamos un paquete NTP al servidor de tiempo (ver la función más abajo)
delay(500);  //esperamos una respuesta…
if ( Udp.available() ) {  //si recibimos paquete…
Udp.readPacket(packetBuffer,NTP_PACKET_SIZE);  // leemos el paquete del buffer

//El número que nos interesa empieza en el byte 40 del paquete recibido y ocupa 4 bytes, que son dos words. Vamos a extraerlos:
// or two words, long. First, esxtract the two words:

unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
// combinamos estos dos enteros en un entero largo (Long Integer), que será el tiempo que nos ha devuelto el servidor NTP
unsigned long secsSince1900 = highWord << 16 | lowWord;
//Ahora vamos a convertir el tiempo que nos ha dado el servidor NTP, en tiempo de UNIX, que empieza el 1 de enero de 1970. 70 años de diferencia, que son 2208988800 (veis como era un poco dificil de saber a ojo y que habia que convertir el valor… 😉   )

const unsigned long seventyYears = 2208988800UL;
//restamos 70 años
unsigned long epoch = secsSince1900 – seventyYears;

//Y aquí en la variable «timestamp» creamos una cadena de fecha en formato «dia/mes/año hora:minuto». Tenemos el tiempo en la variable epoch, y de ahí con las funciones de la librería Time(day, month, year, hour, minute, second) obtenemos los datos que nos van interesando

timestamp = String(day(epoch)) + «/» + String(month(epoch)) + «/» + String(year(epoch)) + » » + String(hour(epoch)+2) + «:» + String(minute(epoch)) + «:» + String(second(epoch));
}
return (timestamp);
}

// enviamos una petición NTP al servidor del tiempo en la dirección que nos llega como parámetro
unsigned long sendNTPpacket(byte *address)
{
// ponemos todos los bytes del buffer a 0
memset(packetBuffer, 0, NTP_PACKET_SIZE);
// Inicializamos los valores necesarios para una petición NTP

packetBuffer[0] = 0b11100011;
packetBuffer[1] = 0;
packetBuffer[2] = 6;
packetBuffer[3] = 0xEC;

packetBuffer[12]  = 49;
packetBuffer[13]  = 0x4E;
packetBuffer[14]  = 49;
packetBuffer[15]  = 52;

//todos los campos del paquete NTP tienen valor. Ahora ya lo podemos enviar para solicitar el tiempo al servidor indicado y al puerto 123
Udp.sendPacket( packetBuffer,NTP_PACKET_SIZE,  address, 123); //NTP requests are to port 123
}

 

Espero que os haya sido de interés, de momento vamos preparandonos las funciones que iremos necesitando. En el próximo tutorial veremos como ir almacenando datos en una tarjeta microSD, y nos encontraremos con nuevos problemas…. 🙂

Hasta pronto!

Recortes en la Seguridad Social

En multitud de noticias, se habla de los recortes que se están haciendo en los presupuestos del estado. Se está recortando muchos servicios, como la educación, infraestructuras, y sobretodo el que más a mí me preocupa, en la sanidad.

Esto no quiere decir que no me importe que se recorte en otros ámbitos, al contrario, me indigna también. Pero en la sanidad…. estamos jugando con la vida de personas. Cerrando centros médicos, despidiendo gente, saturando y exprimiendo a los que quedan trabajando.

En este mes he tenido dos casos cercanos en los que he podido vivir los recortes casi en primera persona, y la verdad, es que me da escalofríos sólo con pensarlo…

En caso que contaré hoy, un familiar cercano, persona mayor, de 91 años, tiene la mala suerte de caer por la noche en casa y fracturarse el femur por tres sitios. Esta persona se traslada al centro de atención médico más cercano (al de Sant Celoni, de la provincia de Barcelona). En este centro médico, muy correctamente se le atiende pero se le indica que allí no pueden atender este tipo de incidencias y proponen trasladarla al hospital de Can Ruti (Badalona). Aquí empieza la odisea.

El médico del centro médico, llama a solicitar una ambulancia que pueda transportar a esta persona, ya que debido al estado en que se encuentra allí no puede ser atendida. ¿Respuesta del servicio de ambulancias? «No, estamos en huelga». Ale, así y sin servicios mínimos. El médico continua insistiendo, una y otra vez, solicitando una ambulancia. Hasta que al final el servicio de ambulancia deja de cogerle el teléfono. ¡Increible! ¿Qué pasará con la gente que llame con alguna urgencia vital?

Al final no nos quedó más remedio que contratar una ambulancia pagando (para eso sí que hay ambulancias). Por lo que aparte de lo que pagamos con nuestros impuestos, nos cobran por lo que utilicemos. ¿Deberíamos entonces de pagar la seguridad social porque si ?

 

 

 

Os deseo que paseis unas buenas vacaciones ahora que muchos las empezarán, pero os deseo más salud por la cuenta que nos trae. 🙂

 

Montañismo por y para principiantes

Con la entrada del buen tiempo, los montañistas aparecen como setas por el bosque. Un deporte muy sano que se acaba transformando en un estilo de vida, quizás, en una forma de ser.

Aparte de descubrir mundo, reorganizas tus valores.

Cuando preparas tu mochila para una excursión de varios días, escoges lo que realmente necesitas para vivir, y te das cuenta de qué es lo importante: Comer, dormir, y tener gente con quien compartir tu camino. Estos son valores últimamente un poco dejados de lado, y que hay que aprender a valorarlos. No me gustan los objetivos materiales (una tele 10 pulgadas más grande, un coche 50 caballos más potente), ya que estos te aportan una satisfacción inmediata, sí, pero poco duradera.

Dejando la parte filosófica aparte para no desviarme del tema y volviendo  al tema de la excursión, espero que este post sirva para todo aquel o aquella que se quiera iniciar en el montañismo.

Vallferrera

¿Cómo preparar la excursión?

Lo primero de todo, planificar la excursión. A dónde ir, cómo llegar, la ruta, refugios cercanos, ver la previsión del tiempo….

Para planificar la ruta os recomiendo la web de Wikiloc (http://www.wikiloc.com). Hay multitud de recorridos detallados que además, si dispones de GPS te los puedes descargar. Por lo que este recorrido o track, junto a tu GPS con un mapa topográfico, pueden ser tus mejores aliados para atreverte a aventurarte en lugares que aún no conozcas, con la seguridad de que no te vayas a perder(Nota: procura llevar pilas de respuesto, sobretodo cuando vayas a sitios que no conozcas…)

Algo casi todavía más importante que la ruta, es ver la previsión del tiempo. En la montaña el clima es muy variable, pero si podeis tener una idea de si hay previsión de lluvias o nieblas, os garantizará una alta probabilidad de que tu excursión sea un éxito. En serio, no vale la pena aventurarse en la niebla ¿ok? Yo nunca lo he hecho ni lo volveré a hacer.

También es importante no ir solo. No tiene porqué pasarnos nada, pero si pasa, es mejor que alguien nos pueda ayudar. Una simple torcedura de tobillo, nos puede dejar en un problema si estamos solos en un sitio sin cobertura….

Llega la hora de preparar la mochila. Nuestra intención era llegar el viernes por la tarde, pernoctar por el camino, y continuar la excursión el sábado, por lo que el equipamiento escogido fué el siguiente:

Acampada

– 1,5 litros de agua por día mínimo (yo para mi recomiendo 2L), pero si hay fuentes por el camino, coged pastillas potabilizadoras y no hace falta que cargueis con mucha agua. Como vereis más adelante el peso de la mochila es un factor muy importante

– Comida: yo elijo siempre pasta. Hidratos de carbono para reponer energia, fundamentales para excursiones largas como esta. Unas barritas energéticas que son siempre fáciles de transportar, y prácticas, algo de frutos secos, (nueces, cacahuetes, etc…) y esta vez como capricho, un sandwich con lechuga, tomate, queso…. mmm…(espero que no lea esto Cristian, quien me lleva la dieta en el Gym, que como se entere que le he puesto queso al sandwich….)

– Ropa de abrigo: direis, ¿en verano ropa de abrigo? Sí señores, a casi 3000 metros de altura, no os imaginais el frío que hace cuando cae el sol… para una excursión como subir la Pica d’Estats llevaba: Camiseta térmica de invierno, polar, pantalon largo de chandal, braga polar, saco de dormir para hasta -20ºC así como una manta térmica para emergencias para retener el calor. Una vez tuve un amigo que con su pareja se vino a una excursión y se trajo un saco de dormir en verano de estos para camping… hasta la fecha no ha vuelto a querer salir de excursión… Si no vais a subir por estas cotas, y os quedais por los 2000 como mucho, no hara falta tanto abrigo, pero almenos yo prefiero llevar de más que de menos. Un pequeño chubasquero por si nos llueve tampoco está nada mal.

– El saco y la tienda: no es fundamental, pero sí importante que sean ligeros y fácilmente transportables plegados. Las Chechuas que se montan en dos segundos están muy bien si tienes prisa para montarla, pero tienen el inconveniente de que pueden ser un aladelta cuando sople el viento fuerte (y allí arriba lo sopla) y te desequilibre cuando estés  haciendo equilibrios.

chechua 2seconds

– Elementos que es mejor no tener que usar pero hay que llevar: botiquín con antihistamínicos, antiinflamatorios, analgésicos, tiritas, esparadrapo, etc… no nos vamos a la guerra, pero no sería raro que te salga una ampolla en el pie…

– Los bastones: no son obligatorios, y puedes hacer excursiones sin problema sin ellos, pero sin duda una gran ayuda para descargar un poco las piernas sobretodo al bajar. Además de darte estabilidad dandote dos apoyos adicionales.

– La mochila: fundamental llevar una buena mochila. Si vas a cargar con peso, que se ajuste bien a tu cadera. Repito, muy importante que se ajuste bien a tu cadera, bien apretada, ya que al cargar con 10kg a tu espalda durante horas puede hacer que tengas molestias en los hombros. Otro factor fundamental es el peso. Cargar con 10kg a tu espalda durante 6 horas te va a ralentizar la marcha, no llegarás tan lejos ni tan rápido. Normalmente se recomienda no llevar más de un 10% de tu peso. Si yo por ejemplo peso 8… digo 70kg, debería llevar un máximo de 7Kg. Si tu mochila pesa 10,5kg, no es «llevo sólo 3,5kg mas», es «¡supero la carga máxima un 50%!»

– El calzado: No estrenes el calzado el dia de la excursión, llévalo puesto unos días antes, y búsca un calzado adecuado a lo que vayas a hacer. No hace falta unas botas duras de caña alta para caminar por senderos… Algo cómodo y que se agarre bien nos será más que suficiente.

Nada más para empezar, ganas, un sitio al que ir, y a disfrutar!

Estany del sotllo(Pica d'estats)

 

Domotiza tu casa – Día 4. Primeros pasos, el Servidor web II

Hoy vamos a hacer nuestro «hola mundo» de arduino con nuestro servidor web.

Para que tengais una referencia de lo que vamos a hacer, conviene que tengais documentación sobre la librería Ethernet donde se detalla el funcionamiento de las funciones usadas. (http://arduino.cc/en/Reference/Ethernet).

Supongo que ya habreis visto como funciona arduino y su entorno de desarrollo, sinó, es un buen momento para visitar el tutorial del día anterior (http://www.pedrocarrillo.es/?p=28).

Vamos a empezar con el planteamiento del programa en pseudocódigo, fácil de entender para los humanos,  y después lo pasaremos a código, para que lo entienda nuestro arduino.

La estructura sería la siguiente:

#includes y defines

Configuración de la ethernet

void setup(){

Inicializar Serial;

Inicializar Ethernet;

}

void loop() {

Detectar cliente conectado;

Leer petición HTTP;

Extraer de la petición HTTP los parámetros que nos hagan llegar;

Imprimir la web indicada en los parámetros;

Detener cliente;

}

Ahora que habeis visto el esquema, escribo el código comentado para facilitar su comprensión

/******** INCLUDES **********/

//Fundamental incluir las librerías para poder utilizar las librerías de funciones que utilizaremos a continuación

#include <SPI.h>
#include <Ethernet.h>

/******** DEFINES **********/

#define BUFSIZ 100;

/************ CONFIGURACION ETHERNET  ************/
//Definimos la MAC, IP, y declaración del server

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 1, 177 };
String ipString = «192.168.1.177»;

Server server = Server(80); // 80 es el puerto por el que nos llegan por defecto las peticiones http

void setup() {
// Inicializando Serial para debug
Serial.begin(9600);
//Inicialiciando ethernet y server
Ethernet.begin(mac, ip);
server.begin();

}

void loop()
{

//Creamos un contador «index», que más adelante veremos para que sirve una variable «clientline» para almacenar la linea HTTP que nos llegará por cada petición

int index = 0;

String clientline= «»;

//Declaramos la variable cliente

Client client = server.available();

//Si hay un cliente conectado empezamos a leer la entrada HTTP
if(client) {
//una peticion http termina con una linea en blanco
boolean current_line_is_blank = true;
//reset el buffer de entrada
index = 0;

//mientras que el cliente esté conectado y disponible, leemos la entrada

while(client.connected()){
if(client.available()){
char c = client.read();

//Si no es una nueva linea, añade el caracter al buffer
if(c!= ‘n’ && c != ‘r’) {
clientline = clientline + c;
index++;
//si es demasiado grande para el buffer empieza a sacar fuera datos
if(index >=100)
index = BUFSIZ -1;
//continua leyendo datos
continue;
}

//si tenemos un n o un r, significa que el string está completo
clientline[index] = 0;

/****** Aquí haremos el filtrado de datos. Descartamos las partes que no nos interesan, y sacamos de la linea (clientline), el nombre del módulo a mostrar, que es lo que nos interesa

String params = clientline.substring(clientline.indexOf(«GET /») + 5,clientline.indexOf(» HTTP/1.1″));
String modulo = params.substring(0, params.indexOf(«/»));

//Utilizamos el puerto serie para debugar
Serial.println («Params: » + params + » Modulo: » + modulo);

//Llamamos a una función para imprimir la cabecera de la web
header(client, modulo);

//Llamamos a una función para imprimir el cuerpo de la web
body(client, modulo);
//Llamamos a una función para imprimir el pir de la web

pie(client);

//paramos el cliente y dejamos un retardo de 1 segundo hasta que se vuelva a ejecutar este loop
client.stop();
delay(1000);
}
}

}
}

//Función para imprimir la cabecera de nuestra web
void header(Client client, String title){
client.print(«<html><head><title>HouseBox – » + title + «</title></head><body><h1>HouseBox</h1>» + modulos(client) + «<h2>» + title + «</h2>»);
}
//Función para imprimir el menú de secciones de nuestra web

String modulos(Client client){
return («<ul><li><a href=»../Inicio»>Inicio</a></li><li><a href=»../Balcon»>Balc&oacute;n</a></li><li><a href=»../Cocina»>Cocina</a></li><li><a href=»../Comedor»>Comedor</a></li><li><a href=»../Recibidor»>Recibidor</a></li><li><a href=»../General»>General</a></li></ul>»);
}

 

//Función para escribir el cuerpo de la web

void body(Client client, String modulo){
if (modulo == «Inicio»){
client.println(«Bienvenido a Inicio»);
}
else if (modulo == «Balcon»){
client.println(«<ul><li>Temperatura balc&oacute;n: XX oC</li><li>Luminosidad: XX</li><li>Humedad:XX</li><li>PH:XX</li><li>Riego programado de: XX a XX, y de YY a YY</li></ul>»);
}
else if (modulo == «Cocina»){
client.println(«<ul><li>Temperatura cocina: XX oC</li><li>Niveles Gas Natural</li><li>Niveles Monoxido de Carbono</li><li>Dectecci&oacute;n agua en suelo</li></ul>»);
}
else if (modulo == «Comedor»){
client.println(«<ul><li>Temperatura comedor: XX oC</li><li>Color ambiental</li></ul>»);
}
else if (modulo == «Recibidor»){
client.println(«<ul><li>Temperatura recibidor: XX oC</li><li>Encender alarma puerta/volum&eacute;trico:  <a href=»#»>ON</a> / <a href=»#»>OFF</a>»);
}
else if (modulo == «General»){
client.println(«<ul><li>Calefacci&oacute;n: <a href=»#»>Apagar</a> / <a href=»#»>Encender</a></li><li>Persianas autom&aacute;ticas: <a href=»#»>ON</a> / <a href=»#»>OFF</a></li><li>Apagado autom&aacute;tico de calefacci&oacute;n(en caso de ventanas abiertas): <a href=»#»>ON</a> / <a href=»#»>OFF</a></li></ul>»);
}
else{
client.println(«P&aacute;gina no encontrada»);
}
}

//Función para escribir el pie de la web

void pie(Client client){
client.print(«</body></html>»);
}

 

Con esto, probadlo y os saldrá una sencilla aplicación web accediendo a la IP de arduino (en este ejemplo 192.168.1.117). Vereis algo como esto:

Arduino web server

A partir de este sencillo desarrollo iremos mejorando e implementando los diversos módulos.

Espero que haya sido de vuestro agrado, y que cualquier sugerencia la comenteis.

¡Hasta la semana que viene!

Domotiza tu casa – Día 3. Primeros pasos, el Servidor web I

Esta semana vamos a ir finalizando la teoría inicial, empezar a tocar componentes y hacer algo más práctico.

Vamos a montar el webserver en arduino. Sí señor, un servidor web para que nuestro arduino  pueda mostrarno datos, una sencilla aplicación web. De momento, la aplicación web que nos servirá arduino será sencilla, casi conceptual. La intención del capítulo de hoy es aprender a montar un servidor web con este ejemplo. Más adelante lo iremos completando con más opciones y estilos.

 

Para empezar, si queremos conectar nuestro arduino a la red, lo mejor será conectarla mediante la Ethernet + MicroSD Shield. Podeis encontrar información sobre ella en su web http://arduino.cc/en/Guide/ArduinoEthernetShield y en castellano, pero menos actualizado en http://arduino.cc/en/Guide/ArduinoEthernetShield.

Conectarla a la placa de Arduino es sencillo, simplemente encajará encima de nuestra placa.

Arduino Ethernet Shield

 

Una vez insertada ya estamos listos para programar. Para ello, nos descargaremos el entorno de desarrollo de arduino, que lo podreis encontrar en su propia página web http://arduino.cc/es/Main/Software.

Una vez descargado e instalado mediante su sencillo instalador, necesitaremos conectar la placa mediante un cable USB  con conector tipo B (como el que utilizan las impresoras). Mediante este cable alimentaremos nuestra placa y nos comunicaremos con ella. También deberemos conectar un cable ethernet que venga desde nuestro router a la placa ethernet Shield.

Ahora ya está todo instalado y listo para funcionar, así que vamos a empezar a programar.

Os recomiendo que para ir practicando algo hagais este sencillo ejemplo que hace parpadear un led. Y vereis como funciona el lenguaje, etc…

http://arduino.cc/es/Tutorial/Blink

Y la básica referencia de funciones que iremos utilizando durante el tutorial la teneis aquí:

http://arduino.cc/es/Reference/HomePage

Echádle un vistazo que en el próximo capítulo empezamos a programar!

 

Cualquier duda o sugerencia, dejad un comentario y os responderé con mucho gusto.

 

Domotiza tu casa – Día 2. El hardware

Ahora que ya sabemos qué queremos domotizar de nuestra casa, vamos a proponer cómo lo haremos y qué necesitaremos.

La idea principal es que el sistema sea lo más independiente posible, que no dependa de tener un ordenador encendido en casa para recoger datos, mostrarlos, y sobretodo, que ocupe y consuma poco.

La estructura será de un arduino central, a los que los sensores serán por radiofrecuencia.

Para ello, he elegido la placa Arduino Mega (http://arduino.cc/es/Main/ArduinoBoardMega) por su gran cantidad de entradas y salidas y potencia, en combinación con una Ethernet Shield (http://www.arduino.cc/en/Main/ArduinoEthernetShield)

Placa Arduino Mega 2650

Placa Ethernet Shield

 

 

Con esta Ethernet Shield, añadimos a las posibilidades de arduino, la capacidad de conectarse a la red mediante Ethernet. Lo que haremos más adelante, es conectar nuestro arduino directamente al router para poder acceder a él desde cualquier lugar.

Para los sensores, en cada sala en la que haya que interactuar, utilizaré una sencilla placa Arduino Pro Mini ( http://arduino.cc/en/Main/ArduinoBoardProMini) .

 

Placa Arduino Pro Mini

Esta placa la podremos colocar en cualquier lugar discretamente grácias a su pequeño tamaño, y tendremos un mínimo consumo. Podeis ver sus características en el link anterior.

Estas placas se comunicarán por radiofrecuencia con un par de emisores y receptores RF a 433Mhz.

Kit Radio Frecuencia 433 Mhz

Estos kits de radiofrecuencia son muy económocos 10€ – 15€ y nos permitirán una comunicación básica, que alcanzará sobradamente en nuestra casa domotizada

 

¡El próximo día empezaremos a programar!

 

 

 

Domitiza tu casa – Día 1. Planificación

Inicio este proyecto para domotizar una casa con Arduino (http://www.arduino.cc/es/). Barato, fácil, flexible, y al alcance de todos, ¿qué más podemos pedir?

La idea inicial es crear un sistema para ir añadiendo sensores y actuadores a la casa e ir domotizándola. Todo el contenido aquí es de todos, así que utilizadlo si os sirve y disfrutarlo si os apetece.

¡Empecemos!

 

En una primera propuesta, el sistema debería controlara los siguientes sensores y actuadores:

 

Cocina

Detección de CO2 y Monoxido de carbono para evitar gases nocivos o posible incendio

Comedor

Escoger el color del ambiente del comedor

Recibidor

Si se abre la puerta, y se detecta movimiento estando la alarma conectada, activar la alarma en caso de que esté activado el modo alarma

Balcón

Control de riego y ph de las plantas del balcón

General

Encender y apagar la calefacción dependiendo de si se está por debajo de la temperatura mínima, apagar si se supera la máxima o si hay ventanas abiertas

Bajar si es noche o si hace mucho calor, si es de dia y no hace mucho calor, subir.

 

Creo que para empezar hay más que de sobras,¿Algo más que sea interesante controlar? De momento pensamos esta primera parte, y más adelante más detalles técnicos.

¡Hasta la próxima!

Hello world!

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!