PicoBlaze z jaką maksymalną częstotliwością zegara działa na Elbercie?

[FlyingDutch]

Cześć witam wszystkich,

mam pytanie - jak widziałem Elvis kombinował z IP Core PLL do generacji wyższej częstotliwości zegara na płytce Elbert. Mam w związku z tym dwa pytania:

1) Jaki jest najwyższy zegar z którym typowe konstrukcje w VHDL działają poprawnie na płytce Elbert. Zdaję sobie sprawę, że pytanie jest trochę bez sensu bo to zależy od konkretnego projektu. Z drugiej strony nie ma jakichś konkretnych ograniczań na zegar używany z naszą wersją Spartana 3A (z różnych materiałów w sieci wynika, że to ograniczenie zawiera się pomiędzy 100 a 200 MHz dla naszego modelu, przy dobrze wykonanym projekcie)

2) Jaki jest najwyższy zegar z jakim PicoBlaze (kcpsm3) na Elbercie V2 działa prawidłowo? Czy są dostępne dla niego jakieś gotowe benchmarki dla instrukcji stałoprzecinkowych?

Wiem, że teoretycznie liczba MIPSów to zegar / 2 (bo instrukcja wykonuje się w 2 taktach zegara) ale chodzi mi o praktyczny pomiar (w programie).

3) Czy macie jakiś pomysł jak to przetestować (program w assemblerze i procedura testowa)?

Update: Chyba wymyśliłem procedurę testową (jeśli uważacie, że jest bez sensu dajcie znać - nie obrażę się 😮 )

Postaram się napisać w asemblerze dla PicoBlaze liczenie funkcji CRC (np. CRC-7), które ma dość prostą implementację (powinno dać się zaimplementować w assemblerze psm i zmieścić się w 1K ROM). Patrz przykład:

http://www.microchip.com/forums/m94767.aspx

Będę w pętli liczył CRC-7 dla podanej wartości (której prawidłowe CRC-7 będę znał) i porównywał z wcześniej obliczoną 'dobrą' wartością. W przypadku niezgodności wyników wywołam procedurę sygnalizującą błąd (np. zapalenie LED "błąd"). Za pomocą pętli PLL będę coraz bardziej zwiększał zegar dla PicoBlaze w FPGA, aż przestanie produkować prawidłowe wyniki. W algorytmie obliczania CRC-7 są zarówno przesunięcia jak i sporo operacji logicznych. Boję się tylko takiej sytuacji, że przy pewnej granicznej wartości częstotliwości zegara dla PicoBlaze, po prostu cały soft-CPU przestanie działać (także nie będzie przedstawiał wyników).

Będę wdzięczny za wszelkie sugestie.

Update: w międzyczasie zamieszczam link z odrobiną teorii dot liczenia CRC i implementacją algorytmu CRC-8 w języku C:

http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html#ch42

Pozdrawiam

[FlyingDutch]

Cześć,

podaję wyniki pierwszych testów z jaką max. częstotliwością na Elbercie V2 działa soft-CPU "PicoBlaze". Otóż korzystając z IP core z "ISE" do generacji pętli PLL (pętla synchronizacji fazowej) przerobiłem projekt Elvisa z miganiem diodą LED za pomocą programu w assemblerze PicoBlaze. Generację pętli PLL za pomocą IP core dokładnie opisał Elvis w swoim poście:

https://www.forbot.pl/forum/topics51/fpga-wlasne-programy-5-obraz-na-monitorze-vga-vt15020.htm

Postępujemy dokładnie tak samo, z tą różnicą, że ustawimy częstotliwość wyjściową pętli PLL na 120 MHz (tak to nie pomyłka - możemy w naszych projektach FPGA na Elbercie używać tak wysokich częstotliwości zegara, czy układ będzie działał poprawnie zależy od jakości projektu).

Potem w projekcie do migania diodą LED za pomocą PicoBlaze - znów z postu Elvisa:

https://www.forbot.pl/forum/topics51/picoblaze-dla-spartan-3-xilinx-8-bit-microcontroller-linki-vt15016.htm

