( Since release V2.5 )

All the configuration settings of the Bitmap2LCD tool have been reorganized and grouped in one single window :

The main settings, the output file header syntax settings, the pixel to data array orientation setting and a new user friendly pixel to data array organisation display.

Output of the GLCD data array in a binary file
The converter data output feeds a built in hexadecimal editor and is saved to disk in a binary file (*.hex)

Output of the GLCD data array in a text file for the compiler or assembler, format 8, 16 or 32 bit data

The converter data output feeds a built in text editor and can saved to disk in a text file
( *.c , *.h , *.asm , “.lib etc..)

Next to the data file, a rich text file (*.rtf) which contains all GLCD conversion parameters is written to disk, in the user defined “Documents folder”.

A simple data compression feature, for the output of GLCD data arrays is implemented in Bitmap2LCD

This function is only available for monochrome mode and 8 bit output format.

The 8 bit microcontrollers for price sensitive projects are circuits with often less onchip memory space than most of the 16 or 32 bit devices.

The target is to save as many as microcontroller flash memory as possible. As tables for full display patterns of for example a 128 x 64 dot matrix LCD need 1024 bytes each, the goal of this function was to save flash space for more code or graphics or just to reduce the overall flash capacity and therefore to sink the price of the MCU chip.

The microcontroller firmware has to be able to handle these tables with a special code, which decodes the compressed data. Processing time for decompression has to be allowed.

How does it work ?

Instead of only converting the black and white pixels found in the work canvas to a linear list of n bytes, with the data compression method explained here, the data array is split into two separate arrays in one single output file : one as usual for the data stream and another for the pointers of each data groups.

The basic concept of this compression is based on making groups of consecutive identical data bytes in the data array.

Consecutive identical byte chains, and consecutive different byte chains are handled, the goal here is to save data bytes when a consecutive identical byte chain is found. While the first pointer of a consecutive different bytes chain is a loss of one data byte stored as a pointer, a consecutive identical byte chain of 10 bytes is a win of 8 bytes, the data being written only once in the data array. The count of them is then stored in the pointer byte array part.

The maximum count of consecutive data, identical or different is limited to 127 ( pointer bits 6 to 0 ). If a data count in a group reaches 127, a new group is encoded.

The bit 7 of the pointer byte is the flag for the compression decoder. A 1 (high) is for a chain of identical data bytes, and a 0 (low) is for an chain of different data.

When data compression is active, Bitmap2LCD converts all data and shows the compression rate in the compression statistics at the end of the output file.

This method of compression shows different results in vertical or horizontal orientation conversion, it depends of the LCD graphic !

If possible, before to choose the LCD controller and its specific data orientation in Display RAM , you could try both orientations and compare the possible compression ratios.

In the Header Include file, the example script below shows how to setup the compression table information.

( It is an example for a GNU-C compiler for ATMEL AVR family )

Everything after the tag [&COMPRESSION] is a script information for the data compression function.

The tag [&CNAME] is replaced in the output table name, by the data array name

with an additional suffix _x ( For example : Newfile_x )

The tag [&CSIZE] is not used yet (v2.3)

In the Header Include file :

