Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-22 16:31:49 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

cxg: renamed some source files

Browse Source 
New systems marked not working
------------------------------
Sphinx Chess Professor [hap, Berger]
Kasparov GK 2000 [hap, Sean Riddle]
This commit is contained in:
hap 2024-02-13 17:47:59 +01:00
parent 6872b33057
commit babb569e6e
16 changed files with 659 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/devices/cpu/h8/h8.cpp
View File

@ -9,7 +9,11 @@
TODO:
- use logmacro and be quiet by default, same for H8 peripherals that
currently have "static constexpr int V"
- add STBY pin (hardware standby mode)
- NVRAM won't work properly when it goes into SSBY (software standby
mode) and the power button triggers an IRQ to wake up instead of RES.
Obviously, MAME always starts at reset-phase at power-on, so it's more
like a 'known issue' instead of a TODO since it can't really be fixed.
- add STBY pin (hardware standby mode, can only wake up with reset)
***************************************************************************/
@ -540,7 +544,7 @@ void h8_device::prefetch_done_noirq_notrace()
void h8_device::set_irq(int irq_vector, int irq_level, bool irq_nmi)
{
// wake up from software standby with an external interrupt
if(standby() && (irq_vector || irq_nmi)) {
if(standby() && irq_vector) {
resume(SUSPEND_REASON_CLOCK);
m_standby_cb(0);
}

2
src/devices/cpu/h8/h8_sci.cpp
View File

@ -12,7 +12,7 @@
// 1 = transmitted/recieved bytes, reception errors and clock setup
// 2 = everything but status register reads
// 3 = everything
static constexpr int V = 1;
static constexpr int V = 0;
DEFINE_DEVICE_TYPE(H8_SCI, h8_sci_device, "h8_sci", "H8 Serial Communications Interface")

8
src/devices/cpu/h8/h8_timer16.cpp
View File

@ -14,6 +14,10 @@
triggered at rising edge of (flag) or (irq_enable & flag).
- H8/325 16-bit timer is shoehorned in and may have a bug lurking?
It doesn't have TGR registers, but functionally equivalent OCR/ICR.
- Make the base class more generic, and derive the devices from that,
so they don't have to jumble so much with the IRQ/flag bits. The
overflow IRQ/flag being hardcoded on bit 4 is also problematic.
- Proper support for input capture registers.
***************************************************************************/
@ -563,8 +567,8 @@ void h8325_timer16_channel_device::tcr_update()
case 2: // /32
m_clock_divider = 5;
break;
case 3: // external
m_clock_type = INPUT_A;
case 3: // TODO: external
m_clock_type = -1;
break;
}
}

2
src/devices/cpu/h8/h8_timer16.h
View File

