Arduino Basic

APA ITU ARDUINO ?
Arduino merupakan mikrokontroller Atmel AVR yang dimodifikasi
sehingga pemrogramannya menjadi lebih “mudah”
“Arduino is an open-source prototyping platform based on easy-to-
use hardware and software”
Dikarenakan menggunakan Atmel AVR maka kemampuan dari
Arduino mengikuti dari chip AVR yang menempel pada board
ARDUINO merupakan AVR yang dimodifikasi bootloadernya sehingga
bekerja dengan environment baru ( Dapat deprogram dengan serial)

APA ITU ARDUINO ?
ARDUINO merupakan mikrokontroller sehingga peruntukannya lebih
mengacu pada MACHINE FRIENDLY tetapi karena disediakan banyak
sekali library dan pihak developer berusaha untuk membuat kode
mudah dipahami namun hal ini berimbas pada “ketidakpahaman user
terhadap mikrokontroller secara mendalam”
ARDUINO memiliki IDE dengan Bahasa C, menggunakan avr gcc

DEVELOPMENT
Web : https://www.arduino.cc/
Software IDE : https://www.arduino.cc/en/Main/Software
Library Arduino : https://www.arduino.cc/en/Reference/Libraries
Arduino Shield : https://www.arduino.cc/en/Main/ArduinoShields

FITUR ARDUINO UNO
14 Pin I/O
16 MHz Clock
Power Jack
Memori Flash 32 KB ( 0.5 KB untuk bootloader), 2 KB SRAM, 1 KB
EEPROM
Komunikasi Serial pada pin 0(RX) dan 1(TX)
EXT INTERRUPT pada pin 2 dan 3
PWM pada pin 3,5,6,9,10,11 -> 8 bit PWM
LED pada pin 13
6 INPUT ANALOG

PROGRAM
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
}

I/O - OUTPUT
SETUP :
pinMode(ledPin, OUTPUT);
Ex :
pinMode(0, OUTPUT);
CODE :
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin, LOW);

BLINKING LED
int ledPin = 13; // LED connected to digital pin 13
void setup()
{
pinMode(ledPin, OUTPUT); // sets the digital pin as output
}
void loop()
{
digitalWrite(ledPin, HIGH); // sets the LED on
delay(1000); // waits for a second
digitalWrite(ledPin, LOW); // sets the LED off
}

I/O READ
pullup resistor (to +5V), or a pulldown resistor (resistor to ground) on
the input. A 10K resistor is a good value for a pullup or pulldown
resistor.
SETUP :
pinMode(inPin, INPUT);
Ex :
pinMode(0, INPUT);
CODE :
digitalRead(inPin);

CAPTURE PUSH BUTTON
int InPin = 7;
int data;
void setup()
{
pinMode(InPin, INPUT); // sets the digital pin as output
}
void loop()
{
data=digitalRead(InPin);
digitalWrite(ledPin, data); // sets the LED on
}

SERIAL
SETUP :
Serialx.begin(baud_rate);
Baud Rate merupakan kecepatan pengiriman data
Pilihan Baud rate :
300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400,
57600, dan 115200
x merupakan serial yang dipakai. Pada uno hanya terdapat 1 buah
serial. Untuk serial 0 maka angka 0 tidak perlu ditulis sehingga setup
menjadi
Serial.begin(baud_rate);

