Section 73: Algorithm program for mirroring fonts on the LCD screen

display_lattice(8,0,Zf816_V,0,1,16); //Display the characters before mirroring

hz816_mirror(Zf816_V,ucBufferResult); //Mirror the characters and put them into the temporary variable ucBufferResult.

display_lattice(9,0,ucBufferResult,0,1,16); //Display the mirrored characters

display_lattice(8,16,Zf816_5,0,1,16); //Display the character <5> before the mirror

hz816_mirror(Zf816_5,ucBufferResult); //Mirror the <5> character and put it into the ucBufferResult temporary variable.

display_lattice(9,16,ucBufferResult,0,1,16); //Display the mirrored character <5>

while(1)

{

;

}

}

void display_clear(void) // Clear the screen

{

unsigned char x,y;

WriteCommand(0x34); //Display buffer command

WriteCommand(0x34); //Display buffer off command is intentionally written twice, for fear that it will not work once. This is because I refer to a driver from a certain manufacturer that is also written in this way.

y=0;

while(y<32) //y axis ranges from 0 to 31

{

WriteCommand(y+0x80); //vertical address

WriteCommand(0x80); //Horizontal address

for(x=0;x<32;x++) //256 horizontal points, 32 bytes

{

LCDWriteData(0x00);

}

y++;

}

WriteCommand(0x36); //Open display buffer command

}

/* Note 1:

* The essence of 16x16 dot matrix mirror:

* A 16x16 dot matrix has 16 rows, each row has 2 bytes. If these 2 bytes are regarded as a 16-bit int data,

* Then the data is reversed from the original order of high bits on the left and low bits on the right. This program does not convert the 2 bytes

* Instead of merging them into an int data, the high and low bit order is directly reversed within a byte of data, and then the first byte of data is swapped with the second byte of data.

*/

void hz1616_mirror(const unsigned char *p_ucHz,unsigned char *p_ucResult) //Function to mirror the 16x16 dot matrix font library

{

unsigned char a;

unsigned char b;

unsigned char c;

unsigned char d;

for(a=0;a<16;a++) //Here 16 means there are 16 rows. Each row has 2 bytes. Consider each byte as a column. Here, we first reverse the order of the bytes in the first column from the original high bits on the left to the low bits on the right, which is equivalent to a mirror image.

{

b=p_ucHz[a*2+0]; //The 2 here means that there are 2 columns of bytes in each row of the 16x16 dot matrix, and 0 means starting from the 1st column.

c=0;

for(d=0;d<8;d++) //switch the order of a byte

{

c=c>>1;

if((b&0x80)==0x80)

{

c=c|0x80;

}

b=b<<1;

}

p_ucResult[a*2+1]=c; //Note that because it is a mirror image, the bytes in reverse order should be swapped from the first column to the second column

}

for(a=0;a<16;a++) //Here 16 means there are 16 rows. Each row has 2 bytes. Consider each byte as a column. Here, we first reverse the order of the bytes in the second column from the original high bits on the left to the low bits on the right, which is equivalent to a mirror image.

{

b=p_ucHz[a*2+1]; //The 2 here means that there are 2 columns of bytes in each row of the 16x16 dot matrix, and 1 means starting from the 2nd column.

c=0;

for(d=0;d<8;d++) //switch the order of a byte

{

c=c>>1;

if((b&0x80)==0x80)

{

c=c|0x80;

}

b=b<<1;

}

p_ucResult[a*2+0]=c; //Note that because it is a mirror image, the bytes in reverse order should be swapped from the second column to the first column

}

}

/* Note 2:

* The essence of 8x16 dot matrix mirror:

* 8x16 dot matrix has 16 rows, each row has 1 byte, the data is reversed from the original order of high bits on the left and low bits on the right.

*/

void hz816_mirror(const unsigned char *p_ucHz,unsigned char *p_ucResult) //Function to mirror the 8x16 dot matrix font library

