Autor Tema: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD  (Leído 79829 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« en: 21 de Noviembre de 2011, 16:51:46 »
SkP32 es una placa desarrollo para PIC32MX3/4 y PIC24 con package TQFP100. Ha sido pensada especialmente para un PIC32, pero gracias a que Microchip mantiene el pinout entre familias, podemos decir que hay seguramente un 95% de compatibilidad para los PIC24. El precursor de la idea ha sido el amigo VelazquezBio, quién plateo y desarrollo una entrenadora para un PIC24, y tomando las mismas bases realizamos éste diseño que mandamos a fabricar (PCB).

Las características de la misma son:

•   Microcontrolador PIC32MX3/4 o PIC24
•   Reguladores de 5.0 y 3.3 V.
•   Alimentación externa o mediante USB.
•   Header con disponibilidad de todos los pines del microcontrolador.
•   Header para UART1 y UART2.
•   Header para I2C1 e I2C2.
•   Header para SPI1 y SPI2.
•   Header para pines I/O RB0-RB7 (8-bits).
•   Header para LCD TFT
•   4 Leds on board con jumpers.
•   2 Switch on board con jumpers.
•   Para PIC con USB, conector mini-USB device
•   Para PIC con USB, USB-A Host con TPS2041B para control sobre corriente.
•   Zócalo para SD Card.
•   Memoria EEPRON SPI (3.3 V).
•   Cristal de 32768 Hz para RTC interno.
•   Header para conexión ISCP.

El esquema de la placa.

Por aquí unas fotos de la que armé en mi caso, el microcontrolador soldado es un PIC32MX360F512L.



La idea es en los siguientes mensajes mostrar algunos ejemplos realizados, un Hola Mundo, control sobre LCD, RTC interno, UART, memoria EEPROM, LCD TFT, Touch, etc...  ;)



Indice


Repositorio GIT: https://github.com/AleSuky/SkP32v1.1

Saludos!
« Última modificación: 28 de Febrero de 2013, 20:17:29 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #1 en: 21 de Noviembre de 2011, 16:52:51 »
Hola Mundo - Configuración del oscilador


Es una buena idea partir la estructuración de nuestras carpetas de proyectos tomando como base la que utiliza Microchip, de esta manera cuando necesitemos utilizar alguna de las librerías que provee Microchip va a resultar más sencillo. Además, también podemos reunir en una carpeta las librerías que vayamos desarrollando, de esa manera estarán disponibles para cualquier proyecto sin la necesidad de copiar todos los archivos a la carpeta raíz ;)
En base a eso una posible forma puede ser la siguiente:


Ahora, en el proyecto los INCLUDE SEARCH PATH serán:
•   .
•   ..\Microchip\Include
•   ..\Micros-Designs\Include
•   C:\Program Files\Microchip\MPLAB C32\pic32mx\include

Configuración del oscilador:
En este caso el cristal utilizado es uno de 8 MHz, y la idea es utilizar el PLL interno para llevar el Clock del CPU y el Clock de periféricos hasta 80 MHz. Partiendo del datasheet, el “camino” a seguir se muestra en la siguiente figura:


Entonces la configuración de los fuses resulta:
Código: [Seleccionar]
#pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_2
#pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
#pragma config CP=OFF, BWP=OFF

Adicionalmente configuramos WDT des-habilitado, des-habilitado cambio de clock, des-habilitado monitoreo de clock y protecciones de código des-habilitadas. Existe el documento de ayuda hlpPIC32MXConfigSet en C:\Program Files\Microchip\MPLAB C32\doc para más detalles (+ Manuales de referencia de la familia en particular ;) )
Además de la configuración de Fuses es necesario llamar a una o un par de funciones que ponen al máximo el rendimiento del microcontrolador, en mi caso directamente llamo a la función SYSTEMConfigPerformance(FCY). Pero se puede utilizar por ejemplo SYSTEMConfig (), que permite seleccionar las características a modificar:
SYSTEMConfig (FCY, OPCIONES);
Opciones:
SYS_CFG_WAIT_STATES    
SYS_CFG_PB_BUS        
SYS_CFG_PCACHE          
SYS_CFG_ALL


Bueno, ya con esto un HelloWord puede ser utilizar los Leds y Switch on board  :)

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF, PWP=OFF
  11. // *--------------------------------------------------------------------------------*
  12. #include "HardwareProfileSkP32.h"
  13. // *--------------------------------------------------------------------------------*
  14. // *--------------------------------------------------------------------------------*
  15. // *--------------------------------------------------------------------------------*
  16. int main(){
  17.        
  18.         mJTAGPortEnable(0);                                                     // JTAG des-habilitado
  19.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  20.  
  21.         PORTSetPinsDigitalOut(PORT_LED1, PIN_LED1);
  22.         PORTSetPinsDigitalOut(PORT_LED3, PIN_LED3);
  23.         PORTSetPinsDigitalOut(PORT_LED4, PIN_LED4);
  24.         PORTSetPinsDigitalIn(PORT_SW1,PIN_SW1);
  25.         PORTSetPinsDigitalIn(PORT_SW2,PIN_SW2);
  26.         while(1){
  27.                 if(PORTReadBits(PORT_SW1,PIN_SW1)==0){
  28.                         PORTSetBits(PORT_LED1,PIN_LED1);
  29.                 }else{
  30.                         PORTClearBits(PORT_LED1,PIN_LED1);
  31.                 }
  32.                 if(PORTReadBits(PORT_SW2,PIN_SW2)==0){
  33.                         PORTSetBits(PORT_LED3,PIN_LED3|PIN_LED4);
  34.                 }else{
  35.                         PORTClearBits(PORT_LED3,PIN_LED3|PIN_LED4);
  36.                 }
  37.         }
  38. }
  39. // *--------------------------------------------------------------------------------*
  40.  

