PIC Programlama – 7 – Kesmeler (Interrupts) 2

31 July 2015 by ozenozkaya

Merhabalar, geçen yazıda RB0/INT kesmesini bahane ederek kesmeler hakkında bir takım feyizli işler yapmıştık. Bu yazımızda da kesmelere olan sevgimizi ve ilgimizi pekiştirerek, ilginç bir başka örnek yapacağız ve yeni ibretlerle karşılaşacağız. PIC mikrodenetleyicilerde de bir taş üstüne bir taş daha koyalım diyerekten bu günkü örneğimizi PORTB değişme kesmesi üzerinden gerçekleyeceğiz.

Bundan seneler önce, gömülü sistemlerdeki ilk dönemlerimde; keypad (tuş takımı) sürmekten nefret ederdim çünkü mikrodenetleyicilerde kullanımı hem zordu hem de inanılmaz derecede verimsiz idi. Tuş takımının pinlerini matris gibi düşünürsek, sütünları ikili düzende her seferinde bir pin 1’de diğerleri 0’da olacak şekilde, 1 olan pini bir kaydırarak sürerdik ve o esnada da satır pinlerini input olarak ayarlayıp değerini okuyup hangi pine basıldığını anlamaya çalışırdık. Bu olay son derece can sıkıcı bir olaydı ama neyse ki bu can sıkıcı durumu uzunca bir süredir unutmuştum. Ta ki bu yazıyı kafamda planlayana kadar. Bu yazı, bu çirkin yönteme bir tepki olabilirdi, olacak da.

Bir donanımı sürmek için yazılan kodun kesmeler yerine polling (sürekli değer okuma/yazma yani bir nevi deneme yanılma) ile sürülmesi gerek performans açısından gerek güç tüketimi açısından kötü bir durum. Öte yandan tuş takımı sürülmesini anlatan resmi dökümanlar bile en iyi çözüm olarak kesme/polling hibrit kodlar veriyorlar. Bu da oldukça verimsiz bir duruma tekabül ediyor. Daha önce tuş takımı süren arkadaşlar eminim anlayacaklardır. Tuştakımı sürme işinin sadece kesme ile yapılabilmesi güzel olurdu. Öyleyse sadece kesmeyle yapalım 🙂 Arada PORTB değişme kesmesini de anlatmış olacağız.

keypad

Gördüğünüz üzere b portunun 4-7 arası pinleri pull down yaparak satır girişlerine bağladık. Yine 0-3 arası pinlerle keypadin sütun pinlerini süreceğiz. Pull down amaçlı koyduğumuz dirençler bize çok yardımcı olacak 😉 Şimdi gelelim kodlara. Öncelikle güncellediğimiz kütüphanelerimiz aşağıdaki gibi:

/* 
 * File:   pic16f84a_lib.h
 * Author: ozenozkaya
 *
 * Created on 20 Temmuz 2015 Pazartesi, 00:05
 */

#ifndef PIC16F84A_LIB_H
#define    PIC16F84A_LIB_H

#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)
#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)

#define REG_TRISA_ADDR (0x85)
#define REG_TRISA (*( volatile unsigned char*)REG_TRISA_ADDR)
    
#define TRIS_PIN_OUTPUT (0)
#define TRIS_PIN_INPUT  (1)
#define TRIS_PORT_OUTPUT (0)
#define TRIS_PORT_INPUT  (0xFF)

#define REG_PORTB_ADDR (0x06)
#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)
    
#define REG_PORTA_ADDR (0x05)
#define REG_PORTA (*( volatile unsigned char*)REG_PORTA_ADDR)
    
#define PORT_PIN_LOW  (0)
#define PORT_PIN_HIGH (1)
#define PORT_ALL_LOW  (0)
#define PORT_ALL_HIGH (0xFF)


#define REG_INTCON_ADDR (0x0B)
#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)
#define INT_ENABLE (1)
#define INT_DISABLE (0)
#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)
#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)
#define INT_EDGE_FALLING (0)
#define INT_EDGE_RISING  (1)
    
#define MAX_INT_CALLBACK_NUM (2)

typedef struct 
{
    //one bit is stored in one BYTE
    uint8_t pin0:1;
    uint8_t pin1:1;
    uint8_t pin2:1;
    uint8_t pin3:1;
    uint8_t pin4:1;
    uint8_t pin5:1;
    uint8_t pin6:1;
    uint8_t pin7:1;
}_tris_port_pin_t, *_tris_port_pin_ptr_t;

typedef struct
{
    uint8_t RBIF:1;
    uint8_t INTF:1;
    uint8_t T0IF:1;
    uint8_t RBIE:1;
    uint8_t INTE:1;
    uint8_t T0IE:1;
    uint8_t EEIE:1;
    uint8_t GIE:1;
}_intcon_reg_t,*_intcon_reg_ptr_t;

typedef struct
{
    uint8_t PS:3;
    uint8_t PSA:1;
    uint8_t T0SE:1;
    uint8_t T0CS:1;
    uint8_t INTEDG:1;
    uint8_t RBPU:1;
}_option_reg_t,*_option_reg_ptr_t;

typedef union
{
    _tris_port_pin_t pins;
    uint8_t port;
}tris_port_t,*tris_port_ptr_t;

typedef union
{
  _option_reg_t bits;
  uint8_t value;  
}option_reg_t, *option_reg_ptr_t;

typedef union
{
  _intcon_reg_t bits;
  uint8_t value;  
}intcon_reg_t, *intcon_reg_ptr_t;

typedef void (*rb0_int_callback_t)();
typedef void (*portb_int_callback_t)();


int8_t register_rb0_int_callback(rb0_int_callback_t new_cb);
int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg);

int8_t register_portb_int_callback(portb_int_callback_t new_cb);
int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg);

#ifdef __cplusplus
}
#endif

#endif /* PIC16F84A_LIB_H */

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

* File: pic16f84a_lib.h

* Author: ozenozkaya

* Created on 20 Temmuz 2015 Pazartesi, 00:05

#ifndef PIC16F84A_LIB_H

#define PIC16F84A_LIB_H

#ifdef __cplusplus

extern "C" {

#endif

#include <stdint.h>

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)

#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)

#define REG_TRISA_ADDR (0x85)

#define REG_TRISA (*( volatile unsigned char*)REG_TRISA_ADDR)

#define TRIS_PIN_OUTPUT (0)

#define TRIS_PIN_INPUT (1)

#define TRIS_PORT_OUTPUT (0)

#define TRIS_PORT_INPUT (0xFF)

#define REG_PORTB_ADDR (0x06)

#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)

#define REG_PORTA_ADDR (0x05)

#define REG_PORTA (*( volatile unsigned char*)REG_PORTA_ADDR)

#define PORT_PIN_LOW (0)

#define PORT_PIN_HIGH (1)

#define PORT_ALL_LOW (0)

#define PORT_ALL_HIGH (0xFF)

#define REG_INTCON_ADDR (0x0B)

#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)

#define INT_ENABLE (1)

#define INT_DISABLE (0)

#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)

#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)

#define INT_EDGE_FALLING (0)

#define INT_EDGE_RISING (1)

#define MAX_INT_CALLBACK_NUM (2)

typedef struct

{

//one bit is stored in one BYTE

uint8_t pin0:1;

uint8_t pin1:1;

uint8_t pin2:1;

uint8_t pin3:1;

uint8_t pin4:1;

uint8_t pin5:1;

uint8_t pin6:1;

uint8_t pin7:1;

}_tris_port_pin_t, *_tris_port_pin_ptr_t;

typedef struct

{

uint8_t RBIF:1;

uint8_t INTF:1;

uint8_t T0IF:1;

uint8_t RBIE:1;

uint8_t INTE:1;

uint8_t T0IE:1;

uint8_t EEIE:1;

uint8_t GIE:1;

}_intcon_reg_t,*_intcon_reg_ptr_t;

typedef struct

{

uint8_t PS:3;

uint8_t PSA:1;

uint8_t T0SE:1;

uint8_t T0CS:1;

uint8_t INTEDG:1;

uint8_t RBPU:1;

}_option_reg_t,*_option_reg_ptr_t;

typedef union

{

_tris_port_pin_t pins;

uint8_t port;

}tris_port_t,*tris_port_ptr_t;

typedef union

{

_option_reg_t bits;

uint8_t value;

}option_reg_t, *option_reg_ptr_t;

typedef union

{

_intcon_reg_t bits;

uint8_t value;

}intcon_reg_t, *intcon_reg_ptr_t;

typedef void (*rb0_int_callback_t)();

typedef void (*portb_int_callback_t)();

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb);

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg);

int8_t register_portb_int_callback(portb_int_callback_t new_cb);

int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg);

#ifdef __cplusplus

}

#endif

#endif /* PIC16F84A_LIB_H */

Ve yukarıdaki header dosyasına ilişkin kaynak kodu aşağıda:

#include "pic16f84a_lib.h"

#define BIT_TOGGLE(x) (x^=1)

#ifndef NULL
#define NULL ((void*)0)
#endif

rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];
portb_int_callback_t portb_int_callback_list[MAX_INT_CALLBACK_NUM];

static void interrupt global_isr_handler()
{
    intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;
    option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;
    
    uint32_t cb_index=0;
    if(intcon_reg_ptr->bits.INTF)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL != rb0_int_callback_list[cb_index])
            {
                rb0_int_callback_list[cb_index]();
            }
        }
        BIT_TOGGLE(option_reg_ptr->bits.INTEDG);
        intcon_reg_ptr->bits.INTF=INT_FLAG_CLEAR;
    }
    
    if(intcon_reg_ptr->bits.RBIF)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL != portb_int_callback_list[cb_index])
            {
                portb_int_callback_list[cb_index]();
            }
        }
        BIT_TOGGLE(option_reg_ptr->bits.INTEDG);
        intcon_reg_ptr->bits.RBIF=INT_FLAG_CLEAR;
    }
}

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)
{
    uint32_t cb_index=0;
    if(NULL != new_cb)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL == rb0_int_callback_list[cb_index])
            {
                rb0_int_callback_list[cb_index]=new_cb;
            }
        }
        if(MAX_INT_CALLBACK_NUM == cb_index)
        {
            return -2; //All callbacks are already registered
        }
    }
    else
    {
        return -1; // Callback is NULL
    }
    return 0;
}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)
{
    uint32_t cb_index=0;
    if(NULL != cb_to_unreg)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(cb_to_unreg == rb0_int_callback_list[cb_index])
            {
                rb0_int_callback_list[cb_index]=NULL;
            }
        }
    }
    else
    {
        return -1; // Callback is NULL
    }
    return 0;
}

int8_t register_portb_int_callback(portb_int_callback_t new_cb)
{
    uint32_t cb_index=0;
    if(NULL != new_cb)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL == portb_int_callback_list[cb_index])
            {
                portb_int_callback_list[cb_index]=new_cb;
            }
        }
        if(MAX_INT_CALLBACK_NUM == cb_index)
        {
            return -2; //All callbacks are already registered
        }
    }
    else
    {
        return -1; // Callback is NULL
    }
    return 0;
}



