Programowanie Procesorów Sygnałowych

Programowanie Procesorów Sygnałowych
Krzysztof Bikonis p. 738 tel

Tematyka zajęć Procesory stałoprzecinkowe rodziny ADSP-21xx
Procesory zmiennoprzecinkowe rodziny ADSP-21k Środowisko programistyczne (symulacja, kompilacja, uruchamianie) Praca w grupach z zestawami - ADSP EZ-LAB x5

Architektura procesorów stałoprzecinkowych z rodziny 21xx

Jednostka arytmetyczno-logiczna wykonywane operacje: dodawanie, dodawanie z przeniesieniem, odejmowanie, odejmowanie z „pożyczką”, zmiana znaku, operacje logiczne AND, OR, XOR, NOT 16-bitowe rejestry AX0 i AX1 – pierwszy argument operacji, AY0 i AY1 – drugi argument operacji, AR i AF – wynik operacji (AR -> DMD BUS, AF -> drugi argument operacji) R BUS -> wyjścia innych układów jako drugi argument operacji rejestry mogą być odczytywane i zapisywane w jednym cyklu rozkazowym (odczyt na początku, zapis na końcu cyklu) argumenty stałoprzecinkowymi liczbami ułamkowymi w formacie 1.15

Jednostka arytmetyczno-logiczna wykonywane operacje: dodawanie, dodawanie z przeniesieniem, odejmowanie, odejmowanie z „pożyczką”, zmiana znaku, operacje logiczne AND, OR, XOR, NOT 16-bitowe rejestry AX0 i AX1 – pierwszy argument operacji, AY0 i AY1 – drugi argument operacji, AR i AF – wynik operacji (AR -> DMD BUS, AF -> drugi argument operacji) R BUS -> wyjścia innych układów jako drugi argument operacji rejestry mogą być odczytywane i zapisywane w jednym cyklu rozkazowym (odczyt na początku, zapis na końcu cyklu) argumenty stałoprzecinkowymi liczbami ułamkowymi w formacie 1.15 B = -1 B = -0.5 B = 0 B = 0.5 B = 1

Jednostka arytmetyczno-logiczna wykonywane operacje: dodawanie, dodawanie z przeniesieniem, odejmowanie, odejmowanie z „pożyczką”, zmiana znaku, operacje logiczne AND, OR, XOR, NOT 16-bitowe rejestry AX0 i AX1 – pierwszy argument operacji, AY0 i AY1 – drugi argument operacji, AR i AF – wynik operacji (AR -> DMD BUS, AF -> drugi argument operacji) R BUS -> wyjścia innych układów jako drugi argument operacji rejestry mogą być odczytywane i zapisywane w jednym cyklu rozkazowym (odczyt na początku, zapis na końcu cyklu) argumenty stałoprzecinkowymi liczbami ułamkowymi w formacie 1.15 Znaczenie bitów rejestru stanu ASTAT AZ – oznacza AR=0 AN – oznacza AR ujemne AC – oznacza przeniesienie z najbardziej znaczącej pozycji wyniku dodawania AV – oznacza przepełnienie AR AS – znak argumentu pierwszego (X) dla ALU AQ – bit wyniku generowany podczas dzielenia Znaczenie bitów rejestru trybu MSTAT 3 – ALU przechodzi do pracy z „nasyceniem” (gdy wystąpi przepełnienie -> AR największa/najmniejsza możliwa liczba dla tego rej.) 2 – zatrzaskiwanie stanu przepełnienia 0 – wybór zbioru rejestrów ALU = pierwszy = drugi B = -1 B = -0.5 B = 0 B = 0.5 B = 1

