//!/////////////////////////////////////////////////////////////////////////
/// glcd.c                                                                //
///                                                                       //
/// Version:     0.6                                                      //
/// Date:        04/16/2010                                               //
/// Author:      Michael Skutek (michael@skutek.de)                       //
///                                                                       //
/// Description: 8 Bit Interface to GLCD displays with 128x64 dots        //
///              and KS0108 Controller.                                   //
///                                                                       //
/// Platform:    AVR ATmega (tested on ATmega16)                          //
///                                                                       //
/// Include Files:                                                        //
///              avr/io.h:             port accessing (part of avr-gcc)   //
///              util/delay.h:         time delays (part of avr-gcc)      //
///              port_definitions.h:   definition of output ports         //
///              glcd.h:               definitions and display setup      //
///              glcd_characters.h:    definitions for font(s)            //
///              glcd_bitmaps.h:       definitions for bitmaps            //
///                                                                       //
///                                                                       //
/// This program is free software: you can redistribute it and/or modify  //
/// it under the terms of the GNU Lesser General Public License as        //
/// published by the Free Software Foundation, either version 3 of the    //
/// License, or (at your option) any later version.                       //
///                                                                       //
/// This program is distributed in the hope that it will be useful,       //
/// but WITHOUT ANY WARRANTY; without even the implied warranty of        //
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          //
/// GNU Lesser General Public License for more details.                   //
///                                                                       //
/// You should have received a copy of the GNU Lesser General Public      //
/// License along with this program. If not, see                          //
/// <http://www.gnu.org/licenses/>.                                       //
//!/////////////////////////////////////////////////////////////////////////


#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>

#include "port_definitions.h"
#include "glcd.h"
#include "glcd_characters.h"
#include "glcd_bitmaps.h"





///global variables

//internal value for current setting
uint8_t row_pos, column_pos;   //display row and column - fitted to characters and pages
uint8_t controller, start_line, scrolling;





//!///////////////////////////////////////////////////////////////////////
///glcd_write_data                                                      //
///                                                                     //
/// Description:                                                        //
///         Sends a byte to GLCD (8 Bit Bus).                           //
///                                                                     //
/// input:                                                              //
///           data:     data byte to send                               //
///  controller_id:     ID of controller                                //
///        di_flag:     Data/Instruction Flag (with respect to Level    //
///                     for GLCD Controller)                            //
///                                                                     //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_write_data(uint8_t data, uint8_t controller_id, uint8_t di_flag) {


  ///implemented signal timing for data:

  ///           __________________________
  ///   CS  ___/                          \_______
  ///
  ///       ___                            _______
  ///   RW     \__________________________/
  ///
  ///       ______________________________________
  ///   DI
  ///
  ///                 ____________
  ///   EN___________/            \_______________
  ///
  ///
  /// DATA  XXXXxDDDDDDDDDDDDDDDDDDDDDDDDDxXXXXXXX
  ///
  /// --------------------------------------------------> t


  ///implemented signal timing for instruction:

  ///           __________________________
  ///   CS  ___/                          \_______
  ///
  ///       ___                            _______
  ///   RW     \__________________________/
  ///
  ///       ___                            _______
  ///   DI     \__________________________/
  ///
  ///                 ____________
  ///   EN___________/            \_______________
  ///
  ///
  /// DATA  XXXXxDDDDDDDDDDDDDDDDDDDDDDDDDxXXXXXXX
  ///
  /// --------------------------------------------------> t


