That’s when I realized: raw sensor data is almost always noisy.

In this article, I’ll walk you through how I handle sensor noise—from the simplest filtering methods to more advanced techniques—and then I’ll give you a reusable filtering library you can drop into your projects.

Why Sensor Readings Are Noisy

Before filtering, it’s important to understand why noise exists:

• Electrical noise (power supply, EMI)
• ADC quantization errors
• Sensor imperfections
• Environmental interference

For example, even a simple potentiometer read using:

int value = analogRead(A0);

…will fluctuate slightly even if you don’t touch it.

1. The Simplest Filter: Delay-Based Stabilization

The most basic approach I used early on was just adding a delay:

int read_sensor()
{
   delay(10);
   return analogRead(A0);
}

This kind of works, but it doesn’t actually filter noise—it just slows things down. I don’t recommend relying on this except for quick tests.

2. Moving Average Filter

This is the first real filter I use in almost every project.

Idea:

Take multiple samples and average them.

Example:

#define NUM_SAMPLES 10

int moving_average_read()
{
   long sum = 0;

   for (int i = 0; i < NUM_SAMPLES; i++)
   {
      sum += analogRead(A0);
   }

   return sum / NUM_SAMPLES;
}

What it does:

• Smooths out random noise
• Reduces spikes

Tradeoff:

• Slower response (lag increases with more samples)

3. Running Average 

Instead of recalculating everything, I use a running average.

#define NUM_SAMPLES 10

int samples[NUM_SAMPLES];
int index = 0;
long total = 0;

int running_average_read()
{
   total -= samples[index];
   samples[index] = analogRead(A0);
   total += samples[index];

   index = (index + 1) % NUM_SAMPLES;

   return total / NUM_SAMPLES;
}

Why I prefer this:

• Much faster
• Works continuously
• Great for real-time systems

4. Exponential Moving Average (EMA)

This is one of my favorite filters because it’s simple and powerful.

Formula:

$filtered = alpha * newValue + (1 - alpha) * previousFiltered$

Example:

float alpha = 0.1;

float filtered_value = 0;

float ema_filter(float new_value)
{
   filtered_value = alpha * new_value + (1 - alpha) * filtered_value;
   return filtered_value;
}

Tuning:

• alpha = 0.1 → very smooth, slow response
• alpha = 0.5 → faster response, less smoothing

When I use this:

• Analog sensors (light, temperature, force)
• Real-time systems where memory is limited

5. Median Filter 

If your sensor occasionally gives crazy spikes, average filters won’t help much.

That’s where median filtering shines.

Example:

#define NUM_SAMPLES 5

int median_filter()
{
   int values[NUM_SAMPLES];

   for (int i = 0; i < NUM_SAMPLES; i++)
   {
     values[i] = analogRead(A0);
   }

   // simple sort
   for (int i = 0; i < NUM_SAMPLES - 1; i++)
   {
      for (int j = i + 1; j < NUM_SAMPLES; j++)
      {
         if (values[j] < values[i])
         {
           int temp = values[i];
           values[i] = values[j];
           values[j] = temp;
         }
      }
   }

   return values[NUM_SAMPLES / 2];
}

Why this works:

• Ignores outliers completely
• Perfect for noisy environments

6. Combining Filters 

In real projects, I rarely use just one filter.

A common combo I use:

Median filter → remove spikes
EMA → smooth the result

This gives:

• Clean signal
• Fast response
• Good stability

7. Kalman Filter 

When I first heard about Kalman filters, I thought they were only for aerospace or robotics. But once I simplified it, I realized:

A Kalman filter is just a smart way of combining prediction and measurement.

How It Works (Intuition First)

Unlike the previous filters, Kalman doesn’t just smooth data.

It does two things every cycle:

1. Predict

It estimates what the next value should be based on previous data.

2. Update

It corrects that prediction using the actual sensor reading.

Key Idea

Instead of blindly trusting the sensor:

If the sensor is noisy → trust prediction more
If the sensor is stable → trust measurement more

The filter automatically balances both

Simplified Model

We track two things:

• Estimated value
• Estimated uncertainty

Each update adjusts both.

Simple 1D Kalman Filter Code

This version is perfect for embedded systems (no matrices).

typedef struct
{
   float estimate;
   float error_estimate;
   float error_measure;
   float q; // process noise
} kalman_t;

void kalman_init(kalman_t *k, float mea_e, float est_e, float q)
{
   k->error_measure = mea_e;
   k->error_estimate = est_e;
   k->q = q;
   k->estimate = 0;
}

float kalman_update(kalman_t *k, float measurement)
{
   // Kalman gain
   float kalman_gain = k->error_estimate /
   (k->error_estimate + k->error_measure);

   // Update estimate
   k->estimate = k->estimate +
   kalman_gain * (measurement - k->estimate);

   // Update error estimate
   k->error_estimate = (1 - kalman_gain) * k->error_estimate +
   fabs(k->estimate - measurement) * k->q;

   return k->estimate;
}

What’s Happening Internally

Let’s break it down simply:

Kalman Gain

$K = \frac{errorEstimate}{(errorEstimate + errorMeasure)}$

• High K → trust measurement more
• Low K → trust prediction more

Update Step

$estimate = estimate + K * (measurement - estimate)$

This is basically:

• Take old estimate
• Move it toward the new measurement
• Amount depends on K

Example

Sensor readings:

10, 11, 50, 12, 11

Kalman output:

10 → 10.5 → 11 → 11.5 → 11.3

Notice:

• The spike (50) is heavily reduced
• Response is faster than moving average

When I Use Kalman Filter

I use it when:

• Sensor is noisy but needs fast response
• Combining sensors (e.g., IMU)
• Precision matters (robotics, control systems)

When NOT to Use It

Avoid Kalman if:

• Simple EMA already works
• You don’t want to tune parameters
• System is very resource-constrained

Practical Example: Temperature Sensor

Let’s say I’m reading a temperature sensor:

Raw: 25.1, 25.3, 24.9, 26.5, 25.0

That 26.5 is likely noise.

After median filter: 25.1, 25.3, 25.0, 25.0, 25.0

After EMA: 25.0 → 25.05 → 25.08 → stable

Now the data is usable.

A Reusable Filtering Library

Here’s a simple library I use across projects.

//filter.h

#ifndef FILTER_H
#define FILTER_H

typedef struct
{
   float alpha;
   float value;
} ema_filter_t;

void ema_init(ema_filter_t *f, float alpha);
float ema_update(ema_filter_t *f, float input);

#endif

//filter.c
#include "filter.h"

void ema_init(ema_filter_t *f, float alpha)
{
   f->alpha = alpha;
   f->value = 0;
}

float ema_update(ema_filter_t *f, float input)
{
   f->value = f->alpha * input + (1 - f->alpha) * f->value;
   return f->value;
}
Example Usage
#include "filter.h"

ema_filter_t temp_filter;

void setup()
{
   Serial.begin(9600);
   ema_init(&temp_filter, 0.1);
}

void loop()
{
   float raw = analogRead(A0);
   float filtered = ema_update(&temp_filter, raw);

   Serial.print("Raw: ");
   Serial.print(raw);
   Serial.print(" Filtered: ");
   Serial.println(filtered);

   delay(100);
}

Choosing the Right Filter

Here’s how I usually decide:

Final Thoughts

If there’s one thing I’ve learned, it’s this:

Filtering is not optional—it’s part of reading a sensor.

The difference between a “working” project and a “reliable” one often comes down to how well you handle noise.

