diff options
Diffstat (limited to 'mcc_generated_files/system/src/pins.c')
| -rw-r--r-- | mcc_generated_files/system/src/pins.c | 393 |
1 files changed, 393 insertions, 0 deletions
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 |