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çã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)

Endereçamento indirecto O Processador TMS320C3x Endereçamento indirecto Cálculos intermédios Registos Modos de endereçamento Imediato – constantes LDF 34, R1 Registo – acesso a registos LDF R2, R1 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 R0 R0 Extended-precision register .... R7 R7 Extended-precision register AR0 R8 Auxiliary Register .... AR7 Auxiliary Register DP Data-page pointer IR0 Index register 0 IR1 Index register 1 BK Block-size register SP Active stack pointer ST Status register RS Repeat start address RE Repeat end address RC Repeat counter Consultar o Manual para descrição mais detalhada

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

src- pode ter vários modos de endereçamento Uma página do Manual src- pode ter vários modos de endereçamento 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 direct 1 0 indirect 1 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 1 Status 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. dst - registo Nota: Retirada do ficheiro de ajuda

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+1 ciclos para implementar um FIR de ordem M

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

Saltos Atrasados e Pipeline Quando à um salto 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 montagem Solução: Saltos atrasados BcondD 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!

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 .endloop buf_str .word BUF_STR .text ............................. ; 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 Representação física O buffer deve ser alinhado numa posição com log2N bits a zero Representação lógica Endereçamento circular

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

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)!!! || 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 Só são necessárias duas posições!! Endereços Buffer circular R2 Cálculo de d[n] d[n] = w[n] R0 Esta implementação tem um erro!! Cálculo de y[n] R1