int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg)
{
    uint32_t cb_index=0;
    if(NULL != cb_to_unreg)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(cb_to_unreg == portb_int_callback_list[cb_index])
            {
                portb_int_callback_list[cb_index]=NULL;
            }
        }
    }
    else
    {
        return -1; // Callback is NULL
    }
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

#include "pic16f84a_lib.h"

#define BIT_TOGGLE(x) (x^=1)

#ifndef NULL

#define NULL ((void*)0)

#endif

rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];

portb_int_callback_t portb_int_callback_list[MAX_INT_CALLBACK_NUM];

static void interrupt global_isr_handler()

{

intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;

option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

uint32_t cb_index=0;

if(intcon_reg_ptr->bits.INTF)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(NULL != rb0_int_callback_list[cb_index])

{

rb0_int_callback_list[cb_index]();

}

BIT_TOGGLE(option_reg_ptr->bits.INTEDG);

intcon_reg_ptr->bits.INTF=INT_FLAG_CLEAR;

}

if(intcon_reg_ptr->bits.RBIF)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(NULL != portb_int_callback_list[cb_index])

{

portb_int_callback_list[cb_index]();

}

BIT_TOGGLE(option_reg_ptr->bits.INTEDG);

intcon_reg_ptr->bits.RBIF=INT_FLAG_CLEAR;

}

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)

{

uint32_t cb_index=0;

if(NULL != new_cb)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(NULL == rb0_int_callback_list[cb_index])

{

rb0_int_callback_list[cb_index]=new_cb;

}

if(MAX_INT_CALLBACK_NUM == cb_index)

{

return -2; //All callbacks are already registered

}

else

{

return -1; // Callback is NULL

}

return 0;

}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)

{

uint32_t cb_index=0;

if(NULL != cb_to_unreg)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(cb_to_unreg == rb0_int_callback_list[cb_index])

{

rb0_int_callback_list[cb_index]=NULL;

}

else

{

return -1; // Callback is NULL

}

return 0;

}

int8_t register_portb_int_callback(portb_int_callback_t new_cb)

{

uint32_t cb_index=0;

if(NULL != new_cb)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(NULL == portb_int_callback_list[cb_index])

{

portb_int_callback_list[cb_index]=new_cb;

}

if(MAX_INT_CALLBACK_NUM == cb_index)

{

return -2; //All callbacks are already registered

}

else

{

return -1; // Callback is NULL

}

return 0;

}

int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg)

{

uint32_t cb_index=0;

if(NULL != cb_to_unreg)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(cb_to_unreg == portb_int_callback_list[cb_index])

{

portb_int_callback_list[cb_index]=NULL;

}

else

{

return -1; // Callback is NULL

}

return 0;

}

Gördüğünüz gibi TRISA ve PORTA kütüklerini de modelledik ve ayrıca kütüphaneyi PORTB kesmesini de destekleyecek hale getirdik. Şimdi gelelim main fonksiyonunun bulunduğu main.c’ye 🙂

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 20 Temmuz 2015 Sali, 23:47
 */

#include "pic16f84a_lib.h"

#define KEYPAD_DRIVE0_PIN pins.pin0
#define KEYPAD_DRIVE1_PIN pins.pin1
#define KEYPAD_DRIVE2_PIN pins.pin2

#define KEYPAD_SCAN0_PIN pins.pin4
#define KEYPAD_SCAN1_PIN pins.pin5
#define KEYPAD_SCAN2_PIN pins.pin6
#define KEYPAD_SCAN3_PIN pins.pin7
    
static void keypad_event_manager()
{
    tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;
    tris_port_t *porta_ptr=(tris_port_ptr_t)REG_PORTA_ADDR;
    uint8_t cnt=0;

    portb_ptr->port |=0x01;
    for(cnt=0;cnt<3;cnt++)
    {
        portb_ptr->port &= 0xF8;  
        portb_ptr->port |= (1 << cnt);
        
        switch((portb_ptr->port&0xF0)>>4)
        {
            case 1:
                porta_ptr->port=0x01+cnt;
                break;
            case 2:
                porta_ptr->port=0x04+cnt;
                break;
            case 4:
                porta_ptr->port=0x07+cnt;
                break;
            case 8:
                switch(cnt)
                {
                    case 0:
                        porta_ptr->port=0x0A;
                        break;
                    case 1:
                        porta_ptr->port=0x00;
                        break;
                    case 2:
                        porta_ptr->port=0x0B;
                        break;
                }
                break;
            default:
                break;

        } 
    }
    
    portb_ptr->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;
    portb_ptr->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;
    portb_ptr->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;
            
}

static void initialize_keypad_and_leds()
{
    tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;
    tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;
    tris_port_t *porta_ptr=(tris_port_ptr_t)REG_PORTA_ADDR;
    tris_port_t *trisa_ptr=(tris_port_ptr_t)REG_TRISA_ADDR;
    
    trisb_ptr->port = TRIS_PORT_INPUT;
    trisb_ptr->KEYPAD_SCAN0_PIN = TRIS_PIN_INPUT;
    trisb_ptr->KEYPAD_SCAN1_PIN = TRIS_PIN_INPUT;
    trisb_ptr->KEYPAD_SCAN2_PIN = TRIS_PIN_INPUT;
    trisb_ptr->KEYPAD_SCAN3_PIN = TRIS_PIN_INPUT;
    trisb_ptr->KEYPAD_DRIVE0_PIN = TRIS_PIN_OUTPUT;
    trisb_ptr->KEYPAD_DRIVE1_PIN = TRIS_PIN_OUTPUT;
    trisb_ptr->KEYPAD_DRIVE2_PIN = TRIS_PIN_OUTPUT;
    
    portb_ptr->port = PORT_ALL_LOW;
    portb_ptr->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;
    portb_ptr->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;
    portb_ptr->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;
    
    trisa_ptr->port = TRIS_PORT_OUTPUT;
    porta_ptr->port = PORT_ALL_LOW;
   
}

static void initialize_keypad_event()
{
    intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;
    option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;
    
    register_portb_int_callback(keypad_event_manager);
    
    option_reg_ptr->bits.INTEDG = INT_EDGE_RISING;
        
    intcon_reg_ptr->bits.RBIF= INT_FLAG_CLEAR;
    intcon_reg_ptr->bits.RBIE = INT_ENABLE;
    intcon_reg_ptr->bits.GIE = INT_ENABLE;     
}