The post Sensor Reading Filtering (Arduino & Embedded Systems) appeared first on Microcontroller Tutorials.

1. Overview of the Module

Your MH-ET Scanner board includes:

• 2D scanning engine (CMOS sensor + decoder)
• Two Micro-USB ports
  • UART USB → Virtual COM port
  • HID USB → Emulates a keyboard
• 6-pin interface block containing:
  • UART-TX / UART-RX
  • S-TX / S-RX (raw TTL UART, ideal for Arduino)
  • HID-TX / HID-RX
• Two jumper headers
  • Selects which interface connects to the scanner engine
• RST pin for hardware reset
• VCC / GND for power (5V required)

2. Understanding the 6-Pin Header & Jumper Settings

The key to using this module is understanding how data flows.

6-Pin Header (left → right)

Jumper Selection

There are two jumpers:

• UART ←→ S: Connect S-TX/RX to USB-UART chip
• HID ←→ S: Connect S-TX/RX to USB-HID chip

For Arduino, we do not use the jumpers at all — we directly wire to S-TX and S-RX, which always connect to the scanner engine.

3. Power Requirements

The scanner must be powered at 5V, not 3.3V.
At 3.3V, the LED driver and CMOS sensor do not get enough current → QR codes fail to scan.

Recommended:

• 5V / 500mA supply
• Add 100 µF capacitor across VCC–GND if using long wires

4. Wiring the Module to Arduino

Arduino UNO / Nano WIRING

S-TX → Arduino RX
S-RX → Arduino TX
(TX always goes to the other device’s RX)

5. Arduino Code (Tested & Working)

This code:

• Initializes serial communication
• Listens for decoded data
• Resets the scanner if needed
• Prints QR/barcode results to Serial Monitor

#include <SoftwareSerial.h>

#define SCANNER_RX 2   // S-TX from scanner → Arduino D2 (RX)
#define SCANNER_TX 3   // S-RX from scanner → Arduino D3 (TX)
#define RST_PIN    4   // Reset pin for scanner engine

SoftwareSerial scanner(SCANNER_RX, SCANNER_TX);

void scannerReset() {
  digitalWrite(RST_PIN, LOW);
  delay(20);
  digitalWrite(RST_PIN, HIGH);
  delay(500);  // scanner reboot time
}

void setup() {
  pinMode(RST_PIN, OUTPUT);
  digitalWrite(RST_PIN, HIGH);

  Serial.begin(9600);
  scanner.begin(9600);    // Some units use 115200

  Serial.println("Scanner ready...");
  scannerReset();
}

void loop() {
  if (scanner.available()) {
    String data = scanner.readStringUntil('\n');
    data.trim();
    if (data.length() > 0) {
      Serial.print("Scanned: ");
      Serial.println(data);
    }
  }
}

6. Confirming Baud Rate

Most units default to 9600, but some ship at 115200.

If you see:

• Random characters
• Half-printed QR values
• Nothing at all

Try:

scanner.begin(115200);

7. Reset Pin (RST) Details

The scanner’s RST pin is active LOW:

• Pull LOW 10–20 ms → module resets
• Releases HIGH → boots in ~500 ms

This is helpful if:

• Scanner stops responding
• Power dips
• Switching between HID/UART modes
• After scanning configuration QR codes

8. Testing QR & Barcode Scanning

For reliable scanning:

Use 5V power

3.3V causes QR detection to fail.

Ideal scan distance

10–20 cm away
(QR is most sensitive to focus distance.)

Best QR size

25–30 mm square

Avoid shiny screens and reflections

If scanning fails:

• Increase ambient lighting
• Move slightly farther/closer
• Try a simpler QR (Hello World)

9. Using USB Modes (Optional)

A. USB-UART Mode

Jumper UART S
Then connect UART microUSB → PC
Open PuTTY / TeraTerm, baud = 9600

B. USB-HID Mode

Jumper HID S
Then connect HID microUSB
Scanner types text like a keyboard.

10. Troubleshooting

Scanner reads no QR codes

Fix: Use 5V, not 3.3V
Fix: Correct distance (15–20 cm)

Only 1D barcodes read

Scanner may be in 1D-only mode
→ Scan configuration QR to enable 2D.

Arduino receives gibberish

Baud rate mismatch
Long wires → noise

Scanner freezes

Call

scannerReset();

11. Bonus: Auto-Recover Watchdog

If scanner becomes idle/unresponsive:

unsigned long lastScan = millis();

void loop() {
  if (scanner.available()) {
    char c = scanner.read();
    Serial.write(c);
    lastScan = millis();
  }

  if (millis() - lastScan > 7000) {
    Serial.println("Resetting scanner...");
    scannerReset();
    lastScan = millis();
  }
}

12. Testing Other Modes and Configurations

The MH-ET Live QR code scanner supports a lot of configuration options. You can switch between the options by directly scanning pre-defined QR codes. The configuration QR codes can be viewed in this document.

Finished!

You now have a complete working setup for:

• Reading QR codes
• Reading 1D barcodes
• Hardware reset via RST
• UART communication via S-TX/S-RX
• Arduino-compatible powering
• Full troubleshooting and configuration process

The post Using the MH-ET LIVE Scanner 3.0 (QR/Barcode) with Arduino appeared first on Microcontroller Tutorials.

Whenever I peel back the layers of how my Arduino boards actually work, I always end up revisiting one classic topic: CISC vs RISC.

When I first heard those terms, I honestly thought they were meant for chip architects wearing lab coats inside semiconductor fabs. But the more I built projects — robots, IoT sensors, timing-critical systems — the more I realized that understanding these architectures directly affects how my Arduino projects behave in the real world.

This guide is my attempt to explain everything the way I wish someone explained it to me years ago:
simple, real, and from the perspective of someone actually using Arduino boards daily.

No jargon walls. No engineering jargon that makes your eyes glaze over.
Just plain talk about what’s really going on under the hood.

Understanding CPU Architectures 

What Is a CPU Instruction Set?

Every time I upload a sketch to my Arduino, that human-friendly C/C++ code eventually gets translated into tiny machine instructions — microscopic tasks that the chip understands.

These instructions are things like:

• add two numbers
• compare values
• read a pin
• jump to another part of the program

The entire “dictionary” of instructions that a CPU understands is its instruction set.

Different CPU families simply have different dictionaries.
Some have a small collection of straight-to-the-point words.
Others have a huge library of fancy phrases.

That’s where RISC and CISC philosophies come from.

How Microcontrollers Actually Use Instructions

Inside the microcontroller, there’s a never-ending loop:

1. fetch an instruction
2. decode it
3. execute it
4. repeat

The style of the instruction set (CISC or RISC) affects:

• how fast each instruction runs
• how predictable the timing is
• how much power the chip consumes
• what kinds of operations the chip can perform directly

This is why architecture matters even in simple Arduino sketches — it influences everything from

digitalWrite()

What Is CISC?

I like thinking of CISC (Complex Instruction Set Computer) as the “giant toolbox” approach.

It includes lots of instructions, some of which can perform surprisingly complex operations in just a single command. A single CISC instruction might:

• load data
• modify it
• store it again

…all in one shot.

This is convenient if the programmer is working at the assembly level since one line replaces many.

Key Features of CISC 

• Large instruction set → lots of “tool shapes” for many scenarios
• Complex instructions → one instruction may do several steps
• Microcode is common → the CPU contains a small internal translator that breaks down those big instructions
• Often higher energy use → complexity has a cost

