CCS C Software and Maintenance Offers
FAQFAQ   FAQForum Help   FAQOfficial CCS Support   SearchSearch  RegisterRegister 

ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

CCS does not monitor this forum on a regular basis.

Please do not post bug Reports on this forum. Send them to support@ccsinfo.com

t6963 full driver 256x256 with Graphic functions

 
Post new topic   Reply to topic    CCS Forum Index -> Code Library
View previous topic :: View next topic  
Author Message
MCDOGANAY



Joined: 09 Apr 2009
Posts: 3
Location: turkey

View user's profile Send private message Visit poster's website

t6963 full driver 256x256 with Graphic functions
PostPosted: Wed Nov 10, 2010 6:43 am     Reply with quote

Code:

/////////////////////////////////////////////////////////////////////////
////    T6963C.c     -      T6963C driver                            ////
////   Not for comercial Use                                         ////
////      Driver by treitmey Graphic functions and Resolution Select ////   
////                                    by mcdoganay(mcdoganay@gmail.com) ////
////                                                                 ////
//// This file contains drivers for using a Tosiba T6963C controller ////
//// in parallel/8080(intel) mode.  The T6963C is 256 pixels across  ////
////  and 256 pixels down. The driver treats the upper left pixel 0,0 ////
////                                                                 ////
////  Connections are as follows:                                    ////
////  /WR - - C4                                                     ////
////  /RD - - C5                                                     ////
////  C//D- - C6                                                     ////
////  /RST- - C7                                                     ////
////  DATA0-7 PORTD0-7                                               ////
////  LCD's FS is tied low (FS = 0 is 8x8 font)                      ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////

// 256 x 256 in the 8x8 font mode means that 30 characters across by
// 32 rows of characters may be displayed

#define set_tris_lcd(x) set_tris_d(x)
#define LCDColorBlack 0b1
#define LCDColorWhite 0b0

//TRIS DataBus=x,  note:control bus (PORTC) always outputs
//unsigned int16 TextHome = 0x0F00;//0x0780;
//const int8  TextArea = 0x001E; // how many bytes before a new line
//const int16 GraphicsHome = 0x0000;
//const int8  GraphicsArea = 0x001E; // how many bytes before a new line

unsigned int16 TextHome = 0x0000;
const int8  TextArea = 0x0028; // how many bytes before a new line
const int16 GraphicsHome = 0x0C00;
const int8  GraphicsArea = 0x0028; // how many bytes before a new line

const int8 AutoModeWrite = 0xB0;
const int8 AutoModeRead  = 0xB1;
const int8 AutoModeReset = 0xB2;

const int8 LCDModeSet  = 0x80;   // send this OR'd with the following
const int8 LCDMode_OR  = 0b0000;
const int8 LCDMode_XOR = 0b0001;
const int8 LCDMode_AND = 0b0010;
const int8 LCDMode_TA  = 0b0100; // TEXT ATTRIBUTE mode.
const int8 LCDMode_RAM = 0b1000; // 1=CG RAM, 0=internal CG ROM

const int8 LCDSetCursorPtr  = 0x21;  // cursor address
const int8 LCDSetCursorSize = 0xA0;  // 1 line cursor

const int8 LCDDispMode = 0x90;   // send this OR'd with the following
const int8 LCDDisp_BLK = 0b0001;
const int8 LCDDisp_CUR = 0b0010;
const int8 LCDDisp_TXT = 0b0100;
const int8 LCDDisp_GRH = 0b1000;

const int8 LCDBitSet   = 0xF8;
const int8 LCDBitReset = 0xF0;
const int8 LCDBit0 = 0b000;
const int8 LCDBit1 = 0b001;
const int8 LCDBit2 = 0b010;
const int8 LCDBit3 = 0b011;
const int8 LCDBit4 = 0b100;
const int8 LCDBit5 = 0b101;
const int8 LCDBit6 = 0b110;
const int8 LCDBit7 = 0b111;

const int8 LCDSetPtr = 0xE0;



struct lcd_pin_def
{
   BOOLEAN unused1;    // C0
   BOOLEAN unused2;    // C1
   BOOLEAN unused3;  // C2
   BOOLEAN unused4;  // C3
   BOOLEAN w_bar;  // C4 Write bar active low
   BOOLEAN r_bar;  // C5 Read bar active low
   BOOLEAN cd;         // C6 Command/Data BAR   1=command 0=data
   BOOLEAN reset_bar;  // C7 Reset active low
   int  data    :  8;  // PortD=Data bus
};
struct lcd_pin_def  LCD;

  #byte LCD = 0xf82    // portC address on 18F452

