Ss_TFT.cpp

Go to the documentation of this file.

#include "Ss_TFT.h"

extern const uint8_t BasicSmallFont[];


//Ss_TFT lcd(0,1,2,3,4,5,6,7,A5,A4,A3,A2);
Ss_TFT::Ss_TFT()
{
   pinMode(0,OUTPUT);
   pinMode(1,OUTPUT);
   pinMode(2,OUTPUT);
   pinMode(3,OUTPUT);
   pinMode(4,OUTPUT);
   pinMode(5,OUTPUT);
   pinMode(6,OUTPUT);
   pinMode(7,OUTPUT);
   pinMode(A5,OUTPUT);
   pinMode(A4,OUTPUT);
   pinMode(A3,OUTPUT);
   pinMode(A2,OUTPUT);

   LCD_RS=A5;
   LCD_WR=A4;
   LCD_CS=A3;
   LCD_REST=A2;

    ForeColor=0xFFFF;
    BackColor=0;
    SCR_WW=240; // è sempre la larghezza col display in portrait
    SCR_HH=320;
    SCR_XX=239;
    SCR_YY=319;
    Tc_X=0,Tc_Y=0;
    SCR_WIDTH=SCR_WW; // cambia con l'orientamento
    SCR_HEIGHT=SCR_HH;

    Service=0;
    //0=
    //1=orientation:0 port / 1 Land
    #ifdef USE_HC595
      #ifdef _595_h
        My595=new hc595(2,4,7,2);
      #endif
    #endif
    LocalFont.memory_pointer=0;
    LocalFont.x_size=0;
    LocalFont.y_size=0;
      LocalFont.font_type=0 ;
    LocalFont.c_min=0;
      LocalFont.c_max=0;

      Touchpin(A1,A3,A0,8,9); // Touchpin(tclk,tcs,din,dout,irq)
      TouchRawCalibX=160; //230
      TouchRawCalibSCR_XX=3930; //3800

      TouchRawCalibY=210;
      TouchRawCalibSCR_YY=3720;

}

void Ss_TFT::LCD_Write8(uint8_t data)
{
#ifdef USE_HC595
   #ifdef _595_h
      My595->Send595Pin(data,0);
   #endif
#else
 #ifdef SS_USEDIRECTPORT
  #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

    register uint8_t port=PORTE;

    if(bitRead(data,0)) port |=  B0000001; // pe0 HIGH
    else port &= ~ B0000001; // pe0 LOW
    if(bitRead(data,1)) port |=  B0000010; // pe1 HIGH
    else port &= ~ B0000010; // pe1 LOW
    if(bitRead(data,2)) port |=  B0010000; // pe4 HIGH
    else port &= ~ B0010000; // pe4 LOW
    if(bitRead(data,3)) port |=  B0100000; // pe5 HIGH
    else port &= ~ B0100000; // pe5 LOW
    if(bitRead(data,5)) port |=  B0001000; // pe3 HIGH
    else port &= ~ B0001000; // pe3 LOW
    PORTE=port;
    port=PORTH;
    if(bitRead(data,6)) port |=  B0001000; // ph3 HIGH
    else port &= ~ B0001000; // ph3 LOW
    if(bitRead(data,7)) port |=  B0010000; // ph4 HIGH
    else port &= ~ B0010000; // ph4 LOW
    PORTH=port;

    if(bitRead(data,4)) PORTG |=  B0100000; // pg5 HIGH
    else PORTG &= ~ B0100000; // pg5 LOW

 #else // UNO
    PORTD=data;
  #endif
 #else
 uint8_t i,temp;
  for(i=0;i<8;i++) //FastdigitalWrite(DB[i+8],(data>>i)&1);
  {
    temp=data&0x01;
    FastdigitalWrite(i,temp);
    data=data>>1;
  }
 #endif
#endif
  LCD_WR_LOW
  LCD_WR_HIGH

}



