Sterowanie CPUCPU Control

Moduł FPGA jest widziany w przestrzeni adresowej CPU jak zwykła pamięć RAM — CPU używa standardowych instrukcji zapisu i odczytu pamięci, bez potrzeby stosowania dedykowanego interfejsu I/O.

Moduł FPGA jest sterowany przez zewnętrzny CPU (np. mikrokontroler ATmega) poprzez magistralę równoległą. Komunikacja odbywa się przez wydawanie komend z odpowiednimi parametrami — CPU zapisuje numer komendy oraz jej parametry do odpowiednich rejestrów, a FPGA wykonuje operację i udostępnia wynik.

CPU może na dwa sposoby dowiedzieć się o zakończeniu operacji:

• Odpytywanie statusu (polling) — CPU cyklicznie odczytuje rejestr statusu i sprawdza, czy operacja się zakończyła.
• Przerwania — FPGA zgłasza zdarzenie linią INT, a CPU obsługuje je w swojej procedurze przerwania.

Oba tryby mogą być używane jednocześnie — CPU może wybrać, które zdarzenia mają generować przerwanie, a pozostałe sprawdzać przez odpytywanie.

Magistrala łącząca CPU z FPGA jest równoległa i składa się z:

• 8 bitów danych — szyna dwukierunkowa, używana zarówno do zapisu, jak i odczytu.
• 5 bitów adresu — co daje 32 adresy (0x00…0x1F), z których wszystkie są wykorzystane. Nie wszystkie adresy są jednak przeznaczone do zapisu — część rejestrów jest tylko do odczytu.

Magistrala jest buforowana i dostosowana do poziomów TTL 5 V, dzięki czemu współpracuje bezpośrednio z typowymi mikrokontrolerami 5 V (np. ATmega) bez konieczności stosowania dodatkowych konwerterów poziomów.

Oprócz szyny danych i adresu magistrala zawiera również linie sterujące:

• CE_n — wybór układu (chip enable).
• OE_n — zezwolenie na wyjście (output enable) — aktywne przy odczycie.
• WE_n — zezwolenie na zapis (write enable) — aktywne przy zapisie.

Dodatkowo wyprowadzone są dwie linie specjalne:

• INT — linia przerwania, zgłasza zdarzenia do CPU.
• LOAD — linia informująca o zakończeniu ładowania bitstreamu do FPGA przy uruchomieniu.

Obie linie — INT i LOAD — są typu open collector. Oznacza to, że wymagają zewnętrznych rezystorów podciągających. Płytka ma wbudowane rezystory podciągające, które można jednak odłączyć od zasilania przez odpowiednią konfigurację jumperów — co jest przydatne, gdy linie są podciągane po stronie CPU.

FPGA jest widziana w przestrzeni adresowej CPU jak zwykła pamięć RAM. Dostępnych jest 32 adresy (5 bitów adresu), z których każdy odpowiada jednemu rejestrowi. Nie wszystkie rejestry są przeznaczone do zapisu — część jest tylko do odczytu, a część dwukierunkowa.

Poniższa tabela przedstawia pełny podział przestrzeni adresowej:

Poniżej opisano znaczenie poszczególnych rejestrów w przestrzeni adresowej FPGA.

Rejestry komend i parametrów (ram[0]…ram[9])

Rejestry sprzętowe (ram[10]…ram[15])

Rejestry przerwań (ram[16]…ram[18])

Rejestry timera (ram[19]…ram[22])

Uwaga o timerze: pełna obsługa timera jest zaimplementowana tylko częściowo — działa wyłącznie tryb przepełnienia (overflow). Tryb porównania (compare match) NIE JEST zaimplementowany: flaga IRQ_TIMER8_CMP i bit TIMCFG_COMPARE istnieją w definicjach, ale nie są nigdzie używane w kodzie Verilog.

Rejestry zarezerwowane (ram[23]…ram[28])