Why CISC Is Useful

I learned that CISC instructions can feel like shortcuts. You can write fewer lines of low-level code to accomplish a task. That’s why CISC dominated desktop CPUs — they needed powerful, flexible instructions.

Where CISC Falls Short

The same complexity that makes CISC powerful also slows it down. Complex instructions need more circuits to decode, and they may take multiple cycles to execute.

Battery-powered devices don’t like that.

What Is RISC?

RISC (Reduced Instruction Set Computer) is the complete opposite philosophy — a minimalist approach.

I imagine RISC as a clean, well-organized toolbox containing only the most essential tools. Nothing unnecessary. Nothing fancy. But every tool is extremely efficient.

Key Features of RISC 

• Small instruction set → fewer but faster instructions
• Each instruction does one thing → no hidden complexity
• Each instruction completes in one cycle (in many cases)
• Timing becomes predictable → perfect for robotics and real-time tasks
• High efficiency → makes RISC great for battery-powered devices

Where RISC Shines

RISC chips often outperform CISC chips at lower power because they do simple things quickly and consistently. Even when a task needs more instructions, the sheer speed of each instruction often makes up for it.

The Tradeoff

Complex tasks may require more lines of low-level code. But since Arduino hides assembly from most users, we rarely see this downside.

CISC vs RISC: How I Personally Compare Them

When I look at the two architectures, here’s how they feel:

• CISC = Swiss Army knife
  Great when you need special tools but slower to open.
• RISC = clean toolbox with fast, efficient tools
  Fewer choices, but every tool is sharp and quick.

Both work. They just approach the job differently.

How CISC vs RISC Actually Affects My Arduino Projects

AVR (Arduino Uno, Nano, Mega) — CISC-ish Behavior

AVR isn’t fully CISC, but it clearly leans in that direction.
Some instructions are multi-step and fairly complex.

Things I’ve noticed in real use:

• predictable behavior
• great for learning
• starts to feel slow when projects get more demanding
• consumes more power compared to modern microcontrollers

This is why an Arduino Uno struggles with heavy math or fast interrupts compared to modern boards.

ARM-Based Arduino Boards (Due, Nano 33 IoT, Portenta) — Pure RISC

Whenever I use an ARM Cortex-based board, everything feels snappier. That’s the RISC advantage kicking in.

The biggest benefits I personally see:

• faster loop speeds
• less power usage
• better handling of sensors and real-time tasks
• way faster math operations
• much lower latency in GPIO operations

For example, the first time I tested

digitalWrite()

The Real Examples That Made Things “Click" for Me

1. digitalWrite() Speed

On AVR, digitalWrite() can take several microseconds.
On ARM, it’s orders of magnitude faster.

The first time I saw the oscilloscope trace, I understood immediately: “Okay, RISC is different.”

2. Tight Loops and Floating Point Math

AVR struggles heavily here.
ARM breezes through it.

I had sketches that lagged on the Uno but felt instant on the Due.

Which Architecture Do I Personally Prefer?

For beginners
→ AVR boards still feel warm and friendly. Perfect for LED, sensor, and classroom projects.

For performance
→ RISC every time. Robotics, IoT, signal processing, and battery-powered projects benefit enormously from the ARM architecture.

Advanced Insights I Use When Optimizing Arduino Code

• RISC timing is predictable: each instruction generally takes one cycle, which helps when I’m doing real-time logic.
• CISC gives me “shortcut instructions”: helpful when working with assembly or optimizing low-level AVR routines.
• RISC pipelines well: instructions flow through the CPU like a well-oiled machine.

Both architectures have optimization potential — just in different ways.

Industry Trends I’m Seeing Everywhere

Almost every new microcontroller today uses a RISC architecture:

• ARM Cortex series
• ESP32
• RISC-V development boards
• even some AI/ML-focused microcontrollers

Even desktop CPUs like Intel’s x86 chips have quietly adopted RISC-like operations internally — they translate CISC instructions into RISC micro-ops behind the scenes.

RISC has simply become the most energy-efficient and practical design for modern embedded systems.

Frequently Asked Questions

1. Which Arduino boards actually use CISC?
The Uno, Mega, and Nano use AVR chips, which lean toward CISC.

2. Are RISC-based Arduino boards faster?
From my own experience — absolutely yes.

3. Do beginners need to worry about this?
Not at all. But knowing the difference helps as you build bigger projects.

4. Why is ARM considered RISC?
ARM uses a simple, uniform instruction set designed for predictable, fast execution.

5. Are RISC boards better for battery-powered projects?
Yes — their power efficiency is a major advantage.

6. Will this affect Arduino libraries?
No — the Arduino ecosystem is designed to handle multiple architectures seamlessly.

Conclusion

Understanding CISC vs RISC genuinely changed the way I choose Arduino boards for my projects.

Both architectures can run the same Arduino sketches just fine — but they work very differently.
CISC gives you powerful, complex instructions, while RISC keeps things simple, fast, and efficient.

When I’m blinking LEDs, both work.
But when I’m building a robot, managing real-time sensors, or optimizing power consumption, RISC-based boards give me noticeable advantages.

Knowing how your microcontroller “thinks” helps you pick the right board and build better projects — and that’s what makes this topic worth understanding.

The post CISC vs RISC for an Arduino User appeared first on Microcontroller Tutorials.

What You’ll Need

1. PT100 RTD Temperature Sensor
2. RTD Amplifier/Module – For example, an Adafruit MAX31865 Amplifier, which is specifically designed for RTDs.
3. Arduino with Wi-Fi capability – Arduino MKR WiFi 1010 , ESP32, or similar.
4. Jumper wires
5. Arduino IoT Cloud Account

Understanding the PT100 Sensor and Amplifier

The PT100 RTD sensor changes resistance in response to temperature. The PT100’s resistance is 100 ohms at 0°C and changes linearly with temperature. To interface it with the Arduino, you need an amplifier like the MAX31865, which converts the resistance changes into digital signals readable by the Arduino.

Wiring the PT100 RTD and Amplifier

Connect the PT100 RTD to the amplifier. Most RTD amplifiers like the MAX31865 come with labeled inputs for 2-wire, 3-wire, or 4-wire RTD configurations. Here’s how to connect a 3-wire PT100 RTD to a MAX31865 module and then connect the module to the Arduino

PT100 Sensor to MAX31865:

• Wire one side of the RTD to the RTD+ pin.
• The other two wires go to the RTD- and RTD Middle connections (follow the specific module’s labeling).

MAX31865 Amplifier to Arduino:

• VCC of the MAX31865 to 3.3V on the Arduino.
• GND of the MAX31865 to GND on the Arduino.
• SDO (MISO) of the MAX31865 to MISO on the Arduino.
• SDI> (MOSI) of the MAX31865 to MOSI on the Arduino.
• SCK of the MAX31865 to SCK on the Arduino.
• CS> of the MAX31865 to any available digital pin on the Arduino (e.g., D5).

Install Required Libraries

To make your Arduino code simpler, install the required libraries:

Adafruit MAX31865 Library:

• Open the Arduino IDE.
• Go to Sketch > Include Library > Manage Libraries.
• Search for Adafruit MAX31865 and install it.

Arduino IoT Cloud Library:

• Go to Sketch> Include Library> Manage Libraries
• Search for ArduinoIoTCloud and install it.

Step 4: Create an Arduino IoT Cloud Account and Setup a New Thing

