mirror of https://github.com/sanni/cartreader.git
876 lines
22 KiB
C++
876 lines
22 KiB
C++
//******************************************
|
|
// ATARI 7800 MODULE
|
|
//******************************************
|
|
#ifdef ENABLE_7800
|
|
// Atari 7800
|
|
// Cartridge Pinout
|
|
// 32P 2.54mm pitch (USE 36P CONNECTOR)
|
|
//
|
|
// RIGHT
|
|
// +-------+
|
|
// R/W -| 1 32 |- CLK
|
|
// HALT -| 2 31 |- IRQ
|
|
// |-------|
|
|
// D3 -| 3 30 |- GND
|
|
// L D4 -| 4 29 |- D2 B
|
|
// A D5 -| 5 28 |- D1 O
|
|
// B D6 -| 6 27 |- D0 T
|
|
// E D7 -| 7 26 |- A0 T
|
|
// L A12 -| 8 25 |- A1 O
|
|
// A10 -| 9 24 |- A2 M
|
|
// S A11 -| 10 23 |- A3
|
|
// I A9 -| 11 22 |- A4 S
|
|
// D A8 -| 12 21 |- A5 I
|
|
// E +5V -| 13 20 |- A6 D
|
|
// GND -| 14 19 |- A7 E
|
|
// |-------|
|
|
// A13 -| 15 18 |- AUD
|
|
// A14 -| 16 17 |- A15
|
|
// +-------+
|
|
// LEFT
|
|
//
|
|
// LABEL SIDE
|
|
//
|
|
// A14 A13 GND +5V A8 A9 A11 A10 A12 D7 D6 D5 D4 D3 HLT R/W
|
|
// +--------------------------------------------------------------------+
|
|
// | 16 15 | 14 13 12 11 10 9 8 7 6 5 4 3 | 2 1 |
|
|
// LEFT | | | | RIGHT
|
|
// | 17 18 | 19 20 21 22 23 24 25 26 27 28 29 30 | 31 32 |
|
|
// +--------------------------------------------------------------------+
|
|
// A15 AUD A7 A6 A5 A4 A3 A2 A1 A0 D0 D1 D2 GND IRQ CLK
|
|
//
|
|
// BOTTOM SIDE
|
|
|
|
// CONTROL PINS:
|
|
// CLK(PH1) - SNES CPUCLK
|
|
// R/W(PH6) - SNES /RD
|
|
// HALT(PH0) - SNES /RESET
|
|
|
|
//******************************************
|
|
// Supported Mappers
|
|
//******************************************
|
|
// Supported Mapper Array
|
|
// Format = {mapper,romsizelo,romsizehi}
|
|
static const byte PROGMEM a7800mapsize[] = {
|
|
0, 0, 2, // Standard 16K/32K/48K [7816/7832/7848]
|
|
1, 4, 4, // SuperGame 128K [78SG]
|
|
2, 5, 5, // SuperGame - Alien Brigade/Crossbow 144K [78S9]
|
|
3, 3, 3, // F-18 Hornet 64K [78AB]
|
|
4, 4, 4, // Double Dragon/Rampage 128K [78AC]
|
|
5, 3, 3, // Realsports Baseball/Tank Command/Tower Toppler/Waterski 64K [78S4]
|
|
6, 3, 3, // Karateka (PAL) 64K [78S4 Variant]
|
|
7, 1, 4, // Bankset switching
|
|
};
|
|
|
|
byte a7800mapcount = 8; // (sizeof(a7800mapsize) / sizeof(a7800mapsize[0])) / 3;
|
|
byte a7800mapselect;
|
|
int a7800index;
|
|
|
|
byte a7800[] = { 16, 32, 48, 64, 128, 144 };
|
|
byte a7800lo = 0; // Lowest Entry
|
|
byte a7800hi = 5; // Highest Entry
|
|
byte a7800mapper = 0;
|
|
byte a7800size;
|
|
|
|
// EEPROM MAPPING
|
|
// 07 MAPPER
|
|
// 08 ROM SIZE
|
|
|
|
//******************************************
|
|
// Menu
|
|
//******************************************
|
|
// Base Menu
|
|
static const char* const menuOptions7800[] PROGMEM = { FSTRING_SELECT_CART, FSTRING_READ_ROM, FSTRING_SET_SIZE, FSTRING_RESET };
|
|
|
|
void setup_7800() {
|
|
// Request 5V
|
|
setVoltage(VOLTS_SET_5V);
|
|
|
|
// Set Address Pins to Output
|
|
// Atari 7800 uses A0-A15 [A16-A23 UNUSED]
|
|
//A0-A7
|
|
DDRF = 0xFF;
|
|
//A8-A15
|
|
DDRK = 0xFF;
|
|
//A16-A23
|
|
DDRL = 0xFF;
|
|
|
|
// Set Control Pins to Output
|
|
// HALT(PH0) ---(PH3) ---(PH4) ---(PH5) R/W(PH6)
|
|
DDRH |= (1 << 0) | (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
|
|
// HALT(PH0) ---(PH3) ---(PH4) ---(PH5) R/W(PH6)
|
|
PORTH |= (1 << 0) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);
|
|
|
|
// Set Unused Data Pins (PA0-PA7) to Output
|
|
DDRA = 0xFF;
|
|
|
|
// Set Unused Pins HIGH
|
|
PORTA = 0xFF;
|
|
PORTL = 0xFF; // A16-A23
|
|
PORTJ |= (1 << 0); // TIME(PJ0)
|
|
|
|
#ifdef ENABLE_CLOCKGEN
|
|
// Adafruit Clock Generator
|
|
|
|
initializeClockOffset();
|
|
|
|
if (!i2c_found) {
|
|
display_Clear();
|
|
print_FatalError(F("Clock Generator not found"));
|
|
}
|
|
|
|
// Set Eeprom clock to 1Mhz
|
|
clockgen.set_freq(200000000ULL, SI5351_CLK1);
|
|
|
|
// Start outputting Eeprom clock
|
|
clockgen.output_enable(SI5351_CLK1, 1); // Eeprom clock
|
|
|
|
// Wait for clock generator
|
|
clockgen.update_status();
|
|
|
|
#else
|
|
// Set CLK(PH1) to Output
|
|
DDRH |= (1 << 1);
|
|
// Output a high signal CLK(PH1)
|
|
PORTH |= (1 << 1);
|
|
#endif
|
|
|
|
checkStatus_7800();
|
|
strcpy(romName, "ATARI");
|
|
|
|
mode = CORE_7800;
|
|
}
|
|
|
|
void a7800Menu() {
|
|
convertPgm(menuOptions7800, 4);
|
|
uint8_t mainMenu = question_box(F("ATARI 7800 MENU"), menuOptions, 4, 0);
|
|
|
|
switch (mainMenu) {
|
|
case 0:
|
|
// Select Cart
|
|
setCart_7800();
|
|
setup_7800();
|
|
break;
|
|
|
|
case 1:
|
|
// Read ROM
|
|
sd.chdir("/");
|
|
readROM_7800();
|
|
sd.chdir("/");
|
|
break;
|
|
|
|
case 2:
|
|
// Set Mapper + Size
|
|
setMapper_7800();
|
|
checkMapperSize_7800();
|
|
setROMSize_7800();
|
|
break;
|
|
|
|
case 3:
|
|
// reset
|
|
resetArduino();
|
|
break;
|
|
}
|
|
}
|
|
|
|
//******************************************
|
|
// READ CODE
|
|
//******************************************
|
|
|
|
uint8_t readData_7800(uint32_t addr) // Add Input Pullup
|
|
{
|
|
PORTF = addr & 0xFF; // A0-A7
|
|
PORTK = (addr >> 8) & 0xFF; // A8-A15
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
// DDRC = 0x00; // Set to Input
|
|
PORTC = 0xFF; // Input Pullup
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
uint8_t ret = PINC;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
return ret;
|
|
}
|
|
|
|
void readSegment_7800(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_7800(addr + w);
|
|
sdBuffer[w] = temp;
|
|
}
|
|
myFile.write(sdBuffer, 512);
|
|
}
|
|
}
|
|
|
|
void writeData_7800(uint32_t addr, uint8_t data) {
|
|
PORTF = addr & 0xFF; // A0-A7
|
|
PORTK = (addr >> 8) & 0xFF; // A8-A15
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
DDRC = 0xFF; // Set to Output
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
PORTC = data;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
PORTH &= ~(1 << 6); // R/W(PH6) LOW = WRITE
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
PORTH |= (1 << 6); // R/W(PH6) HIGH = READ
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
DDRC = 0x00; // Reset to Input
|
|
}
|
|
|
|
// Activision Bankswitch - Double Dragon/Rampage 128K
|
|
void bankSwitch_7800(uint32_t addr) {
|
|
PORTF = addr & 0xFF; // A0-A7
|
|
PORTK = (addr >> 8) & 0xFF; // A8-A15
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
PORTH &= ~(1 << 6); // R/W(PH6) LOW = WRITE
|
|
for (int y = 0; y < 8; y++) { // Pulse Clock to latch data into PAL16 Chip
|
|
PORTH &= ~(1 << 1); // CLK(PH1) LOW
|
|
NOP;
|
|
PORTH |= (1 << 1); // CLK(PH1) HIGH
|
|
NOP;
|
|
}
|
|
|
|
PORTH |= (1 << 6); // R/W(PH6) HIGH = READ
|
|
|
|
DDRC = 0x00; // Reset to Input
|
|
}
|
|
|
|
//******************************************
|
|
// READ ROM
|
|
//******************************************
|
|
|
|
void readROM_7800() {
|
|
strcpy(fileName, romName);
|
|
strcat(fileName, ".a78");
|
|
|
|
// create a new folder for storing rom file
|
|
EEPROM_readAnything(0, foldern);
|
|
sprintf(folder, "7800/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 (a7800mapper) {
|
|
case 0: // Standard 16K/32K/48K [7816/7832/7848]
|
|
readStandard_7800();
|
|
break;
|
|
|
|
case 1: // SuperGame 128K [78SG]
|
|
readSupergame_7800();
|
|
break;
|
|
|
|
case 2: // SuperGame - Alien Brigade/Crossbow 144K [78S9]
|
|
readSegment_7800(0x4000, 0x8000); // 16K
|
|
for (int x = 0; x < 8; x++) {
|
|
writeData_7800(0x8000, x); // Banks 0-7
|
|
readSegment_7800(0x8000, 0xC000); // 16K * 8 = +128K = 144K
|
|
}
|
|
break;
|
|
|
|
case 3: // F-18 Hornet 64K [78AB]
|
|
for (int x = 1; x >= 0; x--) { // Bank Order Inverted = Bank 1 then Bank 0
|
|
writeData_7800(0x8000, x); // Banks 0-1
|
|
readSegment_7800(0x4000, 0x8000); // 16K * 2 = 32K
|
|
}
|
|
readSegment_7800(0x8000, 0x10000); // +32K = 64K
|
|
break;
|
|
|
|
case 4: // Double Dragon/Rampage 128K [78AC]
|
|
/*
|
|
// THIS CODE OUTPUTS ROMS THAT SHOULD MATCH THE CURRENT NO-INTRO DATABASE
|
|
// BUT THE ROMS INCLUDED IN THE NO-INTRO DATABASE WERE DONE INCORRECTLY
|
|
// THE UPPER AND LOWER HALVES OF EACH 16K BANK ARE IN THE WRONG ORDER
|
|
// THE OLD BANKSWITCH INFORMATION IS INCORRECT/INCOMPLETE
|
|
// Double Dragon (NTSC) = CRC32 AA265865 BAD
|
|
// Double Dragon (PAL) = CRC32 F29ABDB2 BAD
|
|
// Rampage (NTSC) = CRC32 39A316AA BAD
|
|
for (int x = 0; x < 8; x++) {
|
|
bankSwitch_7800(0xFF80 + x); // Activision Bankswitch
|
|
readSegment_7800(0xA000, 0xE000); // 16K * 8 = 128K
|
|
}
|
|
*/
|
|
// THIS CODE OUTPUTS PROPER ROMS THAT SHOULD MATCH MAME
|
|
// THE UPPER AND LOWER HALVES OF EACH 16K BANK ARE IN THE CORRECT ORDER
|
|
// Double Dragon (NTSC) = CRC32 F20773D5
|
|
// Double Dragon (PAL) = CRC32 4D634BF5
|
|
// Rampage (NTSC) = CRC32 D2876EE2
|
|
for (int x = 0; x < 8; x++) {
|
|
bankSwitch_7800(0xFF80 + x); // Activision Bankswitch
|
|
readSegment_7800(0xC000, 0xE000); // 8K * 8 = 64K
|
|
readSegment_7800(0xA000, 0xC000); // 8K * 8 = +64K = 128K
|
|
}
|
|
break;
|
|
|
|
case 5: // Realsports Baseball/Tank Command/Tower Toppler/Waterski 64K [78S4]
|
|
for (int x = 0; x < 4; x++) {
|
|
writeData_7800(0x8000, x);
|
|
readSegment_7800(0x8000, 0xC000); // 16K * 4 = 64K
|
|
}
|
|
break;
|
|
|
|
case 6: // Karateka (PAL) 64K [78S4 Variant]
|
|
for (int x = 4; x < 8; x++) {
|
|
writeData_7800(0x8000, x);
|
|
readSegment_7800(0x8000, 0xC000); // 16K * 4 = 64K
|
|
}
|
|
break;
|
|
|
|
case 7: // Bankset switching
|
|
if (a7800size > 3) {
|
|
setHalt_7800(1);
|
|
readSupergame_7800();
|
|
setHalt_7800(0);
|
|
readSupergame_7800();
|
|
} else {
|
|
setHalt_7800(1);
|
|
readStandard_7800();
|
|
setHalt_7800(0);
|
|
readStandard_7800();
|
|
}
|
|
break;
|
|
}
|
|
myFile.close();
|
|
|
|
unsigned long crcsize = a7800[a7800size] * 0x400;
|
|
calcCRC(fileName, crcsize, NULL, 0);
|
|
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
// Prints string out of the common strings array either with or without newline
|
|
print_STR(press_button_STR, 1);
|
|
display_Update();
|
|
wait();
|
|
}
|
|
|
|
void readStandard_7800() {
|
|
if (a7800size > 1)
|
|
readSegment_7800(0x4000, 0x8000); // +16K = 48K
|
|
if (a7800size > 0)
|
|
readSegment_7800(0x8000, 0xC000); // +16K = 32K
|
|
// Base 16K
|
|
readSegment_7800(0xC000, 0x10000); // 16K
|
|
}
|
|
|
|
void readSupergame_7800() {
|
|
for (int x = 0; x < 7; x++) {
|
|
writeData_7800(0x8000, x); // Banks 0-6
|
|
readSegment_7800(0x8000, 0xC000); // 16K * 7 = 112K
|
|
}
|
|
readSegment_7800(0xC000, 0x10000); // Bank 7 +16 = 128K
|
|
}
|
|
|
|
void setHalt_7800(byte on) {
|
|
if(on == 1) {
|
|
PORTH |= (1 << 0); // HALT(PH0) HIGH = SALLY
|
|
} else {
|
|
PORTH &= ~(1 << 0); // HALT(PH0) LOW = MARIA
|
|
}
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
}
|
|
|
|
//******************************************
|
|
// ROM SIZE
|
|
//******************************************
|
|
|
|
void checkMapperSize_7800() {
|
|
for (int i = 0; i < a7800mapcount; i++) {
|
|
a7800index = i * 3;
|
|
byte mapcheck = pgm_read_byte(a7800mapsize + a7800index);
|
|
if (mapcheck == a7800mapper) {
|
|
a7800lo = pgm_read_byte(a7800mapsize + a7800index + 1);
|
|
a7800hi = pgm_read_byte(a7800mapsize + a7800index + 2);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
void println_Mapper7800(byte mapper) {
|
|
if (mapper == 0)
|
|
println_Msg(F("STANDARD"));
|
|
else if (mapper == 1)
|
|
println_Msg(F("SUPERGAME 128K[78SG]"));
|
|
else if (mapper == 2)
|
|
println_Msg(F("SUPERGAME 144K[78S9]"));
|
|
else if (mapper == 3)
|
|
println_Msg(F("F-18 HORNET [78AB]"));
|
|
else if (mapper == 4)
|
|
println_Msg(F("DBLDRGN/RMPG [78AC]"));
|
|
else if (mapper == 5)
|
|
println_Msg(F("BASEBALL/ETC [78S4]"));
|
|
else if (mapper == 6)
|
|
println_Msg(F("KARATEKA(PAL) [78S4]"));
|
|
else if (mapper == 7)
|
|
println_Msg(F("BANKSET"));
|
|
}
|
|
#endif
|
|
|
|
void setROMSize_7800() {
|
|
byte new7800size;
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
display_Clear();
|
|
if (a7800lo == a7800hi)
|
|
new7800size = a7800lo;
|
|
else {
|
|
uint8_t b = 0;
|
|
int i = a7800lo;
|
|
|
|
display_Clear();
|
|
print_Msg(F("ROM Size: "));
|
|
println_Msg(a7800[i]);
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
#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 == a7800lo)
|
|
i = a7800hi;
|
|
else
|
|
i--;
|
|
|
|
display_Clear();
|
|
print_Msg(F("ROM Size: "));
|
|
println_Msg(a7800[i]);
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
#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 == a7800hi)
|
|
i = a7800lo;
|
|
else
|
|
i++;
|
|
|
|
display_Clear();
|
|
print_Msg(F("ROM Size: "));
|
|
println_Msg(a7800[i]);
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
#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)
|
|
new7800size = i;
|
|
break;
|
|
}
|
|
}
|
|
display.setCursor(0, 56); // Display selection at bottom
|
|
}
|
|
print_Msg(F("ROM SIZE "));
|
|
print_Msg(a7800[new7800size]);
|
|
println_Msg(F("K"));
|
|
display_Update();
|
|
delay(1000);
|
|
#else
|
|
if (a7800lo == a7800hi)
|
|
new7800size = a7800lo;
|
|
else {
|
|
setrom:
|
|
String sizeROM;
|
|
for (int i = 0; i < (a7800hi - a7800lo + 1); i++) {
|
|
Serial.print(F("Select ROM Size: "));
|
|
Serial.print(i);
|
|
Serial.print(F(" = "));
|
|
Serial.print(a7800[i + a7800lo]);
|
|
Serial.println(F("K"));
|
|
}
|
|
Serial.print(F("Enter ROM Size: "));
|
|
while (Serial.available() == 0) {}
|
|
sizeROM = Serial.readStringUntil('\n');
|
|
Serial.println(sizeROM);
|
|
new7800size = sizeROM.toInt() + a7800lo;
|
|
if (new7800size > a7800hi) {
|
|
Serial.println(F("SIZE NOT SUPPORTED"));
|
|
Serial.println(FS(FSTRING_EMPTY));
|
|
goto setrom;
|
|
}
|
|
}
|
|
Serial.print(F("ROM Size = "));
|
|
Serial.print(a7800[new7800size]);
|
|
Serial.println(F("K"));
|
|
#endif
|
|
EEPROM_writeAnything(8, new7800size);
|
|
a7800size = new7800size;
|
|
}
|
|
|
|
void checkStatus_7800() {
|
|
EEPROM_readAnything(7, a7800mapper);
|
|
EEPROM_readAnything(8, a7800size);
|
|
if (a7800mapper > 6) {
|
|
a7800mapper = 0; // default
|
|
EEPROM_writeAnything(7, a7800mapper);
|
|
}
|
|
if (a7800size > 5) {
|
|
a7800size = 0; // default 16KB
|
|
EEPROM_writeAnything(8, a7800size);
|
|
}
|
|
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
display_Clear();
|
|
println_Msg(F("ATARI 7800 READER"));
|
|
println_Msg(FS(FSTRING_CURRENT_SETTINGS));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
print_Msg(F("MAPPER: "));
|
|
println_Msg(a7800mapper);
|
|
println_Mapper7800(a7800mapper);
|
|
print_Msg(F("ROM SIZE: "));
|
|
print_Msg(a7800[a7800size]);
|
|
println_Msg(F("K"));
|
|
display_Update();
|
|
wait();
|
|
#else
|
|
Serial.print(F("MAPPER: "));
|
|
Serial.println(a7800mapper);
|
|
if (a7800mapper == 0)
|
|
Serial.println(F("Standard [7816/7832/7848]"));
|
|
else if (a7800mapper == 1)
|
|
Serial.println(F("SuperGame 128K [78SG]"));
|
|
else if (a7800mapper == 2)
|
|
Serial.println(F("SuperGame 144K [78S9] - Alien Brigade/Crossbow"));
|
|
else if (a7800mapper == 3)
|
|
Serial.println(F("F-18 Hornet 64K [78AB]"));
|
|
else if (a7800mapper == 4)
|
|
Serial.println(F("Double Dragon/Rampage [78AC]"));
|
|
else if (a7800mapper == 5)
|
|
Serial.println(F("Realsports Baseball/Tank Command/Tower Toppler/Waterski [78S4]"));
|
|
else if (a7800mapper == 6)
|
|
Serial.println(F("Karateka (PAL) [78S4 Variant]"));
|
|
else if (a7800mapper == 7)
|
|
Serial.println(F("Bankset"));
|
|
Serial.print(F("ROM SIZE: "));
|
|
Serial.print(A7800[a7800size]);
|
|
Serial.println(F("K"));
|
|
Serial.println(FS(FSTRING_EMPTY));
|
|
#endif
|
|
}
|
|
|
|
//******************************************
|
|
// SET MAPPER
|
|
//******************************************
|
|
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
void displayMapperSelect_7800(int index, boolean printInstructions) {
|
|
display_Clear();
|
|
print_Msg(F("Mapper: "));
|
|
a7800index = index * 3;
|
|
a7800mapselect = pgm_read_byte(a7800mapsize + a7800index);
|
|
println_Msg(a7800mapselect);
|
|
println_Mapper7800(a7800mapselect);
|
|
|
|
if(printInstructions) {
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
#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();
|
|
}
|
|
#endif
|
|
|
|
void setMapper_7800() {
|
|
byte new7800mapper = 0;
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
uint8_t 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 = a7800mapcount - 1;
|
|
else
|
|
i--;
|
|
break;
|
|
}
|
|
displayMapperSelect_7800(i, false);
|
|
if (i == (a7800mapcount - 1))
|
|
i = 0;
|
|
else
|
|
i++;
|
|
delay(250);
|
|
}
|
|
}
|
|
|
|
displayMapperSelect_7800(i, true);
|
|
|
|
while (1) {
|
|
b = checkButton();
|
|
if (b == 2) { // Previous Mapper (doubleclick)
|
|
if (i == 0)
|
|
i = a7800mapcount - 1;
|
|
else
|
|
i--;
|
|
displayMapperSelect_7800(i, true);
|
|
}
|
|
if (b == 1) { // Next Mapper (press)
|
|
if (i == (a7800mapcount - 1))
|
|
i = 0;
|
|
else
|
|
i++;
|
|
displayMapperSelect_7800(i, true);
|
|
}
|
|
if (b == 3) { // Long Press - Execute (hold)
|
|
new7800mapper = a7800mapselect;
|
|
break;
|
|
}
|
|
}
|
|
display.setCursor(0, 56);
|
|
print_Msg(F("MAPPER "));
|
|
print_Msg(new7800mapper);
|
|
println_Msg(F(" SELECTED"));
|
|
display_Update();
|
|
delay(1000);
|
|
#else
|
|
setmapper:
|
|
String newmap;
|
|
Serial.println(F("SUPPORTED MAPPERS:"));
|
|
Serial.println(F("0 = Standard [7816/7832/7848]"));
|
|
Serial.println(F("1 = SuperGame 128K [78SG]"));
|
|
Serial.println(F("2 = SuperGame 144K [78S9] - Alien Brigade/Crossbow"));
|
|
Serial.println(F("3 = F-18 Hornet 64K [78AB]"));
|
|
Serial.println(F("4 = Double Dragon/Rampage [78AC]"));
|
|
Serial.println(F("5 = Realsports Baseball/Tank Command/Tower Toppler/Waterski [78S4]"));
|
|
Serial.println(F("6 = Karateka (PAL) [78S4 Variant]"));
|
|
Serial.println(F("7 = Bankset"));
|
|
Serial.print(F("Enter Mapper [0-7]: "));
|
|
while (Serial.available() == 0) {}
|
|
newmap = Serial.readStringUntil('\n');
|
|
Serial.println(newmap);
|
|
a7800index = newmap.toInt() * 3;
|
|
new7800mapper = pgm_read_byte(a7800mapsize + a7800index);
|
|
#endif
|
|
EEPROM_writeAnything(7, new7800mapper);
|
|
a7800mapper = new7800mapper;
|
|
|
|
a7800size = pgm_read_byte(a7800mapsize + a7800index + 1);
|
|
EEPROM_writeAnything(8, a7800size);
|
|
}
|
|
|
|
//******************************************
|
|
// CART SELECT CODE
|
|
//******************************************
|
|
void checkSize_7800() {
|
|
EEPROM_readAnything(7, a7800mapper);
|
|
for (int i = 0; i < a7800mapcount; i++) {
|
|
a7800index = i * 3;
|
|
if (a7800mapper == pgm_read_byte(a7800mapsize + a7800index)) {
|
|
a7800size = pgm_read_byte(a7800mapsize + a7800index + 1);
|
|
EEPROM_writeAnything(8, a7800size);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void setCart_7800() {
|
|
//go to root
|
|
sd.chdir();
|
|
|
|
char gamename[100];
|
|
byte gameMapper;
|
|
byte gameSize;
|
|
|
|
// Select starting letter
|
|
byte myLetter = starting_letter();
|
|
|
|
// Open database
|
|
if (myFile.open("7800.txt", O_READ)) {
|
|
seek_first_letter_in_database(myFile, myLetter);
|
|
|
|
// Display database
|
|
while (myFile.available()) {
|
|
display_Clear();
|
|
|
|
get_line(gamename, &myFile, sizeof(gamename));
|
|
|
|
// Read mapper
|
|
gameMapper = myFile.read() - 48;
|
|
|
|
// Skip over semicolon
|
|
myFile.seekCur(1);
|
|
|
|
// Read rom size
|
|
gameSize = myFile.read() - 48;
|
|
|
|
// Skip rest of line
|
|
myFile.seekCur(2);
|
|
|
|
skip_line(&myFile);
|
|
|
|
println_Msg(F("Select your cartridge"));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(gamename);
|
|
|
|
#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);
|
|
#elif defined(SERIAL_MONITOR)
|
|
println_Msg(F("U/D to Change"));
|
|
println_Msg(F("Space to Select"));
|
|
#endif
|
|
display_Update();
|
|
|
|
uint8_t b = 0;
|
|
while (1) {
|
|
// Check button input
|
|
b = checkButton();
|
|
|
|
// Next
|
|
if (b == 1) {
|
|
break;
|
|
}
|
|
|
|
// Previous
|
|
else if (b == 2) {
|
|
rewind_line(myFile, 6);
|
|
break;
|
|
}
|
|
|
|
// Selection
|
|
else if (b == 3) {
|
|
EEPROM_writeAnything(7, gameMapper);
|
|
EEPROM_writeAnything(8, gameSize);
|
|
myFile.close();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
print_FatalError(F("Database file not found"));
|
|
}
|
|
}
|
|
#endif |