3.Modbus Slave RTU

Setelah di bagian ke-2 diuraikan mengenai pembuatan Modbus Master RTU dengan LabVIEW, maka di bagian ke-3 ini, akan diuraikan mengenai pembuatan Modbus Slave RTU dengan Arduino. Arduino dipilih karena banyak sekali kemudahan yang dapat kita peroleh, salah satunya adalah tersedianya banyak library, termasuk library untuk pembuatan Modbus Slave ini, yang membuat pemrograman menjadi sangat sederhana. 

Dari sekian banyak library Arduino untuk Modbus Slave, saya memilih library di link ini: 

Alasan penggunaan library di atas adalah karena cukup komplit, tidak hanya untuk membuat Modbus RTU, tetapi juga bisa untuk membuat Modbus TCP, baik sebagai Master maupun Slave, dan bisa juga diterapkan untuk hardware ESP8266 (NodeMCU) dan ESP32, tidak hanya Arduino.

Di bagian ke-3 ini, pembahasan dibagi menjadi 3 topik, yaitu:
1. Pembuatan Modbus Slave RTU dengan Arduino dan Proteus.
2. Penggunaan Outseal sebagai alternatif.
3. Penyambungan RS-485 untuk 2 Modbus Slave RTU di Proteus.

Berikut ini langkah-langkah pembuatan untuk masing-masing topik di atas:

1. PEMBUATAN MODBUS SLAVE RTU DENGAN ARDUINO DAN PROTEUS

Dari pembuatan Modbus Master RTU di bagian ke-2, diketahui simulator Modbus Slave  menggunakan 16 buah memori Coil dan sebuah memori Holding Register. Keenambelas buah memori Coil tersebut dibuat untuk menampung data Tag dari 8 buah Sensor (S1 - S8) dan 8 buah Aktuator (A1 - A8).  Sedangkan sebuah memori Holding Register digunakan untuk menampung data Tag Keadaan. 

Di bagian ke-3 ini, simulator Modbus Slave tersebut akan diganti dengan rangkaian Arduino. Software Proteus digunakan di sini untuk mensimulasikan rangkaian Arduino tersebut. Saya memilih software Proteus karena menampilkan simulasi yang sangat baik, bahkan untuk rangkaian yang cukup kompleks, yang melibatkan mikrokontroler seperti Arduino. Untuk rangkaian Arduino di sini, kedelapan buah Sensor direpresentasikan dalam bentuk 8 buah Tombol, sedangkan kedelapan buah Aktuator direpresentasikan dalam bentuk 8 buah LED, dan untuk Tag Keadaan, direpresentasikan dalam bentuk sebuah 7-segmen. Berikut ini contoh rangkaian Arduino yang dapat dibuat:

Gambar 1. Rangkaian Arduino dengan 8 buah sensor (tombol S1 - S8), 8 buah aktuator (LED D1 - D8), sebuah keadaan (7-segmen) dan 2 buah Motor DC

File Proteus untuk gambar skematik di atas dapat diunduh di link ini: 

Pada gambar skematik di atas, di samping 8 buah tombol, 8 buah LED dan sebuah 7-segmen, ditambahkan pula 2 buah motor DC untuk mensimulasikan motor Konveyor K1 dan K2. Di sini Arduino disimulasikan dengan ATmega328P, karena ATmega328P ini merupakan mikrokontroler yang terpasang pada Arduino Uno dan juga Arduino Nano. Tabel berikut menunjukkan sambungan I/O Arduino berikut dengan keterangan komponennya. 

Tabel 1. Sambungan I/O Arduino dengan komponen-komponennya

Klik 2 kali komponen COMPIM untuk mengatur port COM yang digunakan dan mengisi nilai Baud Rate komunikasi. Pada jendela Edit Component COMPIM, isi port COM dengan port COM pasangan, dalam contoh di sini diisi dengan COM14. Tulisan COM14 ini diisikan dengan mengetikkan tulisan COM diikuti angka (di pilihan drop down hanya disediakan COM 1 - COM4, untuk angka COM yang lebih besar, harus diketik dan diakhiri Enter). Untuk Baud Rate, isi dengan nilai 9600, baik untuk Physical Baud Rate maupun Virtual Baud Rate. 

Gambar 2. Edit Component COMPIM, isi dengan pasangan COM dan Baud Rate = 9600

Berikutnya, komponen kedua yang harus diatur isinya adalah ATmega328P. Klik 2 kali ATmega328P, hingga muncul jendela Edit Component seperti berikut. Ada 4 kolom yang harus diatur isinya, seperti terlihat pada gambar berikut ini. Kolom yang harus diatur ditandai dengan kotak kuning, yaitu kolom Program File, kolom CLKDIV8, kolom CKSEL Fuses dan kolom Clock Frequency. 

Gambar 3. Edit Component ATmega328P (Arduino)

