TODOPIC

Microcontroladores PIC => Pic32 => Mensaje iniciado por: Suky en 21 de Noviembre de 2011, 16:51:46

Título: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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  (http://www.micros-designs.com.ar/downloads/Esquemas_SkP32.pdf)de la placa.

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

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17187)

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17189)

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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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:

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17191)

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:

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17193)

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.  
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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 (http://www.micros-designs.com.ar/libreria-generica-en-c-control-lcd/) 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.

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17195)
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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.  
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Nocturno en 21 de Noviembre de 2011, 17:02:14
¡Genial y abrumadora tanta info buena!
Gracias
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MGLSOFT en 21 de Noviembre de 2011, 17:06:34
Excelente Suky !!
Felicitaciones por este desarrollo !!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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  :-)

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17198)

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

Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: manwenwe 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.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: manwenwe 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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky 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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: manwenwe en 22 de Noviembre de 2011, 16:56:50
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

Jejeje ya decía yo: pensaba que habías "overclokeado" el micro jejeje. El jpg es bastante más duro para el PIC32MX. Si el controlador gráfico lo descomprime directamente de una flash (SD, MMC)... si que va más rapidillo.

De todas formas lo del bridge este parece una muy buena idea sobre todo cuando faltan GPIOs. No sabía ni que Microchip vendía de estos.

Enhorabuena por el proyecto en general: Nunca bajas el listón Suky!!!

Saludos.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: EdoNork en 23 de Noviembre de 2011, 04:56:13
Suky: ¿Te importa compartir el BOM de la placa?
Gracias.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: jeremylf en 23 de Noviembre de 2011, 06:03:15
Excelente Suky! Gracias.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: ema en 23 de Noviembre de 2011, 09:46:20
Felicitaciones Suky!! Excelente trabajo....  :-/


Saludos
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MLO__ en 23 de Noviembre de 2011, 10:19:42
Excelente!!!!!!
Título: Re: Ejemplos en MPLAB C32 (ADC a 1 Msps)
Publicado por: Suky en 24 de Noviembre de 2011, 17:46:16
Módulo ADC a 1 Msps



Gracias por los comentarios  ;-)

En este caso dejo un ejemplo que configura el módulo ADC para que trabaje a 1 Msps y configura para que interrumpa cada 16 muestras:

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 vConfigADC(void);
  15. // *-------------------------------------------------------------------------*
  16. void __ISR(_ADC_VECTOR,ipl4) ISR_ADC(void){
  17.         INTClearFlag(INT_AD1);
  18.         PORTToggleBits(PORT_LED1,PIN_LED1);
  19. }
  20. // *-------------------------------------------------------------------------*
  21. // *-------------------------------------------------------------------------*
  22. int main(){
  23.        
  24.         mJTAGPortEnable(0);                                                     // JTAG des-habilitado
  25.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  26.         DelayMs(100);
  27.        
  28.         vConfigADC();
  29.         PORTSetPinsDigitalOut(PORT_LED1, PIN_LED1);
  30.         PORTSetBits(PORT_LED1,PIN_LED1);
  31.        
  32.         INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR);
  33.         INTEnableInterrupts();
  34.         while(1){
  35.                 DelayMs(300);
  36.                 PORTToggleBits(PORT_LED3,PIN_LED3);
  37.         }
  38. }
  39. // *-------------------------------------------------------------------------*
  40. void vConfigADC(void){
  41.        
  42.         AD1CON1=0;                                      // Off
  43.         AD1CON1bits.SIDL=0;                     // Encendido en modo IDLE
  44.         AD1CON1bits.FORM=0;                     // Data Output Format: Entero 16-bits
  45.         AD1CON1bits.SSRC=7;                     // Auto-conversion
  46.         AD1CON1bits.CLRASAM=0;          // Operacion Normal
  47.         AD1CON1bits.ASAM=1;                     // Comenzar muestreo inmediantamente completada la conversion
  48.        
  49.         AD1CON2bits.VCFG=0;                     // Vdd/Vss
  50.         AD1CON2bits.OFFCAL=0;           // Apagada calibracion de offset
  51.         AD1CON2bits.CSCNA=0;            // Scan off
  52.         AD1CON2bits.SMPI=0b1111;                        // Interrupcion por cada 16 conversiones
  53.         AD1CON2bits.BUFM=0;                     // Buffer 16-bits
  54.         AD1CON2bits.ALTS=0;                     // Usar siempre MUXA
  55.            
  56.         AD1CON3bits.ADRC=0;                     // ADC Clock desde PBCLK
  57.         AD1CON3bits.SAMC=1;             // Auto Sample Time = 1*Tad            
  58.         AD1CON3bits.ADCS=2;                 // Tad = TPB • 2 • (ADCS<7:0> + 1) = 75ns (13Mhz) (minimo 65ns)
  59.                                                                 // Tc=13*Tad =  1us (1MHz)
  60.        
  61.         AD1CHSbits.CH0SA=0;                     // MUXA +ve -> CH0
  62.         AD1CHSbits.CH0NA=0;                     // MUXA -ve -> Vr-
  63.        
  64.         AD1PCFG=0xFFFF;
  65.         AD1PCFGbits.PCFG0 = 0;          // AN0 as Analog
  66.         AD1CON1bits.ADON = 1;           // Encender modulo
  67.        
  68.         INTSetVectorPriority(INT_ADC_VECTOR, INT_PRIORITY_LEVEL_4);
  69.         INTSetVectorSubPriority(INT_ADC_VECTOR, INT_SUB_PRIORITY_LEVEL_1);
  70.         INTClearFlag(INT_AD1);      
  71.         INTEnable(INT_AD1, INT_ENABLED);
  72.                        
  73. }
  74.  

Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MerLiNz en 24 de Noviembre de 2011, 18:02:30
las 16 muestras supongo que las guardara en algun registro no? o solo guarda la ultima?
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 24 de Noviembre de 2011, 18:49:20
las 16 muestras supongo que las guardara en algun registro no? o solo guarda la ultima?

 :roll: Hay que darle una revisada al datasheet  ;-) Los PIC32 tienen varias opciones, entre una de ellas un buffer de 16 posiciones y 16-bits. En la interrupción podes leerlo con result = ReadADC10(x), donde x puede ser un valor entre 0 y 15.


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MerLiNz en 24 de Noviembre de 2011, 19:23:05
ya, pero para ke voy a buscar en el datasheet pudiendomelo decir tu  :D es mas comodo, algo asi creo haber leido en los dspic33ep creo que incluso se podia poner un sampleo automatico y va actualizando los registros, cuando te interese lees el que necesites, es bastante practico.

Lo unico que no me gusta es que solo puedes leer 3.3v maximo (si, ya se el tema de divisores y etc..) pero se tiene mas margen de error que con un ADC de 5V
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 24 de Noviembre de 2011, 20:15:51
ya, pero para ke voy a buscar en el datasheet pudiendomelo decir tu  :D es mas comodo,...

Si, he visto ese aspecto en algunos hilos :mrgreen: Pero no lo hagas cuando das una respuesta  :D

... algo asi creo haber leido en los dspic33ep creo que incluso se podia poner un sampleo automatico y va actualizando los registros, cuando te interese lees el que necesites, es bastante practico.

Si, desde los PIC24 se implementan esas características. Además muestreo simultaneo o muestreo secuencial, etc...


Lo unico que no me gusta es que solo puedes leer 3.3v maximo (si, ya se el tema de divisores y etc..) pero se tiene mas margen de error que con un ADC de 5V

Sin palabras...


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MerLiNz en 24 de Noviembre de 2011, 21:24:19
sin palabras?
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 24 de Noviembre de 2011, 22:18:29
Touch Screen y algoritmo de calibración (Driver AD7843/XPT2046)


