TOP

¡Feliz 2014!

Querido geek:

Ya hacia tiempo que no escribía una entrada, por diversos motivos. Y hoy no podía dejar que se acabara el año sin escribir una para desearos a todos un feliz año nuevo.

Para este 2014  tengo muchas ideas para escribir. Me gustaría hacer más tutoriales, artículos, noticias sobre tecnología relevantes y demás. Y proyectos que tengo en mente, y por supuesto acabar algunos proyectos que tengo por ahí que empiezo y no acabo! A propósito, varios usuarios contactaron conmigo que estaban interesados en el NDS Save Backup (que lo tengo un poco abandonado), como dije en su día hasta que no lo tuviera funcional 100% no lo iba a publicar publicar, pero visto el interés de la gente publicare una beta, pero antes debo de arreglar un fallo que vi en su momento. No será a corto plazo ya que tengo que hacer cosas de mayor importancia.
También ahora que están muy de moda las impresoras 3D, este nuevo año publicaré artículos y tutoriales sobre impresión 3D.

¡Un Saludo y Feliz Año Nuevo!

Nitehack.
TOP

NDS Save Backup - Progreso

-¿Qué es el NDS Save Backup? 
Es un dispositivo (que será Open Source Hardware) controlado por un microcontrolador PIC 18F4550 para extraer partidas guardadas de juegos de DS y 3DS al PC mediante USB.

Fig.1.: NDS Save Backup en fase de desarrollo

-¿Cuál es el estado actual del NDS Save Backup?
Actualmente puede extraer partidas de juegos de DS con EEPROM (los juegos de 3DS con EEPROM no los he probado, pero puede que también  extraiga las partidas ya que posiblemente utilice los mismo comandos).


-¿Qué es lo que falta para que esté terminado?
Falta implementar el método de extracción de partidas de juegos de DS/3DS que utilizan Memoria flash como método de almacenamiento, y  un método de escritura de partidas de juegos de DS/3DS en memorias EEPROM y memorias flash.

•El hardware
Los materiales que componen el hardware están pensados para que cualquiera los pueda adquirir y pueda construirse su propio  NDS Save Backup compuesto por un PIC 18F4550, una ranura de Nintendo DS*, condensadores, resistencias, un oscilador, etc.

*Nota: La ranura o slot de Nintendo DS se puede adquirir en Dealextreme por un precio de 2.10$

•El software:
La aplicación que se comunica con el PIC 18F4550 está escrita en VB.


Fig.2.: Aplicación NDS Save Backup 


Como dije en unas entradas atrás de este blog, el código del programa, del PIC y los esquemas del circuito del NDS Save Backup los subiré cuando lo tenga terminado al 100%.  Si alguien está muy interesado puedo subir más adelante la aplicacion ya compilada, el .hex del PIC y un esquema del hardware.

Si quieres estar al tanto sígueme en mi Twitter: @Nitehack

¡Un Saludo!


TOP

Análisis del Hardware de Google Glass

Las "revolucionarias" gafas de Google, las Google Glass,  han dado mucho que hablar en este último año. En esta entrada os hablaré de su parte técnica viendo de qué están hechas estas gafas por dentro.


Antes de nada gracias a la página de http://www.catwig.com/google-glass-teardown/ sabemos cómo son las entrañas de esta curiosas gafas. Yo me baso en las fotos de esa página y diversa información que he encontrado a través de la red.

Al destripar las Google Glass veremos todo esto:

Fig.1: Google Glass desarmadas


Vemos que estas gafas están compuestas por un touchpad, una micropantalla, la óptica para reflejar las imágenes, un altavoz, una cámara, una batería y una placa base donde estará el cerebro de Google Glass, y como no! las monturas!

•Touchpad
El touchpad es un panel táctil con el que se controlarán los menus del sistema y realizar diversas acciones.
Este es similar a los touchpad de los portátiles. El controlador de este panel es un Synaptics T1320A el cual también es usado en portátiles como Samsung Series 9 notebook.

Fig.2: Panel Touchpad

Controlador Touchpad
Synaptics T1320A


•Micropantalla
La micropantalla se utiliza como micro-proyector para el cristal óptico. La pantalla tiene una resolución de 640x360 pixeles. Como se puede ver en la siguiente imagen es muy pequeña:
Fig.3.: Micropantalla comparada con una moneda


•Altavoz
El altavoz que incluye las gafas no es un altavoz normal, es de conducción ósea. Este altavoz transmite el sonido a través de los huesos. Para más información click aquí.

