IC timer 555 adalah sirkuit terpadu (chip) yang digunakan dalam berbagai pembangkit timer, pulsa dan aplikasi osilator. Komponen ini digunakan secara luas, berkat kemudahan dalam penggunaan, harga rendah dan stabilitas yang baik
Kami bantu anda untuk memahami lebih jelas mengenai migrasi tv digital, apa sebabnya dan bagaimana efek terhadap kehidupan. Jasa teknisi juga tersedia dan siap membantu instalasi - setting perangkat - pengaturan antena dan distribusi televisi digital ke kamar kos / hotel
Project Sederhana dengan Dot Matrix dan Attiny2313. Bisa menjadi hadiah buat teman atau pacarmu yang ulang tahun dengan tulisan dan animasi yang dapat dibuat sendiri.
Jika anda pencinta IC TTL datau CMOS maka project jam digital ini akan menunjukkan bahwa tidak ada salahnya balik kembali ke dasar elektronika digital , sebab semuanya BISA dibuat dengan teknologi jadul
Belum lengkap rasanya kalau saya belum mencoba praktek modbus yang telah lengkap piramida IOT nya kedalam platform IOT lokal yaitu ANTARES by telkomiot. Tentunya pembaca yang ingin mengikuti pembahasan kali ini diharapkan membaca penelusuran saya dengan Antares vs ESP 8266 disini dan disini. Masih dengan rangkaian yang sama kita akan mencoba mengirim data pembacaan sensor modbus dan juga menunggu perintah dikirimkan dari antares ke sensor modbus yang saya buat menggunakan arduino.
Dari standar OneM2M yang digunakan antares maka ada ketentuan data MQTT yang di publish dan subscribe hanya terbatas pada 2 topik berikut :
PUBLISH TOPIC :
/oneM2M/req/access:key/antares-cse/json
SUBSCRIBE TOPIC :
/oneM2M/resp/antares-cse/access:key/json
Data yang dikirim / PUBLISH berupa JSON dimana polanya harus sesuai dimana data apapun yang akan dikirim ke Antares merupakan isi dari dalam "con" :
Untuk menunggu request dari antares harus diperhatikan yang diterima melalui callback merupakan JSON juga lhooo...jadi kalau mumet sebaiknya dihentikan segera melanjutkan membaca blog ini!
{
"m2m:rsp" : {
"rsc" : 2001,
"rqi" : "123456",
"pc" : {
"m2m:cin" : {
"rn" : "cin_63068886",
"ty" : 4,
"ri" : "/antares-cse/cin-63068886",
"pi" : "/antares-cse/cnt-682859183",
"ct" : "20200707T152502",
"lt" : "20200707T152502",
"st" : 0,
"cnf" : "message",
"cs" : 35,
"con" : "{\"led\":\"on\"}"
}
},
"to" : "access:key",
"fr" : "/antares-cse"
}
}
Untuk mengolah data request dari antares maka ESP8266 akan melakukan parsing JSON dari payload MQTT dengan menggunakan library ARDUINO JSON
DynamicJsonDocument doc(512);
deserializeJson(doc, message);
String parsedString = doc["m2m:rsp"]["pc"]["m2m:cin"]["con"]; //pertama cari isi con
deserializeJson(doc, parsedString);
String lednya = doc["led"]; //kedua cari isi led on apa off
Serial.println("lednya : " + lednya);
Jadi untuk mendapatkan isi dari message led "on" atau "off" maka diperlukan 2 kali parsing json karena isi dalam "con" juga di syaratkan sebagai JSON. Kenapa begitu? Ya karena itulah standar onem2m yang digunakan jadi harus diikuti saja.
Setelah berhasil memposisikan arduino menjadi modbus master, kita akan butuh sedikit usaha lagi untuk melengkapi piramida IOT nya. Untuk itu perlu penggabungan dari beberapa tulisan sebelumnya yaitu dasar MQTT pada ESP8266 disini dengan tulisan seri modbus part 3 disini. Ada dua mode mqtt yang ingin saya gunakan yaitu mode request-reply dan mode periodic. Perhatikan rangkaian dasar yang telah kita bahas sebelumnya.
Skematik arduino mqtt bridge
Dengan asumsi pembaca telah memahami pembahasan sebelumnya, mode request-reply memiliki 5 type perintah yang akan dikirim ke perangkat modbus dan jika di tuliskan dalam script seperti berikut :
if (Serial.available() > 0) { //perintah dari serial port monitor/putty
// read the incoming byte:
incomingByte = Serial.read();
if (incomingByte == '1') { //toggle led mati hidup
if (!led) mod.write(ledOn, sizeof(ledOn)); //modbus led on
else mod.write(ledOff, sizeof(ledOff)); //modbus led off
led=!led;
}
else if (incomingByte == '2') mod.write(tombol, sizeof(tombol)); //cek tombol
else if (incomingByte == '3') mod.write(humitemp, sizeof(humitemp)); //baca dht11
else if (incomingByte == '4') mod.write(aisi, sizeof(aisi)); //baca holding register
}
Pada script diatas merupakan perintah atau request yang dikirimkan oleh Terminal Serial semisal putty atau serial monitor sketch arduino dimana terjemahan perintah nya seperti berikut :
'1' : Togle led On atau Off
'2' : Baca penekanan tombol
'3' : Baca sensor DHT11
'4' : Baca Holding Register
Kita dapat merubah request dari terminal serial menjadi perintah yg dikirim melalui SUBSCRIBE TOPIK MQTT, jadi esp8266 akan menunggu apakah ada request dari server/broker yang masuk dan membandingkan isi payloadnya sesuai script berikut :
void mqtt_callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived in topic: ");
Serial.println(topic);
Serial.print("Message:");
String message;
for (int i = 0; i < length; i++) {
message = message + (char)payload[i]; //Convert *byte to String
}
Serial.print(message);
if(message == "1"){ //bandingkan payload yang masuk dan kirim modbus
if (!led) mod.write(ledOn, sizeof(ledOn));
else mod.write(ledOff, sizeof(ledOff));
led=!led;
}
if(message == "2")mod.write(tombol, sizeof(tombol));
if(message == "3")mod.write(humitemp, sizeof(humitemp));
if(message == "4")mod.write(aisi, sizeof(aisi));
}
Untuk memahaminya tidaklah begitu sulit jika anda rajin membaca blog ini dari seri tulisan mengenai mqtt yang sering saya bahas sebelumnya.
Setelah modbus me-reply request maka esp8266 akan membandingkan reply modbus dan selanjutnya melakukan PUBLISH MQTT ke topik yang telah ditentukan ke broker mqtt. Anda juga bisa menggunakan Smartphone dengan aplikasi IOT MQTT PANEL untuk menerima data yang di PUBLISH oleh bridge mqtt esp8266 dan tentunya juga bisa mengirimkan perintah/request ke modbus.
Untuk mode periodic cukup menambahkan timer pada loop utama yang akan mengirimkan perintah modbus untuk pengecekan tombol dan pembacaan DHT11 setiap jeda waktu tertentu. Selengkapnya ikuti penjelasan pada video berikut ini :
Dalam sebuah piramida Internet Of Things, bagi developer kelas rumahan seperti penulis yang tukang solder ini, ruang geraknya terbatas pada 2 tingkat yaitu piramida paling bawah pembacaan sensor via microcontroller dan piramida paling atas pada tampilan hasil IOT melalui grafik web dan apps smartphone. Level priramida "connectivity" umumnya merupakan posisi yang hanya bisa dikerjakan oleh dunia telekomunikasi sedangkan level "platforms" merupakan ranah para raksasa IT.
Standar komunikasi MODBUS bisa digambarkan berada pada perbatasan piramida 1 dan 2 dimana para pengembang modbus mulai mengeluarkan standar modbus TCP untuk meng-akomodir standar jaman now yang serba IP. Lalu alat berbasis modbus yang masih menggunakan standar serial com membutuhkan sebuah bridge IOT yang akan membuat loncatan dari piramida 1 ke piramida 3. Tulisan saya serial pembahasan modbus yang ke-3 dan selanjutnya akan membahas perancangan dan praktek arduino sebagai bridge MQTT sederhana yang akan menghubungkan modbus ke dalam piramida IOT.
Jika anda memerlukan sensor suhu kelembaban standar modbus untuk industri yang harganya terjangkau maka gambar diatas merupakan salah satu pilihan. Diperlukan pembacaan datasheet atau manual yang didapat dari produsennya yang merupakan ciri khas dari alat ber-Protokol modbus. Tiap desainer alat menggunakan alamat register bebas dimanapun sesuai pemahaman mereka begitu juga pemetaan data yang dikirim seperti apa prosedurnya dilakukan tanpa pola yang seragam antar alat yang berbeda. Seperti biasa saya lebih suka menjelaskan dengan praktek langsung dimana kali ini saya berusaha menduplikasi alat SHT20 modbus diatas dengan menggunakan sensor sejuta umat DHT11.
Langkah awal yang perlu diperhatikan adalah mengukur kemampuan microcontoller arduino sebagai bridge IOT dengan memposisikannya sebagai modbus master dan hasilnya penulis beberapa kali kesulitan untuk memperoleh library modbus master yang sesuai dengan keinginan. Ini dikarenakan ternyata akibat saking banyaknya standar yang harus diakomodir maka lebih mudah untuk membuat bridge sesuai dengan karakteristik dari masing-masing alat modbus. Pada penjelasan part1 dan part2 yang saya tulis sebelumnya, alat modbus yang saya buat memiliki deretan perintah dan respon serial sebagai berikut:
Untuk perintah mode function 5 force coil / menghidupkan LED maka yang dikirim akan sama dengan apa yang di reply oleh alat modbus, sedangkan function lainnya memiliki karakteristik yang selalu sama. Sehingga jika kita ingin membuat master modbus pada arduino cukup mengirim 5 jenis perintah serial seperti pada array berikut :
Perhatikan reply dari pembacaan DHT 11 seperti berikut :
05 04 06 00 1D 00 4F 00 5F CF BE
05 = Alamat device id slave
04 = Perintah baca input analog/ function 04
06 = 6 byte data berikut akan muncul (format 2 byte per data)
00 1D = 2 byte pertama adalah 001D = 29
00 4F = 2 byte kedua adalah 004F = 79
00 5F = 2 byte ketiga adalah 005F = 95
CF BE = Checksum / CRC 16 modbus
Jadi butuh parsing pada byte ke-4 dan ke-6 untuk mendapatkan pembacaan suhu dan parsing byte ke-8 untuk mendapatkan kelembaban. Checksum tidak begitu critical sehingga mungkin untuk diabaikan, dan urutan script pembacaan DHT 11 yang kemudian akan dilempar ke serial monitor adalah seperti berikut ini :
void loop()
{
unsigned long currentMillis = millis();
if(currentMillis - previousMillis >= 5000) {
// timer baca dht11 tiap 5 detik
previousMillis = currentMillis;
//kirim perintah ke modbus baca dht 11
mod.write(humitemp, sizeof(humitemp));
}
//check modbus timeout
long millisResponModbus = millis() + 1000;
while (!mod.available())
{
if (millisResponModbus < millis())
{
break;//timeout
}
}
// baca data serial yang masuk dari modbus lalu simpan pada pointer
while (mod.available())
{
byte b = mod.read();
*ptr++ = b;
Serial.print("0x");
Serial.print(String(b, HEX));
Serial.print(" ");
delay(2);
}
//proses komparasi data yg masuk (DHT11) dengan array jawaban lalu parsing
if (memcmp(bufferDataModbus, dhtOK, sizeof(dhtOK)) == 0) {
ptr = bufferDataModbus;
Serial.println("");
Serial.print(F("SUHU :"));
Serial.print(ptr[4]); //alamat byte ke 4
Serial.print(F(","));
Serial.print(ptr[6]); //alamat byte ke 6
Serial.print(F(" C HUMI :"));
Serial.print(ptr[8]); //alamat byte ke 8
Serial.println(" %");
memset(bufferDataModbus, 0x00, sizeof(bufferDataModbus));
}
}
Jadi jika ingin melihat visualisasinya anda bisa menontonnya pada video berikut ini :
Pada bagian kedua kita akan membedah standar protokol modbus melalui pembedahan perintah yang dikirim dan terima dari master menuju slave. Dari software sniffer serial port yg menyadap komunikasi serial pada komunikasi antara PC sebagai master modbus dan arduino sebagai modbus slave, didapatkan pola pengiriman data seperti ini saat menghidupkan LED:
05 05 00 00 FF 00 8D BE
Kode diatas berupa Hexa jadi kalau dipisah-pisah berdasarkan standar pada beberapa tulisan yang saya baca di beberapa artikel di internet adalah seperti berikut:
05 = Alamat device id slave
05 = Perintah force coil / function 05
00 00 = 2 byte alamat address memori (mulai 0)
FF 00 = 2 byte force coil ON
8D BE = Checksum / CRC 16 modbus
Ada pola khusus yaitu alamat address register dan data perintah berupa 2 byte. Register / alamat memory modbus selalu dimulai dari nol walaupun sejatinya alamat yang dituju merupakan register yg diawali angka 1, contoh kita akan megakses register 40001, tetap saja perintah nya akses ke reg 0 karena sudah diwakili oleh byte perintah function sebagai penanda jenis register yg akan diakses. Check sum ini didapat dengan rumus tertentu dan daripada pusing langsung aja gunakan website https://www.scadacore.com/tools/programming-calculators/online-checksum-calculator/ untuk menjadi crosscheck. Pada terminal realterm sudah terdapat penghitung checksum otomatis sehingga sangat gampang.
Jadi untuk mematikan led perintahnya adalah :
05 05 00 00 00 00 CC 4E
Untuk mengecek checksumnya (CC 4E) dapat menggunakan website yang telah saya berikan sebelumnya. Untuk mengecek penekanan tombol perintahnya adalah :
05 02 00 00 00 01 B8 4E
05 = Alamat device id slave
02 = Perintah baca input digital / function 02
00 00 = 2 byte alamat address memori (mulai 0)
00 01 = 2 byte panjang data yg diharapkan
B8 4E = Checksum / CRC 16 modbus
Jawaban yg diterima untuk kondisi tombol dilepas / LOW :
Untuk membaca DHT11 dilakukan dengan function 04 dan 3 buah data akan diminta ke modbus yaitu suhu didepan koma, suhu di belakang koma dan terakhir angka kelembaban. Perintahnya sebagai berikut :
05 04 00 00 00 03 B1 8F
05 = Alamat device id slave
04 = Perintah baca input analog/ function 04
00 00 = 2 byte alamat address memori (mulai 0)
00 03 = 2 byte panjang data yg diharapkan (3 buah data)
B1 8F = Checksum / CRC 16 modbus
sedangkan replynya seperti ini formatnya :
05 04 06 00 1D 00 4F 00 5F CF BE
05 = Alamat device id slave
04 = Perintah baca input analog/ function 04
06 = 6 byte data berikut akan muncul (format 2 byte per data)
Seri tulisan saya kali ini akan membahas tentang protokol komunikasi pada industri yang masih de facto menjadi standar disana. Standar MODBUS yang diperkenalkan oleh modicom (kemudian menjadi schneider) pada tahun 1979 sebagai sistem kendali pada mesin industri dimana saat itu kontrol dari pusat PLC (Programmable Logic Unit) dihubungkan menuju RTU (remote terminal unit) melalui komunikasi serial RS 232/485. Untuk memudahkan pemahaman kali ini saya akan menekankan praktek langsung menggunakan mikrokontroller arduino.
Salah satu contoh alat berbasis modbus yang lagi naik daun adalah PZEM dimana saat musim pengiritan energi sangat dibutuhkan kontrol pengaturan daya listrik melalui monitoring yang akurat. Terdapat satu blog pada internet karya mas asep kurniawan (semesin dot com) membahas penggunaan alat ini tanpa menggunakan library pzem pada sketch arduino. Secara sederhana pembacaan datanya digambarkan seperti ini :
courtesy semesin dot com
Pola pikir orang jaman dulu saat mendesain protokol modbus menggunakan pola ADDRESS-DATA, jadi sebuah lokasi alamat memori memiliki data yang dapat dibaca atau ditulis dan dari perubahan register ini maka akan mendapatkan kondisi yang diharapkan. Alamat address yang standar modbus sebagai berikut :
Object type
Access
Size
Address Space
Coil
Read-write
1 bit
00001 - 09999
Discrete input
Read-only
1 bit
10001 - 19999
Input register
Read-only
16 bits
30001 - 39999
Holding register
Read-write
16 bits
40001 - 49999
Coil merupakan istilah output relay, Discrete input merupakan istilah untuk switch, Input register merupakan data sensor analog dan Holding register sebagai alamat memory umum yang dapat digunakan menampung parameter/variabel. Ada istilah lainnya yang perlu diketahui yaitu function code yang menjelaskan perintah yang dikirim akan mengerjakan apa.
FUNCTION
CODE
VALUE TYPE
01 (0x01)
Read Coil Status
02 (0x02)
Read Input Status
03 (0x03)
Read Holding
Registers
04 (0x04)
Read Input Registers
05 (0x05)
Force Single Coil
06 (0x06)
Preset Single
Register
15 (0x0F)
Force Multiple Coils
16 (0x10)
Preset Multiple
Registers
Yang sering digunakan pada alat berbasis modbus adalah fungsi 02, 03, 04 dan 05.
Karena di tempat saya tidak memiliki alat berbasis modbus maka pada praktek part 1 ini kita akan membuat alat seperti pada skematik diatas tujuannya menjadikan arduino dengan I/O berupa dht11, led dan tombol menjadi berbasis modbus. Script nya seperti dibawah ini :
//Library modbus slave: https://code.google.com/archive/p/arduino-modbus-slave/downloads
#include <modbus.h>
#include <modbusDevice.h>
#include <modbusRegBank.h>
#include <modbusSlave.h>
#include "DHT.h"
/*
Cara Mudah Menjadikan arduino menjadi alat modbus
Alamat device ID 5 pada 9600 baud.
*/
#define LED 2
#define TOMBOL 3
#define dhtPin 4
#define DHTTYPE DHT11
DHT dht(dhtPin, DHTTYPE);
unsigned long previousMillis = 0;
const long interval = 5000;
//Setup register bank
//semua data ditulis dan disimpan disini
modbusDevice regBank;
//mode slave
modbusSlave slave;
void setup()
{
pinMode(LED, OUTPUT);
pinMode(TOMBOL, INPUT);
//menentukan device ID.
regBank.setId(5);
dht.begin();
/*
modbus registers format seperti berikut
00001-09999 Digital Outputs, master dapat menulis dan membaca data
10001-19999 Digital Inputs, master hanya bisa baca data
30001-39999 Analog Inputs, master hanya bisa membaca nilai pada register
40001-49999 Analog Outputs, master dapat tulis baca register
*/
//tambahkan alamat LED pada register bank
regBank.add(1); //LED
//Tombol sebagai Input registers 10001
regBank.add(10001); //TOMBOL
//Analog Input registers 30001-30003 untuk DHT11
regBank.add(30001); //DHT11 - suhu puluhan
regBank.add(30002); //DHT11 - suhu desimal
regBank.add(30003); //DHT11 - kelembaban
//Coba simpan register umum 40001-40015
regBank.add(40001); // w
regBank.add(40002); // w
regBank.add(40003); // w
regBank.add(40004); // .
regBank.add(40005); // a
regBank.add(40006); // i
regBank.add(40007); // s
regBank.add(40008); // i
regBank.add(40009); // 5
regBank.add(40010); // 5
regBank.add(40011); // 5
regBank.add(40012); // .
regBank.add(40013); // c
regBank.add(40014); // o
regBank.add(40015); // m
/*
protocol handler yang akan menulis dan membaca
register data.
*/
slave._device = ®Bank;
// Serial pada 9600
slave.setBaud(9600);
//isi register umum diawal
regBank.set(40001,'w');
regBank.set(40002,'w');
regBank.set(40003,'w');
regBank.set(40004,'.');
regBank.set(40005,'a');
regBank.set(40006,'i');
regBank.set(40007,'s');
regBank.set(40008,'i');
regBank.set(40009,'5');
regBank.set(40010,'5');
regBank.set(40011,'5');
regBank.set(40012,'.');
regBank.set(40013,'c');
regBank.set(40014,'o');
regBank.set(40015,'m');
}
//fungsi memecah angka dibelakang koma dht11
int ExtractDecimalPart(float Value, int numberOfDecimals)
{
float temp = Value - (long)(Value);
long p = 1;
for (int i=0; i< numberOfDecimals; i++) p*=10;
long DecimalPart = p * temp;
return DecimalPart;
}
void loop()
{
//Melihat data register 1 dan lempar ke LED
digitalWrite(LED,regBank.get(1));
//Membaca input tombol dan lempar ke register 10001
regBank.set(10001, digitalRead(TOMBOL));
//membaca dht11 tiap 5 detik
unsigned long currentMillis = millis();
if(currentMillis - previousMillis >= interval) {
// save the last time you read the sensor
previousMillis = currentMillis;
int h = dht.readHumidity();
float t= dht.readTemperature();
int t1 = t;
int t2 = ExtractDecimalPart(t,2); //pecah desimal
regBank.set(30001,1000); // tulis suhu depan koma
regBank.set(30002,1000); // tulis suhu belakang koma
regBank.set(30003,1000); // tulis kelembaban
}
// loop terus sebagai slave
slave.run();
}
Pergunakan software monitoring modbus yang banyak ada di internet untuk melakukan pengecekan apakah alat yang kita buat sudah terbukti menggunakan modbus, yang saya gunakan adalah radzio modbus.
Dengan menggunakan USB to Serial langsung ke PC maka telah terbukti device modbus arduino dengan ID 5 dapat dibaca datanya dan dilakukan kontrol LED terhadapnya. Kita juga bisa mengetest data apa sih yang dikirimkan secara serial dan format yang benar melalui terminal real term yang akan dibahas pada video selanjutnya, dan selengkapnya bisa dilihat pada video berikut :
#daring #daringadalah daring adalah mpls #sekolah #guru #google classroom google classroom sekolah online guru kelas zoom webcam
Modul Bluetooth HM10 MLT-BT05-BLE4.0 yang saya beli ternyata merupakan emulator komunikasi serial pada BLE dan cocok untuk proses belajar mengenal parameter dan pengaturan dari device BLE pada umumnya. Harapan saya untuk dapat mengoprek UUID dan Service / Characteristic yg ada ternyata terbatas pada CHAR nama Bluetooth serta UUID 0xFFE0 yang merupakan layanan TX RX Serial seperti yg bisa dilihat di hasil scan pada aplikasi android BLE console ( gunakan google play).
Beberapa kali saya temukan kerancuan dalam mengartikan mana yg UUID dan mana CHARACTERISTIC, tapi dari kenyataan hasil praktek dan manual book maka modul saya ini memang hanya mempunyai 1 UUID dan 1 CHAR yaitu 0xFFE0 dan 0xFFE1. Ada beberapa blog yg mengatakan bahwa angka itu muncul dari kombinasi parameter serivis yg bisa read write dan notify. Daripada bingung kita ikut aja aturan seperti contoh yg ada di internet sana dimana harus disertakan AT command berikut ini :
AT+ROLE0 ==> Sebagai mode slave
AT+UUID0xFFE0 ==> atur UUID
AT+CHAR0xFFE1 ==> atur Characteristic
Kembali ke kelanjutan praktek sebelumnya, kita kembali menghubungkan Arduino Uno dan modul BLE dan kali ini akan disertakan 2 buah lampu LED.
Jadi tujuan dari prakteknya adalah untuk menghidupkan dan mematikan LED melalui terminal android. Scriptnya bagaimana ? Kita bahas satu persatu bagian yuk..
#include <SoftwareSerial.h> // library serial
#define merah 5 // pin LED merah
#define hijau 6 // pin LED hijau
SoftwareSerial mySerial(3, 4); // RX, TX
void setup() {
pinMode(merah, OUTPUT); //inisialisasi led merah
pinMode(hijau, OUTPUT); //inisialisasi led merah
digitalWrite(merah, HIGH); //test led saat awal
digitalWrite(hijau, HIGH); // Nyala lalu mati
delay(500);
digitalWrite(merah, LOW);
digitalWrite(hijau, LOW);
mySerial.begin(9600); // inisialisasi serial BLE
Serial.begin(9600); // inisialisasi serial UNO
// inisialisasi UUID dan BLE sebagai slave mode
sendCommand("AT");
sendCommand("AT+ROLE0");
sendCommand("AT+UUID0xFFE0");
sendCommand("AT+CHAR0xFFE1");
sendCommand("AT+NAMEwww.aisi555.com");
}
Nah begitu aturan awal menginisialisasi modul BLE pembaca cukup ikuti saja aturan ini. Lalu untuk mengirim AT command secara serial ke BLE digunakan function / routine bernama sendCommand() void sendCommand(const char * command){ Serial.print("Command kirim :"); // menulis command ke monitor Serial.println(command); mySerial.println(command); // kirim AT command ke BLE //tunggu bntar delay(100); char reply[100]; //kumpulkan reply dalam char array int i = 0; while (mySerial.available()) { reply[i] = mySerial.read(); i += 1; } //akhir string selalu '\0' reply[i] = '\0'; Serial.print(reply);
Serial.println("Pesan Dibalas");
Untuk menerima perintah dari lawan yaitu Smartphone Android dengan aplikasi BLE Console maka diperlukan pembacaan perintah dan dicompare sesuai kata "kunci" yg dipakai. Misal "LED ON" maka akan di compare melalui script STRCMP seperti berikut :
if (strcmp(reply,"merah on")==0) digitalWrite(merah, HIGH);
else if (strcmp(reply,"merah off")==0) digitalWrite(merah, LOW);
else if (strcmp(reply,"hijau on")==0) digitalWrite(hijau, HIGH);
else if (strcmp(reply,"hijau off")==0) digitalWrite(hijau, LOW);
if(strlen(reply) > 0){
Serial.println(reply);
Serial.println("Perhatikan LED nya");
}
}
Simple bukan ? Dengan kreasi menambahkan delay maka kita bisa juga menambahkan fasilitas flip- flop pada hijau merah seperti pada script dan video dikakhir tulisan ini
void loop() {
readSerial();
delay(500);
if( flip == true) {
if(flop == false) {
digitalWrite(merah, LOW );
digitalWrite(hijau, HIGH);
flop = true;
}
else {
digitalWrite(merah, HIGH );
digitalWrite(hijau, LOW);
flop = false;
}
}
}
Bagaimana jika kita tambahkan DHT11 dan akan membaca suhu udara? Kita cukup menambahkan proses pembacaan DHT11 saat ada perintah serial masuk dari BLE yg dikirim smartphone, misalnya seperti gambar dibawah. Saya menggunakan aplikasi BLE console dengan setting Notify centang dan Send Enter jangan di centang.
Jadi modifikasi script sama saja seperti pembahasan pembacaan DHT 11 pada percobaan yang lalu lalu, yg ditambahkan hanya reply ke BLE melalui serial port.
void SendTempHumid(bool jenis){ // jenis suhu apa humi
//script umum pembacaan DHT11 float h = dht.readHumidity(); float t = dht.readTemperature(); if (isnan(h) || isnan(t)) { Serial.println("Failed to read from DHT sensor!"); //return; This will ensure that data is always sent } if(jenis == false) // baca suhu { Serial.print("Temperature: "); Serial.print(t); Serial.println(" °C "); mySerial.print("T: "); //kirim suhu ke BLE mySerial.print(t); mySerial.println("°C "); } else { Serial.print("Humidity: "); Serial.print(h); Serial.println(" %"); mySerial.print("H: "); //kirim humi ke BLE mySerial.print(h); mySerial.println(" %"); } }
Sedangkan pada function readSerial() kita tambahkan seperti ini untuk menangkap pengiriman kata "suhu" dan "humi" yg dikirimkan oleh smartphone. else if (strcmp(reply,"suhu")==0) SendTempHumid(false); else if (strcmp(reply,"humi")==0) SendTempHumid(true); Hasil selengkapnya bisa dilihat pada video berikut ini :