Para el control del touch screen en algún momento deje la librería por aquí (http://www.todopic.com.ar/foros/index.php?topic=32655.msg272796#msg272796), para un PIC32 mucho no hay que cambiar, solo asegurarse de cumplir el mínimo periodo del clock (__delay_CLK_ADS7843()). Comentar además que el driver XPT2046 también es compatible  ;-)

Respecto al algoritmo de calibración, el aplicado es el detallado en la nota de aplicación AN-1021 (http://www.analog.com/static/imported-files/application_notes/AN-1021.pdf) de Analog. La forma de implementarlo es la siguiente: (Hay otros, solo hay que dar una búsqueda por Google  ;-) )

Código: C
  1. #include "LCDTFT.h"
  2. #include "ADS7843.h"
  3.  
  4. typedef struct{
  5.     double  kx1;
  6.     double  kx2;
  7.     double  kx3;
  8.     double  ky1;
  9.     double  ky2;
  10.     double  ky3;
  11. }DATA_CALIBRACION;
  12. // *---------------------------------------------------------------------------------------------------------------------*
  13. void vAdquirirPuntosTouch(TOUCH_DATA *DataTouch, TOUCH_DATA *DataLCD, unsigned char N){
  14.         char k;
  15.        
  16.         vLCDTFTFillScreen(ColorWhite);
  17.     for(k=0;k<N;k++){
  18.         vLCDTFTCircle(DataLCD->x,DataLCD->y,3,1,ColorBlack);
  19.         while(ADS7843_PIN_IRQ==1);
  20.         vTestTouchPanel(DataTouch);
  21.         DelayMs(500);
  22.         vLCDTFTCircle(DataLCD->x,DataLCD->y,3,1,ColorWhite);
  23.         DataTouch++;
  24.         DataLCD++;
  25.     }
  26. }
  27. // http://www.analog.com/static/imported-files/application_notes/AN-1021.pdf
  28. void vCalibrarTouch(DATA_CALIBRACION *Coef,TOUCH_DATA *DataTouch, TOUCH_DATA *DataLCD, unsigned char N){
  29.     double a[3],b[3],c[3],d[3],k;
  30.     int i;
  31.    
  32.     if(N<3){
  33.         return;
  34.     }else{
  35.         if(N==3){
  36.             for(i=0;i<N;i++){
  37.                 a[i]=(double)(DataTouch->x);
  38.                 b[i]=(double)(DataTouch->y);
  39.                 c[i]=(double)(DataLCD->x);
  40.                 d[i]=(double)(DataLCD->y);
  41.                 DataTouch++;
  42.                 DataLCD++;
  43.             }
  44.         }else{
  45.             for(i=0;i<3;i++){
  46.                 a[i]=0;
  47.                 b[i]=0;
  48.                 c[i]=0;
  49.                 d[i]=0;
  50.             }
  51.             for(i=0; i<N; i++){  //AN-1021  Application Note Rev. 0 | Page 10 of 12
  52.                 a[2]=a[2]+(double)(DataTouch->x);
  53.                 b[2]=b[2]+(double)(DataTouch->y);
  54.                 c[2]=c[2]+(double)(DataLCD->x);
  55.                 d[2]=d[2]+(double)(DataLCD->y);
  56.                 a[0]=a[0]+(double)(DataTouch->x)*(double)(DataTouch->x);
  57.                 a[1]=a[1]+(double)(DataTouch->x)*(double)(DataTouch->y);
  58.                 b[0]=a[1];
  59.                 b[1]=b[1]+(double)(DataTouch->y)*(double)(DataTouch->y);
  60.                 c[0]=c[0]+(double)(DataTouch->x)*(double)(DataLCD->x);
  61.                 c[1]=c[1]+(double)(DataTouch->y)*(double)(DataLCD->x);
  62.                 d[0]=d[0]+(double)(DataTouch->x)*(double)(DataLCD->y);
  63.                 d[1]=d[1]+(double)(DataTouch->y)*(double)(DataLCD->y);
  64.                 DataTouch++;
  65.                 DataLCD++;
  66.             }
  67.             a[0]=a[0]/a[2];
  68.             a[1]=a[1]/b[2];  
  69.             b[0]=b[0]/a[2];
  70.             b[1]=b[1]/b[2];  
  71.             c[0]=c[0]/a[2];
  72.             c[1]=c[1]/b[2];
  73.             d[0]=d[0]/a[2];
  74.             d[1]=d[1]/b[2];
  75.             a[2]=a[2]/N;
  76.             b[2]=b[2]/N;
  77.             c[2]=c[2]/N;
  78.             d[2]=d[2]/N;        
  79.         }
  80.         k=(a[0]-a[2])*(b[1]-b[2])-(a[1]-a[2])*(b[0]-b[2]);
  81.         Coef->kx1=((c[0]-c[2])*(b[1]-b[2])-(c[1]-c[2])*(b[0]-b[2]))/k;
  82.         Coef->kx2=((c[1]-c[2])*(a[0]-a[2])-(c[0]-c[2])*(a[1]-a[2]))/k;
  83.         Coef->kx3=(b[0]*(a[2]*c[1]-a[1]*c[2])+b[1]*(a[0]*c[2]-a[2]*c[0])+b[2]*(a[1]*c[0]-a[0]*c[1]))/k;
  84.         Coef->ky1=((d[0]-d[2])*(b[1]-b[2])-(d[1]-d[2])*(b[0]-b[2]))/k;
  85.         Coef->ky2=((d[1]-d[2])*(a[0]-a[2])-(d[0]-d[2])*(a[1]-a[2]))/k;
  86.         Coef->ky3=(b[0]*(a[2]*d[1]-a[1]*d[2])+b[1]*(a[0]*d[2]-a[2]*d[0])+b[2]*(a[1]*d[0]-a[0]*d[1]))/k;
  87.     }
  88. }
  89. void vPuntosTouch2LCD(DATA_CALIBRACION *Coef,TOUCH_DATA *DataTouch, TOUCH_DATA *DataLCD){
  90.  
  91.     DataLCD->x=Coef->kx1*DataTouch->x+Coef->kx2*DataTouch->y+Coef->kx3;
  92.     DataLCD->y=Coef->ky1*DataTouch->x+Coef->ky2*DataTouch->y+Coef->ky3;
  93. }
  94.  

Con ello dentro del main se puede implementar de la siguiente manera:

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 "TouchCalibracion.h"
  14. // *-------------------------------------------------------------------------*
  15. TOUCH_DATA TouchData;
  16.  
  17. DATA_CALIBRACION CoefTouch2LCD;
  18. void vCalibracionTouch(void);
  19. // *-------------------------------------------------------------------------*
  20. int main(){
  21.         TOUCH_DATA Temp;
  22.        
  23.         mJTAGPortEnable(0);                                                     // JTAG des-habilitado
  24.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  25.         DelayMs(100);
  26.        
  27.         PORTSetPinsDigitalOut(IOPORT_D, BIT_1);         // Backlight del TFT
  28.         mPORTDSetBits(BIT_1);
  29.         vLCDTFTInit(); 
  30.         vInitADS7843();
  31.        
  32.         vCalibracionTouch();
  33.  
  34.         vLCDTFTFillScreen(Color_White);
  35.  
  36.         while(1){
  37.                 if(ADS7843_PIN_IRQ==0){
  38.                         vTestTouchPanel(&Temp);
  39.                         vPuntosTouch2LCD(&CoefTouch2LCD,&Temp,&TouchData);  
  40.                         vLCDTFTPoint(TouchData.x,TouchData.y, Color_Black);
  41.                         DelayMs(2);
  42.                 }
  43.         }
  44. }
  45. // *-------------------------------------------------------------------------*
  46. void vCalibracionTouch(void){
  47.         TOUCH_DATA DatosTouch[9], DatosLCD[9];
  48.        
  49.         DatosLCD[0].x=25;
  50.     DatosLCD[0].y=25;
  51.    
  52.     DatosLCD[1].x=120;
  53.     DatosLCD[1].y=25;
  54.    
  55.     DatosLCD[2].x=214;
  56.     DatosLCD[2].y=25;
  57.      
  58.     DatosLCD[3].x=25;
  59.     DatosLCD[3].y=160;
  60.    
  61.     DatosLCD[4].x=120;
  62.     DatosLCD[4].y=160;  
  63.    
  64.     DatosLCD[5].x=214;
  65.     DatosLCD[5].y=160;
  66.    
  67.     DatosLCD[6].x=25;
  68.     DatosLCD[6].y=294;
  69.    
  70.     DatosLCD[7].x=120;
  71.     DatosLCD[7].y=294;
  72.    
  73.     DatosLCD[8].x=214;
  74.     DatosLCD[8].y=294;
  75.    
  76.     vAdquirirPuntosTouch(&DatosTouch[0],&DatosLCD[0],9);
  77.     vCalibrarTouch(&CoefTouch2LCD,&DatosTouch[0],&DatosLCD[0],9);
  78. }
  79.  

Saludos!
Título: Re: Placa de desarrollo SkP32 [ Reproductor AVI ]
Publicado por: Suky en 26 de Noviembre de 2011, 14:10:12
Hola a todos! Por aquí traigo un proyecto lindo para encarar, un reproductor de vídeos AVI  :) Toda la info la pueden encontrar por aquí: http://www.exploringpic32.com/

Un vídeo de la función de reproducción (sin audio) adaptada a la placa SkP32 y la librería propia del LCD TFT usado:



Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: stk500 en 26 de Noviembre de 2011, 14:18:50
 :mrgreen: que chulo te quedo eso Genio Suky
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: fram_22 en 27 de Noviembre de 2011, 02:18:36
muy interesante!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: manutek en 27 de Noviembre de 2011, 14:56:19
Naaa imposible ¡¡¡¡¡¡¡
Espectacular suky  :shock: :shock: :shock: :shock: :shock:
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 27 de Noviembre de 2011, 19:07:42
Saludos Suky.
¿Que programador usas para esta placa?
Gracias.
Jc
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 27 de Noviembre de 2011, 21:29:25
Gracias por los comentarios!  :-/

¿Que programador usas para esta placa?

PicKit2 Clone (http://www.micros-designs.com.ar/pickit2-clone-5v3-3v/)  <3 :-)  :mrgreen:

Hoy le agregue el audio!  :rolleyes: A diferencia del proyecto base que utiliza el codec WM8731 para el audio, en este caso se genera mediante el módulo Output Compare en modo PWM. El audio es mono, 8-bits a 22050 Hz. Lo que complica un poco es el conversor de Video, que dependiendo de la fuente del mismo desfasa el audio   :x

(Conversor: FFMPEG ==> ffmpeg -i 'input.avi' -vcodec rawvideo -pix_fmt rgb565 -s qqvga -ar 22050 -ac 1 -acodec pcm_u8 -r 15 -t 10 output.avi)

A la salida del PWM va un filtro pasa-banda, el mismo que utilice para el reproductor WAV:

(http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=36799.0;attach=17234)

El vídeo (La salida está conectada a un home 2.1   :mrgreen: ):


Adjunto el proyecto  ;)


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MGLSOFT en 27 de Noviembre de 2011, 22:15:54
E S P E C T A C U L A R !!!!!!!!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: fidodido18 en 27 de Noviembre de 2011, 23:31:05
Impresionante!!!

suky tu de donde sacas tanto tiempo e inteligencia??? jajaja FELICITACIONES!!

una pregunta como haces la parte de la circuiteria de audio?
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 28 de Noviembre de 2011, 11:21:36
una pregunta, como haces la parte de la circuiteria de audio?

 :roll: Me acabo de dar cuenta que no se ve la imagen  :tongue: La pueden ver por  acá (http://www.micros-designs.com.ar/wp-content/uploads/2010/10/EsquemaAudio.png)

Es una plaquita externa conectada a la board SkP32 mediante cables hembra-hembra.


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MGLSOFT en 28 de Noviembre de 2011, 11:26:44
Algo pasa con el link, ya que da este error:

Not Found

Apologies, but the page you requested could not be found. Perhaps searching will help.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 28 de Noviembre de 2011, 11:31:03
Algo pasa con el link, ya que da este error:

Not Found

Apologies, but the page you requested could not be found. Perhaps searching will help.


 :z) Ahí lo adjunte al post adecuado  ;-)
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 03 de Diciembre de 2011, 22:10:46
Saludos SUKY.
Espectacular lo del AVI (ya se que es poco original, jajajajajaja).
He decidido construir la placa (con algunas variaciones) que estas empleado para manejar los PIC32 y tengo algunas preguntas:
1.- Quiero dotarla directamente de un RS232 y un RS485. para ello quería usar el MAX232 y el MAX487. Estos los estoy usando habitualmente para mis proyectos con 5V/8Bits (PIC18F...). No se si necesito chip especificos para 3,3V o puedo usar estos conectados a 5V ya que he visto que las conexiones U1 y U2 del PIC32 son "5V Tolerant". En caso contrario, ¿me puedes recomendar algún chip que pueda usar directamente en 3,3V?.
2.- Ocurre lo mismo con la memoria EEPROM, ya que RG8 y RG6 son "5V tolerant" puedo utilizar una memoria alimentada a 5V?.
3.- Me he fijado en tu esquema que el conector SPI1 (JP12) dispone de un formato IDC10 con selector de tensión (3,3V/5V) y sin embargo el conector SPI2 tiene un formato distinto (SIL6) con ambas tensiones. ¿Cual es el motivo?.
4.- ¿Cual es la misión del TPS2041B?.
5.- Integraré en placa (ODIO los cables encima de la mesa, de verdad) tu programador PICKIT2 (con las ultimas versiones de Firmware) con la variación para 3,3V. Actaulmente uso la versión de Felix para 5V y estoy encantado de la vida.
6.- Entiendo que el LCD (no el TFT) que usas es compatible con HD4478. Yo lo alimento a 5V pero veo en las especificaciones que se puede alimentar desde 2,7V, con lo que entiendo que no hay ningún problema para conectarlo a puertos de 3,3V.
7.- Por último, ¿Que versión de compilador C32 estás usando. ?

