PIC Programlama – 10 – EEPROM

29 May 201626 June 2016 by ozenozkaya

Merhabalar, doktora yeterlik sınavı dolayısıyla ara verdiğim blog yazılarıma, yeterlik aşamasını geçtiğimden dolayı devam ediyorum 😀 PIC16F84A ile ilgili, geriye kalan son bir iki konuyu da irdeleyeceğimiz bu yazıda, ana gündemimiz EEPROM olacak.

“EEPROM nedir?” sorusuna yanıt arayanlar için WIKIPEDIA sayfasında yeterli bilgi olduğunu belirtmek isterim. Kısaca özetlemek gerekirse EEPROM, elektriksel olarak yazılıp silinebilen, kalıcı bir bellek tipi; yani elektrik gitse de içerisinde kayıtlı olan veri kendiliğinden silinmiyor. Flash belleğe göre yazım ömrünün çok fazla olması, bu devre elemanını bu gün dahi popüler tutmaya yetiyor.

PIC16F84A içinde de 64 byte’lık bir EEPROM bulunuyor. 64 byte kadar küçük bir EEPROM olsa da, özellikle kalıcı konfigürasyonları saklama konusunda, bu modül hayat kurtarıyor. Bu durumda bize düşen de, PIC16FLIB adıyla geliştirdiğimiz alternatif PIC kütüphanesine bu modülü de eklemek olacak. Öyleyse hemen başlayalım!

İlk adım olarak, her zamanki gibi datasheet’i okuyup anlayarak, yazılımsal olarak modelleyeceğiz. Datasheet’te EEPROM modülü, sistemin blok diyagramında şöyle yer alıyor:

PIC16F84A veri kağıdından alınmıştır.

Buradan da görüldüğü gibi EEPROM modülümüz 64*8 bitlik veriyi saklayabiliyor. Şimdi de, EEPROM ile ilgili kütüklerin (register), hangi adreslerde olduğuna bakalım.

İlgili kütükleri fosforlu sarı ile işaretlediğimden adreslerini görebilirsiniz. Artık adreslerini ve yapılarını da bildiğimizden, bu kütükleri yazdığımız PIC kütüphanesine ekleyebiliriz. EEPROM modülünü de derlemeye dahil edip etmemeyi seçimli yapmak için işe pic16flib_conf.h dosyasına aşağıdaki işaretli satırı ekleyerek başlıyoruz.

/* 
 * File:   pic16flib_conf.h
 * Author: ozenozkaya
 *
 * Created on 25 Eylül 2015 Cuma, 00:46
 */

#ifndef PIC16FLIB_CONF_H
#define	PIC16FLIB_CONF_H

#ifdef	__cplusplus
extern "C" {
#endif

#define MAX_INT_CALLBACK_NUM (1)

//#define PIC16LIB_USE_RB0_INT
//#define PIC16LIB_USE_PORTB_INT
//#define PIC16LIB_USE_TIMER0_INT
#define PIC16LIB_USE_EEPROM
    
#ifdef	__cplusplus
}
#endif

#endif	/* PIC16FLIB_CONF_H */

* File: pic16flib_conf.h

* Author: ozenozkaya

* Created on 25 Eylül 2015 Cuma, 00:46

#ifndef PIC16FLIB_CONF_H

#define PIC16FLIB_CONF_H

#ifdef __cplusplus

extern "C" {

#endif

#define MAX_INT_CALLBACK_NUM (1)

//#define PIC16LIB_USE_RB0_INT

//#define PIC16LIB_USE_PORTB_INT

//#define PIC16LIB_USE_TIMER0_INT

#define PIC16LIB_USE_EEPROM

#ifdef __cplusplus

}

#endif

#endif /* PIC16FLIB_CONF_H */

Şimdi pic16f84a_lib.h içerisindeki kütük tanımlamalarına geçelim. Aşağıdaki işaretli satırları pic16f84a_lib.h dosyasına ekliyoruz.

/* 
 * 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>
#include "pic16flib_conf.h"
    
#define PIC16LIB_ERROR_NONE     (0)
#define PIC16LIB_ERROR_CB_NULL  (-1)
#define PIC16LIB_ERROR_CB_ALREADY_REGISTERED (-2)
#define PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS (-3)

#define F_OSC (1000000UL)
    
#define _REG_TIMER0_ADDR (0x01)
#define REG_TIMER0 (*( volatile uint8_t*)_REG_TIMER0_ADDR)
    
#define _REG_PROGRAM_COUNTER_ADDR (0x02)
#define REG_PROGRAM_COUNTER (*( volatile uint8_t*)_REG_PROGRAM_COUNTER_ADDR)

#define _REG_STATUS_ADDR (0x03)
#define REG_STATUS (*( volatile uint8_t*)_REG_STATUS_ADDR)
    
#define _REG_PORTA_ADDR (0x05)
#define REG_PORTA (*( volatile uint8_t*)_REG_PORTA_ADDR)
    
#define _REG_PORTB_ADDR (0x06)
#define REG_PORTB (*( volatile uint8_t*)_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_EEDATA_ADDR (0x08)
#define REG_EEDATA (*( volatile uint8_t*)_REG_EEDATA_ADDR)

#define _REG_EEADR_ADDR (0x09)
#define REG_EEADR (*( volatile uint8_t*)_REG_EEADR_ADDR)
    
#define _REG_TRISB_ADDR (0x86)
#define REG_TRISB (*( volatile uint8_t*)_REG_TRISB_ADDR)
 
#define _REG_TRISA_ADDR (0x85)
#define REG_TRISA (*( volatile uint8_t*)_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_EECON1_ADDR (0x88)
#define REG_EECON1 (*( volatile uint8_t*)_REG_EECON1_ADDR)

#define _REG_EECON2_ADDR (0x89)
#define REG_EECON2 (*( volatile uint8_t*)_REG_EECON2_ADDR)

#define EECON2_PROTECTION_SEQ_1 (0x55)    
#define EECON2_PROTECTION_SEQ_2 (0xAA)  
    
#define _REG_INTCON_ADDR (0x0B)
#define REG_INTCON (*( volatile uint8_t*)_REG_INTCON_ADDR)
#define INT_ENABLE (1)
#define INT_ENABLE_ALL (0xFF)
#define INT_DISABLE (0)
#define INT_DISABLE_ALL (0)
#define INT_FLAG_CLEAR (0)

#define _REG_OPTION_ADDR (0x81)
#define REG_OPTION (*( volatile uint8_t*)_REG_OPTION_ADDR)
#define INT_EDGE_FALLING (0)
#define INT_EDGE_RISING  (1)
   

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 union
{
    _tris_port_pin_t pins;
    uint8_t port;
}tris_port_t,*tris_port_ptr_t;

#define REG_TRISA_UNION (*(tris_port_ptr_t)_REG_TRISA_ADDR) 
#define REG_TRISB_UNION (*(tris_port_ptr_t)_REG_TRISB_ADDR) 
#define REG_PORTA_UNION (*(tris_port_ptr_t)_REG_PORTA_ADDR) 
#define REG_PORTB_UNION (*(tris_port_ptr_t)_REG_PORTB_ADDR) 


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;

#define T0CS_SOURCE_RA4_T0CKI_PIN (0x01)
#define T0CS_SOURCE_INTERNAL_CLOCK (0x00)

#define PSA_ASSIGN_TO_WATCHDOG  (0x01)
#define PSA_ASSIGN_TO_TIMER0    (0x00)

#define PS_TMR0_RATE_DIVIDE_2   (0x00)
#define PS_TMR0_RATE_DIVIDE_4   (0x01)
#define PS_TMR0_RATE_DIVIDE_8   (0x02)
#define PS_TMR0_RATE_DIVIDE_16   (0x03)
#define PS_TMR0_RATE_DIVIDE_32   (0x04)
#define PS_TMR0_RATE_DIVIDE_64   (0x05)
#define PS_TMR0_RATE_DIVIDE_128   (0x06)
#define PS_TMR0_RATE_DIVIDE_256   (0x07)

#define REG_OPTION_UNION (*(option_reg_ptr_t)_REG_OPTION_ADDR) 

typedef union
{
  _intcon_reg_t bits;
  uint8_t value;  
}intcon_reg_t, *intcon_reg_ptr_t;
#define REG_INTCON_UNION   (*(intcon_reg_ptr_t)_REG_INTCON_ADDR)

typedef union
{
    uint8_t value;
    uint8_t count;
}timer0_reg_t, *timer0_reg_ptr_t;
#define TIMER0_MAX_CNT (0xFF)
#define TIMER0_ASSIGN_CNT(NEW_TMR0_CNT)    (TIMER0_MAX_CNT - NEW_TMR0_CNT)
#define REG_TIMER0_UNION   (*(timer0_reg_ptr_t)_REG_TIMER0_ADDR)


typedef struct
{
    uint8_t RD:1;
    uint8_t WR:1;
    uint8_t WREN:1;
    uint8_t WRERR:1;
    uint8_t EEIF:1;
    uint8_t _RESERVED:3;
}_eecon1_reg_t,*_eecon1_reg_ptr_t;

#define EEPROM_MAX_ADDRESS      (0x3F)

#define RD_EEPROM_INIT_READ     (0x01)
#define RD_EEPROM_DEINIT_READ   (0x00)

#define WR_EEPROM_INIT_WRITE    (0x01)
#define WR_EEPROM_DEINIT_WRITE  (0x00)

#define EEPROM_SELECT_ADDRESS(EE_ADDR) do{REG_EEADR=EE_ADDR;}while(0)
#define EEPROM_GET_DATA()  (uint8_t)(REG_EEDATA)

typedef union
{
  _eecon1_reg_t bits;
  uint8_t value;  
}eecon1_reg_t, *eecon1_reg_ptr_t;
#define REG_EECON1_UNION   (*(eecon1_reg_ptr_t)_REG_EECON1_ADDR)




#define WAIT_LOOP_FOREVER()  while(1)
#define DO_FOREVER()  while(1)

#ifdef PIC16LIB_USE_RB0_INT
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);
#endif

#ifdef PIC16LIB_USE_PORTB_INT
typedef void (*portb_int_callback_t)();
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);
#endif

#ifdef PIC16LIB_USE_TIMER0_INT
typedef void (*timer0_int_callback_t)();
int8_t register_timer0_int_callback(timer0_int_callback_t new_cb);
int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg);
#endif

#ifdef PIC16LIB_USE_EEPROM
int8_t eeprom_read_data(uint8_t ee_address, uint8_t *ee_read_data_ptr);
int8_t eeprom_write_data(uint8_t ee_address, uint8_t ee_write_data_val);
#endif

#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

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

* 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>

#include "pic16flib_conf.h"

#define PIC16LIB_ERROR_NONE (0)

#define PIC16LIB_ERROR_CB_NULL (-1)

#define PIC16LIB_ERROR_CB_ALREADY_REGISTERED (-2)

#define PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS (-3)

#define F_OSC (1000000UL)

#define _REG_TIMER0_ADDR (0x01)

#define REG_TIMER0 (*( volatile uint8_t*)_REG_TIMER0_ADDR)

#define _REG_PROGRAM_COUNTER_ADDR (0x02)

#define REG_PROGRAM_COUNTER (*( volatile uint8_t*)_REG_PROGRAM_COUNTER_ADDR)

#define _REG_STATUS_ADDR (0x03)

#define REG_STATUS (*( volatile uint8_t*)_REG_STATUS_ADDR)

#define _REG_PORTA_ADDR (0x05)

#define REG_PORTA (*( volatile uint8_t*)_REG_PORTA_ADDR)

#define _REG_PORTB_ADDR (0x06)

#define REG_PORTB (*( volatile uint8_t*)_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_EEDATA_ADDR (0x08)

#define REG_EEDATA (*( volatile uint8_t*)_REG_EEDATA_ADDR)

#define _REG_EEADR_ADDR (0x09)

#define REG_EEADR (*( volatile uint8_t*)_REG_EEADR_ADDR)

#define _REG_TRISB_ADDR (0x86)

#define REG_TRISB (*( volatile uint8_t*)_REG_TRISB_ADDR)

#define _REG_TRISA_ADDR (0x85)

#define REG_TRISA (*( volatile uint8_t*)_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_EECON1_ADDR (0x88)

#define REG_EECON1 (*( volatile uint8_t*)_REG_EECON1_ADDR)

#define _REG_EECON2_ADDR (0x89)

#define REG_EECON2 (*( volatile uint8_t*)_REG_EECON2_ADDR)

#define EECON2_PROTECTION_SEQ_1 (0x55)

#define EECON2_PROTECTION_SEQ_2 (0xAA)

#define _REG_INTCON_ADDR (0x0B)

#define REG_INTCON (*( volatile uint8_t*)_REG_INTCON_ADDR)

#define INT_ENABLE (1)

#define INT_ENABLE_ALL (0xFF)

#define INT_DISABLE (0)

#define INT_DISABLE_ALL (0)

#define INT_FLAG_CLEAR (0)

#define _REG_OPTION_ADDR (0x81)

#define REG_OPTION (*( volatile uint8_t*)_REG_OPTION_ADDR)

#define INT_EDGE_FALLING (0)

#define INT_EDGE_RISING (1)

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 union

{

_tris_port_pin_t pins;

uint8_t port;

}tris_port_t,*tris_port_ptr_t;

#define REG_TRISA_UNION (*(tris_port_ptr_t)_REG_TRISA_ADDR)

#define REG_TRISB_UNION (*(tris_port_ptr_t)_REG_TRISB_ADDR)

#define REG_PORTA_UNION (*(tris_port_ptr_t)_REG_PORTA_ADDR)

#define REG_PORTB_UNION (*(tris_port_ptr_t)_REG_PORTB_ADDR)

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;

#define T0CS_SOURCE_RA4_T0CKI_PIN (0x01)

#define T0CS_SOURCE_INTERNAL_CLOCK (0x00)

#define PSA_ASSIGN_TO_WATCHDOG (0x01)

#define PSA_ASSIGN_TO_TIMER0 (0x00)

#define PS_TMR0_RATE_DIVIDE_2 (0x00)

#define PS_TMR0_RATE_DIVIDE_4 (0x01)

#define PS_TMR0_RATE_DIVIDE_8 (0x02)

#define PS_TMR0_RATE_DIVIDE_16 (0x03)

#define PS_TMR0_RATE_DIVIDE_32 (0x04)

#define PS_TMR0_RATE_DIVIDE_64 (0x05)

#define PS_TMR0_RATE_DIVIDE_128 (0x06)

#define PS_TMR0_RATE_DIVIDE_256 (0x07)

#define REG_OPTION_UNION (*(option_reg_ptr_t)_REG_OPTION_ADDR)

typedef union

{

_intcon_reg_t bits;

uint8_t value;

}intcon_reg_t, *intcon_reg_ptr_t;

#define REG_INTCON_UNION (*(intcon_reg_ptr_t)_REG_INTCON_ADDR)

typedef union

{

uint8_t value;

uint8_t count;

}timer0_reg_t, *timer0_reg_ptr_t;

#define TIMER0_MAX_CNT (0xFF)

#define TIMER0_ASSIGN_CNT(NEW_TMR0_CNT) (TIMER0_MAX_CNT - NEW_TMR0_CNT)

#define REG_TIMER0_UNION (*(timer0_reg_ptr_t)_REG_TIMER0_ADDR)

typedef struct

{

uint8_t RD:1;

uint8_t WR:1;

uint8_t WREN:1;

uint8_t WRERR:1;

uint8_t EEIF:1;

uint8_t _RESERVED:3;

}_eecon1_reg_t,*_eecon1_reg_ptr_t;

#define EEPROM_MAX_ADDRESS (0x3F)

#define RD_EEPROM_INIT_READ (0x01)

#define RD_EEPROM_DEINIT_READ (0x00)

#define WR_EEPROM_INIT_WRITE (0x01)

#define WR_EEPROM_DEINIT_WRITE (0x00)

#define EEPROM_SELECT_ADDRESS(EE_ADDR) do{REG_EEADR=EE_ADDR;}while(0)

#define EEPROM_GET_DATA() (uint8_t)(REG_EEDATA)

typedef union

{

_eecon1_reg_t bits;

uint8_t value;

}eecon1_reg_t, *eecon1_reg_ptr_t;

#define REG_EECON1_UNION (*(eecon1_reg_ptr_t)_REG_EECON1_ADDR)

#define WAIT_LOOP_FOREVER() while(1)

#define DO_FOREVER() while(1)

#ifdef PIC16LIB_USE_RB0_INT

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);

#endif

#ifdef PIC16LIB_USE_PORTB_INT

typedef void (*portb_int_callback_t)();

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);

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

typedef void (*timer0_int_callback_t)();

int8_t register_timer0_int_callback(timer0_int_callback_t new_cb);

int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg);

#endif

#ifdef PIC16LIB_USE_EEPROM

int8_t eeprom_read_data(uint8_t ee_address, uint8_t *ee_read_data_ptr);

int8_t eeprom_write_data(uint8_t ee_address, uint8_t ee_write_data_val);

#endif

#ifdef __cplusplus

}

#endif

#endif /* PIC16F84A_LIB_H */

Register tanımlarını nasıl yaptığımızı daha önceki yazılarda çokça açıkladığımdan bu defa tekrara düşmemek adına açıklamayacağım. Her zamanki gibi, veri kağıdındaki bilgileri modelleyerek kütük tanımlarını yaptık.

Şimdi gelelim eeprom’dan veri okuma ve eeprom’a veri yazma fonksiyonlarına. Onları da aşağıda görebilirsiniz:

int8_t eeprom_read_data(uint8_t ee_address, uint8_t *ee_read_data_ptr)
{
    if(ee_address>EEPROM_MAX_ADDRESS)
    {
        return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;
    }
    EEPROM_SELECT_ADDRESS(ee_address);
    REG_EECON1_UNION.bits.RD=1;
    *ee_read_data_ptr=REG_EEDATA;
    return PIC16LIB_ERROR_NONE;
}

int8_t eeprom_write_data(uint8_t ee_address, uint8_t ee_write_data_val)
{
    if(ee_address>EEPROM_MAX_ADDRESS)
    {
        return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;
    }
    
    EEPROM_SELECT_ADDRESS(ee_address);
    REG_EEDATA=ee_write_data_val;
    REG_EECON1_UNION.bits.WREN=1;
    REG_EECON2=EECON2_PROTECTION_SEQ_1;
    REG_EECON2=EECON2_PROTECTION_SEQ_2;
    REG_EECON1_UNION.bits.WR=1;
    
    REG_INTCON_UNION.bits.EEIE=1;
    while(REG_EECON1_UNION.bits.EEIF == 0)
    {
        asm ("nop");
    }
    REG_INTCON_UNION.bits.EEIE=0;
    REG_EECON1_UNION.bits.EEIF=0;
    REG_EECON1_UNION.bits.WREN=0;
}

int8_t eeprom_read_data(uint8_t ee_address, uint8_t *ee_read_data_ptr)

{

if(ee_address>EEPROM_MAX_ADDRESS)

{

return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;

}

EEPROM_SELECT_ADDRESS(ee_address);

REG_EECON1_UNION.bits.RD=1;

*ee_read_data_ptr=REG_EEDATA;

return PIC16LIB_ERROR_NONE;

}

int8_t eeprom_write_data(uint8_t ee_address, uint8_t ee_write_data_val)

{

if(ee_address>EEPROM_MAX_ADDRESS)

{

return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;

}

EEPROM_SELECT_ADDRESS(ee_address);

REG_EEDATA=ee_write_data_val;

REG_EECON1_UNION.bits.WREN=1;

REG_EECON2=EECON2_PROTECTION_SEQ_1;

REG_EECON2=EECON2_PROTECTION_SEQ_2;

REG_EECON1_UNION.bits.WR=1;

REG_INTCON_UNION.bits.EEIE=1;

while(REG_EECON1_UNION.bits.EEIF == 0)

{

asm ("nop");

}

REG_INTCON_UNION.bits.EEIE=0;

REG_EECON1_UNION.bits.EEIF=0;

REG_EECON1_UNION.bits.WREN=0;

}

Her iki fonksiyon girişinde de, girilen adresin 63 değerinden büyük olup olmadığını kontrol ettik. Toplamda 64 byte’lık bir eeprom’umuz olduğundan, en yüksek adres 63 oluyor. Ardından okuma yapmak için, okuma yapacağımız adresi seçtik. Sonrasında RD bitini 1 yaparak okumayı başlattık ve okunan değeri REG_EEDATA kütüğünden okuduk.

Yazma kısmında ise işler biraz daha karışık şekilde çözülüyor. Yine adres seçimini yaptıktan sonra ilk iş olarak yazmak istediğimiz veriyi REG_EEDATA kütüğüne yazıyoruz. Ardından WREN bitini 1 yaparak yazma izni vermiş oluyoruz. Sonrasında, veri kağıdından okuduğumuza göre EECON2 kütüğüne sırasıyla 0x55 ve 0xAA yazmak gerekiyor. Bu, koruma amaçlı konmuş ve veri kağıdına üretici tarafından yazılmış bir ek sekans 🙂 Kodu yazan ne yaptığını biliyorsa, ancak o zaman yazabilsin demişler. Saygımız sonsuz 😉 Ardından WR bitini 1 yaparak yazım sürecini başlatıyoruz. Yazım hemen bitmiyor; bu durumda yazımın bittiğini anlayabilmek için tek çaremiz EEI (eeproma veri yazıldı) kesmesini kurarak, kesme bayrağı 1 olana kadar beklemek. Burada bekleme işini asm(“nop”); satırı ile yaptık. asm(KOMUT) fonksiyonu, XC8 derleycilerinde C kodunun içerisnde assembly komutları çağırmaya yarar. Biz de “nop” yani “bir şey yapmadan 1 saat darbesi bekle” komutunu çalıştırarak bekleme sağladık. Ardından kesme bayrağı 1 olup while döngüsünden çıktığımızda kesmeyi kapatıp, kesme bayrağını temizleyip, WREN kütüğünü sıfara çekerek çıkıp gidiyoruz 🙂 Verimiz yazıldı.

Dikkat! Burada while döngüsü sonsuza kadar sürebilir. Bunu engellemek için while içinde bir değişkeni her turda 1 artırıp, döngü sayısı bir üst sınır değerini geçerse ve yazım işlemi hala bitmemişse hata döndürerek çıkmasını sağlamakta fayda vardır.

Yukarıdaki fonksiyonların eklendiği durumda pic16f84a_lib.c dosyamız şöyle oluyor:

#include "pic16f84a_lib.h"

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

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

#ifdef PIC16LIB_USE_RB0_INT
rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];
#endif

#ifdef PIC16LIB_USE_PORTB_INT
portb_int_callback_t portb_int_callback_list[MAX_INT_CALLBACK_NUM];
#endif

#ifdef PIC16LIB_USE_TIMER0_INT
timer0_int_callback_t timer0_int_callback_list[MAX_INT_CALLBACK_NUM];
#endif


#if defined(PIC16LIB_USE_RB0_INT) || defined(PIC16LIB_USE_PORTB_INT) || defined(PIC16LIB_USE_TIMER0_INT)
static void interrupt global_isr_handler()
{
#ifdef PIC16LIB_USE_RB0_INT
    if(REG_INTCON_UNION.bits.INTF)
    {
        uint8_t cb_index=0;
        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(REG_OPTION_UNION.bits.INTEDG);
        REG_INTCON_UNION.bits.INTF=INT_FLAG_CLEAR;
    }
#endif
#ifdef PIC16LIB_USE_PORTB_INT
    if(REG_INTCON_UNION.bits.RBIF)
    {
        uint8_t cb_index=0;
        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(REG_OPTION_UNION.bits.INTEDG);
        REG_INTCON_UNION.bits.RBIF=INT_FLAG_CLEAR;
    }
#endif
#ifdef PIC16LIB_USE_TIMER0_INT
    if(REG_INTCON_UNION.bits.T0IF)
    {
        REG_INTCON_UNION.bits.T0IF=INT_FLAG_CLEAR;
        uint8_t cb_index=0;
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL != timer0_int_callback_list[cb_index])
            {
                timer0_int_callback_list[cb_index]();
            }
        }
    }
#endif
}
#endif

