FLProg + Hioni Selanjutnya. Pelajaran 2



Dalam pelajaran terakhir , saya berbicara tentang panel HMI Nextion dan tentang membuat proyek untuk panel ini di Editor Nextion.
Dalam tutorial ini, saya akan menunjukkan kepada Anda bagaimana mengontrol panel ini menggunakan program FLProg dari papan Arduino. Sebagai contoh, mari kita kumpulkan stasiun cuaca paling sederhana, yang akan membaca data dari sensor suhu dan kelembaban DHT-22 dan menampilkannya di panel. Grafik perubahan dalam parameter ini juga akan dibuat. Kecerahan lampu latar layar panel akan diubah menggunakan resistor variabel.

Tata letak bangku tes.


Pertama, Anda perlu mengunggah proyek ke panel (file proyek dalam arsip adalah tautan yang di bagian akhir artikel adalah Lesson2.hmi).
Proyek ini terdiri dari tiga layar.
Layar pertama digunakan untuk menampilkan suhu (halaman “halaman0” indeks - 0).



Ini terdiri dari unsur-unsur berikut:
1 - Gambar dengan gambar termometer alkohol.
2 - Elemen "Bilah kemajuan". Dengan bantuannya, termometer disimulasikan.

Pengaturan Item.


Saya merekomendasikan elemen-elemen yang akan selalu menjadi global melalui UART (atribut "vccope" disetel ke "global"), dan karenanya memberikan nama-nama unik kepada mereka (atribut "objname") di seluruh proyek. Ini mempercepat pekerjaan pengontrol Arduino, dan mengurangi kode untuk itu. Saya akan menjelaskan alasannya.
Saat mencoba menulis atribut elemen lokal, Anda harus terlebih dahulu meminta halaman saat ini dari panel (ini adalah permintaan terpisah yang membutuhkan setidaknya 20 ms.). Jika halaman adalah halaman tempat elemen tersebut berada, maka nilainya dikirim ke panel; jika tidak, nilai yang dimaksudkan untuk pengiriman ditulis ke variabel (yang membutuhkan ruang memori yang sama). Ketika Anda pergi ke halaman dengan elemen, Anda harus segera memperbarui atributnya dengan nilai aktual terbaru, karena ketika merender halaman, variabel lokal diinisialisasi dengan nilai yang ditentukan saat membuat proyek. Dan jika ada banyak elemen yang dikelola dari controller di halaman, maka ketika beralih ke sana, controller ini akan sibuk untuk waktu yang lama dengan memperbarui semua elemen.
Untuk elemen global, semuanya jauh lebih sederhana. Anda dapat merekam nilai atribut untuk itu kapan saja, dan nilai terakhir digunakan saat merender halaman. Ini berarti bahwa tidak perlu meminta nomor halaman sebelum mengirim dan tidak perlu mengubah untuk menyimpan nilai.
Tapi tentu saja itu semua tergantung proyek. Jika proyek untuk panel sangat besar, dan tidak ada cukup ruang untuk elemen global, maka Anda dapat, seolah-olah, mengambil memori dari pengontrol dan menjadikannya lokal.
3. Kotak teks untuk menampilkan suhu.

Parameter barang.


Gambar yang dipotong dipilih sebagai latar belakang (atribut "sta" nilai "potong gambar"). Dan seperti gambar yang digunakan untuk memotong, hal yang sama digunakan yang digunakan untuk latar belakang seluruh halaman (atribut "picc" adalah indeks gambar dari perpustakaan gambar). Berkat ini, tex diperoleh dengan latar belakang transparan.
Seperti yang sudah saya tulis dalam pelajaran terakhir, panel tidak tahu bagaimana bekerja dengan bilangan pecahan dan negatif, dan untuk suhu keduanya mungkin. Oleh karena itu, untuk menampilkan nilai suhu, bidang teks digunakan, ke mana garis selesai akan dikirim langsung dari pengontrol.
4. Gambar yang dipotong.

Parameter barang.


Dengan bantuan elemen ini, matahari akan ditampilkan ketika suhu melebihi batas yang telah ditentukan. Sebenarnya, adalah mungkin untuk menggunakan gambar biasa, dan mengubah visibilitasnya, tetapi sejak contoh pelatihan, saya memutuskan untuk menggunakan elemen khusus ini. Saya sendiri sudah lama memahami ideologi elemen ini, saya akan mencoba menunjukkan cara kerjanya. Untuk pekerjaannya, saya membuat dua gambar, satu dengan matahari, yang lain tanpa matahari.





Elemen ini menampilkan bagian dari gambar yang dilampirkan padanya (atribut "picc" adalah indeks dari gambar di pustaka gambar). Sudut kiri atas bagian ini adalah dalam koordinat penyisipan elemen (atribut "x" dan "y") dan memiliki lebar dan tinggi elemen (atribut "w" dan "h"). Selama pengoperasian program pengontrol, jika perlu, pengikatan elemen ke gambar akan berubah.

5. Tombol.

Parameter barang.


Ketika Anda mengklik tombol, itu pergi ke halaman berikutnya. Saya menggunakan gambar sebagai latar belakang tombol. Saya menggunakan gambar yang sama untuk kedua status (atribut "pic" dan "pic2" adalah indeks gambar di perpustakaan gambar) karena keadaan yang ditekan tidak akan pernah terlihat, ketika Anda mengklik tombol, itu langsung menuju ke halaman berikutnya. Karena kami tidak akan mengubah apa pun di tombol ini, saya meninggalkannya lokal dan nama default.

Kode dalam acara "Sentuh Acara Pers".


Layar kedua digunakan untuk menampilkan kelembaban (halaman "halaman1" indeks - 1).


Untuk latar belakang halaman, saya menggunakan gambar dengan gambar skala hygrometer yang disiapkan.


Pertimbangkan elemen yang termasuk dalam halaman.

