Todas las entradas de: pruebas

Como recorrer todos los componentes de un form o un panel

En determinadas ocasiones tenemos que realizar una misma operación en todos los componentes, ya sean iguales o distintos, que están en un formulario, dentro de un panel, etc.

Lo mas fácil seria ir uno por uno haciendo el cambio deseado, si son unos pocos, no seria mucho problemas, pero cuando son muchos esto puede ser un engorro, pudiendo llevarnos a introducir errores en nuestros código.

Otra opción es ir recorriendo todos los componentes que están dentro de nuestro formulario y comprobar de que clase es, y si es del tipo que tenemos que hacer el cambio, entonces pasamos a hacérselo.

Esto lo podemos hacer de la siguiente forma:

Para saber cuantos componentes tiene nuestro formulario utilizaremos la opción «Controls».  Este tiene varios parámetros que nos indican cuantos «controles» hay en nuestro formulario, el tipo, etc. Con esta información que nos facilita «Controls» podemos recorrer todos los componentes que hay.

foreach (Control cComprobar in fFormulario.Controls)
{
    // Codigo de control para el componente
}

Este código nos permite recorrer todos los controles que tenemos situados en nuestro formulario.

Ahora tenemos que saber de que tipo es el control, para ello solo tenemos que preguntárselo.

if (cComprobar is PictureBox) 
{
     // Si es del tipo que queremos lo procesamos
}

En este caso queremos saber si es un «PictureBox», pero si queremos saber si es de otro tipo, por ejemplo, si queremos modificar un «TextBox», cambiamos el «PictureBox» por «TextBox». Y así según el tipo deseado.

Ejemplo:

foreach (Control cComponente in fFormulario.Controls)
{
    if (cComponente is PictureBox)
    {
        cComponente.Image = Image.FromFile(sNuevaImagen);
    }
}

Pero puede suceder que no a todos los componentes que tenenos en nuestro formulario queramos modificarlos. Para esto, yo me aprovecho de la opción «Tag» que tienen todos los controles. En esta opción podemos introducir  el texto que deseemos. Solo tengo que marcar todos los controles que no quiero modificar y cuando lo recorro comprobar que quiero cambiarlo.

if ((string)cComponente.Tag != "estono")
{
    // Este control si lo quiero modificar
}

y con esto ya podemos realizar cualquier cambio a nuestros controles, sin tener que repetir el código para cada unos de ellos.

Y tu, si utilizas otro método puedes compartirlo con nosotros, solo tienes que dejar un comentario.

La absurda idea del anonimato en internet

acta-internet-censuraDesde hace un tiempo se viene hablado de como la gente usa las redes sociales, sobre todo Twitter y Facebook, para insultar o amenazar a otras personas. El hecho de estar solo delante de la pantalla puede dar una falsa sensación de impunidad, de que nadie sabe quien soy y puedo hacer lo que me de la gana por que nadie sabrá quien soy. Y esto es totalmente falso.

En el comienzo de internet, si se podía tener esa sensación, era bastante mas difícil saber donde se encontraba el ordenador desde el cual se realizaba esa comunicación. Pero en la época actual, es bastante fácil saber donde se encuentra el ordenador que ha realizado la conexión.

Todas las paginas web, y digo todas, guardan como mínimo la dirección IP desde la cual se ha hecho la comunicación cuando esta ha realizado un aporte a la pagina, ya se ha un comentario en un blog, en un foro, un post nuevo, etc.

Con solo la dirección IP ya podemos saber muchas cosas, pero esta no es la única información del usuario que una pagina puede guardar, Podemos almacenar desde el tipo de dispositivo que se esta utilizando, ya sea un pc, tablet, móvil, etc, el sistema operativo, el navegador, la resolución de pantalla, etc.

Pero lo importante para saber quien es y donde esta, es la dirección IP. Desde hace varios años se puede saber el lugar donde se encuentra una determinada IP. Desde esta pagina, por ejemplo, hay muchas otras, podemos saber donde se encuentra una determinada IP. La información es un poco genérica, se puede muestra la población o como mucho la calle desde donde se hizo la conexión. Pero ya tenemos localizado el lugar.

