Usando una fuente de texto en IoT

Posted on por
Responder

Una de las características de los dispositivos que se usan para IoT es la limitación de recursos que tiene. No tienen un sistema operativo disponible y todo lo que queramos que haga hay que programarlo prácticamente de cero. Eso incluye cosas tan peregrinas como definir las fuentes de texto que se utilizarán para escribir en pantalla. Esto es algo que, generalmente, damos por hecho en cualquier otro sistema que programamos, pero que ofrece la oportunidad de ver un poco mejor cómo funciona la informática por dentro.

En principio las pantallas en las que querramos utilizar estas fuentes (en las que queramos escribir algo) son bastante pequeñas, la que vemos en la siguiente imagen, por ejemplo, es de 128×64 pixels (SSD1306):

¿Cómo hacemos para escribir un caracter en una pantalla de estas características? Quitando los comandos propios de inicialización, limpieza y demás, lo único que hacemos es indicar qué pixel queremos que se ilumine y cual no (si hay interés ya desarrollaremos un poco más en profundidad los comandos que se le mandan) y, para ahorrar ciclos y ancho de banda, hay que enviarle los datos en bytes completos (8 bits) y cada bit representa un pixel que se ilumina o no.

Hay software ya desarrollado para convertir fuentes ttf en código c que se puede usar con ciertas librerías, pero vamos a escoger el camino difícil, supongamos que queremos utilizar los primeros 95 caracteres ASCII empezando por el espacio. Serían estos:

Quitando el 127 que no nos interesa porque no es imprimible, una vez decididos los caracteres que queremos imprimir tenemos que decidir el tamaño que queremos utilizar. En este caso queremos que tengan una altura de 8 pixels y, como van a ser de ancho fijo, tendrán una anchura de 8 pixels igualmente. Un carácter se representaría entonces de esta manera:

Y su representación en bits de la primera fila sería 00011000 o lo que es lo mismo 0x18 en hexadecimal. Esta letra, traducida a bytes quedaría: 0x18, 0x3C, 0x66, 0x66, 0x7E, 0x66,0x66,0x00 y con esta información ya sabríamos qué bytes mandar a la pantalla cuando tuviésemos que escribir la letra.

Hacer este proceso para cada letra sería muy pesado, más teniendo en cuenta que son 95 caracteres, pero como nosotros somos programadores os voy a contar un método para extraer estos datos de una mejor manera. Vamos a generar una imagen y vamos a pintar allí las letras que queremos. Para ello abriremos el programa gráfico favorito que tengamos (el mío es gimp) y crearemos una imagen justo del tamaño para que quepan todas nuestras letras (ni más ni menos). En este caso son 95*8 = 760 y 8 de altura, con el fondo negro.

Una vez creada esa imagen, creamos un texto en la fuente que queramos y escribimos los caracteres que queremos:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Ajustamos para que quepan todos (quitamos alisado y hints varios) y quedará algo así:

Luego cambiamos el tipo de imagen a indexada con 2 colores (solo blanco y negro) y lo exportamos a formato raw:

Esto lo que hace es generarnos un archivo .data que contiene 1 byte por pixel que, como hemos indexado solo contendrá ceros o unos… Y ahora toca programar.

El objetivo es obtener una ristra de bytes juntando los ceros y unos agrupándolos de 8 en ocho. Luego veremos cómo usarlos. Lo más sencillo es hacer un scrip en python, así que escribimos algo así:

def convert_to_hex(byte_data):
    # Agrupamos los datos de 8 en 8
    byte_data = [byte_data[i:i+8] for i in range(0, len(byte_data), 8)]
    # Convertimos cada byte a su representación en hexadecimal
    resu = []
    for i in range(len(byte_data)):
        byte = sum([byte_data[i][j] << j for j in range(8)])
        # Añadimos el valor en hexadecimal a la lista resu
        resu.append(f'0x{byte:02X}')

    return resu

Y ahora solo nos queda leer de un archivo y escribirlo en otro como código c:

def read_binary_file(file_path):
    with open(file_path, 'rb') as file:
        return file.read()

