¿Cuándo dejan de ser útiles las computadoras?

Desde la irrupción de las computadoras personales allá en la década de 1970 todo ha sido vértigo, y una generación computadoras ha sido sustituida por la siguiente casi sin respiro desde entonces, generando una pila de deshechos proporcional a la velocidad de la evolución tecnológica y a la necesidad de ventas de los fabricantes.

Por lo tanto, llegados a este punto, debemos preguntarnos si tenemos que deshacernos tan rápidamente de nuestros aparatos, o podemos darle uso por un tiempo más prolongado del que dicta la moda.

En este sentido hoy les dejo un video que hice ayer (22 de julio de 2021) donde muestro mi viejo Celeron 2.66 GHz y 1GByte de Ram funcionando como en los mejores tiempos, a pesar de que tiene unos 15 años de antigüedad.

Les dejo un gran saludo, espero animarlos a poner en práctica aquella máxima de las tres «R»: Reducir, reciclar, reutilizar. Por supuesto, los comentarios son bienvenidos 😉

Smartphone como GNU/Linux webcam

Motivación

Luego de usar mi Lenovo N500 por más de diez años, nunca me preocupé de hacer funcionar la cámara web integrada, y ya con la pandemia y la avalancha de video reuniones encima, descubrí que el driver para GNU/Linux (Debian 10 en mi caso) no funcionaba. Y al mismo tiempo, las aplicaciones usuales para reuniones (ZOOM / Google Meet) ya pesan bastante para mi vieja notebook, así que consideré usar una PC de escritorio que tenía disponible, y que es un poco más nueva. Sin embargo, esta PC, no tiene cámara web.

Con esto en mente, las alternativas eran:

1. Trabajar para lograr que funcione la cámara web integrada en la notebook.
2. Comprar una cámara web externa
3. Usar una cámara digital como cámara web,

La primera alternativa, se descartó por dificultosa. La segunda se descartó por el costo: una cámara web acá (Argentina) cuesta unos $5000, que representa más del 25% de la mensualidad de un jubilado, lo que es un precio considerable. Así que se exploró la tercera opción.

Créditos

Los teléfonos inteligentes que quedan en desuso casi nuevos son tan abundantes que nos dejan piezas de tecnología muy versátiles y poderosas a costo casi cero y todos tienen por lo menos una buena cámara digital. Después de una breve búsqueda en internet aparecieron varias soluciones que implementaban cámaras web usando teléfonos celulares. En especial estos dos vínculos

https://www.atareao.es/software/video/utiliza-tu-android-como-webcam-en-ubuntu/

https://github.com/bluezio/ipwebcam-gst/

El primer vínculo realmente refiere al segundo y siguiendo las instrucciones que da, se puede instalar un smartphone como cámara web en un sistema GNU/Linux. En el segundo link aparece el «driver para Linux», que en realidad es un gran trabajo que ha hecho Antonio García Domínguez, el autor, escribiendo dos scripts de shell que instalan y combinan software ya existente para que todo funcione. Esto demuestra la potencia y versatilidad de GNU/Linux como sistema capaz de adaptarse a usos peculiares y la potencia del software libre que además de proveer herramientas poderosas nos deja la información al alcance de la mano para que quién quiera aprender pueda hacerlo. A continuación muestro una implementación simplificada del trabajo de Antonio, hecha con dos cosas en mente

1. Aprender para poder explicar el proceso
2. Poder usar otras aplicaciones de cámara que la que muestra el trabajo original. Ya veremos de qué se trata.

La idea

La idea es tomar el streaming de la cámara, que normalmente saldría por la interfase de red, y redirigirlo al puerto USB para evitar demoras, y enviarlo a la PC. Ya en la computadora, de nuevo se redirecciona a la interfase loopback (que siempre tiene la dirección 127.0.0.1 ó localhost) desde donde se vuelve a tomar el streaming para procesarlo y enviarlo al dispositivo /dev/video0, lugar que lo hará disponible para cualquier aplicación como si se tratara de un dispositivo de captura convencional

El esquema propuesto en el trabajo de Antonio para usar el teléfono cómo cámara es el siguiente

Lo que es cada cosa…

Cámara y streaming en android

Este planteo requiere correr en el dispositivo android una aplicación que tome el video que produce la cámara y que genere el streaming que se quiere transmitir. Hay varias aplicaciones que hacen eso. Antonio propone usar IP-webcam, y de hecho, es obligatorio usarla para utilizar su script, pero no es una aplicación libre. Lamentablemente, buscando en F-droid (que es un repositorio de software libre para android), si bien hay algunas aplicaciones de este tipo, no funcionan adecuadamente o no trabajan completamente sobre http, cuestión aparentemente insalvable en este esquema de trabajo, como veremos después.

