Inne podejście z Nextion: 3 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

W moim pierwszym projekcie z Arduino Nano podłączonym do wyświetlacza dotykowego Nextion napisałem długą serię poleceń, które miały być przekazywane do Nextion przez port szeregowy i jest to nieuniknione, jeśli musimy wysyłać całkowicie niezależne polecenia w losowych momentach.

Muszę też przyznać, że więcej czasu spędziłem na „walce” z bibliotekami niż z czymkolwiek innym. Więc stopniowo zacząłem pracować całkowicie bez ciężkich bibliotek ITEAD.

Wkrótce zdałem sobie sprawę, że nie mam pośpiechu, aby przekazać Nextionowi zmiany atrybutów obiektów wizualnych, ale wolę poczekać, aż je zgromadzę i wyślę je do Nextion jako całości, kiedy mam kompletną grupę.

Spróbuję się lepiej wytłumaczyć.

Kiedy w moim projekcie złożonym z 16 wskazań tekstowych chcę niektóre z nich włączyć lub wyłączyć, robię to za pomocą atrybutu „bco”, który przy włączaniu przechodzi (na przykład) z ciemnoszarego na biały (jeśli w czarny prostokąt) i odwrotnie, aby wyłączyć.

W mojej aplikacji stwierdziłem, że bezużyteczne jest wysyłanie 16 poleceń do portu szeregowego w 16 różnych momentach, po jednym dla każdego „bco” z 16 sygnałów.

Wolę zamiast tego, aby Arduino zbierało, które sygnały muszą być „włączone” (wysokie), a które muszą być „wyłączone” (niskie) w 16-bitowym rejestrze, gdzie każdy bit odpowiada jednej z 16 sygnalizacji Nextion.

Po aktualizacji każdego bitu rejestru przekazuję jego wartość do Nextion, pojedynczą wiadomość zawierającą zbiorczą informację dotyczącą 16 elementów.

W ten sposób komunikacja z Arduino i Nextion jest znacznie zmniejszona, ponieważ w tej pojedynczej wiadomości przesyłanej szeregowo do Nextion gromadzone są informacje, które w przeciwnym razie wymagałyby transmisji 16 wiadomości.

To prawda, że nie zawsze jest konieczne aktualizowanie wszystkich raportów, ale jestem pewien, że zrobienie tego inaczej zmarnuje więcej czasu.

Oczywiście każdy bit zawarty w liczbie całkowitej otrzymanej przez Arduino, wyświetlacz Nextion będzie musiał powiązać go z żądanym atrybutem.

Oznacza to, że kod musi być napisany na wyświetlaczu Nextion, ale nie ma się czego bać: jeśli mi się udało…

Wtedy jest podwójna zaleta: Arduino będzie miał lżejszy kod i będzie mniej zaangażowany w komunikację szeregową z Nextion.

Nextion po otrzymaniu danych w jednej wiadomości, wykorzysta je znacznie szybciej, niż gdyby miał czekać na 16 wiadomości. Włączenie lub wyłączenie 16 sygnałów będzie zatem prawie równoczesne w stosunku do najzwyklejszego trybu, w którym czas dla nieznanej liczby komunikatów upływa między wykonaniem polecenia dla pierwszej sygnalizacji a poleceniem dla ostatniej sygnalizacji.

W wyświetlaczu Nextion stworzyłem ten system w klasyczny sposób, czyli każdorazowe przekręcanie rejestru „maski” pozwala na zbadanie każdego z 16 bitów. Gdy badany bit jest WYSOKI, sygnał związany z tym bitem zapala się na wyświetlaczu i wyłącza się, gdy bit jest NISKI.

„Negatywnym” aspektem tego systemu jest to, że kod napisany na wyświetlaczu Nextion jest mniej wygodny do udokumentowania niż kod Arduino. Co więcej, kod Nextion może zostać rozrzucony po różnych obiektach. Należy zadbać o to, aby od razu udokumentować to, co robisz.

Używam Notepad ++ do pisania kodu, który następnie kopiuję do obiektu Nextion, który znajduje się prawie wyłącznie w tm0 strony 0.

Składnia języka Nextion ma wiele ograniczeń, ale udaje mu się je pokonać lub ominąć przy minimalnym wysiłku i spróbować spojrzeć na problemy z nietypowego punktu widzenia.

Jako przykład podaję sposób, w jaki Arduino zapisuje rejestr do transmisji, napisany przeze mnie w najbardziej elementarny sposób.

Krok 1: Jak przesyłany jest rejestr

