Buchstaben werden dauernd ausgedruckt auf dem Screen.

[peter (Gast)]

Hallo, guten Tag.
Ich habe hier eine Verilog-Beschreibung mit dem Vga-Text.
Es ist erweitert mit einer RS232 zum PC 19200 Baud.
Es funktioniert auch soweit, nur werden dauernd Buchstaben ausgedruckt 
bis meine Sreen-Abfrage bei 2399 wieder auf "0" und dann geht es wieder 
los.

Die LED_g die ich angeschlossen habe zur Konrolle zeigt auch immer nur 
den einen Buchstaben bis ich den nächsten Buchstaben vom PC übertrage.

Die RS232 läuft mit State.
Ich weiss nicht weiter.
Was muss ich jetzt hier bitte in der Schleife von dem RS232-Modul 
reinsetzen
damit der Kreislauf unterbrochen wird bis zur nächsten Taste.
-----------------------------------------
always @(posedge clock)
begin
  if(rcv_sr >=32)
  begin
    if(write_address < 2399 )
    begin
      we=1;
      write_address=write_address+1;
      dat_w=rcv_sr;
      led_g=rcv_sr;
    end
    else
      write_address=0;
  end
end
---------------------------------------

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

module vga_text_rs232(
 input  clock,      
 output hsync,
 output vsync,
 output reg [3:0] red,
 output reg [3:0] green,
 output reg [3:0] blue,
 output reg [7:0] led_g,
 input reset,
 input RXD
);

parameter rcv_bit_per = 2604; //19200 Buad
parameter half_rcv_bit_per = 1302; 

//--State Definitions--
parameter ready = 2'b00;
parameter start_bit = 2'b01;
parameter data_bits = 2'b10;
parameter stop_bit = 2'b11;

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

wire h_enable;
wire v_enable;
wire vid_enable;
wire CounterXmaxed;
wire CounterYmaxed;

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;

reg [12:0] counter, n_counter;  
reg [3:0]  data_bit_count, n_data_bit_count;
reg [7:0]  rcv_sr, n_rcv_sr;
reg [1:0]  state, n_state;

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

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

always @(posedge clock)
begin
  qc <= qc + 1;
end
// 50Mhz  2^1 = 25MHz
assign clk = qc[0];

always @(posedge clock) 
begin
  if(rcv_sr >=32)
  begin  
    if(write_address < 2399 )
    begin
      we=1;
      write_address=write_address+1;  
      dat_w=rcv_sr;
      led_g=rcv_sr;
    end
    else
      write_address=0;    
  end
end

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 == 1)
    begin
      red = 4'b1111;
      blue = 4'b1111;
      green = 4'b1111;
    end 
    else
    begin
      red = 4'b0000;
      blue = 4'b1111;
      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 > 4 && CounterX < 640);
assign v_enable = (CounterY < 480);
assign vid_enable = h_enable && v_enable;

always @(state, RXD, counter, data_bit_count) begin
  n_rcv_sr  <= rcv_sr;
  n_counter <= counter;
  n_state   <= state;
  n_data_bit_count <= data_bit_count;

  case (state)
  ready: 
    begin
      if(RXD == 0) begin
      n_state   <= start_bit;
      n_counter <= counter + 1;
    end
    else begin
      n_state   <= ready;
      n_counter <= 0;
      n_data_bit_count <= 0;
    end
    end

    start_bit: begin
    
    if(counter == half_rcv_bit_per) begin
      n_state <= data_bits;
      n_data_bit_count <= data_bit_count + 1;
      n_counter <= 0;
    end
    else begin
      n_state   <= start_bit;
      n_counter <= counter + 1;
    end
    end

    data_bits: 
    begin
    if(counter == rcv_bit_per) begin
      n_rcv_sr <= {RXD,rcv_sr[7:1]};
      n_data_bit_count <= data_bit_count + 1;
      n_counter <= 0;
      if(data_bit_count == 8)
        n_state <= stop_bit;
    end
    else
      n_counter <= counter + 1;
    end

    stop_bit: 
    begin
    n_counter <= counter + 1;
    if(counter == rcv_bit_per) 
      n_state <= ready;
    end
endcase
end 

always @(posedge clock or posedge reset) begin
  if(reset == 1) begin
    state   <= ready; 
    rcv_sr  <= 0;
    counter <= 0;
    data_bit_count <= 0;
  end
  else begin
    state   <= n_state;
    rcv_sr  <= n_rcv_sr;
    counter <= n_counter;
    data_bit_count <= n_data_bit_count;
  end
end

endmodule

Danke.
Gruss

[peter (Gast)]

Habe ich vergessen. Es kommt auch immer mit ein Echo rein als 2. 
Buchstabe, welches nicht immer gleich ist, diesma ist es ein "+".

Gruss

[peter (Gast)]

Habe ein Teilerfolg erzielt:
Habe das "we=0" in der schleife nach "else" reingesetzt , das Echo wird 
nicht mehr ausgegeben nur noch die Buchstaben die ich drücke schreiben 
den Screen voll. Sieht schon etwas besser aus....
Jetzt brauche ich bitte die Hilfe, damit der Screen immer nur ein 
Ausdruck vom Buchstaben macht.

Danke.
Gruss

