Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-09-17T13:29:33+01:00

zerolinux napisał(a):

Osiągnąłem sukces!

Wyświetlacz ruszył. Według opisu szyna danych była D0..D7 a powinna być D7..D0. Oprócz tego funkcje EnableControler i DisableControler powinny w przypadku mojego sterownika być zamienione.
Wyświetlacz wyświetla. Walczę ze zdefiniowaniem dużych czcionek żeby osiągnąć efekt wyświetlacza 7 segmentowego na części.

A nie lepiej zrobić dwa rysunki segmentów i wysiedlać ich na pozycjach?

Statystyki: Napisane przez wchpikus — 17 wrz 2015, o 13:29

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-08-31T09:42:25+01:00

zerolinux napisał(a):

Walczę ze zdefiniowaniem dużych czcionek żeby osiągnąć efekt wyświetlacza 7 segmentowego na części.

To nie walcz kolego a zobacz ten temat

viewtopic.php?p=78031#p78031

Ja już jakiś czas temu zmęczyłem fonta i kod dałem w powyższym temacie

Pozdrawiam

Namazane ze smarta.

Statystyki: Napisane przez majster — 31 sie 2015, o 09:42

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-08-31T08:29:50+01:00

Statystyki: Napisane przez zerolinux — 31 sie 2015, o 08:29

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-08-26T08:14:55+01:00

Hej
Sprawdz, czy przypadkiem soft nie zatrzymuje sie przy sprawdzaniu GLCD_ReadStatus.
Sprawdz co zwraca.
Ostatnio robilem nie na takim, ale na T6963C, tez mialem problem.

Statystyki: Napisane przez wchpikus — 26 sie 2015, o 08:14

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-08-17T12:58:33+01:00

Antystatyczny napisał(a):

majster napisał(a):

Nic dziwnego ze nie dziala skoro w petli while masz tylko mruganie dioda co 1 sek.

Program powinien wyświetlić ramkę, a wewnątrz niej napis powitalny. Stosowny kod znajduje się przed pętlą nieskończoną. Oczywiście zakładając, ze reszta softu jest prawidłowa.

Faktycznie. Przepraszam za zamieszanie. Ze smarta dziwnie czyta sie kod i to przeoczylem.

Namazane ze smarta.

Statystyki: Napisane przez majster — 17 sie 2015, o 12:58

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-08-17T09:11:27+01:00

Nic dziwnego ze nie dziala skoro w petli while masz tylko mruganie dioda co 1 sek.

Nie rysujesz nic na lcd

Namazane ze smarta.

Statystyki: Napisane przez majster — 17 sie 2015, o 09:11

Problem z wyświetlaczem graficznym LCD opartym ok KS0108

2015-08-16T19:14:56+01:00

Witam.

Próbuję uruchomić wyświetlacz wydłubany z drukarki fiskalnej. Wyświetlacz ma oznaczenie GTG-192641 i ma rozdzielczość 192x64. Znalazłem w necie, że jest oparty o kontroler KS0108. Nie udało mi się odszukać dokumentacji poza pinologią.

Pobrałem z internetu biblioteki do obsługi ze strony radzio.dxp.pl ale wyświetlacz nie wyświetla żadnych napisów, działa tylko regulacja kontrastu (potencjometrem podłączonym pomiędzy masę a pin3 wyświetlacza).

Uruchamiam go na płytce stykowej, opis podłaczenia:

procesor: ATMEGA32, taktowany wewnętrznie 8MHz, JTAG wyłączony.
dane PORTA, RS PC2, RW PC1, EN PC0, CS1 - PC7, CS2 - PC6, CS3 - PC5.

Dioda jest dodana żeby sprawdzić czy program idzie dalej.

Proszę o podpowiedź

program główny:

[syntax=c]#include
#include
#include
#include "font5x8.h"
#include "graphic.h"
#include "KS0108.h"

#define KS0108_DATA_PORT PORTA
#define KS0108_DATA_PIN PINA
#define KS0108_DATA_DDR DDRA
#define KS0108_DATA_DIR DDRA

#define KS0108_CTRL_PORTPORTC
#define KS0108_CTRL_DIRDDRC

#define KS0108_RS(1 << 2)
#define KS0108_RW(1 << 1)
#define KS0108_EN(1 << 0)

#define KS0108_CS1(1 << 7)
#define KS0108_CS2(1 << 6)
#define KS0108_CS3(1 << 5)

