quartus nios 2 zugriff hdmi

[Geldesch B. (Firma: haa) (dravr)]

hello, hat jemand schonmal mit einem NIOS II auf die HDMI Schnittstelle 
des DE 10 nano zugegriffen ?
Möchte erstmal nur ein paar Testausgaben machen. Nur ein paar Pixel 
ansprechen.

Vielleicht hat jemand einen Tipp wie man grob vorgehen sollte :D

[tja (Gast)]

- HDMI Stream erzeugen
- Daten aus Bildspeicher holen und in den Stream legen
- mit NIOS II den Bildspeicher manipolieren

[Geldesch B. (Firma: haa) (dravr)]

Guten Abend,
vielen Dank für die Antwort !
Ich werde mal schauen wie ich einen solchen Stream kreieren kann.
Dann werde ich schauen wie ich auf den Bildspeicher Zugriff erhalte.

:D

[Donni D. (Gast)]

Hast du denn schon mal in das Datenblatt zum Board geschaut? ADV7513 
Sollte der verwendete HDMI Transmitter IC sein, den guckst du dir an. 
Wenn du allerdings wenig Erfahrung im FPGA Bereich hast, fang klein an.

[Geldesch B. (Firma: haa) (dravr)]

Vielen Dank für den Tipp!

Konnte ich auch gerade in der Terasic Anleitung lesen


Abschnitt 3..6..5 HDMI TX Interface
ADV7513 HDMI TX

Das Datenblatt dazu:
https://www.analog.com/media/en/technical-documentation/data-sheets/ADV7513.pdf

Werde dann mal weiter lesen :D

[Geldesch B. (Gast)]

Analog Devices zeigt in einer PDF: AN-1270.pdf wie man einen 
HDMI-Pattern-Generator auf seinem FPGA in Verilog implementieren könnte:

https://www.analog.com/media/en/technical-documentation/application-notes/AN-1270.pdf

List 1 = Generator
List 2 = Testpattern
List 3 = TopModule implementation

Hat jemand eine Ahnung ob man damit wenigsten schonmal mit Quartus und 
dem De10 nano FPGA eine Testausgabe hinbekommen könnte ?
Ich selber muss noch Arbeitsspeicher nachrüsten. Das hat letztes mal 1 
Stunde gedauert um alles zu compilieren.

Dann hätte man ja schonmal einen Stream


tja schrieb:
>- HDMI Stream erzeugen
>- Daten aus Bildspeicher holen und in den Stream legen
>- mit NIOS II den Bildspeicher manipolieren

Vielen Dank !

[Gustl B. (gustl_b)]

Ja mit dem Board kannst du ganz sicher HDMI ausgeben. Und das vermutlich 
auch ohne CPU. Wobei ... was willst du eigentlich mit dem NIOS, das ist 
ein SoC, das hat ARM9 Kerne drinnen, die sind sehr viel schneller als 
ein NIOS.

Laut Übersicht 
https://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=205&No=1046&PartNo=2 
hängt das HDMI am FPGA, das RAM und Ethernet am ARM. Du kannst also sehr 
wahrscheinlich auch HDMI ohne CPU machen. Dann aber auch nur ohne DDR 
RAM. Für ein einfaches Muster reicht das aber.

[Markus F. (mfro)]

da fehlt - wenn ich das beim kurz drübergucken richtig sehe - das 
i2c-Interface, um den ADV75xx erst mal zu initialisieren.

Wenn's VHDL sein darf, darfst Du dich gerne hier und drumrum bedienen:

https://github.com/mfro0/deca_mem/blob/master/i2c_hdmi_config.vhd

Das ist zwar für ein MAX10 Board, aber das hat auch den ADV7513. Das 
Beispiel generiert einen RGB-Farbverlauf und ist zum Teil bei Terasic 
geklaut.

Den Framebuffer darfst Du selber bauen ;)

[Tobias B. (Firma: www.elpra.de) (ttobsen)]

Markus F. schrieb:
> da fehlt - wenn ich das beim kurz drübergucken richtig sehe - das
> i2c-Interface, um den ADV75xx erst mal zu initialisieren.

Genau das gleiche Problem hatten wir vor kurzem in diesem Thread:

Beitrag "Video mit AC701"

Lohnt sich trotz Artix 7 mal Quer zulesen, da die Initialisierung des 
ADV7511 dort auch diskutiert wurde. Der ADV7513 wird sich da vermutlich 
nicht wirklich von unterschieden.

[Geldesch B. (Firma: haa) (dravr)]

