Perbedaan int, unsigned int, dan long pada Arduino Uno yang Sering Menyebabkan Bug

Arduino Uno merupakan salah satu board mikrokontroler yang banyak digunakan dalam proyek elektronika, robotika, dan Internet of Things (IoT). Meskipun pemrogramannya terlihat sederhana, terdapat beberapa hal teknis yang sering menyebabkan kesalahan saat program dijalankan. Salah satunya adalah pemilihan tipe data yang kurang tepat, terutama ketika menggunakan int, unsigned int, dan long.
Ketiga tipe data tersebut memiliki fungsi untuk menyimpan nilai bilangan bulat. Namun, masing-masing mempunyai kapasitas penyimpanan dan rentang nilai yang berbeda. Kesalahan dalam memilih tipe data dapat menyebabkan hasil perhitungan tidak sesuai, nilai variabel berubah menjadi negatif, penghitung waktu mengalami kesalahan, hingga program menghasilkan perilaku yang sulit dipahami.
Masalah ini sering ditemukan ketika pengguna Arduino Uno membuat program yang melibatkan sensor, penghitung pulsa, pengukuran waktu, pembacaan ADC, atau operasi matematika dengan angka yang cukup besar.
Agar tidak mengalami masalah tersebut, penting untuk memahami perbedaan int, unsigned int, dan long pada Arduino Uno, termasuk cara penggunaannya yang benar dalam program Arduino IDE.

Mengenal Tipe Data pada Arduino Uno

Tipe data merupakan bagian penting dalam bahasa pemrograman C dan C++ yang digunakan oleh Arduino. Setiap variabel harus memiliki tipe data untuk menentukan jenis nilai yang dapat disimpan serta jumlah memori yang digunakan.
Pada Arduino Uno yang menggunakan mikrokontroler ATmega328P dengan arsitektur AVR 8-bit, ukuran beberapa tipe data berbeda dari komputer modern yang menggunakan prosesor 32-bit atau 64-bit.
Sebagai contoh, tipe data int pada komputer biasanya memiliki ukuran 32-bit, tetapi pada Arduino Uno hanya menggunakan 16-bit. Perbedaan ini sering menjadi sumber kesalahan ketika pengguna memindahkan kode program dari komputer atau platform mikrokontroler lain ke Arduino Uno.
Berikut beberapa tipe data bilangan bulat yang perlu diketahui :

• int: Digunakan untuk menyimpan bilangan bulat positif dan negatif.
• unsigned int: Digunakan untuk menyimpan bilangan bulat tanpa nilai negatif.
• long: Digunakan untuk menyimpan bilangan bulat dengan rentang lebih besar dibandingkan int.
• unsigned long: Digunakan untuk menyimpan bilangan bulat positif dengan rentang yang lebih besar.

Memahami karakteristik setiap tipe data akan membantu menghindari kesalahan perhitungan dan penggunaan memori dalam program Arduino.

Perbedaan Ukuran Memori dan Rentang Nilai int, unsigned int, dan long

Hal paling mendasar yang membedakan ketiga tipe data tersebut adalah ukuran memori dan rentang angka yang dapat disimpan.
Pada Arduino Uno berbasis ATmega328P, ukuran dan rentang nilainya adalah sebagai berikut :

Tipe Data	Ukuran	Rentang Nilai
int	16-bit (2 byte)	-32.768 sampai 32.767
unsigned int	16-bit (2 byte)	0 sampai 65.535
long	32-bit (4 byte)	-2.147.483.648 sampai 2.147.483.647
unsigned long	32-bit (4 byte)	0 sampai 4.294.967.295

Dari tabel tersebut, terlihat bahwa int dan unsigned int memiliki ukuran memori yang sama, tetapi rentang nilainya berbeda karena penggunaan bit tanda (sign bit).
Sementara itu, long menggunakan memori dua kali lebih besar dibandingkan int, sehingga dapat menyimpan angka yang jauh lebih besar.
Perbedaan tersebut sangat penting ketika membuat program yang membutuhkan perhitungan dengan nilai besar, seperti penghitung waktu, jumlah pulsa sensor, atau pengolahan data hasil pembacaan perangkat elektronik.