#ifdef PIC16LIB_USE_RB0_INT
int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)
{
    if(NULL != new_cb)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return 0;
}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)
{
    if(NULL != cb_to_unreg)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
#endif
#ifdef PIC16LIB_USE_PORTB_INT
int8_t register_portb_int_callback(portb_int_callback_t new_cb)
{
    if(NULL != new_cb)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
 
 
 
int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg)
{
    if(NULL != cb_to_unreg)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
#endif
#ifdef PIC16LIB_USE_TIMER0_INT
int8_t register_timer0_int_callback(timer0_int_callback_t new_cb)
{
    if(NULL != new_cb)
    {
        uint8_t cb_index=0;
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL == timer0_int_callback_list[cb_index])
            {
                timer0_int_callback_list[cb_index]=new_cb;
            }
        }
        if(MAX_INT_CALLBACK_NUM == cb_index)
        {
            return PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered
        }
    }
    else
    {
        return (int8_t)PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
 
 
 
int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg)
{
    if(NULL != cb_to_unreg)
    {
        uint8_t cb_index=0;
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(cb_to_unreg == timer0_int_callback_list[cb_index])
            {
                timer0_int_callback_list[cb_index]=NULL;
            }
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
#endif

#ifdef PIC16LIB_USE_EEPROM
int8_t eeprom_read_data(uint8_t ee_address, uint8_t *ee_read_data_ptr)
{
    if(ee_address>EEPROM_MAX_ADDRESS)
    {
        return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;
    }
    EEPROM_SELECT_ADDRESS(ee_address);
    REG_EECON1_UNION.bits.RD=1;
    *ee_read_data_ptr=REG_EEDATA;
    return PIC16LIB_ERROR_NONE;
}

int8_t eeprom_write_data(uint8_t ee_address, uint8_t ee_write_data_val)
{
    if(ee_address>EEPROM_MAX_ADDRESS)
    {
        return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;
    }
    
    EEPROM_SELECT_ADDRESS(ee_address);
    REG_EEDATA=ee_write_data_val;
    REG_EECON1_UNION.bits.WREN=1;
    REG_EECON2=EECON2_PROTECTION_SEQ_1;
    REG_EECON2=EECON2_PROTECTION_SEQ_2;
    REG_EECON1_UNION.bits.WR=1;
    
    REG_INTCON_UNION.bits.EEIE=1;
    while(REG_EECON1_UNION.bits.EEIF == 0)
    {
        asm ("nop");
    }
    REG_INTCON_UNION.bits.EEIE=0;
    REG_EECON1_UNION.bits.EEIF=0;
    REG_EECON1_UNION.bits.WREN=0;
}
#endif

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

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

#include "pic16f84a_lib.h"

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

#ifndef NULL

#define NULL ((void*)0)

#endif

#ifdef PIC16LIB_USE_RB0_INT

rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];

#endif

#ifdef PIC16LIB_USE_PORTB_INT

portb_int_callback_t portb_int_callback_list[MAX_INT_CALLBACK_NUM];

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

timer0_int_callback_t timer0_int_callback_list[MAX_INT_CALLBACK_NUM];

#endif

#if defined(PIC16LIB_USE_RB0_INT) || defined(PIC16LIB_USE_PORTB_INT) || defined(PIC16LIB_USE_TIMER0_INT)

static void interrupt global_isr_handler()

{

#ifdef PIC16LIB_USE_RB0_INT

if(REG_INTCON_UNION.bits.INTF)

{

uint8_t cb_index=0;

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(REG_OPTION_UNION.bits.INTEDG);

REG_INTCON_UNION.bits.INTF=INT_FLAG_CLEAR;

}

#endif

#ifdef PIC16LIB_USE_PORTB_INT

if(REG_INTCON_UNION.bits.RBIF)

{

uint8_t cb_index=0;

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(REG_OPTION_UNION.bits.INTEDG);

REG_INTCON_UNION.bits.RBIF=INT_FLAG_CLEAR;

}

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

if(REG_INTCON_UNION.bits.T0IF)

{

REG_INTCON_UNION.bits.T0IF=INT_FLAG_CLEAR;

uint8_t cb_index=0;

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

{

if(NULL != timer0_int_callback_list[cb_index])

{

timer0_int_callback_list[cb_index]();

}

#endif

}

#endif

#ifdef PIC16LIB_USE_RB0_INT

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)

{

if(NULL != new_cb)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return 0;

}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)

{

if(NULL != cb_to_unreg)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

#endif

#ifdef PIC16LIB_USE_PORTB_INT

int8_t register_portb_int_callback(portb_int_callback_t new_cb)

{

if(NULL != new_cb)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg)

{

if(NULL != cb_to_unreg)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

int8_t register_timer0_int_callback(timer0_int_callback_t new_cb)

{

if(NULL != new_cb)

{

uint8_t cb_index=0;

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

{

if(NULL == timer0_int_callback_list[cb_index])

{

timer0_int_callback_list[cb_index]=new_cb;

}

if(MAX_INT_CALLBACK_NUM == cb_index)

{

return PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered

}

else

{

return (int8_t)PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg)

{

if(NULL != cb_to_unreg)

{

uint8_t cb_index=0;

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

{

if(cb_to_unreg == timer0_int_callback_list[cb_index])

{

timer0_int_callback_list[cb_index]=NULL;

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

#endif

#ifdef PIC16LIB_USE_EEPROM

int8_t eeprom_read_data(uint8_t ee_address, uint8_t *ee_read_data_ptr)

{

if(ee_address>EEPROM_MAX_ADDRESS)

{

return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;

}

EEPROM_SELECT_ADDRESS(ee_address);

REG_EECON1_UNION.bits.RD=1;

*ee_read_data_ptr=REG_EEDATA;

return PIC16LIB_ERROR_NONE;

}

int8_t eeprom_write_data(uint8_t ee_address, uint8_t ee_write_data_val)

{

if(ee_address>EEPROM_MAX_ADDRESS)

{

return PIC16LIB_ERROR_WRONG_EEPROM_ADDRESS;

}

EEPROM_SELECT_ADDRESS(ee_address);

REG_EEDATA=ee_write_data_val;

REG_EECON1_UNION.bits.WREN=1;

REG_EECON2=EECON2_PROTECTION_SEQ_1;

REG_EECON2=EECON2_PROTECTION_SEQ_2;

REG_EECON1_UNION.bits.WR=1;

REG_INTCON_UNION.bits.EEIE=1;

while(REG_EECON1_UNION.bits.EEIF == 0)

{

asm ("nop");

}

REG_INTCON_UNION.bits.EEIE=0;

REG_EECON1_UNION.bits.EEIF=0;

REG_EECON1_UNION.bits.WREN=0;

}

#endif

Artık kütüphanemiz hazır olduğuna göre, basit bir test fonksiyonu yazacağız. 0x01 adresli EEPROM bellek alanına 1 byte’lık ‘X’ karakterini yazan ve doğru yazıp yazmadığını kontrol eden bir kod, aşağıda yer almakta.

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 */

#include "pic16f84a_lib.h"

// CONFIG
#pragma config FOSC = XT        // Oscillator Selection bits (XT oscillator)
#pragma config WDTE = ON        // Watchdog Timer (WDT enabled)
#pragma config PWRTE = ON       // Power-up Timer Enable bit (Power-up Timer is enabled)
#pragma config CP = OFF         // Code Protection bit (Code protection disabled)

#define EEPROM_TEST_ADDR    (0x01)
#define EEPROM_TEST_DATA    ('X')

void main() {
    
    uint8_t rd_data=0;
    
    REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;
    REG_PORTB_UNION.port = PORT_ALL_LOW;
    
    eeprom_write_data(EEPROM_TEST_ADDR,EEPROM_TEST_DATA);
    eeprom_read_data(EEPROM_TEST_ADDR,&rd_data);
    
    if(EEPROM_TEST_DATA==rd_data)
    {
        REG_PORTB_UNION.port=0xAA;
    }
    while(1);
}

* File: main.c

* Author: ozenozkaya

#include "pic16f84a_lib.h"

// CONFIG

#pragma config FOSC = XT // Oscillator Selection bits (XT oscillator)

#pragma config WDTE = ON // Watchdog Timer (WDT enabled)

#pragma config PWRTE = ON // Power-up Timer Enable bit (Power-up Timer is enabled)

#pragma config CP = OFF // Code Protection bit (Code protection disabled)

#define EEPROM_TEST_ADDR (0x01)

#define EEPROM_TEST_DATA ('X')

void main() {

uint8_t rd_data=0;

REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;

REG_PORTB_UNION.port = PORT_ALL_LOW;

eeprom_write_data(EEPROM_TEST_ADDR,EEPROM_TEST_DATA);

eeprom_read_data(EEPROM_TEST_ADDR,&rd_data);

if(EEPROM_TEST_DATA==rd_data)

{

REG_PORTB_UNION.port=0xAA;

}

while(1);

}

Bu kodumuz, yazım ve okuma işlemleri başarılı ise B portuna 0xAA yazıyor. Eğer hata olursa B portu ilk değeri olan 0x00 değerinde kalıyor. B portuna 0xAA=10101010 değerinin yazılması, sırasıyla pinlerin yüksekte ve alçakta olmasına sebep oluyor.

Kodda bir diğer önemli kısım ise #pragma ile başlayan konfigürasyon satırları. Buna göre osilatör olarak kristal osilatör seçmiş olduk. Ayrıca, mikrokontrolörün donup kaldığı durumlarda ona reset atacak olan watchdog timer modülünü aktive ettik. Yine güç dalgalanmalarında reset atmaya yarayan power on reset’i aktive ettik ve kod korumayı kapattık. Kod koruma açık olarak mikrokontrolöre yazılım atarsanız, o kod bir daha okunamayacak ve kolaylıkla değiştirilemeyecektir. Prototip aşamasında CP (code protection, kod koruma) seçeneğini OFF yapınız (varsayılan değer de budur).

Bu kodun çalıştığı duruma ilişkin Proteus ISIS simülasyon çıktısı ise aşağıda yer alıyor.

Gördüğünüz gibi, EEPROM sürücümüz de başarıyla çalışıyor 🙂

Projenin kaynak kodlarını BURADAN indirebilirsiniz.

Bu günlük de bu kadar. İleride yeni yazılarla devam edeceğiz.

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

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 9 – Zamanlayıcılar (Timers) 2

10 January 201629 May 2016 by ozenozkaya

Merhabalar, görece uzunca bir aradan sonra yazılarımıza kaldığımız yerden devam ediyoruz. Önceki yazıda tam da bir takım soru işaretleri bırakarak ayrılmıştık. Gün, bunların olabildiğince yanıtlanacağı gündür.

Öncelikle şu 1.06ms meselesinin çözümünü ve cevabını verelim. Evet efendim, kodumuzda yaptığımız tek satırlık bir modifikasyon ile özlenen tabloyu öncelikle kamu huzuruna sunalım.

1.00 ms zamanlayıcı çıktısı

Gördüğünüz üzere tam 1.00 ms’lik çıktıyı yakaladık. Tabi burada tam’dan kasıt, mikrosaniye mertebesindeki ölçüme ithafen bir tamlık. Neyse, şimdi hemen ilk aşamada bu uygulamanın kodlarını paylaşalım.

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 24 September 2015 
 */

#include "pic16f84a_lib.h"

/*FOSC is 4Mhz. Prescaler input it 1Mhz.
 Because prescaler is 8, prescaler output f=125kHz.
 So,the prescaler output period is 8uS.
 Hence, we need 125 timer pulses to reach 1mS.
 8uS*125 = 1mS*/
#define TIMER0_VAL_FOR_1MS  (118)

static void milisecond_event_callback()
{
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);
    REG_PORTB_UNION.port^=0xFF;    
}

void main() {
    REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;
    REG_PORTB_UNION.port = PORT_ALL_LOW;
    
    /*! 125*8uS = 1000uS = 1mS*/
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS); 
    REG_INTCON_UNION.value = INT_DISABLE_ALL;
    REG_INTCON_UNION.bits.GIE = INT_ENABLE;
    REG_INTCON_UNION.bits.T0IE = INT_ENABLE;
    
    REG_OPTION_UNION.bits.T0CS = T0CS_SOURCE_INTERNAL_CLOCK;
    REG_OPTION_UNION.bits.PSA = PSA_ASSIGN_TO_TIMER0;
    REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS
    
    register_timer0_int_callback(milisecond_event_callback);
    WAIT_LOOP_FOREVER();
}

* File: main.c

* Author: ozenozkaya

* Created on 24 September 2015

#include "pic16f84a_lib.h"

/*FOSC is 4Mhz. Prescaler input it 1Mhz.

Because prescaler is 8, prescaler output f=125kHz.

So,the prescaler output period is 8uS.

Hence, we need 125 timer pulses to reach 1mS.

8uS*125 = 1mS*/

#define TIMER0_VAL_FOR_1MS (118)

static void milisecond_event_callback()

{

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

REG_PORTB_UNION.port^=0xFF;

}

void main() {

REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;

REG_PORTB_UNION.port = PORT_ALL_LOW;

/*! 125*8uS = 1000uS = 1mS*/

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

REG_INTCON_UNION.value = INT_DISABLE_ALL;

REG_INTCON_UNION.bits.GIE = INT_ENABLE;

REG_INTCON_UNION.bits.T0IE = INT_ENABLE;

REG_OPTION_UNION.bits.T0CS = T0CS_SOURCE_INTERNAL_CLOCK;

REG_OPTION_UNION.bits.PSA = PSA_ASSIGN_TO_TIMER0;

REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS

register_timer0_int_callback(milisecond_event_callback);

WAIT_LOOP_FOREVER();

}

Kütüphanemiz yine aynı, orada bir değişikliğe ihtiyaç yok. Şimdi burada neyin değiştiğini ve neden değiştiğini açıklayalım. Bir önceki yazıdaki koddan farklı olan tek satır şu:

#define TIMER0_VAL_FOR_1MS  (118)

1	#define TIMER0_VAL_FOR_1MS (118)

Bu değerin normal şartlar altında 125 olması gerektiğini açıklamıştık. Ancak gelgelelim kesme fonksiyonu içinde yazdığımız kodlar, ister istemez bir miktar gecikmeye neden oluyor. Bu sebeple bu gecikmeyi tolere edemiyorsak, timer0’a yüklenecek değeri kalibre etmemiz elzem oluyor. Denemeler ile görüyoruz ki kesme fonksiyondaki kodlarımız 7 timer0 cycle kadar bir gecikmeyi doğuruyor. Bunu kompanze etmek için 125 cycle yerine 118 cycle saydığımızda tam 1.o0 ms’lik bir zamanlama elde ediyoruz. Tabi ki bu süreç yalnızca PIC gibi çok kısıtlı kaynaklı ve görece yavaş ortamlarda yaşanıyor. Örneğin ARM Cortex M3-M4 gibi platformlarda bu süreler ihmal edilecek kadar kısalır ve böyle bir istisnai kodlama yapmanız gerekmez. Yine uygulamanız zaman kritik değilse, böyle bir istisnai kodlamaya ihtiyaç duymazsınız. Ama yine de bu önemli konuyu akılda tutmakta fayda var 🙂

Şimdi, önceki yazıdaki defteri kapattığımıza göre bu yazının esas konusuna gelebiliriz. Bu yazımızda zamanlayıcıların bir başka önemli kullanım alanına değineceğiz: PWM (Pulse Width Modulation). Nedir efendim PWM? Çevirisini yapacak olursak dalga genişliği modülasyonudur. PWM’in ne olduğu detaylıca ŞURADA anlatıldığından daha fazla açıklama yapmaya gerek duymuyorum.

Çoğu mikrokontrolörde, zamanlayıcılar üzerinde çalışan PWM modülleri donanımsal olarak bulunur. PIC’in bazı modellerinde de bu imkan sağlanmış. Onların kullanımına da elbet değineceğiz ama daha önemlisi donanımsal PWM modülü olmasa da bu modülasyonu nasıl gerçekleyebileceğimiz. Bu yazıda zamanlayıcı kullanarak PWM gerçekleyeceğiz.

Zamanlayıcılar ve GPIO ile PWM

PWM dediğimiz nane sayısız işe yarıyor. Örneğin bir motorun dönüş hızını, bir LED’in ışık şiddetini ve daha bir çok benzer şeyi PWM ile yapabiliyoruz. PWM, işaretin etkin değerini değiştirmeye yönelik bir modülasyon olduğundan, fiziksel çıktı farketmeksizin “şiddet ayarlama” işini yapar. Ne demek istiyorum?

Bir motoru sabit 5V ile beslediğinizde o motor 5 birim hızla dönüyorsa, o motoru sabit 2.5V ile beslediğinizde motor 2.5 birim hızla döner.
Bir LED’i sabit 5V ile beslediğinizde o LED 5 birim ışık şiddeti ile yanıyorsa, o LED’i sabit 2.5V ile beslediğinizde LED 2.5 birim ışık şiddeti ile yanar.
Bir buzzer’ı sabit 5V ile beslediğinizde o buzzer 5 birim şiddetle ses çıkarıyorsa, o buzzer’ı sabit 2.5V ile beslediğinizde buzzer 2.5 birim şiddetle ses çıkarır.

Yani çıktının fiziksel şekli farketmeksizin, genelde bu iş böyle yürür. Gelgelelim biz dijital dünyada öyle kolay kolay 2.5V veremiyoruz. Bunun yerine işareti zamanda modüle ederek işimizi görmek istiyoruz. Nasıl yani?

Yani elinizde olan yalnızca 5V ise, bundan 2.5V etkin gerilim değeri elde etmenin başka bir yolu var. 1ms süreyle 5V, 1ms süreyle 0V verip bunu sürekli tekrarlarsanız bu işaretin etkin gerilim değeri (5V*1ms +0V*1ms)/2ms = 2.5V olur. 5V lojik 1, 0V lojik 0 olduğundan ve işaret zamanın %50sinde lojik 1 değerini aldığından bu işarete %50 PWM denir.

Benzer şekilde 8ms süreyle 5V, 2ms süreyle 0V verip bunu sürekli tekrarlarsanız bu işaretin etkin gerilim değeri (5V*8ms + 0V*2ms) /10ms= 4V olur. Hesap açık efendim. Zamanın %80’inde işaret lojik 1 değerini aldığından bu işarete %80 PWM denir. PWM’de işaretin 1 olduğu zamana duty cycle denir. Tekrar eden toplam zaman, periyottur ve burada işaretin periyodu 10ms’dir. Frekans = (1 / Periyot[sn]) olduğundan burada frekans 1/10[ms] = 1/0.01[sn] = 100 Hz olur. Periyot ve duty cycle kontrol edilerek dalga genişliği modülasyonu (PWM) yapılabilir.

PWM’i anlatmaya gerek yok dedim ama anlatmadan da duramadım. Şimdi lafı bırakıp icraate geçelim. Peki ne yapacağız, PWM’in %1’lik çözünürlükle kontrol edilebildiği bir uygulama yazalım.

Kütüphanemizde bir değişiklik yapmaksızın main.c dosyamızı aşağıdaki gibi yazarsak olay tamam oluyor.

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 09 January 2016 
 */

#include "pic16f84a_lib.h"

/*FOSC is 4Mhz. Prescaler input it 1Mhz.
 Because prescaler is 8, prescaler output f=125kHz.
 So,the prescaler output period is 8uS.
 Hence, we need 125 timer pulses to reach 1mS.
 8uS*125 = 1mS*/
#define TIMER0_VAL_FOR_1MS  (118)
#define PWM_DUTY_CYCLE_DEFAULT (50)
#define PWM_OUTPUT_SET()    do{REG_PORTB_UNION.port=0xFF;}while(0)
#define PWM_OUTPUT_CLR()    do{REG_PORTB_UNION.port=0;}while(0)

static uint8_t pwm_duty_cycle=PWM_DUTY_CYCLE_DEFAULT;

static void pwm_event_callback()
{
    static uint8_t pwm_tick=0;
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);
    
    if(pwm_tick<pwm_duty_cycle)
    {
        PWM_OUTPUT_SET();
    }
    else
    {
        PWM_OUTPUT_CLR();
    }
    
    if(pwm_tick>=100)
    {
        pwm_tick=0;
    }
    else
    {
        pwm_tick++;
    }
    
}

void pwm_set_duty_cycle(uint8_t new_pwm_duty_cycle)
{
    if(new_pwm_duty_cycle <= 100)
    {
        pwm_duty_cycle = new_pwm_duty_cycle;
    }
}


void main() {
    REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;
    REG_PORTB_UNION.port = PORT_ALL_LOW;
    
    /*! 125*8uS = 1000uS = 1mS*/
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS); 
    REG_INTCON_UNION.value = INT_DISABLE_ALL;
    REG_INTCON_UNION.bits.GIE = INT_ENABLE;
    REG_INTCON_UNION.bits.T0IE = INT_ENABLE;
    
    REG_OPTION_UNION.bits.T0CS = T0CS_SOURCE_INTERNAL_CLOCK;
    REG_OPTION_UNION.bits.PSA = PSA_ASSIGN_TO_TIMER0;
    REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS
    
    pwm_set_duty_cycle(50);
    register_timer0_int_callback(pwm_event_callback);
    WAIT_LOOP_FOREVER();
}

* File: main.c

* Author: ozenozkaya

* Created on 09 January 2016

#include "pic16f84a_lib.h"

/*FOSC is 4Mhz. Prescaler input it 1Mhz.

Because prescaler is 8, prescaler output f=125kHz.

So,the prescaler output period is 8uS.

Hence, we need 125 timer pulses to reach 1mS.

8uS*125 = 1mS*/

#define TIMER0_VAL_FOR_1MS (118)

#define PWM_DUTY_CYCLE_DEFAULT (50)

#define PWM_OUTPUT_SET() do{REG_PORTB_UNION.port=0xFF;}while(0)

#define PWM_OUTPUT_CLR() do{REG_PORTB_UNION.port=0;}while(0)

static uint8_t pwm_duty_cycle=PWM_DUTY_CYCLE_DEFAULT;

static void pwm_event_callback()

{

static uint8_t pwm_tick=0;

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

if(pwm_tick<pwm_duty_cycle)

{

PWM_OUTPUT_SET();

}

else

{

PWM_OUTPUT_CLR();

}

if(pwm_tick>=100)

{

pwm_tick=0;

}

else

{

pwm_tick++;

}

void pwm_set_duty_cycle(uint8_t new_pwm_duty_cycle)

{

if(new_pwm_duty_cycle <= 100)

{

pwm_duty_cycle = new_pwm_duty_cycle;

}

void main() {

REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;

REG_PORTB_UNION.port = PORT_ALL_LOW;

/*! 125*8uS = 1000uS = 1mS*/

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

REG_INTCON_UNION.value = INT_DISABLE_ALL;

REG_INTCON_UNION.bits.GIE = INT_ENABLE;

REG_INTCON_UNION.bits.T0IE = INT_ENABLE;

REG_OPTION_UNION.bits.T0CS = T0CS_SOURCE_INTERNAL_CLOCK;

REG_OPTION_UNION.bits.PSA = PSA_ASSIGN_TO_TIMER0;

REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS

pwm_set_duty_cycle(50);

register_timer0_int_callback(pwm_event_callback);

WAIT_LOOP_FOREVER();

}

Ve bu şirin mi şirin ama bir o kadar da acımasız kodun çıktısı aşağıdaki gibi oluyor.

%50 PWM

Gördüğünüz üzere periyodu ~100ms olan %50’lik bir PWM işareti elde etmiş olduk. Gelin şimdi %25’lik PWM elde etmek için ne yapmamız gerektiğini görelim.

Yalnızca şu satırı değiştirmek yeterli:

pwm_set_duty_cycle(25);

1	pwm_set_duty_cycle(25);

Bu durumda simülasyon çıktısı da aşağıdaki gibi oluyor.

%25 PWM

Her iki çıktıda da periyodun 100ms olduğuna yani frekansın 10Hz olduğuna dikkat ediniz. PWM frekansını örneğin 20HZ yapmak için aşağıdaki değişikliği yapmanız yeterli.

#define TIMER0_VAL_FOR_1MS  (59)

1	#define TIMER0_VAL_FOR_1MS (59)

Bu değişiklik ile zamanlayıcının birim zamanını 1ms’den 0.5ms’ye düşürdük. Bu da frekansı iki katına çıkardı.

Bu uygulama ile artık bir motorun hızını kontrol etmek mümkün. Robotçu arkadaşlar varsa bu kısım faydalı olacaktır diye düşünüyorum.

Projenin kaynak kodlarını BURADAN indirebilirsiniz.

Bu günlük de bu kadar. İleride yeni ibretlerle ve yeni yazılarla devam edeceğiz.

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

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 8 – Zamanlayıcılar (Timers)

1 October 201510 January 2016 by ozenozkaya

Merhabalar, geçen yazımızda kesmeler üzerine oldukça marjinal bazı çalışmalar yapmıştık. Şu ana kadar PIC mikrokontrolörün giriş çıkış ünitelerini, kesmeleri de içerecek şekilde evire çevire kullanabilecek bilgi birikimini edindik. Tabi bu bahsettiğimiz konu, işin bahanesiydi. Asıl amacımız, tüm mikrokontrolörlerde kullanabileceğimiz bir modelleme ve geliştirme altyapısını tahsis etmekti. Buna istinaden yaptığımız en orijinal iş, Microchip firmasının sunduğu kütüphanelerden performans, estetik, yazılım kalitesi, taşınabilirlik ve geliştirilebilirlik bakımından çok daha iyi bir kütüphane oluşturmak oldu. Mikrokontrolör’ün veri kağıdını nasıl modelleyeceğimizi gördüğümüzden aynı işlemleri herhangi bir başka platform için yapmak sorun olmayacaktır.

Dış dünyaya mikrokontrolörün I/O pinleri üzerinden müdahale edebildiğimizden bir sonraki adıma geçmenin sırası geldi. Bir sonraki adım şüphesiz ki periyodik işlerle nasıl başa çıkabileceğimizi bulmak olacak. Güncel durumda yazdığımız kodlar ömürleri boyunca aynı işi aralıksız olarak yaptılar. Oysa gerçek hayattaki pek çok uygulamada gerçekleşmesi gereken zamanda ve periyodik gerçekleştirilmesi gereken olaylar görürüz. Periyodik yapılan işlerden ilk akla gelen örneklemedir. Nyquist amcamızın da yıllar önce ortaya koyduğu gibi, bir işareti doğru zamanlama ile örneklemezsek o işaretin taşıdığı bilgiyi kaybetmiş olabiliyoruz. Biraz daha net şekilde açıklamak gerekirse:

Sosyal Mesaj

Nyquist örnekleme frekansı, bir işaretin örneklenmesi sürecinde tanımlanan bir alt limittir ve bu limit işaretin içerdiği maksimum frekans bileşeninin iki katıdır. Eğer işaret maksimum frekans bileşeninin iki katından – ki bu frekans Nyquist frekansı oluyor – daha az bir frekansla örneklenirse o işaret, ölçümlerden düzgünce tekrar üretilemez çünkü örnekleme esnasında bilgi kaybı yaşanmış olur.

Sonuç olarak, mikrokontrolörde zamanı ölçmenin bir yolunun olması gerekiyor. İşte bu noktada devreye Timer (Zamanlayıcı) modülleri giriyor. Ancak zamanlayıcılara geçmeden önce, zamanlama sorununa sunduğumuz en basit çözümü hatırlayalım. BURADAKİ yazımızda, DummyDelayMs fonksiyonun kurnazca tanımlayarak milisaniye mertebesinde bir zamanlama sağlamıştık. Hemen implementasyonu hatırlayalım.

static void DummyDelayMs(unsigned int delay_ms)
{
    unsigned long cnt=0;
    unsigned long delay_limit_ms= delay_ms*(F_OSC/120000);
    for(cnt=0;cnt<delay_limit_ms;cnt++);
}

static void DummyDelayMs(unsigned int delay_ms)

{

unsigned long cnt=0;

unsigned long delay_limit_ms= delay_ms*(F_OSC/120000);

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

}

Gördüğünüz gibi bu kodda, mikrokontrolöre boş beleş sayı saydırıp, geçen zamandan faydalandık. Tersten giderek, 1ms beklemek için gerekli olan sayma sayısını hesaplayıp, mikrokontrolörün o kadar boş beleş (dummy) işlem yapmasını sağladık. Bu da adeta bir araçta vitesi boşa atıp gaza sonuna kadar basmaya benziyor. Bir yere gitmiyoruz ama cayır cayır benzin yakıyoruz 🙂 İşte bunu yapmamak için Timer modülü var.

Bizim bu zamana kadar çalıştığımız PIC16F84A’da ne yazık ki tek bir zamanlayıcı modülü var. Ancak diğer modellerde daha fazla sayıda zamanlayıcı modülü mevcut. Unutmamak gerekir ki zamanlayıcılar gömülü sistemlerde “elzem” olduğundan, hemen her mikrokontrolörde zamanlayıcı bulunur. Şimdi hemen bir tablo ile hangi PIC’te hangi zamanlayıcı var görelim.

Zamanlayıcı	PIC16F8X	PIC16F62X	PIC16F877
Timer0	+	+	+
Timer1	–	+	+
Timer2	–	+	+

Bu arada hemen araya sıkıştırayım; zamanlayıcıları da bitirince artık daha gelişmiş PIC modelleri üzerinden devam etmemizde bir sakınca kalmayacak. O nedenle yavaştan diğerlerine de geçebiliriz. Şimdi Timer0’ın hakkından gelelim 😉

TIMER 0

Timer0 kardeşimiz, 8-bit’lik bir zamanlayıcı/sayıcı olarak tasarlanmış olup, doğal olarak 0’dan 255’e kadar sayabilmektedir. Yine bu efendi kardeşimizin sayacını okumak da sayacına yazmak da mümkündür; bu da bize zamanlayı istediğimiz değerden başlatma ve güncel değeri okuma imkanları sunar.

Zamanlayıcı, esasında; herhangi bir saat işaretini (clock pulse) alıp o işareti çeşitli ön işlemlerle örnekleyerek sayan bir devreciktir. Buna istinaden söz konusu saat işareti dışarıdaki bir osilatörden (Ring osilatör) ya da iç osilatörden (RC osilatör) alınabilmektedir.

Bu zamanlayıcılar 255’e kadar sayabildiğinden 255’ten sonraki sayımda taşma olur yani değer tekrar 0’a döner. Bu anda kesme kurmak mümkündür. Bu da zamanlayıcı kesmesi olarak adlandırılmaktadır.

Timer0 ile alakası olan kütükler, mikrodoentleyicinin veri kağıdında açıkça belirtilmiştir. Buna göre OPTION_REG, INTCON_REG, TMR0_REG, TMR0_REG ve inanmazsınız TRISA/PORTA kütükleri Timer0 ile ilintili imiş. Bunların her birini didik didik ederek zamanlayıcıların suyunu çıkaracağız. Tabi ki yapacağımız ilk iş, henüz modellemediğimiz kütükleri modelleyerek kütüphanemize eklemek olacak.

Tüm bunlara ek olarak, kütüphanemizi yine adım adım optimize etmeye devam edeceğiz. Burada yine tasarım trade-off”larını tartışacağız ve yeni eksikleri hep birlikte tespit edeceğiz 🙂 Öyleyse işe koyulalım ve TIMER0 ile ilk periyodik fonksiyonumuza hayat verelim!

Malumunuz her yazıda yeni kesme değerlendirme rutinleri, yeni veri yapıları ekliyoruz. Bunları her uygulamada kullanmayacağımızdan, bu uygulamalarda biraz bellek israfı yapmış oluyorduk. Şimdi onları bir config dosyası üzerinden seçimli hale getirmenin tam sırası. Yeni config dosyamız “pic16lib_conf.h” aşağıdaki gibi.

/* 
 * File:   pic16flib_conf.h
 * Author: ozenozkaya
 *
 * Created on 25 Eylül 2015 Cuma, 00:46
 */

#ifndef PIC16FLIB_CONF_H
#define    PIC16FLIB_CONF_H

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_INT_CALLBACK_NUM (1)

//#define PIC16LIB_USE_RB0_INT
//#define PIC16LIB_USE_PORTB_INT
#define PIC16LIB_USE_TIMER0_INT

#ifdef __cplusplus
}
#endif

#endif /* PIC16FLIB_CONF_H */

* File: pic16flib_conf.h

* Author: ozenozkaya

* Created on 25 Eylül 2015 Cuma, 00:46

#ifndef PIC16FLIB_CONF_H

#define PIC16FLIB_CONF_H

#ifdef __cplusplus

extern "C" {

#endif

#define MAX_INT_CALLBACK_NUM (1)

//#define PIC16LIB_USE_RB0_INT

//#define PIC16LIB_USE_PORTB_INT

#define PIC16LIB_USE_TIMER0_INT

#ifdef __cplusplus

}

#endif

#endif /* PIC16FLIB_CONF_H */

Görmüş olduğunuz PIC16FLIB_USE* etiketlerinden ikisi commentlenmiş. Eğer uygulamanızda RB0/PORTB kesmesini kullanacaksanız bunları da açabilirsiniz. Biz bu uygulamamızda yalnızca TIMER0 kesmelerini kullanacağımızdan seçimi o şekilde yaptık.

Hemen güncellediğimiz kütüphane dosyalarımızı görelim.

/* 
 * 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>
#include "pic16flib_conf.h"
    
#define PIC16LIB_ERROR_NONE     (0)
#define PIC16LIB_ERROR_CB_NULL  (-1)
#define PIC16LIB_ERROR_CB_ALREADY_REGISTERED (-2)

#define F_OSC (1000000UL)
    
#define REG_TIMER0_ADDR (0x01)
#define REG_TIMER0 (*( volatile unsigned char*)REG_TIMER0_ADDR)
    
#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_ENABLE_ALL (0xFF)
#define INT_DISABLE (0)
#define INT_DISABLE_ALL (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)
    


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;
#define REG_TRISA_UNION (*(tris_port_ptr_t)REG_TRISA_ADDR) 
#define REG_TRISB_UNION (*(tris_port_ptr_t)REG_TRISB_ADDR) 
#define REG_PORTA_UNION (*(tris_port_ptr_t)REG_PORTA_ADDR) 
#define REG_PORTB_UNION (*(tris_port_ptr_t)REG_PORTB_ADDR) 

typedef union
{
  _option_reg_t bits;
  uint8_t value;  
}option_reg_t, *option_reg_ptr_t;
#define T0CS_SOURCE_RA4_T0CKI_PIN (0x01)
#define T0CS_SOURCE_INTERNAL_CLOCK (0x00)

#define PSA_ASSIGN_TO_WATCHDOG  (0x01)
#define PSA_ASSIGN_TO_TIMER0    (0x00)

#define PS_TMR0_RATE_DIVIDE_2   (0x00)
#define PS_TMR0_RATE_DIVIDE_4   (0x01)
#define PS_TMR0_RATE_DIVIDE_8   (0x02)
#define PS_TMR0_RATE_DIVIDE_16   (0x03)
#define PS_TMR0_RATE_DIVIDE_32   (0x04)
#define PS_TMR0_RATE_DIVIDE_64   (0x05)
#define PS_TMR0_RATE_DIVIDE_128   (0x06)
#define PS_TMR0_RATE_DIVIDE_256   (0x07)

#define REG_OPTION_UNION (*(option_reg_ptr_t)REG_OPTION_ADDR) 

typedef union
{
  _intcon_reg_t bits;
  uint8_t value;  
}intcon_reg_t, *intcon_reg_ptr_t;
#define REG_INTCON_UNION   (*(intcon_reg_ptr_t)REG_INTCON_ADDR)

typedef union
{
    uint8_t value;
    uint8_t count;
}timer0_reg_t, *timer0_reg_ptr_t;
#define TIMER0_MAX_CNT (0xFF)
#define TIMER0_ASSIGN_CNT(NEW_TMR0_CNT)    (TIMER0_MAX_CNT-NEW_TMR0_CNT)
#define REG_TIMER0_UNION   (*(timer0_reg_ptr_t)REG_TIMER0_ADDR)

#define WAIT_LOOP_FOREVER()  while(1)

#ifdef PIC16LIB_USE_RB0_INT
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);
#endif

#ifdef PIC16LIB_USE_PORTB_INT
typedef void (*portb_int_callback_t)();
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);
#endif

#ifdef PIC16LIB_USE_TIMER0_INT
typedef void (*timer0_int_callback_t)();
int8_t register_timer0_int_callback(timer0_int_callback_t new_cb);
int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg);
#endif

#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

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

* 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>

#include "pic16flib_conf.h"

#define PIC16LIB_ERROR_NONE (0)

#define PIC16LIB_ERROR_CB_NULL (-1)

#define PIC16LIB_ERROR_CB_ALREADY_REGISTERED (-2)

#define F_OSC (1000000UL)

#define REG_TIMER0_ADDR (0x01)

#define REG_TIMER0 (*( volatile unsigned char*)REG_TIMER0_ADDR)

#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_ENABLE_ALL (0xFF)

#define INT_DISABLE (0)

#define INT_DISABLE_ALL (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)

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;

#define REG_TRISA_UNION (*(tris_port_ptr_t)REG_TRISA_ADDR)

#define REG_TRISB_UNION (*(tris_port_ptr_t)REG_TRISB_ADDR)

#define REG_PORTA_UNION (*(tris_port_ptr_t)REG_PORTA_ADDR)

#define REG_PORTB_UNION (*(tris_port_ptr_t)REG_PORTB_ADDR)

typedef union

{

_option_reg_t bits;

uint8_t value;

}option_reg_t, *option_reg_ptr_t;

#define T0CS_SOURCE_RA4_T0CKI_PIN (0x01)

#define T0CS_SOURCE_INTERNAL_CLOCK (0x00)

#define PSA_ASSIGN_TO_WATCHDOG (0x01)

#define PSA_ASSIGN_TO_TIMER0 (0x00)

#define PS_TMR0_RATE_DIVIDE_2 (0x00)

#define PS_TMR0_RATE_DIVIDE_4 (0x01)

#define PS_TMR0_RATE_DIVIDE_8 (0x02)

#define PS_TMR0_RATE_DIVIDE_16 (0x03)

#define PS_TMR0_RATE_DIVIDE_32 (0x04)

#define PS_TMR0_RATE_DIVIDE_64 (0x05)

#define PS_TMR0_RATE_DIVIDE_128 (0x06)

#define PS_TMR0_RATE_DIVIDE_256 (0x07)

#define REG_OPTION_UNION (*(option_reg_ptr_t)REG_OPTION_ADDR)

typedef union

{

_intcon_reg_t bits;

uint8_t value;

}intcon_reg_t, *intcon_reg_ptr_t;

#define REG_INTCON_UNION (*(intcon_reg_ptr_t)REG_INTCON_ADDR)

typedef union

{

uint8_t value;

uint8_t count;

}timer0_reg_t, *timer0_reg_ptr_t;

#define TIMER0_MAX_CNT (0xFF)

#define TIMER0_ASSIGN_CNT(NEW_TMR0_CNT) (TIMER0_MAX_CNT-NEW_TMR0_CNT)

#define REG_TIMER0_UNION (*(timer0_reg_ptr_t)REG_TIMER0_ADDR)

#define WAIT_LOOP_FOREVER() while(1)

#ifdef PIC16LIB_USE_RB0_INT

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);

#endif

#ifdef PIC16LIB_USE_PORTB_INT

typedef void (*portb_int_callback_t)();

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);

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

typedef void (*timer0_int_callback_t)();

int8_t register_timer0_int_callback(timer0_int_callback_t new_cb);

int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg);

#endif

#ifdef __cplusplus

}

#endif

#endif /* PIC16F84A_LIB_H */

Timer0 adres ve kütük tanımlamalarının yapılmış olduğuna dikkatinizi çekerim 🙂 Aynı zamanda, config dosyasında kullandığımız etiketler de, kullanılmayan kesmelerin fonksiyon prototiplerini derleme zamanında kapatmak için yerli yerinde. Öyleyse hemen .c dosyamızı görelim.

#include "pic16f84a_lib.h"

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

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

#ifdef PIC16LIB_USE_RB0_INT
rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];
#endif

#ifdef PIC16LIB_USE_PORTB_INT
portb_int_callback_t portb_int_callback_list[MAX_INT_CALLBACK_NUM];
#endif

#ifdef PIC16LIB_USE_TIMER0_INT
timer0_int_callback_t timer0_int_callback_list[MAX_INT_CALLBACK_NUM];
#endif


#if defined(PIC16LIB_USE_RB0_INT) || defined(PIC16LIB_USE_PORTB_INT) || defined(PIC16LIB_USE_TIMER0_INT)
static void interrupt global_isr_handler()
{
#ifdef PIC16LIB_USE_RB0_INT
    if(REG_INTCON_UNION.bits.INTF)
    {
        uint8_t cb_index=0;
        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(REG_OPTION_UNION.bits.INTEDG);
        REG_INTCON_UNION.bits.INTF=INT_FLAG_CLEAR;
    }
#endif
#ifdef PIC16LIB_USE_PORTB_INT
    if(REG_INTCON_UNION.bits.RBIF)
    {
        uint8_t cb_index=0;
        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(REG_OPTION_UNION.bits.INTEDG);
        REG_INTCON_UNION.bits.RBIF=INT_FLAG_CLEAR;
    }
#endif
#ifdef PIC16LIB_USE_TIMER0_INT
    if(REG_INTCON_UNION.bits.T0IF)
    {
        REG_INTCON_UNION.bits.T0IF=INT_FLAG_CLEAR;
        uint8_t cb_index=0;
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL != timer0_int_callback_list[cb_index])
            {
                timer0_int_callback_list[cb_index]();
            }
        }
    }
#endif
}
#endif

#ifdef PIC16LIB_USE_RB0_INT
int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)
{
    if(NULL != new_cb)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return 0;
}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)
{
    if(NULL != cb_to_unreg)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
#endif
#ifdef PIC16LIB_USE_PORTB_INT
int8_t register_portb_int_callback(portb_int_callback_t new_cb)
{
    if(NULL != new_cb)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
 
 
 
int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg)
{
    if(NULL != cb_to_unreg)
    {
        uint8_t cb_index=0;
        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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
#endif
#ifdef PIC16LIB_USE_TIMER0_INT
int8_t register_timer0_int_callback(timer0_int_callback_t new_cb)
{
    if(NULL != new_cb)
    {
        uint8_t cb_index=0;
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(NULL == timer0_int_callback_list[cb_index])
            {
                timer0_int_callback_list[cb_index]=new_cb;
            }
        }
        if(MAX_INT_CALLBACK_NUM == cb_index)
        {
            return PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
 
 
 
int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg)
{
    if(NULL != cb_to_unreg)
    {
        uint8_t cb_index=0;
        for(cb_index=0;cb_index<MAX_INT_CALLBACK_NUM; cb_index++)
        {
            if(cb_to_unreg == timer0_int_callback_list[cb_index])
            {
                timer0_int_callback_list[cb_index]=NULL;
            }
        }
    }
    else
    {
        return PIC16LIB_ERROR_CB_NULL; // Callback is NULL
    }
    return PIC16LIB_ERROR_NONE;
}
#endif

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

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

#include "pic16f84a_lib.h"

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

#ifndef NULL

#define NULL ((void*)0)

#endif

#ifdef PIC16LIB_USE_RB0_INT

rb0_int_callback_t rb0_int_callback_list[MAX_INT_CALLBACK_NUM];

#endif

#ifdef PIC16LIB_USE_PORTB_INT

portb_int_callback_t portb_int_callback_list[MAX_INT_CALLBACK_NUM];

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

timer0_int_callback_t timer0_int_callback_list[MAX_INT_CALLBACK_NUM];

#endif

#if defined(PIC16LIB_USE_RB0_INT) || defined(PIC16LIB_USE_PORTB_INT) || defined(PIC16LIB_USE_TIMER0_INT)

static void interrupt global_isr_handler()

{

#ifdef PIC16LIB_USE_RB0_INT

if(REG_INTCON_UNION.bits.INTF)

{

uint8_t cb_index=0;

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(REG_OPTION_UNION.bits.INTEDG);

REG_INTCON_UNION.bits.INTF=INT_FLAG_CLEAR;

}

#endif

#ifdef PIC16LIB_USE_PORTB_INT

if(REG_INTCON_UNION.bits.RBIF)

{

uint8_t cb_index=0;

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(REG_OPTION_UNION.bits.INTEDG);

REG_INTCON_UNION.bits.RBIF=INT_FLAG_CLEAR;

}

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

if(REG_INTCON_UNION.bits.T0IF)

{

REG_INTCON_UNION.bits.T0IF=INT_FLAG_CLEAR;

uint8_t cb_index=0;

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

{

if(NULL != timer0_int_callback_list[cb_index])

{

timer0_int_callback_list[cb_index]();

}

#endif

}

#endif

#ifdef PIC16LIB_USE_RB0_INT

int8_t register_rb0_int_callback(rb0_int_callback_t new_cb)

{

if(NULL != new_cb)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return 0;

}

int8_t unregister_rb0_int_callback(rb0_int_callback_t cb_to_unreg)

{

if(NULL != cb_to_unreg)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

#endif

#ifdef PIC16LIB_USE_PORTB_INT

int8_t register_portb_int_callback(portb_int_callback_t new_cb)

{

if(NULL != new_cb)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

int8_t unregister_portb_int_callback(portb_int_callback_t cb_to_unreg)

{

if(NULL != cb_to_unreg)

{

uint8_t cb_index=0;

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 PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

#endif

#ifdef PIC16LIB_USE_TIMER0_INT

int8_t register_timer0_int_callback(timer0_int_callback_t new_cb)

{

if(NULL != new_cb)

{

uint8_t cb_index=0;

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

{

if(NULL == timer0_int_callback_list[cb_index])

{

timer0_int_callback_list[cb_index]=new_cb;

}

if(MAX_INT_CALLBACK_NUM == cb_index)

{

return PIC16LIB_ERROR_CB_ALREADY_REGISTERED; //All callbacks are already registered

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

int8_t unregister_timer0_int_callback(timer0_int_callback_t cb_to_unreg)

{

if(NULL != cb_to_unreg)

{

uint8_t cb_index=0;

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

{

if(cb_to_unreg == timer0_int_callback_list[cb_index])

{

timer0_int_callback_list[cb_index]=NULL;

}

else

{

return PIC16LIB_ERROR_CB_NULL; // Callback is NULL

}

return PIC16LIB_ERROR_NONE;

}

#endif

Görüldüğü üzere, alışılageldik şekilde timer0 kesme rutinlerini de ekledik. Ek olarak yine config etiketlerimiz de fonksiyonları çevrelemiş durumda 🙂 Artık kütüphanemizi kullanan kimselere çok daha geniş optimizasyon imkanı sunuyoruz! Her durumda yine Microchip liblerinden çok daha yüksek performanslı bir konumda kütüphanemiz 🙂 0 byte kullanarak tüm register erişimlerini yapmak mümkün. Konfor arayan yazılımcılar için de, kütük erişimlerini çok kolaylaştıran veri yapılarını implement ettik. İsteyen istediği yönde optimizasyon yapabiliyor. Bu da kütüphanemizin esnekliğini ciddi oranda artırmış durumda. Şimdi uygulama koduna geçelim.

/* 
 * File:   main.c
 * Author: ozenozkaya
 *
 * Created on 24 September 2015 
 */

#include "pic16f84a_lib.h"

/*FOSC is 4Mhz. Prescaler input it 1Mhz.
 Because prescaler is 8, prescaler output f=125kHz.
 So,the prescaler output period is 8uS.
 Hence, we need 125 timer pulses to reach 1mS.
 8uS*125 = 1mS*/
#define TIMER0_VAL_FOR_1MS  (125)

static void milisecond_event_callback()
{
    REG_PORTB_UNION.port^=0xFF;
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);
}

void main() {
    REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;
    REG_PORTB_UNION.port = PORT_ALL_LOW;

    REG_OPTION_UNION.bits.T0CS = T0CS_SOURCE_INTERNAL_CLOCK;
    REG_OPTION_UNION.bits.PSA = PSA_ASSIGN_TO_TIMER0;
    REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS
    
    /*! 125*8uS = 1000uS = 1mS*/
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS); 
    REG_INTCON_UNION.value = INT_DISABLE_ALL;
    REG_INTCON_UNION.bits.GIE = INT_ENABLE;
    REG_INTCON_UNION.bits.T0IE = INT_ENABLE;
    
    register_timer0_int_callback(milisecond_event_callback);
    WAIT_LOOP_FOREVER();
}

* File: main.c

* Author: ozenozkaya

* Created on 24 September 2015

#include "pic16f84a_lib.h"

/*FOSC is 4Mhz. Prescaler input it 1Mhz.

Because prescaler is 8, prescaler output f=125kHz.

So,the prescaler output period is 8uS.

Hence, we need 125 timer pulses to reach 1mS.

8uS*125 = 1mS*/

#define TIMER0_VAL_FOR_1MS (125)

static void milisecond_event_callback()

{

REG_PORTB_UNION.port^=0xFF;

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

}

void main() {

REG_TRISB_UNION.port = TRIS_PORT_OUTPUT;

REG_PORTB_UNION.port = PORT_ALL_LOW;

REG_OPTION_UNION.bits.T0CS = T0CS_SOURCE_INTERNAL_CLOCK;

REG_OPTION_UNION.bits.PSA = PSA_ASSIGN_TO_TIMER0;

REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS

/*! 125*8uS = 1000uS = 1mS*/

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

REG_INTCON_UNION.value = INT_DISABLE_ALL;

REG_INTCON_UNION.bits.GIE = INT_ENABLE;

REG_INTCON_UNION.bits.T0IE = INT_ENABLE;

register_timer0_int_callback(milisecond_event_callback);

WAIT_LOOP_FOREVER();

}

Bu yazılımda, B portlarını 1 milisaniyede bir eviren bir yazılım oluşturduk. Peki ama bunu nasıl yaptık? Hemen hesap kitaba değinelim. PIC mikrokontrolörümüze dışarıdan bir kristal osilatör bağlı ve frekansı 4MHz.

Aman Diyelim

Proteus simülasyonu yapmadan önce, PIC mikrokontrolöre çift tıklayıp FOSC değerini 4Mhz yaparsak, buradaki hesaplarla uyumlu çıktılar alabiliriz. Aksi durumda varsayılan değer olan 1Mhz geçerli olacaktır ve bu durumda istenen çıktılar elde edilemeyecektir.

PIC16F84A’da timer modülüne gelen saat işareti 4’e bölünerek gelir (datasheet’te yazmakta). Dolayısıyla modülün girişi 1MHz yani saniyede 1 milyon saat darbesi geliyor. Timer modülünün giriş kısmında bir frekans ölçeklendirici (prescaler) bulunmakta. Biz ölçeklendirme oranını 8’e bölecek şekilde seçtik. Bunu, aşağıdaki satır ile yaptık.

REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS

1	REG_OPTION_UNION.bits.PS = PS_TMR0_RATE_DIVIDE_8; //8uS

Buna göre, 1MHz’lik işaret frekansını 8’e böldük ve prescaler çıkışındaki frekans 125Khz oldu. Bu da 8 micro saniyede bir saat darbesi demek. Eğer bu saat darbelerinden 125 tane sayılınca kesme olacak şekilde bir konfigurasyon yaparsak, 8*125 us = 1ms’lik bir kesme rutini elde etmiş olacağız. Bu sebeple aşağıdaki tanımla 125 değeri tanımlandı.

/*FOSC is 4Mhz. Prescaler input it 1Mhz.
 Because prescaler is 8, prescaler output f=125kHz.
 So,the prescaler output period is 8uS.
 Hence, we need 125 timer pulses to reach 1mS.
 8uS*125 = 1mS*/
#define TIMER0_VAL_FOR_1MS  (125)

/*FOSC is 4Mhz. Prescaler input it 1Mhz.

Because prescaler is 8, prescaler output f=125kHz.

So,the prescaler output period is 8uS.

Hence, we need 125 timer pulses to reach 1mS.

8uS*125 = 1mS*/

#define TIMER0_VAL_FOR_1MS (125)

Bu değer ise timer0 kütüğüne aşağıdaki şekilde atandı.

/*! 125*8uS = 1000uS = 1mS*/
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

1 2	/! 1258uS = 1000uS = 1mS*/ REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

Burada ibretlik bir macromuz var. Bu macro TIMER0_ASSIGN_CNT. Peki neden buna ihtiyaç duyduk? Malumunuz bizim timer0 modülü yukarı doğru sayıyor ve 255(0xFF)’de taşıyor. Taşmadan önce 125 tur sayabilmesi için aslında 255-125 =130 değerinden başlamalı Timer0. Bu durumda timer 130’dan başlatılacak ve tam 125 tur sonra (1ms yapıyor) kesme gelmiş olacak. İşte bu çıkarma hesabını yapan macromuz TIMER0_ASSIGN_CNT. Kütüphanemizdeki tanımı da aşağıdaki gibi idi.

#define TIMER0_MAX_CNT (0xFF)
#define TIMER0_ASSIGN_CNT(NEW_TMR0_CNT)    (TIMER0_MAX_CNT-NEW_TMR0_CNT)

1 2	#define TIMER0_MAX_CNT (0xFF) #define TIMER0_ASSIGN_CNT(NEW_TMR0_CNT) (TIMER0_MAX_CNT-NEW_TMR0_CNT)

Bu sayede 1ms’lik zamanlama sağlamış oluyor. Ancak sürekli olarak 1ms’lik zamanlamayı sağlamak için TIMER0 taştığında, yani kesme oluştuğunda Timer0’ı tekrar 130 değerinden başlatmak gerekiyor. Bunun için, milisaniye callback fonskiyonumuzda aşağıdaki gibi bir tekar yükleme yaptık.

static void milisecond_event_callback()
{
    REG_PORTB_UNION.port^=0xFF;
    REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);
}

static void milisecond_event_callback()

{

REG_PORTB_UNION.port^=0xFF;

REG_TIMER0_UNION.count = TIMER0_ASSIGN_CNT(TIMER0_VAL_FOR_1MS);

}

Bu sayede her şey çalışır durumda ve enerji efektif şekilde periyodik işlerimizi yapabilir hale geldik 🙂 Hemen proteus isis üzerindeki simülasyon çıktımızı da ekleyelim.

Osiloskoptaki zaman ölçümünün 1.06 mS oluşuna dikkat ediniz. 1ms güzel de, bu 0.06 mS nereden geldi? Buradan da çok güzel ibretlere değineceğiz dostlar, ancak bu sorunun yanıtı ve dahasını bir sonraki yazıya bırakıyoruz 🙂

Zamanlayıcılar konusunda ne kadar çok tekrar yaparsanız, farklı uygulamalar yazarsanız o kadar iyi olur. Örneğin karaşimşek uygulamasını zamanlayıcı kullanarak yazmakta faydalar var.

Şimdi devam!

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

Önceki Sayfa Sonraki Sayfa

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 – 4 – Giriş Çıkış (I/O, Input/Output) İşlemleri

2 June 2015 by ozenozkaya

Merhabalar, bir önceki yazımızda PIC için yazdığımız bir merhaba dünya kodunun içini dışını hallaç pamuğuna çevirmiş ve sayısız ibretlerle keyiflenmiştik. Bu yazımızda da PIC16’nın bir pinini nasıl giriş yaparız, nasıl çıkış yaparız, bir giriş pininden nasıl değer okuruz, bir çıkış pinine nasıl değer yazarız gibi işlemlere değineceğiz 🙂 Sözün özü, hayatı bir dizi gerilimsel işaretle mıncıklayacağız 🙂

Sosyal Mesaj

Malumunuz bu yazım öncekilere nazaran epey gecikti. Ciddi bir ara vermiş oldum ancak gerçekten yoğun bir dönemi geride bırakmış olduğumu belirtip, affınıza sığınarak yazı dizilerine devam ediyorum.

Şimdi, yine bir kütüphane kullanmadan (ya da sadece kendi yazdığımız kütüphaneleri kullanarak) bir karaşimşek kodu yazalım =) Karaşimşek kodu meşhurdur dostlar =) es geçmeyelim!

Tıpkı PIC mikrodentleyicilerinin bizler için “araç” olması gibi, karaşimşek kodu da anlatmak istediklerimizi anlatmak üzere kullanacağımız bir araç olacak. Amacımız ibretleri birer birer kapmak. Sözü sakız edip uzatmadan hemen kodumuzu yazalım.

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

#define F_OSC (1000000UL)

#define REG_TRISB (*( volatile unsigned char*)0x086)
#define REG_PORTB (*( volatile unsigned char*)0x006)

static void InitializeLedArray(void);
static void DummyDelayMs(unsigned int delay_ms);


void main() {
    unsigned char led_index=0;
    InitializeLedArray();
    while(1)
    {
        for(led_index=0; led_index<7; led_index++)
        {
            REG_PORTB=REG_PORTB<<1;
            DummyDelayMs(100);
        }
         for(led_index=0; led_index<7; led_index++)
        {
            REG_PORTB=REG_PORTB>>1;
            DummyDelayMs(100);
        }
    }
}

static void InitializeLedArray(void)
{
    REG_TRISB = 0;
    REG_PORTB = 1;
    DummyDelayMs(100);
}

static void DummyDelayMs(unsigned int delay_ms)
{
    unsigned long cnt=0;
    unsigned long delay_limit_ms= delay_ms*(F_OSC/120000);
    for(cnt=0;cnt<delay_limit_ms;cnt++);
}

* File: main.c

* Author: ozenozkaya

* Created on 02 Haziran 2015 Sali, 12:47

#define F_OSC (1000000UL)

#define REG_TRISB (*( volatile unsigned char*)0x086)

#define REG_PORTB (*( volatile unsigned char*)0x006)

static void InitializeLedArray(void);

static void DummyDelayMs(unsigned int delay_ms);

void main() {

unsigned char led_index=0;

InitializeLedArray();

while(1)

{

for(led_index=0; led_index<7; led_index++)

{

REG_PORTB=REG_PORTB<<1;

DummyDelayMs(100);

}

for(led_index=0; led_index<7; led_index++)

{

REG_PORTB=REG_PORTB>>1;

DummyDelayMs(100);

}

static void InitializeLedArray(void)

{

REG_TRISB = 0;

REG_PORTB = 1;

DummyDelayMs(100);

}

static void DummyDelayMs(unsigned int delay_ms)

{

unsigned long cnt=0;

unsigned long delay_limit_ms= delay_ms*(F_OSC/120000);

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

}

Evet efendim kodumuz yukarıda yer aldığı gibi. Çıktısını göstermeden önce, dilerseniz kodu bir açıklayayım. İlk aşamada bekletme (delay) işlemlerini yapabilmek için çalışma frekansını giriyoruz. Buna göre çalışma frekansı 1.000.000 Hz yani 1MHZ olarak aşağıdaki gibi belirleniyor.

#define F_OSC (1000000UL)

1	#define F_OSC (1000000UL)

Ardından, bir önceki yazımızda anlattığımız üzere kendi çabalarımızla register tanımını yapıyoruz. Malum bu yazı dizisinde bir hedef de PIC’i bahane edip, bir mikrokontrolöre kütüphane nasıl yazılır onu da öğrenmek. Önceki yazıda myTRISB diye yaptığımız register tanımı Ağaoğlu MyTRISB projesi ile isim benzerliği göstermesin diye isimlendirmeyi birazcık değiştirdik 😛

#define REG_TRISB (*( volatile unsigned char*)0x086)
#define REG_PORTB (*( volatile unsigned char*)0x006)

1 2	#define REG_TRISB (( volatile unsigned char)0x086) #define REG_PORTB (( volatile unsigned char)0x006)

Bunlar malumunuz; efektif şekilde tanımlanmış kütükler. Ben afedersiniz kütük diyorum ama onun İngilizcesi “register”. Neyse bir sonraki aşamada main’e geçecek olursak önce pin’lere ilk değer veriliyor ki o kısım zaten önceki, merhaba dünya örneğinin aynısı. Ardından el yordamı ile yazdığımız DummyDelayMs fonksiyonuna değineyim.

static void DummyDelayMs(unsigned int delay_ms)
{
    unsigned long cnt=0;
    unsigned long delay_limit_ms= delay_ms*(F_OSC/120000);
    for(cnt=0;cnt<delay_limit_ms;cnt++);
}

static void DummyDelayMs(unsigned int delay_ms)

{

unsigned long cnt=0;

unsigned long delay_limit_ms= delay_ms*(F_OSC/120000);

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

}

Bu fonksiyonun işi, cnt değişkeninin değerini insafsızca ve ahlaksızca artırarak CPU’nun diğer işleri yapmasını engellemek. Bu da hödükçe bir beklemeye sebep oluyor. Çalışıyor mu? Çalışıyor! Oradaki 120000 sayısını empirik olarak buluyoruz. Proteusta bir OSC kullanıp zamanı ölçerek bulmak mümkün. Hesapla kitapla da yaklaşık olarak bulmak mümkündür. Neyse biz işimize devam edelim. Aşağıdaki kod ise karaşimşek işini yapmaktadır.

  while(1)
    {
        for(led_index=0; led_index<7; led_index++)
        {
            REG_PORTB=REG_PORTB<<1;
            DummyDelayMs(100);
        }
         for(led_index=0; led_index<7; led_index++)
        {
            REG_PORTB=REG_PORTB>>1;
            DummyDelayMs(100);
        }
    }

while(1)

{

for(led_index=0; led_index<7; led_index++)

{

REG_PORTB=REG_PORTB<<1;

DummyDelayMs(100);

}

for(led_index=0; led_index<7; led_index++)

{

REG_PORTB=REG_PORTB>>1;

DummyDelayMs(100);

}

100ms’de bir led bir kaydırılıyor. Bu kodun çıktısı ise aşağıdaki gibi oluyor 🙂

Bu yazı bu kadarcık olsun 🙂 Başka bir yazıda devam edeceğiz.

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 3 – Merhaba Dünya Analizi

27 March 2015 by ozenozkaya

Uzunca bir dönemdir, çok büyük bir yoğunluk içindeyim. Bu sebepledir ki, bir türlü fırsat bulup yeni bir yazıya başlayamadım. Herhalde gün, bu gündür 🙂

Geleneksel olarak yine merhaba dünya yazımızın suyunu sıkma niyetindeyiz. Her ne kadar girizgah seviyesinde de olsa yazdığımız merhaba dünya yazısında, netleştirilmesi gereken bazı şeylerin olduğu aşikar. Bu yazı dizisinden önce Gömülü C yazı dizisinin okunmuş olmasını şiddetle tavsiye ediyorum.

Şimdi lafı uzatmadan, PIC’de yazdığımız ilk kodu hatırlayalım.

#include <xc.h>
 
void main(void)
{
 TRISB=0;
 PORTB=1;
 while(1);
}

#include <xc.h>

void main(void)

{

TRISB=0;

PORTB=1;

while(1);

}

Bir kere şu xc.h’ı bir inceleyelim ne varmış içinde?

#ifndef _XC_H_
#define _XC_H_

#ifdef __XC8
#include <htc.h>
#endif

#endif     //_XC_H

#ifndef _XC_H_

#define _XC_H_

#ifdef __XC8

#include <htc.h>

#endif

#endif //_XC_H

Gördüğünüz üzere, XC aslında MplabX Compiler anlamında yer alıyor ve kullandığımız platform 8 bitlik olduğundan, __XC8 etiketi sistemde tanımlı olduğundan (MplabX tarafından, biz projeyi oluşturduğumuzda otomatik tanımlanır) ilgili compiler header’ı çağırılmış. Bunun da “htc.h” olduğunu görüyoruz. Burada jeton düşüyor, hmm demek ki bu xc serisi, eski hi-tech C compiler’ın üzerine kurulmuş. Burnumuz bunun kokusunu aldı. Şimdi daha derine inelim; htc.h’ı açalım.

#ifndef _HTC_H_
#define _HTC_H_

#if defined(__CCI__) && !defined(_XC_H_)
#warning "CCI projects should use the top-level support file xc.hnIncluding xc.h instead"
#include <xc.h>
#endif

#if !defined(__CCI__) && !defined(__IAR__)
/* allow CCI definitions even when CCI option is not turned on */
#include <cci.h>
#endif

/* Definitions for _HTC_EDITION_ values */
#define __LITE__ 0
#define __STD__ 1
#define __PRO__ 2

/* common definitions */

#define    ___mkstr1(x)    #x
#define    ___mkstr(x) ___mkstr1(x)

#define _OMNITARGET    ((void *)0xFFFFFFFF)

extern const char __xc8_OPTIM_SPEED;

#include <xc8debug.h>

/* HI-TECH PICC / PICC-Lite compiler */
#if    defined(__PICC__) || defined(__PICCLITE__)
#include <pic.h>
#endif

/* HI-TECH PICC-18 compiler */
#if    defined(__PICC18__)
#include <pic18.h>
#endif

/* MPLAB C18 Compatibility Header */
#ifdef __18CXX
#include <pic18.h>
#endif

/* HI-TECH dsPICC compiler */
#if    defined(__DSPICC__)
#include <dspic.h>
#endif

/* HI-TECH C for PIC32 */
#if defined(__PICC32__)
#include <pic32.h>
#endif

#endif

#ifndef _HTC_H_

#define _HTC_H_

#if defined(__CCI__) && !defined(_XC_H_)

#warning "CCI projects should use the top-level support file xc.hnIncluding xc.h instead"

#include <xc.h>

#endif

#if !defined(__CCI__) && !defined(__IAR__)

/* allow CCI definitions even when CCI option is not turned on */

#include <cci.h>

#endif

/* Definitions for _HTC_EDITION_ values */

#define __LITE__ 0

#define __STD__ 1

#define __PRO__ 2

/* common definitions */

#define ___mkstr1(x) #x

#define ___mkstr(x) ___mkstr1(x)

#define _OMNITARGET ((void *)0xFFFFFFFF)

extern const char __xc8_OPTIM_SPEED;

#include <xc8debug.h>

/* HI-TECH PICC / PICC-Lite compiler */

#if defined(__PICC__) || defined(__PICCLITE__)

#include <pic.h>

#endif

/* HI-TECH PICC-18 compiler */

#if defined(__PICC18__)

#include <pic18.h>

#endif

/* MPLAB C18 Compatibility Header */

#ifdef __18CXX

#include <pic18.h>

#endif

/* HI-TECH dsPICC compiler */

#if defined(__DSPICC__)

#include <dspic.h>

#endif

/* HI-TECH C for PIC32 */

#if defined(__PICC32__)

#include <pic32.h>

#endif

Bu header dosyası sayesinde, projenin özelliklerine bakılarak jenerik olarak doğru header’ların seçilmesi sağlanıyor. Muhakkak ki bunların hepsi alt alta dallanıyor ancak şöyle kısaca bir özet geçelim. CCI denilen bir muhabbet var. The Common C Interface (CCI) kavramı, taşınabilir kod yazılabilmesi için ortaya atılmış güzel bir kavram. Ancak Microchip bence bu yarışta biraz geride kalmış. Yine de CCI’ya ileride değineceğim.

xc8debug.h ise, MplabX ide üzerinden yapılan debug işlerine yardımcı olan, çok çok basit bir header. Dolayısıyla üzerinde çok konuşmaya değmeyecek.

pic.h ise önemli. Çünkü derleyicinin bizim işlemcinin register tanımlarını aldığı kütüphane bu kütüphane. Bu iş nasıl oluyor? Biz projeyi yaratır iken, IDE bizim seçtiğimiz işlemciye göre gidip -D ile, compiler define yapıyor. Daha sonra pic.h gibi kütüphaneler bu bilgileri kullanarak, hangi mikrodenetleyicinin header’ının seçileceğine karar veriyor. Örneğin bizim seçimimizde IDE, bizim seçtiğimiz işlemciye göre -D_16F84A tanımını yaptı. Bu bilgiyi cebe atıp devam edelim. pic.h’ın içine bir bakalım.

#ifndef    _PIC_H_
#define    _PIC_H_

#ifndef _HTC_H_
#include <htc.h>
#endif

#ifdef _HAS_OSCVAL_
extern unsigned char __osccal_val(void);
#endif

#include <pic_chip_select.h>

/* MPLAB REAL-ICE related macros & includes (currently enhanced PICs only) */
#if defined(__DISABLE_REALICE_IT) || !defined(__MPLAB_REALICE__) || !defined(_PIC14E)
    #define __TRACE(id)         /* TRACE disabled */
    #define __LOG(id,value)     /* LOG disabled */
#else
    #if defined(__MPLAB_REALICE__)
        #include <trace16.h>
    #endif
#endif

#define    CLRWDT()    asm("clrwdt")
#define    SLEEP()     asm("sleep")
// function version of nop
#pragma intrinsic(__nop)
extern void __nop(void);
#define NOP()      __nop()

/* _nop() has been deprecated; use __nop() */
#define _nop()     __nop()

#define    ASMOPT_ON()     asm("opt asmopt_on")
#define    ASMOPT_OFF()    asm("opt asmopt_off")

//
// Legacy Programming Macro Functions
//
#define    __CONFIG(x) 
            __config(___mkstr(__CONFIG), ___mkstr(pic), ___mkstr(x))
// Programs the lower 4 bits per ID location
#define __IDLOC(w) 
            __config(___mkstr(__IDLOC), ___mkstr(pic), ___mkstr(w))
// Variant of IDLOC for those devices that permit programming of the lower 7 bits per ID location
#define __IDLOC7(a,b,c,d) 
            __config(___mkstr(__IDLOC7), ___mkstr(pic), a, b, c, d)
#define    __PROG_CONFIG(a, x) 
            __config(___mkstr(__PROG_CONFIG), ___mkstr(pic), a, x)


#if !defined(_PIC14E) && !defined(_EEADRL)
#define _EEADRL EEADR
#else
#define _EEADRL EEADRL
#endif
#if    EEPROM_SIZE > 0
#define __EEPROM_DATA(a, b, c, d, e, f, g, h) 
             asm("tpsect eeprom_data,class=EEDATA,delta=2,space=3,noexec"); 
             asm("tdbt" ___mkstr(a) "," ___mkstr(b) "," ___mkstr(c) "," ___mkstr(d) "," 
                      ___mkstr(e) "," ___mkstr(f) "," ___mkstr(g) "," ___mkstr(h))
#endif

/***********************************************************************
 **** FLASH memory read/write/erase macros and function definitions ****
 ***********************************************************************
 * Notes:
 *  __FLASHTYPE == 0 defined in devices that can only read flash memory - cannot write eg. 16F777
 *  __FLASHTYPE == 1 defined in traditional devices that can write 1 word at a time eg. 16F877
 *  __FLASHTYPE == 2 defined in devices that can only write in 4 word blocks eg. 16F877A
 *  __FLASHTYPE == 3 defined in devices requiring 32-word block erasure before writing eg. 16F87
 *  __FLASHTYPE == undefined if device can neither read nor write program memory
 */
// macro FLASH_READ returns a word stored at a flash address
#if defined(__FLASHTYPE)
extern unsigned int flash_read(unsigned short addr);
#if    EEPROM_SIZE > 0
#define FLASH_READ(addr) 
    (_EEADRL=(addr)&0xff,   
    EEADRH=(addr)>>8, 
    WREN=0,         
    EECON1 |= 0x80,     
    RD=1,           
    NOP(),          
    NOP(),          
    (EEDATH << 8) | EEDATA)
#else  // FLASH_READ without EEPROM
#define FLASH_READ(addr) 
    (_EEADRL=(addr)&0xff,   
    EEADRH=(addr)>>8, 
    RD=1,           
    NOP(),          
    NOP(),          
    (EEDATH << 8) | EEDATA)
#endif
#endif // end FLASH_READ

// macro FLASH_WRITE used when writing only one word of data
#if    __FLASHTYPE==2 || __FLASHTYPE==3
/*
 * This is not available in this version. Contact HI-TECH support for more information.
#define FLASH_WRITE(addr,data) 
    do{ 
    unsigned short x=data;  
    flash_copy((const unsigned short *)&x,1,addr);  
    }while(0)

extern void flash_copy(const unsigned short * source_addr,unsigned char length,unsigned short dest_addr);
*/
#elif  __FLASHTYPE==1
#define FLASH_WRITE(addr, value) 
    _EEADRL=((addr)&0xff);  
    EEADRH=((addr)>>8);   
    EEDATH=((value)>>8);  
    EEDATA=((value)&0xff);  
    EECON1 |= 0x80;     
    WREN=1;         
    EECON2 = 0x55;      
    EECON2 = 0xaa;      
    WR=1;           
    NOP();      
    NOP();      
    WREN=0
//extern void flash_copy(const unsigned short * source_addr,unsigned char length,unsigned short dest_addr);
#endif // end FLASH_WRITE

// macro FLASH_ERASE used to clear a 32-Byte sector of flash
#if    __FLASHTYPE==3
#define FLASH_ERASE(addr) 
        while(WR)continue; 
    _EEADRL=((addr)&0xFF); 
    EEADRH=((addr>>8)&0xFF); 
    EECON1=0x94; 
    CARRY=0;if(GIE)CARRY=1;GIE=0;
    EECON2=0x55;EECON2=0xAA;WR=1; 
    NOP(); 
    if(CARRY)GIE=1 

    // library function version
extern void flash_erase(unsigned short addr);
#endif // end FLASH_ERASE

#include <eeprom_routines.h>

#ifdef __PICCPRO__
/****************************************************************/
/* Built-in delay routine                   */
/****************************************************************/
#pragma intrinsic(_delay)
extern __nonreentrant void _delay(unsigned long);
// NOTE: To use the macros below, YOU must have previously defined _XTAL_FREQ
#define __delay_us(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000000.0)))
#define __delay_ms(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000.0)))
#endif

/****************************************************************/
/****** Global interrupt enable/disable macro definitions *******/
/****************************************************************/
#if defined(_PIC14) || defined(_PIC14E)
    
#ifndef    ei
#define    ei()    (GIE = 1)   // interrupt enable bit
#endif  

#if defined(_14000) ||  defined(_16C61) || defined(_16C62) ||
    defined(_16C63) || defined(_16C63A) || defined(_16C64) ||
    defined(_16C65) || defined(_16C65B) || defined(_16C71) ||
    defined(_16C73) || defined(_16C73B) || defined(_16C74) ||
    defined(_16C74B) || defined(_16C84) || defined(_16C745) ||
    defined(_16C765) || defined(_16LC74B)
    #ifndef di
        #define di()    { do { GIE = 0; } while ( GIE == 1 ); } // disable interrupt bit
    #endif  
#else
    #ifndef di
        #define di()    (GIE = 0)   // interrupt enable bit
    #endif  
#endif

#endif

/* The below reflect the state of TO and PD, respectively, which would otherwise
   be trashed by startup code. */
extern unsigned char __resetbits;
extern __bit __powerdown;
extern __bit __timeout;
#endif /* _PIC_H */

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

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

#ifndef _PIC_H_

#define _PIC_H_

#ifndef _HTC_H_

#include <htc.h>

#endif

#ifdef _HAS_OSCVAL_

extern unsigned char __osccal_val(void);

#endif

#include <pic_chip_select.h>

/* MPLAB REAL-ICE related macros & includes (currently enhanced PICs only) */

#if defined(__DISABLE_REALICE_IT) || !defined(__MPLAB_REALICE__) || !defined(_PIC14E)

#define __TRACE(id) /* TRACE disabled */

#define __LOG(id,value) /* LOG disabled */

#else

#if defined(__MPLAB_REALICE__)

#include <trace16.h>

#endif

#define CLRWDT() asm("clrwdt")

#define SLEEP() asm("sleep")

// function version of nop

#pragma intrinsic(__nop)

extern void __nop(void);

#define NOP() __nop()

/* _nop() has been deprecated; use __nop() */

#define _nop() __nop()

#define ASMOPT_ON() asm("opt asmopt_on")

#define ASMOPT_OFF() asm("opt asmopt_off")

// Legacy Programming Macro Functions

#define __CONFIG(x)

__config(___mkstr(__CONFIG), ___mkstr(pic), ___mkstr(x))

// Programs the lower 4 bits per ID location

#define __IDLOC(w)

__config(___mkstr(__IDLOC), ___mkstr(pic), ___mkstr(w))

// Variant of IDLOC for those devices that permit programming of the lower 7 bits per ID location

#define __IDLOC7(a,b,c,d)

__config(___mkstr(__IDLOC7), ___mkstr(pic), a, b, c, d)

#define __PROG_CONFIG(a, x)

__config(___mkstr(__PROG_CONFIG), ___mkstr(pic), a, x)

#if !defined(_PIC14E) && !defined(_EEADRL)

#define _EEADRL EEADR

#else

#define _EEADRL EEADRL

#endif

#if EEPROM_SIZE > 0

#define __EEPROM_DATA(a, b, c, d, e, f, g, h)

asm("tpsect eeprom_data,class=EEDATA,delta=2,space=3,noexec");

asm("tdbt" ___mkstr(a) "," ___mkstr(b) "," ___mkstr(c) "," ___mkstr(d) ","

___mkstr(e) "," ___mkstr(f) "," ___mkstr(g) "," ___mkstr(h))

#endif

/***********************************************************************

**** FLASH memory read/write/erase macros and function definitions ****

***********************************************************************

* Notes:

* __FLASHTYPE == 0 defined in devices that can only read flash memory - cannot write eg. 16F777

* __FLASHTYPE == 1 defined in traditional devices that can write 1 word at a time eg. 16F877

* __FLASHTYPE == 2 defined in devices that can only write in 4 word blocks eg. 16F877A

* __FLASHTYPE == 3 defined in devices requiring 32-word block erasure before writing eg. 16F87

* __FLASHTYPE == undefined if device can neither read nor write program memory

// macro FLASH_READ returns a word stored at a flash address

#if defined(__FLASHTYPE)

extern unsigned int flash_read(unsigned short addr);

#if EEPROM_SIZE > 0

#define FLASH_READ(addr)

(_EEADRL=(addr)&0xff,

EEADRH=(addr)>>8,

WREN=0,

EECON1 |= 0x80,

RD=1,

NOP(),

(EEDATH << 8) | EEDATA)

#else // FLASH_READ without EEPROM

#define FLASH_READ(addr)

(_EEADRL=(addr)&0xff,

EEADRH=(addr)>>8,

RD=1,

NOP(),

(EEDATH << 8) | EEDATA)

#endif

#endif // end FLASH_READ

// macro FLASH_WRITE used when writing only one word of data

#if __FLASHTYPE==2 || __FLASHTYPE==3

* This is not available in this version. Contact HI-TECH support for more information.

#define FLASH_WRITE(addr,data)

do{

unsigned short x=data;

flash_copy((const unsigned short *)&x,1,addr);

}while(0)

extern void flash_copy(const unsigned short * source_addr,unsigned char length,unsigned short dest_addr);

#elif __FLASHTYPE==1

#define FLASH_WRITE(addr, value)

_EEADRL=((addr)&0xff);

EEADRH=((addr)>>8);

EEDATH=((value)>>8);

EEDATA=((value)&0xff);

EECON1 |= 0x80;

WREN=1;

EECON2 = 0x55;

EECON2 = 0xaa;

WR=1;

NOP();

WREN=0

//extern void flash_copy(const unsigned short * source_addr,unsigned char length,unsigned short dest_addr);

#endif // end FLASH_WRITE

// macro FLASH_ERASE used to clear a 32-Byte sector of flash

#if __FLASHTYPE==3

#define FLASH_ERASE(addr)

while(WR)continue;

_EEADRL=((addr)&0xFF);

EEADRH=((addr>>8)&0xFF);

EECON1=0x94;

CARRY=0;if(GIE)CARRY=1;GIE=0;

EECON2=0x55;EECON2=0xAA;WR=1;

NOP();

if(CARRY)GIE=1

// library function version

extern void flash_erase(unsigned short addr);

#endif // end FLASH_ERASE

#include <eeprom_routines.h>

#ifdef __PICCPRO__

/****************************************************************/

/* Built-in delay routine */

/****************************************************************/

#pragma intrinsic(_delay)

extern __nonreentrant void _delay(unsigned long);

// NOTE: To use the macros below, YOU must have previously defined _XTAL_FREQ

#define __delay_us(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000000.0)))

#define __delay_ms(x) _delay((unsigned long)((x)*(_XTAL_FREQ/4000.0)))

#endif

/****************************************************************/

/****** Global interrupt enable/disable macro definitions *******/

/****************************************************************/

#if defined(_PIC14) || defined(_PIC14E)

#ifndef ei

#define ei() (GIE = 1) // interrupt enable bit

#endif

#if defined(_14000) || defined(_16C61) || defined(_16C62) ||

defined(_16C63) || defined(_16C63A) || defined(_16C64) ||

defined(_16C65) || defined(_16C65B) || defined(_16C71) ||

defined(_16C73) || defined(_16C73B) || defined(_16C74) ||

defined(_16C74B) || defined(_16C84) || defined(_16C745) ||

defined(_16C765) || defined(_16LC74B)

#ifndef di

#define di() { do { GIE = 0; } while ( GIE == 1 ); } // disable interrupt bit

#endif

#else

#ifndef di

#define di() (GIE = 0) // interrupt enable bit

#endif

/* The below reflect the state of TO and PD, respectively, which would otherwise

be trashed by startup code. */

extern unsigned char __resetbits;

extern __bit __powerdown;

extern __bit __timeout;

#endif /* _PIC_H */

Arkadaşlar sağolsunlar pic.h içinde bize yardımcı olabilecek çok sayıda şey tanımlamışlar. pic_chip_select.h tam olarak mikrokontrolör header’ı seçimini yapıyor ve onu mutlaka konuşacağız. Ancak sırayla buradaki bazı ibretlere bir değinelim. PIC16F84A; 68 byte RAM’i ve 1024 word’lük inanılmaz(!) FLASH belleği ile, hakikaten kısıtlı kaynaklı bir donanım olduğundan, dayılar haklı olarak LOG ve TRACE fonksiyonelitelerini kapatmışlar 🙂 Zira bu fonksiyoneliteleri kullanmaya kalksaydık, kaynakların çoğunu kullanmış olurduk.

#define    CLRWDT()    asm("clrwdt")
#define    SLEEP()     asm("sleep")

1 2	#define CLRWDT() asm("clrwdt") #define SLEEP() asm("sleep")

Yukarıdaki etiketler, assembler komutlarını çağırarak sırasıyla watchdog timer’ı resetlemenin ve uyku moduna girmenin verimli implementasyonları olarak göze çarpıyor. Watchdog timer’ı resetlemek bazı arkadaşlara bir anlam ifade etmemiş olabilir. Mikrodenetleyici bir sebepten donarsa filan, reset atabilecek bir donanımın olması gerekiyor. Eğer mikrodenetleyicideki kod, belli aralıklarla watchdog timer’ın sayacını sıfırlamazsa, sayaç artıp taşar ve taştığı gibi mikrodenetleyiciye reset atar. Yerli yerinde kullanıldığında WDT (watchdog timer) candır 🙂 Sleep ise, mikrodenetleyiciyi düşük güç tüketimi moduna sokmanın güzel bir yoludur. Bu kısmı da ileride detaylıca ele alacağız.

ei(); ve di(); fonksiyonları ile sırasyla interrupt enable ve interrupt disable işleri kolaylaştırılmış. İleride detaylıca değineceğimiz kesme fonksiyonelitesinin aktive edilmesi ya da devre dışı bırakılması için bu makroları kullanmak mümkün 🙂 Diğer kısımlar zaten benzer. Öyleyse şimdi pic_chip_select.h kütüphanesinin bir kısmını inceleyelim. Gerisi de zaten aynı 😀

...

#ifdef _16F84
#ifdef _LEGACY_HEADERS
#include <pic1684_legacy.h>
#undef _HEADER_NOT_FOUND
#else
#include <pic16f84.h>
#undef _HEADER_NOT_FOUND
#endif
#endif

#ifdef _16F84A
#ifdef _LEGACY_HEADERS
#include <pic1684_legacy.h>
#undef _HEADER_NOT_FOUND
#else
#include <pic16f84a.h>
#undef _HEADER_NOT_FOUND
#endif
#endif

...

...

#ifdef _16F84

#ifdef _LEGACY_HEADERS

#include <pic1684_legacy.h>

#undef _HEADER_NOT_FOUND

#else

#include <pic16f84.h>

#undef _HEADER_NOT_FOUND

#endif

#ifdef _16F84A

#ifdef _LEGACY_HEADERS

#include <pic1684_legacy.h>

#undef _HEADER_NOT_FOUND

#else

#include <pic16f84a.h>

#undef _HEADER_NOT_FOUND

#endif

...

Bu dosyada gördüğünüz gibi, IDE tarafından biz projeyi oluştururken tanımlanan etiketler kullanılarak doğru başlık dosyaları (header files) projeye dahil ediliyor yani çağırılıyor. Bu saydede biz xc.h dediğimizde, mikrokontrolör modeline göre, başlık dosyaları otomatik çağırılmış oluyor. Hmm, güzel 🙂 Öyleyse bir adım daha dalalım.

// Version 1.34
// Generated 16/02/2015 GMT

/*
 * Copyright Â© 2015, Microchip Technology Inc. and its subsidiaries ("Microchip")
 * All rights reserved.
 * 
 * This software is developed by Microchip Technology Inc. and its subsidiaries ("Microchip").
 * 
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 * 
 *     1. Redistributions of source code must retain the above copyright notice, this list of
 *        conditions and the following disclaimer.
 * 
 *     2. Redistributions in binary form must reproduce the above copyright notice, this list
 *        of conditions and the following disclaimer in the documentation and/or other
 *        materials provided with the distribution.
 * 
 *     3. Microchip's name may not be used to endorse or promote products derived from this
 *        software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY MICROCHIP "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MICROCHIP BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWSOEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *  */

#ifndef _PIC16F84A_H_
#define _PIC16F84A_H_

/*
 * C Header file for the Microchip PIC Microcontroller
 * PIC16F84A
 *  */
#ifndef __XC8
#warning Header file pic16f84a.h included directly. Use #include <xc.h> instead.
#endif

/*
 * Register Definitions
 *  */

// Register: INDF
extern volatile unsigned char           INDF                @ 0x000;
#ifndef _LIB_BUILD
asm("INDF equ 00h");
#endif

// Register: TMR0
extern volatile unsigned char           TMR0                @ 0x001;
#ifndef _LIB_BUILD
asm("TMR0 equ 01h");
#endif

// Register: PCL
extern volatile unsigned char           PCL                 @ 0x002;
#ifndef _LIB_BUILD
asm("PCL equ 02h");
#endif

// Register: STATUS
extern volatile unsigned char           STATUS              @ 0x003;
#ifndef _LIB_BUILD
asm("STATUS equ 03h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned C                      :1;
        unsigned DC                     :1;
        unsigned Z                      :1;
        unsigned nPD                    :1;
        unsigned nTO                    :1;
        unsigned RP                     :2;
        unsigned IRP                    :1;
    };
    struct {
        unsigned                        :5;
        unsigned RP0                    :1;
        unsigned RP1                    :1;
    };
    struct {
        unsigned CARRY                  :1;
    };
    struct {
        unsigned                        :2;
        unsigned ZERO                   :1;
    };
} STATUSbits_t;
extern volatile STATUSbits_t STATUSbits @ 0x003;
// bitfield macros
#define _STATUS_C_POSN                                      0x0
#define _STATUS_C_POSITION                                  0x0
#define _STATUS_C_SIZE                                      0x1
#define _STATUS_C_LENGTH                                    0x1
#define _STATUS_C_MASK                                      0x1
#define _STATUS_DC_POSN                                     0x1
#define _STATUS_DC_POSITION                                 0x1
#define _STATUS_DC_SIZE                                     0x1
#define _STATUS_DC_LENGTH                                   0x1
#define _STATUS_DC_MASK                                     0x2
#define _STATUS_Z_POSN                                      0x2
#define _STATUS_Z_POSITION                                  0x2
#define _STATUS_Z_SIZE                                      0x1
#define _STATUS_Z_LENGTH                                    0x1
#define _STATUS_Z_MASK                                      0x4
#define _STATUS_nPD_POSN                                    0x3
#define _STATUS_nPD_POSITION                                0x3
#define _STATUS_nPD_SIZE                                    0x1
#define _STATUS_nPD_LENGTH                                  0x1
#define _STATUS_nPD_MASK                                    0x8
#define _STATUS_nTO_POSN                                    0x4
#define _STATUS_nTO_POSITION                                0x4
#define _STATUS_nTO_SIZE                                    0x1
#define _STATUS_nTO_LENGTH                                  0x1
#define _STATUS_nTO_MASK                                    0x10
#define _STATUS_RP_POSN                                     0x5
#define _STATUS_RP_POSITION                                 0x5
#define _STATUS_RP_SIZE                                     0x2
#define _STATUS_RP_LENGTH                                   0x2
#define _STATUS_RP_MASK                                     0x60
#define _STATUS_IRP_POSN                                    0x7
#define _STATUS_IRP_POSITION                                0x7
#define _STATUS_IRP_SIZE                                    0x1
#define _STATUS_IRP_LENGTH                                  0x1
#define _STATUS_IRP_MASK                                    0x80
#define _STATUS_RP0_POSN                                    0x5
#define _STATUS_RP0_POSITION                                0x5
#define _STATUS_RP0_SIZE                                    0x1
#define _STATUS_RP0_LENGTH                                  0x1
#define _STATUS_RP0_MASK                                    0x20
#define _STATUS_RP1_POSN                                    0x6
#define _STATUS_RP1_POSITION                                0x6
#define _STATUS_RP1_SIZE                                    0x1
#define _STATUS_RP1_LENGTH                                  0x1
#define _STATUS_RP1_MASK                                    0x40
#define _STATUS_CARRY_POSN                                  0x0
#define _STATUS_CARRY_POSITION                              0x0
#define _STATUS_CARRY_SIZE                                  0x1
#define _STATUS_CARRY_LENGTH                                0x1
#define _STATUS_CARRY_MASK                                  0x1
#define _STATUS_ZERO_POSN                                   0x2
#define _STATUS_ZERO_POSITION                               0x2
#define _STATUS_ZERO_SIZE                                   0x1
#define _STATUS_ZERO_LENGTH                                 0x1
#define _STATUS_ZERO_MASK                                   0x4

// Register: FSR
extern volatile unsigned char           FSR                 @ 0x004;
#ifndef _LIB_BUILD
asm("FSR equ 04h");
#endif

// Register: PORTA
extern volatile unsigned char           PORTA               @ 0x005;
#ifndef _LIB_BUILD
asm("PORTA equ 05h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned RA0                    :1;
        unsigned RA1                    :1;
        unsigned RA2                    :1;
        unsigned RA3                    :1;
        unsigned RA4                    :1;
    };
} PORTAbits_t;
extern volatile PORTAbits_t PORTAbits @ 0x005;
// bitfield macros
#define _PORTA_RA0_POSN                                     0x0
#define _PORTA_RA0_POSITION                                 0x0
#define _PORTA_RA0_SIZE                                     0x1
#define _PORTA_RA0_LENGTH                                   0x1
#define _PORTA_RA0_MASK                                     0x1
#define _PORTA_RA1_POSN                                     0x1
#define _PORTA_RA1_POSITION                                 0x1
#define _PORTA_RA1_SIZE                                     0x1
#define _PORTA_RA1_LENGTH                                   0x1
#define _PORTA_RA1_MASK                                     0x2
#define _PORTA_RA2_POSN                                     0x2
#define _PORTA_RA2_POSITION                                 0x2
#define _PORTA_RA2_SIZE                                     0x1
#define _PORTA_RA2_LENGTH                                   0x1
#define _PORTA_RA2_MASK                                     0x4
#define _PORTA_RA3_POSN                                     0x3
#define _PORTA_RA3_POSITION                                 0x3
#define _PORTA_RA3_SIZE                                     0x1
#define _PORTA_RA3_LENGTH                                   0x1
#define _PORTA_RA3_MASK                                     0x8
#define _PORTA_RA4_POSN                                     0x4
#define _PORTA_RA4_POSITION                                 0x4
#define _PORTA_RA4_SIZE                                     0x1
#define _PORTA_RA4_LENGTH                                   0x1
#define _PORTA_RA4_MASK                                     0x10

// Register: PORTB
extern volatile unsigned char           PORTB               @ 0x006;
#ifndef _LIB_BUILD
asm("PORTB equ 06h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned RB0                    :1;
        unsigned RB1                    :1;
        unsigned RB2                    :1;
        unsigned RB3                    :1;
        unsigned RB4                    :1;
        unsigned RB5                    :1;
        unsigned RB6                    :1;
        unsigned RB7                    :1;
    };
} PORTBbits_t;
extern volatile PORTBbits_t PORTBbits @ 0x006;
// bitfield macros
#define _PORTB_RB0_POSN                                     0x0
#define _PORTB_RB0_POSITION                                 0x0
#define _PORTB_RB0_SIZE                                     0x1
#define _PORTB_RB0_LENGTH                                   0x1
#define _PORTB_RB0_MASK                                     0x1
#define _PORTB_RB1_POSN                                     0x1
#define _PORTB_RB1_POSITION                                 0x1
#define _PORTB_RB1_SIZE                                     0x1
#define _PORTB_RB1_LENGTH                                   0x1
#define _PORTB_RB1_MASK                                     0x2
#define _PORTB_RB2_POSN                                     0x2
#define _PORTB_RB2_POSITION                                 0x2
#define _PORTB_RB2_SIZE                                     0x1
#define _PORTB_RB2_LENGTH                                   0x1
#define _PORTB_RB2_MASK                                     0x4
#define _PORTB_RB3_POSN                                     0x3
#define _PORTB_RB3_POSITION                                 0x3
#define _PORTB_RB3_SIZE                                     0x1
#define _PORTB_RB3_LENGTH                                   0x1
#define _PORTB_RB3_MASK                                     0x8
#define _PORTB_RB4_POSN                                     0x4
#define _PORTB_RB4_POSITION                                 0x4
#define _PORTB_RB4_SIZE                                     0x1
#define _PORTB_RB4_LENGTH                                   0x1
#define _PORTB_RB4_MASK                                     0x10
#define _PORTB_RB5_POSN                                     0x5
#define _PORTB_RB5_POSITION                                 0x5
#define _PORTB_RB5_SIZE                                     0x1
#define _PORTB_RB5_LENGTH                                   0x1
#define _PORTB_RB5_MASK                                     0x20
#define _PORTB_RB6_POSN                                     0x6
#define _PORTB_RB6_POSITION                                 0x6
#define _PORTB_RB6_SIZE                                     0x1
#define _PORTB_RB6_LENGTH                                   0x1
#define _PORTB_RB6_MASK                                     0x40
#define _PORTB_RB7_POSN                                     0x7
#define _PORTB_RB7_POSITION                                 0x7
#define _PORTB_RB7_SIZE                                     0x1
#define _PORTB_RB7_LENGTH                                   0x1
#define _PORTB_RB7_MASK                                     0x80

// Register: EEDATA
extern volatile unsigned char           EEDATA              @ 0x008;
#ifndef _LIB_BUILD
asm("EEDATA equ 08h");
#endif

// Register: EEADR
extern volatile unsigned char           EEADR               @ 0x009;
#ifndef _LIB_BUILD
asm("EEADR equ 09h");
#endif

// Register: PCLATH
extern volatile unsigned char           PCLATH              @ 0x00A;
#ifndef _LIB_BUILD
asm("PCLATH equ 0Ah");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned PCLATH                 :5;
    };
} PCLATHbits_t;
extern volatile PCLATHbits_t PCLATHbits @ 0x00A;
// bitfield macros
#define _PCLATH_PCLATH_POSN                                 0x0
#define _PCLATH_PCLATH_POSITION                             0x0
#define _PCLATH_PCLATH_SIZE                                 0x5
#define _PCLATH_PCLATH_LENGTH                               0x5
#define _PCLATH_PCLATH_MASK                                 0x1F

// Register: INTCON
extern volatile unsigned char           INTCON              @ 0x00B;
#ifndef _LIB_BUILD
asm("INTCON equ 0Bh");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned RBIF                   :1;
        unsigned INTF                   :1;
        unsigned T0IF                   :1;
        unsigned RBIE                   :1;
        unsigned INTE                   :1;
        unsigned T0IE                   :1;
        unsigned EEIE                   :1;
        unsigned GIE                    :1;
    };
    struct {
        unsigned                        :2;
        unsigned TMR0IF                 :1;
        unsigned                        :2;
        unsigned TMR0IE                 :1;
    };
} INTCONbits_t;
extern volatile INTCONbits_t INTCONbits @ 0x00B;
// bitfield macros
#define _INTCON_RBIF_POSN                                   0x0
#define _INTCON_RBIF_POSITION                               0x0
#define _INTCON_RBIF_SIZE                                   0x1
#define _INTCON_RBIF_LENGTH                                 0x1
#define _INTCON_RBIF_MASK                                   0x1
#define _INTCON_INTF_POSN                                   0x1
#define _INTCON_INTF_POSITION                               0x1
#define _INTCON_INTF_SIZE                                   0x1
#define _INTCON_INTF_LENGTH                                 0x1
#define _INTCON_INTF_MASK                                   0x2
#define _INTCON_T0IF_POSN                                   0x2
#define _INTCON_T0IF_POSITION                               0x2
#define _INTCON_T0IF_SIZE                                   0x1
#define _INTCON_T0IF_LENGTH                                 0x1
#define _INTCON_T0IF_MASK                                   0x4
#define _INTCON_RBIE_POSN                                   0x3
#define _INTCON_RBIE_POSITION                               0x3
#define _INTCON_RBIE_SIZE                                   0x1
#define _INTCON_RBIE_LENGTH                                 0x1
#define _INTCON_RBIE_MASK                                   0x8
#define _INTCON_INTE_POSN                                   0x4
#define _INTCON_INTE_POSITION                               0x4
#define _INTCON_INTE_SIZE                                   0x1
#define _INTCON_INTE_LENGTH                                 0x1
#define _INTCON_INTE_MASK                                   0x10
#define _INTCON_T0IE_POSN                                   0x5
#define _INTCON_T0IE_POSITION                               0x5
#define _INTCON_T0IE_SIZE                                   0x1
#define _INTCON_T0IE_LENGTH                                 0x1
#define _INTCON_T0IE_MASK                                   0x20
#define _INTCON_EEIE_POSN                                   0x6
#define _INTCON_EEIE_POSITION                               0x6
#define _INTCON_EEIE_SIZE                                   0x1
#define _INTCON_EEIE_LENGTH                                 0x1
#define _INTCON_EEIE_MASK                                   0x40
#define _INTCON_GIE_POSN                                    0x7
#define _INTCON_GIE_POSITION                                0x7
#define _INTCON_GIE_SIZE                                    0x1
#define _INTCON_GIE_LENGTH                                  0x1
#define _INTCON_GIE_MASK                                    0x80
#define _INTCON_TMR0IF_POSN                                 0x2
#define _INTCON_TMR0IF_POSITION                             0x2
#define _INTCON_TMR0IF_SIZE                                 0x1
#define _INTCON_TMR0IF_LENGTH                               0x1
#define _INTCON_TMR0IF_MASK                                 0x4
#define _INTCON_TMR0IE_POSN                                 0x5
#define _INTCON_TMR0IE_POSITION                             0x5
#define _INTCON_TMR0IE_SIZE                                 0x1
#define _INTCON_TMR0IE_LENGTH                               0x1
#define _INTCON_TMR0IE_MASK                                 0x20

// Register: OPTION_REG
extern volatile unsigned char           OPTION_REG          @ 0x081;
#ifndef _LIB_BUILD
asm("OPTION_REG equ 081h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned PS                     :3;
        unsigned PSA                    :1;
        unsigned T0SE                   :1;
        unsigned T0CS                   :1;
        unsigned INTEDG                 :1;
        unsigned nRBPU                  :1;
    };
    struct {
        unsigned PS0                    :1;
        unsigned PS1                    :1;
        unsigned PS2                    :1;
    };
} OPTION_REGbits_t;
extern volatile OPTION_REGbits_t OPTION_REGbits @ 0x081;
// bitfield macros
#define _OPTION_REG_PS_POSN                                 0x0
#define _OPTION_REG_PS_POSITION                             0x0
#define _OPTION_REG_PS_SIZE                                 0x3
#define _OPTION_REG_PS_LENGTH                               0x3
#define _OPTION_REG_PS_MASK                                 0x7
#define _OPTION_REG_PSA_POSN                                0x3
#define _OPTION_REG_PSA_POSITION                            0x3
#define _OPTION_REG_PSA_SIZE                                0x1
#define _OPTION_REG_PSA_LENGTH                              0x1
#define _OPTION_REG_PSA_MASK                                0x8
#define _OPTION_REG_T0SE_POSN                               0x4
#define _OPTION_REG_T0SE_POSITION                           0x4
#define _OPTION_REG_T0SE_SIZE                               0x1
#define _OPTION_REG_T0SE_LENGTH                             0x1
#define _OPTION_REG_T0SE_MASK                               0x10
#define _OPTION_REG_T0CS_POSN                               0x5
#define _OPTION_REG_T0CS_POSITION                           0x5
#define _OPTION_REG_T0CS_SIZE                               0x1
#define _OPTION_REG_T0CS_LENGTH                             0x1
#define _OPTION_REG_T0CS_MASK                               0x20
#define _OPTION_REG_INTEDG_POSN                             0x6
#define _OPTION_REG_INTEDG_POSITION                         0x6
#define _OPTION_REG_INTEDG_SIZE                             0x1
#define _OPTION_REG_INTEDG_LENGTH                           0x1
#define _OPTION_REG_INTEDG_MASK                             0x40
#define _OPTION_REG_nRBPU_POSN                              0x7
#define _OPTION_REG_nRBPU_POSITION                          0x7
#define _OPTION_REG_nRBPU_SIZE                              0x1
#define _OPTION_REG_nRBPU_LENGTH                            0x1
#define _OPTION_REG_nRBPU_MASK                              0x80
#define _OPTION_REG_PS0_POSN                                0x0
#define _OPTION_REG_PS0_POSITION                            0x0
#define _OPTION_REG_PS0_SIZE                                0x1
#define _OPTION_REG_PS0_LENGTH                              0x1
#define _OPTION_REG_PS0_MASK                                0x1
#define _OPTION_REG_PS1_POSN                                0x1
#define _OPTION_REG_PS1_POSITION                            0x1
#define _OPTION_REG_PS1_SIZE                                0x1
#define _OPTION_REG_PS1_LENGTH                              0x1
#define _OPTION_REG_PS1_MASK                                0x2
#define _OPTION_REG_PS2_POSN                                0x2
#define _OPTION_REG_PS2_POSITION                            0x2
#define _OPTION_REG_PS2_SIZE                                0x1
#define _OPTION_REG_PS2_LENGTH                              0x1
#define _OPTION_REG_PS2_MASK                                0x4

// Register: TRISA
extern volatile unsigned char           TRISA               @ 0x085;
#ifndef _LIB_BUILD
asm("TRISA equ 085h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned TRISA0                 :1;
        unsigned TRISA1                 :1;
        unsigned TRISA2                 :1;
        unsigned TRISA3                 :1;
        unsigned TRISA4                 :1;
    };
} TRISAbits_t;
extern volatile TRISAbits_t TRISAbits @ 0x085;
// bitfield macros
#define _TRISA_TRISA0_POSN                                  0x0
#define _TRISA_TRISA0_POSITION                              0x0
#define _TRISA_TRISA0_SIZE                                  0x1
#define _TRISA_TRISA0_LENGTH                                0x1
#define _TRISA_TRISA0_MASK                                  0x1
#define _TRISA_TRISA1_POSN                                  0x1
#define _TRISA_TRISA1_POSITION                              0x1
#define _TRISA_TRISA1_SIZE                                  0x1
#define _TRISA_TRISA1_LENGTH                                0x1
#define _TRISA_TRISA1_MASK                                  0x2
#define _TRISA_TRISA2_POSN                                  0x2
#define _TRISA_TRISA2_POSITION                              0x2
#define _TRISA_TRISA2_SIZE                                  0x1
#define _TRISA_TRISA2_LENGTH                                0x1
#define _TRISA_TRISA2_MASK                                  0x4
#define _TRISA_TRISA3_POSN                                  0x3
#define _TRISA_TRISA3_POSITION                              0x3
#define _TRISA_TRISA3_SIZE                                  0x1
#define _TRISA_TRISA3_LENGTH                                0x1
#define _TRISA_TRISA3_MASK                                  0x8
#define _TRISA_TRISA4_POSN                                  0x4
#define _TRISA_TRISA4_POSITION                              0x4
#define _TRISA_TRISA4_SIZE                                  0x1
#define _TRISA_TRISA4_LENGTH                                0x1
#define _TRISA_TRISA4_MASK                                  0x10

// Register: TRISB
extern volatile unsigned char           TRISB               @ 0x086;
#ifndef _LIB_BUILD
asm("TRISB equ 086h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned TRISB0                 :1;
        unsigned TRISB1                 :1;
        unsigned TRISB2                 :1;
        unsigned TRISB3                 :1;
        unsigned TRISB4                 :1;
        unsigned TRISB5                 :1;
        unsigned TRISB6                 :1;
        unsigned TRISB7                 :1;
    };
} TRISBbits_t;
extern volatile TRISBbits_t TRISBbits @ 0x086;
// bitfield macros
#define _TRISB_TRISB0_POSN                                  0x0
#define _TRISB_TRISB0_POSITION                              0x0
#define _TRISB_TRISB0_SIZE                                  0x1
#define _TRISB_TRISB0_LENGTH                                0x1
#define _TRISB_TRISB0_MASK                                  0x1
#define _TRISB_TRISB1_POSN                                  0x1
#define _TRISB_TRISB1_POSITION                              0x1
#define _TRISB_TRISB1_SIZE                                  0x1
#define _TRISB_TRISB1_LENGTH                                0x1
#define _TRISB_TRISB1_MASK                                  0x2
#define _TRISB_TRISB2_POSN                                  0x2
#define _TRISB_TRISB2_POSITION                              0x2
#define _TRISB_TRISB2_SIZE                                  0x1
#define _TRISB_TRISB2_LENGTH                                0x1
#define _TRISB_TRISB2_MASK                                  0x4
#define _TRISB_TRISB3_POSN                                  0x3
#define _TRISB_TRISB3_POSITION                              0x3
#define _TRISB_TRISB3_SIZE                                  0x1
#define _TRISB_TRISB3_LENGTH                                0x1
#define _TRISB_TRISB3_MASK                                  0x8
#define _TRISB_TRISB4_POSN                                  0x4
#define _TRISB_TRISB4_POSITION                              0x4
#define _TRISB_TRISB4_SIZE                                  0x1
#define _TRISB_TRISB4_LENGTH                                0x1
#define _TRISB_TRISB4_MASK                                  0x10
#define _TRISB_TRISB5_POSN                                  0x5
#define _TRISB_TRISB5_POSITION                              0x5
#define _TRISB_TRISB5_SIZE                                  0x1
#define _TRISB_TRISB5_LENGTH                                0x1
#define _TRISB_TRISB5_MASK                                  0x20
#define _TRISB_TRISB6_POSN                                  0x6
#define _TRISB_TRISB6_POSITION                              0x6
#define _TRISB_TRISB6_SIZE                                  0x1
#define _TRISB_TRISB6_LENGTH                                0x1
#define _TRISB_TRISB6_MASK                                  0x40
#define _TRISB_TRISB7_POSN                                  0x7
#define _TRISB_TRISB7_POSITION                              0x7
#define _TRISB_TRISB7_SIZE                                  0x1
#define _TRISB_TRISB7_LENGTH                                0x1
#define _TRISB_TRISB7_MASK                                  0x80

// Register: EECON1
extern volatile unsigned char           EECON1              @ 0x088;
#ifndef _LIB_BUILD
asm("EECON1 equ 088h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned RD                     :1;
        unsigned WR                     :1;
        unsigned WREN                   :1;
        unsigned WRERR                  :1;
        unsigned EEIF                   :1;
    };
} EECON1bits_t;
extern volatile EECON1bits_t EECON1bits @ 0x088;
// bitfield macros
#define _EECON1_RD_POSN                                     0x0
#define _EECON1_RD_POSITION                                 0x0
#define _EECON1_RD_SIZE                                     0x1
#define _EECON1_RD_LENGTH                                   0x1
#define _EECON1_RD_MASK                                     0x1
#define _EECON1_WR_POSN                                     0x1
#define _EECON1_WR_POSITION                                 0x1
#define _EECON1_WR_SIZE                                     0x1
#define _EECON1_WR_LENGTH                                   0x1
#define _EECON1_WR_MASK                                     0x2
#define _EECON1_WREN_POSN                                   0x2
#define _EECON1_WREN_POSITION                               0x2
#define _EECON1_WREN_SIZE                                   0x1
#define _EECON1_WREN_LENGTH                                 0x1
#define _EECON1_WREN_MASK                                   0x4
#define _EECON1_WRERR_POSN                                  0x3
#define _EECON1_WRERR_POSITION                              0x3
#define _EECON1_WRERR_SIZE                                  0x1
#define _EECON1_WRERR_LENGTH                                0x1
#define _EECON1_WRERR_MASK                                  0x8
#define _EECON1_EEIF_POSN                                   0x4
#define _EECON1_EEIF_POSITION                               0x4
#define _EECON1_EEIF_SIZE                                   0x1
#define _EECON1_EEIF_LENGTH                                 0x1
#define _EECON1_EEIF_MASK                                   0x10

// Register: EECON2
extern volatile unsigned char           EECON2              @ 0x089;
#ifndef _LIB_BUILD
asm("EECON2 equ 089h");
#endif

/*
 * Bit Definitions
 *  */
#define _DEPRECATED __attribute__((__deprecated__))
#ifndef BANKMASK
#define BANKMASK(addr) ((addr)&07Fh)
#endif
extern volatile __bit                   CARRY               @ (((unsigned) &STATUS)*8) + 0;
#define                                 CARRY_bit           BANKMASK(STATUS), 0
extern volatile __bit                   DC                  @ (((unsigned) &STATUS)*8) + 1;
#define                                 DC_bit              BANKMASK(STATUS), 1
extern volatile __bit                   EEIE                @ (((unsigned) &INTCON)*8) + 6;
#define                                 EEIE_bit            BANKMASK(INTCON), 6
extern volatile __bit                   EEIF                @ (((unsigned) &EECON1)*8) + 4;
#define                                 EEIF_bit            BANKMASK(EECON1), 4
extern volatile __bit                   GIE                 @ (((unsigned) &INTCON)*8) + 7;
#define                                 GIE_bit             BANKMASK(INTCON), 7
extern volatile __bit                   INTE                @ (((unsigned) &INTCON)*8) + 4;
#define                                 INTE_bit            BANKMASK(INTCON), 4
extern volatile __bit                   INTEDG              @ (((unsigned) &OPTION_REG)*8) + 6;
#define                                 INTEDG_bit          BANKMASK(OPTION_REG), 6
extern volatile __bit                   INTF                @ (((unsigned) &INTCON)*8) + 1;
#define                                 INTF_bit            BANKMASK(INTCON), 1
extern volatile __bit                   IRP                 @ (((unsigned) &STATUS)*8) + 7;
#define                                 IRP_bit             BANKMASK(STATUS), 7
extern volatile __bit                   PS0                 @ (((unsigned) &OPTION_REG)*8) + 0;
#define                                 PS0_bit             BANKMASK(OPTION_REG), 0
extern volatile __bit                   PS1                 @ (((unsigned) &OPTION_REG)*8) + 1;
#define                                 PS1_bit             BANKMASK(OPTION_REG), 1
extern volatile __bit                   PS2                 @ (((unsigned) &OPTION_REG)*8) + 2;
#define                                 PS2_bit             BANKMASK(OPTION_REG), 2
extern volatile __bit                   PSA                 @ (((unsigned) &OPTION_REG)*8) + 3;
#define                                 PSA_bit             BANKMASK(OPTION_REG), 3
extern volatile __bit                   RA0                 @ (((unsigned) &PORTA)*8) + 0;
#define                                 RA0_bit             BANKMASK(PORTA), 0
extern volatile __bit                   RA1                 @ (((unsigned) &PORTA)*8) + 1;
#define                                 RA1_bit             BANKMASK(PORTA), 1
extern volatile __bit                   RA2                 @ (((unsigned) &PORTA)*8) + 2;
#define                                 RA2_bit             BANKMASK(PORTA), 2
extern volatile __bit                   RA3                 @ (((unsigned) &PORTA)*8) + 3;
#define                                 RA3_bit             BANKMASK(PORTA), 3
extern volatile __bit                   RA4                 @ (((unsigned) &PORTA)*8) + 4;
#define                                 RA4_bit             BANKMASK(PORTA), 4
extern volatile __bit                   RB0                 @ (((unsigned) &PORTB)*8) + 0;
#define                                 RB0_bit             BANKMASK(PORTB), 0
extern volatile __bit                   RB1                 @ (((unsigned) &PORTB)*8) + 1;
#define                                 RB1_bit             BANKMASK(PORTB), 1
extern volatile __bit                   RB2                 @ (((unsigned) &PORTB)*8) + 2;
#define                                 RB2_bit             BANKMASK(PORTB), 2
extern volatile __bit                   RB3                 @ (((unsigned) &PORTB)*8) + 3;
#define                                 RB3_bit             BANKMASK(PORTB), 3
extern volatile __bit                   RB4                 @ (((unsigned) &PORTB)*8) + 4;
#define                                 RB4_bit             BANKMASK(PORTB), 4
extern volatile __bit                   RB5                 @ (((unsigned) &PORTB)*8) + 5;
#define                                 RB5_bit             BANKMASK(PORTB), 5
extern volatile __bit                   RB6                 @ (((unsigned) &PORTB)*8) + 6;
#define                                 RB6_bit             BANKMASK(PORTB), 6
extern volatile __bit                   RB7                 @ (((unsigned) &PORTB)*8) + 7;
#define                                 RB7_bit             BANKMASK(PORTB), 7
extern volatile __bit                   RBIE                @ (((unsigned) &INTCON)*8) + 3;
#define                                 RBIE_bit            BANKMASK(INTCON), 3
extern volatile __bit                   RBIF                @ (((unsigned) &INTCON)*8) + 0;
#define                                 RBIF_bit            BANKMASK(INTCON), 0
extern volatile __bit                   RD                  @ (((unsigned) &EECON1)*8) + 0;
#define                                 RD_bit              BANKMASK(EECON1), 0
extern volatile __bit                   RP0                 @ (((unsigned) &STATUS)*8) + 5;
#define                                 RP0_bit             BANKMASK(STATUS), 5
extern volatile __bit                   RP1                 @ (((unsigned) &STATUS)*8) + 6;
#define                                 RP1_bit             BANKMASK(STATUS), 6
extern volatile __bit                   T0CS                @ (((unsigned) &OPTION_REG)*8) + 5;
#define                                 T0CS_bit            BANKMASK(OPTION_REG), 5
extern volatile __bit                   T0IE                @ (((unsigned) &INTCON)*8) + 5;
#define                                 T0IE_bit            BANKMASK(INTCON), 5
extern volatile __bit                   T0IF                @ (((unsigned) &INTCON)*8) + 2;
#define                                 T0IF_bit            BANKMASK(INTCON), 2
extern volatile __bit                   T0SE                @ (((unsigned) &OPTION_REG)*8) + 4;
#define                                 T0SE_bit            BANKMASK(OPTION_REG), 4
extern volatile __bit                   TMR0IE              @ (((unsigned) &INTCON)*8) + 5;
#define                                 TMR0IE_bit          BANKMASK(INTCON), 5
extern volatile __bit                   TMR0IF              @ (((unsigned) &INTCON)*8) + 2;
#define                                 TMR0IF_bit          BANKMASK(INTCON), 2
extern volatile __bit                   TRISA0              @ (((unsigned) &TRISA)*8) + 0;
#define                                 TRISA0_bit          BANKMASK(TRISA), 0
extern volatile __bit                   TRISA1              @ (((unsigned) &TRISA)*8) + 1;
#define                                 TRISA1_bit          BANKMASK(TRISA), 1
extern volatile __bit                   TRISA2              @ (((unsigned) &TRISA)*8) + 2;
#define                                 TRISA2_bit          BANKMASK(TRISA), 2
extern volatile __bit                   TRISA3              @ (((unsigned) &TRISA)*8) + 3;
#define                                 TRISA3_bit          BANKMASK(TRISA), 3
extern volatile __bit                   TRISA4              @ (((unsigned) &TRISA)*8) + 4;
#define                                 TRISA4_bit          BANKMASK(TRISA), 4
extern volatile __bit                   TRISB0              @ (((unsigned) &TRISB)*8) + 0;
#define                                 TRISB0_bit          BANKMASK(TRISB), 0
extern volatile __bit                   TRISB1              @ (((unsigned) &TRISB)*8) + 1;
#define                                 TRISB1_bit          BANKMASK(TRISB), 1
extern volatile __bit                   TRISB2              @ (((unsigned) &TRISB)*8) + 2;
#define                                 TRISB2_bit          BANKMASK(TRISB), 2
extern volatile __bit                   TRISB3              @ (((unsigned) &TRISB)*8) + 3;
#define                                 TRISB3_bit          BANKMASK(TRISB), 3
extern volatile __bit                   TRISB4              @ (((unsigned) &TRISB)*8) + 4;
#define                                 TRISB4_bit          BANKMASK(TRISB), 4
extern volatile __bit                   TRISB5              @ (((unsigned) &TRISB)*8) + 5;
#define                                 TRISB5_bit          BANKMASK(TRISB), 5
extern volatile __bit                   TRISB6              @ (((unsigned) &TRISB)*8) + 6;
#define                                 TRISB6_bit          BANKMASK(TRISB), 6
extern volatile __bit                   TRISB7              @ (((unsigned) &TRISB)*8) + 7;
#define                                 TRISB7_bit          BANKMASK(TRISB), 7
extern volatile __bit                   WR                  @ (((unsigned) &EECON1)*8) + 1;
#define                                 WR_bit              BANKMASK(EECON1), 1
extern volatile __bit                   WREN                @ (((unsigned) &EECON1)*8) + 2;
#define                                 WREN_bit            BANKMASK(EECON1), 2
extern volatile __bit                   WRERR               @ (((unsigned) &EECON1)*8) + 3;
#define                                 WRERR_bit           BANKMASK(EECON1), 3
extern volatile __bit                   ZERO                @ (((unsigned) &STATUS)*8) + 2;
#define                                 ZERO_bit            BANKMASK(STATUS), 2
extern volatile __bit                   nPD                 @ (((unsigned) &STATUS)*8) + 3;
#define                                 nPD_bit             BANKMASK(STATUS), 3
extern volatile __bit                   nRBPU               @ (((unsigned) &OPTION_REG)*8) + 7;
#define                                 nRBPU_bit           BANKMASK(OPTION_REG), 7
extern volatile __bit                   nTO                 @ (((unsigned) &STATUS)*8) + 4;
#define                                 nTO_bit             BANKMASK(STATUS), 4

#endif // _PIC16F84A_H_

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

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

// Version 1.34

// Generated 16/02/2015 GMT

* This software is developed by Microchip Technology Inc. and its subsidiaries ("Microchip").

* Redistribution and use in source and binary forms, with or without modification, are

* permitted provided that the following conditions are met:

* 1. Redistributions of source code must retain the above copyright notice, this list of

* conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright notice, this list

* of conditions and the following disclaimer in the documentation and/or other

* materials provided with the distribution.

* 3. Microchip's name may not be used to endorse or promote products derived from this

* software without specific prior written permission.

* THIS SOFTWARE IS PROVIDED BY MICROCHIP "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MICROCHIP BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWSOEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

* */

#ifndef _PIC16F84A_H_

#define _PIC16F84A_H_

* C Header file for the Microchip PIC Microcontroller

* PIC16F84A

* */

#ifndef __XC8

#warning Header file pic16f84a.h included directly. Use #include <xc.h> instead.

#endif

* Register Definitions

* */

// Register: INDF

extern volatile unsigned char INDF @ 0x000;

#ifndef _LIB_BUILD

asm("INDF equ 00h");

#endif

// Register: TMR0

extern volatile unsigned char TMR0 @ 0x001;

#ifndef _LIB_BUILD

asm("TMR0 equ 01h");

#endif

// Register: PCL

extern volatile unsigned char PCL @ 0x002;

#ifndef _LIB_BUILD

asm("PCL equ 02h");

#endif

// Register: STATUS

extern volatile unsigned char STATUS @ 0x003;

#ifndef _LIB_BUILD

asm("STATUS equ 03h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned C :1;

unsigned DC :1;

unsigned Z :1;

unsigned nPD :1;

unsigned nTO :1;

unsigned RP :2;

unsigned IRP :1;

};

struct {

unsigned :5;

unsigned RP0 :1;

unsigned RP1 :1;

};

struct {

unsigned CARRY :1;

};

struct {

unsigned :2;

unsigned ZERO :1;

};

} STATUSbits_t;

extern volatile STATUSbits_t STATUSbits @ 0x003;

// bitfield macros

#define _STATUS_C_POSN 0x0

#define _STATUS_C_POSITION 0x0

#define _STATUS_C_SIZE 0x1

#define _STATUS_C_LENGTH 0x1

#define _STATUS_C_MASK 0x1

#define _STATUS_DC_POSN 0x1

#define _STATUS_DC_POSITION 0x1

#define _STATUS_DC_SIZE 0x1

#define _STATUS_DC_LENGTH 0x1

#define _STATUS_DC_MASK 0x2

#define _STATUS_Z_POSN 0x2

#define _STATUS_Z_POSITION 0x2

#define _STATUS_Z_SIZE 0x1

#define _STATUS_Z_LENGTH 0x1

#define _STATUS_Z_MASK 0x4

#define _STATUS_nPD_POSN 0x3

#define _STATUS_nPD_POSITION 0x3

#define _STATUS_nPD_SIZE 0x1

#define _STATUS_nPD_LENGTH 0x1

#define _STATUS_nPD_MASK 0x8

#define _STATUS_nTO_POSN 0x4

#define _STATUS_nTO_POSITION 0x4

#define _STATUS_nTO_SIZE 0x1

#define _STATUS_nTO_LENGTH 0x1

#define _STATUS_nTO_MASK 0x10

#define _STATUS_RP_POSN 0x5

#define _STATUS_RP_POSITION 0x5

#define _STATUS_RP_SIZE 0x2

#define _STATUS_RP_LENGTH 0x2

#define _STATUS_RP_MASK 0x60

#define _STATUS_IRP_POSN 0x7

#define _STATUS_IRP_POSITION 0x7

#define _STATUS_IRP_SIZE 0x1

#define _STATUS_IRP_LENGTH 0x1

#define _STATUS_IRP_MASK 0x80

#define _STATUS_RP0_POSN 0x5

#define _STATUS_RP0_POSITION 0x5

#define _STATUS_RP0_SIZE 0x1

#define _STATUS_RP0_LENGTH 0x1

#define _STATUS_RP0_MASK 0x20

#define _STATUS_RP1_POSN 0x6

#define _STATUS_RP1_POSITION 0x6

#define _STATUS_RP1_SIZE 0x1

#define _STATUS_RP1_LENGTH 0x1

#define _STATUS_RP1_MASK 0x40

#define _STATUS_CARRY_POSN 0x0

#define _STATUS_CARRY_POSITION 0x0

#define _STATUS_CARRY_SIZE 0x1

#define _STATUS_CARRY_LENGTH 0x1

#define _STATUS_CARRY_MASK 0x1

#define _STATUS_ZERO_POSN 0x2

#define _STATUS_ZERO_POSITION 0x2

#define _STATUS_ZERO_SIZE 0x1

#define _STATUS_ZERO_LENGTH 0x1

#define _STATUS_ZERO_MASK 0x4

// Register: FSR

extern volatile unsigned char FSR @ 0x004;

#ifndef _LIB_BUILD

asm("FSR equ 04h");

#endif

// Register: PORTA

extern volatile unsigned char PORTA @ 0x005;

#ifndef _LIB_BUILD

asm("PORTA equ 05h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned RA0 :1;

unsigned RA1 :1;

unsigned RA2 :1;

unsigned RA3 :1;

unsigned RA4 :1;

};

} PORTAbits_t;

extern volatile PORTAbits_t PORTAbits @ 0x005;

// bitfield macros

#define _PORTA_RA0_POSN 0x0

#define _PORTA_RA0_POSITION 0x0

#define _PORTA_RA0_SIZE 0x1

#define _PORTA_RA0_LENGTH 0x1

#define _PORTA_RA0_MASK 0x1

#define _PORTA_RA1_POSN 0x1

#define _PORTA_RA1_POSITION 0x1

#define _PORTA_RA1_SIZE 0x1

#define _PORTA_RA1_LENGTH 0x1

#define _PORTA_RA1_MASK 0x2

#define _PORTA_RA2_POSN 0x2

#define _PORTA_RA2_POSITION 0x2

#define _PORTA_RA2_SIZE 0x1

#define _PORTA_RA2_LENGTH 0x1

#define _PORTA_RA2_MASK 0x4

#define _PORTA_RA3_POSN 0x3

#define _PORTA_RA3_POSITION 0x3

#define _PORTA_RA3_SIZE 0x1

#define _PORTA_RA3_LENGTH 0x1

#define _PORTA_RA3_MASK 0x8

#define _PORTA_RA4_POSN 0x4

#define _PORTA_RA4_POSITION 0x4

#define _PORTA_RA4_SIZE 0x1

#define _PORTA_RA4_LENGTH 0x1

#define _PORTA_RA4_MASK 0x10

// Register: PORTB

extern volatile unsigned char PORTB @ 0x006;

#ifndef _LIB_BUILD

asm("PORTB equ 06h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned RB0 :1;

unsigned RB1 :1;

unsigned RB2 :1;

unsigned RB3 :1;

unsigned RB4 :1;

unsigned RB5 :1;

unsigned RB6 :1;

unsigned RB7 :1;

};

} PORTBbits_t;

extern volatile PORTBbits_t PORTBbits @ 0x006;

// bitfield macros

#define _PORTB_RB0_POSN 0x0

#define _PORTB_RB0_POSITION 0x0

#define _PORTB_RB0_SIZE 0x1

#define _PORTB_RB0_LENGTH 0x1

#define _PORTB_RB0_MASK 0x1

#define _PORTB_RB1_POSN 0x1

#define _PORTB_RB1_POSITION 0x1

#define _PORTB_RB1_SIZE 0x1

#define _PORTB_RB1_LENGTH 0x1

#define _PORTB_RB1_MASK 0x2

#define _PORTB_RB2_POSN 0x2

#define _PORTB_RB2_POSITION 0x2

#define _PORTB_RB2_SIZE 0x1

#define _PORTB_RB2_LENGTH 0x1

#define _PORTB_RB2_MASK 0x4

#define _PORTB_RB3_POSN 0x3

#define _PORTB_RB3_POSITION 0x3

#define _PORTB_RB3_SIZE 0x1

#define _PORTB_RB3_LENGTH 0x1

#define _PORTB_RB3_MASK 0x8

#define _PORTB_RB4_POSN 0x4

#define _PORTB_RB4_POSITION 0x4

#define _PORTB_RB4_SIZE 0x1

#define _PORTB_RB4_LENGTH 0x1

#define _PORTB_RB4_MASK 0x10

#define _PORTB_RB5_POSN 0x5

#define _PORTB_RB5_POSITION 0x5

#define _PORTB_RB5_SIZE 0x1

#define _PORTB_RB5_LENGTH 0x1

#define _PORTB_RB5_MASK 0x20

#define _PORTB_RB6_POSN 0x6

#define _PORTB_RB6_POSITION 0x6

#define _PORTB_RB6_SIZE 0x1

#define _PORTB_RB6_LENGTH 0x1

#define _PORTB_RB6_MASK 0x40

#define _PORTB_RB7_POSN 0x7

#define _PORTB_RB7_POSITION 0x7

#define _PORTB_RB7_SIZE 0x1

#define _PORTB_RB7_LENGTH 0x1

#define _PORTB_RB7_MASK 0x80

// Register: EEDATA

extern volatile unsigned char EEDATA @ 0x008;

#ifndef _LIB_BUILD

asm("EEDATA equ 08h");

#endif

// Register: EEADR

extern volatile unsigned char EEADR @ 0x009;

#ifndef _LIB_BUILD

asm("EEADR equ 09h");

#endif

// Register: PCLATH

extern volatile unsigned char PCLATH @ 0x00A;

#ifndef _LIB_BUILD

asm("PCLATH equ 0Ah");

#endif

// bitfield definitions

typedef union {

struct {

unsigned PCLATH :5;

};

} PCLATHbits_t;

extern volatile PCLATHbits_t PCLATHbits @ 0x00A;

// bitfield macros

#define _PCLATH_PCLATH_POSN 0x0

#define _PCLATH_PCLATH_POSITION 0x0

#define _PCLATH_PCLATH_SIZE 0x5

#define _PCLATH_PCLATH_LENGTH 0x5

#define _PCLATH_PCLATH_MASK 0x1F

// Register: INTCON

extern volatile unsigned char INTCON @ 0x00B;

#ifndef _LIB_BUILD

asm("INTCON equ 0Bh");

#endif

// bitfield definitions

typedef union {

struct {

unsigned RBIF :1;

unsigned INTF :1;

unsigned T0IF :1;

unsigned RBIE :1;

unsigned INTE :1;

unsigned T0IE :1;

unsigned EEIE :1;

unsigned GIE :1;

};

struct {

unsigned :2;

unsigned TMR0IF :1;

unsigned :2;

unsigned TMR0IE :1;

};

} INTCONbits_t;

extern volatile INTCONbits_t INTCONbits @ 0x00B;

// bitfield macros

#define _INTCON_RBIF_POSN 0x0

#define _INTCON_RBIF_POSITION 0x0

#define _INTCON_RBIF_SIZE 0x1

#define _INTCON_RBIF_LENGTH 0x1

#define _INTCON_RBIF_MASK 0x1

#define _INTCON_INTF_POSN 0x1

#define _INTCON_INTF_POSITION 0x1

#define _INTCON_INTF_SIZE 0x1

#define _INTCON_INTF_LENGTH 0x1

#define _INTCON_INTF_MASK 0x2

#define _INTCON_T0IF_POSN 0x2

#define _INTCON_T0IF_POSITION 0x2

#define _INTCON_T0IF_SIZE 0x1

#define _INTCON_T0IF_LENGTH 0x1

#define _INTCON_T0IF_MASK 0x4

#define _INTCON_RBIE_POSN 0x3

#define _INTCON_RBIE_POSITION 0x3

#define _INTCON_RBIE_SIZE 0x1

#define _INTCON_RBIE_LENGTH 0x1

#define _INTCON_RBIE_MASK 0x8

#define _INTCON_INTE_POSN 0x4

#define _INTCON_INTE_POSITION 0x4

#define _INTCON_INTE_SIZE 0x1

#define _INTCON_INTE_LENGTH 0x1

#define _INTCON_INTE_MASK 0x10

#define _INTCON_T0IE_POSN 0x5

#define _INTCON_T0IE_POSITION 0x5

#define _INTCON_T0IE_SIZE 0x1

#define _INTCON_T0IE_LENGTH 0x1

#define _INTCON_T0IE_MASK 0x20

#define _INTCON_EEIE_POSN 0x6

#define _INTCON_EEIE_POSITION 0x6

#define _INTCON_EEIE_SIZE 0x1

#define _INTCON_EEIE_LENGTH 0x1

#define _INTCON_EEIE_MASK 0x40

#define _INTCON_GIE_POSN 0x7

#define _INTCON_GIE_POSITION 0x7

#define _INTCON_GIE_SIZE 0x1

#define _INTCON_GIE_LENGTH 0x1

#define _INTCON_GIE_MASK 0x80

#define _INTCON_TMR0IF_POSN 0x2

#define _INTCON_TMR0IF_POSITION 0x2

#define _INTCON_TMR0IF_SIZE 0x1

#define _INTCON_TMR0IF_LENGTH 0x1

#define _INTCON_TMR0IF_MASK 0x4

#define _INTCON_TMR0IE_POSN 0x5

#define _INTCON_TMR0IE_POSITION 0x5

#define _INTCON_TMR0IE_SIZE 0x1

#define _INTCON_TMR0IE_LENGTH 0x1

#define _INTCON_TMR0IE_MASK 0x20

// Register: OPTION_REG

extern volatile unsigned char OPTION_REG @ 0x081;

#ifndef _LIB_BUILD

asm("OPTION_REG equ 081h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned PS :3;

unsigned PSA :1;

unsigned T0SE :1;

unsigned T0CS :1;

unsigned INTEDG :1;

unsigned nRBPU :1;

};

struct {

unsigned PS0 :1;

unsigned PS1 :1;

unsigned PS2 :1;

};

} OPTION_REGbits_t;

extern volatile OPTION_REGbits_t OPTION_REGbits @ 0x081;

// bitfield macros

#define _OPTION_REG_PS_POSN 0x0

#define _OPTION_REG_PS_POSITION 0x0

#define _OPTION_REG_PS_SIZE 0x3

#define _OPTION_REG_PS_LENGTH 0x3

#define _OPTION_REG_PS_MASK 0x7

#define _OPTION_REG_PSA_POSN 0x3

#define _OPTION_REG_PSA_POSITION 0x3

#define _OPTION_REG_PSA_SIZE 0x1

#define _OPTION_REG_PSA_LENGTH 0x1

#define _OPTION_REG_PSA_MASK 0x8

#define _OPTION_REG_T0SE_POSN 0x4

#define _OPTION_REG_T0SE_POSITION 0x4

#define _OPTION_REG_T0SE_SIZE 0x1

#define _OPTION_REG_T0SE_LENGTH 0x1

#define _OPTION_REG_T0SE_MASK 0x10

#define _OPTION_REG_T0CS_POSN 0x5

#define _OPTION_REG_T0CS_POSITION 0x5

#define _OPTION_REG_T0CS_SIZE 0x1

#define _OPTION_REG_T0CS_LENGTH 0x1

#define _OPTION_REG_T0CS_MASK 0x20

#define _OPTION_REG_INTEDG_POSN 0x6

#define _OPTION_REG_INTEDG_POSITION 0x6

#define _OPTION_REG_INTEDG_SIZE 0x1

#define _OPTION_REG_INTEDG_LENGTH 0x1

#define _OPTION_REG_INTEDG_MASK 0x40

#define _OPTION_REG_nRBPU_POSN 0x7

#define _OPTION_REG_nRBPU_POSITION 0x7

#define _OPTION_REG_nRBPU_SIZE 0x1

#define _OPTION_REG_nRBPU_LENGTH 0x1

#define _OPTION_REG_nRBPU_MASK 0x80

#define _OPTION_REG_PS0_POSN 0x0

#define _OPTION_REG_PS0_POSITION 0x0

#define _OPTION_REG_PS0_SIZE 0x1

#define _OPTION_REG_PS0_LENGTH 0x1

#define _OPTION_REG_PS0_MASK 0x1

#define _OPTION_REG_PS1_POSN 0x1

#define _OPTION_REG_PS1_POSITION 0x1

#define _OPTION_REG_PS1_SIZE 0x1

#define _OPTION_REG_PS1_LENGTH 0x1

#define _OPTION_REG_PS1_MASK 0x2

#define _OPTION_REG_PS2_POSN 0x2

#define _OPTION_REG_PS2_POSITION 0x2

#define _OPTION_REG_PS2_SIZE 0x1

#define _OPTION_REG_PS2_LENGTH 0x1

#define _OPTION_REG_PS2_MASK 0x4

// Register: TRISA

extern volatile unsigned char TRISA @ 0x085;

#ifndef _LIB_BUILD

asm("TRISA equ 085h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned TRISA0 :1;

unsigned TRISA1 :1;

unsigned TRISA2 :1;

unsigned TRISA3 :1;

unsigned TRISA4 :1;

};

} TRISAbits_t;

extern volatile TRISAbits_t TRISAbits @ 0x085;

// bitfield macros

#define _TRISA_TRISA0_POSN 0x0

#define _TRISA_TRISA0_POSITION 0x0

#define _TRISA_TRISA0_SIZE 0x1

#define _TRISA_TRISA0_LENGTH 0x1

#define _TRISA_TRISA0_MASK 0x1

#define _TRISA_TRISA1_POSN 0x1

#define _TRISA_TRISA1_POSITION 0x1

#define _TRISA_TRISA1_SIZE 0x1

#define _TRISA_TRISA1_LENGTH 0x1

#define _TRISA_TRISA1_MASK 0x2

#define _TRISA_TRISA2_POSN 0x2

#define _TRISA_TRISA2_POSITION 0x2

#define _TRISA_TRISA2_SIZE 0x1

#define _TRISA_TRISA2_LENGTH 0x1

#define _TRISA_TRISA2_MASK 0x4

#define _TRISA_TRISA3_POSN 0x3

#define _TRISA_TRISA3_POSITION 0x3

#define _TRISA_TRISA3_SIZE 0x1

#define _TRISA_TRISA3_LENGTH 0x1

#define _TRISA_TRISA3_MASK 0x8

#define _TRISA_TRISA4_POSN 0x4

#define _TRISA_TRISA4_POSITION 0x4

#define _TRISA_TRISA4_SIZE 0x1

#define _TRISA_TRISA4_LENGTH 0x1

#define _TRISA_TRISA4_MASK 0x10

// Register: TRISB

extern volatile unsigned char TRISB @ 0x086;

#ifndef _LIB_BUILD

asm("TRISB equ 086h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned TRISB0 :1;

unsigned TRISB1 :1;

unsigned TRISB2 :1;

unsigned TRISB3 :1;

unsigned TRISB4 :1;

unsigned TRISB5 :1;

unsigned TRISB6 :1;

unsigned TRISB7 :1;

};

} TRISBbits_t;

