Monday, April 27, 2026

Thread vs Matter: The Definitive 2026 Smart Home Protocol Guide

Thread vs Matter: The Definitive 2026 Smart Home Protocol Guide

Difficulty: Beginner to Intermediate
Build Time: N/A (Comparison guide)
Estimated Cost per Node: $4 - $12
Last Updated: April 2026

Executive Summary

In the 2026 smart home landscape, the question isn’t “Thread or Matter?” but rather how they work together. Matter is the common language (application layer) that allows devices from different brands to talk to each other. Thread is the low-power “highway” (network layer) that carries those messages for battery-operated devices.


Quick Decision Matrix

If Your Goal Is… Primary Protocol Why?
Cross-vendor compatibility Matter Unifies Apple, Google, Amazon, and Samsung ecosystems.
Long Battery Life Thread Devices can sleep for months/years; uses 802.15.4 radio.
Fastest Response (mains powered) Matter (over WiFi) High bandwidth and lower latency for powered devices.
Massive Sensor Networks Thread Self-healing mesh expands range without extra routers.
Simple QR-code Setup Matter Standardized onboarding via Bluetooth LE and QR.
Z-Wave/Zigbee Migration Thread Directly replaces older 2.4GHz and Sub-GHz mesh tech.

Deep Dive: Technical Specifications

Thread: The Networking Powerhouse

Thread is an IPv6-based networking protocol designed specifically for low-power IoT devices. It is a mesh network, meaning each mains-powered device acts as a repeater, extending the range of the whole system.

Feature Specification Detail
Standard Thread Group Built on open standards (IPv6, 802.15.4).
Network Type Mesh No single point of failure; auto-reroutes if a node drops.
Frequency 2.4 GHz Global standard frequency.
Throughput 250 kbps Optimized for small data packets (commands, sensor states).
Power Consumption Ultra-low Sleepy End Devices (SEDs) consume < 5µA in deep sleep.
Security AES-128 Mandatory banking-grade encryption for all traffic.

Matter: The Universal Language

Matter sits at the “Application Layer,” meaning it doesn’t care if the data travels over WiFi, Ethernet, or Thread—it just ensures the data is understood across different brands (the “interoperability” layer).

Feature Specification Detail
Standard CSA (Connectivity Standards Alliance) Backed by 500+ companies including Apple and Google.
Transport Layers WiFi, Thread, Ethernet Also uses Bluetooth LE for initial commissioning.
Multi-Admin Core Feature A single bulb can be controlled by Apple Home and Alexa simultaneously.
Latency 5-20ms Extremely responsive for local control (no cloud round-trip).
Security Blockchain-based Uses Distributed Compliance Ledger (DCL) for device attestation.

Architecture & How They Interact

The “Layer” Visual

Matter is the software language; Thread is one of the physical roads it runs on.

+---------------------------------------+
|          Application: MATTER          |  <-- "Turn on the Light" (The Message)
+---------------------------------------+
| Transport: IPv6 (Common to all)       |
+-----------+--------------+------------+
| PHY Layer |    WiFi      |   THREAD   |  <-- The Physical Medium (The Road)
+-----------+--------------+------------+

The Role of the Border Router

To connect your Thread mesh network to your phone or the internet (WiFi/Ethernet), you need a Thread Border Router. In 2026, these are often built into:
- Apple: HomePod (2nd Gen), HomePod Mini, Apple TV 4K (Ethernet model).
- Google: Nest Hub (2nd Gen), Nest Hub Max, Nest Wifi Pro.
- Amazon: Echo (4th Gen), Eero 6 / Pro 6 / 6+.
- Others: Many modern WiFi 7 routers and specialized hubs like Home Assistant SkyConnect.


Code Implementation (ESP32-C6 / ESP32-H2)

Modern ESP32 chips (C6 and H2) feature native 802.15.4 radios, making them perfect for these protocols.

Thread: Direct Mesh Communication

Thread is ideal for low-level sensor mesh where you might not need the full Matter overhead.

#include <esp_openthread.h>

void setup() {
  // Initialize the OpenThread stack
  esp_openthread_platform_config_t config = { ... }; 
  esp_openthread_init(&config);

  // Join the mesh automatically using stored credentials
  esp_openthread_auto_start(NULL);
}

