Saltar ó contido principal

Mostrar el voltaje actual de la batería en gambas

Con el tiempo el hardware deja de funcionar todo lo bien que deberia, esto se nota sobretodo (al menos eso creo) con los portátiles, que al parecer tienen una marcada tendencia a fallar en la batería y en el cargador, piezas que se supongo que resienten especialmente en un uso prolongado.

La última "manifestación" que vi de estos problemas es de vez en cuando la potencia de la corriente que viene del adaptador AC cae por debajo de cierto valor, lo que hace que poco a poco la batería se vaya descargando(¿?). Esto hace que haya que comprobar frecuentemente el voltaje de carga para poder tomar precauciones antes de que se quede sin energía, una forma fácil de hacerlo es con una sencilla línea de bash

=============================================================================== while [ 1 ];do cat /proc/acpi/battery/####/state;sleep 1;done ===============================================================================

Substituyendo #### por el valor que exista. Y se puede aprovechar el código_de_gambas_que_muestra_las_temperaturas para hacerlo un poco más gráfico: [http://3.bp.blogspot.com/_26RJWnubh-w/TMXhSQ5_K-I/AAAAAAAAARc/YHHg6p0IIrA/ s320/cap.png]

El código cambia poco, aunque era ya pequeño de por si :P [Volt.tar.gz], incluso se le podría añadir un disparador para que se active cuando caiga por debajo de un valor predeterminado, el problema es que activar :D

Saludos :)

Improvisando un cifrado de flujo/generador de números aleatorios

A veces hay que hacer un pequeño sistema de cifrado para la ocasión que no tiene porque ser criptográficamente seguro, una chapuzilla vamos, veremos como improvisar uno.

La idea de un cifrado de flujo es hacer un generador de números pseudo- aleatorios, que funcione en base a una semilla (la contraseña), y utilizar los números generados para cifrar/descifrar el mensaje, en este caso utilizaremos la operación XOR con cada byte generado y cada byte del mensaje, lo que se llama un cifrado_Vernam, de una forma similar a como hace ARC4

Una vez decidido esto, ya podemos comenzar con el código class sample_cipher:

def cipherStream(self, stream):

   s = ""  # Se parte de un flujo vacio

   for i in stream:  # A cada byte del flujo original

       s += chr(ord(i) ^ self.nextByte())  # Se le hace XOR con el

aleatorio generado

       # Y se anhade al flujo cifrado

   return s  # El flujo cifrado se devuelve

def nextByte(self):

   if (len(self.buffer) < 1 ):  # Si ya no hay elementos en el buffer

       self.fillBuffer()  # Se rellena

   return self.buffer.pop(0)  # Se extrae y devuelve el primer elemento

Como se puede ver, el cifrado en si es simple, pero hay que añadirle una fuente de aleatoriedad controlable que llenará el buffer, yo por ejemplo he utilizado sha256y sha512. Importante: Al parecer las funciones hash (como SHA, el utilizado) no son una buena fuente de aleatoriedad, ya que su funcion es comprimir información, no expandirla, avisados estáis. Para utilizar fácilmente las funciones sha256 y sha512 las importaremos así: from hashlib import sha256, sha512

Aviso: antes de empezar con lo realmente escabroso repito que no soy criptografo y se más bien poco de eso, y que esto es solo un ejemplo de un sistema que se supone inseguro desde un principio.

Esta es una forma de manejar el buffer, si encuentras otra que te guste más, pues mejor :). Lo primero sería tener en cuenta el buffer al inicializar el objeto, tomando una clave de 64 bytes, 512 bits, (o haciendole un sha512 posterior a la clave) y dividir la contraseña en dos partes y volver a hashearla (con sha256, ya que serían de 32 bytes, 256 bits cada parte), después se llenará el buffer:
def init(self, key): # Inicializacion del objeto

   self.h1 = sha256(key[ : 32 ]).digest() # Se hace sha256 de los 256

