SENSORS/ACTUATORS

INTERNET OF THING (IoT)

Arduino UNO Q - Telegram Bot

Arduino UNO Q - OpenClaw

Arduino UNO Q - ACS712 Current Sensor

How much current does your motor really pull? And what if it gets stuck and the current shoots up? The ACS712 sensor lets the Arduino UNO Q read the current of a load in amps. Then the Linux side of the board can send you a Telegram message the moment the load is overloaded.

In this tutorial, you will learn:

How the ACS712 turns current into a voltage the MCU can read
Why the UNO Q needs a small voltage divider between the sensor and its 3.3V analog pin
How to program the MCU (C/C++) to measure DC current, with zero calibration at startup
How to share the current value with the Linux side (Python) via Bridge
How to get a Telegram alert when the current goes above 2 A (overload or a stalled motor)
How to measure AC current (RMS)
How to use OpenClaw on Arduino UNO Q with the ACS712

Hardware Preparation

1	×	Arduino UNO Q
1	×	USB Cable for Arduino Uno Q
1	×	ACS712 30A Current Sensor Module
1	×	10kΩ Resistor and 1
1	×	12V DC Device (e.g. 12V DC Motor)
1	×	Optionally, 12V DC Device (e.g. 12V LED Strip)
1	×	12V Power Adapter
1	×	DC Power Jack
1	×	Breadboard
1	×	Jumper Wires
1	×	Recommended: Screw Terminal Block Shield for Arduino Uno
1	×	Recommended: Sensors/Servo Expansion Shield for Arduino Uno
1	×	Recommended: Breadboard Shield for Arduino Uno
1	×	Recommended: Enclosure for Arduino Uno
1	×	Recommended: Prototyping Base Plate & Breadboard Kit for Arduino UNO

Or you can buy the following kits:

DIYables Sensor Kit (18 sensors/displays)

Disclosure: Some of the links provided in this section are Amazon affiliate links. We may receive a commission for any purchases made through these links at no additional cost to you.
Additionally, some of these links are for products from our own brand, DIYables .

Overview of the ACS712 Current Sensor

The ACS712 from Allegro measures current with the Hall effect. The current goes through a thick copper path inside the chip. This makes a small magnetic field, and a Hall sensor next to the path turns the field into a voltage. The load side and the Arduino side are not connected by any wire (2.1 kV RMS isolation), and the copper path is only about 1.2 mΩ, so the sensor hardly changes your circuit.

The module has two sides:

3-pin header (to the Arduino UNO Q):

VCC: 5V power. The chip needs 4.5V to 5.5V — 3.3V is not enough.
GND: Ground (0V)
OUT: Analog voltage that shows the current

2-pin screw terminal (to the load): IP+ and IP−. It goes in series with the load: cut one supply wire of the load and put the terminal in between. Current that flows from IP+ to IP− gives a positive reading.

The red LED on the module only shows that it has power.

	ACS712 30A
Chip	ACS712ELCTR-30A-T
Supply Voltage	5V (4.5V to 5.5V)
Measuring Range	−30 A to +30 A (DC and AC)
Sensitivity	66 mV per amp
Output at 0 A	about 2.5V (half of VCC)
Bandwidth	80 kHz
Total Output Error	about ±1.5% at 25°C
Isolation	2.1 kV RMS

The same chip comes in three versions. They differ only in range and sensitivity:

Version	Range	Sensitivity
ACS712 5A	±5 A	185 mV/A
ACS712 20A	±20 A	100 mV/A
ACS712 30A (this tutorial)	±30 A	66 mV/A

From Volts to Amps

At 0 A the output sits near 2.5V. Current one way pushes it up, the other way pulls it down — 66 mV for every amp:

+30 A: 2.5 + 30 × 0.066 ≈ 4.48V
0 A: about 2.5V
−30 A: 2.5 − 30 × 0.066 ≈ 0.52V

So the formula is:

$$current\,(A) = \frac{V_{out} - V_{zero}}{0.066}$$

$V_{zero}$ is the real output at 0 A. It is rarely exactly 2.5V, so the code measures it at startup while no current flows.

※ NOTE THAT:

Small currents: the 30A version is made for loads of about 0.5 A and up — motors, lamps, LED strips, heaters, chargers. On the Arduino UNO Q, one ADC step is about 18 mA, and the sensor itself has some noise, so a reading of ±0.05 to 0.1 A with nothing connected is normal. Averaging many readings, as the code does, makes the value much calmer.

※ NOTE THAT:

Safety: mains AC (110V/220V) can kill. Practice with a low-voltage DC load like the 12V DC device in this tutorial. The screw terminal and the copper side carry the full voltage of the load — never touch them while a mains circuit is live.

Wiring Diagram

The Arduino UNO Q MCU (STM32U585) reads analog pins from 0V to 3.3V only. The ACS712 runs at 5V and its OUT pin can go up to about 4.5V. That is too high for A0. A simple divider fixes this: OUT → 10kΩ → A0 → 20kΩ → GND. A0 now sees 2/3 of the output (4.5V becomes 3.0V), and the code multiplies by 1.5 to get the real value back.

This image is created using Fritzing. Click to enlarge image

Sensor side (low voltage):

ACS712 Pin	Arduino UNO Q MCU
VCC	5V
GND	GND
OUT	10kΩ resistor → A0
(A0)	20kΩ resistor → GND

Load side (12V):

From	To
12V adapter (+) via DC power jack	ACS712 IP+
ACS712 IP−	DC device (+)
DC device (−)	12V adapter (−) via DC power jack

The 12V circuit does not need to share ground with the Arduino UNO Q — the sensor keeps the two sides apart.

How To Program For ACS712

No library is needed. These are the key steps:

Use the 12-bit ADC (0–4095, 3.3V reference) and set the sensor constants:

analogReadResolution(12); const float ADC_VREF = 3.3; const float ADC_STEPS = 4096.0; const float DIVIDER_RATIO = 1.5; // 10k/20k divider const float SENSITIVITY = 0.066; // 30A version

Average many readings and turn the result back into the sensor's OUT voltage:

long sum = 0; for (int i = 0; i < 200; i++) { sum += analogRead(A0); } float sensor_voltage = (sum / 200.0) * ADC_VREF / ADC_STEPS * DIVIDER_RATIO;

At startup, with the load OFF, store the zero point (the code averages 1000 readings here):

zero_voltage = readSensorVoltage(1000);

Convert to amps:

float current = (sensor_voltage - zero_voltage) / SENSITIVITY;

Arduino UNO Q Code

The Arduino UNO Q has two processors:

The STM32 MCU reads the ACS712 on pin A0
The Qualcomm MPU runs Debian Linux and has Wi-Fi
Here only the MCU runs code. The Bridge section later gives the current value to Linux.

This sketch measures DC current. It finds the zero point once, then prints the sensor voltage and the current every 500 ms.

/* * This Arduino UNO Q code was developed by newbiely.com * * This Arduino UNO Q code is made available for public use without any restriction * * For comprehensive instructions and wiring diagrams, please visit: * https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-acs712-current-sensor */ // Arduino UNO Q - ACS712 30A Current Sensor: measure DC current // Sensor VCC -> 5V, GND -> GND. // Sensor OUT can reach about 4.5V, but the UNO Q MCU pins accept only 0-3.3V, // so OUT goes through a divider: OUT -> 10k -> A0 -> 20k -> GND (pin sees 2/3 of OUT). // Switch the load OFF while the board starts: the sketch measures the zero point then. #define CURRENT_PIN A0 const float ADC_VREF = 3.3; // MCU ADC reference voltage const float ADC_STEPS = 4096.0; // 12-bit ADC (0-4095) const float DIVIDER_RATIO = 1.5; // (10k + 20k) / 20k: undo the voltage divider const float SENSITIVITY = 0.066; // 30A version: 66 mV per amp const int SAMPLES = 200; // readings averaged for each value float zero_voltage = 2.5; // sensor output at 0 A, measured in setup() // Average many readings and return the voltage on the sensor's OUT pin float readSensorVoltage(int count) { long sum = 0; for (int i = 0; i < count; i++) { sum += analogRead(CURRENT_PIN); delayMicroseconds(100); } float pin_voltage = (sum / (float)count) * ADC_VREF / ADC_STEPS; return pin_voltage * DIVIDER_RATIO; } void setup() { Serial.begin(115200); delay(1500); analogReadResolution(12); // STM32 on UNO Q: 0-4095 Serial.println("Arduino UNO Q ACS712 - keep the load OFF, finding the zero point..."); zero_voltage = readSensorVoltage(1000); Serial.print("Zero point: "); Serial.print(zero_voltage, 3); Serial.println(" V - you can switch the load on now"); } void loop() { float sensor_voltage = readSensorVoltage(SAMPLES); float current = (sensor_voltage - zero_voltage) / SENSITIVITY; Serial.print("OUT: "); Serial.print(sensor_voltage, 3); Serial.print(" V | Current: "); Serial.print(current, 2); Serial.println(" A"); delay(500); }

