CCS :: View topic - Modified

FAQ

Forum Help

Official CCS Support

Profile Log in to check your private messages Log 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

Modified_GLCDLibrary

CCS Forum Index -> Code Library

View previous topic :: View next topic

Author

Message

prisim

Joined: 07 Nov 2013
Posts: 6

Modified_GLCDLibrary

Posted: Mon Apr 27, 2015 10:51 pm

Hi,

Here is Modified version of CCS built in GLCD library for KS0108 based GLCD.(HDM64GS12.c and Graphics.c)

With some new and modified functions from Extended GLCD Library and other by me.

New Functions included in library are,

glcd_3Dbox(x,y,width,height,depth,color)

Draws a 3D box on a graphic LCD (Ex: to make a 3D Button)

glcd_circle_seg(x,y,radius,angle_start,angle_end,color)

Draws a segment of a circle on a graphic LCD

glcd_image(inverse)

Fills the graphic LCD screen with 128x64 bit converted image
with inverse option

glcd_image_xy(x,y,inverse)

Draws less or equal 128x64 pixels of image to the graphic LCD
screen on specified x, y coordinate with inverse option

glcd_putc1116(x,y,textptr,size,color)
* Write Text in 11x16 font

Tested personally! On software and by hardware both (JHD12864E).
Any kind of questions bugs or feedback will be welcomed Smile

Demo Project of CCS compiler and Library files are below

++++++++++++++++++++
CCS portions of code removed.
Reason: Forum rule #10
10. Don't post the CCS example code or drivers
http://www.ccsinfo.com/forum/viewtopic.php?t=26245
- Forum Moderator
++++++++++++++++++++

Code:

#include <16F877A.h>
#device *=16
#include <stdlib.h>
#include <string.h>
#USE DELAY (CLOCK=4000000)
//#include <24512.c> //for the atmel eeprom
#include <math.h>
#include <C:\Users\mPc\Desktop\New folder (2)\HDM64GS12.c>
#include <C:\Users\mPc\Desktop\New folder (2)\GRAPHICS.c>

#fuses HS,NOWDT,NOLVP

char text[]="PriSim";
char text2[]="A";
char text3[]="TeaM";

void main()
{

glcd_init(ON);

delay_ms(200);

glcd_putc1116(1,1,text2,1,ON);
glcd_text57(70,40,text,1,ON);
glcd_text57(70,50,text3,1,ON);

glcd_circle(18,8,5,0,on);
glcd_rect(25, 1, 36, 15, 0, on);
glcd_circle(44,8,5,1,on);
glcd_rect(52, 1, 63, 15, 1, on);
glcd_3Dbox(70,1,15,15,3,ON);
glcd_image_xy(0,32,NO);

delay_ms(1000);

}

Modified HDM64GS12.c

Code:

/////////////////////////////////////////////////////////////////////////
//// HDM64GS12.c ////
//// ////
// ! DON'T FORGET TO CHANGE YOUR PIN CONFIGURATION FOR YOUR CIRCUIT ! //
// Modified and Tested on JHD12864E GLCD //
// BY //
// PriSim TeaM //
/////////////////////////////////////////////////////////////////////////
//// ////
//// The NEW functions added by me: ////
//// ////
//// glcd_standby(command) ////
//// glcd_3Dbox(x,y,width,height,depth,color) ////
//// ////
//// glcd_image(inverse) ////
//// glcd_image_xy(x,y,inverse) ////
//// ////
//// !! YOU CAN FIND DETAILED DESCRIPTIONS !! ////
//// !! AND "HOW TO USE" INFORMATIONS ABOVE THE FUNCTIONS !! ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// ////
//// The NEW functions ////
//// ////
//// ////
//// glcd_3Dbox(x,y,width,height,depth,color) ////
//// ////
//// glcd_image(inverse) ////
//// glcd_image_xy(x,y,inverse) ////
//// ////
//// !! YOU CAN FIND DETAILED DESCRIPTIONS !! ////
//// !! AND "HOW TO USE" INFORMATIONS ABOVE THE FUNCTIONS !! ////
//// ////

#include <Bitmap.h>

