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);
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
//Set up the general purpose I/Os
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);//1024hz = 15625
//Set up the input/output pins
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1);
GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5 | GPIO_PIN_6);
//Set up the interrupt pins
GPIOIntEnable(GPIO_PORTC_BASE, GPIO_INT_PIN_5 | GPIO_INT_PIN_6);
GPIOIntRegister(GPIO_PORTC_BASE, interrupt_handler);
GPIOIntTypeSet(GPIO_PORTC_BASE, (GPIO_PIN_5 | GPIO_PIN_6), GPIO_RISING_EDGE);
//Just a quick toggle to make sure code is working
toggle();
//Timer Configuration
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER0_BASE, TIMER_A, frequency);
TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_POS_EDGE);
TimerEnable(TIMER0_BASE, TIMER_A);
//Timer Interrupt Enable
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerIntRegister(TIMER0_BASE, TIMER_A, timer_interrupt);
//Loop forever
while(1){
// if(TimerValueGet(TIMER0_BASE, TIMER_A) == 0){
// GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, pin_data);
// pin_data^=0x04;
// }
}
}
//------------------------------------ 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);
}
void motor_init()
{
unsigned long timer;
//configure timer0 for one shot intervals and assign interrupt routine
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_TimerConfigure(TIMER0_BASE,TIMER_CFG_ONE_SHOT);
ROM_TimerControlStall(TIMER0_BASE, TIMER_A, true);
TimerIntRegister(TIMER0_BASE, TIMER_A, Timer0A_ISR);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//setup RGB led outputs.
ROM_SysCtlPeripheralEnable(LED_PERIPH);
ROM_GPIOPinTypeGPIOOutput(LED_PORT, LED_R | LED_G | LED_B );
//enable peripherals used for motor
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
//set motor pins to outputs
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, MOTOR_PORTA_PINS );
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, MOTOR_PORTB_PINS );
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, MOTOR_PORTD_PINS );
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, MOTOR_PORTE_PINS );
//make sure motors are disabled and step pins are low
motor_disable();
motor_unstep();
//start the timer. the ISR will run at the minimum rate
//interval until there is a block to execute.
timer=calculate_timer(MIN_STEP_RATE);
ROM_TimerLoadSet(TIMER0_BASE,TIMER_A, timer);
ROM_TimerEnable(TIMER0_BASE,TIMER_A);
}
void stepper_init(struct stepper *s){
DAC082S085_init(&s->dac, SSI2_BASE);
s->stepping_rate = 0;
s->div = 1;
// Enable the timer
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
TimerConfigure(TIMER2_BASE, TIMER_CFG_PERIODIC);
IntEnable(INT_TIMER2A);
TimerIntRegister(TIMER2_BASE, TIMER_A, TIMER2IntHandler);
TimerIntEnable(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
//set up other necessary GPIO
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_3); //AEN, BPH
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_0); //BEN
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3); //APH
}
void confTimer(){
//Inicializamos el TIMER2 para el ADC como Trigger a una frecuencia de 10Hz
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER2);
TimerControlStall(TIMER2_BASE,TIMER_A,true);
TimerConfigure(TIMER2_BASE, TIMER_CFG_PERIODIC);
uint32_t ui32Period = SysCtlClockGet() *0.1;
TimerLoadSet(TIMER2_BASE, TIMER_A, ui32Period -1);
TimerControlTrigger(TIMER2_BASE,TIMER_A,true);
TimerEnable(TIMER2_BASE, TIMER_A);
//Inicializamos el TIMER4 para la pulsación larga con un periodo de 2 segundos
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER4);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER4);
TimerConfigure(TIMER4_BASE, TIMER_CFG_ONE_SHOT);
ui32Period = (SysCtlClockGet() *2) ;
TimerLoadSet(TIMER4_BASE, TIMER_A, ui32Period -1);
IntEnable(INT_TIMER4A);
TimerIntRegister(TIMER4_BASE,TIMER_A,timerBotonHandler);
IntPrioritySet(INT_TIMER4A,5<<5);
TimerIntEnable(TIMER4_BASE, TIMER_TIMA_TIMEOUT);
}
int main()
{
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_BLUE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_IntMasterEnable();
ROM_TimerDisable(TIMER0_BASE, TIMER_A);
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet());
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerIntRegister(TIMER0_BASE, TIMER_A, Timer0AIntHandler);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE, led_value);
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
while(1)
{}
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); //Configure System Clock
//SSD
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); //Enable Port D
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //Enable Port B
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE,0x0F);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE,0xFF);
//S1 and S2
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //Enable Port F
//Mode 1
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); //Enable ADC0 Module
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //Enable Port E
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_1); //Select ADC Function of PE 1
ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0); //Configure ADC0 Sequencer
ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH2 | ADC_CTL_IE | ADC_CTL_END); //Configure the step of the sequencer
//Mode 2
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); //Enable TIMER1 Module
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE,GPIO_PIN_4); //Set PF4 as Input
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); //Configuring the PF4
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_BOTH_EDGES); //Setting Interrupt to trigger on both edges
TimerConfigure(TIMER1_BASE,TIMER_CFG_PERIODIC); //Configure TIMER1 into a Continuous Mode
TimerIntRegister(TIMER1_BASE, TIMER_A, fast); //Register interrupt if PF4 pressed for more than 1s
//Mode 3
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER4); //Enable TIMER4 Module
SysCtlPeripheralEnable(SYSCTL_PERIPH_WTIMER0); //Enable WTIMER0 Module
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); //Enable Port C
GPIOPinConfigure(GPIO_PC4_WT0CCP0);
GPIOPinTypeTimer(GPIO_PORTC_BASE,GPIO_PIN_4); //Set PC4 as a Timer Capture pin
TimerIntRegister(TIMER4_BASE,TIMER_A,freqfind); //Register a timer interrupt for TIMER4
TimerConfigure(TIMER4_BASE,TIMER_CFG_PERIODIC); //Configure Timer4 in continuous mode
TimerConfigure(WTIMER0_BASE,TIMER_CFG_SPLIT_PAIR|TIMER_CFG_A_CAP_COUNT);
TimerControlEvent(WTIMER0_BASE,TIMER_A,TIMER_EVENT_POS_EDGE); //Configure WTIMER0 for Positive Edge Capture
IntMasterEnable();
GPIOPinWrite(GPIO_PORTB_BASE,0xFF,0x00); //Initialize SSD to 0x00
GPIOPinWrite(GPIO_PORTD_BASE, 0x0F, 0x00); //Turn off all the digits of the SSD
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); //Enable TIMER0 Module
TimerConfigure(TIMER0_BASE,TIMER_CFG_PERIODIC); //Configure TIMER0 into a Continuous Mode
TimerIntRegister(TIMER0_BASE, TIMER_A, ssdmux); //Register ISR for TIMER0 Interrupt to update SSD
TimerLoadSet(TIMER0_BASE, TIMER_A,SysCtlClockGet()/3000); //Set the refresh rate of the SSD
IntEnable(INT_TIMER0A);
TimerIntEnable(TIMER0_BASE,TIMER_TIMA_TIMEOUT); //Enable the timer interrupt
TimerEnable(TIMER0_BASE,TIMER_A); //Start the timer
HWREG(GPIO_PORTF_BASE|GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE|GPIO_O_CR) = GPIO_PIN_0; //Unlock PF0 from the NMI mode
HWREG(GPIO_PORTF_BASE|GPIO_O_LOCK) = 0;
ssdset(0);
mode1set();
GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0); //Setting PF0 to Input
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU); //Configuring the pins
GPIOIntRegister(GPIO_PORTF_BASE, modeselect); //Register Interrupt for Port F with ISR modeselect()
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_0); //Clear any existing interrupts
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_FALLING_EDGE); //Setting Interrupt to trigger on falling edges
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_0); //Enable the GPIO Interrupts on Port F
IntEnable(INT_GPIOF); //Enable Interrupts on Port F
while(1){
switch(mode) //Select operation according to mode
{
case 1: mode1();
break;
case 2: ssdsetHex(hex_count);
if(fast_flag)
{
mode2();
SysCtlDelay(SysCtlClockGet()/300);
}
break;
case 3: mode3(); break;
case 4: mode1(); break;
case 5: ssdsetHex(hex_count);
if(fast_flag)
{
mode2();
SysCtlDelay(SysCtlClockGet()/300);
} break;
}
SysCtlDelay(SysCtlClockGet()/3000);
}
return 0;
}
PROCESS_THREAD(hello_world_process, ev, data)
{
//static struct etimer timer;
PROCESS_BEGIN();
//begintimer();
//etimer_set(&timer, CLOCK_CONF_SECOND * 1);
uint32_t ui32PrevCount = 0;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
//SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
//SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// The Timer0 peripheral must be enabled for use.
//
SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_GPT0);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for Timer operation.
//
//InitConsole();
//
// Display the example setup on the console.
//
printf(" 16-Bit Timer Interrupt ->\n\r");
printf(" Timer = Timer0B\n\r");
printf(" Mode = Periodic\n\r");
printf(" Number of interrupts = %d \n\r", NUMBER_OF_INTS);
printf(" Rate = 1ms\n\r");
//
// Configure Timer0B as a 16-bit periodic timer.
//
TimerConfigure(GPTIMER0_BASE, GPTIMER_CFG_SPLIT_PAIR |
GPTIMER_CFG_A_PERIODIC | GPTIMER_CFG_B_PWM);
/* TimerConfigure(GPTIMER0_BASE, GPTIMER_CFG_SPLIT_PAIR |
GPTIMER_CFG_A_PWM | GPTIMER_CFG_B_PWM); */
//
// Set the Timer0B load value to 1ms.
//
TimerLoadSet(GPTIMER0_BASE, GPTIMER_B, sys_ctrl_get_sys_clock() / 100 );
// TimerLoadSet(GPTIMER0_BASE, GPTIMER_B, SYS_CTRL_32MHZ );
//
// The following call will result in a dynamic interrupt table being used.
// The table resides in RAM.
// Alternatively SysTickIntHandler can be statically registred in your
// application.
//
TimerIntRegister(GPTIMER0_BASE, GPTIMER_B, Timer0BIntHandler);
//
// Enable processor interrupts.
//
//IntMasterEnable();
INTERRUPTS_ENABLE();
//
// Configure the Timer0B interrupt for timer timeout.
//
TimerIntEnable(GPTIMER0_BASE, GPTIMER_TIMB_TIMEOUT);
//
// Enable the Timer0B interrupt on the processor (NVIC).
//
IntEnable(INT_TIMER0B);
//
// Initialize the interrupt counter.
//
g_ui32Counter = 0;
//
// Enable Timer0B.
//
TimerEnable(GPTIMER0_BASE, GPTIMER_B);
//
// Loop forever while the Timer0B runs.
//
while(1)
{
//
// If the interrupt count changed, print the new value
//
if(ui32PrevCount != g_ui32Counter)
{
//
// Print the periodic interrupt counter.
//
printf("Number of interrupts: %d\r", g_ui32Counter);
ui32PrevCount = g_ui32Counter;
}
}
/*
while(1) {
//PROCESS_YIELD();
//if(ev == PROCESS_EVENT_TIMER) {
printf(" Hello Hi \n\r" );
//etimer_set(&timer, CLOCK_SECOND);
//}
}
*/
PROCESS_END();
}
void InitClocksGPIOAndTimer() {
uint32_t ui32PWMClock;
//
// 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 directly from the crystal.
//
ROM_SysCtlClockSet(
SYSCTL_SYSDIV_40 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_1);
// PWM Setup
SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinConfigure(GPIO_PC4_M0PWM6);
GPIOPinTypePWM(GPIO_PORTC_BASE, GPIO_PIN_4);
GPIOPinConfigure(GPIO_PC5_M0PWM7);
GPIOPinTypePWM(GPIO_PORTC_BASE, GPIO_PIN_5);
ui32PWMClock = SysCtlClockGet();
ui32Load = (ui32PWMClock / PWM_FREQUENCY) - 1;
PWMGenConfigure(PWM0_BASE, PWM_GEN_3, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_3, ui32Load);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_6, PWM_LOW);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_7, PWM_LOW);
// Started as not active
PWMOutputState(PWM0_BASE, PWM_OUT_6_BIT, false);
PWMOutputState(PWM0_BASE, PWM_OUT_7_BIT, false);
PWMGenEnable(PWM0_BASE, PWM_GEN_3);
// PWM Setup for IR LED
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinConfigure(GPIO_PB6_M0PWM0);
GPIOPinTypePWM(GPIO_PORTB_BASE, GPIO_PIN_6);
PWMGenConfigure(PWM0_BASE, PWM_GEN_0,
PWM_GEN_MODE_DOWN | PWM_GEN_MODE_NO_SYNC);
PWMGenPeriodSet(PWM0_BASE, PWM_GEN_0, 1050/8);
PWMPulseWidthSet(PWM0_BASE, PWM_OUT_0, 525/8);
PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT, false);
PWMGenEnable(PWM0_BASE, PWM_GEN_0);
//
// Enable peripheral and register interrupt handler
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOIntRegister(GPIO_PORTA_BASE, GPIOMotionDetectorIsr);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOIntRegister(GPIO_PORTE_BASE, GPIOLightSwitchIsr);
#ifdef RUN_AS_MASTER
GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_5);
GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_5, GPIO_BOTH_EDGES);
#else
GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTA_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE);
#endif
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_4, GPIO_RISING_EDGE);
//
// Enable the pin interrupts.
//
GPIOIntEnable(GPIO_PORTA_BASE, GPIO_INT_PIN_2 | GPIO_INT_PIN_5);
GPIOIntEnable(GPIO_PORTE_BASE, GPIO_INT_PIN_4);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
TimerConfigure(TIMER0_BASE, TIMER_CFG_A_ONE_SHOT);
TimerConfigure(TIMER1_BASE, TIMER_CFG_A_ONE_SHOT);
TimerIntRegister(TIMER0_BASE, TIMER_A, IRTimerIsr);
TimerIntRegister(TIMER1_BASE, TIMER_A, IdleTimerIsr);
ulPeriod = (SysCtlClockGet()); // once per second
TimerLoadSet(TIMER0_BASE, TIMER_A, ulPeriod);
TimerLoadSet(TIMER1_BASE, TIMER_A, ulPeriod * LIGHTS_ON_PERIOD_SEC);
TimerLoadSet(TIMER1_BASE, TIMER_B, ulPeriod * 3);
IntEnable(INT_TIMER0A);
IntEnable(INT_TIMER1A);
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable the GPIO pin for blue LED component (PF2).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
g_ulCountsPerMicrosecond = ROM_SysCtlClockGet() / 1000000;
// 10ms = timeout delay
g_ulIRPeriod = g_ulCountsPerMicrosecond * IR_TIMEOUT_VAL;
}
//*****************************************************************************
//
// Timer Interrupt Register
//
// Registers a desired function as the interrupt handler for a timer.
//
//*****************************************************************************
void Timer_IntRegister(void (*pfnHandler)(void))
{
TimerIntRegister(TIMER0_BASE, TIMER_A, pfnHandler);
}
// void setup(void) runs ONCE when the program just STARTS
void setup()
{
// First SET the SYSTEM CLOCK to 80 [MHz]
// Sets the Clock DIVIDER to 2.5, so that SYS_CLOCK runs at 200/2.5 ==> 80 [MHz]
SysCtlClockSet( SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
uint32_t Timer0_Period;
// Enable & Configure Serial(UART0) to BAUDRATE = 9216000
Serial.begin(BAUDRATE);
// Configure PINS for LED OUTPUT
pinMode(RED,OUTPUT);
pinMode(BLUE,OUTPUT);
pinMode(GREEN,OUTPUT);
// Set LED OUTPUT pins to OFF initially
digitalWrite(RED,LOW);
digitalWrite(BLUE,LOW);
digitalWrite(GREEN,LOW);
state_led=0; // initialize the STATE to STATE0
// Initialize the 'Wire' class for the I2C-bus.
Wire.begin();
// Clear the 'sleep' bit to start the sensor.
MPU9150_writeSensor(MPU9150_PWR_MGMT_1, 0);
int temp0;
temp0= MPU9150_readSensor(0x1c);
temp0 |= (0x10);
temp0 &=~(0x08);
MPU9150_writeSensor(0x1c,temp0);
MPU9150_writeSensor(0x19,0x0f);
MPU9150_setupCompass();
SysCtlPeripheralEnable( SYSCTL_PERIPH_TIMER0); // Enable Timer0
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); // Set Timer0 mode PERIODIC
// Timer0_Period ==> 80e6 * A / B, (1/2)=0.5
Timer0_Period = ( 80000000 * A ) / B;
TimerLoadSet( TIMER0_BASE, TIMER_A, Timer0_Period-1);
// REGISTER ISR to TIMER0 INTERRUPT
TimerIntRegister( TIMER0_BASE, TIMER_A, Timer0_isr );
// Enable Interrupts from Timer0_A
IntEnable( INT_TIMER0A);
// Set Timer Interrupt Condition and Enable Timer Interrupt
TimerIntEnable( TIMER0_BASE, TIMER_TIMA_TIMEOUT);
// Enable INTERRUPTS for the SYSTEM
IntMasterEnable();
// Start Timer0
TimerEnable(TIMER0_BASE, TIMER_A);
}
void joystick_init(void) {
// Register Joystick button isr
GPIOPinTypeGPIOInput(JOY_PORT, JOY_MASK);
GPIOPadConfigSet(JOY_PORT, JOY_MASK, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);
GPIOIntTypeSet(JOY_PORT, JOY_MASK, GPIO_BOTH_EDGES);
GPIOPortIntRegister(JOY_PORT, button_handler);
GPIOPinIntEnable(JOY_PORT, JOY_MASK);
//
// The ADC0 peripheral must be enabled for use.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
//
// Select the analog ADC function for these pins.
//
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0);
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3);
// Use sequences 0 and 1 for x and y.
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
// Single ended sample on CH3 (X) and CH4 (Y).
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH3 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH4 | ADC_CTL_IE | ADC_CTL_END);
// Enable the sequences.
ADCSequenceEnable(ADC0_BASE, 0);
ADCSequenceEnable(ADC0_BASE, 1);
// Register ISRs.
ADCIntRegister(ADC0_BASE, 0, x_handler);
ADCIntRegister(ADC0_BASE, 1, y_handler);
ADCIntEnable(ADC0_BASE, 0);
ADCIntEnable(ADC0_BASE, 1);
// Trigger the first conversion (auto-center)
ADCProcessorTrigger(ADC0_BASE, 0);
ADCProcessorTrigger(ADC0_BASE, 1);
// Configure timer
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3);
TimerConfigure(JOY_TIMER, TIMER_CFG_PERIODIC);
// //Register Jog Z buttons
// GPIOPinTypeGPIOInput(JOG_Z_PORT, JOG_Z_MASK);
// GPIOIntTypeSet(JOG_Z_PORT, JOG_Z_MASK, GPIO_BOTH_EDGES);
// GPIOPortIntRegister(JOG_Z_PORT, jog_z_handler);
// GPIOPinIntEnable(JOG_Z_PORT, JOG_Z_MASK);
// GPIOPadConfigSet(JOG_Z_PORT,JOG_Z_MASK,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD);
// Create a 10ms timer callback
TimerLoadSet64(JOY_TIMER, SysCtlClockGet() / 500);
TimerIntRegister(JOY_TIMER, TIMER_A, joystick_isr);
TimerIntEnable(JOY_TIMER, TIMER_TIMA_TIMEOUT);
IntPrioritySet(INT_TIMER3A, CONFIG_JOY_PRIORITY);
TimerEnable(JOY_TIMER, TIMER_A);
}
int main(void) {
SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);//1024hz = 15625
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_3);
GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
GPIOPinConfigure(GPIO_PB1_U1TX);
GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_1);
UARTConfigSetExpClk(b1, SysCtlClockGet(), 9600, UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE);
UARTEnable(b1);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, (GPIO_PIN_0 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_1));
GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
frequency = SysCtlClockGet()/2;
changeCursorUnderscore();
toggleLED();
//Clear Display
clearDisplay();
//putPhrase("Hello World!");
//Timer Configuration
TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER0_BASE, TIMER_A, frequency);
TimerControlEvent(TIMER0_BASE, TIMER_A, TIMER_EVENT_POS_EDGE);
TimerEnable(TIMER0_BASE, TIMER_A);
//Timer Interrupt Enable
TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
TimerIntRegister(TIMER0_BASE, TIMER_A, timer_interrupt);
while(1){
if(flag = 1){
//Reset the line read
code = 0;
//Turn on the scan for a line
if(counter == 0) GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_3, 0x8);
if(counter == 1) GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_4, 0x10);
if(counter == 2) GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5, 0x20);
if(counter == 3) GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_6, 0x40);
//Check which button on the line was pressed
if(GPIOPinRead(GPIO_PORTA_BASE, GPIO_PIN_5) == 0x20) {
code = 1;
temp = log_code;
}
if(GPIOPinRead(GPIO_PORTA_BASE, GPIO_PIN_6) == 0x40) {
code = 2;
temp = log_code;
}
if(GPIOPinRead(GPIO_PORTA_BASE, GPIO_PIN_7) == 0x80) {
code = 3;
temp = log_code;
}
//Turn off the scan for a line
if(counter == 0) GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_3, 0x0);
if(counter == 1) GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_4, 0x0);
if(counter == 2) GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5, 0x0);
if(counter == 3) GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_6, 0x0);
//Check the next line on the next run and if overflows, reset
//Calculate the index_code for the lookup table
index_code = temp + code;
key_char = lookup_table[index_code];
log_code = log_code + 4;
if(log_code > 12){
log_code = 0;
}
counter++;
if(counter > 3) counter = 0;
if(key_char != 'x'){
//toggleLED();
putChar(key_char);
//SysCtlDelay(100000);
index_code = 0;
}
flag = 0;
}
}
}