Fig.4.: Altavoz de conducción ósea

•Cámara
La cámara que incorpora Google Glass es de 5 megapixeles del tamaño de la cámara de los smartphones, es probable que también se use en algunos.

Fig.5.: Cámara

En el siguiente video se muestra la calidad de la cámara:



•Batería
Dispone de una batería de 2.1 Wh, mas o menos 570 mAh

Fig.6.: Batería

•Placa Base
En la placa base encontramos lo siguiente:
Cara A:

Fig.7.: Cara A placa base

Cara B (parte de atrás):

Fig.8.: Cara B placa base

Cara A:

Procesador
TI OMAP 4430 1 GHz de doble núcleo
Memoria RAM
DRAM ELPIDIA B81S4R3PF - 8D de 1 GB
Memoria FLASH
SanDisk SDIN5C2  de 16 GB de capacidad
Administrador de energía
(pulsar el nombre del modelo para ver el datasheet de algunos integrados)

Cara B:

Módulo Wifi/Bluetooth
USI WM-BN-BM-04-a
Controlador GPS
(pulsar el nombre del modelo para ver el datasheet de algunos integrados)

El procesador de las Google Glass es un OMAP 4430 1GHz de doble nucleo de Texas Instruments, que es el mismo que llevan algunos tablets como el Kindle Fire, el Samsung Galaxy Tab 10.1 y otros más. Este procesador no se ve en la Fig.7. ya que se encuentra  debajo del integrado de la memoria DRAM ELPIDIA. En el Kindle Fire ocurría lo mismo, el procesador se situaba debajo de la RAM:

Fig.9.: Procesador Kindle Fire



Como pueden ver las Google Glass son comparables con los smartphones actuales, aunque para el fin que tienen estas gafas sus características van de sobra.

En la siguiente tabla  como resumen, recojo las características técnicas más relevantes:

Procesador
1 GHz de doble núcleo
RAM
1 GB
Memoria interna
16 GB
Cámara
5 Mpx
Display
640x360 pixeles
Batería
570 mAh

Un Saludo.
TOP

Fin de exámenes :)

Y después de............ perdí la cuenta! Terminé los exámenes! Si, yo tampoco me lo creo, me creía que los exámenes nunca iban a acabar.

En esta entrada no me quiero extender mucho asi que, como dije, espero mantener el blog más actualizado ahora que tengo más tiempo.

Un Saludo a todos!

TOP

Así va la cosa: Situación actual, web soyteleco, y nuevo proyecto!

Hola a todos! :)
Pues así va la cosa! Llevo ya más de un mes si publicar una entrada debido a que no tengo tiempo ya ni para descansar 5 minutos (-.-) zZ. Dentro de un mes empiezo los exámenes, por lo que estaré menos activo con el blog.

Aprovecho para decir a aquellos que estéis estudiando Telecomunicaciones que se acaba de abrir la página  web  soyteleco.net en la que encontrares libros en pdf, recursos, programas, etc. que te ayudarán a lo largo de la carrera. También dispone de un foro en el que podrás  plantear dudas, debatir temas acerca de la carrera, y muchas cosas más.

Durante este tiempo, los ratos que he tenido tiempo he estado desarrollando (todavia en proceso) lo que llamo yo "NDS Save Backup" que servirá para hacer copias de seguridad de partidas de juegos de NDS ( y puede que trate también para hacer copias de partidas de juegos de 3DS).  Este proyecto consta de una parte de hardware y otra de software: la parte de hadware cuyo cerebro es  un PIC 18f4550 se encargará de extraer la partida, y la parte de software  que será un programa con interfaz gráfica guardará la partida en el PC.
Si lo termino al 100% publicare el código fuente del PIC, asi como el plano del circuito. Es decir será un proyecto de  hardware libre + software libre. Asi cualquiera que quiera montarse uno pueda hacerlo.
NDS Save Backup digamos que está al 50%, ya he comprobado a extraer algunos bytes de un juego pero estoy teniendo algunos problemas para extraer toda la memoria, que espero solucionar cuando termine los exámenes.

En cuanto a la parte de software esta todavia un poco verde. Aqui teneis una captura de la interfaz gráfica, que ni mucho menos es la definitiva ya que es para pruebas:



Como dije al principio de la entrada estaré ausente durante un tiempo debido a las practicas y exámenes de la facultad.
Cuando termine espero publicar algunas entradas que tengo pensadas y seguir con el proyecto.

