lcd_driver_st7565.c

//--------------------------------------------------------------------

//

// OpenDCC

// Throttle MFT 1.0

//

// Copyright (c) 2009 Wolfgang Kufer

//

// This source file is subject of the GNU general public license 2,

// that is available at the world-wide-web at

// http://www.gnu.org/licenses/gpl.txt

//

// This code is initially based on:

// http://www.mikrocontroller.net/topic/75589

// it runs as driver for Sami Varjo's gLCD lib functions

// available from sourceforge.net

//

// Here we do the access to a graphic lcd display, no special functions

// for MFT contained (so this is a general purpose file)

//

//--------------------------------------------------------------------

//

// file:      lcd_driver_st7565.c

// author:    Wolfgang Kufer

// contact:   kufer@gmx.de

// webpage:   http://www.opendcc.de

// history:   2009-03-24 V0.01 kw  start

//            2009-03-27 V0.02 kw  font proportional added

//            2009-04-04 V0.03 kw  cursor control added

//            2009-04-06 V0.04 kw  cursor in housekeeping integriert, blinkend

//            2009-07-05 V0.05 kw  forced reinit of SPI

//            2010-07-12 V0.06 kw  added LCD_pixelPattern

//            2011-07-09 V0.07 kw  bugfix in update_display_page von Thomas Finn 

//

//--------------------------------------------------------------------

//

// purpose:   control of a spi driven graphic display

//            Controller: EA DOGM128, ST7565, 6B1713 

//

// Interface: downstream: we use hardware SPI, all data transfer is done

//                        with SPI_xmit. This must run with no other

//                        SPI access in between - so in a real time os

//                        you must use a mutex here.

//                        Note: cortos is preemptiv - no mutex needed

//

//            upstream: basic graphic print functions

//

//--------------------------------------------------------------------

// Howto:

//   All printing and drawing goes to internal ram.

//   These routines keep track of the changed area.

//   A separate task is used to update the real display

//   from this memory (see housekeeping)

//

// Reason:

//   a) display is write only (when running on SPI)

//   b) display content will not flicker during repaint

//-----------------------------------------------------------------

// Hardware:  we need SPI (Chip select: SPI_ENABLE_LCD)

//            we need to control line A0 (SPI_ADR0_LOW;SPI_ADR0_HIGH;)

//            

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/eeprom.h>

#include <avr/pgmspace.h>        // put var to program memory

#include <util/delay.h>

#include <stdio.h>

#include "config.h"

#include "cortos.h"

#include "hardware.h"           // CS for SPI

#include "timer.h"

#include "lcd_font5x7.h"

#define FONT5x7_START      0x00  // was 0x20

#define FONT5x7_END        0x7F 

#include "lcd_driver_st7565.h"

#if (DISPLAY == LCD_EA128x64)

//------------------------------------------------------------------------

// hardware settings

//------------------------------------------------------------------------

#define LCD_CONTRAST_DEFAULT    22          // electronic contrast

                                            // default, if we don't have a eeprom

#define EA_DOGM_SINGLE_SUPPLY    1          // 0: init for dual supply

                                            // 1: init for single supply

#define EA_DOGM_TOPVIEW          0          // 0: bottom view (6:00)

                                            // 1: top view (12:00)

#define EA_DOGM_SOFTRESET        1          // 0: hardware pin

                                            // 1: we do software reset

//------------------------------------------------------------------------

//

// Global variables used by driver

//

//------------------------------------------------------------------------

//

//      0 1 2  .....................  127

//     |---------------------------------|

//    0|(0,0)      |                     | 127

//  128|           y                     |

//     |           |                     |

//     |           v                     |

//     |---- x --->*                     |

//     |                                 |

//     |                                 |

//  896|                         (127,63)|1023

//     |---------------------------------|

//

// The display is organized in 8 pages - 8 pixel high, 128 pixel wide.

// defines see header file

// 

// RAM data organisation: left to right; top to bottom

// (this is more efficient for font copying)

//

// Pixel(x,y):          index = (y/8)*128 + x

//                            = ((y & ~0x07) << 4 + x

//                      bit   = y%8