Adresy ram[23]…ram[28] są zarezerwowane na przyszłe zastosowania. W domyślnej kompilacji są to rejestry ALU (REG_ALU_*) — opcjonalne i zależne od definicji USE_ALU16 w pliku config.vh. W obecnej wersji ALU jest wyłączone — odczyt z tych adresów zwraca 0x00, a bit 7 w REG_INT_FLAGS i REG_INT_ENABLE (IRQ_ALU) jest nieużywany.

Generatory pseudolosowe (ram[29]…ram[31])

Poza rejestrami interfejsu komend FPGA posiada szereg rejestrów wewnętrznych, które konfigurują pracę poszczególnych podsystemów i działają w tle — bez potrzeby wydawania komend.

Niektóre z tych mechanizmów działają autonomicznie od momentu resetu FPGA (np. licznik czasu UNIX, generatory pseudolosowe), inne wymagają wcześniejszej konfiguracji przez odpowiedni rejestr (np. UART wymaga włączenia RX w REG_CFG).

Kliknij wiersz, aby zobaczyć szczegóły rejestru.

Kliknij wybrany wiersz, aby zobaczyć szczegóły rejestru.

Komendy wydaje się przez zapis parametrów do rejestrów ram[1]…ram[9], a następnie zapis numeru komendy do rejestru ram[0]. Zapis do ram[0] rozpoczyna wykonanie komendy.

Kliknij wiersz, aby zobaczyć szczegóły komendy.

Kliknij wybrany wiersz, aby zobaczyć szczegóły komendy.

Rejestr statusu ram[15] (REG_STATUS_VGA) to rejestr tylko do odczytu, w którym FPGA na bieżąco aktualizuje stan poszczególnych podsystemów. CPU może go odpytywać (polling) w celu sprawdzenia, czy dana operacja się zakończyła, czy dane są gotowe, albo czy wystąpił błąd.

Bity rejestru statusu

Jak używać

CPU może odpytywać rejestr statusu w pętli, aż wybrany bit zmieni stan. Przykład — oczekiwanie na zakończenie operacji graficznej:

while (fpga_read(15) & 0x01) {
    /* czekaj, aż STATUS_VGA = 0 */
}

FPGA ma osobną linię przerwania INT, która jest typu open collector i jest wyzwalana poziomem niskim (active-low). Zgłasza ona CPU wystąpienie zdarzenia — zamiast odpytywania statusu, CPU może zostać powiadomiony natychmiast. Przerwania są konfigurowalne: każde źródło można indywidualnie włączyć lub zamaskować.

Ważne: linia INT pozostaje aktywna (w stanie niskim) do momentu skasowania wszystkich źródeł przerwania. Jeśli kilka źródeł zgłosi przerwanie jednocześnie, CPU musi skasować wszystkie aktywne flagi — dopiero wtedy INT zostanie zwolniona (przejdzie w stan wysoki).

Rejestry przerwań

Źródła przerwań (bity ram[16] i ram[18])

Uwaga o timerze: pełna obsługa timera jest zaimplementowana tylko częściowo — działa wyłącznie tryb przepełnienia (overflow). Flaga IRQ_TIMER8_CMP i bit TIMCFG_COMPARE istnieją w definicjach, ale nie są nigdzie używane w kodzie Verilog.

Jak to działa

Linia INT jest aktywna (stan niski), gdy którakolwiek flaga w ram[16] jest ustawiona i odpowiadający jej bit w ram[18] jest włączony:

assign INT = |(irq_flags & enable_irq);

Linia INT pozostaje w stanie niskim tak długo, jak długo w ram[16] jest ustawiona jakakolwiek flaga (przy włączonym odpowiadającym jej zezwoleniu w ram[18]). Dopiero skasowanie wszystkich aktywnych flag zwalnia linię INT — przechodzi ona w stan wysoki.

Dzięki temu, że linia jest wyzwalana poziomem niskim, CPU może obsłużyć przerwanie w dowolnym momencie — nie musi reagować natychmiast, bo sygnał nie zniknie, dopóki flaga nie zostanie skasowana.

Obsługa przerwania — krok po kroku

