Beispiel #1
0
// Prints the instructions that the user should follow when
// testing the verifySequence state machine.
// Takes an argument that specifies the length of the sequence so that
// the instructions are tailored for the length of the sequence.
// This assumes a simple incrementing pattern so that it is simple to
// instruct the user.
void verifySequence_printInstructions(uint8_t length, bool startingOver) {
  display_fillScreen(DISPLAY_BLACK);	    // Clear the screen.
  display_setTextSize(MESSAGE_TEXT_SIZE);   // Make it readable.
  display_setCursor(MESSAGE_X, MESSAGE_Y);  // Rough center.
  if (startingOver) {	                    // Print a message if you start over.
    display_fillScreen(DISPLAY_BLACK);	    // Clear the screen if starting over.
    display_setTextColor(DISPLAY_WHITE);    // Print whit text.
    display_println("Starting Over. ");
  }
  display_println("Tap: ");
  display_println();
  switch (length) {
  case 1:
    display_println("red");
    break;
  case 2:
    display_println("red, yellow ");
    break;
  case 3:
    display_println("red, yellow, blue ");
    break;
  case 4:
    display_println("red, yellow, blue, green ");
    break;
  default:
    break;
  }
  display_println("in that order.");
  display_println();
  display_println("hold BTN0 to quit.");
}
Beispiel #2
0
// I used a busy-wait delay (utils_msDelay) that uses a for-loop and just blocks until the time has passed.
// When you implement the game, you CANNOT use this function as we discussed in class. Implement the delay
// using the non-blocking state-machine approach discussed in class.
void simonDisplay_runTest(uint16_t touchCount) {
  display_init();  // Always initialize the display.
  char str[MAX_STR];   // Enough for some simple printing.
  uint8_t regionNumber;
  uint16_t touches = 0;
  // Write an informational message and wait for the user to touch the LCD.
  display_fillScreen(DISPLAY_BLACK);        // clear the screen.
  display_setCursor(0, display_height()/2); //
  display_setTextSize(TEXT_SIZE);
  display_setTextColor(DISPLAY_RED, DISPLAY_BLACK);
  sprintf(str, "Touch and release to start the Simon demo.");
  display_println(str);
  display_println();
  sprintf(str, "Demo will terminate after %d touches.", touchCount);
  display_println(str);
  while (!display_isTouched());       // Wait here until the screen is touched.
  while (display_isTouched());        // Now wait until the touch is released.
  display_fillScreen(DISPLAY_BLACK);  // Clear the screen.
  simonDisplay_drawAllButtons();      // Draw all of the buttons.
  bool touched = false;  	      // Keep track of when the pad is touched.
  int16_t x, y;  		      // Use these to keep track of coordinates.
  uint8_t z;      		      // This is the relative touch pressure.
  while (touches < touchCount) {  // Run the loop according to the number of touches passed in.
    if (!display_isTouched() && touched) {         // user has stopped touching the pad.
      simonDisplay_drawSquare(regionNumber, true); // Erase the square.
      simonDisplay_drawButton(regionNumber);	   // DISPLAY_REDraw the button.
      touched = false;															// Released the touch, set touched to false.
    } else if (display_isTouched() && !touched) {   // User started touching the pad.
      touched = true;                               // Just touched the pad, set touched = true.
      touches++;  																	// Keep track of the number of touches.
      display_clearOldTouchData();  // Get rid of data from previous touches.
      // Must wait this many milliseconds for the chip to do analog processing.
      utils_msDelay(TOUCH_PANEL_ANALOG_PROCESSING_DELAY_IN_MS);
      display_getTouchedPoint(&x, &y, &z);                  // After the wait, get the touched point.
      regionNumber = simonDisplay_computeRegionNumber(x, y);// Compute the region number.
      simonDisplay_drawSquare(regionNumber, false);	    // Draw the square (erase = false).
    }
  }
  // Done with the demo, write an informational message to the user.
  display_fillScreen(DISPLAY_BLACK);        // clear the screen.
  display_setCursor(0, display_height()/2); // Place the cursor in the middle of the screen.
  display_setTextSize(2);                   // Make it readable.
  display_setTextColor(DISPLAY_RED, DISPLAY_BLACK);  // red is foreground color, black is background color.
  sprintf(str, "Simon demo terminated");    // Format a string using sprintf.
  display_println(str);                     // Print it to the LCD.
  sprintf(str, "after %d touches.", touchCount);  // Format the rest of the string.
  display_println(str);  // Print it to the LCD.
}
Beispiel #3
0
int main()
{
    // init the display so we can draw on it!
    display_init();
    // fill the display with black so it's all ready to have buttons drawn on it
    display_fillScreen(DISPLAY_BLACK);
    // Init all interrupts (but does not enable the interrupts at the devices).
    // Prints an error message if an internal failure occurs because the argument = true.
    interrupts_initAll(true);
    interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE);
    printf("timer load value:%ld\n\r", (int32_t) TIMER_LOAD_VALUE);
    u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond();
    printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond);
    interrupts_enableTimerGlobalInts();
    // Initialization of the clock display is not time-dependent, do it outside of the state machine.