Berturut-turut isi dari keempat kolom di atas adalah sebagai berikut:
  • Program File = lokasi file Hex hasil kompilasi program Arduino. 
  • CLKDIV8 = (1) Unprogrammed. 
  • CKSEL Fuses = (0000) Ext Clock.
  • Clock Frequency = 16MHz
Lokasi file Hex hasil kompilasi program Arduino dapat diperoleh dari software IDE Arduino. Lokasi file Hex ini dapat di-copy di bagian Output yang berada di bagian bawah, yang dimunculkan dengan mengatur Preferences di menu File, khususnya di baris "Show verbose output during", beri centang pada pilihan compile. Maka ketika kompilasi dilakukan (dengan menekan tombol centang atau verify), lokasi file Hex akan muncul di bagian bawah, seperti terlihat pada Gambar 5.

 Gambar 4. Beri centang pada compile, di Show verbose output during, di Preferences

Gambar 5. Lokasi file Hex muncul di bagian output, dengan tulisan "C:\\Users\\.../...ino.hex"

Copy keseluruhan direktori lokasi file Hex, yang diapit tanda petik dua, mulai dari C hingga diakhiri tulisan ino.hex, dan tempelkan di kolom Program File pada jendela Edit Component ATmega328P (tanda petik dua tidak ikut di-copy). Namun sebelum bisa melakukan kompilasi, tentu saja program Arduinonya harus sudah ada. Berikut ini program Arduino untuk Modbus Slave RTU, dengan 16 buah Tag Coil dan sebuah Tag Holding Register, untuk membaca kondisi 8 buah Tombol, dan menulis/mengontrol kondisi 8 buah LED, sebuah 7-segmen dan 2 buah Motor DC.

  1. #include <ModbusRTU.h>
  2. #define S1 0      // Alamat COIL 00001
  3. #define S2 1      // Alamat COIL 00002
  4. #define S3 2      // Alamat COIL 00003
  5. #define S4 3      // Alamat COIL 00004
  6. #define S5 4      // Alamat COIL 00005
  7. #define S6 5      // Alamat COIL 00006
  8. #define S7 6      // Alamat COIL 00007
  9. #define S8 7      // Alamat COIL 00008
  10. #define LED1 8    // Alamat COIL 00009
  11. #define LED2 9    // Alamat COIL 00010
  12. #define LED3 10   // Alamat COIL 00011
  13. #define LED4 11   // Alamat COIL 00012
  14. #define LED5 12   // Alamat COIL 00013
  15. #define LED6 13   // Alamat COIL 00014
  16. #define LED7 14   // Alamat COIL 00015
  17. #define LED8 15   // Alamat COIL 00016
  18. #define Proses 0  // Alamat HOLDINGREG 40001
  19. #define SLAVE_ID 1
  20. unsigned long skr = 0;
  21. ModbusRTU mb;
  22. void setup() {
  23.   Serial.begin(9600);
  24.   mb.begin(&Serial);
  25.   mb.setBaudrate(9600);
  26.   mb.slave(SLAVE_ID);
  27.   pinMode(2, OUTPUT);   //LED1
  28.   pinMode(3, OUTPUT);   //LED2
  29.   pinMode(4, OUTPUT);   //LED3
  30.   pinMode(5, OUTPUT);   //LED4
  31.   pinMode(6, OUTPUT);   //Motor1
  32.   pinMode(7, OUTPUT);   //Motor2
  33.   pinMode(8, OUTPUT);   //LED5
  34.   pinMode(9, OUTPUT);   //LED6
  35.   pinMode(10, OUTPUT);  //LED7
  36.   pinMode(11, OUTPUT);  //LED8
  37.   pinMode(12, OUTPUT);  //7-segmen bit0
  38.   pinMode(13, OUTPUT);  //7-segmen bit1
  39.   pinMode(14, OUTPUT);  //7-segmen bit2 (A0)
  40.   pinMode(15, OUTPUT);  //7-segmen bit3 (A1)
  41.   mb.addCoil(S1);
  42.   mb.addCoil(S2);
  43.   mb.addCoil(S3);
  44.   mb.addCoil(S4);
  45.   mb.addCoil(S5);
  46.   mb.addCoil(S6);
  47.   mb.addCoil(S7);
  48.   mb.addCoil(S8);
  49.   mb.addCoil(LED1);
  50.   mb.addCoil(LED2);
  51.   mb.addCoil(LED3);
  52.   mb.addCoil(LED4);
  53.   mb.addCoil(LED5);
  54.   mb.addCoil(LED6);
  55.   mb.addCoil(LED7);
  56.   mb.addCoil(LED8);
  57.   mb.addHreg(Proses);
  58.   skr = millis();
  59. }
  60. void loop() {
  61.   mb.task();
  62.   yield();
  63.   if (millis() - skr > 100) {
  64.     skr = millis();
  65.     int a = analogRead(A2);
  66.     if (a >= 850) mb.Coil(S1, 1);
  67.     else if (a >= 700 && a < 850) mb.Coil(S2, 1);
  68.     else if (a >= 600 && a < 700) mb.Coil(S3, 1);
  69.     else if (a >= 500 && a < 600) mb.Coil(S4, 1);
  70.     else if (a >= 400 && a < 500) mb.Coil(S5, 1);
  71.     else if (a >= 300 && a < 400) mb.Coil(S6, 1);
  72.     else if (a >= 200 && a < 300) mb.Coil(S7, 1);
  73.     else if (a >= 100 && a < 200) mb.Coil(S8, 1);
  74.     else {
  75.       mb.Coil(S1, 0);
  76.       mb.Coil(S2, 0);
  77.       mb.Coil(S3, 0);
  78.       mb.Coil(S4, 0);
  79.       mb.Coil(S5, 0);
  80.       mb.Coil(S6, 0);
  81.       mb.Coil(S7, 0);
  82.       mb.Coil(S8, 0);
  83.     }
  84.     digitalWrite(2, mb.Coil(LED1));
  85.     digitalWrite(6, mb.Coil(LED1));  //Motor1
  86.     digitalWrite(3, mb.Coil(LED2));
  87.     digitalWrite(4, mb.Coil(LED3));
  88.     digitalWrite(5, mb.Coil(LED4));
  89.     digitalWrite(8, mb.Coil(LED5));
  90.     digitalWrite(9, mb.Coil(LED6));
  91.     digitalWrite(10, mb.Coil(LED7));
  92.     digitalWrite(7, mb.Coil(LED7));  //Motor2
  93.     digitalWrite(11, mb.Coil(LED8));
  94.     digitalWrite(12, bitRead(mb.Hreg(Proses), 0));
  95.     digitalWrite(13, bitRead(mb.Hreg(Proses), 1));
  96.     digitalWrite(14, bitRead(mb.Hreg(Proses), 2));
  97.     digitalWrite(15, bitRead(mb.Hreg(Proses), 3));
  98.   }
  99. }