Zmieniamy zegar na wyjście dodanego komponentu pętli PLL w procesorze PicoBlaze i zmieniamy timingi w kodzie VHDL. Tak wygląda zmodyfikowany główny plik tego projektu kcpsm3.vhd:

  library IEEE;
   use IEEE.STD_LOGIC_1164.ALL;
   use IEEE.STD_LOGIC_ARITH.ALL;
   use IEEE.STD_LOGIC_UNSIGNED.ALL;

   entity pr_1 is Port
   ( clk : in  STD_LOGIC;
     rst : in  STD_LOGIC;
     LED_cntrl : out  STD_LOGIC);
   end pr_1;

   architecture Behavioral of pr_1 is

   -- deklaracja KCPSM3
   component kcpsm3 Port
   ( address : out std_logic_vector(9 downto 0);
     instruction : in std_logic_vector(17 downto 0);
     port_id : out std_logic_vector(7 downto 0);
     write_strobe : out std_logic;
     out_port : out std_logic_vector(7 downto 0);
     read_strobe : out std_logic; 
     in_port : in std_logic_vector(7 downto 0);
     interrupt : in std_logic;
     interrupt_ack : out std_logic;
     reset : in std_logic;
     clk : in std_logic);
   end component;

COMPONENT pll
PORT(
	CLKIN_IN : IN std_logic;          
	CLKFX_OUT : OUT std_logic;
	CLKIN_IBUFG_OUT : OUT std_logic;
	CLK0_OUT : OUT std_logic
	);
END COMPONENT;

   -- deklaracja pamieci programu ROM
   component prog_1 Port
   ( address : in std_logic_vector(9 downto 0);
     instruction : out std_logic_vector(17 downto 0);
     clk : in std_logic);
   end component;

   -- Sygnaly uzyte do polaczenia KCPSM3 z pamiecia programu ROM
   signal address : std_logic_vector(9 downto 0);
   signal instruction : std_logic_vector(17 downto 0);
   signal port_id : std_logic_vector(7 downto 0);
   signal out_port : std_logic_vector(7 downto 0);
   signal in_port : std_logic_vector(7 downto 0);
   signal write_strobe    : std_logic;
   signal read_strobe     : std_logic;
   signal interrupt       : std_logic;
   signal interrupt_ack   : std_logic;
   signal main_reset      : std_logic;

   -- Sygnaly dodatkowe
   signal clk_p       : std_logic;
   signal CLK_licznik : integer range 0 to 1_000_000;
 -------------------------------------
 signal clk120MHz    : std_logic;
 signal clkOut       : std_logic;
 signal clkbuf       : std_logic;

   begin

  Petla_pll: pll PORT MAP(
	CLKIN_IN => clk,
	CLKFX_OUT => clk120MHz,
	CLKIN_IBUFG_OUT => clkbuf,
	CLK0_OUT => clkOut
  );

   -- KCPSM3 and the program memory
   processor: kcpsm3
   port map(      address => address,
                  instruction => instruction,
                      port_id => port_id,
                 write_strobe => write_strobe,
                     out_port => out_port,
                  read_strobe => read_strobe,
                      in_port => in_port,
                    interrupt => interrupt,
                interrupt_ack => interrupt_ack,
                        reset => main_reset,
                          clk => clk120MHz); --clk_p
   program_rom: prog_1
   port map(      address => address,
                  instruction => instruction,
                  clk => clk120MHz); --clk_p

     interrupt <= interrupt_ack;
     main_reset <= not rst;

     LED_ustaw: process (clk_p, rst)
     begin
       if (rst = '0') then
         LED_cntrl <= '0';
       elsif clk_p'event and clk_p='1' then
         if ((port_id="00000000") and (write_strobe='1')) then
           LED_cntrl <= out_port(0);
         end if;
       end if;
     end process;

     CLK_ustaw: process (clk120MHz, rst)
     begin
       if (rst = '0') then
         CLK_licznik <= 0;
         clk_p <= '0';
       elsif clk120MHz'event and clk120MHz='1' then
         if (CLK_licznik >= 1_00_000) then
           CLK_licznik <= 0;
           clk_p <= not clk_p;
         else
           CLK_licznik <= CLK_licznik + 1;
         end if;
       end if;
     end process;

   end Behavioral;

Dodaliśmy nowy komponent o nazwie "pll" jest to właśnie pętla PLL wygenerowana w środowisku "ISE". Widzimy też że w procesie CLK_ustaw: process (clk120MHz, rst) zmieniliśmy listę wrażliwości procesu (z sygnału clk na clk120MHz z wyjścia pętli PLL).

Poza tym zmieniliśmy generację sygnału clk_p w tym procesie:

if (CLK_licznik >= 1_00_000) then