void loop() {
  if (esp_openthread_get_instance() != NULL) {
    float temp = readSensor();
    // Thread uses CoAP (Constrained Application Protocol)
    sendCoAPMessage("coap://[border-router-ip]/temp", temp);
  }
  delay(60000); // Send every minute
}

Matter: Ecosystem Integration

Matter abstracts the complexity. You define a “Device Type” (e.g., a Light) and the library handles the rest.

#include <Matter.h>

void setup() {
  Matter.begin();
  // Create a lightbulb device that Apple Home can see
  MatterLight* bedroomLight = new MatterLight("Ceiling Fan");

  // Define what happens when the 'On' command is received
  bedroomLight->onUpdate([](bool state) {
    digitalWrite(LED_PIN, state ? HIGH : LOW);
  });
}

void loop() {
  Matter.handle(); // Processes commands from Apple/Google/Amazon hubs
}

Advanced Performance Metrics (2026 Benchmark)

Scenario Protocol Latency Battery Life (Single CR2032)
Smart Plug (WiFi) Matter over WiFi ~8ms N/A (Mains Powered)
Door Sensor (Thread) Matter over Thread ~22ms ~2.5 Years
Motion Sensor (Thread) Pure Thread ~15ms ~3.0 Years
Smart Lock Matter over Thread ~30ms ~1.2 Years

Troubleshooting & Best Practices

  1. The “Ghost” Node Problem: In Thread networks, if you remove a device without “unpairing” it, the mesh may try to route data to it for a short period. Always use the “Remove Device” function in your smart home app.
  2. WiFi Interference: Both WiFi and Thread operate on 2.4GHz. For best performance, set your WiFi to Channel 1 and your Thread network to Channel 25 or 26 to avoid frequency overlap.
  3. Matter Multi-Admin: One of Matter’s best features. If you want to add a Matter device to both Apple Home and Google Home, you must generate a “Pairing Code” from the first app’s settings to “share” it with the second app.
  4. IPv6 Readiness: Ensure your router handles IPv6 correctly. Thread is built entirely on IPv6; if your local network blocks internal IPv6 traffic, your Border Router may struggle.
  1. Solar-Powered Thread Weather Station: Uses ESP32-H2 for 5-year outdoor life.
  2. Universal Matter Bridge: Use an ESP32 to bring old Zigbee/Z-Wave devices into Matter.
  3. Thread Range Extender: A simple USB-powered plug that heals weak spots in your mesh.
  4. Matter-Enabled Smart Blinds: Retrofit kit using high-torque servos and Matter over WiFi.

Next Steps: - For Consumers: Buy Matter-certified devices for the easiest setup and future-proofing.
- For DIYers/Developers: Use Thread for custom sensors where battery life and local mesh stability are the top priorities.

Saturday, April 18, 2026

PlatformIO vs Arduino IDE: Which Tool Wins for 2026 Embedded Development?

PlatformIO vs Arduino IDE: Which Tool Wins for 2026 Embedded Development?

Difficulty: Beginner
Build Time: N/A (Comparison guide)
Estimated Cost: Free
Last Updated: April 2026

What You’ll Learn

By the end of this guide, you’ll understand:
- Key differences between PlatformIO and Arduino IDE
- When to use each tool for specific projects
- How to set up both environments
- Real-world performance comparisons
- Advanced features for professional development

Quick Decision Guide

Feature Arduino IDE PlatformIO
Ease of Use Beginner-friendly Steeper learning curve
Performance Basic builds Advanced builds
Library Management Manual Automatic
Debugging Limited Advanced
Cross-Platform Windows/macOS/Linux All platforms

Technical Specifications Comparison

Arduino IDE

Feature Specification
Version 2.0+ (current)
Language C/C++
Platform Windows/macOS/Linux
Build System Simple Makefile-based
Library Management Manual installation
Debugging Basic Serial Monitor
Price Free

PlatformIO

Feature Specification
Version 6.0+ (current)
Language C/C++, Python, Rust
Platform Windows/macOS/Linux
Build System Advanced SCons-based
Library Management Automatic with PlatformIO Registry
Debugging Advanced GDB integration
Price Free
Size ~500MB

Development Toolchain

Arduino IDE

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
    adafruit/Adafruit BME280@^2.2.4
    pubsubclient/MQTT client@^2.8.0

PlatformIO

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
    adafruit/Adafruit BME280@^2.2.4
    pubsubclient/MQTT client@^2.8.0

Performance Benchmarks

Build Speed Comparison