Program Arduino di atas dapat diunduh di link ini:

Program di atas memerlukan library modbus-esp8266 yang bisa diunduh di link ini: 

Tambahkan library modbus-esp8266 tersebut ke software IDE Arduino, dengan cara memilih menu Sketch di Arduino, pilih Include Library, pilih Add.ZIP Library, dan arahkan pencarian ke lokasi file library yang sudah diunduh di atas.

Setelah library terpasang, sebelum melakukan kompilasi, pilih Board = Arduino Uno (bisa juga Arduino Nano). Setelah memilih Board, tekan tombol centang (verify) untuk melakukan kompilasi. Tunggu hingga muncul pesan Done Compiling, maka seharusnya akan muncul lokasi file Hex di bagian Output.

Setelah keempat kolom di komponen ATmega328 selesai diisi, tutup jendela Edit Component, dan jalankan Proteus bersama dengan NI OPC Server dan program LabVIEW sebagai Modbus Master RTU yang telah dibuat di bagian ke-2. Sebelum menjalankan program LabVIEW, pastikan kualitas koneksi Modbus di jendela Quick Client bernilai Good. Berikut ini tampilan program LabVIEW sebagai Modbus Master RTU, Quick Client sebagai penghubung, dan rangkaian Arduino di Proteus sebagai Modbus Slave RTU.
 
Gambar 6. Tampilan program LabVIEW sebagai Modbus Master RTU, NI OPC Server sebagai penghubung, dan rangkaian Arduino di Proteus sebagai Modbus Slave RTU

Rangkaian Arduino di atas dapat diganti sesuai dengan keperluan. Ide rangkaian pembagi tegangan untuk 8 buah tombol diterapkan apabila rekan-rekan ingin menghemat penggunaan kaki I/O Arduino, hanya saja penerapannya ke hardware dirasa kurang praktis (karena memerlukan tambahan banyak resistor). Untuk itu, berikut ini alternatif rangkaian Arduino yang lebih praktis, hanya saja, karena memanfaatkan kaki A6 dan A7, rangkaian ini hanya bisa menggunakan Arduino Nano, sedangkan Arduino Uno tidak bisa digunakan.

Gambar 7. Alternatif rangkaian Arduino (Arduino Nano saja) dengan 8 buah sensor (tombol S1 - S8), 8 buah aktuator (LED D1 - D8), sebuah keadaan (7-segmen) dan 2 buah Motor DC

File Proteus untuk rangkaian Gambar 7 di atas dapat diunduh di link ini: 

Terlihat pada rangkaian Gambar 7 di atas, 6 buah tombol (S1 - S6) tidak memerlukan resistor, dan langsung dihubungkan ke Ground, karena kaki I/O yang terhubung ke tombol tersebut (A0 - A5) dilengkapi dengan resistor internal yang bisa diaktifkan dalam program, kecuali untuk kaki A6 dan A7, yang hanya ada di Arduino Nano, tidak memiliki resistor internal, dan hanya bisa digunakan untuk membaca input analog saja.