extern volatile TRISBbits_t TRISBbits @ 0x086;

// bitfield macros

#define _TRISB_TRISB0_POSN 0x0

#define _TRISB_TRISB0_POSITION 0x0

#define _TRISB_TRISB0_SIZE 0x1

#define _TRISB_TRISB0_LENGTH 0x1

#define _TRISB_TRISB0_MASK 0x1

#define _TRISB_TRISB1_POSN 0x1

#define _TRISB_TRISB1_POSITION 0x1

#define _TRISB_TRISB1_SIZE 0x1

#define _TRISB_TRISB1_LENGTH 0x1

#define _TRISB_TRISB1_MASK 0x2

#define _TRISB_TRISB2_POSN 0x2

#define _TRISB_TRISB2_POSITION 0x2

#define _TRISB_TRISB2_SIZE 0x1

#define _TRISB_TRISB2_LENGTH 0x1

#define _TRISB_TRISB2_MASK 0x4

#define _TRISB_TRISB3_POSN 0x3

#define _TRISB_TRISB3_POSITION 0x3

#define _TRISB_TRISB3_SIZE 0x1

#define _TRISB_TRISB3_LENGTH 0x1

#define _TRISB_TRISB3_MASK 0x8

#define _TRISB_TRISB4_POSN 0x4

