Geekly articles weekly

Modul Laurent dan Smart Home (Bagian 2). Arduino dan AMS

Ini adalah artikel kedua dalam seri tentang mengintegrasikan modul Laurent KernelChip dalam sistem otomasi rumah, dan pada bagian ini kita akan fokus pada mengintegrasikan modul-modul ini dengan ekosistem Arduino. Pada bagian pertama dari seri ini, kami berbicara tentang integrasi dengan sistem otomatisasi rumah MajorDoMo yang populer, dan di bagian ketiga Anda akan belajar bagaimana mengelola modul-modul ini dari sketsa dalam bahasa pemrograman Pemrosesan, langsung dari desktop komputer Anda.

gambar

Arduino adalah segalanya bagi kita


Di mana tanpa Arduino? Saya tidak akan menggambarkan keunggulan platform ini untuk waktu yang lama, popularitasnya berbicara untuk dirinya sendiri, jadi mari kita segera turun ke detail teknis interaksi antara modul Arduino dan Laurent. Dan sepanjang jalan, kita tidak akan melupakan sistem Server Arduino Mega , sebagai turunan yang sangat menarik dari ekosistem Arduino.

Besi


Untuk mengendalikan modul melalui jaringan, misalnya, papan Arduino Uno yang umum atau papan Arduino Mega yang sama populernya lengkap dengan kartu antarmuka jaringan Ethernet Shield yang dipasang berdasarkan chip W5100 cocok. Semua contoh dalam artikel ini diberikan untuk kombinasi seperti itu dan telah diuji dalam praktik. Semuanya bekerja dengan andal dan tanpa masalah.

gambar
Ethernet Shield berdasarkan pada chip W5100

Yaitu, Anda hanya perlu mengambil sketsa dan mengunggahnya ke papan Uno atau Mega Anda, setelah mengubahnya sedikit untuk tugas Anda.

Kelola Modul Sketsa


Pada bagian pertama dari seri ini, saya sudah berbicara tentang prinsip-prinsip mengelola modul Laurent melalui jaringan, bagi mereka yang belum membaca bagian pertama, saya akan mengulangi teorinya secara singkat di sini.

Informasi dipertukarkan dengan modul-modul melalui jaringan dan untuk mulai bekerja dengannya, Anda perlu membuat koneksi TCP / IP pada port 2424. Setelah koneksi dibuat, Anda dapat mengirim perintah teks (disebut perintah KE) yang mengontrol modul. Situs web KernelChip memiliki dokumentasi terperinci, termasuk deskripsi yang dapat diakses dari perintah KE.

Sekarang mari kita coba menerjemahkan "kerangka acuan" teoretis ini ke dalam bahasa sederhana sketsa Arduino.

Sketsa


Saya tidak akan menjelaskan di sini cara menginstal dan mengkonfigurasi lingkungan pemrograman Arduino, diasumsikan bahwa Anda telah melakukan ini dan dapat menulis sketsa sederhana. Jadi, sebagai permulaan, kita perlu menghubungkan SPI.h perpustakaan yang diperlukan dan Ethernet.h untuk mengontrol bus dan modul Ethernet itu sendiri.

#include <SPI.h>
#include <Ethernet.h>

Maka Anda perlu mengatur pengaturan jaringan untuk modul Ethernet dan modul Laurent, yang akan kami kelola. Perhatikan bahwa alamat MAC dan alamat IP harus unik, dan LAURENT_PORT harus disetel ke 2424 dan tidak ada yang lain.

byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};

byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;

Kami masih membutuhkan penyangga untuk menyimpan perintah jaringan, dipilih dengan ukuran 200 byte dengan margin tertentu, jika Anda memiliki masalah dengan kekurangan RAM, maka Anda dapat menguranginya, misalnya menjadi 100 byte atau bahkan kurang.

char buf[200];

Dan sentuhan terakhir adalah klien Ethernet untuk modul Laurent. Sekarang kita akan melakukan semua operasi dengan modul menggunakan objek lclient.

EthernetClient lclient;

Itu saja, sekarang mari kita lihat fungsi yang mengirimkan perintah ke modul Laurent.

void sendLaurentRequest() {
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) { 
    Serial.print("Command: ");
    Serial.println(buf);
    lclient.println(buf);
    delay(100);
  
    Serial.print("Answer:  ");
    while(lclient.available() != 0) {
      char c = lclient.read();
      Serial.print(c);
    }
    delay(500);
    lclient.stop();
  } else {
      Serial.println("Error sending command");
    }
}