MENGIRIM DATA DENGAN SERIAL
CODE :
Serial.print(“text");
Serial.println(“text"); => print disertai dengan newline

SERIAL SEND EXAMPLE
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print(“hello world!!!”);
Delay(500);
}

SERIAL READ
Untuk mengetahui apakah terjadi pengiriman data ke Arduino maka
dapat diketahui dengan melakukan cek pada Serialx.available() > 0
CODE :
if (Serialx.available() > 0){
char = char(Serialx.read());
}
* x disesuaikan dengan serial yang dipakai

SERIAL READ – MULTIPLE
CHARACTER
Untuk menerima banyak karakter maka program perlu mengecek secara
terus menerus apakah Serialx.available() > 0. Selama nilai tersebut > 0 maka
data akan terus dimasukan kedalam string
CODE :
String cmd = "";
if (Serial1.available() > 0){
while (Serial1.available() > 0){
cmd += char(Serial1.read()); // memasukan setiap character
kedalam string
delay(1); // untuk baud rate 115200
}
}

SERIAL READ – PARSE / SPLIT DATA
FUNCTION :
String getValue(String data, char separator, int index)
{
int found = 0;
int strIndex[] = { 0, -1 };
int maxIndex = data.length() - 1;
for (int i = 0; i <= maxIndex && found <= index; i++){
if (data.charAt(i) == separator || i == maxIndex){
found++;
strIndex[0] = strIndex[1] + 1;
strIndex[1] = (i == maxIndex) ? i + 1 : i;
}
}
return found>index ? data.substring(strIndex[0], strIndex[1]) : "";
}

SERIAL READ – PARSE / SPLIT DATA
CODE :
String cmd = "";
if (Serial1.available() > 0){
while (Serial1.available() > 0){
cmd += char(Serial1.read());
delay(1);
}
}
String index0 = getValue(cmd, ':', 0);

TIMER - INTERRUPT
Tidak ada library resmi dari Arduino namun beberapa library support
dapat digunakan seperti library pada URL :
https://github.com/JChristensen/Timer
Namun dengan menggunakan library yang tidak resmi Arduino maka
beberapa konsekuensi seperti bugs tidak dapat dihindarkan untuk itu
perlu menggunakan “TRUE C AVR”
Pada Arduino semua timer dikonfigurasi menjadi output pwm, untuk
itu perlu melakukan setting / konfigurasi

PWM CAN’T BE USED ?
Penggunaan timer0, timer1 dan timer2 dapat menggangu pin PWM
pada ARDUINO sehingga perlu menyesuaikan pin mana saja yang
memanfaatkan timer tersebut dan mana yang tidak.
timer-0 terhubung dengan pin 5, 6

TIMER – INTERRUPT CTC
Pada AVR Atmega 328 yang dipakai oleh ARDUINO terdapat 3 buah
timer yaitu timer 0, timer 1 dan timer2 dan setiap timer terdapat
counter yang mencacah. Dengan mode CTC/ Clear Timer on
Compare, Saat angka cacahan mencapai titik tertentu maka terjadi
yang disebut trigger event atau update event atau overflow event.
Event ini dapat kita pakai untuk menimbulkan interrupt.
Diperlukan beberapa konfigurasi pada address tertentu agar timer
dapat berjalan.

ARDUINO bekerja pada 16 MHz yang artinya setiap instruksi di
jalankan setiap 1/16000000 atau (~63ns) per instruksi yang artinya
juga bahwa cacahan dari timer akan mencapai nilai 9 pada detik ke
10/16000000 (Mulai dari 0)
Dalam beberapa kejadian proses cacahan ini terlalu cepat. Maka
dibutuhkan prescaler yang bertujuan untuk membagi 16 MHz ke
dalam beberapa bagian. Terdapat 5 mode prescaler yaitu 1, 8, 64,
256, and 1024
Artinya jika prescaler yang digunakan 8 maka 16000000 akan dibagi
dengan 8 sehingga kecepatan dari timer berada pada 2MHz

Langkah selanjutnya menentukan CTC value. Untuk menentukannya
dapat menggunakan rumus :
compare match register = [ 16,000,000Hz/ (prescaler * desired
interrupt frequency) ] – 1
Nilai dari CTC untuk timer0 dan timer2 adalah 8 Bit yang artinya
diantara 0 – 255
Nilai dari CTC untuk timer1 adalah 16 bit yang artinya diantara 0 -
65536

TIMER0 DAN TIMER2– BLOCK
DIAGRAM

TIMER0 –OCR0
Terdapat 2 buah OCR0 yaitu OCR0A dan OCR0B
Nilai OCR ini yang akan diisi sebagai compare dari CTC

TIMER0 – TCCR0
Perlu konfigurasi agar timer diaktifkan sebagai mode CTC. Pada timer0 terdapat
register TCCR0 yang berisi beberapa value yang perlu disetting agar menyalakan mode
CTC
TCCR0A =0;
TCCR0B =0;
TCCR0A |= (1 << WGM01); // membuat nilai WGM01 menjadi 1
TCCR0B |= (1 << CS02) | (1 << CS00); // Pemilihan prescaler 1024

TIMER0 – TCNT0
TCNT0 adalah register yang berfungsi menyimpan nilai cacahan dari
counter timer 0. Pada konfigurasi perlu untuk diset TCNT0 = 0;
TCNT0 dapat menampung data 8 bit

TIMER0 – INTERRUPT MASK
Untuk mengaktif mode CTC sebagai mode interrupt maka perlu
dilakukan konfigurasi pada interrupt mask
TIMSK0 |= (1 << OCIE0A); // menggunakan OCR0A compare
TIMSK0 |= (1 << OCIE0B); // menggunakan OCR0B compare
TIMSK0 |= (1 << TOIE0); // menggunakan overflow event

TIMER0 – INTERRUPT HANDLER
Dalam interrupt diperlukan sebuah handler yang menangani event
interrupt tersebut. Fungsi tersebut diletakan pada function ISR
Function :
ISR(TIMER0_COMPA_vect){
//your interrupt code here
}
Function :
ISR(TIMER0_COMPB_vect){
}

CONTOH KONFIGURASI
Timer mengunakan timer 0 dengan interrupt CTC setiap 2 ms
Frekuensi interrupt = 1/(2 * 10^-3) ms =1000/2 = 500 Hz
Prescaler ditentukan 1024
CTC Value = [16000000/(1024*500)]-1
= 30.5 = 30
Maka OCR0A = 30;

CONTOH KONFIGURASI
Maka konfigurasi menjadi :
cli(); // disable interrupt
TCCR0A = 0;
TCCR0B = 0;
TCNT0 = 0;
OCR0A = 30; //decimal 30
// turn on CTC mode
TCCR0A |= (1 << WGM01);
// Set CS02 and CS00 bits for 1024 prescaler
TCCR0B |= (1 << CS02) | (1 << CS00);
// enable timer compare interrupt
TIMSK0 |= (1 << OCIE0A); // karena menggunakan OCR0A
sei(); // Enable interrupt

CONTOH KONFIGURASI 2
Timer mengunakan timer 0 dengan interrupt CTC setiap 1 s
Frekuensi interrupt = 1/1 = 1 Hz
compare match register = [ 16,000,000Hz/ (prescaler * desired interrupt
frequency) ] – 1
CTC Value = [16000000/(1024*1)]-1
= 15624
Value CTC lebih besar dari 255 maka untuk konfigurasi ini tidak dapat
menggunakan timer0. untuk itu memerlukan timer dengan nilai CTC yang
lebih besar yaitu timer1 16 bit

TIMER 2
Kira-kira sama seperti timer 0 => datasheet

TIMER 1 – OCR1
Terdapat 2 buah OCR1 yaitu OCR1A dan OCR1B
Nilai OCR ini yang akan diisi sebagai compare dari CTC

TIMER1 – TCCR1
Untuk timer 1 maka TCCR1>>WGM12 harus di set sehingga menjadi
mode CTC
TCCR1A=0;
TCCR1B=0;
TCCR1B |= (1 << WGM12);// WGM12 => 1
TCCR1B |= (1 << CS10)|(1<<CS12); //SET PRESCALER 1024

TIMER1 – TCNT1
TCNT1 adalah register yang berfungsi menyimpan nilai cacahan dari
counter timer 1. Pada konfigurasi perlu untuk diset TCNT1 = 0;
TCNT1 dapat menampung data sampai 16 bit dengan membagi 2
menjadi TCNT1 high dan TCNT1 low

TIMER 1 – INTERRUPT MASK
Untuk mengaktif mode CTC sebagai mode interrupt maka perlu
dilakukan konfigurasi pada interrupt mask
TIMSK1 |= (1 << OCIE1A); // menggunakan OCR1A compare
TIMSK1 |= (1 << OCIE0B); // menggunakan OCR1B compare
TIMSK1 |= (1 << TOIE1); // menggunakan overflow event
OCIE1A

TIMER1 – INTERRUPT HANDLER
Dalam interrupt diperlukan sebuah handler yang menangani event
interrupt tersebut. Fungsi tersebut diletakan pada function ISR
Function :
}
Function :
ISR(TIMER1_COMPB_vect){
}