Mengenal Tipe Data int pada Arduino Uno

Tipe data int merupakan salah satu tipe data yang paling sering digunakan dalam pemrograman Arduino. Tipe ini dapat menyimpan bilangan bulat positif maupun negatif.
Pada Arduino Uno, int memiliki ukuran 16-bit atau 2 byte dengan rentang nilai antara -32.768 hingga 32.767.
Contoh penggunaannya :

Text/Code

int suhu = 25;
int tegangan = -12;
int jumlah = 1000;

void setup() {
  Serial.begin(9600);

  Serial.println(suhu);
  Serial.println(tegangan);
  Serial.println(jumlah);
}

void loop() {
}

Pada contoh tersebut, variabel suhu, tegangan, dan jumlah menggunakan tipe data int karena seluruh nilainya masih berada dalam rentang yang diperbolehkan.
Namun, tipe data int dapat menyebabkan masalah apabila digunakan untuk menyimpan angka yang melebihi batas maksimalnya.
Perhatikan contoh berikut :

Text/Code

int angka = 40000;

void setup() {
  Serial.begin(9600);
  Serial.println(angka);
}

void loop() {
}

Nilai 40.000 berada di luar rentang maksimum int pada Arduino Uno, yaitu 32.767.
Akibatnya, nilai yang disimpan tidak sesuai dengan angka yang dimasukkan. Pada implementasi AVR 16-bit, hasilnya dapat menjadi angka negatif karena terjadi pembungkusan nilai (wraparound).
Inilah salah satu penyebab bug yang sering tidak disadari ketika menggunakan tipe data int.

Mengenal Tipe Data unsigned int pada Arduino Uno

Berbeda dengan int, tipe data unsigned int hanya digunakan untuk menyimpan bilangan bulat nol dan positif.
Pada Arduino Uno, tipe data ini memiliki ukuran 16-bit atau 2 byte dengan rentang nilai antara 0 hingga 65.535.
Karena tidak menyediakan ruang untuk bilangan negatif, seluruh bit dapat digunakan untuk merepresentasikan nilai positif.
Contoh penggunaannya :

Text/Code

unsigned int jumlahPulsa = 50000;

void setup() {
  Serial.begin(9600);

  Serial.print("Jumlah Pulsa: ");
  Serial.println(jumlahPulsa);
}

void loop() {
}

Pada contoh tersebut, nilai 50.000 dapat disimpan dengan benar menggunakan unsigned int, meskipun angka tersebut sudah melewati batas maksimum tipe data int.
Tipe data ini cocok digunakan untuk menyimpan data yang tidak membutuhkan nilai negatif, misalnya :

• Jumlah pulsa dari sensor.
• Nilai penghitung objek.
• Jumlah putaran motor.
• Hasil perhitungan jumlah data.
• Nilai pembacaan yang selalu positif.

Namun, penggunaan unsigned int juga memiliki risiko tersendiri.
Perhatikan contoh berikut :

Text/Code

unsigned int angka = 10;

void setup() {
  Serial.begin(9600);

  angka = angka - 20;

  Serial.println(angka);
}

void loop() {
}

Secara matematis, hasil pengurangan 10 - 20 adalah -10. Akan tetapi, variabel unsigned int tidak dapat menyimpan angka negatif.
Pada Arduino Uno, hasilnya akan mengalami underflow dan membungkus ke nilai maksimum tipe data, sehingga hasil yang ditampilkan menjadi 65.526.
Kesalahan seperti ini sering menyebabkan program menghasilkan angka yang terlihat tidak masuk akal.
Oleh karena itu, gunakan unsigned int hanya ketika nilai variabel memang tidak membutuhkan bilangan negatif dan operasi matematikanya sudah diperhitungkan dengan benar.

Mengenal Tipe Data long pada Arduino Uno

Tipe data long digunakan ketika program membutuhkan penyimpanan bilangan bulat dengan rentang lebih besar dibandingkan int.
Pada Arduino Uno, long memiliki ukuran 32-bit atau 4 byte dengan rentang nilai -2.147.483.648 hingga 2.147.483.647.
Tipe data ini cocok digunakan dalam program yang melibatkan perhitungan angka besar, seperti akumulasi data sensor, penghitung pulsa dalam jumlah besar, dan perhitungan waktu.
Contoh penggunaannya :

