Aquí algunas pruebas de fotos de detalle. La verdad es que es muy manejable y cómoda, el enfoque es rápido y el vídeo a 1080p la hace una sucesora de los vídeos con la D90. Además poder grabar vídeos en slowmotion a 400fps (a 1200fps no los recomiendo,…quedan con muy mala calidad) son divertidos (supongo que la novedad).

Resto de las fotos aquí

También el primer vídeo a 400fps que he grabado

http://www.youtube.com/watch?v=05OHhseLsmg

Resto de fotos en mi nuevo site de trovebox.com (aka OpenPhoto) http://akirasan.trovebox.com/photos/tags-Playmobil/list

Siempre había programado en x86 bajo MS-DOS y recuerdo aquella interrupción para hacer casi de todo, la int 21h. Ahora, un aliciente mas ha sido que no tengo MS-DOS, sino Ubuntu y en 64bits (nada de 32bits), por lo que hay algunos pequeños cambios: por ejemplo la int 21h es la int 80h (la que tiene los servicios de kernel).

Para empezar el compilador; he utilizado el NASM por poner uno, aunque hay varios y la verdad es que no he tenido tiempo ni de comparar ni analizar nada,…

Creamos un fichero holamundo.asm con este código fuente:

section .text
    global _start               ;necesario para el linkado (ld)

_start:                         ;inicio del codigo

        mov     edx,txtlong             ;longitud del maxima del mensaje
        mov     ecx,texto               ;mensaje
        mov     ebx,1           ;file descriptor (stdout)
        mov     eax,4           ;numero de servicio (sys_write)
        int     0x80            ;interrupcion 80h (llama al kernel)

        mov     eax,1           ;numero de servicio (sys_exit)
        int     0x80            ;llamada al kernel otra vez

section .data
texto   db      'Hola mundo!!!',0xa     ;mensaje, acabado en null
txtlong equ     $ - texto                       ;length of our dear string

Para compilar el código tan simple como:

nasm -f elf64 holamundo.asm -o holamundo.o

Una vez compilado y generado el fichero objeto, hay que linkarlo. Para ello hay que utilizar el comando ld:

ld -o holamundo holamundo.o

Listo!!! compilado y linkado, ahora ya solo queda ejecutarlo:

Que maravilla!!!

Normalmente utilizo Google Maps, que está muy actualizado. Pero la ventaja de OSM es que no tiene muchas de las restricciones que los proveedores de servicios de mapas tienen (prohibido la impresión, prohibido sacar capturas de pantalla, prohibido redistribuir los mapas si no es a través de sus portales web, etc.). Mejor explicado en las preguntas frecuentes en la web de openstreetmap.es.

Para editar los mapas puedes utilizar tanto la herramienta online que tiene OSM (Potlatch2) o herramientas de escritorio como JOSM o Merkaartor. Yo personalmente utilizo JOSM para Ubuntu.

Esta es una de mis últimas aportaciones. He mejorado una zona que conozco y que estaba algo desactualizada. Aquí podéis ver la foto del antes y del después:

No mola nada!!!,…

Para empezar vamos a tener que descargar la librería U8glib y añadirla al directorio de libraries del IDE de arduino. Luego arrancamos el IDE y ya podremos utilizarla (esto es fácil y no voy a entrar en detalle).

Os dejo un simple sketch como ejemplo, que permite ver algunas de las funcionalidades de esta librería y de paso probar como funciona la pantalla OLED. Para mi ejemplo he tenido que utilizar la clase U8GLIB_SSD1306_128X64 que utilizar comunicación SPI por software y no por hardware. Esto dependerá un poco del circuito que compréis.

#include <U8glib.h>

#define cs 2     // CS
#define a0 3     // DC
#define reset 4  // RST
#define sck 5    // D0
#define mosi 6   // D1

int x, y;

//SPI Comunicación por SW (sck, mosi, cs, a0 , reset)
U8GLIB_SSD1306_128X64 u8g(sck, mosi, cs, a0, reset);

void setup() {
  x = 50;
  y = 5;
}

void loop() {
  // picture loop
  u8g.firstPage();
  do {
   draw("Hello mundo!!!!");
   pie(x, y, "by akirasan 2k12");

   u8g.drawBox(10,22,20,30);

   u8g.drawCircle(50, 50, 14);

   u8g.drawFrame(110,30,15,10);

   u8g.drawPixel(14,23);
   u8g.drawPixel(24,43);
   u8g.drawPixel(125,53);
   u8g.drawPixel(0,0);
   u8g.drawPixel(127,0);
   u8g.drawPixel(127,63);
   u8g.drawPixel(0,63);

  } while( u8g.nextPage() );
  if (y <= 62) {
    y++;
  }

  // rebuild the picture after some delay
  delay(5);
}