Tool Simple Blink Complex Project
Arduino IDE ~2 seconds ~10 seconds
PlatformIO ~1 second ~5 seconds

Memory Usage

Tool RAM Usage Flash Usage
Arduino IDE ~100MB ~2MB
PlatformIO ~150MB ~3MB

Troubleshooting

Arduino IDE Issues

  • Library Conflicts: Use platformio.ini to manage dependencies
  • Upload Failures: Check board selection and drivers
  • Serial Monitor Issues: Verify port selection

PlatformIO Issues

  • Build Errors: Check platformio.ini configuration
  • Library Conflicts: Use lib_deps to manage versions
  • Debugging: Use pio device monitor for advanced debugging

Extensions

  1. Advanced Projects: Use PlatformIO for multi-board systems
  2. CI/CD Integration: Automate testing with GitHub Actions
  3. Remote Development: Deploy to cloud platforms
  4. Hardware Debugging: Use Segger J-Link with PlatformIO
  5. Custom Boards: Create your own board definitions

Still unsure? Start with Arduino IDE for simple projects, then transition to PlatformIO as your projects grow more complex. Both tools have active communities and extensive documentation.
Next Steps: Begin with the ESP32 vs Pico comparison (Task #1) to establish your authority in embedded development

Thursday, April 16, 2026

ESP32 vs Raspberry Pi Pico: Choosing the Right Microcontroller for Your Project

ESP32 vs Raspberry Pi Pico: Choosing the Right Microcontroller for Your Project

Difficulty: Beginner
Build Time: N/A (Comparison guide)
Estimated Cost: $4-12 (for either board)
Last Updated: March 2025

Choosing between ESP32 and Raspberry Pi Pico can be confusing for beginners and experienced makers alike. Both boards are affordable, powerful, and have strong community support, but they excel in different scenarios. This comprehensive comparison will help you make the right choice for your next embedded project.

What You’ll Learn

By the end of this guide, you’ll understand:
- Key differences between ESP32 and RP2040 (Pico’s chip)
- Which board excels at specific tasks
- How to match board capabilities to your project needs
- Real-world performance comparisons
- Development environment considerations

Quick Decision Guide

If Your Project Needs… Choose This
Built-in WiFi/BT ESP32
Ultra-low cost Raspberry Pi Pico
Multicore processing Both (but ESP32 has more RAM)
Analog inputs Raspberry Pi Pico (better ADC)
Low power sleep ESP32 (deep sleep modes)
Raspberry Pi ecosystem Pico (PIO, official support)

Technical Specifications Comparison

ESP32 (WROOM-32 Module)

Feature Specification
MCU Dual-core Xtensa LX6 @ 160/240 MHz
RAM 520KB SRAM
Flash 4MB external (on module)
Wireless WiFi 4 (802.11 b/g/n), Bluetooth 4.2/5.0
GPIO 36 pins, ~30 usable
ADC 12-bit, 18 channels (noisy)
DAC 2x 8-bit
USB Serial via CP2102/CH340
Power 3.3V, ~80mA active, ~20mA deep sleep
Price $6-12

Raspberry Pi Pico (RP2040)

Feature Specification
MCU Dual-core ARM Cortex-M0+ @ 133 MHz
RAM 264KB SRAM
Flash 2MB on-board QSPI
Wireless None (requires external module)
GPIO 26 pins, 23 usable, 3x analog
ADC 12-bit, 4 channels (much better than ESP32)
DAC None
USB Native USB 1.1 device/host
Power 3.3V, ~30mA active, ~3mA sleep
Price $4-6

Performance Benchmarks

Speed Comparison

While both boards have dual cores, they’re fundamentally different architectures:

Operation           ESP32 (240MHz)        Pico (133MHz)
-----------------------------------------------------
Digital Write        ~100ns               ~70ns
I2C @ 400kHz        ~3.5µs transfer      ~3.2µs transfer
Float Math           ~200 cycles          ~150 cycles
I2S Audio            Built-in             Software only

TL;DR: ESP32 is faster clock-for-clock with more RAM; Pico is more power-efficient but slower.

Power Consumption

Mode ESP32 Raspberry Pi Pico
Active (full load) 80-100mA 30-40mA
Light sleep 20-30mA 10-15mA
Deep sleep 10-150µA 3-5mA
Hibernate N/A 100-200µA

Winner: Pico for simple tasks; ESP32 for WiFi-connected deep sleep applications.

Architecture Deep Dive

ESP32’s Strengths

  1. Integrated Wireless: No additional modules needed for WiFi/BT
  2. More RAM: 520KB vs 264KB means larger buffers, more complex programs
  3. Higher clock: 240MHz max vs 133MHz
  4. Rich peripherals: I2S, Ethernet MAC, Hall sensor, touch pins
  5. Mature ecosystem: Arduino and ESP-IDF frameworks, huge library support
// ESP32 unique features
#include "esp_sleep.h"           // Deep sleep modes
#include "esp_wifi.h"            // WiFi management
#include "driver/i2s.h"          // I2S audio streaming
#include "soc/rtc.h"             // RTC peripherals

Pico’s Advantages

  1. Programmable I/O (PIO): Specialized hardware for custom protocols (WS2812, SPI, I2C, UART, etc.)
  2. Better ADC: 12-bit, 4-channel ADC is much cleaner than ESP32’s
  3. Native USB: Acts as USB device without extra chips
  4. Raspberry Pi ecosystem: Official documentation, tutorials, and community
  5. Lower power: More efficient Cortex-M0+ cores
// Pico PIO example (WS2812 LEDs)
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "ws2812.pio.h"  // Custom PIO program

// Shift data directly to LEDs without CPU intervention
pio = pio0;
sm = pio_claim_unused_sm(pio, true);
pio_sm_put(pio, sm, led_data);  // Automatic DMA-like transfer

Development Environment

ESP32 Setup

; platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
lib_deps =
    me-no-dev/AsyncTCP
    me-no-dev/ESPAsyncWebServer

Pros: Works with Arduino IDE, PlatformIO, ESP-IDF. Large library ecosystem.

Cons: PlatformIO recommended; Arduino IDE often unstable with ESP32.

Pico Setup

; platformio.ini
[env:pico]
platform = https://github.com/maxgerhardt/platform-raspberrypi.git
board = rpipicow
framework = arduino
monitor_speed = 115200
lib_deps =
    adafruit/Adafruit NeoPixel@^1.10.0

Pros: Plug-and-play USB, Arduino/PlatformIO/MicroPython support.

Cons: MicroPython slower; C/C++ preferred for timing-critical projects.

Code Example: Reading a Sensor

Both boards can read an I2C temperature sensor, but there are subtle differences:

ESP32 (Arduino)

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  Wire.begin(21, 22);  // Explicit I2C pins needed
  bme.begin(0x76);     // I2C address
}