Al igual que en los ejemplos de Microchip, creamos un archivo HardwareProfile.h en donde colocamos un par de definiciones propias de la placa de desarrollo utilizada:

Código: C
  1. #define PORT_LED1       IOPORT_B
  2. #define PIN_LED1        BIT_8
  3. #define PORT_LED2       IOPORT_B
  4. #define PIN_LED2        BIT_9
  5. #define PORT_LED3       IOPORT_B
  6. #define PIN_LED3        BIT_10
  7. #define PORT_LED4       IOPORT_B
  8. #define PIN_LED4        BIT_11
  9.  
  10. #define PORT_SW1        IOPORT_B
  11. #define PIN_SW1         BIT_12
  12. #define PORT_SW2        IOPORT_B
  13. #define PIN_SW2         BIT_13
  14.  
  15. #define GetSystemClock()                (80000000ul)                    // Hz
  16. #define GetInstructionClock()   (GetSystemClock()/1)     
  17. #define GetPeripheralClock()    (GetSystemClock()/1)
  18.  
« Última modificación: 22 de Noviembre de 2011, 12:59:20 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #2 en: 21 de Noviembre de 2011, 16:54:47 »
Utilización de LCD

El LCD o el puerto serial son dos de los periféricos más usados, ya que cualquiera de ellos nos permite visualizar resultados o debugger de forma simple durante el desarrollo de un proyecto. En este caso se hace uso de la librería LCDGeneric agregado las definiciones necesarias para utilizarla en C32 y con un microcontrolador trabajando a 80 MHz.

Código: C
  1.         #if defined (__PIC32MX__)
  2.                 #include <p32xxxx.h>
  3.                 #include "TimeDelay.h"
  4.                 #define __delay_1Cycle()        {Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();Nop();}
  5.                 #define __delay_1us()           {UINT8 k; for(k=0;k<50;k++){Nop();}}
  6.                 #define __delay_100us() Delay10us(10)
  7.                 #define __delay_2ms()           DelayMs(2)
  8.         #endif
  9.  


 ;D

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF, PWP=OFF
  11. // *--------------------------------------------------------------------------------*
  12. #include "HardwareProfileSkP32.h"
  13. #include "LCDGeneric.h"
  14. // *--------------------------------------------------------------------------------*
  15. const char CharactersCGRAM[16]={0,0,0x0E,0x1F,0x0A,0x0A,0x0A,0x11,
  16.                                                                 0,0,0,0,0x0E,0x1F,0x0A,0x11};
  17. // *--------------------------------------------------------------------------------*
  18. // Guarda en la CGRAM el caracter en el banco seleccionado.-
  19. // <Caracter> es la dirección de la primer fila del caracter a enviar.-
  20. void vLcdWriteCgram(unsigned char Bank,char Character){
  21.         unsigned char AddressBank,i;
  22.  
  23.         AddressBank=0x40+0x08*Bank;
  24.         vWriteLCD(AddressBank,0);
  25.         // Cargamos los 8 registros.-
  26.         for(i=0;i<8;i++){
  27.                 vWriteLCD(CharactersCGRAM[Character + i],1);
  28.         }
  29.         vWriteLCD(0x80,0); // Se da por terminada la escritura.-
  30. }
  31.  
  32. // Incializa Memoria CGRAM.-
  33. void vLcdInitCgram(void){
  34.         unsigned char j;
  35.        
  36.         for(j=0;j<2;j++){
  37.                 vLcdWriteCgram(j,j*8);  
  38.         }
  39. }
  40. // *--------------------------------------------------------------------------------*
  41. int main(){
  42.        
  43.     mJTAGPortEnable(0);                                                 // JTAG des-habilitado
  44.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  45.        
  46.         PORTSetPinsDigitalOut(IOPORT_A, BIT_3);         // Backlight del LCD
  47.         mPORTASetBits(BIT_3);
  48.         vInitLCD();
  49.         vLcdInitCgram(); // Incializa Memoria CGRAM.-
  50.         vPutrs_LCD("Libreria generica..\nLCD 2x20, 4x20..\nBus 4-bits o 3-pines\npor Suky...");
  51.         DelayMs(1000);
  52.         vLCD_Putc('\f');
  53.         PORTSetPinsDigitalOut(PORT_LED1, PIN_LED1);
  54.         PORTSetPinsDigitalOut(PORT_LED3, PIN_LED3);
  55.         PORTSetPinsDigitalOut(PORT_LED4, PIN_LED4);
  56.         PORTSetPinsDigitalIn(PORT_SW1,PIN_SW1);
  57.         PORTSetPinsDigitalIn(PORT_SW2,PIN_SW2);
  58.         while(1){
  59.                 if(PORTReadBits(PORT_SW1,PIN_SW1)==0){
  60.                         PORTSetBits(PORT_LED1,PIN_LED1);
  61.                         vGotoxyLCD(1,1);
  62.                         vPutrs_LCD("SW1:");
  63.                         vLCD_Putc(1);
  64.                 }else{
  65.                         PORTClearBits(PORT_LED1,PIN_LED1);
  66.                         vGotoxyLCD(1,1);
  67.                         vPutrs_LCD("SW1:");
  68.                         vLCD_Putc(0);
  69.                 }
  70.                 if(PORTReadBits(PORT_SW2,PIN_SW2)==0){
  71.                         PORTSetBits(PORT_LED3,PIN_LED3|PIN_LED4);
  72.                         vGotoxyLCD(1,2);
  73.                         vPutrs_LCD("SW2:");
  74.                         vLCD_Putc(1);
  75.                 }else{
  76.                         PORTClearBits(PORT_LED3,PIN_LED3|PIN_LED4);
  77.                         vGotoxyLCD(1,2);
  78.                         vPutrs_LCD("SW2:");
  79.                         vLCD_Putc(0);
  80.                 }
  81.         }
  82. }
  83. // *--------------------------------------------------------------------------------*
  84.  