Jika koneksi dibuat dengan modul Laurent pada port 2424, maka isi buffer dikirim ke modul dan diduplikasi dalam Serial untuk inspeksi visual. Kemudian diharapkan 100 milidetik dan respons modul diterima. Setelah itu, jeda lagi dan komunikasi dengan modul rusak. Jika karena alasan tertentu koneksi ke modul tidak dapat dibangun, pesan kesalahan ditampilkan.

Sekarang mari kita menganalisis inisialisasi. Inisialisasi Ethernet adalah fungsi sederhana

void ethernetInit() {
  Ethernet.begin(SELF_MAC, SELF_IP);
}

Dan modul Laurent diinisialisasi oleh fungsi laurentInit (), operasi yang sekarang akan kita analisis secara terperinci. Ini cukup besar dan Anda harus memahaminya dengan baik karena berdasarkan kode untuk fungsi ini Anda dapat membangun permintaan Anda sendiri ke modul Laurent.

void laurentInit() {
  Serial.println("Start modul Laurent Init...");
  Serial.print("Connect to Laurent... ");
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
    Serial.println("OK");
    lclient.stop();
    
    // Send test command
    Serial.println("Selftest...");
    sprintf(buf, "$KE");
    sendLaurentRequest();

    // Send password (default: "Laurent")
    Serial.println("Set password...");
    sprintf(buf, "$KE,PSW,SET,Laurent");   
    sendLaurentRequest();
  } else {
      Serial.println("failed");
    }
  delay(500);
    
  //   DATA
  sprintf(buf, "$KE,DAT,OFF");
  sendLaurentRequest();
  delay(100);
  
  //  
  sprintf(buf, "$KE,REL,2,0");
  sendLaurentRequest();
  
  Serial.println("Modul Laurent Init done");
}

Awalnya, pesan inisialisasi ditampilkan dan upaya dilakukan untuk menyambung ke modul Laurent. Jika ini gagal, pesan kesalahan ditampilkan, dan jika koneksi ke modul berhasil, perintah diagnosa diri dikirim, di mana modul sehat harus merespons dengan "#OK".

Selanjutnya, perintah dikirim untuk memasukkan kata sandi (dalam hal ini, ini adalah kata sandi standar). Dan 500 milidetik diharapkan.

Selanjutnya, dua perintah tambahan diperkenalkan - salah satunya menghentikan output data oleh modul (jika berjalan), dan yang kedua mematikan relai No. 2, yang kami gunakan dalam percobaan kami. Dengan kata lain, perintah ini membawa modul ke kondisi awal.

Ini adalah cetakan dari proses inisialisasi tempat semua perintah dan semua respons modul terlihat:

Start modul Laurent Init...
Connect to Laurent... OK
Selftest...
Command: $KE
Answer:  #OK
Set password...
Command: $KE,PSW,SET,Laurent
Answer:  #PSW,SET,OK
Command: $KE,DAT,OFF
Answer:  #DAT,OK
Command: $KE,REL,2,0
Answer:  #REL,OK
Modul Laurent Init done

Sekarang kode untuk fungsi pengaturan standar (). Semua subsistem diinisialisasi, termasuk port serial pada tingkat baud 9600 standar.

void setup() {  
  Serial.begin(9600);  
  ethernetInit();
  laurentInit();
}

Jadi, kita menginisialisasi modul dan kita bisa mengelolanya seperti yang kita butuhkan: mengirim perintah, membaca jawaban, membangun logika kontrol dengan mempertimbangkan data yang dikeluarkan oleh modul Laurent.

Pertimbangkan, misalnya, tugas yang paling sederhana - untuk menghidupkan dan mematikan secara teratur lampu yang terhubung ke relai kedua modul Laurent.

void loop() {
  //  
  sprintf(buf, "$KE,REL,2,1");
  sendLaurentRequest();
  delay(3000);
  //  
  sprintf(buf, "$KE,REL,2,0");
  sendLaurentRequest();
  delay(3000);
}

Fungsi loop () adalah loop tak terbatas dan lampu, mematuhi perintah kami, akan terus menyala dan padam setiap 3 detik. Ini, tentu saja, hanya sebuah contoh, pada kenyataannya, logika kerja dapat berupa apa saja dan semuanya tergantung pada kebutuhan Anda. Dan tentu saja, Anda dapat mengirim tidak hanya perintah untuk mengaktifkan atau menonaktifkan beban, tetapi juga perintah lain yang didukung oleh modul. Anda dapat menemukan daftar perintah lengkap dan uraiannya dalam dokumentasi untuk modul Laurent.

