pic16lf1517.h

picc

} LATCbits @ 0x10E;
#endif

// Register: LATD
volatile unsigned char           LATD                @ 0x10F;
// bit and bitfield definitions
volatile bit LATD0               @ ((unsigned)&LATD*8)+0;
volatile bit LATD1               @ ((unsigned)&LATD*8)+1;
volatile bit LATD2               @ ((unsigned)&LATD*8)+2;
volatile bit LATD3               @ ((unsigned)&LATD*8)+3;
volatile bit LATD4               @ ((unsigned)&LATD*8)+4;
volatile bit LATD5               @ ((unsigned)&LATD*8)+5;
volatile bit LATD6               @ ((unsigned)&LATD*8)+6;
volatile bit LATD7               @ ((unsigned)&LATD*8)+7;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	LATD0               : 1;
        unsigned	LATD1               : 1;
        unsigned	LATD2               : 1;
        unsigned	LATD3               : 1;
        unsigned	LATD4               : 1;
        unsigned	LATD5               : 1;
        unsigned	LATD6               : 1;
        unsigned	LATD7               : 1;
    };
} LATDbits @ 0x10F;
#endif

// Register: LATE
volatile unsigned char           LATE                @ 0x110;
// bit and bitfield definitions
volatile bit LATE0               @ ((unsigned)&LATE*8)+0;
volatile bit LATE1               @ ((unsigned)&LATE*8)+1;
volatile bit LATE2               @ ((unsigned)&LATE*8)+2;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	LATE0               : 1;
        unsigned	LATE1               : 1;
        unsigned	LATE2               : 1;
        unsigned	                    : 1;
    };
    struct {
        unsigned	LATE                : 3;
        unsigned	: 5;
    };
} LATEbits @ 0x110;
#endif

// Register: BORCON
// Brown-out Reset Control Register
volatile unsigned char           BORCON              @ 0x116;
// bit and bitfield definitions
// Brown-out Reset Circuit Ready Status bit
volatile bit BORRDY              @ ((unsigned)&BORCON*8)+0;
volatile bit BORFS               @ ((unsigned)&BORCON*8)+6;
// Software Brown Out Reset Enable bit
volatile bit SBOREN              @ ((unsigned)&BORCON*8)+7;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	BORRDY              : 1;
        unsigned	                    : 5;
        unsigned	BORFS               : 1;
        unsigned	SBOREN              : 1;
    };
} BORCONbits @ 0x116;
#endif

// Register: FVRCON
// Voltage Reference Control Register 0
volatile unsigned char           FVRCON              @ 0x117;
// bit and bitfield definitions
// A/D Converter Fixed Voltage Reference Selection
volatile bit ADFVR0              @ ((unsigned)&FVRCON*8)+0;
// A/D Converter Fixed Voltage Reference Selection
volatile bit ADFVR1              @ ((unsigned)&FVRCON*8)+1;
// Fixed Voltage Reference Ready Flag
volatile bit FVRRDY              @ ((unsigned)&FVRCON*8)+6;
// Fixed Voltage Reference Enable
volatile bit FVREN               @ ((unsigned)&FVRCON*8)+7;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	ADFVR0              : 1;
        unsigned	ADFVR1              : 1;
        unsigned	                    : 1;
        unsigned	: 1;
        unsigned	: 1;
        unsigned	: 1;
        unsigned	FVRRDY              : 1;
        unsigned	FVREN               : 1;
    };
    struct {
        unsigned	ADFVR               : 2;
        unsigned	CDAFVR              : 2;
    };
} FVRCONbits @ 0x117;
#endif

// Register: APFCON
// Alternate Pin Function Control Register
volatile unsigned char           APFCON              @ 0x11D;
// bit and bitfield definitions
// CCP2 Input/Output Pin Selection
volatile bit CCP2SEL             @ ((unsigned)&APFCON*8)+0;
// SS Input Pin Selection
volatile bit SSSEL               @ ((unsigned)&APFCON*8)+1;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	CCP2SEL             : 1;
        unsigned	SSSEL               : 1;
        unsigned	                    : 1;
        unsigned	: 1;
        unsigned	: 1;
        unsigned	: 1;
        unsigned	: 1;
    };
} APFCONbits @ 0x11D;
#endif

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


