rắc rối trong MPLAB 8.33

**kiemkhach10** · 03-02-2010, 09:38 PM

Mình mới tìm hiểu về PIC nên rất gà và cũng có một câu hỏi gà mong các cao thủ giúp đỡ
mình cài MPLAB IDE 8.33 và dùng phần hi-tec 9.65 nhưng khi mình search thì không thấy file (pic16f877a.h). Do vậy khi viết chương trình toàn báo ko tìm thấy con 16f877a.
Mong các cao thủ giúp

**charlie** · 03-02-2010, 10:54 PM

Cậu thử copy file p116f877a ở thư mục cài picc ra cùng thư mục với file project xem thế nào. Mình dùng ccs thì làm vậy còn ht thì ko được rõ lắm nhưng thấy ko ai trả lời nên góp ý vậy thôi. Cậu thử xem có được ko!

**kiemkhach10** · 04-02-2010, 07:35 PM

bạn có thể chỉ mình rõ hơn ko?
mình mới vào nghề nên kém lắm

**charlie** · 04-02-2010, 10:15 PM

Tại vì mình ko dùng hi-tech nên ko được rõ lắm. Mình cũng chỉ mới làm quen với pic thôi trước đó thì mình chỉ lập trình trên avr (mới làm quen với avr được ít bữa thì thày bắt chuyển sang pic. Chán nghê).
Thì thế này:
Mình lập trình trên mplab (dùng ccs c để viết c) thì ví dụ mình tạo một project ở /desktop thì phải copy file p16f877a.h ở C:\Program Files\PICC\Devices\ ra ngoài desktop (nói chung là phải cùng thư mục với file project của mình)
Cách khác cậu hãy thử chỉ ra đường dẫn cụ thể của thư viện xem sao vd: #include<"c:\....\p16f877a.h">
Cái này đáng kể để cho người khác làm về cái này nói thì chính xác hơn. Chẳng biết là có giup được gì cho cậu ko. Cậu thử xem nhé!
Chúc thành công!

**kiemkhach10** · 05-02-2010, 10:53 AM

cái khó là mình đã search nhưng ko có file pic16f877a trong phần cài đặt MPLAB và Hi-TEch PIC
vậy nên ko bít coppy ở đâu

**charlie** · 05-02-2010, 12:36 PM

Cậu thử vào đây nhé: C:\Program Files\HI-TECH Software\PICC\9.70\include\

**sonlamnguyenw** · 27-03-2012, 02:09 AM

bạn ơi đây này:
#ifndef _HTC_H_
#warning Header file pic16f877a.h included directly. Use #include <htc.h> instead.
#endif

/* header file for the MICROCHIP PIC microcontroller
* 16F877A
*/

#ifndef __PIC16F877A_H
#define __PIC16F877A_H

//
// Configuration mask definitions
//

// Config Register: CONFIG
#define CONFIG 0x2007
// Oscillator Selection bits
// RC oscillator
#define FOSC_EXTRC 0xFFFF
// HS oscillator
#define FOSC_HS 0xFFFE
// XT oscillator
#define FOSC_XT 0xFFFD
// LP oscillator
#define FOSC_LP 0xFFFC
// Watchdog Timer Enable bit
// WDT enabled
#define WDTE_ON 0xFFFF
// WDT disabled
#define WDTE_OFF 0xFFFB
// Power-up Timer Enable bit
// PWRT disabled
#define PWRTE_OFF 0xFFFF
// PWRT enabled
#define PWRTE_ON 0xFFF7
// Brown-out Reset Enable bit
// BOR enabled
#define BOREN_ON 0xFFFF
// BOR disabled
#define BOREN_OFF 0xFFBF
// Low-Voltage (Single-Supply) In-Circuit Serial Programming Enable bit
// RB3/PGM pin has PGM function; low-voltage programming enabled
#define LVP_ON 0xFFFF
// RB3 is digital I/O, HV on MCLR must be used for programming
#define LVP_OFF 0xFF7F
// Data EEPROM Memory Code Protection bit
// Data EEPROM code protection off
#define CPD_OFF 0xFFFF
// Data EEPROM code-protected
#define CPD_ON 0xFEFF
// Flash Program Memory Write Enable bits
// Write protection off; all program memory may be written to by EECON control
#define WRT_OFF 0xFFFF
// 0000h to 00FFh write-protected; 0100h to 1FFFh may be written to by EECON control
#define WRT_256 0xFDFF
// 0000h to 07FFh write-protected; 0800h to 1FFFh may be written to by EECON control
#define WRT_1FOURTH 0xFBFF
// 0000h to 0FFFh write-protected; 1000h to 1FFFh may be written to by EECON control
#define WRT_HALF 0xF9FF
// In-Circuit Debugger Mode bit
// In-Circuit Debugger disabled, RB6 and RB7 are general purpose I/O pins
#define DEBUG_OFF 0xFFFF
// In-Circuit Debugger enabled, RB6 and RB7 are dedicated to the debugger
#define DEBUG_ON 0xF7FF
// Flash Program Memory Code Protection bit
// Code protection off
#define CP_OFF 0xFFFF
// All program memory code-protected
#define CP_ON 0xDFFF

//
// Special function register definitions
//

// Register: INDF
volatile unsigned char INDF @ 0x000;
// bit and bitfield definitions

// Register: TMR0
volatile unsigned char TMR0 @ 0x001;
// bit and bitfield definitions

// Register: PCL
volatile unsigned char PCL @ 0x002;
// bit and bitfield definitions