Adjunto el proyecto completo.

« Última modificación: 22 de Noviembre de 2011, 12:59:56 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #3 en: 21 de Noviembre de 2011, 16:55:30 »
RTC interno mas LCD


Otro ejemplo sencillo, el uso del RTC interno del microcontrolador (La primera vez en un PIC en mi caso  ;D ). En este caso se configura el RTC interno con la fecha actual, luego se configura para que ocurra una interrupción cada 1 segundo (Se utilizan interrupciones vectorizadas). Con ello leemos la fecha y hora, y lo visualizamos en un LCD:

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *---------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF
  11. // *---------------------------------------------------------------------------*
  12. #include "HardwareProfileSkP32.h"
  13. #include "LCDGeneric.h"
  14. volatile char kbhit_rtc=0;
  15. // *---------------------------------------------------------------------------*
  16. void __ISR(_RTCC_VECTOR, ipl4) RtccIsr(void){
  17.        
  18.         INTClearFlag(INT_RTCC);
  19.         kbhit_rtc=1;
  20. }
  21. // *---------------------------------------------------------------------------*
  22. int main(){
  23.         rtccTime        tm;            
  24.         rtccDate        dt;
  25.         char Text[50];
  26.        
  27.        
  28.         mJTAGPortEnable(0);                                             // JTAG des-habilitado
  29.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  30.        
  31.         PORTSetPinsDigitalOut(IOPORT_A, BIT_3);         // Backlight del LCD
  32.         mPORTASetBits(BIT_3);
  33.         vInitLCD();
  34.        
  35.         RtccInit();                    
  36.         while(RtccGetClkStat()!=RTCC_CLK_ON);
  37.         vPutrs_LCD("\fRTC:\n");
  38.        
  39.         tm.l=0;
  40.         tm.sec=0x30;
  41.         tm.min=0x44;
  42.         tm.hour=0x16;
  43.         dt.wday=2;
  44.         dt.mday=0x21;
  45.         dt.mon=0x11;
  46.         dt.year=0x11;
  47.        
  48.         RtccChimeEnable();                     
  49.         RtccSetAlarmRptCount(0);               
  50.         RtccSetAlarmRpt(RTCC_RPT_SEC);                  // Cada 1 seg.
  51.         RtccAlarmEnable();
  52.         RtccSetTimeDate(tm.l, dt.l);
  53.        
  54.         INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
  55.         INTEnableInterrupts();
  56.         INTSetVectorPriority(INT_RTCC_VECTOR, INT_PRIORITY_LEVEL_4);                   
  57.         INTSetVectorSubPriority(INT_RTCC_VECTOR, INT_SUB_PRIORITY_LEVEL_1);            
  58.         INTEnable(INT_RTCC, INT_ENABLED);
  59.                
  60.         while(1){
  61.                 if(kbhit_rtc==1){
  62.                         kbhit_rtc=0;
  63.                         RtccGetTimeDate(&tm, &dt);
  64.                         vGotoxyLCD(1,2);
  65.                         sprintf(&Text[0],"%02x:%02x:%02x\n%02x/%02x/%02x",tm.hour,tm.min,tm.sec,dt.mday,dt.mon,dt.year);
  66.                         vPuts_LCD(&Text[0]);
  67.                 }
  68.         }
  69. }
  70.  
« Última modificación: 22 de Noviembre de 2011, 13:00:20 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 17909
    • MicroPIC
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #4 en: 21 de Noviembre de 2011, 17:02:14 »
¡Genial y abrumadora tanta info buena!
Gracias
Un saludo desde Sevilla, España.
Visita MicroPIC                                                                                        ɔ!doɹɔ!ɯ ɐʇ!s!ʌ

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7881
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #5 en: 21 de Noviembre de 2011, 17:06:34 »
Excelente Suky !!
Felicitaciones por este desarrollo !!
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #6 en: 21 de Noviembre de 2011, 17:28:09 »
Muchas gracias!  ;-) En los tiempos libres estoy leyendo sobre el ADC de estos micros  :z) a ver si la señal de la siguiente imagen deja de ser simulada  :-)


Que buena cantidad de problemas a resolver van a surgir de encarar en un proyecto asi  :tongue:

Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado manwenwe

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2190
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #7 en: 21 de Noviembre de 2011, 18:00:39 »
Holap!

el TFT lleva controlador o se trata de la nueva LCC? En tal caso:¿ qué tal funciona?

1 saludo.
Ojo por ojo y todo el mundo acabará ciego - Mahatma Gandhi -

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #8 en: 21 de Noviembre de 2011, 18:12:05 »
Tiene controlador. Es el mismo que utilice en el mbed junto a un MCP23S17 para realizar el Menú:

Pequeña diferencia entre controlarlo mediante SPI que controlarlo por PMP a 16-bits  :D
No contesto mensajes privados, las consultas en el foro

Desconectado manwenwe

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2190
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #9 en: 22 de Noviembre de 2011, 04:31:29 »
Te refieres a que el controlador es PMP y tú utilizas un bridge SPI-PMP? La verdad es que va bastante bien :o Renderizas BMP o JPG?

saludo!
Ojo por ojo y todo el mundo acabará ciego - Mahatma Gandhi -

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #10 en: 22 de Noviembre de 2011, 09:21:15 »
Te refieres a que el controlador es PMP y tú utilizas un bridge SPI-PMP? La verdad es que va bastante bien :o Renderizas BMP o JPG?

saludo!

Exactamente, SPI a 10 MHz, no soporta más el MCP23S17  :undecided: ... Y es BMP


Saludos!
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #11 en: 22 de Noviembre de 2011, 11:11:43 »
Comunicación serial - UART2


En este caso dejo un ejemplo de comunicación serial por UART2. Se crea una función (void vUARTPuts(UART_MODULE id,const char *Ptr)) que permite enviar un string mediante el identificador de la UART usada, con ello se envía un string inicial. Luego por medio de interrupción se captura el dato enviado desde la PC y se lo retorna.