//                            = (y & 0x07)

// Set pixel (x,y):     video_ram[(y & ~0x07) * (LCD_LINE_LENGTH/LCD_PAGE_HEIGHT) + x] |=  (1 << (y & 0x07));

// Clear pixel (x,y):   video_ram[(y & ~0x07) * (LCD_LINE_LENGTH/LCD_PAGE_HEIGHT) + x] &= ~(1 << (y & 0x07));

#define LCD_PAGE_HEIGHT     8   //8 lines per page

#define LCD_LINES          64

#define LCD_LINE_LENGTH   128

static uint8_t video_ram[1024];

uint8_t LCD_currentX;           // cursor

uint8_t LCD_currentY;

//-----------------------------------------------------------------------------

// Mode

unsigned char display_invers = 0;   // this is either 0 or 0xFF

                                    // 00: print font bitmap as is

                                    // ff: print inverted 

unsigned char display_keep = 0;     // this is either 0 or 0xFF 

                                    // 00: replace video content

                                    // ff: keep video content             

//-----------------------------------------------------------------------------

// Cursor

uint8_t cursor_is_on_display;   // cursor currently on display

uint8_t CursorActive;           // cursor task could be enabled

uint8_t Cxmin, Cxmax;           // Cursor is a line from Cxmin to Cxmax

uint8_t Cy, CyPage, CyPattern;  // Cursor page and pattern

//------------------------------------------------------------------------

//

// raw hardware functions (only used by "disp_..."-functions)

//

//------------------------------------------------------------------------

// register defines

#define ST7565R_RESET                           0xE2

#define ST7565R_ADC_SELECT                      0xA0

#define ST7565R_COMMON_OUTPUT_MODE              0xC0

#define ST7565R_DISPLAY_NORMAL                  0xA6

#define ST7565R_DISPLAY_INVERS                  0xA7

#define ST7565R_LCD_BIAS_SET_1_9                0xA2

#define ST7565R_LCD_BIAS_SET_1_7                0xA3

#define ST7565R_POWER_CONTROL_SET               0x28

#define ST7565R_BOOSTER_MASK                    0x04

#define ST7565R_REGULATOR_MASK                  0x02

#define ST7565R_FOLLOWER_MASK                   0x01

#define ST7565R_BOOSTER_RATIO_SET               0xF8

#define ST7565R_BOOSTER_STEP_UP_2x3x4x          0x00

#define ST7565R_BOOSTER_STEP_UP_5x              0x01

#define ST7565R_BOOSTER_STEP_UP_6x              0x03

#define ST7565R_V0_VOLTAGE_REG_RATIO            0x20

#define ST7565R_DISPLAY_ON_OFF                  0xAE

#define ST7565R_SLEEP_MODE_SET                  0xAC

#define ST7565R_ELECTRONIC_VOLUME_MODE_SET      0x81

#define ST7565R_ELECTRONIC_VOLUME_REGISTER_SET  0x00

#define ST7565R_DISPLAY_START_LINE              0x40

#define ST7565R_SET_PAGE_ADDR                   0xB0

#define ST7565R_SET_COLUMN_NIBBLE_H             0x10

#define ST7565R_SET_COLUMN_NIBBLE_L             0x00

static void cursor_init();

//-----------------------------------------------------------------------------

// SPI access

//-----------------------------------------------------------------------------

