Cool_Tools/bemanitools
1
0
Fork 0
mirror of https://github.com/djhackersdev/bemanitools.git synced 2025-02-17 19:19:16 +01:00
Code Releases Activity

feat(p3io-ddr-tool): CLI tool to test and debug a real DDR P3IO

Browse Source 
Extensive tool with subcommands to trigger the various
P3IO commands and run the P3IO + EXTIO DDR hardware
combo with a hardware test menu.
This commit is contained in:
icex2 2023-06-11 17:18:22 +02:00 committed by icex2
parent 23ca366f78
commit 3a89502498
5 changed files with 1208 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Module.mk
View File

@ -171,6 +171,7 @@ include src/main/mm/Module.mk
include src/main/p3io/Module.mk include src/main/p3io/Module.mk
include src/main/p3iodrv/Module.mk include src/main/p3iodrv/Module.mk
include src/main/p3ioemu/Module.mk include src/main/p3ioemu/Module.mk
include src/main/p3io-ddr-tool/Module.mk
include src/main/p4iodrv/Module.mk include src/main/p4iodrv/Module.mk
include src/main/p4ioemu/Module.mk include src/main/p4ioemu/Module.mk
include src/main/popnhook-util/Module.mk include src/main/popnhook-util/Module.mk

16
src/main/p3io-ddr-tool/Module.mk Normal file
View File

@ -0,0 +1,16 @@
exes += p3io-ddr-tool \
ldflags_p3io-ddr-tool := \
-lsetupapi \
libs_p3io-ddr-tool := \
extiodrv \
extio \
p3iodrv \
p3io \
hook \
util \
src_p3io-ddr-tool := \
main.c \
mode-test.c \

774
src/main/p3io-ddr-tool/main.c Normal file
View File

