pic c compiler!!

brkzkn · 2007-03-14T14:24:12.0000000+03:00

arkadaşlar şu anda mevcut pic c compiler'lar nelerdir. ve hangisini tavsiye edersiniz. ilginize şimdiden teşekkürler.

brkzkn

Yüzbaşı

872 Mesaj

Tüm Başarılarını Gör

muuzoo

Yüzbaşı

959 Mesaj

Tüm Başarılarını Gör

zarkabul

Binbaşı

1118 Mesaj

Tüm Başarılarını Gör

muuzoo

Yüzbaşı

959 Mesaj

Tüm Başarılarını Gör

Hi-Tech derleyicisi ANSI C standartları ile birebir uyumlu o yüzden c programlama dililnde kullanılan neredeyse her komutu kullanabililrsin. Sadece pic içiçn özel adlandırmalar var onaları bilmen yeterkli gibi. Misal vermek gerekirse:
TRISA=0x00 ----- A portunun tamamını çıkışyapar
PORTB=0x10------B portuna desimal olarak 16 sayısını yükler yada 4. bacağı lojik 1 diğerlerini sıfır yapar

Yarın daha ayrıntılı yazmaya çalışırım. Eğer kodları merak edersen Hitech derleyicisinin içinde kullancağın pic e göre hazırlanmış uzantısı .h olan dosyalar var oradan kullanabileceğin pic e özel değişkenleri görebililrsin gerisi ise bildiğin (bildiğini varsayıyorum) c dili. o dğişkenlerden birazını örneklyeyeim sana

static volatile unsigned char TMR0 @ 0x01;
static volatile unsigned char PCL @ 0x02;
static volatile unsigned char STATUS @ 0x03;
static unsigned char FSR @ 0x04;
static volatile unsigned char PORTA @ 0x05;
static volatile unsigned char PORTB @ 0x06;
static volatile unsigned char PCLATH @ 0x0A;
static volatile unsigned char INTCON @ 0x0B;
static volatile unsigned char PIR1 @ 0x0C;
static volatile unsigned char TMR1L @ 0x0E;
static volatile unsigned char TMR1H @ 0x0F;
static volatile unsigned char T1CON @ 0x10;
static volatile unsigned char TMR2 @ 0x11;
static volatile unsigned char T2CON @ 0x12;
static volatile unsigned char CCPR1L @ 0x15;
static volatile unsigned char CCPR1H @ 0x16;
static volatile unsigned char CCP1CON @ 0x17;
static volatile unsigned char RCSTA @ 0x18;
static volatile unsigned char TXREG @ 0x19;
static volatile unsigned char RCREG @ 0x1A;
static volatile unsigned char CMCON @ 0x1F;
static bank1 unsigned char OPTION @ 0x81;
static volatile bank1 unsigned char TRISA @ 0x85;
static volatile bank1 unsigned char TRISB @ 0x86;
static bank1 unsigned char PIE1 @ 0x8C;
static volatile bank1 unsigned char PCON @ 0x8E;
static bank1 unsigned char PR2 @ 0x92;
static volatile bank1 unsigned char TXSTA @ 0x98;
static bank1 unsigned char SPBRG @ 0x99;
static volatile bank1 unsigned char EEDATA @ 0x9A;
static bank1 unsigned char EEADR @ 0x9B;
static volatile bank1 unsigned char EECON1 @ 0x9C;
static volatile bank1 unsigned char EECON2 @ 0x9D;
static bank1 unsigned char VRCON @ 0x9F;

yada

port tanımlamaları

/* Definitions for PORTA register */
static volatile bit RA0 @((unsigned)&PORTA*8)+0;
static volatile bit RA1 @((unsigned)&PORTA*8)+1;
static volatile bit RA2 @((unsigned)&PORTA*8)+2;
static volatile bit RA3 @((unsigned)&PORTA*8)+3;
static volatile bit RA4 @((unsigned)&PORTA*8)+4;
static volatile bit RA5 @((unsigned)&PORTA*8)+5;
static volatile bit RA6 @((unsigned)&PORTA*8)+6;
static volatile bit RA7 @((unsigned)&PORTA*8)+7;

/* Definitions for PORTB register */
static volatile bit RB0 @((unsigned)&PORTB*8)+0;
static volatile bit RB1 @((unsigned)&PORTB*8)+1;
static volatile bit RB2 @((unsigned)&PORTB*8)+2;
static volatile bit RB3 @((unsigned)&PORTB*8)+3;
static volatile bit RB4 @((unsigned)&PORTB*8)+4;
static volatile bit RB5 @((unsigned)&PORTB*8)+5;
static volatile bit RB6 @((unsigned)&PORTB*8)+6;
static volatile bit RB7 @((unsigned)&PORTB*8)+7;

yukarıda gördüğün TMR0 la başlayan ve aşaığda gördüğüğn RA0 gibi ifadeler program yazarken kullanabileceğin pic e özel atamalar. Daha ayrıntılısı yuukarıda dediğim dosyalarda bulabililrsin.