def write_hex_file(hex_data, output_path):
    with open(output_path, 'w') as file:
        # Separamos los valores por comas y ponemos un salto de linea cada 16 valores
        file.write ('static const char font_8x8[] = {\n\t')
        slice_size = 16
        for i in range(0, len(hex_data), slice_size):
            file.write(', '.join(hex_data[i:i+slice_size]))
            file.write(',\n\t')
        file.write('};')

Lo juntamos todo en una función principal pasándole como parámetro el archivo de entrada y el de salida:

def main(input_file, output_file):
    binary_data = read_binary_file(input_file)
    hex_data = convert_to_hex(binary_data)
    write_hex_file(hex_data, output_file)

Y ya podemos ejecutarlo, el resultado sería algo así:

static const char font_8x8[] = {
	0x00, 0x0C, 0x36, 0x36, 0x0C, 0x00, 0x1C, 0x06, 0x18, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
	0x3E, 0x0C, 0x1E, 0x1E, 0x38, 0x3F, 0x1C, 0x3F, 0x1E, 0x1E, 0x00, 0x00, 0x18, 0x00, 0x06, 0x1E,
	0x3E, 0x0C, 0x3F, 0x3C, 0x1F, 0x7F, 0x7F, 0x3C, 0x33, 0x1E, 0x78, 0x67, 0x0F, 0x63, 0x63, 0x1C,
	0x3F, 0x1E, 0x3F, 0x1E, 0x3F, 0x33, 0x33, 0x63, 0x63, 0x33, 0x7F, 0x1E, 0x03, 0x1E, 0x08, 0x00,
	0x0C, 0x00, 0x07, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x07, 0x0C, 0x30, 0x07, 0x0E, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x18, 0x07, 0x6E, 0x00,
	0x1E, 0x36, 0x36, 0x3E, 0x63, 0x36, 0x06, 0x0C, 0x0C, 0x66, 0x0C, 0x00, 0x00, 0x00, 0x30, 0x63,
	0x0E, 0x33, 0x33, 0x3C, 0x03, 0x06, 0x33, 0x33, 0x33, 0x0C, 0x0C, 0x0C, 0x00, 0x0C, 0x33, 0x63,
	0x1E, 0x66, 0x66, 0x36, 0x46, 0x46, 0x66, 0x33, 0x0C, 0x30, 0x66, 0x06, 0x77, 0x67, 0x36, 0x66,
	0x33, 0x66, 0x33, 0x2D, 0x33, 0x33, 0x63, 0x63, 0x33, 0x63, 0x06, 0x06, 0x18, 0x1C, 0x00, 0x0C,
	0x00, 0x06, 0x00, 0x30, 0x00, 0x36, 0x00, 0x06, 0x00, 0x00, 0x06, 0x0C, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x18, 0x0C, 0x3B, 0x00, 0x1E,
	0x36, 0x7F, 0x03, 0x33, 0x1C, 0x03, 0x06, 0x18, 0x3C, 0x0C, 0x00, 0x00, 0x00, 0x18, 0x73, 0x0C,
	0x30, 0x30, 0x36, 0x1F, 0x03, 0x30, 0x33, 0x33, 0x0C, 0x0C, 0x06, 0x3F, 0x18, 0x30, 0x7B, 0x33,
	0x66, 0x03, 0x66, 0x16, 0x16, 0x03, 0x33, 0x0C, 0x30, 0x36, 0x06, 0x7F, 0x6F, 0x63, 0x66, 0x33,
	0x66, 0x07, 0x0C, 0x33, 0x33, 0x63, 0x36, 0x33, 0x31, 0x06, 0x0C, 0x18, 0x36, 0x00, 0x18, 0x1E,
	0x06, 0x1E, 0x30, 0x1E, 0x06, 0x6E, 0x36, 0x0E, 0x30, 0x66, 0x0C, 0x33, 0x1F, 0x1E, 0x3B, 0x6E,
	0x3B, 0x3E, 0x3E, 0x33, 0x33, 0x63, 0x63, 0x33, 0x3F, 0x0C, 0x18, 0x0C, 0x00, 0x00, 0x0C, 0x00,
	0x36, 0x1E, 0x18, 0x6E, 0x00, 0x06, 0x18, 0xFF, 0x3F, 0x00, 0x3F, 0x00, 0x0C, 0x7B, 0x0C, 0x1C,
	0x1C, 0x33, 0x30, 0x1F, 0x18, 0x1E, 0x3E, 0x00, 0x00, 0x03, 0x00, 0x30, 0x18, 0x7B, 0x33, 0x3E,
	0x03, 0x66, 0x1E, 0x1E, 0x03, 0x3F, 0x0C, 0x30, 0x1E, 0x06, 0x7F, 0x7B, 0x63, 0x3E, 0x33, 0x3E,
	0x0E, 0x0C, 0x33, 0x33, 0x6B, 0x1C, 0x1E, 0x18, 0x06, 0x18, 0x18, 0x63, 0x00, 0x00, 0x30, 0x3E,
	0x33, 0x3E, 0x33, 0x0F, 0x33, 0x6E, 0x0C, 0x30, 0x36, 0x0C, 0x7F, 0x33, 0x33, 0x66, 0x33, 0x6E,
	0x03, 0x0C, 0x33, 0x33, 0x6B, 0x36, 0x33, 0x19, 0x07, 0x00, 0x38, 0x00, 0x00, 0x0C, 0x00, 0x7F,
	0x30, 0x0C, 0x3B, 0x00, 0x06, 0x18, 0x3C, 0x0C, 0x00, 0x00, 0x00, 0x06, 0x6F, 0x0C, 0x06, 0x30,
	0x7F, 0x30, 0x33, 0x0C, 0x33, 0x30, 0x00, 0x0C, 0x06, 0x00, 0x18, 0x0C, 0x7B, 0x3F, 0x66, 0x03,
	0x66, 0x16, 0x16, 0x73, 0x33, 0x0C, 0x33, 0x36, 0x46, 0x6B, 0x73, 0x63, 0x06, 0x3B, 0x36, 0x38,
	0x0C, 0x33, 0x33, 0x7F, 0x1C, 0x0C, 0x4C, 0x06, 0x30, 0x18, 0x00, 0x00, 0x00, 0x3E, 0x66, 0x03,
	0x33, 0x3F, 0x06, 0x33, 0x66, 0x0C, 0x30, 0x1E, 0x0C, 0x7F, 0x33, 0x33, 0x66, 0x33, 0x66, 0x1E,
	0x0C, 0x33, 0x33, 0x7F, 0x1C, 0x33, 0x0C, 0x0C, 0x18, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x36, 0x1F,
	0x66, 0x33, 0x00, 0x0C, 0x0C, 0x66, 0x0C, 0x0C, 0x00, 0x0C, 0x03, 0x67, 0x0C, 0x33, 0x33, 0x30,
	0x33, 0x33, 0x0C, 0x33, 0x18, 0x0C, 0x0C, 0x0C, 0x3F, 0x0C, 0x00, 0x03, 0x33, 0x66, 0x66, 0x36,
	0x46, 0x06, 0x66, 0x33, 0x0C, 0x33, 0x66, 0x66, 0x63, 0x63, 0x36, 0x06, 0x1E, 0x66, 0x33, 0x0C,
	0x33, 0x1E, 0x77, 0x36, 0x0C, 0x66, 0x06, 0x60, 0x18, 0x00, 0x00, 0x00, 0x33, 0x66, 0x33, 0x33,
	0x03, 0x06, 0x3E, 0x66, 0x0C, 0x33, 0x36, 0x0C, 0x6B, 0x33, 0x33, 0x3E, 0x3E, 0x06, 0x30, 0x2C,
	0x33, 0x1E, 0x7F, 0x36, 0x3E, 0x26, 0x0C, 0x18, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x36, 0x0C, 0x63,
	0x6E, 0x00, 0x18, 0x06, 0x00, 0x00, 0x0C, 0x00, 0x0C, 0x01, 0x3E, 0x3F, 0x3F, 0x1E, 0x78, 0x1E,
	0x1E, 0x0C, 0x1E, 0x0E, 0x0C, 0x06, 0x18, 0x00, 0x06, 0x0C, 0x1E, 0x33, 0x3F, 0x3C, 0x1F, 0x7F,
	0x0F, 0x7C, 0x33, 0x1E, 0x1E, 0x67, 0x7F, 0x63, 0x63, 0x1C, 0x0F, 0x38, 0x67, 0x1E, 0x1E, 0x3F,
	0x0C, 0x63, 0x63, 0x1E, 0x7F, 0x1E, 0x40, 0x1E, 0x00, 0x00, 0x00, 0x6E, 0x3B, 0x1E, 0x6E, 0x1E,
	0x0F, 0x30, 0x67, 0x1E, 0x33, 0x67, 0x1E, 0x63, 0x33, 0x1E, 0x06, 0x30, 0x0F, 0x1F, 0x18, 0x6E,
	0x0C, 0x36, 0x63, 0x30, 0x3F, 0x38, 0x18, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x1F, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00,
	};

