Hey, Note: UNO R3 supports 8-bit PWM resolution, not 10. Higher resolution means the PWM output can be more finely tuned, resulting in a smoother signal. This is particularly important in applications like motor control, LED dimming, and audio signal generation. 8-bit resolution means there are 256 possible Duty cycle values (from 0 to 255). That's why the analogWrite(PWM pin, PWM value) takes values bw 0 and 255. In this case, increasing the Duty cycle step by step corresponds to a change of approximately 0.4% (1/256) of the full-scale value. Whereas the 16-bit resolution means there are 65,536 possible Duty cycle values (from 0 to 65,535).Each step in the Duty cycle corresponds to a change of approximately 0.0015% (1/65,536) of the full-scale value. As much as the resolution is important, so does the frequency of the PWM signal. The increase in PWM resolution decreases the maximum PWM frequency possible for the same clock frequency. if UNO and ESP32 have the same clock frequency i.e., 16 MHZ. The maximum possible PWM frequency(16-bit) for ESP32 will only be 244 Hz. Whereas for UNO(8-bit), it is 62.5 KHz. For example, 16 MHz / 256 and 16 MHz / 65,536. EDIT: Hey everyone! Let’s clear up the confusion regarding PWM resolution and the difference between dividing by 2^n versus 2^n - 1 The Hardware Timer Perspective In fast PWM mode, the timer counts from 0 up to a “TOP” value and then overflows back to 0. For 8-bit PWM, TOP = 255. This gives you a counter range of 0–255 = 256 distinct counts. For 2-bit PWM, TOP = 3. This gives you a counter range of 0–3 = 4 distinct counts. Thus, in terms of raw timer ticks, there are 2^n counts per cycle. The Duty Cycle Perspective When calculating Duty cycle, we typically use: Duty Cycle (%)= (Compare Register Value/TOP) ×100. For 8-bit PWM, you divide by 255 (TOP = 255), so the highest compare value 255 yields 100 % Duty cycle. For 2-bit PWM, you divide by 3 (TOP = 3), so a compare value of 3 yields 100 % Duty cycle. If you were to divide by 2^n directly (e.g., 256 for 8-bit), the maximum compare value (255) would give (255/256)x 100 =~ 99.6% which technically matches clock ticks but doesn’t align with the usual definition of 100 % on hardware PWM outputs. Why It Matters 0 % Duty cycle: Compare Register = 0. 100 % Duty cycle: Compare Register = TOP (which is 2^n - 1). Users generally expect that the maximum compare setting translates to the output being fully ON (i.e., 100 %). Summary The timer truly counts 2^n steps (from 0 to 2^n−1). However, to get a Duty cycle percentage from 0 % to 100 %, you divide the compare value by 2^n - 1. That’s why for 8-bit PWM, you’ll see many references to dividing by 255, not 256.

Hello paul, In Arduino, the analogWrite function is used to generate a PWM signal on a specified pin. The value parameters ranging from (0-255) you provide determines the Duty cycle of the PWM signal. Value of 0: This means the pin is always off (0% Duty cycle). Value of 255: This means the pin is always on (100% Duty cycle). Values between 0 and 255: These values correspond to Duty cycles between 0% and 100%. For example, a value of 127 would create a 50% Duty cycle. This allows for precise control of analog devices, such as LEDs or motors, using digital signals.

@ankunegi The answer is on point but I think there's a mistake in your calculation. To calculate the Duty cycle, we have to divide it by 255(the maximum value) and not 256(The total no. of steps). For example: A 2-bit PWM signal has 4 possible steps: 0,1,2 and 3 corresponding to 0%, 33.33%, 66.67% and 100% Duty cycle. You get this by dividing by 3, not 4. If you divide it by 4, you will get 25%. Which means 0%, 25%, 50% and 75%. See, you are not getting 100% Duty cycle in this case.

To the point answer by Techtalks. Just WAnt to add one important point here: The PWM pins on UNO have an 8-bit resolution. This gives us 256 discrete Duty cycles, since 2^8 = 256. Example: 2 bit means 4 possible Duty cycles. For PWM, they would be: 0, 33.33%, 66.66%, and 100%. Similarly, 4-bit means 16 Duty cycles, and 8-bit means 256 cycles. Now why does the PWM range from 0 to 255 and not 256? Because when you count 0, the total values from 0 to 255 are 256.