int   glcd_ReadByte(void);
void  glcd_WriteByte(int1 cd, int data);
void  glcd_WriteByteAuto(int data);
void  glcd_WriteCmd2(int16 data, int cmd);
void  glcd_WriteCmd1(int data, int cmd);
void  glcd_gotoxy(int x, int y, int1 text);

#inline
void glcd_init(unsigned int16 res_x, unsigned int16 res_y) {
   
  int16 counter;
 
//  TextHome = (res_x/8)*res_y; //0x0F00;//0x0780;
 
  set_tris_c(0x00);  // graphic lcd control lines all output
  set_tris_lcd(0xff);   //TRIS DATA bus,note:control bus always outputs

  LCD.w_bar = 1;      // INITIAL STATES OF CONTROL PINS
  LCD.r_bar = 1;      //
  LCD.cd = 1;         // command

  LCD.reset_bar = 0;  // perform a reset
//  delay_us(10);      // delay for a reset
  LCD.reset_bar = 1;  // run

  // Set up the graphics and text areas
  glcd_WriteCmd2(TextHome, 0x40);
  glcd_WriteCmd2(TextArea, 0x41);
  glcd_WriteCmd2(GraphicsHome, 0x42);
  glcd_WriteCmd2(GraphicsArea, 0x43);

  // set address to 0
  glcd_WriteCmd2(0x0000, 0x24);
  glcd_WriteCmd2(0x0000, 0x24);

  // Clear all RAM of LCD (8k)
  glcd_WriteByte(1, AutoModeWrite);
  for (counter = 0; counter < 0x1fff; counter++)
  {
    glcd_WriteByteAuto(0);    // fill everything with zeros
  }
  glcd_WriteByte(1, AutoModeReset);
}

void glcd_WriteByte(int1 cd, int data)
{
    int status = 0, temp = 0;
    set_tris_lcd(0xff);
    LCD.w_bar = 1;
    LCD.r_bar= 1;
    LCD.cd = 1;//defaults

    while (status != 0x03) {  // is LCD busy?
       LCD.r_bar= 0;
       temp = LCD.data;
       LCD.r_bar = 1;
       status = temp & 0x03;
    }

    set_tris_lcd(0x00);    // All outputs
    LCD.cd = cd;           // Command/Data bar
    LCD.data = data;
    LCD.r_bar = 1;         // not read
    LCD.w_bar = 0;         // write
    LCD.w_bar = 1;         // release
}


void glcd_WriteByteAuto(int data)
{
   int status = 0, temp = 0; // status bits ARE DIFFERENT BITS THAN NORMAL
   set_tris_lcd(0xff);
   LCD.w_bar = 1;
   LCD.r_bar = 1;
   LCD.cd = 1; // defaults

   while (status != 0x08) {  // is LCD busy?
     LCD.r_bar = 0;
     temp = LCD.data;
     LCD.r_bar = 1;
     status = temp & 0x08;
   }

   set_tris_lcd(0x00);     // All outputs
   LCD.cd = 0;             // This is always data, cd=0
   LCD.data = data;        // Put data on data bus
   LCD.w_bar = 0;          // write
   LCD.w_bar = 1;          // release
}

void glcd_WriteCmd1(int data, int cmd)
{
  glcd_WriteByte(0, data);
  glcd_WriteByte(1, cmd);
}

void glcd_WriteCmd2(int16 data, int cmd)
{
  glcd_WriteByte(0, data & 0xff);
  glcd_WriteByte(0, data>>8);
  glcd_WriteByte(1, cmd);
}

int glcd_ReadByte(void)
{
  int data = 0, status = 0, temp = 0;
  set_tris_lcd(0xff);
  LCD.w_bar = 1;
  LCD.r_bar = 1;
  LCD.cd = 1;  // defaults

  #asm nop #endasm

  while (status != 0x03) {  // is LCD busy?
    LCD.r_bar = 0;
    temp = LCD.data;
    LCD.r_bar = 1;
    status = temp & 0x03;
  }

  LCD.cd = 0;          // Command/Data bar
  LCD.r_bar = 0;        // read
  /////////////////////////////////////////////////////////
  #asm nop #endasm    // THIS PAUSE IS VERY NESSESARY !!!//
  /////////////////////////////////////////////////////////
  data = LCD.data;
  LCD.r_bar = 1;
  LCD.cd = 1;
  return data;        // Return the read data
}

void glcd_putc(char c) {
   glcd_WriteCmd1(c - 0x20, 0xc0);
}

