martes, 31 de diciembre de 2013

¿Cómo puedo guardar información en un cassette con Ubuntu?

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.
 Indudablemente, escribir un programa más o menos complejo requiere muchos metros de cinta perforada, y su lenta performance de lectura hizo que esta tecnología fuese superada eventualmente por el medio magnético. Este tiene la desventaja de no poder manipularse manualmente, pero conserva la acción analógica para el almacenamiento binario: las cintas almacenan la información binaria mediante la magnetización o no de sectores de la misma. Este tipo de tecnología es práctica pues permite mayor velocidad de transferencia, y gran estabilidad de los datos. Su uso se adaptó rápidamente a las mainframes, mediante el uso de carretes abiertos de cintas magnéticas.

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:
Simplemente presionamos Next para saltar a la próxima pantalla.
Eb esta también presionamos Next. En segundo lugar aparecerá la ventana Audio Devices, que nos permitirá configurar el dispositivo de entrada y de salida de audio (en este caso la placa de sonido de nuestra computadora). Lo configuramos desde la solapa "Devices". Al emplear la salida de altavoces como salida de audio, y la entrada en línea estéreo como entrada del mismo, tildamos PortAudio. Conforme lo hagamos, podremos escoger el dispositivo de audio para grabar en el campo Capture y el dispositivo de audio para reproducir en el campo Playback (normalmente elegimos la opción "Defailt").
Al presionar Next nos encontraremos con la pantalla principal del programa FLdigi. La misma se divide escencialmente en dos paneles principales, la ventana de demodulación (en color amarillo crema, en la parte superior), y la Ventana de Modulado (en color celeste, en la parte inferior), dentro la cual podremos agregar infomación para que sea modulada a sonido siguiendo el protocolo deseado, ya sea tipeándola, o pegándola.
En segundo lugar buscaremos la información que querremos guardar en el cassette. Tengamos en cuenta que el proceso requiere mucho tiempo, de modo que sólo recomiendo guardar un poco de texto, o código fuente. Como referencia, sepamos que normalmente, este método graba una hoja de texto (unos 1,2Kb) por cada minuto de cinta.

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.
Acto seguido hemos de designar un protocolo de modulación. Existen múltiples modalidades y velocidades para codificar la grabación de los datos. La más básica recomendable para los cassettes es la velocidad de 64 baudios. Para seleccionarla, elegimos Op Mode / MFSK / MFSK-64. Se trata de una modulación por frecuencia de pulso, que era parecida a la empleada en los Datasettes de los microordenadores Commodore 64. Si bien es muy lenta, permite guardar información en cassettes y con grabadores de pésima calidad, lo que prácticamente evita los errores de lectura posteriores incluso después de años.

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).
Ahora generaremos el audio propiamente dicho. Para ello podremos tipear o pegar el texto elegido en la Ventana de Modulación (el panel celeste) mediante clic con botón derecho sobre el panel celeste + paste.


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)
Nuestra tarea entonces será grabar el sonido a un cassette. Conectamos la salida de audio de nuestro sistema (normalmente el conector de color verde) a la entrada de línea o micrófono del grabador de cassettes. Ponemos el cassette en la cassettera, lo rebobinamos y presionamos los botones REC y PLAY. Transcurridos unos segundo, reproducimos el archivo de audio (en mi caso, 17oct.flac)  El grabador capturará el sonido y lo grabará en la cinta. Una vez finalizado presionamos el botón STOP, y ya podremos rebobinar el cassette y escuchar el audio para comprobar que se haya grabado sin problemas.

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.
De esta manera, podremos ver el espectógrafo "de lluvia" que nos ayuda a sintonizar el audio (si no tuviésemos la información de frecuencia o protocolo).

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.