Timer mengunakan timer 1 dengan interrupt CTC setiap 1 s
Frekuensi interrupt = 1/1 = 1 Hz
CTC Value = [16000000/(1024*1)]-1
= 15624

Maka konfigurasi menjadi :
TCCR1A = 0;
TCCR1B = 0;
TCNT1 = 0;
OCR1A = 15624; //decimal 15624
// turn on CTC mode
TCCR1B |= (1 << WGM12);// SET WGM12
// Set CS12 and CS10 bits for 1024 prescaler
TCCR1B |= (1 << CS10)|(1<<CS12);

INPUT INTERRUPT
Fungsi : attachInterrupt()
Board Digital Pins Usable For Interrupts
Uno, Nano, Mini, other 328-based 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
Micro, Leonardo, other 32u4-based 0, 1, 2, 3, 7
Zero, MKR1000 all digital pins, except 4
Due all digital pins
attachInterrupt(digitalPinToInterrupt(pin), ISR, mode);

INPUT INTERRUPT - MODE
- LOW
Memanggil ISR saat kondisi low pada pin
- CHANGE
Memanggil ISR saat terjadi perubahan kondisi pin
- RISING
Memanggil ISR saat terjadi perubahan low to high
- FALLING
Memanggil ISR saat terjadi perubahan high to low
- HIGH (ONLY FOR ARDUINO DUE)
Memanggil ISR saat kondisi high pada pin

