Proyecto emular procesadores usando Delphi PASCAL y Ensamblador

[compsystems]

Hola, en el curso de microcontroladores que realice, el docente solo abarco la programación en lenguaje ensamblador las tres primeras semanas , luego salto desafortunadamente a lenguajes estructurados como C.

Tengo algún dominio en lenguaje ensamblador, pero este es propio de cada microprocesador o procesador aunque la lógica es la misma para todos, mis docentes son de la vieja guardia, donde desarrollaban aplicaciones en un 90% en lenguaje ensamblador; ahora con el facilismo de los IDEs el lenguaje ensamblador paso a segundo plano.

Mi docente decía que los verdaderos conocedores o programadores de un sistema computacional son los programadores en lenguaje ensamblador, mas bien yo los llamo MAGOS, pues un código escrito en ASM se basa en dar saltos de un lugar otro, aunque un lenguaje estructurado en ultimas también lo es así, pero escrito en un ¨texto¨ mas cercano al lenguaje natural humano.

Un compilador es un software que en el caso de un lenguaje como C, lo lleva a binario, pero antes pasando por una traducción en ensamblador, y como lo hace una maquina, el docente decía que esas traducciones dan muchas vueltas para llegar a lo mismo, que si se hubiera escrito directamente en ASM, así que programar en ASM es ir a la fija, pero en muy impráctico con respecto a los lenguajes de alto nivel

Ahora todos han escuchado los famosos emuladores, los mas conocidos son los emuladores de consolas de videos juegos, emular significa usar un procesador antiguo o no compatible instrucción por instrucción en otro, es como un traductor, esto se hizo cuando los desarrolladores escribían un código y luego salía un nuevo procesador entonces para no reescribir el código se invento la manera de hacerlo compatible con el otro procesador, pero lo mas interesante es que podemos ejecutar un código de un procesador x en otro procesador totalmente diferente.

me interesa mas los emuladores de calculadoras, pueden buscar los dos mas famosos EMU48 que emula las calculadoras Hewlett Packard serie HP48 y TIEMU que emula las calculadoras Texas Instruments, a sido un sueño crear un emulador o por lo menos entender como lo hacen

Encontré un emulador de una calculadora CASIO PB1000 y PB2000 escrito en Delphi PASCAL, espero encontrar entusiastas para que exploremos el código fuente que por cierto es muy corto y ver como es que se hace la emulación y por que no aprender a crear emuladores

emuladores de calculadoras Casio

EL código fuente de emulación descomprimido solo es de 300K pues 200k son imagenes, buscar pb2000es.zip escrito Delphi

Ejemplo del código CPU.pas

unit Cpu;

interface

  procedure CpuReset;
  procedure CpuWakeUp (apo_value: boolean);
  procedure SetIfl (int_bit: byte);
  function CpuRun : integer;


implementation

  uses Def, Decoder, Port;

  type Proc1 = procedure;


  procedure CpuReset;
  begin
    procptr := nil;
    pc := $0000;
    ua := 0;
    delayed_ua := ua;
    ky := $0C00;
    delayed_ky := ky;
    ie := 0;
    ia := 0;
    ib := 0;
    iserv := 0;
    speed := 0;
    acycles := 0;
  end {CpuReset};


  procedure CpuWakeUp (apo_value: boolean);
  begin
    if not CpuSleep then Exit;
    if apo_value then
      flag := flag or APO_bit
    else
      flag := flag and not APO_bit;
    speed := 0;
    acycles := 0;
    CpuSleep := False;
  end {CpuWakeUp};


{ set the interrupt request flag in the IB register if the interrupt is
  enabled }
  procedure SetIfl (int_bit: byte);
  begin
    if ((ie shr 3) and int_bit) <> 0 then
      ib := ib or int_bit;
{ the system can be waken-up by an One-Minute Timer interrupt ... }
    if ((ib and (MINTIMER_bit or $20)) = (MINTIMER_bit or $20)) or
{ ... or through the ON terminal }
    ((int_bit = ONINT_bit) and ((ie and $04) <> 0)) then
      CpuWakeUp (True);
  end {SetIfl};


{ execute a single instruction, returns number of clock cycles }
  function CpuRun : integer;
  var
    i: integer;
  begin

{ complete an optional I/O device write }
    if procptr <> nil then
    begin
      Proc1(procptr);
      procptr := nil;
    end {if};

    cycles := 0;
    if CpuSleep then Inc (cycles, 6) else
    begin
{ is there a pending interrupt request of higher priority than currently serviced? }
      if (ib and $1F and not iserv) > iserv then
{ handle an interrupt }
      begin
        Dec (ss);		{ push the return address on the stack }
        DstPtr(Addr18(ua shr 2, ss))^ := Hi (pc);
        Dec (ss);
        DstPtr(Addr18(ua shr 2, ss))^ := Lo (pc);
        for i:=0 to INTVECTORS-1 do
        begin
          if (ib and intmask[i]) <> 0 then
          begin
            iserv := iserv or intmask[i];
            pc := intvec[i];
            opindex := 0;	{prevents subsequent PC alignment}
            Break;
          end {if};
        end {for};
        Inc (cycles, 11);
        if (ua and 3) <> 0 then Inc (cycles);
      end
      else
{ execute an instruction }
        ExecInstr;
    end {if};
    if iserv = 0 then cycles := cycles shl speed;
    CpuRun := cycles;
  end {CpuRun};

end.