new resource endpoint for posting data

adding toString methode to models.

.classpath

@@ -24,8 +24,9 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-10">
 		<attributes>
+			<attribute name="module" value="true"/>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>

src/main/java/de/mcs/tools/sps/emulator/emulator/AbstractEmulator.java

@@ -1,141 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator;
-
-import java.util.List;
-
-import de.mcs.tools.sps.emulator.EmulatorInput;
-import de.mcs.tools.sps.emulator.EmulatorInternals;
-import de.mcs.tools.sps.emulator.EmulatorOutput;
-import de.mcs.tools.sps.emulator.SPSCommand;
-import de.mcs.tools.sps.emulator.SPSCommandData;
-import de.mcs.tools.sps.emulator.SPSEmulator;
-import de.mcs.tools.sps.emulator.TOutputCallback;
-import de.mcs.tools.sps.emulator.exceptions.WrongProgramSizeException;
-
-/**
- * @author w.klaas
- *
- */
-public abstract class AbstractEmulator implements SPSEmulator {
-
-  protected byte[] programMemory;
-  private boolean debug;
-  private boolean active;
-  private TOutputCallback outputCallback;
-  private EmulatorInput emulatorInput;
-  private EmulatorOutput emulatorOutput;
-  private EmulatorInternals emulatorInternals;
-
-  @Override
-  public abstract List<SPSCommand> getCommands();
-
-  @Override
-  public abstract int getProgramSize();
-
-  @Override
-  public void loadProgram(byte[] program) throws WrongProgramSizeException {
-    if (program.length > getProgramSize()) {
-      throw new WrongProgramSizeException(
-          String.format("the program is to long. Only %d bytes are permitted", getProgramSize()));
-    }
-    this.programMemory = program;
-  }
-
-  @Override
-  public void startProgram(boolean debug) {
-    this.debug = debug;
-    if (emulatorInput == null) {
-      emulatorInput = createEmulatorInput();
-    }
-    emulatorOutput = createEmulatorOutput();
-    emulatorInternals = createEmulatorInternals();
-    reset();
-    active = true;
-    if (outputCallback != null) {
-      outputCallback.onOutput(getEmulatorOutput());
-    }
-    if (!debug) {
-      while (active) {
-        callNextCommand();
-      }
-    }
-  }
-
-  protected abstract void callNextCommand();
-
-  protected abstract EmulatorInput createEmulatorInput();
-
-  protected abstract EmulatorOutput createEmulatorOutput();
-
-  protected abstract EmulatorInternals createEmulatorInternals();
-
-  @Override
-  public SPSCommandData getCommandData(byte command) {
-    SPSCommandData commandData = null;
-    byte commandByte = (byte) (command & (byte) 0xF0);
-
-    List<SPSCommand> commands = getCommands();
-    for (SPSCommand c : commands) {
-      if (c.getCommandByte() == commandByte) {
-        for (SPSCommandData cd : c.getCommandDatas()) {
-          if (cd.getCommandByte() == command) {
-            commandData = cd;
-          }
-        }
-      }
-    }
-    return commandData;
-  }
-
-  protected void runCommand(SPSCommandData commandData) {
-    EmulatorOutput emulatorOutput = commandData.doWork(getEmulatorInput(), getEmulatorInternals(), getEmulatorOutput());
-    if (outputCallback != null) {
-      outputCallback.onOutput(emulatorOutput);
-    }
-  }
-
-  protected abstract void reset();
-
-  @Override
-  public void addCallback(TOutputCallback callback) {
-    this.outputCallback = callback;
-  }
-
-  @Override
-  public void nextStep() {
-    callNextCommand();
-  }
-
-  @Override
-  public boolean isActive() {
-    return active;
-  }
-
-  @Override
-  public void stop() {
-    active = false;
-  }
-
-  @Override
-  public void setEmulatorInput(EmulatorInput input) {
-    this.emulatorInput = input;
-  };
-
-  @Override
-  public EmulatorInput getEmulatorInput() {
-    return emulatorInput;
-  };
-
-  @Override
-  public EmulatorInternals getEmulatorInternals() {
-    return emulatorInternals;
-  };
-
-  @Override
-  public EmulatorOutput getEmulatorOutput() {
-    return emulatorOutput;
-  };
-
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/HoltekEmulator.java

@@ -1,682 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import de.mcs.tools.sps.emulator.EmulatorInput;
-import de.mcs.tools.sps.emulator.EmulatorInternals;
-import de.mcs.tools.sps.emulator.EmulatorOutput;
-import de.mcs.tools.sps.emulator.SPSCommand;
-import de.mcs.tools.sps.emulator.SPSCommandData;
-import de.mcs.tools.sps.emulator.SPSCommandDataImpl;
-import de.mcs.tools.sps.emulator.SPSCommandImpl;
-import de.mcs.tools.sps.emulator.SPSEmulator;
-import de.mcs.tools.sps.emulator.emulator.AbstractEmulator;
-
-/**
- * @author w.klaas
- *
- */
-public class HoltekEmulator extends AbstractEmulator implements SPSEmulator {
-  private List<SPSCommand> commands = new ArrayList<>();
-  {
-    commands.add(SPS_NOP);
-    commands.add(SPS_PORT);
-    commands.add(SPS_WAIT);
-    commands.add(SPS_JUMP_DOWN);
-    commands.add(SPS_A_EQUALS);
-    commands.add(SPS_EQUALS_A);
-    commands.add(SPS_A_INPUT);
-    commands.add(SPS_A_CALCULATE);
-    commands.add(SPS_PAGE);
-    commands.add(SPS_JUMP);
-    commands.add(SPS_C_LOOP);
-    commands.add(SPS_D_LOOP);
-    commands.add(SPS_SKIP_IF);
-    commands.add(SPS_CALL);
-    commands.add(SPS_RETURN);
-  }
-
-  private static SPSCommand SPS_NOP = new SPSCommandImpl().setName("no operation").setMnemonic("NOP")
-      .setCommandByte((byte) 0x00);
-  static {
-    SPS_NOP.getCommandDatas().add(new SPSCommandDataNOP().setName("nop").setMnemonic("NOP")
-        .setCommandByte((byte) (SPS_NOP.getCommandByte())).setCommand(SPS_NOP));
-  }
-
-  private static SPSCommand SPS_PORT = new SPSCommandImpl().setName("Port Output").setMnemonic("PORT")
-      .setCommandByte((byte) 0x10);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_PORT.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte data = getData();
-          HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-          emulatorOutput.setOutput(data);
-          internals.incAddress(1);
-          return emulatorOutput;
-        }
-      }.setName("Port " + Integer.toString(i)).setMnemonic("PO" + Integer.toString(i))
-          .setCommandByte((byte) (SPS_PORT.getCommandByte() + i)).setCommand(SPS_PORT));
-    }
-  }
-
-  private static SPSCommand SPS_WAIT = new SPSCommandImpl().setName("WAIT").setMnemonic("WAIT")
-      .setCommandByte((byte) 0x20);
-  static {
-    List<SPSCommandData> datas = SPS_WAIT.getCommandDatas();
-    for (int i = 0; i < 16; i++) {
-      datas.add(
-          new SPSCommandDataWait().setName(SPSCommandDataWait.getName(i)).setMnemonic(SPSCommandDataWait.getMnemonic(i))
-              .setCommandByte((byte) (SPS_WAIT.getCommandByte() + i)).setCommand(SPS_WAIT));
-    }
-  }
-
-  private static SPSCommand SPS_JUMP_DOWN = new SPSCommandImpl().setName("jump back").setMnemonic("JMP-")
-      .setCommandByte((byte) 0x30);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_JUMP_DOWN.getCommandDatas()
-          .add(new SPSCommandDataJumpDown().setName("Jump -" + Integer.toString(i))
-              .setMnemonic("JN" + Integer.toString(i)).setCommandByte((byte) (SPS_JUMP_DOWN.getCommandByte() + i))
-              .setCommand(SPS_JUMP_DOWN));
-    }
-  }
-
-  private static SPSCommand SPS_A_EQUALS = new SPSCommandImpl().setName("Set A").setMnemonic("A=")
-      .setCommandByte((byte) 0x40);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_A_EQUALS.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte data = getData();
-          internals.setRegister("A", data);
-          internals.incAddress(1);
-          return output;
-        }
-      }.setName("A= " + Integer.toString(i)).setMnemonic(String.format("A%02d", i))
-          .setCommandByte((byte) (SPS_A_EQUALS.getCommandByte() + i)).setCommand(SPS_A_EQUALS));
-    }
-  }
-
-  private static SPSCommand SPS_EQUALS_A = new SPSCommandImpl().setName("=A").setMnemonic("=A")
-      .setCommandByte((byte) 0x50);
-  static {
-    List<SPSCommandData> datas = SPS_EQUALS_A.getCommandDatas();
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("B", internals.getRegister("A"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("B=A").setMnemonic("BEA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x01))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("C", internals.getRegister("A"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("C=A").setMnemonic("CEA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x02))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("D", internals.getRegister("A"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("D=A").setMnemonic("DEA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x03))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-        emulatorOutput.setOutput(internals.getRegister("A"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("Output=A").setMnemonic("OEA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x04))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-        byte dataNew = internals.getRegister("A");
-        byte dataOld = emulatorOutput.getOutput();
-        byte data = (byte) ((dataOld & 0b00001110) + (dataNew & 0x01));
-        emulatorOutput.setOutput(data);
-        internals.incAddress(1);
-        return emulatorOutput;
-      }
-    }.setName("Output.1=A").setMnemonic("O1EA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x05))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-        byte dataNew = internals.getRegister("A");
-        byte dataOld = emulatorOutput.getOutput();
-        byte data = (byte) ((dataOld & 0b00001101) + ((dataNew & 0x01) << 1));
-        emulatorOutput.setOutput(data);
-        internals.incAddress(1);
-        return emulatorOutput;
-      }
-    }.setName("Output.2=A").setMnemonic("O2EA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x06))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-        byte dataNew = internals.getRegister("A");
-        byte dataOld = emulatorOutput.getOutput();
-        byte data = (byte) ((dataOld & 0b00001011) + ((dataNew & 0x01) << 2));
-        emulatorOutput.setOutput(data);
-        internals.incAddress(1);
-        return emulatorOutput;
-      }
-    }.setName("Output.3=A").setMnemonic("O3EA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x07))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-        byte dataNew = internals.getRegister("A");
-        byte dataOld = emulatorOutput.getOutput();
-        byte data = (byte) ((dataOld & 0b00000111) + ((dataNew & 0x01) << 3));
-        emulatorOutput.setOutput(data);
-        internals.incAddress(1);
-        return emulatorOutput;
-      }
-    }.setName("Output.4=A").setMnemonic("O4EA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x08))
-        .setCommand(SPS_EQUALS_A));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        HoltekEmulatorOutput emulatorOutput = (HoltekEmulatorOutput) output;
-        emulatorOutput.setFeature("PWM", internals.getRegister("A"));
-        internals.incAddress(1);
-        return emulatorOutput;
-      }
-    }.setName("PWM=A").setMnemonic("PEA").setCommandByte((byte) (SPS_EQUALS_A.getCommandByte() + 0x09))
-        .setCommand(SPS_EQUALS_A));
-  }
-
-  private static SPSCommand SPS_A_INPUT = new SPSCommandImpl().setName("A=(some input)").setMnemonic("AEI")
-      .setCommandByte((byte) 0x60);
-  static {
-    List<SPSCommandData> datas = SPS_A_INPUT.getCommandDatas();
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", internals.getRegister("B"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=B").setMnemonic("AEB").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x01))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", internals.getRegister("C"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=C").setMnemonic("AEC").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x02))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", internals.getRegister("D"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=D").setMnemonic("AED").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x03))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", input.getInput());
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=Input").setMnemonic("AEI").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x04))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        boolean value = (input.getInput() & 0x01) > 0;
-        internals.setRegister("A", (byte) (value ? 1 : 0));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=Input.1").setMnemonic("AEI1").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x05))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        boolean value = (input.getInput() & 0x02) > 0;
-        internals.setRegister("A", (byte) (value ? 1 : 0));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=Input.2").setMnemonic("AEI2").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x06))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        boolean value = (input.getInput() & 0x04) > 0;
-        internals.setRegister("A", (byte) (value ? 1 : 0));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=Input.3").setMnemonic("AEI3").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x07))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        boolean value = (input.getInput() & 0x08) > 0;
-        internals.setRegister("A", (byte) (value ? 1 : 0));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=Input.4").setMnemonic("AEI4").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x08))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", input.getFeature("AD1"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=AD.1").setMnemonic("AEA1").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x09))
-        .setCommand(SPS_A_INPUT));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", input.getFeature("AD2"));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=AD.2").setMnemonic("AEA2").setCommandByte((byte) (SPS_A_INPUT.getCommandByte() + 0x0A))
-        .setCommand(SPS_A_INPUT));
-  }
-
-  private static SPSCommand SPS_A_CALCULATE = new SPSCommandImpl().setName("Calculate with A").setMnemonic("CALC")
-      .setCommandByte((byte) 0x70);
-  static {
-    List<SPSCommandData> datas = SPS_A_CALCULATE.getCommandDatas();
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") + 1));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A+1").setMnemonic("INCA").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x01))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") - 1));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A-1").setMnemonic("DECA").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x02))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") + internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A+B").setMnemonic("ADDB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x03))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") - internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A-B").setMnemonic("SUBB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x04))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") * internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A*B").setMnemonic("MULB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x05))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") / internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A/B").setMnemonic("DIVB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x06))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") & internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A AND B").setMnemonic("ANDB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x07))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") | internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A OR B").setMnemonic("ORB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x08))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") ^ internals.getRegister("B")));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=A XOR B").setMnemonic("XORB").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x09))
-        .setCommand(SPS_A_CALCULATE));
-    datas.add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.setRegister("A", (byte) (internals.getRegister("A") ^ 0xFF));
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=NOT A").setMnemonic("NOTA").setCommandByte((byte) (SPS_A_CALCULATE.getCommandByte() + 0x0A))
-        .setCommand(SPS_A_CALCULATE));
-  }
-
-  private static SPSCommand SPS_PAGE = new SPSCommandImpl().setName("Page").setMnemonic("PG")
-      .setCommandByte((byte) 0x80);
-  static {
-    for (int i = 0; i < 8; i++) {
-      SPS_PAGE.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte data = getData();
-          if (data <= 0x07) {
-            internals.setRegister(HoltekEmulatorInternals.REGISTER_PAGE, data);
-          }
-          internals.incAddress(1);
-          return output;
-        }
-      }.setName("Page " + Integer.toString(i)).setMnemonic("PG" + Integer.toString(i))
-          .setCommandByte((byte) (SPS_PAGE.getCommandByte() + i)).setCommand(SPS_PAGE));
-    }
-  }
-
-  private static SPSCommand SPS_JUMP = new SPSCommandImpl().setName("Jump").setMnemonic("JMP")
-      .setCommandByte((byte) 0x90);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_JUMP.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          ((HoltekEmulatorInternals) internals).address = getData()
-              + (internals.getRegister(HoltekEmulatorInternals.REGISTER_PAGE) * 16);
-          return output;
-        }
-      }.setName("Jump " + Integer.toString(i)).setMnemonic("JMP" + Integer.toString(i))
-          .setCommandByte((byte) (SPS_JUMP.getCommandByte() + i)).setCommand(SPS_JUMP));
-    }
-  }
-
-  private static SPSCommand SPS_C_LOOP = new SPSCommandImpl().setName("C* Loop").setMnemonic("CLOP")
-      .setCommandByte((byte) 0xA0);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_C_LOOP.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte c = internals.getRegister(HoltekEmulatorInternals.REGISTER_C);
-          if (c > 0) {
-            c -= 1;
-            c = (byte) (c & 0x0F);
-            internals.setRegister(HoltekEmulatorInternals.REGISTER_C, c);
-            ((HoltekEmulatorInternals) internals).address = getData()
-                + (internals.getRegister(HoltekEmulatorInternals.REGISTER_PAGE) * 16);
-          } else {
-            internals.incAddress(1);
-          }
-          return output;
-        }
-      }.setName("C* Loop " + Integer.toString(i)).setMnemonic("CLOP" + Integer.toString(i))
-          .setCommandByte((byte) (SPS_C_LOOP.getCommandByte() + i)).setCommand(SPS_C_LOOP));
-    }
-  }
-
-  private static SPSCommand SPS_D_LOOP = new SPSCommandImpl().setName("D* Loop").setMnemonic("DLOP")
-      .setCommandByte((byte) 0xB0);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_D_LOOP.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte d = internals.getRegister(HoltekEmulatorInternals.REGISTER_D);
-          if (d > 0) {
-            d -= 1;
-            d = (byte) (d & 0x0F);
-            internals.setRegister(HoltekEmulatorInternals.REGISTER_D, d);
-            ((HoltekEmulatorInternals) internals).address = getData()
-                + (internals.getRegister(HoltekEmulatorInternals.REGISTER_PAGE) * 16);
-          } else {
-            internals.incAddress(1);
-          }
-          return output;
-        }
-      }.setName("D* Loop " + Integer.toString(i)).setMnemonic("DLOP" + Integer.toString(i))
-          .setCommandByte((byte) (SPS_D_LOOP.getCommandByte() + i)).setCommand(SPS_D_LOOP));
-    }
-  }
-
-  private static SPSCommand SPS_SKIP_IF = new SPSCommandImpl().setName("Skip if").setMnemonic("SKIP")
-      .setCommandByte((byte) 0xC0);
-  static {
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        byte a = internals.getRegister(HoltekEmulatorInternals.REGISTER_A);
-        byte b = internals.getRegister(HoltekEmulatorInternals.REGISTER_B);
-        if (a > b) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A>B").setMnemonic("AGRB").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x01))
-        .setCommand(SPS_SKIP_IF));
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        byte a = internals.getRegister(HoltekEmulatorInternals.REGISTER_A);
-        byte b = internals.getRegister(HoltekEmulatorInternals.REGISTER_B);
-        if (a < b) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A<B").setMnemonic("ASMB").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x02))
-        .setCommand(SPS_SKIP_IF));
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        byte a = internals.getRegister(HoltekEmulatorInternals.REGISTER_A);
-        byte b = internals.getRegister(HoltekEmulatorInternals.REGISTER_B);
-        if (a == b) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("A=B").setMnemonic("AEQB").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x03))
-        .setCommand(SPS_SKIP_IF));
-
-    for (int i = 0; i < 4; i++) {
-      SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte in = input.getInput();
-          byte data = (byte) (getData() - 0x04);
-          if ((in & (0x01 << data)) > 0) {
-            internals.incAddress(1);
-          }
-          internals.incAddress(1);
-          return output;
-        }
-      }.setName(String.format("In.%d=1", i + 1)).setMnemonic(String.format("IN%d1", i + 1))
-          .setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x04 + i)).setCommand(SPS_SKIP_IF));
-    }
-
-    for (int i = 0; i < 4; i++) {
-      SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          byte in = input.getInput();
-          byte data = (byte) (getData() - 0x08);
-          if ((in & (0x01 << data)) == 0) {
-            internals.incAddress(1);
-          }
-          internals.incAddress(1);
-          return output;
-        }
-      }.setName(String.format("In.%d=0", i + 1)).setMnemonic(String.format("IN%d0", i + 1))
-          .setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x08 + i)).setCommand(SPS_SKIP_IF));
-    }
-
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        if (!input.getFeatureAsBool(HoltekEmulatorInput.S1)) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("S1=0").setMnemonic("S10").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x0C))
-        .setCommand(SPS_SKIP_IF));
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        if (!input.getFeatureAsBool(HoltekEmulatorInput.S2)) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("S2=0").setMnemonic("S20").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x0D))
-        .setCommand(SPS_SKIP_IF));
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        if (input.getFeatureAsBool(HoltekEmulatorInput.S1)) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("S1=1").setMnemonic("S11").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x0E))
-        .setCommand(SPS_SKIP_IF));
-    SPS_SKIP_IF.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        if (input.getFeatureAsBool(HoltekEmulatorInput.S2)) {
-          internals.incAddress(1);
-        }
-        internals.incAddress(1);
-        return output;
-      }
-    }.setName("S2=1").setMnemonic("S21").setCommandByte((byte) (SPS_SKIP_IF.getCommandByte() + 0x0F))
-        .setCommand(SPS_SKIP_IF));
-  };
-
-  private static SPSCommand SPS_CALL = new SPSCommandImpl().setName("Call").setMnemonic("CALL")
-      .setCommandByte((byte) 0xD0);
-  static {
-    for (int i = 0; i < 16; i++) {
-      SPS_CALL.getCommandDatas().add(new SPSCommandDataImpl() {
-        @Override
-        public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-          internals.pushRtrAddress();
-          ((HoltekEmulatorInternals) internals).address = getData()
-              + (internals.getRegister(HoltekEmulatorInternals.REGISTER_PAGE) * 16);
-          return output;
-        }
-      }.setName("Call " + Integer.toString(i)).setMnemonic("CALL" + Integer.toString(i))
-          .setCommandByte((byte) (SPS_CALL.getCommandByte() + i)).setCommand(SPS_CALL));
-    }
-  }
-
-  private static SPSCommand SPS_RETURN = new SPSCommandImpl().setName("return").setMnemonic("RET")
-      .setCommandByte((byte) 0xE0);
-  private static HoltekEmulator instance;
-  static {
-    SPS_RETURN.getCommandDatas().add(new SPSCommandDataImpl() {
-      @Override
-      public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-        internals.popRtrAddress();
-        return output;
-      }
-    }.setName("Return").setMnemonic("RET").setCommandByte((byte) (SPS_RETURN.getCommandByte())).setCommand(SPS_RETURN));
-  }
-
-  @Override
-  public List<SPSCommand> getCommands() {
-    return commands;
-  }
-
-  @Override
-  public int getProgramSize() {
-    return 128;
-  }
-
-  @Override
-  protected void reset() {
-    getEmulatorOutput().reset();
-    getEmulatorInternals().reset();
-    System.out.println("holtec emulator resettet");
-
-  }
-
-  @Override
-  protected void callNextCommand() {
-    byte command = programMemory[getEmulatorInternals().getAddress()];
-    SPSCommandData commandData = getCommandData(command);
-    runCommand(commandData);
-  }
-
-  @Override
-  protected EmulatorInput createEmulatorInput() {
-    return new HoltekEmulatorInput();
-  }
-
-  @Override
-  protected EmulatorOutput createEmulatorOutput() {
-    return new HoltekEmulatorOutput();
-  }
-
-  @Override
-  protected EmulatorInternals createEmulatorInternals() {
-    return new HoltekEmulatorInternals();
-  }
-
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/HoltekEmulatorInput.java