#define _TRISB_TRISB4_POSITION 0x4

#define _TRISB_TRISB4_SIZE 0x1

#define _TRISB_TRISB4_LENGTH 0x1

#define _TRISB_TRISB4_MASK 0x10

#define _TRISB_TRISB5_POSN 0x5

#define _TRISB_TRISB5_POSITION 0x5

#define _TRISB_TRISB5_SIZE 0x1

#define _TRISB_TRISB5_LENGTH 0x1

#define _TRISB_TRISB5_MASK 0x20

#define _TRISB_TRISB6_POSN 0x6

#define _TRISB_TRISB6_POSITION 0x6

#define _TRISB_TRISB6_SIZE 0x1

#define _TRISB_TRISB6_LENGTH 0x1

#define _TRISB_TRISB6_MASK 0x40

#define _TRISB_TRISB7_POSN 0x7

#define _TRISB_TRISB7_POSITION 0x7

#define _TRISB_TRISB7_SIZE 0x1

#define _TRISB_TRISB7_LENGTH 0x1

#define _TRISB_TRISB7_MASK 0x80

// Register: EECON1

extern volatile unsigned char EECON1 @ 0x088;

#ifndef _LIB_BUILD

asm("EECON1 equ 088h");

#endif

// bitfield definitions

typedef union {

struct {

unsigned RD :1;

unsigned WR :1;

unsigned WREN :1;

unsigned WRERR :1;

unsigned EEIF :1;

};

} EECON1bits_t;