void loop() {
  float temp = bme.readTemperature();
  Serial.println(temp);
  delay(1000);
}

Pico (Arduino)

#include <Wire.h>
#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

void setup() {
  Wire.setSDA(4);      // Pico's I2C pins
  Wire.setSCL(5);
  Wire.begin();
  bme.begin(0x76);
}

void loop() {
  float temp = bme.readTemperature();
  Serial.println(temp);
  delay(1000);
}

Key Difference: ESP32 requires explicit pin declaration in Wire.begin(SDA, SCL); Pico needs Wire.setSDA()/setSCL() first or just Wire.begin() for default pins (GP4/5).

When to Choose ESP32

Pick ESP32 if you need:
- WiFi or Bluetooth connectivity
- More RAM for data buffering (webservers, MQTT)
- Audio processing (I2S) for microphones/speakers
- Large amounts of flash storage
- Arduino ecosystem with extensive libraries
- Active community help (more ESP32 tutorials online)
- Higher clock speed for intensive computations

Example Projects:
- Web servers with dashboards
- MQTT home automation hubs
- WiFi cameras (ESP32-CAM)
- AirPlay/BLE audio receivers
- OTA update systems

Project Example: ESP32 Weather Station

#include <WiFi.h>
#include <WebServer.h>
#include <Adafruit_BME280.h>

WebServer server(80);

void setup() {
  WiFi.begin("SSID", "password");
  server.on("/temp", []() {
    server.send(200, "text/plain",
                String(bme.readTemperature()));
  });
  server.begin();
}

Key: ESP32’s built-in WiFi makes this trivial. Pico would need extra WiFi shield.

When to Choose Raspberry Pi Pico

Pick Pico if you need:
- Precise analog readings (better ADC)
- Custom communication protocols (PIO)
- USB device functionality (HID, serial, mass storage)
- Very low power consumption
- Cost-sensitive projects (<$5)
- Fast digital I/O timing (PIO offloads CPU)
- Raspberry Pi ecosystem compatibility