Ejemplo:

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF
  11. // *--------------------------------------------------------------------------------*
  12. #include "HardwareProfileSkP32.h"
  13. // *--------------------------------------------------------------------------------*
  14. void __ISR(_UART2_VECTOR, ipl2) ISRUart2(void){
  15.         unsigned char Temp;
  16.  
  17.         if(INTGetFlag(INT_SOURCE_UART_RX(UART2))){
  18.                 INTClearFlag(INT_SOURCE_UART_RX(UART2));
  19.  
  20.                 Temp=UARTGetDataByte(UART2);
  21.                 UARTSendDataByte(UART2,Temp);
  22.  
  23.         }
  24.         /*if(INTGetFlag(INT_SOURCE_UART_TX(UART2))){
  25.                 INTClearFlag(INT_SOURCE_UART_TX(UART2));
  26.         }*/
  27. }
  28. // *--------------------------------------------------------------------------------*
  29. void vUARTPuts(UART_MODULE id,const char *Ptr){
  30.  
  31.         while(*Ptr!='\0'){
  32.                 while(!UARTTransmitterIsReady(id));
  33.                 UARTSendDataByte(id, *Ptr++);
  34.         }
  35. }
  36. // *--------------------------------------------------------------------------------*
  37. int main(){
  38.         char Text[20];
  39.         unsigned char Valor1=126;
  40.         float Valor2=456.342;
  41.        
  42.     mJTAGPortEnable(0);                                                 // JTAG des-habilitado
  43.     SYSTEMConfigPerformance(GetSystemClock());  // Activa pre-cache.-
  44.        
  45.     UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY); // Habilita pines Tx y Rx.
  46.     UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY); // INT_Tx cuando el buffer tiene espacio para otro caracter.
  47.                                                                                                                                                                                 // INT_Rx cuando el buffer tiene un byte.
  48.     UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);     // 8:N:1
  49.     UARTSetDataRate(UART2, GetPeripheralClock(), 9600);                                                                         // 9600
  50.     UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));                          // Modulo encedido, Tx y Rx encendido
  51.    
  52.    
  53.     vUARTPuts(UART2,"Iniciando comunicacion serial por UART 2, SkP32\r\n");
  54.     sprintf(&Text[0],"-->%u,%3.2f<--",Valor1,Valor2);
  55.     vUARTPuts(UART2,(const char *)&Text[0]);
  56.    
  57.     // Configuramos interrupcion por Rx UART2
  58.     INTEnable(INT_SOURCE_UART_RX(UART2), INT_ENABLED);
  59.     INTSetVectorPriority(INT_UART_2_VECTOR, INT_PRIORITY_LEVEL_2);
  60.     INTSetVectorSubPriority(INT_UART_2_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
  61.  
  62.     INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
  63.     INTEnableInterrupts();
  64.         while(1){
  65.                
  66.         }
  67. }
  68. // *--------------------------------------------------------------------------------*
  69.  
  70.  


Saludos!
« Última modificación: 22 de Noviembre de 2011, 13:00:46 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #12 en: 22 de Noviembre de 2011, 12:35:48 »
Memoria Flash SST25VF016

En este caso a la placa se le ha soldado una memoria Flash de 16-Mbits, o sea una SST25VF016. Aquí podemos diseñar una librería propia a gusto, o aprovechar la que entrega Microchip entre sus stack. Este ejemplo aprovecha esto último  :mrgreen: , así que para ello necesitamos copiar la carpeta Board Support Package desde Microchip Solutions a nuestra carpeta de proyectos, quedando al mismo "nivel" que Microchip y Micros-Designs, por ejemplo.

También debemos agregar el Path ..\Board Support Package en el proyecto para ubicar los include  ;-) Y al proyecto además de agregar SST25VF016.c y SST25VF016.h, también debemos agregar drv_spi.c y drv_spi.h que tiene las funciones necesarias para trabajar con el módulo SPI.

La librería SST25VF016.c hace uso del archivo cabecera HardwareProfile.h, donde allí se habilita su uso y se indica que canal SPI utilizar, así que debemos agregar:

Código: C
  1. #define USE_SST25VF016
  2. #define SPI_CHANNEL_2_ENABLE
  3. #define SST25_CS_LAT                    LATAbits.LATA5
  4. #define SST25_CS_TRIS                   TRISAbits.TRISA5
  5.  

SST25_CS_TRIS fue un adicional, dado que no está en la librería. Además en void SST25Init(DRV_SPI_INIT_DATA *pInitData) agregué la linea SST25_CS_TRIS=0; para configurar como salida tal pin. Y listo, con ello ya se puede probar la EEPROM  :)

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF
  11. // *--------------------------------------------------------------------------------*
  12. #include "SST25VF016.h"
  13. #include "LCDGeneric.h"
  14. #include "HardwareProfileSkP32.h"
  15. // *--------------------------------------------------------------------------------*
  16. char Text[35]="Prueba de almacenamiento en EEPROM";
  17. // *--------------------------------------------------------------------------------*
  18. // *--------------------------------------------------------------------------------*
  19. int main(){
  20.         DRV_SPI_INIT_DATA ConfigSPI;
  21.         char err;
  22.        
  23.         mJTAGPortEnable(0);                                                     // JTAG des-habilitado
  24.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  25.        
  26.         PORTSetPinsDigitalOut(IOPORT_A, BIT_3);         // Backlight del LCD
  27.         mPORTASetBits(BIT_3);
  28.         vInitLCD();
  29.        
  30.         vPutrs_LCD("Inicia SPI:");     
  31.         ConfigSPI.channel=2;
  32.         ConfigSPI.baudRate=1;   // 20 MHz = 80 Mhz/(2*(Brg+1))
  33.         ConfigSPI.cke=1;                // MODE_11, Sample Middle (Misma SD Card)
  34.         ConfigSPI.ckp=0;
  35.         ConfigSPI.smp=0;
  36.         ConfigSPI.mode=0b00;    // 8-bits
  37.         SST25Init(&ConfigSPI);  // Configuracion SPI.
  38.         vPutrs_LCD("\nBorramos sector:");
  39.         SST25SectorErase(0x0000);
  40.         vPutrs_LCD("\nEscribimos...:");
  41.         err=SST25WriteArray(0x0000,Text,34);
  42.         if(err==0){
  43.                 vPutrs_LCD("\nError en escritura");
  44.         }else{
  45.                 vPutrs_LCD("\nEscritura exitosa");
  46.         }
  47.         while(1){
  48.  
  49.         }
  50. }
  51. // *--------------------------------------------------------------------------------*
  52.  
  53.  