static inline void SPI_init(void)

  {

    // Enable SPI, Master, set clock rate fck/16

    // ST7565 has fast SPI (up to 20MHz), no need to slow down SPI

    // our F_CPU is 10 MHz, so we use fcpu/2; a transfer lasts 1,6us 

    #define SPI_PRESCALER  2

    #if   (SPI_PRESCALER==2)

      #define SPI_PRESCALER_BITS   ((0<<SPR1)|(0<<SPR0))

      #define SPI2XMUL             (1 << SPI2X)

    #elif (SPI_PRESCALER==4)

      #define SPI_PRESCALER_BITS   ((0<<SPR1)|(0<<SPR0))

      #define SPI2XMUL             (0 << SPI2X)

    #elif (SPI_PRESCALER==8)

      #define SPI_PRESCALER_BITS   ((0<<SPR1)|(1<<SPR0))

      #define SPI2XMUL             (1 << SPI2X)

    #elif (SPI_PRESCALER==16)

      #define SPI_PRESCALER_BITS   ((0<<SPR1)|(1<<SPR0))

      #define SPI2XMUL             (0 << SPI2X)

    #elif (SPI_PRESCALER==32)

      #define SPI_PRESCALER_BITS   ((1<<SPR1)|(0<<SPR0))

      #define SPI2XMUL             (1 << SPI2X)

    #elif (SPI_PRESCALER==64)

      #define SPI_PRESCALER_BITS   ((1<<SPR1)|(0<<SPR0))

      #define SPI2XMUL             (0 << SPI2X)

    #elif (SPI_PRESCALER==128)

      #define SPI_PRESCALER_BITS   ((1<<SPR1)|(1<<SPR0))

      #define SPI2XMUL             (0 << SPI2X)

    #else

      #error SPI_PRESCALER is not defined or is not a supported value

    #endif

    SPCR = (0 << SPIE)    // 0 = no interrupt

         | (1 << SPE)     // 1 = enabled

         | (0 << DORD)    // 1 = data order LSB first; 0 = msb first

         | (1 << MSTR)    // 1 = master mode

         | (0 << CPOL)    // 0 = clock low when idle

         | (0 << CPHA)    // 0 = sample a leading edge

         | SPI_PRESCALER_BITS;

    SPSR = (SPI2XMUL);

  }

static unsigned char SPI_xmit (unsigned char aData) 

  {

    // sendchar(aData); // mirror to usb, debug only

    // here we do write only, so mormally no need to wait after xmit

    // we wait, since: we must ensure SPI_CS is kept low, otherwise

    // we would need a mutex.

    SPI_init();                    // only two accesses - but make sure we the correct setup!

    SPI_ENABLE_LCD;                // CS low

    SPDR = aData;                    

    while(!(SPSR & (1<<SPIF)));

    SPI_DISABLE_LCD;

    return (SPDR);          

  }

void dogm_send_command(unsigned char command)

  {

    SPI_ADR0_LOW;           //  clear A0-Bit -> command

    SPI_xmit(command);

  }  

void dogm_send_display(unsigned char data)

  {

    SPI_ADR0_HIGH;          //  set A0-Bit -> Display data

    SPI_xmit(data);

  }  

void dogm_reset()

  {

    #if (EA_DOGM_SOFTRESET == 1)

        dogm_send_command( ST7565R_RESET );

        _delay_ms(50);

    #else

        RES_PORT &= ~(1<<RES_BIT); // RES\ = LOW (Reset)

        _delay_ms(50);

        RES_PORT |= (1<<RES_BIT); // RES\ = HIGH (kein Reset)

    #endif

  }

void LCD_contrast(uint8_t contrast)

{

  /* "electronic volume" */

  dogm_send_command( ST7565R_ELECTRONIC_VOLUME_MODE_SET );

  dogm_send_command( ST7565R_ELECTRONIC_VOLUME_REGISTER_SET | ( contrast & 0x3F ) );

}

void dogm_sleep( uint8_t sleep )

{

  dogm_send_command( ST7565R_SLEEP_MODE_SET );

  if (sleep)  dogm_send_command(1);

  else        dogm_send_command(0);     // alive

}