@ -134,7 +134,7 @@ public:
{
m_cpu.set_tag(std::forward<T>(cpu));
m_intc.set_tag(std::forward<U>(intc));
m_tgr_count = 3; // OCRA/OCRB/ICR
m_tgr_count = 2; // OCRA/OCRB(/ICR)
m_interrupt[0] = irq_base + 1; // OCIA
m_interrupt[1] = irq_base + 2; // OCIB

1
src/mame/coleco/wrinkles.cpp
View File

@ -1,5 +1,6 @@
// license:BSD-3-Clause
// copyright-holders:hap
// thanks-to:David Viens
/*******************************************************************************
Talking Wrinkles (model 6006), a dog hand puppet

38
src/mame/cxg/ch2001.cpp → src/mame/cxg/chess2001.cpp
View File

@ -31,15 +31,15 @@ Hardware notes:
#include "speaker.h"
// internal artwork
#include "cxg_ch2001.lh"
#include "cxg_chess2001.lh"
namespace {
class ch2001_state : public driver_device
class chess2001_state : public driver_device
{
public:
ch2001_state(const machine_config &mconfig, device_type type, const char *tag) :
chess2001_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_display(*this, "display"),
@ -49,7 +49,7 @@ public:
{ }
// machine configs
void ch2001(machine_config &config);
void chess2001(machine_config &config);
protected:
virtual void machine_start() override;
@ -74,7 +74,7 @@ private:
u8 input_r();
};
void ch2001_state::machine_start()
void chess2001_state::machine_start()
{
// register for savestates
save_item(NAME(m_inp_mux));
@ -87,16 +87,14 @@ void ch2001_state::machine_start()
I/O
*******************************************************************************/
// TTL
void ch2001_state::speaker_w(u8 data)
void chess2001_state::speaker_w(u8 data)
{
// 74ls109 toggle to speaker
m_dac_data ^= 1;
m_dac->write(m_dac_data);
}
void ch2001_state::leds_w(u8 data)
void chess2001_state::leds_w(u8 data)
{
// d0-d7: 74ls273 (WR to CLK)
// 74ls273 Q1-Q4: 74ls145 A-D
@ -110,7 +108,7 @@ void ch2001_state::leds_w(u8 data)
m_display->matrix(sel, led_data);
}
u8 ch2001_state::input_r()
u8 chess2001_state::input_r()
{
u8 data = 0;
@ -132,12 +130,12 @@ u8 ch2001_state::input_r()
Address Maps
*******************************************************************************/
void ch2001_state::main_map(address_map &map)
void chess2001_state::main_map(address_map &map)
{
map(0x0000, 0x3fff).rom();
map(0x4000, 0x47ff).mirror(0x3800).ram();
map(0x8000, 0x8000).mirror(0x3fff).rw(FUNC(ch2001_state::input_r), FUNC(ch2001_state::leds_w));
map(0xc000, 0xc000).mirror(0x3fff).w(FUNC(ch2001_state::speaker_w));
map(0x8000, 0x8000).mirror(0x3fff).rw(FUNC(chess2001_state::input_r), FUNC(chess2001_state::leds_w));
map(0xc000, 0xc000).mirror(0x3fff).w(FUNC(chess2001_state::speaker_w));
}
@ -146,7 +144,7 @@ void ch2001_state::main_map(address_map &map)
Input Ports
*******************************************************************************/
static INPUT_PORTS_START( ch2001 )
static INPUT_PORTS_START( chess2001 )
PORT_START("IN.0")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_T) PORT_NAME("Black")
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_2) PORT_NAME("King")
@ -174,11 +172,11 @@ INPUT_PORTS_END
Machine Configs
*******************************************************************************/
void ch2001_state::ch2001(machine_config &config)
void chess2001_state::chess2001(machine_config &config)
{
// basic machine hardware
Z80(config, m_maincpu, 8_MHz_XTAL/2);
m_maincpu->set_addrmap(AS_PROGRAM, &ch2001_state::main_map);
m_maincpu->set_addrmap(AS_PROGRAM, &chess2001_state::main_map);
auto &irq_clock(CLOCK(config, "irq_clock", 568)); // 555 timer (20nF, 100K+33K, 1K2), measured 568Hz
irq_clock.set_pulse_width(attotime::from_nsec(16600)); // active for 16.6us
@ -190,7 +188,7 @@ void ch2001_state::ch2001(machine_config &config)
// video hardware
PWM_DISPLAY(config, m_display).set_size(10, 8);
config.set_default_layout(layout_cxg_ch2001);
config.set_default_layout(layout_cxg_chess2001);
// sound hardware
SPEAKER(config, "speaker").front_center();
@ -205,7 +203,7 @@ void ch2001_state::ch2001(machine_config &config)
ROM_START( ch2001 )
ROM_REGION( 0x10000, "maincpu", 0 )
ROM_LOAD("ch2001.bin", 0x0000, 0x4000, CRC(b3485c73) SHA1(f405c6f67fe70edf45dcc383a4049ee6bad387a9) ) // D27128D, no label
ROM_LOAD("chess2001.bin", 0x0000, 0x4000, CRC(b3485c73) SHA1(f405c6f67fe70edf45dcc383a4049ee6bad387a9) ) // D27128D, no label
ROM_END
} // anonymous namespace
@ -216,5 +214,5 @@ ROM_END
Drivers
*******************************************************************************/
// YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY, FULLNAME, FLAGS
SYST( 1984, ch2001, 0, 0, ch2001, ch2001, ch2001_state, empty_init, "CXG Systems / Newcrest Technology / Intelligent Software", "Chess 2001", MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )
// YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY, FULLNAME, FLAGS
SYST( 1984, ch2001, 0, 0, chess2001, chess2001, chess2001_state, empty_init, "CXG Systems / Newcrest Technology / Intelligent Software", "Chess 2001", MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )

57
src/mame/cxg/scptchess.cpp → src/mame/cxg/computachess.cpp
View File