Vielen Dank für die Antworten.
Wegen I2C steht am Anfang von

 https://www.analog.com/media/en/technical-documentation/application-notes/AN-1270.pdf

>BASIC REQUIREMENTS To output in HDMI or DVI format, the ADV751x must be 
>programmed with the appropriate I2C register writes (see List 4) and fed >with a 
valid video sync signal accompanied by a clock.

Liste 4 habe ich im Anhang als Bild. Und die Übersicht vom AD 
Videogenerator.

Also man muss dann vlt. den ADV75xx mit diesen dort beschriebenen 
Befehlen ansprechen. Dafür müsste ich dann extra selber sorgen.

---
Ja ich weiß, dass Softcore Prozessoren ggfs. langsamer sind als Hardcore 
Prozessoren. Auch ggfs. etwas umständlicher. Trotzdem ist es mein Ziel 
den NIOS II dafür zu verwenden :D

---
Danke für die Links : 
https://github.com/mfro0/deca_mem/blob/master/i2c_hdmi_config.vhd und 
Beitrag "Video mit AC701"

in vhdl wäre das aus anderen Gründen für mich sogar besser, allerdings 
wäre es gut wenn ich überhaupt was hinbekomme :D

[Gustl B. (gustl_b)]

Im Handbuch auf Seite 58 steht was. Terasic ist ja richtig nett, die 
haben auch Schaltplan und alles online, sehr fein. Und Code ist auch da.

[Geldesch B. (Firma: haa) (dravr)]

oh, ja vor ein paar Tagen waren das nur Hieroglyphen  für mich auf S.58 
xD
>This section gives instructions to program the HDMI transmitter to >generate 
video pattern
>and audio source. The entire reference is composed into three parts: video 
>design, audio
>design, and I2C design.

Jetzt werde ich mal schauen wo die Beispieldateien sind.

naja hatte noch glücklicherweise einen Ordner - konnte aber gerade auf 
Terasic.com noch nichts sehen-

\board_docu\Demonstrations\FPGA\HDMI_TX

hier ist es:
https://github.com/DarmstadtLinux/FPGAStuff/tree/master/HDMI_TX

Werde das gleich mal hochladen und warten bis ich einen HDMI Bildschirm 
finde xD

Dann wäre noch die grandiose Frage ob es schwer ist, parallel noch den 
NIOS laufen zu lassen ... Also ich müsste dafür ja alles in das Projekt 
einbinden.

Oh ich werde wohl noch einen 8 GB RAM für meinen Laptop kaufen müssen.
Aber wenigsten kann man das .sof File ohne compilieren drauf laden.
Nur leider sehe ich noch nichts ohne hdmi bildschirm xD

[Geldesch B. (Gast)]

Wenn ich mein Quartus auf "nur 1 Prozessor" stelle kann ich alles 
anstatt in 30 Minuten in 5 Minuten compilieren. Zumindest ist das jetzt 
bei kleinen NIOS Projekten so.
Man kann für erste Tests auch in Settings einstellen, dass manche 
Aufgaben beim compilieren nicht mit "voller Leistung" beachtet werden 
sollen.

Das erspart zumindest einem Anfänger ein paar Nerven

Außerdem habe ich "herausgefunden", dass man wirklich ein HDL programm 
parallel zum NIOS laufen lassen kann. Also nichts besonderes, wusste ich 
eben einfach noch nicht.
Nun bin ich an dem Punkt, wo ich wissen muss, ob man z.B. die HDMI 
Schnittstelle an den AVALON Bus dranhängt oder, ob es eine andere 
Möglichkeit gibt darauf zuzugreifen. Also eigentlich wie gerade 
beschrieben einfach parallel dazu einbinden un darauf zugreifen.
Falls es eine andere Möglichkeit, also ohne Avalon gibt, muss man 
schauen ob diese nicht zu aufwendig ist.

Ich möchte ja den HDMI Stream beeinflussen. Einfach nur immer weiße 
Punkte auf einen schwarzen Bildschirm setzten. Ich habe schon gesehen, 
dass es einen Avalon Interface Slave gibt.
https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/manual/mnl_avalon_spec.pdf

Vielen Dank.
Vielleicht hat jemand eine Anregung oder eine Idee :D

[Tja (Gast)]

Ich glaube, du stellst dir das zu einfach vor. Mein hinweis auf die vip 
suite wurde, warum auch immer, gelöscht. Ich denke, dass das was ein 
moderator nicht kennt grundsätzlich gelöscht wird. Einfacher als mit der 
vip suite wirds nicht 
(https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/ug/ug_vip.pdf).