extern volatile EECON1bits_t EECON1bits @ 0x088;

// bitfield macros

#define _EECON1_RD_POSN 0x0

#define _EECON1_RD_POSITION 0x0

#define _EECON1_RD_SIZE 0x1

#define _EECON1_RD_LENGTH 0x1

#define _EECON1_RD_MASK 0x1

#define _EECON1_WR_POSN 0x1

#define _EECON1_WR_POSITION 0x1

#define _EECON1_WR_SIZE 0x1

#define _EECON1_WR_LENGTH 0x1

#define _EECON1_WR_MASK 0x2

#define _EECON1_WREN_POSN 0x2

#define _EECON1_WREN_POSITION 0x2

#define _EECON1_WREN_SIZE 0x1

#define _EECON1_WREN_LENGTH 0x1

#define _EECON1_WREN_MASK 0x4

#define _EECON1_WRERR_POSN 0x3

#define _EECON1_WRERR_POSITION 0x3

#define _EECON1_WRERR_SIZE 0x1

#define _EECON1_WRERR_LENGTH 0x1

#define _EECON1_WRERR_MASK 0x8

#define _EECON1_EEIF_POSN 0x4

#define _EECON1_EEIF_POSITION 0x4

#define _EECON1_EEIF_SIZE 0x1

#define _EECON1_EEIF_LENGTH 0x1