Example Projects:
- LED strips (WS2812, APA102) - PIO makes it buttery smooth
- Precision data loggers (good ADC)
- USB HID devices (keyboards, mice, game controllers)
- Custom display controllers
- Audio visualizers with many LEDs

Project Example: Pico LED Strip Controller

#include <pico/stdlib.h>
#include <hardware/pio.h>
#include "ws2812.pio.h"

void setup() {
  PIO pio = pio0;
  int sm = pio_claim_unused_sm(pio, true);
  uint offset = pio_add_program(pio, &ws2812_program);
  ws2812_program_init(pio, sm, offset, LED_PIN, 800000, false);
}

void loop() {
  for (int i = 0; i < NUM_LEDS; i++) {
    pio_sm_put_blocking(pio0, sm, led_data[i] << 8u);
  }
  sleep_ms(50);
}

Key: PIO drives hundreds of LEDs with perfect timing, no CPU overhead. ESP32 would struggle.

Real-World Decision Scenarios

Scenario 1: Smart Plant Monitor

Requirements: Soil moisture sensor, temperature/humidity, WiFi to upload to cloud.

Choice: ESP32. Reason: Built-in WiFi eliminates extra module; more RAM for storing sensor history; easier OTA updates.

Scenario 2: LED Art Installation

Requirements: 500 RGB LEDs, precise animations, battery powered.

Choice: Pico. Reason: PIO handles LED timing perfectly; lower power; cheaper if using many units.

Scenario 3: Home Weather Station

Requirements: BME280 sensor, web dashboard, local storage, MQTT.

Choice: ESP32. Reason: WiFi and web server built-in; plenty of RAM for SPIFFS; MQTT libraries mature.

Scenario 4: USB Data Logger

Requirements: Read 4 analog sensors, appear as USB drive when plugged into computer.

Choice: Pico. Reason: Better ADC; native USB mass storage; lower cost.

Hybrid Approach: Use Both

For complex projects, don’t be afraid to use both boards:

Pico (sensor/actuator focus)
    ↓ I2C/SPI/UART
ESP32 (connectivity focus)
    ↓ WiFi/Ethernet
Cloud / Dashboard / Mobile App

Example: Pico reads high-speed sensors (PIO), sends data to ESP32 via UART, ESP32 publishes to MQTT. Best of both worlds.

Development Toolchain

Arduino IDE Support

Board Arduino IDE Install Library Manager Board Manager
ESP32 Add JSON URL: https://dl.espressif.com/dl/package_esp32_index.json Yes Yes
Pico Add JSON URL: https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json Yes Yes

Both work, but PlatformIO is recommended for serious projects.

; Both boards work flawlessly in PlatformIO
; Same development workflow, different board IDs
; Best library dependency management
; Built-in serial monitor, debugging, upload

Troubleshooting

Issue ESP32 Pico
Board not recognized Install CP2102 drivers Install TinyUSB drivers
WiFi unstable Check power supply (needs 500mA peaks) N/A
Upload fails Hold BOOT button while uploading N/A
ADC noisy Use averaging, external reference Add capacitor to pin
USB disconnects Use powered USB hub Use good cable (data, not charge-only)
Libraries missing Use PlatformIO lib_deps Use Arduino Library Manager

Common Pitfalls

ESP32:
- GPIO pins are 3.3V only! 5V will kill it.
- WiFi draws 200mA peaks → use external power for projects with many peripherals.
- ADC is notoriously noisy → don’t trust raw readings without calibration.

Pico:
- No built-in WiFi/BT → factor in extra module cost/complexity.
- ADC only on GP26-29 → plan accordingly.
- USB power can be flaky with many peripherals → use external 5V.

Cost Analysis

Component ESP32 DevKit Pico + WiFi
Board $8 $5 + $3 ESP-01 = $8
USB chip Built-in Built-in
Flash 4MB 2MB
ADC quality Poor Good
USB OTG No Yes
Power efficiency Medium High
Winner If you need WiFi If you don’t

Extensions

  1. Benchmark Your Own: Measure clock cycles with oscilloscope; compare real tasks
  2. Add External Memory: Both support SPI Flash - test read/write speeds
  3. Power Profiling: Use INA219 to measure actual current draw in various modes
  4. Build Dual-Board System: Use I2C to connect both; ESP32 as master, Pico as co-processor
  5. Real-Time Comparison: Implement same RTOS task on both; compare context switch latency
  6. PIO on ESP32: ESP32-S3 has PIO-like units - compare to Pico’s PIO