Pero esta pagina también nos devuelve otra información importante. Y es el nombre del ISP que esta ofreciendo el servicio. Con esta información la policía ya sabe todo lo necesario. Ya que el ISP tiene la  obligación de guardar un registro de las ip’s asignadas a sus clientes.

Y en obtener estos datos no se ha tardado más de 1  minuto en obtenerlos.

Por supuesto, tanto Twitter como Facebook, no van ha soltar la información de la ip de sus usuarios así como así, pero ante una orden judicial no le quedara mas remedio. Con lo que el anonimato en internet es un quimera. Es mas fácil tener anonimato en el mundo real que en internet, por muy solos que estemos  en nuestra habitación delante del ordenador.

Pero como sabemos hay gente que lo tiene. Lo normal y mas habitual es hacer las conexión mediante una conexión que no sea nuestra, wifi del vecino, todavía los hay que no la protegen, wifis gratuitas que estan saliendo como setas, con sus problemas añadidos, y demás accesos. Pero los router mas modernos guardan un historial de las conexiones, por que ya estamos cazados.

También podemos hacer la comunicación a través de un proxy anónimo, en esta pagina se puede obtener un lista de este tipo de proxis, pero un alto porcentaje de estos servidores lo único que hacen es inyectar malware al equipo que se conecta, si estas usando este tipo de comunicación seguro que no es para hacer nada bueno, por ello, toma virus.  En este vídeo Chema Alonso, muestra la utilidad que normalmente se hace de este tipo de servidores.

Otra opción, muy utilizada en la «darknet», es la red TOR, pero esta red ya no es fiable, ya ha habido varios casos donde se ha podido rastrear comunicaciones a través de ella.

Hacer que un Label sea realmente transparente en C#

En ocasiones necesitamos que en los «label» se vea el fondo, por que es una foto, cambia de color y no queremos ir cambiando el fondo de cada label, etc.

En la opción de color de fondo del «label», en la pestaña de web, podemos elegir que el fondo sea transparente, que fácil, pongo el color en transparente y listo, ya podemos cambiar el fondo cuando queramos.

Opcion BackColor del Label
Parámetro para seleccionar el color de fondo
Color transparente Label
Poner el color del fondo en transparente

Pues no, esto funciona si lo que cambiamos es el fondo de formulario, pero si tenemos un «picturebox» o un «panel» o cualquier otra cosa que no sea el fondo del formulario, esto no funciona.

Esto se debe a que cuando añadimos un nuevo componente a nuestro formulario, este es automáticamente propiedad del formulario, y por ello el «label», toma por defecto el color de fondo de su dueño.

Esto nos da la solución, si el color de fondo es el del propietario, lo que tenemos que hacer, para que nos funcione, es decirle quien es el dueño de nuestro «label» para que este, pueda coger el fondo que nosotros deseamos.

// Asignamos el propietario del label al picturebox
label1.parent = picturebox1;

Esto, para la mayoría de los casos, funciona, pero si el «label» lo vamos a mover por el formulario en tiempo de ejecución, este método nos puede causar un error. Debido a que el «label» esta fuera de su dueño.

Para solucionarlo tenemos que controlar en cada momento por donde movemos el «label», y si esta fuera del «panel» o del «picturebox», etc. bloquearlo y que no salga.

Para este problema se puede utilizar componentes externos al C#. pero como no era mi caso, no los he probado.

Otra cosa, si lo que queremos es hacer una especie de «OSD» para un vídeo (poner un texto y que se vea el vídeo por detrás), esto tampoco funciona. Los componentes de vídeo, ya sea el media player o VLC, son una especie de derivados de un panel, por lo que si le pasamos como propietaria a nuestro «label» el componente de vídeo, este tomara el color del fondo del componente que soporta el vídeo, es decir, el color del panel.

Aun así, con todos los «peros», este método es la solución para el 90% de los casos.

Si tienes otra solución puedes compartirla en los comentarios.

 

 

Por que no debemos de fiarnos de las wifis publicas

Peligro WiFi publicas
Peligro WiFi publicas

En los últimos años ha proliferado mucho la instalación de redes wifi publicas, se ha creado una obsesión de tener que estar las 24 horas del día conectado. Por ello, muchos establecimientos han decidido ofrecer este tipo de conexión gratis, bares, bibliotecas, tiendas, etc, y por supuestos los hoteles.

