Rejestry przesuwne, Pamięci

1. Rejestry przesuwne, Pamięci Ernest Jamro Kat. Elektroniki AGH

2. Multiplekser Mux 2:1 Mux 4:1

3. Sel\In1, In0 00 01 11 10 0 0 1 1 0 1 0 0 1 1 Multiplekser 2:1 na bramkach Out= SelIn0 + Sel In1

4. Multiplekser na bramkach – postać ogólna Mux 4:1

5. Multiplekser na buforach trójstanowych VHDL (wewnątrz FPGA): Ch(1)<= In1 when Tn(1)=‘1’ else ‘Z’; Ch(2)<= In2 when Tn(2)=‘1’ else ‘Z’; VHDL (testbench): Y<= ch(1); Y<= ch(2); Aby uniknąć krótkotrwałego zwierania buforów stosuje się krótki czas martwy w którym wszystkie bufory są w stanie wysokiej impedancji. Wymaga to użycia automatu zamiast prostego dekodera kodu binarnego na 1 z n.

6. Multiplekser na bramkach OC *.ucf NET "ch<1>" LOC = "T3" ; NET "ch<1>" PULLUP; VHDL bramka OD/OC: Ch(1)<= ‘0’ when D0=‘0’ else ‘Z’; Ch(2)<= ‘0’ when D1=‘0’ else ‘Z’; Y= S’D0 + SD1 - multiplekser A + B= (A’B’)’ - prawo De Morgana, (Wired AND) Y= ( (S’D0)’ (SD1)’ )’

7. Demultiplekser

8. Multipleksowanie w czasie Wyświetlacz 7-segmentowy Tylko jeden wyświetlacz jest aktywny w danej krótkiej chwili czasowej W układach scalonych z reguły bardziej kosztowne jest dodanie dodatkowego wyprowadzenia niż dodatkowej logiki

9. SIPO (Serial-In Parallel-Out) process(clk) begin if clk'event and clk1=‘1' then Q(N-1 downto 0)<= Q(N-2 downto 0) & Din; end if; end process;

10. SIPO (Clock Enable) – błędne użycie Przykład taktowania co drugi takt zegara modułu SIPO i złego użycia bramki AND na sygnale zegarowym – powstaje wyścig!!!

11. SIPO (Clock Enable) – poprawne użycie Przykład taktowania co drugi takt zegara SIPO – sygnał zegarowy jest wyjściem Q przerzutnika (Uwaga wyścig może powstać pomiędzy sygnałem Din a Clk2).

12. SIPO (CE - Clock Enable)

13. SISO (Serial-In Serial-Out)

14. Parallel-In Serial-Out (PISO)

15. PISO - VHDL process(clk) begin if clk'event and clk1=‘1' then if load=‘1’ then Q <= D; else Q(N-1 downto 0)<= Q(N-2 downto 0) & Din; end if; end if; end process; Qout<= Q(N-1);

16. Przesyłanie danych szeregowo Sposób 1 Sposób 2 PISO Clk SIPO D clk takt

17. ci-1\ai ci-1\ai 0 0 1 1 0 0 0 0 0 1 1 1 1 0 1 0 Incrementator (S=A+1) Si Ci HA Half Adder si = ai ci-1 ci= ai ci-1

18. Incrementator: Example A=10112= 1110=0xB S=A+1= 11002=1210=0xC

19. ci-1\ai,bi ci-1\ai,bi 00 00 01 01 11 11 10 10 0 0 0 0 0 1 1 0 0 1 1 1 0 1 0 1 1 1 1 0 Dodawanie z szeregową propagacją przeniesienia(Ripple Carry) Adder: S= A+B si ai + bi+ci-1 = si + 2·ci si = ai bi ci-1 ci= ai bi + ai ci-1 + bi ci-1= ai bi + ci-1 (ai bi) ci Propagate Generate

20. ci-1\ai,bi ci-1\ai,bi 00 00 01 01 11 11 10 10 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 0 1 1 0 0 Odejmowanie / Subtraction (a-b) Direct Two’s Complement (2C) ai - bi-ci-1 = si - 2·ci si = ai bi ci-1 Add 1 to the LSB (Least Significant Bit) Sign bit negation si Instead of employing dedicated subtraction we can use a standard adder convert B to 2C code Example: 1111 in 2C= 0000+1= 0001 (minus one) ci Red color – difference between addition and subtraction

21. Add/Subtract Logic S<= A+B when Sub=‘0’ else A-B; Convert B to Two’s Complement when Sub=1

22. Dodaj,Odejmij, Przepełnienie, Przykłady Add: 9+1= 10 01001 = 9 00001 = 1 01010 = 10 Add: 9+8= 17 01001 = 9 01000 = 8 10001 = -15 Overflow Add: -9+8= -1 10111 = -9 01000 = 8 11111 = -1 0 0 0 0 0 0 1 0 0 0 Overflow= CarryOutN xor CarryOutN-1 Subtract: 9-1= 8 01001 = 9 11111 = -1 01000 = 8 Subtract: 9-8= 1 01001 = 9 11000 = -8 00001 = 1 Subtract: -9-8= -17 10111 = -9 11000 = -8 01111= 15 Overflow 1 1 0 0 0 1 0 0 0 0

