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 ?

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.

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 zit te kijken naar de PIC18F26K22.
Deze lijkt geschikt te zijn...

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

// 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 !!