1. Elemen "Gaude", yang akan mensimulasikan operasi hygrometer.

Parameter barang.


Karena kita akan mengendalikannya dari controller, itu dibuat global. Gambar yang dipotong (atribut "sta") dipilih sebagai latar belakang, dan gambar latar belakang halaman (atribut "picc") dipilih sebagai latar belakang.

2. Bidang numerik.

Parameter barang.


Nilai kelembaban akan ditampilkan di bidang ini. Karena panel tidak mendukung kerja dengan angka fraksional, kami akan menampilkan nilai kelembaban tanpa bagian fraksional. Gambar yang dipotong dipilih sebagai latar belakang (atribut "sta" nilai "potong gambar"). Dan seperti gambar yang digunakan untuk memotong, hal yang sama digunakan yang digunakan untuk latar belakang seluruh halaman (atribut "picc" adalah indeks gambar dari perpustakaan gambar). Demi keindahan tampilan, saya mengatur perataan ke kanan (atribut nilai "xcen" - 2), dan di sebelahnya saya meletakkan bidang teks (3) dengan nilai "%". Pengaturan latar belakang untuknya mirip dengan pengaturan untuk bidang angka.

Opsi bidang teks (3).


4 dan 5. Tombol halaman sebelumnya dan halaman berikutnya. Ketika Anda menekan tombol 4, Anda pergi ke halaman pertama, dan ketika Anda mengklik tombol 5, Anda pergi ke halaman berikutnya. Pengaturan tampilan tombol mirip dengan tombol di halaman pertama.

Pengaturan Tombol 4 ("Halaman Sebelumnya")


Kode dalam "Acara Tekan Sentuh" ​​untuk Tombol 4 ("Halaman Sebelumnya").


Pengaturan Tombol 5 ("Halaman Berikutnya")


Kode dalam "Acara Tekan Sentuh" ​​untuk Tombol 5 ("Halaman Berikutnya").


Halaman ketiga - Grafik perubahan suhu dan kelembaban (indeks "halaman2" - 2).


Pada halaman ini akan ditampilkan grafik perubahan suhu dan kelembaban. Pertimbangkan elemen yang termasuk dalam halaman.

1. Elemen Waveform.

Parameter barang.


Dalam pelajaran terakhir, saya sudah menulis bahwa elemen ini tidak dapat (saya harap sejauh ini) menjadi global, yaitu, nilai atribut dapat diubah, tetapi ini tidak akan mengarah pada apa pun. Jadi saya meninggalkannya lokal (siapa tahu, tapi tiba-tiba dia masih memakan memori variabel global). Akan ada dua saluran tampilan dalam elemen ini (atribut "ch" nilai - 2).

2 dan 3 hanyalah bidang teks yang menunjukkan sumbu grafik.

4 - Tombol kembali. Ini mirip dengan tombol yang sama pada layar sebelumnya, dengan pengecualian kode pada pengendali event.

Kode dalam "Acara Tekan Sentuh" ​​untuk tombol 4 ("Halaman Sebelumnya").


Kami telah menemukan panelnya, sekarang mari kita urus pengontrolnya. Saya tidak akan memberi tahu cara membuka program FLProg, membuat proyek, dan menggambar diagram. Semua ini saya katakan dalam pelajaran sebelumnya (pelajaran 1 , pelajaran 2 ), dan di samping itu, banyak informasi tentang ini ada di pusat pelatihan di situs web proyek. Karena itu, saya akan segera menunjukkan papan sirkuit yang sudah jadi dan memberi tahu apa yang terjadi pada mereka.

Papan 1. Membaca data dari sensor.


Untuk mendapatkan nilai suhu dan kelembaban dengan sensor DHT-22, blok B1 digunakan - "DHT11, DHT21, DHT22" (Perpustakaan elemen, folder "Sensor").

Blokir pengaturan (dipanggil dengan mengklik dua kali).


Dalam pengaturan, pin ditetapkan untuk output "Data" dari sensor yang terhubung, jenis sensor, dan adanya output suhu dan kelembaban. Mode polling sensor juga dipilih. Saya mengatur polling sensor setiap 5 detik.

Karena pengontrol Arduino tidak bekerja dengan baik dengan angka floating point, dan bekerja dengan mereka memakan banyak memori, saya segera menerjemahkan semua nilai ke dalam format Integer. Untuk melakukan ini, gunakan blok B3 dan B4 - "Konversi Float ke Integer" (perpustakaan elemen, folder "Jenis Konversi"), yang memotong bagian fraksional dari angka. Agar tidak kehilangan sepersepuluh derajat, nilai suhu yang diperoleh dari sensor dikalikan 10 dengan menggunakan blok B2 - “MUL (*)” (perpustakaan elemen, folder “Matematika”).
Kemudian nilai yang diperoleh dalam format Integer dimasukkan ke dalam variabel yang sesuai.

Papan 2. Menampilkan nilai suhu pada panel.


Dalam proyek ini, saya menggunakan koneksi bernama. Anda dapat mempelajari lebih lanjut tentang mereka dalam pelajaran yang sesuai .
Untuk membatasi beban pada pengontrol, masuk akal untuk mengirim data ke panel hanya ketika data telah berubah. Oleh karena itu, kami pertama-tama menentukan bahwa data telah berubah. Untuk melakukan ini, gunakan blok B5 - "Detektor perubahan angka" (pustaka elemen, folder - "Blok dasar"). Unit ini mengontrol angka "Nilai" pada inputnya dan, ketika diubah, menghasilkan pulsa output dari satu siklus pelaksanaan program pada output.
Setelah itu, kami menyiapkan string untuk dikirim ke bidang teks panel. Pertama, bagi nilai suhu, dikalikan dengan 10, dengan konstanta tipe Float dengan nilai 10. Dengan demikian, kita mendapatkan nilai suhu dengan bagian fraksional. Kami melakukan ini menggunakan blok B6 - “DIV (/)” (pustaka elemen, folder “Matematika”). Kemudian kita mengubah nilai yang diperoleh dalam format Float menjadi string menggunakan blok B7 - “Konversi string” (pustaka elemen, folder “Type Conversion”). Kemudian kita hubungkan string yang dihasilkan dengan string konstan "C" menggunakan blok B8 - "Addition of lines" (pustaka elemen, folder "Lines"). Baris yang dihasilkan diumpankan ke input unit untuk menulis nilai atribut ke panel HMI B9 Nextion - “Set Parameter” (pustaka elemen -> folder “Panel HMI Nextion” -> folder “Elemen”).
Blok ini menulis nilai ke atribut yang ditentukan.

