Problemas com TFT

wander_gw
(usa KUbuntu)

Enviado em 29/10/2020 - 22:52h

Caros,

Comprei esse conjunto

https://www.aliexpress.com/snapshot/0.html?spm=a2g0s.12269583.0.0.1524dbf067M160&orderId=8118001...

Porem o script enviado pelo vendedor não está rodando.

Já coloquei as imagens no SD e nada!!!

Notem no vídeo demonstrativo https://www.youtube.com/watch?v=EKOHU3GKXjc que é sugerido a porta COM3, minha porta é /dev/ttyUSB1

Ao checar o códiog não dá erro , mas ao transferir a TFT liga mas aparece a mensagen de erro:

avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x00
avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00

Uso o arduino no meu linux e sempre funcionou nessa porta.


O script é: (pode ser baixado em https://drive.google.com/drive/folders/0B6uNNXJ2z4CxXzNXVUZZZ0ZYNHc?spm=a2g0s.imconversation.0.0.588...

++++++++++++++++++++++++++++++++++++++++++++
// Simple BMP display on Uno
// library: 320x240x24 180x180x24 320x240x16
// SDfat (SPI) 2146ms 845ms 1735ms
// SDfat (soft) 4095ms 1730ms 3241ms
// SD (SPI) 3046ms 1263ms 2441ms (7)
// SD (AS7) 16398ms 7384ms 12491ms (7)
//
//Demo for TFT LCD Shield 2.8"
//by Open-Smart Team and Catalex Team
//catalex_inc@163.com
//Store: http://dx.com
//Demo Function: Display bmp file from TF card
//Arduino IDE: 1.6.5
// Board: Arduino UNO R3, Arduino Mega2560

#include <SPI.h> // f.k. for Arduino-1.5.2
//#define USE_SDFAT
#include <SD.h>

//#include <SdFat.h> // Use the SdFat library
//SdFat SD; // Use hardware SPI (or UNO with SD_SPI_CONFIGURATION==2)
//SdFatSoftSpi<12, 11, 13> SD; //Bit-Bang SD_SPI_CONFIGURATION==3

//#include <Adafruit_GFX.h> // Hardware-specific library

//#include <MCUFRIEND_kbv.h>
#include <UTFT.h>

extern uint8_t BigFont[];

//----------------------------------------|
// TFT Breakout -- Arduino UNO / Mega2560 / OPEN-SMART UNO Black
// GND -- GND
// 3V3 -- 3.3V
// CS -- A3
// RS -- A2
// WR -- A1
// RD -- A0
// RST -- RESET
// LED -- GND
// DB0 -- 8
// DB1 -- 9
// DB2 -- 10
// DB3 -- 11
// DB4 -- 4
// DB5 -- 13
// DB6 -- 6
// DB7 -- 7
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_RS A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
//#define LCD_RD A0 // LCD Read goes to Analog 0 the library not use read function
UTFT tft(RM68130,LCD_RS,LCD_WR,LCD_CS);
#define SD_CS 5

#define WHITE 0xFFFF
File root;


int pathlen;
uint8_t spi_save;

void setup()
{

//Serial.begin(9600);

tft.InitLCD();
tft.orient = 0;
tft.setFont(BigFont);
tft.clrScr();

bool good = SD.begin(SD_CS);
/* if (!good) {
Serial.print(F("cannot start SD"));
while (1);
}*/
//tft.setRotation(2);
// bmpDraw("03.bmp", 0, 0);//show a beautiful girl photo in the folder \libraries\MCUFRIEND_kbv\bitmaps
// delay(1000);
}

void loop()
{
tft.fillScr(0);
bmpDraw("01.bmp", 0, 0);
delay(500);
tft.fillScr(0);
bmpDraw("02.bmp", 0, 0);
delay(500);
tft.fillScr(0);
bmpDraw("03.bmp", 0, 0);
delay(500);
tft.fillScr(0);

/* for(int i = 0; i<4; i++) {
tft.fillScreen(0);
tft.setRotation(i);

for(int j=0; j <= 200; j += 50) {
bmpDraw("miniwoof.bmp", j, j);
}
delay(1000);
}*/
}

// This function opens a Windows Bitmap (BMP) file and
// displays it at the given coordinates. It's sped up
// by reading many pixels worth of data at a time
// (rather than pixel by pixel). Increasing the buffer
// size takes more of the Arduino's precious RAM but
// makes loading a little faster. 20 pixels seems a
// good balance.

#define BUFFPIXEL 20

void bmpDraw(char *filename, int x, int y) {
File bmpFile;
int bmpWidth, bmpHeight; // W+H in pixels
uint8_t bmpDepth; // Bit depth (currently must be 24)
uint32_t bmpImageoffset; // Start of image data in file
uint32_t rowSize; // Not always = bmpWidth; may have padding
uint8_t sdbuffer[3*BUFFPIXEL]; // pixel in buffer (R+G+B per pixel)
uint16_t lcdbuffer[BUFFPIXEL]; // pixel out buffer (16-bit per pixel)
uint8_t buffidx = sizeof(sdbuffer); // Current position in sdbuffer
boolean goodBmp = false; // Set to true on valid header parse
boolean flip = true; // BMP is stored bottom-to-top
int w, h, row, col;
uint8_t r, g, b;
uint32_t pos = 0, startTime = millis();
uint8_t lcdidx = 0;
boolean first = true;

if((x >= tft.getDisplayXSize()) || (y >= tft.getDisplayYSize())) return;

Serial.println();
Serial.print("Loading image '");
Serial.print(filename);
Serial.println('\'');
// Open requested file on SD card
SPCR = spi_save;
if ((bmpFile = SD.open(filename)) == NULL) {
Serial.print("File not found");
return;
}

// Parse BMP header
if(read16(bmpFile) == 0x4D42) { // BMP signature
Serial.print(F("File size: ")); Serial.println(read32(bmpFile));
(void)read32(bmpFile); // Read & ignore creator bytes
bmpImageoffset = read32(bmpFile); // Start of image data
Serial.print(F("Image Offset: ")); Serial.println(bmpImageoffset, DEC);
// Read DIB header
Serial.print(F("Header size: ")); Serial.println(read32(bmpFile));
bmpWidth = read32(bmpFile);
bmpHeight = read32(bmpFile);
if(read16(bmpFile) == 1) { // # planes -- must be '1'
bmpDepth = read16(bmpFile); // bits per pixel
Serial.print(F("Bit Depth: ")); Serial.println(bmpDepth);
if((bmpDepth == 24) && (read32(bmpFile) == 0)) { // 0 = uncompressed

goodBmp = true; // Supported BMP format -- proceed!
Serial.print(F("Image size: "));
Serial.print(bmpWidth);
Serial.print('x');
Serial.println(bmpHeight);

// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * 3 + 3) & ~3;

// If bmpHeight is negative, image is in top-down order.
// This is not canon but has been observed in the wild.
if(bmpHeight < 0) {
bmpHeight = -bmpHeight;
flip = false;
}

// Crop area to be loaded
w = bmpWidth;
h = bmpHeight;
if((x+w-1) >= tft.getDisplayXSize()) w = tft.getDisplayXSize() - x;
if((y+h-1) >= tft.getDisplayYSize()) h = tft.getDisplayYSize() - y;
Serial.print("getDisplayXSize() = ");
Serial.print(tft.getDisplayXSize());
Serial.print(" getDisplayYSize() = ");
Serial.print(tft.getDisplayYSize());
// Set TFT address window to clipped image bounds
SPCR = 0;

cbi(tft.P_CS, tft.B_CS);
tft.setXY(x, y, x+w-1, y+h-1);
sbi(tft.P_CS, tft.B_CS);

for (row=0; row<h; row++) { // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
else // Bitmap is stored top-to-bottom
pos = bmpImageoffset + row * rowSize;
SPCR = spi_save;
if(bmpFile.position() != pos) { // Need seek?
bmpFile.seek(pos);
buffidx = sizeof(sdbuffer); // Force buffer reload
}

for (col=0; col<w; col++) { // For each column...
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) { // Indeed
// Push LCD buffer to the display first
if(lcdidx > 0) {
SPCR = 0;
pushColors(lcdbuffer, lcdidx, first);
lcdidx = 0;
first = false;
}
SPCR = spi_save;
bmpFile.read(sdbuffer, sizeof(sdbuffer));
buffidx = 0; // Set index to beginning
}

// Convert pixel from BMP to TFT format
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
lcdbuffer[lcdidx++] = tft.color565(r,g,b);
} // end pixel
} // end scanline
// Write any remaining data to LCD
if(lcdidx > 0) {
SPCR = 0;
pushColors(lcdbuffer, lcdidx, first);
}
Serial.print(F("Loaded in "));
Serial.print(millis() - startTime);
Serial.println(" ms");
} // end goodBmp
}
}
sbi(tft.P_CS, tft.B_CS);
bmpFile.close();
if(!goodBmp) Serial.println("BMP format not recognized.");
}

// These read 16- and 32-bit types from the SD card file.
// BMP data is stored little-endian, Arduino is little-endian too.
// May need to reverse subscript order if porting elsewhere.

uint16_t read16(File f) {
uint16_t result;
((uint8_t *)&result)[0] = f.read(); // LSB
((uint8_t *)&result)[1] = f.read(); // MSB
return result;
}

uint32_t read32(File f) {
uint32_t result;
((uint8_t *)&result)[0] = f.read(); // LSB
((uint8_t *)&result)[1] = f.read();
((uint8_t *)&result)[2] = f.read();
((uint8_t *)&result)[3] = f.read(); // MSB
return result;
}
void pushColors(uint16_t * block, int16_t n, bool first)
{
uint16_t color;
cbi(tft.P_CS, tft.B_CS);

sbi(tft.P_RS, tft.B_RS);
while (n-- > 0) {
color = *block++;
tft.LCD_Write_DATA(color>>8,color&0xff);
}
sbi(tft.P_CS, tft.B_CS);
}
++++++++++++++++++++++++++++++++++++++++++++