1. Włącz przerwania — zapisz maskę do ram[18] (1 = włączone).
2. Czekaj na INT — FPGA ustawi linię INT w stan niski, gdy wystąpi zdarzenie.
3. Odczytaj flagi — odczytaj ram[16], żeby sprawdzić, które źródła zadziałały.
4. Obsłuż zdarzenia — wykonaj odpowiednie akcje dla wszystkich aktywnych flag.
5. Wyczyść wszystkie flagi — zapisz 1 na wszystkich aktywnych bitach w ram[17] — to skasuje flagi w ram[16] i zwolni linię INT (przejdzie w stan wysoki).

Uwaga: jeśli CPU skasuje tylko część flag, linia INT pozostanie w stanie niskim — bo w ram[16] wciąż są ustawione pozostałe flagi. Dopiero skasowanie wszystkich aktywnych flag zwalnia INT.

Przykład — włączenie przerwania od PS/2 i UART RX

/* Włącz przerwania od PS/2 (bit 2) i UART RX (bit 3) */
fpga_write(18, 0x0C);

/* W procedurze przerwania */
void INT_ISR(void) {
    uint8_t flags = fpga_read(16);
    uint8_t to_clear = 0;

    if (flags & 0x04) {
        /* Obsłuż klawisz PS/2 */
        uint8_t key = fpga_read(13);
        /* ... */
        to_clear |= 0x04;
    }

    if (flags & 0x08) {
        /* Obsłuż dane UART */
        uint8_t data = fpga_read(12);
        /* ... */
        to_clear |= 0x08;
    }

    /* Skasuj wszystkie obsłużone flagi naraz */
    fpga_write(17, to_clear);
}

Przerwanie od zakończenia długiej komendy

Flaga IRQ_CMD_DONE (bit 5) jest ustawiana po zakończeniu długich operacji: CMD_DRAW_RECT, CMD_DRAW_FRAME, CMD_CLEAR_FRAMEBUFFER, CMD_CLEAR_TEXT. Dzięki temu CPU nie musi odpytywać statusu — dostaje przerwanie, gdy operacja się zakończy.

Kasowanie flag

Aby skasować flagę, zapisz 1 na odpowiednim bicie w ram[17]:

fpga_write(17, 0x04);  /* skasuj flagę IRQ_PS2 */

Zapis 0 nie zmienia stanu flagi.

Aby zwolnić linię INT, trzeba skasować wszystkie aktywne flagi. Można to zrobić jednym zapisem — sumując bity wszystkich flag, które chcemy skasować:

fpga_write(17, 0x04 | 0x08);  /* skasuj IRQ_PS2 i IRQ_UART_RX naraz */

Linia LOAD informuje CPU o zakończeniu ładowania bitstreamu do FPGA. Jest typu open collector i jest wyzwalana poziomem niskim (active-low). Dzięki niej CPU może poczekać, aż FPGA będzie gotowe do pracy, zanim rozpocznie komunikację.

Jak to działa

Po włączeniu zasilania FPGA ładuje bitstream z pamięci konfiguracji (SPI Flash). W tym czasie linia LOAD pozostaje w stanie wysokim — CPU czeka. Gdy ładowanie się zakończy, FPGA wypuszcza linię LOAD w stan niski — CPU przechodzi do dalszej części kodu.

Stany linii LOAD

Przykład kodu — oczekiwanie na LOAD

/* Oczekiwanie na zakończenie ładowania bitstreamu */
while ((PING & (1 << PG5)) != 0) {
    /* LOAD = 1 — czekaj */
    _delay_ms(10);
}

/* LOAD = 0 — FPGA gotowe, można kontynuować */

Pull-upy

Linia LOAD — podobnie jak INT — jest typu open collector. Wymaga rezystora podciągającego. Płytka ma wbudowane rezystory podciągające, które można odłączyć przez odpowiednią konfigurację jumperów.

Linie INT i LOAD są typu open collector. Oznacza to, że nie mogą same wyprowadzić stanu wysokiego — wymagają zewnętrznego rezystora podciągającego, który ustali stan wysoki, gdy żadne urządzenie nie ściąga linii do masy.

Wbudowane pull-upy