Blok parameterisasi.

Dengan mengklik dua kali pada blok, jendela editor blok terbuka.


Jika belum ada panel yang dibuat dalam proyek, maka Anda perlu membuat panel. Jika panel yang diperlukan telah dibuat, itu dapat dipilih dari daftar drop-down dengan menekan tombol 3. Panel yang dipilih dapat diubah menggunakan tombol "Ubah panel" (2). Untuk membuat panel, klik tombol "Tambah Panel" (1). Jendela pembuatan panel akan terbuka.


Dalam dialog ini, pilih port untuk menghubungkan panel (dalam pelajaran kami - SoftwareSerial). Jika Anda memilih SoftwareSerial, Anda juga harus memilih pin yang ditetapkan sebagai sinyal RX dan TX dari port UART (dalam kasus kami, 2 dan 3). Anda juga perlu menetapkan nama panel. Itu harus unik. Beberapa panel dapat dihubungkan dalam suatu proyek, selama ada cukup banyak port UART gratis. Nama setiap panel harus unik dalam proyek. Dalam dialog yang sama Anda dapat menambahkan halaman yang termasuk dalam panel. Apa yang akan kita lakukan Klik tombol tambah halaman. Jendela pembuatan halaman terbuka.


Di jendela ini kita perlu memasukkan nama halaman dan ID-nya. Informasi ini dapat dipelajari dari proyek di Editor Nextin.


Secara default, halaman awal (dibuka saat controller dinyalakan) akan menjadi halaman dengan ID 0, tetapi Anda dapat mencentang kotak "Halaman Awal" di properti halaman mana saja dan itu akan menjadi halaman awal.
Di jendela ini, Anda dapat menambahkan elemen yang menarik bagi kami yang ada di halaman ini. Klik tombol "Tambahkan item".
Jendela pembuatan item terbuka.


Di sini kita perlu memilih jenis dan jenis elemen, masukkan namanya, indeks, dan jika elemen tersebut bersifat global, tetapkan kotak centang yang sesuai. Semua data ini dapat dilihat di proyek di Editor Nextin.


Setelah mengisi semua data, klik "Selesai", dan kemudian di jendela pembuatan halaman dengan cara yang sama tambahkan semua elemen yang menarik bagi kami di halaman ini.


Setelah membuat semua elemen pada halaman, kita juga mengklik tombol “Finish” di jendela pembuatan halaman dan di jendela untuk membuat panel menggunakan skenario yang sama, buat sisa halaman.






Kami selesai membuat panel dengan tombol "Selesai" yang familier.
Di editor blok, pilih halaman "halaman0" elemen "Teks" dengan nama "tnt" dan atributnya "Teks (txt)". Sebagai nilai, pilih input.


Blok dikonfigurasi.
Kami mempertimbangkan skema lebih lanjut.
Secara empiris, sudah pasti ditentukan bahwa nilai -40 derajat dari termometer yang ditarik sesuai dengan nilai 10 pada elemen "Progress bar" yang terletak di sana, dan nilai 50 derajat ke termometer sesuai dengan nilai kemajuan 91 bar. Sesuai dengan ini, kami skala nilai dengan variabel "Suhu x10" menggunakan blok B10 - "Skala" (perpustakaan Elemen, folder "Scaling") tanpa lupa bahwa kami memiliki nilai suhu dikalikan dengan 10. Parameter dari blok ini.


Nilai suhu berskala dikirim ke panel menggunakan blok B11 - "Set Parameter" (pustaka elemen -> folder "Panel Nextion HMI" -> folder "Elements"). Pengaturan untuk blok ini.


Blok B12 berikutnya - "Pembanding" (perpustakaan elemen, folder "Perbandingan") menentukan apakah suhu saat ini melebihi titik yang ditetapkan dengan nilai default dari variabel "Setpoint - Hot". Ini adalah 290 (jangan lupa bahwa di mana-mana kita memiliki suhu dikalikan dengan 10).


Blok B12 dikonfigurasikan untuk menghasilkan unit logis pada outputnya ketika nilai pada input "I1" melebihi nilai pada input "I2".


Blok B13, B14, dan B15 membentuk sirkuit deteksi perubahan sinyal diskrit. Blok B13 dan B14 - Rtrig (pustaka elemen, folder "Pemicu"), ketika tepi terdepan dari sinyal diskrit muncul, berikan pulsa output dengan durasi 1 siklus program. Blok B14, karena inversi pada inputnya, mendeteksi tepi trailing dari sinyal "Exceeding the threshold". Blok B15 –OR (pustaka elemen, folder “Elemen Dasar”), jika ada unit logis pada salah satu input, outputkan unit logis ke outputnya. Dengan demikian, sinyal terbentuk "Mengirim data ketika ambang melebihi." Di tepi terdepan sinyal ini, perintah dikirim untuk mengubah warna font bidang teks yang menampilkan suhu saat ini. Pengiriman terjadi menggunakan blok B17– “Set Parameter” (pustaka elemen -> folder “Panel HMI Selanjutnya” ->Folder elemen). Pengaturan untuk blok ini.