Gracias anticipadas,

Jc

Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 04 de Diciembre de 2011, 10:03:29
Hola xp8100! Genial que se animen a los PIC32  :) Haber si puedo contestar a las dudas:

1. Por lo que veo el MAX232 puede ser alimentado con 3.3V, sino podes ver el max3232. En un PIC24HJ me acuerdo que use el MAX232 alimentado a 5V, aprovechando, que al igual que en los PIC32, los pines eran "5V Tolerant" y funciono sin ningún problema.

2. Dependiendo de la memoria podes conectarlo directamente a 3.3V. Por ahi te conviene una de gran capacidad, de 2Mbit, 4Mbit o 16Mbit, y esas son de 3.3V.

3. SPI2, que esta conectado a la EEPROM y a la SD Card, están pensados para trabajar a alta velocidad >10MHz, y en caso de agregar otro dispositivo lo ideal sería evitar los cables. Entonces, una placa externa, se puede conectar directamente al SIL6. Fue la idea  :mrgreen:

4. Para USB en modo HOST permite el control de la corriente proporcionada, y como máximo 500 mA. Como puede no conseguirse fácil le agregue un jumper como para des-habilitarlo.

5. Podes revisar el datasheet del PIC32 y conectar el bus ISCP (Tiene 3 opciones) al par "5V Tolerant", de esa manera ahorras un poco de espacio.

6. La alimentación no depende del driver sino de la placa que hayas adquirido. Generalmente incluyen un regulador de 3.3V que puede ser des-habilitado en caso de querer alimentarlo con 3.3V. Luego, aprovechando el PMP de 16-bits de los PIC32, lo mejor sería conseguir un LCD que sea configurado (por hardware) a trabajar a 16-bits.

7. v1.11(b)


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 04 de Diciembre de 2011, 14:52:51
Gracias por tu rápida y amable respuesta, Suky.

1, 2 3.- Ok. Aprovecharé mis MAX233 y memorias.
4.- Entiendo que si no pongo el IC simplemente no puedo controlar el exceso de consumo por parte de la placa desde el puerto USB
5.- No entiendo tu respuesta.¿En que me ahorro espacio?. Entiendo que la inclusión del PICKIT3 adaptada a 3,3V es correcta o me planteas programarlo desde 5V y así ahorrar los componentes para 3,3V?
6.- me refería al LCD de 4x20 que muestras en los ejemplos, no al TFT.
7.- Ok.

Estoy terminando ya el esquema Eagle y voy a intentar meterlo en una placa de una sola cara (más grande que la tuya obviamente). Por cierto, ¿los ficheros que enviaste a iteadstudio para realizar la placa se los enviaste en GERBER o directamente en Eagle, ...?. ¿Tiempo y coste, puedes darme alguna estimación?


Como libro de cabecera voy a utilizar "Programming 32-Bit Microcontrollers In C - Exploring The Pic32 - Lucio Di, Elseiver", salvo que me recomiendes algo mejor o más sencillo.