Text/Code

long totalPulsa = 100000;

void setup() {
  Serial.begin(9600);

  Serial.print("Total Pulsa: ");
  Serial.println(totalPulsa);
}

void loop() {
}

Berbeda dengan int, variabel long dapat menyimpan angka 100.000 tanpa mengalami overflow.
Contoh lainnya :

Text/Code

long jarakTotal = 150000;
long jarakTambahan = 250000;
long hasil;

void setup() {
  Serial.begin(9600);

  hasil = jarakTotal + jarakTambahan;

  Serial.print("Total Jarak: ");
  Serial.println(hasil);
}

void loop() {
}

Hasil penjumlahan kedua variabel tersebut adalah 400.000 dan masih berada dalam rentang nilai tipe data long.
Meskipun memiliki kapasitas lebih besar, penggunaan long membutuhkan memori dua kali lebih banyak dibandingkan int.
Karena Arduino Uno hanya mempunyai SRAM sebesar 2 KB, pemilihan tipe data tetap harus mempertimbangkan kebutuhan memori program.

Perbedaan Penggunaan int, unsigned int, dan long dalam Operasi Matematika

Salah satu kesalahan yang sering terjadi pada pemrograman Arduino adalah menganggap bahwa hasil operasi matematika akan otomatis mengikuti tipe data variabel yang memiliki kapasitas paling besar.
Padahal, hasil operasi matematika ditentukan oleh aturan konversi tipe data dan tipe operand yang digunakan.
Perhatikan contoh berikut :

Text/Code

int angka1 = 20000;
int angka2 = 20000;

long hasil = angka1 + angka2;

void setup() {
  Serial.begin(9600);

  Serial.println(hasil);
}

void loop() {
}

Meskipun variabel hasil menggunakan tipe data long, operasi angka1 + angka2 terlebih dahulu dilakukan menggunakan tipe int.
Hasil penjumlahan 40.000 sudah berada di luar rentang int pada Arduino Uno. Dengan demikian, overflow dapat terjadi sebelum hasilnya disimpan ke variabel long.
Untuk memperbaikinya, lakukan konversi salah satu operand menjadi long sebelum operasi penjumlahan dilakukan.
Contoh perbaikannya :

Text/Code

int angka1 = 20000;
int angka2 = 20000;

long hasil;

void setup() {
  Serial.begin(9600);

  hasil = (long)angka1 + angka2;

  Serial.println(hasil);
}

void loop() {
}

Dengan menggunakan (long)angka1, operasi penjumlahan dilakukan menggunakan tipe data 32-bit sehingga hasil 40.000 dapat dihitung dengan benar.
Hal ini penting untuk diperhatikan ketika membuat program yang melibatkan perkalian, penjumlahan, pembagian, dan pengurangan dengan angka yang cukup besar.

Bug Overflow dan Underflow yang Sering Terjadi pada Arduino Uno

Overflow dan underflow merupakan dua masalah yang sering muncul akibat penggunaan tipe data yang tidak sesuai.
Overflow terjadi ketika hasil perhitungan melebihi batas maksimum tipe data yang digunakan.
Contohnya :

Text/Code

int nilai = 32767;

void setup() {
  Serial.begin(9600);

  nilai++;

  Serial.println(nilai);
}

void loop() {
}

Ketika nilai int mencapai 32.767 kemudian ditambah satu, nilainya membungkus menjadi -32.768 pada Arduino Uno.
Sementara itu, underflow terjadi ketika nilai perhitungan berada di bawah batas minimum tipe data atau ketika bilangan unsigned dikurangi hingga melewati nol.
Contoh underflow pada unsigned int :

Text/Code

unsigned int nilai = 0;

void setup() {
  Serial.begin(9600);

  nilai--;

  Serial.println(nilai);
}

void loop() {
}

