ESP32: Getting Started with Deta Base (Unlimited and Free Database for Developers)

Get started with Deta Base using the ESP32 board. Deta Base is a NoSQL database. It is unlimited, free, and easy to use. Additionally, it requires minimal setup. So, it’s perfect for your hobbyist projects and prototyping. You’ll learn how to perform create, read, update, delete and query operations in a Deta Base instance using an ESP32.

To interact with Deta base using the ESP32, we’ll use the detaBaseArduinoESP32 library. The present tutorial was based on the guides created by the library developer. You can find the guides on the following link:

• ESP32 Deta Base Guides by Kushagra Goel

Introducing Deta Base

The best way to describe Deta Base:

Deta Base is a fully-managed, fast, scalable and secure NoSQL database with a focus on end-user simplicity. It offers a UI through which you can easily see, query, update and delete records in the database.

https://docs.deta.sh/docs/base/about

And the best part is that Deta Base is free to use!

If you’re wondering where your data is saved and if it is secured, here’s the answer:

Your data is encrypted and stored safely on AWS. Encryption keys are managed by AWS; AWS manages Exabytes of the world’s most sensitive data.

https://docs.deta.sh/docs/base/about#is-my-data-secure

We recommend taking a look at the docs to get more familiar with Deta Base:

• Deta Base documentation

Deta Base is still in the beta version, so you may expect improvements in the future.

Creating a Deta Base Account

To get started, you need to create a Deta Base account. Go to deta.sh, and click on Join Deta to create a new account.

Enter a username, password, and email to create a new account.

Deta base will send you a verification email. Verify your account, and you should be redirected to your Deta dashboard. The following window pops up:

By default, it creates a new project called “default”. As mentioned, projects are accessed via ids and keys. When you click on the See My Key button, you’ll get your project id and key. Make sure you save it somewhere because you’ll need those later—the key will only be shown once.

When you’re done. Click Close.

The library we’ll use with the ESP32 automatically creates a Base (database table) instance for your project. So, you don’t need to manually create it on the Deta Base interface.

Installing the Deta Base Library for ESP32

To interact with Deta Base using the ESP32, we’ll use the detaBaseArduinoESP32 library. You can install the library in the Arduino IDE. Go to Sketch > Include Library > Manage Libraries. Search for detabasearduinoesp32 and install the library by Kushagra Goel.

Deta Base with ESP32: CRUD Operations

In this section, you’ll learn how to program your ESP32 to perform CRUD (create, read, update, delete) operations and queries on Deta Base. The library provides a simple example showing how to do that.

In the Arduino IDE, make sure you have an ESP32 board selected in Tools > Board. Then, go to File > Examples > detabaseAduinoESP32 and select the detaLibTest example.

The following code should load.

# Original Source: https://github.com/A223D/detaBaseArduinoESP32/blob/main/examples/detaLibTest/detaLibTest.ino

#include <detaBaseArduinoESP32.h>
#include <WiFiClientSecure.h>
#define LED 2

char* apiKey = "MY_KEY";
char* detaID = "MY_ID";
char* detaBaseName = "MY_BASE";

WiFiClientSecure client;
DetaBaseObject detaObj(client, detaID, detaBaseName, apiKey, true);