void lcd_init(void)

  {

    uint8_t contrast;

    #ifdef eadr_lcd_contrast

       contrast = eeprom_read_byte((void *)eadr_lcd_contrast);

       if (contrast == 0 || contrast > 0x3F)

         // obviously void

         contrast = LCD_CONTRAST_DEFAULT;

    #else

       contrast = LCD_CONTRAST_DEFAULT;

    #endif

    SPI_init();

  //RESET Display

  dogm_reset();

  //Display start line

  dogm_send_command(ST7565R_DISPLAY_START_LINE | 0);          // Display start line 0

    #if (EA_DOGM_TOPVIEW == 1)

        dogm_send_command( ST7565R_ADC_SELECT | 0);             // ADC set normal

        dogm_send_command( ST7565R_COMMON_OUTPUT_MODE | 0x08 ); // Common output mode revers COM63-COM0

    #else // //Bottom view, default

        dogm_send_command( ST7565R_ADC_SELECT | 1 );            // ADC set reverse

        dogm_send_command( ST7565R_COMMON_OUTPUT_MODE | 0 );    // Common output mode normal COM0-COM63

    #endif // EA_DOGM_TOPVIEW 

  dogm_send_command(ST7565R_DISPLAY_NORMAL);                  // Display normal / invers

  //Hardware options

  dogm_send_command(ST7565R_LCD_BIAS_SET_1_9);                // Set bias 1/9 (Duty 1/65)

    #if (EA_DOGM_SINGLE_SUPPLY == 1)

        dogm_send_command( 

            ST7565R_POWER_CONTROL_SET | 

            ST7565R_BOOSTER_MASK |                              // booster on

            ST7565R_REGULATOR_MASK |                            // regulator on

            ST7565R_FOLLOWER_MASK );                            // follower on

        dogm_send_command( ST7565R_BOOSTER_RATIO_SET );         // internal booster to 4x

        dogm_send_command( ST7565R_BOOSTER_STEP_UP_2x3x4x );

    #else // dual supply 

        dogm_send_command( 

        ST7565R_POWER_CONTROL_SET |                             // booster off, regulator and follower on

        ST7565R_REGULATOR_MASK | ST7565R_FOLLOWER_MASK );

    #endif

  dogm_send_command(ST7565R_V0_VOLTAGE_REG_RATIO | 0x07 );    // V0 resistor-ratio (see table 11, here 6.5 -> 0b111 = 0x07)

  LCD_contrast(contrast);

  dogm_sleep(0);

  dogm_send_command(ST7565R_DISPLAY_ON_OFF | 1);              // Display on

    cursor_init();

  }

void lcd_reset(void)

  {

    dogm_reset();

  }

//------------------------------------------------------------------------------

//

// Housekeeping

//

//------------------------------------------------------------------------------

// These routines try to update the video_ram to the lcd

//

volatile uint8_t update_blocked;

t_update_lcd update_lcd[LCD_LINES / LCD_PAGE_HEIGHT ];

/*

struct

  {

    uint8_t page_modified;

  } update_lcd[LCD_LINES / LCD_PAGE_HEIGHT ];

*/

void update_display_page(unsigned char page)

  {

    dogm_send_command(ST7565R_SET_PAGE_ADDR + page);    // Set page address to <page>

    dogm_send_command(ST7565R_SET_COLUMN_NIBBLE_H + 0); // Set column address to 0 (4 MSBs)

    #if (EA_DOGM_TOPVIEW == 1)  

        dogm_send_command(ST7565R_SET_COLUMN_NIBBLE_L + 4); // Shift column address to 4 (4 LSBs) while ST7565 is 132x65 Controller

    #else

        dogm_send_command(ST7565R_SET_COLUMN_NIBBLE_L + 0); // Set column address to 0 (4 LSBs)

    #endif  

    uint8_t column;

    if (cursor_is_on_display && (page == CyPage))   // with cursor

      {

        for (column = 0; column < Cxmin; column++)

          {

            dogm_send_display(video_ram[page * LCD_LINE_LENGTH + (column)]);

          }

        for (column = Cxmin; column < Cxmax; column++)

          {

            dogm_send_display(video_ram[page * LCD_LINE_LENGTH + (column)] ^ CyPattern);

          }

        for (column = Cxmax; column < LCD_LINE_LENGTH; column++)

          {

            dogm_send_display(video_ram[page * LCD_LINE_LENGTH + (column)]);

          }

      }

    else                                            // normal

      {

        for (column = 0; column < LCD_LINE_LENGTH; column++)

          {

            dogm_send_display(video_ram[page * LCD_LINE_LENGTH + (column)]);

          }

      }

    update_lcd[page].page_modified = 0;

  }

// see cortos.h 

// This is the TASK_DISPLAY

// scan through the pages and if a page is modified: do the update

// if all pages are done: set inactive

