Bahasa Pemrograman Arduino Part 1 - Dasar-Dasar Syntax dan Struktur

Tutorial lengkap bahasa pemrograman Arduino mulai dari syntax dasar, tipe data, operator, hingga struktur kontrol untuk pemula.

05-03-2025

04:53 18 Juni 2025

9 min read

Arduino

Bahasa pemrograman Arduino adalah versi sederhana dari C/C++ yang dirancang khusus untuk mikrokontroler. Memahami dasar-dasar bahasa ini adalah kunci untuk membuat program Arduino yang efektif dan efisien. Mari pelajari syntax, struktur, dan konsep fundamental dalam pemrograman Arduino!

Apa itu Bahasa Arduino?

Bahasa Arduino adalah subset dari C/C++ yang telah disederhanakan untuk pemrograman mikrokontroler. Bahasa ini menyediakan abstraksi yang memudahkan pemula untuk mulai programming tanpa harus memahami kompleksitas low-level programming.

Tujuan Pembelajaran

Setelah menyelesaikan tutorial ini, akan dipahami:

Struktur dasar program Arduino (setup dan loop)
Tipe data dan variabel dalam Arduino
Operator dan ekspresi matematika
Struktur kontrol (if, for, while)
Fungsi dasar dan parameter
Array dan string handling dasar
Konsep scope dan lifetime variabel

Struktur Dasar Program Arduino

1. Anatomy Program Arduino

Setiap program Arduino memiliki dua fungsi wajib:

1
void setup() {
2
  // Kode inisialisasi - dijalankan sekali
3
  // Setup pin modes, serial communication, variabel awal
4
}
5

6
void loop() {
7
  // Kode utama - dijalankan berulang-ulang
8
  // Logic utama program berada di sini
9
}

Fungsi setup() digunakan untuk inisialisasi, seperti mengatur pin mode dan memulai komunikasi serial. Fungsi loop() berisi kode yang akan dieksekusi berulang kali selama board aktif.

2. Preprocessor Directives

Preprocessor directives digunakan untuk mengimpor library atau mendefinisikan konstanta. Contoh:

1
#include <SoftwareSerial.h>  // Include library
2
#define LED_PIN 13           // Define konstanta
3
#define BAUD_RATE 9600       // Define nilai numerik
4

5
void setup() {
6
  // setup code
7
}
8

9
void loop() {
10
  // main code
11
}

Preprocessor directives harus diletakkan di bagian atas file sebelum kode lainnya. #include digunakan untuk mengimpor library, sedangkan #define untuk mendefinisikan konstanta yang akan digunakan di seluruh program.

3. Comments (Komentar)

Komentar digunakan untuk menjelaskan kode dan membuatnya lebih mudah dipahami. Ada dua jenis komentar dalam Arduino:

Single-line comment: Dimulai dengan // dan hanya berlaku untuk satu baris.
Multi-line comment: Dikelilingi oleh /* dan */, berguna untuk dokumentasi panjang atau menonaktifkan kode sementara.

Contoh penggunaan komentar:

1
// Single line comment
2

3
/*
4
  Multi-line comment
5
  Berguna untuk dokumentasi panjang
6
  atau temporary disable code
7
*/
8

9
void setup() {
10
  pinMode(13, OUTPUT);  // Set pin 13 sebagai output
11
}

Tipe Data Arduino

Tipe data dalam Arduino mirip dengan C/C++, tetapi disesuaikan untuk mikrokontroler. Berikut adalah tipe data yang umum digunakan:

1. Tipe Data Numerik

Tipe data numerik digunakan untuk menyimpan nilai angka. Ada beberapa jenis tipe data numerik:

Tipe Data	Ukuran	Rentang Nilai
`int`	16-bit	-32,768 hingga 32,767
`unsigned int`	16-bit	0 hingga 65,535
`long`	32-bit	-2,147,483,648 hingga 2,147,483,647
`unsigned long`	32-bit	0 hingga 4,294,967,295
`byte`	8-bit	0 hingga 255
`char`	8-bit	-128 hingga 127
`float`	32-bit	-3.4028235E+38 hingga 3.4028235E+38
`double`	64-bit	-1.7976931348623157E+308 hingga 1.7976931348623157E+308