@ -51,6 +51,9 @@ HD44801C89 MCU is used in:
- Schneider Sensor Chessmaster MK 6
- Schneider Sensor Chesspartner MK 4
Computachess II has a HD44840 MCU. Computachess III has a HD6301V1 MCU and
should be the same as Enterprise "S" (see saitek/companion2.cpp).
*******************************************************************************/
#include "emu.h"
@ -63,16 +66,16 @@ HD44801C89 MCU is used in:
#include "speaker.h"
// internal artwork
#include "cxg_scptchess_v1.lh"
#include "cxg_scptchess_v2.lh"
#include "cxg_scptchess.lh"
#include "cxg_scptchessa.lh"
namespace {
class scptchess_state : public driver_device
class computachess_state : public driver_device
{
public:
scptchess_state(const machine_config &mconfig, device_type type, const char *tag) :
computachess_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_board(*this, "board"),
@ -81,8 +84,8 @@ public:
m_inputs(*this, "IN.0")
{ }
void scptchess_v1(machine_config &config);
void scptchess_v2(machine_config &config);
void scptchess(machine_config &config);
void scptchessa(machine_config &config);
// New Game button is directly tied to MCU reset
DECLARE_INPUT_CHANGED_MEMBER(reset_button) { m_maincpu->set_input_line(INPUT_LINE_RESET, newval ? ASSERT_LINE : CLEAR_LINE); }
@ -107,7 +110,7 @@ private:
u16 input_r();
};
void scptchess_state::machine_start()
void computachess_state::machine_start()
{
save_item(NAME(m_inp_mux));
save_item(NAME(m_led_data));
@ -119,20 +122,20 @@ void scptchess_state::machine_start()
I/O
*******************************************************************************/
void scptchess_state::update_display()
void computachess_state::update_display()
{
m_display->matrix(m_inp_mux, m_led_data);
}
template<int N>
void scptchess_state::mux_w(u8 data)
void computachess_state::mux_w(u8 data)
{
// R2x,R3x: input mux, led select
m_inp_mux = (m_inp_mux & ~(0xf << (N*4))) | (data << (N*4));
update_display();
}
void scptchess_state::leds_w(u16 data)
void computachess_state::leds_w(u16 data)
{
// D2,D3: led data
m_led_data = ~data >> 2 & 3;
@ -142,7 +145,7 @@ void scptchess_state::leds_w(u16 data)
m_dac->write(data & 1);
}
u16 scptchess_state::input_r()
u16 computachess_state::input_r()
{
u16 data = 0;
@ -164,21 +167,21 @@ u16 scptchess_state::input_r()
Input Ports
*******************************************************************************/
static INPUT_PORTS_START( scptchess_v1 )
static INPUT_PORTS_START( scptchess )
PORT_START("IN.0")
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_S) PORT_NAME("Sound") // only hooked up on 1st version
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_R) PORT_NAME("Reverse Play")
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_L) PORT_NAME("Level")
INPUT_PORTS_END
static INPUT_PORTS_START( scptchess_v2 )
PORT_INCLUDE( scptchess_v1 )
static INPUT_PORTS_START( scptchessa )
PORT_INCLUDE( scptchess )
PORT_MODIFY("IN.0")
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_UNUSED)
PORT_START("RESET")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_N) PORT_CHANGED_MEMBER(DEVICE_SELF, scptchess_state, reset_button, 0) PORT_NAME("New Game")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_N) PORT_CHANGED_MEMBER(DEVICE_SELF, computachess_state, reset_button, 0) PORT_NAME("New Game")
INPUT_PORTS_END
@ -187,14 +190,14 @@ INPUT_PORTS_END
Machine Configs
*******************************************************************************/
void scptchess_state::scptchess_v1(machine_config &config)
void computachess_state::scptchess(machine_config &config)
{
// basic machine hardware
HD44801(config, m_maincpu, 400'000);
m_maincpu->write_r<2>().set(FUNC(scptchess_state::mux_w<0>));
m_maincpu->write_r<3>().set(FUNC(scptchess_state::mux_w<1>));
m_maincpu->write_d().set(FUNC(scptchess_state::leds_w));
m_maincpu->read_d().set(FUNC(scptchess_state::input_r));
m_maincpu->write_r<2>().set(FUNC(computachess_state::mux_w<0>));
m_maincpu->write_r<3>().set(FUNC(computachess_state::mux_w<1>));
m_maincpu->write_d().set(FUNC(computachess_state::leds_w));
m_maincpu->read_d().set(FUNC(computachess_state::input_r));
SENSORBOARD(config, m_board).set_type(sensorboard_device::BUTTONS);
m_board->init_cb().set(m_board, FUNC(sensorboard_device::preset_chess));
@ -202,17 +205,17 @@ void scptchess_state::scptchess_v1(machine_config &config)
// video hardware
PWM_DISPLAY(config, m_display).set_size(8, 2);
config.set_default_layout(layout_cxg_scptchess_v1);
config.set_default_layout(layout_cxg_scptchess);
// sound hardware
SPEAKER(config, "speaker").front_center();
DAC_1BIT(config, m_dac).add_route(ALL_OUTPUTS, "speaker", 0.25);
}
void scptchess_state::scptchess_v2(machine_config &config)
void computachess_state::scptchessa(machine_config &config)
{
scptchess_v1(config);
config.set_default_layout(layout_cxg_scptchess_v2);
scptchess(config);
config.set_default_layout(layout_cxg_scptchessa);
}
@ -239,6 +242,6 @@ ROM_END
Drivers
*******************************************************************************/
// YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY, FULLNAME, FLAGS
SYST( 1981, scptchess, 0, 0, scptchess_v1, scptchess_v1, scptchess_state, empty_init, "CXG Systems / White & Allcock / Intelligent Software", "Sensor Computachess (1981 version)", MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )
SYST( 1985, scptchessa, scptchess, 0, scptchess_v2, scptchess_v2, scptchess_state, empty_init, "CXG Systems / Newcrest Technology / Intelligent Software", "Sensor Computachess (1985 version)", MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )
// YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY, FULLNAME, FLAGS
SYST( 1981, scptchess, 0, 0, scptchess, scptchess, computachess_state, empty_init, "CXG Systems / White & Allcock / Intelligent Software", "Sensor Computachess (1981 version)", MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )
SYST( 1985, scptchessa, scptchess, 0, scptchessa, scptchessa, computachess_state, empty_init, "CXG Systems / Newcrest Technology / Intelligent Software", "Sensor Computachess (1985 version)", MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )

230
src/mame/cxg/professor.cpp Normal file
View File

@ -0,0 +1,230 @@
// license:BSD-3-Clause
// copyright-holders:hap
// thanks-to:Berger
/*******************************************************************************
CXG Sphinx Chess Professor (CXG-243)
NOTE: Before exiting MAME, press the STOP button to turn the power off. Otherwise,
NVRAM won't save properly.
The chess engine is by Frans Morsch, similar to the one in Mephisto Europa.
For some reason, they've put the row leds on the right instead of on the left.
Hardware notes:
- PCB label: 243 600 001
- Hitachi HD63B01Y0P, 8MHz XTAL
- Sanyo LC7580, LCD with custom segments
- 8*8 chessboard buttons, 16 LEDs, piezo
TODO:
- map the buttons
- add lcd
- internal artwork
*******************************************************************************/
#include "emu.h"
#include "cpu/m6800/m6801.h"
#include "machine/sensorboard.h"
#include "sound/dac.h"
#include "video/pwm.h"
#include "speaker.h"
// internal artwork
//#include "cxg_professor.lh"
namespace {
class professor_state : public driver_device
{
public:
professor_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_board(*this, "board"),
m_display(*this, "display"),
m_dac(*this, "dac"),
m_inputs(*this, "IN.%u", 0)
{ }
void professor(machine_config &config);
DECLARE_INPUT_CHANGED_MEMBER(on_button);
protected:
virtual void machine_start() override;
private:
// devices/pointers
required_device<hd6301y0_cpu_device> m_maincpu;
required_device<sensorboard_device> m_board;
required_device<pwm_display_device> m_display;
required_device<dac_bit_interface> m_dac;
required_ioport_array<3> m_inputs;
u16 m_inp_mux = 0;
// I/O handlers
template <int N> void leds_w(u8 data);
void control_w(u8 data);
u8 input_r();
void board_w(u8 data);
};
void professor_state::machine_start()
{
save_item(NAME(m_inp_mux));
}
/*******************************************************************************
I/O
*******************************************************************************/
INPUT_CHANGED_MEMBER(professor_state::on_button)
{
// standby check actually comes from P27 high-impedance state
if (newval && m_maincpu->standby())
m_maincpu->pulse_input_line(INPUT_LINE_RESET, attotime::zero);
}
template <int N>
void professor_state::leds_w(u8 data)
{
// P10-P17, P40-P47: leds (direct)
m_display->write_row(N, ~data);
}
void professor_state::control_w(u8 data)
{
// P20-P22: input mux (buttons)
m_inp_mux = (m_inp_mux & 0xff) | (~data << 8 & 0x700);
// P23: speaker out
m_dac->write(BIT(data, 3));
}
u8 professor_state::input_r()
{
// P50-P57: multiplexed inputs
u8 data = 0;
// read buttons
for (int i = 0; i < 3; i++)
if (BIT(m_inp_mux, i + 8))
data |= m_inputs[i]->read();
// read chessboard
for (int i = 0; i < 8; i++)
if (BIT(m_inp_mux, i))
data |= m_board->read_file(i);
return ~data;
}
void professor_state::board_w(u8 data)
{
// P60-P67: input mux (chessboard)
m_inp_mux = (m_inp_mux & 0x700) | (data ^ 0xff);
}
/*******************************************************************************
Input Ports
*******************************************************************************/
static INPUT_PORTS_START( professor )
PORT_START("IN.0")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_1) // p
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_2) // n
PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_3) // b
PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_4) // r
PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_5) // q
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_6) // k
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_7) // take back
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_8) // move
PORT_START("IN.1")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_Q) // reset
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_W) // position?
PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_E)
PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_R) // sound
PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_T)
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_Y)
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_U) // level
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_I) // monitor?
PORT_START("IN.2")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_A) // off
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_S)
PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_D)
PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_F)
PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_G)
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_H)
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_J)
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_K) // also rook?
PORT_START("RESET")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_O) PORT_CHANGED_MEMBER(DEVICE_SELF, professor_state, on_button, 0) PORT_NAME("On")
INPUT_PORTS_END
/*******************************************************************************
Machine Configs
*******************************************************************************/
void professor_state::professor(machine_config &config)
{
// basic machine hardware
HD6301Y0(config, m_maincpu, 8_MHz_XTAL);
m_maincpu->nvram_enable_backup(true);
m_maincpu->standby_cb().set(m_maincpu, FUNC(hd6301y_cpu_device::nvram_set_battery));
//m_maincpu->standby_cb().append(FUNC(professor_state::standby));
m_maincpu->out_p1_cb().set(FUNC(professor_state::leds_w<0>));
m_maincpu->out_p4_cb().set(FUNC(professor_state::leds_w<1>));
m_maincpu->out_p2_cb().set(FUNC(professor_state::control_w));
m_maincpu->in_p5_cb().set(FUNC(professor_state::input_r));
m_maincpu->out_p6_cb().set(FUNC(professor_state::board_w));
SENSORBOARD(config, m_board).set_type(sensorboard_device::BUTTONS);
m_board->init_cb().set(m_board, FUNC(sensorboard_device::preset_chess));
m_board->set_delay(attotime::from_msec(150));
//m_board->set_nvram_enable(true);
// video hardware
PWM_DISPLAY(config, m_display).set_size(2, 8);
//config.set_default_layout(layout_cxg_professor);
// sound hardware
SPEAKER(config, "speaker").front_center();
DAC_1BIT(config, m_dac).add_route(ALL_OUTPUTS, "speaker", 0.25);
}
/*******************************************************************************
ROM Definitions
*******************************************************************************/
ROM_START( scprof )
ROM_REGION( 0x4000, "maincpu", 0 )
ROM_LOAD("1988_107_newcrest_hd6301y0j76p", 0x0000, 0x4000, CRC(681456c7) SHA1(99f8ab7369dbc2c93335affc38838295a8a2c5f3) )
ROM_END
} // anonymous namespace
/*******************************************************************************
Drivers
*******************************************************************************/
// YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY, FULLNAME, FLAGS
SYST( 1989, scprof, 0, 0, professor, professor, professor_state, empty_init, "CXG Systems / Newcrest Technology", "Sphinx Chess Professor", MACHINE_NOT_WORKING | MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )

4
src/mame/hegenerglaser/europa.cpp
View File

@ -54,10 +54,10 @@ public:
m_inputs(*this, "IN.%u", 0)
{ }
DECLARE_INPUT_CHANGED_MEMBER(on_button);
void europa(machine_config &config);
DECLARE_INPUT_CHANGED_MEMBER(on_button);
protected:
virtual void machine_start() override;

0
src/mame/layout/cxg_ch2001.lay → src/mame/layout/cxg_chess2001.lay
View File

0
src/mame/layout/cxg_scptchess_v1.lay → src/mame/layout/cxg_scptchess.lay
View File

0
src/mame/layout/cxg_scptchess_v2.lay → src/mame/layout/cxg_scptchessa.lay
View File

14
src/mame/mame.lst
View File

@ -16426,9 +16426,13 @@ galaxiac // (c) 1979
quasar // (c) 1980 Zelco Games Italy
quasara // (c) 1980 Zelco Games Italy
@source:cxg/ch2001.cpp
@source:cxg/chess2001.cpp
ch2001
@source:cxg/computachess.cpp
scptchess
scptchessa
@source:cxg/dominator.cpp
scmder
sdtor
@ -16436,9 +16440,8 @@ sgalaxy
sgalaxya
sgalaxyb
@source:cxg/scptchess.cpp
scptchess
scptchessa
@source:cxg/professor.cpp
scprof
@source:cxg/senterprise.cpp
senterp
@ -38529,6 +38532,9 @@ edames
@source:saitek/exechess.cpp
exechess
@source:saitek/gk2000.cpp
gk2000
@source:saitek/intchess.cpp
intchess

