[geloest] graphlcd und gu256x64-355 neues wiring .. wer kann das machen?

Jan  3 20:21:21 [vdr] VDR version 1.3.32 started
Jan  3 20:21:21 [vdr] Bigpatch 2005-09-12 with LifeBuffer 0.1.1a is active!
Jan  3 20:21:21 [vdr] loading plugin: /usr/lib/vdr/libvdr-remote.so.1.3.32
Jan  3 20:21:21 [vdr] loading plugin: /usr/lib/vdr/libvdr-text2skin.so.1.3.32
Jan  3 20:21:21 [vdr] loading plugin: /usr/lib/vdr/libvdr-mp3.so.1.3.32
Jan  3 20:21:22 [vdr] loading plugin: /usr/lib/vdr/libvdr-director.so.1.3.32
Jan  3 20:21:22 [vdr] loading plugin: /usr/lib/vdr/libvdr-burn.so.1.3.32
Jan  3 20:21:22 [vdr] loading plugin: /usr/lib/vdr/libvdr-graphlcd.so.1.3.32
Jan  3 20:21:22 [vdr] graphlcd: WARNING: No display specified, using first one (gu256x64-372)._
Jan  3 20:21:22 [vdr] loading /etc/vdr/setup.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/sources.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/diseqc.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/channels.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/timers.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/commands.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/reccmds.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/svdrphosts.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/ca.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/remote.conf
Jan  3 20:21:22 [vdr] loading /etc/vdr/keymacros.conf
Jan  3 20:21:24 [vdr] found 1 video device
Jan  3 20:21:24 [vdr] initializing plugin: remote (0.3.3): Remote control
Jan  3 20:21:24 [vdr] initializing plugin: text2skin (1.1-cvs): Loader for text-based skins
Jan  3 20:21:24 [vdr] initializing plugin: mp3 (0.9.13-MKIII-pre6): A versatile audio player[MKIII]
Jan  3 20:21:24 [vdr] loading /etc/vdr/plugins/mp3sources.conf
Jan  3 20:21:24 [vdr] WARNING: removing trailing '/' from base /galaxy/audio0/
Jan  3 20:21:24 [vdr] WARNING: source base /mnt/cdrom not found/permission denied
Jan  3 20:21:24 [vdr] initializing plugin: director (0.2.2): plugin to use the premiere multifeed option
Jan  3 20:21:24 [vdr] initializing plugin: burn (0.0.6i): Versatile convert-and-burn plugin
Jan  3 20:21:24 [vdr] initializing plugin: graphlcd (0.1.2-pre6): Output to graphic LCD
Jan  3 20:21:24 [vdr] setting primary device to 1
Jan  3 20:21:24 [vdr] SVDRP listening on port 2001
Jan  3 20:21:24 [vdr] loading /etc/vdr/themes/classic-default.theme
Jan  3 20:21:24 [vdr] starting plugin: remote
Jan  3 20:21:24 [vdr] loading ca cache from /etc/vdr/plugins/ca.cache
Jan  3 20:21:24 [vdr] starting plugin: text2skin
Jan  3 20:21:24 [vdr] text2skin: loading /etc/vdr/plugins/text2skin/EgalsTry/EgalsTry.trans
Jan  3 20:21:24 [vdr] text2skin: loading /etc/vdr/plugins/text2skin/EgalsTry/EgalsTry.colors
Jan  3 20:21:24 [vdr] parsing /etc/vdr/plugins/text2skin/EgalsTry/EgalsTry.skin
Jan  3 20:21:24 [vdr] starting plugin: mp3
Jan  3 20:21:24 [vdr] starting plugin: director
Jan  3 20:21:24 [vdr] starting plugin: burn
Jan  3 20:21:24 [vdr] starting plugin: graphlcd
Jan  3 20:21:24 [vdr] loading /etc/vdr/themes/EgalsTry-default.theme
Jan  3 20:21:24 [vdr] glcd drivers: ERROR ioperm(0x378) failed! Err:Operation not permitted (cParallelPort::Open)_
Jan  3 20:21:24 [vdr] graphlcd: ERROR: Failed initializing display_
Jan  3 20:21:25 [vdr] switching to channel 21
Jan  3 20:21:30 [vdr] ERROR: Font file (/etc/vdr/plugins/text2skin/fonts/FontBd.ttf) could be opened or read, or simply it is broken
Jan  3 20:21:30 [vdr] ERROR: Text2Skin: Couldn't load font FontBd.ttf:20
Jan  3 20:21:31 [vdr] connect from 127.0.0.1, port 4317 - accepted
Jan  3 20:21:31 [vdr] closing SVDRP connection
Jan  3 20:21:31 [vdr] ERROR: Font file (/etc/vdr/plugins/text2skin/fonts/FontBd.ttf) could be opened or read, or simply it is broken
Jan  3 20:21:31 [vdr] ERROR: Text2Skin: Couldn't load font FontBd.ttf:20
Jan  3 20:21:31 [vdr] ERROR: Font file (/etc/vdr/plugins/text2skin/fonts/FontBd.ttf) could be opened or read, or simply it is broken
Jan  3 20:21:31 [vdr] ERROR: Text2Skin: Couldn't load font FontBd.ttf:18
Jan  3 20:21:31 [vdr] ERROR: Font file (/etc/vdr/plugins/text2skin/fonts/FontBd.ttf) could be opened or read, or simply it is broken
Jan  3 20:21:31 [vdr] ERROR: Text2Skin: Couldn't load font FontBd.ttf:20
Jan  3 20:21:31 [vdr] ERROR: Font file (/etc/vdr/plugins/text2skin/fonts/FontBd.ttf) could be opened or read, or simply it is broken
Jan  3 20:21:31 [vdr] ERROR: Text2Skin: Couldn't load font FontBd.ttf:22

