Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

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

Podobne prezentacje


Prezentacja na temat: "Programowanie Procesorów Sygnałowych Krzysztof Bikonis p. 738tel. 347 1326."— Zapis prezentacji:

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

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

3 Architektura procesorów stałoprzecinkowych z rodziny 21xx

4 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

5 Architektura procesorów stałoprzecinkowych z rodziny 21xx B = B = B = B = 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

6 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 B = B = B = B = B = 1 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 0 = pierwszy 1 = drugi

7 Architektura procesorów stałoprzecinkowych z rodziny 21xx 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, 40-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)

8 Architektura procesorów stałoprzecinkowych z rodziny 21xx 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, 40-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 0 = pierwszy 1 = 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

9 Architektura procesorów stałoprzecinkowych z rodziny 21xx Przesuwnik pozwala jednym rozkazem umieścić 16-bitowy argument w dowolnym miejscu 32-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, 32-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)

10 Architektura procesorów stałoprzecinkowych z rodziny 21xx 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

11 Architektura procesorów stałoprzecinkowych z rodziny 21xx 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ę

12 Architektura procesorów stałoprzecinkowych z rodziny 21xx

13 Rodzina stałoprzecinkowych procesorów sygnałowych ADSP21xx

14 Symulator procesorów stałoprzecinkowych z rodziny 21xx

15

16

17

18

19

20

21

22

23 .MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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;

24 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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 Początek modułu

25 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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; Definicja stałej

26 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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; Definicja zmiennych

27 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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 zmiennych

28 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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; Powiązanie portu ze zmienną

29 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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ń

30 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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 rejestrów indeksowych

31 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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 rejestrów długości

32 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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 rejestrów modyfikacji

33 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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

34 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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

35 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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

36 Symulator procesorów stałoprzecinkowych z rodziny 21xx.MODULE vector_add;.CONST n=10;.VAR/DM/RAM x_input[n];.VAR/PM/RAM/ABS=100 y_input[n];.INIT x_input: ;.INIT y_input: ;.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

37 Symulator procesorów stałoprzecinkowych z rodziny 21xx X_INPUT A Y_INPUT 000B 000C 000D 000E 000F Z_OUT 000C 000E A 001C 001E

38 Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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;

39 Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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; Definicja bufora kołowego

40 Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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;

41 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; Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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

42 Symulator procesorów stałoprzecinkowych z rodziny 21xx t sin(t) 440Hz 2.27ms 8kHz 125μs B = 4189H = k 0 – 0000H, pi – 7FFFH, 2pi – FFFFH

43 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; Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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; { } Arithmetic shift SR0 SR1

44 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; Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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; { }

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

46 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; Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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; { } Arithmetic shift dddddddd dddddddd dddddddd dddddddd d SR0 SR1

47 Symulator procesorów stałoprzecinkowych z rodziny 21xx

48 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; Symulator procesorów stałoprzecinkowych z rodziny 21xx.module/RAM/ABS=0 ex;.const N=0x100;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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;

49 Symulator procesorów stałoprzecinkowych z rodziny 21xx

50 .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; sr=ashift si by 3 (hi); my0=h#4189; mr=sr1*my0(rnd); sr=ashift mr1 by 1 (hi); 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); ar=ax0+ay0; dm(theta2)=ar; ax0=ar; call boot_sin; sr=ashift ar by -1 (hi); dm(i1,m3)=sr1; ax0=dm(i0,m0); ay0=dm(i1,m1); ar=ax0+ay0; dm(i2,m2)=ar; rts; #include "sin.dsp".endmod;

51 Symulator procesorów stałoprzecinkowych z rodziny 21xx

52 .module/RAM/ABS=0 ex;.const N=0x100;.const up=0x5FFF;.const down=0xA000;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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; ay0=dm(i0,m0); ar=ax0-ay0; 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;

53 Symulator procesorów stałoprzecinkowych z rodziny 21xx

54 .module/RAM/ABS=0 ex;.const N=0x100;.const theta_cut=0x3FFF;.var/dm theta;.var/dm/ram/circ buf[N];.inittheta: 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; dm(theta)=ar; skip: ax0=dm(theta); call boot_sin; rts; #include "sin.dsp".endmod;

55 Symulator procesorów stałoprzecinkowych z rodziny 21xx

56 .module/RAM/ABS=0 ex01;{filtr}.const taps=21;.const buf_size=0x100;.var/dm/ram/circbuf[buf_size];.var/dm/ram/circbuf2[buf_size];.var/dm/ram/circdelay[taps];.var/pm/ram/circcoeffs[taps];.init coeffs: ;.init buf: ; { 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;

57 Symulator procesorów stałoprzecinkowych z rodziny 21xx

58 .module/RAM/ABS=0 ex01;{filtr}.const taps=21;.const buf_size=0x100;.var/dm/ram/circbuf[buf_size];.var/dm/ram/circbuf2[buf_size];.var/dm/ram/circdelay[taps];.var/pm/ram/circcoeffs[taps];.var/pm/ram/circcoeffs2[taps];.var/pm/rammode[1];.init coeffs: ;.init coeffs2: ;.initmode: 0x100; {0x0 down 0x100 up}.init buf: ; { 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); rts; { MODE } g2: i4=^coeffs2; l4=%coeffs2; m4=-1;modify(i4,m4); rts;.endmod;

59 Symulator procesorów stałoprzecinkowych z rodziny 21xx input mode 0 mode 1

60 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; rti;.endmod;


Pobierz ppt "Programowanie Procesorów Sygnałowych Krzysztof Bikonis p. 738tel. 347 1326."

Podobne prezentacje


Reklamy Google