Un Saludo!




TOP

Encender Nintendo DS sin la pantalla superior [MOD]

Introducción
En esta entrada os enseñaré un mod muy sencillo con el que podréis usar vuestra Nintendo DS Lite con solo la pantalla inferior.
Los que nunca habéis visto una DS con la faja rota lo mismo pensáis que  sigue funcionando igualmente pero con la pantalla inferior....Pues esto no es así! La DS cuando no tiene la LCD superior o inferior pega un flash en la que sí está conectada y se apaga.
He arreglado muchas Nintendo DS a causa del problema de la faja y un buen día me pregunte: ¿Por qué no cojo y simulo que está conectada la pantalla y  la uso si la pantalla superior?
Bueno lo primero que hice fue buscar por Google, pues en Google está todo! :P.....Y bien, no tuve resultado :(
Así que busque el datasheet de la pantalla superior de la Lite, pero solo encontré una parecida a la de la NDS tocha :(
Y ya solo me tocaba ami ponerme a estudiar la LCD....
Bueno y después de pensar, y recorriendo pistas usando el polímetro, hacer cálculos...Aquí tenes la solución!

ANTES DE NADA!
¡HAZ ESTO BAJO TU RESPONSABILIDAD!
¡SI VAS A COPIAR ESTE TUTORIAL EN ALGUN SITIO PON DE FUENTE ESTA ENTRADA!

Materiales
-Dos cables (sin son wrapping mejor)
-1 resistencia de 1KΩ (si es mayor no pasa nada pero tampoco de 1MΩ xD)
-Soldador y estaño (por supuesto :P )

Mini-Tuto
Para usar la Nintendo DS sin la pantalla superior es tan sencillo como colocar una resistencia entre dos puntos.
1º Localizamos en la placa de la DS, los dos puntos que se ven en la imagen.( Para quién le interese: esos dos puntos corresponden con el ánodo y el cátodo de los leds que iluminan la LCD superior. Me fijé que la DS solo verifica que los leds están funcionando, y haciendo cálculos con una resistencia de 1KΩ, pasaría la misma intensidad por la resistencia que con los leds)

2º Pre-estañamos estos dos puntos

3º Le soldamos un cable a cada punto

4º Soldamos la resistencia de 1KΩ en el otro extremo de los cables

5º Le cortamos las patillas a la resistencia. Encendemos la DS y...Voilà! La DS arranca perfectamente!


Ya solo quedaría colocar la resistencia en un lugar donde no estorbe y montar la DS ;)

¡Un Saludo!

ACTUALIZADO (22/10/13):
Actualizo la entrada con los puntos para encenderla con la pantalla superior solo y para la DS "tocha" (la primera). Lo puse hace tiempo en un foro pero se me pasó actualizar la entrada aquí :P

Si solo queréis usar la pantalla superior en vez de la inferior, la resistencia hay que ponerla entre estos dos pines (corresponden a los leds de la pantalla inferior):




Para la DS tocha debería de funcionar igual (no tengo una asi que no lo he probado). Los pines se sitúan en diferente lugar:
Leds de la pantalla superior: marcados como LEDA2 y LEDC2:



Leds de la pantalla inferior: marcados como LEDA1 y LEDC1:



TOP

Cómo hacer una PCB casera

En esta ocasión os traigo un tutorial de cómo hacer una PCB casera con materiales y herramientas fácil de encontrar y además baratos.

¿Que necesitamos?
-Placa de cobre virgen (en las tiendas de electrónica las venden por unos 2 €-3 €)
-Papel grueso (Yo utilizo de 130 gr)
-Imagen de la PCB a imprimir
-Agua fuerte
-Agua oxigenada
-Lana de acero o estropajo de aluminio
-Cepillo de dientes usado que ya no uses (¡ojo! nuevo no, ya que nos interesa que esté un poco desgastado)
-Plancha
-Taladro
-Punzón
-Segueta


¡Manos a la obra!
-Primeramente imprimimos la PCB que queremos hacer en un papel grueso con una impresora láser a máxima resolución.


IMPORTANTE: ¡No vale imprimir el diseño del circuito en una impresora de tinta! Si no tienes una impresora láser (como yo :P) puedes ir a una fotocopiadora a que te impriman el circuito. Lo que vamos buscando es el toner  que deja pegado la impresora laser en el papel

-Cortamos un trozo de la placa de cobre según vayamos a necesitar para la PCB con una segueta


-Una vez cortada la pulimos con la lana de acero o el estropajo de aluminio hasta que quede brillante. Este paso es importante ya que dependiendo de como quede de limpia se pegará mas o menos el toner (de nuestra fotocopia)  en la placa.


Nota: Intenta no tocar con los dedos la placa después de pulirla

-Ponemos la plancha a máxima temperatura y mientras pegamos con "celo" o "fiso"  la fotocopia del circuito a la parte de la placa donde está el cobre. Una vez que se haya calentado la plancha le aplicamos directamente calor a la placa con la fotocopia, haciendo presión para que se desprenda el toner que tiene y quede adherido a esta. Para que se reparta bien el calor podemos hacer movimientos de círculos con la plancha.
Esto lo hacemos durante 5 minutos mas o menos.


Nota: ¡Tampoco debemos pasarnos dándole calor ya que se podría desprender el propio cobre!

-Una vez hecho lo anterior metemos rápidamente la placa con la fotocopia en agua caliente y esperamos sobre 15 minutos o más a que se reblandezca el papel.


-Pasado este tiempo cogemos la placa y empezamos a frotar por la parte de la fotocopia con un cepillo de dientes, y veremos como se va desprendiendo el papel. Vamos echandole agua y frotandole hasta que se quede sin papel la placa y veamos el circuito pegado a la placa de cobre.



(Como podéis ver hay dos pista en la parte de la derecha que no se han pegado bien, esto se puede arreglar marcándolas con un rotulador permanente)

IMPORTANTE: No frotar muy fuerte ya que podríamos romper alguna pista del circuito. En el caso de que no se hayan pegado bien algunas pistas o hayas roto por accidente alguna luego puedes repararlas con un rotulador permanente
Si en este paso te cargas gran parte de las pistas del circuito puedes pulir la placa con el estropajo o la lana de acero y volver a empezar.

-Cogemos un vaso, el agua fuerte y el agua oxigenada para preparar el ácido que atacará al cobre. Yo las medidas que utilizo son 1/2 vaso de agua oxigenada  1/4 de agua fuerte, es decir que siempre tienes que echar de agua fuerte la mitad de lo que eches de agua oxigenada. Y vertimos la mezcla en algún "cacharro" en el que entre luego la placa.
¡Hacer la mezcla en un lugar ventilado!

IMPORTANTE: En este paso hay que tener mucho cuidado con la mezcla ya que el agua fuerte es muy corrosivo y podría hacerte un agujero literalmente en la piel

-Echamos la placa con mucho cuidado en el ácido y "oxigenamos" la placa ayudándonos de unas pinzas largas, teniendo la precaución de que no salpique la mezcla. Y hacemos esto hasta que se haya comido todo el cobre excepto el toner. El tiempo aquí depende de las cantidades de la mezcla, no os desesperéis  Primero veréis que se va poniendo oscura la placa, luego cambiara de color a más claro y finalmente veréis como empieza a desaparecer el cobre empezando por los laterales de la placa.



-Sacamos la placa del ácido con unas pinzas y le aplicamos abundante agua .

-Con el estropajo o con la lana de acero (recomiendo la lana de acero) frotamos la placa hasta quitar el toner del todo (también se puede quitar echándole un poco de acetona y frotar con un papel de cocina o similar).


-Con un polímetro comprobamos si dan continuidad las pistas en los diferentes puntos. En caso de no darla podemos hacer un puente en la zona dañada.

-Marcamos con un punzón los agujeros donde irán los componentes y los taladramos con su correspondiente broca según el diámetro de estos.




-Y..¡ya está! Ya solo nos quedaría ponernos a colocar los componentes y a soldar!

Como extra si quieres tener la PCB más profesional y tienes la impresión de la parte de arriba de la PCB con las indicaciones de donde va cada componente puedes seguir el mismo procedimiento que en este tutorial para pegarlo a la placa, ¡pero si llegar a echarlo en el ácido!

¡Espero que os haya servido este tutorial!

TOP

Termómetro digital con PIC

¡Buenas a todos!
En esta entrada os explicaré como funciona y cómo montar un termómetro digital con un PIC. El PIC por si solo no puede detectar cambios de temperatura por lo que obviamente necesitaremos un sensor de temperatura.

¿Qué necesitaré para montarlo?
-PIC (que tenga modulo A/D y con suficientes patillas para conectar un display LCD)

-Display LCD


-LM35 o LM335 (el LM35 y el LM335 son sensores de temperatura, el primero da un voltaje de 10mV/ºC y el segundo da un voltaje de 10mV/K. El LM335 tiene la ventaja sobre el LM35 que se puede ajustar su valor por una patilla en caso de que no este bien regulado)

-Una resistencia de 1KΩ en el caso de que hayas elegido el LM335

Circuito con el sensor LM35:
Imagen 1: Circuito Termómetro digital PIC+ LM35

Con el sensor LM335 sería igual solo que habría que colocar una resistencia de 1KΩ (ojo solo si lo vamos a alimentarlo con 5V, si se alimenta con menos habría que hacer la cuentas), entre la fuente y la patilla +
Circuito con el sensor LM335:

Imagen 2Circuito Termómetro digital PIC+ LM335

¡Ojo con las patillas! Son diferentes las del LM35 y las del LM335

Vista mirando los sensores con las patillas en perpendicular al plano
Imagen 3: Patillas LM35 y patillas LM335

Nota: Si vuestro sensor tiene otro encapsulado revisad el datasheet. Os he puesto un enlace arriba en los dos nombres

Bueno antes de poneros el código para programarlo, os explicaré como funciona el termómetro para que se entienda mejor el código.
Como dije al principio de esta entrada el sensor de temperatura ya sea el LM35 o el LM335  da un voltaje por una de sus patillas a razón de 10mV/ºC o 10mV/K, la idea es transformar estos voltios a grados Celcius o Kelvin y representarlo por una pantalla, pero ¿cómo?
Lo que haremos será conectar la patilla del sensor que nos da los voltios a una patilla del pic y mediante el módulo A/D (analógico/digital) muestrear y cuantizar la señal analogica que nos va llegando (en este caso una señal electrica), y guardarla en una variable del pic para luego trabajar con ella.
Si utilizamos 10 bits para la conversion A/D, tendremos 1024 "niveles" para usar (2^10). Y si ponemos un limite de  una tensión de 5V (esto lo fijaremos en una patilla del pic que tenga la función de Vref, tensión de referencia) , cada nivel será de  0.0048 V  (5V/1024 posibles niveles). 

Imagen 4: Cuantización de una señal analógica

En el compilador CCS tenemos una función que se llama read_adc() que nos devuelve el nivel de la tensión que hay en ese momento en la patilla que estemos usando como A/D.
Luego una vez que guardemos el valor del nivel (con lectura=read_adc()) podremos calcular la tensión con la siguiente forma:

voltios=5.0*lectura/1024.0;

Una vez calculada cuanta tensión nos da el sensor  lo único que tendremos que hacer será pasarla a temperatura multiplicándola por 100.

temperatura=voltios *100;

Hay que tener una cosa en cuenta, si usamos el LM335 aparte de multiplicar los voltios por 100 tendremos que que restarle 273 si queremos que nos de la temperatura en ºC (recordad que el LM335 tiene una razón de 10mV/K)

Y para tener el termómetro continuamente actualizado usaremos un bucle infinito.



Aqui teneís el código para el PIC16F88 con el sensor LM335:


#include <16F88.h>
#device adc=10 //Ponemos que se usen 10 bits para A/D
#use delay(clock=8000000) //Frecuencia de reloj de 8MHz
#include <lcd.c>

void main()
{
   int16 lectura;
   float voltios;
   float grados;
 
  /************************Configuración delPIC*****************************/
   setup_oscillator(OSC_8MHZ); //Usamos el oscilador interno del PIC a 8MHz
   setup_adc_ports(ALL_ANALOG); //Todos los puertos A como analogicos
   setup_adc(ADC_CLOCK_INTERNAL); //Reloj interno para laconversion ADC
   setup_comparator(NC_NC_NC_NC);
   set_tris_a (0b11111111); //Configuramos todo el puerto A como entrada
   /************************************************************************/

  lcd_init(); //Inicializamos el display LCD
        
       
   while(true)
      {
         set_adc_channel(0);              //PIN_A0 como canal analogico
         delay_us(20);
         lectura=read_adc();              //Leemos el nivel del PIN
     
         voltios=5.0*lectura/1024.0;      //
         grados=voltios*100-273;          //10mV/1K -273= ºC
         printf(lcd_putc,"\f");           //Limpiamos la LCD
         delay_ms(1);
       
         printf(lcd_putc,"Temperatura ");
         printf(lcd_putc,"\n %01.2f C", grados);
         delay_ms(500);
       
       

      }
}


Para cualquier duda escribir un comentario,
Espero os haya gustado esta entrada.

Un Saludo.
TOP

¿Cómo funcionan las alarmas de las etiquetas?

Cuando nos compramos un objeto ya sea una prenda, un videojuego, un CD, etc. Nos encontramos con que tiene una alarma pegada como sistema  anti-hurto. ¿Eres de los que se pregunta como leches detectan los arcos  que están a la entrada de la tienda, el objeto y como desactivan la alarma? 
Si tu respuesta es sí,  esta entrada te puede resultar interesante. ;)

