Suchergebnisse für "einsen zählen"

Durchsucht Beiträge, Anhänge und Wiki-Artikel.

Forum FPGA, VHDL & Co.
zurücksetzen
Zeitraum alle

72 Treffer für einsen zählen Suchergebnisse für "einsen zählen"

Relevanz Datum
  • Thread

    Weils so schön war : Einsen Zählen II

    78 Downloads haben mich motiviert, nochmal richtig Gas zu geben um die Einsen im Vektor zu zählen ;-) Das Beispiel zeigt, dass man die Synthese doch extrem pushen kann, wenn man nachhilft. Ergebnis: Nur noch 501 Logikelemente im Cyclone II (vorher 1285), max Laufzeit

    haben soll und hab mir den Ursprungsthread angesehen. Und siehe da, es geht gar nicht darum alle Einsen zu zählen, sondern alle aufeinanderfolgenden Einsen. Das legt den Verdacht nahe, daß der riesengroße Aufwand nur in einer völlig falschen Aufgabenteilung fußt. Warscheinlich wird ein Signal abgetastet

    FPGA, VHDL & Co. ·FPGA-User · ·23 Antworten

  • Thread

    einsen im Vektor zählen

    immer so aufgebaut das zu beginn ein oder mehrere Nullen stelen. Gefolg werden sie von mehreren einsen und am ende stehen wieder nullen. Die Verhältnisse variieren aber immer. Es ist quasi ein Impuls mit variabler länge. Ich muss nun die Anzahl der einsen bestimmen. MEine Idee war nun, die Daten über

    Schiebegister in einen Seriellen Datenstrom umzuwandeln, und dann die anzahl der aufeinanderfolgenden einsen zu zählen. Das ist abllerdings eine sehr zeitaufwendige angelegenheit 256 bits zu schieben. Gibt es keine lösung, um die einsen im Vektor aufzuaddieren? Oder hat jemand eine ganz andere Idee?? Danke

    FPGA, VHDL & Co. ·AxelMeineke · ·30 Antworten

  • Thread

    Eine Zahl in Einsen convertieren

    Hallo Leute, ich habe folgende Frage. Ich habe ein Signal, dass beispielsweise den Wert 4 enthält. Diesen Wert möchte ich in 4 "Einsen" umwandeln. Also quasi so: 4 ->"00001111". Ich habe es schon gelöst aber ich würde gerne wissen ob es eine elegantere Möglichkeit gibt? Ich zeig euch mal meinen Weg: [vhdl] signal data : integer range 0 to DATA_WIDTH*2 := 0; signal valid_bytes : std_logic_vector(DATA_WIDTH/8-1 downto 0) := (others => '0'); .... for i in 0 to DATA_WIDTH/8-1 loop if(i < data/8) then valid_bytes(i) <= '1'; end if; end loop; [/vhdl] valid_bytes soll

    FPGA, VHDL & Co. ·Alex · ·16 Antworten

  • Thread

    Zähler

    hochzählen, aber das erste Bit freilassen bzw auf 0 setzten. Das wird dann 1, wenn eine ungerade Anzahl "einsen" im Binärwert stehen !! NICHT eine ungerade Zahl !!! Gruß, Thomas

    Na ja, also doch die einsen zählen. :-/ Irgendwie muss es doch einfacher gehen @Hagen: nein, Greencode ist es wohl leider nicht Wen es noch interessiert, hier sind die ersten ein Paar Werte: 1F,2F,37,3B,3D.3E,4F,57,5B

    FPGA, VHDL & Co. ·kest · ·45 Antworten

  • Datei

    top_zahl_einsen.vhd

    - 1 downto 0); o_valid_bytes_gustl : out std_logic_vector(G_DATA_WIDTH/8 - 1 downto 0) ); end top_zahl_einsen; architecture rtl of top_zahl_einsen is begin inst_zahl_einsen_alex : entity work.zahl_einsen_alex generic map ( G_DATA_WIDTH => G_DATA_WIDTH ) port map ( i_data => i_data, o_valid_bytes => o_valid_bytes_alex ); inst_zahl_einsen_lothar : entity work.zahl_einsen_lothar generic map ( G_DATA_WIDTH => G_DATA_WIDTH ) port map ( i_data => i_data, o_valid_bytes => o_valid_bytes_lothar ); inst_zahl_einsen_gustl : entity work.zahl_einsen_gustl

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. ·

  • Thread

    Spannungsspitzen in VHDL eliminieren

    ; end Mehrheit; architecture Behavioral of Mehrheit is begin process (din) variable einsen : integer; begin einsen := 0; for i in din'range loop if din(i) ='1' then einsen := einsen+1; end if; end loop; if einsen >= 4 then dout <= '1'; else

    ; end Mehrheit; architecture Behavioral of Mehrheit is begin process (din) variable einsen : integer; begin einsen := 0; for i in din'range loop if din(i) ='1' then einsen := einsen+1; end if; end loop; if einsen >= 4 then dout <= '1'; else

    FPGA, VHDL & Co. ·Rainer · ·46 Antworten

  • Thread

    Bits in Wort zählen

    vorkommen können. BTW: War alles schonmal da... https://www.mikrocontroller.net/search?query=einsen+zählen&forums[]=9

    Detlef _a schrieb im Beitrag #2957158: > einsen zählen kann man auch ohne Schleife, siehe angehängten C-Code. Bekommt das Dein C-Code auch in einem einzigen Takt hin?

    FPGA, VHDL & Co. ·Bronco · ·21 Antworten

  • Datei

    tb_zahl_einsen.vhd

    library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity tb_zahl_einsen is end tb_zahl_einsen; architecture tb of tb_zahl_einsen is constant C_DATA_WIDTH : natural := 64; signal data : std_logic_vector(7 downto 0) := (others => '0'); signal valid_bytes_alex : std_logic_vector

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. ·

  • Thread

    Verständnisfrage zu Fixed-Point Zahlen

    Erm, natürlich muss für "10" am Ende alles mit Einsen aufgefüllt werden *hüstel*

    Ja, da hätte ich noch etwas rumprokeln müssen, also nicht "10" -> mit einsen auffüllen, sondern "1......." mit einsen auffüllen, da erwischt man sowieso auch die -2 :D Aber zu der 2.8 stehe ich noch immer, wenn es um 8 nachkomma-bits geht. Oder nicht?

    FPGA, VHDL & Co. ·Marius S. · ·8 Antworten

  • Thread

    Bits zählen mit Verilog

    Ich suche einen möglichst effizienten Code der aus einem Bitvektor die Anzahl der Einsen bestimmt. Also 10101011100 = 6 Einsen Die Größe des Bitvektors kann dabei (vor der Synthese) eingestellt werden, der Code sollte daher allgemein sein (for-Schleife o.ä).

    überhaupt? Wenn du mit eine For-Schleife nicht zufreiden bist, von mir aus kannst du eine zweite Zähler werwenden. Gruß fredy

    FPGA, VHDL & Co. ·A380 A380 · ·8 Antworten

  • Datei

    zahl_einsen_alex.vhd

    library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity zahl_einsen_alex is generic ( G_DATA_WIDTH : natural ); port ( i_data : in std_logic_vector(7 downto 0); o_valid_bytes : out std_logic_vector(G_DATA_WIDTH/8 - 1 downto 0) ); end zahl_einsen_alex; architecture rtl of zahl_einsen_alex is begin process (i_data) begin for i in 0 to G_DATA_WIDTH/8 - 1 loop if i < unsigned(i_data) then o_valid_bytes(i) <= '1'; else o_valid_bytes(i) <= '0'; end if; end loop; end process; end

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. ·

  • Datei

    zahl_einsen_lothar.vhd

    library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity zahl_einsen_lothar is generic ( G_DATA_WIDTH : natural ); port ( i_data : in std_logic_vector(7 downto 0); o_valid_bytes : out std_logic_vector(G_DATA_WIDTH/8 - 1 downto 0) ); end zahl_einsen_lothar; architecture rtl of zahl_einsen_lothar is begin process (i_data) variable x : std_logic_vector(G_DATA_WIDTH/8 - 1 downto 0); begin x := (others => '0'); x(to_integer(unsigned(i_data))) := '1'; o_valid_bytes <= std_logic_vector

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. ·

  • Datei

    zahl_einsen_gustl.vhd

    library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity zahl_einsen_gustl is generic ( G_DATA_WIDTH : natural ); port ( i_data : in std_logic_vector(7 downto 0); o_valid_bytes : out std_logic_vector(G_DATA_WIDTH/8 - 1 downto 0) ); end zahl_einsen_gustl; architecture rtl of zahl_einsen_gustl is begin process (i_data) begin o_valid_bytes <= (others => '0'); o_valid_bytes(to_integer(unsigned(i_data)) - 1 downto 0) <= (others => '1'); end process; end;

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. ·

  • Thread

    High Zustände eines Bitvectors zählen

    Syntheseergebnis zu optimieren. Das Ergebnis war, das das Synthesetool schon die optimalste Lösung findet. einsen im Vektor zählen http://www.mikrocontroller.net/topic/34231 Weils so schön war : Einsen Zählen II http://www.mikrocontroller.net/topic/34250 MfG Holger

    klar), aber im Endeffekt kann man die Bits der Synthesis nach mit über 200 MHz auf einem Virtex2 zählen und irgendwo aufaddieren (wenn ich mich nicht irre). Im Anhang ist die pdf mit der Waveform, wollte keine .09k BMP Datei uppen.

    FPGA, VHDL & Co. ·noname · ·6 Antworten

  • Thread

    Guter Rauschgenerator in VHDL

    . Im Zweifelsfall sollte man also etwa 800.000 Zufallszahlen generieren lassen, bevor man die Zahlen verwendet. [/c]

    Du kannst aber nicht garantieren, dass es gleichverteilt ist. Wie will man das machen, ohne die Zahlen untersucht zu haben?

    FPGA, VHDL & Co. ·Michael · ·76 Antworten

  • Thread

    Exponentiation

    implementiere. Und momentan bin ich gerade auf der Suche nach einem Algorithmus, der die Exponentiation einer Zahl implementiert (ich weiß, dass es hier um Square and Multiply geht). Jedoch hab ich hier einen Spezialfall und zwar besitzt mein Exponent fast auschließlich einsen (binär gesehen). Und ich weiß, dass

    blockweises überspringen der Einsen passiert. Ein Detektor für bis zu mehreren zig Einsen am Stück müsste ohne Probleme in einem einzigen Takt ablaufen können; falls eine oder mehrere Nullen kommen, wird immer nur die erste bearbeitet

    FPGA, VHDL & Co. ·Andreas Auer · ·10 Antworten

  • Thread

    Speed Optimierung !!!

    end if; elsif(S_REGD(8) = '1' and S_STOP_SEARCH_A = '0' and S_STOP ='0')then if(S_EINSEN_GESAMT_A >= S_MAX_ANZ_EINSEN_A)then S_MAX_ANZ_EINSEN_A <= S_EINSEN_GESAMT_A; FIRST_POS <= POSITION - "000000010100";

    eine BitCount() die mit 56 LE's kombinatorisch arbeitet, ca. 10ns Delay. Thread "Eines im Vektor zählen". Gruß Hagen

    FPGA, VHDL & Co. ·Michael · ·21 Antworten

  • Thread

    1 clk impuls erzeugen

    @Michi: Du kannst aufeinanderfolgende Einsen und Nuller zu zählen und diese Zähler jeweils zurückzusetzen, wenn eine 0 resp. eine 1 erkannt wird. Nun weißt du, wenn z.B. der Einser-Zähler über eine festgelegte Schwelle kommt, dass eine Flanke

    end if; [/vhdl] Ggf. könntest du im else-Zweig, wo der edge_counter hochzählt, auch noch die einsen zählen und nach einer bestimmten Anzahl Einsen die Erkennung wieder scharfmachen.

    FPGA, VHDL & Co. ·Michi · ·10 Antworten

  • Thread

    formell korrekte Summation von Einzelbits

    aber schon im Brunnen liegt, dann sieh dir das an: http://www.lothar-miller.de/s9y/archives/86-Einsen-im-Vektor-zaehlen.html

    17) Bei dieser Rechnung muss ich doch nur das erste und das letzte Bit bearbeiten (z.B. einen "Einser-Zähler" inkrementieren bzw. dekrementieren), die in der Mitte bleiben ja gleich und ändern die Summe nicht. > also müssen alle gespeichert werden. Sehe ich zwar anders, aber du hast das Modul in

    FPGA, VHDL & Co. ·Herbert · ·10 Antworten

  • Thread

    Probleme bei Vivado Tutorial mit State Machine

    viel vorkommt. mir auch. ich verstehe die Aufgabe so, dass du 3 Zustände brauchst. s0,wenn die Zahl der einsen 3*n ist, s1 wenn die Zahl 3*n+1 ist, s2 wenn die Zahl 3*n+2 ist. immer wenn eine neue 1 ankommt gehst du einen Zustand weiter.

    vorkommt. > > mir auch. ich verstehe die Aufgabe so, dass du 3 Zustände brauchst. > s0,wenn die Zahl der einsen 3*n ist, s1 wenn die Zahl 3*n+1 ist, s2 wenn > die Zahl 3*n+2 ist. immer wenn eine neue 1 ankommt gehst du einen > Zustand weiter. Hallo, das mit den 3 Zuständen ist eine gute Idee

    FPGA, VHDL & Co. ·Daniel P. · ·16 Antworten

  • Bild

    Tabelle mit FPGA-Ressourcenbelegung

    Name Slice LUTs (10400) Bonded IOB (170) top_zahl_einsen 15 32 inst_zahl_einsen_alex (zahl_einsen_alex) 5 0 inst_zahl_einsen_gustl (zahl_einsen_gustl) 5 0 inst_zahl_einsen_lothar (zahl_einsen_lothar) 5 0

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. · · Screenshots

    Tabelle mit FPGA-Ressourcenbelegung
  • Bild

    Tabelle der FPGA-Ressourcenauslastung

    Name 1 Slice LUTs (10400) Bonded IOB (170) top_zahl_einsen 87 104 inst_zahl_einsen_alex (zahl_einsen_alex) 26 0 inst_zahl_einsen_gustl (zahl_einsen_gustl) 26 0 inst_zahl_einsen_lothar (zahl_einsen_lothar) 35 0

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. · · Screenshots

    Tabelle der FPGA-Ressourcenauslastung
  • Bild

    Tabelle mit FPGA Ressourcenbelegung

    Name Slice LUTs (10400) Slice (8150) LUT as Logic (10400) Bonded IOB (170) top_zahl_einsen 15 8 15 32 inst_zahl_einsen_alex (zahl_einsen_alex) 5 4 5 0 inst_zahl_einsen_gustl (zahl_einsen_gustl) 5 4 5 0 inst_zahl_einsen_lothar (zahl_einsen_lothar) 5 2 5 0

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. · · Screenshots

    Tabelle mit FPGA Ressourcenbelegung
  • Bild

    Tabelle der FPGA-Ressourcenauslastung

    Name Slice LUTs (10400) Slice (8150) LUT as Logic (10400) Bonded IOB (170) top_zahl_einsen 87 45 87 104 inst_zahl_einsen_alex (zahl_einsen_alex) 26 17 26 0 inst_zahl_einsen_gustl (zahl_einsen_gustl) 26 16 26 0 inst_zahl_einsen_lothar (zahl_einsen_lothar) 35 12 35 0

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. · · Screenshots

    Tabelle der FPGA-Ressourcenauslastung
  • Thread

    Setzen einzelner Stellen eines std_logic_vector

    zuweisen können oder müssen, dann würde man nur sehen : y <= x und es brächte kein "downt to" und die Zahlen. :-)

    können oder müssen, dann würde man nur sehen : y <= x > und es brächte kein "downt to" und die Zahlen. :-) Ja ist so. Ich hatte einen Konflikt aufgrund zweier Prozesse, wo in beidem versucht wurde dem Vektor einen Wert zuzuweisen. In dem einen die Nullen und im anderen die Einsen an genannter Stelle

    FPGA, VHDL & Co. ·Student · ·16 Antworten

  • Thread

    Unterschied zwischen cast und convert bei VHDL Datentypen?

    1111110 > 7 = 11111110 > 8 = 111111110 > 9 = 1111111110 Meinst du jetzt die Längenänderung als Zahl? Das führt zum Chaos, denn die Länge (bzw. die Anzahl von Einsen) als proportional zur Zahl ist rein theoretisch zwar möglich, bedarf aber des Abzählens - und ist praktisch nur Murks. Stell dir mal

    W.S. schrieb im Beitrag #7042600: > Meinst du jetzt die Längenänderung als Zahl? Muss nicht. Man könnte das eben wie mit den 10 Fingern auch machen. Als Beispiel hat das Array immer 10 Bits. Und die Anzahl der Einsen von rechts sagt welcher Wert das ist. "0000111111" =

    FPGA, VHDL & Co. ·Bliad B. · ·58 Antworten

  • Thread

    Sinc3 Filter von VHDL in Bit Logik umsetzen

    kannst du auch mal einen gleitenden Mittelwert bauen. Z. B. ein langes Schieberegister und einen Zähler. Zum Zählerstand addierst du immer den Wert der ins Schieberegister rein geht und subtrahierst den Wert der aus dem Register hinten rausfällt. Der Zählerstand ist dann quasi dein Analogsignal. Und

    übelste Oberwellen hat, ist sicher auch bekannt. Das Nullenzaehlen kann man sich sparen, wenn der "Einser"-Zaehler regelmaessig zb. alle 65536 Takte zurueckgesetzt wird. Dann sind die Anzahl der Nullen eben 65536-Einser-Zaehlerstand. Klar ist ein sinc() kein rect(), der waere natuerlich besser fuer den

    FPGA, VHDL & Co. ·Marc · ·27 Antworten

  • Thread

    Vektorposition im Array auslesen

    Dennis schrieb im Beitrag #2123803: > ..seh nur noch Nullen und Einsen Aber in einer unerwarteten Reihenfolge? Ich vermute, du hast die Indexe char_x und char_y vertauscht: char_y läuft in deinem Zähler schneller als char_x... :-o

    sowas soll mir mein modelsim auch zeigen!!!, nur das die char_x und char_y Werte sich gemaß dem Zähler ändern.

    FPGA, VHDL & Co. ·Dennis · ·14 Antworten

  • Thread

    Hilfe CRC zu verstehen

    versuch's mal: Wo kommen wir zu diesen "Polynomen"? Das in einem Computer nun mal gebräuchliche "Zahlen-Format" sind Binärwerte - dargestellt als Folgen von Nullen und Einsen. Z.B. nehmen wir mal einen 8-stellige Wert wie: 10101010 (binär) = #170 (decimal) Bei der Binär-Darstellung kann jede

    sich wegen des "Aufblähens" der Meldung durch die Multiplikation mit der Primzahl. Wenn du die Einsen und Nullen der Meldung als eine vielstellige Zahl auffasst, so ist die Meldung einschliesslich CRC immer ein Vielfaches dieser Zahl. Wenn ich z.B. Meldungen mit den Inhalten 1, 2, 3, 4, 5, ... mit

    FPGA, VHDL & Co. ·Lennart · ·25 Antworten

  • Thread

    Grenzen der digitalen Pulsweitenmodulation

    einstellbare Pulsfolge vom Typ 0101010... mit bis zu 18 bit, bei denen die Länge der Nullen und Einsen sehr genau einstellbar sein muss. Die Pulslängen betragen 1,2ns bis 2,4ns, einstellbar möglichst fein und reproduzierbar. Die Bits sind mindestens 4. Denkbar wäre eine solche Konstellation: 1,35

    ein schnelles Nachführen des Wertes geht. Joggel E. schrieb im Beitrag #5995672: > Ein 8 Bit Zaehler laeuft mit 16 MHz, Schon mit 6MHz statt 16 kriegt man damit gutes Audio hin.

    FPGA, VHDL & Co. ·Hamburger · ·76 Antworten

  • Bild

    Blockschaltbild einer digitalen Logikschaltung

    inst_zahl_einsen_alex, i_data[7:0], o_valid_bytes0_i, RTL_LT, o_valid_bytes0_i_0, o_valid_bytes0_i_1, o_valid_bytes0_i_2, o_valid_bytes0_i_3, o_valid_bytes0_i_4, o_valid_bytes0_i_5, o_valid_bytes0_i_6, o_valid_bytes0_i_7, inst_zahl_einsen_gustl, o_valid_bytes1_i, o_valid_bytes_gustl[7:0], o_valid_bytes2_i, o_valid_bytes_lothar[7:0], RTL_LSHIFT, RTL_INV, RTL_MUX, RTL_SUB, inst_zahl_einsen_lothar, o_valid_bytes2_i_0, RTL_LT, zahi_einsen_gustl

    in „Eine Zahl in Einsen convertieren“ · FPGA, VHDL & Co. · · Diagramme

    Blockschaltbild einer digitalen Logikschaltung
  • Thread

    ModelSim Simulationsproblem/-frage

    nur. Klappt auch soweit ganz gut, ich krieg schön bei der seriellen Schnittstelle meine Nullen und Einsen raus ... aber es ist irgendwie stressig, die ganze Zeit dranzusitzen und Nullen und Einsen zu zählen und aufzuschreiben.. Gibt es in ModelSim die Möglichkeit, dass ich ein Signal "zusammenfassen" kann oder so, d.h. ModelSim mir die ganzen Nullen und Einsen anzeigt? Wenn wir gerade dabei wären, kann bei ModelSim auch irgendwie Eingänge "belegen"? Also sagen, dass beim seriellen Eingang irgendwas reinkommt, dass dann mein Programm verarbeiten kann?

    FPGA, VHDL & Co. ·andrgrau · ·5 Antworten

  • Thread

    VHDL: Variable in Prozesse

    es gleichzeitig zuzuweisen, ist absolut korrekt und erzeugt keine Probleme. Sonst würde ja ein Zähler auch nicht funktionieren [C] process(clk) begin if rising_edge(clk) then count <= count + 1; end if; end process; [/C] Du darfst also ohne weiteres auch schreiben (count

    nicht. Weiss nicht, ob das so gedacht war, evt. fehlt da noch Code. Und wie schon im Beitrag "Einsen zählen im Vektor" zu lesen ist, man muss dem Compiler nicht alles vorkauen! Ein paar Loops sind schon OK, die Abstraktion darf ruhig etwas höher sein. Das wurde von einem Teilnehmer und mir in exzessiven

    FPGA, VHDL & Co. ·Holger · ·28 Antworten

  • Datei

    DCF_ERROR.vhd

    ungerade sreg(25)) xor sreg(26)) xor sreg(27)) xor sreg(28)) -- Zahl logischer Einsen! or (sreg(24) and (sreg(23) or sreg(22))) -- Fehler durch nicht mögliche Kombinationen or (sreg(27) and sreg(26))) -- Fehler durch nicht mögliche Kombinationen or ----------Kontrolle

    in „Addition mit std_logic“ · FPGA, VHDL & Co. ·

  • Thread

    VHDL E-Funktion oder Potenzfunktion zweier reeler zahlen

    dann einfach e als Kosnstante der Basis eingeben. als Exponent sollte zum Beispiel eine 16 Bit Zahl mit 4 Vorkomma und 12 Nachkomma stellen möglich sein.

    D.h. in Zahlen? 1000 FF / LUTs, 10.000, 50.000 ?

    FPGA, VHDL & Co. ·Thomas · ·13 Antworten

  • Thread

    Hommage an Lothar Miller

    Lothar Miller kann einen Zähler, eine ALU und zwei Schieberegister in einen PLL-Block reinsynthetisieren.

    bleibt. Neben diesen Datenbits, die so übertragen werden, dass maximal 5 aufeinanderfolgende Einsen entstehen, werden auch spezielle Block-Marken übertragen, die im Prinzip eine Protokollverletzung darstellen und aus 6 aufeinanderfolgenden Einsen "01111110" bestehen . Damit kann der Empfänger dann

    FPGA, VHDL & Co. ·Lothar Miller Fan · ·116 Antworten

  • Thread

    Lauvzeitverzögerungen. Verschiedene Werte bei Quartus und im Oszi.

    Meine Fragen an Kenner: 1. Warum so ein großer Unterschied? 2. Kann man überhaupt die Zahlen aus dem TimeQuest ernsthaft wahrnehmen? Die entstehen doch nicht aus den Messungen, sondern nur analytisch, oder? Sorry wenn die Fragen naiv klingen, habe wenig Erfahrung. Danke im Voraus, wenn

    von Einsen und Nullen.

    FPGA, VHDL & Co. ·IL · ·17 Antworten

  • Thread

    VHDL 95% LUTs, wieso so viele?

    Bild 3 Hab den Synthese-Report mal angehängt. Habe auch mal Testweise das Array mit a 24 einsen und nullen gefüllt -> Bild 4, und interessanterweise braucht er da nur 13% der LUTs :S Könnte mir ein schlauer Kopf Tipps geben woran das liegen könnte :) ?

    kostet dann auch noch einige LUTs zur Decodierung. > Habe auch mal Testweise das Array mit a 24 einsen und nullen gefüllt -> > Bild 4, und interessanterweise braucht er da nur 13% der LUTs :S > Könnte mir ein schlauer Kopf Tipps geben woran das liegen könnte :) ? Statische Daten --> heftigste Optimierung

    FPGA, VHDL & Co. ·Waldemar M. · ·9 Antworten

  • Thread

    Umwandlung und Erstellung von Q7 bzw. Q0.7 in VHDL

    habe das oben beschriebene Problem was ich für die Uni lösen muss. Folgende Aufgabe: Ein 8bit Zähler soll über einen Wertebereich von -1 bis 1 Zählen und den entsprechenden Wert im Q-Format mit Fixpoint ausgeben, mit dem ich dann Berechnungen durchführe. Folgende Vorgaben gibs vom Prof: - 8bit

    weil ja das vorderste Bit gesetzt ist. Richtig müsste die Interpretation heißen: führende Einsen zeigen eine negative Zahl an. >> wie ich das jetzt auf einen std_logic_vector anwenden übertragen >> interpretieren soll. Wie gesagt: nimm einen "normalen" 8-Bit-Vektor und teile dir den Wert

    FPGA, VHDL & Co. ·Torben Gliem · ·10 Antworten

  • Thread

    std_logic_vector to integer

    hatte nur den Sinn das Problem auf den Punkt zu bringen. Ich habe einen RAM und in dem steht ein Zähler-Startwert als 32-Bit-Vektor. Mein Zähl-Integer ist unterschiedlich groß, je nach generic-Einstellung. Dem Zähler wird der 32-Bit-Wert aus dem RAM zugewiesen und dann zählt er runter bis 0. Wenn im

    die 32 Bit eines "vollen" Integers verwendet werden. Und natürlich enthält der dadurch entstehende Zähler jeweils ungültige Zustände. Und wenn man sich vergegenwärtigt, dass ein Zähler von 0..8 eben schon 4 Bits braucht und 7 ungültige zustände hat, wird schnell klar, dass es bei diesem Zähler einen

    FPGA, VHDL & Co. ·Daniel R. · ·21 Antworten

  • Thread

    Bit stuffing / Bit einfügen

    Programmstück schreiben, das Bit stuffing erfüllt. Also ich erhalte eine Datenmenge von Nullen und Einsen, und das Programm soll nach jeweils 5 gleichen Bits jeweils das negierte Bit einfügen. Beispiel: nach fünf Nullen soll eine Eins eingefügt werden. Schreibe das Programm in Xilinx9. Ich habe nur

    > Also ich erhalte eine Datenmenge von Nullen und Einsen, Woher kommen diese Daten? Ist das ein serieller Bitstrom? Wieviele Bits hat ein Paket? Darfst du die Daten zwischenspeichern?

    FPGA, VHDL & Co. ·sandero · ·8 Antworten

  • Thread

    vhdl array / tabelle

    @ Lothar Miller Verstehe ich das richtig, das man in das o die Konstanden Zahlen aus dem Array ausliest? Wie kann ich jetzt den den Array Wert eingeben? (dies müsste ich nach mir mit dem x und dem y machen.) Aber diesen Variablen kann ich ja nur 0 oder 1 zuweisen oder nicht?

    "42",x"43",x"44"));[/vhdl] Wie kann ich jetzt z.B. genau die Zelle auslesen in welcher die hex Zahl 23 steht?

    FPGA, VHDL & Co. ·R. M. · ·18 Antworten

  • Thread

    vhdl: std_logic_vector in Dezimalzahl umwandeln

    Für einen Vektor, der als vorzeichenlose Zahl interpretiert wird, signed im Gegensatz wird als vorzeichenbehaftete Zahl interpretiert. Es sind trotzdem noch Vektoren, deshalb nur der Cast unsigned(Vektor). Für die Umwandlung in integer muss richtig

    > wie ich einen 11Bit Vecor in einen 19Bit umwandle? Einfach links oder rechts Nullen oder Einsen anhängen, z.B. so: vec19 <= "00000000" & vec11;

    FPGA, VHDL & Co. ·Paradigma · ·16 Antworten

  • Thread

    CPLD - Glitches/Spikes-Problem

    Wackelkontakt oder so. Denn deine Statemachine läuft unabhängig von deinen Eingängen, ist ja nur ein Zähler mit 4 Zuständen und deine Daten ein einfaches Schieberegister.

    systematischen Fehler, was ich nicht glaube, da z.B. bei Vorbelegung von DOUT mit 8 Nullen oder 8 Einsen genau diese dann auch ausgegeben werden).

    FPGA, VHDL & Co. ·Peter · ·16 Antworten

  • Thread

    GAL: Decoder 8Bit/3xBCD

    20 Total Nodes: 0 Average P-Term/Output: 12 Was heisst die Zahl vor /, und was die Zahl danach? MfG Camel PS: Thx, for help again!

    und die vier mit der hohen Zahl kann er nicht fitten, daher UNASSIGNED, der Rest klappt.

    FPGA, VHDL & Co. ·Camel · ·25 Antworten

  • Thread

    Bitvector in VHDL

    Hallo leute die Aufgabe ist folgende:zählen wieviele Bits in einem Bitvector auf 1 gesetzt sind und sie anschließen rechtsbündig ausgibt also beispiel a=100101101 conv(a)=000011111 hat da einer ne idee wie man das realisieren kann in

    Conv funktion den Vector mit 1 dann rechtsbündig habe. Die andere funktion wandelt die integer zahl in einen Bitvector um 01101 => 3 einsen 2^3-1=7 => 0111 so hab ich mir das vorgestellt!!!

    FPGA, VHDL & Co. ·der Türke · ·7 Antworten

  • Thread

    Differenzengleichung in VHDL

    Moin... Welches Ergbnis erwatest du denn für eine 10-Bit Zahl, irgendeine, wenn du 11-bit nach rechts verschiebst? -- Sven Johannes

    aufnimmst, desto mehr reagierst Du auf den Eingang. Ines PS: Ich übernehme keine Gewähr für die Zahlen, die ich da gerade in den Mund - ähh in die Finger??? :-) - genommen habe. Ich habe sie nur überschlagen.

    FPGA, VHDL & Co. ·Thomas · ·59 Antworten

  • Thread

    optimale PWM erzeugen

    hoch Wenn du jedoch 65536 unterschiedliche Einstellmöglichkeiten brauchst also sozusagen 65536 Einsen oder Nullen (und jede Abstufung dazwischen bzw. 1/65536) dann wäre die mögliche Frequenz ca. 65536/4=16384 geringer. Was du brauchst und wieso kannst nur du wissen.

    dem Sigma-Delta klingt gut. J. S. schrieb im Beitrag #2537263: > Man nimmt dann einfach einen Zähler, der die Differenz > zwischen Ist- und Solwert aufaddiert und steuert das höchstwertige Bit > als Vergleichswert an den Eingangswert heran. D.h. der Zähler zählt nicht konstant, sondern mit der

    FPGA, VHDL & Co. ·BB · ·9 Antworten

  • Thread

    Addition & Multiplikation mit FPGA

    zaehler <="001"; when "0101" => error <= '1'; zaehler <="010"; when "0110" => error <= '1'; zaehler <="010"; when "0111" => error <= '1'; zaehler <="011"; when "1000" => error <= '0'; zaehler <="001"; when "1001" => error <= '1'; zaehler <="010"; when "1010" => error <= '1'; zaehler <="010"; when "1011" => error <= '1'; zaehler <="011"; when "1100" => error <= '1';

    FPGA, VHDL & Co. ·D. E. · ·58 Antworten

  • Thread

    Effizienter popcount

    für eine Transformation (FPGA Bildverarbeitung) ein Popcount, welches aus einem 80-bit-Array die Einsen zählt und als Stream ausgibt (II=1). Ich verpacke das ganze in AXI4-Streams (Input: 80-bit, Output 7-bit). Mein bisheriger Ansatz bestand aus dem folgenden Snippet: [vhdl] for idx

    Stufe kannst du die 2-Output LUTs nur nutzen um 3 Inputs zusammenzufassen. Das gibt dann 27 2Bit Zahlen die du zusammenfassen musst. Davon kannst du mit je 4 6-Input LUTs eben 3 Stueck verarbeiten. Damit hast du 2 Logic Levels und es bleiben dir 9 4Bit Zahlen. Spaetestens hier musst du richtige Addierer

    FPGA, VHDL & Co. ·Dominik N. · ·10 Antworten