#endif
//****************************************************************************//
// Purpose: Turns ON-OFF graphic LCD. Good solution on system standby //
// GLCD does not clear its memory map on OFF command. So last //
// screen shows up when ON command send to GLCD //
// Inputs: OFF - Turns the LCD off //
// ON - Turns the LCD on //
//****************************************************************************//
void glcd_standby(int1 command)
{
output_low(GLCD_E);
output_low(GLCD_CS1);
output_low(GLCD_CS2);
output_low(GLCD_DI);
if (command)
{
glcd_writeByte(GLCD_CS1,0x3F);
glcd_writeByte(GLCD_CS2,0x3F);
}
else
{
glcd_writeByte(GLCD_CS1,0x3E);
glcd_writeByte(GLCD_CS2,0x3E);
}
}
//****************************************************************************//
// Purpose: Fill the graphic LCD screen with 128x64 bit converted image //
// Inputs: YES - Inverse of image (Raw data saved in ROM) //
// NO - Normal image (Raw data saved in ROM) //
// Dependencies: glcd_pixel(), glcd_init() //
// //
// !! Check the "Bitmap.h" file !! //
// //
//****************************************************************************//
void glcd_image(int1 inverse)
{
unsigned int i, j, k;
unsigned int16 count=0;
int width = 128;
int height = 64;
glcd_fillScreen(OFF); //Clears the screen (opt.)
if(inverse)
{
for(i=0;i<height;i+=8)
{
for(j=0;j<width;j++)
{
for(k=0;k<8;k++)
{
if(~bit_test(image[count],k))
{
glcd_pixel(j,i+k,ON);
}

}
count++;
}
}
}
else
{
for(i=0;i<height;i+=8)
{
for(j=0;j<width;j++)
{
for(k=0;k<8;k++)
{
if(bit_test(image[count],k))
{
glcd_pixel(j,i+k,ON);
}

}
count++;
}
}
}
}
//****************************************************************************//
// Purpose: Draw a 3D box on a graphic LCD (Ex: to make a 3D Button) //
// Inputs: (x, y) - the start point //
// (width, height) - size of the box //
// depth - 3D depth effect ratio of the box (2 or 3 is fine) //
// color - ON or OFF //
// Dependencies: glcd_pixel() //
//****************************************************************************//
void glcd_3Dbox(int16 x,int16 y,int16 width, int16 height, int depth, int1 color)
{
int16 i,j;
for(i=x;i<=x+width;i++)
{
glcd_pixel(i,y,1);
glcd_pixel(i,y+height,1);
}
for(i=y;i<=y+height;i++)
{
glcd_pixel(x,i,1);
glcd_pixel(x+width,i,1);
}
for(j=1;j<=depth;j++)
{
for(i=y+j;i<=y+height+j;i++)
{
glcd_pixel(x-j,i,1);
}
}
for(j=1;j<=depth;j++)
{
for(i=x-j;i<=(x-j+width);i++)
{
glcd_pixel(i,y+height+j,color);
}
}
}

//****************************************************************************//
// Purpose: Draw less or equal 128x64 pixels of image to the graphic LCD//
// screen on specified x, y coordinate //
// Inputs: (x, y) - The start coordinate //
// YES - Inverse of image (Raw data saved in ROM) //
// NO - Normal image (Raw data saved in ROM) //
// Dependencies: glcd_pixel(), glcd_init() //
// //
// !!! PRLEASE BE CAREFULL !! //
// //
// First 2 bytes of your image data must be size of your BMP //
// //
// Example: If your BMP image size is 64x32, first 2 bytes should //
// be 0x40, 0x20 --> (64 = 0x40, 32 = 0x20) //
// //
// !! Check the "Bitmap.h" file !! //
// //
//****************************************************************************//
void glcd_image_xy(int x, int y, int1 inverse)
{
unsigned int i, j, k;
unsigned int16 count=2;
int width = image_xy[0];
int height = image_xy[1];
//glcd_fillScreen(OFF); //Clears the screen (opt.)
if(inverse)
{
for(i=0;i<height;i+=8)
{
for(j=0;j<width;j++)
{
for(k=0;k<8;k++)
{
if(~bit_test(image_xy[count],k))
{
glcd_pixel(x+j,y+i+k,ON);
}
}
count++;
}
}
}
else
{
for(i=0;i<height;i+=8)
{
for(j=0;j<width;j++)
{
for(k=0;k<8;k++)
{
if(bit_test(image_xy[count],k))
{
glcd_pixel(x+j,y+i+k,ON);
}
}
count++;
}
}
}
}

