ettft240320tp3_2_rev_b.c

/**************************************************************************************************

 *                                GLCD Treiber Modul;                        *

 *                                                         *

 *                     GLCD_Touch Screen :ET-TFT240320TP-3.2Rev.B                               *

 *                               DISPLAY :PORTRAIT(Ver.)                                        *

 *                                  MODE :Interface GLCD Parallel Data 8 Bit                      *

 **************************************************************************************************

 *                                                                                               *

 * Editor         : AVR Studio 4.18 Build 700                                                    *

 * Compiler       : WinAVR-20100110                                                              *

 * Create By      : Mr. Sittiphol Yooyod (WWW.ETT.CO.TH)                                         *

 * Last Update    : 24/August /2009                                                              *

 * Modifiziert am : xx/Oktober/2010                                     *

 *                                                         *

 * DipSw1 (TSC Select)    : On  On  On On : Touch Screen Kommunikation                       *

 * DipSw2 (Interface Mode): Off Off On -- : Interface Mode (8Bit Modus)                         *

 *                                                     *

 * Port Interface :       |   MCU: Mega128/2561    |     LCD: ET-TFT240320TP-3.2 Rev.B          *

 *________________________|_______________________|_________________________________________       *

 *  - Data GLCD           |    : PF[0..7]         | Connect: DB8..DB15                            *

 *  - Control GLCD        |    : PE2           | Connect: CS-H                                *

 *  -                     |    : PE3        | Connect: RS-H(0=cmm,1=data)                  *

 *  -                     |    : PE4        | Connect: WR-H(Write)                         *

 *  -                     |    : PE5          | Connect: RD-H(Read)                          *

 *  -                     |    : PE6        | Connect: RES-H(Reset)                        *

 *  - Back Light GLCD     |    : PE7          | Connect: BL-H(LCD-Back Light(Active=1))      *

 *  - Touch Screen        |    : PD2 (MISO-in)    | Connect: MISO                                *

 *  -                     |    : PD3 (MOSI-out)   | Connect: MOSI                                *

 *  -                     |    : PD4 (SCLK-out)   | Connect: SCLK                                *

 *  -                     |    : PD5 (BUSY-in)    | Connect: BUSY(No_USE)                        *

 *  -                     |    : PD6 (PEN-in)     | Connect: PEN                                 *

 *  -                     |    : PD7 (TC_CS-out)  | Connect: TC_CS                               *

 *  - UART0(BaudRate=9600)|    : PE0 = RXD0       |                                              *

 *  -                     |    : PE1 = TXD0       |                                              *

 **************************************************************************************************/

#ifndef ETTFT240320TP3_2_REV_B_C

#define ETTFT240320TP3_2_REV_B_C

// interne Header

#include <stdio.h>             // Standard I/O-Funktionen (printf, ...)

#include <stdlib.h>            // Deklariert ISO C-Makros/Funktionen & AVR-spezifische Erweiterungen

#include <avr/io.h>            // Makros für IO Ports.

#include <math.h>              // Mathematische Funktionen: sin, cos, log, gamma, bessel, ...

#include <stdint.h>         // Deklariert Datentypen wie int8_t usw.

#include <compat/deprecated.h> // Call Function sbi(port,bit),cbi(port,bit) = Set,Clear bit

// zusätzliche Header

#define extern

#include "f_cpu.h" // wird für util/delay.h benötigt

#include "ettft240320tp3_2_rev_b.h"

#include "ettft240320tp3_2_rev_b_font.h"

#undef extern

// interner Header

#include <util/delay.h>        // Verzögerungsschleifen für kurze, exakte Verzögerungen

long dis_XD[3] = {24,215,120} ; // Value refer Point X at 10% of Display(X=240:0-239) 3 Position

long dis_YD[3] = {32,160,287} ; // Value refer Point Y at 10% of Display(Y=320:0-319) 3 Position

// *** Function Delay ms ***

void delay_ms(uint16_t cnt){for(;cnt>0;cnt--)_delay_ms(1);}

// *** Function Initial Port ***

void init_port(void)

  { DDRF  = 0xFF ; // Set PortF(0..7) = Output for data GLCD Byte High

    DDRE |= 0xFC ; // Set PortE(2..7) = Output for Control GLCD(CS,RS,WR,RD,Reset,BL)

    DDRD  = 0x98 ; // Set PortD = PD7,PD4,PD3:Output ;PD6,PD5,PD2:Input for Touch Screen

// --- Set Value Default Port ---

    PORTF = 0    ;

    PORTE = 0x7C ;

    PORTD = 0x80 ;

  }

/*** 1.Function Control of Graphic LCD EL-TFT240320TP-3.2 REV.B(Driver SPFD5408S) ***/

// --- ControlPin cs (PE2=CS) ---

void gp_cs_hi(void) {sbi(PORTE,2) ;} // PE2 = Hi