Finalmente, se decidió usar #LiveDroid, porque aunque no es software libre, es relativamente pequeña (5,8 MB), funciona completamente sobre http y no contiene ni anuncios ni compras integradas. Se puede instalar desde Google Play, como indica el link mostrado recién. Agradezco a su autor Akshay Chopde por esta amigable y eficaz aplicación.

Normalmente estas aplicaciones hacen el streaming sobre la red en la dirección IP del teléfono, de manera que si nos conectamos a la misma red podemos acceder al video desde un navegador. Por ejemplo, si el teléfono está conectado a un access point con la dirección 192.168.1.20 y nuestra computadora está conectada al mismo access point con la dirección 192.168.1.5, si ponemos http://192.168.1.20:puerto/algo en la computadora, podremos ver la imagen que está tomando la cámara del teléfono por intermedio de la red local.

Por lo general, puerto es 8080, y comunmente se puede configurar desde la aplicación. Una relativa dificultad es conocer qué es algo en la dirección de arriba, porque en general debemos tener la dirección completa para acceder al streaming de la cámara. Para el caso de IP-webcam se puede usar el url http://ip_del_telefono:puerto/videofeed según el trabajo de Antonio.

Para #LiveDroid es http://ip_del_telefono:puerto/?action=stream cosa que se descubrió analizando el flujo de datos con wireshark, que es un excelente analizador de flujos de red libre con una utilidad superlativa. Es probable que descubrir el url completo sea el paso clave que permita adaptar otras aplicaciones de cámaras que hacen streaming para que funcionen con GNU/Linux. Como veremos más adelante, al final se usa la dirección 127.0.0.1 (localhost) para acceder a la cámara, así que se apunta wireshark hacia allí, y con un poco de suerte, se puede verificar el url donde la aplicación sube el streaming.

Software de redirección en Android y en GNU/Linux

Existe un software llamado adb por Android Debug Bridge, que permite hacer cosas asombrosas. Si ya está instalado, se puede consultar información al respecto tecleando man adb desde la consola. Y si no está instalado, es imprescindible instalarlo usando apt o synaptic. Desde la consola podemos instalarlo poniendo

$apt-get install adb

adb tiene tres partes: un servidor que corre en segundo plano en la máquina GNU/Linux y un demonio que se ejecuta también en segundo plano en el dispositivo android. Finalmente, hay un cliente que también se ejecuta en la computadora GNU/Linux.

La idea es que los clientes nos permiten enviar comandos al servidor local para luego enviarlos al demonio remoto en el dispositivo.

Usaremos adb para redirigir el tráfico de la interfase de red del teléfono hacia el puerto USB. Para hacer esto tenemos que hacer dos cosas.

1. En el dispositivo android, habilitar primero el modo de desarrollador y luego habilitar el modo de depuración por USB. Esto permitirá al demonio adb redirigir el tráfico tcp y otras cosas.
2. Luego, desde la consola, tipear

$adb forward tcp:8080 tcp:8080

Con lo cual se hace el reenvío de los paquetes tcp entre el puerto 8080 en la máquina GNU/Linux con el puerto tcp 8080 del dispositivo android. Volveremos sobre esto más adelante con más detalle.

El modo de desarrollador puede estar habilitado en el dispositivo android, o quizá sea necesario habilitarlo. Para hacerlo, por lo general hay que ir a Ajustes -> Acerca del teléfono -> Información de Software -> Número de compilación y golpear 7 veces en esa última opción. Luego de esto, deberá aparecer la opción Ajustes -> Opciones del desarrollador y dentro, deberemos habilitar la opción Depuración de USB.

GStreamer

GStreamer es un software de procesamiento de audio y video que permite separar la complejidad del procesamiento del streaming de la aplicación que finalmente muestra esos datos.

GStreamer se basa en tuberías que es un concepto muy usado en sistemas tipo UN*X y consiste en la idea de que un flujo de datos (stream) puede ser la entrada de un programa que lo procesa, dando una salida que a su vez se puede usar como entrada de otro programa y así sucesivamente. En el caso de GStreamer, el operador que conecta la tubería, es decir, la salida de un programa con la entrada del siguiente, es » ! «.

