implemented keypad

CMakeLists.txt

@@ -5,5 +5,5 @@ SET(CMAKE_BUILD_TYPE Debug)
 add_subdirectory(submodules/sdl2)
 
 SET(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-add_executable(chocochip8 main.cpp Interpreter.cpp DisplaySDL.cpp BuzzerSDL.cpp)
+add_executable(chocochip8 main.cpp Interpreter.cpp DisplaySDL.cpp BuzzerSDL.cpp CountdownTimerSDL.cpp KeypadSDL.cpp)
 target_link_libraries(chocochip8 SDL2::SDL2-static)

CountdownTimerSDL.cpp

@@ -0,0 +1,18 @@
+#include "CountdownTimerSDL.hpp"
+
+CountdownTimerSDL::CountdownTimerSDL(unsigned frequency):
+  mDesiredFrequency{frequency},
+  mSDLFrequency{SDL_GetPerformanceFrequency()},
+  mStartTime{0},
+  mStartValue{0} {}
+
+void CountdownTimerSDL::set(unsigned value) {
+  mStartTime = SDL_GetPerformanceCounter();
+  mStartValue = value;
+}
+
+unsigned CountdownTimerSDL::get() const {
+  Uint64 elapsedTime = SDL_GetPerformanceCounter() - mStartTime;
+  Uint64 elapsedTicks = (elapsedTime * mDesiredFrequency) / mSDLFrequency;
+  return elapsedTicks >= mStartValue ? 0 : mStartValue - elapsedTicks;
+}

CountdownTimerSDL.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <SDL2/SDL_timer.h>
+
+#include "Peripherals.hpp"
+
+class CountdownTimerSDL : public chocochip8::CountdownTimer {
+public:
+  CountdownTimerSDL(unsigned frequency); 
+  void set(unsigned value) override;
+  unsigned get() const override;
+private:
+  const Uint64 mDesiredFrequency;
+  const Uint64 mSDLFrequency;
+  Uint64 mStartTime;
+  Uint64 mStartValue;
+};

Interpreter.cpp

@@ -44,13 +44,14 @@ constexpr uint8_t gcvLowResFontData[80] = {
   0xF0, 0x80, 0xF0, 0x80, 0x80
 };
 
-Interpreter::Interpreter(unsigned ticksPerSecond, Display &display, Buzzer &buzzer, Keypad &keypad):
+Interpreter::Interpreter(Display &display, Buzzer &buzzer, Keypad &keypad, CountdownTimer &delayTimer, CountdownTimer &soundTimer):
   mvMemory(scMemorySize),
   mCallStack{},
   mrDisplay{display},
   mrBuzzer{buzzer},
   mrKeypad{keypad},
-  mcTicksPerSecond{ticksPerSecond},
+  mrDelayTimer(delayTimer),
+  mrSoundTimer(soundTimer),
   mvSpecialReg{},
   mvReg{},
   mIsHighResMode{false} {
@@ -138,21 +139,45 @@ void Interpreter::tick() {
   case 0xD000: // DXYN - draw
     executeDraw(mvReg[iRegDst], mvReg[iRegSrc], opcode);
     break;
-  case 0xE000: // EX9E, EXA1 - keypad access
+  case 0xE000: // keypad access
+    switch(inst & 0xF0FF) {
+    case 0xE09E: // EX9E - skip if key pressed
+      if(mrKeypad.isKeyPressed(mvReg[iRegDst])) {
+        mvSpecialReg[SR_PC] += 2;
+      }
+      break;
+    case 0xE0A1: // EXA1 - skip if key not pressed
+      if(!mrKeypad.isKeyPressed(mvReg[iRegDst])) {
+        mvSpecialReg[SR_PC] += 2;
+      }
+      break;
+    default:
+      throw std::invalid_argument("not implemented");
+      break;
+    }
     break;
   case 0xF000: // several unique instructions
     switch(inst & 0xF0FF) {
     case 0xF007: // FX07 - read timer register
-      mvReg[iRegDst] = (mvSpecialReg[SR_T1] * scTimerFreq + (mcTicksPerSecond - 1)) / mcTicksPerSecond;
+      mvReg[iRegDst] = mrDelayTimer.get();
+      break;
+    case 0xF00A: // FX0A - wait for a keypress
+      mvSpecialReg[SR_PC] -= 2;
+      for(int i = KEY_0; i < KEY_0 + KEY_COUNT; i++) {
+        if(mrKeypad.isKeyPressed(i)) {
+          mvSpecialReg[SR_PC] += 2;
+          break;
+        }
+      }
       break;
     case 0xF015: // FX15 - set timer register
-      mvSpecialReg[SR_T1] = (mcTicksPerSecond * mvReg[iRegDst]) / scTimerFreq;
+      mrDelayTimer.set(mvReg[iRegDst]);
       break;
     case 0xF018: // FX18 - set sound timer register
-      if(mvSpecialReg[SR_T2] == 0 && mvReg[iRegDst] != 0) {
+      if(mvReg[iRegDst] != 0) {
         mrBuzzer.on();
       }
-      mvSpecialReg[SR_T2] = (mcTicksPerSecond * mvReg[iRegDst]) / scTimerFreq;
+      mrSoundTimer.set(mvReg[iRegDst]);
       break;
     case 0xF01E: // FX1E - add to I
       mvSpecialReg[SR_I] += mvReg[iRegDst];
@@ -182,17 +207,10 @@ void Interpreter::tick() {
     break;
   }
 
-  // decrement timers
+  if(mrSoundTimer.get() == 0) {
-  if(mvSpecialReg[SR_T1] > 0) {
-    mvSpecialReg[SR_T1] -= 1;
-  }
-  if(mvSpecialReg[SR_T2] > 0) {
-    mvSpecialReg[SR_T2] -= 1;
-    if(mvSpecialReg[SR_T2] == 0) {
     mrBuzzer.off();
   }
 }
-}
 
 void Interpreter::loadProgram(char const* data, size_t count, size_t where) {
   if(where + count > scMemorySize) {

Interpreter.hpp

@@ -16,7 +16,6 @@ private:
 public:
   constexpr static sreg_t scLowRestFontAddr = 0x0000;
   constexpr static sreg_t scResetVector = 0x0200;
-  constexpr static sreg_t scTimerFreq = 60;
   constexpr static size_t scMemorySize = 4096;
 
   enum {
@@ -26,7 +25,7 @@ public:
   };
 
   enum {
-    SR_PC, SR_I, SR_T1, SR_T2,
+    SR_PC, SR_I, /*SR_T1, SR_T2,*/
     SR_COUNT
   };
 
@@ -35,7 +34,7 @@ public:
   };
 
 public:
-  Interpreter(unsigned ticksPerSecond, Display &display, Buzzer &buzzer, Keypad &keypad);
+  Interpreter(Display &display, Buzzer &buzzer, Keypad &keypad, CountdownTimer &delayTimer, CountdownTimer &soundTimer);
   void tick();
   void loadProgram(char const* data, size_t count, size_t where = scResetVector);
 
@@ -49,7 +48,8 @@ private:
   Display &mrDisplay;
   Buzzer &mrBuzzer;
   Keypad &mrKeypad;
-  const unsigned mcTicksPerSecond;
+  CountdownTimer &mrDelayTimer;
+  CountdownTimer &mrSoundTimer;
   sreg_t mvSpecialReg[SR_COUNT];
   reg_t mvReg[R_COUNT];
   bool mIsHighResMode;

KeypadSDL.cpp

@@ -0,0 +1,36 @@
+#include "KeypadSDL.hpp"
+
+bool KeypadSDL::isKeyPressed(int key) const {
+  return mvKeyDown.at(key);
+}
+
+void KeypadSDL::processEvent(SDL_Event &e) {
+  auto keymap = [](int sdlKeyCode) -> int {
+    switch(sdlKeyCode) {
+      case SDLK_1: return chocochip8::KEY_1;
+      case SDLK_2: return chocochip8::KEY_2;
+      case SDLK_3: return chocochip8::KEY_3; 
+      case SDLK_4: return chocochip8::KEY_C;
+      case SDLK_q: return chocochip8::KEY_4;
+      case SDLK_w: return chocochip8::KEY_5;
+      case SDLK_e: return chocochip8::KEY_6;
+      case SDLK_r: return chocochip8::KEY_D;
+      case SDLK_a: return chocochip8::KEY_7;
+      case SDLK_s: return chocochip8::KEY_8;
+      case SDLK_d: return chocochip8::KEY_9;
+      case SDLK_f: return chocochip8::KEY_E;
+      case SDLK_z: return chocochip8::KEY_A;
+      case SDLK_x: return chocochip8::KEY_0;
+      case SDLK_c: return chocochip8::KEY_B;
+      case SDLK_v: return chocochip8::KEY_F;
+      default    : return -1;
+    }
+  };
+
+  if(e.type == SDL_KEYUP || e.type == SDL_KEYDOWN) {
+    int k = keymap(e.key.keysym.sym);
+    if(k != -1) {
+      mvKeyDown[k] = (e.type == SDL_KEYDOWN);
+    }
+  }
+}

KeypadSDL.hpp

@@ -0,0 +1,12 @@
+#include "Peripherals.hpp"
+
+#include <SDL2/SDL_events.h>
+#include <array>
+
+class KeypadSDL : public chocochip8::Keypad {
+public:
+  bool isKeyPressed(int key) const override;
+  void processEvent(SDL_Event &e);
+private:
+  std::array<bool, chocochip8::KEY_COUNT> mvKeyDown;
+};

Peripherals.hpp

@@ -8,11 +8,12 @@ namespace chocochip8 {
   constexpr size_t gcHeight = 64;
   using Scanline = std::bitset<gcWidth>;
 
-  enum class Key {
+  enum {
     KEY_0, KEY_1, KEY_2, KEY_3,
     KEY_4, KEY_5, KEY_6, KEY_7,
     KEY_8, KEY_9, KEY_A, KEY_B,
-    KEY_C, KEY_D, KEY_E, KEY_F
+    KEY_C, KEY_D, KEY_E, KEY_F,
+    KEY_COUNT
   };
 
   class Display {
@@ -32,7 +33,14 @@ namespace chocochip8 {
   class Keypad {
   public:
     virtual ~Keypad() = default;
-    virtual bool isKeyPressed(Key key) = 0;
+    virtual bool isKeyPressed(int key) const = 0;
+  };
+
+  class CountdownTimer {
+  public:
+    virtual ~CountdownTimer() = default;
+    virtual void set(unsigned value) = 0;
+    virtual unsigned get() const = 0;
   };
 
 }; // namespace chocochip8

main.cpp

@@ -6,11 +6,10 @@
 #include <SDL2/SDL.h>
 
 #include "BuzzerSDL.hpp"
+#include "CountdownTimerSDL.hpp"
 #include "DisplaySDL.hpp"
+#include "KeypadSDL.hpp"
 #include "Interpreter.hpp"
-#include "Peripherals.hpp"
-#include "SDL2/SDL_events.h"
-#include "SDL2/SDL_timer.h"
 
 int main(int argc, char* argv[]) {
   if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
@@ -18,14 +17,14 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
-  class TestKeypad : public chocochip8::Keypad {
-    bool isKeyPressed(chocochip8::Key) override { return false; }
-  };
-
   BuzzerSDL buzzer(440);
-  DisplaySDL display(1280, 640);
+  int N = 4;
-  TestKeypad keypad;
+  DisplaySDL display(128*N, 64*N);
-  chocochip8::Interpreter chip8(1000, display, buzzer, keypad);
+  KeypadSDL keypad;
+  CountdownTimerSDL delayTimer(60);
+  CountdownTimerSDL soundTimer(60);
+  CountdownTimerSDL displayTimer(60);
+  chocochip8::Interpreter chip8(display, buzzer, keypad, delayTimer, soundTimer);
 
   auto rom = std::vector<char>();
   auto romfile = std::ifstream(argv[1] != NULL ? argv[1] : "/dev/stdin", std::ios_base::in | std::ios_base::binary);
@@ -38,25 +37,22 @@ int main(int argc, char* argv[]) {
 
   SDL_Event event;
   bool done = false;
-  Uint64 start, end;
-  start = SDL_GetTicks64();
   while(!done) {
     while(SDL_PollEvent(&event)) {
       if(event.type == SDL_QUIT) {
         done = true;
+      } else {
+        keypad.processEvent(event);
       }
     }
     chip8.tick();
+    if(displayTimer.get() == 0) {
       display.updateWindow();
-    SDL_Delay(1);
+      displayTimer.set(1);
-    end = SDL_GetTicks64();
+    }
-    if(end - start > 3) 
-      std::cout << "Frame took too long: " << end - start << "\n";
-    start = end;
   }
   
   buzzer.off();
   SDL_Quit();
   return 0;
 }
-