INPUT INTERRUPT
int pin=2;
volatile int state=LOW;
void setup() {
// put your setup code here, to run once:
pinMode(pin,INPUT);
pinMode(13,OUTPUT);
attachInterrupt(digitalPinToInterrupt(pin),blink,CHANGE);
}
void loop() {
digitalWrite(13,state);
}
void blink(){
state=!state;
}

INTERRUPT MANAGEMENT
Pada Arduino terdapat 2 buah fungsi yang berhubungan langsung pada penggunaan interrupt. Yaitu
interrupts(); => Berfungsi untuk menyalakan interrupt
noInterrupts(); => Berfungsi untuk mematikan interrupt
CODE :
void setup() {}
void loop()
{
noInterrupts();
// critical, time-sensitive code here
interrupts();
// other code here
}

DELAY
DELAY bertujuan untuk menunda suatu instruksi. Terdapat dua buah
jenis delay yaitu
 Delay Blocking
 Delay Non Blocking

DELAY BLOCKING
Delay blocking adalah delay yang memblockir instruksi secara
keseluruhan sehingga saat delay ini diaktifkan maka CPU berhenti
bekerja dan menunggu sampai dengan waktu yang ditentukan
tercapai.
CODE :
Delay(1000); // menghentikan program selama satu detik

CONTOH DELAY BLOCKING -
BLINKING LED
void setup()
{
}
void loop()
{
digitalWrite(ledPin, HIGH); // sets the LED on
digitalWrite(ledPin, LOW); // sets the LED off
}

