#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=OFFTe 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!
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
las 16 muestras supongo que las guardara en algun registro no? o solo guarda la ultima?
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
¿Que programador usas para esta placa?
una pregunta, como haces la parte de la circuiteria de audio?
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.
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.
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.
Por cierto, la versión más avanzada de C32 que he conseguido es la 1.04, entiendo que servirá para empezar.
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!
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.
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
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
PMMODE = 0; PMAEN = 0; PMCON = 0; PMMODEbits.MODE = 2; // Intel 80 master interface PMMODEbits.WAITB = 0; PMMODEbits.WAITM = 2; PMMODEbits.WAITE = 0; PMMODEbits.MODE16 = 1; // 16 bit mode PMCONbits.PTRDEN = 1; // enable RD line PMCONbits.PTWREN = 1; // enable WR line PMCONbits.PMPEN = 1; // enable PMP
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
void vLCDTFT_Scroll_V(UINT16 y1); void vLCDTFTFillScreen(UINT16 Color); void vLCDTFTPoint(UINT16 x,UINT16 y,UINT16 Color); void vLCDTFTText(UINT16 x,UINT16 y,const char *PtrText,const char (*Fuente)[5],unsigned char Alto,UINT16 Color); void vLCDTFTLine(UINT16 x1,UINT16 y1,UINT16 x2,UINT16 y2,UINT16 Color); void vLCDTFTRectangle(UINT16 x1,UINT16 y1,UINT16 x2,UINT16 y2,BOOL Filled,UINT16 Color); 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
#include "LCDTFT.h" #include "FSIO.h" extern BOOL RelojSalir; volatile BOOL kbhit_rtc=0; // *---------------------------------------------------------------------------* void __ISR(_RTCC_VECTOR, ipl4) RtccIsr(void){ INTClearFlag(INT_RTCC); kbhit_rtc=1; } // *---------------------------------------------------------------------------* UINT8 ui8BCD2BIN(UINT8 BCDValue){ UINT8 Temp; Temp = BCDValue; Temp >>= 1; Temp &= 0x78; return(Temp + (Temp >> 2) + (BCDValue & 0x0f)); } // *---------------------------------------------------------------------------* void vDrawReloj(void){ rtccTime tm; BOOL Esperar; UINT16 x_sec,y_sec,x_min,y_min,x_hr,y_hr; UINT16 Angulo; #define CENTRO_X 119 #define CENTRO_Y 159 #define AGUJA_SEC 55 #define AGUJA_MIN 50 #define AGUJA_HR 42 #define COLOR_FONDO 0xEF7D RtccInit(); while(RtccGetClkStat()!=RTCC_CLK_ON); tm.l=0; tm.sec=0x30; tm.min=0x45; tm.hour=0x13; RtccChimeEnable(); RtccSetAlarmRptCount(0); RtccSetAlarmRpt(RTCC_RPT_SEC); // Cada 1 seg. RtccAlarmEnable(); RtccSetTimeDate(tm.l,0x11112202); INTConfigureSystem(INT_SYSTEM_CONFIG_MULT_VECTOR); INTEnableInterrupts(); INTSetVectorPriority(INT_RTCC_VECTOR, INT_PRIORITY_LEVEL_4); INTSetVectorSubPriority(INT_RTCC_VECTOR, INT_SUB_PRIORITY_LEVEL_1); INTEnable(INT_RTCC, INT_ENABLED); // Dibujamos imagen desde Sd Card vDrawImageSDBMP24Bits("RELOJ.BMP"); while(RelojSalir==0){ // Calculamos extremos (x,y) de las agujas-> // Esto depende de la imagen del reloj de fondo :p Angulo=ui8BCD2BIN(tm.sec)*6; // 6=360/60 Angulo=ui8BCD2BIN(tm.min)*6+ui8BCD2BIN(tm.sec)*0.1; // 0.1=6/360 Angulo=ui8BCD2BIN(tm.hour)*30+ui8BCD2BIN(tm.min)*0.5; // 30=360/12, 0.5=30/60 // Dibujamos: vLCDTFTLine(CENTRO_X,CENTRO_Y,x_min,y_min,ColorAzulMarino); vLCDTFTLine(CENTRO_X,CENTRO_Y,x_hr,y_hr,ColorAzulMarino); vLCDTFTLine(CENTRO_X,CENTRO_Y,x_sec,y_sec,ColorNaranja); vLCDTFTCircle(CENTRO_X,CENTRO_Y,3,1,ColorNaranja); Esperar=0; while(Esperar==0){ // Interrpcion cada 1 segundo que setea bandera kbhit_rtc if(kbhit_rtc==1){ kbhit_rtc=0; tm.l=RtccGetTime(); Esperar=1; } } // Borramos: vLCDTFTLine(CENTRO_X,CENTRO_Y,x_sec,y_sec,COLOR_FONDO); vLCDTFTLine(CENTRO_X,CENTRO_Y,x_min,y_min,COLOR_FONDO); vLCDTFTLine(CENTRO_X,CENTRO_Y,x_hr,y_hr,COLOR_FONDO); } } // *---------------------------------------------------------------------------* void vDrawImageSDBMP24Bits(const CHAR8 *NameImagen){ #define OffsetWidthPixel 18 #define OffsetHeighPixel 22 #define OffsetSizeFile 34 #define OffsetInitData 10 #define OffserTipeFile 28 CHAR8 err,p; UINT16 PosXImagen,PosYImagen,k,i,y; UINT8 Temp,BufferHeader[54],BufferTemp[3],Adicional; UINT32 WidthPixel,HeighPixel; UINT16 TipeFile,InitData,Temp16bits; union{ UINT16 Val; struct{ unsigned Blue:5; unsigned Green:6; unsigned Red:5; }; }Color; FSFILE *Imagen; err=FSInit(); if(err==FALSE){ vLCDTFTFillScreen(ColorBlack); return; } Imagen = FSfopen(NameImagen,"r"); // Si no se pudo encontrar archivo: if(Imagen==NULL){ vLCDTFTFillScreen(ColorBlack); return; } // Leemos cabecera de archivo FSfread(&BufferHeader[0],1,54,Imagen); WidthPixel = ((UINT32)BufferHeader[OffsetWidthPixel + 3]*16777216+BufferHeader[OffsetWidthPixel + 2]*65536+BufferHeader[OffsetWidthPixel + 1]*256+BufferHeader[OffsetWidthPixel]); HeighPixel = ((UINT32)BufferHeader[OffsetHeighPixel + 3]*16777216+BufferHeader[OffsetHeighPixel + 2]*65536+BufferHeader[OffsetHeighPixel + 1]*256+BufferHeader[OffsetHeighPixel]); InitData = ((UINT16)BufferHeader[OffsetInitData]); TipeFile = ((UINT16)BufferHeader[OffserTipeFile + 1]*256 + BufferHeader[OffserTipeFile]); if((WidthPixel>LCD_X_MAX) || (HeighPixel>LCD_Y_MAX) || (TipeFile!=24)){ LATBbits.LATB8=1; FSfclose(Imagen); return; } if(InitData!=54){ for(k=54;k<InitData;k++){ FSfread(&Temp,1,1,Imagen); } } PosXImagen=(LCD_X_MAX/2)-(WidthPixel/2); PosYImagen=(LCD_Y_MAX/2)+(HeighPixel/2); Temp16bits=WidthPixel*3; Adicional=0; while(((Temp16bits)%4)!=0){ Adicional++; Temp16bits++; } 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.- vLCDTFTWriteData(Color.Val); } // Bytes adicionales para que linea sea multiplo de 4.- for(p=0;p<Adicional;p++){ FSfread(&Temp,1,1,Imagen); } } FSfclose(Imagen); }
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
#include <p32xxxx.h> #include <plib.h> // *--------------------------------------------------------------------------------* // Cristal de 8MHz.- // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV) // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz // FPBDIV 1:1 -> 80MHz #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1 #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL #pragma config CP=OFF, BWP=OFF, PWP=OFF // *--------------------------------------------------------------------------------* #include "Graphics_Card2TFT.h" // <-- Incluye vDrawImageSDBMP24Bitsy vDrawReloj #include "HardwareProfile.h" // *--------------------------------------------------------------------------------* BOOL RelojSalir; // *--------------------------------------------------------------------------------* int main(){ mJTAGPortEnable(0); // JTAG des-habilitado SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.- PORTSetPinsDigitalOut(PORT_LED1, PIN_LED1); PORTSetPinsDigitalOut(PORT_LED2, PIN_LED2); PORTSetPinsDigitalOut(PORT_LED3, PIN_LED3); PORTSetPinsDigitalOut(PORT_LED4, PIN_LED4); PORTClearBits(PORT_LED1,PIN_LED1|PIN_LED2|PIN_LED3|PIN_LED4); DelayMs(100); PORTSetPinsDigitalOut(IOPORT_D, BIT_1); // Backlight del TFT mPORTDSetBits(BIT_1); vLCDTFTInit(); vLCDTFTFillScreen(ColorBlack); RelojSalir=0; vDrawReloj(); while(1){ //vDrawImageSDBMP24Bits("IMAGEN01.BMP"); } }
Saludos!
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
#define USE_SST25VF016 #define SPI_CHANNEL_2_ENABLE #define SST25_CS_LAT LATAbits.LATA5 #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
#include <p32xxxx.h> #include <plib.h> // *--------------------------------------------------------------------------------* // Cristal de 8MHz.- // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV) // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz // FPBDIV 1:1 -> 80MHz #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1 #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL #pragma config CP=OFF, BWP=OFF // *--------------------------------------------------------------------------------* #include "SST25VF016.h" #include "LCDGeneric.h" #include "HardwareProfileSkP32.h" // *--------------------------------------------------------------------------------* char Text[35]="Prueba de almacenamiento en EEPROM"; // *--------------------------------------------------------------------------------* // *--------------------------------------------------------------------------------* int main(){ DRV_SPI_INIT_DATA ConfigSPI; char err; mJTAGPortEnable(0); // JTAG des-habilitado SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.- PORTSetPinsDigitalOut(IOPORT_A, BIT_3); // Backlight del LCD mPORTASetBits(BIT_3); vInitLCD(); vPutrs_LCD("Inicia SPI:"); ConfigSPI.channel=2; ConfigSPI.baudRate=1; // 20 MHz = 80 Mhz/(2*(Brg+1)) ConfigSPI.cke=1; // MODE_11, Sample Middle (Misma SD Card) ConfigSPI.ckp=0; ConfigSPI.smp=0; ConfigSPI.mode=0b00; // 8-bits SST25Init(&ConfigSPI); // Configuracion SPI. vPutrs_LCD("\nBorramos sector:"); SST25SectorErase(0x0000); vPutrs_LCD("\nEscribimos...:"); err=SST25WriteArray(0x0000,Text,34); if(err==0){ vPutrs_LCD("\nError en escritura"); }else{ vPutrs_LCD("\nEscritura exitosa"); } while(1){ } } // *--------------------------------------------------------------------------------*
Nota: La función SST25WriteArray realiza una verificación del string guardado en EEPROM, retornando 0 o 1. ;-)
Saludos!
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);
}
}
}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++;
}
}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
#define USE_SST25VF016 #define SPI_CHANNEL_2_ENABLE #define SST25_CS_LAT LATAbits.LATA5 #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
#include <p32xxxx.h> #include <plib.h> // *--------------------------------------------------------------------------------* // Cristal de 8MHz.- // SYSCLK = 80 MHz (8MHz Cristal/ FPLLIDIV * FPLLMUL / FPLLODIV) // FPLLDIV 1:2, PLLMULT x20, PLLODIV 1:1. -> 80MHz // FPBDIV 1:1 -> 80MHz #pragma config FPLLODIV=DIV_1, FPLLIDIV=DIV_2, FPLLMUL=MUL_20, FPBDIV=DIV_1 #pragma config FWDTEN=OFF, FCKSM=CSDCMD, POSCMOD=XT, FNOSC=PRIPLL #pragma config CP=OFF, BWP=OFF // *--------------------------------------------------------------------------------* #include "SST25VF016.h" #include "LCDGeneric.h" #include "HardwareProfileSkP32.h" // *--------------------------------------------------------------------------------* char Text[35]="Prueba de almacenamiento en EEPROM"; // *--------------------------------------------------------------------------------* // *--------------------------------------------------------------------------------* int main(){ DRV_SPI_INIT_DATA ConfigSPI; char err; mJTAGPortEnable(0); // JTAG des-habilitado SYSTEMConfigPerformance(GetSystemClock()); // Activa pre-cache.- PORTSetPinsDigitalOut(IOPORT_A, BIT_3); // Backlight del LCD mPORTASetBits(BIT_3); vInitLCD(); vPutrs_LCD("Inicia SPI:"); ConfigSPI.channel=2; ConfigSPI.baudRate=1; // 20 MHz = 80 Mhz/(2*(Brg+1)) ConfigSPI.cke=1; // MODE_11, Sample Middle (Misma SD Card) ConfigSPI.ckp=0; ConfigSPI.smp=0; ConfigSPI.mode=0b00; // 8-bits SST25Init(&ConfigSPI); // Configuracion SPI. vPutrs_LCD("\nBorramos sector:"); SST25SectorErase(0x0000); vPutrs_LCD("\nEscribimos...:"); err=SST25WriteArray(0x0000,Text,34); if(err==0){ vPutrs_LCD("\nError en escritura"); }else{ vPutrs_LCD("\nEscritura exitosa"); } while(1){ } } // *--------------------------------------------------------------------------------*
Nota: La función SST25WriteArray realiza una verificación del string guardado en EEPROM, retornando 0 o 1. ;-)
Saludos!
SST25Init(&ConfigSPI); // Configuracion SPI. alli se queda, mas exactamente en // Wait for write end
while(SST25IsWriteBusy()); siempre me regresa un 1... que sera que tengo malo??? :(
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
void SST25WriteWord(WORD data, DWORD address)
{
vSST25WriteByte(((WORD_VAL) data).v[0], address);
vSST25WriteByte(((WORD_VAL) data).v[1], address + 1);
}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.WORD SST25ReadWord(DWORD address)
{
WORD_VAL temp;
temp.v[0] = uiSST25ReadByte(address);
temp.v[1] = uiSST25ReadByte(address + 1);
return (temp.Val);
}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);
}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!