Mam taki wyświetlacz LCD TFT 2.8" 240x320 SPI 14-pin ILI9341 oraz ESP32, chcę połączyć to ze sobą i wyświetlać na ekranie 5 zdjęć po kolei, jak taka ramka na zdjęcia. Nie wiem, jak to zaprogramować, ktoś pomoże?
Mam taki wyświetlacz LCD TFT 2.8" 240x320 SPI 14-pin ILI9341 oraz ESP32, chcę połączyć to ze sobą i wyświetlać na ekranie 5 zdjęć po kolei, jak taka ramka na zdjęcia.
Nie wiem, jak to zaprogramować, ktoś pomoże?
NIE!
Jakiś czas temu, tu na tej grupie , uważalem że pomoglem jakiemuś "Wojtkek #" wysylając mu pelny, wytestowany gotowy program do jego projektu z mostkiem H.
Po pewnym czasie otrzymalem odpowiedź, z podkreśleniem, że nie dziękuje, bo taki sam program napisal sobie sam (!?) i mu pracuje...
Jeżeli jednak dalej potrzebujesz pomocy, to jest ona tu: (*jeden klik na myszy)
https://www.youtube.com/watch?v=g1OknIhJa30 albo tu:
https://www.youtube.com/watch?v=STh2koGXPQo
Jaki to dokładnie wyświetlacz? Czy magistrala SPI ma zdefiniowany pin CS przy inicjalizacji? Należałoby się pokazać schemat połączeń ESP32 z wyświetlaczem.
Moduł kolorowego wyświetlacza LCD o przekątnej 2,8 cala i rozdzielczości 240x320 pikseli, oparty na popularnym sterowniku ILI9341. Urządzenie charakteryzuje się 14-pinowym złączem oraz zintegrowanym gniazdem na karty micro SD, co pozwala na wygodne przechowywanie i wyświetlanie grafik bezpośrednio z pamięci zewnętrznej. Jest to wersja modułu bez panelu dotykowego (No Touch), co upraszcza konstrukcję i czyni go idealnym do projektów wymagających wyłącznie czystego i wyraźnego przekazu wizualnego.
Wyświetlacz LCD TFT 2.8" 240x320 SPI 14-pin ILI9341 Stan opakowania oryginalne
Kluczowe cechy
Wydajny sterownik ILI9341: zapewnia szerokie wsparcie w bibliotekach graficznych takich jak Adafruit_ILI9341 czy TFT_eSPI.
Zintegrowany czytnik kart SD: dedykowane gniazdo micro SD z wyprowadzoną magistralą SPI umożliwia szybki dostęp do plików graficznych i danych.
Brak panelu dotykowego: konstrukcja "No Touch" eliminuje zbędne warstwy nad wyświetlaczem, poprawiając jasność i klarowność obrazu.
Interfejs SPI: szeregowa komunikacja pozwala na oszczędność pinów mikrokontrolera przy zachowaniu wysokiej prędkości odświeżania.
Solidny montaż: czerwony laminat o wymiarach 86x50 mm wyposażony w cztery otwory montażowe ułatwia instalację w panelach i obudowach.
W tej wersji modułu (No Touch) piny oznaczone jako T_... są nieaktywne ze względu na brak kontrolera dotyku na płytce PCB.
Pamiętaj, że sterownik ILI9341 pracuje w logice 3.3V. Przy podłączaniu do Arduino Uno lub innych systemów 5V należy zastosować konwertery poziomów logicznych na liniach sygnałowych.
Aby korzystać z karty SD, należy połączyć odpowiednie pola lutownicze przy gnieździe SD z magistralą SPI mikrokontrolera i zdefiniować osobny pin Chip Select (SD_CS).
Skoro inicjalizacja karty SD przebiega błędnie, to należy w pierwszej kolejności sprawdzić, jaki jest tego powód. Czy przypadkowo nie zamieniłeś miejscami MISO i MOSI?
Dobra mamy postępy robiłem tak jak w tutorialu ale nie wgrywałem oprogramowania z filmiku tylko w arduino ide programie są przykłady examples i tam było esp 32 jpeg i jak to wgrałem i wziołem pliki z przykładów to działa wyswietla sie kilka obrazów po kolei tylko nie wszystkie zatrzymuje się przy obrazku myszy i są one nie dopasowane do ekrany wielkoscią może to kwestia rozdzielczości pliku zdjęcia zaraz to sprawdze ale dlaczego nie ma pętli czyli nie lecą cały czas w kółko
// This sketch if for an ESP32, it draws Jpeg images pulled from an SD Card
// onto the TFT.
// As well as the TFT_eSPI library you will need the JPEG Decoder library.
// A copy can be downloaded here, it is based on the library by Makoto Kurauchi.
// https://github.com/Bodmer/JPEGDecoder
// Images on SD Card must be put in the root folder (top level) to be found
// Use the SD library examples to verify your SD Card interface works!
// The example images used to test this sketch can be found in the library
// JPEGDecoder/extras folder
//----------------------------------------------------------------------------------------------------
// Set all chip selects high to avoid bus contention during initialisation of each peripheral
digitalWrite(22, HIGH); // Touch controller chip select (if used)
digitalWrite(15, HIGH); // TFT screen chip select
digitalWrite( 5, HIGH); // SD card chips select, must use GPIO 5 (ESP32 SS)
tft.begin();
if (!SD.begin(5, tft.getSPIinstance())) {
Serial.println("Card Mount Failed");
return;
}
uint8_t cardType = SD.cardType();
// The image is 300 x 300 pixels so we do some sums to position image in the middle of the screen!
// Doing this by reading the image width and height from the jpeg info is left as an exercise!
int x = (tft.width() - 300) / 2 - 1;
int y = (tft.height() - 300) / 2 - 1;
drawSdJpeg("/EagleEye.jpg", x, y); // This draws a jpeg pulled off the SD Card
delay(2000);
tft.setRotation(2); // portrait
tft.fillScreen(random(0xFFFF));
drawSdJpeg("/Baboon40.jpg", 0, 0); // This draws a jpeg pulled off the SD Card
delay(2000);
tft.setRotation(2); // portrait
tft.fillScreen(random(0xFFFF));
drawSdJpeg("/lena20k.jpg", 0, 0); // This draws a jpeg pulled off the SD Card
delay(2000);
tft.setRotation(1); // landscape
tft.fillScreen(random(0xFFFF));
drawSdJpeg("/Mouse480.jpg", 0, 0); // This draws a jpeg pulled off the SD Card
delay(2000);
while(1); // Wait here
}
//####################################################################################################
// Draw a JPEG on the TFT pulled from SD Card
//####################################################################################################
// xpos, ypos is top left corner of plotted image
void drawSdJpeg(const char *filename, int xpos, int ypos) {
// Open the named file (the Jpeg decoder library will close it)
File jpegFile = SD.open( filename, FILE_READ); // or, file handle reference for SD library
if ( !jpegFile ) {
Serial.print("ERROR: File \""); Serial.print(filename); Serial.println ("\" not found!");
return;
}
// Use one of the following methods to initialise the decoder:
bool decoded = JpegDec.decodeSdFile(jpegFile); // Pass the SD file handle to the decoder,
//bool decoded = JpegDec.decodeSdFile(filename); // or pass the filename (String or character array)
if (decoded) {
// print information about the image to the serial port
jpegInfo();
// render the image onto the screen at given coordinates
jpegRender(xpos, ypos);
}
else {
Serial.println("Jpeg file format not supported!");
}
}
//####################################################################################################
// Draw a JPEG on the TFT, images will be cropped on the right/bottom sides if they do not fit
//####################################################################################################
// This function assumes xpos,ypos is a valid screen coordinate. For convenience images that do not
// fit totally on the screen are cropped to the nearest MCU size and may leave right/bottom borders.
void jpegRender(int xpos, int ypos) {
//jpegInfo(); // Print information from the JPEG file (could comment this line out)
// Jpeg images are draw as a set of image block (tiles) called Minimum Coding Units (MCUs)
// Typically these MCUs are 16x16 pixel blocks
// Determine the width and height of the right and bottom edge image blocks
uint32_t min_w = jpg_min(mcu_w, max_x % mcu_w);
uint32_t min_h = jpg_min(mcu_h, max_y % mcu_h);
// save the current image block size
uint32_t win_w = mcu_w;
uint32_t win_h = mcu_h;
// record the current time so we can measure how long it takes to draw an image
uint32_t drawTime = millis();
// save the coordinate of the right and bottom edges to assist image cropping
// to the screen size
max_x += xpos;
max_y += ypos;
// Fetch data from the file, decode and display
while (JpegDec.read()) { // While there is more data in the file
pImg = JpegDec.pImage ; // Decode a MCU (Minimum Coding Unit, typically a 8x8 or 16x16 pixel block)
// Calculate coordinates of top left corner of current MCU
int mcu_x = JpegDec.MCUx * mcu_w + xpos;
int mcu_y = JpegDec.MCUy * mcu_h + ypos;
// check if the image block size needs to be changed for the right edge
if (mcu_x + mcu_w <= max_x) win_w = mcu_w;
else win_w = min_w;
// check if the image block size needs to be changed for the bottom edge
if (mcu_y + mcu_h <= max_y) win_h = mcu_h;
else win_h = min_h;
// copy pixels into a contiguous block
if (win_w != mcu_w)
{
uint16_t *cImg;
int p = 0;
cImg = pImg + win_w;
for (int h = 1; h < win_h; h++)
{
p += mcu_w;
for (int w = 0; w < win_w; w++)
{
*cImg = *(pImg + w + p);
cImg++;
}
}
}
// calculate how many pixels must be drawn
uint32_t mcu_pixels = win_w * win_h;
// draw image MCU block only if it will fit on the screen
if (( mcu_x + win_w ) <= tft.width() && ( mcu_y + win_h ) <= tft.height())
tft.pushImage(mcu_x, mcu_y, win_w, win_h, pImg);
else if ( (mcu_y + win_h) >= tft.height())
JpegDec.abort(); // Image has run off bottom of screen so abort decoding
}
tft.setSwapBytes(swapBytes);
showTime(millis() - drawTime); // These lines are for sketch testing only
}
//####################################################################################################
// Print image information to the serial port (optional)
//####################################################################################################
// JpegDec.decodeFile(...) or JpegDec.decodeArray(...) must be called before this info is available!
void jpegInfo() {
// Print information extracted from the JPEG file
Serial.println("JPEG image info");
Serial.println("===============");
Serial.print("Width :");
Serial.println(JpegDec.width);
Serial.print("Height :");
Serial.println(JpegDec.height);
Serial.print("Components :");
Serial.println(JpegDec.comps);
Serial.print("MCU / row :");
Serial.println(JpegDec.MCUSPerRow);
Serial.print("MCU / col :");
Serial.println(JpegDec.MCUSPerCol);
Serial.print("Scan type :");
Serial.println(JpegDec.scanType);
Serial.print("MCU width :");
Serial.println(JpegDec.MCUWidth);
Serial.print("MCU height :");
Serial.println(JpegDec.MCUHeight);
Serial.println("===============");
Serial.println("");
}
//####################################################################################################
// Show the execution time (optional)
//####################################################################################################
// WARNING: for UNO/AVR legacy reasons printing text to the screen with the Mega might not work for
// sketch sizes greater than ~70KBytes because 16-bit address pointers are used in some libraries.
// The Due will work fine with the HX8357_Due library.
void showTime(uint32_t msTime) {
//tft.setCursor(0, 0);
//tft.setTextFont(1);
//tft.setTextSize(2);
//tft.setTextColor(TFT_WHITE, TFT_BLACK);
//tft.print(F(" JPEG drawn in "));
//tft.print(msTime);
//tft.println(F(" ms "));
Serial.print(F(" JPEG drawn in "));
Serial.print(msTime);
Serial.println(F(" ms "));
}
Wow już się nie zatrzymuje leci cały czas w kółko jutro zrobię zdjęcia odpowiedni format i będzie lux dzięki wielkie oczywiscie jeszcze tam w kodzie nazwy tych zdjęć będzie trzeba chyba zmienic plików
Dodano po 29 [minuty]:
Mam problem wziołem zdjęcie jpg przyciołem 320x240 px zmieniłem nazwę na takie jakie było mouse480 wyrzuciłem z karty zdjęcie myszy i nie pokazuje tamte zdjęcia są a zamiast wczesniejszej myszy ekranik zmienia kolor i idzie dalej dlaczego jakie wymagania zdjęcia muszą być spełnione czasu mało do weekendu
Dodano po 5 [minuty]:
No te moje zdjęcia nie działają z jakiegoś powodu
Dodano po 6 [minuty]:
Plik -> Eksportuj jako -> JPG -> Zaawansowane opcje -> odznacz "Progresywny" uff znalazłem rozwiązanie problemu a już panikowałem trzeba odpowiednio wyeksportować jeszcze nie zamykam tematu dopiero jutro jak skończę
jeszcze tam w kodzie nazwy tych zdjęć będzie trzeba chyba zmienic
Jeśli wszystkie zdjęcia znajdują się w głównym katalogu karty SD, to stosując kod z przykładu, nie trzeba się troszczyć o nazwy plików. Wszystkie zdjęcia tego katalogu będą wyświetlane po kolei.
Wówczas można będzie zmieniać zdjęcia bez potrzeby zmiany kodu programu.
✨ Dyskusja dotyczy podłączenia ESP32 do wyświetlacza TFT 2.8" 240x320 SPI z kontrolerem ILI9341 i wyświetlania kilku zdjęć JPG po kolei z karty SD. Początkowo problemem była inicjalizacja SD oraz poprawne połączenie linii SPI, w tym MISO/MOSI i CS. Wskazano przykładowe projekty oraz biblioteki TFT_eSPI, TJpg_Decoder/JPEGDecoder i SD. Po uruchomieniu przykładowego kodu obrazy zaczęły się wyświetlać cyklicznie, a problem z zatrzymywaniem się na jednym pliku rozwiązano przez usunięcie pętli blokującej while(1) z loop(). Zwrócono też uwagę, że zdjęcia muszą być zapisane w odpowiednim formacie JPG bez kompresji progresywnej; po poprawnym eksporcie obrazy zaczęły działać. Ostatecznie podano sposób iterowania po wszystkich plikach w katalogu głównym karty SD i wyświetlania ich kolejno bez konieczności ręcznego podawania nazw plików. Wygenerowane przez model językowy.
