Bernd hat geschrieben:Betreff der Hardware, als Referenz habe ich einige Links hinzugefügt.
Easy Flash 3

Interessantes Ding, kannte ich noch garnicht. C64 ist aber auch nicht so ganz mein Gebiet :)

Die Hardware wurde für den C64 als offenes Projekt entwickelt, die Software inklusive der PLD Programmierung veröffentlicht. Das Modul benutzt die von Hias oben beschriebene 8k Flashtechnik, die Bauteile sind die gleichen.

Eine nette Portierung.

Huh?!? Willst Du uns mit dieser seltsamen Formulierung etwa unterstellen wir hätten abgekupfert?

Wenn dem so ist, weise ich das auf das entschiedenste zurück und fordere eine öffentliche Entschuldigung von Dir. Ich hab wirklich keine Lust auf so einen Kindergarten.

so long,

Hias

Schade dass man sich nicht einfach an neuer Hardware erfreuen kann
sondern die Kindergartenspielchen losgehen.

((

Ich find´s lustig. Ich hatte das nämlich so verstanden, dass das easyflash eine nette Portierung von The!Cart ist.
Allerdings sehe ich wohl, dass jetzt wieder Sackhaare gespalten werden, egal, wer was schreibt. Schade.

Hier noch ein paar Infos zur Entstehung von The!Cart:

Das ganze war eigentlich nur ein kleines Nebenprojekt im Sommer/Herbst 2011 nachdem wir mit dem Freezer fertig waren und auf die finalen Platinen warteten. Wolfram ist über den S29GL512 Flash gestolpert und hatte die Idee ihn statt 2x 29F040 in der MegaMax Cart zu verwenden (in erster Linie aus Platzgründen).

Den Xilinx XC95144XL CPLD hatten wir ja gerade für den Freezer verwendet, also lag die Idee nahe für die neue MegaMax Cart einfach einen XC95144XL, den S29GL512 und ein 512k SRAM auf eine Cart-Platine zu klatschen. Dazu dann noch ein SPI EEPROM und der übliche '123er.

Anfang Oktober 2011 hatte Wolfram die Platinen da und einen ersten Prototypen bestückt. Mitte Oktober hielt ich den ersten Prototypen in Händen und wir konnten den ersten erfolgreichen Test durchführen :)

Die Logik und Software hab' ich in etwa einem Monat, rund um die JHV 2011, geschrieben - inkl. 8k Sektor SIO Modus im Flasher und Anpassung von AtariSIO und AspeQt. Zur JHV 2011 hatte Wolfram einen Prototypen mit, ihn aber nur (ganz geheim :) Peter Dell gezeigt :)

Dann lag das Projekt knapp eineinhalb Jahre auf Eis, in der Zeit dachten wir aber einiges darüber nach wie man die ziemlich große Datenmenge mit unserem kleinen Atari halbwegs managen kann.

Im Frühling dieses Jahres ging's dann mit Peter Dells Hilfe weiter (er hatte schon 2011 erste Tests damit gemacht), er kümmerte sich um das The!Cart Studio, ich um die inkrementelle Update Funktion und die Atari Flasher Software.

Was aktuell noch fehlt ist ein "schönes" Auswahlmenü am Atari, darum kümmert sich Peter noch :)

BTW: Die Entwicklung der Software (sowohl für den PC als auch für den Atari) war der mit Abstand schwierigste und aufwändigste Teil an dem Projekt - so wie bei vielen anderen Hardware Projekten ja auch. Die Hardware ist ziemlich straight-forward und die PLD Logik recht simpel (die Infos wie die unterschiedlichen Cart-Modi funktionieren sind ja schön in der Atari800 Doku und Source aufbereitet).