329
src/mame/saitek/gk2000.cpp Normal file
View File

@ -0,0 +1,329 @@
// license:BSD-3-Clause
// copyright-holders:hap
// thanks-to:Sean Riddle
/*******************************************************************************
Saitek Kasparov GK 2000
TODO:
- verify buttons
- stop key does not work
- IN.2 does not work
- beeper sounds glitchy
- add lcd
- clean up WIP code
- internal artwork
*******************************************************************************/
#include "emu.h"
#include "cpu/h8/h8325.h"
#include "machine/sensorboard.h"
#include "sound/dac.h"
#include "video/pwm.h"
#include "speaker.h"
// internal artwork
//#include "saitek_gk2000.lh"
namespace {
class gk2000_state : public driver_device
{
public:
gk2000_state(const machine_config &mconfig, device_type type, const char *tag) :
driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_board(*this, "board"),
m_led_pwm(*this, "led_pwm"),
m_dac(*this, "dac"),
m_inputs(*this, "IN.%u", 0)
{ }
void gk2000(machine_config &config);
DECLARE_INPUT_CHANGED_MEMBER(go_button);
protected:
virtual void machine_start() override;
private:
// devices/pointers
required_device<h8323_device> m_maincpu;
required_device<sensorboard_device> m_board;
required_device<pwm_display_device> m_led_pwm;
required_device<dac_bit_interface> m_dac;
required_ioport_array<3> m_inputs;
u16 m_inp_mux = 0;
void main_map(address_map &map);
// I/O handlers
u8 p1_r();
void p1_w(u8 data);
u8 p2_r();
void p2_w(u8 data);
u8 p3_r();
void p3_w(u8 data);
u8 p4_r();
void p4_w(u8 data);
u8 p5_r();
void p5_w(u8 data);
u8 p6_r();
void p6_w(u8 data);
u8 p7_r();
void p7_w(u8 data);
};
void gk2000_state::machine_start()
{
// register for savestates
save_item(NAME(m_inp_mux));
}
/*******************************************************************************
I/O
*******************************************************************************/
INPUT_CHANGED_MEMBER(gk2000_state::go_button)
{
m_maincpu->set_input_line(INPUT_LINE_IRQ0, newval ? ASSERT_LINE : CLEAR_LINE);
}
//[:maincpu] syscr = f9
//[:maincpu:port1] ddr_w ff
//[:maincpu:port3] ddr_w ff
//[:maincpu:port7] ddr_w ff
//[:maincpu:port6] ddr_w 4f
//[:maincpu:port2] ddr_w 00 ?
//[:maincpu:port5] ddr_w 27 ?
//[:maincpu:port5] ddr_w 1f
//[:maincpu:port2] ddr_w ff
// p4 ddr=0 -> read inputs
u8 gk2000_state::p1_r()
{
//printf("r1 ");
return 0xff;
}
void gk2000_state::p1_w(u8 data)
{
//printf("w1_%X ",data);
}
u8 gk2000_state::p2_r()
{
//printf("r2 ");
return 0xff;
}
void gk2000_state::p2_w(u8 data)
{
//printf("w2_%X ",data);
// P20-P27: input mux (chessboard), led data
m_inp_mux = (m_inp_mux & 0x700) | (data ^ 0xff);
m_led_pwm->write_mx(~data);
}
u8 gk2000_state::p3_r()
{
//printf("r3 ");
return 0xff;
}
void gk2000_state::p3_w(u8 data)
{
//printf("w3_%X ",data);
}
u8 gk2000_state::p4_r()
{
//printf("r4 ");
// P40-P47: multiplexed inputs
u8 data = 0;
// read buttons
for (int i = 0; i < 3; i++)
if (BIT(m_inp_mux, i + 8))
data |= m_inputs[i]->read();
// read chessboard
for (int i = 0; i < 8; i++)
if (BIT(m_inp_mux, i))
data |= m_board->read_rank(i);
return ~data;
}
void gk2000_state::p4_w(u8 data)
{
//printf("w4_%X ",data);
}
u8 gk2000_state::p5_r()
{
//printf("r5 ");
return 0xff;
}
void gk2000_state::p5_w(u8 data)
{
//printf("w5_%X ",data);
// P50: speaker out
m_dac->write(data & 1);
// P51,P52: led select
m_led_pwm->write_my(~data >> 1 & 3);
// P53-P55: input mux (buttons)
m_inp_mux = (m_inp_mux & 0xff) | (~data << 5 & 0x700);
}
u8 gk2000_state::p6_r()
{
//printf("r6 ");
return 0xff;
}
void gk2000_state::p6_w(u8 data)
{
//printf("w6_%X ",data);
}
u8 gk2000_state::p7_r()
{
//printf("r7 ");
return 0xff;
}
void gk2000_state::p7_w(u8 data)
{
//printf("w7_%X ",data);
}
/*******************************************************************************
Address Maps
*******************************************************************************/
void gk2000_state::main_map(address_map &map)
{
map(0x0000, 0x3fff).rom();
}
/*******************************************************************************
Input Ports
*******************************************************************************/
static INPUT_PORTS_START( gk2000 )
PORT_START("IN.0")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_1) // ng
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_2) // pos
PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_3) // lev
PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_4) // opt
PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_5) // info
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_6) // tb
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_7) // cl
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_8) // ent
PORT_START("IN.1")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_Q) // p
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_W) // n
PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_E) // b
PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_R) // r
PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_T) // q
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_Y) // k
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_U) // -
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_I) // +
PORT_START("IN.2")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_A)
PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_S)
PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_D)
PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_F)
PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_G)
PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_H)
PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_J)
PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_K)
PORT_START("POWER")
PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYPAD) PORT_CODE(KEYCODE_Z) PORT_CHANGED_MEMBER(DEVICE_SELF, gk2000_state, go_button, 0) PORT_NAME("Go / Stop")
INPUT_PORTS_END
/*******************************************************************************
Machine Configs
*******************************************************************************/
void gk2000_state::gk2000(machine_config &config)
{
// basic machine hardware
H8323(config, m_maincpu, 20_MHz_XTAL / 2);
m_maincpu->set_addrmap(AS_PROGRAM, &gk2000_state::main_map);
//m_maincpu->nvram_enable_backup(true);
//m_maincpu->standby_cb().set(m_maincpu, FUNC(h8325_device::nvram_set_battery));
m_maincpu->read_port1().set(FUNC(gk2000_state::p1_r));
m_maincpu->write_port1().set(FUNC(gk2000_state::p1_w));
m_maincpu->read_port2().set(FUNC(gk2000_state::p2_r));
m_maincpu->write_port2().set(FUNC(gk2000_state::p2_w));
m_maincpu->read_port3().set(FUNC(gk2000_state::p3_r));
m_maincpu->write_port3().set(FUNC(gk2000_state::p3_w));
m_maincpu->read_port4().set(FUNC(gk2000_state::p4_r));
m_maincpu->write_port4().set(FUNC(gk2000_state::p4_w));
m_maincpu->read_port5().set(FUNC(gk2000_state::p5_r));
m_maincpu->write_port5().set(FUNC(gk2000_state::p5_w));
m_maincpu->read_port6().set(FUNC(gk2000_state::p6_r));
m_maincpu->write_port6().set(FUNC(gk2000_state::p6_w));
m_maincpu->read_port7().set(FUNC(gk2000_state::p7_r));
m_maincpu->write_port7().set(FUNC(gk2000_state::p7_w));
SENSORBOARD(config, m_board).set_type(sensorboard_device::BUTTONS);
m_board->init_cb().set(m_board, FUNC(sensorboard_device::preset_chess));
m_board->set_delay(attotime::from_msec(150));
//m_board->set_nvram_enable(true);
// video hardware
PWM_DISPLAY(config, m_led_pwm).set_size(2, 8);
//config.set_default_layout(layout_saitek_gk2000);
// sound hardware
SPEAKER(config, "speaker").front_center();
DAC_1BIT(config, m_dac).add_route(ALL_OUTPUTS, "speaker", 0.25);
}
/*******************************************************************************
ROM Definitions
*******************************************************************************/
ROM_START( gk2000 )
ROM_REGION( 0x4000, "maincpu", 0 )
ROM_LOAD("92_saitek_86071220x12_3238a13p.u1", 0x0000, 0x4000, CRC(2059399c) SHA1(d99d5f86b80565e6017b19ef3f330112ac1ce685) )
ROM_END
} // anonymous namespace
/*******************************************************************************
Drivers
*******************************************************************************/
// YEAR NAME PARENT COMPAT MACHINE INPUT CLASS INIT COMPANY, FULLNAME, FLAGS
SYST( 1992, gk2000, 0, 0, gk2000, gk2000, gk2000_state, empty_init, "Saitek", "Kasparov GK 2000", MACHINE_NOT_WORKING | MACHINE_SUPPORTS_SAVE | MACHINE_CLICKABLE_ARTWORK )