Nota: La función SST25WriteArray realiza una verificación del string guardado en EEPROM, retornando 0 o 1.  ;-)


Saludos!
« Última modificación: 04 de Enero de 2013, 20:36:03 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #13 en: 22 de Noviembre de 2011, 12:55:48 »
MDD File System

Sigamos aprovachando el uso de las librerías que nos entrega Microchip, en este caso MDD File System  :-) Para su uso, además de agregar los archivos FSIO.c, FSIO.h, SD-SPI.c, SD-SPI.h, FSConfig.h y FSDef.h al proyecto, debemos agregar ciertas definiciones en el archivo HardwareProfile.h, tales como el uso del módulo SPI para el manejo de la memoria, los pines para uso de CS, CD y WE, la frecuencia SPI final máxima de trabajo, los registros del módulo, etc. En este caso como se utiliza el módulo SPI2 las definiciones son:

Código: C
  1. #ifndef _HARDWAREPROFILE_H_
  2. #define _HARDWAREPROFILE_H_
  3.  
  4.  
  5. #define PORT_LED1       IOPORT_B
  6. #define PIN_LED1        BIT_8
  7. #define PORT_LED2       IOPORT_B
  8. #define PIN_LED2        BIT_9
  9. #define PORT_LED3       IOPORT_B
  10. #define PIN_LED3        BIT_10
  11. #define PORT_LED4       IOPORT_B
  12. #define PIN_LED4        BIT_11
  13.  
  14. #define PORT_SW1        IOPORT_B
  15. #define PIN_SW1         BIT_12
  16. #define PORT_SW2        IOPORT_B
  17. #define PIN_SW2         BIT_13
  18.  
  19. #define GetSystemClock()                (80000000ul)                    // Hz
  20. #define GetInstructionClock()   (GetSystemClock()/1)    // Normally GetSystemClock()/4 for PIC18, GetSystemClock()/2 for PIC24/dsPIC, and GetSystemClock()/1 for PIC32.  Might need changing if using Doze modes.
  21. #define GetPeripheralClock()    (GetSystemClock()/1)
  22.  
  23. #define MILLISECONDS_PER_TICK       10                  // Definition for use with a tick timer
  24. #define TIMER_PRESCALER             TIMER_PRESCALER_8   // Definition for use with a tick timer
  25. #define TIMER_PERIOD                37500               // Definition for use with a tick timer
  26.  
  27. // Description: Macro used to enable the SD-SPI physical layer (SD-SPI.c and .h)
  28. #define USE_SD_INTERFACE_WITH_SPI
  29.  
  30. #ifdef USE_SD_INTERFACE_WITH_SPI
  31.  
  32.         //SPI Configuration
  33.         #define SPI_START_CFG_1     (PRI_PRESCAL_64_1 | SEC_PRESCAL_8_1 | MASTER_ENABLE_ON | SPI_CKE_ON | SPI_SMP_ON)
  34.         #define SPI_START_CFG_2     (SPI_ENABLE)
  35.        
  36.         // Define the SPI frequency
  37.         #define SPI_FREQUENCY                   (20000000)
  38.        
  39.         // Description: SD-SPI Chip Select Output bit
  40.         #define SD_CS               LATAbits.LATA4
  41.         // Description: SD-SPI Chip Select TRIS bit
  42.         #define SD_CS_TRIS          TRISAbits.TRISA4
  43.        
  44.         // Description: SD-SPI Card Detect Input bit
  45.         #define SD_CD               PORTGbits.RG9
  46.         // Description: SD-SPI Card Detect TRIS bit
  47.         #define SD_CD_TRIS          TRISGbits.TRISG9
  48.        
  49.         // Description: SD-SPI Write Protect Check Input bit
  50.         //#define SD_WE               PORTGbits.RG1
  51.         // Description: SD-SPI Write Protect Check TRIS bit
  52.         //#define SD_WE_TRIS          TRISGbits.TRISG1
  53.        
  54.         // Description: The main SPI control register
  55.         #define SPICON1             SPI2CON
  56.         // Description: The SPI status register
  57.         #define SPISTAT             SPI2STAT
  58.         // Description: The SPI Buffer
  59.         #define SPIBUF              SPI2BUF
  60.         // Description: The receive buffer full bit in the SPI status register
  61.         #define SPISTAT_RBF         SPI2STATbits.SPIRBF
  62.         // Description: The bitwise define for the SPI control register (i.e. _____bits)
  63.         #define SPICON1bits         SPI2CONbits
  64.         // Description: The bitwise define for the SPI status register (i.e. _____bits)
  65.         #define SPISTATbits         SPI2STATbits
  66.         // Description: The enable bit for the SPI module
  67.         #define SPIENABLE           SPI2CONbits.ON
  68.         // Description: The definition for the SPI baud rate generator register (PIC32)
  69.         #define SPIBRG                      SPI2BRG
  70.        
  71.         // Tris pins for SCK/SDI/SDO lines
  72.        
  73.         // Description: The TRIS bit for the SCK pin
  74.         #define SPICLOCK            TRISGbits.TRISG6
  75.         // Description: The TRIS bit for the SDI pin
  76.         #define SPIIN               TRISGbits.TRISG7
  77.         // Description: The TRIS bit for the SDO pin
  78.         #define SPIOUT              TRISGbits.TRISG8
  79.         //SPI library functions
  80.         #define putcSPI             putcSPI2
  81.         #define getcSPI             getcSPI2
  82.         #define OpenSPI(config1, config2)   OpenSPI2(config1, config2)
  83. #endif
  84.  
  85. //#include <uart2.h>
  86.  
  87. #endif
  88.  
  89.  