CoAP (Constrained Application Protocol) is designed specifically for resource-constrained IoT devices and networks. It’s preferred over HTTP because it’s Lightweight, uses UDP (not TCP), and has lower overhead, making it ideal for low-power devices and lossy networks. Compared to MQTT, CoAP is better for request/response models and supports multicast and built-in resource discovery. It’s commonly used in constrained environments like smart homes, industrial sensors, or low-power mesh networks.

Yes, you can hook these pins to the PWM pin on Arduino. The Enable pin on the L298N acts as a gatekeeper for the power supplied to the motor. When the pin is set HIGH, the motor is enabled and can run. When set LOW, the motor is disabled and stops. By connecting the Enable pin to a PWM-capable pin on the Arduino and sending a PWM signal, you can control the effective voltage supplied to the motor. This changes the speed of the motor: A higher Duty cycle (e.g., 100%) means the Enable pin is HIGH most of the time, allowing full power to the motor and thus full speed.A lower Duty cycle (e.g., 50%) means the Enable pin is HIGH only half the time, reducing the average power supplied to the motor and thus reducing the speed. Here's an example that demonstrates how to set up and control the motor speed connected to A channel: // Define pins const int ENA = 9; // PWM pin for Motor A const int IN1 = 8; // Direction pin 1 for Motor A const int IN2 = 7; // Direction pin 2 for Motor A void setup() { // Set pin modes pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); } void loop() { // Set motor direction digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); // Set motor speed using PWM analogWrite(ENA, 127); // 50% Duty cycle, half speed delay(2000); // Run for 2 seconds // Change motor speed analogWrite(ENA, 255); // 100% Duty cycle, full speed delay(2000); // Run for 2 seconds

I’ve tested all three — Raspberry Pi OS, Ubuntu, and DietPi — and honestly, each one has its strengths depending on what you’re trying to do. If you're using a lower-end model like the Pi 3 or Zero, DietPi is a beast in terms of performance. It's super Lightweight and boots fast, with very minimal background processes. Great for headless or server-style setups. Raspberry Pi OS is the most balanced in my opinion. It’s stable, well-supported, and has excellent compatibility with GPIO, camera modules, and most accessories. Plus, it’s officially maintained by the Pi Foundation, so updates and long-term support are pretty solid. Ubuntu (especially Server) is decent, but I’ve found it to be a bit heavier on Pi 3 and not ideal for Zero. It works better on Pi 4, and is nice if you're already used to Ubuntu on desktops or other servers. That said, sometimes peripherals or GPIO need extra tweaks to work smoothly. In terms of ease of use — Pi OS with Desktop is very beginner-friendly. DietPi is command-line based but has a great first-boot installer that lets you choose only what you need, so it’s pretty efficient. Ubuntu is more for those who are already comfortable with Linux. For community and support, Pi OS is the winner. Tons of tutorials, help forums, and guides tailored specifically to the Pi. DietPi and Ubuntu both have good communities too, but they’re a bit more general. My personal picks: For simple or GPIO-heavy projects → Raspberry Pi OS For Lightweight, headless, or server projects → DietPi For more advanced server use on Pi 4 → Ubuntu Server Hope that helps — happy to share more if you’ve got a specific use case in mind!

Yes Arduino can do floating-point operations, but there’s a few things to keep in mind. 1. On boards like the Uno or Nano (which use the ATmega328P), it supports float and double, but the funny thing is—they’re actually the same thing. Both are 32-bit IEEE 754 floating point numbers. So don’t expect extra precision with double, it's just a float behind the scenes. 2. It can handle basic operations like addition, subtraction, multiplication, and division just fine. But it’s not super fast at it, since the 8-bit microcontrollers don’t have a floating point unit (FPU). That means it does all floating-point math in software, which can slow things down if you’re doing a lot of calculations in your loop. 3. Also, things like sin(), cos(), sqrt() and pow() work, but again, they’re kinda Heavy on processing time. So if you’re working with sensors and need to process stuff quickly, it’s sometimes better to stick with integers where possible, or scale up the values and work in "fixed point" math if you can. 4. One more thing—printing floats with Serial.print() only shows two decimal places by default. You can control that though: float pi = 3.14159; Serial.print(pi); // prints 3.14 Serial.println(pi, 4); // prints 3.1416 So yeah, Arduino can handle floats, but it’s not optimized for Heavy-duty number crunching. If you're doing more advanced math or need higher precision, better to move to something like a Teensy or a 32-bit board like the Arduino Due or even ESP32. But for basic stuff, it’s totally usable.

