Codigo Morse

Primero… ¿Qué es el codigo Morse?

El Codigo Morse son la representación de nuestro alfabeto en “puntos y rayas“, ello permite la trasmisión de mensaje a través de dispositivos capaces de emitir sonidos o imprimir puntos y rayas (como el telégrafo), si quieres una explicación mas profunda podemos recurrir a la wikipedia: Código Morse

¿Como funciona?

Lo que haremos con nuestro pequeño programa es reconocer cada caracter de una cadena de texto, luego enviaremos cada caracter a un método (funcion/procedimiento) y éste nos retornará su representación en código morse (nos retorna un string), la funcion recibe como parámetros una variable de tipo char (solo un caracter) y retorna un string (cadena de texto, en este caso una cadena de puntos y rayas)

static string morseCode(char txt)
{
 string morse = "" ;
 switch (txt)
 {
 case 'a': morse = "·-"; break;
 case 'b': morse = "-···"; break;
 case 'c': morse = "-·-·"; break;
 case 'd': morse = "-··"; break;
 case 'e': morse = "·"; break;
 case 'f': morse = "··-·"; break;
 case 'g': morse = "--·"; break;
 case 'h': morse = "····"; break;
 case 'i': morse = "··"; break;
 case 'j': morse = "·---"; break;
 case 'k': morse = "-·-"; break;
 case 'l': morse = "·-··"; break;
 case 'm': morse = "--"; break;
 case 'n': morse = "-·"; break;
 case 'ñ': morse = "--·--"; break;
 case 'o': morse = "---"; break;
 case 'p': morse = "·--·"; break;
 case 'q': morse = "--·-"; break;
 case 'r': morse = "·-·"; break;
 case 's': morse = "···"; break;
 case 't': morse = "-"; break;
 case 'u': morse = "··-"; break;
 case 'v': morse = "···-"; break;
 case 'w': morse = "·--"; break;
 case 'x': morse = "-··-"; break;
 case 'y': morse = "-·--"; break;
 case 'z': morse = "--··"; break;
 case ' ': morse = " "; break;
 case '0': morse = "-----"; break;
 case '1': morse = "·----"; break;
 case '2': morse = "··---"; break;
 case '3': morse = "···--"; break;
 case '4': morse = "····-"; break;
 case '5': morse = "·····"; break;
 case '6': morse = "-····"; break;
 case '7': morse = "--···"; break;
 case '8': morse = "---··"; break;
 case '9': morse = "----·"; break;
 case '.': morse = "·-·-·-"; break;
 case ',': morse = "--··--"; break;
 case '?': morse = "··--··"; break;
 case '\"': morse = "·-··-·"; break;
 default: morse = ""; break;
 }
 return morse;
}

Eso viene a ser practicamente todo, ahora solo nos queda pedir la cadena, extraer cada caracter y enviarlo a la función anterior:

Para leer una cadena ingresada por teclado usamos el método Console.ReadLine(); si queremos algo mas “bonito” entonces lo ideal sería solicitar la cadena de texto con un mensaje:

Console.Write(“Escriba aqui su texto a convertir : “);
string txt = Console.ReadLine();

Como nuestra funcion morseCode() solo trabaja con caracteres en minúscula, entonces necesitamos convertir a minúscula todos los caracteres de nuestra cadena, para ello usamos el método ToLower();

txt = txt.ToLower();

Ahora recorreremos nuestra cadena de texto con un bucle y extraeremos cada caracter, al mismo tiempo enviaremos el caracter extraido a nuestra funcion morseCode() e imprimiremos la respuesta de la función:

char tmp; int p;
for (p = 0; p < txt.Length; p++)
{
 tmp = char.Parse(txt.Substring(p, 1));
 Console.Write("{0} ", morseCode (tmp));
}

Creamos las variables TMP y P, haciendo uso del bucle FOR (para) recorremos toda la cadena mientras P sea menor que la longitud de la cadena (txt.Length), TMP tomará el valor de la cadena en la posicion P y convertimos la salida a tipo Char (char.Parse), luego imprimimos en pantalla la salida de morseCode(tmp)…

Ahora construiremos nuestra funcion para pitar el altavoz del sistema (beep)

Las normas del código Morse nos dice que…