En la figura de abajo se muestra este concepto, en donde el origen de datos se llama source (fuente) y el destino recibe el nombre de sink (sumidero). (Las dos figuras siguientes se han tomado de https://es.wikipedia.org/wiki/GStreamer, lugar en donde se puede encontrar una muy buena explicación sobre GStreamer)

Para instalar gstreamer en Debian GNU/Linux (según la página oficial de gstreamer) ponemos

$apt-get install libgstreamer1.0-0 gstreamer1.0-plugins-base  gstreamer1.0-plugins-good gstreamer1.0-plugins-bad  gstreamer1.0-plugins-ugly gstreamer1.0-libav gstreamer1.0-doc  gstreamer1.0-tools gstreamer1.0-x gstreamer1.0-alsa gstreamer1.0-gl  gstreamer1.0-gtk3 gstreamer1.0-qt5 gstreamer1.0-pulseaudio

v4l2loopbak

Un dispositivo de video real constituye un punto en dónde se puede tomar una señal de streaming proveniente de un dispositivo de captura real, como por ejemplo, una cámara de video física conectada a la computadora. Por el contrario, un dispositivo de video virtual, toma su streaming de otra fuente, pero la hace disponible a cualquier aplicación de la misma forma que uno real. en nuestro caso, esta característica resulta muy conveniente y se logra utilizando el módulo v4l2loopback.

Bajo Debian, este módulo puede venir para construir en formato dkms como directamente en formato binario y se puede instalar usando tanto apt como synaptic.

Si elegimos usar el que viene para construir con dkms, hay que prestar atención a un asunto muy importante: la versión de este módulo debe coincidir con la versión del kernel que correrá cuando hemos de cargarlo. Es sencillo, pero es algo que hay que resolver a mano, porque ni el script de Antonio ni los programas de instalación lo resuelven de manera automática. Una forma de asegurarse de esto es usar synaptic y mirar la versión de kernel que figura al final del nombre del paquete v4l4loopback, para luego buscar las imágenes (linux-image-*) y verificar que coincida con la versión que también aparece al final del nombre del archivo de la imagen del kernel. Si la imagen no es la activa, sencillamente instalamos la que nos hace falta y la elegimos desde el menú de inicio cuando la computadora arranque la próxima vez.

Por ejemplo, si nuestro paquete es v4l2loopback-modules-4.9.0-13-686-pae, entonces, tendremos que instalarlo junto con la imagen del kernel que viene en linux-image-4.9.0-13-686-pae.

Para este caso, desde la consola habría que teclear, como root

$apt-get install v4l2loopback-modules-4.9.0-13-686-p linux-image-4.9.0-13-686-pae

Ahora tenemos que construir e instalar el módulo con module-assitant, de tal manera que si no está instalado, hay que instalarlo. Siempre como root, desde la terminal ponemos

$apt-get install module-assistant

Una vez instalado el asistente para la construcción de módulos, lo usamos para construir e instalar el módulo que nos interesa

$ module-assistant auto-install v4l2loopback

Esto iniciará un proceso de compilación e instalación que culminará con nuestro módulo disponible. La ventaja de este método sobre el clásico make install es que el sistema lleva la cuenta de que el módulo se instaló y lo considera para futuras dependencias.

Si por el contrario, instalamos el binario, hacemos directamente podremos instalarlo (como root) tecleando en la terminal

$ apt-get install v4l2loopback-dkms

Una vez instalado por cualquiera de los dos métodos, el módulo queda disponible para cargar poniendo, como root

$modprobe -v v4l2loopback

Y si no hay errores, ya tendríamos que tener nuestro /dev/video0 listo para usar.

Ponemos todo junto…

En este punto ya se puede unir todo, con el siguiente esquema

1. Conectamos el teléfono con #LiveDroid instalado a la computadora mediante un cable USB. En mi caso usé un viejo y pequeño LG20. Para verificar que está bien conectado podemos teclear, como root, desde la terminal

$ adb devices -l
 List of devices attached
 * daemon not running; starting now at tcp:5037
 * daemon started successfully
 LF5SP7AIHIRG8DVO       unauthorized usb:2-5 transport_id:1 d:1 
$

Al ingresar este comando, en el teléfono debe aparecer algo como esto

Pantalla del LG 20 al ser conectado mediante adb

Esa es una reacción de seguridad del teléfono, así que debemos contestar «ok» para poder conectar el teléfono. Si vamos a usar siempre la misma computadora, también podemos tildar la casilla y ya no nos va pedir nada la próxima vez que nos conectemos al teléfono.

Si esto no sucede, se puede matar al servidor adb en la computadora y volver a intentarlo. Por ejemplo

$ps -C adb
   PID TTY          TIME CMD
 28244 ?        00:03:15 adb
$kill 28244

Esto mataría al servidor adb para poder volver a intentar.

Retomando, si apretamos «ok» en el teléfono, ya podremos conectarnos

$adb devices -l
 List of devices attached
 LF5SP7AIHIRG8DVO       device usb:2-5 product:luv20ss_global_com model:LG_D100 device:luv20ss transport_id:1

Notar que ha desaparecido la palabra unauthorized de la salida del comando, lo cual significa que podremos conectarnos.

2. Ahora redireccionamos el puerto tcp 8080 del dispositivo android al puerto tcp 8080 de la computadora GNU/Linux. Esto significa que los datos que las aplicaciones del teléfono envíen a ip_telefono:8080 aparecerán en 127.0.0.1:8080, y habrán viajado por el cable USB, no por el WiFi. Usamos el comando adb forward tcp:puerto_local tcp:puerto_remoto, que en realidad permite redireccionar dos puertos cualquiera de los dos lados. El comando es

$ adb forward tcp:8080 tcp:8080

(Si da error, verificar la conexión con el teléfono: si no permitimos siempre la depuración desde esta computadora en la pregunta que nos hizo el dispositivo antes, tendremos que autorizar de nuevo la conexión)

3. Ahora hay que cargar el módulo v4l2loopback para tener disponible nuestro dispositivo de video /dev/video0

$ /sbin/modprobe -v v4l2loopback
 insmod /lib/modules/4.19.0-6-686-pae/kernel/drivers/media/v4l2-core/v4l2-common.ko 
 insmod /lib/modules/4.19.0-6-686-pae/updates/dkms/v4l2loopback.ko 

4. Ahora ejecutamos gstreamer para habilitar el procesamiento y redirección del streaming

$ gst-launch-1.0 souphttpsrc location=http://localhost:8080/?action=stream do-timestamp=true is-live=true ! queue ! multipartdemux ! decodebin ! videoconvert ! video/x-raw,format=YUY2 ! v4l2sink device=/dev/video0 sync=false

5. Si no hubo errores, ya podemos intentar ver lo que está capturando la cámara del teléfono. Una alternativa es teclear lo siguiente en la consola

$ webcamoid /dev/video0

Veremos aparecer webcamoid y si apretamos play tendría que aparecer en vivo la imagen que captura nuestro dispositivo

El teléfono funcionando como webcam

En síntesis…

Una vez que tenemos todo el software instalado, cada vez que queremos habilitar la cámara sólo tenemos que ingresar tres órdenes para habilitar la cámara

$ adb forward tcp:8080 tcp:8080
$ /sbin/modprobe -v v4l2loopback
$ gst-launch-1.0 souphttpsrc location=http://localhost:8080/?action=stream do-timestamp=true is-live=true ! queue ! multipartdemux ! decodebin ! videoconvert ! video/x-raw,format=YUY2 ! v4l2sink device=/dev/video0 sync=false

Luego de esto, la cámara debería estar disponible, como se muestra en el video que sigue

Como una forma de hacerlo más simple, puse esos tres comandos juntos en un pequeño script llamado webcam.sh: se puede bajar, hay que hacerlo ejecutable y correrlo cada vez que se necesite usar la cámara web. El archivo se puede bajar desde acá.

Si no se quiere cambiar los permisos al archivo, se lo puede ejecutar poniendo, como root:

$ bash webcam.sh

Conclusión

Se presentó una manera sencilla y económica de agregar una cámara web a una computadora GNU/Linux: no se gasta un céntimo, se hace todo con lo que hay a mano, y se da nuevo uso a celulares que de otro modo terminarían en la basura. Y por si fuera poco se aprenden cosa nuevas.

Por supuesto, cualquier comentario, corrección o ampliación de este trabajo es bienvenida. En especial sería muy agradable que alguien acerque el dato de una aplicación libre de cámara web para ejecutar en el teléfono, que fue el único software propietario que no se pudo evitar usar.

Realtek se8192se bajo GNU/Linux

Al instalar el nuevo Debian 10 Buster en una muy antigua computadora del programa Conectar Igualdad vi que como era de esperar, el sistema funcionó perfectamente y con excelente performance, haciendo que una máquina que estaba extremadamente lenta y colapsada volviera a ser útil. Así es de amistosa la última y más actual versión de Debian con el hardware antiguo. Sin embargo, la computadora no se lograba conectar por WiFi, a pesar de detectar correctamente las redes inalámbricas.

El módulo correspondiente estaba presente (rtl8192se), el paquete de firmware (paquete firmware-realtek) también estaba instalado e incluso la interface de red aparecía en el sistema. Lo más probable es que fuese un problema en la configuración del módulo rtl8192se. Luego de un par de días de investigaciones y pruebas, encontré la punta de la solución (en este link) y todo se solucionó haciendo lo siguiente, siempre como usuario root:

crear el archivo /etc/modprobe.d/rtl8192se.conf con un editor de texto. Me gusta usar ‘joe’ para estas cosas así que la orden sería

joe /etc/modprobe.d/rtl8192se.conf

y luego, dentro del archivo ponemos

options rtl8192se fwlps=N ips=N swlps=N swenc=Y aspm=0 disable_watchdog=1

Guardamos el archivo, descargamos y volvemoa a cargar el módulo (modprobe -r rtl8192se; modprobe -r rtl8192se) y todo debería andar. También se podría reiniciar la máquina para comprobar que funciona.

Comandos para tener a mano en circunstancias como esta

• modprobe
• hwinfo
• modinfo
• iwconfig
• lsmod

Saludos y espero que haya servido. Por supuesto, los comentarios son bienvenidos.

Teclado para PC con Arduino

La idea de este proyecto es construir un dispositivo (con un Arduino Uno) que, por un lado, sea reconocido por la PC como un teclado, y que por el otro tenga conectados unos pulsadores, de tal manera que al presionar alguno de estos, la computadora interprete que se ha presionado una tecla.

Por supuesto, existen varias formas de hacer esto. Sin embargo, la aproximación propuesta por Michael J. Mitchell es especialmente interesante por la facilidad con la que puede ser llevada a la práctica. Veamos de qué se trata.

Un poco de teoría

El USB es mucho más que solo un enchufe en el gabinete de nuestro PC: es un protocolo completo de comunicaciones, comparable a protocolos de red por ejemplo. Esta complejidad tiene dos efectos. Uno, hace posible la «magia» que ve el usuario que al conectar un periférico a la computadora, funcione automáticamente. Dos, que el diseñador o programador de un sistema tenga que lidiar con las complejidades sustanciales del protocolo, incluso para tareas sencillas.

Para solventar estas dificultades existen por lo menos dos enfoques, uno por hardware y otro por software. Por hardware existen circuitos integrados que de un lado permiten conectarse a la PC mediante el puerto USB, mientras que del otro lado ofrecen una interfase serie mucho más simple, como la RS232. Por software, existen librerías para hardware específico que facilitan la implementación de la comunicación por USB en esa plataforma específica.

En el caso del Arduino Uno, se usan dos procesadores: el ATmega328 es el procesador principal (el que se programa con la IDE de Arduino) y se delega la tarea de comunicación USB en el ATmega16U2 al que le carga un programa específico para ese fin. Es ese programa el que hace posible que cuando se conecta la placa a la PC sea reconocida como un Arduino. Por lo tanto, si en el ATmega16U2 se escribe el programa apropiado, se puede lograr que al conectar la placa a la computadora esta sea reconocida como un teclado u otro dispositivo de entre todos los previstos en la especificación USB. Afortunadamente, el ATmega16U2 se puede programar directamente desde la PC mediante un protocolo llamado DFU (Device Firmware Update) que lo único que requiere es un puerto USB disponible.

Manos a la obra…

Descarga del programador

Antes de comenzar es necesario instalar en la PC el programador que permite manejar el protocolo DFU. En el caso de GNU/Linux se escribe desde la terminal

sudo aptitude install dfu-programmer

Sí se está usando Windows se puede descargar el programa desde Atmel.

Reseteo de la placa

Ahora conectamos nuestra placa Arduino Uno a la PC como de costumbre y reseteamos el ATmega16U2 puenteando los dos pines marcados en rojo en la foto de abajo

Una vez hecho esto, el ATmega16U2 queda reseteado, y la PC ya no reconoce el Arduino UNO como tal. Para comprobarlo se puede desconectar y reconectar la placa, y luego pedir un listado de los dispositivos usb conectados. En GNU/Linux esto se puede hacer con el comando lsusb tipeado desde la terminal

lsusb

Escritura del firmware en el ATmega16U2

Ahora necesitamos descargar los firmawares apropiados para el ATmega16U2. Necesitaremos dos: uno el original del Arduino y otro el que nos permita emular el teclado

Firmware del Arduino Uno (Arduino-usbserial-uno.hex)

Firmware teclado USB (Arduino-keyboard-0.3.hex)

Podremos resetear la placa y subir con el programador uno u otro según nos haga falta.

Para restaurar el firmare original de Arduino, reseteamos la placa y desde la terminal hacemos

dfu-programmer atmega16u2 erase
dfu-programmer atmega16u2 flash –debug 1 Arduino-usbserial-uno.hex
dfu-programmer atmega16u2 reset

Para escribir el firmware del teclado, reseteamos la placa y desde la terminal hacemos

dfu-programmer atmega16u2 erase
dfu-programmer atmega16u2 flash –debug 1 Arduino-keyboard-0.3.hex
dfu-programmer atmega16u2 reset

Ciclo de desarrollo

El ciclo de desarrollo para escribir y probar una aplicación sería más o menos así:

1. Reseteamos el ATmega16U2; conectamos y reconectamos el Arduino a la placa
2. Escribimos el firmare de Arduino en el ATmega16U2 con el programador «dfu-programmer» como se explicó
3. Subimos el «sketch» que estamos desarrollando de la manera usual, usando la IDE de Arduino.
4. Reseteamos el ATmega16U2; conectamos y reconectamos el Arduino a la placa
5. Escribimos el firmare del teclado en el ATmega16U2 con el programador «dfu-programmer» como se explicó
6. Hacemos las pruebas que creamos convenientes, y volvemos a ejecutar el punto 1) si fuese necesario.

