Skocz do zawartości

FPGA (własne programy #4): komunikacja FPGA-Arduino UART-RS485


Pomocna odpowiedź

Musisz wprowadzić dodatkowy sygnał pośredni (wektor czterobitowy), podać go na wejście modułu Binary_To_7Segment, a w innym miejscu przełączać (pseudokod w Verilogu – nie znam tego języka za dobrze, mogą być tam jakieś błędy składniowe):

wire [3:0] nowyWektor = 4'h0;

...

 Binary_To_7Segment SevenSeg_Inst
  (.i_Clk(i_Clk),
   .i_Binary_Num(nowyWektor),

...
   

// Zamiast x=3;y=0;
   nowyWektor = w_RX_Byte[3:0];
...

// Zamiast x=7;y=4;
   nowyWektor = w_RX_Byte[7:4];

 

Nie jestem do końca pewien, czy dokładnie w tym miejscu powinno się odbywać to przypisywanie wartości do nowej zmiennej – Binary_To_7Segment wprowadza pewnie jakieś opóźnienie (działa na zbocze zegara – sprawdź np. w symulacji), dlatego trzeba to zrealizować w ten sposób:
1. Przypisanie nowej wartości do wektora podawanego na wejście modułu Binary_To_7Segment.
2. Odczekanie taktu sygnału zegarowego.
3. Przełączenie zmiennej led_enable.

Ponieważ działasz na razie co takt zegara, to sprowadzi się do tego, że w chwili, gdy uruchamiasz pierwszy wyświetlacz (ten, który ma wyświetlać młodszą część bajtu):

led_enable[0] = 0;

 trzeba przypisać do tego „nowego wektora" starszą połówkę bajtu:

nowyWektor = w_RX_Byte[7:4];

I analogicznie w przypadku drugiego wyświetlacza.

Link to post
Share on other sites

Działa kod w ten sposób, że którakolwiek z wybieranych cyfr jest wyświetlana na obu wyświetlaczach i nie odświeża się prawidłowo (jaśniejsze są aktualne cyfry, a przyciemnione te wyświetlane poprzednio). Próbowałam jakoś zerować poprzednie wyświetlenia poprzez led_enable = 3'b000, ale bez efektu. Zarówno przypisanie starszej połówki bajtu przy wyświetlaniu wyświetlacza dla młodszej połówki bajtu nic nie zmienia.

module UART_RX_To_7_Seg_Top
  (input i_Clk,     // Main Clock
   input i_UART_RX, // UART RX Data
	output o_UART_TX,   // UART TX Data
   // Segment1 is upper digit, Segment2 is lower digit
   output o_Segment_7,	
   output o_Segment_A,
   output o_Segment_B,
   output o_Segment_C,
   output o_Segment_D,
   output o_Segment_E,
   output o_Segment_F,
   output o_Segment_G,
	output reg [2:0] led_enable);
 
   wire w_RX_DV;
   wire [7:0] w_RX_Byte;
	wire w_TX_Active, w_TX_Serial;
   wire w_Segment_7, w_Segment_A, w_Segment_B, w_Segment_C, 
   w_Segment_D, w_Segment_E, w_Segment_F, w_Segment_G;	
	
	reg [3:0] nowyWektor = 4'h00;
	reg wybranyBajtMlodszy = 1'b1;

  // 12,000,000 / 115,200 = 104
  UART_RX #(.CLKS_PER_BIT(104)) UART_RX_Inst
  (.i_Clock(i_Clk),
   .i_RX_Serial(i_UART_RX),
   .o_RX_DV(w_RX_DV),
   .o_RX_Byte(w_RX_Byte));
	
  UART_TX #(.CLKS_PER_BIT(104)) UART_TX_Inst
  (.i_Clock(i_Clk),
   .i_TX_DV(w_RX_DV),      // Pass RX to TX module for loopback
   .i_TX_Byte(w_RX_Byte),  // Pass RX to TX module for loopback
   .o_TX_Active(w_TX_Active),
   .o_TX_Serial(w_TX_Serial),
   .o_TX_Done());
   
  // Drive UART line high when transmitter is not active
  assign o_UART_TX = w_TX_Active ? w_TX_Serial : 1'b1; 	
  
  // Binary to 7-Segment Converter for Lower Digit
  Binary_To_7Segment SevenSeg_Inst
  (.i_Clk(i_Clk),
   .i_Binary_Num(nowyWektor),
	.o_Segment_7(w_Segment_7),	
	.o_Segment_A(w_Segment_A),
	.o_Segment_B(w_Segment_B),
	.o_Segment_C(w_Segment_C),
	.o_Segment_D(w_Segment_D),
	.o_Segment_E(w_Segment_E),
	.o_Segment_F(w_Segment_F),
	.o_Segment_G(w_Segment_G)); 
	assign o_Segment_7 = ~w_Segment_7;  
	assign o_Segment_A = ~w_Segment_A;
	assign o_Segment_B = ~w_Segment_B;
	assign o_Segment_C = ~w_Segment_C;
	assign o_Segment_D = ~w_Segment_D;
	assign o_Segment_E = ~w_Segment_E;
	assign o_Segment_F = ~w_Segment_F;
	assign o_Segment_G = ~w_Segment_G;

	always @(posedge i_Clk)
	begin 
		if (wybranyBajtMlodszy)
		begin
		   led_enable = 3'b000;
			led_enable = 3'b110;
			nowyWektor = w_RX_Byte[3:0];				
		end  		
		else
		begin
		  led_enable = 3'b000;
		  led_enable = 3'b101;
		  nowyWektor = w_RX_Byte[7:4];		  
		end		
		wybranyBajtMlodszy = ~wybranyBajtMlodszy;
	end 	
endmodule

Załączam cały projekt

UART_RX.zip

Link to post
Share on other sites

Napisz bardziej szczegółowo, co dokładnie się dzieje. Jeżeli np. wyślesz liczbę 0xA5, (poprzednio była 0xC2), to co jest wyświetlane na wyświetlaczach. Wspominasz, że na obydwu to samo, to znaczy która połówka bajtu (cyfra szesnastkowa)?

Spróbuj może opóźnić to przełączanie, nie co takt zegara, tylko rzadziej, na początek np. co milisekundę (albo i rzadziej, jeżeli zrobisz przełączanie co 5 sekund, to może łatwiej będzie wyłapać co jest nie tak). Możesz to zrobić na przykład poprzez dodanie licznika i obudowanie wnętrza tego ostatniego ifa. Coś w stylu:

module UART_RX_To_7_Seg_Top
  (input i_Clk,     // Main Clock
   input i_UART_RX, // UART RX Data
	output o_UART_TX,   // UART TX Data
   // Segment1 is upper digit, Segment2 is lower digit
   output o_Segment_7,	
   output o_Segment_A,
   output o_Segment_B,
   output o_Segment_C,
   output o_Segment_D,
   output o_Segment_E,
   output o_Segment_F,
   output o_Segment_G,
	output reg [2:0] led_enable = 3'h0);
 
   wire w_RX_DV;
   wire [7:0] w_RX_Byte;
	wire w_TX_Active, w_TX_Serial;
   wire w_Segment_7, w_Segment_A, w_Segment_B, w_Segment_C, 
   w_Segment_D, w_Segment_E, w_Segment_F, w_Segment_G;	
	
	reg [3:0] nowyWektor = 4'h0;
	reg wybranyBajtMlodszy = 1'b1;
	reg [6:0] licznik = 7'h00;


  // 12,000,000 / 115,200 = 104
  UART_RX #(.CLKS_PER_BIT(104)) UART_RX_Inst
  (.i_Clock(i_Clk),
   .i_RX_Serial(i_UART_RX),
   .o_RX_DV(w_RX_DV),
   .o_RX_Byte(w_RX_Byte));
	
  UART_TX #(.CLKS_PER_BIT(104)) UART_TX_Inst
  (.i_Clock(i_Clk),
   .i_TX_DV(w_RX_DV),      // Pass RX to TX module for loopback
   .i_TX_Byte(w_RX_Byte),  // Pass RX to TX module for loopback
   .o_TX_Active(w_TX_Active),
   .o_TX_Serial(w_TX_Serial),
   .o_TX_Done());
   
  // Drive UART line high when transmitter is not active
  assign o_UART_TX = w_TX_Active ? w_TX_Serial : 1'b1; 	
  
  // Binary to 7-Segment Converter for Lower Digit
  Binary_To_7Segment SevenSeg_Inst
  (.i_Clk(i_Clk),
   .i_Binary_Num(nowyWektor),
	.o_Segment_7(w_Segment_7),	
	.o_Segment_A(w_Segment_A),
	.o_Segment_B(w_Segment_B),
	.o_Segment_C(w_Segment_C),
	.o_Segment_D(w_Segment_D),
	.o_Segment_E(w_Segment_E),
	.o_Segment_F(w_Segment_F),
	.o_Segment_G(w_Segment_G)); 
	assign o_Segment_7 = ~w_Segment_7;  
	assign o_Segment_A = ~w_Segment_A;
	assign o_Segment_B = ~w_Segment_B;
	assign o_Segment_C = ~w_Segment_C;
	assign o_Segment_D = ~w_Segment_D;
	assign o_Segment_E = ~w_Segment_E;
	assign o_Segment_F = ~w_Segment_F;
	assign o_Segment_G = ~w_Segment_G;

	always @(posedge i_Clk)
	begin 
		licznik <= licznik + 1;
		if (licznik == 120) begin
			licznik <= 0;
			if (wybranyBajtMlodszy)
			begin
				nowyWektor = w_RX_Byte[3:0];				
			end
			else
			begin
			  nowyWektor = w_RX_Byte[7:4];		  
			end		
			wybranyBajtMlodszy = ~wybranyBajtMlodszy;
		end
		if (licznik == 0) begin
			if (wybranyBajtMlodszy)
			begin
				led_enable = 3'b101;
			end
			else
			begin
			  led_enable = 3'b110;
			end		
		end
	end
endmodule

Nie mam przy sobie płytki, to tego nie przetestuję na razie, ale napisz dokładne objawy, to znajdziemy przyczynę.

 

Link to post
Share on other sites

Przed twoim postem na obu wyświetlaczach wyświetlała się ostatnio wybrana cyfra, czyli jak np. przesłałam 47 to widziałam 7 na obu wyświetlaczach i przyciemniony fragment, który został po 4 na obu wyświetlaczach.

Na tutorialu są wpisywane liczby dziesiętnie. Nie wiem jak miałabym przekazywać liczby szesnastkowe przez terminal (serial port).

Po wprowadzeniu twoich modyfikacji następuje wpisanie starszej połówki bajtu do wyświetlacza oznaczonego led_enable = 3'b110 (bez fragmentów po poprzedniej cyfrze), a drugi wyświetlacz aktualizuje się tą samą cyfrą (przeznaczony dla starszej połówki bajtu), ale są fragmenty przyciemnione tej młodszej połówki bajtu na tym wyświetlaczu.

https://mega.nz/file/agVDUaSC#72TnbOn3oWcbfRyOSIgCjQ8cj_fh7dPJ_gKn4Y_wGB4

Krótki film pokazuje jak to wygląda, ale niezbyt widać te stare "przyciemnione" fragmenty. Wybierane 1->2->3->4->5->6->7->8->9->0

Edytowano przez monsiw
Link to post
Share on other sites
Zarejestruj się lub zaloguj, aby ukryć tę reklamę.
Zarejestruj się lub zaloguj, aby ukryć tę reklamę.

jlcpcb.jpg

jlcpcb.jpg

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

47 dziesiętnie, to 2F szesnastkowo i to powinno być wyświetlone na wyświetlaczu – tutaj trochę Cię nie rozumiem. Nie ma znaczenia postać liczby w terminalu i tak każda jest przechowywana binarnie i może być wyświetlana w różnych formatach. Niektóre terminale mają możliwość wprowadzania liczb w różnych formatach (zależy od konkretnego programu, którego używasz).

Druga rzecz, która mi się nie podoba, to zachowanie się modułu odbiorczego UART. Byłem przekonany (bez analizy kodu), że moduł ten wystawia na swoje wyjście bajt po otrzymaniu całej ramki danych (a przynajmniej po odebraniu bitów danych). Jednak jest inaczej, ten wektor jest na bieżąco aktualizowany, po odebraniu każdego bitu. Odebranie kompletnego bajtu danych jest sygnalizowane jedynką logiczną na sygnale w_RX_DV. Spróbuj zatem dla testu:
1. Stworzyć nową zmienną, przechowującą bajt danych.
2. Do tej nowej zmiennej przepisać odebrany bajt (czyli w_RX_Byte) w chwili wystąpienia jedynki logicznej sygnału w_RX_DV (sprawdzaj to na zboczu sygnału zegarowego).
3. Do wektora będącego wejściem modułu Binary_To_7Segment („nowyWektor") przepisuj nie bezpośrednio połówki bajtu w_RX_Byte, tylko zamiast niego użyj tej nowej zmiennej, stworzonej w punkcie 1.

Napisz, czy cokolwiek się zmieniło w działaniu projektu.

Link to post
Share on other sites

Teraz nic nie jest wyświetlane (tzn. jest 00 na obu wyświetlaczach)

UART_RX_To_7_Seg_Top.v

module UART_RX_To_7_Seg_Top
  (input i_Clk,     // Main Clock
   input i_UART_RX, // UART RX Data
	output o_UART_TX,   // UART TX Data
   // Segment1 is upper digit, Segment2 is lower digit
   output o_Segment_7,	
   output o_Segment_A,
   output o_Segment_B,
   output o_Segment_C,
   output o_Segment_D,
   output o_Segment_E,
   output o_Segment_F,
   output o_Segment_G,
	output reg [2:0] led_enable = 3'h0);
 
   wire w_RX_DV;
   wire [7:0] w_RX_Byte;
	wire w_TX_Active, w_TX_Serial;
   wire w_Segment_7, w_Segment_A, w_Segment_B, w_Segment_C, 
   w_Segment_D, w_Segment_E, w_Segment_F, w_Segment_G;	
	
	reg [3:0] nowyWektor = 4'h0;
	reg wybranyBajtMlodszy = 1'b1;
	reg [6:0] licznik = 7'h00;
	
	reg [7:0] nowy = 8'h0;

  // 12,000,000 / 115,200 = 104
  UART_RX #(.CLKS_PER_BIT(104)) UART_RX_Inst
  (.i_Clock(i_Clk),
   .i_RX_Serial(i_UART_RX),
   .o_RX_DV(w_RX_DV),
   .o_RX_Byte(w_RX_Byte));
	
  UART_TX #(.CLKS_PER_BIT(104)) UART_TX_Inst
  (.i_Clock(i_Clk),
   .i_TX_DV(w_RX_DV),      // Pass RX to TX module for loopback
   .i_TX_Byte(w_RX_Byte),  // Pass RX to TX module for loopback
   .o_TX_Active(w_TX_Active),
   .o_TX_Serial(w_TX_Serial),
   .o_TX_Done());
   
  // Drive UART line high when transmitter is not active
  assign o_UART_TX = w_TX_Active ? w_TX_Serial : 1'b1; 	
  
  // Binary to 7-Segment Converter for Lower Digit
  Binary_To_7Segment SevenSeg_Inst
  (.i_Clk(i_Clk),
   .i_Binary_Num(nowy),
	.o_Segment_7(w_Segment_7),	
	.o_Segment_A(w_Segment_A),
	.o_Segment_B(w_Segment_B),
	.o_Segment_C(w_Segment_C),
	.o_Segment_D(w_Segment_D),
	.o_Segment_E(w_Segment_E),
	.o_Segment_F(w_Segment_F),
	.o_Segment_G(w_Segment_G)); 
	assign o_Segment_7 = ~w_Segment_7;  
	assign o_Segment_A = ~w_Segment_A;
	assign o_Segment_B = ~w_Segment_B;
	assign o_Segment_C = ~w_Segment_C;
	assign o_Segment_D = ~w_Segment_D;
	assign o_Segment_E = ~w_Segment_E;
	assign o_Segment_F = ~w_Segment_F;
	assign o_Segment_G = ~w_Segment_G;

always @(posedge i_Clk)
begin 
	licznik <= licznik + 1;
	if (licznik == 120) 
	begin
		licznik <= 0;
		if (wybranyBajtMlodszy)
		begin
			if(w_RX_DV)
			begin
				nowy = w_RX_Byte;
			end				
		end
		else
		begin
			if(w_RX_DV)
			begin
				nowy = w_RX_Byte;
			end		  
		end		
		wybranyBajtMlodszy = ~wybranyBajtMlodszy;
	end		
	if (licznik == 0) 
	begin
		if (wybranyBajtMlodszy)
		begin
			led_enable = 3'b101;
		end
		else
		begin
			led_enable = 3'b110;
		end		
	end
end

endmodule
/*
This file converts an input binary number into an output which can get sent
to a 7-Segment LED.  7-Segment LEDs have the ability to display all decimal
numbers 0-9 as well as hex digits A, B, C, D, E and F.  The input to this
module is a 4-bit binary number.  This module will properly drive the
individual segments of a 7-Segment LED in order to display the digit.
Hex encoding table can be viewed at:
http://en.wikipedia.org/wiki/Seven-segment_display
*/
module Binary_To_7Segment(
   input       i_Clk,
   input [7:0] i_Binary_Num,
	output      o_Segment_7,
   output      o_Segment_A,
   output      o_Segment_B,
   output      o_Segment_C,
   output      o_Segment_D,
   output      o_Segment_E,
   output      o_Segment_F,
   output      o_Segment_G
   ); 
  reg [7:0]    r_Hex_Encoding = 8'h00;   
  /* 
  Purpose: Creates a case statement for all possible input binary numbers.
  Drives r_Hex_Encoding appropriately for each input combination.
  */ 
  always @(posedge i_Clk)
    begin
      case (i_Binary_Num) 
        8'd0 : r_Hex_Encoding <= 8'hFC;
        8'd1 : r_Hex_Encoding <= 8'h60;
        8'd2 : r_Hex_Encoding <= 8'hDA;
        8'd3 : r_Hex_Encoding <= 8'hF2;		 
        8'd4 : r_Hex_Encoding <= 8'h66;  		  
        8'd5 : r_Hex_Encoding <= 8'hB6;
        8'd6 : r_Hex_Encoding <= 8'hBE;		  
        8'd7 : r_Hex_Encoding <= 8'hE0;
        8'd8 : r_Hex_Encoding <= 8'hFE;		  
        8'd9 : r_Hex_Encoding <= 8'hF6;
        8'd10 : r_Hex_Encoding <= 8'hEE;		  
        8'd11 : r_Hex_Encoding <= 8'h3E;
        8'd12 : r_Hex_Encoding <= 8'h9C;
        8'd13 : r_Hex_Encoding <= 8'h7A;
        8'd14 : r_Hex_Encoding <= 8'h9E;
        8'd15 : r_Hex_Encoding <= 8'h8E;
      endcase	
		  /*
			not "11111100" when "0000",
			not "01100000" when "0001",
			not "11011010" when "0010",
			not "11110010" when "0011",
			not "01100110" when "0100",
			not "10110110" when "0101",
			not "10111110" when "0110",
			not "11100000" when "0111",
			not "11111110" when "1000",
			not "11110110" when "1001",
			not "11101110" when "1010",		
			not "00111110" when "1011",
			not "10011100" when "1100",
			not "01111010" when "1101",
			not "10011110" when "1110",	
			not "10001110" when others;
			*/		
    end // always @ (posedge i_Clk) 
	 
  assign o_Segment_7 = r_Hex_Encoding[7];
  assign o_Segment_A = r_Hex_Encoding[6];
  assign o_Segment_B = r_Hex_Encoding[5];
  assign o_Segment_C = r_Hex_Encoding[4];
  assign o_Segment_D = r_Hex_Encoding[3];
  assign o_Segment_E = r_Hex_Encoding[2];
  assign o_Segment_F = r_Hex_Encoding[1];
  assign o_Segment_G = r_Hex_Encoding[0]; 
endmodule // Binary_To_7Segment

 

Link to post
Share on other sites

Nie o to mi chodziło, to nie ma prawa działać, raczej coś takiego przewidywałem:

always @(posedge i_Clk)
begin 
  	if(w_RX_DV) 
  	begin
      nowy = w_RX_Byte;
    end
	licznik <= licznik + 1;
	if (licznik == 120) 
	begin
		licznik <= 0;
			if (wybranyBajtMlodszy)
			begin
				nowyWektor = nowy[3:0];				
			end
			else
			begin
			  nowyWektor = nowy[7:4];		  
			end
			wybranyBajtMlodszy = ~wybranyBajtMlodszy;
	end		
	if (licznik == 0) 
	begin
		if (wybranyBajtMlodszy)
		begin
			led_enable = 3'b101;
		end
		else
		begin
			led_enable = 3'b110;
		end		
	end

Na wejściu modułu Binary_To_7Segment powinien być poprzednio używany wektor: .i_Binary_Num(nowyWektor), zamiast i_Binary_Num(nowy).

Link to post
Share on other sites

Teraz efekt jest taki, że oba wyświetlacze aktualizują się starszą połówką bajtu (ostatnio wpisaną cyfrą), ale jeden z nich tą aktualizacje ma przyciemnioną, a na jasno jest wyświetlana "3" na stałe.

Link to post
Share on other sites

Spróbuj znacząco zwolnić przełączanie wyświetlaczy (zmniejszyć częstotliwość), poprzez modyfikację warunku „licznik == 120", zwiększając liczbę po prawej stronie znaku porównania i w razie potrzeby zwiększając liczbę bitów zmiennej licznik.

Zrób test dla częstotliwości przełączania 1000 Hz (nie musi być dokładnie taka, może być zbliżona; mam kod z bliźniaczej płytki Mimas v2, który działał bezproblemowo właśnie z taką częstotliwością, ale nie wyświetlał znaków z UARTa, tylko generowane w kodzie VHDL), ale spróbuj też inne częstotliwości, np. 50, 200 Hz.


Jakie dokładnie wartości przesyłasz? Te same co wcześniej?

Próbowałaś może uruchamiać symulację?

Link to post
Share on other sites

Z CLKS_PER_BIT równym 1250 synteza kończy się z warningami przez co mam obawy wgrywać kod do płytki.

Przy CLKS_PER_BIT=208 nie było znaczących zmian. Licznik(200) i jego bity również zwiększyłam.

Wartości te same co wcześniej.

Nie symulowałam, nie wiedziałabym jak to zweryfikować, ale zobaczę jeszcze.

2021-09-17-12-07-27.jpg

Link to post
Share on other sites

Nie zmieniaj CLKS_PER_BIT, tylko liczbę 120 w warunku „licznik == 120". Daj na początek 12000 (wtedy wyświetlacze będą zmieniane co około 1 ms).

 

Jeśli chodzi o ostrzeżenia, to musiałabyś pokazać dokładnie o jakie chodzi w tym okienku:
image.thumb.png.a8c126b7b0197ba600ee14071ee6450c.png

Ogólnie (bez odniesienia do tego konkretnego projektu), kod z ostrzeżeniami można wgrać na płytkę, będzie działał poprawnie lub nie, nie ma gwarancji. Ale w każdym razie nie zmieniaj tego parametru CLKS_PER_BIT.

Link to post
Share on other sites

Teraz nie zmieniałam CLKS_PER_BIT a po zmianie wartości licznika na 1200 i liczby bitów na 11 jest to samo - na obu wyświetlaczach widnieje ta sama ostatnio wpisana cyfra z tym, że zdecydowanie słabiej na jednym z nich i na tym właśnie na stałe świeci się "3"

Aktualnie mam tylko takie ostrzeżenia przy syntezie:

2021-09-17-14-06-21.jpg

Edytowano przez monsiw
Link to post
Share on other sites

Nic więcej nie modyfikowałaś? Wstaw cały projekt. Teraz wychodzi na to, że nic nie jest odbierane. Reszta kodu też nie działa, bo powinno coś się pokazywać na obydwu wyświetlaczach. Dziwna sytuacja.

 

Możesz do debugowania spróbować użyć LEDów:
1. W pliku UCF dodaj coś takiego

NET "LED[0]"             LOC = P46   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[1]"             LOC = P47   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[2]"             LOC = P48   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[3]"             LOC = P49   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[4]"             LOC = P50   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[5]"             LOC = P51   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[6]"             LOC = P54   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;
NET "LED[7]"             LOC = P55   | IOSTANDARD = LVCMOS33 | SLEW = SLOW | DRIVE = 12;

2. Dodaj nowe wyjście z głównej jednostki projektowej:

output reg [7:0] LED = 8'h00

3. Dodaj przypisanie (może być na zboczu zegarowym)

LED = w_RX_Byte;

 

Na lampkach możesz wyświetlać też inne zmienne, zobaczysz wówczas gdzie jest problem.

Link to post
Share on other sites

EDIT: Teraz nie zmieniałam CLKS_PER_BIT a po zmianie wartości licznika na 1200 i liczby bitów na 11 jest to samo - na obu wyświetlaczach widnieje ta sama ostatnio wpisana cyfra z tym, że zdecydowanie słabiej na jednym z nich i na tym właśnie na stałe świeci się "3"

 

Zaraz po podłączeniu świeci się dioda D3 i D4 i one są na stałe, a D1 i D2 w ogóle. Czyli nie działa zmiana jednej połówki bajtu, aktualizuje się tylko jedna z nich (jeden wyświetlacz)

Konwerter podłączyłam do Header P4

UART_RX1.zip

Edytowano przez monsiw
Link to post
Share on other sites

Wcześniej pisałem, żebyś zmieniła liczbę na 12000, a nie 1200, ale to w tej chwili mało istotne.

 

Te ostrzeżenia zamieszczone powyżej są niepokojące (nie widziałem ich wcześniej), w załączonym projekcie mam tylko cztery, niemające większego znaczenia.

 

Jaką liczbę wysyłasz przez UART? Skoro diody D3 i D4 się świecą, to by oznaczało liczbę 12. To się zgadza?

 

Zrób test – spróbuj na chwilę odłączyć UART, przypisując do zmiennej „nowy" stałą wartość:

 // 	if(w_RX_DV) 
 // 	begin
      nowy = 8'h5A;
 //  end

Napisz, co wtedy jest na wyświetlaczach.

Link to post
Share on other sites

Dołącz do dyskusji, napisz odpowiedź!

Jeśli masz już konto to zaloguj się teraz, aby opublikować wiadomość jako Ty. Możesz też napisać teraz i zarejestrować się później.
Uwaga: wgrywanie zdjęć i załączników dostępne jest po zalogowaniu!

Anonim
Dołącz do dyskusji! Kliknij i zacznij pisać...

×   Wklejony jako tekst z formatowaniem.   Przywróć formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Twój link będzie automatycznie osadzony.   Wyświetlać jako link

×   Twoja poprzednia zawartość została przywrócona.   Wyczyść edytor

×   Nie możesz wkleić zdjęć bezpośrednio. Prześlij lub wstaw obrazy z adresu URL.

×
×
  • Utwórz nowe...

Ważne informacje

Ta strona używa ciasteczek (cookies), dzięki którym może działać lepiej. Więcej na ten temat znajdziesz w Polityce Prywatności.