Detailed Instructions

First time with Arduino UNO Q? Read Getting Started with Arduino UNO Q first.

Wire: Build the circuit from the wiring diagram. Check the 10kΩ/20kΩ divider twice — A0 must never get the raw OUT signal.
Load OFF: Leave the 12V adapter unplugged for now.
Open Arduino App Lab: Wait until it detects your Arduino UNO Q.
Create a new App: Click Create New App.

Create New App in Arduino App Lab on Arduino UNO Q

Name it ACS712Current and click Create.

Arduino App Lab App folders and files on Arduino UNO Q

Paste the sketch: Put the code above into sketch/sketch.ino. No library is needed.
Run: Click the Run button.

Click Run button in Arduino App Lab on Arduino UNO Q

Wait for "Zero point": Then plug in the 12V adapter so the DC device turns on.
Test it: If your DC device is a motor, gently slow its shaft with your fingers (a short moment only) — the current goes up.

App Lab Console Output

sketch.ino

1#include "Arduino_RouterBridge.h"

Serial Monitor

Python

Message (Enter to send a message to "Newbiely" on usb(2820070321))

[2026-10-10 09:12:01] Arduino UNO Q ACS712 - keep the load OFF, finding the zero point... [2026-10-10 09:12:02] Zero point: 2.487 V - you can switch the load on now [2026-10-10 09:12:02] OUT: 2.490 V | Current: 0.05 A [2026-10-10 09:12:03] OUT: 2.484 V | Current: -0.05 A [2026-10-10 09:12:05] OUT: 2.538 V | Current: 0.77 A [2026-10-10 09:12:06] OUT: 2.545 V | Current: 0.88 A [2026-10-10 09:12:06] OUT: 2.541 V | Current: 0.82 A [2026-10-10 09:12:07] OUT: 2.574 V | Current: 1.32 A [2026-10-10 09:12:08] OUT: 2.543 V | Current: 0.85 A

The first lines are the idle noise with the DC device off. With a 12V DC motor as the DC device, it starts at about 0.8 A, and 1.32 A is the moment the shaft was slowed by hand. A negative value means the current flows from IP− to IP+ — swap the two load wires if you want positive numbers.

Bridge: Linux + MCU

Now let the Linux side read the current:

The ACS712 is wired to the MCU's analog pin A0 — the MPU has no way to read it directly
The MCU measures the current every 500 ms and keeps the latest value in memory
It shares that value with Bridge.provide("get_current", ...)
Python calls Bridge.call("get_current") and gets the cached value at once — the callback never waits for the ADC
⚠️ /dev/ttyHS1 (Linux) and Serial1 (MCU) are RESERVED by the router — never open them in user code

In short: MCU averages 200 readings → stores the amps → Python asks over Bridge → Linux can log it or send it online.

MCU Code (Bridge)