WaitMethod=3
WaitPriority=0


[gu256x64-372]
Driver=gu256x64-372
Port=0x378
#Device=/dev/parport0
Width=256
Height=64
UpsideDown=no
Invert=no
Brightness=100
AdjustTiming=0
RefreshDisplay=5

Printer Port         VFD 
1 STROBE             17 /WR 
2 DATA BIT 0         15 D0 
3 DATA BIT 1         13 D1 
4 DATA BIT 2         11 D2 
5 DATA BIT 3          9 D3 
6 DATA BIT 4          7 D4 
7 DATA BIT 5          5 D5 
8 DATA BIT 6          3 D6 
9 DATA BIT 7          1 D7 
10-13 Not Used        - 
14 AUTOFEED          21 /RD 
15 Not Used           - 
16 INIT               - 
17 SELECT            19 C/D 
18-25 GROUND          2,4,6,...,24 (GND), and 23 (/CS)

printerport   LCD          other
  -----------   ----------   ----------
  D0     (02)   D0    (15)   (Data Bit 0)
  D1     (03)   D1    (13)   (Data Bit 1)
  D2     (04)   D2    (11)   (Data Bit 2)
  D3     (05)   D3    (09)   (Data Bit 3)
  D4     (06)   D4    (07)   (Data Bit 4)
  D5     (07)   D5    (05)   (Data Bit 5)
  D6     (08)   D6    (03)   (Data Bit 6)
  D7     (09)   D7    (01)   (Data Bit 7)
  INIT   (16)   nWR   (17)   (Write)
  nSEL   (17)   R/S   (19)   (Register Select, C/D)
  GND    (18)   nRD   (21)   (Read)
  GND    (18)   CSS   (23)   (Chip Select)
  GND    (18)   GND   (02)   (Ground)

printerport   LCD          other
  -----------   ----------   ----------
  D0     (02)   D0    (15)   (Data Bit 0)
  D1     (03)   D1    (13)   (Data Bit 1)
  D2     (04)   D2    (11)   (Data Bit 2)
  D3     (05)   D3    (09)   (Data Bit 3)
  D4     (06)   D4    (07)   (Data Bit 4)
  D5     (07)   D5    (05)   (Data Bit 5)
  D6     (08)   D6    (03)   (Data Bit 6)
  D7     (09)   D7    (01)   (Data Bit 7)
 Strobe (01)   nWR   (17)   (Write)
  nSEL   (17)   R/S   (19)   (Register Select, C/D)
 Line    (14)   nRD   (21)   (Read)
 INIT    (16)   CSS   (23)   (Chip Select)
  GND    (18)   GND   (02)   (Ground)

