Wikifab - Contributions de l’utilisateur [fr]

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e2.JPG

2026-03-22T17:57:37Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e2

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e2

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e3.JPG

2026-03-22T17:57:36Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e3

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e3

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e4.JPG

2026-03-22T17:57:35Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e4

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e4

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e5.JPG

2026-03-22T17:57:34Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e5

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e5

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e6.JPG

2026-03-22T17:57:33Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e6

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e6

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e7.JPG

2026-03-22T17:57:31Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e7

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e7

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e8.JPG

2026-03-22T17:57:30Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e8

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e8

Fichier:DFRobot FireBeetle ESP32-P4 OLED Controller e1.JPG

2026-03-22T17:50:05Z

CETECH : DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e1

DFRobot_FireBeetle_ESP32-P4_OLED_Controller_e1

LattePanda IOTA: Tiny Beast. Full-Throttle Brains.

2026-03-02T08:41:15Z

CETECH : Page créée avec « {{Tuto Details |Main_Picture=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._dfrobotcover.JPG |Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","ve... »

{{Tuto Details
|Main_Picture=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._dfrobotcover.JPG
|Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0","originX":"left","originY":"top","left":-9,"top":-7,"width":754,"height":569,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.83,"scaleY":0.83,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://wikifab.org/images/9/93/LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._dfrobotcover.JPG","filters":[]}],"height":450,"width":600}
|Licences=Attribution (CC BY)
|Description=<translate>A pocket-sized x86 powerhouse with RP2040 control—built to dominate edge AI, robotics, and real-time embedded magic.</translate>
|Area=Electronics
|Type=Technique
|Difficulty=Easy
|Duration=2
|Duration-type=hour(s)
|Cost=30
|Currency=USD ($)
|Tags=LattePanda, PSoC
}}
{{Introduction
|Introduction=<translate>If you’ve ever wished for a single-board computer that could juggle Windows, real-time control, and edge AI—all while fitting in your palm—your wish just came true. Meet the '''LattePanda IOTA''', a pint-sized monster that packs Intel’s N150 processor, RP2040 co-processor, and a buffet of I/O options into a sleek, modular form factor.

Whether you're upgrading from the original LattePanda or diving into embedded systems for the first time, the IOTA is designed to make serious computing feel playful, expressive, and scalable.</translate>
}}
{{Materials
|Material=<translate></translate>
|Tools=<translate></translate>
}}
{{Tuto Step
|Step_Title=<translate>Get PCBs for Your Projects Manufactured</translate>
|Step_Content=<translate>You must check out [https://www.pcbway.com/ PCBWAY] for ordering PCBs online for cheap!

You get 10 good-quality PCBs manufactured and shipped to your doorstep for cheap. You will also get a discount on shipping on your first order. Upload your Gerber files onto [https://www.pcbway.com/ PCBWAY] to get them manufactured with good quality and quick turnaround time. PCBWay now could provide a complete product solution, from design to enclosure production. Check out their online Gerber viewer function. With reward points, you can get free stuff from their gift shop. Also, check out this useful blog on PCBWay Plugin for KiCad from [https://www.pcbway.com/blog/News/PCBWay_Plug_In_for_KiCad_3ea6219c.html here.] Using this plugin, you can directly order PCBs in just one click after completing your design in KiCad.</translate>
|Step_Picture_00=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._pcbway.JPG
}}
{{Tuto Step
|Step_Title=<translate>🧠 What Makes IOTA Special?</translate>
|Step_Content=<translate>* '''Intel N150 Quad-Core CPU''': Up to 3.6GHz of x86 muscle, perfect for multitasking, AI inference, and industrial workloads.
* '''RP2040 Co-Processor''': Handles GPIO, sensors, and motor control with Arduino and MicroPython support.
* '''Ultra-Compact Form''': Just 88mm × 70mm—ideal for robots, kiosks, and portable devices.
* '''Rich Connectivity''': USB 3.2 Gen2, HDMI 2.1, eDP, Gigabit Ethernet, M.2 slots, PCIe, and more.
* '''Modular Ecosystem''': Add UPS, PoE, LTE, NVMe, or AI accelerators with plug-and-play ease.</translate>
|Step_Picture_00=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d1.JPG
|Step_Picture_01=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d2.JPG
}}
{{Tuto Step
|Step_Title=<translate>🛠️ Getting Started: Step-by-Step Setup</translate>
|Step_Content=<translate>=== 1. Pick Your Board Variant ===
Choose based on your workload:

* '''8GB RAM / 64GB eMMC''' – Great for dashboards, kiosks, and sensor hubs.
* '''16GB RAM / 128GB eMMC''' – Ideal for AI inference, multitasking, and classroom demos.
* '''Windows IoT Enterprise License''' – Optional for commercial deployments.

=== 2. Install Cooling (Mandatory) ===

* '''Fanless Heatsink''' – Silent and rugged.
* '''Active Cooler''' – Recommended for heavy-duty tasks.

<blockquote>⚠️ Never boot without a cooling solution—this board runs hot!</blockquote>

=== 3. Add WiFi Module (Optional) ===

* '''Intel AX210 (WiFi 6E)''' or '''BE200 (WiFi 7)''' for blazing-fast wireless.

=== 4. Power It Right ===
Use the official 60W adapter for stable performance. It supports global plugs and ensures safe operation.

=== 5. Expand as Needed ===

* '''UPS Board''' – For power backup and safe shutdown.
* '''PoE Board''' – Power + data over Ethernet.
* '''M.2 NVMe SSD''' – For fast storage.
* '''4G LTE Board''' – Cellular connectivity for remote deployments.

=== 6. Protect It ===
The aluminum heatsink case offers passive cooling and rugged protection—perfect for field use.

=== 7. Touch Display Options ===

* '''7" 1024×600''' – Compact and multi-touch.
* '''11.6" FHD''' – Sleek and immersive.</translate>
|Step_Picture_00=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d3.JPG
|Step_Picture_01=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d6.JPG
|Step_Picture_02=LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d8.JPG
}}
{{Tuto Step
|Step_Title=<translate>🧪 First Boot Tips</translate>
|Step_Content=<translate>* Connect cooling and WiFi modules before powering on.
* Use HDMI or eDP to connect your display.
* Boot into '''Windows IoT''' or '''Ubuntu 22.04'''—both run smoothly.
* Use the RP2040 for GPIO tasks while offloading heavy lifting to the Intel CPU.</translate>
}}
{{Tuto Step
|Step_Title=<translate>💡 Project Ideas to Kickstart</translate>
|Step_Content=<translate>* '''Smart Retail Kiosk''' – Touch interface + barcode scanner.
* '''Edge AI Inference Device''' – Run local LLMs or vision models.
* '''Industrial Sensor Hub''' – Real-time logging + remote access.
* '''Portable Robot Controller''' – Wireless telemetry + motor control.
* '''Classroom IoT Dashboard''' – Live data visualization + modular sensors.</translate>
}}
{{Tuto Step
|Step_Title=<translate>🧩 Final Thoughts</translate>
|Step_Content=<translate>LattePanda IOTA isn’t just a board—it’s a creative engine. It’s built for those who want to push boundaries, teach others, and build expressive systems that blend power with personality. Whether you're crafting a rugged sensor node or a classroom-ready dashboard, IOTA gives you the tools to make it modular, scalable, and fun.

So go ahead—boot it up, wire it in, and let your imagination run wild. And when you build something cool, share it. The community’s waiting.</translate>
}}
{{Notes
|Notes=<translate></translate>
}}
{{PageLang
|SourceLanguage=none
|IsTranslation=0
|Language=en
}}
{{Tuto Status
|Complete=Published
}}

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. pcbway.JPG

2026-03-02T08:38:45Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._pcbway

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._pcbway

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d1.JPG

2026-03-02T08:38:44Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d1

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d1

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d3.JPG

2026-03-02T08:38:43Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d3

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d3

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d2.JPG

2026-03-02T08:38:43Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d2

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d2

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d4.JPG

2026-03-02T08:38:42Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d4

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d4

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d5.JPG

2026-03-02T08:38:41Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d5

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d5

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d6.JPG

2026-03-02T08:38:40Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d6

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d6

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d7.JPG

2026-03-02T08:38:39Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d7

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d7

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d8.JPG

2026-03-02T08:38:38Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d8

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d8

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d9.JPG

2026-03-02T08:38:36Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d9

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d9

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. d10.JPG

2026-03-02T08:38:35Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d10

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._d10

Fichier:LattePanda IOTA- Tiny Beast. Full-Throttle Brains. dfrobotcover.JPG

2026-03-02T08:32:47Z

CETECH : LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._dfrobotcover

LattePanda_IOTA-_Tiny_Beast._Full-Throttle_Brains._dfrobotcover

Real Time System Telemetry Dashboard with FireBeetle ESP32P4

2025-12-20T12:27:55Z

CETECH : Page créée avec « {{Tuto Details |Main_Picture=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2a.JPG |Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","v... »

{{Tuto Details
|Main_Picture=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2a.JPG
|Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0","originX":"left","originY":"top","left":-1,"top":-3,"width":764,"height":576,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.79,"scaleY":0.79,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://wikifab.org/images/3/3c/Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2a.JPG","filters":[]}],"height":450.20576131687244,"width":600}
|Licences=Attribution (CC BY)
|Description=<translate>Build a real‑time system telemetry dashboard that shows your PC’s CPU, RAM, and network stats in a dark, single‑page web UI.</translate>
|Area=Electronics
|Type=Technique
|Difficulty=Easy
|Duration=2
|Duration-type=hour(s)
|Cost=15
|Currency=USD ($)
|Tags=ESP32
}}
{{Introduction
|Introduction=<translate>Build a '''real‑time system telemetry dashboard''' that shows your PC’s CPU, RAM, and network stats in a '''dark, single‑page web UI''' served by a '''DFRobot FireBeetle ESP32‑P4'''. Your PC sends newline‑terminated JSON over USB serial; the ESP32 parses it, blinks an onboard LED (pin 3) when new data arrives, and serves a responsive AJAX dashboard that updates every 5 seconds and includes a raw JSON console.</translate>
}}
{{Materials
|Material=<translate></translate>
|Tools=<translate></translate>
}}
{{Tuto Step
|Step_Title=<translate>Hardware</translate>
|Step_Content=<translate>* '''DFRobot FireBeetle ESP32‑P4''' board (or compatible ESP32‑P4 board
* USB cable (for power, programming, and serial data)
* Optional: small breadboard / jumper wires if you want to wire external LED or buttons (onboard LED uses pin 3)

'''Display / UI'''

* No OLED required for the web UI version — everything is in the browser.

'''Software on PC'''

* '''Python 3.8+'''
* Python packages: '''pyserial''', '''psutil''' (install with <code>pip install pyserial psutil</code>)

'''Arduino IDE'''

* Latest Arduino IDE or VS Code with PlatformIO
* ESP32 board support installed (Espressif package)
* Libraries: '''Arduino_JSON''' (install via Library Manager)

'''Network'''

* Local Wi‑Fi network credentials (SSID and password) for the ESP32 to host the webserver</translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2b.JPG
}}
{{Tuto Step
|Step_Title=<translate>Get PCBs for Your Projects Manufactured</translate>
|Step_Content=<translate>You must check out [https://www.pcbway.com/ PCBWAY] for ordering PCBs online for cheap!

You get 10 good-quality PCBs manufactured and shipped to your doorstep for cheap. You will also get a discount on shipping on your first order. Upload your Gerber files onto [https://www.pcbway.com/ PCBWAY] to get them manufactured with good quality and quick turnaround time. PCBWay now could provide a complete product solution, from design to enclosure production. Check out their online Gerber viewer function. With reward points, you can get free stuff from their gift shop. Also, check out this useful blog on PCBWay Plugin for KiCad from [https://www.pcbway.com/blog/News/PCBWay_Plug_In_for_KiCad_3ea6219c.html here]. Using this plugin, you can directly order PCBs in just one click after completing your design in KiCad.</translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2c.JPG
}}
{{Tuto Step
|Step_Title=<translate>Wiring and hardware setup</translate>
|Step_Content=<translate>=== Power and data ===

* Connect the FireBeetle to your PC using the USB cable. This provides power and the serial link for telemetry.

'''LED'''

* The sketch uses the '''onboard LED on pin 3'''. No extra wiring required unless you want an external LED — then connect LED + resistor to pin 3 and GND.

'''Notes'''

* Close Arduino Serial Monitor before running the Python sender (only one app can open the COM port at a time)
* Ensure the FireBeetle is selected as the target board in Arduino IDE and the correct COM port is chosen.</translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2d.JPG
|Step_Picture_01=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2e.JPG
}}
{{Tuto Step
|Step_Title=<translate>Arduino sketch (webserver with AJAX dashboard)</translate>
|Step_Content=<translate>'''What it does'''

* Connects to Wi‑Fi using your SSID and password.
* Listens on USB serial (9600 baud) for newline‑terminated JSON from the PC.
* Parses JSON and stores the latest values.
* Serves a dark themed HTML dashboard at <code>http://<ESP32-IP>/</code>.
* Provides <code>/data</code> JSON endpoint used by the page’s AJAX to update UI every 5 seconds.
* Blinks onboard LED on pin 3 when new data arrives.

'''Paste and upload this sketch''' (replace <code>YOUR_SSID</code> and <code>YOUR_PASSWORD</code>):
<br /><syntaxhighlight lang="c">
#include <WiFi.h>
#include <WebServer.h>
#include <Arduino_JSON.h>

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

WebServer server(80);

String host, os, boot, ramUsed, ramTotal, ip, mac;
double cpu = 0, ramPct = 0;

#define LED_PIN 3 // onboard LED pin

// Serve the main HTML page
void handleRoot() {
String html = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>ESP32-P4 Telemetry Dashboard</title>
<style>
body{background:#121212;color:#eee;font-family:Arial;text-align:center;}
h1{color:#4cafef;}
.card{background:#1e1e1e;padding:20px;margin:20px;border-radius:10px;box-shadow:0 0 10px rgba(0,0,0,0.5);}
.bar{height:20px;background:#333;border-radius:10px;overflow:hidden;margin-top:10px;}
.fill{height:100%;background:#4caf50;text-align:right;color:#fff;padding-right:5px;}
.gauge{width:120px;height:60px;background:#333;border-radius:120px 120px 0 0;overflow:hidden;margin:20px auto;position:relative;}
.needle{width:4px;height:60px;background:#4cafef;position:absolute;bottom:0;left:58px;transform-origin:bottom center;}
</style>
<script>
async function fetchData(){
const res = await fetch('/data');
const data = await res.json();
document.getElementById('host').innerText = data.host;
document.getElementById('os').innerText = data.os;
document.getElementById('boot').innerText = data.boot_time;
document.getElementById('cpu').innerText = data.cpu_percent + '%';
document.getElementById('cpuFill').style.width = data.cpu_percent + '%';
document.getElementById('cpuNeedle').style.transform = 'rotate('+(data.cpu_percent/100*180)+'deg)';
document.getElementById('ram').innerText = data.ram.used + ' / ' + data.ram.total + ' ('+data.ram.percent+'%)';
document.getElementById('ramFill').style.width = data.ram.percent + '%';
document.getElementById('ramNeedle').style.transform = 'rotate('+(data.ram.percent/100*180)+'deg)';
document.getElementById('ip').innerText = data.network.ip;
document.getElementById('mac').innerText = data.network.mac;
// Show raw JSON in console widget
document.getElementById('console').innerText = JSON.stringify(data, null, 2);
}
setInterval(fetchData, 5000); // auto refresh every 5s
window.onload = fetchData;
</script>
</head>
<body>
<h1>ESP32-P4 Telemetry Dashboard</h1>
<div class="card">
<h2>System Info</h2>
<p><b>Host:</b> <span id="host"></span></p>
<p><b>OS:</b> <span id="os"></span></p>
<p><b>Boot Time:</b> <span id="boot"></span></p></div>
<div class="card">
<h2>CPU Usage</h2>
<div class="gauge"><div id="cpuNeedle" class="needle"></div></div>
<div class="bar"><div id="cpuFill" class="fill">0%</div></div>
<p id="cpu"></p>
</div>
<div class="card">
<h2>RAM Usage</h2>
<div class="gauge"><div id="ramNeedle" class="needle"></div></div>
<div class="bar"><div id="ramFill" class="fill">0%</div></div>
<p id="ram"></p>
</div>
<div class="card">
<h2>Network</h2>
<p><b>IP:</b> <span id="ip"></span></p>
<p><b>MAC:</b> <span id="mac"></span></p>
</div>
<div class="card" style="margin:20px;">
<h2>Raw data console</h2>
<pre id="console" style="background:#000;color:#0f0;padding:10px;border-radius:6px;height:140px;overflow:auto;">{}</pre>
</div>
</body>
</html>
)rawliteral";
server.send(200, "text/html", html);
}

// Serve JSON data for AJAX
void handleData() {
String json = "{";
json += "\"host\":\"" + host + "\",";
json += "\"os\":\"" + os + "\",";
json += "\"boot_time\":\"" + boot + "\",";
json += "\"cpu_percent\":" + String(cpu) + ",";
json += "\"ram\":{\"used\":\"" + ramUsed + "\",\"total\":\"" + ramTotal + "\",\"percent\":" + String(ramPct) + "},";
json += "\"network\":{\"ip\":\"" + ip + "\",\"mac\":\"" + mac + "\"}";
json += "}";
server.send(200, "application/json", json);
}

void setup() {
Serial.begin(9600);
pinMode(LED_PIN, OUTPUT);

WiFi.begin(ssid, password);
Serial.print("Connecting to WiFi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nConnected!");
Serial.print("ESP32 IP: ");
Serial.println(WiFi.localIP());

server.on("/", handleRoot);
server.on("/data", handleData);
server.begin();
}

void loop() {
server.handleClient();

if (Serial.available()) {
String msg = Serial.readStringUntil('\n');
JSONVar data = JSON.parse(msg);
if (JSON.typeof(data) != "undefined") {
host = (const char*)data["host"];
os = (const char*)data["os"];
boot = (const char*)data["boot_time"];
cpu = double(data["cpu_percent"]);
ramUsed = (const char*)data["ram"]["used"];
ramTotal = (const char*)data["ram"]["total"];
ramPct = double(data["ram"]["percent"]);
ip = (const char*)data["network"]["ip"];
mac = (const char*)data["network"]["mac"];

// Blink LED when new data arrives
digitalWrite(LED_PIN, HIGH);
delay(100);
digitalWrite(LED_PIN, LOW);
}
}
}
</syntaxhighlight>

'''Notes'''

* Replace <code>YOUR_SSID</code> and <code>YOUR_PASSWORD</code>.
* Keep Serial Monitor closed while Python is running.</translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2f.JPG
}}
{{Tuto Step
|Step_Title=<translate>Python telemetry sender (PC side)</translate>
|Step_Content=<translate>'''What it does'''

* Collects real system stats using <code>psutil</code>.
* Formats a JSON object and sends it over USB serial to the ESP32 every 5 seconds.
* Newline terminator <code>\n</code> is required so the ESP32 can use <code>readStringUntil('\n')</code>.

<code>pip install pyserial psutil</code>
'''Python script (run on your PC, update''' <code>PORT</code>''')'''<syntaxhighlight lang="python">
import psutil
import platform
import socket
import time
import serial
import json
from datetime import datetime

PORT = "COM8" # Change to your ESP32 port
BAUD = 9600

def get_size(bytes, suffix="B"):
factor = 1024.0
for unit in ["", "K", "M", "G", "T"]:
if bytes < factor:
return f"{bytes:.2f}{unit}{suffix}"
bytes /= factor

def get_ip_mac():
ip, mac = "N/A", "N/A"
for iface, addrs in psutil.net_if_addrs().items():
for addr in addrs:
if addr.family == socket.AF_INET and not addr.address.startswith("127."):
ip = addr.address
if hasattr(addr.family, "name") and addr.family.name in ("AF_LINK", "AF_PACKET"):
mac = addr.address
return ip, mac

try:
ser = serial.Serial(PORT, BAUD, timeout=1)
time.sleep(2)

while True:
uname = platform.uname()
boot_time = datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
cpu = psutil.cpu_percent(interval=None)
ram = psutil.virtual_memory()
disk = psutil.disk_usage('/')
ip, mac = get_ip_mac()

data = {
"host": uname.node,
"os": f"{uname.system} {uname.release}",
"boot_time": boot_time,
"cpu_percent": cpu,
"ram": {
"used": get_size(ram.used),
"total": get_size(ram.total),
"percent": ram.percent
},
"disk": {
"used": get_size(disk.used),
"total": get_size(disk.total),
"percent": disk.percent
},
"network": {
"ip": ip,
"mac": mac
}
}

ser.write((json.dumps(data) + "\n").encode("utf-8"))
print("Sent:", json.dumps(data))
time.sleep(5)

except serial.SerialException as e:
print("Serial error:", e)
except KeyboardInterrupt:
print("Stopped by user.")
finally:
try:
ser.close()
except:
pass
</syntaxhighlight></translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2g.JPG
}}
{{Tuto Step
|Step_Title=<translate>Running and verification (step by step)</translate>
|Step_Content=<translate>'''Prepare hardware'''

* Connect FireBeetle to PC via USB.
* Ensure board drivers are installed and the COM port is visible.

'''Upload Arduino sketch'''

* Open Arduino IDE, paste the sketch, set board to FireBeetle ESP32‑P4, update Wi‑Fi credentials, and upload.
* After upload, open Serial Monitor briefly to see Wi‑Fi connection logs, then close it. Note the printed '''ESP32 IP'''.

'''Start Python sender'''

* Update <code>PORT</code> to the ESP32 COM port (Windows: <code>COMx</code>, Linux: <code>/dev/ttyUSB0</code>), then run the Python script.
* Confirm the script prints “Sent:” messages every 5 seconds.

'''Open dashboard'''

* In a browser on the same network, open <code>http://<ESP32-IP>/</code> (use the IP printed in Serial Monitor).
* The page will auto‑fetch <code>/data</code> every 5 seconds and update the UI.
* The raw JSON console shows the latest packet.

'''Verify LED'''

* Each time the Python script sends a new JSON packet, the onboard LED on pin 3 should blink briefly.

=== Next steps and enhancements ===

* '''Add authentication''' to the web UI (basic token or password).
* '''Send telemetry over Wi‑Fi''' (HTTP POST from Python to ESP32) to remove USB dependency.
* '''Add more metrics''': network throughput, GPU stats (via <code>GPUtil</code>), disk per‑partition details.
* '''Persist logs''' on an SD card or send to a remote server.
* '''Add manual controls''': buttons on the FireBeetle to change refresh rate or toggle panels.
* Improve visuals: use charting libraries (Chart.js) hosted locally for sparklines and history graphs.</translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2h.JPG
|Step_Picture_01=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2i.JPG
}}
{{Tuto Step
|Step_Title=<translate>Conclusion:</translate>
|Step_Content=<translate><section id="story">
You now have a complete local telemetry solution: a Python script on your PC collects CPU, RAM, disk, and network stats and streams them as newline‑terminated JSON over USB to your DFRobot FireBeetle ESP32‑P4, which parses the data, blinks its onboard LED on new packets, and serves a dark, single‑page AJAX dashboard that updates every five seconds and includes live gauges and a raw JSON console—giving you real‑time visibility, local control and privacy, and a flexible foundation for adding authentication, Wi‑Fi telemetry, logging, or alerts.
</section></translate>
|Step_Picture_00=Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2j.JPG
}}
{{Notes
|Notes=<translate></translate>
}}
{{PageLang
|SourceLanguage=none
|IsTranslation=0
|Language=en
}}
{{Tuto Status
|Complete=Published
}}

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2a.JPG

2025-12-20T12:20:59Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2a

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2a

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2b.JPG

2025-12-20T12:20:58Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2b

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2b

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2c.JPG

2025-12-20T12:20:57Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2c

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2c

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2d.JPG

2025-12-20T12:20:55Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2d

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2d

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2e.JPG

2025-12-20T12:20:54Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2e

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2e

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2f.JPG

2025-12-20T12:20:53Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2f

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2f

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2g.JPG

2025-12-20T12:20:52Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2g

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2g

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2i.JPG

2025-12-20T12:20:51Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2i

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2i

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2h.JPG

2025-12-20T12:20:51Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2h

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2h

Fichier:Real Time System Telemetry Dashboard with FireBeetle ESP32P4 a2j.JPG

2025-12-20T12:20:50Z

CETECH : Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2j

Real_Time_System_Telemetry_Dashboard_with_FireBeetle_ESP32P4_a2j

Interfacing a Servo Motor with Arduino Nano

2025-12-20T12:15:05Z

CETECH : Page créée avec « {{Tuto Details |Main_Picture=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1a.JPG |Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0","... »

{{Tuto Details
|Main_Picture=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1a.JPG
|Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0","originX":"left","originY":"top","left":21,"top":9,"width":759,"height":571,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.75,"scaleY":0.75,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://wikifab.org/images/a/ad/Interfacing_a_Servo_Motor_with_Arduino_Nano_a1a.JPG","filters":[]}],"height":450.38759689922483,"width":600}
|Licences=Attribution (CC BY)
|Description=<translate>Will guide you to interface the Arduino nano with Servo motor.</translate>
|Area=Electronics
|Type=Technique
|Difficulty=Easy
|Duration=2
|Duration-type=hour(s)
|Cost=10
|Currency=USD ($)
|Tags=Arduino Nano, Servo
}}
{{Introduction
|Introduction=<translate>Servo motors are widely used in robotics, automation, and DIY projects because they allow precise control of angular position. The Arduino Nano, being compact and versatile, is perfect for controlling servos in space-constrained projects. In this tutorial, we’ll learn how to connect and program a servo motor with the Arduino Nano</translate>
}}
{{Materials
|Material=<translate></translate>
|Tools=<translate></translate>
}}
{{Tuto Step
|Step_Title=<translate>Components Required</translate>
|Step_Content=<translate>* '''Arduino Nano''' (official or compatible board)
* '''Servo Motor''' (e.g., SG90 micro servo)
* '''Jumper wires'''
* '''USB cable (Mini-B)''' for programming</translate>
}}
{{Tuto Step
|Step_Title=<translate>Get PCBs for Your Projects Manufactured</translate>
|Step_Content=<translate>You must check out [https://www.pcbway.com/ PCBWAY] for ordering PCBs online for cheap!

You get 10 good-quality PCBs manufactured and shipped to your doorstep for cheap. You will also get a discount on shipping on your first order. Upload your Gerber files onto [https://www.pcbway.com/ PCBWAY] to get them manufactured with good quality and quick turnaround time. PCBWay now could provide a complete product solution, from design to enclosure production. Check out their online Gerber viewer function. With reward points, you can get free stuff from their gift shop. Also, check out this useful blog on PCBWay Plugin for KiCad from [https://www.pcbway.com/blog/News/PCBWay_Plug_In_for_KiCad_3ea6219c.html here]. Using this plugin, you can directly order PCBs in just one click after completing your design in KiCad.</translate>
|Step_Picture_00=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1b.JPG
}}
{{Tuto Step
|Step_Title=<translate>Understanding the Servo Motor</translate>
|Step_Content=<translate>'''Wires:'''

* '''Red''' → VCC (typically 5V)
* '''Brown/Black''' → GND
* '''Orange/Yellow''' → Signal (PWM input)

'''Working Principle:''' The servo motor rotates to a specific angle (0°–180°) based on the PWM signal sent from the Arduino

Circuit Connections

* Connect '''servo VCC (red)''' to '''5V pin''' of Arduino Nano
* Connect '''servo GND (black/brown)''' to '''GND pin''' of Arduino Nano.
* Connect '''servo signal (orange/yellow)''' to '''digital pin D9''' of Arduino Nano (you can choose other PWM-capable pins).
* If using a high-torque servo, power it with an '''external 5V supply''' and connect grounds together to avoid damaging the Nano</translate>
|Step_Picture_00=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1c.JPG
|Step_Picture_01=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1d.JPG
}}
{{Tuto Step
|Step_Title=<translate>Installing the Servo Library</translate>
|Step_Content=<translate>The Arduino IDE comes with a built-in '''Servo.h library'''.

* Open Arduino IDE → Go to '''Sketch > Include Library > Servo'''.
* This library simplifies sending PWM signals to the servo.
<syntaxhighlight lang="c">
#include <Servo.h>

Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0; // variable to store the servo position

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(10); // waits 15 ms for the servo to reach the position
}
for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(10); // waits 15 ms for the servo to reach the position
}
}
</syntaxhighlight><br /></translate>
|Step_Picture_00=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1e.JPG
}}
{{Tuto Step
|Step_Title=<translate>Uploading the Code</translate>
|Step_Content=<translate>* Connect Arduino Nano to your PC via USB.
* Select '''Tools > Board > Arduino Nano'''.

* Choose the correct '''Port'''.

* Click '''Upload'''.
* The servo should start sweeping back and forth.</translate>
|Step_Picture_00=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1f.JPG
}}
{{Tuto Step
|Step_Title=<translate>Testing and Troubleshooting</translate>
|Step_Content=<translate>* If the servo '''jitters''', provide external power.
* Ensure '''common ground''' between Arduino and external supply.
* If the servo doesn’t move, check wiring and pin assignment.
* Use <code>myServo.write(angle)</code> to set specific angles (e.g., <code>myServo.write(90)</code> for center position).

=== Expanding the Project ===

* Control servo with a '''potentiometer''' for manual angle adjustment.
* Use '''ultrasonic sensors''' to make the servo respond to distance.
* Integrate with '''Bluetooth/Wi-Fi modules''' for remote control.</translate>
}}
{{Tuto Step
|Step_Title=<translate>Conclusion</translate>
|Step_Content=<translate><section id="story">
By following these steps, you’ve successfully interfaced a servo motor with an Arduino Nano. This forms the foundation for robotics arms, pan-tilt camera systems, and countless automation projects.
</section></translate>
|Step_Picture_00=Interfacing_a_Servo_Motor_with_Arduino_Nano_a1g.JPG
}}
{{Notes
|Notes=<translate></translate>
}}
{{PageLang
|SourceLanguage=none
|IsTranslation=0
|Language=en
}}
{{Tuto Status
|Complete=Published
}}

Fichier:Interfacing a Servo Motor with Arduino Nano a1a.JPG

2025-12-20T12:09:05Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1a

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1a

Fichier:Interfacing a Servo Motor with Arduino Nano a1b.JPG

2025-12-20T12:09:04Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1b

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1b

Fichier:Interfacing a Servo Motor with Arduino Nano a1c.JPG

2025-12-20T12:09:02Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1c

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1c

Fichier:Interfacing a Servo Motor with Arduino Nano a1d.JPG

2025-12-20T12:09:00Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1d

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1d

Fichier:Interfacing a Servo Motor with Arduino Nano a1e.JPG

2025-12-20T12:08:59Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1e

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1e

Fichier:Interfacing a Servo Motor with Arduino Nano a1f.JPG

2025-12-20T12:08:58Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1f

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1f

Fichier:Interfacing a Servo Motor with Arduino Nano a1g.JPG

2025-12-20T12:08:57Z

CETECH : Interfacing_a_Servo_Motor_with_Arduino_Nano_a1g

Interfacing_a_Servo_Motor_with_Arduino_Nano_a1g

Radiation Mapper Using DFRobot Beetle ESP32-C6

2025-09-18T03:51:06Z

CETECH : Page créée avec « {{Tuto Details |Main_Picture=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm1.JPG |Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0... »

{{Tuto Details
|Main_Picture=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm1.JPG
|Main_Picture_annotation={"version":"3.5.0","objects":[{"type":"image","version":"3.5.0","originX":"left","originY":"top","left":9,"top":1,"width":767,"height":572,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.76,"scaleY":0.76,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://wikifab.org/images/c/ce/Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm1.JPG","filters":[]}],"height":450.59288537549406,"width":600}
|Licences=Attribution (CC BY)
|Description=<translate>Explore your surroundings like never before with a Geiger counter-based radiation mapper built using Beetle ESP32-C6.</translate>
|Area=Electronics
|Type=Technique
|Difficulty=Easy
|Duration=2
|Duration-type=hour(s)
|Cost=20
|Currency=USD ($)
|Tags=DFRobot, ESP32
}}
{{Introduction
|Introduction=<translate>Explore your surroundings like never before with a Geiger counter-based radiation mapper built using Beetle ESP32-C6.</translate>
}}
{{Materials
|Material=<translate></translate>
|Tools=<translate></translate>
}}
{{Tuto Step
|Step_Title=<translate>🧠 Overview</translate>
|Step_Content=<translate>In an age where invisible environmental factors matter more than ever, having personal access to real-time radiation data can be both empowering and educational. This project transforms the tiny but powerful '''Beetle ESP32-C6'''

into a '''wearable Geiger Counter''', enabling background radiation monitoring, data logging, and potential cloud integration—all in a portable form factor.

Whether you're exploring vintage collectibles, surveying urban areas, or just curious about your surroundings, this compact DIY device is a step toward environmental awareness.</translate>
|Step_Picture_00=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm2.JPG
|Step_Picture_01=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm3.JPG
}}
{{Tuto Step
|Step_Title=<translate>🧰 Components</translate>
|Step_Content=<translate></translate>
|Step_Picture_00=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm4.JPG
}}
{{Tuto Step
|Step_Title=<translate>Get PCBs for Your Projects Manufactured</translate>
|Step_Content=<translate>You must check out [https://www.pcbway.com/ PCBWAY f]or ordering PCBs online for cheap!

You get 10 good-quality PCBs manufactured and shipped to your doorstep for cheap. You will also get a discount on shipping on your first order. Upload your Gerber files onto [https://www.pcbway.com/ PCBWAY t]o get them manufactured with good quality and quick turnaround time. PCBWay now could provide a complete product solution, from design to enclosure production. Check out their online Gerber viewer function. With reward points, you can get free stuff from their gift shop. Also, check out this useful blog on PCBWay Plugin for KiCad from [https://www.pcbway.com/blog/News/PCBWay_Plug_In_for_KiCad_3ea6219c.html here. Us]ing this plugin, you can directly order PCBs in just one click after completing your design in KiCad.</translate>
|Step_Picture_00=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm5.JPG
}}
{{Tuto Step
|Step_Title=<translate>🔧 Hardware Setup</translate>
|Step_Content=<translate>=== Wiring ===
<code>Geiger Module → Beetle ESP32-C6</code>

<code>----------------------------------</code>

<code>VCC → 3.3V</code>

<code>GND → GND</code>

<code>OUT → GPIO4</code>
<blockquote>⚠️ Be cautious around the Geiger tube—it operates at ~400V and is fragile.</blockquote></translate>
|Step_Picture_00=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm6.JPG
}}
{{Tuto Step
|Step_Title=<translate>🖥️ Arduino IDE Configuration</translate>
|Step_Content=<translate>Install '''ESP32-C6 board support''': Add this URL to Board Manager: <code><nowiki>https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json</nowiki></code>

Select the board: <code>Beetle ESP32-C6 → Partition Scheme: “Minimal SPIFFS (Large App)”</code>

Install '''DFRobot_Geiger''' library via Library Manager or from this [https://github.com/cdjq/DFRobot_Geiger GIT Repo].</translate>
|Step_Picture_00=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm7.JPG
|Step_Picture_01=Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm8.JPG
}}
{{Tuto Step
|Step_Title=<translate>🧪 Arduino Code</translate>
|Step_Content=<translate><syntaxhighlight lang="c++">
#include <DFRobot_Geiger.h>
#define detect_pin 4
DFRobot_Geiger geiger(detect_pin);

void setup() {
Serial.begin(115200);
geiger.start(); // Start counting
}

void loop() {
delay(3000);
Serial.print("CPM: ");
Serial.println(geiger.getCPM());
Serial.print("µSv/h: ");
Serial.println(geiger.getuSvh());
}
</syntaxhighlight>CPM = Counts Per Minute µSv/h = Radiation dose rate (safe background levels are usually 0.05–0.2 µSv/h)</translate>
}}
{{Tuto Step
|Step_Title=<translate>📦 Real-World Use Cases</translate>
|Step_Content=<translate>🔬 Ph'''ysics Demos –''' Quick hands-on tool for teaching radiation in schools.

🧱 An'''tique & Gem Scans –''' Detect hidden radioactive elements in old items or minerals.

🌆 Ur'''ban Mapping –''' Log background levels in metro stations or granite-rich zones.

🚨 Em'''ergency Monitoring –''' Lightweight safety gear for post-disaster areas.

🏠 Ho'''me Check –''' Scan tiles, marble, and powders for elevated readings.

🛰️ Co'''smic Ray Tracker–''' Capture fluctuations during hikes or balloon launches.</translate>
}}
{{Tuto Step
|Step_Title=<translate>🚀 Optional Enhancements</translate>
|Step_Content=<translate>* 📍 GP'''S Logging:''' Pair with a GPS module to create timestamped radiation maps
* ☁️ '''Wi-Fi Uploads''': Send readings to Qubitro or ThingSpeak dashboards
* 🧾 Te'''legram Bot:''' Trigger measurement and get results remotely
* 🖥️ OL'''ED Display:''' Add compact readouts for field use
* 🔋 So'''lar Charging:''' Combine with a small panel for outdoors</translate>
}}
{{Tuto Step
|Step_Title=<translate>📝 Final Thoughts</translate>
|Step_Content=<translate>This project leverages the versatility of the Beetle ESP32-C6 and the precision of DFRobot’s Geiger counter to create a meaningful gadget. It’s easy to build, scales well with wireless/cloud modules, and makes environmental sensing more accessible to hobbyists, educators, and citizen scientists alike.</translate>
}}
{{Tuto Step
|Step_Title=<translate>🚀 Optional Enhancements</translate>
|Step_Content=<translate>* 📍 GP'''S Logging:''' Pair with a GPS module to create timestamped radiation maps
* ☁️ '''Wi-Fi Uploads''': Send readings to Qubitro or ThingSpeak dashboards
* 🧾 Te'''legram Bot:''' Trigger measurement and get results remotely
* 🖥️ OL'''ED Display:''' Add compact readouts for field use
* 🔋 So'''lar Charging:''' Combine with a small panel for outdoors</translate>
}}
{{Tuto Step
|Step_Title=<translate>📝 Final Thoughts</translate>
|Step_Content=<translate>This project leverages the versatility of the Beetle ESP32-C6 and the precision of DFRobot’s Geiger counter to create a meaningful gadget. It’s easy to build, scales well with wireless/cloud modules, and makes environmental sensing more accessible to hobbyists, educators, and citizen scientists alike.</translate>
}}
{{Notes
|Notes=<translate></translate>
}}
{{PageLang
|SourceLanguage=none
|IsTranslation=0
|Language=en
}}
{{Tuto Status
|Complete=Published
}}

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm2.JPG

2025-09-16T18:49:17Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm2

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm2

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm1.JPG

2025-09-16T18:49:17Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm1

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm1

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm3.JPG

2025-09-16T18:49:16Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm3

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm3

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm4.JPG

2025-09-16T18:49:15Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm4

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm4

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm5.JPG

2025-09-16T18:49:14Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm5

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm5

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm6.JPG

2025-09-16T18:49:13Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm6

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm6

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm8.JPG

2025-09-16T18:49:12Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm8

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm8

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm7.JPG

2025-09-16T18:49:12Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm7

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm7

Fichier:Radiation Mapper Using DFRobot Beetle ESP32-C6 rm9.JPG

2025-09-16T18:49:11Z

CETECH : Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm9

Radiation_Mapper_Using_DFRobot_Beetle_ESP32-C6_rm9