«Sketch» de ejemplo

Acá dejo un pequeño «sketch» de ejemplo que hace que  unos pulsadores conectados a las entradas digitales de un Arduino Uno sean interpretados por la PC como teclas. Para cargarlo en la placa debemos asegurarnos que el firmware del Arduino Uno esté cargado en el ATmega16U2, tal y como se explicó. Abajo está el código fuente, pero se puede descargar directamente el archivo desde acá.

// Basado en https://github.com/nylen/auto-f1-presser/blob/master/auto-f1-presser.ino

/*
* teclado-usb.ino
*
* Copyright 2018 Julian R. Perez Knulst <julianperezknulst@gmail.com>
* Web site: http://www.equisye.tk
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*
*
*/

/* Buffer de reporte de teclado. Definido en el estándard USB */
uint8_t buf[8] = {
0 };
// Definimos los pines que se usarán. Los pulsadores van conectados
// entre cada pin y masa.
#define PIN_TECLA_00 5
#define PIN_TECLA_01 6
#define PIN_TECLA_02 7

// Definimos los códigos de técla. Estos códigos se definen
// en el documento
// https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf
#define COD_TECLA_00 0x04
#define COD_TECLA_01 0x05
#define COD_TECLA_02 0x06
int state = 1;

void setup()
{
Serial.begin(9600);
pinMode(PIN_TECLA_00, INPUT);
pinMode(PIN_TECLA_01, INPUT);
pinMode(PIN_TECLA_02, INPUT);
pinMode(LED_BUILTIN, OUTPUT);
// Hablito los pull-ups internos
digitalWrite(PIN_TECLA_00, 1);
digitalWrite(PIN_TECLA_01, 1);
digitalWrite(PIN_TECLA_02, 1);
digitalWrite(LED_BUILTIN, LOW);

delay(200);
}

