Guten Abend,
ich habe meine Pro Mini doch nicht aus dem Fenster geworfen, vielmehr hatte ich heute Abend mein erstes Erfolgserlebnis mit dem SD Card Modul am Pro Mini.
Ablauf wie folgt:
- ich hatte ein Modul mit dem zu Beginn empfohlenen Hardware Hack gesteckt - leider erfolglos.
- dann "live" (unter Spannung) das Modul getauscht - jetzt wurde das Modul erkannt und Bilder am Display ausgegeben.
- ich habe dies mit einem weiteren SD-Modul ausprobiert. Unter Spannung tauschen, Reset drücken und es läuft!
Meine Frage nun: wenn es so funktioniert, wie kann ich dies im Sketch nachbilden?
Anbei nochmals mein Sketch.
Liebe Grüße
Peter
#include <Adafruit_GFX.h> // Core graphics library
#include <Adafruit_ST7735.h> // Hardware-specific library for ST7735
#include <SPI.h>
#include <SD.h>
#define CS_MASTER 10 // SPI Master
#define SD_CS 4 // Chip select line for SD card
#define TFT_CS 9 // Chip select line for TFT display
#define TFT_DC 8 // Data/command line for TFT
#define TFT_RST 7 // Reset line for TFT (or see below...)
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
void setup(void) {
Serial.begin(9600);
while (!Serial) {
delay(10); // wait for serial console
}
pinMode(CS_MASTER, OUTPUT);
digitalWrite(CS_MASTER, HIGH);
pinMode(TFT_CS, OUTPUT);
digitalWrite(TFT_CS, HIGH);
pinMode(SD_CS, OUTPUT);
digitalWrite(SD_CS, HIGH);
// Use this initializer (uncomment) if you're using a 0.96" 180x60 TFT
tft.initR(INITR_MINI160x80); // initialize a ST7735S chip, mini display
Serial.print("Initializing SD card...");
if (!SD.begin(SD_CS)) {
Serial.println("failed!");
return;
}
Serial.println("OK!");
File root = SD.open("/");
printDirectory(root, 0);
root.close();
}
void loop() {
tft.fillScreen(ST7735_BLACK);
delay(2000); // 2 Sekunden warten
// Fontgroesse setzen
// setTextSize(groesse);
tft.setTextSize(2);
// Schrift umbrechen?
// setTextWrap(true); true=Ja, false=Nein
tft.setTextWrap(true);
// Textposition setzen
// setCursor(x,y);
tft.setCursor(24,4);
// Textfarbe setzen
// setTextColor(farbe);
tft.setTextColor(ST7735_WHITE);
// Text ausgeben
// print(text);
tft.print("Hallo !");
delay(2000);
tft.setRotation(1);
/* tft.fillScreen(ST7735_BLACK); // Clear display
// for(uint8_t i=0; i<4; i++) // Draw 4 parrots
// bmpDraw("bmp1.bmp", tft.width() / 4 * i, tft.height() / 4 * i);
// tft.setRotation(tft.getRotation() + 1); // Inc rotation 90 degrees
// Bildausgabe */
/* bmpDraw("bmp1.bmp", 0, 0);
delay(5000);
tft.fillScreen(ST7735_BLACK); // Clear display
delay (200);
bmpDraw("bmp2.bmp", 0, 0);
delay(5000); */
tft.fillScreen(ST7735_BLACK); // Clear display
delay (700);
bmpDraw("CON1.BMP", 0, 0);
delay(5000);
//
tft.fillScreen(ST7735_BLACK); // Clear display
delay (700);
bmpDraw("con2.bmp", 0, 0);
delay(5000);
//
tft.fillScreen(ST7735_BLACK); // Clear display
delay (700);
}
// #define BUFFPIXEL 20 Originl
#define BUFFPIXEL 30 // Test
void bmpDraw(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)); original
tft.pushColor(tft.color565(b,g,r)); // corrected
} // 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();
}
}
