Zastąpienie układu CIA 8520 przez układ ATF1508 przy użyciu języka opisu sprzętu (HDL) to zaawansowany projekt, który wymaga stworzenia odpowiedniej logiki do emulacji funkcji CIA 8520. Poniżej przedstawiam przykładowy szkic implementacji w języku VHDL dla układu ATF1508, który realizuje niektóre podstawowe funkcje CIA 8520, takie jak porty I/O, proste timery i przerwania.

Krok 1: Ogólna koncepcja
CIA 8520 posiada kilka głównych funkcji, które musimy emulować:

Porty I/O – obsługa dwóch 8-bitowych portów (A i B).
Timery – dwa 16-bitowe timery.
Przerwania – mechanizm przerwań dla timerów i portów.
Rejestry konfiguracyjne – rejestry do konfiguracji portów I/O oraz ustawień timerów.
W poniższym przykładzie skupię się na implementacji dwóch podstawowych portów I/O i timerów, jako wstępny krok w stronę pełnej emulacji CIA 8520.

Krok 2: Projekt w VHDL
1. Zdefiniowanie portów I/O
Zaczniemy od zaimplementowania portów I/O (Port A i Port B), które będą działały jako wejścia/wyjścia, podobnie jak w układzie CIA 8520.

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

entity CIA_Emulator is
Port ( clk : in STD_LOGIC;
rst : in STD_LOGIC;
dir_a : in STD_LOGIC; -- 1 = Port A is output, 0 = Port A is input
dir_b : in STD_LOGIC; -- 1 = Port B is output, 0 = Port B is input
data_in_a : in STD_LOGIC_VECTOR(7 downto 0); -- Data to write to Port A (if output)
data_in_b : in STD_LOGIC_VECTOR(7 downto 0); -- Data to write to Port B (if output)
data_out_a : out STD_LOGIC_VECTOR(7 downto 0); -- Data from Port A (if input)
data_out_b : out STD_LOGIC_VECTOR(7 downto 0); -- Data from Port B (if input)
irq_a : out STD_LOGIC; -- Interrupt for Port A
irq_b : out STD_LOGIC -- Interrupt for Port B
);
end CIA_Emulator;
W tym projekcie, dir_a i dir_b służą do konfiguracji portów jako wejścia lub wyjścia. data_in_a i data_in_b to dane, które mają zostać zapisane na porty, a data_out_a i data_out_b to dane odczytane z portów. Przerwania są generowane, gdy stan portów zmienia się.

2. Implementacja portów I/O
W tym kroku zaimplementujemy logikę do obsługi portów I/O. Gdy port jest ustawiony jako wyjście, zapisujemy dane na wyjście, a gdy port jest ustawiony jako wejście, odczytujemy dane.

vhdl
Kopiuj
architecture Behavioral of CIA_Emulator is
begin

process(clk, rst)
begin
if rst = '1' then
data_out_a <= (others => '0');
data_out_b <= (others => '0');
irq_a <= '0';
irq_b <= '0';
elsif rising_edge(clk) then
-- Obsługa Portu A
if dir_a = '1' then
data_out_a <= data_in_a; -- Zapis danych do Portu A
else
data_out_a <= data_out_a; -- Odczyt danych z Portu A (brak zmiany)
end if;

-- Obsługa Portu B
if dir_b = '1' then
data_out_b <= data_in_b; -- Zapis danych do Portu B
else
data_out_b <= data_out_b; -- Odczyt danych z Portu B (brak zmiany)
end if;
end if;
end process;

end Behavioral;
W tym kodzie process monitoruje sygnał clk i wykonuje odpowiednie operacje na portach, w zależności od ustawienia dir_a i dir_b. Gdy port jest ustawiony na wyjście (wartość '1'), dane z data_in_a lub data_in_b zostają zapisane na odpowiednie porty. Gdy port jest ustawiony na wejście (wartość '0'), odczytujemy dane z portu i nie zmieniamy wartości.

3. Implementacja Timerów
CIA 8520 zawiera dwa 16-bitowe timery. Zaimplementujemy jeden prosty timer, który będzie zliczał impulsy zegarowe i generował przerwanie, gdy osiągnie określoną wartość.

vhdl
Kopiuj
architecture Behavioral of CIA_Emulator is
signal timer : STD_LOGIC_VECTOR(15 downto 0) := (others => '0');
signal timer_irq : STD_LOGIC := '0'; -- Timer interrupt flag
begin

process(clk, rst)
begin
if rst = '1' then
timer <= (others => '0');
timer_irq <= '0';
elsif rising_edge(clk) then
-- Timer zlicza impulsy
if timer = X"FFFF" then
timer_irq <= '1'; -- Generowanie przerwania
else
timer <= timer + 1;
end if;
end if;
end process;