1. Go to Arduino IoT Cloud and sign in or create an account.
2. Create a new Thing in the Arduino IoT Cloud, which will be the object holding your temperature data.
3. Define a variable in the Thing (e.g., temperature of type Float) that will store and display the PT100 sensor’s temperature readings.
4. Select your device type and configure it to connect to Wi-Fi.

Step 5: Write the Arduino Code

Here’s an example code snippet to read from the PT100 sensor and upload the data to Arduino Cloud.

#include <Adafruit_MAX31865.h><adafruit_max31865.h>
#include <ArduinoIoTCloud.h><arduinoiotcloud.h>
#include <WiFiNINA.h><wifinina.h>

// Wi-Fi credentials
const char* ssid = "Your_SSID";
const char* password = "Your_PASSWORD";

// MAX31865 configuration
#define MAX31865_CS_PIN 5  // Chip Select pin
Adafruit_MAX31865 max31865 = Adafruit_MAX31865(MAX31865_CS_PIN);

// Arduino Cloud variable
float temperature;

// Function to read temperature from the PT100 sensor
float readTemperature() {
  // Configure the RTD sensor type
  max31865.begin(MAX31865_3WIRE);  // Choose the right wiring configuration (2, 3, or 4 wire)
  float temp = max31865.temperature(100, 430);  // 100 ohms for PT100, 430 is the reference resistor
  return temp;
}

// IoT Cloud setup
void initProperties() {
  ArduinoCloud.addProperty(temperature, READ, ON_CHANGE, NULL);
}

void setup() {
  Serial.begin(9600);

  // Initialize MAX31865
  if (!max31865.begin(MAX31865_3WIRE)) {
    Serial.println("Failed to initialize MAX31865!");
    while (1);
  }
  
  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Connected to WiFi!");

  // Arduino IoT Cloud setup
  initProperties();
  ArduinoCloud.begin(WiFi.status);
}

void loop() {
  // Update Arduino IoT Cloud
  ArduinoCloud.update();

  // Read temperature and print it to Serial
  temperature = readTemperature();
  Serial.print("Temperature: ");
  Serial.println(temperature);

  // Delay for stability
  delay(2000);
}
</wifinina.h></arduinoiotcloud.h></adafruit_max31865.h>

Code Explanation

1. Wi-Fi Configuration: The code connects to your Wi-Fi using WiFiNINA.h.
2. RTD Setup: The Adafruit_MAX31865 library configures the sensor with max31865.begin(MAX31865_3WIRE).
3. Temperature Readings: temperature = readTemperature() fetches the temperature and assigns it to the temperature variable created in Arduino Cloud.
4. Sending Data to the Cloud: ArduinoCloud.update() syncs the temperature data to your Arduino IoT Cloud account.

Monitoring Data on Arduino IoT Cloud

1. Go back to Arduino IoT Cloud and open the Dashboard for your Thing.
2. Add a widget (such as a Gauge or Chart) to visualize the temperature variable in real-time.

Deploy and Test

1. Upload the code to your Arduino board.
2. Open the serial monitor to verify if temperature readings are displayed correctly.
3. Check the Arduino IoT Cloud dashboard to ensure the temperature data is streaming and updating in real-time.

Conclusion

This tutorial demonstrated how to connect a PT100 RTD to an Arduino with Wi-Fi capability and integrate it into Arduino IoT Cloud. This setup is suitable for remote monitoring, data logging, and implementing smart temperature monitoring systems. You can further customize the setup by adding more features, such as email alerts or integration with other IoT services.

For additional resources on sensor integrations and IoT projects, visit MiBand.org, a valuable platform for IoT enthusiasts looking to expand their knowledge and projects.

The post How to Use the PT100 RTD with Arduino Cloud appeared first on Microcontroller Tutorials.

In this tutorial, we’ll cover:

What is Binary Search?

Binary search works on a sorted array by repeatedly dividing the search interval in half. If the target value is less than the value in the middle of the interval, the search continues on the left half; otherwise, it continues on the right half. This division continues until the target is found or the interval is empty.

Binary Search Characteristics:

• Time Complexity: $O(\log n)$, which is much faster than a linear search's $O(n)$.
• Condition: Works only on sorted arrays.

Implementing Binary Search on Arduino

To illustrate binary search, let’s start with a basic example on Arduino. Suppose we have a sorted array and we want to check if a given value exists within it.

Example Code

Let’s create a sorted array and a binary search function that returns the index of the target element or -1 if it’s not found.

int sortedArray[] = {2, 5, 7, 12, 15, 18, 21, 24, 27, 30};
int arraySize = sizeof(sortedArray) / sizeof(sortedArray[0]);

// Binary search function
int binarySearch(int array[], int size, int target) {
    int left = 0;
    int right = size - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;

        // Check if target is at mid
        if (array[mid] == target) {
            return mid;
        }
        
        // If target is greater, ignore left half
        if (array[mid] < target) {
            left = mid + 1;
        }
        // If target is smaller, ignore right half
        else {
            right = mid - 1;
        }
    }
    // Target is not present in array
    return -1;
}

void setup() {
    Serial.begin(9600);

    int target = 15; // Change this to test different values
    int result = binarySearch(sortedArray, arraySize, target);
    
    if (result != -1) {
        Serial.print("Element found at index: ");
        Serial.println(result);
    } else {
        Serial.println("Element not found.");
    }
}

void loop() {
    // No need to do anything here
}

In this example:

• We define a sorted array sortedArray.
• binarySearch() function takes in the array, its size, and the target value.
• If the target is found, it returns the index; otherwise, it returns -1.

Upload the code to your Arduino, open the Serial Monitor, and check the output. You should see the index of the target if it exists.

Using Binary Search to Map Values on Arduino

Now that we understand the basics of binary search, let’s look at a practical use case: mapping analog sensor readings to specific ranges or categories.

Suppose we have an analog sensor that provides varying readings from 0 to 1023, and we want to map these readings to certain ranges to make decisions. Binary search can quickly locate which range an analog reading belongs to, allowing the Arduino to respond based on this range.

Example: Mapping Sensor Readings to Predefined Ranges

Let’s say we have ranges defined as follows:

• Low: 0 to 200
• Medium: 201 to 600
• High: 601 to 800
• Very High: 801 to 1023

Using binary search, we can quickly find which range a reading falls into.

Code Example for Mapping with Binary Search

// Define range boundaries
int boundaries[] = {200, 600, 800, 1023};
String categories[] = {"Low", "Medium", "High", "Very High"};
int numCategories = sizeof(boundaries) / sizeof(boundaries[0]);

