Luego del post anterior (donde les contaba mi triste destino…) decidí compartir unas cuantas líneas de código, en esta oportunidad les escribo algo sobre la programación en calculdoras HP 50G, resulta que ésta es una de mis calculadoras favoritas (jaja en realidad es la única que tengo), a continuación detallo alguna de las características del hardware de ésta calculadora:

• Procesador ARM @75Mhz (ARM920T)
• Resolución de Pantalla: 131 x 80 píxeles
• Memoria RAM: 512KB (300kb para el usuario)
• Memoria FLASH: 2MB (800KB para el usuario)

Bueno el motivo de éste post es programar música en la calculadora HP 50 G…

SI! Música, resulta que quien redacta este artículo es un músico frustrado y aprovechando que ésta calculadora posee un beeper piezoeléctrico y tiene capacidad de programación, entonces que mejor manera de aprender algo de programación en User_RPL haciendo algo de música!

Primero, unos cuantos conceptos sobre el lenguaje userRPL

• UserRPL significa RPL del Usuario, es el lenguaje en el que programamos cosas sencillas sin manejar excepciones (a nivel hardware) que pueda tener la calculadora, es un lenguaje de alto nivel
• RPL significa Reverse Polish Lisp, traduciendo a nuestra lengua madre significaría Lisp Polaco Inverso;
• RPN significa Notación Polaca Inversa, es una notación matemática donde no hace falta usar paréntesis, en el caso de la calculadora se aplica al manejo de PILA (stack)

Entendiendo un poco la  Notación Polaca Inversa, la lógica es sencilla y fácil de entender, a continuación unos ejemplos

2 + 3 en RPN es 2 3 +
4/3 en RPN es 4 3 /
(4 + 8 ) / 3 en RPN es 4 8 + 3 /
4 * (7  / 1 ) – 3 en RPN es 4 7 1 / * 3 -
1 * (((((4+7)*5)/2)^2)+1) en RPN es 4 7 + 5 * 2 / 2 ^ 1 + 1 *

Como vimos en los ejemplos anteriores, el uso de paréntesis queda limitado, las operaciones se resuelven segun la pila (el orden) y cada operador en realidad es una funcion, por lo cual si tuvieramos la funcion FPOS, la notación se mantiene siempre de la siguiente manera:

fpos(4,3) + 4 en RPN es 4 3 fpos 4 +

¿Cómo programar en la HP50G?

No pretendo explicar detalladamente la programación de esta calculadora, solo me limitaré a dar pequeñas nociones, tenemos 2 formas (algebraico y RPN) y 4 lenguajes (HP-Basic, UserRPL, SystemRPL, ML ); en este post me limitaré a explicar la sintaxis de UserRPL y la notación RPN, prometo a futuro crear un sitio exclusivo donde explicaré de forma detallada la programación de ésta y otras calculadoras…

1. Encender la calculadora
2. Configurar tu calculadora para que funcione en RPN (Boton MODE > Operating Mode: ‘RPN’ > ENTER)

Si ya estamos en MODO RPN, entonces aqui viene la parte divertida, todos los programas en ésta calculadora comienzan y terminan con estos simbolos: « », por lo cual ahora crearemos una funcion:

f(x) = x ^2;

La cual en Notación Polaca Inversa, sería:

x 2 ^

Veamos como programar esta pequeña funcion en la calculadora, a continuación el código y luego ire detallando…

« → X « X 2 ^» » F STO

Explicación del código anterior:

• « → X; con ello iniciamos un programa y depositamos cualquier dato que esté en la pila como la variable X
• « x 2 ^»; iniciamos un subprograma con los simbolos « » el cual nos retornará el valor de X al cuadrado
• Terminamos el programa principal con »
• Creamos la variable F y como tenemos un “programa” (un objeto) en la Pila de Datos, entonces con el comando STO depositamos el valor del objeto (el programa) en la variable F
  Con ello conseguimos guardar todo el codigo en la variable F como si el código se tratase de un simple número (esto es lo fantástico)

Para poner en marcha el pequeño programa basta con escribir un numero y seguido de él la letra F, presionar Enter y ver los resultados

8 [espacio] F [enter] nos devuelve 64, o sino 8 [enter] F [enter] y tambien nos devuelve 64

Ahora veamos lo más interesante…

¿Música en la calculadora HP50g?