Nilai yang dikirimkan dalam perintah dipilih menggunakan blok B16 - “Switch” (pustaka elemen, folder “Switch”). Blok ini dengan level logika rendah pada inputnya mentransfer nilai dari input “0” ke output, dan dengan yang tinggi, dari input “1”. Nilai warna yang disediakan untuk input sakelar diatur menggunakan blok B44 dan B45 - “Color Hight Color konstan” (pustaka elemen -> folder “Panel HMI Berikutnya” -> folder “Warna”). Warna dipilih di editor blok (klik dua kali pada blok).


Untuk memilih warna, klik tombol "Ubah". Pemilih warna terbuka.


Di dalamnya, pengaturan nilai komponen R (merah), G (hijau) dan B (biru), warna yang diperlukan dipilih.
Juga, di tepi depan sinyal "Mengirim data ketika ambang melebihi", perintah dikirim untuk mengubah pengikatan gambar yang dipotong. Ini terjadi menggunakan blok B19 - “Set Parameter” (pustaka elemen -> folder “Panel HMI Selanjutnya” -> folder “Elemen”).
Pengaturan untuk blok ini.


Indeks gambar dipilih menggunakan blok B18 - “Switch” (pustaka elemen, folder “Switch”). Karyanya telah dijelaskan di atas. Nilai indeks dari gambar yang diperlukan dapat dilihat di proyek Editor Nextion di pustaka gambar.

Dengan transfer data suhu selesai. Mari beralih ke kelembaban.

Papan 3. Kesimpulan kelembaban.


Seperti halnya suhu, pertama-tama kita membuat sinyal “Mengirim data saat kelembaban berubah”. Kami melakukan ini menggunakan blok B20 - "Detektor perubahan angka" (perpustakaan elemen, folder - "Blok dasar"). Pengoperasian unit ini telah dijelaskan sebelumnya. Sinyal ini mengirimkan nilai ke bidang numerik yang menampilkan kelembaban. Ini dilakukan dengan menggunakan blok B21– “Set Parameter” (pustaka elemen -> folder “Panel HMI Selanjutnya” -> folder “Elemen”).
Pengaturan untuk blok ini.


Secara empiris, pasti ditentukan bahwa untuk nilai kelembaban 0% dari skala hygrometer yang ditarik dalam desain panel, elemen "Gayge" yang menggambar panah adalah 314 dan untuk kelembaban 100% adalah 226. Pada saat yang sama, panah melewati nilai 0. Ketika dikonversi ke nilai linear, kami mendapatkan kontinu berkisar dari -46 (0%) hingga 226 (100%). Sesuai dengan data ini, kami mengkonfigurasi blok B22 - "Skala".
Parameter Blok.


Karena nilai untuk elemen "Gauge" tidak boleh negatif, untuk menghitung sudut panah pada nilai-nilai ini, dalam kasus nilai negatif, nilai 360 ditambahkan ke dalamnya. Kami melakukan ini menggunakan blok B23- "SUMM (+)" (pustaka elemen, Folder matematika). Kami menentukan bahwa jumlahnya kurang dari 0 menggunakan blok B26 - "Pembanding" (perpustakaan elemen, folder "Perbandingan"). Keluarannya mengontrol saklar B24 - “Switch” (pustaka elemen, folder “Switch”) dan nilai yang dipilih dikirim ke panel menggunakan blok B25 - “Set Parameter” (pustaka elemen -> folder “Nextion HMI Panel” -> folder “Elements” )
Pengaturan untuk blok ini.


Papan selanjutnya menampilkan grafik perubahan suhu dan kelembaban.


Seperti yang saya tulis di awal pelajaran, elemen Waveform tidak tahu bagaimana menjadi elemen global dan digambar ulang setiap kali Anda membuka halaman di mana ia berada. Kita harus menghindari batasan ini. Pertama, tentukan jumlah halaman yang saat ini dimuat pada panel. Untuk melakukan ini, gunakan blok B27 - “Dapatkan Id halaman saat ini” (pustaka elemen -> folder “Panel HMI Berikutnya” -> folder “Halaman”). Dalam pengaturan blok ini Anda hanya perlu memilih panel yang akan kami akses dengan permintaan ini.


Nomor halaman yang diperoleh dari blok ini dibandingkan dengan indeks halaman yang kita butuhkan (2) menggunakan blok B28 - "Pembanding" (pustaka elemen, folder "Perbandingan"). Jika halaman yang diinginkan terbuka, maka unit logis ditulis ke dalam variabel "Buka halaman bagan", jika tidak, maka nol logis.
Menggunakan blok B29 - "Generator" (pustaka elemen, folder "Pengatur Waktu"), sinyal dihasilkan untuk merekam titik berikutnya pada grafik. Blok ini menghasilkan pulsa dengan durasi dan jeda pulsa yang diberikan.
Blokir pengaturan.


Jenis generator yang dipilih adalah "Symmetric multivibrator", yang berarti bahwa durasi pulsa sama dengan durasi jeda. Saat mengatur durasi pulsa menjadi 5 detik, masing-masing, jeda akan sama 5 detik. Tepi terdepan pulsa akan datang setiap 10 detik. Bagian depan ini disorot oleh blok B30 - "Rtrig" (pustaka elemen, folder "Pemicu"), dan ditulis ke dalam variabel "Perintah untuk merekam titik berikutnya".
Di tepi depan sinyal "Buka grafik halaman", yang akan dipilih menggunakan blok B31 - "Rtrig" (pustaka elemen, folder "Pemicu"), sinyal "Kirim grafik riwayat" akan dihasilkan. Berdasarkan sinyal ini, isi array akan dikirim ke panel pada grafik; Untuk suhu, ini akan dilakukan dengan menggunakan blok B32 - “Mengirim array ke grafik” (pustaka elemen -> folder “Panel HMI Berikutnya” -> folder “Grafik”). Blok dikonfigurasi menggunakan editor blok.


