void awp_draw_reel(int rno)
{
int x = rno + 1;
char rg[16];
sprintf(rg,"reel%d", x);
reelpos[rno] = stepper_get_position(rno);
if (reelpos[rno] == output_get_value(rg))
{
// Not moved, no need to update.
}
else
{
output_set_value(rg,(reelpos[rno]));
// if the reel isn't configured don't do this, otherwise you'll get DIV0
if (stepper_get_max(rno))
{
sprintf(rg,"sreel%d", x); // our new scrolling reels are called 'sreel'
// normalize the value
int sreelpos = (reelpos[rno] * 0x10000) / stepper_get_max(rno);
output_set_value(rg,sreelpos);
}
}
}
static WRITE8_DEVICE_HANDLER( amiga_cia_0_portA_w )
{
amiga_state *state = space.machine().driver_data<amiga_state>();
/* switch banks as appropriate */
state->m_bank1->set_entry(data & 1);
/* swap the write handlers between ROM and bank 1 based on the bit */
if ((data & 1) == 0) {
UINT32 mirror_mask = state->m_chip_ram.bytes();
while( (mirror_mask<<1) < 0x100000 ) {
mirror_mask |= ( mirror_mask << 1 );
}
/* overlay disabled, map RAM on 0x000000 */
state->m_maincpu_program_space->install_write_bank(0x000000, state->m_chip_ram.bytes() - 1, 0, mirror_mask, "bank1");
/* if there is a cart region, check for cart overlay */
if (space.machine().root_device().memregion("user2")->base() != NULL)
amiga_cart_check_overlay(space.machine());
}
else
/* overlay enabled, map Amiga system ROM on 0x000000 */
state->m_maincpu_program_space->unmap_write(0x000000, state->m_chip_ram.bytes() - 1);
set_led_status( space.machine(), 0, ( data & 2 ) ? 0 : 1 ); /* bit 2 = Power Led on Amiga */
output_set_value("power_led", ( data & 2 ) ? 0 : 1);
}
void update_moles()
{
for (int i = 0; i < 6; i++)
{
char temp[32];
sprintf(temp, "molea_%d", i);
output_set_value(temp, mole_state_a[i]);
}
for (int i = 0; i < 6; i++)
{
char temp[32];
sprintf(temp, "moleb_%d", i);
output_set_value(temp, mole_state_b[i]);
}
}
void device_output_interface::set_digit_value(int value)
{
if (m_output_name)
output_set_value(m_output_name, value);
else
output_set_digit_value(m_output_index, value);
}
void device_output_interface::set_output_value(int value)
{
if (m_output_name)
output_set_value(m_output_name, value);
else
fatalerror("Output name not set!");
}
INPUT_PORTS_END
void h8_state::machine_reset()
{
m_beep->set_frequency(H8_BEEP_FRQ);
output_set_value("pwr_led", 0);
m_irq_ctl = 1;
}
static MACHINE_RESET( mephisto )
{
mephisto_state *state = machine.driver_data<mephisto_state>();
state->m_lcd_shift_counter = 3;
state->m_allowNMI = 1;
mboard_set_border_pieces();
mboard_set_board();
/* adjust artwork depending on current emulation*/
if (!strcmp(machine.system().name,"mm2") )
output_set_value("MM",1);
else if (!strcmp(machine.system().name,"mm4") )
output_set_value("MM",2);
else if (!strcmp(machine.system().name,"mm4tk") )
output_set_value("MM",5);
else if (!strcmp(machine.system().name,"mm5tk") )
output_set_value("MM",5);
else if (!strcmp(machine.system().name,"mm5") )
output_set_value("MM",3);
else if (!strcmp(machine.system().name,"mm50") )
output_set_value("MM",3);
else if (!strcmp(machine.system().name,"rebel5") )
output_set_value("MM",4);
}
void amiga_fdc::setup_leds()
{
if(floppy) {
int drive =
floppy == floppy_devices[0] ? 0 :
floppy == floppy_devices[1] ? 1 :
floppy == floppy_devices[2] ? 2 :
3;
output_set_value("drive_0_led", drive == 0);
output_set_value("drive_1_led", drive == 1);
output_set_value("drive_2_led", drive == 2);
output_set_value("drive_3_led", drive == 3);
set_led_status(machine(), 1, drive == 0); /* update internal drive led */
set_led_status(machine(), 2, drive == 1); /* update external drive led */
}
}
static WRITE8_HANDLER( lx800_portc_w )
{
lx800_state *lx800 = space->machine().driver_data<lx800_state>();
logerror("%s: lx800_portc_w(%02x): %02x\n", space->machine().describe_context(), offset, data);
logerror("--> err: %d, ack: %d, fire: %d, buzzer: %d\n", BIT(data, 4), BIT(data, 5), BIT(data, 6), BIT(data, 7));
output_set_value("online_led", !BIT(data, 2));
beep_set_state(lx800->m_speaker, !BIT(data, 7));
}
void awp_draw_reel(int rno)
{
int rsteps = steps[rno];
int rsymbols = symbols[rno];
int m;
int x = rno + 1;
char rg[16], rga[16], rgb[16];
sprintf(rg,"reel%d", x);
reelpos[rno] = stepper_get_position(rno);
if (reelpos[rno] == output_get_value(rg))
{
// Not moved, no need to update.
}
else
{
reelpos[rno] = stepper_get_position(rno)%(stepper_get_max(rno)-1);
for ( m = 0; m < (rsymbols-1); m++ )
{
{
sprintf(rga,"reel%da%d", x, m);
output_set_value(rga,(reelpos[rno] + rsteps * m)%stepper_get_max(rno));
}
{
if ((reelpos[rno] - rsteps * m) < 0)
{
sprintf(rgb,"reel%db%d", x, m);
output_set_value(rgb,(reelpos[rno] - (rsteps * m - stepper_get_max(rno))));
}
else
{
sprintf(rgb,"reel%db%d", x, m);
output_set_value(rgb,(reelpos[rno] - rsteps * m));
}
}
}
output_set_value(rg,(reelpos[rno]));
}
}
static WRITE32_HANDLER( motor_control_w )
{
/*
Standard value poked into MSW is 0x3c00
(0x2000 and zero are written at startup)
*/
if (data & 0x1000000)
{
output_set_value("Player1_Gun_Recoil",1);
}
else
{
output_set_value("Player1_Gun_Recoil",0);
}
if (data & 0x10000)
{
output_set_value("Player2_Gun_Recoil",1);
}
else
{
output_set_value("Player2_Gun_Recoil",0);
}
if (data & 0x40000)
{
output_set_value("Hit_lamp",1);
}
else
{
output_set_value("Hit_lamp",0);
}
}
static void mouse_update(running_machine &machine)
{
supercon_state *state = machine.driver_data<supercon_state>();
UINT8 port_input; // m_left;
int i;
/* Boarder pieces and moving pice */
port_input=input_port_read(machine, "B_WHITE");
if (port_input)
{
i=get_first_bit(port_input);
state->m_moving_piece=border_pieces[i];
output_set_value("MOVING",state->m_moving_piece);
return;
}
port_input=input_port_read(machine, "B_BLACK");
if (port_input)
{
i=get_first_bit(port_input);
state->m_moving_piece=border_pieces[6+i];
output_set_value("MOVING",state->m_moving_piece);
return;
}
port_input=input_port_read(machine, "B_CLR");
if (port_input)
{
if (state->m_moving_piece)
{
state->m_moving_piece=0;
output_set_value("MOVING",state->m_moving_piece);
return;
}
}
}
void supercon_state::mouse_update()
{
UINT8 port_input; // m_left;
int i;
/* border pieces and moving piece */
port_input = m_b_white->read();
if (port_input)
{
i = get_first_bit(port_input);
m_moving_piece = m_border_pieces[i];
output_set_value("MOVING", m_moving_piece);
return;
}
port_input = m_b_black->read();
if (port_input)
{
i = get_first_bit(port_input);
m_moving_piece = m_border_pieces[6+i];
output_set_value("MOVING", m_moving_piece);
return;
}
port_input = m_b_clr->read();
if (port_input)
{
if (m_moving_piece)
{
m_moving_piece=0;
output_set_value("MOVING", m_moving_piece);
return;
}
}
}
INPUT_PORTS_END
void h8_state::machine_reset()
{
m_beep->set_frequency(H8_BEEP_FRQ);
output_set_value("pwr_led", 0);
m_irq_ctl = 1;
m_cass_state = 1;
m_cass_data[0] = 0;
m_cass_data[1] = 0;
m_uart->write_rxd(0);
m_cass_data[3] = 0;
m_ff_b = 1;
}
static WRITE16_HANDLER( term2_sound_w )
{
midyunit_state *state = space->machine().driver_data<midyunit_state>();
/* Flash Lamp Output Data */
if ( ((data & 0x800) != 0x800) && ((data & 0x400) == 0x400 ) )
{
output_set_value("Left_Flash_1", data & 0x1);
output_set_value("Left_Flash_2", (data & 0x2) >> 1);
output_set_value("Left_Flash_3", (data & 0x4) >> 2);
output_set_value("Left_Flash_4", (data & 0x8) >> 3);
output_set_value("Right_Flash_1", (data & 0x10) >> 4);
output_set_value("Right_Flash_2", (data & 0x20) >> 5);
output_set_value("Right_Flash_3", (data & 0x40) >> 6);
output_set_value("Right_Flash_4", (data & 0x80) >> 7);
}
void awp_draw_reel(const char* reeltag, stepper_device &reel)
{
char rg[16];
int reelpos = reel.get_position();
if (reelpos == output_get_value(reeltag))
{
// Not moved, no need to update.
}
else
{
output_set_value(reeltag,(reelpos));
// if the reel isn't configured don't do this, otherwise you'll get DIV0
if (reel.get_max())
{
sprintf(rg,"s%s", reeltag); // our new scrolling reels are called 'sreel'
// normalize the value
int sreelpos = (reelpos * 0x10000) / reel.get_max();
output_set_value(rg,sreelpos);
}
}
}
void eacc_state::eacc_display()
{
UINT8 i;
char lednum[6];
for (i = 3; i < 7; i++)
if (BIT(m_digit, i))
output_set_digit_value(i, m_segment);
if (BIT(m_digit, 7))
for (i = 0; i < 8; i++)
{
sprintf(lednum,"led%d",i);
output_set_value(lednum, BIT(m_segment, i)^1);
}
}
void vt100_state::machine_reset()
{
m_keyboard_int = 0;
m_receiver_int = 0;
m_vertical_int = 0;
m_speaker->set_frequency(786); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz
output_set_value("online_led",1);
output_set_value("local_led", 0);
output_set_value("locked_led",1);
output_set_value("l1_led", 1);
output_set_value("l2_led", 1);
output_set_value("l3_led", 1);
output_set_value("l4_led", 1);
m_key_scan = 0;
}
void output_set_indexed_value(const char *basename, int index, int value)
{
char buffer[100];
char *dest = buffer;
/* copy the string */
while (*basename != 0)
*dest++ = *basename++;
/* append the index */
if (index >= 1000) *dest++ = '0' + ((index / 1000) % 10);
if (index >= 100) *dest++ = '0' + ((index / 100) % 10);
if (index >= 10) *dest++ = '0' + ((index / 10) % 10);
*dest++ = '0' + (index % 10);
*dest++ = 0;
/* set the value */
output_set_value(buffer, value);
}
void vt100_state::machine_reset()
{
m_keyboard_int = 0;
m_receiver_int = 0;
m_vertical_int = 0;
beep_set_frequency( m_speaker, 786 ); // 7.945us per serial clock = ~125865.324hz, / 160 clocks per char = ~ 786 hz
output_set_value("online_led",1);
output_set_value("local_led", 0);
output_set_value("locked_led",1);
output_set_value("l1_led", 1);
output_set_value("l2_led", 1);
output_set_value("l3_led", 1);
output_set_value("l4_led", 1);
m_key_scan = 0;
machine().device("maincpu")->execute().set_irq_acknowledge_callback(vt100_irq_callback);
}
static READ8_HANDLER( supercon_port4_r )
{
supercon_state *state = space->machine().driver_data<supercon_state>();
int i_18, i_AH;
UINT8 key_data = 0x00;;
static const char *const board_lines[8] =
{ "BOARD_1", "BOARD_2", "BOARD_3", "BOARD_4", "BOARD_5", "BOARD_6", "BOARD_7", "BOARD_8" };
LOG(("Read from %04x \n",0x1F00));
/* Board buttons */
i_18=get_first_bit(state->m_data_1E00);
if (i_18==NOT_VALID)
return 0xff;
/* if a button was pressed wait til timer -timer_mouse_click- is fired */
if (state->m_selecting)
return state->m_save_key_data;
else
{
set_pieces(state);
output_set_value("MOVING",state->m_moving_piece);
}
key_data=input_port_read(space->machine(), board_lines[i_18]);
if (key_data != 0xff)
{
LOG(("%s key_data: %02x \n",board_lines[i_18],key_data));
/* Only if valid data and mouse button is pressed */
if (key_data && input_port_read(space->machine(), "BUTTON_L"))
{
/* Set or remove pieces */
i_AH=7-get_first_cleared_bit(key_data);
LOG(("Press -> AH: %d 18: %d Piece: %d\n",i_AH,i_18,state->m_board[i_18*8 + i_AH]););
static TIMER_DEVICE_CALLBACK( display_callback )
{
tm990189 *state = timer.machine().driver_data<tm990189>();
UINT8 i;
char ledname[8];
// since the segment data is cleared after being used, the old_segment is there
// in case the segment data hasn't been refreshed yet.
for (i = 0; i < 10; i++)
{
state->m_old_segment_state[i] |= state->m_segment_state[i];
sprintf(ledname,"digit%d",i);
output_set_digit_value(i, state->m_old_segment_state[i]);
state->m_old_segment_state[i] = state->m_segment_state[i];
state->m_segment_state[i] = 0;
}
for (i = 0; i < 7; i++)
{
sprintf(ledname,"led%d",i);
output_set_value(ledname, !BIT(state->m_LED_state, i));
}
}
static WRITE16_HANDLER( othunder_tc0220ioc_w )
{
othunder_state *state = space->machine().driver_data<othunder_state>();
if (ACCESSING_BITS_0_7)
{
switch (offset)
{
case 0x03:
/* 0000000x SOL-1 (gun solenoid)
000000x0 SOL-2 (gun solenoid)
00000x00 OBPRI (sprite priority)
0000x000 (unused)
000x0000 eeprom reset (active low)
00x00000 eeprom clock
0x000000 eeprom in data
x0000000 eeprom out data */
/* Recoil Piston Motor Status */
output_set_value("Player1_Recoil_Piston", data & 0x1 );
output_set_value("Player2_Recoil_Piston", (data & 0x2) >>1 );
if (data & 4)
popmessage("OBPRI SET!");
eeprom_write_bit(state->m_eeprom, data & 0x40);
eeprom_set_clock_line(state->m_eeprom, (data & 0x20) ? ASSERT_LINE : CLEAR_LINE);
eeprom_set_cs_line(state->m_eeprom, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
break;
default:
tc0220ioc_w(state->m_tc0220ioc, offset, data & 0xff);
}
}
}
void mephisto_state::machine_reset()
{
m_lcd_shift_counter = 3;
m_allowNMI = 1;
mboard_set_border_pieces();
mboard_set_board();
/* adjust artwork depending on current emulation*/
if (!strcmp(machine().system().name,"mm2") )
output_set_value("MM",1);
else if (!strcmp(machine().system().name,"mm4") )
output_set_value("MM",2);
else if (!strcmp(machine().system().name,"mm4tk") )
output_set_value("MM",5);
else if (!strcmp(machine().system().name,"mm5tk") )
output_set_value("MM",5);
else if (!strcmp(machine().system().name,"mm5") )
output_set_value("MM",3);
else if (!strcmp(machine().system().name,"mm50") )
output_set_value("MM",3);
else if (!strcmp(machine().system().name,"rebel5") )
output_set_value("MM",4);
}
static WRITE32_HANDLER( twinkle_io_w )
{
twinkle_state *state = space->machine().driver_data<twinkle_state>();
if( ACCESSING_BITS_16_23 )
{
state->m_io_offset = ( data >> 16 ) & 0xff;
}
if( ACCESSING_BITS_0_7 )
{
if( state->m_output_last[ state->m_io_offset ] != ( data & 0xff ) )
{
state->m_output_last[ state->m_io_offset ] = ( data & 0xff );
switch( state->m_io_offset )
{
/* ? */
case 0x07:
case 0x0f:
case 0x17:
case 0x1f:
case 0x27:
case 0x2f:
case 0x37:
/* led */
case 0x3f:
case 0x47:
case 0x4f:
case 0x57:
case 0x5f:
case 0x67:
case 0x6f:
case 0x77:
case 0x7f:
output_set_indexed_value( "led", ( state->m_io_offset - 7 ) / 8, asciicharset[ ( data ^ 0xff ) & 0x7f ] );
break;
case 0x87:
output_set_indexed_value( "spotlight", 0, ( ~data >> 3 ) & 1 );
output_set_indexed_value( "spotlight", 1, ( ~data >> 2 ) & 1 );
output_set_indexed_value( "spotlight", 2, ( ~data >> 1 ) & 1 );
output_set_indexed_value( "spotlight", 3, ( ~data >> 0 ) & 1 );
output_set_indexed_value( "spotlight", 4, ( ~data >> 4 ) & 1 );
output_set_indexed_value( "spotlight", 5, ( ~data >> 5 ) & 1 );
output_set_indexed_value( "spotlight", 6, ( ~data >> 6 ) & 1 );
output_set_indexed_value( "spotlight", 7, ( ~data >> 7 ) & 1 );
break;
case 0x8f:
output_set_value( "neonlamp", ~data & 1 );
if( ( data & 0xfe ) != 0xfe )
{
printf("%02x = %02x\n", state->m_io_offset, data & 0xff );
}
break;
default:
printf( "unknown io %02x = %02x\n", state->m_io_offset, data & 0xff );
break;
}
}
}
static WRITE8_HANDLER( m79amb_8002_w )
{
/* D1 may also be watchdog reset */
/* port goes to 0x7f to turn on explosion lamp */
output_set_value("EXP_LAMP", data ? 1 : 0);
}
void mgavegas_state::update_lamp(){
//output_set_value("AUXS", m_auxs); //unused
output_set_value("MGA4", m_anal&0x01);
output_set_value("MGA3", m_anacl&0x01);
output_set_value("MGA2", m_anacr&0x01);
output_set_value("MGA", m_anar&0x01);
output_set_value("PL", m_pl&0x01);
output_set_value("PC", m_pc&0x01);
output_set_value("PR", m_pr&0x01);
output_set_value("250", m_luz_250_rul&0x01);
output_set_value("1002", m_luz_100_rul&0x01);
output_set_value("50", m_luz_50_rlul&0x01);
output_set_value("252", m_luz_25_lrul&0x01);
output_set_value("25", m_luz_25_rrul&0x01);
output_set_value("FL", m_fl&0x01);
output_set_value("FC", m_fc&0x01);
output_set_value("FR", m_fr&0x01);
output_set_value("INSERTCOIN", m_insert_coin&0x01);
output_set_value("NOCAMBIO", m_no_cambio&0x01);
output_set_value("FUSE", m_fuse&0x01);
output_set_value("FALTA", m_falta&0x01);
//output_set_value("ANAG", m_anag&0x01); //unused
output_set_value("CL", m_cl&0x01);
output_set_value("CC", m_cc&0x01);
output_set_value("CR", m_cr&0x01);
output_set_value("PREMIOS", m_premio_s&0x01);
output_set_value("100", m_100&0x01);
output_set_value("200", m_200&0x01);
output_set_value("300", m_300&0x01);
output_set_value("500", m_500&0x01);
output_set_value("ML", m_ml&0x01);
output_set_value("MC", m_mc&0x01);
output_set_value("MR", m_mr&0x01);
/*
m_inh=BIT(data, 3);
m_printer=BIT(data, 6); //not_used
m_auxp=BIT(data, 7); //not_used
m_bobina_ctrl=BIT(data, 0);
m_timbre=BIT(data, 1);
m_coil_1=BIT(data, 2);
m_coil_2=BIT(data, 3);
m_coil_3=BIT(data, 4);
m_cont_ent=BIT(data, 5);
m_cont_sal=BIT(data, 6);
m_cont_caj=BIT(data, 7);
*/
}
void x68k_keyboard_device::write(UINT8 data)
{
/* Keyboard control commands:
00xxxxxx - TV Control
Not of much use as yet
01000xxy - y = Mouse control signal
01001xxy - y = Keyboard enable
010100xy - y = Sharp X1 display compatibility mode
010101xx - xx = LED brightness (00 = bright, 11 = dark)
010110xy - y = Display control enable
010111xy - y = Display control via the Opt. 2 key enable
0110xxxx - xxxx = Key delay (default 500ms)
100 * (delay time) + 200ms
0111xxxx - xxxx = Key repeat rate (default 110ms)
(repeat rate)^2*5 + 30ms
1xxxxxxx - xxxxxxx = keyboard LED status
b6 = "full size"
b5 = hiragana
b4 = insert
b3 = caps
b2 = code input
b1 = romaji input
b0 = kana
*/
if(data & 0x80) // LED status
{
output_set_value("key_led_kana",(data & 0x01) ? 0 : 1);
output_set_value("key_led_romaji",(data & 0x02) ? 0 : 1);
output_set_value("key_led_code",(data & 0x04) ? 0 : 1);
output_set_value("key_led_caps",(data & 0x08) ? 0 : 1);
output_set_value("key_led_insert",(data & 0x10) ? 0 : 1);
output_set_value("key_led_hiragana",(data & 0x20) ? 0 : 1);
output_set_value("key_led_fullsize",(data & 0x40) ? 0 : 1);
logerror("KB: LED status set to %02x\n",data & 0x7f);
}
if((data & 0xc0) == 0) // TV control
{
// nothing for now
}
if((data & 0xf8) == 0x48) // Keyboard enable
{
m_enabled = data & 0x01;
logerror("KB: Keyboard enable bit = %i\n",m_enabled);
}
if((data & 0xf0) == 0x60) // Key delay time
{
m_delay = data & 0x0f;
logerror("KB: Keypress delay time is now %ims\n",(data & 0x0f)*100+200);
}
if((data & 0xf0) == 0x70) // Key repeat rate
{
m_repeat = data & 0x0f;
logerror("KB: Keypress repeat rate is now %ims\n",((data & 0x0f)^2)*5+30);
}
}
LEGACY_FLOPPY_OPTIONS_END
void rainbow_state::machine_reset()
{
if (COLD_BOOT == 1)
{
COLD_BOOT = 2;
m_crtc->MHFU(-100); // reset MHFU counter
}
m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
INT88 = false;
INTZ80 = false;
m_zflip = true;
m_z80_halted = true;
m_kbd_tx_ready = m_kbd_rx_ready = false;
m_kbd8251->input_callback(device_serial_interface::CTS); // raise clear to send
m_KBD = 0;
m_beep->set_frequency(2000);
m_beep->set_state(0);
// RESET ALL LEDs
output_set_value("led1", 1);
output_set_value("led2", 1);
output_set_value("led3", 1);
output_set_value("led4", 1);
output_set_value("led5", 1);
output_set_value("led6", 1);
output_set_value("led7", 1);
output_set_value("led8", 1);
output_set_value("led9", 1);
output_set_value("led10", 1);
output_set_value("led11", 1);
MOTOR_DISABLE_counter = 2; // soon resets drv.LEDs
m_unit = 0;
}
INPUT_PORTS_END
void rainbow_state::machine_reset()
{
m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
m_zflip = true;
m_z80_halted = true;
m_kbd_tx_ready = m_kbd_rx_ready = false;
m_kbd8251->input_callback(SERIAL_STATE_CTS); // raise clear to send
m_KBD = 0;
m_beep->set_frequency(2000);
m_beep->set_state(0);
// RESET ALL LEDs
output_set_value("led1", 1);
output_set_value("led2", 1);
output_set_value("led3", 1);
output_set_value("led4", 1);
output_set_value("led5", 1);
output_set_value("led6", 1);
output_set_value("led7", 1);
output_set_value("led8", 1);
output_set_value("led9", 1);
output_set_value("led10", 1);
output_set_value("led11", 1);
output_set_value("led20", 1); // DRIVE 0 (A)
output_set_value("led21", 1); // DRIVE 1 (B)
}
