ESP32 Data Logger with DHT22 & Google Sheets using ChatGPT

In this article, we're Creating an ESP32 Data Logger with DHT22 and Google Sheets Using ChatGPT Code Interpreter. We explain how to make a smart ESP32 Data Logger. This device will keep track of information using DHT22 and store it in Google Sheets. What makes it so curious is that we'll be getting some help from ChatGPT along the way. ChatGPT makes coding easier, so you don't have to be a programming expert to create this useful data logger. Explore the journey where we combine ESP32, DHT22, esp 32 Google Sheets, and the friendly assistance of ChatGPT to make a better arduino data to google sheets and smart data logging solution.

Introduction

Lots of money has been spent on making AI better through research. AI is always changing and getting better, doing things we didn't think were possible before. That's why the newest version of ChatGPT now has a new tool called the Code Interpreter. This new addition makes using ChatGPT for coding even more awesome. It helps users get more flexible and dynamic responses, making it easier to go from talking in regular language to making real programming solutions. It's like ChatGPT has learned a new trick to make arduino data to google sheets & coding smoother and more practical.

The recent update to ChatGPT introduces an enhanced Code Interpreter, making it even more versatile for coding tasks. Now, equipped with this innovative tool, users can expect a more dynamic and seamless experience in crafting practical programming solutions. So, let's explore by Creating an ESP32 google sheets Data Logger with DHT22 and esp 32 Google Sheets Using ChatGPT Code Interpreter, as we embark on this hands-on journey of creating a sophisticated yet accessible data logging solution.

Prompting ChatGPT to generate the ESP32 and AppScript code for us

Here, our action plan involves Prompting ChatGPT to generate the ESP32 and AppScript code for us. Prior to that, we'll click on the GPT-4 Model and opt for the Code Interpreter from the available choices.

Now, it's time to provide our request. We'll ask ChatGPT to generate an ESP32 code compatible with the Arduino IDE. This code should be designed to fetch temperature and humidity data from the DHT22 sensor and send it to esp 32 Google Sheets. Additionally, we'll request the Google App Script Code. We are looking for detailed instructions to accompany both sets of code.

The code interpreter provides the Google App Script code above, but upon inspection, it's evident that the sheet name and sheet ID are absent from the code.

I informed ChatGPT that I needed to include parameters for sheet_id and sheet_name in the App Script, specifying, "In the App Script, there should be an authentication parameter such as sheet name and sheet id." Consequently, it provided me with the following response.

Next, Proceeded to create the hardware circuit.

Developing the schematic based on the code instructions

If we were following a conventional approach, we would typically create the schematic first, followed by the hardware circuit, and then proceed with the code. However, for this particular project, we're taking a different route by assuming that ChatGPT has comprehensive knowledge. We'll trust its guidance and construct the hardware based on the code it provides.

In the schematic, the DHT22 is linked to the GPIO4 of the ESP32 google sheets. Upon completion of the hardware schematic, it would resemble the illustration provided above.

#include "DHT.h"
#define DHTPIN 4  // Define which pin the DHT22 is connected to 
#define DHTTYPE DHT22

This is the code snippet where ChatGPT instructs us to establish a connection between the DHT22 sensor and GPIO4 of the ESP32 module.

Deploying The Google App Script

The Google App Script is like the messenger in our project. It helps the ESP32 (our device) talk smoothly with Google Sheets. Think of it as a bridge that carries the temperature and humidity data from our ESP32 to the specific place we want in esp 32 Google Sheets.

• Create a new Google Sheet.
• Click on Extension > Apps Scripts.
• In the Apps Scripts editor, paste the following code:

Looking at the prompt I provided to ChatGPT earlier, it's evident that I clearly requested detailed instructions on deploying the code. However, as shown above, ChatGPT didn't quite meet expectations in this regard, marking a bit of a letdown. In light of this, I had to rely on my own research skills to uncover the proper steps for deploying the code. Let's explore what I discovered.

Navigate to the Extensions menu and select "Apps Script." This action will open a new window for Apps Script. Subsequently, paste the provided code into this window. Ensure not to overlook the inclusion of your Sheet ID and Sheet Name during this process.

Next, click on the Settings Icon and then proceed to select the "Web app" option.

