Contruye tu propio reproductor de mp3. Capítulos (hilo bloqueado)

[jokerman]

             Capítulo 0. Definición de intenciones.

      -¿Có, y esto de qué va?
      Vamos a intentar hacer un tutorial de como construir un reproductor de mp3 desde cero, comprando los componentes electrónicos necesarios y programando el microprocesador que maneja el dsp, así como de la conexión de los circuitos integrados.

      -¿Cuánto se necesita saber y cuanto va a durar está colección? ¿Tiene oferta de promoción?
      Los conocimientos en electrónica son deseables, sobre todo en la programación de pics que es en lo que se centra el proyecto; pero aún así quiero hacerlo simple y que lo pueda entender cualquiera. Si sabéis algo de cualquier lenguaje de programación mucho mejor. No obstante ya digo que quiero explicar todo con mucho detalle y de manera simple, pues el abordar un tema así no tiene porque ser complicado

      -¿Quién eres tú? ¿Realmente sabes en lo que te estás metiendo, quillo?
      Actualmente estoy acabado ingeniería industrial superior con la especialidad de electrónica, no soy un genio de la electrónica ni nada; de hecho este proyecto está un poco más allá de mis conocimientos a priori, pero en teoría y por lo ya mirado, nada que no se pueda resolver leyendo y aprendiendo poco a poco. En la carrera he trabajado con un microprocesador en una asignatura, hace poco programé mi primer dspic por mi cuenta totalmente a base de leer en internet llegando a desarrollar un proyecto de dificultad media diría, y actualmente estoy trabajando con un dsp en el proyecto fin de carrera.

      -Ahhh....todo eso está muy bien, pero... que es un PIC
      Un PIC es un microprocesador o microcontrolador (en realidad no significan lo mismo pero por entendernos) que se programa para manejar/comunicarse con el mundo exterior, ya sea un teclado matricial, un display lcd, unos botones, un DAC o un chip decodificador de mp3.

      -Bueno vale, pero ¿te flipas o en realidad sabes tanto?
      Realmente me flipo :mrgreen: No, fuera de bromas, siempre me ha gustado el tema de como funciona internamente un mp3, y me parece un proyecto muy interesante. Como desde luego no es que tenga conocimientos extraordinarios para empezar desde cero, me apoyaré básicamente en el diseño de esta página: http://www.ladyada.net/make/minty/index.html Lo que muy posiblemente cambié sea el microcontrolador que usan ellos por el que ya he comentado que he usado; así no es un copy y paste de código y podemos trabajar a nuestro gusto.

      -Bueno pues nada chico, ahí te dejo. ¿Algo más que deba saber?
      Sólo decir, que posiblemente se que no tenga mucho tirón este hilo, pero me parece interesante y así me obliga a semanalmente a mirarme algo del tema e ir avanzando y no tirar la toalla. En caso de que os moleste realmente el hilo, o ver que hay nulo interés lo cerraría; además me gustaría duplicar el hilo: uno para colgar los fascículos en el que estará prohibido postear para que queden todos los fascículos, y otro en el que podáis postear comentarios y cualquier tipo de preguntas. Se me olvidaba: los componentes serán fáciles y baratos de obtener a través de internet, saliendo el reproductor con pcb incluido por unos 50€ puesto en casa a ojo estimador borrachero. Un saludo, en unos minutos colgaré el primer capítulo, en el que hablaremos de componentes y haremos una aproximación a como funciona el núcleo del reproductor.

