STM32F407 Black und No-Arduino

[grundschüler (Gast)]

Ich kämpfe mit dem oben angegebenen board. Eigentlich ohne Hal und ohne 
arduino. Ohne Hal hab ich bereits aufgegeben.

Problem mit dem ili9341: Irgendwie klappt die Initialisierung nicht. Es 
sieht so aus, als gäbe es zwei Speicherbereiche, die parallel 
beschrieben werden. In  früheren ilis konnte man Orientation einstellen: 
Bildaufbau von oben links bis von unten rechts. Das finde ich weder im 
Init-code noch im manual (240 Seiten). Das nit Anfangs- und Endwert 
klappt auch nicht. Der Bereich zwischen Anfangs- und Endwert wird  n i c 
h t  beschrieben (weißer Rahmen). Warum?

Hier der init-code:

void ili9341_init(void)
{
  LCD_REG = ILI9341_RESET;
  HAL_Delay(60);
    
  LCD_REG = ILI9341_DISPLAY_OFF;

  LCD_REG = ILI9341_POWERA;
  LCD_RAM = 0x39;
  LCD_RAM = 0x2C;
  LCD_RAM = 0x00;
  LCD_RAM = 0x34;
  LCD_RAM = 0x02;

  LCD_REG = ILI9341_POWERB;
  LCD_RAM = 0x00;
  LCD_RAM = 0xC1;
  LCD_RAM = 0x30;

  LCD_REG = ILI9341_DTCA;
  LCD_RAM = 0x85;
  LCD_RAM = 0x00;
  LCD_RAM = 0x78;

  LCD_REG = ILI9341_DTCB;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;

  LCD_REG = ILI9341_POWER_SEQ;
  LCD_RAM = 0x64;
  LCD_RAM = 0x03;
  LCD_RAM = 0x12;
  LCD_RAM = 0x81;

  LCD_REG = ILI9341_PRC;
  LCD_RAM = 0x20;

  LCD_REG = ILI9341_POWER1;
  LCD_RAM = 0x23;

  LCD_REG = ILI9341_POWER2;
  LCD_RAM = 0x10;

  LCD_REG = ILI9341_VCOM1;
  LCD_RAM = 0x3E;
  LCD_RAM = 0x28;

  LCD_REG = ILI9341_VCOM2;
  LCD_RAM = 0x86;

  LCD_REG = ILI9341_MAC;
  LCD_RAM = 0x48;

  LCD_REG = ILI9341_PIXEL_FORMAT;
  LCD_RAM = 0x55;

  LCD_REG = ILI9341_FRC;
  LCD_RAM = 0x00;
  LCD_RAM = 0x18;

  LCD_REG = ILI9341_DFC;
  LCD_RAM = 0x08;
  LCD_RAM = 0x82;
  LCD_RAM = 0x27;

  LCD_REG = ILI9341_3GAMMA_EN;
  LCD_RAM = 0x00;

  LCD_REG = ILI9341_COLUMN_ADDR;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;
  LCD_RAM = 0xEF;

  LCD_REG = ILI9341_PAGE_ADDR;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;
  LCD_RAM = 0x01;
  LCD_RAM = 0x3F;

  LCD_REG = ILI9341_GAMMA;
  LCD_RAM = 0x01;

  LCD_REG = ILI9341_PGAMMA;
  LCD_RAM = 0x0F;
  LCD_RAM = 0x31;
  LCD_RAM = 0x2B;
  LCD_RAM = 0x0C;
  LCD_RAM = 0x0E;
  LCD_RAM = 0x08;
  LCD_RAM = 0x4E;
  LCD_RAM = 0xF1;
  LCD_RAM = 0x37;
  LCD_RAM = 0x07;
  LCD_RAM = 0x10;
  LCD_RAM = 0x03;
  LCD_RAM = 0x0E;
  LCD_RAM = 0x09;
  LCD_RAM = 0x00;

  LCD_REG = ILI9341_NGAMMA;
  LCD_RAM = 0x00;
  LCD_RAM = 0x0E;
  LCD_RAM = 0x14;
  LCD_RAM = 0x03;
  LCD_RAM = 0x11;
  LCD_RAM = 0x07;
  LCD_RAM = 0x31;
  LCD_RAM = 0xC1;
  LCD_RAM = 0x48;
  LCD_RAM = 0x08;
  LCD_RAM = 0x0F;
  LCD_RAM = 0x0C;
  LCD_RAM = 0x31;
  LCD_RAM = 0x36;
  LCD_RAM = 0x0F;

  LCD_REG = ILI9341_SLEEP_OUT;
  HAL_Delay(100);

  LCD_REG = ILI9341_DISPLAY_ON;
  LCD_RAM = ILI9341_GRAM;


}

