5. Interaksi Kontrol & Responnya

Ketika kita mengirimkan permintaan, kita ingin tahu apakah permintaan kita tersebut dilaksanakan atau tidak. Di bagian ini kita akan membahas dan menerapkan request dan respon tersebut dalam kaitannya dengan tampilan gambar proses kerja yang telah kita buat di bagian ke-4, dan juga penggunaan Arduino di bagian ke-3. 

Jadi apa sih yang akan kita buat? 
Seperti teman-teman ketahui, bahwa di bagian ke-4, kita telah membuat gambar proses di halaman web, yang bisa interaktif, yang akan berganti setiap kali tombol berbeda ditekan. Tampilan gambar proses tersebut saya maksudkan sebagai representasi atau visualisasi dari suatu mesin, dalam contoh yang saya buat di bagian ke-4, mesin itu adalah CT-Scan. Hanya saja, kekurangan dari visualisasi tersebut ada 2: yaitu, kita tidak tahu berapa lama suatu proses harus dijalankan, bisa saja ketika kita melanjutkan ke proses berikutnya, ternyata proses yang sebelumnya masih belum selesai. Kemudian kekurangan kedua, ketika penekanan tombol tidak berurutan, akan mengakibatkan proses kerjanya menjadi salah. Untuk itu diperlukan 2 hal berikut ini:
  1. Harus ada indikator yang memberi tanda bahwa proses yang dijalankan saat itu, telah selesai.
  2. Harus ada kontrol program yang membuat proses tidak dapat dijalankan ketika tombol yang ditekan tidak berurutan.
Untuk menghasilkan kedua solusi di atas, berikut ini gambaran langkah-langkahnya:
1. Untuk menandai bahwa proses telah selesai, digunakan 8 buah tombol yang terhubung ke Arduino. Kedelapan tombol di sini digunakan untuk mensimulasikan 8 buah sensor. yang masing-masing sensor menandai selesainya proses tertentu. Jadi ketika tombol pertama (yang terhubung ke Arduino) ditekan, ini berarti proses pertama telah selesai. Ketika tombol 2 ditekan, ini berarti proses kedua telah selesai, demikian seterusnya.

2. Untuk menunjukkan bahwa proses sedang berjalan, digunakan 8 buah LED yang terhubung ke Arduino. LED akan menyala ketika button di halaman web ditekan. Ketika button STEP1 ditekan, LED pertama harusnya menyala. Ketika LED pertama menyala, ini berarti proses pertama sedang berlangsung. Penekanan button yang kedua tidak akan bisa menyalakan LED kedua. LED kedua hanya bisa menyala apabila LED pertama sudah padam. Untuk memadamkan LED pertama, tombol pertama di Arduino, sebagai simulasi sensor yang menandai proses pertama selesai, harus ditekan. Baru setelah LED pertama mati, maka penekanan button kedua di halaman web bisa membuat LED kedua menyala. Demikian seterusnya, jadi setiap kali akan menjalankan proses berikutnya, proses sebelumnya harus sudah selesai dulu.

3. Langkah pertama dan kedua di atas sebenarnya telah dibuat di bagian ke-3 dari blog ini, yaitu dengan topik Arduino, Proteus & Node-RED, di mana sudah dibuat 8 buah node button di Node-RED, yang bila ditekan akan menyalakan 8 buah LED di Proteus, dan sudah dibuat 8 buah tombol di Proteus, yang bila ditekan, akan mengirimkan angka 1 s/d 8 ke Node-RED, seperti terlihat pada gambar berikut ini. 

Gambar 1. Komunikasi serial antara Node-RED dengan Arduino yang disimulasikan di Proteus

