#i2c module

[stlle2ista]

https://www.futureelectronics.com/p/semiconductors--comm-products--i2c/pca9532pw-118-nxp-5033862

I2c bus, Embedded communication, Isolated CAN Transceiver ICs

PCA9532 Series 5.5 V 350 uA 400kHz SMT 16-bit I2C-bus LED Dimmer - TSSOP-24

[knet2thorn]

https://www.futureelectronics.com/p/semiconductors--comm-products--i2c/pca9532pw-118-nxp-5033862

16-bit I2C-bus LED Dimmer, Embedded communication, image processing,

PCA9532 Series 5.5 V 350 uA 400kHz SMT 16-bit I2C-bus LED Dimmer - TSSOP-24

[didw2rden]

https://www.futureelectronics.com/p/semiconductors--comm-products--i2c/pca9515adp-118-nxp-5973557

I2C CAN Bus Module, I2C adapter, I2C devices, Serial Peripheral Interface

PCA9515A Series 3.6 V 5 mA 400 kHz 6 pF Surface Mount I2C-bus Repeater - SOIC-8

[adafruit]

Leftovers & layout - WLED board revision A completed!

Sunday night, Babyada went to bed early, so we finished the capture and layout of our WLED board. Thanks to all the suggestions, we were able to implement quite a few!

For power, use USB C PD with switch-select or DC up to 24V; they are diode-OR'd together with PMEG3050

https://www.digikey.com/short/zv22b0pq

into a massive 5A 24V fuse

https://www.digikey.com/short/43qwwtwm

For the 5V regulator, we picked NCP718ASN500T1G

https://www.digikey.com/short/bb9ncc0n

- it's linear, but we don't need a lot of current at 5V. For 3.3V, we went with our trusty TPS54202

https://www.digikey.com/short/c1wnnf94

Upon request, we kept the ICS-43434 I2S microphone

https://www.digikey.com/short/28zwrrhz

and added an IR 38KHz receiver. For external connectivity, there's an ADC/DAC/GPIO #27 breakout on a JST SH 3-pin and I2C on a StemmaQT/Qwiic 4-pin.

We also added a 2x3 breakout header with 3V, GND, and 3 more GPIO so you could connect an external microphone, IR receiver, buttons, or rotary encoder. The terminal blocks have three 5V level-shifted outputs with 100 ohm in-line resistors and power/ground pairs for each. If you need just one more LED strand, the fourth 5V signal is on the 2x3 block.

Rounding out the design are four mounting holes, a reset button, GPIO #0 user button, GPIO LED, and an individual NeoPixel, which could be useful for testing. It's still pretty small, 2" x 1.3". With an ESP32-Mini module, we can pick a PCB or wFL antenna port, and it's an easy swap to make it use an ESP32-Pico, which has 2MB PSRAM.

Whatcha think - anything else we should add or watch out for?

[christanworkshop]

DIY: Making A Pwnagotchi

Yes, I know I am very late to the game ... LOL I was meddling with Flipper Zero and war driving, then I came across the Pwnagotchi project. Since I already had the parts to do this lying around in my workshop, I decided to put together my own Pwnagotchi just for fun. Started by hooking up the Waveshare 2.13" Black and White E-Ink Display to a Raspberry Pi running a fresh Raspbian image and downloaded the Waveshare demo code to test the display to make sure it's working properly, since I have not actually used it before. This is a v4 display.

After that, I just followed all the instructions over here to put it all together, including adding a real time clock. I used the DS3231 RTC module designed for Pi, but in order to make it fit into the space between the display and the Pi board, I had to make some modifications. The female header pins on the RTC module was desoldered and short wires were soldered on. The battery also had to be desoldered and resoldered on in a new positionlike below to make the module thin enough. The module was then wrapped in wire tape for insulation. Now, we can just slot the wires into the female header pin holes of the display before we snap it onto the Pi board.

Below, you can see the RTC fits comfortably between the boards. I also attached a UPS Lite v1.2 board. Apparently, the UPS Lite board I had was a clone/knock off. It uses I2C address of 0x32 instead of 0x36 that was used in the original product, so the UPS Lite plugin in Pwnagotchi won't work. Oh well, I will just use it like a normal battery pack.

Now, for the software. The original Pwnagotchi project has not had any new updates for over 2 years, so it's kinda out of date and it doesn't support the newer Waveshare displays. Luckily for us, someone had taken the effort to fork the project and released new versions of Pwnagotchi over here. Note that this requires Raspberry Pi Zero 2 W.

The Waveshare 2.13" E-Ink display that I had was v4, but I found that I had to set the display type to "waveshare_3" in Pwnagotchi settings for it to work properly. Next is to 3D print a case for this, but in the mean time, I used some nano bricks to build a temporary case for it.

That's it for now. Happy hacking!

[ui-alcoholic]

clockwork PicoCalc

clockwork PicoCalc Back to Basics, rediscover the Golden Age of Computing

Code in BASIC, explore the magic of Lisp, taste the elegance of Unix, play retro games and digital music all in just 260KB memory. Infinite possibilities, inspired by the genius in you!

ClockworkPi v2.0 mainboard

Raspberry Pi Pico 1 H Core module (ARM32-bit Dual-core Cortex M0+, 264KB RAM, 2MB flash)

320x320 4-inch IPS screen (SPI interface)

Ultra-portable QWERTY Backlit keyboard on board (I2C interface)

Dual speaker

ABS plastic shell & 2.5mm Hex key

Tempered glass cover

32GB high-speed SD-card with optimized BASIC firmware

source: clockworkpi.com

[quartz-components]

How to Use AHT10 High Precision Digital Temperature & Humidity Sensor with Arduino

Looking to measure temperature and humidity with high accuracy using Arduino? The AHT10 sensor is a compact, I2C-based module that provides reliable data, making it perfect for IoT projects, weather stations, and smart home automation.

What You’ll Learn: ✔️ How the AHT10 sensor works ✔️ Wiring it to an Arduino board ✔️ Writing & uploading the code to get readings ✔️ Tips for stable and accurate measurements

What You Need:

AHT10 Temperature and Humidity Sensor Module

Arduino Nano

0.96 inch SSD1306 OLED Display (128x64, I2C)

Breadboard

Connecting/Jumper Wires

Arduino Nano Cable

Download the Code & Library Arduino AHT10 Temperature and Humidity Sensor Module

Watch the full tutorial on YouTube:

Follow for more DIY electronics tutorials & Arduino projects!

[c-53]

WARNING: LONG ASK INCOMING

For hobby electronics there’s two major kinds of processors: Microcomputers and Microcontrollers. Microcomputers are small full computer systems like the Raspberry Pi, they typically run a general-purpose OS (typically some flavor of Linux) and are useful for the kinds of projects that require basically a full computer to function, but not necessarily individual sensors. They’re a great place to start for people who don’t know a whole ton about programming or working with individual components because they typically can output a true GUI to a screen and have the capabilities of a regular desktop computer. They have a main processor, true RAM, and either large on-board storage space or a way to read a storage device, like an SD card.