void glcd_gotoxy(int x, int y, int1 text) { // sets memory location to screen location x, y
   // location 1,1 is upper left corner;  text = 1 (text area), text = 0 (graphics area)
   int16 location, home;
   int line;

   if (text==0) {
      home = GraphicsHome;
      line = GraphicsArea;
   } else {
      home = TextHome;
      line = TextArea;
   }

   location = home + (((int16)y) * line) + x;
   glcd_WriteCmd2(location, 0x24);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose:       Clears LCD RAM
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_clr(int16 location,int16 size)
{
  ////fprintf(DEBUG,"loc=%lu  size=%lu\n\r",location,size);
  // look very simular to the init,... doesn't it. : )
  glcd_WriteCmd2(location,LCDSetPtr);
  glcd_WriteCmd1(1,AutoModeWrite);
  for (;size;size--)
  {
    glcd_WriteByteAuto(0x00);//clear ram
  }
  glcd_WriteCmd1(1,AutoModeReset);
}

/////////////////////////////////////////
// Graphics Controller by mcdoganay (c)2010
//    mcdoganay@gmail.com
//       Not for comercial use
/////////////////////////////////////////

unsigned int8 i;  //General Purpouse variable

// glcd_pixel(x,y,c) sets pixel x,y with c color
void glcd_pixel(unsigned int8 x, unsigned int8 y, int1 c){
   unsigned int8 x_H;
   unsigned int8 x_L=0;
   x_H = (x / 8);
   x_L = 7 - (x - 8*x_H);
   glcd_gotoxy(x_H,y,0);    //Bug fixed, thanks to etiedon
   if(c){
      glcd_WriteCmd1(1,(LCDBitSet|x_L));
   } else {
      glcd_WriteCmd1(1,(LCDBitReset|x_L));
   }
}

// glcd_pixel8(x,y,px8) sets 8 pixels in line.
void glcd_pixel8(unsigned int8 x, unsigned int8 y, int8 pixel8){
   unsigned int8 x_H;
   x_H = (x / 8);
   glcd_gotoxy(x_H,y,0);
   glcd_WriteCmd1(pixel8,0xc0);
}

// glcd_line(x0,y0, x1,y1, c) puts line from (x0, y0) to (x1, y1) with c color
#separate
void glcd_line(int16 x1, int16 y1, int16 x2, int16 y2, int1 color)
{
   int16        dy, dx;
   signed int8  addx=1, addy=1;
   signed int16 P, diff;

   int16 i=0;
   dx = abs((signed int16)(x2 - x1));
   dy = abs((signed int16)(y2 - y1));


   if(x1 > x2)
      addx = -1;
   if(y1 > y2)
      addy = -1;

   if(dx >= dy)
   {
      dy *= 2;
      P = dy - dx;
      diff = P - dx;

      for(; i<=dx; ++i)
      {
         glcd_pixel(x1, y1, color);

         if(P < 0)
         {
            P  += dy;
            x1 += addx;
         }
         else
         {
            P  += diff;
            x1 += addx;
            y1 += addy;
         }
      }
   }
   else
   {
      dx *= 2;
      P = dx - dy;
      diff = P - dy;

      for(; i<=dy; ++i)
      {
         glcd_pixel(x1, y1, color);

         if(P < 0)
         {
            P  += dx;
            y1 += addy;
         }
         else
         {
            P  += diff;
            x1 += addx;
            y1 += addy;
         }
      }
   }
}


// glcd_square(x0,y0,x1,y1, c) sets square
void glcd_square( unsigned int8 x0, unsigned int8 y0,
                  unsigned int8 x1, unsigned int8 y1 , int1 c){
   glcd_line(x0,y0, x1,y0, c);
   glcd_line(x1,y0, x1,y1, c);
   glcd_line(x0,y1, x1,y1, c);
   glcd_line(x0,y0, x0,y1, c);
}

// glcd_box(x0,y0,x1,y1, c)
void glcd_box( unsigned int8 x0, unsigned int8 y0,
               unsigned int8 x1, unsigned int8 y1 , int1 c){
   unsigned int8 x;
   unsigned int8 y;
   for(y=y0; y<=y1;y++){
      for(x=x0; x<=x1;x++){
         if((!(x%8)) && ((x1-x)>8)){
            glcd_pixel8(x,y,0xFF*c);  //Same time to write 8 pixel
            x +=7 ;
         } else {
            glcd_pixel(x,y,c);
         }
      }
   }
}

/////////////////////////////////////////////////////////////////////////
// Purpose:       Draw a circle on a graphic LCD
// Inputs:        (x,y) - the center of the circle
//                radius - the radius of the circle
//                fill - YES or NO
//                color - ON or OFF
/////////////////////////////////////////////////////////////////////////

void glcd_circle(int16 x, int16 y, int16 radius, int1 fill, int1 color)

{
   #ifdef LARGE_LCD
   signed int16 a, b, P;
   #else
   signed int8  a, b, P;
   #endif

   a = 0;
   b = radius;
   P = 1 - radius;

   do
   {
      if(fill)
      {
         glcd_line(x-a, y+b, x+a, y+b, color);
         glcd_line(x-a, y-b, x+a, y-b, color);
         glcd_line(x-b, y+a, x+b, y+a, color);
         glcd_line(x-b, y-a, x+b, y-a, color);
      }
      else
      {
         glcd_pixel(a+x, b+y, color);
         glcd_pixel(b+x, a+y, color);
         glcd_pixel(x-a, b+y, color);
         glcd_pixel(x-b, a+y, color);
         glcd_pixel(b+x, y-a, color);
         glcd_pixel(a+x, y-b, color);
         glcd_pixel(x-a, y-b, color);
         glcd_pixel(x-b, y-a, color);
      }

      if(P < 0)
         P += 3 + 2 * a++;
      else
         P += 5 + 2 * (a++ - b--);
    } while(a <= b);
}



//glcd_image8 (*Pic, x, y, size_x, size_y)
void glcd_image8(int8 *pic_px, unsigned int8 x, unsigned int8 y,
                 unsigned int8 size_x, unsigned int8 size_y){
   
   unsigned int8 px_y;
   unsigned int8 px_x;
   unsigned int8 px=0;
   
   for(px_y=y; px_y<(y+size_y); px_y++){
      for(px_x=x; px_x<(x+size_x); px_x+=8){
         glcd_pixel8(px_x, px_y, *(pic_px+px));
         px+=1;
      }
   }
}
#use fast_io(D)

main program

#include <18F4520.h>
#device *=16
#device adc=10
#use delay(clock=12000000,RESTART_WDT)
#fuses XT, BROWNOUT, BORV27, PUT, STVREN, NOLVP
#include <t6963.h>
void main() {

   int n;
   int8 bt_logo[11] = { //8x11 picture
      0b00010000,      //     XX
      0b00011000,      //     XXXX
      0b00010100,      //     XX  XX
      0b01010010,      // XX  XX    XX
      0b00110100,      //   XXXX  XX
      0b00011000,      //     XXXX
      0b00110100,      //   XXXX  XX
      0b01010010,      // XX  XX    XX
      0b00010100,      //     XX  XX
      0b00011000,      //     XXXX
      0b00010000       //     XX
   };

   glcd_init(255,255);
   glcd_WriteByte(1, (LCDModeSet|LCDMode_XOR));
   glcd_WriteByte(1, (LCDDispMode|LCDDisp_TXT|LCDDisp_GRH));

   
  glcd_gotoxy(1,1,1);  // 1 = text area of memory; note that there are only
                        // 32 rows of text possible
  glcd_putc("torbali ATL");
  glcd_circle(40, 40, 40, 0, 1);
  glcd_box(0,0,254,254,1);
  glcd_line(0,0,254,254,0);
  glcd_line(3,6,20,50,1);
  glcd_line(100,40,210,20,1);
  glcd_box(30,30,160,160,0);
  glcd_square(1,1,250,250,0);
  glcd_image8(&bt_logo[0],212,40,8,11);

/*  glcd_image8(&bt_logo[0],216,40,8,11);
  glcd_line(30,6,200,100,1);
  glcd_square(0,0,247,253,1);
  glcd_image8(&bt_logo[0],26,110,8,11);
  glcd_box(0,0,254,254,1);
*/
// thanks for by endSly
}
noyz



Joined: 31 Jan 2009
Posts: 57

View user's profile Send private message

PostPosted: Wed Jun 01, 2011 3:14 pm     Reply with quote

Have you test the read function ?
How does it work ?
gotoxy 1,1 if you want to read what is o x=1,y=1
I didn't got it work,
it's result doesn't differ of what i have written on lcd,
"asd"
1,1 return 36 and so (2,1),(3,1)
and i do know that the value returned must be added to 0x20 and transform it to char.. and doesnt seem to be "a" and s cand be equal to a..(36 for both ) 0x20hex = 32 int
So the real value is 4
Display posts from previous:   
Post new topic   Reply to topic    CCS Forum Index -> Code Library All times are GMT - 6 Hours
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2005 phpBB Group