Berikut ini program Arduino Nano untuk rangkaian alternatif di atas:

  1. #include <ModbusRTU.h>
  2. #define S1 0      // Alamat COIL 00001
  3. #define S2 1      // Alamat COIL 00002
  4. #define S3 2      // Alamat COIL 00003
  5. #define S4 3      // Alamat COIL 00004
  6. #define S5 4      // Alamat COIL 00005
  7. #define S6 5      // Alamat COIL 00006
  8. #define S7 6      // Alamat COIL 00007
  9. #define S8 7      // Alamat COIL 00008
  10. #define LED1 8    // Alamat COIL 00009
  11. #define LED2 9    // Alamat COIL 00010
  12. #define LED3 10   // Alamat COIL 00011
  13. #define LED4 11   // Alamat COIL 00012
  14. #define LED5 12   // Alamat COIL 00013
  15. #define LED6 13   // Alamat COIL 00014
  16. #define LED7 14   // Alamat COIL 00015
  17. #define LED8 15   // Alamat COIL 00016
  18. #define Proses 0  // Alamat HOLDINGREG 40001
  19. #define SLAVE_ID 1
  20. unsigned long skr = 0;
  21. ModbusRTU mb;
  22. void setup() {
  23.   Serial.begin(9600);
  24.   mb.begin(&Serial);
  25.   mb.setBaudrate(9600);
  26.   mb.slave(SLAVE_ID);
  27.   pinMode(2, OUTPUT);         //LED1 dan Motor1
  28.   pinMode(3, OUTPUT);         //LED2
  29.   pinMode(4, OUTPUT);         //LED3
  30.   pinMode(5, OUTPUT);         //LED4
  31.   pinMode(6, OUTPUT);         //LED5
  32.   pinMode(7, OUTPUT);         //LED6
  33.   pinMode(8, OUTPUT);         //LED7 dan Motor2
  34.   pinMode(9, OUTPUT);         //LED8
  35.   pinMode(10, OUTPUT);        //7-segmen A
  36.   pinMode(11, OUTPUT);        //7-segmen B
  37.   pinMode(12, OUTPUT);        //7-segmen C
  38.   pinMode(13, OUTPUT);        //7-segmen D
  39.   pinMode(14, INPUT_PULLUP);  //Tombol S1
  40.   pinMode(15, INPUT_PULLUP);  //Tombol S2
  41.   pinMode(16, INPUT_PULLUP);  //Tombol S3
  42.   pinMode(17, INPUT_PULLUP);  //Tombol S4
  43.   pinMode(18, INPUT_PULLUP);  //Tombol S5
  44.   pinMode(19, INPUT_PULLUP);  //Tombol S6
  45.   mb.addCoil(S1);
  46.   mb.addCoil(S2);
  47.   mb.addCoil(S3);
  48.   mb.addCoil(S4);
  49.   mb.addCoil(S5);
  50.   mb.addCoil(S6);
  51.   mb.addCoil(S7);
  52.   mb.addCoil(S8);
  53.   mb.addCoil(LED1);
  54.   mb.addCoil(LED2);
  55.   mb.addCoil(LED3);
  56.   mb.addCoil(LED4);
  57.   mb.addCoil(LED5);
  58.   mb.addCoil(LED6);
  59.   mb.addCoil(LED7);
  60.   mb.addCoil(LED8);
  61.   mb.addHreg(Proses);
  62.   skr = millis();
  63. }
  64. void loop() {
  65.   mb.task();
  66.   yield();
  67.   if (millis() - skr > 100) {
  68.     skr = millis();
  69.     mb.Coil(S1, !digitalRead(14));
  70.     mb.Coil(S2, !digitalRead(15));
  71.     mb.Coil(S3, !digitalRead(16));
  72.     mb.Coil(S4, !digitalRead(17));
  73.     mb.Coil(S5, !digitalRead(18));
  74.     mb.Coil(S6, !digitalRead(19));
  75.     if (analogRead(A6) > 500) mb.Coil(S7, 1);
  76.     else mb.Coil(S7, 0);
  77.     if (analogRead(A7) > 500) mb.Coil(S8, 1);
  78.     else mb.Coil(S8, 0);
  79.     digitalWrite(2, mb.Coil(LED1));  //LED1 & Motor1
  80.     digitalWrite(3, mb.Coil(LED2));
  81.     digitalWrite(4, mb.Coil(LED3));
  82.     digitalWrite(5, mb.Coil(LED4));
  83.     digitalWrite(6, mb.Coil(LED5));
  84.     digitalWrite(7, mb.Coil(LED6));
  85.     digitalWrite(8, mb.Coil(LED7));  //LED7 & Motor2
  86.     digitalWrite(9, mb.Coil(LED8));
  87.     digitalWrite(10, bitRead(mb.Hreg(Proses), 0));
  88.     digitalWrite(11, bitRead(mb.Hreg(Proses), 1));
  89.     digitalWrite(12, bitRead(mb.Hreg(Proses), 2));
  90.     digitalWrite(13, bitRead(mb.Hreg(Proses), 3));
  91.   }
  92. }