void gp_cs_lo(void) {cbi(PORTE,2) ;} // PE2 = Lo

// --- ControlPin rs (PE3=RS) ---

void gp_rs_hi(void) {sbi(PORTE,3) ;} // PE3 = Hi

void gp_rs_lo(void) {cbi(PORTE,3) ;} // PE3 = Lo

// --- ControlPin wr (PE4=WR) ---

void gp_wr_hi(void) {sbi(PORTE,4) ;} // PE4 = Hi

void gp_wr_lo(void) {cbi(PORTE,4) ;} // PE4 = Lo

// --- ControlPin rd (PE5=RD) ---

void gp_rd_hi(void) {sbi(PORTE,5) ;} // PE5 = Hi

void gp_rd_lo(void) {cbi(PORTE,5) ;} // PE5 = Lo

// --- ControlPin res(PE6=RES) ---

void gp_res_hi(void) {sbi(PORTE,6);} // PE6 = Hi

void gp_res_lo(void) {cbi(PORTE,6);} // PE6 = Lo

// --- Control BackLight(PE7=Back Light) ---

void gp_bl_on (void){sbi(PORTE,7) ;} // PE7 = Hi(ON)

void gp_bl_off(void){cbi(PORTE,7) ;} // PE7 = Lo(OFF)

/****************************

 Write Address Command to LCD

 ****************************/

void gp_wr_cmm(uint8_t cmm)

  {

// --- Sent Command 8 bit High ---

    gp_cs_lo()   ;

    PORTF = 0x00 ; // Write the command to the data bus

    gp_rs_lo()   ; // RS=0, Set the RS signal low, indicating a command.

    gp_wr_lo()   ; // wr=0, Assert the write enable signal.

    gp_wr_hi()   ; // wr=1, Deassert the write enable signal.

// --- Sent Command 8 bit Low ---

    PORTF = cmm  ; // Write the command to the data bus

    gp_wr_lo()   ; // wr=0, Assert the write enable signal

    gp_wr_hi()   ; // wr=1, Deassert the write enable signal

    gp_rs_hi()   ; // RS=1, Set the RS signal high, indicating that following writes are data

  }

/*****************

 Write data to LCD

 *****************/

void gp_wr_data(uint16_t dw)

  {

// --- Sent Command 8 bit High ---

    gp_cs_lo()    ;

    PORTF = dw>>8 ; // Write data to data bus. 8 bit PF[8..15]

    gp_wr_lo()    ; // wr = 0, Assert the write enable signal.

    gp_wr_hi()    ; // wr = 1, Deassert the write enable signal.

// --- Sent Command 8 bit Low ---

    PORTF = dw    ; // Write data to data bus. 16 bit PF[8..15]

    gp_wr_lo()    ; // wr = 0, Assert the write enable signal.

    gp_wr_hi()    ; // wr = 1, Deassert the write enable signal.

    gp_cs_hi()    ;

  }

/*********************

 Function Initial GLCD

 *********************/