brkzkn

Yüzbaşı

872 Mesaj

Tüm Başarılarını Gör

alıntı ama nereden aldıgımı hatırlamıyorum ....:
********************************************************
PIC C Derleyici
Hi-TEch Pic C lite 8.05
********************************************************
1. C PROGRAMLAMA DİLİ

C programlama dili günümüzde en yaygın olarak kullanılan programlama dillerinden biridir. Bir PC ve bir mikrokontrolör için yazılmış olan C derleyicileri her ne kadar birbirlerine benzeseler de aralarında bazı önemli farklar vardır. PC için yazılmış olan bir C derleyicisi genellikle daha büyük olup programcıya çok çeşitli fonksiyonlar sunmaktadır (örneğin dosya açıp kapama, dosya okuma vs). Bunun yanında, mikrokontrolör için yazılmış olan bir C derleyicisi daha küçük olup programcıya sunulan fonksiyon sayısı da oldukça sınırlıdır. Bununla birlikte, standart C dilini öğrenmiş olan bir programcı, kullanmış olduğu mikrokontrolörün mimarisini de bildiği takdirde çok kolaylıkla C dilinde program geliştirebilir.

PIC mikrokontrolörler için yazılmış olan çok sayıda C derleyicileri bulunmaktadır. Örneğin, Forest Electronics firmasının sunduğu FED C, Hi-Tech firmasının ürünü olan PICC ve yine ayni firmanın ürünü olan ve ücretsiz olarak verilen PICC Lite, CCS firmasının PCM ve PCW derleyicileri ve bunun gibi daha birçokları.

Bu projede Hi-Tech firmasının ürünü olan ve oldukça popüler olan PICC Lite C derleyicisi kullanılmıştır.

1.1. PICC Lite Derleyici

Hi-Tech firması tarafından geliştirilmiş olan ve ANSI C standardını izleyen bu C derleyicisi pek çok özelliklere sahip olup birçok endüstriyel uygulamalarda, öğretim ve öğrenim amaçlı, ve ayni zamanda elektronik hobi olarak kullanılmaktadır.

PICC Lite derleyicisi, yine ayni firmanın ürettiği ve pazarladığı PICC derleyicisine çok benzemekte olup, ücretsiz olduğu için bazı kısıtlamaları bulunur. Örneğin, PICC Lite sadece 16C84, 16F84, 16F84A, 16F627, 12F629, 16F877 ve 16F877A PIC mikrokontrolörleri için kullanılabilir. Bunun yanında, sadece 2 tane RAM bankı desteklemektedir (2 bank PIC16F84 için yeterli olduğu halde, PIC16F877 için yeterli olmayabilir) ve 16F877 ve 16F877A mikrokontrolörleri kullanıldığında ROM kapasitesi 2K olarak sınırlandırılmıştır. Ayrıca, PICC Lite derleyicisinde printf fonksiyonu long ve float veri çeşitleri için kullanılamaz. Bu kısıtlamalar dışında PICC Lite ve PICC derleyiciler ayni olup her iki derleyiciyi de kullanarak çok karmaşık PIC uygulamaları geliştirmek mümkündür.

Bu bölümde, PICC Lite derleyicisinin özelliklerini ve bu derleyici ile C programı geliştirmeyi inceleyeceğiz.

1.2. PICC Lite Veri Çeşitleri.

PICC Lite C derleyicisi aşağıda belirtilen veri çeşitlerini desteklemektedir. Burada küçük harf kullanıldığına dikkat edilmelidir. .

bit
unsigned char
signed char
unsigned int
signed int
long
unsigned long
float
double

Şimdi bu veri çeşitlerini örneklerle daha yakından inceleyelim.

1.2.1. bit

Bu veri çeşidinde sayılar Boolean (0 veya 1) olabilir. Örneğin, aşağıdaki tanımda değişken flag sadece 0 veya 1 değerlerini alabilir.

bit flag;

1.2.2. unsigned char

Bu veri çeşidi ile 8 bitlik sayılar tanımlanır ve bu sayılar 0 ve 255 arasında değer alabilirler. Örneğin, aşağıdaki veri tanımında değişken q, 0 ve 255 arasında herhangi bir değer alabilir ve burada q 180 olarak değerlendirilmiştir. Aynı zamanda, değişken a karakter R ye eşitlenmiştir. unsigned char tanımı ile hem 8 bitlik bir integer ve hem de bir karakter tanımlanabilir:

unsigned char q,a;
q = 180;
a=’R’;

Burada dikkat edileceği gibi, C dilinde her satır noktalı-virgül (“;”) işareti ile bitmektedir. Satır sonuna bu işaret konulmadığı takdirde derleyici hata verecektir.

1.2.3. signed char

İşaret içeren bu veri tanımı, -128 ve +127 arasındaki sayıları tanımlamak için kullanılır. Aşağıdaki örnekte değişken p’ye¬50 değeri ve değişken z’ye 28 değeri verilmiştir:

signed char p,z;
p = -50;
z = 28;

1.2.4. unsigned int

Bu tanım ile 16 bit olan ve 0 ile 65535 arasında değişen sayılar tanımlanabilir. Aşağıdaki örnekte, değişken q’ya 915 ve değişken x’e 3000 değerleri verilmiştir:

unsigned int q;
q = 915;
x = 3000;

1.2.5. signed int

İşaret içeren ve 16 bitlik sayılar için kullanılan bu tanımda, sayının -32768 ve +32767 arasında olması gerekir. Aşağıdaki örnekte değişken t’ye -500 değeri verilmiştir:

signed int t;
t = -500;

1.2.6. long

32 bit ve işaret içeren sayılar için kullanılan bu tanımda sayının -2147483648 ve +2147483647 arasında olması gerekir. Örneğin, aşağıdaki tanımda değişken m long olarak tanımlanmış ve değeri 200000 yapılmıştır:

long m;
m = 200000;

1.2.7. unsigned long

32 bit işaretsiz sayılar için kullanılan bu tanımda sayıların 0 ve 4294967295 arasında olması gerekir. Aşağıdaki örnekte değişken k unsigned long olarak tanımlanmış ve değeri 2000000 yapılmıştır:

unsigned long k;
k =2000000;

1.2.8. float

Bu tanım 24 veya 32 bitlik kayan nokta değişkenler için kullanılır. . Kayan nokta değişkenler matematik işlemlerinde çok önem taşımaktadırlar. Aşağıdaki örnekte değişken temp’e 1.23 değeri verilmiştir:

float temp;
temp = 1.23;

1.2.9. double

Bu tanımda sayılar 24 veya 32 bit olabilmektedir. Aşağıdaki örnekte değişken sum 12.45 değerini almaktadır:

double sum;
sum = 12.45;

1.3. Değişkenlere Tanım Esnasında Değer Vermek

C programlama dilinde değişkenlere tanım esnasında değer vermek mümkündür. Örneğin, aşağıda değişken temp’e tanım esnasında 10 değeri ve değişken x’e ise karakter ‘A’ değeri verilmiştir:

unsigned int temp = 10;
unsigned char x = ‘A’;

1.4. Programda Açıklayıcı Yazılar

