[Diao Ye aprende a programar] MicroPython práctico (14) - Pantalla OLED de la placa de control 2

Puntos de conocimiento: ¿Qué es un tablero de control?
La placa de control es un hardware inteligente de código abierto que populariza la educación de creadores de STEAM, la educación en inteligencia artificial y la educación en programación de robots. Integra el chip de doble núcleo de alto rendimiento ESP-32, admite la comunicación de modo dual WiFi y Bluetooth, y se puede utilizar como un nodo de IoT para realizar aplicaciones de IoT. Al mismo tiempo, la placa de control integra una pantalla OLED, luces RGB, acelerómetros, micrófonos, sensores de luz, zumbadores, interruptores de llave, interruptores táctiles e interfaces de expansión externa con dedos dorados.Admite gráficos y programación de código MicroPython, que pueden realizar robots inteligentes. , Aplicaciones de control inteligente como Maker Smart Works.

Características del hardware de la placa de control: Control
principal ESP-32
Procesador: Procesador de doble núcleo Tensilica LX6 (un núcleo maneja la conexión de alta velocidad; un núcleo de desarrollo de aplicaciones independiente)
frecuencia principal: frecuencia de reloj de hasta 240 MHz
SRAM: 520 KB
Flash:
Wi-Fi de 8 MB estándar: FCC/CE/TELEC/KCC
Protocolo Wi-Fi: 802.11 b/g/n/d/e/i/k/r (802.11n, velocidad de hasta 150 Mbps), agregación A-MPDU y A-MSDU, soporte 0.4us Intervalo de protección
Rango de frecuencia: 2.4~2.5 GHz
Protocolo Bluetooth: Cumple con los estándares Bluetooth v4.2 BR/EDR y BLE
Audio Bluetooth: Audio CVSD y SBC Bajo consumo de energía: 10uA
Método de suministro de energía: Fuente de alimentación Micro USB
Voltaje de funcionamiento: 3,3 V
Corriente de funcionamiento máxima: 200 mA
Corriente de carga máxima: 1000 mA Acelerómetro de tres ejes
integrado MSA300, rango de medición: ±2/4/8/16G sensor geomagnético MMC5983MA, rango de medición: ±8 Gauss, precisión 0,4 mGz, error de brújula electrónica ±0,5 ° Sensor de luz Micrófono 3 perlas de lámpara ws2812 a todo color Pantalla OLED de 1,3 pulgadas, admite pantalla de 16 * 16 caracteres, resolución 128x64 zumbador pasivo , admite 2 botones físicos (A / B), 6 botones táctiles, admite 1 interfaz de clip de cocodrilo, Fácil acceso a varios sensores resistivos









Interfaz de expansión
E/S digital de 20 canales (incluido PWM de 12 canales, entrada táctil de 6 canales)
ADC de entrada analógica de 12 bits de 5 canales, P0~P4
Interfaz de pinza de cocodrilo de entrada externa de 1 canal: EXT/GND
compatible con I2C, UART , protocolo de comunicación SPI

9. Realice el efecto de escritura dinámica OLED

efecto de escritura dinámica

from mpython import *
oled.fill(0)

cadena mostrada

_str = "La placa de control es una placa de microcontrolador MicroPython, que utiliza el lenguaje de programación Python más popular, por lo que puede transferir fácilmente el código desde el escritorio al microcontrolador o al sistema integrado. hardware para educación de inteligencia artificial y educación de programación.Integra el chip de doble núcleo de alto rendimiento ESP-32, admite la comunicación de modo dual WiFi y Bluetooth, y se puede utilizar como un nodo de Internet de las cosas para realizar aplicaciones de Internet de las cosas.El control La placa está equipada con una pantalla OLED, una lámpara RGB, un acelerómetro, un micrófono, un sensor de luz, un zumbador, un interruptor de llave, un interruptor táctil, una interfaz de expansión externa Golden Finger, admite la programación de gráficos y código Python, y puede realizar aplicaciones de control inteligente, como robots inteligentes y creadores. trabajos inteligentes Usando los sensores ricos en el control, combinados con su pequeño tamaño, también se puede usar en varios trabajos de bricolaje, como ropa inteligente y accesorios electrónicos ".

coordenadas del punto de partida

axis = (0, 0)

Mostrar palabra por palabra, continuar mostrando de acuerdo con las coordenadas devueltas

for c in _str:
    response = oled.DispChar(c, axis[0], axis[1])
    char_width = response[0]
    axis = response[1]
    oled.show()

    # 满屏时,清屏
    if axis[1] >= 64 - 16 and char_width >= 128-axis[0]:
        print('Clear screen')
        oled.fill(0)

anotación:

oled.DispChar_font(font, s, x, y, invert=False)

Pantalla de fuente personalizada. Los usuarios pueden convertir archivos de fuentes estándar otf y ttf en el lado de la PC para generar código fuente de python con mapa de bits de fuente a través del script de Python font_to_py.py de acuerdo con sus propias necesidades, y llamarlos para su uso. Devuelve una tupla de 2 de (el ancho total en píxeles del carácter, las coordenadas x, y de la visualización de continuación).

font - el objeto de la fuente. El código fuente de Python convertido por el script font_to_py.py se coloca en el sistema de archivos. Tenga en cuenta que el archivo de fuente debe importarse antes de usar la función.
s - la cadena para mostrar
x, y - la esquina superior izquierda del texto como las coordenadas del punto inicial.
invertir - inversión de píxeles de visualización.

Use el script font_to_py.py para convertir fuentes en el lado de la PC:

Convierta la altura a 16px que contenga solo un conjunto de caracteres ASCII

font_to_py.py -x FreeSans.ttf 16 myfont.py

