El Muro de la Vergüenza

Antes que nada, disculpas a todos por no haber actualizado mi blog la última semana con la entrada sobre Arduino y la Raspberry PI. Como se imaginarán la última semana del año siempre es algo movida, sin embargo espero abrir el 2013 con la nueva entrada aprovechando que tengo algunos días libres del trabajo.

Para cerrar el año, es traigo un pequeño "Muro de la Verguenza". Desde que dejé la Raspberry PI en línea (hace 7 días) con el puerto SSH abierto he tenido numerosos intentos de acceso no autorizados vía SSH.

Realmente la RasPI no tiene nada interesante, sin embargo para un SPAMMER una máquina con acceso a Internet siempre es algo valioso. Ahora, es muy difícil que accedan a la RasPI si no es con un Exploit 0-Day ya que los logins de usuario/password están desactivados, sin embargo es divertido verlos intentar. Por eso les dejo "El Muro de La Vergüenza" en la siguiente dirección:

Has Clic Aquí para abrir El Muro de La Verguenza

La lista de accesos fallidos se "pre-procesa" por medio de comandos de consola antes de pasar al script PHP por medio de este comando:

$ /bin/cat /var/log/auth.log* \
    | /bin/grep "Invalid user" \
    | /usr/bin/sort -r

Encontraran la lista de usuarios utilizados con su IP junto con la estadística de accesos fallidos. Le he llamado el Muro de la Vergüenza porque primero es una vergüenza que estén intentando acceder a una humilde Raspberry PI y segundo porque es una vergüenza que sigan intentando hacer un ataque de fuerza bruta sabiendo que los logins de user/pass están deshabilitados.

Si estan interesados en el código de la página pueden descargarlo aquí. Solo recuerden ejecutar el siguiente comando para que el log pueda ser leído por el script PHP:

$ sudo chmod o+r /var/log/auth.log*

+Modificado 31/12/12: El sueño me hizo ayer una mala jugada y había puesto en el link la IP interna de la RasPI, ya he corregido el link. :)

+Agregado 31/12/12: Para los que esten interesados he incluido el script en PHP que lee los logs y calcula el número de intentos de acceso fallidos.

DNS Dinámico en la Raspberry PI

En entradas anteriores hablamos de como instalar un servidor web de manera sencilla en nuestra Raspberry PI, luego explicamos como armar un complicadísimo puente wireless y realizar la redirección de puertos en nuestro router para acceder a una página web.

Sin embargo habrán notado que mi Raspberry PI es accesible desde la dirección raspi.teubi.co bajo este mismo dominio; En esta entrada les voy a explicar como pueden obtener un DNS dinámico utilizando servicios como los de no-ip.com y dyndns para poder actualizar dinámicamente la IP de su Raspberry PI o de cualquier server que tengan bajo una conexión con IP pública dinámica.

Haciendo un "puente wireless" para la Raspberry PI

Si han estado revisando mi últimos videos, notarán como me toca trabajar literalmente "en la cocina". Sucede que junto a la cocina tenemos un pequeño comedor que es una mesita de vidrio templado que me parece maravillosa para trabajar con la Raspberry PI y el Arduino ya que tiene espacio y puedo estar cortando cosas sin miedo a rayar nada.

El problema es que mi módem se encuentra en una sala de la casa que no tiene mucho espacio para trabajar así que necesitaba encontrar una forma de conectar la RasPI sin tener que sacar cableado UTP ya que primero no tengo y segundo tenía mucha pereza de comprar un dongle Wireless.

Voy a explicar en esta entrada mi configuración de red por si a alguien es útil, aunque lo más probable es que termine comprando un dongle Wireless para la RasPI.

Esta configuración les puede servir adicionalmente por si tienen un servidor web en otro segmento de red que no está conectado directamente al módem de Internet (en este caso mi RasPI).

Instalando Lighttpd+PHP 5+Sqlite en la RasPI

Para la serie de articulos de Arduino y Raspberry PI estaba pensando en hacer un pequeño dispositivo que se pudiera controlar vía Internet. Para ello necesito instalar un servidor web con soporte de PHP en el que pudiera programar una sencilla aplicación web.

En esta corta entrada, les voy a guiar paso a paso para realizar la instalación de Lighttpd+PHP 5+Sqlite. Para ello solo van a necesitar su Raspberry PI, asegurarse de que está conectada a Internet y seguir estos sencillos pasos.

Ojo, como no quiero simplemente darles una "receta de cocina" que diga "ejecuta estos comandos", intentaré comentar cada uno de los mismo, trataré de explicar que hace y para que sirve y espero que en el camino también aprendan algo de lo que están instalando en vez de seguir ciegamente los comandos que un extraño en Internet les ha dado.