Skąd taka duża zmiana - już tłumaczę. Przyjrzyjmy się teraz programowi w assemblerze dla PicoBlaze do mrugania diodą:

   ;**************************************************************************************
   ; Stale uzyte w programie
   ;**************************************************************************************

   CONSTANT led_signal       , 01    ; numer diody LED
   CONSTANT led_port_nr      , 00    ; numer portu, do ktorego przylaczony jest LED
   CONSTANT licznik          , 2F    ; do ilu bedziemy odliczac aby zmienic stan diody LED

   ;**************************************************************************************
   ; Rejestry specjalnego przeznaczenia
   ;**************************************************************************************
   ;
   ; s0                 ; rejestr uzyty do zliczania impulsow
   ; s1                 ; s1 – rejestr z wartoscia portu – 1
   ; s2                 ; s2 – rejestr z wartoscia portu – 0
   ;;============================================================================
   ;; Nieskonczona petla.
   ;;============================================================================

       __start:    LOAD s1, 01                 ; s1 <= 1
                   LOAD s2, 00                 ; s2 <= 0

       start:      LOAD s0, licznik            ; ustaw licznik
                   LOAD sA, sA                 ; instrukcja pusta

       petla1:     SUB s0, 01                  ; odejmij jeden
                   COMPARE s0, 00              ; sprawdz, czy zero
                   JUMP NZ, petla1             ; jesli nie skocz do petla1

                   OUTPUT s1, led_port_nr      ; ustaw sygnal LED_cntrl na ‘1’

                   LOAD s0, licznik            ; ustaw licznik

       petla2:     SUB s0, 01                  ; odejmij jeden
                   COMPARE s0, 00              ; sprawdz, czy zero
                   JUMP NZ, petla2             ; jesli nie skocz do petla2

                   OUTPUT s2, led_port_nr      ; ustaw sygnal LED_cntrl na ‘0’

                   JUMP start                  ; skocz na poczatek programu

Jak widać z tego kodu:

CONSTANT licznik , 2F ; do ilu bedziemy odliczac aby zmienic stan diody LED

licznik p0ętli ma wartość 2F Hex a to 47 dziesiętnie dodajmy kilka dodatkowych instrukcji w kodzie i mamy 50 dziesiętnie - jako że jedna instrukcja w Pico wykonuje się 2 takty zegara to zmiana stanu diody wykonuje się w programie co 100 taktów zegara 9w przybliżeniu).

No tak ale teraz na wejściu nasz PicoBlaze ma 120 MHz czyli 120 000 000 Hz. Podzielmy to przz nasze 100 - wychodzi 1200000. Z taką częstotliwościa by migała dioda !

Zebyśmy mieli 1,2 Hz (czyli zmiana co 0,6 sekundy) dzielimy przez 1000000 - stąd magiczna wartość licznika w kodzie VHDL procesu 😉

Plików z program em ROM i pliku ucf nie zmianiamy.

W załączniku "PicoBlaze03.zip" mam spakowany cały projekt "ISE" (14.7) z PicoBlaze mrugającym diodą LED z zegarem CPU = 120 MHz.

PicoBlaze03.zip

[Elvis]

Gdzieś w sieci widziałem informację, że PicoBlaze może dawać nawet 100 MIPS przy taktowaniu 200MHz. Jak dla mnie 100MHz i 50MIPS to i tak byłby niezły wynik... Szczególnie biorąc pod uwagę użycie 15% zasobów - może i ElbertV2 ma najmniejszego Spartan-a na pokładzie, ale to i tak potężny układ 🙂

[JTyburski]

See: GoldenLine 😃

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[FlyingDutch]

See: GoldenLine 😃

Cześć Jakub,

fajnie, że tu zajrzałeś - dzieje się tu zdecydowanie wiĘcej niż na Goldenline.pl. Możesz tutaj dużo wnieść z twoją wiedzą dot układów programowalnych 😃

Może przedstawię Jakuba : Jakub jest doktorantem i wykładowcą na WAT z "Układów programowalnych"

Pozdrawiam

[ Dodano: 28-12-2017, 16:39 ]

Gdzieś w sieci widziałem informację, że PicoBlaze może dawać nawet 100 MIPS przy taktowaniu 200MHz. Jak dla mnie 100MHz i 50MIPS to i tak byłby niezły wynik... Szczególnie biorąc pod uwagę użycie 15% zasobów - może i ElbertV2 ma najmniejszego Spartan-a na pokładzie, ale to i tak potężny układ 🙂

Elvis - dzięki za zainteresowanie. Myślę, że może się dać osiągnąć zbliżoną wartość na Elbercie, ale trzeba to przeprowadzić test na programie z większą liczbą operacji matematycznych i logicznych 😃

Pozdrawiam

[Elvis]

W dokumentacji Spartana jest informacja o maksymalnej częstotliwości taktowania pamięci blokowej RAM - 280MHz. Ponieważ jest używana do emulacji ROM, wydaje mi się że lepiej nie przekaczać tej wartości. Chociaż pewnie i na 300 MHz będzie działało...