Anda dapat mengambil sketsa ini dan mengintegrasikannya ke dalam proyek Anda sendiri, sehingga menambahkan dukungan untuk mengelola modul Laurent kepada mereka. Atau sebaliknya, anggap sketsa ini sebagai dasar dan secara bertahap tingkatkan fungsinya. Tidak ada batasan untuk kesempurnaan. Ini sketsa lengkapnya.

Kode sketsa lengkap
#include <SPI.h>
#include <Ethernet.h>

byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};

byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;

char buf[200];

EthernetClient lclient;

void ethernetInit() {
Ethernet.begin(SELF_MAC, SELF_IP);
}

void laurentInit() {
Serial.println(«Start modul Laurent Init...»);
Serial.print(«Connect to Laurent… „);
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.println(“OK»);
lclient.stop();

// Send test command
Serial.println(«Selftest...»);
sprintf(buf, "$KE");
sendLaurentRequest();

// Send password (default: «Laurent»)
Serial.println(«Set password...»);
sprintf(buf, "$KE,PSW,SET,Laurent");
sendLaurentRequest();
} else {
Serial.println(«failed»);
}
delay(500);

// DATA
sprintf(buf, "$KE,DAT,OFF");
sendLaurentRequest();
delay(100);

//
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();

Serial.println(«Modul Laurent Init done»);
} // laurentInit

void sendLaurentRequest() {
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.print(«Command: „);
Serial.println(buf);
lclient.println(buf);
delay(100);

Serial.print(“Answer: „);
while(lclient.available() != 0) {
char c = lclient.read();
Serial.print©;
}
delay(500);
lclient.stop();
} else {
Serial.println(“Error sending command»);
}
} // sendLaurentRequest

void setup() {
Serial.begin(9600);
ethernetInit();
laurentInit();
}

void loop() {
//
sprintf(buf, "$KE,REL,2,1");
sendLaurentRequest();
delay(3000);

//
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
delay(3000);
}


Arduino Mega Server


gambar

Arduino Mega Server (AMS) adalah sistem yang kuat untuk Arduino Mega (sekarang juga untuk Arduino DUE dan, segera, untuk platform 32-bit lainnya M0 (Zero) dan Genuino 101), yang berisi kode "untuk semua kesempatan" dan ditambah lagi server internal dan antarmuka web yang user-friendly. AMS mendukung modul Laurent langsung dari kotak dan Anda tidak perlu menambahkan apa pun selain logika pengguna.

AMS memiliki struktur modular dan modul switching on dan off dilakukan dengan hanya mengomentari garis dalam sketsa, misalnya,

#define LAURENT_FEATURE

atau

//#define LAURENT_FEATURE

Jika baris dikomentari, maka modul tidak dikompilasi dan tidak berpartisipasi dalam pekerjaan, seperti yang dapat dilihat pada indikator modul di header situs. Atau sebaliknya, modul yang dikompilasi dan berfungsi ditunjukkan dengan warna biru. Dalam hal ini, modul kontrol LRT LRT tidak berfungsi.

gambar
Indikator Operasi Modul

Bekerja dengan respons modul Laurent


Sekarang mari kita tambahkan kemampuan untuk tidak hanya menampilkan respons modul, tetapi juga bekerja dengannya, misalnya, menganalisis atau menampilkannya di halaman web Server Arduino Mega. Untuk melakukan ini, kita memerlukan variabel string baru dan konstanta yang menentukan panjang string yang kita tetapkan untuk jawaban modul Laurent. Dalam contoh pengujian, ini sama dengan 25 karakter, tetapi Anda dapat meningkatkannya jika jawaban tidak sesuai dengan nilai ini. Anda hanya perlu mengingat bahwa RAM mikrokontroler adalah sumber daya yang berharga dan Anda harus menyimpannya. Tambahkan baris berikut ke modul laurent.ino standar dari paket AMS:

byte MAX_LEN_LREQUEST = 25;
String lrequest = String(MAX_LEN_LREQUEST);

Kita juga perlu mengubah kode fungsi yang membuat permintaan (perubahan yang ditambahkan disorot oleh panah).