If you need a battery with better durability, longer lifespan, and stable power delivery, go with Li-ion—ideal for general electronics and low to moderate power applications. If your project requires high discharge rates, Lightweight design, or a flexible form factor, Li-Po is the better choice—commonly used in drones, RC vehicles, and high-performance applications. Li-ion is more stable and lasts longer, while Li-Po is more powerful but requires careful handling.

I think it’s less about “Arduino vs. ESP32” and more about picking the right tool for the job. Arduino is still fantastic for: Beginners learning electronics and coding. Quick prototypes that don’t need Wi-Fi or Heavy processing power. Reliable, simple projects like controlling LEDs or reading basic sensors. For IoT or real-time applications, ESP32 or Raspberry Pi Pico W is a better choice. But I’d say Arduino’s relevance comes from its accessibility. Many professionals started their careers with Arduino, and that familiarity keeps it in the game.

If you're just starting out with Arduino and electronics, you're definitely not alone—there are some fantastic beginner-friendly resources out there to help you get going without feeling overwhelmed. Helpful YouTube Channels Paul McWhorterOne of the best for beginners. His “Arduino Tutorial Series” is clear, structured, and goes from basics to intermediate projects. Jeremy BlumHis Arduino series is a classic and covers foundational knowledge with well-explained videos. GreatScott!Excellent for understanding how the hardware works behind your projects. Programming Electronics AcademyVery helpful if you're also interested in understanding the coding side deeply. Online Courses Worth Checking Out Udemy – "Arduino Step by Step: More than 50 Hours Complete Course" Taught by Dr. Peter Dalmaris. Very beginner-friendly and includes lifetime access to lessons and materials. Coursera – “Introduction to Programming with Arduino” Offered by University of California, Irvine. Teaches both basic electronics and coding in a structured format.

I recently found myself in a similar situation when my old laptop stopped working, so I gave my new Raspberry Pi 5 a shot as a temporary desktop replacement. For basic tasks like browsing the web, checking emails, and doing some light coding, it’s been surprisingly capable. The performance is quite decent, especially with an SSD and a good cooling setup. However, I did notice that it struggles a bit with Heavy multitasking or media-rich websites. For longer-term use, I think it really depends on your workload. If most of your tasks are browser-based or involve Lightweight applications, it’s actually a practical and cost-effective solution. That said, there are some limitations in terms of software compatibility and overall responsiveness compared to a regular desktop or laptop. I’m curious to know how others are finding the Pi 5 for daily use.

If your robot needs both real-time motor control and higher-level processing (like computer vision or LIDAR), I’d recommend a hybrid setup. Use a Teensy 4.1 (or an STM32 if you're comfortable with it) to handle motor control, encoders, and IMU. Teensy is Arduino-compatible but much faster — 600 MHz and great real-time performance. Pair it with a Jetson Nano (or Raspberry Pi if you're not doing Heavy vision tasks) for computer vision, path planning, and data logging. Jetson Nano has GPU support and is great for running Lightweight AI models or OpenCV. This combo gives you real-time performance where it matters and the flexibility of Linux for everything else. Communicate between the two using UART, I2C, or CAN depending on your latency needs. We've had good success with this kind of architecture in robotics projects using ROS. If you're using ROS2, check out micro-ROS for STM32 or rosserial for Teensy. Let me know if you need example setups or wiring tips.

... etc. Tough housing, drop-tests, high-CAT safety ratings. High accuracy, true-RMS, stable calibration. Long lifespan, support and WArranty which reduce long-term cost. If you’re replacing a hobby-meter and don’t work in Heavy Duty applications, yes you might be fine with a cheaper brand. But if you need one tool that you can trust under serious conditions, the extra cost makes sense.

I think it really depends on the type of projects you're working on. If you're mainly doing simple LED displays, motor control, or basic IoT projects, Arduino boards are perfect. They’re simple and get the job done without much hassle. But if you WAnt to dive into audio processing, real-time data acquisition, or anything that requires Heavy computation, STM32 is a beast. I switched over when I started working on a DIY oscilloscope project because I needed faster ADC and more memory.