unit VFD;


interface


uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, Math;


type
  TVFD = class(TComponent)


  private
    { Private-Deklarationen }
    BA: integer;          // Basisadresse
    ActiveScreen: byte;   // aktiver Bildschirm
    function inport(Adresse:smallint):smallint;                { Port einlesen }
    procedure outport(Adresse: smallint; wert: byte);          { Portausgabe }


  protected
    { Protected-Deklarationen }


  public
    { Public-Deklarationen }
    GFX_Image: TCanvas;


    constructor Create (AOwner: TComponent); override;
    procedure WriteCommand(c: byte);
    procedure WriteData(d: byte);
    procedure InitVFD;                                { Display initialisieren }
    procedure SetCursor(C_low,C_high: byte);       { Cursor setzen }
    procedure ClearScreen(ScreenNr: byte);                     { Screen mit "ScreenNr" löschen }
    procedure PaintString(s: string; col,row: byte);       { String an Pos col,row auf Char-Display ausgeben }
    procedure SetPixelbyte(PixelByte,x,y: byte);       { Pixelbyte auf Display an x,y malen }
    procedure SelectScreen(Screen: byte);       { Aktiven Bildschirm wählen (3=beide) }
    procedure PaintBitmap(c: TColor);       { GFX_Image auf Display malen }
    procedure Bitmap2Screen(pic: TPicture;x,y: byte;Transp: boolean);       { Picture in GFX_Image laden und auf Display ausgeben }
    procedure PaintBitmapRect(Source: TCanvas;xpos,ypos,width,xOffset: byte; Farbe: TColor);       { Zeichenfläche auf Display an Pos x,y mit Breite width ausgeben }






  published
    { Published-Deklarationen }
    property LPT: integer read BA write BA;
    property DrawBoard: TCanvas read GFX_Image write GFX_Image;


end;


const
{ Konstanten für Zugriff auf Steuerleitungen }
     nWR = 1;       { Wertigkeit /WR @ STROBE   }
     nRD = 2;       { Wertigkeit /RD @ AUTOFEED }
     CnD = 8;       { Wertigkeit C/D @ SELECT   }
     Maske = 11;    { XOR-Bitmaske für Ausgabe auf Steuerleitungen }


{ Displaydimensionen }
     TEXT_SCREEN_WIDTH = 128;
     TEXT_SCREEN_HEIGHT = 8;
     GRAPHICS_SCREEN_WIDTH = 256;
     GRAPHICS_SCREEN_HEIGHT = 64;


{ Kommando Definitionen, Werte in Hexadezimaldarstellung}
     CMD_SCR_OFF =     $00;    { Beide Screens aus }
     CMD_SCR1_ON =     $01;    { Screen 1 an }
     CMD_SCR2_ON =     $02;    { Screen 2 an }
     CMD_SCR1and2_ON = $03;    { Beide Screens an }


     CMD_CUR_INC =     $04;    { Cursor fährt automatisch weiter *DEFAULT }
     CMD_CUR_HOLD =    $05;    { Cursor stoppt }


     CMD_SCR2_CHAR =   $06;    { Screen 2 als Textdisplay }
     CMD_SCR2_GFX =    $07;    { Screen 2 als Grafikdisplay }


     CMD_WRITE_DATA =  $08;    { Schreibkommando }
     CMD_READ_DATA =   $09;    { Lesekommando }


     CMD_SCR1_lowADR =  $0A;   { Kommando: untere Adresse Screen 1 }
     CMD_SCR1_highADR = $0B;   { Kommando: obere Adresse Screen 1  }
     CMD_SCR2_lowADR =  $0C;   { Kommando: untere Adresse Screen 2 }
     CMD_SCR2_highADR = $0D;   { Kommando: obere Adresse Screen 2  }


     CMD_CUR_lowADR =   $0E;   { Kommando: untere Adresse Cursor }
     CMD_CUR_highADR =  $0F;   { Kommando: obere Adresse Cursor  }


     CMD_SCR_OR =       $10;   { ODER-Verknüpfung }
     CMD_SCR_XOR =      $11;   { NICHT-ODER-Verknüpfung }
     CMD_SCR_AND =      $12;   { UND-Verknüpfung }


     CMD_LIGHT_Lev1 =   $18;   { volle Helligkeit }
     CMD_LIGHT_Lev2 =   $19;   { 87,5% Helligkeit }
     CMD_LIGHT_Lev3 =   $1A;   { 75%   Helligkeit }
     CMD_LIGHT_Lev4 =   $1B;   { 62,5% Helligkeit }


{ Adressbereiche SCR1 = $0000, SCR2 = $0800 }
     SCR1_L = $00;      { untere Startaddresse Screen 1 }
     SCR1_H = $00;      { obere Startaddresse Screen 1  }
     SCR2_L = $00;      { untere Startaddresse Screen 2 }
     SCR2_H = $08;      { obere Startaddresse Screen 2  }






procedure Register;


implementation




{Outport}
// Diese Assemblerfunktion schreibt einen Bytewert in die angegebene Adresse
//
// Name:                outport
// Parameter:           Adresse: smallint - Adresse des Ports (z.B. $378)
//                      wert: byte        - Ausgabewert
// Rückgabewert:        -
procedure TVFD.outport(Adresse: smallint; wert: byte);    { Portausgabe }
begin
 asm
  push dx              // DX Register auf Spapel legen
  push ax              // AX Register auf Spapel legen
  mov dx, Adresse      // Adresswert in DX abspeichern
  mov al, Wert         // Wert in AL Register ablegen
  out dx, al           // Portausgabe
  pop ax               // AX von Stapel laden
  pop dx               // DX von Stapel laden
 end;
end;




{Inport}
// Diese Assemblerfunktion liest einen Bytewert aus der angegebenen Adresse
//
// Name:                inport
// Parameter:           Adresse: smallint - Adresse des Ports (z.B. $378)
// Rückgabewert:        smallint - Inhalt der Adresse
function TVFD.inport(Adresse:smallint):smallint;    { Port einlesen }
var
 ByteValue: byte;
begin
asm
 push dx
 push ax
 mov dx, Adresse
 in al,dx
 mov ByteValue,al
 pop ax
 pop dx
end;
Inport:=smallint(Bytevalue) and $00FF;   // Maske, da nur ein Byte gelesen wird
end;




procedure TVFD.WriteCommand(c: byte);
begin
     // setze C/D auf 1 für "C"
     outport(BA+2,(CnD+nRD) XOR Maske);
     outport(BA+2,(CnD+nRD) XOR Maske);
     // lege Kommandobyte an Datenleitungen
     outport(Ba,c);
     outport(Ba,c);
     // setze /WR auf 1
     outport(BA+2,(CnD+nWR+nRD) XOR Maske);
     outport(BA+2,(CnD+nWR+nRD) XOR Maske);
     // /WR wieder rücksetzen
     outport(BA+2,(CnD+nRD) XOR Maske);
     outport(BA+2,(CnD+nRD) XOR Maske);
     // setze C/D wieder auf "D"
     outport(BA+2,(nRD+nWR) XOR Maske);
     outport(BA+2,(nRD+nWR) XOR Maske);
end;




procedure TVFD.WriteData(d: byte);
begin
     // setze C/D aud "D"
     outport(BA+2,(nRD+nWR) XOR Maske);
     outport(BA+2,(nRD+nWR) XOR Maske);
     // lege Datenbyte an Datenleitungen an
     outport(BA,d);
     outport(BA,d);
     // setze /WR
     outport(BA+2,(nWR+nRD) XOR Maske);
     outport(BA+2,(nWR+nRD) XOR Maske);
      // /WR wieder zurücksetzen
     outport(BA+2,(nRD) XOR Maske);
     outport(BA+2,(nRD) XOR Maske);
    // setze C/D wieder auf "C"
     outport(BA+2,(CnD+nRD+nWR) XOR Maske);
     outport(BA+2,(CnD+nRD+nWR) XOR Maske);
end;






procedure TVFD.InitVFD;       { Display initialisieren }
begin
     // setze Screen1-Startadresse
     WriteCommand(CMD_SCR1_lowADR);
     WriteData(SCR1_L);
     WriteCommand(CMD_SCR1_highADR);
     WriteData(SCR1_H);
     // setze Screen2-Startadresse
     WriteCommand(CMD_SCR2_lowADR);
     WriteData(SCR2_L);
     WriteCommand(CMD_SCR2_highADR);
     WriteData(SCR2_H);
     // setze Cursor in autohold-mode
     WriteCommand(CMD_CUR_HOLD);
end;




procedure TVFD.SetCursor(C_low,C_high: byte);       { Cursor setzen }
begin
   WriteCommand(CMD_CUR_lowADR);
   WriteData(C_low);
   WriteCommand(CMD_CUR_highADR);
   WriteData(C_high);
end;




procedure TVFD.ClearScreen(ScreenNr: byte);       { Screen mit "ScreenNr" löschen }
var
   i: integer;
begin
   // Berechne Startadresse
   if ScreenNr=1 then begin
    SetCursor(SCR1_L,SCR1_H);
   end
   else begin
    SetCursor(SCR2_L,SCR2_H);
   end;


   // setze Cursor in autoinc-mode
   WriteCommand(CMD_CUR_INC);


   // Schreibkommando
   WriteCommand(CMD_WRITE_DATA);


   //löschen
   if ScreenNr=1 then begin
     for i:=1 to (GRAPHICS_SCREEN_WIDTH*GRAPHICS_SCREEN_HEIGHT) do
      begin
       WriteData(0);
      end;
    end
    else begin
     for i:=1 to (TEXT_SCREEN_WIDTH*TEXT_SCREEN_HEIGHT) do
      begin
       WriteData(0);
      end;
   end;
   // setze Cursor in autohold-mode
   WriteCommand(CMD_CUR_HOLD);
end;




procedure TVFD.PaintString(s: string; col,row: byte);       { String an Pos col,row auf Char-Display ausgeben }
var
   a,b: byte;                    // bilden Adresse für Cursorposition (a=CUR_low, b=CUR_high)
   position: word;               // Adresse als Word
   c: char;                      // Char
   i: integer;                   // for-Variable
begin
     // Überprüfen ob Parameter sinnvoll sind
     if col>(TEXT_SCREEN_WIDTH-1) then col:=(TEXT_SCREEN_WIDTH-1);
     if row>(TEXT_SCREEN_HEIGHT-1) then row:=(TEXT_SCREEN_HEIGHT-1);


     // Adresse berechnen
     position:=SCR2_L+(SCR2_H*$100);                    // Adresse des SCR2 als Offset...
     position:=position+ (row*TEXT_SCREEN_WIDTH)+col;   // ... + Position auf dem Display


     // ermittle CUR_low und CUR_high aus position
     a:=trunc(position mod $100);
     b:=trunc(position / $100);


     // setze Cursor in autoinc-mode
     WriteCommand(CMD_CUR_INC);


     // setze Cursor auf position
     SetCursor(a,b);


     // Schreibkommando
     WriteCommand(CMD_WRITE_DATA);


     // For-Schleife für Zeichenweise Ausgabe des Strings
     for i:= 1 to length(s) do begin
      // kopiere Char aus String s
      c:=s[i];
      // c auf Display ausgeben
      WriteData(ord(c));
     end;
     // setze Cursor in autohold-mode
     WriteCommand(CMD_CUR_HOLD);
end;




procedure TVFD.SetPixelbyte(PixelByte,x,y: byte);       { Pixelbyte auf Display an x,y malen }
var
   a,b: byte;                    // bilden Adresse für Cursorposition (a=CUR_low, b=CUR_high)
   position: word;               // Adresse als Word