void loop()
{
state = digitalRead(PIN_TECLA_00);
if (state != 1) {
buf[2] = COD_TECLA_00; // Código letra A
Serial.write(buf, 8); // Envío tecla
releaseKey();
//titilar();
}

state = digitalRead(PIN_TECLA_01);
if (state != 1) {
buf[2] = COD_TECLA_01; // Código letra B
Serial.write(buf, 8); // Envío tecla
releaseKey();
//titilar();
}

state = digitalRead(PIN_TECLA_02);
if (state != 1) {
buf[2] = COD_TECLA_02; // Código letra C
Serial.write(buf, 8); // Envío tecla
releaseKey();
//titilar();
}
}

void releaseKey()
{
// Suelto tecla
buf[0] = 0;
buf[2] = 0;
Serial.write(buf, 8); // Release key
delay(300);
}

void titilar() {
digitalWrite(LED_BUILTIN, HIGH);
delay(200);
digitalWrite(LED_BUILTIN, LOW);
delay(200);
}

Luego que cargamos esto en el Arduino Uno, reseteamos la placa y cargamos en el ATmega16U2 el firmware del teclado, como se explicó antes. Una vez hecho esto y conectados los pulsadores a los pines indicados, se podrá probar la aplicación, y al accionar los pulsadores se verán aparecer las letras correspondientes el programa que tenga el foco en la PC (aquel programa que esté recibiendo datos del teclado en este caso.)

