Mit 2 Microcontrollern auf einen Speicher zugreifen?

[Thorsten Oesterlein]

Am Sun, 08 Jan 2006 02:25:05 +0100 schrieb Andreas Sauer:

Es sollen Zykluszeiten von ca 1ms erreicht werden, daher soll die ganze
Kommunikation ausgelagert werden.

[...]

Die Idee mit dem abwechselnden Zugriff auf den SRAM denke ich ist am
schnellsten und kostengünstigsten, es sollen maximal ca 2MB E/A Daten
bearbeitet werden,

Als Prozessoren hatte ich an Atmel 90S8515 gedacht, da diese ein
externes Speicherinterface besitzen.

Wenn ich das nun recht verstehe, willst du mit einem Atmel innerhalb von
1ms - also 20.000 Takten bei 20Mhz - 2MB E/A Daten einlesen, bearbeiten und
wieder ausgeben?

Ich fürchte, daß sich das nicht ganz ausgehen wird.

Das geht sich nicht mal aus wenn du 2M_Bit_ innerhalb einer ganzen Sekunde
verarbeiten willst. Da bleiben dir für jedes Bit 10 Takte. Die sind mit
Zugriff auf externes RAM und zurückschreiben nach irgendwohin schon weg.

mfg Andreas

lg,
Thorsten

 

[Thorsten Oesterlein]

Am Sun, 08 Jan 2006 02:25:05 +0100 schrieb Andreas Sauer:

Es sollen Zykluszeiten von ca 1ms erreicht werden, daher soll die ganze
Kommunikation ausgelagert werden.

[...]

Die Idee mit dem abwechselnden Zugriff auf den SRAM denke ich ist am
schnellsten und kostengünstigsten, es sollen maximal ca 2MB E/A Daten
bearbeitet werden,

Als Prozessoren hatte ich an Atmel 90S8515 gedacht, da diese ein
externes Speicherinterface besitzen.

Wenn ich das nun recht verstehe, willst du mit einem Atmel innerhalb von
1ms - also 20.000 Takten bei 20Mhz - 2MB E/A Daten einlesen, bearbeiten und
wieder ausgeben?

Ich fürchte, daß sich das nicht ganz ausgehen wird.

Das geht sich nicht mal aus wenn du 2M_Bit_ innerhalb einer ganzen Sekunde
verarbeiten willst. Da bleiben dir für jedes Byte 80 Takte.
Mit Einlesen und Zurückschreiben des Ergebnisses bleibt da nicht mehr viel
zum Rechnen.

In C schon gar nicht. Da schaffst du mit 80 Takten grad mal etwas mehr als
eine Funktion die ein simples "i++" macht.

mfg Andreas

lg,
Thorsten

 

[Makus Gr0n0tte]

"Thorsten Oesterlein"

Das geht sich nicht mal aus wenn du 2M_Bit_ innerhalb einer ganzen Sekunde
verarbeiten willst. Da bleiben dir für jedes Byte 80 Takte.

A

Mit Einlesen und Zurückschreiben des Ergebnisses bleibt da nicht mehr viel
zum Rechnen.

B

In C schon gar nicht. Da schaffst du mit 80 Takten grad mal etwas mehr als
eine Funktion die ein simples "i++" macht.

A und B ist aber fast das gleiche. denk mal drüber nach Ist C wirklich so
viel langsamer? Hab da ja eigentlich keine Ahnung. Kenne halt nur die grobe
implementation von i++ in Assembler.

 

[Helmut Sennewald]

"Andreas Sauer" <620@ktmlc4.de> schrieb im Newsbeitrag
news:43c06ad1$0$21027$9b4e6d93@newsread2.arcor-online.net...

Helmut Sennewald schrieb:

Hallo Andreas,

Um welche Microcontroller handelt es sich denn?

Die Möglichkeiten können stark eingeschränkt sein,
wenn man die "falschen" Microcontroller hat.

Es gibt Dual-Port-Speicher. Aber das wurde ja scon mehrfach erwähnt.

