/// <summary>Procesa las peticiones de la consola de depuracion</summary>
/// <param name="cpu">CPU principal de la consola para acceder a sus registros y memoria</param>
public static void ConsolaDepuracion(kernel.CPU cpu)
{
string linea = null;
string[] a = null;
WriteLine("Iniciando Consola de depuracion");
mostrarAyudaConsolaDepuracion();
do{
Write("CSGBE> ");
linea = Console.ReadLine();
a = linea.Split(null);
try{
switch(a[0]){
case "?": mostrarAyudaConsolaDepuracion(); break;
case "r": imprimirRegistros(cpu.registros); break;
case "i": imprimirInterrupciones(cpu.registros, cpu.memoria); break;
case "m": hexDump(cpu.memoria, wordHex(a[1]), Int32.Parse(a[2])); break;
case "x": cpu.reset(); break;
case "e": cpu.procesarInstrucciones(Int32.Parse(a[1])); break;
case "a": cpu.registros.setReg(a[1].ToUpper(), wordHex(a[2])); break;
case "f": cpu.registros.setFlag(a[1], !cpu.registros.getFlag(a[1])); break;
case "w": cpu.memoria.escribir(wordHex(a[2]), wordHex(a[1])); break;
case "n": asignarInterrupcion(cpu.memoria, a[1], a[2]); break;
case "k": toggleTecla(cpu.memoria, a[1]); break;
case "b": cpu.toggleBreakpoint(wordHex(a[1])); break;
}
}catch(Exception e){ WriteLine(e.StackTrace); }
}while(a[0] != "q");
WriteLine("Fin de la consola de depuracion");
}
=> input => new CuDnnConvolutionalLayer(input, info, kernel, kernels, activation, biasMode);
/// <summary>Cambia el estado de una tecla de la consola</summary>
/// <param name="memoria">Memoria</param>
/// <param name="tecla">Nombre de la tecla (DOWN, UP, LEFT, RIGHT, START, SELECT, B o A)</param>
private static void toggleTecla(kernel.Memoria memoria, string tecla)
{
tecla = tecla.ToUpper();
int idTecla = 0;
bool error = false;
switch(tecla){
case "DOWN": idTecla = kernel.Constantes.KEY_DOWN; break;
case "UP": idTecla = kernel.Constantes.KEY_UP; break;
case "LEFT": idTecla = kernel.Constantes.KEY_LEFT; break;
case "RIGHT": idTecla = kernel.Constantes.KEY_RIGHT; break;
case "START": idTecla = kernel.Constantes.KEY_START; break;
case "SELECT": idTecla = kernel.Constantes.KEY_SELECT; break;
case "B": idTecla = kernel.Constantes.KEY_B; break;
case "A": idTecla = kernel.Constantes.KEY_A; break;
default: error = true; break;
}
if (!error) Keypad.toggleTecla(idTecla);
}
/// <summary>Imprime el valor de todos los registros</summary>
/// <param name="registros">Registros</param>
private static void imprimirRegistros(kernel.Registros registros)
{
WriteLine("PC = " + hexWord(registros.regPC) + "\tSP = " + hexWord(registros.regSP));
WriteLine("A = " + hexByte(registros.regA) + "\tB = " + hexByte(registros.regB) + "\tC = " + hexByte(registros.regC) + "\tD = " + hexByte(registros.regD) + "\tE = " + hexByte(registros.regE) + "\tH = " + hexByte(registros.regH) + "\tL = " + hexByte(registros.regL));
WriteLine("Z = " + registros.flagZ + "\tN = " + registros.flagN + "\tH = " + registros.flagH + "\tC = " + registros.flagC);
}
/// <summary>Imprime el estado de las interrupciones y del IME (Interrupt Master Enable)</summary>
/// <param name="registros">Registros</param>
/// <param name="memoria">Memoria</param>
private static void imprimirInterrupciones(kernel.Registros registros, kernel.Memoria memoria)
{
WriteLine("IME = " + registros.flagIME);
Write("VBLANK = " + ((memoria.leer(kernel.Constantes.INT_FLAG) & kernel.Constantes.INT_VBLANK) > 0));
Write("\tLCDC = " + ((memoria.leer(kernel.Constantes.INT_FLAG) & kernel.Constantes.INT_LCDC) > 0));
Write("\tTIMER = " + ((memoria.leer(kernel.Constantes.INT_FLAG) & kernel.Constantes.INT_TIMER) > 0));
Write("\tSERIALTX = " + ((memoria.leer(kernel.Constantes.INT_FLAG) & kernel.Constantes.INT_SERIALTX) > 0));
WriteLine("\tKEY = " + ((memoria.leer(kernel.Constantes.INT_FLAG) & kernel.Constantes.INT_KEY) > 0));
}
/// <summary>Imprime una zona de memoria en un formato presentable</summary>
/// <param name="memoria">Memoria</param>
/// <param name="direccion">Direccion de memoria de inicio</param>
/// <param name="longitud">Cantidad de bytes que se quieren imprimir a partir de la direccion de inicio (minimo 10)</param>
private static void hexDump(kernel.Memoria memoria, int direccion, int longitud)
{
int start = direccion & 0xFFF0;
int lines = longitud / 16;
if (lines == 0) lines = 1;
for (int l = 0; l < lines; l++) {
Write(hexWord(start + (l * 16)) + " ");
for (int r = start + (l * 16); r < start + (l * 16) + 16; r++) Write(hexByte(memoria.leer(r)) + " ");
Write(" ");
for (int r = start + (l * 16); r < start + (l * 16) + 16; r++) {
char c = (char)memoria.leer(r);
if ((c >= 32) && (c <= 128)) Write(c);
else Write(".");
}
WriteLine();
}
}
/// <summary>Activa o desactiva una interrupcion</summary>
/// <param name="memoria">Memoria</param>
/// <param name="interrupcion">Nombre de la interrupcion a modificar (VBLANK, LCDC, TIMER, SERIALTX o KEY)</param>
/// <param name="valor">Nuevo valor para la interrupcion. 1 o 0</param>
private static void asignarInterrupcion(kernel.Memoria memoria, string interrupcion, string valor)
{
bool error = false;
int val = 0;
interrupcion = interrupcion.ToUpper();
switch(interrupcion){
case "VBLANK": val = kernel.Constantes.INT_VBLANK; break;
case "LCDC": val = kernel.Constantes.INT_LCDC; break;
case "TIMER": val = kernel.Constantes.INT_TIMER; break;
case "SERIALTX": val = kernel.Constantes.INT_SERIALTX; break;
case "KEY": val = kernel.Constantes.INT_KEY; break;
default: error = true; break;
}
switch(valor){
case "1": break;
case "0": val = ~val; break;
default: error = true; break;
}
if (!error) memoria.escribir(memoria.leer(kernel.Constantes.INT_FLAG) | val, kernel.Constantes.INT_FLAG);
}
