Ku potomności lcd 2,4cala z mcu friend jest

W dniu 2016-04-22 o 00:00, Bo(o)t manager pisze:

Jakość obrazu. Zero kontrastu, kolory kompletnie bez życia, brak jakiejkolwiek czerni, migające linie na "czarnych" tłach, dziwnie widoczne piksele, podświetlenie walące po oczach a przy tym nierówne i pulsujące, kanciaste gradienty (fakt, używam tylko 16 bitów).

Może na to trzeba nałożyć jakiś filtr ? Tylko nie wiem czy to znowu nie wpłynie negatywnie na działanie dotyku.

ww pisze:

[..]

Cieszy mnie, że udało Ci się naprawić cytowanie. Co do LCD, sam jeszcze nawet go nie podłączałem więc się nie wypowiem ale to co opisujesz jest dla mnie dziwne, nic takiego nie powinno mieć miejsca, czy sprawdzałeś dokumentację pod kątem regulacji np jasności podświetlenia, zegarów wewnętrznych (może chodzi za szybko i stąd artefakty)?

W dniu 2016-04-22 o 10:33, AlexY pisze:

Nie przypominam sobie żebym coś naprawiał ale niech będzie.

Wszystko sprawdzałem. Jest duża szansa, że ten mój jest oparty na jakiejś wyjątkowo marnej podróbce kontrolera. Zresztą oprócz tych latających linii w tle to mi nie wygląda na typowy błąd. To prostu jest żałośnie marnej jakości.

ww pisze:

[..]

Sorki, nie Ty, dwuliterowy nick mnie zmylił.

Może, ciężko mi w to uwierzyć aczkolwiek to by tłumaczyło niską cenę, jak zacznę boje ze swoimi to będę wiedział coś więcej.

On Fri, 22 Apr 2016 08:06:57 +0200, ww napisał/a:

[ciach]

Obraz u mnie ok. Ale proc chyba nie wyrabia, Jak dobrze spojrzałem to: JAKIŚ_PORT->BRRSL to 6 cykli zegara a jest w komplecie z BRRSH i to trzeba wysłać 2 razy na jeden piksel + wystawienie danych na port. Chyba będę się musiał przeprosić z FSMC czy jak to tam zwą.

Jak korzystasz z stm32 to do testowania LCD stosuję ten program:

//By AtomSoft : AKA Jason Lopez // Enjoy

/* Includes */ /* WAŻNE!!! PODPIĄĆ RESET OD LCD DO +3V!!!*/ #include <stdlib.h>

#include <string.h>

#include "stm32f4xx_conf.h" #include "stm32f4xx.h" #include "font.h" #include "stlinky.h"

void SysTick_Handler(void); void CONFIG_LCD_PINS(void);

char buff[64]; char buff2[]; char spacja[1] = " "; char koniecLinii[2] = "\n"; struct stlinky stlinky_buff;

#define LCD_DB 8 #define LCD_IOP GPIOE #define LCD_CTP GPIOD //#define LCD_RESET GPIOD #define LCD_PINS (GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15) #define LCD_CONT (GPIO_Pin_2 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15) //#define LCD_RST (GPIO_Pin_15)

#define RST GPIO_Pin_2 #define CS GPIO_Pin_12 #define RS GPIO_Pin_13 #define WR GPIO_Pin_14 #define RD GPIO_Pin_15

#define RST_LOW GPIO_ResetBits(LCD_CTP, RST); #define CS_LOW GPIO_ResetBits(LCD_CTP, CS); #define RS_LOW GPIO_ResetBits(LCD_CTP, RS); #define RD_LOW GPIO_ResetBits(LCD_CTP, RD); #define WR_LOW GPIO_ResetBits(LCD_CTP, WR);

#define RST_HIGH GPIO_SetBits(LCD_CTP, RST); #define CS_HIGH GPIO_SetBits(LCD_CTP, CS); #define RS_HIGH GPIO_SetBits(LCD_CTP, RS); #define RD_HIGH GPIO_SetBits(LCD_CTP, RD); #define WR_HIGH GPIO_SetBits(LCD_CTP, WR);

unsigned int IC_CODE; //Stores Driver IC ID (either SPFD5408A or ST7781R)

//Basic Colors #define RED 0xf800 #define GREEN 0x7e00 #define BLUE 0x001f #define BLACK 0x0000 #define YELLOW 0xffe0 #define WHITE 0xffff