[Arduinoquäler (Gast)]

Wenn du Pixels auf das Display bringst dann ist die Initialisierung
schon mal nicht sooo schlecht.

Konzentriere dich darauf dass du bei jeder Operation wo du
Pixel malen willst, immer die Beriche/Grenzen setzen musst.

Also damit

  LCD_REG = ILI9341_COLUMN_ADDR;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;
  LCD_RAM = 0xEF;

  LCD_REG = ILI9341_PAGE_ADDR;
  LCD_RAM = 0x00;
  LCD_RAM = 0x00;
  LCD_RAM = 0x01;
  LCD_RAM = 0x3F;

Dann ist die Abfolge des Setzens mehrerer Pixel davon abhängig
wie die Orientungsbits gesetzt sind. Das zuständige Register
dass du dabei selbst in der Hand haben musst ist

ILI9341_MADCTL      0x36

Ich habe die Erfahrung gemacht dass dieses Register bzw seine
Bit-Definitionen bei jedem Hersteller bzw Display-Typ anders
zu interpretieren ist bzw seine Richtungen unterschiedlich sind.

Nachdem ich keine Treiber öffentlich gefunden habe die die
Display-Orientierung für alle vier Möglichkeiten korrekt
behandeln blieb mir auch nur der steinige Weg dies selbst
durch trial-and-error herauszufinden da die Angaben im Manual
nicht sehr klar sind.

Durch ungeeignetes Setzen der Orientierungs-Bits bekommt man
oft seltsame Effekte die deiner Darstellung ähneln. Oft kommt
es bei mehrfachen Schreiben dann zu Über-/Unterläufen bei den
Parametern (die ja automatisch inkrementiert werden) von
ILI9341_COLUMN_ADDR und/oder ILI9341_PAGE_ADDR.

Dass man die Parameter-Liste der Kommandos immer 8-bittig
schreibt hast du ja erfreulicherweise bereits herausgefunden
(was ich dir gestern nicht so deutlich mitgeteilt habe).

[grundschüler (Gast)]

Arduinoquäler schrieb:
> ILI9341_MADCTL      0x36

danke für den Hinweis. Habe das manual jetzt ausgedruckt. 9.3 /S.201 
enthält eine Übersicht über die Einstellung von MV/MX/MY - MADCTl.

[Arduinoquäler (Gast)]

Also gut, hier noch eine Funktion zum "Herausfinden" der
Zeichenrichtung.

/* FUNCTION ************************************/
void Drawbar_Test (uint16_t colour)
/*
 * SPECIFICATION: Eine Linie ziehen
 *                zum Erkennen der Update-Richtung
 * PARAMETERS:
 * SIDE_EFFECTS:
 * RETURN VALUES:
 ***********************************************/
{
  uint16_t  ii, fillcount;
  uint16_t  x1, x2, y1, y2;

  x1 =   0;
  x2 = 200;
  y1 =   3;    // wegen erster Linie sehr am Rand
  y2 =   4;    // zwei Linien damit es deutlicher wird

  fillcount = (x2 - x1) + 1;
  fillcount = fillcount * (y2 - y1 + 1);

  TFT_SetWindow (x1, y1, x2, y2);
  TFT_WriteCmd (ILI9341_RAMWR);

  for (ii=0; ii<fillcount; ii++)
  {
    LCD_RAM = colour;
    delay (paar_Millisekunden); // das Schreiben ohne wäre ja zu schnell
    // damit kann man beobachten in welcher Richtung die Pixels
    // geschrieben werden und seine Schlussfolgerungen für
    // MAD_CTRL ziehen.
  }
}

[grundschüler (Gast)]

Ich kann jetzt 240x240 px sinnvoll Beschreiben(Bild). Schön wäre esw 
natürlich, wenn die gesamte Bildschirmbreite mit 320 px genutzt werden 
könnte. Wo wird eingestellt, ob nach 240 oder 320px umgebrochen wirde?