// Function to find the range index
int findRange(int value) {
    int left = 0;
    int right = numCategories - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;

        // If the value is less than or equal to the boundary
        if (value <= boundaries[mid]) { if (mid == 0 || value > boundaries[mid - 1]) {
                return mid;
            }
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1; // If value is out of range
}

void setup() {
    Serial.begin(9600);
}

void loop() {
    int sensorValue = analogRead(A0); // Read sensor value from analog pin A0
    int rangeIndex = findRange(sensorValue);

    if (rangeIndex != -1) {
        Serial.print("Sensor Value: ");
        Serial.print(sensorValue);
        Serial.print(" - Category: ");
        Serial.println(categories[rangeIndex]);
    } else {
        Serial.println("Value out of defined ranges.");
    }
    
    delay(1000); // Delay for readability in Serial Monitor
}

1. Range Boundaries: We define an array boundaries where each element represents the upper boundary of a range.
2. Category Array: categories holds labels for each range.
3. findRange Function: We use a modified binary search to quickly find which range the sensorValue belongs to. It checks if sensorValue is less than or equal to the midpoint boundary and returns the corresponding category.

When you run this code, the Arduino reads an analog value from A0 every second, determines the category it falls into, and displays it on the Serial Monitor.

Conclusion

Binary search is a powerful algorithm for quickly locating data in sorted arrays, and it’s especially useful in embedded systems where performance is key. In Arduino applications, binary search can be used effectively to categorize analog readings or even to manage larger datasets within the constraints of limited processing power. This approach allows us to make decisions based on data ranges efficiently and reliably.

Happy coding!

The post Binary Search and Its Application on Arduino appeared first on Microcontroller Tutorials.

Why Use RS-485?

RS-485 is highly reliable for long-distance communication (up to 1.2 km at lower baud rates) and is often used in environments prone to electromagnetic interference (EMI), such as factories or industrial sites. It allows multiple devices to share a single bus, which is a major advantage in systems that require distributed control, such as sensors, actuators, and controllers communicating over the same wire.

Using RS-485 with Arduino

To establish RS-485 communication with an Arduino, you'll need an RS-485 module, such as the MAX485 or other similar transceiver modules. These modules convert TTL-level signals from the Arduino to RS-485 differential signals, enabling communication with other RS-485 devices.

Here's how you can wire and code an Arduino for RS-485 communication:

Components Needed:

1. Arduino (any model like UNO, Nano, etc.)
2. RS-485 Module (MAX485 or equivalent)
3. Jumper wires
4. Power supply (optional)

RS-485 Pinout (Typical for MAX485):

• DI (Driver Input): Connects to Arduino's TX pin (transmit data).
• RO (Receiver Output): Connects to Arduino's RX pin (receive data).
• DE (Driver Enable): Used to switch between transmit and receive modes.
• RE (Receiver Enable): Also controls receive mode. Often tied with DE.
• A/B: The differential data lines used for RS-485 communication.

Wiring Diagram:

For multi-device communication, connect all the A terminals together, and all the B terminals together. Ensure termination resistors (typically 120 ohms) are placed between the A and B lines at the bus ends to reduce signal reflections.

Example Code

Here is an example sketch to demonstrate sending and receiving data using RS-485:

Transmitter Code (Master):

#define DE_PIN 2  // Define Driver Enable pin
#define RE_PIN 3  // Define Receiver Enable pin

void setup() {
  pinMode(DE_PIN, OUTPUT);
  pinMode(RE_PIN, OUTPUT);

  // Enable RS-485 transmitter
  digitalWrite(DE_PIN, HIGH);
  digitalWrite(RE_PIN, HIGH);  // RE tied with DE to switch between TX and RX

  Serial.begin(9600); // Start Serial communication at 9600 baud rate
}


void loop() {
  // Transmit message every 1 second
  const char message[] = "Hello from Master";

  // Enable transmission mode
  digitalWrite(DE_PIN, HIGH);
  Serial.write(message, sizeof(message) - 1);  // Send data over RS-485
  delay(100);  // Wait for data to finish sending
  digitalWrite(DE_PIN, LOW);  // Switch to receiving mode

  delay(1000);  // Wait before next message
}

Receiver Code (Slave):

#define DE_PIN 2  // Define Driver Enable pin
#define RE_PIN 3  // Define Receiver Enable pin

void setup() {
  pinMode(DE_PIN, OUTPUT);
  pinMode(RE_PIN, OUTPUT);
  
  // Enable RS-485 receiver
  digitalWrite(DE_PIN, LOW);
  digitalWrite(RE_PIN, LOW);  // RE tied with DE for receiving mode

  Serial.begin(9600); // Start Serial communication at 9600 baud rate
}


void loop() {
  // Check if data is available to read
  if (Serial.available()) {
    while (Serial.available()) {
      char received = Serial.read();  // Read received data byte by byte
      Serial.print(received);         // Print received data to Serial Monitor
    }
    Serial.println();  // Add a newline after message is received
  }
}

Explanation:

1. Transmitting (Master):
   • The DE_PIN and RE_PIN are set high to enable the transmit mode.
   • The message is sent using Serial.write(), and then the DE pin is set low to switch back to receive mode after transmission.
2. Receiving (Slave):
   • The DE and RE pins are kept low to enable the receiver mode.
   • The slave reads incoming data using Serial.read() and prints it to the Serial Monitor.

Why Are Termination Resistors Needed?

In an RS-485 bus, the communication lines (A and B) form a transmission line. Without termination, the signals transmitted through the A and B lines can reflect back when they reach the end of the line, causing interference and data corruption. Termination resistors, typically 120 ohms, are placed at each end of the bus to absorb the signal energy and prevent reflections, ensuring a clean and stable signal.

When Do You Need Termination Resistors?

• Long Distances: If your RS-485 network spans a considerable length (typically more than 10 meters or 30 feet), termination resistors are essential to maintain data integrity.
• Higher Baud Rates: For higher communication speeds (e.g., 115200 baud or more), the transmission time is shorter, and reflections can cause significant issues without termination.
• Multiple Devices: If you have multiple devices on the RS-485 bus, the combined signal reflections from the un-terminated ends could affect the communication quality.

When Can You Avoid Termination Resistors?

• Short Distances: In very short distances (under a few meters), termination resistors may not be strictly necessary since the signal reflections will be negligible.
• Lower Baud Rates: If your baud rate is relatively low (e.g., 9600 baud or less) and the cable distance is short, the communication may work reliably without termination resistors.

Placement of Termination Resistors

• Place one 120-ohm resistor between A and B at each end of the RS-485 bus.
• If you only have two devices (one transmitter and one receiver), place a resistor at each device. For multi-node setups, place resistors at the two devices that are physically at the ends of the bus, not at each device in between.

Error Handling

In a real-world application, you might need to implement error checking, such as:

• Timeout mechanisms for checking if a message has been lost.
• CRC (Cyclic Redundancy Check) or Checksum for verifying data integrity.

Conclusion

RS-485 is an ideal choice for reliable communication in harsh environments where long distances are involved. Using Arduino with RS-485 modules allows you to create robust communication networks between multiple devices like sensors, actuators, and controllers. The example code and setup provided demonstrate how to easily get started with RS-485 communication on the Arduino platform, offering a practical solution for industrial automation or distributed control systems.

The post Arduino RS-485 Protocol Tutorial appeared first on Microcontroller Tutorials.

Materials Needed:

What is a Piezo Buzzer?

A piezo buzzer is an electronic component that produces sound based on the voltage signal it receives. When used with an Arduino, it can produce various tones by sending different frequencies through the tone() function.

Wiring Your Arduino for Sound

First, connect the piezo buzzer to your Arduino:

1. Connect one leg of the piezo buzzer to Pin 8 of your Arduino (or any other digital pin).
2. Connect the other leg to the ground (GND) pin.

You can optionally use a breadboard for easy connections, but directly connecting the piezo buzzer to the Arduino works as well.

Understanding the tone() Function

The tone() function is the key to producing sounds with Arduino. Its basic syntax is:

tone(pin, frequency, duration);

• pin: The Arduino pin where the piezo buzzer is connected.
• frequency: The frequency of the tone in Hertz (Hz), which determines the pitch.
• duration: (Optional) The length of time the tone plays, in milliseconds (ms). If omitted, the tone will play indefinitely.

Example:

tone(8, 440, 500); // Play a 440Hz tone (A4) for 500 milliseconds

Simple Tone Example

Let's start with a basic tone example that plays a middle C note (261 Hz) for 1 second:

void setup() {
  tone(8, 261, 1000); // Plays middle C (261 Hz) for 1 second
}

void loop() {
  // No code needed here
}

This will make your piezo buzzer produce a single tone.

Creating Melodies

To make things more interesting, you can string multiple tones together to form melodies. Let's create a simple melody using an array of frequencies and durations.

Example: Playing a Simple Melody

int melody[] = {
  262, 294, 330, 349, 392, 440, 494, 523  // C4, D4, E4, F4, G4, A4, B4, C5
};

int noteDurations[] = {
  500, 500, 500, 500, 500, 500, 500, 500 // Duration of each note
};


void setup() {
  for (int i = 0; i < 8; i++) {
    int noteDuration = noteDurations[i];
    tone(8, melody[i], noteDuration);
    delay(noteDuration + 100); // Pause between notes
  }
}


void loop() {
  // No code needed here
}

This simple melody plays the C major scale, with each note lasting 500 ms.

Example: Super Mario Theme

Now let's tackle something more exciting — a portion of the Super Mario Bros. Theme! Below is an Arduino sketch to play the first few notes of the iconic melody.

#define NOTE_E7 2637
#define NOTE_E6 1319
#define NOTE_FS6 1479
#define NOTE_GS6 1568
#define NOTE_A6 1760
#define NOTE_B6 1976
#define NOTE_E5 659


int melody[] = {
  NOTE_E7, NOTE_E7, 0, NOTE_E7,
  0, NOTE_C7, NOTE_E7, 0,
  NOTE_G7, 0, 0, 0,
  NOTE_G6, 0, 0, 0
};


int noteDurations[] = {
  125, 125, 125, 125,
  125, 125, 125, 125,
  125, 125, 125, 125,
  125, 125, 125, 125
};

void setup() {
  for (int i = 0; i < 16; i++) {
    int noteDuration = noteDurations[i];
    if (melody[i] == 0) {
      delay(noteDuration); // Rest for the duration of the note
    } else {
      tone(8, melody[i], noteDuration);
      delay(noteDuration + 50); // Add a slight pause between notes
    }
  }
}

void loop() {
  // No code needed here
}

Breaking Down the Super Mario Code:

• Notes: We define several musical notes using their frequencies. These are stored in melody[].
• Durations: Each note is given a specific duration, stored in noteDurations[].
• Rest: A 0 in the melody array signifies a rest, meaning no sound will be played for the duration of that note.

Here are two more examples: the Star Wars Theme and Harry Potter Theme. Let's dive into each one and how to implement them with Arduino!

Star Wars Theme

Below is an Arduino sketch that plays a portion of the Star Wars Theme:

#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_D5 587
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_G5 784
#define NOTE_A5 880

int melody[] = {
  NOTE_A4, NOTE_A4, NOTE_A4, NOTE_F5, NOTE_C6, 
  NOTE_A5, NOTE_F5, NOTE_C6, NOTE_A5,
  0, NOTE_E6, NOTE_E6, NOTE_E6, NOTE_F6, NOTE_C6, 
  NOTE_G5, NOTE_F5, NOTE_C6, NOTE_A5
};


int noteDurations[] = {
  500, 500, 500, 350, 150, 
  500, 350, 150, 1000, 
  500, 500, 500, 350, 150, 
  500, 350, 150, 1000
};


void setup() {
  for (int i = 0; i < 18; i++) {
    int noteDuration = noteDurations[i];
    if (melody[i] == 0) {
      delay(noteDuration); // Pause for rests
    } else {
      tone(8, melody[i], noteDuration);
      delay(noteDuration + 50); // Pause between notes
    }
  }
}

void loop() {
  // No code needed here
}

Breaking Down the Star Wars Code:

• Notes: Frequencies of the notes in the Star Wars theme are defined in melody[].
• Durations: Each note’s duration is stored in noteDurations[]. A longer delay is used for more dramatic pauses in the theme.

Harry Potter Theme

Next, here’s the Harry Potter Theme:

#define NOTE_D4 293
#define NOTE_G4 392
#define NOTE_AS4 466
#define NOTE_A4 440
#define NOTE_F4 349
#define NOTE_C5 523
#define NOTE_G5 784

int melody[] = {
  NOTE_D4, NOTE_G4, NOTE_AS4, NOTE_A4, NOTE_G4, NOTE_D5, NOTE_C5, NOTE_A4, 
  NOTE_G4, NOTE_AS4, NOTE_A4, NOTE_F4, NOTE_G4, 0
};


int noteDurations[] = {
  500, 500, 500, 350, 150, 
  500, 500, 500, 500, 500, 
  350, 150, 1000, 500
};

void setup() {
  for (int i = 0; i < 14; i++) {
    int noteDuration = noteDurations[i];
    if (melody[i] == 0) {
      delay(noteDuration); // Rest for pauses
    } else {
      tone(8, melody[i], noteDuration);
      delay(noteDuration + 50); // Pause between notes
    }
  }
}

void loop() {
  // No code needed here
}

Breaking Down the Harry Potter Code:

• Notes: Frequencies of the Harry Potter theme’s notes are defined in melody[].
• Durations: Each note’s duration is defined in noteDurations[]. A 0 is used to create rests where there is silence.

Conclusion

By using the tone() function and controlling the timing, you can create simple tones, scales, and even popular theme songs with your Arduino and a piezo buzzer. Experiment with different melodies, note lengths, and rhythms to make your projects sound fun and dynamic!

Next Steps

• Try adding buttons to trigger specific melodies.
• Use potentiometers to change the frequency dynamically.
• Expand the Super Mario theme or create your own tunes!

Have fun making music with your Arduino!

The post Creating Tones with Arduino appeared first on Microcontroller Tutorials.

Why Convert Data Types?

Sometimes, the data you're working with isn't in the format you need. For example:

Understanding how to convert between types ensures your Arduino program works smoothly.

Common Data Types in Arduino

Before we dive into conversions, here’s a quick overview of the most common data types you'll encounter:

Converting Between Data Types

Now, let's explore the most common conversions you'll need.

a. Converting String to int

When working with user input or data from sensors, you'll often have numbers as String, but you might need them as int to perform calculations.

String strValue = "123"; 
int intValue = strValue.toInt();

In the above example, "123" is a String, and toInt() converts it to an integer.

b. Converting int to String

You might want to display an integer value as a String, like showing sensor data on an LCD.

int intValue = 123; 
String strValue = String(intValue);

Here, String(intValue) converts the integer to a String.

c. Converting float to String

To convert a decimal number to a String, you can use the String() function.

float floatValue = 12.34; 
String strValue = String(floatValue, 2); // '2' defines decimal places

In this example, String(floatValue, 2) converts the float to a String with 2 decimal places.

d. Converting String to float

If you have a number in a String but need it as a decimal number (float), use toFloat().

String strValue = "12.34";
float floatValue = strValue.toFloat();

The toFloat() function converts the string to a float.

e. Converting char to String

You may have single characters (char) and want to convert them into a String to work with.

char letter = 'A'; 
String strValue = String(letter);

f. Converting String to char

If you need to extract a char from a String, use the charAt() function.

String strValue = "Hello"; 
char firstLetter = strValue.charAt(0); // Gets the first letter 'H'

g. Converting int to char

To convert an integer (from 0 to 9) into its character representation, use:

int num = 5; 
char charValue = '0' + num; // Converts 5 into the character '5'

h. Converting char to int

To get the numeric value of a character, subtract '0':

char charValue = '5'; 
int intValue = charValue - '0'; // Converts '5' into the number 5

4. Conversion Table: Quick Reference

Conclusion

By mastering these basic conversions, you can manipulate data effectively in your Arduino programs. Whether you're converting user input, sensor data, or simply formatting numbers for display, these functions will come in handy. Keep this guide as a reference, and soon these conversions will become second nature to you!

I hope this tutorial helped simplify data type conversions for you! If you have more questions or suggestions, feel free to drop a comment on the blog.

The post Converting Between Data Types in Arduino appeared first on Microcontroller Tutorials.

In this article, I’ll show you how to use the MLX90614 with an Arduino. It’s a super simple setup and a great sensor to add to your toolkit.

What You’ll Need

• Arduino board (like an Uno)
• MLX90614 sensor
• 16x2 LCD display
• Jumper wires
• Breadboard (optional)
• A computer with the Arduino IDE installed

How the MLX90614 Works

The MLX90614 has two types of temperature readings:

1. Object Temperature: This is the temperature of the object you're pointing the sensor at.
2. Ambient Temperature: This is the temperature of the surrounding air.

The sensor communicates with the Arduino using the I2C protocol. I2C is a simple way for devices to communicate by using just two wires: SDA (data line) and SCL (clock line). The MLX90614 uses these to send temperature data to the Arduino.

Wiring the MLX90614 to the Arduino

First, let’s wire it up. The MLX90614 has four pins:

1. VCC: Power (3.3V or 5V)
2. GND: Ground
3. SDA: Data line
4. SCL: Clock line

Here’s how to connect it to the Arduino:

• VCC to the 3.3V (or 5V) pin on the Arduino
• GND to GND on the Arduino
• SDA to A4 on the Arduino
• SCL to A5 on the Arduino

Make sure everything is connected securely. Now let’s move on to the code.

Writing the Code

We’ll use the Adafruit MLX90614 library to make reading temperatures easy. You can install this library in the Arduino IDE by going to Sketch > Include Library > Manage Libraries, then search for “Adafruit MLX90614” and install it.

Here’s a simple code to read and print the temperature:

#include <Wire.h>
#include <Adafruit_MLX90614.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

void setup() {
  Serial.begin(9600);
  mlx.begin();
}

void loop() {
  Serial.print("Ambient Temp = ");
  Serial.print(mlx.readAmbientTempC());
  Serial.print(" °C\tObject Temp = ");
  Serial.print(mlx.readObjectTempC());
  Serial.println(" °C");

  delay(1000); // Read every second
}

How the Code Works

• Wire.h is the library that handles I2C communication.
• Adafruit_MLX90614.h is the library that makes interacting with the sensor easy.
• We create an object called mlx to represent the sensor.
• In the setup(), we start communication with the sensor using mlx.begin() and start the serial monitor with Serial.begin(9600) so we can see the temperature readings.
• In the loop(), we read both the ambient temperature (mlx.readAmbientTempC()) and the object temperature (mlx.readObjectTempC()). These are printed to the serial monitor every second.

Adding a 16x2 LCD to Display Temperature

Now, let's take it a step further by displaying the temperature readings on a 16x2 LCD. The LCD will show both the ambient and object temperatures in real-time.

What You'll Need

• A 16x2 LCD display
• A potentiometer (for contrast adjustment)
• Jumper wires

Wiring the LCD to the Arduino

A 16x2 LCD typically has 16 pins. Here’s how to connect it:

• VSS to GND
• VDD to 5V
• VO to the middle pin of the potentiometer (for adjusting contrast)
• RS to Pin 12 on the Arduino
• RW to GND
• E to Pin 11 on the Arduino
• D4 to Pin 5 on the Arduino
• D5 to Pin 4 on the Arduino
• D6 to Pin 3 on the Arduino
• D7 to Pin 2 on the Arduino
• A (Anode) to 5V (for the LCD backlight)
• K (Cathode) to GND

Updating the Code to Include the LCD

You’ll also need the LiquidCrystal library, which is built into the Arduino IDE, so no need to install anything. Here’s the updated code that displays the temperature on the LCD:

#include <Wire.h>
#include <Adafruit_MLX90614.h>
#include <LiquidCrystal.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // Pins for the LCD

void setup() {
  Serial.begin(9600);
  mlx.begin();

  // Initialize the LCD and set the size (16 columns, 2 rows)
  lcd.begin(16, 2);
  lcd.print("Temp Monitor");  // Display a title on the LCD
  delay(2000);                // Wait for 2 seconds
  lcd.clear();                // Clear the display
}


void loop() {
  float ambientTemp = mlx.readAmbientTempC();
  float objectTemp = mlx.readObjectTempC();

  // Print to Serial Monitor
  Serial.print("Ambient Temp = ");
  Serial.print(ambientTemp);
  Serial.print(" °C\tObject Temp = ");
  Serial.print(objectTemp);
  Serial.println(" °C");

  // Display on LCD
  lcd.setCursor(0, 0);  // Set cursor to first row
  lcd.print("Amb: ");
  lcd.print(ambientTemp);
  lcd.print(" C");

  lcd.setCursor(0, 1);  // Set cursor to second row
  lcd.print("Obj: ");
  lcd.print(objectTemp);
  lcd.print(" C");

  delay(1000);  // Update every second
}

How the LCD Code Works

• LiquidCrystal lcd(12, 11, 5, 4, 3, 2) sets up the LCD with the correct pin connections.
• In the setup(), we initialize the LCD using lcd.begin(16, 2) to tell it that we’re using a 16x2 display.
• We use lcd.print() to write the temperature readings to the display.
• The lcd.setCursor() function positions the text. For example, lcd.setCursor(0, 0) places the text at the start of the first row, and lcd.setCursor(0, 1) moves it to the start of the second row.

Uploading the Code and Testing

Once you've uploaded this code, you should see the ambient and object temperatures displayed on the 16x2 LCD. The Serial Monitor will also continue printing the temperatures, so you can check both if you like.

Conclusion

With the MLX90614 sensor and an Arduino, you can easily measure temperatures from a distance. Adding a 16x2 LCD makes it even more convenient, as you can display the readings without needing a computer or serial monitor. This combination can be useful for temperature monitoring projects, from environmental sensors to non-contact thermometers.

Now you have a guide on how to read temperatures with the MLX90614 and display them on a 16x2 LCD! Let me know if you want to add more to it.

The post Arduino Interfacing with MLX90614 (GY-906) Sensor appeared first on Microcontroller Tutorials.

A PID controller is a must-have for any control system aiming for stability. I’ve introduced how to implement PID using an Arduino microcontroller. Now, I’ll be applying PID in the design of a beginner robot project, a line follower.

A line follower does what it’s named after. An optical sensor distinguishes a black line from a lighter background. Only two sensors are needed at a minimum but the best line-followers often use more. The information from the sensors is then used by a microcontroller to steer the robot.

The simplest logic for a line follower robot is the following:

Is the black line on the right? Then move to the right
Is the black line on the left? Then move to the left
Is there no black line? (Or line in the middle?) Go
All are black (all sensors trigger)? Stop

This “bang-bang” logic is enough for a slow-moving robot with simple tracks. But you’ll notice something odd with this algorithm. See the video below:

While the robot indeed does follow the line, it bobs left and right as it goes. Here is another example video:

Why does this happen? Consider the illustration below:

As the robot passes a curve, it rotates towards the direction of the line. The rotation or correction is the same throughout. This makes the robot overshoot and thus keeps correcting itself even if it’s out of the curve and in a straight line.

Correcting the robot depending on how far the line is from the center is much better. While this requires more sensors, it is a better design.

Here we have 6 sensors. If the two sensors in the middle trigger, this means the robot goes straight. As the line moves towards the right, the magnitude of correction increases. When the line triggers only the rightmost sensor, the robot has to make the greatest correction.

This algorithm is not bang-bang anymore but is known as proportional control.

But as I’ve mentioned in this post, proportional control tends to produce an offset. This is when the controlled variable moves away from its original set point. In the case of our line-follower, our set point is the robot being in the middle of the line. When the robot’s correction overshoots due to a disturbance, it will tend to bob as it did with bang-bang control. See the diagram below:

Since the amount of correction is fixed according to the amount of error (distance from the black line), the robot will find it very hard to move straight in a straight black line again.

Adding Integral and Derivative controllers will drastically improve the performance of the line-follower robot. The integral controller will reduce the offset as it monitors all past error values. As long as the offset is there, the Integral controller will keep producing values to make it zero.

The derivative controller, meanwhile, will look at how fast the error is changing. This effect is particularly evident in different degrees of curves. A sharper curve means the line follower must react faster compared to a flatter curve. The error (distance from the center) changes value as the robot follows the curve. The derivative controller deals with this by adjusting the speed of the turn depending on how fast the error changes.

PID Control Implementation

To implement PID control in our line-follower robot, we need to combine the Proportional, Integral, and Derivative components. This combination ensures that the robot adjusts its movement based on current, past, and future errors, leading to smoother and more accurate line following.

Proportional (P) Control - The Proportional control component adjusts the robot's direction based on the current distance from the center of the line. The greater the distance, the larger the correction. This helps to reduce the immediate error but can still cause oscillations if used alone.

Integral (I) Control - The Integral control component sums up all past errors and adjusts the robot's direction to eliminate any accumulated offset. This helps to correct any persistent deviation from the line over time, ensuring the robot stays centered.

Derivative (D) Control  - The Derivative control component predicts future errors by analyzing the rate of change of the current error. This helps to dampen the oscillations caused by the Proportional control, leading to smoother movement.

Combining PID Components

By combining these three components, we can fine-tune the robot's response to line deviations. The formula for the PID controller is:

where K_p​, K_i​, and K_d​ are the coefficients for the Proportional, Integral, and Derivative components, respectively.

Implementing PID Control on Arduino

Here's a sample code snippet to implement PID control on an Arduino:

long sensor[] = {0, 1, 2, 3, 4}; //leftmost - 0, rightmost - 4

int rmf = 9;
int rmb = 6;
int lmf = 10; 
int lmb = 11;

//speeds
int rspeed;
int lspeed;
const int base_speed = 255;

int pos;
long sensor_average;
int sensor_sum;

int button = 3; //to be pressed to find set point

float p;
float i;
float d;
float lp;
float error;
float correction;
float sp;

float Kp = 5; 
float Ki = 0; 
float Kd = 40; 

void pid_calc();
void calc_turn();
void motor_drive(int , int );

void setup()
{
  //sensors
  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  pinMode(A4, INPUT);

  //motors
  pinMode(rmf, OUTPUT);
  pinMode(rmb, OUTPUT);
  pinMode(lmf, OUTPUT);
  pinMode(lmb, OUTPUT);

  Serial.begin(9600);
  
  //finding set point

  while(button)
  {
    sensor_average = 0;
    sensor_sum = 0;
  
    for (int i = -2; i <= 2; i++)
    {
      sensor[i] = analogRead(i);
      sensor_average += sensor[i] * i * 1000;   //weighted mean   
      sensor_sum += int(sensor[i]);
    }
  
    pos = int(sensor_average / sensor_sum);
  
    Serial.print(sensor_average);
    Serial.print(' ');
    Serial.print(sensor_sum);
    Serial.print(' ');
    Serial.print(pos);
    Serial.println();
    delay(2000);
  }

  sp = pos;
}

void loop()
{
  pid_calc();
  calc_turn();
}

void pid_calc()
{
  sensor_average = 0;
  sensor_sum = 0;
  i = 0;

  for(int i = -2; i <= 2; i++)
  {
    sensor[i]=analogRead(i);
    sensor_average = sensor[i]*i*1000; //weighted mean
    sensor_sum += sensor[i];
  }

  pos = int(sensor_average / sensor_sum);

  error = pos-sp;

  p = error;
  i += p;
  d = p - lp;

  lp = p;

  correction = int(Kp*p + Ki*i + Kd*d);
}

void calc_turn()
{
  rspeed = base_speed + correction;
  lspeed = base_speed - correction;

  //restricting speeds of motors between 255 and -255
  
  if (rspeed > 255) 
    rspeed = 255;
    
  if (lspeed > 255) 
    lspeed = 255;
    
  if (rspeed < -255) 
    rspeed = -255;
    
  if (lspeed < -255) 
    lspeed = -255;
 
 motor_drive(rspeed,lspeed);  
}

void motor_drive(int right, int left){
  
  if(right>0)
  {
    analogWrite(rmf, right);   
    analogWrite(rmb, 0);
  }
  else 
  {
    analogWrite(rmf, 0); 
    analogWrite(rmb, abs(right));
  }
  
 
  if(left>0)
  {
    analogWrite(lmf, left);
    analogWrite(lmb, 0);
  }
  else 
  {
    analogWrite(lmf, 0);
    analogWrite(lmb, abs(left));
  }
  
}

Here, the robot uses an array of sensors (long sensor[] = {0, 1, 2, 3, 4}) to detect the line and motors controlled by specific pins (rmf = 9, rmb = 6, lmf = 10, lmb = 11) to adjust its direction. The setup function initializes the sensors and motors, and a button press determines the set point (sp), representing the desired position of the robot on the line. The PID controller's gains (Kp, Ki, Kd) are defined, with initial dummy values for proportional, integral, and derivative terms, respectively.

In the loop, the pid_calc() function calculates the error between the current position (pos) and the set point, updating the PID terms and computing the correction. This correction adjusts the motor speeds (rspeed and lspeed), ensuring the robot follows the line accurately. The calc_turn() function determines the appropriate motor speeds based on the correction and limits them within the range of -255 to 255. Finally, motor_drive(int right, int left) applies these speeds to the motors, ensuring the robot's movement aligns with the PID controller's output. The result is a smoother and more accurate line-following behavior compared to simpler control methods.

Tuning PID Coefficients

Tuning the K_p​, K_i​, and K_d coefficients is crucial for optimal performance. This process often involves trial and error:

• Start with K_p: Increase K_p​ until the robot starts oscillating around the line.
• Adjust K_i​​: Increase K_i​ to eliminate any steady-state error.
• Fine-tune with K_d​: Increase K_d​ to dampen the oscillations.

Conclusion

Using a PID controller significantly improves the performance of a line-follower robot compared to simple bang-bang control. By considering the current error, accumulated past errors, and the rate of error change, the robot can follow the line more accurately and smoothly. This project not only demonstrates the effectiveness of PID control but also provides a solid foundation for more advanced robotics projects.

Happy building and coding!

The post Implementing PID for a Line Follower Robot appeared first on Microcontroller Tutorials.