Pantalla OLED de 0,91 pulgadas – Introducción del producto

La pantalla OLED de 0,91 pulgadas es un módulo de visualización de bajo consumo basado en comunicación I2C con una resolución de 128x32. Admite la conexión con varias placas de desarrollo, como los controladores de la serie Jetson, Raspberry Pi y Orange Pi, y puede mostrar en tiempo real información del estado del sistema.

Características principales

• 📊 Visualización en tiempo real del uso de la CPU
• ⏰ Muestra la hora actual del sistema
• 💾 Muestra el uso de memoria y la memoria total
• 🗄️ Muestra el uso del espacio de la tarjeta TF
• 🌐 Muestra la dirección IP local del dispositivo
• 🔌 Admite conexión en caliente, estable y fiable

Conexión de hardware

Instrucciones de cableado

Mediante la interfaz de comunicación I2C, el cableado es el siguiente:

⚠️ Nota: Asegúrate de que el cableado sea correcto y evita los cortocircuitos de pines; de lo contrario, podría dañarse el hardware de la placa principal.

Guía de uso del software

Plataformas compatibles:

• ✅ Controladores de la serie Jetson
• ✅ Todos los modelos de Raspberry Pi
• ✅ Todos los modelos de Orange Pi
• ✅ Otras placas de desarrollo Linux que admiten comunicación I2C

Pasos de instalación para la serie Jetson

1. Instalar las dependencias

sudo apt install -y python3-pip
sudo pip3 install smbus
sudo pip3 install Adafruit_SSD1306

2. Detectar dispositivos I2C

# List all I2C buses
i2cdetect -l

# Detect I2C devices, OLED default address is 0x3c
i2cdetect -y -r *

3. Ejecutar el código de prueba

#!/usr/bin/env python3
# coding=utf-8
import time
import os
import sys
import Adafruit_SSD1306 as SSD
from PIL import Image, ImageDraw, ImageFont
import subprocess

class Juxi_OLED:
    def __init__(self, i2c_bus=1, debug=False):
        self.__debug = debug
        self.__i2c_bus = i2c_bus
        self.__top = -2
        self.__x = 0
        self.__total_last = 0
        self.__idle_last = 0
        self.__str_CPU = "CPU:0%"

    # Initialize OLED, return True on success, False on failure
    def begin(self):
        try:
            self.__oled = SSD.SSD1306_128_32(rst=None, i2c_bus=self.__i2c_bus, gpio=1)
            self.__oled.begin()
            self.__oled.clear()
            self.__oled.display()
            self.__width = self.__oled.width
            self.__height = self.__oled.height
            self.__image = Image.new('1', (self.__width, self.__height))
            self.__draw = ImageDraw.Draw(self.__image)
            self.__font = ImageFont.truetype("DejaVuSansMono.ttf",8)
            return True
        except:
            return False

    # Clear display, refresh=True to refresh immediately
    def clear(self, refresh=False):
        self.__draw.rectangle((0, 0, self.__width, self.__height), outline=0, fill=0)
        if refresh:
            self.refresh()

    # Add text at specified position
    def add_text(self, start_x, start_y, text, refresh=False):
        if start_x > 128 or start_x < 0 or start_y < 0 or start_y > 32:
            return
        x = int(start_x + self.__x)
        y = int(start_y + self.__top)
        self.__draw.text((x, y), str(text), font=self.__font, fill=255)
        if refresh:
            self.refresh()

    # Add text to specified line (1-4)
    def add_line(self, text, line=1, refresh=False):
        if line < 1 or line > 4:
            return
        y = int(8 * (line - 1))
        self.add_text(0, y, text, refresh)

    # Refresh OLED display
    def refresh(self):
        self.__oled.image(self.__image)
        self.__oled.display()

    # Get CPU usage
    def getCPULoadRate(self, index):
        count = 10
        if index == 0:
            f1 = os.popen("cat /proc/stat", 'r')
            stat1 = f1.readline()
            data_1 = []
            for i in range(count):
                data_1.append(int(stat1.split(' ')[i+2]))
            self.__total_last = sum(data_1)
            self.__idle_last = data_1[3]
        elif index == 4:
            f2 = os.popen("cat /proc/stat", 'r')
            stat2 = f2.readline()
            data_2 = []
            for i in range(count):
                data_2.append(int(stat2.split(' ')[i+2]))
            total_now = sum(data_2)
            idle_now = data_2[3]
            total = int(total_now - self.__total_last)
            idle = int(idle_now - self.__idle_last)
            usage = int(total - idle)
            usageRate = int(float(usage / total) * 100)
            self.__str_CPU = "CPU:" + str(usageRate) + "%"
            self.__total_last = 0
            self.__idle_last = 0
        return self.__str_CPU

    # Get system time
    def getSystemTime(self):
        cmd = "date +%H:%M:%S"
        date_time = subprocess.check_output(cmd, shell=True)
        str_Time = str(date_time).lstrip('b\'').rstrip('\\n\'')
        return str_Time

    # Get memory usage
    def getUsagedRAM(self):
        cmd = "free | awk 'NR==2{printf \"RAM:%2d%% -> %.1fGB \", 100*($2-$7)/$2, ($2/1048576.0)}'"
        FreeRam = subprocess.check_output(cmd, shell=True)
        str_FreeRam = str(FreeRam).lstrip('b\'').rstrip('\'')
        return str_FreeRam

    # Get disk usage
    def getUsagedDisk(self):
        cmd = "df -h | awk '$NF==\"/\"{printf \"SDC:%s -> %.1fGB\", $5, $2}'"
        Disk = subprocess.check_output(cmd, shell=True)
        str_Disk = str(Disk).lstrip('b\'').rstrip('\'')
        return str_Disk

    # Get local IP address
    def getLocalIP(self):
        ip = os.popen("/sbin/ifconfig enP8p1s0 | grep 'inet' | awk '{print $2}'").read()
        ip = ip[0: ip.find('\n')]
        if(ip == ''):
            ip = os.popen("/sbin/ifconfig wlP1p1s0 | grep 'inet' | awk '{print $2}'").read()
            ip = ip[0: ip.find('\n')]
            if(ip == ''):
                ip = 'x.x.x.x'
        if len(ip) > 15:
            ip = 'x.x.x.x'
        return ip

    # Main operation loop, support hot swap
    def main_program(self):
        state = False
        try:
            cpu_index = 0
            state = self.begin()
            while state:
                self.clear()
                str_CPU = self.getCPULoadRate(cpu_index)
                str_Time = self.getSystemTime()
                if cpu_index == 0:
                    str_FreeRAM = self.getUsagedRAM()
                    str_Disk = self.getUsagedDisk()
                    str_IP = "IPA:" + self.getLocalIP()
                self.add_text(0, 0, str_CPU)
                self.add_text(50, 0, str_Time)
                self.add_line(str_FreeRAM, 2)
                self.add_line(str_Disk, 3)
                self.add_line(str_IP, 4)
                self.refresh()
                cpu_index = cpu_index + 1
                if cpu_index >= 5:
                    cpu_index = 0
                time.sleep(.1)
        except:
            pass