Microcontrollers are less complicated (component wise) than microcomputers, but as a result are more difficult for total beginners to begin working with. They’re typically primarily a SoC (System on a Chip) processor without discrete RAM modules and a very small EEPROM (on-ship storage space) and need to have components wired and configured to them to be able to do much more than being a fancy calculator. They’re used for when you need something to carry out electronic functions or get sensor readings, but not necessarily a full operating system, so they’re best suited for small/integrated applications. Your helmet uses a microcontroller to control the LEDs you used in the Cunt Machine post.

I build high-power model rockets as a hobby and with my university team, so I work with both kinds of processor as part of designing payload systems. I typically prefer microcontrollers in these as most of what we do doesn’t need an actual OS to run, and they’re smaller/lighter than microcomputers. One of the advantages of a microcontroller is that it runs a Real-Time OS (RTOS) which forgoes all the user-friendliness of things like windows and linux to instead be the bare minimum backend necessary to run code uploaded into the processor. 

The main advantage of using a microcontroller is really that they’re typically a lot cheaper than microcomputers are and are plenty powerful for really embedded applications. They also make other parts of whatever system is being built cheaper/easier to integrate because they require less overhead to function - the raspberry pi needs a minimum of 5 volts of power to work, while a chip like an ESP32-PICO can run at 1.8V. 

The main way you make sensors/buttons/peripherals work with a microcontroller is via digital communication busses. There’s a few protocols, the most common being I2C, SPI, and UART. I’ll talk about I2C since that’s generally the most common. With I2C each component is assigned a 2-byte “address” that they’re identified by. When the controller sends a request signal on the I2C data bus, every sensor along the line will return their own signal, marked with their address so that they can be identified. It allows for a large number of devices to be put on the same lines and you can daisy-chain them through each other to the microcontroller.

I’ll be honest I really can’t think of a good way to say much more on the subject as like a starting message because I’ve been working with computers so long all the tech stuff for me is second nature, but if you have any questions ask away I can probably answer them or google them.

.

[g-nicerf]

Characteristics and Applications of LoRa Spread Spectrum Modulation SoC Module

LoRa spread spectrum modulation technology, known for its low power consumption and long-distance transmission capabilities, excels in long-range wireless communication. So, what kind of sparks will this modulation technology create when applied to SOC modules? Let's briefly illustrate this with the LoRa-STM32WLE5 LoRa spread spectrum modulation SOC module developed by NiceRF.

The LoRa-STM32WLE5 wireless module  is SOC wireless module the latest  developed by NiceRF Wireless. The LoRa-STM32WLE5 adopts ST's STM32WLE5 chip as the main chip, equipped with a high-performance Arm Cortex-M4 32-bit RISC core, operating at a frequency of up to 48 MHz. supporting 256KB flash memory and 64KB operational memory. This module ensures ample storage and processing capabilities. Additionally, the module is equipped with an industrial-grade crystal oscillator, ensuring stable operation in various working environments. 

In terms of communication technology, the LoRa-STM32WLE5  adopts  LoRa spread spectrum modulation, which features low power consumption and long-distance transmission. This makes the module perform exceptionally well in ultra-long-range wireless communication. It has a high receiving sensitivity of up to -141dBm@BW=125KHz and adjustable transmission power, with a maximum of 22dBm, allowing for transmission distances of over 5000 meters. This characteristic offers extensive application possibilities in fields such as security systems, smart agriculture, and industrial manufacturing. 

In addition to its technical features, the LoRa-STM32WLE5  also has  advantages such as low power consumption, secure encryption, and multiple interface types. Its sleep current is less than 1uA, and its receive current is less than 8mA, making it suitable for scenarios requiring long battery life and high energy efficiency. Additionally, it supports 256-bit hardware encryption and PCROP read/write protection, ensuring data security and integrity. The support for various interface types, including UART, SPI, I2C, GPIO, and ADC, enables it to meet the interface needs of different application scenarios, offering excellent scalability and flexibility.

In terms of applications, the LoRa-STM32WLE5 wireless module can be widely used in security systems, smart agriculture, industrial manufacturing, and smart home scenarios.

For example: in security systems, it can be used for remote monitoring and alarm systems; in smart agriculture, it can be utilized for agricultural environment monitoring and automated irrigation systems;in industrial manufacturing, it can be applied to equipment monitoring and remote control systems; and in smart homes, it can be used for smart door locks and environmental monitoring.

In the future, with the development of IoT technology and the proliferation of intelligent applications, the LoRa-STM32WLE5 wireless module is expected to demonstrate its value in more fields. For instance, in urban smart construction, it can be applied to smart city traffic systems and intelligent energy management. In the industrial IoT sector, it can be used for remote monitoring of industrial equipment and intelligent production lines. Additionally, as technology continues to advance and costs continue to decrease, the LoRa-STM32WLE5 wireless module will become more widespread and mature, bringing more convenience and possibilities to people's lives. 

For details, please click：https://www.nicerf.com/products/ Or click：https://nicerf.en.alibaba.com/productlist.html?spm=a2700.shop_index.88.4.1fec2b006JKUsd For consultation, please contact NiceRF (Email: sales@nicerf.com).

[bliiot-jerry]

ARM AI Edge Controller + Prometheus Database for Smart Building Energy Monitoring

Case Details

ARM Embedded Computers and Prometheus Overview

1. ARM Embedded Computers

ARM embedded computers are low-power, high-performance microcomputers based on ARM architecture, designed for IoT and edge computing scenarios. Key features include:

Low Power Consumption: Utilizes ARM processors (e.g., Cortex-A series), ideal for long-term embedded applications.

Compact Design: Small form factor, easily integrated into devices like sensor gateways or industrial controllers.

Rich Interfaces: Supports GPIO, I2C, SPI, UART, USB, Ethernet, etc., enabling seamless connectivity with sensors and peripherals.

Real-Time Capabilities: Some models support real-time operating systems (RTOS) or Linux, meeting industrial control requirements. Typical applications include smart homes, industrial automation, and energy management.

2. Prometheus

Prometheus is an open-source monitoring and alerting tool maintained by the Cloud Native Computing Foundation (CNCF). Core functionalities include:

Time-Series Database: Efficiently stores and queries metrics (e.g., CPU usage, energy consumption).

Data Collection: Uses HTTP pull mode to gather metrics from targets (e.g., ARM devices).

PromQL Query Language: Enables flexible data analysis and aggregation.

Visualization & Alerting: Integrates with Grafana for dashboards and Alertmanager for anomaly notifications. Prometheus excels in distributed systems and IoT real-time monitoring.

Application Cases: ARM Embedded Computers + Prometheus in Lighting System Energy Monitoring

System Architecture

Hardware Layer

ARM embedded computers (e.g., Raspberry Pi, NVIDIA Jetson Nano, Rockchip boards) act as edge nodes, connected to light sensors, current/voltage sensors, and smart meters.

