dbox1-display

[Michael W. (mwulz)]

hallo Community,

hat jemand von euch Erfahrung mit dem DBOX1-Display von Siemens ==> 
SDA-5708-24

Ich hab mal schon gegoogled, und folgendes gefunden: 
http://www.grautier.com/grautier/index.php

Mir scheint das Bus-Diagramm des Displays sehr ähnlich dem I2C Bus. Kann 
es sein, dass sich dieses Display auch mit I2C Controllern ansteuern 
liese?

DATA und CLOCK könnte man vom I2C Bus nehmen, und die -LOAD- dann halt 
über einen dritten Pin mitgeben?

danke im Voraus
Michael

[Jörg S. (joerg-s)]

>Mir scheint das Bus-Diagramm des Displays sehr ähnlich dem I2C Bus.
Das war eher SPI. Schau dir mal die alten OSRAM "Intelligent Displays" 
an (z.B. SCD5583A). Sind quasi identisch.
Ansonsten steht ja auch schon alles in dem Beitrag den du gelinkt hast.

[Michael W. (mwulz)]

Hallo,

danke für den Tip!

Ich hab nun einen Treiber gebastelt.
Soweit ich das ganze im Datasheet verstanden habe, ist es jetzt in dem 
Treiber eingepflegt.
Verwendet wird der Port-D am PIC18F4550.

Compiler verwende ich den CCS.

Ich komme einfach nicht klar mit der Ausgabe der Zeichen.
Testweise hab ich in den Code unten das 1te Zeichen und hier
aus dem Datenblatt den Buchstaben "A" als array "char_A" definiert.
Diesen versuche ich auszugeben.

Hier der Code:

struct lcd_pin_map {
    BOOLEAN bit7;
    BOOLEAN bit6;
    BOOLEAN bit5;
    BOOLEAN bit4;
    BOOLEAN bit3;
    BOOLEAN bit2;
    BOOLEAN bit1;
    BOOLEAN bit0;
};

char char_A[4] = {0x04,0x2A,0x5F,0x71,0x91};
int timeval = 1;

#define lcd_reset   PIN_D3
#define lcd_clk    PIN_D2
#define lcd_data  PIN_D1
#define lcd_load  PIN_D0

struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0,0,0,0}; // Set all PINs to output mode
struct lcd_pin_map const LCD_CLEAR = {0,0,0,0,0,0,1,1};
struct lcd_pin_map const LCD_CONFIG = {0,0,0,0,1,1,1,1};

void lcd_send_byte ( BYTE n ) {
  byte i;
  boolean value;

  //Enable data load
  output_low(lcd_clk);
  delay_us(timeval);
  output_low(lcd_load);
  delay_us(timeval);

  for(i=0;i<=7;i++) {
    //test bit of config array
    value = bit_test(n,i);
    output_bit(lcd_data,value);

    //Clock short time high
    output_high(lcd_clk);
    delay_us(timeval);
    output_low(lcd_clk);
    delay_us(timeval);
  }

  //disable data load
  output_high(lcd_load);
  delay_us(timeval);
}

void lcd_init() {
  set_tris_D(LCD_WRITE);
  delay_us(timeval);

  //Initial Reset
  output_high(lcd_load);
  output_high(lcd_reset);
  output_low(lcd_clk);
  delay_us(timeval);
  output_low(lcd_reset);
  delay_us(timeval);
  output_low(lcd_load);
  delay_us(timeval);
  
  //Display clear
  lcd_send_byte(LCD_CLEAR);
  
  //Display Configuration
  lcd_send_byte(LCD_CONFIG);
  
  //Display should be successfully initialized
}

void lcd_putc() {
  byte i;

  lcd_send_byte(0xb0); // Hier testweise das 1te Zeichen am Display.

  delay_us(timeval);

  for(i=0;i<=4;i++) {
    lcd_send_byte(char_a[i]); // Hier wird das Zeichen A ausgegeben
    delay_us(timeval);
  }

}

Ausgeführt wird dann:

lcd_init();

lcd_putc();

Das Display bleibt komplett dunkel.
Ich such schon die ganze Zeit nach Fehlern kann aber nix finden.
Hat einer von euch einen solchen Treiber schonmal programmiert?

[K. J. (Gast)]

Vileicht hilft dir ja folgendes weiter.

