Skip to main content

MicroSD basics

The built-in microSD card slot on Inkplate 6FLICK can be of great use for your project. It can store a very large number of high-quality image files to be displayed, and it can also read and write data during deep sleep cycles. This page contains basic examples that will help you quickly get started with using the built-in microSD card slot.

MicroSD card slot on Inkplate 6FLICK
MicroSD card slot on Inkplate 6FLICK
ℹ️
Inkplate 6FLICK uses the SdFat library
⚠️
All supported card formats are: FAT16, FAT32, exFAT
⚠️
All supported card types are: SD, SDHC and SDXC

Preparing the microSD card before usage​

For best results, use the official SD card formatter to format the card to FAT32 before usage.

Official SD card formatter
The official SD Card formatter

Initializing​

Before the microSD card can be used in code, it must first be initialized. This powers on the microSD card circuitry and performs all the necessary memory allocations. In this code snippet, the microSD card is initialized and the result of the initialization is checked:

#include "Inkplate.h"            //Include Inkplate library to the sketch
#include "SdFat.h"               //Include library for SD card
Inkplate inkplate(INKPLATE_1BIT); // Create an object on Inkplate library and also set library into 1 Bit mode (BW)
SdFile file;                     // Create SdFile object used for accessing files on SD card

void setup()
{
    inkplate.begin();        // Init Inkplate library (you should call this function ONLY ONCE)
    inkplate.clearDisplay(); // Clear frame buffer of display
    inkplate.display();      // Put clear image on display
    inkplate.setTextSize(5);

    // Init SD card. Display if SD card is init properly or not.
    if (inkplate.sdCardInit())
    {
        inkplate.println("SD Card ok! Reading data...");
        inkplate.partialUpdate();
    }
    else
    { // If card init was not successful, display error on screen, put sd card in sleep mode, and stop the program (using infinite loop)
        inkplate.println("SD Card error!");        
        inkplate.partialUpdate();
        inkplate.sdCardSleep();
        while (true)
            ;
    }
}
void loop()
{
    // Nothing...
}

Initializes sd card trough SPI.

Returns value: Returns true if the initialization was successful, otherwise returns false.

Reading and writing​

Place a sample text.txt file on the microSD card and write something in it. This code snippet will read it and print it to the e-Paper:

/*
   Inkplate6FLICK_SD_TXT_Read example for Soldered Inkplate 6FLICK
   For this example you will need only a micro USB cable, Inkplate 6FLICK and a SD card
   loaded with text.txt file that can be found inside folder of this example.
   Select "Soldered Inkplate 6FLICK" from Tools -> Board menu.
   Don't have "Inkplate 6FLICK(ESP32)" option? Follow our tutorial and add it:
   https://soldered.com/learn/add-inkplate-6-board-definition-to-arduino-ide/

   To work with SD card on Inkplate, you will need to add one extra library.
   Download and install it from here: https://github.com/e-radionicacom/Inkplate-6-SDFat-Arduino-Library

   You can open your own .txt file, but in order for this example to work properly it should
   not have more than 200 chars and you should name it text.txt

   This example will show you how to open .txt files and display the content of that file on the Inkplate epaper display.

   Want to learn more about Inkplate? Visit www.inkplate.io
   Looking to get support? Write on our forums: https://forum.soldered.com/
   15 March 2024 by Soldered
*/

// Next 3 lines are a precaution, you can ignore those, and the example would also work without them
#ifndef ARDUINO_INKPLATE6FLICK
#error "Wrong board selection for this example, please select Soldered Inkplate 6FLICK"
#endif

#include "Inkplate.h"            //Include Inkplate library to the sketch
#include "SdFat.h"               //Include library for SD card
Inkplate display(INKPLATE_1BIT); // Create an object on Inkplate library and also set library into 1 Bit mode (BW)
SdFile file;                     // Create SdFile object used for accessing files on SD card

void setup()
{
    display.begin();        // Init Inkplate library (you should call this function ONLY ONCE)
    display.clearDisplay(); // Clear frame buffer of display
    display.display();      // Put clear image on display
    display.setRotation(1);
    display.setFrontlight(15);
    // Init SD card. Display if SD card is init properly or not.
    if (display.sdCardInit())
    {
        display.println("SD Card ok! Reading data...");
        display.partialUpdate();

        // Try to load text with max length of 200 chars.
        if (!file.open("/text.txt", O_RDONLY))
        { // If it fails to open, send error message to display, otherwise read the file.
            display.println("File open error");
            display.display();
        }
        else
        {
            display.clearDisplay();    // Clear everything that is stored in the frame buffer of the epaper
            display.setCursor(0, 0);   // Set print position at the beginning of the screen
            char text[3001];           // Array where data from SD card is stored (max 200 chars here)
            int len = file.fileSize(); // Read how big the file that we are opening is
            if (len > 3000)
                len = 3000;       // If it's more than 3000 bytes, limit to max 3000 bytes
            file.read(text, len); // Read data from the file and save it in the text array
            text[len] = 0;        // Put null terminating character at the end of the data
            display.setTextSize(2);
            display.print(text);   // Print data/text
            display.sdCardSleep(); // Put sd card in sleep mode
            display.display();     // Do a full refresh of the display
        }
    }
    else
    { // If card init was not successful, display error on screen, put sd card in sleep mode, and stop the program
      // (using infinite loop)
        display.println("SD Card error!");
        display.partialUpdate();
        display.sdCardSleep();
        while (true)
            ;
    }
}

void loop()
{
    // Nothing...
}

file.open()

Open a file in the current working directory.

Returns value: Returns true if opening is successful, otherwise returns false.

Function parameters:

TypeNameDescription
const char *pathThe path to the file which is being opened, if it's in the root folder just write the filename.
oflag_toflagThe settings for opening the file. The different flags have to be OR'd, eg. O_CREAT | O_RDWR. Below is a table of these flags and what they mean.
FlagHex ValueDescription
O_RDONLY0x00Open for reading only.
O_WRONLY0x01Open for writing only.
O_RDWR0x02Open for reading and writing.
O_AT_END0x04Open at the end-of-file (EOF).
O_APPEND0x08Set append mode (writes are added to EOF).
O_CREAT0x10Create file if it does not exist.
O_TRUNC0x20Truncate file to zero length.
O_EXCL0x40Fail if the file already exists.
O_SYNC0x80Synchronized write I/O operations.

file.fileSize()

Returns the total number of bytes in a file.

Returns type: uint32_t

file.read()

Reads data from the file into the provided buffer. The function attempts to read up to a given number of bytes starting from the current file pointer.

Returns value: Returns the number of bytes read, or -1 if an error occurs.

Function parameters:

TypeNameDescription
void *bufA pointer to the buffer where the read file data will be stored.
size_tcountThe maximum number of bytes to read from the file.
ℹ️
In the above mentioned functions, the file pointer is like a marker where you continue reading the file from, so subsequent calls to file.print() and file.print() will continue from where you left off.
ℹ️
Using this method, it's possible to write to a .csv file, making it easy to store a table or log of events!

Inkplate6FLICK_SD_TXT_Read.ino

This example will show you how to open .txt files and display the content of that file on Inkplate epaper display.

Inkplate6FLICK_SD_TXT_Write.ino

This example will show you how to write to a .txt file.