[Gustl B. (-gb-)]

Hier

[verilog]begin
  if(rcv_sr >=32)
  begin
    if(write_address < 2399 )
    begin
      we=1;
      write_address=write_address+1;
      dat_w=rcv_sr;
      led_g=rcv_sr;
    end
    else
      write_address=0;
  end
end[/verilog]

Schreibst du immer rcv_sr in den Textspeicher wenn rcv_sr >= 32. Diese 
Bedingung würde ich so umschreiben, dass das nur dann in den 
Textspeicher geschrieben wird, wenn ein neues Byte/Char empfangen wurde.

[peter (Gast)]

Ja Gustl Buheitel.

Kannst du mal schauen, ich weiss nicht was ich aus dem RS232-Modul als 
abfrage neben kann?
rcv_sr : funktioniert nicht zb : if(rcv_sr>32)

Ich kann kein Befehl da rausfischen. Immer wird der Screen 
vollgeschrieben.

Danke.
Gruss

[peter (Gast)]

--------------------
...Textspeicher geschrieben wird, wenn ein neues Byte/Char empfangen 
wurde.
--------------------

Hm...wie soll ich das machen, es muss ja dann irgendwie angehalten 
werden?

Danke.
Gruss

[peter (Gast)]

Ich habe ein Terminalprogramm, wo ich 1 Buchstaben verschicken kann.
Dieser eine Buchstabe schreibt dann schonden Screen voll bis die Abfrage 
:write_address <= 2399 kommt. Der Screen hat ja 2400 Zeichen.

Mehr sende ich nicht.

Gruss

[Gustl B. (-gb-)]

Ich kann leider kein Verilog. Aber in dem Code gibt es

data_bit_count == 8

Diese Bedingung kannst du verwenden um einmalig den gerade empfangenen 
Buchstaben ins Textram zu schreiben.

always @(posedge clock) 
begin
  if(rcv_sr >=32)
  begin  
    if(write_address < 2399 )
    begin
      we=1;
      write_address=write_address+1;  
      dat_w=rcv_sr;
      led_g=rcv_sr;
    end
    else
      write_address=0;    
  end
end

Da drinnen die Zeile

if(rcv_sr >=32)

ersetzen durch

if(data_bit_count == 8)

Wobei auch das nicht funktioniert. Du musst den Übergang von 
data_bit_count von 7 nach 8 erkennen oder irgendwie eben das Ende von 
jedem Byte. Also z.B. so:

if(data_bit_count == 7 and rcv_bit_per == 2604)

Das wäre also dann das Ende des letzten Bits vor dem Stoppbit, wenn der 
Zähler der Bitzeit auf dem Maximum steht.

[peter (Gast)]

Habe jetzt diese Zählkontrolle für "write_address" rausgenommen, 
trotzdem rattert der Screen voll durch, wenn ich mit dem Terminal nur 1 
Buchstaben sende.

[vhdl]
always @(posedge clk)
begin
  if(rcv_sr >=32)
  begin
    we=1;
    write_address=write_address+1;
    dat_w=rcv_sr;
    led_g=rcv_sr;
  end
  else
    we=0;
end
[vhdl]

Gruss

[Gustl B. (-gb-)]

Ha? Wieso hast du das gemacht? Es geht um die Bedingung bei der 
geschrieben wird. Und die trifft öfter ein als du willst. Eine 
Möglichkeit das zu ändern oder was man grob beschreiben sollte habe ich 
oben geschrieben.

[peter (Gast)]

Danke Gustl, bringt auch nichts.

Grus

[Christian R. (supachris)]

Was sagt denn die Simulation? Da findest du doch solche Fehler schnell.

[Softwareverwickler (Gast)]

Hallo Peter,

Das probelm ist, dass es hier keine möglichkeit gibt, zu erkennen, ob 
ein empfangenes zeichen bereits angezeigt wurde.

Füre noch ein flag ein. es wird gesetzt, wenn ein neues zeichen 
hineingeschrieben wurde, und zurückgesetzt, wenn das empfangene zeichen 
in den bildspeicher komiert wurde. Mein Verilog ist etwas eingerostet, 
abe so in etwa müsste es gehen:

reg newchar;

always @(posedge clk)
begin
  if(newchar == 1)
  begin
    if(rcv_sr >=32)
    begin
      we=1;
      write_address=write_address+1;
      dat_w=rcv_sr;
      led_g=rcv_sr;
    end
    else
      we=0;
   newchar<=0;
end

und beim empfang

case (state)
  ready: 
    begin
      if(RXD == 0 && newchar == 0) begin
      n_state   <= start_bit;
      n_counter <= counter + 1;
    end
   
...

  stop_bit: 
  begin
    n_counter <= counter + 1;
    if(counter == rcv_bit_per)
    begin
      newchar <= 1; 
      n_state <= ready;
    end
  end
endcase
end

[peter (Gast)]

Der Compiler beanstandet, das newchar 2x angesprochen wird als 
Drahtverbindung.
Man kann zwar beliebig abfragen , aber nur einmal zuweisen.

Aber daran liegt es, nur ich finde ausgedrückt keine Beschreibung für 
einen Weg. Eine Testbench braucht man hier nicht weil es an einem Weg 
hapert.

Danke.
Gruss