03 Oct 2018
-
Disassembler
An initial class to disassemble and perform a simple trace of the program flow to discriminate between instructions and data.
- Chip8 and SChip8 correctly clear flag during DRAW
26 Sept 2018
- SChip8
** Storing and Loading from HP registers implemented.
-
Chip8 correctly sets the not borrow register (0x0F) when subtracting equal values
-
Buffer overflow flag is set when adding register to address pointer
13 Sept 2018
- SChip8
** Most operations implemented. Not sure what to do with exit and load_register_rpl and dump_register_rpl, as these are dependent on HP-48 platform.
-
General cleanup of the reop
-
Memory
** Added SuperChip (8x10) fonts to memory
- SimpleSDLGui
** Changed from key events to checking keyboard state, to try to remove or minimize repeated keypresses.
- Chip8 correctly stored digits when store_bcd operation is performed.
12 Sept 2018
-
SChip8
A subclass of Chip8 that implements the extended instruction set from SuperChip-8.
-
Created a Revision History document (History.md) to keep track of version number and major changes.
-
Display
** Added methods to scroll the screen down, left and right.
- SimpleSDLGui
** Added frame for display screen, run and step buttons, and program name.
** Allow for changing screen resolution during runtime with up/down arrows.
11 Sept 2018
-
SimpleSDLGui
A simple GUI based on the SDL2 library. Screen updates are much more responsive, and users use the keyboard directly, as opposed to clicking the keys in the GUI.
- Display
** Display can now have arbitrary dimensions, enabiling other Chip-8 like implementations.
** Can dynamically change the Display dimensions during runtime.
10 Sept 2018
- Completely replaced switch / case method of decoding operations with a simpler method of properly masking the opcode and looking up the corresponding operation in the opcode map.
8 Sept 2018
-
Implement an operation lookup map in Chip8 class, which maps opcodes to method pointers.
-
Modified methods to have a common signature. All methods now take the address, two register numbers, and a value as arguments. This greatly simplifies the decoding aspect of the chip.
7 Sept 2018
- Organized code base into core and view subdirectories, separating the core computing components from the various GUIs.
13 July 2018
Major Revision change. Initial fully functional release. Chip-8 programs appear to work correctly.
-
Clock
Moved the clock to a separate class. The purpose of this class is to run clock(s) in a separate thread, and to trigger cycles and sound / delay timer countdowns separately, as opposed to having the GUI do it.
-
GtkmmGui
Converted the GladeGui to use the gtkmm library, and object oriented version of gtkmm.
- Chip8
** Added code to cycle the delay and sound timer.
- GtkmmGui
** Maintain and updates the content of the stack on the GUI.
-
Separated code base into src and include directories.
-
Refined the update methods of the ChipListener.
-
Moved the calls to the update methods in the Chip8 class to specific operations, which removed unneeded calls to the GUI when things do not change.
27 April 2018
- GladeGui
** Implemented a file dialog box for loading programs arbitrarily, rather than being hardcoded in the main program.
- Fixed the delay timer and sound timer datasets (converted from 8-bit to 16-bit).
26 April 2018
- Fixed a drawing bug in the Display class.
19 April 2018
-
ChipListener
An interface to be implemented by GUIs to allow the chip to communicate changes without needed to know a specific GUI setup. Basically used to fully decouple the GUI from the Computer.
- GladeGui
** Implemented needed update methods to work with the ChipListener interface
- Chip8
** Allow adding a ChipListener object.
** Calls the update methods of the ChipListener after each compute cycle.
13 April 2018
-
Computer
A simple class used to encapsulate all of the components in the system (chip, memory, keyboard, display), manage interaction between these, and act as a single interface to GUIs.
- Chip8
** Added methods to interact with the Keyboard class
- Memory
** Implemented a method to provide a pretty string representation of memory contents (complete with addresses every N bytes).
- GladeGui
** Added widgets and callbacks to interact with the Keyboard class, so that user can press the keys.
** Added listener methods to update memory, program counter, stack pointer, and address register widgets, in order to work towards an MPC framework.
-
Started using CMake as the build system, and created appropriate directory structure.
-
Downloaded and added a whole lot of Chip-8 and Chip-48 programs to the repo.
- Moved all the computer components (Chip, Memory, Display, Keyboard) into the GladeGui class, rather than the Chip class, to avoid needless
12 April 2018
-
GladeGui
A Class based on the GtkGui, except that the GUI is defined in a glade file in order to decouple the interface design and operation.
- GladeGui
** Added a Run button, so programs can run continuously rather than having the user simply step through them.
** Added a widget to draw the display to the GUI.
- Fixed issue with drawing too many lines with the draw operation. Was passing a byte (up to 256 lines) instead of a nybble (up to 16 lines) to the operation.
05 April 2018
Minor Revision change. The core functionality of the emulator can be demonstrated. Sound is currently missing, and there are several bugs and architectural changes to be made.
- Chip8
** Implemented the draw, skip key pressed, skip key not pressed, get key, set address sprite, and store bcd operations
- Diplay
** Added methods to get and set individual pixels, write a line of 8 pixels (for the draw operation), and dump the contents of the display to the console.
- Keyboard
** Implemented methods to check if a key is pressed, and to indicate when a key is pressed and released.
- Memory
** Implmented methods to load sprites (16 hex digits 0-F), and to get the address of specific sprites.
- GtkGui
** Create a window with widgets for displaying register values, program counter and stack pointer
** Correctly destroys window when closed
** Button to perform a single cycle on the chip
04 April 2018
-
GtkGui
A simple GUI implemented using GTK.
- Chip8
** Added needed getters for register values, address, program counter and stack pointer
27 March 2018
- Memory
** Implemented code to load ROM files into memory.
** Added code to Memory class to read and write to memory, dump the contents of memroy to the console, and identify where ROM and display memory is located.
- Chip8
** Implemented a basic decoder using switch / case blocks.
** Implemented most of the microprocessor operations. Still need to implement draw, skip key pressed, skip key not pressed, get key, set address sprite, store bcd
** Implement ability to simulate a single cycle (instruction fetch, instruction decode, execution). Can cycle through the maze program (without display).
- Chip8
** Replaced hard-coded call stack size with defined constant
26 March 2018
Initial Version, consisting primarily of skeleton code for core components. Created a main program to run and test the emulator.
-
Chip8
The main class to simulate microcontroller.
-
Keyboard
An abstraction of keyboard functions.
-
Memory
An abstraction of memory.
-
Display
An abstraction of the display or screen.