Hier ein Ausschnitt aus der PLD Logik, mit der Konfiguration und Emulation der unterschiedlichen Cartridge Typen (den vollständigen VHDL Code gibt's dann nach dem Hardware Wettbewerb):

Code: Alles auswählen

----------------------------------------------------------------------------------
-- Company:             HiassofT
-- Engineer:            Matthias Reichl
--
-- Create Date:         2011-06-11
-- Module Name:         CartLogic
-- Project Name:        TheCart
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.NUMERIC_STD.ALL;

library work;
use work.all;
use CartDef.all;

entity CartLogic is
    Port (      clk_register: in std_logic;
                a: in vec12;
                d_in: in std_logic_vector;
                rw: in std_logic;
                reset_n: in std_logic;
                cctl: in std_logic;
                s4: in std_logic;
                s5: in std_logic;
                mem_out: out cart_mem_output;
                data_out: out data_output;
                write_enable_out: out std_logic
        );

end CartLogic;

architecture Behavioral of CartLogic is

-- general cart configuration

signal cfg_bank: bankvec := startup_bank;

signal cfg_enable: std_logic := '1';

signal cfg_bank2: bankvec := (others => '0');

signal cfg_enable2: std_logic := '0';

subtype cart_mode_type is std_logic_vector(5 downto 0);
-- 8k modes
constant cart_mode_off:         cart_mode_type := "000000";
constant cart_mode_8k:          cart_mode_type := "000001";
constant cart_mode_atarimax1:   cart_mode_type := "000010";
constant cart_mode_atarimax8:   cart_mode_type := "000011";
constant cart_mode_oss:         cart_mode_type := "000100";

constant cart_mode_sdx64:       cart_mode_type := "001000";
constant cart_mode_diamond64:   cart_mode_type := "001001";
constant cart_mode_express64:   cart_mode_type := "001010";

constant cart_mode_atrax_128:   cart_mode_type := "001100";
constant cart_mode_williams_64: cart_mode_type := "001101";

-- 16k modes
constant cart_mode_flexi:       cart_mode_type := "100000";
constant cart_mode_16k:         cart_mode_type := "100001";
constant cart_mode_megamax16:   cart_mode_type := "100010";
constant cart_mode_blizzard_16: cart_mode_type := "100011";
constant cart_mode_sic:         cart_mode_type := "100100";

constant cart_mode_mega_16:     cart_mode_type := "101000";
constant cart_mode_mega_32:     cart_mode_type := "101001";
constant cart_mode_mega_64:     cart_mode_type := "101010";
constant cart_mode_mega_128:    cart_mode_type := "101011";
constant cart_mode_mega_256:    cart_mode_type := "101100";
constant cart_mode_mega_512:    cart_mode_type := "101101";
constant cart_mode_mega_1024:   cart_mode_type := "101110";
constant cart_mode_mega_2048:   cart_mode_type := "101111";

constant cart_mode_xegs_32:     cart_mode_type := "110000";
constant cart_mode_xegs_64:     cart_mode_type := "110001";
constant cart_mode_xegs_128:    cart_mode_type := "110010";
constant cart_mode_xegs_256:    cart_mode_type := "110011";
constant cart_mode_xegs_512:    cart_mode_type := "110100";
constant cart_mode_xegs_1024:   cart_mode_type := "110101";

constant cart_mode_sxegs_32:    cart_mode_type := "111000";
constant cart_mode_sxegs_64:    cart_mode_type := "111001";
constant cart_mode_sxegs_128:   cart_mode_type := "111010";
constant cart_mode_sxegs_256:   cart_mode_type := "111011";
constant cart_mode_sxegs_512:   cart_mode_type := "111100";
constant cart_mode_sxegs_1024:  cart_mode_type := "111101";

signal cfg_mode: cart_mode_type := cart_mode_8k;

signal cfg_source_ram: std_logic := '0';        -- ROM
signal cfg_write_enable: std_logic := '0';      -- writes disabled

signal cfg_source_ram2: std_logic := '0';       -- secondary bank: ROM
signal cfg_write_enable2: std_logic := '0';     -- secondary bank: writes disabled

-- OSS cart emulation
signal oss_bank: std_logic_vector(1 downto 0) := "00";

-- sic cart 8xxx/axxx enable
signal sic_8xxx_enable: std_logic := '0';
signal sic_axxx_enable: std_logic := '1';

signal access_cctl: boolean;
signal access_8xxx: boolean;
signal access_axxx: boolean;

-- true if accessing cctl range other than Ax
signal access_cctl_other : boolean;

begin

access_cctl <= ( cctl = '0');
access_cctl_other <= (cctl = '0') and (a(7 downto 4) /= x"A");

access_8xxx <= ( s4 = '0');
access_axxx <= ( s5 = '0');

-- read back config registers
config_io: process(a, rw, access_cctl,
        cfg_bank, cfg_enable,
        cfg_bank2, cfg_enable2,
        cfg_source_ram, cfg_write_enable,
        cfg_source_ram2, cfg_write_enable2,
        cfg_mode)
begin
        data_out.dout_enable <= false;
        data_out.dout <= x"00";
        if access_cctl then
                -- cart config (always)
                case a(7 downto 0) is
                when cfg_bank_adr_lo =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= cfg_bank(20 downto 13);
                        end if;
                when cfg_bank_adr_hi =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= "00" & cfg_bank(26 downto 21);
                        end if;
                when cfg_enable_adr =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= "0000000" & cfg_enable;
                        end if;
                when cfg_bank2_adr_lo =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= cfg_bank2(20 downto 13);
                        end if;
                when cfg_bank2_adr_hi =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= "00" & cfg_bank2(26 downto 21);
                        end if;
                when cfg_enable2_adr =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= "0000000" & cfg_enable2;
                        end if;
                when cfg_mode_adr =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= "00" & cfg_mode;
                        end if;
                when cfg_misc_adr =>
                        if (rw = '1') then
                                data_out.dout_enable <= true;
                                data_out.dout <= "0000" &
                                        cfg_source_ram2 & cfg_write_enable2 &
                                        cfg_source_ram & cfg_write_enable;
                        end if;
                when others => null;
                end case;
        end if;
end process config_io;

set_config: process(clk_register)
begin
        if falling_edge(clk_register) then
                if (reset_n = '0') then
                        cfg_mode <= cart_mode_8k;
                        cfg_bank <= startup_bank;
                        cfg_enable <= '1';
                        cfg_bank2 <= (others => '0');
                        cfg_enable2 <= '0';
                        cfg_write_enable <= '0';
                        cfg_source_ram <= '0';
                        cfg_write_enable2 <= '0';
                        cfg_source_ram2 <= '0';
                        oss_bank <= "00";
                        sic_8xxx_enable <= '0';
                        sic_axxx_enable <= '1';
                elsif access_cctl then
                        if (rw = '0') then
                                -- cart config (always)
                                case a(7 downto 0) is
                                when cfg_bank_adr_lo =>
                                        cfg_bank(20 downto 13) <= d_in(7 downto 0);
                                        cfg_enable <= '1';      -- automatically enable cart on bank access
                                when cfg_bank_adr_hi =>
                                        cfg_bank(26 downto 21) <= d_in(5 downto 0);
                                        cfg_enable <= '1';      -- automatically enable cart on bank access
                                when cfg_enable_adr =>
                                        cfg_enable <= d_in(0);
                                when cfg_bank2_adr_lo =>
                                        cfg_bank2(20 downto 13) <= d_in(7 downto 0);
                                        cfg_enable2 <= '1';     -- automatically enable cart on bank access
                                when cfg_bank2_adr_hi =>
                                        cfg_bank2(26 downto 21) <= d_in(5 downto 0);
                                        cfg_enable2 <= '1';     -- automatically enable cart on bank access
                                when cfg_enable2_adr =>
                                        cfg_enable2 <= d_in(0);
                                when cfg_mode_adr =>
                                        cfg_mode <= d_in(5 downto 0);
                                when cfg_misc_adr =>
                                        cfg_source_ram2 <= d_in(3);
                                        cfg_write_enable2 <= d_in(2);
                                        cfg_source_ram <= d_in(1);
                                        cfg_write_enable <= d_in(0);
                                when others => null;
                                end case;

                                -- (s)xegs bank select
                                if (cfg_mode(5 downto 4) = "11") and access_cctl_other then
                                        -- sxegs disable via bit 7
                                        if (cfg_mode(3) = '1') then
                                                cfg_enable <= not d_in(7);
                                        end if;
                                        case cfg_mode is
                                        when cart_mode_xegs_32 | cart_mode_sxegs_32 =>
                                                cfg_bank(14 downto 13) <= d_in(1 downto 0);
                                        when cart_mode_xegs_64 | cart_mode_sxegs_64 =>
                                                cfg_bank(15 downto 13) <= d_in(2 downto 0);
                                        when cart_mode_xegs_128 | cart_mode_sxegs_128 =>
                                                cfg_bank(16 downto 13) <= d_in(3 downto 0);
                                        when cart_mode_xegs_256 | cart_mode_sxegs_256 =>
                                                cfg_bank(17 downto 13) <= d_in(4 downto 0);
                                        when cart_mode_xegs_512 | cart_mode_sxegs_512 =>
                                                cfg_bank(18 downto 13) <= d_in(5 downto 0);
                                        when cart_mode_xegs_1024 | cart_mode_sxegs_1024 =>
                                                cfg_bank(19 downto 13) <= d_in(6 downto 0);
                                        when others =>
                                                null;
                                        end case;
                                end if;
                                -- megacart bank select
                                if (cfg_mode(5 downto 3) = "101") and access_cctl_other then
                                        -- disable via bit 7
                                        cfg_enable <= not d_in(7);
                                        case cfg_mode is
                                        when cart_mode_mega_32 =>
                                                cfg_bank(14 downto 14) <= d_in(0 downto 0);
                                        when cart_mode_mega_64 =>
                                                cfg_bank(15 downto 14) <= d_in(1 downto 0);
                                        when cart_mode_mega_128 =>
                                                cfg_bank(16 downto 14) <= d_in(2 downto 0);
                                        when cart_mode_mega_256 =>
                                                cfg_bank(17 downto 14) <= d_in(3 downto 0);
                                        when cart_mode_mega_512 =>
                                                cfg_bank(18 downto 14) <= d_in(4 downto 0);
                                        when cart_mode_mega_1024 =>
                                                cfg_bank(19 downto 14) <= d_in(5 downto 0);
                                        when cart_mode_mega_2048 =>
                                                cfg_bank(20 downto 14) <= d_in(6 downto 0);
                                        when others =>
                                                null;
                                        end case;
                                end if;
                                -- atrax 128
                                if (cfg_mode = cart_mode_atrax_128) and access_cctl_other then
                                        cfg_enable <= not d_in(7);
                                        cfg_bank(16 downto 13)<= d_in(3 downto 0);
                                end if;
                                -- blizzard
                                if (cfg_mode = cart_mode_blizzard_16) and access_cctl_other then
                                        cfg_enable <= '0';
                                end if;
                                -- sic
                                if (cfg_mode = cart_mode_sic) and (a(7 downto 4) = x"0") then
                                        sic_8xxx_enable <= d_in(5);
                                        sic_axxx_enable <= not d_in(6);
                                        cfg_bank(18 downto 14) <= d_in(4 downto 0);
                                end if;
                        end if;

                        -- cart config using addresses, ignore read/write
                        case cfg_mode is
                        when cart_mode_oss =>
                                -- D500-D50F
                                if (a(7 downto 4) = "0000") then
                                        oss_bank <= a(0) & NOT a(3);
                                end if;
                        when cart_mode_atarimax1 =>
                                -- D500-D50F: set bank, enable
                                if (a(7 downto 4) = x"0") then
                                        cfg_bank(16 downto 13) <= a(3 downto 0);
                                        cfg_enable <= '1';
                                end if;
                                -- D510-D51F: disable
                                if (a(7 downto 4) = x"1") then
                                        cfg_enable <= '0';
                                end if;
                        when cart_mode_atarimax8 =>
                                -- D500-D57F: set bank, enable
                                if (a(7) = '0') then
                                        cfg_bank(19 downto 13) <= a(6 downto 0);
                                        cfg_enable <= '1';
                                end if;
                                -- D580-D58F: disable
                                if (a(7 downto 4) = x"8") then
                                        cfg_enable <= '0';
                                end if;
                        when cart_mode_megamax16 =>
                                -- D500-D57F: set 16k bank, enable
                                if (a(7) = '0') then
                                        cfg_bank(20 downto 14) <= a(6 downto 0);
                                        cfg_enable <= '1';
                                end if;
                                -- D580-D58F: disable
                                if (a(7 downto 4) = x"8") then
                                        cfg_enable <= '0';
                                end if;
                        when cart_mode_williams_64 =>
                                if (a(7 downto 4) = x"0") then
                                        cfg_enable <= not a(3);
                                        cfg_bank(15 downto 13) <= a(2 downto 0);
                                end if;
                        when cart_mode_sdx64 =>
                                if (a(7 downto 4) = x"E") then
                                        cfg_enable <= not a(3);
                                        cfg_bank(15 downto 13) <= not a(2 downto 0);
                                end if;
                        when cart_mode_diamond64 =>
                                if (a(7 downto 4) = x"D") then
                                        cfg_enable <= not a(3);
                                        cfg_bank(15 downto 13) <= not a(2 downto 0);
                                end if;
                        when cart_mode_express64 =>
                                if (a(7 downto 4) = x"7") then
                                        cfg_enable <= not a(3);
                                        cfg_bank(15 downto 13) <= not a(2 downto 0);
                                end if;
                        when others => null;
                        end case;
                end if;
        end if;
end process set_config;

access_cart_data: process(a, rw, access_8xxx, access_axxx,
        cfg_bank, cfg_enable, cfg_bank2, cfg_enable2,
        cfg_source_ram, cfg_write_enable,
        cfg_source_ram2, cfg_write_enable2,
        cfg_mode,
        oss_bank,
        sic_8xxx_enable, sic_axxx_enable)

variable address: vec27;
variable source_ram: boolean;
variable allow_write: boolean;

variable rd4: boolean;
variable rd5: boolean;
variable do_access: boolean;

begin
        address := cfg_bank & a(12 downto 0);
        source_ram := (cfg_source_ram = '1');
        allow_write := (cfg_write_enable = '1');

        rd4 := false;
        rd5 := (cfg_enable = '1');
        do_access := (cfg_enable = '1') and access_axxx;

        if (cfg_mode(5) = '1') then     -- default for 16k carts
                rd4 := (cfg_enable = '1');
                do_access := (cfg_enable = '1') and (access_8xxx or access_axxx);
        end if;

        case cfg_mode is
        when cart_mode_8k |
             cart_mode_atarimax1 | cart_mode_atarimax8 |
             cart_mode_atrax_128 | cart_mode_williams_64 |
             cart_mode_sdx64 | cart_mode_diamond64 | cart_mode_express64 =>
                null;
        when cart_mode_16k | cart_mode_megamax16 | cart_mode_blizzard_16 =>
                if (access_8xxx) then
                        address(13) := '0';
                else
                        address(13) := '1';
                end if;
        when cart_mode_oss =>
                if (oss_bank = "00") then
                        rd5 := false;
                        do_access := false;
                else
                        address(13) := oss_bank(1) and (not a(12));
                        address(12) := oss_bank(0) and (not a(12));
                end if;
        when cart_mode_flexi =>
                rd4 := (cfg_enable2 = '1');
                do_access := (cfg_enable = '1') and access_axxx;
                if (access_8xxx) then
                        address(26 downto 13) := cfg_bank2;
                        do_access := (cfg_enable2 = '1');
                        source_ram := (cfg_source_ram2 = '1');
                        allow_write := (cfg_write_enable2 = '1');
                end if;
        when cart_mode_xegs_32 |cart_mode_sxegs_32 =>
                if (access_axxx) then
                        address(14 downto 13) := (others => '1');
                end if;
        when cart_mode_xegs_64 | cart_mode_sxegs_64 =>
                if (access_axxx) then
                        address(15 downto 13) := (others => '1');
                end if;
        when cart_mode_xegs_128 | cart_mode_sxegs_128 =>
                if (access_axxx) then
                        address(16 downto 13) := (others => '1');
                end if;
        when cart_mode_xegs_256 | cart_mode_sxegs_256 =>
                if (access_axxx) then
                        address(17 downto 13) := (others => '1');
                end if;
        when cart_mode_xegs_512 | cart_mode_sxegs_512 =>
                if (access_axxx) then
                        address(18 downto 13) := (others => '1');
                end if;
        when cart_mode_xegs_1024 | cart_mode_sxegs_1024 =>
                if (access_axxx) then
                        address(19 downto 13) := (others => '1');
                end if;
        when cart_mode_mega_16 | cart_mode_mega_32 | cart_mode_mega_64 | cart_mode_mega_128 |
             cart_mode_mega_256 | cart_mode_mega_512 | cart_mode_mega_1024 | cart_mode_mega_2048 =>
                if (access_8xxx) then
                        address(13) := '0';
                else
                        address(13) := '1';
                end if;
        when cart_mode_sic =>
                rd4 := (cfg_enable = '1') and (sic_8xxx_enable = '1');
                rd5 := (cfg_enable = '1') and (sic_axxx_enable = '1');
                do_access := (access_8xxx and (cfg_enable = '1') and (sic_8xxx_enable = '1'))
                                or
                             (access_axxx and (cfg_enable = '1') and (sic_axxx_enable = '1'));
                if (access_8xxx) then
                        address(13) := '0';
                else
                        address(13) := '1';
                end if;
        when others =>
                rd4 := false;
                rd5 := false;
                do_access := false;
                allow_write := false;
                source_ram := false;
        end case;

        if  (rw = '0') and (allow_write = false) then
                do_access := false;
        end if;

        mem_out.adr <= address;
        mem_out.rd4 <= rd4;
        mem_out.rd5 <= rd5;
        mem_out.ram_access <= false;
        mem_out.rom_access <= false;

        if (do_access) then
                if (source_ram) then
                        mem_out.ram_access <= true;
                else
                        mem_out.rom_access <= true;
                end if;
        end if;
end process access_cart_data;

write_enable_out <= cfg_write_enable;

end Behavioral;


so long,

Hias

Also gibbet nu USB zum flashen vom PC/Mac wie beim Atarimax oder nicht? Würde bei der Kapazität des Moduls ja durchaus Sinn ergeben, oder?

Moin,

skriegel hat geschrieben:Also gibbet nu USB zum flashen vom PC/Mac wie beim Atarimax oder nicht? Würde bei der Kapazität des Moduls ja durchaus Sinn ergeben, oder?

Das wurde doch schon beantwortet... zur Zeit nicht. Im CPLD ist dafür kein Platz mehr. Das Easyflash 3 emuliert nur ein Bruchteil, weil es so viele ROM-Schemata offenbar beim C64 nicht gibt oder die keine Relevanz haben. Dann war halt Platz frei. Wobei ich vermute (ich habe es nicht überprüft), daß auf dem Easyflash noch ein kleiner ATMEL oder so drauf ist, der den USB Sklaven macht.

Das ist aber alles nicht so wild. Durch das inkrementelle Flashen dauert es nur beim "ersten Mal" richtig lange - sofern man die Kapazität ausreizt. Schau Dir einfach mal das Studio von Peter an, die Software ist schon richtig klasse. Und ist Java - also auch Mac-freundlich.

Gruß, Jürgen

HiassofT hat geschrieben:

Die Hardware wurde für den C64 als offenes Projekt entwickelt, die Software inklusive der PLD Programmierung veröffentlicht. Das Modul benutzt die von Hias oben beschriebene 8k Flashtechnik, die Bauteile sind die gleichen.

Eine nette Portierung.

Huh?!? Willst Du uns mit dieser seltsamen Formulierung etwa unterstellen wir hätten abgekupfert?
....
so long,

Hias

Hallo Hias,
>Eine nette Portierung
falls du dich damit angegriffen fühlst, entschuldige ich mich bei dir hier vor allen.
Mit deiner Darstellung ist jetzt alles klar, beide Projekte haben nichts miteinander zu tun.

Bye,
Bernd

Hallo Bernd!

Bernd hat geschrieben:>Eine nette Portierung
falls du dich damit angegriffen fühlst, entschuldige ich mich bei dir hier vor allen.
Mit deiner Darstellung ist jetzt alles klar, beide Projekte haben nichts miteinander zu tun.

OK, Butter bei die Fische - Deine Formulierung kam halt etwas seltsam bei mir an.

so long,

Hias

Hi Hias,
einige Fragen zum Modul. Wenn alles mit unterschiedlichen Modultypen 16,64,128k, 1MB hintereinander beschrieben wurde und einzelne Blöcke zb. 16k, 32k anschließend entfernt werden, wie löst ihr das Problem mit der Fragmentierung. Können einzelne Blöcke zu einem neuen Typ zusammengefasst werden? Wenn auf dem Modul teile gelöscht wurden, wie erfährt dies das Studio Programm? Wird die FAT übermittelt?

Bye,
Bernd

Hallo Bernd!

Bernd hat geschrieben:einige Fragen zum Modul. Wenn alles mit unterschiedlichen Modultypen 16,64,128k, 1MB hintereinander beschrieben wurde und einzelne Blöcke zb. 16k, 32k anschließend entfernt werden, wie löst ihr das Problem mit der Fragmentierung. Können einzelne Blöcke zu einem neuen Typ zusammengefasst werden? Wenn auf dem Modul teile gelöscht wurden, wie erfährt dies das Studio Programm? Wird die FAT übermittelt?

Den Teil hat Peter in seiner Software implementiert, vielleicht kann er noch etwas genaueres dazu schreiben.

Grundsätzlich liegt die Verwaltung des Moduls in der Hand vom Cart Studio. Möchte man auch vom Atari direkt aus Module reinprogrammieren, so kann man am Ende des Flashes dafür einen Teil reservieren. Der Teil wird dann vom Cart Studio nicht angefasst, um die Verwaltung wo genau was liegt muss man sich selber kümmern. Hatte dazu aber letztens die Idee (muss ich erst Peter mailen :), daß es praktisch wäre wenn man die Info auch im Cart Studio hinterlegen könnte (damit die Sachen dann auch im Auswahlmenü auftauchen).

Bezüglich der Fragmentierung: Die Cart Images müssen aligned sein, ein 32k Modul zB an einer 32k-Grenze beginnen, ein 1MB Modul an einer 1MB Grenze etc. Die Software erkennt freie zusammenhängende Blöcke und kann dann zB in einen 8k+8k Block ein 16k Image speichern. Mit der Zeit kann es aber natürlich passieren, daß Speicher fragmentiert und zB noch 2MB frei wären aber nicht mehr am Stück.

Aktuell bietet die Software dafür eine "defragmentierungs" Option. Damit werden die Images umgeschlichtet, sodass am Ende des Speichers ein großer Block frei ist. Der Nachteil dabei ist, daß das negative Auswirkungen auf die inkrementelle Flash Funktion hat - es müssen wahrscheinlich grössere Teile der Cart neu programmiert werden.

Eine andere Möglichkeit ist die manuelle Defragmentierung. In der GUI fehlt zwar glaubich noch die Option die Start-Bank manuell zu setzen, ich hab das bisher meist durch Editieren des Workbook-Files (ein ganz normales XML File, mit jedem Editor bearbeitbar) erledigt. Evtl. wär auch eine "reassing Bank" Option praktisch, die automatisch eine neue Bank auswählt (mit dem gleichen Ergebnis wie zuerst das Image zu entfernen und dann wieder neu hinzuzufügen).

So lange genug Speicher in der Cart frei ist sollte die Fragmentierung eigentlich keine Probleme machen. Je voller sie ist, desto kritischer wird's aber. Wir warten da auch mal auf Feedback, es kommt ja auch drauf an wie die User mit der Software umgehen, und bauen dann ggf noch weitere Optionen in die Software ein. Denkbar wär zB auch eine partielle Defragmentierung, nur Images kleiner als ein angegebener Wert zu verschieben.

so long,

Hias

Hallo Hias!
Ich hätte die Modulfiles in "gleiche Schubladen" unterteilt. 8k Modultypen, 16k Modultypen, usw und z.b. 1MB Atarimax mit 1 MB Megacart zusammen gefasst, da die Speichergrößen identisch sind. Diese hätte ich dann für gewisse Bereiche im Modulspeicher reserviert. Die Vorgabe für die Speichergößen der einzelnen Bereiche wäre über eine Maske regelbar. So kann dann jeder selbst entscheiden wieviel Files (Speicher) er für seinen Modultyp verwenden möchte. Diese Schubladen (Bereiche) im Modulspeicher sind dann exklusiv für diese Größen reserviert. Falls es einen nicht zugeordneten Bereich gibt, so ist dieser für einen Mischbetrieb freigegeben. Der Vorteil dieser Logik ist, man benötigt kein Defragmentierungstool. Gelöschte Romfiles können durch den gleichen Typen ersetzt werden. Der Mischbetrieb liegt dabei außen vor, dafür ist jeder selbst zuständig.

Was das Händling mit dem Cart Studio anbelangt, beim starten des Programmes sollte eine Frage für einen Abgleich mit der FAT im Modul erfolgen. Gelöschte Files werden dann automatisch aus dem Studio entfernt. Wer dem Anwender die Verwaltung so überlässt, sorgt für einen gewaltigen Zettelbetrieb um die Daten abzugleichen und wehe er macht mal einen Fehler. Zusätzlich würde ich noch eine Seriennummer mit übertragen. Wer mehr als ein Modul hat wird automatisch mit der richtigen Zusammenstellung verbunden.

So wäre mein Konzept für ein Multi Modul.

Bye,
Bernd

Schade ist, dass die beiden "Modulfraktionen" nicht in der Lage sind, in früheren Stadien Informationen, Ideen und Gedanken auszutauschen. Bei Bündelung der Kräfte wären wahrscheinlich noch tollere und ausgereiftere Produkte zu erwarten. Stattdessen zerreibt man sich in unnötigen Konkurrenzkämpfen...

ja...
das war vor etlichen Jahren auch mal ein Vorschlag von mir Bernd gegenüber,
kam aber keine Reaktion...

Es ist so wie es es.

Eine andere Möglichkeit ist die manuelle Defragmentierung. In der GUI fehlt zwar glaubich noch die Option die Start-Bank manuell zu setzen, ich hab das bisher meist durch Editieren des Workbook-Files (ein ganz normales XML File, mit jedem Editor bearbeitbar) erledigt. Evtl. wär auch eine "reassing Bank" Option praktisch, die automatisch eine neue Bank auswählt (mit dem gleichen Ergebnis wie zuerst das Image zu entfernen und dann wieder neu hinzuzufügen).

Das ist alles schon drin. Du Kannst "Start Bank Fixed" setzen und dann einen Wert angeben. Dabei wird auch reassigned, wenn das Ziel frei ist. Du kannst auch inkonsistent speichern wenn Du magst, aber spätestens beim Export muss es passen. Das ganze ist aber nicht zum manuell Defragmentieren gedacht, sondern für Spezialfälle wie ich einige programmieren und testen muss.

Deshalb ist das standardmäßig ausgeblendet (Kontextmenü auf den Spalten).

So kann dann jeder selbst entscheiden wieviel Files (Speicher) er für seinen Modultyp verwenden möchte. Diese Schubladen (Bereiche) im Modulspeicher sind dann exklusiv für diese Größen reserviert. Falls es einen nicht zugeordneten Bereich gibt, so ist dieser für einen Mischbetrieb freigegeben. Der Vorteil dieser Logik ist, man benötigt kein Defragmentierungstool. Gelöschte Romfiles können durch den gleichen Typen ersetzt werden. Der Mischbetrieb liegt dabei außen vor, dafür ist jeder selbst zuständig.

Ich habe jahrelang DEFRAG bei der Arbei zugeschaut und fand das immer geil, die bunten Kästchen, wo wird es nun hingesetzt .... im Ernst Jetzt habe ich auch ein eigenes. Und das findet immer automatisch das Optium ohne dass der Benutzer es merkt. Im Kern funktioniert jeder DEFRAG gleich und zwar so wie Du beschrieben hast, nur dass die Bereiche für jeweils fest Größen sich dynamisch anpassen.

Gelöschte Files werden dann automatisch aus dem Studio entfernt. Wer dem Anwender die Verwaltung so überlässt, sorgt für einen gewaltigen Zettelbetrieb um die Daten abzugleichen und wehe er macht mal einen Fehler.

Das Studio hat 2 Ziele:
- Baue mit AtariMax Studio was Du willst und wie Du willst, nutze alle seine Features (.XEX, ATR) und hab nacher doch auch mein Menü. Mit der Ansatz kommen im Extremfall 63 1 MB Module ins Projekt.
- Das ganze Projekt kann als 1 ZIP exportiert und weitergegeben werden und funktioniert egal was Du sonst auf der Platte änderst (Pfade, Order usw.). Kurz: Fehler machen kannst Du eigentlich nicht. Hier hast Du im Extremfall 8000 8K Module im Projekt

und halt alles dazwischen. Und wenn Du die Files in einem anderen Order hast sagst Du einfach "Hinzufügen" und fügst alles hinzu. Dann werden die fehlenden übernommen. Automatisch gelöscht wird aktuell extra nicht, da man im Projekt ja noch mehr Daten (Genre, ...) eingegeben hast.

Richtigstellung....

Erstmal möchte ich mich noch einmal für mein erstes Posting entschuldigen. Wegen der vielen Übereinstimmungen beider Projekte habe ich mich zu einer Aussage hingezogen gefühlt, diese war unpassend und ich verurteile sie selber. Ich möchte auch nicht euer Modul diskreditieren, dazu habe ich kein Recht. Was mich eigentlich dazu bewegt hat, wenn Leistungen, die andere erstellt haben, als eigene ausgegeben werden. Wegen der Übereinstimmung des schreibens der Software in das Flash und den dazu wichtigen IC´s hatte ich mein Urteil ohne die Darstellung der The!CART Entwickler vorab gefällt, nochmals Sorry dafür. Bewegt zu dieser Datstellung hat mich der Hinweis des Autor Thomas 'skoe' Giesel, der Programierer des XILINX Chips der C64 Hardware, der in seiner Veröffentlichung auf folgendes hin: The origin of this software must not be misrepresented; you must not claim that you wrote the original software.

Die erste lauffähige Easy Flash 3 Version wurde am 06.09.2011 veröffentlicht: Youtoube.

Deshalb zolle ich hier mein Respekt: Hias für all seine Leistungen rund um den Atari, dem Autor Thomas 'skoe' Giesel, der als erster den genialen Weg fand über den XILINX Chip Daten vom SRam ins Flash zu schaufeln. Dies ist meine persöhnliche Meinung.

honorem ei, qui meritur.

Noch etwas, warum mir die Ähnlichkeit auffiel, ich war mal Besitzer eines C64er und schaue immer noch gerne mal über den Tellerrand.


Bye,
Bernd

Hallo Peter,
ich habe deine Darstellung verstanden und bin auf das Resultat gespannt.

Bye,
Bernd

mega-hz hat geschrieben:ja...
das war vor etlichen Jahren auch mal ein Vorschlag von mir Bernd gegenüber,
kam aber keine Reaktion...

Es ist so wie es es.

Dies sollten wir mal unter vier Augen besprechen und gehört in kein Forum.

Bernd

Hallo,

ich habe mir das The!Cart Studio schon einmal angesehen. Natürlich noch ohne The!Cart.

Als unerfahrener User musste ich schauen, wie ich dieses Java Programm starten muss. Falls auch Jemand noch das Problem hat ... Unter Ubuntu geht es so.

dl7ukk@computer:~$ java -jar Downloads/TheCartStudio.jar

Hallo Jac!,


soll beim The!Cart Studio die Menüleiste (fast) unsichtbar sein? Oder sind es meine Bildschirmeinstellungen die mir da einen Streich spielen ...

in der Hilfe steht, daß Ubunto da wohl einen kleinen Bug hat:

...Please note that there is a known bug in Ubuntu , for example 12.10 with openjdk7. It is tracked as "Unreadable menu bar with Ambiance theme in Java/Swing GTK L&F" and causes the menu to appear too dark, making is barely readable with the standard desktop theme. Change the desktop theme fixes this.

Gruß,
Wolfram