void sendLaurentRequest() {
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) { 
    Serialprint("Command: ");
    Serial.println(buf);
    lclient.println(buf);
    delay(100);
  
    Serialprint("Answer:  ");
    // -------------------->
    lrequest = "";
    // -------------------->
    while(lclient.available() != 0) {
      char c = lclient.read();
      Serial.print(c);
      // -------------------->
      if (lrequest.length() < MAX_LEN_LREQUEST) {
        lrequest += (c);
      }
      // -------------------->
    }
    delay(500);
    lclient.stop();
  } else {
      Serialprint("Error sending command\n");
    }
}

Jadi, kami belajar bagaimana mendapatkan jawaban Laurent dalam variabel lrequest dan sekarang kami dapat melakukan apa pun yang kami inginkan. Selanjutnya, saya akan menunjukkan cara menampilkan hasil kueri langsung di panel dasbor di header situs AMS.

Catatan kecil. Contoh ini menggunakan fungsi Serialprint alih-alih Serial.print standar karena menghemat lebih banyak RAM. Dan itu dapat dengan mudah dikonversi menjadi standar dengan hanya mengakhiri dua kata.

Mengeluarkan respons modul ke header situs


Dan contoh terakhir. Mari kita tampilkan jawaban dari modul Laurent di tajuk situs Arduino Mega Server. Untuk melakukan ini, kita perlu menambahkan permintaan ke loop utama () dari sketsa AMS. Buka file arduino_mega_server.ino dan masukkan kode berikut sebelum fungsi cyclosInSecWork ():

    #ifdef LAURENT_FEATURE
      if (cycle30s) {
        sprintf(buf, "$KE");   
        sendLaurentRequest();
      }
    #endif

Kode ini akan menanyakan kesehatan modul Laurent setiap tiga puluh detik. Secara alami, ini hanyalah sebuah contoh, di tempat ini dapat ada permintaan dan kode apa pun. Jadi, dalam lrequest variabel kita memiliki jawaban tentang status modul dan sekarang dapat menampilkannya di header situs. Untuk melakukan ini, buka modul server_ajax.ino dan di bagian paling akhir, dalam kode fungsi responseDash (EthernetClient cl), sebelum baris cl.println (""); tambahkan kode berikut:

    #ifdef LAURENT_FEATURE
      sendTagString("laurent", "", lrequest, cl);
    #endif

Kode ini, pada kenyataannya, mengirimkan respons modul ke halaman web. Tetap melakukan dua hal: yang pertama adalah menambahkan kode JavaScript yang akan "menangkap" data kami dan yang kedua adalah kode HTML pada halaman AMS itu sendiri, di mana jawaban modul akan ditampilkan.

Jadi, buka file scripts.js dan dalam fungsi getDashData () sebelum braket penutup} // jika (this.responseXML! = Null) masukkan kode yang akan menerima tempat kami.

          // Laurent
          try {
            var laurent = this.responseXML.getElementsByTagName('laurent')[0].childNodes[0].nodeValue;
          } catch (err) {
              laurent = "-";
            }
          document.getElementById("laurent").innerHTML = laurent;

Tetap hanya sedikit memperbaiki file dash.htm dari pengiriman AMS standar dan menambahkan kode padanya yang akan menampilkan informasi di layar. Segera setelah baris yang berisi class = "perangkat online" kami memasukkan baris baru kami dengan kode:

<p>Laurent: <span class="value" id="laurent">...</span></p>

Itu saja. Kami telah menampilkan respons modul Laurent di tajuk situs Arduino Mega Server. Dan ini adalah hasil dari upaya kami. Status modul terlihat jelas di panel AMS dan diperbarui setiap 30 detik, jadi jika terjadi sesuatu pada modul, Anda akan mengetahuinya setelah maksimal 30 detik.

gambar

Kesimpulan


Seperti yang Anda lihat, tidak ada yang rumit dalam mengelola modul Laurent menggunakan Arduino dan Arduino Mega Server, dan jika Anda sudah memiliki modul atau rencana untuk menambahkannya ke sistem Smart Home Anda, artikel ini akan membantu Anda melakukan ini dengan mudah dan sederhana.

Dan di artikel berikutnya dari siklus, Anda akan belajar cara mengelola Loranes langsung dari layar komputer Anda dan bagaimana membuat proses mengajar anak-anak pemrograman interaktif dan lebih menarik.

Selain itu . Saluran Youtube terbuka dan berikut ini adalah video promo dari Arduino Mega Server, yang menunjukkan cara bekerja dengan sistem nyata.

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

More articles:


All Articles