// Register: ANSELA
volatile unsigned char           ANSELA              @ 0x18C;
// bit and bitfield definitions
volatile bit ANSA0               @ ((unsigned)&ANSELA*8)+0;
volatile bit ANSA1               @ ((unsigned)&ANSELA*8)+1;
volatile bit ANSA2               @ ((unsigned)&ANSELA*8)+2;
volatile bit ANSA3               @ ((unsigned)&ANSELA*8)+3;
volatile bit ANSA5               @ ((unsigned)&ANSELA*8)+5;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	ANSA0               : 1;
        unsigned	ANSA1               : 1;
        unsigned	ANSA2               : 1;
        unsigned	ANSA3               : 1;
        unsigned	                    : 1;
        unsigned	ANSA5               : 1;
        unsigned	: 1;
        unsigned	: 1;
    };
    struct {
        unsigned	ANSELA              : 6;
    };
} ANSELAbits @ 0x18C;
#endif

// Register: ANSELB
volatile unsigned char           ANSELB              @ 0x18D;
// bit and bitfield definitions
volatile bit ANSB0               @ ((unsigned)&ANSELB*8)+0;
volatile bit ANSB1               @ ((unsigned)&ANSELB*8)+1;
volatile bit ANSB2               @ ((unsigned)&ANSELB*8)+2;
volatile bit ANSB3               @ ((unsigned)&ANSELB*8)+3;
volatile bit ANSB4               @ ((unsigned)&ANSELB*8)+4;
volatile bit ANSB5               @ ((unsigned)&ANSELB*8)+5;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	ANSB0               : 1;
        unsigned	ANSB1               : 1;
        unsigned	ANSB2               : 1;
        unsigned	ANSB3               : 1;
        unsigned	ANSB4               : 1;
        unsigned	ANSB5               : 1;
        unsigned	                    : 2;
    };
    struct {
        unsigned	ANSELB              : 6;
    };
} ANSELBbits @ 0x18D;
#endif

// Register: ANSELC
volatile unsigned char           ANSELC              @ 0x18E;
// bit and bitfield definitions
volatile bit ANSC0               @ ((unsigned)&ANSELC*8)+0;
volatile bit ANSC1               @ ((unsigned)&ANSELC*8)+1;
volatile bit ANSC2               @ ((unsigned)&ANSELC*8)+2;
volatile bit ANSC3               @ ((unsigned)&ANSELC*8)+3;
volatile bit ANSC4               @ ((unsigned)&ANSELC*8)+4;
volatile bit ANSC5               @ ((unsigned)&ANSELC*8)+5;
volatile bit ANSC6               @ ((unsigned)&ANSELC*8)+6;
volatile bit ANSC7               @ ((unsigned)&ANSELC*8)+7;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	ANSC0               : 1;
        unsigned	ANSC1               : 1;
        unsigned	ANSC2               : 1;
        unsigned	ANSC3               : 1;
        unsigned	ANSC4               : 1;
        unsigned	ANSC5               : 1;
        unsigned	ANSC6               : 1;
        unsigned	ANSC7               : 1;
    };
} ANSELCbits @ 0x18E;
#endif

// Register: ANSELD
volatile unsigned char           ANSELD              @ 0x18F;
// bit and bitfield definitions
volatile bit ANSD0               @ ((unsigned)&ANSELD*8)+0;
volatile bit ANSD1               @ ((unsigned)&ANSELD*8)+1;
volatile bit ANSD2               @ ((unsigned)&ANSELD*8)+2;
volatile bit ANSD3               @ ((unsigned)&ANSELD*8)+3;
volatile bit ANSD4               @ ((unsigned)&ANSELD*8)+4;
volatile bit ANSD5               @ ((unsigned)&ANSELD*8)+5;
volatile bit ANSD6               @ ((unsigned)&ANSELD*8)+6;
volatile bit ANSD7               @ ((unsigned)&ANSELD*8)+7;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	ANSD0               : 1;
        unsigned	ANSD1               : 1;
        unsigned	ANSD2               : 1;
        unsigned	ANSD3               : 1;
        unsigned	ANSD4               : 1;
        unsigned	ANSD5               : 1;
        unsigned	ANSD6               : 1;
        unsigned	ANSD7               : 1;
    };
} ANSELDbits @ 0x18F;
#endif