void draw(char* text) {
  // graphic commands to redraw the complete screen should be placed here
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr( 0, 20, text);
}

void pie(int x, int y, char* text) {
  // graphic commands to redraw the complete screen should be placed here
  u8g.setFont(u8g_font_04b_03);
  u8g.drawStr( x, y, text);
}

El resultado de este programita es el siguiente:

Muy fácil, verdad??,…pues existe otra librería llamada http://code.google.com/p/m2tklib/ que soporta la U8glib y permite realizar GUI (graphical user interface), es decir, menús y control de entrada de datos para interactuar. Aún no la he probado, pero seguro que tiene que ser igualmente sencillo (un posible post en el futuro).

Existen otros tipos de pantalla OLED y evidentemente circuitos con pines diferentes. En este caso en concreto, voy a explicar cual es el pineado necesario y su relación con el constructor de la clase de la librería U8glib. Estos son los pines que trae este circuito:

Esta es la relación de pines (OLED) y parámetros (U8glib) y pines digitales (arduino) (sin contar con los pines de alimentación GND y V (a +3.3V) ):

PP: Me he pedido otra pantalla de color blanco,…

…así que he tenido que buscar el punto de fallo, cortar y soldar,…

No hay que olvidar que el termoretractil hay que ponerlo antes de soldar,… una vez preparado el tema hay que calentarlo. Yo he utilizado un secador de pelo a la máxima potencia.

El resultado final ha quedado bastante bien y el cable funciona de maravilla

El ratón es muy majo, pero claro, los portátiles ya no suelen venir con pcmcia,…así que ¿como cargo el ratoncillo?, pues haciendo un modmouse

La modificación es sencilla, únicamente hay que quitar la tapa que tiene con cuatro tornillos y justo debajo hay una batería con un controlador de carga. Simplemente hay que soldar a los dos cables de entrada al controlador de carga, dos cables con el pineado de USB de V+ y GND.

Resulta que existe un bug reportado a Ubuntu con este fallo: https://bugs.launchpad.net/ubuntu/+source/linux/+bug/990913 (he de comentar que mi versión no es la 12.04 Server, pero es lo mismo )

Para solucionarlo de forma temporal hasta que esté corregido, he optado por poner el parámetro BOOT_DEGRADED=true como parámetro de arranque. De esta forma ignorará este advertencia y arrancará sin pedir confirmación. Estos son los pasos a seguir:

sudo nano /etc/initramfs-tools/conf.d/mdadm

Este será el fichero que editaremos:

# mdadm boot_degraded configuration
#
# You can run 'dpkg-reconfigure mdadm' to modify the values in this file, if
# you want. You can also change the values here and changes will be preserved.
# Do note that only the values are preserved; the rest of the file is
# rewritten.
#
# BOOT_DEGRADED:
# Do you want to boot your system if a RAID providing your root filesystem
# becomes degraded?
#
# Running a system with a degraded RAID could result in permanent data loss
# if it suffers another hardware fault.
#
# However, you might answer "yes" if this system is a server, expected to
# tolerate hardware faults and boot unattended.

BOOT_DEGRADED=false

…al final ponemos el parámetro BOOT_DEGRADED=false a “true“. Guardamos y reiniciamos.

OJO!!! que previamente tenéis que comprobrar que realmente tras arrancar el raid funciona correctamente y que tenéis este bug!!!. Para ver que tenéis el raid en perfecto estado tenéis que ejecutar este comando:

root@qtrnas:~# mdadm --query --detail /dev/md0
/dev/md0:
        Version : 1.2
  Creation Time : Thu Sep  8 21:29:33 2011
     Raid Level : raid1
     Array Size : 488376184 (465.75 GiB 500.10 GB)
  Used Dev Size : 488376184 (465.75 GiB 500.10 GB)
   Raid Devices : 2
  Total Devices : 2
    Persistence : Superblock is persistent

    Update Time : Mon May  7 15:36:44 2012
          State : clean
 Active Devices : 2
Working Devices : 2
 Failed Devices : 0
  Spare Devices : 0

           Name : qtrnas:0  (local to host qtrnas)
           UUID : cfff5808:181b19bc:154931a0:1f3ecfc4
         Events : 7441

    Number   Major   Minor   RaidDevice State
       0       8       33        0      active sync   /dev/sdc1
       2       8       17        1      active sync   /dev/sdb1

Aquí algunas fotos de las primeras pruebas de campo con el sistema “a la vista”:

He reciclado el conector del disparador para que me haga de caja. Para ello hay que desmontarlo todo y con la “dremel” vaciar el contenido de plástico para poder hacer hueco.

He tenido que sacrificar los tres led’s con indicaciones (aunque no descarto ponerlos en algún momento mediante LED’s SMD) y únicamente me he quedado con el indicador del estado del módulo bluetooth, que realmente “me da información“.