Bin selber gerade wieder bei ist schon nen augenblick her das ich des 
das letzte mal laufen hatte

  ;list p=16f627a
  include "p16f627a.inc"

  __CONFIG _WDT_OFF & _PWRTE_OFF & _INTOSC_OSC_NOCLKOUT & _MCLRE_OFF & _BOREN_OFF & _LVP_OFF & _DATA_CP_OFF & _CP_OFF

  org    0x00
  goto   main
  org    0x04

  cblock  0x20
  vfdsend
  count
  count1
  endc 

  #define  vfdload    PORTB,0
  #define  vfddata    PORTB,1
  #define  vfdsdclk    PORTB,2
  #define  vfdrst    PORTB,3
  #define  vfdinit    B'11100000'  ;Config Register: 11= Control REG, 1=Normal OP, 0=NA, 0=PEAK, 000= Brighness 100%
  #define  vfdcls    B'11000000'
  #define  vfddigit1     B'10100000'
  #define  vfddigit2     B'10100001'
  #define  vfddigit3     B'10100010'
  #define  vfddigit4     B'10100011'
  #define  vfddigit5     B'10100100'
  #define  vfddigit6     B'10100101'
  #define  vfddigit7     B'10100110'
  #define  vfddigit8     B'10100111'
  
main
  ; Von Analog auf Digital Schalten
  BSF CMCON, CM0
  BSF CMCON, CM1
  BSF CMCON, CM2 
  ; PORTA
  bsf    STATUS, RP0  ; auf Bank 1 umschalten
  movlw  B'00000000'  ; PortB I/O setzen (1=In, 0=Out) (Reinfolge RA7,RA6...)
  movwf  TRISA    ; PortB I/O setzen
  bcf    STATUS, RP0  ; auf Bank 0 schalten
  clrf    PORTA    ; PortB auf 0 setzen
  ; PORTB
  bsf    STATUS, RP0  ; auf Bank 1 umschalten
  movlw  B'00000000'  ; PortC I/O setzen (1=In, 0=Out) (Reinfolge RB7,RB6...)
  movwf  TRISB    ; PortC I/O setzen
  bcf    STATUS, RP0  ; auf Bank 0 schalten
  clrf    PORTB    ; PortB auf 0 setzen
init
  bsf    vfdrst    ; vfdrst auf high
  bsf    vfdload
  movf    vfdinit, w    ; Display Inialisieren
  movwf  vfdsend
  call    vfddatasend
loop
  movlw  B'10100001'  ;Digit 0
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00011111'  ;ROW 0
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00001110'  ;ROW 1
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00000100'  ;ROW 2
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00000100'  ;ROW 3
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00000100'  ;ROW 4
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00001110'  ;ROW 5
  movwf  vfdsend
  call    vfddatasend
  movlw  B'00011111'  ;ROW 6
  movwf  vfdsend
  call    vfddatasend
  goto    loop
vfddatasend
  bcf     vfdsdclk
  call     delay_200_ns
  bcf     vfdload
  call     delay_200_ns
  btfsc   vfdsend,0
  bsf     vfddata
  btfss   vfdsend,0
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,1
  bsf     vfddata
  btfss   vfdsend,1
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,2
  bsf     vfddata
  btfss   vfdsend,2
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,3
  bsf    vfddata
  btfss   vfdsend,3
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,4
  bsf     vfddata
  btfss     vfdsend,4
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,5
  bsf     vfddata
  btfss   vfdsend,5
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,6
  bsf     vfddata
  btfss   vfdsend,6
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  btfsc   vfdsend,7
  bsf     vfddata
  btfss   vfdsend,7
  bcf     vfddata
  bsf     vfdsdclk
  call     delay_200_ns
  bcf     vfdsdclk
  call     delay_200_ns
  bsf     vfdload
  bsf     vfdsdclk
  return
delay_200_ns
  movlw  D'5'
  movwf  count1
delay_200_ns_loop
  decfsz  count1,1
  goto    delay_200_ns_loop
  return
end

[Michael W. (mwulz)]

Hallo,

Danke für einen Post!
Hat mir geholfen, ich hatte einen Fehler im Code, hab mit deiner Hilfe 
diesen jetzt zum laufen gebracht ;-)

Weisst du wie ich nun normale ASCII Zeichen so umwandeln kann, dass ich 
damit das Display füttere ohne, dass ich jedes Zeichen extra mit einem 
#define anlegen muss??

danke
Michael

[K. J. (Gast)]

Hm im c gab es glaube ich auch Tabellen in asm würde ich des mit der 
Tabelle im Flash machen und den dementsprechend die  7 x 8bit daraus 
auslesen.

