ESP32 - DIYables Bluetooth App Table
Overview
The Bluetooth Table example provides a structured key-value data display accessible through the DIYables Bluetooth STEM app. Designed for ESP32 boards with support for both BLE (Bluetooth Low Energy) and Classic Bluetooth connections. Define named rows and update their values in real time — perfect for dashboards, sensor status panels, system monitors, and any application requiring organized data presentation.
This example supports two Bluetooth modes:
- ESP32 BLE (Bluetooth Low Energy): Works on both Android and iOS
- ESP32 Classic Bluetooth: Works on Android only. iOS does not support Classic Bluetooth. Use BLE if you need iOS support.
Features
- Structured Rows: Up to 20 named attribute rows
- Real-Time Updates: Update individual row values without refreshing the entire table
- Named Attributes: Each row has a descriptive label (e.g., "Temperature", "Status")
- Dynamic Values: Send any string value for each row
- Table Structure Sync: App requests table configuration on connect
- BLE & Classic Bluetooth: Choose the Bluetooth mode that suits your project
- Cross-Platform: BLE mode works on both Android and iOS; Classic Bluetooth works on Android
- Low Power Option: BLE mode consumes less power than Classic Bluetooth
Hardware Used In This Tutorial
Or you can buy the following kits:
| 1 | × | DIYables ESP32 Starter Kit (ESP32 included) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Disclosure: Some of the links in this section are Amazon affiliate links, meaning we may earn a commission at no additional cost to you if you make a purchase through them. Additionally, some links direct you to products from our own brand, DIYables .
ESP32 Code
Quick Instructions
Follow these instructions step by step:
- If this is your first time using the ESP32, refer to the tutorial on setting up the environment for ESP32 in the Arduino IDE.
- Connect the ESP32 board to your computer using a USB cable.
- Launch the Arduino IDE on your computer.
- Select the appropriate ESP32 board and COM port.
- Navigate to the Libraries icon on the left bar of the Arduino IDE.
- Search "DIYables Bluetooth", then find the DIYables Bluetooth library by DIYables
- Click Install button to install the library.
- You will be asked for installing some other library dependencies
- Click Install All button to install all library dependencies.
Choose one of the two Bluetooth modes below depending on your needs:
ESP32 Classic Bluetooth Code (works with app on Android only)
Note: Classic Bluetooth is NOT supported on iOS. If you need iOS support, use the BLE code below.
- On Arduino IDE, Go to File Examples DIYables Bluetooth Esp32Bluetooth_Table example, or copy the above code and paste it to the editor of Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Table Example
* Works with DIYables Bluetooth STEM app on Android
* Note: Classic Bluetooth is NOT supported on iOS. Use BLE examples for iOS support.
*
* This example demonstrates the Bluetooth Table feature:
* - Display structured data in a two-column table
* - Real-time value updates for each row
* - Perfect for sensor dashboards and status displays
*
* Compatible Boards:
* - ESP32 (all variants with Classic Bluetooth)
* - ESP32-WROOM-32
* - ESP32-DevKitC
* - ESP32-WROVER
*
* Note: Select "Huge APP (3MB No OTA/1MB SPIFFS)" partition scheme
* in Arduino IDE: Tools > Partition Scheme
*
* Setup:
* 1. Upload the sketch to your ESP32
* 2. Open Serial Monitor (115200 baud) to see connection status
* 3. Use DIYables Bluetooth App to connect and view the table
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothTable.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Table");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Table app instance
DIYables_BluetoothTable bluetoothTable;
// Variables for demo data
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 1000; // Update every second
int counter = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Table Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add table app to server
bluetoothServer.addApp(&bluetoothTable);
// Define table structure (add rows with attribute names)
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Counter");
bluetoothTable.addRow("Uptime");
bluetoothTable.addRow("Free Heap");
bluetoothTable.addRow("CPU Freq");
bluetoothTable.addRow("Status");
Serial.print("Table rows defined: ");
Serial.println(bluetoothTable.getRowCount());
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send table structure
bluetoothTable.sendTableStructure();
// Send initial values
updateTableValues();
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Optional: Handle requests for table data
bluetoothTable.onDataRequest([]() {
Serial.println("App requested table data");
bluetoothTable.sendTableStructure();
updateTableValues();
});
Serial.println("Waiting for Bluetooth connection...");
}
void updateTableValues() {
// TODO: Replace with actual sensor readings
// Simulated temperature (20-30°C)
float temperature = 20.0 + random(0, 100) / 10.0;
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
// Simulated humidity (40-60%)
int humidity = 40 + random(0, 21);
bluetoothTable.sendValueUpdate("Humidity", String(humidity) + " %");
// Simulated pressure (1000-1020 hPa)
int pressure = 1000 + random(0, 21);
bluetoothTable.sendValueUpdate("Pressure", String(pressure) + " hPa");
// Counter value
bluetoothTable.sendValueUpdate("Counter", String(counter));
counter++;
// Uptime (in seconds)
unsigned long uptime = millis() / 1000;
String uptimeStr = String(uptime / 3600) + "h " +
String((uptime % 3600) / 60) + "m " +
String(uptime % 60) + "s";
bluetoothTable.sendValueUpdate("Uptime", uptimeStr);
// ESP32-specific: Free heap memory
bluetoothTable.sendValueUpdate("Free Heap", String(ESP.getFreeHeap()) + " bytes");
// ESP32-specific: CPU frequency
bluetoothTable.sendValueUpdate("CPU Freq", String(ESP.getCpuFreqMHz()) + " MHz");
// Status
bluetoothTable.sendValueUpdate("Status", counter % 2 == 0 ? "Running" : "Active");
Serial.println("Table values updated");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Update table values periodically (only when connected)
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
updateTableValues();
}
delay(10);
}
- Click Upload button on Arduino IDE to upload code to ESP32
- Open the Serial Monitor
- Check out the result on Serial Monitor. It looks like the below:
COM6
DIYables Bluetooth - ESP32 Table Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
ESP32 BLE Code (works with app on both Android and iOS)
- On Arduino IDE, Go to File Examples DIYables Bluetooth Esp32BLE_Table example, or copy the above code and paste it to the editor of Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 BLE Table Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Table feature:
* - Display structured data in a two-column table
* - Real-time value updates for each row
* - Perfect for sensor dashboards and status displays
*
* Compatible Boards:
* - ESP32-WROOM-32
* - ESP32-DevKitC
* - ESP32-WROVER
* - ESP32-S3
* - ESP32-C3
* - Any ESP32 board supporting BLE
*
* Note: Select "Huge APP (3MB No OTA/1MB SPIFFS)" partition scheme
* in Arduino IDE: Tools > Partition Scheme
*
* Setup:
* 1. Upload the sketch to your ESP32
* 2. Open Serial Monitor (115200 baud) to see connection status
* 3. Use DIYables Bluetooth App to connect and view the table
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothTable.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Table";
const char* SERVICE_UUID = "19B10000-E8F2-537E-4F6C-D104768A1214";
const char* TX_UUID = "19B10001-E8F2-537E-4F6C-D104768A1214";
const char* RX_UUID = "19B10002-E8F2-537E-4F6C-D104768A1214";
// Create Bluetooth instances
DIYables_Esp32BLE bluetooth(DEVICE_NAME, SERVICE_UUID, TX_UUID, RX_UUID);
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Table app instance
DIYables_BluetoothTable bluetoothTable;
// Variables for demo data
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 1000;
int counter = 0;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Table Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add table app to server
bluetoothServer.addApp(&bluetoothTable);
// Define table structure
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Counter");
bluetoothTable.addRow("Uptime");
bluetoothTable.addRow("Free Heap");
bluetoothTable.addRow("Status");
Serial.print("Table rows defined: ");
Serial.println(bluetoothTable.getRowCount());
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothTable.sendTableStructure();
updateTableValues();
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
bluetoothTable.onDataRequest([]() {
Serial.println("App requested table data");
bluetoothTable.sendTableStructure();
updateTableValues();
});
Serial.println("Waiting for Bluetooth connection...");
}
void updateTableValues() {
float temperature = 20.0 + random(0, 100) / 10.0;
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
int humidity = 40 + random(0, 21);
bluetoothTable.sendValueUpdate("Humidity", String(humidity) + " %");
int pressure = 1000 + random(0, 21);
bluetoothTable.sendValueUpdate("Pressure", String(pressure) + " hPa");
bluetoothTable.sendValueUpdate("Counter", String(counter));
counter++;
unsigned long uptime = millis() / 1000;
String uptimeStr = String(uptime / 3600) + "h " +
String((uptime % 3600) / 60) + "m " +
String(uptime % 60) + "s";
bluetoothTable.sendValueUpdate("Uptime", uptimeStr);
bluetoothTable.sendValueUpdate("Free Heap", String(ESP.getFreeHeap()) + " bytes");
bluetoothTable.sendValueUpdate("Status", counter % 2 == 0 ? "Running" : "Active");
Serial.println("Table values updated");
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
updateTableValues();
}
delay(10);
}
- Click Upload button on Arduino IDE to upload code to ESP32
- Open the Serial Monitor
- Check out the result on Serial Monitor. It looks like the below:
COM6
DIYables Bluetooth - ESP32 BLE Table Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
Mobile App
- If you are using the ESP32 Classic Bluetooth code, you need to pair the ESP32 with your Android phone before opening the app:
- Go to your phone's Settings > Bluetooth
- Make sure Bluetooth is turned on
- Your phone will scan for available devices
- Find and tap "ESP32_Table" in the list of available devices
- Confirm the pairing request (no PIN required)
- Wait until it shows "Paired" under the device name
- If you are using the ESP32 BLE code, no pairing is needed. Just proceed to the next step.
- Open the DIYables Bluetooth App
- When opening the app for the first time, it will ask for permissions. Please grant the following:
- Nearby Devices permission (Android 12+) / Bluetooth permission (iOS) - required to scan and connect to Bluetooth devices
- Location permission (Android 11 and below only) - required by older Android versions to scan for BLE devices
- Make sure Bluetooth is turned on on your phone
- On the home screen, tap the Connect button. The app will scan for both BLE and Classic Bluetooth devices.
- Find and tap your device in the scan results to connect:
- For Classic Bluetooth: tap "ESP32_Table"
- For BLE: tap "ESP32BLE_Table"
- Once connected, the app automatically goes back to the home screen. Select the Table app from the app menu.
Note: You can tap the settings icon on the home screen to hide/show apps on the home screen. For more details, see the DIYables Bluetooth App User Manual.
- The table will populate with the attribute names and their current values
Now look back at the Serial Monitor on Arduino IDE. You will see:
COM6
Bluetooth connected!
App requested table data
Sent table structure
Temperature: 25.3
Humidity: 62%
Pressure: 1013 hPa
Counter: 1
Uptime: 0h 0m 5s
Free Heap: 245780
Status: Running
Autoscroll
Clear output
9600 baud
Newline
- Watch the table values update in real time in the app
Creative Customization - Adapt the Code to Your Project
Define Table Rows
Add attribute rows to the table (up to 20 rows max):
// Add rows during setup
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Status");
bluetoothTable.addRow("Uptime");
// Check row count
int rows = bluetoothTable.getRowCount();
Serial.println("Total rows: " + String(rows));
// Get attribute name by index
String attr = bluetoothTable.getAttribute(0); // Returns "Temperature"
Update Row Values
Update individual row values by attribute name or index:
// Update by attribute name
bluetoothTable.sendValueUpdate("Temperature", "25.3 °C");
bluetoothTable.sendValueUpdate("Humidity", "62%");
bluetoothTable.sendValueUpdate("Status", "Running");
// Update by row index (0-based)
bluetoothTable.sendValueUpdate(0, "25.3 °C"); // First row
bluetoothTable.sendValueUpdate(1, "62%"); // Second row
Handle Data Requests from App
When the app connects or requests a refresh:
bluetoothTable.onDataRequest([]() {
Serial.println("App requested table data");
bluetoothTable.sendTableStructure(); // Send row names
// Send current values for all rows
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
bluetoothTable.sendValueUpdate("Humidity", String(humidity) + "%");
bluetoothTable.sendValueUpdate("Status", "Online");
});
Clear and Rebuild Table
// Clear all rows
bluetoothTable.clearTable();
// Add new rows
bluetoothTable.addRow("Sensor A");
bluetoothTable.addRow("Sensor B");
// Send updated structure to app
bluetoothTable.sendTableStructure();
Handle Connection Events
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
How to Use the Table
App Interface
The table interface in the DIYables Bluetooth App shows:
- Attribute Column: Row labels defined by addRow()
- Value Column: Current values updated by sendValueUpdate()
- Auto-Refresh: Values update in real time as they arrive
Table Limits
- Maximum 20 rows per table (MAX_TABLE_ROWS = 20)
- Attribute names should be concise but descriptive
- Values are displayed as strings
Programming Examples
Sensor Dashboard
// Define sensor dashboard rows
bluetoothTable.addRow("Temperature");
bluetoothTable.addRow("Humidity");
bluetoothTable.addRow("Pressure");
bluetoothTable.addRow("Light Level");
bluetoothTable.addRow("Air Quality");
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 2000) {
lastUpdate = millis();
float temp = readTemperature();
float hum = readHumidity();
float press = readPressure();
int light = analogRead(34);
int airQuality = analogRead(35);
bluetoothTable.sendValueUpdate("Temperature", String(temp, 1) + " °C");
bluetoothTable.sendValueUpdate("Humidity", String(hum, 0) + "%");
bluetoothTable.sendValueUpdate("Pressure", String(press, 0) + " hPa");
bluetoothTable.sendValueUpdate("Light Level", String(map(light, 0, 4095, 0, 100)) + "%");
bluetoothTable.sendValueUpdate("Air Quality", airQuality < 1000 ? "Good" : "Poor");
}
delay(10);
}
System Status Monitor
bluetoothTable.addRow("Uptime");
bluetoothTable.addRow("Free Heap");
bluetoothTable.addRow("CPU Temp");
bluetoothTable.addRow("WiFi Signal");
bluetoothTable.addRow("Clients");
bluetoothTable.addRow("Status");
void updateSystemStatus() {
unsigned long uptime = millis() / 1000;
int hours = uptime / 3600;
int minutes = (uptime % 3600) / 60;
int seconds = uptime % 60;
bluetoothTable.sendValueUpdate("Uptime",
String(hours) + "h " + String(minutes) + "m " + String(seconds) + "s");
bluetoothTable.sendValueUpdate("Free Heap", String(ESP.getFreeHeap()) + " bytes");
bluetoothTable.sendValueUpdate("CPU Temp", String(temperatureRead(), 1) + " °C");
bluetoothTable.sendValueUpdate("Status", "Online");
}
GPIO Pin Status Table
const int PINS[] = {2, 4, 5, 12, 13, 14, 15, 16};
const int NUM_PINS = sizeof(PINS) / sizeof(PINS[0]);
void setup() {
// ... Bluetooth setup ...
for (int i = 0; i < NUM_PINS; i++) {
pinMode(PINS[i], INPUT);
bluetoothTable.addRow("GPIO " + String(PINS[i]));
}
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
for (int i = 0; i < NUM_PINS; i++) {
int state = digitalRead(PINS[i]);
bluetoothTable.sendValueUpdate("GPIO " + String(PINS[i]),
state == HIGH ? "HIGH ?" : "LOW ?");
}
}
delay(10);
}
Analog Sensor Array
struct SensorConfig {
String name;
int pin;
String unit;
float scale;
};
SensorConfig sensors[] = {
{"Temperature", 34, "°C", 0.0488},
{"Humidity", 35, "%", 0.0244},
{"Light", 36, "lux", 0.244},
{"Pressure", 39, "hPa", 0.488}
};
const int NUM_SENSORS = sizeof(sensors) / sizeof(sensors[0]);
void setup() {
// ... Bluetooth setup ...
for (int i = 0; i < NUM_SENSORS; i++) {
bluetoothTable.addRow(sensors[i].name);
}
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 2000) {
lastUpdate = millis();
for (int i = 0; i < NUM_SENSORS; i++) {
int raw = analogRead(sensors[i].pin);
float value = raw * sensors[i].scale;
bluetoothTable.sendValueUpdate(sensors[i].name,
String(value, 1) + " " + sensors[i].unit);
}
}
delay(10);
}
Advanced Programming Techniques
Conditional Formatting with Emojis
void updateTemperatureRow(float temp) {
String status;
if (temp < 10) {
status = "❄️ " + String(temp, 1) + " °C (Cold)";
} else if (temp < 30) {
status = "✅ " + String(temp, 1) + " °C (Normal)";
} else {
status = "🔥 " + String(temp, 1) + " °C (Hot!)";
}
bluetoothTable.sendValueUpdate("Temperature", status);
}
Event-Driven Updates
float lastTemp = 0;
float threshold = 0.5; // Only update on significant change
void loop() {
bluetoothServer.loop();
float temp = readTemperature();
if (abs(temp - lastTemp) >= threshold) {
lastTemp = temp;
bluetoothTable.sendValueUpdate("Temperature", String(temp, 1) + " °C");
bluetoothTable.sendValueUpdate("Last Change", getTimestamp());
}
delay(100);
}
Hardware Integration Ideas
BME280 Weather Station Table
Connect a BME280 sensor to display temperature, humidity, and pressure in the table.
Multi-Sensor Dashboard
Connect multiple sensors (DHT22, BMP280, LDR, MQ-135) and display all readings as rows.
Device Info Panel
Display ESP32 system information: chip model, flash size, free heap, uptime, and MAC address.
BLE vs Classic Bluetooth - Which to Choose?
| Feature | BLE (Esp32BLE_Table) | Classic Bluetooth (Esp32Bluetooth_Table) |
|---|---|---|
| iOS Support | ? Yes | ? No |
| Android Support | ? Yes | ? Yes |
| Power Consumption | Low | Higher |
| Range | ~30-100m | ~10-100m |
| Data Rate | Lower | Higher |
| Pairing Required | No (auto-connect) | Yes (manual pairing) |
| Best For | Battery-powered, cross-platform | High throughput, Android-only |
Troubleshooting
Common Issues
1. Cannot find the device in the app
- Make sure the ESP32 is powered on and the sketch is uploaded
- For BLE: Ensure your phone's Bluetooth and Location are enabled
- For Classic Bluetooth: Pair the device first in phone's Bluetooth settings
- Check that the correct partition scheme is selected (Huge APP)
2. Table shows no data
- Ensure sendTableStructure() is called in the onDataRequest callback
- Verify rows are added with addRow() before sending updates
- Check Serial Monitor for "App requested table data" message
3. Values not updating
- Verify the attribute name in sendValueUpdate() matches exactly what was added with addRow()
- Check that your update interval timer is working
- Ensure Bluetooth is still connected
4. Missing rows in the table
- Maximum 20 rows are supported
- Check getRowCount() to verify all rows were added
- Rows must be added before sending the table structure
5. Connection drops frequently
- Move closer to the ESP32 (reduce distance)
- For BLE: Check for interference from other BLE devices
- For Classic Bluetooth: Ensure stable power supply to ESP32
6. Sketch too large / not enough space
- In Arduino IDE, go to Tools > Partition Scheme and select "Huge APP (3MB No OTA/1MB SPIFFS)" or "No OTA (Large APP)"
- The default partition scheme only provides ~1.2MB for app code, which is not enough for Bluetooth libraries
- This setting gives ~3MB by sacrificing the OTA (over-the-air update) partition
Debug Tips
Add comprehensive debugging:
void debugTable() {
Serial.println("=== Table Debug ===");
Serial.println("Row Count: " + String(bluetoothTable.getRowCount()));
for (int i = 0; i < bluetoothTable.getRowCount(); i++) {
Serial.println("Row " + String(i) + ": " + bluetoothTable.getAttribute(i));
}
Serial.println("===================");
}
Project Ideas
Monitoring Dashboards
- Weather station display (temp, humidity, pressure, wind)
- Server/network status monitor
- Plant care dashboard (soil moisture, light, temperature)
- Aquarium monitor (temperature, pH, TDS)
System Information
- ESP32 system diagnostics table
- WiFi connection details
- Memory usage tracker
- Battery status display
Data Logging
- Sensor min/max/average tracker
- Event counter display
- Timing statistics (response time, uptime)
- I/O pin state summary
Home Automation
- Room-by-room temperature display
- Device status overview
- Energy consumption summary
- Security sensor status
Integration with Other Bluetooth Apps
Combine with Bluetooth Plotter
Display values in table and visualize trends in plotter:
float temperature = 0;
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 2000) {
lastUpdate = millis();
temperature = readTemperature();
// Update table
bluetoothTable.sendValueUpdate("Temperature", String(temperature, 1) + " °C");
bluetoothTable.sendValueUpdate("Status", temperature > 30 ? "Warning" : "Normal");
// Plot trend
bluetoothPlotter.send(temperature);
}
delay(10);
}
Combine with Bluetooth Monitor
Use table for structured data and monitor for log messages:
bluetoothTable.sendValueUpdate("Temperature", String(temp, 1) + " °C");
bluetoothMonitor.send("[INFO] Temperature: " + String(temp, 1) + " °C");
if (temp > 40) {
bluetoothTable.sendValueUpdate("Status", "? ALERT");
bluetoothMonitor.send("[ALERT] High temperature detected!");
}
Next Steps
After mastering the Bluetooth Table example, try:
- Bluetooth Monitor - For free-form text logging
- Bluetooth Plotter - For visualizing data trends
- Bluetooth Temperature - For dedicated temperature display
- Multiple Bluetooth Apps - Combining table with other displays
Support
For additional help:
- Check the API Reference documentation
- Visit DIYables tutorials
- Arduino community forums