Le he incorporado un pequeño pulsador para poder realizar el reset, en caso que se quede sin señal o cualquier otra cosa. Así no tengo que quitarlo y volverlo a conectar (ya que la alimentación de la cámara es constante). La idea es colocarle un pequeño interruptor que permita apagar/encender y no tener que desmontarlo.

Para fijar el conector he utilizado, por primera vez, Sugru. Que aunque es muy versátil  y fácil de utilizar,…tiene su “que”. Las pruebas de campo fueron muy bien aquí os dejo alguna foto del cacharro y alguna de las fotos geoposicionadas directamente desde la cámara.

Fotos geoposicionadas en Panoramio:

PD: Tal vez haga una revisión 2 del proyecto (que he bautizado como qtrArduD90) con GPS incorporado y batería propia.

Le he puesto tres led’s para conocer el estado (rojo = estado del bluetooth, verde = operativo, amarillo = proceso de configuración). En el código veréis referencias y funciones para tratar los leds:

En esta parte prácticamente es todo programación. He colocado bastantes comentarios en el sketch y el código está muy modularizado para simplificar y entender las acciones. Como podéis ver, en las funciones estandars setup() y loop(), es muy simple:

void setup()
{
  configurar_pines();
  check_leds();            //secuencia de chequeo visual de los leds
  pinMode(ledR,INPUT);     //redefinimos pin del led rojo para que funcione como led del estado del bluetooth
  configurar_bluetooth();
  onled(ledV);
}

void loop()
{
  while (bt.available()){
    i = 0;
    buffer[i] = (char)bt.read();
    if (buffer[i]=='$'){        //inicio sentencia
      leer_comando();           //lee hasta la "," i=","
      validar_comando();        //verifica si es $GPGGA o $GPRMC
      if (_GPGGA || _GPRMC){
        procesar_comando();     //comando válido
        i = 0;
      }
    }//fin inicio sentencia
  }//fin bt.available
}//fin loop

…pero, hay un par de puntos que hay que tener en cuenta:

1. Configurar el módulo de bluetooth para conectarse al GPS, es decir, que cuando arranquemos el bluetooth sea capaz de emparejarse con el GPS.
2. Tratar las sentencias NMEA que envía el GPS para que las reconozca la Nikon D90. Hay un par de temillas a tener en cuenta

Configurar módulo bluetooth

Antes de utilizarlo, es recomendable conectarlo vía adaptador USB-UART(TTL) y entrar en modo AT para configurar la velocidad por defecto, que es de 9600 a 4800. Velocidad con la que trabajaremos, ya que la Nikon D90 utiliza esta velocidad para recibir los datos. Esta parte es simple, únicamente necesitas un adaptador serial-USB y conectarte al puerto COM. Puedes utilizar el mismo monitor de serial que viene en el IDE de Arduino o utilizar el Putty u otros,…(recordad que para entrar en modo AT hay que seguir lo que se comenta en el siguiente párrafo para entrar en modo AT). Comandos AT que se pueden utilizar. Necesitaréis algo como esto:

Este módulo conversor con chip CP2102 es bastante barato y en ebay lo podéis encontrar por unos 3$ (con gastos incluidos).

Para que el módulo BT (bluetooth) se conecte al GPS hay que inicializarlo en modo AT, es decir, que acepte los comandos de configuración AT. Para ello hay que poner en HIGH (tensión) el pin 34 (o el PIO11) y luego poner encender el módulo. Esto hará que el módulo BT acepte comandos AT.

Básicamente le enviaremos los comandos de fijar a rol master, fijamos el password o pincode (del módulo GPS), emparejamiento y vinculación:

void iniciar_BT_modoAT(){
  // Entrar en modo AT - pin34_HIGH + power
  flashled(ledA,2);
  digitalWrite(bt_PowerPin, HIGH);
  delay(4000);
  flashled(ledA,1);
  digitalWrite(bt_KEYPin, HIGH);
  delay(1000);
  bt.listen();
}

void finalizar_BT_modoAT(){
  // Quitamos power al pin34
  digitalWrite(bt_KEYPin, LOW);
}

void configurar_bluetooth()
{
  String result, bt_pincode, bt_mac;

  flashled(ledA,3);
  Serial.println("Inicializando modulo BT...");

  iniciar_BT_modoAT();

  // Entramos en modo master============================== se supone que debe estar en role=1
  flashled(ledA,2);
  Serial.println("-----------------role");
  enviar_comandoAT("AT+ROLE=1", &result);
  Serial.println(result);

  // Fijamos el pin==============================
  flashled(ledA,2);
  bt_pincode = BT_pincode;
  Serial.println("-----------------password");
  enviar_comandoAT("AT+PSWD="+bt_pincode, &result);
  Serial.println(result);

  // Fijamos el emparejamiento==============================
  flashled(ledA,2);
  bt_mac = BT_MAC;
  Serial.println("-----------------pair");
  enviar_comandoAT("AT+PAIR="+bt_mac+",20", &result);
  Serial.println(result);

  // Vinculamos al GPS==============================
  flashled(ledA,2);
  Serial.println("-----------------link");
  enviar_comandoAT("AT+LINK="+bt_mac, &result);
  Serial.println(result);

  finalizar_BT_modoAT();
}