@ -0,0 +1,774 @@
#define LOG_MODULE "p3io-ddr-tool"
#include <windows.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "extiodrv/extio.h"
#include "p3io/ddr.h"
#include "p3iodrv/ddr.h"
#include "p3iodrv/device.h"
#include "util/log.h"
#include "util/thread.h"
#include "mode-test.h"
enum mode {
MODE_INVALID = 0,
MODE_SCAN = 1,
MODE_VERP3IO = 2,
MODE_INIT = 3,
MODE_VERDDR = 4,
MODE_WATCHDOGON = 5,
MODE_WATCHDOGOFF = 6,
MODE_CABTYPE = 7,
MODE_DIPSW = 8,
MODE_VIDEOFREQ = 9,
MODE_TEST = 10,
MODE_LIGHTOFF = 11,
MODE_POLL = 12,
MODE_SENSORES = 13,
MODE_TOTAL_COUNT = 14,
};
typedef bool (*mode_proc)(HANDLE handle);
static bool _mode_invalid(HANDLE handle);
static bool _mode_scan(HANDLE handle);
static bool _mode_verp3io(HANDLE handle);
static bool _mode_init(HANDLE handle);
static bool _mode_verddr(HANDLE handle);
static bool _mode_watchdogon(HANDLE handle);
static bool _mode_watchdogoff(HANDLE handle);
static bool _mode_cabtype(HANDLE handle);
static bool _mode_dipsw(HANDLE handle);
static bool _mode_videofreq(HANDLE handle);
static bool _mode_test(HANDLE handle);
static bool _mode_lightoff(HANDLE handle);
static bool _mode_poll(HANDLE handle);
static bool _mode_sensores(HANDLE handle);
static mode_proc _mode_procs[MODE_TOTAL_COUNT] = {
_mode_invalid,
_mode_scan,
_mode_verp3io,
_mode_init,
_mode_verddr,
_mode_watchdogon,
_mode_watchdogoff,
_mode_cabtype,
_mode_dipsw,
_mode_videofreq,
_mode_test,
_mode_lightoff,
_mode_poll,
_mode_sensores,
};
static enum log_level _log_level = LOG_LEVEL_FATAL;
static bool _extio_enabled = true;
static const char *_p3io_device_path = "";
static const char *_extio_com_port = "COM1";
static enum mode _mode = MODE_INVALID;
static bool _scan_and_open(HANDLE *handle)
{
HRESULT hr;
char path[MAX_PATH];
log_info("Scanning for p3io...");
hr = p3iodrv_device_scan(path);
if (FAILED(hr)) {
log_warning("Cannot find a connected p3io: %lX", hr);
return false;
}
log_info("Opening p3io: %s", path);
hr = p3iodrv_device_open(path, handle);
if (FAILED(hr)) {
log_warning("Opening p3io failed: %lX", hr);
return false;
}
return true;
}
static bool _close(HANDLE handle)
{
HRESULT hr;
log_info("Closing p3io...");
hr = p3iodrv_device_close(handle);
if (FAILED(hr)) {
log_warning("Closing p3io failed: %lX", hr);
return false;
}
return true;
}
static bool _process_cmd_args(int argc, char **argv)
{
char *mode;
if (argc < 2) {
fprintf(stderr, "DDR P3IO and EXTIO CLI testing tool\n");
fprintf(stderr, "\n");
fprintf(stderr, "Usage: [ARG ...] MODE\n");
fprintf(stderr, "Arguments:\n");
fprintf(
stderr,
" -v Enable additional logging, log level 'warning'\n");
fprintf(
stderr,
" -vv Enable additional logging, log level 'info'\n");
fprintf(
stderr,
" -vvv Enable additional logging, log level 'misc' (very "
"verbose)\n");
fprintf(
stderr,
" -noextio Run the tool without an EXTIO. This also impacts "
"various functionality, e.g. sensor polling, light outputs\n");
fprintf(
stderr,
" -p3io Explicit device path pointing to a P3IO device to "
"open. If not provided, the device will be automatically scanned "
"for.\n");
fprintf(
stderr,
" -extio Explicitly set the COM port the EXTIO is connected "
"to, e.g. COM4. If not provided COM1 is used.\n");
fprintf(stderr, "\n");
fprintf(stderr, "Modes:\n");
fprintf(
stderr,
" scan: Scan for a connected P3IO device. Outputs the full device "
"path to stdout if found.\n");
fprintf(
stderr,
" verp3io: Get and print the P3IO version information to "
"stdout.\n");
fprintf(stderr, " init: Initialize the P3IO (\"DDR mode\").\n");
fprintf(
stderr,
" verddr: Get and print the DDR P3IO specific information to "
"stdout.\n");
fprintf(stderr, " watchdogon: Turn the watchdog on.\n");
fprintf(stderr, " watchdogoff: Turn the watchdog off.\n");
fprintf(
stderr,
" cabtype: Get and print the cabinet type information to "
"stdout.\n");
fprintf(
stderr, " dipsw: Get and print the DIP switch state to stdout.\n");
fprintf(
stderr,
" videofreq: Get and print the detected video frequency to "
"stdout.\n");
fprintf(
stderr,
" test: Run interactive test mode, executes a polling read/write "
"loop to drive the IO and displays the current input states.\n");
fprintf(stderr, " lightoff: Turn all the lights off\n");
fprintf(
stderr,
" poll: Run a simple polling loop that polls data from the JAMMA "
"endpoint with input state output.\n");
fprintf(
stderr,
" sensores: Run cycling individual sensores in a simple polling "
"loop with input state ouptut.\n");
return false;
}
for (int i = 0; i < argc; i++) {
if (!strcmp(argv[i], "-v")) {
_log_level = LOG_LEVEL_WARNING;
} else if (!strcmp(argv[i], "-vv")) {
_log_level = LOG_LEVEL_INFO;
} else if (!strcmp(argv[i], "-vvv")) {
_log_level = LOG_LEVEL_MISC;
} else if (!strcmp(argv[i], "-noextio")) {
_extio_enabled = false;
} else if (!strcmp(argv[i], "-p3io")) {
if (i + 1 < argc) {
_p3io_device_path = argv[++i];
} else {
fprintf(stderr, "Missing value for -p3io argument\n");
}
} else if (!strcmp(argv[i], "-extio")) {
if (i + 1 < argc) {
_extio_com_port = argv[++i];
} else {
fprintf(stderr, "Missing value for -extio argument\n");
}
}
}
mode = argv[argc - 1];
if (!strcmp(mode, "scan")) {
_mode = MODE_SCAN;
} else if (!strcmp(mode, "verp3io")) {
_mode = MODE_VERP3IO;
} else if (!strcmp(mode, "init")) {
_mode = MODE_INIT;
} else if (!strcmp(mode, "verddr")) {
_mode = MODE_VERDDR;
} else if (!strcmp(mode, "watchdogon")) {
_mode = MODE_WATCHDOGON;
} else if (!strcmp(mode, "watchdogoff")) {
_mode = MODE_WATCHDOGOFF;
} else if (!strcmp(mode, "cabtype")) {
_mode = MODE_CABTYPE;
} else if (!strcmp(mode, "dipsw")) {
_mode = MODE_DIPSW;
} else if (!strcmp(mode, "videofreq")) {
_mode = MODE_VIDEOFREQ;
} else if (!strcmp(mode, "test")) {
_mode = MODE_TEST;
} else if (!strcmp(mode, "lightoff")) {
_mode = MODE_LIGHTOFF;
} else if (!strcmp(mode, "poll")) {
_mode = MODE_POLL;
} else if (!strcmp(mode, "sensores")) {
_mode = MODE_SENSORES;
} else {
fprintf(stderr, "Invalid mode '%s'", mode);
return false;
}
return true;
}
static void _init_logging()
{
log_to_writer(log_writer_stderr, NULL);
log_set_level(_log_level);
}
static bool _mode_invalid(HANDLE handle)
{
fprintf(stderr, "Invalid mode");
return false;
}
static bool _mode_scan(HANDLE handle)
{
HRESULT hr;
char path[MAX_PATH];
log_info("Scanning for p3io...");
hr = p3iodrv_device_scan(path);
if (FAILED(hr)) {
log_warning("Cannot find a connected p3io: %lX", hr);
return false;
}
log_info("Found p3io: %s", path);
printf("%s\n", path);
return true;
}
static bool _mode_verp3io(HANDLE handle)
{
HRESULT hr;
char version[P3IODRV_VERSION_MAX_LEN];
memset(version, 0, P3IODRV_VERSION_MAX_LEN);
hr = p3iodrv_device_read_version(handle, version);
if (FAILED(hr)) {
log_warning("Getting version failed: %lX", hr);
return _close(handle);
}
log_info("Version (P3IO): %s", version);
printf("%s\n", version);
return true;
}
static bool _mode_init(HANDLE handle)
{
HRESULT hr;
hr = p3iodrv_ddr_init(handle);
if (FAILED(hr)) {
log_warning("Init failed: %lX", hr);
return false;
}
log_info("Initialized");
return true;
}
static bool _mode_verddr(HANDLE handle)
{
HRESULT hr;
char str[4];
uint32_t major;
uint32_t minor;
uint32_t patch;
hr = p3iodrv_ddr_get_version(handle, str, &major, &minor, &patch);
if (FAILED(hr)) {
log_warning("Getting DDR version failed: %lX", hr);
return false;
}
log_info("Version (DDR): %s %d.%d.%d", str, major, minor, patch);
printf("%s %d.%d.%d\n", str, major, minor, patch);
return true;
}
static bool _mode_watchdogon(HANDLE handle)
{
HRESULT hr;
hr = p3iodrv_ddr_set_watchdog(handle, true);
if (FAILED(hr)) {
log_warning("Enabling watchdog failed: %lX", hr);
return false;
}
log_info("Watchdog on");
return true;
}
static bool _mode_watchdogoff(HANDLE handle)
{
HRESULT hr;
hr = p3iodrv_ddr_set_watchdog(handle, false);
if (FAILED(hr)) {
log_warning("Disabling watchdog failed: %lX", hr);
return false;
}
log_info("Watchdog off");
return true;
}
static bool _mode_cabtype(HANDLE handle)
{
HRESULT hr;
enum p3io_cab_type type;
const char *type_str;
hr = p3iodrv_ddr_get_cab_type(handle, &type);
if (FAILED(hr)) {
log_warning("Getting cab type failed: %lX", hr);
return false;
}
log_info("Cabinet type: %d", type);
switch (type) {
case P3IO_CAB_TYPE_SD:
type_str = "sd";
break;
case P3IO_CAB_TYPE_HD:
type_str = "hd";
break;
default:
type_str = "unknown";
break;
}
printf("%s\n", type_str);
return true;
}
static bool _mode_dipsw(HANDLE handle)
{
HRESULT hr;
uint8_t dip_sw;
hr = p3iodrv_ddr_get_dipsw(handle, &dip_sw);
if (FAILED(hr)) {
log_warning("Getting dip switches failed: %lX", hr);
return false;
}
log_info("Dip switches: 0x%X", dip_sw);
printf("0x%X\n", dip_sw);
return true;
}
static bool _mode_videofreq(HANDLE handle)
{
HRESULT hr;
enum p3io_video_freq video_freq;
const char *video_freq_str;
hr = p3iodrv_ddr_get_video_freq(handle, &video_freq);
if (FAILED(hr)) {
log_warning("Getting video freq failed: %lX", hr);
return false;
}
log_info("Video freq: 0x%X", video_freq);
switch (video_freq) {
case P3IO_VIDEO_FREQ_15KHZ:
video_freq_str = "15khz";
break;
case P3IO_VIDEO_FREQ_31KHZ:
video_freq_str = "31khz";
break;
default:
video_freq_str = "unknown";
break;
}
printf("%s\n", video_freq_str);
return true;
}
static bool _mode_test(HANDLE handle_p3io)
{
HRESULT hr;
HANDLE handle_extio;
bool result;
if (_extio_enabled) {
hr = extiodrv_device_open(_extio_com_port, &handle_extio);
if (FAILED(hr)) {
log_warning(
"Failed opening EXTIO on com port '%s': %lX",
_extio_com_port,
hr);
return false;
}
} else {
handle_extio = INVALID_HANDLE_VALUE;
}
result = mode_test_proc(handle_p3io, handle_extio);
if (_extio_enabled) {
hr = extiodrv_device_close(&handle_extio);
if (FAILED(hr)) {
log_warning("Failed closing EXTIO: %lX", hr);
result = false;
}
}
return result;
}
static bool _mode_lightoff(HANDLE handle_p3io)
{
HRESULT hr;
HANDLE handle_extio;
struct p3io_ddr_output output;
struct extiodrv_extio_pad_lights pad_lights[EXTIO_PAD_LIGHT_MAX_PLAYERS];
bool neons;
memset(&output, 0, sizeof(output));
memset(&pad_lights, 0, sizeof(pad_lights));
neons = false;
if (_extio_enabled) {
hr = extiodrv_device_open(_extio_com_port, &handle_extio);
if (FAILED(hr)) {
log_warning(
"Failed opening EXTIO on com port '%s': %lX",
_extio_com_port,
hr);
return false;
}
} else {
handle_extio = INVALID_HANDLE_VALUE;
}
hr = p3iodrv_ddr_set_outputs(handle_p3io, &output);
if (FAILED(hr)) {
log_warning("Setting outputs failed: %lX", hr);
return false;
}
if (_extio_enabled) {
hr = extiodrv_extio_transfer(
handle_extio,
EXTIODRV_EXTIO_SENSOR_READ_MODE_ALL,
pad_lights,
neons);
if (FAILED(hr)) {
log_warning("extio transfer failed: %lX", hr);
return false;
}
}
if (_extio_enabled) {
hr = extiodrv_device_close(&handle_extio);
if (FAILED(hr)) {
log_warning("Failed closing EXTIO: %lX", hr);
return false;
}
}
return true;
}
static bool _mode_poll(HANDLE handle_p3io)
{
HRESULT hr;
HANDLE handle_extio;
struct p3io_ddr_jamma jamma;
struct p3io_ddr_output output;
struct extiodrv_extio_pad_lights pad_lights[EXTIO_PAD_LIGHT_MAX_PLAYERS];
bool neons;
uint32_t cnt;
memset(&output, 0, sizeof(output));
memset(&pad_lights, 0, sizeof(pad_lights));
neons = false;
if (_extio_enabled) {
hr = extiodrv_device_open(_extio_com_port, &handle_extio);
if (FAILED(hr)) {
log_warning(
"Failed opening EXTIO on com port '%s': %lX",
_extio_com_port,
hr);
return false;
}
} else {
handle_extio = INVALID_HANDLE_VALUE;
}
fprintf(
stderr,
">>> Press enter to start endless polling loop. Press Escape to exit "
"to exit polling loop <<<\n");
if (getchar() != '\n') {
return true;
}
cnt = 0;
while ((GetAsyncKeyState(VK_ESCAPE) & 0x8000) == 0) {
hr = p3iodrv_ddr_set_outputs(handle_p3io, &output);
if (FAILED(hr)) {
log_warning("Setting outputs failed: %lX", hr);
return false;
}
if (_extio_enabled) {
hr = extiodrv_extio_transfer(
handle_extio,
EXTIODRV_EXTIO_SENSOR_READ_MODE_ALL,
pad_lights,
neons);
if (FAILED(hr)) {
log_warning("extio transfer failed: %lX", hr);
return false;
}
}
hr = p3iodrv_ddr_get_jamma(handle_p3io, &jamma);
if (FAILED(hr)) {
log_warning("Reading jamma failed: %lX", hr);
return false;
}
printf(
"%d: %08X %08X %08X\n",
cnt,
*((uint32_t *) &jamma) & 0xFFFFFF00,
jamma.unused,
jamma.unused2);
cnt++;
}
if (_extio_enabled) {
hr = extiodrv_device_close(&handle_extio);
if (FAILED(hr)) {
log_warning("Failed closing EXTIO: %lX", hr);
return false;
}
}
return true;
}
static bool _mode_sensores(HANDLE handle_p3io)
{
HRESULT hr;
HANDLE handle_extio;
struct p3io_ddr_jamma jamma;
struct p3io_ddr_output output;
struct extiodrv_extio_pad_lights pad_lights[EXTIO_PAD_LIGHT_MAX_PLAYERS];
bool neons;
uint32_t cnt;
uint8_t sensor_read;
memset(&output, 0, sizeof(output));
memset(&pad_lights, 0, sizeof(pad_lights));
neons = false;
if (_extio_enabled) {
hr = extiodrv_device_open(_extio_com_port, &handle_extio);
if (FAILED(hr)) {
log_warning(
"Failed opening EXTIO on com port '%s': %lX",
_extio_com_port,
hr);
return false;
}
} else {
handle_extio = INVALID_HANDLE_VALUE;
}
fprintf(
stderr,
">>> Press enter to start endless sensor cycling loop. Press Escape to "
"exit to exit sensor cycling loop <<<\n");
if (getchar() != '\n') {
return true;
}
cnt = 0;
sensor_read = 0;
while ((GetAsyncKeyState(VK_ESCAPE) & 0x8000) == 0) {
hr = p3iodrv_ddr_set_outputs(handle_p3io, &output);
if (FAILED(hr)) {
log_warning("Setting outputs failed: %lX", hr);
return false;
}
if (_extio_enabled) {
hr = extiodrv_extio_transfer(
handle_extio, sensor_read + 1, pad_lights, neons);
if (FAILED(hr)) {
log_warning("extio transfer failed: %lX", hr);
return false;
}
}
hr = p3iodrv_ddr_get_jamma(handle_p3io, &jamma);
if (FAILED(hr)) {
log_warning("Reading jamma failed: %lX", hr);
return false;
}
printf(
"%d (%d): %08X %08X %08X\n",
cnt,
sensor_read,
*((uint32_t *) &jamma) & 0xFFFFFF00,
jamma.unused,
jamma.unused2);
cnt++;
sensor_read++;
if (sensor_read > 3) {
sensor_read = 0;
}
}
if (_extio_enabled) {
hr = extiodrv_device_close(&handle_extio);
if (FAILED(hr)) {
log_warning("Failed closing EXTIO: %lX", hr);
return false;
}
}
return true;
}
int main(int argc, char **argv)
{
HANDLE handle;
bool result;
if (!_process_cmd_args(argc, argv)) {
return -1;
}
_init_logging();
if (_mode != MODE_SCAN) {
if (!_scan_and_open(&handle)) {
result = false;
} else {
result = _mode_procs[_mode](handle);
if (!_close(&handle)) {
result = false;
}
}
} else {
result = _mode_procs[_mode](INVALID_HANDLE_VALUE);
}
return result ? 0 : -1;
}