if __name__ == "__main__":
    try:
        i2c_num = 7
        if len(sys.argv) > 1:
            if str(sys.argv[1]).isdigit():
                i2c_num = int(sys.argv[1])
        
        oled = Juxi_OLED(i2c_num, debug=True)
        while True:
            oled.main_program()
            time.sleep(2)
    except KeyboardInterrupt:
        oled.clear(True)
        del oled
        print(" Program closed! ")
        pass

4. Iniciar el programa

# Default bus 7
python3 Oled_i2c.py

# Or specify bus (e.g. bus 1)
python3 Oled_i2c.py 1

Pasos de instalación para Raspberry Pi / Orange Pi

1. Habilitar la interfaz I2C

Entra en la configuración del sistema: Preferences → Raspberry Pi Configuration → Interfaces → Enable I2C option, y reinicia el sistema.

O usa el modo de línea de comandos:

sudo raspi-config
# Select Interface Options → I2C → Enable → Restart system

2. Instalar las dependencias

sudo apt install -y python3-dev python3-smbus i2c-tools python3-pil python3-pip python3-setuptools python3-rpi.gpio python3-venv

# Install required font
sudo apt-get install -y fonts-dejavu-core

3. Configurar permisos

sudo chmod a+rw /dev/i2c-* # Temporary effect, permanent effect requires udev rule configuration

4. Detectar el dispositivo

i2cdetect -y 1
# Normally, device address 0x3c will be displayed

5. Crear un entorno virtual (recomendado)

# Install virtual environment tool (if not installed)
sudo apt-get install -y python3-venv

# Create virtual environment
python3 -m venv oled_env

# Activate virtual environment
source oled_env/bin/activate

# Install required libraries
pip install Adafruit_SSD1306 pillow -i https://mirrors.aliyun.com/pypi/simple/

6. Ejecutar el programa

python3 Oled_i2c.py 1
# If permission error occurs, check sudo configuration or I2C device permissions

Efecto de visualización

Tras ejecutar el programa correctamente, la pantalla OLED mostrará la siguiente información en 4 líneas:

1. Primera línea: uso de la CPU + hora del sistema
2. Segunda línea: uso de memoria + memoria total
3. Tercera línea: uso de la tarjeta TF + capacidad total
4. Cuarta línea: dirección IP local del dispositivo

Enlaces relacionados

• JuxiTechnology GitHub
• Documentación de Lark Wiki