Y ya estaría… ¿Cómo usaríamos esto en nuestra aplicación IoT? Pues básicamente incluiríamos la cabecera font_8x8.h y cuando necesitásemos localizar un carácter ASCII simplemente tendremos que restarle 32 al caracter, multiplicarlo por el número de caracteres de nuestra fuente (95) y ese sería el primer byte del caracter dentro del array. Como vamos a necesitar todas las líneas del caracter podemos hacer una función que las recupere de esta manera:

char getcharslicefrom8x8font(char c, int rowInChar)
{
    return font_8x8[(c - 32) + (rowInChar)*95];
}

Para escribir una cadena completa en una línea habría que localizar la posición inicial de la línea, recuperar todos los bytes de cada caracter que queramos escribir y mandarlos a esa línea de la pantalla (así explicado simplificadamente).

Tenéis todo el código de la conversión de bitmap a c en este repositorio: https://github.com/yoprogramo/font_to_c

Happy coding!

UPDATE: Ya se puede encontrar la fuente así creada en los repositorios de un par de proyectos muy interesantes: https://github.com/fhoedemakers/pico-infonesPlus/ y https://github.com/fhoedemakers/pico-smsplus

Cambiar el agua del aire acondicionado mediante IoT

Posted on por
Responder

Si tienes aire acondicionado, uno de los defectos que más se encuentran en estos aparatos es cómo deshacerse del agua de condensación del mismo, especialmente en verano. Si eres como yo o como la mayoría de la gente, lo que harás será poner una botella en algún sitio accesible que se va llenando poco a poco y que, periódicamente, tendrás que cambiar para que no se desborde. Pero, en tiempos calurosos y ajetreados es muy común que la botella (sea del tamaño que sea) termine llenándose y mojemos a quien sea que tengamos debajo del aire acondicionado.