//Other Colors #define CYAN 0x07ff #define BRIGHT_RED 0xf810 #define GRAY1 0x8410 #define GRAY2 0x4208

//TFT resolution 240*320 #define MIN_X 0 #define MIN_Y 0 #define MAX_X 239 #define MAX_Y 319

void init (void); void sendCommand(unsigned int index); void sendData(unsigned int data); void pushData(unsigned char data); unsigned char getData(void); unsigned int readRegister(unsigned int index);

void setXY(unsigned int poX, unsigned int poY); void setPixel(unsigned int poX, unsigned int poY,unsigned int color); void drawLine(unsigned int x0,unsigned int y0,unsigned int x1,unsigned int y1,unsigned int color); void drawVerticalLine(unsigned int poX, unsigned int poY,unsigned int length,unsigned int color); void drawHorizontalLine(unsigned int poX, unsigned int poY,unsigned int length,unsigned int color); void drawRectangle(unsigned int poX, unsigned int poY, unsigned int length,unsigned int width,unsigned int color); void fillRectangle(unsigned int poX, unsigned int poY, unsigned int length, unsigned int width, unsigned int color); void drawCircle(int poX, int poY, int r,unsigned int color); void fillCircle(int poX, int poY, int r,unsigned int color); void drawChar(unsigned char ascii,unsigned int poX, unsigned int poY,unsigned int size, unsigned int fgcolor); void drawString(char *string,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor); unsigned char drawNumber(long long_num,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor);

unsigned char drawFloat(float floatNumber,unsigned char decimal,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor); void delay(unsigned char time, int unit); void all_pin_input(void); void all_pin_output(void); void all_pin_low(void);

void setOrientation(unsigned int HV); void LCD_WriteReg(unsigned int INDEX, unsigned int DATA);

GPIO_InitTypeDef LCDCTR_Setup; GPIO_InitTypeDef LCDIO_Setup;

int color = WHITE;

#define us 1 #define ms 1000 #define sec 100000

void uart(char tekst[]){ stlinky_buff.magic = STLINKY_MAGIC; stlinky_buff.bufsize = CONFIG_LIB_STLINKY_BSIZE; stlinky_tx(&stlinky_buff, tekst, strlen(tekst)); }

int main(void) { uint32_t licznik; unsigned int cur = 0,rejestr,i; unsigned int nColor = 1;

uart("odpalam program\n"); /* Configure SysTick for 1ms interrupts: */ SysTick_Config(SystemCoreClock/1000000); uart("ustawiam opóźnienia\n"); CONFIG_LCD_PINS(); uart("konfiguruję piny\n");

init(); //init TFT library setOrientation(1);

//drawString("Ale sie ciesze",10,10,2,WHITE); // drawString("z uruchomienia ",10,30,2,WHITE); // drawString("maszyny",10,50,2,WHITE); // drawString("A Morus to drze chorus",10,70,1,RED);

// drawString("Ja pierdykam, alem szczesliwy",10,80,1,WHITE);

for(;;){

drawHorizontalLine(50,i,30,BLACK); i++;

}

return(0); }

unsigned int TimeCount = 0; unsigned char IsTimeUp = 0;

void SysTick_Handler(void) {

static unsigned int n16Count = 0;

if(!IsTimeUp) { if (TimeCount == n16Count) { IsTimeUp = 1; n16Count = -1; } else { n16Count = n16Count + 1; }

} }

void CONFIG_LCD_PINS(void) {

//RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure GPIOs to drive LCD: */ LCDIO_Setup.GPIO_Pin = LCD_PINS; LCDIO_Setup.GPIO_Mode = GPIO_Mode_OUT; LCDIO_Setup.GPIO_OType = GPIO_OType_PP; LCDIO_Setup.GPIO_Speed = GPIO_Speed_50MHz; LCDIO_Setup.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(LCD_IOP, &LCDIO_Setup);

LCDCTR_Setup.GPIO_Pin = LCD_CONT; LCDCTR_Setup.GPIO_Mode = GPIO_Mode_OUT; LCDCTR_Setup.GPIO_OType = GPIO_OType_PP; LCDCTR_Setup.GPIO_Speed = GPIO_Speed_50MHz; LCDCTR_Setup.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(LCD_CTP, &LCDCTR_Setup);

GPIO_ResetBits(LCD_CTP, LCD_CONT); GPIO_ResetBits(LCD_IOP, LCD_PINS); }