void init_glcd(void)

  { long cnt ;

  // --- Start GLCD ----

    gp_rd_hi()         ;

    gp_res_lo()        ; // Reset GLCD

    delay_ms(1)        ; // Delay for 1ms.

    gp_res_hi()        ; // Stop Signal Reset GLCD

    delay_ms(1)      ; // Delay for 1ms while the LCD comes out of reset.

    gp_wr_cmm(0x00)    ; // Command Start Oscillater

    gp_wr_data(0x0001) ; // Enable the oscillator.

    delay_ms(10)       ; // Delay for 10ms while the oscillator stabilizes.

  // - Display Setting -

    gp_wr_cmm(0x01)    ; // Configure the output drivers.

    gp_wr_data(0x0100) ;

    gp_wr_cmm(0x02)    ; // Configure the LCD A/C drive waveform.

    gp_wr_data(0x0700) ; // Line inversion 0x0700

    gp_wr_cmm(0x03)    ; // Configure Entry Mode

    gp_wr_data(0x1230) ; // Color:RGB ,Incremen Hor.&Ver.address,Address update Hor.

  // -- Power Control --

    gp_wr_cmm(0x07)    ; // Enable internal operation of the LCD controller.

    gp_wr_data(0x0101) ; // 0011

    gp_wr_cmm(0x10)    ;

    gp_wr_data(0x0000) ; // 0x00B0

    gp_wr_cmm(0x11)    ;

    gp_wr_data(0x0007) ; // 0x0037

    gp_wr_cmm(0x12)    ;

    gp_wr_data(0x0000) ; // 0x011E

    gp_wr_cmm(0x13)    ;

    gp_wr_data(0x0000) ; // 0x1A00 

    delay_ms(20)       ;

    gp_wr_cmm(0x10)    ;

    gp_wr_data(0x16B0) ;

    gp_wr_cmm(0x11)    ;

    gp_wr_data(0x0037) ;

    delay_ms(20)       ; // 50

    gp_wr_cmm(0x12)    ;

    gp_wr_data(0x013E) ;

    delay_ms(20)      ; // 50

    gp_wr_cmm(0x13)    ;

    gp_wr_data(0x1A00) ;

    gp_wr_cmm(0x29)    ;

    gp_wr_data(0x000F) ;

    delay_ms(20)       ; // 50- Delay for 40ms while the power supply stabilizes.

  // --- Clear the contents of the display buffer. ---

    gp_wr_cmm(0x22);

    for(cnt = 0;cnt<((long)240*320);cnt++)

    gp_wr_data(Black)     ; // Back-Ground Color =Black

    gp_wr_cmm(0x20)       ; // Command Horizontal GRAM Address Set

    gp_wr_data(0x0000)    ; // Address Start 0x0000

    gp_wr_cmm(0x21)       ; // Command Vertical GRAM Address Set

    gp_wr_data(0x0000)    ; // Address Start 0x0000

    gp_wr_cmm(0x50)       ; // Command Horizontal Address Start Position

    gp_wr_data(0x0000)    ;

    gp_wr_cmm(0x51)       ; // Command Horizontal Address End Position(239)

    gp_wr_data(0x00EF)    ;

    gp_wr_cmm(0x52)       ; // Command Vertical Address Start Position

    gp_wr_data(0x0000)    ;

    gp_wr_cmm(0x53)       ; // Command Verticall Address End Position(239)

    gp_wr_data(0x013F)    ;

    gp_wr_cmm(0x60)       ; // Set the number of lines to scan.

    gp_wr_data(0x2700)    ;

    gp_wr_cmm(0x61)       ; // Enable grayscale inversion of the source outputs.

    gp_wr_data(0x0001)    ;

  // -- GAMMA Control --

    gp_wr_cmm(0x30)    ;

    gp_wr_data(0x0007) ;

    gp_wr_cmm(0x31)    ;

    gp_wr_data(0x0403) ;

    gp_wr_cmm(0x32)    ;

    gp_wr_data(0x0404) ;

    gp_wr_cmm(0x35)    ;

    gp_wr_data(0x0002) ;

    gp_wr_cmm(0x36)    ;

    gp_wr_data(0x0707) ;

    gp_wr_cmm(0x37)    ;

    gp_wr_data(0x0606) ;

    gp_wr_cmm(0x38)    ;

    gp_wr_data(0x0106) ;

    gp_wr_cmm(0x39)    ;

    gp_wr_data(0x0007) ; 

    gp_wr_cmm(0x3C)    ;

    gp_wr_data(0x0700) ;

    gp_wr_cmm(0x3D)    ;

    gp_wr_data(0x0707) ;

    gp_wr_cmm(0x07)    ; // Enable the image display.

    gp_wr_data(0x0173) ;

    gp_bl_on() ; // Back Light ON

    delay_ms(20) ; // Delay for 20ms, which is equivalent to two frames.

  }

/*** 2. Function Touch Screen (ADS7846:SPI-Interface) ***/

// ---------- CS [PD7] --------------

void tcs_cs_hi (void) {sbi(PORTD,7);}   //PD7 =1

void tcs_cs_lo (void) {cbi(PORTD,7);}   //PD7 =0

// ---------- SCK [PD4] -------------

void tcs_sck_hi(void) {sbi(PORTD,4);}   //PD4 =1

void tcs_sck_lo(void) {cbi(PORTD,4);}   //PD4 =0

// ---------- Data MOSI [PD3] -------

void tcs_sdo_hi(void) {sbi(PORTD,3);}   //PD3 =1

void tcs_sdo_lo(void) {cbi(PORTD,3);}   //PD3 =0

/*********************************************

 Function Check Status Press Touch Screen

 *********************************************

 Return Value :

 Function return value '0'= Not Touched screen

 Function return value '1'= Touched screen

 *********************************************/

uint8_t status_touch(void)

    { if((PIND & 0x40)== 0x40) // Read PD6

        return 0 ;           // No Touch

      else

         return 1 ;           // Press Touch screen

    }

/************************************************

 Function SPI Write and Read Data 1 Byte from

 Touch Screen ADS7846

 ************************************************

 Parameter :

 DataByte =data or command control ADS7846(1Byte)

 Return Value: Return value adc from touched

               times 1 byte Pass Function

 ************************************************/