La altura de conversión es de 16 píxeles para especificar el conjunto de caracteres Unicode, y el parámetro -c es seguido por el conjunto de caracteres que especificó

font_to_py.py -x simfang.ttf 16 simfang.py -c  ¬!"#£$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~°Ωαβγδθλμπωϕ£

Experimento grabando video: efecto de escritura dinámica OLED en el tablero de control (29 segundos)

https://v.youku.com/v_show/id_XNDYzODQyNzkzMg==.html

10. Relación dinámica entre el seno y el círculo
Muestre la relación entre el seno y el círculo controlando el oled integrado.

#MicroPython动手做（14）——掌控板之OLED屏幕
#动态正弦与圆的关系

from mpython import *
from machine import Timer
import math

def upRange(start, stop, step):
    while start <= stop:
        yield start
        start += abs(step)

def downRange(start, stop, step):
    while start >= stop:
        yield start
        start -= abs(step)

def timer1_tick(_):
    global Dy, Dx, i, j, my_list, _item
    oled.fill_rect(48, 0, 80, 64, 0)
    oled.hline(48, 32, 80, 1)
    oled.vline(48, 8, 50, 1)
    j_end = int(len(my_list) - 1)
    for j in (0 <= j_end) and upRange(0, j_end, 1) or downRange(0, j_end, 1):
        oled.pixel(((len(my_list) + 49) - j), my_list[j], 1)

tim1 = Timer(1)

def add_to_list(_item):
    global Dy, Dx, i, j, my_list
    my_list.append(_item)
    if len(my_list) > 72:
        my_list.pop(0)


my_list = []
oled.fill(0)
tim1.init(period=100, mode=Timer.PERIODIC, callback=timer1_tick)
while True:
    for i in range(0, 361, 5):
        oled.fill_rect(0, 0, 47, 64, 0)
        oled.circle(20, 32, 20, 1)
        Dx = int((20 + math.cos(math.radians(i)) * 20))
        Dy = int((32 - math.sin(math.radians(i)) * 20))
        oled.line(20, 32, Dx, Dy, 1)
        oled.line(Dx, Dy, 46, Dy, 1)
        oled.show()
        add_to_list(Dy)

Programación de gráficos mPython X

Video: muestra la relación entre el seno y el círculo controlando el oled integrado (10 segundos)

https://v.youku.com/v_show/id_XNDYzODU1MDgxMg==.html?spm=a2hbt.13141534.app.5 _5!2 5!2 ₅ 5 _5!2 5 _5!2 5!2 _5!2 5 ₅ A

11. Caracteres fluidos de pantalla completa OLED

#MicroPython práctico (14) - Pantalla OLED de la placa de control
#OLED pantalla completa palabras que fluyen

#MicroPython动手做（14）——掌控板之OLED屏幕
#OLED满屏流水字

from mpython import *
import time


rgb.fill((int(0), int(0), int(102)))
rgb.write()
time.sleep_ms(1)
while True:
    _E8_A1_8C = 0
    while not _E8_A1_8C >= 4:
        _E5_88_97 = 0
        while not _E5_88_97 >= 8:
            oled.fill(0)
            oled.DispChar("掌控板OLED", (_E5_88_97 * 16), (_E8_A1_8C * 16), 1)
            oled.show()
            _E5_88_97 = _E5_88_97 + 1
        _E8_A1_8C = _E8_A1_8C + 1
    _E8_A1_8C = 0
    while not _E8_A1_8C >= 4:
        _E5_88_97 = 0
        while not _E5_88_97 >= 8:
            oled.fill(0)
            oled.DispChar("mPython", (_E5_88_97 * 16), (_E8_A1_8C * 16), 1)
            oled.show()
            _E5_88_97 = _E5_88_97 + 1
        _E8_A1_8C = _E8_A1_8C + 1

Programación de gráficos mPython X

12. La pantalla de salto muestra 32 caracteres

//MicroPython práctico (14) - Pantalla OLED de la placa de control
//La pantalla de salto muestra 32 caracteres

//MicroPython动手做（14）——掌控板之OLED屏幕
//跳动屏显32个字

#include <MPython.h>

// 动态变量
volatile float mind_n_Xing, mind_n_Lie;


// 主程序开始
void setup() {
    
    
        mPython.begin();
}
void loop() {
    
    
        mind_n_Xing = 0;
        while (!(mind_n_Xing>=4)) {
    
    
                mind_n_Lie = 0;
                while (!(mind_n_Lie>=8)) {
    
    
                        display.setCursor((mind_n_Lie * 16), (mind_n_Xing * 16));
                        display.print("掌");
                        mind_n_Lie += 1;
                        yield();
                }
                mind_n_Xing += 1;
                yield();
        }
        buzz.freq(196, BEAT_1_4);
        delay(1000);
        mind_n_Xing = 0;
        while (!(mind_n_Xing>=4)) {
    
    
                mind_n_Lie = 0;
                while (!(mind_n_Lie>=8)) {
    
    
                        display.setCursor((mind_n_Lie * 16), (mind_n_Xing * 16));
                        display.print("控");
                        mind_n_Lie += 1;
                        yield();
                }
                mind_n_Xing += 1;
                yield();
        }
        buzz.freq(196, BEAT_1_4);
        delay(1000);
        mind_n_Xing = 0;
        while (!(mind_n_Xing>=4)) {
    
    
                mind_n_Lie = 0;
                while (!(mind_n_Lie>=8)) {
    
    
                        display.setCursor((mind_n_Lie * 16), (mind_n_Xing * 16));
                        display.print("板");
                        mind_n_Lie += 1;
                        yield();
                }
                mind_n_Xing += 1;
                yield();
        }
        buzz.freq(392, BEAT_1_4);
        delay(1000);
}

Programación gráfica Mind+