[JTyburski]

Dokumentacja dokumentacją - w praktyce to uda ci się wpuścić i 800 MHz sygnał zegarowy (co dowiedli u mnie na zakładzie w uczelni swego czasu jak testowali Xilinxy - sygnał co prawda zniekształcony, wręcz karłowaty, ale o dziwo zaimplementowane układy działały! A jakie było zdziwienie, że takie przerzutniki jeszcze się nie wykrzaczają!) 😃

[FlyingDutch]

W dokumentacji Spartana jest informacja o maksymalnej częstotliwości taktowania pamięci blokowej RAM - 280MHz. Ponieważ jest używana do emulacji ROM, wydaje mi się że lepiej nie przekaczać tej wartości. Chociaż pewnie i na 300 MHz będzie działało...

Tak, ale z drugiej strony w sieci dużo ludzi pisze, że max. zegar dla projektów dla Spartana 3A kończy się w pobliżu 200 MHZ. Nie wiem ,czy to prawda, ale będziemy mieli okazję się przekonać 😉

BTW: instaluję "ISE Webpack" pod Linuksem (używam Mint'a 18.1 Mate i Gentoo), ale ze względu, że do pracy potrzebuję "Visual Studio" (C#) to ostatni więcej siedziałem pod Windowsem.

Dla Linux'a jest więcej narzędzi do "PicoBlaze" (assemblery i symulatory) i ogolnie lepiej się pod tym OS pracuje.

Pozdrawiam

[Elvis]

Nie jestem ekspertem od FPGA, ale w dokumentacji są różne maksymalne częstotliwości taktowania dla różnych modułów. Więc 800MHz jak najbardziej, ale nie dla blockRAM-u, a PicoBlaze go używa. Natomiast, że układ działał to akurat niczego nie dowodzi - ja kiedyś zasilałem MSP430 z 5V i chodził, ale co z tego 🙂

[JTyburski]

A to z tego, że jeśli celem jest ustaleniem maksymalnej częstotliwości to warto zacząć od samego sygnału - o dziwo zadziałało takie 800 MHz nawet dla pamięci! 😃 Stąd dokumentacja to jest taka tylko orientacyjna, a nie faktyczna 😃 Zaufaj trochę nam "naukowcom", którzy trochę już w tym siedzieli 😃

[Elvis]

Wolę zaufać producentowi, wybacz, ale naukowcy to nie zawsze się znają na tym co robią, więc dowód przez autorytet nie przejdzie 😉 Ale mniejsza o większość - 200 MHz to chyba rozsądna wartość dla takiej podstawowej płytki jak ElbertV2.

[JTyburski]

A szkoda 😃 Bo jednak nam wyszły i tak spore nieścisłości w przypadku takiego Xilinxa i nie ufamy bezkrytycznie dokumentacjom (no ale co kto woli) ^^

[FlyingDutch]

A to z tego, że jeśli celem jest ustaleniem maksymalnej częstotliwości to warto zacząć od samego sygnału - o dziwo zadziałało takie 800 MHz nawet dla pamięci! 😃 Stąd dokumentacja to jest taka tylko orientacyjna, a nie faktyczna 😃 Zaufaj trochę nam "naukowcom", którzy trochę już w tym siedzieli 😃

Tak, ale jeszcze trzeba praktycznie przetestować,czy nie ma przekłamań w wykonywaniu operacji arytmetyczno-logicznych przez CPU. Jak podkręcałem CPU to jeden z pierwszych objawów za dużej częstotliwości taktowania to przekłamania w wykonywaniu obliczeń.

Pozdrawiam

[Elvis]

Ja nie podkręcam CPU, stąd może moja ostrożność. Ale nie neguję uzyskanych wyników - na pewno Spartan ma potencjał do overclockingu. W sumie to dobrze 🙂

Chociaż jak dla mnie to nawet skromne 100MHz brzmi jak odrzutowiec w przypadku ElbertV2.... Traktowałem go jako prostą i tanią płytkę do nauki podstaw, a nie platformę do wymagających projektów.

[JTyburski]

I co z tego, że przekłamania - takiś prędki, że chcesz od razu wszystko, pomijając resztę (cos za co niektórych na mej uczelni od razu uwalili na starcie) - spokojnie - najpierw zegar, potem reszta 😃 Poza tym masz takie możliwości rozkładania elementów na takim Spartanie, że możesz właśnie temu zapobiec po iluś tam próbach, żeby dało się zlikwidować te przekłamania 😃 I już 😃