void main() {

    initialize_keypad_and_leds();
    initialize_keypad_event();
      
    while(1);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

* File: main.c

* Author: ozenozkaya

* Created on 20 Temmuz 2015 Sali, 23:47

#include "pic16f84a_lib.h"

#define KEYPAD_DRIVE0_PIN pins.pin0

#define KEYPAD_DRIVE1_PIN pins.pin1

#define KEYPAD_DRIVE2_PIN pins.pin2

#define KEYPAD_SCAN0_PIN pins.pin4

#define KEYPAD_SCAN1_PIN pins.pin5

#define KEYPAD_SCAN2_PIN pins.pin6

#define KEYPAD_SCAN3_PIN pins.pin7

static void keypad_event_manager()

{

tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;

tris_port_t *porta_ptr=(tris_port_ptr_t)REG_PORTA_ADDR;

uint8_t cnt=0;

portb_ptr->port |=0x01;

for(cnt=0;cnt<3;cnt++)

{

portb_ptr->port &= 0xF8;

portb_ptr->port |= (1 << cnt);

switch((portb_ptr->port&0xF0)>>4)

{

case 1:

porta_ptr->port=0x01+cnt;

break;

case 2:

porta_ptr->port=0x04+cnt;

break;

case 4:

porta_ptr->port=0x07+cnt;

break;

case 8:

switch(cnt)

{

case 0:

porta_ptr->port=0x0A;

break;

case 1:

porta_ptr->port=0x00;

break;

case 2:

porta_ptr->port=0x0B;

break;

}

break;

default:

break;

}

portb_ptr->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;

portb_ptr->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;

portb_ptr->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;

}

static void initialize_keypad_and_leds()

{

tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;

tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;

tris_port_t *porta_ptr=(tris_port_ptr_t)REG_PORTA_ADDR;

tris_port_t *trisa_ptr=(tris_port_ptr_t)REG_TRISA_ADDR;

trisb_ptr->port = TRIS_PORT_INPUT;

trisb_ptr->KEYPAD_SCAN0_PIN = TRIS_PIN_INPUT;

trisb_ptr->KEYPAD_SCAN1_PIN = TRIS_PIN_INPUT;

trisb_ptr->KEYPAD_SCAN2_PIN = TRIS_PIN_INPUT;

trisb_ptr->KEYPAD_SCAN3_PIN = TRIS_PIN_INPUT;

trisb_ptr->KEYPAD_DRIVE0_PIN = TRIS_PIN_OUTPUT;

trisb_ptr->KEYPAD_DRIVE1_PIN = TRIS_PIN_OUTPUT;

trisb_ptr->KEYPAD_DRIVE2_PIN = TRIS_PIN_OUTPUT;

portb_ptr->port = PORT_ALL_LOW;

portb_ptr->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;

portb_ptr->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;

portb_ptr->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;

trisa_ptr->port = TRIS_PORT_OUTPUT;

porta_ptr->port = PORT_ALL_LOW;

}

static void initialize_keypad_event()

{

intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;

option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

register_portb_int_callback(keypad_event_manager);

option_reg_ptr->bits.INTEDG = INT_EDGE_RISING;

intcon_reg_ptr->bits.RBIF= INT_FLAG_CLEAR;

intcon_reg_ptr->bits.RBIE = INT_ENABLE;

intcon_reg_ptr->bits.GIE = INT_ENABLE;

}

void main() {

initialize_keypad_and_leds();

initialize_keypad_event();

while(1);

}

Gördüğünüz gibi gerekli pin ayarlamalarını yaptıktan sonra, kesmeyi aşağıdaki gibi aktive ettik:

intcon_reg_ptr->bits.RBIE = INT_ENABLE;

1	intcon_reg_ptr->bits.RBIE = INT_ENABLE;

Ardından, yazdığımız kütüphaneye eklediğimiz callback registration (fonksiyon bildirimi kaydı) mekanizmasını kullanarak kesme geldiğinde, haberdar olmak için initialize_keypad_event fonksiyonunu implement ettik. Buna göre PORTB’nin 4-7 arası pinlerinde gerilimsel bir değişme olduğunda haberdar olacağız. Yükselen kenarı ilk konfigurasyon olarak almamızın sebebi ise, keypad satır pinlerimizi donanımsal olarak pull-down’a yani lojik sıfıra çekmiş olmamız. Pull-down ne demek bilmiyorsanız buradan öğrenebilirsiniz.

Bu durumda kodumuz tamamen kesme ile çalışacak şekilde tamamlanmış oldu ve başarıyla da çalışıyor. Ancak yine içimize sinmeyen bazı noktalar var. Bunlardan birincisi şu aşağıdaki satır.

portb_ptr->port &= 0xF8;

1	portb_ptr->port &= 0xF8;

Bu satırın amacı, B portunun ilk 3 pinini 0 değerine çekmek ama bunu yaparken diğerlerini değiştirmemek. Aslında bu satır daha anlaşılır şekilde aşağıdaki gibi de implement edilebilirdi.

portb_ptr->KEYPAD_DRIVE0_PIN = PORT_PIN_LOW;
portb_ptr->KEYPAD_DRIVE1_PIN = PORT_PIN_LOW;
portb_ptr->KEYPAD_DRIVE2_PIN = PORT_PIN_LOW;

portb_ptr->KEYPAD_DRIVE0_PIN = PORT_PIN_LOW;

portb_ptr->KEYPAD_DRIVE1_PIN = PORT_PIN_LOW;

portb_ptr->KEYPAD_DRIVE2_PIN = PORT_PIN_LOW;

Peki neden yukarıdaki gibi yazmadık? Çok daha anlaşılır olurdu oysa ki. İşte burada cevap “performans”. Tek satır olan kod eğer diğerinden daha kısa sürede işletiliyorsa, o zaman zaman kaybetmemek için anlaşılırlıktan feda edilebilir, ki burada yapılan da o 🙂 Ancak bu durumda bile anlaşılırlığı kaybetmemek mümkün. Nasıl mı? Comment yani yorum satırları ekleyerek. Bu vesileyle bir kez daha yorum satırlarının ne denli önemli olduğuna değinmekte fayda var. Kodu iyileştirmek için aklımda bazı hinlikler var ama önce kodun bellek kullanımına bakalım.

Yukarıdaki kodun bellek kullanımı aşağıdaki gibi:

Memory Summary:
    Program space        used   264h (   612) of   400h words   ( 59.8%)
    Data space           used    25h (    37) of    44h bytes   ( 54.4%)
    EEPROM space         used     0h (     0) of    40h bytes   (  0.0%)
    Data stack space     used     0h (     0) of    1Fh bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     1h word    (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)

Memory Summary:

Program space used 264h ( 612) of 400h words ( 59.8%)

Data space used 25h ( 37) of 44h bytes ( 54.4%)

EEPROM space used 0h ( 0) of 40h bytes ( 0.0%)

Data stack space used 0h ( 0) of 1Fh bytes ( 0.0%)

Configuration bits used 0h ( 0) of 1h word ( 0.0%)

ID Location space used 0h ( 0) of 4h bytes ( 0.0%)

Şimdi iyileştirme yaptığımız main.c dosyamıza bakalım.

/**
 * @file main.c
 * @author Özen Özkaya
 * @date 31 July 2015
 * @brief File containing example of keypad interfacing by using PORTB 
 * interrupt of PIC16F84A. Keypad is attached to B port pins of PIC and a 
 * 7-SEG display is attached to A port pins of PIC. Application displays the
 * last pressed number of keypad on 7-SEG led display. 
 *
 * This file is freely published and distributed in my blog.
 * @see http://ozenozkaya.com/blog/
 */

#include "pic16f84a_lib.h"

#define KEYPAD_DRIVE0_PIN pins.pin0
#define KEYPAD_DRIVE1_PIN pins.pin1
#define KEYPAD_DRIVE2_PIN pins.pin2

#define KEYPAD_SCAN0_PIN pins.pin4
#define KEYPAD_SCAN1_PIN pins.pin5
#define KEYPAD_SCAN2_PIN pins.pin6
#define KEYPAD_SCAN3_PIN pins.pin7

#define KEYPAD_DIRECTION_REG    ((tris_port_ptr_t)REG_TRISB_ADDR)
#define KEYPAD_PORT_REG         ((tris_port_ptr_t)REG_PORTB_ADDR)

#define SEVEN_SEG_DIRECTION_REG    ((tris_port_ptr_t)REG_TRISA_ADDR)
#define SEVEN_SEG_PORT_REG         ((tris_port_ptr_t)REG_PORTA_ADDR)
 

/**
 * @brief keypad_event_manager function is an interrupt callback function.
 *
 * We register this function for PORTB change interrupt event. Normally,
 * keypad drive & scan is done here. When user is pressed to any key in
 * keypad, interrupt occurs and this callback is called by our library.
 * Then here we scan & drive keypad pins to detect the pressed button.
 * @see http://ozenozkaya.com/blog
 * @note Please share if you like :)
 * @warning Do not forget to register this function with: .
 * @code
 * register_portb_int_callback(keypad_event_manager);
 * @endcode
 */
static void keypad_event_manager()
{
    uint8_t cnt=0;

    KEYPAD_PORT_REG->KEYPAD_SCAN0_PIN =PORT_PIN_HIGH;
    for(cnt=0;cnt<3;cnt++)
    {
        KEYPAD_PORT_REG->port &= 0xF8;  
        /*Here we are shifting the drive pin. Possible values:
         1 0 0
         0 1 0
         0 0 1
         By the way we scan each row*/
        KEYPAD_PORT_REG->port |= (1 << cnt);
        
        switch((KEYPAD_PORT_REG->port&0xF0)>>4)
        {
            case 1:
                SEVEN_SEG_PORT_REG->port=0x01+cnt;
                break;
            case 2:
                SEVEN_SEG_PORT_REG->port=0x04+cnt;
                break;
            case 4:
                SEVEN_SEG_PORT_REG->port=0x07+cnt;
                break;
            case 8:
                switch(cnt)
                {
                    case 0:
                        SEVEN_SEG_PORT_REG->port=0x0A;
                        break;
                    case 1:
                        SEVEN_SEG_PORT_REG->port=0x00;
                        break;
                    case 2:
                        SEVEN_SEG_PORT_REG->port=0x0B;
                        break;
                }
                break;
            default:
                break;

        } 
    }
    
    KEYPAD_PORT_REG->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;
    KEYPAD_PORT_REG->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;
    KEYPAD_PORT_REG->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;
            
}

static void initialize_keypad_and_leds()
{   
    KEYPAD_DIRECTION_REG->port = TRIS_PORT_INPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_SCAN0_PIN = TRIS_PIN_INPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_SCAN1_PIN = TRIS_PIN_INPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_SCAN2_PIN = TRIS_PIN_INPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_SCAN3_PIN = TRIS_PIN_INPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_DRIVE0_PIN = TRIS_PIN_OUTPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_DRIVE1_PIN = TRIS_PIN_OUTPUT;
    KEYPAD_DIRECTION_REG->KEYPAD_DRIVE2_PIN = TRIS_PIN_OUTPUT;
    
    
    KEYPAD_PORT_REG->port = PORT_ALL_LOW;
    KEYPAD_PORT_REG->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;
    KEYPAD_PORT_REG->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;
    KEYPAD_PORT_REG->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;
    
    SEVEN_SEG_DIRECTION_REG->port = TRIS_PORT_OUTPUT;
    SEVEN_SEG_PORT_REG->port = PORT_ALL_LOW;
   
}

static void initialize_keypad_event()
{    
    register_portb_int_callback(keypad_event_manager);
    
    ((option_reg_ptr_t)REG_OPTION_ADDR)->bits.INTEDG = INT_EDGE_RISING;
        
    ((intcon_reg_ptr_t)REG_INTCON_ADDR)->bits.RBIF= INT_FLAG_CLEAR;
    ((intcon_reg_ptr_t)REG_INTCON_ADDR)->bits.RBIE = INT_ENABLE;
    ((intcon_reg_ptr_t)REG_INTCON_ADDR)->bits.GIE = INT_ENABLE;     
}

void main() {

    initialize_keypad_and_leds();
    initialize_keypad_event();
      
    while(1);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

/**

* @file main.c

* @author Özen Özkaya

* @date 31 July 2015

* @brief File containing example of keypad interfacing by using PORTB

* interrupt of PIC16F84A. Keypad is attached to B port pins of PIC and a

* 7-SEG display is attached to A port pins of PIC. Application displays the

* last pressed number of keypad on 7-SEG led display.

* This file is freely published and distributed in my blog.

* @see http://ozenozkaya.com/blog/

#include "pic16f84a_lib.h"

#define KEYPAD_DRIVE0_PIN pins.pin0

#define KEYPAD_DRIVE1_PIN pins.pin1

#define KEYPAD_DRIVE2_PIN pins.pin2

#define KEYPAD_SCAN0_PIN pins.pin4

#define KEYPAD_SCAN1_PIN pins.pin5

#define KEYPAD_SCAN2_PIN pins.pin6

#define KEYPAD_SCAN3_PIN pins.pin7

#define KEYPAD_DIRECTION_REG ((tris_port_ptr_t)REG_TRISB_ADDR)

#define KEYPAD_PORT_REG ((tris_port_ptr_t)REG_PORTB_ADDR)

#define SEVEN_SEG_DIRECTION_REG ((tris_port_ptr_t)REG_TRISA_ADDR)

#define SEVEN_SEG_PORT_REG ((tris_port_ptr_t)REG_PORTA_ADDR)

/**

* @brief keypad_event_manager function is an interrupt callback function.

* We register this function for PORTB change interrupt event. Normally,

* keypad drive & scan is done here. When user is pressed to any key in

* keypad, interrupt occurs and this callback is called by our library.

* Then here we scan & drive keypad pins to detect the pressed button.

* @see http://ozenozkaya.com/blog

* @note Please share if you like :)

* @warning Do not forget to register this function with: .

* @code

* register_portb_int_callback(keypad_event_manager);

* @endcode

static void keypad_event_manager()

{

uint8_t cnt=0;

KEYPAD_PORT_REG->KEYPAD_SCAN0_PIN =PORT_PIN_HIGH;

for(cnt=0;cnt<3;cnt++)

{

KEYPAD_PORT_REG->port &= 0xF8;

/*Here we are shifting the drive pin. Possible values:

1 0 0

0 1 0

0 0 1

By the way we scan each row*/

KEYPAD_PORT_REG->port |= (1 << cnt);

switch((KEYPAD_PORT_REG->port&0xF0)>>4)

{

case 1:

SEVEN_SEG_PORT_REG->port=0x01+cnt;

break;

case 2:

SEVEN_SEG_PORT_REG->port=0x04+cnt;

break;

case 4:

SEVEN_SEG_PORT_REG->port=0x07+cnt;

break;

case 8:

switch(cnt)

{

case 0:

SEVEN_SEG_PORT_REG->port=0x0A;

break;

case 1:

SEVEN_SEG_PORT_REG->port=0x00;

break;

case 2:

SEVEN_SEG_PORT_REG->port=0x0B;

break;

}

break;

default:

break;

}

KEYPAD_PORT_REG->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;

KEYPAD_PORT_REG->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;

KEYPAD_PORT_REG->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;

}

static void initialize_keypad_and_leds()

{

KEYPAD_DIRECTION_REG->port = TRIS_PORT_INPUT;

KEYPAD_DIRECTION_REG->KEYPAD_SCAN0_PIN = TRIS_PIN_INPUT;

KEYPAD_DIRECTION_REG->KEYPAD_SCAN1_PIN = TRIS_PIN_INPUT;

KEYPAD_DIRECTION_REG->KEYPAD_SCAN2_PIN = TRIS_PIN_INPUT;

KEYPAD_DIRECTION_REG->KEYPAD_SCAN3_PIN = TRIS_PIN_INPUT;

KEYPAD_DIRECTION_REG->KEYPAD_DRIVE0_PIN = TRIS_PIN_OUTPUT;

KEYPAD_DIRECTION_REG->KEYPAD_DRIVE1_PIN = TRIS_PIN_OUTPUT;

KEYPAD_DIRECTION_REG->KEYPAD_DRIVE2_PIN = TRIS_PIN_OUTPUT;

KEYPAD_PORT_REG->port = PORT_ALL_LOW;

KEYPAD_PORT_REG->KEYPAD_DRIVE0_PIN = PORT_PIN_HIGH;

KEYPAD_PORT_REG->KEYPAD_DRIVE1_PIN = PORT_PIN_HIGH;

KEYPAD_PORT_REG->KEYPAD_DRIVE2_PIN = PORT_PIN_HIGH;

SEVEN_SEG_DIRECTION_REG->port = TRIS_PORT_OUTPUT;

SEVEN_SEG_PORT_REG->port = PORT_ALL_LOW;

}

static void initialize_keypad_event()

{

register_portb_int_callback(keypad_event_manager);

((option_reg_ptr_t)REG_OPTION_ADDR)->bits.INTEDG = INT_EDGE_RISING;

((intcon_reg_ptr_t)REG_INTCON_ADDR)->bits.RBIF= INT_FLAG_CLEAR;

((intcon_reg_ptr_t)REG_INTCON_ADDR)->bits.RBIE = INT_ENABLE;

((intcon_reg_ptr_t)REG_INTCON_ADDR)->bits.GIE = INT_ENABLE;

}

void main() {

initialize_keypad_and_leds();

initialize_keypad_event();

while(1);

}

Yapılan değişiklikleri kısaca sıralarsak:

Register erişimi için değişken kullanımını ortadan kaldırdık. Ve bu iş için hiç değişken kullanmadık!
Bellek bayram etti (mi acaba, göreceğiz 🙂 ama etti)
Kodun anlaşılabilirliğini çeşitli define ve yorum satırları ile boost ettik.
Doxygen stili dökümantasyon yaparak (hepsini yapmasak da 😉 ) o işi de kodun üzerinde aradan çıkardık.

Ve güncellenmiş main kodumuzun olduğu uygulamanın bellek kullanımı:

Memory Summary:
    Program space        used   1B8h (   440) of   400h words   ( 43.0%)
    Data space           used    1Dh (    29) of    44h bytes   ( 42.6%)
    EEPROM space         used     0h (     0) of    40h bytes   (  0.0%)
    Data stack space     used     0h (     0) of    27h bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     1h word    (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)

Memory Summary:

Program space used 1B8h ( 440) of 400h words ( 43.0%)

Data space used 1Dh ( 29) of 44h bytes ( 42.6%)

EEPROM space used 0h ( 0) of 40h bytes ( 0.0%)

Data stack space used 0h ( 0) of 27h bytes ( 0.0%)

Configuration bits used 0h ( 0) of 1h word ( 0.0%)

ID Location space used 0h ( 0) of 4h bytes ( 0.0%)

Gördüğünüz üzere program alanı kullanımını 612’den 440 worde (1 word=2 byte) düşürdük. Ayrıca veri alanı kullanımını da 37 byte’dan 29 byte’a düşürdük 🙂 İşte bu elle tutulur bir optimizasyon.

Keypad’i de tertemiz, kesme kullanarak sürmüş olduk. Arada PORTB değişme kesmesi nasıl kullanılır onu da hallettik. Sayısız ibretlere de değindiğimizden bu günlük bu kadar diyoruz 🙂

Yazıları beğendiyseniz, faydalanabilecek tanıdıklarınızla paylaşmayı unutmayınız.

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 6 – Kesmeler (Interrupts)

20 July 2015 by ozenozkaya

Önceki yazımızda PIC16F84A’nın pinlerini kontrol etmeyi işlemiştik. Elbette ki buraya kadarki bilgilerle çok sayıda uygulama yapmak mümkün ancak bu yazı dizisi altyapı oluşturma amacı taşıdığından şimdilik farklı uygulamaları geleceğe bırakarak altyapı çalışmalarına devam diyoruz. Mikrokontrolör’ün giriş çıkış arayüzlerini detaylıca inceledikten sonra sıra geldi kesmelere. Önce genel manada kesmelerin ne olduğuna değinip, ardından da port ve pin kesmeleri ile devam edeceğiz. Mikrokontrolör’ün çevresellerinden bazıları farklı tipte kesmeler destekler. Örneğin zamanlayıcı kesmelerine, zamanlayıcı modülünde değineceğiz. Hazır port/pin kontrolünü görmüşken bu yazıda port/pin kesmelerine değineceğiz.

Kesme nedir demeden önce, mikrokontrolör ve CPU arasındaki farkları hatırlayalım. CPU (işlemci, merkezi işlem birimi) mikrokontrolör içerisindeki bir modüldür. Mikrokontrolör içinde, CPU’ya ek olarak bellek ve çevreseller (perihperal) bulunur. CPU içerisinde genelde aritmetik/lojik işlemleri yapan bir modül (ALU) bulunur. Hemen PIC16F84A’nın yapısını inceleyelim. Bu blog diyagram PIC16F84A’nın veri kağıdından alındı.

Diyagramda ALU’ya dikkat ediniz. Onu CPU olarak düşünebilirsiniz. ALU’dan W reg’e giden yolda sağa doğru bir kanal olduğunu göreceksiniz. O kanal I/O portlarına, TMR (timer, zamanlayıcı) modüllerine ve daha nice yerlere gidiyor. Bu kaçak kanal, olası bir kesme sinyalinin ALU’ya müdahale edebildiğinin bir kanıtı. Bu yazının sonunda da resmin sağ alt kısmında yer alan RB0/INT’in ne olduğu anlatılacak.

Kesme Nedir?

Kesmeleri tanımlamak uygulamada göstermekten zor bir iştir ama şöyle bir tanım yapmak mümkün: Kesme (interrupt), CPU’nun dışındaki bir dış etken tarafından oluşturulan ve oluştuğunda CPU’nun yaptığı işi durdurup, ayrı bir özel kod parçacığının işletilmesini (yürütülmesini) sağlayan elektriksel bir işarettir. Kesme oluştuğunda işletilen bu koda genelde kesme servis rutini (interrupt service routine, ISR) denir. Kesme oluştuğu anda, ISR’ye gitmeden önce, CPU program işletiminde kaldığı yeri kaydeder. ISR’nin işletimi bittiği anda da CPU bu kayıtlı noktadan yani kaldığı yerden programı işletmeye devam eder.

Kesme asenkron gerçekleşen bir olaydır, yani ne zaman gerçekleşeceğini CPU önceden bilmez. Gündelik hayattan buna benzer bir süreç örneği verecek olursak; kapı zilinin ya da telefonun çalması durumlarını örnek verebiliriz. Diyelim yemek yapıyorsunuz, zil çaldı; yemek yapmayı bırakıp kapıyı açıp yemek yapmaya devam ederiz. Zil çalınca, yahu dur sırası mıydı demeyiz. Ya da sürekli kapıyı kontrol etmeden zilin ne zaman çalacağını bilemeyiz. Bununla birlikte, kapının çalışını duymazdan gelmeniz bir seçenektir tabi ki. Aynı şeyler kesmeler için de geçerli 🙂

Kesmeler, gömülü sistemlerde çok çok önemli bir yere sahiptir. Kesmeler’in düzgün kullanımı ile tasarlanmış bir sistem daha verimli, daha duyarlı (responsive) ve daha anlaşılır şekilde tasarlanabilir. Kesmeler düzgün kullanılmazsa da “yaa böyle olmaması lazımdı ama, çok saçma, böyle çalışmaması lazımdı ama” sözleri havada uçuşur, işin içinden çıkılmaz. Halbuki dostlar, her şey deterministik 🙂 Çok güçlü ama biraz da tehlikeli olduklarından bazı yazılımcılar kesmelerden korkar ama gömülü sistem programcısı kesmeden korkmamalı, kesmelerle samimi olmalı, onları son derece işeyarar ve güçlü bir arkadaş olarak görmelidir. Zira, etrafınızda gördüğünüz gömülü sistemlerden en az bir kesme kullanmayanı bulmak sıradışı bir olaydır. Sözün özü, kesme candır.

Farklı mikrokontrolör mimarilerinde kesmeler farklı şekillerde ele alınır. Şimdi PIC’ten başlayalım. Yine ibretlerle dolu bir uygulama yapacağız.

Switch ve Led Uygulaması

Bir önceki yazımıza yaptığımız uygulamada, while döngüsünün içerisinde switch’in durumunu sürekli kontrol etmiştik. Buna polling deniyor ve ekstrem derecede verimsiz bir yöntemdir bu. Bunun yerine kesme kullansaydık, sadece anahtarın durumu değiştiğinde ledlerin durumuna müdahale edebileceğimiz bir senaryo oluşacaktı. Bu da ileride özellikle güç tüketimi anlamında da bize avantajlar sağlayacaktı. Haydi sağlasın madem. Uygulamayı bu defa kesme kullanarak yapacağız. Yine switch bir konumda iken kırmızı yanar sarı söner durumda olacak, switch diğer konumdayken sarı yanar kırmızı söner durumda olacak. Yine bu uygulamada da kod yazımımızı bir kaç adım öteye taşıyacağız ancak önce kaldığımız yerden devam edelim 🙂

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 02 Haziran 2015 Sali, 12:47
 */
#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)
#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)
#define TRIS_PIN_OUTPUT (0)
#define TRIS_PIN_INPUT  (1)
#define TRIS_PORT_OUTPUT (0)
#define TRIS_PORT_INPUT  (0xFF)

#define REG_PORTB_ADDR (0x06)
#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)
#define PORT_PIN_LOW  (0)
#define PORT_PIN_HIGH (1)
#define PORT_ALL_LOW  (0)
#define PORT_ALL_HIGH (0xFF)

#define SWITCH_PIN pins.pin0
#define RED_LED_PIN pins.pin1
#define YELLOW_LED_PIN pins.pin2

#define LED_ON (PORT_PIN_HIGH)
#define LED_OFF (PORT_PIN_LOW)

#define REG_INTCON_ADDR (0x0B)
#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)
#define INT_ENABLE (1)
#define INT_DISABLE (0)
#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)
#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)
#define INT_EDGE_FALLING (0)
#define INT_EDGE_RISING  (1)

#define BIT_TOGGLE(x) (x^=1)

typedef struct 
{
    unsigned char pin0:1;
    unsigned char pin1:1;
    unsigned char pin2:1;
    unsigned char pin3:1;
    unsigned char pin4:1;
    unsigned char pin5:1;
    unsigned char pin6:1;
    unsigned char pin7:1;
}tris_port_pin_t;

typedef struct
{
    unsigned char RBIF:1;
    unsigned char INTF:1;
    unsigned char T0IF:1;
    unsigned char RBIE:1;
    unsigned char INTE:1;
    unsigned char T0IE:1;
    unsigned char EEIE:1;
    unsigned char GIE:1;
}intcon_reg_t,*intcon_reg_ptr_t;

typedef struct
{
    unsigned char PS:3;
    unsigned char PSA:1;
    unsigned char T0SE:1;
    unsigned char T0CS:1;
    unsigned char INTEDG:1;
    unsigned char RBPU:1;
}option_reg_t,*option_reg_ptr_t;

typedef union
{
    tris_port_pin_t pins;
    volatile unsigned char port;
}tris_port_t,*tris_port_ptr_t;

tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;
tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;
intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;
option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;
    
static void interrupt global_isr_handler()
{
    if(intcon_reg_ptr->INTF)
    {
        switch(portb_ptr->SWITCH_PIN)
            {
                case PORT_PIN_LOW:
                    portb_ptr->RED_LED_PIN = LED_ON;
                    portb_ptr->YELLOW_LED_PIN = LED_OFF;
                    break;
                case PORT_PIN_HIGH:
                    portb_ptr->RED_LED_PIN = LED_OFF;
                    portb_ptr->YELLOW_LED_PIN = LED_ON;    
                    break;
                default:
                    break;        
            }
        BIT_TOGGLE(option_reg_ptr->INTEDG);
        intcon_reg_ptr->INTF=INT_FLAG_CLEAR;
    }
}


void main() {
    trisb_ptr->port = TRIS_PORT_INPUT;
    trisb_ptr->SWITCH_PIN = TRIS_PIN_INPUT;
    trisb_ptr->RED_LED_PIN = TRIS_PIN_OUTPUT;
    trisb_ptr->YELLOW_LED_PIN = TRIS_PIN_OUTPUT;
    
    portb_ptr->port = PORT_ALL_LOW;
    
    
    intcon_reg_ptr->INTF = INT_FLAG_CLEAR;
    intcon_reg_ptr->INTE = INT_ENABLE;
    intcon_reg_ptr->GIE = INT_ENABLE;
    
    option_reg_ptr->INTEDG = INT_EDGE_RISING; 
      
    while(1);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

* File: main.c

* Author: ozenozkaya

* Created on 02 Haziran 2015 Sali, 12:47

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)

#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)

#define TRIS_PIN_OUTPUT (0)

#define TRIS_PIN_INPUT (1)

#define TRIS_PORT_OUTPUT (0)

#define TRIS_PORT_INPUT (0xFF)

#define REG_PORTB_ADDR (0x06)

#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)

#define PORT_PIN_LOW (0)

#define PORT_PIN_HIGH (1)

#define PORT_ALL_LOW (0)

#define PORT_ALL_HIGH (0xFF)

#define SWITCH_PIN pins.pin0

#define RED_LED_PIN pins.pin1

#define YELLOW_LED_PIN pins.pin2

#define LED_ON (PORT_PIN_HIGH)

#define LED_OFF (PORT_PIN_LOW)

#define REG_INTCON_ADDR (0x0B)

#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)

#define INT_ENABLE (1)

#define INT_DISABLE (0)

#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)

#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)

#define INT_EDGE_FALLING (0)

#define INT_EDGE_RISING (1)

#define BIT_TOGGLE(x) (x^=1)

typedef struct

{

unsigned char pin0:1;

unsigned char pin1:1;

unsigned char pin2:1;

unsigned char pin3:1;

unsigned char pin4:1;

unsigned char pin5:1;

unsigned char pin6:1;

unsigned char pin7:1;

}tris_port_pin_t;

typedef struct

{

unsigned char RBIF:1;

unsigned char INTF:1;

unsigned char T0IF:1;

unsigned char RBIE:1;

unsigned char INTE:1;

unsigned char T0IE:1;

unsigned char EEIE:1;

unsigned char GIE:1;

}intcon_reg_t,*intcon_reg_ptr_t;

typedef struct

{

unsigned char PS:3;

unsigned char PSA:1;

unsigned char T0SE:1;

unsigned char T0CS:1;

unsigned char INTEDG:1;

unsigned char RBPU:1;

}option_reg_t,*option_reg_ptr_t;

typedef union

{

tris_port_pin_t pins;

volatile unsigned char port;

}tris_port_t,*tris_port_ptr_t;

tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;

tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;

intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;

option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

static void interrupt global_isr_handler()

{

if(intcon_reg_ptr->INTF)

{

switch(portb_ptr->SWITCH_PIN)

{

case PORT_PIN_LOW:

portb_ptr->RED_LED_PIN = LED_ON;

portb_ptr->YELLOW_LED_PIN = LED_OFF;

break;

case PORT_PIN_HIGH:

portb_ptr->RED_LED_PIN = LED_OFF;

portb_ptr->YELLOW_LED_PIN = LED_ON;

break;

default:

break;

}

BIT_TOGGLE(option_reg_ptr->INTEDG);

intcon_reg_ptr->INTF=INT_FLAG_CLEAR;

}

void main() {

trisb_ptr->port = TRIS_PORT_INPUT;

trisb_ptr->SWITCH_PIN = TRIS_PIN_INPUT;

trisb_ptr->RED_LED_PIN = TRIS_PIN_OUTPUT;

trisb_ptr->YELLOW_LED_PIN = TRIS_PIN_OUTPUT;

portb_ptr->port = PORT_ALL_LOW;

intcon_reg_ptr->INTF = INT_FLAG_CLEAR;

intcon_reg_ptr->INTE = INT_ENABLE;

intcon_reg_ptr->GIE = INT_ENABLE;

option_reg_ptr->INTEDG = INT_EDGE_RISING;

while(1);

}

Kodun çalıştırılacağı devre bir önceki yazıdakilerle aynı. Yani çıktı aşağıdaki gibi olacak.

Şimdi gelelim fasülyenin faydalarına. Kesmeyi nasıl kullanacağımızı nereden bildik? PIC16F84A’nın veri kağıdının 6.8 Interrupts başlıklı kısmında hangi registerları nasıl konfigüre etmemiz gerektiği açıkça yazıyor. Bildiğiniz gibi bu yazı dizisinde kendi yazdıklarımızdan başka bir kütüphane kullanmıyoruz. Bunun amacı her şeyi temelinden anlamaktı. Doğal olarak kullanacağımız yeni registerlar için de tanımlamaları yapıyoruz. Aşağıda OPTION ve INTCON kütüklerinin (registerlarının) adres tanımlarını ve yardımcı etiketleri görebilirsiniz. Buna ek olarak bir de BIT_TOGGLE makrosu tanımladık. Bu makronun amacı bir biti birse sıfır, sıfırsa bir yapmak. Bunu ileride kullanacağız.

#define REG_INTCON_ADDR (0x0B)
#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)
#define INT_ENABLE (1)
#define INT_DISABLE (0)
#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)
#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)
#define INT_EDGE_FALLING (0)
#define INT_EDGE_RISING  (1)

#define BIT_TOGGLE(x) (x^=1)

#define REG_INTCON_ADDR (0x0B)

#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)

#define INT_ENABLE (1)

#define INT_DISABLE (0)

#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)

#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)

#define INT_EDGE_FALLING (0)

#define INT_EDGE_RISING (1)

#define BIT_TOGGLE(x) (x^=1)

Registerların modellenmesini ise aşağıdaki gibi yaptık.

typedef struct
{
    unsigned char RBIF:1;
    unsigned char INTF:1;
    unsigned char T0IF:1;
    unsigned char RBIE:1;
    unsigned char INTE:1;
    unsigned char T0IE:1;
    unsigned char EEIE:1;
    unsigned char GIE:1;
}intcon_reg_t,*intcon_reg_ptr_t;

typedef struct
{
    unsigned char PS:3;
    unsigned char PSA:1;
    unsigned char T0SE:1;
    unsigned char T0CS:1;
    unsigned char INTEDG:1;
    unsigned char RBPU:1;
}option_reg_t,*option_reg_ptr_t;

typedef struct

{

unsigned char RBIF:1;

unsigned char INTF:1;

unsigned char T0IF:1;

unsigned char RBIE:1;

unsigned char INTE:1;

unsigned char T0IE:1;

unsigned char EEIE:1;

unsigned char GIE:1;

}intcon_reg_t,*intcon_reg_ptr_t;

typedef struct

{

unsigned char PS:3;

unsigned char PSA:1;

unsigned char T0SE:1;

unsigned char T0CS:1;

unsigned char INTEDG:1;

unsigned char RBPU:1;

}option_reg_t,*option_reg_ptr_t;

Bu tanımlamaları datasheetten bakıp yaptıktan sonra INTCON ve OPTION kütüklerini gösterecek işaretçileri aşağıdaki gibi tanımladık.

intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;
option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

1 2	intcon_reg_t intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR; option_reg_t option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

Ardından gelelim ana fonksiyon(main) içinde yaptığımız ek konfigürasyonlara.

option_reg_ptr->INTEDG = INT_EDGE_RISING; 
    
intcon_reg_ptr->INTF = INT_FLAG_CLEAR;
intcon_reg_ptr->INTE = INT_ENABLE;
intcon_reg_ptr->GIE = INT_ENABLE;

option_reg_ptr->INTEDG = INT_EDGE_RISING;

intcon_reg_ptr->INTF = INT_FLAG_CLEAR;

intcon_reg_ptr->INTE = INT_ENABLE;

intcon_reg_ptr->GIE = INT_ENABLE;

Öncelikle kesme bayrağının temiz olduğundan emin olmak için onu temizledik. Ardından INTE ile RB0/INT kesmesine izin verdik. Ardından da global kesme aktivasyonu için GIE bitini etkinleştirdik. GIE ve INTE bitlerinin ikisi de 1 değerini almadan kesme gerçekleşemez. Bunu da verikağıdındaki aşağıdaki şemadan anlayabiliyoruz.

Konfigürasyonda kesmeyi de yükselen kenarda olacak şekilde ayarladık. Buna göre anahtar sıfırdan bire çekildiğinde yükselen kenar kesmesi gelecek. Ama burada bir sorun var, bize hem yükselen kenar hem düşen kenarda kesme gerekiyor. Çünkü anahtarın konumu sıfırdan bire değiştiğinde de birden sıfıra değiştiğinde de kesme almak ve LED’lerin durumunu değiştirmek istiyoruz. PIC’te böyle doğrudan böyle bir seçenek yok; ya yükselen kenar kesmesi seçilebiliyor ya da düşen kenar. Burada beyin bedava diyoruz ve kafayı çalıştırarak soruna çözüm sunuyoruz. Önce yükselen kenar kesmesini aktive ettiğimizi düşünelim, bu durumda ilk gelen yükselen kenar kesmesinin hemen ardından düşen kenar kesmesini aktive edersek, switchin durumu tekrar değiştiğinde kesme alabiliriz. Yani yükselen/düşen kenar konfigürasyonunu, kesme oluştuğunda toggle etmemiz gerekiyor. Kesme tamamlandığında kesme bayrağını yani INTF bitini de sıfıra çekip temizlemek gerekiyor. Kodda da bunları yaptık. PIC’te kesme fonksiyonu fonksiyon adının başına gelen “interrupt” kelimesi ile derleyiciye anlatılır. Buna göre kesme fonksiyonumuz aşağıdaki gibi oluyor.

static void interrupt global_isr_handler()
{
    if(intcon_reg_ptr->INTF)
    {
        switch(portb_ptr->SWITCH_PIN)
            {
                case PORT_PIN_LOW:
                    portb_ptr->RED_LED_PIN = LED_ON;
                    portb_ptr->YELLOW_LED_PIN = LED_OFF;
                    break;
                case PORT_PIN_HIGH:
                    portb_ptr->RED_LED_PIN = LED_OFF;
                    portb_ptr->YELLOW_LED_PIN = LED_ON;    
                    break;
                default:
                    break;        
            }
        BIT_TOGGLE(option_reg_ptr->INTEDG);
        intcon_reg_ptr->INTF=INT_FLAG_CLEAR;
    }
}

static void interrupt global_isr_handler()

{

if(intcon_reg_ptr->INTF)

{

switch(portb_ptr->SWITCH_PIN)

{

case PORT_PIN_LOW:

portb_ptr->RED_LED_PIN = LED_ON;

portb_ptr->YELLOW_LED_PIN = LED_OFF;

break;

case PORT_PIN_HIGH:

portb_ptr->RED_LED_PIN = LED_OFF;

portb_ptr->YELLOW_LED_PIN = LED_ON;

break;

default:

break;

}

BIT_TOGGLE(option_reg_ptr->INTEDG);

intcon_reg_ptr->INTF=INT_FLAG_CLEAR;

}

PIC’te tüm kesmeler tek bir fonksiyon içine düşer, bu da interrupt ön ekli fonksiyondur. Bu sebeple bu fonksiyonun adını global_isr_handler koyduk. Daha sonra gelen kesmenin RB0/INT olup olmadığını kontrol ettik ve eğer o ise switch değerlendirmesi işlemini yapıp yükselen/düşen kenar seçimini güncelleştirip bayrağı temizledik. INTEDG’nin toggle edilmesi ile hem düşen hem yükselen kenardaki değişimleri güzel bir oyun ile algılayabilir duruma geldik. Çiçek oldu.

Şimdi gelelim bu kodun sorunlarına. Birincisi register tanımları giderek kabarıyor ve onların ayrı bir *.h dosyası içinde yer alması gerekiyor artık. İkincisi, ilk durumda switch’in durumuna bakmaksızın kesme konfigurasyonu yaptığımız için ilk açılışta ledlerin ikisi de yanmıyor. Üçüncüsü de şu, madem her kesme aynı fonksiyona düşecek, ileride kod daha da büyüdüğünde kesme fonksiyonu sürekli değiştirilecek ve eğer birisi orada yanlış bayrakları temizlerse ya da kurarsa, önceden yazılmış kısımlar da bundan etkilenecek ve kodun her yeri bozulacak. Bu çok büyük bir risk. Burada SDK tasarımı devreye giriyor. Akıllıca bir seçenek, kesme fonksiyonunu kullanıcı programından ayırmak olacaktır. Burada kesme bayraklarının yönetiminin de otomatik yapılması da isabetli olacaktır. Bu olay gerçekten bir ileri tasarım öğesidir ancak adım adım oraya gideceğiz. Kodun bir diğer önemli sorunu da kütüphane kullanmayacağız inadımızla kullanmadığımız stdint kütüphanesidir. “unsigned char” gibi boyutu “hayırlısı” olan bir veri tipi kullanmak yerine “uint8_t” ile modelleme yapmamız daha temiz olurdu. Nitekim amacımız PIC kütüphanelerini kullanmadan, daha iyi şekilde temelden olayı yazarak olayın dinamiklerini anlamaktı. Bu da stdint’e geçişimizi engellemiyor. Bir diğer eksik nokta da register tanımlarıyla ilgili. Önceki yazıda, sebeplerini sıraladığımız üzere hem bit hem de byte erişimi sağlayabilmek için kütük modellemelerinde union kullanmıştık. Yeni modellediğimiz kütüklerde de bunu uygulamakta fayda var. Bunlara göre projemizi yine düzenleyelim 🙂

Switch ve LED Uygulaması v2

Bu projede 3 adet dosyamız olacak. Birincisi pic16f84a kütüphanemizin header dosyası. Bu dosya (pic16f84a_lib.h) aşağıdaki gibidir.

/* 
 * File:   pic16f84a_lib.h
 * Author: ozenozkaya
 *
 * Created on 20 Temmuz 2015 Pazartesi, 00:05
 */

#ifndef PIC16F84A_LIB_H
#define    PIC16F84A_LIB_H

#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)
#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)
#define TRIS_PIN_OUTPUT (0)
#define TRIS_PIN_INPUT  (1)
#define TRIS_PORT_OUTPUT (0)
#define TRIS_PORT_INPUT  (0xFF)

#define REG_PORTB_ADDR (0x06)
#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)
#define PORT_PIN_LOW  (0)
#define PORT_PIN_HIGH (1)
#define PORT_ALL_LOW  (0)
#define PORT_ALL_HIGH (0xFF)

#define REG_INTCON_ADDR (0x0B)
#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)
#define INT_ENABLE (1)
#define INT_DISABLE (0)
#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)
#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)
#define INT_EDGE_FALLING (0)
#define INT_EDGE_RISING  (1)
    
#define MAX_INT_CALLBACK_NUM (5)

typedef struct 
{
    uint8_t pin0:1;
    uint8_t pin1:1;
    uint8_t pin2:1;
    uint8_t pin3:1;
    uint8_t pin4:1;
    uint8_t pin5:1;
    uint8_t pin6:1;
    uint8_t pin7:1;
}_tris_port_pin_t, *_tris_port_pin_ptr_t;

typedef struct
{
    uint8_t RBIF:1;
    uint8_t INTF:1;
    uint8_t T0IF:1;
    uint8_t RBIE:1;
    uint8_t INTE:1;
    uint8_t T0IE:1;
    uint8_t EEIE:1;
    uint8_t GIE:1;
}_intcon_reg_t,*_intcon_reg_ptr_t;

typedef struct
{
    uint8_t PS:3;
    uint8_t PSA:1;
    uint8_t T0SE:1;
    uint8_t T0CS:1;
    uint8_t INTEDG:1;
    uint8_t RBPU:1;
}_option_reg_t,*_option_reg_ptr_t;

typedef union
{
    _tris_port_pin_t pins;
    uint8_t port;
}tris_port_t,*tris_port_ptr_t;

typedef union
{
  _option_reg_t bits;
  uint8_t value;  
}option_reg_t, *option_reg_ptr_t;

typedef union
{
  _intcon_reg_t bits;
  uint8_t value;  
}intcon_reg_t, *intcon_reg_ptr_t;

typedef void (*rb0_int_callback_t)();


int8_t register_rb0_int_callback(rb0_int_callback_t new_cb);
int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg);

#ifdef __cplusplus
}
#endif

#endif /* PIC16F84A_LIB_H */

100

101

102

103

104

105

106

107

108

* File: pic16f84a_lib.h

* Author: ozenozkaya

* Created on 20 Temmuz 2015 Pazartesi, 00:05

#ifndef PIC16F84A_LIB_H

#define PIC16F84A_LIB_H

#ifdef __cplusplus

extern "C" {

#endif

#include <stdint.h>

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)

#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)

#define TRIS_PIN_OUTPUT (0)

#define TRIS_PIN_INPUT (1)

#define TRIS_PORT_OUTPUT (0)

#define TRIS_PORT_INPUT (0xFF)

#define REG_PORTB_ADDR (0x06)

#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)

#define PORT_PIN_LOW (0)

#define PORT_PIN_HIGH (1)

#define PORT_ALL_LOW (0)

#define PORT_ALL_HIGH (0xFF)

#define REG_INTCON_ADDR (0x0B)

#define REG_INTCON (*( volatile unsigned char*)REG_INTCON_ADDR)

#define INT_ENABLE (1)

#define INT_DISABLE (0)

#define INT_FLAG_CLEAR (0)

#define REG_OPTION_ADDR (0x81)

#define REG_OPTION (*( volatile unsigned char*)REG_OPTION_ADDR)

#define INT_EDGE_FALLING (0)

#define INT_EDGE_RISING (1)

#define MAX_INT_CALLBACK_NUM (5)

typedef struct

{

uint8_t pin0:1;

uint8_t pin1:1;

uint8_t pin2:1;

uint8_t pin3:1;

uint8_t pin4:1;

uint8_t pin5:1;

uint8_t pin6:1;

uint8_t pin7:1;

}_tris_port_pin_t, *_tris_port_pin_ptr_t;

typedef struct

{

uint8_t RBIF:1;

uint8_t INTF:1;

uint8_t T0IF:1;

uint8_t RBIE:1;

uint8_t INTE:1;

uint8_t T0IE:1;

uint8_t EEIE:1;

uint8_t GIE:1;

}_intcon_reg_t,*_intcon_reg_ptr_t;

typedef struct

{

uint8_t PS:3;

uint8_t PSA:1;

uint8_t T0SE:1;

uint8_t T0CS:1;

uint8_t INTEDG:1;

uint8_t RBPU:1;

}_option_reg_t,*_option_reg_ptr_t;

typedef union

{

_tris_port_pin_t pins;

uint8_t port;

}tris_port_t,*tris_port_ptr_t;

typedef union

{

_option_reg_t bits;

uint8_t value;

}option_reg_t, *option_reg_ptr_t;

typedef union

{

_intcon_reg_t bits;

uint8_t value;

}intcon_reg_t, *intcon_reg_ptr_t;

typedef void (*rb0_int_callback_t)();

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb);

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg);