Hasilnya adalah 65.535 karena nilai unsigned membungkus dari nol ke nilai maksimum.
Masalah ini dapat menyebabkan kesalahan pada sistem penghitung, pengaturan kecepatan motor, pengukuran sensor, dan pengolahan data.
Untuk menghindarinya, pastikan nilai variabel tidak melewati batas rentang tipe data yang digunakan.

Kesalahan Penggunaan Tipe Data pada Fungsi millis()

Fungsi millis() merupakan fungsi bawaan Arduino yang digunakan untuk mengetahui jumlah waktu dalam milidetik sejak board mulai menjalankan program.
Fungsi ini mengembalikan nilai bertipe unsigned long, sehingga variabel penampungnya sebaiknya juga menggunakan tipe data unsigned long.
Kesalahan yang sering terjadi adalah menggunakan int untuk menyimpan hasil millis().
Contoh kode yang salah :

Text/Code

int waktuSebelumnya = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int waktuSekarang = millis();

  if (waktuSekarang - waktuSebelumnya >= 1000) {
    waktuSebelumnya = waktuSekarang;

    Serial.println("1 detik berlalu");
  }
}

Kode tersebut bermasalah karena nilai millis() terus bertambah dan dapat melewati batas maksimum int hanya dalam waktu sekitar 32,768 detik.
Akibatnya, pengukuran waktu dapat menghasilkan nilai yang tidak sesuai.
Cara yang benar adalah menggunakan unsigned long :

Text/Code

unsigned long waktuSebelumnya = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  unsigned long waktuSekarang = millis();

  if (waktuSekarang - waktuSebelumnya >= 1000UL) {
    waktuSebelumnya = waktuSekarang;

    Serial.println("1 detik berlalu");
  }
}

Penggunaan unsigned long membuat program dapat mengukur waktu dengan benar, termasuk ketika penghitung millis() mengalami rollover setelah sekitar 49,7 hari.
Perhatikan juga bahwa pengurangan dua nilai unsigned long seperti contoh di atas merupakan pola yang tepat untuk mengukur selang waktu selama interval yang dibandingkan masih berada dalam batas yang dapat direpresentasikan.

Contoh Bug Perhitungan Sensor akibat Salah Memilih Tipe Data

Kesalahan pemilihan tipe data juga dapat terjadi ketika Arduino Uno digunakan untuk membaca sensor analog melalui pin A0 hingga A5.
Fungsi analogRead() pada Arduino Uno menghasilkan nilai antara 0 hingga 1023. Nilai tersebut masih aman disimpan menggunakan int atau unsigned int.
Namun, masalah dapat muncul ketika nilai sensor digunakan dalam perhitungan yang menghasilkan angka lebih besar.
Contohnya :

Text/Code

int nilaiSensor = 1023;
int faktorPengali = 100;

long hasil;

void setup() {
  Serial.begin(9600);

  hasil = nilaiSensor * faktorPengali;

  Serial.print("Hasil Perhitungan: ");
  Serial.println(hasil);
}

void loop() {
}

Pada contoh tersebut, hasil perkalian 1023 × 100 adalah 102.300.
Namun, kedua operand menggunakan tipe int, sehingga operasi perkalian dilakukan dalam tipe 16-bit sebelum disimpan ke variabel long.
Hal ini dapat menyebabkan overflow.
Untuk memperbaikinya, gunakan konversi tipe data :

Text/Code

int nilaiSensor = 1023;
int faktorPengali = 100;

long hasil;

void setup() {
  Serial.begin(9600);

  hasil = (long)nilaiSensor * faktorPengali;

  Serial.print("Hasil Perhitungan: ");
  Serial.println(hasil);
}

void loop() {
}

Dengan mengubah salah satu operand menjadi long, hasil perkalian dapat dihitung dengan kapasitas 32-bit.
Contoh ini menunjukkan bahwa memilih tipe data pada variabel hasil saja belum tentu cukup. Tipe data operand dalam operasi matematika juga harus diperhatikan.

Cara Memilih Tipe Data yang Tepat untuk Program Arduino Uno

Agar tidak mengalami bug akibat kesalahan tipe data, pemilihan variabel harus disesuaikan dengan kebutuhan program.
Berikut beberapa panduan yang dapat digunakan :
Gunakan int apabila :