void enviar_comandoAT(String cmd, String *resultado)
{
  String result = "";

  Serial.print("\n-----llamamos al comando "+cmd+" --> ");

  for (int i2=0; i2<10 ; i2++){
    while (bt.available()){
      Serial.print((char)bt.read());
    }
  }

  bt.print(cmd+"\r\n");
  delay(3000);

  if (bt.available()){
    while(bt.available())
    {
      result.concat((char)bt.read());
    }
  }
  Serial.print("------resultado:"+result);
  *resultado = result;
}

En el sketch está indicado, pero hay que tener en cuenta un detalle con el número de la MAC del dispositivo al que nos tenemos que conectar, es decir, hay que adaptar su formato. Por ejemplo una MAC del estilo 00:1b:c1:06:1b:6b se debe enviar así 1B,C1,61B6B.

Adaptación de sentencias NMEA

De todas las sentencias NMEA que envía el GPS, la Nikon D90 únicamente reconoce (o simplemente utiliza) dos: $GPGGA y $GPRMC. En mi caso, de estas sentencias, la $GPGGA requiere además una pequeña adaptación para que la D90 la entienda (tal vez sería bueno una actualización de firmware de la cámara,…). Así que ojo con el módulo de GPS que utilizáis, porque tal vez no sea necesaria esta adaptación,…o si,…hay que verificarlo. Para ello conéctalo por un puerto COM y monitoriza sus sentencias NMEA.

Ejemplo de una trama en formato NMEA:

$GPGGA,152848.000,4199.9999,N,00209.9999,E,1,7,1.46,10.8,M,51.3,M,,*6B
$GPGSA,A,3,02,10,07,13,05,04,23,,,,,,1.72,1.46,0.90*0A
$GPGSV,3,1,12,10,79,346,22,07,67,128,16,13,51,047,27,04,50,216,28*72
$GPGSV,3,2,12,02,48,279,33,08,43,179,,23,23,063,30,05,21,304,31*7C
$GPGSV,3,3,12,16,08,044,,26,03,250,,20,02,120,,49,,,*4B
$GPRMC,152848.000,A,4199.9999,N,00209.9999,E,0.31,0.27,020212,,,A*67
$GPVTG,0.27,T,,M,0.31,N,0.57,K,A*38

Sentencia $GPGGA. Dos son las modificaciones que con el GPS Holux M-241 hay que hacer:

1. Número de satélites

El número de satélites tiene que ser de dos dígitos, por lo que si recibimos un número inferior a 10, tendremos que añadir un 0 (cero) por delante. Por ejemplo, esta sentencia:

$GPGGA,152848.000,4199.9999,N,00209.9999,E,1,7,1.46,10.8,M,51.3,M,,*6B

Se tiene que sustituir por:

$GPGGA,152848.000,4199.9999,N,00209.9999,E,1,07,1.46,10.8,M,51.3,M,,*6B

Esta info la descubrí por propia experiencia la cual confirmé en esta web http://we.easyelectronics.ru/upgrade-repair/analog-nikon-gps.html (ojo!!! que el contenido está en ruso).

2. Altitud

Algo parecido al anterior punto le pasa al número que marca la altitud en metros. Hay que hacer lo mismo, rellenar con 0 (ceros) hasta completar un número con cuatro digitos. Un ejemplo:

$GPGGA,152848.000,4199.9999,N,00209.9999,E,1,07,1.46,10.8,M,51.3,M,,*6B

Debe quedar así:

$GPGGA,152848.000,4199.9999,N,00209.9999,E,1,07,1.46,0010.8,M,51.3,M,,*6B

La parte del código que se encarga de hacer toda esta adaptación es esta:

void enviar_comando_gprmc(){
  int i2 = 7;
  //leer y enviar hasta final del comando --> previo al inicio del nuevo $
  Serial.print("$GPRMC,");    //enviamos lo que tenemos en el buffer
  while (bt.peek()!='$'){
    while (bt.available() && bt.peek()!='$'){
      Serial.print((char)bt.read());
    }
  }
}

void enviar_comando_gpgga(){
  int cs;
  int i2;
  leer_comando_entero();
  adaptar_satelites();      //  ",7," --> ",07," i=,
  adaptar_altitud();        //  ",148.0," --> ",00148.0,"
  cs=getCheckSum(buffer);
  Serial.write(buffer);
  Serial.print(cs,HEX);
  Serial.println("");
}