Collects real-time data (power, current, on/off status) from lighting devices (e.g., LED lights, smart switches) via Modbus, MQTT, or LoRa protocols.

Data Collection Layer

Deploy Prometheus Exporters (e.g., Node Exporter, custom exporters) on ARM devices to convert sensor data into Prometheus-compatible metrics (e.g., light_power_consumption{watt="50", location="room1"}).

Transmits data to a Prometheus server (deployed locally or in the cloud) via Wi-Fi/Ethernet.

Monitoring & Analytics Layer

Prometheus periodically pulls metrics from ARM devices and stores them in its time-series database.

Grafana dashboards visualize real-time energy usage, historical trends, and device status.

Typical Use Cases

Case 1: Commercial Building Energy Optimization

Requirement: Reduce lighting energy consumption in an office building while ensuring comfortable illumination.

Solution:

Deploy ARM devices on each floor to collect light intensity and power data.

Use Prometheus to monitor real-time power usage and automatically adjust LED brightness based on ambient light.

Trigger alerts via Alertmanager for high-energy zones (e.g., lights left on in empty meeting rooms).

Outcome: 30% reduction in energy consumption; remote lighting strategy management.

Case 2: Industrial Lighting Health Monitoring

Requirement: Prevent production line downtime caused by lighting failures in a factory.

Solution:

ARM devices monitor current fluctuations to detect anomalies (e.g., voltage drops).

Prometheus stores historical data; machine learning models (e.g., TensorFlow Lite) predict lamp lifespan.

Dashboards display device health scores for proactive maintenance.

Outcome: 50% fewer failures; 20% lower maintenance costs.

Case 3: Smart City Streetlight Management

Requirement: Enable remote control and time-based dimming for municipal streetlights.

Solution:

ARM devices with LoRa modules act as streetlight controllers.

Prometheus collects status and energy data, adjusts brightness based on time (e.g., dimming at night).

GPS-integrated maps pinpoint faulty streetlights.

Outcome: 40% lower energy usage; 60% reduction in public complaints.

Key Advantages

Real-Time Insights: ARM edge computing + Prometheus enables sub-second data collection for rapid responses.

Cost Efficiency: Low-cost ARM hardware + free/open-source Prometheus suits large-scale deployments.

Scalability: Easily expandable—add sensors or zones without system overhauls.

Data-Driven Decisions: Historical analysis supports energy-saving initiatives (e.g., replacing inefficient fixtures).

Future Prospects

Integrating AI algorithms (e.g., time-series prediction) could further optimize lighting strategies, 

The BL370 series, with its high-performance hardware, industrial protocol stack, and edge AI capabilities, combined with Prometheus’ real-time monitoring, flexible querying, and visualization, delivers the following core benefits for lighting energy management:

Precision Control: End-to-end low latency from data acquisition to action.

Reliable Operations: Resilient in harsh environments with remote diagnostics and long-term stability.

Intelligent Decision-Making: AI-driven energy optimization and predictive maintenance.

Rapid Deployment: Out-of-the-box hardware/software with strong protocol compatibility, shortening project timelines.

Future Expansion: Leverage BL370’s NPU and Prometheus’ time-series database to develop predictive models (e.g., lighting demand forecasts based on historical data), enabling "zero-touch" energy management.

[draegerit]

ESP32-S3-Matrix von Waveshare: Kompaktes Board mit 8x8 RGB-LED-Matrix im Test

Das kleine ESP32-S3-Matrix Board von Waveshare kombiniert moderne Mikrocontroller-Technik mit einer integrierten 8x8 RGB-LED-Matrix – ideal für kreative LED-Projekte, coole Animationen oder einfache Pixelspiele. In diesem Beitrag zeige ich dir, was mit diesem kompakten Board alles möglich ist. https://youtu.be/RxWwx_eNJn8 Du erfährst, wie du das Board schnell in Betrieb nimmst und programmierst – wahlweise über die Arduino IDE oder mit Visual Studio Code. Danach wird’s praktisch: Wir erstellen gemeinsam verschiedene Lichteffekte und Animationen auf der integrierten LED-Matrix. So bekommst du nicht nur einen Eindruck von der Vielseitigkeit des Boards, sondern auch direkt Inspiration für eigene Projekte.

Technische Daten des ESP32-S3-Matrix von Waveshare

Hier zunächst die technischen Daten des Boards: EigenschaftDetailsMikrocontrollerESP32-S3 mit Xtensa® 32-bit LX7 Dual-Core ProzessorTaktfrequenzBis zu 240 MHzArbeitsspeicher (RAM)512 KB SRAMROM384 KBRTC-SRAM16 KBFlash-Speicher4 MBFunkverbindungen2.4 GHz WiFi, Bluetooth Low Energy (BLE)AnschlussUSB Type-CGPIO-Pins20 digitale Ein-/Ausgänge (über Pinheader)Anzeigeeinheit8x8 RGB-LED-Matrix (64 LEDs insgesamt)BesonderheitenNiedriger Energieverbrauch, integrierte Antenne, hohe RF-LeistungHinweis zur LED-MatrixHelligkeit nicht zu hoch einstellen – Hitzeentwicklung kann das Board schädigen

ESP32-S3 Chip auf dem ESP32-S3-Matrix Board von Waveshare

Bezug des Mikrocontrollers

Du bekommst diesen Mikrocontroller auf eBay.de bereits ab ca. 8 € zzgl. Versandkosten*. Wenn du etwas sparen möchtest und etwas Geduld mitbringst, lohnt sich ein Blick auf AliExpress.com – dort ist das Board bereits ab rund 6 € zzgl. Versand erhältlich. Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Lieferumfang Der Mikrocontroller wird in einer kleinen antistatischen Tüte geliefert ohne Pinleisten. Du musst dir somit noch zusätzlich eine 2,54mm Stiftleisten* besorgen. Diese Stiftleisten gibt es ebenso recht günstig auf Aliexpress oder ebay.de.

Pinout & Aufbau des Mikrocontrollers

Nachfolgend siehst du das Pinout des Mikrocontrollers. Besonders positiv fällt auf, dass es einen deutlich gekennzeichneten 5V-Pin gibt – das ist bei Mikrocontrollern der ESP32-Familie eher selten.

Pinout - ESP32-S3 Matrix Abgesehen davon sind nahezu alle GPIOs vielseitig nutzbar: Sie unterstützen UART, PWM, I2S, ADC, I2C und SPI-Kommunikation. Zusätzlich ermöglichen die beiden Pins unten rechts, TX und RX, die serielle Kommunikation mit anderen Geräten – etwa für Debugging-Zwecke oder die Anbindung externer Module. Aufbau der RGB LED Matrix Die RGB-LED-Matrix auf dem ESP32-S3-Matrix Board ist fest verlötet und folgt einem 8x8-Raster, also 64 einzeln adressierbaren LEDs. Standardmäßig ist die Matrix intern mit GPIO 14 des Mikrocontrollers verbunden – diesen Pin müssen wir auch in unserem Sketch angeben, um die LEDs korrekt anzusteuern. Die erste LED (Index 0) befindet sich dabei oben links, direkt neben dem USB-Anschluss, in der ersten Zeile. Von dort aus verläuft die Adressierung zeilenweise nach rechts, also in sogenannter „serienmäßiger Reihenfolge“ (row-major order). Das ist wichtig zu wissen, wenn man später eigene Muster oder Animationen umsetzen möchte.