Keterangan program: 
1. Karena A6 dan A7 adalah pin khusus yang hanya bisa membaca input analog, maka di baris ke-75 dan 77, ditambahkan pembandingan nilai hasil pembacaan dengan batas 500. Apabila tombol di A6 atau A7 ditekan, akan menghasilkan nilai output 1023, sedangkan apabila tidak ditekan, akan menghasilkan nilai output 0. Dengan membandingkan nilai yang dibaca tersebut dengan angka 500, akan diketahui apabila nilai output lebih dari 500, berarti tombol ditekan, sedangkan bila kurang dari 500 berarti tombol tidak ditekan. Apabila tombol di A6 ditekan, maka Coil S7 akan bernilai 1, sedangkan bila tidak ditekan akan bernilai 0. Begitu pula untuk tombol di A7, bila ditekan maka Coil S8 akan bernilai 1, bila tidak ditekan akan bernilai 0. 
2. Untuk membuat resistor internal di kaki A0 - A5 aktif, di baris ke-39 hingga 44, instruksi penugasan pinMode diberi INPUT_PULLUP. Kemudian karena rangkaian tombol bersifat Aktif Low, yang bila ditekan malah menghasilkan output Low atau 0, maka perlu dibalik nilainya dengan menambahkan tanda seru pada instruksi pembacaan input, seperti terlihat pada program di baris ke 69 - 74.

Program Arduino Nano untuk rangkaian alternatif di atas dapat diunduh di link ini:

Sebelum melakukan kompilasi, pastikan Board yang dipilih adalah Arduino Nano. Lakukan kompilasi program Arduino. Isi Program File dengan lokasi file Hex hasil kompilasi. Kemudian jalankan Proteus. Berikut ini tampilan program LabVIEW sebagai Modbus Master RTU, Quick Client sebagai penghubung, dan alternatif rangkaian Arduino Nano di Proteus sebagai Modbus Slave RTU.

 
Gambar 8. Tampilan program LabVIEW sebagai Modbus Master RTU, NI OPC Server sebagai penghubung, dan alternatif rangkaian Arduino Nano di Proteus sebagai Modbus Slave RTU


2. PENGGUNAAN OUTSEAL SEBAGAI ALTERNATIF

Sebuah produk karya anak bangsa, yang bagus dan menarik untuk dipelajari, yang diberi nama Outseal, menjadi pilihan alternatif untuk Modbus Slave di sini. Hal menariknya adalah, pemrograman untuk komunikasi Modbus sangat mudah dan sederhana. Rekan-rekan dapat mendownload software Outseal di link ini: https://www.outseal.com/site/download/download.html 

Tersedia pula buku Panduan Dasar Outseal yang dapat didownload di link tersebut. Lalu bagaimana kemudahannya (pemrograman komunikasi Modbus) di Outseal? Kemudahannya terletak pada sudah disediakannya kaki I/O dan memori internal yang terhubung dengan alamat Modbus. Di buku Panduan tersebut, di halaman 110, diberikan peta alamat Modbus di Outseal PLC seperti berikut:

Tabel 2. Peta Alamat Modbus di Outseal PLC

Keterangan memori:
  • Memori dengan huruf awal R terhubung dengan kaki Output Digital. 
  • Memori dengan huruf awal S terhubung dengan kaki Input Digital. 
  • Memori dengan huruf awal A terhubung dengan kaki Input Analog. 
  • Memori dengan huruf awal B merupakan memori internal beukuran 1 bit (Diskrit).
  • Memori dengan huruf awal I merupakan memori internal berukuran 16 bit (Analog).

Di rangkaian Outseal PLC Nano, kaki Input Output sudah dibuat tetap, dengan kaki Input sebanyak 8 buah (S.1 - S.8), dan kaki Output juga sebanyak 8 buah (R.1 - R.8), dengan penempatan kaki Input Output seperti terlihat pada gambar berikut:
Gambar 9. Outseal dari Arduino Nano dengan penempatan kaki input dan output dibuat tetap

Menyesuaikan dengan kebutuhan program Tampilan LabVIEW yang memerlukan 8 buah input tombol dan 8 buah output LED Aktuator, maka agar 8 buah LED di Outseal Nano dapat menyala mengikuti nyala 8 buah LED di Tampilan LabVIEW, dan juga 8 buah tombol di rangkaian Outseal Nano dapat mengontrol atau memicu peralihan keadaan pada Tampilan LabVIEW, maka dapat dibuat program Outseal Nano seperti berikut:

Gambar 10. Program Outseal untuk membaca kondisi 8 tombol dan mengontrol 8 LED

Keterangan program:
Untuk bisa mengakses data Modbus pada kaki input dan output Outseal, kaki input dan output tersebut harus dimasukkan ke dalam program, seperti terlihat pada program di atas, baris pertama hingga ke-8 adalah program untuk mengakses (membaca) kaki input S.1 - S.8, dan baris ke-9 sampai ke-16 adalah program untuk mengakses (mengontrol) kaki output R.1 - R.8. Karena data Modbus dengan huruf awal S dan R tidak dapat ditulis, hanya bisa dibaca, maka agar LabVIEW yang menjadi Modbus Master bisa mengontrol/menulis data Modbus di Outseal, dalam program di atas, digunakan memori internal dengan huruf awal B (B.1 - B.16) sebagai penghubung Modbus Master ke kaki input (S.1 - S.8) dan ke kaki output (R.1 - R.8).

Program Outseal di atas dapat diunduh di link ini: 

Setelah program Outseal di atas selesai dibuat, langkah berikutnya adalah melakukan kompilasi. Kompilasi dilakukan dengan menekan tombol Test (bergambar centang). Namun sebelum menekan tombol Test, lakukan pengaturan pada Settings, untuk memilih jenis hardware Outseal (pilih Nano V5), saluran port COM, baudrate (isi = 9600) dan alamat Modbus Slave (isi = 1), seperti ditunjukkan pada Gambar 9 di atas. Setelah Settings diatur, berikutnya tekan tombol Test, apabila muncul pesan Tidak terdapat kesalahan, maka kompilasi telah berhasil dilakukan. File Hex hasil kompilasi pada program Outseal ini selalu berada pada lokasi yang selalu sama, dengan nama file Hasil.hex. 

Lokasi file Hasil.hex ini di: C:\Users\nama_user\AppData\Local\Temp\Outseal\Hasil.hex , 
dengan nama_user sesuai nama user di komputer.

Setelah pembuatan program Outseal selesai, maka langkah berikutnya adalah membuat rangkaian Modbus Slave Outseal. Gambar berikut menunjukkan rangkaian Modbus Slave Outseal Nano dengan 8 input tombol dan 8 output LED serta 2 buah Motor DC.

Gambar 11. Rangkaian Modbus Slave RTU Outseal Nano, dengan 8 input tombol dan 8 output LED

File Proteus untuk rangkaian Gambar 11 di atas dapat diunduh di link ini: 

Sebelum menjalankan simulasi Proteus, pastikan kolom Program File di komponen ATmega328P diisi dengan lokasi file hasil kompilasi program Outseal. Klik 2 kali pada komponen ATmega328P hingga muncul jendela Edit Component, dan isi seperti gambar berikut:

Gambar 12. Isi kolom Program File dengan lokasi file Hasil.hex, hasil kompilasi software Outseal

Setelah pembuatan rangkaian Modbus Slave RTU dengan Outseal Nano selesai, maka langkah berikutnya adalah menyesuaikan alamat Tag Modbus di NI OPC Server, agar sesuai dengan memori Modbus yang digunakan di Outseal Nano. Karena menggunakan memori internal B.1 hingga B.16, maka untuk Tag S1 - S8 diubah alamatnya dari 000001 - 000008 menjadi 000129 - 000136. Begitu pula untuk Tag A1 - A8, diubah alamatnya dari 000009 - 000016 menjadi 000137 - 000144, seperti terlihat pada gambar berikut.

Gambar 13. Alamat ke-16 Tag Modbus diubah dari 000001 - 000016 menjadi 000129 - 000144

Setelah alamat Tag Modbus diubah, berikutnya tekan tombol Quick Client untuk melihat kualitas koneksi Modbus. Pastikan kualitas koneksinya bernilai Good. Apabila bernilai Bad, pastikan waktu runtime belum habis, dan jalankan simulasi Proteus. Apabila keduanya sudah terpenuhi, seharusnya nilai kualitas koneksi berubah menjadi Good. Apabila tombol Quick Client tidak dapat ditekan (dalam kondisi disabled), pilih menu Runtime, dan pilih Connect. Setelah bernilai Good, jalankan program Tampilan LabVIEW, dan lakukan penekanan kedelapan tombol di rangkaian Outseal Nano di Proteus secara berurutan, dan perhatikan Tampilan LabVIEW dan LED indikatornya, baik di LabVIEW dan juga di Proteus. 

Gambar berikut menunjukkan komunikasi Modbus antara program Tampilan LabVIEW sebagai Modbus Master RTU, Quick Client sebagai penghubung, dan rangkaian Outseal Nano di Proteus sebagai Modbus Slave RTU.

Gambar 14. Komunikasi Modbus RTU antara program Tampilan LabVIEW dengan Outseal Nano