[Geldesch B. (Firma: haa) (dravr)]

Tja schrieb:
> Ich glaube, du stellst dir das zu einfach vor. Mein hinweis auf die vip
> suite wurde, warum auch immer, gelöscht. Ich denke, dass das was ein
> moderator nicht kennt grundsätzlich gelöscht wird. Einfacher als mit der
> vip suite wirds nicht
> 
(https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/ug/ug_vip.pdf).

Danke vor allem für das nochmal posten..
Werde ich mir näher anschauen ! :D
Es muss ja nicht einfacher werden. Es muss einfach nur werden xD

(grade auch noch mal drauf gestoßen vip 
...https://www.youtube.com/watch?v=V5RwFBH4nVI)

Jetzt habe ich etwas gesehen wo ein einzelne Pixel eingegangen wird.. : 
https://www.fpga4fun.com/HDMI.html

Wenn die HDMI driver als Module laufen könnte ich doch seine Signale per 
PIO mit dem Avalon verbinden..und mit dem Nios Daten übertragen... ?

[Gustl B. (gustl_b)]

Das was du da bei fpga4fun gefunden hast funktioniert wenn du die HDMI 
Buchse direkt an den FPGA anschließt. Bei dir sitzt aber ein Baustein 
dazwischen. Und den musst du auf der Hardware für den verbauten HDMI 
Ausgang auch verwenden.

[Geldesch B. (Firma: haa) (dravr)]

hallo nochmal :D
habe nur noch mal kurz in den Code geschaut... :
Ziel: Eigene Bilder auf FPGA über HDMI ausgeben
HDMI TX ist eine Demo die je nach SWitch des FPGAs den Bildschirm in 
einer Farbe ausgibt...
( ich glaube mit meinem hdmi bildschirm ging das nicht/ sollte ich mit 
einem anderen testen.hdmi bildschirm ging auch bei meinem normalen pc 
nicht. nur bei linux xD)
--------------------
Nun eine Stelle im Beispiel Code die ich interessant finde:

In vga_generator.v wird nur gezeigt wie die Farbe verändert werden 
kann..
Man wählt also eine Farbe aus und dann "zeichnet der mit seinem Hsyn und 
Vsync alles" ...

(Der soll aber eigentlich für jeden Pixel bzgl. meines Bildes.. entweder 
weiß oder schwarz zeichnen !)

Was ich aus dem Code sehen kann ist, dass er jeden Clock etwas 
entscheidet.

Code aus Datei

//pattern generator and display enable
always @(posedge clk or negedge reset_n)
begin
  if (!reset_n)
  begin
    vga_de    <=  1'b0;
    pre_vga_de  <=  1'b0;
    boarder    <=  1'b0;    
  end
  else
  begin
    vga_de    <=  pre_vga_de;
    pre_vga_de  <=  v_act && h_act;
    
    if ((!h_act_d&&h_act) || hr_end || (!v_act_d&&v_act) || vr_end)
      boarder  <=  1'b1;
    else
      boarder  <=  1'b0;       
    
    if (boarder)
      {vga_r, vga_g, vga_b} <= {8'hFF,8'hFF,8'hFF};
    else
      case (color_mode)
        4'b0001  :  {vga_r, vga_g, vga_b}  <=  {pixel_x,8'h00,8'h00};
        4'b0010  :  {vga_r, vga_g, vga_b}  <=  {8'h00,pixel_x,8'h00};
        4'b0100  :  {vga_r, vga_g, vga_b}  <=  {8'h00,8'h00,pixel_x};
        4'b1000  :  {vga_r, vga_g, vga_b}  <=  {pixel_x,pixel_x,pixel_x};
        default  :  {vga_r, vga_g, vga_b}  <=  {8'h00,8'h00,8'h00};
      endcase
  end
end

Ich sehe da aber gerade (PSEUDOCODE) :

 if (boarder)
      {vga_r, vga_g, vga_b} <= {8'hFF,8'hFF,8'hFF};else "WÄHLE FARBE"

Heißt das, dass der wenn er ne boarder identifiziert hat, also am Ende 
des Bildes ist , einfach schwarz malt ?!

Dann heißt das ja dass der pixel für pixel entscheidet !
So könnte ich doch mein Bild aufbauen !?

[Gustl B. (-gb-)]

Geldesch B. schrieb:
> Heißt das, dass der wenn er ne boarder identifiziert hat, also am Ende
> des Bildes ist , einfach schwarz malt ?!

Eher weiß.

Geldesch B. schrieb:
> Dann heißt das ja dass der pixel für pixel entscheidet !
> So könnte ich doch mein Bild aufbauen !?

Ja und ja.

Ich verwende für sowas zwei Zähler, einer vertikal (Zeile) und einer 
horizontal (Pixel in der Zeile).

Und in Abhängigkeit der beiden Zählerstände gibst du dann die Farben 
aus.

[Geldesch B. (Firma: haa) (dravr)]

Hi Gustl B.,

vielen Dank für deine Antwort :D
Habe bis jetzt nur kurze Zeit zum Überlegen gehabt:

Jetzt würde ich die Terasic "HDMI TX" Demo gerne so umschreiben, dass 
ich meine sich ändernden Bilder ( z.B. 60 Hz)dargestellt bekomme.
Ich habe diese "HDMI TX" Demo heute nur kurz noch mal auf einem normalen 
HDMI Display laufen lassen und konnte wirklich einen weißen Rand 
0xffffff sehen. Außerdem noch, das in der Terasic-Anleitung beschriebene 
Pattern.
Switch0 sorgt sogar dafür,dass der Bildschirm summt.

Über KEY1 Taster kann man den Mode ändern.:

Pattern ID Video Format PCLK (MHZ)
0 640x480@60P 25
1 720x480@60P 27
2 1024x768@60P 65
3 1280x1024@60P 108
4 1920x1080@60P 148.5

Der weißte Rand um alles bleibt immer noch da.
Es werden mehrere Reihen gezeichnet ( je nach Auflösung)
Eine Reihe besteht aus mehreren Rechtecken einer Farbe.  rot grün blau 
weiß. Danach wäre wieder rot dran.
Die Rechtecke beginnen links immer mit einem Schatten.
Dieser hat aber nichts mit dem Farbcodex RGB zu tun oder ?
Da geht es um weitere Parameter oder ?
HSV ? ( wenn V klein ist wird grün dunkler z.B.)
https://www.rapidtables.com/web/color/RGB_Color.html

Nun müsste man identifizieren was das Programm dazu bewegt immer wieder 
neue Rechtecke zu zeichnen ( vielleicht ist es auch nur der Schatten der 
so wirkt als seien es mehrere Rechtecke).
Und warum immer eine neue Farbe gewählt wird.

Denn so könnte man den "Code" so umschreiben, dass er sich nicht immer 
stumpf wiederholt, sondern die Zeit des Durchlaufens im Bild, dafür 
nutzt, mein Bild zu zeichnen !
Undzwar jede 1/60 Sekunde !

Macht das Sinn ? xD

Danke :D
( Anhang: Pattern - weißen Rand sieht man evtl. nicht ist aber am Rand 
xD)

[Markus F. (mfro)]

Geldesch B. schrieb:
> Denn so könnte man den "Code" so umschreiben, dass er sich nicht immer
> stumpf wiederholt, sondern die Zeit des Durchlaufens im Bild, dafür
> nutzt, mein Bild zu zeichnen !
> Undzwar jede 1/60 Sekunde !

Gratuliere - Du hast das Konzept des Framebuffers entdeckt.

Framebuffer = Bildschirmspeicher.

Du reservierst einen Speicherbereich als Dual-Port Memory, der (durch 
unabhängigen, "entkoppelten" Code - über einen Fifo) mit Pixelwerten 
beschrieben wird.

Statt die Farbwerte, die ans Display gehen, im Flug algorithmisch zu 
bestimmen, werden sie eben aus dem Framebuffer gelesen.

Praktisch alle Computerdisplays basieren auf diesem Prinzip.

[Geldesch B. (Firma: haa) (dravr)]

@Markus F.

haha,
sehr gut^^
Und sehr wichtig !

Und danke für die Antwort !
( Auch Gustl B. danke nochmal ! Du hast das ja bereits stark angedeutet)

Sehr interessanter Tipp ,werde ich prüfen :
>Du reservierst einen Speicherbereich als Dual-Port Memory, der (durch
>unabhängigen, "entkoppelten" Code - über einen Fifo) mit Pixelwerten
>beschrieben wird.

Danke, dass du genau darauf noch mal eingegangen bist:
>Statt die Farbwerte, die ans Display gehen, im Flug algorithmisch zu
>bestimmen, werden sie eben aus dem Framebuffer gelesen.

--------------------------------
Mein nächster Schritt wäre es jetzt den HDL-Code besser zu verstehen. 
Ist ja eine Voressetzung, um überhaupt voran zu kommen denke ich^^

Falls jemand noch eine Anregung vor allem für diesen speziellen Fall 
Terasic HDMI TX -Demo hat wäre es natürlich interessant.
-----

Vielen Dank :D

[Geldesch B. (Firma: haa) (dravr)]

deinen MAX10 Code sollte ich mir entsprechend auch anschauen
>https://github.com/mfro0/deca_mem/blob/master/i2c_hdmi_config.vhd

[Geldesch B. (Firma: haa) (dravr)]

Ok es gibt ein Dokument von Intel was einem bei diesem Thema ebenfalls 
weiterhilft: *DE10-Nano_Computer_ARM.pdf*

https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&ved=2ahUKEwi79qztuIHoAhXMMewKHV2oCpsQFjABegQIAhAB&url=ftp%3A%2F%2Fftp.intel.com%2FPub%2Ffpgaup%2Fpub%2FIntel_Material%2F18.1%2FComputer_Systems%2FDE10-Nano%2FDE10-Nano_Computer_ARM.pdf&usg=AOvVaw0CYTylSR3oXOxLhhY2xeur

Dort ist sogar ein Listing dargestellt wie man den HDMI Treiber über den 
NIOS ansprechen kann

Werde das erst mal genauer betrachten :D
-----
Habe außerdem über die HDMI TX Demo nachgedacht, denke das Ding läuft 
so:
Sehr schlecht formuliert- und bereits von euch fast bestätigt:
Von hinten drängelt Hsync und Vsync , während die 
Buffercontrollereinheit dazu was sagen soll.

Also man kann bei jedem CLK Takt abfragen welches Pixel gerade im Fokus 
steht und diesem einen Farbwert zuweisen, der dann auch ausgegeben wird.

---
Mal schauen !

[Geldesch B. (Firma: haa) (dravr)]

Ist auch evtl. hilfreich..
Video IP Coresfor Intel DE-Series Boards
https://faculty-web.msoe.edu/johnsontimoj/Common/FILES/video.pdf

[Tja (Gast)]

Dort ist sogar ein Listing dargestellt wie man den HDMI Treiber über den
NIOS ansprechen kann



Welchen Treiber meinst Du?

[Geldesch B. (Firma: haa) (dravr)]

Ah habe den ADV7513 wahrscheinlich nicht korrekt benannt.
Also es geht wohl um das Ansprechen des ADV7513-Bausteins auf dem FPGA 
über den NIOS.
Man muss dafür wohl ein paar IPs zu Qsys hinzufügen.
Es steht jetzt nur indirekt drin welche.
Ich nehme an video_pixel_buffer_dma_0 und
video_character_buffer_with_dma_0

Bei der Demo geben die nämlich noch Buchstaben aus xD

Bin so auf das "Thema" HAL - Hardware application Layer gekommen.
Also ist ja eigentlich logisch, dass der NIOS auch umfangreich auf die 
Hardwarekomponenten/IPs zugreifen soll.

Z.b. mit dem Board support package editor von Intel , ist es möglich auf 
"einfachem Weg" den Umfang der HAL-Funktionen festzulegen. Jeder 
Hersteller und auch Intel stellt häufig für seine Komponenten/IPs ein 
paar Zugriffsmöglichkeiten zur Verfügung.

In der PDF steht einfach nur
include "address_map_nios2.h"
Dort sind einfach Adressen definiert - zumindest habe ich diese Datei 
irgendwo auf GitHub in verschiedensten Versionen gesehen xD

Vlt. ist das schon die support Datei und der NIOS erreicht die 
Komponenten (sofern in QSYS eingebunden ) damit.
Also vor allem wenn man das Beispielprogramm von Intel verwendet.

Könnte mir aber auch vorstellen, dass man diese Datei mit dem BSP-Editor 
selber generieren kann.
Muss ich jetzt einfach mal testen ... vor allem wie man die Komponenten 
korrekt anschließt xD

Muss ich anschauen:
https://www.youtube.com/watch?v=HF7Low_sUig

[Markus F. (mfro)]

Damit sind wohl fast alle wesentlichen Fragen beantwortet.

Bis auf: "Was will er uns damit sagen?"

[Gustl B. (-gb-)]

Die Frage ist auch was er denn will. Fertige Bauteile zusammenklicken 
und dann läuft etwas und zeigt ein Bild?
Oder das selber mal zu Fuß bauen um das am Ende auch verstanden zu 
haben.

Das ist nicht schwer selber die Pixeldaten an den ADV zu geben und es 
ist auch nicht schwer in diesem ADV ein paar Register zu beschreiben. 
Welche das sind und wie das geht steht alles im Datenblatt.

[Geldesch B. (Firma: haa) (dravr)]

Wenigstens ist der Titel nicht ganz daneben:
quartus nios 2 zugriff hdmi

Ziel: Über den NIOS Pixeln eine Farbe zuweisen und über HDMI ausgeben

------------------
Bisher geschehen:
* ADV7513 auf Board gesehen
* Bei der HDMI TX Demo die den ADV7513 nutzt eine Stelle gesehen, die 
Pixel wie beim Ziel beschrieben analysiert.
* Gesehen, dass Intel ein Dokument bereitstellt wo beschrieben wird wie 
man HDMI Ausgaben über den NIOS macht. Voraussetzung HAL verstehen

-----------------
 Mir reicht als erster Schritt:
>Fertige Bauteile zusammenklicken
>und dann läuft etwas und zeigt ein Bild?

Dabei einfach noch ein paar Pixel mit gewünschten Farben ausgeben 
können.

Also es sollte eigentlich die folgende Lösung reichen.
Es wird in dem Dokument aber vorausgesetzt, dass man weiß, welche 
Komponenten man als IP einbinden soll. Muss ich noch herausfinden xD

#include "address_map_nios2.h"
/* function prototypes */
void video_text(int, int, char *);
void video_box(int, int, int, int, short);
int resample_rgb(int, int);
int get_data_bits(int);
#define STANDARD_X 320
#define STANDARD_Y 240
#define INTEL_BLUE 0x0071C5
/* global variables */
int screen_x;
int screen_y;
int res_offset;
int col_offset;
/*******************************************************************************
* This program demonstrates use of the video in the computer system.
* Draws a blue box on the video display, and places a text string inside the
* box
******************************************************************************/
int main(void) {
volatile int * video_resolution = (int *)(PIXEL_BUF_CTRL_BASE + 0x8);
screen_x = *video_resolution & 0xFFFF;
screen_y = (*video_resolution >> 16) & 0xFFFF;
volatile int * rgb_status = (int *)(RGB_RESAMPLER_BASE);
int db = get_data_bits(*rgb_status & 0x3F);
/* check if resolution is smaller than the standard 320 x 240 */
res_offset = (screen_x == 160) ? 1 : 0;
/* check if number of data bits is less than the standard 16-bits */
col_offset = (db == 8) ? 1 : 0;
/* create a message to be displayed on the video and LCD displays */
char text_top_row[40] = "Intel FPGA\0";
char text_bottom_row[40] = "Computer Systems\0";
/* update color */
short background_color = resample_rgb(db, INTEL_BLUE);
video_text(35, 29, text_top_row);
video_text(32, 30, text_bottom_row);
video_box(0, 0, STANDARD_X, STANDARD_Y, 0); // clear the screen
video_box(31 * 4, 28 * 4, 49 * 4 - 1, 32 * 4 - 1, background_color);
}
/*******************************************************************************
* Subroutine to send a string of text to the video monitor
******************************************************************************/
void video_text(int x, int y, char * text_ptr) {
int offset;
volatile char * character_buffer =
(char *)FPGA_CHAR_BASE; // video character buffer
/* assume that the text string fits on one line */
offset = (y << 7) + x;
while (*(text_ptr)) {
*(character_buffer + offset) =
*(text_ptr); // write to the character buffer
++text_ptr;
++offset;
}
}
/*******************************************************************************
* Draw a filled rectangle on the video monitor
* Takes in points assuming 320x240 resolution and adjusts based on differences
* in resolution and color bits.
******************************************************************************/
void video_box(int x1, int y1, int x2, int y2, short pixel_color) {
int pixel_buf_ptr = *(int *)PIXEL_BUF_CTRL_BASE;
int pixel_ptr, row, col;
int x_factor = 0x1 << (res_offset + col_offset);
int y_factor = 0x1 << (res_offset);
x1 = x1 / x_factor;
x2 = x2 / x_factor;
y1 = y1 / y_factor;
y2 = y2 / y_factor;
/* assume that the box coordinates are valid */
for (row = y1; row <= y2; row++)
for (col = x1; col <= x2; ++col) {
pixel_ptr = pixel_buf_ptr +
(row << (10 - res_offset - col_offset)) + (col << 1);
*(short *)pixel_ptr = pixel_color; // set pixel color
}
}
/********************************************************************************
* Resamples 24-bit color to 16-bit or 8-bit color
*******************************************************************************/
int resample_rgb(int num_bits, int color) {
if (num_bits == 8) {
color = (((color >> 16) & 0x000000E0) | ((color >> 11) & 0x0000001C) |
((color >> 6) & 0x00000003));
color = (color << 8) | color;
} else if (num_bits == 16) {
color = (((color >> 8) & 0x0000F800) | ((color >> 5) & 0x000007E0) |
((color >> 3) & 0x0000001F));
}
return color;
}
/********************************************************************************
* Finds the number of data bits from the mode
*******************************************************************************/
int get_data_bits(int mode) {
switch (mode) {
case 0x0:
return 1;
case 0x7:
return 8;
case 0x11:
return 8;
case 0x12:
return 9;
case 0x14:
return 16;
case 0x17:
return 24;
case 0x19:
return 30;
case 0x31:
return 8;
case 0x32:
return 12;
case 0x33:
return 16;
case 0x37:
return 32;
case 0x39:
return 40;
}
}

[Geldesch B. (Firma: haa) (dravr)]

habe gerade gesehen, dass Intel ein Programm namens Intel FPGA Monitor 
Program verwendet...
Man öffnet es, wählt das angeschlossene Board aus und dann die Demo die 
man starten möchte. Darunter auch die oben aufgeführte. Da mein HDMI 
Bildschirm evtl. nicht so einfach damit harmoniert erscheint 5/6 des 
Bildschirms schwarz xD
Hatte aber auch schon Probleme bei der HDMI TX Demo. Bei einem größeren 
wurde das Bild "normal" angezeigt.

----
Bringt aber jetzt nichts außer, dass man so an das angegebene Header 
file dran kommt #include "address_map_nios2.h" .. liegt dort im 
source-Ordner.
Aber wie man das in Qsys nachbildet wird da nicht direkt gezeigt xD

[Geldesch B. (Gast)]

Hi wieder mal Neuigkeiten.

Ich habe das zwar mit dem Intel FPGA Monitor Program nicht hinbekommen - 
Projekt erstellen und "example" laden- aber dort befidnet sich eine 
Projektdatei .qpf , sowie die HAL Funktionen um mit dem NIOS die 
Hardware zu nutzen.
Ich habe die zugehörige .sof auf den FPGA geladen und anschließend 
video.c ( siehe oben) sowie die Bibliotheken per copy & paste eingefügt.
Nach Compilieren erscheint auf meinem HDMI-Display ( größerer als 
vorher...) "Intel FPGA Computer Systems" innerhalb eines türkisen 
Rechtecks.
Nun kann ich endlich beginnen meine Pixel zu manipulieren :D

Danke :D

[Geldesch B. (Firma: haa) (dravr)]

Mist jetzt geht es nicht mehr xD

Aus irgendeinem Grund werden oben in den ersten 6 Zeilen einfach nur 
random-Pixel angezeigt. Rest ist schwarz.
Hatte das vor ein paar Tagen schon, wobei ich dann einfach alle Dateien 
neu installiert habe ( intel_fpga_upds_setup.exe) und dann alle Schritte 
nochmal durchgeführt habe.
Jetzt klappt das aber nicht mehr.

Habe den gleichen Fehler bei 3 (gleichen, relativ modernen) Bildschirmen 
gesehen und jetzt nochmal bei einem Bildschirm wobei ich hier einen HDMI 
zu VGA Adapter nutze. ( Der konnte aber zb bereits meine Windows 
Oberfläche anzeigen auf diese Weise)

Also ich denke es liegt einfach an der Projektkonfiguration..

Ich kompiliere gerade das gesamte Besipielprojekt neu.
(Dauert jetzt schon mehr als 30 min - muss nochmal meine Einstellungen 
diesbezüglich prüfen)
Falls ich gar nicht weiter weiß muss ich wohl mehr Details posten
:DDD

[Geldesch B. (Firma: haa) (dravr)]

Ok jetzt habe ich gerade ein neues Projekt mit dem "Intel FPGA Monitor 
Program" erstellt, wobei dort wohl eine .sof hochgeladen wurde... da der 
Bildschirm schwarz blieb, habe ich in Eclipse rein und habe wieder 
video.c und die anderen dateien in ein HelloWorld Porjekt reinkopiert.
Jetzt kam nach dem ersten "Run" wieder auf dem Bildschirm: Intel FPGA 
Computer Systems",
dann habe ich den String ein bisschen verändert und nach compilieren / 
run kamen oben wieder die random-pixel

Diese Kombination hatte ich bis jetzt noch nicht. Also random pixel und 
dabei den String.

Siehe Anhang

[Geldesch B. (Firma: haa) (dravr)]

Also immer wenn ich gerade die .sof -Datei draufgeladen habe und dann 
direkt mit Eclipse video.c abspiele - funktioniert das...

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Geldesch B. schrieb:
> Außerdem habe ich "herausgefunden", dass man wirklich ein HDL programm
> parallel zum NIOS laufen lassen kann.

Möglicherweise fehlt Dir derzeit noch jegliches Verständnis über den 
Aufbau eines FPGA und die Hardwarebeschreibungssprachen.

> Falls ich gar nicht weiter weiß muss ich wohl mehr Details posten
> :DDD

Nein, erspare uns am besten das ganze Geschreibsel. Damit kann niemand 
etwas anfangen.

> Also immer wenn ich gerade die .sof -Datei draufgeladen habe
> und dann direkt mit Eclipse video.c abspiele - funktioniert das...

Das ist ein deutliches Zeichen dafür, dass Du Dich nicht ansatzweise mit 
der Funktionsweise eines FPGA befasst hast und auch nicht weißt, wie ein 
Softcore darin überhaupt funktioniert.

[Geldesch B. (Firma: haa) (dravr)]

>>Außerdem habe ich "herausgefunden", dass man wirklich ein HDL >>programm
>> parallel zum NIOS laufen lassen kann.
Ja es ging darum wie man das dann umsetzt.

>Nein, erspare uns am besten das ganze Geschreibsel. Damit kann >niemand
>etwas anfangen.
Ich werde versuchen es wirklich knapp zu halten !


>>wie ein
>>Softcore darin überhaupt funktioniert
Ja stimmt.


Vielen Dank

[Geldesch B. (Firma: haa) (dravr)]

ja jetzt gehts wieder so wie vorher..

Mit etwas Glück liegt das nur daran :
Bei den Run Configurations unter Zielverbindung ( "target connection") 
muss man die Prozessorverbindung und die Byte Stream Device-Verbindung 
korrekt wählen.

Siehe Anhang

Mal schauen ob das auch weiterhin funktioniert :P

[Dergute W. (derguteweka)]

Moin,

Angesichts des hochprofessionellen Vorgehens und der steilen Lernkurve 
muss ich doch mal fragen: Und was wird das, wenns fertig ist?

Gruss
WK

[Markus F. (mfro)]

Dergute W. schrieb:
> Angesichts des hochprofessionellen Vorgehens und der steilen Lernkurve

Immerhin läßt sich eine gewisse Hartnäckigkeit nicht verleugnen.

Vielleicht lernt er's ja doch noch ;)

[Gustl B. (-gb-)]

Ganz ernst gemeint:

Dein Ziel scheint ja zu seien etwas mit FPGAs zu lernen. Dann mach das 
auch. Und zwar von ganz unten her. Wenn du selbst das SPI geschrieben 
hast (in HDL), den ADV damit beschrieben hast und selber Pixeldaten 
ausgegeben hast ohne Softprozessor, dann hast du viel gelernt.

Wenn dein Ziel aber ist Bilddaten über HDMI auszugeben, warum quälst du 
dich dann mit einem FPGA? Das kann ein PC/Raspberry nämlich auch.

[Geldesch B. (Firma: haa) (dravr)]

>>Das kann ein PC/Raspberry nämlich auch.
Stimmt das wäre einfacher.
Nur das Ziel ist hier mit dem NIOS eine Bildschirmausgabe über HDMI zu 
erzeugen.

Hätte ich mehr Zeit würde ich die Ansteuerung des HDMI selber in einer 
HDL schreiben und dann über den NIOS ansteuern.

>>warum quälst du dich dann mit einem FPGA?
Ja es quält schon etwas. Hatte aber Glück, dass ich zum einen die HDMI 
TX Demo (HDL) und dann noch video-Demo (HDL+ NIOS programm) gefunden 
habe.

>>Und was wird das, wenns fertig ist?
Werde ich hochladen. Hoffe es ist bald soweit xD

(Tatsächlich sollte ich demnächst einfach mal ne ganz normale 
Schnittstelle, wie SPI oder I2C in HDL schreiben, da habt ihr 100 % 
recht)