#define _EECON1_EEIF_MASK 0x10

// Register: EECON2

extern volatile unsigned char EECON2 @ 0x089;

#ifndef _LIB_BUILD

asm("EECON2 equ 089h");

#endif

* Bit Definitions

* */

#define _DEPRECATED __attribute__((__deprecated__))

#ifndef BANKMASK

#define BANKMASK(addr) ((addr)&07Fh)

#endif

extern volatile __bit CARRY @ (((unsigned) &STATUS)*8) + 0;

#define CARRY_bit BANKMASK(STATUS), 0

extern volatile __bit DC @ (((unsigned) &STATUS)*8) + 1;

#define DC_bit BANKMASK(STATUS), 1

extern volatile __bit EEIE @ (((unsigned) &INTCON)*8) + 6;

#define EEIE_bit BANKMASK(INTCON), 6

extern volatile __bit EEIF @ (((unsigned) &EECON1)*8) + 4;

#define EEIF_bit BANKMASK(EECON1), 4

extern volatile __bit GIE @ (((unsigned) &INTCON)*8) + 7;

#define GIE_bit BANKMASK(INTCON), 7

extern volatile __bit INTE @ (((unsigned) &INTCON)*8) + 4;

#define INTE_bit BANKMASK(INTCON), 4

extern volatile __bit INTEDG @ (((unsigned) &OPTION_REG)*8) + 6;