{

unsigned char a;

unsigned char b;

unsigned char c;

unsigned char d;

for(a=0;a<16;a++) //Here 16 means there are 16 rows. Each row has 1 byte. Here, we first reverse the order of the bytes in each row from the original left side being high bits and the right side being low bits, which is equivalent to mirroring.

{

b=p_ucHz[a*1+0]; //Here 1 means that there is 1 column of bytes in each row of the 8x16 dot matrix, and 0 means starting from the 1st column.

c=0;

for(d=0;d<8;d++) //switch the order of a byte

{

c=c>>1;

if((b&0x80)==0x80)

{

c=c|0x80;

}

b=b<<1;

}

p_ucResult[a*1+0]=c; //Note that since each row has only one column, there is no need to swap the first column with the second column like in a 16x16 matrix.

}

}

/* Note 3: The core function of this section. Readers should especially understand the display relationship between x_amount and y_amount.

* The first and second parameters x and y are coordinate systems. The range of x is 0 to 15, and the range of y is 0 to 31.

* The third parameter *ucArray is the array of fonts.

* The fourth parameter ucFbFlag is the reverse display flag. 0 represents normal display, 1 represents reverse display.

* The 5th and 6th parameters x_amount and y_amount represent the number of bytes in the horizontal direction and the number of bytes in the vertical direction of the font array respectively.

*/

void display_lattice(unsigned int x,unsigned int y,const unsigned char *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)

{

unsigned int j=0;

unsigned int i=0;

unsigned char ucTemp;

WriteCommand(0x34); //Display buffer command

WriteCommand(0x34); //Display buffer off command is intentionally written twice, for fear that it will not work once. This is because I refer to a driver from a certain manufacturer that is also written in this way.

for(j=0;j

{

WriteCommand(y+j+0x80); //vertical address

WriteCommand(x+0x80); //Horizontal address

for(i=0;i

{

ucTemp=ucArray[j*x_amount+i];

if(ucFbFlag==1) //Highlight

{

ucTemp=~ucTemp;

}

LCDWriteData(ucTemp);

// delay_short(30000); //Remove the delay function in the previous section to speed up the screen refresh

}

}

WriteCommand(0x36); //Open display buffer command

}

void SendByteToLcd(unsigned char ucData) //Send a byte of data to the LCD module

{

unsigned char i;

for ( i = 0; i < 8; i++ )

{

if ( (ucData << i) & 0x80 )

{

LCDSID_dr = 1;

}

else

{

LCDSID_dr = 0;

}

LCDCLK_dr = 0;

LCDCLK_dr = 1;

}

}

void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //Simulate SPI to send a byte of command or data to the underlying driver of the LCD module

{

SendByteToLcd( 0xf8 + (ucWRS << 1) );

SendByteToLcd(ucWData & 0xf0);

SendByteToLcd( (ucWData << 4) & 0xf0);

}

void WriteCommand(unsigned char ucCommand) //Send a byte command to the LCD module

{

LCDCS_dr = 0;

LCDCS_dr = 1;

SPIWrite(ucCommand, 0);

delay_short(90);

}

void LCDWriteData(unsigned char ucData) //Send one byte of data to the LCD module

{

LCDCS_dr = 0;

LCDCS_dr = 1;

SPIWrite(ucData, 1);

}

void LCDInit(void) //Initialization function including LCD module reset

{

LCDRST_dr = 1; // reset

LCDRST_dr = 0;

LCDRST_dr = 1;

}

void delay_short(unsigned int uiDelayShort) //delay function

{

unsigned int i;

for(i=0;i

{

;

}

}

Closing remarks:

Careful netizens will definitely find that this 12864 LCD screen generally has a problem. It cannot fully display as desired in the x and y directions of the coordinate axis with one dot matrix. For example, the horizontal direction is at least one byte of 8 dots, and the 1st and 2nd rows and the 3rd and 4th rows cannot be seamlessly displayed. If I want to display half of the Chinese characters in the 2nd row and half in the 3rd row, is it possible? Of course. But we need to write an additional algorithm program. How is this algorithm program written? For details, please listen to the next analysis - the algorithm program that allows fonts to be seamlessly displayed across regions in the LCD screen.