// Register: STATUS
volatile unsigned char STATUS @ 0x003;
// bit and bitfield definitions
volatile bit CARRY @ ((unsigned)&STATUS*8)+0;
volatile bit DC @ ((unsigned)&STATUS*8)+1;
volatile bit ZERO @ ((unsigned)&STATUS*8)+2;
volatile bit nPD @ ((unsigned)&STATUS*8)+3;
volatile bit nTO @ ((unsigned)&STATUS*8)+4;
volatile bit IRP @ ((unsigned)&STATUS*8)+7;
volatile bit RP0 @ ((unsigned)&STATUS*8)+5;
volatile bit RP1 @ ((unsigned)&STATUS*8)+6;
#ifndef _LIB_BUILD
volatile 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;
};
} STATUSbits @ 0x003;
#endif

// Register: FSR
volatile unsigned char FSR @ 0x004;
// bit and bitfield definitions

// Register: PORTA
volatile unsigned char PORTA @ 0x005;
// bit and bitfield definitions
volatile bit RA0 @ ((unsigned)&PORTA*8)+0;
volatile bit RA1 @ ((unsigned)&PORTA*8)+1;
volatile bit RA2 @ ((unsigned)&PORTA*8)+2;
volatile bit RA3 @ ((unsigned)&PORTA*8)+3;
volatile bit RA4 @ ((unsigned)&PORTA*8)+4;
volatile bit RA5 @ ((unsigned)&PORTA*8)+5;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RA0 : 1;
unsigned RA1 : 1;
unsigned RA2 : 1;
unsigned RA3 : 1;
unsigned RA4 : 1;
unsigned RA5 : 1;
};
} PORTAbits @ 0x005;
#endif

// Register: PORTB
volatile unsigned char PORTB @ 0x006;
// bit and bitfield definitions
volatile bit RB0 @ ((unsigned)&PORTB*8)+0;
volatile bit RB1 @ ((unsigned)&PORTB*8)+1;
volatile bit RB2 @ ((unsigned)&PORTB*8)+2;
volatile bit RB3 @ ((unsigned)&PORTB*8)+3;
volatile bit RB4 @ ((unsigned)&PORTB*8)+4;
volatile bit RB5 @ ((unsigned)&PORTB*8)+5;
volatile bit RB6 @ ((unsigned)&PORTB*8)+6;
volatile bit RB7 @ ((unsigned)&PORTB*8)+7;
#ifndef _LIB_BUILD
volatile 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 @ 0x006;
#endif

// Register: PORTC
volatile unsigned char PORTC @ 0x007;
// bit and bitfield definitions
volatile bit RC0 @ ((unsigned)&PORTC*8)+0;
volatile bit RC1 @ ((unsigned)&PORTC*8)+1;
volatile bit RC2 @ ((unsigned)&PORTC*8)+2;
volatile bit RC3 @ ((unsigned)&PORTC*8)+3;
volatile bit RC4 @ ((unsigned)&PORTC*8)+4;
volatile bit RC5 @ ((unsigned)&PORTC*8)+5;
volatile bit RC6 @ ((unsigned)&PORTC*8)+6;
volatile bit RC7 @ ((unsigned)&PORTC*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RC0 : 1;
unsigned RC1 : 1;
unsigned RC2 : 1;
unsigned RC3 : 1;
unsigned RC4 : 1;
unsigned RC5 : 1;
unsigned RC6 : 1;
unsigned RC7 : 1;
};
} PORTCbits @ 0x007;
#endif

// Register: PORTD
volatile unsigned char PORTD @ 0x008;
// bit and bitfield definitions
volatile bit RD0 @ ((unsigned)&PORTD*8)+0;
volatile bit RD1 @ ((unsigned)&PORTD*8)+1;
volatile bit RD2 @ ((unsigned)&PORTD*8)+2;
volatile bit RD3 @ ((unsigned)&PORTD*8)+3;
volatile bit RD4 @ ((unsigned)&PORTD*8)+4;
volatile bit RD5 @ ((unsigned)&PORTD*8)+5;
volatile bit RD6 @ ((unsigned)&PORTD*8)+6;
volatile bit RD7 @ ((unsigned)&PORTD*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RD0 : 1;
unsigned RD1 : 1;
unsigned RD2 : 1;
unsigned RD3 : 1;
unsigned RD4 : 1;
unsigned RD5 : 1;
unsigned RD6 : 1;
unsigned RD7 : 1;
};
} PORTDbits @ 0x008;
#endif

// Register: PORTE
volatile unsigned char PORTE @ 0x009;
// bit and bitfield definitions
volatile bit RE0 @ ((unsigned)&PORTE*8)+0;
volatile bit RE1 @ ((unsigned)&PORTE*8)+1;
volatile bit RE2 @ ((unsigned)&PORTE*8)+2;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RE0 : 1;
unsigned RE1 : 1;
unsigned RE2 : 1;
};
} PORTEbits @ 0x009;
#endif

// Register: PCLATH
volatile unsigned char PCLATH @ 0x00A;
// bit and bitfield definitions
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned PCLATH : 5;
};
} PCLATHbits @ 0x00A;
#endif

// Register: INTCON
volatile unsigned char INTCON @ 0x00B;
// bit and bitfield definitions
volatile bit RBIF @ ((unsigned)&INTCON*8)+0;
volatile bit INTF @ ((unsigned)&INTCON*8)+1;
volatile bit TMR0IF @ ((unsigned)&INTCON*8)+2;
volatile bit RBIE @ ((unsigned)&INTCON*8)+3;
volatile bit INTE @ ((unsigned)&INTCON*8)+4;
volatile bit TMR0IE @ ((unsigned)&INTCON*8)+5;
volatile bit PEIE @ ((unsigned)&INTCON*8)+6;
volatile bit GIE @ ((unsigned)&INTCON*8)+7;
volatile bit T0IF @ ((unsigned)&INTCON*8)+2;
volatile bit T0IE @ ((unsigned)&INTCON*8)+5;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RBIF : 1;
unsigned INTF : 1;
unsigned TMR0IF : 1;
unsigned RBIE : 1;
unsigned INTE : 1;
unsigned TMR0IE : 1;
unsigned PEIE : 1;
unsigned GIE : 1;
};
struct {
unsigned : 2;
unsigned T0IF : 1;
unsigned : 2;
unsigned T0IE : 1;
};
} INTCONbits @ 0x00B;
#endif

