void portInit2() { SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlDelay(10); //delay by (3 * 10) 30 clock cycles SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlDelay(10); //delay by (3 * 10) 30 clock cycles //IntMasterEnable(); //Temporarily put here GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); //UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 9600, // (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | // UART_CONFIG_PAR_NONE)); // If interrupts are desired, then enable interrupts on this UART IntEnable(INT_UART0); UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); UARTStdioInit(0); //configures this UART0 as the uart to use for UARTprintf SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlDelay(10); //delay by (3 * 10) 30 clock cycles /* Outputs */ GPIOPadConfigSet(GPIO_PORTB_BASE, (GPIO_PIN_0 | GPIO_PIN_1), GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD); GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, (GPIO_PIN_0 | GPIO_PIN_1)); //configure LEDs IntMasterEnable(); }
//***************************************************************************** // // This example application demonstrates the use of the timers to generate // periodic interrupts. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Initialize the UART and write status. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); UARTprintf("\033[2JTimers example\n"); UARTprintf("T1: 0 T2: 0"); // // Enable the peripherals used by this example. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); // // Enable processor interrupts. // ROM_IntMasterEnable(); // // Configure the two 32-bit periodic timers. // ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC); ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()); ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet() / 2); // // Setup the interrupts for the timer timeouts. // ROM_IntEnable(INT_TIMER0A); ROM_IntEnable(INT_TIMER1A); ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT); // // Enable the timers. // ROM_TimerEnable(TIMER0_BASE, TIMER_A); ROM_TimerEnable(TIMER1_BASE, TIMER_A); // // Loop forever while the timers run. // while(1) { } }
/* ** Main Function. */ int main(void) { unsigned char choice = 0; /* Enable the clocks for McSPI0 module.*/ McSPI0ModuleClkConfig(); /* Perform Pin-Muxing for SPI0 Instance.*/ McSPIPinMuxSetup(0); /* Perform Pin-Muxing for CS0 of SPI0 Instance.*/ McSPI0CSPinMuxSetup(MCSPI_CH_NUM); /* Initialize the UART utility functions.*/ UARTStdioInit(); /* Enable IRQ in CPSR.*/ IntMasterIRQEnable(); UARTPuts("Here the McSPI controller on the SOC communicates with ",-1); UARTPuts("the McSPI Flash.\r\n\r\n",-1); /* Initialize the EDMA3 instance.*/ EDMA3Initialize(); /* Request EDMA3CC for Tx and Rx channels for SPI0. */ RequestEDMA3Channels(); /* Set up the McSPI instance.*/ McSPISetUp(); /* Enable the SPI Flash for writing to it. */ WriteEnable(); UARTPuts("Do you want to erase a sector of the flash before writing to it ?.", -1); UARTPuts("\r\nInput y(Y)/n(N) to proceed.\r\n", -1); choice = UARTGetc(); UARTPutc(choice); if(('y' == choice) || ('Y' == choice)) { /* Erasing the specified sector of SPI Flash. */ FlashSectorErase(); } /* Enable the SPI Flash for writing to it. */ WriteEnable(); /* Write data of 1 page size into a page of Flash.*/ FlashPageProgram(); /* Read data of 1 page size from a page of flash.*/ ReadFromFlash(); /* Verify the data written to and read from Flash are same or not.*/ VerifyData(); while(1); }
//***************************************************************************** // //! Initializes the user interface. //! //! This function initializes the user interface modules (ethernet), //! preparing them to operate. //! //! \return None. // //***************************************************************************** void UIInit(void) { // // Initialize the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); UARTprintf("\033[2JEK-LM3S9B92 Plane-Power control board\n"); // // Initialize the Ethernet user interface. Use DHCP // UIEthernetInit( true ); // // Configure SysTick to provide a periodic user interface interrupt. // SysTickPeriodSet( ROM_SysCtlClockGet() / UI_INT_RATE ); SysTickIntEnable(); SysTickEnable(); }
//***************************************************************************** // // Print "Hello world!" to the UART on the Stellaris evaluation board. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Initialize the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); // // Hello! // UARTprintf("\033[2JHello World!\n"); // // Finished. // while(1) { } }
//***************************************************************************** // // This function sets up UART0 to be used for a console to display information // as the example is running. // //***************************************************************************** void InitConsole(void) { // // Enable GPIO port A which is used for UART0 pins. // TODO: change this to whichever GPIO port you are using. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Configure the pin muxing for UART0 functions on port A0 and A1. // This step is not necessary if your part does not support pin muxing. // TODO: change this to select the port/pin you are using. // GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); // // Select the alternate (UART) function for these pins. // TODO: change this to select the port/pin you are using. // GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Initialize the UART for console I/O. // UARTStdioInit(0); }
void init() { ROM_FPUEnable(); ROM_FPULazyStackingEnable(); ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIO_PORTB_DIR_R = 0x00; GPIO_PORTB_DEN_R = 0xff; ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 1000000); ROM_SysTickEnable(); ROM_SysTickIntEnable(); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); reset(); }
//***************************************************************************** // // Initializes the logging interface. // //***************************************************************************** void LogInit(void) { // // Enable the peripherals used to perform logging. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Configure the UART pins appropriately. // GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_1 | GPIO_PIN_0); // // Initialize the UART as a console for text I/O. // UARTStdioInit(0); // // Print hello message to user via the serial port. // UARTprintf("\n\nQuickstart Keypad Example Program\n"); UARTprintf("Type \'help\' for help.\n"); // // Write a log message to indicate that the application has started. // LogWrite("Application started"); }
static void uart_setup(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); }
// Serial virtual void SerialBegin(int serialDevice, int baudrate) { if (serialDevice == 0) { MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); MAP_GPIOPinConfigure(GPIO_PA0_U0RX); MAP_GPIOPinConfigure(GPIO_PA1_U0TX); MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); UARTEnable(UART0_BASE); } }
void UartInit(void) { /* Enable GPIO port A which is used for UART0 pins. */ SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); /* Make the UART pins be peripheral controlled. */ GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); /* Initialize the UART for console I/O. */ UARTStdioInit(0); }
/** Initialize UART0 to use for stdio * @pre UART0 pins were configured */ void halUartInit() { SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); PERIPHERAL_ENABLE_DELAY(); #ifdef TIVA //UARTStdioConfig(uint32_t ui32PortNum, uint32_t ui32Baud, uint32_t ui32SrcClock) UARTStdioConfig(0, 115200, SysCtlClockGet()); #else UARTStdioInit(0); //configures this UART0 as the uart to use for UARTprintf #endif IntEnable(INT_UART0); // If interrupts are desired, then enable interrupts on this UART UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT); }
void cmd_init(void) { // // Enable and Initialize the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); cmd_printf("\nSplitAlarm - UART Loaded\n"); cmd_printf("> "); }
int main(void) { unsigned int triggerValue = 0; /* Setup the MMU and do necessary MMU configurations. */ MMUConfigAndEnable(); /* Enable all levels of CACHE. */ CacheEnable(CACHE_ALL); /* Set up the UART2 peripheral */ UARTStdioInit(); /* Enable the WDT clocks */ WatchdogTimer1ModuleClkConfig(); /* Reset the Watchdog Timer */ WatchdogTimerReset(SOC_WDT_1_REGS); /* Disable the Watchdog timer */ WatchdogTimerDisable(SOC_WDT_1_REGS); /* Perform the initial settings for the Watchdog Timer */ WatchdogTimerSetUp(); /* Send the message to UART console */ UARTPuts("Program Reset!", -1); UARTPuts("Input any key at least once in every 4 seconds to avoid a further reset.\n\r", -1); /* Enable the Watchdog Timer */ WatchdogTimerEnable(SOC_WDT_1_REGS); while(1) { /* Wait for an input through UART. If no input is given, ** the WDT will timeout and reset will occur. */ if(UARTGetc()) { triggerValue += 1; /* Write into the trigger register. This will load the value from the ** load register into the counter register and hence timer will start ** from the initial count. */ WatchdogTimerTriggerSet(SOC_WDT_1_REGS, triggerValue); } } }
// //Initialization method // void init(void) { //Necessary inits for chip LockoutProtection(); InitializeMCU(); //Various driver inits //initUART SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); //motors InitializeMotors(false, false); }
//***************************************************************************** // // Initialize FreeRTOS and start the initial set of tasks. // //***************************************************************************** int main(void) { // // Set the clocking to run at 50 MHz from the PLL. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_8MHZ | SYSCTL_OSC_MAIN); // // Initialize the UART and configure it for 115,200, 8-N-1 operation. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); // // Print demo introduction. // UARTprintf("\n\nLM3S5749 FreeRTOS\n"); // // Create a mutex to guard the UART. // g_pUARTSemaphore = xSemaphoreCreateMutex(); // // Create the LED task. // if(TestTaskInit() != 0) { while(1) ; } // // Start the scheduler. This should not return. // vTaskStartScheduler(); // // In case the scheduler returns for some reason, print an error and loop // forever. // while(1) ; }
/* ** Interrupt Service Routine for UART. */ static void UARTIsr(void) { /* Reconfiguring the UART STDIO instance. */ UARTStdioInit(); UARTPuts("StarterWare Interrupt Preemption Demonstration.\r\n", -2); UARTPuts("UART ISR Entry.\r\n", -1); RTCSetupAndEnable(); /* Wait till any higher priority ISR changes preemptFlag */ while(PREEMPT_FLAG_DEFAULT == preemptFlag); UARTPuts("UART ISR Exit.\r\n", -1); }
void InitConsole(void) { SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); /* Make the UART pins be peripheral controlled. */ GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Initialize the UART for console I/O. // UARTStdioInit(0); }
void Task_PrintData_Init( ) { // // Enable UART0, to be used as a serial console. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Initialize the UART standard I/O. // UARTStdioInit( 0 ); UARTprintf( "FreeRTOS EvalBot starting\n" ); }
//***************************************************************************** // // The main entry point for the qs-autonomous example. It initializes the // system, then eners a forever loop where it runs the scheduler. The // scheduler then periodically calls all the tasks in the example to keep // the program running. // //***************************************************************************** int main (void) { // // Set the system clock to run at 50MHz from the PLL // ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Enable UART0, to be used as a serial console. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Initialize the UART standard I/O. // UARTStdioInit(0); UARTprintf("EVALBOT starting\n"); // // Initialize the simple scheduler to use a tick rate of 100 Hz. // SchedulerInit(100); // // Initialize all the tasks used in the example. // DriveInit(); DisplayTaskInit(); LEDTaskInit(); SoundTaskInit(); AutoTaskInit(); // // Enter a forever loop and call the scheduler. The scheduler will // periodically call all the tasks in the system according to the timeout // value of each task. // for(;;) { SchedulerRun(); } }
int main(void) { MMUConfigAndEnable(); CacheEnable(CACHE_ALL); SetupIntc(); UARTStdioInit(); /* This function will enable clocks for the DMTimer2 instance */ DMTimer2ModuleClkConfig(); TouchScreenInit(); return 0; }
/****************************************************************************** ** FUNCTION DEFINITIONS *******************************************************************************/ int main(void) { /* Set up the UART2 peripheral */ UARTStdioInit(); /* Set up the Timer2 peripheral */ TimerSetUp64Bit(); /* Set up the AINTC to generate Timer2 interrupts */ TimerIntrSetUp(); /* Enable the timer interrupt */ TimerIntEnable(SOC_TMR_2_REGS, TMR_INT_TMR12_NON_CAPT_MODE); #ifndef _TMS320C6X /* Switch to non privileged mode; This is done for demonstration purpose */ CPUSwitchToUserMode(); #endif /* Send the first String */ UARTPuts("Tencounter: 9", -1); /* Start the timer. Characters from cntArr will be sent from the ISR */ TimerEnable(SOC_TMR_2_REGS, TMR_TIMER12, TMR_ENABLE_CONT); /* make sure all the characters from cntArray from ISR */ while(secCnt < 9) { /* Replace previous number each time the timer interrupt occurs */ if(flagIsrCnt) { UARTPutc('\b'); UARTPutc(cntArr[secCnt]); secCnt++; flagIsrCnt = 0; } } /* Disable the timer. No more timer interrupts */ TimerDisable(SOC_TMR_2_REGS, TMR_TIMER12); /* Halt the program */ while(1); }
//***************************************************************************** // // This function sets up UART0 to be used for a console to display information // as the example is running. // //***************************************************************************** void InitConsole(void) { // // Map UART signals to the correct GPIO pins and configure them as // hardware controlled. // IOCPinConfigPeriphOutput(EXAMPLE_GPIO_UART_BASE, EXAMPLE_PIN_UART_TXD, IOC_MUX_OUT_SEL_UART0_TXD); GPIOPinTypeUARTOutput(EXAMPLE_GPIO_UART_BASE, EXAMPLE_PIN_UART_TXD); IOCPinConfigPeriphInput(EXAMPLE_GPIO_UART_BASE, EXAMPLE_PIN_UART_RXD, IOC_UARTRXD_UART0); GPIOPinTypeUARTInput(EXAMPLE_GPIO_UART_BASE, EXAMPLE_PIN_UART_RXD); // // Initialize the UART (UART0) for console I/O. // UARTStdioInit(0); }
void InitConsole(void) { SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); /* Make the UART pins be peripheral controlled. */ GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); //Initialize UART UARTConfigSetExpClk(UART0_BASE, 8000000, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); UARTEnable(UART0_BASE); // Initialize the UART for console I/O. UARTStdioInit(0); }
/* ------------------------------------------------------------------------------------------------------ * BSP_Init() * * Description : MCU sysctl init function. * * Argument(s) : none. * */ void BSP_Init(void) { /* If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is a workaround to allow the PLL to operate reliably. */ if( DEVICE_IS_REVA2 ) { SysCtlLDOSet( SYSCTL_LDO_2_75V ); } // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Enable the LED. // BSP_LedInit(); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Set GPIO A0 and A1 as UART. // GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Initialize the UART as a console for text I/O. // UARTStdioInit(0); UARTprintf("BSP initialise\n"); }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { tRectangle sRect; tUSBMode eLastMode; char *pcString; // // Enable lazy stacking for interrupt handlers. This allows floating-point // instructions to be used within interrupt handlers, but at the expense of // extra stack usage. // ROM_FPULazyStackingEnable(); // // Set the system clock to run at 50MHz from the PLL. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Initially wait for device connection. // g_eUSBState = STATE_NO_DEVICE; eLastMode = USB_MODE_OTG; g_eCurrentUSBMode = USB_MODE_OTG; // // Enable Clocking to the USB controller. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); // // Configure the required pins for USB operation. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN); ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure SysTick for a 100Hz interrupt. // ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND); ROM_SysTickEnable(); ROM_SysTickIntEnable(); // // Enable Interrupts // ROM_IntMasterEnable(); // // Enable clocking to the UART and associated GPIO // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure the relevant pins such that UART0 owns them. // ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Open UART0 for debug output. // UARTStdioInit(0); // // Initialize the USB stack mode and pass in a mode callback. // USBStackModeSet(0, USB_MODE_OTG, ModeCallback); // // Register the host class drivers. // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers); // // Open an instance of the keyboard driver. The keyboard does not need // to be present at this time, this just save a place for it and allows // the applications to be notified when a keyboard is present. // g_ulKeyboardInstance = USBHKeyboardOpen(KeyboardCallback, g_pucBuffer, KEYBOARD_MEMORY_SIZE); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); // // Initialize the USB controller for OTG operation with a 2ms polling // rate. // USBOTGModeInit(0, 2000, g_pHCDPool, HCD_MEMORY_SIZE); // // Initialize the display driver. // CFAL96x64x16Init(); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sCFAL96x64x16); // // Fill the top part of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1; sRect.sYMax = (2 * DISPLAY_BANNER_HEIGHT) - 1; GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG); GrRectFill(&g_sContext, &sRect); // // Change foreground for white text. // GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_FG); // // Put the application name in the middle of the banner. // GrContextFontSet(&g_sContext, g_pFontFixed6x8); GrStringDrawCentered(&g_sContext, "usb-host-", -1, GrContextDpyWidthGet(&g_sContext) / 2, 4, 0); GrStringDrawCentered(&g_sContext, "keyboard", -1, GrContextDpyWidthGet(&g_sContext) / 2, 14, 0); // // Calculate the number of characters that will fit on a line. // Make sure to leave a small border for the text box. // g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) / GrFontMaxWidthGet(g_pFontFixed6x8); // // Calculate the number of lines per usable text screen. This requires // taking off space for the top and bottom banners and adding a small bit // for a border. // g_ulLinesPerScreen = (GrContextDpyHeightGet(&g_sContext) - (3*(DISPLAY_BANNER_HEIGHT + 1)))/ GrFontHeightGet(g_pFontFixed6x8); // // Open and instance of the keyboard class driver. // UARTprintf("Host Keyboard Application\n"); // // Initial update of the screen. // UpdateStatus(); // // The main loop for the application. // while(1) { // // Tell the OTG library code how much time has passed in // milliseconds since the last call. // USBOTGMain(GetTickms()); // // Has the USB mode changed since last time we checked? // if(g_eCurrentUSBMode != eLastMode) { // // Remember the new mode. // eLastMode = g_eCurrentUSBMode; switch(eLastMode) { case USB_MODE_HOST: pcString = "HOST"; break; case USB_MODE_DEVICE: pcString = "DEVICE"; break; case USB_MODE_NONE: pcString = "NONE"; break; default: pcString = "UNKNOWN"; break; } UARTprintf("USB mode changed to %s\n", pcString); } switch(g_eUSBState) { // // This state is entered when they keyboard is first detected. // case STATE_KEYBOARD_INIT: { // // Initialized the newly connected keyboard. // USBHKeyboardInit(g_ulKeyboardInstance); // // Proceed to the keyboard connected state. // g_eUSBState = STATE_KEYBOARD_CONNECTED; // // Update the screen now that the keyboard has been // initialized. // UpdateStatus(); USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers); break; } case STATE_KEYBOARD_UPDATE: { // // If the application detected a change that required an // update to be sent to the keyboard to change the modifier // state then call it and return to the connected state. // g_eUSBState = STATE_KEYBOARD_CONNECTED; USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers); break; } case STATE_KEYBOARD_CONNECTED: { // // Nothing is currently done in the main loop when the keyboard // is connected. // break; } case STATE_UNKNOWN_DEVICE: { // // Nothing to do as the device is unknown. // break; } case STATE_NO_DEVICE: { // // Nothing is currently done in the main loop when the keyboard // is not connected. // break; } default: { break; } } } }
//***************************************************************************** // // This example application demonstrates the use of a periodic timer to // request DMA transfers. // // Timer0 is used as the periodic timer that requests DMA transfers. // Timer1 is a free running counter that is used as the source data for // DMA transfers. The captured counter values from Timer1 are copied by // uDMA into a buffer. // //***************************************************************************** int main(void) { unsigned long ulIdx; unsigned long ulThisTimerVal; unsigned long ulPrevTimerVal; unsigned long ulTimerElapsed; unsigned long ulTimerErr; // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Initialize the UART and write status. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); UARTprintf("\033[2JuDMA periodic timer example\n\n"); // // Enable the timers used by this example. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); // // Enable the uDMA peripheral // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); // // Enable the uDMA controller error interrupt. This interrupt will occur // if there is a bus error during a transfer. // ROM_IntEnable(INT_UDMAERR); // // Enable the uDMA controller. // ROM_uDMAEnable(); // // Point at the control table to use for channel control structures. // ROM_uDMAControlBaseSet(ucControlTable); // // Enable processor interrupts. // ROM_IntMasterEnable(); // // Configure one of the timers as free running 32-bit counter. Its // value will be used as a time reference. // ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC); ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ~0); ROM_TimerEnable(TIMER1_BASE, TIMER_A); // // Configure the 32-bit periodic timer. // ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, TIMEOUT_VAL - 1); // // Enable the timer master interrupt. The timer interrupt will actually // be generated by the uDMA controller when the timer channel transfer is // complete. The interrupts on the timer (TimerIntEnable) do not need // to be configured. // ROM_IntEnable(INT_TIMER0A); // // Put the attributes in a known state for the uDMA Timer0A channel. These // should already be disabled by default. // ROM_uDMAChannelAttributeDisable(UDMA_CHANNEL_TMR0A, UDMA_ATTR_ALTSELECT | UDMA_ATTR_USEBURST | UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK); // // Set up the DMA channel for Timer 0A. Set it up to transfer single // 32-bit words at a time. The source is non-incrementing, the // destination is incrementing. // ROM_uDMAChannelControlSet(UDMA_CHANNEL_TMR0A | UDMA_PRI_SELECT, UDMA_SIZE_32 | UDMA_SRC_INC_NONE | UDMA_DST_INC_32 | UDMA_ARB_1); // // Set up the transfer for Timer 0A DMA channel. Basic mode is used, // which means that one transfer will occur per timer request (timeout). // The amount transferred per timeout is determined by the arbitration // size (see function above). The source will be the value of free running // Timer1, and the destination is a memory buffer. Thus, the value of the // free running Timer1 will be stored in a buffer every time the periodic // Timer0 times out. // ROM_uDMAChannelTransferSet(UDMA_CHANNEL_TMR0A | UDMA_PRI_SELECT, UDMA_MODE_BASIC, (void *)(TIMER1_BASE + TIMER_O_TAV), g_ulTimerBuf, MAX_TIMER_EVENTS); // // Enable the timers and the DMA channel. // UARTprintf("Using timeout value of %u\n", TIMEOUT_VAL); UARTprintf("Starting timer and uDMA\n"); TimerEnable(TIMER0_BASE, TIMER_A); uDMAChannelEnable(UDMA_CHANNEL_TMR0A); // // Wait for the transfer to complete. // UARTprintf("Waiting for transfers to complete\n"); while(!g_bDoneFlag) { } // // Check for the expected number of occurrences of the interrupt handler, // and that there are no DMA errors // if(g_uluDMAErrCount != 0) { UARTprintf("\nuDMA errors were detected!!!\n\n"); } if(g_ulTimer0AIntCount != 1) { UARTprintf("\nUnexpected number of interrupts occurrred (%d)!!!\n\n", g_ulTimer0AIntCount); } // // Display the timer values that were transferred using timer triggered // uDMA. Compare the difference between stored values to the timer // period and make sure they match. This verifies that the periodic // DMA transfers were occuring with the correct timing. // UARTprintf("\n Captured\n"); UARTprintf("Event Value Difference Status\n"); UARTprintf("----- ---------- ---------- ------\n"); for(ulIdx = 1; ulIdx < MAX_TIMER_EVENTS; ulIdx++) { // // Compute the difference between adjacent captured values, and then // compare that to the expected timeout period. // ulThisTimerVal = g_ulTimerBuf[ulIdx]; ulPrevTimerVal = g_ulTimerBuf[ulIdx - 1]; ulTimerElapsed = ulThisTimerVal > ulPrevTimerVal ? ulThisTimerVal - ulPrevTimerVal : ulPrevTimerVal - ulThisTimerVal; ulTimerErr = ulTimerElapsed > TIMEOUT_VAL ? ulTimerElapsed - TIMEOUT_VAL : TIMEOUT_VAL - ulTimerElapsed; // // Print the captured value and the difference from the previous // UARTprintf(" %2u 0x%08X %8u ", ulIdx, ulThisTimerVal, ulTimerElapsed); // // Print error status based on the deviation from expected difference // between samples (calculated above). Allow for a difference of up // to 1 cycle. Any more than that is considered an error. // if(ulTimerErr > 1) { UARTprintf(" ERROR\n"); } else { UARTprintf(" OK\n"); } } // // End of application // while(1) { } }
//***************************************************************************** // // Demonstrate the use of the USB stick update example. // //***************************************************************************** int main(void) { unsigned long ulCount; // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Enable the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); UARTprintf("\n\nUSB Stick Update Demo\n---------------------\n\n"); // // Enable the GPIO module which the select button is attached to. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Indicate what is happening. // UARTprintf("Press the user button to start the USB stick updater\n\n"); // // Enable the GPIO pin to read the select button. // ROM_GPIODirModeSet(GPIO_PORTB_BASE, GPIO_PIN_4, GPIO_DIR_MODE_IN); ROM_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); // // Wait for the pullup to take effect or the next loop will exist too soon. // SysCtlDelay(1000); // // Wait until the select button has been pressed for ~40ms (in order to // debounce the press). // ulCount = 0; while(1) { // // See if the button is pressed. // if(ROM_GPIOPinRead(GPIO_PORTB_BASE, GPIO_PIN_4) == 0) { // // Increment the count since the button is pressed. // ulCount++; // // If the count has reached 4, then the button has been debounced // as being pressed. // if(ulCount == 4) { break; } } else { // // Reset the count since the button is not pressed. // ulCount = 0; } // // Delay for approximately 10ms. // SysCtlDelay(16000000 / (3 * 100)); } // // Wait until the select button has been released for ~40ms (in order to // debounce the release). // ulCount = 0; while(1) { // // See if the button is pressed. // if(ROM_GPIOPinRead(GPIO_PORTB_BASE, GPIO_PIN_4) != 0) { // // Increment the count since the button is released. // ulCount++; // // If the count has reached 4, then the button has been debounced // as being released. // if(ulCount == 4) { break; } } else { // // Reset the count since the button is pressed. // ulCount = 0; } // // Delay for approximately 10ms. // SysCtlDelay(16000000 / (3 * 100)); } // // Indicate that the updater is being called. // UARTprintf("The USB stick updater is now running and looking for a\n" "USB memory stick\n\n"); // // Wait for the entire message above to transmit before continuing // while(UARTBusy(UART0_BASE)) { } // // Call the updater so that it will search for an update on a memory stick. // (*((void (*)(void))(*(unsigned long *)0x2c)))(); // // The updater should take control, so this should never be reached. // Just in case, loop forever. // while(1) { } }
//***************************************************************************** // // The program main function. It performs initialization, then handles wav // file playback. // //***************************************************************************** int main(void) { int nStatus; // // Set the system clock to run at 80MHz from the PLL. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Give bget some memory to work with. // bpool(g_pulHeap, sizeof(g_pulHeap)); // // Set the device pin out appropriately for this board. // PinoutSet(); // // Configure the relevant pins such that UART0 owns them. // ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Open the UART for I/O // UARTStdioInit(0); UARTprintf("i2s_speex_enc\n"); // // Configure and enable uDMA // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); SysCtlDelay(10); ROM_uDMAControlBaseSet(&sDMAControlTable[0]); ROM_uDMAEnable(); // // Enable Interrupts // ROM_IntMasterEnable(); // // Configure the I2S peripheral. // SoundInit(1); // // Set the format of the play back in the sound driver. // SoundSetFormat(AUDIO_RATE, AUDIO_BITS, AUDIO_CHANNELS); // // Print out some header information to the serial console. // UARTprintf("\ni2s_speex_enc Stellaris Example\n"); UARTprintf("Streaming at %d %d bit ",SoundSampleRateGet(), AUDIO_BITS); if(AUDIO_CHANNELS == 2) { UARTprintf("Stereo\n"); } else { UARTprintf("Mono\n"); } // // Set the initial volume. // SoundVolumeSet(INITIAL_VOLUME_PERCENT); // // Initialize the Speex decoder. // SpeexDecodeInit(); // // Set the default quality to 2. // g_iQuality = 2; // // Initialize the Speex encoder to Complexity of 1 and Quality 2. // SpeexEncodeInit(AUDIO_RATE, 1, g_iQuality); // // Initialize the audio buffers. // InitBuffers(); // // Initialize the applications global state flags. // g_ulFlags = 0; // // Kick off a request for a buffer play back and advance the encoder // pointer. // SoundBufferRead(g_pucRecBuffer, RECORD_BUFFER_INC, RecordBufferCallback); g_pucEncode += RECORD_BUFFER_INC; // // Kick off a second request for a buffer play back and advance the encode // pointer. // SoundBufferRead(&g_pucRecBuffer[RECORD_BUFFER_INC], RECORD_BUFFER_INC, RecordBufferCallback); g_pucEncode += RECORD_BUFFER_INC; // // The rest of the handling occurs at interrupt time so the main loop will // simply stall here. // while(1) { // // Print a prompt to the console. Show the CWD. // UARTprintf("\n> "); // // Get a line of text from the user. // UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf)); // // Pass the line from the user to the command processor. // It will be parsed and valid commands executed. // nStatus = CmdLineProcess(g_cCmdBuf); // // Handle the case of bad command. // if(nStatus == CMDLINE_BAD_CMD) { UARTprintf("Bad command!\n"); } // // Handle the case of too many arguments. // else if(nStatus == CMDLINE_TOO_MANY_ARGS) { UARTprintf("Too many arguments for command processor!\n"); } // // Otherwise the command was executed. Print the error // code if one was returned. // else if(nStatus != 0) { UARTprintf("Command returned error code \n"); } } }
//***************************************************************************** // // This example demonstrates how to configure MPU regions for different levels // of memory protection. The following memory map is set up: // // 0000.0000 - 0000.1C00 - rgn 0: executable read-only, flash // 0000.1C00 - 0000.2000 - rgn 0: no access, flash (disabled sub-region 7) // 0100.0000 - 0100.8000 - rgn 1: executable read-only, ROM // 2000.0000 - 2000.8000 - rgn 2: read-write, RAM // 2000.8000 - 2000.A000 - rgn 3: read-only, RAM (disabled sub-rgn 4 of rgn 1) // 2000.A000 - 2000.FFFF - rgn 2: read-write, RAM // 4000.0000 - 4001.0000 - rgn 4: read-write, peripherals // 4001.0000 - 4002.0000 - rgn 4: no access (disabled sub-region 1) // 4002.0000 - 4006.0000 - rgn 4: read-write, peripherals // 4006.0000 - 4008.0000 - rgn 4: no access (disabled sub-region 6, 7) // E000.E000 - E000.F000 - rgn 5: read-write, NVIC // // The example code will attempt to perform the following operations and check // the faulting behavior: // // - write to flash (should fault) // - read from the disabled area of flash (should fault) // - read from the read-only area of RAM (should not fault) // - write to the read-only section of RAM (should fault) // //***************************************************************************** int main(void) { unsigned int bFail = 0; // // Set the clocking to run directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Initialize the UART and write status. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinConfigure(GPIO_PA0_U0RX); GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); UARTprintf("\033[2JMPU example\n"); // // Configure an executable, read-only MPU region for flash. It is an 8 KB // region with the last 1 KB disabled to result in a 7 KB executable // region. This region is needed so that the program can execute from // flash. // ROM_MPURegionSet(0, FLASH_BASE, MPU_RGN_SIZE_8K | MPU_RGN_PERM_EXEC | MPU_RGN_PERM_PRV_RO_USR_RO | MPU_SUB_RGN_DISABLE_7 | MPU_RGN_ENABLE); // // Configure an executable, read-only MPU region for ROM. This region is // needed so that the program can execute DriverLib from ROM. // ROM_MPURegionSet(1, 0x01000000, MPU_RGN_SIZE_32K | MPU_RGN_PERM_EXEC | MPU_RGN_PERM_PRV_RO_USR_RO | MPU_RGN_ENABLE); // // Configure a read-write MPU region for RAM. It is a 64+32 KB region. // There is a 8 KB sub-region in the middle that is disabled in order to // open up a hole in which different permissions can be applied. // ROM_MPURegionSet(2, SRAM_BASE, MPU_RGN_SIZE_64K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_SUB_RGN_DISABLE_4 | MPU_RGN_ENABLE); ROM_MPURegionSet(3, SRAM_BASE + 65536, MPU_RGN_SIZE_32K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_SUB_RGN_DISABLE_4 | MPU_RGN_ENABLE); // // Configure a read-only MPU region for the 8 KB of RAM that is disabled in // the previous region. This region is used for demonstrating read-only // permissions. // ROM_MPURegionSet(4, SRAM_BASE + 0x8000, MPU_RGN_SIZE_2K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RO_USR_RO | MPU_RGN_ENABLE); // // Configure a read-write MPU region for peripherals. The region is 512 KB // total size, with several sub-regions disabled to prevent access to areas // where there are no peripherals. This region is needed because the // program needs access to some peripherals. // ROM_MPURegionSet(5, 0x40000000, MPU_RGN_SIZE_512K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_SUB_RGN_DISABLE_1 | MPU_SUB_RGN_DISABLE_6 | MPU_SUB_RGN_DISABLE_7 | MPU_RGN_ENABLE); // // Configure a read-write MPU region for access to the NVIC. The region is // 4 KB in size. This region is needed because NVIC registers are needed // in order to control the MPU. // ROM_MPURegionSet(6, NVIC_BASE, MPU_RGN_SIZE_4K | MPU_RGN_PERM_NOEXEC | MPU_RGN_PERM_PRV_RW_USR_RW | MPU_RGN_ENABLE); // // Need to clear the NVIC fault status register to make sure there is no // status hanging around from a previous program. // g_ulFaultStatus = HWREG(NVIC_FAULT_STAT); HWREG(NVIC_FAULT_STAT) = g_ulFaultStatus; // // Enable the MPU fault. // ROM_IntEnable(FAULT_MPU); // // Enable the MPU. This will begin to enforce the memory protection // regions. The MPU is configured so that when in the hard fault or NMI // exceptions, a default map will be used. Neither of these should occur // in this example program. // ROM_MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to write to the flash. This should cause a protection fault due // to the fact that this region is read-only. // UARTprintf("Check flash write..."); g_ulMPUFaultCount = 0; HWREG(0x100) = 0x12345678; // // Verify that the fault occurred, at the expected address. // if((g_ulMPUFaultCount == 1) && (g_ulFaultStatus == 0x82) && (g_ulMMAR == 0x100)) { UARTprintf("OK\n"); } else { bFail = 1; UARTprintf("Fail\n"); } // // The MPU was disabled when the previous fault occurred, so it needs to be // re-enabled. // ROM_MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to read from the disabled section of flash, the upper 1 KB of // the 8 KB region. // UARTprintf("Check flash read..."); g_ulMPUFaultCount = 0; g_ulValue = HWREG(0x1C10); // // Verify that the fault occurred, at the expected address. // if((g_ulMPUFaultCount == 1) && (g_ulFaultStatus == 0x82) && (g_ulMMAR == 0x1C10)) { UARTprintf("OK\n"); } else { bFail = 1; UARTprintf("Fail\n"); } // // The MPU was disabled when the previous fault occurred, so it needs to be // re-enabled. // ROM_MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to read from the read-only area of RAM, the middle 8 KB of the // 64 KB region. // UARTprintf("Check RAM read..."); g_ulMPUFaultCount = 0; g_ulValue = HWREG(0x20008440); // // Verify that the RAM read did not cause a fault. // if(g_ulMPUFaultCount == 0) { UARTprintf("OK\n"); } else { bFail = 1; UARTprintf("Fail\n"); } // // The MPU should not have been disabled since the last access was not // supposed to cause a fault. But if it did cause a fault, then the MPU // will be disabled, so re-enable it here anyway, just in case. // ROM_MPUEnable(MPU_CONFIG_HARDFLT_NMI); // // Attempt to write to the read-only area of RAM, the middle 8 KB of the // 64 KB region. // UARTprintf("Check RAM write..."); g_ulMPUFaultCount = 0; HWREG(0x20008460) = 0xabcdef00; // // Verify that the RAM write caused a fault. // if((g_ulMPUFaultCount == 1) && (g_ulFaultStatus == 0x82) && (g_ulMMAR == 0x20008460)) { UARTprintf("OK\n"); } else { bFail = 1; UARTprintf("Fail\n"); } // // Display the results of the example program. // if(bFail) { UARTprintf("Failure!\n"); } else { UARTprintf("Success!\n"); } // // Disable the MPU, so there are no lingering side effects if another // program is run. // ROM_MPUDisable(); // // Finished. // while(1) { } }