-
Thread
Warning sequential type is unconnected
<= (0=>irq_1, 1=>irq_2, 2=>irq_3, 3=>irq_4, 4=>irq_5, 5=>irq_6, OTHERS=>'0'); end if; end process; dout <= irqReg(15 downto 0) when rd_irq='1' else (others=>'Z'); end BEHAVIORAL;
(rd_irq='1' and irq_4='1') else (x"00" & "00" & "010000") when (rd_irq='1' and irq_5='1') else (x"00" & "00" & "100000") when (rd_irq='1' and irq_6='1') else (others=>'Z'); end BEHAVIORAL; Grüße Daniel
-
Thread
Verständnisproblem: Variablen in Prozessen
when others => TEMP_OUT := "01"; end case; SI <= TEMP_OUT(0); -- Kopie ins Summenbit COUT <= TEMP_OUT(1); -- Kopie ins Carry-Bit end process P1; end ARCH1; [/vhdl]
"111" => COUT <= '1'; SI <= '1'; when others => COUT <= '0'; SI <= '1'; end case; end process P1; [/vhdl] Da sehe ich gleich, wie Carry und Sum sich verhalten. Das scheint mir sogar noch besser lesbar ;-)
-
Thread
LC Display Initialisierung (VHDL)
"; --100us when "0010" => sig_init_out <= "0000110000"; delay_time <= "00000011001"; --100us hier muss man nicht warten, sicherheit when "0011" => sig_init_out <= "0000111000";-- 8bit
an :-) when "0111" => sig_init_out <= "0000001111";-- display on, curser on, blink on delay_time <= "00000001010"; --42us when "1000" => init_suc <= '1'; when others
-
Thread
Nexys II Board mit Intel Flash
* -- State: IDLE --************************************************************* when IDLE => if DBIN = "00110000" then --ASCII: 0 cnt <= (others => '0'); toggle<= '0'; s_state <= wri;
: Reset RS232 --************************************************************* --when wri0 => -- ce <= '0'; -- s_state <= wri; when wri => RD <= '0'; WE <= '1'; CE
-
Thread
Suche Befehl eine einzelne Flanke
Anhang): [vhdl] -- Register signal state0, state1, state2: std_logic_vector(7 downto 0) := (others => '0'); signal key_pressed_old: std_logic_vector(7 downto 0) := (others => '0'); signal key_pressed: std_logic_vector(7 downto 0) := (others => '0'); -- Taster mit langsamem Takt einlesen
range loop state := state2(i) & state1(i) & state0(i); case state is when "000" => key_pressed(i) <= '0'; when "001" => key_pressed(i) <= '0'; when "010" => key_pressed(i) <= '0'; when "100" => key_pressed(i) <= '0'; when others
-
Thread
1-Bit ALU -- geht es besser?
variable ERG : std_logic_vector(n-1 downto 0); variable ZERO : std_logic_vector(n-1 downto 0) := (others => '0'); begin case F is -- AND when "00" => ERG := E_AND; --CA AND CB; -- OR when "01" => ERG := E_OR; --CA OR CB; -- NOT B when "10" => ERG := E_NOT; --NOT CB; -- A + B + INC when "11" => ERG := E_SUM; when others => ERG := (others => '-'); end case; -- Flags FLAG_N <= ERG(n-1); if ERG = ZERO then FLAG_Z <= '1'; else FLAG_Z
-
Thread
Probleme mit Portzuweisung in der Entity
-- CEn <= CEn_ESPM; -- OEn <= OEn_ESPM; when "0010" => --Write (Flash_Addr_gen + UART) Data_io(15 downto 8) <= (others => '0'); Data_io(7 downto 0) <= Data_UART; Data <= (others => 'Z')
CEn <= CEn_Chip_Erase; -- OEn <= OEn_Chip_Erase; when others => Data_io <= (others => 'Z'); Data <= (others => 'Z'); Addr <= (others => '0'); WEn(0) <= '1'; --
-
Thread
Verständnissproblem sequeziell/parallel
beschreiben: process(Clk) begin if rising_edge(CLK) then if Reset = '1' then Reg0 <= (others=>'0'); Reg1 <= (others=>'0'); Reg2 <= (others=>'0'); Reg3 <= (others=>'0'); elsif Write = '1' then case Addr is: when "00" => Reg0 <= Input; when "01" => Reg1 <= Input; when "10" => Reg2 <= Input; when "11" => Reg3 <= Input; when others => null; end if; end if; end process; Reset & Addr sind in diesem Fall zwei Signale, die aber nicht in FF
-
Thread
Dynamische Zuweisung VHDL
temp_old <= 0; WHEN "0001" => temp_old <= 15; WHEN "0010" => temp_old <= 14; WHEN "0011" => temp_old <= 13; WHEN "0100" => temp_old <= 12; WHEN "0101" => temp_old <= 11; WHEN "0110" => temp_old <= 10; WHEN OTHERS => temp_old <= 0; END CASE; END IF; END PROCESS; [/vhdl] Dann später innerhalb dieser Architektur möchte
-
Thread
Simulation digitaler Rauschgenerator
(5)) when (rst = '0') else '0'; invChain_osc1(7) <= not(invChain_osc1(6)) when (rst = '0') else '0'; -- signle inverter short_feedback_osc1 <= not(invChain_osc1(invChain_osc1'left)) when (rst =
_2(0)) when (rst = '0') else '0'; invChain_secondBlock_2(2) <= not(invChain_secondBlock_2(1)) when (rst = '0') else '0'; invChain_secondBlock_2(3) <= not(invChain_secondBlock_2(2)) when (rst = '0') else
-
Thread
Temperatursensor ADT7420 auslesen
<= send_stop; when two_byte_read => first_byte_sent <= '1'; state <= two_byte_read; when others => state <= idle; end case; -----------------------------------------------------------
when loop_again_send_stop => scl <= '1'; sda_tmp <= '1'; state <= idle; ------------------------------------------------------------------------- when others => state <= idle
-
Thread
FSM States in "if" oder "case" statement schalten
<= Next_State; counter <= "00000"; end if; case counter is when "01001" => Current_State <= Next_State; when "10011" => Current_State <= Next_State; when "10100" => Current_State <= Next_State; when others => end case; end if;
(clk)then counter <= counter + '1'; if counter = "10100" then -- 20 counter <= (others => '0'); end if; case counter is when "01001" => Counter_State <= S1; when "10011" => Counter_State <= S2; when "10100" => Counter_State <= S0; when others
-
Thread
RS232 und Tastatur zusammenbringen?
CLK RxRegister <= DataSR(1) & RxRegister(10 downto 1); end if; case PS2RXState is when IDLE => RxRegister <= (others=>'1'); RxActive <= '0'; DataReady <= '0'; RxTimeout <= 0; if (DataSR(1) = '0' and ClkSR(1) = '1') then -- STARTBIT erkannt PS2RXState
CLK RxRegister <= DataSR(1) & RxRegister(10 downto 1); end if; case PS2RXState is when IDLE => RxRegister <= (others=>'1'); RxActive <= '0'; DataReady <= '0'; RxTimeout <= 0; if (DataSR(1) = '0' and ClkSR(1) = '1') then -- STARTBIT erkannt PS2RXState
-
Thread
SPI "stufenweise" auswerten
(15 downto 2); when others => end case; end process; [/vhdl]
when others => end case; end process; VerteilMEM : process(Takteingang) begin if rising_edge(Takteingang) then Modul1mem <= Modul1; Modul2mem <= Modul2; Modul3mem <= Modul3
-
Thread
Outputsignal bleibt gleich
lfsr(9) xnor lfsr(6); when others => null; end case; lfsr <= std_logic_vector(unsigned(lfsr) sll 1); --shifting all bits to left by 1 lfsr_out <= lfsr(WIDTH - 1); --MSB to output lfsr <= lfsr
anstoßen ... when others => null; end case; lfsr <= std_logic_vector(unsigned(lfsr) sll 1); -- wenn lfsr in der Sensitivliste steht, dann wird hier
-
Thread
Shifter-Register Problem
begin wait until rising_edge(CLK); if(RESET='1') then E_RE <= (others=>(others=>(others=>'0'))); E_IM <= (others=>(others=>(others=>'0'))); RX_STOP <= '0'; elsif(RXSTATE=5) then E_RE <= SHIFTER_RE; -- Data parallel
ZUSTAND <= S_OUT; end if; when S_OUT => ZUSTAND <= S_STOP; when S_STOP => ZUSTAND <= S_WAIT; when OTHERS => ZUSTAND <= S_WAIT; end case; if (RESET ='1') then ZUSTAND <= S_WAIT
-
Thread
Grundsatzfrage zum Umgang mit RAM
Beispiel 2: Wie (1) nur aufgetrennt in Kombinatorik und Speicher [vhdl] signal count_q := (others => '0'); signal next_count; process(clk) begin if rising_edge(clk) then count_q <= next_count; end if; end process; next_count <= (others => '0') when count_q = "1111" else
immer noch bei 0 beginnt muss der initwert eins vorgezogen werden [vhdl] signal count_q := (others => '1'); --init eins vor signal next_count; process(clk) begin if rising_edge(clk) then count_q <= next_count; end if; end process; next_count <= (others => '0') when count_q = "1111
-
Thread
FSM von ISE nicht erkannt
<= 6; when 6 => folgezustand <= 7; when 7 => folgezustand <= 8; when 8 => folgezustand <= 9; when 9 => folgezustand <= 10; when 10 => folgezustand <= 11; when 11 => folgezustand
<= 24; when 24 => folgezustand <= 25; when others => folgezustand <= 0; end case; end process zustandsermittlung; ausgabe: process(zustand, befehl_intern) begin sid_out <= befehl_intern
-
Thread
LCD Initialisieren
-1ms 0 auf Disply schreiben when "1010" => sig_init_out <= "1100000";-- delay_time <= 50000; --1ms when "1011" => init_suc <= '1'; when others => null; end
; --100us when "1101" => init_suc <= '1'; when others => null; end case; delay_nr := unsigned(delay_nr)+1; end if; end if; end process; end struct;
-
Thread
VHDL Einsteiger: State-Machine?
State <= Running; when Running => ALI <= not ALI; AHI <= not AHI; when others => end case; end if; end
State) begin if rising_edge(IN_COMP) then case State is when Enabled => ALI <= '1'; AHI <= '0'; when others => end case; end if; end process; [/C] Ich bin ein Hardware
-
Thread
[VHDL] Subtrahieren in der FOR-Schleife
STD_LOGIC; Clock : in STD_LOGIC ); signal O: STD_LOGIC_VECTOR(32 downto 0) := (others => '0'); signal Bh: STD_LOGIC_VECTOR(31 downto 0); end ALU; architecture Behavioral of ALU is begin process (A, B, F, O, Clock) begin Z <= '0'; case F is when "000" =
k) <= (A(k) AND '1') OR ((A(k) XOR '1') AND O(k-1)); end if; end loop; when others => end case; end process; end Behavioral;[/vhdl]
-
Thread
ISE: bad synchronous description
<= fussgaenger; end if; when fussgaenger => if timer_2 = 10 then folge_status <= strasse; end if; when others => folge_status <= strasse; end case; end process folge; [/C]
and clk_geteilt = '1' then case status is when strasse => timer_2 <= 0; when warten => timer_1 <= timer_1 +1; when fussgaenger => timer_1 <= 0; timer_2 <= timer_2 + 1; when others
-
Thread
Bug in Quartus 21.1?
ISE über die fehlenden Fälle (ISE meldet sogar ein erkanntes MUX, perfekt!). Mit der Erweiterung "when others" läufts dann, was aber der Erweiterung von "else <= '0'" oÄ bei deinem Code entspricht. Bleibt also nur die Frage, warum Quartus mit einer CASE-Anweisung ohne Defaults klarkommt, mit deiner
denke ich eiglich nicht mehr nach. Bleibt nur die Frage, warum Xilinx-ISE bei fehlender CASE-"When others"-Anweisung mekert (korrekt!), Quartus aber nicht (Fehler!). Der Rest, d.h. das erzeugte Latch, ist aber bei allen 3 mir gerade zur Verfügung stehenden Umgebungen identisch. (Xilinx-ISE
-
Thread
grosses MUX mit loop erzeugen
Ausgeschrieben ware es so etwas: process(Select, Data) begin case Select is when (255 => '1' , others => '0') => data_out <= Data(255); when (254 => '1' , others => '0') => data_out <= Data(254); when (253 => '1' , others => '0') => data_out <= Data(253); . . . when ( 0 => '1' , others => '0') => data_out <= Data(0); when others => data_out <= (others => '0'); end case; end process; Kann man das irgendwie mit einer loop machen? Danke schon
-
Thread
Synchronous prbblem in VHDL
STD_LOGIC; begin if (DIR='1') then rstemp:='0'; -- conteggio up case count is when "1001" => next_state<="0000"; when others => next_state<=count+1; end case; end if; if (DIR='0') then -- conteggio down rstemp:='0'; case count is when "0000" => next_state<="1001
next_state & DIR; if (SET='1' and SET'event) then case Temp is when "00001" => rstemp:='1'; when "10010" => rstemp:='1'; when others => rstemp:='0'; end case; end if; RST<=rstemp; end process; end Behavioral;
-
Thread
Verdrahtung von Instanzen mit generate
"; --7 when "1000" => var:="0000000100000000"; --8 when "1001" => var:="0000001000000000"; --9 when "1010" => var:="0000010000000000"; --A when "1011" => var:="0000100000000000
"; --F when others => var:="0000000000000000"; end case; return var; end; [/vhdl]
-
Thread
LED-Multiplex aufm dem Spartan-3 von Digilent
; seg(1) <= '1'; seg(2) <= '1'; seg(3) <= '0'; end if; when others => null; end case; end if; case hex is when "0000" => led <= "1000000"; when "0001" => led <= "1111001"; when "0010" => led <= "0100100
<= "1111000"; when "1000" => led <= "0000000"; when "1001" => led <= "0010000"; when others => led <= "1111111"; end case; end process; end Behavioral;
-
Thread
Wie in VHDL formulieren
Gleichungen der folgenden Art schreiben muss, um gleiches auszudrücken? Nö. [vhdl] dl <= ja when cs = '1' and a(4 downto 0) = "000000" else dd when a6 else (others => '0'); [/vhdl]
VHDLneu schrieb im Beitrag #5252477: > ließe sich als > > dl <= ja and dd when cs = '1' and a(4 downto 0) = b"000000" else (others > => '0'); > schreiben? freilich.
-
Thread
Benötigt ein MUX Macrozellen im CPLD?
ram_addr) schalten möchte. [vhdl]process(ramAddr, readRam, temp_trigger) begin case readRam is when '0' => ram_addr <= ramAddr; when others => ram_addr <= temp_trigger(addresswidth-1 downto 0); end case; end process; [/vhdl] Jezt ist es aber leider so das die Synthese nicht (wie
etwas verwirrt. [vhdl]process begin wait until rising_edge(clk); case readRam is when '0' => ram_addr <= ramAddr; when others => ram_addr <= temp_trigger(addresswidth-1 downto 0); end case; end process;[/vhdl]
-
Thread
Sinus Abstand vergrößern, VHDL
dass der n_Sinus die Werte von s_Sinus übernimmt. [vhdl] case wartezaehler is when 0 => n_Sinus <= s_Sinus; when others => n_Sinus <= "00000000"; end case; [/vhdl] solange wartezähler null ist soll n_Sinus die Werte von s_Sinus übernehmen, aber bei
sollte, solange wartezähler null ist: [vhdl] case wartezaehler is when 0 => n_Sinus <= s_Sinus; when others => n_Sinus <= "00000000"; end case; [/vhdl] ich komm da leider nicht mehr weiter wäre ich dankbar wenn mir einer weiterhelfen
-
Thread
SPI-Slave für FPGA sendet keine Daten
); process variable Counter : UNSIGNED(7 downto 0) := (others => '0'); begin wait until rising_edge(Clock); case CurrentState is when State_Reset => CurrentState <= State_WaitBusy; when State_WaitBusy
CurrentState <= State_WaitForTransmit; end if; when others => end case; Tx <= STD_LOGIC_VECTOR(Counter); if(nReset = '0') then CurrentState <= State_Reset; end if; end process;
-
Thread
Division von 2 Vektoren
Ergebniss rechtzeitig berechnet, aber trotzdem um ein Bit verschoben Process(z) begin case z is when 0 => zplus <= 9; when 9 => zplus <= z-1; Rest <=tempA(9 downto 0); Ergebnis<=y; when others => zplus <= z-1; end case; end process;
das Ergebnis auch von diesen beiden Werten ab: [vhdl] Process(z, tempa, y) begin case z is when 0 => zplus <= 9; when 9 => zplus <= z-1; Rest <=tempA(9 downto 0); Ergebnis<=y; when others => zplus <= z-1; end case; end process; [/vhdl]
-
Thread
Datenregister im FPGA
wenn das Ganze dann sowieso kombinatorisch ist geht es auch so: [vhdl] datenbus <= register1 when ce='0' and oe='0' and we='1' and adressbus=0 else register2 when ce='0' and oe='0' and we='1' and adressbus=1 else (others => '0') when ce='0' and oe='
when rd='1' and adressbus=0 else register2 when rd='1' and adressbus=1 else (others => '0') when rd='1' else (others => 'Z'); -- default hochohmig
-
Thread
Ampelsteuerung mit einen Zustandsautomaten mit 2 Prozess-Aufbau
= 1s if cnt = to_unsigned(CNT_OFL, cnt'length) or main_state = idle then cnt <= (others => '0'); else cnt <= cnt + 1; end if; -- Sekunden timer if main_state = reset then -- reset timer time_s <= (others => '0'); elsif main_state
) <= '1'; ledg30 <= (others => '0'); elsif va_colour = gruen then ledr93 <= (others => '0'); ledg30 <= (others => '1'); end if; ledg7_out <= ledg7; ledg30_out <= ledg30
-
Thread
UART
-- sensitive to clock, asynch reset by reset -- -- storage data in internal register when data_ready = 1 -- ----------------------------------------------------------- data_storage : process (clk, reset, sent) is begin if reset = '1' or sent then data_register <= (others => '0');
data_error <= '1'; end if; when others => count_bit <= count_bit + 1; data_register(count_bit-1) <= rx; end case; end if; end if; end process data_read; end behaviour; [/c]
-
Thread
Sequential System Design Using ASM Charts
Noch eine Silbe zum Code: [vhdl] when others => [/vhdl] Es gibt für diese FSM kein "others", weil alle 4 möglichen Zustände manuell auscodiert sind. Siehe dort: http://www.lothar-miller.de/s9y/categories/25-when-others Man kann mit einem solchen "when others" also logischerweise auch niemals eine "irre gelaufene" FSM wieder "einfangen". Daniel P. schrieb im Beitrag #6716960: > Es kam eine Warnung des einige Latches eingefügt wurden. Hinweise
-
Thread
Mehr als eine State Machine pro process/architecture
haben. Also im Prinzip so was: architecture... process() begin case state1 is when x => when y => end case case state2 is when u => when v => end case; end process; process() begin case state3 is when p =>
abgedeckt sind wie es Vorschrift ist. Also so was: process begin ... case state1 is when x => Anweisung_was_auch_immer: state1 <= y; when y => Anweisung_was_auch_immer_2; when others => end case Das gleiche gilt auch für die anderen States. Nun wollte
-
Thread
Fehler durch Signalabgreifen
not(event_6); -- ADC_Trigger<=not(event_5 and not(event_6)); -- -- when others => -- -- end case; -- end if; -- end process; -- -- -- set hv switch -- process(reset, stopper, start_signal, modulator, event_2) -- begin --
POL_22<='0'; -- POL_35<='0'; -- end if; -- -- when others => -- -- end case; -- end if; -- end process; [/vhdl]
-
Thread
Statemachine "überspringt" Zustand
schreiben... rx_read <= '0'; tx_write <= '0'; wr <= '0'; tx_data <= (others => '-'); -- End Default case state is when START => if (rx_ready = '1') then rx_read <= '1'; OPCODE <= rx_data; LED
TOP2(7 downto 0); state <= START; LED <= (others => '0'); end if; when others => if (tx_full = '0') then tx_write <= '1'; tx_data <= std_logic_vector
-
Thread
VHDL feste Strukturen wiederverwenden
verschiedenen states einer FSM immer wieder ansteuern/nutzen. also z.B. [vhdl] CASE state_fsm IS WHEN state_1 => function1(a,b,c); WHEN state_2 => function1(d,e,f); WHEN state_2 => function1(g,h,i); WHEN OTHERS => END CASE; [/vhdl] Wird in diesem Falle für "function1" nur einmal Logik
() ist auch eine Funktion... Du wirst das etwa so machen müssen: [vhdl] CASE state_fsm IS WHEN state_1 => p1<=a; p2<=b; p3<=c; WHEN state_2 => p1<=d; p2<=e; p3<=f; WHEN state_2 => p1<=g; p2<=h; p3<=i; WHEN OTHERS => END CASE; function1(p1,p2,p3); [/vhdl] Allerdings scheint mir
-
Thread
State Machine in VHDL - Design
Output depends solely on the current state process (state) begin case state is when s0 => data_out <= "00"; when s1 => data_out <= "01"; when s2 => data_out <= "10"; when s3 => data_out <= "11"; end case; end process;
. Also ist die Default-Zuweisung next_state<=state die beste Wahl und nicht next_state<=S0. 3. "when others"-Fälle sind bei selbstdefinierten Datentypen total überflüssig. 4. Startzustand-Zuweisung fehlt in der Deklaration (akzeptiert jedes Tool, seit wann eigentlich? 15 Jahren?) Standard-Frame
-
Thread
VHDL / case
BEGIN p1: PROCESS (i,a,b,c) BEGIN -- alle Zweige sind gleichwertig CASE i IS WHEN 3 => z <= a; WHEN 0 TO 2 => z <= b; WHEN OTHERS => z <= c; END CASE; END PROCESS p1; END case_variante;
p1: PROCESS (i,a,b,c) > BEGIN > -- alle Zweige sind gleichwertig > CASE i IS > WHEN 3 => z <= a; > WHEN 0 TO 2 => z <= b; > WHEN OTHERS => z <= c; > END CASE; > END PROCESS p1; > > END case_variante; genau das wurde mir bei der Klausur angestrichen.
-
Thread
Allererster Versuch - Frequenzteiler
2µs when "0111" => count_to <= 100; --div by 200 -> 5µs when others => count_to <= 1; end case; end process; process begin wait until rising_edge(clk); if
80 -> 2µs when "0111" => count_to <= 100-1; --div by 200 -> 5µs when others => count_to <= 1-1; end case; end process; process begin wait until rising_edge(clk);
-
Thread
Schleifen in Zustandsmaschinen
und Daten zuweisen -- address_key <= (others => '0'); address_key <= std_logic_vector(to_unsigned(n,8)); data_in_key <= key_in; load_key_state <= one; when one => -- Adresse inkrementieren n := n + 1;
abgeschlossen done <= '1'; -- Ende load_key_state <= two; end if; when two => null; end case;
-
Thread
Wartezustand in Zustandsautomat
when others => next_state <= st_standby; end case; end process; end Behavioral; Die eingangsseitige Clock läuft mit 3.125 MHz. k1 wird in einem anderen Modul dann über
state, button_down, switch_reg) >begin > if (state = st_k1) then > case button_down(0) is > when '1' => k1_i <= k1_i+1; > when others => k1_i <= k1_i; > end case; > end if; >end process; Hier stecken zwei Fehler drin. 1.) Welchen Wert bekommt k1_i wenn state= st_k1 nicht erfüllt
-
Thread
Multiplexer aus std_logic
habe eine Multiplexer Beschreibung folgender Art gefunden: [vhdl] (...) CASE sel IS WHEN "00" => output <= in0; WHEN "01" => output <= in1; WHEN "10" => output <= in2; WHEN "11" => output <= in3; WHEN OTHERS => output <= 'X'; END CASE; (...) [/vhdl] Meine Frage ist nach dem when others. Macht eine solche Beschreibung Sinn, oder wäre es aureichend when "11" durch when others zu ersetzen? schöne grüße
-
Thread
Hilfsprogramm zur ROM-Erzeugung geschrieben
-> ROM byte range [0xa, 0xe] 11 => x"01", 12 => x"02", 13 => x"03", 14 => x"04", others => x"ff"); begin process (Clk) begin if falling_edge(Clk) then Dint <= ROMdata(to_integer(unsigned(A))); end if; end process; D <= Dint when OE_n='0' else (others => 'Z');
14 => x"06", 15 => x"00", 16 => x"3c", 17 => x"c3", 18 => x"02", 19 => x"00", others => x"ff"); begin process (A) begin Dint <= ROMdata(to_integer(unsigned(A))); end process; D <= Dint when OE_n='0' else (others => 'Z'); end BEHAVIOR; [/vhdl]
-
Thread
Finite-State-Machine
<= STOP ; end if ; when STOP => if (A xor B)=`1` then NEXTSTATE <= START ; end if ; when others => NEXTSTATE <= START ; end case ; end process
<= STOP ; end if ; when STOP => if (A xor B)=`1` then NEXTSTATE <= START ; end if ; when others => NEXTSTATE <= START ; end case ; end process
-
Thread
XC9572XL als GLCD-Treiber mit Stabilitätsschwäche. Code-Problem? EMV? Defekt?
Verhalten konnte ich bis auf in etwa das hier reduziert beobachten: [vhdl] begin c_da <= (others => '0') when c_we = '1' and c_oe = '0' else (others => 'Z'); process begin wait until rising_edge(clk); -- !!! wait until rising_edge(clk); d_flm <= '1';
die geringe Menge an FFs. Ich meinte, das wäre insofern im gelben Bereich: [vhdl] c_da <= c_d when c_oe = '0' and c_we = '1' else (others => 'Z'); m_d <= c_d when writing else (others => 'Z'); m_we <= '0' when writing else '1'; [/vhdl] writing und c_d werden synchron gesetzt. c_oe ist asynchron
-
Thread
Ausgangssignal eines FPGA basierten Tiefpasses
begin if (rising_edge(clk)) then case (current_state) is when waitForADC => filter_rdy_intern <= '0'; data_read_ready <= '0'; sop := (others => '0'); counter_filter := 0;
case (current_state) is --Alles zurücksetzen when startup => result := (others => '0'); temp_result := (others => '0'); counter_filter := 0;