void Ss_TFT::LCD_Write8x2(unsigned short dataL)
{
#ifdef USE_HC595
  #ifdef _595_h
    uint8_t data,i,temp;
    data=dataL>>8;
    My595->Send595Pin(data,0);
    LCD_WR_LOW
    LCD_WR_HIGH
    data=dataL;
    My595->Send595Pin(dataL,0);
  #endif
#else
 #ifdef SS_USEDIRECTPORT
  #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    uint8_t data=dataL>>8;
    register uint8_t port=PORTE;

    if(bitRead(data,0)) port |=  B0000001; // pe0 HIGH
    else port &= ~ B0000001; // pe0 LOW
    if(bitRead(data,1)) port |=  B0000010; // pe1 HIGH
    else port &= ~ B0000010; // pe1 LOW
    if(bitRead(data,2)) port |=  B0010000; // pe4 HIGH
    else port &= ~ B0010000; // pe4 LOW
    if(bitRead(data,3)) port |=  B0100000; // pe5 HIGH
    else port &= ~ B0100000; // pe5 LOW
    if(bitRead(data,5)) port |=  B0001000; // pe3 HIGH
    else port &= ~ B0001000; // pe3 LOW
    PORTE=port;
    port=PORTH;
    if(bitRead(data,6)) port |=  B0001000; // ph3 HIGH
    else port &= ~ B0001000; // ph3 LOW
    if(bitRead(data,7)) port |=  B0010000; // ph4 HIGH
    else port &= ~ B0010000; // ph4 LOW
    PORTH=port;
    if(bitRead(data,4)) PORTG |=  B0100000; // pg5 HIGH
    else PORTG &= ~ B0100000; // pg5 LOW
    data=dataL;
     LCD_WR_LOW
     LCD_WR_HIGH
     if(bitRead(data,0)) port |=  B0000001; // pe0 HIGH
    else port &= ~ B0000001; // pe0 LOW
    if(bitRead(data,1)) port |=  B0000010; // pe1 HIGH
    else port &= ~ B0000010; // pe1 LOW
    if(bitRead(data,2)) port |=  B0010000; // pe4 HIGH
    else port &= ~ B0010000; // pe4 LOW
    if(bitRead(data,3)) port |=  B0100000; // pe5 HIGH
    else port &= ~ B0100000; // pe5 LOW
    if(bitRead(data,5)) port |=  B0001000; // pe3 HIGH
    else port &= ~ B0001000; // pe3 LOW
    PORTE=port;
    port=PORTH;
    if(bitRead(data,6)) port |=  B0001000; // ph3 HIGH
    else port &= ~ B0001000; // ph3 LOW
    if(bitRead(data,7)) port |=  B0010000; // ph4 HIGH
    else port &= ~ B0010000; // ph4 LOW
    PORTH=port;
    if(bitRead(data,4)) PORTG |=  B0100000; // pg5 HIGH
    else PORTG &= ~ B0100000; // pg5 LOW





 #else // UNO
    PORTD=dataL>>8;
         LCD_WR_LOW
  LCD_WR_HIGH
  PORTD=dataL;
  #endif
 #else
 uint8_t data,i,temp;
 data=dataL>>8;
  for(i=0;i<8;i++) //FastdigitalWrite(DB[i+8],(data>>i)&1);
  {
    temp=data&0x01;
    FastdigitalWrite(i,temp);
    data=data>>1;
  }
  data=dataL;
  LCD_WR_LOW
  LCD_WR_HIGH
  for(i=0;i<8;i++) //FastdigitalWrite(DB[i+8],(data>>i)&1);
  {
    temp=data&0x01;
    FastdigitalWrite(i,temp);
    data=data>>1;
  }
 #endif
#endif
  LCD_WR_LOW
  LCD_WR_HIGH

}



void Ss_TFT::LCD_Write_COMM8(unsigned short comm)
{
  LCD_RS_LOW
  LCD_Write8x2(comm);
}


void Ss_TFT::LCD_Write_DATA8(unsigned short data)
{
  LCD_RS_HIGH
  LCD_Write8x2(data);
}

void Ss_TFT::LCD_Write_CD(unsigned short command,unsigned short data)
{
  LCD_Write_COMM8(command);
  LCD_Write_DATA8(data);
}

