Pemrograman Dengan Kelas (Class) dan Objek (Object) di Arduino

Kelas atau Class adalah kumpulan fungsi dan variabel yang dapat digunakan untuk melakukan tugas pemrograman tertentu. Dalam pemrograman Arduino, kelas pada dasarnya sama dengan perpustakaan.

Kelas seperti template yang memungkinkan Anda menggunakan kembali kode tanpa harus mengetiknya berulang-ulang. Misalnya, Anda perlu membuat 20 dokumen yang semuanya memiliki font, header dan margin yang sama. Akan terlalu memakan waktu untuk mengubah pemformatan semua 20 dokumen satu per satu. Sebagai gantinya, Anda dapat membuat dokumen template dengan font, header dan margin yang tepat, lalu menambahkan teks dan menyimpannya sebagai file terpisah.

Kelas seperti dokumen template itu. Kelas adalah templat kode untuk apa yang disebut "objek". Pikirkan kelas sebagai dokumen template dan objek sebagai dokumen individual. Objek dapat memungkinkan untuk Anda mengakses fungsi dan variabel di dalam kelas. Sebuah objek kadang-kadang disebut sebagai "instance" dari sebuah kelas.

LED Berkedip (Blink) Tanpa Kelas dan Objek

Untuk mendemonstrasikan betapa bergunanya kelas dan objek, lihat contoh proyek yang mengedipkan dua LED dengan kecepatan berbeda tanpa menggunakan kelas dan objek.

Berikut adalah bagian yang Anda perlukan untuk proyek ini:

• arduino uno
• Kabel jumper
• Papan projectboard
• Schmitt SN74HC14N
• Push button taktil
• Resistor 10K Ohm
• 1 uF kapasitor

Diagram pengkabelan untuk proyek ditunjukkan di bawah ini:

Sketsa ini akan membuat LED hijau berkedip dan mati selama dua detik dan LED merah berkedip dan mati selama satu detik:

int redLED = 10;
int greenLED = 11;

void setup() {
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
}

void loop() {
  digitalWrite(greenLED, HIGH);
  delay(2000);
  digitalWrite(greenLED, LOW);
  delay(2000);

  digitalWrite(redLED, HIGH);
  delay(1000);
  digitalWrite(redLED, LOW);
  delay(1000);
}

Penjelasan Kode

Di bagian atas sketsa kami mendeklarasikan variabel untuk redLED dan pin greenLED.

Di bagian setup() ini, kami mengatur mode pin untuk setiap pin LED sebagai OUTPUT.

Di bagian loop() ini, kami menulis digital greenLED dengan nilai high, tunda (delay) selama 2000 milidetik, tulis digital low, lalu tunda selama 2000 milidetik lagi.

Selanjutnya kita tulis digital redLED dengan nilai high, tunda selama 1000 milidetik, tulis digital low, lalu tunda lagi selama 1000 milidetik.

Ini adalah banyak kode untuk tugas yang sederhana seperti mengedipkan dan mematikan beberapa LED. Kita dapat membuat program ini jauh lebih kecil dengan kelas dan objek.

Led Berkedip (Blink) Dengan Kelas dan Objek

Mari kita lihat cara mengedipkan LED pada sketsa di atas dengan kelas dan objek. Kita akan mulai dengan menulis kode untuk kelas, dan kemudian kita akan membuat objek dalam sketsa untuk mengakses kode di dalam kelas.

Untuk membuat kelas Arduino, kita perlu membuat dua file, yakni file header dan file sumber. Kita akan menulis sketsa yang menggunakan kelas ini nanti, tapi sekarang mari kita mulai menulis file header.

File Header

File header adalah tempat kelas dideklarasikan. Itu juga di mana fungsi dan variabel yang digunakan di dalam kelas dideklarasikan. Mari kita berjalan selangkah demi selangkah melalui cara menulis file header.

Bagian pertama dari kode yang dibutuhkan dalam file header disebut dengan penjaga yang disertakan. Penjaga yang disertakan mencegah kesalahan program jika pustaka secara tidak sengaja disertakan lebih dari sekali dalam sketsa:

#ifndef MyClass_h
#define MyClass_h
// code goes here
#endif

Anda dapat memberi nama file header apa pun yang Anda inginkan tetapi dalam artikel ini akan diberi nama MyClass. File header harus disimpan dengan ekstensi .h. Di dalam #ifndefdan #define, nama file header harus diikuti oleh _h.

