Digital rechnen in programmierbarer Logik

Do you have a question? Post it now! No Registration Necessary

Translate This Thread From German to

Threaded View
Moin!

Vorweg: Ja, FAQ gelesen, aber leider komme ich nicht weiter.

Ich möchte vier 16-bit Datenwerte miteinander verrechnen, also
addieren und subtrahieren. Da das ganze sehr schnell gehen soll,
möchte ich das nicht mit einem Controller machen, sondern lieber in
Hardware. Die Datenwerte liegen nacheinander an einem Bus an und
sollen jeweils per Clock-Signal übernommen werden. Das ganze soll dann
in etwa so aussehen:

        16bit
          |
          |
          o--- D-FF -----o-----.
  Clk1--- | -----^       |     |
          |             (-)-----------------> 16bit
          |              |     |
          |              |    (+)----.
          |              |     |     |
          o--- D-FF -----o-----´     |
  Clk2--- | -----^                   |
          |                          |
          |                         (-)-----> 16bit
          |                          |
          |                          |
          o--- D-FF -----.           |
  Clk3--- | -----^       |           |
          |              |           |
          |             (+)----------´
          |              |
          |              |
          `--- D-FF -----´
  Clk4-----------^
      
Ein eventueller Übertrag braucht nicht berücksichtigt zu werden.
Ebenso kann an Stelle der Subtraktion auch die Addition mit dem
invertierten stehen: a - b = a + /b + 1 wenn der Übertrag wegfällt.
Die +1 stört nicht, kann ich später berücksichtigen.

Ich habe schonmal angefangen, das ganze in diskreter Logik zu planen -
aber alleine die 16 Stück 4-Bit Addierer fressen schon ne Menge Platz
und Strom.

Für sowas müsste doch eigentlich programmierbare Logik ideal sein.
Bloß was? PAL, GAL, FPGA, CPLD? Ich hab da überhaupt keinen Überblick.
Und gibt es einen Hersteller dafür, der einem die entsprechende
Software kostenlos dazugibt? Ein Hinweis auf ne passende FAQ dazu wäre
auch prima, momentan weiß ich nicht mal, nach welchem der vier "Typen"
ich googlen muss.

Dank und Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
Quoted text here. Click to load it
comp.arch.fpga, dein Problem passt wegen 16 Eingaengen und 2*16
Ausgaengen, also mehr als 48 I/O leider nicht mehr in ein PLCC44
(es sei denn, es reicht dir, die beiden Differenzen nacheinander
an delselben Ausgangspins zu erhalten), daher brauchst du TQFP100,
am billigsten wohl XC9572TQ100 von xilinx, bei Reichlt zu kaufen,
dessen 72 Maxrozellen das dann auch locker schaffen (man braucht
ja nur 1 16 bit Subtrahierwerk, 1 16 bit Addierwerk, und 2 16 bit
Register, wenn man das Problem ein wenig zusammenoptimiert).
--
Manfred Winterhoff, reply-to invalid, use mawin at despammed.com
homepage: http://www.geocities.com/mwinterhoff /
We've slightly trimmed the long signature. Click to see the full one.
Re: Digital rechnen in programmierbarer Logik

Hi!

Quoted text here. Click to load it

Danke, werd ich mal reinschauen.

Quoted text here. Click to load it

Evtl kann ich teilweise auf 14bit oder 10bit reduzieren, kommt darauf
an, wie die weitere Peripherie später aussieht. Ausgehen wollte ich
erstmal von einem halbwegs symmetrischen Aufbau. Wenns später in ein
kleineres Gehäuse passt - umso besser.

Quoted text here. Click to load it

Oder so, mal schauen.

Quoted text here. Click to load it

Prima. Und die PLCC44-Version scheint ja laut Reichelt bis auf die
Zahl der I/O identisch zu sein.

Quoted text here. Click to load it

Klar, kann ich auch nacheinander rechnen, hauptsache der Durchsatz
stimmt. Wieviele bit kann ich da parallel addieren? Bei der Hardware-
Lösung wirds ja auch nur deshalb knapp mit der Zeit, weil ich für
16bit drei 4bit Addierer hintereinanderklemmen muss.

Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
On 02 Sep 2003 19:26:14 +0200, Juergen Hannappel

Hi!

Quoted text here. Click to load it


10 MHz auf dem Bus. Also alle 100ns einer von vier Werten.

Mit Fast Logik würde es gerade so gehen:

FFs: 10ns

Addition: 3 * 10ns für die carrys + 1 * 15ns für die letzten 4 bit
        = 45ns

Subtraktion: Addition + 5ns für Inverter = 50ns.


Da ich die Reihenfolge der Clocks beliebig wählen kann, kann ich die
Subtrahenden in den ersten drei Clocks vorbereiten. Als letztes kommt
dann Clk1 und ich brauch noch

10ns für FF1,
45ns für FF1 + FF2 = Summe1,
45ns für Summe1 + /Summe2,

wobei FF2 und /Summe2 schon lange warten.

Notfalls kann ich die Summen auch nochmal in FFs zwischenspeichern,
dann wirds mit dem letzten Clock nicht so knapp. Latenz spielt keine
Rolle, nur konstant hoher Durchsatz.


Quoted text here. Click to load it

Für vier Datenwerte, yepp.


Quoted text here. Click to load it

Wäre doch in der Entwicklungsphase auch angenehmer, nur EEPROM
tauschen zu müssen?


Quoted text here. Click to load it

Wieviel Platz ist Platz? :-) Ich will ja wirklich nicht viel machen.


Quoted text here. Click to load it


Heißt das, die bieten alle auch kostenlose Software an?

Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
Quoted text here. Click to load it



Ist das mit den 4 clockdomains nur verwirrend gezeichnet oder sind das clock
enables ?
Du solltest alles in einer clockdomain machen (was angesagt ist !) bzw die
verschiedenen langsamen clocks in eine clockdomain transferieren.
Ich nehme mal vereinachend 4 16bit inputs a,b,c,d an.
Ein Spartan2-50-5 schafft das in 10ns, allerdings gepipelined. Siehe:


-- a-b, (a+b)-(c+d)
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;
use IEEE.std_logic_arith.all;

entity addsub is
Port (
 clock:        in std_logic;
 a,b,c,d:       in std_logic_vector(15 downto 0) ;
 result1,result2:    out std_logic_vector(15 downto 0)
);
end addsub;


architecture Behavioral of addsub is
-- SIGNALS
signal a_in,b_in,c_in,d_in:  std_logic_vector(15 downto 0);
signal sum1,sum2:            std_logic_vector(15 downto 0);

begin
process(clock)
begin
  if (clock'event and clock = '1') then
   a_in <= a;
   b_in <= b;
   c_in <= c;
   d_in <= d;
   sum1 <= (a_in + b_in) ;
   sum2 <= (c_in + d_in) ;
   result1 <= a_in - b_in  ;
   result2 <= sum1 - sum2 ;
 end if;
end process;

end Behavioral;

PAR-Report (Alles mit webpack5.2 übersetzt)
----------------------------------------------------------------------------
----
  Constraint                                | Requested  | Actual     |
Logic
                                            |            |            |
Levels
----------------------------------------------------------------------------
----
  NET "clock_bufgp/IBUFG" PERIOD =  10 nS   | 10.000ns   | 9.906ns    | 1
   HIGH 50.000000 %                         |            |            |
----------------------------------------------------------------------------
----


All constraints were met.

All signals are completely routed.


Ein coolrunner2 braucht dafür über 17ns. Ist also um einiges langsamer. Hat
ja auch keine carry-chain.

                     Minimum Internal Clock Period: 17.7ns
                     Maximum Internal Clock Speed: 56.4Mhz
                            (Limited by Cycle Time)

                     Minimum External Clock Period: 17.7ns
             Maximum External Clock Speed (before divider): 56.4Mhz
                            (Limited by Cycle Time)


MIKE









Re: Digital rechnen in programmierbarer Logik
On Tue, 2 Sep 2003 20:44:18 +0200, "M.Randelzhofer"

Hi!

Quoted text here. Click to load it


Ööh?

Alle 100ns rauscht ein 16Bit-Wort rein und wird auf eines der FFs
gegeben. Nach 400ns hab ich einen Satz von 4 Worten komplett, und
damit soll dann gerechnet werden. Die Reihenfolge, in der ich die FFs
lade, kann ich mir aussuchen.


Quoted text here. Click to load it

Ich komm nicht ganz mit, was Du meinst.

Der 10MHz clock ist einfach auf die 4 FFs aufgeteilt, was ich bloß
nicht gezeichnet hab. Aber klar gibts ihn auch in seiner noch nicht
aufgeteilten Form.

Oder meinst Du, ich soll die _Daten_ mit _einem_ Clock in die Addierer
bzw. Subtrahierer schicken? Auch kein Problem:


        16bit
          |
          |
          o--- D-FF --- D-FF --- ...
  Clk1--- | -----^       ^
          |              |
          |          .---´
          |          |
          |          |
          o--- D-FF --- D-FF --- ...
  Clk2--- | -----^   |   ^
          |          |   |
          |          o---´
          |          |
          |          |
          o--- D-FF --- D-FF --- ...
  Clk3--- | -----^   |   ^
          |          |   |
          |          o---´
          |          |
          |          |
          `------------ D-FF --- ...
                     |   ^
                     |   |
  Clk4---------------o---´

