DOGM Display an STM32

[Al. Liebl (Gast)]

Hallo,

gibt es für den STM32 eine fertige Bibliothek zur Ansteuerung der EA 
DOGM Displays?

Wenn nicht, wie schwer ist die Ansteuerung?

Hintergrund: Bei einem Schulprojekt wäre das Display nur eine nette 
kleine Erweiterung. Wir können uns deshalb nicht allzu lange damit 
beschäftigen.

Schon mal ein herzliches Dankeschön für alle Antworten.


Alexander

[Zero V. (Firma: Freelancer) (gnd)]

Was ist das denn für ein Schulprojekt, das umfangreichste was ich je 
gemacht habe ist der Pendelversuch in Physik (mehr war leider nicht 
drin, aber er wurde dafür alle 2 Jahre wiederholt :-) ) !

[Al. Liebl (Gast)]

Wahlfach "Elektronik". Man ist in der Gestaltung des Projekts relativ 
frei und hat 6 Monate Zeit.

[Zeichnungen und Screenshots (Gast)]

google: "DOGM Display an STM32"

[Gerhard G. (g_g)]

Hallo,


Zeichnungen und Screenshots schrieb:
> DOGM Display an STM32

ist vermutlich eine Nummer zu groß:

http://www.basteln-mit-avr.de/LPCXpresso_1769.html#stm32f4


Gruß G.G.

[Al. Liebl (Gast)]

Vielen Dank.

Ist zwar für einen Cortex M4 aber eventuell kann man den Code anpassen. 
Das ist auf jeden Fall mal ein Ansatz :)

[Al. Liebl (Gast)]

Könnte mal jemand einen kurzen Blick riskieren ob das so ok ist?

[Matthias K. (matthiask)]

Die Pin- und Unitkonfiguration bekommt Ihr doch selber hin;

//***********************************************************************************************
// Programm:        LCD Funktionen (DOG-M, SPI, 3.3V)
// Mikrocontroller: STM32F103RE (ARM 32-bit CORTEX-M3)
// Speicher:        512KB FLASH, 64KB SRAM
// Taktfrequenz:    8MHz, PLL: 72MHz
// Stand:           08.04.2011
// IDE/Compiler:    Atollic TrueStudio STM32-Lite 2.0.1
// STM FW-Lib:      3.4.0
//***********************************************************************************************

// Includes
#include <stddef.h>
#include "stm32f10x.h"
#include <string.h>

#include "defines.h"
#include "main.h"

// ***********************************************************************
// SPI Initialisierung
// ***********************************************************************
void init_spi_lcd (void) {
  SPI_InitTypeDef  SPI_InitStructure;                                   // SPI Struktur

  SPI_I2S_DeInit(SPI1);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,  ENABLE);                 // SPI1 Takt freigeben

  // SPI1 Konfiguration
  SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;             // Nur senden
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                         // SPI Master-Mode
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                     // 8 Datenbits
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                           // CPOL High=Ruhezustand
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                          // CPHA 2. Flanke (L/H) gibt Daten aus
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                             // CS Chipselect per Software
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;   // Taktfrequenz 72MHz/32 = 2,2 MHz
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                    // MSB (höherwertiges Bit) zuerst senden
  SPI_InitStructure.SPI_CRCPolynomial = 7;                              // CRC (?)
  SPI_Init(SPI1, &SPI_InitStructure);                                   // SPI initialisieren
  SPI_Cmd(SPI1, ENABLE);                                                // SPI freigeben
}

// ***********************************************************************
// Senden eines Bytes per SPI-Interface
// Übergabe: byte : Datenbyte
// ***********************************************************************
void sendbyte_spi_lcd (unsigned char byte) {
  SPI_I2S_SendData(SPI1, byte);                                     // Byte per SPI senden
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);     // Warten bis Byte vollständig gesendet ist
}

// ***********************************************************************
// Schreiben eines Zeichens an das LCD-Modul
// Übergabe: lcd_byte : Auszugebendes Zeichen/Steuerzeichen
//           lcd_mode : 0 - Daten
//                      1 - Steuerzeichen
// ***********************************************************************
void write_lcd (unsigned char lcd_byte, unsigned char lcd_mode) {
// Zeitangaben für 72 MHz und 2 Waitstates
  delay_us(200);                // Pause mind. 15us bevor nächstes Zeichen gesendet werden darf
  GPIO_ResetBits(LCD_CSB);      // LCD_CSB = 0;
  if (lcd_mode) GPIO_ResetBits(LCD_RS); // LCD_RS = 0 Steuerzeichen
    else GPIO_SetBits(LCD_RS);          // LCD_RS = 1 Daten
  // Byte senden seriell senden (D7 D6 D5 D4 D3 D2 D1 D0)
  sendbyte_spi_lcd(lcd_byte);
  delay_us(10);                 // Pause (ca. 1us)
  GPIO_SetBits(LCD_CSB);        // LCD_CSB = 1  
} 