void Ss_TFT::SetXY(unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{


  LCD_Write_CD(0x0020,x1);
  LCD_Write_CD(0x0021,y1);
  LCD_Write_CD(0x0050,x1);
  LCD_Write_CD(0x0052,y1);
  LCD_Write_CD(0x0051,x2);
  LCD_Write_CD(0x0053,y2);
  LCD_Write_COMM8(0x0022);//LCD_Write_COM(0x00,0x22);

}
/*!Inizialize dislay in standar portrait orientation*/
void Ss_TFT::Initialize()
{
  FastdigitalWrite(LCD_REST,HIGH);
  delay(5);
  FastdigitalWrite(LCD_REST,LOW);
  delay(15);
  FastdigitalWrite(LCD_REST,HIGH);
  delay(15);
  //FastdigitalWrite(LCD_CS,LOW);
  LCD_CS_LOW
  //************* Start Initial Sequence **********//
  LCD_Write_CD(0x00E5,0x78F0); // set SRAM internal timing
  LCD_Write_CD(0x0001,0x0100); // set SS and SM bit - Driver Output Control
  LCD_Write_CD(0x0002,0x0000); // set 1 line inversion //LCD_Write_CD(0x0002,0x0700);
  LCD_Write_CD(0x0003,0x1030); // set GRAM write direction and BGR=1.

  //LCD_Write_CD(0x0004,0x0000); // Resize register
  LCD_Write_CD(0x0008,0x0207); // set the back porch and front porch
  LCD_Write_CD(0x0009,0x0000); // set non-display area refresh cycle ISC[3:0]
  LCD_Write_CD(0x000A,0x0000); // FMARK function
  LCD_Write_CD(0x000C,0x0000); // RGB interface setting
  LCD_Write_CD(0x000D,0x0000); // Frame marker Position
  LCD_Write_CD(0x000F,0x0000); // RGB interface polarity

  //*************Power On sequence ****************//
  LCD_Write_CD(0x0010,0x0000); // SAP, BT[3:0], AP, DSTB, SLP, STB // (0x0010, 0x1690
  LCD_Write_CD(0x0011,0x0007); // DC1[2:0], DC0[2:0], VC[2:0]
  LCD_Write_CD(0x0012,0x0000); // VREG1OUT voltage
  LCD_Write_CD(0x0013,0x0000); // VDV[4:0] for VCOM amplitude
  LCD_Write_CD(0x0007,0x0001);

  delay(200); // Dis-charge capacitor power voltage
  LCD_Write_CD(0x0010,0x1690); // 1490//SAP, BT[3:0], AP, DSTB, SLP, STB
  LCD_Write_CD(0x0011,0x0227); // DC1[2:0], DC0[2:0], VC[2:0]

  delay(50); // Delay 50ms
  LCD_Write_CD(0x0012,0x000D); //1C-1f// Internal reference voltage= Vci;
  delay(50); // Delay 50ms
  LCD_Write_CD(0x0013,0x1200);//0x1000//1400   Set VDV[4:0] for VCOM amplitude  1A00
  LCD_Write_CD(0x0029,0x000A);//0x0012 //001a  Set VCM[5:0] for VCOMH  //0x0025  0034
  LCD_Write_CD(0x002B,0x000D);// Set Frame Rate   000C

  delay(50); // Delay 50ms

  LCD_Write_CD(0x0020,0x0000);// GRAM horizontal Address
  LCD_Write_CD(0x0021,0x0000);// GRAM Vertical Address

  // ----------- Adjust the Gamma Curve ----------//

    LCD_Write_CD(0x30, 0x0000);
    LCD_Write_CD(0x31, 0x0404);
    LCD_Write_CD(0x32, 0x0003);
    LCD_Write_CD(0x35, 0x0405);
    LCD_Write_CD(0x36, 0x0808);
    LCD_Write_CD(0x37, 0x0407);
    LCD_Write_CD(0x38, 0x0303);
    LCD_Write_CD(0x39, 0x0707);
    LCD_Write_CD(0x3C, 0x0504);
    LCD_Write_CD(0x3D, 0x0808);

    //------------------ Set GRAM area ---------------//

  LCD_Write_CD(0x0050,0x0000);// Horizontal GRAM Start Address
  LCD_Write_CD(0x0051,0x00EF);// Horizontal GRAM End Address
  LCD_Write_CD(0x0052,0x0000);// Vertical GRAM Start Address
  LCD_Write_CD(0x0053,0x013F);// Vertical GRAM End Address
  LCD_Write_CD(0x0060,0xA700);// Gate Scan Line
  LCD_Write_CD(0x0061,0x0001); // NDL,VLE, REV
  LCD_Write_CD(0x006A,0x0000);// set scrolling line

  //-------------- Partial Display Control ---------//
  LCD_Write_CD(0x0080,0x0000);
  LCD_Write_CD(0x0081,0x0000);
  LCD_Write_CD(0x0082,0x0000);
  LCD_Write_CD(0x0083,0x0000);
  LCD_Write_CD(0x0084,0x0000);
  LCD_Write_CD(0x0085,0x0000);

    //-------------- Panel Control -------------------//

  LCD_Write_CD(0x0090,0x0010);
  LCD_Write_CD(0x0092,0x0600);
  LCD_Write_CD(0x0007,0x0133);// 262K color and display ON

  //FastdigitalWrite(LCD_CS,HIGH);
  LCD_CS_HIGH


}
/*
resta bianco, in stand by ma non si spegne.
 LCD_CS_LOW
 lcd.LCD_Write_CD(0x0007,0x0030);// 262K color and display ON
 LCD_CS_HIGH*/

 /*!Draw empty rectangle 
\param x0 x coordinate of starting point
\param y0 y coordinate of starting point
\param x1 x coordinate of target point
\param y1 y coordinate of target point

*/
void Ss_TFT::Rect(int x0,int y0,int x1,int y1)
{
  LCD_CS_LOW
  LCD_RS_HIGH
  Line(x0,y0,x1,y0);
  LCD_RS_HIGH
  Line(x0,y1,x1,y1);
  LCD_RS_HIGH
  Line(x0,y0+1,x0,y1-1);
  LCD_RS_HIGH
  Line(x1,y0,x1,y1-1);
  LCD_CS_HIGH
}

void Ss_TFT::CheckPoint(int * x,int * y)
{
  if(*x<0) *x=0;
  if(*x>SCR_XX) *x=SCR_XX;
  if(*y<0) *y=0;
  if(*y>SCR_YY) *y=SCR_YY;
}


/*!Draw filled rectangle 
\param sx x coordinate of starting point
\param sy y coordinate of starting point
\param ex x coordinate of target point
\param ey y coordinate of target point
\param force optional parameter (default false): if set to true the dysplay orientation will be ignored (used default portrait)
*/

void Ss_TFT::RectFill(int sx,int sy, int ex, int ey,bool force)
{
  unsigned short  i,j;

if (bitRead(Service,1)==Ss_LANDSCAPE && !force)
    {
        int z;
        int dx=ex-sx;
        int dy=ey-sy;
        z=sx;
        sx=sy;
        sy=SCR_YY-z-dx;
        ex=sx+dy;
        ey=sy+dx;

    }



  LCD_CS_LOW
  SetXY(sx,sy,ex,ey);
  LCD_RS_HIGH
  for(i=0;i<(ey-sy+1);i++)
  {
    for (j=0;j<(ex-sx+1);j++)
    {

      LCD_Write8x2(ForeColor);//LCD_Write_DATA8(ForeColor);

    }
  }

  LCD_CS_HIGH
}
/*!This function empties the display content. Without parameter it uses the white color.
Alternatively you can select a color on the format 0xRRGGBB.
\param rgb optional background color
*/
void Ss_TFT::CleanLCD(unsigned short rgb)
{
  unsigned int fc=ForeColor;
  //SetFcolor(255,255,255);
  ForeColor=rgb;
  RectFill(0,0,SCR_XX,SCR_YY,1);
  ForeColor=fc;
}
/*!Sets foreground color. Every componente are from 0 to 255 (8bit for channel) but the display support less colors number, for this an automatic conversion will done.
\param r red component
\param g green component
\param b blue component 
*/
void Ss_TFT::SetFcolor(uint8_t r,uint8_t g,uint8_t b)
{
   ForeColor=((r>>3)<<11)+((g>>2)<<5)+(b>>3);
}
/*!Sets background color. Every componente are from 0 to 255 (8bit for channel) but the display support less colors number, for this an automatic conversion will done.
\param r red component
\param g green component
\param b blue component 
*/
void Ss_TFT::SetBcolor(uint8_t r,uint8_t g,uint8_t b)
{
     BackColor=((r>>3)<<11)+((g>>2)<<5)+(b>>3);
}
/*!Sets foreground and color using single integer value (for example 0xff00cc
\param FC Foreground color
\param BC Background color

*/
void Ss_TFT::SetFBcolor(int FC,int BC)
{
     ForeColor=FC;
     BackColor=BC;
}

/*!Draw horizontal line
\param x x coordinate of starting point
\param y y coordinate of starting point
\param ln lenght of line
*/
void Ss_TFT::HLine(short x,short y, short ln)
{
    if (ln<0) {ln = -ln;x -= ln;}
    if(x<0) {ln+=x;x=0;}
    else if(x>SCR_XX) {ln-=(x-SCR_XX);x=SCR_XX;}

    SetXY(x, y, x+ln, y);
    LCD_RS_HIGH
    for (unsigned short i=0; i<ln+1; i++) LCD_Write8x2(ForeColor);//LCD_Write_DATA8(ForeColor);
}
/*!Draw vertical line
\param x x coordinate of starting point
\param y y coordinate of starting point
\param ln lenght of line
*/
void Ss_TFT::VLine(short x, short y, short ln)
{

      if (ln<0) {ln = -ln;y -= ln;}
    if(y<0) {ln+=y;y=0;}
    else if(y>SCR_YY) {ln-=(y-SCR_YY); y=SCR_YY;}
      SetXY(x, y, x, y+ln);
      LCD_RS_HIGH
      for (unsigned short i=0; i<ln+1; i++) LCD_Write8x2(ForeColor);//LCD_Write_DATA8(ForeColor);


}


void Ss_TFT::LineVS(int x,int y, int l)
{
 Line(x,y,x,y+l);
}
void Ss_TFT::LineHS(int x,int y, int l)
{
 Line(x,y,x+l,y);
}

/*!Draw  line
\param x1 x coordinate of starting point
\param y1 y coordinate of starting point
\param x2 x coordinate of target point
\param y2 y coordinate of target point
*/
void Ss_TFT::Line(int x1,int y1, int x2, int y2)
{
  LCD_CS_LOW
  if (bitRead(Service,1)==Ss_LANDSCAPE)
    {
        int z;
        z=x1;
        x1=y1;
        y1=SCR_YY-z;
    z=x2;
        x2=y2;
        y2=SCR_YY-z;
    }


    if (y1==y2) HLine(x1, y1, x2-x1);
    else if (x1==x2) VLine(x1, y1, y2-y1);
    else
    {




    unsigned short  dx,xstep,dy,ystep;
        unsigned short  col = x1, row = y1;

    if(x2>x1) {dx=x2-x1;xstep=1;}
    else {dx=x1-x2;xstep=-1;}
    if(y2>y1) {dy=y2-y1;ystep=1;}
    else {dy=y1-y2;ystep=-1;}

        if (dx < dy)
        {
            int t = - (dy >> 1);
            while (true)
            {
                SetXY (col, row, col, row);
                LCD_Write_DATA8(ForeColor);
                if (row == y2) return;
                row += ystep;
                t += dx;
                if (t >= 0)
                {
                    col += xstep;
                    t   -= dy;
                }
            }
        }
        else
        {
            int t = - (dx >> 1);
            while (true)
            {
                SetXY (col, row, col, row);
                LCD_Write_DATA8(ForeColor);
                if (col == x2) return;
                col += xstep;
                t += dy;
                if (t >= 0)
                {
                    row += ystep;
                    t   -= dx;
                }
            }
        }
    }
    LCD_CS_HIGH
}

/*!Draw empty circle
\param cx x coordinate of circle center
\param cy y coordinate of circle center
\param radius radius
*/
void Ss_TFT::Circle(int cx, int cy, int radius) //7227 -- 7194
{

  if (bitRead(Service,1)==Ss_LANDSCAPE)
    {
        int z;
        z=cx;
        cx=cy;
        cy=SCR_YY-z;
    }


  LCD_CS_LOW

  int error = -radius;
  int x = radius;
  int y = 0;

  while (x > y)
  {
    plot4points(cx, cy, x, y);
    plot4points(cx, cy, y, x);

    error += y;
    ++y;
    error += y;

    if (error>=0) //!(error&0x80))
    {
      error -= x;
      --x;
      error -= x;
    }
  }

  LCD_CS_HIGH
}

void Ss_TFT::plot4points(int cx, int cy, int x, int y)
{
  FPixel(cx + x, cy + y);

  if (x)
  {
    FPixel(cx - x, cy + y);
    if (y ) FPixel(cx - x, cy - y);
  }
  if (y ) FPixel(cx + x, cy - y);
}

 /*!Draw filled circle
\param cx x coordinate of circle center
\param cy y coordinate of circle center
\param radius radius
*/
void Ss_TFT::CircleFill(int x, int y, int raggio)  //7383
{
    for(int y1=-raggio; y1<=0; y1++)
        for(int x1=-raggio; x1<=0; x1++)
            if(x1*x1+y1*y1 <= raggio*raggio)
            {
                Line(x-x1, y+y1, x+x1,y+y1);
                Line(x-x1, y-y1,x+x1,y-y1);
                break;
            }
}






void Ss_TFT::d32s(short x,short y,uint8_t val)
{
  uint8_t i,j,ch,seg,bsp,cmax,spx,spy; // bsp è lo spazio fra i segmenti
  unsigned short offset;

  if(LocalFont.font_type!=2) return;
  seg=LocalFont.x_size;
  bsp=LocalFont.y_size;
  spx=LocalFont.sp_x;
  spy=LocalFont.sp_y;
  val++; // nel primo carattere memorizzo il simbolo d'errore
  if(val<LocalFont.c_min+1) val=LocalFont.c_min; // occhio che c_min da qui in poi contiene l'errore e NON il primo carattere
  if(val>LocalFont.c_max+1) val=LocalFont.c_min;
  offset=4*(val-LocalFont.c_min);

  //cmax=LocalFont.c_max;




  LocalFont.font_x_space=4*spx+7+8*seg;
  LocalFont.font_y_space=4*spy+7+8*seg;

  LCD_CS_LOW


 uint8_t b1=pgm_read_byte(LocalFont.memory_pointer+offset);
 uint8_t b2=pgm_read_byte(LocalFont.memory_pointer+offset+1);
 uint8_t b3=pgm_read_byte(LocalFont.memory_pointer+offset+2);
 uint8_t b4=pgm_read_byte(LocalFont.memory_pointer+offset+3);

 //b1=b2=b3=b4=255;

 unsigned short VU=1+2*seg;
 unsigned short HU=1+2*seg;

 unsigned short HSU=1+spx;
 unsigned short VSU=1+spy;

 unsigned short VSegment=2*VSU+3*seg+1;
 unsigned short HSegment=2*HSU+3*seg+1;//2*HSU+HU+1+seg;
 uint8_t step;

 unsigned short x1,x2,x3,y1,y2,y3,y4,y5,x4,x5;

 x1=x+seg; // togliere -1
 x2=x1+HSegment;
 x3=x2+HSegment;
 y1=y+seg; // togli -1
 y2=y1+VSegment;
 y3=y2+VSegment;

 //bsp*=2;

 VSegment-=(2*bsp);
 HSegment-=(2*bsp);

y4=(y2+y1)>>1;
y5=(y3+y2)>>1;
x4=(x1+x2)>>1;
x5=(x2+x3)>>1;

//LocalFont.font_x_space=x3-x1+2*seg+1;
//LocalFont.font_y_space=y3-y1+2*seg+1;

 for(step=0;step<seg;step++)
 {
 // PRIMO BYTE 1 - 8
   if(bitRead(b1,7)) //segmento 1
   {
     LineVS(x1-step,y1+step+bsp,VSegment-step*2);
     if(step) LineVS(x1+step,y1+step+bsp,VSegment-step*2);

   }
   if(bitRead(b1,6)) //segmento 2
   {
      LineVS(x1-step,y2+step+bsp,VSegment-step*2);
     if(step) LineVS(x1+step,y2+step+bsp,VSegment-step*2);
   }
   if(bitRead(b1,5))  //segmento 3
   {
     LineVS(x2-step,y1+step+bsp,VSegment-step*2);
     if(step) LineVS(x2+step,y1+step+bsp,VSegment-step*2);
   }

   if(bitRead(b1,4)) //segmento 4
   {
     LineVS(x2-step,y2+step+bsp,VSegment-step*2);
     if(step) LineVS(x2+step,y2+step+bsp,VSegment-step*2);
   }

   if(bitRead(b1,3)) //segmento 5
   {
     LineVS(x3-step,y1+step+bsp,VSegment-step*2);
     if(step) LineVS(x3+step,y1+step+bsp,VSegment-step*2);
   }

   if(bitRead(b1,2)) //segmento 6
   {
      LineVS(x3-step,y2+step+bsp,VSegment-step*2);
     if(step) LineVS(x3+step,y2+step+bsp,VSegment-step*2);
   }

    if(bitRead(b1,1))//segmento 7
    {
      LineHS(x1+step+bsp,y1-step,HSegment-step*2);
      if(step) LineHS(x1+step+bsp,y1+step,HSegment-step*2);
    }

    if(bitRead(b1,0))//segmento 8
    {
      LineHS(x2+step+bsp,y1-step,HSegment-step*2);
      if(step) LineHS(x2+step+bsp,y1+step,HSegment-step*2);
    }

// SECONDO BYTE 9 - 16
    //HSegment+=2;
    if(bitRead(b2,7)) //segmento 9
    {
      LineHS(x1+step+bsp,y2-step,HSegment-step*2);
      if(step) LineHS(x1+step+bsp,y2+step,HSegment-step*2);
    }

    if(bitRead(b2,6)) //segmento 10
    {
      LineHS(x2+step+bsp,y2-step,HSegment-step*2);
      if(step) LineHS(x2+step+bsp,y2+step,HSegment-step*2);
    }

    if(bitRead(b2,5))//segmento 11
    {
      LineHS(x1+step+bsp,y3-step,HSegment-step*2);
      if(step) LineHS(x1+step+bsp,y3+step,HSegment-step*2);
    }

    if(bitRead(b2,4)) //segmento 12
    {
      LineHS(x2+step+bsp,y3-step,HSegment-step*2);
      if(step) LineHS(x2+step+bsp,y3+step,HSegment-step*2);
    }
    if(bitRead(b2,3))//segmento 13
    {
      Line(x1+step+seg+bsp,y1+seg+bsp,x2-seg-bsp,y2-step-seg-bsp);
      if(step) Line(x1+seg+bsp,y1+step+seg+bsp,x2-step-seg-bsp,y2-seg-bsp);
    }

    if(bitRead(b2,2))//segmento 14
    {
      Line(x2+seg+bsp,y2-seg-step-bsp,x3+bsp-step-seg-bsp,y1+seg+bsp);
      if(step) Line(x2+step+seg+bsp,y2-seg-bsp,x3-seg-bsp,y1+step+seg+bsp);
    }

    if(bitRead(b2,1))  //segmento 15
    {
      Line(x1+seg+bsp,y3-step-seg-bsp,x2-seg-step-bsp,y2+seg+bsp);
      if(step) Line(x1+step+seg+bsp,y3-seg-bsp,x2-seg-bsp,y2+step+seg+bsp);
    }


    if(bitRead(b2,0))//segmento 16
    {
      Line(x2+step+seg+bsp,y2+seg+bsp,x3-seg-bsp,y3-step-seg-bsp);
      if(step) Line(x2+seg+bsp,y2+step+seg+bsp,x3-step-seg-bsp,y3-seg-bsp);
    }

// TERZO BYTE 17 - 24
   if(bitRead(b3,7))//segmento 17
    {
      HLine(x1+bsp+seg+1,y4+step-(seg>>1),HSegment-2*seg-2);
    }

   if(bitRead(b3,6))//segmento 18
    {
      HLine(x2+bsp+seg+1,y4+step-(seg>>1),HSegment-2*seg-2);
    }

   if(bitRead(b3,5))//segmento 19
    {
      HLine(x1+bsp+seg+1,y5+step-(seg>>1),HSegment-2*seg-2);
    }
   if(bitRead(b3,4))//segmento 20
    {
      HLine(x2+bsp+seg+1,y5+step-(seg>>1),HSegment-2*seg-2);
    }

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

   if(bitRead(b3,3))//segmento 21
    {
      VLine(x4+step-(seg>>1),y1+bsp+seg+1,VSegment-2*seg-2);
    }
     if(bitRead(b3,2))//segmento 22
    {
      VLine(x5+step-(seg>>1),y1+bsp+seg+1,VSegment-2*seg-2);
    }


    if(bitRead(b3,1))//segmento 23
    {
      VLine(x4+step-(seg>>1),y2+bsp+seg+1,VSegment-2*seg-2);
    }
    if(bitRead(b3,0))//segmento 24
    {
      VLine(x5+step-(seg>>1),y2+bsp+seg+1,VSegment-2*seg-2);
    }




// QUARTO BYTE 25 - 16

  // SetFcolor(0,0,255);
   if(bitRead(b4,6))
   {
     HLine(x2-step,y3+step,step*2);//RectFill(x2-seg,y3-seg,x2+seg,y3+seg);//segmento 26
     HLine(x2-step,y3+seg+(seg-step),step*2);//RectFill(x2-seg,y3-seg,x2+seg,y3+seg);//segmento 26
   }
 }
 }

/*!Select the font type. Parameters changes if you use bitmap or vectorial font. If you use bitmap font you have to choice only the font pointer:
\code
extern uint8_t BasicSmallFont[];
...
lcd.SetFont(BasicSmallFont);
\endcode
If you want to use the vectorial font you must use 4 parameters: font pointer, segment width, segment height, space between segments, more X width and Y height (for change X:Y ratio).
\code
extern unsigned char SegmentFont[]; 
...
lcd.SetFont(SegmentFont,2,1,0); 
\endcode
*/
void Ss_TFT::SetFont(uint8_t * font,uint8_t x,uint8_t y,uint8_t spx,uint8_t spy)
{
    LocalFont.font_type=pgm_read_byte(font+0);
    if(LocalFont.font_type==1)
  {
     LocalFont.x_size=pgm_read_byte(font+1);
     LocalFont.y_size=pgm_read_byte(font+2);
     LocalFont.c_min=pgm_read_byte(font+3);
     LocalFont.c_max=pgm_read_byte(font+4);
     LocalFont.memory_pointer=font+5;
     LocalFont.sp_x=x; // usato per mantenere l'opzione di zoom sugli assi x ed y
     LocalFont.font_x_space=LocalFont.x_size;
     LocalFont.font_y_space=LocalFont.y_size;
  }
  else if(LocalFont.font_type==2)
  {
    //if(x<1) x=1;
     LocalFont.x_size=x; //  spessore dei segmenti - seg
     LocalFont.y_size=y; //  usato per il bordo di spaziatura fra i segmenti
   LocalFont.sp_x=spx;// spaziatura aggiuntiva  x
     LocalFont.sp_y=spy;// spaziatura aggiuntiva y
     LocalFont.c_min=pgm_read_byte(font+1);
     LocalFont.c_max=pgm_read_byte(font+2);
     LocalFont.memory_pointer=font+3;
   LocalFont.font_x_space=4*spx+7+8*x;//4*spx+6*x+11;//4*(1+2*x)+spx*4+4;
   LocalFont.font_y_space=4*spy+7+8*y;////4*spy+10*x+12;//6*(1+2*x)+spy*4;;
  }
}

void Ss_TFT::SetFontOption(uint8_t option) // da usare SOLO con fonttype=1
{
  if(LocalFont.font_type==1)
  {
    LocalFont.font_x_space=LocalFont.x_size;
    LocalFont.font_y_space=LocalFont.y_size;
    if(bitRead(option,0)) LocalFont.font_x_space=LocalFont.x_size<<1; // raddoppia X
    if(bitRead(option,1)) LocalFont.font_y_space=LocalFont.y_size<<1; // raddoppia Y
  }
}

void Ss_TFT::DisplayChar(short x,short y ,uint8_t val,uint8_t option)
{
 uint8_t type;
 type=LocalFont.font_type;
 LocalFont.sp_x=option;

 if(type==1)
 {
   SetFontOption(option);
   DisplayBitmapChar(x,y,val,option);
 }
 else if(type==2) d32s(x,y,val);

 //localX=x+LocalFont.x_size;
 //localY=y+LocalFont.y_size;
}




void Ss_TFT::DisplayBitmapChar(int x,int y ,uint8_t val,uint8_t option)
{

    uint8_t i,j,ch,chx,chy,cmin,cmax,bit,type,sp=1,L,H;
    unsigned int bitnum,bytenum;

   uint8_t bit_x,bit_y;
   uint8_t *bit_buff;

    type=LocalFont.font_type;
    chx=LocalFont.x_size;
    chy=LocalFont.y_size;
    cmin=LocalFont.c_min;
    cmax=LocalFont.c_max;

    if(type!=1) return; // segmenti
    if(option>3) option=3;


   if (bitRead(Service,1)==Ss_LANDSCAPE) GetLandscapePoint(&x,&y);// rotazione di 90 gradi
    /* {
        int z;
        z=x;
        x=y;
        y=SCR_YY-z;
     }*/


        bit_x=chx;
        bit_y=chy;
   if(bitRead(option,0)) bit_x=bit_x*2;
   if(bitRead(option,1)) bit_y=bit_y*2;

   bit_buff=(uint8_t*)malloc(bit_x*bit_y);

    LCD_CS_LOW




    //HU=2*SP+1;

    bitnum=(val-cmin)*chx*chy;
    bool *  myarray;
    myarray=(bool *)malloc(sizeof(bool)*chy*chx);
    unsigned short pointer=0,fpointer=0;

    for(j=0;j<chy;j++) // preparo un array di valori booleani per una più facile gestione
    {
        for(i=0;i<chx;i++)
        {
          bytenum=bitnum>>3; //Fbit/8;
          bit=bitnum-8*bytenum;
          ch=pgm_read_byte(LocalFont.memory_pointer+bytenum);
          if(ch&(1<<(7-bit))) *(myarray+pointer)=1;
          else *(myarray+pointer)=0;
          pointer++;
          bitnum++;
        }
    }
    if (bitRead(Service,1)==Ss_LANDSCAPE) SetXY(x,y-bit_x+1,x+bit_y-1,y);
    else SetXY(x,y,x+bit_x-1,y+bit_y-1);


// option: 0:1:1 1:2x 2:2y 3:2xy

    pointer=0;
    bool FoB1=0;
    bool FoB2=0;
    // e ora interagisco con i valori.

    for(j=0;j<chy;j++)
    {

        for(i=0;i<chx;i++) // for x prima riga
        {

           FoB1=0;
           FoB2=0;

          if(*(myarray+pointer))
              {
           FoB1=1; // 1
           if(i<chx-1) if(*(myarray+pointer+1)) FoB2=1;//2 //OK
           if(option==1) FoB2=1; // duplicazione solo x
              }



            if(FoB1) {*(bit_buff+fpointer)=1;/*LCD_Write_DATA8(ForeColor);*/}
          else {*(bit_buff+fpointer)=0;/*LCD_Write_DATA8(BackColor);*/}

            if(option==1 || option==3)  if(FoB2){fpointer++;/*LCD_Write_DATA8(ForeColor);*/*(bit_buff+fpointer)=1; }// solo x doppie
          else {fpointer++;/*LCD_Write_DATA8(BackColor);*/*(bit_buff+fpointer)=0;}


          pointer++;
            fpointer++;
        } // for x prima riga


    if(bitRead(option,1)) // solo y doppie
    {
        pointer-=chx;

          for(i=0;i<chx;i++) // for x seconda riga -  righe calcolate
        {
          FoB1=0;
          FoB2=0;

           if(j<chy-1)
           {
            if(*(myarray+pointer+chx) & *(myarray+pointer) ) FoB1=1;//1
            if(option==2 && *(myarray+pointer)) FoB1=1; // duplicazione solo y
            if(*(myarray+pointer+chx+1)  & *(myarray+pointer) & *(myarray+pointer+1)==0 & *(myarray+pointer+chx)==0) FoB2=1;//2 //ok
           if(i<chx-1)  if( *(myarray+pointer)==0 & *(myarray+pointer+chx) & *(myarray+pointer+1) & *(myarray+pointer+chx+1)==0) FoB2=1;
          }


          if(FoB1) *(bit_buff+fpointer)=1;
          else *(bit_buff+fpointer)=0;

            if(option==3)
          {
              if(FoB2) {fpointer++;*(bit_buff+fpointer)=1;}
              else {fpointer++;*(bit_buff+fpointer)=0;}
            }


            pointer++;
            fpointer++;
        } // for x seconda riga*/


    } // option


        //temp++;

     } // for y



    pointer=0;
    uint8_t * bitpointer=0;



    if(!bitRead(Service,1))
    {
      for(j=0;j<bit_y;j++) // pre
      {
        for(i=0;i<bit_x;i++)
        {
          //if(*(bit_buff+i+j*bit_x)) LCD_Write_DATA8(ForeColor);
          if(*(bit_buff+pointer)) LCD_Write_DATA8(ForeColor);
          else LCD_Write_DATA8(BackColor);
          pointer++;
        }
      }
    }
    else // LANDSCAPE
    {
      for(i=0;i<bit_x;i++) // pre
      {
        for(j=0;j<bit_y;j++)
        {
          if(*(bit_buff+(bit_x-i-1)+j*bit_x))LCD_Write_DATA8(ForeColor);
          else LCD_Write_DATA8(BackColor);
        }
      }
    }

    free(myarray);
    free(bit_buff);
    //FastdigitalWrite(LCD_CS,HIGH);
    LCD_CS_HIGH

}

 /*!This function writes a string to the display in the selected position, using actual font and colors.
 
For vectorial font you need 3 parameters: X, Y and string
\code
lcd.DisplayString(10,10,"MCMAJAN.COM");
\endcode
If you are using a bitmap font, you have to add a fourth parameter: this one at 0 indicate normal dimension, at 1 doubles X, at 2 doubles Y, at 3 doubles X and Y.
\code
lcd.DisplayString(10,10,"MCMAJAN.COM",3);
\endcode
*/
void Ss_TFT::DisplayString(int x,int y, char *st,uint8_t options)
{
  unsigned int x1,y1;
  x1=x;
  y1=y;
  if(LocalFont.font_type==1) SetFontOption(options);
  //FastdigitalWrite(LCD_CS,LOW);
  LCD_CS_LOW
    while(*st!='\0')
    {
        DisplayChar(x1,y1,*st,options);
        x1+=LocalFont.font_x_space;
        st++;
    }
  LCD_CS_HIGH
}

/*!Draw a single dot
\param x 
\param y
*/
void Ss_TFT::Pixel(int x, int y)
{
  LCD_CS_LOW //FastdigitalWrite(LCD_CS,LOW);
  SetXY(x, y, x, y);
  LCD_RS_HIGH
  LCD_Write8x2(ForeColor);
  LCD_CS_HIGH //FastdigitalWrite(LCD_CS,HIGH);
}

void Ss_TFT::GetLandscapePoint(int * x,int * y)
{
        int z;
        z=*x;
        *x=*y;
        *y=SCR_YY-z;
}




// TOUCH


void Ss_TFT::Touchpin(int tclk,int tcs,int din,int dout, int irq)
{
    T_CLK=tclk;
    pinMode(T_CLK,OUTPUT);
    T_CS=tcs;
    pinMode(T_CS,OUTPUT);
    T_DIN=din;
    pinMode(T_DIN,OUTPUT);
    T_DOUT=dout;
    pinMode(T_DOUT,INPUT);
    T_IRQ=irq;
    pinMode(T_IRQ,INPUT);
}

/*! Initialize touch screen capabilities*/
void Ss_TFT::TouchInitial()
{
  FastdigitalWrite(T_CS,HIGH);
  FastdigitalWrite(T_CLK,HIGH);
  FastdigitalWrite(T_DIN,HIGH);
  FastdigitalWrite(T_CLK,HIGH);
}

void Ss_TFT::Write7843(uint8_t num)
{

  //S A2 A1 A0 MOD SER PD1 PD0

  uint8_t count=0;
  uint8_t temp;
  unsigned nop;
  temp=num;
  FastdigitalWrite(T_CLK,LOW);
  for(count=0;count<8;count++)
  {
    if(temp&0x80) // primo bit sempre alto
      FastdigitalWrite(T_DIN,HIGH);
    else
      FastdigitalWrite(T_DIN,LOW);

    temp=temp<<1;

    FastdigitalWrite(T_CLK,LOW);
    nop++;
    FastdigitalWrite(T_CLK,HIGH);
    nop++;

  }
}

unsigned int Ss_TFT::Read7843()
{
  //unsigned nop;
  uint8_t count=0;
  unsigned short Num=0;
  for(count=0;count<12;count++)
  {
    Num<<=1;
    HPulse(T_CLK);
    if(FastdigitalRead(T_DOUT)) Num++;
  }
  return(Num);
}
/*!Transforms raw touch screen coordinates to real X,Y pixel. If you need it, you can read coordinates reading Tc_X e Tc_Y.
\code
     lcd.TouchGetPoint();
     int lx=lcd.Tc_X;
     int ly=lcd.Tc_Y;
\endcode     
*/

void Ss_TFT::TouchGetPoint()
{


  FastdigitalWrite(T_CS,LOW);
  //for(;;)
  //{
   Write7843(0x90);     //1001 0000 A0 12 bit differenziale Y
   HPulse(T_CLK);
   TouchRawY=Read7843();
   //if(TouchRawY>0 && TouchRawY<4096) break;
  //}
  //for(;;)
  //{
   Write7843(0xD0);    //1101 0000 A2 A0 12 bit differenziale X
   HPulse(T_CLK);
   TouchRawX=Read7843();
   //if(TouchRawX>0 && TouchRawX<4096) break;

 // }

  float fy=(TouchRawCalibSCR_YY/SCR_YY);
  float fx=(TouchRawCalibSCR_XX/SCR_XX);
  FastdigitalWrite(T_CS,HIGH);

  Tc_X=((float)TouchRawX-(float)TouchRawCalibX)/fx;
  Tc_Y=((float)TouchRawY-(float)TouchRawCalibY)/fy;
//Tc_Y=(TouchRawY-TouchRawCalibY)*SCR_YY/TouchRawCalibSCR_YY;

#ifdef Touch_Limit
  if(Tc_X<0) Tc_X=0;
  if(Tc_X>SCR_XX) Tc_X=SCR_XX;
  if(Tc_Y<0) Tc_Y=0;
  if(Tc_Y>SCR_YY) Tc_Y=SCR_YY;
#endif

  if (bitRead(Service,1)==Ss_LANDSCAPE)
  {
    int z;
        z=Tc_Y;
    Tc_Y=Tc_X;
    Tc_X=SCR_YY-z;

  }





}


/*! Return true if touch sensor was touched*/
bool Ss_TFT::TouchReady()
{
  return !(FastdigitalRead(T_IRQ));
}




//if (bitRead(Service,1)==Ss_LANDSCAPE)
unsigned int Ss_TFT::TouchGetX()
{
  //int TouchW=TouchRawCalibSCR_XX-TouchRawCalibX;
  return ((TouchRawX-TouchRawCalibX)/(TouchRawCalibSCR_XX/SCR_WW));

}

unsigned int Ss_TFT::TouchGetY()
{
  //int TouchH=TouchRawCalibSCR_YY-TouchRawCalibY;
  return ((TouchRawY-TouchRawCalibY)/(TouchRawCalibSCR_YY/SCR_HH));
}