#define INTEDG_bit BANKMASK(OPTION_REG), 6

extern volatile __bit INTF @ (((unsigned) &INTCON)*8) + 1;

#define INTF_bit BANKMASK(INTCON), 1

extern volatile __bit IRP @ (((unsigned) &STATUS)*8) + 7;

#define IRP_bit BANKMASK(STATUS), 7

extern volatile __bit PS0 @ (((unsigned) &OPTION_REG)*8) + 0;

#define PS0_bit BANKMASK(OPTION_REG), 0

extern volatile __bit PS1 @ (((unsigned) &OPTION_REG)*8) + 1;

#define PS1_bit BANKMASK(OPTION_REG), 1

extern volatile __bit PS2 @ (((unsigned) &OPTION_REG)*8) + 2;

#define PS2_bit BANKMASK(OPTION_REG), 2

extern volatile __bit PSA @ (((unsigned) &OPTION_REG)*8) + 3;

#define PSA_bit BANKMASK(OPTION_REG), 3

extern volatile __bit RA0 @ (((unsigned) &PORTA)*8) + 0;

#define RA0_bit BANKMASK(PORTA), 0

extern volatile __bit RA1 @ (((unsigned) &PORTA)*8) + 1;

#define RA1_bit BANKMASK(PORTA), 1

extern volatile __bit RA2 @ (((unsigned) &PORTA)*8) + 2;

#define RA2_bit BANKMASK(PORTA), 2

extern volatile __bit RA3 @ (((unsigned) &PORTA)*8) + 3;

#define RA3_bit BANKMASK(PORTA), 3

extern volatile __bit RA4 @ (((unsigned) &PORTA)*8) + 4;

#define RA4_bit BANKMASK(PORTA), 4

extern volatile __bit RB0 @ (((unsigned) &PORTB)*8) + 0;

#define RB0_bit BANKMASK(PORTB), 0

extern volatile __bit RB1 @ (((unsigned) &PORTB)*8) + 1;

#define RB1_bit BANKMASK(PORTB), 1

extern volatile __bit RB2 @ (((unsigned) &PORTB)*8) + 2;

#define RB2_bit BANKMASK(PORTB), 2

extern volatile __bit RB3 @ (((unsigned) &PORTB)*8) + 3;

#define RB3_bit BANKMASK(PORTB), 3

extern volatile __bit RB4 @ (((unsigned) &PORTB)*8) + 4;

#define RB4_bit BANKMASK(PORTB), 4

extern volatile __bit RB5 @ (((unsigned) &PORTB)*8) + 5;

#define RB5_bit BANKMASK(PORTB), 5

extern volatile __bit RB6 @ (((unsigned) &PORTB)*8) + 6;

#define RB6_bit BANKMASK(PORTB), 6

extern volatile __bit RB7 @ (((unsigned) &PORTB)*8) + 7;

#define RB7_bit BANKMASK(PORTB), 7

extern volatile __bit RBIE @ (((unsigned) &INTCON)*8) + 3;

#define RBIE_bit BANKMASK(INTCON), 3

extern volatile __bit RBIF @ (((unsigned) &INTCON)*8) + 0;

#define RBIF_bit BANKMASK(INTCON), 0

extern volatile __bit RD @ (((unsigned) &EECON1)*8) + 0;

#define RD_bit BANKMASK(EECON1), 0

extern volatile __bit RP0 @ (((unsigned) &STATUS)*8) + 5;

#define RP0_bit BANKMASK(STATUS), 5

extern volatile __bit RP1 @ (((unsigned) &STATUS)*8) + 6;

#define RP1_bit BANKMASK(STATUS), 6

extern volatile __bit T0CS @ (((unsigned) &OPTION_REG)*8) + 5;

#define T0CS_bit BANKMASK(OPTION_REG), 5

extern volatile __bit T0IE @ (((unsigned) &INTCON)*8) + 5;

#define T0IE_bit BANKMASK(INTCON), 5

extern volatile __bit T0IF @ (((unsigned) &INTCON)*8) + 2;

#define T0IF_bit BANKMASK(INTCON), 2

extern volatile __bit T0SE @ (((unsigned) &OPTION_REG)*8) + 4;

#define T0SE_bit BANKMASK(OPTION_REG), 4

extern volatile __bit TMR0IE @ (((unsigned) &INTCON)*8) + 5;

#define TMR0IE_bit BANKMASK(INTCON), 5

extern volatile __bit TMR0IF @ (((unsigned) &INTCON)*8) + 2;

#define TMR0IF_bit BANKMASK(INTCON), 2

extern volatile __bit TRISA0 @ (((unsigned) &TRISA)*8) + 0;

#define TRISA0_bit BANKMASK(TRISA), 0

extern volatile __bit TRISA1 @ (((unsigned) &TRISA)*8) + 1;

#define TRISA1_bit BANKMASK(TRISA), 1

extern volatile __bit TRISA2 @ (((unsigned) &TRISA)*8) + 2;

#define TRISA2_bit BANKMASK(TRISA), 2

extern volatile __bit TRISA3 @ (((unsigned) &TRISA)*8) + 3;

#define TRISA3_bit BANKMASK(TRISA), 3

extern volatile __bit TRISA4 @ (((unsigned) &TRISA)*8) + 4;

#define TRISA4_bit BANKMASK(TRISA), 4

extern volatile __bit TRISB0 @ (((unsigned) &TRISB)*8) + 0;

#define TRISB0_bit BANKMASK(TRISB), 0

extern volatile __bit TRISB1 @ (((unsigned) &TRISB)*8) + 1;

#define TRISB1_bit BANKMASK(TRISB), 1

extern volatile __bit TRISB2 @ (((unsigned) &TRISB)*8) + 2;

#define TRISB2_bit BANKMASK(TRISB), 2

extern volatile __bit TRISB3 @ (((unsigned) &TRISB)*8) + 3;

#define TRISB3_bit BANKMASK(TRISB), 3

extern volatile __bit TRISB4 @ (((unsigned) &TRISB)*8) + 4;

#define TRISB4_bit BANKMASK(TRISB), 4

extern volatile __bit TRISB5 @ (((unsigned) &TRISB)*8) + 5;

#define TRISB5_bit BANKMASK(TRISB), 5

extern volatile __bit TRISB6 @ (((unsigned) &TRISB)*8) + 6;

#define TRISB6_bit BANKMASK(TRISB), 6

extern volatile __bit TRISB7 @ (((unsigned) &TRISB)*8) + 7;

#define TRISB7_bit BANKMASK(TRISB), 7

extern volatile __bit WR @ (((unsigned) &EECON1)*8) + 1;

#define WR_bit BANKMASK(EECON1), 1

extern volatile __bit WREN @ (((unsigned) &EECON1)*8) + 2;

#define WREN_bit BANKMASK(EECON1), 2

extern volatile __bit WRERR @ (((unsigned) &EECON1)*8) + 3;

#define WRERR_bit BANKMASK(EECON1), 3

extern volatile __bit ZERO @ (((unsigned) &STATUS)*8) + 2;

#define ZERO_bit BANKMASK(STATUS), 2

extern volatile __bit nPD @ (((unsigned) &STATUS)*8) + 3;

#define nPD_bit BANKMASK(STATUS), 3

extern volatile __bit nRBPU @ (((unsigned) &OPTION_REG)*8) + 7;

#define nRBPU_bit BANKMASK(OPTION_REG), 7

extern volatile __bit nTO @ (((unsigned) &STATUS)*8) + 4;

#define nTO_bit BANKMASK(STATUS), 4

#endif // _PIC16F84A_H_

Burada, tüm register tanımlarının nasıl yapıldığına dikkat ediniz 🙂 Bizim Gömülü C yazı dizisini tamamen okuyan herkes için burada ne yapıldığını anlamak kolay olacaktır. Yine de anlamadığınız yerler olursa sorunuz 🙂 Şimdi merhaba dünya kodumuzdaki register’ları özellikle inceleyelim.

...
// Register: PORTB
extern volatile unsigned char           PORTB               @ 0x006;
#ifndef _LIB_BUILD
asm("PORTB equ 06h");
#endif

...
// Register: TRISB
extern volatile unsigned char           TRISB               @ 0x086;
#ifndef _LIB_BUILD
asm("TRISB equ 086h");
#endif

...

// Register: PORTB

extern volatile unsigned char PORTB @ 0x006;

#ifndef _LIB_BUILD

asm("PORTB equ 06h");

#endif

...

// Register: TRISB

extern volatile unsigned char TRISB @ 0x086;

#ifndef _LIB_BUILD

asm("TRISB equ 086h");

#endif

Burada demişler ki PORTB diye bir değişken yaratıyoruz ve bu bellekteki 0x006 numaralı adrese karşılık düşüyor. Yine benzer şekilde TRISB diye bir değişken yaratıyoruz ve bu bellekteki 0x086 numaralı adrese karşılık düşüyor. Bu bilgileri datasheet’teki bellek haritasından aynen doğrulamak mümkün. Zaten oradan bakıp yazmışlar 🙂 Ama ayıbetmişler… Çünkü tüm register’lar için kafadan değişken tanımlanmış. Bu, ödemesi ağır bir bedel. Ayrıca @ operatörü standart bir operatör değil. Dolayısıyla bu tanımlar, platform bağımlılığı yaratmakta ve kodların taşınabilirliğini negatif etkilemekte. Bunlara bir ayar çekmemiz kaçınılmaz duruyor 🙂

Şimdi, bu noktaya geldikten sonra, geleneğimizi uygulayalım ve yine header kullanmaksızın merhaba dünya kodumuzu yeniden yazalım 🙂

#define myTRISB (*( volatile unsigned char*)0x086)
#define myPORTB (*( volatile unsigned char*)0x006)

void main() {
    myTRISB = 0;
    myPORTB = 1;
    while(1);
}

#define myTRISB (*( volatile unsigned char*)0x086)

#define myPORTB (*( volatile unsigned char*)0x006)

void main() {

myTRISB = 0;

myPORTB = 1;

while(1);

}

Gördüğünüz üzere, kodda ne bir kütüphane kullandık, ne de bir değişken! Zaten kodumuzda, merhaba dünya kodundaki gereksiz şeylerin hiç birisi yok. Register tanımlarını da çok çok daha verimli şekilde yaptığımızı gururla huzurlarınıza sunarım 🙂 0 byte değişken kullanarak, yine ledimizi yaktık!

Buradan gerekli ibretleri lütfen alalım 🙂 Sanıyorum ki, “Abi PIC programlama yaparken Hi-Tech compiler CSS’den iyiymiş yaa” filan gibi geyiklere artık bolca gülersiniz. Hiçbirine ihtiyacımız yok, sadece tekerleği yeniden icad etmemek için onları araç olarak kullanıyoruz 😉

Sonraki yazımda bu temellerin üzerine, giriş çıkış işlemleriyle ilgili detaylı bir yapı inşa etmeyi planlıyorum. Dilerim sizler için de faydalı ve eğlenceli bir yazı olmuştur.

Şimdi devam…

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 2: Merhaba PIC16

8 March 2015 by ozenozkaya

Selamlar 🙂 Bu gün nihayetinde Merhaba PIC16 yazımı ekleme niyetindeyim. Esasen yazdığım sayfalarca yazıyı browser’ın azizliğinden dolayı kaybettim. Ancak yılmak yok 🙂 Tekrardan yazmaya devam. Sizlerle 07.03.2015 tarihinde paylaşmayı planladığım bu yazımı ne yazık ki ancak paylaşabiliyorum. Bu gecikme için affınıza sığınıyorum ve yılmadan yazmaya devam diyorum.

Bu yazı dizisinde, sevgili dostum Birol Çapa ile üniversite yıllarında birlikte oluşturduğumuz kaynaklardan da faydalanacağım. Bu vesileyle sevgili dostum Birol‘a da teşekkürlerimi iletiyorum.

Efendim bu yazı dizisinin temel amacı, devasa bir okyanus olan gömülü sistemlere, okyanusun ortasından dalmak yerine güzel bir sahilden dalmak. Yani ne demek istiyorum? Derya deniz diye özetleyebileceğimiz bu konuda, uygulama yapabileceğimiz güzel bir başlangıç noktasından balıklama konuya dalmak. Yine çok sayıda ibretlik noktaya değineceğimizi düşünüyorum. Yazılar da yine her zamanki uslüpla olacağından, sizleri de sıkmadan eğlenceli bir yazı dizisi geçireceğimize inanıyorum.

Neden PIC16 sorusunun cevabını esasen bir önceki yazımızda bir miktar vermiştik. Şimdi başka soruların peşinde koşalım!

Neden Mikrokontrolörler?

Efendim gömülü sistemler derya deniz demiştik. Gömülü sistemlerin en yaygın kullanım alanlı alt dalı, mikrokontrolör tabanlı sistemlerdir. Bu dal öyle bir daldır ki, çoğu ağaçtan çok daha okkalıdır. Burada edineceğimiz bilgileri, joker gibi diğer tüm gömülü sistem uygulamalarında uygulayabileceğimizden dolayı, mikrokontrolörleri iyi bilmek, iyi kullanmak çok çok önemlidir. Buna istinaden bu yazı dizisi vesilesiyle hızlıca mevzuya dalmanın faydalı olacağını düşünüyorum.

PIC de, gömülü sistemlerin temel mantığını çok çok güzel şekilde anlayabileceğimiz bir başlangıç noktası. Beğenirsiniz beğenmezsiniz, Arduino var olana kadar en önemli hobi elektroniği argümanlarından birisi PIC idi. Halen daha kullanımı çok yaygın. Ve dostlar bence buradan da öğrenebileceğimiz çok önemli noktalar olabilir. O sebeple hakir görmeyelim 🙂

Neden C?

C dili ile ilgili tonlarca şeyi, Gömülü C yazı dizisinde konuşmuştuk. Mikrokontrolör programlama işlerinde, C/C++’ın yanı sıra, Assembler, basic ve hatta yer yer java dilleri bile kullanılır. C dili bunların hepsinin ağzını burnunu kırar diyeceğimi lütfen düşünmeyiniz bile. C dilini bir kenara atıp diğer dillere çamur atmaya da niyetli değilim.

Yazılımda programlama dilleri amaç değil araçtır. Programcı bir nevi ninja ise, programlama dili de ninjanın silahıdır. Bazen kocaman bir kılıç karşısında, minik bir hançer ya da mınçıka galip gelebilir. Zira kılıç ile bir hareket yapıncaya kadar, bu ufaklıkları 8. hamlesini tamamlayabilir 🙂 Keza savaş uzaktan yapılıyorsa, belki ok ve yay kullanmak daha yeğdir. Neyse, Age of Empires ya da Hitman oynamıyoruz. Ağzımdaki baklayı çıkarayım; bu dillerin her birinin muhakkak ki birtakım avantajları ve dezavantajları bulunmaktadır. Bu diller içerisinden C dilini seçmemizin nedeni, bu dilin en yaygın kullanılan programlama dili olması, gömülü sistemlerin her alanında gücünden pek de bir şey kaybetmeden kullanılabilmesi gibi çok güzel sebepler yatar. Ancak göreceksiniz ki yeri gelecek birden fazla dili beraber de kullanacağız. Benim Assembly kardeşimi hakir görmek, şüphesiz ki davaya ihanet olacaktır 😛

Temel Kaynaklar

Bir mikrokontrolör programlama mevzusu varsa en birinci kaynak, şüphesiz ki o mikrokontrolörün datasheet’i (veri kağıdı) olacaktır. Gömülü sistemlerde bir şeyler yapmayı öğrenmenin büyük bir kısmı veri kağıdı okuyup anlayabilmekten geçer. Bizim PIC16’nın da çeşitlerinin güzel güzel veri kağıtları mevcut. Aslında daha gelişmiş mikrokontrolörlerin datasheet’inde genellikle donanımsal özelliklere yer veriliyor. Bu tip donanımları kullanabilmek için “user guide” olarak da bilinen kullanım kılavuzlarını okumak gerekiyor. Neyseki PIC16F serisi, görece basit bir seri olduğundan veri kağıdı ile paçayı sıyırıyor olacağız. Hemen çok kullanacağımız bazı PIC’lerin veri kağıtlarını paylaşalım.

Efendim, gömülü sistemci olacaksak ne yapıp edip bu dokümanları okuyabilir hale gelmemiz gerekiyor. İngilizce bilmeyen arkadaşlarım da lütfen bu sorunun üstesinden gelmek için Google Translate gibi araçları kullansınlar. Zira bir yerden sonra hep aynı terimler geçtiği için dökümanları anlamak çok çok kolay oluyor.

Veri kağıtlarına ek olarak önemli bir kaynak da, geliştirme ortamının ya da derleyicinin dökümanasyonu oluyor. Ben derleyici dedim ama aslında demek istediğim toolchain. Yani içinde derleyici, bağlayıcı (linker dayı), assembler, türlü türlü kütüphaneler filan bulunan yazılım paketi. Bunun dökümantasyonunu da incelemekte faideler mevcut. Bizimkine, sırası gelince değineceğim.

Kullanılacak Programlar (Kurulumlar)

Yolculuğu kafamızda şöyle kısaca bir çizelim ki, ihtiyacı listeleyebilelim. Bizim öncelikle kodumuzu yazabileceğimiz bir ortama ihtiyacımız var. Bunun adı geliştirme ortamı (IDE). Ardından kodlarımızı anlayacak, derleyecek, link edecek bir yazılım setine ihtiyacımız var. Sonra diyelim ki yazılımımızı yazdık ve executable dosyamızı elde ettik. Bunu PIC’e yazacak bir programlayıcıya, ve programlayabileceğimiz bir donanıma ihtiyacımız var. Veya, programlayıcı + programlanacak donanım yerine simülatör kullanabiliriz 🙂 Özellikle hızlı uygulama ve öğrenme açısından simülatör kullanmak çok mantıklı olabiliyor. Ancak gerçekleme yapmak da şart. Biz tüm bu aşamalara değineceğiz ancak önce kurulumlarımızı tamamlayalım.

