Algumas Características
Típicas de DSPs
 Instruções especiais para a implementação de equações
às diferenças, ou convolução (Implementação de Filtros
M
IIR e FIR):
y[n]   bm .x[n  m]
Instruções num ciclo de relógio
m 0
Nomeadamente, Multiplicação + Adição
(Multiply and Acumulate, MAC) (C3x – Instruções paralelas)
 Facilidades para a Implementação de Buffers (C3x – Buffers
circulares)
 Ciclos por Hardware (C3x - Repeat Block)

1
O Processador TMS320C3x
Endereçamento
indirecto
 Registos
R0
....
R7
AR0
....
AR7
DP
IR0
IR1
BK
SP
ST
RS
RE
RC
Cálculos
intermédios
Modos de endereçamento
R0
Extended-precision register
Imediato – constantes
LDF 34, R1
R7
R8
Extended-precision register
Auxiliary Register
Registo – acesso a registos
LDF R2, R1
Auxiliary Register
Data-page pointer
Index register 0
Index register 1
Block-size register
Active stack pointer
Status register
Repeat start address
Repeat end address
Repeat counter
Directo – acesso a posições de
memoria pré determinadas
LDF @VAR, R0
Indirecto – acesso a posições de
memoria indicadas em registos
LDF *AR1, R2
Consultar o Manual para
descrição mais detalhada
2
Algumas Instruções Típicas
Nota: O Resultado das Operações é sempre colocado no argumento
da direita.
@ - Endereçamento Directo (@Var = m[Var])
* - Endereçamento Indirecto (*AR1 = m[AR1])
 Load ( de Registos), LDI, LDF, etc

LDF R1, R3 – Copia para R3 o valor de R1
m[x] = conteúdo
da posição de
memória x
 Store (de Registos) , STI, STF, etc

STF R4, *AR0++ - Copia R4 para a posição de memoria apontada por AR0 e incrementa
AR0
 Aritméticas, MPYI, MPYF, ADDF

MPYF *AR0++, *AR1--, R3
– R3=m[AR0]+m[AR1]; AR0=AR0+1; AR1=AR1-1
 Saltos, Beq, B, Bne

Dependem do resultado da ultima operação
3
Uma página do Manual
MPYI
Multiply Integer
src- pode ter
vários modos de
endereçamento
Syntax
MPYI
Operation
dst x src -> dst
Operands
src general addressing modes (G):
00
01
10
11
src, dst
dst - registo
register (Rn, 0 <= n <= 27)
direct
indirect
immediate
dst register (Rn, 0 <= n< = 27)
Description The product of the dst and src operands is loaded
into the dst register. The src and dst operands, when read,
are assumed to be 24-bit signed integers. The result is
assumed to be a 48-bit signed integer. The output to the
dst register is the 32 least significant bits of the result.
Integer overflow occurs when any of the most significant 16 bits
of the 48-bit result differs from the most significant bit of
the 32-bit output value.
Cycles
1
Status Bits
These condition flags are modified only if the
destination register is R7 - R0.
LUF
LV
UF
N
Z
V
C
Unaffected.
1 if an integer overflow occurs, unchanged otherwise.
0.
1 if a negative result is generated, 0 otherwise.
1 if a zero result is generated, 0 otherwise.
1 if an integer overflow occurs, 0 otherwise.
Unaffected.
Mode Bit
OVM Operation is affected by OVM bit value.
Nota: Retirada do ficheiro de ajuda
4
Implementação de um FIR
 São necessárias duas zonas de memoria:


Buffer com as amostras do sinal de entrada x[n]
Tabela com os coeficientes da resposta Impulsiva
 Como manter o Buffer actualizado?
Buffer circular!
M
y[n]   h[m]. x[n  m]
m 0
 M+1 ciclos para implementar um FIR de ordem M
5
Instruções Paralelas
 Duas instruções são executadas
simultaneamente!
 Em geral os registos são lidos no inicio do
ciclo de relógio e escritos no fim!
Ex: Instrução MAC, Multiply and Acumulate
||
MPYF3 *AR0++, *AR1++, R0
ADDF3 R0, R2, R2
O valor somado a R2, não é o
resultado da multiplicação, mas sim
o valor anterior de R0
6
Saltos Atrasados e Pipeline
 Quando à um salto o pipeline