#if GLCD_LATCHED_IO == 1

  ///set data

  //fill latch 1
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_DB0)  & ~(1 << GLCD_L_DB1)  & ~(1 << GLCD_L_DB2)  & ~(1 << GLCD_L_DB3);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x08) >> 3) << GLCD_L_DB3);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x04) >> 2) << GLCD_L_DB2);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x02) >> 1) << GLCD_L_DB1);
  GLCD_L_PORT = GLCD_L_PORT | ((data & 0x01) << GLCD_L_DB0);
  //set an reset latch (1) enable and disable it without delay
  GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_LATCH1_ENABLE);
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_LATCH1_ENABLE);

  //fill latch 2
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_DB4)  & ~(1 << GLCD_L_DB5)  & ~(1 << GLCD_L_DB6)  & ~(1 << GLCD_L_DB7);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x80) >> 7) << GLCD_L_DB7);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x40) >> 6) << GLCD_L_DB6);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x20) >> 5) << GLCD_L_DB5);
  GLCD_L_PORT = GLCD_L_PORT | (((data & 0x10) >> 4) << GLCD_L_DB4);
  //set an reset latch (2) enable and disable it without delay
  GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_LATCH2_ENABLE);
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_LATCH2_ENABLE);



  ///prepare enable, chip select and data/instruction

  //for controller 1
  if (controller_id == GLCD_CONTROLLER_ID1) {

    //data?
    if (di_flag == GLCD_DATA_VALUE) {
      GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_CS1) | (1 << GLCD_L_DI);
    } else {     //instruction
      GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_CS1);
      GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_DI);
    }
    GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_CS2);

    //for controller 2
  } else {

    //data?
    if (di_flag == GLCD_DATA_VALUE) {
      GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_CS2) | (1 << GLCD_L_DI);
    } else {     //instruction
      GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_CS2);
      GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_DI);
    }
    GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_CS1);

  }

  ///wait for EN Low Pulse Time
  _delay_us(GLCD_ENABLELOW_WIDTH_US);

  ///set enable to high
  GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_EN);

  ///wait for EN High Pulse Time
  _delay_us(GLCD_ENABLEHIGH_WIDTH_US);

  ///set data and enable to low
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_EN);

  ///wait for Data Hold Time
  _delay_us(GLCD_DATAHOLD_US);

  ///reset all control pins
  GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_DI);
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_CS1) & ~(1 << GLCD_L_CS2);

  ///wait for EN Low Pulse Time
  _delay_us(GLCD_ENABLELOW_WIDTH_US);


#else

  ///set data
  GLCD_ADDR_PORT = data;


  ///prepare enable, chip select and data/instruction

  //for controller 1
  if (controller_id == GLCD_CONTROLLER_ID1) {

    //data?
    if (di_flag == GLCD_DATA_VALUE) {
      GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_CS1) | (1 << GLCD_DI);
      GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_RW);
    } else {     //instruction
      GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_CS1);
      GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_RW) & ~(1 << GLCD_DI);
    }

    //for controller 2
  } else {

    //data?
    if (di_flag == GLCD_DATA_VALUE) {
      GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_CS2) | (1 << GLCD_DI);
      GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_RW);
    } else {     //instruction
      GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_CS2);
      GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_RW) & ~(1 << GLCD_DI);
    }

  }

  ///wait for EN Low Pulse Time
  _delay_us(GLCD_ENABLELOW_WIDTH_US);

  ///set enable to high
  GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_EN);

  ///wait for EN High Pulse Time
  _delay_us(GLCD_ENABLEHIGH_WIDTH_US);

  ///set data and enable to low
  GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_EN);

  ///wait for Data Hold Time
  _delay_us(GLCD_DATAHOLD_US);

  ///reset all control pins
  GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_DI) | (1 << GLCD_RW);
  GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_CS1) & ~(1 << GLCD_CS2);

  ///wait for EN Low Pulse Time
  _delay_us(GLCD_ENABLELOW_WIDTH_US);

#endif



}