// Register: PIR1
volatile unsigned char PIR1 @ 0x00C;
// bit and bitfield definitions
volatile bit TMR1IF @ ((unsigned)&PIR1*8)+0;
volatile bit TMR2IF @ ((unsigned)&PIR1*8)+1;
volatile bit CCP1IF @ ((unsigned)&PIR1*8)+2;
volatile bit SSPIF @ ((unsigned)&PIR1*8)+3;
volatile bit TXIF @ ((unsigned)&PIR1*8)+4;
volatile bit RCIF @ ((unsigned)&PIR1*8)+5;
volatile bit ADIF @ ((unsigned)&PIR1*8)+6;
volatile bit PSPIF @ ((unsigned)&PIR1*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TMR1IF : 1;
unsigned TMR2IF : 1;
unsigned CCP1IF : 1;
unsigned SSPIF : 1;
unsigned TXIF : 1;
unsigned RCIF : 1;
unsigned ADIF : 1;
unsigned PSPIF : 1;
};
struct {
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 2;
unsigned : 1;
unsigned : 1;
};
} PIR1bits @ 0x00C;
#endif

// Register: PIR2
volatile unsigned char PIR2 @ 0x00D;
// bit and bitfield definitions
volatile bit CCP2IF @ ((unsigned)&PIR2*8)+0;
volatile bit BCLIF @ ((unsigned)&PIR2*8)+3;
volatile bit EEIF @ ((unsigned)&PIR2*8)+4;
volatile bit CMIF @ ((unsigned)&PIR2*8)+6;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned CCP2IF : 1;
unsigned : 2;
unsigned BCLIF : 1;
unsigned EEIF : 1;
unsigned : 1;
unsigned CMIF : 1;
};
} PIR2bits @ 0x00D;
#endif
// bit and bitfield definitions

// Register: TMR1L
volatile unsigned char TMR1L @ 0x00E;
// bit and bitfield definitions

// Register: TMR1H
volatile unsigned char TMR1H @ 0x00F;
// bit and bitfield definitions

// Register: TMR1
volatile unsigned int TMR1 @ 0x00E;

// Register: T1CON
volatile unsigned char T1CON @ 0x010;
// bit and bitfield definitions
volatile bit TMR1ON @ ((unsigned)&T1CON*8)+0;
volatile bit TMR1CS @ ((unsigned)&T1CON*8)+1;
volatile bit nT1SYNC @ ((unsigned)&T1CON*8)+2;
volatile bit T1OSCEN @ ((unsigned)&T1CON*8)+3;
volatile bit T1SYNC @ ((unsigned)&T1CON*8)+2;
volatile bit T1CKPS0 @ ((unsigned)&T1CON*8)+4;
volatile bit T1CKPS1 @ ((unsigned)&T1CON*8)+5;
volatile bit T1INSYNC @ ((unsigned)&T1CON*8)+2;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TMR1ON : 1;
unsigned TMR1CS : 1;
unsigned nT1SYNC : 1;
unsigned T1OSCEN : 1;
unsigned T1CKPS : 2;
};
struct {
unsigned : 2;
unsigned T1SYNC : 1;
unsigned : 1;
unsigned T1CKPS0 : 1;
unsigned T1CKPS1 : 1;
};
struct {
unsigned : 2;
unsigned T1INSYNC : 1;
};
} T1CONbits @ 0x010;
#endif

// Register: TMR2
volatile unsigned char TMR2 @ 0x011;
// bit and bitfield definitions

// Register: T2CON
volatile unsigned char T2CON @ 0x012;
// bit and bitfield definitions
volatile bit TMR2ON @ ((unsigned)&T2CON*8)+2;
volatile bit T2CKPS0 @ ((unsigned)&T2CON*8)+0;
volatile bit T2CKPS1 @ ((unsigned)&T2CON*8)+1;
volatile bit TOUTPS0 @ ((unsigned)&T2CON*8)+3;
volatile bit TOUTPS1 @ ((unsigned)&T2CON*8)+4;
volatile bit TOUTPS2 @ ((unsigned)&T2CON*8)+5;
volatile bit TOUTPS3 @ ((unsigned)&T2CON*8)+6;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned T2CKPS : 2;
unsigned TMR2ON : 1;
unsigned TOUTPS : 4;
};
struct {
unsigned T2CKPS0 : 1;
unsigned T2CKPS1 : 1;
unsigned : 1;
unsigned TOUTPS0 : 1;
unsigned TOUTPS1 : 1;
unsigned TOUTPS2 : 1;
unsigned TOUTPS3 : 1;
};
} T2CONbits @ 0x012;
#endif

// Register: SSPBUF
volatile unsigned char SSPBUF @ 0x013;
// bit and bitfield definitions