[jokerman]

      Capítulo 1. Componentes Internos


      Bueno lo primero citar el diseño en el que nos estamos basando, ahí podéis ver todo el hardware que lleva:   http://www.ladyada.net/make/minty/hardware.html

      Por partes:
      
              1.Chip decodificador de mp3: Los archivos mp3 que se encuentren en nuestra memoria del reproductor, necesitamos decodificarlos, ya que el formato mp3 codifica (comprime) los datos para que ocupen menos espacio. Por medio de este chip, decodificaremos esos archivos y se los pasaremos directamente a nuestro DAC. Digamos que este chip es el interprete o traductor, de los archivos de mp3, que a priori no tiene ningún sentido, a la señal digital de audio, que se la pasará al DAC para que la convierta en analógica y podamos escucharla

              2. DAC: conversor analógico digital. Éste cogera los datos que le pase el DAC y los sacará al exterior convertidos ya en la señal analógica de audio que escucharemos

             3.Memoria: en dicha página usan una tarjeta de memoria de las típicas de las cámaras. Puestos a elegir preferiría usar una flash integrada, como cualquier mp3 de memoria, así que es un aspecto que dejaremos de momento en el aire.

             4.Microcontrolador: el corazón de nuestro reproductor de mp3. Él es el director de orquesta y el que se comunicará con el resto de componentes. Básicamente se encargará de leer de la memoria, y pasarle los datos al decodificador de mp3. Él es el que programaremos y el resto de componentes serán pasivos por así decirlo, respondiendo ante él según él les pida. En la página usan un PIC18F452, pero seguramente acabe usando el dsPIC 30f4013, que es el que ya he usado y tengo por casa, además de ser más potente, de cualquier manera la programación es muy similar

   Bueno espero que nadie se haya perdido, no entro a describir más en profundidad las cosas por no enrrollarnos si tenéis alguna duda, preguntar por el hilo de posteos, o mirar en wikipedia que vienen muchas cosas muy bien explicadas.

   Componentes y dónde comprarlos.

   Intentaremos comprar todos los componentes a futurlec.com, es una web de EEUU pero tiene precios muy baratos y los gastos de envío también son bastante baratos (por debajo de 10$ depende de la cantidad que compres), yo siempre he comprado las cosas ahí si podía y la verdad es que muy bien, los más baratos (más que la tienda de la ciudad de electrónica) y además sin salir de casa.

   -Chip decodificador: http://www.futurlec.com/ICSFSTMicro.shtml el mismo que indican en la web del minty player. 7$
   -DAC: cs4340 mismo que usan en el minty: 2.90$ en futurlec (hacer una búsqueda)
   -El microcontrolador intentaremos pedir samples a la casa de microchip, que se portan bastante bien en este aspecto, para obtenerlos gratis (no es nada ilegal ni nada, tranquilos).
   -El tema de la memoria de momento lo dejamos en el aire a la espera de ver cual elegimos finalmente

[jokerman]

            Capítulo 2. El microcontrolador: dspic 30f4013

                      Vamos a usar este microcontrolador, porque nos permitirá de sobra cumplir con las necesidades del proyecto y es con el que estoy familiarizado. Encontraremos mucha información sobre él en el fabricante (que es microchip):

               dsPIC30f4013

           ahí tenemos multitud de pdf a los que acudiremos para conocer nuestro microcontrolador, entre todos el más importante por así decirlo es el manual de su familia:
         
            dsPIC30F Family Reference Manual

            este manual es el genérico para todos los dspic30fxxxx, en él es dónde está explicado con todo detalle su arquitectura, para hilar más fino deberemos acudir al manual propio de nuestro microcontrolador, el 4013:

         dsPIC30f4013 Data Sheet

           en este último encontramos lo mismo que en el genérico pero menos detallado y más especificado a nuestro microcontrolador; de hecho muchas veces nos referenciará al anterior. ¿Cuál usar? Si con este último nos quedan las cosas claras pues bien, sino tendremos que recurrir al genérico dónde las descripciones son más detalladas.


          ¿Cómo empezamos a jugar con este bicho?

             Bueno primeramente necesitaríamos un llamado programador:



          este cacharro lo enchufaremos a nuestro ordenador por medio de usb, y por medio de cables enchufaremos también este cacharro a unas determinadas patas de nuestro microcontrolador para flashear nuestro programa previamente escrito en la memoria flash del dsPIC. Yo en su día compre el winpic800 que véis en las fotos (unos 60€ puesto en casa) es un poco caro pero es de los mejores por no decir el mejor, por la red también encontraréis multitud de diseños para fabricaros el vuestro, o incluso en ebay se pueden encontar algunos muy baratos, sólo aseguraos que es compatible con el modelo de micro que queréis programar. No entro más en el tema de como se programa porque hay mucha información en internet y en la misma web del winpic800.

        ¿Cómo escribo mi primera aplicación para el dsPIC?

           El entorno de desarrollo que usaremos será MPLAB Hay una versión de 30 días que podemos descargar, además funciona el truco de cambiarle la fecha para poder seguir usándolo.
            Con el propio mplab encontraremos un archivo que contiene la siguiente plantilla para empezar a escribir código en C:

         

