Created
January 7, 2021 15:33
-
-
Save shivasiddharth/bd6093839d0fd283c1d5ecc594eab032 to your computer and use it in GitHub Desktop.
Arduino Sketch for Digital Photo Frame Project
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/************************************************************************************** | |
Code for DIY Digitial Photoframe using Wemos D1 Mini and Adafruit 1.44" TFT Display | |
Written by Sid for Sid's E Classroom | |
https://www.youtube.com/c/SidsEClassroom | |
Arduino Libraries Used | |
1. ArduinoJson – 5.13.5 | |
2. Adafruit ST7735 and ST7739 Library – 1.6.0 | |
3. Adafruit GFX Library – 1.10.4 | |
4. TFT – 1.2.1 | |
**************************************************************************************/ | |
#include <Adafruit_GFX.h> // Core graphics library | |
#include <Adafruit_ST7735.h> // Hardware-specific library | |
#include <SPI.h> | |
#include <SD.h> | |
// Pin declarations for Wemos D1 Mini | |
#define TFT_CS D2 // Chip select line for TFT display | |
#define TFT_RST D4 // Reset line for TFT (or see below...) | |
#define TFT_DC D3 // Data/command line for TFT | |
#define SD_CS D1 // Chip select line for SD card | |
// Maximum number of images to play. Change 100 to your desired value below. | |
char *Files[100]; | |
int Filecounter = 0; | |
// Change the value below to change the slideshow interval | |
int slideshowinterval = 1000; | |
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST); | |
void setup(void) { | |
Serial.begin(115200); | |
pinMode(TFT_CS, OUTPUT); | |
digitalWrite(TFT_CS, HIGH); | |
pinMode(SD_CS, OUTPUT); | |
digitalWrite(SD_CS, HIGH); | |
while (!Serial) { | |
delay(10); // wait for serial console | |
} | |
tft.initR(INITR_144GREENTAB); | |
tft.fillScreen(ST77XX_BLUE); | |
Serial.print("Initializing SD card..."); | |
if (!SD.begin(SD_CS)) { | |
Serial.println("failed!"); | |
return; | |
} | |
File root = SD.open("/"); | |
printDirectory(root, 0); | |
Serial.println("OK!"); | |
tft.setRotation(2); // Enable to rotate images to Landscape | |
} | |
void loop() { | |
File root = SD.open("/"); // open SD card main root | |
while (true) { | |
File entry = root.openNextFile(); // open file | |
if (! entry) { | |
// no more files | |
root.close(); | |
return; | |
} | |
uint8_t nameSize = String(entry.name()).length(); // get file name size | |
String str1 = String(entry.name()).substring( nameSize - 4 ); // save the last 4 characters (file extension) | |
if ( str1.equalsIgnoreCase(".bmp") ) // if the file has '.bmp' extension | |
bmpDraw(entry.name(), 0, 0); // draw it | |
entry.close(); // close the file | |
delay(slideshowinterval); | |
} | |
} | |
// 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(const char *filename, uint8_t x, uint16_t 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 buffer (R+G+B 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(); | |
if ((x >= tft.width()) || (y >= tft.height())) return; | |
Serial.println(); | |
Serial.print(F("Loading image '")); | |
Serial.print(filename); | |
Serial.println('\''); | |
// Open requested file on SD card | |
if ((bmpFile = SD.open(filename)) == NULL) { | |
Serial.print(F("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.width()) w = tft.width() - x; | |
if ((y + h - 1) >= tft.height()) h = tft.height() - y; | |
// Set TFT address window to clipped image bounds | |
tft.startWrite(); | |
tft.setAddrWindow(x, y, w, h); | |
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; | |
if (bmpFile.position() != pos) { // Need seek? | |
tft.endWrite(); | |
bmpFile.seek(pos); | |
buffidx = sizeof(sdbuffer); // Force buffer reload | |
} | |
for (col = 0; col < w; col++) { // For each pixel... | |
// Time to read more pixel data? | |
if (buffidx >= sizeof(sdbuffer)) { // Indeed | |
bmpFile.read(sdbuffer, sizeof(sdbuffer)); | |
buffidx = 0; // Set index to beginning | |
tft.startWrite(); | |
} | |
// Convert pixel from BMP to TFT format, push to display | |
b = sdbuffer[buffidx++]; | |
g = sdbuffer[buffidx++]; | |
r = sdbuffer[buffidx++]; | |
tft.pushColor(tft.color565(r, g, b)); | |
} // end pixel | |
} // end scanline | |
tft.endWrite(); | |
Serial.print(F("Loaded in ")); | |
Serial.print(millis() - startTime); | |
Serial.println(" ms"); | |
} // end goodBmp | |
} | |
} | |
bmpFile.close(); | |
if (!goodBmp) Serial.println(F("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 printDirectory(File dir, int numTabs) { | |
while (true) { | |
File entry = dir.openNextFile(); | |
if (! entry) { | |
// no more files | |
break; | |
} | |
for (uint8_t i = 0; i < numTabs; i++) { | |
Serial.print('\t'); | |
} | |
Serial.print(entry.name()); | |
if (entry.isDirectory()) { | |
Serial.println("/"); | |
printDirectory(entry, numTabs + 1); | |
} else { | |
// files have sizes, directories do not | |
Serial.print("\t\t"); | |
Serial.println(entry.size(), DEC); | |
} | |
entry.close(); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment