LittleFS with ESP8266 to Read, Write and Delete Data on 16X2 LCD Display (2023)

In our previous tutorial we learned how to install a file system (LittleFS) uploader plugin in Arduino IDE to upload files to ESP8266 NodeMCU. In this section, we will discuss the process of reading and writing data in LittleFS file systems.

This section also includes how to read, write, and delete data on Arduino IDE. By default, the Arduino IDE has no support for uploading files to the ESP 8266 Flash file system. But we can install a plugin to add the file uploading feature to the Arduino IDE.

Related post:

• ESP8266 NodeMCU LittleFS Filesystem in Arduino IDE
• ESP8266(NodeMCU)-BME280 Sensor on Web Server using SPIFFS
• ESP8266 SPIFFS (SPI Flash File System) with Arduino IDE
• ESP8266 save data permanently using Preferences library
• Using the EEPROM with the ESP8266 Microcontrollers (NodeMCU)
• Different Types of Memory on Microcontroller -RAM, EEPROM, Flash.

ESP8266 Filesystem Introduction

ESP8266 provides a file system on the same flash where the program is stored. A file system has been created by dividing the FLASH of ESP 8266 into Arduino sketch, OTA update, file system, EEPROM, and WiFi configuration areas. There are two filesystems available with ESP8266 to use Flash such as SPIFFS and LittleFS.

NOTE: SPIFFS is going to deprecate and ESP8266 Arduino code may be removed from future releases. Therefore, it is recommended to use LittleFS. Because it supports real directories and is several times faster than SPIFFS for most operations.

LittleFS Introduction

LittleFS has recently been added and focuses on high performance and directory support, but has high filesystem and per-file overhead (4K minimum vs. SPIFFS’s 256-byte minimum file allocation unit).

We can use LittleFS to store files in Flash without using any external memory with ESP8266 NodeMCU. LittleFS allows users to read and write files from the microcontroller’s flash memory.

Converting most applications from SPIFFS to LittleFS simply requires changing sPIFS.start() to LittleFS.start() and SPIFFS.open() to LittleFS.open(), the rest of the code remains untouched.

In short, you can port all your existing projects that have been developed using SPIFFS, only by replacing SPIFFS.h with LittleFS.h and SPIFFS methods with LittleFS.

I2C Module

In the module left side, we have 4 pins, and two are for power ( Vcc and GND ), and the other two are the interface I2C ( SDA and SCL ) . The plate pot is for display contrast adjustment, and the jumper on the opposite side allows the back light is controlled by the program or remain off for power saving.

Features:

Hitachi’s HD44780based 16×2-character LCD are very cheap and widely available. Using the LCD backpack module, desired data can be displayed on the LCD through the I2C bus. this is a general purpose bidirectional 8 bit I/O port expander that uses the I2C protocol. The PCF8574 is a silicon CMOS circuit provides general purpose remote I/O expansion (an 8-bit quasi-bidirectional) for most microcontroller families. This i2c module are centered around PCF8574T (SO16 package of PCF8574 in DIP16 package) with a default slave address of 0x27.

If your module holds a PCF8574AT chip, then the default slave address will change to 0x3F. In short, your backpack is based on PCF8574T and the address connections (A0-A1- A2) are not bridged with solder it will have the slave address 0x27.

In this section, we will discuss the process of reading and writing data in LittleFS file systems. This will give you a basic idea of how the total system works.

Writing Data to the Flash Memory of NodeMCU (Writing data to LittleFS):

It is very easy to write data in LittleFS file system, we have our very simple code for writing data in LittleFS file system, which we will discuss later. The code is written in such a way that it allows the user to type data on a serial monitor so that the data can be easily stored.

void writeData(String data)
{
//Open the file
File file = LittleFS.open("/SavedFile.txt", "w");
//Write to the file
file.print(data);
delay(1);
//Close the file
file.close();
Serial.println("Write successful");
lcd.clear();
lcd.print("Data Saved :");
// set cursor to first column, second row
lcd.setCursor(0,1);
// print the data on the LCD
lcd.print(data);
// reset cursor position
lcd.setCursor(0,0);
}

After writing the desired data, we need to press ‘enter’ (Make sure that the Baud rate = 115200 and no line ending is selected). Whatever is typed is taken as the data and it is saved to LittleFS file system.

Save Data to the Flash Memory of the NodeMCU (Write to LittleFs);

The LittleFs file system is mounted on Flash memory of ESP8266. Other than writing in the LittleFs file system, two other tasks can be done. Those are reading and deleting. To do that, the code is written in such a way that it takes input from the user and does the function that the user requests.

When the user enters “D” the file is deleted. And “R” to read the file. (NOTE: it is case sensitive. And any error like “DD” or ”RR” instead of “D”&”R” will be considered as input data and this will be overwritten on the existing data)

Reading Data from the Flash Memory of the NodeMCU (Read From LittleFs):

When attempting to read the data without writing anything first, the display shows the message saying “No saved data” Reading data from NodeMCU’s flash memory is not complicated at all.

The “readData()” function is used to read the data and “lcd.write(file.read());” function is used to print the data on the LCD display. Serial.println(“No Saved Data!”); use for serial monitor on Arduino IDE.

void readData()
{
File file = LittleFS.open("/SavedFile.txt", "r");
if(!file)
{
Serial.println("No Saved Data!");
lcd.clear();
lcd.print("No Saved Data!"); return;
}
lcd.clear();
lcd.print("Saved Data :");
lcd.setCursor(0,1);
while(file.available())
{
lcd.write(file.read());
}lcd.setCursor(0,0);
file.close();
}

Delete Data from Flash Memory of NodeMCU (Delete from LittleFS):

To delete data from LittleFS, a simple function called “LittleFS.remove();” is used. This function deletes the contents of the file whose path should be given by the user.

void deleteData()
{
//Remove the file
LittleFS.remove("/SavedFile.txt");
lcd.clear();
//update the display
lcd.print("Data Deleted");
}

Components Required:

• 16×2 LCD I2C module Display
• ESP8266 NodeMCU board
• Breadboard
• Jumper wires (Male to Female)

Connections:

The complete schematic diagram forthe ESP8266, I2C LCD and NodeMCU based LittleFStest Circuit is shown below.

Library Installation:

We should also install an ESP8266 NodeMCU add-on in the Arduino IDE before starting. You can check this tutorial: How to Install ESP8266 in Arduino IDE .

The libraries required to download the link are given below.

• Arduino-LiquidCrystal-I2C-libraryfrom GitHub
• LittleFS libraryfrom GitHub

Testing the 16X2 I2C LCD with Arduino:

For For simplicity first we check only the working of the I2C display with little FS. the simple code to check LCD display wIth NodeMCU. if everything is working fine, you will get a hello world message in the display.

#include <LiquidCrystal_I2C.h>#include <Wire.h>int lcdColumns = 16;int lcdRows = 2;LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows);void setup(){ lcd.init(); lcd.backlight();}void loop() { lcd.setCursor(0, 0); lcd.print("Hello World!");delay(1000); lcd.clear(); lcd.setCursor(0,1); lcd.print("Hello World!"); delay(1000); lcd.clear();}

Arduino Sketch:

#include <LiquidCrystal_I2C.h>#include <Wire.h>#include "LittleFS.h"// set the LCD number of columns and rowsint lcdColumns = 16;int lcdRows = 2;// set LCD address, number of columns and rowsLiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows); //function prototypesvoid readData();void writeData(String data);void deleteData();void setup() { //Start the serial monitor Serial.begin(115200); // initialize LCD lcd.init(); // turn on LCD backlight lcd.backlight(); // set cursor to first column, first row lcd.setCursor(0, 0); lcd.print("Little FS Demo"); delay(1000); //Start LittleFS if(!LittleFS.begin()){ Serial.println("An Error has occurred while mounting LittleFS"); //Print the error on display lcd.clear(); lcd.print("Mounting Error"); delay(1000); return; } //Read the saved data readData(); }void loop() { //Take input from user on serial monitor if(Serial.available()) { String data = Serial.readString(); Serial.println(data); if(data == "D") // To delete the file { deleteData(); Serial.println("File deleted!"); return; } else if(data == "R") // To read the file { readData(); return; } Serial.println("Writing Data..."); writeData(data); Serial.println("done Writing Data!"); }}void readData(){ //Open the file File file = LittleFS.open("/SavedFile.txt", "r"); //Check if the file exists if(!file){ //Read the file data and display it on LCD Serial.println("No Saved Data!"); lcd.clear(); lcd.print("No Saved Data!"); return; } lcd.clear(); lcd.print("Saved Data :"); // set cursor to first column, second row lcd.setCursor(0,1); //Display on the LCD while(file.available()){ lcd.write(file.read()); } //reset cursor poisition lcd.setCursor(0,0); //Close the file file.close();}void writeData(String data){ //Open the file File file = LittleFS.open("/SavedFile.txt", "w"); //Write to the file file.print(data); //Close the file file.close(); delay(1); Serial.println("Write successful"); lcd.clear(); lcd.print("Data Saved :"); // set cursor to first column, second row lcd.setCursor(0,1); // print the data on the LCD lcd.print(data); // reset cursor position lcd.setCursor(0,0);}void deleteData(){ //Remove the file LittleFS.remove("/SavedFile.txt"); lcd.clear(); lcd.print("Data Deleted"); }

How the Code Works

These libraries are required to work with LCD display, I2C and LittleFs.

#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <LittleFS.h>
int lcdColumns = 16;
int lcdRows = 2;

To set the LCD number of columns and rows. In our case, 16×2 which means 16 columns and 2 rows.

Function is used to set the LCD address, number of columns and rows.

LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows);

To read the data to the flash memory use the custom function “readData()”. Similarly, “writeData” and “deleteData” are custom functions to write data and to delete data from LittleFs respectively.

void readData();
void writeData(String data);
void deleteData();

Start the serial monitor and set the baud rate to 115200.

Serial.begin(115200);

“lcd.init” function will initialise LCD and. backlight function will turn on LCD backlight

lcd.init();
lcd.backlight();

To set the cursor to the first column, first row and print the message “Little FS Demo” and wait for a second.

lcd.setCursor(0, 0);
lcd.print("Little FS Demo");
delay(1000);

To check whether the file has opened correctly, if it doesn’t open correctly, it will print an error message and end the function. Or it will print the data written whatever was written earlier. On the LCD display, “Mounting Error” message will be displayed.

if(!LittleFS.begin())
{
Serial.println("An Error has occurred while mounting LittleFS");
lcd.clear();
lcd.print("Mounting Error");
delay(1000);
return;
}

Here, this part of program is used because in case Little Fs fails to start then an error message should be display to notify the user that Little Fs failed to start.

When the Serial receives some data from the serial monitor the data is read using “serial.readString()” and stored in a string “data”. Then it’ll check to see what command the user has entered and perform delete / read / write based on it.

void loop()
{
if(Serial.available())
{
String data = Serial.readString();
Serial.println(data);
if(data == "D")
{
deleteData();
Serial.println("File deleted!");
return;
}
else if(data == "R")
{
readData();
Return;
}
Serial.println("Writing Data...");
writeData(data);
Serial.println("done Writing Data!");}
}

Result:

For the first time, since there is no data to display, the LCD screen will display the message “No data saved” After entering the data through the serial monitor, the data can be read by typing “R” or deleted by typing “D” in the serial monitor.

Reference:

• LCD Screen datasheethttps://www.arduino.cc/documents/datasheets/LCDscreen.PDF
• Arduino IDEhttps://www.arduino.cc/en/main/software
• Liquid CrystalLibrary https://github.com/arduino-libraries/LiquidCrystal
• PCF8574 IC datasheethttps://www.nxp.com/docs/en/data-sheet/PCF8574_PCF8574A.pdf
• Project Guide: https://circuitdigest.com/microcontroller-projects/littlefs-with-esp8266-to-read-write-and-delete-data-on-flash-memory-of-nodemcu