/* * This Arduino UNO Q code was developed by newbiely.com * * This Arduino UNO Q code is made available for public use without any restriction * * For comprehensive instructions and wiring diagrams, please visit: * https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-acs712-current-sensor */ // Arduino UNO Q - ACS712 30A current sensor shared with Linux via Bridge // The MCU measures the current every 500 ms and keeps the latest value. // Linux (Python) reads it with Bridge.call("get_current"). // Wiring: VCC -> 5V, GND -> GND, OUT -> 10k -> A0 -> 20k -> GND // Keep the load OFF while the board starts (zero point calibration). #include "Arduino_RouterBridge.h" #define CURRENT_PIN A0 const float ADC_VREF = 3.3; // MCU ADC reference voltage const float ADC_STEPS = 4096.0; // 12-bit ADC (0-4095) const float DIVIDER_RATIO = 1.5; // undo the 10k/20k divider const float SENSITIVITY = 0.066; // 30A version: 66 mV per amp const int SAMPLES = 200; float zero_voltage = 2.5; // measured at startup with the load OFF float cached_current = 0.0; // latest current in amps unsigned long last_read_ms = 0; float readSensorVoltage(int count) { long sum = 0; for (int i = 0; i < count; i++) { sum += analogRead(CURRENT_PIN); delayMicroseconds(100); } return (sum / (float)count) * ADC_VREF / ADC_STEPS * DIVIDER_RATIO; } // Read-only callback: returns the cached value, never waits for the ADC String get_current(String arg) { return String(cached_current, 2); } void setup() { Bridge.begin(); Monitor.begin(); analogReadResolution(12); zero_voltage = readSensorVoltage(1000); // the load must be OFF here Bridge.provide("get_current", get_current); Monitor.println("Arduino UNO Q ACS712 Bridge ready - zero point " + String(zero_voltage, 3) + " V"); } void loop() { unsigned long now = millis(); if (now - last_read_ms >= 500) { last_read_ms = now; cached_current = (readSensorVoltage(SAMPLES) - zero_voltage) / SENSITIVITY; } }

Python Code (Bridge)

Detailed Instructions

Create a new App in Arduino App Lab, for example ACS712Bridge.
Paste the MCU sketch into sketch/sketch.ino, and add the library:

Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.

Add sketch library in Arduino App Lab on Arduino UNO Q

Search for Arduino_RouterBridge created by Arduino and click the Install button.

My Apps

Examples

Bricks

AI Models

Learn

Settings

My Apps / DIYables Apps

Run

Bricks

No bricks added...

Sketch Libraries

No sketch libra...

Files

python

sketch

.gitignore

README.md

app.yaml

sketch.ino

Paste the Python code into the Python file of the same App.
Keep the load OFF, click the Run button, and switch the load on after the MCU prints "ready".

App Lab Console Output

sketch.ino

1#include "Arduino_RouterBridge.h"

Serial Monitor

Python

Message (Enter to send a message to "Newbiely" on usb(2820070321))

[2026-10-10 09:30:00] Arduino UNO Q ACS712 Bridge ready - zero point 2.491 V

sketch.ino

1#include "Arduino_RouterBridge.h"

Serial Monitor

Python

[2026-10-10 09:30:02] Current: 0.04 A (load OFF) [2026-10-10 09:30:03] Current: -0.02 A (load OFF) [2026-10-10 09:30:04] Current: 0.91 A (load ON) [2026-10-10 09:30:05] Current: 0.86 A (load ON) [2026-10-10 09:30:06] Current: 0.89 A (load ON)

A jammed motor pulls much more current than a free-running one, and it gets hot fast. This bot watches the current and sends one message when it goes above 2.0 A. When the current falls under 1.5 A again, it sends an "all clear". The gap between the two numbers stops a flood of messages when the value sits near the limit.

MCU sketch: Keep the same MCU sketch from the Bridge section.

Python Code (Telegram)