Programmierung des Boards ESP32-S3-Matrix

In der offiziellen englischen Dokumentation zum Board von Waveshare wird dir erläutert wie du dieses Board in der Arduino IDE, Visual Studio Code, Espressif IDF sowie MicroPython programmierst. Ich möchte dir nachfolgend meinen Weg aufzeigen wie ich diesen in der Arduino IDE zum laufen gebracht und programmiert habe. Achtung: Helligkeit nicht zu hoch einstellen Ein wichtiger, aber leicht zu übersehender Hinweis findet sich in einem der Beispielsketches von Waveshare: Die Helligkeit der RGB-LED-Matrix sollte nicht zu hoch eingestellt werden, da sich das Board sonst stark erwärmen kann. Durch die kompakte Bauweise und die hohe Leistungsaufnahme der LEDs besteht die Gefahr, dass sich die Temperatur schnell erhöht – was auf Dauer zu einer Beschädigung der Platine führen kann. Programmieren in der Arduino IDE Die Entwicklungsumgebung Arduino IDE ist für die Mikrocontroller der Arduino-Familie (wie der Name es erahnen lässt) ausgelegt. Damit wir den Mikrocontroller mit dem ESP32-S3 Chip programmieren können, müssen wir zunächst den Boardtreiber installieren. Installieren des Boardtreibers für Espressif Chips Im ersten Schritt öffnen wir die Einstellungen – entweder über das Hauptmenü Datei > Einstellungen oder mit der Tastenkombination Strg + , (Komma).

In den Einstellungen klicken wir auf die in der zweiten Grafik markierte Schaltfläche (2), um den Dialog „Zusätzliche Boardverwalter-URLs“ zu öffnen. Dort fügen wir die folgende URL ein und bestätigen mit OK: https://espressif.github.io/arduino-esp32/package_esp32_index.json Sobald dieser Schritt abgeschlossen ist, kannst du den Boardverwalter über das linke Menü (6) öffnen und dort nach „esp32“ suchen (7). In der Ergebnisliste sollte der Eintrag „esp32 von Espressif Systems“ erscheinen. Wähle dort die Schaltfläche „INSTALLIEREN“ (8), um die Boarddefinitionen zu installieren.

Die Installation kann etwas Zeit in Anspruch nehmen, da es zahlreiche Varianten des ESP32 gibt und alle benötigten Treiber von einem eher langsamen Server heruntergeladen werden. Bei mir hat der Vorgang rund 5 Minuten gedauert. Den Fortschritt der Installation kannst du im Fenster „Ausgabe“ mitverfolgen. Damit sind die benötigten Boardtreiber installiert. Du findest nun unter Werkzeuge > Board > esp32 eine große Auswahl an ESP32-Boards. Für das hier verwendete Board wählen wir den Eintrag „ESP32-S3 Dev Module“ aus.

Programmieren der 8x8 RGB Matrix mit der Adafruit NeoPixel Bibliothek Wie man eine RGB-LED vom Typ WS2812B am Mikrocontroller ansteuert, habe ich bereits in mehreren Beiträgen gezeigt. Besonders einfach gelingt das mit der Adafruit NeoPixel Bibliothek, die ich auch in diesem Beispiel wiederverwende. - RGB Beleuchtung einfach steuern: NeoPixel Ring mit Arduino - Arduino Lektion 31: 12bit RGB NeoPixel Ring - LED-Würfel: Zufallszahlen auf der Pixelmatrix darstellen Du kannst die Bibliothek ganz bequem über den Bibliotheksverwalter der Arduino IDE installieren – inklusive aller nötigen Abhängigkeiten (engl. dependencies). Suche dazu einfach nach „Adafruit NeoPixel“ und klicke auf Installieren. Hilfsfunktion zum ansteuern einer LED via X & Y Koordinate Um eine einzelne LED auf der Pixelmatrix anzusteuern, benötigen wir ihren Index im Array. Dieser beginnt oben links bei 0 und endet unten rechts bei 63. Das direkte Arbeiten mit diesen eindimensionalen Indizes kann beim Zeichnen von Figuren jedoch schnell unübersichtlich und fehleranfällig werden. Deshalb habe ich mir eine kleine Hilfsfunktion erstellt, mit der man stattdessen über X- und Y-Koordinaten arbeiten kann. Dabei steht X für die Spalte und Y für die Zeile, was dem gewohnten Koordinatensystem entspricht. So lässt sich die Positionierung einzelner Pixel deutlich klarer und intuitiver gestalten, besonders beim Aufbau grafischer Muster in einem zweidimensionalen Array. // Gerade Verdrahtung: Zeile für Zeile von links nach rechts uint16_t xy(uint8_t x, uint8_t y) { // Die LED-Matrix ist 8 Spalten (x) breit und 8 Zeilen (y) hoch. // Die LEDs sind zeilenweise verdrahtet – also: // erste Zeile von links nach rechts (x = 0 bis 7), // dann zweite Zeile direkt danach, usw. // Um die Position (x, y) auf den eindimensionalen LED-Array-Index (0–63) zu berechnen, // multiplizieren wir die Zeilennummer mit 8 (Anzahl Spalten), um den Zeilen-Offset zu bekommen: // y * 8 = Startposition dieser Zeile im Array // Dann addieren wir die Spaltennummer x hinzu: // So ergibt sich die konkrete LED-Nummer in der 1D-LED-Liste return y * 8 + x; // Beispiel: // x = 3, y = 2 → 2. Zeile = Offset 16 → Index = 16 + 3 = 19 // Das bedeutet: Pixel an Spalte 3, Zeile 2 → LED Nr. Read the full article

[jayakody2000lk]

RDA5807M FM stereo receiver module

This project focuses on a simple yet powerful FM stereo tuner module. The core component of the module is RDA5807M, a single-chip broadcast FM stereo tuner that has gained popularity among designers in recent years due to its high level of integration. This integration significantly reduces the need for external components, simplifying circuit design. The RDA5807M supports a wide FM band, covering frequencies from 50MHz to 115MHz, making it adaptable to global FM standards.

Additionally, its use of a low-IF digital architecture streamlines the design process by requiring fewer external parts. The inclusion of an AGC (automatic gain control) feature ensures consistent signal reception, even in environments with fluctuating signal strengths.

The chip's digital stereo decoding capabilities deliver high-quality audio output, providing a rich stereo sound experience. Moreover, the energy efficiency of the RDA5807M makes it suitable for portable, battery-powered devices. The I2C control interface allows for easy integration with microcontrollers, enabling straightforward digital control.