//    clockDisplay_init();
    // Start the private ARM timer running.
    interrupts_startArmPrivateTimer();
    // Enable interrupts at the ARM.
    interrupts_enableArmInts();
    // The while-loop just waits until the total number of timer ticks have occurred before proceeding.
    while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond));
    // All done, now disable interrupts and print out the interrupt counts.
    interrupts_disableArmInts();
    printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount());
    printf("internal interrupt count: %ld\n\r", isr_functionCallCount);
    return 0;
}
// Inits the tic-tac-toe display, draws the lines that form the board.
void ticTacToeDisplay_init(){
	display_init();  // Must init all of the software and underlying hardware for LCD.
	display_fillScreen(DISPLAY_BLACK);  // Blank the screen.
	display_setRotation(true);
	buttons_init();
	ticTacToeDisplay_drawBoardLines();

/*
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_2);
*/
	/*
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_0, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_1, TICTACTOE_DISP_ROW_2);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_0);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_1);
	ticTacToeDisplay_drawO(TICTACTOE_DISP_COLUMN_2, TICTACTOE_DISP_ROW_2);*/




}
Beispiel #5
0
// Prints out informational messages based upon a message type (see above).
void verifySequence_printInfoMessage(verifySequence_infoMessage_t messageType) {
  // Setup text color, position and clear the screen.
  display_setTextColor(DISPLAY_WHITE);
  display_setCursor(MESSAGE_X, MESSAGE_Y);
  display_fillScreen(DISPLAY_BLACK);
  switch(messageType) {
  case user_time_out_e:  // Tell the user that they typed too slowly.
    display_println("Error:");
    display_println();
    display_println("  User tapped sequence");
    display_println("  too slowly.");
    break;
  case user_wrong_sequence_e:  // Tell the user that they tapped the wrong color.
    display_println("Error: ");
    display_println();
    display_println("  User tapped the");
    display_println("  wrong sequence.");
    break;
  case user_correct_sequence_e:  // Tell the user that they were correct.
    display_println("User tapped");
    display_println("the correct sequence.");
    break;
  case user_quit_e:             // Acknowledge that you are quitting the test.
    display_println("quitting runTest().");
    break;
  default:
    break;
  }
}
Beispiel #6
0
void TicTacToeDisplay_complete()
{
	display_fillScreen(DISPLAY_BLACK);
	display_setTextColor(DISPLAY_RED);
	display_setTextSize(4);
	display_println("TEST COMPLETE" );

}
Beispiel #7
0
void ticTacToeDisplay_init()
{
    display_init();  // Must initialize all of the software and underlying hardware for LCD.
    display_fillScreen(TICTACTOEDISPLAY_BLACK);  // Blank the screen with all black
    display_setTextColor(TICTACTOEDISPLAY_GREEN);  // Make the text green.
    display_setTextSize(TICTACTOEDISPLAY_TEXT_SIZE);  // this sets the text size
    ticTacToeDisplay_drawBoardLines();//draw the board lines
}
Beispiel #8
0
// Draw the initial splash (instruction) screen.
void wamDisplay_drawSplashScreen()
{
    display_setTextSize(WAM_D_NORMAL_TEXT);
    display_fillScreen(DISPLAY_BLACK); //clear screen
    //position in center ish
    display_setCursor(WAM_D_MESSAGE_OFFSET*DISPLAY_CHAR_WIDTH * WAM_D_NORMAL_TEXT,
            WAM_D_NORMAL_TEXT*DISPLAY_CHAR_HEIGHT);
    //print
    display_println(WAM_INSTRUCTIONS);
}
void ticTacToeDisplay_gameOver() {
	display_init();  // Must init all of the software and underlying hardware for LCD.
	display_fillScreen(DISPLAY_BLACK);  // Blank the screen.
	display_setRotation(true);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_ROW_0,TICTACTOE_DISP_COLUMN_0);
	ticTacToeDisplay_drawX(TICTACTOE_DISP_ROW_0,TICTACTOE_DISP_COLUMN_2);
	display_drawFastHLine(display_width()/3, display_height()/2, display_width()/3, DISPLAY_CYAN);

	display_setCursor(TICTACTOE_DISP_COLUMN_1_PT,TICTACTOE_DISP_ROW_2_PT);
	display_println("Game Over");

}
int main() {
	display_init();  // Must init all of the software and underlying hardware for LCD.
	display_fillScreen(DISPLAY_BLACK);  // Blank the screen.

	display_setRotation(0);
	display_drawLine(0,0,240,320,GREEN);
	display_drawLine(240,0,0,320 ,GREEN);
	display_drawCircle(120,80,30,RED);
	display_fillCircle(120,240,30,RED);
	display_drawTriangle(90,160,45,134,45,186,YELLOW);
	display_fillTriangle(150,160,195,134,195,186,YELLOW);

}
Beispiel #11
0
void buttons_runTest() {
  buttons_init();  // Initialize buttons
  display_init();  // Initialize display, which sets Rotation = 1 by default
  display_fillScreen(DISPLAY_BLACK); // blank the screen
  display_setTextColor(DISPLAY_BLACK);  // Change text color to black
  display_setTextSize(BUTTONS_TEXT_SIZE); // Make text larger

  // Set the values of the global variables
  x_max = display_width();
  y_max = display_height();

  // Set the values of screen positions
  x_fourth = FOURTH(x_max);
  x_half = HALF(x_max);
  x_three_fourths = THREE_FOURTHS(x_max);
  y_fourth = FOURTH(y_max);
  y_half = HALF(y_max);
  y_three_fourths = THREE_FOURTHS(y_max);

  // Do an initial read of button values
  int32_t buttonValues = buttons_read();

  // Until all 4 BTNS are pressed simultaneously, write info to the LCD
  while (buttonValues != BUTTONS_ALL_BTNS_ON) {

    // Draw the Rects/Text on the LCD corresponding to current buttons
    buttons_write_LCD(buttonValues);

    // Poll new value of buttons
    buttonValues = buttons_read();
  }

  // After all buttons are pushed simultaneously, finish test.
  display_fillScreen(DISPLAY_BLACK);  // blank screen
  display_setTextColor(DISPLAY_CYAN); // change text color
  display_setCursor(0,0);  // reset cursor to origin
  display_println("Button Test Finished!");  // print that the test is complete
}
Beispiel #12
0
// Draw the game-over screen.
void wamDisplay_drawGameOverScreen()
{
    wamDisplay_freeMemory(currentBoardsize); //deallocate the memory

    display_fillScreen(DISPLAY_BLACK); //clear screen
    //center and move down the Game Over message
    display_setCursor(WAM_D_MESSAGE_OFFSET*DISPLAY_CHAR_WIDTH * WAM_D_BIG_TEXT,
            WAM_D_MESSAGE_OFFSET*DISPLAY_CHAR_HEIGHT*WAM_D_BIG_TEXT);
    display_setTextSize(WAM_D_BIG_TEXT); //set size of text
    display_println(WAM_D_GAME_OVER_MESSAGE1); //print GAME OVER
    display_setTextSize(WAM_D_NORMAL_TEXT); //lower text size
    sprintf(gameOverStatString, WAM_D_GAME_OVER_MESSAGE2_FORMAT, oldHits, oldMisses, currentLevel);
    display_println(gameOverStatString); //display
    wamDisplay_resetAllScoresAndLevel(); //after printing, reset it all.
}
Beispiel #13
0
int main()
{
		srand(LARGE_PRIME_NUMBER);
	    // Initialize the GPIO LED driver and print out an error message if it fails (argument = true).
		   // You need to init the LEDs so that LD4 can function as a heartbeat.
	    leds_init(true);
	    // Init all interrupts (but does not enable the interrupts at the devices).
	    // Prints an error message if an internal failure occurs because the argument = true.
	    interrupts_initAll(true);
	    interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE);
	    u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond();
	    printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond);
	    // Allow the timer to generate interrupts.
	    interrupts_enableTimerGlobalInts();
	    // Initialization of the clock display is not time-dependent, do it outside of the state machine.
	    //TicTacToeDisplay_init();
	    display_init();
	    display_fillScreen(DISPLAY_BLACK);
	    buttons_init();
	    // Keep track of your personal interrupt count. Want to make sure that you don't miss any interrupts.
	     int32_t personalInterruptCount = 0;
	    // Start the private ARM timer running.
	    interrupts_startArmPrivateTimer();
	    // Enable interrupts at the ARM.
	    interrupts_enableArmInts();
	    // interrupts_isrInvocationCount() returns the number of times that the timer ISR was invoked.
	    // This value is maintained by the timer ISR. Compare this number with your own local
	    // interrupt count to determine if you have missed any interrupts.
	     while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)) {
	      if (interrupts_isrFlagGlobal) {  // This is a global flag that is set by the timer interrupt handler.
	    	  // Count ticks.
	    	  double duration0;
	      	personalInterruptCount++;
	      	 SimonControl_tick();
	      	verifySequence_tick();
	      	flashSequence_tick();
	      	simonbuttonHandler_tick();
	    	  interrupts_isrFlagGlobal = FLAG_DOWN;
	      }
	   }
	   interrupts_disableArmInts();
	   printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount());
	   printf("internal interrupt count: %ld\n\r", personalInterruptCount);
	   return 0;

}
// Init function
void clockDisplay_init() {
	display_init();  // Must init all of the software and underlying hardware for LCD.
	display_fillScreen(CLOCKDISPLAY__BLACK);  // Blank the screen.
	display_setRotation(true);
	display_setTextColor(CLOCKDISPLAY_GREEN);
	display_setTextSize(CLOCKDISPLAY_DISP_TXT_SIZE);

	clockDisplay_updateTimeDisplay(true);

	// Sets the colons on display; they never change
	display_drawChar(clockDisplay_x_char (CLOCKDISPLAY_CHAR_5),clockDisplay_y_char (CLOCKDISPLAY_CHAR_0),Colon,CLOCKDISPLAY_GREEN,CLOCKDISPLAY__BLACK,CLOCKDISPLAY_DISP_TXT_SIZE);
	display_drawChar(clockDisplay_x_char (CLOCKDISPLAY_CHAR_2),clockDisplay_y_char (CLOCKDISPLAY_CHAR_0),Colon,CLOCKDISPLAY_GREEN,CLOCKDISPLAY__BLACK,CLOCKDISPLAY_DISP_TXT_SIZE);

	clockDisplay_Triangle(CLOCKDISPLAY_DISP_TRIANGLE_0 ,CLOCKDISPLAY_GREEN);
	clockDisplay_Triangle(CLOCKDISPLAY_DISP_TRIANGLE_1 ,CLOCKDISPLAY_GREEN);
	clockDisplay_Triangle(CLOCKDISPLAY_DISP_TRIANGLE_2 ,CLOCKDISPLAY_GREEN);
	clockDisplay_Triangle(CLOCKDISPLAY_DISP_TRIANGLE_3 ,CLOCKDISPLAY_GREEN);
	clockDisplay_Triangle(CLOCKDISPLAY_DISP_TRIANGLE_4 ,CLOCKDISPLAY_GREEN);
	clockDisplay_Triangle(CLOCKDISPLAY_DISP_TRIANGLE_5 ,CLOCKDISPLAY_GREEN);
}
Beispiel #15
0
// Just clears the screen and draws the four buttons used in Simon.
void verifySequence_drawButtons() {
	display_fillScreen(DISPLAY_BLACK);
	simonDisplay_drawAllButtons();  // Draw the four buttons.
}
int main() {
	//buttonHandler_runTest(10);
	//flashSequence_runTest();
	//verifySequence_runTest();



	  // The formula for computing the load value is based upon the formula from 4.1.1 (calculating timer intervals)
	  // in the Cortex-A9 MPCore Technical Reference Manual 4-2.
	  // Assuming that the prescaler = 0, the formula for computing the load value based upon the desired period is:
	  // load-value = (period * timer-clock) - 1

	    // Initialize the GPIO LED driver and print out an error message if it fails (argument = true).
		   // You need to init the LEDs so that LD4 can function as a heartbeat.
	    leds_init(true);
	    // Init all interrupts (but does not enable the interrupts at the devices).
	    // Prints an error message if an internal failure occurs because the argument = true.
	    interrupts_initAll(true);
	    interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE);
	    u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond();
	    printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond);
	    // Allow the timer to generate interrupts.
	    interrupts_enableTimerGlobalInts();
	    // Initialization of the Simon game state machines is not time-dependent so we do it outside of the state machine.
		display_init();
		display_fillScreen(DISPLAY_BLACK);
	    // Keep track of your personal interrupt count. Want to make sure that you don't miss any interrupts.
	     int32_t personalInterruptCount = 0;
	    // Start the private ARM timer running.
	    interrupts_startArmPrivateTimer();
	    // Enable interrupts at the ARM.
	    interrupts_enableArmInts();
	    // interrupts_isrInvocationCount() returns the number of times that the timer ISR was invoked.
	    // This value is maintained by the timer ISR. Compare this number with your own local
	    // interrupt count to determine if you have missed any interrupts.


	    double *seconds;


	     while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)) {
	      if (interrupts_isrFlagGlobal) {  // This is a global flag that is set by the timer interrupt handler.
	    	  // Count ticks.
	      	personalInterruptCount++;
	      	verifySequence_tick();
	      	flashSequence_tick();
	      	buttonHandler_tick();
	      	intervalTimer_start(1);

	      	simonControl_tick();
	      	intervalTimer_stop(1);
	      	intervalTimer_getTotalDurationInSeconds(1,seconds);
	      	printf("%f \r\n",*seconds);
	      	//printf("interrupt count: %lu \r\n", interrupts_isrInvocationCount());
	      	intervalTimer_reset(1);
	    	  interrupts_isrFlagGlobal = 0;
	      }
	   }
	   interrupts_disableArmInts();
	   printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount());
	   printf("internal interrupt count: %ld\n\r", personalInterruptCount);

	return 0;
}
Beispiel #17
0
void TicTacToeDisplay_init()
{
	// Must init all of the software and underlying hardware for LCD.
	display_fillScreen(DISPLAY_BLACK);  // Blank the screen.
	TicTacToeDisplay_drawBoardLines();
}
Beispiel #18
0
void buttons_runTest() {
    buttons_init();
    // Initialize the display for writing.
    display_init();
    // Clear the screen; make the whole thing black.
    display_fillScreen(DISPLAY_BLACK);
    // Set up a var for storing the current value of the buttons.
    // This will be updated every time our while loop cycles.
    uint32_t newVal = 0;
    // Set up a var for storing the previous value of the buttons.
    // This will be updated every time our while loop cycles.
    uint32_t lastVal = 0;
    // Set the text size to a value of 2.
    display_setTextSize(BUTTONS_TEXT_SIZE);

    // As long as all four buttons are not all pressed at once, do this:
    while(newVal ^ BUTTONS_ARE_ALL_PRESSED) {
        // Copy newVal into lastVal because we're going to update newVal.
        lastVal = newVal;
        // Read the state of the buttons into newVal.
        newVal = buttons_read();
        // We need to check whether BUTTONS_BUTTON1's corresponding square has
        // already been drawn. We don't want to draw it again if it's
        // already there.
        if(!(lastVal & BUTTONS_BUTTON1) && (newVal & BUTTONS_BUTTON1)) {
            // Fill the far right square with yellow.
            display_fillRect(BUTTONS_BUTTON1_X_CORD, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_YELLOW);
            // Set our text cursor to a good place in the center of the square.
            display_setCursor(BUTTONS_BUTTON1_CURSOR_X_CORD, BUTTONS_ALL_BUTTONS_CURSOR_Y_CORD);
            // Make the text color black.
            display_setTextColor(DISPLAY_BLACK);
            // Write BTN0 in the center of the square.
            display_println(BUTTONS_BUTTON1_TEXT);
        }
        // If the square is drawn, and button 1 is no longer pressed:
        else if((lastVal & BUTTONS_BUTTON1) && !(newVal & BUTTONS_BUTTON1)) {
            // Write a black square on top of the yellow square.
            display_fillRect(BUTTONS_BUTTON1_X_CORD, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_BLACK);
        }
        // Repeat the process for BUTTONS_BUTTON1 for all other buttons:
        if(!(lastVal & BUTTONS_BUTTON2) && (newVal & BUTTONS_BUTTON2)) {
            // Draw a green square
            display_fillRect(BUTTONS_BUTTON2_X_CORD, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_GREEN);
            // Set the cursor
            display_setCursor(BUTTONS_BUTTON2_CURSOR_X_CORD, BUTTONS_ALL_BUTTONS_CURSOR_Y_CORD);
            // Set text color to black
            display_setTextColor(DISPLAY_BLACK);
            // Write BTN1
            display_println(BUTTONS_BUTTON2_TEXT);
        }
        // If the BUTTONS_BUTTON2 square is there and BUTTONS_BUTTON2 is no longer pressed:
        else if((lastVal & BUTTONS_BUTTON2) && !(newVal & BUTTONS_BUTTON2)) {
            // Draw a black square over the top of the green one
            display_fillRect(BUTTONS_BUTTON2_X_CORD, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_BLACK);
        }
        // If BUTTONS_BUTTON3 is pressed and the square is not already drawn:
        if(!(lastVal & BUTTONS_BUTTON3) && (newVal & BUTTONS_BUTTON3)) {
            // Draw a red rectangle
            display_fillRect(BUTTONS_BUTTON3_X_CORD, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_RED);
            // Set the cursor
            display_setCursor(BUTTONS_BUTTON3_CURSOR_X_CORD, BUTTONS_ALL_BUTTONS_CURSOR_Y_CORD);
            // Set the text color to white
            display_setTextColor(DISPLAY_WHITE);
            // Write BTN2 to the screen
            display_println(BUTTONS_BUTTON3_TEXT);
        }
        // If BUTTONS_BUTTON3 is no longer pressed and the square is on the screen:
        else if((lastVal & BUTTONS_BUTTON3) && !(newVal & BUTTONS_BUTTON3)) {
            // Draw a black rectangle over the top of the red one
            display_fillRect(BUTTONS_BUTTON3_X_CORD, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_BLACK);
        }
        // If BUTTONS_BUTTON4 is pressed and the square isn't on the screen:
        if(!(lastVal & BUTTONS_BUTTON4) && (newVal & BUTTONS_BUTTON4)) {
            // Draw a blue rectangle
            display_fillRect(0, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_BLUE);
            // Set the cursor
            display_setCursor(BUTTONS_BUTTON4_CURSOR_X_CORD, BUTTONS_ALL_BUTTONS_CURSOR_Y_CORD);
            // Set the text to be white
            display_setTextColor(DISPLAY_WHITE);
            // Write BTN3 to the screen
            display_println(BUTTONS_BUTTON4_TEXT);
        }
        // If BUTTONS_BUTTON4 is no longer pressed and the square is on the screen:
        else if((lastVal & BUTTONS_BUTTON4) && !(newVal & BUTTONS_BUTTON4)) {
            // Draw a black square over the blue one
            display_fillRect(0, 0, BUTTONS_ALL_BUTTONS_X_LENGTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_BLACK);
        }
    }
    // Once all 4 buttons are pressed simultaneously,
    // Draw a black square over the top part of the screen
    // To reset it.
    display_fillRect(0, 0, BUTTONS_SCREEN_WIDTH, BUTTONS_ALL_BUTTONS_Y_LENGTH, DISPLAY_BLACK);
}
Beispiel #19
0
    void simonControl_tick()
    {
        SC_debugStatePrint();


        /// //ACTIONS***********************************************************************
        switch(SC_State)
        {
        case SC_init_st:
            //do nothing
            break;
        case SC_instructions_st:
            display_setTextColor(DISPLAY_WHITE);
            display_setCursor(SC_INSTRUCTION_CURSORX,SC_INSTRUCTION_CURSORY);
            display_setTextSize(SC_INSTRUCTION_TEXTSIZE);
            display_println(SC_INSTRUCTIONS);
            break;
        case SC_wait_first_touch_st:
            // do nothing
            break;
        case SC_get_sequence_st:
            SC_currentScore = 0; //reset
            SC_setSequence();
            break;
        case SC_flash_sequence_st:
            //do nothing
            break;
        case SC_verify_sequence_st:
            //do nothing
            break;
        case SC_error_st:
            errorTimer++;
            if (verifySequence_isTimeOutError()) // user didn't press
            {
                display_setTextSize(SC_TEXTSIZE);
                display_println(ERROR_MESSAGE_TIMEOUT);
            }
            else if (verifySequence_isUserInputError()) //pressed wrong input
            {
                display_setTextSize(SC_TEXTSIZE);
                display_println(ERROR_MESSAGE_INPUT);
            }
            verifySequence_disable(); //set this here so we can read these flags. disable resets the error flags
            break;
        case SC_print_score_st:
            sprintf(maxScoreString, SC_HIGHSCORE_MESSAGE, SC_maxScore);
            display_setTextSize(SC_TEXTSIZE); //decrease text size
            display_println(maxScoreString);
            //reset scores, index, and sequence
            SC_currentIndex = 1; //reset to 1. since this is sequence length, when we setSequence, don't put to zero
            SC_maxScore = 0; //reset
            errorTimer = 0; //reset timer
            lvlMessageTimer = 0;
            break;
        case SC_level_complete_st:
            lvlMessageTimer++;
            if(printFlag) //set a flag so it doesn't keep being printed
            {
                display_println(SC_LVL_MESSAGE);
                printFlag = false; //switch flag
            }
            break;
        default:
            printf(SC_ERROR_MESSAGE); //invalid state
            break;
        }


        //TRANSITIONS***********************************************************************
        switch(SC_State)
        {
        case SC_init_st:
            SC_State = SC_instructions_st; //just go to instructions
            break;
        case SC_instructions_st:
            SC_State = SC_wait_first_touch_st; //go wait after drawing.
            break;
        case SC_wait_first_touch_st:
            if (display_isTouched()) //if touched, move ahead
            {
                SC_State = SC_get_sequence_st;
                display_fillScreen(DISPLAY_BLACK); //clear screen of instructions
            }
            break;
        case SC_get_sequence_st:
            SC_State = SC_flash_sequence_st;
            flashSequence_enable();
            break;
        case SC_flash_sequence_st:
            if (flashSequence_completed())
            {
                SC_State = SC_verify_sequence_st; //go to verify
                flashSequence_disable(); //disable flash machine
                simonDisplay_drawAllButtons(); //draw the buttons upon exit
                verifySequence_enable();
            }
            break;
        case SC_verify_sequence_st:
            if (verifySequence_isComplete()) //done verifying
            {
                //if there a time out error or wrong input error
                if (verifySequence_isTimeOutError() || verifySequence_isUserInputError()) //no errors
                {
                    SC_State = SC_error_st;
                    display_fillScreen(DISPLAY_BLACK); //clear buttons off screen
                }
                //level complete
                else if (globals_getSequenceIterationLength() == SC_sequence_length)
                {
                    SC_sequence_length++;
                    SC_State = SC_level_complete_st;
                    verifySequence_disable();
                    display_fillScreen(DISPLAY_BLACK); //clear buttons off screen
                    SC_currentIndex = 1; //reset
                    SC_maxScore = SC_currentScore;
                }
                else
                {
                    SC_State = SC_flash_sequence_st;
                    flashSequence_enable();
                    SC_currentIndex++; //how many to flash?
                    globals_setSequenceIterationLength(SC_currentIndex); //udate how many to falsh
                    verifySequence_disable();
                    display_fillScreen(DISPLAY_BLACK); //clear buttons off screen
                    SC_currentScore++;
                    if (SC_currentScore > SC_maxScore) //before first level is complete, maxScore doesn't get set
                    {
                        SC_maxScore = SC_currentScore; //this mostly before first level is complete
                    }
                }
            }
            break;
        case SC_error_st:
            if (errorTimer >= SC_ERROR_EXPIRE)
            {
                SC_State = SC_print_score_st; //print highest score
                display_fillScreen(DISPLAY_BLACK);
            }

            break;
        case SC_print_score_st:
            SC_State = SC_instructions_st;
            SC_maxScore = 0; //reset the maxScore!
            sequenceSeed++; //change the seed
            break;
        case SC_level_complete_st:
            if (lvlMessageTimer > SC_LVL_MESSAGE_EXPIRE) //timed out
            {
                SC_State = SC_print_score_st;
            }
            else if (display_isTouched())
            {
                SC_State = SC_instructions_st;
                display_fillScreen(DISPLAY_BLACK); // clear screen
                sequenceSeed++; //change the seed
                printFlag = true; //rest print flag
            }
            break;
        default:
            printf(SC_ERROR_MESSAGE);
            break;
        }

    }