begin
     // Überprüfen ob Parameter sinnvoll sind
     if x>(GRAPHICS_SCREEN_WIDTH-1) then x:=(GRAPHICS_SCREEN_WIDTH-1);
     if y>(GRAPHICS_SCREEN_HEIGHT-1) then y:=(GRAPHICS_SCREEN_HEIGHT-1);


     // Adresse berechnen
     position:=SCR1_L+(SCR1_H*$100);                    // Adresse des SCR1 als Offset...
     position:=position+ (x*8)+y;                       // ... + Position auf dem Display


     // ermittle CUR_low und CUR_high aus position
     a:=trunc(position mod $100);
     b:=trunc(position / $100);


     // setze Cursor auf position
     SetCursor(a,b);


     // Schreibkommando
     WriteCommand(CMD_WRITE_DATA);


     // sende Pixelbyte
     WriteData(PixelByte);


     // setze Cursor in autohold-mode
     WriteCommand(CMD_CUR_HOLD);
end;


procedure TVFD.SelectScreen(Screen: byte);       { Aktiven Bildschirm wählen (3=beide) }
begin
   if (Screen<=3)and (Screen>=0) then WriteCommand(Screen);
   ActiveScreen:=screen;
end;


















procedure TVFD.PaintBitmap(c: TColor);       { GFX_Image auf Display malen }
var
   x,y,i: word;                    // Zählervariablen
   pixbyte: byte;                  // Pixelbyte
begin
     // setze Cursor in autoinc-mode
     WriteCommand(CMD_CUR_INC);


     // setze Cursor auf SCR1-Adresse
     SetCursor(SCR1_L,SCR1_H);


     // Schreibkommando
     WriteCommand(CMD_WRITE_DATA);


     // Ausgabe
     for x:=0 to 256 do begin
     for y:=0 to 7 do begin


       // reset pixbyte
       pixbyte:=0;
       //pixbyte erstellen
       for i:=0 to 7 do begin
        if GFX_Image.Pixels[x,(y*8)+7-i]=c then pixbyte:=pixbyte+ trunc(Power(2,i));
       end;
       WriteData(pixbyte);


     end;
     end;


     // setze Cursor in autohold-mode
     WriteCommand(CMD_CUR_HOLD);
end;




procedure TVFD.Bitmap2Screen(pic: TPicture;x,y: byte;Transp: boolean);       { Picture in GFX_Image laden und auf Display ausgeben }
var
  Bitmap : TBitmap;
begin
  // Bitmap erzeugen
  Bitmap := TBitmap.Create;
  try
    with Bitmap do begin
      Assign(pic.Bitmap);
      if Transp = true then Transparent := True
      else Transparent:= false;
      TransParentColor := clWhite;
      GFX_Image.Draw(x,y,Bitmap);
    end;
  finally
    Bitmap.Free;  // Bitmap freigeben
  end;
  // Display aktualisieren
  PaintBitmap(clBlack);
end;




procedure TVFD.PaintBitmapRect(Source: TCanvas;xpos,ypos,width,xOffset: byte; Farbe: TColor);       { Zeichenfläche auf Display an Pos x,y mit Breite width ausgeben }
var
   x,y,i: word;                    // Zählervariablen
   pixbyte: byte;                  // Pixelbyte
begin
     // überprüfe ob Breiteangabe korrekt
     //if width>bmp.Width then width:=bmp.Width;


     // Schreibkommando
     WriteCommand(CMD_WRITE_DATA);


     // Ausgabe
     for x:=0 to width do begin
     for y:=0 to 7-ypos do begin


       // reset pixbyte
       pixbyte:=0;
       //pixbyte erstellen
       for i:=0 to 7 do begin
        if Source.Pixels[x+xOffset,(y*8)+7-i]=Farbe then pixbyte:=pixbyte+ trunc(Power(2,i));
       end;
       SetPixelByte(pixbyte,x+xpos,y+ypos);


     end;
     end;


     // setze Cursor in autohold-mode
     WriteCommand(CMD_CUR_HOLD);


end;
























constructor TVFD.Create (AOwner: TComponent);
begin
     inherited Create (AOwner);
      BA:=$378;                 // Default-Wert beim Laden
      ActiveScreen:=0;
end;


procedure Register;
begin
  RegisterComponents('Hardware', [TVFD]);
end;


end.