""" This Arduino UNO Q script was developed by newbiely.com This Arduino UNO Q script is made available for public use without any restriction For comprehensive instructions and wiring diagrams, please visit: https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-acs712-current-sensor """ from arduino.app_utils import * import requests import time TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN" CHAT_ID = "YOUR_CHAT_ID" API_URL = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}" CURRENT_ALERT_A = 2.0 # above this: overload, or the motor is stalled CURRENT_CLEAR_A = 1.5 # below this: back to normal (the gap stops repeat alerts) last_update_id = 0 overload_active = False def get_updates(): try: resp = requests.get(f"{API_URL}/getUpdates", params={"offset": last_update_id + 1, "timeout": 5}, timeout=10) data = resp.json() if data.get("ok"): return data["result"] except Exception as e: print(f"Error getting updates: {e}") return [] def send_message(chat_id, text): try: requests.post(f"{API_URL}/sendMessage", data={"chat_id": chat_id, "text": text}, timeout=10) except Exception as e: print(f"Error sending message: {e}") def check_overload(): global overload_active try: current = abs(float(Bridge.call("get_current"))) except ValueError: return if current > CURRENT_ALERT_A and not overload_active: overload_active = True msg = f"⚠️ Current is {current:.2f} A - overload! Is the motor stalled?" print(msg) send_message(CHAT_ID, msg) elif current < CURRENT_CLEAR_A and overload_active: overload_active = False msg = f"✅ Current is back to {current:.2f} A - normal again." print(msg) send_message(CHAT_ID, msg) def loop(): global last_update_id check_overload() for update in get_updates(): last_update_id = update["update_id"] if "message" not in update: continue chat_id = update["message"]["chat"]["id"] text = update["message"].get("text", "").strip() print(f"Received: {text}") if text == "/current": send_message(chat_id, f"Current: {Bridge.call('get_current')} A") else: send_message(chat_id, "Arduino UNO Q Current Bot\n" "/current - load current in amps\n" f"Auto alert when the current goes above {CURRENT_ALERT_A} A.") time.sleep(1) App.run(user_loop=loop)

Detailed Instructions

Replace YOUR_TELEGRAM_BOT_TOKEN with your bot token from BotFather. New to bots? See How to Create a Telegram Bot.
Replace YOUR_CHAT_ID with your Telegram chat ID — alerts go there.
Paste this code into the Python file of your App (keep the Bridge MCU sketch).
Click Run, then send /current to your bot.
Pick the limit for your own load: measure its normal current first, then set CURRENT_ALERT_A a bit above it (and CURRENT_CLEAR_A a little lower).

App Lab Console Output

sketch.ino

1#include "Arduino_RouterBridge.h"

Serial Monitor

Python

[2026-10-10 11:05:14] Received: /current [2026-10-10 11:07:40] ⚠️ Current is 2.37 A - overload! Is the motor stalled? [2026-10-10 11:07:52] ✅ Current is back to 0.93 A - normal again. [2026-10-10 11:08:10] Received: /current

ArduinoBot

bot

Today

/current

10:15 AM ✓✓

Current: 0.87 A

10:16 AM

⚠️ Current is 2.37 A - overload! Is the motor stalled?

10:17 AM

✅ Current is back to 0.93 A - normal again.

10:18 AM

/current

10:19 AM ✓✓

Current: 0.90 A

10:20 AM

Measuring AC Current

The ACS712 can also measure AC current, but AC changes direction many times per second (50 or 60 Hz). A single reading lands anywhere on the wave, so it tells you nothing. Instead, the code samples for 200 ms (10 to 12 full cycles) and calculates the RMS value — the "effective" current that a clamp meter shows:

$$I_{RMS} = \frac{\sqrt{mean\big((V - V_{zero})^2\big)}}{0.066}$$

The wiring on the Arduino side is the same. The screw terminal goes in series with one wire of the AC load.

※ NOTE THAT:

Danger: this means working with mains voltage. If you are not trained for it, stop here or use a ready-made, closed power-monitor device. Never touch the screw terminal, the module, or loose wires while the plug is in the socket.

Arduino UNO Q Code — AC Current (RMS)