34
src/mame/saitek/prisma.cpp
View File

@ -30,7 +30,7 @@ TODO:
#include "cpu/h8/h8325.h"
#include "machine/sensorboard.h"
#include "sound/dac.h"
#include "sound/spkrdev.h"
#include "video/pwm.h"
#include "video/sed1500.h"
@ -50,7 +50,7 @@ public:
driver_device(mconfig, type, tag),
m_maincpu(*this, "maincpu"),
m_board(*this, "board"),
m_display(*this, "display"),
m_led_pwm(*this, "led_pwm"),
m_lcd_pwm(*this, "lcd_pwm"),
m_lcd(*this, "lcd"),
m_dac(*this, "dac"),
@ -70,10 +70,10 @@ private:
// devices/pointers
required_device<h8325_device> m_maincpu;
required_device<sensorboard_device> m_board;
required_device<pwm_display_device> m_display;
required_device<pwm_display_device> m_led_pwm;
required_device<pwm_display_device> m_lcd_pwm;
required_device<sed1502_device> m_lcd;
required_device<dac_bit_interface> m_dac;
required_device<speaker_sound_device> m_dac;
required_ioport_array<4> m_inputs;
output_finder<16, 34> m_out_lcd;
@ -91,7 +91,7 @@ private:
void lcd_output_w(offs_t offset, u64 data);
void standby(int state);
void update_display();
void update_leds();
void p1_w(u8 data);
void p2_w(u8 data);
@ -135,7 +135,11 @@ void prisma_state::standby(int state)
{
if (state)
{
m_display->clear();
// clear display
for (int i = 0; i < 0x80; i++)
m_lcd->write(i, 0);
m_led_pwm->clear();
m_lcd_pwm->clear();
}
}
@ -163,20 +167,20 @@ void prisma_state::lcd_output_w(offs_t offset, u64 data)
// MCU ports
void prisma_state::update_display()
void prisma_state::update_leds()
{
m_display->matrix_partial(0, 2, m_led_select, m_inp_mux);
m_display->matrix_partial(2, 1, 1, m_led_direct);
m_led_pwm->matrix_partial(0, 2, m_led_select, m_inp_mux);
m_led_pwm->matrix_partial(2, 1, 1, m_led_direct);
}
void prisma_state::p1_w(u8 data)
{
// P10-P13: direct leds
m_led_direct = (data & 0xf) ^ 3;
update_display();
update_leds();
// P14: speaker out
m_dac->write(BIT(data, 4));
m_dac->level_w(BIT(data, 4));
// P16: ext power
// (no need to emulate it)
@ -186,7 +190,7 @@ void prisma_state::p2_w(u8 data)
{
// P20-P27: input mux, led data
m_inp_mux = bitswap<8>(~data,7,6,5,4,0,3,1,2);
update_display();
update_leds();
}
void prisma_state::p3_w(u8 data)
@ -224,7 +228,7 @@ void prisma_state::p5_w(u8 data)
{
// P54,P55: led select
m_led_select = ~data >> 4 & 3;
update_display();
update_leds();
}
void prisma_state::p6_w(u8 data)
@ -343,12 +347,12 @@ void prisma_state::prisma(machine_config &config)
screen.set_size(873/2, 1080/2);
screen.set_visarea_full();
PWM_DISPLAY(config, m_display).set_size(2+1, 8);
PWM_DISPLAY(config, m_led_pwm).set_size(2+1, 8);
//config.set_default_layout(layout_saitek_prisma);
// sound hardware
SPEAKER(config, "speaker").front_center();
DAC_1BIT(config, m_dac).add_route(ALL_OUTPUTS, "speaker", 0.25);
SPEAKER_SOUND(config, m_dac).add_route(ALL_OUTPUTS, "speaker", 0.25);
}