// ***********************************************************************
// Löschen des LCD-Display
// ***********************************************************************
void clear_lcd (void) {
  write_lcd(0x01,1);            // Diplay löschen
  lcd.x = lcd.y = 0;            // Position für Scrollfunktion auf Anfang setzen
  delay(50);                    // Pause
}

// ***********************************************************************
// Ausgabe eines ASCII-Zeichen positioniert auf dem LCD-Modul
// Übergabe: lcd_x : Spalte (0...SPALTEN_MAX-1)
//           lcd_y : Zeile  (0...ZEILEN_MAX-1)
//           lcd_ascii : ASCII-Zeichen
// *********************************************************************** 
void write_byte_lcd (unsigned char lcd_x, unsigned char lcd_y, unsigned char lcd_ascii) {
unsigned char lcd_offset = 0;
  if (lcd_x > (SPALTEN_MAX - 1)) lcd_x = 0;
  if (lcd_y > (ZEILEN_MAX  - 1)) lcd_y = 0;
  switch (lcd_y) {
    case 0:  lcd_offset = 0x80; break;  // Zeile 1
    case 1:  lcd_offset = 0xC0; break;  // Zeile 2 
    default: lcd_offset = 0x80;
  };
  write_lcd(lcd_x+lcd_offset,1);        // Kursorposition setzen
  write_lcd(lcd_ascii,0);               // Ausgabe des ASCII-Zeichen an der Kursorposition
}

// ***********************************************************************
// Ausgabe einer Zeichenkette positioniert auf dem LCD-Modul
// Zeichenkette muss im SRAM liegen
// Übergabe: lcd_x : Spalte (0...SPALTEN_MAX-1)
//           lcd_y : Zeile  (0...ZEILEN_MAX-1)
//           lcd_zeichen : Adresse der auszugebenden format.  Zeichenkette
//           clr_line    : Löschen bis Zeilenende
//                         1 - Löschen
//                         0 - kein Löschen
// ***********************************************************************
void printf_lcd (unsigned char lcd_x, unsigned char lcd_y, char *lcd_zeichen, unsigned char clr_line) {
unsigned char lcd_i;
unsigned char lcd_offset = 0;
  if (lcd_x > (SPALTEN_MAX - 1)) lcd_x = 0;
  if (lcd_y > (ZEILEN_MAX  - 1)) lcd_y = 0;
  switch (lcd_y) {
    case 0:  lcd_offset = 0x80; break;  // Zeile 1
    case 1:  lcd_offset = 0xC0; break;  // Zeile 2 
    default: lcd_offset = 0x80;
  }
  write_lcd(lcd_x+lcd_offset,1);        // Kursorposition setzen
  // Ausgabe der Zeichenkette ab der Kursorposition
  lcd_offset = strlen(lcd_zeichen);     // Länge der Zeichenkette
  if (lcd_offset > SPALTEN_MAX) lcd_offset = SPALTEN_MAX;
  for(lcd_i = lcd_offset ; lcd_i ; lcd_i--) {
    write_lcd(*lcd_zeichen,0);
    lcd_zeichen++;
  }
  if (clr_line) {
    // Löschen bis Zeilenende
    for(lcd_i = SPALTEN_MAX - lcd_offset - lcd_x ; lcd_i ; lcd_i--) write_lcd(' ',0);
  }
}

// ***********************************************************************
// Blinkposition auf dem LCD-Displays setzen / Blinken ein/ausschalten
// Übergabe: lcd_x : Spalte (0...SPALTEN_MAX-1)
//           lcd_y : Zeile  (0...ZEILEN_MAX-1)
//           lcd_blink :   0 - Blinken/Cursor aus
//                         1 - Blinken an
//                         2 - Cursor  an
// ***********************************************************************
void blink_lcd (unsigned char lcd_x, unsigned char lcd_y, unsigned char lcd_blink) {
unsigned char lcd_offset;
  write_lcd(0x0C,1);                     // KURSOR ausschalten
  if (lcd_x > (SPALTEN_MAX - 1)) lcd_x = 0;
  if (lcd_y > (ZEILEN_MAX  - 1)) lcd_y = 0;
  switch (lcd_y) {
    case 0:  lcd_offset = 0x80; break;   // Zeile 1
    case 1:  lcd_offset = 0xC0; break;   // Zeile 2 
    default: lcd_offset = 0x80;
  };
  write_lcd(lcd_x+lcd_offset,1);         // Blinkposition setzen
  if (lcd_blink == 1) write_lcd(0x0D,1); // Blinken ein
  if (lcd_blink == 2) write_lcd(0x0E,1); // Cursor ein
}