table
  banksel  PCLATH
        clrf    PCLATH
  banksel  PCL
        addwf  PCL, 1
;A
  retlw  B'00001110'          ; 0
  retlw  B'00010001'          ; 1
  retlw  B'00010001'          ; 2
  retlw  B'00011111'          ; 3
  retlw  B'00010001'          ; 4
  retlw  B'00010001'          ; 5
  retlw  B'00010001'          ; 6
;B
  retlw  B'00011110'          ; 0
  retlw  B'00010001'          ; 1
  retlw  B'00010001'          ; 2
  retlw  B'00011110'          ; 3
  retlw  B'00010001'          ; 4
  retlw  B'00010001'          ; 5
  retlw  B'00011110'          ; 6
................
  return

[Michael W. (mwulz)]

Hallo,
danke!

hab's mit Tabellen in C gelöst!
Ich hab nur etwas bemerkt, wenn ich nun Text anzeigen lasse, ist dieser 
immer unterschiedlich hell. Die ersten 4 Spalten sind heller als die 
letzten 4 Spalten.

Wenn ich dann mehrmals Strom-Weg, Strom-Dazu und das Display neu mit 
Daten beschreibe, sind oft die letzen 4 Stellen ganz hell, die ersten 4 
garnicht zu sehen, usw...

Hast du das auch bemerkt?

gruss
M

[K. J. (Gast)]

Hi ja des hab ich hier auch  bin mir noch nicht sicher woran des liegt 
versuch mal nach jedem Zeichen die int neu zu setzen man kann je eh 
jedes zeichen in der heligkeit regeln.

[Michael W. (mwulz)]

Hallo,

ich hab einfach am Anfang zweimal die initialisierungs-Routine 
ausgeführt, jetzt ist es schön hell ;-)

danke jedenfalls
M

[Michael W. (mwulz)]

Wisst Ihr wie ich einen String, zum Beispiel "asdf" so zerteilen kann,
dass ich einzelne Zeichen daraus bekomme und dementsprechend für jedes
zeichen eine Variable ausgeben kann.

ich habe die Tabellen so angelegt:

char char_a[7] = {  0b00001110,
          0b00010001,
          0b00010001,
          0b00011111,
          0b00010001,
          0b00010001,
          0b00010001};

char char_b[7] = {  0b00011110,
          0b00010001,
          0b00010001,
          0b00011110,
          0b00010001,
          0b00010001,
          0b00011110};

char char_c[7] = {  0b00001111,
          0b00010000,
          0b00010000,
          0b00010000,
          0b00010000,
          0b00010000,
          0b00001111};
// und so weiter bis Z

Wie kann ich nun prüfen welche Zeichen der String enthält (Zeichen für 
Zeichen) und dann aus diesen Tabellen ausgeben??

danke
M

[Frank O. (nucleus)]

Hallo Michael,
ich bin heute auf Deinen Beitrag ueber das SDA5708 gestossen und habe 
versucht Deinen C-Code auf den Arduino zu portieren. Mein Problem ist, 
dass ich keine Anzeige bekomme. Das Display bleibt dunkel. Kannst Du mir 
bitte einen Tipp geben, was Du damals gemacht hast, um das Display zum 
Leben zu erwecken ?
Gruss Nucleus

[Uwe B. (boerge)]

MoinMoin,

hier findet man einen funktionierenden C-Code-Schnipsel für das Display:
http://bralug.de/wiki/Display_SDA5708

Grüße Uwe

[Frank O. (nucleus)]

Hallo Uwe,
vielen Dank fuer Deinen Hinweis. Ich werde - sofern ich dazu komme - 
heute Abend mir einmal den besagten Code ansehen. Eventuell finde ich ja 
das Problem auf Anhieb. Wenn Du Lust und Zeit hast, kannst Du mal in 
meinen umgefriemelten Code schauen (siehe Anfrage an Michael. Anlage 
test.pde)
Viele Gruesse
Frank (nucleus)

[Frank O. (nucleus)]

Hallo Uwe,
sorry, dass ich schon wieder nerve aber ich bekomme den Code einfach 
nicht zu Laufen. Ich habe mir Dein Template hergenommen und an den 
Arduino angepasst. Was mach ich falsch? Die Anzeige bleibt einfach 
schwarz. Ich hoffe, Du kannst mir weiterhelfen. (Den Quellcode habe ich 
beigelegt)
Viele Gruesse
Frank (nucleus)