Los códigos de las teclas

Los códigos de las teclas se pueden encontrar en el documento Universal serial bus HID usage tables  alrededor de la página 55.

Conclusiones

Es un método excelente para usar cada vez que sea necesario comunicarse con la PC emulando un teclado: es sencillo, económico, y no se necesita instalar ningún driver del lado de la PC.

Referencias

http://mitchtech.net/arduino-usb-hid-keyboard/

https://github.com/nylen/auto-f1-presser

https://www.arduino.cc/en/Hacking/DFUProgramming8U2

Instalar Qucs/ADMS/qucsator en Debian

Qucs es un simulador de circuitos electrónicos para GNU/Linux que lamentablemente no tiene un paquete para Debian, de modo que para instalarlo hay que recurrir al viejo método de compilarlo a partir de las fuentes. Para Qucs en sí, hay que seguir las instrucciones para Debian que dan los propios creadores. Sin embargo, se necesita instalar ADMS y el programa de simulación (una especie de SPIECE) llamado qucsator para que se puedan realizar las simulaciones.

Instalación de Qucs

Primero, obtener las fuentes. Desde una consola ponemos

cd
mkdir git; cd git
git clone git://git.code.sf.net/p/qucs/git qucs

Al momento en que yo hice la descarga de las fuentes, le faltaba el archivo autogen.sh, de modo que hay que buscarlo y ponerlo en

~/git/qucs/qucs

porque si no, no compila. El archivo se puede encontrar usando la opción «Find file» de la página https://github.com/Qucs/qucs  . El archivo aparece en el vínculo https://github.com/Qucs/qucs/blob/develop/contrib/ubuntu-debian/qucs-doc/autogen.sh de modo que hay que descargarlo usando la opción ‘Raw’ y grabarlo en el lugar indicado (se puede hacer copiando y pegando en un editor como el notepad y grabándolo luego)

Ahora, como root, instalamos los paquetes necesarios para cumplir con las dependencias