Wenn Clk4 jeweils als letzter kommt, hab ich jetzt aus den vier
nacheinander ankommenden Datenworten vier gleichzeitige gemacht, die
in die Addierer gehen. Meintest Du das?

Die Zeichnung bezog sich aber nur darauf, wie ich es in _Hardware_
machen würde. Daß das in programmierbarer Logik anders aussehen kann
oder wird, ist schon klar.


Quoted text here. Click to load it

So wie ich. Die FFs sollten aber schon innerhalb der programmierbaren
Logik liegen. Wäre ja witzlos, 8 Stück ´574 zu opfern um die Breite
auf 64 Leitungen aufzublasen, wo sie doch eh in einzelnen Worten
vorliegen. Sich 4 Worte zu merken, das kann die programmierbare Logik
doch sicher besser.

Quoted text here. Click to load it

Find ich jetzt so direkt nicht. Hat der noch eine andere Bezeichnung?

Quoted text here. Click to load it

Klingt nicht schlecht.

Quoted text here. Click to load it

Ääh, was?

Quoted text here. Click to load it

[....]

Sieht schick aus. Erinnert stark an C. Ist das VHDL? Würde mich
überraschen, hatte so in Erinnerung, daß VHDL sehr hardwarenah ist.
Das hier hingegen müsste erstmal von nem Compiler in Logik umgesetzt
werden. Macht der einfach so!?

