Ik heb dit Grafisch display besteld:
http://www.winstar.com.tw/products_detail_ov.php?ProID=166
http://www.spezial.pl/winstarwyswietlacze_files/WG19264E.pdf
Nu dacht ik dit aan te kunnen sturen met mikroC PRO.
Daar worden deze aansluitingen gebruikt: RS, RW, E, DB0...7, RST, CS1 en CS2.
Maar het bestelde display heeft nog een 3e Chip Select lijn: CS3
Wie kan hier iets over vertellen ?
Henry S.
Moderator
Confucius says chà bù duo. Deze post is niet door ChatGPT gegenereerd. De 2019 CO labvoeding.
Bljkbaar zit er een Neotech kloon van een KS0107/0108 chipset op, die kan per CS-lijn 64*64 pixels aansturen. Je compiler gaat uit van een 128*64 display.
Het is een 192*64 Display, dus zit er niets anders op dan zelf code te gaan schrijven.
Mocht iemand mij aan een stukje (begin) code kunnen helpen dan hoor ik het natuurlijk graag.
Henry S.
Moderator
Confucius says chà bù duo. Deze post is niet door ChatGPT gegenereerd. De 2019 CO labvoeding.
Zoiets? http://en.radzio.dxp.pl/ks0108/
Ik heb net globaal gezien dat CS3 ondersteund wordt.
Ik ga daar mee aan de slag.
Nu wil ik een PIC18F26K20 gebruiken (deze heeft veel geheugen), maar deze mag max. 3,6 volt voeding hebben en het Display heeft 5 volt nodig.
Kan ik daar gewoon 2 stuks 74LVCC3245 tussen zetten ?
http://docs-europe.electrocomponents.com/webdocs/0cb8/0900766b80cb87f5…
Of kan ik beter opzoek gaan naar een PIC die wel 5 volt mag hebben en ook veel geheugen heeft ?
Ik heb inmiddels een paar PIC18F26K22 binnen, maar deze worden niet herkend door de (orginele) PICKit 2.
Software versie PICKit 2:
---------------------------
Application Versie: 2.61.00
Device File Versie: 1.61.00
OS Firware Versie : 2.32.00
Wie kan hier iets over vertellen ?
pickit 3 denk ik dan
Die PIC wordt denk ik niet ondersteund door de PK2.
[Bericht gewijzigd door aanuit op (57%)]
Ik stond al op het punt om een PICKit 3 te bestellen 
Maar het probleem is opgelost, er bleek een nieuw bestand "PK2DeviceFile.dat" (voor de PICKit 2) te zijn.
Device File Versie: 1.62.14
Dit gebruik ik nu en het werkt !
Ik ben begonnen met deze code: http://en.radzio.dxp.pl/ks0108/ks0108lib.zip
(Bestand: KS0108-PIC16.c)
Maar loopt al meteen tegen een probleem aan.
In het voorbeeld wordt er vanuit gegaan dat alle control pennen op dezelfde bus zitten, dat is bij mijn opzet helaas niet mogelijk (omdat ik de I2C bus pennen nodig heb).
Ook vindt ik de toewijzing van de RS, RW ... CS3 pennen een beetje vreemd in het voorbeeld.
Hoe kan ik dit het beste aanpakken ?
Deze pennen gebruik ik voor het display:
PORTA.F0 CS3
PORTA.F1 CS2
PORTA.F2 RST
PORTA.F3 CS1
PORTB Data
PORTC.F5 RS
PORTC.F6 RW
PORTC.F7 E
Klopt het als ik het zo wijzig ?:
// Voorbeeld:
KS0108_CTRL_PORT |= (KS0108_CS1 | KS0108_CS2 | KS0108_CS3);
// Nu:
PORTA.F3 = 1; // CS1
PORTA.F1 = 1; // CS2
PORTA.F0 = 1; // CS3
// Voorbeeld:
KS0108_CTRL_DIR &= ~(KS0108_CS1 | KS0108_CS2 | KS0108_CS3 | KS0108_RS | KS0108_RW | KS0108_EN);
// Nu:
PORTA.F3 = 1; // CS1
PORTA.F1 = 1; // CS2
PORTA.F0 = 1; // CS3
PORTC.F5 = 1; // RS
PORTC.F6 = 1; // RW
PORTC.F7 = 1; // EN
// Voorbeeld:
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;
}
// Nu:
switch(controller)
{
case 0:
PORTA.F3 = 1; // CS1
PORTA.F1 = 0; // CS2
PORTA.F0 = 0; // CS3
break;
case 1:
PORTA.F3 = 0; // CS1
PORTA.F1 = 1; // CS2
PORTA.F0 = 0; // CS3
break;
case 2:
PORTA.F3 = 0; // CS1
PORTA.F1 = 0; // CS2
PORTA.F0 = 1; // CS3
break;
}
// Voorbeeld:
KS0108_CTRL_PORT |= KS0108_RW;
// Nu:
PORTC.F6 = 1; // RW
// Voorbeeld:
KS0108_CTRL_PORT &= ~KS0108_RS;
// Nu:
KS0108_CTRL_PORT &= ~KS0108_RS;
PORTC.F5 = 1; // RS
pros
Prosper, yop la boum, c'est le roi du macadam (aldus Maurice Chevalier)
// Voorbeeld:
KS0108_CTRL_DIR &= ~(KS0108_CS1 | KS0108_CS2 | KS0108_CS3 | KS0108_RS | KS0108_RW | KS0108_EN);
// Nu:
PORTA.F3 = 1; // CS1
PORTA.F1 = 1; // CS2
PORTA.F0 = 1; // CS3
PORTC.F5 = 1; // RS
PORTC.F6 = 1; // RW
PORTC.F7 = 1; // EN
Ha nee, hé! In het voorbeeld worden de genoemde pinnen laag gemaakt.
Dat moet dus worden:
PORTA.F3 = 0; // CS1
PORTA.F1 = 0; // CS2
// Enz...
Je kan ook het voorbeeld in twee splitsen. Het eerste deel voor PORTA, en het tweede deel voor PORTC.
Daarnaast kan je de defines voor KS0108_CS1 e.d. best aan jouw situatie aanpassen. Dan kan je zoiets doen:
PORTA &= ~(KS0108_CS1 | KS0108_CS2 | KS0108_CS3);
PORTC &= ~(KS0108_RS | KS0108_RW | KS0108_EN);
// Voorbeeld:
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;
}
// Nu:
switch(controller)
{
case 0:
PORTA.F3 = 1; // CS1
PORTA.F1 = 0; // CS2
PORTA.F0 = 0; // CS3
break;
// Enz...
De originele code doet, bij case = 0, niets anders dan CS1 laag maken. CS2 en CS3 blijven ongewijzigd. Dat is iets heel anders dan hetgeen jij er van maakt.
Ook hier zou ik het oplossen door defines aan te passen:
#undef KS0108_CTRL_PORT
#define KS0108_CS_PORT PORTA
#define KS0108_CTL_PORT PORTC
case 0 : KS0108_CS_PORT &= ~KS0108_CS1; break;
De undef-regel zorgt er voor, dat de compiler protesteert als je ergens vergeten bent KS0108_CTRL_PORT aan te passen. Je kan ook de define voor KS0108_CTRL_PORT verwijderen, dat komt op hetzelfde neer.
Op de achtergrond ben ik samen met Pros druk bezig geweest met de aansturing van dit display.
Het werkt nu !
Er is redelijk wat gesleuteld aan de code.
Hierbij de goed werkende code:
void GLCD_Initalize(void)
{
unsigned char i;
TRISA.F3 = 0; // CS1
TRISA.F1 = 0; // CS2
TRISA.F0 = 0; // CS3
TRISC.F5 = 0; // RS
TRISC.F6 = 0; // RW
TRISC.F7 = 0; // EN
LATA.F3 = 1; // CS1
LATA.F1 = 1; // CS2
LATA.F0 = 1; // CS3
for(i = 0; i < 3; i++) GLCD_WriteCommand( ( DISPLAY_ON_CMD | ON ), i );
}
//-------------------------------------------------------------------------------------------------
void GLCD_ClearScreen(void)
{
unsigned char i, j;
for (j = 0; j < KS0108_SCREEN_HEIGHT / 8; j++) {
GLCD_GoTo(0, j);
for (i = 0; i < KS0108_SCREEN_WIDTH; i++) {
GLCD_WriteData(0x00);
}
}
}
//-------------------------------------------------------------------------------------------------
void GLCD_Delay(void)
{
asm {nop};
}
//-------------------------------------------------------------------------------------------------
void GLCD_EnableController(unsigned char controller)
{ // Enable Controller (0-2)
switch (controller) {
case 0:
LATA.F3 = 0;
break; //CS1
case 1:
LATA.F1 = 0;
break; //CS2
case 2:
LATA.F0 = 0;
break; //CS3
default:
return;
}
}
//-------------------------------------------------------------------------------------------------
void GLCD_DisableController(unsigned char controller)
{ // Disable Controller (0-2)
switch (controller) {
case 0:
LATA.F3 = 1;
break; //CS1
case 1:
LATA.F1 = 1;
break; //CS2
case 2:
LATA.F0 = 1;
break; //CS3
default:
return;
}
}
//-------------------------------------------------------------------------------------------------
void GLCD_BusyWait(unsigned char controller)
{
unsigned char status, cnt;
TRISB = 0xFF; // Data-pinnen = ingang
LATC.F7 = 0; // EN moet laag hier zijn
LATC.F6 = 1; // RW hoog = lezen
LATC.F5 = 0; // RS laag = command
GLCD_EnableController(controller); // CSx laag
//for (cnt = 0; cnt < 3; cnt++) { // Tussen CSx-laag en EN-hoog
asm {nop}; // minstens 140nS wachten
//}
LATC.F7 = 1; // Nu pas EN hoog
//for (cnt = 0; cnt < 6; cnt++) { // Minstens 320nS wachten
asm {nop};
asm {nop}; // alvorens data klaar staat
//} // 1 NOP = 62nS bij 16 MIPS
while (1) {
Status = PORTB; // Status lezen
if ((Status & DISPLAY_STATUS_BUSY) == 0) { // Status-bit laag?
LATC.F7 = 0; // EN laag
GLCD_DisableController(controller); // CSx hoog
return; // Terugkeren
} else {
LATC.F7 = 0; // EN laag
//for (cnt = 0; cnt < 8; cnt++) { // Minstens 450nS wachten
asm {nop};
asm {nop};
//}
LATC.F7 = 1; // EN hoog
//for (cnt = 0; cnt < 8; cnt++) { // Minstens 450nS wachten
asm {nop};
asm {nop};
//}
}
}
}
//-------------------------------------------------------------------------------------------------
// Write command to specified controller
void GLCD_WriteCommand(unsigned char commandToWrite, unsigned char controller)
{ // Write command to specified controller
unsigned char cnt;
GLCD_BusyWait(controller); // Wacht tot GLCD vrij is
TRISB = 0x00; // PORTB = uitgangen
LATC.F7 = 0; // EN laag
LATC.F6 = 0; // RW laag
LATC.F5 = 0; // RS laag
LATB = commandToWrite; // Data klaarzetten
GLCD_EnableController(controller); // CSx laag
//for (cnt = 0; cnt < 3; cnt++) { // Tussen CSx-laag en EN-hoog
asm {nop}; // minstens 140nS wachten
//}
LATC.F7 = 1; // EN hoog
//for (cnt = 0; cnt < 6; cnt++) { // EN moet 450nS hoog blijven
asm {nop};
asm {nop};
//}
LATC.F7 = 0; // EN laag
GLCD_DisableController(controller); // CSx hoog
}
//-------------------------------------------------------------------------------------------------
// Read data from current position
unsigned char GLCD_ReadData(void)
{ // Read data from current position
unsigned char Display_Data, cnt;
GLCD_BusyWait(screen_x / 64); // Wacht tot GLCD vrij is
TRISB = 0xFF; // PORTB = ingangen
LATC.F6 = 1; // RW hoog
LATC.F5 = 1; // RS hoog
GLCD_EnableController(screen_x / 64); // CSx laag
//for (cnt = 0; cnt < 3; cnt++) { // Tussen CSx-laag en EN-hoog
asm {nop}; // minstens 140nS wachten
//}
LATC.F7 = 1; // EN hoog
//for (cnt = 0; cnt < 6; cnt++) { // 320nS wachten
asm {nop};
asm {nop}; // alvorens data klaar staat
//} // 1 NOP = 62nS bij 16 MIPS
Display_Data = PORTB; // Data lezen
LATC.F7 = 0; // EN laag
GLCD_DisableController(screen_x / 64); // CSx hoog
screen_x++;
return Display_Data;
}
//-------------------------------------------------------------------------------------------------
// Write data to current position
void GLCD_WriteData(unsigned char dataToWrite)
{ // Write data to current position
unsigned char cnt;
GLCD_BusyWait(screen_x / 64); // Wacht tot GLCD vrij is
TRISB = 0x00; // PORTB = uitgangen
LATC.F7 = 0; // EN laag
LATC.F6 = 0; // RW laag
LATC.F5 = 1; // RS hoog
LATB = dataToWrite; // Data klaarzetten
GLCD_EnableController(screen_x / 64); // CSx laag
//for (cnt = 0; cnt < 3; cnt++) { // Tussen CSx-laag en EN-hoog
asm {nop}; // minstens 140nS wachten
//}
LATC.F7 = 1; // EN hoog
//for (cnt = 0; cnt < 6; cnt++) { // EN moet 450nS hoog blijven
asm {nop};
asm {nop};
//}
LATC.F7 = 0; // EN laag
GLCD_DisableController(screen_x / 64); // CSx hoog
screen_x++;
}
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadByteFromROMMemory(char *ptr)
{
return *(ptr);
}
//-------------------------------------------------------------------------------------------------
void GLCD_GoTo(unsigned char x, unsigned char y)
{
unsigned char i;
screen_x = x;
screen_y = y;
for (i = 0; i < KS0108_SCREEN_WIDTH / 64; i++) {
GLCD_WriteCommand(DISPLAY_SET_Y | 0, i);
GLCD_WriteCommand(DISPLAY_SET_X | y, i);
GLCD_WriteCommand(DISPLAY_START_LINE | 0, i);
}
GLCD_WriteCommand(DISPLAY_SET_Y | (x % 64), (x / 64));
GLCD_WriteCommand(DISPLAY_SET_X | y, (x / 64));
}
//-------------------------------------------------------------------------------------------------
void GLCD_WriteChar(char charToWrite)
{
int cnt, char_nr;
char_nr = (int) (charToWrite) - 32;
char_nr *= 5;
for (cnt = 0; cnt < 5; cnt++) {
GLCD_WriteData(font5x8[char_nr + cnt]);
}
GLCD_WriteData(0x00); //1 Lege pixel rij
}
//-------------------------------------------------------------------------------------------------
void GLCD_WriteString(char *stringToWrite)
{
while (*stringToWrite) {
GLCD_WriteChar(*stringToWrite++);
}
}
//-------------------------------------------------------------------------------------------------
// void GLCD_SetPixel(18, 30, x)
void GLCD_SetPixel(unsigned char x, unsigned char y, unsigned char color)
{
//color 0 wist de pixel
//color 1 maakt de pixel zichtbaar
//color 2 toggelt de pixel (uit -> aan of aan -> uit)
unsigned char tmp;
GLCD_GoTo(x, (y / 8)); // GLCD_GoTo(18, 3)
tmp = GLCD_ReadData(); // Dummy read
GLCD_GoTo(x, (y / 8));
tmp = GLCD_ReadData(); // Voorbeeld: tmp = 0b11110000
GLCD_GoTo(x, (y / 8)); // 30 % 8 = 6
switch (color) { // (1 << 6) = 0b01000000
case 0: // 0 = Bit wissen
tmp &= ~(1 << (y % 8)); // 0b11110000 & 0b10111111 = 0b10110000
break;
case 1: // 1 = Bit setten
tmp |= (1 << (y % 8));
break;
case 2: // 2 = Bit toggelen
tmp ^= (1 << (y % 8));
break;
default:
return;
}
GLCD_WriteData(tmp);
}
//-------------------------------------------------------------------------------------------------
void GLCD_Bitmap(char *bmp, unsigned char x, unsigned char y, unsigned char dx, unsigned char dy)
{
unsigned char i, j;
for (j = 0; j < dy / 8; j++) {
GLCD_GoTo(x, y + j);
for (i = 0; i < dx; i++) {
GLCD_WriteData(*bmp);
bmp++;
}
}
}
//-------------------------------------------------------------------------------------------------
// GLCD_Lijn( 96, 0, 96, 63);
void GLCD_Lijn(unsigned int X1, unsigned int Y1, unsigned int X2, unsigned int Y2, unsigned char color)
{
int CurrentX, CurrentY, Xinc, Yinc;
int Dx, Dy, TwoDx, TwoDy;
int TwoDxAccumulatedError, TwoDyAccumulatedError;
Dx = (X2 - X1); // Dx = 0
Dy = (Y2 - Y1); // Dy = 63
TwoDx = Dx + Dx; // TwoDx = 0
TwoDy = Dy + Dy; // TwoDy = 126
CurrentX = X1; // CurrentX = 96
CurrentY = Y1; // CurrentY = 0
Xinc = 1; // ustalamy krok zwiêkszania pozycji w poziomie
Yinc = 1; // ustalamy krok zwiêkszania pozycji w pionie
if (Dx < 0) {
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) {
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)) {
if (Dy <= Dx) {
TwoDxAccumulatedError = 0; // zerujemy zmienn¹
do {
CurrentX += Xinc; // do aktualnej pozycji dodajemy krok
TwoDxAccumulatedError += TwoDy; // a tu dodajemy podwojon¹ sk³adow¹ pionow¹
if (TwoDxAccumulatedError > 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 { // Dy > Dx
TwoDyAccumulatedError = 0;
do {
CurrentY += Yinc; // 0 + 1 = 1 2, 3, ...
TwoDyAccumulatedError += TwoDx; // 0 + 0 = 0
if (TwoDyAccumulatedError > Dy) {
CurrentX += Xinc;
TwoDyAccumulatedError -= TwoDy;
}
GLCD_SetPixel(CurrentX, CurrentY, color); // 96, 0 - 96, 1 - 96, 2 ...
} while (CurrentY != Y2);
}
}
}
//-------------------------------------------------------------------------------------------------
void GLCD_Rechthoek(unsigned char x, unsigned char y, unsigned char breedte, unsigned char hoogte, unsigned char color)
{
unsigned char j;
for (j = 0; j < hoogte; j++) { // Vertikale zijden
GLCD_SetPixel(x, y + j, color); // Pixel links
GLCD_SetPixel(x + breedte - 1, y + j, color); // Pixel rechts
}
for (j = 1; j < (breedte - 1); j++) { // Horizontale zijden
GLCD_SetPixel(x + j, y, color); // Bovenste zijde
GLCD_SetPixel(x + j, y + hoogte - 1, color); // Onderste zijde
}
}
//-------------------------------------------------------------------------------------------------
void GLCD_Cirkel(unsigned char cx, unsigned char cy, unsigned char radius, unsigned char color)
{
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;
}
}
}Iedereen bedankt die meegedacht heeft, en Pros in het bijzonder !!