El compartir la conexión a internet es fácil, instalo un router wifi en mi acceso a internet y listo, cualquiera lo puede hacer, no hay que ser un ingeniero de teleco para hacerlo. Y con eso, ya puedo gritar a los cuatro vientos, que la gente venga a mi local que ofrezco conexión a internet gratis.

Y hay es donde esta el problema, nos conectamos a cualquier red wifi que encontramos por hay, sin pensar lo que nos puede pasar. Si le preguntas a cualquiera sobre el tema, te dirá que ha él le da igual, que no tiene nada de importante en su móvil, tableta o portátil. Pero lo que no se dan cuenta, es que dentro de esos aparatos esta toda su vida, su agenda, sus cuentas de correos y de redes sociales, etc. Una simple foto hecha con el móvil, sacada en la playa, en una fiesta,  un «selfi», etc, puede ser utilizada como gancho en paginas de pornografía, suplantación de identidad para un  pederasta que puede utilizarla de imagen de perfil en Facebook, etc. Para nosotros es una simple foto, sin posible valor alguno, pero para la delincuencia que se mueve por internet, es un tesoro.

Cualquier persona, y digo cualquiera, puede, con un una pequeña búsqueda en Google,  obtener millones de manuales de como instalar un troyano en cualquier dispositivo a través de la red. Sin hablar de las bandas organizadas que se dedican ha robar esos datos para luego vendérselos a terceras personas u organizaciones.

Soy un asiduo lector del blog de Chema Alonso, UN INFORMÁTICO EN EL LADO DEL MAL. Este blog se dedica ha la seguridad informática. Es considerado uno de los mejores hacker éticos españoles, una pena que sea un forofo incondicional de los productos de Microsoft 🙂

En este blog, a parte de escribir él, también escriben otros profesionales de la seguridad informática, y uno de estos, explica como, con un simple teléfono móvil, si se puede llamar simple a los teléfonos actuales, se puede hackear la red wifi de un hotel. Aunque, en este caso, ayuda mucho la poca conciencia y profesionalidad que tienen muchas de las empresas que se dedican a instalar este tipo de redes, y por supuesto, los dueños de los locales, que no se preocupan de las consecuencias que puede tener para sus clientes, la falta de seguridad en la red wifi que comparte.

En este caso el hotel se encuentra de una zona muy turística, lo que lo  hace de un lugar propicio para que algún delincuente o banda, que se dedique a la venta de datos, pueda hacer de las suyas, y utilizar estas redes, para poder acceder a la información de las miles de personas que se mueven por estas zonas, fácilmente.

Aquí os dejo el enlace al post en concreto «Auditar la WiFi del hotel con resaca y un jailbroken iPhone»

Si sabes de algún caso mas no dudes en dejar un comentario sobre el.

 

Conocer la duración del video en VideoLan (VLC) con C#

VLMC-IconTrasteando un poco con el activeX del VLC no encontraba como podía obtener la duración del vídeo que estaba reproduciendo. No tenia que ser muy difícil, es su reproductor se muestra, así que por algún lado tenia que haber una función  que devolviera el dichoso valor.  Encontré una que te devolvía todos los metadatos del vídeo, e incluso la posición actual en la que esta la reproducción del vídeo. Pero nada sobre la duración.

Después de darle varias vueltas, encontré una que, una vez que ha comenzado ha reproducirse el vídeo, nos devuelve esa información. Mientras tanto devuelve 0, lo que me engaño vilmente.

Para poder ver el valor tenemos que capturar el evento.

vVideoLan.MediaPlayerPlaying += vVideoLan_MediaPlayerPlaying;

Este evento salta cuando se pone a reproducir el vídeo.

Dentro de este evento podemos llamar a la función que ya nos devuelve la duración del vídeo.

TimeSpan tDuracionVideo = TimeSpan.FromMilliseconds(vVideoLan.input.Length);

La función «input.Legnth» nos devuelve la duración del vídeo en milisegundos.

Una vez que conocemos la duración del vídeo, podemos pasar ha obtener la posición actual de la reproducción. Esto es más fácil, solo tenemos que capturar el evento.