23. Counter mod 2N Qn+1= Qn+1 architecture Beh of counter_2N is signal Q: std_logic_vector(3 downto 0); begin process(clk, reset_asynch) begin if reset_asynch=‘1’ then Q<= (others=>’0’); elsif clk’event and clk=‘1’ then Q<= Q + 1; end if; end process; Count<= Q end Beh; library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity counter_2N is port(clk, reset_asynch: in std_logic; count : out std_logic_vector (3 downto 0)); end counter_2N; architecture Behavioral of race_ce is signal p: std_logic_vector(4 downto 0);

24. Counter mod N architecture Beh of counter_N is signal Q: std_logic_vector(3 downto 0); begin process(clk) begin if clk’event and clk=‘1’ then if reset_synch=‘1’ or Q=N-1 then Q<= (others=>’0’); else Q<= Q + 1; end if; -- not reset end if; -- clk end process; end Beh;

25. Up/Down Counter mod 2N architecture Beh of counter_up_down is signal Q: std_logic_vector(3 downto 0); begin process(clk) begin if clk’event and clk=‘1’ then if Up_DownN=‘1’ then Q<= Q + 1; else Q<= Q - 1; end if; -- up / downN end if; -- clk end process; Count <= Q; end Beh;

26. Up/Down Counter mod N process(clk) begin if clk’event and clk=‘1’ then if Up_DownN=‘1’ then if Q = N-1 then Q<= (others=>’0’) else Q<= Q + 1; end if; else -- counting down if Q = 0 then Q<= conv_std_logic_vector(N-1, vec_width); else Q<= Q - 1; end if; end if; -- up / downN end if; -- clk end process;

27. Rotacja, Przesunięcie logiczne i Arytmetyczne Wejście: a3a2a1a0 W lewo Rot: a2a1a0a3 B<= A(2 downto 0) & A(3); Log: a2a1a00 B<= A(2 downto 0) & ‘0’; Arith: a2a1a00 B<= A(2 downto 0) & ‘0’; W prawo Rot: a0a3a2a1 B<= A(0) & A(3 downto 1); Log: 0a3a2a1 B<= ‘0’ & A(3 downto 1); Arith: a3a3a2a1 B<= A(3) & A(3 downto 1); Logiczne –mnożenie/dzielenie przez 2 dla nieujemnych liczb Arytmetyczne: mnożenie/dzielenie przez 2 dla uzupełnień do dwóch Przykład: –1= 1111; -1/2= 1111= -1

28. Rejestr przesuwny w prawo lub lewo SLEFT=0 – przesuń w prawo SLEFT=1 – przesuń w lewo

29. Rejestr przesuwny w prawo i w lewo z wpisem równoległym process(clk) begin if clk’event and clk=‘1’ then if S(1)= ‘1’ then -- load Q<= D; elsif S(0)= ‘0’ then – shift right Q<= Dleft & Q(3 downto 1); else -- shift left Q<= Q(2 downto 0) & Drigth; end if; end if; end process; S= 0 - przesuń w prawo S=1 - przesuń w lewo S=2 - wpis równoległy S=3 - wpis równoległy

30. Rejestr przesuwny: rotujący, logiczny, arytmetyczny Mnożenie/dzielenie przez 2 Kopiowanie bity znaku przy dzieleniu w kodzie U2

31. Barrel Shifter (szybkie przesunięcie o dowolną liczbę bitów) Mnożenie Dzielenie (kod U2 - uzupełnień do dwóch)

32. Barrel Shifter - wielopoziomowy Każdy z n poziomów przesuwa o 0 lub 2i-bitów (i=0..(n-1)) bitów w ten sposób można przesunąć o dowolną liczbę bitów w zakresie od (0..2n-1)-bitów używając prostych multiplekserów 2:1.