Esta dinámica, que a mi se me antoja muy molesta, la llevo repitiendo en casa y en la oficina (si, en mi oficina tengo un aire acondicionado con botellita) durante varios años y siempre me planteo, ¿y si hago algo para que me avise justo cuando está apunto de llenarse y así puedo cambiarla a tiempo? Hasta el momento no había tenido tiempo, pero ahora he encontrado un ratillo y me he puesto manos a la obra.

Los requisitos eran sencillos, necesito saber si el nivel de agua de una botella ha llegado a cierta altura en la botella, no necesito saber el % exacto, pero si saber si se esta llenando antes de que se llene. Hay algunos sensores de ultrasonidos para depósitos, pero me parecía matar moscas a cañonazos, además, el tamaño de la botella podía ser variable, por lo que el sensor no tendría que ser muy aparatoso. Buscando encontré este:

Puede funcionar a 3.3v o 5v y básicamente devuelve un valor analógico distinto según por donde le llegue el agua en la parte inferior. Este es el enlace de compra en amazon: https://www.amazon.es/dp/B07DJ5FZ31

Por otro lado quería que la solución fuese portable, es decir, que no tuviese que andar echando cables por ahí, por lo que una solución que admitiese baterías también era recomendable. Como plataforma yo estoy muy acostumbrado a usar ESP32 y me hacía mucho más sencillo la parte de conexión a la wifi, así que buscando encontré esto:

T-OI Plus

Un ESP32-C3 que tiene un puerto para batería que se puede recargar mediante usb, me fue casi más complicado hacerme con las pilas LS16340

Con todos los componentes solo me quedaba conectar el ESP32-C3 al sensor, teniendo cuidado de no usar el pin que se usa para medir el voltaje de la pila (spoiler, es el A0 y lo descubrí después de haberlo soldado). El esquema sería tal que así:

Todo soldado para probar quedaría así:

Y ahora lo interesante, que sería programarla para que podamos controlar el nivel de agua. Como las especificaciones no son siempre exactas lo que hice fue unas pruebas leyendo el nivel del GPIO04 (que tiene conversor A/D) y meter y sacar el sensor del agua imprimiendo por el puerto serie los valores obtenidos:

#define A1 4
void setup() {
  // (Optional)Press reset button
  // on the dev board to see these print statements
  Serial.begin(115200);
  while (!Serial) { }
  // Configuramos el pin A1 como de entrada analógica
  pinMode(A1, INPUT);
  delay (1000);
  Serial.println("Starting...");
}

void loop() {
  int sensorValue = analogRead(A1);
  Serial.println(sensorValue);
  delay(1000);
}

Nota: Esto lo he compilado usando platformio.io (os lo recomiendo mucho) y os dejaré el proyecto completo en un repositorio para que podáis compilarlo vosotros también.

Una vez compilado e instalado el programa veíamos por el puerto serie cada segundo el valor que leíamos del sensor, obteniendo valores entre cero y 3000 (supongo que el rango máximo será Vin que en nuestro caso es 3.3v), así que nuestro valor «umbral» será de 2000 (no se ha llegado todavía arriba del todo pero ya hay agua mojando el sensor).

El siguente paso es conectar a internet para que nos pueda mandar la alerta. Esto en ESP32 es relativamente sencillo:

#include <WiFi.h>

void printWifiStatus() {
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}
boolean connectWifi (char *ssid, char *pass){
  WiFi.useStaticBuffers(true);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, pass);
  int max = MAXATTEMPS;

  Serial.println("Connecting to WiFi");
  while ((WiFi.status() != WL_CONNECTED) && --max>0) {
    delay(500);
    Serial.print(".");
  }
  if (max == 0)
    return false;
  Serial.println("Connected to WiFi");
  return true;
}

Con esto solo hay que añadir una llamada a connectWifi parándole el SSID y la contraseña de nuestra red wifi para tener conexión. Una vez que tenemos conexión podemos hacer varias cosas para hacernos llegar una alerta, pero la más sencilla para mi era hacer que me enviase un mensaje por telegram. Para ello habría que crear un bot (hablando con botfather) y obtener el token necesario para poder usarlo. Luego he creado un canal y he puesto a este bot como administrador, con lo que para utilizar este bot solo tendría que hacer estos defines:

#define BOTTOKEN "7413559559:AAHmlkmiubcvtxZO0j0nqITZjByjrS1Ah3U"
#define CHAT_ID "-1002245988095"

y usar la librería Universal-Arduino-Telegram-bot, que podéis encontrar en https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot de esta manera:

#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

WiFiClientSecure client;
UniversalTelegramBot bot(BOTTOKEN, client);
client.setCACert(TELEGRAM_CERTIFICATE_ROOT);

bot.sendMessage(CHAT_ID, "esto es un mensaje");

Así que la lógica del programa cambia ahora a que cuando el valor detectado sea mayor que 2000 enviemos un mensaje con el bot para alertarnos.

El programa lo he mejorado para leer el valor de voltaje de la batería y para que entre en suspensión y se despierte cada 10 segundos para ahorrar energía, pero eso podéis sacarlo de los ejemplos que hay en el repositorio https://github.com/Xinyuan-LilyGO/LilyGo-T-OI-PLUS. El caso es que ahora tenía que hacer el montaje final en mi botella de agua del aire acondicionado. Elegí un bote de estos gigantes de proteinas (si, alguien en casa va al gimnasio) y tras impermeabilizar adecuadamente los cables y las conexiones decidí meter el sensor por la parte superior del tapón y así antes de llegar arriba del todo haría el contacto adecuado y quedó tal que así:

Y ya con el tubo del aire metido y todo:

Si queréis ver el resultado final (probando con una taza con agua, que no voy a esperar que se llene el bidón este) os dejo aquí un video:

El repositorio con el código inicial podéis encontrarlo en: https://github.com/yoprogramo/waterlevel

Grabar y emular un ratón en linux

Posted on por
Responder