4. Hanya saja, dalam aplikasi yang sudah dibuat di atas, belum ada kontrol program yang memaksa prosesnya bekerja secara berurutan. Proses masih dapat dijalankan secara tidak berurutan. Diinginkan agar proses bisa bekerja berurutan, dimulai dari proses pertama (LED pertama menyala), yang dinyalakan dari penekanan button 1, dan selesai ketika tombol urutan pertama (posisi paling atas) di Proteus ditekan (LED pertama padam), baru kemudian dilanjutkan proses kedua (LED kedua menyala), yang dinyalakan dari penekanan button 2, dan selesai ketika tombol posisi kedua di Proteus ditekan (LED kedua padam), demikian seterusnya, jadi proses berikutnya hanya bisa dijalankan apabila proses sebelumnya telah selesai. Button 0 akan mereset proses hingga bisa bekerja kembali dari awal. 

5. Untuk membuat kontrol program yang memaksa proses bekerja secara berurutan, cara paling mudah adalah dengan menambahkan counter, yang nilainya akan naik 1 angka setiap kali salah satu button ditekan, atau salah satu tombol di Proteus ditekan. Angka counter ini akan kembali 0 ketika button 0 ditekan. Kemudian agar bisa berurut, semua button dan tombol diberi angka yang berurutan. Mulai dari button 1, bila ditekan akan menghasilkan angka 1. Dilanjutkan tombol teratas di Proteus, bila ditekan akan menghasilkan angka 2. Berikutnya button 2, bila ditekan akan menghasilkan angka 3. Kemudian tombol di posisi kedua di Proteus, bila ditekan akan menghasilkan angka 4, demikian seterusnya, hingga terakhir, button 8, bila ditekan akan menghasilkan angka 15, dan tombol terbawah di Proteus. bila ditekan akan menghasilkan angka 16. Kemudian dengan membandingkan angka counter dengan angka yang dihasilkan setiap kali button atau tombol ditekan, akan diketahui apakah penekanan button atau tombol tersebut berurutan atau tidak. Jadi ketika counter bernilai 1, maka seharusnya button 1 yang ditekan. Ketika counter bernilai 2, maka seharusnya tombol teratas di Proteus yang ditekan, karena tombol teratas menghasilkan angka 2. Apabila antara nilai counter dengan angka yang dihasilkan button atau tombol tidak sama, maka tidak akan ada output dikeluarkan, sebaliknya apabila sama, maka akan ada output dikeluarkan, dengan cara ini, akan memaksa penekanan tombol atau button haruslah tombol atau button yang menghasilkan angka yang sama dengan counter. Dan setiap kali output bisa dikeluarkan, nilai counter akan bertambah 1, yang membuat button atau tombol yang ditekan haruslah button atau tombol urutan berikutnya.

6. Berikut ini implementasi dari langkah no. 5 di atas. Mula-mula, silahkan rekan-rekan mengunduh file program Node-RED yang dibuat di bagian ke-3, yang bisa juga diunduh di sini: 

7. Buka program Node-RED tersebut, klik 2 kali pada node button, kemudian ubah beberapa msg.payload node button dari 0, 1, 2, 3, 4, 5, 6, 7, 8 sehingga menjadi 0, 1, 3, 5, 7, 9, 11, 13, 15.

Gambar 2. Ubah angka di node button, dari 0, 1, 2, 3, 4, 5, 6, 7, 8, menjadi 0, 1, 3, 5, 7, 9, 11, 13, 15

7. Berikutnya, tambahkan sebuah node switch, sisipkan di antara kesembilan node button dengan node serial out. Fungsi node switch ini untuk menyaring output node button, yaitu hanya meneruskan output dari node button, apabila nilai output node button tersebut sama dengan nilai counter. Agar nilai counter ini bisa diakses oleh setiap node yang ada di halaman program, maka nilai counter ini menggunakan jenis variabel context flow (variabel context flow adalah sebuah variabel yang dapat diakses oleh node lain di dalam halaman flow yang sama, tanpa perlu menghubungkannya dengan garis). Lebih jelas mengenai node switch ini, lihat gambar berikut:

Gambar 3. Sisipkan node switch di antara node button dan node serial out, dan isi kotaknya dengan == flow.counter

8. Berikutnya, ambil sebuah node function, dan hubungkan output node switch ke input node function, dan isi node function dengan kode seperti berikut. 