vVideoLan.MediaPlayerTimeChanged += vVideoLan_MediaPlayerTimeChanged;

Este evento se producirá cada vez que la posición del vídeo cambie, para saber la posición solo tenemos que poner.

int tPosicion = e.time;

Teniendo estos datos, ya se puede hacer la típica barra de progreso para saber cuanto falta para terminar el vídeo.

Pero resulta que tenemos un problema, no se, si es una fallo del VLC o que, pero el valor de «input.Length» y el valor final de «e.time» no son el mismo. El valor final de «e.time», y todas la variantes que se puede obtener para sacar la misma información que he encontrada en el VLC, es unos milisegundos superior. Por lo que si lo ponemos de esta forma en una barra de progresos.

double max = fVideoLan.vVideoLan.input.Length;
pbPlay.Minimum = 0;
pbPlay.Maximum = (int)max;

// en MediaPlayerTimeChanged
pbPlay.Value = (int)fVideoLan.vVideoLan.input.Time;

Al llegar al final del vídeo, nos genera un error que le valor el superior al valor maximo. La diferencia es pequeña, no llega un segundo, por las pruebas que he hecho, ronda los 500 – 800 milisegundos, varia con cada video, no es fija. Por lo que, antes de pasar el valor actual de la posición del vídeo a la barra de progreso, compruebo que el valor sea igual o inferior.

if ( pbPlay.Maximum > vVideoLan.input.Time )
{
    pbPlay.Value = (int)vVideoLan.input.Time;
}

Y así es como lo he solucionado, si alguien sabe como obtener la duración del vídeo de otra forma o como solucionar el problema del desfase de la duración puede dejar un comentario.

Abrir un Form en cualquier pantalla utlizando C#

Virt7En la actualidad es bastante habitual el tener más de una pantalla conectado a nuestro ordenador, ya sea dos pantallas, pantalla y televisión, etc.

Esto lo podemos aprovecharlo para mostrar diferentes ventanas de nuestros programa en cada una de las pantallas.

Windows maneja los multimonitores como si fuera uno con la resolución de la suma de todos ellos, es decir, si tenemos 2 monitores con una resolución de 1024×768 cada uno, para windows la resolución de la pantalla sera de 2048×768.

Con lo que, para poder posicionar nuestro nuevo formulario en el otro monitor, le sumaríamos  la resolución de nuestro monitor al parámetro «left» de nuestro nuevo Form. Si solo utilizamos 2 monitores no hay problema, pero cuando son varios monitores y con distintas resoluciones cada uno, se complica la cosa.

Para hacernos la vida mas fácil, C#  dispone de una clase llamada «Screen» de donde podemos obtener mucha información de las pantallas que tenemos instaladas en nuestro equipo. Una de estas funciones que hay en «Screen» es «Bound», esta función nos devuelve la posición de la esquina superior izquierda, es decir, «Left» y «Top» donde empieza cada una de las pantallas.

Declaración de la variable

// Declaramos una variable para manejar los monitores
Screen[] sMonitores;
sMonitores = Screen.AllScreens;

Funcionamiento

// Posicion del formulario
fNuevo.Left = sMonitores[1].Bounds.Left;
fNuevo.Top = sMonitores[ 1].Bounds.Top;

Como siempre, cuando hacemos referencia a una lista la posición siempre empieza por «0». Si queremos referirnos al monitor 2, tendríamos que por 1.

Este ejemplo abriría nuestro nuevo formulario en la posición 0, 0 de la pantalla 2.

Si queremos posicionarlo en otro lugar de la pantalla que fuese la 0, 0, sumaríamos el desplazamiento correspondiente tanto al parámetro «Left» como al «Top».

// Posicion del formulario
fNuevo.Left = sMonitores[2].Bounds.Left + 200;
fNuevo.Top = sMonitores[2].Bounds.Top + 100;

En este otro ejemplo, el formulario se abriría en la posición 200×100 del monitor 3.

Para saber cuantos monitores tenemos funcionando en nuestro equipo podemos utilizar la siguiente función.

NumMonitoresFuncionando = sMonitor.Rank + 1