t_cr_task update_display(void)

  {

    if (update_blocked) return(-1);     // fall asleep

    uint8_t page;

    for (page = 0; page < LCD_LINES / LCD_PAGE_HEIGHT; page++)

      {

        if (update_lcd[page].page_modified)

          {

            update_display_page(page);

            return(0);                  // ready again

          }

      }

    return(-1);                         // all up to date, fall asleep

  }

// call this function at end of your display routines

void enable_display_update(void)

  {

    update_blocked = 0;

    #ifdef _CORTOS_H_

        set_task_ready(TASK_DISPLAY);

    #else

        while (update_display() >= 0) {}

    #endif

  }

// complete update, no conditions; could be used in non cortos environment

// warning: this lasts 1,6ms

void update_display_complete(void)

  {

    uint8_t page;

    for (page = 0; page < LCD_LINES / LCD_PAGE_HEIGHT; page++)

      {

        update_display_page(page);

      }

  }

//------------------------------------------------------------------------------

//

// Upstream Interface

//

//------------------------------------------------------------------------------

// every access to video_ram must:

//   a) block the update process

//   b) set to corresponding page to modified

//

// when a display sequence is complete, it must enable the update

//

static void _blockcomplete(void)   // local helper functions

  {

    uint8_t page;

    for (page = 0; page < LCD_LINES / LCD_PAGE_HEIGHT; page++)

      {

        update_lcd[page].page_modified = 1;

      }

    update_blocked = 1;

  }

void LCD_clr(void)                   //clear LCD memory

  {

    _blockcomplete();

    uint16_t i;

    for (i=0; i<sizeof(video_ram); i++)

      {

        video_ram[i] = 0;

      }

    LCD_currentX = 0;

    LCD_currentY = 0;

    cursor_is_on_display = 0;

  }

void lcd_clear(void)

  {

    LCD_clr();

  }

void LCD_fill_with_counter(void)

  {

    _blockcomplete();

    uint16_t i;

    for (i=0; i<sizeof(video_ram); i++)

      {

        video_ram[i] = (unsigned char) i;

      }

  }

//------------------------------------------------------------------------------

// Copy a complete screen (no checking)

// bitmap_P points to bitmap in flash

// The bitmap must be organized like our page.

void LCD_fill_with_BMP(uint8_t* bitmap_P)

  {

    _blockcomplete();

    uint16_t i;

    for (i=0; i<sizeof(video_ram); i++)

      {

        video_ram[i] = pgm_read_byte(&bitmap_P[i]);

      }

  }

//------------------------------------------------------------------------------

//Move cursor to position x y (in pixels)

void LCD_setCursorXY(uint8_t x, uint8_t y)

  {

    LCD_currentX = x;

    LCD_currentY = y;

  }

void LCD_getCursorXY(uint8_t* x, uint8_t* y)

  {

    *x = LCD_currentX;

    *y = LCD_currentY;

  }

//------------------------------------------------------------------------------

//Write a byte to LCD.  Single 8 bit segment is send to current cursor position

//(page aligned!)

void LCD_writeByte(uint8_t data)

  {

    update_blocked = 1;

    uint8_t page;

    page = LCD_currentY / LCD_PAGE_HEIGHT;

    update_lcd[page].page_modified = 1;

    video_ram[page * LCD_LINE_LENGTH + LCD_currentX] = data;

    LCD_currentX++;

}

//------------------------------------------------------------------------------

// Pixel at x y

void LCD_pixelOn(uint8_t x, uint8_t y)

  {

    update_blocked = 1;

    uint8_t page;

    page = y / LCD_PAGE_HEIGHT;

    update_lcd[page].page_modified = 1;

    video_ram[page * LCD_LINE_LENGTH + x] |=  (1 << (y & 0x07));

  }

void LCD_pixelOff(uint8_t x, uint8_t y)

  {

    update_blocked = 1;

    uint8_t page;

    page = y / LCD_PAGE_HEIGHT;

    update_lcd[page].page_modified = 1;

    video_ram[page * LCD_LINE_LENGTH + x] &=  ~(1 << (y & 0x07));

  }