Código [Seleccionar] Expandir

*    Filename:       temp_6014.c                                      *

*    Date:           8/20/2004                                        *

*    File Version:   1.30                                             *

*    Other Files Required: p30f6014.gld, libpic30.a                   *

*    Tools Used: MPLAB GL  -> 6.60                                    *

*                Compiler  -> 1.30                                    *

*                Assembler -> 1.30                                    *

*                Linker    -> 1.30                                    *

*                                                                     *

*    Devices Supported:                                               *

*                dsPIC30F2011                                         *

*                dsPIC30F3012                                         *

*                dsPIC30F2012                                         *

*                dsPIC30F3013                                         *

*                dsPIC30F3014                                         *

*                dsPIC30F4013                                         *

*                dsPIC30F5011                                         *

*                dsPIC30F6011                                         *

*                dsPIC30F6012                                         *

*                dsPIC30F5013                                         *

*                dsPIC30F6013                                         *

*                dsPIC30F6014                                         *

*                                                                     *

***********************************************************************

*                                                                     *

* Other Comments:                                                     *

*                                                                     *

* 1) C attributes, designated by the __attribute__ keyword, provide a *

*    means to specify various characteristics of a variable or        *

*    function, such as where a particular variable should be placed   *

*    in memory, whether the variable should be aligned to a certain   *

*    address boundary, whether a function is an Interrupt Service     *

*    Routine (ISR), etc. If no special characteristics need to be     *

*    specified for a variable or function, then attributes are not    *

*    required. For more information about attributes, refer to the    *

*    C30 User's Guide.                                                *

*                                                                     *

* 2) The __space__(xmemory) and __space__(ymemory) attributes are     *

*    used to place a variable in X data space and Y data space,       *

*    respectively. Variables accessed by dual-source DSP instructions *

*    must be defined using these attributes.                          *

*                                                                     *

* 3) The aligned(k) attribute, used in variable definitions, is used  *

*    to align a variable to the nearest higher 'k'-byte address       *

*    boundary. 'k' must be substituted with a suitable constant       *

*    number when the ModBuf_X(k) or ModBuf_Y(k) macro is invoked.     *

*    In most cases, variables are aligned either to avoid potential   *

*    misaligned memory accesses, or to configure a modulo buffer.     *                           

*                                                                     *

* 4) The __interrupt__ attribute is used to qualify a function as an  *

*    interrupt service routine. An interrupt routine can be further   *

*    configured to save certain variables on the stack, using the     *

*    __save__(var-list) directive.                                    *

*                                                                     *

* 5) The __shadow__ attribute is used to set up any function to       * 

*    perform a fast context save using shadow registers.              *

*                                                                     *

* 6) Note the use of double-underscores (__) at the start and end of  *

*    all the keywords mentioned above.                                *

*                                                                     *

**********************************************************************/





/* Include the appropriate header (.h) file, depending on device used */

/* Example (for dsPIC30F5013): #include <p30f5013.h>                  */



/* Alternatively, the header file may be inserted from the Project    */

/* window in the MPLAB IDE                                            */



