//****************************************************************************
//
// This is the main loop serial handling function.
//
//****************************************************************************
void
SerialMain(void)
{
int iStatus;
//
// Main application loop.
//
if(HWREGBITW(&g_ulFlags, FLAG_COMMAND_RECEIVED))
{
//
// Clear the flag
//
HWREGBITW(&g_ulFlags, FLAG_COMMAND_RECEIVED) = 0;
//
// Process the command line.
//
iStatus = CmdLineProcess(g_pcCmdBuf);
//
// Handle the case of bad command.
//
if(iStatus == CMDLINE_BAD_CMD)
{
CommandPrint(g_pcCmdBuf);
CommandPrint(" is not a valid command!\n");
}
CommandPrint("\n> ");
}
}
int32_t LoopLib_Evaluate(char* g_cInput)
{
int32_t i32CommandStatus = 0;
i32CommandStatus = CmdLineProcess(g_cInput);
return(i32CommandStatus);
}
void cmd_periodic_cont(void)
{
long cmd_status;
if(UARTPeek('\r') == -1)
{
return;
}
// Get the buffer
UARTgets(input_buffer, sizeof(input_buffer));
cmd_status = CmdLineProcess(input_buffer);
switch(cmd_status)
{
case CMDLINE_BAD_CMD:
UARTprintf("Bad command!\n");
break;
case CMDLINE_TOO_MANY_ARGS:
UARTprintf("Bad arguments!\n");
break;
default:
break;
}
UARTprintf("> ");
}
//*****************************************************************************
//
// Checks to see if a new command has been received via the serial port and,
// if so, processes it.
//
//*****************************************************************************
void
LogProcessCommands(void)
{
int nStatus;
//
// Check to see if there is a new serial command to process.
//
if(UARTPeek('\r') >= 0)
{
//
// A new command has been entered so read it.
//
UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_cCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(nStatus != 0)
{
UARTprintf("Command returned error code %d\n", nStatus);
}
//
// Print a prompt on the console.
//
UARTprintf("\n> ");
}
}
//*****************************************************************************
//
// The program main function. It performs initialization, then handles wav
// file playback.
//
//*****************************************************************************
int
main(void)
{
int nStatus;
//
// Set the system clock to run at 80MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Give bget some memory to work with.
//
bpool(g_pulHeap, sizeof(g_pulHeap));
//
// Set the device pin out appropriately for this board.
//
PinoutSet();
//
// Configure the relevant pins such that UART0 owns them.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Open the UART for I/O
//
UARTStdioInit(0);
UARTprintf("i2s_speex_enc\n");
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Configure the I2S peripheral.
//
SoundInit(1);
//
// Set the format of the play back in the sound driver.
//
SoundSetFormat(AUDIO_RATE, AUDIO_BITS, AUDIO_CHANNELS);
//
// Print out some header information to the serial console.
//
UARTprintf("\ni2s_speex_enc Stellaris Example\n");
UARTprintf("Streaming at %d %d bit ",SoundSampleRateGet(), AUDIO_BITS);
if(AUDIO_CHANNELS == 2)
{
UARTprintf("Stereo\n");
}
else
{
UARTprintf("Mono\n");
}
//
// Set the initial volume.
//
SoundVolumeSet(INITIAL_VOLUME_PERCENT);
//
// Initialize the Speex decoder.
//
SpeexDecodeInit();
//
// Set the default quality to 2.
//
g_iQuality = 2;
//
// Initialize the Speex encoder to Complexity of 1 and Quality 2.
//
SpeexEncodeInit(AUDIO_RATE, 1, g_iQuality);
//
// Initialize the audio buffers.
//
InitBuffers();
//
// Initialize the applications global state flags.
//
g_ulFlags = 0;
//
// Kick off a request for a buffer play back and advance the encoder
// pointer.
//
SoundBufferRead(g_pucRecBuffer, RECORD_BUFFER_INC,
RecordBufferCallback);
g_pucEncode += RECORD_BUFFER_INC;
//
// Kick off a second request for a buffer play back and advance the encode
// pointer.
//
SoundBufferRead(&g_pucRecBuffer[RECORD_BUFFER_INC], RECORD_BUFFER_INC,
RecordBufferCallback);
g_pucEncode += RECORD_BUFFER_INC;
//
// The rest of the handling occurs at interrupt time so the main loop will
// simply stall here.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
UARTprintf("\n> ");
//
// Get a line of text from the user.
//
UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_cCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(nStatus != 0)
{
UARTprintf("Command returned error code \n");
}
}
}
//
// Main - It performs initialization, then runs a command processing loop to
// read commands from the console.
//
int
main(void)
{
int nStatus;
FRESULT fresult;
//
// Set the clocking to run from the PLL at 50MHz
//
SysCtlClockSet(SYSCTL_OSCSRC_OSC2 | SYSCTL_PLL_ENABLE | SYSCTL_IMULT(10) |
SYSCTL_SYSDIV(2));
SysCtlAuxClockSet(SYSCTL_OSCSRC_OSC2 | SYSCTL_PLL_ENABLE |
SYSCTL_IMULT(12) | SYSCTL_SYSDIV(2)); //60 MHz
#ifdef _FLASH
//
// Copy time critical code and Flash setup code to RAM
// This includes the following functions: InitFlash_Bank0();
// The RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart
// symbols are created by the linker. Refer to the device .cmd file.
//
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
//
// Call Flash Initialization to setup flash waitstates
// This function must reside in RAM
//
InitFlash_Bank0();
#endif
//
// Initialize interrupt controller and vector table
//
InitPieCtrl();
InitPieVectTable();
//
// Set the system tick to fire 100 times per second.
//
SysTickInit();
SysTickPeriodSet(SysCtlClockGet(SYSTEM_CLOCK_SPEED) / 100);
SysTickIntRegister(SysTickHandler);
SysTickIntEnable();
SysTickEnable();
//
// Enable Interrupts
//
IntMasterEnable();
//
// Configure UART0 for debug output.
//
ConfigureUART();
//
// Print hello message to user.
//
UARTprintf("\n\nSD Card Example Program\n");
UARTprintf("Type \'help\' for help.\n");
//
// Mount the file system, using logical disk 0.
//
fresult = f_mount(0, &g_sFatFs);
if(fresult != FR_OK)
{
UARTprintf("f_mount error: %s\n", StringFromFresult(fresult));
return(1);
}
//
// Enter an (almost) infinite loop for reading and processing commands from
// the user.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
UARTprintf("\n%s> ", g_cCwdBuf);
//
// Get a line of text from the user.
//
UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_cCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(nStatus != 0)
{
UARTprintf("Command returned error code %s\n",
StringFromFresult((FRESULT)nStatus));
}
}
}
//*****************************************************************************
//
// The main application loop.
//
//*****************************************************************************
int
main(void)
{
int32_t i32Status, i32Idx;
uint32_t ui32SysClock, ui32PLLRate;
#ifdef USE_ULPI
uint32_t ui32Setting;
#endif
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Set the part pin out appropriately for this device.
//
PinoutSet();
#ifdef USE_ULPI
//
// Switch the USB ULPI Pins over.
//
USBULPIPinoutSet();
//
// Enable USB ULPI with high speed support.
//
ui32Setting = USBLIB_FEATURE_ULPI_HS;
USBOTGFeatureSet(0, USBLIB_FEATURE_USBULPI, &ui32Setting);
//
// Setting the PLL frequency to zero tells the USB library to use the
// external USB clock.
//
ui32PLLRate = 0;
#else
//
// Save the PLL rate used by this application.
//
ui32PLLRate = 480000000;
#endif
//
// Initialize the hub port status.
//
for(i32Idx = 0; i32Idx < NUM_HUB_STATUS; i32Idx++)
{
g_psHubStatus[i32Idx].bConnected = false;
}
//
// Enable Clocking to the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, eUSBModeHost, 0);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open the Keyboard interface.
//
KeyboardOpen();
MSCOpen(ui32SysClock);
//
// Open a hub instance and provide it with the memory required to hold
// configuration descriptors for each attached device.
//
USBHHubOpen(HubCallback);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Tell the USB library the CPU clock and the PLL frequency.
//
USBOTGFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);
USBOTGFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate);
//
// Initialize the USB controller for Host mode.
//
USBHCDInit(0, g_pui8HCDPool, sizeof(g_pui8HCDPool));
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "usb-host-hub");
//
// Calculate the number of characters that will fit on a line.
// Make sure to leave a small border for the text box.
//
g_ui32CharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 16) /
GrFontMaxWidthGet(g_psFontFixed6x8);
//
// Calculate the number of lines per usable text screen. This requires
// taking off space for the top and bottom banners and adding a small bit
// for a border.
//
g_ui32LinesPerScreen = (GrContextDpyHeightGet(&g_sContext) -
(2*(DISPLAY_BANNER_HEIGHT + 1)))/
GrFontHeightGet(g_psFontFixed6x8);
//
// Initial update of the screen.
//
UpdateStatus(0);
UpdateStatus(1);
UpdateStatus(2);
UpdateStatus(3);
g_ui32CmdIdx = 0;
g_ui32CurrentLine = 0;
//
// Initialize the file system.
//
FileInit();
//
// The main loop for the application.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
WriteString("> ");
//
// Is there a command waiting to be processed?
//
while((g_ui32Flags & FLAG_CMD_READY) == 0)
{
//
// Call the YSB library to let non-interrupt code run.
//
USBHCDMain();
//
// Call the keyboard and mass storage main routines.
//
KeyboardMain();
MSCMain();
}
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
i32Status = CmdLineProcess(g_pcCmdBuf);
//
// Handle the case of bad command.
//
if(i32Status == CMDLINE_BAD_CMD)
{
WriteString("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(i32Status == CMDLINE_TOO_MANY_ARGS)
{
WriteString("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(i32Status != 0)
{
WriteString("Command returned error code\n");
WriteString((char *)StringFromFresult((FRESULT)i32Status));
WriteString("\n");
}
//
// Reset the command flag and the command index.
//
g_ui32Flags &= ~FLAG_CMD_READY;
g_ui32CmdIdx = 0;
}
}
int main2(void)
{
UINT8 IsDHCP = 0;
int32_t i32CommandStatus;
_NetCfgIpV4Args_t ipV4;
unsigned char len = sizeof(_NetCfgIpV4Args_t);
int Status = 0;
/* Stop WDT */
stopWDT();
/* Initialize the system clock of MCU */
initClk();
Board_Init(); // initialize LaunchPad I/O and PD1 LED
ConfigureUART(); // Initialize the UART.
UARTprintf("Section 11.4 IoT example, Volume 2 Real-time interfacing\n");
UARTprintf("This application is configured to measure analog signals from Ain7=PD0\n");
UARTprintf(" and send UDP packets to IP: %d.%d.%d.%d Port: %d\n\n",
SL_IPV4_BYTE(IP_ADDR,3), SL_IPV4_BYTE(IP_ADDR,2),
SL_IPV4_BYTE(IP_ADDR,1), SL_IPV4_BYTE(IP_ADDR,0),PORT_NUM);
/* Initializing the CC3100 device */
sl_Start(0, 0, 0);
/* Connecting to WLAN AP - Set with static parameters defined at the top
After this call we will be connected and have IP address */
WlanConnect();
/* Read the IP parameter */
sl_NetCfgGet(SL_IPV4_STA_P2P_CL_GET_INFO,&IsDHCP,&len,
(unsigned char *)&ipV4);
//Print the IP
UARTprintf("This node is at IP: %d.%d.%d.%d\n", SL_IPV4_BYTE(ipV4.ipV4,3), SL_IPV4_BYTE(ipV4.ipV4,2), SL_IPV4_BYTE(ipV4.ipV4,1), SL_IPV4_BYTE(ipV4.ipV4,0));
//
// Loop forever waiting for commands from PC...
//
while(1)
{
//
// Print prompt for user.
//
UARTprintf("\n>");
//
// Peek to see if a full command is ready for processing.
//
while(UARTPeek('\r') == -1)
{
//
// Approximately 1 millisecond delay.
//
ROM_SysCtlDelay(ROM_SysCtlClockGet() / 3000);
}
//
// A '\r' was detected so get the line of text from the receive buffer.
//
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. Try again.\n");
}
//
// Handle the case of too many arguments.
//
else if(i32CommandStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf(" Too many arguments for command. Try again.\n");
}
//
// Handle the case of too few arguments.
//
else if(i32CommandStatus == CMDLINE_TOO_FEW_ARGS)
{
UARTprintf(" Too few arguments for command. Try again.\n");
}
//
// Handle the case of too few arguments.
//
else if(i32CommandStatus == CMDLINE_INVALID_ARG)
{
UARTprintf(" Invalid command argument(s). Try again.\n");
}
}
}
//*****************************************************************************
//
// main loop - sets up UART1, UART 0, and the command loop to process commands
//
//*****************************************************************************
int
main(void)
{
int nStatus;
int x;
//
// 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);
//Setup UART1 on PB0 / PB1
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinConfigure(GPIO_PB0_U1RX);
GPIOPinConfigure(GPIO_PB1_U1TX);
GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioConfig(1, 9600, SysCtlClockGet());
ConfigureUART(); //UART0
//
// Enable the UART1 interrupt.
//
ROM_IntEnable(INT_UART1);
ROM_UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
//Initialize LED's
SYSCTL_RCGC2_R = SYSCTL_RCGC2_GPIOF;
x = SYSCTL_RCGC2_R; //dummy cycle
GPIO_PORTF_DIR_R |= 0x08;
GPIO_PORTF_DEN_R |= 0x08;
GPIO_PORTF_DIR_R |= 0x04;
GPIO_PORTF_DEN_R |= 0x04;
GPIO_PORTF_DIR_R |= 0x02;
GPIO_PORTF_DEN_R |= 0x02;
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Enter an infinite loop for reading and processing commands from the
// user.
//
Cmd_help(0,0);
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
UARTprintf("\n> ");
//
// Get a line of text from the user.
//
UARTgets(g_pcCmdBuf, sizeof(g_pcCmdBuf));
//
// Pass the line from the user to the command processor. It will be
// parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_pcCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error code if one was
// returned.
//
else if(nStatus != 0)
{
UARTprintf("Command returned error code\n");
}
}
}
//*****************************************************************************
//
// 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");
}
}
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
int32_t i32CommandStatus;
int i;
initUart();
UARTprintf("Welcome to the Tiva C Series TM4C123G LaunchPad!\n");
UARTprintf("Type 'help' for a list of commands to control Moto\n");
UARTprintf("> ");
InitDelay();
cSPIN_Peripherals_Init();
cSPIN_Reset_And_Standby();
/* Structure initialization by default values, in order to avoid blank records */
cSPIN_Regs_Struct_Reset(&cSPIN_RegsStruct);
//cSPIN_PWM_Enable(2000);
//cSPIN_Delay(0x00FFFFFF);
//cSPIN_PWM_DISABLE();
#if 0
/* Acceleration rate settings to cSPIN_CONF_PARAM_ACC in steps/s2, range 14.55 to 59590 steps/s2 */
cSPIN_RegsStruct.ACC = AccDec_Steps_to_Par(cSPIN_CONF_PARAM_ACC);
/* Deceleration rate settings to cSPIN_CONF_PARAM_DEC in steps/s2, range 14.55 to 59590 steps/s2 */
cSPIN_RegsStruct.DEC = AccDec_Steps_to_Par(cSPIN_CONF_PARAM_DEC);
/* Maximum speed settings to cSPIN_CONF_PARAM_MAX_SPEED in steps/s, range 15.25 to 15610 steps/s */
cSPIN_RegsStruct.MAX_SPEED = MaxSpd_Steps_to_Par(cSPIN_CONF_PARAM_MAX_SPEED);
/* Full step speed settings cSPIN_CONF_PARAM_FS_SPD in steps/s, range 7.63 to 15625 steps/s */
cSPIN_RegsStruct.FS_SPD = FSSpd_Steps_to_Par(cSPIN_CONF_PARAM_FS_SPD);
/* Minimum speed settings to cSPIN_CONF_PARAM_MIN_SPEED in steps/s, range 0 to 976.3 steps/s */
cSPIN_RegsStruct.MIN_SPEED = cSPIN_CONF_PARAM_LSPD_BIT|MinSpd_Steps_to_Par(cSPIN_CONF_PARAM_MIN_SPEED);
/* Acceleration duty cycle (torque) settings to cSPIN_CONF_PARAM_KVAL_ACC in %, range 0 to 99.6% */
cSPIN_RegsStruct.KVAL_ACC = Kval_Perc_to_Par(cSPIN_CONF_PARAM_KVAL_ACC);
/* Deceleration duty cycle (torque) settings to cSPIN_CONF_PARAM_KVAL_DEC in %, range 0 to 99.6% */
cSPIN_RegsStruct.KVAL_DEC = Kval_Perc_to_Par(cSPIN_CONF_PARAM_KVAL_DEC);
/* Run duty cycle (torque) settings to cSPIN_CONF_PARAM_KVAL_RUN in %, range 0 to 99.6% */
cSPIN_RegsStruct.KVAL_RUN = Kval_Perc_to_Par(cSPIN_CONF_PARAM_KVAL_RUN);
/* Hold duty cycle (torque) settings to cSPIN_CONF_PARAM_KVAL_HOLD in %, range 0 to 99.6% */
cSPIN_RegsStruct.KVAL_HOLD = Kval_Perc_to_Par(cSPIN_CONF_PARAM_KVAL_HOLD);
/* Thermal compensation param settings to cSPIN_CONF_PARAM_K_THERM, range 1 to 1.46875 */
cSPIN_RegsStruct.K_THERM = KTherm_to_Par(cSPIN_CONF_PARAM_K_THERM);
/* Intersect speed settings for BEMF compensation to cSPIN_CONF_PARAM_INT_SPD in steps/s, range 0 to 3906 steps/s */
cSPIN_RegsStruct.INT_SPD = IntSpd_Steps_to_Par(cSPIN_CONF_PARAM_INT_SPD);
/* BEMF start slope settings for BEMF compensation to cSPIN_CONF_PARAM_ST_SLP in % step/s, range 0 to 0.4% s/step */
cSPIN_RegsStruct.ST_SLP = BEMF_Slope_Perc_to_Par(cSPIN_CONF_PARAM_ST_SLP);
/* BEMF final acc slope settings for BEMF compensation to cSPIN_CONF_PARAM_FN_SLP_ACC in% step/s, range 0 to 0.4% s/step */
cSPIN_RegsStruct.FN_SLP_ACC = BEMF_Slope_Perc_to_Par(cSPIN_CONF_PARAM_FN_SLP_ACC);
/* BEMF final dec slope settings for BEMF compensation to cSPIN_CONF_PARAM_FN_SLP_DEC in% step/s, range 0 to 0.4% s/step */
cSPIN_RegsStruct.FN_SLP_DEC = BEMF_Slope_Perc_to_Par(cSPIN_CONF_PARAM_FN_SLP_DEC);
/* Stall threshold settings to cSPIN_CONF_PARAM_STALL_TH in mV, range 31.25 to 1000mV */
cSPIN_RegsStruct.STALL_TH = StallTh_to_Par(cSPIN_CONF_PARAM_STALL_TH);
/* Set Config register according to config parameters */
/* clock setting, switch hard stop interrupt mode, */
/* supply voltage compensation, overcurrent shutdown */
/* UVLO threshold, VCC reg output voltage , PWM frequency */
cSPIN_RegsStruct.CONFIG = (uint16_t)cSPIN_CONF_PARAM_CLOCK_SETTING | \
(uint16_t)cSPIN_CONF_PARAM_SW_MODE | \
(uint16_t)cSPIN_CONF_PARAM_VS_COMP | \
(uint16_t)cSPIN_CONF_PARAM_OC_SD | \
(uint16_t)cSPIN_CONF_PARAM_UVLOVAL | \
(uint16_t)cSPIN_CONF_PARAM_VCCVAL | \
(uint16_t)cSPIN_CONF_PARAM_PWM_DIV | \
(uint16_t)cSPIN_CONF_PARAM_PWM_MUL;
/* Overcurrent threshold settings to cSPIN_CONF_PARAM_OCD_TH, range 31.25 to 1000mV */
cSPIN_RegsStruct.OCD_TH = cSPIN_CONF_PARAM_OCD_TH;
/* Alarm settings to cSPIN_CONF_PARAM_ALARM_EN */
cSPIN_RegsStruct.ALARM_EN = cSPIN_CONF_PARAM_ALARM_EN;
/* Step mode and sycn mode settings via cSPIN_CONF_PARAM_SYNC_MODE and cSPIN_CONF_PARAM_STEP_MODE */
cSPIN_RegsStruct.STEP_MODE = (uint8_t)cSPIN_CONF_PARAM_SYNC_MODE | \
(uint8_t)cSPIN_CONF_PARAM_STEP_MODE;
/* Sink/source current, duration of constant current phases, duration of overboost phase settings */
cSPIN_RegsStruct.GATECFG1 = (uint16_t)cSPIN_CONF_PARAM_IGATE | \
(uint16_t)cSPIN_CONF_PARAM_TCC | \
(uint16_t)cSPIN_CONF_PARAM_TBOOST;
/* Blank time, Dead time stiings */
cSPIN_RegsStruct.GATECFG2 = (uint16_t)cSPIN_CONF_PARAM_TBLANK | \
(uint16_t)cSPIN_CONF_PARAM_TDT;
/* Program all cSPIN registers */
cSPIN_Registers_Set(&cSPIN_RegsStruct);
#if defined(DEBUG)
/* check the values of all cSPIN registers */
cSPIN_rx_data = cSPIN_Registers_Check(&cSPIN_RegsStruct);
/* get the values of all cSPIN registers and print them to the terminal I/O */
cSPIN_Registers_Get(&cSPIN_RegsStruct);
#endif /* defined(DEBUG) */
#else
/**********************************************************************/
/* Start example of DAISY CHAINING */
/**********************************************************************/
/* Structure initialization by default values, in order to avoid blank records */
for (i=0;i<number_of_slaves;i++)
{
cSPIN_Regs_Struct_Reset(&cSPIN_RegsStructArray[i]);
}
/* Setting of parameters for ALL DEVICES */
for (i=0;i<number_of_slaves;i++)
{
cSPIN_RegsStructArray[i].ACC = AccDec_Steps_to_Par(ACC[i]);
cSPIN_RegsStructArray[i].DEC = AccDec_Steps_to_Par(DEC[i]);
cSPIN_RegsStructArray[i].MAX_SPEED = MaxSpd_Steps_to_Par(MAX_SPEED[i]);
cSPIN_RegsStructArray[i].FS_SPD = FSSpd_Steps_to_Par(FS_SPD[i]);
cSPIN_RegsStructArray[i].MIN_SPEED = LSPD_BIT[i]|MinSpd_Steps_to_Par(MIN_SPEED[i]);
cSPIN_RegsStructArray[i].KVAL_ACC = Kval_Perc_to_Par(KVAL_ACC[i]);
cSPIN_RegsStructArray[i].KVAL_DEC = Kval_Perc_to_Par(KVAL_DEC[i]);
cSPIN_RegsStructArray[i].KVAL_RUN = Kval_Perc_to_Par(KVAL_RUN[i]);
cSPIN_RegsStructArray[i].KVAL_HOLD = Kval_Perc_to_Par(KVAL_HOLD[i]);
cSPIN_RegsStructArray[i].K_THERM = KTherm_to_Par(K_THERM[i]);
cSPIN_RegsStructArray[i].INT_SPD = IntSpd_Steps_to_Par(INT_SPD[i]);
cSPIN_RegsStructArray[i].ST_SLP = BEMF_Slope_Perc_to_Par(ST_SLP[i]);
cSPIN_RegsStructArray[i].FN_SLP_ACC = BEMF_Slope_Perc_to_Par(FN_SLP_ACC[i]);
cSPIN_RegsStructArray[i].FN_SLP_DEC = BEMF_Slope_Perc_to_Par(FN_SLP_DEC[i]);
cSPIN_RegsStructArray[i].STALL_TH = StallTh_to_Par(STALL_TH[i]);
cSPIN_RegsStructArray[i].CONFIG = (uint16_t)CONFIG_CLOCK_SETTING[i] |
(uint16_t)CONFIG_SW_MODE[i] | \
(uint16_t)CONFIG_VS_COMP[i] | \
(uint16_t)CONFIG_OC_SD[i] | \
(uint16_t)CONFIG_UVLOVAL[i] | \
(uint16_t)CONFIG_VCCVAL[i] | \
(uint16_t)CONFIG_PWM_DIV[i] | \
(uint16_t)CONFIG_PWM_MUL[i];
cSPIN_RegsStructArray[i].OCD_TH = OCD_TH[i];
cSPIN_RegsStructArray[i].ALARM_EN = ALARM_EN[i];
cSPIN_RegsStructArray[i].STEP_MODE = (uint8_t)SYNC_MODE[i] | (uint8_t)STEP_MODE[i];
cSPIN_RegsStructArray[i].GATECFG1 = (uint16_t)GATECFG1_WD_EN[i] | \
(uint16_t)GATECFG1_TBOOST[i] | \
(uint16_t)GATECFG1_IGATE[i] | \
(uint16_t)GATECFG1_TCC[i];
cSPIN_RegsStructArray[i].GATECFG2 = (uint16_t)GATECFG2_TBLANK[i] | \
(uint16_t)GATECFG2_TDT[i];
}
/* Program all cSPIN registers of All Devices */
cSPIN_All_Slaves_Registers_Set(number_of_slaves, &cSPIN_RegsStructArray[0]);
/* Get status of all devices, clear FLAG pin */
cSPIN_All_Slaves_Get_Status(number_of_slaves, responseArray);
#endif
//
// Loop forever echoing data through the UART.
//
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");
}
}
}
//*****************************************************************************
//
// Read a command line from the user and process it.
//
//*****************************************************************************
void
CommandReadAndProcess(void)
{
int iCount;
//
// Check to see if there is a string available in the UART receive
// buffer.
//
iCount = UARTPeek('\r');
//
// A negative return code indicates that there is no '\r' character in
// the receive buffer and, hence, no complete string entered by the user
// so just return.
//
if(iCount < 0)
{
return;
}
//
// Here, we know that a string is available so read it.
//
iCount = UARTgets(g_pcCmdLine, COMMAND_BUFFER_LEN);
//
// If something sensible was entered, go ahead and process the command
// line.
//
if(iCount)
{
//
// Process the command entered by the user
//
iCount = CmdLineProcess(g_pcCmdLine);
switch(iCount)
{
//
// The command was not recognized
//
case CMDLINE_BAD_CMD:
{
UARTprintf("ERROR: Unrecognized command\n");
break;
}
//
// The command contained too many arguments for the command
// line processor to handle.
//
case CMDLINE_TOO_MANY_ARGS:
{
UARTprintf("ERROR: Too many arguments\n");
break;
}
}
//
// Display a prompt
//
UARTprintf(">");
}
}
//*****************************************************************************
//
// Main application entry function.
//
//*****************************************************************************
int main(void)
{
int nStatus;
//
// Set the system clock to run at 50MHz from the PLL
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the default pinout (and query any daughter board that may be
// there already. This has the side-effect of initializing the I2C
// controller for us too.
//
PinoutSet();
//
// Enable UART0.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Initialize the UART standard I/O.
//
UARTStdioInit(0);
UARTprintf("\n\nDaughter Board ID EEPROM Read/Write\n");
UARTprintf( "-----------------------------------\n\n");
UARTprintf("Use this tool to read or repair the information stored\n");
UARTprintf("in the 128 byte ID EEPROM on optional development kit\n");
UARTprintf("daughter boards.\n");
//
// Output our help screen.
//
Cmd_help(0, 0);
//
// Tell the user which daughter board we have detected.
//
UARTprintf("\nCurrent daughter board: ");
switch(g_eDaughterType)
{
case DAUGHTER_NONE:
{
UARTprintf("None or SDRAM\n");
break;
}
case DAUGHTER_SRAM_FLASH:
case DAUGHTER_FPGA:
case DAUGHTER_EM2:
{
UARTprintf(g_pcIDNames[g_eDaughterType - 1]);
break;
}
default:
{
UARTprintf("Unrecognized\n");
break;
}
}
//
//
// Fall into the command line processing loop.
//
while (1)
{
//
// Print a prompt to the console
//
UARTprintf("\n> ");
//
// Get a line of text from the user.
//
UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_cCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
}
}