• Nilai variabel berada antara -32.768 hingga 32.767.
• Program membutuhkan bilangan positif dan negatif.
• Perhitungan tidak menghasilkan angka di luar rentang 16-bit.

Gunakan unsigned int apabila :

• Nilai variabel hanya nol atau positif.
• Nilai maksimum tidak melebihi 65.535.
• Program membutuhkan penghitung dengan rentang positif yang lebih besar daripada int.

Gunakan long apabila :

• Nilai variabel dapat melebihi 32.767.
• Program membutuhkan bilangan positif dan negatif dalam rentang yang lebih besar.
• Perhitungan melibatkan perkalian atau akumulasi angka besar.

Gunakan unsigned long apabila :

• Program membutuhkan penghitung waktu menggunakan millis().
• Variabel menyimpan nilai yang tidak negatif.
• Program membutuhkan rentang nilai positif hingga 4.294.967.295.

Selain itu, biasakan memeriksa ukuran tipe data menggunakan fungsi sizeof().
Contoh :

Text/Code

void setup() {
  Serial.begin(9600);

  Serial.print("Ukuran int: ");
  Serial.println(sizeof(int));

  Serial.print("Ukuran unsigned int: ");
  Serial.println(sizeof(unsigned int));

  Serial.print("Ukuran long: ");
  Serial.println(sizeof(long));

  Serial.print("Ukuran unsigned long: ");
  Serial.println(sizeof(unsigned long));
}

void loop() {
}

Pada Arduino Uno, hasilnya akan menunjukkan bahwa int dan unsigned int menggunakan 2 byte, sedangkan long dan unsigned long menggunakan 4 byte.
Cara ini berguna untuk memeriksa ukuran tipe data ketika memindahkan program dari Arduino Uno ke board lain.

Praktik Terbaik Menghindari Bug Tipe Data pada Arduino Uno

Selain memahami perbedaan ukuran dan rentang nilai, terdapat beberapa praktik pemrograman yang dapat membantu mengurangi kesalahan akibat penggunaan tipe data.

1. Periksa rentang nilai sebelum menentukan tipe data
   

   Sebelum membuat variabel, tentukan nilai minimum dan maksimum yang mungkin dihasilkan oleh program. Jangan memilih tipe data hanya berdasarkan angka awal yang digunakan.

2. Perhatikan tipe data hasil operasi matematika
   

   Jangan langsung menganggap variabel hasil bertipe long akan membuat semua perhitungan menggunakan kapasitas 32-bit. Pastikan operand juga dikonversi jika diperlukan.

3. Gunakan akhiran UL untuk konstanta unsigned long
   

   Contohnya :
   
   Text/Code

   unsigned long interval = 1000UL;

   Akhiran UL membantu memastikan konstanta diperlakukan sebagai unsigned long.

4. Hindari mencampur tipe data signed dan unsigned tanpa alasan
   

   Operasi yang mencampurkan int dan unsigned int dapat menghasilkan konversi tipe yang tidak terduga, terutama ketika salah satu nilainya negatif.

5. Periksa hasil perhitungan melalui Serial Monitor
   

   Gunakan Serial.print() dan Serial.println() untuk memeriksa nilai variabel selama program berjalan. Cara ini membantu menemukan overflow, underflow, dan kesalahan konversi tipe data.

6. Perhatikan penggunaan memori SRAM
   

   Arduino Uno hanya memiliki SRAM sebesar 2 KB. Oleh karena itu, gunakan tipe data sesuai kebutuhan agar penggunaan memori tetap efisien.

7. Lakukan pengujian pada nilai batas
   

   Uji program menggunakan nilai minimum, maksimum, serta nilai yang berada di sekitar batas tipe data. Misalnya, 32.767, 32.768, 65.535, dan 65.536.
   Pengujian ini membantu memastikan program tetap menghasilkan perhitungan yang benar ketika menghadapi nilai ekstrem.

Kesimpulan