t_LCD_linePixel LCD_linePixel = 

  {

    1,  // Mode

    1,  // OffAct

    1,  // OffCount

    1,  // OnAct

    1,  // OnCount

  };

void LCD_pixelPattern(uint8_t x, uint8_t y)

  {

    if (LCD_linePixel.Mode)

      {

        LCD_linePixel.OnAct++;

        if (LCD_linePixel.OnAct >= LCD_linePixel.OnCount)

          {

            LCD_linePixel.OffAct = 0;

            LCD_linePixel.Mode = 0;

          }

        LCD_pixelOn(x, y);

      }

    else

      {

        LCD_linePixel.OffAct++;

        if (LCD_linePixel.OffAct >= LCD_linePixel.OffCount)

          {

            LCD_linePixel.OnAct = 0;

            LCD_linePixel.Mode = 1;

          }

        LCD_pixelOff(x, y);   

      }

  }

//------------------------------------------------------------------------------

//Invert pixel value at x y

void LCD_invertPixel(uint8_t x, uint8_t y)

  {

    update_blocked = 1;

    uint8_t mask;

    uint8_t page;

    page = y / LCD_PAGE_HEIGHT;

    update_lcd[page].page_modified = 1;

    mask = video_ram[page * LCD_LINE_LENGTH + x];

    if (mask & (1<<(y&0b111))) mask &= ~(1<<(y&0b111));

    else                       mask |= (1<<(y&0b111));

    video_ram[page * LCD_LINE_LENGTH + x] = mask;

}

//------------------------------------------------------------------------------

//Turn pixels on in a single page in LCD DDRAM from x1 to x2

void LCD_onPage(uint8_t page, uint8_t x1, uint8_t x2)

  {

    update_blocked = 1;

    update_lcd[page].page_modified = 1;

    uint8_t i;

    for (i=x1; i<=x2; i++)

      {

        video_ram[page * LCD_LINE_LENGTH + i] = 0xff;

      }

  }

//------------------------------------------------------------------------------

//invert pixels on a page from x1 to x2

// x1 must be smaller than x2

void LCD_invertPage(uint8_t page, uint8_t x1, uint8_t x2)

  {

    update_blocked = 1;

    uint8_t mask,i;

    update_lcd[page].page_modified = 1;

    for (i=x1; i<=x2; i++)

      {

        mask = video_ram[page * LCD_LINE_LENGTH + i];

        video_ram[page * LCD_LINE_LENGTH + i] = ~mask;

      }

}

//------------------------------------------------------------------------------

//clear a single page in LCD DDRAM from x1 to x2

void LCD_offPage(uint8_t page, uint8_t x1, uint8_t x2)

  {

    update_blocked = 1;

    uint8_t i;

    update_lcd[page].page_modified = 1;

    for (i=x1; i<=x2; i++)

      {

        video_ram[page * LCD_LINE_LENGTH + i] = 0x00;

      }

  }

//------------------------------------------------------------------------------

// Copy a 8 bit high bmp to page

// bitmap_P points to bitmap in flash, page correct

void LCD_fillPage_with_BMP(uint8_t width, PGM_VOID_P bitmap_P)

  {

    update_blocked = 1;

    uint8_t page;

    uint8_t upper_bound;

    page = LCD_currentY / LCD_PAGE_HEIGHT;

    update_lcd[page].page_modified = 1;

    if ((LCD_currentX + width) > LCD_LINE_LENGTH)

        upper_bound=LCD_LINE_LENGTH-1;

    else

        upper_bound = LCD_currentX + width;  

    for ( ; LCD_currentX < upper_bound; LCD_currentX++)

      {

        video_ram[page * LCD_LINE_LENGTH + LCD_currentX] = pgm_read_byte(bitmap_P++);

      }

  }

//-----------------------------------------------------------------------------

// put a graphical bitmap with width and height (given in pages)

// at LCD_currentX,LCD_currentY

// y must be page-aligned, input bitmap is page aligned

//

void LCD_drawBMP_aligned(PGM_VOID_P  bitmap_P, uint8_t width, uint8_t height)