Con solo eso y las configuraciones establecidas en FSconfig.h ya se puede probar la librería:

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF, PWP=OFF
  11. // *--------------------------------------------------------------------------------*
  12. #include "FSIO.h"
  13. #include "HardwareProfile.h"
  14. // *--------------------------------------------------------------------------------*
  15. char MyBuffer[100]="Creacion de archivo mediante libreria de Microchip\r\nby Suky...";
  16. // *--------------------------------------------------------------------------------*
  17. int main(){
  18.         unsigned char err,k;
  19.         char *Sc;
  20.         FSFILE *MyFile;
  21.         rtccTime tm;           
  22.         rtccDate dt;
  23.        
  24.         mJTAGPortEnable(0);                                                     // JTAG des-habilitado
  25.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  26.                        
  27.         PORTSetPinsDigitalOut(PORT_LED1, PIN_LED1);
  28.         PORTSetPinsDigitalOut(PORT_LED3, PIN_LED2);
  29.         PORTClearBits(PORT_LED1,PIN_LED1|PIN_LED2);
  30.         DelayMs(100);
  31.         INTEnableSystemMultiVectoredInt();
  32.         //Initialize the RTCC
  33.         RtccInit();
  34.         while(RtccGetClkStat()!=RTCC_CLK_ON);
  35.        
  36.         tm.l=0;
  37.         tm.sec=0x30;
  38.         tm.min=0x07;
  39.         tm.hour=0x19;
  40.         dt.wday=2;
  41.         dt.mday=0x21;
  42.         dt.mon=0x11;
  43.         dt.year=0x11;
  44.         RtccSetTimeDate(tm.l, dt.l);
  45.    
  46.         k=0;
  47.         do{
  48.                 DelayMs(50);
  49.                 err=FSInit();
  50.                 k++;                   
  51.         }while((k<10) && (err==FALSE));
  52.         if((k==10) && (err==FALSE)){
  53.                 // Error...    
  54.                 PORTSetBits(PORT_LED1,PIN_LED1);
  55.         }else{ 
  56.                 PORTSetBits(PORT_LED2,PIN_LED2);
  57.                 // w Abre archivo para escritura, si existe sobre-escribe
  58.                 // a Abre archivo para escritura, si existe continua agregando datos al final.
  59.                 MyFile = FSfopen("ARCHIVO.TXT","w");
  60.                 for(Sc=&MyBuffer[0];*Sc!=0;Sc++);
  61.                 k=Sc-&MyBuffer[0];
  62.  
  63.                 FSfwrite(&MyBuffer[0], 1, k, MyFile);
  64.                 FSfclose(MyFile);
  65.         }
  66.        
  67.         while(1);
  68. }
  69.  
  70.  

Se configura el RTC interno debido a que en FSconfig.h se establece su uso mediante la definición USEREALTIMECLOCK   ;-)

Saludos!
« Última modificación: 22 de Noviembre de 2011, 13:01:31 por Suky »
No contesto mensajes privados, las consultas en el foro

Desconectado Suky

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 6758
Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
« Respuesta #14 en: 22 de Noviembre de 2011, 14:03:35 »
LCD TFT 320x240


Para la utilización y creación de una librería para un LCD TFT hay que determinar exactamente que controlador utiliza, y que modo de comunicación (8-bits o 16-bits) ha sido establecido por hardware en su construcción. Teniendo en claro eso se puede buscar por la red alguna librería como para migrarla al lenguaje que se utilice  ;-) En mi caso el controlador es un SSD1289 a 16-bits, y la idea es implementar el módulo PMP para su control, por lo que su configuración es:

Código: C
  1.     PMMODE = 0;
  2.     PMAEN = 0;
  3.     PMCON = 0;
  4.     PMMODEbits.MODE = 2;                    // Intel 80 master interface
  5.     PMMODEbits.WAITB = 0;
  6.     PMMODEbits.WAITM = 2;
  7.     PMMODEbits.WAITE = 0;
  8.     PMMODEbits.MODE16 = 1;                  // 16 bit mode
  9.     PMCONbits.PTRDEN = 1;                   // enable RD line
  10.     PMCONbits.PTWREN = 1;                   // enable WR line
  11.     PMCONbits.PMPEN = 1;                    // enable PMP
  12.  

Adicionalmente a las funciones de inicialización, envio de comando u datos, la librería debe tener lo minimo necesario como para realizar alguna gráfica, en este caso las funciones implementadas son:

Código: C
  1. void vLCDTFT_Scroll_V(UINT16 y1);
  2. void vLCDTFTFillScreen(UINT16 Color);
  3. void vLCDTFTPoint(UINT16 x,UINT16 y,UINT16 Color);
  4. void vLCDTFTText(UINT16 x,UINT16 y,const char *PtrText,const char (*Fuente)[5],unsigned char Alto,UINT16 Color);
  5. void vLCDTFTLine(UINT16 x1,UINT16 y1,UINT16 x2,UINT16 y2,UINT16 Color);
  6. void vLCDTFTRectangle(UINT16 x1,UINT16 y1,UINT16 x2,UINT16 y2,BOOL Filled,UINT16 Color);
  7. void vLCDTFTCircle(UINT16 x,UINT16 y,UINT16 Radius,BOOL Filled,UINT16 Color);

