Mirrors/cartreader
2
0
Fork 0
mirror of https://github.com/sanni/cartreader.git synced 2024-11-10 23:15:08 +01:00
Code Issues Projects Releases Wiki Activity
029c33dfb9
cartreader/Cart_Reader/C64.ino

1503 lines
41 KiB
Arduino
Raw Normal View History

Add support for Atari 5200/7800, C64, Vectrex (thx to skaman)
2023-09-23 00:11:08 +02:00
//******************************************
// COMMODORE 64 MODULE
//******************************************
#ifdef enable_C64
// Commodore 64
// Cartridge Pinout
// 44P 2.54mm pitch connector
//
// FRONT BACK
// SIDE SIDE
// +-------+
// GND -| 1 A |- GND
// +5VDC -| 2 B |- /ROMH
// +5VDC -| 3 C |- /RESET
// /IRQ -| 4 D |- /NMI
// R/W -| 5 E |- PHI2
// DOTCLK -| 6 F |- A15
// /IO1 -| 7 H |- A14
// /GAME -| 8 J |- A13
// /EXROM -| 9 K |- A12
// /IO2 -| 10 L |- A11
// /ROML -| 11 M |- A10
// BA -| 12 N |- A9
// /DMA -| 13 P |- A8
// D7 -| 14 R |- A7
// D6 -| 15 S |- A6
// D5 -| 16 T |- A5
// D4 -| 17 U |- A4
// D3 -| 18 V |- A3
// D2 -| 19 W |- A2
// D1 -| 20 X |- A1
// D0 -| 21 Y |- A0
// GND -| 22 Z |- GND
// +-------+
//
// TOP
// +---------------------------------------------------------------------------------------+
// | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// LEFT | | RIGHT
// | A B C D E F H J K L M N P R S T U V W X Y Z |
// +---------------------------------------------------------------------------------------+
// BOTTOM
//
// CONTROL PINS:
// /RESET(PH0) - SNES RESET
// PHI2(PH1) - SNES CPUCLK
// /GAME(PH3) - SNES /CS
// /EXROM(PH4) - SNES /IRQ
// R/W(PH6) - SNES /RD
// /ROML(PL0) - SNES A16
// /ROMH(PL1) - SNES A17
// /IO1(PL2) - SNES A18
// /IO2(PL3) - SNES A19
//******************************************
// Defines
//******************************************
#define PHI2_ENABLE PORTH |= (1 << 1)
#define PHI2_DISABLE PORTH &= ~(1 << 1)
#define GAME_DISABLE PORTH |= (1 << 3)
#define GAME_ENABLE PORTH &= ~(1 << 3)
#define EXROM_DISABLE PORTH |= (1 << 4)
#define EXROM_ENABLE PORTH &= ~(1 << 4)
#define ROML_DISABLE PORTL |= (1 << 0)
#define ROML_ENABLE PORTL &= ~(1 << 0)
#define ROMH_DISABLE PORTL |= (1 << 1)
#define ROMH_ENABLE PORTL &= ~(1 << 1)
#define IO1_DISABLE PORTL |= (1 << 2)
#define IO1_ENABLE PORTL &= ~(1 << 2)
#define IO2_DISABLE PORTL |= (1 << 3)
#define IO2_ENABLE PORTL &= ~(1 << 3)
//******************************************
// Supported Mappers
//******************************************
// Supported Mapper Array
// Format = {c64mapper,c64lo,c64hi}
static const byte PROGMEM c64mapsize[] = {
0, 0, 3, // Normal 4K/8K/16K + Ultimax 8K/16K
1, 5, 5, // Action Replay 32K [UNTESTED]
2, 3, 3, // KCS Power Cartridge 16K [UNTESTED]
3, 6, 6, // Final Cartridge III 64K [UNTESTED]
4, 3, 3, // Simons Basic 16K [UNTESTED]
5, 7, 9, // Ocean 128K/256K/512K
6, 2, 2, // Expert Cartridge 8K [UNTESTED]
7, 7, 7, // Fun Play, Power Play 128K [UNTESTED]
8, 6, 6, // Super Games 64K [UNTESTED]
9, 5, 5, // Atomic Power 32K [UNTESTED]
10, 2, 2, // Epyx Fastload 8K [UNTESTED]
11, 3, 3, // Westermann Learning 16K [UNTESTED]
12, 1, 1, // Rex Utility 8K [UNTESTED]
13, 3, 3, // Final Cartridge I 16K [UNTESTED]
14, 6, 6, // Magic Formel 64K [UNTESTED]
15, 9, 9, // C64 Game System, System 3 512K [UNTESTED]
16, 3, 3, // WarpSpeed 16K [UNTESTED]
17, 7, 7, // Dinamic 128K [UNTESTED]
18, 4, 4, // Zaxxon, Super Zaxxon (SEGA) 20K [UNTESTED]
19, 5, 7, // Magic Desk, Domark, HES Australia 32K/64K/128K [UNTESTED]
20, 6, 6, // Super Snapshot 5 64K [UNTESTED]
21, 6, 6, // Comal-80 64K [UNTESTED]
};
int C64[] = { 4, 8, 12, 16, 20, 32, 64, 128, 256, 512 };
byte c64lo = 0; // Lowest Entry
byte c64hi = 9; // Highest Entry
byte c64mapcount = 22; // (sizeof(mapsize)/sizeof(mapsize[0])) / 3;
boolean c64mapfound = false;
byte c64mapselect;
int c64index;
byte c64mapper;
byte newc64mapper;
byte c64size;
byte newc64size;
uint8_t c64banks;
byte c64port; // exrom+game
byte newc64port;
// EEPROM MAPPING
// 07 MAPPER
// 08 ROM SIZE
// 12 PORT STATE - EXROM/GAME
//******************************************
// MENU
//******************************************
// Base Menu
static const char c64MenuItem1[] PROGMEM = "Select Cart";
static const char c64MenuItem2[] PROGMEM = "Read ROM";
static const char c64MenuItem3[] PROGMEM = "Set Mapper + Size";
static const char* const menuOptionsC64[] PROGMEM = { c64MenuItem1, c64MenuItem2, c64MenuItem3, string_reset2 };
void c64Menu() {
convertPgm(menuOptionsC64, 4);
uint8_t mainMenu = question_box(F("C64 MENU"), menuOptions, 4, 0);
switch (mainMenu) {
case 0:
// Select Cart
setCart_C64();
wait();
setup_C64();
break;
case 1:
// Read ROM
sd.chdir("/");
readROM_C64();
sd.chdir("/");
break;
case 2:
// Set Mapper + Size + Ports
setMapper_C64();
checkMapperSize_C64();
setROMSize_C64();
setPorts_C64();
break;
case 3:
// reset
resetArduino();
break;
}
}
//******************************************
// SETUP
//******************************************
void setup_C64() {
// Request 5V
setVoltage(VOLTS_SET_5V);
// Set Address Pins to Output
// C64 uses A0-A15
//A0-A7
DDRF = 0xFF;
//A8-A15
DDRK = 0xFF;
//A16-A23 - Use A16-A19 for /ROML, /ROMH, /IO1, /IO2
DDRL = 0xFF;
// Set Control Pins to Output
// /RST(PH0) PHI2(PH1) /GAME(PH3) /EXROM(PH4) ---(PH5) R/W(PH6)
DDRH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);
// Set TIME(PJ0) to Output (UNUSED)
DDRJ |= (1 << 0);
// Set Pins (D0-D7) to Input
DDRC = 0x00;
// Setting Control Pins to HIGH
// /RST(PH0) PHI2(PH1) /GAME(PH3) /EXROM(PH4) ---(PH5) R/W(PH6)
PORTH |= (1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);
// Set /GAME(PH3) and /EXROM(PH4) to LOW
PORTH &= ~(1 << 3) & ~(1 << 4);
// Set /ROML, /ROMH, /IO1, /IO2 to HIGH
PORTL = 0xFF; // A16-A23 (A16 = /ROML, A17 = /ROMH, A18 = /IO1, A19 = /IO2)
// Set Unused Data Pins (PA0-PA7) to Output
DDRA = 0xFF;
// Set Unused Pins HIGH
PORTA = 0xFF;
PORTJ |= (1 << 0); // TIME(PJ0)
checkStatus_C64();
strcpy(romName, "C64");
mode = mode_C64;
}
//******************************************
// READ DATA
//******************************************
uint8_t readData_C64(uint16_t addr) {
PORTF = addr & 0xFF; // A0-A7
PORTK = (addr >> 8) & 0xFF; // A8-A15
NOP;
NOP;
// Set /GAME(PH3) + /EXROM(PH4) to LOW
// PORTH &= ~(1 << 3) & ~(1 << 4);
// Set R/W(PH6) to HIGH
PORTH |= (1 << 6); // R/W HIGH (READ)
NOP;
NOP;
NOP;
uint8_t ret = PINC;
// Set /GAME(PH3) + /EXROM(PH4) to HIGH
// PORTH |= (1 << 3) | (1 << 4);
// NOP; NOP;
return ret;
}
void readSegment_C64(uint32_t startaddr, uint32_t endaddr) {
for (uint32_t addr = startaddr; addr < endaddr; addr += 512) {
for (int w = 0; w < 512; w++) {
uint8_t temp = readData_C64(addr + w);
sdBuffer[w] = temp;
}
myFile.write(sdBuffer, 512);
}
}
void readSegmentSmall_C64(uint32_t startaddr, uint32_t endaddr) {
for (uint32_t addr = startaddr; addr < endaddr; addr += 256) {
for (int w = 0; w < 256; w++) {
uint8_t temp = readData_C64(addr + w);
sdBuffer[w] = temp;
}
myFile.write(sdBuffer, 256);
}
}
//******************************************
// WRITE DATA
//******************************************
void writeData_C64(uint16_t addr, uint8_t data) {
PORTF = addr & 0xFF; // A0-A7
PORTK = (addr >> 8) & 0xFF; // A8-A15
NOP;
NOP;
DDRC = 0xFF; // Set to Output
PORTC = data;
NOP;
NOP;
NOP;
// Set R/W(PH6) to LOW
PORTH &= ~(1 << 6); // R/W LOW (WRITE)
NOP;
NOP;
NOP;
// Set R/W(PH6) to HIGH
PORTH |= (1 << 6);
NOP;
NOP;
DDRC = 0x00; // Reset to Input
}
void bankSwitch_C64(uint16_t addr, uint8_t data) {
PORTF = addr & 0xFF; // A0-A7
PORTK = (addr >> 8) & 0xFF; // A8-A15
NOP;
NOP;
NOP;
DDRC = 0xFF; // Set to Output
PORTC = data;
NOP;
NOP;
NOP;
// Latch Bank Data
PHI2_DISABLE; // PHI2 LOW
if (((addr >> 8) & 0xFF) == 0xDF) // 0xDFxx
IO2_ENABLE;
else if (((addr >> 8) & 0xFF) == 0xDE) // 0xDExx
IO1_ENABLE;
PORTH &= ~(1 << 6); // R/W LOW (WRITE)
NOP;
NOP;
NOP;
PORTH |= (1 << 6); // R/W HIGH (READ)
PHI2_ENABLE; // PHI2 HIGH
IO2_DISABLE;
IO1_DISABLE;
DDRC = 0x00; // Reset to Input
}
//******************************************
// PORT STATE
//******************************************
void enablePorts_C64() {
if (c64port == 0) { // 0 = 00 = EXROM LOW/GAME LOW
EXROM_ENABLE;
GAME_ENABLE;
} else if (c64port == 1) { // 1 = 01 = EXROM LOW/GAME HIGH
EXROM_ENABLE;
GAME_DISABLE;
} else if (c64port == 2) { // 2 = 10 = EXROM HIGH/GAME LOW
EXROM_DISABLE;
GAME_ENABLE;
} else { // c64port == 3 = 11 = EXROM HIGH/GAME HIGH
EXROM_DISABLE;
GAME_DISABLE;
}
}
void disablePorts_C64() { // EXROM HIGH/GAME HIGH
EXROM_DISABLE;
GAME_DISABLE;
}
//******************************************
// READ ROM
//******************************************
// ADDRESS RANGES
// $8000-$9FFF/$A0000-$BFFF/$E000-$FFFF
// NORMAL (EXROM LOW/GAME LOW): ROML = $8000, ROMH = $A000
// ULTIMAX (EXROM HIGH/GAME LOW/): ROML = $8000, ROMH = $E000
// GAME HIGH/EXROM LOW: ROML = $8000
void readROM_C64() {
strcpy(fileName, romName);
strcat(fileName, ".bin");
// create a new folder for storing rom file
EEPROM_readAnything(0, foldern);
sprintf(folder, "C64/ROM/%d", foldern);
sd.mkdir(folder, true);
sd.chdir(folder);
display_Clear();
print_STR(saving_to_STR, 0);
print_Msg(folder);
println_Msg(F("/..."));
display_Update();
// open file on sdcard
if (!myFile.open(fileName, O_RDWR | O_CREAT))
print_FatalError(sd_error_STR);
// write new folder number back to EEPROM
foldern++;
EEPROM_writeAnything(0, foldern);
switch (c64mapper) {
case 0: // Normal (4K/8K/16K) & Ultimax (8K/16K)
// ULTIMAX CARTS
if (c64port == 2) { // 2 = 10 = EXROM HIGH/GAME LOW
GAME_ENABLE; // LOW
EXROM_DISABLE; // HIGH
if (c64size > 1) { // 16K [NO ROML FOR 8K]
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
}
ROMH_ENABLE;
readSegment_C64(0xE000, 0x10000); // +8K = 8K/16K
ROMH_DISABLE;
} else { // NORMAL CARTS
enablePorts_C64(); // MOST CARTS EXROM LOW/GAME LOW BUT VARIATIONS EXIST
ROML_ENABLE;
readSegment_C64(0x8000, 0x9000); // 4K
if (c64size > 0)
readSegment_C64(0x9000, 0xA000); // +4K = 8K
ROML_DISABLE;
if (c64size > 1) {
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
}
}
disablePorts_C64();
break;
case 1: // Action Replay (32K)
GAME_DISABLE; // HIGH
EXROM_ENABLE; // LOW
ROML_ENABLE;
for (int x = 0; x < 4; x++) {
bankSwitch_C64(0xDE00, x << 3); // Switch Bank using D3-D4
readSegment_C64(0x8000, 0xA000); // 8K *4 = 32K
}
ROML_DISABLE;
disablePorts_C64();
break;
case 2: // KCS Power Cartridge (16K)
case 11: // Westermann Learning (16K)
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
disablePorts_C64();
break;
case 3: // Final Cartridge III (64K)
GAME_DISABLE; // HIGH
EXROM_DISABLE; // HIGH
for (int x = 0; x < 4; x++) {
bankSwitch_C64(0xDFFF, 0x40 + x); // Switch Bank using $DFFF
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
}
break;
case 4: // Simons Basic (16K)
GAME_DISABLE; // HIGH
EXROM_ENABLE; // LOW
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
bankSwitch_C64(0xDE00, 0x1); // Switch Bank to ROM
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
disablePorts_C64();
break;
// Ocean Bank 1/B (Single Chip) Selection Notes (Luigi Di Fraia):
// 128 KiB cartridges (all known titles): bits 0-3 at $DE00 and /ROML (single 128 KiB chip with A16 on pin 22, rather than the /OE signal)
// 256 KiB cartridges (just "Chase H.Q. II"): bits 0-4 at $DE00 and /ROML (single 256 KiB chip)
// 512 KiB cartridges (just "Terminator 2"): bits 0-5 at $DE00 and /ROML (single 512 KiB chip)
// Ocean 256K ROM Start Data
// Single Chip:
// Chase HQ II 09 80 63 80 C3 C2 CD 38 30 4C 63 80 4C C8 80 80
// Space Gun 09 80 09 80 C3 C2 CD 38 30 78 A2 FF 9A A9 E7 85
// Two Chip:
// Robocop 2 09 80 75 80 C3 C2 CD 38 30 4C 75 80 4C FA 80 80
// Shadow of the Beast 09 80 83 81 C3 C2 CD 38 30 4C 83 81 4C 76 82 80
// Read 0x8002 to determine whether Single Chip or Two Chip
// IF 0x75 OR 0x83, THEN Two Chip ELSE Single Chip
case 5: // Ocean 128K/256K/512K
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
ROML_ENABLE;
bankSwitch_C64(0xDE00, 0); // Reset Bank 0
uint8_t checkOcean = readData_C64(0x8002);
ROML_DISABLE;
if ((c64size == 8) && ((checkOcean == 0x75) || (checkOcean == 0x83))) { // Two Chip 256K
// Robocop 2 + Shadow of the Beast
println_Msg(F("TWO CHIP"));
display_Update();
ROML_ENABLE;
for (int x = 0; x < 16; x++) {
bankSwitch_C64(0xDE00, x); // Switch Bank using D0-D3
readSegment_C64(0x8000, 0xA000); // 8K * 16 = 128K
}
ROML_DISABLE;
ROMH_ENABLE;
for (int x = 0; x < 16; x++) {
bankSwitch_C64(0xDE00, x); // Switch Bank using D0-D3
readSegment_C64(0xA000, 0xC000); // 8K * 16 = +128K = 256K
}
ROMH_DISABLE;
} else { // Single Chip 128K/256K/512K
println_Msg(F("SINGLE CHIP"));
display_Update();
ROML_ENABLE;
c64banks = C64[c64size] / 8;
for (int x = 0; x < c64banks; x++) {
bankSwitch_C64(0xDE00, x); // Switch Bank using D0-D5
readSegment_C64(0x8000, 0xA000); // 8K * Banks = 128K/256K/512K
}
ROML_DISABLE;
}
disablePorts_C64();
break;
case 6: // Expert Cartridge (8K)
GAME_DISABLE; // HIGH
EXROM_DISABLE; // HIGH
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
break;
case 7: // Fun Play, Power Play (128K)
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
ROML_ENABLE;
for (int x = 0; x < 8; x++) {
bankSwitch_C64(0xDE00, x * 8); // Switch Bank 0-8
readSegment_C64(0x8000, 0xA000); // 8K * 8 = 64K
}
ROML_DISABLE;
ROMH_ENABLE;
for (int x = 0; x < 8; x++) {
bankSwitch_C64(0xDE00, (x * 8) + 1); // Switch Bank 9-15
readSegment_C64(0x8000, 0xA000); // 8K * 8 = +64K = 128K
}
ROMH_DISABLE;
bankSwitch_C64(0xDE00, 0x86); // Reset ROM
disablePorts_C64();
break;
case 8: // Super Games (64K)
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
for (int x = 0; x < 4; x++) {
bankSwitch_C64(0xDF00, x); // Switch Bank
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
}
disablePorts_C64();
break;
case 9: // Atomic Power (32K)
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
ROML_ENABLE;
for (int x = 0; x < 4; x++) {
bankSwitch_C64(0xDE00, x << 3); // Switch Bank using D3-D4
readSegment_C64(0x8000, 0xA000); // 8K
}
ROML_DISABLE;
disablePorts_C64();
break;
case 10: // Epyx Fastload (8K)
GAME_DISABLE; // HIGH
EXROM_DISABLE; // HIGH
ROML_ENABLE;
bankSwitch_C64(0xDE00, 0); // Read IO1 - Trigger Access
readSegment_C64(0x8000, 0x9E00); // 7680 Bytes
readSegmentSmall_C64(0x9E00, 0x9F00); // +256 Bytes = 7936 Bytes
bankSwitch_C64(0xDF00, 0); // Read IO2 - Access Last 256 Bytes
readSegmentSmall_C64(0x9F00, 0xA000); // +256 Bytes = 8K
ROML_DISABLE;
break;
case 12: // Rex Utility (8K)
GAME_DISABLE; // HIGH
EXROM_ENABLE; // LOW
ROML_ENABLE;
bankSwitch_C64(0xDFC0, 0); // Enable ROM
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
disablePorts_C64();
break;
case 13: // Final Cartridge I (16K)
GAME_DISABLE; // HIGH
EXROM_DISABLE; // HIGH
bankSwitch_C64(0xDF00, 0); // Enable ROM
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
break;
case 14: // Magic Formel (64K)
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
ROMH_ENABLE;
for (int x = 0; x < 8; x++) {
bankSwitch_C64(0xDF00 + x, 0); // Switch Bank using A0-A2
readSegment_C64(0xE000, 0x10000); // 8K * 8 = 64K
}
ROMH_DISABLE;
disablePorts_C64();
break;
case 15: // C64 Game System, System 3 (512K)
GAME_ENABLE; // LOW
EXROM_DISABLE; // HIGH
ROML_ENABLE;
for (int x = 0; x < 64; x++) {
bankSwitch_C64(0xDE00 + x, 0); // Switch Bank using A0-A4
readSegment_C64(0x8000, 0xA000); // 8K * 64 = 512K
}
disablePorts_C64();
break;
case 16: // WarpSpeed (16K)
GAME_ENABLE; // LOW
EXROM_ENABLE; // LOW
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
disablePorts_C64();
break;
case 17: // Dinamic (128K) - Luigi Di Fraia has opposite PORT states - GAME_DISABLE/EXROM_ENABLE
GAME_ENABLE; // LOW
EXROM_DISABLE; // HIGH
ROML_ENABLE;
for (int x = 0; x < 16; x++) {
bankSwitch_C64(0xDE00 + x, 0); // Switch Bank using A0-A4
readSegment_C64(0x8000, 0xA000); // 8K * 16 = 128K
}
ROML_DISABLE;
disablePorts_C64();
break;
case 18: // Zaxxon, Super Zaxxon (SEGA) (20K)
GAME_DISABLE; // HIGH
EXROM_DISABLE; // HIGH
ROML_ENABLE;
readSegment_C64(0x8000, 0x9000); // 4K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 12K
ROMH_DISABLE;
// Switch Bank
readData_C64(0x9000);
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 20K
ROMH_DISABLE;
break;
case 19: // Magic Desk, Domark, HES Australia (32K/64K/128K)
GAME_ENABLE; // LOW
EXROM_DISABLE; // HIGH
ROML_ENABLE;
c64banks = C64[c64size] / 8;
for (int x = 0; x < c64banks; x++) {
bankSwitch_C64(0xDE00, x); // Switch Bank using D0-D3
readSegment_C64(0x8000, 0xA000); // 8K * Banks = 32K/64K/128K
}
ROML_DISABLE;
disablePorts_C64();
break;
case 20: // Super Snapshot 5 (64K)
GAME_DISABLE;
EXROM_DISABLE;
for (int x = 0; x < 4; x++) {
int bank = (((x & 2) << 3) | (0 << 3) | ((x & 1) << 2));
bankSwitch_C64(0xDE00, bank); // Switch Bank using D2-D4 (D3 == 0 Enable ROM)
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
}
break;
case 21: // Comal-80 (64K)
GAME_DISABLE;
EXROM_DISABLE;
for (int x = 0; x < 4; x++) {
bankSwitch_C64(0xDE00, x + 0x80); // Switch Bank
ROML_ENABLE;
readSegment_C64(0x8000, 0xA000); // 8K
ROML_DISABLE;
ROMH_ENABLE;
readSegment_C64(0xA000, 0xC000); // +8K = 16K
ROMH_DISABLE;
}
}
myFile.close();
unsigned long crcsize = C64[c64size] * 0x400;
calcCRC(fileName, crcsize, NULL, 0);
println_Msg(F(""));
// Prints string out of the common strings array either with or without newline
print_STR(press_button_STR, 1);
display_Update();
wait();
}
//******************************************
// MAPPER CODE
//******************************************
void setMapper_C64() {
#if (defined(enable_OLED) || defined(enable_LCD))
int b = 0;
int i = 0;
// Check Button Status
#if defined(enable_OLED)
buttonVal1 = (PIND & (1 << 7)); // PD7
#elif defined(enable_LCD)
boolean buttonVal1 = (PING & (1 << 2)); //PG2
#endif
if (buttonVal1 == LOW) { // Button Pressed
while (1) { // Scroll Mapper List
#if defined(enable_OLED)
buttonVal1 = (PIND & (1 << 7)); // PD7
#elif defined(enable_LCD)
boolean buttonVal1 = (PING & (1 << 2)); //PG2
#endif
if (buttonVal1 == HIGH) { // Button Released
// Correct Overshoot
if (i == 0)
i = c64mapcount - 1;
else
i--;
break;
}
display_Clear();
print_Msg(F("Mapper: "));
c64index = i * 3;
c64mapselect = pgm_read_byte(c64mapsize + c64index);
println_Msg(c64mapselect);
printMapper_C64(c64mapselect);
display_Update();
if (i == (c64mapcount - 1))
i = 0;
else
i++;
delay(250);
}
}
display_Clear();
print_Msg(F("Mapper: "));
c64index = i * 3;
c64mapselect = pgm_read_byte(c64mapsize + c64index);
println_Msg(c64mapselect);
printMapper_C64(c64mapselect);
println_Msg(F(""));
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
while (1) {
b = checkButton();
if (b == 2) { // Previous Mapper (doubleclick)
if (i == 0)
i = c64mapcount - 1;
else
i--;
display_Clear();
print_Msg(F("Mapper: "));
c64index = i * 3;
c64mapselect = pgm_read_byte(c64mapsize + c64index);
println_Msg(c64mapselect);
printMapper_C64(c64mapselect);
println_Msg(F(""));
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
}
if (b == 1) { // Next Mapper (press)
if (i == (c64mapcount - 1))
i = 0;
else
i++;
display_Clear();
print_Msg(F("Mapper: "));
c64index = i * 3;
c64mapselect = pgm_read_byte(c64mapsize + c64index);
println_Msg(c64mapselect);
printMapper_C64(c64mapselect);
println_Msg(F(""));
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
}
if (b == 3) { // Long Press - Execute (hold)
newc64mapper = c64mapselect;
break;
}
}
display.setCursor(0, 56);
print_Msg(F("MAPPER "));
print_Msg(newc64mapper);
println_Msg(F(" SELECTED"));
display_Update();
delay(1000);
#else
setmapper:
String newmap;
c64mapfound = false;
printMapper_C64(0);
Serial.print(F("Enter Mapper [0-22]: "));
while (Serial.available() == 0) {}
newmap = Serial.readStringUntil('\n');
Serial.println(newmap);
newc64mapper = newmap.toInt();
for (int i = 0; i < c64mapcount; i++) {
c64index = i * 3;
c64mapselect = pgm_read_byte(c64mapsize + c64index);
if (newc64mapper == c64mapselect)
c64mapfound = true;
}
if (c64mapfound == false) {
Serial.println(F("MAPPER NOT SUPPORTED!"));
Serial.println(F(""));
newc64mapper = 0;
goto setmapper;
}
#endif
EEPROM_writeAnything(7, newc64mapper);
c64mapper = newc64mapper;
}
void checkMapperSize_C64() {
for (int i = 0; i < c64mapcount; i++) {
c64index = i * 3;
byte mapcheck = pgm_read_byte(c64mapsize + c64index);
if (mapcheck == c64mapper) {
c64lo = pgm_read_byte(c64mapsize + c64index + 1);
c64hi = pgm_read_byte(c64mapsize + c64index + 2);
break;
}
}
}
//******************************************
// SET ROM SIZE
//******************************************
void setROMSize_C64() {
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
if (c64lo == c64hi)
newc64size = c64lo;
else {
int b = 0;
int i = c64lo;
display_Clear();
print_Msg(F("ROM Size: "));
println_Msg(C64[i]);
println_Msg(F(""));
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
while (1) {
b = checkButton();
if (b == 2) { // Previous (doubleclick)
if (i == c64lo)
i = c64hi;
else
i--;
display_Clear();
print_Msg(F("ROM Size: "));
println_Msg(C64[i]);
println_Msg(F(""));
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
}
if (b == 1) { // Next (press)
if (i == c64hi)
i = c64lo;
else
i++;
display_Clear();
print_Msg(F("ROM Size: "));
println_Msg(C64[i]);
println_Msg(F(""));
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
}
if (b == 3) { // Long Press - Execute (hold)
newc64size = i;
break;
}
}
display.setCursor(0, 56); // Display selection at bottom
}
print_Msg(F("ROM SIZE "));
print_Msg(C64[newc64size]);
println_Msg(F("K"));
display_Update();
delay(1000);
#else
if (c64lo == c64hi)
newc64size = c64lo;
else {
setrom:
String sizeROM;
for (int i = 0; i < (c64hi - c64lo + 1); i++) {
Serial.print(F("Select ROM Size: "));
Serial.print(i);
Serial.print(F(" = "));
Serial.print(C64[i + c64lo]);
Serial.println(F("K"));
}
Serial.print(F("Enter ROM Size: "));
while (Serial.available() == 0) {}
sizeROM = Serial.readStringUntil('\n');
Serial.println(sizeROM);
newc64size = sizeROM.toInt() + c64lo;
if (newc64size > c64hi) {
Serial.println(F("SIZE NOT SUPPORTED"));
Serial.println(F(""));
goto setrom;
}
}
Serial.print(F("ROM Size = "));
Serial.print(C64[newc64size]);
Serial.println(F("K"));
#endif
EEPROM_writeAnything(8, newc64size);
c64size = newc64size;
}
//******************************************
// SET PORT STATE
//******************************************
void setPorts_C64()
{
#if (defined(enable_OLED) || defined(enable_LCD))
int b = 0;
int i = 0;
display_Clear();
print_Msg(F("Port State: "));
println_Msg(i);
if (i == 0) {
println_Msg(F("EXROM LOW/GAME LOW"));
}
else if (i == 1) {
println_Msg(F("EXROM LOW/GAME HIGH"));
}
else if (i == 2) {
println_Msg(F("EXROM HIGH/GAME LOW"));
}
else if (i == 3) {
println_Msg(F("EXROM HIGH/GAME HIGH"));
}
println_Msg(F(""));
println_Msg(F("Press to Change"));
println_Msg(F("Hold to Select"));
display_Update();
while (1) {
b = checkButton();
if (b == 2) { // Previous (doubleclick)
if (i == 0)
i = 3;
else
i--;
display_Clear();
print_Msg(F("Port State: "));
println_Msg(i);
if (i == 0) {
println_Msg(F("EXROM LOW/GAME LOW"));
}
else if (i == 1) {
println_Msg(F("EXROM LOW/GAME HIGH"));
}
else if (i == 2) {
println_Msg(F("EXROM HIGH/GAME LOW"));
}
else if (i == 3) {
println_Msg(F("EXROM HIGH/GAME HIGH"));
}
println_Msg(F(""));
println_Msg(F("Press to Change"));
println_Msg(F("Hold to Select"));
display_Update();
}
if (b == 1) { // Next (press)
if (i == 3)
i = 0;
else
i++;
display_Clear();
print_Msg(F("Port State: "));
println_Msg(i);
if (i == 0) {
println_Msg(F("EXROM LOW/GAME LOW"));
}
else if (i == 1) {
println_Msg(F("EXROM LOW/GAME HIGH"));
}
else if (i == 2) {
println_Msg(F("EXROM HIGH/GAME LOW"));
}
else if (i == 3) {
println_Msg(F("EXROM HIGH/GAME HIGH"));
}
println_Msg(F(""));
println_Msg(F("Press to Change"));
println_Msg(F("Hold to Select"));
display_Update();
}
if (b == 3) { // Long Press - Execute (hold)
newc64port = i;
break;
}
}
display.setCursor(0, 56); // Display selection at bottom
print_Msg(F("PORT STATE "));
println_Msg(newc64port);
display_Update();
delay(1000);
#else
setrom:
String sizeROM;
Serial.print(F("Select Port State [0-3]:"));
Serial.println(F("0 = EXROM LOW/GAME LOW"));
Serial.println(F("1 = EXROM LOW/GAME HIGH"));
Serial.println(F("2 = EXROM HIGH/GAME LOW"));
Serial.println(F("3 = EXROM HIGH/GAME HIGH"));
Serial.print(F("Enter Port State: "));
while (Serial.available() == 0) {}
sizeROM = Serial.readStringUntil('\n');
Serial.println(sizeROM);
newc64port = sizeROM.toInt();
if (newc64port > 3) {
Serial.println(F("INVALID STATE"));
Serial.println(F(""));
goto setrom;
}
Serial.print(F("Port State = "));
Serial.println(newc64port);
#endif
EEPROM_writeAnything(12, newc64port);
c64port = newc64port;
}
//******************************************
// CHECK STATUS
//******************************************
void checkStatus_C64() {
EEPROM_readAnything(7, c64mapper);
EEPROM_readAnything(8, c64size);
EEPROM_readAnything(12, c64port);
if (c64mapper > 21) {
c64mapper = 0;
EEPROM_writeAnything(7, c64mapper);
}
if (c64size > 9) {
c64size = 0;
EEPROM_writeAnything(8, c64size);
}
if (c64port > 3) {
c64port = 0;
EEPROM_writeAnything(12, c64port);
}
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(F("C64 READER"));
println_Msg(F("CURRENT SETTINGS"));
println_Msg(F(""));
print_Msg(F("MAPPER: "));
println_Msg(c64mapper);
printMapper_C64(c64mapper);
print_Msg(F("ROM SIZE: "));
print_Msg(C64[c64size]);
println_Msg(F("K"));
print_Msg(F("PORT STATE: "));
println_Msg(c64port);
display_Update();
wait();
#else
Serial.print(F("CURRENT MAPPER: "));
Serial.println(c64mapper);
Serial.print(F("CURRENT ROM SIZE: "));
Serial.print(C64[c64size]);
Serial.println(F("K"));
Serial.print(F("CURRENT PORT STATE: "));
Setial.println(c64port);
Serial.println(F(""));
#endif
}
void printMapper_C64(byte c64maplabel) {
#if (defined(enable_OLED) || defined(enable_LCD))
switch (c64maplabel) {
case 0:
println_Msg(F("NORMAL/ULTIMAX"));
break;
case 1:
println_Msg(F("ACTION REPLAY"));
break;
case 2:
println_Msg(F("KCS POWER CARTRIDGE"));
break;
case 3:
println_Msg(F("FINAL CARTRIDGE III"));
break;
case 4:
println_Msg(F("SIMONS BASIC"));
break;
case 5:
println_Msg(F("OCEAN"));
break;
case 6:
println_Msg(F("EXPERT CARTRIDGE"));
break;
case 7:
println_Msg(F("FUN PLAY/POWER PLAY"));
break;
case 8:
println_Msg(F("SUPER GAMES"));
break;
case 9:
println_Msg(F("ATOMIC POWER"));
break;
case 10:
println_Msg(F("EPYX FASTLOAD"));
break;
case 11:
println_Msg(F("WESTERMANN LEARNING"));
break;
case 12:
println_Msg(F("REX UTILITY"));
break;
case 13:
println_Msg(F("FINAL CARTRIDGE I"));
break;
case 14:
println_Msg(F("MAGIC FORMEL"));
break;
case 15:
println_Msg(F("C64 GAME SYSTEM"));
break;
case 16:
println_Msg(F("WARPSPEED"));
break;
case 17:
println_Msg(F("DINAMIC"));
break;
case 18:
println_Msg(F("ZAXXON/SUPER ZAXXON"));
break;
case 19:
println_Msg(F("MAGIC DESK/DOMARK"));
break;
case 20:
println_Msg(F("SUPER SNAPSHOT"));
break;
case 21:
println_Msg(F("COMAL-80"));
break;
}
#else
Serial.println(F("0 = NORMAL/ULTIMAX"));
Serial.println(F("1 = ACTION REPLAY"));
Serial.println(F("2 = KCS POWER CARTRIDGE"));
Serial.println(F("3 = FINAL CARTRIDGE III"));
Serial.println(F("4 = SIMONS BASIC"));
Serial.println(F("5 = OCEAN"));
Serial.println(F("6 = EXPERT CARTRIDGE"));
Serial.println(F("7 = FUN PLAY/POWER PLAY"));
Serial.println(F("8 = SUPER GAMES"));
Serial.println(F("9 = ATOMIC POWER"));
Serial.println(F("10 = EPYX FASTLOAD"));
Serial.println(F("11 = WESTERMANN LEARNING"));
Serial.println(F("12 = REX UTILITY"));
Serial.println(F("13 = FINAL CARTRIDGE I"));
Serial.println(F("14 = MAGIC FORMEL"));
Serial.println(F("15 = C64 GAME SYSTEM"));
Serial.println(F("16 = WARPSPEED"));
Serial.println(F("17 = DINAMIC"));
Serial.println(F("18 = ZAXXON/SUPER ZAXXON"));
Serial.println(F("19 = MAGIC DESK/DOMARK/HES AUSTRALIA"));
Serial.println(F("20 = SUPER SNAPSHOT"));
Serial.println(F("21 = COMAL-80"));
#endif
}
//******************************************
// CART SELECT CODE
//******************************************
FsFile c64csvFile;
char c64game[47]; // title
char c64mm[3]; // mapper
char c64rr[3]; // romsize
char c64pp[3]; // port state (exrom+game)
char c64ll[4]; // linelength (previous line)
unsigned long c64csvpos; // CSV File Position
char c64cartCSV[] = "c64cart.txt"; // CSV List
char c64csvEND[] = "EOF"; // CSV End Marker for scrolling
bool readLine_C64(FsFile& f, char* line, size_t maxLen) {
for (size_t n = 0; n < maxLen; n++) {
int c = f.read();
if (c < 0 && n == 0) return false; // EOF
if (c < 0 || c == '\n') {
line[n] = 0;
return true;
}
line[n] = c;
}
return false; // line too long
}
bool readVals_C64(char* c64game, char* c64mm, char* c64rr, char* c64pp, char* c64ll) {
char line[54];
c64csvpos = c64csvFile.position();
if (!readLine_C64(c64csvFile, line, sizeof(line))) {
return false; // EOF or too long
}
char* comma = strtok(line, ",");
int x = 0;
while (comma != NULL) {
if (x == 0)
strcpy(c64game, comma);
else if (x == 1)
strcpy(c64mm, comma);
else if (x == 2)
strcpy(c64rr, comma);
else if (x == 3)
strcpy(c64pp, comma);
else if (x == 4)
strcpy(c64ll, comma);
comma = strtok(NULL, ",");
x += 1;
}
return true;
}
bool getCartListInfo_C64() {
bool buttonreleased = 0;
bool cartselected = 0;
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(F(" HOLD TO FAST CYCLE"));
display_Update();
#else
Serial.println(F("HOLD BUTTON TO FAST CYCLE"));
#endif
delay(2000);
#if defined(enable_OLED)
buttonVal1 = (PIND & (1 << 7)); // PD7
#elif defined(enable_LCD)
boolean buttonVal1 = (PING & (1 << 2)); //PG2
#endif
if (buttonVal1 == LOW) { // Button Held - Fast Cycle
while (1) { // Scroll Game List
while (readVals_C64(c64game, c64mm, c64rr, c64pp, c64ll)) {
if (strcmp(c64csvEND, c64game) == 0) {
c64csvFile.seek(0); // Restart
} else {
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(F("CART TITLE:"));
println_Msg(F(""));
println_Msg(c64game);
display_Update();
#else
Serial.print(F("CART TITLE:"));
Serial.println(c64game);
#endif
#if defined(enable_OLED)
buttonVal1 = (PIND & (1 << 7)); // PD7
#elif defined(enable_LCD)
boolean buttonVal1 = (PING & (1 << 2)); //PG2
#endif
if (buttonVal1 == HIGH) { // Button Released
buttonreleased = 1;
break;
}
if (buttonreleased) {
buttonreleased = 0; // Reset Flag
break;
}
}
}
#if defined(enable_OLED)
buttonVal1 = (PIND & (1 << 7)); // PD7
#elif defined(enable_LCD)
boolean buttonVal1 = (PING & (1 << 2)); //PG2
#endif
if (buttonVal1 == HIGH) // Button Released
break;
}
}
#if (defined(enable_OLED) || defined(enable_LCD))
display.setCursor(0, 56);
println_Msg(F("FAST CYCLE OFF"));
display_Update();
#else
Serial.println(F(""));
Serial.println(F("FAST CYCLE OFF"));
Serial.println(F("PRESS BUTTON TO STEP FORWARD"));
Serial.println(F("DOUBLE CLICK TO STEP BACK"));
Serial.println(F("HOLD TO SELECT"));
Serial.println(F(""));
#endif
while (readVals_C64(c64game, c64mm, c64rr, c64pp, c64ll)) {
if (strcmp(c64csvEND, c64game) == 0) {
c64csvFile.seek(0); // Restart
} else {
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(F("CART TITLE:"));
println_Msg(F(""));
println_Msg(c64game);
display.setCursor(0, 48);
#if defined(enable_OLED)
print_STR(press_to_change_STR, 1);
print_STR(right_to_select_STR, 1);
#elif defined(enable_LCD)
print_STR(rotate_to_change_STR, 1);
print_STR(press_to_select_STR, 1);
#endif
display_Update();
#else
Serial.print(F("CART TITLE:"));
Serial.println(c64game);
#endif
while (1) { // Single Step
int b = checkButton();
if (b == 1) { // Continue (press)
break;
}
if (b == 2) { // Reset to Start of List (doubleclick)
byte prevline = strtol(c64ll, NULL, 10);
c64csvpos -= prevline;
c64csvFile.seek(c64csvpos);
break;
}
if (b == 3) { // Long Press - Select Cart (hold)
newc64mapper = strtol(c64mm, NULL, 10);
newc64size = strtol(c64rr, NULL, 10);
newc64port = strtol(c64pp, NULL, 10);
EEPROM_writeAnything(7, newc64mapper);
EEPROM_writeAnything(8, newc64size);
EEPROM_writeAnything(12, newc64port);
cartselected = 1; // SELECTION MADE
#if (defined(enable_OLED) || defined(enable_LCD))
println_Msg(F("SELECTION MADE"));
display_Update();
#else
Serial.println(F("SELECTION MADE"));
#endif
break;
}
}
if (cartselected) {
cartselected = 0; // Reset Flag
return true;
}
}
}
#if (defined(enable_OLED) || defined(enable_LCD))
println_Msg(F(""));
println_Msg(F("END OF FILE"));
display_Update();
#else
Serial.println(F("END OF FILE"));
#endif
return false;
}
void checkCSV_C64() {
if (getCartListInfo_C64()) {
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(F("CART SELECTED"));
println_Msg(F(""));
println_Msg(c64game);
display_Update();
// Display Settings
display.setCursor(0, 56);
print_Msg(F("CODE: M"));
print_Msg(newc64mapper);
print_Msg(F("/R"));
print_Msg(newc64size);
print_Msg(F("/P"));
print_Msg(newc64port);
display_Update();
#else
Serial.println(F(""));
Serial.println(F("CART SELECTED"));
Serial.println(c64game);
// Display Settings
Serial.print(F("CODE: M"));
Serial.print(newc64mapper);
Serial.print(F("/R"));
Serial.print(newc64size);
Serial.print(F("/P"));
Serial.print(newc64port);
Serial.println(F(""));
#endif
} else {
#if (defined(enable_OLED) || defined(enable_LCD))
display.setCursor(0, 56);
println_Msg(F("NO SELECTION"));
display_Update();
#else
Serial.println(F("NO SELECTION"));
#endif
}
}
void setCart_C64() {
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(c64cartCSV);
display_Update();
#endif
sd.chdir();
sprintf(folder, "C64/CSV");
sd.chdir(folder); // Switch Folder
c64csvFile = sd.open(c64cartCSV, O_READ);
if (!c64csvFile) {
#if (defined(enable_OLED) || defined(enable_LCD))
display_Clear();
println_Msg(F("CSV FILE NOT FOUND!"));
display_Update();
#else
Serial.println(F("CSV FILE NOT FOUND!"));
#endif
while (1) {
if (checkButton() != 0)
setup_C64();
}
}
checkCSV_C64();
c64csvFile.close();
}
#endif
Reference in New Issue Copy Permalink