After clicking on "Web app, " a new window will appear. In this window, provide a name for your app in the description. Crucially, ensure that you change the access settings to "Anyone." Once these steps are completed, click on the "Deploy" button.

Following this, you'll need to authorize your app using a Google account. If all steps are executed correctly, you'll receive a web app URL. However, in my case, it didn't work seamlessly on the initial attempt, leading me to implement the following steps to ensure its functionality.

If you encounter issues with the API, you can try the following steps. Navigate to "Deploy, " then choose "New Deployment." Now, select "API Executable" and click the "Deploy" button. Copy the provided API. In my case, this API worked seamlessly, and by simply clicking on it, I could observe the data being transferred to my Google Sheets effortlessly.

Code for Arduino Nano ESP32 and Google App Script

The entire code for Arduino Nano ESP32 and Google App Script is provided below. You can easily copy and paste it into your project, and it should function smoothly & transfer arduino data to google sheets without any errors. However, for those interested in exploring ChatGPT's capabilities, you can use the provided prompt to put it to the test.

Google App Script Code

var SHEET_NAME = 'Sheet 1’; // Change to your sheet name
var SHEET_ID = 'YOUR_SHEET_ID'; // Change to your sheet ID 
function doGet(e){
var result = 'Failed'; // default failure message
// Check if the provided parameters match our expected values
if(e.parameter.sheetname == SHEET_NAME && e.parameter.sheetid == SHEET_ID) {
try {
var doc = SpreadsheetApp.openById(SHEET_ID);
var sheet = doc.getSheetByName(SHEET_NAME);
var newRow = sheet.getLastRow() + 1;
var rowData = [];
rowData[0] = new Date(); // Timestamp
rowData[1] = e.parameter.temperature; // Temperature from DHT22
rowData[2] = e.parameter.humidity; // Humidity from DHT22
sheet.getRange(newRow, 1, 1, rowData.length).setValues([rowData]);
result = 'Ok'; // success message
} catch(e){
result = 'Error: ' + e.toString();
}
}
return ContentService.createTextOutput(result);
}

Arduino Nano ESP32 Code

#include <WiFi.h>
#include <HTTPClient.h>
#include "DHT.h"
#define DHTPIN 4 // Define which pin the DHT22 is connected to
#define DHTTYPE DHT22
// WiFi settings
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
// Google Script Deployment URL
String GAS_URL = "YOUR_GOOGLE_SCRIPT_URL";
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(115200);
dht.begin();
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");
}
void loop() {
float humidity = dht.readHumidity();
float temperature = dht.readTemperature();
if (isnan(humidity) || isnan(temperature)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
sendDataToGoogleSheet(temperature, humidity);
delay(60000); // Send data every 1 minute
}
void sendDataToGoogleSheet(float temperature, float humidity) {
if(WiFi.status()== WL_CONNECTED){
HTTPClient http;
String url = GAS_URL + "?temperature=" + String(temperature) + "&humidity=" + String(humidity);
http.begin(url);
int httpResponseCode = http.GET();
if(httpResponseCode>0){
String response = http.getString();
Serial.println(response);
} else {
Serial.print("Error on sending POST: ");
Serial.println(httpResponseCode);
}
http.end();
} else {
Serial.println("Error in WiFi connection");
}
}

Conclusion

In this project, we used ChatGPT's smart coding skills to create a ESP32-based data logger. We added a special sensor, DHT22, to capture detailed temperature and humidity info. To make things even more interesting, we made Google Sheets our go-to place for neatly storing and organizing all this valuable data. The dynamic language generation prowess of ChatGPT arduino data to google sheets significantly expedited the coding process, enabling us to efficiently develop the necessary code for both the ESP32 google sheets device and the seamless integration with Google Sheets. But, even though things got simpler as we developed our project, we faced some problems at the start. We bumped into a few roadblocks during the setup.

However, with determination and a step-by-step problem-solving method, we overcame these challenges, proving that our project can handle tough situations and keep going strong. Working together, the smart side of technology, represented by ChatGPT, teamed up with the hands-on hardware esp 32 google sheets world to create a cool system for tracking data. By blending the brainpower of AI with the practical use of a hardware data logger, arduino data to google sheets. we made arduino data to google sheets technology work together seamlessly. This not only makes tracking data easier but also makes it work better. Our project is a great example of how AI and hardware can join forces to come up with clever solutions.