Ejemplos en MPLAB C32. Placa de desarrollo SkP32 xD

[Suky]

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!

[Diego Gonzalez]

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

[Diego Gonzalez]

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...

[Diego Gonzalez]

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

[Suky]

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!

[IngRandall]

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   , 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

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. // *--------------------------------------------------------------------------------*

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???

[Suky]

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. }

Saludos!

[Suky]

Hola! Agrego un proyecto utilizando las librerías FAT File System de ChaN, 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!

[Diego Gonzalez]

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

[Diego Gonzalez]

Logrado, vi que era instalando un paquete que te instala en el disco duro todas las librerias.

saludos

[Suky]

Exacto... Podes bajar lo siguiente y está todo   https://github.com/AleSuky/SkP32v1.1


Saludos!

[Diego Gonzalez]

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

[Mentor]

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:



 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:



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



Como veis el resultado es un Gato "Psicodelico" 

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.

[Suky]

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 

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!

[Mentor]

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.