primeros bits

   self.h2 = sha256(key[ 32 : ]).digest() # Se hace lo mismo con los

ultimos bits

   self.fillBuffer() # Y se rellena el buffer

Para rellenar el buffer se juntan los dos hash que se obtuvieron a partir de la contraseña y se pasan por un sha512. A los primeros y a los segundos 32 bytes se les pasa por un sha256 por separado y se almacenan en los hashes, substituyendo a los que se obtuvieron de la contraseña, por último se limpia el buffer y se rellena haciendo XOR de cada byte de los hashes:
def fillBuffer(self):

   key = sha512(self.h1 + self.h2).digest() # Se hashean las dos cadenas

juntas

   self.h1 = sha256(key[ : 32 ]).digest() # Se hace sha256 de los primeros

bytes

   self.h2 = sha256(key[ 32 : ]).digest() # Se tambien con los ultimos

   self.buffer = [] # Se limpia el buffer

   for i in xrange(32): # Se rellena con el XOR de las dos cadenas de hash

       self.buffer.append(ord(self.h1[i]) ^ ord(self.h2[i]))

Y ya está, aquí [sample_cipher.py] completo, si se lanza sin argumentos mostrará las instruciones, la generación de números aleatorios usa el time como semilla.

===============================================================================

Uso: ./sample_cipher.py | randtest Si se utiliza randtest solo generará los números pseudo-aleatorios Clave de 512 bits (64 caracteres)

===============================================================================

[Referencias] https://secure.wikimedia.org/wikipedia/es/wiki/Cifrado_XOR https://secure.wikimedia.org/wikipedia/es/wiki/Cifrado_Vernam https://secure.wikimedia.org/wikipedia/en/wiki/SHA2

Música con el WiiMote y python

Antes de nada, gracias a Vishkey por prestarme el mando para poder seguir con estas cosas :D

Enfin, que hay avances en el_código_para_manejar_el_Wiimote, conseguí reproducir música de 8-bits en el, el resultado a penas se entiende con sonido "normal", pero con música electrónica a lo binärpilot, se escucha relativamente bien. El formato usado es PCM a 8 bits con signo (no como wav), con un framerate de 1500Hz

Decir también que para el preprocesado de la música (convertirla al formato adecuado) usaré SoX, así que no me pararé con eso, el comando es este:

===============================================================================

sox  -c 1 -t raw -r 1500 -1 -s 

===============================================================================

El -c es para especificar el número de canales (1) ,  -t para el tipo de archivo (raw), -rpara el framerate (1500), -1 para que sepa que es de 8-bits, y -s para que sea con signo.

El script que controla el wiimote necesitó unos cambios para poder hacer esto [pymote.py], el audio se activa automágicamente y solo hay que enviar el sonido puro, recién salido de f.read() por la función .send_audio(), solo tener en cuenta que está en el formato correcto y que no se mandan más de 20 bytes de una vez (limitaciónes del protocolo)

Así, mandar sonido al mando es bastante fácil, aquí [playmote.py] está un ejemplo, como se puede ver, la mayoría del código es para buscar la dirección bluetooth del dispositivo o para hacer paridas varias (jugar con las luces y mostrar cuanto se reprodujo)

Y eso es todo, queda mucho por hacer, hasta otra. [Referencias] http://wiibrew.org/wiki/Wiimote

Colorinchos

Hoy presento un programilla que muestra triángulos de colores a lo caleidoscopio (que era la primera intención, pero de SDL se pasó a OpenGl y de texturas a triángulos y ya la armamos)[colorinchos.c].