// Register: ANSELE
volatile unsigned char           ANSELE              @ 0x190;
// bit and bitfield definitions
volatile bit ANSE0               @ ((unsigned)&ANSELE*8)+0;
volatile bit ANSE1               @ ((unsigned)&ANSELE*8)+1;
volatile bit ANSE2               @ ((unsigned)&ANSELE*8)+2;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	ANSE0               : 1;
        unsigned	ANSE1               : 1;
        unsigned	ANSE2               : 1;
        unsigned	                    : 5;
    };
    struct {
        unsigned	ANSELE              : 3;
    };
} ANSELEbits @ 0x190;
#endif
// bit and bitfield definitions

// Register: PMADRL
volatile unsigned char           PMADRL              @ 0x191;
// bit and bitfield definitions

// Register: PMADRH
volatile unsigned char           PMADRH              @ 0x192;
// bit and bitfield definitions
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	PMADRH              : 7;
    };
} PMADRHbits @ 0x192;
#endif

// Register: PMADR
volatile unsigned int            PMADR               @ 0x191;
// bit and bitfield definitions

// Register: PMDATL
volatile unsigned char           PMDATL              @ 0x193;
// bit and bitfield definitions

// Register: PMDATH
volatile unsigned char           PMDATH              @ 0x194;
// bit and bitfield definitions
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	PMDATH              : 6;
    };
} PMDATHbits @ 0x194;
#endif

// Register: PMDAT
volatile unsigned int            PMDAT               @ 0x193;

// Register: PMCON1
volatile unsigned char           PMCON1              @ 0x195;
// bit and bitfield definitions
// Read Control bit
volatile bit RD                  @ ((unsigned)&PMCON1*8)+0;
// Write Control bit
volatile bit WR                  @ ((unsigned)&PMCON1*8)+1;
// Program/Erase Enable bit
volatile bit WREN                @ ((unsigned)&PMCON1*8)+2;
// Sequence Error Flag bit
volatile bit WRERR               @ ((unsigned)&PMCON1*8)+3;
// Program FLASH Erase Enable bit
volatile bit FREE                @ ((unsigned)&PMCON1*8)+4;
// Load Write Latches Only bit
volatile bit LWLO                @ ((unsigned)&PMCON1*8)+5;
// FLASH Program / Data EEPROM or Configuration Select bit
volatile bit CFGS                @ ((unsigned)&PMCON1*8)+6;
#ifndef _LIB_BUILD
volatile union {
    struct {
        unsigned	RD                  : 1;
        unsigned	WR                  : 1;
        unsigned	WREN                : 1;
        unsigned	WRERR               : 1;
        unsigned	FREE                : 1;
        unsigned	LWLO                : 1;
        unsigned	CFGS                : 1;
        unsigned	                    : 1;
    };
} PMCON1bits @ 0x195;
#endif

// Register: PMCON2
volatile unsigned char           PMCON2              @ 0x196;
// bit and bitfield definitions

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

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

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

// Register: SPBRGH
volatile unsigned char           SPBRGH              @ 0x19C;
// bit and bitfield definitions

// Register: RCSTA
// Receive Status and Control Register
volatile unsigned char           RCSTA               @ 0x19D;
// bit and bitfield definitions
// 9th bit of received data (can be parity bit)
volatile bit RX9D                @ ((unsigned)&RCSTA*8)+0;
// Overrun Error bit
volatile bit OERR                @ ((unsigned)&RCSTA*8)+1;
// Framing Error bit
volatile bit FERR                @ ((unsigned)&RCSTA*8)+2;
// Address Detect Enable bit
volatile bit ADDEN               @ ((unsigned)&RCSTA*8)+3;
// Continuous Receive Enable bit
volatile bit CREN                @ ((unsigned)&RCSTA*8)+4;
// Single Receive Enable bit
volatile bit SREN                @ ((unsigned)&RCSTA*8)+5;
// 9-bit Receive Enable bit
volatile bit RX9                 @ ((unsigned)&RCSTA*8)+6;