Gambar 4. Tambahkan node function, hubungkan output node switch ke input node function, dan isi kode program di node function seperti berikut: 

  1. var counter = flow.get('counter') || 0;
  2. counter += 1;
  3. flow.set('counter', counter);
  4. msg.payload = counter;
  5. return msg;

9. Berikutnya, karena output semua node button sudah terhubung ke node switch, maka putus semua garis dari node button ke node debug, dan sebagai gantinya, hubungkan output node switch ke node debug. Begitu juga hubungkan output dari node function ke node debug, agar nilai flow.counter dapat ditampilkan juga di kotak output debug.

Gambar 5. Agar nilai output node switch dan node function diketahui, hubungkan output kedua node tersebut ke node debug

10. Berikutnya, agar data tombol dari Arduino juga disaring di node switch, maka hubungkan output node serial in ke node switch. Hanya saja, data node serial in ini bertipe string, dengan tambahan akhiran karakter Enter (Carriage Return + New Line), sedangkan node switch mengharapkan data bertipe number. Oleh karena itu, tipe data string output serial in harus diubah menjadi number, dan karakter akhiran harus dihilangkan agar pengubahan dari string ke angka bisa dilakukan. Untuk bisa melakukan pengubahan ini, tambahkan node change. Hubungkan output node serial in ke input node change, dan kemudian hubungkan output node change ke node switch. Kemudian agar data dari serial in bisa berubah menjadi angka, dengan karakter akhiran dihilangkan, klik 2 kali node change, di kolom to the value, pilih tipe J: Expression, dan isi dengan kode: $number($trim(payload)).

Gambar 6. Tambahkan node change untuk mengubah data string output node serial in menjadi angka, agar nilainya dapat diberikan ke input node switch yang mengharapkan nilai angka 

11. Berikutnya, agar nilai counter bisa dimulai dari 0 kembali setelah seluruh proses dijalankan, tambahkan sebuah node change, dan hubungkan input node change ini ke output node button 0. Diinginkan setiap kali button 0 ini ditekan, maka nilai counter, yang disimpan dalam memori context flow.counter, akan menjadi 0. Untuk itu klik 2 kali node change yang baru ini, dan buat kode program seperti berikut:

Gambar 7. Tambahkan node change ke output node button 0, dan atur set flow.counter to the value 0