This module is designed as a ready-to-use FM receiver solution, emphasizing compactness and ease of integration. It incorporates the RDA5807M IC and the STM8S003F3P MCU, along with the necessary supporting passive components, standard headers for connections, and flexible antenna connectivity options. The module is engineered to connect with commonly available 0.56-inch, 4-digit common cathode LED seven-segment display modules without any soldering.

The compact footprint of the module makes it ideal for projects where space is at a premium. Importantly, its open-source design allows for complete customization and modification.

It provides standard stereo audio output with separate left and right channels. The antenna input options allow for various antenna types, ensuring optimal signal reception. During testing, we utilized a 30cm long wire as the antenna and successfully received all FM stations clearly.

The tuner module features push switches to perform automatic station scans in both directions. The firmware limits the tuning range of the module to between 87MHz and 108MHz. Additionally, it includes digital volume control with 15 levels and a memory manager for storing up to 10 FM radio stations. The current tuner frequency is displayed on the segment display module, and there are two LEDs to indicate stereo reception and memory manager status.

The output level of this receiver module is not sufficient to drive speakers directly. Therefore, to achieve audio output through speakers, this module needs to be paired with a stereo audio amplifier. During testing, we successfully used the commonly available PAM8403 3W class-D audio amplifier with this module.

Power is supplied via a screw terminal, typically requiring a DC power source between 5V and 9V. The dimensions of the module are 72.85mm × 32.0mm.

This project is available on GitHub, providing schematics, PCB files, firmware source code, and comprehensive documentation. The hardware design of this project is licensed under CERN-OHL-W, while the firmware is licensed under the terms and conditions of the MIT license. All other resources, including documentation, are released under the Creative Commons Attribution 4.0 International license.

[adafruit]

Trying to design a great WLED board 🌈🦄🦃

While waiting for the turkey to finish brining, we're designing a board for using WLED - and we want to make like the bestest board in the whole world.

Our resident mermaid, firepixie

, makes a lot of projects with WLED, and she loves it! So, how can we make something that will be powerful but not too bulky? Here are some things we're thinking about as the design starts to congeal like cranberry sauce:

Power via USB Type C PD with a slide switch that selects between 5, 12, and 20V (24V pixels can usually run fine at 20V) OR via a 2.1mm DC jack. With ideal diodes, it's good for up to 5A from either.

ESP32-Mini module with built-in or optional wFL antenna port. The classic '32 has broad support, even if we'd prefer the 'S2 or 'S3.

There are three output signal terminal block sets, with power and ground for each. They'll be level-shifted to 5V.