void pushData(unsigned char data) { all_pin_low(); LCD_IOP->ODR = (int)((int)data << LCD_DB); }

void delay(unsigned char time, int unit) { TimeCount=time * unit; IsTimeUp = 0; while(!IsTimeUp); }

unsigned char getData(void) { unsigned char data=0; //delay(1,ms);

data = (LCD_IOP->IDR >> 8);

return data; }

void sendCommand(unsigned int index) { CS_LOW; RS_LOW; RD_HIGH; WR_HIGH;

WR_LOW; pushData(index>>8); //delay(10,us); WR_HIGH;

WR_LOW; pushData(index); //delay(10,us); WR_HIGH;

CS_HIGH; }

void sendData(unsigned int data) { CS_LOW; RS_HIGH; RD_HIGH;

WR_LOW; pushData(data>>8); //delay(10,us); WR_HIGH;

WR_LOW; pushData(data); //delay(10,us); WR_HIGH;

CS_HIGH; }

unsigned int readRegister(unsigned int index) { unsigned int data=0;

CS_LOW; RS_LOW; RD_HIGH; all_pin_output();

//delay(50,us); WR_LOW; //delay(50,us); pushData(index>>8); WR_HIGH;

//delay(50,us); WR_LOW; //delay(50,us); pushData(index); WR_HIGH;

all_pin_input(); all_pin_low(); RS_HIGH;

//delay(50,us); RD_LOW; //delay(50,us); data = (int)getData()<<8; RD_HIGH;

delay(50,us); RD_LOW; delay(50,us); data |= getData(); RD_HIGH;

CS_HIGH; all_pin_output(); return data; }