Perbedaan int, unsigned int, dan long pada Arduino Uno terletak pada ukuran memori, rentang nilai, serta kemampuan masing-masing tipe data dalam menyimpan bilangan bulat.
Tipe data int menggunakan 2 byte dan dapat menyimpan angka antara -32.768 hingga 32.767. Sementara itu, unsigned int juga menggunakan 2 byte, tetapi memiliki rentang 0 hingga 65.535 karena tidak mendukung bilangan negatif.
Berbeda dengan keduanya, long menggunakan 4 byte dan dapat menyimpan angka antara -2.147.483.648 hingga 2.147.483.647.
Kesalahan memilih tipe data dapat menyebabkan overflow, underflow, hasil perhitungan yang tidak sesuai, serta bug pada fungsi pengukuran waktu seperti millis().
Oleh karena itu, penting untuk menyesuaikan tipe data dengan rentang nilai yang dibutuhkan program. Perhatikan juga tipe data operand ketika melakukan operasi matematika agar hasil perhitungan tidak mengalami overflow sebelum disimpan ke variabel tujuan.
Dengan memahami karakteristik setiap tipe data dan menerapkan praktik pemrograman yang benar, program Arduino Uno dapat berjalan lebih stabil, akurat, dan terhindar dari kesalahan perhitungan yang sering tidak disadari.

Catatan teknis: Artikel ini menggunakan karakteristik tipe data Arduino Uno ATmega328P (AVR 8-bit). Contoh kode juga disesuaikan dengan perilaku operasi bilangan bulat pada platform tersebut, bukan ukuran tipe data pada komputer atau board Arduino lain.

Baca Juga :

• Penyebab Hasil Perhitungan Arduino Uno Berbeda dari Hasil Kalkulator 
• Cara Memisahkan Data Sensor Arduino yang Dikirim dalam Format CSV 
• Penyebab Nilai Variabel Arduino Berubah Setelah Operasi Aritmetika 
• Mengapa Variabel byte Arduino Kembali ke Nol Setelah Mencapai 255? 
• Perhitungan Waktu Arduino Bermasalah Saat Menggunakan millis() 
• Cara Mengatasi String Arduino Kosong Saat Menerima Data Serial 
• Cara Mengatasi Warning Konversi Tipe Data pada Arduino IDE 
• Bug Arduino Akibat Konversi Tipe Data dari float ke int 
• Perbedaan Ukuran Tipe Data int pada Arduino Uno dan Komputer Windows 
• Penyebab Data Serial Arduino Hilang Saat Menggunakan delay() 
• Penyebab Program Python Membaca Data Serial Arduino Secara Tidak Konsisten 
• Cara Mengatasi Data Serial Arduino Terpotong Saat Mengirim String Panjang 
• Cara Mengatasi Kesalahan Perhitungan Akibat Integer Promotion pada Arduino C++
• Arduino Uno Mati Total Setelah Salah Memberikan Tegangan 
• Arduino Uno Menyala Tapi Program Tidak Berjalan 
• Cara Flash Bootloader Arduino Uno 
• Cara Mengecek IC ATmega328P Arduino Uno 
• Cara Mengetahui Pin Arduino Uno Rusak atau Tidak 
• Cara Mengatasi LCD I2C Arduino Uno Tidak Menampilkan Tulisan 
• Penyebab Arduino Uno Tidak Bisa Membaca Sensor 
• Penyebab Arduino Uno Sering Reset Sendiri 
• Cara Mengatasi CH340 Arduino Uno Tidak Muncul di Device Manager 
• Cara Mengatasi Error "stk500_recv" pada Arduino Uno

FAQ: Perbedaan int, unsigned int, dan long pada Arduino Uno yang Sering Menyebabkan Bug

Apa perbedaan int, unsigned int, dan long pada Arduino Uno?

Perbedaan utama terletak pada ukuran memori dan rentang nilai yang dapat disimpan. Pada Arduino Uno, int dan unsigned int menggunakan 2 byte, sedangkan long menggunakan 4 byte. Tipe int mendukung bilangan negatif dan positif, unsigned int hanya bilangan nol dan positif, sedangkan long dapat menyimpan bilangan negatif dan positif dengan rentang lebih besar.

Berapa rentang nilai int pada Arduino Uno?