Selanjutnya kita perlu menyertakan library Arduino.h. Arduino.h adalah perpustakaan inti yang berisi semua fungsi bawaan Arduino. Menyertakannya dalam file header membuat fungsi-fungsi tersebut tersedia untuk digunakan di kelas:

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
#endif

Sekarang kita dapat mendefinisikan kelas. Untuk mendefinisikan kelas, tulis class diikuti dengan nama kelas:

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
// class code goes here
};
#endif

Nama kelas dalam contoh ini adalah MyClass. Kode untuk kelas dimasukkan ke dalam tanda kurung kurawal.

Fungsi dan variabel di dalam kelas dapat bersifat publik atau pribadi:

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
public:
private:
};
#endif

Kata kunci publik dan pribadi dikenal sebagai penentu akses. Fungsi dan variabel publik dapat digunakan di dalam sketsa, tetapi fungsi dan variabel pribadi hanya dapat digunakan di dalam kelas.

Setiap kelas membutuhkan fungsi khusus yang disebut konstruktor. Konstruktor mendefinisikan apa yang akan terjadi ketika sebuah objek dibuat. Saat kita menulis sketsa untuk proyek ini, kita akan membuat objek untuk LED hijau dan objek lain untuk LED merah. Konstruktor akan memberi tahu Arduino apa yang harus dilakukan ketika kita membuat objek LED tersebut.

Kami akan menulis kode aktual untuk konstruktor ketika kami mendefinisikannya di file sumber, tetapi kami masih perlu mendeklarasikannya di file header. Karena objek akan dibuat dalam sketsa, deklarasi konstruktor harus bersifat publik dan memiliki nama yang sama dengan kelasnya. Kelas dalam contoh ini disebut MyClass, jadi deklarasi konstruktornya adalah MyClass():

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
public:
	MyClass();
private:
};
#endif

Dalam proyek contoh ini kita akan memiliki dua LED yang terhubung ke Arduino sehingga kita perlu mengatur mode pin dari setiap pin LED sebagai OUTPUT. Saat kita menulis kode untuk konstruktor di file sumber, kita akan meletakkan fungsi pinMode() di dalamnya. Fungsi pinMode() mengambil nomor pin sebagai parameter pertama. Kita perlu meneruskan nomor pin itu ke konstruktor agar fungsi pinMode() dapat menggunakannya. Untuk melakukan itu, kami mendeklarasikan variabel int yang dipanggil pin di dalam tanda kurung dari deklarasi konstruktor:

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
public:
	MyClass(int pin);
private:
};
#endif

Sekarang kita perlu mendeklarasikan fungsi yang akan membuat LED berkedip. Fungsi di dalam kelas dideklarasikan dengan cara yang sama seperti yang dideklarasikan dalam sketsa. Pertama tulis tipe pengembaliannya. Fungsi ini tidak akan mengembalikan nilai apa pun, jadi tipe pengembaliannya adalah void. Kemudian tulis nama fungsinya. Mari kita menyebutnya myFunction():

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
public:
	MyClass(int pin);
	void myFunction();
private:
};
#endif

Karena fungsi ini akan mengedipkan LED, alangkah baiknya jika Anda memiliki kendali atas seberapa cepat kedipan terjadi. Kita dapat melakukan ini dengan melewatkan variabel ke fungsi myFunction() yang akan menentukan panjang penundaan. Ketika fungsi digunakan dalam sketsa, itu akan memiliki parameter yang akan mengatur panjang penundaan.

Mari kita mendeklarasikan variabel pada myFunction() untuk menyimpan parameter itu dan menyebutnya blinkRate:

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
public:
	MyClass(int pin);
	void myFunction(int blinkRate);
private:
};
#endif

Sekarang, argumen apa pun yang digunakan dalam fungsi myFunction() dalam sketsa akan diteruskan ke kode fungsi di file sumber.

Fungsi myFunction() perlu mengetahui nomor pin yang terhubung dengan LED, jadi kita perlu mendeklarasikan variabel untuk menyimpannya. Variabel nomor pin hanya akan digunakan di dalam fungsi sehingga akan dideklarasikan sebagai variabel pribadi. Konvensi penamaan untuk variabel pribadi adalah dengan garis bawah sebelum nama variabel. Jadi mari kita mendeklarasikan mendeklarasikan variabel pribadi yang disebut _pin:

#ifndef MyClass_h
#define MyClass_h
#include "Arduino.h" 
class MyClass {
public:
	MyClass(int pin);
	void myFunction(int blinkRate);
private:
	int _pin;
};
#endif

Ini semua kode yang kita butuhkan untuk file header.

