You are on page 1of 13

Seminarvortrag

26. Juni 1998
Universität - Gesamthochschule Kassel

Aufbau und Anwendung von
Digital Signal Prozessoren

von
Sven Semmelrodt
Roger Wolf
INHALTSVERZEICHNIS

Gängige µProzessoren besitzen eine ‘von Neumann’ Architektur
• Daten und Programmcode liegen in einem gemeinsam
adressierbaren Speicherbereich
• einfache Hardware, sehr flexibel → PC
• Programm und Daten werden sequentiell gelesen → sehr langsam

Signal Prozessoren besitzen eine ‘Harvard’ Architektur
• Daten und Programmcode liegen in unterschiedlich adressierbaren
Speicherbereichen
• aufwendige Hardware
• ermöglicht sehr effiziente Bearbeitung von Daten
• DSP’s → erweiterte ‘Harvard Architektur (1 Programm, 2 Daten
Bereiche)

P r o g r a m X - D a t a Y - D a t a
M e m o r yM e m o r yM e m o r y

Y - A B
A d d r e s s E x t e r n a l
X - A B
G e n e r a t i n A d d r . B u s
P - A B
U n it S w it c h

E x t e r n a l
Bu s
C o n t r o l

Y - D B
I n t e r n a l X - D B E x t e r n a l
D a t a B u s P - D B D a t a B u s
S w i t c h G - D B S w it c h

S e r i a l / P a r a lP l e r ol g r a m
A r i t h m e t i c L o g
I n t e r f aBlockschaltbild
Abbildung 1-1: Vereinfachtes c e s C des
o DSP
n t r56002
o l U n i t

M oFoliet 2o r o l a D
Zahlenformate der Signalverarbeitung

• Festkomma Darstellung
− ‘geringere’ Genauigkeit als Fließkommazahlen
− Zahlenbereich von -1 ≤ X < 1 → Skalieren wird notwendig
− kein Überlauf bei der Multiplikation möglich (Ausnahme: -1 × -1 = 1)
− einfache Rechenwerke

• Fließkomma Darstellung
− hohe Genauigkeit
− Zahlenbereich: ± Mantisse × 2 ± Exponent

− aufwendige Rechenwerke (getrennte Berechnung von Exponent und
Mantisse)
− aufwendige Überlaufs- und Rundungslogik wird notwendig

Folie 4
Zahlenformate der Signalverarbeitung

Bit 23 22 21 ... 2 1 0
Wert 0 1 1 ... 0 1 0
Wichtung -20 2-1 2-2 ... 2-21 2-22 2-23
Abbildung 1-2: 24 Bit Festkommaformat

Bit 31 ... 24 23 ... 0
Bedeutung Exponent +/- Mantisse
Abbildung 1-3: 32 Bit Fließkommaformat (TI)

Folie 4
Zahlenformate der Signalverarbeitung

X D A T A B U S

Y D A T A B U S

2 4 2 4

2 4 B i t F i x p o i n t
A r i t h m e t i c L o g i c U n i t
R e g is t e r X 0

R e g is t e r X 1

R e g is t e r Y 0

R e g is t e r Y 1

2 4 2 4

M u lt ip li e r

4 8

A
c c u m u l a t o r
5 6 5 6
R o u n d i n g a n d
L o g i c U n it

B a r r e l s h i f t e r5 6

A c c u A

A c c u B

5 6 5 6

Abbildung 1-4: 24 Bit Festkomma Rechenwerk (ALU)
S h i f t e r / L im it e r

2 4 2 4
Folie 4
Adreßwerke von DSP’s

Spezielle Eigenschaften des Adreßwerkes
• Modulo Adressierung (Implementierung von Ringspeichern)
• Bit Reversed Addressing (Implementierung von FFT Algorithmen)

A e n t h a l t e d e n n e u e n A b t a s t w e r t

A

B e a r b e i t u n g s s c h r i t t e : 4
D 1
6
1: B = D 3
5
2: X 0 = D 2 D 2 R e g is t
2
3: D 3 = X 0
1
4: X 0 = D 1 D 3
5: D 2 = X 0 3
6: D 1 = A
B

Abbildung 1-5: Verzögerung durch umspeichern von Abtastwerten