Modified Graphics.c

Code:

/////////////////////////////////////////////////////////////////////////
//// graphics.c ////
// //
// EXTRA TEXT WRITING ROUTINE //
// //
// There is a one extra font routine: //
// glcd_putc1116(x,y,textptr,size,color) //
// * Write Text in 11x16 font //
// //

/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
#ifndef GRAPHICS_DRAWING_FUNCTIONS
#define GRAPHICS_DRAWING_FUNCTIONS
/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
#ifndef ON
#define ON 1
#endif

#ifndef OFF
#define OFF 0
#endif

#ifndef YES
#define YES 1
#endif

#ifndef NO
#define NO 0
#endif
////////////////////////////////Defines 11x16 TEXT Array//////////////////////////////////

const unsigned int16 TEXT_11x16_1[11][11]={
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
0, 0, 0, 124, 13311, 13311, 124, 0, 0, 0, 0, // !
0, 0, 60, 60, 0, 0, 60, 60, 0, 0, 0, // "
512, 7696, 8080, 1008, 638, 7710, 8080, 1008, 638, 30, 16, // #
0, 1144, 3324, 3276, 16383, 16383, 3276, 4044, 1928, 0, 0, // $
12288, 14392, 7224, 3640, 1792, 896, 448, 14560, 14448, 14392, 28, // %
0, 7936, 16312, 12796, 8646, 14306, 7742, 7196, 13824, 8704, 0, // &
0, 0, 0, 39, 63, 31, 0, 0, 0, 0, 0, // '
0, 0, 1008, 4092, 8190, 14343, 8193, 8193, 0, 0, 0, // (
0, 0, 8193, 8193, 14343, 8190, 4092, 1008, 0, 0, 0, // )
0, 3224, 3768, 992, 4088, 4088, 992, 3768, 3224, 0, 0, // *
};

const unsigned int16 TEXT_11x16_2[11][11]={
0, 384, 384, 384, 4080, 4080, 384, 384, 384, 0, 0 // +
0, 0, 0, 47104, 63488, 30720, 0, 0, 0, 0, 0, // ,
0, 384, 384, 384, 384, 384, 384, 384, 384, 0, 0, // -
0, 0, 0, 14336, 14336, 14336, 0, 0, 0, 0, 0, // .
6144, 7168, 3584, 1792, 896, 448, 224, 112, 56, 28, 14, // /
2040, 8190, 7686, 13059, 12675, 12483, 12387, 12339, 6174, 8190, 2040, // 0
0, 0, 12300, 12300, 12302, 16383, 16383, 12288, 12288, 12288, 0, // 1
12316, 14366, 15367, 15875, 14083, 13187, 12739, 12515, 12407, 12350, 12316, // 2
3084, 7182, 14343, 12483, 12483, 12483, 12483, 12483, 14823, 8062, 3644, // 3
960, 992, 880, 824, 796, 782, 775, 16383, 16383, 768, 768, // 4
3135, 7295, 14435, 12387, 12387, 12387, 12387, 12387, 14563, 8131, 3971 // 5
};

const unsigned int16 TEXT_11x16_3[11][11]={
4032, 8176, 14840, 12508, 12494, 12487, 12483, 12483, 14787, 8064, 3840, // 6
3, 3, 3, 12291, 15363, 3843, 963, 243, 63, 15, 3, // 7
3840, 8124, 14846, 12519, 12483, 12483, 12483, 12519, 14846, 8124, 3840, // 8
60, 126, 12519, 12483, 12483, 14531, 7363, 3779, 2023, 1022, 252, // 9
0, 0, 0, 7280, 7280, 7280, 0, 0, 0, 0, 0, // :
0, 0, 0, 40048, 64624, 31856, 0, 0, 0, 0, 0, // ;
0, 192, 480, 1008, 1848, 3612, 7182, 14343, 12291, 0, 0, // <
0, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 1632, 0, // =
0, 12291, 14343, 7182, 3612, 1848, 1008, 480, 192, 0, 0, // >
28, 30, 7, 3, 14211, 14275, 227, 119, 62, 28, 0, // ?
4088, 8190, 6151, 13299, 14331, 13851, 14331, 14331, 13831, 1022, 504 // @
};

const unsigned int16 TEXT_11x16_4[11][11]={
14336, 16128, 2016, 1788, 1567, 1567, 1788, 2016, 16128, 14336, 0, // A
16383, 16383, 12483, 12483, 12483, 12483, 12519, 14846, 8124, 3840, 0, // B
1008, 4092, 7182, 14343, 12291, 12291, 12291, 14343, 7182, 3084, 0, // C
16383, 16383, 12291, 12291, 12291, 12291, 14343, 7182, 4092, 1008, 0, // D
16383, 16383, 12483, 12483, 12483, 12483, 12483, 12483, 12291, 12291, 0, // E
16383, 16383, 195, 195, 195, 195, 195, 195, 3, 3, 0, // F
1008, 4092, 7182, 14343, 12291, 12483, 12483, 12483, 16327, 16326, 0, // G
16383, 16383, 192, 192, 192, 192, 192, 192, 16383, 16383, 0, // H
0, 0, 12291, 12291, 16383, 16383, 12291, 12291, 0, 0, 0, // I
3584, 7680, 14336, 12288, 12288, 12288, 12288, 14336, 8191, 2047, 0, // J
16383, 16383, 192, 480, 1008, 1848, 3612, 7182, 14343, 12291, 0 // K
};

const unsigned int16 TEXT_11x16_5[11][11]={
16383, 16383, 12288, 12288, 12288, 12288, 12288, 12288, 12288, 12288, 0, // L
16383, 16383, 30, 120, 480, 480, 120, 30, 16383, 16383, 0, // M
16383, 16383, 14, 56, 240, 960, 1792, 7168, 16383, 16383, 0, // N
1008, 4092, 7182, 14343, 12291, 12291, 14343, 7182, 4092, 1008, 0, // O
16383, 16383, 387, 387, 387, 387, 387, 455, 254, 124, 0, // P
1008, 4092, 7182, 14343, 12291, 13827, 15879, 7182, 16380, 13296, 0, // Q
16383, 16383, 387, 387, 899, 1923, 3971, 7623, 14590, 12412, 0, // R
3132, 7294, 14567, 12483, 12483, 12483, 12483, 14791, 8078, 3852, 0, // S
0, 3, 3, 3, 16383, 16383, 3, 3, 3, 0, 0, // T
2047, 8191, 14336, 12288, 12288, 12288, 12288, 14336, 8191, 2047, 0, // U
7, 63, 504, 4032, 15872, 15872, 4032, 504, 63, 7, 0 // V
};

const unsigned int16 TEXT_11x16_6[11][11]={
16383, 16383, 7168, 1536, 896, 896, 1536, 7168, 16383, 16383, 0, // W
12291, 15375, 3612, 816, 480, 480, 816, 3612, 15375, 12291, 0, // X
3, 15, 60, 240, 16320, 16320, 240, 60, 15, 3, 0, // Y
12291, 15363, 15875, 13059, 12739, 12515, 12339, 12319, 12303, 12291, 0, // Z
0, 0, 16383, 16383, 12291, 12291, 12291, 12291, 0, 0, 0, // [
14, 28, 56, 112, 224, 448, 896, 1792, 3584, 7168, 6144, // \
0, 0, 12291, 12291, 12291, 12291, 16383, 16383, 0, 0, 0, // ]
96, 112, 56, 28, 14, 7, 14, 28, 56, 112, 96, // ^
49152, 49152, 49152, 49152, 49152, 49152, 49152, 49152, 49152, 49152, 49152, // _
0, 0, 0, 0, 62, 126, 78, 0, 0, 0, 0, // `
7168, 15936, 13152, 13152, 13152, 13152, 13152, 13152, 16352, 16320, 0 // a
};

const unsigned int16 TEXT_11x16_7[11][11]={
16383, 16383, 12480, 12384, 12384, 12384, 12384, 14560, 8128, 3968, 0, // b
3968, 8128, 14560, 12384, 12384, 12384, 12384, 12384, 6336, 2176, 0, // c
3968, 8128, 14560, 12384, 12384, 12384, 12512, 12480, 16383, 16383, 0, // d
3968, 8128, 15328, 13152, 13152, 13152, 13152, 13152, 5056, 384, 0, // e
192, 192, 16380, 16382, 199, 195, 195, 3, 0, 0, 0, // f
896, 51136, 52960, 52320, 52320, 52320, 52320, 58976, 32736, 16352, 0, // g
16383, 16383, 192, 96, 96, 96, 224, 16320, 16256, 0, 0, // h
0, 0, 12288, 12384, 16364, 16364, 12288, 12288, 0, 0, 0, // i
0, 0, 24576, 57344, 49152, 49248, 65516, 32748, 0, 0, 0, // j
0, 16383, 16383, 768, 1920, 4032, 7392, 14432, 12288, 0, 0, // k
0, 0, 12288, 12291, 16383, 16383, 12288, 12288, 0, 0, 0 // l
};

const unsigned int16 TEXT_11x16_8[11][11]={
16352, 16320, 224, 224, 16320, 16320, 224, 224, 16320, 16256, 0, // m
0, 16352, 16352, 96, 96, 96, 96, 224, 16320, 16256, 0, // n
3968, 8128, 14560, 12384, 12384, 12384, 12384, 14560, 8128, 3968, 0, // o
65504, 65504, 3168, 6240, 6240, 6240, 6240, 7392, 4032, 1920, 0, // p
1920, 4032, 7392, 6240, 6240, 6240, 6240, 3168, 65504, 65504, 0, // q
0, 16352, 16352, 192, 96, 96, 96, 96, 224, 192, 0, // r
4544, 13280, 13152, 13152, 13152, 13152, 16224, 7744, 0, 0, 0, // s
96, 96, 8190, 16382, 12384, 12384, 12384, 12288, 0, 0, 0, // t
4064, 8160, 14336, 12288, 12288, 12288, 12288, 6144, 16352, 16352, 0, // u
96, 480, 1920, 7680, 14336, 14336, 7680, 1920, 480, 96, 0, // v
2016, 8160, 14336, 7168, 4064, 4064, 7168, 14336, 8160, 2016, 0 // w
};

const int16 TEXT_11x16_9[7][11]={
12384, 14560, 7616, 3968, 1792, 3968, 7616, 14560, 12384, 0, 0, // x
0, 96, 33248, 59264, 32256, 7680, 1920, 480, 96, 0, 0, // y
12384, 14432, 15456, 13920, 13152, 12768, 12512, 12384, 12320, 0, 0, // z
0, 128, 448, 8188, 16254, 28679, 24579, 24579, 24579, 0, 0, // {
0, 0, 0, 0, 16383, 16383, 0, 0, 0, 0, 0, // |
0, 24579, 24579, 24579, 28679, 16254, 8188, 448, 128, 0, 0, // }
16, 24, 12, 4, 12, 24, 16, 24, 12, 4, 0 // ~
};

//////////////////////////////////////////////////////////////////////////
//// Defines a 5x7 font ARray
/////////////////////////////////////////////////////////////////////////
const unsigned int8 FONT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, //
.
.
.
}

//****************************************************************************//
// Purpose: Draw a segment of a circle on a graphic LCD //
// Inputs: (x,y) - The center of the circle //
// radius - The radius of the circle //
// angle_start - Start point angle of segment of circle //
// angle_end - End point angle of segment of circle //
// //
// Example: (angle_start = 0 & angle_end = 360 draws a normal circle) //
// (angle_start = 0 & angle_end = 180 draws half circle (arc) )//
// //
// color - ON or OFF //
// Dependencies: glcd_pixel(), <math.h> //
//****************************************************************************//
void glcd_circle_seg(int x, int y, int radius, int16 angle_start, int16 angle_end, int1 color)
{
int x_round, y_round;
float angle;
#define DEGREE 2*3.14159265/360

for (angle = (float)angle_start; angle <= angle_end; angle += .9)
{
x_round = (sin (angle * DEGREE) * radius);
y_round = (cos (angle * DEGREE) * radius);
glcd_pixel(x + x_round, y + y_round, color);
}
}