3. PENYAMBUNGAN RS-485 UNTUK 2 MODBUS SLAVE RTU DI PROTEUS

Pada rangkaian Outseal Nano di atas, masih ada Tag Modbus yang belum ditampilkan datanya, yaitu Tag Keadaan, yang seharusnya ditampilkan dalam bentuk 7-segmen. Berhubung Outseal Nano hanya memiliki 8 output yang sudah terpakai semua, maka agar Tag keadaan bisa ditampilkan di 7-segmen, dibutuhkan tambahan Outseal Nano. Keistimewaan dari komunikasi Modbus adalah kemampuannya untuk berkomunikasi lebih dari 2 alat. Pada Modbus RTU dengan sambungan RS485, dimungkinkan penyambungan hingga 32 alat. Berikut ini gambar skematik dari rangkaian 2 buah Outseal Nano dengan sambungan RS485, untuk membaca 8 buah input tombol, dan mengontrol 8 buah output LED, 2 buah Motor DC dan sebuah 7 segmen. 

Gambar 15. Rangkaian 2 buah Modbus Slave RTU Outseal Nano dengan sambungan RS485, untuk membaca 8 buah tombol dan mengontrol 8 buah LED, 2 buah Motor DC, dan sebuah 7-segmen

File Proteus untuk rangkaian Gambar 15 di atas dapat diunduh di link ini: 

CATATAN PENTING:
Seringkali saya tidak menyadari bahwa penamaan di rangkaian Proteus sangat menentukan. Di rangkaian Outseal Slave2, saya tidak sadar memberi nama yang sama dengan nama kaki di Outseal Slave1, sehingga hasil simulasi menjadi aneh. Untuk itu, agar pengalaman saya ini tidak terulang pada rekan-rekan, pastikan untuk memeriksa pemberian nama, karena secara otomatis semua yang nama kakinya sama akan dihubungkan. Untuk itu, di Outseal Slave2 saya memberi nama kaki output dengan menambahkan titik di tengah-tengah, yaitu menjadi R.8, R.3, R.2 dan R.1, agar kaki-kaki ini tidak terhubung dengan kaki output di Outseal Slave1.

Program Outseal Nano untuk Slave1 adalah sama seperti Gambar 10, sedangkan program Outseal Nano untuk Slave2 adalah seperti berikut ini:

Gambar 16. Program Outseal untuk mengontrol 7-segmen sesuai dengan nilai Tag Keadaaan

Keterangan program: 
1. Karena Tag Keadaan ditempatkan di Holding Register di alamat 400001, maka data Tag Keadaan tersebut akan berada di memori internal I.1 Outseal Nano.
2. Memori internal I.1 ini berisi data angka desimal 0 - 8. Program pada Gambar 16 di atas akan mengubah angka desimal I.1 tersebut menjadi angka biner 4 digit di R3, R8, R7 dan R6. 
3. Output biner 4 digit di R3, R8, R7 dan R6 ini kemudian diubah menjadi tampilan angka di 7-segmen dengan bantuan dekoder IC 4511.

Program Outseal Nano Slave2 di atas dapat diunduh di link ini: 

Buat atau buka program Outseal Nano Slave2 tersebut. Sebelum menekan tombol Test untuk kompilasi, terlebih dahulu lakukan 2 hal berikut ini:
1. Pindahkan file Hasil.hex dari hasil kompilasi program Outseal Nano Slave1 ke lokasi folder yang sama dengan file Proteus yang berisi rangkaian Gambar 15. Ubah nama file Hasil.hex tersebut dengan nama bebas, misal HasilSlave1.hex. 

Catatan: File Hasil.hex yang ada di lokasi default, harus dipindah, karena kalau tidak dipindah, akan tertimpa dengan file hasil kompilasi yang terbaru. Pemindahan file sebaiknya ditempatkan di folder yang sama dengan file Proteus agar di kolom Program File tidak lagi perlu menuliskan direktori lokasi file, tetapi cukup namanya saja seperti gambar berikut:

Gambar 17. File hasil kompilasi Outseal cukup ditulis namanya saja di kolom Program File, asal file tersebut ditempatkan di folder yang sama dengan file Proteus ini ditempatkan

2. Berikutnya, sebelum melakukan kompilasi untuk Outseal Nano Slave2, atur Settings Hardware pada pilihan Nano V5, Baudrate = 9600, dan alamat Modbus Slave = 2, seperti gambar berikut:

Gambar 18. Atur di Settings: Hardware = Nano V5, Baudrate = 9600, Alamat Modbus = 2

Setelah Settings diatur seperti Gambar 18 di atas, lakukan kompilasi dengan menekan tombol Test, apabila muncul pesan Tidak terdapat kesalahan, maka kompilasi telah berhasil dilakukan. 

