Navigation

    LILYGO

    • Register
    • Login
    • Categories
    • Recent
    • Tags
    • Popular
    • Users
    • Groups

    AMOLED S3 T-Display Touch - Problem with reading SD Card

    Technical Discussion
    2
    3
    236
    Loading More Posts
    • Oldest to Newest
    • Newest to Oldest
    • Most Votes
    Reply
    • Reply as topic
    Log in to reply
    This topic has been deleted. Only users with topic management privileges can see it.
    • R
      rs77can last edited by

      I need to have the WiFi, the AMOLED display, as well as the SD card all working simultaneously.

      I am using Arduino IDE

      The examples for the SD card interface do not work, and generate an error that the SD card cannot be mounted.

      I tried

      https://community.lilygo.cc/topic/154/t-display-s3-touch-version-trouble-to-connect-sd-card-reader-spi

      Anyone have a working example

      teastain2 R 2 Replies Last reply Reply Quote 0
      • teastain2
        teastain2 @rs77can last edited by

        @rs77can Maybe this will help:

        https://github.com/Xinyuan-LilyGO/T-Display-S3-AMOLED/issues/24

        1 Reply Last reply Reply Quote 0
        • R
          rs77can @rs77can last edited by

          @rs77can That did not work either - cant mount card

          I tried this

          https://github.com/espressif/arduino-esp32/blob/master/libraries/FFat/examples/FFat_Test/FFat_Test.ino

          This worked - just make sure not to reformat the drive each time.

          #include "FS.h"
          #include "FFat.h"
          
          // This file should be compiled with 'Partition Scheme' (in Tools menu)
          // set to 'Default with ffat' if you have a 4MB ESP32 dev module or
          // set to '16M Fat' if you have a 16MB ESP32 dev module.
          
          // You only need to format FFat the first time you run a test
          #define FORMAT_FFAT true
          
          void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {
            Serial.printf("Listing directory: %s\r\n", dirname);
          
            File root = fs.open(dirname);
            if (!root) {
              Serial.println("- failed to open directory");
              return;
            }
            if (!root.isDirectory()) {
              Serial.println(" - not a directory");
              return;
            }
          
            File file = root.openNextFile();
            while (file) {
              if (file.isDirectory()) {
                Serial.print("  DIR : ");
                Serial.println(file.name());
                if (levels) {
                  listDir(fs, file.path(), levels - 1);
                }
              } else {
                Serial.print("  FILE: ");
                Serial.print(file.name());
                Serial.print("\tSIZE: ");
                Serial.println(file.size());
              }
              file = root.openNextFile();
            }
          }
          
          void readFile(fs::FS &fs, const char *path) {
            Serial.printf("Reading file: %s\r\n", path);
          
            File file = fs.open(path);
            if (!file || file.isDirectory()) {
              Serial.println("- failed to open file for reading");
              return;
            }
          
            Serial.println("- read from file:");
            while (file.available()) {
              Serial.write(file.read());
            }
            file.close();
          }
          
          void writeFile(fs::FS &fs, const char *path, const char *message) {
            Serial.printf("Writing file: %s\r\n", path);
          
            File file = fs.open(path, FILE_WRITE);
            if (!file) {
              Serial.println("- failed to open file for writing");
              return;
            }
            if (file.print(message)) {
              Serial.println("- file written");
            } else {
              Serial.println("- write failed");
            }
            file.close();
          }
          
          void appendFile(fs::FS &fs, const char *path, const char *message) {
            Serial.printf("Appending to file: %s\r\n", path);
          
            File file = fs.open(path, FILE_APPEND);
            if (!file) {
              Serial.println("- failed to open file for appending");
              return;
            }
            if (file.print(message)) {
              Serial.println("- message appended");
            } else {
              Serial.println("- append failed");
            }
            file.close();
          }
          
          void renameFile(fs::FS &fs, const char *path1, const char *path2) {
            Serial.printf("Renaming file %s to %s\r\n", path1, path2);
            if (fs.rename(path1, path2)) {
              Serial.println("- file renamed");
            } else {
              Serial.println("- rename failed");
            }
          }
          
          void deleteFile(fs::FS &fs, const char *path) {
            Serial.printf("Deleting file: %s\r\n", path);
            if (fs.remove(path)) {
              Serial.println("- file deleted");
            } else {
              Serial.println("- delete failed");
            }
          }
          
          void testFileIO(fs::FS &fs, const char *path) {
            Serial.printf("Testing file I/O with %s\r\n", path);
          
            static uint8_t buf[512];
            size_t len = 0;
            File file = fs.open(path, FILE_WRITE);
            if (!file) {
              Serial.println("- failed to open file for writing");
              return;
            }
          
            size_t i;
            Serial.print("- writing");
            uint32_t start = millis();
            for (i = 0; i < 2048; i++) {
              if ((i & 0x001F) == 0x001F) {
                Serial.print(".");
              }
              file.write(buf, 512);
            }
            Serial.println("");
            uint32_t end = millis() - start;
            Serial.printf(" - %u bytes written in %lu ms\r\n", 2048 * 512, end);
            file.close();
          
            file = fs.open(path);
            start = millis();
            end = start;
            i = 0;
            if (file && !file.isDirectory()) {
              len = file.size();
              size_t flen = len;
              start = millis();
              Serial.print("- reading");
              while (len) {
                size_t toRead = len;
                if (toRead > 512) {
                  toRead = 512;
                }
                file.read(buf, toRead);
                if ((i++ & 0x001F) == 0x001F) {
                  Serial.print(".");
                }
                len -= toRead;
              }
              Serial.println("");
              end = millis() - start;
              Serial.printf("- %u bytes read in %lu ms\r\n", flen, end);
              file.close();
            } else {
              Serial.println("- failed to open file for reading");
            }
          }
          
          void setup() {
            Serial.begin(115200);
            Serial.setDebugOutput(true);
            if (FORMAT_FFAT) {
              FFat.format();
            }
            if (!FFat.begin()) {
              Serial.println("FFat Mount Failed");
              return;
            }
          
            Serial.printf("Total space: %10u\n", FFat.totalBytes());
            Serial.printf("Free space: %10u\n", FFat.freeBytes());
            listDir(FFat, "/", 0);
            writeFile(FFat, "/hello.txt", "Hello ");
            appendFile(FFat, "/hello.txt", "World!\r\n");
            readFile(FFat, "/hello.txt");
            renameFile(FFat, "/hello.txt", "/foo.txt");
            readFile(FFat, "/foo.txt");
            deleteFile(FFat, "/foo.txt");
            testFileIO(FFat, "/test.txt");
            Serial.printf("Free space: %10u\n", FFat.freeBytes());
            deleteFile(FFat, "/test.txt");
            Serial.println("Test complete");
          }
          
          void loop() {}
          
          1 Reply Last reply Reply Quote 1
          • First post
            Last post
          Powered by NodeBB | Contributors