12. Program Node-RED di atas sudah bisa menghasilkan nilai counter yang akan selalu bertambah setiap kali salah satu button ditekan, atau setiap kali salah satu tombol di Proteus ditekan. Program Node-RED di atas juga sudah bisa menyaring apakah button atau tombol yang ditekan sudah sesuai dengan nilai counter apa tidak, jika sama, maka akan diteruskan ke output node switch, tetapi jika tidak sama, tidak akan diteruskan. Program di atas juga sudah bisa membuat nilai counter direset kembali ke 0 setiap kali penekanan button 0. Setelah program Node-RED di atas bisa berjalan seperti yang dikehendaki, langkah berikutnya adalah memodifikasi program Arduino di Proteus, sehingga ketika tombol pertama sampai dengan tombol kedelapan ditekan, akan menghirimkan angka (dalam bentuk string) berturut-turut: 2, 4, 6, 8, 10, 12, 14 dan 16. Berikut ini kode programnya:
  1. int a0 = 0;
  2. int b0 = 0;
  3. int c0 = 0;
  4. int d0 = 0;
  5. int e0 = 0;
  6. int f0 = 0;
  7. int g0 = 0;
  8. int h0 = 0;
  9. void setup() {
  10.   Serial.begin(9600);
  11.   pinMode(2, INPUT_PULLUP);
  12.   pinMode(3, INPUT_PULLUP);
  13.   pinMode(4, INPUT_PULLUP);
  14.   pinMode(5, INPUT_PULLUP);
  15.   pinMode(6, INPUT_PULLUP);
  16.   pinMode(7, INPUT_PULLUP);
  17.   pinMode(8, INPUT_PULLUP);
  18.   pinMode(9, INPUT_PULLUP);
  19.   pinMode(10, OUTPUT);
  20.   pinMode(11, OUTPUT);
  21.   pinMode(12, OUTPUT);
  22.   pinMode(13, OUTPUT);
  23.   pinMode(14, OUTPUT);  //=A0
  24.   pinMode(15, OUTPUT);  //=A1
  25.   pinMode(16, OUTPUT);  //=A2
  26.   pinMode(17, OUTPUT);  //=A3
  27. }
  28. void loop() {
  29.   int a = digitalRead(2);
  30.   if (a != a0 && a == 0) Serial.println("2");
  31.   a0 = a;
  32.   int b = digitalRead(3);
  33.   if (b != b0 && b == 0) Serial.println("4");
  34.   b0 = b;
  35.   int c = digitalRead(4);
  36.   if (c != c0 && c == 0) Serial.println("6");
  37.   c0 = c;
  38.   int d = digitalRead(5);
  39.   if (d != d0 && d == 0) Serial.println("8");
  40.   d0 = d;
  41.   int e = digitalRead(6);
  42.   if (e != e0 && e == 0) Serial.println("10");
  43.   e0 = e;
  44.   int f = digitalRead(7);
  45.   if (f != f0 && f == 0) Serial.println("12");
  46.   f0 = f;
  47.   int g = digitalRead(8);
  48.   if (g != g0 && g == 0) Serial.println("14");
  49.   g0 = g;
  50.   int h = digitalRead(9);
  51.   if (h != h0 && h == 0) Serial.println("16");
  52.   h0 = h;
  53. }
  54. void serialEvent() {
  55.   while (Serial.available()) {
  56.     int data = Serial.parseInt();
  57.     if (Serial.read() == char(13)) {
  58.       switch (data) {
  59.         case 1:
  60.           mati();
  61.           digitalWrite(10, HIGH);
  62.           break;
  63.         case 3:
  64.           mati();
  65.           digitalWrite(11, HIGH);
  66.           break;
  67.         case 5:
  68.           mati();
  69.           digitalWrite(12, HIGH);
  70.           break;
  71.         case 7:
  72.           mati();
  73.           digitalWrite(13, HIGH);
  74.           break;
  75.         case 9:
  76.           mati();
  77.           digitalWrite(14, HIGH);
  78.           break;
  79.         case 11:
  80.           mati();
  81.           digitalWrite(15, HIGH);
  82.           break;
  83.         case 13:
  84.           mati();
  85.           digitalWrite(16, HIGH);
  86.           break;
  87.         case 15:
  88.           mati();
  89.           digitalWrite(17, HIGH);
  90.           break;
  91.         default:
  92.           mati();
  93.           break;
  94.       }
  95.     }
  96.   }
  97. }
  98. void mati() {
  99.   digitalWrite(10, LOW);
  100.   digitalWrite(11, LOW);
  101.   digitalWrite(12, LOW);
  102.   digitalWrite(13, LOW);
  103.   digitalWrite(14, LOW);
  104.   digitalWrite(15, LOW);
  105.   digitalWrite(16, LOW);
  106.   digitalWrite(17, LOW);
  107. }
File program Arduino di atas dapat diunduh di link ini: 

13. Berikut ini tampilan program Node-RED dengan rangkaian Arduino di Proteus, yang dapat melakukan proses kerja secara berurutan, yang disimulasikan dalam bentuk nyala dari kedelapan buah LED secara bergantian, berurutan dari atas ke bawah, dan hanya bisa dibuat demikian, apabila button dan tombol ditekan secara berurutan.

Gambar 8. Tampilan program Node-RED dan rangkaian Arduino di Proteus hanya bisa berjalan (menyalakan LED secara bergantian) apabila button dan tombol ditekan secara berurutan

14. Berikutnya dengan menggabungkan tampilan program Node-RED di Gambar 8 di atas dengan tampilan program Dashboard Node-RED di bagian ke-4, akan dihasilkan visualisasi proses kerja yang selalu berurutan dan yang hanya bisa berjalan apabila proses sebelumnya telah selesai.

15. Agar lebih jelas, berikut ini video langkah-langkah pembuatan di atas.


Video pembuatan interaksi kontrol dan respon alat




No comments:

Post a Comment

Subscribe to: Posts (Atom)