Un fuerte abrazo desde España,
Jc
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 04 de Diciembre de 2011, 15:16:47
Citar
4.- Entiendo que si no pongo el IC simplemente no puedo controlar el exceso de consumo por parte de la placa desde el puerto USB

Exacto.

Citar
5.- No entiendo tu respuesta.¿En que me ahorro espacio?. Entiendo que la inclusión del PICKIT3 adaptada a 3,3V es correcta o me planteas programarlo desde 5V y así ahorrar los componentes para 3,3V?

Claro, podes utilizar el par ISCP que es tolerante a 5V y usar directamente el que tienes o armar el que tienes en la placa. Si es el de Felixls, lo único sería agregarle unas resistencias de 4.7k pull-down a las lineas Data y Clock. Te ahorras varias resistencias y transistores  ;-)

Citar
6.- me refería al LCD de 4x20 que muestras en los ejemplos, no al TFT.

Aaa! Me falto leer el (no el TFT)  :x Para poder usarlo en micros de 3.3V utilizo un registro de desplazamiento. O sea, el conjunto LCD + registro de desplazamiento lo alimento con 5V (Sino el LCD no funciona).

Citar
Estoy terminando ya el esquema Eagle y voy a intentar meterlo en una placa de una sola cara (más grande que la tuya obviamente). Por cierto, ¿los ficheros que enviaste a iteadstudio para realizar la placa se los enviaste en GERBER o directamente en Eagle, ...?. ¿Tiempo y coste, puedes darme alguna estimación?

En gerber. Si tienes la idea de mandarlo a fabricar encara el proyecto en base a eso, o sea doble faz, pistas finas y juntas, etc  ;-)

Citar
Como libro de cabecera voy a utilizar "Programming 32-Bit Microcontrollers In C - Exploring The Pic32 - Lucio Di, Elseiver", salvo que me recomiendes algo mejor o más sencillo.

Los libros de LDJ son excelentes, lo único a tener en cuenta es que el libro lo realizo cuando estaban los PIC32 a 72MHz. Por aquí un par de comentarios a tener en cuenta: http://www.exploringpic32.com/6

Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 04 de Diciembre de 2011, 16:52:04
Ultima pregunta, Suky.
¿Puedes darme la referencia de tu memoria SPI (Fabricante con Samples si es posible  :))?
Por cierto, la versión más avanzada de C32 que he conseguido es la 1.04, entiendo que servirá para empezar.
Jc
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 04 de Diciembre de 2011, 17:05:33
Para samples.... mmm Ramtron, tiene memorias hasta 2Mbits y envían samples.

Por cierto, la versión más avanzada de C32 que he conseguido es la 1.04, entiendo que servirá para empezar.

Creería que si.

Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 05 de Diciembre de 2011, 15:25:42
Saludos Suky.

Necesito un pequeño consejo.

Como primer paso he creado con Eagle un adaptador TQFP100 a DIP-100 (como definio VelazquezBio en sus primeras bnotas para elproyecto PIC32+TFT).

Imprimiendo desde varias impresoras laser de alta calidad para insolar o planchar, me ha resultado imposible obtener un circuito del Ic PIC32 (TQFP100) legible. Probando como máximo he llegado a TQFP44.

¿Hay algún truco para imprimir este tipo de circuitos?, ¿como imprimiste el tuyo?, ¿lo mandaste a la empresa directamente en GERBER?

Gracias y disculpas por las molestias,

Jc
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 05 de Diciembre de 2011, 15:30:38
El PCB de la placa SkP32 directamente fue mandada a fabricar, o sea se enviaron los Gerber. Planchar esa placa es imposible. Ahora si se diseña la PCB pensando en el planchado o insolado, en mi caso he usado la impresora Laser Samsung ml-1640 con toner original y a 1200 ppp. Luego el papel es muy parecido al fotográfico o también el del contact.


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 06 de Diciembre de 2011, 17:29:16
Asunto resuelto, he pedido un par de estos adaptadores.
TQFP100 PCB Converter (http://www.ebay.com/itm/TQFP-100-TQFP100-TQFP-100-Adapter-SMD-PCB-Double-Side-/280545041432?pt=LH_DefaultDomain_0&hash=item4151c99c18)
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MerLiNz en 07 de Diciembre de 2011, 08:26:19
te tenias que haber pillado este TQFP100 (http://www.ebay.com/itm/ws/eBayISAPI.dll?ViewItem&item=280544767186) trae para poner el ICSP, y por detras trae para poner todos los condensadores, resistencias de mclr...
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 07 de Diciembre de 2011, 09:19:35
MerlinZ, de esos he pedido 2  :o
Fue mi primera opción, pero luego me lie con los 04mm y los 0,5 mm.
Finalmente he pedido los de 100, estos que tu comentas y unos de 64 contactos.

¿Los has usado alguna vez los que tu comentas?

Un abrazo,

Jc
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MerLiNz en 07 de Diciembre de 2011, 10:07:10
nop, yo al igua lque tu tambien me pille de 64 y otro que habia de 100 0.4 por una cara y 100 0.5 por otra. El de 64 no me valio, era demasiado grande para un pic32 que tenia por aqui. Y de 100 estoy esperando que me llegen los samples de microchip de 100 pins. El de 64 no ponia nada de medidas ni nada, vamos fue una compra a ciegas pero no sirve.

No te lies con 0.4 y 0.5, depende del formato que tengas mirando el datasheet sabes la separacion que tienes, normalmente los de 0.5 son pics mas grandes 12x12, y los de 0.4 de 10x10 (hablando de tqfp100), si miras el final del datasheet veras a que me refiero, segun elijas una opcion u otra tambien te pone la separacion entre patillas.

Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 09 de Diciembre de 2011, 21:00:52
Saludos Suky.
Pues aqui ando liado redibujando tus esquemas del proyecto SKP32. La idea es meter en una PCB de 15x10 simple cara, tu diseño para hacerlo asequible a más gente (ya veremos como queda).
Estoy usando EAGLE y en el momento que los termine y afine, los subo para ver si sirven para que algún "pirado" más se anime y "ruede la bola".
He respetado tu diseño, añadiendo un conector ICD10 para conectar una módulo Ethernet ENC28j60, un reset mediante un DS1233 y un zocalo para montar una placa huesped con la MCU 32, 24 o dsp33.
El caso es que revisando tu esquema me he encontrado con alguna preguntas, que si tienes a bien me gustaría remitirte:
1.- Que cristal montaste finalmente en la placa y el valor de los condensadores C4, C5, C6 y C7 (indicas entre 17 y 22pf). Si me indicas exactamente tu valor, te lo agradecería.
2.- Cual es el motivo de R3 en el conector USB X2 a RF7 (SDI1).? Indicas no colocar si MCU no USB, pero aun así no lo entiendo.
3.- Podrías proporcionarme el Fottprint en formato EAGLE para TPS2041B?. No hay forma de encontrarlo en ninguna libreía de CADSOFT.
4.- Por que R7 conectada a RG9?
5.- C2 es recomendable de tántalo en lugar de Electrolítico?.
6.- Por que SWITCH VUSB para conectar RF6 a +3V3?.
7.- En el conector SV4, existen dos conectores 17 (N$40) y 16 (N$49) sin asignar nombre. ¿Deliberado?.
8.- Puedes suministrarme elpatillaje de tu TFT (4=LCD_RS, 5=LCD_WR, ....). Te lo agradecería ya que el que yo tengo no se porque me da que es "rarito".
9.- En conector ISCP, existen 2 LABEL identificados como RB6- y RB7-, ¿tienen algún significado?.

Buff, menudo pesadez de tio que soy. Lo siento.

Un fuerte abrazo,

Jc


Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 09 de Diciembre de 2011, 22:17:22
1. Como dice, entre 15pF y 27pF. Podes revisar el datasheet, pero generalmente se coloca 22pF.
2. En dispositivos con USB allí esta VBUS, revisar datasheets.
3. Es fácil realizarlo, tienes el datasheet del TPS2041B y aquí (http://picmania.garcia-cuervo.net/eagle_tutlbr_i_library.php) RedPic explica como se puede hacer.
4. Es el pin para detectar cuando se introduce una SD Card  :tongue:
5. Revisar datasheet, allí indica de bajo ESR.
6. Revisar datasheet de PIC24/32 con USB  ;-)
7. VDCAP y ENVREG  ;-)
8. Por lo que he visto existe un estandar, por aquí (http://iteadstudio.com/store/index.php?main_page=product_info&cPath=57_58&products_id=55) lo puedes ver.
9. Es para colocar resistencias entre DATA y CLOCK y el uso del pin. Más detalles por aquí (http://www.sitionica.com.ar/icsp.htm)

Realizar ese esquema en una placa simple faz va a ser un reto bastante importante, ánimos  ;-)


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: xp8100 en 09 de Diciembre de 2011, 22:59:13
Rápido y conciso, si señor.

Gracias Suky!.

Jc
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 15 de Diciembre de 2011, 18:59:11
Hola Suky

Yo tambien puede que me meta en este interesante proyecto. Muchas gracias por compartirlo. Es estupendo. Tambien vi unos videos en youtube realmente buenos.
Gracias por todo.

Tengo una pregunta. aunque mas bien busco opiniones personales respecto a futuros proyectos. En general, ¿como encarais el tema de las adaptaciones de tensiones TTl entre micros y sensores por ejemplo, o ciertos perifericos como lcds, memorias, etc...? ¿Es preocupante en cuanto a la pesadez de realizar conversores de niveles? ¿Procurais tener todo al mismo nivel o directamente adaptais lo que teneis (tipicos 5v)?

Un saludo!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 15 de Diciembre de 2011, 20:31:51
Cuando me toco implementar dispositivos que si o si necesitaban recibir señales >4.5 V (GLCD) implementé adaptadores de nivel (Hay C.I. muy variados para este propósito), pero generalmente los dispositivos permiten trabajarlo a 3.3 V o en todo caso toman esos 3.3 V como un 1 lógico.


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: MerLiNz en 15 de Diciembre de 2011, 22:47:09
Cuando me toco implementar dispositivos que si o si necesitaban recibir señales >4.5 V (GLCD) implementé adaptadores de nivel (Hay C.I. muy variados para este propósito), pero generalmente los dispositivos permiten trabajarlo a 3.3 V o en todo caso toman esos 3.3 V como un 1 lógico.


Saludos!

No te vino mejor usar los pines por colector abierto con una pull-up?

Tu que seguro que lo habras probado, en la mayoria de integrados pone el voltaje minimo para HIGH 0.7VDD osea si esta a 5V serian 3,5V lo toma como 1 logico? Lo digo porque en la mayoria de datasheet viene asi.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 15 de Diciembre de 2011, 23:55:22
Cuando me toco implementar dispositivos que si o si necesitaban recibir señales >4.5 V (GLCD) implementé adaptadores de nivel (Hay C.I. muy variados para este propósito), pero generalmente los dispositivos permiten trabajarlo a 3.3 V o en todo caso toman esos 3.3 V como un 1 lógico.


Saludos!

No te vino mejor usar los pines por colector abierto con una pull-up?

Hable de forma general, no específicamente de un PIC32, y en los casos que lo utilice no disponía de esa posibilidad.

Citar
Tu que seguro que lo habras probado, en la mayoria de integrados pone el voltaje minimo para HIGH 0.7VDD osea si esta a 5V serian 3,5V lo toma como 1 logico? Lo digo porque en la mayoria de datasheet viene asi.

Si, es cierto. Pero los 3.3 V los toman como 1 lógico, igualmente siempre me aseguro probando en un protoboard  ;-)
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 17 de Diciembre de 2011, 05:57:07
Gracias por la respuesta Suky.

Me estoy leyendo el libro. Ademas a la espera de unas muestras que pueden ser programadas por icd2 clone y pickit2 clone :P y luego a ver si monto una placa modular

keep it going!! ;-)
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 17 de Diciembre de 2011, 19:43:21
Ultima pregunta, Suky.
¿Puedes darme la referencia de tu memoria SPI (Fabricante con Samples si es posible  :))?
Por cierto, la versión más avanzada de C32 que he conseguido es la 1.04, entiendo que servirá para empezar.
Jc

 Pero no usas la 2.02 disponible em microchip?