Se adjunta código fuente de LCDTFT.c y LCDTFT.h  ;-)


Como ejemplo de uso, y aprovechando la implementación del RTC interno y de MDD File System, se realiza un reloj analógico animado  :) Para ello se crean 2 funciones principalmente, vDrawImageSDBMP24Bits que a partir del nombre de la imagen BMP de 24-bits, la dibuja centrada en pantalla y vDrawReloj que configura el RTC y crea la animación de las agujas del reloj.

Código: C
  1. #include "LCDTFT.h"
  2. #include "FSIO.h"
  3.  
  4. extern BOOL RelojSalir;
  5. volatile BOOL kbhit_rtc=0;
  6. // *---------------------------------------------------------------------------*
  7. void __ISR(_RTCC_VECTOR, ipl4) RtccIsr(void){
  8.        
  9.         INTClearFlag(INT_RTCC);
  10.         kbhit_rtc=1;
  11. }
  12. // *---------------------------------------------------------------------------*
  13. UINT8 ui8BCD2BIN(UINT8 BCDValue){
  14.         UINT8 Temp;
  15.  
  16.         Temp = BCDValue;
  17.         Temp >>= 1;
  18.         Temp &= 0x78;
  19.         return(Temp + (Temp >> 2) + (BCDValue & 0x0f));
  20. }
  21. // *---------------------------------------------------------------------------*
  22. void vDrawReloj(void){
  23.         rtccTime        tm;
  24.         BOOL Esperar;
  25.         UINT16 x_sec,y_sec,x_min,y_min,x_hr,y_hr;
  26.     UINT16 Angulo;
  27.     #define CENTRO_X                119
  28.     #define CENTRO_Y                159
  29.     #define AGUJA_SEC               55
  30.     #define AGUJA_MIN               50
  31.     #define AGUJA_HR                42
  32.     #define COLOR_FONDO             0xEF7D
  33.        
  34.         RtccInit();                    
  35.         while(RtccGetClkStat()!=RTCC_CLK_ON);
  36.         tm.l=0;
  37.         tm.sec=0x30;
  38.         tm.min=0x45;
  39.         tm.hour=0x13;
  40.        
  41.         RtccChimeEnable();                     
  42.         RtccSetAlarmRptCount(0);               
  43.         RtccSetAlarmRpt(RTCC_RPT_SEC);                  // Cada 1 seg.
  44.         RtccAlarmEnable();
  45.         RtccSetTimeDate(tm.l,0x11112202);
  46.        
  47.         INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
  48.         INTEnableInterrupts();
  49.         INTSetVectorPriority(INT_RTCC_VECTOR, INT_PRIORITY_LEVEL_4);                   
  50.         INTSetVectorSubPriority(INT_RTCC_VECTOR, INT_SUB_PRIORITY_LEVEL_1);            
  51.         INTEnable(INT_RTCC, INT_ENABLED);
  52.        
  53.         // Dibujamos imagen desde Sd Card
  54.         vDrawImageSDBMP24Bits("RELOJ.BMP");
  55.         while(RelojSalir==0){
  56.                 // Calculamos extremos (x,y) de las agujas->
  57.                 // Esto depende de la imagen del reloj de fondo :p
  58.         Angulo=ui8BCD2BIN(tm.sec)*6; // 6=360/60
  59.         x_sec=CENTRO_X+sin((Angulo*3.14159)/180.0)*AGUJA_SEC;
  60.         y_sec=CENTRO_Y-cos((Angulo*3.14159)/180.0)*AGUJA_SEC;
  61.         Angulo=ui8BCD2BIN(tm.min)*6+ui8BCD2BIN(tm.sec)*0.1;  // 0.1=6/360
  62.         x_min=CENTRO_X+sin((Angulo*3.14159)/180.0)*AGUJA_MIN;
  63.         y_min=CENTRO_Y-cos((Angulo*3.14159)/180.0)*AGUJA_MIN;
  64.         Angulo=ui8BCD2BIN(tm.hour)*30+ui8BCD2BIN(tm.min)*0.5; // 30=360/12, 0.5=30/60
  65.         x_hr=CENTRO_X+sin((Angulo*3.14159)/180.0)*AGUJA_HR;
  66.         y_hr=CENTRO_Y-cos((Angulo*3.14159)/180.0)*AGUJA_HR;
  67.         // Dibujamos:        
  68.         vLCDTFTLine(CENTRO_X,CENTRO_Y,x_min,y_min,ColorAzulMarino);
  69.         vLCDTFTLine(CENTRO_X,CENTRO_Y,x_hr,y_hr,ColorAzulMarino);
  70.         vLCDTFTLine(CENTRO_X,CENTRO_Y,x_sec,y_sec,ColorNaranja);
  71.         vLCDTFTCircle(CENTRO_X,CENTRO_Y,3,1,ColorNaranja);
  72.         Esperar=0;
  73.         while(Esperar==0){
  74.             // Interrpcion cada 1 segundo que setea bandera kbhit_rtc
  75.             if(kbhit_rtc==1){
  76.                 kbhit_rtc=0;
  77.                 tm.l=RtccGetTime();
  78.                 Esperar=1;      
  79.             }
  80.         }
  81.         // Borramos:
  82.         vLCDTFTLine(CENTRO_X,CENTRO_Y,x_sec,y_sec,COLOR_FONDO);
  83.         vLCDTFTLine(CENTRO_X,CENTRO_Y,x_min,y_min,COLOR_FONDO);
  84.         vLCDTFTLine(CENTRO_X,CENTRO_Y,x_hr,y_hr,COLOR_FONDO);
  85.        
  86.         }
  87. }
  88. // *---------------------------------------------------------------------------*
  89. void vDrawImageSDBMP24Bits(const CHAR8 *NameImagen){
  90.     #define OffsetWidthPixel    18
  91.     #define OffsetHeighPixel    22
  92.     #define OffsetSizeFile      34
  93.     #define OffsetInitData      10
  94.     #define OffserTipeFile      28
  95.    
  96.     CHAR8 err,p;
  97.     UINT16 PosXImagen,PosYImagen,k,i,y;
  98.     UINT8 Temp,BufferHeader[54],BufferTemp[3],Adicional;
  99.     UINT32 WidthPixel,HeighPixel;
  100.     UINT16 TipeFile,InitData,Temp16bits;
  101.     union{
  102.         UINT16 Val;
  103.         struct{
  104.             unsigned Blue:5;
  105.             unsigned Green:6;
  106.             unsigned Red:5;
  107.         };
  108.     }Color;
  109.     FSFILE *Imagen;
  110.    
  111.     err=FSInit();    
  112.         if(err==FALSE){
  113.                 vLCDTFTFillScreen(ColorBlack);
  114.                 return;
  115.         }
  116.         Imagen = FSfopen(NameImagen,"r");
  117.     // Si no se pudo encontrar archivo:
  118.     if(Imagen==NULL){
  119.         vLCDTFTFillScreen(ColorBlack);
  120.         return;
  121.     }
  122.     // Leemos cabecera de archivo
  123.     FSfread(&BufferHeader[0],1,54,Imagen);
  124.     WidthPixel = ((UINT32)BufferHeader[OffsetWidthPixel + 3]*16777216+BufferHeader[OffsetWidthPixel + 2]*65536+BufferHeader[OffsetWidthPixel + 1]*256+BufferHeader[OffsetWidthPixel]);
  125.     HeighPixel = ((UINT32)BufferHeader[OffsetHeighPixel + 3]*16777216+BufferHeader[OffsetHeighPixel + 2]*65536+BufferHeader[OffsetHeighPixel + 1]*256+BufferHeader[OffsetHeighPixel]);
  126.     InitData = ((UINT16)BufferHeader[OffsetInitData]);
  127.     TipeFile = ((UINT16)BufferHeader[OffserTipeFile + 1]*256 + BufferHeader[OffserTipeFile]);
  128.    
  129.     if((WidthPixel>LCD_X_MAX) || (HeighPixel>LCD_Y_MAX) || (TipeFile!=24)){
  130.             LATBbits.LATB8=1;
  131.         FSfclose(Imagen);
  132.         return;
  133.     }
  134.    
  135.     if(InitData!=54){
  136.         for(k=54;k<InitData;k++){
  137.             FSfread(&Temp,1,1,Imagen);
  138.         }
  139.     }
  140.    
  141.     PosXImagen=(LCD_X_MAX/2)-(WidthPixel/2);
  142.     PosYImagen=(LCD_Y_MAX/2)+(HeighPixel/2);
  143.    
  144.     Temp16bits=WidthPixel*3;
  145.     Adicional=0;
  146.     while(((Temp16bits)%4)!=0){
  147.         Adicional++;
  148.         Temp16bits++;
  149.     }
  150.     for(k=0,y=PosYImagen;k<HeighPixel;k++,y--){
  151.         vLCDTFTAddressSet(PosXImagen,y,PosXImagen+WidthPixel-1,y);
  152.         for(i=0;i<WidthPixel;i++){
  153.             FSfread(&BufferTemp[0],1,3,Imagen); // Leemos 3 bytes (R,G,B)
  154.             Color.Blue=BufferTemp[0]>>3;Color.Green=BufferTemp[1]>>2;Color.Red=BufferTemp[2]>>3; // Conversion de 24-bits a 16-bits.-
  155.             vLCDTFTWriteData(Color.Val);
  156.         }
  157.         // Bytes adicionales para que linea sea multiplo de 4.-
  158.         for(p=0;p<Adicional;p++){
  159.             FSfread(&Temp,1,1,Imagen);
  160.         }
  161.     }
  162.     FSfclose(Imagen);
  163. }
  164.  