DELAY NON BLOCKING
Delay non blocking bertujuan untuk membuat delay yang tidak
menghambat CPU bekerja secara total. Sehingga program dapat
berjalan secara “Multi Tasking”
Untuk membuat delay non blocking diperlukan sebuah interrupt yang
bekerja setiap waktu tertentu dan berfungsi sebagai detak jantung
dari delay

MEMBUAT INTERRUPT SETIAP 1 MS
Timer mengunakan timer 0 dengan interrupt CTC setiap 1 ms
Frekuensi interrupt = 1/(1 * 10^-3) ms =1000/1 = 1000 Hz
CTC Value = [16000000/(256*1000)]-1
= 62.5 = 63
Maka OCR0A = 63;

KONFIGURASI DELAY NON
BLOCKINGSETUP :
TCCR0A = 0;
TCCR0B = 0;
TCNT0 = 0;
OCR0A = 63; // interrupt setiap 1 ms
// turn on CTC mode
TCCR0A |= (1 << WGM01);
// Set CS02 bits for 256 prescaler
TCCR0B |= (1 << CS02);

INTERRUPT HANDLER DAN
DEKLARASI
DEKLARASI VARIABEL:
volatile unsigned long ticks;
INTERRUPT HANDLER :
ticks++;
if(ticks>=65537){
ticks=0;
}
}

MEMBUAT DELAY NON BLOCKING –
INTERRUPT CTC
DEKLARASI VARIABEL:
unsigned long blinks;
SETUP :
blinks=ticks;
CODE :
if(ticks-blinks>=delay){
// Do something
blinks=ticks;
}
*delay sesuai dengan angka yang diinginkan

CONTOH DELAY NON BLOCKING
INTERRUPT CTC – BLINKING LED
volatile unsigned long ticks;
unsigned long blinks;
int led1;
void setup() {
pinMode(13,OUTPUT);
TCCR0A = 0;
TCCR0B = 0;
TCNT0 = 0;
OCR0A = 63; // interrupt setiap
1 ms
TCCR0A |= (1 << WGM01);
TCCR0B |= (1 << CS02);
TIMSK0 |= (1 << OCIE0A);
blinks=ticks;
led1=0;
void loop() {
unsigned long cticks=ticks;
if(cticks-blinks>=1000){
if(led1==0){
led1=1;
}else{
led1=0;
}
blinks=ticks;
digitalWrite(13,led1);
}
}
ticks++;
if(ticks>=65537){
ticks=0;
}
}

MILLIS()
millis() digunakan untuk mengetahui berapa lama Arduino telah berjalan.
Terjadi overlflow setiap 50 hari. Kemudian nilai milis() akan direset ke 0.
millis() memanfaatkan timer 0 dengan mode fast pwm.
CODE :
unsigned long time;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = millis();
Serial.println(time);
delay(1000);
}

MICROS()
micros() digunakan untuk mengetahui berapa lama Arduino telah berjalan. Terjadi overlflow setiap 70
menit. Kemudian nilai micros() akan direset ke 0. Resolusi dari micros() adalah 4 us. micros()
memanfaatkan timer 0 dengan mode fast pwm.
CODE :
unsigned long time;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = micros();
Serial.println(time);
delay(1000);
}

MEMBUAT DELAY NON BLOCKING –
MENGGUNAKAN MILIS()
unsigned long previousMillis = 0;
const long interval = 1000;
const int ledPin = 13;
int ledState = LOW;
void setup() {
previousMillis=millis();
}
void loop() {
// put your main code here, to run
repeatedly:
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >=
interval) {
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
digitalWrite(ledPin, ledState);
previousMillis=currentMillis;
}
}

ANALOG WRITE - PWM
SETUP :
CODE :
analogWrite(ledPin, 8 bit value);

