1

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 IIR e FIR): Instruções num ciclo de relógio

Nomeadamente, Multiplicação + AdiçãoMultiplicação + Adição(Multiply and Acumulate, MACMAC) (C3x – Instruções paralelas) Facilidades para a Implementação de Buffers (C3x – Buffers

circulares) Ciclos por Hardware (C3x - Repeat Block)

M

mm mnxbny

0

][.][

2

O Processador TMS320C3x

RegistosR0 R0 Extended-precision register....R7 R7 Extended-precision registerAR0 R8 Auxiliary Register....AR7 Auxiliary RegisterDP Data-page pointerIR0 Index register 0IR1 Index register 1BK Block-size registerSP Active stack pointerST Status registerRS Repeat start addressRE Repeat end addressRC Repeat counter

Consultar o Manual para descrição mais detalhada

Modos de endereçamentoModos de endereçamento

Imediato – constantesLDF 34, R1

Registo – acesso a registosLDF R2, R1

Directo – acesso a posições de memoria pré determinadasLDF @VAR, R0

Indirecto – acesso a posições de memoria indicadas em registos

LDF *AR1, R2

Cálculos intermédios

Endereçamento indirecto

3

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

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

m[x] = conteúdo da posição de

memória x

4

Uma página do Manual

MPYI Multiply Integer

Syntax MPYI src, dst

Operation dst x src -> dst

Operands src general addressing modes (G):

0 0 register (Rn, 0 <= n <= 27)0 1 direct1 0 indirect1 1 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 1Status Bits These condition flags are modified only if

the destination register is R7 - R0.

LUF Unaffected.LV 1 if an integer overflow occurs, unchanged otherwise.UF 0.N 1 if a negative result is generated, 0 otherwise.Z 1 if a zero result is generated, 0 otherwise.V 1 if an integer overflow occurs, 0 otherwise.C Unaffected.

Mode Bit OVM Operation is affected by OVM bit value.

src- pode ter vários modos de endereçamento

dst - registo

Nota: Retirada do ficheiro de ajuda

5

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

M

m

mnxmhny0

][].[][ Como manter o Buffer actualizado?

Buffer circular!

M+1 ciclos para implementar um FIR de ordem MM+1 ciclos para implementar um FIR de ordem M

6

Instruções Paralelas

Duas instruções são executadas simultaneamente!

ExEx: Instrução MACMAC, Multiply and Acumulate

MPYF3 *AR0++, *AR1++, R0

|| ADDF3 R0, R2, R2

Em geral os registos são lidos no inicio do ciclo de relógio e escritos no fim!

O valor somado a R2, não é o resultado da multiplicação, mas sim

o valor anterior de R0

7

Saltos Atrasados e Pipeline

Quando à um saltosalto o pipeline é interrompido, já que o processador não sabe que instrução vai executar de seguida!

Pipeline

As instruções são executadas em paralelo num esquema tipo linha de

montagemSolução: Saltos atrasadosBcondDBcondD

As três instruções seguintes ao salto são executadas. Ex:

CMPI 0, R1BeqD LoopMPYF R3,R2ABSF R2, R2STF R2, @Var

As três instruções são

executadas antes do salto!

8

Endereçamento Circular

Exemplo, somar todos os valores de um buffer circular:

BUF_SZ .set 127

.brstart "buf_sec", BUF_SZ .sect "buf_sec“BUF_STR .loop BUF_SZ .float 0.0

.endloopbuf_str .word BUF_STR

.text

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

; AR0 aponta para o início do buffer circular

LDI BUF_SZ,BK ; Indica tamanho do bufferRPTS BUF_SZ -1 ; repete a próxima instrução BUF_SZ vezesADDF *AR0++%%, R1 ; soma valores

Representação lógica

Representação física

Endereçamento circular

O buffer deve ser alinhado numa posição com log2N bits a zero

9

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

10

Implementação de um IIR

* 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) -> R0MPYF3 *++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) -> R2MPYF3 *++AR0(1),*AR1––(1)%,R0 ; b1 * d(n-1) -> R0|| ADDF3 R0,R2,R2 ; a1*d(n-1)+a2*d(n-2)+x(n) -> R2MPYF3 *++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) -> R2ADDF3 R1,R2,R0 ; b2*d(n-2)+b1*d(n-1)+b0*d(n) -> R0RETS ; Return

AR0 AR1

R0

R1

R2

Endereços

Buffer circular

d[n] = w[n]

Cálculo de d[n]

Cálculo de y[n]

Só são necessárias duas posições!!