uint8_t tcs_wr(uint8_t DataByte)

  {

   uint8_t Bit,result=0  ;

   for(Bit=0;Bit<8;Bit++)  // 8 Bit Write

      {

     tcs_sck_hi()      ; // Start Clock  High

  // --- write Data(PD3) ---

       if((DataByte & 0x80)== 0x80)

      tcs_sdo_hi()   ; // Set bit data(PD3) = 1

    else

      tcs_sdo_lo()   ; // Clear bit data(PD3) = 0

      tcs_sck_lo()   ; // Clock low

      DataByte <<= 1 ; // Shift Next Bit Data

  // --- Read Data(PD2) ---

     result <<= 1      ;

       if ((PIND & 0x04)== 0x04) // If SDI = "1"

        {

         result |= 0x01; // Keep Result of Read-data

        }

    }

   return (result)       ;

  }

/***********************************************

 Function Read X-Y-Pos.ADC TouchScreen-12bit adc

 ***********************************************

 Parameter :  No

 Return Value  :

 dif_adc_X = Keep Result ADC X-Position(12 bit)

 dif_adc_Y = Keep result ADC Y-Position(12 bit)

 ***********************************************/

void tcs_read(void)

  {

   uint16_t tcs_adc_X ,tcs_adc_Y ;

   uint8_t buf_data[4]           ;

   if(status_touch())

   {

   // --- Set default Pin control Touch Screen ---

     tcs_sdo_lo() ;

    tcs_sck_lo() ;

    tcs_cs_lo () ;

      buf_data[0] =tcs_wr(0xD0); // Write Command Measure X-Position

    buf_data[0] =tcs_wr(0x00); // Read ADCdata X-Position (7-bit byte High) data: 0ddddddd  (bit)

    buf_data[1] =tcs_wr(0x90); // Write Command Measure Y-Pos.;Read ADC data X-Pos.(5-bit byte Low)data:ddddd000(bit)

    buf_data[2] =tcs_wr(0x00); // Read ADCdata Y-Position(7-bit byte High) data:0ddddddd (bit)

    buf_data[3] =tcs_wr(0x00); // Read ADCdata Y-Position(5-bit byte Low) data:ddddd000 (bit)

    tcs_adc_X  = buf_data[0]       ; // Mark ADC Data X-Position 12 bit

    tcs_adc_X  = tcs_adc_X << 5    ;

    tcs_adc_X |= buf_data[1] >> 3  ;

    tcs_adc_X  = tcs_adc_X & 0x0FFF;

    tcs_adc_Y  = buf_data[2]       ; // Mark ADC Data Y-Position 12 bit

    tcs_adc_Y  = tcs_adc_Y << 5    ; // Shift 7 bit High

    tcs_adc_Y |= buf_data[3] >> 3  ; // Shift 5 bit low

    tcs_adc_Y  = tcs_adc_Y & 0x0FFF; // total ADC data 12 bit

    tcs_cs_hi()                    ;

    dif_adc_X = tcs_adc_X          ; // ADC 12 bit :LCD Start Portrait

    dif_adc_Y = 4095-tcs_adc_Y   ;

     }

  }

/*********************************************************

 Function Calculate average of measurements,

 by cut value max and min measurement.

 *********************************************************

 Parameter :

 num = number times of measurement adc from touch screen

 Return value:

 ave_adc_X = Keep result average adc X-Position

 ave_adc_Y = Keep result average adc Y-Position

 *********************************************************/

void ave_x_y(uint8_t num)

  {

   uint8_t i;

   long sum_x, sum_y;

   long min_x, min_y, max_x, max_y;

   sum_x=0;sum_y=0;min_x=0xffff;min_y=0xffff,max_x=0;max_y=0;

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

      {

     sum_x += buf_adc_X[i] ;

     sum_y += buf_adc_Y[i] ;

     if(buf_adc_X[i]< min_x) // search for minimum X value

      {

      min_x = buf_adc_X[i] ;

     }

     else if (buf_adc_X[i]> max_x) // search for maximum X value

           {

          max_x = buf_adc_X[i] ;

           }

     if(buf_adc_Y[i]< min_y) // search for minimum Y value

     {

      min_y = buf_adc_Y[i] ;

     }

     else if(buf_adc_Y[i]> max_y) // search for maximum Y value

          {

           max_y = buf_adc_Y[i] ;

             }

    }

   ave_adc_X = (sum_x - min_x - max_x ) / (num-2) ; // update x average value

   ave_adc_Y = (sum_y - min_y - max_y ) / (num-2) ;  // update y average value

  }

/***********************************************

 Function Calculate Matrix Find value Coeffcient

 ***********************************************

 Parameter    : No

 Return Value : Keep value Coeffcient for use

                calculate X-Y-Pos.in variable

                divider,An,Bn,Cn,Dn,En,Fn

 ***********************************************/