/* * This Arduino UNO Q code was developed by newbiely.com * * This Arduino UNO Q code is made available for public use without any restriction * * For comprehensive instructions and wiring diagrams, please visit: * https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-acs712-current-sensor */ // Arduino UNO Q - ACS712 30A Current Sensor: measure AC current (RMS) // Same wiring as the DC sketch: VCC -> 5V, GND -> GND, OUT -> 10k -> A0 -> 20k -> GND. // AC current keeps changing direction, so we sample for 200 ms // (10 cycles at 50 Hz, 12 cycles at 60 Hz) and compute the RMS value. // Switch the load OFF while the board starts: the sketch measures the zero point then. #define CURRENT_PIN A0 const float ADC_VREF = 3.3; // MCU ADC reference voltage const float ADC_STEPS = 4096.0; // 12-bit ADC (0-4095) const float DIVIDER_RATIO = 1.5; // (10k + 20k) / 20k: undo the voltage divider const float SENSITIVITY = 0.066; // 30A version: 66 mV per amp const unsigned long WINDOW_MS = 200; // sampling window float zero_voltage = 2.5; // sensor output at 0 A, measured in setup() // Voltage on the sensor's OUT pin for one ADC value float toSensorVoltage(float adc_value) { return adc_value * ADC_VREF / ADC_STEPS * DIVIDER_RATIO; } void setup() { Serial.begin(115200); delay(1500); analogReadResolution(12); // STM32 on UNO Q: 0-4095 Serial.println("Arduino UNO Q ACS712 AC - keep the load OFF, finding the zero point..."); long sum = 0; for (int i = 0; i < 1000; i++) { sum += analogRead(CURRENT_PIN); delayMicroseconds(100); } zero_voltage = toSensorVoltage(sum / 1000.0); Serial.print("Zero point: "); Serial.print(zero_voltage, 3); Serial.println(" V"); } void loop() { double square_sum = 0; long count = 0; unsigned long start = millis(); // Collect samples for the whole window while (millis() - start < WINDOW_MS) { float diff = toSensorVoltage(analogRead(CURRENT_PIN)) - zero_voltage; square_sum += diff * diff; count++; } // RMS voltage around the zero point, then convert it to amps float rms_voltage = sqrt(square_sum / count); float rms_current = rms_voltage / SENSITIVITY; Serial.print("AC current (RMS): "); Serial.print(rms_current, 2); Serial.println(" A"); delay(300); }

Detailed Instructions

Keep the load unplugged, replace the code in sketch/sketch.ino with the sketch above, and click Run.
After "Zero point" appears, switch on the AC load.

App Lab Console Output

sketch.ino

1#include "Arduino_RouterBridge.h"

Serial Monitor

Python

Message (Enter to send a message to "Newbiely" on usb(2820070321))

[2026-10-10 15:20:01] Arduino UNO Q ACS712 AC - keep the load OFF, finding the zero point... [2026-10-10 15:20:02] Zero point: 2.493 V [2026-10-10 15:20:02] AC current (RMS): 0.07 A [2026-10-10 15:20:03] AC current (RMS): 0.06 A [2026-10-10 15:20:04] AC current (RMS): 4.31 A [2026-10-10 15:20:04] AC current (RMS): 4.36 A [2026-10-10 15:20:05] AC current (RMS): 4.33 A

Here a 1000 W kettle on 230V was switched on (1000 / 230 ≈ 4.35 A). With no load, the RMS value never reaches exactly 0 — the 0.06 to 0.07 A is sensor noise.

OpenClaw

You can adapt the OpenClaw to this tutorial by refering the instruction on Arduino Uno Q - OpenClaw Tutorial

Project Ideas

Ideas that use the ACS712 with both processors of the Arduino UNO Q:

Motor Stall Guard: Switch a 12V motor through a relay and cut its power when the current stays above the limit for more than one second
Battery Charger Log: Python records the charging current every minute to a CSV file and sends a Telegram message when it drops low (battery full)
Power Use Report: Multiply current by the supply voltage to get watts, add it up on the Linux side, and send a daily watt-hour summary
3D Printer Watch: Follow the heater current of a 12V/24V printer and get a message when a print ends (current drops) or a heater stays on too long
Appliance "Done" Notifier: With a trained person's help on the mains wiring, detect when a washing machine stops pulling current and send "laundry is done"

Challenge Yourself

Ready to go further with the ACS712 on Arduino UNO Q? Try these:

Easy: Turn on the built-in LED in the MCU sketch while the current is above 1 A.
Medium: Make the Python Bridge script keep the highest current since startup and print it next to every reading.
Advanced: Add a /power Telegram command that uses the 12V supply value to report watts, plus the watt-hours used since the script started.

Learn More

Arduino UNO Q - PC817 Optocoupler: Monitor 12V/24V DC Input Signal

※ OUR MESSAGES

As freelancers, We are AVAILABLE for HIRE. See how to outsource your project to us
Please feel free to share the link of this tutorial. However, Please do not use our content on any other websites. We invested a lot of effort and time to create the content, please respect our work!