İki tane öne eğik çizgiden (“//”) sonra yazılanlar derleyici tarafından öneme alınmamakta ve programın çalışmasını kolay anlamak için bu tip açıklayıcı yazılar tavsiye edilmektedir:

i = 0; //i değişkenini sıfır yap
j = j + 2; //j değişkenine 2 ilave et
//şimdi iki sayıyı çarp
// ve neticeyi sakla

Açıklamaları bir diğer şekilde yazma formatı ise, açıklamayı “/*” karakterleri ile başlatmak ve “*/” karakterleri ile bitirmektir. Aşağıdaki örnekte bu açıklama şekli gösterilmiştir:

/* Bu program iki tane sayıyı toplar.
Sayılardan biri x, diğeri ise y dir.
Netice z de saklanir.
*/

z = x + y;

Herhangi bir programda her iki tanım şeklini de kullanmak mümkündür.

1.5. Değişkenlerin Bellekte Saklanması

PICC Lite C derleyicisinde değişkenler normal olarak RAM bellekte (genel maksatlı yazmaçlarda) saklanmaktadır. Eğer bir değişkenin değeri sabitse ve program boyunca değişmeyecekse, o değişkeni program belleğinde (EPROM veya Flash) saklamak mümkündür. Bu şekilde, kapasitesi sınırlı olan RAM belleği çok kullanılmamış olur.

Sabit bir değişkeni program belleğinde saklamak için önüne const komutu ilave edilmeli ve değişkenin değeri tanım esnasında belirtilmelidir. Aşağıdaki örnekte temp1 değişkeni RAM belleğinde saklanır, temp2 değişkeni ise 12 değerini alır ve program belleğinde bir sabit olarak saklanır. Burada temp değişkeninin değeri program boyunca sabit olup program içerisinde değiştirilemez. temp 1 değişkeni ise istenildiği gibi ve istenilen an değiştirilebilir:

int temp1 ;
const int temp = 12;

1.6. Diziler

Diziler (arrays) benzeri bir takım değişkenleri bir grup altında toplamak için kullanılırlar. Örneğin,

int sonuc[6];

Komutu Şekil 1.1 de gösterildiği gibi 6 tane tam sayı tanımlar ve bu tam sayıların ilki sonuc[0], ikincisi sonuc , ve sonuncusu ise sonuc[5] olmaktadır.

Şekil 1_1

Örneğin, sonuc = 18 komutu sonuc dizisinin 4üncü elemanını 18 sayısına eşitler. Aynı şekilde, sonuc = sonuc komutu sonuc dizisinin 2inci elemanını 3üncü elemanına eşitler.

Bir dizinin elemanları RAM bellekte veya program belleğinde saklanabilirler. Eğer elemanların değerleri sabitse ve program boyunca değişmeyecekse, const komutu kullanarak bu elemanlar program bellekte saklanabilirler. Bu şekilde, kapasitesi kısıtlı olan RAM bellek de kullanılmamış olur. Aşağıdaki örnekte 5 elemanlı temp dizisinin elemanları program bellekte saklanırlar. Bu dizi bellekte 10 bayt tutar (her integer 2 bayt yer tutar):

const int temp[] = {1, 5, 9, 12, 45};

Aşağıdaki örnekte ise temp dizisi RAM bellekte 10 bayt tutar:

int temp[] = {1, 5, 9, 12, 45};

C programlama dilinde string değişkenleri ASCII 0 ile sonlandırılan ve bir takım karakterler ihtiva eden dizilerdir. Bu durumda,

char name[ ] = “Suzan”;

Komutunda derleyici otomatik olarak name stringi için sonuncu karakteri ASCII 0 olan 6 karakter ayırır. Bu örnekte dizi RAM bellekte saklanmıştır. Aynı dizinin başına const komutu koyarak diziyi program bellekte saklayabiliriz.

Diziler birden çok boyutlu olabilirler. Aşağıdaki örnekte ve Şekil 1.2 de 2 boyutlu bir dizi tanımlanmıştır:

int temp [5];

Şekil 1_2

Burada temp, 3 sırası ve 5 sütunu olan bir dizi olarak düşünülebilir. Dizinin ilk elemanı temp[0][0], ikinci elemanı temp[0] , üçüncü elemanı temp[0] vs dir.

Örneğin, temp[0] = 10 komutu dizinin ikinci elemanını 10 sayısına eşitler.

Dizi elemanlarını tanım esnasında belirtmek mümkündür. Aşağıdaki örnekte test dizisi RAM bellekte saklanmış ve elemanları test[0]=2, test =5, ve test =8 olarak belirlenmiştir:

int temp = {2,5,8};

1.7. Program Değişken isimleri

Program değişkenleri bir karakter veya alt çizgi (“_”) ile başlamalı ve bunu takiben istenilen miktarda karakter veya 0¬-9 arasında sayı kullanılmalıdır. Aşağıdakiler geçerli olan bazı program değişken isimleridir:

size
toplam_miktar
max5
_ortalama
j
ge2ci23ci
a_b_c_d

1.8. Static Değişkenler

Static değişkenler genel olarak bir fonksiyonda bulunan ve fonksiyonu her kullanışta değerleri değişmeyen değişkenlerdir. Bu değişkenleri tanımlarken isimleri başına static yazılır. Örneğin, bir fonksiyona girişte, fonksiyonda daha önce kullanılan bir değişkenin değeri belirsizdir. Fakat değişkeni static yapmakla değerini muhafaza etmiş oluruz.

1.9. Volatile Değişkenler

Volatile değişkenler, bir değişkenin her kullanıldığında eski değerini muhafaza edemeyeceği durumlarda kullanılır. Bütün giriş-çıkış portları ve kesme rutinlerinin değiştirdiği değişkenler volatile yapılmalıdır.

1.10. Persistent Değişkenler

Genel olarak PIC mikrokontrolör reset yapıldığında programda kullanılan bütün değişkenler ilk olarak sıfır değerini alırlar. Yalnız bazı durumlarda, birtakım değişkenlerin reset esnasında değerlerini kaybetmelerini istemeyebiliriz. Herhangi bir değişkenin ismi önüne persistent kelimesini yazmakla o değişkenin reset esnasında sıfırlanmasını istemediğimizi belirtiriz.

1.11. Mutlak Adres Değişkenleri

Bir değişkenin ismi sonuna “@” karakteri konarak o değişkene bir mutlak adres değeri verilebilir. Örneğin,

unsigned char Portbit @ 0x06;

Yukarıdaki satırda belleğin 6 ncı adresinde Portbit diye bir değişken tanımlanmıştır. Burada derleyici Portbit değişkeni için bir yer ayırmaz, fakat sadece Portbit ismini mutlak adres 6 ya eşitler. Bu tanımın assembler eşiti şudur:

Portbit EQU 06h

Bit veri çeşidi ve mutlak adres birleştirilip istenilen bir adresteki herhangi bir bit okunup değiştirilebilir. Örneğin, STATUS yazmacı bellekte adres 3 tedir. Bu yazmacın 3 üncü bitini istiyorsak, STATUS yazmacını adres 3 de tanımlayıp 3x8 + 3 = 27 nci biti şu şekilde tanımlayabiliriz:

static unsigned char STATUS @ 0x03;
static bit PD @ (unsigned)&STATUS*8+3;

Burada PD değişkeni bellekteki 27 nci biti (STATUS yazmacının 3 üncü biti) tanımlamıştır.

1.12. Operatörler

Herhangi bir programlama dilinde operatörler son derece önem taşımaktadırlar. Bütün aritmetik ve lojik işlemler bu operatörler sayesinde yapılmaktadır. PICC Lite derleyicisi aşağıdaki operatörleri desteklemektedir:

Şekil 1_2_2

1.13. Program Akış Kontrolü

Program akışını değiştiren komutlar assembler dili de olmak üzere her programlama dilinde son derece önemlidirler. Bu komutlar sayesinde döngü yapabiliriz veya bir değişkenin değerine bağlı olarak değişik işlemler yapabiliriz. PICC Lite aşağıdaki program akış kontrol komutlarını destekler:

if-else
for
while
do
goto
break
switch - case

Şimdi bu komutların kullanımlarını daha yakından inceleyelim.

1.13.1. if - else

Koşula bağlı olarak program akışını değiştiren bu komut genel olarak şu şekillerde kullanılabilir:

if(koşul)komut;

veya,

if(koşul)
{
komut;
komut;
……….
……….
komut;

}

veya,

if(koşul)
{
komut;
komut;
……….
}
else
{
komut;
komut;
……….
}

sadece bir komut içeren durumlarda şu şekilde de kullanılabilir:

if(koşul)
komut;
else
komut;

Burada, komutlar sonunda noktalı-virgül işaretlerine dikkat ediniz.

Aşağıdaki örnekte, p değişkeni 0 ise b değişkeni 1 olarak artırılır, aksi halde b değişkenine 2 ilave edilir:

if(p = = 0)
b=b+1;
else
b=b+2;

Yukarıdaki örnekte eşittir operatörü olan “= =” karakterlerinin kullanıldığına dikkat ediniz.

1.13.2. for

for komutu program içerisinde döngü yapmak için kullanılır. Döngü bir veya birtakım komutu birden fazla tekrarlamak maksadıyla kullanılır. Bu komut şu şekillerde olabilir:

for(başla; koşul; artış)komut;

veya,

for(başla; koşul; artış)
{
komut;
komut;
……….
}

burada, başla döngü değişkeninin ilk değerini, artış ise son değerini belirtmektedirler.

Aşağıdaki örnekte döngü değişkeni i, 1 den 10 a kadar gitmekte ve sayac değişkeni 10 defa artırılmaktadır.

for(i = 1 ; k = 10; i + + )sayac+ +;

for komutunu kullanarak iç içe döngü yapmak mümkündür. Aşağıdaki örnekte iç döngü 5 defa ve dış döngü ise 10 defa tekrarlanmaktadırlar:

for(i=0; i<10; i+ +)
{
for(j=0; j<5; j+ +)
{
komut;
.........
}
}

1.13.3. while

Döngü yapmak için kullanılan bir başka komut da while komutu olup bu komutun genel kullanım şekli şu şekildedir:

while(koşul)komut;

veya,

while(koşul)
{
komut;
komut;
.........
}

Belirtilen koşul doğru olduğu müddetçe döngü devam etmektedir. Eğer döngü başında seçenek doğru değilse döngü içerisindeki komutlar işlem görmezler. Aşağıdaki örnekte döngü 10 defa tekrarlanmaktadır:

i=0;
while(i < 10)
{
komut;
komut;
i++;
}

while komutunu kullanırken döngü içerisinde koşulun sağlanmasına dikkat etmemiz gerekir, aksi halde sonsuz bir döngü elde etmiş oluruz.

1.13.4. do

Döngü yapmak için kullanılan bir diğer komut ise do komutudur. Burada seçenek döngünün sonunda kontrol edilir ve bundan dolayı koşul doğru olmasa bile döngü en az¬ bir defa çalışmış olur. Bu komutun genel kullanımı şu şekildedir:

do
{
komut;
komut;
……..
}while(koşul);

Aşağıdaki örnekte döngü değişkeni j, 0 dan 5 e kadar gitmekte ve döngü 5 defa tekrarlanmaktadır:

j = 0;
do
{
komut;
komut;
j++;
}while < 5);