Etiqueta RFID usada como alarma y como "contenedor" de información


Antes de nada decir que existen varios tipos de alarma y según el interés se utiliza una u otra. Yo me centraré en una de las más usadas, basadas en radiofrecuencia.
La alarma está compuesta por una antena helicoidal (normalmente hecha con una tira fina  de aluminio) y un diodo o un circuito RC en el extremo de esta. Estas alarmas suelen estar "implementadas" en etiquetas como las RFID, no tienen alimentación pero cuando les llega cierta onda electromagnética absorben parte de la energía que transmite y se activan, generando la etiqueta a su vez una nueva señal. Bueno ya sabemos como es la etiqueta pero...¿Como funciona el sistema de alarma?


Como sabréis los arcos que están en la entrada de las tiendas no están ahí por gusto. Un arco tiene la función de transmisor de señales, y el otro como receptor de una señal. Pues bien el arco transmisor emite una señal, la etiqueta absorbe parte de la energía de esta y  la etiqueta a su vez emite una señal que es recogida por el arco receptor. El arco receptor está a la escucha de la señal de la etiqueta y la etiqueta solo se excitará a una frecuencia determinada. Obviamente cuando el arco receptor detecte la señal de la etiqueta sonará la alarma.
Para hacer frente a distintos tipos de alarmas el arco transmisor suele hacer un barrido de frecuencias.

