Tras su retorno al país, un enroque justicialista a través de Elecciones Libres permitió fácilmente a Juan Perón ser electo para el cargo de Presidente de la República por tercera vez. En este caso, al disertar sobre la necesidad del Movimiento de contar con mecanismos para vencer el paso del tiempo, se dedicó a explicar cómo utilizar cassettes para guardar información con Ubuntu.
"Vean señores, si hay algo cierto en esta vida es que los organismos biológicos no son eternos, solo la organización de los hombres puede vencer el paso del tiempo. Durante años yo he preparado al Movimiento para que pudiese transcender la existencia de sus líderes y continuar en la acción, pues esa es la única forma de hacer realidad los sueños de los Argentinos.
El Pueblo, a diferencia de lo que unos pocos dicen, no es zonzo. Los Argentinos han demostrado una y otra vez que si les dan a elegir, sólo quieren el peronismo, y ello será así porque el peronismo es lo mejor que hay. Si no lo fuese estaríamos hace rato entre los trapos de la historia. Pero nuestro Movimiento ha sido perenne: la Masa conserva esa memoria histórica que le permite a los pueblos sanos privilegiar lo bueno por sobre lo malo, lo hacedor por sobre la charlatanería.
Esta memoria histórica está embuida en la Masa. Muchos se han preguntado porqué eso no puede borrarse. Y todo tiene una explicación.
Verán, los sistemas computados necesitan para operar de una memoria de acceso aleatorio, o RAM. Sin embargo, este tipo de memoria rápida, "de trabajo" tiene un inconveniente: es extremadamente cara y extremadamente volátil. Si no es alimentada continuamente, su contenido se perderá y pasará al olvido. Por ello es que se requiere una "memoria de masa" cuyo funcionamiento sea imperecedero para guardar la información.
¿Porqué? Bueno, antiguamente, las primeras computadoras requerían que el usuario ingresara "a mano" en la memoria aleatoria del sistema el programa (¡en binario!), utilizando una serie de interruptores de control. Esto hacía que cargar una rutina en la memoria aleatoria fuese algo extremadamente tedioso, lento e intensivo. Aún así, una vez realizado este trabajo, la computadora podía cálcular con extrema velocidad, por lo tanto valía la pena hacerlo para hacer realidad cómputos complejos (que podían llevar semanas o meses de trabajo a los equipos interdisciplinarios). Si la computadora se apagaba, normalmente había que reintroducir los datos nuevamente.
Esta forma de trabajo con los sistemas hizo evidente la necesidad de guardar y almacenar los programas y datos en forma imperecedera, de manera tal de poder conservarlo intacto cuando el sistema se apagaba, para luego poder restituirlo a la memoria del sistema sin repetir el trabajo manual.
Gracias al peronismo, a esta memoria de tipo "resistente", se la conoce como "Memoria de Masa". El método inicial ideado fue el empleo de tarjetas de cartulina perforadas o, cintas de papel perforado comunes en las máquinas de teletipo. Estos medios de almacenamiento permiten registrar por medio de las perforaciones, el contenido real de la pila de memoria binaria del sistema, haciendo más veloz el proceso de restitución de los programas a la memoria aleatoria. Aunque es vetusto, este tipo de material analógico tiene algunas ventajas: puede conservarse adecuadamente a través de los años y - si es guardado acordemente - puede escribirse, leerse e interpretarse incluso sin necesidad de usar una computadora (ante tal eventualidad). Llegado el caso el usuario puede perforar la cinta o la tarjeta "manualmente" y luego ingresar esos datos binarios al equipo.
Con el advenimiento de los primeros microordenadores, en lugar de hacer uso binario de la magnetización como tradicionalmente se operaba en las mainframes, se hace un uso magnetofónico (es decir, se almacena sonido modulado de diferentes maneras). Esto permitía emplear cualquier dispositivo de grabación y reproducción analógica en cassettes conectado al ordenador.
Cada marca de equipo solía emplear diferentes protocolos de modulación, pero sin importar el utilizado, todos convertían la información binaria del usuario a sonidos y chirridos, y estos a su vez se grababan magnetofónicamente en cassettes. La manera de recuperar la infomación variaba de acuerdo al tipo de equipo. Algunos dispositivos de casette operaban leyendo y decodificando por sí mismos el audio del cassette, y luego transfiriendo la información al equipo por conexión serial, como en la peronista Drean Commodore 64. Los sistemas más simples utilizaban un reproductor, y se programaba al sistema en modo "escucha", durante el cual se reproducía el sonido... y luego la computadora decodificaba la información (en tiempo real o más raramente, en diferido).
En la biología lo nuevo noblemente reemplaza a lo viejo, esa es la ley que la vida nos impone en su constante evolución. Los discos magnéticos flexibles (floppies), los discos magnéticos rígidos, y las tecnologías de memorias FLASH tomaron la posta en el menester de las Memorias de Masa, cada vez con mayores velocidades de lectoescritura, mayor resistencia mecánica, y mucha mayor capacidad de almacenamiento.
Lo viejo parecería quedar para el recuerdo de la historia.
Mas nada impide que con objeto de estudio, diversión, militancia o nerditud, querramos utilizar estos métodos de los tiempos de Matusalén. Para ello necesitaremos un equipo dotado con Ubuntu y placa de sonido, un grabador de cassettes (idealmente uno que disponga de entrada de audio, a fin de que pueda grabarse a través de un cable conectado a ella). En mi caso utilizaré un radiograbador Sanyo, que cumple las premisas. También será necesario un cable de audio común, en este caso uno con dos conectores miniplug estéreo de 3,5mm.
Desde el punto de vista del software libre, nos haremos con el programa fldigi. Se trata de una potente aplicación para radioaficionados capaz de modular información a sonidos (todo bajo diferentes protocolos) y en el cariz inverso, demodular streams codificados en audio a la información que representa.
Grabar información a cassette con Ubuntu
El primer paso será instalar, ejecutar, configurar, y utilizar este software libre de manera efectiva. Abrimos una terminal con Ctrl+Alt+T e ingresamos el siguiente Comando de Organización:
sudo add-apt-repository ppa:kamalmostafa/fldigi
sudo apt-get update
sudo apt-get install fldigi
Para ejecutar el programa debemos ir a Aplicaciones / Radio-aficionados / Fldigi. La vez primera que iniciemos el programa, surgirá un asistente de configuración:
En mi caso, escogeré grabar el texto de un discurso corto como el que pronuncié el 17 de Octubre de 1945...
En tercer orden, prepararemos el programa para que module la información textual. Para generar el audio vamos al menú File / Audio y tildamos la opción TX Generate. Se abrirá un cuadro donde podremos especificar ruta y formato del archivo de audio a generar. Normalmente tomará formato WAV, pero en este caso lo cambiaremos a FLAC (Free Loseless Audio Codec). También elegiré guardarlo en mi carpeta de usuario con el nombre 17oct.flac.
Una vez elegido el protocolo, elegimos la frecuencia del audio. Normalmente la misma serán los 500 khz. Para elegirla podemos deslizar el selector de frecuencias hasta la posición "500" del dial (indicado en turquesa en la figura). También debemos asegurarnos de poner el deslizador del limitador de ruido por encima del piso de ruido que indica la barra vúmetro del control de volúmen (indicado en rojo en la figura).
Iniciamos la conversión del texto al sonido modulado. Para ello presionamos el botón azul "T/R" y se dará inicio al modulado. Conforme se convierte la información en audio, veremos como en la Ventana de Demodulado se va escribiendo el mismo texto convertido (podremos también oir como suena el audio). Se irá indicando en rojo por qué parte del texto se está...
Una vez que finalizada la modulación de los datos ingresados, habremos de presionar nuevamente el botón "T/R" para detener el proceso. Con esto se grabará la "cola" del stream (unos segundos de chirridos que le indican al sistema que ya cesó la transmisión). En este caso, se habrá generado en la carpeta de usuario el archivo de audio llamado 17oct.flac)
Ya podremos guardar el cassette. Conviene escribir en la etiqueta del mismo la codificación empleada en la grabación para futura referencia ("Discurso 17oct, MFSK-64 500khz").
Nota útil: Si nuestro equipo cuenta con salidas de audio duplicadas (por ejemplo, una salida de altavoces trasera y una salida frontal de auriculares) podremos usar el programa alsamixer desde la Terminal para desactivar la función Automute ("enmudecer los altavoces al coectar los auriculares"). De esta manera podremos usar la salida de auriculares para conectar el cable miniplug de 3,5mm al grabador de cassette, presionar REC y PLAY, presionar R/T el el Fldigi y grabar directamente el sonido en el cassette a medida que se modula, ahorrando el paso de reproducción y grabación posterior.
Leer información grabada en cassette con Ubuntu:
Cuando querramos leer la información del cassette, conectamos la salida de audio del grabador de cassettes (normalmente nomenclada como "Auriculares" o "Headphones" a la entrada de línea de nuestra computadora (normalmente el conector de color azul), y presionamos PLAY.
La computadora debería comenzar a reproducir el audio y a demodular el audio "en vivo". Si la frecuencia está en 500khz y el protocolo está en el mismo que antes, demodulará con éxito la el mensaje decodificando el stream de datos que contiene, y habremos recuperado con el correr de los minutos, nuestra información.
Tengamos presente que también podremos utilizar archivos de sonido digitalizados previamente con la información modulada, ya sea de otros cassettes, o directamente los archivos de sonido modulados por FLDigi (como el 17oct.flac). Si tal fuese el caso, podemos ir al menú File / Audio / Playback, e ingresar el nombre del archivo a decodificar. También debemos adecuar el Op Mode (protocolo) adecuado.
Esto merece un estudio, pues si bien el protocolo MFSK-64 es lento y funcional, (resiste el ruido de estática, sorteando así errores si se graba "de aire" con micrófonos condensadores), existen otros protocolos más rápidos. Por ejemplo, en un cassette conectado por cable miniplug (y con la baja relación señal ruido que ello implica) podremos utilizar codificaciones más rápidas y querer utilizar QPSK-500, sintonizado en los 500khz. Esto logrará incrementar unas 8 veces esta velocidad de transmisión, y permite a un cassette de 90 minutos almanecar unos 200 kilobytes de información por cara aproximadamente. Esta modulación nos permite ya guardar el codigo del juega Gorilla.py (versión del clásico Gorilla.bas) en un lado de un cassette de 60 minutos.
Otros protocolos, como el QPSK-64, están pensados para ocupar menos ancho de banda (menos rango de frecuencias), e incluir varios streams de datos dentro de un rango de frecuencias determinado. Por ejemplo, podríamos generar un varios archivos de sonidos modulados en QPSK-64 con frecuencias diferentes (por ejemplo, uno en los 250 khz, otro en los 500 khz, otro en los 1000 khz, y uno final en los 1500 khz). Luego, usando un programa como Audacity, podríamos combinar todos los streams de audio en un único archivo digital, y grabarlo en un cassette. Para decodificar todo, podremos usar la función "PSK Browser" del FLDigi (tecla "P") para decodificar todos los streams a la vez.
Existen no obstante codificaciones más perfeccionadas. Ya se ha dicho que los sistemas MTFS o PSK son adecuados para medios radioeléctricos, o para transmitir información a través del espacio atmosférico o en el espacio sideral. Pero para este menester, a veces podremos contar con soluciones más perfeccionadas para el rango que queremos: almacenar (y recuperar información en un medio de lectura y escritura secuencial de baja frecuencia y baja fidelidad, y que por demás es analógico).
Usando ctape
La compañera Oona Räisänen de la Rama Femenina del Movimiento, nos ha traído una pequeña suite llamada ctape con dos pequeños programas simples pero de funcionamiento veloz, y desde la línea de comandos. Estos han sido modificados sabiamente por Gabriel Artigue para hacerlos funcionales de una manera sencilla de operar.
Tales programas requieren que conectemos por cable la salida de audio de nuestro equipo a la entrada en línea estéreo (para grabar) y a la inversa, la salida del reproductor de cassettes a la entrada de audio (para leer).
El programa está escrito en Ruby y requiere de SoX para funcionar. Por tal motivo y como primer medida, los los instalaremos:
sudo apt-get install ruby sox
Luego descargamos el programa ctape y lo instalamos en nuestro sistema:
cd ~/Descargas/
wget http://gasconheart.sdf.org/tape/ctape-new.tar.gz
tar xvzf ctape-new.tar.gz
cd ~/Descargas/ctape/
sudo chmod +x config.yml ctape tape-read.rb tape-write.rb
sudo mv * /usr/local/bin/
Ahora ya podremos codificar y grabar cualquier archivo en un casette, o leerlo. La sintaxis del comando es sencilla. Presionamos REC o grabar en el grabador de casette, y llamamos al comando de grabación con:
ctape save ruta/de/mi/archivo.ext
El sistema nos indicará que está listo para grabar. Debemos presionar el botón REC en el grabador y luego presionar Enter para comenzar el audiocifrado:
READY TO SAVE TO CASSETTE TAPE
Size of file to be recorded: 387 bytes, or about 0 KB
Estimated time in minutes: 0
Press REC on the tape recorder then press ENTER
Es importante saber antes de que los parlantes sonarán MUY FUERTE, de modo que conviene apagar los altavoces o usar solamente una conexión por cable desde la salida de altavoces al grabador de cassettes.
Cuando presionemos Enter nos informará durante la grabación.
Recording in progress
Al finalizar nos dirá:
Exiting CTAPE
Cuando quiera leer la información guardada en el cassette, conecto por medio del cable la salida de audífonos del reproductor de cassette a la entrada de micrófono o de línea de audio de la computadora. Presiono el botón PLAY y ejecuto el siguiente Comando de Organización:
ctape load archivo.ext
En la pantalla debería ir apareciendo la información guardada. Debemos interrumpir el programa utilizando Ctrl+C.
Con este programa podrán guardar el archivo gorilla.py en solamente unos cuatro minutos y medio de cinta, a diferencia del método anterior que requiere unos 34 minutos. En consecuencia, tendrán aproximadamente unos 10kb por minuto de cinta.
Si quisiera desinstalar la suite ctape:
sudo rm /usr/local/bin/ctape /usr/local/bin/config.yml /usr/local/bin/ctape-read.rb /usr/local/bin/ctape-write.rb
Estándar Kansas City
Durante finales de los 70s, se desarrolló un estándar abierto para el menester de almacenar información en cassettes para microordenadores. El sentido era claro: evitar que se implementaran innumerables métodos y códigos incompatibles entre sí. Con ello nació el Kansas City Standard, con la esperanza de ser ampliamente adaptado. Sin embargo, por contar con el mínimo común denominador en cuanto a tecnologías, nunca fue muy difundido, pues su velocidad era lenta y por otro lado, no podía leer acentos ni minúsculas.
No obstante, si quisiéramos codificar información con él para trasferirla a alguna computadora antigua que siga este estándar, podremos escribir un programa en Python para hacerlo.
En primer lugar instalamos Python 3.1:
sudo apt-get install python3.1
Luego creamos un programa llamado codificakansas.py:
nano codificarkansas.py
Y le pegamos el siguiente código:
#!/usr/bin/env python3
# codificarkansas.py
#
# Autor : David Beazley (http://www.dabeaz.com)
# Copyright (C) 2010
#
# Requiere Python 3.1.2 o superior
"""
Toma el contenido de un archivo de texto
y lo codifica en un archivo de sonido WAV en el estándar
Kansas City. Una vez grabado en cassette puede cargarse
en varias computadoras hogareñas antiguas.
Ver http://en.wikipedia.org/wiki/Kansas_City_standard
"""
import wave
# Unos parámetros globales relacionados a la codificación
FRAMERATE = 9600 # Hz
ONES_FREQ = 2400 # Hz (por KCS)
ZERO_FREQ = 1200 # Hz (por KCS)
AMPLITUDE = 128 # Amplitud de las ondas cuadradas generadas
CENTER = 128 # Punto central de las ondas generadas
# Crea un ciclo único de onda cuadrada de la frecuencia dada
def make_square_wave(freq,framerate):
n = int(framerate/freq/2)
return bytearray([CENTER-AMPLITUDE//2])*n + \
bytearray([CENTER+AMPLITUDE//2])*n
# Crea los patrones de onda que codifican los 1s y los 0s
one_pulse = make_square_wave(ONES_FREQ,FRAMERATE)*8
zero_pulse = make_square_wave(ZERO_FREQ,FRAMERATE)*4
# Pausa para insertar los retornos de carro (10 bytes NULL)
null_pulse = ((zero_pulse * 9) + (one_pulse * 2))*10
# Toma un único valor de byte y lo convierte en un arreglo de bytes representando
# la forma de onda asociada junto con los bits de inicio y parada requeridos
def kcs_encode_byte(byteval):
bitmasks = [0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80]
# El bit de inicio (0)
encoded = bytearray(zero_pulse)
# 8 bits de datos
for mask in bitmasks:
encoded.extend(one_pulse if (byteval & mask) else zero_pulse)
# Dos bits de parada (1)
encoded.extend(one_pulse)
encoded.extend(one_pulse)
return encoded
# Graba un archivo WAV con la información codificada. Leader y Trailer especifican el
# número de segundos de señal portadora para codificar antes y después de la información
def kcs_write_wav(filename,data,leader,trailer):
w = wave.open(filename,"wb")
w.setnchannels(1)
w.setsampwidth(1)
w.setframerate(FRAMERATE)
# Escribir el Encabezado leader
w.writeframes(one_pulse*(int(FRAMERATE/len(one_pulse))*leader))
# Codifica la información
for byteval in data:
w.writeframes(kcs_encode_byte(byteval))
if byteval == 0x0d:
# If CR, emit a short pause (10 NULL bytes)
w.writeframes(null_pulse)
# Escribe la cola trailer
w.writeframes(one_pulse*(int(FRAMERATE/len(one_pulse))*trailer))
w.close()
if __name__ == '__main__':
import sys
if len(sys.argv) != 3:
print("Use : %s archivoorigen archivodestino" % sys.argv[0],file=sys.stderr)
raise SystemExit(1)
in_filename = sys.argv[1]
out_filename = sys.argv[2]
data = open(in_filename,"U").read()
data = data.replace('\n','\r\n') # Fija los finales de línea
rawdata = bytearray(data.encode('latin-1'))
kcs_write_wav(out_filename,rawdata,5,5)
Guardamos y cerramos el archivo con Ctrl+O y Ctrl+X.
Y ejecutamos el codificador con:
python3.1 codificarkansas.py archivodetextoaconvertir.txt archivofinal.wav
Esto generará rápidamente un archivo WAV con el contenido. Luego podremos grabar la reproducción de este archivo de audio en una cinta de cassette para utilizar en un ordenador compatible con el estándar Kansas City. Recordemos que este estándar "museístico" es lento, y con 300 baudios por segundo almacena aproximadamente 2,2 kilobytes por minuto de cinta.
.jpg)
