//***************************************************************************** // // Main application entry function. // //***************************************************************************** int main(void) { tBoolean bRetcode; // // 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); // // NB: We don't call PinoutSet() in this testcase since the EM header // expansion board doesn't currently have an I2C ID EEPROM. If we did // call PinoutSet() this would configure all the EPI pins for SDRAM and // we don't want to do this. // g_eDaughterType = DAUGHTER_NONE; // // Enable peripherals required to drive the LCD. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); // // Configure SysTick for a 10Hz interrupt. // ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND); ROM_SysTickEnable(); ROM_SysTickIntEnable(); // // Initialize the display driver. // Kitronix320x240x16_SSD2119Init(); // // Initialize the touch screen driver. // TouchScreenInit(); // // Set the touch screen event handler. // TouchScreenCallbackSet(WidgetPointerMessage); // // Add the compile-time defined widgets to the widget tree. // WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sHeading); // // Initialize the status string. // UpdateStatus(true, "Joining network..."); // // Paint the widget tree to make sure they all appear on the display. // WidgetPaint(WIDGET_ROOT); // // Initialize the SimpliciTI BSP. // BSP_Init(); // // Set the SimpliciTI device address using the current Ethernet MAC address // to ensure something like uniqueness. // bRetcode = SetSimpliciTIAddress(); // // Did we have a problem with the address? // if(!bRetcode) { // // Yes - make sure the display is updated then hang the app. // WidgetMessageQueueProcess(); while(1) { // // MAC address is not set so hang the app. // } } // // Turn both "LEDs" off. // SetLED(1, false); SetLED(2, false); // // Keep trying to join (a side effect of successful initialization) until // successful. Toggle LEDS to indicate that joining has not occurred. // while(SMPL_SUCCESS != SMPL_Init(0)) { ToggleLED(1); ToggleLED(2); SPIN_ABOUT_A_SECOND; } // // We have joined the network so turn on both "LEDs" to indicate this. // SetLED(1, true); SetLED(2, true); UpdateStatus(true, "Joined network"); // // Link to the access point which is now listening for us and continue // processing. This function does not return. // LinkTo(); }
//***************************************************************************** // // A simple demonstration of the features of the Stellaris Graphics Library. // //***************************************************************************** int main(void) { tContext sContext; tRectangle sRect; // // If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is // a workaround to allow the PLL to operate reliably. // if(REVISION_IS_A2) { SysCtlLDOSet(SYSCTL_LDO_2_75V); } // // Set the clocking to run from the PLL. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the display driver. // Kitronix320x240x16_SSD2119Init(); // // Turn on the backlight. // Kitronix320x240x16_SSD2119BacklightOn(255); // // Set graphics library text rendering defaults. // GrLibInit(&GRLIB_INIT_STRUCT); // // Set the string table and the default language. // GrStringTableSet(STRING_TABLE); // // Set the default language. // ChangeLanguage(GrLangEnUS); // // Initialize the graphics context. // GrContextInit(&sContext, &g_sKitronix320x240x16_SSD2119); // // Fill the top 26 rows of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&sContext) - 1; sRect.sYMax = 25; GrContextForegroundSet(&sContext, ClrDarkBlue); GrRectFill(&sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&sContext, ClrWhite); GrRectDraw(&sContext, &sRect); // // Load the static strings from the string table. These strings are // independent of the language in use but we store them in the string // table nonetheless since (a) we may be using codepage remapping in // which case it would be difficult to hardcode them into the app source // anyway (ASCII or ISO8859-1 text would not render properly with the // remapped custom font) and (b) even if we're not using codepage remapping, // we may have generated a custom font from the string table output and // we want to make sure that all glyphs required by the application are // present in that font. If we hardcode some text in the application // source and don't put it in the string table, we run the risk of having // characters missing in the font. // GrStringGet(STR_ENGLISH, g_pcEnglish, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_DEUTSCH, g_pcDeutsch, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_ESPANOL, g_pcEspanol, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_ITALIANO, g_pcItaliano, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_CHINESE, g_pcChinese, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_KOREAN, g_pcKorean, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_JAPANESE, g_pcJapanese, MAX_LANGUAGE_NAME_LEN); GrStringGet(STR_PLUS, g_pcPlus, 2); GrStringGet(STR_MINUS, g_pcMinus, 2); // // Put the application name in the middle of the banner. // GrStringGet(STR_APPNAME, g_pcBuffer, SCOMP_MAX_STRLEN); GrContextFontSet(&sContext, FONT_20PT); GrStringDrawCentered(&sContext, g_pcBuffer, -1, GrContextDpyWidthGet(&sContext) / 2, 10, 0); // // Initialize the sound driver. // SoundInit(); // // Initialize the touch screen driver and have it route its messages to the // widget tree. // TouchScreenInit(); TouchScreenCallbackSet(WidgetPointerMessage); // // Add the title block and the previous and next buttons to the widget // tree. // WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sPrevious); WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sTitle); WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sNext); // // Add the first panel to the widget tree. // g_ulPanel = 0; WidgetAdd(WIDGET_ROOT, (tWidget *)g_psPanels); // // Set the string for the title. // CanvasTextSet(&g_sTitle, g_pcTitle); // // Initialize the pointer to the button text. // PushButtonTextSet(&g_sFirmwareUpdateBtn, g_pcUpdateButton); // // Issue the initial paint request to the widgets. // WidgetPaint(WIDGET_ROOT); // // Loop forever unless we receive a signal that a firmware update has been // requested. // while(!g_bFirmwareUpdate) { // // Process any messages in the widget message queue. // WidgetMessageQueueProcess(); } // // If we drop out, a firmware update request has been made. We call // WidgetMessageQueueProcess once more to ensure that any final messages // are processed then jump into the bootloader. // WidgetMessageQueueProcess(); // // Wait a while for the last keyboard click sound to finish. This is about // 500mS since the delay loop is 3 cycles long. // SysCtlDelay(SysCtlClockGet() / 6); // // Pass control to the bootloader. // JumpToBootLoader(); // // The boot loader should take control, so this should never be reached. // Just in case, loop forever. // while(1) { } }
//***************************************************************************** // // Handles presses of the next panel button. // //***************************************************************************** void OnNext(tWidget *pWidget) { // // There is nothing to be done if the last panel is already being // displayed. // if(g_ulPanel == (NUM_PANELS - 1)) { return; } // // Remove the current panel. // WidgetRemove((tWidget *)(g_psPanels + g_ulPanel)); // // Increment the panel index. // g_ulPanel++; // // Add and draw the new panel. // WidgetAdd(WIDGET_ROOT, (tWidget *)(g_psPanels + g_ulPanel)); WidgetPaint((tWidget *)(g_psPanels + g_ulPanel)); // // Set the title of this panel. // GrStringGet(g_ulPanelNames[g_ulPanel], g_pcTitle, TITLE_MAX_SIZE); WidgetPaint((tWidget *)&g_sTitle); // // See if the previous panel was the first panel. // if(g_ulPanel == 1) { // // Display the previous button. // PushButtonImageOn(&g_sPrevious); PushButtonTextOn(&g_sPrevious); PushButtonFillOff(&g_sPrevious); WidgetPaint((tWidget *)&g_sPrevious); } // // See if this is the last panel. // if(g_ulPanel == (NUM_PANELS - 1)) { // // Clear the next button from the display since the last panel is being // displayed. // PushButtonImageOff(&g_sNext); PushButtonTextOff(&g_sNext); PushButtonFillOn(&g_sNext); WidgetPaint((tWidget *)&g_sNext); } // // Play the key click sound. // SoundPlay(g_pusKeyClick, sizeof(g_pusKeyClick) / 2); }
//***************************************************************************** // // Displays the "Position Control Mode" panel. The returned valud is the ID of // the panel to be displayed instead of the "Position Control Mode" panel. // //***************************************************************************** unsigned long DisplayPosition(void) { unsigned long ulPos, ulIdx, ulDelay, ulDemo, ulTime, ulStep; // // Read the current position mode configuration. // PositionConfigRead(); // // Enable position control mode. // CANPositionModeEnable(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100)); // // Initially, updates to the position occur immediately. // ulDelay = 0; // // Initially, demo mode is disabled. // ulDemo = 0; ulTime = 0; ulStep = 0; // // Disable the widget fill for all the widgets except the one for the // device ID selection. // for(ulIdx = 0; ulIdx < 7; ulIdx++) { CanvasFillOff(g_psPositionWidgets + ulIdx); } CanvasFillOn(g_psPositionWidgets + 1); // // Add the "Position Control Mode" panel widgets to the widget list. // for(ulIdx = 0; ulIdx < NUM_WIDGETS; ulIdx++) { WidgetAdd(WIDGET_ROOT, (tWidget *)(g_psPositionWidgets + ulIdx)); } // // Enable the status display. // StatusEnable(0); // // Set the default cursor position to the device ID selection. // ulPos = 1; // // Loop forever. This loop will be explicitly exited when the proper // condition is detected. // while(1) { // // Print out the current device ID. // usnprintf(g_pcIDBuffer, sizeof(g_pcIDBuffer), "%d", g_ulCurrentID); // // Print out the current position. // if(g_sPositionConfig.lPosition < 0) { usnprintf(g_pcPositionBuffer, sizeof(g_pcPositionBuffer), "-%d.%02d", (0 - g_sPositionConfig.lPosition) / 100, (0 - g_sPositionConfig.lPosition) % 100); } else { usnprintf(g_pcPositionBuffer, sizeof(g_pcPositionBuffer), "%d.%02d", g_sPositionConfig.lPosition / 100, g_sPositionConfig.lPosition % 100); } // // Print out the current P coefficient. // if(g_sPositionConfig.lP < 0) { usnprintf(g_pcPositionPBuffer, sizeof(g_pcPositionPBuffer), "-%d.%03d", (0 - g_sPositionConfig.lP) / 1000, (0 - g_sPositionConfig.lP) % 1000); } else { usnprintf(g_pcPositionPBuffer, sizeof(g_pcPositionPBuffer), "%d.%03d", g_sPositionConfig.lP / 1000, g_sPositionConfig.lP % 1000); } // // Irint out the current I coefficient. // if(g_sPositionConfig.lI < 0) { usnprintf(g_pcPositionIBuffer, sizeof(g_pcPositionIBuffer), "-%d.%03d", (0 - g_sPositionConfig.lI) / 1000, (0 - g_sPositionConfig.lI) % 1000); } else { usnprintf(g_pcPositionIBuffer, sizeof(g_pcPositionIBuffer), "%d.%03d", g_sPositionConfig.lI / 1000, g_sPositionConfig.lI % 1000); } // // Print out the current D coefficient. // if(g_sPositionConfig.lD < 0) { usnprintf(g_pcPositionDBuffer, sizeof(g_pcPositionDBuffer), "-%d.%03d", (0 - g_sPositionConfig.lD) / 1000, (0 - g_sPositionConfig.lD) % 1000); } else { usnprintf(g_pcPositionDBuffer, sizeof(g_pcPositionDBuffer), "%d.%03d", g_sPositionConfig.lD / 1000, g_sPositionConfig.lD % 1000); } // // Print out the current position reference source. // usnprintf(g_pcReferenceBuffer, sizeof(g_pcReferenceBuffer), "%s", g_ppcPosReference[g_sPositionConfig.ulPosRef]); // // Update the status display. // StatusUpdate(); // // Update the display. // DisplayFlush(); // // See if a serial download has begun. // if(HWREGBITW(&g_ulFlags, FLAG_SERIAL_BOOTLOADER) == 1) { // // Disable the status display. // StatusDisable(); // // Remove the "Position Control Mode" panel widgets. // for(ulIdx = 0; ulIdx < NUM_WIDGETS; ulIdx++) { WidgetRemove((tWidget *)(g_psPositionWidgets + ulIdx)); } CanvasTextColorSet(g_psPositionWidgets + 2, ClrWhite); // // Disable position control mode. // CANPositionModeDisable(); // // Return the ID of the update panel. // return(PANEL_UPDATE); } // // See if demo mode is enabled. // if(ulDemo != 0) { // // See if the current time delay has expired. // if(ulTime < g_ulTickCount) { // // Increment to the next step, wrapping back to the beginning // of the sequence when the end has been reached. // ulStep++; if(ulStep == (sizeof(g_plPositionDemo) / sizeof(g_plPositionDemo[0]))) { ulStep = 0; } // // Set the position as directed by the next step. // g_sPositionConfig.lPosition = g_plPositionDemo[ulStep][0]; CANPositionSet(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100), 0); // // Set the time delay for this step. // ulTime = g_ulTickCount + g_plPositionDemo[ulStep][1]; } } // // See if the up button was pressed. // if(HWREGBITW(&g_ulFlags, FLAG_UP_PRESSED) == 1) { // // Only move the cursor if it is not already at the top of the // screen and a delayed position update is not in progress. // if((ulPos != 0) && (ulDelay == 0)) { // // Disable the widget fill for the currently selected widget. // CanvasFillOff(g_psPositionWidgets + ulPos); // // Decrement the cursor row, skipping the position row when // demo mode is enabled. // ulPos--; if((ulPos == 2) && (ulDemo != 0)) { ulPos--; } // // Enable the widget fill for the newly selected widget. // CanvasFillOn(g_psPositionWidgets + ulPos); } // // Clear the press flag for the up button. // HWREGBITW(&g_ulFlags, FLAG_UP_PRESSED) = 0; } // // See if the down button was pressed. // if(HWREGBITW(&g_ulFlags, FLAG_DOWN_PRESSED) == 1) { // // Only move the cursor if it is not already at the bottom of the // screen and a delayed position update is not in progress. // if((ulPos != 6) && (ulDelay == 0)) { // // Disable the widget fill for the currently selected widget. // CanvasFillOff(g_psPositionWidgets + ulPos); // // Increment the cursor row, skipping the position row when // demo mode is enabled. // ulPos++; if((ulPos == 2) && (ulDemo != 0)) { ulPos++; } // // Enable the widget fill for the newly selected widget. // CanvasFillOn(g_psPositionWidgets + ulPos); } // // Clear the press flag for the down button. // HWREGBITW(&g_ulFlags, FLAG_DOWN_PRESSED) = 0; } // // See if the left button was pressed. // if(HWREGBITW(&g_ulFlags, FLAG_LEFT_PRESSED) == 1) { // // See if the device ID is being changed. // if(ulPos == 1) { // // Only change the device ID if it is greater than one. // if(g_ulCurrentID > 1) { // // Exit demo mode. // ulDemo = 0; CanvasTextColorSet(g_psPositionWidgets + 2, ClrWhite); // // Disable position control mode for the current device ID. // CANPositionModeDisable(); // // Decrement the device ID. // if((HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL1) == 1) || (HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL2) == 1) || (HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL3) == 1)) { if(g_ulCurrentID > 3) { CANSetID(g_ulCurrentID - 3); } else { CANSetID(1); } } else { CANSetID(g_ulCurrentID - 1); } // // Read the configuration of the new device. // PositionConfigRead(); // // Enable position control mode. // CANPositionModeEnable(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100)); } } // // See if the position is being changed. // else if(ulPos == 2) { // // Only change the position if it is not already fully // negative. // if(g_sPositionConfig.lPosition > -20000) { // // Decrement the position. // if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL1) == 1) { g_sPositionConfig.lPosition -= 11; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL2) == 1) { g_sPositionConfig.lPosition -= 111; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL3) == 1) { g_sPositionConfig.lPosition -= 1111; } else { g_sPositionConfig.lPosition--; } if(g_sPositionConfig.lPosition < -20000) { g_sPositionConfig.lPosition = -20000; } // // Send the updated position to the motor controller if a // delayed update is not in progress. // if(ulDelay == 0) { CANPositionSet(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100), 0); } } } // // See if the position P gain is being changed. // else if(ulPos == 3) { // // Only change the P gain if it is not already fully negative. // if(g_sPositionConfig.lP > (-32767 * 1000)) { // // Decrement the P gain. // if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL1) == 1) { g_sPositionConfig.lP -= 11; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL2) == 1) { g_sPositionConfig.lP -= 111; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL3) == 1) { g_sPositionConfig.lP -= 1111; } else { g_sPositionConfig.lP--; } if(g_sPositionConfig.lP < (-32767 * 1000)) { g_sPositionConfig.lP = -32767 * 1000; } // // Send the new P gain to the motor controller. // CANPositionPGainSet(((g_sPositionConfig.lP / 1000) * 65536) + (((g_sPositionConfig.lP % 1000) * 65536) / 1000)); } } // // See if the position I gain is being changed. // else if(ulPos == 4) { // // Only change the I gain if it is not already fully negative. // if(g_sPositionConfig.lI > (-32767 * 1000)) { // // Decrement the I gain. // if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL1) == 1) { g_sPositionConfig.lI -= 11; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL2) == 1) { g_sPositionConfig.lI -= 111; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL3) == 1) { g_sPositionConfig.lI -= 1111; } else { g_sPositionConfig.lI--; } if(g_sPositionConfig.lI < (-32767 * 1000)) { g_sPositionConfig.lI = -32767 * 1000; } // // Send the new I gain to the motor controller. // CANPositionIGainSet(((g_sPositionConfig.lI / 1000) * 65536) + (((g_sPositionConfig.lI % 1000) * 65536) / 1000)); } } // // See if the position D gain is being changed. // else if(ulPos == 5) { // // Only change the D gain if it is not already fully negative. // if(g_sPositionConfig.lD > (-32767 * 1000)) { // // Decrement the D gain. // if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL1) == 1) { g_sPositionConfig.lD -= 11; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL2) == 1) { g_sPositionConfig.lD -= 111; } else if(HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL3) == 1) { g_sPositionConfig.lD -= 1111; } else { g_sPositionConfig.lD--; } if(g_sPositionConfig.lD < (-32767 * 1000)) { g_sPositionConfig.lD = -32767 * 1000; } // // Send the new D gain to the motor controller. // CANPositionDGainSet(((g_sPositionConfig.lD / 1000) * 65536) + (((g_sPositionConfig.lD % 1000) * 65536) / 1000)); } } // // See if the position reference source is being changed. // else if(ulPos == 6) { // // Toggle to the other position reference source. // g_sPositionConfig.ulPosRef ^= 1; // // Send the position reference source to the motor controller. // CANPositionRefSet(g_sPositionConfig.ulPosRef); } // // Clear the press flag for the left button. // HWREGBITW(&g_ulFlags, FLAG_LEFT_PRESSED) = 0; HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL1) = 0; HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL2) = 0; HWREGBITW(&g_ulFlags, FLAG_LEFT_ACCEL3) = 0; } // // See if the right button was pressed. // if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_PRESSED) == 1) { // // See if the device ID is being changed. // if(ulPos == 1) { // // Only change the device ID if it is less than 63. // if(g_ulCurrentID < 63) { // // Exit demo mode. // ulDemo = 0; CanvasTextColorSet(g_psPositionWidgets + 2, ClrWhite); // // Disable position control mode for the current device ID. // CANPositionModeDisable(); // // Increment the device ID. // if((HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL1) == 1) || (HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL2) == 1) || (HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL3) == 1)) { if(g_ulCurrentID < 60) { CANSetID(g_ulCurrentID + 3); } else { CANSetID(63); } } else { CANSetID(g_ulCurrentID + 1); } // // Read the configuration of the new device. // PositionConfigRead(); // // Enable position control mode. // CANPositionModeEnable(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100)); } } // // See if the position is being changed. // else if(ulPos == 2) { // // Only change the position if it is not already fully // positive. // if(g_sPositionConfig.lPosition < 20000) { // // Increment the position. // if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL1) == 1) { g_sPositionConfig.lPosition += 11; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL2) == 1) { g_sPositionConfig.lPosition += 111; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL3) == 1) { g_sPositionConfig.lPosition += 1111; } else { g_sPositionConfig.lPosition++; } if(g_sPositionConfig.lPosition > 20000) { g_sPositionConfig.lPosition = 20000; } // // Send the updated position to the motor controller if a // delayed update is not in progress. // if(ulDelay == 0) { CANPositionSet(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100), 0); } } } // // See if the position P gain is being changed. // else if(ulPos == 3) { // // Only change the P gain if it is not already fully positive. // if(g_sPositionConfig.lP < (32767 * 1000)) { // // Increment the P gain. // if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL1) == 1) { g_sPositionConfig.lP += 11; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL2) == 1) { g_sPositionConfig.lP += 111; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL3) == 1) { g_sPositionConfig.lP += 1111; } else { g_sPositionConfig.lP++; } if(g_sPositionConfig.lP > (32767 * 1000)) { g_sPositionConfig.lP = 32767 * 1000; } // // Send the new P gain to the motor controller. // CANPositionPGainSet(((g_sPositionConfig.lP / 1000) * 65536) + (((g_sPositionConfig.lP % 1000) * 65536) / 1000)); } } // // See if the position I gain is being changed. // else if(ulPos == 4) { // // Only change the I gain if it is not already fully positive. // if(g_sPositionConfig.lI < (32767 * 1000)) { // // Increment the I gain. // if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL1) == 1) { g_sPositionConfig.lI += 11; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL2) == 1) { g_sPositionConfig.lI += 111; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL3) == 1) { g_sPositionConfig.lI += 1111; } else { g_sPositionConfig.lI++; } if(g_sPositionConfig.lI > (32767 * 1000)) { g_sPositionConfig.lI = 32767 * 1000; } // // Send the new I gain to the motor controller. // CANPositionIGainSet(((g_sPositionConfig.lI / 1000) * 65536) + (((g_sPositionConfig.lI % 1000) * 65536) / 1000)); } } // // See if the position D gain is being changed. // else if(ulPos == 5) { // // Only change the D gain if it is not already fully positive. // if(g_sPositionConfig.lD < (32767 * 1000)) { // // Increment the D gain. // if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL1) == 1) { g_sPositionConfig.lD += 11; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL2) == 1) { g_sPositionConfig.lD += 111; } else if(HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL3) == 1) { g_sPositionConfig.lD += 1111; } else { g_sPositionConfig.lD++; } if(g_sPositionConfig.lD > (32767 * 1000)) { g_sPositionConfig.lD = 32767 * 1000; } // // Send the new D gain to the motor controller. // CANPositionDGainSet(((g_sPositionConfig.lD / 1000) * 65536) + (((g_sPositionConfig.lD % 1000) * 65536) / 1000)); } } // // See if the position reference source is being changed. // else if(ulPos == 6) { // // Toggle to the other position reference source. // g_sPositionConfig.ulPosRef ^= 1; // // Send the position reference source to the motor controller. // CANPositionRefSet(g_sPositionConfig.ulPosRef); } // // Clear the press flag for the right button. // HWREGBITW(&g_ulFlags, FLAG_RIGHT_PRESSED) = 0; HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL1) = 0; HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL2) = 0; HWREGBITW(&g_ulFlags, FLAG_RIGHT_ACCEL3) = 0; } // // See if the select button was pressed. // if(HWREGBITW(&g_ulFlags, FLAG_SELECT_PRESSED) == 1) { // // Clear the press flag for the select button. // HWREGBITW(&g_ulFlags, FLAG_SELECT_PRESSED) = 0; // // See if the cursor is on the top row of the screen. // if(ulPos == 0) { // // Display the menu. // ulIdx = DisplayMenu(PANEL_POSITION); // // See if another panel was selected. // if(ulIdx != PANEL_POSITION) { // // Disable the status display. // StatusDisable(); // // Remove the "Position Control Mode" panel widgets. // for(ulPos = 0; ulPos < NUM_WIDGETS; ulPos++) { WidgetRemove((tWidget *)(g_psPositionWidgets + ulPos)); } CanvasTextColorSet(g_psPositionWidgets + 2, ClrWhite); // // Disable position control mode. // CANPositionModeDisable(); // // Return the ID of the newly selected panel. // return(ulIdx); } // // Since the "Position Control Mode" panel was selected from // the menu, move the cursor down one row. // CanvasFillOff(g_psPositionWidgets); ulPos++; CanvasFillOn(g_psPositionWidgets + 1); } // // See if the cursor is on the ID selection. // else if(ulPos == 1) { // // Toggle demo mode. // ulDemo ^= 1; // // See if the demo has just been disabled. // if(ulDemo == 0) { // // Set the output position to the current position. // if(g_lStatusPosition < 0) { g_sPositionConfig.lPosition = (((g_lStatusPosition / 65536) * 100) + ((((g_lStatusPosition % 65536) * 100) - 32768) / 65536)); } else { g_sPositionConfig.lPosition = (((g_lStatusPosition / 65536) * 100) + ((((g_lStatusPosition % 65536) * 100) + 32768) / 65536)); } CANPositionSet(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100), 0); // // Indicate that demo mode has exited by setting the text // color to white. // CanvasTextColorSet(g_psPositionWidgets + 2, ClrWhite); } // // Otherwise start demo mode. // else { // // Indicate that demo mode is active by setting the text // color to gray. // CanvasTextColorSet(g_psPositionWidgets + 2, ClrSelected); // // Start with the first step. // ulStep = 0; // // Set the position as directed by the first step. // g_sPositionConfig.lPosition = g_plPositionDemo[0][0]; CANPositionSet(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100), 0); // // Set the time delay for the first step. // ulTime = g_ulTickCount + g_plPositionDemo[0][1]; } } // // See if the cursor is on the position selection. // else if(ulPos == 2) { // // Toggle the state of the delayed update. // ulDelay ^= 1; // // See if a delayed update should be performed. // if(ulDelay == 0) { // // Send the delayed position update. // CANPositionSet(((g_sPositionConfig.lPosition / 100) * 65536) + (((g_sPositionConfig.lPosition % 100) * 65536) / 100), 0); // // Change the text color of the position selection to white // to indicate that updates will occur immediately. // CanvasTextColorSet(g_psPositionWidgets + 2, ClrWhite); } else { // // Change the text color of the position selection to black // to indicate that updates will be delayed. // CanvasTextColorSet(g_psPositionWidgets + 2, ClrBlack); } } } } }
//***************************************************************************** // // Initialize and operate the data logger. // //***************************************************************************** int main(void) { tContext sDisplayContext, sBufferContext; uint32_t ui32HibIntStatus, ui32SysClock, ui32LastTickCount; bool bSkipSplash; uint8_t ui8ButtonState, ui8ButtonChanged; uint_fast8_t ui8X, ui8Y; // // 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. // MAP_FPULazyStackingEnable(); // // Set the clocking to run at 50 MHz. // MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); ui32SysClock = MAP_SysCtlClockGet(); // // Initialize locals. // bSkipSplash = false; ui32LastTickCount = 0; // // Initialize the data acquisition module. This initializes the ADC // hardware. // AcquireInit(); // // Enable access to the hibernate peripheral. If the hibernate peripheral // was already running then this will have no effect. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE); // // Check to see if the hiberate module is already active and if so then // read the saved configuration state. If both are okay, then proceed // to check and see if we are logging data using sleep mode. // if(HibernateIsActive() && !GetSavedState(&g_sConfigState)) { // // Read the status of the hibernate module. // ui32HibIntStatus = HibernateIntStatus(1); // // If this is a pin wake, that means the user pressed the select // button and we should terminate the sleep logging. In this case // we will fall out of this conditional section, and go through the // normal startup below, but skipping the splash screen so the user // gets immediate response. // if(ui32HibIntStatus & HIBERNATE_INT_PIN_WAKE) { // // Clear the interrupt flag so it is not seen again until another // wake. // HibernateIntClear(HIBERNATE_INT_PIN_WAKE); bSkipSplash = true; } // // Otherwise if we are waking from hibernate and it was not a pin // wake, then it must be from RTC match. Check to see if we are // sleep logging and if so then go through an abbreviated startup // in order to collect the data and go back to sleep. // else if(g_sConfigState.ui32SleepLogging && (ui32HibIntStatus & HIBERNATE_INT_RTC_MATCH_0)) { // // Start logger and pass the configuration. The logger should // configure itself to take one sample. // AcquireStart(&g_sConfigState); g_iLoggerState = eSTATE_LOGGING; // // Enter a forever loop to run the acquisition. This will run // until a new sample has been taken and stored. // while(!AcquireRun()) { } // // Getting here means that a data acquisition was performed and we // can now go back to sleep. Save the configuration and then // activate the hibernate. // SetSavedState(&g_sConfigState); // // Set wake condition on pin-wake or RTC match. Then put the // processor in hibernation. // HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC); HibernateRequest(); // // Hibernating takes a finite amount of time to occur, so wait // here forever until hibernate activates and the processor // power is removed. // for(;;) { } } // // Otherwise, this was not a pin wake, and we were not sleep logging, // so just fall out of this conditional and go through the normal // startup below. // } else { // // In this case, either the hibernate module was not already active, or // the saved configuration was not valid. Initialize the configuration // to the default state and then go through the normal startup below. // GetDefaultState(&g_sConfigState); } // // Enable the Hibernate module to run. // HibernateEnableExpClk(SysCtlClockGet()); // // The hibernate peripheral trim register must be set per silicon // erratum 2.1 // HibernateRTCTrimSet(0x7FFF); // // Start the RTC running. If it was already running then this will have // no effect. // HibernateRTCEnable(); // // In case we were sleep logging and are now finished (due to user // pressing select button), then disable sleep logging so it doesnt // try to start up again. // g_sConfigState.ui32SleepLogging = 0; SetSavedState(&g_sConfigState); // // Initialize the display driver. // CFAL96x64x16Init(); // // Initialize the buttons driver. // ButtonsInit(); // // Pass the restored state to the menu system. // MenuSetState(&g_sConfigState); // // Enable the USB peripheral // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); // // Configure the required pins for USB operation. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); MAP_GPIOPinConfigure(GPIO_PG4_USB0EPEN); MAP_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); MAP_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); MAP_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Erratum workaround for silicon revision A1. VBUS must have pull-down. // if(CLASS_IS_TM4C123 && REVISION_IS_A1) { HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1; } // // Initialize the USB stack mode and pass in a mode callback. // USBStackModeSet(0, eUSBModeOTG, ModeCallback); // // Initialize the stack to be used with USB stick. // USBStickInit(); // // Initialize the stack to be used as a serial device. // USBSerialInit(); // // Initialize the USB controller for dual mode operation with a 2ms polling // rate. // USBOTGModeInit(0, 2000, g_pui8HCDPool, HCD_MEMORY_SIZE); // // Initialize the menus module. This module will control the user // interface menuing system. // MenuInit(WidgetActivated); // // Configure SysTick to periodically interrupt. // g_ui32TickCount = 0; MAP_SysTickPeriodSet(ui32SysClock / CLOCK_RATE); MAP_SysTickIntEnable(); MAP_SysTickEnable(); // // Initialize the display context and another context that is used // as an offscreen drawing buffer for display animation effect // GrContextInit(&sDisplayContext, &g_sCFAL96x64x16); GrContextInit(&sBufferContext, &g_sOffscreenDisplayA); // // Show the splash screen if we are not skipping it. The only reason to // skip it is if the application was in sleep-logging mode and the user // just waked it up with the select button. // if(!bSkipSplash) { const uint8_t *pui8SplashLogo = g_pui8Image_TI_Black; // // Draw the TI logo on the display. Use an animation effect where the // logo will "slide" onto the screen. Allow select button to break // out of animation. // for(ui8X = 0; ui8X < 96; ui8X++) { if(ButtonsPoll(0, 0) & SELECT_BUTTON) { break; } GrImageDraw(&sDisplayContext, pui8SplashLogo, 95 - ui8X, 0); } // // Leave the logo on the screen for a long duration. Monitor the // buttons so that if the user presses the select button, the logo // display is terminated and the application starts immediately. // while(g_ui32TickCount < 400) { if(ButtonsPoll(0, 0) & SELECT_BUTTON) { break; } } // // Extended splash sequence // if(ButtonsPoll(0, 0) & UP_BUTTON) { for(ui8X = 0; ui8X < 96; ui8X += 4) { GrImageDraw(&sDisplayContext, g_ppui8Image_Splash[(ui8X / 4) & 3], (int32_t)ui8X - 96L, 0); GrImageDraw(&sDisplayContext, pui8SplashLogo, ui8X, 0); MAP_SysCtlDelay(ui32SysClock / 12); } MAP_SysCtlDelay(ui32SysClock / 3); pui8SplashLogo = g_ppui8Image_Splash[4]; GrImageDraw(&sDisplayContext, pui8SplashLogo, 0, 0); MAP_SysCtlDelay(ui32SysClock / 12); } // // Draw the initial menu into the offscreen buffer. // SlideMenuDraw(&g_sMenuWidget, &sBufferContext, 0); // // Now, draw both the TI logo splash screen (from above) and the initial // menu on the screen at the same time, moving the coordinates so that // the logo "slides" off the display and the menu "slides" onto the // display. // for(ui8Y = 0; ui8Y < 64; ui8Y++) { GrImageDraw(&sDisplayContext, pui8SplashLogo, 0, -ui8Y); GrImageDraw(&sDisplayContext, g_pui8OffscreenBufA, 0, 63 - ui8Y); } } // // Add the menu widget to the widget tree and send an initial paint // request. // WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sMenuWidget); WidgetPaint(WIDGET_ROOT); // // Set the focus handle to the menu widget. Any button events will be // sent to this widget // g_ui32KeyFocusWidgetHandle = (uint32_t)&g_sMenuWidget; // // Forever loop to run the application // while(1) { // // Each time the timer tick occurs, process any button events. // if(g_ui32TickCount != ui32LastTickCount) { // // Remember last tick count // ui32LastTickCount = g_ui32TickCount; // // Read the debounced state of the buttons. // ui8ButtonState = ButtonsPoll(&ui8ButtonChanged, 0); // // Pass any button presses through to the widget message // processing mechanism. The widget that has the button event // focus (probably the menu widget) will catch these button events. // if(BUTTON_PRESSED(SELECT_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_SELECT); } if(BUTTON_PRESSED(UP_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_UP); } if(BUTTON_PRESSED(DOWN_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_DOWN); } if(BUTTON_PRESSED(LEFT_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT); } if(BUTTON_PRESSED(RIGHT_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_RIGHT); } } // // Tell the OTG library code how much time has passed in milliseconds // since the last call. // USBOTGMain(GetTickms()); // // Call functions as needed to keep the host or device mode running. // if(g_iCurrentUSBMode == eUSBModeDevice) { USBSerialRun(); } else if(g_iCurrentUSBMode == eUSBModeHost) { USBStickRun(); } // // If in the logging state, then call the logger run function. This // keeps the data acquisition running. // if((g_iLoggerState == eSTATE_LOGGING) || (g_iLoggerState == eSTATE_VIEWING)) { if(AcquireRun() && g_sConfigState.ui32SleepLogging) { // // If sleep logging is enabled, then at this point we have // stored the first data item, now save the state and start // hibernation. Wait for the power to be cut. // SetSavedState(&g_sConfigState); HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC); HibernateRequest(); for(;;) { } } // // If viewing instead of logging then request a repaint to keep // the viewing window updated. // if(g_iLoggerState == eSTATE_VIEWING) { WidgetPaint(WIDGET_ROOT); } } // // If in the saving state, then save data from flash storage to // USB stick. // if(g_iLoggerState == eSTATE_SAVING) { // // Save data from flash to USB // FlashStoreSave(); // // Return to idle state // g_iLoggerState = eSTATE_IDLE; } // // If in the erasing state, then erase the data stored in flash. // if(g_iLoggerState == eSTATE_ERASING) { // // Save data from flash to USB // FlashStoreErase(); // // Return to idle state // g_iLoggerState = eSTATE_IDLE; } // // If in the flash reporting state, then show the report of the amount // of used and free flash memory. // if(g_iLoggerState == eSTATE_FREEFLASH) { // // Report free flash space // FlashStoreReport(); // // Return to idle state // g_iLoggerState = eSTATE_IDLE; } // // If we are exiting the clock setting widget, that means that control // needs to be given back to the menu system. // if(g_iLoggerState == eSTATE_CLOCKEXIT) { // // Give the button event focus back to the menu system // g_ui32KeyFocusWidgetHandle = (uint32_t)&g_sMenuWidget; // // Send a button event to the menu widget that means the left // key was pressed. This signals the menu widget to deactivate // the current child widget (which was the clock setting wigdet). // This will cause the menu widget to slide the clock set widget // off the screen and resume control of the display. // SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT); g_iLoggerState = eSTATE_IDLE; } // // Process any new messages that are in the widget queue. This keeps // the user interface running. // WidgetMessageQueueProcess(); } }
//***************************************************************************** // // A simple demonstration of the features of the Stellaris Graphics Library. // //***************************************************************************** int main(void) { tContext sContext; tRectangle sRect; // // If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is // a workaround to allow the PLL to operate reliably. // if(REVISION_IS_A2) { SysCtlLDOSet(SYSCTL_LDO_2_75V); } // // Set the clocking to run from the PLL. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the display driver. // Kitronix320x240x16_SSD2119Init(); // // Turn on the backlight. // Kitronix320x240x16_SSD2119BacklightOn(255); // // Initialize the graphics context. // GrContextInit(&sContext, &g_sKitronix320x240x16_SSD2119); // // Fill the top 24 rows of the screen with blue to create the banner. // sRect.sXMin = 0; sRect.sYMin = 0; sRect.sXMax = GrContextDpyWidthGet(&sContext) - 1; sRect.sYMax = 23; GrContextForegroundSet(&sContext, ClrDarkBlue); GrRectFill(&sContext, &sRect); // // Put a white box around the banner. // GrContextForegroundSet(&sContext, ClrWhite); GrRectDraw(&sContext, &sRect); // // Put the application name in the middle of the banner. // GrContextFontSet(&sContext, g_pFontCm20); GrStringDrawCentered(&sContext, "grlib demo", -1, GrContextDpyWidthGet(&sContext) / 2, 11, 0); // // Initialize the sound driver. // SoundInit(); // // Initialize the touch screen driver and have it route its messages to the // widget tree. // TouchScreenInit(); TouchScreenCallbackSet(WidgetPointerMessage); // // Add the title block and the previous and next buttons to the widget // tree. // WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sPrevious); WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sTitle); WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sNext); // // Add the first panel to the widget tree. // g_ulPanel = 0; WidgetAdd(WIDGET_ROOT, (tWidget *)g_psPanels); CanvasTextSet(&g_sTitle, g_pcPanelNames[0]); // // Issue the initial paint request to the widgets. // WidgetPaint(WIDGET_ROOT); // // Loop forever unless we receive a signal that a firmware update has been // requested. // while(!g_bFirmwareUpdate) { // // Process any messages in the widget message queue. // WidgetMessageQueueProcess(); } // // If we drop out, a firmware update request has been made. We call // WidgetMessageQueueProcess once more to ensure that any final messages // are processed then jump into the bootloader. // WidgetMessageQueueProcess(); // // Wait a while for the last keyboard click sound to finish. This is about // 500mS since the delay loop is 3 cycles long. // SysCtlDelay(SysCtlClockGet() / 6); // // Pass control to the bootloader. // JumpToBootLoader(); // // The boot loader should take control, so this should never be reached. // Just in case, loop forever. // while(1) { } }