//!///////////////////////////////////////////////////////////////////////
///lcd_delete_line                                                      //
///                                                                     //
/// Description:                                                        //
///         Deletes a line.                                             //
///                                                                     //
/// input:                                                              //
///     line_number:       number of line to delete (fitted to          //
///                        character == page)                           //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_delete_line(uint8_t line_number) {

  int i;

  ///go to line
  glcd_write_data(GLCD_SETPAGE_VALUE | line_number, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETPAGE_VALUE | line_number, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///clear all bytes
  for (i = 0; i < GLCD_PAGE_WIDTH; i++) {
    glcd_write_data(0x00, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    glcd_write_data(0x00, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
  }

  ///set DRAM position back to beginning of line
  glcd_write_data(GLCD_SETPAGE_VALUE | line_number, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETPAGE_VALUE | line_number, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///set internal position indicators
  column_pos = 0;
  row_pos = line_number;
  controller = GLCD_CONTROLLER_ID1;

}



//!///////////////////////////////////////////////////////////////////////
///lcd_clear_display                                                    //
///                                                                     //
/// Description:                                                        //
///         Clears the complete display.                                //
///                                                                     //
/// input:                                                              //
///                                                                     //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_clear_display(void) {

  int i, j;

  ///clear display RAM
  for (i = 0; i < GLCD_PAGE_NUMBER; i++) {
    glcd_write_data(GLCD_SETPAGE_VALUE | i, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETPAGE_VALUE | i, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
    for (j = 0; j < GLCD_PAGE_WIDTH; j++) {
      glcd_write_data(0x00, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(0x00, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    }
  }

  ///reset cursor position
  glcd_write_data(GLCD_SETPAGE_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETPAGE_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///reset start line
  glcd_write_data(GLCD_SETSTARTLINE_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETSTARTLINE_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///reset all internal values
  start_line = 0;
  scrolling = FALSE;
  controller = GLCD_CONTROLLER_ID1;
  row_pos = 0;
  column_pos = 0;


}



//!///////////////////////////////////////////////////////////////////////
///glcd_get_address                                                     //
///                                                                     //
/// Description:                                                        //
///         Calculates the address (page ID, Controller ID, column and  //
///         bit position) for given coordinates or vice versa.          //
///                                                                     //
/// input/output:                                                       //
///                                                                     //
///         pos_x:     GLCD x-position                                  //
///         pos_y:     GLCD y-position                                  //
///       page_id:     ID of page                                       //
/// controller_id:     ID of Controller (GLCD_CONTROLLER_IDx)           //
///        column:     column at page (considering the controller)      //
///       bit_pos:     Bit position at page column                      //
///          mode:     GLCD_POS_TO_ADDRESS:  position to address        //
///                                          conversion                 //
///                    GLCD_ADDRESS_TO_POS:  address to position        //
///                                          conversion                 //
///                                                                     //
/// return:                                                             //
///                                                                     //
///  return_value:     GLCD_NO_ERROR: no error occured                  //
///                    GLCD_ERROR: error occured (wrong input values)   //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////
#if GLCD_GET_ADDRESS_ENABLED == 1
uint8_t glcd_get_address(uint8_t *pos_x, uint8_t *pos_y, uint8_t *page_id,
                         uint8_t *controller_id, uint8_t *column, uint8_t *bit_pos,
                         uint8_t mode) {

  ///check for valid input values
  if ((mode != GLCD_POS_TO_ADDRESS) && (mode != GLCD_ADDRESS_TO_POS)) {
    return GLCD_ERROR;
  }

  ///mode: convert position to GLCD address
  if (mode == GLCD_POS_TO_ADDRESS) {

    if ((*pos_x >= (GLCD_X_RESOLUTION)) || (*pos_y >= GLCD_Y_RESOLUTION)) {
      return GLCD_ERROR;
    }

    //get Controller ID and column
    if (*pos_x >= GLCD_PAGE_WIDTH) {
      *controller_id = GLCD_CONTROLLER_ID2;
      *column = *pos_x - GLCD_PAGE_WIDTH;
    } else {
      *controller_id = GLCD_CONTROLLER_ID1;
      *column = *pos_x;
    }

    //get page ID and bit position
    *page_id = *pos_y / GLCD_PAGE_NUMBER;
    *bit_pos = *pos_y % GLCD_PAGE_NUMBER;


    ///mode: convert GLCD address to position
  } else {

    //calculate the x-position value (depending on controller ID and column)
    if (*controller_id == GLCD_CONTROLLER_ID1) {
      *pos_x = *column;
    } else {
      *pos_x = *column + GLCD_PAGE_WIDTH;
    }

    //calculate the y-position value (depending on page ID and bit position)
    *pos_y = (*page_id * GLCD_PAGE_HEIGHT) + *bit_pos;

  }


  return GLCD_NO_ERROR;

}
#endif


//!///////////////////////////////////////////////////////////////////////
///glcd_show_xbm                                                        //
///                                                                     //
/// Description:                                                        //
///         Shows XBM bitmap on GLCD.                                   //
///                                                                     //
/// input:                                                              //
///         bitmap:     pointer to bitmap array                         //
///        start_x:     start position (x) at GLCD                      //
///        start_y:     start position (y) at GLCD                      //
///          dim_x:     dimension of bitmap (x)                         //
///          dim_y:     dimension of bitmap (y)                         //
///      flash_mem:     specifies the string data location              //
///                     (flash_mem == TRUE: data source is PROGMEM      //
///                      flash_mem == FALSE: data source is RAM)        //
/// return:                                                             //
///   return_value:     0: no error                                     //
///                     1: error occured (wrong dimensions or start     //
///                        position)                                    //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////
#if GLCD_SHOW_XBM_ENABLED == 1
uint8_t glcd_show_xbm(unsigned char *bitmap, uint8_t start_x, uint8_t start_y,
                      uint8_t dim_x, uint8_t dim_y, uint8_t flash_mem) {


  uint8_t i, j, k;
  uint8_t page_id, start_page_id, number_pages;
  uint8_t bit_pos, column, start_column;
  uint8_t pos_x, pos_y;
  uint8_t controller_id;
  uint8_t bytes_per_line;
  uint8_t tmp_byte;
  unsigned char bitmap_byte;


  ///check start position
  if (((uint16_t) (start_x + dim_x) > GLCD_X_RESOLUTION) ||
      ((uint16_t) (start_y + dim_y) > GLCD_Y_RESOLUTION) ||
      (dim_x == 0) || (dim_y == 0)) {
    glcd_set_cursor(0, 0);
    glcd_send_string("GLCD ERROR: Wrong bitmap dimensions!", FALSE);
    return GLCD_ERROR;
  }


  ///get initial values
  glcd_get_address(&start_x, &start_y, &page_id, &controller_id, &column, &bit_pos, GLCD_POS_TO_ADDRESS);
  start_page_id = page_id;
  start_column = start_x;
  bytes_per_line = (dim_x / 8);               //number of bytes which contain a complete line
  if ((dim_x % 8) > 0) {
    bytes_per_line++;
  }

  //end position
  pos_x = start_x + dim_x - 1;
  pos_y = start_y + dim_y - 1;
  glcd_get_address(&pos_x, &pos_y, &page_id, &controller_id, &column, &bit_pos, GLCD_POS_TO_ADDRESS);
  number_pages = page_id - start_page_id + 1;


  ///write bitmap data to display

  for (i = start_page_id; i < (start_page_id + number_pages); i++) {   //go through all pages which are contain parts of the bitmap

    //get current page ID
    page_id = i;
    glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);


    for (j = start_column; j < (start_column + dim_x); j++) {          //go through all the columns which are contain parts of the bitmap

      //get controller ID for current column
      if (j >= GLCD_PAGE_WIDTH) {
        controller_id = GLCD_CONTROLLER_ID2;
        column = j - GLCD_PAGE_WIDTH;
      } else {
        controller_id = GLCD_CONTROLLER_ID1;
        column = j;
      }

      ///go trough all bit positions of page column and:
      ///  1. find out whether there is a pixel or not (offset)
      ///  2. calculate byte and position of bit in bitmap structure

      tmp_byte = 0x00;

      for (k = 0; k < 8; k++) {
        //bit --> get pos_x and pos_y
        bit_pos = k;
        glcd_get_address(&pos_x, &pos_y, &page_id, &controller_id, &column, &bit_pos, GLCD_ADDRESS_TO_POS);

        //page and bit position inside bitmap? --> get bit value or set bit to 0
        if ((pos_x >= start_x) && (pos_x < (start_x + dim_x)) &&
            (pos_y >= start_y) && (pos_y < (start_y + dim_y))) {

          pos_x = pos_x - start_x;
          pos_y = pos_y - start_y;

          if (flash_mem == TRUE) {
            bitmap_byte = pgm_read_byte(&bitmap[(pos_y*bytes_per_line)+(pos_x/8)]);
            tmp_byte = tmp_byte | (((bitmap_byte >> (pos_x % 8)) & 0x1) << bit_pos);
          } else {
            bitmap_byte = bitmap[(pos_y*bytes_per_line)+(pos_x/8)];
            tmp_byte = tmp_byte | (((bitmap_byte >> (pos_x % 8)) & 0x1) << bit_pos);
          }

        }

      }

      ///write data to display
      glcd_write_data(GLCD_SETADDRESS_VALUE | column, controller_id, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(tmp_byte, controller_id, GLCD_DATA_VALUE);

    }

  }


  ///reset cursor position
  glcd_write_data(GLCD_SETPAGE_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETPAGE_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///reset start line
  glcd_write_data(GLCD_SETSTARTLINE_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETSTARTLINE_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///reset all internal values
  start_line = 0;
  scrolling = FALSE;
  controller = GLCD_CONTROLLER_ID1;
  row_pos = 0;
  column_pos = 0;


  return GLCD_NO_ERROR;

}
#endif

//!///////////////////////////////////////////////////////////////////////
///glcd_show_diagram                                                    //
///                                                                     //
/// Description:                                                        //
///         Shows a diagram on GLCD.                                    //
///                                                                     //
/// input:                                                              //
///        x_descr:     description for x-axis                          //
/// x_descr_length:     number of chars (description for x-axis)        //
///        y_descr:     description for y-axis                          //
///     curr_value:     current signal value                            //
///        y_range:     maximum signal value (== description of y-axis) //
///          reset:     reset flag - clears diagram buffer              //
///                                                                     //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////
#if GLCD_SHOW_DIAGRAM_ENABLED == 1
void glcd_show_diagram(char *x_descr, uint8_t x_descr_length, char *y_descr,
                        uint16_t curr_value, uint16_t y_range, uint8_t reset) {


  static uint16_t diagram_data[GLCD_X_RESOLUTION];
  static uint8_t current_position = 0;
  uint8_t page_id, bit_position;
  uint16_t i, index;


  ///clear diagram buffer
  if (reset == TRUE) {

    for (i = 0; i < GLCD_X_RESOLUTION; i++) {
      diagram_data[i] = GLCD_Y_RESOLUTION - 1;
    }
    current_position = 0;

  }

  ///clear display and repaint diagram
  glcd_clear_display();

  //y-axis
  for (i = 0; i < GLCD_PAGE_NUMBER; i++) {
    glcd_write_data(GLCD_SETPAGE_VALUE | i, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);

    if (i == 0) {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(0x03, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    } else if (i == (GLCD_PAGE_NUMBER_2 - 1)) {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(0x80, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    } else if (i == GLCD_PAGE_NUMBER_2) {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(0x01, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    } else {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    }
  }

  //x-axis
  glcd_write_data(GLCD_SETPAGE_VALUE | (GLCD_PAGE_NUMBER - 1), GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);  //first position is already displayed by y-axis
  glcd_write_data(GLCD_SETPAGE_VALUE | (GLCD_PAGE_NUMBER - 1), GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  for (i = 0; i < GLCD_PAGE_WIDTH; i++) {

    if (i > 0) {                                 //first position is already displayed by y-axis
      if (i == GLCD_PAGE_WIDTH - 1) {
        glcd_write_data(0xc0, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      } else {
        glcd_write_data(0x80, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      }
    }

    if (i == 0) {
      glcd_write_data(0xc0, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    } else if (i > GLCD_PAGE_WIDTH - 3) {
      glcd_write_data(0xc0, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    } else {
      glcd_write_data(0x80, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    }

  }


  //write description to x- and y axis
  if (x_descr_length <= GLCD_CHARS_PER_LINE) {

    glcd_set_cursor(GLCD_CHARS_PER_LINE - x_descr_length, 7);
    glcd_send_string(x_descr, FALSE);

  }
  glcd_set_cursor(1, 0);
  glcd_send_string(y_descr, FALSE);


  ///return if RESET Flag is set
  if (reset == TRUE) return;


  ///calculate and save current value (display row)
  diagram_data[current_position] = GLCD_Y_RESOLUTION - (((uint32_t)curr_value * (uint32_t)GLCD_Y_RESOLUTION) / (uint32_t)y_range);


  ///display data
  glcd_write_data(GLCD_SETADDRESS_VALUE | 0x01, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);   //first position is already displayed by y-axis
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  for (i = 0; i < GLCD_X_RESOLUTION; i++) {

    //calculate the index
    index = current_position + 1 + i;

    if (index > GLCD_X_RESOLUTION-1) {
      index = index - GLCD_X_RESOLUTION;
    }

    //don't display '0'
    if (diagram_data[index] > (GLCD_Y_RESOLUTION - 2)) {
      if (i < GLCD_PAGE_WIDTH) {
        glcd_write_data(GLCD_SETADDRESS_VALUE | (i + 1), GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      } else {
        glcd_write_data(GLCD_SETADDRESS_VALUE | (i - GLCD_PAGE_WIDTH + 1), GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
      }
      continue;
    }


    //calculate the display position
    page_id = diagram_data[index] / GLCD_PAGE_HEIGHT;
    bit_position = (diagram_data[index] % GLCD_PAGE_HEIGHT);

    if (i < GLCD_PAGE_WIDTH) {
      if (i > 0) {                 //first position is already displayed by y-axis
        if ((i == GLCD_PAGE_WIDTH - 1) && (page_id == GLCD_PAGE_NUMBER - 1)) {
          glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data((1 << bit_position) | 0xc0, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
        } else if (page_id == GLCD_PAGE_NUMBER - 1) {
          glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data((1 << bit_position) | 0x80, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
        } else {
          glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data((1 << bit_position), GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
        }
      }
    } else {
      if (((i == GLCD_PAGE_WIDTH) || (i > GLCD_X_RESOLUTION - 2)) && (page_id == GLCD_PAGE_NUMBER - 1)) {
        glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data((1 << bit_position) | 0xc0, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
      } else if (page_id == GLCD_PAGE_NUMBER - 1) {
        glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data((1 << bit_position) | 0x80, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
      } else {
        glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data((1 << bit_position), GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
      }
    }

  }


  ///update position pointer
  if (current_position < (GLCD_X_RESOLUTION - 1)) {
    current_position++;
  } else {
    current_position = 0;
  }


}
#endif



//!///////////////////////////////////////////////////////////////////////
///glcd_show_complete_diagram                                           //
///                                                                     //
/// Description:                                                        //
///         Shows a complete diagram on GLCD (external ring buffer).    //
///                                                                     //
/// input:                                                              //
///        x_descr:     description for x-axis                          //
/// x_descr_length:     number of chars (description for x-axis)        //
///        y_descr:     description for y-axis                          //
///      adc_value:     pointer to adc values, range: GLCD_X_RESOLUTION //
///        y_range:     maximum signal value (== description of y-axis) //
///                                                                     //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////
#if GLCD_SHOW_COMPLETE_DIAGRAM_ENABLED == 1
void glcd_show_complete_diagram(char *x_descr, uint8_t x_descr_length, char *y_descr,
                                 uint16_t *diagram_data, uint16_t y_range) {


  uint8_t page_id, bit_position;
  uint16_t i;


  ///clear display and repaint diagram
  glcd_clear_display();

  //y-axis
  for (i = 0; i < GLCD_PAGE_NUMBER; i++) {
    glcd_write_data(GLCD_SETPAGE_VALUE | i, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);

    if (i == 0) {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(0x03, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    } else if (i == (GLCD_PAGE_NUMBER_2 - 1)) {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(0x80, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    } else if (i == GLCD_PAGE_NUMBER_2) {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      glcd_write_data(0x01, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    } else {
      glcd_write_data(0xff, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
    }
  }

  //x-axis
  glcd_write_data(GLCD_SETPAGE_VALUE | (GLCD_PAGE_NUMBER - 1), GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE | 1, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);  //first position is already displayed by y-axis
  glcd_write_data(GLCD_SETPAGE_VALUE | (GLCD_PAGE_NUMBER - 1), GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
  for (i = 0; i < GLCD_PAGE_WIDTH; i++) {

    if (i > 0) {                                 //first position is already displayed by y-axis
      if (i == GLCD_PAGE_WIDTH - 1) {
        glcd_write_data(0xc0, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      } else {
        glcd_write_data(0x80, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
      }
    }

    if (i == 0) {
      glcd_write_data(0xc0, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    } else if (i > GLCD_PAGE_WIDTH - 3) {
      glcd_write_data(0xc0, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    } else {
      glcd_write_data(0x80, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
    }

  }


  //write description to x- and y axis
  if (x_descr_length <= GLCD_CHARS_PER_LINE) {

    glcd_set_cursor(GLCD_CHARS_PER_LINE - x_descr_length, 7);
    glcd_send_string(x_descr, FALSE);

  }
  glcd_set_cursor(1, 0);
  glcd_send_string(y_descr, FALSE);



  ///display data
  glcd_write_data(GLCD_SETADDRESS_VALUE | 0x01, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);   //first position is already displayed by y-axis
  glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  for (i = 0; i < GLCD_X_RESOLUTION; i++) {

    //calculate and save current value (display row)
    diagram_data[i] = GLCD_Y_RESOLUTION - (((uint32_t)diagram_data[i] * (uint32_t)GLCD_Y_RESOLUTION) / (uint32_t)y_range);


    //don't display '0'
    if (diagram_data[i] > (GLCD_Y_RESOLUTION - 2)) {
      if (i < GLCD_PAGE_WIDTH) {
        glcd_write_data(GLCD_SETADDRESS_VALUE | (i + 1), GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
      } else {
        glcd_write_data(GLCD_SETADDRESS_VALUE | (i - GLCD_PAGE_WIDTH + 1), GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
      }
      continue;
    }


    //calculate the display position
    page_id = diagram_data[i] / GLCD_PAGE_HEIGHT;
    bit_position = (diagram_data[i] % GLCD_PAGE_HEIGHT);

    if (i < GLCD_PAGE_WIDTH) {
      if (i > 0) {                 //first position is already displayed by y-axis
        if ((i == GLCD_PAGE_WIDTH - 1) && (page_id == GLCD_PAGE_NUMBER - 1)) {
          glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data((1 << bit_position) | 0xc0, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
        } else if (page_id == GLCD_PAGE_NUMBER - 1) {
          glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data((1 << bit_position) | 0x80, GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
        } else {
          glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data((1 << bit_position), GLCD_CONTROLLER_ID1, GLCD_DATA_VALUE);
        }
      }
    } else {
      if (((i == GLCD_PAGE_WIDTH) || (i > GLCD_X_RESOLUTION - 2)) && (page_id == GLCD_PAGE_NUMBER - 1)) {
        glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data((1 << bit_position) | 0xc0, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
      } else if (page_id == GLCD_PAGE_NUMBER - 1) {
        glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data((1 << bit_position) | 0x80, GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
      } else {
        glcd_write_data(GLCD_SETPAGE_VALUE | page_id, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data((1 << bit_position), GLCD_CONTROLLER_ID2, GLCD_DATA_VALUE);
      }
    }

  }

}
#endif



//!///////////////////////////////////////////////////////////////////////
///glcd_set_cursor                                                      //
///                                                                     //
/// Description:                                                        //
///         Sets cursor to specified position.                          //
///                                                                     //
/// input:                                                              //
///         column:     GLCD column (fitted to character)               //
///         row:        GLCD row (fitted to character == page)          //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_set_cursor(uint8_t column, uint8_t row) {

  ///if scrolling active -> clear display to avoid some trouble with conflicting
  ///addresses
  if (scrolling == TRUE) glcd_clear_display();

  ///set row
  row_pos = row;
  glcd_write_data(GLCD_SETPAGE_VALUE | row, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_SETPAGE_VALUE | row, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  ///set column
  column_pos = column * STD_FONT_WIDTH;
  if ((column * STD_FONT_WIDTH) < GLCD_PAGE_WIDTH) {
    glcd_write_data(GLCD_SETADDRESS_VALUE | column_pos, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
    controller = GLCD_CONTROLLER_ID1;
  } else {
    glcd_write_data(GLCD_SETADDRESS_VALUE | (column_pos - GLCD_PAGE_WIDTH), GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
    glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
    controller = GLCD_CONTROLLER_ID2;
  }


}



//!///////////////////////////////////////////////////////////////////////
///lcd_send_string                                                      //
///                                                                     //
/// Description:                                                        //
///         Sends string to GLCD. It reads the string data from RAM     //
///         or from PROGMEM if requested. After reaching the end of     //
///         displayable area, scrolling will automatically enabled.     //
///                                                                     //
/// input:                                                              //
///         data:       string                                          //
///         flash_mem:  specifies the string data location              //
///                     (flash_mem == TRUE: data source is PROGMEM      //
///                      flash_mem == FALSE: data source is RAM)        //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_send_string(const char *data, uint8_t flash_mem) {

  char c;
  uint8_t pos;
  uint8_t i;


  if (flash_mem == TRUE) {

    c = pgm_read_byte(data);

    while (c != '\0') {   //until *s != '\0' --> means "string end sign"

      ///set row and column address and controller ID for end of line (if character is
      ///too long for left space)
      if (((column_pos + STD_FONT_WIDTH) > GLCD_LAST_X_POS) ||
          (c == '\n')) {
        if (row_pos >= GLCD_PAGE_NUMBER - 1) {
          row_pos = 0;
          scrolling = TRUE;
          start_line = start_line + GLCD_PAGE_HEIGHT;
          if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
          glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        } else {
          row_pos++;
          if (scrolling == TRUE) {
            start_line = start_line + GLCD_PAGE_HEIGHT;
            if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
          }
        }
        column_pos = 0;
        controller = GLCD_CONTROLLER_ID1;
        glcd_delete_line(row_pos);
        glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
        glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
        glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        if (c == '\n') {
          //next character
          data++;
          c = pgm_read_byte(data);
          continue;
        }
      }

      ///write data depending on the controller ID (column address)
      pos = (uint8_t) c - GLCD_ASCII_TABLE_OFFSET;
      for (i = 0; i < STD_FONT_WIDTH; i++) {
        if (column_pos == GLCD_X_RESOLUTION) {
          if (row_pos >= GLCD_PAGE_NUMBER - 1) {
            row_pos = 0;
            scrolling = TRUE;
            start_line = start_line + GLCD_PAGE_HEIGHT;
            if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
          } else {
            row_pos++;
            if (scrolling == TRUE) {
              start_line = start_line + GLCD_PAGE_HEIGHT;
              if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
              glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
              glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
            }
          }
          column_pos = 0;
          controller = GLCD_CONTROLLER_ID1;
          glcd_delete_line(row_pos);
          glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        }
        //switch to the second controller
        if (column_pos == GLCD_Y_RESOLUTION) {
          controller = GLCD_CONTROLLER_ID2;
        }
        glcd_write_data(pgm_read_byte(&ascii_std_tab[pos][i]), controller, GLCD_DATA_VALUE);
        //increase column pos
        column_pos++;
      }

      //next character
      data++;
      c = pgm_read_byte(data);
    }




  } else {

    while (*data != '\0') {  //until *s != '\0' --> means "string end sign"

      ///set row and column address and controller ID for end of line (if character is
      ///too long for left space)
      if (((column_pos + STD_FONT_WIDTH) > GLCD_LAST_X_POS) ||
          (*data == '\n')) {

        if (row_pos >= GLCD_PAGE_NUMBER - 1) {
          row_pos = 0;
          scrolling = TRUE;
          start_line = start_line + GLCD_PAGE_HEIGHT;
          if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
          glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        } else {
          row_pos++;
          if (scrolling == TRUE) {
            start_line = start_line + GLCD_PAGE_HEIGHT;
            if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
          }
        }
        column_pos = 0;
        controller = GLCD_CONTROLLER_ID1;
        glcd_delete_line(row_pos);
        glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
        glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
        glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
      }
      if (*data == '\n') {
        //next character
        data++;
        continue;
      }

      ///write data depending on the controller ID (column address)
      pos = *data - GLCD_ASCII_TABLE_OFFSET;
      for (i = 0; i < STD_FONT_WIDTH; i++) {
        if (column_pos == GLCD_X_RESOLUTION) {

          if (row_pos >= GLCD_PAGE_NUMBER - 1) {
            row_pos = 0;
            scrolling = TRUE;
            start_line = start_line + GLCD_PAGE_HEIGHT;
            if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
            glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
          } else {
            row_pos++;
            if (scrolling == TRUE) {
              start_line = start_line + GLCD_PAGE_HEIGHT;
              if (start_line >= GLCD_Y_RESOLUTION) start_line = 0;
              glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
              glcd_write_data(GLCD_SETSTARTLINE_VALUE | start_line, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
            }

          }
          column_pos = 0;
          controller = GLCD_CONTROLLER_ID1;
          glcd_delete_line(row_pos);
          glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETPAGE_VALUE | row_pos, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
          glcd_write_data(GLCD_SETADDRESS_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);
        }
        //switch to the second controller
        if (column_pos == GLCD_Y_RESOLUTION) {
          controller = GLCD_CONTROLLER_ID2;
        }
        glcd_write_data(pgm_read_byte(&ascii_std_tab[pos][i]), controller, GLCD_DATA_VALUE);
        //increase column pos
        column_pos++;
      }

      //next character
      data++;
    }

  }

}



//!///////////////////////////////////////////////////////////////////////
///glcd_init                                                            //
///                                                                     //
/// Description:                                                        //
///         Initializes the GLCD after Reset.                           //
///                                                                     //
/// input:                                                              //
///         --                                                          //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_init(void) {


#if GLCD_LATCHED_IO == 1

  ///reset GLCD
  GLCD_L_PORT = GLCD_L_PORT & ~(1 << GLCD_L_RST);
  _delay_ms(GLCD_RESET_WIDTH_MS);
  GLCD_L_PORT = GLCD_L_PORT | (1 << GLCD_L_RST);

#else

  ///reset GLCD
  GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_RST);
  _delay_ms(GLCD_RESET_WIDTH_MS);
  GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_RST);

#endif


  ///switch both controllers on
  glcd_write_data(GLCD_DISPLAY_ON_VALUE, GLCD_CONTROLLER_ID1, GLCD_INSTRUCTION_VALUE);
  glcd_write_data(GLCD_DISPLAY_ON_VALUE, GLCD_CONTROLLER_ID2, GLCD_INSTRUCTION_VALUE);

  _delay_ms(GLCD_RESET_WIDTH_MS);

  ///clear display
  glcd_clear_display();

}




//!///////////////////////////////////////////////////////////////////////
///glcd_pin_init                                                        //
///                                                                     //
/// Description:                                                        //
///         Initializes the pins for interfacing the GLCD.              //
///                                                                     //
/// input:                                                              //
///         --                                                          //
/// return:                                                             //
///         --                                                          //
///                                                                     //
//!///////////////////////////////////////////////////////////////////////

void glcd_pin_init(void) {

#if GLCD_LATCHED_IO == 1

  //set GLCD Ports/Pins to output ports/pins
  GLCD_L_PORT = 0x00 | (1 << GLCD_L_RST);
  GLCD_L_DDR = 0xff;

#else

  //set GLCD Address and Control Ports/Pins to output ports/pins
  GLCD_ADDR_PORT = 0xff;
  GLCD_ADDR_DDR = 0xff;

  GLCD_CTRL_PORT = GLCD_CTRL_PORT | (1 << GLCD_DI) | (1 << GLCD_RW) | (1 << GLCD_RST);
  GLCD_CTRL_PORT = GLCD_CTRL_PORT & ~(1 << GLCD_CS1) & ~(1 << GLCD_CS2) & ~(1 << GLCD_EN);
  GLCD_CTRL_DDR = GLCD_CTRL_DDR | (1 << GLCD_DI) | (1 << GLCD_RW) | (1 << GLCD_EN) | (1 << GLCD_CS1) | (1 << GLCD_CS2) | (1 << GLCD_RST);

#endif

}