Układ mnożąco-akumulujący wykonywane operacje: mnożenie liczb stałoprzecinkowych oraz mnożenie i akumulacja (dodawanie lub odejmowanie) 16-bitowe rejestry MX0 i MX1 – pierwszy argument operacji, MY0 i MY1 – drugi argument operacji, bitowy rejestr MR (MR2 8 bitów, MR1 i MR0 16 bitów) – rejestr wyjściowy rejestr MR ma własność „nasycenia”, czyli jeśli zostanie wykryte przepełnienie to do MR zostanie zapisana największa/najmniejsza 32-bitowa liczba (Czy rejestr MR zostanie „nasycony”, czy nie, jest częścią kodu instrukcji) możliwość zaokrąglania 40-bitowego wyniku obliczeń do 16 bitów, wynik zaokrąglenia do rejestru MF, lub MR1 (znak powielony w rejestrze MR2) 16-bitowy rejestr MF – rejestr pośredniczący, można go wykorzystać w następnym rozkazie mnożenia przez podanie na wejście Y układu mnożącego rejestry mogą być odczytywane i zapisywane w jednym cyklu rozkazowym (odczyt na początku, zapis na końcu cyklu)

Układ mnożąco-akumulujący wykonywane operacje: mnożenie liczb stałoprzecinkowych oraz mnożenie i akumulacja (dodawanie lub odejmowanie) 16-bitowe rejestry MX0 i MX1 – pierwszy argument operacji, MY0 i MY1 – drugi argument operacji, bitowy rejestr MR (MR2 8 bitów, MR1 i MR0 16 bitów) – rejestr wyjściowy rejestr MR ma własność „nasycenia”, czyli jeśli zostanie wykryte przepełnienie to do MR zostanie zapisana największa/najmniejsza 32-bitowa liczba (Czy rejestr MR zostanie „nasycony”, czy nie, jest częścią kodu instrukcji) możliwość zaokrąglania 40 bitowego wyniku obliczeń do 16 bitów, wynik zaokrąglenia do rejestru MF, lub MR1 (znak powielony w rejestrze MR2) 16-bitowy rejestr MF – rejestr pośredniczący, można go wykorzystać w następnym rozkazie mnożenia przez podanie na wejście Y układu mnożącego rejestry mogą być odczytywane i zapisywane w jednym cyklu rozkazowym (odczyt na początku, zapis na końcu cyklu) Znaczenie bitów rejestru stanu ASTAT MV – oznacza przepełnienie MR Jeśli wynik operacji mnożenia i akumulacji nie mieści się w parze rejestrów MR1, MR0, to najbardziej znaczący bity wyniku znajdują się w rejestrze MR2 i ustawiana jest flaga MV przepełnienia akumulatora MR Znaczenie bitów rejestru trybu MSTAT 0 – wybór zbioru rejestrów = pierwszy = drugi 4 – tryb pracy 0 = liczby ułamkowe (1.15) 1 = liczby całkowite (16.0) Dla liczb bitowy wynik mnożenia jest rozszerzany do 40 bitów poprzez powielenie bitu znaku, przesuwany w lewo o jeden bit i podawany na wejście układu sumatora Dla liczb 16.0 rozszerzony do 40 bitów wynik jest bezpośrednio podawany na wejście układu sumatora

Przesuwnik pozwala jednym rozkazem umieścić 16-bitowy argument w dowolnym miejscu bitowego rejestru wyjściowego, łącznie z sytuacją gdy argument pozostaje poza rejestrem wyjściowym (49 położeń w rejestrze wyjściowym) 16-bitowy rejestr wejściowy SI – przesuwana liczba, 8-bitowy rejestr SE – liczba pozycji binarnych do przesunięcia (SE dodatnie – w lewo, SE ujemne – w prawo), 8-bitowy rejestr SB – argument w przypadku normalizacji lub denormalizacji bloku liczb, bitowy rejestr SR (SR1 i SR0 po 16 bitów) – wynik operacji rejestry mogą być odczytywane i zapisywane w jednym cyklu rozkazowym (odczyt na początku, zapis na końcu cyklu), są zdublowane (wybór poprzez bit 0 rejestru MSTAT)

Generatory adresowe I – rejestry indeksowe, M – rejestry modyfikacji, L – rejestry długości wykorzystując rejestr długości L można zorganizować w pamięci bufor kołowy, wtedy rejestr indeksowy I jest używany jako wskaźnik, natomiast rejestr L przechowuje długość bufora, a kiedy wskaźnik I przekroczy górną granicę bufora, to do rejestru I zostanie załadowany adres bazowy bufora