while komutunu kullanırken döngü içerisinde koşulun sağlanmasına dikkat etmemiz gerekir, aksi halde sonsuz bir döngü elde etmiş oluruz. Ayni zamanda, koşul sağlansa bile döngü en az bir defa yapılmaktadır.

1.13.5. break

break komutu, bir döngü içerisinde ve döngü bitmeden, döngü dışına çıkmak için kullanılmaktadır. Aşağıdaki örnekte j değişkeni 10 olunca döngü durur ve döngü sonrasındaki komutlar işlem görürler. Bu komut bir sonra göreceğimiz switch-case komutunda çok kullanılmaktadır:

while(i < 100)
{
komut;
komut;
if(j = = 10)break;
}

1.13.6. switch - case

Bu komut, çoklu if-else komutu gibi görev yapmaktadır. Bir değişken alınır ve bu değişkenin değerine bağlı olarak çeşitli komutlar işlem görürler.

Aşağıdaki örnekte, sec değişkeninde bulunan ve ‘A’ ve ‘F’ arasında olan 1-digit bir hexadecimal sayının decimal sayıya dönüştürülmesi gösterilmiştir. Dönüştürülen sayı hex gibi bir değişkende saklanmıştır:

Switch(sec)
{
Case’A’: hex = 65;
break;
Case’B’: hex = 66;
break;
Case’C’: hex = 67;
break;
Case’D’: hex = 68;
break;
Case’E’: hex = 69;
break;
Case’F’: hex = 70;
break;
default: hex = 0;
break;
}

Burada, sec değişkeninin değeri ‘A’ ise hex değişkeni 65 olur, ‘B’' ise hex değişkeni 66 olur, ‘C’ ise hex değişkeni 67 olur v.s. Eğer sec değişkeni ‘A’ ve ‘F’ arasında değilse default komutu çalıştırılır ve bu örnekte hex değişkeni 0 a eşitlenir. switch-case komutunda break komutunun çok sık olarak kullanıldığına dikkat ediniz (eğer break kullanılmazsa program bir sonraki koşula devam etmektedir).

1.14 Kullanıcı Fonksiyonları

Fonksiyonlar genel olarak bir program içerisinde kullanılan ve ana programdan bağımsız programdırlar. Her fonksiyonun bir ismi olup istenilirse bir fonksiyon ana programa bilgi aktarabilir. Başında void komutu ile başlayan fonksiyonlar ana programa bilgi aktaramazlar. Örneğin, aşağıdaki fonksiyonun ismi ledon olup bu fonksiyon ana programa bilgi aktarmaz.

void ledon()
{
led = 1;
}

Aşağıdaki ledon fonksiyonu ise ana programa integer bir bilgi aktarır:

int ledon()
{
komut;
komut;
return(değişken);
}

Fonksiyonlar ana programdan bilgi alıp bu bilgiyi işler ve tekrar ana programa bilgi aktarabilirler. Aşağıdaki örnekte kare fonksiyonu ana programdan bir integer değer alır (parameter) ve bunun karesini alıp ana programa aktarır:

int kare(int y)
{
int w;
w = y*y;
return (w) ;
}
Bu fonksiyon ana program tarafından şu şekilde kullanılabilir:

s = kare(p);

Kare fonksiyonu ana programdan p değişkeninin değerini alır ve bu sayının karesini alıp geri ana programa aktarır. Fonksiyon başındaki int tanımı fonksiyonun ana programa integer (tam sayı) aktaracağını gösterir. Bu durumda, ana programdaki s değişkeni p nin karesine eşitlenmiş olur.
Burada önemli olan bir nokta, fonksiyonda kullanılan w ve y değişkenleri sadece fonksiyona ait olup ana programda olan bir w veya y değişkeni ile hiçbir ilgileri yoktur. Ayni zamanda, ana programda kullanılan bir değişken ile fonksiyonda kullanılan ve aynı ismi taşıyan herhangi bir değişken arasında bir bağıntı yoktur.

Örnek 3.2
Tabanı ve yüksekliği bilinen bir üçgenin alanını hesaplayan bir fonksiyon yazınız ve bulduğunuz alanı ana programa aktarınız.

Çözüm 3.2
Tabanı ve yüksekliği bilinen bir üçgenin alanı, olarak bulunabilir. Bu durumda, istenilen fonksiyon aşağıda verilmiştir. Değişkenlerin herhangi bir sayı olabilecekleri göz önünde bulundurularak float veri çeşidi kullanılmıştır:

float alan(float taban, float yukseklık)
{
float i;
i = (taban * yukseklik)/2;
return(i) ;
}

Tabanın 23.2 ve yüksekliğin ise 3.4 olduğunu kabul edersek bu fonksiyon ana program tarafından şu şekilde çağrılabilir:

hesap = alan(23.2, 3.4);

Burada, alan fonksiyon tarafından hesaplanır ve hesap diye adlandırılan bir değişkende saklanır. hesap değişkeni, ana programda float olarak tanımlanmalıdır.

1.15 Ön-işlemci Direktifleri

PICC Lite derleyici, diğer standart C derleyicilerde bulunan çeşitli ön-işlemci direktiflerini destekler. Yaygın olarak kullanılan ön-işlemci direktifleri aşağıda açıklanmıştır.

1.15.1 #define
Bu direktif program başında kullanılır ve bir makro gibi çalışıp semboller yerine tanımlanan eşitlerini koyar.

Örneğin;
#define size 10
#define max 100
#define min 0

program içerisinde bu semboller kullanıldığı zaman yerlerine otomatik olarak değerleri konur:

a = 1; // a değişkenini 1 yap
a = a + size; // a değişkeni 11 değerini alır

define direktifi çok kompleks de olabilmektedir. Aşağıdaki makro tanımında 2*(a+b) işlemi mult(a,b) olarak tanımlanmıştır:

#define mult(a,b) 2*(a + b)

Şimdi bu makronun bir program içerisinde kullanımına bakalım.

a = 2; // a değişkenini 2 yap
b = 5; // b değişkenini 5 yap
c = mult(a,b); // c değişkeni 2*(2+5)=14 olur