{

  uint8_t saved_x,j;

  PGM_P my_bitmap = bitmap_P;

  //whole pages  

  saved_x = LCD_currentX;

  for (j=0; j < height; j++)

    {

      LCD_fillPage_with_BMP(width, &my_bitmap[j*width]);

      LCD_currentY += LCD_PAGE_HEIGHT;

      if(LCD_currentY>=LCD_LINES) LCD_currentY=0;

      LCD_currentX = saved_x;

    }

}

//-----------------------------------------------------------------------------

// put a graphical bitmap with width and height (given in first two locations of bitmap_P)

// at LCD_currentX,LCD_currentY

// input bitmap is page aligned

// parameters: display_keep, display_invers

//

void LCD_drawBMP(PGM_VOID_P  bitmap_P)

  {

    uint8_t page, pageoffset;

    uint8_t copy_width;

    uint8_t pixel_mask, and_mask, and_maskL, and_maskH;

    uint8_t j;

    PGM_P z_ptr = bitmap_P;

    update_blocked = 1;

    uint8_t width = pgm_read_byte(z_ptr++);

    int8_t height = pgm_read_byte(z_ptr++);

    // bound check

    if ((LCD_currentX + width) > LCD_LINE_LENGTH)    copy_width = LCD_LINE_LENGTH-LCD_currentX;

    else                                             copy_width = width; 

    if (copy_width == 0) return; 

    if ((LCD_currentY + height) > LCD_LINES)         height =  LCD_LINES-LCD_currentY;

    page = LCD_currentY / LCD_PAGE_HEIGHT;

    pageoffset = LCD_currentY & (LCD_PAGE_HEIGHT-1);

    and_maskL = 1 << pageoffset;

    and_maskL -= 1;                // aus pageoffset 3 wird dadurch 0b00000111

    while (height > 0)

      {

        update_lcd[page].page_modified = 1;

        // copy one page of char set to video_ram

        if ((pageoffset + height) < 8)

          {

            // mask on both sides required

            and_maskH = 1 << (pageoffset + height);        // z.B. 3 + 4

            and_maskH -= 1; 

            and_maskH = ~and_maskH;                         // z.B. 0b10000000

            pixel_mask = ~(and_maskL | and_maskH);          // z.B. 0b01111000

            and_mask = and_maskL | and_maskH | display_keep;

            for (j=0; j<copy_width; j++)

              {

                uint8_t temp;

                uint8_t pixels;

                pixels = pgm_read_byte(z_ptr+j) ^ display_invers;

                pixels = pixels << pageoffset;

                pixels &= pixel_mask;

                temp = video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j];

                temp &= and_mask;

                temp ^= pixels;

                video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j] = temp;

              }

          }

        else if ((pageoffset + height) == 8)

          {

            // mask only on lower bound required

            and_mask = and_maskL | display_keep;

            for (j=0; j<copy_width; j++)

              {

                uint8_t temp;

                uint8_t pixels;

                pixels = pgm_read_byte(z_ptr+j) ^ display_invers;

                pixels = pixels << pageoffset;

                temp = video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j];

                temp &= and_mask;

                temp ^= pixels;

                video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j] = temp;

              }

          }

        else

          {

            // two pages affected

            and_mask = and_maskL | display_keep;

            for (j=0; j<copy_width; j++)

              {

                uint8_t temp;

                uint8_t pixels;

                pixels = pgm_read_byte(z_ptr+j) ^ display_invers;

                pixels = pixels << pageoffset;                                  //es werden nullen nachgezogen

                temp = video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j];

                temp &= and_mask;

                temp ^= pixels;                                                 // einkopieren

                video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j] = temp;

              }

            // now next page (look at upper bound)

            page++;

            update_lcd[page].page_modified = 1;

            if (height < 8) and_maskH = 1 << (pageoffset + height - 8);

            else and_maskH = 1 << (pageoffset); 

            and_maskH -= 1;

            pixel_mask = and_maskH; 

            and_mask = ~and_maskH | display_keep;

            for (j=0; j<copy_width; j++)

              {

                uint8_t temp;

                uint8_t pixels;

                pixels = pgm_read_byte(z_ptr+j) ^ display_invers;

                pixels = pixels >> (8-pageoffset);

                pixels &= pixel_mask;

                temp = video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j];

                temp &= and_mask;

                temp ^= pixels;

                video_ram[page * LCD_LINE_LENGTH + LCD_currentX + j] = temp;

              }

            page--;

          }

        z_ptr += width;

        page++;

        height -= 8;

      }

    LCD_currentX = LCD_currentX + copy_width;

  }