Y ya esta con esto podemos abrir nuestro Form en cualquier monitor sin preocuparnos que resolución tiene cada uno.

Fallo con Grub al actualizar a Ubuntu 14.04

En estos días se ha publicado la nueva versión de Ubuntu 14.04 LTS, nombre clave «Trusty Tahr». Pero esta nueva versión ha salido con un  error grabe, al actualizar desde la versión 13.10, por lo que he leído por hay, de momento solo se ha documentado este fallo cuando es una actualización, cuando termina de instalar todas las actualizaciones y procede ha reiniciar el ordenador con la nueva versión, el gestor de arranque GRUB  2 da un error «grub_term_highlight_color» not found y entra en modo de recuperación, con lo que no nos deja iniciar el equipo.

El error esta documentado ya con el codigo «Bug #1289977» y se ha elevado a nivel alto, por lo que me imagino que en breve saldrá una nueva actualización con el fallo solucionado.

Yo para solucionar el problema he seguido los siguientes pasos.

Lo primero fue conseguir arrancar de nuevo el equipo desde la versión actualizada. Para ello utilice el programa «Super Grub2 Disk» este programa nos permite arrancar el ordenador comprobando que sistemas tenemos en nuestro equipo y creando un nuevo menú del GRUB para seleccionar el sistema con el que queremos arrancar.

Para ello descargamos la imagen ISO del Super Grub2 Disk y la copiamos a un USB o a un CD. En mi caso la instale un un usb utilizando el comando «dd» de la siguiente forma

sudo dd if=super_grub_disk_hybrid-1.98s1.iso of=/dev/sdj

Donde «/dev/sdj» es la ruta donde esta montada nuestra unidad USB.

Y arrancamos desde el usb, el programa en un primero momento nos muestra un menú, seleccionamos «Language», en el nuevo menú seleccionamos «Español», y en el nuevo menú que nos aparece seleccionamos la opción «Todo», la siguiente pantalla que se muestra es la lista con los sistemas que tenemos instalados, solo nos queda seleccionar nuestra versión de Ubuntu para poder arrancar desde ella.

Con esto ya hemos conseguido que nuestro equipo arranque desde la nueva versión actualizada de Ubuntu.

Una vez que consegui arrancar el ordenador desde la versión de Ubuntu actualizada, instale la herramienta «Boot-repair»

Para ello hay que seguir los siguientes comandos

Añadir el repositorio donde se encuentra esta herramienta.

sudo add-apt-repository ppa:yannubuntu/boot-repair
sudo sh -c "sed -i 's/trusty/saucy/g' /etc/apt/sources.list.d/yannubuntu-boot-repair-trusty.list"

Actualizar la base de datos de los repositorios.

sudo apt-get update

Instalar la herramienta.

sudo apt-get install -y boot-repair

Y ejecutamos el programa.

sudo boot-repair

La herramienta procederá a comprobar nuestro sistema y nos mostrara la siguiente ventana.

Herramienta Boot-Repair
Herramienta para reparar el arranque de Ubuntu

Seleccionamos el botón «Reparación recomendada», y esperamos que termine el proceso.

Cuando termine de reparar, solo nos queda reiniciar nuestro equipo, y habremos conseguido que el gestor de arranque vuelva  ha estar operativo.

Temperatura con Arduino, DHT11 y python (II)

modulo-sensor-de-tempertura-y-humedad-dht11-para-arduino_MEC-O-3277967849_102012Una vez que ya hemos hecho que nuestro arduino nos «hable», ya solo nos queda «escuchar» lo que nos dice. Para ello vamos a utilizar Python para obtener la temperatura con Arduino.

Lo primero que tenemos que hacer es conectarnos con nuestro arduino (Arduino Uno R3), para ello, lo primero que haremos es descubrir en que puerto esta conectado nuestro arduino, este método esta explicado en un por anterior, así que no me detendré el ello.

Temperatura con Arduino

Una vez que ya sabemos en que puerto esta el arduino, pasamos a leer los datos que nos esta trasmitiendo. para la lectura de estos datos utilizaremos la librería PySerial. como con la búsqueda de puerto del arduino, ya esta explicado en otro post, por lo que tampoco me detendré en ello. Como siga así no explico nada :-).