Örnek 3.3
Bir integer 2 bayt’tan meydana gelmektedir. Böyle bir integer’in üst ve alt byte’larını almak için “define” komutunu kullanarak makro yazınız.

Çözüm 3.3
Üst baytı almak için sayıyı 8 defa sağa kaydırabiliriz. Makro adına ustbayt dersek,

#define usfbayt(x) (unsigned char)(x>>8)

olur. Alt baytı bulmak için ise, sayıyı, 0xFF (desimal 255) ile mask yapabiliriz. Makro adına altbayt dersek,

#define altbayt(x) (unsigned char)(x & 0xFF)

olur.

Örnek 3.4
Bir değişkenin herhangi bir bitini 1 veya 0 yapmak için “define” direktifini kullanarak bir makro yazınız.

Çözüm 3.4
Herhangi bir biti 1 yapmak için kullanacağımız makroya bit_set dersek, şu şekilde yazabiliriz:

#define bit_set(var, bitno) ((var) │= (1<< (bitno)))

Herhangi bir biti 0 yapmak için, kullanacağımız makroya bit_reset dersek, şu şekilde yazabiliriz:

#define bit_reset(var, bitno) ((yar) &= ~(1<< (bitno)))

Örneğin, x değişkeninin bit 3 ünü 1 yapmak için şu komutu kullanabiliriz:

bit_set(x,3) ;
Aynı şekilde, p değişkeninin 6 cı bitini 0 yapmak için şu komutu kullanabiliriz:

bit_reset(p,6);

1.15.2 #asm ve #endasm

Bu direktifler sayesinde bir assembler programı, veya bir veya birkaç assembler komutları C programımıza ilave edilebilir:

..........
..........
a=2;
#asm
movlw 10h
#endasm
.............
.............

Yukarıdaki programda görüleceği gibi assembler komutları #asm ve #endasm direktifleri arasına yerleştirilmelidir.

1.15.3 #include

Bu direktifi kullanarak başka bir text dosyasını programımız içerisine alabiliriz. Örneğin, “myproject.h” dosyası programımıza şu şekilde ilave edilebilir:

#include “myproject.h”

veya,

#include <myproject.h>

PIC yazılımı geliştirirken <pic.h> dosyası programımıza ilave edilmelidir. Bu dosya içerik olarak PIC mikrokontrolöre ait çeşitli değişkenleri tanımlamaktadır.

1.16 Programda Değişik Sayı Tabanı Kullanımı

PICC Lite derleyicisinin normal sayı tabanı 10 (desimal) olup birçok mikroişlemci ve mikrokontrolör uygulamalarında kullanılan sayı tabanının zaman zaman değiştirilmesi gerekmektedir. Örneğin, mikrokontrolör tabanlı kontrol uygulamalarında genellikle 16 tabanı (hexadecimal) veya 8 tabanı (octal) kullanılmaktadır.

Bir sayıyı hexadecimal olarak yazmak için önüne %x (veya %0X), octal olarak yazmak için önüne %o ve ikili tabanda yazmak için ise önüne 0b koymak gerekir. Aşağıda değişik tabanlarda bazı örnekler verilmiştir:

toplam = %0x1f; // toplam = 0001 1111
sum = %o37; // sum = 011 111
a = 0b00001111 // a = 00001111

1.17 Yapılar (Structures)

Yapılar, birbirleriyle ilgili olan çeşitli değişkenleri yeni bir değişken altında toplamak için kullanılır. Örneğin, bir şahıs hakkındaki, bir takım bilgiler normal olarak şu şekilde tanımlanabilir:

unsigned char adi[80];
unsigned char soyadi[80];
unsigned int yasi;
unsigned char adresi[80];

Bir yapı (structure) kullanarak yukarıdaki tanımları şu şekilde yazabiliriz:

struct sahsi
{
unsigned char adi[80];
unsigned char soyadi[80];
unsigned int yasi;
urisigned char adresi[80];
}

Bu durumda, sahsi yapısı bir şahıs hakkında olan bütün tanımları bir çatı altında toplamış olur. Bir yapı yukarıdaki gibi tanımlandığı zaman bellekte hiçbir yer tutmaz. Ancak bu yapı bir sonraki örnekte gösterildiği zaman kullanıldığı zaman bellekte yer tutar.

Şimdi, aşağıdaki yeni tanımı yapabiliriz:

struct sahsi benim_bilgiler;

Yukarıdaki tanım ile benim_bilgiler yeni bir değişken olup bu değişkenin çeşidi sahsi’dir ve bu değişken bellekte yer tutar. Şimdi, bu yeni değişkeni kullanarak şu komutu yazabiliriz:

Benim_bilgiler.yasi = 25;

Yapıları kullanarak bir değişkene istenilen sayıda bit ayırabiliriz. Aşağıdaki örnekte x ve y 1 bitlik değişkendirler ve z ise 6 bitlik bir değişkendir. Değişken temp flags çeşidi bir yapıya sahip olup bellekte toplam 1 bayt tutmaktadır:

struct flags
{
unsigned char x:1;
unsigned char y:1;
unsigned char z:6;
}

struct flags temp;

1.18 İşaretçiler (Pointers)

C programlama dilinde işaretçi kavramı çok geniş olarak kullanılmaktadır. Genel olarak bir işaretçi bir değişkenin bellekteki adresini gösterir. Örneğin, x bir değişken ise, x’i gösteren bir işaretçi x’in bellekteki adresini tutar. İşaretçiler, değişken ismi önüne “*” karakteri koyarak tanımlanırlar. Değişken çeşidine göre işaretçi çeşidi de değişmektedir. Örneğin, bir karakter işaretçisi bir integer için kullanılamaz. Aşağıdaki örnekte, p bir karakter işaretçisi olarak tanımlanmıştır:

char *p;

Burada p bir karakter işaretçisi olarak tanımlandığı halde şu an herhangi bir yerde kullanılmış değildir. Herhangi bir değişken önüne “&” karakterini koyarak o değişkenin adresini elde edebiliriz. Daha sonra da işaretçi değişkenini kullanabiliriz. Örneğin, işaretçi p’ye, z değişkeninin adresini şu şekilde yükleyebiliriz:

p = &z;

p işaretçisi şimdi z değişkeninin adresini tutmaktadır. “*” operatörünü kullanarak, adresi bilinen bir değişkenin asıl değerini okuyabiliriz. Aşağıdaki örnekte, daha önce tanımlanan z değişkeninin değeri 3 yapılmıştır:

*p = 3;

Herhangi bir değişkenin adresine erişebilme birçok uygulamalarda çok kullanışlı olmaktadır. Bu şekilde daha verimli ve daha kısa programlar geliştirmek, mümkün olabilmektedir.

İşaretçiler dizilerde çok kullanışlı olmaktadırlar. Bir dizinin ismi o dizinin adresini tutmaktadır. Bu durumda, bir işaretçi kullanarak dizi işlemlerini kolaylıkla yapabiliriz. Bir örnek aşağıda verilmiştir:

char buffer[10]; // 10 elemanı olan bir buffer tanımlama
char *p; // p bir karakter işaretçisidir
p = buffer; // p işaretçiye buffer adresi yüklendi
*p = 0; // buffer dizisinin ilk elemanını 0 yap
p++; // p’yi artır (sonraki elemanı adresle)
*p = 1; // buffer’in ikinci elemanını 1 yap

Yukarıda da görüleceği gibi işaretçiler ile çeşitli aritmetik işlemler yapmak ve değişik adreslere gitmek mümkündür.

1.19 EEPROM Belleğe Yazıp Okuma

Bazı PIC mikrokontrolörlerde (örneğin PIC16F84) EEPROM bellek bulunmaktadır. Bu belleğe yazıp okumak için PICC Lite derleyicinin EEPROM_WRITE ve EEPROM_READ diye iki tane fonksiyonu bulunmaktadır.

EEPROM_WRITE(adres, veri) fonksiyonu belleğin adresine veriyi yazar. Örneğin, EEPROM_WRITE(5, 12) komutu belleğin 5 inci adresine 12 sayısını yazar.

EEPROM_READ(adres) fonksiyonu belleğin adresinden veri okur. Örneğin, z = EEPROM_READ(14) komutu belleğin 14 üncü adresindeki veriyi okur ve değişken z yi bu veriye eşitler.

1.20 Konfigürasyon Bitleri

PIC mikrokontrolörün konfigürasyon bitleri “_CONFIG(x)” komutunu kullanarak istenildiği gibi seçilebilir. Burada x istenilen konfigürasyondur. Aşağıdaki örnekte Bekçi Köpek devreden çıkarılır, XT kristal modu seçilir ve kod koruması yapılmaz:

_CONFIG(WDTDIS & XT & UNPROTECT);

PIC konfigürasyon bitlerini yonganın programlanması esnasında programlayıcı yazılımızla da istediğimiz gibi seçebiliriz.
------------------------------------------------------------------------------------------

klutch

Binbaşı

1205 Mesaj

Tüm Başarılarını Gör

yucelnet

Yarbay

2178 Mesaj

Tüm Başarılarını Gör

brkzkn

Yüzbaşı

872 Mesaj

Tüm Başarılarını Gör

muuzoo

Yüzbaşı

959 Mesaj

Tüm Başarılarını Gör

brkzkn

Yüzbaşı

872 Mesaj

Tüm Başarılarını Gör

brkzkn

Yüzbaşı

872 Mesaj

Tüm Başarılarını Gör

muuzoo

Yüzbaşı

959 Mesaj

Tüm Başarılarını Gör

NiQuitinCQ

Yüzbaşı

715 Mesaj

Tüm Başarılarını Gör

brkzkn

Yüzbaşı

872 Mesaj

Tüm Başarılarını Gör

klutch

Binbaşı

1205 Mesaj

Tüm Başarılarını Gör

Benzer içerikler