[&COMPRESSION]
const prog_uint8_t [&CNAME][&CSIZE] = {

 Please also check the online forum for other topics about this function

Compression Decoder Example

The below example of a function in C language, decodes compressed data arrays converted with bitmap2LCD.

It is for an Atmel AVR target MCU with GCC compiler, a T6963C LCD controller ( horizontal byte orientation from left to right )
No buffer RAM.

Note : For LCD module widths greater than 255 dots, x and width variables should be long integers

// T6963 function for uncompressed bitmaps

void GLCD_Bitmap(unsigned char *bitmap, unsigned char x, unsigned char y, unsigned char width, unsigned char height)

{

unsigned char val;

uint8_t LcdX,LcdY,EndX,EndY;

long ip = 0; // table byte counter

LcdX=x; // LCD dot adress X

LcdY=y; // LCD dot adress Y

EndY=y+height-1;

EndX=x+width;

while (LcdY < EndY || LcdX < EndX)

{

GLCD_GraphicGoTo(LcdX, LcdY);

GLCD_WriteDisplayData(pgm_read_byte(bitmap + ip));

ip ++;

LcdX=LcdX+8;

if (( LcdX == EndX ) && ( LcdY<EndY ))

{

LcdY++;

LcdX=x;

}

}

}

// T6963 function for Bitmap2LCD compressed bitmaps

void GLCD_xBitmap(unsigned char *bitmap, unsigned char *pointer, unsigned char x, unsigned char y, unsigned char width, unsigned char height)

{

unsigned char val;

uint8_t p,pv,nb,LcdX,LcdY,EndX,EndY;

long ip = 0; // table byte counter

p = 0; // pointer

LcdX=x; // LCD dot adress X

LcdY=y; // LCD dot adress Y

EndY=y+height-1; // End pixel in Y

EndX=x+width; // End Pixel in X

while (LcdY < EndY || LcdX < EndX)

{

pv = (int)(pgm_read_byte(pointer + p)); // read the pointer byte

p++;

if (pv > 128) // bit 7 is logical high when identical bytes chain, low when different

{

val = pgm_read_byte(bitmap + ip);

ip++;

nb = pv – 128;

while ( nb > 0 ) // substract bit 7 value for number of bytes in chain

{

GLCD_GraphicGoTo(LcdX, LcdY); // bytes in chain are identical

GLCD_WriteDisplayData(val);

LcdX=LcdX+8;

nb–;

if (( LcdX == EndX ) && ( LcdY<EndY ))

{

LcdY++;

LcdX =x;

}

}

}

else // bytes in chain are different

{

while ( pv > 0 )

{

GLCD_GraphicGoTo(LcdX, LcdY);

GLCD_WriteDisplayData(pgm_read_byte(bitmap + ip));

ip ++;

LcdX=LcdX+8;

pv–;

if (( LcdX == EndX ) && ( LcdY<EndY ))

{

LcdY++;

LcdX=x;

}

}

}

}

}

Since V2.3 and upwards, Bitmap2LCD supports the 4,16 and 32 level grayscale controllers. ( Newly implemented are the 4 and 32 gray levels capability )

Color images and pictures can be imported and converted to 4, 16 and 32 gray levels into the work canvas. The software tool then generates the pixel data array in the selected arrangment, 2, 4 or 5 bits per pixel.

Here’s a list of grayscale LCD controllers, featuring 4, 16 and 32 gray levels.

Grayscale LCD Controllers

4 Gray Levels (2bpp)

S6B0741 128×129 Samsung

KS0741 128×129 Samsung

HT1647 64×16 Holtek

ST7541 128×129 Sitronix

ST7571 128×129 Sitronix

ST7586S 384×160 Sitronix

UPD16686 128×128 NEC

UPD16498 128×128 NEC

UPD16488A 128×92 NEC

HD66750 128×128 Hitachi

HD66421 160×100 Hitachi

EM65100 69 x101 Elan Microelectronics Corp

NJU6680 128×128 New Japan Radio

NJU6682 160×132 New Japan Radio

RA8806 320X240 Raio Technology

16 Gray Levels (4bpp)

EM65101 128×160 Elan Microelectronics Corp

SSD1322 480×120 Solomon Systech

SSD1325 128×80 Solomon Systech

SSD1326 256×32 Solomon Systech

SSD1327 128×128 Solomon Systech

32 Gray Levels (5bpp)

ST7529 255×160 Sitronix

Let’s look how to configure the GLCD data output settings :

The generated data array file (orange arrow, in the picture below) can be configured to meet the syntax requests of your compiler or assembler. There are many possible settings, to make it possible to match the tool with most of the compilers of the market.

At first, you define the table data settings (red arrow)

• Data Width format. ( 8,16 or 32 bits data)
• Binary, Hex or decimal format.
• Syntax of Data Byte/Word (make it compatible with your favorite compiler, assembler)
• Generated Type of file.

As next, you define the header syntax (green arrow)

• Click on the button and the header script is loaded into the editor. Modify it to meet your requirements.
• When ready, quit the header editor by clicking the same button (green arrow at the right) or the quit button. (script is auto-saved)
• Find more about the header syntax at the end of this article.

As next, you define the way the data arrays are arranged to correctly fit in the DDRAM of your LCD controller. These settings must be compatible with the LCD display functions in the GLCD Library you use in your project (blue arrow)

• The origin corner X0,Y0
• Data direction (The direction in which the pixels slices are taken from the work canvas and converted to GLCD data, for example in slices or in full canvas height or full canvas width. A slice is 8 pixels in monochrome mode and 2 pixels in 4bpp grayscale mode)
• The Endianness (Most Significant Bit is first or last)
• Special settings

More about File Header syntax (green arrow)

The script components [&***] can be included only once and will be replaced by the data or value when the data array is generated. Not needed script components can be erased.

[&NAME]

The [$NAME] and the image size and position are optional and can be placed optionally anywhere in the header.

[&SIZE]

Same for Size of Data

[&TRUEORG]

This is the script component if present in the file, to indicate that you want to have the XPOS and YPOS origins of a reduced dynamic table of constants ( a part of the display you want to change ) given from the X0,Y0 corner you selected in the table translation manager window.

[&XPOS]

[&YPOS]

[&WIDTH]

[&HEIGHT]

The corner position on the Work Canvas and the size of the converted graphic area can be exported into the file.

There are additional script components for font generation and data compression.

Let’s see how we can create an animation for small Graphic LCD.

• When in static mode (blue arrow), go to the animation menu (green arrow) and click the animation button (red arrow). The same button should later be used to go back to the static mode. An animation will be saved as a standard GIF file.

•  When in animation mode (blue arrow) the animation sub-menu becomes accessible (red arrow) . The animation is made of frames, a sequence of images. The ghost image of the previous frame can optionally be displayed, it is a visual help for correct placement of graphic items (green arrow)

• In the animation mode the window border becomes dark gray (green arrow)
• At the top you can read the number of the displayed frame  (2)  and the number of total frames (3) (blue  arrow)
• In the animation menu , you can use the navigation buttons to move between frames, move to the beginning or the end of the animation. You can also play and stop the animation sequence. (orange arrow) An alternative is to use the page-up and page-down keyboard keys to move thru the animation frames.

•  When the animation is done you can convert the frames in GLCD data in one go  (green arrow)
• With this animation made of 3 frames example, Bitmap2LCD produces 4 files : A clip unit file  (blue arrow, the code in the editor) and the 3 frames as data files  (orange  arrow)
• You can navigate and view these files with the buttons  (red arrow)
• A selected part of the animation frames can be converted : Enable Display Paging Scheme Limits and then select the area to convert. Click conversion button to start conversion.

•  In this example, 3 full frame size of data for  a 128 x 128 pixel GLCD are converted (black arrow). If the “Autoframing” option whas been enabled in the configuration settings, an automatic framing of only the changing pixels is made. Then the X and Y positions, the height and teh width of the frame is reported inside the clip unit.
• In the configuration settings window , find other animation settings on the “clip unit” panel.
• In the monochrome mode, in addition to autoframing, an animation output can optionally be “internally compressed” to generate reduced code size.

Let’s see an example of an image import and resize in Bitmap2LCD

• To import an image, click on the image filename inside the file explorer of Bitmap2LCD
• If the picture size is bigger as the Work Canvas, ( in this example a 500 x 579 pixels image – red arrow - and a 128 x 128 pixels Work Canvas ) a red frame in a proportional size of the canvas appears in the image preview (blue arrow)
• Move the mouse inside this red frame in the image preview (blue arrow), and move the frame to the area you would like to import.
• When ready, click the import image button (the button at the right side below the preview)

• In the “Resize to fit ?”pop-up message, choose  = NO
• In this example, Bitmap2LCD converts the 236 “colors” picture to the 16 gray levels for the target Graphic LCD

•  If needed, move the selected area inside the canvas (click & move with mouse)
• If you want to adjust the size of the image import, click the resize selection button (green arrow)
• Then use the mouse wheel or the resize area buttons to resize the import (orange arrow)
• At the end, Paste the selection (Paste Button or Return Key)

( From V2.2 and upwards )

Let’s see how we can export selected characters out of a Windows System font into the Font Editor of Bitmap2LCD :

• Create a GLCD Font Script by clicking the main menu item (blue arrow)
• In this example, it is a set of antialiased Chars for a grayscale Graphic LCD (orange arrow)
• In the “Ascii Grid”, select the chars you want to export, here for example A, B and C  (red arrow)
• In the main menu, click on item “Translate LCD Font Script to an Editable Font” (green arrow)

The “editable font” has been created. It is an Editable Font File (EFF) and an associated GIF file, which is the catalogue of char bitmaps. Both files are located in the Fonts folder.

In this example, the selected font name and font size were Arial and 10, in this case the filename of the file will be Arial_10_editable_Font.EFF

• Quit Font Script Creator mode.
• Click menu item “Open an Editable Font file (EFF)”  (blue arrow)
• Click on the Arial_10_editable_Font.EFF file in the list inside the file explorer
• The chars are ready to be edited in the Font editor (green & red arrows)

Since V2.2, in the GLCD Font Editor Component of Bitmap2LCD , a feature makes it possible to create segmented fonts, a set of characters that are similar to the 4 numbers displayed on the LCD module in the picture below.

A segmented character is made of an assembly of smaller graphic segments (in this example 6 segments for the O) . These segments being present more than only one time in the different characters of the font.

Now let’s see how this feature is implemented in bitmap2LCD  :

• View of the char group #1 in the Work canvas (red arrow) The word “group” means an assembly of segments or small graphic elements.
• The 8 segments needed for the whole charset in the Font Editor Window (blue arrow)
• The Segment Font Script for this font. This file contains for each character (group) the X and Y positions of all graphic elements and their associated segment bitmap.

Description of the GLCD font editor in Bitmap2LCD (since V2.2)

The example below shows the begin of the creating of an Editable font from scratch

On the font panel window at the left :

• There is one single new Char is in the font grid (red arrow), all pixels are white
• The font editor toolbar (brown arrow) Buttons: insert new char or paste a char, delete a char, copy a char,export to work canvas,import from work canvas, save font…
• Above the Font Editor toolbar, the segmented font viewer buttons to hide/show the different Char segments (up to 12 segments)
• The character displayer and pixels editor. (green arrow) For complicated Char edits, the Char can be exported into the work canvas, and re-imported after modification.

On the Outputs panel window at the right :

• The Editable Font Script in the editor (blue arrow) , in the GLCD Font Editor mode, the editor gutter becomes yellow.
• The Editable Font Script editor toolbar  (orange arrow), the values in the Font Script can only be modified in the edits there. It depends where the cursor is located in the script. The Normal Font / Segment Font switch is located on this toolbar too.