Verilog VGA-Text , 80x30 umgesetzt für das DE1.

[peter (Gast)]

Hallo, guten Tag.

Ich habe hier ein VGA-Text 80x30(Verilog) der von Micha stammt 
,umgesetzt auf dem DE1-Board. Im Test lasse ich den Bildschirm immer 
wieder neu beschreiben.
Die Datei Screen.hex ist der Inhalt der Angezeigt wird.
Es ist ein Charrom und ein Screenram vorhanden.

Diesen Screen im RAM beschreibe ich in einer Schleife immer wieder neu.
Die Schleife habe ich ausgebremst, sonst kann man es wegen der hohen 
Geschindigkeit nicht sehen.

Am Ende 80. Zeichen(rechte Rand), kann man die letzten 2 Pixelreihen 
nicht erkennen, sind abgeschnitten. Am linken Rand scheint es so, als 
wenn man das VGA-Bild noch nach rechts verschieben könnte vom Programm 
aus.
Bloss ich finde kein Anfang, an welcher Zeitschraube ich da drehen kann.

Wer kann an den Zeiten im Programm etwas drehen??

Anderes Thema:
Im VHDL kenne ich mich nicht so aus.
Es müsste auch zu VHDL umsetzbar sein?

Danke.
Gruss

Im Anhang ist ein Set den man  compilieren kann.

`include "rom.v"
`include "ram.v"

module vga_text(
 input  clock,      
 output hsync,
 output vsync,
 output reg[3:0] red,
 output reg [3:0] green,
 output reg [3:0] blue
);

wire clk;
wire [7:0] char;
wire [7:0] dat;
wire [9:0] charLin;

wire h_enable;
wire v_enable;
wire vid_enable;

reg [16:0] qc;
reg [32:0] cnt;
reg  Pixel;
reg [9:0]  CounterX; // 10 Bit, range 0..799
reg [9:0]  CounterY; //  10 Bit, range 0..524
reg [11:0] Basis;    // Adr. Zeilenanfang
reg [6:0]  Offs;     // Pos. in Zeile 
reg [11:0] ZPos;     // effektive Zeichenpos. in BWS  
reg [11:0] write_address;    
reg [7:0] dat_w;
reg we;

rom myRom (.addr_a(charLin), .clk(clk), .q_a(dat));   // Zeichensatz
ram myRam (.q(char), .read_address(ZPos), .clk(clk),.write_address(write_address), .d(dat_w),.we(we)); // Bildspeicher

wire CounterXmaxed = (CounterX==800);
wire CounterYmaxed = (CounterY==525);

always @(posedge clock)
begin
  if (cnt <= 10000)
    cnt = cnt + 1;
  else
  begin
    cnt =0; 
    we=1;
    
    write_address=write_address+1;    
    dat_w=dat_w+1;
    
    if (write_address==2399)
      write_address=0;
    if (dat_w==255)
      dat_w=0;    
  end  
end
 
always @(posedge clock)
begin
  qc <= qc + 1;
end
// 50Mhz  2^1 = 25MHz
assign clk = qc[0];

always @(posedge clk) begin 
// Zählen in horizontaler Richtung
  if(CounterXmaxed)
    CounterX <= 0;
  else begin 
    CounterX <= CounterX + 1;
    if (dat & (1 << CounterX[2:0])) 
      Pixel <= 1;
    else 
      Pixel <= 0;
  end

// Zählen in vertikaler Richtung
  if(CounterXmaxed) begin 
    if (CounterYmaxed) CounterY <= 0;
  else CounterY <= CounterY + 1;
  end

  if (CounterX[2:0] == 0) begin
    if (CounterX == 0 && CounterY == 0) Basis <= 0;
    else if (CounterX == 0 && CounterY[3:0]==0) Basis <= Basis + 80;
  end
  
  Offs <= CounterX[9:3];
  ZPos <= Basis + Offs;
end

always @(posedge clk)
begin
  if (vid_enable==1 && Pixel == 0)
    begin
      red = 4'b1111;
      blue = 4'b1111;
      green = 4'b1111;
    end 
    else
    begin
      red = 4'b0000;
      blue = 4'b0000;
      green = 4'b0000;
    end 
end

assign hsync = (CounterX < 655) || (CounterX > 751);
assign vsync = (CounterY < 489) || (CounterY > 491);  

assign charLin = {char,CounterY[3:1]};  // Zeiger fuer Zeichensatz

// Filter für video enable ableiten
assign h_enable = (CounterX > 3 && CounterX < 640);
assign v_enable = (CounterY < 480);
assign vid_enable = h_enable && v_enable;

endmodule

[peter (Gast)]

----------------------------------------
wenn man das VGA-Bild noch nach rechts verschieben könnte vom Programm
aus.
----------------------------------------


natürlich nach links...

Gruss

[peter (Gast)]

Im Anhang habe ich mal das Charset und den Screenram ferig übersetzt für 
ein hineincopieren in einem Array für VHDL als Textdatei falls man mal 
dieses Verilog in VHDL umsetzen möchte. Im Screen steht schon ein Text 
drin, der auch angezeigt wird.

Wenn man die screen.dat zb im Hexeditor "HXD" im 80 Zeilenmodus öffnet, 
kann man schön sehen wie der Text auch auf dem Monitor erscheint. Und 
diese Zellen kann man einfach neu beschreiben während des Betriebes.

Gruss

[Gustl B. (-gb-)]

Klar geht das auch in VHDL, du beschreibst nämlich Hardware.

Zu dem Code:

Welcher Pixeltakt, welche Auflösung? Und dann guckst du ob die Zeiten 
von HSync und VSync stimmen, danach richtet der Monitor den sichtbaren 
Bereich aus.

Da der Code aber auch korrekt sein könnte (hab ich nicht überprüft), 
reicht vielleicht auch eine neue Kalibrierung des Monitors, das geht oft 
durch Drücken der "Auto" Taste.

-gb-

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Gustl Buheitel schrieb:
> Klar geht das auch in VHDL, du beschreibst nämlich Hardware
Ein Dejavu. Wie schrieb ich schon im 
Beitrag "Re: synchrones Ram-Modul imit Verilog."
>>> Denn eines ist klar: wenn es mit Verilog geht,
>>> dann geht es auch mit VHDL. Es ist ja die selbe Hardware!

[peter (Gast)]

Jup, danke.

Beim Autokalibrieren rückt der Screen nach links, aber auch der 
sichtbare Bereich...die fehlende Pixelreihe wird mitgezogen.

Gruss

[peter (Gast)]

--------------------------
Beitrag "Re: synchrones Ram-Modul imit Verilog."
-------------------------

Mit den RAM/ROM-Modulen klappt es jetzt wunderbar über Componenten.

Gruss

[Robert (Gast)]

peter schrieb:
> --------------------------
> Beitrag "Re: synchrones Ram-Modul imit Verilog."
> -------------------------

Es gibt so etwas, das nennt sich Kommentarfunktion!