Bueno, ahora es cuando llega la hora de saber lo que nos dice nuestro arduino. Como ya dije en la otra parte de este post, lo que nos envía el arduino es un registro formateado con los datos que nosotros queremos, por lo que solo tendremos que dividir el registro leído en los diferentes campos en que se compone el registro.

Cuando leamos el registro lo primero que hacemos es comprobar que el registro esta completo. Esto lo hago comprobando que los últimos caracteres del registros son los que establecimos como final de este «|f|» y que la longitud es la que definimos.

if sArduino.endswith("|f|") and len(sArduino) == cTamanoRegistro:

Si todo esta bien, pasamos a trocear el registro, si esta mal, pasamos de los datos leídos y volvemos a leer un nuevo registro. Si el sistema fuera para el control de sistemas críticos, este método no nos valdría, debido a la perdida de datos. Para mi caso me sobra, ya que esto va ha controlar la temperatura y humedad de un invernadero.

Para dividir el registro utilizamos el carácter que hemos utilizado en el arduino como separador de campos, en mi caso el carácter «|», y el numero de campos de que consta nuestro registro, en mi proyecto 2, uno para la temperatura y otro para la humedad (Módulo de Sensor de Humedad Módulo de Temperatura Digital). Y lo guardamos en sus correspondientes variables. El resto del registro lo podemos guardar en una variable temporal, pero hay que pasarle una variable, sino, nos daría error.

sHumedad, sTemp, sFin = sArduino.split("|", 2)

Con esto ya tenemos nuestro campos guardados en sus respectivas variables para poder procesarlas como queramos. Y ya esta, hemos escuchado al arduino y sabemos lo que nos esta diciendo.

Este es el proceso completo que he utilizado.

# Abrimos el puerto del arduino a 9600
    PuertoSerie = serial.Serial(str(self.pPuerto), 9600)
    PuertoSerie.timeout = 1 

    while not self.Terminar:
        sArduino = PuertoSerie.read(PuertoSerie.inWaiting())
	time.sleep(1)

	# leemos hasta que encontarmos el final de linea
	sArduino = PuertoSerie.readline()
	sArduino = sArduino.strip()

	if sArduino.endswith("|f|") and len(sArduino) == cTamanoRegistro:
	# Separamos los datos recibidos mediante el seprador "|"
	sHumedad, sTemp, sFin = sArduino.split("|", 2) 
	global tTempMax
	global tTempMin

	global tHumeMax
	global tHumeMin

	if int(sTemp) > tTempMax: 
            tTempMax = int(sTemp)
	if int(sTemp) < tTempMin:
	    tTempMin = int(sTemp)

	if int(sHumedad) > tHumeMax:
	    tHumeMax = int(sHumedad)
	if int(sHumedad) < tHumeMin:
	    tHumeMin = int(sHumedad)

    else:
        PuertoSerie.close()
        time.sleep(5)

Y esto es todo para obtener la temperatura con Arduino, si tienes alguna duda, o si ves que se puede mejorar, que se puede mejorar y mucho, no te cortes y deja tu comentario.

Temperatura con Arduino, sensor DHT11 y python (I)

modulo-sensor-de-tempertura-y-humedad-dht11-para-arduino_MEC-O-3277967849_102012El sensor DHT11 (Módulo de Sensor de Humedad Módulo de Temperatura Digital), y sus variantes, es uno de los sensores más fáciles de manejar para obtener la temperatura con arduino. Gracias a la librería disponible para el, solo tenemos que pedir la temperatura o la humedad y ya la tenemos, sin hacer ninguna otra operación.

Materiales usados

Arduino UNO Arduino UNO
 Sensor DHT 11 Sensor DHT11
protoboard Protoboard
cables_union Cables de conexión

Sensor DHT11

Para conectarlo al arduino es muy sencillo, alimentamos el pin vcc, primero por la izquierda, con 5v desde unos de los pines del arduino, conectamos la masa al más a la derecha, y desde un pin analogico del arduino al 2 pin del sensor, empezando por la izquierda, el 3 pin no hay que conectarlo a nada.

Montaje de un sensor DHT11 en una placa Arduino UNO
Montaje de un sensor DHT11 en una placa Arduino UNO

