














                                ** LCD Tools **

                               Tools for Building

                         Mapping & Character Generation

                               tables for custom

                            Liquid Crystal Displays










                          Dunfield Development Systems
                          ----------------------------
                             High quality tools for
                              Embedded Development
                                 at low prices.

                            http://www.dunfield.com










                       Copyright 2002-2005 Dave Dunfield
                              All rights reserved.



                                    LCDtools

                               TABLE OF CONTENTS


                                                                         Page

     1. INTRODUCTION                                                        1


     2. USING LCD TOOLS                                                     2

        2.1 Main Screen Layout                                              2
        2.2 Main Screen Functions                                           2
        2.3 Steps to create an LCD layout                                   6

     3. EMULATION COMMANDS                                                  9

        3.1 ASCII data                                                      9
        3.2 Clear LCD screen                                                9
        3.3 Report event flag                                               9
        3.4 Set high segment address                                        9
        3.5 Turn segment OFF                                                9
        3.6 Turn segment ON                                                 9

     4. LCM - MAP TABLE BUILD UTILITY                                      10

        4.1 Command Line Options                                           10
        4.2 Example Table Processing                                       11

     5. LCG - CHARACTER GENERATOR BUILD UTILITY                            12

        5.1 Command Line Options                                           12
        5.2 Example Character Processing                                   13

     6. SAMPLE FILES                                                       14

        6.1 PANEL1.LCD                                                     14
        6.2 PANEL2.LCD                                                     14
        6.3 25DOT.LCG                                                      14
        6.4 7SEG.LCG                                                       14
        6.5 16SEG.LCG                                                      14
    LCDtools                                                         Page: 1


    1. INTRODUCTION

       Many modern embedded designs utilize custom liquid  crystal  display,
       which can be quite complex.  Due to this complexity and limitaions in
       the construction of the displays,  the mapping of display segments to
       hardware addresses in the LCD controller rarely works out to anything
       which can be easily manipulated from a software point of view.

       For example, a display I recently worked with had this layout:

            Top row   : 15 5x5 dot matrix characters
            Middle row: 13 7-segment digits + one dash only digit
            Bottom row: 12 7-segment digits + 11 misc words/symbols

       The matrix design had to pretty much  "square",  which ment that each
       byte in the LCD controller memory had a few bits  from  a  dot-matrix
       character,  and a few assorted segments from the 7-segment and  misc.
       areas.  To make matters worse, the mapping changed every time a misc.
       symbol occured,  so that the bits used in a dot-matrix  or  7-segment
       character were not the same from position to position.  This made  it
       impossible  to  directly  address  the  display  from   a   character
       generator.

       To write characters on a bit  mapped  display,  you  need  to  use  a
       character generator.  This is simply a table which  tells  you  which
       bits should be turned on for a given character.  To avoid  having  to
       have a separate character generator table for each display  position,
       you need to have exactly the same  relative  bit  mapping  with  each
       character of a given type. Then you can select any character position
       on the display  simply  by  adjusting  the  starting  address  within
       display memory where you write the bits from the character  generator
       table.  Clearly if the mapping within each character position is  not
       identical  (such as in the display above),  this technique  will  not
       work.

       Unless you have a square dot-matrix display,  most custom displays do
       not have such nice "software friendly"  mapping.  The usual method of
       handling this is  to  build  a  table  which  translates  linear  bit
       addresses which are convienient for the software into  the  haphazard
       memory  layout  which  suits  the  hardware.  This  table  should  be
       organized so that the display layout presented  to  the  software  is
       idealy suited for character generator output.

       Building these tables  "by hand"  is a  tedious  process.  LCD  Tools
       simplifies the job by allowing you to define the LCD layout  visually
       on your PC screen,  and to define hardwre and software mapping simply
       by selecting segments with the mouse.  A  character  editor  is  also
       provided,  providing easy  on-screen  visual  creation  of  character
       generator tables,  with the resulting  characters  displayed  on  the
       actual LCD image.

       LCD Tools also provides an emulation mode,  which allows you  to  use
       the PC representation created above as a functional display  on  your
       target system.  This makes it easy to try out new LCD display designs
       before committing to production,  and also provides a way to continue
       with product software development while waiting for the LCD panel  to
       be manufactured.
    LCDtools                                                         Page: 2


    2. USING LCD TOOLS

       Tha main LCD Tools program is called  "LCD".  To start this  program,
       simply type LCD at the DOS prompt.  LCD will start  and  present  you
       with it's main operating screen.

       2.1 Main Screen Layout

          The  top  1/2  of  this  screen  is  a  320   x   102   dot-matrix
          representation of the LCD  panel.  Within  this  screen,  you  can
          define up to 1024 LCD segments,  which can  each  consist  of  any
          combination of display  "dots"  from a single dot,  to the  entire
          panel.

          Immediately below the LCD display,  is a text line which indicates
          status and error messages which may be generated during the use of
          the program.

          Below this is a line indicating the current display magnification,
          the visible panel area (in rows - colums),  and the current cursor
          position.

          The next line displays the currently  selected  hardware  physical
          segment number  (1-1024),  or is blank if no segment is  selected,
          indicating unassigned panel area).  This display also includes the
          offset  into  LCD  display  memory   in   both   hex-address   and
          hex-address.bit forms  (refer  to  whichever  is  suited  to  your
          hardware design).

          The next line displays  the  currently  selected  software  mapped
          segment number  (1-1024),  or is blank  for  no  software  segment
          mapping assigned.  This display also includes the hex offset  into
          LCD bitmap table memory.

          Below these lines is a text  "help"  display which shows  the  key
          functions which can be performed.

       2.2 Main Screen Functions

          The main screen is primarily used for  defining  the  LCD  screen,
          assigning the hardware segment mapping,  and for activating  other
          functions.

          For most operations,  the ENTER key will perform the same function
          as the LEFT mouse button,  and the ESC key will perform  the  same
          function as the RIGHT mouse button.

          2.2.1 Mouse Functions

             Pressing the LEFT mouse button  will  assign  the  display  dot
             under the flashing cursor to the hardware segment shown by  the
             "Seg:"  prompt.  If no hardware segment is selected  (no "Seg:"
             visible),  then the dot will be unassigned and  set  to  unused
             panel space.

             Pressing the RIGHT mouse button  will  "pick  up"  the  segment
             number under the cursor, making it the current selection.
    LCDtools                                                         Page: 3


          2.2.2 Keyboard Functions

            Key(s)              Function
            -----------------------------------------------------------------
            LEFT,ENTER          Assign current hardware segment to display

            RIGHT,ESC           Pickup hardware segment number from display

            +,=                 Increases display magnification

            -,_                 Decreases display magnification

            Up/Down/Left/Right  Move display view (when >x1 magnification)

            ^Left               Adjust LCD display contrast

            ^Right              Adjust LCD display brightness

            Ins                 Reset to full display view

            Del                 Activate display "Zoom"
              - Use mouse to position "window", press LEFT,ENTER and
                display will "zoom" to that position.
              - Use +,= and -,_ to adjust the size of the "window"
              - Press RIGHT,ESC to exit without zoom.

            PgUp/PgDn           Select hardware segment number (by 1)

            ^PgUp/^PgDn         Select hardware segment number (by 10)

            Home/End            Select software mapping number (by 1)

            ^Home/^End          Select software mapping number (by 10)

            F                   Block fill segment
              - Select start  point, press LEFT
              - Select ending point, press LEFT
              * Entire block will be be assigned hardware segment number

            C                   Copy block to clipboard
              - Select start  point, press LEFT
              - Select ending point, press LEFT
              * Block will be copied to clipboard for later P)aste
              * Clipboard is limited to 16384 dots (approx 1/2 display area)

            M                   Software Mapping functions
              - Press 'C' to clear the software map (no mapping)
              - Press 'F' to find the segment with currently selected map
              - Press 'H' to auto-assign 1-1 Software=Hardware mapping
                * Used if hardware map is same as software map
                * Also useful for creating "dummy" displays for emulation.
                  (Simply map hardware the way you want)

            P                   Paste Clipboard
              - Content of clipboard is displayed at mouse
              - Position to desired location and press LEFT to copy the
                clipboard block into the display at this point.
    LCDtools                                                         Page: 4



            R                   Redraw screen (restore markers etc.)

            S                   Set "Snap" spaceing
              - Prompts with "Snap?"
              - Enter value, cursor will "Snap" to this spacing.
              * Value of 0 will turn Snap off.

            L                   Draw Line
              - Select start  position, press LEFT
              - Select ending position, press LEFT
              * Segments along line will be assigned hardware segment number

            F1                  Set base marker
              - Pick a point on LCD and press LEFT
              * Cursor position will be shown relative to this marker

            F2                  Assign hardware segments - Block
              - Select start  position, press LEFT
              - Select ending position, press LEFT
              - All existing segments within the block will be reassigned
                with the new hardware segment number.
              - Repeat for as many blocks as you like
              - Press SPACE to toggle On/Off auto-increment to next hardware
                segment number with each block.
              - Press RIGHT,ESC to exit
              * Useful to re-assign complex segments after copy/paste.

            F3                  Assign hardware segments - Shape
              - Select a segment dot on the screen, press LEFT
              - This and all adjacent dots (vertical and horizontal) with the
                same hardware segment number will be reassigned with the new
                hardware segment number.
              - Repeat for as many shapes as you like.
              - Press SPACE to toggle On/Off auto-increment to next hardware
                segment number with each block.
              - Press RIGHT,ESC to exit
              * Useful to re-assign simpler segments after copy/paste.

            F4                  Adjust hardware segments - Block
              - Select start  position, press LEFT
              - Select ending position, press RIGHT
              - All segments within the block are reassigned beginning with
                the new hardware segment number, keeping the relative segment
                numbering of the original block.
              - Press SPACE to toggle On/Off auto-increment to next unused
                hardware segment number after this operation completes.

            F5                  Assign software mapping number
              - Position mouse over an assigned hardware segment, press LEFT
              - Segment will be assigned displayed software mapping number.
              - Repeat with as many segments as you like.
              - Press SPACE to toggle On/Off auto-increment to next software
                map number.
              - Press RIGHT,ESC to exit.

            F6                  Assign software mapping to block
    LCDtools                                                         Page: 5


              - Select start  position, press LEFT
              - Select ending position, press LEFT
              - All segments within block will be assigned an ascending map
                number (from current map number) beginning with upper left
                corner, and ending with lower right corner, and scanning for
                new segments row by row.
              - Press SPACE to toggle On/Off auto-advance of map number on
                exit.

            F7                  Character generator editor
              - Prompts with "Filename?", enter existing character generator
                to use, or press RIGHT,ESC to begin a new one.
              - Select upper left  corner of character block, press LEFT
              - Select lower right corner of character block, press LEFT
              - You are now in character editing mode:
                - Click (LEFT) on a character segment to Toggle On/Off
                - Press ASCII character to switch to a specific character
                - Use Left/Right to switch character by 01
                - Use Up/Down to switch charcter by 10 (hex)
                - Use Ins for full screen view
                - Use Del for zoom
                - Use ^Left/^Right to adjust contrast/brightness
                - Use RIGHT,ESC to activate menu
                    'S' = Save file
                    'Q' = Quit (no save)

            F8                  Audit LCD layout
              - Performs tests of the LCD layout and reports:
                - Duplicated MAP addresses (error)
                - Skipped MAP addresses (warning)
                - Skipped Hardware Segments (informational)

            F9                  Emulate LCD panel
              - Prompts with COM=n BAUD=speed
                - Use Up/Down to select COM port
                - Use Left/Right to select baudrate
                - Press ENTER when finished
              - The display panel will be emulated via the serial data from
                the target (See EMULATION COMMANDS)
              - Use INS or DEL to clear screen
              - Use ^Left/^Right to adjust Contrast/Brightness
              - Press F1 to clear text area (under screen)
              - Press ESC to exit

            F10                 File menu
                - Press 'L' to load an LCD description file
                - Press 'S' to save current description to file
                - Press 'Q' to exit program
    LCDtools                                                         Page: 6


    2.3 Steps to create an LCD layout

    The following is the recommend steps for creating an LCD layout:
    (Note, you should save your layout after each step)

    2.3.1 1 - Define physical LCD segments

    Using the main screen, define the visible segments using the LEFT mouse
    button to assign single dots, or the F)ill and L)ine functions to create
    larger shapes.

    You may choose to assign the hardware segment numbering as you create the
    segments, or to create them all with the same segment number (I use 1024),
    and then reassign the hardware mapping afterward.

    For displays with many identical elements (eg: 7-segment or dot-matrix
    displays), it is usually best to create a single element, and then use
    the C)opy and P)aste functions to copy the elements as many times as
    you like.

    2.3.2 2 - Assign hardware mapping

    If you did not do so in step #1, you should now use the F2, F3 and F4
    functions to assign the correct hardware mapping for each segment on the
    display.

    Note that if you have identical display elements which are mapped in
    the same relative ordering, you can set the relative segment numbering
    on the first element before you C)opy it to the clipboard, then after
    you P)aste each new element, you can use the F4 function to automatically
    assign the segment of the new block to a new range of hardware segment
    numbers.

    If you are mapping an existing display configuration, it may be useful to
    write a small program on the target system which allows you to step an ON
    segment through the display memory. This way you can simply step to each
    new address, view the display segment, and click the corresponding segment
    on the PC view to map that segment.
    LCDtools                                                         Page: 7


    2.3.3 3 - Assign software mapping

    Once you have all display segments mapped to their corresponding hardware
    address, you need to assign the software addresses. Keep in mind that the
    software addresses should be laid out in a manner which allows character
    generation. For example, if you have a display composed of several 5x5 dot
    matrix characters, you might want the first character to be assigned software
    addresses 1-25, the second 26-50, the third 51-75 etc.

    In this example, you could calculate the starting address of any character
    position by simply multiplying the character position by 25. As long as each
    character position has the same relative mapping, all you need to do to write
    a specific character on the display at that position is to copy the 25 bits
    from the corresponding character generator table entry into the display memory
    starting at that address.

    You can use the F5 function to assign software addresses to individual
    hardware segments, or the F6 function to automatically scan a block of
    segments and automatically assign software addresses in a left-to-right,
    top-to-bottom matrix.

    2.3.4 4 - Verify the LCD Layout

    Use the F8 function to audit the LCD layout.

    - There should be NO duplicate MAP addresses. This is an error and
      will result in a bad map table.
    - There should be NO skipped map addresses. If this occurs, the map
      table will still be correct, however it will contain zero entries
      for the unused map locations, which wastes space, and would require
      that your application driver be able to handle these special cases.
    - There may or may not be skipped hardware segment addresses. Make
      sure any segments reported are in fact NOT used on your display.

    Be sure to correct any problems in the LCD layout before proceeding.

    2.3.5 4 - Define character generators

    Use the F7 functon to activate a character generator editor, select a
    suitable display element (dot-matrix character for example), then simply
    click on segments to turn them ON/OFF for each character position. (It
    helps to use DEL-Zoom to view a large image of just that character
    position).

    Be sure to save your character generator before you exit.

    Repeat this step for each type of display element for which you need a
    character generator table.

    2.3.6 5 - Build the Bit->Hardware map table

    Use the LCM command to create an assembly language source file containing
    the logical-bit to hardware-display-address table that your target will
    need to address the LCD.
    LCDtools                                                         Page: 8


    2.3.7 6 - Build the Character Generator tables

    Use the LCG command to create assembly language source files containing
    the character generator Character-Code to Bit-Pattern tables that your
    target system will need to translate character codes into displayed
    characters.

    2.3.8 7 - Write application drivers

    Write the software drivers for your target application which will use
    the above tables to provide simple and straightforward logical addressing
    and character output to your LCD screen.
    LCDtools                                                         Page: 9


    3. EMULATION COMMANDS

    When operating in emulation mode (F9 command), the following single byte
    commands are accepted from the target system via the serial line:

            0xxxxxxx    - ASCII data
            10000000    - Clear LCD screen
            100xxxxx    - Report event flag (xxxxx=00001-11111 [1-31])
            101xxxxx    - Set high segment address
            110xxxxx    - Turn segment OFF
            111xxxxx    - Turn segment ON

       3.1 ASCII data

             All ASCII data received from the serial port  is  displayed  in
          the text portion of  the  screen.  NOTE:  This  portion  does  NOT
          scroll...  When the display advances to a  new  line,  the  screen
          wraps to the top of the display area if it was previously  on  the
          bottom line, and the new display line is cleared.

       3.2 Clear LCD screen

             This command causes all segments of the emulated LCD  panel  to
          be turned OFF.

       3.3 Report event flag

             Displays the string "[n]" (n=1-31) in the text window using the
          color RED. This provides a simple 1-byte way of reporting up to 31
          different software events.

       3.4 Set high segment address

             This command sets the upper  5  bits  of  the  10  bit  segment
          address (segments are numbered from 0 to 1023).  This command does
          not have to be sent for every segment update. It need only be sent
          when the upper 5 bits of the segment  number  to  be  updated  has
          changed.

       3.5 Turn segment OFF

             Use the lower 5 bits included in this command and the higher  5
          bits sent previously to determine a 10 bit segment number (0-1023)
          and turns that logical  segment  OFF  (Note:  The  segment  number
          refers to the software mapping number assigned by the LCD editor).

       3.6 Turn segment ON

             Use the lower 5 bits included in this command and the higher  5
          bits sent previously to determine a 10 bit segment number (0-1023)
          and turns that logical segment ON (Note: The segment number refers
          to the software mapping number assigned by the LCD editor).
    LCDtools                                                         Page: 10


    4. LCM - MAP TABLE BUILD UTILITY

       The LCM utility is used to build the software ->  hardware map  table
       which is used by your application driver to address the LCD panel  in
       a logical way.

       The output of LCM is assembly language source code,  which is written
       to the standard output device. You can redirect this output to a file
       with the '>' command line operator:

                    eg: LCM lcd_file [options] >output_file

       'lcd-file'  is the name of  the  .LCD  file  created  using  the  LCD
       utility.  It contains the complete  segment/mapping  definitions  for
       your LCD.

       'output_file'  is the name of a new file to receive the  LCD  mapping
       table in the form of assembly source code.

       4.1 Command Line Options

        -I        = "Intel format" when this option is specified, hex
                    byte values are written to the output file in the
                    form: 0xxh where 'xx' is the hex value. When this
                    option is NOT specified, output values are in the
                    form '$xx'.

        -L        = "Little endian" when this option is used, 16 bit
                    values are reversed before output. This may be
                    needed for systems which expect word values to
                    occur low byte first.

        -R        = "Reverse bit masks". For the output formats which
                    contain a bit mask, this reverses the mask, so that
                    bit 7 becomes bit 0 and vice versa.

        C=text    = "opening Comment". This option causes LCM to insert
                    a comment containing the specified text at the start
                    of the output file. Note that the '_' character will
                    be translated to a space.

        D=text    = "Define directive". Sets the assembly language
                    directive that LCM will use to define bytes/words.

        F=n       = "output Format". Specifies the type of output data that
                    will be generated for each table entry:
                    1 = single byte address     :       DB  $12
                    2 = byte address.bit-mask8  :       DB  $53,$40
                    3 = word address.bit-mask8  :       DB  $01,$36,$20
                    4 = word address            :       DW  $0157
                    5 = word address.bit-mask16 :       DW  $0115,$8000

        L=n       = "operand Length". Specifies the length (in characters)
                    of each output operand at which LCM will begin a new line.

        N=text    = "Name". Causes LCM to output a symbolic label containing
                    this name at the beginning of the table.
    LCDtools                                                         Page: 11


        O=hex     = "Offset". Specify an offset (in hex) which LCM will add
                    to each table address before output.

        S=hex     = "Step". Specify the distance (in hex memory locations)
                    between each address within the hardware LCD memory.

          LCM will generate one table entry for each logical  (map)  address
          defined within  the  LCD  module.  This  entry  will  contain  the
          physical hardware address for the  corresponding  segment  in  the
          selected format.  The most commonly used format is an address  and
          bit mask.  The address  represents  the  memory  location/register
          within the  LCD  controller,  and  the  bit  mask  represents  the
          individual bit which  must  be  set/cleared  to  turn  ON/OFF  the
          segment.

       4.2 Example Table Processing

          For example,  when the software wishes to turn ON logical  segment
          number 123,  it would look in entry  number  123  of  the  mapping
          table, where it might find:  $57,$04.  These entries indicate that
          bit 2  (mask=04)  must be set in location  $57  to  turn  on  this
          segment.

          Example RTS8505 code (6502 core) to do this, given that the memory
          location LCDADR contains  the  logical  bit  address  within  this
          table,  the  following  code  might  be  used  to  turn   on   the
          corresponding segment:

                LDY     #0                  ; Zero offset
                LDA     [LCDADR],Y          ; Read LCD hardware address
                TAX                         ; X = LCD address
                INY                         ; Advance to mask
                LDA     [LCDADR],Y          ; Read the bit mask
                ORA     0,X                 ; Set this bit
                STA     0,X                 ; Set new value

          To clear the bit, you might use:

                LDY     #0                  ; Zero offset
                LDA     [LCDADR],Y          ; Get LCD hardware address
                TAX                         ; X = LCD address
                INY                         ; Advance to mask
                LDA     [LCDADR],Y          ; Read the masl
                EOR     #%11111111          ; Invert for AND
                AND     0,X                 ; Remove the bit
                STA     0,X                 ; Set new value
    LCDtools                                                         Page: 12


    5. LCG - CHARACTER GENERATOR BUILD UTILITY

       The LCG utility is used  to  build  the  character  generator  bitmap
       table(s)  which are  used  by  the  application  to  write  arbitrary
       characters onto the LCD screen through the logical mapping table.

       The output of LCG is assembly language source code,  which is written
       to the standard output device. You can redirect this output to a file
       with the '>' command line operator:

                    eg: LCG lcg_file [options] >output_file

       'lcg-file'  is the name of  the  .LCG  file  created  using  the  LCD
       utility, containing a character generator definition.

       'output_file'  is the name of a new file  to  receive  the  character
       generator bitmap table in the form of assembly source code.

       5.1 Command Line Options

        -I        = "Intel format" when this option is specified, hex
                    byte values are written to the output file in the
                    form: 0xxh where 'xx' is the hex value. When this
                    option is NOT specified, output values are in the
                    form '$xx'.

        -R        = "Reverse bit pattern". Causes LCG to write the bit
                    pattern with the first bit in bit-0 of each byte.
                    If this option is NOT specified, LCG writes the first
                    bit in bit 7 of each byte.

        C=text    = "opening Comment". This option causes LCG to insert
                    a comment containing the specified text at the start
                    of the output file. Note that the '_' character will
                    be translated to a space.

        D=text    = "Define directive". Sets the assembly language
                    directive that LCM will use to define bytes.

        L=hex     = "Low bound character". Specifies the first character
                    code for which LCG will begin generating table entries.
                    If not specified, the lowest character position defined
                    in the character generator is used.

        H=hex     = "High bound character". Specifies the last character
                    code for which LCG will geneate table entries. If not
                    specified, the highest character position defined in
                    the character generator is used.

        N=text    = "Name". Causes LCG to output a symbolic label containing
                    this name at the beginning of the table.

          The tables produced by LCG contain the bit pattern which  must  be
          written to the logical LCD segments to produce  the  corresponding
          character.
    LCDtools                                                         Page: 13


       5.2 Example Character Processing

          Lets assume:

          - An LCD mapped  with  a  10  character  5x5  dot  matrix  display
            beginning at logical segment 98.  Each 5x5 character consists of
            25 dots,  which are mapped such that the  first  digit  is  dots
            98-122, second digit is dots 123-147,  the third is dots 148-172
            an so on.

          - A 5x5 dot matrix character  generator  is  defined.  This  table
            spans the characters from 'space' ($20) to 'Z' ($5A).

          - We would like to display the character 'A' in the 3rd dot matrix
            location.

          First,  we need to compute the logical bit address for the 3rd dot
          matrix character.  To do this,  we multiply the number  of  digits
          occuring BEFORE the character  we  desire  by  the  size  of  each
          character in bits,  and  add  the  offset  to  the  start  of  the
          dot-matrix display:

                     2          <= Characters before 3rd
                x   25          <= Dots / character
                ------
                =   50          <= Total # of dots before this character
                +   98          <= Beginning address of dot matrix
                ------
                =  148          <= Beginning address of 3rd character

          Then,  we need to find the character generator table entry for the
          character 'A'.  To do this,  we take the character code  ('A'=$41)
          and subtract the first character in the table  (in this case,  our
          table starts at $20).  The result must be multipled by the size of
          each table entry,  which in this case is 4 bytes  (25 bits needs 4
          bytes):

                   $41          <= 'A' code
                -  $20          <= First code in table (space)
                ------
                =  $21          <= # of characters into table
                *    4          <= # of bytes/entry
                ------
                   $84          <= Offset into table where 'A' starts

          Then,  to draw the  'A'  on the LCD screen at the 3rd  dot  matrix
          character position,  we simply read the 25 bits at offset  $84  in
          the character generator table,  and write those bits  through  the
          logical mapping table beginning at dot position 148  ($94  hex)...
          Voila! the character  'A'  will  appear  at  the  3rd  dot  matrix
          character position.
    LCDtools                                                         Page: 14


    6. SAMPLE FILES

       The following sample files are included with this package:

       6.1 PANEL1.LCD

          This is the layout of the actual  562  segment  LCD  for  which  I
          originally created LCD tools.  This  was  attached  to  a  RealTek
          RTS8505 Caller ID using exactly the segment  mapping  shown.  Note
          the haphazard hardware addressing,  including many segments  which
          are simply "skipped" in the hardware map.

       6.2 PANEL2.LCD

          This is a prototype LCD  panel  for  a  feature  telephone,  which
          incorporates  dot  matrix,  7  segment  numeric  and  16   segment
          alphanumeric displays.  Since this is  a  prototype,  no  physical
          display exists  (yet),  and no hardware mapping is  available.  To
          easily  map  this  display,  I  simply  created  the  segments  in
          "logical"  order and used the M)ap H)ardware function to  map  the
          display 1-1.

          When the actual LCD gets laid out and  I  have  the  hardware  map
          information, I will simply re-address and re-map the display using
          LCD Tools.

       6.3 25DOT.LCG

          This is a 25 dot (5x5) dot-matrix character generator, which spans
          ASCII codes from $20 (space) to $60 (`).  It can be used on either
          PANEL1 or PANEL2.

       6.4 7SEG.LCG

          This is a 7 segment character generator which  spans  ASCII  codes
          from $20 to $60 (`).  Although not all of these codes will be used
          (some letters are a bit odd),  having the same character generator
          size for all three display areas in PANEL2  allow  me  to  have  a
          single character output function  which  selects  the  appropriate
          character generator table based on the  logical  display  address.
          This character generator can be used on either PANEL1 or PANEL2.

       6.5 16SEG.LCG

          This is a 16 segment character generator which  also  spans  ASCII
          codes from $20 to $60  (`).  It is applicable to PANEL2  only,  as
          PANEL1 does not have any 16 segment alphanumeric display elements.