// Register: SSPCON
volatile unsigned char SSPCON @ 0x014;
// bit and bitfield definitions
volatile bit CKP @ ((unsigned)&SSPCON*8)+4;
volatile bit SSPEN @ ((unsigned)&SSPCON*8)+5;
volatile bit SSPOV @ ((unsigned)&SSPCON*8)+6;
volatile bit WCOL @ ((unsigned)&SSPCON*8)+7;
volatile bit SSPM0 @ ((unsigned)&SSPCON*8)+0;
volatile bit SSPM1 @ ((unsigned)&SSPCON*8)+1;
volatile bit SSPM2 @ ((unsigned)&SSPCON*8)+2;
volatile bit SSPM3 @ ((unsigned)&SSPCON*8)+3;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned SSPM : 4;
unsigned CKP : 1;
unsigned SSPEN : 1;
unsigned SSPOV : 1;
unsigned WCOL : 1;
};
struct {
unsigned SSPM0 : 1;
unsigned SSPM1 : 1;
unsigned SSPM2 : 1;
unsigned SSPM3 : 1;
};
} SSPCONbits @ 0x014;
#endif
// bit and bitfield definitions

// Register: CCPR1L
volatile unsigned char CCPR1L @ 0x015;
// bit and bitfield definitions

// Register: CCPR1H
volatile unsigned char CCPR1H @ 0x016;
// bit and bitfield definitions

// Register: CCPR1
volatile unsigned int CCPR1 @ 0x015;

// Register: CCP1CON
volatile unsigned char CCP1CON @ 0x017;
// bit and bitfield definitions
volatile bit CCP1Y @ ((unsigned)&CCP1CON*8)+4;
volatile bit CCP1X @ ((unsigned)&CCP1CON*8)+5;
volatile bit CCP1M0 @ ((unsigned)&CCP1CON*8)+0;
volatile bit CCP1M1 @ ((unsigned)&CCP1CON*8)+1;
volatile bit CCP1M2 @ ((unsigned)&CCP1CON*8)+2;
volatile bit CCP1M3 @ ((unsigned)&CCP1CON*8)+3;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned CCP1M : 4;
unsigned CCP1Y : 1;
unsigned CCP1X : 1;
};
struct {
unsigned CCP1M0 : 1;
unsigned CCP1M1 : 1;
unsigned CCP1M2 : 1;
unsigned CCP1M3 : 1;
};
} CCP1CONbits @ 0x017;
#endif

// Register: RCSTA
volatile unsigned char RCSTA @ 0x018;
// bit and bitfield definitions
volatile bit RX9D @ ((unsigned)&RCSTA*8)+0;
volatile bit OERR @ ((unsigned)&RCSTA*8)+1;
volatile bit FERR @ ((unsigned)&RCSTA*8)+2;
volatile bit ADDEN @ ((unsigned)&RCSTA*8)+3;
volatile bit CREN @ ((unsigned)&RCSTA*8)+4;
volatile bit SREN @ ((unsigned)&RCSTA*8)+5;
volatile bit RX9 @ ((unsigned)&RCSTA*8)+6;
volatile bit SPEN @ ((unsigned)&RCSTA*8)+7;
volatile bit RCD8 @ ((unsigned)&RCSTA*8)+0;
volatile bit RC9 @ ((unsigned)&RCSTA*8)+6;
volatile bit nRC8 @ ((unsigned)&RCSTA*8)+6;
volatile bit RC8_9 @ ((unsigned)&RCSTA*8)+6;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RX9D : 1;
unsigned OERR : 1;
unsigned FERR : 1;
unsigned ADDEN : 1;
unsigned CREN : 1;
unsigned SREN : 1;
unsigned RX9 : 1;
unsigned SPEN : 1;
};
struct {
unsigned RCD8 : 1;
unsigned : 5;
unsigned RC9 : 1;
};
struct {
unsigned : 6;
unsigned nRC8 : 1;
};
struct {
unsigned : 6;
unsigned RC8_9 : 1;
};
} RCSTAbits @ 0x018;
#endif

// Register: TXREG
volatile unsigned char TXREG @ 0x019;
// bit and bitfield definitions

// Register: RCREG
volatile unsigned char RCREG @ 0x01A;
// bit and bitfield definitions
// bit and bitfield definitions

// Register: CCPR2L
volatile unsigned char CCPR2L @ 0x01B;
// bit and bitfield definitions

// Register: CCPR2H
volatile unsigned char CCPR2H @ 0x01C;
// bit and bitfield definitions

// Register: CCPR2
volatile unsigned int CCPR2 @ 0x01B;

// Register: CCP2CON
volatile unsigned char CCP2CON @ 0x01D;
// bit and bitfield definitions
volatile bit CCP2Y @ ((unsigned)&CCP2CON*8)+4;
volatile bit CCP2X @ ((unsigned)&CCP2CON*8)+5;
volatile bit CCP2M0 @ ((unsigned)&CCP2CON*8)+0;
volatile bit CCP2M1 @ ((unsigned)&CCP2CON*8)+1;
volatile bit CCP2M2 @ ((unsigned)&CCP2CON*8)+2;
volatile bit CCP2M3 @ ((unsigned)&CCP2CON*8)+3;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned CCP2M : 4;
unsigned CCP2Y : 1;
unsigned CCP2X : 1;
};
struct {
unsigned CCP2M0 : 1;
unsigned CCP2M1 : 1;
unsigned CCP2M2 : 1;
unsigned CCP2M3 : 1;
};
} CCP2CONbits @ 0x01D;
#endif

// Register: ADRESH
volatile unsigned char ADRESH @ 0x01E;
// bit and bitfield definitions