extern unsigned char screen_x;
extern unsigned char screen_y;

#define DISPLAY_STATUS_BUSY0x80

#define LED1 PB0

//-------------------------------------------------------------------------------------------------
// Delay function
//-------------------------------------------------------------------------------------------------
void GLCD_Delay(void)
{
asm("nop");
}
//-------------------------------------------------------------------------------------------------
// Enalbe Controller (0-2)
//-------------------------------------------------------------------------------------------------
void GLCD_EnableController(unsigned char controller)
{
switch(controller){
case 0 : KS0108_CTRL_PORT &= ~KS0108_CS1; break;
case 1 : KS0108_CTRL_PORT &= ~KS0108_CS2; break;
case 2 : KS0108_CTRL_PORT &= ~KS0108_CS3; break;
}
}
//-------------------------------------------------------------------------------------------------
// Disable Controller (0-2)
//-------------------------------------------------------------------------------------------------
void GLCD_DisableController(unsigned char controller)
{
switch(controller){
case 0 : KS0108_CTRL_PORT |= KS0108_CS1; break;
case 1 : KS0108_CTRL_PORT |= KS0108_CS2; break;
case 2 : KS0108_CTRL_PORT |= KS0108_CS3; break;
}
}
//-------------------------------------------------------------------------------------------------
// Read Status from specified controller (0-2)
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadStatus(unsigned char controller)
{
unsigned char status;
KS0108_DATA_DIR = 0x00;
KS0108_CTRL_PORT |= KS0108_RW;
KS0108_CTRL_PORT &= ~KS0108_RS;
GLCD_EnableController(controller);
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
status = KS0108_DATA_PIN;
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(controller);
return status;
}
//-------------------------------------------------------------------------------------------------
// Write command to specified controller
//-------------------------------------------------------------------------------------------------
void GLCD_WriteCommand(unsigned char commandToWrite, unsigned char controller)
{
while(GLCD_ReadStatus(controller)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR = 0xFF;
KS0108_CTRL_PORT &= ~(KS0108_RW | KS0108_RS);
GLCD_EnableController(controller);
KS0108_DATA_PORT = commandToWrite;
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(controller);
}
//-------------------------------------------------------------------------------------------------
// Read data from current position
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadData(void)
{
unsigned char data;
while(GLCD_ReadStatus(screen_x / 64)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR = 0x00;
KS0108_CTRL_PORT |= (KS0108_RW | KS0108_RS);
GLCD_EnableController(screen_x / 64);
//GLCD_Delay();
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
data = KS0108_DATA_PIN;
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(screen_x / 64);
screen_x++;
return data;
}
//-------------------------------------------------------------------------------------------------
// Write data to current position
//-------------------------------------------------------------------------------------------------
void GLCD_WriteData(unsigned char dataToWrite)
{
while(GLCD_ReadStatus(screen_x / 64)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR = 0xFF;
KS0108_CTRL_PORT &= ~KS0108_RW;
KS0108_CTRL_PORT |= KS0108_RS;
KS0108_DATA_PORT = dataToWrite;
GLCD_EnableController(screen_x / 64);
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(screen_x / 64);
screen_x++;
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
void GLCD_InitalizePorts(void)
{
KS0108_CTRL_DIR |= (KS0108_CS1 | KS0108_CS2 | KS0108_CS3 | KS0108_RS | KS0108_RW | KS0108_EN);
KS0108_CTRL_PORT |= (KS0108_CS1 | KS0108_CS2 | KS0108_CS3);
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadByteFromROMMemory(char * ptr)
{
return pgm_read_byte(ptr);
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------

int main(void)
{

DDRB |= (1< PORTB |= (1< _delay_ms(1000);
PORTB ^=(1<

GLCD_InitalizePorts();
GLCD_ClearScreen();

GLCD_GoTo(0,0);
GLCD_WriteString("+-------------------+");
GLCD_GoTo(0,1);
GLCD_WriteString("| Universal |");
GLCD_GoTo(0,2);
GLCD_WriteString("| KS0108 library |");
GLCD_GoTo(0,3);
GLCD_WriteString("| |");
GLCD_GoTo(0,4);
GLCD_WriteString("| en.radzio.dxp.pl |");
GLCD_GoTo(0,5);
GLCD_WriteString("| STM32 Cortex-M3 |");
GLCD_GoTo(0,6);
GLCD_WriteString("| microcontrollers |");
GLCD_GoTo(0,7);
GLCD_WriteString("+-------------------+");

while(1)
{
//TODO:: Please write your application code

_delay_ms(1000);
PORTB ^=(1< }
}[/syntax]

biblioteki:
KS0108.h
[syntax=c]#define KS0108_SCREEN_WIDTH192
#define KS0108_SCREEN_HEIGHT64

#define DISPLAY_SET_Y 0x40
#define DISPLAY_SET_X 0xB8
#define DISPLAY_START_LINE 0xC0
#define DISPLAY_ON_CMD0x3E
#define ON0x01
#define OFF0x00
#define DISPLAY_STATUS_BUSY0x80

void GLCD_Initalize(void);
void GLCD_WriteData(unsigned char);
void GLCD_WriteCommand(unsigned char, unsigned char);
void GLCD_ClearScreen(void);
void GLCD_GoTo(unsigned char, unsigned char);
void GLCD_WriteString(char *);
unsigned char GLCD_ReadByteFromROMMemory(char *);
unsigned char GLCD_ReadData(void);
void GLCD_Bitmap(char *, unsigned char, unsigned char, unsigned char, unsigned char);[/syntax]

KS0108.c
[syntax=c]//-------------------------------------------------------------------------------------------------
// Universal KS0108 driver library
// Atmel AVR MCU low-level driver.
// (c) Radosław Kwiecień, radek@dxp.pl
//-------------------------------------------------------------------------------------------------
#include
#include

#define KS0108_DATA_PORTPORTA
#define KS0108_DATA_DIRDDRA
#define KS0108_DATA_PINPINA

#define KS0108_CTRL_PORTPORTC
#define KS0108_CTRL_DIRDDRC

#define KS0108_RS(1 << 2)
#define KS0108_RW(1 << 1)
#define KS0108_EN(1 << 0)

#define KS0108_CS1(1 << 7)
#define KS0108_CS2(1 << 6)
#define KS0108_CS3(1 << 5)

extern unsigned char screen_x;
extern unsigned char screen_y;

#define DISPLAY_STATUS_BUSY0x80

//-------------------------------------------------------------------------------------------------
// Delay function
//-------------------------------------------------------------------------------------------------
void GLCD_Delay(void)
{
asm("nop");
}
//-------------------------------------------------------------------------------------------------
// Enalbe Controller (0-2)
//-------------------------------------------------------------------------------------------------
void GLCD_EnableController(unsigned char controller)
{
switch(controller){
case 0 : KS0108_CTRL_PORT &= ~KS0108_CS1; break;
case 1 : KS0108_CTRL_PORT &= ~KS0108_CS2; break;
case 2 : KS0108_CTRL_PORT &= ~KS0108_CS3; break;
}
}
//-------------------------------------------------------------------------------------------------
// Disable Controller (0-2)
//-------------------------------------------------------------------------------------------------
void GLCD_DisableController(unsigned char controller)
{
switch(controller){
case 0 : KS0108_CTRL_PORT |= KS0108_CS1; break;
case 1 : KS0108_CTRL_PORT |= KS0108_CS2; break;
case 2 : KS0108_CTRL_PORT |= KS0108_CS3; break;
}
}
//-------------------------------------------------------------------------------------------------
// Read Status from specified controller (0-2)
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadStatus(unsigned char controller)
{
unsigned char status;
KS0108_DATA_DIR = 0x00;
KS0108_CTRL_PORT |= KS0108_RW;
KS0108_CTRL_PORT &= ~KS0108_RS;
GLCD_EnableController(controller);
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
status = KS0108_DATA_PIN;
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(controller);
return status;
}
//-------------------------------------------------------------------------------------------------
// Write command to specified controller
//-------------------------------------------------------------------------------------------------
void GLCD_WriteCommand(unsigned char commandToWrite, unsigned char controller)
{
while(GLCD_ReadStatus(controller)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR = 0xFF;
KS0108_CTRL_PORT &= ~(KS0108_RW | KS0108_RS);
GLCD_EnableController(controller);
KS0108_DATA_PORT = commandToWrite;
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(controller);
}
//-------------------------------------------------------------------------------------------------
// Read data from current position
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadData(void)
{
unsigned char data;
while(GLCD_ReadStatus(screen_x / 64)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR = 0x00;
KS0108_CTRL_PORT |= (KS0108_RW | KS0108_RS);
GLCD_EnableController(screen_x / 64);
//GLCD_Delay();
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
data = KS0108_DATA_PIN;
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(screen_x / 64);
screen_x++;
return data;
}
//-------------------------------------------------------------------------------------------------
// Write data to current position
//-------------------------------------------------------------------------------------------------
void GLCD_WriteData(unsigned char dataToWrite)
{
while(GLCD_ReadStatus(screen_x / 64)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR = 0xFF;
KS0108_CTRL_PORT &= ~KS0108_RW;
KS0108_CTRL_PORT |= KS0108_RS;
KS0108_DATA_PORT = dataToWrite;
GLCD_EnableController(screen_x / 64);
KS0108_CTRL_PORT |= KS0108_EN;
GLCD_Delay();
KS0108_CTRL_PORT &= ~KS0108_EN;
GLCD_DisableController(screen_x / 64);
screen_x++;
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
void GLCD_InitalizePorts(void)
{
KS0108_CTRL_DIR |= (KS0108_CS1 | KS0108_CS2 | KS0108_CS3 | KS0108_RS | KS0108_RW | KS0108_EN);
KS0108_CTRL_PORT |= (KS0108_CS1 | KS0108_CS2 | KS0108_CS3);
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadByteFromROMMemory(char * ptr)
{
return pgm_read_byte(ptr);
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------[/syntax]

graphic.h
[syntax=c]void GLCD_Rectangle(unsigned char x, unsigned char y, unsigned char b, unsigned char a);
void GLCD_Circle(unsigned char cx, unsigned char cy ,unsigned char radius);
void GLCD_Line(unsigned int X1,unsigned int Y1,unsigned int X2,unsigned int Y2);[/syntax]

graphic.c
[syntax=c]extern void GLCD_SetPixel(unsigned char x, unsigned char y, unsigned char color);

const unsigned char color = 1;

void GLCD_Rectangle(unsigned char x, unsigned char y, unsigned char b, unsigned char a)
{
unsigned char j; // zmienna pomocnicza
// rysowanie linii pionowych (boki)
for (j = 0; j < a; j++) {
GLCD_SetPixel(x, y + j, color);
GLCD_SetPixel(x + b - 1, y + j, color);
}
// rysowanie linii poziomych (podstawy)
for (j = 0; j < b; j++){
GLCD_SetPixel(x + j, y, color);
GLCD_SetPixel(x + j, y + a - 1, color);
}
}
//

void GLCD_Circle(unsigned char cx, unsigned char cy ,unsigned char radius)
{
int x, y, xchange, ychange, radiusError;
x = radius;
y = 0;
xchange = 1 - 2 * radius;
ychange = 1;
radiusError = 0;
while(x >= y)
{
GLCD_SetPixel(cx+x, cy+y, color);
GLCD_SetPixel(cx-x, cy+y, color);
GLCD_SetPixel(cx-x, cy-y, color);
GLCD_SetPixel(cx+x, cy-y, color);
GLCD_SetPixel(cx+y, cy+x, color);
GLCD_SetPixel(cx-y, cy+x, color);
GLCD_SetPixel(cx-y, cy-x, color);
GLCD_SetPixel(cx+y, cy-x, color);
y++;
radiusError += ychange;
ychange += 2;
if ( 2*radiusError + xchange > 0 )
{
x--;
radiusError += xchange;
xchange += 2;
}
}
}
//

void GLCD_Line(unsigned int X1,unsigned int Y1,unsigned int X2,unsigned int Y2)
{
int CurrentX, CurrentY, Xinc, Yinc,
Dx, Dy, TwoDx, TwoDy,
TwoDxAccumulatedError, TwoDyAccumulatedError;

Dx = (X2-X1); // obliczenie składowej poziomej
Dy = (Y2-Y1); // obliczenie składowej pionowej

TwoDx = Dx + Dx; // podwojona składowa pozioma
TwoDy = Dy + Dy; // podwojona składowa pionowa

CurrentX = X1; // zaczynamy od X1
CurrentY = Y1; // oraz Y1

Xinc = 1; // ustalamy krok zwiększania pozycji w poziomie
Yinc = 1; // ustalamy krok zwiększania pozycji w pionie

if(Dx < 0) // jesli składowa pozioma jest ujemna
{
Xinc = -1; // to będziemy się "cofać" (krok ujemny)
Dx = -Dx; // zmieniamy znak składowej na dodatni
TwoDx = -TwoDx; // jak również podwojonej składowej
}

if (Dy < 0) // jeśli składowa pionowa jest ujemna
{
Yinc = -1; // to będziemy się "cofać" (krok ujemny)
Dy = -Dy; // zmieniamy znak składowej na dodatki
TwoDy = -TwoDy; // jak równiez podwojonej składowej
}

GLCD_SetPixel(X1,Y1, color); // stawiamy pierwszy krok (zapalamy pierwszy piksel)

if ((Dx != 0) || (Dy != 0)) // sprawdzamy czy linia składa się z więcej niż jednego punktu ;)
{
// sprawdzamy czy składowa pionowa jest mniejsza lub równa składowej poziomej
if (Dy <= Dx) // jeśli tak, to idziemy "po iksach"
{
TwoDxAccumulatedError = 0; // zerujemy zmienną
do // ruszamy w drogę
{
CurrentX += Xinc; // do aktualnej pozycji dodajemy krok
TwoDxAccumulatedError += TwoDy; // a tu dodajemy podwojoną składową pionową
if(TwoDxAccumulatedError > Dx) // jeśli TwoDxAccumulatedError jest większy od Dx
{
CurrentY += Yinc; // zwiększamy aktualną pozycję w pionie
TwoDxAccumulatedError -= TwoDx; // i odejmujemy TwoDx
}
GLCD_SetPixel(CurrentX,CurrentY, color);// stawiamy następny krok (zapalamy piksel)
}while (CurrentX != X2); // idziemy tak długo, aż osiągniemy punkt docelowy
}
else // w przeciwnym razie idziemy "po igrekach"
{
TwoDyAccumulatedError = 0;
do
{
CurrentY += Yinc;
TwoDyAccumulatedError += TwoDx;
if(TwoDyAccumulatedError>Dy)
{
CurrentX += Xinc;
TwoDyAccumulatedError -= TwoDy;
}
GLCD_SetPixel(CurrentX,CurrentY, color);
}while (CurrentY != Y2);
}
}
}
//[/syntax]

font5x8.h
[syntax=c]#ifdef __AVR__
#include
static const char PROGMEM font5x8[] = {
#else
static const char font5x8[] = {
#endif
0x00, 0x00, 0x00, 0x00, 0x00,// (spacja)
0x00, 0x00, 0x5F, 0x00, 0x00,// !
0x00, 0x07, 0x00, 0x07, 0x00,// "
0x14, 0x7F, 0x14, 0x7F, 0x14,// #
0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
0x23, 0x13, 0x08, 0x64, 0x62,// %
0x36, 0x49, 0x55, 0x22, 0x50,// &
0x00, 0x05, 0x03, 0x00, 0x00,// '
0x00, 0x1C, 0x22, 0x41, 0x00,// (
0x00, 0x41, 0x22, 0x1C, 0x00,// )
0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
0x08, 0x08, 0x3E, 0x08, 0x08,// +
0x00, 0x50, 0x30, 0x00, 0x00,// ,
0x08, 0x08, 0x08, 0x08, 0x08,// -
0x00, 0x30, 0x30, 0x00, 0x00,// .
0x20, 0x10, 0x08, 0x04, 0x02,// /
0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
0x00, 0x42, 0x7F, 0x40, 0x00,// 1
0x42, 0x61, 0x51, 0x49, 0x46,// 2
0x21, 0x41, 0x45, 0x4B, 0x31,// 3
0x18, 0x14, 0x12, 0x7F, 0x10,// 4
0x27, 0x45, 0x45, 0x45, 0x39,// 5
0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
0x01, 0x71, 0x09, 0x05, 0x03,// 7
0x36, 0x49, 0x49, 0x49, 0x36,// 8
0x06, 0x49, 0x49, 0x29, 0x1E,// 9
0x00, 0x36, 0x36, 0x00, 0x00,// :
0x00, 0x56, 0x36, 0x00, 0x00,// ;
0x00, 0x08, 0x14, 0x22, 0x41,// <
0x14, 0x14, 0x14, 0x14, 0x14,// =
0x41, 0x22, 0x14, 0x08, 0x00,// >
0x02, 0x01, 0x51, 0x09, 0x06,// ?
0x32, 0x49, 0x79, 0x41, 0x3E,// @
0x7E, 0x11, 0x11, 0x11, 0x7E,// A
0x7F, 0x49, 0x49, 0x49, 0x36,// B
0x3E, 0x41, 0x41, 0x41, 0x22,// C
0x7F, 0x41, 0x41, 0x22, 0x1C,// D
0x7F, 0x49, 0x49, 0x49, 0x41,// E
0x7F, 0x09, 0x09, 0x01, 0x01,// F
0x3E, 0x41, 0x41, 0x51, 0x32,// G
0x7F, 0x08, 0x08, 0x08, 0x7F,// H
0x00, 0x41, 0x7F, 0x41, 0x00,// I
0x20, 0x40, 0x41, 0x3F, 0x01,// J
0x7F, 0x08, 0x14, 0x22, 0x41,// K
0x7F, 0x40, 0x40, 0x40, 0x40,// L
0x7F, 0x02, 0x04, 0x02, 0x7F,// M
0x7F, 0x04, 0x08, 0x10, 0x7F,// N
0x3E, 0x41, 0x41, 0x41, 0x3E,// O
0x7F, 0x09, 0x09, 0x09, 0x06,// P
0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
0x7F, 0x09, 0x19, 0x29, 0x46,// R
0x46, 0x49, 0x49, 0x49, 0x31,// S
0x01, 0x01, 0x7F, 0x01, 0x01,// T
0x3F, 0x40, 0x40, 0x40, 0x3F,// U
0x1F, 0x20, 0x40, 0x20, 0x1F,// V
0x7F, 0x20, 0x18, 0x20, 0x7F,// W
0x63, 0x14, 0x08, 0x14, 0x63,// X
0x03, 0x04, 0x78, 0x04, 0x03,// Y
0x61, 0x51, 0x49, 0x45, 0x43,// Z
0x00, 0x00, 0x7F, 0x41, 0x41,// [
0x02, 0x04, 0x08, 0x10, 0x20,// "\"
0x41, 0x41, 0x7F, 0x00, 0x00,// ]
0x04, 0x02, 0x01, 0x02, 0x04,// ^
0x40, 0x40, 0x40, 0x40, 0x40,// _
0x00, 0x01, 0x02, 0x04, 0x00,// `
0x20, 0x54, 0x54, 0x54, 0x78,// a
0x7F, 0x48, 0x44, 0x44, 0x38,// b
0x38, 0x44, 0x44, 0x44, 0x20,// c
0x38, 0x44, 0x44, 0x48, 0x7F,// d
0x38, 0x54, 0x54, 0x54, 0x18,// e
0x08, 0x7E, 0x09, 0x01, 0x02,// f
0x08, 0x14, 0x54, 0x54, 0x3C,// g
0x7F, 0x08, 0x04, 0x04, 0x78,// h
0x00, 0x44, 0x7D, 0x40, 0x00,// i
0x20, 0x40, 0x44, 0x3D, 0x00,// j
0x00, 0x7F, 0x10, 0x28, 0x44,// k
0x00, 0x41, 0x7F, 0x40, 0x00,// l
0x7C, 0x04, 0x18, 0x04, 0x78,// m
0x7C, 0x08, 0x04, 0x04, 0x78,// n
0x38, 0x44, 0x44, 0x44, 0x38,// o
0x7C, 0x14, 0x14, 0x14, 0x08,// p
0x08, 0x14, 0x14, 0x18, 0x7C,// q
0x7C, 0x08, 0x04, 0x04, 0x08,// r
0x48, 0x54, 0x54, 0x54, 0x20,// s
0x04, 0x3F, 0x44, 0x40, 0x20,// t
0x3C, 0x40, 0x40, 0x20, 0x7C,// u
0x1C, 0x20, 0x40, 0x20, 0x1C,// v
0x3C, 0x40, 0x30, 0x40, 0x3C,// w
0x44, 0x28, 0x10, 0x28, 0x44,// x
0x0C, 0x50, 0x50, 0x50, 0x3C,// y
0x44, 0x64, 0x54, 0x4C, 0x44,// z
0x00, 0x08, 0x36, 0x41, 0x00,// {
0x00, 0x00, 0x7F, 0x00, 0x00,// |
0x00, 0x41, 0x36, 0x08, 0x00,// }
0x08, 0x08, 0x2A, 0x1C, 0x08,// ->
0x08, 0x1C, 0x2A, 0x08, 0x08 // <-
};
//[/syntax]

Statystyki: Napisane przez zerolinux — 16 sie 2015, o 19:14

ATNEL tech-forum

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

Re: Problem z wyświetlaczem graficznym LCD opartym ok KS0108

Problem z wyświetlaczem graficznym LCD opartym ok KS0108