07- UART Seri İletişim Örnekleri
Merhaba sevgili okuyucu.
Bir önceki yazıda UART iletişim için kütüphane oluşturmuştuk. Bu yazıda oluşturduğumuz bu kütüphaneyi kullanara 3 örnek yapacağız. Tüm örnekleri PIC ve bilgisayar arasında yapacağız. Bilgisayar ile arasındaki bağlantıyı seri porttan direkt olarak yapabileceğimiz gibi herhangi bir seri-usb dönüştürücü kullanarak da yapabilirsiniz. Ben bu testleri elimdeki PL2303 entegreli bir dönüştürücü ile yaptım.
Donanım
Seri portta 9 pin bulunmaktadır. Bunlardan sadece üçünü kullanarak iletişimi gerçekleştireceğiz. Biri veriyi almak için bir tanesi veriyi göndermek için diğeri ise toprak (-) ucudur. İki farklı elektronik sistemi birbirine bağlamak için ortak bir uç mutlaka olması zorunludur. Genelde bu ortak uç eksi (-) uçtur. Aksi olduğu durumlar da mevcuttur tabi ki.
Unutulmaması gereken nokta şu ki bu seri port pinleri direkt olarak PIC e bağlanmamalıdır. İki cihazın TTL voltajları birbirine eşit değildir. RS232 portu +13 ve -13 volt arasını kullanırken bizim PIC imiz 5 ve 0 volt arasında konuşur. Bu durumu en basit yolla çözecek entegremiz ise adeta bir hayat kurtarıcı olan MAX232 entegresidir. 16 pine sahip ve iki giriş iki çıkış iletişim kapasitesi vardır. Yani aynı anda 2 PIC i 2 RS232 portuyla konuşturabilir. Ve bunu sadece 4 kapasitörle yapabilmektedir. Gayet basit bir devre olduğu için direkt olarak devreyi veriyorum. Kapasitöreler 1 ile 20 uF arasında olabilirler.
Bilgisayardan herhangi bir seri terminal yazılımı ile bu okumayı yapabilirsiniz. Ben linux makinemde GtkTerm aldı programı kullandım.
Yazılım
Öncelikle bir proje açıyoruz ve bir main dosyası oluşturuyoruz. Açtığımız projenin klasörüne önceki yazıda oluşturduğumu kütüphane dosyasını ekliyoruz. MPLABX de projeye sağ tıklayıp “Add Existing item…” yani “Var olan bir dosya ekle” diyerek açılan sayfadan uart.h dosyamızı seçiyoruz. MPLABX bu proje için artık kütüphane dosyamızı tanıyor. #include “uart.h” komutu ile main fonksiyonumuza da tanıtıyoruz. Artık uart.h içindeki fonksiyonları çağırabilir olacağız.
Onun yanına pic16f877a.h kütüphane dosyamızı eklemek de yararımıza olacaktır. Gerekli konfigürasyon ayarlarını yapıp saat hızımızı da belirledikten sonra çekirdek kodumuz artık hazır. Tekrar söylüyorum. Yazının buraya kadarki kısımında kavrayamadığınız bir şey var ise önceki bölümlere bakınız. Elbet bahsetmiş olmalıyım.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#define _XTAL_FREQ 20000000 #include <xc.h> #include <pic16f877a.h> #include "uart.h" //Kütüphane dosyamız ekleniyor #pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT disabled) #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off) void main(void) { return; } |
Şimdi sıra geldi uart_init() fonksiyonunu çalıştırıp iletişim ayarlarını yapmaya. 9600 bit/s lik hızı seçiyoruz. Fakat yavaş mod mu hızlı mod mu seçeceğimize datasheet e bakarak karar veriyoruz.
BRGH = 0 için 9.6Kbit hızı seçersek gerçek hız değeri 9.766K olacak. Bu durumda hata yüzdemiz %1.73 olduğunu görebiliriz.
BRGH = 1 için 9.6Kbit hızı seçersek gerçek hız değeri 9.615 olacak. Bu durumda hata yüzdemiz %0.16 olacak.
Bu tabloya bakarsak 9600 bitlik bir hız için ideal mod “hızlı” mod olacaktır. BRGH değerinin 1 olduğu. Bu yüzden uart_init(9600,1); komutunu kullanıyoruz. BRGH değerini 0 almak isterseniz. uart_init(9600,0); şeklinde kullanabilirsiniz.
Örnek 1
İlk projede 0-255 arası tüm değerleri arada belli bir süre boşluk bırakarak bilgisayara göndereceğiz. Bilgisayar tarafında hem karakter değerini hem de ASCII karşılığını göreceğiz.
Bunun için bir değişkene ihtiyacımız var. Bu değişkeni 255 e kadar birer birer arttıracağız ve her iki gönderim arasında 100 milisaniye bekleme yapacağız. Kodlar basit ve açıklamaları yanında olduğu için direkt olarak veriyorum.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
#define _XTAL_FREQ 20000000 #include <xc.h> #include <pic16f877a.h> #include "uart.h" //Kütüphane dosyamız ekleniyor #pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT disabled) #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off) void main(void) { uart_init(9600,1); //İlk ayarlamalar yapılıyor char i = 0; //8 bitlik bir değişken tanımlanıyor while(1) //Sonsuz döngü { uart_write(i); //i değişkeniyle belirlediğimiz karakter gönderiliyor __delay_ms(100); //100 milisaniye bekleme if(i==255) //eğer i değişkeni 255 değerine geldiyse sıfırlanıyor yoksa 1 arttırılıyor i=0; else i++; } return; } |
Sonuç
Terminal programınızı açıp 9600,8,N ayarlarını yaparak PIC e güç verdiğiniz taktirde bu şekilde verileri almaya başlayacaksınız. Görünüm ayalarından HEX olarak göstermeyi seçerseniz her karakterin 8 bitlik değerini görebilirsiniz. Aksi halde çektiğim videodaki sağ taraf gibi olabilir.
Örnek 2
İlk örnekte tek karakter göndermeyi denemiştik. Şimdi ise öncelikle birçok karakterden oluşan bir metin göndereceğiz. Ardından bir reel bir tam sayı göndereceğiz. Her zaman açıklayıcı bir şeyler yazmayacağımızı hatta çoğu zaman veri olarak hesaplanmış sayıların gideceğini düşünürsek bu bölüm hayli önemli.
|
1 2 3 |
float f = 1.414; int i = 56; char s[20]; |
Bu kod ile bir reel bir tam sayı bir de karakter kümesi oluşturduk. Değişkenler ile ilgili bölüm bir sonraki bölüm olacak.
|
1 |
uart_init(9600,1); |
Tekrar iletişim ayarlarımızı yaptık.
|
1 |
uart_write_text("Metin Gonderimi\r\n"); |
Daha önce kütüphanemizde oluşturduğumuz fonksiyonu çağırarak göndermek istediğimiz metini giriyoruz. Burada önemli iki nokta var. İlki Türkçe karakter kullanmamak. Bunların kullanımı bilgisayarda karşılıksız kalacaktır. İkinci nokta ise \r\n kullanımı. Burada \r ve \n birer karekteri temsil ederler. Ve bu kullanım terminale aşağı satıra geçmesini ve satır başı yapmasını söyler. Bunu kullanmamızın nedeni sonraki yazacaklarımızın bir sonraki satırda olmasını istememizdir.
|
1 |
sprintf(s, "Reel sayi = %4.2f\r\nTam sayi = %d\r\n", f, i); |
Bu kod çok önemli. Fakat bunu yazmadan önce sprintf fonksiyonunu kullanabilmek için öncelikle stdio.h kütüphanesini main fonksiyonuna eklemek gerekiyor.
|
1 |
#include <stdio.h> |
Koda geri dönecek olursak şunu görüyoruz. Öncelikle girdiğimiz değerler virgül ile ayrıldı. Bu ayrılan değerleri tek tek inceleyelim.
|
1 |
s |
|
1 |
"Reel sayi = %4.2f\r\nTam sayi = %d\r\n" |
|
1 |
f |
|
1 |
i |
Bunun anlamı şudur. s değişkenine tırnak içindeki “Reel sayi = %4.2f\r\nTam sayi = %d\r\n” değerini aktar. Fakat bunu yaparken %4.2f yerine virgülden sonra girdiğim ilk değer olan f değerini %d yerine ise virgülden sonra girdiğim ikinci değer olan i değerini koy. Bu şekilde “Reel sayi = 1.41\r\nTam sayi = 56\r\n” yazısını elde etmiş olduk. \r\n kısmının “alt satıra geç ve satır başı yap” demek olduğunu söylemiştik. Yani çıkış değerimiz şu şekilde olacak.
|
1 2 |
Reel sayi = 1.41 Tam sayi = 56 |
s karakterini oluşturduk. Sıra geldi yazmaya.
|
1 |
uart_write_text(s); |
Çoklu karakterden oluşan değerlerimizi gönderdiğimiz fonksiyona bu değişkeni vermek yeterli olmaktadır.
|
1 |
__delay_ms(5000); |
Ve 5 saniyelik beklemeyi vererek okunur halde çıktımızı elde edebiliriz.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
#define _XTAL_FREQ 20000000 #include <xc.h> #include <pic16f877a.h> #include "uart.h" #include <stdio.h> #pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT disabled) #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off) float f = 1.414; int i = 56; char s[20]; void main(void) { uart_init(9600,1); while(1) { uart_write_text("Metin Gonderimi\r\n"); //Metin gonderimi sprintf(s, "Reel sayi = %4.2f\r\nTam sayi = %d\r\n", f, i); //Degisken formatlama uart_write_text(s); __delay_ms(5000); } return; } |
Sonuç
Örnek 3
Gerek karakter gerek sayı gönderim örneklerini gördük. Sıra geldi daha heyecanlı kısma. Bilgisayardan girilen komutu okuma ve ona göre işlem yapabilme.
Bu uygulamada bilgisayardan bir değer girilmesini isteyeceğiz. Girilen değer “a” karakteri ile başlıyorsa C5 portuna bağladığımız LED yanacak. Eğer “kapat” yazılırsa LED sönecek. Bu şekilde hem tek karakter hem çoklu karakter okuma örneklerini yapmış olacağız. Burada aslında ileride bahsedeceğim bir konuya değinmiş olacağız. Kesmeler. Kesme dediğimiz yapı belirli bir şey gerçekleştiğinde o an PIC ne yapıyorsa yapsın işlem yarıda duraklatılarak bizim o öncelikli işin yapılmasını sağlamak. Yani burada kullanacağımız örnek şu şekilde olacak. Biz while ile sonsuz döngü içinde herhangi bir şey yaparken bilgisayardan gelen verinin araya kaynamamasını istiyoruz. Örneğin tasarım gereği belirli bir yere 1 saniyelik bekleme verdik. Eğer bu bekleme sırasında veri gelirse kesinlikle okuma gerçekleştirilemez. Bunu mümkün kılmak kesmelerle olasıdır. Kesme “interrupt” olarak geçer. 16F877A mikrodenetleyicide 15 kesme bulunmaktadır. Bu yazıda konusu geçecek olan kesme USART iletişim kullanırken bir veri geldiğinde oluşacak RCIE kesmesidir. PIE1 register ına bakarsak görebiliriz. Kesme ayarlarını ise INTCON register ında görebiliriz.
Öncelikle minimum kodumuzu oluşturalım.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
#define _XTAL_FREQ 20000000 #include <xc.h> #include <pic16f877a.h> #include "uart.h" #pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT disabled) #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off) void main(void) { TRISCbits.TRISC5 = 0; //RC5 pinini çıkış yap uart_init(9600,1); //UART yapılandırılıyor uart_write_text("Ledi yakmak icin ilk harfi 'a' olan bir sey yazip 'ENTER tusuna basin'\r\n"); //Açılışta seri yolla iki satır gönderiliyor uart_write_text("Ledi kapatmak icin 'kapat' yazin\r\n"); while(1) //sonsuz döngü { } return; } |
Konfigürasyon ayarlarını yaptık. Kütüphaneleri ekledik. RC5 i pin bağlayacağımız için çıkış olarak ayarladık. İletişim ayarlarını yaptık ve ekranda görünmesini istediğimiz yazıyı gönderdik.
|
1 2 3 |
RCIE = 1; //UART kesmesi aktif PEIE = 1; //Çevresel kesmelere izin ver GIE = 1; //Aktif edilmiş tüm kesmelere izin ver |
Ardından bu kodu yazıyoruz while döngüsüne henüz gelmeden main fonksiyonu altında. Burada yaptığımız şudur. RCIE kesmesini aktif et. Çevresel kesmelere izin ver. Ve izin verilmiş tüm sekmeleri çalıştır. Bunu yaparak çevresel bir kesme olan RCIE kesmesini aktif etmiş ve çalıştırmış oluyoruz. Yani veri gelince bu kesme oluşacak.
Bu kesme oluşunca oluşacak olayı yazmaya geldi sıra. Bir fonksiyon yaratıyoruz main fonksiyonu dışında.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
void interrupt uart(void) //UART kesmesi fonksiyonu { RCIE = 0; //UART kesmesi fonksiyon tamamlanana kadar devre dışı bırakılır if(PIR1bits.RCIF == 1) //Eğer kesme flag işareti varsa { PIR1bits.RCIF = 0; //flag isareti sıfırlanıyor } RCIE = 1; //UART kesmesi yeniden aktif ediliyor } |
Kodların anlamı şunu ifade ediyor. RCIE kesmesini başta devre dışı bırak. Çünkü biz işlem yaparken oluşabilecek başka bir kesme bu işleminde kesilmesine neden olabilir. Yani biz gelen veriyi incelerken RCIE kesmesinin gelip gelmediğine bakma. En sonda da zaten fonksiyondan çıkarken bunu tekrar atktif ediyoruz.
Asıl önemli kısım şu. PIR1 register ı altındaki RCIF biti.
Bu RCIE kesmesinin flag ıdır. Yani bayrağıdır. Bunu şu şekilde düşünün. Bilgisayarda bir iş yapıyorsunuz. Ama mail geldiğinde hemen o maile bakma ihtiyacınız var. Mail gelmesi bir kesmedir. Maile bakıp işinize devam edeceksiniz. İşte CRIF biti o mailin geldiğini haber veren bildirimdir. Biz bu değeri 1 olarak okursak verinin tam olarak geldiğini anlamış oluruz. Mail gelidiği an bayrağı kaldırarak bize bilgiyi veriyor. Kodda da görüleceği gibi bu değerin 1 olduğu durumda gerekli işlemleri yapacak olmamız. İşlemi yaptıktan sonra da bu değeri 0 yaparak bayrağı indiriyoruz.
Biz veriyi karakter karaker alacağımız için öncelikle bir i değişkeni oluşturup bu her karakterde bu değeri bir arttırmak kolaylık sağlayacaktır. Ayrıca karakterleri hafızaya alacağımız bir karakter dizisine ihtiyacımız var. Burada maksimum 10 karakter alabilen bir dizi işimizi görecektir. Bu değişkenleri global olarak tüm fonksiyonlardan dışarıda bir yere yazıyoruz.
|
1 2 |
char dizi[10]; int i; |
Karakter geldiğinde öncelikle karakteri geçici olarak bir yere yazmamız gerekecek. temp isimli bir karakter oluşturuyoruz ve seri yoldan gelen veriyi okuyoruz. Biz ne olduğunda işlem yapmak istiyoruz ? Bir kelime veya karakter girip “Enter” tuşuna bastığımızda. O yüzden gelen değerin “Enter” tuşu olup olmadığını kontrol etmek işimizi kolaylaştıracaktır. Eğer “Enter” tuşu gelmediyse i sıradaki dizi değişkenine karakterimizi aktarıp i değerini 1 arttırıyoruz. Bu sayede gelen kelimeyi tek tek toplayabiliriz. Eğer “Enter” tuşuna basılmışsa bizim gelen veriyi kontrol edip bir karar vermemiz gerekmektedir. Öncelikle kontrol amaçlı bu veriyi bilgisayara geri yolluyoruz.
Gönderdiğimiz veriyi okuyorsak eğer yanlış yapmamışız anlamına gelecektir bu. Ardından dizinin ilk karakterinin “a” olup olmadığına bakıyoruz. Buradaki önemli nokta dizinin ilk karakterinin 1. değil 0. karakter olması. Eğer ilk karakter “a” ise LED i yakabiliriz.
Sıra geldi “kapat” karakter dizisini okumaya. Bunu “a” karakterini okuyarak yaptığımız gibi yapamıyoruz. Tek tek “ilk harf k mi ? ikinci harf a mı ?” şeklinde de yapabiliriz fakat bu zorluğu ortadan kaldırmak için stdio.h ve string.h kütüphanelerini dosyamıza ekleyerek strcmp() fonksiyonunu kullanıyoruz. Bu fonksiyon ile dizimizin “kapat” karakterlerinden oluşup oluşmadığını sorgulayabiliriz. Fonksiyondan gelen değer 0 ise gelen verinin “kapat” olduğunu anlayabiliriz. Bu durum gerçekleşirse LED imizi kapatıyoruz. Ve ardından dizi değişkenimizi ve i değişkenimizi sıfırlayıp bir sonraki veriye hazırlıyoruz. Son durumda tüm kodumuz bu şekilde oluyor.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
#define _XTAL_FREQ 20000000 #include <xc.h> #include <pic16f877a.h> #include "uart.h" #include <stdio.h> #include <string.h> #pragma config FOSC = HS // Oscillator Selection bits (HS oscillator) #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT enabled) #pragma config PWRTE = ON // Power-up Timer Enable bit (PWRT disabled) #pragma config BOREN = ON // Brown-out Reset Enable bit (BOR enabled) #pragma config LVP = OFF // Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming) #pragma config CPD = OFF // Data EEPROM Memory Code Protection bit (Data EEPROM code protection off) #pragma config WRT = OFF // Flash Program Memory Write Enable bits (Write protection off; all program memory may be written to by EECON control) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off) char dizi[10]; int i; void interrupt uart(void) //UART kesmesi fonksiyonu { RCIE = 0; //UART kesmesi fonksiyon tamamlanana kadar devre dışı bırakılır if(PIR1bits.RCIF == 1) //Eğer kesme flag işareti varsa { char temp; //geçici değişkenimiz tanımlanıyor temp = uart_read(); //okunan 8bitlik değer değişkene atanıyor if(temp == '\r') //eğer "ENTER" tuşuna basıldıysa { uart_write_text(dizi); //dizi değişkenini seri yoldan gönder uart_write_text("\r\n"); //satır atla satır başı yap if(dizi[0]== 'a') //eğer alınan karakterlerden ilki 'a' karakteri ise RC5 e bağlı ledi yak PORTCbits.RC5 = 1; if( !strcmp(dizi, "kapat") ) //eğer alınan karakterlerin hepsi "kapat" değerini veriyorsa ledi kapat PORTCbits.RC5 = 0; for(i=0;dizi[i]!='\0';i++) //dizi değişkenini sıfırla dizi[i] = 0; i=0; //dizi karakter sırasını sıfırla } else //eğer "ENTER" tuşu dışında bir karater gönderildiyse { dizi[i] = temp; //geçici bellekteki değeri dizinin i ile tanımladığımız sırasına ata i++; //dizideki sıradaki karakter sırasını 1 arttır } PIR1bits.RCIF = 0; //flag isareti sıfırlanıyor } RCIE = 1; //UART kesmesi yeniden aktif ediliyor } void main(void) { RCIE = 1; //UART kesmesi aktif PEIE = 1; //Çevresel kesmelere izin ver GIE = 1; //Aktif edilmiş tüm kesmelere izin ver TRISCbits.TRISC5 = 0; //RC5 pinini çıkış yap uart_init(9600,1); //UART yapılandırılıyor uart_write_text("Ledi yakmak icin ilk harfi 'a' olan bir sey yazip 'ENTER tusuna basin'\r\n"); //Açılışta seri yolla iki satır gönderiliyor uart_write_text("Ledi kapatmak icin 'kapat' yazin\r\n"); while(1) //sonsuz döngü { } return; } |
Kısaca özetlersek, USART kesmesi oluştu ve gelen veriyi inceleyip LED i yakıp söndürdük. Farkettiyseniz while döngüsü boş kaldı. Buraya istediğimiz kodu yazabiliriz. Tamamen while döngüsü dışında yaptığımız bu seri iletişim örneği en sağlıklı yöntemdir veri kaybına karşı.
SONUÇ
Videoda görüldüğü gibi PIC i öncelikle resetliyorum. Bu sayede başlangıç yazısını de görmüş oluyoruz. Çünkü o yazı sadece PIC e güç verildiğinde yazacak şekilde kodlandı. Verdiğim Proteus dosyasında hex dosyasınızı simüle edip aynı sonucu alabilirsiniz.
Bir sonraki yazıda görüşmek üzere.
Proje ile ilgili MPLAB, Fritzing ve Proteus dökümanlarına aşağıdaki linkten ulaşabilirsiniz.