// Register: ADCON0
volatile unsigned char ADCON0 @ 0x01F;
// bit and bitfield definitions
volatile bit ADON @ ((unsigned)&ADCON0*8)+0;
volatile bit GO_nDONE @ ((unsigned)&ADCON0*8)+2;
volatile bit GO @ ((unsigned)&ADCON0*8)+2;
volatile bit CHS0 @ ((unsigned)&ADCON0*8)+3;
volatile bit CHS1 @ ((unsigned)&ADCON0*8)+4;
volatile bit CHS2 @ ((unsigned)&ADCON0*8)+5;
volatile bit ADCS0 @ ((unsigned)&ADCON0*8)+6;
volatile bit ADCS1 @ ((unsigned)&ADCON0*8)+7;
volatile bit nDONE @ ((unsigned)&ADCON0*8)+2;
volatile bit GO_DONE @ ((unsigned)&ADCON0*8)+2;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned ADON : 1;
unsigned : 1;
unsigned GO_nDONE : 1;
unsigned CHS : 3;
unsigned ADCS : 2;
};
struct {
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 3;
unsigned : 2;
};
struct {
unsigned : 2;
unsigned GO : 1;
unsigned CHS0 : 1;
unsigned CHS1 : 1;
unsigned CHS2 : 1;
unsigned ADCS0 : 1;
unsigned ADCS1 : 1;
};
struct {
unsigned : 2;
unsigned nDONE : 1;
};
struct {
unsigned : 2;
unsigned GO_DONE : 1;
};
} ADCON0bits @ 0x01F;
#endif

//
// Special function register definitions: Bank 1
//

// Register: OPTION_REG
volatile unsigned char OPTION_REG @ 0x081;
// bit and bitfield definitions
volatile bit PSA @ ((unsigned)&OPTION_REG*8)+3;
volatile bit T0SE @ ((unsigned)&OPTION_REG*8)+4;
volatile bit T0CS @ ((unsigned)&OPTION_REG*8)+5;
volatile bit INTEDG @ ((unsigned)&OPTION_REG*8)+6;
volatile bit nRBPU @ ((unsigned)&OPTION_REG*8)+7;
volatile bit PS0 @ ((unsigned)&OPTION_REG*8)+0;
volatile bit PS1 @ ((unsigned)&OPTION_REG*8)+1;
volatile bit PS2 @ ((unsigned)&OPTION_REG*8)+2;
#ifndef _LIB_BUILD
volatile 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 @ 0x081;
#endif

// Register: TRISA
volatile unsigned char TRISA @ 0x085;
// bit and bitfield definitions
volatile bit TRISA0 @ ((unsigned)&TRISA*8)+0;
volatile bit TRISA1 @ ((unsigned)&TRISA*8)+1;
volatile bit TRISA2 @ ((unsigned)&TRISA*8)+2;
volatile bit TRISA3 @ ((unsigned)&TRISA*8)+3;
volatile bit TRISA4 @ ((unsigned)&TRISA*8)+4;
volatile bit TRISA5 @ ((unsigned)&TRISA*8)+5;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TRISA0 : 1;
unsigned TRISA1 : 1;
unsigned TRISA2 : 1;
unsigned TRISA3 : 1;
unsigned TRISA4 : 1;
unsigned TRISA5 : 1;
};
} TRISAbits @ 0x085;
#endif

// Register: TRISB
volatile unsigned char TRISB @ 0x086;
// bit and bitfield definitions
volatile bit TRISB0 @ ((unsigned)&TRISB*8)+0;
volatile bit TRISB1 @ ((unsigned)&TRISB*8)+1;
volatile bit TRISB2 @ ((unsigned)&TRISB*8)+2;
volatile bit TRISB3 @ ((unsigned)&TRISB*8)+3;
volatile bit TRISB4 @ ((unsigned)&TRISB*8)+4;
volatile bit TRISB5 @ ((unsigned)&TRISB*8)+5;
volatile bit TRISB6 @ ((unsigned)&TRISB*8)+6;
volatile bit TRISB7 @ ((unsigned)&TRISB*8)+7;
#ifndef _LIB_BUILD
volatile 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 @ 0x086;
#endif

// Register: TRISC
volatile unsigned char TRISC @ 0x087;
// bit and bitfield definitions
volatile bit TRISC0 @ ((unsigned)&TRISC*8)+0;
volatile bit TRISC1 @ ((unsigned)&TRISC*8)+1;
volatile bit TRISC2 @ ((unsigned)&TRISC*8)+2;
volatile bit TRISC3 @ ((unsigned)&TRISC*8)+3;
volatile bit TRISC4 @ ((unsigned)&TRISC*8)+4;
volatile bit TRISC5 @ ((unsigned)&TRISC*8)+5;
volatile bit TRISC6 @ ((unsigned)&TRISC*8)+6;
volatile bit TRISC7 @ ((unsigned)&TRISC*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TRISC0 : 1;
unsigned TRISC1 : 1;
unsigned TRISC2 : 1;
unsigned TRISC3 : 1;
unsigned TRISC4 : 1;
unsigned TRISC5 : 1;
unsigned TRISC6 : 1;
unsigned TRISC7 : 1;
};
} TRISCbits @ 0x087;
#endif

// Register: TRISD
volatile unsigned char TRISD @ 0x088;
// bit and bitfield definitions
volatile bit TRISD0 @ ((unsigned)&TRISD*8)+0;
volatile bit TRISD1 @ ((unsigned)&TRISD*8)+1;
volatile bit TRISD2 @ ((unsigned)&TRISD*8)+2;
volatile bit TRISD3 @ ((unsigned)&TRISD*8)+3;
volatile bit TRISD4 @ ((unsigned)&TRISD*8)+4;
volatile bit TRISD5 @ ((unsigned)&TRISD*8)+5;
volatile bit TRISD6 @ ((unsigned)&TRISD*8)+6;
volatile bit TRISD7 @ ((unsigned)&TRISD*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TRISD0 : 1;
unsigned TRISD1 : 1;
unsigned TRISD2 : 1;
unsigned TRISD3 : 1;
unsigned TRISD4 : 1;
unsigned TRISD5 : 1;
unsigned TRISD6 : 1;
unsigned TRISD7 : 1;
};
} TRISDbits @ 0x088;
#endif