@@ -1,111 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import de.mcs.tools.sps.emulator.EmulatorInput;
-
-/**
- * @author w.klaas
- *
- */
-public class HoltekEmulatorInput implements EmulatorInput {
-
-  public static final String AD1 = "AD1";
-  public static final String AD2 = "AD2";
-  public static final String S1 = "S1";
-  public static final String S2 = "S2";
-  boolean i0, i1, i2, i3, s1, s2;
-  int ad1, ad2;
-
-  @Override
-  public void reset() {
-    i0 = false;
-    i1 = false;
-    i2 = false;
-    i3 = false;
-    s1 = false;
-    s2 = false;
-    ad1 = 0;
-    ad2 = 0;
-  }
-
-  @Override
-  public void setInput(byte data) {
-    i0 = (data & (byte) 0x01) > 0;
-    i1 = (data & (byte) 0x02) > 0;
-    i2 = (data & (byte) 0x04) > 0;
-    i3 = (data & (byte) 0x08) > 0;
-  }
-
-  public byte getInput() {
-    return (byte) ((i0 ? 1 : 0) + (i1 ? 2 : 0) + (i2 ? 4 : 0) + (i3 ? 8 : 0));
-  }
-
-  @Override
-  public void setFeature(String name, byte value) {
-    if (AD1.equals(name.toUpperCase())) {
-      ad1 = value;
-    }
-    if (AD2.equals(name.toUpperCase())) {
-      ad2 = value;
-    }
-    if (S1.equals(name.toUpperCase())) {
-      s1 = value > 0;
-    }
-    if (S2.equals(name.toUpperCase())) {
-      s2 = value > 0;
-    }
-  }
-
-  @Override
-  public void setFeature(String name, boolean value) {
-    if (AD1.equals(name.toUpperCase())) {
-      ad1 = value ? 1 : 0;
-    }
-    if (AD2.equals(name.toUpperCase())) {
-      ad2 = value ? 1 : 0;
-    }
-    if (S1.equals(name.toUpperCase())) {
-      s1 = value;
-    }
-    if (S2.equals(name.toUpperCase())) {
-      s2 = value;
-    }
-  }
-
-  @Override
-  public byte getFeature(String name) {
-    if (AD1.equals(name.toUpperCase())) {
-      return (byte) ad1;
-    }
-    if (AD2.equals(name.toUpperCase())) {
-      return (byte) ad2;
-    }
-    if (S1.equals(name.toUpperCase())) {
-      return (byte) ad1;
-    }
-    if (S2.equals(name.toUpperCase())) {
-      return (byte) ad2;
-    }
-    return 0;
-  }
-
-  @Override
-  public boolean getFeatureAsBool(String name) {
-    if (AD1.equals(name.toUpperCase())) {
-      return (byte) ad1 > 0;
-    }
-    if (AD2.equals(name.toUpperCase())) {
-      return (byte) ad2 > 0;
-    }
-    if (S1.equals(name.toUpperCase())) {
-      return s1;
-    }
-    if (S2.equals(name.toUpperCase())) {
-      return s2;
-    }
-    return false;
-  }
-
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/HoltekEmulatorInternals.java

@@ -1,107 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import de.mcs.tools.sps.emulator.EmulatorInternals;
-
-/**
- * @author w.klaas
- *
- */
-public class HoltekEmulatorInternals implements EmulatorInternals {
-  public static final String REGISTER_A = "A";
-  public static final String REGISTER_B = "B";
-  public static final String REGISTER_C = "C";
-  public static final String REGISTER_D = "D";
-  public static final String REGISTER_PAGE = "PAGE";
-  int address;
-  int a, b, c, d;
-  int page;
-  long delay;
-  public int rtrAddress;
-
-  @Override
-  public void reset() {
-    address = 0x00;
-    a = 0;
-    b = 0;
-    c = 0;
-    d = 0;
-    page = 0;
-  }
-
-  @Override
-  public int getAddress() {
-    return address;
-  }
-
-  @Override
-  public void incAddress(int i) {
-    address += i;
-  }
-
-  @Override
-  public void setAddress(int i) {
-    address = i;
-  }
-
-  @Override
-  public void setDelay(long l) {
-    delay = l;
-  }
-
-  @Override
-  public long getDelay() {
-    return delay;
-  }
-
-  @Override
-  public void setRegister(String registerName, byte data) {
-    if (REGISTER_A.equals(registerName.toUpperCase())) {
-      a = data;
-    }
-    if (REGISTER_B.equals(registerName.toUpperCase())) {
-      b = data;
-    }
-    if (REGISTER_C.equals(registerName.toUpperCase())) {
-      c = data;
-    }
-    if (REGISTER_D.equals(registerName.toUpperCase())) {
-      d = data;
-    }
-    if (REGISTER_PAGE.equals(registerName.toUpperCase())) {
-      page = data;
-    }
-  }
-
-  @Override
-  public byte getRegister(String register) {
-    if (REGISTER_A.equals(register.toUpperCase())) {
-      return (byte) (a & 0x0F);
-    }
-    if (REGISTER_B.equals(register.toUpperCase())) {
-      return (byte) (b & 0x0F);
-    }
-    if (REGISTER_C.equals(register.toUpperCase())) {
-      return (byte) (c & 0x0F);
-    }
-    if (REGISTER_D.equals(register.toUpperCase())) {
-      return (byte) (d & 0x0F);
-    }
-    if (REGISTER_PAGE.equals(register.toUpperCase())) {
-      return (byte) (page & 0x0F);
-    }
-    return 0;
-  }
-
-  @Override
-  public void pushRtrAddress() {
-    rtrAddress = address;
-  }
-
-  @Override
-  public void popRtrAddress() {
-    address = rtrAddress;
-  }
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/HoltekEmulatorOutput.java

@@ -1,53 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import de.mcs.tools.sps.emulator.EmulatorOutput;
-
-/**
- * @author w.klaas
- *
- */
-public class HoltekEmulatorOutput implements EmulatorOutput {
-
-  boolean d0, d1, d2, d3;
-  int pwm;
-
-  @Override
-  public void reset() {
-    d0 = false;
-    d1 = false;
-    d2 = false;
-    d3 = false;
-    pwm = 0;
-  }
-
-  @Override
-  public void setOutput(byte data) {
-    d0 = (data & (byte) 0x01) > 0;
-    d1 = (data & (byte) 0x02) > 0;
-    d2 = (data & (byte) 0x04) > 0;
-    d3 = (data & (byte) 0x08) > 0;
-  }
-
-  @Override
-  public byte getOutput() {
-    return (byte) ((d0 ? 1 : 0) + (d1 ? 2 : 0) + (d2 ? 4 : 0) + (d3 ? 8 : 0));
-  }
-
-  @Override
-  public void setFeature(String name, byte register) {
-    if ("PWM".equals(name.toUpperCase())) {
-      pwm = register;
-    }
-  }
-
-  @Override
-  public byte getFeature(String name) {
-    if ("PWM".equals(name.toUpperCase())) {
-      return (byte) pwm;
-    }
-    return 0;
-  }
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/SPSCommandDataJumpDown.java

@@ -1,35 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import de.mcs.tools.sps.emulator.EmulatorInput;
-import de.mcs.tools.sps.emulator.EmulatorInternals;
-import de.mcs.tools.sps.emulator.EmulatorOutput;
-import de.mcs.tools.sps.emulator.SPSCommandDataImpl;
-
-/**
- * @author w.klaas
- *
- */
-public class SPSCommandDataJumpDown extends SPSCommandDataImpl {
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * de.mcs.tools.sps.SPSCommandDataImpl#doWork(de.mcs.tools.sps.EmulatorInput,
-   * de.mcs.tools.sps.EmulatorInternals)
-   */
-  @Override
-  public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-    byte data = getData();
-    if ((data >= 0) && (data < 16)) {
-      internals.incAddress(-1 * data);
-    } else {
-      throw new IllegalArgumentException(String.format("jump target %d illegal", data));
-    }
-    return output;
-  }
-
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/SPSCommandDataNOP.java

@@ -1,30 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import de.mcs.tools.sps.emulator.EmulatorInput;
-import de.mcs.tools.sps.emulator.EmulatorInternals;
-import de.mcs.tools.sps.emulator.EmulatorOutput;
-import de.mcs.tools.sps.emulator.SPSCommandDataImpl;
-
-/**
- * @author w.klaas
- *
- */
-public class SPSCommandDataNOP extends SPSCommandDataImpl {
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * de.mcs.tools.sps.SPSCommandDataImpl#doWork(de.mcs.tools.sps.EmulatorInput,
-   * de.mcs.tools.sps.EmulatorInternals)
-   */
-  @Override
-  public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-    internals.incAddress(1);
-    return output;
-  }
-
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/SPSCommandDataWait.java

@@ -1,72 +0,0 @@
-/**
- * 
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;
-
-import de.mcs.tools.sps.emulator.EmulatorInput;
-import de.mcs.tools.sps.emulator.EmulatorInternals;
-import de.mcs.tools.sps.emulator.EmulatorOutput;
-import de.mcs.tools.sps.emulator.SPSCommandDataImpl;
-
-/**
- * @author w.klaas
- *
- */
-public class SPSCommandDataWait extends SPSCommandDataImpl {
-
-  private static final long[] WAIT_TIMES = new long[] {
-      // @formatter-off
-      1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 30000, 60000
-      // @formatter-on
-  };
-
-  private static final String[] WAIT_NAMES = new String[] {
-      // @formatter-off
-      "1ms", "2ms", "5ms", "10ms", "20ms", "50ms", "100ms", "200ms", "500ms", "1s", "2s", "5s", "10s", "20s", "30s",
-      "60s"
-      // @formatter-on
-  };
-
-  static String getName(int i) {
-    return String.format("Wait %s", WAIT_NAMES[i]);
-  }
-
-  static String getMnemonic(int i) {
-    return String.format("D", WAIT_NAMES[i]).toUpperCase();
-  }
-
-  /*
-   * (non-Javadoc)
-   * 
-   * @see
-   * de.mcs.tools.sps.SPSCommandDataImpl#doWork(de.mcs.tools.sps.EmulatorInput,
-   * de.mcs.tools.sps.EmulatorInternals)
-   */
-  @Override
-  public EmulatorOutput doWork(EmulatorInput input, EmulatorInternals internals, EmulatorOutput output) {
-    byte data = getData();
-    if ((data >= 0) && (data < 16)) {
-      try {
-        internals.setDelay(WAIT_TIMES[data]);
-        long delay = WAIT_TIMES[data];
-        if (delay <= 100) {
-          Thread.sleep(delay);
-        } else {
-          long count = delay / 100;
-          while (count > 0) {
-            count--;
-            Thread.sleep(100);
-            internals.setDelay(count * 100);
-          }
-        }
-      } catch (InterruptedException e) {
-        e.printStackTrace();
-      }
-    } else {
-      throw new IllegalArgumentException(String.format("Wait time %d illegal", data));
-    }
-    internals.incAddress(1);
-    return output;
-  }
-
-}

src/main/java/de/mcs/tools/sps/emulator/emulator/holtek/package-info.java

@@ -1,8 +0,0 @@
-/**
- * 
- */
-/**
- * @author w.klaas
- *
- */
-package de.mcs.tools.sps.emulator.emulator.holtek;

src/main/java/de/mcs/tools/sps/emulator/model/CommandModel.java

@@ -1,11 +1,12 @@
 package de.mcs.tools.sps.emulator.model;
 
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
 public class CommandModel {
 
-  private enum COMMAND {
+  public enum COMMAND {
     START, STOP, NEXT, RESET, NN
   };
 
@@ -18,7 +19,15 @@ public class CommandModel {
     evaluateAvailableCommands(getActualCommand());
   }
 
-  private void evaluateAvailableCommands(COMMAND command) {
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    b.append(String.format("%s:[available: [%s], actual: %s]", this.getClass().getSimpleName(),
+        Arrays.toString(availableCommands.toArray()), actualCommand.name()));
+    return b.toString();
+  }
+
+  public void evaluateAvailableCommands(COMMAND command) {
     getAvailableCommands().clear();
     switch (command) {
     case START:

src/main/java/de/mcs/tools/sps/emulator/model/InputModel.java

@@ -15,6 +15,15 @@ public class InputModel {
   byte rc1;
   byte rc2;
 
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    b.append(String.format(
+        "%s:[Din1: %s, Din2: %s, Din3: %s Din4: %s, SEL: %s, PRG: %s, adc1: %d, adc2: %d, rc1: %d, rc2: %d]",
+        this.getClass().getSimpleName(), input1, input2, input3, input4, sel, prg, adc1, adc2, rc1, rc2));
+    return b.toString();
+  }
+
   /**
    * @return the input1
    */

src/main/java/de/mcs/tools/sps/emulator/model/OutputModel.java

@@ -14,6 +14,15 @@ public class OutputModel {
 
   byte tone;
 
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    b.append(String.format(
+        "%s:[Dout1: %s, Dout2: %s, Dout3: %s Dout4: %s, pwm1: %d, pwm2: %d, servo1: %d, servo2: %d, tone: %d]",
+        this.getClass().getSimpleName(), output1, output2, output3, output4, pwm1, pwm2, servo1, servo2, tone));
+    return b.toString();
+  }
+
   /**
    * @return the output1
    */

src/main/java/de/mcs/tools/sps/emulator/model/ProgramModel.java

@@ -14,10 +14,21 @@ public class ProgramModel {
   private String hash;
   private byte[] bin;
   private boolean modified;
+  private int actualLine;
 
   public ProgramModel() {
     hardware = Hardware.HOLTEK;
     modified = false;
+    setActualLine(0);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    b.append(String.format("%s:[Hardware: %s, Hash: %s, modified: %s, actualLine: %d, Source: \"%s\", bin: %s ]",
+        this.getClass().getSimpleName(), hardware.name(), hash, modified, actualLine, (source != null) ? source[0] : "",
+        (bin != null)));
+    return b.toString();
   }
 
   /**
@@ -33,18 +44,6 @@ public class ProgramModel {
    */
   public void setSource(String[] source) {
     this.source = source;
-    String sourceStr = Arrays.toString(source);
-    try {
-      String newHash = SHA256Utils.shaBytesToString(SHA256Utils.shaBytes(sourceStr.getBytes("UTF-8")));
-      if (StringUtils.isEmpty(hash)) {
-        this.hash = newHash;
-        this.setModified(false);
-      } else {
-        this.setModified(true);
-      }
-    } catch (UnsupportedEncodingException e) {
-      e.printStackTrace();
-    }
   }
 
   /**
@@ -106,4 +105,37 @@ public class ProgramModel {
   public void setModified(boolean modified) {
     this.modified = modified;
   }
+
+  /**
+   * @return the actualLine
+   */
+  public int getActualLine() {
+    return actualLine;
+  }
+
+  /**
+   * @param actualLine
+   *          the actualLine to set
+   */
+  public void setActualLine(int actualLine) {
+    this.actualLine = actualLine;
+  }
+
+  public boolean rebuildHash() {
+    if ((source != null) && (source.length > 0)) {
+      String sourceStr = Arrays.toString(source);
+      try {
+        String newHash = SHA256Utils.shaBytesToString(SHA256Utils.shaBytes(sourceStr.getBytes("UTF-8")));
+        if (StringUtils.isEmpty(hash)) {
+          this.hash = newHash;
+          this.setModified(false);
+        } else {
+          this.setModified(true);
+        }
+      } catch (UnsupportedEncodingException e) {
+        e.printStackTrace();
+      }
+    }
+    return isModified();
+  }
 }

src/main/java/de/mcs/tools/sps/emulator/model/WebSessionModel.java

@@ -41,6 +41,14 @@ public class WebSessionModel {
     work = new WorkingModel();
   }
 
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    b.append(String.format("%s:[program: %s, command: %s, input: %s, output: %s, work: %s]",
+        this.getClass().getSimpleName(), program, command, input, output, work));
+    return b.toString();
+  }
+
   /**
    * @return the input
    */

src/main/java/de/mcs/tools/sps/emulator/model/WorkingModel.java

@@ -2,14 +2,26 @@ package de.mcs.tools.sps.emulator.model;
 
 public class WorkingModel {
 
-  byte registerA;
-  byte registerB;
-  byte registerC;
-  byte registerD;
-
-  byte page;
-  short raddress;
-  short address;
+  private byte registerA;
+  private byte registerB;
+  private byte registerC;
+  private byte registerD;
+  private byte registerE;
+  private byte registerF;
+
+  private byte page;
+  private short raddress;
+  private short address;
+
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    b.append(String.format(
+        "%s:[registerA: 0x%02x, registerB: 0x%02x, registerC: 0x%02x, registerD: 0x%02x, registerE: 0x%02x, registerF: 0x%02x, page: 0x%02x, address: 0x%04x, raddress: 0x%04x ]",
+        this.getClass().getSimpleName(), registerA, registerB, registerC, registerD, registerE, registerF, page,
+        address, raddress));
+    return b.toString();
+  }
 
   /**
    * @return the registerA
@@ -116,4 +128,34 @@ public class WorkingModel {
     this.address = address;
   }
 
+  /**
+   * @return the registerE
+   */
+  public byte getRegisterE() {
+    return registerE;
+  }
+
+  /**
+   * @param registerE
+   *          the registerE to set
+   */
+  public void setRegisterE(byte registerE) {
+    this.registerE = registerE;
+  }
+
+  /**
+   * @return the registerF
+   */
+  public byte getRegisterF() {
+    return registerF;
+  }
+
+  /**
+   * @param registerF
+   *          the registerF to set
+   */
+  public void setRegisterF(byte registerF) {
+    this.registerF = registerF;
+  }
+
 }

src/main/java/de/mcs/tools/sps/emulator/resources/EmulatorResource.java

@@ -1,10 +1,12 @@
 package de.mcs.tools.sps.emulator.resources;
 
 import javax.ws.rs.GET;
+import javax.ws.rs.POST;
 import javax.ws.rs.Path;
 import javax.ws.rs.Produces;
 import javax.ws.rs.core.MediaType;
 
+import de.mcs.tools.sps.emulator.model.CommandModel.COMMAND;
 import de.mcs.tools.sps.emulator.model.WebSessionModel;
 
 @Path("/emulator")
@@ -12,7 +14,15 @@ import de.mcs.tools.sps.emulator.model.WebSessionModel;
 public class EmulatorResource {
 
   @GET
-  public WebSessionModel getSession() {
+  public WebSessionModel newSession() {
     return new WebSessionModel();
   }
+
+  @POST
+  public WebSessionModel getSession(WebSessionModel model) {
+    model.getProgram().rebuildHash();
+    COMMAND actualCommand = model.getCommand().getActualCommand();
+    model.getCommand().evaluateAvailableCommands(actualCommand);
+    return model;
+  }
 }

src/test/java/de/mcs/tools/sps/emulator/model/testWebSessionModel.java

@@ -62,4 +62,9 @@ class testWebSessionModel {
     System.out.printf("size: %d\r\n", newModelJson.length());
   }
 
+  @Test
+  void testme() {
+    int value = 2;
+    System.out.printf("0x%04x \r\n", value);
+  }
 }