Sterowanie procesorem instrukcje są pobierane z kolejnych komórek pamięci programu wskazywanych przez licznik programu PC każda instrukcja jest wykonywana w jednym cyklu zegarowym zmiana kolejności realizacji instrukcji dokonuje się w wyniku wykonania instrukcji skoku, instrukcji skoku ze śladem (wywołanie podprogramu) lub instrukcji organizującej pętlę DO UNTIL (możliwość zagnieżdżania do czterech poziomów) przerwania w sposób sztywny mają przypisany priorytet, mogą być maskowane (IMASK) STATUS STACK stos sprzętowy, w trakcie obsługi przerwania są tam przechowywane rejestry ASTAT,MSTAT, IMASK PC STACK stos sprzętowy, w trakcie obsługi przerwania przechowuje licznik rozkazów tablica wektorów przerwań zaczyna się od adresu 0x0000, a program obsługi przerwania nie może przekraczać czterech instrukcji powrót z obsługi przerwania za pomocą instrukcji RTI ICNTL rejestr konfiguracji trybu pracy systemu przerwań, w ten sposób można uzyskać przerwania zewnętrzne czułe na wartość poziomu sygnału lub na jego zbocze lub zagnieżdżania przerwań IFC rejestr za pomocą którego można programowo wymusić przerwanie sprzętowe lub wyzerować zamaskowane przerwanie oczekujące na obsługę

Rodzina stałoprzecinkowych procesorów sygnałowych ADSP21xx

Symulator procesorów stałoprzecinkowych z rodziny 21xx

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

Początek modułu .MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD; Koniec programu

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Definicja stałej start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Definicja zmiennych start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Inicjalizacja zmiennych start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Powiązanie portu ze zmienną start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD; Tablica wektorów przerwań

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Inicjalizacja rejestrów indeksowych start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Inicjalizacja rejestrów długości start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; Inicjalizacja rejestrów modyfikacji start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD;

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD; Inicjalizacja rejestru licznika

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD; Wykorzystanie możliwości wykonywania kilku operacji jednocześnie

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD; Konstrukcja DO etykieta UNTIL warunek

.MODULE vector_add; .CONST n=10; .VAR/DM/RAM x_input[n]; .VAR/PM/RAM/ABS= y_input[n]; .INIT x_input: <xin.dat>; .INIT y_input: <yin.dat>; .PORT z_out; JUMP start; NOP; NOP; NOP; RTI; NOP; NOP; NOP; start: I2=^x_input; L2=0; I6=^y_input; L6=0; M0=1; L0=0; M5=1; L5=0; CNTR=n-1; AX0=DM(I2,M0), AY0=PM(I6,M5); DO add_loop UNTIL CE; AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5); add_loop: DM(z_out)=AR; AR=AX0+AY0; DM(z_out)=AR; IDLE; .ENDMOD; Wprowadzenie procesora w stan bezczynności

X_INPUT 0001 0002 0003 0004 0005 0006 0007 0008 0009 000A Y_INPUT 000B 000C 000D 000E 000F 0010 0011 0012 0013 0014 Z_OUT 000C 000E 0010 0012 0014 0016 0018 001A 001C 001E

.module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } Definicja bufora kołowego gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } Inicjalizacja rejestrów indeksowego (I), modyfikacji (M) i długości (L) gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } Generowanie sinusa gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

sin(t) 440Hz ≈ 2.27ms t 8kHz 125μs 64k 0 – 0000H, pi – 7FFFH, 2pi – FFFFH B = 4189H = 0.512

Arithmetic shift .module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } SR1 SR0 gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

Dwa przykłady zaokrąglania. Pierwszy to typowa operacja zaokrąglania (x=0 lub1). Przykład 1 MR2 MR MR0 Przed: xxxxxxxx xxxxxxxx xxxxxxxxxxxxxxx Bit 15 = 1. Dodajemy 1 do bitu Po: xxxxxxxx xxxxxxxx xxxxxxxxxxxxxxx Drugi, gdy 15 najmłodszych bitów to zera. Przykład 2 MR2 MR MR0 Przed: xxxxxxxx xxxxxxxx Bit 15 = 1, bity 0-14 = 0. Dodajemy 1 do bitu xxxxxxxx xxxxxxxx Bit 16 = 1, wymuszone na tym bicie 0 Po: xxxxxxxx xxxxxxxx

