Pierwsze dni ze sprzętem „retro” uświadamiają nam jak wiele technologii, które dzisiaj są dla nas 'oczywiste’ – wcale takimi nie były tych kilkadziesiąt lat temu. Zwłaszcza dotyczy to pamięci masowych. Gdy minie pierwsza fascynacja kasetami, gdy zrozumie się jak niewielką częścią gigabajta jest 720 kB i doświadczy, że „zapisana” dyskietka wcale nie musi być „odczytywalna” – czas poszukać rozwiązań do pracy „na co dzień” (czy weekend).
Sporym ułatwieniem jest używanie karty SD podłączanej do Atari przez interfejs ACSI. Komputer widzi taką kartę jako dysk twardy. Można na niej tworzyć partycje, formatować, ustawić jako startową – no i oczywiście kopiować/odczytywać dane. Jeżeli chcemy przenieść programy – po prostu wyciągamy kartę z Atari i zapisujemy w „normalnym” komputerze (choć to akurat wymaga dodatkowych zabiegów).
Takie rozwiązania już istnieją. Urządzenia pamięci masowej podłączane do ACSI można kupić w Internecie – są rozwijane od lat, dopracowane, po prostu – gotowe produkty sklepowe. Fakt: kosztują swoje – ale za tym idą lata pracy nad nimi. Czy można jednak coś takiego zrobić samemu (i co tu dużo ukrywać: taniej)? Okazuje się, że tak. Przeglądając sieć wpadł mi w oko github retro 16. Projekt acsi2stm wydał się stosunkowo prosty do wykonania i bardzo ekonomiczny – czemu więc nie spróbować?
I ubiegając wieli finał… działa🙂 Choć ma pewne ograniczenia.
Oryginalnie port ACSI wykorzystywany był do podłączania (kaskadowego) urządzeń typu twardy dysk czy drukarka. O dyskach ACSI pisałem już kilka razy – zapraszam do tekstów o megafile-30 i sh-205. Co do zasady, pomysł na podłączenie czytnika kart SD do Atari jest podobny:
- Do ACSI podłączamy urządzenie, które emuluje zachowanie twardego dysku, tzn. z punktu widzenia Atari odpowiada jak twardy dysk (to znaczy musi nim być:)),
- Urządzenie to obsługuje czytnik kart SD,
- Gdy komputer poprosi o dane z dysku, urządzenie tłumaczy to na operacje wykonywane na karcie SD – i zwraca odpowiednie dane do komputera.
Oczywiście – czysto teoretycznie – zamiast karty SD można by użyć np. flaszki na USB. Niestety obsługa urządzeń USB jest dużo bardziej skomplikowana. Zostańmy więc przy karcie SD.
Zanim zaczniecie… Musicie być świadomi kilku szczegółów…
Zanim zaczniecie
Przeszkoda: kabel d-sub 19? (TYLKO DLA MEGA ST)
Jeżeli śledziliście moje poprzednie posty o dyskach Atari wiecie, że problemem jest dostanie odpowiedniego kabla – male-male d-sub 19 pin. Takie kable nie są już używane/ produkowane – i pewnie niewielu z Was ma szczęście posiadać oryginał. Nie musicie:) Dla modeli z rodziny Mega ST (1/2/4), piny portu ACSI wyprowadzono na płycie w formie rastra gold-pinów 2.5mm.
Uwaga: wyprowadzenie to znajduje się tylko na płycie Mega ST (pizza box). 1040 już takiego nagłówka nie ma.
Dolutowanie się do płyty 1040 jest dalej możliwe, choć na pewno trochę trudniejsze. Oczywiście, dalej możecie skonstruować acsi2stm jako urządzenie zewnętrzne. Jeżeli nie macie odpowiedniego kabla db19 – można przerobić wtyczkę DB25…
Tak wygląda to gniazdo wewnątrz komputra Atari ST: (link do tekstu na http://joo.kie.sk/wp-content/uploads/2013/05/):
Zauważcie: porównując to rozwiązania z oryginalnym na stronie projekt retro 16, gdzie moduł podłącza się od strony gniazda zewnętrznego, wyprowadzenia będą trochę inne – co trzeba wziąć pod uwagę przy lutowaniu płytki.
Przeszkoda: zasilanie
Moduł wymaga zasilania 5v. Stabilizator na kontrolerze ST wytrzyma do 5.5v. Z takim zasilaniem nie powinno być problemów w komputerze – Atari ST do pracy używa 5v i 12v. Wystarczy podpiąć się pod którąś z wtyczek. Zazwyczaj kabelki masy są czarne, 5v czerwone, 12v niebieskie lub żółte – ale nie musi to być reguła. Sprawdźcie dokładnie miernikiem.
Przeszkoda: współpraca Windows PC i Atari
I tu zaczynają się schody. Chociaż Atari używa takiego samego (prawie) systemu plików FAT16 jak DOS czy Windows (wczesny), MBR (Master Boot Record), który trzyma dane partycji, jest inny. Czyli w „normalnej” sytuacji – PC nie odczyta dysku podzielonego na partycje i sformatowanego przez Atari. Podobnie nie da rady tak sformatować karty SD pod Windows, żeby odczytało go Atari.
Problem ten można rozwiązać stosując sterowniki dysku Atari takie jak HDDRIVER lub PP (Pery Putnik). Niestety obydwa są płatne – kosztują odpowiednio 40+ i 10 EUR. Nie miałem jeszcze okazji je wypróbować. Sterowniki te pokonują barierę 30MB i partycje mogą mieć nawet ponad 500MB.
Opisywane tu rozwiązanie można spokojnie używać jako alternatywę dla dysków twardych Atari czy podobnych urządzeń dostępnych komercyjnie. Ale bez wymienionych wyżej sterowników, nie da rady odczytać takiej karty SD sformatowanej pod Atari w komputerze z Windows.
Czytniki
Zgodnie z kilkoma doświadczeniami, czytniki kart SD różnią się między sobą. Pierwszym objawem kłopotów jest to, że biblioteka SdFat nie może rozpoznać wielkości włożonej karty SD. Jeżeli tak jest, trzeba przestawić częstotliwość z jaką pracuje ta biblioteka – zobaczcie poniżej.
Co potrzeba?
Będziecie potrzebowali:
- Mikrokontroler STM32F103C8T6 (tzw. blue pill)- bardzo popularny, kosztuje mniej niż 20 złotych,
- Moduł czytnika kart SD, kolejne 20 złotych – choć widziałem tańsze – ważne, żeby miał konwerter z 5v na 3.3v (zasilanie i logika),
- Port USb2serial do programowania kontrolera, konieczny jeżeli pracujecie z praktycznie dowolnym kontrolerem (ten sam co użwacie np. do programowania Arduino; można te użyć samo Arduino),
- Miernik – do mierzenia napięcia na płycie, poprawności połączeń,
- Płytka uniwersalna, żeby na czymś to polutować, trochę kabelków połączeniowych, gniazdo gold-in 2×12 (do płyty ST), goldpiny (piny/gniazda),
- Podstawowe umiejętności lutowania:)
Wszystko opisane jest na stronie projektu acsi2stm, ale dla kompletności tekstu opiszę to jeszcze raz poniżej.
Środowisko programowania
Do programowania STM wystarczy Arduino IDE (do ściągnięcia za darmo w z sieci, ja używam 1.8.13). Musicie dodać kilka bibliotek:
- Zainstalujcie: Narzędzia->Płytka->Menadżer Płytek->Arduino SAM Boards
- Z tej strony pobierzcie bibliotekę, rozpakujcie do C:\Users\..\Documents\Arduino\hardware
- Zmieńcie nazwę folderu na z „Arduino_STM32-master” na „Arduino_STM32”
- Kolejno trzeba dodać bibliotekę SDFat: Szkic: dodaj bibliotekę->zarządzaj, SDFat – by Bill Greaiman, ja pobrałem wersję 2.0.6
Pobieranie projektu i kompilacja
Do ściągnięcia kodu przyda się git – pobierzcie go ze strony https://git-scm.com/download/win. Teraz:
git clone https://github.com/retro16/acsi2stm.git
Otwórzcie projekt i ustawcie docelowy procesor, jak wskazano na stronie projektu:
- Board: Generic STM32F103C series
- Variant: STM32F103C8
- Upload method: Serial
- CPU speed: 72MHz (normal)
- Optimize: Fastest (-O3)
- Port: your USB serial dongle
Pozostało skompilować projekt – mi zaskoczył od pierwszego razu.
Kilka zmian…
Mimo, że projekt skompilował się od razu, musiałem w nim zrobić kilka zmian.
Logi
Na początek proponuję ustawić:
- #define ACSI_DEBUG 1
- #define ACSI_VERBOSE 1
Dzięki temu będziecie widzieli co się dzieje z kontrolerem. Po wypaleniu kodu otwórzcie konsolę szeregową, ustawcie ją na szybkość transferu 115200. Teraz zobaczycie co się dokładnie dzieje z modułem. I możecie reagować w zależności od pojawiających się błędów.
UWAGA: w ostatecznej wersji ustawcie te flagi z powrotem na „0”. Wysyłanie wiadomości diagnostycznych po porcie szeregowym wpływa na wydajność modułu.
Wracając do czytników kart…
Podczas pierwszego uruchomienia kontroler wykrył czytnik SD bez większych problemów. Wszystko niby działało… ale żadne dane nie trafiały na kartę SD. Co więcej – przy inicjalizacji karta namiętnie pokazywała wielkość „0”. Na konsoli szeregowej wyglądało to tak:
1 2 3 4 5 6 7 8 9 |
----------------------- ACSI2STM SD bridge v2b2 ----------------------- Initializing SD card 0...done Size: 0MB - 0 blocks 1 SD cards found Initializing ACSI bus ... ACSI bus ready |
Powodów szukałem w pull-upach itp… W rezultacie wystarczyła drobna zmiana w sposobie, jaki szkic inicjuje bibliotekę obsługi karty. Około linii 708, z:
1 |
initialized = card.begin(SdSpiConfig(sdCs[acsiDevId], SHARED_SPI)); |
Na (uwaga: wersja dla jednego czytnika SD):
1 |
initialized = card.begin(SdSpiConfig(SS, SHARED_SPI, SD_SCK_MHZ(16))); |
W ten sposób obniżyłem częstotliwość obsługi karty – i nagle wszystko zadziałało. Wybrana częstotliwość była dobra dla jednego rodzaju czytnika – dla innego musiałem ją obniżyć jeszcze bardziej – do 8MHz (paradoksalnie: o wiele droższego).
Teraz:
1 2 3 4 5 6 7 8 9 |
----------------------- ACSI2STM SD bridge v2b2 ----------------------- Initializing SD card 0...done Size: 958MB - 1961984 blocks (capped to 102MB) 1 SD cards found Initializing ACSI bus ... ACSI bus ready |
Dla porównania: czytnik na 16MHz:
i na 8Mhz- trochę wolniejszy:
Inne zmiany
Druga zmiana, dosłownie kilka linijek poniżej, była kosmetyczna – ale kompilator narzekał, że card.cardSize() jest stara i nie powinna być używana. Stąd zamiast:
1 |
blocks = card.cardSize(); |
wpisałem:
1 |
blocks = card.sectorCount(); |
Rozmiar karty
Wkładając 2GB kartę system zobaczy prawie 4 miliony sektorów. Niektóre procedury testują powierzchnię szukając bad-sektorów. Przy takiej ich ilości będzie to trwało wieczność. Ja ograniczyłem rozmiar do ok. 100Mb:
1 |
#define SD_MAX_BLOCKS 0x033333 |
Wystarczy odkomentować tą flagę i zmienić jej wartość (liczba szesnastkowa, podzielona przez 2 da mniej-więcej liczbę MB).
Ilość dostępnych czytników
Projekt może obsługiwać kilka czytników kart – ale jeżeli nie korzystacie z nich, warto je wyłączyć. Dzięki temu przyspieszycie inicjalizację urządzenia. W strukturze sdCs wstawcie -1 w miejsca nieużywanych czytników – tutaj korzystam tylko z jednego:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// Pin definitions static const int sdCs[] = { // List of SD card CS pins. CS pins must be on PA0 to PA4. // Use -1 to ignore an ID PA4, // ACSI ID 0 -1, // ACSI ID 1 -1, // ACSI ID 2 -1, // ACSI ID 3 -1, // ACSI ID 4 -1, // ACSI ID 5 -1, // ACSI ID 6 -1, // ACSI ID 7 }; |
Programowanie STM
Tu potrzebujecie port USB2Serial. Ustawcie go na 3.3.v. Połączenie:
- TX do PA10,
- RX to PA9
- GND portu do GND ST.
- PWR do PWR ST
- Na ST: BOOT0 w stan wysoki 1 (włączenie ładowania przez serial do flasha) – do normalnego działania trzeba przełączyć z powrotem na „0”,
- Na ST: wciśnij przycisk reset,
Lutując płytkę zawsze „wystawiam” sobie dostęp do pinów służących do programowania i zasilania – wygodniejsze to niż ciągłe przekładanie kontrolera do programatora.
Teraz możecie załadować projekt z IDE – ustawiając odpowiedni port szeregowy. Konsola szeregowa umożliwi podglądnięcie wykonania program (szybkość 115200).
UWAGA: gdy podłączycie STM’a do Atari – dalej możecie wgrywać na niego kod. Pamiętajcie jedynie o ODŁĄCZENIU ZASILANIA Z PORTU USB2SERIAL DO STM. Inaczej możecie uszkodzić moduł. Oczywiście dalej masy muszą być spięte.
Piny STM
Ze strony https://stm32duinoforum.com/forum/wiki_subdomain/index_title_Blue_Pill.html:
Stąd podłączenie do ACSI z użyciem wewnętrznego gniazda:
ACSI | STM32 | PIN na załączu | Description |
---|---|---|---|
01 | PB8 | D0: 2 (górny – lewy) | Data 0 (LSB) |
02 | PB9 | D1: 4 (górny rząd) | Data 1 |
03 | PB10 | D2: 6 (górny rząd) | Data 2 |
04 | PB11 | D3: 8 (górny rząd) | Data 3 |
05 | PB12 | D4: 10 (górny rząd) | Data 4 |
06 | PB13 | D5: 12 (górny rząd) | Data 5 |
07 | PB14 | D6: 14 (górny rząd) | Data 6 |
08 | PB15 | D7: 16 (górny rząd) | Data 7 (MSB) |
09 | PB7 | CS: : 18 (górny rząd) | Chip Select |
10 | PA8 | IRQ : 24 (ostatni w górny rząd) | Interrupt |
11 | GND | GND | Ground |
12 | (nc) | RST | Reset |
13 | GND | GND | Ground |
14 | PA12 | ACK : 11 (dolny rząd) | Acknowledge |
15 | GND | GND | Ground |
16 | PB6 | A1 : 19 (dolny rząd) | Address bit |
17 | GND | GND | Ground |
18 | (nc) | R/W | Read/Write |
19 | PA11 | DRQ : 23 (dolny rząd najbardziej po prawej) | Data request |
Pierwsza przymiarka
Zanim zaczniecie lutować, proponuję wszystko złożyć na płytce stykowej. Przynajmniej część z kartą SD. W przykładach (Plik->Przykłady->Sdfat) znajdziecie projekt SDInfo. Możecie użyć go żeby zweryfikować połączenie z czytnikiem kart.
Lutujemy
A teraz czas na łącze ACSI:
I w Atari… na razie trochę „developmentowo”:
Uruchomienie
Pobierzcie ICD tools ze strony http://joo.kie.sk/?page_id=306. Przenieście zawartość paczki na dyskietkę i włóżcie ją do stacji Atari. Podłączcie zaprogramowanego STM’a, do czytnika włóżcie jakąś kartę SD. Wystartujcie komputer. Jeżeli wszystko poszło zgodnie z planem, przy starcie powinien pojawić się komunikat:
Teraz po prostu użyjcie program INSTALL.PRG. Zrobi za Was co trzeba – stworzy partycje, sformatuje je, założy katalog auto i ustawi partycję C: jako startową.
Po restarcie:
Wersja docelowa
Czas pozbyć się prowizorki i jakoś zamontować kontroler w obudowie – i wystawić czytnik kart SD na zewnątrz. Przyda się drukarka 3D:)
I czytnik – u mnie zmieścił się jeszcze port zasilający:
Podsumowanie
Po prostu jestem zadowolony. Niewielka inwestycja – a zysk niesamowity. Nawet bez możliwości przenoszenia danych z/na Windows – dysk sprawuje się świetnie. Jak tylko kupię sterowniki – dam Wam znać jak to jest z czytaniem kart spormatowanych pod Windows.
Źródła
- https://github.com/retro16/acsi2stm
- https://github.com/rogerclarkmelbourne/Arduino_STM32/wiki/Installation
- http://joo.kie.sk/wp-content/uploads/2013/05/megast_pinout.jpg
- https://www.seniorlinuxadmin.co.uk/atari-fs.html
- https://www.atari-forum.com/viewtopic.php?t=34967