Mehrere Geräte von gleichem Typ steuern

[Maxim B. (max182)]

Guten Tag!
Ich bin wieder mit meinen (vielleicht dummen) Fragen...

Die Aufgabe:
es gibt zwei oder drei LCD, die alle mit HD44780 kompatibel sind. Nur 
sind sie alle unterschiedlich angeschlossen (aber immer in 4-bit-Mode): 
an verschiedene Pins von Controller oder über SN74HC595 oder über 
MCP23S17 usw.
Offensichtlich sind so gut wie alle Unterschiede zwischen LCD nur in der 
Weise, wie 4 bit zusammen mit RS und EN ausgegeben werden, und evtl. 
könnten sich auch Zeichen-pro-Zeile-Zahl und Zeilenadresse 
unterscheiden.

Was ist besser:
1. für jeden LCD einzeln *.c+*.h - Paar mit allen Funktionen zu 
schreiben?
2. in ihren eigenen *.c+*.h nur Zeichen-pro-Zeile, Zeilenadressen und 
out_4bit() - Funktion angeben und alles andere in File lcd.c + lcd.h 
unabhängig von Anschluss machen?

Wenn P.2: wie ist dann besser zwischen LCD umschalten? Mit Zeiger auf 
out_4bit()- Funktion? Oder über globale Variable? Oder eine zusätzliche 
Variable immer an Funktion für LCD-Steuerung übergeben? Oder anders?

Wenn man nur Basisfunktionen verwendet (Zeichen und Zeile ausgeben), 
dann macht P.1 vielleicht nicht so großen Aufwand. Wenn aber andere 
Möglichkeiten kommen, dann häufen sich Funktionen...

Vielen Dank für eure Tipps im voraus!

[Karl M. (Gast)]

Hallo,

ich sag mal so, wenn alle LCD unterschiedliche Inhalte tragen, dann 
kann man auch die Implementierung n-fach anlegen.

Oder einfach eine Trennung zwischen Hardware-Level und User-Level 
anstreben.
Die Auswahl der Hardware könnte über eine DISPLAY-ID: 0 1st LCD usw. 
erfolgen.

Der GCC optimiert, wenn man will, da wird dann unbenutzter Code 
entfernt.

[Cyblord -. (cyblord)]

Man schreibt einmal eine lib für ein HD44780.

Deren Funktionen gibt man immer ein struct mit dem Context für jedes 
physikalische Display mit. Darin werden von der lib evt. States für 
jedes Display gehalten und darin teilt man der lib auch mit, wie und wo 
das Display angeschlossen ist. Also ob 4- Bit oder 8-Bit Mode und welche 
Pins und Ports.

Die Nutzung sähe dann so aus (ohne Initalisierung des Structs mit den 
Pins und Ports):

DISPLAY_t lcd1;
DISPLAY_t lcd2;

lcd_write("Hallo",&lcd1);
lcd_write("Blubb",&lcd2);

[Maxim B. (max182)]

Vielen Dank!
Ich versuche es mit Lib.

[Maxim B. (max182)]

Das funktioniert!!!

Ich habe zuerst für mich einfacher gemacht. init, lcd_data und 
lcd_command ließ ich nicht auseinander. Aber größere Funktionen sind für 
alle LCD dann gemeinsam. Später kann ich das umarbeiten, Hauptsache 
Prinzip habe ich verstanden.

Nun aber logische Frage: da Structur für einzelne LCD während der Arbeit 
konstant bleibt, wäre es besser, sie vollständig in Flash zu speichern. 
Wie macht man das? Wie kann man Structurinit ersparen? Eine 
Flash-Tabelle mit Zeiger in union zusammen? Einfach const __flash vor 
"display_t dip203g;" zu schreiben reicht leider nicht.

// lcd.h
typedef void (*TPF)(void);
typedef void (*TPFu8)(u8 data);

typedef struct 
{
    TPF lcdinit;
  TPFu8 lcdcommand;
  TPFu8 lcddata;
    u8 zeilenadr[4];
} display_t; 

// lcd.c
void lcd_init( display_t *lcd )
{
  (lcd->lcdinit)();
}

void lcd_command( uint8_t data,  display_t *lcd){
  (lcd->lcdcommand)(data);
  _delay_us(LCD_COMMAND_US );
}

void lcd_data( uint8_t data,  display_t *lcd){
  (lcd->lcddata)(data);
  _delay_us( LCD_WRITEDATA_US );
}

// * * *

void lcd_string_P( PGM_P data, display_t *lcd ){
    uint8_t tmp;

    tmp=pgm_read_byte(data);
    while( tmp != '\0' ) {        
    (lcd->lcddata)(tmp);
    _delay_us( LCD_WRITEDATA_US );
        data++;
        tmp = pgm_read_byte(data);
    }
}

// lcd_dip203g.h
#define LCD_ZEICHEN_PRO_ZEILE  20 
#define LCD_DDADR_LINE1         0x00
#define LCD_DDADR_LINE2         (LCD_DDADR_LINE1 + LCD_ZEICHEN_PRO_ZEILE)
#define LCD_DDADR_LINE3         0x40
#define LCD_DDADR_LINE4         (LCD_DDADR_LINE3 + LCD_ZEICHEN_PRO_ZEILE) 

#define BIT_RS  0
#define BIT_E  1

extern display_t dip203g;
static inline void lcd_dip203g_out( u8 data, u8 rs ) 
{ 
  u8 a;
  lcd_adrmode();

  a = (data & 0xf0);
  if(rs) a |= (1<<BIT_RS);


  spi_master_transmit(a);
  spi_intern_start();
  asm volatile("lpm");
  spi_intern_stop();
  asm volatile("lpm");

  spi_master_transmit(a | (1<<BIT_E));
  spi_intern_start();
  asm volatile("lpm");
  spi_intern_stop();
  asm volatile("lpm");

  spi_master_transmit(a);
  spi_intern_start();
  asm volatile("lpm");
  spi_intern_stop();
  asm volatile("lpm");
}

// lcd_dip203g.c
display_t dip203g;

void lcd_dip203g_structinit(void){
  dip203g.lcdinit = lcd_dip203g_init;
  dip203g.lcdcommand = lcd_dip203g_command;
  dip203g.lcddata = lcd_dip203g_data;
  dip203g.zeilenadr[0] = LCD_DDADR_LINE1;
  dip203g.zeilenadr[1] = LCD_DDADR_LINE2;
  dip203g.zeilenadr[2] = LCD_DDADR_LINE3;
  dip203g.zeilenadr[3] = LCD_DDADR_LINE4;
}

void lcd_dip203g_init(void){
    _delay_ms( LCD_BOOTUP_MS );

    lcd_dip203g_out( LCD_SOFT_RESET,0 );  // 0x30

    _delay_ms( LCD_SOFT_RESET_MS1 );  // 5 ms

  lcd_dip203g_out( LCD_SOFT_RESET,0 );  // 0x30

    _delay_ms( LCD_SOFT_RESET_MS2 );  // 1 ms

  lcd_dip203g_out( LCD_SOFT_RESET,0 );  // 0x30

// * * *
}

void lcd_dip203g_command(u8 data){
  lcd_dip203g_out( data,0 ); 
    lcd_dip203g_out( data<<4,0);  
}

void lcd_dip203g_data(u8 data){
  lcd_dip203g_out( data,1);  
    lcd_dip203g_out( data<<4,1); 
}