void adaptar_satelites(){
  int n=0;
  int i=0;
  while (n<8)              //llegamos hasta el final del comando numero #8
  {
    i++;
    if (buffer[i]==',') n++;
  }
  if (buffer[i-2]==','){
    for (n=strlen(buffer);n>i-2;n--){
      buffer[n+1] = buffer[n];
    }
    buffer[i-1]='0';
  }
}

void adaptar_altitud(){
  int n=0;
  int i=0;
  int k=0;
  int dig=6;

  while (n<10)   //llegamos hasta el comando n9 -->(k)XXXXXX(i) k=, inicial y i=, final
  {
    i++;
    if (n==8) k=i;
    if (buffer[i]==',') n++;
  }

  if (buffer[k+1]=='-'){
    k++;
    dig--;
  }

  int offset = dig-((i-k)-1);            //la longitud del dígito es de 6 o 5 dependiendo del signo - o +

  for (n=strlen(buffer);n>k;n--){        //desplazamos todo n posiciones segun offset
    buffer[n+offset] = buffer[n];
  }
  for (n=k+1;n<=k+offset;n++) buffer[n]='0';
}

Ojo!!! que en ocasiones también pueden venir altitudes negativas. Normalmente cuando no hay suficientes satélites para establecer una posición correcta (el código ya lo contempla).

int getCheckSum(char *string) {
  int i2;
  int XOR;
  int c2;
  // Calculate checksum ignoring any $'s in the string
  for (XOR = 0, i2 = 0; i2 < strlen(string); i2++) {
    c2 = (unsigned char)string[i2];
    if (c2 == '*') break;
    if (c2 != '$') XOR ^= c2;
  }
  return XOR;
}

Un vez programado, prototipado y probado, ya solo queda traspasarlo y empaquetarlo todo debidamente, ponerle un pulsador de reset exterior y un interruptor de encendido. Para ello voy a utilizar un Arduino mini pro versión de 3.3V a 8Mhz (ya veremos si funciona!!! y es capaz de procesar toda la información correctamente y sin retrasos, ya que sino habrá perdidas en los datos).

Para acabar aquí os dejo el link para descargar el sketch, está realizado con la versión Arduino 1.0 (tenedlo en cuenta para la compilación). También agradecer en esta parte del proyecto la colaboración de fefago , por su aporte de información y comentarios .

Links de referencia de esta parte:

http://www.cutedigi.com/pub/Bluetooth/BMX_Bluetooth_quanxin.pdf

http://www.gpsinformation.org/dale/nmea.htm

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1293745670

http://timzaman.wordpress.com/code-c-arduino/checksum-xor-cpp/

http://air.imag.fr/mediawiki/index.php/Wireless_Bluetooth_RS232_TTL_Transceiver_Module

…bueno esto era lo que yo pensaba, hasta que lo he probado y he visto que mi módulo no aceptaba este comando, ni otros comandos AT. Arrebuscando información por internet me he dado cuenta de un inconveniente: el chipi-chipi viene con un firmware llamado HC-06 o Linvor V1.5, el cual acepta muy pocos comandos AT. Básicamente estos:

…y lo mas grave no permite el modo master . En este post tenéis info sobre el HC-06 o Linvor V1.5 (este hardware puede aceptar varios firmware, incluso existe un IDE para poder desarrollarlos uno mismo,…).

Llegados a este punto, solo me quedaba dos opciones: comprar un nuevo módulo master en ebay (10$) o tostar un firmware nuevo sobre el cacharro. Así que siguiendo el siguiente esquema, descargando el software BlueSuiteCasira 1.24 y recuperando un viejo PC con puerto paralelo LPT y WindowsXP,…he actualizado el firmware!!!,…

Evidentemente, y para un único uso, no he hecho ni una sola soldadura (bueno las del puerto LPT reaprovechado que he encontrado por casa). Así es como me ha quedado el “engendro” temporal. Lo increíble es que ha funcionado “a la primera“:

Ahora ya tengo el módulo tal y como yo quería. Siguiente paso,…programar el Arduino con los componentes pinchados!!!

Si queréis mas información aquí os dejo los links que he utilizado yo. Tendréis mas detalle (paso a paso de la aplicación para flashear, aunque no tiene mucho secreto) y un poco mas de teoría:

http://byron76.blogspot.com/

http://curiosidadesford.blogspot.com/2011/01/modulo-bluetooth-bluetooth-module.html

http://www.neoteo.com/modulo-bluetooth-hc-06-android

En esta primera parte he conectado el Arduino por cable a la Nikon D90 y he simulado la entrada de datos del GPS en formato NMEA. Para ello hará falta: un Arduino (en mi caso un Nano v3.0, pero cualquier versión vale), un pequeño programa (sketch) para que Arduino simule la salida de datos y un conector para la entrada GPS de la cámara (ahora explicaré como conseguirlo).

