ATNEL tech-forum

Re: KS0108 [C]

2016-11-04T10:22:09+01:00

Na temat Bascoma nie wypowiem się, bo go nie znam. Natomiast nawet pisząc w języku C, kod wynikowy w dużej mierze jest zależny od ustawionego poziomu optymalizacji (jak zresztą również wcześniej pokazał kolega krish).

Statystyki: Napisane przez andrews — 4 lis 2016, o 10:22

Re: KS0108 [C]

2016-11-04T09:57:34+01:00

Ehh asembler... wstyd się przyznać ale to dla mnie czarna magia ;( chyba jednak trzeba będzie zaczerpnąć jakiejś lekcji chociaż podstaw. Czyli rozumiem ze te opóźnienia wynikają z poziomu programowania? Jak bym napisał taki sam program powiedzmy w bascomie to opóźnienia byłyby jeszcze większe?

Statystyki: Napisane przez klimeq — 4 lis 2016, o 09:57

Re: KS0108 [C]

2016-11-04T08:03:01+01:00

Kup sobie Saleae na portalu aucyjnym (koszt poniżej 50zl). Przyda ci się do tego (sprawdzisz dokladnie czasy przełączania itd.) i do wielu innych rzeczy. Ew. możesz spróbować zmierzyć częstotliwość miernikiem.

Statystyki: Napisane przez micky — 4 lis 2016, o 08:03

Re: KS0108 [C]

2016-11-04T07:40:34+01:00

klimeq napisał(a):

Dziwi mnie dlaczego bez żadnych delay'ów jest tak mała częstotliwość.

Załóżmy, że masz ustawioną częstotliwość taktowania mikrokontrolera 1MHz.
Jak już wcześniej pokazał Tobie kolega krish jeden obieg pętli while, czyli jeden okres generowanego przebiegu, to 3 instrukcje asemblera, z których każda trwa 2 takty zegara, łącznie 6 taktów.
Jeżeli teraz podzielisz 1MHz przez 6, to jaką częstotliwość uzyskasz?

Statystyki: Napisane przez andrews — 4 lis 2016, o 07:40

Re: KS0108 [C]

2016-11-04T00:20:21+01:00

Ale jak?

Sorry ale twoje pytanie to już wyższa szkoła wróżenia nie ze szklanej kuli ale to jest jak wróżenie z piasku.

Wysłane z mojego LIVE przy użyciu Tapatalka

Statystyki: Napisane przez majster — 4 lis 2016, o 00:20

Re: KS0108 [C]

2016-11-03T23:51:06+01:00

Problemem okazał się jeden Warning którego olałem na początku Jednak zastanawia mnie ta częstotliwość zmiany stanu pinu bez opóźnień. Czy mógłby mi ktoś z Was wytłumaczyć dla czego tak jest ?

Statystyki: Napisane przez tomas140 — 3 lis 2016, o 23:51

Re: KS0108 [C]

2016-10-31T09:45:05+01:00

Dziwi mnie dlaczego bez żadnych delay'ów jest tak mała częstotliwość. Czy może to być spowodowane ustawieniami kompilatora ?

Statystyki: Napisane przez klimeq — 31 paź 2016, o 09:45

Re: KS0108 [C]

2016-10-30T20:52:58+01:00

Jeden projekt zmieniam kod i ewentualnie zegar. Optymalizacja Os

Statystyki: Napisane przez klimeq — 30 paź 2016, o 20:52

Re: KS0108 [C]

2016-10-30T20:47:14+01:00

Zobacz w pliku *.lss lub *.lst w projekcie- jak to się skompilowało.
[syntax=asm]int main(void)
{
DDRC |= (1< 6c:a0 9a sbi0x14, 0; 20
while(1)
{
PORTC |= (1< 6e:a8 9a sbi0x15, 0; 21
PORTC &=~(1< 70:a8 98 cbi0x15, 0; 21
}
72:fd cf rjmp.-6 ; 0x6e [/syntax]
Wychodzi chyba nawet więcej sbi/cbi/rjmp po 2 takty zagara

Czy Twoje przykłady były kompilowane w różnych projektach czy w jednym poprzez podmianę kodu? Czy włączona optymalizacja?

------------------------ [ Dodano po: 2 minutach ]

To samo bez opymalizacji
[syntax=asm]int main(void)
{
DDRC |= (1< 6c:84 e3 ldir24, 0x34; 52
6e:90 e0 ldir25, 0x00; 0
70:24 e3 ldir18, 0x34; 52
72:30 e0 ldir19, 0x00; 0
74:f9 01 movwr30, r18
76:20 81 ldr18, Z
78:21 60 orir18, 0x01; 1
7a:fc 01 movwr30, r24
7c:20 83 stZ, r18
while(1)
{
PORTC |= (1< 7e:85 e3 ldir24, 0x35; 53
80:90 e0 ldir25, 0x00; 0
82:25 e3 ldir18, 0x35; 53
84:30 e0 ldir19, 0x00; 0
86:f9 01 movwr30, r18
88:20 81 ldr18, Z
8a:21 60 orir18, 0x01; 1
8c:fc 01 movwr30, r24
8e:20 83 stZ, r18
PORTC &=~(1< 90:85 e3 ldir24, 0x35; 53
92:90 e0 ldir25, 0x00; 0
94:25 e3 ldir18, 0x35; 53
96:30 e0 ldir19, 0x00; 0
98:f9 01 movwr30, r18
9a:20 81 ldr18, Z
9c:2e 7f andir18, 0xFE; 254
9e:fc 01 movwr30, r24
a0:20 83 stZ, r18
}
a2:ed cf rjmp.-38 ; 0x7e [/syntax]

Statystyki: Napisane przez krish — 30 paź 2016, o 20:47

Re: KS0108 [C]

2016-10-30T20:29:46+01:00

Kod2: powinno być ok 1 MHz

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

Statystyki: Napisane przez adamBo — 30 paź 2016, o 20:29

Re: KS0108 [C]

2016-10-30T20:21:03+01:00

[syntax=c]#include
#include
int main(void)
{

DDRC |= (1< while(1)
{
PORTC |= (1<_delay_ms(1000);
PORTC &=~(1<_delay_ms(1000);

}
}[/syntax]
pin przełącza idealnie co sekundę, natomiast

[syntax=c]#include
#include
int main(void)
{

DDRC |= (1< while(1)
{
PORTC |= (1<PORTC &=~(1< }
}[/syntax]

daje mi szpilki 165.5kHz a powinno być 1MHz tak ? czy może się mylę ?

Statystyki: Napisane przez klimeq — 30 paź 2016, o 20:21

Re: KS0108 [C]

2016-10-30T20:12:01+01:00

Napisz najprostszy program przełączający jakimś pinem ( lub LED-em) za pomocą
funkcji _delay_ms(1000), oczywiście przy właściwych ustawieniach F_CPU (analiza wyników z kompilacji) , i sprawdź czy pin przełącza/mruga co sekundę- będziesz wtedy wiedział, że procesor (fusy) i kompilator są dobrze ustawione. Wtedy pozostanie analiza/zmiana programu obs ługi KS-a. Możliwe, choć mało prawdopodobne, że źle działa kwarc/oscylator i wzbudza się na innej częstotliwości. Kondensatory przy kwarcu?

Statystyki: Napisane przez krish — 30 paź 2016, o 20:12

Re: KS0108 [C]

2016-10-30T20:10:48+01:00

Tak powinieneś mieć 16MHz

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

Statystyki: Napisane przez adamBo — 30 paź 2016, o 20:10

Re: KS0108 [C]

2016-10-30T20:10:26+01:00

Od 1 do 8 Mhz na wewnętrznym oscylatorze a 16 podpinam kwarc.
Warning2 inline function 'ks0108ReadData' declared but never defined [enabled by default]

Statystyki: Napisane przez klimeq — 30 paź 2016, o 20:10

Re: KS0108 [C]

2016-10-30T20:04:47+01:00

Masz jakieś warningi przy kompilacji?
Piszesz że reaguje na zmianę częstotliwości, zmieniasz kwarce czy tylko w ustawieniach procka?

Statystyki: Napisane przez Harry — 30 paź 2016, o 20:04

Re: KS0108 [C]

2016-10-30T19:55:46+01:00

Sprawdzałem wszystkie możliwe opcje zegara

Dobra, powiedzcie mi bo ja już mam mętlik w głowie od tego wszystkiego.
Czy przy zegarze 16Mhz na pinie C0 powinienem mieć szpilki o częstotliwości ok. 16 Mhz ?
[syntax=c]#include
int main(void)
{

DDRC |= (1< while(1)
{
PORTC |= (1<PORTC &=~(1< }
}[/syntax]

Statystyki: Napisane przez klimeq — 30 paź 2016, o 19:55

Re: KS0108 [C]

2016-10-30T19:53:53+01:00

W akcie desperacji jak się wyraziłeś dałeś mu pałą w łeb by się zamulał tym 1MHz. Weź sobie na spokojnie posprawdzaj ustawienia zegara a jak już będziesz zdesperowany to daj mu kopa w żyć to wtedy pewnie przyspieszy

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

Statystyki: Napisane przez adamBo — 30 paź 2016, o 19:53

Re: KS0108 [C]

2016-10-30T19:53:10+01:00

W Studio też ustawia się F_CPU w opcjach projektu- poszukaj w sieci.
ps.
Ty programujesz w "C", a Eclipse i AS to tylko tzw. IDE trochę "inteligentniejsze" edytory tekstu i "uruchamiacze" kompilacji i ew. programatorów.

Statystyki: Napisane przez krish — 30 paź 2016, o 19:53

Re: KS0108 [C]

2016-10-30T19:45:57+01:00

Wyświetlanie reaguje na zmianę częstotliwości (im wyższa tym szybciej wyświetla) na filmiku jest 16Mhz. F_CPU użyłem w akcie desperacji . Ja programuje w AS 6 nie ECLIPSE

------------------------ [ Dodano po: 6 minutach ]

krish napisał(a):

Jeżeli chcesz mieć naprawdę szybką obsługę KS-a, znajdź/napisz jego obsługę za pomocą bufora w SRAM procesora. Zajmie to 1KB (128*64/8 ), w mniejszych projektach nie powinno przeszkadzać.

krish ja rozumiem że to nie jest najszybszy sposób na obsługę tego wyświetlacza ale nie rozumiem czemu ten sam kod wczoraj działał poprawnie a dzisiaj tak zamula

Statystyki: Napisane przez klimeq — 30 paź 2016, o 19:45

Re: KS0108 [C]

2016-10-30T19:45:08+01:00

Jeżeli chcesz mieć naprawdę szybką obsługę KS-a, znajdź/napisz jego obsługę za pomocą bufora w SRAM procesora. Zajmie to 1KB (128*64/8 ), w mniejszych projektach nie powinno przeszkadzać.

Statystyki: Napisane przez krish — 30 paź 2016, o 19:45

Re: KS0108 [C]

2016-10-30T19:43:59+01:00

klimeq napisał(a):

#define F_CPU 1000000

A co to robi w kodzie?
Naprawdę odpalasz to na 1MHz?

widzę że kolega wyżej mnie uprzedził

Statystyki: Napisane przez Harry — 30 paź 2016, o 19:43

Re: KS0108 [C]

2016-10-30T19:38:21+01:00

Wywal kolego definicje f-CPU to robimy z poziomu ustawień w eklipsie. Zobacz jak przedstawisz fuzy na 8MHz czy wyświetlacz przyspieszy .

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

Statystyki: Napisane przez adamBo — 30 paź 2016, o 19:38

Re: KS0108 [C]

2016-10-30T19:17:35+01:00

kolego popraw wstawianie kodu bo zaraz moderatorzy się przyczepią...

Jesteś z nami już prawie rok i pewnie nie jeden wątek przeczytałeś i nie raz już były podobne sytuacje, że pytanie nie było sprecyzowane albo źle wstawiony kod. Na pewno się na takie coś natknąłeś nie raz, więc nie popełniaj takich podstawowych błędów

Statystyki: Napisane przez michal1210 — 30 paź 2016, o 19:17

Re: KS0108 [C]

2016-10-30T19:34:01+01:00

ks108.c
[syntax=c]#include
#include
#include
#include "ks0108.h"

lcdCoordks0108Coord;
uint8_tks0108Inverted=0;
ks0108FontCallbackks0108FontRead;
uint8_tks0108FontColor;
const uint8_t*ks0108Font;

void ks0108DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color) {
uint8_t length, i, y, yAlt, xTmp, yTmp;
int16_t m;

//
// vertical line
//
if(x1 == x2) {
// x1|y1 must be the upper point
if(y1 > y2) {
yTmp = y1;
y1 = y2;
y2 = yTmp;
}
ks0108DrawVertLine(x1, y1, y2-y1, color);

//
// horizontal line
//
} else if(y1 == y2) {
// x1|y1 must be the left point
if(x1 > x2) {
xTmp = x1;
x1 = x2;
x2 = xTmp;
}
ks0108DrawHoriLine(x1, y1, x2-x1, color);

//
// schiefe line :)
//
} else {
// angle >= 45°
if((y2-y1) >= (x2-x1) || (y1-y2) >= (x2-x1)) {
// x1 must be smaller than x2
if(x1 > x2) {
xTmp = x1;
yTmp = y1;
x1 = x2;
y1 = y2;
x2 = xTmp;
y2 = yTmp;
}

length = x2-x1;// not really the length :)
m = ((y2-y1)*200)/length;
yAlt = y1;

for(i=0; i<=length; i++) {
y = ((m*i)/200)+y1;

if((m*i)%200 >= 100)
y++;
else if((m*i)%200 <= -100)
y--;

ks0108DrawLine(x1+i, yAlt, x1+i, y, color);

if(length <= (y2-y1) && y1 < y2)
yAlt = y+1;
else if(length <= (y1-y2) && y1 > y2)
yAlt = y-1;
else
yAlt = y;
}

// angle < 45°
} else {
// y1 must be smaller than y2
if(y1 > y2) {
xTmp = x1;
yTmp = y1;
x1 = x2;
y1 = y2;
x2 = xTmp;
y2 = yTmp;
}

length = y2-y1;
m = ((x2-x1)*200)/length;
yAlt = x1;

for(i=0; i<=length; i++) {
y = ((m*i)/200)+x1;

if((m*i)%200 >= 100)
y++;
else if((m*i)%200 <= -100)
y--;

ks0108DrawLine(yAlt, y1+i, y, y1+i, color);
if(length <= (x2-x1) && x1 < x2)
yAlt = y+1;
else if(length <= (x1-x2) && x1 > x2)
yAlt = y-1;
else
yAlt = y;
}
}
}
}

void ks0108DrawRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color) {
ks0108DrawHoriLine(x, y, width, color);// top
ks0108DrawHoriLine(x, y+height, width, color);// bottom
ks0108DrawVertLine(x, y, height, color);// left
ks0108DrawVertLine(x+width, y, height, color);// right
}

void ks0108DrawRoundRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t radius, uint8_t color) {
int16_t tSwitch, x1 = 0, y1 = radius;
tSwitch = 3 - 2 * radius;

while (x1 <= y1) {
ks0108SetDot(x+radius - x1, y+radius - y1, color);
ks0108SetDot(x+radius - y1, y+radius - x1, color);

ks0108SetDot(x+width-radius + x1, y+radius - y1, color);
ks0108SetDot(x+width-radius + y1, y+radius - x1, color);

ks0108SetDot(x+width-radius + x1, y+height-radius + y1, color);
ks0108SetDot(x+width-radius + y1, y+height-radius + x1, color);

ks0108SetDot(x+radius - x1, y+height-radius + y1, color);
ks0108SetDot(x+radius - y1, y+height-radius + x1, color);

if (tSwitch < 0) {
tSwitch += (4 * x1 + 6);
} else {
tSwitch += (4 * (x1 - y1) + 10);
y1--;
}
x1++;
}

ks0108DrawHoriLine(x+radius, y, width-(2*radius), color);// top
ks0108DrawHoriLine(x+radius, y+height, width-(2*radius), color);// bottom
ks0108DrawVertLine(x, y+radius, height-(2*radius), color);// left
ks0108DrawVertLine(x+width, y+radius, height-(2*radius), color);// right
}

/*
* Hardware-Functions
*/
void ks0108FillRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color) {
uint8_t mask, pageOffset, h, i, data;
height++;

pageOffset = y%8;
y -= pageOffset;
mask = 0xFF;
if(height < 8-pageOffset) {
mask >>= (8-height);
h = height;
} else {
h = 8-pageOffset;
}
mask <<= pageOffset;

ks0108GotoXY(x, y);
for(i=0; i<=width; i++) {
data = ks0108ReadData();

if(color == BLACK) {
data |= mask;
} else {
data &= ~mask;
}

ks0108WriteData(data);
}

while(h+8 <= height) {
h += 8;
y += 8;
ks0108GotoXY(x, y);

for(i=0; i<=width; i++) {
ks0108WriteData(color);
}
}

if(h < height) {
mask = ~(0xFF << (height-h));
ks0108GotoXY(x, y+8);

for(i=0; i<=width; i++) {
data = ks0108ReadData();

if(color == BLACK) {
data |= mask;
} else {
data &= ~mask;
}

ks0108WriteData(data);
}
}
}

void ks0108InvertRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height) {
uint8_t mask, pageOffset, h, i, data, tmpData;
height++;

pageOffset = y%8;
y -= pageOffset;
mask = 0xFF;
if(height < 8-pageOffset) {
mask >>= (8-height);
h = height;
} else {
h = 8-pageOffset;
}
mask <<= pageOffset;

ks0108GotoXY(x, y);
for(i=0; i<=width; i++) {
data = ks0108ReadData();
tmpData = ~data;
data = (tmpData & mask) | (data & ~mask);
ks0108WriteData(data);
}

while(h+8 <= height) {
h += 8;
y += 8;
ks0108GotoXY(x, y);

for(i=0; i<=width; i++) {
data = ks0108ReadData();
ks0108WriteData(~data);
}
}

if(h < height) {
mask = ~(0xFF << (height-h));
ks0108GotoXY(x, y+8);

for(i=0; i<=width; i++) {
data = ks0108ReadData();
tmpData = ~data;
data = (tmpData & mask) | (data & ~mask);
ks0108WriteData(data);
}
}
}

void ks0108SetInverted(uint8_t invert) {
if(ks0108Inverted != invert) {
ks0108InvertRect(0,0,127,63);
ks0108Inverted = invert;
}
}

void ks0108SetDot(uint8_t x, uint8_t y, uint8_t color) {
uint8_t data;

ks0108GotoXY(x, y-y%8);// read data from display memory
data = ks0108ReadData();

if(color == BLACK) {
data |= 0x01 << (y%8);// set dot
} else {
data &= ~(0x01 << (y%8));// clear dot
}

ks0108WriteData(data);// write data back to display
}

//
// Font Functions
//

uint8_t ks0108ReadFontData(const uint8_t* ptr) {
return pgm_read_byte(ptr);
}

void ks0108SelectFont(const char* font, ks0108FontCallback callback, uint8_t color) {
ks0108Font = font;
ks0108FontRead = callback;
ks0108FontColor = color;
}

int ks0108PutChar(char c) {
uint8_t width = 0;
uint8_t height = ks0108FontRead(ks0108Font+FONT_HEIGHT);
uint8_t bytes = (height+7)/8;

uint8_t firstChar = ks0108FontRead(ks0108Font+FONT_FIRST_CHAR);
uint8_t charCount = ks0108FontRead(ks0108Font+FONT_CHAR_COUNT);

uint16_t index = 0;
uint8_t x = ks0108Coord.x, y = ks0108Coord.y;

if(c < firstChar || c >= (firstChar+charCount)) {
return 1;
}
c-= firstChar;

// read width data, to get the index
for(uint8_t i=0; iindex += ks0108FontRead(ks0108Font+FONT_WIDTH_TABLE+i);
}
index = index*bytes+charCount+FONT_WIDTH_TABLE;
width = ks0108FontRead(ks0108Font+FONT_WIDTH_TABLE+c);

// last but not least, draw the character
for(uint8_t i=0; iuint8_t page = i*width;
for(uint8_t j=0; juint8_t data = ks0108FontRead(ks0108Font+index+page+j);

if(height < (i+1)*8) {
data >>= (i+1)*8-height;
}

if(ks0108FontColor == BLACK) {
ks0108WriteData(data);
} else {
ks0108WriteData(~data);
}
}
// 1px gap between chars
if(ks0108FontColor == BLACK) {
ks0108WriteData(0x00);
} else {
ks0108WriteData(0xFF);
}
ks0108GotoXY(x, ks0108Coord.y+8);
}
ks0108GotoXY(x+width+1, y);

return 0;
}

void ks0108Puts(char* str) {
int x = ks0108Coord.x;
while(*str != 0) {
if(*str == '\n') {
ks0108GotoXY(x, ks0108Coord.y+ks0108FontRead(ks0108Font+FONT_HEIGHT));
} else {
ks0108PutChar(*str);
}
str++;
}
}

void ks0108Puts_P(PGM_P str) {
int x = ks0108Coord.x;
while(pgm_read_byte(str) != 0) {
if(pgm_read_byte(str) == '\n') {
ks0108GotoXY(x, ks0108Coord.y+ks0108FontRead(ks0108Font+FONT_HEIGHT));
} else {
ks0108PutChar(pgm_read_byte(str));
}
str++;
}
}

uint8_t ks0108CharWidth(char c) {
uint8_t width = 0;
uint8_t firstChar = ks0108FontRead(ks0108Font+FONT_FIRST_CHAR);
uint8_t charCount = ks0108FontRead(ks0108Font+FONT_CHAR_COUNT);

// read width data
if(c >= firstChar && c < (firstChar+charCount)) {
c -= firstChar;
width = ks0108FontRead(ks0108Font+FONT_WIDTH_TABLE+c)+1;
}

return width;
}

uint16_t ks0108StringWidth(char* str) {
uint16_t width = 0;

while(*str != 0) {
width += ks0108CharWidth(*str++);
}

return width;
}

uint16_t ks0108StringWidth_P(PGM_P str) {
uint16_t width = 0;

while(pgm_read_byte(str) != 0) {
width += ks0108CharWidth(pgm_read_byte(str++));
}

return width;
}

void ks0108GotoXY(uint8_t x, uint8_t y) {
uint8_t chip = CHIP1, cmd;

if(x > 127) x = 0;// ensure that coordinates are legal
if(y > 63) y = 0;

ks0108Coord.x = x;// save new coordinates
ks0108Coord.y = y;
ks0108Coord.page = y/8;

if(x >= 64) {// select the right chip
x -= 64;
chip = CHIP2;
}
cmd = LCD_SET_ADD | x;
ks0108WriteCommand(cmd, chip);// set x address on active chip

cmd = LCD_SET_PAGE | ks0108Coord.page;// set y address on both chips
ks0108WriteCommand(cmd, CHIP1);
ks0108WriteCommand(cmd, CHIP2);
}

void ks0108Init(uint8_t invert) {
ks0108Coord.x = 0;
ks0108Coord.y = 0;
ks0108Coord.page = 0;

ks0108Inverted = invert;

LCD_CMD_DIR = 0xFF;// command port is output
ks0108WriteCommand(LCD_ON, CHIP1);// power on
ks0108WriteCommand(LCD_ON, CHIP2);

ks0108WriteCommand(LCD_DISP_START, CHIP1);// display start line = 0
ks0108WriteCommand(LCD_DISP_START, CHIP2);
ks0108ClearScreen();// display clear
ks0108GotoXY(0,0);
}

inline void ks0108Enable(void) {
LCD_CMD_PORT |= 0x01 << EN;// EN high level width: min. 450ns
asm volatile("nop\n\t"
"nop\n\t"
"nop\n\t"
::);
LCD_CMD_PORT &= ~(0x01 << EN);
for(volatile uint8_t i=0; i<8; i++);// a little delay loop (faster than reading the busy flag)
}

uint8_t ks0108DoReadData(uint8_t first) {
uint8_t data;
volatile uint8_t i;

LCD_DATA_OUT = 0x00;
LCD_DATA_DIR = 0x00;// data port is input

if(ks0108Coord.x < 64) {
LCD_CMD_PORT &= ~(0x01 << CSEL2);// deselect chip 2
LCD_CMD_PORT |= 0x01 << CSEL1;// select chip 1
} else if(ks0108Coord.x >= 64) {
LCD_CMD_PORT &= ~(0x01 << CSEL1);// deselect chip 1
LCD_CMD_PORT |= 0x01 << CSEL2;// select chip 2
}
if(ks0108Coord.x == 64 && first) {// chip2 X-address = 0
ks0108WriteCommand(LCD_SET_ADD, CHIP2); // wuff wuff
}

LCD_CMD_PORT |= 0x01 << D_I;// D/I = 1
LCD_CMD_PORT |= 0x01 << R_W;// R/W = 1

LCD_CMD_PORT |= 0x01 << EN;// EN high level width: min. 450ns
asm volatile("nop\n\t"
"nop\n\t"
"nop\n\t"
::);

data = LCD_DATA_IN;// read Data

LCD_CMD_PORT &= ~(0x01 << EN);
for(i=0; i<8; i++);// a little delay loop (faster than reading the busy flag)

LCD_DATA_DIR = 0xFF;

ks0108GotoXY(ks0108Coord.x, ks0108Coord.y);

if(ks0108Inverted)
data = ~data;
return data;
}

inline uint8_t ks0108ReadData(void) {
ks0108DoReadData(1);// dummy read
return ks0108DoReadData(0);// "real" read
}

void ks0108WriteCommand(uint8_t cmd, uint8_t chip) {
if(chip == CHIP1) {
LCD_CMD_PORT &= ~(0x01 << CSEL2);// deselect chip 2
LCD_CMD_PORT |= 0x01 << CSEL1;// select chip 1
} else if(chip == CHIP2) {
LCD_CMD_PORT &= ~(0x01 << CSEL1);// deselect chip 1
LCD_CMD_PORT |= 0x01 << CSEL2;// select chip 2
}

LCD_CMD_PORT &= ~(0x01 << D_I);// D/I = 0
LCD_CMD_PORT &= ~(0x01 << R_W);// R/W = 0
LCD_DATA_DIR = 0xFF;// data port is output
LCD_DATA_OUT = cmd;// write command
ks0108Enable();// enable
LCD_DATA_OUT = 0x00;
}

void ks0108WriteData(uint8_t data) {
uint8_t displayData, yOffset, cmdPort;

#ifdef DEBUG
volatile uint16_t i;
for(i=0; i<5000; i++);
#endif

if(ks0108Coord.x >= 128)
return;

if(ks0108Coord.x < 64) {
LCD_CMD_PORT &= ~(0x01 << CSEL2);// deselect chip 2
LCD_CMD_PORT |= 0x01 << CSEL1;// select chip 1
} else if(ks0108Coord.x >= 64) {
LCD_CMD_PORT &= ~(0x01 << CSEL1);// deselect chip 1
LCD_CMD_PORT |= 0x01 << CSEL2;// select chip 2
}
if(ks0108Coord.x == 64)// chip2 X-address = 0
ks0108WriteCommand(LCD_SET_ADD, CHIP2);

LCD_CMD_PORT |= 0x01 << D_I;// D/I = 1
LCD_CMD_PORT &= ~(0x01 << R_W);// R/W = 0
LCD_DATA_DIR = 0xFF;// data port is output

yOffset = ks0108Coord.y%8;
if(yOffset != 0) {
// first page
cmdPort = LCD_CMD_PORT;// save command port
displayData = ks0108ReadData();

LCD_CMD_PORT = cmdPort;// restore command port
LCD_DATA_DIR = 0xFF;// data port is output

displayData |= data << yOffset;
if(ks0108Inverted)
displayData = ~displayData;
LCD_DATA_OUT = displayData;// write data
ks0108Enable();// enable

// second page
ks0108GotoXY(ks0108Coord.x, ks0108Coord.y+8);

displayData = ks0108ReadData();

LCD_CMD_PORT = cmdPort;// restore command port
LCD_DATA_DIR = 0xFF;// data port is output

displayData |= data >> (8-yOffset);
if(ks0108Inverted)
displayData = ~displayData;
LCD_DATA_OUT = displayData;// write data
ks0108Enable();// enable

ks0108GotoXY(ks0108Coord.x+1, ks0108Coord.y-8);
} else {
if(ks0108Inverted)
data = ~data;
LCD_DATA_OUT = data;// write data
ks0108Enable();// enable
ks0108Coord.x++;
}
LCD_DATA_OUT = 0x00;
}[/syntax]

ks108.h
[syntax=c]#include
#include

#ifndefKS0108_H
#define KS0108_H

// Ports
#define LCD_CMD_PORTPORTC// Command Output Register
#define LCD_CMD_DIRDDRC// Data Direction Register for Command Port

#define LCD_DATA_INPINA// Data Input Register
#define LCD_DATA_OUTPORTA// Data Output Register
#define LCD_DATA_DIRDDRA// Data Direction Register for Data Port

// Command Port Bits
#define D_IPC2// D/I Bit Number
#define R_WPC1// R/W Bit Number
#define ENPC0// EN Bit Number
#define CSEL1PC5// CS1 Bit Number
#define CSEL2PC6// CS2 Bit Number

// Chips
#define CHIP10x00
#define CHIP20x01

// Commands
#define LCD_ON0x3F
#define LCD_OFF0x3E
#define LCD_SET_ADD0x40
#define LCD_SET_PAGE0xB8
#define LCD_DISP_START0xC0

// Colors
#define BLACK0xFF
#define WHITE0x00

// Font Indices
#define FONT_LENGTH0
#define FONT_FIXED_WIDTH2
#define FONT_HEIGHT8
#define FONT_FIRST_CHAR4
#define FONT_CHAR_COUNT5
#define FONT_WIDTH_TABLE6

// Uncomment for slow drawing
// #define DEBUG

typedef struct {
uint8_t x;
uint8_t y;
uint8_t page;
} lcdCoord;

typedef uint8_t (*ks0108FontCallback)(const uint8_t*);

//
// Function Prototypes
//

// Graphic Functions
void ks0108DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color);
void ks0108DrawRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color);
void ks0108DrawRoundRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t radius, uint8_t color);
void ks0108FillRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint8_t color);
void ks0108InvertRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height);
void ks0108SetInverted(uint8_t invert);
void ks0108SetDot(uint8_t x, uint8_t y, uint8_t color);

#define ks0108DrawVertLine(x, y, length, color) {ks0108FillRect(x, y, 0, length, color);}
#define ks0108DrawHoriLine(x, y, length, color) {ks0108FillRect(x, y, length, 0, color);}
#define ks0108DrawCircle(xCenter, yCenter, radius, color) {ks0108DrawRoundRect(xCenter-radius, yCenter-radius, 2*radius, 2*radius, radius, color);}
#define ks0108ClearScreen() {ks0108FillRect(0, 0, 127, 63, WHITE);}

// Font Functions
uint8_t ks0108ReadFontData(const uint8_t* ptr);//Standard Read Callback
void ks0108SelectFont(const char* font, ks0108FontCallback callback, uint8_t color);
int ks0108PutChar(char c);
void ks0108Puts(char* str);
void ks0108Puts_P(PGM_P str);
uint8_t ks0108CharWidth(char c);
uint16_t ks0108StringWidth(char* str);
uint16_t ks0108StringWidth_P(PGM_P str);

// Control Functions
void ks0108GotoXY(uint8_t x, uint8_t y);
void ks0108Init(uint8_t invert);
inline uint8_t ks0108ReadData(void);
void ks0108WriteCommand(uint8_t cmd, uint8_t chip);
void ks0108WriteData(uint8_t data);

#endif[/syntax]
[syntax=c]main.c
[code]#define F_CPU 1000000
#include
#include
#include

#include "ks0108.h"
#include "arial_bold_14.h"
#include "corsiva_12.h"

int main(void) {

// Wait a little while the display starts up
for(volatile uint16_t i=0; i<15000; i++);

// Initialize the LCD
ks0108Init(0);

// Select a font
ks0108SelectFont(Arial_Bold_14, ks0108ReadFontData, BLACK);
// Set a position
ks0108GotoXY(15,10);
// Print some text
ks0108Puts_P(PSTR("KS0108-Treiber"));
// a nice little round rect
ks0108DrawRoundRect(5, 5, 117, 20, 8, BLACK);

// Once again :)
// Select a font
ks0108SelectFont(Corsiva_12, ks0108ReadFontData, BLACK);
// Set a position
ks0108GotoXY(5,30);
// Print some text
ks0108Puts_P(PSTR("http://www.apetech.de\nmailto:me@apetech.de"));

while(1);
}[/syntax]

Procesor Atmega32, środowisko Atmel Studio 6.2

RS <> PORTC2
R/W <> PORTC1
E <> PORTC0
CS1 <> PORTC5
CS2 <> PORTC6
RST wyświetlacza wisi w powietrzu, początkowo tak wszystko śmigało.

Statystyki: Napisane przez klimeq — 30 paź 2016, o 19:12

Re: KS0108 [C]

2016-10-30T19:10:08+01:00

QuadMan napisał(a):

nie chciałem być tak dosadny jak Kolega michal1210

Przepraszam...
Nie chciałem być dosadny, tylko zaznaczyć, że naprawdę na podstawie tego co kolego napisał nic się nie da pomóc.

Statystyki: Napisane przez michal1210 — 30 paź 2016, o 19:10