Arithmetic shift dddddddd dddddddd dddddddd dddddddd d .module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=sr1; wait: idle; jump wait; { } SR1 SR0 gen_sin: si=440; { freq stored as Hz } sr=ashift si by 3 (hi); my0=h#4189; { mult Hz by .512 * 2 } mr=sr1*my0(rnd); { i.e. mult by } sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=ar; wait: idle; jump wait; gen_sin: si=100; sr=ashift si by 3 (hi); my0=h#4189; mr=sr1*my0(rnd); sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; ar=abs ar; rts; #include "sin.dsp" .endmod;

.module/RAM/ABS=0 ex; .const N=0x100; .const freq1=440; .const freq2=220; .var/dm theta1; .var/dm theta2; .var/dm dtheta1; .var/dm dtheta2; .var/dm/ram/circ buf1[N]; .var/dm/ram/circ buf2[N]; .var/dm/ram/circ buf3[N]; .init theta1: 0; .init theta2: 0; jump start; start: si=freq1; sr=ashift si by 3 (hi); my0=h#4189; mr=sr1*my0(rnd); sr=ashift mr1 by 1 (hi); dm(dtheta1)=sr1; si=freq2; dm(dtheta2)=sr1; i0=^buf1;m0=1;l0=%buf1; i1=^buf2;m1=1;l1=%buf2; i2=^buf3;m2=1;l2=%buf3; m3=0; cntr=%buf1; do gen until ce; call gen_sin; gen: nop; wait: idle; jump wait; gen_sin: ax0=dm(dtheta1); ay0=dm(theta1); ar=ax0+ay0; dm(theta1)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); dm(i0,m3)=sr1; ax0=dm(dtheta2); ay0=dm(theta2); dm(theta2)=ar; dm(i1,m3)=sr1; ax0=dm(i0,m0); ay0=dm(i1,m1); dm(i2,m2)=ar; rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .const up=0x5FFF; .const down=0xA000; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=0; m1=1; l0=%buf; cntr=%buf; do gen until ce; call gen_sin; dm(i0,m0)=ar; ax0=up; ay0=dm(i0,m0); ar=ax0-ay0; if ge jump skip; dm(i0,m0)=up; skip: ax0=down; if le jump gen; dm(i0,m0)=down; gen: modify(i0,m1); wait: idle; jump wait; gen_sin: si=100; sr=ashift si by 3 (hi); my0=h#4189; mr=sr1*my0(rnd); sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; call boot_sin; rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex; .const N=0x100; .const theta_cut=0x3FFF; .var/dm theta; .var/dm/ram/circ buf[N]; .init theta: 0; jump start; start: i0=^buf;m0=1;l0=%buf; cntr=%buf; do gen until ce; call gen_sin; gen: dm(i0,m0)=ar; wait: idle; jump wait; gen_sin: si=100; sr=ashift si by 3 (hi); my0=h#4189; mr=sr1*my0(rnd); sr=ashift mr1 by 1 (hi); ay0=dm(theta); ar=sr1+ay0; dm(theta)=ar; ax0=ar; ay0=theta_cut; ar=ax0+ay0; if not ac jump skip; ar=pass 0x0; skip: ax0=dm(theta); call boot_sin; rts; #include "sin.dsp" .endmod;

.module/RAM/ABS= ex01; {filtr} .const taps=21; .const buf_size=0x100; .var/dm/ram/circ buf[buf_size]; .var/dm/ram/circ buf2[buf_size]; .var/dm/ram/circ delay[taps]; .var/pm/ram/circ coeffs[taps]; .init coeffs: <firhex.dat>; .init buf: <input.dat>; { interrupt table } jump start; start: i0=^delay; l0=%delay; m0=1; i1=^buf; l1=%buf; m1=1; i2=^buf2; l2=%buf2; m2=1; i4=^coeffs;l4=%coeffs;m4=-1; modify(i4,m4); cntr=%delay; do _clear until ce; _clear: dm(i0,m0)=0; cntr=%buf; do fir_do until ce; ar=dm(i1,m1); call fir; fir_do: dm(i2,m2)=ar; wait: idle; jump wait; { FIR subroutine } fir: dm(i0,m0)=ar; cntr=taps-1; mr=0, mx0=dm(i0,m0), my0=pm(i4,m4); do fir_loop until ce; fir_loop: mr=mr+mx0*my0(ss), … … mx0=dm(i0,m0), my0=pm(i4,m4); mr=mr+mx0*my0(rnd); if mv sat mr; ar=mr1; rts; .endmod;