ANALOG READ
CODE :
sensorValue = analogRead(sensorPin);
Hasil dari analog read berupa data dari 0 – 1023 dapat di convert
menjadi 0 – 255 untuk keperluan eeprom misalnya maka hasil
read dapat di map yaitu dengan memanggil function map
map(sensorValue, 0, 1023, 0, 255);
Fitur map dapat berlaku untuk aplikasi lainnya yang membutuhkan
fitur perbandingan angka

ANALOG EXAMPLE
int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 3; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the
sensor
void setup() {
// declare the ledPin as an OUTPUT:
}

ANALOG EXAMPLE
void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
analogWrite(LedPin, sensorValue);
}

EEPROM
LIBRARY :
#include <EEPROM.h>
PENGGUNAAN :
EEPROM memiliki Address dengan max address sesuai dengan
Arduino yang digunakan (ARDUINO UNO 1 KB / 1000 ADDRESS)
Setiap BYTE / ADDRESS dapat menampung unsigned integer value
antara 0 sampai 255. Untuk data yang lebih besar perlu dipotong
sebelum dimasukan kedalam eeprom

WRITE
CODE :
EEPROM.write(addr, val);
Addr adalah address dari eeprom
* Terdapat fungsi EEPROM.length() yang berguna untuk mengetahui
length address dari Arduino tersebut

READ
CODE :
value = EEPROM.read(address);
* Address merupakan alamat dari data yang disimpan dalam eeprom

I2C
Uno, Ethernet A4 (SDA), A5 (SCL)
Mega2560 20 (SDA), 21 (SCL)
Leonardo 2 (SDA), 3 (SCL)
Due 20 (SDA), 21 (SCL), SDA1, SCL1

I2C – DS1307 REAL TIME CLOCK
Crystal / XTAL : 32.768 KHz

LIBRARY DS1307 RTC
URL Download :
http://www.instructables.com/files/orig/FC2/O0HR/HW4OIBWY/FC2
O0HRHW4OIBWY.zip

I2C - DS1307 REAL TIME CLOCK
INCLUDE :
#include <Wire.h>
#include <RealTimeClockDS1307.h>
START CLOCK :
RTC.start();
STOP CLOCK :
RTC.stop();

TIME COMMAND :
//Checks whether the clock is running.
RTC.isStopped();
//Check whether it is AM or PM(1) depending on the output(given
above).
RTC.isPM();
//Checks whether the clock is in 24hour mode.
RTC.is12hour();
//Toggles between the 12hour mode and 24hour mode.
RTC.switchTo24h();

READ CLOCK :
int hours = 0;
int minutes = 0;
int seconds = 0;
int dates = 0;
int months = 0;
int years = 0;
int date = 0;
//syntax for setting the values to the integers
RTC.readClock(); //This line is essential for the other commands to work.
//Commands for getting the individual time values.
hours = RTC.getHours();
minutes = RTC.getMinutes();
seconds = RTC.getSeconds();
dates = RTC.getDate();
months = RTC.getMonth();
years = RTC.getYear();
date = RTC.getDayofWeek();

WRITE CLOCK :
RTC.setHours(jam);
RTC.setMinutes(menit);
RTC.setSeconds(detik);
RTC.setDate(hari);
RTC.setMonth(bulan);
RTC.setYear(tahun);
RTC.set24h();
//RTC.setAM();
RTC.setPM();
RTC.setDayofWeek(1);

LCD 16X2
INCLUDE :
#include <LiquidCrystal.h>
LIQUID CRYSTAL CONFIGURATION
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//LCD RS pin to digital pin 12
//LCD Enable pin to digital pin 11
//LCD D4 pin to digital pin 5
//LCD R/W pin to ground
//LCD VSS pin to ground
//LCD VCC pin to 5V

LCD 16X2
SETUP :
lcd.begin(16, 2);
CODE :
lcd.setCursor(0, 0);
lcd.print(“Hello World!”);

Arduino Basic

More Related Content

What's hot

Viewers also liked

Similar to Arduino Basic

Arduino Basic