#include <p30f6014.h>





/* Define constants here                            */



#define CONSTANT1 10

#define CONSTANT2 20





/************* START OF GLOBAL DEFINITIONS **********/





/* Define arrays: array1[], array2[], etc.          */

/* with attributes, as given below                  */



/* either using the entire attribute                */

int array1[CONSTANT1] __attribute__((__space__(xmemory), __aligned__(32)));

int array2[CONSTANT1] __attribute__((__space__(ymemory), __aligned__(32)));



/* or using macros defined in the header file       */

int array3[CONSTANT1] _XBSS(32);

int array4[CONSTANT1] _YBSS(32);





/* Define arrays without attributes                 */



int array5[CONSTANT2];   /* array5 is NOT an aligned buffer */



/* ------------------------------------------------ */



/* Define global variables with attributes          */



int variable1 __attribute__((__space__(xmemory)));

int variable2 __attribute__((__space__(ymemory)));



/* Define global variables without attributes       */



int variable3;





/************** END OF GLOBAL DEFINITIONS ***********/







/************* START OF MAIN FUNCTION ***************/



int main ( void )

{





/* Code goes here                                   */





}







/****** START OF INTERRUPT SERVICE ROUTINES *********/



/* Replace the interrupt function names with the    */

/* appropriate names depending on interrupt source. */



/* The names of various interrupt functions for     */

/* each device are defined in the linker script.    */





/* Interrupt Service Routine 1                      */

/* No fast context save, and no variables stacked   */



void __attribute__((__interrupt__)) _ADCInterrupt(void)

{





/* Interrupt Service Routine code goes here         */

       

}





/* Interrupt Service Routine 2                      */

/* Fast context save (using push.s and pop.s)       */



void __attribute__((__interrupt__, __shadow__)) _T1Interrupt(void)

{



/* Interrupt Service Routine code goes here         */

       

}





/* Interrupt Service Routine 3: INT0Interrupt       */

/* Save and restore variables var1, var2, etc.      */



void __attribute__((__interrupt__(__save__(variable1,variable2)))) _INT0Interrupt(void)

{



/* Interrupt Service Routine code goes here         */



}





/********* END OF INTERRUPT SERVICE ROUTINES ********/


                   
             En principio no preocuparse por el tremendo tocho que ahí, pues la mayoría son comentarios y es simplemente una plantilla. De momento vamos a dejarlo aquí, el próximo día veremos de modificarla un poco para hacer nuestro primer hola mundo: un programa que nos haga hacer parpadear un led externo, y ya después de esa entrega volveremos a centrarnos en nuestro reproductor mp3.

Las palabras en verde conducen a enlaces. Por cierto, dejo este post así, y no voy a citarlo en el de comentarios, si alguien quiere preguntar algo o decir cualquier cosa, por favor, que cite este allí y a continuación exponga su pregunta (por no tener dos hilos en la portada)
               