W pliku ArduinoCode. PDF pokazuję cały mój szkic. (Czytanie kodu tutaj na dole nie jest takie jasne)

Tutaj na dole chcę tylko pokazać, w jaki sposób Arduino wysyła 16-bitowy Register do Nextion, bez pomocy bibliotek, ale z poszanowaniem składni opisanej przez ITEAD.

//***************************************************************************************

nieważna aktualizacja Nex()

//***************************************************************************************

{

SRSerial.print("vINP.val=");

SRSerial.print(InpReg); // prześlij 16 zebranych bitów do wyświetlacza Nextion

SRSerial.print(InpReg); // prześlij 16 zebranych bitów do wyświetlacza Nextion

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

SRSerial.write(termin); // 255

}

//***************************************************************************************

Krok 2:.. Ale przed …

Oczywiście kod zaczyna się od wszystkich deklaracji i funkcji setup().

Wejścia to INPUT_PULLUP, więc przełączniki wejściowe są normalnie otwarte, a po zamknięciu doprowadzają GND do odpowiedniego wejścia.

(To jest moja pierwsza instrukcja i przepraszam, że pokazuję ci mój kod w tak zły sposób. Pobierz plik ArduinoCode. PDF, który jest bardzo jasny.

Pozwól, że porozmawiam o tym więcej

Opracowałem własny sposób, aby „powiedzieć” wyświetlaczowi Nextion, co musi zrobić. Zwykle MCU (w moim przypadku Arduino) wysyła wiadomość dla każdej pojedynczej zmiany, aby zastosować ją do atrybutu dowolnego pojedynczego obiektu. Ta metoda marnuje dużo czasu na robienie rzeczy, które nie zawsze są tak pilne, aby stale ładować linię szeregową. Uważam, że wygodniejsze jest to, że Arduino zbiera w 16-bitowych rejestrach informacje o atrybutach, które mają się zmieniać w Nextion. Mniej więcej co 500 ms moje Arduino wysyła do Nextion jedną wiadomość zawierającą 16 bitów zawartych w każdym rejestrze w danym momencie. Oczywiście w Nextion potrzebujemy kodu, który obsłuży to, co ma zostać wykonane. Taka dystrybucja zadania (i kodu) pozwala uzyskać wiele innych korzyści. Na przykład pomyśl, jak sprawić, by mruganie było światłem! Z moim podejściem jest to proste: wstaw bit do rejestru Arduino i wyślij go do Nextion. Bliźniacze rejestry Nextion mogą być aktualizowane z Arduino bardzo rzadko, ponieważ częstotliwość migania jest niezależna od komunikacji; częstotliwość migania zależy od obiektu Timer do Nextion i może działać z minimalną podstawą czasu bliską 50 ms. Dzięki mojej metodzie możemy mrugać światłem w Nextion przy stosunkowo wysokiej częstotliwości (załóżmy 2 Hz), nawet jeśli moje Arduino wysyła wiadomości co 10 sekund, tylko dla ekstremalnego przykładu. Może to sugerować odwrotny problem: jak zrobić, jeśli komunikacja nie powiedzie się? To nie jest przedmiot tej dyskusji, ale rozwiązałem już ten problem za pomocą pewnego rodzaju Watch Dog: jednego w kodzie Arduino, drugiego w kodzie Nextion.

Miganie regulowane jest kodem Nextion, gdzie każde światło spełnia swoje własne zasady: ON/OFF lub ZIELONY/CZERWONY lub też zmiana napisu wewnątrz (lub inne więcej). Mógłbym opowiedzieć kilka innych rzeczy o moim projekcie, ale wolę poczekać na twoje pytania, zanim dodać zbyt wiele słów, które nie są tak łatwe do przetłumaczenia, jak bym chciał.

Krok 3: Edycja obiektów Nextion

Oto część kodu, który napisałem za pomocą Nextion Editor na obiekcie tm0.

Nie umknie naszej uwadze, że przy 16 bitach otrzymanych z Arduino, wyświetlacz Nextion nie tylko włącza i wyłącza sygnały. Na razie pomijam wyjaśnienia, aby nie komplikować zrozumienia.

Jestem początkującym, więc lepiej jest pobrać stronę Nextion code. PDF zamiast przeczytać pomieszany kod tutaj. (przepraszam, to moja pierwsza instrukcja)

Jeśli chcesz, możesz pobrać pełny kod "HMI" dla tej mojej aplikacji. Nazwa pliku tego kodu to POW1225. HMI. Może uruchomić się na wyświetlaczu Nextion NX4024T032, ale aby to zrozumieć, musisz wpłynąć do wielu obiektów i zajrzeć do kodu w małym oknie edytora. Myślę więc, że łatwiej będzie wyglądać główny kod, zapisany w pliku Nextion code. PDF

// Projekt POW1225. HMI 15 maja 2019

// vACC (va0) Akumulator

// vINP (va1) Rejestr wejściowy xxxx xxxx xxxx xxxx

tm0.en=1 // tm0 Start

tm0.tim=50 // tm0 Podstawa czasu 50 mS

// RDY ***************

vACC.val=vINP.val&0x0001 // Maska

if(vACC.val!=0) // Test RDY

{

tRDY.pco=NIEBIESKI // CZERWONY

}w przeciwnym razie

{

tRDY.pco=SZARY // ciemny SZARY

}

// PWR ***************

vACC.val=vINP.val&0x0002

if(vACC.val!=0) // Test PWR

{

tPWR.pco=ZIELONY // jasno ZIELONY

tPON.txt="WŁ" // WŁ

tPON.pco=ZIELONY // jasno ZIELONY

}w przeciwnym razie

{

tPWR.pco=SZARY // ciemny SZARY 33808

tPON.txt="WYŁĄCZONY" // WYŁĄCZONY

tPON.pco=SZARY // ciemny SZARY 33808

}

// SUCHY ***************

vACC.val=vINP.val&0x0004

if(vACC.val!=0) // Test DRY

{

tDRV.pco=NIEBIESKI // NIEBIESKI

tDRY.pco=NIEBIESKI // NIEBIESKI

}w przeciwnym razie

{

tDRV.pco=SZARY // ciemny SZARY 33808

tDRY.pco=SZARY // ciemny SZARY 33808

}

// BIEGAĆ ***************

vACC.val=vINP.val&0x0018

if(vACC.val!=0) // Uruchom test

{

tRUN.bco=RED // MARCIA RED (wł.)

tRUN.pco=CZARNY // na CZARNY

tDIR.bco=CZERWONY // KATALOG CZERWONY

tDIR.pco=CZARNY // na CZARNY

}w przeciwnym razie

{

tRUN.bco=32768 // MARCIA GREY (wyłączone)

tRUN.pco=GREY // na GREY

tDIR.bco=32768 // DIR ciemnozielony 1024

tDIR.pco=SZARY // DIR SZARY

tDIR.txt="---" // ZATRZYMAJ

}

// LEWO **************

vACC.val=vINP.val&0x0008

if(vACC.val!=0) // Uruchom test w prawo

{

tDIR.txt="<<< " // KIER LEWY

}

// PRAWIDŁOWY *************

vACC.val=vINP.val&0x0010

if(vACC.val!=0) // Uruchom test w lewo

{

tDIR.txt=" >>>" // KATALOG PRAWY

}

// ZARÓWNO **************

vACC.val=vINP.val&0x0018

if(vACC.val==24) // Uruchom oba testy

{

tDIR.txt=">>!<<" // KATALOG OBU

}

// TEST **************

vACC.val=vINP.val&0x0020

if(vACC.val!=0) // Test TEST

{

tTEST.pco=BIAŁY // BIAŁY

tsw tTEST, 1 // Włącz zdarzenia dotykowe

}w przeciwnym razie

{

tTEST.pco=SZARY // ciemny SZARY 33808

tsw tTEST, 0 // Wyłącz zdarzenia dotykowe

}

// WADA *************

vACC.val=vINP.val&0x0040

if(vACC.val==0) // Test BŁĄD

{

tFLT.pco=SZARY // BŁĄD nieobecny

}

if(vACC.val!=0)

{

tFLT.pco=ŻÓŁTY // BŁĄD obecny

}

// EME ***************

vACC.val=vINP.val&0x0080

if(vACC.val==0) // Przetestuj EME

{

tEME.pco=GREY // EME nieobecny

}

if(vACC.val!=0)

{

tEME.pco=RED // EME obecny

}

}

// FERMO *************

vACC.val=vINP.val&0x0100

if(vACC.val!=0) // Przetestuj FERMO

{

tFER.pco=CZARNY // CZARNY

tFER.bco=ZIELONY // ZIELONY

}w przeciwnym razie

{

tFER.pco=SZARY // SZARY

tFER.bco=672 // ciemny ZIELONY

}

// *******************

Potwierdzenie

Chcę podziękować Gideonowi Rossouwvowi, ponieważ czytając jego Instructables, szybko osiągnąłem część moich celów. Dziekuję panu. Gideon Rossouwu