void set_matrix()

  {

   divider =    ((tcs_ave_X[0]-tcs_ave_X[2])*(tcs_ave_Y[1]-tcs_ave_Y[2]))-

              ((tcs_ave_X[1]-tcs_ave_X[2])*(tcs_ave_Y[0]-tcs_ave_Y[2])) ;

        An =   ((dis_XD[0]-dis_XD[2])*(tcs_ave_Y[1]-tcs_ave_Y[2]))-

        ((dis_XD[1]-dis_XD[2])*(tcs_ave_Y[0]-tcs_ave_Y[2])) ;

      Bn =   ((tcs_ave_X[0]-tcs_ave_X[2])*(dis_XD[1]-dis_XD[2]))-

        ((dis_XD[0]-dis_XD[2])*(tcs_ave_X[1]-tcs_ave_X[2])) ;

      Cn =    (tcs_ave_X[2]*dis_XD[1]-tcs_ave_X[1]*dis_XD[2])*tcs_ave_Y[0]+

            (tcs_ave_X[0]*dis_XD[2]-tcs_ave_X[2]*dis_XD[0])*tcs_ave_Y[1]+

          (tcs_ave_X[1]*dis_XD[0]-tcs_ave_X[0]*dis_XD[1])*tcs_ave_Y[2] ;

      Dn =   ((dis_YD[0]-dis_YD[2])*(tcs_ave_Y[1]-tcs_ave_Y[2]))-

        ((dis_YD[1]-dis_YD[2])*(tcs_ave_Y[0]-tcs_ave_Y[2])) ;

        En =   ((tcs_ave_X[0]-tcs_ave_X[2])*(dis_YD[1]-dis_YD[2]))-

        ((dis_YD[0]-dis_YD[2])*(tcs_ave_X[1]-tcs_ave_X[2])) ;

    Fn =    (tcs_ave_X[2]*dis_YD[1]-tcs_ave_X[1]*dis_YD[2])*tcs_ave_Y[0]+

            (tcs_ave_X[0]*dis_YD[2]-tcs_ave_X[2]*dis_YD[0])*tcs_ave_Y[1]+

          (tcs_ave_X[1]*dis_YD[0]-tcs_ave_X[0]*dis_YD[1])*tcs_ave_Y[2] ;

  }

/***********************************************

 Function Get Position Address real of Display

 ***********************************************

 Parameter:

 num = Number times for Measure adc from Touched

 Return Value :

   X = Keep value address X-Position

   Y = Keep value address Y-Position

 ***********************************************/

void get_point(uint8_t num)

  {

   uint8_t nm ;

   nm=0;

   while(status_touch() && nm<num)  // Measure touch x,y 10 times if the Touch kept pressed,

        {

         tcs_read()               ; // Read value ADC Touch X-Y

         buf_adc_X[nm]=  dif_adc_X ; // keep value ADC Touch-X

     buf_adc_Y[nm]=  dif_adc_Y ; // keep value ADC Touch-Y

         nm++               ;

    }

   if(nm==num)                // if the touch xy successfuly collected,

     {

    ave_x_y(num)          ; // take average out of 10 touch measurements, excluding max and min measurement.

    dif_adc_X = ave_adc_X ; // keep average ADC Touch-X

    dif_adc_Y = ave_adc_Y ; // keep average ADC Touch-Y

      X = ((An*dif_adc_X)+(Bn*dif_adc_Y)+Cn)/divider  ;

      Y = ((Dn*dif_adc_X)+(En*dif_adc_Y)+Fn)/divider  ;

     }

  }

/*******************************

 Function Calibrate Touch Screen

 Touch at Point + on Screen

 3 Point(3 step) for Caribrate

 *******************************

 Parameter : No

 Return value : No

 *******************************/

void touch_calibrate(void)

  {

   uint8_t n,touch_mark_point=0;

   plot_mark(17,32,24,25,Red); // Plot Signe + for Position Calibrate Touch Point1

   print_Str("  <Touch Screen Calibration>  ",2,0, 20,Green, Black); // Plot Text Color Green

   print_Str("         Step 1 of 3          ",2,0, 50,Green, Black);

   print_Str("  Click on center of '+'Icon  ",2,0,200,White, Black); // Plot Text Color White

   print_Str("  for Touch screen calibrate  ",2,0,220,White, Black);

   while(status_touch()){;}     // Wait until not Touch screen ,

   while(touch_mark_point != 3)  // Number Mark Point Calibrate = 3 Point 

      {

     if(status_touch())      // return (1) if touch screen is detected.

       {

      for(n=0;n<50;n++)

         {

        tcs_read(); // Read portrait(ADC X,Y) by touch value from ADS7846 and update dif_adc_X & dif_adc_Y

        buf_adc_X[n] = dif_adc_X; // General buffer for averaging and filter touch screen adc read outs.

        buf_adc_Y[n] = dif_adc_Y; // General buffer for averaging and filter touch screen adc read outs.

         }

      ave_x_y(50);                // Take average out of 50 touch measurements, excluding max and min measurement.

      tcs_ave_X[touch_mark_point]=  ave_adc_X;

      tcs_ave_Y[touch_mark_point]=  ave_adc_Y;

      touch_mark_point++; // touch_cal_status;0=xy1,1=xy2,2=xy3,3=calibration success.0xff=calibrat. not performed.

      while(status_touch()) {;} // Waite until not Touch screen ,

      switch(touch_mark_point)  // Select Caribrate Next Step 2 and 3

            {

          case 1:

            bg_color(Black);             // Clear Screen

            plot_mark(208,160,215,153,Red); // Plot Signe + for Position Calibrate Touch Point2

                         print_Str("  <Touch Screen Calibration>  ",2,0, 20,Green, Black);

                        print_Str("         Step 2 of 3          ",2,0, 50,Green, Black);

                        print_Str("  Click on center of '+'Icon  ",2,0,200,White, Black);

                       print_Str("  for Touch screen calibrate  ",2,0,220,White, Black);

            break;

          case 2:

            bg_color(Black);             // Clear Screen

            plot_mark(113,287,120,280,Red); // Plot Signe + for Position Calibrate Touch Point3

            print_Str("  <Touch Screen Calibration>  ",2,0, 20,Green, Black);

                        print_Str("         Step 3 of 3          ",2,0, 50,Green, Black);

                        print_Str("  Click on center of '+'Icon  ",2,0,200,White, Black);

                       print_Str("  for Touch screen calibrate  ",2,0,220,White, Black);

            break;

            }

       }

     delay_ms(100);

      }

   set_matrix(); // Calculate Coefficient for use find Position Address real on Display

  }

/*** 3.Function Aplication Display Screen; ***/

/*******************************************

 Funktion Background Farbe oder Clear Screen

 *******************************************

 Parameter:

 - bg_color = Hintergrund Farbe

 *******************************************/

void bg_color(uint16_t bg_color)

  {

   long cnt             ;

   gp_wr_cmm(0x20)      ; // Command Horizontal GRAM Address Set

   gp_wr_data(0x0000)   ; // Address +Start 0x0000

   gp_wr_cmm(0x21)      ; // Command Vertical GRAM Address Set

   gp_wr_data(0x0000)   ; // Address Start 0x0000

   gp_wr_cmm(0x22)      ;

   for(cnt = 0;cnt<((long)240*320);cnt++)

   gp_wr_data(bg_color) ; // Back-Ground Color Black

  }

/******************************************************

 Function Print Text 1 Charecter

 ******************************************************

 Parameter :

 - row      = Ascii Code (Position buffer keep text)

 - adx,ady  = Position X,Y for begin plot text by will

              begin plot from bottom left to top left

 - fg_clr   = Color of text

 - bg_clr   = Color background of text

              if bg_clr =no_bg or1=non color background

 ******************************************************/