// ***********************************************************************
// Definieren eines Sonderzeichen
// Übergabe: lcd_addr : Adresse
//           lcd_zeichen: Zeiger auf das 1. Byte der Zeichendefinition
// ***********************************************************************
void write_lcd_cg (unsigned char lcd_addr, char *lcd_zeichen) {
unsigned char lcd_i;
  for(lcd_i = 0; lcd_i < 8; lcd_i++) {
    write_lcd(0x40 + lcd_addr * 8 + lcd_i,1);   // CG RAM Adresse Set (01aa azzz)
    write_lcd(*lcd_zeichen,0);                  // Data Write 8x Pixelzeile
    lcd_zeichen++;
  }
} 

// ***********************************************************************
// Definieren von 8 Sonderzeichen
// Übergabe:  lcd_zeichen: Zeiger auf das Zeichenfeld (8x8 Byte)
// ***********************************************************************
void write_lcd_cg_block (char *sonderzeichenblock) {
unsigned char lcd_i;
  for(lcd_i = 0; lcd_i < 8; lcd_i++) {
    write_lcd_cg(lcd_i, &sonderzeichenblock[lcd_i * 8]);
  }
} 

// ***********************************************************************
// Grundinitialisierung des LCD-Moduls
// LCD wird wie im 8-Bit parallel-Mode initialisiert!
// ***********************************************************************
void init_lcd (void) {
  // init_spi_lcd();           // Hardware SPI Initialisierung

  GPIO_SetBits(LCD_CSB);    // LCD_CSB = 1  
  // GPIO_SetBits(LCD_SCK);    // LCD_SCK = 1
  delay(500);               // Wartezeit nach POWER-ON bis VCC stabil ist
  // Grundinitialisierung (SPI, wie im 8-Bit Parallel-Mode)
  write_lcd(0x39,1);        // Function Set
  write_lcd(0x39,1);        // Function Set (gleiches Byte nochmal senden)
  write_lcd(0x14,1);        // Bias Set
  write_lcd(0x55,1);        // Power Control + Kontrast Set C5,C4
  write_lcd(0x6D,1);        // Follower Control
  write_lcd(0x78,1);        // Kontrast Set C3,C2,C1,C0
  write_lcd(0x0C,1);        // Display Set
  write_lcd(0x06,1);        // Entry Mode Set
  clear_lcd();              // Display löschen
}



.....
// Call

  init_spi_lcd();          // SPI-Interface für LCD konfigurieren
  init_lcd();              // LCD Initialisierung
  printf_lcd(0,0,"Test",1);

...

[Spess53 (Gast)]

Hi

>Könnte mal jemand einen kurzen Blick riskieren ob das so ok ist?

Um welches DOG-Display geht es eigentlich? Mit dem ST7565 gibt es zwei. 
Aber bei keinem sind P/S und alle CS-Signale am Display zugänglich.

MfG Spess

[Al. Liebl (Gast)]

@Matthias: Vielen herzlichen Dank, das hilft uns sicher sehr weiter! 
Darf ich noch fragen was in der defines.h steht?

@Spess53: Es ist ein DOGM128. Die Pinkonfig haben wir aus dem Datenblatt 
des Controllers, nicht des Displays. Kann gut sein, dass es da ein paar 
Unterschiede gibt.

Schönes Wochenende

Alex & Friends

[Matthias K. (matthiask)]

Al. Liebl schrieb:
> Es ist ein DOGM128

Die Information hätte in den ersten Beitrag gehört. Der Code ist für die 
DOGM Textdisplays.

[Navid M. (Firma: mori) (navidmo198)]

Ich habe das für Stm32f0 einbisschen genändert. Aber das funktioniert 
nicht.