é interrompido, já que o
processador não sabe que
instrução vai executar de
seguida!
Solução: Saltos
atrasados
BcondD
Pipeline
As instruções são executadas em
paralelo num esquema tipo linha de
montagem
As três instruções seguintes ao salto são
executadas. Ex:
CMPI 0, R1
BeqD Loop
MPYF R3,R2
ABSF R2, R2
STF R2, @Var
As três
instruções são
executadas
antes do salto!
7
Endereçamento Circular
Exemplo, somar todos os valores de um buffer circular:
BUF_SZ
BUF_STR
buf_str
.set
127
Representação física
.brstart "buf_sec", BUF_SZ
.sect
"buf_sec“
.loop
BUF_SZ
O buffer deve ser
.float
0.0
alinhado numa posição
.endloop
com log2N bits a zero
.word
BUF_STR
Representação lógica
.text
.............................
Endereçamento
circular
; AR0 aponta para o início do buffer circular
LDI BUF_SZ,BK ; Indica tamanho do buffer
RPTS BUF_SZ -1 ; repete a próxima instrução BUF_SZ vezes
ADDF *AR0++%, R1
; soma valores
8
Implementação de um FIR
;****************************************************
; Filtros FIR de ordem N-1 (N coeficintes)
; y(n)= a(0)*x(n) + a(1)*x(n-1) + a(2)*x(n-2)+... a(N-1)*x(n-N+1)
;
; R0 - Input x(n)
;
; AR0 - Filter coeficients : a(0), a(1), ... , a(N-1)
; AR1 - Circular Buffer Pointer: x(n-1), ...., x(n-N)
;
(deve ser presevado entre chamadas)
; N - Numero de coeficientes do filtro
;
; Altera: R0, AR0, AR1
; R2 - Output y(n)
;****************************************************
; Enderecamento circular, cuidado: Endereco inicial =xxxxx(0)n b
; n = numero de bits ate ao ultimo '1' de BK
; Ex: BK=31 => xx xxx0 0000
; BK=32 => XX XX00 0000 (buffer de 64 amostras!)
; BK = N = Tamanho do Buffer
; Assim este deve ser <> que 2^n-1
; O filtro comeca por inserir a amostra corrente no buffer.
;
; Filtro FIR1: in - R0; out - R2
FIR1 ldi N, BK
ldf *AR1--(1)%, R2 ; AR1 aponta para x(n-N)
; R2 auxiliar
stf R0, *AR1
ldf 0.0, R2
ldf 0.0, R1 ;O primeiro add utiliza o valor passado de R1
rpts N-1
mpyf3 *AR0++, *AR1++(1)%, R1 ; dst1=R0 ou R1
|| addf3 R2,R1,R2
; dst2=R2 ou R3
addf3 R2,R1,R2
;Falta adicionar o ultimo valor
sti AR1, @fir1_bf
9
Implementação de um IIR
AR0
AR1
* INPUT: R2, AR0, AR1, BK
* MODIFIED: R0, R1, R2, AR0, AR1 * RESULT: R0
* AR1 should be preserver between calls
** CYCLES: 11 WORDS: 8
.global IIR1; * FILTER
*
IIR1:
MPYF3 *AR0,*AR1,R0 * ; a2 * d(n-2) -> R0
MPYF3 *++AR0(1),*AR1––(1) % ,R1* ; b2 * d(n-2) -> R1
MPYF3 *++AR0(1),*AR1,R0 ; a1 * d(n-1) -> R0
|| ADDF3 R0,R2,R2 ; a2*d(n-2)+x(n) -> R2
MPYF3 *++AR0(1),*AR1––(1)%,R0 ; b1 * d(n-1) -> R0
|| ADDF3 R0,R2,R2 ; a1*d(n-1)+a2*d(n-2)+x(n) -> R2
MPYF3 *++AR0(1), *AR1––(1)% ,R2 ; b0 * d(n) -> R2 ;
!!!d(n-3) erro!!!
|| STF R2,*AR1--(1)% ; store d(n) (in d(n-2)) and point to
d(n-1)
ADDF R0,R2 ; b1*d(n-1)+b0*d(n) -> R2
ADDF3 R1,R2,R0 ; b2*d(n-2)+b1*d(n-1)+b0*d(n) -> R0
RETS ; Return
Cálculo de y[n]
Só são necessárias
duas posições!!
Endereços
Buffer circular
R2
Cálculo de d[n]
R0
d[n] = w[n]
R1
10