B e n t h ä l t d e n u m 3 A b t a s t p e r i o d e n v e r z ö g
Aenthaldubswr Ringpuferz0
4. . .
3.
.2
0 . Bearbitungsch: 1
3:R0+1 409. 2:*(R0)=A 4095 1:B=*(R0 .
4:if(R0=96)then .
. .
..
..
Benthäld4096-facvrzögAbsw

Abbildung 1-6: Verzögerung mit Hilfe von Ringspeichern

Folie 6
Adreßwerke von DSP’s

Adresse Speicherinhalt
$00 x[0]
$01 x[1]
$02 x[2]
$03 x[3]
$04 x[4]
$05 x[5]
$06 x[6]
$07 x[7]
$08 ...
... ...
Abbildung 1-7: Speicherkonfiguration für FFT-Algorithmus

Bearbeitungsschritte 1 2 3 4 5 6 7 8
Benötigte Abtastwerte x [0] x [4] x [2] x [6] x [1] x [5] x [3] x [7]
Zugehörige Adressen $00 $04 $02 $06 $01 $05 $03 $07
Binäre Adressen 000 100 010 110 001 101 011 111
Binäre Bit Rev. Addr. 000 001 010 011 100 101 110 111
Bit Reversed Addr. $00 $01 $02 $03 $04 $05 $06 $07
Abbildung 1-8: Prinzipschaubild der Bitverdrehten Adressierung

Operationen für die Bitverdrehte Addressierung
• Adresse = $06
• Bits drehen ⇒ $06 = 110 → 011 = $03
• Adresse inkrementieren ⇒ $03 → $04
• Bits drehen ⇒ $04 = 100 → 001 = $01
• Adresse = $01

Folie 7
Piplinestruktur und Befehlssatz

Bearbeitungsphasen während der Befehlsausführung :
• Programmwort aus Programmspeicher lesen (Fetch)
• Programmwort decodieren (Decode)
• Operanden aus Programmspeicher lesen (Read)
• Befehl ausführen (Execute)

Zyklus Fetch Decode Read Execute
m-3 Befehl ‘1’ - - -
m-2 Befehl ‘2’ Befehl ‘1’ - -
m-1 Befehl ‘3’ Befehl ‘2’ Befehl ‘1’ -
m Befehl ‘4’ Befehl ‘3’ Befehl ‘2’ Befehl ‘1’
m+1 ... Befehl ‘4’ Befehl ‘3’ Befehl ‘2’
m+2 ... ... Befehl ‘4’ Befehl ‘3’
m+3 ... ... ... Befehl ‘4’
Abbildung 1-9: Befehlsverarbeitung mit einer 4 stufigen Pipelinestruktur

Beispiel 1: Beispiel 2:
... ...
BR XYZ BRD XYZ
ADD ... OR ...
MPY ... ADD ...
... SUB ...
ADD ...
XYZ: OR ... MPY ...
ADD ... ...
SUB ...
ADD ... XYZ: ADD ...
... ...
Abbildung 1-10: Konfliktbehebung durch verzögerte Programmverzweigung

Folie 8
Piplinestruktur und Befehlssatz

Zykl. F. D. R. E. Zykl. F. D. R. E.
m-3 BR - - - m-3 BRD - - -
m-2 MPY BR - - m-2 OR BRD - -
m-1 - - BR - m-1 ADD OR BRD -
m - - - BR m SUB ADD OR BRD
m+1 OR - - - m+1 ADD SUB ADD OR
m+2 ADD OR - - m+2 ... ... ... ...
m+3 SUB ADD OR - m+3 ... ... ... ...
m+4 ADD SUB ADD OR m+4 ... ... ... ...
m+5 ... ... ... ... m+5 ... ... ... ...
Abbildung 1-11: Pipline mit und ohne Sprungkonflikt

Spezielle Befehle

Repeat Single Instruction
• ermöglicht ‘Zero Overhead Loops’ durch spezielle Schleifen-
register
• Wiederholt n-mal den folgenden Befehl (z. B. Speicher löschen)
• kein Softwareaufwand zur Implementierung einer Programm-
schleife (Zähler inkrementieren, Prüfen der Abbruchbedingung)
• einmalige Initialisierung (4 Zyklen wegen Piplinestruktur)
• Programm läuft so schnell, als würde der Befehl n-mal im Source-
Code auftauchen

Repeat Instruction Block
• Wiederholt n-mal den folgenden Befehlsblock
• siehe oben

Automatic Addressincrement / decrement
• ermöglicht automatisches weitersetzen von Datenzeigern
• Inkrement bzw. Dekrement von Zeigern

Multiply and Add
• Parallele Multiplikation und Addition

Folie 9
Peripherie von Signalprozessoren

Standardausstattung
• Interrupt Controller
• Mindestens eine serielle oder parallele Schnittstelle
• On-Chip RAM (256 - 1k Worte pro RAM Block)
• Boot ROM
• Timer/Counter
• I/O Ports
• Externes Bus Interface

Zusatzperipherie je nach Hersteller und Typ
• DMA Controller
• n-fach Serielles Interface
• n-fach Paralleles Interface
• Host bzw. Debug Interface
• Clock Generator mit PLL
• Befehls Cache
• ROM Tabellen

Alle peripheren Einheiten sind über den Interrupt Controller mit der
‘CPU’ und - wenn vorhanden - mit dem DMA Controller verbunden,
um gezielt in den Programmablauf eingreifen zu können.

Folie 10
Anwendungsbeispiel ‘FIR-Filter’

x [ n - 1 ] x [ n - 2 ] x [ n - N - 2 ] x [ n - N - 1 ]
- 1 - 1 - 1
x [ n ] z z . . . z

a 0
a 1
a 2
a N -2
a N -1
. . .

Abbildung 1-12: Filterstruktur
+ eines N-stufigen+ FIR-Filters. . . + +

Differenzengleichung:

N −1
y n = ∑ ak ⋅ x n − k
k=0

Übertragungsfunktion bzw. Impulsantwort:

 a 0 ≤ k ≤ N −1
h[ n ] =  k
 0 sonst

X-Speicher Y-Speicher
0 x [n] ← R0 0 a0 ← R1
1 x [n+1] 1 a1
2 x [n+2] 2 a2

... ... ... ...

N-2 x [n + N - 2] N-2 aN-2
N-1 x [n + N - 1] N-1 aN-1
Abbildung 1-13: Speicherbelegung für die FIR-Filter Berechnung

Folie 11
Anwendungsbeispiel ‘FIR-Filter’

HAUPT_PROG
{
< Initialisierung des Prozessors und der Peripherie >
< Initialisierung des Eingangs- und Koeffizientenspeicher als Ringpuffer
>
while (1)
{
< Auf nächsten Abtastwert warten >
< Abtastwert empfangen und im Eingangspuffer eintragen >
< FIR Funktion aufrufen >
< Berechneten Ausgangswert ausgeben >
}
}

FIR (Version 1)
{
B=0
for k = 0 to N ;N-fach Schleife (6 Zykl. / Durchlauf)
{
X0 = *(R0) ;Abtastwert laden (1 Zyklus)
R0 + 1 ;Zeiger weitersetzen (1 Zyklus)
Y0 = *(R1) ;Koeffizient laden (1 Zyklus)
R1 + 1 ;Zeiger weitersetzen (1 Zyklus)
A = X0 × Y0 ;x[n-k] * ak (2 Zyklen)
B=A+B ;aufsummieren (1 Zyklus)
}
return (B)
}

FIR (Version 2)
{
A=0
X0 = *(R0 ++) ;1. Abtastwert laden (1 Zyklus)
Y0 = *(R1 ++) ;1. Koeffizient laden (1 Zyklus)
Repeat N ;N-fach Hardw. loop(4 Zyklen)
{
A = A + X0 × Y0 ;Σ x[n-k] * ak (2 Zyklen)
|| X0 = *(R0 ++) ;par. Wert laden
|| Y0 = *(R1 ++) ;par. Koeff. laden
}
return (A)
}

Performance FIR (Version 1): N × 13 Zyklen + Initialisierung
Performance FIR (Version 2): N × 2 Zyklen + Initialisierung

Folie 12
Anwendungsbeispiel ‘FIR-Filter’
Prozessor ADSP-21060 TMS320C40
Befehlsausführung 25 ns 25 ns
Spitzen-MFLOPS 120 80
1024-Punkte FFT (komplex) 0,46 ms 0,96 ms
Division 150 ns 225 ns
DMA-Bandbreite Port / Port 40 MBytes/s 32 MBytes/s
DMA-Bandbreite Off- / On-Chip 240 MBytes/s 32 MBytes/s
DMA-Bandbreite On- / Off-Chip 240 MBytes/s 53 MBytes/s
Datenregister 32 8
Interner RAM (32 Bit Worte) 2 mal 64k 2 mal 1k
Parallele Ports 6 6
Serielle Ports 2 0
DMA-Kanäle 10 6
Abbildung 1-14: ADSP-21060 gegen TMS320C40

Prozessor ADSP-2104 TMS320C203
Evaluation Boards $ 89 $ 99
Software Entwicklung $ 395 $ 4000
Emulator $ 1495 $ 4000
Summe $ 1979 $ 8099
Abbildung 1-15: Entwicklungskosten im Vergleich

Prozessor ADSP-2104 TMS320C203
Befehlsausführung 50 ns 25 ns
MIPS 20 40
FFT Berechnung 0,596 ms 0,626 ms
Zyklen 11914 25033
Datenspeicher (32 Bit Worte) 256 288
Prg.-speicher (32 Bit Worte) 512 256
Serielle Ports 2 2
Piplinestruktur 2 Stufig 4 Stufig
Modulo Adressierung ja -
Datenregister 32 4
Parallele Verarbeitung keine Einschr. mit Einschr.
Externe Speicherzugriffe 0 Waitstates X Waitstates
Indirekte Addressierung keine Einschr. mit Einschr.
Befehlsverarbeitungszeit 1 Zyklus 1 - 4 Zyklen
Abbildung 1-16: ADSP-2104 gegen TMS320C203

Folie 13