Polling adalah metode di mana program secara terus-menerus memeriksa status atau data dari suatu perangkat perifer atau sumber data. Dalam polling, CPU secara berkala melakukan kueri atau pemeriksaan pada perangkat atau data tersebut untuk memastikan apakah perangkat tersebut siap atau data telah berubah.
Dalam konteks mikrokontroler atau mikroprosesor, polling biasanya digunakan untuk memantau status perangkat perifer seperti tombol, sensor, atau input/output digital. CPU akan terus memeriksa status perangkat tersebut dan mengambil tindakan yang sesuai berdasarkan kondisi yang ditemukan.
Contoh sederhana polling adalah membaca tombol pada papan Arduino:
```cpp
void setup() {
pinMode(2, INPUT); // Konfigurasi pin 2 sebagai input
Serial.begin(9600);
}
void loop() {
// Polling status tombol
int buttonState = digitalRead(2);
if (buttonState == HIGH) {
Serial.println("Tombol ditekan!");
}
delay(100); // Jeda polling
}
```
Dalam contoh di atas, program secara terus-menerus memeriksa status pin 2 untuk melihat apakah tombol ditekan atau tidak. Jika tombol ditekan (nilai HIGH), maka akan dicetak pesan.
Meskipun polling mudah diimplementasikan, ia memiliki beberapa kelemahan. Pertama, polling menghabiskan sumber daya CPU karena CPU harus terus menerus memeriksa status perangkat. Kedua, polling dapat menghasilkan jeda waktu atau keterlambatan dalam merespons perubahan. Dalam beberapa kasus, seperti pembacaan sensor yang harus cepat dan akurat, polling mungkin kurang efektif dibandingkan dengan metode lain seperti interrupt atau DMA (Direct Memory Access).
Polling Vs Intterupt Vs DMA
Tentu! Berikut contoh program sederhana yang membandingkan penggunaan polling, interrupt, dan DMA dalam konteks pembacaan tombol pada papan Arduino.
**Contoh Program Polling:**
```cpp
const int buttonPin = 2;
int buttonState = 0;
void setup() {
pinMode(buttonPin, INPUT);
Serial.begin(9600);
}
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
Serial.println("Tombol ditekan (Polling)!");
}
}
```
**Contoh Program Interrupt:**
```cpp
const int buttonPin = 2;
void setup() {
pinMode(buttonPin, INPUT);
attachInterrupt(digitalPinToInterrupt(buttonPin), buttonInterrupt, CHANGE);
Serial.begin(9600);
}
void loop() {
// Tidak ada kode yang dieksekusi di loop karena menggunakan interrupt
}
void buttonInterrupt() {
int buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
Serial.println("Tombol ditekan (Interrupt)!");
}
}
```
**Contoh Program DMA:**
Sayangnya, Arduino tidak memiliki dukungan DMA secara langsung. Oleh karena itu, contoh program DMA tidak akan berlaku untuk platform Arduino.
Namun, saya dapat memberikan contoh konsepnya menggunakan platform ESP32 yang mendukung DMA:
```cpp
#include <Arduino.h>
#include <driver/dac.h>
#include <esp32-hal-dma.h>
#define BUFFER_SIZE 1024
uint16_t sineWave[BUFFER_SIZE];
void setup() {
Serial.begin(115200);
dac_output_enable(DAC_CHANNEL_1);
dmaChannelAllocate(1);
dmaSetPeriph(1, sineWave);
dmaSetTransferSize(1, BUFFER_SIZE * 2);
dmaSetBurst(1, 1, 1);
dmaSetIncrement(1, true);
dmaSetTrigger(1, DAC1_DMA);
dmaStart(1);
for (int i = 0; i < BUFFER_SIZE; i++) {
sineWave[i] = 2047 + 2047 * sin(2 * PI * i / BUFFER_SIZE);
}
}
void loop() {
// Tidak ada kode yang dieksekusi di loop karena menggunakan DMA
}
```
**Perbandingan:**
- **Polling**: Dalam program polling, CPU terus memeriksa status tombol secara terus-menerus, yang dapat menghabiskan sumber daya CPU dan menghasilkan keterlambatan dalam merespons perubahan tombol.
- **Interrupt**: Dalam program interrupt, CPU hanya akan dieksekusi ketika terjadi perubahan pada tombol. Hal ini mengurangi beban CPU dan menghasilkan respons yang lebih cepat.
- **DMA**: Dalam contoh program DMA, transfer data seperti pada sinewave dilakukan oleh DMA tanpa campur tangan CPU. Ini mengurangi beban CPU dan memungkinkan transfer data yang lebih cepat dan efisien.
Saat memilih metode yang tepat, pertimbangkan tujuan aplikasi, efisiensi sumber daya, dan waktu respons yang diperlukan. Interrupt dan DMA seringkali lebih efektif dalam menghadapi situasi yang memerlukan respons yang cepat dan efisien.
Contoh program on-off led memakai dma
Arduino Uno, yang paling umum digunakan, tidak memiliki dukungan DMA. Oleh karena itu, saya tidak dapat memberikan contoh program menggunakan DMA pada Arduino Uno. DMA lebih umum ditemukan pada mikrokontroler yang lebih canggih dan kuat seperti STM32, ESP32, atau beberapa varian mikrokontroler PIC.
Jika Anda ingin melihat contoh penggunaan DMA pada platform seperti ESP32, berikut adalah contoh sederhana untuk mengendalikan LED menggunakan DMA:
```cpp
#include <Arduino.h>
#include <driver/gpio.h>
#include <esp32-hal-dma.h>
#define LED_PIN 2
#define BUFFER_SIZE 32
volatile uint8_t ledBuffer[BUFFER_SIZE];
dma_channel_t dmaChannel;
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
for (int i = 0; i < BUFFER_SIZE; i++) {
ledBuffer[i] = (i % 2 == 0) ? HIGH : LOW;
}
dmaChannel = dmaAttachPin(LED_PIN);
dmaChannelAllocate(dmaChannel);
dmaSetPeriph(dmaChannel, ledBuffer);
dmaSetTransferSize(dmaChannel, BUFFER_SIZE);
dmaSetBurst(dmaChannel, 1, 1);
dmaSetIncrement(dmaChannel, true);
dmaSetTrigger(dmaChannel, DAC1_DMA);
dmaStart(dmaChannel);
}
void loop() {
// Tidak ada yang dieksekusi di loop karena DMA mengendalikan LED
}
```
Dalam contoh ini, DMA digunakan untuk mengendalikan LED yang terhubung ke pin 2. DMA akan mengubah status LED (on-off) berdasarkan data yang ada dalam buffer. Karena Arduino Uno tidak mendukung DMA, contoh ini hanya relevan jika Anda menggunakan mikrokontroler seperti ESP32 yang mendukung DMA.
Pastikan untuk merujuk pada dokumentasi resmi ESP32 dan datasheet mikrokontroler Anda untuk memahami penggunaan DMA dalam konteks yang tepat.
0 Response to "Program Arduino: Polling Vs Interrupt Vs DMA"
Posting Komentar