Haben deine Prozessoren überhaupt ein richtiges externes
Memory-Interface?
Für Dual-Port-RAM müßten sie dann idealerweise auch noch die
Fähigkeit besitzen bei Speicherzugriffen "kurz" zu warten
wenn ein Zugriffskonflikt auftritt.

Erzähl doch einfach noch etwas mehr über dein Prozessorsystem
und welche Datenraten auftreten.

Gruß
Helmut


Das ganze soll ein SPS System werden.

Der Hauptprozessor arbeitet als Interpreter und liest bei jedem
Zyklusbeginn die Eingangsdaten des Kommunikationsprozessors, und beim
Zyklusende schreibt er die Ausgangsdaten.
Es sollen Zykluszeiten von ca 1ms erreicht werden, daher soll die ganze
Kommunikation ausgelagert werden.

Hallo Andreas,

Da bleiben aber nur noch wenige tausend Assembler-Befehle
die da pro Millisekunde ausgeführt werden können.

Der Kommunikationsprozessor nimmt dann die bearbeiten E/A Daten des
Hauptprozessors und verteilt diese an die verschiedenen Slaves über
Can-Bus bzw. irgendeinen 2-wire BUS wie I2C

An sich ist das eine gute Idee die Aufgaben aufzuteilen.

Die Idee mit dem abwechselnden Zugriff auf den SRAM denke ich ist am
schnellsten und kostengünstigsten, es sollen maximal ca 2MB E/A Daten
bearbeitet werden,

Was sind 2MB?

Wieviele Bits oder Bytes müssen in der 1ms verarbeit werden?

Ich nehme an, eine SPS macht hauptsächlich logische Verknüpfungen.

Sind auch Daten von A/D-Wandlern(8bit?) zu verarbeiten?

Als Prozessoren hatte ich an Atmel 90S8515 gedacht, da diese ein
externes Speicherinterface besitzen.
mfg Andreas

Mehr als 1000 logische Operationen pro Millisekunde schafft
das Teil nicht. Vielleicht sind es sogar nur wenige hundert
logische UND/ODER-Verknüpfungen einer SPS.

Schon Lesen und Schreiben dauert jeweils 3 Takte pro Byte.
Dieser Prozessor scheint auch keine Möglichkeit zu besitzen,
bei Zugriffskonflikten auf den Dual-Port-Speicher, den
Speicherzugriff zu verlängern.
Also muß schon mal per Software irgendeine zusätzliche
Abfrage erfolgen.

Gruß
Helmut

 

[Thorsten Oesterlein]

Am Sun, 8 Jan 2006 09:44:09 +0100 schrieb Makus Gr0n0tte:

"Thorsten Oesterlein"

Das geht sich nicht mal aus wenn du 2M_Bit_ innerhalb einer ganzen Sekunde
verarbeiten willst. Da bleiben dir für jedes Byte 80 Takte.

A
Mit Einlesen und Zurückschreiben des Ergebnisses bleibt da nicht mehr viel
zum Rechnen.

B
In C schon gar nicht. Da schaffst du mit 80 Takten grad mal etwas mehr als
eine Funktion die ein simples "i++" macht.

A und B ist aber fast das gleiche. denk mal drüber nach Ist C wirklich so
viel langsamer? Hab da ja eigentlich keine Ahnung. Kenne halt nur die grobe
implementation von i++ in Assembler.

Wenn du Assembler verwendest kannst du selbst entscheiden wie du die
Prozeduren aufrufst, was du auf den Stack legst und was nicht. Verwendest
du C, popt der Compiler bei jedem Funktionsaufruf erstmal alle Register auf
den Stack und schreibt den Stack beim Verlassen natürlich wieder zurück in
die Register. Das alleine kostet schon mal jede Menge Takte. Um es genau zu
sagen, müsste ich das AVR Studio erst wieder anwerfen.

lg,
Thorsten

 

[Thorsten Oesterlein]

Am Mon, 9 Jan 2006 00:44:54 +0100 schrieb Thorsten Oesterlein:

Wenn du Assembler verwendest kannst du selbst entscheiden wie du die
Prozeduren aufrufst, was du auf den Stack legst und was nicht. Verwendest
du C, popt
^^^^

pusht natürlich

den Stack und schreibt den Stack beim Verlassen natürlich wieder zurück in
die Register. Das alleine kostet schon mal jede Menge Takte. Um es genau zu
sagen, müsste ich das AVR Studio erst wieder anwerfen.

Zum Vergleich:

Dieses Stück C Source

SIGNAL (SIG_INT0)
{
PORTB = out_array[g_position].bits;
g_position = out_array[g_position + g_step].next;
}

wird mit dem GNU C Compiler zu

=========================================================================
// Erstmal alles auf den Stack
PUSH R1 Push register on stack
PUSH R0 Push register on stack
IN R0,0x3F In from I/O location
PUSH R0 Push register on stack
CLR R1 Clear Register
PUSH R18 Push register on stack
PUSH R19 Push register on stack
PUSH R24 Push register on stack
PUSH R25
Push register on stack
PUSH R30 Push register on stack
PUSH R31
Push register on stack

// PORTB = out_array[g_position].bits;
LDS R24,0x00C2 Load direct from data space
MOV R30,R24 Copy register
CLR R31 Clear Register
LDI R18,0x60 Load immediate
LDI R19,0x00 Load immediate
LSL R30 Logical Shift Left
ROL R31 Rotate Left Through Carry
ADD R30,R18 Add without carry
ADC R31,R19 Add with carry
LDD R24,Z+0 Load indirect with displacement
OUT 0x18,R24 Out to I/O location

// g_position = out_array[g_position + g_step].next;
LDS R25,0x00C2 Load direct from data space
LDS R24,0x00C0 Load direct from data space
MOV R30,R24 Copy register
CLR R31 Clear Register
SBRC R30,7 Skip if bit in register cleared
COM R31 One's complement
ADD R30,R25 Add without carry
ADC R31,R1 Add with carry
LSL R30 Logical Shift Left
ROL R31 Rotate Left Through Carry
ADD R30,R18 Add without carry
ADC R31,R19 Add with carry
LDD R24,Z+1 Load indirect with displacement
STS 0x00C2,R24 Store direct to data space

// Alles vom Stack zurück
POP R31 Pop register from stack
POP R30 Pop register from stack
POP R25 Pop register from stack
POP R24 Pop register from stack
POP R19 Pop register from stack
POP R18 Pop register from stack
POP R0 Pop register from stack
OUT 0x3F,R0 Out to I/O location
POP R0 Pop register from stack
POP R1 Pop register from stack
RETI Interrupt return
=========================================================================



Selber in Assembler gestrickt wird der selbe Code Zeile zu

=========================================================================
ld out_val, X+
out PORTB, out_val
add XL, steps
ld XL, X
=========================================================================

Und braucht nur mehr ganze 6 Takte.

Ganz schöner Unterschied, oder?

Den Stack brauchts hier übrigens nicht weil der Proz genau nix anderes tut
als dieses Stück Code abzuarbeiten.

lg,
Thorsten

lg,
Thorsten

 

[Gernot Fink]

In article <43c06ad1$0$21027$9b4e6d93@newsread2.arcor-online.net>,
Andreas Sauer <620@ktmlc4.de> writes:

schnellsten und kostengünstigsten, es sollen maximal ca 2MB E/A Daten
bearbeitet werden,

Als Prozessoren hatte ich an Atmel 90S8515 gedacht, da diese ein
externes Speicherinterface besitzen.

Bei 2MB wirst du mit dem AVR nicht viel spass haben. Du musst den Speicher
in pages aufteilen und hast nicht mal leistungsfähige Befehle um darauf
zuzugreifen.

Ich würd eher in richtung 68008,68000 oder 68020 denken. Der kann mit
dem addressraum umgehen und kann z.b.DMA. Ausserdem hat schon atari und amiga
gezeigt wie man diesen Speicher mit der Grafik teilt.

--
MFG Gernot