MPLAB X IDE: PIC için diye gayet hoş bir IDE mevcut. Ardından bir toolchain’e ihtiyacımız var. Bazı IDE’lerin içinde toolchain hazır olarak geliyor ancak MPLAB söz konusu olunca bu kadar şanslı değiliz. Gerçi MPLAB X, tüm seriler için genelgeçer bir IDE olduğundan, toolchain’in sonradan kurulması da mantıklı 🙂 Ben MPLAB X versiyonu olarak 3.0 beta kurdum. Normal şartlar altında, bir gömülü sistemci asla ama asla beta yazılım kullanmaz. Sağlamclığıa çok aykırıdır. Ancak bu, bilgi paylaşımı amaçlı bir yazılım olduğundan, siz bu yazıyı okuyuncaya kadar 3.0 stabil versiyon da çıkar diyerekten 3.0 beta kurdum. Siz de ücretsiz olarak kurulumu yapabilirsiniz.
MPLAB XC8. Neyse bir sonraki aşama olarak 8 bit’lik PIC’ler için olan XC8 toolchain’i kuruyoruz. Efendim eğer 16 bit’lik bir PIC için yazılım geliştirecek olsaydık XC16, 32 bit’lik bir PIC için yazılım geliştirecek olsaydık XC32 kuracaktık ancak suyu bulandırmayalım ve MPLAB X’in üzerine XC8 kuralım. Son versiyon olan, MPLAB^® XC8 Compiler v1.34 kurulumunu tamamladım. Siz de en son versiyon hangisi ise, onu kurabilirsiniz. Evaluation sürümü ücretsiz! PRO versiyonu da 60 gün için yine ücretsiz 🙂 XC8’in çiçek gibi de bir dökümantasyonu var. Mutlaka feyizlenelim. Kurulumu yaparken, MPLAB X IDE’yi XC8’i kullanacak şekilde güncelleyin seçeneğini işaretlemeyi unutmayalım 🙂 Esasen ben eskiden toolchain olarak Hitech PIC C kullanırdım. Ama Microchip şurada, artık kullanmayın demiş. Zaten hiç bir şeyin fark etmeyeceğini, bunlara ihtiyacımız bile pek olmadığını anlatacağım. Ama şimdilik önerilen ile devam edip XC8’i kuralım.
Proteus ISE: Bu yazılım da güzel bir simülasyon ortamı. Aslında Proteus’a simülasyon ortamı demek biraz vicdansızlık olur. Zira Proteus ile, devre tasarımı, devre simülasyonu, şematik ve PCB tasarımı da yapılabiliyor. Kendisi çok çok başarılı bir yazılım. Ancak ne yazık ki ücretli. Yine de evaluation versiyonunu kullanabilirsiniz. Ya da internetten proteus kurulumu ile ilgili detaylı bilgileri bulabilirsiniz. Ben 8.10 SP1 versiyonunu kullanıyorum, çok da memnunum 😀 Proteus kurulumunu yaptıktan sonra, eğer proteus kullanmayı bilmiyorsanız google üzerinde proteus derslerine bakıp, proteus kullanımını kabaca öğrenmeniz gerekiyor.

Bunlara ek olarak, donanım bağımsız algoritmaları test etmek amacıyla bir C/C++ IDE’si kurmakta fayda var. Orwell Dev C++ gayet ufacık tefecik ama işe yarar bir araç.

Kurulumları tamamladıktan sonra, mevzuya dalalım 🙂 Öncelikle, proteus üzerinde programlayabileceğimiz bir PIC ortamı oluşturmamız gerekiyor. İlk örneğimizi PIC16F84A ile yapalım. Proteus’ta “P” tuşuna bastığımızda, place part yani devre elemanı ekleme ekranı açılıyor. Buraya PIC16F84A yazdığınızda, ilgili sembol çıkacak ve çift tıkladığınızda soldaki listeye eklenecektir. Ardından PIC mikrokontrolörü ve diğer gerekli devre elemanlarını eklemeniz mümkün olacak. Proteus derslerini incelediğiniz için burayı kısa kesiyorum ve kurmanız gereken basit devreyi aşağıda sizlerle paylaşıyorum.

Şimdi akıllara haklı bazı sorular gelebilir. En birincisi, bu devrenin beslemeleri nerede? PIC16F84A üzerine çift tıkladığımızda bir pencere açılır. O penecede sol kısımda “hidden pins” yani gizli pinler yazar. Burada VDD ve VCC pinlerinin gizli olduğunu ve otomatik olarak PIC’in beslendiğini görürüz. Şimdilik bu konu üzerinde çok durmayacağım ancak ileride bunu da açıklayacağım. Şimdilik merak edenler buraya bakabilirler. Proteus burada bizim işimizi kolaylaştırmış ancak gerçek hayatta beslemeyi bağlamazsanız hiç bir şey çalışmayacaktır. Buna ithafen VCC ve GND bacaklarının arasında 2.0V – 5.5V arası bir gerilim olması gerekiyor. Bu bilgiyi nereden öğrendim? Tabi ki datasheet’ten 🙂

Neyse şimdi devam edelim, işlemcinin beslemeleri otomatik yapıldı. PIC16F84A’nın dahili osilatörü olmadığından dışarıdan OSC1 ve OSC2 pinlerine bir XTAL (crystal) osilatör bağlamışız. Buradaki kapasitelerin değerine kadar datasheet’te yazıyor. 22pF da bağlasak olurdu 🙂 Esasen bu pinlerin arasında bir ring osilatör var, XTAL ve kapasitörler bu devreyi tamamlıyor ve osilasyon başlıyor. Burada şimdilik çok detaya girmeyeceğim. Osilatör bir anlamda kalp atışı gibi sinyaller üretir ve mikrodenetleyicinin, bu işarete (saat işareti, clock cycle) senkronize şekilde işlem yapmasını sağlar. Bu kısma parantez değil paragraflar açmak gerekiyor. Onu da ileride açacağım. Ancak şimdi neyse diyelim ve devam edelim.

MCLR diye bir pin var üzerinde de bir çizgi var. Bu pin Reset pini ve üzerindeki çizgi bize, bu pinin “active low” yani “düşük seviyede aktif” olacak şekilde çalıştığını anlatıyor. Bu durumun Türkçe’si şu ki, o pini lojik 0 seviyesine çekerseniz mikrokontrolör reset durumunda kalacaktır. Biz de ne yapmışız, butona basılmadığında o pin lojik 1’de kalacak şekilde yapmışız. Buton’a basıldığında ise mikrokontrolör reset’e çekilecek.

Bizim PIC16F84A yerine PIC16F877A kullanmak istesek bağlantılar nasıl olacaktı? Aşağıdaki gibi, yani aynı olacaktı.

Neyse biz hemen mevzumuza yani PIC16F84A’ya geri dönelim. Proteus’ta mikrokontrolöre hiç bir şey bağlamasak da mikrokontrolör çalışıyor 😀 Bu sebeple, hızlıca bir led bağlayıp, aşağıdaki devreyi kuralım.

Hemen ilk kodumuzu da yazalım 🙂 Bunun için MPLAB X’de bir PIC16F84A projesi oluşturmak ve aşağıdaki kodu eklemek gerekiyor.

#include <xc.h>

void main(void)
{
 TRISB=0;
 PORTB=1;
 while(1);
}

#include <xc.h>

void main(void)

{

TRISB=0;

PORTB=1;

while(1);

}

Bu kodu projemizde derlediğimizde, derleyici .hex uzantılı bir dosya oluşturacak. Şimdi proteus isis’te kurduğumuz devreye dönelim, ve PIC üzerine çıft tıklayıp “Program File” yazan kısma çift tıklayarak, üretilen .hex uzantılı dosyamızı seçelim. “OK” tuşuna basarak çıkalım ve “play” butonuna basarak simülasyonu başlatalım. Led, aşağıdaki gibi yanacak.

Değerli dostlarım, burada PIC dünyasına merhaba demiş olduk. Mutlaka ki buraya kadar olan kısımda konuşabileceğimiz çok şey var. Ancak tüm bunları diğer yazıya bırakıyorum 🙂 Zira bu yazıyı bu gün bitmeden yayınlamak niyetindeyim. Bir sonraki yazıda bu yaptıklarımızın suyunu çıkaracağız ve ibretler üzerinden gideceğiz 🙂

Buraya kadar okuduğunuz için teşekkürler. Yazıyı beğendiyseniz, faydalanabilecek tanıdıklarınız ile paylaşabilirseniz sevinirim.

Şimdi devam!

Önceki Sayfa Sonraki Sayfa

PIC Programlama – 1: Girizgah

2 March 2015 by ozenozkaya

Yol haritamız, karanlıkta kılavuzumuz demiştik. Donanım altyapısının tahsisinden sonra, kaya misali bir gömülü c altyapısı oluşturmuştuk. Bu sert altyapının ardından yol haritamızda sözünü ettiğimiz ilk yazı dizisi nihayetinde başlıyor. Hobi elektroniğinde yeri çok başka olan Microchip PIC mikrodenetleyicilerini nasıl kulumuz kölemiz yaparız, ne yapar ne eder de bu mikrokontrolörün suyunu sıkarız ona değinmeye çalışacağım.

Tüm bu planlar yol haritamızda belirttiğimiz stratejik bir yolun parçası tabi ki. Gömülü sistemlere adım atan çoğu kimse aynı kırıcı mevzudan şikayetçi; nereden başlayıp nereye gideceğini bilememekten… Sırf bu bağlamda bile yol haritamızın değerli olduğunu düşünüyorum. Konuları kompleks hale getirmeden anlatmanın yollarını bulamazsak eğer, kompleks sistemleri anlamamız mümkün olamayacak. 8-bitlik popüler bir mikrodenetleyici bu sebeple başlamak için iyi bir adım olacak 🙂 Bu sayede sonraki adımlarımızı da çok sağlam atma şansına sahip olacağız.

Kulağa çok kötü gelmiyor da bilader niye böyle bir şey yapıyoruz diyenler olmuştur. Amaç, gömülü sistemler dünyasına ayakları yere basan bir giriş yapmak. Bir eve girerken, duvardan geçmeye çalışmak her zaman iyi bir fikir olmayabilir, ancak bunun farkına varmamız için kapı, pencere gibi temel alternatifleri bilmemiz gerekir. Bu amaçla basit bir mikrodenetleyici üzerinde detaylı bir bilgi seti inşa edip sonraki basamaklara tırmanıyor olacağız. Bu süreç içerisinde yine her zamanki gibi türlü türlü ibretler ve komiklikler şakalar ile karşılaşacağız.

Bu kapsamda Microchip firmasının 3 farklı ürünü üzerinden gideceğiz. PIC16F84A, PIC16F628A ve PIC16F877A. Neden bu serileri seçiyoruz? Çünkü hobi elektroniği camiasında en çok kullanılan ürünler bunlar. Ayrıca vermek istediğim mesajları düşününce, bu serilerin işimizi gayet tertemiz göreceğini düşünüyorum. Bu sebepledir ki bu üç civciv ile başlayacağız yolculuğumuza.Haydi hayırlısı artık 🙂

Bu yolculuğumuzda elle tutulur neler ile karşılaşacağız diye soracak olursanız şöyle bir liste yapmak mümkün olacaktır diye düşünüyorum.

Temel anlamda mikrokontrolör kullanımını anlamak
Mikrokontrolör’ün veri kağıdını (datasheet) güzelce okumayı öğrenmek
Mikrokontrolörün çevresellerini (peripheral) modellemeyi ve kullanmayı öğrenmek (çok önemli)
Sensör modellemeyi ve kullanmayı öğrenmek
8 bitlik bir mikrokontrolör üzerinde neler yapılabileceğini ve neler yapılamayacağını görmek
Kütüphaneleri kullanıp, onlara bağımlı olmamayı öğrenmek
Donanım bağımsız kodlama yapmayı öğrenmek
Mikrokontrolörlerde hata ayıklama yöntemlerini öğrenmek
Mikrokontrolörün nasıl çalıştığını öğrenmek
Karışık sinyal devre tasarımı hakkında pratikler görmek
Hayata dokunan, onu yumruklayan işler yapmak

Bu bağlamda standard PIC programlama yazılarından epeyce farklı şeyler göreceğinizin garantisini veriyorum. Umuyorum ülkemizde, bu konular ile ilgilenmek isteyen kimselere faydalı olacak bir yazı dizisi olur. Gerek ilgi duyan kimselerin bu alanlara yönlendirilmesi, gerek bu alanda çalışan kişilerin bilgi birikimine bir nebze olsun katkıda bulunulması hedefleriyle bu yazıyı büyük bir motivasyonla sürdürüyor olacağım 🙂

PIC deyip küçümsemeyiniz, es geçmeyiniz efem. Zira buradan da edineceğimiz bir şeyler muhakkak vardır bakış açısı, bu güne kadar kimseye zarar getirmemiştir 🙂 Ayrıca yalnızca öğrenecek şeyleri olduğunu kabul edenler, kestirmesi olmayan uzun yolların sonunu görebilirler diye düşünüyorum. Bu vesileyle ben de zamanları boşa harcamayacak şekilde yazmayı sürdüreceğim 🙂 Bu süreçten büyük keyif alacağımı hissediyorum.

Dilerim ki sizler için de eğlenceli olur.

NOT: Yazı dizisi’nin ikinci yazısı “Merhaba PIC16” 7 Mart Cumartesi yayınlanacak.

Yazıları beğendiyseniz eğer, faydalanabilecek arkadaşlarınızla da paylaşabilirseniz sevinirim.

Şimdi devam…

Önceki Sayfa Sonraki Sayfa

XBee Kullanımı

26 February 2015 by ozenozkaya

Merhabalar arkadaşlar, eski blog sayfamı artık güncellemeyeceğimden, oradaki önemli bir yazıyı buraya taşımak istedim. XBee kullanımı üzerine yazdığım yazı, beklentilerimin ötesinde bir ilgi görmüştü ve zaman içerisinde özellikle resimlerin uçmasından ötürü çok sayıda kişi, resimleri güncellemem için benimle iletişime geçmişti. Bu vesileyle hem resimleri güncelleyeceğim hem de yazıyı buraya taşımış olacağım.

RF haberleşmesinin ne kadar sık kullanılan bir haberleşme teknolojisi olduğu su götürmez bir gerçek. Günümüzde RF haberleşme bir ham veri kümesini radyo dalgalarıyla aktarmaktan fazlasını ifade ediyor. Zigbee kavramı da burada ağırlığını ortaya koymuş, hatta ve hatta stratejik önemi haiz olmuş bir kavram olarak karşımıza çıkmaktadır (ne dedim !? :D)

Zigbee aslında bir protololdür. Jennic firmasının Jennet protokolü gibi… xBee ise bu haberleşme protokolünü taşıyan bir donanımdır.

Bu blog yazımda iki adet xBee’nin haberleştirilmesi işleminin nasıl yapıldığı ve gerekli alt yapı bilgilerini aktarmaya çalışacağım.

PAN ( Personal Area Network )

xBee modüllerinde tüm haberleşme işlemleri bir PAN üzerinden yapılmaktadır. Haberleşmenin gerçekleşebilmesi için mutlaka ama mutlaka bir PAN oluşturulmalıdır. PAN oluşturulmadığında hiç bir xBee cihazı faaliyet gösteremeyecektir. Bir PAN’ı ancak bir “Coordinator” oluşturabilir. PAN yönetimi ile ilgili bilgilere raporun ileri ki kısımlarında değineceğiz.

Bir PAN içinde bulunan tüm cihazların PAN ID’si aynı olmalıdır. Bunu daha teknik biçimde açıklayacak olursak aslında “coordinator” tarafından oluşturulan PAN’a katılmak isteyen tüm cihazların PAN ID’leri mutlaka “coordinator” cihazın PAN ID’si ile aynı olmalıdır. Aksi taktirde cihaz ağa kabul edilmez. Ağa kabul işlemleri ile ilgili daha geniş bilgilere ileri ki kısımlarında değineceğim.

Ağ Oluşturma:

Yukarıda örnek bir PAN görmektesiniz. C, R ve E türü cihazların özelliklerini açıklayalım.

C , “Coordinator” :

Haberleşme kanalını ve PAN ID’sini belirler. Bir PAN’ın başlatılmasından C sorumludur. PAN’ı başlattıktan sonra C, E ve R’lerin PAN’a katılmasına izin verebilir. C veri alıp yollayabilir, ya da mesh network yapısında verinin bir sonrki cihaza iletilmesi işlemlerini gerçekleştirebilir. C tüm ağı yönettiğinden pil ile beslenmesi ve/veya düşük güç modlarında çalıştırılması kesinlikle uygun değildir. C sabit bir güç kaynağı ile beslenmeli ve “main power mode” dediğimiz standart güç modunda çalıştırılmalıdır. C’nin işlevini kaybetmesi, tüm ağın çökmesi anlamına gelmektedir.

R, “Router” :

Bir R’nin çalışabilmesi için öncelikle bir PAN’a katılması gerekir. PAN’a katıldıktan sonra R, diğer R’lerin ve E’lerin (End Point) PAN’a katılmasına izin verebilir. R veri alıp yollayabilir ya da mesh network üzerinde veri aktarımını sağlayabilir. R’ler diğer cihazların PAN’a katılmasına izin vereceklerinden düşük güç modlarında çalıştırılmaları uygun değildir.

E, “End Device”:

R’de olduğu gibi E’de çalışabilmek için öncelikle bir PAN’a katılmalıdır. E diğer cihazların PAN’a katılmasına izin veremez, ancak mesh network üzerinde veri iletimi yapabilir.

Cihazların işlevlerini okuduktan sonra, yukarıdaki iletişim diyagramının tekrar incelenmesi faydalı olacaktır.

Xbee Konfigürasyonu

xBee’lerin konfigüre edilmesi için bir çok araç bulunmamaktadır ancak bunlar içerisinde en çok kullanılan ve en güvenilir olan digi firmasının bizzat ürettiği x-ctu yazılımı-dır. Tamamen ücretsiz olan bu arayüz ile xBee ile ilgili hemen her işlemi gerçekleştirebiliyo-ruz. Bu program üreticinin web sitesinden indirilebilir.

C Konfigrasyonu:

C’yi broadcast modda çalıştırıyoruz. Bunun için yapmamız gerekenler:

PAN ID belirlenir, (ID)

Scan Channels belirlenir, (SC)

Scan Duration belirlenir (opsiyonel) (SD)

Destination Low Adress belirlenir: DL = 0xFFFF yapılır.

Destination High Adress belirlenir: DH = 0 yapılır.

NI belirlenir: NI = COORDINATOR

İlgili konfigrasyon ekranı aşağıdaki gibidir:

R Konfigrasyonu:

R unicast modda programlanmalıdır.

SC ve ID değerleri seçilir (PAN’a göre yani C’ye göre)

CH ve OP kontrol edilir

MY belirlenir, bu routerın 16 bitlik network adresidir.

DH = 0 yapılır.

NI = ROUTERNAME yapılır

Ekran aşağıdaki gibidir:

ÇOKLU AĞ KURMA

xBee’ler ile mesh network kurmak için yapılması gerekenlere değineceğimiz bu kısımdaki işlemler temelde 2 ana başlık altında toplanabilir. Bunlardan bir tanesi AT komutları, diğeri ise konfigürasyon.

AĞ 1:

Kurmak istediğimiz basit ağ yapısı, 1 koordinatör ve 3 router cihazdan oluşacak. Öncelikli olarak koordinatör cihazdan yayın yaparak tüm router cihazlar ile aktif veri alışverişi kuracağız.

Yukarıda çizmiş olduğumuz diyagramda görüleceği üzere koordinatör router cihazlara yayın yapmakta, bununla birlikte de router cihazlar koordinatöre veri yollayabilmektedir.

Cihazları yukarıdaki çalışma için konfigüre ederken, öncelikli olarak xctu yazılımında fonksiyon seti olarak ROUTER/END DEVICE AT seçilir. Daha sonra Show Defaults butonuna basılır. sonrasında da PANID belirlenir. Biz bu uygulamada PANID olarak 0x100 değerini girdik. 3 router’ı da konfigüre etttiğimizde operating PANID olarak gördüğümüz değer 0xFFFF olmalıdır. Bunun sebebi ise xBee’lerin aynı PANID’li bir koordinatör bulamaması ve ilgili PAN’ın açılmasını beklemesidir. Bu durumda Router’lara ilişkin konfigürasyon aşağıdaki gibidir:

Koordinatör cihazı konfigüre etmek için ise, function set kısmı COORDINATOR AT olarak seçilir. Daha sonra Show Defaults butonuna basılır. Bundan sonra da PAN ID seçilmelidir. PAN ID’yi yine 0x100 seçeceğiz. Daha sonra read butonuna bastığımızda operating channel’ın 0x0E olduğunu gördük. Bu değer farklılık gösterebilir.

PAN oluşturulduktan sonra tekrar router cihazları xctu programı yardımıyla gözlemlemeliyiz. Bunun için yine ilgili modüle bağlandıktan sonra modem konfigrasyonu sekmesi açılmalıdır ve read butonuna basılmalıdır. Bunu yaptığınızda tüm modemlerin operating channel değerinin koordinatör cihaz ile aynı olduğunu göreceksiniz. Bu da router/end cihazların personal area network(PAN) içine başarıyla katıldığını göstermektedir.

Bu ayarları yaparken tüm modüllerin aynı seri haberleşme parametrelerini taşıdığından emin olmak gerekir, eğer bir modül handshaking isterken diğeri istemiyorsa ya da arada baudrate, parity, stop bit gibi farklılıklar varsa haberleşme gerçekleşmeyecektir. Bu haberleşmenin başarılı olduğunu aşağıda 1 defaya mahsus olarak gösteriyoruz, bundan sonraki ağ yapılarında bu şekilde olduğu gibi ekran çıktıları ile gösterim yapılmayacaktır. Benzer basamaklar kullanılarak tüm yapılar kolaylıkla test edilebilir.

Koordinatör Xbee:

Router 1 Xbee:

Router 2 Xbee:

Router 3 Xbee:

Görüldüğü üzre planladığımız ağ yapısı beklentilerimize uygun olarak çalışmıştır. Yukarıda gördüğünüz mesajlardan kırmızı olanlar cihazın aldığı mesajlar, mavi olanlar ise cihazın gönderdiği mesajlardır. Buna göre koordinatör herkese mesaj göndermiş ve herkesten mesaj almıştır. Bu sayede ağ yapılarına ilişkin ilk uygulama tamamlanmış oldu.

AĞ 2 (Point to MultiPoint Bidirectional Network)

Bu ağ yapısı çoğunlukla kullanacağımız ağ yapısıdır. Bu ağ yapısı sayesinde bir merkezin kontrolünde istediğimiz haberleşme sistemini rahatlıkla kurabilmekteyiz. Ağ yapısı ise aşağıdaki gibidir:

Yukarıdaki sistemde koordinatör yayın yapmamaktadır. Router/End cihazlar doğrudan merkez ile haberleşmektedirler. Bu yapıda koordinatör bir anlamda server, router ise client gibi düşünülebilir. Her xBee ağında olduğu gibi burada da koordinatörün gücünün kesilmemesine dikkat edilmelidir.

Yukarıdaki yapı gibi bir çok farklı ağ yapısı düşünülebilir.Bu yapıların kurulmasında artık arayüzden ziyade AT komutlarından yararlanacağız. Bunun nedeni ise xBee modüllerini OHM’ler ile kontrol edecek olmamızdır. Dolayısıyla xBee modülüne ilişkin yapacağımız her türlü değişiklik seri haberleşme ile sağlanacaktır. Şimdi de yukarıdaki sistemi oluşturmak için yapmamız gerekenlere değinelim.

Öncelikli olarak bir önceki uygulamada yani AĞ1’deki gibi bir yapı kurulur.
Tüm router’lar için aşağıdaki işlemler yapılır
1. Koordinatör cihaza terminal vasıtası ile “+++” komutu yollanır. Bu 2 saniyelik bir süre için xBee’yi komut moduna sokar.
2. Zaman geçirilmeden “ATSH” komutu yollanır. Okunan değer not edilir.
3. Hemen ardından “ATSL” komutu yollanır ve bu değer de not edilir.
4. Daha sonra da “ATWR” komutu yollanır.
Routerların tümü için sırayla aşağıdaki adımlar izlenir:
1. “+++” komutu ile komut moduna geçilir.
2. “ATDLkoordinatörSL” komutu işletilir. KoordinatörSL yazdığımız kısma 2. adımda not etmiş olduğumuz SL değeri yazılır. Örneğin “ATDL1A3252” gibi bir komut yollanabilir.
3. “ATDHkoordinatörSH” komutu işletilir. KoordinatörSH yazdığımız kısma 2. adıma not etmiş olduğumuz SH değeri yazılır. “Örneğin ATDH402D5DA9” gibi bir komut yollanabilir.
4. Bu adımlar tamamlanınca router koordinatöre veri yollamak üzere konfigüre edilmiş demektir. “ATWR” ile işlem sonlandırılır.
Koordinatörden herhangi bir router cihaza veri yollamak için yapılması gerekenler 3. adımda router’a yaptığımız ile neredeyse aynıdır. Hangi router’a veri yollamak istiyorsak DH ve DL adreslerine onun adresini girebilir ve sırayla istediğimiz cihaza veri yollayabilir. Bu veri yollama rutininde xBee ağlarının tüm özellikleri devam eder.

Umarım işinize yarar 🙂

Yazıları beğendiyseniz eğer, faydalanabilecek arkadaşlarınızla da paylaşabilirseniz sevinirim.

Şimdi devam…

Özen Özkaya :: Blog

Elektronik

PIC Programlama – 10 – EEPROM

PIC Programlama – 9 – Zamanlayıcılar (Timers) 2

PIC Programlama – 8 – Zamanlayıcılar (Timers)

PIC Programlama – 7 – Kesmeler (Interrupts) 2

PIC Programlama – 6 – Kesmeler (Interrupts)

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

PIC Programlama – 3 – Merhaba Dünya Analizi

PIC Programlama – 2: Merhaba PIC16

PIC Programlama – 1: Girizgah

XBee Kullanımı