コード例 #1
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawBody(void){
	// Method for displaying the body of the hangman
	RIT128x96x4ImageDraw(g_pucBody, 36, 24, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 25, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 26, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 27, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 28, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 29, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 30, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 31, 2, 1);
	RIT128x96x4ImageDraw(g_pucBody, 36, 32, 2, 1);
}
コード例 #2
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void clearPointer(int y){
	// Method for clearing a pointer
	int i;
	for (i=0; i<50; i++){
		RIT128x96x4ImageDraw(g_clearPointer, 0, y+i, 4, 15);
	}
}
コード例 #3
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawLeftLeg(void){
	// Method for displaying the left leg of the hangman
	RIT128x96x4ImageDraw(g_pucLeg2, 36, 33, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 38, 34, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg2, 38, 35, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 40, 36, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg2, 40, 37, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 42, 38, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg2, 42, 39, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 44, 40, 2, 1);
}
コード例 #4
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawRightLeg(void){
	// Method for displaying the right leg of the hangman
	RIT128x96x4ImageDraw(g_pucLeg2, 34, 33, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 34, 34, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg2, 32, 35, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 32, 36, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg2, 30, 37, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 30, 38, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg2, 28, 39, 2, 1);
	RIT128x96x4ImageDraw(g_pucLeg1, 28, 40, 2, 1);
}
コード例 #5
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawPointer(int y){
	// Method for drawing a pointer
	RIT128x96x4ImageDraw(g_pucPointer1, 0, y, 4, 1);
	RIT128x96x4ImageDraw(g_pucPointer2, 0, y+1, 4, 1);
	RIT128x96x4ImageDraw(g_pucPointer3, 0, y+2, 4, 1);
	RIT128x96x4ImageDraw(g_pucPointer4, 0, y+3, 4, 1);
	RIT128x96x4ImageDraw(g_pucPointer5, 0, y+4, 4, 1);
	RIT128x96x4ImageDraw(g_pucPointer6, 0, y+5, 4, 1);
	RIT128x96x4ImageDraw(g_pucPointer7, 0, y+6, 4, 1);
}
コード例 #6
0
ファイル: rit128x96x4.c プロジェクト: tach4455/EE345M
//*****************************************************************************
//
//! Colors a pixel on the oLED display
//!
//! This function will color a pixel the current color on the oLED display
//!
//!
//! \return None.
//
//*****************************************************************************
void 
RIT128x96x4DrawDot(unsigned long xpos, unsigned long ypos){
  unsigned char *pucRow;
  const unsigned char dotBufferRight[] = {0x0F};
  const unsigned char dotBufferLeft[] = {0x0F};
  if((xpos % 2) == 0)
  {
    pucRow = (unsigned char *)&dotBufferLeft[0];
  } else
  {
  	pucRow = (unsigned char *)&dotBufferRight[0];
	xpos--;
  }
  RIT128x96x4ImageDraw(pucRow, xpos, ypos, 2, 1);
}
コード例 #7
0
ファイル: rit128x96x4.c プロジェクト: oujoshua/445M
// *************** RIT128x96x4ShowPlot ********************
// Used in all the plots to write buffer to LED
// Example 1 Voltage versus time
//    RIT128x96x4PlotClear(0,1023);  // range from 0 to 1023
//    RIT128x96x4PlotPoint(data); RIT128x96x4PlotNext(); // called 108 times
//    RIT128x96x4ShowPlot();
// Example 2 Voltage versus time (N data points/pixel, time scale)
//    RIT128x96x4PlotClear(0,1023);  // range from 0 to 1023
//    {
//        RIT128x96x4PlotPoint(data); // called N times
//        RIT128x96x4PlotNext(); 
//    }   // called 108 times
//    RIT128x96x4ShowPlot();
// Example 3 Voltage versus frequency (512 points)
//    perform FFT to get 512 magnitudes
//    RIT128x96x4PlotClear(0,511);  // parameters ignored
//    {
//        RIT128x96x4PlotPoint(mag); // called 4 times
//        RIT128x96x4PlotPoint(mag); 
//        RIT128x96x4PlotPoint(mag); 
//        RIT128x96x4PlotPoint(mag); 
//        RIT128x96x4PlotNext(); 
//    }   // called 128 times
//    RIT128x96x4ShowPlot();
// Inputs: none
// Outputs: none
void RIT128x96x4ShowPlot(void){
  RIT128x96x4ImageDraw(PlotImage, 16, 10, 112, 80);
}
コード例 #8
0
ファイル: rit128x96x4.c プロジェクト: tach4455/EE345M
void RIT128x96x4ShowPlotFreq(void){
  RIT128x96x4ImageDraw(PlotFreqImag, 0, 10, 128, 80);
}
コード例 #9
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void removeUnderscore(int x, int y){
	// Method for removing an underscore from the display
	RIT128x96x4ImageDraw(g_pucUnderscoreClear, x, y, 128, 1);
}
コード例 #10
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawUnderscore(int x, int y){
	// Method for displaying an underline
	RIT128x96x4ImageDraw(g_pucUnderscore, x, y, 6, 1);
}
コード例 #11
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawRightArm(void){
	// Method for displaying the right arm of the handman
	RIT128x96x4ImageDraw(g_pucRightArm, 28, 27, 8, 1);
}
コード例 #12
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawLeftArm(void){
	// Method for displaying the left arm of the hangman
	RIT128x96x4ImageDraw(g_pucLeftArm, 36, 27, 10, 1);
}
コード例 #13
0
ファイル: oled.c プロジェクト: SLongofono/Classwork-Resume
// The function to generate and hold the initial start screen
//Note, this function does not have a while loop, nor does it set a "vTaskDelay", meaning
//it will only execute once.
//This is reflected in the way we use it in main; we call it a single time as a part of
//our system set up (as a blocking task), and then we enter the task scheduler loop
void startScreen(){
    /*
     * The RIT128x96x4** functions are a part of the driver API for the OLED
     * The details for this API can be found in drivers/rit128x96x4.c
     *
     * Create a frame for the OLED display
     * 		The ImageDraw function takes an array of unsigned char
     * 		each 8-bit char represents 2 pixels (side-by-side)
     * 		so, 4 of these bits represent a single pixel's brightness
     * 		with valid brightness values ranging (0-15)
     * 		and the pixels are represented in pairs.
     *
     *  Since the pixels are represented in pairs along the horizontal,
     *  	and the OLED is 128x96 pixels,
     *  	the horizontal frame only needs 64 elements (64 * 2 = 128).
     *  However the vertical frames will require two separate arrays,
     *  	each will have 94 elements (the OLED is 96 pixels high
     *  	but we have taken care of the two ends with the horizontal lines)
     *  The left frame will set the right column of pixels to zero,
     *  	and the right frame will set the left column of pixels to zero.
     *  The blank array elements are initialized to 0 to turn-off pixels later.
     *  It only needs 62 elements because we don't want to erase the frame.
     */
    unsigned char lframe[94], rframe[94], hframe[64], blank[62];

    // The loop is used to initialize the arrays
    unsigned int i;
    for(i = 0; i < 94; i++){
    	lframe[i] = 0xF0; 				// Vertical line for the left edge
    	rframe[i] = 0x0F; 				// Vertical line for the right edge
    	if(i < 64) hframe[i] = 0xFF; 	// Horizontal line for top and bottom
    	if(i < 62) blank[i] = 0x00; 	// The blank line used to clear the screen
    }

    //  Initialize the OLED display
    RIT128x96x4Init(1000000);
    /*
     *  Draw the frame
     *  ImageDraw takes an array of unsigned char as the first argument
     *  the next two arguments are the x and y coordinates (respectively)
     *  of the screen position to start drawing, and the final two arguments
     *  are the width and height (respectively) to which the image is scaled.
     */
    // Draw upper frame starting at (0,0) with width = 128 pixels and height = 1 pixel
    // 	(width and height should match the size of array measured in pixels)
    RIT128x96x4ImageDraw(hframe, 0, 0, 128, 1);
    // Draws lower frame starting at (0,95) width = 128, height = 1
    RIT128x96x4ImageDraw(hframe, 0, 95, 128, 1);
    // Draws left frame starting at (0,1) width = 2, height = 94
    RIT128x96x4ImageDraw(lframe, 0, 1, 2, 94);
    // Draws right frame starting at (127,1) width = 2, height = 94
    RIT128x96x4ImageDraw(rframe, 127, 1, 2, 94);

    /*
     * 	Draw the message
     * 	StringDraw takes a string as the first argument
     * 	the next two arguments are again the x and y coordinates of the starting position
     * 	and the final argument is pixel brightness for the
     * 	The first function writes the first part of the message at (32,24)
     * 	with a brightness of 15 (full brightness)
     */
	RIT128x96x4StringDraw(" Press the", 32, 24, 15);
	RIT128x96x4StringDraw("\"Select\" Button", 16, 33, 15);
	RIT128x96x4StringDraw("To Continue", 32, 42, 15);

	// Enable the select button, wait for the press, then reset and disable the port
	// The button is disabled after the splash screen and the port is reset to default for future use.
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
	GPIOPinTypeGPIOInput(GPIO_PORTG_BASE, GPIO_PIN_7); 	// Set the select button signal PG7 as input
	while(GPIOPinRead(GPIO_PORTG_BASE, GPIO_PIN_7));	// Wait until the signal changes (button pressed)
	SysCtlPeripheralReset(SYSCTL_PERIPH_GPIOG);
	SysCtlPeripheralDisable(SYSCTL_PERIPH_GPIOG);

	/*
	 *  When the select button is pressed we need to wipe the message leaving the frame on the OLED.
	 *  The loop sets the pixels to 0 everywhere except the screen's edges.
	 */
	for(i = 24; i < 50; i++)
		RIT128x96x4ImageDraw(blank, 2, i, 124, 1);
}
コード例 #14
0
ファイル: clockOLED.c プロジェクト: ab39826/EmbeddedSystems
//*************RIT128x96x4_ShowImage************************************** 
// Copies the RAM version of the image to the OLED 
// Inputs: none 
// Outputs: none 
void RIT128x96x4_ShowImage(void){
	RIT128x96x4ImageDraw(*bitmap, 0, 0, NUM_COLS, NUM_ROWS);
}
コード例 #15
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawHead(void){
	// Method for displaying the head of the hangman
	RIT128x96x4ImageDraw(g_pucHead13, 28, 11, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead12, 28, 12, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead11, 28, 13, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead10, 28, 14, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead9, 28, 15, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead8, 28, 16, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead7, 28, 17, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead6, 28, 18, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead5, 28, 19, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead4, 28, 20, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead3, 28, 21, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead2, 28, 22, 18, 1);
	RIT128x96x4ImageDraw(g_pucHead1, 28, 23, 18, 1);
}
コード例 #16
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
static void drawGallow(void){
	// method for displaying the gallow
	RIT128x96x4ImageDraw(g_pucLogo1, 10, 50, 32, 1);
	RIT128x96x4ImageDraw(g_pucLogo2, 10, 49, 32, 1);
	RIT128x96x4ImageDraw(g_pucLogo3, 10, 48, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo4, 10, 47, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo5, 10, 46, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo6, 10, 45, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo7, 10, 44, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo8, 10, 43, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo9, 10, 42, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo10, 10, 41, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo11, 10, 40, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo12, 10, 39, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo13, 10, 38, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo14, 10, 37, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo15, 10, 36, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo16, 10, 35, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo17, 10, 34, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo18, 10, 33, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo19, 10, 32, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo20, 10, 31, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo21, 10, 30, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo22, 10, 29, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo23, 10, 28, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo24, 10, 27, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo25, 10, 26, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo26, 10, 25, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo27, 10, 24, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo28, 10, 23, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo29, 10, 22, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo30, 10, 21, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo31, 10, 20, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo32, 10, 19, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo33, 10, 18, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo34, 10, 17, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo35, 10, 16, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo36, 10, 15, 8, 1);
    RIT128x96x4ImageDraw(g_pucLogo37, 10, 14, 10, 1);
    RIT128x96x4ImageDraw(g_pucLogo38, 10, 13, 10, 1);
    RIT128x96x4ImageDraw(g_pucLogo39, 10, 12, 12, 1);
    RIT128x96x4ImageDraw(g_pucLogo40, 10, 11, 12, 1);
    RIT128x96x4ImageDraw(g_pucLogo41, 10, 10, 28, 1);
    RIT128x96x4ImageDraw(g_pucLogo42, 10, 9, 28, 1);
    RIT128x96x4ImageDraw(g_pucLogo43, 10, 8, 28, 1);
    RIT128x96x4ImageDraw(g_pucLogo44, 10, 7, 28, 1);
    RIT128x96x4ImageDraw(g_pucLogo45, 10, 6, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo46, 10, 5, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo47, 10, 4, 32, 1);
    RIT128x96x4ImageDraw(g_pucLogo48, 10, 3, 32, 1);
}
コード例 #17
0
ファイル: hangman.c プロジェクト: drosales007/EmbeddedHW
//*****************************************************************************
//
// Helper Functions
//
//*****************************************************************************
static void drawLogo(void){
	// Method for displaying the Hangman logo
	int x0 = (128-72)/2;
	RIT128x96x4ImageDraw(g_pucHangman1, x0, 20, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman2, x0, 21, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman3, x0, 22, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman4, x0, 23, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman5, x0, 24, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman6, x0, 25, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman7, x0, 26, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman8, x0, 27, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman9, x0, 28, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman10, x0, 29, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman11, x0, 30, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman12, x0, 31, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman13, x0, 32, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman14, x0, 33, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman15, x0, 34, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman16, x0, 35, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman17, x0, 36, 72, 1);
	RIT128x96x4ImageDraw(g_pucHangman18, x0, 37, 72, 1);
}
コード例 #18
0
ファイル: rit128x96x4.c プロジェクト: liulvc/EE445L
//*************RIT128x96x4_ShowImage************************************** 
//  Copies the RAM version of the image to the OLED 
//  Inputs: none 
//  Outputs: none 
void RIT128x96x4_ShowImage(void){
	RIT128x96x4ImageDraw((unsigned char*)buffer, 0, 0, 128, 96);
}
コード例 #19
0
//*****************************************************************************
//
// Displays a logo for a specified amount of time.
//
//*****************************************************************************
static void
DisplayLogo(const unsigned char *pucLogo, unsigned long ulWidth,
            unsigned long ulHeight, unsigned long ulDelay)
{
    unsigned char *pucDest, ucHigh, ucLow;
    unsigned long ulLoop1, ulLoop2;
    const unsigned char *pucSrc;
    long lIdx;

    //
    // Loop through thirty two intensity levels to fade the logo in from black.
    //
    for(lIdx = 1; lIdx <= 32; lIdx++)
    {
        //
        // Clear the local frame buffer.
        //
        for(ulLoop1 = 0; ulLoop1 < sizeof(g_pucFrame); ulLoop1 += 4)
        {
            *(unsigned long *)(g_pucFrame + ulLoop1) = 0;
        }

        //
        // Get a pointer to the beginning of the logo.
        //
        pucSrc = pucLogo;

        //
        // Get a point to the upper left corner of the frame buffer where the
        // logo will be placed.
        //
        pucDest = (g_pucFrame + (((96 - ulHeight) / 2) * 64) +
                   ((128 - ulWidth) / 4));

        //
        // Copy the logo into the frame buffer, scaling the intensity.  Loop
        // over the rows.
        //
        for(ulLoop1 = 0; ulLoop1 < ulHeight; ulLoop1++)
        {
            //
            // Loop over the columns.
            //
            for(ulLoop2 = 0; ulLoop2 < (ulWidth / 2); ulLoop2++)
            {
                //
                // Get the two nibbles of the next byte from the source.
                //
                ucHigh = pucSrc[ulLoop2] >> 4;
                ucLow = pucSrc[ulLoop2] & 15;

                //
                // Scale the intensity of the two nibbles.
                //
                ucHigh = ((unsigned long)ucHigh * lIdx) / 32;
                ucLow = ((unsigned long)ucLow * lIdx) / 32;

                //
                // Write the two nibbles to the frame buffer.
                //
                pucDest[ulLoop2] = (ucHigh << 4) | ucLow;
            }

            //
            // Increment to the next row of the source and destination.
            //
            pucSrc += (ulWidth / 2);
            pucDest += 64;
        }

        //
        // Wait until an update has been requested.
        //
        while(HWREGBITW(&g_ulFlags, FLAG_UPDATE) == 0)
        {
        }

        //
        // Clear the update request flag.
        //
        HWREGBITW(&g_ulFlags, FLAG_UPDATE) = 0;

        //
        // Display the local frame buffer on the display.
        //
        RIT128x96x4ImageDraw(g_pucFrame, 0, 0, 128, 96);
    }

    //
    // Delay for the specified time while the logo is displayed.
    //
    Delay(ulDelay);

    //
    // Loop through the thirty two intensity levels to face the logo back to
    // black.
    //
    for(lIdx = 31; lIdx >= 0; lIdx--)
    {
        //
        // Clear the local frame buffer.
        //
        for(ulLoop1 = 0; ulLoop1 < sizeof(g_pucFrame); ulLoop1 += 4)
        {
            *(unsigned long *)(g_pucFrame + ulLoop1) = 0;
        }

        //
        // Get a pointer to the beginning of the logo.
        //
        pucSrc = pucLogo;

        //
        // Get a point to the upper left corner of the frame buffer where the
        // logo will be placed.
        //
        pucDest = (g_pucFrame + (((96 - ulHeight) / 2) * 64) +
                   ((128 - ulWidth) / 4));

        //
        // Copy the logo into the frame buffer, scaling the intensity.  Loop
        // over the rows.
        //
        for(ulLoop1 = 0; ulLoop1 < ulHeight; ulLoop1++)
        {
            //
            // Loop over the columns.
            //
            for(ulLoop2 = 0; ulLoop2 < (ulWidth / 2); ulLoop2++)
            {
                //
                // Get the two nibbles of the next byte from the source.
                //
                ucHigh = pucSrc[ulLoop2] >> 4;
                ucLow = pucSrc[ulLoop2] & 15;

                //
                // Scale the intensity of the two nibbles.
                //
                ucHigh = ((unsigned long)ucHigh * lIdx) / 32;
                ucLow = ((unsigned long)ucLow * lIdx) / 32;

                //
                // Write the two nibbles to the frame buffer.
                //
                pucDest[ulLoop2] = (ucHigh << 4) | ucLow;
            }

            //
            // Increment to the next row of the source and destination.
            //
            pucSrc += (ulWidth / 2);
            pucDest += 64;
        }

        //
        // Wait until an update has been requested.
        //
        while(HWREGBITW(&g_ulFlags, FLAG_UPDATE) == 0)
        {
        }

        //
        // Clear the update request flag.
        //
        HWREGBITW(&g_ulFlags, FLAG_UPDATE) = 0;

        //
        // Display the local frame buffer on the display.
        //
        RIT128x96x4ImageDraw(g_pucFrame, 0, 0, 128, 96);
    }
}