apt-get install libxml2 libxml2-dev zlib1g zlib1g-dev
cpan -i XML::LibXML
apt-get install libgd2-xpm-dev
apt-get install libgd-perl

Finalmente compilamos

  cd ~/git/qucs/qucs
  sh autogen.sh
  ./configure --enable-maintainer-mode --prefix=/home/$(whoami)/local/qucs/
  make install

Esto va a tardar un buen rato. Si todo anduvo bien, se puede testear el programa poniendo

  export QUCSDIR=/home/$(whoami)/local/qucs
  ~/local/qucs/bin/qucs

y deberíamos ver aparecer la interfase del programa.

Instalación de ADMS

Buscamos las fuentes en https://sourceforge.net/projects/mot-adms/files/adms-source/2.3/adms-2.3.6.tar.gz/download y seguimos las instrucciones:

Completamos las dependencias, como root

apt-get install build-essential
apt-get install automake libtool gperf flex bison
apt-get install libxml2 libxml2-dev
apt-get install libxml-libxml-perl
apt-get install libgd-perl

Descomprimimos las fuentes en, por ejemplo ~/git/ADMS (para poder instalarlo se debe ejecutar esto como root, por lo menos el ‘make install’)

tar xvfz adms-x.x.x.tar.gz
cd adms-x.x.x
./configure 
make install

Y, finalmente

export LD_LIBRARY_PATH=/usr/local/lib

(Sin este paso, no se puede compilar qucsator porque da error ).

Compilar qucsator

Las fuentes de qucsator ya vienen con la descarga de qucs hecha al principio, sólo hay que ir al directorio qucs-core y compilar (como root, para que la instalación sea posible)

cd qucs-core
./configure
make
make install

Después de todo esto, la instalación debería ser funcional y permitir la simulación de circuitos ;-).

 

 

 

 

 

Configurar el teclado en GNU/Linux

Suponiendo Debian Linux, se deben tocar los paquetes

keyboard-configuration : Configuración del teclado para todo el sistema

console-common : distribución del teclado en el arranque

console-data : datos para las herramientas de consolas

console-setup: ajusta la consola de texto de las X al mismo tiempo

Los paquetes se instalan con

apt-get install paquete

y se van configurando a medida que se van instalando, o sí ya están instalados, se vuelven a configurar con

dpkg-reconfigure paquete

Finalmente, luego de configurar, sí se está usando un teclado USB, hay que desconectarlo y volverlo a conectar para que los cambios tengan efecto.

 

Compilar mkspiffs para Linux

La placa WeMos D1 está basada en el microcontrolados ESP8266 y tiene 4 Mbytes de flash (la página del fabricante se puede consultar acá). Esta memoria no volátil se puede usar ya sea sólo para grabar nuestro programa, o bien fraccionarla como si fuera un disco y usar parte de ese espacio para guardar datos diversos. Estos datos pueden ser desde páginas web, calibración de sensores o certificados y claves de seguridad. El sistema de archivos que se construye sobre esta memoria se llama spiffs (SPI Flash File System, más información acá ).

Tanto la configuración de la memoria como la carga de datos se puede hacer desde la ide de arduino : Primero se elige el tamaño que se va a destinar para el sistema de archivos (Herramientas -> Flash Size) y luego se pueden cargar los datos (Herramientas  -> ESP8266 Sketch Data Upload). En cuanto al tamaño hay dos opciones: 3 MB para programa y 1 MB para datos, o al revés. Respecto a los datos, se cargan aquellos archivos que se hayan colocada en un subdirectorio llamado ‘data’ en el directorio del sketch actual.

Dicho esto, el caso fue que cuando quise subir mis datos obtuve un error del tipo

SPIFFS Create Failed!

Investigando un poquito, resulta que la ide en realidad usa un programa llamado mkspiffs para subir los archivos a la flash del la placa, a través de un plugin. Las instrucciones para instalar el plugin están en el vínculo anterior, pero se reducen básicamente a descargar el archivo .jar y copiarlo en la ruta que corresponde, así que lo hice, pero el error persistió, aunque me dio la pista de que el problema se hallaba en el mkspiffs, ya que no encontraba una librería. Por lo tanto, había que reinstalarlo partiendo del código fuente para que se adapte a las librerías que tenía en mi sistema.

Primero hay que clonar el repositorio en nuestro directorio ‘home’ (eso es muy importante para no tener problemas con los permisos de acceso)

git clone https://github.com/igrr/mkspiffs

Luego, entramos al directorio ‘mkspifss’ y sincronizamos para que no falte ningún archivo (antes de hacer este paso me faltaba ‘spiffss.h’ 😉 )

cd mkspiffs

git submodule update –init

Ahora ya podemos compilar

make dist

Y con eso deberíamos, después de un ratito que tarda la compilación tener el ejecutable ‘mkspiffs’ en el directorio en que compilamos. Lo que queda es copiarlo a la ruta correcta para que lo encuentre la ide de arduino,  debe ser algo como