El conector GPS para la Nikon D90: Se puede conseguir muy barato en eBay (por unos 5$-6$) un disparador remoto por cable (modelo MC-DC2). De este cable únicamente nos servirá el conector, el cual hay que volverlo a pinear correctamente. En esta web tenéis el pineado necesario (es de donde he sacado algo de información). Esta es la pinta que tiene el mío (evidentemente sin el envoltorio):

Bien, una vez pineado el conector de forma correcta, hay que centrarse en el Arduino. Os dejo el programa que he generado como ejemplo para simular la entrada de datos GPS a la cámara:

 #include <SoftwareSerial.h>
 */
 GPS test D90
 SoftwareSerial(rxPin, txPin)
 rxPin = 2
 txPin = 3
 */
 SoftwareSerial mySerial(2, 3);
 void setup()
 {
 mySerial.begin(4800);
 pinMode(2,INPUT);
 pinMode(3,OUTPUT);
 pinMode(13,OUTPUT);
 }
 void loop()
 {
 digitalWrite(13,HIGH);
 mySerial.println("$GPGGA,154654,4428.2011,N,00440.5161,W,0,00,,-00044.7,M,051.6,M,,6B");
 mySerial.println("$GPGSA,A,1,,,,,,,,,,,,,,,1E");
 mySerial.println("$GPGSV,3,1,10,02,50,290,00");
 mySerial.println("$GPGGA,154655,4328.1874,N,00340.5185,W,1,03,08.5,-00044.7,M,051.6,M,,*79");
 mySerial.println("$GPGSA,A,2,13,23,25,,,,,,,,,,08.5,08.5,00.9*0E");
 mySerial.println("$GPGSV,3,1,10,02,50,290,26,04,60,210,26,08,33,173,29,10,21,296,00*7E");
 mySerial.println("$GPGSV,3,2,10,13,58,044,34,16,03,035,00,20,02,109,00,23,26,057,34*7B");
 mySerial.println("$GPGSV,3,3,10,25,24,045,35,27,56,145,27,,,,,,,,*7D");
 mySerial.println("$GPRMC,154655,A,4428.1874,N,00440.5185,W,000.7,000.0,050407,,,A*6C");
 digitalWrite(13,LOW);
 }

Ahora ya solo queda conectar el cable a la salida del Arduino y a la entrada GPS de la D90, dar corriente al Arduino y encender la cámara y verificar que correctamente está recibiendo los datos:

Si disparas alguna foto y consulta sus datos, verás que tiene la información del GPS.

Bueno hasta aquí la primera parte. Estoy a la espera de que me llegue el módulo bluetooth para pincharlo a la placa Arduino y ver de emparejar el GPS Holux (aunque evidentemente se podría utilizar un movil con GPS, porque no?)

• Gnome Shell está basado en Javascript y utiliza librerías GTK
• Unity está basado en Phyton y utiliza librerías GTK
• KDE está basado en QtScript y utiliza librerías Qt

Vía google-plus.com

Para pintarlos y dejarlos protegidos para que no se borren, me hecho varias pruebas con diferentes productos (todos los podéis encontrar en casa) y el mejor resultado ha sido: pintar los botones directamente con tempera de color (sin diluir) con un palillo, dejar secar un rato y eliminar el exceso con un palillo (cuidado, hay algunos botones mas complicados que otros, pero se pueden volver a repintar sin problema). Una vez los botones estén correctamente pintados y nos guste el resultado, solo falta aplicar (también con un palillo) y recubrir los botones pintados con pegamento del estilo “loctite”. Y ya está!!!,…ahora los botones son mas visibles.

También os podéis aventurar con combinaciones de colores (al final yo he optado con el clásico blanco y algunos detalles en rojo, como la papelera)

Resultado final:

Foto original (tamaño 4,2Mb):

Foto tratada con JPEGmini (tamaño 670Kb):

Foto tratada con jpegoptim parámetro -m80 (tamaño 704Kb):

Un crop al 100% de la misma zona (original, jpegmini, jpegoptim):

…y para comparar un poco mas, unos crop al 100% con parámetros a -m75 (tamaño 559Kb) y -m70 (tamaño 484Kb):

Resultado: el JPEGmini es una kk de servicio. Lo que tienen que hacer la gente es no fliparse tanto y reducir con alguna aplicación en su PC el tamaño antes de compartir las fotos por la web.

Mis pruebas me llevan a la conclusión que JPEGmini utiliza un ratio de compresión similar al parámetro “-mXX” de jpgoptim, de entre un valor 70-80. http://www.akirasan.net/?p=716