#ifdef __cplusplus

}

#endif

#endif /* PIC16F84A_LIB_H */

Yine pic16f84a kütüphanemizin kaynak dosyası (pic16f84a_lib.c) aşağıdaki gibidir.

#include "pic16f84a_lib.h"

#define BIT_TOGGLE(x) (x^=1)

#ifndef NULL
#define NULL ((void*)0)
#endif

rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];

static void interrupt global_isr_handler()
{
    intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;
    option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;
    
    uint32_t cb_index=0;
    if(intcon_reg_ptr->bits.INTF)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL != rb0_int_callback_list[cb_index])
            {
                rb0_int_callback_list[cb_index]();
            }
        }
        BIT_TOGGLE(option_reg_ptr->bits.INTEDG);
        intcon_reg_ptr->bits.INTF=INT_FLAG_CLEAR;
    }
}

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)
{
    uint32_t cb_index=0;
    if(NULL != new_cb)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL == rb0_int_callback_list[cb_index])
            {
                rb0_int_callback_list[cb_index]=new_cb;
            }
        }
        if(MAX_INT_CALLBACK_NUM == cb_index)
        {
            return -2; //All callbacks are already registered
        }
    }
    else
    {
        return -1; // Callback is NULL
    }
    return 0;
}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)
{
    uint32_t cb_index=0;
    if(NULL != cb_to_unreg)
    {
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(cb_to_unreg == rb0_int_callback_list[cb_index])
            {
                rb0_int_callback_list[cb_index]=NULL;
            }
        }
    }
    else
    {
        return -1; // Callback is NULL
    }
    return 0;
}