#include "lcd.h"
#include "font_lcd.h"
#include "stm32f0xx.h"
#include "stm32f0xx_conf.h"
 
 
// ***********************************************************************
// Schreiben eines Zeichens an das LCD-Modul
// seriell Soft-SPI Mode, 3/4 Draht Interface
// ـbergabe: lcd_byte : Auszugebendes Zeichen/Steuerzeichen
//           lcd_mode : 0 - Daten
//                      1 - Steuerzeichen
// ***********************************************************************
void write_lcd(byte lcd_byte, byte lcd_mode)
{
  // Zeitangaben für 72 MHz und 2 Waitstates
  Delay(200);  // Pause mind. 15us bevor nächstes Zeichen gesendet werden darf
    //GPIO_ResetBits(LCD_CSB);      // LCD_CSB = 0;
    GPIO_ResetBits(GPIOA, GPIO_Pin_4);
    if (lcd_mode) GPIO_ResetBits(GPIOA, GPIO_Pin_8); // LCD_RS = 0 Steuerzeichen
      //else GPIO_SetBits(LCD_RS);          // LCD_RS = 1 Daten
    else GPIO_SetBits(GPIOA, GPIO_Pin_8);
    // Byte senden seriell senden (D7 D6 D5 D4 D3 D2 D1 D0)
    sendbyte_spi_lcd(lcd_byte);
    Delay(10);                 // Pause (ca. 1us)
    //GPIO_SetBits(LCD_CSB);        // LCD_CSB = 1
    GPIO_SetBits(GPIOA, GPIO_Pin_4);
}
 
// ***********************************************************************
// Lِschen des LCD-Display
// und Kursor auf Position 0,0 setzen
// ***********************************************************************
void clear_lcd(void)
{
  write_lcd(0x01,1);            // Diplay löschen
  //lcd_x = lcd_y = 0;            // Position für Scrollfunktion auf Anfang setzen
  Delay(50);                    // Pause
}
 
// ***********************************************************************
// Ausgabe eines ASCII-Zeichen positioniert auf dem LCD-Modul
// ـbergabe: lcd_x : Spalte (0...SPALTEN-1)
//           lcd_y : Zeile  (0...ZEILEN-1)
//           lcd_ascii : ASCII-Zeichen
// ***********************************************************************
void write_byte_lcd(byte lcd_x, byte lcd_y, byte lcd_ascii, byte invertiert)
{
  unsigned char lcd_offset = 0;
    if (lcd_x > (101 - 1)) lcd_x = 0;
    if (lcd_y > (31  - 1)) lcd_y = 0;
    switch (lcd_y) {
      case 0:  lcd_offset = 0x80; break;  // Zeile 1
      case 1:  lcd_offset = 0xC0; break;  // Zeile 2
      default: lcd_offset = 0x80;
    };
    write_lcd(lcd_x+lcd_offset,1);        // Kursorposition setzen
    write_lcd(lcd_ascii,0);               // Ausgabe des ASCII-Zeichen an der Kursorposition1
}
 
// ***********************************************************************
// Ausgabe einer Zeichenkette positioniert auf dem LCD-Modul
// ـbergabe: lcd_x : Spalte (0...SPALTEN-1)
//           lcd_y : Zeile  (0...ZEILEN-1)
//           lcd_zeichen : Adresse der auszugebenden format.  Zeichenkette
//           clr_line    : Lِschen bis Zeilenende
//                         1 - Lِschen
//                         0 - kein Lِschen
// ***********************************************************************
void printf_lcd(byte lcd_x, byte lcd_y, byte *lcd_zeichen, byte invertiert)
{
  unsigned char lcd_i;
  unsigned char lcd_offset = 0;
    if (lcd_x > (101 - 1)) lcd_x = 0;
    if (lcd_y > (31  - 1)) lcd_y = 0;
    switch (lcd_y) {
      case 0:  lcd_offset = 0x80; break;  // Zeile 1
      case 1:  lcd_offset = 0xC0; break;  // Zeile 2
      default: lcd_offset = 0x80;
    }
    write_lcd(lcd_x+lcd_offset,1);        // Kursorposition setzen
    // Ausgabe der Zeichenkette ab der Kursorposition
    lcd_offset = strlen(lcd_zeichen);     // Länge der Zeichenkette
    if (lcd_offset > 101) lcd_offset = 101;
    for(lcd_i = lcd_offset ; lcd_i ; lcd_i--) {
      write_lcd(*lcd_zeichen,0);
      lcd_zeichen++;
    }
    if (invertiert) {
      // Löschen bis Zeilenende
      for(lcd_i = 101 - lcd_offset - lcd_x ; lcd_i ; lcd_i--) write_lcd(' ',0);
    }
}
 
