effizienterer VHDL Counter

Warum lädst du den Counter nicht mit 31 und lässt ihn auf 0 laufen?

Du hast 2X "-1"-Operation, einmal mit 6 und einmal
mit 7 Bits, macht "13 Bits": Das 2. "-1" wird bei
Dir nur für den Überlauftest verwendet.

Mach mal eine komplette Tabelle mit einem z.B.
2-Bit-Counter + 1 Bit für Überlauf, dann siehst du,
wo man einsparen kann (Hinweis: fang z.B. mit 2^n-1
an zu zählen und zähl runter bis -1 => NEG-Flag
gesetzt).

Hallo,

danke für deine Anwort, ja kann ich theoretisch auch machen würd mir 
auch 2 LEs sparen, aber immerhin...
Ich denke man müsste das Überlauf-Bit effizienter nutzen...

Nein, du sparst nicht 2 LEs, sondern 6; d.h. Du hast 7 LEs
inkl. Überlaufflag. (+ evtl. nach ein weitere LE für sonst.
Statusinfos, macht also 8 LEs).

Ok, wenn ich dich richtig verstehe, soll ich einen von den zwei Countern 
streichen. Diesen bis -1 dekrementieren...und nehme dann das neg Flag 
für meinen Nulldurchlauf.

Hallo,
ich habe jetzt für meinen Zähler nur den Ausdruck cnt := ( '0' & cnt )-1 
verwendet. Allerdings muss ich meinen zu ladendenden Wert (load) in eine 
Variable legen und diese dann zuwweisen...
Kann ich noch was vereinfachen?

Beschreibe mal ganz exakt, was dein Counter können soll.
Also laden mit Flanke oder Pegel von "load"..?
Start mit Flanke oder Pegel von "start"..?
Zählen von 31 Takten und dann im nächsten Takt "overrun" auf High.. oder 
sind es 32 Takte und dann "overrun" auf High.

Und wenn du mit Signalen statt Variablen arbeitest, dann bist du auch 
gedanklich "näher" an der Hardware :-)

Danke für deine Antwort. Der Counter soll wenn dieser enabled ist 32 
Taktzyklen runterzählen und anschließend beim Nulldurchlauf  ein Flag 
setzen (roll over zero flag). Der Counter soll mit einem festen Wert 
geladen werden können, quasi mit den 32 Zyklen. Wenn die 32 Zyklen 
runtergezählt sind soll mit dem overrun bit einen Takt lang ein Flag 
gesetzt werden. Es passt ja auch alles wunderbar nur ich brauche halt 
einfach zu viele LEs im Vergleich zum IP Core von Altera.

Also wenn ich dich richtig verstehe, dann willst du 32 mal zählen und 
erst mit dem 33. Takt wird der Überlauf gesetzt und bleibt so lange 
gesetzt, bis der counter neu gestartet wird.

Dann würde ich einen Zähler machen, der von 31 auf 0 zählt (oder 
andersrum) und mit Erreichen des Vergleichswertes das Overrun-REGISTER. 
setzen, welches dann erst einen Takt später seinen Zustand ändert.

Dann hast einen 5-Bit Zähler, der bei erreichen von 0 (oder 31) EINEN 
Takt später einen Overrun auslöst.

Danke für deine Antwort. Hochzählen würde genauso funktionieren. Dein 
Design benötigt aber auch noch 11 LEs, so wie meines...Hmm, ich habe auf 
meinem MAX3000 nur noch 8 LEs frei...

Ja richtig, nur das mein zero Flag auch nur solange aktiv ist, solange 
der Counter den Wert 0 hat, also genau einen Takt lang.

chris h. schrieb:
> Ja richtig, nur das mein zero Flag auch nur solange aktiv ist, solange
>
> der Counter den Wert 0 hat, also genau einen Takt lang.

Also du willst, dass es nur EINEN Takt lang aktiv ist?

Ja genau, nur solange der Counter den Nulldurchgang hat...

Brauchst du das Enable-Signal unbedingt? Und wenn ja, muss das jederzeit 
den Zählvorgang anhalten können?

Ja, das enable muss nach dem load signal die zweite Prio haben. Es 
schaltet den Zählvoragng ein und aus.

also unterbricht auch einen aktiven Zählvorgang? Oder setzt diesen 
zurück oder was macht das?
Ist Laden auch ohne Enable erlaubt? Also steuert enable nur das zählen?

Ja, wenn enable weg ist bricht das Zählen auch ab. Laden ohne enable ist 
erlaubt...nur das Zählen läuft über den enable.

Wenn load den Counter zurücksetzt, aber er nicht losläuft, solange 
enable nicht aktiv ist. Und ein inaktives enable den Counter ebenfalls 
abbricht, dann haben meines Erachtens doch enable und load die gleiche 
Funktion, oder nicht?

probier mal sowas aus:
Ist ein bisschen gemurkst, aber könnte evtl klein werden

1

process (clk, aclr, load)

2

begin

3

   if ((aclr  = '1') or (load = '1')) then

4

     cnt <= "000000";

5

   elsif (rising_edge(clk)) then

6

     if enable = '1' then

7

        cnt <= cnt+1;

8

        if cnt(5) = '1' then

9

          cnt <= "111111";

10

        end if;

11

     end if;  

12

   end if;

13

end process;

14

cout <= cnt(5) and not cnt(4);

ja, genau genommen schon...

Ja genau so in etwa, danke für den Tipp.

Lothar Miller schrieb:
> Man sollte genau wissen, welche Fußanglen da auftauchen können...

... darum auch mein Hinweis...

Schlumpf schrieb:
> Ist ein bisschen gemurkst

Hallo Zusammen,
falls es noch aktuell ist, hab ich meine Version angehängt.
Weiss zwar nicht wie groß der in einem MAX3000 wird aber funktional 
enspricht er deinen Vorgaben.
Vielleicht könnte ihn mal jemand für einen MAX3000 synthetisieren und 
Posten wie viel LEs es sind?

Mfg Dennis