// Register: TRISE
volatile unsigned char TRISE @ 0x089;
// bit and bitfield definitions
volatile bit TRISE0 @ ((unsigned)&TRISE*8)+0;
volatile bit TRISE1 @ ((unsigned)&TRISE*8)+1;
volatile bit TRISE2 @ ((unsigned)&TRISE*8)+2;
volatile bit PSPMODE @ ((unsigned)&TRISE*8)+4;
volatile bit IBOV @ ((unsigned)&TRISE*8)+5;
volatile bit OBF @ ((unsigned)&TRISE*8)+6;
volatile bit IBF @ ((unsigned)&TRISE*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TRISE0 : 1;
unsigned TRISE1 : 1;
unsigned TRISE2 : 1;
unsigned : 1;
unsigned PSPMODE : 1;
unsigned IBOV : 1;
unsigned OBF : 1;
unsigned IBF : 1;
};
} TRISEbits @ 0x089;
#endif

// Register: PIE1
volatile unsigned char PIE1 @ 0x08C;
// bit and bitfield definitions
volatile bit TMR1IE @ ((unsigned)&PIE1*8)+0;
volatile bit TMR2IE @ ((unsigned)&PIE1*8)+1;
volatile bit CCP1IE @ ((unsigned)&PIE1*8)+2;
volatile bit SSPIE @ ((unsigned)&PIE1*8)+3;
volatile bit TXIE @ ((unsigned)&PIE1*8)+4;
volatile bit RCIE @ ((unsigned)&PIE1*8)+5;
volatile bit ADIE @ ((unsigned)&PIE1*8)+6;
volatile bit PSPIE @ ((unsigned)&PIE1*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TMR1IE : 1;
unsigned TMR2IE : 1;
unsigned CCP1IE : 1;
unsigned SSPIE : 1;
unsigned TXIE : 1;
unsigned RCIE : 1;
unsigned ADIE : 1;
unsigned PSPIE : 1;
};
} PIE1bits @ 0x08C;
#endif

// Register: PIE2
volatile unsigned char PIE2 @ 0x08D;
// bit and bitfield definitions
volatile bit CCP2IE @ ((unsigned)&PIE2*8)+0;
volatile bit BCLIE @ ((unsigned)&PIE2*8)+3;
volatile bit EEIE @ ((unsigned)&PIE2*8)+4;
volatile bit CMIE @ ((unsigned)&PIE2*8)+6;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned CCP2IE : 1;
unsigned : 2;
unsigned BCLIE : 1;
unsigned EEIE : 1;
unsigned : 1;
unsigned CMIE : 1;
};
} PIE2bits @ 0x08D;
#endif

// Register: PCON
volatile unsigned char PCON @ 0x08E;
// bit and bitfield definitions
volatile bit nBOR @ ((unsigned)&PCON*8)+0;
volatile bit nPOR @ ((unsigned)&PCON*8)+1;
volatile bit nBO @ ((unsigned)&PCON*8)+0;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned nBOR : 1;
unsigned nPOR : 1;
};
struct {
unsigned nBO : 1;
};
} PCONbits @ 0x08E;
#endif

// Register: SSPCON2
volatile unsigned char SSPCON2 @ 0x091;
// bit and bitfield definitions
volatile bit SEN @ ((unsigned)&SSPCON2*8)+0;
volatile bit RSEN @ ((unsigned)&SSPCON2*8)+1;
volatile bit PEN @ ((unsigned)&SSPCON2*8)+2;
volatile bit RCEN @ ((unsigned)&SSPCON2*8)+3;
volatile bit ACKEN @ ((unsigned)&SSPCON2*8)+4;
volatile bit ACKDT @ ((unsigned)&SSPCON2*8)+5;
volatile bit ACKSTAT @ ((unsigned)&SSPCON2*8)+6;
volatile bit GCEN @ ((unsigned)&SSPCON2*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned SEN : 1;
unsigned RSEN : 1;
unsigned PEN : 1;
unsigned RCEN : 1;
unsigned ACKEN : 1;
unsigned ACKDT : 1;
unsigned ACKSTAT : 1;
unsigned GCEN : 1;
};
} SSPCON2bits @ 0x091;
#endif

// Register: PR2
volatile unsigned char PR2 @ 0x092;
// bit and bitfield definitions

// Register: SSPADD
volatile unsigned char SSPADD @ 0x093;
// bit and bitfield definitions