Płytka FPGA ma wbudowane rezystory podciągające o wartości 4.7 kΩ, podłączone do zasilania 5 V. Napięcie to jest pobierane z układu CPU, z którym FPGA współpracuje (np. z płytki ATmegi) — dzięki temu poziomy napięć na liniach INT i LOAD są zgodne z poziomami CPU.

Konfiguracja

Każda linia ma swój własny jumper SMD:

Fabrycznie zworki są zwarte, czyli pull-upy są podłączone. Aby odłączyć pull-up danej linii, należy rozciąć odpowiednią zworkę SMD (np. przecinając ścieżkę ostrym narzędziem).

Kiedy odłączyć pull-upy

Odłączenie pull-upów jest przydatne, gdy:

• CPU ma własne rezystory podciągające,
• linie są podciągane po stronie CPU,
• CPU pracuje na innym napięciu niż 5 V,
• występuje konflikt napięć między CPU a FPGA.

Uwaga

Odłączenie pull-upów jest trwałe — zworki SMD są jednorazowe. Jeśli chcesz je później przywrócić, trzeba będzie wlutować rezystor 0Ω albo połączyć pady kroplą cyny.

Na płytce znajduje się więcej zworek SMD — zostaną one opisane w przyszłości.

Kompletny kod demo dla mikrokontrolera ATmega2560 jest dostępny do pobrania. Kod jest napisany w czystym C/AVR (nie jest to sketch Arduino) i kompilowany w środowisku Microchip Studio (dawniej Atmel Studio) z użyciem kompilatora avr-gcc.

Wersja kodu demo: 1.0

Programowanie ATmega2560

ATmega2560 jest programowany przez interfejs JTAG — na płytce FPGA wyprowadzone jest dedykowane złącze JTAG dla ATmela. Programowanie odbywa się przez zewnętrzny programator (np. Atmel-ICE, AVR JTAGICE mkII, JTAGICE3), a nie przez bootloader Arduino ani USB.

Środowisko i kompilacja

Połączenie ATmega2560 ↔ FPGA

Uwaga: piny FPGA są ściśle przyporządkowane do konkretnych pinów ATmega2560 — nie ma możliwości dowolnego wyboru pinów. Wynika to z implementacji magistrali w bibliotece FPGA.cpp, która używa bezpośrednio rejestrów portów ATmega. Poniższe tabele przedstawiają pełne mapowanie.

Magistrala adresowa (A0–A4)

Magistrala danych (D0–D7)

Linie sterujące magistrali

Linie specjalne

UART

PS/2

Uwagi do połączenia

• Ścisłe przypisanie pinów: mapowanie pinów wynika bezpośrednio z implementacji magistrali w FPGA.cpp (operacje na rejestrach PORTD, PORTH, PORTJ, PORTK, PORTE, PORTG). Zmiana pinów wymagałaby modyfikacji kodu biblioteki.
• Poziomy napięć: magistrala pracuje w standardzie TTL 5 V — ATmega2560 (5 V) współpracuje bezpośrednio, bez konwerterów poziomów.
• Linie INT i LOAD: są typu open collector — wymagają rezystorów podciągających. Płytka FPGA ma wbudowane pull-upy 4.7 kΩ (zworki SJ3 i SJ5), które można odłączyć, jeśli pull-upy są po stronie ATmega.
• Bufory magistrali: linie CE_n, WE_n, OE_n sterują buforem magistrali — kolejność ich przełączeń ma znaczenie dla poprawnej komunikacji.
• Timer5: wykorzystywany do migania Pac-Mana (~4,19 s).

Zawartość paczki

Kod źródłowy jest podzielony na pliki:

• main.cpp — menu główne i obsługa demo
• game.cpp — logika gry Pac-Man
• FPGA.cpp, FPGA.h — biblioteka komunikacji z FPGA
• color.h, Cursor.h, SDcard.h — definicje pomocnicze
• def_screen.h — stałe geometryczne ekranu

Pobierz kod demo v1.0 (ZIP)

Pełny kod projektu jest dostępny w repozytorium GitHub:

Zobacz na GitHubie