En un juego de cartucho de Super Nintendo como este.
Tiene una pila para mantener las partidas del juego guardadas, si la pila se agota, perderás la información en la SRAM, cosa que no interesa. La SRAM en este caso stá justo debajo dela pila que pone MOSEL, al lado en blanco pone U4 64K SRAM.
Mi idea es con Arduino UNO obtener los datos cargados de la SRAM del cartucho del juego, luego pasarlo a una EEPROM que yo ponga.
Pulso Reset a la SNES, como no tiene pila porque se lo he quitado, los datos está en una EEPROM que incrustaré en ese cartucho, la SRAM está borrada, automáticamente Arduino UNO pasa los datos de la EEPROM a la SRAM.
Ahora en el menú del juego, le damos cargar y ya tenemos la partida recuperada.
Quiero saber que tipo de memorias o EEPROM es el adecuado para hacer este tipo de cosas, lo de leer datos de la SRAM y pasarlo a una EEPROM, luego al revés.
Busca información del BUS que estas mostrando o sea de los pines de la tarjeta como para poder direccionar lo que quieres hacer.
Empecemos por ahi, y luego veremos como seguir
Yo como lo veo buscaría un conector para que puedas enchufar ese cartucho a tu INTERFAZ y ese conector luego lo conectarás a Arduino. Sabiendo que es y que hace cada pin, el mapa de memoria y bla bla bla, podrémos hacer algo.
Es un equipo del que se ha hablado mucho asi que no te debe costar mucho encontrarlo.
No busques en castellano.
Muchas gracias por el enlace. Hay personas que me han preguntado estas preguntas...
...y da quepensar.
¿Qué pasaría con las colisiones en la SRAM cuando escribe el juego y quiere leer el uC? ¿Cúando puede leer el uC libre de problemas? ¿Cómo garantizas una copia válida de la SRAM en EEPROM? ¿Qué pasa en juegos como Treasure Hunter G donde la SRAM se usa como RAM para guardar variables del motor del juego que se actualizan constantemente?
Todas estas preguntas ya nos las hemos hecho antes muchos y son auténticos quebraderos de cabeza, algunos irresolubles, por lo que se usan soluciones alternativas.
Lo sabe porque el decodificador lo unico que hace es direccionar una u otra memoria de acuerdo al area de memoria que se este usando.
Ejemplo. supongamos una memoria que va de 0x00000 a 0x0FFFF y otra va de 0x10000 a 0x1FFFF o sea de 64k, bien, tienes un deco que cuando reciba una instrucción para leer en 0x02000 ira a la ROM1 y cuando reciba 0x12345 ira a la ROM2.
Todo esto es hardwriten o sea, hay un hard que responde a lo que pides. No se lo que es SNES?
LA ROM no cambia nada. Es una memoria de solo lectura Read Only Memory que esta para decirte que en tal posición tiene tal byte. Nada mas.
Entonces si en el bus se direcciona algo, ella pondrá luego del tiempo de respuesta en D0..D7 lo que tiene almacenado.
Jajajaja pero que quiers hacer Metaconta? Estas reviviendo un dinosaurio de la sangre de un mosquito atrapado en una gota de miel?
Yo soy formado en la electrónica que estas describiendo de modo que te entiendo perfectamente solo que no se para que revivir estos "muertos" mas alla de que sean históricos.
Esas memorias se borraban con Luz Ultravioleta y se programaban con unos programadores determinados.
Claro que fueron reemplazados por memorias Flash pin a pin compatibles porque existió un período de transición.
Asi que si las buscas las encuentras.
Si mal recuerdo las puedes borrar cuantas veces quieras usando Luz Ultravioleta de intensidad y tiempo determinados.
Es más , han hecho consolas compatibles como la RetroN 5 que pudes ver aquí. Hecho en EE.UU. http://hyperkin.com/Retron5/
Es más, en Japón hicieron esta y no se sabe si lo venderán también por todo el mundo, esa duda también estaba en la RetroN 5 y salió a la luz por todas pares, lo que este funciona hasta con tarjetas SD las ROM.
Porque en el mercado hay interés, sobre todo modificaciones de consolas, y las originales las entán vendiendo a precios de oro.
Informándome hasta las últimas, hay que aprender bien como es una ROM por dentro, que es el programa que hay que grabar en las eproms. Hay juegos o ROM que tiene que activar si hay SRAM sin pila, con pila para mantener la información y más detalles.
Código en C# que todavía no he probado para saber los datos de la ROM.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
namespace SnesKit
{
public enum BankTypeEnum { Lo, Hi };
public class RomDump
{
// Indica si la ROM tiene el smc header o no
bool SmcHeader;
// Indica la localización del header de SNES
int HeaderLocation;
// Array con los datos de la ROM
public byte[] Data;
// Los diferentes datos que obtenemos de la ROM
public string Name;
public byte Layout;
public byte CartridgeType;
public byte RomSize;
public byte RamSize;
public byte CountryCode;
public byte LicenseCode;
public byte VersionNumber;
ushort Checksum;
ushort ChecksumCompliment;
public BankTypeEnum BankType;
// Esta funcion permite el analisis de ROMS de SNES con extensiones SMC y SFC
public RomDump(byte[] rom)
{
this.Data = rom;
// Comprobamos si existe el header smc
if (this.Data.Length % 1024 == 512)
SmcHeader = true;
else if (this.Data.Length % 1024 == 0)
SmcHeader = false;
else
throw new Exception("Archivo de rom invalida.");
this.HeaderLocation = 0x81C0;
if (HeaderIsAt(0x07FC0)) // La Rom es LoROM
{
this.BankType = BankTypeEnum.Lo;
}
else if (HeaderIsAt(0x0FFC0))
{
this.BankType = BankTypeEnum.Hi;
}
// Leemos el Header
ReadHeader();
}
// Función para comprobar si el header esta en la dirección correcta
private bool HeaderIsAt(ushort addr)
{
this.HeaderLocation = addr;
return VerifyChecksum();
}
// Offset 0x07FC0 in a headerless LoROM image (LoROM rom sin smc header)
// Offset 0x0FFC0 in a headerless HiROM image (HiROM rom sin smc header)
// verifica el checksum
private bool VerifyChecksum()
{
// La rom tiene header smc
if (SmcHeader)
this.HeaderLocation += 512;
this.ChecksumCompliment = BitConverter.ToUInt16(this.Get(0x1C, 0x1D), 0);
this.Checksum = BitConverter.ToUInt16(this.Get(0x1E, 0x1F), 0);
ushort ver = (ushort)(this.Checksum ^ this.ChecksumCompliment);
return (ver == 0xFFFF);
}
private void ReadHeader()
{
this.Name = Encoding.ASCII.GetString(this.Get(0x00, 0x14)); // 21 chars
this.Layout = this.At(0x15);
this.CartridgeType = this.At(0x16);
this.RomSize = this.At(0x17);
this.RamSize = this.At(0x18);
this.CountryCode = this.At(0x19);
this.LicenseCode = this.At(0x1A);
this.VersionNumber = this.At(0x1B);
}
private string GetROmB()
{
return String.Format("{0}", this.RomSize);
}
private byte[] Get(int from, int to)
{
return this.Data.Skip(this.HeaderLocation + from).Take(to - from + 1).ToArray();
}
private byte At(int addr)
{
return this.Data[this.HeaderLocation + addr];
}
}
}
Cuando lo comprenda, lo pasaré a modo visual que estoy haciendo como puedes ver abajo.
Hay que saber los pines que usan las eprom gracias a la ROM, me falta averiguar esa parte.