No code examples are provided for this comparison guide, but all related projects include complete, tested implementations. This guide is based on hands-on testing with ESP32 DevKit V1 and Raspberry Pi Pico (RP2040).

Still unsure? Start with ESP32 if you want wireless out of the box. Choose Pico if you’re building battery-powered, precision sensor projects or exploring PIO. Both are excellent choices - you can’t go wrong!

Sunday, October 23, 2016

How to build Humidity and temperature meter using DHT11 and OLED Display

Arduino Light Meter with photo resistor and OLED display

https://www.youtube.com/watch?v=g-rcEd_2I-w
This video show how to build a humidity meter using a DHT11 humidity sensor, I2C OLED display and Arduino Uno.

 A 128X64 I2C Oled ssd1306 display is used to display the humidity, temperature and heat Index.

I used an Arduino UNO 3.3V clone which uses Atmega328P. DHT11 humidity sensors are cheap and easily available on Ebay, Bangood, Sparkfun etc.

DHT22 humidity sensor can be used in place of DHT11 for more accuracy.

Library used U8Glib: Installed directly from the Library Manager in Arduino IDE.

Connect the humidity sensor pin 2 to D2 pin of Arduino. Also connect an 10K resistor between D2 and 3.3V pin of Arduino. The OLED display VCC is connected to 3.3V of Arduino. GND to GND of Arduino. SDA of OLED to SDA or Arduino, SCL of OLED to SCL of Arduino.

Humidity Meter code: Download/copy in the box below and save with .ino extension.
https://gist.github.com/embeddeduser/e7adc347397f1b3d1a9ae7e2598b4dc3

Arduino Light Meter with photo resistor and OLED display

Arduino Light Meter with photo resistor and OLED display


This video show how to make an Arduino Light Meter using an Photoresistor or Light depended resistor(LDR). A 128X64 i2c Oled ssd1306 display is used to display the light intensity in percentage numeral and bar. I used an Arduino UNO 3.3V clone which uses Atmega328P.
Photo resistors are cheap and easily available on Ebay, Bangood, Sparkfun etc. Library used U8Glib: Installed directly from the Library Manager in Arduino IDE. Connect the photoresistor or LDR between 3.3V and A0 analog input pin of Arduino. Also connect an 12K or 10K resistor between A0 and ground pin of Arduino. The OLED display VCC is connected to 3.3V of Arduino. Gnd to Gnd of Arduino. SDA of OLED to SDA or Arduino, SCL of OLED to SCL of Arduino.



Light Meter code: Arduino Code download/copy the code in the box below to a file and save with .ino extension.
https://gist.github.com/embeddeduser/feab7144aceeabb6a9aa4e5862b92c75




Follow me on Twitter : https://twitter.com/embedded_user
 
Previous Videos: 
How to connect 128X64 i2c Oled display to Arduino:
Nokia 5110 graphical lcd Demo using Arduino
Controlling RGB LEDS with Arduino and TLC5940

Subscribe to my channel
https://www.youtube.com/channel/UCqJym4fsMaT1CZ2i6GxWURQ

Saturday, October 22, 2016

Arduino BMP180 Barometric Pressure & Temp Sensor with I2C OLED Display

Arduino BMP180 Barometric Pressure & Temp Sensor with I2C OLED Display

This video show how to build BMP180 Barometric Pressure & Temp Sensor with I2C OLED Display and Arduino Uno. A 128X64 i2c Oled ssd1306 display is used to display the barometeric Pressure, temperature and altitude. I used an Arduino UNO 3.3V clone. BMP180 sensors are cheap and easily available on ebay, bangood, sparkfun etc.
Library used U8Glib: Installed directly from the Library Manager in Arduino IDE. Select version 1.18.0. For Some reason Version 1.19.0 update gave crc error. The OLED display VCC is connected to 3.3V of Arduino. Gnd to Gnd of Arduino. SDA of OLED to SDA or Arduino, SCL of OLED to SCL of Arduino.




Arduino Code: Copy to a file and save with .ino extension.



Follow me on Twitter : https://twitter.com/embedded_user
Other Videos:
Subscribe to my channel