Al principio todo bien, hace lo que tiene que hacer,…pero el otro día tirando a máxima del objetivo (a 270mm), la cámara me indicaba que estaba enfocado OK pero yo por el visor lo veía borroso (bastante borroso). Muy raro me puse a tocar ajustes, a enfocar en manual,…y nada no había forma, se veía borroso,…así que probé de quitar el filtro,…y bingo!!!,…ahí estaba el problema.

Un ejemplo. Estas dos fotos están tomadas “de la misma forma”, pero una con el filtro polarizado y la otra sin, ¿alguna diferencia?:

…si verdad?, se nota a simple vista. Aquí un crop al 100% y se nota tela!!!:

…y si,..el punto de enfoque es el mismo,…

El filtro funciona perfectamente en otras distancias focales,…pero a 270,..kk!!!.

Mas bien,…un Búho Real

Te puedes creer que los bichos estos están entre nosotros desde la Edad Media,…jejeje

Unos polluelos de golondrina han anidado cerca.

(este post es una excusa para probar la publicación de fotos desde el Flickr directamente en mi blog)

unity --reset

También si quieres eliminar los iconos añadidos:

unity --reset-icons

…y bueno si estás como loco con el Compiz y te ha pasado lo mismo, ejecuta esto para eliminar tus cambios:

gconftool-2 --recursive-unset /apps/compiz-1

ls -l /dev/disk/by-uuid
blkid