// Purpose: Write a text in 11x16 font on a graphic LCD
#ifdef LARGE_LCD
void glcd_putc1116(unsigned int16 x, unsigned int16 y, char* textptr, unsigned int8 size, int1 color)
#else
void glcd_putc1116(unsigned int8 x, unsigned int8 y, char* textptr, unsigned int8 size, int1 color)
{
byte j, k, l, m; // Loop counters
unsigned int16 pixelData[11]; // Stores character data

for(; *textptr != '\0'; ++textptr, ++x)// Loop through the passed string
{

if(*textptr < ' ' || *textptr> '~')
memcpy(pixelData, TEXT_11x16_1[0], 22); // Non printable defaults to a space
else if(*textptr < ' ' + 11) // Checks if the letter is in the first text array
memcpy(pixelData, TEXT_11x16_1[*textptr-' '], 22);
else if(*textptr < '+' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_2[*textptr-'+'], 22);
else if(*textptr < '6' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_3[*textptr-'6'], 22);
else if(*textptr < 'A' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_4[*textptr-'A'], 22);
else if(*textptr< 'L' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_5[*textptr-'L'], 22);
else if(*textptr < 'W' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_6[*textptr-'W'], 22);
else if(*textptr < 'b' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_7[*textptr-'b'], 22);
else if(*textptr < 'm' + 11) // Checks if the letter is in the next text array
memcpy(pixelData, TEXT_11x16_8[*textptr-'m'], 22);
else // Must be in the last array
memcpy(pixelData, TEXT_11x16_9[*textptr-'x'], 22);

// Handles newline and carriage returns
switch(*textptr)
{
case '\n':
y +=16*size+1;
return;
case '\r':
x = 0;
return;
}

if(x+11*size >= GLCD_WIDTH) // Performs character wrapping
{
x = 0; // Set x at far left position
y += 16*size + 1; // Set y at next position down
}

for(j=0; j<11; ++j, x+=size) { // Loop through character byte data
for(k=0; k<16*size; ++k) { // Loop through the vertical pixels
if(bit_test(pixelData[j], k)) { // Check if the pixel should be set
for(l=0; l<size; ++l) { // The next two loops change the character's size
for(m=0; m<size; ++m) {
glcd_pixel(x+m, y+k*size+l, color); // Draw the pixel
}
}
}
}
}
}
}
#endif

bitmap.h for the array of images.

Code:

const int image_xy[]=
{
0x40 , 0x20 // This 2 bytes defines the size of BMP for glcd_image_xy() function
// You should define it by yourself if your image converter does not
// add it by itself.(this image is 64x32 pixels -> 64=0x40, 32=0x20)

0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x3F, 0x3F, 0x3F, 0x3F,
0x1F, 0x3F, 0x3F, 0x3F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF3, 0xF0, 0xF8, 0x38, 0x12, 0x07, 0x1F, 0x3E,
0x7C, 0x78, 0x36, 0x0F, 0x1F, 0x3E, 0xFC, 0xF3, 0xE7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F, 0x83, 0xF3, 0xC7, 0x8F, 0xC7, 0xF3,
0x83, 0xFF, 0x87, 0xC7, 0xC7, 0x87, 0xB7, 0xB7, 0xB7, 0xFF, 0x87, 0xD7, 0xD7, 0xD6, 0x86, 0xFE,
0x86, 0xB6, 0xB6, 0x96, 0x86, 0xFF, 0x87, 0xB7, 0xB7, 0xB7, 0xFF, 0xC7, 0x87, 0xEF, 0xEF, 0x87,
0xFF, 0x87, 0xF7, 0x87, 0xC7, 0xD7, 0xD7, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};

muratmert4

Joined: 19 May 2011
Posts: 3


Posted: Wed Apr 29, 2015 4:06 am

Very nice program. thanks They worked with little improvement. Microchip logo beautiful.

Display posts from previous:

	CCS Forum Index -> Code Library	All times are GMT - 6 Hours
Page 1 of 1

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