zoriya/ComSquare
1
0
Fork 0
mirror of https://github.com/zoriya/ComSquare.git synced 2025-12-05 23:06:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixing bugs with the DMA

Browse Source
This commit is contained in:
Zoe Roux
2021-02-01 19:21:18 +01:00
parent fdfa0fc0d6
commit ced42a3bf9
11 changed files with 141 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -103,7 +103,7 @@ add_executable(unit_tests
sources/PPU/Background.hpp
sources/CPU/DMA/DMA.cpp
sources/CPU/DMA/DMA.hpp
)
tests/CPU/testDMA.cpp)
# include criterion & coverage
target_link_libraries(unit_tests criterion -lgcov)

2
Doxyfile
View File

@@ -2431,7 +2431,7 @@ DIRECTORY_GRAPH = YES
# The default value is: png.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_IMAGE_FORMAT = png
DOT_IMAGE_FORMAT = svg
# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.

1
sources/CPU/CPU.hpp
View File

@@ -12,7 +12,6 @@
#include "../Memory/AMemory.hpp"
#include "Instruction.hpp"
#include "DMA/DMA.hpp"
#include "../Debugger/RegisterViewer.hpp"
namespace ComSquare::CPU
{

9
sources/CPU/DMA/DMA.cpp
View File

@@ -72,13 +72,13 @@ namespace ComSquare::CPU
if (this->_port == 0x80) {
auto accessor = this->_bus->getAccessor(aAddress);
if (accessor && accessor->getComponent() == WRam) {
if (this->_controlRegister.direction == AToB)
if (this->_controlRegister.direction == AtoB)
return 8;
this->_bus->write(aAddress, 0xFF);
return 4;
}
}
if (this->_controlRegister.direction == AToB) {
if (this->_controlRegister.direction == AtoB) {
uint8_t data = this->_bus->read(aAddress);
this->_bus->write(bAddress, data);
} else {
@@ -88,11 +88,10 @@ namespace ComSquare::CPU
return 8;
}
uint8_t DMA::run(unsigned int maxCycles)
unsigned DMA::run(unsigned int maxCycles)
{
unsigned cycles = 8;
int i = 0;
std::cout << "Starting a DMA transfer" << std::endl;
do {
cycles += this->_writeOneByte(this->_aAddress.raw, 0x2100 | (this->_port + this->_getModeOffset(i)));
@@ -100,7 +99,7 @@ namespace ComSquare::CPU
this->_aAddress.page += this->_controlRegister.increment ? -1 : 1;
this->_count.raw--;
i++;
} while (this->_count.raw > 0);
} while (this->_count.raw > 0 && this->enabled);
this->enabled = false;
return cycles;
}

45
sources/CPU/DMA/DMA.hpp
View File

@@ -9,31 +9,34 @@
#include <memory>
#include "../../Models/Int24.hpp"
#include "../../Memory/MemoryBus.hpp"
#include "../../Debugger/RegisterViewer.hpp"
#ifdef DEBUGGER_ENABLED
#include "../../Debugger/RegisterViewer.hpp"
#endif
namespace ComSquare::CPU
{
//! @brief The first three bytes of the DMA's control register. Used to tell how many bytes/registers there is.
enum DMAMode {
//! @brief 1 byte is transferred to 1 register (write once)
OneToOne = 0b000,
//! @brief 2 byte is transferred to 2 register (write once)
TwoToTwo = 0b001,
//! @brief 2 byte is transferred to 1 register (write twice)
TwoToOne = 0b010,
//! @brief 4 byte is transferred to 2 register (write twice)
FourToTwo = 0b011,
//! @brief 4 byte is transferred to 4 register (write once)
FourToFour = 0b100
};
enum Direction {
AToB,
BToA
};
//! @brief Class handling all DMA/HDMA transfers (Direct Memory Access or H-Blank Direct Memory Access)
class DMA {
public:
//! @brief The first three bytes of the DMA's control register. Used to tell how many bytes/registers there is.
enum DMAMode {
//! @brief 1 byte is transferred to 1 register (write once)
OneToOne = 0b000,
//! @brief 2 byte is transferred to 2 register (write once)
TwoToTwo = 0b001,
//! @brief 2 byte is transferred to 1 register (write twice)
TwoToOne = 0b010,
//! @brief 4 byte is transferred to 2 register (write twice)
FourToTwo = 0b011,
//! @brief 4 byte is transferred to 4 register (write once)
FourToFour = 0b100
};
enum Direction {
AtoB,
BtoA
};
private:
//! @brief Write one byte using the A address, the port and the _direction. Handle special cases where no write occurs.
//! @return The number of cycles used.
@@ -92,7 +95,7 @@ namespace ComSquare::CPU
//! @brief Run the DMA for x cycles
//! @param cycles The maximum number of cycles this DMA should run.
//! @return the number of cycles taken
uint8_t run(unsigned cycles);
unsigned run(unsigned cycles);
DMA() = default;
DMA(std::shared_ptr<Memory::MemoryBus> bus);

5
sources/Debugger/RegisterViewer.cpp
View File

@@ -24,7 +24,8 @@ namespace ComSquare::Debugger
void RegisterViewer::_setupUi()
{
for (int i = 0; i < 8; i++) {
int i = 0;
// for (int i = 0; i < 8; i++) {
RegistersViewerModel *model = new RegistersViewerModel(this->_snes);
model->addRegister(Register(0x420B, ":0", "Enabled", [i](SNES &snes) {
return snes.cpu->_dmaChannels[i].enabled;
@@ -52,7 +53,7 @@ namespace ComSquare::Debugger
}, nullptr, EightBits));
this->_ui.dmaChannel1->setModel(model);
this->_models.push_back(model);
}
// }
}
void RegisterViewer::focus()

4
sources/PPU/PPU.cpp
View File

@@ -126,7 +126,7 @@ namespace ComSquare::PPU
//std::cout << "vmdatal" << std::endl;
if (!this->_registers._inidisp.fblank) {
this->_registers._vmdata.vmdatal = data;
this->vram->write_internal(getVramAddress(), this->_registers._vmdata.vmdatal);
this->vram->write_internal(getVramAddress(), data);
}
if (!this->_registers._vmain.incrementMode)
this->_registers._vmadd.vmadd += this->_registers._incrementAmount;
@@ -135,7 +135,7 @@ namespace ComSquare::PPU
//std::cout << "vmdatah" << std::endl;
if (!this->_registers._inidisp.fblank) {
this->_registers._vmdata.vmdatah = data;
this->vram->write_internal(getVramAddress(), this->_registers._vmdata.vmdatah);
this->vram->write_internal(getVramAddress(), data);
}
if (this->_registers._vmain.incrementMode)
this->_registers._vmadd.vmadd += this->_registers._incrementAmount;

10
sources/SNES.hpp
View File

@@ -12,12 +12,12 @@
#include "PPU/PPU.hpp"
#include "APU/APU.hpp"
#include "Renderer/IRenderer.hpp"
#ifdef DEBUGGER_ENABLED
#include "Debugger/MemoryViewer.hpp"
#include "Debugger/HeaderViewer.hpp"
#include "Debugger/CGramDebug.hpp"
#include "Debugger/RegisterViewer.hpp"
#ifdef DEBUGGER_ENABLED
#include "Debugger/MemoryViewer.hpp"
#include "Debugger/HeaderViewer.hpp"
#include "Debugger/CGramDebug.hpp"
#include "Debugger/RegisterViewer.hpp"
#endif
namespace ComSquare

70
tests/CPU/testDMA.cpp Normal file
View File

@@ -0,0 +1,70 @@
//
// Created by anonymus-raccoon on 2/1/21.
//
#include <criterion/criterion.h>
#include <bitset>
#include "../tests.hpp"
using namespace ComSquare;
//Test(DMA, RomToVRAM)
//{
// Init()
// snes.cartridge->_size = 4000000;
// snes.cartridge->_data = new uint8_t[snes.cartridge->_size];
// for(unsigned i = 0xBE00, j = 0; i < 0xBE00 + 0x800; i++, j++)
// snes.cartridge->_data[i] = j;
//
// // Transferring $800 bytes from ROM ($13BE00) to VRam ($2000) via DMA channel 0
//
// // Setting VRam address (since this is an indirect write)
// snes.bus->write(0x2117, 0x20);
// snes.bus->write(0x2116, 0);
//
// snes.bus->write(0x4301, 0x18);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._port, 0x18, "The dma's b port was $%x but it should have been $18.", snes.cpu->_dmaChannels[0]._port);
// snes.bus->write(0x4304, 0x13);
// snes.bus->write(0x4303, 0xBE);
// snes.bus->write(0x4302, 0x00);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._aAddress.raw, 0x13BE00, "The dma's a address was $%x but it should have been $13BE00.", snes.cpu->_dmaChannels[0]._aAddress.raw);
// snes.bus->write(0x4306, 0x08);
// snes.bus->write(0x4305, 0);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._count.raw, 0x0800, "The dma's count was $%x but it should have been $0800.", snes.cpu->_dmaChannels[0]._count.raw);
// snes.bus->write(0x4300, 1);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.direction, CPU::DMA::AtoB, "Direction should have been 0 (A to B) but it was %x.", snes.cpu->_dmaChannels[0]._controlRegister.direction);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister._, 0, "The unused byte should be 0.");
// cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.increment, 0, "The increment byte should be set to 0.");
// cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.fixed, 0, "The increment byte should be set to 0.");
// cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.mode, CPU::DMA::TwoToTwo, "The DMA mode should have been TwoToTwo (%%001) but it was) $%x", snes.cpu->_dmaChannels[0]._controlRegister.mode);
// cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, false, "The DMA channel should be disabled.");
// // Enabling DMA's channel 0
// snes.bus->write(0x420B, 1);
// cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, true, "The DMA channel should be enabled.");
// // TODO There is an overhead of 12-24 cycles for the whole transfer. How should I know how many cycles there is?
// auto cycles = snes.cpu->_dmaChannels[0].run(1000000);
// cr_assert_eq(cycles, 8 + 8 * 0x800, "The dma should take $4008 cycles but it took $%x.", cycles);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._count.raw, 0, "The dma count should be 0 but it was $%x.", snes.cpu->_dmaChannels[0]._count.raw);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._aAddress.raw, 0x13C600, "The dma count should be $13C600 but it was $%x.", snes.cpu->_dmaChannels[0]._aAddress.raw);
// cr_assert_eq(snes.cpu->_dmaChannels[0]._port, 0x18, "The dma count should be $18 but it was $%x.", snes.cpu->_dmaChannels[0]._port);
// cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0x2400, "The vram address should be $2400 but it was %x.", snes.ppu->_registers._vmadd.vmadd);
// for(unsigned i = 0x2000, j = 0; i < 0x2000 + 0x800; i++, j++)
// std::cout << std::hex << i << ": " << (unsigned)snes.ppu->vram->_data[i] << std::endl;
//// cr_assert_eq(snes.ppu->vram->_data[i], j, "The memory at %x should be %x but it was %x", i, (uint16_t)j, snes.ppu->vram->_data[i]);
//}
Test(DMA, VramWrite)
{
Init()
snes.bus->write(0x2117, 0x20);
snes.bus->write(0x2116, 0x0);
for (unsigned i = 0; i < 0x400; i++) {
snes.bus->write(0x2119, i >> 8);
snes.bus->write(0x2118, i);
cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0x2001 + i, "The vram address was %x but it should have been %x", snes.ppu->_registers._vmadd.vmadd, 0x2001 + i);
}
for(unsigned i = 0; i < 0x400; i++) {
uint16_t value = snes.ppu->vram->_data[0x2000 + i * 2] | (snes.ppu->vram->_data[0x2000 + i * 2 + 1] << 8);
std::cout << std::hex << 0x2000 + i << ": " << value << std::endl;
// cr_assert_eq(value, (uint16_t)i, "The memory at %x should be %x but it was %x", 0x2000 + i, (uint16_t)i, value);
}
}

65
tests/CPU/testInternal.cpp
View File

@@ -3,13 +3,8 @@
//
#include <criterion/criterion.h>
#include <iostream>
#include <bitset>
#include "../tests.hpp"
#include "../../sources/SNES.hpp"
#include "../../sources/Memory/MemoryBus.hpp"
#include "../../sources/CPU/CPU.hpp"
using namespace ComSquare;
Test(SEP, setall)
@@ -196,8 +191,8 @@ Test(PLA, basic)
snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.a;
cr_assert_eq(data, 0x7BCD, "The accumulator should be 0x7BCD but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -211,8 +206,8 @@ Test(PLA, zero)
snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.a;
cr_assert_eq(data, 0x0000, "The accumulator should be 0x0000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -226,8 +221,8 @@ Test(PLA, negative)
snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.a;
cr_assert_eq(data, 0xA000, "The accumulator should be 0xA000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -241,8 +236,8 @@ Test(PLX, basic)
snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.x;
cr_assert_eq(data, 0x7BCD, "The X register should be 0x7BCD but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -256,8 +251,8 @@ Test(PLX, zero)
snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.x;
cr_assert_eq(data, 0x0000, "The x register should be 0x0000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -271,8 +266,8 @@ Test(PLX, negative)
snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.x;
cr_assert_eq(data, 0xA000, "The x register should be 0xA000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -286,8 +281,8 @@ Test(PLY, basic)
snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.y;
cr_assert_eq(data, 0x7BCD, "The Y register should be 0x7BCD but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -301,8 +296,8 @@ Test(PLY, zero)
snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.y;
cr_assert_eq(data, 0x0000, "The y register should be 0x0000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -316,8 +311,8 @@ Test(PLY, negative)
snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.y;
cr_assert_eq(data, 0xA000, "The y register should be 0xA000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -330,8 +325,8 @@ Test(PLD, basic)
snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.d;
cr_assert_eq(data, 0x7BCD, "The D register should be 0x7BCD but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -344,8 +339,8 @@ Test(PLD, zero)
snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.d;
cr_assert_eq(data, 0x0000, "The d register should be 0x0000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -358,8 +353,8 @@ Test(PLD, negative)
snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.d;
cr_assert_eq(data, 0xA000, "The D register should be 0xA000 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s);
}
@@ -371,8 +366,8 @@ Test(PLB, basic)
snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.dbr;
cr_assert_eq(data, 0x7D, "The DBR should be 0x7D but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
}
@@ -384,8 +379,8 @@ Test(PLB, zero)
snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.dbr;
cr_assert_eq(data, 0x00, "The dbr should be 0x00 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
}
@@ -397,8 +392,8 @@ Test(PLB, negative)
snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied);
auto data = snes.cpu->_registers.dbr;
cr_assert_eq(data, 0xA0, "The D register should be 0xA0 but it was %x", data);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.", snes.cpu->_registers.p.n);
cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.");
cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
}

2
ui/ui_cpuView.h
View File

@@ -1,7 +1,7 @@
/********************************************************************************
** Form generated from reading UI file 'cpuView.ui'
**
** Created by: Qt User Interface Compiler version 5.14.2
** Created by: Qt User Interface Compiler version 5.15.2
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/