12
src/mame/saitek/simultano.cpp
View File

@ -57,7 +57,7 @@ public:
m_maincpu(*this, "maincpu"),
m_rombank(*this, "rombank"),
m_board(*this, "board"),
m_display(*this, "display"),
m_led_pwm(*this, "led_pwm"),
m_lcd_pwm(*this, "lcd_pwm"),
m_lcd(*this, "lcd"),
m_dac(*this, "dac"),
@ -79,7 +79,7 @@ private:
required_device<cpu_device> m_maincpu;
memory_view m_rombank;
required_device<sensorboard_device> m_board;
required_device<pwm_display_device> m_display;
required_device<pwm_display_device> m_led_pwm;
required_device<pwm_display_device> m_lcd_pwm;
required_device<sed1502_device> m_lcd;
required_device<dac_bit_interface> m_dac;
@ -147,7 +147,7 @@ void simultano_state::power_off()
for (int i = 0; i < 0x80; i++)
m_lcd->write(i, 0);
m_display->clear();
m_led_pwm->clear();
m_lcd_pwm->clear();
}
@ -180,8 +180,8 @@ void simultano_state::select_w(u8 data)
// d0-d3: input/chessboard mux
// d6,d7: side panel led mux
// d4,d5: led data
m_display->matrix_partial(0, 2, data >> 4 & 3, 1 << (data & 0xf));
m_display->matrix_partial(2, 2, data >> 6 & 3, ~data >> 4 & 3);
m_led_pwm->matrix_partial(0, 2, data >> 4 & 3, 1 << (data & 0xf));
m_led_pwm->matrix_partial(2, 2, data >> 6 & 3, ~data >> 4 & 3);
m_select = data;
}
@ -339,7 +339,7 @@ void simultano_state::cc2150(machine_config &config)
screen.set_size(873/2, 1080/2);
screen.set_visarea_full();
PWM_DISPLAY(config, m_display).set_size(2+2, 8);
PWM_DISPLAY(config, m_led_pwm).set_size(2+2, 8);
config.set_default_layout(layout_saitek_simultano);
// sound hardware