Vale ya sabemos como se activa pero ¿Cómo hacen para desactivarla?
Para desactivar la etiqueta lo que se hace es aplicarle un fuerte impulso de una onda RF que provoca que se queme el diodo o el circuito RC que lleva (cuando la etiqueta pase por los arcos ya  no podrá emitir la antena y por lo tanto no sonará la alarma).

Como dije al principio de esta entrada existen más tipos de alarmas (unas que se activan y se desactivan por magnetización), pero espero que este artículo haya servido para que tengáis una idea de como funcionan estos sistemas anti-hurto.

Un Saludo!
TOP

Cómo generar música con un PIC

En esta entrada os explicaré como generar música con un PIC. La idea está sacada de este blog picrobot
Yo trataré de que se entienda mejor la idea y con un código más claro.
Si queremos generar música debemos generar sonidos.


Pero...¿Qué es un sonido?
Un sonido se trata de una onda de presión generada por un cuerpo en vibración que se propaga por un fluido.Tres características básicas del sonido son:
-La intensidad (Lo "fuerte" que se escucha el sonido)
-El tono (La frecuencia del sonido: a mayor frecuencia mas agudo y a menor frecuencia  mas grave)
-La duración (Cuanto dura el sonido)


Para generar un sonido con un PIC obviamente necesitaremos el PIC y un componente que reproduzca esas ondas audibles, el altavoz.
Si ponemos en alto "X" tiempo un pin del PIC y luego en bajo ese tiempo y repetimos esa secuencia, tendremos una onda. (Una onda cuadrada que se puede asemejar a una onda senoidal)