void init (void) { unsigned char i; unsigned int f; uart("resetuje LCD\n"); uart("chuj resetuję LCD \n"); RST_HIGH; delay(1000,ms);

RST_LOW; delay(300,ms); RST_HIGH; uart("skończyłem resetowanie LCD\n"); CS_HIGH;

//all_pin_output(); //all_pin_low();

delay(100,us); uart("odczyt IC_CODE\n"); IC_CODE = readRegister(0x0); uart("Odczytałem IC_CODE\n"); itoa(IC_CODE, buff,10); uart(buff); uart("\n");

if(!IC_CODE){ while(!IC_CODE) { uart("ponowne odczytanie IC_CODE\n"); IC_CODE = readRegister(0x0); //WAIT UNTIL KNOWN LCD itoa(IC_CODE, buff,10); uart(buff); uart("\n");

} }

if(IC_CODE == 0x6809) //SPFD5408B { uart("To jest RM68090\n"); LCD_WriteReg(0x00E3, 0x3008); // Set internal timing LCD_WriteReg(0x00E7, 0x0012); // Set internal timing LCD_WriteReg(0x00EF, 0x1231); // Set internal timing LCD_WriteReg(0x0001, 0x0100); // set SS and SM bit LCD_WriteReg(0x0002, 0x0700); // set 1 line inversion LCD_WriteReg(0x0003, 0x1030); // set GRAM write direction and BGR=1. LCD_WriteReg(0x0004, 0x0000); // Resize register LCD_WriteReg(0x0008, 0x0207); // set the back porch and front porch LCD_WriteReg(0x0009, 0x0000); // set non- display area refresh cycle ISC[3:0] LCD_WriteReg(0x000A, 0x0000); // FMARK function LCD_WriteReg(0x000C, 0x0000); // RGB interface setting LCD_WriteReg(0x000D, 0x0000); // Frame marker Position LCD_WriteReg(0x000F, 0x0000); // RGB interface polarity //*************Power On sequence ****************// LCD_WriteReg(0x0010, 0x0000); // SAP, BT [3:0], AP, DSTB, SLP, STB LCD_WriteReg(0x0011, 0x0007); // DC1[2:0], DC0[2:0], VC[2:0] LCD_WriteReg(0x0012, 0x0000); // VREG1OUT voltage LCD_WriteReg(0x0013, 0x0000); // VDV[4:0] for VCOM amplitude delay (200,ms); // Dis- charge capacitor power voltage LCD_WriteReg(0x0010, 0x1490); // SAP, BT [3:0], AP, DSTB, SLP, STB LCD_WriteReg(0x0011, 0x0227); // DC1[2:0], DC0[2:0], VC[2:0] delay(50,ms); // Delay 50ms LCD_WriteReg(0x0012, 0x001C); // Internal reference voltage= Vci; delay(50,ms); // Delay 50ms LCD_WriteReg(0x0013, 0x1A00); // Set VDV [4:0] for VCOM amplitude LCD_WriteReg(0x0029, 0x0025); // Set VCM [5:0] for VCOMH LCD_WriteReg(0x002B, 0x000C); // Set Frame Rate delay(50,ms); // Delay 50ms LCD_WriteReg(0x0020, 0x0000); // GRAM horizontal Address LCD_WriteReg(0x0021, 0x0000); // GRAM Vertical Address // ----------- Adjust the Gamma Curve ----------// LCD_WriteReg(0x0030, 0x0000); LCD_WriteReg(0x0031, 0x0506); LCD_WriteReg(0x0032, 0x0104); LCD_WriteReg(0x0035, 0x0207); LCD_WriteReg(0x0036, 0x000F); LCD_WriteReg(0x0037, 0x0306); LCD_WriteReg(0x0038, 0x0102); LCD_WriteReg(0x0039, 0x0707); LCD_WriteReg(0x003C, 0x0702); LCD_WriteReg(0x003D, 0x1604); //------------------ Set GRAM area ---------------// LCD_WriteReg(0x0050, 0x0000); // Horizontal GRAM Start Address LCD_WriteReg(0x0051, 0x00EF); // Horizontal GRAM End Address LCD_WriteReg(0x0052, 0x0000); // Vertical GRAM Start Address LCD_WriteReg(0x0053, 0x013F); // Vertical GRAM Start Address LCD_WriteReg(0x0060, 0xA700); // Gate Scan Line LCD_WriteReg(0x0061, 0x0001); // NDL,VLE, REV LCD_WriteReg(0x006A, 0x0000); // set scrolling line //-------------- Partial Display Control ---------// LCD_WriteReg(0x0080, 0x0000); LCD_WriteReg(0x0081, 0x0000); LCD_WriteReg(0x0082, 0x0000); LCD_WriteReg(0x0083, 0x0000); LCD_WriteReg(0x0084, 0x0000); LCD_WriteReg(0x0085, 0x0000); //-------------- Panel Control -------------------// LCD_WriteReg(0x0090, 0x0010); LCD_WriteReg(0x0092, 0x0600); LCD_WriteReg(0x0007, 0x0133); // 262K color and display ON }

if(IC_CODE == 0x5408B) //SPFD5408B { uart("To jest SPFD5408B"); sendCommand(0x0000); sendData(0x0001); delay(100,ms);

sendCommand(0x0001); sendData(0x0000); sendCommand(0x0002); sendData(0x0700); sendCommand(0x0003); sendData(0x1030); sendCommand(0x0004); sendData(0x0000); sendCommand(0x0008); sendData(0x0207); sendCommand(0x0009); sendData(0x0000); sendCommand(0x000A); sendData(0x0000); sendCommand(0x000C); sendData(0x0000); sendCommand(0x000D); sendData(0x0000); sendCommand(0x000F); sendData(0x0000); //power on sequence VGHVGL sendCommand(0x0010); sendData(0x0000); sendCommand(0x0011); sendData(0x0007); sendCommand(0x0012); sendData(0x0000); sendCommand(0x0013); sendData(0x0000); //vgh sendCommand(0x0010); sendData(0x1290); sendCommand(0x0011); sendData(0x0227); delay(100,ms); //vregiout sendCommand(0x0012); sendData(0x001d); //0x001b delay(100,ms); //vom amplitude sendCommand(0x0013); sendData(0x1500); delay(100,ms); //vom H sendCommand(0x0029); sendData(0x0018); sendCommand(0x002B); sendData(0x000D);

//gamma sendCommand(0x0030); sendData(0x0004); sendCommand(0x0031); sendData(0x0307); sendCommand(0x0032); sendData(0x0002);// 0006 sendCommand(0x0035); sendData(0x0206); sendCommand(0x0036); sendData(0x0408); sendCommand(0x0037); sendData(0x0507); sendCommand(0x0038); sendData(0x0204);//0200 sendCommand(0x0039); sendData(0x0707); sendCommand(0x003C); sendData(0x0405);// 0504 sendCommand(0x003D); sendData(0x0F02); //ram sendCommand(0x0050); sendData(0x0000); sendCommand(0x0051); sendData(0x00EF); sendCommand(0x0052); sendData(0x0000); sendCommand(0x0053); sendData(0x013F); sendCommand(0x0060); sendData(0xA700); sendCommand(0x0061); sendData(0x0001); sendCommand(0x006A); sendData(0x0000); // sendCommand(0x0080); sendData(0x0000); sendCommand(0x0081); sendData(0x0000); sendCommand(0x0082); sendData(0x0000); sendCommand(0x0083); sendData(0x0000); sendCommand(0x0084); sendData(0x0000); sendCommand(0x0085); sendData(0x0000); // sendCommand(0x0090); sendData(0x0010); sendCommand(0x0092); sendData(0x0600); sendCommand(0x0093); sendData(0x0003); sendCommand(0x0095); sendData(0x0110); sendCommand(0x0097); sendData(0x0000); sendCommand(0x0098); sendData(0x0000); sendCommand(0x0007); sendData(0x0133);

sendCommand(0x0022);//Start to write to display RAM

} else { sendCommand(0x0001); sendData(0x0100); sendCommand(0x0002); sendData(0x0700); sendCommand(0x0003); sendData(0x1030); sendCommand(0x0004); sendData(0x0000); sendCommand(0x0008); sendData(0x0302);

sendCommand(0x000A); sendData(0x0000); sendCommand(0x000C); sendData(0x0000); sendCommand(0x000D); sendData(0x0000); sendCommand(0x000F); sendData(0x0000);

delay(100,ms);

sendCommand(0x0030); sendData(0x0000); sendCommand(0x0031); sendData(0x0405); sendCommand(0x0032); sendData(0x0203); sendCommand(0x0035); sendData(0x0004); sendCommand(0x0036); sendData(0x0B07); sendCommand(0x0037); sendData(0x0000); sendCommand(0x0038); sendData(0x0405); sendCommand(0x0039); sendData(0x0203); sendCommand(0x003c); sendData(0x0004); sendCommand(0x003d); sendData(0x0B07); sendCommand(0x0020); sendData(0x0000); sendCommand(0x0021); sendData(0x0000); sendCommand(0x0050); sendData(0x0000); sendCommand(0x0051); sendData(0x00ef); sendCommand(0x0052); sendData(0x0000); sendCommand(0x0053); sendData(0x013f);

delay(100,ms);

sendCommand(0x0060); sendData(0xa700); sendCommand(0x0061); sendData(0x0001); sendCommand(0x0090); sendData(0x003A); sendCommand(0x0095); sendData(0x021E); sendCommand(0x0080); sendData(0x0000); sendCommand(0x0081); sendData(0x0000); sendCommand(0x0082); sendData(0x0000); sendCommand(0x0083); sendData(0x0000); sendCommand(0x0084); sendData(0x0000); sendCommand(0x0085); sendData(0x0000); sendCommand(0x00FF); sendData(0x0001); sendCommand(0x00B0); sendData(0x140D); sendCommand(0x00FF); sendData(0x0000); delay(100,ms); sendCommand(0x0007); sendData(0x0133); delay(50,ms); //exit standby sendCommand(0x0010); sendData(0x14E0); delay(100,ms); sendCommand(0x0007); sendData(0x0133); sendCommand(0x0022); }

//paint screen black for(i=0;i<2;i++) { for(f=0;f<38400;f++) { sendData(GREEN); } } } void LCD_WriteReg(unsigned int INDEX, unsigned int DATA) { sendCommand(INDEX); sendData(DATA); } void setOrientation(unsigned int HV)//horizontal or vertical { sendCommand(0x03); if(HV==1)//vertical { if(IC_CODE == 0x5408) { sendData(0x1038); } else { sendData(0x5038); } } else//horizontal { if(IC_CODE == 0x5408) { sendData(0x1030); } else { sendData(0x5030); } } sendCommand(0x0022); //Start to write to display RAM }

void setXY(unsigned int poX, unsigned int poY) { if(poX <0) poX = 0; if(poX>239) poX = 239;

if(poY <0) poY = 0; if(poY>319) poY = 319; //poX = constrain(poX,MIN_X,MAX_X); //Limits the pixel range to 0 - 239 //poY = constrain(poY,MIN_Y,MAX_Y); //Limits the pixel range to 0 - 319 /* Writing to GRAM beyond the range gives unpredictable results. The above code is to limit this. This might also slow down the writing to TFT. You can remove the above two lines of code, if you think your application code does not write beyond this range. This would speed up TFT writing.

*/

sendCommand(0x0020);//X sendData(poX); sendCommand(0x0021);//Y sendData(poY); sendCommand(0x0022);//Start to write to display RAM }

void setPixel(unsigned int poX, unsigned int poY,unsigned int color) { setXY(poX,poY); sendData(color); }

void drawCircle(int poX, int poY, int r,unsigned int color) { int x = -r, y = 0, err = 2-2*r, e2; do { setPixel(poX-x, poY+y,color); setPixel(poX+x, poY+y,color); setPixel(poX+x, poY-y,color); setPixel(poX-x, poY-y,color); e2 = err; if (e2 <= y) { err += ++y*2+1; if (-x == y && e2 <= x) e2 = 0; } if (e2 > x) err += ++x*2+1; } while (x <= 0); }

void fillCircle(int poX, int poY, int r,unsigned int color) { int x = -r, y = 0, err = 2-2*r, e2; do {

drawVerticalLine(poX-x,poY-y,2*y,color); drawVerticalLine(poX+x,poY-y,2*y,color);

e2 = err; if (e2 <= y) { err += ++y*2+1; if (-x == y && e2 <= x) e2 = 0; } if (e2 > x) err += ++x*2+1; } while (x <= 0);

}

void drawLine(unsigned int x0,unsigned int y0,unsigned int x1,unsigned int y1,unsigned int color) { int dx = (x1-x0), sx = x0<x1 ? 1 : -1; int dy = -(y1-y0), sy = y0<y1 ? 1 : -1; int err = dx+dy, e2; /* error value e_xy */ for (;;){ /* loop */ setPixel(x0,y0,color); e2 = 2*err; if (e2 >= dy) { /* e_xy+e_x > 0 */ if (x0 == x1) break; err += dy; x0 += sx; } if (e2 <= dx) { /* e_xy+e_y < 0 */ if (y0 == y1) break; err += dx; y0 += sy; } } }

void drawVerticalLine(unsigned int poX, unsigned int poY,unsigned int length,unsigned int color) { unsigned int i; if(poX <0) poX = 0; if(poX>239) poX = 239;

if(poY <0) poY = 0; if(poY>319) poY = 319; //poX = constrain(poX,MIN_X,MAX_X); //Limits the pixel range to 0 -

239 //poY = constrain(poY,MIN_Y,MAX_Y); //Limits the pixel range to 0 - 319

setXY(poX,poY); setOrientation(1); if(length+poY>MAX_Y) { length=MAX_Y-poY; }

for(i=0;i<length;i++) { sendData(color); } }

void drawHorizontalLine(unsigned int poX, unsigned int poY,unsigned int length,unsigned int color) { unsigned int i; if(poX <0) poX = 0; if(poX>239) poX = 239;

if(poY <0) poY = 0; if(poY>319) poY = 319; //poX = constrain(poX,MIN_X,MAX_X); //Limits the pixel range to 0 -

239 //poY = constrain(poY,MIN_Y,MAX_Y); //Limits the pixel range to 0 - 319

setXY(poX,poY); setOrientation(0); if(length+poX>MAX_X) { length=MAX_X-poX; } for(i=0;i<length;i++) { sendData(color); } }

void drawRectangle(unsigned int poX, unsigned int poY, unsigned int length,unsigned int width,unsigned int color) { drawHorizontalLine(poX, poY, length, color); drawHorizontalLine(poX, poY+width, length, color);

drawVerticalLine(poX, poY, width,color); drawVerticalLine(poX + length, poY, width,color); }

void fillRectangle(unsigned int poX, unsigned int poY, unsigned int length, unsigned int width, unsigned int color) { unsigned int i; for(i=0;i<width;i++) { drawHorizontalLine(poX, poY+i, length, color); } }

void drawChar(unsigned char ascii,unsigned int poX, unsigned int poY,unsigned int size, unsigned int fgcolor) { unsigned char i; unsigned char temp; unsigned char f; setXY(poX,poY); setOrientation(0); if((ascii < 0x20)||(ascii > 0x7e))//Unsupported char. { ascii = '?'; } for(i=0;i<8;i++) { temp = simpleFont[ascii-0x20][i]; for(f=0;f<8;f++) { if((temp>>f)&0x01) { fillRectangle(poX+i*size, poY+f*size, size, size, fgcolor); }

} } }