void lcd_Ascii(uint8_t row,uint8_t font, uint8_t adx,uint16_t ady,uint16_t fg_clr,uint16_t bg_clr)

  {

   uint16_t ay        ;

   uint8_t ax,m,s,n,tx;

   ax = adx         ;

   ay = ady         ;

   row = row-0x20   ;

  // ********** Print Text 1 Charecter(data 14 Byte) **********

      if (font == 1) {s = 6;}

    if (font == 2) {s = 14;}

    for(m=0;m<s;m++)

     {

      // **** Sent data byte1=8 bit ****

    tx = pgm_read_byte(&(ascii_6x8[row][m]));       // Lese Ascii Zeichen Font 1 (6x8)

        if (font == 2)

       {tx = pgm_read_byte(&(ascii_7x11[row][m]));} // Lese Ascii Zeichen Font 2 (7x11)

    for(n=0;n<8;n++)          // Loop Sent data  1 byte(8bit)

       {

          if(tx & 0x80)        // if data bit7 = 1 ,Plot Color area Charecter

         {

          gp_wr_cmm(0x20)      ; // Command Set Adddress Hor(X)

               gp_wr_data(ax)       ; // Sent X_Address CGRAM

               gp_wr_cmm(0x21)      ; // Command Set Address Ver(Y)

                 gp_wr_data(ay)   ; // Sent Y_Address CGRAM

           gp_wr_cmm(0x22)  ; // Command Write data

               gp_wr_data(fg_clr)   ;

         }

        else            // if data bit7 = 0 ,Plot Color area back ground Charecter

        {

         if(bg_clr != 1)

                 {

            gp_wr_cmm(0x20)   ; // Command Set Adddress Hor(X)

                  gp_wr_data(ax)    ; // Sent X_Address CGRAM

                  gp_wr_cmm(0x21)   ; // Command Set Adddress Ver(Y)

                  gp_wr_data(ay)    ; // Sent Y_Address CGRAM

            gp_wr_cmm(0x22)   ; // Command Write data

                  gp_wr_data(bg_clr); // Sent Data

           }

        }

        tx <<= 1                 ; // Shift Right data 1 bit

        ay   = ay-1              ; // Decrement Y-address

       }

        if (font == 2)  //------- Sent data byte2=3 bit (nur Font 2)-----

           {m++                      ; // Increment Next pointter byte Data

          tx = pgm_read_byte(&(ascii_7x11[row][m])); // Read data byte2

         for(n=0;n<3;n++)         // Loop sent data byte2 = 3 bit

           {

              if(tx & 0x80)       // if data bit7 = 1 ,Plot Color area Charecter

            {

             gp_wr_cmm(0x20)   ; // Command Set Adddress Hor(X)

                   gp_wr_data(ax)    ; // Sent X_Address CGRAM

                   gp_wr_cmm(0x21)   ; // Command Set Adddress Ver(Y)

                   gp_wr_data(ay)    ; // Sent Y_Address CGRAM

             gp_wr_cmm(0x22)   ; // Command Write data

                   gp_wr_data(fg_clr);

             }

            else              // if data bit7 = 0 ,Plot Color area back ground Charecter

            {

             if(bg_clr != 1)

                     {

                gp_wr_cmm(0x20)   ; // Command Set Adddress Hor(X)

                      gp_wr_data(ax)    ; // Sent X_Address CGRAM

                      gp_wr_cmm(0x21)   ; // Command Set Adddress Ver(Y)

                      gp_wr_data(ay)    ; // Sent Y_Address CGRAM

                gp_wr_cmm(0x22)   ; // Command Write data

                      gp_wr_data(bg_clr);

               }

            }

            tx <<= 1                ; // Shift Right data 1 bit

            ay = ay-1               ; // -decrement Y-address

           }

       }

    ax = ax+1; // Complet sent data 1 oder 2 Byte (11bit bei Font 2, 8bit bei Font 1) Increment X-Address

    ay = ady ; // Set Position Y-address old

      }       ;

   // **** Fill Back ground Color Position space between Charecter 1 Colum ****

     if(font ==2)

     {

      if(bg_clr != 1)

          {

         for(n=0;n<11;n++)

            {

             gp_wr_cmm(0x20)   ; // Command Set Adddress Hor(X)

               gp_wr_data(ax)    ; // Sent X_Address CGRAM

               gp_wr_cmm(0x21)   ; // Command Set Adddress Ver(Y)

               gp_wr_data(ay)    ; // Sent Y_Address CGRAM

             gp_wr_cmm(0x22)   ; // Command Write data

               gp_wr_data(bg_clr);

           ay = ay-1         ; // Incre ment Y-Address

            }

          }

       }

  }

/************************************************

 Function Print String

 ************************************************

 Parameter :

 *str = Charecter ASCII (String)

 sx,sy = Position X,Y for begin plot text by will

 begin plot from bottom left to top left

 fg_color = color of Text

 bg_color = color Background of text

 ************************************************/

void print_Str(char *str,uint8_t font,uint8_t sx,uint16_t sy,uint16_t fg_color,uint16_t bg_color)

  {

   uint8_t i;

  for (i=0; str[i] != '\0'; i++)

  {

   lcd_Ascii(str[i],font,sx,sy,fg_color,bg_color);

   if(font ==1) {sx += 6;} // Abstand zwischen den Zeichen, bei Font1 = 6 pixel)

   if(font ==2) {sx += 8;} // Abstand zwischen den Zeichen, bei Font2 = 8 pixel)

  }

  }

/*****************************************************

 Funktion: LCD Print Numbers

 *****************************************************

 Formatiert die übergebene "cha" Variable die einen

 Sendet über die LCD_Ascii Funktion eine maximal fünf-

 stellige Zahlenvariable an das Display.

 Parameter :

 - num     :die Zahlenvar. die ausgegeben werden soll

 - nr      :Wieviele Ziffern? 1-5 Zifferstellen.

 - font    :Font für die Ziffern.

 - x       :X-Position

 - y     :Y-Position

 - farbe   :Ziffernfarbe

 - bgfarbe :Hintergrundfarbe

 *****************************************************/

void print_Num(uint16_t num,uint8_t nr,uint8_t font,uint8_t x,uint16_t y,uint16_t fg_color, uint16_t bg_color)

  {

   uint8_t font_x   =0;         // Variable für die Fontbreite

   char     zif      =0;         // Variable für die separierte Ziffer

   if (font == 1) {font_x = 6;}    // X-Pos zur nächsten Ziffer an den Font anpassen

   if (font == 2) {font_x = 7;}    // "

   for(char i=nr; i>0; i--)        // alle Ziffern der Zahl separieren

      {

     if(num >9)           // mehr als 1 Ziffer in Zahl?

      {

        zif   =num %10;       // Ziffer separieren und ...

        num   =num /10;       // von Zahl entfernen

      }

        else               // nur 1 Ziffer in Zahl?

        {

        zif = num; num = 0;      // Ziffer direkt aus Zahl entnehmen, nächste Ziffer =0

      }

     lcd_Ascii(zif +0x30,font,x+((i *font_x)-font_x),y,fg_color,bg_color); // Ziffer am Display ausgeben

      }

  }