Berikutnya pindahkan file kompilasi Hasil.hex yang baru ke lokasi yang sama dengan file  HasilSlave1.hex, yaitu di lokasi file Proteus yang berisi rangkaian Gambar 15. Setelah dipindahkan, ubah nama file Hasil.hex yang baru menjadi HasilSlave2.hex. Isikan nama HasilSlave2.hex di kolom Program File komponen ATmega328P yang kedua.

Setelah rangkaian 2 buah Outseal Nano di Proteus selesai dibuat, berikutnya adalah mengatur Device di NI OPC Server. Karena ada 2 Device Modbus, maka tambahkan Device dengan meng-klik kanan pada Channel1 di NI OPC Server, pilih New Device. Biarkan namanya tetap Device2, klik Next, hingga di isian Device ID, ganti angka 1 dengan angka 2. Device ID ini sama seperti alamat Modbus. Karena pada program Outseal Nano yang kedua dibuat alamat Modbusnya = 2, maka di Device ID untuk Device2 ini juga diisi dengan angka 2.

Gambar 19. Untuk Device2, isi Device ID = 2 (alamat Modbus)

Berikutnya, karena Device2 digunakan untuk menampilkan data Tag Keadaan, maka hapus Tag Keadaan yang ada di Device1, dan pindahkan Tag Keadaan ke Device2.

Gambar 20. Hapus Tag Keadaan di Device1, gunakan Cut agar bisa ditempel di Device2

Gambar 21. Di Device2, tempelkan (Paste) Tag Keadaan

Setelah pengaturan Device dan Tag di NI OPC Server selesai, berikutnya perbaharui variabel Tag Keadaan di kotak Project. Hapus atau remove dulu Tag Keadaan dengan meng-klik kanan Tag, pilih Remove From Library. 

Gambar 22. Variabel Tag Keadaan di kotak Project dihapus

Kemudian klik kanan pada objek OPC1, pilih Create Bound Variables.

Gambar 23. Klik kanan OPC1, pilih Crate Bound Variables

Berikutnya, di jendela Create Bound Variables, buka Channel1 Device2, pilih Tag Keadaan, tekan tombol Add untuk menambahkan ke variable kotak Project. Klik OK.

Gambar 24. Buka Channel1 Device 2, pilih Tag Keadaan, tekan tombol Add, klik OK

Muncul jendela Multiple Variable Editor. Klik Done, maka Tag Keadaan dari Device2 akan muncul di kotak Project. Tarik atau drag Tag Keadaan yang baru ini menggantikan Tag Keadaan lama yang ada di Block Diagram.

Gambar 25. Hapus Tag Keadaan lama yang di Block Diagram, kemudian tarik atau drag Tag Keadaan yang baru ke Block Diagram

Gambar 26. Ubah Access Mode Tag Keadaan dari Read menjadi Write, dan hubungkan kaki inputnya ke garis data yang terhubung dengan input icon Tahap

Terakhir, jalankan simulasi Proteus rangkaian 2 buah Outseal Nano. Tekan tombol Quick Client untuk memeriksa kualitas koneksi Tag Modbus pada Device1 dan Device2. Setelah kualitas koneksi semua Tag bernilai Good, maka berikutnya jalankan program LabVIEW. Seharusnya Tampilan LabVIEW akan dapat dijalankan, baik dari tombol di program LabVIEW, maupun dari tombol di rangkaian Outseal di Proteus. Kemudian 8 buah LED di rangkaian Outseal, beserta 2 buah Motor DC dan tampilan angka 7-segmen, akan mengikuti tampilan di program LabVIEW.

Gambar berikut menunjukkan komunikasi Modbus antara program Tampilan LabVIEW sebagai Modbus Master RTU, Quick Client sebagai penghubung, dan rangkaian 2 buah Outseal Nano yang terhubung dengan sambungan RS485 di Proteus, yang keduanya menjadi Modbus Slave.

Gambar 27. Tampilan komunikasi antara LabVIEW sebagai Modbus Master RTU dengan 2 buah Outseal Nano sebagai Modbus Slave RTU dengan penghubung NI OPC Server

Untuk memudahkan rekan-rekan dalam membuat Modbus Slave di bagian ini, berikut ini file lengkap untuk pembuatan 4 buah tipe Modbus Slave sesuai dengan gambar skematik rangkaian: 

Agar lebih jelas, rekan-rekan dapat melihat video pembuatan Modbus Slave RTU dengan Arduino dan Outseal berikut ini:

Video Pembuatan Modbus Slave RTU dengan Arduino, Outseal + RS485

Sampai di sini, pembuatan Modbus Slave RTU selesai. Di bagian ke-4 akan dijelaskan pembuatan Modbus Master TCP dengan LabVIEW dan KEPServerEX Kepware. Berikutnya, silahkan klik Tab 4. Pembuatan Modbus Master TCP.

No comments:

Post a Comment

Subscribe to: Posts (Atom)