El código como he dicho antes es muy fácil gracias a la librería existente, solo tenemos que inicializar una variable que nos permita manejar en sensor y poco mas.

Importamos la libreria

#include <DHT.h>

Inicializamos la variable para manejar el sensor DHT11

#define DHTPIN A0     // Indicamos el pin donde conectaremos la patilla data de nuestro sensor DHT11

#define DHTTYPE DHT11   // modelo del sensor que vamos a usar DHT 11 

// Inicializamos la variable
DHT dht(DHTPIN, DHTTYPE);  //Indica el pin con el que trabajamos y el tipo de sensor

Ahora solo tenemos que leer los datos del sensor DHT11 tanto de temperatura como de humedad de la siguiente forma

int iHumedad = dht.readHumidity();  // Guarda la humedad en iHumedad
int iTemepratura = dht.readTemperature(); // guarda la temepratura en iTemperatura

y con esto ya tendríamos tanto el % de la humedad con los grados de temperatura en la escala Celsius.

Pero ahora me queda mandar la información por el puerto serie para luego poderla leer en python.

Para esto creo un registro de 30 caracteres formateado, donde incluyo los dos valores leídos, una cadena variable de caracteres para ajustar la longitud del registro, un carácter separador de los campos «|»  y un campo «|f|» indicando que es el final del registro. quedando de la siguiente forma

HH|TT|XXXXXXXXXXXXXXXXXXXXX|f|

  1. HH seria el valor de la humedad, puede ser 1 0 2 caracteres dependiendo de la humedad que haya.
  2. TT valor de la temperatura, como la humedad el tamaño de este campo puede ser de 1 o 2 caracteres.
  3. X cadena variable, que dependiendo de la longitud de humedad o temperatura puede variar su longitud.
  4. |f| indica que es el final del registro. Para comprobar luego mediante python, que hemos leído correctamente la información enviada.

Si queremos enviar mas información solo tenemos que añadirla incluyendo los separadores. El tamaño del registro lo he establecido en 30 caracteres pero lo podemos variar cambiando la configuración del programa.

// Tamaño del registro a enviar al puerto serie 
int iTamanoCadena = 30;

Y el código seria el siguiente

    // añadimos la humedad y la temperatura, añadiendo al final de cada uno el caracter "|" 
    sResultado = String(h) + "|" + String(t) + "|";
    sEspacios = "";
    / Calculamos cuantos espacios tenemos que crear
    // Le restamos 3 que es el tamaño del campo final
    if (sResultado.length() < (iTamanoCadena - 3))
    {      
      // Creamos la cadena
      for (iContador = 0; iContador < ((iTamanoCadena - 3) - sResultado.length()); iContador ++)
      {
        // le añadimos el caracter que queramos, no vale para nada
        sEspacios += "X";
      }
    }
    // Añadimos el campo de fin de registro
    sResultado = sResultado + sEspacios + "|f|";
    // lo enviamos al puerto serie
    Serial.println(sResultado);
  }

Y con esto ya hemos leído la temperatura y la humedad desde el sensor DHT11 (Módulo de Sensor de Humedad Módulo de Temperatura Digital), y enviada al puerto serie para ser leída por nuestro programa en python.

Código completo.

#include <DHT.h>

#define DHTPIN A0     // Indicamos el pin donde conectaremos la patilla data de nuestro sensor

// Descomenta el tipo de sensor que vas a emplear. En este caso usamos el DHT11
#define DHTTYPE DHT11   // DHT 11 
//#define DHTTYPE DHT22   // DHT 22  (AM2302)
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Conecta el pin 1 (el de la izquierda) del sensor a +5V
// Conecta el pin 2 del sensor al pin que has elegido para DHTPIN
// Conecta el pin 4 (el de la derecha) del sensor a GROUND

DHT dht11(DHTPIN, DHTTYPE);  // indicamos en que pin esta conectado el data, y el tipo de sensor

String sResultado, sEspacios;
int iContador;
int iTamanoCadena = 30;

void setup() 
{
  //Inicio comunicacion serie para ver los datos en el ordenador
  Serial.begin(9600); 
  //Iniciamos el sensor
  dht11.begin();
}