/*****************************

 Function Plot Dot 1 Pixel

 *****************************

 Parameter:

 dx,dy = Pos. X,Y for Plot Dot

 color = Color of dot

 *****************************/

void plot_dot(uint8_t dx,uint16_t dy,uint16_t color)

  {

   gp_wr_cmm(0x20)  ; // Command Set Adddress Hor(X)

   gp_wr_data(dx)   ; // Sent X_address for CGRAM

   gp_wr_cmm(0x21)  ; // Command Set Address Ver(Y)

   gp_wr_data(dy)   ; // Sent Y_address for CGRAM

   gp_wr_cmm(0x22)  ; // Command Write Data RGB

   gp_wr_data(color); // write Data

  }

/*********************************************

 Function Draw Line

 *********************************************

 Function: Line(lx1,ly1,lx2,ly2,line_type);

 Input: lx1,ly1   = Start Coordinate Line

        lx2,ly2   = End Coordinate Line

        line_type = Value Thick of Line(1-100)

        color     = Color of line

 *********************************************/

  void Line(uint8_t lx1,uint16_t ly1,uint8_t lx2,uint16_t ly2,uint8_t line_type,uint16_t color)

   {

    uint8_t  tick           ;

    uint8_t  x1=lx1,xx1=lx1;

    uint16_t y1=ly1        ;

    uint8_t  x2=lx2,xx2=lx2;

    uint16_t y2=ly2        ;

  int16_t  dx,dy,inc_dec,two_dx,two_dy,two_dy_dx,two_dx_dy,x,y,p;

    if(lx1>lx2) {x1=lx2; y1=ly2; x2=lx1; y2=ly1;}

    dx  =abs(x2-x1); dy  =abs(y2-y1);

    if(y2>=y1) {inc_dec =1  ;}

  else       {inc_dec = -1;}

    if(dx>dy)

    {

     two_dy=(2*dy)         ;

     two_dy_dx=(2*(dy-dx)) ;

     p=((2*dy)-dx)         ;

       x=x1; y=y1;

       while(x<=x2)

     {

        for(tick=0;tick<line_type;tick++)

       {

        if(xx1==xx2){plot_dot(x+tick,y,color);}

        else        {plot_dot(x,y+tick,color);}

        }

      x++;

        if(p<0) {p += two_dy;}

        else    {y += inc_dec; p += two_dy_dx;}

      } // while

      } // if

       else

      {

       two_dx=(2*dx)        ;

       two_dx_dy=(2*(dx-dy));

       p=((2*dx)-dy)        ;

        x=x1                ;

        y=y1                ;

       while(y!=y2)

      {

       for(tick=0;tick<line_type;tick++)

        {

       if(xx1==xx2) {plot_dot(x+tick,y,color);}

       else      {plot_dot(x,y+tick,color);}

          }

         y+=inc_dec;

       if(p<0) {p+=two_dx;}

       else    {x++; p += two_dx_dy;}

     } // while

     } // else

    }

/**************************************************************************

 Function Draw Circle

 **************************************************************************

 Function: Circle(cx,cy,Radius,tick,color,fill)

 Input   : CX,CY      = Center Point of Circle

           Radius     = radius of Circle

           tick(1-100)= bold of line

            - (have effect when fill=0)

           color      = color of Circle

           fill       = 0: No fill color in Circle, 1: Fill color in Circle

 **************************************************************************/

void Circle(uint8_t cx,uint16_t cy,uint8_t Radius,uint8_t tick,uint16_t color,uint8_t fill)

  {

   int8_t tswitch=0    ;

   uint8_t d,x=0,y=0,bd;

   d = cy-cx ;

   y = Radius;

   tswitch = 3-(2*Radius);

   while(x<=y)

        {

         if(fill==1)

         {

          Line(cx-x,cy+y,cx+x,cy+y,1,color);

          Line(cx-x,cy-y,cx+x,cy-y,1,color);

          Line(cx-y,cy+x,cx+y,cy+x,1,color);

          Line(cx-y,cy-x,cx+y,cy-x,1,color);

         }

       else

         {

            for(bd=0;bd<tick;bd++)

             {

              plot_dot((cx+x)  +bd,(cy+y)+bd,color);

              plot_dot((cx+x)  +bd,(cy-y)+bd,color);

              plot_dot((cx-x)  +bd,(cy+y)+bd,color);

              plot_dot((cx-x)  +bd,(cy-y)+bd,color);

              plot_dot((cy+y-d)+bd,(cy+x)+bd,color);