.module/RAM/ABS= ex01; {filtr} .const taps=21; .const buf_size=0x100; .var/dm/ram/circ buf[buf_size]; .var/dm/ram/circ buf2[buf_size]; .var/dm/ram/circ delay[taps]; .var/pm/ram/circ coeffs[taps]; .var/pm/ram/circ coeffs2[taps]; .var/pm/ram mode[1]; .init coeffs: <firhex_dn.dat>; .init coeffs2: <firhex_up.dat>; .init mode: 0x100; {0x0 down 0x100 up} .init buf: <input.dat>; { interrupt table } jump start; start: i0=^delay; l0=%delay; m0=1; i1=^buf; l1=%buf; m1=1; i2=^buf2; l2=%buf2; m2=1; i5=^mode; l5=%mode; m5=0; ax0=0; ay0=pm(i5,m5); none=ax0-ay0; if eq call g1; if lt call g2; cntr=%delay; do _clear until ce; _clear: dm(i0,m0)=0; cntr=%buf; do fir_do until ce; ar=dm(i1,m1); call fir; fir_do: dm(i2,m2)=ar; wait: idle; jump wait; { FIR subroutine } fir: dm(i0,m0)=ar; cntr=taps-1; mr=0, mx0=dm(i0,m0), my0=pm(i4,m4); do fir_loop until ce; fir_loop: mr=mr+mx0*my0(ss), mx0=dm(i0,m0),… …my0=pm(i4,m4); mr=mr+mx0*my0(rnd); if mv sat mr; ar=mr1; rts; { MODE } g1: i4=^coeffs; l4=%coeffs; m4=-1; modify(i4,m4); { MODE } g2: i4=^coeffs2; l4=%coeffs2; m4=-1; modify(i4,m4); .endmod;

input mode 0 mode 1

ADSP2181 EZ-KIT LITE .module/RAM/ABS=0 loopback; #include "init.dsp"
#include "rs.dsp" #include "test.dsp" .var/dm mode; .init mode: 0; start: { processing init ----} { end of processing init } {call test_input_samples;} call dsp_init; call rs_init; ax1 = h#3e; {'>'} call rs_putc; wait: call rs_term; { terminal } ay0 = 27; { 'ESC ?' } none = ax1 - ay0; if eq rts; { go back to monitor. } toggle fl1; jump wait; {======= C O D E C R E C E I V E R H A N D L E R ===========} input_samples: { SPORT1 rx } ena sec_reg; { use shadow register bank } ax0 = dm (rx_buf + 1); { read from input auto-buffer } ax1 = dm (rx_buf + 2); { read from input auto-buffer } { processing } { end of processing } dm (tx_buf + 1) = ax0; { write to output auto-buffer } dm (tx_buf + 2) = ax1; { write to output auto-buffer } rti; {======= P U S H B U T T O N H A N D L E R =================} irqe: ena sec_reg; ay0=dm(mode); ar=ay0+1; dm(mode)=ar; .endmod;

Programowanie Procesorów Sygnałowych

Podobne prezentacje

Prezentacja na temat: "Programowanie Procesorów Sygnałowych"— Zapis prezentacji:

Podobne prezentacje

О projekcie

Zwrotny adres

Wejść

Zaloguj się poprzez sieć społeczną:

Programowanie Procesorów Sygnałowych

Podobne prezentacje

Prezentacja na temat: "Programowanie Procesorów Sygnałowych"— Zapis prezentacji:

Podobne prezentacje

О projekcie

Zwrotny adres