pic16lf720.h

picc

#ifndef	_HTC_H_
#warning Header file pic16lf720.h included directly. Use #include <htc.h> instead.
#endif

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

#ifndef __PIC16LF720_H
#define __PIC16LF720_H

//
// Configuration mask definitions
//

// Config Register: CONFIG
#define CONFIG               0x2007 
// EC oscillator: CLKO function on RA4/CLKO pin and CLKI on RA5/CLKI
#define FOSC_EC_OSC_CLKOUT   0xFFFF 
// EC oscillator: I/O function on RA4/CLKO pin and CLKI on RA5/CLKI
#define FOSC_EC_OSC_NOCLKOUT 0xFFFE 
// INTOSC oscillator: CLKO function on RA4 and I/O function on RA5
#define FOSC_INTOSC_CLKOUT   0xFFFD 
// INTOSC oscillator: I/O function on both RA4 and RA5
#define FOSC_INTOSC_NOCLKOUT 0xFFFC 
// Watchdog Timer
// WDT enabled
#define WDTEN_ON             0xFFFF 
// WDT disabled
#define WDTEN_OFF            0xFFF7 
// Power Up Timer
// PWRT disabled
#define PWRTE_OFF            0xFFFF 
// PWRT enabled
#define PWRTE_ON             0xFFEF 
// Master Clear Enable
// RA3 is digital input, nMCLR internally disabled, Weak pull up disabled
#define MCLRE_OFF            0xFFDF 
// RA3 is nMCLR, Weak pull up enabled
#define MCLRE_ON             0xFFFF 
// Code Protect
// Program memory code protection is disabled
#define CP_OFF               0xFFFF 
// Program memory code protection is enabled
#define CP_ON                0xFFBF 
// Brown out reset disabled
#define BOREN_OFF            0xFCFF 
// Brown out reset enabled during operation and disabled in Sleep
#define BOREN_NSLEEP         0xFEFF 
// Brown out reset enabled
#define BOREN_ON             0xFFFF 
// INTOSC PLLEN Enable Bit
// Internal oscillator is 16 MHz
#define PLLEN_ON             0xFFFF 
// Internal oscillator is 500 kHz
#define PLLEN_OFF            0xEFFF 
// Background Debug
// Background debugger is disabled
#define DEBUG_OFF            0xFFFF 
// Background debugger is enabled
#define DEBUG_ON             0xDFFF 


// Config Register: CONFIG2
#define CONFIG2              0x2009 
// Write protection off
#define WRTEN_OFF            0xFFFF 
// 0h to 1FFh of flash memory write protected, 200h to 7FFh may be modified
#define WRTEN_BOOT           0xFFFE 
// 0h to 3FFh of flash memory write protected, 400h to 7FFh may be modified
#define WRTEN_HALF           0xFFFD 
// 0h to 7FFh of flash memory write protected, no address may be modified
#define WRTEN_FULL           0xFFFC 
// All VCAP pin functions are disabled.
#define VCAPEN_OFF           0xFFFF 


//
// Special function register definitions: Bank 0
//

// 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;
#ifndef _LIB_BUILD
union {
    struct {
        volatile unsigned C                   : 1;
        volatile unsigned DC                  : 1;
        volatile unsigned Z                   : 1;
        volatile unsigned nPD                 : 1;
        volatile unsigned nTO                 : 1;
        volatile unsigned RP                  : 2;
        volatile unsigned IRP                 : 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
union {
    struct {
        volatile unsigned RA0                 : 1;
        volatile unsigned RA1                 : 1;
        volatile unsigned RA2                 : 1;
        volatile unsigned RA3                 : 1;
        volatile unsigned RA4                 : 1;
        volatile unsigned RA5                 : 1;
        volatile unsigned                     : 1;
        volatile unsigned : 1;
    };
} PORTAbits @ 0x005;
#endif

// Register: PORTB
volatile unsigned char           PORTB               @ 0x006;
// bit and bitfield definitions
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
union {
    struct {
        volatile unsigned                     : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned RB4                 : 1;
        volatile unsigned RB5                 : 1;
        volatile unsigned RB6                 : 1;
        volatile 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
union {
    struct {
        volatile unsigned RC0                 : 1;
        volatile unsigned RC1                 : 1;
        volatile unsigned RC2                 : 1;
        volatile unsigned RC3                 : 1;
        volatile unsigned RC4                 : 1;
        volatile unsigned RC5                 : 1;
        volatile unsigned RC6                 : 1;
        volatile unsigned RC7                 : 1;
    };
} PORTCbits @ 0x007;
#endif

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

// Register: INTCON
volatile unsigned char           INTCON              @ 0x00B;
// bit and bitfield definitions
volatile bit RABIF               @ ((unsigned)&INTCON*8)+0;
volatile bit INTF                @ ((unsigned)&INTCON*8)+1;
volatile bit TMR0IF              @ ((unsigned)&INTCON*8)+2;
volatile bit RABIE               @ ((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;
#ifndef _LIB_BUILD
union {
    struct {
        volatile unsigned RABIF               : 1;
        volatile unsigned INTF                : 1;
        volatile unsigned TMR0IF              : 1;
        volatile unsigned RABIE               : 1;
        volatile unsigned INTE                : 1;
        volatile unsigned TMR0IE              : 1;
        volatile unsigned PEIE                : 1;
        volatile unsigned GIE                 : 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 TMR1GIF             @ ((unsigned)&PIR1*8)+7;
////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 ADIF               @ ((unsigned)&PIR1*8)+6;
volatile bit PSPIF               @ ((unsigned)&PIR1*8)+7;
#ifndef _LIB_BUILD
union {
    struct {
        volatile unsigned TMR1IF              : 1;
        volatile unsigned TMR2IF              : 1;
        volatile unsigned CCP1IF              : 1;
        volatile unsigned SSPIF               : 1;
        volatile unsigned TXIF                : 1;
        volatile unsigned RCIF                : 1;
        volatile unsigned ADIF                : 1;
        volatile unsigned TMR1GIF             : 1;
    };
    struct {
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned : 1;
        volatile unsigned                     : 2;
        volatile unsigned : 1;
        volatile unsigned PSPIF               : 1;
    };
} PIR1bits @ 0x00C;
#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 T1SYNC              @ ((unsigned)&T1CON*8)+2;
#ifndef _LIB_BUILD
union {
    struct {
        volatile unsigned TMR1ON              : 1;
        volatile unsigned                     : 1;
        volatile unsigned T1SYNC              : 1;
        volatile unsigned : 1;
        volatile unsigned T1CKPS              : 2;
        volatile unsigned TMR1CS              : 2;
    };
} 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;
#ifndef _LIB_BUILD
union {
    struct {
        volatile unsigned T2CKPS              : 2;
        volatile unsigned TMR2ON              : 1;
        volatile unsigned TOUTPS              : 4;
    };
} T2CONbits @ 0x012;
#endif

// Register: SSPBUF