void loop() 
{
  int iHumedad = dht11.readHumidity();  //Guarda la lectura de la humedad
  int iTemperatura = dht11.readTemperature();  //Guarda la lectura de la temperatura

  // Comprobamos si lo que devuelve el sensor es valido, si no son numeros algo esta fallando
  if (isnan(iHumedad) || isnan(iTemperatura)) // funcion que comprueba si son numeros las variables indicadas 
  {
    Serial.println("Fallo al leer del sensor DHT 11"); //Mostramos mensaje de fallo si no son numeros
  } 
  else 
  {
    // añadimos la humedad y la temperatura, añadiendo al final de cada uno el caracter "|" 
    sResultado = String(iHumedad) + "|" + String(iTemperatura) + "|";
    sEspacios = "";
    // Calculamos cuantos espacios tenemos que crear
    // Le restamos 3 que es el tamaño del campo final
    if (sResultado.length() < (iTamanoCadena - 3))
    {      
      // Creamos la cadena
      for (iContador = 0; iContador < ((iTamanoCadena - 3) - sResultado.length()); iContador ++)
      {
        // le añadimos el caracter que queramos, no vale para nada
        sEspacios += "X";
      }
    }
    // Añadimos el campo de fin de registro
    sResultado = sResultado + sEspacios + "|f|";
    // lo enviamos al puerto serie
    Serial.println(sResultado);
  }
  // y esperamos 1 segundo para volver a leer los datos del sensor.
  delay(1000);
}

Y con eso terminamos la primera entrega. en la segunda, la lectura de los datos en Python.

Como modificar la ruta de una carpeta Samba en ClearOS

clearos.jpg?w=480ClearOS nos permite montar un servidor basado en Linux fácilmente, especialmente recomendado para pequeñas empresas, que deseen un servidor estable y potente, sin tener que desembolsar una gran cantidad de dinero en licencias, este nos ofrece una forma sencilla de tener un servidor web, ftp, correo, proxy, firewall, y por supuesto, también de Samba.

Samba nos permite compartir carpetas en el servidor para que cualquier ordenador con Windows pueda tener acceso a ellas como si de un servidor Windows se tratase.

La compartición se realiza mediante la opción de Server – File – Flexshare, esta opción nos facilita el poder compartir carpetas del servidor ya sea para el servidor web, ftp o el samba (windows file share). Pero en esta opción no nos permite seleccionar que carpeta queremos compartir, sino que crear una por defecto con las opciones que le hayamos indicado.

Pero esto tiene facil solución, solo tenemos que editar el fichero donde se guarda la configuración de samba, el fichero normal para guardar la configuración del samba es /etc/samba/smb.conf.

sudo nano /etc/samba/smb.conf

Pero si editamos este fichero y nos movemos hasta la parte donde están definidos los recursos que estamos compartiendo, no encontramos las carpetas que acabamos de compartir, si no, que solo encontramos «include = /etc/samba/flexshare.conf». La palabra «include» lo que hace es incluir el que contiene del fichero, al que hace referencia, dentro de este cuando el sistema lo esta procesando. Por ello para poder modificar la configuración que hemos creado con el Flexshare tendremos que editar ese fichero.

Si abrimos el fichero «/etc/samba/flexshare.conf» nos encontramos la estructura típica de la compartición de recursos con samba.

sudo nano /etc/samba/flexshare.conf

Con la única salvedad de que disponemos ya de todos los parámetros para compartir, sin tener que haber escrito nada. Como lo que queremos es cambiar la carpeta por defecto que nos ha creado Flexshare, vamos a la opción de «path» y cambiamos la ruta por defecto por la que nosotros queramos.

Ruta por defecto que crea Flexshare

path = /var/flexshare/shares/prueba1

Ruta que queremos compartir nostros

path = /home/Public

Ya solo nos queda grabar el fichero y reiniciar el servicio.

Comando para reiniciar el servidor de Samba en ClearOS (o en cualquier servidor Linux)

sudo /sbin/service smb restart

Para pararlo utlizariamos

sudo /sbin/service smb stop

Y para iniciarlo

sudo /sbin/service smb start

Y con esto nuestra carpeta compartida ya es la que nosotros queramos.

Quien dice que Linux es difícil.