Hoy me tocó un trabajo muy ingrato, tenía que reenviar de una cuenta de correo a otra todos los correos recibidos en dos meses. El correo estaba gestionado en una cuenta de outlook y ya tenía como 2000 correos acumulados. En principio suponía que sería sencillo, selecciono todos y reenvio… Pues no, outlook no te deja hacerlo así. El origen de la tarea era porque una regla de reenvío, que lo hace automáticamente, había estado deshabilitada un tiempo y, desafortunadamente, tampoco hay forma de hacerla correr solo para un conjunto determinado de correos, o todos, o los que entran, nada de reglas «personalizadas».

Conseguí crear una acción rápida para enviar el correo y mover el mensaje a la carpeta de procesados (para tenerlos ordenaditos), pero las acciones de outlook no te mandan los mensajes automáticamente sino que te generan un borrador con el destinatario y tu tienes que dar al botón enviar. Así que ahora tenía que dar dos clicks por cada mensaje… Solo son 2000!! ESto podía llevarme muuuucho tiempo.

¿Probamos a bajarlos por imap o algo? Pueeee no, microsoft se ha puesto muy borde con la autenticación del correo y no iba a ser sencillo, así que, para no tirarme toda una mañana (o todo un día) haciendo clicks y creandome un tunel carpiano inmenso tiré de google y encontré un repositorio de alguien que te permite grabar lo que haces con el ratón y repetirlo (aunque era en el navegador el uso de selenium me daba mucha pereza). En concreto el repositorio es este:

https://github.com/RMPR/atbswp

Y las instrucciones «rápidas» para instalarlo en un ubuntu serían estas:

sudo apt install git python3-dev python3-tk python3-setuptools python3-wheel python3-pip python3-wxgtk4.0
git clone https://github.com/RMPR/atbswp.git && cd atbswp
python3 -m pip install pyautogui pynput --user
python3 atbswp/atbswp.py

Una vez instalado y lanzado solo hay que grabar la secuencia que queramos (empezamos dando al botón de grabar o al f9 y terminamos igualmente). Esta secuencia se puede guardar en un archivo para ejecutarla posteriormente (o editarla a mano como hice yo) y luego se puede cargar y ejecutar un número determinado de veces.

Dicho y hecho, registro mis dos clicks y digo que se ejecuten 2000 veces… Ahora solo queda esperar a que termine!

Eso si, el ordenador no puedo usarlo mientras está haciendo mi trabajo… Bueno, será por ordenadores… Me ha dado tiempo a escribir esta entrada y todo mientras redirijo correos.

Japón es otro mundo

Posted on por
Responder

Hoy no voy a escribir de temas técnicos, que últimamente tengo mucha deuda técnica que pagar y estoy un poco despistado con los siguientes pasos, así que, aprovechando que me he ido a Japón unos días de vacaciones para contaros las cosas que me han sorprendido de este país.

La puntualidad de los transportes

Si en Japón un tren dice que sale a las 12:13 saldrá a las 12:13, no hay más, cualquier retraso es avisado en todas partes y, realmente, hay muy pocos y están muy justificados. Sea tren, metro o avión la puntualidad de los Japoneses con los transportes es algo que no creí que fuese real hasta que lo comprobé por mi mismo. Si abres google maps y le preguntas cómo llegar a algún sitio en transporte público verás las horas de salida de cada tren con una exactitud pasmosa. Supongo que eso es algo que se puede conseguir teniendo el mantenimiento adecuado del sistema y con disciplina. Algo que deberíamos copiar los demás.

La limpieza en las calles

Creí que era un mito, pero no, no hay papeleras en las calles de las ciudades que he visitado. Aún así, estas están completamente limpias, ni colillas (está prohibido fumar en la calle), ni papeles, ni nada de nada. Hay unas pocas papeleras para botellas y latas al lado de algunas máquinas de vending o, en otro caso, en las tiendas de conveniencia (aunque queda un poco raro entrar en una tienda solo para tirar basura). No me puedo explicar cómo es posible que los japoneses sean tan respetuosos con el tema de las basuras (algunos turistas no lo son tanto, pero son pocos)

El uso de las bicicletas