1. Un guión es igual a tres puntos
2. El espacio entre las partes de la misma letra es igual a un punto
3. El espacio entre dos letras es igual a tres puntos
4. El espacio entre dos palabras es igual a siete puntos

static void beepMorseCode(string morse)
{
 int f = 600; //frecuencia en hz del pitido
 int dot = 50; //duracion del pitido PUNTO
 int x = 0;
 char t = ' ';
 while (x < morse.Length)
 {
  t = char.Parse(morse.Substring(x, 1));
  if (t == '·')
  {
   Console.Beep(f, dot); //tono punto
   Thread.Sleep(dot); //separacion entre partes de la letra
  }
  else if (t == '-')
  {
   Console.Beep(f, dot * 3); //tono raya 3 puntos
   Thread.Sleep(dot); //separacion entre partes
  }
  else
  {
   //genera una pausa de 6 puntos
   Thread.Sleep(dot * 6); //en total 7 contando las pausas anteriores
  }
  x++;
 }
 //pausa de 3 puntos, equivale a separacion de frase
 Thread.Sleep(dot * 2);
}

En nuestro método beepMorsCode recibimos una variable de tipo string, al comienzo declaramos la frecuencia de cada pitido y la duración del mismo, tambien declaramos la duración de cada silencio.
Iniciamos un bucle diciendo: “mientras X sea menor que la longitud de la variable MORSE”; iniciamos condiciones, si T (el char “actual”) es un PUNTO entonces pitamos F con duración L, si es RAYA pitamos F con el doble de L y si es un ESPACIO hacemos PAUSA (con Thread.Sleep();), incrementamos X;

Para usar la opción SLEEP debemos colocar “using System.Threading;” en las primeras lineas de nuestro codigo!

Ahora nuestro pequeño programa ya puede reproducir sonidos según el codigo morse, para llamar al método beepMorseCode() solo hace falta enviarle el string generado por morseCode(), nuestro método beepMorseCode se encargará de generar la secuencia de beeps y pausas adecuadas!

Eso es todo, aquí tienen el código fuente de: Console.Beep Morse Code listo para compilar y probar!

Supuesto Clavecín de Bach

Hoy disponía de tiempo (casi siempre dispongo de tiempo) y como Johann Sebastian Bach es mi compositor favorito decidí escribir una de sus composiciones que tanto me gusta usando frecuencias, tiempos y  el método Beep() de la clase Console en CSharp! Bach es barroco por ello he implementado métodos como trino() y mordente() para darle estilo barroco a la melodía

La obra en sí es la Gavotta BWV 808 de la Suite Inglesa No3

Para escuchar la melodía:

1. Descargar el codigo fuente desde el código ignoranto o haciendo clic aquí, Gavotte BWV808
2. Compilar el código fuente con MonoDevelop, Visual Studio, Sharp Develop o directamente con algun compilador de C#
3. Ejecutar el binario y escuchar (debemos tener un BEEP en nuestra placa, de lo contrario no podremos escuchar

Eso es todo, pronto estaré escribiendo el Preludio Op23 Nro5 de Sergei Rachmaninov!

Teclado del Piano

Hola! Necesitaba escribir música en consola y se me ocurrió crear arreglos (arrays) con las frecuencias musicales según octavas, cada arreglo contiene 8 elementos (todas las octavas), a continuación el código en c# (c sharp):

 int[] ut = new int[8]  { 65, 130, 261, 523, 1046, 2093, 4168, 8372 };
 int[] uts = new int[8] { 69, 138, 277, 554, 1108, 2217, 4434, 8869 };
 int[] re = new int[8]{ 73, 146, 293, 587, 1174, 2349, 4698, 9397  };
 int[] res = new int[8] { 77, 155, 311, 622, 1244, 2489, 4978, 9956 };
 int[] mi = new int[8] { 82, 164, 329, 659, 1318, 2637, 5274, 10548 };
 int[] fa = new int[8] { 87, 174, 349, 698, 1396, 2793, 5587 , 11175};
 int[] fas = new int[8] { 92, 184, 370, 740, 1480, 2959, 5919, 11839 };
 int[] sol = new int[8] { 97, 195, 391, 784, 1568, 3136, 6271, 12543 };
 int[] sols = new int[8] { 103, 207, 415, 830, 1661, 3322, 6644, 13298 };
 int[] la = new int[8] { 110, 220, 440, 880, 1760, 3520, 7040, 14080 };
 int[] las = new int[8] { 116, 233, 466, 932, 1864, 3729, 7458, 14917 };
 int[] si = new int[8] { 123, 246,  493, 987, 1975, 3951, 7902, 15804 };

¿Cómo funciona?

Pues es sencillo, cada arreglo contiene 8 elementos, siendo cada elemento la frecuencia de una nota en una determinada octava, muchas de las notas estan redondeadas y otras expresadas en su máximo entero debido a que Console.Beep() solo admite variables de tipo entero. Para invocar a la nota basta con escribir el nombre del arreglo (ut, uts, re, res) y entre corchetes [] la octava deseada menos 1 (debido a que las posiciones del array comienzan desde 0);

Ejemplo:

Si queremos interpretar Do en su 3ra octava escribiríamos lo siguiente:

Console.Beep(ut[2],100);

¿Por que UT y no DO?

“do” es una palabra reservada, por ello consideré el nombre de UT para reemplazar a “do”, recordemos que Do en un principio tenia el nombre de UT

Actualización 28/10/2009:

¿Usas GNU/Linux? Ahora podras escuchar, ejecutar, leer y modificar la marcha imperial desde tu terminal! Solo necesitas tener instalado el comando beep y claro también un beep en la mainboard de tu PC Lee este post Imperial March Bash Beep y descarga el script aquí!

Darth Vader

No explicaré a detalle ya que son 333 líneas de código y jamás terminaría de escribir esta entrada, así que solo mostraré uno que otro detallito! La partitura la conseguí de por ahi y la pongo a disposición aquí es un arreglo para piano, el código C Sharp de esta melodía esta publicada en develop.ignoranto.info (haz clic para descargar) y el binario ya compilado (y libre de virus) se encuentra aqui (haz clic para descargar y escuchar) para escucharlo necesitas el framework dotnet.

¿Que de especial tiene ésta melodía?

• Esta formada por más de 20 métodos
• Existe la función tremolo(); con esta función podemos dar el efecto de trémolo a las notas musicales

El método trémolo es el siguiente:

static void tremolo(int frecuenciaPAR, int duracion)
{
 for (int x = 0; x < 8; x++)
 {
  if (x % 2 == 0)
   Console.Beep(frecuenciaPAR, duracion / 8);
  else
   Console.Beep(frecuenciaPAR / 2, duracion / 8);
 }
}

Una pequeña explicación de éste método
Cuando queremos hacer o dar el efecto de trémolo tenemos varias alternativas, una de las que se usa en el piano es alternar entre octavas, es decir (ejemplo), si tocamos un Re entonces tenemos que tocar luego un Re superior (una octava arriba) y alternamos entre el Re y el Re más agudo, así es como funciona este método trémolo, divide el tiempo entre 8 y con un bucle repite la operación 8 veces, para alternar entre octavas pregunta si “el número de veces (numero de veces que tenee que repetir el bucle)” que está procesando es par (módulo = 0) entonces ejecutará la nota correspondiente, si es impar una nota mas grave (una octava abajo); como ejemplo tenemos a LA, si queremos hacer un trémolo de LA, durante 600 milésimas de segundo escribiríamos asi:

tremolo(440, 600);

Esto produciría un trémolo de 600 milésimas de segundo de duración de la nota LA.

Pronto escribiré esta melodia en BASH asi podremos ejecutarla en nuestro terminal en GNU/Linux, cuando disponga de tiempo lo escribiré en userRPN para las calculadoras HP 50G!

Puedes encontrar más información sobre el uso beel aquí > Metodo System.Console.Beep()

¿Conoces a Johann Sebastian Bach? Bach es mi ídolo, admiro bastante a este compositor, por ello escribí la Gavotte de la Suite Inglesa 3 de Johann Sebastian Bach en Console.Beep();

Descarga, lee y compila el código!

Darth Vader aprendiendo a programar!

Actualización 28/10/2009

¿Usas GNU/Linux? ¿Mono ejecuta el binario pero no suena la bocina de tu PC? La solución esta en éste post: Imperial March Bash Beep, un script en BASH con las frecuencias de la Marcha Imperial de StarWars listo para ejecutar, incluye control de tempo para ejecutarlo al tempo (bpm, negras por minuto) que más gustes!

Continuando con el post …

Anteriormente escribí aquí como hacer crear pequeñas melodías usando una consola en GNU, ahora le tocó el turno a Microsoft Windows; usaremos Microsoft Visual Studio y programaremos en Do Sostenido (C#, C Sharp) la melodía de StarWars.

En este pseudotutorial haremos uso del método Console.Beep() de la clase System en C Sharp, si quieres conocer más a fondo como funciona éste método puedes leer >> Sobrecargas en Console.Beep();

Gerber dice:

No me hago responsable por el uso inadecuado de Console.Beep(); si exageras escribiendo frecuencias muy altas puedes llegar a dañar TUS OIDOS y probablemente también dañar el hardware de tu ordenador!

Requisitos:

1. Conocimientos básicos de programación en C Sharp
   Métodos y Bucles
2. Paciencia y Muchas ganas de programar
3. Amor por la música

Comenzemos…

Arreglo de la Partitura de Star Wars

Programar toda la melodía escribiendo “nota por nota” nos llevaría dias, meses (y quizá años); para ello crearemos (e implementaremos) métodos y haremos uso de bucles FOR para llamar (o repetir) “ciertas secuencias musicales” las veces que sean necesarias durante la melodía!

Console.Beep(int frecuencia, int duración_sonido);
Este método de la clase consola necesita 2 parámetros, el primero es la frecuencia de tipo ENTERO (no double, no float) y la duración del sonido expresado en milésimas de segundo, ejemplo si quisieramos hacer sonar una LA (frecuencia = 440hertz) durante 3 segundos (3000 milésimas de segundo) escribiríamos asi:

Console.Beep(440, 3000) // laaaaaaaaaaaaaaaaa

Aquí tenemos una tabla de frecuencias de las notas musicales, sería bueno que echemos un vistazo para conocer las frecuencias, es necesario redondearlas (o expresar su máximo entero) para usar la frecuencia en Beep();

Se ha dividido el tema en 3 partes, cada parte es un método (método = función, procedimiento) y cada método ejecuta una secuencia de notas diferentes (estas notas están asociadas en otros métodos), los métodos son: partI_starwars(); partII_starwars(); y final();

El método partI_starwars(); ejecuta este fragmento!

La primera parte esta formada por 3 métodos:

• rerere(); ejecuta un tresillo (tres notas en una corchea) de la nota RE
• dosila(); ejecuta un tresillo con las notas Do Si La
• dosido(); ejecuta un tresillo con las notas Do Si Do

A continuación el código de cada método (rerere, dosila, dosido)

//tresillo re re re
static void rerere(int d)
{
 //un bucle FOR repite 3 veces el Beep
 for (int x = 0; x < 3; x++) {
   Console.Beep(523, d); //re
 }
}

//tresillo do si la
static void dosila(int d)
{
 Console.Beep(1046, d); //do
 Console.Beep(987, d); //si
 Console.Beep(880, d);//la
}

//tresillo do si do
static void dosido(int d)
{
 Console.Beep(1046, d);
 Console.Beep(987, d);
 Console.Beep(1046, d);
}

Cada tresillo recibe un parámetro, en esta melodía he tomado 1200 milésimas de segundo como duración de una negra, como sabemos (si es que sabemos) los tresillos se ejecutan en el lapso de una corchea, entonces nuestra corchea vale 600 (la mitad de la negra), y cada tresillo valdría 200, es por eso que el parámetro (int d) recibirá un 200; también se ha usado un bucle para que se repita el primer tresillo (rerere), ahora veremos cómo esta compuesto nuestro método partI_starwars();

static void partI_starwars()
{
 rerere(200); // llamamos a la funcion rerere()
 Console.Beep(783, 1200); //sol
 Console.Beep(1174, 1200);//re2
 dosila(200); //funcion dosila()
 Console.Beep(1567, 1200); //sol2
 Console.Beep(1174, 600); //re2
 dosila(200); //nuevamente funcion dosila()
 Console.Beep(1567, 1200); //sol2
 Console.Beep(1174, 600); //re2
 dosido(200); //ahora dosido()
 Console.Beep(880, 1200); //la
}

El método partII_starwars();

La segunda parte está formada por los métodos:

• reremimi(); Como verán existe un puntillo, re … re mi… mi
• frase000(); Una larga melodía
• frase001(); Otra larga melodía
• frase002(); Y La última casi larga melodía

Estos métodos no reciben parámetros, y se ejecutan de modo secuencial, aquí el código de los métodos (reremimi, frase001…)

static void reremimi()
{
 Console.Beep(523, 400); //re
 Console.Beep(523, 200); //re
 Console.Beep(659, 900); //mi
 Console.Beep(659, 300); //mi
}

static void frase000()
{
 Console.Beep(1046,300);//do
 Console.Beep(987, 300);//si
 Console.Beep(880, 300);//la
 Console.Beep(783, 300);//sol

 Console.Beep(783, 300);//sol
 Console.Beep(880, 150);//la
 Console.Beep(987, 150);//si
 Console.Beep(880, 300);//la
 Console.Beep(659, 300); //mi
 Console.Beep(733, 600); //fa#
}

static void frase001()
{
 Console.Beep(1046, 300);//do
 Console.Beep(987, 300);//si
 Console.Beep(880, 300);//la
 Console.Beep(783, 300);//sol

 Console.Beep(1174, 900);//re2
 Console.Beep(880, 300);//la
 Console.Beep(880, 600);//la
}

static void frase002()
{
 Console.Beep(1174, 400); //re2
 Console.Beep(1174, 200); //re2
 Console.Beep(1567, 400); //sol2
 Console.Beep(1396, 200); //sol2
 Console.Beep(1244, 400); //mib
 Console.Beep(1174, 200); //re
 Console.Beep(1046, 400); //do
 Console.Beep(923, 200);  //sib
 Console.Beep(880, 400);  //la
 Console.Beep(783, 200);  //sol
 Console.Beep(1174, 600);//re2
 for (int x = 0; x < 3; x++)
 {
  Console.Beep(880, 200);  //la
 }
 Console.Beep(880, 600);  //la
}

Luego tendremos que asociar éstos métodos en el método principal que es partII_starwars(); solo haremos una llamada a cada método y éstos iran ejecutando sus partes!

static void partII_starwars()
{
 reremimi();frase000();
 reremimi();frase001();
 reremimi();frase000();
 frase002();
}

La parte final

Final de la melodía de StarWars

Ahora solo nos queda el método final(); es tan simple y está formado por 2 bucles y 2 largas notas

static void final()
{
 for (int x = 0; x < 3; x++)
 {
  Console.Beep(1174, 200); //re2
 }
Console.Beep(1567, 1800); //sol2

for (int x = 0; x < 3; x++)
 {
  Console.Beep(783, 200); //re2
 }
 Console.Beep(783, 1800);  //sol
}

Los bucles ejecutan los tresillos y las largas notas son las Blancas (equivalen a 2 negras) pero son blancas con puntillo (el puntillo equivale a la mitad de su propia duración) eso quiere decir que equivale a 1800 milésimas de segundo (1200 = blanca, 600 = mitad de blanca => 1200+600 = 1800).

Ahora solo nos queda armar el Main(), el cual se encargará de ejecutar la primera, segunda parte y la parte final, su código es:

static void Main()
{
 //repetimos la primera parte 2 veces
 //asi esta en la partitura 
 for (int x = 0; x < 2; x++) {partI_starwars();}
 //ejecutamos la segunda parte 1 sola vez
 partII_starwars();
 //nuevamente la primera parte vuelve a ejecutarse
 //2 veces
 for (int x = 0; x < 2; x++) { partI_starwars(); }
 //ejecutamos el final de la melodia
 final();
}

El código de ésta melodía la encuentras aquí > starwars beep.cs, si quieres escuchar la melodía (sin necesidad de compilar el código) puedes descargarte el binario (libre de virus) starwars_beep.exe; para ejecutar necesitas el framework.net

¿Encontraste algún fallo? Puedes escribirme a gerber@ignoranto.info