Pertama, Anda perlu membuat array di mana sejarah grafik suhu akan disimpan. Untuk melakukan ini, klik tombol "Buat". Jendela pembuatan array terbuka.


Di lautan ini, Anda harus memasukkan nama array, ketik (gunakan Byte, karena elemen Waveform mengambil nilai maksimum 255). Ukurannya diambil sama dengan lebar grafik (330).
Setelah membuat, pilih panel, halaman, elemen dan saluran di mana grafik akan digambar.


Dengan cara yang sama, kita mengonfigurasi blok untuk mengirim array dengan data kelembaban ke panel B33 - “Mengirim array ke grafik” (pustaka elemen -> folder “Panel HMI Berikutnya” -> folder “Grafik”). Dalam pengaturannya, kami membuat array lain untuk menyimpan data ini.


Sekarang Anda perlu menyiapkan data untuk grafik suhu. Bagan ini akan memiliki garis di sepanjang porosnya pada ketinggian 160 poin dari bagian bawah grafik. Untuk membuat perubahan suhu lebih terlihat, kami membagi nilai variabel "Temperatur x10" dengan 5 (yaitu, seolah mengalikan nilai suhu riil dengan 2) menggunakan blok B35 dan menambahkan offset ke dalamnya menggunakan blok B36. Hasilnya akan dimasukkan ke dalam variabel "Suhu dengan pergeseran untuk grafik."
Menggunakan blok B37 - "Stack" (pustaka elemen, folder "array"), pulsa dari variabel "Perintah untuk merekam titik berikutnya" ditulis ke array oleh suhu dengan pergeseran untuk grafik menggunakan prinsip tumpukan (elemen pertama dari array dihapus, sisanya digeser satu, dan nilai terakhir ditulis). Blok ini diparameterisasi menggunakan editor blok.


Di editor, pilih array yang diinginkan dengan mengklik tombol "Pilih".
Dengan cara yang sama, kita mengkonfigurasi blok B34 - "Stack" (perpustakaan elemen, folder "array") untuk menulis nilai kelembaban ke array dengan memilih di array yang sesuai.
Jika halaman bagan terbuka, transfer array ke bagan selesai, dan perintah untuk merekam titik berikutnya diterima, maka nilai-nilai titik baru dikirim ke bagan yang sesuai. Ini diperlukan agar grafik terus dibangun saat halaman ditampilkan. Kepatuhan terhadap kondisi ini dipantau menggunakan blok B38 - “AND” (pustaka elemen, folder “Elemen dasar”). Blok ini mengeluarkan unit pada outputnya jika ada unit logis di semua inputnya. Nilai suhu berikutnya dengan pergeseran dikirim ke grafik menggunakan blok B40 - "Tambahkan titik ke grafik" (perpustakaan elemen -> folder "Panel HMI Berikutnya" -> folder "Grafik").
Blokir pengaturan.


Blok untuk mengirim nilai kelembaban berikutnya ke bagan B39 juga diatur - "Tambahkan titik ke bagan" (perpustakaan elemen -> folder "Panel HMI Berikutnya" -> folder "Bagan").


Selesai dengan kesimpulan jadwal.

Papan 5. Sesuaikan kecerahan lampu latar.


Nilai set lampu latar menggunakan resistor variabel dibaca menggunakan blok input analog "Kecerahan". Karena nilai kecerahan lampu latar panel diatur dalam rentang 0 hingga 100, kami menskalakan nilai baca dari rentang 0-1023 hingga kisaran 0-100 menggunakan blok B41 - “Skala”.
Blokir pengaturan.


Lalu kami menentukan fakta perubahan dalam nilai ini menggunakan blok B42 - "Detektor untuk mengubah angka". Blok ini memiliki sedikit pengaturan non-standar.


Agar tidak mengubah kecerahan untuk setiap gerakan resistor variabel, deadband diatur dalam unit dengan nilai 5. Yaitu, unit akan bekerja ketika nilai input berubah lebih dari 5 pada kedua arah. Ketika unit dipicu, perintah akan dikirim ke panel untuk mengatur kecerahan cahaya latar baru menggunakan blok B43 - "Setel tingkat cahaya latar" (pustaka elemen -> folder "Panel HMI Berikutnya" -> folder "Sistem").
Pengaturan blok


Bekerja pada program untuk pengontrol selesai.

Bagi yang tertarik dengan kode untuk skoller sketsa yang dihasilkan.
#include <SoftwareSerial.h>
#include "DHT.h"
DHT _dht1(4, DHT22);

SoftwareSerial Serial100(2, 3);