33. Pamięci - klasyfikacja • ROM (Read Only Memory) - nieulotne (non-volatile) • ROM (programowany podczas produkcji układu scalonego) • PROM (programowane jednorazowo u użytkownika) • EPROM (Erasable PROM – możliwa ale uciążliwa wielokrotna programowalność • EEPROM (Electrically Erasable and Programmable ROM) • Flash (błysk-awiczne EEPROM) • RAM (Random Access Memory), Ulotne • Pamięci specjalizowane

34. Pamięci ROM • Pamięci ROM powstają bezpośrednio w procesie produkcji układu scalonego dlatego mają następujące cechy: • Stan pamięci określony na poziomie produkcji układu scalonego • Brak możliwości zmiany zawartości pamięci • Tanie w produkcji ale wymagają dużych nakładów (wykonania w milionach sztuk – drogie przy małej liczbie sztuk) • Długi okres produkcji – kilkanaście tygodni. • Pamięci coraz rzadziej stosowane

35. Schemat pojedynczej komórki ROM

36. Wybieranie 2 wymiarowe Sposób wybierania np. klawiszy, komórek pamięci, itd

37. Dwuwymiarowe wybieranie komórki pamięci

38. Pamięci PROM Programmable Read Only Memory: Programowanie pamięci wykonywane jest przez użytkownika w specjalnym urządzeniu programującym. Programowanie następuje poprzez przepalenie tzw. bezpieczników (ang. fuse) i jest nieodwracalne. Pamięci te są dzisiaj rzadko stosowane

39. Pamięci EPROM Erasable Programmable ROM Kasowanie pamięci wymaga użycie promieni UV i specjalnego okienka kwarcowego – co zdecydowanie podraża koszt produkcji. Czas kasowania to około 30min. Pamięci dzisiaj raczej nie stosowane

40. Tranzystor w EPROM Swobodna bramka (floating gate)

41. Pamięci EEPROM Electrically Erasable Programmable Read-Only Możliwość elektrycznego wielokrotnego kasowania pamięci. Łatwość kasowania, nie potrzeba użycia promieni UV Kasowanie całej pamięci lub pojedynczego sektora Liczba kasowań około 10 000 - 100 000 razy

42. Programowanie i kasowanie EEPROM

43. Pamięć EEPROM Flash Struktura działania podobna do EEPROM. Bardzo szybki proces kasowania (rzędu 1ms) w porównaniu z pamięcią EEPROM (rzędu 15min.). Szybkość pracy pamięci Flash polega głównie na kasowaniu całego bloku na raz a nie jak to ma miejsce w pamięci EEPROM pojedynczych bajtów. Potrzebny tylko 1 tranzystor na 1 bit pamięci

44. Flash – kasowanie i programowanie

45. Struktura NOR i NAND pamięci Flash • Struktura NOR • b) NAND

46. Flash: NOR i NAND • W strukturze NAND napięcia wszystkich (oprócz jednej) bramek WL0-WL15 są na tyle wysokie że tranzystory szeregowe zawsze przewodzą. Natomiast napięcie jednej bramki jest takie, że stan pracy tranzystora zależy od zaprogramowania. • Cechy struktury NOR: • Swobodny odczyt, ale wolny zapis i kasowanie • Preferowane jako pamięci o dostępie swobodnym (BIOS, ROM procesora) • Cechy struktury NAND • Preferowany odczyt całego bloku danych • Tańsze w produkcji od NOR (zajmują mniej powierzchni krzemu) • Szybszy zapis i kasowanie • Liczba kasowań około 10 razy większa niż w przypadku NOR • Preferowany dla pamięci masowych (pendrive, karty CF/SD, SSD- Solid State Drive)

47. Wielopoziomowe pamięci FlashMultiple Level Cell (MLC) Alternatywa: Single Level Cell (SLC)

48. Pamięci Flash i Interface szeregowy: • I2C (Inter Integrated Circuit) – 2 przewody (100, 400kHz, 3.4MHz) (Philips) • SPI (Serial Peripherial Interface) – 3 przewody (1-50MHz) (Motorola) • Microwire – 3 przewody (1-3MHz) (National Semiconductor)

49. Przykład pamięci ROM w VHDL library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; entity rom is port ( ADDR : in std_logic_vector(5 downto 0); DATA : out std_logic_vector(19 downto 0)); end rom; architecture syn of rom is type rom_type is array (63 downto 0) of std_logic_vector (19 downto 0); signal ROM : rom_type:= (X"0200A", X"00300", X"08101", X"04000", X"08601", X"0233A", X"00300", X"08602", X"02310", X"0203B", X"08300", X"04002", X"08201", X"00500", X"04001", X"02500", X"00340", X"00241", X"04002", X"08300", X"08201", X"00500", X"08101", X"00602", X"04003", X"0241E", X"00301", X"00102", X"02122", X"02021", X"00301", X"00102", X"02222", X"04001", X"00342", X"0232B", X"00900", X"00302", X"00102", X"04002", X"00900", X"08201", X"02023", X"00303", X"02433", X"00301", X"04004", X"00301", X"00102", X"02137", X"02036", X"00301", X"00102", X"02237", X"04004", X"00304", X"04040", X"02500", X"02500", X"02500", X"0030D", X"02341", X"08201", X"0400D"); begin data <= ROM(conv_integer(ADDR)); end syn;

50. Pamięci • ROM (Read Only Memory) • RAM (Random Access Memory) • Statyczne (SRAM) • Asynchroniczne • Synchroniczne • Dynamiczne (DRAM) • -Asynchroniczne (historia) • - Synchroniczne SDRAM, DDR, DDR2, DDR3, RAM-BUS (RDRAM), XDR-DRAM • Specjalizowane • FIFO (First-In First-Out) • LIFO (Last-In First-Out – stos) • CAM (Content-Addressable Memory) • LUT (Look-Up Table) (pamięć ROM/RAM)