//*****************************************************************************
//
//! Initializes the sound output.
//!
//! This function prepares the sound driver to play songs or sound effects. It
//! must be called before any other sound function. The sound driver uses
//! uDMA and the caller must ensure that the uDMA peripheral is enabled and
//! its control table configured prior to making this call.
//!
//! \return None
//
//*****************************************************************************
void
SoundInit(void)
{
//
// Set the current active buffer to zero.
//
g_ulPlaying = 0;
//
// Enable and reset the peripheral.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2S0);
//
// Select alternate functions for all of the I2S pins.
//
ROM_SysCtlPeripheralEnable(I2S0_SCLKTX_PERIPH);
GPIOPinTypeI2S(I2S0_SCLKTX_PORT, I2S0_SCLKTX_PIN);
ROM_SysCtlPeripheralEnable(I2S0_LRCTX_PERIPH);
GPIOPinTypeI2S(I2S0_LRCTX_PORT, I2S0_LRCTX_PIN);
ROM_SysCtlPeripheralEnable(I2S0_SDATX_PERIPH);
GPIOPinTypeI2S(I2S0_SDATX_PORT, I2S0_SDATX_PIN);
ROM_SysCtlPeripheralEnable(I2S0_MCLKTX_PERIPH);
GPIOPinTypeI2S(I2S0_MCLKTX_PORT, I2S0_MCLKTX_PIN);
//
// Initialize the DAC.
//
WM8510Init();
//
// Set the intial volume level
//
WM8510VolumeSet(g_ucVolume);
//
// Set the FIFO trigger limit
//
I2STxFIFOLimitSet(I2S0_BASE, 4);
//
// Clear out all pending interrupts.
//
I2SIntClear(I2S0_BASE, I2S_INT_TXERR | I2S_INT_TXREQ );
//
// Enable the I2S interrupt on the NVIC
//
ROM_IntEnable(INT_I2S0);
//
// Disable all uDMA attributes.
//
ROM_uDMAChannelAttributeDisable(UDMA_CHANNEL_I2S0TX, UDMA_ATTR_ALL);
}
void timerInit()
{
#if F_CPU >= 80000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#elif F_CPU >= 50000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#elif F_CPU >= 40000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#elif F_CPU >= 25000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_8|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#elif F_CPU >= 16200000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1|SYSCTL_USE_OSC|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN); //NOT PLL
#elif F_CPU >= 16100000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1|SYSCTL_USE_OSC|SYSCTL_OSC_INT|
SYSCTL_OSC_MAIN); //NOT PLL, INT OSC
#elif F_CPU >= 16000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_12_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#elif F_CPU >= 10000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_20|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#elif F_CPU >= 8000000
ROM_SysCtlClockSet(SYSCTL_SYSDIV_25|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#else
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
#endif
//
// SysTick is used for delay() and delayMicroseconds()
//
// ROM_SysTickPeriodSet(0x00FFFFFF);
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
//
//Initialize Timer5 to be used as time-tracker since beginning of time
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER5); //not tied to launchpad pin
ROM_TimerConfigure(TIMER5_BASE, TIMER_CFG_PERIODIC_UP);
ROM_TimerLoadSet(TIMER5_BASE, TIMER_A, ROM_SysCtlClockGet()/1000);
ROM_IntEnable(INT_TIMER5A);
ROM_TimerIntEnable(TIMER5_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(TIMER5_BASE, TIMER_A);
ROM_IntMasterEnable();
}
//*****************************************************************************
//
// Initializes the uDMA software channel to perform a memory to memory uDMA
// transfer.
//
//*****************************************************************************
void
InitSWTransfer(void)
{
unsigned int uIdx;
//
// Fill the source memory buffer with a simple incrementing pattern.
//
for(uIdx = 0; uIdx < MEM_BUFFER_SIZE; uIdx++)
{
g_ulSrcBuf[uIdx] = uIdx;
}
//
// Enable interrupts from the uDMA software channel.
//
ROM_IntEnable(INT_UDMA);
//
// Put the attributes in a known state for the uDMA software channel.
// These should already be disabled by default.
//
ROM_uDMAChannelAttributeDisable(UDMA_CHANNEL_SW,
UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT |
(UDMA_ATTR_HIGH_PRIORITY |
UDMA_ATTR_REQMASK));
//
// Configure the control parameters for the SW channel. The SW channel
// will be used to transfer between two memory buffers, 32 bits at a time.
// Therefore the data size is 32 bits, and the address increment is 32 bits
// for both source and destination. The arbitration size will be set to 8,
// which causes the uDMA controller to rearbitrate after 8 items are
// transferred. This keeps this channel from hogging the uDMA controller
// once the transfer is started, and allows other channels cycles if they
// are higher priority.
//
ROM_uDMAChannelControlSet(UDMA_CHANNEL_SW | UDMA_PRI_SELECT,
UDMA_SIZE_32 | UDMA_SRC_INC_32 | UDMA_DST_INC_32 |
UDMA_ARB_8);
//
// Set up the transfer parameters for the software channel. This will
// configure the transfer buffers and the transfer size. Auto mode must be
// used for software transfers.
//
ROM_uDMAChannelTransferSet(UDMA_CHANNEL_SW | UDMA_PRI_SELECT,
UDMA_MODE_AUTO, g_ulSrcBuf, g_ulDstBuf,
MEM_BUFFER_SIZE);
//
// Now the software channel is primed to start a transfer. The channel
// must be enabled. For software based transfers, a request must be
// issued. After this, the uDMA memory transfer begins.
//
ROM_uDMAChannelEnable(UDMA_CHANNEL_SW);
ROM_uDMAChannelRequest(UDMA_CHANNEL_SW);
}
// Start the timers and interrupt frequency
void servoStart(void) {
ROM_SysCtlPeripheralEnable(SERVO_TIMER_PERIPH);
ROM_IntMasterEnable();
ROM_TimerConfigure(SERVO_TIMER, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(SERVO_TIMER, SERVO_TIMER_A, (ROM_SysCtlClockGet() / 1000000) * SERVO_TIMER_RESOLUTION);
ROM_IntEnable(SERVO_TIMER_INTERRUPT);
ROM_TimerIntEnable(SERVO_TIMER, SERVO_TIMER_TRIGGER);
ROM_TimerEnable(SERVO_TIMER, SERVO_TIMER_A);
}
// * svm_int_init *************************************************************
// * setup counter reload interrupt from pwm generator for svm *
// * Assumes system clock already configured *
// ****************************************************************************
void svm_int_init(void)
{
ROM_IntMasterEnable(); // enable NVIC interrupts
ROM_PWMIntEnable(SVM_PWM_BASE, SVM_PWM_INT_GEN); // enable interrupt assertion from our specific generator in module
ROM_PWMGenIntTrigEnable(SVM_PWM_BASE, SVM_PWM_GEN, PWM_INT_CNT_LOAD);
// enable counter load interrupt from our generator
ROM_IntEnable(SVM_PWM_GEN_INTVECT); // enable NVIC vector for our generator
// load interrupt for our generator is now active
}
//*****************************************************************************
//
// PoC2Repeater
//
//*****************************************************************************
int
main(void)
{
// Set the clocking to run directly from the crystal at 120MHz.
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
// Enable the peripherals
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
// Enable the GPIO pins for the LEDs (PN0 and PN1).
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4);
// ButtonsInit
ROM_GPIODirModeSet(GPIO_PORTJ_BASE, ALL_BUTTONS, GPIO_DIR_MODE_IN);
MAP_GPIOPadConfigSet(GPIO_PORTJ_BASE, ALL_BUTTONS,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
// Enable processor interrupts.
ROM_IntMasterEnable();
// Set GPIO PC4 and PC5 as UART pins.
GPIOPinConfigure(GPIO_PC4_U7RX);
GPIOPinConfigure(GPIO_PC5_U7TX);
ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);
// Configure the UART for 115,200, 8-N-1 operation.
ROM_UARTConfigSetExpClk(UART7_BASE, g_ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
// Enable the UART interrupt.
ROM_IntEnable(INT_UART7);
ROM_UARTIntEnable(UART7_BASE, UART_INT_RX | UART_INT_RT);
// Reset message info
for(uint8_t i = 0; i < MSG; i++)
message[i] = 0;
// Loop forever echoing data through the UART.
while(1)
{
}
}
void initializeTimer(void)
{
timerSeconds = 0;
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
// invoke timer once a second
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet());
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
}
//*****************************************************************************
//
//! Initializes the sound driver.
//!
//! \param ui32SysClock is the frequency of the system clock.
//!
//! This function initializes the sound driver, preparing it to output sound
//! data to the speaker.
//!
//! The system clock should be as high as possible; lower clock rates reduces
//! the quality of the produced sound. For the best quality sound, the system
//! should be clocked at 120 MHz.
//!
//! \note In order for the sound driver to function properly, the sound driver
//! interrupt handler (SoundIntHandler()) must be installed into the vector
//! table for the timer 5 subtimer A interrupt.
//!
//! \return None.
//
//*****************************************************************************
void
SoundInit(uint32_t ui32SysClock)
{
//
// Enable the peripherals used by the sound driver.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER5);
//
// Compute the PWM period based on the system clock.
//
g_sSoundState.ui32Period = ui32SysClock / 64000;
//
// Set the default volume.
//
g_sSoundState.i32Volume = 255;
//
// Configure the timer to run in PWM mode.
//
if((HWREG(TIMER5_BASE + TIMER_O_CTL) & TIMER_CTL_TBEN) == 0)
{
ROM_TimerConfigure(TIMER5_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PWM |
TIMER_CFG_B_PERIODIC));
}
ROM_TimerLoadSet(TIMER5_BASE, TIMER_A, g_sSoundState.ui32Period - 1);
ROM_TimerMatchSet(TIMER5_BASE, TIMER_A, g_sSoundState.ui32Period);
ROM_TimerControlLevel(TIMER5_BASE, TIMER_A, true);
//
// Update the timer values on timeouts and not immediately.
//
TimerUpdateMode(TIMER5_BASE, TIMER_A, TIMER_UP_LOAD_TIMEOUT |
TIMER_UP_MATCH_TIMEOUT);
//
// Configure the timer to generate an interrupt at every time-out event.
//
ROM_TimerIntEnable(TIMER5_BASE, TIMER_CAPA_EVENT);
//
// Enable the timer. At this point, the timer generates an interrupt
// every 15.625 us.
//
ROM_TimerEnable(TIMER5_BASE, TIMER_A);
ROM_IntEnable(INT_TIMER5A);
//
// Clear the sound flags.
//
g_sSoundState.ui32Flags = 0;
}
//*****************************************************************************
//
//! Initializes the Timer and GPIO functionality associated with the RGB LED
//!
//! \param ui32Enable enables RGB immediately if set.
//!
//! This function must be called during application initialization to
//! configure the GPIO pins to which the LEDs are attached. It enables
//! the port used by the LEDs and configures each color's Timer. It optionally
//! enables the RGB LED by configuring the GPIO pins and starting the timers.
//!
//! \return None.
//
//*****************************************************************************
void
RGBInit(uint32_t ui32Enable)
{
//
// Enable the GPIO Port and Timer for each LED
//
ROM_SysCtlPeripheralEnable(RED_GPIO_PERIPH);
ROM_SysCtlPeripheralEnable(RED_TIMER_PERIPH);
ROM_SysCtlPeripheralEnable(GREEN_GPIO_PERIPH);
ROM_SysCtlPeripheralEnable(GREEN_TIMER_PERIPH);
ROM_SysCtlPeripheralEnable(BLUE_GPIO_PERIPH);
ROM_SysCtlPeripheralEnable(BLUE_TIMER_PERIPH);
//
// Configure each timer for output mode
//
HWREG(GREEN_TIMER_BASE + TIMER_O_CFG) = 0x04;
HWREG(GREEN_TIMER_BASE + TIMER_O_TAMR) = 0x0A;
HWREG(GREEN_TIMER_BASE + TIMER_O_TAILR) = 0xFFFF;
HWREG(BLUE_TIMER_BASE + TIMER_O_CFG) = 0x04;
HWREG(BLUE_TIMER_BASE + TIMER_O_TBMR) = 0x0A;
HWREG(BLUE_TIMER_BASE + TIMER_O_TBILR) = 0xFFFF;
HWREG(RED_TIMER_BASE + TIMER_O_CFG) = 0x04;
HWREG(RED_TIMER_BASE + TIMER_O_TBMR) = 0x0A;
HWREG(RED_TIMER_BASE + TIMER_O_TBILR) = 0xFFFF;
//
// Invert the output signals.
//
HWREG(RED_TIMER_BASE + TIMER_O_CTL) |= 0x4000;
HWREG(GREEN_TIMER_BASE + TIMER_O_CTL) |= 0x40;
HWREG(BLUE_TIMER_BASE + TIMER_O_CTL) |= 0x4000;
if(ui32Enable)
{
RGBEnable();
}
//
// Setup the blink functionality
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WTIMER5);
ROM_TimerConfigure(WTIMER5_BASE, TIMER_CFG_B_PERIODIC | TIMER_CFG_SPLIT_PAIR);
ROM_TimerLoadSet64(WTIMER5_BASE, 0xFFFFFFFFFFFFFFFF);
ROM_IntEnable(INT_WTIMER5B);
ROM_TimerIntEnable(WTIMER5_BASE, TIMER_TIMB_TIMEOUT);
}
void setup()
{
//--------------------- GENERAL ---------------------
// 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_FPUEnable();
ROM_FPULazyStackingEnable();
// Set the clocking to run directly from the crystal.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
ROM_IntMasterEnable();
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_6);
//--------------------- UART ---------------------
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
// Configure the UART for 115,200, 8-N-1 operation.
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
// Enable the UART interrupt.
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//--------------------- SSI ---------------------
SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
GPIOPinConfigure(GPIO_PA2_SSI0CLK);
GPIOPinConfigure(GPIO_PA3_SSI0FSS);
GPIOPinConfigure(GPIO_PA4_SSI0RX);
GPIOPinConfigure(GPIO_PA5_SSI0TX);
GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 | GPIO_PIN_2);
SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 10000, 8);
SSIEnable(SSI0_BASE);
}
ServoClass::ServoClass()
{
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
// Initialize variables of the class
g_ulPeriod = 0;
for(int il_iter = 0; il_iter < SERVOS_PER_TIMER; il_iter++)
{
g_ulServoPins[il_iter] = INVALID_SERVO_PIN;
g_ulServoPulse[il_iter] = DEFAULT_SERVO_PULSE_WIDTH;
}
g_iServoNo = 0;
g_ulPulseWidth = 0;
g_ulTicksPerMicrosecond = 0;
setRefresh();
// for(int il_iter = 0; il_iter < SERVOS_PER_TIMER; il_iter++)
// {
// if (g_ulServoPins[il_iter] != INVALID_SERVO_PIN)
// {
// pinMode(g_ulServoPins[il_iter], OUTPUT);
// digitalWrite(g_ulServoPins[il_iter], LOW);
// }
// }
// Enable TIMER
ROM_SysCtlPeripheralEnable(SERVO_TIMER_PERIPH);
// Enable processor interrupts.
ROM_IntMasterEnable();
// Configure the TIMER
ROM_TimerConfigure(SERVO_TIMER, SERVO_TIME_CFG);
// Calculate the number of timer counts/microsecond
g_ulTicksPerMicrosecond = ROM_SysCtlClockGet() / 1000000;
g_ulPeriod = g_ulTicksPerMicrosecond * REFRESH_INTERVAL; // 20ms = Standard Servo refresh delay
// Initially load the timer with 20ms interval time
ROM_TimerLoadSet(SERVO_TIMER, SERVO_TIMER_A, g_ulPeriod);
// Setup the interrupt for the TIMER1A timeout.
ROM_IntEnable(SERVO_TIMER_INTERRUPT);
ROM_TimerIntEnable(SERVO_TIMER, SERVO_TIMER_TRIGGER);
// Enable the timer.
ROM_TimerEnable(SERVO_TIMER, SERVO_TIMER_A);
}
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! \param ui32SysClock is the frequency of the system clock.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC 0 sample sequence 3
//! - Timer 5 subtimer B
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(uint32_t ui32SysClock)
{
//
// Set the initial state of the touch screen driver's state machine.
//
g_ui32TSState = TS_STATE_INIT;
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Enable the peripherals used by the touch screen interface.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER5);
//
// Configure the ADC sample sequence used to read the touch screen reading.
//
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 4);
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0,
TS_YP_ADC | ADC_CTL_END | ADC_CTL_IE);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
//
// Enable the ADC sample sequence interrupt.
//
ROM_ADCIntEnable(ADC0_BASE, 3);
ROM_IntEnable(INT_ADC0SS3);
//
// Configure the timer to trigger the sampling of the touch screen
// every 2.5 milliseconds.
//
if((HWREG(TIMER5_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0) {
ROM_TimerConfigure(TIMER5_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PWM |
TIMER_CFG_B_PERIODIC));
}
ROM_TimerPrescaleSet(TIMER5_BASE, TIMER_B, 255);
ROM_TimerLoadSet(TIMER5_BASE, TIMER_B, ((ui32SysClock / 256) / 400) - 1);
TimerControlTrigger(TIMER5_BASE, TIMER_B, true);
//
// Enable the timer. At this point, the touch screen state machine will
// sample and run every 2.5 ms.
//
ROM_TimerEnable(TIMER5_BASE, TIMER_B);
}
//*****************************************************************************
//
// This function prepares the watchdog timer to detect the lost of the input
// link.
//
//*****************************************************************************
void
WatchdogInit(void)
{
//
// Configure the watchdog timer to interrupt if it is not pet frequently
// enough.
//
ROM_WatchdogReloadSet(WATCHDOG0_BASE, WATCHDOG_PERIOD);
ROM_WatchdogStallEnable(WATCHDOG0_BASE);
ROM_WatchdogEnable(WATCHDOG0_BASE);
ROM_IntEnable(INT_WATCHDOG);
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
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);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO A0 and A1 as UART pins.
//
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//
// Prompt for text to be entered.
//
UARTSend((unsigned char *)"\033[2JEnter text: ", 16);
//
// Loop forever echoing data through the UART.
//
while(1)
{
}
}
//函数创建区
//----------------------------------------Start-------------------------------------------
void Init_Timer()
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()/100);//10ms周期中断,由100决定 如果为1为1s定时
GPIOIntRegister(INT_TIMER0A, Timer0AIntHandler);
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
ROM_IntMasterEnable();
}
void wiz610_init(void)
{
ROM_SysCtlPeripheralEnable(WIZ610_GPIO_PERIPH);
ROM_GPIODirModeSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE ,GPIO_DIR_MODE_OUT);
ROM_GPIOPadConfigSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,GPIO_STRENGTH_8MA,GPIO_PIN_TYPE_STD_WPU);
ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,WIZ610_GPIO_PIN_CMD_ENABLE);
// uart setup
ROM_SysCtlPeripheralEnable(WIZ610_UART_PERIPH);
ROM_GPIOPinConfigure(GPIO_PB0_U1RX);
ROM_GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(WIZ610_GPIO_BASE, WIZ610_GPIO_PIN_RX | WIZ610_GPIO_PIN_TX);
ROM_UARTConfigSetExpClk(WIZ610_UART_BASE, ROM_SysCtlClockGet(), 38400,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,0);
ROM_UARTFIFOLevelSet(WIZ610_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX1_8);
ROM_IntEnable(INT_UART1);
ROM_UARTEnable(WIZ610_UART_BASE);
ROM_UARTDMAEnable(WIZ610_UART_BASE, UART_DMA_TX);
ROM_UARTIntEnable(WIZ610_UART_BASE, UART_INT_RX);
ROM_IntEnable(INT_UDMA);
cmd_modbus_switch=1;
}
/*---------------------------------------------------------------------------*/
void
clock_init(void)
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()/1000);
TimerControlStall(TIMER0_BASE,TIMER_A,true);
TimerEnable(TIMER0_BASE, TIMER_A);
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
count = 0;
}
void Button_init(void)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_AFSEL) &= ~0x01;
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD_WPU);
ROM_GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_FALLING_EDGE);
GPIOIntRegister(GPIO_PORTF_BASE, &ButtonsISR);
ROM_IntEnable(INT_GPIOF);
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
}
void initTimer0(int interval, gyro *G){
//
// 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();
volatile int tick = 0;
tick = (ROM_SysCtlClockGet() / 1000) * interval;
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable the GPIO pins for the LED (PF1 & PF2).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
//
// Configure the two 32-bit periodic timers.
//
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
/// imposta il time_out
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, tick);
G->tick = (float) interval / 1000;
//
// 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);
}
/**
Configures timer.
@see timers example in EK-LM4F120XL StellarisWare package
@note On the LM4F120XL, there are 16/32 bit timers or "wide" timers featuring 32/64bit. We use a standard timer.
@param seconds period of the timer. Maximum is 0xFFFFFFFF / SysCtlClockGet(); or about 171 sec if using 25MHz main clock
@return 0 if success; -1 if illegal parameter
*/
int16_t initTimer(uint8_t seconds)
{
#define TIMER_MAX_SECONDS (0xFFFFFFFF / SysCtlClockGet())
if ((seconds > TIMER_MAX_SECONDS) || (seconds == 0))
return -1;
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
ROM_TimerConfigure(TIMER2_BASE, TIMER_CFG_PERIODIC); // Full width (32 bit for Timer 2) periodic timer
ROM_TimerLoadSet(TIMER2_BASE, TIMER_A, (ROM_SysCtlClockGet() * seconds)); // for once per second
ROM_IntEnable(INT_TIMER2A);
ROM_TimerIntEnable(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(TIMER2_BASE, TIMER_A);
return 0;
}
void
HardwareSerial::begin(unsigned long baud)
{
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(g_ulUARTInt[uartModule]);
//TODO:Add functionality for PinConfigure with variable uartModule
ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Only allow a single instance to be opened.
//
ASSERT(g_ulUARTBase[uartModule] == 0);
//
// Check to make sure the UART peripheral is present.
//
if(!ROM_SysCtlPeripheralPresent(g_ulUARTPeriph[uartModule]))
{
return;
}
ROM_SysCtlPeripheralEnable(g_ulUARTPeriph[uartModule]);
ROM_UARTConfigSetExpClk(g_ulUARTBase[uartModule], ROM_SysCtlClockGet(), baud,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
//
// Set the UART to interrupt whenever the TX FIFO is almost empty or
// when any character is received.
//
ROM_UARTFIFOLevelSet(g_ulUARTBase[uartModule], UART_FIFO_TX1_8, UART_FIFO_RX1_8);
flushAll();
ROM_UARTIntDisable(g_ulUARTBase[uartModule], 0xFFFFFFFF);
ROM_UARTIntEnable(g_ulUARTBase[uartModule], UART_INT_RX | UART_INT_RT);
ROM_IntMasterEnable();
ROM_IntEnable(g_ulUARTInt[uartModule]);
//
// Enable the UART operation.
//
ROM_UARTEnable(g_ulUARTBase[uartModule]);
}
void DBG_Init(void)
{
newlines = 0;
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), DBG_BAUD, UART_CFG_8N1);
ROM_UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX1_8, UART_FIFO_RX7_8);
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_TX | UART_INT_RX | UART_INT_RT);
} // DBG_Init()
//*****************************************************************************
//
// Initialize the IO used in this demo
//
//*****************************************************************************
void
io_init(void)
{
//
// Configure Port N0 for as an output for the status LED.
//
ROM_GPIOPinTypeGPIOOutput(LED_PORT_BASE, LED_PIN);
//
// Configure Port N0 for as an output for the animation LED.
//
ROM_GPIOPinTypeGPIOOutput(LED_ANIM_PORT_BASE, LED_ANIM_PIN);
//
// Initialize LED to OFF (0)
//
ROM_GPIOPinWrite(LED_PORT_BASE, LED_PIN, 0);
//
// Initialize animation LED to OFF (0)
//
ROM_GPIOPinWrite(LED_ANIM_PORT_BASE, LED_ANIM_PIN, 0);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
//
// Configure the timer used to pace the animation.
//
ROM_TimerConfigure(TIMER2_BASE, TIMER_CFG_PERIODIC);
//
// Setup the interrupts for the timer timeouts.
//
ROM_IntEnable(INT_TIMER2A);
ROM_TimerIntEnable(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
//
// Set the timer for the current animation speed. This enables the
// timer as a side effect.
//
io_set_timer(g_ulAnimSpeed);
}
void init_Timer1B(void)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_PERIODIC);
ROM_TimerLoadSet(TIMER1_BASE, TIMER_B, ROM_SysCtlClockGet() / 2000);
ROM_IntMasterEnable();
ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMB_TIMEOUT);
ROM_IntEnable(INT_TIMER1B);
timeCounter = 0;
ROM_TimerEnable(TIMER1_BASE, TIMER_B);
}
void
HardwareSerial::begin(unsigned long baud)
{
baudRate = baud;
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(g_ulUARTPeriph[uartModule]);
//TODO:Add functionality for PinConfigure with variable uartModule
ROM_GPIOPinConfigure(g_ulUARTConfig[uartModule][0]);
ROM_GPIOPinConfigure(g_ulUARTConfig[uartModule][1]);
ROM_GPIOPinTypeUART(g_ulUARTPort[uartModule], g_ulUARTPins[uartModule]);
ROM_UARTConfigSetExpClk(UART_BASE, F_CPU, baudRate,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
//
// Set the UART to interrupt whenever the TX FIFO is almost empty or
// when any character is received.
//
ROM_UARTFIFOLevelSet(UART_BASE, UART_FIFO_TX1_8, UART_FIFO_RX1_8);
flushAll();
ROM_UARTIntDisable(UART_BASE, 0xFFFFFFFF);
ROM_UARTIntEnable(UART_BASE, UART_INT_RX | UART_INT_RT);
ROM_IntEnable(g_ulUARTInt[uartModule]);
//
// Enable the UART operation.
//
ROM_UARTEnable(UART_BASE);
// Allocate TX & RX buffers
if (txBuffer != (unsigned char *)0xFFFFFFFF) // Catch attempts to re-init this Serial instance by freeing old buffer first
free(txBuffer);
if (rxBuffer != (unsigned char *)0xFFFFFFFF) // Catch attempts to re-init this Serial instance by freeing old buffer first
free(rxBuffer);
txBuffer = (unsigned char *) malloc(txBufferSize);
rxBuffer = (unsigned char *) malloc(rxBufferSize);
SysCtlDelay(100);
}
//*****************************************************************************
//
// Initializes the ADC.
//
//*****************************************************************************
void
ADCInit(void)
{
//
// Set the ADC speed to 1 Msps.
//
ROM_SysCtlADCSpeedSet(SYSCTL_ADCSPEED_1MSPS);
//
// Configure the GPIOs used with the analog inputs.
//
GPIOPinTypeADC(ADC_POSITION_PORT, ADC_POSITION_PIN);
GPIOPinTypeADC(ADC_CURRENT_PORT, ADC_CURRENT_PIN);
GPIOPinTypeADC(ADC_VBUS_PORT, ADC_VBUS_PIN);
GPIOPinTypeADC(ADC_VBOOTA_PORT, ADC_VBOOTA_PIN);
GPIOPinTypeADC(ADC_VBOOTB_PORT, ADC_VBOOTB_PIN);
//
// Configure the ADC sample sequence that is triggered by PWM
// generator 2
//
ROM_ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PWM0, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CURRENT_CH);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_VBUS_CH);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_POSITION_CH);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 3,
(ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END));
ROM_ADCSequenceEnable(ADC0_BASE, 0);
//
// Enable interrupts
//
ROM_ADCIntEnable(ADC0_BASE, 0);
ROM_IntEnable(INT_ADC0SS0);
//
// Set the zero current to indicate that the initial sampling has just
// begun.
//
g_usCurrentZero = 0xffff;
}
void OneMsTaskTimer::start(uint32_t timer_index) {
uint32_t load = (F_CPU / 1000);
//// !!!! count = 0;
overflowing = 0;
// Base address for first timer
g_ulBase = getTimerBase(timerToOffset(timer_index));
timerAB = TIMER_A << timerToAB(timer_index);
//Setup interrupts for duration, interrupting at 1kHz
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0+ timer_index);
ROM_IntMasterEnable();
ROM_TimerConfigure(g_ulBase, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(g_ulBase, TIMER_A, F_CPU/1000);
// Setup the interrupts for the timer timeouts.
TimerIntRegister(g_ulBase, TIMER_A, OneMsTaskTimer_int);
ROM_IntEnable(INT_TIMER0A+timer_index);
ROM_TimerIntEnable(g_ulBase, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(g_ulBase, TIMER_A);
}
//------------------------------------ Timer init ---------------------------------
void ir_timer_init(void) {
// The Timer0 peripheral must be enabled for use.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
//
// The Timer0 peripheral must be enabled for use.
// When configured for a pair of half-width timers, each timer is separately configured.
//
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PERIODIC | TIMER_CFG_B_ONE_SHOT);
// Calculate the number of timer counts/microsecond
ulCountsPerMicrosecond = ROM_SysCtlClockGet() / 10000;
// 0.10ms = timeout delay
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ulCountsPerMicrosecond);
ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerIntRegister(TIMER0_BASE, TIMER_A, Timer0AIntHandler );
//
// Configure the Timer0 interrupt for timer timeout.
//
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Enable the Timer0 interrupt on the processor (NVIC).
//
ROM_IntEnable(INT_TIMER0A);
gulTicks = 0;
//
// Enable Timer0A.
//
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
}
int gpio_init_int(gpio_t pin, gpio_mode_t mode, gpio_flank_t flank,
gpio_cb_t cb, void *arg)
{
const uint8_t port_num = _port_num(pin);
const uint32_t port_addr = _port_base[port_num];
const uint32_t icr_reg_addr = port_addr + GPIO_ICR_R_OFF;
const uint8_t pin_num = _pin_num(pin);
const uint8_t pin_bit = 1<<pin_num;
const unsigned int int_num = _int_assign[port_num];
const uint32_t sysctl_port_base = _sysctl_port_base[port_num];
ROM_SysCtlPeripheralEnable(sysctl_port_base);
gpio_config[port_num][pin_num].cb = cb;
gpio_config[port_num][pin_num].arg = arg;
DEBUG("init int pin:%d, int num %d, port addr %" PRIx32 "\n",
pin_num, int_num, port_addr);
ROM_GPIODirModeSet(port_addr, 1<<pin_num, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(port_addr, 1<<pin_num,
GPIO_STRENGTH_2MA, TYPE(mode));
ROM_IntMasterDisable();
HWREG(icr_reg_addr) = pin_bit;
ROM_GPIOIntTypeSet(port_addr, pin_bit, flank);
HWREG(port_addr+GPIO_LOCK_R_OFF) = GPIO_LOCK_KEY;
HWREG(port_addr+GPIO_CR_R_OFF) |= pin_bit;
HWREG(port_addr+GPIO_DEN_R_OFF) |= pin_bit;
HWREG(port_addr+GPIO_LOCK_R_OFF) = 0;
gpio_irq_enable(pin);
ROM_IntEnable(int_num);
ROM_IntMasterEnable();
return 0;
}
void tone(uint8_t _pin, unsigned int frequency, unsigned long duration)
{
uint8_t port = digitalPinToPort(_pin);
if (port == NOT_A_PORT) return;
if (tone_state == 0 || _pin == current_pin) {
//Setup PWM
current_pin = _pin;
tone_timer = digitalPinToTimer(_pin);
uint32_t timerBase = getTimerBase(timerToOffset(tone_timer));
tone_state = 1;
g_duration = duration;
PWMWrite(_pin, 256, 128, frequency);
//Setup interrupts for duration, interrupting at 1kHz
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER4);
ROM_IntMasterEnable();
ROM_TimerConfigure(TIMER4_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER4_BASE, TIMER_A, ROM_SysCtlClockGet()/1000);
ROM_IntEnable(INT_TIMER4A);
ROM_TimerIntEnable(TIMER4_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerEnable(TIMER4_BASE, TIMER_A);
}
}