Manejo de Interrupciones con Arduino

El artículo anterior conectamos un simple display de 7 segmentos a nuestro Arduino y programamos un sencillo contador. Pero... ¿Qué tal si queremos interactuar con eventos externos?

Una de las formas comunes de interactuar con cosas que suceden "fuera" de nuestro control es por ejemplo monitorear el estado de las líneas. Dentro de nuestro "loop" principal podemos leer continuamente el valor de una línea de entrada y ejecutar por medio de una condicional un código especifico en caso de que detectemos un cambio.

El problema de este método es que el código se vuelve sumamente complejo cuando tenemos que monitorear muchas cosas o cuando nuestro loop principal simplemente tiene que hacer cosas que toman demasiado tiempo.

En esta entrada vamos a comprender como utilizar las interrupciones externas del Arduino. Esto nos será de mucha utilidad para interactuar ya sea con el usuario o con otros dispositivos de hardware que emitan "señales" que nos permitan saber que un evento ha sucedido.

Antes de continuar preparen su display de 7 segmentos porque en esta entrada lo vamos a re-utilizar.

Fabricando un contador simple con Arduino y un display de 7 segmentos

Luego de la entrada sobre interconexión entre la Raspberry y el Arduino vía Serial, vamos a comenzar una serie de entradas donde construiremos distintos módulos que nos permitirán conocer las distintas funcionalidades básicas del Arduino. Luego de finalizar esta serie de artículos tendremos un pequeño módulo de pruebas que será capaz de realizar realizar algunas tareas interesantes:

1. Desplegar información a traves de un display de 7 segmentos.
2. Capturar eventos del usuario mediante pulsadores.
3. Monitorear y controlar nuestro Arduino mediante la conexión serial que probamos previamente.

Si bien los módulos pueden construirse por separado y prácticamente hemos cubierto la mitad del tercer punto, pensé que sería más interesante ir armando cada módulo paso a paso y luego poner todo en conjunto para ver como trabaja. En esta primera entrada vamos a hacer uso de las funciones digitalWrite para controlar un pequeño display de 7 segmentos conectado a nuestro Arduino Mega.

Conectando la Raspberry PI al Arduino vía Serial

De bachiller, hace ya algunos años por cierto, estudié una opción técnica en electrónica. Esto fué así porque en algún momento de mi vida quise ser ingeniero electrónico (o algo que se le asemejara). Lástimosamente, esa rama de la ingeniería no tiene mucha demanda en mi país y la verdad al descubrir la computación me di cuenta que era algo en lo que no era nada malo, me gustaba bastante y actualmente es lo que me da de comer.

Sin embargo, el pasar de los años no ha logrado hacer que pierda el cariño por la electrónica y esa magia especial que tiene el "inventar" o "armar" dispositivos que simplemente hagan cosas interesantes por muy pequeñas que sean. Actualmente, resulta muchísimo más facil el armado de prototipos para todos aquellos cuyo hobby o profesión sea la electrónica.

En esta entrada vamos a conocer al Rasberry PI, luego al Arduino y vamos a conectarlos vía puerto serial. Al final, podrán usar esta configuración para conectar sus Arduinos (o cualquier dispositivo que se comunique via Serie) al Rasperry PI y solo su imaginación será el límite para los proyectos que podrán inventar.

Redimensionando Imágenes con PHP y GD

Una de las tareas más comunes a la hora de desarrollar aplicaciones web, es la de redimensionar las imágenes que envían los usuarios.

PHP a través de la extensión GD, provee de una serie de funciones que nos facilitan este trabajo. En esta entrada explicaré un sencillo algoritmo para redimensionar manteniendo el aspecto, es decir redimensionar una imágen sin que esta se deforme.

El problema: Imaginemos que ustedes han creado una super-aplicación que va a sacar a Flickr fuera de línea. Sin embargo todos sus usuarios están enviandoles fotografías de 10Mpx. ¿Como hacer para generar los thumbnails y versiones en distintos tamaños desde php?

La siguiente función se encarga de redimensionar una imágen manteniendo el ancho y alto dentro de los límites especificados. Así si nuestra imagen original tiene 1600x1200 de tamaño y especificamos 800x800 en los parámetros la imagen redimensionada resultante tendrá 800x600.