Built in I2S microphone (we're still pondering this one).

Stemma QT I2C port to connect external sensors/OLEDs/etc.; separate analog/digital input JST port.

1.3"x1.75" / 33mm x 45mm size with mounting holes.

Anything we're missing, anything that's extraneous?

[mastersofthearts]

Chatgpt computer communication design

Designing a computer circuit where two computers communicate with each other and "teach themselves" using an Arduino board involves a combination of hardware setup and software programming. Here’s a general guide to get you started:

1. Basic Concept

Two Computers (PCs or Microcontrollers): These are the two devices that will communicate and learn from each other. Each will run a program for self-learning.

Arduino Board: The Arduino will facilitate the communication between the two computers and control the process. It could also be part of the system performing calculations or simulations.

Communication Protocol: The two computers will need to communicate with each other. For simplicity, we can use serial communication (UART) or I2C with the Arduino acting as the intermediary.

2. Hardware Components

Arduino Board (e.g., Arduino Uno, Nano, or Mega)

Two Computers (PCs or other microcontrollers, like Raspberry Pi or other Arduino boards)

Communication Module: If you are using something like a Raspberry Pi or another microcontroller, you might need USB-to-Serial adapters or Bluetooth/Wi-Fi modules (e.g., ESP8266/ESP32, HC-05).

Power Supply: Proper power sources for the Arduino and computers.

Cables: USB, serial cables, or jumper wires for communication.

3. Circuit Design

Here is a high-level overview of the connections between the Arduino and the two computers.

Arduino and PC1 (Computer 1):

Connect the Arduino to PC1 via USB or UART communication pins (TX/RX pins if using serial).

Arduino and PC2 (Computer 2):

If you are using a second microcontroller (like another Arduino or a Raspberry Pi), connect them to the Arduino board using a communication protocol (e.g., I2C or UART).

The two computers could either communicate directly over a network (like Ethernet or Wi-Fi) or through serial communication.

For this example, let’s assume you are using UART for communication between the Arduino and both computers. You can use the TX/RX pins on the Arduino and connect them to the USB-to-Serial adapters connected to each computer.

4. Software Design

The software should allow the computers to "teach themselves," which likely means implementing some form of machine learning or pattern recognition. For simplicity, let’s outline how you could set up communication, with the learning part handled on the computers.

Arduino Code: The Arduino will act as the middleman for the communication. It will receive data from one computer, send it to the other, and also handle basic processing or simulation. It can be programmed to send responses or instructions back to the computers.

// Simple Arduino code for UART communication void setup() { Serial.begin(9600); // Start the serial communication at 9600 baud } void loop() { if (Serial.available()) { char incomingByte = Serial.read(); // Read incoming byte Serial.print("Received: "); Serial.println(incomingByte); // Send back the received byte } }

Computer 1 and Computer 2 Code: Each computer should run a program that will send data to the Arduino and receive responses. This could be a simple Python script or C++ program for serial communication.

Example Python Script: Here’s a basic Python script that can run on each computer. This script will send data to the Arduino and read the response back.import serial import time # Open serial port (make sure to change COM port for your system) ser = serial.Serial('COM3', 9600) # Change COM port as needed time.sleep(2) # Wait for the serial connection to initialize # Send data to Arduino ser.write(b'Hello Arduino!\n') # Read response while True: if ser.in_waiting > 0: response = ser.readline().decode('utf-8').strip() print(f"Arduino says: {response}") break ser.close()

This Python script could run on Computer 1, while a similar script runs on Computer 2. Both will send messages to the Arduino and receive feedback.

5. Self-Learning Simulation

To simulate the "self-teaching" aspect, each computer can use machine learning algorithms. You could start with something simple like linear regression or a decision tree. The computers could send random data points to each other and exchange feedback on whether the predictions made by each other are correct.

Computer 1 could generate a random dataset and send it to Computer 2.

Computer 2 processes the data, makes predictions, and sends the feedback back.

Computer 1 uses this feedback to adjust its learning algorithm (e.g., adjust weights in a simple linear regression model).

Example of a Simple Learning Process: Each computer could adjust its internal model based on the received feedback, similar to how a neural network or other machine learning models learn. The Arduino could be involved in simple processing tasks or sending acknowledgment signals when certain thresholds are reached (e.g., "success" or "failure").

6. Scaling Up

If you want to scale up the project to involve more complex learning or higher levels of interaction, you could use a more advanced platform such as a Raspberry Pi or ESP32/ESP8266 for networking and faster processing, where each computer uses a machine learning library (like TensorFlow Lite or scikit-learn).

7. Final Setup

Computer 1 and Computer 2 run machine learning algorithms that adjust based on feedback.

Arduino manages data flow between the computers and possibly performs basic learning tasks like adjusting variables or sending commands.

The entire system simulates a network where two computers are learning from each other.

This is a high-level overview, and there are many ways to implement it depending on the complexity of the communication and learning algorithm you want to achieve. Would you like to dive deeper into any specific area or need more detailed code for the project?

Creating two PCs from scratch using Arduino boards is an interesting challenge, but it's important to note that a full-fledged personal computer involves much more complexity than an Arduino is capable of. However, you can certainly simulate basic "PC-like" behavior using Arduino boards, where each "PC" would be a microcontroller (Arduino) with some level of functionality, communication, and processing.

High-Level Concept

Each Arduino board would act as a basic computing unit (like a simplified "PC"), running simple programs, processing input, and communicating with each other. While these "PCs" won't have the advanced features of a real computer (like an OS, GUI, or complex processing power), they can serve as learning devices or communication nodes in a network.

To make two PCs communicate with each other using an Arduino board, the Arduino acts as an intermediary. The Arduino will handle the communication between the two PCs, either via a serial connection (UART), I2C, or wireless communication (e.g., Bluetooth/Wi-Fi). Below is a guide on how to set up such a system:

1. Hardware Setup

Here, I'll describe a setup where two PCs communicate via an Arduino board using serial communication (UART). The Arduino will act as a mediator, forwarding messages between the two computers.

Components Needed:

Arduino board (e.g., Arduino Uno, Nano, Mega)

2 PCs (PC1 and PC2)

USB-to-Serial adapters (if using UART)

Jumper wires (if using direct communication between Arduino and PC)

Connections:

PC1 <-> Arduino: The first PC will communicate with the Arduino using its USB port (acting as a serial port).

PC2 <-> Arduino: The second PC will communicate via another USB-to-Serial adapter or possibly the second USB port of the Arduino (if the Arduino model supports multiple serial connections, e.g., Mega).

In simpler terms:

Arduino will be connected via USB to PC1.

PC2 will be connected to Arduino's serial pins (TX/RX) or using a USB-to-Serial adapter.

2. Arduino Code

The Arduino will need to read from one serial port (PC1) and forward the data to another serial port (PC2) and vice versa. The following is a simple Arduino sketch for this task.// Arduino code for mediating between two PCs void setup() { // Start serial communication with both computers Serial.begin(9600); // For communication with PC1 Serial1.begin(9600); // For communication with PC2 (if using Arduino Mega or another board with multiple serial ports) } void loop() { // Check if data is available from PC1 (connected to Serial) if (Serial.available() > 0) { char dataFromPC1 = Serial.read(); // Read data from PC1 Serial1.write(dataFromPC1); // Send data to PC2 (connected to Serial1) } // Check if data is available from PC2 (connected to Serial1) if (Serial1.available() > 0) { char dataFromPC2 = Serial1.read(); // Read data from PC2 Serial.write(dataFromPC2); // Send data to PC1 (connected to Serial) } }

Explanation of the Code:

Serial.begin(9600): Initializes communication with PC1.

Serial1.begin(9600): Initializes communication with PC2. (Note: Only available on boards with multiple UARTs like Arduino Mega, if using an Arduino Uno, you’ll need a USB-to-Serial adapter for PC2).

Serial.read(): Reads data from one serial port.

Serial.write(): Sends data to the other serial port.

3. Software on the PCs

On each of the two PCs, you will run a program that communicates with the Arduino via a serial connection. You can use Python to interface with the Arduino. Here’s a simple Python example that reads data from the Arduino and sends data back.

Python Code for PC1:

import serial import time # Connect to Arduino via serial port (Adjust the port name as needed) ser = serial.Serial('COM3', 9600) # Replace 'COM3' with your Arduino's port time.sleep(2) # Wait for the serial connection to establish # Send data to Arduino (which will forward to PC2) ser.write(b'Hello from PC1!\n') # Read data from Arduino (which is coming from PC2) while True: if ser.in_waiting > 0: response = ser.readline().decode('utf-8').strip() print(f"Received from PC2: {response}") break ser.close()

Python Code for PC2:

import serial import time # Connect to Arduino via serial port (Adjust the port name as needed) ser = serial.Serial('COM4', 9600) # Replace 'COM4' with your Arduino's port time.sleep(2) # Wait for the serial connection to establish # Read data from Arduino (which is coming from PC1) while True: if ser.in_waiting > 0: message = ser.readline().decode('utf-8').strip() print(f"Received from PC1: {message}") # Send data back to Arduino (which will forward to PC1) ser.write(b'Hello from PC2!\n') break ser.close()

4. Explanation of the PC Software:

Python serial library: Used to open a serial connection to the Arduino.

ser.write(): Sends data from PC1 or PC2 to the Arduino.

ser.readline(): Reads incoming data from the Arduino, which is forwarded from the other PC.

Time Delays: time.sleep(2) ensures that the serial connection is established before communication begins.

5. Communication Flow

PC1 sends a message (e.g., "Hello from PC1") to the Arduino.

The Arduino forwards the message to PC2.

PC2 receives the message, processes it, and sends a response back to the Arduino (e.g., "Hello from PC2").

The Arduino forwards the message back to PC1.

6. Adjusting for More Complex Setups

If you are using an Arduino Uno (which has only one serial port), you’ll need an additional USB-to-Serial adapter to handle communication with both PCs. Alternatively, you can use an Arduino Mega, which has multiple serial ports (like Serial, Serial1, Serial2, etc.).

For the Arduino Mega, you can use Serial for PC1 and Serial1 for PC2, as shown in the code above.

For PC2, you might need a USB-to-Serial adapter if you're not using an Arduino Mega.

7. Next Steps

To make the setup more advanced, you can:

Add error handling and retry mechanisms for more robust communication.

Implement data processing algorithms to simulate machine learning (e.g., a simple model for each PC that "learns" from the data it receives).

Use wireless communication like Bluetooth or Wi-Fi if you don't want to rely on USB connections.

Would you like to explore how to expand this further or add more complexity to the system? Let me know!

Here’s how you might approach creating two Arduino-based "PCs" from scratch:

1. Basic Requirements and Constraints

You’re working with Arduino boards, which are microcontrollers with limited processing power, memory, and storage compared to a real PC. The Arduino can run basic programs, perform calculations, and communicate with other devices, but it cannot run complex software like a PC.

To simulate PCs, you'll need:

Arduino microcontroller boards (e.g., Arduino Uno, Nano, Mega, etc.)

Inputs/outputs (e.g., buttons, LEDs, displays)

Communication method between the two Arduinos (e.g., UART serial, I2C, or even wireless)

Storage (limited, but can use EEPROM or SD card modules)

Basic display (e.g., an LCD or LED screen for output)

2. Building the Two "PCs" with Arduino

Each Arduino board will act as one "PC." Here’s how you can conceptualize the setup:

Arduino 1 (PC1): Will handle user input and perform computations.

Arduino 2 (PC2): Will also handle user input and perform computations. It will communicate with PC1 to share or exchange data.

The communication between the two PCs can be done using serial communication (UART) or I2C.

3. Basic Hardware Setup for Each PC

Each "PC" could have:

Buttons or switches to simulate input (e.g., user input or commands).

LCD or 7-segment display for output (or use an LED to indicate activity).

Communication interface to talk to the other PC (e.g., UART or I2C).

SD card or EEPROM to simulate storage.

Components Needed:

2 Arduino boards (e.g., Arduino Uno or Nano)

1 LCD display (16x2 or 20x4 for basic text output)

2 push buttons (to simulate input)

2 LEDs (to indicate some activity or status)

2 USB-to-Serial adapters (if using UART communication between PCs)

1 I2C or UART communication method

1 SD card module (optional for storage simulation)

4. Software Design for the "PCs"

Each Arduino PC will need a program to read inputs, perform some basic computation, and send/receive data to/from the other PC. Here’s a simple breakdown of the software for each Arduino:

Arduino PC1 (PC1 Sketch)

This sketch allows PC1 to process input (button presses), perform simple calculations, and send/receive data from PC2.#include <Wire.h> // For I2C communication (if using I2C) #include <LiquidCrystal_I2C.h> // For LCD display // Initialize the LCD (change pin numbers according to your setup) LiquidCrystal_I2C lcd(0x27, 16, 2); // Input and output pins int buttonPin = 7; // Pin for button input int ledPin = 13; // Pin for LED output void setup() { // Start communication Wire.begin(); // Start I2C communication if using I2C lcd.begin(16, 2); pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); lcd.print("PC1: Ready"); delay(2000); // Wait for 2 seconds } void loop() { int buttonState = digitalRead(buttonPin); // Read button state if (buttonState == HIGH) { // If button is pressed digitalWrite(ledPin, HIGH); // Turn on LED lcd.clear(); lcd.print("Button Pressed"); // Send data to PC2 (via I2C or serial) Wire.beginTransmission(8); // 8 is the I2C address of PC2 Wire.write("PC1: Button Pressed"); Wire.endTransmission(); } else { digitalWrite(ledPin, LOW); // Turn off LED } delay(100); // Small delay to avoid bouncing }

Arduino PC2 (PC2 Sketch)

This sketch for PC2 will receive data from PC1 and display it on the LCD, simulating output.#include <Wire.h> // For I2C communication (if using I2C) #include <LiquidCrystal_I2C.h> // For LCD display LiquidCrystal_I2C lcd(0x27, 16, 2); // LCD setup void setup() { Wire.begin(8); // Set PC2's I2C address to 8 Wire.onReceive(receiveEvent); // Define the event handler for receiving data lcd.begin(16, 2); // Start the LCD display lcd.print("PC2: Ready"); } void loop() { // Main loop does nothing, waiting for incoming data } void receiveEvent(int bytes) { String message = ""; // Initialize an empty string for the message while (Wire.available()) { message += (char)Wire.read(); // Read each byte and convert to character } // Display the received message on LCD lcd.clear(); lcd.print("PC2: "); lcd.print(message); // Print received message on LCD }

5. How They Communicate:

I2C Communication: In this setup, PC1 sends a message to PC2 using I2C. This allows you to connect the two Arduinos with just two wires (SDA, SCL) and share data.

Serial Communication (UART): Alternatively, if you're using UART (Serial) communication, PC1 sends data to PC2 via the Arduino’s TX/RX pins and vice versa.

6. Adding Storage (Optional)

To simulate storage, you can attach an SD card module to the Arduino. The Arduino can read/write simple text files or store computational results on the SD card.

Example of using an SD card module on PC1:#include <SPI.h> #include <SD.h> File myFile; void setup() { Serial.begin(9600); if (!SD.begin(4)) { Serial.println("SD card initialization failed!"); return; } myFile = SD.open("log.txt", FILE_WRITE); if (myFile) { myFile.println("PC1: Data Log"); myFile.close(); } else { Serial.println("Error opening log.txt"); } } void loop() { // Example of logging data continuously myFile = SD.open("log.txt", FILE_WRITE); if (myFile) { myFile.println("New Data Recorded"); myFile.close(); } delay(1000); // Wait for 1 second }

7. Expanding the "PCs"

You can add more features to each Arduino "PC," such as:

User input: Keyboard or mouse emulation.

Network Communication: Use Wi-Fi or Ethernet modules (like ESP8266 or Ethernet shield) to allow the two PCs to communicate over a network.

Processing: Implement simple algorithms or calculations on each Arduino to make them more like basic computers.

8. Limitations

Remember that an Arduino board is not a real PC, and it has significant limitations:

Limited processing power and memory.

No operating system or advanced software.

Minimal input/output capabilities.

But it is still a great way to learn about the basics of computer-like behavior, communication, and microcontroller programming.

Conclusion

While building a full-fledged PC using Arduino isn’t feasible, you can create two basic "PC-like" systems by using Arduino boards to simulate basic functionality such as processing, input/output, communication, and storage. This setup is a great way to learn about how computers work at a fundamental level, as well as how data is shared and processed between multiple devices.

Would you like to explore any specific part of the project further or need help with something else?

[unikeyic]

Arduino Hands-on — 0.96-inch OLED Display

Experiment: 0.96 inch I2C IIC Communication 128*64 Display OLED LCD Screen Module

OLED, short for Organic Light-Emitting Diode, is also known as Organic Electroluminescence Display. It belongs to a kind of current-driven organic light-emitting device, in which light emission is achieved through the injection and recombination of charge carriers, with the intensity of light emission directly proportional to the injected current. Under the influence of an electric field, holes generated at the anode and electrons produced at the cathode move towards the hole transport layer and electron transport layer respectively, to finally reach the light-emitting layer. Upon meeting in the light-emitting layer, they form excitons that excite light-emitting molecules to emit visible light. Generally speaking, OLED can be divided into two categories based on the emissive materials: small molecule OLED and polymer OLED (also known as PLED). OLED is a device that utilizes multi-layer organic thin films to achieve electroluminescence, making it easy to fabricate with low driving voltages. These characteristics make OLED particularly outstanding for flat panel display applications. OLED displays are thinner and lighter compared to LCDs, with higher brightness, lower power consumption, faster response time, superior clarity, good flexibility, high luminous efficiency, meeting consumers' new demands for display technology. With more and more display manufacturers worldwide investing in research and development, the industrialization process of OLED has been significantly accelerated.

Characteristics of OLED

(1) Low power consumption - Compared to LCDs, OLEDs do not require a backlight source, which is a relatively energy-consuming part in LCDs, making OLEDs more energy-efficient. For example, a 24-inch AMOLED module consumes only 440mW, while a 24-inch polysilicon LCD module reaches 605mW.

(2) Fast response time - OLED technology has a fast response time compared to other technologies, with response times reaching the microsecond level. The higher response speed better achieves motion images. According to relevant data analysis, its response speed is approximately 1000 times faster than that of liquid crystal displays.

(3) Wide viewing angles - Compared to other displays, OLED screens do not exhibit distortion over a large viewing angle range due to their active light emission. The vertical and horizontal viewing angles exceed 170 degrees.

(4) High-resolution display capability - Most high-resolution OLED displays use active matrix organic light-emitting diode (AMOLED) technology, which can absorb up to 260,000 true colors of high resolution. With the advancement of science and technology, OLED resolutions are expected to increase further in the future.

(5) Wide temperature characteristics - Unlike LCDs, OLEDs can operate over a wide temperature range. According to technical analysis, OLEDs can function normally within a temperature range of -40 degrees Celsius to 80 degrees Celsius. This reduces geographical limitations, allowing for normal use even in extremely cold regions.

(6) OLED enables flexible screens - OLED technology can be produced on various flexible substrate materials such as plastic and resin. By depositing or coating organic layers on flexible substrates, OLEDs can achieve flexible screens.

(7) Lighter weight of OLED finished products - Compared to other products, OLEDs have a smaller footprint and thickness than LCDs. They have a higher resistance coefficient, able to withstand greater accelerations, vibrations, and harsh environments.

OLED Structure

The structure of an OLED consists of various components including the substrate, cathode, anode, hole injection layer (HIL), electron injection layer (EIL), hole transport layer (HTL), electron transport layer (ETL), electron blocking layer (EBL), hole blocking layer (HBL), and emissive layer (EML). The substrate serves as the foundation of the entire device, with all functional layers needing to be deposited onto it; typically, glass is used as the substrate material for the device, but if flexible OLED devices are required, other materials such as plastic may be used. The anode is connected to the positive terminal of the external driving voltage applied to the device, where the holes within the anode move towards the emissive layer within the device under the influence of the driving voltage. The anode needs to have a certain degree of transparency when the device is in operation, allowing light emitted from within the device to be observed externally; the most commonly used material for the anode is ITO. The hole injection layer modifies the anode of the device and facilitates the smooth injection of holes from the anode into the hole transport layer; the hole transport layer is responsible for transporting holes to the emissive layer. The electron blocking layer prevents electrons from the cathode from entering the emissive layer interface of the device, increasing the concentration of electrons at the emissive layer interface. The emissive layer is where the recombination of electrons and holes occurs to form excitons which then emit light. The hole blocking layer blocks the holes from the anode at the interface of the emissive layer in order to enhance the probability of electron-hole recombination at the emissive layer interface, thereby increasing the device's luminous efficiency. The electron transport layer is responsible for transporting electrons from the cathode to the emissive layer of the device; the electron injection layer functions to modify the cathode and transfer electrons to the electron transport layer. Electrons within the cathode move towards the device's emissive layer under the driving force of the external driving voltage, where they recombine with holes from the anode at the emissive layer.

Principle of Luminescence

The luminescent process of OLED devices can be divided into: injection of electrons and holes, transmission of electrons and holes, recombination of electrons and holes, and exciton excitation light emission. Specifically:

(1) Injection of electrons and holes. Electrons in the cathode and holes in the anode will move towards the light-emitting layer of the device under the driving voltage. In the process of moving towards the light-emitting layer, if the device contains an electron injection layer and a hole injection layer, electrons and holes first need to overcome the energy barrier between the cathode and the electron injection layer, as well as between the anode and the hole injection layer, and then move through the electron injection layer and hole injection layer to the electron transport layer and hole transport layer of the device; the electron injection layer and hole injection layer can increase the efficiency and lifespan of the device. The mechanism of electron injection in OLED devices is still under continuous research, and currently, the most commonly used mechanisms are tunneling effect and interface dipole mechanism.

(2) Transmission of electrons and holes. Under the driving voltage, electrons from the cathode and holes from the anode will respectively move to the electron transport layer and hole transport layer of the device. The electron transport layer and hole transport layer will then move electrons and holes to the interface of the light-emitting layer of the device; at the same time, the electron transport layer and hole transport layer will block the holes from the anode and electrons from the cathode at the interface of the light-emitting layer, allowing electrons and holes to accumulate at the interface of the light-emitting layer.

(3) Recombination of electrons and holes. When a certain number of electrons and holes at the interface of the light-emitting layer of the device are reached, electrons and holes will recombine to form excitons in the light-emitting layer.

(4) Light emission due to exciton de-excitation. Excitons generated in the light-emitting layer will activate the organic molecules in the light-emitting layer of the device, causing the outermost electrons of the organic molecules to transition from the ground state to the excited state. Since the electrons in the excited state are highly unstable, they will transition back to the ground state, releasing energy in the form of light during the transition, thereby achieving device illumination.

Comparison between OLED and LED/LCD

Compared to the crystal layer of LED or LCD, the organic plastic layer of OLED is thinner, lighter, and more flexible.

The light-emitting layer of OLED is relatively light, allowing for the use of flexible materials in its base layer, rather than rigid materials. While OLED's base layer is made of plastic, LED and LCD use glass substrates.

OLED is brighter than LED. The organic layer of OLED is much thinner than the corresponding inorganic crystal layer in LED, allowing OLED's conductive and emitting layers to be multi-layered. Additionally, LED and LCD require glass as support, which absorbs some light. OLED, on the other hand, does not need to use glass.

OLED does not require a backlight system like LCD. LCD selectively blocks certain backlight areas to display images, while OLED emits light by itself. Due to not needing a backlight system, OLED consumes less power compared to LCD (where most of the power consumption is for the backlight system). This is particularly important for battery-powered devices such as mobile phones.

OLED is easier to manufacture and can be made in larger sizes. Being made of plastic material, OLED can be manufactured into large thin sheets. In contrast, it would be much more challenging to use so many crystals and lay them flat.

OLED has a wide viewing angle, reaching around 170 degrees. LCD needs to block light when operating, leading to natural viewing obstacles at certain angles. As OLED emits light by itself, the viewing range is also much wider.

0.96 inch I2C IIC Communication 12864 Display OLED LCD Screen Module

Voltage: 3V~5V DC

Operating Temperature: -30℃~70℃

Duty Duty: 1/64 duty

High Resolution: 128 64

Panel Size: 26.70 19.26 1.85 mm / 1.03 0.76 0.07 inches (approx.)

Effective Area: 21.74 11.2 mm / 0.86 0.44 inches (approx.)

Driver IC: SSD1306

128 * 64 LED display module, supporting various control chips.

Fully compatible with 51 series, MSP430 series, STM32/2, CSR IC, etc.

Ultra-low power consumption: 0.08W when the full screen is lit.

Super high brightness and adjustable contrast

With embedded driver/controller

Interface Type: IIC