void drawString(char *string,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor) { while(*string) { drawChar(*string, poX, poY, size, fgcolor); string++;

if(poX < MAX_X) { poX+=8*size; // Move cursor right } } }

unsigned char drawNumber(long long_num,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor) { unsigned char char_buffer[10]=""; unsigned char i = 0; unsigned char f = 0;

if (long_num < 0) { f=1; drawChar('-',poX, poY, size, fgcolor); long_num = -long_num; if(poX < MAX_X) { poX+=8*size; // Move cursor right } } else if (long_num == 0) { f=1; drawChar('0',poX, poY, size, fgcolor); return f; if(poX < MAX_X) { poX+=8*size; // Move cursor right } }

while (long_num > 0) { char_buffer[i++] = long_num % 10; long_num /= 10; }

f=f+i; for(; i > 0; i--) { drawChar('0'+ char_buffer[i - 1],poX, poY, size, fgcolor); if(poX < MAX_X) { poX+=8*size; // Move cursor right } } return f; }

unsigned char drawFloat(float floatNumber,unsigned char decimal,unsigned int poX, unsigned int poY,unsigned int size,unsigned int fgcolor) { unsigned int temp=0; float decy=0.0; float rounding = 0.5; unsigned char f=0; unsigned char i; unsigned char howlong;

if(floatNumber<0.0) { drawChar('-',poX, poY, size, fgcolor); floatNumber = -floatNumber; if(poX < MAX_X) { poX+=8*size; // Move cursor right } f =1; } for (i=0; i<decimal; ++i) { rounding /= 10.0; } floatNumber += rounding;

temp = (unsigned int)floatNumber; howlong=drawNumber(temp,poX, poY, size, fgcolor); f += howlong; if((poX+8*size*howlong) < MAX_X) { poX+=8*size*howlong; // Move cursor right }

if(decimal>0) { drawChar('.',poX, poY, size, fgcolor); if(poX < MAX_X) { poX+=8*size; // Move cursor right } f +=1; } decy = floatNumber-temp;//decimal part, for(i=0;i<decimal;i++)//4 { decy *=10;// for the next decimal temp = decy;//get the decimal drawNumber(temp,poX, poY, size, fgcolor); floatNumber = -floatNumber; if(poX < MAX_X) { poX+=8*size; // Move cursor right } decy -= temp; } f +=decimal; return (unsigned char)f; }

void all_pin_input(void) { LCDIO_Setup.GPIO_Mode = GPIO_Mode_IN; //SET PORT AS INPUT GPIO_Init(LCD_IOP, &LCDIO_Setup); //Re-Init Port

//LCDCTR_Setup.GPIO_Mode = GPIO_Mode_IN; //SET PORT AS INPUT //GPIO_Init(LCD_CTP, &LCDCTR_Setup); //Re-Init Port }

void all_pin_output(void) { LCDIO_Setup.GPIO_Mode = GPIO_Mode_OUT; //SET PORT AS INPUT GPIO_Init(LCD_IOP, &LCDIO_Setup); //Re-Init Port

//LCDCTR_Setup.GPIO_Mode = GPIO_Mode_OUT; //SET PORT AS INPUT //GPIO_Init(LCD_CTP, &LCDCTR_Setup); //Re-Init Port }

void all_pin_low(void) { LCD_IOP->BSRRH = LCD_PINS; // LCD_CTP->BSRRH = LCD_CONT; }

Wytnij tylko wszystko co dotyczy stlinky.

W dniu 2016-04-23 o 12:05, Bo(o)t manager pisze:

Zawsze jest coś z czym procesor się nie wyrobi.

I w czym to właściwie pomoże ? Chodzi o dodatkową pamięć na bufor ramki czy może da się jakimś cudem podpiąć ten LCD jako zewnętrzną pamięć ?

To zdecydowanie nie jest ten sam kontroler co u mnie.

Ja te wszystko procedury zoptymalizowałem pod kątem mojego LCD i tego co chce wyświetlać. Działa to w sumie nawet nieźle. Tylko teraz np wyświetlam animacje z prędkością 24 klatek na sekundę i mam fatalny "tearing effect". Te kontrolery mają linię synchronizujące aktualizacje pamięci z wyświetlaniem ale te tanie shieldy chyba tego w żaden sposób nie obsługują.

On Mon, 25 Apr 2016 08:14:12 +0200, ww napisał/a:

[ciach]

Jako zewnętrzną pamięć,czy coś takiego, wszystko idzie sprzętowo, sterowanie R/W i takimi tam.

To jest właśnie słabizna tych chińczyków, różne kontrolery i nie opisane co jest tam włożone, ale kupiłem se 3,6cala i chińczyk podał na ebay'u od razu rodzaj sterownika i komendy do niego. Ciekawe co z tego będzie.

Mnie się udało wyciągnąć 7,5 klatki/s, a z ciekawości z jakiego mikroprocesora korzystasz? I programowo obsługujesz R/W czy może zew. timer? A i jak obliczasz framerate? Ja mu każę zalewać kolorem ekran a potem, wyświetlam liczbę i tak w kółko, Potem prosta matematyka i tyle. A jak u Ciebie to wygląda?

On Tue, 26 Apr 2016 19:28:19 +0200, Bo(o)t manager napisał/a:

No i d.. zbita, na tym nowym jest oznaczenie 9481, chińczyk podaje 9488 że tam jest, a komendy podaje od ILI9327, Ten kod co tutaj wstawiłem odczytuje zero zamiast kodu LCD(a kod sterownika powinien zawsze odczytać z tego co się orientuję). Jest fajnie, jak się wk.. zdenerwuję, kupię coś na spi.

W dniu 2016-04-26 o 20:09, Bo(o)t manager pisze:

Jak to u chinczyków

Ten kod co tutaj wstawiłem

Na moim za cholere nie da się odczytać. A komend używam z ILI9341

A czemu na SPI by miało działać łatwiej ? To tylko interfejs

On Tue, 26 Apr 2016 20:14:12 +0200, ww napisał/a:

[ciach]

Na pewno szybciej niż teraz bez FSMC, a i lepiej pewnie opisane np. od Raspberry Pi.

W dniu 2016-04-26 o 19:28, Bo(o)t manager pisze:

Jak patrzę na mnogość tych sterowników (każdy z innymi komendami) to mam duże wątpliwości czy to się da podpiąć pod jakiś standardowy interfejs. Ale może się da.

On Wed, 04 May 2016 10:04:14 +0200, ww napisał/a:

Właściwie już nie muszę stosować żadnych FSMC czy jak to tam zwali, wystarczyło... włączyć optymalizację w kompilatorze teraz mam 12 Mhz napinie WR i ponad 80FPS. Ten rozdział walki zakończony. Teraz trzeba tylko powalczyć z synchronizacją. Problem jest z tym drugim wyświetlaczem (3,6 cala), ale mam nadzieję sobie poradzę. Podobno się jednak da podpiąć ten LCD pod w/w interfejs.

W dniu 2016-04-04 o 08:29, ww pisze:

Kupiłem kolejny (2,8) i chyba szlag mnie trafi. Ten dotyk rezystancyjny jak pewnie wiadomo nie jest zbyt czuły, więc trzeba przycisnąć, no i skutkuje to powstaniem wielkiej plamy. Wyświetlacz osadzony jest na czymś w rodzaju gąbki przez co wygina się na wszystkie strony. Jednak nawet podłożenie go czymś sztywnym dużo nie pomaga. Co za chińskie gówno...

A nie masz problemu przypadkiem z kalibracją "pressure" touchscreena?

To są zwykłe dwa rezystory analogowe więc kalibrację mogę zrobić najwyżej po swojej stronie. I nie ma opcji żeby to działało na dotyk jak w telefonach.

To jest panel rezystancyjny i czułość "pressure" można ustawić w pewnym zakresie, ale taki panel nigdy nie będzie tak czuły jak pojemnościowy z telefonu.

MiSter

Zgadzam się. Mało tego, jak na tak małym panelu próbować będziemy dotyk opuszką palca to chyba efekty będą dużo gorsze niż rysikiem?

Jakoś to tak krzywo było sklejone więc zacząłem wyrównywać i się kompletnie rozpadło. No co za chiński szajs. Posklejam to jakoś porządniej a potem pewnie wyrzuce bo chiński szajs zawsze będzie chińskim szajsem. Nie wiem po co oni takie gówno produkują.

ww pisze:

Bo ktoś to kupuje. Kupiłem 2 szt 2.4 calowe z tej samej aukcji, dostałem z różnymi kontrolerami LCD i nadrukami na dotyku (jeden z ikonkami na dole drugi bez).