function resizeImage($originalImage,$toWidth,$toHeight){
  /* Esta función redimensiona un archivo JPG manteniendo
   * su radio de aspecto original dentro de los límites
   * $toWidth y $toHeight.
   * Parámetros:
   * $originalImage: Nombre del archivo en formato JPG
   * a redimensionar.
   * $toWidth: Ancho máximo de la imágen redimensionada.
   * $toHeight: Alto máximo de la imágen redimensionada.
   * Devuelve una imágen en memoria con las proporciones
   * correctas.
   */
  
  list($width, $height) = getimagesize($originalImage);
  
  // Obtenemos la relación de tamaño respecto
  // al ancho y alto máximo.
  $xscale=$width/$toWidth;
  $yscale=$height/$toHeight;

  // Cuando la escala en y es mayor que la escala en x
  // implica que debemos redimensionar en base al nuevo
  // alto.
  if ($yscale>$xscale){
    $new_width = round($width * (1/$yscale));
    $new_height = round($height * (1/$yscale));
    
  // Por el contrario si la escala en x es mayor o igual
  // debemos de redimensionar en base al nuevo ancho.
  } else {
    $new_width = round($width * (1/$xscale));
    $new_height = round($height * (1/$xscale));
  }
  
  // Reservamos espacio en memoria para la nueva imágen
  $imageResized = imagecreatetruecolor($new_width, $new_height);
  
  // Cargamos la imágen original y redimensionamos
  $imageTmp     = imagecreatefromjpeg ($originalImage);
  imagecopyresampled($imageResized, $imageTmp,
    0, 0, 0, 0, $new_width, $new_height, $width, $height);

  // Devolvemos la nueva imágen redimensionada.
  return $imageResized;
}

Un ejemplo sencillo de uso:

$imagenRedimensionada = resizeImage("miImagen.jpg",800,800);
imagejpeg($imagenRedimensionada,"miImagen800.jpg",100);

Espero este código les haya sido útil. ¡Hasta la próxima!

Convirtiendo Gráficos Vectoriales (SVG) en PNG programáticamente

Trabajando en unas cosas de la oficina me vi en la necesidad de desplegar la información de tendencias de precios en una página web; Sinceramente, no soy nada amigo de Flash, necesitaba algo estándar, que tuviera la posiblidad de agregar interactividad y que al mismo tiempo me permitiera trabajar directamente con los datos en vez de tener que hacer todo a mano. Buscando un poquito en google me topé con d3js - Data-Driven Documents.

d3js es una biblioteca de Javascript que permite crear visualizaciones de datos de una manera un poco fuera de lo común usando Gráficos Vectoriales Redimensionables(SVG). En esta entrada no pretendo explicar como usar d3js sino cómo resolver la siguiente pregunta que me hizo un usuario luego de ver las gráficas que había generado con esta herramienta:

¿Se puede descargar la gráfica?

¡Hello World! en Java (Estricto al paradigma OO)

Esta será una entrada super corta. Cuando uno aprende un lenguaje de programación uno de los primeros ejemplos que le dan es el famosísimo "Hello World!", Java en este aspecto no es la excepción.

Sin embargo me encuentro con que el ejemplo mas sencillo realmente no es OO.

public class SayHello {
  public static void main(String args[]) {
    System.out.println("Hello World!");
  }
}  

¿Muy lindo no? El problema es que no considera la orientación a objetos y es un simple ejemplo de programación estructurada al estilo de C.

Comencemos por la función "main", esta es una simple convención. Todo programa tiene que tener un punto de entrada al iniciar su ejecución, se decidió para mantener la sintaxis similar a otros lenguajes que el punto de entrada de una clase Java fuera la función main junto con los parámetros de la linea de comandos que se guardan en el arreglo args[].

¿Que tal si hacemos un SayHello? Realmente orientado a objetos.

public class SayHello {
  private String message;

  public SayHello() {
    this.message = "Hello World!";
  }

  public String toString() {
    return this.message;
  }

  public static void main(String args[]) {
    System.out.println(new SayHello());
  }
}

¿Cual es la diferencia? Primero estamos haciendo uso de la encapsulación, para el ejemplo la clase SayHello contiene un atributo interno que guarda el estado del mensaje. Este mensaje es establecido al inicio por el constructor de la clase y solo podemos acceder a el mediante un método toString(). Por convención cuando java quiere hacer una conversión de un objeto al tipo String utiliza la funcion toString, es por eso que podemos instanciar un nuevo objeto del tipo SayHello en nuestra llamada al método println y este lo trata como si fuera una cadena de texto. 

¡Y ya! Eso es todo, espero no me odien por haberlos hecho perder dos minutos de su vida ;)

Variando la intensidad de un LED en Arduino con PWM

El día de ayer recibí mi Arduino Mega, esta es una pequeña tableta creada especialmente para hacer prototipos electrónicos. En lo personal me llamó mucho la atención porque es sumamente fácil de programar y utilizar. Si son de la gente que les encanta hacer proyectos electrónicos Arduino es una excelente solución. En esta entrada intentaré explicar una aplicación básica de Modulación del Ancho de Pulso (PWM) para el cambio de la intensidad de un LED.