[jokerman]

          Capítulo 3. Un "hola mundo" con el 30f4013

              ¿Cómo funciona un dspic/pic?

             Hablando de una manera muy básica, el dspic tiene una serie de registros internos (como si fuesen cajones, cabiendo en cada uno 16 bits (ya que el micro es de 16 bits), así podemos escribir "xxxx xxxx xxxx xxxx" siendo x un bit, es decir 0 o 1), dependiendo de en que registros y que escribamos manejaremos el dsPIC

            Por ejemplo...?

             En el capítulo 7 del manual específico del dspic30f4013 (colgado en el post anterior), hablan de los puertos de entrada/salida (es decir las patas que podemos configurar como entrada/salida directamente; las patas se encuentran asociadas en grupos llamadas puertos). En este capítulo nos indica como manejarnos con estos puertos de entrada/salida y en que dirección están mapeados:



            Vemos que efectivamente, cada registro tiene 16 bits (de 0 a 15). ¿Porqué hay tanta raya? porque por ejemplo el puerto C, no tiene 16 patas, sino sólo 3, careciendo de sentido escribir algo en los bits 12 a 0. 
            Si por ejemplo, escribiesemos 1110 0000 0000 0000, en el puerto C, las patas 13, 14 y 15 correspondientes al puerto C, se pondrían a nivel alto, es decír el uno lógico, que sería 5v o a la tensión que esté alimentado el micro (si nuestra alimentación fuese 3v por ejemplo, se pondrían a 3v). Si escribiesemos 0000 0000 0000 0000, las patas estarían a nivel bajo, es decir 0 voltios, o el cero lógico. Por supuesto, en los bits 12 al 0, podíamos haber escrito "unos" en vez de "ceros" y obtendríamos el mismo resultado, pues da igual lo que escribamos en esos bits como hemos comentado.
            Podemos comprobar los niveles de tensión de las patas del puerto C directamente conectando un led y una resistencia de alrededor de unos 250 ohmnios a las patas (valores más altos hará que ilumine menos el led, y viceversa, por no quemar el led, mejor que sea superior a los 200 ohmnios). Cuando tengamos 5v el led se iluminará y con 0v estará apagado.

          Vale, en la imagen que has puesto entiendo que PORTC es el puerto C, pero que es eso de LATC, y TRISC

          TRISx (ya sea TRISC, TRISB...etc) es un registro para configurar si la pata va a ser usada de entrada o salida visto desde punto de vista del micro. Así lo lógico es que si queremos escribir en el puerto C para encender leds la configuremos como pata de salida... si por ejemplo fuésemos a conectarlo a unos pulsadores que debemos leer, las configurararíamos como entradas.

            ¿Cómo configuramos entonces nuestras patas del puerto C como salidas, entonces?


           Muy sencillo: escribiendo un 1 en el bit "x" de TRISC la pata x queda configurada como entrada y un 0 como salida (pág. 53 del manual del 30f4013), así que haremos: TRISC= 000x xxxx xxxx xxxx (pongo x para representar que da igual lo que escribamos en esos bits).

           LATx es una especie de registro que hace de buffer del PORTx. Es decir las cosas que vayan a ser escritas en PORTx pasan primero por LATx SIEMPRE y luego son copiadas en los siguientes ciclos de reloj al PORTx correspondiente. ¿Cómo nos afecta esto? De momento no preocuparse con esto, basta con saber que por seguridad tanto para leer como escribir en un puerto en vez de PORTx vamos a usar LATx

          Bien... y finalmente el código es.... ?

           Bueno gracias a un archivo que incluiremos en nuestro código no nos hace falta decir en que dirección estamos escribiendo, sino que ya tenemos definidos PORTx, LATx, TRISx y muchos otros registros allí y podemos usar directamente  "PORTC= xxxx xxxx xxxx xxxx"
          Así que yendo al caso, imaginaros que tenemos 3 leds con sus resistencias en las patas 13, 14 y 15 del puerto C y queremos encender sólo la 13 y la 15 dejando la de en medio apagada. Así que haríamos (ojo, los datos están en hexadecimal en vez de en binario)