// Register: SSPSTAT
volatile unsigned char SSPSTAT @ 0x094;
// bit and bitfield definitions
volatile bit BF @ ((unsigned)&SSPSTAT*8)+0;
volatile bit UA @ ((unsigned)&SSPSTAT*8)+1;
volatile bit R_nW @ ((unsigned)&SSPSTAT*8)+2;
volatile bit S @ ((unsigned)&SSPSTAT*8)+3;
volatile bit P @ ((unsigned)&SSPSTAT*8)+4;
volatile bit D_nA @ ((unsigned)&SSPSTAT*8)+5;
volatile bit CKE @ ((unsigned)&SSPSTAT*8)+6;
volatile bit SMP @ ((unsigned)&SSPSTAT*8)+7;
volatile bit R @ ((unsigned)&SSPSTAT*8)+2;
volatile bit D @ ((unsigned)&SSPSTAT*8)+5;
volatile bit I2C_READ @ ((unsigned)&SSPSTAT*8)+2;
volatile bit I2C_START @ ((unsigned)&SSPSTAT*8)+3;
volatile bit I2C_STOP @ ((unsigned)&SSPSTAT*8)+4;
volatile bit I2C_DATA @ ((unsigned)&SSPSTAT*8)+5;
volatile bit nW @ ((unsigned)&SSPSTAT*8)+2;
volatile bit nA @ ((unsigned)&SSPSTAT*8)+5;
volatile bit nWRITE @ ((unsigned)&SSPSTAT*8)+2;
volatile bit nADDRESS @ ((unsigned)&SSPSTAT*8)+5;
volatile bit R_W @ ((unsigned)&SSPSTAT*8)+2;
volatile bit D_A @ ((unsigned)&SSPSTAT*8)+5;
volatile bit READ_WRITE @ ((unsigned)&SSPSTAT*8)+2;
volatile bit DATA_ADDRESS @ ((unsigned)&SSPSTAT*8)+5;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned BF : 1;
unsigned UA : 1;
unsigned R_nW : 1;
unsigned S : 1;
unsigned P : 1;
unsigned D_nA : 1;
unsigned CKE : 1;
unsigned SMP : 1;
};
struct {
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 1;
unsigned : 1;
};
struct {
unsigned : 2;
unsigned R : 1;
unsigned : 2;
unsigned D : 1;
};
struct {
unsigned : 2;
unsigned I2C_READ : 1;
unsigned I2C_START : 1;
unsigned I2C_STOP : 1;
unsigned I2C_DATA : 1;
};
struct {
unsigned : 2;
unsigned nW : 1;
unsigned : 2;
unsigned nA : 1;
};
struct {
unsigned : 2;
unsigned nWRITE : 1;
unsigned : 2;
unsigned nADDRESS : 1;
};
struct {
unsigned : 2;
unsigned R_W : 1;
unsigned : 2;
unsigned D_A : 1;
};
struct {
unsigned : 2;
unsigned READ_WRITE : 1;
unsigned : 2;
unsigned DATA_ADDRESS : 1;
};
} SSPSTATbits @ 0x094;
#endif

// Register: TXSTA
volatile unsigned char TXSTA @ 0x098;
// bit and bitfield definitions
volatile bit TX9D @ ((unsigned)&TXSTA*8)+0;
volatile bit TRMT @ ((unsigned)&TXSTA*8)+1;
volatile bit BRGH @ ((unsigned)&TXSTA*8)+2;
volatile bit SYNC @ ((unsigned)&TXSTA*8)+4;
volatile bit TXEN @ ((unsigned)&TXSTA*8)+5;
volatile bit TX9 @ ((unsigned)&TXSTA*8)+6;
volatile bit CSRC @ ((unsigned)&TXSTA*8)+7;
volatile bit TXD8 @ ((unsigned)&TXSTA*8)+0;
volatile bit nTX8 @ ((unsigned)&TXSTA*8)+6;
volatile bit TX8_9 @ ((unsigned)&TXSTA*8)+6;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned TX9D : 1;
unsigned TRMT : 1;
unsigned BRGH : 1;
unsigned : 1;
unsigned SYNC : 1;
unsigned TXEN : 1;
unsigned TX9 : 1;
unsigned CSRC : 1;
};
struct {
unsigned TXD8 : 1;
unsigned : 5;
unsigned nTX8 : 1;
};
struct {
unsigned : 6;
unsigned TX8_9 : 1;
};
} TXSTAbits @ 0x098;
#endif

// Register: SPBRG
volatile unsigned char SPBRG @ 0x099;
// bit and bitfield definitions

// Register: CMCON
volatile unsigned char CMCON @ 0x09C;
// bit and bitfield definitions
volatile bit CIS @ ((unsigned)&CMCON*8)+3;
volatile bit C1INV @ ((unsigned)&CMCON*8)+4;
volatile bit C2INV @ ((unsigned)&CMCON*8)+5;
volatile bit C1OUT @ ((unsigned)&CMCON*8)+6;
volatile bit C2OUT @ ((unsigned)&CMCON*8)+7;
volatile bit CM0 @ ((unsigned)&CMCON*8)+0;
volatile bit CM1 @ ((unsigned)&CMCON*8)+1;
volatile bit CM2 @ ((unsigned)&CMCON*8)+2;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned CM : 3;
unsigned CIS : 1;
unsigned C1INV : 1;
unsigned C2INV : 1;
unsigned C1OUT : 1;
unsigned C2OUT : 1;
};
struct {
unsigned CM0 : 1;
unsigned CM1 : 1;
unsigned CM2 : 1;
};
} CMCONbits @ 0x09C;
#endif

// Register: CVRCON
volatile unsigned char CVRCON @ 0x09D;
// bit and bitfield definitions
volatile bit CVRR @ ((unsigned)&CVRCON*8)+5;
volatile bit CVROE @ ((unsigned)&CVRCON*8)+6;
volatile bit CVREN @ ((unsigned)&CVRCON*8)+7;
volatile bit CVR0 @ ((unsigned)&CVRCON*8)+0;
volatile bit CVR1 @ ((unsigned)&CVRCON*8)+1;
volatile bit CVR2 @ ((unsigned)&CVRCON*8)+2;
volatile bit CVR3 @ ((unsigned)&CVRCON*8)+3;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned CVR : 4;
unsigned : 1;
unsigned CVRR : 1;
unsigned CVROE : 1;
unsigned CVREN : 1;
};
struct {
unsigned CVR0 : 1;
unsigned CVR1 : 1;
unsigned CVR2 : 1;
unsigned CVR3 : 1;
};
} CVRCONbits @ 0x09D;
#endif