Tipe data int pada Arduino Uno memiliki ukuran 16-bit atau 2 byte dengan rentang nilai -32.768 hingga 32.767. Jika nilai yang disimpan melebihi batas tersebut, program dapat mengalami overflow sehingga hasilnya tidak sesuai dengan angka yang diharapkan.

Berapa nilai maksimum unsigned int pada Arduino Uno?

Nilai maksimum unsigned int pada Arduino Uno adalah 65.535, sedangkan nilai minimumnya adalah 0. Tipe data ini cocok digunakan untuk menyimpan jumlah pulsa, penghitung objek, dan nilai lain yang tidak membutuhkan bilangan negatif.

Berapa ukuran memori tipe data long pada Arduino Uno?

Tipe data long pada Arduino Uno menggunakan memori sebesar 4 byte atau 32-bit. Rentang nilainya adalah -2.147.483.648 hingga 2.147.483.647 sehingga cocok untuk menyimpan angka yang lebih besar daripada kapasitas tipe data int.

Mengapa int pada Arduino Uno hanya memiliki rentang -32.768 sampai 32.767?

Arduino Uno menggunakan mikrokontroler ATmega328P dengan arsitektur AVR 8-bit. Pada platform ini, tipe data int memiliki ukuran 16-bit atau 2 byte. Satu bit digunakan sebagai bit tanda, sedangkan bit lainnya digunakan untuk merepresentasikan nilai bilangan.

Apa yang terjadi jika nilai int melebihi 32.767 pada Arduino Uno?

Jika nilai int melebihi batas maksimum 32.767, akan terjadi overflow. Pada Arduino Uno, nilai tersebut dapat membungkus menjadi bilangan negatif. Contohnya, ketika variabel int bernilai 32.767 kemudian ditambah satu, hasilnya menjadi -32.768.

Apa penyebab unsigned int menghasilkan angka besar ketika dikurangi sampai negatif?

Hal tersebut terjadi karena unsigned int tidak dapat menyimpan bilangan negatif. Ketika nilai nol dikurangi satu, terjadi underflow sehingga nilai membungkus ke batas maksimum tipe data, yaitu 65.535 pada Arduino Uno.

Mengapa hasil penjumlahan int bisa salah meskipun variabel hasil menggunakan long?

Hal ini terjadi karena operasi matematika dilakukan berdasarkan tipe data operand terlebih dahulu. Jika kedua operand menggunakan int, perhitungan dapat mengalami overflow sebelum hasilnya disimpan ke variabel long. Solusinya adalah mengonversi salah satu operand menjadi long sebelum operasi dilakukan.

Mengapa fungsi millis() harus menggunakan unsigned long pada Arduino Uno?

Fungsi millis() mengembalikan nilai bertipe unsigned long. Penggunaan tipe data yang sama pada variabel penampung membantu mencegah overflow terlalu cepat. Jika menggunakan int, nilai penghitung waktu akan melewati batas maksimum dalam waktu sekitar 32,768 detik.

Apa perbedaan long dan unsigned long pada Arduino Uno?

Keduanya memiliki ukuran memori 4 byte atau 32-bit, tetapi rentang nilainya berbeda. long dapat menyimpan bilangan negatif dan positif dari -2.147.483.648 hingga 2.147.483.647, sedangkan unsigned long hanya menyimpan bilangan nol dan positif dari 0 hingga 4.294.967.295.

Bagaimana cara mengetahui ukuran tipe data int, unsigned int, dan long pada Arduino Uno?

Gunakan fungsi sizeof() untuk mengetahui ukuran memori setiap tipe data. Contohnya, sizeof(int), sizeof(unsigned int), dan sizeof(long). Hasilnya dapat ditampilkan melalui Serial Monitor menggunakan Serial.println().

Bagaimana cara menghindari bug overflow dan underflow pada program Arduino Uno?

Gunakan tipe data sesuai rentang nilai yang dibutuhkan, perhatikan tipe data operand dalam operasi matematika, hindari konversi signed dan unsigned yang tidak tepat, serta lakukan pengujian pada nilai minimum dan maksimum. Gunakan Serial Monitor untuk memeriksa hasil perhitungan dan mendeteksi kesalahan selama program berjalan.

Share This Article