From c9335332df86fbc895a8868a34abcc98817d53f0 Mon Sep 17 00:00:00 2001 From: Joshua Drake Date: Sat, 6 Dec 2025 14:22:21 -0600 Subject: Inital Commit --- mcc_generated_files/system/src/pins.c | 393 ++++++++++++++++++++++++++++++++++ 1 file changed, 393 insertions(+) create mode 100644 mcc_generated_files/system/src/pins.c (limited to 'mcc_generated_files/system/src/pins.c') diff --git a/mcc_generated_files/system/src/pins.c b/mcc_generated_files/system/src/pins.c new file mode 100644 index 0000000..92133c9 --- /dev/null +++ b/mcc_generated_files/system/src/pins.c @@ -0,0 +1,393 @@ +/** + * Generated Driver File + * + * @file pins.c + * + * @ingroup pinsdriver + * + * @brief This is generated driver implementation for pins. + * This file provides implementations for pin APIs for all pins selected in the GUI. + * + * @version Driver Version 1.1.0 +*/ + +/* +© [2025] Microchip Technology Inc. and its subsidiaries. + + Subject to your compliance with these terms, you may use Microchip + software and any derivatives exclusively with Microchip products. + You are responsible for complying with 3rd party license terms + applicable to your use of 3rd party software (including open source + software) that may accompany Microchip software. SOFTWARE IS ?AS IS.? + NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS + SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, + MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT + WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, + INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY + KIND WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF + MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE + FORESEEABLE. TO THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP?S + TOTAL LIABILITY ON ALL CLAIMS RELATED TO THE SOFTWARE WILL NOT + EXCEED AMOUNT OF FEES, IF ANY, YOU PAID DIRECTLY TO MICROCHIP FOR + THIS SOFTWARE. +*/ + +#include "../pins.h" + +static void (*IO_PA5_InterruptHandler)(void); +static void (*IO_PA4_InterruptHandler)(void); +static void (*IO_PA6_InterruptHandler)(void); +static void (*IO_PA7_InterruptHandler)(void); +static void (*IO_PA2_InterruptHandler)(void); +static void (*IO_PA3_InterruptHandler)(void); +static void (*IO_PD0_InterruptHandler)(void); +static void (*IO_PD1_InterruptHandler)(void); +static void (*IO_PD2_InterruptHandler)(void); +static void (*IO_PD3_InterruptHandler)(void); +static void (*IO_PD4_InterruptHandler)(void); +static void (*IO_PD5_InterruptHandler)(void); +static void (*IO_PD6_InterruptHandler)(void); +static void (*IO_PD7_InterruptHandler)(void); + +void PIN_MANAGER_Initialize() +{ + + /* OUT Registers Initialization */ + PORTA.OUT = 0x0; + PORTC.OUT = 0x0; + PORTD.OUT = 0x0; + PORTF.OUT = 0x0; + + /* DIR Registers Initialization */ + PORTA.DIR = 0xDC; + PORTC.DIR = 0x0; + PORTD.DIR = 0xFF; + PORTF.DIR = 0x0; + + /* PINxCTRL registers Initialization */ + PORTA.PIN0CTRL = 0x0; + PORTA.PIN1CTRL = 0x0; + PORTA.PIN2CTRL = 0x0; + PORTA.PIN3CTRL = 0x0; + PORTA.PIN4CTRL = 0x0; + PORTA.PIN5CTRL = 0x0; + PORTA.PIN6CTRL = 0x0; + PORTA.PIN7CTRL = 0x0; + PORTC.PIN0CTRL = 0x0; + PORTC.PIN1CTRL = 0x0; + PORTC.PIN2CTRL = 0x0; + PORTC.PIN3CTRL = 0x0; + PORTC.PIN4CTRL = 0x0; + PORTC.PIN5CTRL = 0x0; + PORTC.PIN6CTRL = 0x0; + PORTC.PIN7CTRL = 0x0; + PORTD.PIN0CTRL = 0x0; + PORTD.PIN1CTRL = 0x0; + PORTD.PIN2CTRL = 0x0; + PORTD.PIN3CTRL = 0x0; + PORTD.PIN4CTRL = 0x0; + PORTD.PIN5CTRL = 0x0; + PORTD.PIN6CTRL = 0x0; + PORTD.PIN7CTRL = 0x0; + PORTF.PIN0CTRL = 0x0; + PORTF.PIN1CTRL = 0x0; + PORTF.PIN2CTRL = 0x0; + PORTF.PIN3CTRL = 0x0; + PORTF.PIN4CTRL = 0x0; + PORTF.PIN5CTRL = 0x0; + PORTF.PIN6CTRL = 0x0; + PORTF.PIN7CTRL = 0x0; + + /* PORTMUX Initialization */ + PORTMUX.CCLROUTEA = 0x0; + PORTMUX.EVSYSROUTEA = 0x0; + PORTMUX.SPIROUTEA = 0x0; + PORTMUX.TCAROUTEA = 0x0; + PORTMUX.TCBROUTEA = 0x0; + PORTMUX.TWIROUTEA = 0x0; + PORTMUX.USARTROUTEA = 0x0; + + // register default ISC callback functions at runtime; use these methods to register a custom function + IO_PA5_SetInterruptHandler(IO_PA5_DefaultInterruptHandler); + IO_PA4_SetInterruptHandler(IO_PA4_DefaultInterruptHandler); + IO_PA6_SetInterruptHandler(IO_PA6_DefaultInterruptHandler); + IO_PA7_SetInterruptHandler(IO_PA7_DefaultInterruptHandler); + IO_PA2_SetInterruptHandler(IO_PA2_DefaultInterruptHandler); + IO_PA3_SetInterruptHandler(IO_PA3_DefaultInterruptHandler); + IO_PD0_SetInterruptHandler(IO_PD0_DefaultInterruptHandler); + IO_PD1_SetInterruptHandler(IO_PD1_DefaultInterruptHandler); + IO_PD2_SetInterruptHandler(IO_PD2_DefaultInterruptHandler); + IO_PD3_SetInterruptHandler(IO_PD3_DefaultInterruptHandler); + IO_PD4_SetInterruptHandler(IO_PD4_DefaultInterruptHandler); + IO_PD5_SetInterruptHandler(IO_PD5_DefaultInterruptHandler); + IO_PD6_SetInterruptHandler(IO_PD6_DefaultInterruptHandler); + IO_PD7_SetInterruptHandler(IO_PD7_DefaultInterruptHandler); +} + +/** + Allows selecting an interrupt handler for IO_PA5 at application runtime +*/ +void IO_PA5_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PA5_InterruptHandler = interruptHandler; +} + +void IO_PA5_DefaultInterruptHandler(void) +{ + // add your IO_PA5 interrupt custom code + // or set custom function using IO_PA5_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PA4 at application runtime +*/ +void IO_PA4_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PA4_InterruptHandler = interruptHandler; +} + +void IO_PA4_DefaultInterruptHandler(void) +{ + // add your IO_PA4 interrupt custom code + // or set custom function using IO_PA4_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PA6 at application runtime +*/ +void IO_PA6_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PA6_InterruptHandler = interruptHandler; +} + +void IO_PA6_DefaultInterruptHandler(void) +{ + // add your IO_PA6 interrupt custom code + // or set custom function using IO_PA6_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PA7 at application runtime +*/ +void IO_PA7_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PA7_InterruptHandler = interruptHandler; +} + +void IO_PA7_DefaultInterruptHandler(void) +{ + // add your IO_PA7 interrupt custom code + // or set custom function using IO_PA7_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PA2 at application runtime +*/ +void IO_PA2_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PA2_InterruptHandler = interruptHandler; +} + +void IO_PA2_DefaultInterruptHandler(void) +{ + // add your IO_PA2 interrupt custom code + // or set custom function using IO_PA2_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PA3 at application runtime +*/ +void IO_PA3_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PA3_InterruptHandler = interruptHandler; +} + +void IO_PA3_DefaultInterruptHandler(void) +{ + // add your IO_PA3 interrupt custom code + // or set custom function using IO_PA3_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD0 at application runtime +*/ +void IO_PD0_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD0_InterruptHandler = interruptHandler; +} + +void IO_PD0_DefaultInterruptHandler(void) +{ + // add your IO_PD0 interrupt custom code + // or set custom function using IO_PD0_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD1 at application runtime +*/ +void IO_PD1_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD1_InterruptHandler = interruptHandler; +} + +void IO_PD1_DefaultInterruptHandler(void) +{ + // add your IO_PD1 interrupt custom code + // or set custom function using IO_PD1_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD2 at application runtime +*/ +void IO_PD2_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD2_InterruptHandler = interruptHandler; +} + +void IO_PD2_DefaultInterruptHandler(void) +{ + // add your IO_PD2 interrupt custom code + // or set custom function using IO_PD2_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD3 at application runtime +*/ +void IO_PD3_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD3_InterruptHandler = interruptHandler; +} + +void IO_PD3_DefaultInterruptHandler(void) +{ + // add your IO_PD3 interrupt custom code + // or set custom function using IO_PD3_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD4 at application runtime +*/ +void IO_PD4_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD4_InterruptHandler = interruptHandler; +} + +void IO_PD4_DefaultInterruptHandler(void) +{ + // add your IO_PD4 interrupt custom code + // or set custom function using IO_PD4_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD5 at application runtime +*/ +void IO_PD5_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD5_InterruptHandler = interruptHandler; +} + +void IO_PD5_DefaultInterruptHandler(void) +{ + // add your IO_PD5 interrupt custom code + // or set custom function using IO_PD5_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD6 at application runtime +*/ +void IO_PD6_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD6_InterruptHandler = interruptHandler; +} + +void IO_PD6_DefaultInterruptHandler(void) +{ + // add your IO_PD6 interrupt custom code + // or set custom function using IO_PD6_SetInterruptHandler() +} +/** + Allows selecting an interrupt handler for IO_PD7 at application runtime +*/ +void IO_PD7_SetInterruptHandler(void (* interruptHandler)(void)) +{ + IO_PD7_InterruptHandler = interruptHandler; +} + +void IO_PD7_DefaultInterruptHandler(void) +{ + // add your IO_PD7 interrupt custom code + // or set custom function using IO_PD7_SetInterruptHandler() +} +ISR(PORTA_PORT_vect) +{ + // Call the interrupt handler for the callback registered at runtime + if(VPORTA.INTFLAGS & PORT_INT5_bm) + { + IO_PA5_InterruptHandler(); + } + if(VPORTA.INTFLAGS & PORT_INT4_bm) + { + IO_PA4_InterruptHandler(); + } + if(VPORTA.INTFLAGS & PORT_INT6_bm) + { + IO_PA6_InterruptHandler(); + } + if(VPORTA.INTFLAGS & PORT_INT7_bm) + { + IO_PA7_InterruptHandler(); + } + if(VPORTA.INTFLAGS & PORT_INT2_bm) + { + IO_PA2_InterruptHandler(); + } + if(VPORTA.INTFLAGS & PORT_INT3_bm) + { + IO_PA3_InterruptHandler(); + } + /* Clear interrupt flags */ + VPORTA.INTFLAGS = 0xff; +} + +ISR(PORTC_PORT_vect) +{ + /* Clear interrupt flags */ + VPORTC.INTFLAGS = 0xff; +} + +ISR(PORTD_PORT_vect) +{ + // Call the interrupt handler for the callback registered at runtime + if(VPORTD.INTFLAGS & PORT_INT0_bm) + { + IO_PD0_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT1_bm) + { + IO_PD1_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT2_bm) + { + IO_PD2_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT3_bm) + { + IO_PD3_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT4_bm) + { + IO_PD4_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT5_bm) + { + IO_PD5_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT6_bm) + { + IO_PD6_InterruptHandler(); + } + if(VPORTD.INTFLAGS & PORT_INT7_bm) + { + IO_PD7_InterruptHandler(); + } + /* Clear interrupt flags */ + VPORTD.INTFLAGS = 0xff; +} + +ISR(PORTF_PORT_vect) +{ + /* Clear interrupt flags */ + VPORTF.INTFLAGS = 0xff; +} + +/** + End of File +*/ \ No newline at end of file -- cgit v1.2.3