N Ander benadering met die volgende: drie stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

In my eerste projek met Arduino Nano wat gekoppel is aan die aanraakskerm van Nextion, het ek 'n lang reeks opdragte geskryf om via die seriële poort aan Nextion te kommunikeer, en dit is onvermydelik as ons op 'n willekeurige oomblik heeltemal onafhanklike opdragte moet stuur.

Ek moet ook erken dat ek meer tyd aan biblioteke bestry het as enigiets anders. Ek het geleidelik heeltemal aan die werk gekom sonder die swaar ITEAD -biblioteke.

Ek het gou besef dat ek geen dringendheid het om die veranderinge aan die eienskappe van visuele voorwerpe aan Nextion te kommunikeer nie, maar ek verkies om te wag totdat ek dit versamel het en dit as 'n volledige groep na Nextion stuur.

Ek sal probeer om myself beter te verduidelik.

As ek in my projek uit 16 tekstuele aanduidings wil in- of uitskakel, doen ek dit deur gebruik te maak van die 'bco' -eienskap wat vir aanskakel (byvoorbeeld) van donkergrys na wit oorgaan (as in 'n swart reghoek), en omgekeerd om uit te skakel.

In my aansoek het ek dit nutteloos gevind om 16 opdragte in 16 verskillende oomblikke na die seriële poort te stuur, een vir elke 'bco' van die 16 seine.

Ek verkies eerder dat Arduino versamel watter seine 'aan' (HOOG) moet wees en watter 'af' (LOW) moet wees in 'n 16-bis-register, waar elke bit ooreenstem met een van die 16 seine van Nextion.

Nadat ek elke stukkie van die register bygewerk het, dra ek die waarde daarvan oor na Nextion, 'n enkele boodskap wat kollektiewe inligting bevat oor 16 elemente.

Op hierdie manier word die kommunikasie van Arduino en Nextion aansienlik verminder, want in die enkele boodskap wat op die reeks na Nextion gestuur word, word inligting versamel wat andersins die oordrag van 16 boodskappe sou vereis.

Dit is weliswaar nie altyd nodig om alle verslae by te werk nie, maar ek is seker dat andersins meer tyd sal mors.

Elke bietjie wat in die heelgetal deur Arduino ontvang word, moet natuurlik op die Nextion -skerm gekoppel word aan die gewenste eienskap.

Dit beteken dat kode in die Nextion -skerm geskryf moet word, maar dit is nie bang nie: as ek dit reggekry het …

Dan is daar 'n dubbele voordeel: Arduino het 'n ligter kode en is minder betrokke by seriële kommunikasie met Nextion.

Nadat die data in 'n enkele boodskap ontvang is, sal dit baie vinniger gebruik word as om op 16 boodskappe te wag. Die aan- of uitskakeling van 16 seine sal dus byna gelyktydig wees ten opsigte van die mees algemene modus, waarin die tyd vir 'n onbekende aantal boodskappe verloop tussen die uitvoering van die opdrag vir die eerste sein en die opdrag vir die laaste sein.

In die Nextion -skerm het ek hierdie stelsel op 'n klassieke manier geskep, dit wil sê deur elke keer 'n 'masker' -register te draai, kan u elkeen van die 16 bisse ondersoek. As die bietjie wat ondersoek is, HOOG is, brand die sein wat verband hou met die bit op die skerm en word afgeskakel as 'n bietjie LOW is.

Die 'negatiewe' aspek van hierdie stelsel is dat die kode wat in die Nextion -skerm verskyn, minder gerieflik is om gedokumenteer te word as die Arduino -kode. Verder loop die risiko van die Nextion -kode versprei oor verskillende voorwerpe. U moet sorg dat u dadelik dokumenteer wat u doen.

Ek gebruik Notepad ++ om die kode te skryf wat ek dan na die Nextion -voorwerp kopieer, wat byna uitsluitlik in tm0 van bladsy 0 is.

Die sintaksis van die Nextion -taal het talle beperkings, maar dit slaag daarin om dit te oorkom of om dit met 'n minimum van moeite te vermy en om die probleme uit ongewone oogpunte te sien.

As voorbeeld gee ek verslag oor die manier waarop Arduino die register wat oorgedra moet word, op die mees elementêre manier moontlik skryf.

Stap 1: Hoe die register oorgedra word

In die lêer ArduinoCode. PDF wys ek al my sketse. (As u die kode hier lees, is dit nie so duidelik nie)

Hier wil ek net wys op watter manier Arduino die 16 -bits register na Nextion stuur, sonder die hulp van die biblioteke, maar net met respek vir die sintaksis wat deur ITEAD beskryf word.

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

nietig NexUpd ()

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

{

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

SRSerial.print (InpReg); // stuur die 16 versamelde stukkies na die Nextion -skerm

SRSerial.print (InpReg); // stuur die 16 versamelde stukkies na die Nextion -skerm

SRSerial.write (terminale); // 255

SRSerial.write (terminale); // 255

SRSerial.write (terminale); // 255

}

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

Stap 2:.. Maar voor …

Natuurlik begin die kode met al die verklarings en die opstelling ().

Die insette is INPUT_PULLUP, dus is die invoerskakelaars normaalweg oop en as dit gesluit is, pas dit die GND toe op die korrespondent -invoer.

(Dit is my eerste instruksies, en ek is jammer om my kode op 'n slegte manier te wys. Laai die lêer ArduinoCode. PDF af dat dit baie duidelik is.

Laat ek meer daaroor praat

Ek het my eie manier ontwikkel om aan die Nextion -skerm te vertel wat dit moet doen. Gewoonlik stuur die MCU (in my geval Arduino) 'n boodskap vir elke variasie wat van toepassing is op die kenmerk van 'n enkele voorwerp. Ek vind dit geriefliker dat Arduino die inligting oor die eienskappe wat op Nextion moet wissel in 16 -bits registers versamel. Ongeveer elke 500 mS stuur my Arduino 'n boodskap wat die 16 -bit in elke register bevat, aan Nextion. Uiteraard benodig ons in Nextion die kode wat hanteer wat uitgevoer moet word. Hierdie verspreiding van die taak (en die kode) kan baie ander voordele inhou. Dink byvoorbeeld aan hoe om 'n lig te laat flikker! Met my benadering is dit maklik: sit 'n bietjie in die Arduino -register en stuur dit na Nextion. Die Nextion -tweelingregisters kan uit Arduino baie selde opgedateer word, omdat die flitsfrekwensie onafhanklik is van die kommunikasie; die knipfrekwensie hang af van 'n timer -voorwerp in Nextion en kan met 'n minimum tydsbasis naby 50 mS loop. Met my metode kan ons 'n lig in Nextion knip teen 'n relatief hoë frekwensie (veronderstel 2 Hz), selfs al stuur my Arduino elke 10 sekondes boodskappe, net vir 'n uiterste voorbeeld. Dit kan die teenoorgestelde probleem suggereer: hoe om te doen as die kommunikasie misluk? Dit is nie die doel van hierdie bespreking nie, maar ek het hierdie probleem reeds opgelos met 'n soort Watch Dog: een in die Arduino -kode, 'n ander in die Nextion -kode.

Die knipper word gereguleer deur die Nextion -kode, waar elke lig sy regte reëls volg: AAN/UIT of GROEN/ROOI of ook die binnekant (of ander meer) verander. Ek kan 'n paar ander dinge oor my projek vertel, maar ek verkies om op u vrae te wag voordat ek te veel woorde byvoeg, nie so maklik vir my om goed te vertaal as wat ek sou doen nie.

Stap 3: Bewerking van die Nextion -voorwerpe

Hier is 'n deel van die kode wat ek met Nextion Editor op die tm0 -voorwerp geskryf het.

Dit ontglip ons nie dat die Nextion -skerm met die 16 bisse wat van Arduino ontvang is, nie net die seine aan- en uitskakel nie. Op die oomblik laat ek die verduidelikings weg om die begrip nie te bemoeilik nie.

Ek is 'n beginner, en daarom is dit beter om die Nextion code. PDF -bladsy af te laai om die verwarde kode hier neer te lees. (Ek is jammer dit is my eerste instruksie)

As u wil, kan u die volledige kode "HMI" vir hierdie aansoek aflaai. Die lêernaam van hierdie kode is POW1225. HMI. Dit kan u Nextion -skerm NX4024T032 raakloop, maar om dit te verstaan, moet u in baie voorwerpe swem en die kode in die klein venster van die redakteur kyk. So ek dink dit sal makliker wees om na die hoofkode te kyk, wat in die lêer Nextion code. PDF geskryf is

// Projek POW1225. HMI 15 Mei 2019

// vACC (va0) Akkumulator

// vINP (va1) Invoerregister xxxx xxxx xxxx xxxx

tm0.en = 1 // tm0 Begin

tm0.tim = 50 // tm0 Tydsbasis 50 mS

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

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

as (vACC.val! = 0) // Toets RDY

{

tRDY.pco = BLOU // ROOI

} anders

{

tRDY.pco = Grys // donker Grys

}

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

vACC.val = vINP.val & 0x0002

as (vACC.val! = 0) // Toets PWR

{

tPWR.pco = GROEN // lig GROEN

tPON.txt = "AAN" // AAN

tPON.pco = GROEN // liggroen

} anders

{

tPWR.pco = Grys // donker Grys 33808

tPON.txt = "OFF" // OFF

tPON.pco = Grys // donker Grys 33808

}

// DROOG ****************

vACC.val = vINP.val & 0x0004

as (vACC.val! = 0) // Toets DRY

{

tDRV.pco = BLOU // BLOU

tDRY.pco = BLOU // BLOU

} anders

{

tDRV.pco = Grys // donker Grys 33808

tDRY.pco = Grys // donker Grys 33808

}

// RUN ****************

vACC.val = vINP.val & 0x0018

as (vACC.val! = 0) // Toets RUN

{

tRUN.bco = ROOI // MARCIA ROOI (aan)

tRUN.pco = SWART // op SWART

tDIR.bco = ROOI // DIR ROOI

tDIR.pco = SWART // op SWART

} anders

{

tRUN.bco = 32768 // MARCIA GREY (af)

tRUN.pco = Grys // op Grys

tDIR.bco = 32768 // DIR donker GROEN 1024

tDIR.pco = Grys // DIR Grys

tDIR.txt = "---" // STOP

}

// LINKS ***************

vACC.val = vINP.val & 0x0008

as (vACC.val! = 0) // Toets RUN regs

{

tDIR.txt = "<<<" // DIR LINKS

}

// REGS **************

vACC.val = vINP.val & 0x0010

as (vACC.val! = 0) // Toets RUN links

{

tDIR.txt = ">>>" // DIR REG

}

// BEIDE ***************

vACC.val = vINP.val & 0x0018

if (vACC.val == 24) // Toets RUN beide

{

tDIR.txt = ">>! <<" // DIR BEIDE

}

// TOETS ***************

vACC.val = vINP.val & 0x0020

as (vACC.val! = 0) // Toets TEST

{

tTEST.pco = WIT // WIT

tsw tTEST, 1 // Aktiveer raakgebeurtenisse

} anders

{

tTEST.pco = Grys // donker Grys 33808

tsw tTEST, 0 // Skakel Touch -geleenthede uit

}

// FOUT **************

vACC.val = vINP.val & 0x0040

as (vACC.val == 0) // Toets Fout

{

tFLT.pco = Grys // Fout afwesig

}

as (vACC.val! = 0)

{

tFLT.pco = GEEL // FOUT teenwoordig

}

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

vACC.val = vINP.val & 0x0080

as (vACC.val == 0) // Toets EME

{

tEME.pco = GREY // EME afwesig

}

as (vACC.val! = 0)

{

tEME.pco = ROOI // EME teenwoordig

}

}

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

vACC.val = vINP.val & 0x0100

as (vACC.val! = 0) // Toets FERMO

{

tFER.pco = SWART // SWART

tFER.bco = GROEN // GROEN

} anders

{

tFER.pco = Grys // Grys

tFER.bco = 672 // donker GROEN

}

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

Erkenning

Ek wil my erkenning aan Gideon Rossouwv gee, want ek het vinnig 'n deel van my doelwitte bereik toe ek sy instruksies gelees het. Dankie mnr. Gideon Rossouwv