Berikut adalah contoh penggunaan tipe data numerik dalam Arduino:

1
// Integer types
2
int sensorValue = 512;        // 16-bit signed integer (-32,768 to 32,767)
3
unsigned int distance = 1500; // 16-bit unsigned (0 to 65,535)
4
long timestamp = 123456789;   // 32-bit signed (-2,147,483,648 to 2,147,483,647)
5
unsigned long uptime = 0;     // 32-bit unsigned (0 to 4,294,967,295)
6

7
// Byte types
8
byte brightness = 255;        // 8-bit unsigned (0 to 255)
9
char letter = 'A';           // 8-bit signed (-128 to 127)
10

11
// Floating point
12
float temperature = 23.5;     // 32-bit floating point
13
double precision = 3.14159;   // 64-bit floating point (same as float on Arduino)

2. Boolean dan Konstanta

Boolean digunakan untuk menyimpan nilai logika (true/false). Konstanta adalah nilai yang tidak berubah selama program berjalan. Berikut adalah contoh penggunaan boolean dan konstanta:

1
// Boolean
2
bool ledState = true;
3
boolean isRunning = false;    // Sama dengan bool
4

5
// Constants
6
const int BUTTON_PIN = 2;     // Konstanta integer
7
const float PI = 3.14159;     // Konstanta float
8

9
// Arduino constants
10
HIGH, LOW                     // Digital values
11
INPUT, OUTPUT, INPUT_PULLUP   // Pin modes
12
true, false                   // Boolean values

3. Array dan String Dasar

Array digunakan untuk menyimpan kumpulan nilai dengan tipe data yang sama. String adalah array karakter yang diakhiri dengan null ('\0'). Berikut adalah contoh penggunaan array dan string:

1
// Array declaration
2
int sensorReadings[10];               // Array 10 integers
3
int pins[] = {2, 3, 4, 5};           // Array dengan nilai awal
4
char message[20];                     // Character array
5

6
// String types
7
String deviceName = "Arduino Uno";   // String object
8
char serialNumber[] = "ABC123";      // C-style string
9

10
// Multi-dimensional arrays
11
int matrix[3][3] = {
12
  {1, 2, 3},
13
  {4, 5, 6},
14
  {7, 8, 9}
15
};

Variabel dan Scope

Variabel dalam Arduino digunakan untuk menyimpan data yang dapat berubah selama eksekusi program. Variabel memiliki scope (jangkauan) yang menentukan di mana variabel tersebut dapat diakses.

1. Deklarasi Variabel

Variabel dalam Arduino dideklarasikan dengan menyebutkan tipe data diikuti dengan nama variabel. Berikut adalah contoh deklarasi variabel:

1
// Global variables (accessible everywhere)
2
int globalCounter = 0;
3
const int MAX_SENSORS = 5;
4

5
void setup() {
6
  // Local variables (only in setup)
7
  int setupValue = 100;
8
  Serial.begin(9600);
9
}
10

11
void loop() {
12
  // Local variables (only in loop)
13
  static int staticCounter = 0;  // Retains value between calls
14
  int localValue = analogRead(A0);
15

16
  staticCounter++;  // Increments each loop iteration
17
}

2. Variable Scope Rules

Scope variabel menentukan di mana variabel tersebut dapat diakses. Berikut adalah contoh penggunaan scope dalam Arduino:

1
int globalVar = 0;        // Global scope
2

3
void setup() {
4
  int localVar = 10;      // Local to setup()
5

6
  {
7
    int blockVar = 20;    // Local to this block only
8
    globalVar = 5;        // Can access global
9
  }
10
  // blockVar tidak accessible di sini
11
}
12

13
void customFunction() {
14
  // localVar tidak accessible di sini
15
  globalVar = 15;         // Can access global
16
}

Operator Arduino

Operator dalam bahasa Arduino digunakan untuk melakukan operasi pada variabel dan nilai. Ada beberapa jenis operator yang umum digunakan, termasuk operator aritmatika, perbandingan, logika, bitwise, dan lainnya.

1. Arithmetic Operators

Operator aritmatika digunakan untuk melakukan operasi matematika dasar seperti penjumlahan, pengurangan, perkalian, pembagian, dan modulo. Berikut adalah contoh penggunaan operator aritmatika dalam Arduino:

1
int a = 10, b = 3;
2

3
int sum = a + b;          // Addition (13)
4
int diff = a - b;         // Subtraction (7)
5
int product = a * b;      // Multiplication (30)
6
int quotient = a / b;     // Division (3)
7
int remainder = a % b;    // Modulo (1)
8

9
// Increment/Decrement
10
a++;                      // Post-increment
11
++a;                      // Pre-increment
12
b--;                      // Post-decrement
13
--b;                      // Pre-decrement

2. Comparison Operators

Operator perbandingan digunakan untuk membandingkan dua nilai dan menghasilkan nilai boolean (true atau false). Berikut adalah contoh penggunaan operator perbandingan dalam Arduino:

1
int x = 5, y = 10;
2

3
bool equal = (x == y);           // Equal to (false)
4
bool notEqual = (x != y);        // Not equal (true)
5
bool lessThan = (x < y);         // Less than (true)
6
bool greaterThan = (x > y);      // Greater than (false)
7
bool lessEqual = (x <= y);       // Less than or equal (true)
8
bool greaterEqual = (x >= y);    // Greater than or equal (false)

3. Logical Operators

Operator logika digunakan untuk menggabungkan atau membalik nilai boolean. Ada tiga operator logika utama: AND (&&), OR (||), dan NOT (!). Berikut adalah contoh penggunaannya:

1
bool a = true, b = false;
2

3
bool andResult = a && b;         // Logical AND (false)
4
bool orResult = a || b;          // Logical OR (true)
5
bool notResult = !a;             // Logical NOT (false)
6

7
// Practical example
8
if ((sensorValue > 100) && (sensorValue < 900)) {
9
  // Sensor dalam range normal
10
}

Struktur Kontrol

Struktur kontrol dalam bahasa Arduino digunakan untuk mengontrol alur eksekusi program berdasarkan kondisi tertentu. Ada beberapa jenis struktur kontrol yang umum digunakan, termasuk conditional statements (if-else), switch statement, dan loops (for, while, do-while).

1. Conditional Statements

Conditional statements digunakan untuk mengeksekusi blok kode tertentu berdasarkan kondisi yang diberikan.

1
// Basic if statement
2
if (sensorValue > 500) {
3
  digitalWrite(LED_PIN, HIGH);
4
}
5

6
// if-else statement
7
if (temperature > 25) {
8
  digitalWrite(FAN_PIN, HIGH);
9
} else {
10
  digitalWrite(FAN_PIN, LOW);
11
}
12

13
// if-else if-else chain
14
if (score >= 90) {
15
  grade = 'A';
16
} else if (score >= 80) {
17
  grade = 'B';
18
} else if (score >= 70) {
19
  grade = 'C';
20
} else {
21
  grade = 'F';
22
}
23

24
// Ternary operator
25
int status = (buttonPressed) ? 1 : 0;

2. Switch Statement

Switch statement digunakan untuk memilih salah satu dari beberapa blok kode yang akan dieksekusi berdasarkan nilai dari suatu variabel. Ini berguna ketika ada banyak kondisi yang perlu diperiksa.

1
int mode = 2;
2

3
switch (mode) {
4
  case 1:
5
    Serial.println("Mode 1: Basic");
6
    digitalWrite(LED1, HIGH);
7
    break;
8

9
  case 2:
10
    Serial.println("Mode 2: Advanced");
11
    digitalWrite(LED2, HIGH);
12
    break;
13

14
  case 3:
15
    Serial.println("Mode 3: Expert");
16
    digitalWrite(LED3, HIGH);
17
    break;
18

19
  default:
20
    Serial.println("Unknown mode");
21
    // Semua LED mati
22
    digitalWrite(LED1, LOW);
23
    digitalWrite(LED2, LOW);
24
    digitalWrite(LED3, LOW);
25
    break;
26
}

3. Loops

Loops digunakan untuk mengeksekusi blok kode berulang kali selama kondisi tertentu terpenuhi. Ada beberapa jenis loop yang umum digunakan dalam Arduino: for, while, dan do-while.

1
// For loop
2
for (int i = 0; i < 10; i++) {
3
  Serial.println(i);
4
  delay(100);
5
}
6