irq_a <= timer_irq; -- Powiązanie przerwania timera z przerwaniami portu A
end Behavioral;
W tym przypadku timer jest 16-bitowym licznikiem, który zlicza impulsy zegarowe (clk). Gdy licznik osiągnie wartość 0xFFFF, generowane jest przerwanie (timer_irq), które może być przekazywane jako przerwanie na port A. Możesz dodać drugi timer, który będzie działał podobnie, lub skonfigurować więcej timerów, jeśli będzie to wymagane.

4. Całość projektu
Łącząc powyższe bloki, masz już podstawową wersję emulatora CIA 8520 w układzie ATF1508. Oczywiście jest to tylko początek — pełna funkcjonalność wymaga implementacji dodatkowych rejestrów, logiki przerwań, rozbudowy timerów, oraz obsługi bardziej zaawansowanej komunikacji, jak np. RS-232 lub bardziej złożone interfejsy.

Krok 3: Symulacja i testowanie
Po napisaniu kodu w VHDL, następnym krokiem będzie:

Symulacja: Przetestowanie projektu w symulatorze VHDL (np. ModelSim lub Xilinx Vivado) w celu upewnienia się, że logika działa poprawnie. Sprawdź, czy porty działają poprawnie jako wejścia/wyjścia, czy timer zlicza czas, a przerwania są generowane.

Syntezowanie: Po pomyślnych testach symulacyjnych możesz przejść do syntezowania projektu, aby stworzyć bitstream, który zostanie zaprogramowany w układzie ATF1508.

Programowanie ATF1508: Za pomocą odpowiedniego programatora załaduj stworzony projekt na układ ATF1508.

Podsumowanie:
Zastąpienie układu CIA 8520 w komputerze Amiga układem ATF1508 przy pomocy języka VHDL wymaga zaawansowanej logiki sprzętowej. Zaprezentowany przykład to jedynie początek — implementacja pełnej funkcjonalności, jaką oferuje CIA 8520, jest bardziej złożona i wymaga uwzględnienia wszystkich jego funkcji.

dysponuje ktoś szczegółowymi danymi na temat CIA 8520 i ALICE do A1200 ?

dla ALICE


Zastąpienie układu Alice 8374 w Amiga 1200 przez układ FPGA Altera Cyclone IV EP4CE6 to bardziej zaawansowane podejście, które umożliwia emulację całego funkcjonalnego układu graficznego. Cyclone IV to układ FPGA, który oferuje wystarczającą moc obliczeniową i elastyczność do implementacji funkcji podobnych do Alice 8374, zwłaszcza że FPGA ma dużą ilość logicznych zasobów oraz możliwość programowania w językach opisu sprzętu (VHDL/Verilog).

Układ Alice 8374 odpowiedzialny był za generowanie obrazu i zarządzanie pamięcią wideo w systemie AGA (Advanced Graphics Architecture), więc zadaniem FPGA będzie odwzorowanie tych funkcji, w tym:

Zarządzanie pamięcią wideo (VRAM).
Generowanie grafiki 2D.
Synchronizacja sygnałów wideo.
Obsługa wyjść wideo w standardzie Amiga.
Kluczowe kroki projektu
Replikacja logiki pamięci VRAM: Układ Alice zarządzał pamięcią VRAM, która była używana do przechowywania obrazów wyświetlanych na ekranie. Musimy zaimplementować odpowiednią logikę do zarządzania pamięcią w FPGA.

Generowanie sygnałów wideo: Alice odpowiadał za generowanie sygnałów H-sync i V-sync oraz obsługę różnych trybów wideo, takich jak wyświetlanie grafiki w wysokiej rozdzielczości, trybów HAM, itp. W FPGA musimy wygenerować odpowiednie timingi wideo.

Przerwania i współpraca z procesorem: Alice współpracował z procesorem Amiga 1200, generując przerwania, które synchronizowały wyświetlanie obrazu. Ta funkcjonalność musi zostać zaimplementowana w FPGA.

Emulacja trybów grafiki AGA: Alice zarządzał wyświetlaniem grafiki w trybach takich jak HAM (Hold-And-Modify), EHB (Extra Half-Brite) i inne. Te tryby trzeba będzie odpowiednio emulować w FPGA.

Wybór narzędzi
Verilog/VHDL: Będziesz musiał używać języka opisu sprzętu, takiego jak Verilog lub VHDL, do implementacji logiki w FPGA. Wybór zależy od Twoich preferencji i doświadczenia w programowaniu FPGA.

Quartus Prime: Aby zaprogramować układ Cyclone IV EP4CE6, użyj Altera Quartus Prime, który jest narzędziem do syntezowania, kompilowania i programowania projektów FPGA.

Symulacja i testowanie: Przed implementacją na fizycznym układzie FPGA ważne jest przetestowanie kodu na poziomie symulacji. Można to zrobić w narzędziach takich jak ModelSim lub bezpośrednio w Quartus Prime.