//------------------------------------------------------------------------------

// Put a single char to LCD on line at current cursor position

// Note that page is used not exact coordinates 

// Default font is used, no checking of illegal chars

void LCD_putchar(uint8_t c)

  {

    update_blocked = 1;

    uint8_t i = 0;  

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

      {         

        if (LCD_currentX >= LCD_LINE_LENGTH)

          {

            if (LCD_currentY < LCD_LINES+LCD_PAGE_HEIGHT)

              {

                LCD_setCursorXY(0,LCD_currentY+LCD_PAGE_HEIGHT);

              }

            else 

              {

              LCD_setCursorXY(0,0);    

              }

          }

        LCD_writeByte(pgm_read_byte(&Font5x7[(c - FONT5x7_START)*Font5x7_WIDTH + i])); 

      }    

    LCD_writeByte(0x00);  

  }

//------------------------------------------------------------------------------

// Put a single char to LCD on line at current cursor position

// Note that page is used not exact coordinates 

// Proportional font is used, no checking of illegal chars

// IgnP (=Ignore Pattern) is a pixel pattern (typ. 0xAA) which determines the end of pixel map

// 

#define Font5x7prop_WIDTH       5

#define Font5x7prop_HEIGHT      7

void LCD_PF_putchar(uint8_t c)

  {

    update_blocked = 1;

    uint8_t i = 0;  

    uint8_t pixels;  

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

      {         

        if (LCD_currentX >= LCD_LINE_LENGTH)

          {

            if (LCD_currentY < LCD_LINES+LCD_PAGE_HEIGHT)

              {

                LCD_setCursorXY(0,LCD_currentY+LCD_PAGE_HEIGHT);

              }

            else 

              {

              LCD_setCursorXY(0,0);    

              }

          }

        pixels = pgm_read_byte(&Font5x7prop[(c - FONT5x7_START)*Font5x7prop_WIDTH + i]);

        if (pixels != IgnP) LCD_writeByte(pixels); 

      }    

    LCD_writeByte(0x00);  

  }

unsigned char LCD_PF_get_sizeX(uint8_t c)

  {

    uint8_t i = 0;  

    uint8_t pixels;  

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

      {         

        pixels = pgm_read_byte(&Font5x7prop[(c - FONT5x7_START)*Font5x7prop_WIDTH + i]);

        if (pixels == IgnP) return(i); 

      }    

    return(i);

  }

//---------------------------------------------------------------------------------

// Put a string on display - auto for next line is default (from LCD_putchar)

// null terminated strings are expected

// /n  for new line 

void LCD_puts(uint8_t* pString)

  {      

    update_blocked = 1;

    uint8_t i=0;

    while (pString[i] != '\0')

      {

        if (pString[i]=='\n')

          {           

            LCD_currentX=0;

            LCD_currentY+=LCD_PAGE_HEIGHT;    

          }

        else

          {

            LCD_putchar(pString[i]);

          }

        i++;    

      }

  }

//-----------------------------------------------------------------------------

//Put a string on selected page (line) starting at x

//

void LCD_putsp(uint8_t* pString, uint8_t page, uint8_t x)

  {

    LCD_currentX = x;

    LCD_currentY = page * LCD_PAGE_HEIGHT;

    LCD_puts(pString);

  }

//------------------------------------------------------------------------------

// printf - fixed font 4x6, only for numbers

#include "bmp/number_6px_glcd.h"

void LCD_number_6px(char* data)

  {

    char val;

    uint8_t i = 0; 

    while( (val = *data++ ) )

      {

        if (val == ' ') 

          {

            for(i=0; i < NUMBER_6PX_GLCD_WIDTH; i++)  LCD_writeByte(0x00); 

          }

        else if ( val >= '0' && val <= '9' ) 

          {

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