Forum: FPGA, VHDL & Co. Mit 2. Counter 1. resetten in Abel


von Strangelet (Gast)


Lesenswert?

Hallo,

Für ein "Schulprojekt" arbeite ich momentan mit einem LC4128V CPLD. Da 
ich meine eigentliche Aufgabe schon erfüllt hab möchte ich noch ein 
bisschen mehr aus dem CPLD rausholen. Einen ein-Chip Taktzähler, Der 
Cpld soll dabei vom zählen bis zum 7Segment Anzeigen multiplexen alles 
machen, am ende werd ich sehn was ich für ne Auflösung bei nur 128FFs 
bekomm... Das schwierigste, der Bin to BCD Wandler geht schon. Jetzt 
muss ich noch mit dem einen Takt die Takte zählen und mit dem anderen in 
einem Interwall von 1/4s den Takt ausgeben. Der 2. counter zählt 
immoment mit 1khz damit ich mit ihm auch noch die Leds multiplexen kann. 
Das Problem ist jedoch das ich mit ihm den 1. Counter nicht reseten 
kann.

Hier meine versuche:
1
  cnt7..cnt0 pin ISTYPE 'reg'; " cnt7..cnt0 als Register definieren
2
3
  count = [cnt9..cnt0]; " Deklariert den Vector count
4
5
  cntt7..cntt0 pin ISTYPE 'reg'; " cnt7..cnt0 als Register definieren
6
7
  counttwo = [cntt9..cntt0]; " Deklariert den Vector counttwo
8
9
clk pin 88; "Clockpin1 deklarieren
10
clk2 pin 89; "Clockpin2 deklarieren
11
12
Equations
13
14
"################# Counter1 ######################
15
count.clk = clk;
16
count := count +1;          // Zaehlen
17
18
"################# Counter2 ######################
19
counttwo.clk = clk2;
20
21
  WHEN (counttwo == 256) THEN "Bei 1/4s"
22
{counttwo := 0; count := 0; "hier wird der 1. Takt noch weitergegeben"}
23
  ELSE                       counttwo := counttwo +1;          // Zaehlen

Hier zählen Counter 1 und 2. Counter 2 wird auch zurückgesetzt, Counter 
1 allerdings nicht.

1
rsetbit = pin 58; "pin an LED
2
  
3
  cnt7..cnt0 pin ISTYPE 'reg'; " cnt7..cnt0 als Register definieren
4
5
  count = [cnt9..cnt0]; " Deklariert den Vector count
6
7
  cntt7..cntt0 pin ISTYPE 'reg'; " cnt7..cnt0 als Register definieren
8
9
  counttwo = [cntt9..cntt0]; " Deklariert den Vector counttwo
10
11
clk pin 88; "Clockpin1 deklarieren
12
clk2 pin 89; "Clockpin2 deklarieren
13
14
Equations
15
16
"################# Counter1 ######################
17
count.clk = clk;
18
count := count +1;          // Zaehlen
19
20
  WHEN (rsetbit == 1) THEN {count := 0; rsetbit = 0;}
21
  ELSE                       count := count +1;          // Zaehlen
22
23
"################# Counter2 ######################
24
counttwo.clk = clk2;
25
26
  WHEN (counttwo == 256) THEN "Bei 1/4s"
27
{counttwo := 0; rsetbit = 1; "hier wird der 1. Takt noch weitergegeben"}
28
  ELSE                       counttwo := counttwo +1;          // Zaehlen

Hier wird count1 zwar manchmal resetet aber nur wenn count2 langsamer 
zählt als count1. Denn rsetbit wird zwar durch count 2 gesetzt, 
allerdings auch wieder beim nächsten Takt auf count 2 geresetet obwohl 
ich das doch nirgends angegeben hab, und es ja auch ein Flipflop ist?

Auch viele weitere versuche(resetbit direkt als FF zu deklarieren....) 
haben nie die richtige Funktion gebracht. Kann mir wer helfen?

von Duke Scarring (Gast)


Lesenswert?

Es wird schwierig Dir zu helfen.
Abel 'riecht' eben schon etwas und wird für neue Projekte nur sehr 
vereinzelt verwendet.
Vielleicht kannst Du mal eine kleine Übersichtszeichnung machen, damit 
man sieht, was Du wie zusammenschalten willst?

Wenn ich Dich richtig verstanden habe, willst Du einen Frequenzzähler 
mit einer 7-Segment-Multiplexanzeige bauen.

Duke

von Achim S. (Gast)


Lesenswert?

Hallo Strangelet,

ich bin zwar auch kein Abel-Experte, aber ich denke dein Grundproblem 
besteht darin, dass du zwei voneinander abhängige Statemachines mit 
unterschiedlichen Taktsignalen versorgst. (Den Counter mit Resetlogik 
kann man schon als Statemachine betrachten.)

Jede dieser beiden Statemachines macht nur dann etwas, wenn auf ihrem 
Takt eine positive Flanke kommt. Die Flanken deiner beiden Taktsignale 
haben aber keine feste Beziehung zueinander. Deshalb kann es mal dazu 
kommen, dass count richtig zurückgesetzt wird, wenn zufällig gerade eine 
Flanke auf clk kommt, während count2 den richtigen Wert hat. Aber wenn 
diese Flanke nicht zufällig im richtigen Zeitbereich kommt, wird count 
eben nicht zurückgesetzt. Zuverlässig funktionieren wird das leider nie.

Es könnte vielleicht etwas besser funktionieren, wenn du rsetbit als 
asynchrones Resetsignal für count benutzt. (Gibt es in Abel so etwas wie 
count.ar = rsetbit ?) Allerdings ist auch das keine schöne Lösung und 
wird ab und zu falsch funktionieren.

Wirklich sauber wäre, wenn du die ganze Logik nur mit einem einzigen 
Taktsignal clk_master schalten lässt, das deutlich schneller als clk und 
clk2 ist. Die beiden Eingänge clk und clk2 dürftest du dann nicht mehr 
als Takte verwenden, sondern als "normale Logiksignale". Dann musst du 
für beide eine Flankendetektion einbauen (wenn im letzten Takt von 
clk_master der Wert clk = 0 war, und im aktuellen Takt von clk_master 
ist clk = 1, dann wird count um 1 inkrementiert...). Damit arbeiten 
beide Statemachines mit dem gleichen Takt clk_master, und count kann 
nicht "verpassen", dass count2 gerade seinen Überlauf hatte.

viele Grüße

Achim

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.