Asi que:
-El tiempo en alto(o bajo) será medio periodo de esta y con ello podremos calcular la frecuencia, es decir el tono.
-La intensidad del sonido será el voltaje que le suministremos al altavoz.
-Y la duración será cuanto tiempo repetiremos la secuencia de alto y bajo.

Ahora bien para generar música no basta con hacer sonidos con las frecuencias que nos de la gana ya que lo mas seguro es que no suene bien, si no que los sonidos deben de tener el tono adecuado, es decir, aquí es donde actúan las notas musicales. 




 Decir que dividimos el espectro audible (de 20 Hz a 20 KHz) en octavas, y las octavas en notas (Si me equivoco en algo que alguien me corrija que no soy experto en música :P).  Tenemos 7 notas musicales  (Do, Re Mi, Fa, Sol, La, Si) , cada una de ellas tendrá una frecuencia determinada. La octava inferior  de una nota tendrán la mitad de frecuencia y la octava superior tendrá el doble de frecuencia.
Por ejemplo la nota "La"  de la tercera octava tiene una frecuencia de 440 Hz, la cuarta octava tiene 880 Hz y la segunda octava 220 Hz. (A partir de esta nota se calculan las demás con unos cálculos)
(Para quién le interese saber más que lea este artículo http://latecladeescape.com/t/Frecuencia+de+las+notas+musicales)

A nosotros solo nos interesarán las primeras 6 octavas ya que por encima de la sexta no se escucha bien con el PIC.
Estas son las frecuencias de cada nota (en Hz):


0
1
2
3
4
5
6
DO
32,70
65,40
130,81
261,62
523,25
1046,50
2093,00
DO#
34,64
69,29
138,59
277,18
554,36
1108,73
2217,46
RE
36,70
73,41
146,83
293,66
587,32
1174,65
2349,31
RE#
38,89
77,78
155,56
311,12
622,25
1244,50
2489,01
MI
41,20
82,40
164,81
329,62
659,25
1318,51
2637,02
FA
43,65
87,30
174,61
349,22
698,45
1396,91
2793,82
FA#
46,24
92,49
184,99
369,99
739,98
1479,97
2959,95
SOL
48,99
97,99
195,99
391,99
783,99
1567,98
3135,96
SOL#
51,91
103,82
207,65
415,30
830,60
1661,21
3322,43
LA
55,00
110,00
220,00
440,00
880,00
1760,00
3520,00
LA#
58,27
116,54
233,08
466,16
932,32
1864,65
3729,31
SI
61,73
123,47
246,94
493,88
987,76
1975,53
3951,06


Para no cargar el PIC con cálculos matemáticos pasamos la frecuencia ya a su equivalencia a T/2 que debe estar en alto o en bajo el PIC (en microsegundos) :


0
1
2
3
4
5
6
DO
15289,02
7644,51
3822,25
1911,12
955,56
477,78
238,89
DO#
14430,91
7215,45
3607,72
1803,86
901,93
450,96
225,48
RE
13620,97
6810,48
3405,24
1702,62
851,31
425,65
212,82
RE#
12856,48
6428,24
3214,12
1607,06
803,53
401,76
200,88
MI
12134,90
6067,45
3033,72
1516,86
758,43
379,21
189,60
FA
11453,82
5726,91
2863,45
1431,72
715,86
357,93
178,96
FA#
10810,97
5405,48
2702,74
1351,37
675,68
337,84
168,92
SOL
10204,20
5102,10
2551,05
1275,52
637,76
318,88
159,44
SOL#
9631,48
4815,74
2407,87
1203,93
601,96
300,98
150,49
LA
9090,90
4545,45
2272,72
1136,36
568,18
284,09
142,04
LA#
8580,67
4290,33
2145,16
1072,58
536,29
268,14
134,07
SI
8099,07
4049,53
2024,76
1012,38
506,19
253,09
126,54


Si habéis entendido lo anterior no será nada difícil entender el código para reproducir música con el PIC.

Funciones que realizaremos:
-Función para reproducir un sonido dada la nota musical (el tono) con su octava y la duración de esta.
-Función para reproducir una canción. (En esta función pondremos los diferentes sonidos (Usando la función anterior) con las diferente pausas para generar la canción).

Para que sea más fácil crear la canción crearemos un vector global con los tiempos de los medios periodos de las notas de la octava 0. Y  para no tener que recordar en que posición del vector están las notas crearemos un define asignando las posiciones del vector con una palabra (el nombre de las notas).



#define nDO     0    // DO
#define nDO_    1    // DO#
#define nRE     2    // RE
#define nRE_    3    // RE#
#define nMI     4    // MI
#define nFA     5    // FA
#define nFA_    6    // FA#
#define nSOL    7    // SOL
#define nSOL_   8    // SOL#
#define nLA     9    // LA
#define nLA_    10   // LA#
#define nSI     11   // SI


int16 FreqNota[12]={  // retardos entre estado alto
                            // y bajo para generar las notas
15289, // DO
14430, // DO#
13620, // RE
12856, // RE#
12134, // MI
11453, // FA
10810, // FA#
10204, // SOL
9631,  // SOL#
9090,  // LA
8580,  // LA#
8099   // SI
};




Pasaremos ahora a la función para generar un sonido con la nota y la duración de esta:

void play(int8 nota, int8 octava, int32 tiempo){ //Tiempo en ms
   int16 i;
   int16 espera;
   int16 vueltas;
   

   espera=FreqNota[nota]; /*Calculamos T/2 que le corresponden a la nota*/
   espera>>=(octava);     /*Calculamos su correspondiente octava
                          /*>>= es desplazamiento a la derecha, lo mismo que si     hiciésemos
                          espera/2 tantas veces como pone despues de  >>= , asi nos ahorramos calculos*/
   
vueltas=(tiempo*1000)/(espera*2); /*Calcula cuantas vueltas tiene que dar el    bucle siguiente, multiplicamos el tiempo por 1000 para pasarlo a us*/
   
   for(i=0; i< vueltas; i++){
      output_high(Altavoz); /*Ponemos en alto el Altavoz*/
      delay_us(espera);     /*Lo dejamos durante el tiempo calculado*/
      output_low(Altavoz);  /*Ponemos en bajo el Altavoz*/
      delay_us(espera);     /*Lo dejamos durante el tiempo calculado*/
   }

}

El único problema que tiene la función anterior es que si la canción es muy larga no entrará en la ROM del PIC debido a que para calcular el tiempo utilizo enteros de 32 bits. (si se usan enteros de 16 bits no podremos hacer la cuenta de  vueltas=(tiempo*1000)/(espera*2); ya que si el tiempo es mayor de 65 ms
al hacer tiempo*1000 sobrepasaremos el tamaño de 16 bits).
(Si vais a hacer un proyecto y le queréis poner una música, ojo con la memoria)
Esto se puede solucionar como el código del blog picrobot que permite hacer canciones de mayor tamaño en menos espacio, aunque el código es un poco mas lioso y largo:


void Play(int nota, int octava, int16 duracion){
 int16 fn;

 int16 mS_Transcurridos=0;  // Contadores necesarios
                            // para controlar la duración
 int16 CiclosL=0;           // Contandor de uS

 fn=FreqNota[nota];         // Define los retardos para generar
                            // la frecuencia de cada nota
 fn>>=(octava);             // Adapta la frecuencia a la octava actual
                            // haciendo una rotación
                            // a la derecha por octava
do{

    output_high(Speaker);   // Genera la frecuancia
    delay_us(fn);           // con los retardos mientras
    CiclosL+=(fn);          // aumenta el contador de 
                            // ciclos transcurridos
    output_low(Speaker);    // en dos partes para repartir el
    delay_us(fn);           // trabajo entre estado alto y bajo.
    CiclosL+=(fn);          //
    CiclosL+=25;            // Compensador.

    while(CiclosL>999){     // Se queda en el bucle mientras CiclosL
                            // sea menor a 1000 (1 mS)
       CiclosL-=1000;       // Le resta 1000 a CiclosL
       mS_Transcurridos++;  // y le suma 1 a mS_Transcurridos.
       CiclosL+=25;         // Compensador.
    }
 }while (duracion>mS_Transcurridos); // Repite el bucle hasta que haya
                                     // pasado el tiempo indicado.
}


Ya solo queda crear una función para reproducir la canción. La idea es ir poniendo las notas usando la función anterior con las pausas adecuadas para que suene bien la canción.
Aquí tenéis un ejemplo de la canción Pop Corn:


void PlayCancion(){
        //POP CORN
        play (nDO   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nSOL  ,4,166);
        play (nRE_  ,4,166);
        play (nSOL  ,4,166);
        play (nDO   ,4,166);
        delay_ms (166);
        play (nDO   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nSOL  ,4,166);
        play (nRE_  ,4,166);
        play (nSOL  ,4,166);
        play (nDO   ,4,166);
        delay_ms (166);
        play (nDO   ,5,166);
        play (nRE   ,5,166);
        play (nRE_  ,5,166);
        play (nRE   ,5,166);
        play (nRE_  ,5,166);
        play (nDO   ,5,166);
        play (nRE   ,5,166);
        play (nDO   ,5,166);
        play (nRE   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nLA_  ,4,166);
        play (nDO   ,5,166);
        play (nSOL_ ,4,166);
        play (nDO   ,5,166);
        
  }


Yo he utilizado el PIC16F88 y he adaptado la canción de Super Mario Bros I de NES  al PIC.
Por si alguien quiere el código con la canción lo dejo aquí:

DESCARGAR

Decir que la canción no se escucha perfecta porque la duración de las notas las hice a oído.
Aquí podéis ver el resultado:
Espero que os haya gustado la entrada.
¡Un Saludo!