7
// While loop
8
int counter = 0;
9
while (counter < 5) {
10
  digitalWrite(13, HIGH);
11
  delay(500);
12
  digitalWrite(13, LOW);
13
  delay(500);
14
  counter++;
15
}
16

17
// Do-while loop
18
int attempts = 0;
19
do {
20
  int reading = analogRead(A0);
21
  if (reading > 512) {
22
    break;  // Exit loop jika kondisi terpenuhi
23
  }
24
  attempts++;
25
  delay(100);
26
} while (attempts < 10);
27

28
// For loop dengan array
29
int pins[] = {2, 3, 4, 5, 6};
30
for (int i = 0; i < 5; i++) {
31
  pinMode(pins[i], OUTPUT);
32
  digitalWrite(pins[i], HIGH);
33
}

Fungsi Dasar (Functions)

Fungsi dalam bahasa Arduino digunakan untuk mengelompokkan kode yang dapat digunakan kembali, membuat program lebih modular dan mudah dibaca. Fungsi dapat memiliki parameter, tipe pengembalian, dan dapat dipanggil dari bagian lain program.

1. Function Declaration dan Definition

Dalam Arduino, fungsi dideklarasikan dengan menyebutkan tipe pengembalian, nama fungsi, dan parameter (jika ada). Berikut adalah contoh deklarasi dan definisi fungsi:

1
// Function prototype (declaration)
2
void blinkLED(int pin, int duration);
3
int calculateAverage(int values[], int count);
4
bool isInRange(int value, int min, int max);
5

6
void setup() {
7
  Serial.begin(9600);
8
}
9

10
void loop() {
11
  blinkLED(13, 500);
12

13
  int sensors[] = {100, 200, 150, 175};
14
  int avg = calculateAverage(sensors, 4);
15
  Serial.println(avg);
16

17
  if (isInRange(avg, 100, 200)) {
18
    Serial.println("Average in normal range");
19
  }
20
}
21

22
// Function definitions
23
void blinkLED(int pin, int duration) {
24
  digitalWrite(pin, HIGH);
25
  delay(duration);
26
  digitalWrite(pin, LOW);
27
  delay(duration);
28
}
29

30
int calculateAverage(int values[], int count) {
31
  int sum = 0;
32
  for (int i = 0; i < count; i++) {
33
    sum += values[i];
34
  }
35
  return sum / count;
36
}
37

38
bool isInRange(int value, int min, int max) {
39
  return (value >= min && value <= max);
40
}

2. Function Parameters

Fungsi dapat menerima parameter untuk menerima input dari luar. Parameter dideklarasikan dalam tanda kurung setelah nama fungsi. Berikut adalah contoh penggunaan parameter dalam fungsi:

1
// Pass by value
2
void updateCounter(int counter) {
3
  counter++;  // Tidak mempengaruhi variabel asli
4
}
5

6
// Pass by reference (using pointers)
7
void updateCounterRef(int* counter) {
8
  (*counter)++;  // Mempengaruhi variabel asli
9
}
10

11
// Array parameters (always passed by reference)
12
void processArray(int arr[], int size) {
13
  for (int i = 0; i < size; i++) {
14
    arr[i] = arr[i] * 2;  // Mengubah array asli
15
  }
16
}
17

18
// Default parameters
19
void configurePin(int pin, int mode = OUTPUT) {
20
  pinMode(pin, mode);
21
}

Kesimpulan Part 1

Pada part pertama ini, kita telah mempelajari dasar-dasar bahasa pemrograman Arduino meliputi:

Struktur dasar program Arduino (setup dan loop)
Tipe data dan variabel
Operator dan operasi matematika
Struktur kontrol (if, switch, loops)
Fungsi dasar dan parameter

Konsep-konsep ini adalah fondasi yang penting untuk memahami programming Arduino. Pada part 2, kita akan melanjutkan dengan topik yang lebih advanced seperti array operations, memory management, interrupts, dan best practices.

Langkah Selanjutnya

Lanjutkan ke Part 2 untuk mempelajari:

Array dan String Operations yang lebih kompleks
Memory Management dan PROGMEM
Interrupts dan Timer
Error Handling dan Debugging
Best Practices dan Optimization
Troubleshooting dan Proyek Tantangan