10 comentarios:

  1. Aleluya. Lo logré. El señor existe. El señor que me vendió la
    grabadora de cassettes. Tengo que perfeccionar la técnica, porque esto
    no tiene por qué ser complicado, pero lo logré. Tengo que hacer
    malabares circenses para hacerlo, pero ya lo puedo hacer.

    Tengo que poner el volumen del output ridículamente bajo, pero no
    demasiado, para hacer la grabación. Medí con regla la línea del
    volumen en la pantalla, para poder volver a ponerlo en el mismo nivel
    la próxima vez que quiera grabar. El audio tiene que salir desde la
    salida de audio de atrás de la computadora. Desde la salida de
    adelante para auriculares no me funciona.

    Para cargar los programas desde cassette, algo muy parecido. Tengo que
    utilizar la entrada de micrófono de adelante en este caso. No me ha
    funcionado con la entrada de micrófono que hay en la parte de atrás de
    la computadora. El volumen de la entrada de micrófono también tiene
    que estar ridículamente bajo. También medí con regla la pantalla de la
    computadora para poder volver a poner el volumen del micrófono
    exactamente en ese nivel.

    Y la pirueta más circense de todas es que esto me funciona ... solo
    inmediatamente al conectar la grabadora a la entrada de micrófono de
    la computadora. Si quiero cargar dos programas uno después del otro,
    no puedo dejar el cassetero conectado. Tengo que desenchufar la
    clavija y volverla a enchufar. Si alguien sabe por qué eso es así y
    sabe cómo se puede corregir, hágamelo saber.

    Ahora a hacerme una pequeña colección de cassettes para guardar copias
    de pequeños archivos míos personales. Ya estoy en los '80 de nuevo.

    Saludos

    ResponderEliminar
    Respuestas
    1. Estimado Gabriel:

      Enhorabuena por tu éxito en esta técnica. Efectivamente, es algo sensible al control de volúmen. Cuando grabes el archivo, prueba usar luego un reprioductor como el Audacity para comprobar el fichero de audio (si es que lo generas) y comprobar allí el volúmen en una unidad coherente como los decibeles (dB). De esta manera podrás dejar de usar la "regla", que es como hacerlo "a lo vikingo".

      Indudablemente se trata de alguna complejidad con el adaptador de sonido que tu tienes. En particular lo empleamos con una portatil netbook con sonido RS888, que no tiene detección de entradas de audio. Tal vez sea esa función que molesta en la tuya (puedes probar abrir un mezclador alsamixer en la terminal, y ver si puedes deshabilitar la función de detección de entrada ("automute" y ponerla en Disabled.

      Algo de eso hay aqui: http://ubuntuperonista.blogspot.com.ar/2012/10/realtekalc982ubuntu12.04precise.html

      Atte

      Juan Perón

      Eliminar
  2. Soy Gabriel Artigue. Estoy utilizando intensamente el Ctape. Debo de ser el único usuario de Ctape en todo el mundo. Dos comentarios más.

    1. Por razones que me escapan completamente, el Ctape a mí personalmente me funciona solo con casetes de tipo II. La computadora permanece absolutamente sorda a grabaciones en casetes de tipo I. El tipo de casete lo determina la composición metálica con la que está revestida la cinta de plástico.
    Algunas de las personas que han probado el Ctape, lo han hecho como una curiosidad, y en general han hecho "trampa" en el sentido de que han grabado el audio en un iPod, Smartphone, o semejante. ¿Puedo apelar a los lectores de este blog para pedirles que hagan pruebas con casetes reales y suban aquí mismo sus comentarios? Les quedaría muy agradecido.

    2. Hice una interfaz textual para Ctape, en bash, utilizando el programita Dialog. La interfaz usa Ctape en combinación con Tar, de manera que uno simplemente elige un archivo o un directorio (carpeta, folder), se crea automáticamente un tar.gz, y es grabado en el casete. Ctape resulta muy fácil de utilizar de esta manera. Puedo compartir con quien quiera este script.
    Un saludo
    Gabriel
    gabriel punto artigue arroba gmail punto com

    ResponderEliminar
    Respuestas
    1. Estimado Gabriel:

      Enhorabuena por tu éxito en la seguida experimentación de la grabación de datos en cinta de audio. Esta técnica, al no emplear un aparato dedicado sino un programa genérico y una casettera casera común y corriente, puede tener algunos problemas.

      Conformamos en su momento un grupo de usuarios que con fin didáctico lo empleamos, incluso a nivel educativo, para enseñar tecnologías entre los educandos peronistas.

      En particular lo hemos probado con casette con éxito, con casettes C60 TDK (el común y corriente) grabándola en un equipo Aiwa NSX900. Desconozco de momento si es tipo I o II y cual sería la diferencia entre ellos, y si dicho minicomponente antiguo posee preamplificadores o algo parecido. Utilizamos volúmenes "intermedios, tirando a alto" pero nunca al máximo.

      Hemos tenido éxito también grabando con un grabador digital tipo periodista, modelo Panasonic de 256MB, en modo "Música", no así en los modos Voz LQ o Voz HQ.
      Seguramente se deba a cortes de frecuencia aplicados a estos últimos con el fin de ahorrar espacio en memoria. Cuando grabamos digitalmente en modo PCM funciona bien, no así en modo GSM (de calidad reducida).

      Si tienes un script y lo has probado con éxito, eres libre de publicarlo a través de este blog (lo haremos acreditando), por supuesto siempre que utilices licencias libres para el mismo (como la GPL).

      Atte:
      Juan Perón

      Eliminar
  3. Gracias por tu respuesta. El script está aquí: http://wikisend.com/download/144458/ctape.tar.gz

    Gabriel

    ResponderEliminar
  4. En Dropbox el script durará más tiempo:
    https://www.dropbox.com/sh/rrt8aoa4547z75g/AACaueBTN-I5b1Ayqi4Fgo_ya
    Saludos
    Gabriel

    ResponderEliminar
  5. Enmienda a mi script.
    Cerca del final del script ctape, el script se llama a sí mismo, de manera de repetir el menú en un bucle sin final. Es mejor poner "exec ctape" en vez de solo "ctape". Sin el "exec" precediendo el nombre del script, se crea en la memoria de la computadora una nueva ejecución del programa, lo que hace que la computadora se vuelva inestable si se usa el script varias veces. Con "exec", cada ejecución del script elimina la anterior de la memoria.
    Saludos
    Gabriel

    ResponderEliminar
    Respuestas
    1. Estimado Gabriel:

      Gracias por sus aportes, lo evaluaremos con la condición que comenta y haremos un artículo en breve!

      Atte.

      Juan Perón

      Eliminar
  6. Sitio web sobre el Ctape:
    http://gasconheart.sdf.org/tape/

    IRC chat sobre el almacenamiento de datos en cinta magnética:
    http://artigue.org.es/

    Saludos
    Gabriel

    ResponderEliminar