byte _FLPArray142003126[330] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
byte _FLPArray239384258[330] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int _SUETFLPATemp = 0;
byte _nextionSaveDataVAL_P0_E2;
long _nextionSaveDataPCO_P0_E3;
String _nextionSaveDataTXT_P0_E3;
byte _nextionSaveDataPICC_P0_E4;
int _nextionSaveDataVAL_P1_E2;
long _nextionSaveDataVAL_P1_E4;
String _nextionCommandTempString;
struct _nextionLissenStruct {
  char code;
  String result;
  long number;
};
_nextionLissenStruct _nextionTempLissen;
int nextionGetPageIdTempVar = 0;
int NextionPanel_47525121_PageIdOut = 0;
int _hasNumberChangeInTemp = 0;
int _gtv1;
int _gtv2;
int _gtv3 = 290;
bool _gtv4 = 0;
bool _gtv5 = 0;
int _gtv6;
unsigned long _dht1Tti = 0UL;
float _dht1t = 0.00;
float _dht1h = 0.00;
bool _changeNumber1_Out = 0;
int _changeNumber1_OLV;
bool _nextionSetAttr1_isNU = 0;
bool _nextionSetAttr1_oldState = 0;
bool _nextionSetAttr2_isNU = 0;
bool _nextionSetAttr2_oldState = 0;
bool _trgrt1 = 0;
bool _trgrt1I = 0;
bool _trgrt2 = 0;
bool _trgrt2I = 0;
bool _nextionSetAttr3_isNU = 0;
bool _nextionSetAttr3_oldState = 0;
long _swi1;
bool _nextionSetAttr4_isNU = 0;
bool _nextionSetAttr4_oldState = 0;
byte _swi2;
bool _nextionSetAttr5_isNU = 0;
bool _nextionSetAttr5_oldState = 0;
bool _changeNumber2_Out = 0;
int _changeNumber2_OLV;
int _swi3;
bool _nextionSetAttr6_isNU = 0;
bool _nextionSetAttr6_oldState = 0;
bool _trgrt3 = 0;
bool _trgrt3I = 0;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
bool _trgrt5 = 0;
bool _trgrt5I = 0;
bool _nextionAddPointToWave1_OldState = 0;
bool _nextionAddPointToWave2_OldState = 0;
bool _SFLPAS1;
bool _SFLPAS2;
bool _nextionSendArraytToWave1_OldState = 0;
bool _nextionSendArraytToWave2_OldState = 0;
bool _nextionSetLighting1_OldStae = 0;
bool _changeNumber3_Out = 0;
int _changeNumber3_OLV;
void setup()
{
  Serial100.begin(9600);
  _dht1.begin();
  nextionSendCommand("", 100);
  nextionAck(100);
  nextionSendCommand("page 0", 100);
  delay(100);
  nextionAck(100);
}
void loop()
{ nextionGetPageIdTempVar = nextionAskPageNamper(100);
  if ( ! (nextionGetPageIdTempVar < 0) ) {
    NextionPanel_47525121_PageIdOut = nextionGetPageIdTempVar;
  };
  if (_isTimer(_dht1Tti, 5000)) {
    _dht1Tti = millis();
    float tempDht4;
    tempDht4 = _dht1.readTemperature();
    if (!(isnan(tempDht4))) {
      _dht1t = tempDht4;
    }
    tempDht4 = _dht1.readHumidity();
    if (!(isnan(tempDht4))) {
      _dht1h = tempDht4;
    }
  }



  _gtv1 = (int((_dht1t) * (10)));
  _gtv2 = (int(_dht1h));
  if ((_gtv1) > (_gtv3)) {
    if (_trgrt1I) {
      _trgrt1 = 0;
    } else {
      _trgrt1 = 1;
      _trgrt1I = 1;
    }
  } else {
    _trgrt1 = 0;
    _trgrt1I = 0;
  };
  if ((_gtv1) > (_gtv3))
  {
    _swi1 = 63488;
  }
  else
  {
    _swi1 = 2016;
  }
  if (!((_gtv1) > (_gtv3))) {
    if (_trgrt2I) {
      _trgrt2 = 0;
    } else {
      _trgrt2 = 1;
      _trgrt2I = 1;
    }
  } else {
    _trgrt2 = 0;
    _trgrt2I = 0;
  };
  if ((_gtv1) > (_gtv3))
  {
    _swi2 = 2;
  }
  else
  {
    _swi2 = 0;
  }
  if (_changeNumber1_Out) {
    _changeNumber1_Out = 0;
  } else {
    _hasNumberChangeInTemp = _gtv1;
    if (_hasNumberChangeInTemp != _changeNumber1_OLV) {
      _changeNumber1_OLV = _hasNumberChangeInTemp;
      _changeNumber1_Out = 1;
    }
  }
  if (_changeNumber1_Out) {
    if (! _nextionSetAttr1_oldState ) {
      _nextionSetAttr1_oldState = 1;
      _nextionSetAttr1_isNU = 1;
      _nextionSaveDataTXT_P0_E3 =  ((( _floatToStringWitRaz((_gtv1) / (10.00), 1))) + (String(" C"))) ;
    }
  } else {
    _nextionSetAttr1_oldState = 0;
  } if (_nextionSetAttr1_isNU) {
    _nextionCommandTempString = String("page0.tnt.txt=\"") + _nextionSaveDataTXT_P0_E3 + String("\"");
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr1_isNU = 0;
  } if (_changeNumber1_Out) {
    if (! _nextionSetAttr2_oldState ) {
      _nextionSetAttr2_oldState = 1;
      _nextionSetAttr2_isNU = 1;
      _nextionSaveDataVAL_P0_E2 =  (map((_gtv1), (-400), (500), (10), (91))) ;
    }
  } else {
    _nextionSetAttr2_oldState = 0;
  } if (_nextionSetAttr2_isNU) {
    _nextionCommandTempString = String("page0.tpb.val=") + String(_nextionSaveDataVAL_P0_E2);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr2_isNU = 0;
  } if (( (_trgrt1) || (_trgrt2) )) {
    if (! _nextionSetAttr3_oldState ) {
      _nextionSetAttr3_oldState = 1;
      _nextionSetAttr3_isNU = 1;
      _nextionSaveDataPCO_P0_E3 =  _swi1 ;
    }
  } else {
    _nextionSetAttr3_oldState = 0;
  }
  if (nextionAskPageNamper(100) == 0) {
    if (_nextionSetAttr3_isNU) {
      _nextionCommandTempString = String("page0.tnt.pco=") + String(_nextionSaveDataPCO_P0_E3);
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionCommandTempString = "ref tnt";
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionSetAttr3_isNU = 0;
    }
  } else {
    _nextionSetAttr3_isNU = 1;
  }
  if (( (_trgrt1) || (_trgrt2) )) {
    if (! _nextionSetAttr4_oldState ) {
      _nextionSetAttr4_oldState = 1;
      _nextionSetAttr4_isNU = 1;
      _nextionSaveDataPICC_P0_E4 =  _swi2 ;
    }
  } else {
    _nextionSetAttr4_oldState = 0;
  }
  if (nextionAskPageNamper(100) == 0) {
    if (_nextionSetAttr4_isNU) {
      _nextionCommandTempString = String("page0.tci.picc=") + String(_nextionSaveDataPICC_P0_E4);
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionCommandTempString = "ref tci";
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
      _nextionSetAttr4_isNU = 0;
    }
  } else {
    _nextionSetAttr4_isNU = 1;
  }
  if (((map((_gtv2), (0), (100), (-46), (226)))) < (0))
  {
    _swi3 = ((map((_gtv2), (0), (100), (-46), (226)))) + (360);
  }
  else
  {
    _swi3 = (map((_gtv2), (0), (100), (-46), (226)));
  }
  if (_changeNumber2_Out) {
    _changeNumber2_Out = 0;
  } else {
    _hasNumberChangeInTemp = _gtv2;
    if (_hasNumberChangeInTemp != _changeNumber2_OLV) {
      _changeNumber2_OLV = _hasNumberChangeInTemp;
      _changeNumber2_Out = 1;
    }
  }
  if (_changeNumber2_Out) {
    if (! _nextionSetAttr5_oldState ) {
      _nextionSetAttr5_oldState = 1;
      _nextionSetAttr5_isNU = 1;
      _nextionSaveDataVAL_P1_E4 =  _gtv2 ;
    }
  } else {
    _nextionSetAttr5_oldState = 0;
  } if (_nextionSetAttr5_isNU) {
    _nextionCommandTempString = String("page1.humN.val=") + String(_nextionSaveDataVAL_P1_E4);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr5_isNU = 0;
  } if (_changeNumber2_Out) {
    if (! _nextionSetAttr6_oldState ) {
      _nextionSetAttr6_oldState = 1;
      _nextionSetAttr6_isNU = 1;
      _nextionSaveDataVAL_P1_E2 =  _swi3 ;
    }
  } else {
    _nextionSetAttr6_oldState = 0;
  } if (_nextionSetAttr6_isNU) {
    _nextionCommandTempString = String("page1.humG.val=") + String(_nextionSaveDataVAL_P1_E2);
    nextionSendCommand(_nextionCommandTempString.c_str(), 100);  nextionAck(100);
    _nextionSetAttr6_isNU = 0;
  } if (1) {
    if (! _gen1I) {
      _gen1I = 1;
      _gen1O = 1;
      _gen1P = millis();
    }
  } else {
    _gen1I = 0 ;
    _gen1O = 0;
  }
  if (_gen1I) {
    if ( _isTimer ( _gen1P , 5000 )) {
      _gen1P = millis();
      _gen1O = ! _gen1O;
    }
  }
  if (_gen1O) {
    if (_trgrt5I) {
      _trgrt5 = 0;
    } else {
      _trgrt5 = 1;
      _trgrt5I = 1;
    }
  } else {
    _trgrt5 = 0;
    _trgrt5I = 0;
  };
  if (_gtv4) {
    if (_trgrt3I) {
      _trgrt3 = 0;
    } else {
      _trgrt3 = 1;
      _trgrt3I = 1;
    }
  } else {
    _trgrt3 = 0;
    _trgrt3I = 0;
  };
  _gtv4 = (NextionPanel_47525121_PageIdOut) == (2);
  _gtv5 = _trgrt5;
  if (_trgrt3) {
    if ( ! _nextionAddPointToWave1_OldState) {
      _nextionAddPointToWave1_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        for (int nextionSATWTemp = 0;  nextionSATWTemp < 330;  nextionSATWTemp ++) {
          _nextionCommandTempString = String ("add 1,1,") + String (_FLPArray142003126[nextionSATWTemp]);
          nextionSendCommand(_nextionCommandTempString.c_str(), 100);
        } delay (50);
      }
    }
  } else {
    _nextionAddPointToWave1_OldState = 0;
  }

  if (_trgrt3) {
    if ( ! _nextionAddPointToWave2_OldState) {
      _nextionAddPointToWave2_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        for (int nextionSATWTemp = 0;  nextionSATWTemp < 330;  nextionSATWTemp ++) {
          _nextionCommandTempString = String ("add 1,0,") + String (_FLPArray239384258[nextionSATWTemp]);
          nextionSendCommand(_nextionCommandTempString.c_str(), 100);
        } delay (50);
      }
    }
  } else {
    _nextionAddPointToWave2_OldState = 0;
  }

  if (_gtv5) {
    if (!_SFLPAS1) {
      _SFLPAS1 =  1;
      for (_SUETFLPATemp = 0; _SUETFLPATemp < 329; _SUETFLPATemp = _SUETFLPATemp + 1 ) {
        _FLPArray239384258[_SUETFLPATemp ] = _FLPArray239384258[_SUETFLPATemp + 1];
      }  _FLPArray239384258[329] = _gtv2;
    }
  }  else {
    _SFLPAS1 = 0;
  }
  _gtv6 = ((_gtv1) / (5)) + (160);
  if (_gtv5) {
    if (!_SFLPAS2) {
      _SFLPAS2 =  1;
      for (_SUETFLPATemp = 0; _SUETFLPATemp < 329; _SUETFLPATemp = _SUETFLPATemp + 1 ) {
        _FLPArray142003126[_SUETFLPATemp ] = _FLPArray142003126[_SUETFLPATemp + 1];
      }  _FLPArray142003126[329] = _gtv6;
    }
  }  else {
    _SFLPAS2 = 0;
  }
  if (( (_gtv5) && (!(_trgrt3)) && (_gtv4) )) {
    if ( ! _nextionSendArraytToWave1_OldState) {
      _nextionSendArraytToWave1_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        _nextionCommandTempString = String ("add 1,0,") + String (_gtv2);
        nextionSendCommand(_nextionCommandTempString.c_str(), 100); delay (50);
      }
    }
  } else {
    _nextionSendArraytToWave1_OldState = 0;
  }

  if (( (_gtv5) && (!(_trgrt3)) && (_gtv4) )) {
    if ( ! _nextionSendArraytToWave2_OldState) {
      _nextionSendArraytToWave2_OldState = 1;
      if (nextionAskPageNamper(100) == 2) {
        _nextionCommandTempString = String ("add 1,1,") + String (_gtv6);
        nextionSendCommand(_nextionCommandTempString.c_str(), 100); delay (50);
      }
    }
  } else {
    _nextionSendArraytToWave2_OldState = 0;
  }

  if (_changeNumber3_Out) {
    _changeNumber3_Out = 0;
  } else {
    _hasNumberChangeInTemp = (map(( (analogRead (0))), (0), (1023), (0), (100)));
    if (((_hasNumberChangeInTemp > _changeNumber3_OLV) && ((_hasNumberChangeInTemp - _changeNumber3_OLV ) > 5)) || ((_hasNumberChangeInTemp < _changeNumber3_OLV) && ((_changeNumber3_OLV - _hasNumberChangeInTemp ) > 5) ))
    {
      _changeNumber3_OLV = _hasNumberChangeInTemp;
      _changeNumber3_Out = 1;
    }
  }
  if (_changeNumber3_Out) {
    if (!(_nextionSetLighting1_OldStae)) {
      _nextionSetLighting1_OldStae = 1;
      _nextionCommandTempString = String("dim=") + String((map(( (analogRead (0))), (0), (1023), (0), (100))));
      nextionSendCommand(_nextionCommandTempString.c_str(), 100);
    }
  } else {
    _nextionSetLighting1_OldStae = 0;
  }




}
bool _isTimer(unsigned long startTime, unsigned long period )
{
  unsigned long currentTime;
  currentTime = millis();
  if (currentTime >= startTime) {
    return (currentTime >= (startTime + period));
  } else {
    return (currentTime >= (4294967295 - startTime + period));
  }
}
String  _floatToStringWitRaz(float value, int raz)
{
  float tv;
  int ti = int(value);
  String ts = String(ti);
  if (raz == 0) {
    return ts;
  }
  ts += ".";
  float tf = abs(value - ti);
  for (int i = 1; i <= raz; i++ )
  {
    tv = tf * 10;
    ti = int(tv);
    ts += String(ti);
    tf = (tv - ti);
  }
  return ts;
}
void nextionSendCommand(const char* cmd, byte port )
{
  while (Serial100.available()) {
    Serial100.read();
  }
  Serial100.print(cmd);
  Serial100.write(0xFF);
  Serial100.write(0xFF);
  Serial100.write(0xFF);
}
boolean nextionAck( byte port )
{
  uint8_t bytes[4] = {0};
  Serial100.setTimeout(20); if (sizeof(bytes) != Serial100.readBytes((char *)bytes, sizeof(bytes))) {
    return 0;
  }

  if ((bytes[1] == 0xFF) && (bytes[2] == 0xFF) && (bytes[3] == 0xFF)) {
    switch (bytes[0]) {
      case 0x00:
        return false; break;
      case 0x01:
        return true; break;
      default:
        return false;
    }
  }
}
struct _nextionLissenStruct nextionListen( byte port )
{
  char _bite;
  char _end = 0xff;
  String cmd;
  _nextionLissenStruct temp;
  int countEnd = 0;
  delay(10);
  while (Serial100.available() > 0) {
    if (Serial100.available() > 0) {
      _bite = Serial100.read();
      cmd += _bite;
      if (_bite == _end) {
        countEnd++;
      }
      if (countEnd == 3) {
        break;
      }
    }
  }
  temp.result = "";
  temp.code = 'z';
  temp.number = 0;
  switch (cmd[0]) {
    case 'e':
      temp.code = 'e';
      countEnd = 0;
      for (uint8_t i = 0; i < cmd.length(); i++) {
        if (cmd[i] == _end) {
          countEnd++;
        }
        temp.result += String(cmd[i], HEX);
        if (countEnd == 3) {
          return temp;
        }
        temp.result += " ";
      }
      break;
    case 'f':
      temp.code = 'f';
      temp.result = String(cmd[1], DEC);
      return temp;
      break;
    case 'g':
      temp.code = 'g';
      temp.result = String(cmd[2], DEC) + "," + String(cmd[4], DEC) + "," + String(cmd[5], DEC);
      return temp;
      break;
    case 'h':
      temp.code = 'h';
      temp.result = String(cmd[2], DEC) + "," + String(cmd[4], DEC) + "," + String(cmd[5], DEC);
      temp.result = "68 " + temp.result;
      return temp;
      break;
    case 'p':
      temp.code = 'p';
      temp.result = cmd.substring(1, cmd.length() - 3);
      return temp;
      break;
    case 'q':
      temp.code = 'q';
      temp.number = (cmd[4] << 24) | (cmd[3] << 16) | (cmd[2] << 8) | (cmd[1]);
      return temp;
      break;
    default:
      return temp;
      break;
  }
  return temp;
}
int nextionAskPageNamper(byte port)
{
  int result;
  _nextionLissenStruct temp;
  nextionSendCommand("sendme", port);
  temp = nextionListen(port);
  if ((temp.code == 'f') && (temp.result != "")) {
    result = temp.result.toInt();
  } else {
    result = -1;
  }
  return result;
}


Video pendek dengan demonstrasi.


Arsipkan dengan proyek untuk panel dan proyek untuk pengontrol.
Dalam pelajaran berikutnya, kita akan belajar cara mengontrol pengontrol Arduino dari panel.

Source: https://habr.com/ru/post/id392685/


All Articles