//*****************************************************************************
//
// 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)
{
}
}
void board_init(void) {
uint32_t clockfreq;
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
board_configure_led();
console_init();
board_spi_init();
board_systick_init();
board_watchdog_init();
timer_example_timer_init();
clockfreq = ROM_SysCtlClockGet();
delayloopspermicrosecond = (ROM_SysCtlClockGet() / (uint32_t) 1e6) / 3;
delayloopspermillisecond = (ROM_SysCtlClockGet() / (uint32_t) 1e3) / 3;
console_printtext("\n\n\n***** TM4C scheduler *****\n");
console_printtext("** System clock: %d MHz **\n", ROM_SysCtlClockGet() / (uint32_t) 1e6);
console_printtext("* Type 'help' for commands *\n");
if (clockfreq < 3e6)
console_printtext("WARNING: System clock is below 3 MHz, board timing might be inaccurate!\n");
else
console_printtext("\n");
ROM_IntMasterEnable();
}
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();
}
void lcd_init() {
ROM_SysCtlPeripheralEnable(LCD_PORTENABLE);
ROM_GPIOPinTypeGPIOOutput(LCD_PORT, (LCD_RS | LCD_E | LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7));
// Please refer to the HLCD_D44780 datasheet for how these initializations work!
ROM_SysCtlDelay(ROM_SysCtlClockGet()/3/2);
ROM_GPIOPinWrite(LCD_PORT, LCD_RS, 0x00);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x30);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((50e-3)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x30);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3);ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((50e-3)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x30);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((10e-3)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, 0x20);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((10e-3)*ROM_SysCtlClockGet()/3);
lcd_command(LCD_CLEARDISPLAY); // Clear the screen.
lcd_command(0x06); // Cursor moves right.
lcd_command(LCD_DISPLAYCONTROL | LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF); // Don't show any cursor, turn on LCD.
}
void lcd_command(unsigned char command) {
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, (command & 0xf0) );
ROM_GPIOPinWrite(LCD_PORT, LCD_RS, 0x00);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((100e-6)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, (command & 0x0f) << 4 );
ROM_GPIOPinWrite(LCD_PORT, LCD_RS, 0x00);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3); ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((5e-3)*ROM_SysCtlClockGet()/3);
}
// Main ----------------------------------------------------------------------------------------------
int main(void){
// Enable lazy stacking
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);
// Initialize the UART and write status.
ConfigureUART();
UARTprintf("Timers example\n");
// Enable LEDs
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN);
// Enable the peripherals used by this example.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
// 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_TimerConfigure(TIMER2_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet());
ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet()*2); // Blue should blink 2 times as much as red
ROM_TimerLoadSet(TIMER2_BASE, TIMER_A, ROM_SysCtlClockGet()*3); // Green should blink 3 times as much as red
// Setup the interrupts for the timer timeouts.
ROM_IntEnable(INT_TIMER0A);
ROM_IntEnable(INT_TIMER1A);
ROM_IntEnable(INT_TIMER2A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerIntEnable(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
// Enable the timers.
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
ROM_TimerEnable(TIMER1_BASE, TIMER_A);
ROM_TimerEnable(TIMER2_BASE, TIMER_A);
// Loop forever while the timers run.
while(1){}
}
void buzzer_init(void)
{
BUZZER_GPIO_PERIPHERAL_ENABLE();
BUZZER_TIMER_PERIPHERAL_ENABLE();
ROM_GPIOPinConfigure(BUZZER_TIMER_PIN_AF);
ROM_GPIOPinTypeTimer(BUZZER_PORT, BUZZER_PIN);
ROM_TimerConfigure(BUZZER_TIMER, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM);
// ROM_TimerPrescaleSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, 10);
ROM_TimerLoadSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, ROM_SysCtlClockGet());
ROM_TimerMatchSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, ROM_SysCtlClockGet()); // PWM
ROM_TimerEnable(BUZZER_TIMER, BUZZER_TIMER_CHANNEL);
}
void lcd_write(unsigned char inputData) {
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, (inputData & 0xf0) );
ROM_GPIOPinWrite(LCD_PORT, LCD_RS, 0x01);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);
ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((100e-6)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7, (inputData & 0x0f) << 4 );
ROM_GPIOPinWrite(LCD_PORT, LCD_RS, 0x01);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x02);
ROM_SysCtlDelay((20e-6)*ROM_SysCtlClockGet()/3);
ROM_GPIOPinWrite(LCD_PORT, LCD_E, 0x00);
ROM_SysCtlDelay((5e-3)*ROM_SysCtlClockGet()/3);
}
// Main ----------------------------------------------------------------------------------------------
int main(void){
// Enable lazy stacking
ROM_FPULazyStackingEnable();
// Set the system clock to run at 40Mhz off PLL with external crystal as reference.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
// Initialize the UART and write status.
ConfigureUART();
UARTprintf("ISL29023 Example\n");
// Enable LEDs
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_BLUE|LED_GREEN);
// Enable I2C3
ConfigureI2C3();
// Create struct
tISL29023 islSensHub;
// Create print variables
uint32_t printValue[2];
ISL29023ChangeSettings(ISL29023_COMMANDII_RANGE64k, ISL29023_COMMANDII_RES16, &islSensHub);
while(1){
// Get ALS
ISL29023GetALS(&islSensHub);
FloatToPrint(islSensHub.alsVal, printValue);
UARTprintf("ALS: %d.%03d |.| ",printValue[0],printValue[1]);
// Get IR
ISL29023GetIR(&islSensHub);
FloatToPrint(islSensHub.irVal, printValue);
UARTprintf("IR: %d.%03d\n",printValue[0],printValue[1]);
// Blink LED
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, LED_GREEN);
ROM_SysCtlDelay(ROM_SysCtlClockGet()/3/10); // Delay for 100ms (1/10s) :: ClockGet()/3 = 1second
ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE, 0);
// Delay for second
ROM_SysCtlDelay(ROM_SysCtlClockGet()/3);
}
}
/**
* Initalize the RS232 port.
*
*/
void
uart0_init(unsigned long ubr)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable the GPIO pins for the LED (PF2).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
ROM_IntMasterEnable();
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(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
}
static void system_SystickConfig(uint32_t ui32_msInterval)
{
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() * ui32_msInterval / 1000);
SysTickIntRegister(&SysTickIntHandle);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
}
void PWMWrite(uint8_t pin, uint32_t analog_res, uint32_t duty, unsigned int freq)
{
if (duty == 0) {
pinMode(pin, OUTPUT);
digitalWrite(pin, LOW);
}
else if (duty >= analog_res) {
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
}
else {
uint8_t bit = digitalPinToBitMask(pin); // get pin bit
uint8_t port = digitalPinToPort(pin); // get pin port
uint8_t timer = digitalPinToTimer(pin);
uint32_t portBase = (uint32_t) portBASERegister(port);
uint32_t offset = timerToOffset(timer);
uint32_t timerBase = getTimerBase(offset);
uint32_t timerAB = TIMER_A << timerToAB(timer);
if (port == NOT_A_PORT) return; // pin on timer?
uint32_t periodPWM = ROM_SysCtlClockGet()/freq;
enableTimerPeriph(offset);
ROM_GPIOPinConfigure(timerToPinConfig(timer));
ROM_GPIOPinTypeTimer((long unsigned int) portBase, bit);
//
// Configure for half-width mode, allowing timers A and B to
// operate independently
//
HWREG(timerBase + TIMER_O_CFG) = 0x04;
if(timerAB == TIMER_A) {
HWREG(timerBase + TIMER_O_CTL) &= ~TIMER_CTL_TAEN;
HWREG(timerBase + TIMER_O_TAMR) = PWM_MODE;
}
else {
HWREG(timerBase + TIMER_O_CTL) &= ~TIMER_CTL_TBEN;
HWREG(timerBase + TIMER_O_TBMR) = PWM_MODE;
}
ROM_TimerLoadSet(timerBase, timerAB, periodPWM);
ROM_TimerMatchSet(timerBase, timerAB,
(analog_res-duty)*periodPWM/analog_res);
//
// If using a 16-bit timer, with a periodPWM > 0xFFFF,
// need to use a prescaler
//
if((offset < WTIMER0) && (periodPWM > 0xFFFF)) {
ROM_TimerPrescaleSet(timerBase, timerAB,
(periodPWM & 0xFFFF0000) >> 16);
ROM_TimerPrescaleMatchSet(timerBase, timerAB,
(((analog_res-duty)*periodPWM/analog_res) & 0xFFFF0000) >> 16);
}
ROM_TimerEnable(timerBase, timerAB);
}
void UART_setup_gps(void)
{
//
// Enable the peripherals used by gps.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//
// Set GPIO B0 and B1 as UART pins for the gps.
//
ROM_GPIOPinConfigure(GPIO_PB0_U1RX);
ROM_GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the GPS for 9600, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART1_BASE, ROM_SysCtlClockGet(), 9600,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART1);
ROM_UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
}
void BPMTimerSetUp()
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); // timer 0
SysCtlDelay(3);
//
// Enable processor interrupts.
//
//IntPrioritySet(INT_TIMER0A_TM4C123, 2);
//
// Configure the two 32-bit periodic timers.
//
ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet()/500);
//ROM_SysCtlClockGet()/100000
//ROM_SysCtlClockGet()/500
// Setup the interrupts for the timer timeouts.
ROM_IntEnable(INT_TIMER0A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
//
// Enable the timers.
//
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
}
void initTimer1(int interval){
//
// 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.
//
volatile int tick = 0;
tick = (ROM_SysCtlClockGet() / 1000) * interval; //100 sono i ms
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
//
// Configure the two 32-bit periodic timers.
//
TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
/// imposta il time_out
TimerLoadSet(TIMER1_BASE, TIMER_A, tick);
//
// Setup the interrupts for the timer timeouts.
//
IntEnable(INT_TIMER1A);
//ROM_IntEnable(INT_TIMER1A);
TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
//ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
}
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();
}
int main0(void){
// "Embedded Systems: Real Time Interfacing to ARM Cortex M Microcontrollers",
// ISBN: 978-1463590154, Jonathan Valvano, copyright (c) 2014, Volume 2, Program 11.2
UINT8 IsDHCP = 0;
_NetCfgIpV4Args_t ipV4;
SlSockAddrIn_t Addr;
UINT16 AddrSize = 0;
INT16 SockID = 0;
UINT32 data;
unsigned char len = sizeof(_NetCfgIpV4Args_t);
initClk(); // PLL 50 MHz, ADC needs PPL active 15
ADC0_InitSWTriggerSeq3(7); // Ain7 is on PD0 16
sl_Start(0, 0, 0); // Initializing the CC3100 device 17
WlanConnect(); // connect to AP 18
sl_NetCfgGet(SL_IPV4_STA_P2P_CL_GET_INFO,&IsDHCP,&len, // 19
(unsigned char *)&ipV4); // 20
Addr.sin_family = SL_AF_INET; // 21
Addr.sin_port = sl_Htons((UINT16)PORT_NUM); // 22
Addr.sin_addr.s_addr = sl_Htonl((UINT32)IP_ADDR); // 23
AddrSize = sizeof(SlSockAddrIn_t); // 24
SockID = sl_Socket(SL_AF_INET,SL_SOCK_DGRAM, 0); // 25
while(1){
uBuf[0] = ATYPE; // analog data type 26
uBuf[1] = '='; // 27
data = ADC0_InSeq3(); // 0 to 4095, Ain7 is on PD0 28
Int2Str(data,(char*)&uBuf[2]); // 6 digit number 29
sl_SendTo(SockID, uBuf, BUF_SIZE, 0, // 30
(SlSockAddr_t *)&Addr, AddrSize); // 31
ROM_SysCtlDelay(ROM_SysCtlClockGet() / 25); // 40ms 32
}
}
void buzzer_setsound(uint32_t ulFrequency)
{
uint32_t ulPeriod;
if (ulFrequency == 0)
{
ROM_TimerLoadSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, ROM_SysCtlClockGet());
ROM_TimerMatchSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, ROM_SysCtlClockGet());
}
else
{
ulPeriod = ROM_SysCtlClockGet() / ulFrequency;
ROM_TimerLoadSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, ulPeriod);
ROM_TimerMatchSet(BUZZER_TIMER, BUZZER_TIMER_CHANNEL, ulPeriod / 2);
}
}
//*****************************************************************************
//
//! 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();
}
/*
* UART3 is used to communicate with the Optode. Set UART3
* to 9600 baud, 8, N, 1. Also, set up and enable the RX FIFO interrupt
* to receive data.
*/
void UART3Init(void)
{
// set up UART3 to the optode
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
ROM_GPIOPinConfigure(GPIO_PC6_U3RX); //set up the pins
ROM_GPIOPinConfigure(GPIO_PC7_U3TX);
ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7);
//9600 baud, 8, N, 1
ROM_UARTConfigSetExpClk(UART3_BASE, ROM_SysCtlClockGet(), 9600,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
// Enable the UART.
ROM_UARTEnable(UART3_BASE);
//RX interrupt will occur when FIFO is 1/8 full
ROM_UARTFIFOLevelSet(UART3_BASE, UART_FIFO_TX7_8, UART_FIFO_RX1_8);
//enable the interrupt
ROM_IntEnable(INT_UART3);
//flush the RX fifo before enabling the RX interrupt to get rid of residual data
while(ROM_UARTCharsAvail(UART3_BASE))
{
ROM_UARTCharGetNonBlocking(UART3_BASE);
}
//Enable the UART peripheral interrupt...receive
ROM_UARTIntEnable(UART3_BASE, UART_INT_RX);
}
BOOL xMBTCPPortInit(USHORT port)
{
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,WIZ610_GPIO_PIN_CMD_ENABLE);
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);
WIZ610Transfer();
cmd_modbus_switch=0;
g_ulRxBufACount=0;
modbus_tcp_rab=MODBUS_TCP_IDLE;
return TRUE;
}
// Main ----------------------------------------------------------------------------------------------
int main(void){
// Enable lazy stacking
ROM_FPULazyStackingEnable();
// Set the clocking to run directly from the crystal.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
// Initialize the UART and write status.
ConfigureUART();
UARTprintf("--Countdown Example--\n");
// Initialize LEDs
ConfigureLEDs();
// Enable the peripherals used by this example.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER2);
// 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_TimerConfigure(TIMER2_BASE, TIMER_CFG_ONE_SHOT);
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet());
ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet()/20);
ROM_TimerLoadSet(TIMER2_BASE, TIMER_A, ROM_SysCtlClockGet()/10);
// Setup the interrupts for the timer timeouts.
ROM_IntEnable(INT_TIMER0A);
ROM_IntEnable(INT_TIMER1A);
ROM_IntEnable(INT_TIMER2A);
ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
ROM_TimerIntEnable(TIMER2_BASE, TIMER_TIMA_TIMEOUT);
// Enable the timers.
ROM_TimerEnable(TIMER0_BASE, TIMER_A);
UARTprintf("Time Left: \n");
// Loop forever while the timers run.
while(1){}
}
//****************************************************************************
//
// This is the main loop that runs the application.
//
//****************************************************************************
int
main(void)
{
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
g_psCompDevices[0].pvInstance =
USBDHIDMouseCompositeInit(0, (tUSBDHIDMouseDevice *)&g_sMouseDevice);
g_psCompDevices[1].pvInstance =
USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass the device information to the USB library and place the device
// on the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
g_pucDescriptorData);
//
// Initialize the mouse and serial devices.
//
MouseInit();
SerialInit();
//
// Drop into the main loop.
//
while(1)
{
//
// Allow the main mouse routine to run.
//
MouseMain();
//
// Allow the main serial routine to run.
//
SerialMain();
}
}
/* Sets baud rate registers */
void usart_baud(uint32_t baud) {
float brd = ROM_SysCtlClockGet() / (16 * baud);
int brdi = (int) brd;
int brdf = (int) (brd * 64 + 0.5);
UART0_IBRD_R = brdi;
UART0_FBRD_R = brdf;
}
void init_uart(void) {
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
}
void initQEI(void){
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); //PhA sur C4 et PhB sur C6
SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //PhA sur E3 et PhB sur E2
SysCtlPeripheralEnable(SYSCTL_PERIPH_QEI1);
//init QEI0 du micro pour moteur 0
GPIOPinConfigure(GPIO_PC4_PHA0);
GPIOPinConfigure(GPIO_PC6_PHB0);
GPIOPinTypeQEI(GPIO_PORTC_BASE, GPIO_PIN_4); //Ph A
GPIOPinTypeQEI(GPIO_PORTC_BASE, GPIO_PIN_6); //Ph B
QEIDisable(QEI0_BASE);
QEIConfigure(QEI0_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_NO_RESET|
QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), 1000000); //64 counts par révolution de moteur avec un ratio 100:1
QEIEnable(QEI0_BASE);
QEIPositionSet(QEI0_BASE,0);
QEIVelocityDisable(QEI0_BASE);
QEIVelocityConfigure (QEI0_BASE, QEI_VELDIV_1, ROM_SysCtlClockGet()*dt);
QEIVelocityEnable(QEI0_BASE);
//init QEI1 du micro pour moteur 1
GPIOPinConfigure(GPIO_PE3_PHA1);
GPIOPinConfigure(GPIO_PE2_PHB1);
GPIOPinTypeQEI(GPIO_PORTE_BASE, GPIO_PIN_3); //Ph A
GPIOPinTypeQEI(GPIO_PORTE_BASE, GPIO_PIN_2); //Ph B
QEIDisable(QEI1_BASE);
QEIConfigure(QEI1_BASE, (QEI_CONFIG_CAPTURE_A_B | QEI_CONFIG_NO_RESET|
QEI_CONFIG_QUADRATURE | QEI_CONFIG_NO_SWAP), 1000000); //64 counts par révolution de moteur avec un ratio 100:1
QEIEnable(QEI1_BASE);
QEIPositionSet(QEI1_BASE,0);
QEIVelocityDisable(QEI1_BASE);
QEIVelocityConfigure (QEI1_BASE, QEI_VELDIV_1, ROM_SysCtlClockGet()*dt);
QEIVelocityEnable(QEI1_BASE);
//init decodeur fait a la mitaine pour moteur 2 et 3 (pins J4 et J5 pour moteur 2, J6 et J7 pour moteur 3)
GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_6 | GPIO_PIN_7, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPD);
GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_6 | GPIO_PIN_7);
GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_6 | GPIO_PIN_7, GPIO_BOTH_EDGES);
GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_6 | GPIO_PIN_7);
IntEnable(INT_GPIOE);
position_m0 = 0;
position_m1 = 0;
position_m2 = 0;
position_m3 = 0;
}
void system_Process_System_State(void)
{
switch (system_GetState())
{
case SYSTEM_POWER_UP:
break;
case SYSTEM_INITIALIZE:
break;
case SYSTEM_CALIB_SENSOR:
break;
case SYSTEM_SAVE_CALIB_SENSOR:
break;
case SYSTEM_ESTIMATE_MOTOR_MODEL:
ProcessSpeedControl();
break;
case SYSTEM_SAVE_MOTOR_MODEL:
break;
case SYSTEM_WAIT_TO_RUN:
break;
case SYSTEM_RUN_SOLVE_MAZE:
pid_Wallfollow_process();
ProcessSpeedControl();
break;
case SYSTEM_RUN_IMAGE_PROCESSING:
LED1_ON();
ProcessSpeedControl();
break;
case SYSTEM_ERROR:
speed_Enable_Hbridge(false);
system_Enable_BoostCircuit(false);
IntMasterDisable();
while (1)
{
LED1_ON();
LED2_ON();
LED3_ON();
ROM_SysCtlDelay(ROM_SysCtlClockGet() / 3);
LED1_OFF();
LED2_OFF();
LED3_OFF();
ROM_SysCtlDelay(ROM_SysCtlClockGet() / 3);
}
// break;
}
}
/*
* @brief: Read all 3 axes of HMC5883L
* @param[in]: ptr output to individual axes
* @param[out]: none
*/
void hmc5883l_ReadXYZ(int16_t *x, int16_t *y, int16_t *z){
uint8_t b[6];
i2c_WriteByte(I2C_ID_HMC5883L, HMC5883L_RA_MODE, HMC5883L_MODE_SINGLE);
ROM_SysCtlDelay(6*(ROM_SysCtlClockGet()/3000));
i2c_ReadBuf(I2C_ID_HMC5883L, HMC5883L_DATA, 6, b);
*x = ((int16_t)(((uint16_t)b[0]<<8) | (uint16_t)b[1]))*xyz_comp_num[0]/xyz_comp_den[0];
*y = ((int16_t)(((uint16_t)b[2]<<8) | (uint16_t)b[3]))*xyz_comp_num[1]/xyz_comp_den[1];
*z = ((int16_t)(((uint16_t)b[4]<<8) | (uint16_t)b[5]))*xyz_comp_num[2]/xyz_comp_den[2];
}
void delay_ms(uint32_t ui32Ms) {
// 1 clock cycle = 1 / SysCtlClockGet() second
// 1 SysCtlDelay = 3 clock cycle = 3 / SysCtlClockGet() second
// 1 second = SysCtlClockGet() / 3
// 0.001 second = 1 ms = SysCtlClockGet() / 3 / 1000
ROM_SysCtlDelay(ui32Ms * (ROM_SysCtlClockGet() / 3 / 1000));
}
// 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);
}