Quoted text here. Click to load it


Jetzt sag nicht, das heißt "ja"!??

Hast Du ihm überhaupt irgendwo gesagt, welche Pins Ein- und Ausgänge
sind? Und hat der Compiler auch erzählt, wieviele Zellen er belegt
hat?

Quoted text here. Click to load it

Wäre auch OK. Kenne ich auch nicht :-)

Quoted text here. Click to load it

Wasauchimmerdasist :-)


Ich hatte eigentlich nur ein "schau Dich mal in der Familie um"
erwartet, aber wenn ich schon _so_ konkrete Bauteilvorschläge bekomme:

PLCC wäre bequem, TQFP aber auch noch machbar (ist halt nur Arbeit).
5V wären schön. Timing hab ich ja oben angegeben, alle 100ns ein Wort,
alle 400ns eine Berechnung.

Vielen Dank schonmal,
Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
Quoted text here. Click to load it
Mögliche,
Quoted text here. Click to load it
http://www.xilinx.com/xlnx/xil_prodcat_landingpage.jsp?title=ISE+WebPa
ck

gibt's die auch für win98?

ciao, Arne



Re: Digital rechnen in programmierbarer Logik
On Tue, 16 Sep 2003 19:55:00 +0200, "Arne Krüger"

Hi!

Quoted text here. Click to load it


Ja, aber nur die 4.2 - dafür scheint die nicht auf 90 Tage beschränkt
zu sein, hab jedenfalls nix derartiges gelesen.

http://www.xilinx.com/webpack/classics/wpclassic/index.htm

Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
On Tue, 2 Sep 2003 20:44:18 +0200, "M.Randelzhofer"

Hi!

Nur so zum Spaß:
Was sagt Dein Programm, wenn Du nicht result1 und result2, sondern
result <= result1/result2; in 16-bit oder 24-bit integer ausgibst?

Macht aber nix, wenns zu langsam ist, ich kann auch ne Logarithmen-
Tafel in nem Eprom ablegen (hatte ich ursprünglich auch vor). Unter
anderem auch daher die mögliche Beschränkung auf 10bit (siehe Antwort
an MaWin), ab 1MB aufwärts wirds haarig.

Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
On Tue, 02 Sep 2003 22:22:12 +0200, Michael Eggert

Quoted text here. Click to load it

10bit -> 1MB War natürlich Dummschwatz meinerseits.
Ich dachte bereits darüber nach, für jede _Kombination_ aus 10bit
Werten im Eprom einen Quotienten zu hinterlegen - den ich dann noch
mit einer Kalibrierkurve (hängt mit dem Mess-System zusammen)
gewichten kann. DANN hab ich 2x10bit Adressen -> 1MWord.

@Mike: Deine zweite Antwort les ich morgen, war ja vorhin schon nicht
mehr richtig wach :-)

Gruß,
Michael.

Re: Digital rechnen in programmierbarer Logik
On Tue, 02 Sep 2003 19:14:28 +0200, Michael Eggert

Moin!

Mist, im 9572 wird eng mit dem Platz. Nun dachte ich mir, nehm ich den
alten Spartan XCS10, der hat massig Platz auch für andere Spielereien,
läuft auf 5V, gibts in PLCC-84, und bei Reichelt zu kaufen. Eigentlich
doch ideal? Denkste - Xilinx´s Entwicklungssoftware im WebPack kennt
die nicht (mehr. Da will Xilinx wohl lieber die neuen verkaufen.)

GRMPF!
Michael.

Site Timeline