Código [Seleccionar] Expandir

            [b]TRISC= 0x0000[/b]  /* Configuramos el puerto C como de salida "0000 0000 0000 0000" en binario
            [b]LATC=0xA000[/b]   /* Esribimos en el LATC "1010 0000 0000 0000" es decir los bits 15 y 13 a uno

          Y ya tendríamos nuestros 2 leds brillando.
           NOTA SOBRE HEXADECIMAL: Cada dígito hexadecimal corresponde a 4 bits así tenemos
                   
                              0x0 - 0000
                              0x1 - 0001
                              0x2 - 0010
                              0x3 - 0011
                              0x4 - 0100
                              0x5 - 0101                             
                              0x6 - 0110
                              0x7 - 0111
                              0x8 - 1000
                              0x9 - 1001
                              0xa - 1010
                              0xb - 1011
                              0xc - 1100
                              0xd - 1101
                              0xe - 1110
                              0xf  - 1111
                             
          si tenéis alguna duda os dejo la dirección de la wikipedia: SISTEMA HEXADECIMAL

             ¿A tódo esto... dónde se encuentran localizadas esas patas en nuestro micro?


               Pág 5 del manual del 4013: (hay distintos formatos pero para empezar vamos a usar éste)

            Y de momento vamos a dejarlo aquí. En el próximo capítulo, acabaremos el programa con la configuración inicial del microcontrolador para que empiece a funcionar.

             Lo mismo que en el post anterior, para preguntas, citar este capítulo en el otro hilo

Un saludo!

[jokerman]

          Capítulo 4. Acabando el "hola mundo"

                 
               Vamos a poner el código final para que si pusiesemos 3 leds (cada uno junto con su resistencia de 330 ohmnios por ejemplo) en las patas del puerto C 15, 14 y 13, se encendiesen la 15 y la 14 y la 13 se quedase apagada (que está justo en medio, podéis ver que el puerto C se encuentra en las patas 14, 15 y 16 en la imagen anterior):

Código [Seleccionar] Expandir




#include <p30f4013.h>                        /* fichero dónde se encuentran definidos los puertos
                                                        ; y palabras claves del microprocesador usado
                                                   

        _FOSC(CSW_FSCM_OFF & XT_PLL16)    /* ;Turn off clock switching and
                                                             ;fail-safe clock monitoring and
                                                              ;use the External Clock as the
                                                              ;system clock

        _FWDT( WDT_OFF)                          //  ;Turn off Watchdog Timer

        _FBORPOR(PBOR_ON & BORV_27 & PWRT_16 & MCLR_EN);
                                                               //       ;Set Brown-out Reset voltage and
                                                               //      ;and set Power-up Timer to 16msecs
                                           
        _FGS(CODE_PROT_OFF)                       // ;Set Code Protection Off for the
                                                               //       ;General Segment


/* Definir constantes aquí, ejemplo:                          */
/*#define CONSTANT1 10

/* Definir arrays de la siguiente manera       */
/*int mivector[]tamañoquequiera  _XBSS(32);
/* int mivector2[34]  _YBSS(32);

/* Definir variables       */
/* int mivariable;      usaremos preferentemente variables enteras, ya que corresponden a 16 bits


int main(void)          */ EL PROGRAMA PRINCIPAL VA A AQUÍ:
{
        TRISC=0x0000   ;         */configuramos todas las patas del puerto C como salidas
        PORTC=0xA000   ;       */ es decir: 1010 0000 0000 0000 con lo que las patas 15 y 13
                                                    */ las pondremos a 1, 5 voltios en el mundo real y por tanto
                                                   */ se encenderán los leds
}



           Como véis el código es muy corto y simple, ya que estamos haciendo bien poco, os he puesto también como se definirían variables, arrays y constantes entre comentarios (las líneas que véis después de */ o // son comentarios y serán ignorados por el compilador; se ponen a gusto del programador para especificar que se hace en cada línea) aunque no vamos a usar ninguna.

          Vamos a explicar las primeras líneas de configuración del micro:


#include <p30f4013.h>                        /* fichero dónde se encuentran definidos los puertos
                                                        ; y palabras claves del microprocesador usado
                                        /dicho fichero nos viene con MPLAB al instalarlo (no recuerdo en que directorio pero está por ahí

          Es decir, en este fichero tenemos definido palabras por PORTC y LATC, entendiéndolos de manera adecuada el compilador.


_FOSC(CSW_FSCM_OFF & XT_PLL16)           /* ;Turn off clock switching and
                                                                     ;fail-safe clock monitoring and
                                                                      ;use the External Clock as the
                                                                      ;system clock

     Aquí estamos usando una macro para configurar dos cosas: el clock switching y el fail-safe por un lado, y el reloj que usaremos. La primera cosa no recuerdo muy bien de que se trataba, tiene pinta/creo recordar que era por cuestiones de seguridad de si el reloj no funciona por cualquier cosa haga algo... en cualquier manera no nos importa de momento. El segundo parámetro es la configuración del reloj. El microcontrolador funciona con un cristal de cuarzo que le da una señal cuadrada que es la que usa como reloj, a más velocidad de esa señal cuadrada, más Hz y más veloz será el microcontrolador. Hay multitud de configuraciones (ver el datasheet del 30f4013); aquí vamos a usar esta: con un reloj de 6 Mhz utilizaremos la PLL (wikipedia para ver que es una PLL) para multiplicar su frecuencia por 16, obteniendo un reloj de 96 Mhz, más que suficiente en principio para nuestros propósitos.                


        _FWDT( WDT_OFF)                          //  ;Turn off Watchdog Timer

                El watchdog es una característica que tienen muchos micros para vigilar que si el sistema se cuelgue se resetee. ¿Cómo funciona? Es una especie de contador contínuo, que si llega a un número determinado se va a resetear (un millón por ejemplo), entonces por programa, cada x líneas deberíamos de poner el contador a cero para evitar que nunca llegue a ese millón, si por cualquier cosa se queda colgado el programa dicho contador seguiría contando y llegaría a su tope produciendo el reset del sistema. En principio resulta muy útil en muchas aplicaciones, pero por contra hay que introducir líneas en el código para borrarlo con la ejecución normal del programa, así que por simplicidad lo desactivamos.



        _FBORPOR(PBOR_ON & BORV_27 & PWRT_16 & MCLR_EN);
                                                               //       ;Set Brown-out Reset voltage to 2.7 V and
                                                               //      ;and set Power-up Timer to 16msecs

         Aquí especificamos que el voltaje mínimo en el que se produciría el reset sería 2.7 voltios, lo cual quiere decir que si en algún momento nuestra alimentación cae de los 5v normales a 2.7 por lo que sea, el micro se resetearía. Por otra parte damos un tiempo de encendido del dispositivo de 16 msecs.
                                           

        _FGS(CODE_PROT_OFF)                       // ;Set Code Protection Off for the
                                                               //       ;General Segment


           Finalmente esta línea creo que es para proteger el código que hemos escrito en el microcontrolador y que terceras personas no puedan acceder a él (estos chinos de hoy en día que lo copian todo xD). En principio, por simplicidad lo desactivaremos.

         En el fichero que hemos añadido al código, el p30f4013.h encontramos definidos todos los parámetros de estas macros, por ejemplo, PWRT_64, y PWRT_4, que nos darían 64 msecs y 4 msecs de tiempo de encendido de nuestro microcontrolador (cuánto más complicada sea nuestra aplicación mejor que se mayor para darle más tiempo a que se inicialice correctamente), así como el resto de parámetros de configuración.

        Y finalmente escribiremos nuestro código escrito entre las llaves de  int main(void) {} al igual que se hace en C stándar. Simplemente configuramos el puerto C como salida, y ponemos las salidas a 0 o a 1 como queramos (recordar que del puerto C sólo tiene patas al exterior los bits 15, 14 y 13, sino mirar la tabla 7-1 del anterior post).

         Bueno y esto es todo por hoy, sólo nos faltaría compilar el programa con el MPLAB, y flashearlo en el micro por medio del programador; recomendar por último, de la web de microchip el datasheet DS70094 dónde encontraremos información que al novato le puede ir muy bien sobre estos primeros pasos con el microcontrolador (56 páginas).

         En la próxima entrega empezaremos a hablar de las interrupciones en vistas a usar el Timer del micro para poder hacer parpadear los leds. Una vez llegados a ese punto, podríamos dejar por terminada la introducción al dsPIC para empezar con nuestro reproductor de mp3 propiamente dicho

Un saludo