Pada era sekarang ini mikroelektronika sangat berkembang pesat, IC dan prosesorprosesor mini sudah banyak dipasaran dan mudah untuk didapatkan. Hal ini yang
mengakibatkan mikrokontroler sangat murah karena hampir semua peralatan elektronika
yang kita lihat sehari-hari menggunakan teknologi ini, seperti jam digital, pintu otomatis
yang ada di mall-mall, palang pintu parkir, lampu merah, counter down (angka yang ada
pada lampu merah) dan masih banyak yang lain.
Jika anda melihat benda atau alat yang seperti kami sebutkan diatas pasti anda
berfikir bagaimana ya cara membuat alat seperti itu??, wahpasti susah dan ribet banget
!!!
memang
sebenarnya
untuk
merancang
sebuah
system
yang
menggunakan
awam dalam hal mikroelektronika dan pemrograman. Disini anda akan mempraktekkan
secara langsung tanpa harus terlebih dahulu membaca dasar-dasar teori yang bisa membuat
anda semakin bingung. Dan anda bisa langsung melihat hasil kerja anda secara real tanpa
harus menggunakan simulasi dan membayangkan bagaimana hasilnya.
Dalam kit ini, selain anda belajar mikrokontroler dan pemroraman juga akan
menjelaskan bagaimana cara membuat PCB dengan standart pabrikan internasional dan
sekali lagi untuk membuat PCB dengan satndart pabrikan internasional tidaklah serumit
dan sesusah yang anda bayangkan. Dan sebenarnya sangat mudah dan tidak membutuhkan
waktu yang cukup lama, bahakan hanya membutuhkan waktu + 30 menit saja. Pembuatan
PCB ini akan dijelaskan pada bagian suplemen buku yang ada pada bab-bab terakhir.
aplikasi
interface,
diantaranya
dsb.
development
Kelebihan
board
utama
ini
mini
adalah
32
tidak
32
ini
mikrokontroller
menggunakan
ATMEL
Selain
Atmega32
itu
mikrokontroller
yang
internal,
Timer/Counter,
AVR
memiliki
keunggulan
PWM,
lengkap
diantaranya
EEPROM
Port
internal,
Watchdog
I/O,
ADC
timer,
Komparator
dll.
AVR
memiliki
program
sebagian
yang
kemampuan
sangat
besar
cepat
instruksi
eksekusi
karena
hanya
didesain
dan
deprogram
untuk
Berikut akan dijelaskan beberapa fitur yang ada pada ATMEL Atmega32 :
1. Merupakan mikrokontroler AVR 18 yang mempunyai kemampuan yang tinggi
dengan kebutuhan daya yang rendah.
2. Mempunyai 32 buah register.
3. fitur pheripheral
-
4. I.nput/Output
-
board
dimana
ini
disusun
Anda
secara
dapat
sistematis
belajar
dan
sekaligus
Gambar 1.1
Memilih bahasa installasi
Gambar 1.2
Kotak dialog continue setup
Klik next
Gambar 1.3
Memilih letak Folder Installasi
Gambar 1.4
Memilih letak Shortcuts
Gambar 1.5
Informasi mengenai letak installasi,
klik install
Gambar 1.6
Proses extracting file sekaligus proses
installasi
Gambar 1.7
Proses installasi telah selesai
Klik finish
ight Emitting Diodes atau lebih sering disebut LED adalah komponen semikonduktor
yang mampu merubah energi listrik menjadi cahaya. Sekarang ini hampir semua alat
atau instrumen menggunakan LED sebagai salah satu komponennya. LED bentuknya kecil
dan harganya murah sehingga sangat sederhana untuk digunakan. LED bisa memancarkan
cahaya
yang
berbeda
semikonduktornya.
bergantung
pada
senyawa
kimia
di
dalam
komponen
Keuntungan :
1. LED memancarkan cahaya
yang lebih terang per
wattnya daripada bola lampu
pijar.
2. Lebih mudah dan hemat
untuk menghasilkan
pancaran cahaya berwarna.
3. Dapat menyala dengan
cepat.
Kerugian :
Tengangannya sangat sensitive.
LED harus diberikan tegangan yang
lebih rendah dari batas maksimumnya
dan dialirkan arus dibawah nilai
batasnya. Dapat juga dirangkai seri
dengan resistornya.
Simbol LED
Simbol yang biasa digunakan sebagai simbol LED adalah simbol dioda standar tetapi
dengan
sepasang
anak
panah
keluar
yang
menunjukkan
bahwa
dioda
tersebut
memancarkan cahaya.
6. Kabel IDE
7. Soket IDE
8. Black housing
4. Solder.
single 8 pin.
9. Konektor IDE
5. Tenol.
sesuai dengan gambar skematik datas. Berikut contoh rangkaian led yang sudah jadi :
Selanjutnya kita akan menghubungkan rangkaian led yang telah kita buat sebelumnya ke
mini 32 dengan menggunakan kabel.
Langkahnya sebagai berikut:
1. Hubungkan rangkaian LED dengan Port D pada mini 32.
2. Hubungkan mini 32 ke komputer dengan kabel USB mini B.
3. Buka code vision dan atur konfigurasi chip,clock serta Port keluarannya. Seperti
penjelasan dibawah ini :
Kita
dapat
menjalankan
aplikasi
ini
melalui
menu
startall
Untuk memulai projek baru /new project kita pilih menu filenew maka akan muncul kotak
dialog seperti dibawah ini :
Pilih project kemudian klik OK, kemudian akan muncul kotak dialog konfirmasi kita pilih
yes
Kemudian akan muncul kotak dialog konfigurasi mengenai chip serta pin yang akan kita
gunakan
Pada menu chip, chip yang kita gunakan pada mini 32 adalah ATmega32 dengan nilai
clock
7.372000,
kemudian
kita
setting
port
yang
akan
kita
gunakan
sebagai
output/keluaran yang kemudian disambungkan pada rangkaian LED, sebenarnya kita dapat
menggunakan salah satu dari keempat port diatas, namun pada kesematan kali ini kita
hanya akan menggunakan port D sebagai output dan kita sambungkan dengan rangkaian
LED. Maka kita setting port D sebagai output dengan memilih sub menu port D kemudian
klik In pada bit ke-0 sampai dengan bit ke-7,maka secara otomatis akan berubah menjadi
out
Setelah kita setting chip, clock serta port yang kita gunakan, langkah selanjutnya
adalah menyimpan konfigurasi tersebut melalui filesave as, kemudian beri nama file, file
yang pertama bereksistensi .cwp, file .cwp kita beri nama led_blink.cwp .kemudian pilih
Generate,Save and Exit, seperti langkah sebelumnya kita beri nama file .c ini dengan nama
file led_blink.c dan file .prj dengan nama led_blink.prj
Kotak dialog diatas merupakan lembar kerja dimana kita akan menulis program.
Contoh Program
#include <mega32.h>
#include <delay.h>
void main(void)
// fungsi utama
DDRD=0xFF;
while (1)
{
PORTD=0xFF;
delay_ms(1000);
PORTD=0x00;
delay_ms(1000);
}
}
Program akan berulang terus menerus karena syarat whie (1), dan akan menghasilkan nilai
benar, maka pernyataan yang ada didalam kalang while akan dijalankan berulang dan led
tampak hidup dan mati secara berulang-ulang(blink/kedip) .
Save file yang sudah anda ketik dengan memilih menu FileSave atau klik icon disket
pada tollbar. Pilih menu project kemudian pilih build all, kemudian akan muncul kotak
dialog sebagai berikut :
delay_ms(500);
// Waktu tunda
}
}
Setelah anda menulis program pada code vision kemudian simpan dengan nama
led_shift. Setelah dipastikan tidak ada error dan warning (bisa dilihat pada kotak dialog
information setelah program di build all), kemudian download program ke mini 32 dan lihat
hasilnya.
Binary counter
Pada praktik LED yang ke- 3 ini, kita akan mencoba menghidupkan led binary counter.
Seluruh proses installasi perangkat kerasnya sama dengan praktik led sebelumnya, yang
membedakan hanyalah pada programnya saja
Berkut adalah script program led berjalan :
#include <mega32.h>
#include <delay.h>
int Sign;
void main(void)
{
Sign=0;
DDRD=0xFF;
PORTD= ~Sign;
nilai Sign
delay_ms(1000);
// Fungsi Utama
while (1)
{
Sign ++;
PORTD= ~Sign;
delay_ms(1000);
//Tunda 1 detik
if (Sign==255)
{
Sign=0;
}
}
nilai Sign
}
Setelah anda menulis program pada code vision kemudian simpan dengan nama
led_bc. Setelah dipastikan tidak ada error dan warning ( bisa dilihat pada kotak dialog
information setelah program di build all), kemudian download program ke mini 32 dan lihat
hasilnya.
Common Anoda
Disini, semua anoda dari diode disatukan secara parallel dan semua itu
dihubungkan ke VCC dan kemudian LED dihubungkan melalui tahanan pembatas
arus keluar dari penggerak. Karena dihubungkan ke VCC, maka Common Anoda ini
berada pada kondisi Aktif High.
Common Katoda
Disini semua katoda disatukan secara parallel dan dihubungkan ke Ground.
Karena seluruh katoda dihubungkan ke Ground, maka Common Katoda ini berada
pada kondisi Aktif Low.
setelah melihat hasil dari tampilan seven segment diatas pasti timbul pertanyaan,
bagaimana caranya supaya seven segment bisa menampilkan tampilan seperti yang ada
pada gambar diatas. Disini kita akan menjawab pertanyaan itu.
Di awal tadi kita sudah tahu apa sebenarnya seven segment itu, tiap-tiap segment
yang ada pada seven segment dibentuk oleh sebuah led, dimana led tersebut akan menyala
jika diberi tegangan antara 3,5 sampai dengan 5 Volt. Untuk menampilkan sebuah angka
ataupun huruf pada penampil seven segment tentunya dibutuhkan beberapa led yang harus
menyala, misal untuk menampilkan angka 0, maka led yang harus menyala/ON adalah
A,B,C,D,E,F. Sedangkan led G dalam keadaan mati/OFF
7. Tenol.
8. Solder.
Test segmen 1
#include<mega32.h>
#include<delay.h>
void main(void)
{
DDRC = 0xFF;
//port C di fungsikan sebagai output
While(1);
{
PORTC = 0b11111101;
}
}
Test segmen 2
#include<mega32.h>
#include<delay.h>
void main(void)
{
DDRC = 0b11111111;
//port C di fungsikan sebagai output
While(1);
{
PORTC = 0b11111011;
}
}
Test segmen 3
#include<mega32.h>
#include<delay.h>
void main(void)
{
DDRC = 0b11111111; //port C di fungsikan sebagai output
While(1);
{
PORTC = 0b11110111;
}
}
Mungkin sebagian dari anda asing mendengar istilah dot matrik dan timbul
pertanyaan, apa sih dot matrix itu??. Dot matrix merupakan salah satu penampil yang pada
dasarnya tersusun dari led (dot) yang disusun berbentuk baris dan kolom(matrix). Hampir
sama dengan seven segment dan hanya susunan led/segment yang berbeda.
sebenarnya ada beberapa jenis dot matrix, namun pada keempatan kali ini kita hanya
akan membahas dot matrix 8x8 dan 16x16. Dot matrix 8x8 artinya dot matrix yang
mempunyai dot sebanyak 8 baris medatar dan 8 baris menurun. Begitu juga untuk dot
matrix 16x16.
Dot matrix lebih fleksibel dibandingkan dengan penampil-penampil yang lain seperti
led dan seven segment, selain dapat menampilkan angka dan huruf dot matrix juga dapat
untuk menampilkan gambar dan karakter/emoticon. Tapi proses scaning/penampilan
tampilan agak sedikit susah. Jika pada seven segment, anda hanya perlu menghidupkan 8
buah led yang sudah tersusun, namun pada dot matrix anda harus menentukan tiap baris
dan kolomnya.
Sebagai contoh jka anda ingin menampilkan angka 1 pada dot matrix 8x8 maka
susunan dot yang menyala sebagai berikut :
BARIS
0
Setelah membaca sedikit pengenalan dan penjelasan mengenai dot matrix, kemudian
kita buat modul dot matrix sederhana yang nantinya akan kita hubungkan dengan mini 32
dan kita program.
#include <mega32.h>
#include<delay.h>
Void main(main)
{
DDRA=0xFF; //Port A di fungsikan sebagai output.
DDRC=0xFF; //Port C di fungsikan sebagai output.
While(1);
{
PORTA=0b11111110;
PORTC=0b11111111;
delay_ms(1);
PORTC=0b00000000;
delay_ms(10);
PORTA=0b11111101;
PORTC=0b11111111;
delay_ms(1);
PORTC=0b0000100;
delay_ms(10);
PORTA=0b11111011;
PORTC=0b00000100;
delay_ms(1);
PORTC=0b00000000;
delay_ms(10);
PORTA=0b11110111;
PORTC=0b00000100;
delay_ms(1);
PORTC=0b00000000;
delay_ms(10);
PORTA=0b11101111;
PORTC=0b00000100;
delay_ms(1);
PORTC=0b00000000;
delay_ms(10);
}
}
Liquid
merupakan
Crystal
sebuah
Display
(LCD)
teknologi
layar
permukaan
yang
rata
(flat)
listrik
diberikan,
molekul
susunan
kristalin
yang
tergantung
Dalam
ditentukan
kebutuhannya.
pemogramannya,
dengan
LCD
pengalamatan
LCD
berfungsi
menampilkan
mikrokontroler.
merupakan
tampilan
konsumsi
tersebut
modul
16
daya
LCD
ini
LCD
dengan
baris
dengan
rendah.
Modul
dilengkapi
dengan
Sedang
modul
graphics
hanya
grafik
saja
ini
pada
sudah
menampilakan
gambar/grafik
dimensi 128x64.
dengan
Gambar 4.2 LCD Grafik 128x64
Nokia 5510 LCD modul didasarkan pada PCD8544 48x48 piksel pengontrol LCD
matrix ini adalah LCD grafik dimana dapat menampilkan gambar, logo dan membuat game
sederhana. LCD ini menggunakan mikrokontroler Atmel 8-bit.
Jika anda dalam pembuatan PCB menggunakan teknik sablon maupun UV berikut adalah
gambar filmnya :
Berikut gambar contoh hasil pembuatan rangkaian LCD 128x64 yang sudah jadi :
Jika dalam proses pembuatan PCB menggunakan teknik UV berikut ini filmnya :
// glcd
on();
// glcd
SetStartLine(0);
glcd_clear();
lcd_printf(30,1,"POWER ON");
delay_ms(50):
delay_ms(2000);
WDTCR=0x0F;
// watchdog
show(at[0],1);
delay_ms(2000);
glcd_clear();
while (1)
{
lcd_printf(4,2,"Graphics LCD");
delay_ms(2000);
glcd_clear();
lcd_printf2(4,5,"SELAMAT MENCOBA");
delay_ms(2000);
glcd_clear();
};
}
PORTA.5
#define LCD_X
84
#define LCD_Y
48
#define HIGH
#define LOW
#include <font5x7.c>
/*****************************************************/
void send_data_lcd(char byte)
{
unsigned char i;
for (i=0;i<8;i++)
{
if (byte&0x80) SDI=1; else SDI=0;
byte<<=1;
SCK=1;
SCK=0;
}
}
/*****************************************************/
/*****************************************************/
void write_data(unsigned char byte_data)
{
D_C=1;
SCE=0;
send_data_lcd(byte_data);
SCE=1;
}
/**********************************************************************************
***/
void send_lcd_data(flash unsigned char values[], unsigned int amount)
{
unsigned int counter;
write_command(0x80|(x&0x7f));
}
/*****************************************************/
void lcd_clear(void)
{
unsigned int ddram;
goto_x_y(0,0);
for (ddram=504;ddram>0;ddram--)
{
write_data(0x00);
}}
// 84*6=504
clear LCD
void LCD_init(void)
{
DDRA=0b11111111;
// Port A
D_C=0;
SCE=0;
RES=0; delay_ms(100); RES=1;
write_command(0x21);
set
write_command(0x90);
v2: 0xa0 (for 3V) // v3: 0xc2 (2v6-5v)
// (0xc2Vop
write_command(0x20);
right, X axe are incremented automatically ,
/**********************************************************************************
***/
void lcd_printf(unsigned char x, unsigned char y,
{
unsigned char n,w;
unsigned int yy;
goto_x_y(x,y);
for (n = 0;Str[n]!=0;n++)
{
yy=(*(Str+n)-32);
w=wide5x7[yy];
yy*=5;
send_lcd_data(&font5x7[yy],w);
write_data(0);
}
// (space)
// !
// "
// #
// $
// %
// &
// '
// (
// )
// *
// +
// ,
// -
// .
// /
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// :
// ;
// <
// =
// >
// ?
// @
// A
// B
// C
// D
// E
// F
// G
// H
// I
// a
// b
// c
// d
// e
// f
// g
// h
// i
// j
// k
// l
// m
// n
// o
// p
// q
// r
// s
// t
// u
// w
// y
// z
0x00, // |
0x03,// (
0x03,// )
0x05,// *
0x05,// +
0x02,// ,
0x05,// 0x02,// .
0x05,// /
0x05,// 0
0x05,// 1
0x05,// 2
0x05,// 3
0x05,// 4
0x05,// 5
0x05,// 6
0x05,// 7
0x05,// 8
0x05,// 9
0x05,// :
0x02,// ;
0x04,// <
0x05,// =
0x04,// >
0x05,// ?
0x05,// @
0x05,// A
0x05,// B
0x05,// C
0x05,// D
0x05,// E
0x05,// F
0x05,// G
0x05,// H
0x03,// I
0x05,// J
0x05,// K
0x05,// L
0x05,// M
0x05,// N
0x05,// O
0x05,// P
0x05,// Q
0x05,// R
0x05,// S
0x05,// T
0x05,// U
0x05,// V
0x05,// W
0x05,// X
0x05,// Y
0x05,// Z
0x03,// [
0x05,// "\"
0x03,// ]
0x05,// ^
0x05,// _
0x03,// `
0x04,// a
0x04,// b
0x04,// c
0x04,// d
0x04,// e
0x04,// f
0x04,// g
0x04,// h
0x01,// i
0x04,// j
0x04,// k
0x01,// l
0x05,// m
0x04,// n
0x04,// o
0x04,// p
0x04,// q
0x04,// r
0x04,// s
0x04,// t
0x04,// u
0x05,// v
0x05,// w
0x05,// x
0x04,// y
0x03,// z
0x03,// {
0x01,// |
0x03,// }
0x05,// ->
0x05 // <};
LCD_init();
BL=0;
lcd_printf(4, 1, "Selamat Datang");
lcd_printf(4, 3, "Di MM UGM");
while (1)
{
}
}
(sirine),
yang
mana
dapat
berupa
Buzzer
ini
sering
digunakan
pemberi
bel
informasi(penanda)
sekolah,
jam
weker,
kepada
sirine
buzzer
anda
bisa
sederhana
dibutuhkan
IDC,soket
hanya
dan
masing-masing
bahan
buzzer,kabel
black
4
yang
housing
buah
serta
while (1)
{
PORTC=0;
delay_ms(1);
PORTC=255;
delay_ms(1);
}
}
//
ON
Pengenalan Tombol
Pada intinya tombol merupakan sebuah saklar pusbutton, Pushbutton merupakan
sebuah device untuk menghubungkan dan memutuskan rangkaian listrik antara 2 titik.
Penggunaan pushbutton dikehidupan sehari-hari hampir menyentuh semua bidang. Di
bidang komputer dengan keyboard dan mouse, dibidang otomotif dengan panel-panel
kontrolnya, bahkan diperalatan rumah tangga sekalipun seperti kontrol peralatan listrik juga
menggunakan push button.
penekanan
maka
dalam
keadaan
terputus(off)
sedangkan
saat
ditekan
akan
tersambung(on).
Pada kesempatan kali ini kita akan mencoba mengaplikasikan tombol(pushbutoon,
keypad 3x4, keypad Nokia 6610) dengan mini 32.
housing
5. Kabel IDC.
6. PCB 7,5x5 cm.
7. Solder.
8. Tenol.
20
Jika dalam pembuatan PCB anda menggunakan teknik sablon atau UV berikut gambar
filmnya :
// Port Led
= Output
PORTC=255;
DDRA=0b00000000;
PORTA=0b11111111;
while(1)
{
TestTombol4();
}
}
void TestTombol4(void)
{
if (PINA.0==0) //Jika Pin A 0 nilainya sama dengan 0 maka akn menjalankan
pernyataan selanjutnya.
{
PORTC=0b11111110;
// Port C 0 ON.
delay_ms(300);
PORTC=0b01111111;
// Port C 0 Off.
delay_ms(300);
}
else
Keypad 3x4 di kombinasikan dengan penampil LCD 16x2. Berikut adalah contoh kode
programnya :
#asm
.equ __lcd_port=0x15
#endasm
#include <mega32.h>
#include <delay.h>
#include <lcd.h>
void main(void)
{
DDRA=0b11110000;
// PORTC
while(1)
{
PORTA=0b11101111;
delay_ms(30);
if (PINA.0==0) { lcd_gotoxy(1,1); lcd_putsf ("1"); }
if (PINA.1==0) { lcd_gotoxy(1,1); lcd_putsf ("4"); }
if (PINA.2==0) { lcd_gotoxy(1,1); lcd_putsf ("7"); }
if (PINA.3==0) { lcd_gotoxy(1,1); lcd_putsf ("*"); }
PORTA=0b11011111;
delay_ms(30);
if (PINA.0==0) { lcd_gotoxy(1,1); lcd_putsf ("2"); }
if (PINA.1==0) { lcd_gotoxy(1,1); lcd_putsf ("5"); }
if (PINA.2==0) { lcd_gotoxy(1,1); lcd_putsf ("8"); }
if (PINA.3==0) { lcd_gotoxy(1,1); lcd_putsf("0"); }
PORTA=0b10111111;
delay_ms(30);
if (PINA.0==0) { lcd_gotoxy(1,1); lcd_putsf ("3"); }
if (PINA.1==0) { lcd_gotoxy(1,1); lcd_putsf ("6"); }
if (PINA.2==0) { lcd_gotoxy(1,1); lcd_putsf ("9"); }
if (PINA.3==0) { lcd_gotoxy(1,1); lcd_putsf ("#"); }
}
}
Jenis dari motor listrik ini sendiri antara lain motor DC dan motor stepper.
Motor DC
Mesin yang berfungsi mengubah tenaga listrik DC menjadi tenaga mekanik dengan
tenaga gerak berupa putaran dari rotor. Komponen utama motor ini : kutub medan, dinamo
dan komutator.
utub medan Secara sederhada digambarkan bahwa interaksi dua kutub magnet
akan menyebabkan perputaran pada motor DC. Motor DC memiliki kutub medan
yang stasioner dan dinamo yang menggerakan bearing pada ruang diantara
kutub medan. Motor DC sederhana memiliki dua kutub medan: kutub utara dan kutub
selatan. Garis magnetik energi membesar melintasi bukaan diantara kutub-kutub dari utara
ke selatan. Untuk motor yang lebih besar atau lebih komplek terdapat satu atau lebih
elektromagnet. Elektromagnet menerima listrik dari sumber daya dari luar sebagai penyedia
struktur medan.
inamo. Bila arus masuk menuju dinamo, maka arus ini akan menjadi
elektromagnet. Dinamo yang berbentuk silinder, dihubungkan ke as penggerak
untuk menggerakan beban. Untuk kasus motor DC yang kecil, dinamo berputar
dalam medan magnet yang dibentuk oleh kutub-kutub, sampai kutub utara dan
selatan magnet berganti lokasi. Jika hal ini terjadi, arusnya berbalik untuk merubah kutubkutub utara dan selatan dinamo.
Keuntungan
utama
motor
DC
adalah
sebagai
pengendali
kecepatan,
yang
tidak
mempengaruhi kualitas pasokan daya. Motor ini dapat dikendalikan dengan mengatur:
1. Tegangan dinamo meningkatkan tegangan dinamo akan meningkatkan kecepatan
2. Arus medan menurunkan arus medan akan meningkatkan kecepatan.
Motor Stepper
Motor Stepper adalah motor DC yang gerakannya bertahap (step per step) dan memiliki
akurasi yang tinggi tergantung pada spesifikasinya. Setiap motor stepper mampu berputar
untuk setiap stepnya dalam satuan sudut (0.75, 0.9, 1.8), makin keil sudut per step-nya
maka gerakan per step-nya motor stepper tersebut makin presisi. Motor stepper banyak
digunakan untuk aplikasi-aplikasi yang biasanya cukup menggunakan torsi yang kecil,
seperti untuk penggerak piringan disket atau piringan CD. Dalam hal kecepatan, kecepatan
motor stepper cukup cepat jika dibandingkan dengan motor DC.
Motor stepper merupakan motor DC yang tidak memiliki komutator. Pada umumnya
motor stepper hanya mempunyai kumparan pada statornya sedangkan pada bagian rotornya
merupakan magnet permanent. Dengan model motor seperti ini maka motor stepper dapat
diatur posisinya pada posisi tertentu dan/atau berputar ke arah yang diinginkan, searah
jarum jam atau sebaliknya.
Kecepatan motor stepper pada dasarnya ditentukan oleh kecepatan pemberian data pada
komutatornya. Semakin cepat data yang diberikan maka motor stepper akan semakin cepat
pula berputarnya. Pada kebanyakan motor stepper kecepatannya dapat diatur dalam daerah
frekuensi audio dan akan menghasilkan putaran yang cukup cepat.
Variabel Reluktansi Motor
Pada motor stepper yang mempunyai variabel reluktansi maka terdapat 3 buah lilitan
yang pada ujungnya dijadikan satu pada sebuah pin common. Untuk dapat menggerakkan
motor ini maka aktivasi tiap-tiap lilitan harus sesuai urutannya.
Gambar 8.2. merupakan gambar struktur dari motor dengan variabel reluktansi
dimana tiap stepnya adalah 30. Mempunyai 4 buah kutub pada rotor dan 6 buah kutub
pada statornya yang terletak saling berseberangan.
akan menghasilkan gaya tolakan kepada rotor dan rotor akan berputar sejauh 30 searah
jarum jam sehingga kutub rotor dengan label Y sejajar dengan kutub dengan label 2.
Jika kondisi seperti ini berulang terus menerus secara berurutan, lilitan 2 dilewati
arus kemudian lilitan 3 maka motor akan berputar secara terus menerus. Maka agar dapat
berputar sebanyak 21 step maka perlu diberikan data dengan urutan seperti pada Gambar
8.3
Ketelitian dari magnet permanen di rotor dapat sampai 1.8 untuk tiap stepnya. Ketika
arus mengalir melalui tap tengah pada lilitan pertama akan menyebabkan kutub pada stator
bagian atas menjadi kutub utara sedangkan kutub stator pada bagian bawah menjadi kutub
selatan. Kondisi akan menyebabkan rotor mendapat st="on"gaya tarik menuju kutub-kutub
ini. Dan ketika arus yang melalui lilitan 1 dihentikan dan lilitan 2 diberi arus maka rotor
akan mengerak lagi menuju kutub-kutub ini. Sampai di sini rotor sudah berputar sampai
30 atau 1 step.
Gambar 8.5 Urutan Data Untuk Motor Stepper dengan Tipe Unipolar (torsi normal)
Gambar 8.6 Urutan Data Motor Stepper Tipe Unipolar (torsi besar)
Untuk meningkatkan torsi yang tidak terlalu besar maka dapat digunakan urutan
pemberian data seperti pada gambar 8.6 Dimana terdapat dua buah lilitan yang di beri arus
pada suatu waktu. Dengan pemberian urutan data seperti ini akan menghasilkan torsi yang
lebih besar dan tentunya membutuhkan daya yang lebih besar.
Dengan urutan data baik pada Gambar 8.5 atau Gambar 8.6 akan menyebabkan
motor berputar sebanyak 24 step atau 4 putaran.
Untuk mengontrol agar motor ini dapat berputar satu step maka perlu diberikan arus
untuk tiap-tiap lilitan dengan polaritas tertentu pula. Urutan datanya dapat dilihat pada
Gambar 8.8.
//max 100
min 10
duty cycle
// A
delay_ms(2);
PORTB =0b00000010;
// B
delay_ms(2);
PORTB =0b00000100;
// ~A
delay_ms(2);
PORTB =0b00001000;
delay_ms(2);
}
// ~B
void step_mundur(void)
{
PORTB =0b00001000;
// A
delay_ms(2);
PORTB =0b00000100;
// B
delay_ms(2);
PORTB =0b00000010;
// ~A
delay_ms(2);
PORTB =0b00000001;
delay_ms(2);
}
// ~B
void main(void)
{
DDRB
=0b00001111;
PORTB =0b00000000;
while(1)
{
// step_maju();
step_mundur();
delay_ms(100);
}
}
dengan besar frekuensi diatas frekuensi gelombang suara yaitu lebih dari 20 KHz. Seperti
telah disebutkan bahwa sensor ultrasonik terdiri dari rangkaian pemancar ultrasonik yang
disebut transmitter dan rangkaian penerima ultrasonik yang disebut receiver. Sinyal
ultrasonik yang dibangkitkan akan dipancarkan dari transmitter ultrasonik. Ketika sinyal
mengenai benda penghalang, maka sinyal ini dipantulkan, dan diterima oleh receiver
ultrasonik. Sinyal yang diterima oleh rangkaian receiver
dikirimkan
ke rangkaian
dihitung dengan cara mengalikan setengah waktu yang digunakan oleh sinyal ultrasonik
dalam perjalanannya dari rangkaian Tx sampai diterima oleh rangkaian Rx, dengan
kecepatan rambat dari sinyal ultrasonik tersebut pada media rambat yang digunakannya,
yaitu udara.
Waktu di hitung ketika pemencar aktif dan sampai ada input dari rangkaian penerima
dan bila pada melebihi batas waktu tertentu rangkaian penerima tidak ada sinyal input
maka dianggap tidak ada halangan didepannya.
Prinsip kerja dari sensor ultrasonik dapat ditunjukkan dalam gambar dibawah ini :
Prinsip kerja dari rangkaian pemancar gelombang ultrasonik tersebut adlah sebagai berikut :
a) Sinyal 40 kHz dibangkitkan melalui mikrokontroler.
b) Sinyal tersebut dilewatkan pada sebuah resistor sebesar 3kOhm untuk pengaman
ketika sinyal tersebut membias maju rangkaian dioda dan transistor.
c) Kemudian sinyal tersebut dimasukkan ke rangkaian penguat arus yang merupakan
kombinasi dari 2 buah dioda dan 2 buah transistor.
d) Ketika sinyal dari masukan berlogika tinggi (+5V) maka arus akan melewati dioda D1
(D1 on), kemudian arus tersebut akan membias transistor T1, sehingga arus yang
akan mengalir pada kolektotr T1 akan besar sesuai dari penguatan dari transistor.
e) Ketika sinyal dari masukan berlogika tinggi (0V) maka arus akan melewati dioda D2
(D2 on), kemudian arus tersebut akan membias transistor T2, sehingga arus yang
akan mengalir pada kolektotr T2 akan besar sesuai dari penguatan dari transistor.
f) Resistor R4 dan R6 berfungsi untuk membagi tengangan menjadi 2,5 V. Sehingga
pemancar ultrasonik akan menerima tegangan bolak balik dengan Vpeak-peak
adalah 5V (+2,5 V s.d -2,5 V).
tegangan keluaran
penguat pada saat jarak antara sensor kendaraan mini dengan sekat/dinding pembatas
mencapai jarak minimum untuk berbelok arah. Dapat dianggap keluaran komparator pada
kondisi ini adalah high (logika 1) sedangkan jarak yang lebih jauh adalah low (logika0).
Logika-logika biner ini kemudian diteruskan ke rangkaian pengendali (mikrokontroler).
sebagai
berikut :
1. Pertama tama sinyal yang diterima akan dikuatkan terlebih dahulu oleh rangkaian
transistor penguat Q2.
2. Kemudian sinyal tersebut akan di filter menggunakan High pass filter pada frekuensi >
40kHz oleh rangkaian transistor Q1.
3. Setelah sinyal tersebut dikuatkan dan di filter, kemudian sinyal tersebut akan
disearahkan oleh rangkaian dioda D1 dan D2.
4. Kemudian sinyal tersebut melalui rangkaian filter low pass filter pada frekuensi <
40kHz melalui rangkaian filter C4 dan R4.
5. Setelah itu sinyal akan melalui komparator Op-Amp pada U3.
6. Jadi ketika ada sinyal ultrasonik yang masuk ke rangkaian, maka pada komparator
akan mengeluarkan logika rendah (0V) yang kemudian akan diproses oleh
mikrokontroler untuk menghitung jaraknya.
<mega32.h>
<delay.h>
<stdlib.h>
<lcd.h>
#asm
.equ __lcd_port=0x15
#endasm
//port c
void main(void)
{
DDRB.0=1;
DDRB.1=0;
PORTB=0x00;
// Timer/Counter 0 initialization
TCCR0=0x05;
TCNT0=0x00;
OCR0=0x00;
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: On
// INT2 Mode: Falling Edge
GICR|=0x20;
MCUCR=0x00;
MCUCSR=0x00;
GIFR=0x20;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x00;
lcd_init(16);
lcd_clear();
lcd_gotoxy(0, 0);
Remote Receiver adalah merupakan penerima jarak jauh. Dalam hal ini
sinar infra merah yang dipancarkan oleh pemancar infra merah tentunya
mempunyai aturan tertentu agar data yang dipancarkan dapat diterima dengan
baik di penerima. Oleh karena itu baik di pengirim infra merah maupun penerima
infra merah harus mempunyai aturan yang sama dalam mentransmisikan (bagian
pengirim) dan menerima sinyal tersebut kemudian mendekodekannya kembali
menjadi data biner (bagian penerima). Komponen yang dapat menerima infra
merah ini merupakan komponen yang peka cahaya yang dapat berupa dioda
(photodioda) atau transistor (phototransistor). Komponen ini akan merubah energi
cahaya, dalam hal ini energi cahaya infra merah, menjadi pulsa-pulsa sinyal
listrik. Komponen ini harus mampu mengumpulkan sinyal infra merah sebanyak
mungkin sehingga pulsapulsa sinyal listrik yang dihasilkan kualitasnya cukup
baik. Pada perangkat ini detektor cahaya yang digunakan adalah komponen
TSOP4838, dimana pada komponen ini sudah terdapat filter. Jadi detektor ini
akan bekerja dengan baik jika terdapat frekuensi 38KHz.
#include <mega32.h>
#include <delay.h>
// Declare your global variables here
unsigned char
}
}
else
{
for (j=0; j<25; j++)
{
PORTB.0=0;
delay_us(13);
PORTB.0=0;
delay_us(13);
}
}
}
void main(void)
{
PORTB=0x00;
DDRB=0x00;
PORTB.0=0;
DDRB.0=1;
value=170;
while (1)
{
data=value;
tx_ir(1);
for (i=0;i<8;i++)
{
if (data&0x01) tx=1; else tx=0;
//data 8 bit
data>>=1;
tx_ir(tx);
}
tx_ir(0);
PORTB.0=0;
value++;
delay_ms(1000);
}
}
Gelombang radio adalah satu bentuk dari radiasi elektromagnetik, dan terbentuk
ketika objek bermuatan listrik dimodulasi (dinaikkan frekuensinya) pada frekuensi yang
terdapat dalam frekuensi gelombang radio (RF) dalam suatu spektrum elektromagnetik, dan
radiasi
elektromagnetiknya
bergerak
dengan
cara
osilasi
elektrik
maupun
Secara alternatif, seseorang bisa mengukur waktu antara dua buah kejadian/
peristiwa (dan menyebutnya sebagai periode), lalu memperhitungkan frekuensi (f ) sebagai
hasil kebalikan dari periode (T ), seperti nampak dari rumus di bawah ini :
RFM12B
/**********************************************************************************
void rfInit()
{
writeCmd(0x80E7);
// EL,EF,868band,12.0pF
writeCmd(0x8299);
// er,!ebb,ET,ES,EX,!eb,!ew,DC (bug was
here)
writeCmd(0xA640);
// freq select
writeCmd(0xC647);
// 4.8kbps
writeCmd(0x94A0);
// VDI,FAST,134kHz,0dBm,-103dBm
writeCmd(0xC2AC);
// AL,!ml,DIG,DQD4
writeCmd(0xCA81);
// FIFO8,SYNC,!ff,DR (FIFO level = 8)
writeCmd(0xCED4);
// SYNC=2DD4;
writeCmd(0xC483);
// @PWR,NO RSTRIC,!st,!fi,OE,EN
writeCmd(0x9850);
// !mp,90kHz,MAX OUT
writeCmd(0xCC17);
// !OB1,!OB0, LPX,!ddy,DDIT,BW0
writeCmd(0xE000);
// NOT USED
writeCmd(0xC800);
// NOT USED
writeCmd(0xC040);
// 1.66MHz,2.2V
}
/**********************************************************************************
/**********************************************************************************
void FIFOReset()
{
writeCmd(0xCA81);
writeCmd(0xCA83);
}
delay_ms(2000);
putchar(200);
portInit();
rfInit();
FIFOReset();
putchar(255);
while(1)
{
for (i=0; i<5; i++)
{
dataRF[i] = rfRecv();
// Saving to Array
}
FIFOReset();
}
}
// Send to UART
// SPI clock
#define SDO
#define SDI
#define CS
#define NIRQ
// (PORTD)
/* IO CONTROL */
#define HI(x) PORTB |=
(1<<(x))
void portInit()
{
HI(CS);
HI(SDI);
LO(SCK);
DDRB = (1<<CS) | (1<<SDI) | (1<<SCK);
DDRD.2=0;
PORTD.2=1;
}
/*********************************************************************************/
unsigned int writeCmd(unsigned int cmd)
{
unsigned char i;
unsigned int recv;
recv = 0;
LO(SCK);
LO(CS);
for(i=0; i<16; i++)
{
if(cmd&0x8000)
HI(SDI);
else
LO(SDI);
HI(SCK);
recv<<=1;
if( PINB&(1<<SDO) )
{
recv|=0x0001;
}
LO(SCK);
cmd<<=1;
}
HI(CS);
return recv;
}
/*********************************************************************************/
void rfInit()
{
writeCmd(0x80E7);
// EL,EF,868band,12.0pF
writeCmd(0x8239);
// !er,!ebb,ET,ES,EX,!eb,!ew,DC
writeCmd(0xA640);
// frequency select
writeCmd(0xC647);
// 4.8kbps
writeCmd(0x94A0);
// VDI,FAST,134kHz,0dBm,-103dBm
writeCmd(0xC2AC);
// AL,!ml,DIG,DQD4
writeCmd(0xCA81);
// FIFO8,SYNC,!ff,DR
writeCmd(0xCED4);
// SYNC=2DD4
writeCmd(0xC483);
// @PWR,NO RSTRIC,!st,!fi,OE,EN
writeCmd(0x9850);
// !mp,90kHz,MAX OUT
writeCmd(0xCC17);
writeCmd(0xE000);
// NOT USED
writeCmd(0xC800);
// NOT USED
writeCmd(0xC040);
// 1.66MHz,2.2V
asm("cli");
delay_ms(2000);
portInit();
rfInit();
while(1)
{
writeCmd(0x0000);
rfSend(0xAA);
// PREAMBLE
rfSend(0xAA);
rfSend(0xAA);
rfSend(0x2D);
// SYNC
0x2DD4
rfSend(0xD4);
for(i=0; i<5; i++)
{
rfSend(0x41+i);
}
rfSend(0xAA);
rfSend(0xAA);
rfSend(0xAA);
// DUMMY BYTES
delay_ms(200);
}
}
RTC (real time clock) merupakan IC yang dapat menyimpan setting waktu. sebagai
contoh saat sebuah komputer di matikan selama 3 hari misalnya. maka saat kita ON kan
lagi waktu dalam komputer masih menunjukkan waktu saat itu, waktu tidak mengalami
kelambatan walaupun selama 3 hari tanpa sumber tegangan.
RTC merupakan IC yang dapat mempertahan setting waktu. Ada 2 macam tipe IC RTC
yaitu serial dan pararel. Untu schema di atas merupakan serial RTC. Agar waktunya sesuai
standar maka diperlukan xtal eksternal 32.768 kHz. Saat supply utama OFF IC akan dapat
suplly dari Baterai sehingga setting waktu tetap jalan. IC ini haruslah terkoneksi ke sebuah
mokrokontroler.
Real Time Clock berhubungan dengan waktu mulai dari detik, menit, jam, hari, tanggal,
bulan dan tahun. Tetapi IC RTC ini juga bisa dipakai untuk menyimpan data di dalam
internal RAM RTC ini, di mana data tersebut tidak bisa hilang meskipun supply diputus, hal
ini karena di dalam IC RTC tersebut ada battery-nya yang selalu hidup untuk menjalankan
clock-nya jadi waktu (clock) tetap berjalan meskipun supply dimatikan. IC RTC ini masih
mempunyai kelebihan bisa dipakai sebagai timer atau alarm. Untuk hitungan detik, menit,
jam, hari, tanggal, bulan dan tahun dengan tahun kabisat yang valid sampai 2100 karena
compensation valid up to 2100. Mode yang dipilih juga bisa 12 or 24 hour clock with AM dan
PM in 12 hour mode.
RTC 1307 menggunakan teknik I2C yaitu memakai 2 jalur untuk keperluan transfer
data secara seri, sedangkan SPI dan MicroWire memakai 3 jalur. Semua teknik mempunyai 1
jalur untuk Clock, I2C hanya punya satu jalur data 2 arah, sedangkan SPI dan MicroWire
mempunyai 2 jalur data satu arah, masing-masing untuk jalur data masuk dan jalur data
keluar.
KONFIGURASI PIN
Untuk lebih jelas mengenai fungsi dan kegunaan dari IC ini terlebih dahulu akan dijelaskan
fungsi dari tiap-tiap pin pada IC keluarga DS1307, di mana diketahui bahwa IC DS1307
memiliki 8 pin atau kaki, seperti pada Gambar 12.1.
2. Resistor 3 buah.
3. Kapasitor 1 buah.
8. Kabel IDC.
4. Batteray.
10. Solder.
11. Tenol.
__lcd_port=0x15
__i2c_port=0x1b
__scl_bit=1
__sda_bit=0
#include
#include
#include
#include
#include
#include
<mega32.h>
<delay.h>
<stdlib.h>
<lcd.h>
<ds1307.h>
<i2c.h>
// PortC
// PortA
void main(void)
{
lcd_init(16);
lcd_gotoxy(0, 0);
lcd_putsf("Latihan RTC");
i2c_init();
rtc_init(0,0,0);
rtc_set_time(0,0,0);
rtc_set_date(11,12,2011);
delay_ms(1000);
while (1)
{
rtc_get_time(&jam,&menit,&detik);
if(detik==0)
{
lcd_clear();
lcd_gotoxy(0, 0);
lcd_putsf("Latihan RTC");
}
str_jam[0]=(jam/10)+48;
str_jam[1]=jam%10+48;
lcd_gotoxy(0, 1);
lcd_puts(str_jam);
lcd_gotoxy(2,1);
lcd_puts(":");
str_menit[0]=(menit/10)+48;
str_menit[1]=menit%10+48;
lcd_gotoxy(3, 1);
lcd_puts(str_menit);
lcd_gotoxy(5,1);
lcd_puts(":");
// SET JAM
// SET TANGGAL
// Read Time
str_detik[0]=(detik/10)+48;
str_detik[1]=detik%10+48;
lcd_gotoxy(6, 1);
lcd_puts(str_detik);
delay_ms(1000);
}
}
dalam komputer dan peralatan elektronik lain untuk menyimpan sejumlah konfigurasi data
pada alat elektronik tersebut yang tetap harus terjaga meskipun sumber daya diputuskan,
seperti tabel kalibrasi atau kofigurasi perangkat.
Kelebihan utama dari EEPROM dibandingkan EPROM adalah ia dapat dihapus secara
elektris tanpa menggunakan cahaya ultraviolet sehingga prosesnya lebih cepat. Jika RAM
tidak memiliki batasan dalam hal read-write memori, maka EEPROM sebaliknya. Beberapa
jenis EEPROM keluaran pertama hanya dapat dihapus dan ditulis ulang (erase-rewrite)
sebanyak 100 kali sedangkan model terbaru bisa sampai 100.000 kali.
AT24C32
Serial EEPROM tipe 24xx adalah merupakan memori serial yang menggunakan
teknologi I2C di mana dengan adanya penggunaan teknologi tersebut, hanya membutuhkan
jumlah I/O yang digunakan untuk meng-akses memori tersebut semakin sedikit. Hal ini
tentunya sangat bermanfaat bagi sebuah sistem yang memerlukan banyak I/O. Penggunaan
I/O yang semakin sedikit untuk mengakses memori, akan menyediakan lebih banyak I/O
yang dapat digunakan untuk keperluan lain. I2C adalah teknologi komunikasi serial yang
ditemukan oleh Philips pada tahun 1992 dan direvisi hingga versi 2.1 yang terbaru pada
tahun 2000. Teknologi ini hanya menggunakan 2 buah jalur I/O yaitu SDA dan SCL SDA
merupakan jalur data pada komunikasi I2C
SCL merupakan jalur clock di mana sinyal clock akan selalu muncul untuk setiap bit
dari pengiriman data. Komunikasi I2C diciptakan oleh Philips bukan hanya untuk Serial
EEPROM melainkan juga diperuntukkan bagi komponen-komponen lain yang mempunyai
kemampuan untuk diakses secara I2C. Oleh karena itu, untuk membedakan antara Serial
EEPROM
dengan
komponen-komponen
yang
lain
digunakan
Slave
Address
yang
menunjukkan identitas dari komponen tersebut. Dalam hal ini Serial EEPROM mempunyai
kode 1010.
Type
AT24C01
AT24C02
AT24C04
AT24C08
AT24C16
AT24C32
AT24C64
AT24C128
AT24C256
AT24C512
Kapasitas
128 byte
256 byte
512 byte
1 Kbyte
2 Kbyte
4 Kbyte
8 Kbyte
16 Kbyte
32 Kbyte
64 Kbyte
Terlebih dahulu buat source baru dan simpan dengan nama I2Croutin.c, berikut adalah
kode programnya :
/*
*******************************************************************************
write a byte to the EEPROM
************************************************************************* */
void eeprom_write(unsigned int address, unsigned char data)
{
unsigned char addrH=address/256;
unsigned char addrL=address%256;
i2c_start();
i2c_write(AT24C32_Bus_Addr);
i2c_write(addrH);
i2c_write(addrL);
i2c_write(data);
i2c_stop();
delay_ms(10);
}
/*
**************************************************************************
read a byte from the EEPROM
******************************************************************/
unsigned char eeprom_read(unsigned int address)
{
unsigned char addrH=address/256;
unsigned char addrL=address%256;
unsigned char data;
i2c_start();
i2c_write(AT24C32_Bus_Addr);
i2c_write(addrH);
i2c_write(addrL);
i2c_start();
i2c_write(AT24C32_Bus_Addr | 1);
data=i2c_read(0);
i2c_stop();
return data;
}
Version
: 1.0.0
Date
: 09 mei 2010
Author
: Uwiex
Company
Comments
: Book Section
Chip type
: ATmega32
Program type
: Application
Clock frequency
: 12.00000000 MHz
Memory model
: Small
: 0
: 512
*****************************************************/
#asm
.equ __i2c_port=0x1B
// Port A
.equ __sda_bit=0
.equ __scl_bit=1
//
.equ __lcd_port=0x18
.equ __lcd_port=0x15
#endasm
// PORTB
// PORTC
#include <mega32.h>
#include <stdio.h>
#include <Delay.h>
#include <string.h>
#include <lcd.h>
#include <i2c.h>
#include <I2C Routine.c>
void main(void)
{
delay_ms(500);
lcd_init(16);
lcd_clear();
lcd_gotoxy( 0,0); lcd_putsf("Mulai....");
0 Baris 0
/*
eeprom_write(512,'A');
// Inisialisasi LCD
// Menulis di Kolom
eeprom_write(513,'B');
eeprom_write(514,'C');
eeprom_write(515,'D');
*/
//
DataAddr=0;
//
//
eeprom_write(DataAddr+Counter,NoID[Counter]);
while (1)
{
}
Dalam ilmu komputer dan ilmu telekomunikasi, komunikasi serial adalah proses dari
pengiriman data satu bit dalam satu waktu secara sekuensial melalui kanal komunikasi atau
bus pada komputer. Hal ini tentunya sangat kontras dengan komunikasi paralel, dimana
beberapa bit dikirimkan secara bersamaan pada sebuah jalur yang terdiri dari beberapa
kanal berkabel yang tersusun paralel. Komunikasi serial digunakan untuk semua
komunikasi long-haul dan kebanyakan jaringan komputer dimana biaya untuk kabel dan
kesulitan sinkronisasi membuat komunikasi paralel tidak praktis. Pada jarak yang lebih
dekat, bus serial pada komputer menjadi lebih umum digunakan karena kekurangan dari
bus paralel, misalnya ketidakcocokan clock dan densitas interkoneksi, mengalahkan
kelebihannya, yaitu tidak perlu ada proses serialisasi dan deserialisasi (serializer and
deserializer/SERDES). Teknologi yang berkembang untuk memastikan integritas sinyal dan
untuk mengirim dan menerima pada kecepatan per jalur yang cukup tinggi telah membuat
jalur-jalur serial menjadi kompetitif.
FTDI
chip
sendiri
adalah
sirkuit
terpadu
yang
Terlebih dahulu buat source baru, simpan dengan nama app USART.c
/*
===================================================================================
Inisialisasi USART Interrupt
Description
RXC
TXC
UDRE
FE
- Frame Error
DOR
- Data OverRun
PE
- Parity Error
U2X
MPCM
Bit
Description
RXCIE
TXCIE
UDREIE
RXEN
- Receiver Enable
TXEN
- Transmitter Enable
UCSZ2
- Character Size
RXB8
TXB8
Description
URSEL
- Register Select
UMSEL
USSEL
0
Description
-
Asyncronous Operation
5-4
UPM1:0
- Parity Mode
UPM1
UPM0
Disable / No Parity
Reserved
USBS
Description
USBS
2-1
Syncronous Operation
Description
1-bit
2-bit
UCSZ2
UCSZ2
Description
5-bit
6-bit
7-bit
8-bit
Reserved
Reserved
Reserved
9-bit
UCPOL
- Clock Polarity
UCPOL
Description
=================================================================================*/
12000000
#define BaudRate
9600
UBRRH=(XTAL/16/BaudRate-1) >> 8;
UBRRL=(XTAL/16/BaudRate-1) & 0xFF;
if (X==0)
{
UCSRA=0x00;
UCSRB=0b00011000;
Without Interrupt
// 0x18
UCSRC=0b10000110;
// 0x86
}
else
{
UCSRA=0x00;
UCSRB=0b10011000;
Interrupt
// 0x98
UCSRC=0b10000110;
// 0x86
}
}
With
#include <mega32.h>
#include <stdio.h>
#include <delay.h>
#include <lcd.h>
// PortC
void main(void)
{
InitUSART(0);
lcd_init(16);
lcd_gotoxy(0, 0);
lcd_putsf("USB to Serial");
while (1)
{
//
putchar('A');
puts("Selamat Mencoba");
delay_ms(1000);
k=getchar();
// Waiting data
lcd_gotoxy(0, 1);
lcd_putchar(k);
}