Przykładowa implementacja w Verilog
Poniżej przedstawiam uproszczony fragment kodu w Verilog, który może być częścią systemu zastępującego Alice 8374 w FPGA. Będzie to podstawowa logika do zarządzania pamięcią wideo (VRAM) oraz generowania podstawowych sygnałów synchronizacji wideo.

1. Zarządzanie VRAM
verilog
Kopiuj
module vram_controller (
input clk, // Zegar FPGA
input reset, // Sygnał resetu
input [15:0] address, // Adres VRAM
input [7:0] data_in, // Dane do zapisania do VRAM
output reg [7:0] data_out, // Dane wyjściowe z VRAM
input write_enable // Włączenie zapisu do VRAM
);

// Pamięć VRAM 64KB (pojedyncze bajty)
reg [7:0] vram [0:65535];

// Logika odczytu i zapisu do VRAM
always @(posedge clk or posedge reset) begin
if (reset) begin
data_out <= 8'b0;
end else if (write_enable) begin
vram[address] <= data_in; // Zapis do VRAM
end else begin
data_out <= vram[address]; // Odczyt z VRAM
end
end

endmodule
2. Generowanie sygnałów wideo (H-sync, V-sync)
W tym fragmencie kodu implementujemy proste generowanie sygnałów synchronizacji H-sync i V-sync, które są kluczowe do wyświetlania obrazu.

verilog
Kopiuj
module video_sync (
input clk, // Zegar FPGA
input reset, // Sygnał resetu
output reg hsync, // Sygnał synchronizacji poziomej
output reg vsync, // Sygnał synchronizacji pionowej
output reg [7:0] pixel_data_out, // Dane pikseli
input [15:0] address, // Adres w pamięci VRAM
input [7:0] pixel_data_in, // Dane do zapisu do VRAM
input write_enable // Włączenie zapisu do VRAM
);

reg [9:0] h_counter = 0; // Licznik poziomy
reg [9:0] v_counter = 0; // Licznik pionowy

// Generowanie sygnałów synchronizacji H-sync i V-sync
always @(posedge clk or posedge reset) begin
if (reset) begin
h_counter <= 0;
v_counter <= 0;
hsync <= 1'b1;
vsync <= 1'b1;
pixel_data_out <= 8'b0;
end else begin
// Generowanie poziomej synchronizacji (H-sync)
if (h_counter == 799) begin
h_counter <= 0;
if (v_counter == 524) begin
v_counter <= 0;
end else begin
v_counter <= v_counter + 1;
end
end else begin
h_counter <= h_counter + 1;
end

// Generowanie pionowej synchronizacji (V-sync)
if (h_counter < 640) begin // 640 pikseli na linii
hsync <= 1'b0; // H-sync w aktywnej części
end else begin
hsync <= 1'b1; // H-sync w nieaktywnej części
end

if (v_counter < 480) begin // 480 linii
vsync <= 1'b0; // V-sync w aktywnej części
end else begin
vsync <= 1'b1; // V-sync w nieaktywnej części
end

// Zapis do pamięci VRAM
if (write_enable) begin
vram[address] <= pixel_data_in; // Zapis danych
end

// Odczyt z VRAM
pixel_data_out <= vram[address]; // Odczyt danych z VRAM
end
end

endmodule
3. Integracja z resztą systemu
Oprócz samego zarządzania VRAM i generowania sygnałów wideo, będziesz musiał zaimplementować całą resztę logiki, aby system działał poprawnie. Obejmuje to:

Interakcję z procesorem 68EC020, który wysyła dane do VRAM.
Zarządzanie trybami grafiki AGA, w tym HAM (Hold And Modify) oraz inne tryby graficzne.
Obsługę przerwań, które synchronizują generowanie obrazu z procesorem.
4. Testowanie
Po napisaniu kodu, kolejnym krokiem jest testowanie projektu. W pierwszej kolejności powinieneś skorzystać z symulacji w Quartus Prime lub ModelSim, aby upewnić się, że Twój kod działa poprawnie. Wykorzystaj testbench do emulacji sygnałów wejściowych i sprawdzenia wyników.

5. Implementacja na FPGA
Po przetestowaniu kodu i uzyskaniu pozytywnych wyników, możesz przejść do implementacji na fizycznym układzie Altera Cyclone IV EP4CE6. Użyj Quartus Prime, aby skompilować projekt i załadować go na FPGA.

Podsumowanie
Zastąpienie układu Alice 8374 przez Altera Cyclone IV EP4CE6 to ambitne zadanie, które wymaga zaawansowanego projektowania w językach opisu sprzętu (VHDL/Verilog). Twoim zadaniem będzie odwzorowanie funkcji Alice, takich jak zarządzanie pamięcią VRAM, generowanie grafiki, synchronizacja wideo, obsługa przerwań oraz implementacja trybów graficznych AGA. FPGA oferuje dużą elastyczność, ale wymaga również dużej uwagi do detali, aby emulować wszystkie funkcje oryginalnego układu.