yo estoy teniendi problemas ilogicos... :( abrire un tema de consulta si no avanzo nada :(
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 17 de Diciembre de 2011, 21:17:30
Hola.

Lo confirmo que ya me funciona la version nueva. Pense que era algun posible problema mio, y efectivamente, tras tanta actualizacion del mplab no me funcionaba bien. He instalado el 8.83 con version pic32 2.02 y ya estoy realizando los primeros programas y simulandolos perfectamente. Os dejo las librerias (que ya conoceran los veteranos) pero yo no las conocia

http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en547784

Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: IngRandall en 29 de Marzo de 2012, 12:39:07
Hola, estoy intentando utilizar el uart 1 del pic32, en la recepcion supuestamente esta bien pero en la transmision solo me llegan dos ceros, osea todo lo que sale es cero, en 9600, si le bajo el baudrate salen simbolos raros y si se lo subo aparecen ceros, que creen q pueda estar pasando?
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: steelheart en 30 de Agosto de 2012, 00:27:41
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!
Título: TFT 2N0369-E + touch screen + controlador SSD1289
Publicado por: steelheart en 30 de Agosto de 2012, 15:48:07
Hola suky te habia escrito para comentarte sobre el problema que tengo con mi touch de la pantalla, lo que pasa es que yo mido los voltajes que salen cuando hago un desplazamiento por la pantalla y cuando es horizontal no me varia, solo ve varia en forma vertical el voltaje.
Yo utilizo un dsPIC33FJ256GP710 y el controlador de la pantalla es SSD1289, ud me dijo que siempre utilizaba un driver para el manejo del touch, me puede decir cual utiliz'o y que hace el driver en la pantalla, es que soy un poco novato en esto de pantallas TFT.

Gracias...... EXITOSSSSS
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 30 de Agosto de 2012, 16:17:44
El ADS7843: http://www.todopic.com.ar/foros/index.php?topic=32655.0


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: IngRandall en 30 de Octubre de 2012, 17:14:44
Se configura el RTC interno debido a que en FSconfig.h se establece su uso mediante la definición USEREALTIMECLOCK   ;-)
[/quote]

Necesariamente se tiene que utilizar el rtc interno del pic para poder utilizar la libreria de la sd???... estoy intentando utilizarla por spi, pero FSInit() siempre me da error y comente la parte que activa el rtc, no se si sera por esto.

Estoy utilizando un PIC32MX795F512L.

La SD en que formato debe estar???

Perdón por tantas preguntas  :oops: :oops:
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: IngRandall en 27 de Noviembre de 2012, 11:34:08
Hola Suky, sera que me puedes hacer el favor de subir el proyecto MDD File System, por que he intentado hacerlo compilar así tal cual como dices aquí, pero no me compila  :( :( :( :(
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 27 de Noviembre de 2012, 19:34:52
Hola! Te lo dejo por aquí para su descarga: http://www.micros-designs.com.ar/downloads/SkP32v1.1_SdCard.rar


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: IngRandall en 28 de Noviembre de 2012, 09:35:38
Muchas gracias, voy a probarlo, pero tengo algunas dudas... la gran mayoría de memorias nuevas ya son HC, este stack las soporta??? también leí por allí que no todas las memorias micro sd poseen el modulo spi, por ejemplo las SanDisk si lo tienen pero las genéricas no sabemos si lo tienen o no, esto es cierto???


Lo probe pero nada de nada, no me funciona, el programa se queda esperando respuesta de getcSPI(); pero esta nunca llega, ya he probado con varios programas distintos, como el de Lucio Di Jasio o el mismo ejemplo que trae Microchip, pero tampoco me funcionan, ya me estoy frustrando con esa micro sd... tengo un rtc y una flash al mismo spi y pruebo sus programas y veo las señales en el osciloscopio y funciona, pero e el de la micro sd solo veo ruido :( :( :(
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: IngRandall en 04 de Enero de 2013, 11:07:50
Una pregunta, esta es una memoria eeprom o flash???

Memoria EEPROM SST25VF016

En este caso a la placa se le ha soldado una memoria EEPROM 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.  
  2. #define USE_SST25VF016
  3. #define SPI_CHANNEL_2_ENABLE
  4. #define SST25_CS_LAT                    LATAbits.LATA5
  5. #define SST25_CS_TRIS                   TRISAbits.TRISA5
  6.  

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!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 04 de Enero de 2013, 20:35:25
Flash  :mrgreen: Hay que creerle al datasheet  :D :D
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 20 de Enero de 2013, 14:17:29
Hola Suky, Como seria un ejemplo del uso de la funcion vLCDTFTText ??

Muchas gracias
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 20 de Enero de 2013, 15:08:36
Solucionado jeje, es que no era que la usara mal... es que pintaba un rectangulo encima del texto instantaneamente y no lo veia jejje
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 21 de Enero de 2013, 07:36:29
Hola a todos.
Vengo con novedades. La primera es que quisiera comentar un pequeño fallo en una funcion de VelazquezBio de otro foro.
Código: [Seleccionar]
void tft_cell(unsigned int16 x1,unsigned int16 y1,unsigned int16 lado,unsigned int16 nCell_fil,unsigned int16 nCell_col,unsigned int16 borde,unsigned int16 color1, unsigned int16 Color2, int1 fill)
{

if(borde>=2){borde=borde/2;}
  
   tft_box(x1,y1,(lado*ncell_Fil)+x1,(lado*nCell_Col)+y1,color1,color1,fill);
       for(j=0;j<nCell_Col;j++){
                  for(i=0;i<nCell_Fil;i++){
                     tft_box((i*lado)+x1+borde,(j*lado)+y1+borde,((i*lado)+(lado+y1-borde)),((j*lado)+(lado+y1-borde)),color1,color2,fill);
                  }
            }
}

tft_box((i*lado)+x1+borde,(j*lado)+y1+borde,((i*lado)+(lado+y1-borde)),((j*lado)+(lado+y1-borde)),color1,color2,fill);
Eso debe ser x1 para que funcione bien.

No estoy en ese foro, per agradecele tambien a el de mi parte su colaboracion (como a ti).

Por otra parte he adaptado una funcion para mi tft ue permite hacer scroll:

Código: [Seleccionar]
void vLCDTFT_Scroll_V(UINT16 y1,BOOL direction,UINT16 speed,UINT16 steps){
   unsigned int col,i,j;
   j=0;
   col=y1;
   vLCDTFTWriteCommandData(0x0061,0x0003);
   for(i=0;i<steps;i++){  
      if(direction == 0) {
         if(col-j<1){col=319; j=0;}
            vLCDTFTWriteCommandData(0x006A,col-j);
      }else if(direction == 1){      
         if(col+j>319){col=0; j=0;}
            vLCDTFTWriteCommandData(0x006A,col+j);
      }  
         DelayMs(speed);
         j++;
      }
}

Direccion 0/1 arriba o abajo, bueno dependera de si la tft esta horizontal o no... yo ya probé en vertical, speed cuanto menor mas rapido el scroll y steps el numero de pixeles que "saltan" cada vez
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 21 de Enero de 2013, 09:05:47
Hola amigos, en esto estoy. Ahora tratando de comprender como hacer rejillas para graficas y graficas. ¿Como se hace? saludos
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 21 de Enero de 2013, 13:24:44
He avanzado algo en la "logica"

Se me ocurrio recorrer un buffer, pero voy a seguir teniendo el mismo problema, ya que al llegar al final de la grafica queria "correr" todos los valores sin afectar al fondo ni a la rejilla. ¿Sabe alguien como se suele hacer eso?

Asi hasta ahora, lo dejo por ahora por dolores de cabeza xD  :D Aunque enamorado de la pantallita ^^



Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 21 de Enero de 2013, 17:41:53
Hola! Geniales los avances! El tema de dibujar un fondo, una grilla y poder actualizar la grafica de forma rapida y que no se vea ningun redibujado es bastante complicado.

Hay que elegir colores donde dentro del mismo podes colocar banderas indicando de que se trata y que color habia antes, para poder reponerlo. E implementar una función de lectura del LCD. Esto lo pude apreciar en el código fuente del DSO-NANO, y que en el LCD que yo tengo y en C no lo pude realizar de la mejor manera.

Cuando tenga un poco de tiempo intento explicar como es que lo han implementado.


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 22 de Enero de 2013, 00:40:51
Hola Suky
Muchas gracias, La verdad que una explicacion aunque fuera pequeña me seria de ayuda, mi intencion inicial es hacer una simple muestra de señales "lentas" como con una muestra por segundo (temperaturas,presion,humedad etc...) aunque el tema del borrado lectura de la pantalla entiendo que es similar.
Me he puesto en contacto con el autor del "portoscope" que aparece en youtbe,  y me esta aconsejando para que yo aprenda por mi cuenta, me aconsejo para estos casos que aprenda el concepto de buffer doble, aunque aun estoy tratando de saber de que va.
Tambien me voy a papear un poco las librerias del dsonano y el data de la tft.
Saludos y seguiremos por aqui
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 22 de Enero de 2013, 09:22:36
Avances:
Aunque no es lo que yo quiero (quiero que toda la grafica avance de una vez, pero aun asi estoy en ello. Puede que lo haga pintando gram "internamente" y luego refescando la pantalla para que no se vea el "llenado" (no se si esto es posible pero es mi idea). Siguo leyendo el datasheet... :-)

Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 31 de Enero de 2013, 18:00:08
Hola compañeros.

He realizado mas avances, por fin, ayer denoche y hoy a lo largo del dia puse a andar el touch de la pantalla, a partir de ahora menús y demas cosas jejeje, gracias a todos tambien por vuestros ejemplos

(http://imageshack.us/a/img819/7795/20130131215701.th.jpg) (http://imageshack.us/photo/my-images/819/20130131215701.jpg/)
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 28 de Febrero de 2013, 20:21:04
Hola a todos! Hace un par de días subí a un repositorio GIT todos los ejemplos y esquemas: https://github.com/AleSuky/SkP32v1.1

Hay un par de ejemplos adicionales  ;-)


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: IngRandall en 09 de Marzo de 2013, 11:16:52
Haciendo esto mismo, en el programa del bootloader por uart del PIC32MX795F512L, me sale un error... alguien tiene alguna idea de como solucionarlo???... adjunto la imagen del error.

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!

Esto se soluciono leyendo en un foro de microchip cambie unas cosas y funciono, pero no se que cambie jajajajaja son valores en el .ld del bootloader... ahora me corre el programa, pero cuando llego a
Código: [Seleccionar]
SST25Init(&ConfigSPI); // Configuracion SPI. alli se queda, mas exactamente en
Código: [Seleccionar]
// Wait for write end
    while(SST25IsWriteBusy());
siempre me regresa un 1... que sera que tengo malo??? :(
Título: Re: Ejemplos en MPLAB C32. (Utilización de freeMODBUS)
Publicado por: Suky en 31 de Agosto de 2013, 20:27:05
Hola a todos! He agregado otro proyecto al repositorio. Se trata de implementar lo necesario para utilizar la librería freeMODBUS, con algunas modificaciones (desactivé el envío de datos por interrupciones)

Por acá se puede bajar los fuentes:

https://github.com/AleSuky/SkP32v1.1/tree/master/SW/Ejemplos

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 4MHz.-
  5. // SYSCLK = 80 MHz (4MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:1, 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 UPLLEN=ON, UPLLIDIV=DIV_2
  11. #pragma config CP=OFF, BWP=OFF, PWP=OFF
  12. // *--------------------------------------------------------------------------------*
  13. #include "HardwareProfile.h"
  14. #include "mb.h"
  15. // *--------------------------------------------------------------------------------*
  16. #define REG_INPUT_START         1000
  17. #define REG_INPUT_NREGS         4
  18. #define REG_HOLDING_START       2000
  19. #define REG_HOLDING_NREGS       100
  20. // *--------------------------------------------------------------------------------*
  21. static USHORT   usRegInputStart = REG_INPUT_START;
  22. static USHORT   usRegInputBuf[REG_INPUT_NREGS];
  23. static USHORT   usRegHoldingStart = REG_HOLDING_START;
  24. static USHORT   usRegHoldingBuf[REG_HOLDING_NREGS];
  25. // *--------------------------------------------------------------------------------*
  26. int main(){
  27.     UINT32 Count=0x3FFFF;
  28.     mJTAGPortEnable(0);                                                 // JTAG des-habilitado
  29.     SYSTEMConfigPerformance(GetSystemClock());  // Activa pre-cache.-
  30.  
  31.     LED1_OUTPUT();
  32.     LED2_OUTPUT();
  33.     LED3_OUTPUT();
  34.     LED4_OUTPUT();
  35.  
  36.     LED1_OFF();LED2_OFF();LED3_OFF();LED4_OFF();
  37.  
  38.     SW1_INPUT();
  39.     SW2_INPUT();
  40.  
  41.  
  42.     eMBInit( MB_ASCII, 0x01, 0, 19200, MB_PAR_NONE );
  43.     //eMBInit( MB_RTU, 0x01, 0, 19200, MB_PAR_NONE );
  44.     eMBEnable(  );
  45.     while(1){
  46.         ( void )eMBPoll(  );
  47.         if(--Count==0){
  48.             Count=0x3FFFF;
  49.             LED1_TOGGLE();
  50.         }
  51.     }
  52. }
  53. // *--------------------------------------------------------------------------------*
  54. eMBErrorCode
  55. eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
  56. {
  57.     eMBErrorCode    eStatus = MB_ENOERR;
  58.     int             iRegIndex;
  59.  
  60.     if( ( usAddress >= REG_INPUT_START )
  61.         && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
  62.     {
  63.         iRegIndex = ( int )( usAddress - usRegInputStart );
  64.         while( usNRegs > 0 )
  65.         {
  66.             *pucRegBuffer++ =
  67.                 ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
  68.             *pucRegBuffer++ =
  69.                 ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
  70.             iRegIndex++;
  71.             usNRegs--;
  72.         }
  73.     }
  74.     else
  75.     {
  76.         eStatus = MB_ENOREG;
  77.     }
  78.  
  79.     return eStatus;
  80. }
  81. // *--------------------------------------------------*
  82. eMBErrorCode
  83. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
  84.                  eMBRegisterMode eMode )
  85. {
  86.     eMBErrorCode    eStatus = MB_ENOERR;
  87.     int             iRegIndex;
  88.  
  89.     if( ( usAddress >= REG_HOLDING_START ) &&
  90.         ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
  91.     {
  92.         iRegIndex = ( int )( usAddress - usRegHoldingStart );
  93.         switch ( eMode )
  94.         {
  95.             /* Pass current register values to the protocol stack. */
  96.         case MB_REG_READ:
  97.             while( usNRegs > 0 )
  98.             {
  99.                 *pucRegBuffer++ = ( UCHAR ) ( usRegHoldingBuf[iRegIndex] >> 8 );
  100.                 *pucRegBuffer++ = ( UCHAR ) ( usRegHoldingBuf[iRegIndex] & 0xFF );
  101.                 iRegIndex++;
  102.                 usNRegs--;
  103.             }
  104.             break;
  105.  
  106.             /* Update current register values with new values from the
  107.              * protocol stack. */
  108.         case MB_REG_WRITE:
  109.             while( usNRegs > 0 )
  110.             {
  111.                 usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
  112.                 usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
  113.                 iRegIndex++;
  114.                 usNRegs--;
  115.             }
  116.         }
  117.     }
  118.     else
  119.     {
  120.         eStatus = MB_ENOREG;
  121.     }
  122.     return eStatus;
  123. }
  124. // *--------------------------------------------------*
  125.  
  126. eMBErrorCode
  127. eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
  128.                eMBRegisterMode eMode )
  129. {
  130.     return MB_ENOREG;
  131. }
  132. // *--------------------------------------------------*
  133. eMBErrorCode
  134. eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
  135. {
  136.     return MB_ENOREG;
  137. }
  138.  



Saludos!
Título: Re: Ejemplos en MPLAB C32. (Uso de FAT File System de ChaN)
Publicado por: Suky en 01 de Septiembre de 2013, 16:36:16
Hola! Agrego un proyecto utilizando las librerías FAT File System de ChaN (http://elm-chan.org/fsw/ff/00index_e.html), lo que se hacer es modificar las funciones que están en diskio.c adecuado al hardware, en este caso se utilizan las de Microchip. Creería que esto también se puede usar para XC32, XC16, XC8, C30 y C18..

https://github.com/AleSuky/SkP32v1.1/tree/master/SW/Ejemplos/FSFatTest

Código: C
  1. #include <p32xxxx.h>
  2. #include <plib.h>
  3. // *--------------------------------------------------------------------------------*
  4. // Cristal de 8MHz.-
  5. // SYSCLK = 80 MHz (4MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV)
  6. // FPLLDIV 1:1, 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 UPLLEN=ON, UPLLIDIV=DIV_2
  11. #pragma config CP=OFF, BWP=OFF, PWP=OFF
  12. // *--------------------------------------------------------------------------------*
  13. #include "HardwareProfile.h"
  14. #include "ff.h"
  15. // *--------------------------------------------------------------------------------*
  16. FATFS SD_FS;
  17. FIL file;
  18. BYTE buffer[50]="Probando memoria con FSFAT y PIC32\n\r";
  19. BYTE temp[50];
  20. // *--------------------------------------------------------------------------------*
  21.  
  22. int main(void){
  23.         FRESULT err,res;
  24.         UINT br, bw;
  25.         UINT32 Count=0xFFFFF;
  26.        
  27.        
  28.         mJTAGPortEnable(0);                                                     // JTAG des-habilitado
  29.         SYSTEMConfigPerformance(GetSystemClock());      // Activa pre-cache.-
  30.        
  31.         LED1_OUTPUT();
  32.         LED2_OUTPUT();
  33.         LED3_OUTPUT();
  34.         LED4_OUTPUT();
  35.        
  36.         LED1_OFF();LED2_OFF();LED3_OFF();LED4_OFF();
  37.        
  38.         err = f_mount(0, &SD_FS);
  39.         if (err == FR_OK) {
  40.                 f_open(&file, "dstfile.txt", FA_CREATE_ALWAYS | FA_WRITE);
  41.                 f_write(&file,buffer,36,&bw);
  42.                 f_close(&file);
  43.                 if(bw!=36){
  44.                         LED1_TOGGLE();
  45.                 }
  46.                
  47.                 f_open(&file, "dstfile.txt", FA_READ);
  48.                 f_read(&file,temp,36,&br);
  49.                 f_close(&file);
  50.                 if(br!=36){
  51.                         LED2_TOGGLE();
  52.                 }
  53.                
  54.                 f_open(&file, "dstfile2.txt", FA_CREATE_ALWAYS | FA_WRITE);
  55.                 f_write(&file,temp,36,&bw);            
  56.                 f_close(&file);
  57.                 if(bw!=36){
  58.                         LED3_TOGGLE();
  59.                 }
  60.         }
  61.         while(1){
  62.                 if(--Count==0){
  63.                         Count=0xFFFFF;
  64.                         LED4_TOGGLE();
  65.                 }
  66.         }
  67. }


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 09 de Octubre de 2013, 08:19:44
Hola Suky

Quisiera hacerte una pregunta acerca de la memoria flash. La board support package donde se localiza? Asi como las funciones para manejar el SPI, recientemente acabo de soldar la memoria que empleas pero no se como agregar los archivos de microchip

Saludos
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 09 de Octubre de 2013, 12:36:19
Logrado, vi que era instalando un paquete que te instala en el disco duro todas las librerias.

saludos
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 09 de Octubre de 2013, 21:43:33
Exacto... Podes bajar lo siguiente y está todo ;)  https://github.com/AleSuky/SkP32v1.1


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Diego Gonzalez en 04 de Noviembre de 2013, 20:36:39
Suky, estoy por aqui de nuevo.

Quisiera hacerte una pregunta acerca de la sst25vf016b, quizas sea tonta pero bueno, puede que a alguien que empiece con tus ejemplos le pase.
El caso es que estoy guardando arrays de datos en la memoria, y previamente borro los sectores o incluso la memoria entera para dejarla con el valor decimal 255 o el 0xff ya que segun el datasheet para hacer una programacion byte a byte es necesario que previamente la direccion donde queramos guardar datos este a 0xff, mi pregunta es si es posible evitar eso, ya que yo quisiera modificar bytes al azar dentro de un mapa de bytes pero sin que me sea obligatorio borrar todo el sector.
¿deberia emplear otra memoria?
saludos y muchas gracias
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Mentor en 10 de Noviembre de 2013, 06:30:58
Hola a todos, me he construido una SkP32 de Suky a la cual le he soldado un PIC32MX695F512 y realizado un par de modificaciones por falta de componentes.

Aqui una foto:

(http://i161.photobucket.com/albums/t231/Makanaki_photos/IMG_8902-1.jpg)

 La pirmera es el zócalo SD, el cual parece ser que solo lo fabrican en Argentina y no he podido encontrar un sustituto razonable asi que, rasqué un poco la PCB para los anclajes del zocalo microSD y lo soldé para fijarlo. Luego he adaptado las señales con hilos de grapinar hacia los pads del zocalo original. La segunda es saltar los componentes que controlan el backlight del LCD y fijar la tension a 3v3 ( esta hecho por debajo con un hilo de grapinar). Bueno y la tercera, que yo diria mas que una modificación es una sustitucion de componente, la memoria flash spi SST25VF016B ó SST25VF064c por una W25Q64 de Winbond, que a efectos es lo mismo para comandos spi estandar, eso si, algo lenta en borrar el chip entero comparado con una de Microchip.

Y ya puestos a seguir el ultimo tema del compañero Diego Gonzalez en referencia a la memoria SPI pues he estado usando los ejemplos de Suky y adaptandolos a lo que ahora mismo estoy experimentando, que es grabar imagenes en la memoria SPI y luego leyendo desde la misma para mostrarla en el LCD, aunque no funciona bien. La imagen que leo es un BMP de 24 bits convertido a 5-6-5 con la rutina de Suky desde la SD, modificada para que escriba en la memoria SPI a la vez que se muestra en pantalla perfectamente.

Aqui una foto del BMP leido:

(http://i161.photobucket.com/albums/t231/Makanaki_photos/IMGP9254.jpg)

Una vez leida procedo a leer lo que ha escrito en la memoria y este es el resultado:

(http://i161.photobucket.com/albums/t231/Makanaki_photos/IMGP9256.jpg)

Como veis el resultado es un Gato "Psicodelico"  :mrgreen: :mrgreen:

En fin, a ver si alguno puede arrojar algo de luz pues he probado montones de opciones de lectura y escritura y ninguna da resultado.

Y algo mas.. despues de todo este rollo aprovecho para presentarme.. Mi nombre es Francisco y soy del Sur de España, aficionado a la electronica aunque trabajo de forma profesional en el mismo sector. Tambien aprovecho para dar la enhorabuena a Syku y colaboradores por esta magnifica placa.

En respuesta a Diego, que alguien me corrija si me equivoco para hacer lo que quieres hacer no hay otra forma que borrar o el chip entero o el sector en cuestion.

Saludos.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Suky en 10 de Noviembre de 2013, 12:30:04
Hola!

Diego, las memorias Flash necesitan ese procedimiento si o si.. Y sino podes usar cualquier EEPROM, y si necesitas tiempos más rápidos de escritura podes mirar las opciones FRAM y NSRAM.


Mentor, felicitaciones por el armado de la PCB! Que lastima lo del zócalo (te aseguro que acá no se fabrica nada), en su momento era la única opción que disponía en la zona... Habría que agregar a la placa otro footprint de una micro-SD de forma paralela, pero cual! Alguna que aparezca en Digikey puede ser  :undecided:

Respecto al problema de guardado en la memoria SPI, proba de guardar 10 (por ejemplo) variables de 16-bits en tu memoria y después leerlas, y ahí ver si esta funcionando bien el guardado de los 16-bits y el direccionamiento cada 2 bytes. Tiene que ser alguna detalle que se te escapa.


Saludos!
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Mentor en 10 de Noviembre de 2013, 17:56:54
Citar
Mentor, felicitaciones por el armado de la PCB! Que lastima lo del zócalo (te aseguro que acá no se fabrica nada), en su momento era la única opción que disponía en la zona... Habría que agregar a la placa otro footprint de una micro-SD de forma paralela, pero cual! Alguna que aparezca en Digikey puede ser  undecided

Muchas gracias Suky, reitero el excelente trabajo con esta placa. En cuanto a lo del zocalo no es problema, de momento la solución esta funciona ;), aunque hay zocalos microSD estandar importados de china, si se permite puedo colgar algun enlace de una famosa pagina.
Lo de la memoria SPI, como tu bien dices sospecho que o en la escritura se esta fallando o en la lectura. He usado las rutinas implementadas por microchip de la siguiente manera:

Para escribir uso la rutina:
Código: [Seleccionar]
void SST25WriteWord(WORD data, DWORD address)
{
    vSST25WriteByte(((WORD_VAL) data).v[0], address);
    vSST25WriteByte(((WORD_VAL) data).v[1], address + 1);
}

Y en el codigo que lee de la sd y escribe:
Código: [Seleccionar]
for(k=0,y=PosYImagen;k<HeighPixel;k++,y--){
        vLCDTFTAddressSet(PosXImagen,y,PosXImagen+WidthPixel-1,y);
        for(i=0;i<WidthPixel;i++){
            FSfread(&BufferTemp[0],1,3,Imagen); // Leemos 3 bytes (R,G,B)
            Color.Blue=BufferTemp[0]>>3;Color.Green=BufferTemp[1]>>2;Color.Red=BufferTemp[2]>>3; // Conversion de 24-bits a 16-bits.-
              SST25WriteWord(Color.Val,Address);
           // vSST25WriteByte(Color.LB,Address++);
          //  vSST25WriteByte(Color.HB,Address++);
            vLCDTFTWriteData(Color.Val);
            Address++;
            Address++;
        }
Da igual que use cualquiera de los dos metodos, el resultado es el mismo.

Para la lectura desde la memoria:

Función:
Código: [Seleccionar]
WORD SST25ReadWord(DWORD address)
{
    WORD_VAL    temp;

    temp.v[0] = uiSST25ReadByte(address);
    temp.v[1] = uiSST25ReadByte(address + 1);

    return (temp.Val);
}

Y en la rutina de lectura:
Código: [Seleccionar]
for(k=0,y=PosYImagen;k<HeighPixel;k++,y--){
        vLCDTFTAddressSet(PosXImagen,y,PosXImagen+WidthPixel-1,y);
        for(i=0;i<WidthPixel;i++){
        Color= SST25ReadWord(Address);
        Address++;
        Address++;
        vLCDTFTWriteData(Color);
        }

Tambien he probado a leer 2 bytes y combinarlo en una variable de 16 bits y hace lo mismo.

Saludos.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Mentor en 12 de Noviembre de 2013, 06:35:55
Bueno pues me respondo yo mismo  :mrgreen:

Al final las rutinas de escritura y lectura estan bien, el problema ha sido el colocar el zocalo microsd con hilos que hace que haya algo de ruido en el bus spi por lo que he tenido que bajar la velocidad del micro para que lo haga bien.

Ahora a experimentar un poco con el DMA a ver si se acelera un poco la carga de imagenes desde la Flash SPI.

Saludos.
Título: Re: Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: martpic en 20 de Enero de 2014, 23:23:36
Hola suky has implementado bootloader en esta placa???? Que consideraciones me aconsejas ya que lo estoy implementando y no m funciona.... Use loa ld que estaba en tu proyecto,,,,
Título: Re:Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: ninaa en 01 de Julio de 2018, 00:01:11
Hola estimada comunidad! Les comento, estoy en busca de las librerías del sensor DHT22(RHT03) para utilizarlas con la PIC32MX460 en MPLAB en lenguaje C. Si alguien me las pudiera facilitar sería de gran ayuda. He encontrado sólo las librerías para la PIC18, PIC16 y ARDUINO, pero ignoro cómo hacer la conversión. Gracias de antemano!
Título: Re:Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD
Publicado por: Fer_TACA en 01 de Julio de 2018, 08:18:07
Hola estimada comunidad! Les comento, estoy en busca de las librerías del sensor DHT22(RHT03) para utilizarlas con la PIC32MX460 en MPLAB en lenguaje C. Si alguien me las pudiera facilitar sería de gran ayuda. He encontrado sólo las librerías para la PIC18, PIC16 y ARDUINO, pero ignoro cómo hacer la conversión. Gracias de antemano!

No deberías de poner el mismo mensaje en varios sitios.
Con eso no vas a conseguir que se te responda antes y lo único que haces es dar trabajo a los usuarios que tienen que leer 2 veces la misma consulta.
Revisa las reglas del foro.