• Hardware: Holux M-241, Nikon D90
• Software: mtkbabel (instalable desde repositorio), gpxsplitter.py, Geotag (webstart en java, requiere instalación de las Exiftool (desde repositorio como libimage-exiftool-perl), jhead (instalable desde repositorio).

1. Copiamos todas las fotos en un directorio temporal.
2. Abrimos un terminal y vamos al directorio temporal.
3. Descargamos la información del GPS en formato .gpx con mtkbabel:

   mtkbabel -s 38400 -f datos_tmp -t

4. (opcional) particionamos el fichero .gpx en varios con información diaria:

   gpxsplitter.py datos_tmp_trk.gpx

5. (recomendación) Estos dos pasos anteriores los podéis encapsular en un script en bash para simplificar el trabajo.
6. Arrancamos el Geotag y seleccionamos las fotos a geoposicionar (File->Add images from directory) y el fichero .gpx con las coordenas recogidas por el GPS (File->Load tracks from file)
7. Ahora desde la lista de fotos botón derecho->Find locations->for all images. Esto lanzará el matching entre el timestamp (hora:minuto) de la informacion guardada en la foto (exif) con la posición GPS registrada en es momento.
8. Una vez todas las fotos han sido correlacionadas (si no, podemos hacerlo manualmente ya que nos posiciona la foto en un mapa).
9. Ahora solo falta fijar estas coordenadas a la información del foto (exif). Para ello desde el menú File->Save new locations->All images (este proceso no modifica la foto original, crea una copia con el mismo nombre y los nuevos metadatos de GPS y la antigua la renombra con el sufijo _original)
10. Una vez acaba este proceso cerramos el Geotag.
11. Desde el terminal que teníamos abierto, borramos los ficheros originales:

    rm *_original

12. Ejecutamos jhead para restaurar la fecha y hora original de la foto (puedes ver que el nuevo fichero tiene la fecha y hora de hoy y no de cuando fué tomada). Básicamente jhead lee la información exif de cuando se tomó la foto y la pone como fecha de creación del fichero:

    jhead -ft *.JPG

13. Ahora ya toca clasificar las fotos.

Almacenamiento de claves

Al final me quedo con la solucción KeePass (ojo no KeePassX que aún no tiene soporte para KeePass 2 (.kdbx)), que aunque tiene poco rodaje apuesto en que será a medio plazo una solución adoptada como “standard“. Tiene cliente Windows y Linux, es sencillo, no necesito mucho mas y es portable tanto para Windows como para Linux (funciona con mono 2.6 que habrá que instalar). El inconveniente por ahora es que la autoescritura con autodetección del sitio web en Linux no está muy elaborada (aunque si funciona la autoescritura). Solo espero que evolucione con el tiempo o que KeePassX agrege el soporte para KeePass 2.

Almacenamiento de datos encriptados

He mirado TrueCrypt (unidad completa encriptada y contenedor encriptado) y Free OTFE(windows)+dm-crypt(linux). Aquí es donde tengo mas dudas, así que seguiré probando un poco mas. Los escenarios son estos:

• TrueCrypt
  • Unidad USB 4Gb: cliente portable de TrueCrypt para Windows + fichero encriptado
  • Cliente TrueCrypt instalado en Linux para leer el fichero contenedor del USB.
• dm-crypt + Free OTFE
  • Unidad USB 4Gb: partición total del USB encriptada con dm-crypt (la creación de esta partición es MUY sencilla desde la utilizada de Gestión de Discos que viene por defecto en Ubuntu, ojo!!! hay que instalar el cryptsetup (sudo apt-get install cryptsetup).
  • La comodidad en Linux es muy buena, nada mas introducir el stick USB detecta un partición como encriptada y te solicita password, la monta como unidad y lo podemos utilizar como un USB mas. En Windows hay que tener un cliente Free OTFE que puede ser portable (en otro USB a parte) o instalado. Se indica la partición y listo.

Lo chungo de todo esto, es que tengo 

Por ahora Google sigue abriendo a cuenta gotas su Google Map Maker, la misma idea, pero con GoogleMaps.

http://maps.google.es/maps/ms?ie=UTF8&oe=UTF8&msa=0&msid=101783864080580985248.0004799bda0c2cfe3dd6a

Terremotos en tiempo real: http://earthquake.usgs.gov/earthquakes/recenteqsww/

Web de USGS

Visto en Twitter

Ver el consumo de forma online nos puede ayudar sobretodo a concienciarnos en el tema de consumo electrico, así como llevar el control del gasto realizado y que luego no nos time la compañía electrica. El propio dispositivo receptor es capaz de almacenar unos 7 años de información diaria, pero si lo que queremos es tener mayor detalle, podemos conectarlo al PC y recuperar la información en tiempo real.

A continuación voy a explicar como hacerlo por consola desde Ubuntu. Al final lo que tendrémos será un script que nos mostrará la información recibida del consumo en tiempo real (cada 5seg).

Prerequisitos: Hay que tener instalado el Perl y el módulo Device::SerialPort

Instalar módulo Device::SerialPort en Perl (suponiendo que ya tenéis Perl instalado): Desde una consola ejecutamos el siguiente comando como root:

perl -MCPAN -e shell

Cuando ha acabado las verificaciones y cosas raras, ejecutamos el comando para instalar en módulo:

install Device::SerialPort

Cuando finaliza, salimos com exit.

Ahora hay que crear el siguiente script, el cual leerá la salida que emite el receptor cada 5 seg y la interpreta, de tal forma que nos mostrará los watios y la temperatura en ese momento. Lo único que debemos tener en cuenta es el puerto USB por el que está conectado el receptor, en este caso en /dev/ttyUSB0 (marcado en rojo):

 #!/usr/bin/perl -w
 # Reads data from Current Cost and e.on energy monitor devices via serial port.
 use strict;
 use Device::SerialPort qw(  ARAM :STAT 0.07 );
 my $PORT = "<span style="color: #ff0000;">/dev/ttyUSB0</span><span style="font-family: terminal, monaco;">";
 my $ob = Device::SerialPort-&gt;new($PORT);
 $ob-&gt;baudrate(57600);
 $ob-&gt;write_settings;
 open(SERIAL, "+&gt;$PORT");
 while (my $line = &lt;SERIAL&gt;) {
  if ($line =~ m!&lt;tmpr&gt; *([\-\d.]+)&lt;/tmpr&gt;.*&lt;watts&gt;0*(\d+)&lt;/watts&gt;!) {
  my $temp = $1;
  my $watts = $2;
  print "$watts, $temp\n";
  }</span>
 }

El resultado cuando se ejecuta este script es algo como esto:

akirasan@akirasan-desktop:~/currentcost# ./consumo.sh
 2432, 19.9
 2443, 19.9
 2423, 19.8
 2435, 19.8
 1074, 19.8
 969, 19.9
 964, 19.9
 990, 19.9
 2436, 19.9
 2501, 19.8
 2460, 19.8
 2449, 19.8
 2458, 19.8
 2440, 19.8
 2449, 19.8

akirasan@akirasan-desktop:~/currentcost# cat /dev/ttyUSB0
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:44:42</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02455</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:44:48</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02474</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:44:54</time><tmpr>19.9</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02472</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:06</time><tmpr>19.9</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>01020</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:12</time><tmpr>19.9</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>01041</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:18</time><tmpr>19.9</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>01021</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:24</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02400</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:30</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02318</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:37</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02472</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:43</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02478</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:49</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02468</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:45:55</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02441</watts></ch1></msg>
<msg><src>CC128-v0.11</src><dsb>00003</dsb><time>09:46:02</time><tmpr>19.8</tmpr><sensor>0</sensor><id>00077</id><type>1</type><ch1><watts>02444</watts></ch1></msg>

Descarga del script en Perl aquí: http://pastebin.com/eksBABuD

Información de referencia de ayuda:

http://www.linuxuk.org/2008/12/currentcost-and-ubuntu/

http://www.jibble.org/currentcost/

Recomendación: actualiza!!!

VideoLAN blog

periscope <nombre_fichero_video> -l es
periscope <nombre_fichero_video> -l es -l en

En la primera instrucción busca subtítulos en Español y en la segunda en Español e Ingles.