Untuk menyimpan file header, navigasikan ke Documents > Arduino > Libraries. Buat folder baru dengan nama yang sama dengan kelas (MyClass dalam contoh ini). Simpan file header di folder ini. File header harus disimpan dengan ekstensi .h. Dalam contoh ini, file header akan diberi nama MyClass.h.

File Sumber (Source File)

File sumber berisi kode aktual untuk fungsi, dan mendefinisikan apa yang akan terjadi saat Anda membuat objek. Mari kita telusuri proses penulisan file sumber.

File sumber harus memiliki nama yang sama dengan file header tetapi dengan ekstensi “.cpp”.

Hal pertama yang harus dilakukan adalah menyertakan library Arduino.h sehingga kita dapat menggunakan fungsi bawaan Arduino seperti pinMode(), digitalWrite() dan delay():

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass() {
}

Kemudian kita perlu memasukkan file header yang baru saja kita tulis. Kami melakukannya dengan cara yang sama kami menyertakan semua kelas, dengan #include diikuti oleh nama file header dalam tanda kutip:

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass() {
}

Sekarang kita dapat menulis definisi konstruktor. Kode ini akan dieksekusi setiap kali sebuah objek dibuat dalam sketsa. Definisi konstruktor dimulai dengan nama kelas diikuti oleh dua titik dua. Dalam contoh ini, kelasnya adalah MyClass. Dua titik dua disebut operator resolusi lingkup. Setelah dua titik dua adalah nama konstruktor yang kami nyatakan di file header. Konstruktor harus memiliki nama yang sama dengan kelas. Jadi nama konstruktornya adalah MyClass():

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass() {
}

Objek yang kita buat dengan kelas ini akan mewakili pin Arduino yang terhubung ke LED hijau dan merah. Setiap kali objek LED dibuat, setiap pin pinMode() perlu diatur sebagai output. Untuk melakukan itu, kita perlu meneruskan nomor pin Arduino yang terhubung ke LED ke konstruktor dengan mendeklarasikan variabel yang disebut pindi dalam konstruktor MyClass():

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass(int pin) {
}

Di dalam konstruktor yang perlu kita lakukan adalah mengatur mode pin dari pin LED. Nomor pin yang disimpan dalam pinvariabel akan diteruskan ke konstruktor ketika objek dibuat, jadi kami mengatur mode pin dengan pin, OUTPUT:

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass(int pin) {
	pinMode(pin, OUTPUT);
}

Ingat variabel _pin pribadi yang kami deklarasikan di file header? Sekarang kita atur itu sama dengan variabel pin publik yang kita deklarasikan di dalam konstruktor MyClass(). Kami akan melihat mengapa kami ingin melakukan ini dalam satu menit:

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass(int pin) {
	pinMode(pin, OUTPUT);
	_pin = pin;
}

Tapi sekarang mari kita tulis fungsi yang akan membuat LED berkedip. Untuk mendefinisikan suatu fungsi, pertama-tama tuliskan tipe kembalian fungsi tersebut. Fungsi dalam contoh ini tidak akan mengembalikan nilai apa pun sehingga tipe pengembaliannya adalah void.

Kemudian tulis nama kelas tempat fungsi tersebut berada. Dalam contoh ini, fungsi akan menjadi milik kelas MyClass. Selanjutnya, sertakan operator :: resolusi ruang lingkup diikuti dengan nama fungsi. Kami sudah mendeklarasikan fungsi myFunction() di file header, jadi kami bisa menggunakannya:

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass(int pin) {
	pinMode(pin, OUTPUT);
	_pin = pin;
}
void MyClass::myFunction(){
}

Fungsi myFunction() tersebut akan memiliki parameter yang mengatur durasi kedipan LED. Kami mendeklarasikan variabel dalam file header yang dipanggil blinkRate untuk menyimpan nilai itu, tetapi kami juga perlu mendeklarasikannya di sini di file sumber di dalam tanda kurung myFunction():

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass(int pin) {
	pinMode(pin, OUTPUT);
	_pin = pin;
}
void MyClass::myFunction(int blinkRate){
}  

Ini akan membuat parameter untuk fungsi myFunction() tersebut. Sekarang ketika kita memanggil fungsi dalam sketsa, kita dapat memberikannya sebuah argumen. Dalam contoh ini, argumen akan menjadi variabel blinkRate.

Sekarang kita dapat memasukkan kode untuk membuat LED berkedip. Ini adalah kode dasar yang sama yang biasanya digunakan untuk mengedipkan LED:

#include "Arduino.h”
#include "MyClass.h"
MyClass::MyClass(int pin) {
	pinMode(pin, OUTPUT);
	_pin = pin;
}
void MyClass::myFunction(int blinkRate){
digitalWrite(_pin, HIGH);
delay(blinkRate);
digitalWrite(_pin, LOW);
delay(blinkRate);
}

Pertama kita menulis variabel _pin digital pribadi (privat) sebagai nilai high. Dalam konstruktor, variabel _pin privat disetel sama dengan variabel pin publik. Jadi ketika objek LED dibuat, nomor pin akan disimpan dalam variabel pin publik dan diteruskan ke konstruktor. Nomor pin itu juga akan disimpan dalam variabel _pin pribadi dan diteruskan ke fungsi digitalWrite().

Durasi penundaan akan diatur dalam sketsa dan disimpan dalam variabel blinkRate, jadi kami menggunakan blinkRate sebagai argumen fungsi delay(). Kemudian kita tulis digital variabel _pin pribadi dengan nilai low dan tunda (delay) lagi oleh blinkRate.

Ok, itu saja yang kita butuhkan untuk file sumber.

Untuk menyimpan file sumber, navigasikan ke Documents > Arduino > Libraries. Simpan file sumber di folder yang dibuat untuk MyClass. File sumber harus memiliki nama yang sama dengan file header, tetapi dengan ekstensi .cpp. Dalam contoh ini, file header akan diberi nama MyClass.cpp.

Sekarang mari kita menulis sketsa.

Sketsa

Dalam pemrograman Arduino, kelas diperlakukan seperti perpustakaan, jadi kita dapat memasukkan kelas MyClass dalam sketsa dengan cara yang sama seperti perpustakaan disertakan:

#include <MyClass.h>

Untuk menggunakan fungsi yang didefinisikan di kelas, kita perlu membuat beberapa objek. Kami mengedipkan dua LED, jadi kami akan memiliki satu objek untuk LED merah dan satu objek untuk LED hijau.

Untuk membuat objek, tulis nama kelasnya, lalu nama objeknya. Objek dapat diberi nama sesuka Anda. Dalam contoh ini kita membuat objek redLED() untuk LED merah, dan objek greenLED() untuk LED hijau. Setiap objek dipanggil melalui kelas MyClass:

#include <MyClass.h>
MyClass redLED(10);
MyClass greenLED(11);

Ketika kami mendefinisikan konstruktor MyClass di file sumber, kami meneruskan pin variabel publik ke sana. Jadi sekarang kita dapat menggunakan nomor pin Arduino sebagai argumen objek dan nomor pin tersebut akan diteruskan ke konstruktor. Dalam contoh ini, konstruktor kemudian akan mengatur mode pin dari pin 10 dan 11 sebagai output.

Sekarang kita bisa menulis bagiannya loop().

Kami akan mengedipkan LED merah dan LED hijau dengan fungsi myFunction()yang ditentukan dalam file sumber. Untuk menggunakan fungsi dari kelas atau pustaka, tulis nama objek, titik, lalu nama fungsi yang ingin Anda panggil:

#include <MyClass.h>
MyClass redLED(10);
MyClass greenLED(11);
void setup(){
}
void loop(){
	greenLED.myFunction(2000);
}

Ini akan memanggil fungsi myFunction() dari kelas MyClass dan menerapkannya ke objek greenLED.

Ketika kami mendefinisikan fungsi myFunction(), kami meneruskannya ke variabel blinkRate untuk mengontrol seberapa cepat LED akan berkedip. Dengan nilai 2000 sebagai argumen, fungsi delay() di dalam myFunction() akan ditunda selama 2000 milidetik.

Sekarang kita hanya perlu memanggil fungsi myFunction() pada objek redLED. LED merah akan berkedip dan mati selama 1000 milidetik:

#include <MyClass.h>
MyClass redLED(10);
MyClass greenLED(11);
void setup() {
}
void loop() {
  greenLED.myFunction(2000);
  redLED.myFunction(1000);
}

Hal hebat tentang menggunakan kelas dan objek adalah Anda dapat menggunakan kembali fungsi yang sama pada banyak objek. Ini membuat kode Anda lebih sederhana, lebih efisien dan lebih mudah digunakan orang lain juga.

Setelah Anda mengunggah sketsa, Anda akan melihat LED merah menyala dan mati sekali per detik dan LED hijau menyala dan mati setiap dua detik.

Sumber: Circuit Basics