ich benötige mal wieder euere Hilfe.
Ich habe dieses 7" Display an einen ESP32 angeschlossen und dazu noch einen Potentiometer.
Ich will die Stellung des Potis grafisch darstellen und seine Stellung in Prozent auf dem Display ausgeben. Grafisch sieht das so aus. Nur dass da nicht 5 s steht, sondern je nach dem 0 - 100% und der dicke Strich und der ausgemalte Kreis verändern dann entsprechende die Position(ich nenne das im folgenden mal "Regler").
Da ich ein Hintergrundbild habe, habe ich für die Darstellung des Reglers 25 transparente Bilder erstellt. Das sieht zwar super aus, bedeutet aber auch, dass bei einer Änderung des Reglers nicht einach das aktuelle Bild über das vorherige legen kann. Ich muss bei jeder Regleränderung dafür sorgen, dass alle anderen Bilder ausgebelndet sind und nur das aktuelle eingeblendet wird.
Das funktioniert mit meinem Test-Code aus, aber zu langsam.
Wenn ich am Poti drehe, ändert sich die Prozentanzeige verzögerungsfrei, aber der Regler sieht bei der Änderung aus, als würde er "blinken". Also man erkennt, dass aus- und wieder einblenden.
Meine Frage wäre, kann ich da am Code noch was verbessern, ist das ein Hardwareproblem oder könnte man allgemein anders vorgehen um das Problem zu vermeiden?
Als Workaround habe ich mir überlegt, dass ich den dünnen Strich des Reglers als zusätzliches Bild "unter" die anderen lege und das immer eingeblendet lasse. Aber bevor ich das versuche, würde mich erst interessieren, ob ich da bis jetzt was falsch gemacht habe.
Zur Ansteuerung des Displays habe ich folgenden Code im Internet gefunden:
Code: Alles auswählen
from machine import UART
from os import uname
import time
class Nextion:
WRITE_ONLY = 0
WRITE_AND_READ = 1
DECODE = 1
RAW = 0
def __init__(self, tx_pin, rx_pin, baudrate):
self.uart = UART(1, baudrate, tx=tx_pin, rx=rx_pin)
self.uart.init(baudrate, bits=8, parity=None, stop=1)
def cmd(self, cmd, flags=WRITE_AND_READ):
end_cmd=b'\xFF\xFF\xFF'
self.uart.write(cmd)
self.uart.write(end_cmd)
if(flags == 1):
time.sleep_ms(100)
return self.uart.read()
def sleep(self, state):
self.cmd("sleep=" + str(state))
def page(self, page):
self.cmd("page {}".format(page))
def reset(self):
self.cmd("rest")
def brightness(self, brightness):
self.cmd("dim=" + str(brightness))
def read(self, flags=0):
if(flags == 0):
return self.uart.read()
else:
output = self.uart.read()
if(not output is None):
#output.replace("\xFF\xFF\xFF", "")
output = bytearray(str(output)).decode("ascii")
return output
else:
return None
Code: Alles auswählen
from machine import Pin, ADC
from time import sleep
from Nextion import Nextion
TX_PIN = 16
RX_PIN = 17
def initial_display(display):
for picture in range(1, 26):
display.cmd("vis speed{},0".format(picture), flags=0)
def translate_to_percent(value):
return 100 - (100 * value // 4095)
def translate_to_picture_number(value):
return 25 * value // 100
def clear_display(display, number):
display.cmd("vis speed{},0".format(number), flags=0)
def update_display(display, number):
display.cmd('percent.txt="{}"'.format(number), flags=0)
display.cmd("vis speed{},1".format(translate_to_picture_number(number), flags=0))
def main():
potentiometer = ADC(Pin(39))
potentiometer.atten(potentiometer.ATTN_11DB)
display = Nextion(TX_PIN, RX_PIN, 9600)
display.brightness(100)
initial_display(display)
sleep(0.1)
percent = translate_to_percent(potentiometer.read())
update_display(display, percent)
old_percent = percent
while True:
percent = translate_to_percent(potentiometer.read())
if not old_percent == percent:
clear_display(display, translate_to_picture_number(old_percent))
update_display(display, percent)
old_percent = percent
sleep(0.01)
if __name__ == "__main__":
main()
Die verwendete Nextion-Befehle sind hier auf der Nextion Seite zu finden.
Vielen Dank vorab.
Viele Grüße
Dennis