Si! Es posible, como dije anteriormente tenemos un BEEP en el aparatito en cuestión el cual haremos sonar metiendole frecuencias y duración de las mismas, con ello conseguimos música! SI quieres comprobar las capacidades sonoras de tu calculadora escribe el siguiente código:

1760 [espacio] .5 [espacio] BEEP [enter]

Tu calculadora deberá producir un BEEP de medio segundo de duración y 1760hz que equivale a una LA aguda (muy aguda), te parece si ahora hacemos un bucle?

« → A
« WHILE A 0 > REPEAT
1760  0.1 BEEP  A 1 – ‘A’ STO
END
»
» MM STO

Explicación del código anterior:

• → A; Depositamos el número de la pila (stack) como la variable A
• WHILE A 0 > REPEAT (mientras A sea mayor que Cero repetir)
• 1760 0.1 BEEP A 1 – ‘A’ STO; Hacemos sonar un Beep de 1760Hz durante 0.1 Segundos y luego restamos el valor de A en 1 y lo depositamos como A
• END (Fin)
• Guardamos todo el codigo anterior como la variable MM

Para poner en marcha el código, escribe cualquier numero y luego ejecuta MM, ejemplo:

10 [espacio] MM [enter]

Debería dar 10 pitidos!

Star Wars Imperial March in HP 50G, How To

Bueno, luego de tanta explicación (para enteder la lógica de la calculadora), veremos a continuación el código de la Marcha Imperial!

«
.48 'N' STO

523 'D' STO
554 'DS' STO
587 'R' STO
622 'RS' STO
659 'M' STO
698 'F' STO
739 'FS' STO
783 'S' STO
830 'SS' STO
880 'L' STO
932 'LS' STO
987 'SI' STO

S N BEEP
S N BEEP
S N BEEP

RS N 4 / 3 * BEEP
LS N 4 / BEEP
S N BEEP

RS N 4 / 3 * BEEP
LS N 4 / BEEP
S N 2 * BEEP

R 2 * N BEEP
R 2 * N BEEP
R 2 * N BEEP
RS 2 * N 4 / 3 * BEEP
LS N 4 / BEEP
FS N BEEP

RS N 4 / 3 * BEEP
LS N 4 / BEEP
S N 2 * BEEP

S 2 * N BEEP
S N 4 / 3 * BEEP
S N 4 / BEEP
S 2 * N BEEP

FS 2 * N 4 / 3 * BEEP
F 2 * N 4 / BEEP
M 2 * N 4 / BEEP
RS 2 * N 4 / BEEP
M 2 * N BEEP

SS N 2 / BEEP
R 2 * N BEEP
D 2 * N 4 / 3 * BEEP
SI N 4 / BEEP
LS N 4 / BEEP
L N 4 / BEEP
LS N BEEP

RS N 2 / BEEP
FS N BEEP

RS N 4 / 3 * BEEP
FS N 4 / BEEP

LS N BEEP
S N 4 / 3 * BEEP
LS N 4 / BEEP
R 2 * N 2 * BEEP

S 2 * N BEEP
S N 4 / 3 * BEEP
S N 4 / BEEP
S 2 * N BEEP

FS 2 * N 4 / 3 * BEEP
F 2 * N 4 / BEEP
M 2 * N 4 / BEEP
RS 2 * N 4 / BEEP
M 2 * N BEEP

SS N 2 / BEEP
R 2 * N BEEP
D 2 * N 4 / 3 * BEEP
SI N 4 / BEEP
LS N 4 / BEEP
L N 4 / BEEP
LS N BEEP

RS N 2 / BEEP
FS N BEEP

RS N 4 / 3 * BEEP
LS N 4 / BEEP
S N BEEP

RS N 4 / 3 * BEEP
LS N 4 / BEEP
S N 2 * BEEP

R 2 / N 2 / BEEP
R N 4 / BEEP
R N 4 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP
D N 4 / BEEP
D N 4 / BEEP

R 2 / N 2 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
L N 4 / BEEP
L N 4 / BEEP
FS N 4 / BEEP
FS N 4 / BEEP

R 2 / N 2 / BEEP
R 2 * N 4 / BEEP
R 2 * N 4 / BEEP
DS 2 * N 4 / BEEP
DS 2 * N 4 / BEEP
L N 4 / BEEP
L N 4 / BEEP
D 2 * N 4 / BEEP
D 2 * N 4 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
FS N 4 / BEEP
FS N 4 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP

R 2 / N 2 / BEEP
R N 4 / BEEP
R N 4 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP
D N 4 / BEEP
D N 4 / BEEP

R 2 / N 2 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
L N 4 / BEEP
L N 4 / BEEP
FS N 4 / BEEP
FS N 4 / BEEP

R 2 / N 2 / BEEP
S 2 * N 4 / BEEP
S 2 * N 4 / BEEP
RS 2 * N 4 / BEEP
RS 2 * N 4 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
SS N 4 / BEEP
SS N 4 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP
SI 2 / N 4 / BEEP
SI 2 / N 4 / BEEP
SS 2 / N 4 / BEEP
SS 2 / N 4 / BEEP

S 2 / N 2 / BEEP
R N 4 / BEEP
R N 4 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP
D N 4 / BEEP
D N 4 / BEEP

S 2 / N 2 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
L N 4 / BEEP
L N 4 / BEEP
FS N 4 / BEEP
FS N 4 / BEEP

S 2 / N 2 / BEEP
R 2 * N 4 / BEEP
R 2 * N 4 / BEEP
DS 2 * N 4 / BEEP
DS 2 * N 4 / BEEP
L N 4 / BEEP
L N 4 / BEEP
D 2 * N 4 / BEEP
D 2 * N 4 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
FS N 4 / BEEP
FS N 4 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP

SS 2 / N 2 / BEEP
RS N 4 / BEEP
RS N 4 / BEEP
M N 4 / BEEP
M N 4 / BEEP
DS N 4 / BEEP
DS N 4 / BEEP

SS 2 / N 2 / BEEP
SI N 4 / BEEP
SI N 4 / BEEP
LS N 4 / BEEP
LS N 4 / BEEP
S N 4 / BEEP
S N 4 / BEEP

SS 2 / N 2 / BEEP
SS 2 * N 4 / BEEP
SS 2 * N 4 / BEEP
RS 2 * N 4 / BEEP
RS 2 * N 4 / BEEP
SI N 4 / BEEP
SI N 4 / BEEP
L N 4 / BEEP
L N 4 / BEEP
M N 4 / BEEP
M N 4 / BEEP
D N 4 / BEEP
D N 4 / BEEP
L 2 / N 4 / BEEP
L 2 / N 4 / BEEP

L 2 / N BEEP
L 2 / N BEEP
L 2 / N BEEP

F 2 / N 4 / 3 * BEEP
D N 4 / BEEP
L 2 / N BEEP

F 2 / N 4 / 3 * BEEP
D N 4 / BEEP
L 2 / N 2 * BEEP

M N BEEP
M N BEEP
M N BEEP

F N 4 / 3 * BEEP
D N 4 / BEEP
SS 2 / N BEEP

F 2 / N 4 / 3 * BEEP
D N 4 / BEEP
L 2 / N 2 * BEEP

L N BEEP
L 2 / N 4 / 3 * BEEP
L 2 / N 4 / BEEP
L N BEEP

SS N 4 / 3 * BEEP
S N 4 / BEEP

FS N 4 / BEEP
F N 4 / BEEP
FS N BEEP

LS 2 / N 2 / BEEP
M N BEEP
R N 4 / 3 * BEEP
DS N 4 / BEEP

D N 4 / BEEP
SI 2 / N 4 / BEEP
D N BEEP

F 2 / N 2 / BEEP
S 2 / N BEEP

F 2 / N 4 / 3 * BEEP
D N 4 / BEEP
L 2 / N BEEP

F 2 / N 4 / 3 * BEEP
D N 4 / BEEP
L 2 / N 2 * BEEP

"IMPERIAL MARCH
Ignoranto.Info" MSGBOX

'N' PURGE
'D' PURGE
'DS' PURGE
'R' PURGE
'RS' PURGE
'M' PURGE
'F' PURGE
'FS' PURGE
'S' PURGE
'SS' PURGE
'L' PURGE
'LS' PURGE
'SI' PURGE

»

Algo de explicación…

Primero Declaramos las Variables, en los ejemplos anteriores vimos que usabamos una flechita → para depositar variables, dicha flechita genera variables locales (las cuales se eliminan al finalizar el programa) en este caso usaremos variables globales pero luego de finalizar el script las eliminaremos:

.48 ‘N’ STO Declaramos la N como global (nótese las media comillas), es la duración de una NEGRA

523 ‘D’ STO Declaramos D, la frecuencia de la nota DO
554 ‘DS’ STO Declaramos DS, la frecuencia de la nota DO#
587 ‘R’ STO Declaramos R, la frecuencia de la nota RE
622 ‘RS’ STO Declaramos RS, la frecuencia de la nota RE#

… hasta terminar de declarar toda una Octava

Luego en la parte final del script

‘N’ PURGE Eliminamos la variable N
‘D’ PURGE Eliminamos la variable D
‘DS’ PURGE Eliminamos la variable DS
…

A partir de S N BEEP comienza la musiquita, ya que S tiene la frecuencia de la nota SOL y N es la duración de una Negra, BEEP el comando mágico que hace sonar el Buzzer!

Para reproducir la música en tu calculadora deberías escribir todo ese código en ella misma y luego guardar como un objeto (variable, archivo); pero existe una solución, la cual es descargar mi script: imperial march hp50g; o copiar y pegar el código anterior en el programa HPuserEdit y luego Archivo > Exportar a Objeto Binario, posteriormente copiar el Script en la tarjeta de memoria y leerlo en la calculadora!

Fin!

Comenta o sino escríbeme >> grbr@ignoranto.info

In English…

Hello! Download here: Imperial March GNU/Linux Bash Beep

Darth Vader

Para conocer un poco el funcionamiento de Beep en BASH recomiendo leer este pequeño post: Beep Bash.

La partitura (un arreglo simple) para piano y el script: Imperial March Bash Beep

Ésta melodía se agrupa en varias frases las cuales constan de “beeps” y son llamadas en orden según la composición de la melodía, aquí solo una de las frases:

function frase000
{
for ((i=0;i<3;i+=1)); do
 pitido ${SOL[3]} $NEGRA;
done;
 pitido ${RES[3]} $CORCHEAP;
 pitido ${LAS[3]} $FUSA;
 pitido ${SOL[3]} $NEGRA;

 miSiSol;
}

La función anterior reproduce un bucle con la nota SOL de la 3ra octava +1 (los arrays comienzan de 0), por lo cual estaría tocando SOL SOL SOL y cada sol con la duración de una NEGRA, luego de ello llamamos a la funcion miSiSOl, el cual reproduce dichas notas , como verán el código es entendible, la función “pitido” recibe 2 parámetros, la frecuencia y la duración de la nota, en realidad dicha funcion hace llamado a beep, el pequeño programa que se encarga de producir beeps;

Luego de todo ello he implementado la función trémolo, el cual hace un trémolo intercambiando octavas dependiendo a un lapso de tiempo, la función recibe 3 parámetros y el código es el siguiente:

function tremolo
{
 let F1=$1;
 let F2=$2;
 let DUR=$3
 let FU=50;
 let FD=25;

 while [ $FU -le $DUR ];
 do
 pitido $F1 $FD;
 pitido $F2 $FD;
 let FU=$FU+50;
 done;

}

Recibimos el primer parametro y lo guardamos como F1 de la misma manera con F2 y DUR (usamos let para evaluar (operar aritmeticamente) las entradas), iniciamos un bucle, mientras FU sea menor que DUR (duración del trémolo) entonces ejecutará 2 pitidos el primero con la primera frecuencia y el segundo con la segunda frecuencia, cada pitido con 25 milésimas de segundo de duración, luego cambiamos el valor de FU y le añadimos su mismo valor incrementado en 50 (la duracion de ambos pitidos).

Descarga y ejecuta el Script

Sin más que escribir les presento: Imperial March Bash Beep Para ejecutarlo necesitamos darle permisos de ejecución y luego escribimos en la carpeta donde guardamos el script ./nombreArchivo.sh o sh nombreArchivo.sh, el script les solicitará un tempo (notas “negras” por minuto [bpm]), recomiendo colocar un tempo entre 100 y 140.

Es IMPORTANTE tener instalado el comando BEEP, si usas un sistema basado en debian basta con escribir “apt-get install beep” en la linea de comandos

¿Algo más? SI! Pronto (cuando disponga de tiempo) escribiré esta misma melodía en userRPL para las calculadoras HP50G

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

Y tu, que opinas?