Con ello, dentro del main, luego de iniciar el LCD TFT llamamos a la función vDrawReloj() que se encargará de ejecutar la animación:

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz
  7. // FPBDIV 1:1 -> 80MHz
  8. #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1
  9. #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL
  10. #pragma config CP=OFF, BWP=OFF, PWP=OFF
  11. // *--------------------------------------------------------------------------------*
  12. #include "Graphics_Card2TFT.h"  // <-- Incluye vDrawImageSDBMP24Bitsy vDrawReloj
  13. #include "HardwareProfile.h"
  14. // *--------------------------------------------------------------------------------*
  15. BOOL RelojSalir;
  16. // *--------------------------------------------------------------------------------*
  17. int main(){
  18.        
  19.     mJTAGPortEnable(0);                                                 // JTAG des-habilitado
  20.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  21.                        
  22.         PORTSetPinsDigitalOut(PORT_LED1, PIN_LED1);
  23.         PORTSetPinsDigitalOut(PORT_LED2, PIN_LED2);
  24.         PORTSetPinsDigitalOut(PORT_LED3, PIN_LED3);
  25.         PORTSetPinsDigitalOut(PORT_LED4, PIN_LED4);
  26.         PORTClearBits(PORT_LED1,PIN_LED1|PIN_LED2|PIN_LED3|PIN_LED4);
  27.         DelayMs(100);
  28.    
  29.     PORTSetPinsDigitalOut(IOPORT_D, BIT_1);             // Backlight del TFT
  30.         mPORTDSetBits(BIT_1);
  31.         vLCDTFTInit();
  32.         vLCDTFTFillScreen(ColorBlack);
  33.         RelojSalir=0;
  34.         vDrawReloj();          
  35.         while(1){
  36.                 //vDrawImageSDBMP24Bits("IMAGEN01.BMP");
  37.         }
  38. }
  39.  
  40.  


Saludos!
« Última modificación: 22 de Noviembre de 2011, 14:09:17 por Suky »
No contesto mensajes privados, las consultas en el foro


 

anything