El efecto es este (videobin mola :P) [ http://videobin.org/+1zv/2ac.html ]

No tiene gran cosa, se compila con:

===============================================================================

gcc colorinchos.c -o colorinchos -Wall -lglut -lGL -lGLU

===============================================================================

Y los controles son estos:

===============================================================================

[Enter]: Entra y sale de modo automático [U]: Hace zoom in [J]: Hace zoom out [F]: Salta a pantalla completa [W/S/X]: Cambia el patrón de colores [Espacio]: restaura los colores originales

===============================================================================

Lo único digno de mención es que la rotación en modo automático no tiene ningún temporizador, así que no es regular (lo que tiene su gracia), y que el modo automático cambia según la posición inicial, partiendo de los colores originales si se pulsa 'X' hasta que para de cambiar y después se pone el modo automático, el resultado será distinto del que se obtendría si no se pulsara 'X'

Y no se que más decir, hasta otra...

El hola mundo con el alfabeto fonético

La idea original era hacer define de las letras "fonéticas" a su equivalente normal y despues unirlas, todo con el preprocesador, pero parece que este funciona al reves, primero cambia las funciones y después lo demás, ademas no se puede usar la recursividad (que un archivo se incluya a si mismo), porque cada nivel vuelve a ver el archivo original. Así que habrá que conformarse con esto, que es bastante menos elegante, pero enfin...

include

/ Une los identificadores /

define _3(a,b,c) a ## b ## c

define _4(a,b,c,d) a ## b ## c ## d

define _6(a,b,c,d,e,f) a ## b ## c ## d ## e ## f

define indianovembertango int

define mikealphaindianovember main

define victoroscarindiadelta void

define paparomeoindianovembertangofoxtrot printf

_3(india, november, tango) _4(mike, alpha, india, november) ( _4(victor, oscar, india, delta ) ){

_6(papa, romeo, india, november, tango, foxtrot)("Hotel, wishkey!\n"); / / printf(...);

}

Hasta otra...

Concurso de programación de corewars

Me entero por Thoughts_on_Corewar que están organizando un concurso de programación para este juego. Traduzco_el_post:
El Primer_Concurso_Internacional_de_Programación_de_Corewars acaba
de ser anunciado, con un primer premio de $50 patrocinado por
www.corewar.info. 

La competición tomará lugar en el área inexplorada entre la  
configuración '94nop y LP, que ha sido recientemente investigada por  
Fizmo en Redcode_Talk.

La configuración exacta es como sigue:  
Estándar:           CWS'94  
Tamaño del núcleo8000  
Procesos:              200  
Tamaño de la entrada20  
Puntos de victoria:    3  
Puntos de empate:      1  
Ciclos:                80000  
Rondas:                1000

La línea de comandos de pMARS es pmars -p 200 -l 20 -r 1000.  
STPyLDPestán prohibidos se permiten hasta dos entradas y las  
batallas serán en un torneo round-robin.


Para más información, hecha un vistazo al anuncio_en  
rec.games.corewar.

Solo añadir que como dicen en la página web, el deadline es el 31 de diciembre.

Happy coding!

De Firefox y URL's extrañas [Offtopic]

La verdad, no se me ocurre como explicarlo, pero encontre que  intruciendo el número "420269270299515438631900510129391513177391570263223450330471608719833573145727622663393847726701366096253366170285832918664116229882221533373" sacado de el resultado un post anterior, sin comillas en firefox, te lleva a una_página_web:

Sin embargo otros navegadores te mandan directamente al buscador (y se niegan a ir aunque pongas http:// delante), nslookup y dig dicen  'is not a legal name (label too long)' y telnet dice de primeras que "Name or service not known".

No creo que se pueda considerar un bug ni nada por el estilo, pero uno no puede evitar seguir tirando del hilo =P

Siguiendo, parece que firefox interpreta una url compuesta solo de números como una IP, por ejemplo, con 0 se dirige a 0.0.0.0, eso se confirma al ver que al eliminar un número del principio de la URL extraña sigue dirigiendonos a esa web, pero si se elimina uno del final da 404, eso hace pensar además que firefox hace un & (por llamarlo de alguna forma) a la IP para que quepa en la dirección, que toma solo lo que necesita empezando por la derecha, vamos.

El número se puede reducir hasta: 450330471608719833573145727622663393847726701366096253366170285832918664116229882221533373 (90 Caracteres)

Que cualquier otro programa sigue negandose a resolver y que al parecer simboliza la IP [ 207.57.152.189 ]

Enfin, la más pura coincidencia, si hubiera sacado un dígito más o menos el navegador no hubiera hecho nada interesante y esto no habría ocurrido. Pero sigo sin entender lo de que una URL de 90 caracteres simbolice una IP que se supone contiene solo... 32 bits, algo falta aún ¿?

Hasta otra.

Interactuando con el WiiMote desde Python

El mando de Wii es a día de hoy un cachivache muy capaz de interactuar con el PC, tanto por que funciona a través de bluetooth, como porque sus capacidades impolsaron a la scene a estudiarlo. El detalle es que después de ver un problema recurrente con estas consolas, que hacían falta pilas para usar el mando incluso cuando al final para jugar solo se utilizaran los que se conectan por cable a la consola, decidí escribir un script que permitiese conectarse a la consola y que, al menos, moviera el cursor y pulsara el boton principal [A] para poder solventar estos casos. Nota: Hay una librería C para interactuar con el mando, llamada libcwiid Aunque dicho script aún no está escrito, es más fácil conseguir un mando para trastear y explorar la forma con la que se comunica con la consola que una consola directamente, con ese motivo se escribió este código [pymote.py]. Conecta el dongle/pincho/chuzo bluetooth y comenzemos... El código utiliza pybluez, no debería ser un problema obtenerlo [http:// people.csail.mit.edu/albert/bluez-intro/x45.html] El archivo provee una clase llamada pymote, esta se inicializa con 3 valores (solo 1 necesario): - baddr: Dirección bluetooth del mando, este es obligatorio - name: Nombre del dispositivo, este no se utiliza aún - debug: Mensajes de depuración, por defecto a False Una vez creado, el objeto se conecta al mando, y inicia el speaker (por comodidad), el objeto provee estas funciones: - get_next: Recupera el siguiente paquete de datos - close: Cierra las conexiones bluetooth - is_connected: True si las conexiones están abiertas, False si están cerradas - toogle_mute: Silencia/Da voz al speaker, el valor actual está definido en el atributo mute - toogle_speaker: Activa/Desactiva el speaker, al activarlo se le da voz automáticamente, el valor actual está definido en el atributo speaker -set_leds:Ponelos leds en el estado definido por el atributo led, se especifica como funciona a continuación de esta lista - toogle_led: Activa/Desactiva un led concreto - toogle_rumble: Activa/Desactiva la vibración, el valor actual está definido en el atributo rumble - req_stat: "Pregunta" el estado actual al mando El resto de funciones son para uso interno o aún no están acabadas. El atributo ledes un array de 4 elementos (uno por cada led), si el bit 0 (si es impar) está activado, el led está encendido, en caso contrario, estará apagado, el estado por defecto es [ 0, 1, 1, 0], los leds 2 y 3 activados (simplemente para no confundirlo con una conexión a una consola "real"). Un problema es que el objeto no devuelve los paquetes ya decodificados, sino como los manda el wiimote, aunque el formato es bastante simple. Este script [ctrlmote.py] hace al anterior útil (de cara al usuario), dando una interfaz al con en mando (en modo texto), y interpretando los paquetes que envía. Si se ejecuta sin argumentos muestra los dispositivos disponibles: Si se le da un nombre, se intentará conectar a ese dispositivo: Eso es todo, cuando consiga hecharle la mano a una Wii para trastear, intentaré programar el script que funciona como el WiiMote. Hasta entonces... [Referencias] http://wiibrew.org/wiki/Wiimote http://people.csail.mit.edu/albert/bluez-intro/index.html

HTTPS en todos sitios

(Además de ser lo que es, este post está aquí por curiosidad, para saber cuanto tarda Blogger en publicar un post programado, por ejemplo, para las 23: 59)

Hace tiempo que pensaba hablar de esto, pero me pareció demasiado offtopic, ahora... también.

Traduciendo lo que pone en su web:

HTTPS Everywhere es una extensión de Firefox producida en  
colaboración entre El_proyecto_Tor y la Electronic_Frontier  
Foundation. Encripta tus comunicaciónes en varias webs  
"importantes".

Muchos páginas web ofrecen una encriptación limitada sobre HTTPS,  
pero se hace dificil de usar. Por ejemplo, ellos pueden usar por  
defecto el HTTP sin encriptar o llenar páginas cifradas con enlaces  
que vuelven al sitio sin encriptar.

La extensión HTTPS Everywhere arregla esos problemas reescribiendo  
todas las peticiones a esas páginas a HTTPS. Los usuarios de Firefox  
la pueden conseguir haciendo click aqui:  
[https://www.eff.org/files/https-everywhere-button.png]

Para saber con que páginas funciona, visita: https://www.eff.org/https-everywhere

Hace bastante tiempo que anda por ahí (hace quizá un mes o más que se hablo de esto en la lista de correo de TOR)

Hasta otra.

Fortunes con javascript y perl

¿Quien no conoce las miticas frases que suelen salir cuando se hace login en un sistema? (al menos en Slackware), tambien conocidas como Galletas de la suerte, fortunes, o algo asi...

¿Seria curioso poder usarlas tambien en una pagina web y que cada vez que carge la pagina salga una diferente, no?, pues no es demasiado dificil. Si las instalaste " sudo apt-get install fortune " puedes encontrar varias en /usr/ share/games/fortunes/ , el formato que siguen es bastante sencillo, es texto plano, separando una "galleta" de otra con una linea con solo un %, seria algo asi:

Frase nº 1 % Frase nº 2 % Frase nº 3 ...

Siendo tan sencillo el formato, se pueden aprovechar facilmente los archivos para cualquier cosa, por ejemplo (o para descargar [fort2js.pl] ):

===============================================================================

!/usr/bin/env perl

if ($#ARGV != 1){ # Se comprueba que se especificaron los dos archivos     print "./fort2js.pl \n";     exit(0); }

$fname = $ARGV[0]; $foutname = $ARGV[1];

print "fort2js: ".$fname." -> ".$foutname."\r\n";

$fname = "<".$fname; # Archivo que se lee $foutname = ">".$foutname; # Archivo que se escribe $i = 0; # nº de fortunes open (F, $fname); open (O, $foutname); print O "function get_cookie(v){var cookie = new Array(\""; # Cabecera de la funcion

while ($line = ){     if (substr($line,0,1) eq "%"){ # Si es el fin de una fortune         print O "\",\""; # Nueva posicion en el array         $i++; # Una fortune mas     }     else{         $line =~ s/\ \ /\ /g; # Se eliminan los dobles espacion         $line =~ s/"/\"/g; # Se escapan las comillas         $line =~ s/\n/
/g; # Se cambian los saltos de linea por
        $line =~ s/\r//g; # Se eliminan los retornos de carro         print O $line;     } } print O "\");return cookie[v]}"; # Fin de la funcion print O "function max_cookie(){return ".$i.";}"; # Funcion max_cookie() close F, O; ===============================================================================

Esto sirve para convertir un archivo de fortune's en uno de Javascript que permita usar las "galletas" con dos funciones, get_cookie(i) para recuperar la frase numero i y max_cookie() que servira para saber de cuantas "galletas" podemos hacer uso. El archivo que resulta de hacer ./fort2js.pl < archivo de salida> se puede usar muy facilmente, solo habria que subirlo a algun lugar, y añadir algo como esto al codigo HTML donde queramos que se muestre:

===============================================================================

=============================================================================== Y ya estan listas las galletas de la fortuna :D

Hasta ahora! [Referencias] http://www.w3schools.com/js/default.asp http://en.wikipedia.org/wiki/Fortune_(Unix)