void setup() {
  Serial.begin(115200);
  Serial.println("Let's begin initialization");
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
  Serial.println("Reached before WiFi init");
  WiFi.begin("0xCAFE", "0xC0FFEE");
  Serial.println("Waiting to connect to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  digitalWrite(LED, HIGH);

}

// PUT "{\"items\":[{\"age\":4}]}"

//INSERT "{\"item\":{\"key\":\"cba\",\"age\":4}}"

//INSERT "{\"item\":{\"key\":\"abc\",\"age\":4}}"

//UPDATE "{\"increment\":{\"age\":1}}", key:abc

//UPDATE "{\"increment\":{\"age\":1}}", key:cba

//QUERY "{\"query\":[{\"age?lt\": 10}]}"

void loop() {
  printResult(detaObj.putObject("{\"items\":[{\"age\":4}]}"));
  Serial.println();
  printResult(detaObj.getObject("cba"));
  Serial.println();
  printResult(detaObj.deleteObject("abc"));
  Serial.println();
  printResult(detaObj.insertObject("{\"item\":{\"key\":\"cba\",\"age\":4}}"));
  Serial.println();
  printResult(detaObj.insertObject("{\"item\":{\"key\":\"abc\",\"age\":4}}"));
  Serial.println();
  printResult(detaObj.updateObject("{\"increment\":{\"age\":1}}", "abc"));
  Serial.println();
  printResult(detaObj.updateObject("{\"increment\":{\"age\":1}}", "bcs"));
  Serial.println();
  printResult(detaObj.query("{\"query\":[{\"age?lt\": 10}]}"));
  Serial.println();

  while (true);
}

View raw code

You need to insert your project API KEY and ID. You also need to inserte a name for the database—it can be whatever you want. I called it Test.

char* apiKey = "REPLACE_WITH_YOUR_PROJECT_API_KEY";
char* detaID = "REPLACE_WITH_YOUR_PROJECT_ID";
char* detaBaseName = "Test";

In the setup(), you need to include your network credentials, SSID and password so that your ESP32 can connect to the internet.

WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

You can upload the code now and it will work straight away. We recommend reading through the following section to understand how things actually work.

How it Works

Read this section to learn how to interact with Deta Base using the ESP32.

Include Libraries

First, include the detaBaseArduinoESP32 library. You also need to include the WiFiClientSecure library—this automatically includes the WiFi.h library, also needed in this example.

#include <detaBaseArduinoESP32.h>
#include <WiFiClientSecure.h>

Deta Base Key, ID, and Name

Insert the project key, ID, and a name for the Base. As mentioned previously, if not created yet, the library will automatically create a Base instance for you on Deta Base. The name for the database can be whatever best describes it. In this case, I called it Test. If you’ve already created a Base instance manually on Deta Base, you can use it’s name here.

char* apiKey = "REPLACE_WITH_YOUR_PROJECT_API_KEY";
char* detaID = "REPLACE_WITH_YOUR_PROJECT_ID";
char* detaBaseName = "Test";

Creating a DetaBaseObject

Then, you need to create a WiFiClientSecure and a DetaBaseObject objects. The DetaBaseObject accepts as arguments the WiFi client, the project ID, base name, API key, lastly a boolean variable. This last boolean variable when set to true enables debugging statement.

WiFiClientSecure client;
//choose this:
DetaBaseObject detaObj(client, detaID, detaBaseName, apiKey, true);
//or this:
//DetaBaseObject detaObj(client, detaID, detaBaseName, apiKey);

The client is passed to the DetaBaseObject as is, without any modification. This is done because a root CA certificate is set in the DetaBaseObject constructor. This is required since we are making requests over HTTPS.

setup()

In the setup(), connect the ESP32 to Wi-Fi using your Wi-Fi credentials: SSID and password.

void setup() {
  Serial.begin(115200);
  Serial.println("Let's begin initialization");
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
  Serial.println("Reached before WiFi init");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.println("Waiting to connect to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  digitalWrite(LED, HIGH);
}

Insert

To insert items into the database, you can use the putObject() function. As described in the Deta Base documentation, a put operation expects a JSON object in the following format:

{
  // array of items to put
  "items": [
    {
      "key": {key}, // optional, a random key is generated if not provided
      "field1": "value1",
      // rest of item
    },
    // rest of items
  ]
}

The key is optional, and will be assigned by Deta Base if not provided. If a key is provided, and an entry already exists with that key, it is overwritten.

The following line of code:

printResult(detaObj.putObject("{\"items\":[{\"age\":4}]}"));

That contains the following JSON:

{
  "items":[
    {
      "age":"4"
    }
  ]
}

Adds the following to the database:

{
  "age": 4
}

A backslash character (\) is added before each “ to indicate an escape character, since we require “ in the JSON input.

Note: Keys have to be strings. If you want to use a number as a key, make sure it is interpreted as a string by enclosing it in double-quotes. (Double quotes with back-slashes.)

With PUT you can insert multiple items in a single request. For example:

printResult(detaObj.putObject("{\"items\":[{\"age\":4,\"weight\":28}]}"));

If the request succeeds, we will see a 200-level status code in the Serial monitor, as well as the entire object(s) with its key(s).

If you go to your Deta Base project, you should see a new base instance and the item we’ve just inserted.

Retrieve an Object

You can retrieve an object by its key using the getObject() function. The function expects a key as argument. It can be an existing key or a non-existing key.

The following line of code tries to retrieve an object with cba key.

printResult(detaObj.getObject("cba"));

You should get an error message because there isn’t any object with that key on the database yet.

However, if you manually create an object with the cba key and run the code again, it will retrieve the object with success.

To create an object manually, you can click on the +Add button on the deta base interface. It will automatically create a new item with a predefined key. You can change it to cba.

Delete

To delete an object on the database, use the deleteObject() function. This function accepts as an argument the key of the object we want to delete. The output of this function returns a 200-level code that indicates success even though there’s no object with that key. In our case, it tries to delete an object with the abc key.

printResult(detaObj.deleteObject("abc"));

However, if there was an object with the abc key it would be deleted.

Insert

To insert a new item in the database, you can use the insertObject() function that will make a POST request. This will create a new item only if no item with the same key exists. It expects a JSON in the following format:

{
  "item": {
    "key": {key}, // optional
    // rest of item
  }
}

If you don’t provide a key, Deta Base will automatically do that for you.

In the example, the following line:

printResult(detaObj.insertObject("{\"item\":{\"key\":\"cba\",\"age\":4}}"));

Adds the following object to the database:

{
  "key": "cba",
  "age": 4
}

If you’re already have an object with that key you’ll get a 400-level code and an error in the payload message.

Update

The updateObject() method updates existing entries. It accepts as arguments the key for an existing objkect and a JSON object in the following format:

{
  "set"  :  {
    //set some attribute to some value like
    //age: 10
  },
  "increment"  :{
    //increment some attribute by some value like
    //age: 1
  },
  "append":  {
    //append some value to some list attribute like
    //names: ["John"]
  },
  "prepend": {
    //append some value to some list attribute like
    //names: ["Sam"]
  },
  "delete":  [//attributes to be deleted]
}

All of those JSON sub-objects (set, increment, append, prepend, and delete) are optional.

You can learn more about this type of request on the documentation.

In our example, the following line will increment the age by 1 in the entry with the abc key.

 printResult(detaObj.updateObject("{\"increment\":{\"age\":1}}", "abc"));

Query Data

Deta Base also supports queries for fetching data that match certain conditions. You can learn more about Deta Base Queries on the following link:

• Deta Base Queries Documentation

To make a query you can use the query() function that accepts as argument the query itself in JSON format (see the link to the documentation above).

The following query will return all the objects whose value of age is less than 10, which in our case corresponds to all objects in the database.

printResult(detaObj.query("{\"query\":[{\"age?lt\": 10}]}"));

Demonstration

After running the example, you should get the following on the Serial Monitor.

And your database should look as follows.

Wrapping Up

In this tutorial, you learned how to interact with Deta Base using the ESP32. Deta Base is a NoSQL database, it’s free and unlimited. This means you won’t have to pay anything to use it, and you can add as many entries as needed. The database requires minimal setup and you can use it right away. Thanks to the detaBaseArduinoESP32 library, it’s even easier to make HTTP requests to the database and handle the responses.

In this example, you learned how to insert sample values. You can easily modify the examples to save sensor readings, for example, or GPIO states.

The present tutorial was based on the tutorial created by Kushagra Goel.

We hope you found this article useful.

We have guides for other popular databases with the ESP32:

• ESP32: Getting Started with Firebase (Realtime Database)
• ESP32: Getting Started with InfluxDB (Time Series Database)
• ESP32/ESP8266 Insert Data into MySQL Database using PHP and Arduino IDE

Learn more about the ESP32 with our resources:

• Learn ESP32 with Arduino IDE
• Build Web Servers with ESP32 and ESP8266
• Firebase Web App with ESP32 and ESP8266
• Free ESP32 Projects and Tutorials

Thanks for reading.