Este no es un punto positivo, más bien lo contrario, aunque en Japón se usan mucho las bicicletas, parece que los carriles bici no tienen mucho éxito y hay mucha gente por las aceras circulando en bicicletas y es muy difícil esquivarlas si te vienen por detrás. Quizá no teníamos muy interiorizadas las reglas para circular por las aceras (ellos circulan por la izquierda y se ponen en ese lado de las escaleras igualmente), pero es un poco caos cuando hay varias bicicletas a distintas velocidades circulando por tu misma acera. Es loable que usen este medio de transporte tan a menudo, pero hay que mejorar un poco la forma en que lo hacen.

El silencio en los transportes

En España ir en metro supone meterse en un guirigay de sonidos variados, gente hablando, móviles sonando, pedigüeños molestando. En Japón NADIE habla en el transporte público, menos aún en los días de diario. Si alguien está hablando será un turista despistado o que estamos en día festivo y estamos en un tren hacia un destino turístico. La verdad es que se agradece estar en medio de una multitud y no oir ni una mosca.

Las excursiones escolares

Si, igual es una tontería, pero cuando estuvimos en Nara y en Kyoto vimos muchísimos escolares que iban de excursión sin supervisión (o al menos ninguna que nosotros viésemos). Chicos de 12 y menos años visitando los sitios turísticos a su bola y volviendo a los autobuses sin que nadie tuviese que estar detrás de ellos diciéndoles lo que tenían que ver o no. Es cierto que los Japoneses hacen que sus hijos vayan solos al colegio y que tengas una autonomía propia desde muy jóvenes, pero es algo que me choca mucho con lo que se ve en nuestro país.

Todavía me quedan muchas cosas que contar sobre esto, pero como aperitivo lo dejo aquí, no sea que se me olvide… Iremos actualizando.

De puertas traseras y software libre

Posted on por
Responder

Es casi imposible que no hayas oido hablar del backdoor xz, no es que yo pueda darte más información sobre el tema, os dejo un video de alguien que os cuenta el caso completo como si de un episodio de serie negra se tratase:

El caso es que, alguien durante tres años ha ido infiltrándose en un repositorio de un elemento pequeño pero crítico de software libre llamado xz, de tal manera que consiguió, no solo quedarse como mantenedor de ese repositorio sino que fue introduciendo, poco a poco, una puerta trasera que permitía el acceso remoto (todavía hay que ver el payload real lo que llegaba a hacer) y conseguir que ese backdoor se distribuyese en algunas de las más importantes distribuciones.

Por suerte, o mejor dicho, por la misma estructura del software libre, esta versión no pasó de las versiones inestables de las distribuciones y se descubrió el pastel porque una persona notó que algo iba más lento de lo que debía después de la actualización. Esta persona (Andres Freund) no se paró en medir el tiempo de respuesta sino que terminó encontrando la causa subyacente y la puerta trasera que habían metido (aquí el aviso que dió a la comunidad) y, obviamente, la reacción de los mantenedores de la distribución, e incluso del antiguo mantenedor del repositorio fue inmediata y reliminó todas las trazas del código dañino.

Hay varias cosas que podemos destacar, pero yo me quedo con un par de ellas:

  1. La dependencia que tenemos de código que han escrito terceros y que pueden estar bien mantenidos o no (dependiendo del ánimo de esa persona o de sus circunstancias personales)
  2. La potencia del ecosistema open source para descubrir y arreglar este tipo de problemas. Todos los sistemas operativos actuales, desde mac os hasta windows usan componentes externos, no hay ninguno 100% original y tampoco es que se pueda saber qué es lo que usan exactamente. Si hay un backdoor en windows o en macos nos lo tendremos que comer con patatas porque nadie puede mirar lo que hay dentro.

Estoy seguro de que esta forma de actuar, por muy inteligente y paciente que sea, no deja de ser un ataque en toda regla con unas finalidades seguramente malvadas (crear una botnet inmensa, por ejemplo) y no creo que sepamos realmente quien está detrás de ello y, posiblemente, nos de para una docuserie de Netflix un día de estos.

En fin, no ha pasado nada, todo está en orden de nuevo y lo malo es que nos deja un regusto amargo y hace bajar un peldaño la confianza que teníamos en el ecosistema (pero no mucho, oye, que seguimos estando a salvo).