[Arduinoquäler (Gast)]

Gut!

Es wird dann umgebrochen wenn das X-Ende oder Y-Ende deines
aktuell gesetzten Fensters erreicht ist. Abhängig davon wie du
die Schreibrichtung des MAD_CTRL Registers gesetzt hast.

Also entweder wird zuerst von x1 bis x2 geschrieben, dann der
y-Wert inkrementiert, oder es wird von y1 bis y2 geschrieben und
dann x inkrementiert.

Das Inkrementieren kann aber auch Dekrementieren sein.

Schreibe dir doch erst mal die Fillscreen-Funktion die dir
einen ganzen schwarzen bzw einfarbigen Screen liefert.

[Arduinoquäler (Gast)]

grundschüler schrieb:
> Wo wird eingestellt, ob nach 240 oder 320px umgebrochen wirde?

Wenn du so fragst habe ich den Eindruck dass du noch nicht
verstanden hast was ich dir schon vorher beschrieben habe:

Arduinoquäler schrieb:
> Konzentriere dich darauf dass du bei jeder Operation wo du
> Pixel malen willst, immer die Beriche/Grenzen setzen musst.
>
> Also damit
>   LCD_REG = ILI9341_COLUMN_ADDR;
>   LCD_RAM = 0x00;  // start
>   LCD_RAM = 0x00;
>   LCD_RAM = 0x00;  // ende
>   LCD_RAM = 0xEF;
>
>   LCD_REG = ILI9341_PAGE_ADDR;
>   LCD_RAM = 0x00;  // start
>   LCD_RAM = 0x00;
>   LCD_RAM = 0x01;  // ende
>   LCD_RAM = 0x3F;

[grundschüler (Gast)]

Arduinoquäler schrieb:
> Wenn du so fragst habe ich den Eindruck dass du noch nicht
> verstanden hast was ich dir schon vorher beschrieben habe:

Ich habe das schon verstanden und auch ausprobiert. Nur war das 
Ergebnis, dass bei 0,0,240,320 gar nichts angezeigt wurde und bei 
0,0,10,20 ein unbeschriebener weißer Rand von 10 bzw. 20 blieb -auf dem 
Foto gut sichtbar.

Vielleicht habe ich es dann doch nicht richtig verstanden - jedenfalls 
der Bereich zwischen Start- und Endwert wird nicht beschrieben, erst der 
Bereich nach dem Endwert...

Warum?

[Arduinoquäler (Gast)]

Poste doch mal deine Setwindow Funktion.

Vermutlich verwechselst du irgedwas in Richtung:

xxxfunction (x1, y1, x2, y2)

und

xxxfunction (x1, x2, y1, y2)

Erkennst du den Unterschied?

[grundschüler (Gast)]

Arduinoquäler schrieb:
> Poste doch mal deine Setwindow Funktion.

mach ich nach feierabend. Meine aber genau mein Problem ab Seite 127 des 
manuals gefunden zu haben. Probiere es heute abend aus.

[grundschüler (Gast)]

hier der Code:

void lcd_clear(uint16_t Color){
  uint32_t index;
    LCD_REG = 0x002A;  // column address set
    LCD_RAM = 0;       // x Startwert 16 Bit
    LCD_RAM = 10;       // x Endwert 16 Bit
    LCD_REG = 0x002B;  // row address set
    LCD_RAM = 0;       // y Startwert 16 Bit
    LCD_RAM = 10;       // y Endwert 16 Bit
  LcdWriteReg(0x002c);
  for( index = 0; index < (MAX_X) * MAX_Y; index++ )
  {
    LcdWriteData(Color);
    //delay_ms(1);
  }
}

Damit bekomme ich den auf den Fotos ersichtlichen weißen Rand zwischen 
Start- und Endwert. Der Cursor wird auf den Endwert gesetzt und ab da 
dann die angegebene Anzahl pixel gesetzt. Umgebrochen wird nicht.

Allerdings wird jetzt der gesamte Bildschirm beschrieben. Fehler lag an 
MV.

Ich versuche mich jetzt mal an einem fonts.






Ich bekomme

[Arduinoquäler (Gast)]

grundschüler schrieb:
> hier der Code:

Der ist nicht korrekt.

column address set und row address set verlangen
nach 4 (in Worten: vier) Parameter à 8 Bit.

Du kannst Kommando-Parameter nicht 16 Bit breit schreiben.
Das Datenblatt schreibt dir das vor. Schau es dir nochmals an!

Arduinoquäler schrieb:
> Dass man die Parameter-Liste der Kommandos immer 8-bittig
> schreibt hast du ja erfreulicherweise bereits herausgefunden

Aber offensichtlich nicht konsequent weitergeführt.

[Arduinoquäler (Gast)]

grundschüler schrieb:
> LcdWriteData(Color);

Warum schreibst du an dieser Stelle nicht

LCD_RAM = Color;


grundschüler schrieb:
> LcdWriteReg(0x002c);

Warum schreibst du an dieser Stelle nicht

LCD_REG = 0x002c;

Es ist doch erbärmlich umständlich für einen einfachen
Write-Vorgang extra eine Funktion aufzurufen.

[grundschüler (Gast)]

Arduinoquäler schrieb:
> nach 4 (in Worten: vier) Parameter à 8 Bit.

du hast recht. Deswegen klappt der ganze code nicht richtig, danke, 
hätte ich selbst nicht gefunden.

Arduinoquäler schrieb:
> Es ist doch erbärmlich umständlich für einen einfachen
> Write-Vorgang extra eine Funktion aufzurufen.

Das ist überbleibsel von dem Versuch, meinen eigenen Standard-code 
abzuändern. Wird geändert.

[grundschüler (Gast)]

Display geht. Nächstes Problem RTC:

HAL_RTC_GetTime(&hrtc, &sTime, FORMAT_BIN);
lcd_goto(1,1);
lcd_int2(sTime.Hours);
lcd_write(":");
lcd_int2(sTime.Minutes);
lcd_write(":");
lcd_int2(sTime.Seconds);

Die RTC läuft. Nach dem rst ändert sich die Zeit. Allerdings im 
laufenden Programm wird die Zeit mit "HAL_RTC_GetTime" nicht 
aktualisiert. Was mach ich falsch?

[grundschüler (Gast)]

grundschüler schrieb:
> Was mach ich falsch?

mit
  HAL_RTC_GetTime(&hrtc, &sTime, FORMAT_BIN);
  HAL_RTC_GetDate(&hrtc, &sDate, FORMAT_BIN);
läuft es...

[Harry L. (mysth)]

hast du dir HAL_RTC_GetTime mal genauer angesehen?
Kann man doch wunderbar im Debugger durchgehen.
Ich glaube nicht, daß der doppelte Aufruf der Weisheit letzter Schluß 
ist.

[grundschüler (Gast)]

Harry L. schrieb:
> der Weisheit letzter Schluss

Das sehe ich genauso. Aber:
 * @note You must call HAL_RTC_GetDate() after HAL_RTC_GetTime() to 
unlock the values
  *        in the higher-order calendar shadow registers to ensure 
consistency between the time and date values.
  *        Reading RTC current time locks the values in calendar shadow 
registers until current date is read.

Eine endlose hal-Funktion für einen einfachen Registeraufruf. Ich 
benutze diese nur zum Abgleich und ansonsten einen systick-timer. Hal 
ist gut für ein lauffähiges Grundgerüst.

[grundschüler (Gast)]

habe jetzt ein ir-Einstellmenu für die rtc.

void set_smh(void){
  sTime.Seconds=sec;
  sTime.Minutes =min;
  sTime.Hours =hou;
  sDate.Date= DAY;
  sDate.Month =MON;
  sDate.Year= YEA;
  sDate.WeekDay= WDY;

  HAL_RTC_SetTime(&hrtc, &sTime, FORMAT_BIN);
  HAL_RTC_SetDate(&hrtc, &sDate, FORMAT_BIN);
}

Problem: die rtc läuft nicht auf Batterie weiter. Hat jemand die 
richtige Einstellung parat?

[grundschüler (Gast)]

Hänge immer noch an der rtc bzw. die rtc hängt immer noch.

Es gibt doch sicher Jemanden, der beim black-board die rtc korrekt zum 
laufen gebracht hat. Muss man etwa etwas umlöten, damit die rtc nach 
Power_down über Batterie weiterläuft???