#include "pic16f84a_lib.h"

#define BIT_TOGGLE(x) (x^=1)

#ifndef NULL

#define NULL ((void*)0)

#endif

rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];

static void interrupt global_isr_handler()

{

intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;

option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

uint32_t cb_index=0;

if(intcon_reg_ptr->bits.INTF)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(NULL != rb0_int_callback_list[cb_index])

{

rb0_int_callback_list[cb_index]();

}

BIT_TOGGLE(option_reg_ptr->bits.INTEDG);

intcon_reg_ptr->bits.INTF=INT_FLAG_CLEAR;

}

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)

{

uint32_t cb_index=0;

if(NULL != new_cb)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(NULL == rb0_int_callback_list[cb_index])

{

rb0_int_callback_list[cb_index]=new_cb;

}

if(MAX_INT_CALLBACK_NUM == cb_index)

{

return -2; //All callbacks are already registered

}

else

{

return -1; // Callback is NULL

}

return 0;

}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)

{

uint32_t cb_index=0;

if(NULL != cb_to_unreg)

{

for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)

{

if(cb_to_unreg == rb0_int_callback_list[cb_index])

{

rb0_int_callback_list[cb_index]=NULL;

}

else

{

return -1; // Callback is NULL

}

return 0;

}

Ve nihayetinde ana programımız (main.c) aşağıdaki gibidir:

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 20 Temmuz 2015 Sali, 23:47
 */

#include "pic16f84a_lib.h"

#define SWITCH_PIN pins.pin0
#define RED_LED_PIN pins.pin1
#define YELLOW_LED_PIN pins.pin2

#define LED_ON (PORT_PIN_HIGH)
#define LED_OFF (PORT_PIN_LOW)

static tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;
static tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;
    
static void switch_event_manager()
{
    switch(portb_ptr->SWITCH_PIN)
        {
            case PORT_PIN_LOW:
                portb_ptr->RED_LED_PIN = LED_ON;
                portb_ptr->YELLOW_LED_PIN = LED_OFF;
                break;
            case PORT_PIN_HIGH:
                portb_ptr->RED_LED_PIN = LED_OFF;
                portb_ptr->YELLOW_LED_PIN = LED_ON;    
                break;
            default:
                break;        
        }
}

static void initialize_switch_and_leds()
{
    trisb_ptr->port = TRIS_PORT_INPUT;
    trisb_ptr->SWITCH_PIN = TRIS_PIN_INPUT;
    trisb_ptr->RED_LED_PIN = TRIS_PIN_OUTPUT;
    trisb_ptr->YELLOW_LED_PIN = TRIS_PIN_OUTPUT;
    
    portb_ptr->port = PORT_ALL_LOW;
    
    switch_event_manager();
}

static void initialize_switch_interrupt()
{
    intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;
    option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;
    
    register_rb0_int_callback(switch_event_manager);
    
    option_reg_ptr->bits.INTEDG = INT_EDGE_RISING;
        
    intcon_reg_ptr->bits.INTF = INT_FLAG_CLEAR;
    intcon_reg_ptr->bits.INTE = INT_ENABLE;
    intcon_reg_ptr->bits.GIE = INT_ENABLE;     
}

void main() {

    initialize_switch_and_leds();
    initialize_switch_interrupt();
      
    while(1);
}

* File: main.c

* Author: ozenozkaya

* Created on 20 Temmuz 2015 Sali, 23:47

#include "pic16f84a_lib.h"

#define SWITCH_PIN pins.pin0

#define RED_LED_PIN pins.pin1

#define YELLOW_LED_PIN pins.pin2

#define LED_ON (PORT_PIN_HIGH)

#define LED_OFF (PORT_PIN_LOW)

static tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;

static tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;

static void switch_event_manager()

{

switch(portb_ptr->SWITCH_PIN)

{

case PORT_PIN_LOW:

portb_ptr->RED_LED_PIN = LED_ON;

portb_ptr->YELLOW_LED_PIN = LED_OFF;

break;

case PORT_PIN_HIGH:

portb_ptr->RED_LED_PIN = LED_OFF;

portb_ptr->YELLOW_LED_PIN = LED_ON;

break;

default:

break;

}

static void initialize_switch_and_leds()

{

trisb_ptr->port = TRIS_PORT_INPUT;

trisb_ptr->SWITCH_PIN = TRIS_PIN_INPUT;

trisb_ptr->RED_LED_PIN = TRIS_PIN_OUTPUT;

trisb_ptr->YELLOW_LED_PIN = TRIS_PIN_OUTPUT;

portb_ptr->port = PORT_ALL_LOW;

switch_event_manager();

}

static void initialize_switch_interrupt()

{

intcon_reg_t *intcon_reg_ptr= (intcon_reg_ptr_t)REG_INTCON_ADDR;

option_reg_t *option_reg_ptr = (option_reg_ptr_t)REG_OPTION_ADDR;

register_rb0_int_callback(switch_event_manager);

option_reg_ptr->bits.INTEDG = INT_EDGE_RISING;

intcon_reg_ptr->bits.INTF = INT_FLAG_CLEAR;

intcon_reg_ptr->bits.INTE = INT_ENABLE;

intcon_reg_ptr->bits.GIE = INT_ENABLE;

}

void main() {

initialize_switch_and_leds();

initialize_switch_interrupt();

while(1);

}

Kodda, vadettiğimiz tüm değişiklikleri yapmış olduk. En en en en en önemli yer, kullanıcının yani main dosyasının kesme fonksiyonunu hiç bir şekilde görmeden kesme işlemlerini haber alması. Bunun için SDK geliştiricisi olarak çıkardığımız fonksiyonu kullancı aşağıdaki şekilde çağırmış oldu:

 register_rb0_int_callback(switch_event_manager);

1	register_rb0_int_callback(switch_event_manager);

Bu fonksiyonun implementasyonu da tam anlamıyla ibretlik. Maksimum 5 kaynak RB0/INT kesmesine abone olabiliyor. Bu genişletilebilirlik açısından çok çok önemli. Biz switch kodunu yarın öbürgün “switch geldiğinde bir de düdük çalsın” isteriyle genişletmek istediğimizde düdüğü çalacak fonksiyonu da register edecersek o düdük çalınacaktır ve bizim önceki işlerimiz asla bundan etkilenmeyecektir. Bu olaya lütfen çok dikkat ediniz. Listeye kaydolmuş fonksiyonların yani callback’lerin çağırıldığı satır ise aşağıdaki satır.

rb0_int_callback_list[cb_index]();

1	rb0_int_callback_list[cb_index]();

Şimdilik bu kadar 🙂 Bu gün epey fantastik mevzulara değindik. PIC deyip geçmemek gerek, bu basit alet için bile ileri düzey tasarım yapmak mümkün. Nitekim daha da ilerleyeceğiz. Yazılar devam edecek.

Yazıları beğendiyseniz, faydalanabilecek tanıdıklarınızla paylaşmayı unutmayınız.

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 5 – Giriş Çıkış (I/O, Input/Output) İşlemleri -2

11 July 2015 by ozenozkaya

Önceki yazımızın başlığını giriş çıkış işlemleri olarak koymuştuk ama açıkça görülebildiği üzere, yalnızca çıkış işlemleri üzerinde durduk 🙂 Bu yazıda, vadedileni tamamlayarak PIC mikrokontrolörlerinde giriş işlemlerini nasıl yaparız ona değineceğiz.

PIC programlama yazı dizisinin asıl amaç seti, gömülü sistemlerin programlanması hususunda temel oluşturup, sürecin iç dinamiklerini de anlatmak olduğundan yine bir kütüphane kullanmadan devam edeceğiz. Giriş işlemleri üzerinden gidebilmemiz için, mikrokontrolörün pinlerine bağlayacağımız elemanların, pinde oluşturacağı gerilimsel seviyeyi okumamız gerekir. Buna göre buton ve switch uygulamaları, mevzuyu anlatmakta kullanılabilecek iki güzel ve basit eleman oluyor. Butona daha sonra da değineceğiz. Şimdi mevzuyu anlatmak için switch üzerinden gidelim. Butonun basit kullanımı switch’den çok farklı değil ama bouncing gibi problemlere de önlem alacağımız için butonu timer’dan sonra anlatacağız. Neyse 🙂

Öncelikle daha kolay olandan başlayalım. Switch yani anahtar elemanının kullanımına değinelim. Anahtar’ın adı üzerinde, elektriksel akımı açıp kapatabilen devre elemanı. Buna göre, iki durumlu bir anahtar için; anahtar bir konumdayken açık devre, diğer konumdayken kısa devre davranışı gösterecektir.

Wikipedia sayfasında daha fazla bilgi bulabilir, çeşitli switch’lerin fotoğraflarını da görebilirsiniz.

Şimdi gelelim bu anahtarın PIC16 ile kullanılmasına. Çok basit bir uygulama olacak olsa da, anahtar ile PIC’i aracı yaparak LED sürelim. LED’i normal şartlar altında PIC’siz de sürebiliriz ama mevzunun basit yoldan anlaşılması için böyle anlamsız bir uygulama üzerinden gitmek mantıklı olacak diye düşünüyorum. Bir sarı ve bir kırmızı olmak üzere iki LED, bir anahtar ve bir de PIC olan bir devre düşünelim (Direnc, kondansatör gibi elemanları saymıyorum). Birazcık da olsa farklılık yaratmak için anahtar bir konumda iken sarı LED’i yakıp kırmızı LED’i söndüreceğiz. Diğer durumda ise kırmızı ledi yakıp sarı ledi söndüreceğiz. Tabi bu basit işi yaparken bile, kodu ibretlik şekilde yazacağız. Haydi işe koyulalım 🙂

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 02 Haziran 2015 Sali, 12:47
 */

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)
#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)
#define TRIS_PIN_OUTPUT (0)
#define TRIS_PIN_INPUT  (1)
#define TRIS_PORT_OUTPUT (0)
#define TRIS_PORT_INPUT  (0xFF)

#define REG_PORTB_ADDR (0x06)
#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)
#define PORT_PIN_LOW  (0)
#define PORT_PIN_HIGH (1)
#define PORT_ALL_LOW  (0)
#define PORT_ALL_HIGH (0xFF)

typedef struct 
{
    //one bit is stored in one BYTE
    unsigned char pin0:1;
    unsigned char pin1:1;
    unsigned char pin2:1;
    unsigned char pin3:1;
    unsigned char pin4:1;
    unsigned char pin5:1;
    unsigned char pin6:1;
    unsigned char pin7:1;
}tris_port_pin_t;

typedef union
{
    tris_port_pin_t pins;
    volatile unsigned char port;
}tris_port_t,*tris_port_ptr_t;



void main() {
    tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;
    tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;
    
    trisb_ptr->port = TRIS_PORT_INPUT;
    trisb_ptr->pins.pin1 = TRIS_PIN_OUTPUT;
    trisb_ptr->pins.pin2 = TRIS_PIN_OUTPUT;
    
    portb_ptr->port = PORT_ALL_LOW;
    
    
    while(1)
    {
        switch(portb_ptr->pins.pin0)
        {
            case PORT_PIN_LOW:
                portb_ptr->pins.pin1 = PORT_PIN_HIGH;
                portb_ptr->pins.pin2 = PORT_PIN_LOW;
                break;
            case PORT_PIN_HIGH:
                portb_ptr->pins.pin1 = PORT_PIN_LOW;
                portb_ptr->pins.pin2 = PORT_PIN_HIGH;    
                break;
            default:
                break;        
        }
    
    }   
    
}

* File: main.c

* Author: ozenozkaya

* Created on 02 Haziran 2015 Sali, 12:47

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)