// ***********************************************************************
// Grundinitialisierung des LCD-Moduls in SPI-Mode (seriell)
// ***********************************************************************
void init_lcd(void)
{
 
    SPI_InitTypeDef  SPI_InitStructure;                                   // SPI Struktur
      SPI_I2S_DeInit(SPI1);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,  ENABLE);                 // SPI1 Takt freigeben
    SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;             // Nur senden
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                         // SPI Master-Mode
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                     // 8 Datenbits
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                           // CPOL High=Ruhezustand
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                          // CPHA 2. Flanke (L/H) gibt Daten aus
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                             // CS Chipselect per Software
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;   // Taktfrequenz 72MHz/32 = 2,2 MHz
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                    // MSB (höherwertiges Bit) zuerst senden
    SPI_InitStructure.SPI_CRCPolynomial = 7;                              // CRC (?)
    SPI_Init(SPI1, &SPI_InitStructure);                                   // SPI initialisieren
    SPI_Cmd(SPI1, ENABLE);
 
    GPIO_InitTypeDef LCS_CBS;
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
    LCS_CBS.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_8|GPIO_Pin_9; //pa4=cs/ pa8=rst/ pa9=cmd
    LCS_CBS.GPIO_Mode = GPIO_Mode_OUT;
    LCS_CBS.GPIO_OType = GPIO_OType_PP;
    LCS_CBS.GPIO_Speed = GPIO_Speed_50MHz;
    LCS_CBS.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(GPIOA, &LCS_CBS);
 
    GPIO_InitTypeDef INSTR;
    INSTR.GPIO_Pin= GPIO_Pin_5|GPIO_Pin_7;//pa5=clk/pa7=mosi
    INSTR.GPIO_Mode=GPIO_Mode_AF;
    INSTR.GPIO_OType = GPIO_OType_PP;
    INSTR.GPIO_Speed= GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &INSTR);
 
    // init_spi_lcd();           // Hardware SPI Initialisierung
     GPIO_ResetBits(GPIOA, GPIO_Pin_4);
     Delay(500);               // Wartezeit nach POWER-ON bis VCC stabil ist
     // Grundinitialisierung (SPI, wie im 8-Bit Parallel-Mode)
     write_lcd(0x39,1);        // Function Set
     write_lcd(0x39,1);        // Function Set (gleiches Byte nochmal senden)
     write_lcd(0x14,1);        // Bias Set
     write_lcd(0x55,1);        // Power Control + Kontrast Set C5,C4
     write_lcd(0x6D,1);        // Follower Control
     write_lcd(0x78,1);        // Kontrast Set C3,C2,C1,C0
     write_lcd(0x0C,1);        // Display Set
     write_lcd(0x06,1);        // Entry Mode Set
     clear_lcd();              // Display löschen
 
}
/*****************************************************************************/
void sendbyte_spi_lcd (unsigned char byte) {
  //SPI_I2S_SendData(SPI1, byte);                                     // Byte per SPI senden
  SPI_I2S_SendData16(SPI1, byte);
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET);     // Warten bis Byte vollständig gesendet ist
}
 
int main(int argc, char* argv[])
{
  config_pin();
  init_lcd();
 
  while (1)
  {
    printf_lcd(0,0,"Test",1);
    //write_byte_lcd(10, 10, 0x41,1);
    }
 
}

[Nop (Gast)]

Navid M. schrieb:
> Ich habe das für Stm32f0 einbisschen genändert. Aber das
> funktioniert nicht.

Mach einen neuen Thread dafür auf, und schrieb rein, was genau nicht 
funktioniert, wo Du schon mit dem Oszi nachgemessen hast, ob Du mit den 
IOs an sich wackeln kannst, und wie Deine Hardware verschaltet ist.

Ein bloßes "funktioniert nicht" ist sch**ße.

[Eindringlicher Berater (Gast)]

Navid M. schrieb:
> Ich habe das für Stm32f0 einbisschen genändert. Aber das funktioniert
> nicht.

Du kannst schon lesen und verstehen?

Sourcen solcher Grösse gehören in einen Datei-Anhang und
nicht in einen Beitrags-Text.

Siehe:

------------------------------------------------
Wichtige Regeln - erst lesen, dann posten!
.............
    Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang
------------------------------------------------

[Axel S. (a-za-z0-9)]

Eindringlicher Berater schrieb:
> Sourcen solcher Grösse gehören in einen Datei-Anhang und
> nicht in einen Beitrags-Text

Und keines von beidem gehört in eine seit 8 Jahren tote Thread-Leiche. 
Noch dazu eine zu einem ganz anderen Thema.

[Eindringlicher Berater (Gast)]

Axel S. schrieb:
> in eine seit 8 Jahren tote Thread-Leiche

Die Source wurde heute gepostet.

[spess53 (Gast)]

Hi

>Die Source wurde heute gepostet.

Aber von niemanden, der bis zum 8.9.2012 am thread beteiligt war.

"Eindringlicher Berater" =  ein dümmlicher Nickname + dümmlicher Post.

MfG Spess