/**
* Main function
*
* This is the traditional C main().
*/
int main(void)
{
#if USE_PROGRAM_STARTUP
program_startup();
#else
char s[64]; /* sprintf string */
unsigned long why; /* Why did we get reset? Why? */
prvSetupHardware();
init_logger();
#if PART == LM3S8962
RIT128x96x4Init(1000000);
#endif
/*
* \todo maybe this needs to be earlier or later in the code.
* Enable fault handlers in addition to FaultIsr()
*/
NVIC_SYS_HND_CTRL_R |= NVIC_SYS_HND_CTRL_USAGE
|NVIC_SYS_HND_CTRL_BUS
|NVIC_SYS_HND_CTRL_MEM;
#if (PART != LM3S2110)
/*
* Allow the following to erase the permanent configuration flash page:
*
* make PROTECT_PERMCFG="-D PROTECT_PERMCFG=0" \
* ERASE_PERMCFG="-D ERASE_PERMCFG=1"
*
* The program will continue to erase the permanent configuration structure
* at every powerup, so the program must be recompiled without the
* ERASE_PERMCFG=1 part and reloaded to allow a permanent configuration
* record to persist through power cycles.
*/
#if ERASE_PERMCFG
#if !PROTECT_PERMCFG
if (permcfg_erase()) {
#if (PART == LM3S8962)
RIT128x96x4StringDraw("permcfg Blank",
0, RITLINE(10), 15);
#endif
}
else {
#if (PART == LM3S8962)
RIT128x96x4StringDraw("permcfg Not Blank",
0, RITLINE(10), 15);
#endif
}
#endif
#endif
config_init();
#endif
/**
* \req \req_id The \program \shall identify:
* - The program version.
* - A copyright string.
* - The board identification.
* - The assembly identification.
* - Network configuration information.
*
* \todo Issue #1175 Add software build time, git hash, software
* version to build.
*/
lstr("\r\nCRI Quickstart\r\n");
#if (PART == LM3S2110)
lstr("LM3S2110 Eval Board\r\n");
#elif (PART == LM3S8962)
lstr("LM3S8962 Eval Board\r\n");
#elif (PART == LM3S9B96)
lstr("LM3S9B96 Eval Board\r\n");
#endif
lstr("Copyright (C) 2011 Consolidated Resource Imaging\r\n");
lprintf(" Software Build Date: %s\n", buildDate);
#if (PART != LM3S2110)
lprintf(" Assembly Part Number: %s\n", usercfg.assy_pn);
lprintf("Assembly Serial Number: %s\n", usercfg.assy_sn);
lprintf(" Board Part Number: %s\n", permcfg.bd_pn);
lprintf(" Board Serial Number: %s\n", permcfg.bd_sn);
lprintf("Notes:\r\n %s\r\n", usercfg.notes);
#endif
#if (PART == LM3S8962)
/*
* Display our configuration on the OLED display.
*/
RIT128x96x4StringDraw("CRI Quickstart", 0, RITLINE(0), 15);
RIT128x96x4StringDraw("LM3S8962", 0, RITLINE(1), 15);
/*
* Split date
* 0123456789012345678901234567890
* Sun, 08 May 2011 19:05:42 -0400
*
* into:
* 0123456789012345678901234567890
* Sun, 08 May 2011
*
* and
*
* 0123456789012345678901234567890
* 19:05:42 -0400
*/
strcpy(s,buildDate);
s[16]=0;
RIT128x96x4StringDraw(s, 0, RITLINE(2), 15);
RIT128x96x4StringDraw(&s[17], 0, RITLINE(3), 15);
#endif
/**
* \req \req_id The \program \shall identify:
* - The reason for the reset.
*/
why = SysCtlResetCauseGet();
if (why != 0) {
SysCtlResetCauseClear(why);
lprintf("Reset reason: ");
if (why & SYSCTL_CAUSE_LDO)
lprintf("LDO ");
if (why & SYSCTL_CAUSE_SW)
lprintf("SW ");
if (why & SYSCTL_CAUSE_WDOG)
lprintf("WDOG ");
if (why & SYSCTL_CAUSE_BOR)
lprintf("Brown-out ");
if (why & SYSCTL_CAUSE_POR)
lprintf("Power-on ");
if (why & SYSCTL_CAUSE_EXT)
lprintf("External ");
lprintf("\r\n");
}
io_init();
#endif
util_init();
/**
* \req \req_tcpip The \program \shall support TCP/IP communications.
*
* Create the LWIP task if running on a processor that includes a MAC
* and PHY.
*/
#if QUICK_ETHERNET
if( SysCtlPeripheralPresent( SYSCTL_PERIPH_ETH ) ) {
xTaskCreate(ethernetThread,
(signed char *)"eth-init",
DEFAULT_STACK_SIZE,
NULL,
ETH_INIT_PRIORITY,
NULL);
}
#endif
/*
* Enable interrupts...
*/
IntMasterEnable();
vSetupHighFrequencyTimer();
vTaskStartScheduler();
DPRINTF(0,"Idle Task Create Failed.");
/*
* Will only get here if there was insufficient memory to create the
* idle task.
*/
for( ;; );
return 0;
}
//*****************************************************************************
//
// Main function performs init and manages system.
//
// Called automatically after the system and compiler pre-init sequences.
// Performs system init calls, restores state from hibernate if needed and
// then manages the application context duties of the system.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32Status;
uint32_t ui32ResetCause;
int32_t i32CommandStatus;
//
// Enable 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_FPUStackingEnable();
//
// 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);
//
// Enable the hibernate module
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE);
//
// Enable and Initialize the UART.
//
ConfigureUART();
UARTprintf("Welcome to the Tiva C Series TM4C123G LaunchPad!\n");
UARTprintf("Type 'help' for a list of commands\n");
UARTprintf("> ");
//
// Determine why system reset occurred and respond accordingly.
//
ui32ResetCause = SysCtlResetCauseGet();
SysCtlResetCauseClear(ui32ResetCause);
if(ui32ResetCause == SYSCTL_CAUSE_POR)
{
if(HibernateIsActive())
{
//
// Read the status bits to see what caused the wake.
//
ui32Status = HibernateIntStatus(0);
HibernateIntClear(ui32Status);
//
// Wake was due to the push button.
//
if(ui32Status & HIBERNATE_INT_PIN_WAKE)
{
UARTprintf("Hibernate Wake Pin Wake Event\n");
UARTprintf("> ");
//
// Recover the application state variables from battery backed
// hibernate memory. Set ui32Mode to normal.
//
HibernateDataGet((uint32_t*) &g_sAppState,
sizeof(tAppState) / 4 + 1);
g_sAppState.ui32Mode = APP_MODE_NORMAL;
}
//
// Wake was due to RTC match
//
else if(ui32Status & HIBERNATE_INT_RTC_MATCH_0)
{
UARTprintf("Hibernate RTC Wake Event\n");
UARTprintf("> ");
//
// Recover the application state variables from battery backed
// hibernate memory. Set ui32Mode to briefly flash the RGB.
//
HibernateDataGet((uint32_t*) &g_sAppState,
sizeof(tAppState) / 4 + 1);
g_sAppState.ui32Mode = APP_MODE_HIB_FLASH;
}
}
else
{
//
// Reset was do to a cold first time power up.
//
UARTprintf("Power on reset. Hibernate not active.\n");
UARTprintf("> ");
g_sAppState.ui32Mode = APP_MODE_NORMAL;
g_sAppState.fColorWheelPos = 0;
g_sAppState.fIntensity = APP_INTENSITY_DEFAULT;
g_sAppState.ui32Buttons = 0;
}
}
else
{
//
// External Pin reset or other reset event occured.
//
UARTprintf("External or other reset\n");
UARTprintf("> ");
//
// Treat this as a cold power up reset without restore from hibernate.
//
g_sAppState.ui32Mode = APP_MODE_NORMAL;
g_sAppState.fColorWheelPos = APP_PI;
g_sAppState.fIntensity = APP_INTENSITY_DEFAULT;
g_sAppState.ui32Buttons = 0;
//
// colors get a default initialization later when we call AppRainbow.
//
}
//
// Initialize clocking for the Hibernate module
//
HibernateEnableExpClk(SysCtlClockGet());
//
// Initialize the RGB LED. AppRainbow typically only called from interrupt
// context. Safe to call here to force initial color update because
// interrupts are not yet enabled.
//
RGBInit(0);
RGBIntensitySet(g_sAppState.fIntensity);
AppRainbow(1);
RGBEnable();
//
// Initialize the buttons
//
ButtonsInit();
//
// Initialize the SysTick interrupt to process colors and buttons.
//
SysTickPeriodSet(SysCtlClockGet() / APP_SYSTICKS_PER_SEC);
SysTickEnable();
SysTickIntEnable();
IntMasterEnable();
//
// spin forever and wait for carriage returns or state changes.
//
while(1)
{
UARTprintf("\n>");
//
// Peek to see if a full command is ready for processing
//
while(UARTPeek('\r') == -1)
{
//
// millisecond delay. A SysCtlSleep() here would also be OK.
//
SysCtlDelay(SysCtlClockGet() / (1000 / 3));
//
// Check for change of mode and enter hibernate if requested.
// all other mode changes handled in interrupt context.
//
if(g_sAppState.ui32Mode == APP_MODE_HIB)
{
AppHibernateEnter();
}
}
//
// a '\r' was detected get the line of text from the user.
//
UARTgets(g_cInput,sizeof(g_cInput));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
i32CommandStatus = CmdLineProcess(g_cInput);
//
// Handle the case of bad command.
//
if(i32CommandStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(i32CommandStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
}
}
int
main(void)
{
char cThisChar;
/* Result code */
unsigned long ulResetCause;
//SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
unsigned long g=SysCtlClockGet();
FPUEnable();
FPUStackingEnable();
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
ulResetCause = SysCtlResetCauseGet();
SysCtlResetCauseClear(ulResetCause);
HibernateEnableExpClk(SysCtlClockGet());
ButtonsInit();
SysTickPeriodSet(SysCtlClockGet() / APP_SYSTICKS_PER_SEC);
SysTickEnable();
SysTickIntEnable();
IntMasterEnable();
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinConfigure(GPIO_PC4_U4RX);
GPIOPinConfigure(GPIO_PC5_U4TX);
GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);
UARTConfigSetExpClk(UART4_BASE, SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinConfigure(GPIO_PB0_U1RX);
GPIOPinConfigure(GPIO_PB1_U1TX);
GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//Orden al PGS de que me devuelva solo un mensaje..
for(i=0; i<sizeof(buferA); i++){
UARTCharPut(UART1_BASE, buferA[i]);}
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
rc = f_mount(0, &Fatfs); //registra un area de trabajo
rc = f_open(&Fil, "BuffGPS.TXT", FA_WRITE | FA_CREATE_ALWAYS); //abre o crea un archivo
do {
int contador1=0;
cThisChar='0';
do{
cThisChar=UARTCharGet(UART1_BASE);
BuffGPS[contador1]=cThisChar;
contador1=contador1+1;
} while((cThisChar != '\n'));
cThisChar='0';
for(i=0; i<sizeof(cuaternion); i++){
UARTCharPut(UART4_BASE, cuaternion[i]);}
do{
cThisChar=UARTCharGet(UART4_BASE);
BuffGPS[contador1]=cThisChar;
contador1=contador1+1;
} while((cThisChar != '\n'));
rc = f_write(&Fil, &BuffGPS, contador1, &bwGPS);
rc = f_sync(&Fil);
contador1=0;
//while(UARTCharsAvail(UART1_BASE)==false){;}
}
while(1);
}