#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)

#define TRIS_PIN_OUTPUT (0)

#define TRIS_PIN_INPUT (1)

#define TRIS_PORT_OUTPUT (0)

#define TRIS_PORT_INPUT (0xFF)

#define REG_PORTB_ADDR (0x06)

#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)

#define PORT_PIN_LOW (0)

#define PORT_PIN_HIGH (1)

#define PORT_ALL_LOW (0)

#define PORT_ALL_HIGH (0xFF)

typedef struct

{

//one bit is stored in one BYTE

unsigned char pin0:1;

unsigned char pin1:1;

unsigned char pin2:1;

unsigned char pin3:1;

unsigned char pin4:1;

unsigned char pin5:1;

unsigned char pin6:1;

unsigned char pin7:1;

}tris_port_pin_t;

typedef union

{

tris_port_pin_t pins;

volatile unsigned char port;

}tris_port_t,*tris_port_ptr_t;

void main() {

tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;

tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;

trisb_ptr->port = TRIS_PORT_INPUT;

trisb_ptr->pins.pin1 = TRIS_PIN_OUTPUT;

trisb_ptr->pins.pin2 = TRIS_PIN_OUTPUT;

portb_ptr->port = PORT_ALL_LOW;

while(1)

{

switch(portb_ptr->pins.pin0)

{

case PORT_PIN_LOW:

portb_ptr->pins.pin1 = PORT_PIN_HIGH;

portb_ptr->pins.pin2 = PORT_PIN_LOW;

break;

case PORT_PIN_HIGH:

portb_ptr->pins.pin1 = PORT_PIN_LOW;

portb_ptr->pins.pin2 = PORT_PIN_HIGH;

break;

default:

break;

}

Kodu açıklamadan önce, bir define hinliği ile, daha şeker hale getirelim diyorum. Misal aşağıdaki gibi yapsak, kodun yaptığı iş daha iyi anlaşılacak sanki.

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 02 Haziran 2015 Sali, 12:47
 */

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)
#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)
#define TRIS_PIN_OUTPUT (0)
#define TRIS_PIN_INPUT  (1)
#define TRIS_PORT_OUTPUT (0)
#define TRIS_PORT_INPUT  (0xFF)

#define REG_PORTB_ADDR (0x06)
#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)
#define PORT_PIN_LOW  (0)
#define PORT_PIN_HIGH (1)
#define PORT_ALL_LOW  (0)
#define PORT_ALL_HIGH (0xFF)

#define SWITCH_PIN pins.pin0
#define RED_LED_PIN pins.pin1
#define YELLOW_LED_PIN pins.pin2

#define LED_ON (PORT_PIN_HIGH)
#define LED_OFF (PORT_PIN_LOW)


typedef struct 
{
    //one bit is stored in one BYTE
    unsigned char pin0:1;
    unsigned char pin1:1;
    unsigned char pin2:1;
    unsigned char pin3:1;
    unsigned char pin4:1;
    unsigned char pin5:1;
    unsigned char pin6:1;
    unsigned char pin7:1;
}tris_port_pin_t;


typedef union
{
    tris_port_pin_t pins;
    volatile unsigned char port;
}tris_port_t,*tris_port_ptr_t;



void main() {
    tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;
    tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;
    
    trisb_ptr->port = TRIS_PORT_INPUT;
    trisb_ptr->SWITCH_PIN = TRIS_PIN_INPUT;
    trisb_ptr->RED_LED_PIN = TRIS_PIN_OUTPUT;
    trisb_ptr->YELLOW_LED_PIN = TRIS_PIN_OUTPUT;
    
    portb_ptr->port = PORT_ALL_LOW;
    
    
    while(1)
    {
        switch(portb_ptr->SWITCH_PIN)
        {
            case PORT_PIN_LOW:
                portb_ptr->RED_LED_PIN = LED_ON;
                portb_ptr->YELLOW_LED_PIN = LED_OFF;
                break;
            case PORT_PIN_HIGH:
                portb_ptr->RED_LED_PIN = LED_OFF;
                portb_ptr->YELLOW_LED_PIN = LED_ON;    
                break;
            default:
                break;        
        }
    
    }   
    
}

* File: main.c

* Author: ozenozkaya

* Created on 02 Haziran 2015 Sali, 12:47

#define F_OSC (1000000UL)

#define REG_TRISB_ADDR (0x86)

#define REG_TRISB (*( volatile unsigned char*)REG_TRISB_ADDR)

#define TRIS_PIN_OUTPUT (0)

#define TRIS_PIN_INPUT (1)

#define TRIS_PORT_OUTPUT (0)

#define TRIS_PORT_INPUT (0xFF)

#define REG_PORTB_ADDR (0x06)

#define REG_PORTB (*( volatile unsigned char*)REG_PORTB_ADDR)

#define PORT_PIN_LOW (0)

#define PORT_PIN_HIGH (1)

#define PORT_ALL_LOW (0)

#define PORT_ALL_HIGH (0xFF)

#define SWITCH_PIN pins.pin0

#define RED_LED_PIN pins.pin1

#define YELLOW_LED_PIN pins.pin2

#define LED_ON (PORT_PIN_HIGH)

#define LED_OFF (PORT_PIN_LOW)

typedef struct

{

//one bit is stored in one BYTE

unsigned char pin0:1;

unsigned char pin1:1;

unsigned char pin2:1;

unsigned char pin3:1;

unsigned char pin4:1;

unsigned char pin5:1;

unsigned char pin6:1;

unsigned char pin7:1;

}tris_port_pin_t;

typedef union

{

tris_port_pin_t pins;

volatile unsigned char port;

}tris_port_t,*tris_port_ptr_t;

void main() {

tris_port_t *portb_ptr=(tris_port_ptr_t)REG_PORTB_ADDR;

tris_port_t *trisb_ptr=(tris_port_ptr_t)REG_TRISB_ADDR;

trisb_ptr->port = TRIS_PORT_INPUT;

trisb_ptr->SWITCH_PIN = TRIS_PIN_INPUT;

trisb_ptr->RED_LED_PIN = TRIS_PIN_OUTPUT;

trisb_ptr->YELLOW_LED_PIN = TRIS_PIN_OUTPUT;

portb_ptr->port = PORT_ALL_LOW;

while(1)

{

switch(portb_ptr->SWITCH_PIN)

{

case PORT_PIN_LOW:

portb_ptr->RED_LED_PIN = LED_ON;

portb_ptr->YELLOW_LED_PIN = LED_OFF;

break;

case PORT_PIN_HIGH:

portb_ptr->RED_LED_PIN = LED_OFF;

portb_ptr->YELLOW_LED_PIN = LED_ON;

break;

default:

break;

}

Tabi kodu yazdık öyle ama kısa bir açıklama da yapacağız. Ayrıca birinci kod ile ikincisi arasındaki farkları da ele almakta fayda var. Ancak bundan önce kodun Proteus ISIS ortamındaki çıktılarını bir paylaşalım.

Gördüğünüz gibi kodumuz çiçek gibi çalışıyor. Şimdi gelelim kod hakkında konuşma faslına. Malumunuz bu kod çok farklı şekillerde yazılabilirdi ama yine özgün bir iş yapalım istedik. Bu sebeple gittik her bir pini struct bitfield olarak tanımladık. Bu sayede port üzerindeki her pine tek tek, bir değişken üzerinden erişmek mümkün oldu. Tanımladığımız union ile, registerlara hem pin bazlı (tek tek) hem de port bazlı (topluca) erişim imkanı sağladık. Bu işin ekmeğini de kodu yazarken yedik; kodumuz hem çok anlaşılır hem de çok genişletilebilir oldu.

İkinci kodda yaptığımız trick ise, kodun okunurluğunu çok artırdı. Switch ve ledlerin hangi pinlere bağlı olduğunu define ile tanımlayarak, kodun okunurluğunu epeyce artırmış olduk. Bu sayede ikinci kodu okuyan birisi artık kodun fiziksel olarak ne iş yaptığını kolayca anlayabilir durumu geldi. Her kod bir hikaye anlatır malum. Birinci kod hikayeyi mikrokontrolörün perspektifinden anlatırken, ikinci kod hikayeyi insan gözü perspektifinden anlatmış oldu.

Bu yazı bu kadar olsun 🙂 Bir başka yazıda yine devam edeceğiz. Yazıları beğendiyseniz, faydalanabilecek tanıdıklarınızla paylaşmayı unutmayınız.

Önceki Sayfa Sonraki Sayfa

Özen Özkaya :: Blog

Month: July 2015

PIC Programlama – 7 – Kesmeler (Interrupts) 2

PIC Programlama – 6 – Kesmeler (Interrupts)

PIC Programlama – 5 – Giriş Çıkış (I/O, Input/Output) İşlemleri -2