406
src/main/p3io-ddr-tool/mode-test.c Normal file
View File

@ -0,0 +1,406 @@
#define LOG_MODULE "mode-test"
#include <stdio.h>
#include <stdlib.h>
#include "extiodrv/extio.h"
#include "p3io/ddr.h"
#include "p3iodrv/ddr.h"
#include "p3iodrv/device.h"
#include "util/log.h"
#include "mode-test.h"
struct mode_test_output_state {
struct p3io_ddr_output output;
struct extiodrv_extio_pad_lights pad_lights[EXTIO_PAD_LIGHT_MAX_PLAYERS];
bool neons;
};
struct mode_test_input_state {
struct p3io_ddr_jamma jamma[4];
};
static bool _check_input_state_change(
const struct mode_test_input_state *cur_state,
const struct mode_test_input_state *prev_state)
{
return !memcmp(cur_state, prev_state, sizeof(struct mode_test_input_state));
}
static void _input_state_swap(
struct mode_test_input_state **cur_state,
struct mode_test_input_state **prev_state)
{
struct mode_test_input_state *tmp;
tmp = *cur_state;
*cur_state = *prev_state;
*prev_state = tmp;
}
static bool _update_io_frame(
HANDLE handle_p3io,
HANDLE handle_extio,
bool polling_mode,
struct mode_test_input_state *input,
const struct mode_test_output_state *output)
{
HRESULT hr;
hr = p3iodrv_ddr_set_outputs(handle_p3io, &output->output);
if (FAILED(hr)) {
log_warning("Setting outputs failed: %lX", hr);
return false;
}
if (polling_mode) {
hr = extiodrv_extio_transfer(
handle_extio,
EXTIODRV_EXTIO_SENSOR_READ_MODE_ALL,
output->pad_lights,
output->neons);
if (FAILED(hr)) {
log_warning("extio transfer failed: %lX", hr);
return false;
}
hr = p3iodrv_ddr_get_jamma(handle_p3io, &input->jamma[0]);
if (FAILED(hr)) {
log_warning("Reading jamma failed: %lX", hr);
return false;
}
} else {
for (uint8_t i = 0; i < 4; i++) {
hr = extiodrv_extio_transfer(
handle_extio, i + 1, output->pad_lights, output->neons);
if (FAILED(hr)) {
log_warning("extio transfer failed: %lX", hr);
return false;
}
hr = p3iodrv_ddr_get_jamma(handle_p3io, &input->jamma[i]);
if (FAILED(hr)) {
log_warning("Reading jamma failed: %lX", hr);
return false;
}
}
}
return true;
}
static void _set_outputs_on_inputs(
const struct mode_test_input_state *input,
struct mode_test_output_state *output)
{
memset(&output->pad_lights, 0, sizeof(output->pad_lights));
output->output.cabinet.p1_menu_buttons = 0;
output->output.cabinet.p2_menu_buttons = 0;
for (uint8_t i = 0; i < 4; i++) {
output->pad_lights[0].up |= input->jamma[i].p1.pad_up ? 1 : 0;
output->pad_lights[0].down |= input->jamma[i].p1.pad_down ? 1 : 0;
output->pad_lights[0].left |= input->jamma[i].p1.pad_left ? 1 : 0;
output->pad_lights[0].right |= input->jamma[i].p1.pad_right ? 1 : 0;
output->pad_lights[1].up |= input->jamma[i].p2.pad_up ? 1 : 0;
output->pad_lights[1].down |= input->jamma[i].p2.pad_down ? 1 : 0;
output->pad_lights[1].left |= input->jamma[i].p2.pad_left ? 1 : 0;
output->pad_lights[1].right |= input->jamma[i].p2.pad_right ? 1 : 0;
output->output.cabinet.p1_menu_buttons |=
(input->jamma[i].p1.menu_left || input->jamma[i].p1.menu_right ||
input->jamma[i].p1.menu_start) ?
1 :
0;
output->output.cabinet.p2_menu_buttons |=
(input->jamma[i].p2.menu_left || input->jamma[i].p2.menu_right ||
input->jamma[i].p2.menu_start) ?
1 :
0;
}
}
static void _render_main(
uint8_t cnt, bool polling_mode, const struct mode_test_input_state *state)
{
printf("Counter: %d\n", cnt);
printf("Polling mode: %d\n", polling_mode);
printf("Player 1 Player 2\n");
printf("\n");
printf("Pad\n");
if (polling_mode) {
printf(
"Up: %d Up: %d\n",
state->jamma[0].p1.pad_up,
state->jamma[0].p2.pad_up);
printf(
"Down: %d Down: %d\n",
state->jamma[0].p1.pad_down,
state->jamma[0].p2.pad_down);
printf(
"Left: %d Left: %d\n",
state->jamma[0].p1.pad_left,
state->jamma[0].p2.pad_left);
printf(
"Right: %d Right: %d\n",
state->jamma[0].p1.pad_right,
state->jamma[0].p2.pad_right);
} else {
printf(
"Up: %c%c%c%c Up: %c%c%c%c\n",
state->jamma[0].p1.pad_up ? 'U' : '_',
state->jamma[1].p1.pad_up ? 'D' : '_',
state->jamma[2].p1.pad_up ? 'L' : '_',
state->jamma[3].p1.pad_up ? 'R' : '_',
state->jamma[0].p2.pad_up ? 'U' : '_',
state->jamma[1].p2.pad_up ? 'D' : '_',
state->jamma[2].p2.pad_up ? 'L' : '_',
state->jamma[3].p2.pad_up) ?
'R' :
'_';
printf(
"Down: %c%c%c%c Down: %c%c%c%c\n",
state->jamma[0].p1.pad_down ? 'U' : '_',
state->jamma[1].p1.pad_down ? 'D' : '_',
state->jamma[2].p1.pad_down ? 'L' : '_',
state->jamma[3].p1.pad_down ? 'R' : '_',
state->jamma[0].p2.pad_down ? 'U' : '_',
state->jamma[1].p2.pad_down ? 'D' : '_',
state->jamma[2].p2.pad_down ? 'L' : '_',
state->jamma[3].p2.pad_down ? 'R' : '_');
printf(
"Left: %c%c%c%c Left: %c%c%c%c\n",
state->jamma[0].p1.pad_left ? 'U' : '_',
state->jamma[1].p1.pad_left ? 'D' : '_',
state->jamma[2].p1.pad_left ? 'L' : '_',
state->jamma[3].p1.pad_left ? 'R' : '_',
state->jamma[0].p2.pad_left ? 'U' : '_',
state->jamma[1].p2.pad_left ? 'D' : '_',
state->jamma[2].p2.pad_left ? 'L' : '_',
state->jamma[3].p2.pad_left ? 'R' : '_');
printf(
"Right: %c%c%c%c Right: %c%c%c%c\n",
state->jamma[0].p1.pad_right ? 'U' : '_',
state->jamma[1].p1.pad_right ? 'D' : '_',
state->jamma[2].p1.pad_right ? 'L' : '_',
state->jamma[3].p1.pad_right ? 'R' : '_',
state->jamma[0].p2.pad_right ? 'U' : '_',
state->jamma[1].p2.pad_right ? 'D' : '_',
state->jamma[2].p2.pad_right ? 'L' : '_',
state->jamma[3].p2.pad_right ? 'R' : '_');
}
printf("\n");
printf("Menu\n");
printf(
"Start: %d Start: %d\n",
state->jamma[0].p1.menu_start,
state->jamma[0].p2.menu_start);
printf(
"Up: %d Up: %d\n",
state->jamma[0].operator.p1_menu_up,
state->jamma[0].operator.p2_menu_up);
printf(
"Down: %d Down: %d\n",
state->jamma[0].operator.p1_menu_down,
state->jamma[0].operator.p2_menu_down);
printf(
"Left: %d Left: %d\n",
state->jamma[0].p1.menu_left,
state->jamma[0].p2.menu_left);
printf(
"Right: %d Right: %d\n",
state->jamma[0].p1.menu_right,
state->jamma[0].p2.menu_right);
printf("\n");
printf("Operator\n");
printf(
"Test: %d Service: %d Coin: %d\n",
state->jamma[0].operator.test,
state->jamma[0].operator.service,
state->jamma[0].operator.coin);
}
static void
_render_menu(bool *continue_loop, struct mode_test_output_state *output)
{
printf(
"Menu options:\n"
" 0: Exit menu and continue loop\n"
" 1: Exit\n"
" 2: Set neon state\n"
" 3: Top lamp state\n"
" 4: Set all lights on\n"
" 5: Set all lights off\n"
"Waiting for input: ");
char c = getchar();
// Keyboard input debounce
Sleep(10);
switch (c) {
case '1': {
*continue_loop = false;
break;
}
case '2': {
int state;
int n;
printf("Enter neon state (0/1): ");
n = scanf("%d", &state);
if (n > 0) {
output->neons = state > 0;
}
break;
}
case '3': {
char buf[4];
int n;
printf("Enter top lamp state, chain of 0/1s: ");
n = scanf("%8s", buf);
if (n > 0) {
output->output.cabinet.top_p1_upper = buf[0] == '1';
output->output.cabinet.top_p1_lower = buf[1] == '1';
output->output.cabinet.top_p2_upper = buf[2] == '1';
output->output.cabinet.top_p2_lower = buf[3] == '1';
}
break;
}
case '4': {
output->output.cabinet.top_p1_upper = 1;
output->output.cabinet.top_p1_lower = 1;
output->output.cabinet.top_p2_upper = 1;
output->output.cabinet.top_p2_lower = 1;
output->output.cabinet.p1_menu_buttons = 1;
output->output.cabinet.p2_menu_buttons = 1;
output->neons = true;
output->pad_lights[0].up = true;
output->pad_lights[0].down = true;
output->pad_lights[0].left = true;
output->pad_lights[0].right = true;
output->pad_lights[1].up = true;
output->pad_lights[1].down = true;
output->pad_lights[1].left = true;
output->pad_lights[1].right = true;
break;
}
case '5': {
output->output.cabinet.top_p1_upper = 0;
output->output.cabinet.top_p1_lower = 0;
output->output.cabinet.top_p2_upper = 0;
output->output.cabinet.top_p2_lower = 0;
output->output.cabinet.p1_menu_buttons = 0;
output->output.cabinet.p2_menu_buttons = 0;
output->neons = false;
output->pad_lights[0].up = false;
output->pad_lights[0].down = false;
output->pad_lights[0].left = false;
output->pad_lights[0].right = false;
output->pad_lights[1].up = false;
output->pad_lights[1].down = false;
output->pad_lights[1].left = false;
output->pad_lights[1].right = false;
break;
}
case '0':
default:
break;
}
}
bool mode_test_proc(HANDLE handle_p3io, HANDLE handle_extio)
{
struct mode_test_input_state state[2];
struct mode_test_input_state *cur_input_state;
struct mode_test_input_state *prev_input_state;
struct mode_test_output_state output_state;
bool polling_mode;
bool loop;
uint8_t cnt;
memset(&state, 0, sizeof(state));
cur_input_state = &state[0];
prev_input_state = &state[1];
memset(&output_state, 0, sizeof(output_state));
polling_mode = true;
loop = true;
cnt = 0;
fprintf(stderr, ">>> Press enter to start running test mode <<<\n");
if (getchar() != '\n') {
return true;
}
while (loop) {
if ((GetAsyncKeyState(VK_ESCAPE) & 0x8000) != 0) {
system("cls");
_render_menu(&loop, &output_state);
} else {
_input_state_swap(&cur_input_state, &prev_input_state);
memset(cur_input_state, 0, sizeof(struct mode_test_input_state));
if (!_update_io_frame(
handle_p3io,
handle_extio,
polling_mode,
cur_input_state,
&output_state)) {
return false;
}
_set_outputs_on_inputs(cur_input_state, &output_state);
if (_check_input_state_change(cur_input_state, prev_input_state)) {
system("cls");
_render_main(cnt, polling_mode, cur_input_state);
}
}
/* avoid CPU banging */
Sleep(1);
++cnt;
}
return true;
}

11
src/main/p3io-ddr-tool/mode-test.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef P3IO_DDR_TOOL_MODE_TEST_H
#define P3IO_DDR_TOOL_MODE_TEST_H
#include <windows.h>
#include <stdbool.h>
#include <stdint.h>
bool mode_test_proc(HANDLE handle_p3io, HANDLE handle_extio);
#endif