// Register: ADRESL
volatile unsigned char ADRESL @ 0x09E;
// bit and bitfield definitions

// Register: ADCON1
volatile unsigned char ADCON1 @ 0x09F;
// bit and bitfield definitions
volatile bit ADCS2 @ ((unsigned)&ADCON1*8)+6;
volatile bit ADFM @ ((unsigned)&ADCON1*8)+7;
volatile bit PCFG0 @ ((unsigned)&ADCON1*8)+0;
volatile bit PCFG1 @ ((unsigned)&ADCON1*8)+1;
volatile bit PCFG2 @ ((unsigned)&ADCON1*8)+2;
volatile bit PCFG3 @ ((unsigned)&ADCON1*8)+3;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned PCFG : 4;
unsigned : 2;
unsigned ADCS2 : 1;
unsigned ADFM : 1;
};
struct {
unsigned PCFG0 : 1;
unsigned PCFG1 : 1;
unsigned PCFG2 : 1;
unsigned PCFG3 : 1;
};
} ADCON1bits @ 0x09F;
#endif

//
// Special function register definitions: Bank 2
//

// Register: EEDATA
volatile unsigned char EEDATA @ 0x10C;
// bit and bitfield definitions

// Register: EEADR
volatile unsigned char EEADR @ 0x10D;
// bit and bitfield definitions

// Register: EEDATH
volatile unsigned char EEDATH @ 0x10E;
// bit and bitfield definitions
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned : 6;
};
} EEDATHbits @ 0x10E;
#endif

// Register: EEADRH
volatile unsigned char EEADRH @ 0x10F;
// bit and bitfield definitions
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned : 5;
};
} EEADRHbits @ 0x10F;
#endif

//
// Special function register definitions: Bank 3
//

// Register: EECON1
volatile unsigned char EECON1 @ 0x18C;
// bit and bitfield definitions
volatile bit RD @ ((unsigned)&EECON1*8)+0;
volatile bit WR @ ((unsigned)&EECON1*8)+1;
volatile bit WREN @ ((unsigned)&EECON1*8)+2;
volatile bit WRERR @ ((unsigned)&EECON1*8)+3;
volatile bit EEPGD @ ((unsigned)&EECON1*8)+7;
#ifndef _LIB_BUILD
volatile union {
struct {
unsigned RD : 1;
unsigned WR : 1;
unsigned WREN : 1;
unsigned WRERR : 1;
unsigned : 3;
unsigned EEPGD : 1;
};
} EECON1bits @ 0x18C;
#endif

// Register: EECON2
volatile unsigned char EECON2 @ 0x18D;
// bit and bitfield definitions

#endif

03-02-2010, 09:38 PM	#1
kiemkhach10 Đệ tử 5 túi Tham gia ngày: Jan 2010 Bài gửi: 114 :	rắc rối trong MPLAB 8.33 Mình mới tìm hiểu về PIC nên rất gà và cũng có một câu hỏi gà mong các cao thủ giúp đỡ mình cài MPLAB IDE 8.33 và dùng phần hi-tec 9.65 nhưng khi mình search thì không thấy file (pic16f877a.h). Do vậy khi viết chương trình toàn báo ko tìm thấy con 16f877a. Mong các cao thủ giúp

04-02-2010, 07:35 PM	#3
kiemkhach10 Đệ tử 5 túi Tham gia ngày: Jan 2010 Bài gửi: 114 :	cám ơn bạn! bạn có thể chỉ mình rõ hơn ko? mình mới vào nghề nên kém lắm

05-02-2010, 10:53 AM	#5
kiemkhach10 Đệ tử 5 túi Tham gia ngày: Jan 2010 Bài gửi: 114 :	cám ơn bạn! cái khó là mình đã search nhưng ko có file pic16f877a trong phần cài đặt MPLAB và Hi-TEch PIC vậy nên ko bít coppy ở đâu

03-02-2010, 10:54 PM	#2
charlie Nhập môn đệ tử Tham gia ngày: Jan 2010 Bài gửi: 3 :	Cậu thử copy file p116f877a ở thư mục cài picc ra cùng thư mục với file project xem thế nào. Mình dùng ccs thì làm vậy còn ht thì ko được rõ lắm nhưng thấy ko ai trả lời nên góp ý vậy thôi. Cậu thử xem có được ko!

04-02-2010, 10:15 PM	#4
charlie Nhập môn đệ tử Tham gia ngày: Jan 2010 Bài gửi: 3 :	Tại vì mình ko dùng hi-tech nên ko được rõ lắm. Mình cũng chỉ mới làm quen với pic thôi trước đó thì mình chỉ lập trình trên avr (mới làm quen với avr được ít bữa thì thày bắt chuyển sang pic. Chán nghê). Thì thế này: Mình lập trình trên mplab (dùng ccs c để viết c) thì ví dụ mình tạo một project ở /desktop thì phải copy file p16f877a.h ở C:\Program Files\PICC\Devices\ ra ngoài desktop (nói chung là phải cùng thư mục với file project của mình) Cách khác cậu hãy thử chỉ ra đường dẫn cụ thể của thư viện xem sao vd: #include<"c:\....\p16f877a.h"> Cái này đáng kể để cho người khác làm về cái này nói thì chính xác hơn. Chẳng biết là có giup được gì cho cậu ko. Cậu thử xem nhé! Chúc thành công!

05-02-2010, 12:36 PM	#6
charlie Nhập môn đệ tử Tham gia ngày: Jan 2010 Bài gửi: 3 :	Cậu thử vào đây nhé: C:\Program Files\HI-TECH Software\PICC\9.70\include\