~/arduino-1.8.4/hardware/esp8266com/esp8266/tools/mkspiffs/

Sencillamente se borra la versión vieja, se copia la nueva y ya debería funcionar correctamente.

Espero sirva a quien lo necesite. Por supuesto, cualquier comentario es bienvenido,

Error arduino: avrdude: ser_open(): can’t open device «/dev/ttyACM0»

Este error se origina al tratar de subir un programa a la placa sin contar con los permisos necesarios para escribir en el puerto usb. La forma de solucionarlo es agregar el usuario al grupo que puede escribir en el puerto (por lo general el grupo ‘dialout’)

Buscamos qué grupo puede escribir en el puerto en cuestión con el comando ls -l

 

root@mini:/home/luck# ls -l /dev/ttyACM*
crw-rw—- 1 root dialout 166, 0 sep 4 09:02 /dev/ttyACM0

Vemos que efectivamente el grupo es ‘dialout’. Si el usuario es ‘luck’ escribimos

root@mini:/home/luck# usermod -a -G dialout luck

Ahora hay que cerrar la sesión de ‘luck’ o del usuario de que se trate, y volver a entrar para que la modificación surta efecto.

(Esta es la fuente consultada)

Clonar un CD/DVD desde la consola de GNU/Linux

Con ‘clonar un CD/DVD’ se quiere decir realizar una o más copias de uno de estos discos partiendo de un original.

Para ello primero se debe hacer la imagen del disco original con el comando ‘dd’

root@mini:# dd if=/dev/cdrom of=imagen.iso

Por supuesto, el dispositivo de entrada (indicado con ‘if’ en el comando de arriba) puede ser también ‘/dev/dvd’ sí se está copiando un DVD.

Sí la imagen que se está copiando es de un DVD se la puede grabar con el comando

root@mini:# growisofs -dvd-compat -Z /dev/dvd=imagen.iso

Y sí se trata de un CD, se puede usar el comando

root@mini:# wodim -v dev=/dev/sg1 imagen.iso

Por supuesto, se debe adaptar el dispositivo de escritura (en este caso ‘/dev/sg1’) al que esté presente en cada máquina en particular.

Más información sobre growisofs en esta página  .

Sobre ‘wodim’ es interesante este extracto del README.ATAPI.setup que viene con el paquete

Howto setup an ATAPI CD-RW/DVD+-RW recorder on Debian/Ubuntu
============================================================

This guide should be applicable to most kernel 2.6 using distributions of
GNU/Linux. For installations with kernel 2.4, continue reading below.

Kernel 2.6.*
============

If you have just one CD writer in your computer, CD-writing should work out of
the box. There should be a symbolic link /dev/cdrw which points to your actual
CD-Writer’s device (e. g. /dev/hdb). If the link is not present (eg. the
system is not using udev/devfs) or if you want to use a different device as
default, you can configure the device in /etc/wodim.conf:

CDR_DEVICE=/dev/hdd

would configure the default device to be /dev/hdd, i. e. the slave
device on the secondary IDE bus.

You can always override this default setting with wodim’s «dev»
option:

wodim dev=/dev/hdc …

Only users part of the system group «cdrom» are able to write CDs.
If you wish to allow non-root users to write CDs then add your users to the
cdrom group («adduser user cdrom») and let the user completely logout and
re-login.
Note: with certain kernel versions wodim can fail with this message:
«wodim: Operation not permitted. Cannot send SCSI cmd via ioctl»
In this case it still does need the suid bit – please send patches if you have
identified the reason of that problem.

 

Instalar GNU/Linux desde un pendrive

Por lo general las distribuciones de GNU/Linux ofrecen descargar imágenes ISO desde sus sitios para que cada cual pueda crear sus propios CDs/DVDs de instalación a partir de ellas. Sin embargo, es posible que tengamos que hacer una instalación en una computadora que no posea lectora de CD/DVD.  Para esta situación es conveniente instalar desde un pendrive, tal como se describe a continuación

1. Bajar imagen iso desde el sitio de la distribución elegida
2. Escribir la imagen iso al pendrive con el comando dd (puede tardar bastante este paso)
3. Arrancar la computadora desde el pen y seguir las instrucciones

Acá dejo un ejemplo donde usé la imagen debian-8.8.0-i386-DVD-1.iso y un pendrive ubicado en /dev/sdb. (Notar que puede ser necesario entrar como usuario root, usando ‘sudo’ o ‘su’)

root@mini:/home/luck# dd if=/home/luck/Documentos/Informatica/debian-8.8.0-i386-DVD-1.iso of=/dev/sdb
7710592+0 registros leídos
7710592+0 registros escritos
3947823104 bytes (3,9 GB) copiados, 2670,66 s, 1,5 MB/s