NOTE: the PPS.bas module is now included as part of the standard libraries as of V2.2.3.0
This module allows you to assign the remappable input and output pins for devices that have a Peripheral Pin Select (PPS) module.
Currently, the PPS module is only present in certain "J" and "K" series devices, and the number of pins/function varies depending on the device, so consult the datasheet.
V1.5 adds support for xxQ10 family and corrects some K40 assignments
V1.41 errata for 24K40/25K40
V1.4 adds support for the xxK40 family
V1.3 added support for the J94/J99 family
device = 18F47J53 include "pps.bas" // //------------------------------------------------------------------------------ // example usage - 47J53 //------------------------------------------------------------------------------ // sub init_pps() // unlock pps registers for change (disables interrupts) pps.unlock() // assign intr pins pps.assign_input(PPS_INT1, PPS_IN_RP3) // INT1 -> RB0 pps.assign_input(PPS_INT3, PPS_IN_RP6) // INT3 -> RB3 // assign uart2 pins pps.assign_input(PPS_RX2, PPS_IN_RP24) // RX2 -> RD7 pps.assign_output(PPS_TX2, PPS_OUT_RP23) // TX2 <- RD6 // assign spi2 (master) pps.assign_output(PPS_SCK2, PPS_OUT_RP20) // SCK2 <- RD3 pps.assign_input(PPS_SDI2, PPS_IN_RP21) // SDI2 -> RD4 pps.assign_output(PPS_SDO2, PPS_OUT_RP22) // SDO2 <- RD5 // relock pps config (restores interrupt enable) pps.lock() end sub // start of main code main: // reset all the pps assignments to default pps.assign_defaults() init_pps()
// //------------------------------------------------------------------------------ // Name : pps.bas // Author : Jerry Messina // Date : 7/22/2018 // Version : 1.50 // Notes : Peripheral Pin Select (PPS) module // : This peripheral is available in select J, K, and Q series devices // : (see PPS module type definitions below for a list of supported devices) // // ver 1.50: change 24K40,25K40 output mapping to match datasheet 40001843D (PPS_V5_1) // : add support for 24Q10,25Q10 (PPS_V6_1) // : add prelim support for 26Q10,27Q10,45Q10,46Q10,47Q10 (PPS_V6_2) // ver 1.41: incorporate output register mapping errata for 24K40/25K40 (PPS_V5_1) // ver 1.4 : add support for xxK40 family // : this family is slightly different so check assign_input/assign_output // : examples // : fix errors from xc8 pps.h for 4xJ50 // ver 1.3 : add support for J94/J99 (PPS_V4) PPS Lite module // : split PPS_V3 into two groups (J13 and J53 devices are different) // : change pin definitions from previous version to support V4 // : add #option PPS_IOL1WAY to enable changes to the config w/out editing // : fix errors from XC8 pps.h // ver 1.2 : add definitions for PPS_V3 RP17/RP18 pins //------------------------------------------------------------------------------ // module pps // //------------------------------------------------------------------------------ // PPS module type definitions // list of devices is current as of MPLABX v4.10 (MPASMX 5.77) // V1.4 adds the K40 family (PPS_V5 devices), which are not supported by XC8 plibs // V1.5 adds the Q10 family (PPS_V6 devices) // notes: // taken from XC8 v1.33 pconfig.h/pps.h (and C18 v3.47) // note: pconfig.h lumps the J13 and J53 devices together into PPS_V3, but they // have to be split into two groups (V3 and V3B) because of RPOR14/15/16 // also, some of the mappings in pps.h aren't correct, esp for the V4 devices // (V4 devices don't work at all in XC8) //------------------------------------------------------------------------------ // #if _device in (18F24J50, 18F25J50, 18F26J50) #define PPS_V1 #elseif _device in (18F24J11, 18F25J11, 18F26J11) #define PPS_V1_1 #elseif _device in (18F44J50, 18F45J50, 18F46J50) #define PPS_V2 #elseif _device in (18F44J11, 18F45J11, 18F46J11) #define PPS_V2_1 #elseif _device in (18F26J13, 18F27J13) #define PPS_V3 #elseif _device in (18F26J53, 18F27J53) #define PPS_V3B #elseif _device in (18F46J13, 18F47J13) #define PPS_V3_1 #elseif _device in (18F46J53, 18F47J53) #define PPS_V3B_1 #elseif _device in (18F65J94, 18F66J94, 18F67J94) or _ _device in (18F85J94, 18F86J94, 18F87J94, 18F95J94, 18F96J94, 18F97J94) or _ _device in (18F66J99, 18F86J99, 18F96J99) #define PPS_V4 #elseif _device in (18F24K40, 18F25K40, 18LF24K40, 18LF25K40) #define PPS_V5_1 #elseif _device in (18F26K40, 18F27K40, 18LF26K40, 18LF27K40) #define PPS_V5_1B #elseif _device in (18F45K40, 18F46K40, 18F47K40, 18LF45K40, 18LF46K40, 18LF47K40) #define PPS_V5_2 #elseif _device in (18F65K40, 18F66K40, 18F67K40, 18LF65K40, 18LF66K40, 18LF67K40) #define PPS_V5_3 #elseif _device in (18F24Q10, 18F25Q10) #define PPS_V6_1 #elseif _device in (18F26Q10, 18F45Q10, 18F46Q10, 18F27Q10, 18F47Q10) #define PPS_V6_2 #else #error _device + " unknown PPS module type" #endif // //------------------------------------------------------------------------------ // PPS CONFIG settings //------------------------------------------------------------------------------ // // There is a CONFIG bit (IOL1WAY/PPS1WAY) that will prevent you from changing // the pps mapping more than once, and it defaults to ON. You must set the config // setting off if you want to be able to remap them more than once #option PPS_IOL1WAY = OFF // K40 device #if defined(PPS_V5_1) or defined(PPS_V5_1B) or defined(PPS_V5_2) or defined(PPS_V5_3) config PPS1WAY = PPS_IOL1WAY // Q10 device #elseif defined(PPS_V6_1) or defined(PPS_V6_2) config PPS1WAY = PPS_IOL1WAY // all others #else config IOL1WAY = PPS_IOL1WAY #endif // the lock() and unlock() sequences are timing sensitive. by default, the routines // will manage the state of the global IE bit... lock() will disable interrupts and // unlock() will restore the setting that was in effect when lock() was initially // called. setting 'PPS_DISABLE_INT = false' will bypass this #option PPS_DISABLE_INT = true // //------------------------------------------------------------------------------ // PPS input //------------------------------------------------------------------------------ // // pps input pin definitions #if defined (PPS_V1) or defined (PPS_V1_1) or defined (PPS_V2) or defined (PPS_V2_1) or _ defined (PPS_V3) or defined (PPS_V3_1) or defined (PPS_V3B) or defined (PPS_V3B_1) public const PPS_IN_VSS = 31 // RPxx Input tied to Vss (unused) public const PPS_IN_RP0 = 0 // assign RP0 as Input Pin public const PPS_IN_RP1 = 1 // assign RP1 as Input Pin public const PPS_IN_RP2 = 2 // assign RP2 as Input Pin public const PPS_IN_RP3 = 3 // assign RP3 as Input Pin public const PPS_IN_RP4 = 4 // assign RP4 as Input Pin public const PPS_IN_RP5 = 5 // assign RP5 as Input Pin public const PPS_IN_RP6 = 6 // assign RP6 as Input Pin public const PPS_IN_RP7 = 7 // assign RP7 as Input Pin public const PPS_IN_RP8 = 8 // assign RP8 as Input Pin public const PPS_IN_RP9 = 9 // assign RP9 as Input Pin public const PPS_IN_RP10 = 10 // assign RP10 as Input Pin public const PPS_IN_RP11 = 11 // assign RP11 as Input Pin public const PPS_IN_RP12 = 12 // assign RP12 as Input Pin public const PPS_IN_RP13 = 13 // assign RP13 as Input Pin // alias name for unmapping an input pin public const PPS_IN_UNUSED = PPS_IN_VSS #endif // (PPS_V1) or (PPS_V1_1) or (PPS_V2) or (PPS_V2_1) or (PPS_V3) or (PPS_V3_1) or (PPS_V3B) or (PPS_V3B_1) #if defined (PPS_V1_1) or defined (PPS_V2_1) public const PPS_IN_RP14 = 14 // assign RP14 as Input Pin public const PPS_IN_RP15 = 15 // assign RP15 as Input Pin public const PPS_IN_RP16 = 16 // assign RP16 as Input Pin #endif // (PPS_V1_1) or (PPS_V2_1) #if defined (PPS_V1) or defined (PPS_V2) or defined (PPS_V2_1) or defined (PPS_V3_1) or defined (PPS_V3B_1) public const PPS_IN_RP17 = 17 // assign RP17 as Input Pin public const PPS_IN_RP18 = 18 // assign RP18 as Input Pin #endif // (PPS_V1) or (PPS_V2) or (PPS_V2_1) or (PPS_V3_1) or (PPS_V3B_1) #if defined (PPS_V2) or defined (PPS_V2_1) or defined (PPS_V3_1) or defined (PPS_V3B_1) public const PPS_IN_RP19 = 19 // assign RP19 as Input Pin public const PPS_IN_RP20 = 20 // assign RP20 as Input Pin public const PPS_IN_RP21 = 21 // assign RP21 as Input Pin public const PPS_IN_RP22 = 22 // assign RP22 as Input Pin public const PPS_IN_RP23 = 23 // assign RP23 as Input Pin public const PPS_IN_RP24 = 24 // assign RP24 as Input Pin #endif // (PPS_V2) or (PPS_V2_1) or (PPS_V3_1) or (PPS_V3B_1) #if defined (PPS_V4) public const PPS_IN_VSS = $0F // RPxx Input tied to Vss (unused) // GROUP 4n public const PPS_IN_RP0 = 0 // assign RP0 as Input Pin public const PPS_IN_RP4 = 1 // assign RP1 as Input Pin public const PPS_IN_RP8 = 2 // assign RP2 as Input Pin public const PPS_IN_RP12 = 3 // assign RP3 as Input Pin public const PPS_IN_RP16 = 4 // assign RP4 as Input Pin public const PPS_IN_RP20 = 5 // assign RP5 as Input Pin public const PPS_IN_RP24 = 6 // assign RP6 as Input Pin public const PPS_IN_RP28 = 7 // assign RP7 as Input Pin public const PPS_IN_RP32 = 8 // assign RP8 as Input Pin public const PPS_IN_RP36 = 9 // assign RP9 as Input Pin public const PPS_IN_RP40 = $0A // assign RP10 as Input Pin public const PPS_IN_RP44 = $0B // assign RP11 as Input Pin // GROUP (4n+1) public const PPS_IN_RP1 = 0 // assign RP0 as Input Pin public const PPS_IN_RP5 = 1 // assign RP1 as Input Pin public const PPS_IN_RP9 = 2 // assign RP2 as Input Pin public const PPS_IN_RP13 = 3 // assign RP3 as Input Pin public const PPS_IN_RP17 = 4 // assign RP4 as Input Pin public const PPS_IN_RP21 = 5 // assign RP5 as Input Pin public const PPS_IN_RP25 = 6 // assign RP6 as Input Pin public const PPS_IN_RP29 = 7 // assign RP7 as Input Pin public const PPS_IN_RP33 = 8 // assign RP8 as Input Pin public const PPS_IN_RP37 = 9 // assign RP9 as Input Pin public const PPS_IN_RP41 = $0A // assign RP10 as Input Pin public const PPS_IN_RP45 = $0B // assign RP11 as Input Pin // GROUP (4n+2) public const PPS_IN_RP2 = 0 // assign RP0 as Input Pin public const PPS_IN_RP6 = 1 // assign RP1 as Input Pin public const PPS_IN_RP10 = 2 // assign RP2 as Input Pin public const PPS_IN_RP14 = 3 // assign RP3 as Input Pin public const PPS_IN_RP18 = 4 // assign RP4 as Input Pin public const PPS_IN_RP22 = 5 // assign RP5 as Input Pin public const PPS_IN_RP26 = 6 // assign RP6 as Input Pin public const PPS_IN_RP30 = 7 // assign RP7 as Input Pin public const PPS_IN_RP34 = 8 // assign RP8 as Input Pin public const PPS_IN_RP38 = 9 // assign RP9 as Input Pin public const PPS_IN_RP42 = $0A // assign RP10 as Input Pin public const PPS_IN_RP46 = $0B // assign RP11 as Input Pin // GROUP (4n+3) public const PPS_IN_RP3 = 0 // assign RP0 as Input Pin public const PPS_IN_RP7 = 1 // assign RP1 as Input Pin public const PPS_IN_RP11 = 2 // assign RP2 as Input Pin public const PPS_IN_RP15 = 3 // assign RP3 as Input Pin public const PPS_IN_RP19 = 4 // assign RP4 as Input Pin public const PPS_IN_RP23 = 5 // assign RP5 as Input Pin public const PPS_IN_RP27 = 6 // assign RP6 as Input Pin public const PPS_IN_RP31 = 7 // assign RP7 as Input Pin public const PPS_IN_RP35 = 8 // assign RP8 as Input Pin public const PPS_IN_RP39 = 9 // assign RP9 as Input Pin public const PPS_IN_RP43 = $0A // assign RP10 as Input Pin public const PPS_IN_RP47 = $0B // assign RP11 as Input Pin // alias name for unmapping an input pin public const PPS_IN_UNUSED = PPS_IN_VSS #endif // (PPS_V4) // pps input functions #if defined (PPS_V1) or defined (PPS_V1_1) or defined (PPS_V2) or defined (PPS_V2_1) or _ defined (PPS_V3) or defined (PPS_V3_1) or defined (PPS_V3B) or defined (PPS_V3B_1) public dim PPS_INT1 as RPINR1 // assign External Interrupt 1 (INTR1) to the RPn pin public dim PPS_INT2 as RPINR2 // assign External Interrupt 2 (INTR2) to the RPn pin public dim PPS_INT3 as RPINR3 // assign External Interrupt 3 (INTR3) to the RPn pin public dim PPS_T0CK as RPINR4 // assign Timer0 External Clock (T0CK) to the RPn pin public dim PPS_T3CK as RPINR6 // assign Timer3 External Clock (T3CK) to the RPn pin public dim PPS_IC1 as RPINR7 // assign Input Capture 1 (IC1) to the RPn pin public dim PPS_IC2 as RPINR8 // assign Input Capture 2 (IC2) to the RPn pin public dim PPS_T1G as RPINR12 // assign Timer1 External Gate Input (TG1) to the RPn pin public dim PPS_T3G as RPINR13 // assign Timer3 External Gate Input (TG3) to the RPn pin public dim PPS_RX2 as RPINR16 // assign EUSART2 Async/Sync Receive (RX2/DT2) to the RPn pin public dim PPS_CK2 as RPINR17 // assign EUSART2 Sync Slave Clock Input (CK2) to the RPn pin public dim PPS_SDI2 as RPINR21 // assign SDI2 Data Input (SDI2) to the RPn pin public dim PPS_SCK2IN as RPINR22 // assign SCK2 Clock Input (SCK2IN) to the RPn pin public dim PPS_SS2IN as RPINR23 // assign SS2 Slave Select Input (SS2IN) to the RPn pin public dim PPS_FLT0 as RPINR24 // assign PWM Fault Input (FLT0) to the RPn pin #endif // (PPS_V1) or (PPS_V1_1) or (PPS_V2) or (PPS_V2_1) od (PPS_V3) or (PPS_V3_1) or (PPS_V3B) or (PPS_V3B_1) #if defined (PPS_V3) or defined (PPS_V3_1) or defined (PPS_V3B) or defined (PPS_V3B_1) public dim PPS_T5CK as RPINR15 // assign Timer5 External Clock (T5CK) to the RPn pin public dim PPS_IC3 as RPINR9 // assign Input Capture 3 (IC3) to the RPn pin public dim PPS_T5G as RPINR14 // assign Timer5 External Gate Input (TG5) to the RPn pin #endif // (PPS_V3) or (PPS_V3_1) or (PPS_V3B_1) // the PPS Lite module splits the RPINR registers into two nibbles with certain functions // assigned to each of the upper and lower nibbles. in order to use a macro for this we need // a unique value for each input function so that we can place the setting in the proper spot. // we just assign numbers to the functions in increasing order... the number itself isn't // important as the macro will translate PPS_xxx input functions to RPINRxx registers // some input function names had to be changed so that there is a unique input/output function // (ie PPS_CCPx, PPS_PBIOx, etc) // #if defined (PPS_V4) // GROUP 4n public const PPS_SDI1 = 0 // assign SDI1 Data input (SDI1) to the RPn pin public const PPS_FLT0 = 1 // assign PWM Fault Input (FLT0) to the RPn pin public const PPS_IOC0 = 2 // assign InterruptOnChange0 (IOC0) to the RPn pin public const PPS_IOC4 = 3 // assign InterruptOnChange4 (IOC4) to the RPn pin public const PPS_MDCIN1 = 4 // assign MDCIN1 to the RPn pin public const PPS_T0CKI = 5 // assign Timer0 External Clock (T0CKI) to the RPn pin public const PPS_T5G = 6 // assign Timer5 External Gate Input (T5G) to the RPn pin public const PPS_U3RX = 7 // assign EUSART3 Async/Sync Receive (RX3/DT3) to the RPn pin public const PPS_U4RX = 8 // assign EUSART4 Async/Sync Receive (RX4/DT4) to the RPn pin public const PPS_IC5 = 9 // assign Input Capture 5 (CCP5) to the RPn pin public const PPS_IC8 = 10 // assign Input Capture 8 (CCP8) to the RPn pin public const PPS_PBI0 = 11 // assign PBIO0 to the RPn pin (Virtual port?) public const PPS_PBI4 = 12 // assign PBIO4 to the RPn pin // GROUP (4n+1) public const PPS_SDI2 = 13 // assign SDI1 Data input (SDI2) to the RPn pin public const PPS_INT1 = 14 // assign External Interrupt 1 (INTR1) to the RPn pin public const PPS_IOC1 = 15 // assign InterruptOnChange1 (IOC1) to the RPn pin public const PPS_IOC5 = 16 // assign InterruptOnChange5 (IOC5) to the RPn pin public const PPS_MDCIN2 = 17 // assign MDCIN2 to the RPn pin public const PPS_T1CKI = 18 // assign Timer1 External Clock (T1CKI) to the RPn pin public const PPS_T1G = 19 // assign Timer1 External Gate Input (T1G) to the RPn pin public const PPS_T3CKI = 20 // assign Timer3 External Clock (T3CKI) to the RPn pin public const PPS_T3G = 21 // assign Timer3 External Gate Input (T3G) to the RPn pin public const PPS_T5CKI = 22 // assign Timer5 External Clock (T5CKI) to the RPn pin public const PPS_U3TX_CKI = 23 // assign EUSART3 Sync Clock In (TX3/CK3) to the RPn pin public const PPS_U4TX_CKI = 24 // assign EUSART4 Sync Clock In (TX4/CK4) to the RPn pin public const PPS_IC7 = 25 // assign Input Capture 7 (CCP7) to the RPn pin public const PPS_IC9 = 26 // assign Input Capture 9 (CCP9) to the RPn pin public const PPS_PBI1 = 27 // assign PBIO1 to the RPn pin public const PPS_PBI5 = 28 // assign PBIO5 to the RPn pin // GROUP (4n+2) public const PPS_SS1 = 29 // assign SS1 (SS1) to the RPn pin public const PPS_INT2 = 30 // assign External Interrupt 2 (INTR2) to the RPn pin public const PPS_IOC2 = 31 // assign InterruptOnChange2 (IOC2) to the RPn pin public const PPS_IOC6 = 32 // assign InterruptOnChange6 (IOC6) to the RPn pin public const PPS_MDMIN = 33 // assign MDMIN to the RPn pin public const PPS_U1TX_CKI = 34 // assign EUSART1 Sync Clock In (TX1/CK1) to the RPn pin public const PPS_U2RX = 35 // assign EUSART2 Async/Sync Receive (RX2/DT2) to the RPn pin public const PPS_SCK2IN = 36 // assign SCK2 to the RPn pin public const PPS_ECCP3 = 37 // assign ECCP3 to the RPn pin public const PPS_IC6 = 38 // assign Input Capture 6 (CCP6) to the RPn pin public const PPS_IC10 = 39 // assign Input Capture 10 (CCP10) to the RPn pin public const PPS_PBI2 = 40 // assign PBIO2 to the RPn pin public const PPS_PBI6 = 41 // assign PBIO6 to the RPn pin // GROUP (4n+3) public const PPS_SS2 = 42 // assign SS2 (SS2) to the RPn pin public const PPS_INT3 = 43 // assign External Interrupt 3 (INTR3) to the RPn pin public const PPS_IOC3 = 44 // assign InterruptOnChange3 (IOC3) to the RPn pin public const PPS_IOC7 = 45 // assign InterruptOnChange7 (IOC7) to the RPn pin public const PPS_U1RX = 46 // assign EUSART1 Async/Sync Receive (RX1/DT1) to the RPn pin public const PPS_U2TX_CKI = 47 // assign EUSART2 Sync Clock In (TX2/CK2) to the RPn pin public const PPS_SCK1IN = 48 // assign SCK1 to the RPn pin public const PPS_ECCP1 = 49 // assign ECCP1 to the RPn pin public const PPS_ECCP2 = 50 // assign ECCP2 to the RPn pin public const PPS_IC4 = 51 // assign Input Capture 4 (CCP4) to the RPn pin public const PPS_PBI3 = 52 // assign PBIO2 to the RPn pin public const PPS_PBI7 = 53 // assign PBIO6 to the RPn pin #endif // (PPS_V4) // K40 family device #if defined(PPS_V5_1) or defined(PPS_V5_1B) or defined(PPS_V5_2) or defined(PPS_V5_3) // Register Definitions: PPS Input Selection // xxxPPS<4:3> Peripheral xxx Input PORTx Selection bits public const PPS_PORTA as byte = %0000, PPS_PORTB as byte = %0001, PPS_PORTC as byte = %0010 // 18(L)F4xK40, 18(L)F6xK40 #if defined(PPS_V5_2) or defined(PPS_V5_3) public const PPS_PORTD as byte = %0011 #endif // 4xK40, 6xK40 // 18(L)F6xK40 #if defined(PPS_V5_3) public const PPS_PORTE as byte = %0100, PPS_PORTF as byte = %0101, PPS_PORTG as byte = %0110, PPS_PORTH as byte = %0111 #endif // 6xK40 // xxxPPS<2:0>: Peripheral xxx Input PINx Pin Selection bits // pin selection bits are three bits 0-7, ie port pin 0(Rx0) = 0, port pin 7(Rx7) = 7 // xxxPPS<4:3>: Peripheral xxx Input PORTx Pin Selection bits // port selection bits are four bits 0-3: 0000=PORTA, 0001=PORTB, 0010=PORTC, 0011=PORTD, etc // K40 family // assign_input(input_function_reg, pps_port, pin_no) // // assigns pps input function to a pin // input_function_reg pps input register/function (ie INT0PPS) from datasheet TABLE 17-1 // pps_port one of PPS_PORTA to PPS_PORTH definitions above // pin_no port pin number 0-7 // // to assign an input function to a pin set xxxPPS reg input PORT bits[4:3] and PIN bits[2:0]: // xxxPPS = (PPS_PORTx << 3) + (port_pin_no and %111) // macro example: // pps.assign_input(INT0PPS, PPS_PORTA, 4) // assigns INT0 input to RA4 // pps.assign_input(RX1PPS, PPS_PORTB, 2) // assigns usart RX1 input to RB2 // note: pps input functions are limited to specific ports // currently the macro does not check to see if the assignment is valid (nothing does) // refer to TABLE 17-1: PPS INPUT REGISTER DETAILS in the device datasheet for specifics // public macro assign_input(pps_function_reg, pps_port, pin_no) pps_function_reg = ((pps_port and %0111) << 3) + (pin_no and %111) end macro // Q10 family device #elseif defined(PPS_V6_1) or defined(PPS_V6_2) // Register Definitions: PPS Input Selection // xxxPPS<4:3> Peripheral xxx Input PORTx Selection bits public const PPS_PORTA as byte = %0000, PPS_PORTB as byte = %0001, PPS_PORTC as byte = %0010 // 18F4xQ10 #if _device in(18F45Q10, 18F46Q10, 18F47Q10) public const PPS_PORTD as byte = %0011 #endif // 4xQ10 // xxxPPS<2:0>: Peripheral xxx Input PINx Pin Selection bits // pin selection bits are three bits 0-7, ie port pin 0(Rx0) = 0, port pin 7(Rx7) = 7 // xxxPPS<4:3>: Peripheral xxx Input PORTx Pin Selection bits // port selection bits are two bits 0-1: 00=PORTA, 01=PORTB, 10=PORTC, 11=PORTD // Q10 family (similar to K40) // assign_input(input_function_reg, pps_port, pin_no) // // assigns pps input function to a pin // input_function_reg pps input register/function (ie INT0PPS) from datasheet TABLE 17-1 // pps_port one of PPS_PORTA to PPS_PORTD definitions above // pin_no port pin number 0-7 // // to assign an input function to a pin set xxxPPS reg input PORT bits[4:3] and PIN bits[2:0]: // xxxPPS = (PPS_PORTx << 3) + (port_pin_no and %111) // macro example: // pps.assign_input(INT0PPS, PPS_PORTA, 4) // assigns INT0 input to RA4 // pps.assign_input(RX1PPS, PPS_PORTB, 2) // assigns usart RX1 input to RB2 // note: pps input functions are limited to specific ports // currently the macro does not check to see if the assignment is valid (nothing does) // refer to TABLE 17-1: PPS INPUT REGISTER DETAILS in the device datasheet for specifics // public macro assign_input(pps_function_reg, pps_port, pin_no) pps_function_reg = ((pps_port and %0111) << 3) + (pin_no and %111) end macro // J94/J99 family #elseif defined(PPS_V4) //------------------------------------------------------------------------------ // assign_input(input_fn, rp_pin) // // assigns pps input function to a pin // input_fn input function/register (ie PPS_RX2) // rp_pin PPS_IN_RPx pin (ie PPS_IN_RP0) // example usage: // assign_input(PPS_INT1, PPS_IN_UNUSED) 'unmaps INT1 function // assign_input(PPS_RX2, PPS_IN_RP0) 'sets RPINR16 to RP0 pin // //------------------------------------------------------------------------------ public macro assign_input(input_fn, rp_pin) // for the PPS Lite module we need to translate input "function numbers" // to register and upper/lower nibble selection. just do it brute force // since the macro will remove all the unused code // taken from J94/J99 family datasheet Table 11-12 // functions that use the lower nibble of the RPINRxx reg if (input_fn = PPS_PBI6) then RPINR52_53 = (RPINR52_53 and $F0) or rp_pin elseif (input_fn = PPS_PBI4) then RPINR50_51 = (RPINR50_51 and $F0) or rp_pin elseif (input_fn = PPS_PBI2) then RPINR48_49 = (RPINR48_49 and $F0) or rp_pin elseif (input_fn = PPS_PBI0) then RPINR46_47 = (RPINR46_47 and $F0) or rp_pin elseif (input_fn = PPS_T5G) then RPINR44_45 = (RPINR44_45 and $F0) or rp_pin elseif (input_fn = PPS_T3G) then RPINR42_43 = (RPINR42_43 and $F0) or rp_pin elseif (input_fn = PPS_T1G) then RPINR40_41 = (RPINR40_41 and $F0) or rp_pin elseif (input_fn = PPS_IC10) then RPINR38_39 = (RPINR38_39 and $F0) or rp_pin elseif (input_fn = PPS_IC8) then RPINR36_37 = (RPINR36_37 and $F0) or rp_pin elseif (input_fn = PPS_IC6) then RPINR34_35 = (RPINR34_35 and $F0) or rp_pin elseif (input_fn = PPS_IC4) then RPINR32_33 = (RPINR32_33 and $F0) or rp_pin elseif (input_fn = PPS_MDCIN1) then RPINR30_31 = (RPINR30_31 and $F0) or rp_pin elseif (input_fn = PPS_INT3) then RPINR28_29 = (RPINR28_29 and $F0) or rp_pin elseif (input_fn = PPS_INT1) then RPINR26_27 = (RPINR26_27 and $F0) or rp_pin elseif (input_fn = PPS_IOC6) then RPINR24_25 = (RPINR24_25 and $F0) or rp_pin elseif (input_fn = PPS_IOC4) then RPINR22_23 = (RPINR22_23 and $F0) or rp_pin elseif (input_fn = PPS_IOC2) then RPINR20_21 = (RPINR20_21 and $F0) or rp_pin elseif (input_fn = PPS_IOC0) then RPINR18_19 = (RPINR18_19 and $F0) or rp_pin elseif (input_fn = PPS_ECCP2) then RPINR16_17 = (RPINR16_17 and $F0) or rp_pin elseif (input_fn = PPS_FLT0) then RPINR14_15 = (RPINR14_15 and $F0) or rp_pin elseif (input_fn = PPS_SDI2) then RPINR12_13 = (RPINR12_13 and $F0) or rp_pin elseif (input_fn = PPS_SS1) then RPINR10_11 = (RPINR10_11 and $F0) or rp_pin elseif (input_fn = PPS_SCK1IN) then RPINR8_9 = (RPINR8_9 and $F0) or rp_pin elseif (input_fn = PPS_U4RX) then RPINR6_7 = (RPINR6_7 and $F0) or rp_pin elseif (input_fn = PPS_U3RX) then RPINR4_5 = (RPINR4_5 and $F0) or rp_pin elseif (input_fn = PPS_U2RX) then RPINR2_3 = (RPINR2_3 and $F0) or rp_pin elseif (input_fn = PPS_U1RX) then RPINR0_1 = (RPINR0_1 and $F0) or rp_pin endif // functions that use the upper nibble of the RPINRxx reg if (input_fn = PPS_U1TX_CKI) then RPINR0_1 = (RPINR0_1 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_U2TX_CKI) then RPINR2_3 = (RPINR2_3 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_U3TX_CKI) then RPINR4_5 = (RPINR4_5 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_U4TX_CKI) then RPINR6_7 = (RPINR6_7 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_SDI1) then RPINR8_9 = (RPINR8_9 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_SCK2IN) then RPINR10_11 = (RPINR10_11 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_SS2) then RPINR12_13 = (RPINR12_13 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_ECCP1) then RPINR14_15 = (RPINR14_15 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_ECCP3) then RPINR16_17 = (RPINR16_17 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IOC1) then RPINR18_19 = (RPINR18_19 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IOC3) then RPINR20_21 = (RPINR20_21 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IOC5) then RPINR22_23 = (RPINR22_23 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IOC7) then RPINR24_25 = (RPINR24_25 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_INT2) then RPINR26_27 = (RPINR26_27 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_MDMIN) then RPINR28_29 = (RPINR28_29 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_MDCIN2) then RPINR30_31 = (RPINR30_31 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IC5) then RPINR32_33 = (RPINR32_33 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IC7) then RPINR34_35 = (RPINR34_35 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_IC9) then RPINR36_37 = (RPINR36_37 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_T0CKI) then RPINR38_39 = (RPINR38_39 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_T1CKI) then RPINR40_41 = (RPINR40_41 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_T3CKI) then RPINR42_43 = (RPINR42_43 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_T5CKI) then RPINR44_45 = (RPINR44_45 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_PBI1) then RPINR46_47 = (RPINR46_47 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_PBI3) then RPINR48_49 = (RPINR48_49 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_PBI5) then RPINR50_51 = (RPINR50_51 and $0F) or (rp_pin << 4) elseif (input_fn = PPS_PBI7) then RPINR52_53 = (RPINR52_53 and $0F) or (rp_pin << 4) endif end macro // regular V1-V3 PPS module #else public macro assign_input(input_rp_reg, rp_pin) input_rp_reg = rp_pin end macro #endif // PPS_V5/PPS_V4/PPS_V1-PPS_V3 // //------------------------------------------------------------------------------ // PPS output //------------------------------------------------------------------------------ // // pps output functions #if defined (PPS_V1) or defined (PPS_V2) or defined (PPS_V1_1) or defined (PPS_V2_1) or _ defined (PPS_V3) or defined (PPS_V3_1) or defined (PPS_V3B) or defined (PPS_V3B_1) public const PPS_NULL = 0 // RPn tied to default port pin public const PPS_C1OUT = 1 // RPn tied to comparator 1 output public const PPS_C2OUT = 2 // RPn tied to comparator 2 output public const PPS_ULPWU = 13 // RPn tied to Ultra Low Power Wake Up Event public const PPS_CCP1P1A = 14 // RPn tied to ECCP1/CCP1 compare or PWM output channel A public const PPS_P1B = 15 // RPn tied to ECCP1 Enhanced PWM output, channel B public const PPS_P1C = 16 // RPn tied to ECCP1 Enhanced PWM output, channel C public const PPS_P1D = 17 // RPn tied to ECCP1 Enhanced PWM output, channel D public const PPS_CCP2P2A = 18 // RPn tied to ECCP2/CCP2 compare or PWM output public const PPS_P2B = 19 // RPn tied to ECCP2 Enhanced PWM output, channel B public const PPS_P2C = 20 // RPn tied to ECCP2 Enhanced PWM output, channel C public const PPS_P2D = 21 // RPn tied to ECCP2 Enhanced PWM output, channel D // alias name for unmapping an output pin public const PPS_OUT_UNUSED = PPS_NULL #endif // (PPS_V1) or (PPS_V2) or (PPS_V1_1) or (PPS_V2_1) or (PPS_V3) or (PPS_V3_1) or (PPS_V3B) or (PPS_V3B_1) #if defined (PPS_V1) or defined (PPS_V2) or defined (PPS_V1_1) or defined (PPS_V2_1) public const PPS_TX2CK2 = 5 // RPn tied to EUSART 2 Async Transmit / Sync Clock Output public const PPS_TX2 = 5 // alias for PPS_TX2CK2 public const PPS_DT2 = 6 // RPn tied to EUSART 2 Sync Transmit public const PPS_SDO2 = 9 // RPn tied to SPI2 Data Output public const PPS_SCK2 = 10 // RPn tied to SPI2 Clock Output public const PPS_SSDMA = 12 // RPn tied to SPI DMA Slave Select #endif // (PPS_V1) or (PPS_V2) or (PPS_V1_1) or (PPS_V2_1) #if defined (PPS_V3) or defined (PPS_V3_1) or defined (PPS_V3B) or defined (PPS_V3B_1) public const PPS_C3OUT = 3 // RPn tied to comparator 3 output public const PPS_TX2CK2 = 6 // RPn tied to EUSART 2 Async Transmit / Sync Clock Output public const PPS_TX2 = 6 // alias for PPS_TX2CK2 public const PPS_DT2 = 7 // RPn tied to EUSART 2 Sync Transmit public const PPS_SDO2 = 10 // RPn tied to SPI2 Data Output public const PPS_SCK2 = 11 // RPn tied to SPI2 Clock Output public const PPS_SSDMA = 12 // RPn tied to SPI DMA Slave Select public const PPS_CCP3P3A = 22 // RPn tied to ECCP3/CCP3 compare or PWM output public const PPS_P3B = 23 // RPn tied to ECCP3 Enhanced PWM output, channel B public const PPS_P3C = 24 // RPn tied to ECCP3 Enhanced PWM output, channel C public const PPS_P3D = 25 // RPn tied to ECCP3 Enhanced PWM output, channel D #endif // (PPS_V3) or (PPS_V3_1) or (PPS_V3B) or (PPS_V3B_1) #if defined (PPS_V4) // some output function names had to be changed so that there is a unique input/output function // (ie PPS_CCPx, PPS_PBIOx, etc) public const PPS_NULL = 0 // RPn tied to default port pin // alias name for unmapping an output pin public const PPS_OUT_UNUSED = PPS_NULL // GROUP 4n public const PPS_U2BCLK = 1 // RPn tied to U2BCLK port pin public const PPS_U3RX_DT = 2 // RPn tied to EUSART3 Sync transmit (RX3/DT3) output public const PPS_U4RX_DT = 3 // RPn tied to EUSART4 Sync transmit (TRX4/DT4) output public const PPS_SDO2 = 4 // RPn tied to SPI2 Data Output public const PPS_P1D = 5 // RPn tied to ECCP1 Enhanced PWM output, channel D public const PPS_P2D = 6 // RPn tied to ECCP2 Enhanced PWM output, channel D public const PPS_P3B = 7 // RPn tied to ECCP3 Enhanced PWM output, channel B public const PPS_CTPLS = 8 // RPn tied to CTPLS public const PPS_CCP5 = 9 // RPn tied to CCP5 compare or PWM output public const PPS_CCP8 = $0A // RPn tied to CCP8 compare or PWM output public const PPS_C1OUT = $0B // RPn tied to comparator 1 public const PPS_PBO0 = $0D // RPn tied to PBIO0 public const PPS_PBO4 = $0E // RPn tied to PBIO4 // GROUP (4n+1) public const PPS_U1BCLK = 1 // RPn tied to U1BCLK port pin public const PPS_U3TX_CK = 2 // RPn tied to EUSART3 Async Transmit / sync Clock Output public const PPS_U3TX = PPS_U3TX_CK public const PPS_U4TX_CK = 3 // RPn tied to EUSART4 Async Transmit / sync Clock Output public const PPS_U4TX = PPS_U4TX_CK public const PPS_SDO1 = 4 // RPn tied to SPI1 Data Output public const PPS_P1C = 5 // RPn tied to ECCP1 Enhanced PWM output, channel C public const PPS_P2C = 6 // RPn tied to ECCP2 Enhanced PWM output, channel C public const PPS_P3C = 7 // RPn tied to ECCP3 Enhanced PWM output, channel C public const PPS_CCP7 = 8 // RPn tied to CCP7 compare or PWM output public const PPS_CCP9 = 9 // RPn tied to CCP9 compare or PWM output public const PPS_C2OUT = $0A // RPn tied to comparator 2 public const PPS_PBO1 = $0D // RPn tied to PBIO1 public const PPS_PBO5 = $0E // RPn tied to PBIO5 // GROUP (4n+2) public const PPS_U1TX_CK = 1 // RPn tied to EUSART1 Async Transmit / sync Clock Output public const PPS_U1TX = PPS_U1TX_CK public const PPS_U2RX_DT = 2 // RPn tied to EUSART2 Async/Sync Receive (RX2/DT2) public const PPS_U3BCLK = 3 // RPn tied to U3BCLK port pin public const PPS_U4BCLK = 4 // RPn tied to U4BCLK port pin public const PPS_SCK2 = 5 // RPn tied to SPI2 Clock Output public const PPS_P1B = 6 // RPn tied to ECCP1 Enhanced PWM output, channel B public const PPS_P2B = 7 // RPn tied to ECCP2 Enhanced PWM output, channel B public const PPS_ECCP3P3A = 8 // RPn tied to ECCP3/CCP3 compare or PWM output public const PPS_CCP6 = 9 // RPn tied to CCP6 compare or PWM output public const PPS_CCP10 = $0A // RPn tied to CCP10 compare or PWM output public const PPS_PBO2 = $0D // RPn tied to PBIO2 public const PPS_PBO6 = $0E // RPn tied to PBIO6 // GROUP (4n+3) public const PPS_U1RX_DT = 1 // RPn tied to EUSART1 Async/sync Receive (RX1/DT1) public const PPS_U2TX_CK = 2 // RPn tied to EUSART2 Async Transmit / sync Clock Output public const PPS_U2TX = PPS_U2TX_CK public const PPS_SCK1 = 3 // RPn tied to SPI1 Clock Output public const PPS_ECCP1P1A = 4 // RPn tied to ECCP1/CCP1 compare or PWM output public const PPS_ECCP2P2A = 5 // RPn tied to ECCP2/CCP2 compare or PWM output public const PPS_P3D = 6 // RPn tied to ECCP3 Enhanced PWM output, channel D public const PPS_MDOUT = 7 // RPn tied to MDOUT port pin public const PPS_CCP4 = 8 // RPn tied to CCP4 compare or PWM output public const PPS_C3OUT = 9 // RPn tied to comparator 3 public const PPS_PBO3 = $0D // RPn tied to PBIO3 public const PPS_PBO7 = $0E // RPn tied to PBIO7 #endif // (PPS_V4) // pps output pin definitions #if defined (PPS_V1) or defined (PPS_V2) or defined (PPS_V1_1) or defined (PPS_V2_1) or _ defined (PPS_V3) or defined (PPS_V3_1) or defined (PPS_V3B) or defined (PPS_V3B_1) public dim PPS_OUT_RP0 as RPOR0 // assign RP0 as Output Pin public dim PPS_OUT_RP1 as RPOR1 // assign RP1 as Output Pin public dim PPS_OUT_RP2 as RPOR2 // assign RP2 as Output Pin public dim PPS_OUT_RP3 as RPOR3 // assign RP3 as Output Pin public dim PPS_OUT_RP4 as RPOR4 // assign RP4 as Output Pin public dim PPS_OUT_RP5 as RPOR5 // assign RP5 as Output Pin public dim PPS_OUT_RP6 as RPOR6 // assign RP6 as Output Pin public dim PPS_OUT_RP7 as RPOR7 // assign RP7 as Output Pin public dim PPS_OUT_RP8 as RPOR8 // assign RP8 as Output Pin public dim PPS_OUT_RP9 as RPOR9 // assign RP9 as Output Pin public dim PPS_OUT_RP10 as RPOR10 // assign RP10 as Output Pin public dim PPS_OUT_RP11 as RPOR11 // assign RP11 as Output Pin public dim PPS_OUT_RP12 as RPOR12 // assign RP12 as Output Pin public dim PPS_OUT_RP13 as RPOR13 // assign RP13 as Output Pin public dim PPS_OUT_RP17 as RPOR17 // assign RP17 as Output Pin public dim PPS_OUT_RP18 as RPOR18 // assign RP18 as Output Pin #endif // (PPS_V1) or (PPS_V2) or (PPS_V1_1) or (PPS_V2_1) or (PPS_V3) or (PPS_V3_1) or (PPS_V3B) or (PPS_V3B_1) #if defined (PPS_V1_1) or defined (PPS_V2_1) or defined (PPS_V3) or defined (PPS_V3_1) public dim PPS_OUT_RP14 as RPOR14 // assign RP14 as Output Pin public dim PPS_OUT_RP15 as RPOR15 // assign RP15 as Output Pin public dim PPS_OUT_RP16 as RPOR16 // assign RP16 as Output Pin #endif // (PPS_V1_1) or (PPS_V2_1) or (PPS_V3) or (PPS_V3_1) #if defined (PPS_V2) or defined (PPS_V2_1) or defined (PPS_V3_1) or defined (PPS_V3B_1) public dim PPS_OUT_RP19 as RPOR19 // assign RP19 as Output Pin public dim PPS_OUT_RP20 as RPOR20 // assign RP20 as Output Pin public dim PPS_OUT_RP21 as RPOR21 // assign RP21 as Output Pin public dim PPS_OUT_RP22 as RPOR22 // assign RP22 as Output Pin public dim PPS_OUT_RP23 as RPOR23 // assign RP23 as Output Pin public dim PPS_OUT_RP24 as RPOR24 // assign RP24 as Output Pin #endif // (PPS_V2) or (PPS_V2_1) or (PPS_V3_1) or (PPS_V3B_1) // the PPS Lite module splits the RPOR registers into two nibbles with certain pins // assigned to each of the upper and lower nibbles. in order to use a macro for this we need // a unique value for each output pin so that we can place the setting in the proper spot. // we just assign numbers to the output pins to match the RPx number... the number itself // isn't important as the macro will translate PPS_OUT_RPxx pins to RPORx registers #if defined (PPS_V4) // GROUP 4n public const PPS_OUT_RP0 = 0 // assign RP0 as Output Pin public const PPS_OUT_RP4 = 4 // assign RP4 as Output Pin public const PPS_OUT_RP8 = 8 // assign RP8 as Output Pin public const PPS_OUT_RP12 = 12 // assign RP12 as Output Pin public const PPS_OUT_RP16 = 16 // assign RP16 as Output Pin public const PPS_OUT_RP20 = 20 // assign RP20 as Output Pin public const PPS_OUT_RP24 = 24 // assign RP24 as Output Pin public const PPS_OUT_RP28 = 28 // assign RP28 as Output Pin public const PPS_OUT_RP32 = 32 // assign RP32 as Output Pin public const PPS_OUT_RP36 = 36 // assign RP36 as Output Pin public const PPS_OUT_RP40 = 40 // assign RP40 as Output Pin public const PPS_OUT_RP44 = 44 // assign RP44 as Output Pin // GROUP (4n+1) public const PPS_OUT_RP1 = 1 // assign RP1 as Output Pin public const PPS_OUT_RP5 = 5 // assign RP5 as Output Pin public const PPS_OUT_RP9 = 9 // assign RP9 as Output Pin public const PPS_OUT_RP13 = 13 // assign RP13 as Output Pin public const PPS_OUT_RP17 = 17 // assign RP17 as Output Pin public const PPS_OUT_RP21 = 21 // assign RP21 as Output Pin public const PPS_OUT_RP25 = 25 // assign RP25 as Output Pin public const PPS_OUT_RP29 = 29 // assign RP29 as Output Pin public const PPS_OUT_RP33 = 33 // assign RP33 as Output Pin public const PPS_OUT_RP37 = 37 // assign RP37 as Output Pin public const PPS_OUT_RP41 = 41 // assign RP41 as Output Pin public const PPS_OUT_RP45 = 45 // assign RP45 as Output Pin // GROUP (4n+2) public const PPS_OUT_RP2 = 2 // assign RP2 as Output Pin public const PPS_OUT_RP6 = 6 // assign RP6 as Output Pin public const PPS_OUT_RP10 = 10 // assign RP10 as Output Pin public const PPS_OUT_RP14 = 14 // assign RP14 as Output Pin public const PPS_OUT_RP18 = 18 // assign RP18 as Output Pin public const PPS_OUT_RP22 = 22 // assign RP22 as Output Pin public const PPS_OUT_RP26 = 26 // assign RP26 as Output Pin public const PPS_OUT_RP30 = 30 // assign RP30 as Output Pin public const PPS_OUT_RP34 = 34 // assign RP34 as Output Pin public const PPS_OUT_RP38 = 38 // assign RP38 as Output Pin public const PPS_OUT_RP42 = 42 // assign RP42 as Output Pin public const PPS_OUT_RP46 = 46 // assign RP46 as Output Pin // GROUP (4n+3) public const PPS_OUT_RP3 = 3 // assign RP3 as Output Pin public const PPS_OUT_RP7 = 7 // assign RP7 as Output Pin public const PPS_OUT_RP11 = 11 // assign RP11 as Output Pin public const PPS_OUT_RP15 = 15 // assign RP15 as Output Pin public const PPS_OUT_RP19 = 19 // assign RP19 as Output Pin public const PPS_OUT_RP23 = 23 // assign RP23 as Output Pin public const PPS_OUT_RP27 = 27 // assign RP27 as Output Pin public const PPS_OUT_RP31 = 31 // assign RP31 as Output Pin public const PPS_OUT_RP35 = 35 // assign RP35 as Output Pin public const PPS_OUT_RP39 = 39 // assign RP39 as Output Pin public const PPS_OUT_RP43 = 43 // assign RP43 as Output Pin #endif // (PPS_V4) // //---------------------------------------------------------- // PPS output pin assignments //---------------------------------------------------------- // // K40 family #if defined(PPS_V5_1) or defined(PPS_V5_1B) or defined(PPS_V5_2) or defined(PPS_V5_3) // 24K40, 25K40 (see errata DS80000711B pg 6) // v1.50 note: these were changed in datasheet 40001843D #if defined(PPS_V5_1) public const PPS_ADGRDB as byte = $13, PPS_ADGRDA as byte = $14, // was $12 w PPS_DSM as byte = $11, PPS_CLKR as byte = $10, PPS_TMR0 as byte = $0F, PPS_MSSP1_SDO_SDA as byte = $0E, PPS_MSSP1_SCK_SCL as byte = $0D, PPS_CMP2 as byte = $0C, PPS_CMP1 as byte = $0B, PPS_EUSART1_RX as byte = $0A, PPS_EUSART1_TX as byte = $09, PPS_PWM4 as byte = $08, PPS_PWM3 as byte = $07, PPS_CCP2 as byte = $06, PPS_CCP1 as byte = $05, PPS_CWG1D as byte = $04, PPS_CWG1C as byte = $03, PPS_CWG1B as byte = $02, PPS_CWG1A as byte = $01, PPS_LAT as byte = $00, PPS_NULL as byte = PPS_LAT #endif // PPS_5_1 // 26K40, 27K40, 4xK40 #if defined(PPS_V5_1B) or defined(PPS_V5_2) public const PPS_ADGRDB as byte = $17, PPS_ADGRDA as byte = $16, PPS_DSM as byte = $15, PPS_CLKR as byte = $14, PPS_TMR0 as byte = $13, PPS_MSSP2_SDO_SDA as byte = $12, PPS_MSSP2_SCK_SCL as byte = $11, PPS_MSSP1_SDO_SDA as byte = $10, PPS_MSSP1_SCK_SCL as byte = $0F, PPS_CMP2 as byte = $0E, PPS_CMP1 as byte = $0D, PPS_EUSART2_RX as byte = $0C, PPS_EUSART2_TX as byte = $0B, PPS_EUSART1_RX as byte = $0A, PPS_EUSART1_TX as byte = $09, PPS_PWM4 as byte = $08, PPS_PWM3 as byte = $07, PPS_CCP2 as byte = $06, PPS_CCP1 as byte = $05, PPS_CWG1D as byte = $04, PPS_CWG1C as byte = $03, PPS_CWG1B as byte = $02, PPS_CWG1A as byte = $01, PPS_LAT as byte = $00, PPS_NULL as byte = PPS_LAT #endif // PPS_5_1B/5_2 // 6xK40 #if defined(PPS_V5_3) public const PPS_ADGRDB as byte = $21, PPS_ADGRDA as byte = $20, PPS_DSM as byte = $1f, PPS_CLKR as byte = $1e, PPS_TMR0 as byte = $1d, PPS_MSSP2_SDO_SDA as byte = $1c, PPS_MSSP2_SCK_SCL as byte = $1b, PPS_MSSP1_SDO_SDA as byte = $1a, PPS_MSSP1_SCK_SCL as byte = $19, PPS_CMP3 as byte = $18, PPS_CMP2 as byte = $17, PPS_CMP1 as byte = $16, PPS_EUSART5_DT as byte = $15, PPS_EUSART5_RX as byte = $15, PPS_EUSART5_TX_CK as byte = $14, PPS_EUSART5_TX as byte = $14, PPS_EUSART4_DT as byte = $13, PPS_EUSART4_RX as byte = $13, PPS_EUSART4_TX_CK as byte = $12, PPS_EUSART4_TX as byte = $12, PPS_EUSART3_DT as byte = $11, PPS_EUSART3_RX as byte = $11, PPS_EUSART3_TX_CK as byte = $10, PPS_EUSART3_TX as byte = $10, PPS_EUSART2_DT as byte = $0f, PPS_EUSART2_RX as byte = $0f, PPS_EUSART2_TX_CK as byte = $0e, PPS_EUSART2_TX as byte = $0e, PPS_EUSART1_DT as byte = $0d, PPS_EUSART1_RX as byte = $0d, PPS_EUSART1_TX_CK as byte = $0c, PPS_EUSART1_TX as byte = $0c, PPS_PWM7 as byte = $0b, PPS_PWM6 as byte = $0a, PPS_CCP5 as byte = $09, PPS_CCP4 as byte = $08, PPS_CCP3 as byte = $07, PPS_CCP2 as byte = $06, PPS_CCP1 as byte = $05, PPS_CWG1D as byte = $04, PPS_CWG1C as byte = $03, PPS_CWG1B as byte = $02, PPS_CWG1A as byte = $01, PPS_LAT as byte = $00, PPS_NULL as byte = PPS_LAT #endif // PPS_5_3 // // to assign an output function to a pin: // RxxPPS = pps_output_function // macro example: // pps.assign_output(RA0PPS, PPS_TMR0) // assigns TMR0 output to RA0 // pps.assign_output(RB1PPS, PPS_EUSART1_TX) // assigns usart TX1 output to RB1 // note: pps output functions are limited to specific ports // currently the macro does not check to see if the assignment is valid (nothing does) // refer to REGISTER 17-2 PIN Rxy OUTPUT SOURCE SELECTION REGISTER // note: for the K40 family this macro doesn't really do much at all // public macro assign_output(pps_port_sel_reg, pps_out_function) pps_port_sel_reg = pps_out_function end macro // Q10 family #elseif defined(PPS_V6_1) or defined(PPS_V6_2) #if defined(PPS_V6_1) // 24Q10, 25Q10 datasheet DS40001945B public const PPS_ADGRDB as byte = $13, PPS_ADGRDA as byte = $12, // likely a mistake... K40 has this as $14 now PPS_DSM as byte = $11, PPS_CLKR as byte = $10, PPS_TMR0 as byte = $0F, PPS_MSSP1_SDO_SDA as byte = $0E, PPS_MSSP1_SCK_SCL as byte = $0D, PPS_CMP2 as byte = $0C, PPS_CMP1 as byte = $0B, PPS_EUSART1_RX as byte = $0A, PPS_EUSART1_TX as byte = $09, PPS_PWM4 as byte = $08, PPS_PWM3 as byte = $07, PPS_CCP2 as byte = $06, PPS_CCP1 as byte = $05, PPS_CWG1D as byte = $04, PPS_CWG1C as byte = $03, PPS_CWG1B as byte = $02, PPS_CWG1A as byte = $01, PPS_LAT as byte = $00, PPS_NULL as byte = PPS_LAT #endif // PPS_V6_1 // 26Q10, 45Q10, 46Q10, 27Q10, 47Q10 #if defined(PPS_V6_2) public const PPS_CLC8OUT as byte = $1F, PPS_CLC7OUT as byte = $1E, PPS_CLC6OUT as byte = $1D, PPS_CLC5OUT as byte = $1C, PPS_CLC4OUT as byte = $1B, PPS_CLC3OUT as byte = $1A, PPS_CLC2OUT as byte = $19, PPS_CLC1OUT as byte = $18, PPS_ADGRDB as byte = $17, PPS_ADGRDA as byte = $16, PPS_DSM as byte = $15, PPS_CLKR as byte = $14, PPS_TMR0 as byte = $13, PPS_MSSP2_SDO_SDA as byte = $12, PPS_MSSP2_SCK_SCL as byte = $11, PPS_MSSP1_SDO_SDA as byte = $10, PPS_MSSP1_SCK_SCL as byte = $0F, PPS_CMP2 as byte = $0E, PPS_CMP1 as byte = $0D, PPS_EUSART2_RX as byte = $0C, PPS_EUSART2_TX as byte = $0B, PPS_EUSART1_RX as byte = $0A, PPS_EUSART1_TX as byte = $09, PPS_PWM4 as byte = $08, PPS_PWM3 as byte = $07, PPS_CCP2 as byte = $06, PPS_CCP1 as byte = $05, PPS_CWG1D as byte = $04, PPS_CWG1C as byte = $03, PPS_CWG1B as byte = $02, PPS_CWG1A as byte = $01, PPS_LAT as byte = $00, PPS_NULL as byte = PPS_LAT #endif // PPS_V6_2 // // to assign an output function to a pin: // RxxPPS = pps_output_function // macro example: // pps.assign_output(RA0PPS, PPS_TMR0) // assigns TMR0 output to RA0 // pps.assign_output(RB1PPS, PPS_EUSART1_TX) // assigns usart TX1 output to RB1 // note: pps output functions are limited to specific ports // currently the macro does not check to see if the assignment is valid (nothing does) // refer to REGISTER 17-2 PIN Rxy OUTPUT SOURCE SELECTION REGISTER // note: for the Q10 family this macro doesn't really do much at all // public macro assign_output(pps_port_sel_reg, pps_out_function) pps_port_sel_reg = pps_out_function end macro #elseif defined(PPS_V4) //------------------------------------------------------------------------------ // assign_output(output_fn, rp_pin) // // assign pps output function to a pin // output_fn pps output function (ie PPS_TX2) // rp_pin PPS_OUT_RPx pin (ie PPS_OUT_RP0) // example usage: // assign_output(PPS_NULL, PPS_OUT_RP0) // assign_output(PPS_TX2, PPS_OUT_RP23) //------------------------------------------------------------------------------ public macro assign_output(output_fn, rp_pin) // for the PPS Lite module we need to translate output "pin numbers" // to register and upper/lower nibble selection. just do it brute force // since the macro will remove all the unused code // functions that use the lower nibble of the RPORxx reg if (rp_pin = PPS_OUT_RP0) then RPOR0_1 = (RPOR0_1 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP4) then RPOR4_5 = (RPOR4_5 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP8) then RPOR8_9 = (RPOR8_9 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP12) then RPOR12_13 = (RPOR12_13 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP16) then RPOR16_17 = (RPOR16_17 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP20) then RPOR20_21 = (RPOR20_21 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP24) then RPOR24_25 = (RPOR24_25 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP28) then RPOR28_29 = (RPOR28_29 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP32) then RPOR32_33 = (RPOR32_33 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP36) then RPOR36_37 = (RPOR36_37 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP40) then RPOR40_41 = (RPOR40_41 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP44) then RPOR44_45 = (RPOR44_45 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP2) then RPOR2_3 = (RPOR2_3 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP6) then RPOR6_7 = (RPOR6_7 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP10) then RPOR10_11 = (RPOR10_11 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP14) then RPOR14_15 = (RPOR14_15 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP18) then RPOR18_19 = (RPOR18_19 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP22) then RPOR22_23 = (RPOR22_23 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP26) then RPOR26_27 = (RPOR26_27 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP30) then RPOR30_31 = (RPOR30_31 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP34) then RPOR34_35 = (RPOR34_35 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP38) then RPOR38_39 = (RPOR38_39 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP42) then RPOR42_43 = (RPOR42_43 and $F0) or output_fn elseif (rp_pin = PPS_OUT_RP46) then RPOR46 = (RPOR46 and $F0) or output_fn endif // functions that use the upper nibble of the RPORxx reg if (rp_pin = PPS_OUT_RP1) then RPOR0_1 = (RPOR0_1 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP5) then RPOR4_5 = (RPOR4_5 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP9) then RPOR8_9 = (RPOR8_9 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP13) then RPOR12_13 = (RPOR12_13 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP17) then RPOR16_17 = (RPOR16_17 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP21) then RPOR20_21 = (RPOR20_21 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP25) then RPOR24_25 = (RPOR24_25 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP29) then RPOR28_29 = (RPOR28_29 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP33) then RPOR32_33 = (RPOR32_33 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP37) then RPOR36_37 = (RPOR36_37 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP41) then RPOR40_41 = (RPOR40_41 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP45) then RPOR44_45 = (RPOR44_45 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP3) then RPOR2_3 = (RPOR2_3 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP7) then RPOR6_7 = (RPOR6_7 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP11) then RPOR10_11 = (RPOR10_11 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP15) then RPOR14_15 = (RPOR14_15 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP19) then RPOR18_19 = (RPOR18_19 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP23) then RPOR22_23 = (RPOR22_23 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP27) then RPOR26_27 = (RPOR26_27 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP31) then RPOR30_31 = (RPOR30_31 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP35) then RPOR34_35 = (RPOR34_35 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP39) then RPOR38_39 = (RPOR38_39 and $0F) or (output_fn << 4) elseif (rp_pin = PPS_OUT_RP43) then RPOR42_43 = (RPOR42_43 and $0F) or (output_fn << 4) endif end macro #else // regular V1-V3 PPS module public macro assign_output(output_fn, rp_pin) rp_pin = output_fn end macro #endif // (PPS_V4) // //------------------------------------------------------------------------------ // PPS helper functions //------------------------------------------------------------------------------ // // // unlock/lock pps configuration // Changes to the pps control registers must be unlocked in hardware prior to // accessing them, or they will not change. This should be done with interrupts // disabled, so unlock() records the state of the global IE flag for later use // by the lock() routine // // K40 family #if defined(PPS_V5_1) or defined(PPS_V5_1B) or defined(PPS_V5_2) or defined(PPS_V5_3) dim PPSLOCKED_BIT as PPSLOCK.bits(0) // PPSLOCKED bit dim PPSLOCK_REG as PPSLOCK // alias name for the PPS lock control reg // Q10 family #elseif defined(PPS_V6_1) or defined(PPS_V6_2) dim PPSLOCKED_BIT as PPSLOCK.bits(0) // PPSLOCKED bit dim PPSLOCK_REG as PPSLOCK // alias name for the PPS lock control reg // J94/J99 family #elseif defined (PPS_V4) dim PPSLOCKED_BIT as OSCCON2.bits(6) // IOLOCK bit dim PPSLOCK_REG as WREG // alias name for the (dummy) PPS lock control reg // all others #else dim PPSLOCKED_BIT as PPSCON.bits(0) // IOLOCK bit dim PPSLOCK_REG as EECON2 // alias name for the PPS lock control reg #endif #if (PPS_DISABLE_INT) dim t_intcon as byte // copy of INTCON register const GIE = 7 // GIEH bit number #endif // //------------------------------------------------------------------------------ // unlock PPS configuration changes //------------------------------------------------------------------------------ // public sub unlock() #if (PPS_DISABLE_INT) // save current state of GIE intr bit and disable interrupts t_intcon = INTCON INTCON.bits(GIE) = 0 #endif // send sequence to unlock the PPS configuration PPSLOCK_REG = $55 PPSLOCK_REG = $AA PPSLOCKED_BIT = 0 end sub // //------------------------------------------------------------------------------ // lock PPS configuration //------------------------------------------------------------------------------ // public sub lock() // send sequence to lock the PPS configuration PPSLOCK_REG = $55 PPSLOCK_REG = $AA PPSLOCKED_BIT = 1 #if (PPS_DISABLE_INT) // restore the interrupt enable state previously saved by unlock() if (t_intcon.bits(GIE) = 1) then INTCON.bits(GIE) = 1 endif #endif end sub // //------------------------------------------------------------------------------ // assign_defaults() // remap all RPxx pins to the default unmapped state //------------------------------------------------------------------------------ // // RPINR and RPOR register ranges #if defined (PPS_V1) or defined (PPS_V1_1) or defined(PPS_V3) or defined(PPS_V3B) dim FIRST_RPINR as RPINR1 dim LAST_RPINR as RPINR24 dim FIRST_RPOR as RPOR0 dim LAST_RPOR as RPOR18 #elseif defined (PPS_V2) or defined (PPS_V2_1) or defined (PPS_V3_1) or defined (PPS_V3B_1) dim FIRST_RPINR as RPINR1 dim LAST_RPINR as RPINR24 dim FIRST_RPOR as RPOR0 dim LAST_RPOR as RPOR24 #elseif defined (PPS_V4) dim FIRST_RPINR as RPINR0_1 dim LAST_RPINR as RPINR52_53 dim FIRST_RPOR as RPOR0_1 dim LAST_RPOR as RPOR46 #endif #if defined(PPS_V5_1) or defined(PPS_V5_1B) or defined(PPS_V5_2) or defined(PPS_V5_3) or defined(PPS_V6_1) or defined(PPS_V6_2) public sub assign_defaults() // the K40 and Q10 family do not have a common "default" register setting // it's best to do it individually, so this is just a dummy routine end sub #else public sub assign_defaults() // default setting depends on PPS type... V4 has two settings per reg #if defined (PPS_V4) const RPIN_UNUSED = PPS_IN_UNUSED or (PPS_IN_UNUSED << 4) const RPOUT_UNUSED = PPS_OUT_UNUSED or (PPS_OUT_UNUSED << 4) #else const RPIN_UNUSED = PPS_IN_UNUSED const RPOUT_UNUSED = PPS_OUT_UNUSED #endif dim wtmp as word, // need a word to compute address differences, count as wtmp.bytes(0) // but only need a byte count value result // the algorithm used here relies on a few assumptions: // - registers in the RPINR and RPOR sections are contiguous // - addresses in a section increase from first to last (last > first) // - writing to an unimplemented register causes no harm // if any of these assumptions aren't true then the routine will // have unintended consequences // unlock pps for config changes unlock() // default inputs - tied to PPS_VSS // compute the count of RPINRxx regs to set wtmp = addressof(LAST_RPINR) wtmp = wtmp - addressof(FIRST_RPINR) count = byte(wtmp) + 1 // init starting addr and loop setting RPINRxx FSR0 = addressof(FIRST_RPINR) repeat POSTINC0 = RPIN_UNUSED count = count - 1 until (count = 0) // default outputs - set to default port pin function // compute the count of RPORxx regs to set wtmp = addressof(LAST_RPOR) wtmp = wtmp - addressof(FIRST_RPOR) count = byte(wtmp) + 1 // init starting addr and loop setting RPORxx FSR0 = addressof(FIRST_RPOR) repeat POSTINC0 = RPOUT_UNUSED count = count - 1 until (count = 0) // relock pps lock() end sub #endif // //------------------------------------------------------------------------------ // module initialization //------------------------------------------------------------------------------ // end module