//***************************************************************************** // // Passes control to the bootloader and initiates a remote software update. // // This function passes control to the bootloader and initiates an update of // the main application firmware image via UART0 or USB depending // upon the specific boot loader binary in use. // // \return Never returns. // //***************************************************************************** void JumpToBootLoader(void) { // // We must make sure we turn off SysTick and its interrupt before entering // the boot loader! // ROM_SysTickIntDisable(); ROM_SysTickDisable(); // // Disable all processor interrupts. Instead of disabling them // one at a time, a direct write to NVIC is done to disable all // peripheral interrupts. // HWREG(NVIC_DIS0) = 0xffffffff; HWREG(NVIC_DIS1) = 0xffffffff; HWREG(NVIC_DIS2) = 0xffffffff; HWREG(NVIC_DIS3) = 0xffffffff; // // Return control to the boot loader. This is a call to the SVC // handler in the boot loader. // (*((void (*)(void))(*(uint32_t *)0x2c)))(); }
void initSysTick(void) { ROM_SysTickDisable(); ROM_SysTickPeriodSet( SYSTICK_PERIOD ); /* Write 0 to STCURRENT to clear counter */ *((volatile uint32_t *)NVIC_ST_CURRENT) = 0; ROM_SysTickIntEnable(); ROM_SysTickEnable(); return; }
void SysTickHandler(void){ static long i = 0; buffer[i] = GPIO_PORTB_DATA_R; i++; if(i > BUFFERSIZE){ ROM_SysTickDisable(); ROM_SysTickIntDisable(); i = 0; // send it over uart for (int j = 0; j < BUFFERSIZE; j++){ uart_putch(buffer[j]); } } }
//***************************************************************************** // // This is the main application entry function. // //***************************************************************************** int main(void) { uint32_t ui32TxCount; uint32_t ui32RxCount; //uint32_t ui32Loop; // // 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 clocking to run from the PLL at 50MHz // #if 1 ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Configure the required pins for USB operation. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_5 | GPIO_PIN_4); //ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100); /* This code taken from: http://e2e.ti.com/support/microcontrollers/tiva_arm/f/908/t/311237.aspx */ #else #include "hw_nvic.h" FlashErase(0x00000000); ROM_IntMasterDisable(); ROM_SysTickIntDisable(); ROM_SysTickDisable(); uint32_t ui32SysClock; ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); ui32SysClock = ROM_SysCtlClockGet(); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5); ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100); HWREG(NVIC_DIS0) = 0xffffffff; HWREG(NVIC_DIS1) = 0xffffffff; HWREG(NVIC_DIS2) = 0xffffffff; HWREG(NVIC_DIS3) = 0xffffffff; HWREG(NVIC_DIS4) = 0xffffffff; int ui32Addr; for(ui32Addr = NVIC_PRI0; ui32Addr <= NVIC_PRI34; ui32Addr+=4) { HWREG(ui32Addr) = 0; } HWREG(NVIC_SYS_PRI1) = 0; HWREG(NVIC_SYS_PRI2) = 0; HWREG(NVIC_SYS_PRI3) = 0; ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); ROM_SysCtlPeripheralReset(SYSCTL_PERIPH_USB0); ROM_SysCtlUSBPLLEnable(); ROM_SysCtlDelay(ui32SysClock*2 / 3); ROM_IntMasterEnable(); ROM_UpdateUSB(0); while(1) { } #endif #define BOOTLOADER_TEST 0 #if BOOTLOADER_TEST #include "hw_nvic.h" //ROM_UpdateUART(); // May need to do the following here: // 0. See if this will cause bootloader to start //ROM_FlashErase(0); //ROM_UpdateUSB(0); #define SYSTICKS_PER_SECOND 100 uint32_t ui32SysClock = ROM_SysCtlClockGet(); ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND); ROM_SysTickIntEnable(); ROM_SysTickEnable(); //USBDCDTerm(0); // Disable all interrupts ROM_IntMasterDisable(); ROM_SysTickIntDisable(); ROM_SysTickDisable(); HWREG(NVIC_DIS0) = 0xffffffff; HWREG(NVIC_DIS1) = 0xffffffff; HWREG(NVIC_DIS2) = 0xffffffff; HWREG(NVIC_DIS3) = 0xffffffff; HWREG(NVIC_DIS4) = 0xffffffff; int ui32Addr; for(ui32Addr = NVIC_PRI0; ui32Addr <= NVIC_PRI34; ui32Addr+=4) { HWREG(ui32Addr) = 0; } HWREG(NVIC_SYS_PRI1) = 0; HWREG(NVIC_SYS_PRI2) = 0; HWREG(NVIC_SYS_PRI3) = 0; // 1. Enable USB PLL //ROM_SysCtlUSBPLLEnable(); // 2. Enable USB controller ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); ROM_SysCtlPeripheralReset(SYSCTL_PERIPH_USB0); //USBClockEnable(USB0_BASE, 8, USB_CLOCK_INTERNAL); //HWREG(USB0_BASE + USB_O_CC) = (8 - 1) | USB_CLOCK_INTERNAL; ROM_SysCtlUSBPLLEnable(); // 3. Enable USB D+ D- pins // 4. Activate USB DFU ROM_SysCtlDelay(ui32SysClock * 2 / 3); ROM_IntMasterEnable(); // Re-enable interrupts at NVIC level ROM_UpdateUSB(0); // 5. Should never get here since update is in progress #endif // BOOTLOADER_TEST // // Enable the GPIO port that is used for the on-board LED. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // gjs Our board uses GPIOB for LEDs // gjs original ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); // // Enable the GPIO pins for the LED (PF2 & PF3). // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0|GPIO_PIN_1); // gjs original ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3|GPIO_PIN_2); // // Not configured initially. // g_bUSBConfigured = false; // // Enable the UART that we will be redirecting. // ROM_SysCtlPeripheralEnable(USB_UART_PERIPH); // // Enable and configure the UART RX and TX pins // ROM_SysCtlPeripheralEnable(TX_GPIO_PERIPH); ROM_SysCtlPeripheralEnable(RX_GPIO_PERIPH); ROM_GPIOPinTypeUART(TX_GPIO_BASE, TX_GPIO_PIN); ROM_GPIOPinTypeUART(RX_GPIO_BASE, RX_GPIO_PIN); // // TODO: Add code to configure handshake GPIOs if required. // // // Set the default UART configuration. // ROM_UARTConfigSetExpClk(USB_UART_BASE, ROM_SysCtlClockGet(), DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG); ROM_UARTFIFOLevelSet(USB_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8); // // Configure and enable UART interrupts. // ROM_UARTIntClear(USB_UART_BASE, ROM_UARTIntStatus(USB_UART_BASE, false)); ROM_UARTIntEnable(USB_UART_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX)); // // Enable the system tick. // #if 0 ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND); ROM_SysTickIntEnable(); ROM_SysTickEnable(); #endif // // Initialize the transmit and receive buffers. // USBBufferInit(&g_sTxBuffer); USBBufferInit(&g_sRxBuffer); // // Set the USB stack mode to Device mode with VBUS monitoring. // USBStackModeSet(0, eUSBModeDevice, 0); // // Pass our device information to the USB library and place the device // on the bus. // USBDCDCInit(0, &g_sCDCDevice); // // Clear our local byte counters. // ui32RxCount = 0; ui32TxCount = 0; // // Enable interrupts now that the application is ready to start. // ROM_IntEnable(USB_UART_INT); // Enable FreeRTOS mainA(); // FreeRTOS. Will not return #if 0 // // Main application loop. // while(1) { // // Have we been asked to update the status display? // if(g_ui32Flags & COMMAND_STATUS_UPDATE) { // // Clear the command flag // ROM_IntMasterDisable(); g_ui32Flags &= ~COMMAND_STATUS_UPDATE; ROM_IntMasterEnable(); } // // Has there been any transmit traffic since we last checked? // if(ui32TxCount != g_ui32UARTTxCount) { // // Turn on the Green LED. // // gjs ROM_UARTCharPutNonBlocking(USB_UART_BASE, 'b'); #if 1 if (ui32TxCount & 1) { GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, GPIO_PIN_0); } else { GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 0); } #else if (1 || g_ui32UARTTxCount & 0x01) { GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); } else { //GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0); } // // Delay for a bit. // for(uint32_t ui32Loop = 0; ui32Loop < 150000; ui32Loop++) { } // // Turn off the Green LED. // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0); #endif // // Take a snapshot of the latest transmit count. // ui32TxCount = g_ui32UARTTxCount; } // // Has there been any receive traffic since we last checked? // if(ui32RxCount != g_ui32UARTRxCount) { // // Turn on the Blue LED. // #if 1 if (ui32RxCount & 1) { GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_1, GPIO_PIN_1); } else { GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_1, 0); } #else GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); // // Delay for a bit. // for(uint32_t ui32Loop = 0; ui32Loop < 150000; ui32Loop++) { } // // Turn off the Blue LED. // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); #endif // // Take a snapshot of the latest receive count. // ui32RxCount = g_ui32UARTRxCount; } } #endif }