summaryrefslogtreecommitdiffstatshomepage
path: root/src/mame/machine/nl_rebound.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mame/machine/nl_rebound.cpp')
-rw-r--r--src/mame/machine/nl_rebound.cpp1272
1 files changed, 1272 insertions, 0 deletions
diff --git a/src/mame/machine/nl_rebound.cpp b/src/mame/machine/nl_rebound.cpp
new file mode 100644
index 00000000000..b01422e9b7e
--- /dev/null
+++ b/src/mame/machine/nl_rebound.cpp
@@ -0,0 +1,1272 @@
+// license:GPL-2.0+
+// copyright-holders:Couriersud,DICE Team,
+/*
+ * The work herein is based on the "Rebound computer service manual"
+ * available on archive.org:
+ *
+ * https://archive.org/details/ArcadeGameManualRebound
+ *
+ * Changelog:
+ *
+ * - Migrated from DICE (Couriersud)
+ * - Added all missing elements (Couriersud)
+ * - Added discrete startup logic
+ * - Added credit led
+ * - Added missing start and coin discrete elements
+ * - Added missing paddle elements
+ * - Fixed bugs in start and coin logic and ensured it matches schematics
+ * - Replaced HLE by discrete elements (Couriersud)
+ * - Documented PCB connector (Couriersud)
+ *
+ * TODO:
+ * - Add switch to pull Connector 3 (CON3) to GND
+ *
+ * The MAME team has asked for and received written confirmation from the
+ * author of DICE to use, modify and redistribute code under:
+ *
+ * - GPL (GNU General Public License)
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * - DICE itself is licensed under version 3 of the GNU General Public License.
+ * Under no circumstances the exemptions listed above shall apply to any
+ * other code of DICE not contained in this file.
+ *
+ * The following is an extract from the DICE readme.
+ *
+ * ----------------------------------------------------------------------------
+ *
+ * DICE is a Discrete Integrated Circuit Emulator. It emulates computer systems
+ * that lack any type of CPU, consisting only of discrete logic components.
+ *
+ * Project Page: http://sourceforge.net/projects/dice/
+ * Email: dice.emulator@gmail.com
+ *
+ * License
+ *
+ * Copyright (C) 2008-2013 DICE Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ */
+
+#ifndef __PLIB_PREPROCESSOR__
+ #define NL_PROHIBIT_BASEH_INCLUDE 1
+ #include "netlist/devices/net_lib.h"
+#endif
+
+NETLIST_START(rebound_schematics)
+ SOLVER(Solver, 48000)
+ PARAM(Solver.DYNAMIC_TS, 1)
+ PARAM(Solver.LTE, 1e-2)
+ PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 5e-7)
+
+ PARAM(Solver.PARALLEL, 0) // Don't do parallel solvers
+ PARAM(Solver.ACCURACY, 1e-9)
+ PARAM(NETLIST.USE_DEACTIVATE, 1)
+
+ ANALOG_INPUT(V5, 5)
+
+ /* -----------------------------------------------------------------------
+ * External interface section
+ * -----------------------------------------------------------------------*/
+
+ SWITCH2(COIN1_SW)
+ SWITCH2(START_SW)
+
+ TTL_INPUT(antenna, 0)
+
+ // DSW1a/b are actually only a 1 contact switches.
+ // The logic is needed to force high level on
+ // inputs since proxies have zero input impedance.
+ SWITCH2(DSW1a)
+ NET_C(V5, DSW1a.1)
+ SWITCH2(DSW1b)
+ NET_C(V5, DSW1b.1)
+ SWITCH2(DSW2)
+
+ // POTS
+ POT(POTP1, RES_K(1)) // 1k ... pure guess - not documented
+ PARAM(POTP1.DIALLOG, 0)
+ PARAM(POTP1.REVERSE, 1)
+ NET_C(POTP1.1, V5)
+ NET_C(POTP1.3, GND)
+ ALIAS(CON14, POTP1.2)
+
+ POT(POTP2, RES_K(1)) // 1k ... pure guess - not documented
+ PARAM(POTP2.DIALLOG, 0)
+ PARAM(POTP2.REVERSE, 1)
+ NET_C(POTP2.1, V5)
+ NET_C(POTP2.3, GND)
+ ALIAS(CON18, POTP2.2)
+
+ NET_C(START_SW.1, CON5)
+ NET_C(START_SW.2, CON7)
+ NET_C(START_SW.Q, GND)
+
+ NET_C(COIN1_SW.1, CON12)
+ NET_C(COIN1_SW.2, CON10)
+ NET_C(COIN1_SW.Q, GND)
+
+ NET_C(CON15, antenna)
+
+ /* -----------------------------------------------------------------------
+ * Real netlist start
+ * -----------------------------------------------------------------------*/
+
+ MAINCLOCK(CLOCK, 14318000.0) //7159000.0*2
+
+ TTL_7400_DIP(A1)
+
+ TTL_7400_DIP(B1)
+ TTL_7474_DIP(B2)
+ TTL_74107_DIP(B3)
+ TTL_9316_DIP(B4)
+ TTL_7404_DIP(B5)
+ TTL_9322_DIP(B6)
+ TTL_9316_DIP(B7)
+ TTL_7410_DIP(B8)
+ TTL_7493_DIP(C1)
+ TTL_7450_DIP(C2)
+ TTL_7410_DIP(C3)
+ TTL_9316_DIP(C4)
+ TTL_7486_DIP(C5)
+ TTL_7474_DIP(C6)
+ TTL_9316_DIP(C7)
+ TTL_7402_DIP(C8)
+ TTL_7402_DIP(D2)
+ TTL_9316_DIP(D3)
+ TTL_9316_DIP(D4)
+ TTL_7400_DIP(D5)
+ TTL_7474_DIP(D6)
+ TTL_7400_DIP(D7)
+ TTL_7474_DIP(D8)
+
+ TTL_7400_DIP(E1)
+ TTL_7483_DIP(E2)
+ TTL_9316_DIP(E3)
+ TTL_74193_DIP(E4)
+ TTL_7408_DIP(E5)
+ TTL_7402_DIP(E6)
+ TTL_7474_DIP(E7)
+ TTL_7474_DIP(E8)
+ TTL_7404_DIP(E9)
+
+ TTL_7474_DIP(F1)
+ TTL_7408_DIP(F2)
+ TTL_74107_DIP(F3)
+ TTL_7420_DIP(F4)
+ TTL_7493_DIP(F5)
+ TTL_7410_DIP(F6)
+ TTL_7408_DIP(F7)
+ TTL_7410_DIP(F8)
+ TTL_7404_DIP(F9)
+
+ TTL_7400_DIP(H1)
+ TTL_7410_DIP(H2)
+ TTL_7493_DIP(H3)
+ TTL_74107_DIP(H4)
+ TTL_7493_DIP(H5)
+ TTL_7427_DIP(H6)
+ TTL_7410_DIP(H7)
+ TTL_7430_DIP(H8)
+ TTL_74107_DIP(H9)
+
+ TTL_7474_DIP(J1)
+ TTL_7474_DIP(J2)
+ TTL_7493_DIP(J3)
+ TTL_7474_DIP(J4)
+ TTL_7486_DIP(J5)
+ TTL_7400_DIP(J6)
+ TTL_7410_DIP(J7)
+ TTL_74153_DIP(J8)
+ TTL_7490_DIP(J9)
+
+ TTL_7493_DIP(K2)
+ TTL_9316_DIP(K3)
+ TTL_7400_DIP(K4)
+ TTL_7474_DIP(K5)
+ TTL_7402_DIP(K6)
+ TTL_7448_DIP(K7)
+ TTL_74153_DIP(K8)
+ TTL_7490_DIP(K9)
+
+ /* -----------------------------------------------------------------------
+ * Paddle 2
+ * -----------------------------------------------------------------------*/
+
+ // FIXME: Hack, schematic shows 100k (100 to be exact which makes even less sense)
+ // One way or the other, according to schematics both horizontal position logic for
+ // P1 and P2 start at hreset_n. This limits the usable range for P2.
+
+ RES(R24, 47)
+ CAP(CC27, CAP_U(0.1))
+ NET_C(CC27.2, GND)
+ NET_C(B9.5, CC27.1, R24.2)
+ NET_C(R24.1, CON18)
+
+ NE555_DIP(B9)
+ RES(R23, RES_K(200.0))
+ CAP(CC26, CAP_P(220.0))
+
+ NET_C(B9.6, B9.7)
+ NET_C(B9.6, R23.1)
+ NET_C(B9.6, CC26.1)
+ NET_C(R23.2, V5)
+ NET_C(CC26.2, GND)
+ NET_C(B9.8, V5)
+ NET_C(B9.1, GND)
+
+ /* -----------------------------------------------------------------------
+ * Paddle 1
+ * -----------------------------------------------------------------------*/
+
+ RES(R17, 47)
+ CAP(CC23, CAP_U(0.1))
+ NET_C(CC23.2, GND)
+ NET_C(C9.5, CC23.1, R17.2)
+ NET_C(R17.1, CON14)
+
+ NE555_DIP(C9)
+ NET_C(C9.6, C9.7)
+ RES(R16, RES_K(100.0))
+ CAP(CC22, CAP_P(220.0))
+ NET_C(C9.6, R16.1)
+ NET_C(C9.6, CC22.1)
+ NET_C(R16.2, V5)
+ NET_C(CC22.2, GND)
+ NET_C(C9.8, V5)
+ NET_C(C9.1, GND)
+
+ TTL_9602_DIP(D1)
+
+ RES(R10, RES_K(47.0))
+ CAP(CC16, CAP_U(5.0))
+ RES(R9, RES_K(47.0))
+ CAP(CC21, CAP_U(10.0))
+
+ NET_C(V5, D1.16)
+ NET_C(GND, D1.8)
+ NET_C(D1.1, CC16.1)
+ NET_C(D1.2, CC16.2)
+ NET_C(D1.2, R10.2)
+ NET_C(V5, R10.1)
+ NET_C(D1.15, CC21.1)
+ NET_C(D1.14, CC21.2)
+ NET_C(D1.14, R9.2)
+ NET_C(V5, R9.1)
+
+ TTL_9602_DIP(K1)
+
+ RES(R2, RES_K(33.0))
+ CAP(CC2, CAP_U(47.0))
+ RES(R1, RES_K(47.0))
+ CAP(CC3, CAP_U(10.0))
+
+ NET_C(V5, K1.16)
+ NET_C(GND, K1.8)
+ NET_C(K1.1, CC2.1)
+ NET_C(K1.2, CC2.2)
+ NET_C(K1.2, R2.2)
+ NET_C(V5, R2.1)
+ NET_C(K1.15, CC3.1)
+ NET_C(K1.14, CC3.2)
+ NET_C(K1.14, R1.2)
+ NET_C(V5, R1.1)
+
+ /* -----------------------------------------------------------------------
+ * Start circuit
+ * -----------------------------------------------------------------------*/
+
+ RES(R30, RES_K(1))
+ RES(R31, RES_K(1))
+
+ NET_C(V5, R31.1, R30.1)
+ NET_C(B1.3, B1.4, A1.5, R30.2)
+ NET_C(B1.6, B1.2)
+ NET_C(R31.2, E9.1)
+ NET_C(E9.2, B1.1)
+
+ ALIAS(CON5, R30.2)
+ ALIAS(CON7, B1.2)
+ ALIAS(CON3, R31.2) // Not explained in manual
+
+ /* -----------------------------------------------------------------------
+ * Coin circuit
+ * -----------------------------------------------------------------------*/
+
+ DIODE(CR3, "1N916")
+ DIODE(CR4, "1N4001")
+ CAP(CC20, CAP_U(0.1))
+ CAP(CC17, CAP_U(0.1))
+ CAP(CC18, CAP_U(0.1))
+ CAP(CC19, CAP_U(0.1))
+ RES(R12, RES_K(1))
+ RES(R13, RES_K(100))
+
+ NE555_DIP(D9)
+
+ NET_C(V5, CR4.K, R12.1, D9.8, D9.4, R13.1, E8.10)
+ NET_C(CR3.K, CR4.A)
+ NET_C(E9.10, E9.13, B1.5, CC20.2, CR3.A)
+ NET_C(E9.12, E9.11, CC17.1, C8.2, E8.13, E8.12)
+ NET_C(CC20.1, R12.2, D9.2)
+ NET_C(CC19.1, D9.5)
+ NET_C(CC18.1, D9.6, D9.7, R13.2)
+ NET_C(D9.3, E9.9)
+ NET_C(E9.8, E8.11)
+ NET_C(CR8.K, E8.8, D8.1, D8.13)
+
+ NET_C(GND, CC17.2, CC19.2, D9.1, CC18.2)
+
+ ALIAS(CON12, E9.11)
+ ALIAS(CON10, CR3.K)
+
+ /* -----------------------------------------------------------------------
+ * Power on clear
+ * -----------------------------------------------------------------------*/
+
+ QBJT_EB(Q1, "2N3643")
+ QBJT_EB(Q2, "2N3644")
+ QBJT_EB(Q3, "2N3643")
+ DIODE(CR6, "1N914")
+ DIODE(CR7, "1N914")
+ DIODE(CR8, "1N914") // not readable on schematic, guessing CR8
+
+ CAP(CC15, CAP_U(0.1))
+ CAP(CC24, CAP_U(0.1))
+ RES(R8, 100)
+ RES(R14, 330)
+ RES(R15, 100)
+ RES(R18, 100)
+ RES(R19, 220)
+
+ NET_C(D7.3, CR6.K)
+ NET_C(CR6.A, R19.1, R15.2)
+ NET_C(R15.1, Q2.C)
+ NET_C(V5, Q2.E, CC15.1, R8.1)
+ NET_C(Q2.B, CC15.2, R8.2, R14.1)
+ NET_C(R14.2, Q3.C, CR8.A, E9.3)
+ NET_C(Q1.C, R19.2, CC24.1, R18.1, Q3.B)
+ NET_C(GND, Q1.E, CC24.2, R18.2, Q3.E, CR7.A)
+ NET_C(CR7.K, Q1.B)
+
+ /* -----------------------------------------------------------------------
+ * Antenna
+ * -----------------------------------------------------------------------*/
+
+ ALIAS(CON15, CR7.K)
+
+ /* -----------------------------------------------------------------------
+ * Credit LED
+ * -----------------------------------------------------------------------*/
+
+ RES(R7, 150)
+ NET_C(D8.8, E9.5)
+ NET_C(E9.6, R7.2)
+
+ ALIAS(CON11, R7.1)
+
+ DIODE(CR_LED, "LedRed")
+ NET_C(CR_LED.K, CON11)
+ NET_C(CR_LED.A, V5)
+
+ /* -----------------------------------------------------------------------
+ * Aliases
+ * -----------------------------------------------------------------------*/
+
+ ALIAS(CLK ,J4.5)
+ ALIAS(CLK_n ,J4.6)
+
+ ALIAS(H1 ,H5.12)
+ ALIAS(H2 ,H5.9)
+ ALIAS(H4 ,H5.8)
+ ALIAS(H8 ,H5.11)
+
+ ALIAS(H16 ,F5.12)
+ ALIAS(H32 ,F5.9)
+ ALIAS(H64 ,F5.8)
+ ALIAS(H128 ,F5.11)
+
+ ALIAS(H256 ,H4.3)
+ ALIAS(H256_n ,H4.2)
+
+ ALIAS(HRESET ,J4.8)
+ ALIAS(HRESET_n ,J4.9)
+
+ ALIAS(HBLANK ,K5.5)
+ ALIAS(HBLANK_n ,K5.6)
+
+ ALIAS(HSYNC ,K5.9)
+ ALIAS(HSYNC_n ,K5.8)
+
+ ALIAS(V1 ,J3.12)
+ ALIAS(V2 ,J3.9)
+ ALIAS(V4 ,J3.8)
+ ALIAS(V8 ,J3.11)
+
+ ALIAS(V16 ,H3.12)
+ ALIAS(V32 ,H3.9)
+ ALIAS(V64 ,H3.8)
+ ALIAS(V128 ,H3.11)
+
+ ALIAS(V256 ,H4.5)
+ ALIAS(V256_n ,H4.6)
+
+ ALIAS(VRESET ,J2.8)
+ ALIAS(VRESET_n ,J2.9)
+
+ ALIAS(VSYNC_n ,H1.11)
+
+ ALIAS(NET_n ,B8.12)
+ ALIAS(PADDLE_12 ,K6.10)
+ ALIAS(NET_HEIGHT_n ,B5.10)
+
+ ALIAS(STOP1_n ,F7.8)
+ ALIAS(STOP2_n ,F7.6)
+
+ ALIAS(DISP_PAD1_n ,B8.6)
+ ALIAS(DISP_PAD2_n ,B8.8)
+
+ ALIAS(BACKWARDS_n ,D6.5)
+ ALIAS(DP ,C6.5)
+ ALIAS(CP_n ,D6.8)
+ ALIAS(BP_n ,C6.8)
+
+ ALIAS(V64_n ,C8.13)
+
+ ALIAS(HIT ,E6.10)
+ ALIAS(HIT_n ,D5.3)
+
+ ALIAS(SERVE ,J1.8)
+ ALIAS(SERVE_n ,J1.9)
+ ALIAS(SERVE_TIME ,K1.6)
+ ALIAS(SERVE_TIME_n ,K1.7)
+
+ ALIAS(RIGHT_SCORE ,A1.11)
+ ALIAS(LEFT_SCORE ,A1.3)
+
+ ALIAS(BALL_RETURN ,J5.3)
+ ALIAS(MISS_n ,D2.1)
+
+ ALIAS(BALL ,E6.4)
+ ALIAS(BALL_n ,E6.1)
+
+ ALIAS(LSB1 ,K9.12)
+ ALIAS(LSB2 ,J9.12)
+ ALIAS(STOP ,J6.8)
+
+ ALIAS(ATTRACT ,E8.5)
+ ALIAS(ATTRACT_n ,E8.6)
+
+ ALIAS(START ,E7.9)
+ ALIAS(START_n ,E7.8)
+
+
+ /* -----------------------------------------------------------------------
+ * HRESET
+ * -----------------------------------------------------------------------*/
+
+ NET_C(CLOCK.Q, J4.3)
+ NET_C(J4.6, J4.2)
+ NET_C(V5, J4.4)
+ NET_C(V5, J4.1)
+
+ NET_C(CLK, H5.14)
+ NET_C(J4.8, H5.2)
+ NET_C(J4.8, H5.3)
+ NET_C(H5.12, H5.1)
+
+ NET_C(H5.11, F5.14)
+ NET_C(J4.8, F5.2)
+ NET_C(J4.8, F5.3)
+ NET_C(F5.12, F5.1)
+
+ NET_C(F5.11, H4.12)
+ NET_C(J4.9, H4.13)
+ NET_C(V5, H4.1)
+ NET_C(V5, H4.4)
+
+ NET_C(H256, F4.5)
+ NET_C(H128, F4.2)
+ NET_C(H64, F4.1)
+ NET_C(H4, F4.4)
+
+ NET_C(CLK_n, J4.11)
+ NET_C(V5, J4.10)
+ NET_C(V5, J4.13)
+ NET_C(F4.6, J4.12)
+
+ /* -----------------------------------------------------------------------
+ * HBLANK/HSYNC
+ * -----------------------------------------------------------------------*/
+
+ NET_C(H16, K4.2)
+ NET_C(H64, K4.1)
+
+ NET_C(HRESET_n, K5.4)
+ NET_C(GND, K5.2)
+ NET_C(GND, K5.3)
+ NET_C(K4.3, K5.1)
+
+ NET_C(H64, B5.3)
+
+ NET_C(H32, K4.13)
+ NET_C(B5.4, K4.12)
+
+ NET_C(B5.4, F7.1)
+ NET_C(K5.5, F7.2)
+
+ NET_C(V5, K5.10)
+ NET_C(K4.11, K5.12)
+ NET_C(H16, K5.11)
+ NET_C(F7.3, K5.13)
+
+ /* -----------------------------------------------------------------------
+ * VRESET
+ * -----------------------------------------------------------------------*/
+
+ NET_C(J4.8, J3.14)
+ NET_C(J2.8, J3.2)
+ NET_C(J2.8, J3.3)
+ NET_C(J3.12, J3.1)
+
+ NET_C(J3.11, H3.14)
+ NET_C(J2.8, H3.2)
+ NET_C(J2.8, H3.3)
+ NET_C(H3.12, H3.1)
+
+ NET_C(H3.11, H4.9)
+ NET_C(J2.9, H4.10)
+ NET_C(V5, H4.8)
+ NET_C(V5, H4.11)
+
+ NET_C(V256, H2.1)
+ NET_C(V4, H2.2)
+ NET_C(V1, H2.13)
+
+ NET_C(J4.8, J2.11)
+ NET_C(V5, J2.10)
+ NET_C(V5, J2.13)
+ NET_C(H2.12, J2.12)
+
+ /* -----------------------------------------------------------------------
+ * VSYNC
+ * -----------------------------------------------------------------------*/
+
+ NET_C(V8, H2.3)
+ NET_C(V4, H2.4)
+ NET_C(V2, H2.5)
+
+ NET_C(J2.9, H1.1)
+ NET_C(H1.11, H1.2)
+
+ NET_C(H1.3, H1.12)
+ NET_C(H2.6, H1.13)
+
+ /* -----------------------------------------------------------------------
+ * Volleyball net
+ * -----------------------------------------------------------------------*/
+
+ NET_C(SERVE_n, K1.11)
+ NET_C(BALL_RETURN, K1.12)
+ NET_C(V5, K1.13)
+
+ NET_C(J1.6, J1.2)
+ NET_C(K1.9, J1.3)
+ NET_C(V5, J1.4)
+ NET_C(H1.6, J1.1)
+
+ NET_C(SERVE, K2.2)
+ NET_C(SERVE, K2.3)
+ NET_C(J1.5, K2.14)
+ NET_C(K2.12, K2.1)
+
+ NET_C(K2.9, H1.4)
+ NET_C(K2.11, H1.5)
+
+ NET_C(V128, K3.9)
+ NET_C(V5, K3.3)
+ NET_C(K2.9, K3.4)
+ NET_C(K2.8, K3.5)
+ NET_C(K2.11, K3.6)
+ NET_C(K4.8, K3.7)
+ NET_C(V5, K3.10)
+ NET_C(V4, K3.2)
+ NET_C(V5, K3.1) //Not shown on schematic
+
+ NET_C(V64, H2.11)
+ NET_C(V32, H2.10)
+ NET_C(V128, H2.9)
+
+ NET_C(V16, B1.12)
+ NET_C(V8, B1.13)
+
+ NET_C(H2.8, K6.9)
+ NET_C(B1.11, K6.8)
+
+ NET_C(V128, K4.10)
+ NET_C(K3.15, K4.9)
+
+ NET_C(H2.8, K4.4)
+ NET_C(K4.8, K4.5)
+
+ NET_C(K4.6, B5.11)
+
+ NET_C(K4.6, B2.10)
+ NET_C(H256, B2.12)
+ NET_C(H2, B2.11)
+ NET_C(V5, B2.13)
+
+ NET_C(V4, B8.2)
+ NET_C(H256, B8.1)
+ NET_C(B2.8, B8.13)
+
+ /* -----------------------------------------------------------------------
+ * Stop signals
+ * -----------------------------------------------------------------------*/
+
+ NET_C(H256, F6.3)
+ NET_C(H128, F6.5)
+ NET_C(H16, F6.4)
+
+ NET_C(H64, F6.11)
+ NET_C(H128, F6.9)
+ NET_C(H32, F6.10)
+
+ NET_C(F6.6, F7.5)
+ NET_C(ATTRACT_n, F7.4)
+
+ NET_C(F6.8, F7.9)
+ NET_C(ATTRACT_n, F7.10)
+
+ /* -----------------------------------------------------------------------
+ * Paddle 1
+ * -----------------------------------------------------------------------*/
+
+ NET_C(HRESET_n, C9.2)
+ NET_C(STOP1_n, C9.4)
+
+ NET_C(K5.5, C8.6)
+ NET_C(C9.3, C8.5)
+
+ NET_C(V5, C7.10)
+ NET_C(D7.11, C7.7)
+ NET_C(H1, C7.2)
+ NET_C(GND, C7.3)
+ NET_C(GND, C7.4)
+ NET_C(GND, C7.5)
+ NET_C(GND, C7.6)
+ NET_C(V5, C7.1)
+ NET_C(C8.4, C7.9)
+
+ NET_C(ATTRACT_n, D7.12)
+ NET_C(C7.15, D7.13)
+
+ NET_C(D7.11, B8.4)
+ NET_C(PADDLE_12, B8.3)
+ NET_C(C8.4, B8.5)
+
+ /* -----------------------------------------------------------------------
+ * Paddle 2
+ * -----------------------------------------------------------------------*/
+
+ NET_C(HRESET_n, B9.2)
+ NET_C(STOP2_n, B9.4)
+
+ NET_C(H256_n, C8.8)
+ NET_C(B9.3, C8.9)
+
+ NET_C(V5, B7.10)
+ NET_C(D7.8, B7.7)
+ NET_C(H1, B7.2)
+ NET_C(GND, B7.3)
+ NET_C(GND, B7.4)
+ NET_C(GND, B7.5)
+ NET_C(GND, B7.6)
+ NET_C(V5, B7.1)
+ NET_C(C8.10, B7.9)
+
+ NET_C(ATTRACT_n, D7.10)
+ NET_C(B7.15, D7.9)
+
+ NET_C(D7.8, B8.10)
+ NET_C(PADDLE_12, B8.11)
+ NET_C(C8.10, B8.9)
+
+ /* -----------------------------------------------------------------------
+ * Ball direction and speed
+ * -----------------------------------------------------------------------*/
+
+ NET_C(C7.11, B6.2)
+ NET_C(B7.11, B6.3)
+ NET_C(C7.12, B6.5)
+ NET_C(B7.12, B6.6)
+ NET_C(C7.13, B6.14)
+ NET_C(B7.13, B6.13)
+ NET_C(B8.6, B6.11)
+ NET_C(B8.8, B6.10)
+ NET_C(H256, B6.1)
+ NET_C(GND, B6.15)
+
+ NET_C(B6.9, B5.1)
+
+ NET_C(B5.2, D5.2)
+ NET_C(BALL, D5.1)
+
+ NET_C(H1, E6.9)
+ NET_C(D5.3, E6.8)
+
+ NET_C(E6.10, E6.11)
+ NET_C(GND, E6.12)
+
+ NET_C(E6.13, E5.13)
+ NET_C(SERVE_TIME_n, E5.12)
+
+ NET_C(H256_n, C5.5)
+ NET_C(B6.4, C5.4)
+
+ NET_C(LSB1, C5.9)
+ NET_C(LSB2, C5.10)
+
+ NET_C(SERVE, D5.10)
+ NET_C(C5.8, D5.9)
+
+ NET_C(C5.8, B5.5)
+
+ NET_C(SERVE, D5.12)
+ NET_C(B5.6, D5.13)
+
+ NET_C(V5, D6.4)
+ NET_C(C5.6, D6.2)
+ NET_C(E6.10, D6.3)
+ NET_C(SERVE_TIME_n, D6.1)
+
+ NET_C(D5.8, C6.4)
+ NET_C(B6.4, C6.2)
+ NET_C(E6.10, C6.3)
+ NET_C(D5.11, C6.1)
+
+ NET_C(D5.11, D6.10)
+ NET_C(B6.7, D6.12)
+ NET_C(E6.10, D6.11)
+ NET_C(D5.8, D6.13)
+
+ NET_C(D5.8, C6.10)
+ NET_C(B6.12, C6.12)
+ NET_C(E6.10, C6.11)
+ NET_C(D5.11, C6.13)
+
+ NET_C(D6.9, C5.1)
+ NET_C(C6.5, C5.2)
+
+ NET_C(C6.9, C5.13)
+ NET_C(C6.5, C5.12)
+
+ NET_C(C5.3, E5.4)
+ NET_C(SERVE_n, E5.5)
+
+ NET_C(B4.15, B5.9)
+
+ NET_C(V5, B4.10)
+ NET_C(V5, B4.7)
+ NET_C(V64, B4.2)
+ NET_C(V5, B4.3)
+ NET_C(V5, B4.4)
+ NET_C(GND, B4.5)
+ NET_C(GND, B4.6)
+ NET_C(B5.8, B4.9)
+ NET_C(D5.3, B4.1)
+
+ NET_C(V5, E4.5)
+ NET_C(B4.15, E4.4)
+ NET_C(E5.11, E4.11)
+ NET_C(C5.11, E4.15)
+ NET_C(E5.6, E4.1)
+ NET_C(SERVE_n, E4.10)
+ NET_C(V5, E4.9)
+ NET_C(GND, E4.14)
+
+ /* -----------------------------------------------------------------------
+ * Score
+ * -----------------------------------------------------------------------*/
+
+ NET_C(V64, C8.11)
+ NET_C(V64, C8.12)
+
+ NET_C(V128, F9.5)
+
+ NET_C(V32, F7.12)
+ NET_C(F9.6, F7.13)
+
+ NET_C(H256_n, J5.9)
+ NET_C(H64, J5.10)
+
+ NET_C(H256, J5.13)
+ NET_C(H128, J5.12)
+
+ NET_C(C8.13, J6.2)
+ NET_C(F7.11, J6.1)
+
+ NET_C(J5.8, J6.5)
+ NET_C(J5.11, J6.4)
+
+ NET_C(J6.3, K6.5)
+ NET_C(J6.6, K6.6)
+
+ /* -----------------------------------------------------------------------
+ * Score decoder
+ * -----------------------------------------------------------------------*/
+
+ NET_C(K6.4, K7.4)
+ NET_C(V5, K7.3) //Not on schematic
+ NET_C(V5, K7.5) //Not on schematic
+ NET_C(K8.7, K7.7)
+ NET_C(K8.9, K7.1)
+ NET_C(J8.7, K7.2)
+ NET_C(J8.9, K7.6)
+
+ NET_C(H4, J6.13)
+ NET_C(H8, J6.12)
+
+ NET_C(H16, K6.2)
+ NET_C(GND, K6.3)
+
+ NET_C(V4, F6.2)
+ NET_C(V8, F6.1)
+ NET_C(H16, F6.13)
+
+ NET_C(H8, H6.5)
+ NET_C(H4, H6.4)
+ NET_C(K6.1, H6.3)
+
+ NET_C(V16, F9.3)
+
+ NET_C(J6.11, K6.11)
+ NET_C(K6.1, K6.12)
+
+ NET_C(K6.1, H6.2)
+ NET_C(V8, H6.1)
+ NET_C(V4, H6.13)
+
+ NET_C(F6.12, F9.9)
+
+ NET_C(K7.15, J7.2)
+ NET_C(H6.6, J7.13)
+ NET_C(F9.4, J7.1)
+
+ NET_C(K7.9, J7.9)
+ NET_C(H6.6, J7.10)
+ NET_C(V16, J7.11)
+
+ NET_C(F9.4, H7.3)
+ NET_C(K6.13, H7.4)
+ NET_C(K7.12, H7.5)
+
+ NET_C(V16, J7.3)
+ NET_C(K6.13, J7.4)
+ NET_C(K7.11, J7.5)
+
+ NET_C(K7.13, F8.9)
+ NET_C(F9.4, F8.10)
+ NET_C(H6.12, F8.11)
+
+ NET_C(F9.4, H7.1)
+ NET_C(K7.14, H7.2)
+ NET_C(F9.8, H7.13)
+
+ NET_C(K7.10, H7.9)
+ NET_C(V16, H7.10)
+ NET_C(F9.8, H7.11)
+
+ NET_C(J7.12, H8.4)
+ NET_C(J7.8, H8.6)
+ NET_C(H7.6, H8.3)
+ NET_C(J7.6, H8.5)
+ NET_C(NET_n, H8.1)
+ NET_C(F8.8, H8.12)
+ NET_C(H7.12, H8.11)
+ NET_C(H7.8, H8.2)
+
+ /* -----------------------------------------------------------------------
+ * Score counters
+ * -----------------------------------------------------------------------*/
+
+ NET_C(LEFT_SCORE, K9.14)
+ NET_C(K9.1, K9.12)
+ NET_C(GND, K9.6)
+ NET_C(GND, K9.7)
+ NET_C(START, K9.2)
+ NET_C(START, K9.3)
+
+ NET_C(V5, H9.8)
+ NET_C(K9.11, H9.9)
+ NET_C(V5, H9.11)
+ NET_C(START_n, H9.10)
+
+ NET_C(RIGHT_SCORE, J9.14)
+ NET_C(J9.1, J9.12)
+ NET_C(GND, J9.6)
+ NET_C(GND, J9.7)
+ NET_C(START, J9.2)
+ NET_C(START, J9.3)
+
+ NET_C(V5, H9.1)
+ NET_C(J9.11, H9.12)
+ NET_C(V5, H9.4)
+ NET_C(START_n, H9.13)
+
+ NET_C(K9.8, DSW1a.2)
+
+ NET_C(H9.5, F8.4)
+ NET_C(K9.12, F8.5)
+ NET_C(DSW1a.Q, F8.3)
+
+ NET_C(J9.8, DSW1b.2)
+
+ NET_C(H9.3, F8.2)
+ NET_C(J9.12, F8.1)
+ NET_C(DSW1b.Q, F8.13)
+
+ NET_C(F8.6, J6.10)
+ NET_C(F8.12, J6.9)
+
+ NET_C(H32, K8.14)
+ NET_C(H64, K8.2)
+ NET_C(K9.12, K8.5)
+ NET_C(K9.9, K8.11)
+ NET_C(V5, K8.6)
+ NET_C(V5, K8.4)
+ NET_C(J9.12, K8.3)
+ NET_C(J9.9, K8.13)
+ NET_C(H9.2, K8.12)
+ NET_C(H9.6, K8.10)
+ NET_C(GND, K8.1)
+ NET_C(GND, K8.15)
+
+ NET_C(H32, J8.14)
+ NET_C(H64, J8.2)
+ NET_C(K9.8, J8.5)
+ NET_C(K9.11, J8.11)
+ NET_C(H9.6, J8.6)
+ NET_C(H9.2, J8.4)
+ NET_C(J9.8, J8.3)
+ NET_C(J9.11, J8.13)
+ NET_C(H9.2, J8.12)
+ NET_C(H9.6, J8.10)
+ NET_C(GND, J8.1)
+ NET_C(GND, J8.15)
+
+ /* -----------------------------------------------------------------------
+ * Serve logic
+ * -----------------------------------------------------------------------*/
+
+ NET_C(H128, C3.10)
+ NET_C(H64, C3.11)
+ NET_C(H256_n, C3.9)
+
+ NET_C(V64_n, H6.10)
+ NET_C(V128, H6.9)
+ NET_C(C3.8, H6.11)
+
+ NET_C(START, K1.4)
+ NET_C(D1.7, K1.5)
+ NET_C(V5, K1.3)
+
+ NET_C(V5, J1.10)
+ NET_C(K1.7, J1.12)
+ NET_C(H6.8, J1.11)
+ NET_C(K1.7, J1.13)
+
+ /* -----------------------------------------------------------------------
+ * Out of bounds checks
+ * -----------------------------------------------------------------------*/
+
+ NET_C(H256, B3.1)
+ NET_C(BALL, B3.12)
+ NET_C(H256_n, B3.4)
+ NET_C(SERVE_n, B3.13)
+
+ NET_C(SERVE_n, J2.4)
+ NET_C(B3.3, J2.2)
+ NET_C(H2, J2.3)
+ NET_C(V5, J2.1)
+
+ NET_C(B3.3, J5.2)
+ NET_C(J2.5, J5.1)
+
+ NET_C(V5, D1.11)
+ NET_C(F1.8, D1.12)
+ NET_C(V5, D1.13)
+
+ NET_C(J5.3, C1.2)
+ NET_C(J5.3, C1.3)
+ NET_C(D1.9, C1.14)
+ NET_C(C1.12, C1.1)
+
+ NET_C(HBLANK_n, B1.9)
+ NET_C(NET_HEIGHT_n, B1.10)
+
+ NET_C(J5.3, E5.1)
+ NET_C(B1.8, E5.2)
+
+ NET_C(C1.8, D2.8)
+ NET_C(E5.3, D2.9)
+
+ NET_C(D2.10, D2.11)
+ NET_C(SERVE, D2.12)
+
+ NET_C(BALL_n, D2.5)
+ NET_C(V256_n, D2.6)
+
+ NET_C(D2.4, D2.3)
+ NET_C(D2.13, D2.2)
+
+ NET_C(V5, B2.4)
+ NET_C(H256_n, B2.2)
+ NET_C(HIT, B2.3)
+ NET_C(V5, B2.1)
+
+ NET_C(D2.4, C2.1)
+ NET_C(H256_n, C2.13)
+ NET_C(D2.13, C2.10)
+ NET_C(B2.5, C2.9)
+
+ NET_C(D2.4, C2.2)
+ NET_C(H256, C2.3)
+ NET_C(D2.13, C2.4)
+ NET_C(B2.6, C2.5)
+
+ NET_C(C2.8, A1.13)
+ NET_C(ATTRACT_n, A1.12)
+
+ NET_C(ATTRACT_n, A1.2)
+ NET_C(C2.6, A1.1)
+
+ /* -----------------------------------------------------------------------
+ * Horizontal motion
+ * -----------------------------------------------------------------------*/
+
+ NET_C(V5, F1.4)
+ NET_C(F1.6, F1.2)
+ NET_C(VRESET, F1.3)
+ NET_C(BACKWARDS_n, F1.1)
+
+ NET_C(F1.6, F2.5)
+ NET_C(VRESET, F2.4)
+
+ NET_C(BP_n, F2.1)
+ NET_C(F2.6, F2.2)
+
+ NET_C(CP_n, F2.13)
+ NET_C(F2.6, F2.12)
+
+ NET_C(DP, H1.9)
+ NET_C(F2.6, H1.10)
+
+ NET_C(H1.8, E1.12)
+ NET_C(H1.8, E1.13)
+
+ NET_C(F2.3, E2.10)
+ NET_C(F2.11, E2.8)
+ NET_C(H1.8, E2.3)
+ NET_C(GND, E2.1)
+ NET_C(E1.11, E2.11)
+ NET_C(V5, E2.7)
+ NET_C(V5, E2.4)
+ NET_C(GND, E2.16)
+ NET_C(GND, E2.13)
+
+ NET_C(E2.15, E3.6)
+ NET_C(E2.2, E3.5)
+ NET_C(E2.6, E3.4)
+ NET_C(E2.9, E3.3)
+ NET_C(C3.6, E3.9)
+ NET_C(SERVE_n, E3.1)
+ NET_C(V5, E3.10)
+ NET_C(V5, E3.7)
+ NET_C(CLK, E3.2)
+
+ NET_C(GND, D3.6)
+ NET_C(GND, D3.5)
+ NET_C(V5, D3.4)
+ NET_C(V5, D3.3)
+ NET_C(C3.6, D3.9)
+ NET_C(SERVE_n, D3.1)
+ NET_C(V5, D3.10)
+ NET_C(E3.15, D3.7)
+ NET_C(CLK, D3.2)
+
+ NET_C(V5, F3.1)
+ NET_C(D3.15, F3.12)
+ NET_C(V5, F3.4)
+ NET_C(SERVE_n, F3.13)
+
+ NET_C(E3.15, C3.5)
+ NET_C(D3.15, C3.3)
+ NET_C(F3.3, C3.4)
+
+ NET_C(F3.3, F4.9)
+ NET_C(D3.15, F4.10)
+ NET_C(E3.11, F4.12)
+ NET_C(E3.12, F4.13)
+
+ /* -----------------------------------------------------------------------
+ * Vertical motion
+ * -----------------------------------------------------------------------*/
+
+ NET_C(E4.7, D4.6)
+ NET_C(E4.6, D4.5)
+ NET_C(E4.2, D4.4)
+ NET_C(E4.3, D4.3)
+ NET_C(D5.6, D4.9)
+ NET_C(SERVE_n, D4.1)
+ NET_C(VSYNC_n, D4.10)
+ NET_C(V5, D4.7)
+ NET_C(HSYNC_n, D4.2)
+
+ NET_C(GND, C4.6)
+ NET_C(GND, C4.5)
+ NET_C(GND, C4.4)
+ NET_C(GND, C4.3)
+ NET_C(D5.6, C4.9)
+ NET_C(SERVE_n, C4.1)
+ NET_C(V5, C4.10)
+ NET_C(D4.15, C4.7)
+ NET_C(HSYNC_n, C4.2)
+
+ NET_C(D4.15, D5.5)
+ NET_C(C4.15, D5.4)
+
+ NET_C(C4.15, C3.13)
+ NET_C(D4.11, C3.2)
+ NET_C(D4.12, C3.1)
+
+ NET_C(F4.8, E6.5)
+ NET_C(C3.12, E6.6)
+
+ NET_C(E6.4, E6.3)
+ NET_C(E6.4, E6.2)
+
+ /* -----------------------------------------------------------------------
+ * Sound
+ * -----------------------------------------------------------------------*/
+
+ NET_C(D2.1, D1.5)
+ NET_C(GND, D1.4)
+ NET_C(V5, D1.3)
+
+ NET_C(V32, E1.10)
+ NET_C(D1.6, E1.9)
+
+ NET_C(J1.9, F1.10)
+ NET_C(HIT_n, F1.12)
+ NET_C(C4.15, F1.11)
+ NET_C(HIT_n, F1.13)
+
+ NET_C(F1.8, E1.2)
+ NET_C(C4.14, E1.1)
+
+ NET_C(ATTRACT_n, F2.10)
+ NET_C(E1.8, F2.9)
+
+ NET_C(F2.8, E1.5)
+ NET_C(E1.3, E1.4)
+
+
+ /* -----------------------------------------------------------------------
+ * Coin and Start switches continued
+ * -----------------------------------------------------------------------*/
+
+ NET_C(GND, DSW2.1)
+ NET_C(V5, DSW2.2)
+
+ NET_C(V5, D8.2)
+ NET_C(DSW2.Q, D8.4)
+ NET_C(ATTRACT, D8.3)
+
+ NET_C(D8.5, D8.12)
+ NET_C(E9.4, D8.10)
+ NET_C(ATTRACT, D8.11)
+
+ NET_C(D8.9, C8.3)
+
+ NET_C(C8.1, A1.4)
+
+ NET_C(V5, E7.4)
+ NET_C(E8.5, E7.2)
+ NET_C(A1.6, E7.3)
+ NET_C(E7.8, E7.1)
+
+ NET_C(V5, E7.10)
+ NET_C(E7.5, E7.12)
+ NET_C(V256, E7.11)
+ NET_C(C8.1, E7.13)
+
+ NET_C(E7.9, D7.5)
+ NET_C(D8.8, D7.4)
+
+ NET_C(E9.4, E8.4)
+ NET_C(V5, E8.2)
+ NET_C(STOP, E8.3)
+ NET_C(D7.6, E8.1)
+
+ NET_C(D8.9, D7.2)
+ NET_C(ATTRACT, D7.1)
+
+ /* -----------------------------------------------------------------------
+ * Video signal
+ * -----------------------------------------------------------------------*/
+
+ NET_C(V4, E5.9)
+ NET_C(B5.2, E5.10)
+
+ NET_C(J5.4, H1.11) // VSYNC
+ NET_C(J5.5, K5.9) // HSYNC
+
+ RES(R29, 1000)
+ RES(R25, 330)
+ RES(R26, 330)
+ RES(R27, 330)
+ RES(R28, 330)
+
+ NET_C(R29.1, V5)
+ NET_C(H8.8, R25.1)
+ NET_C(J5.6, R26.1)
+ NET_C(E6.4, R27.1) // BALL
+ NET_C(E5.8, R28.1)
+
+ NET_C(R29.2, R25.2, R26.2, R27.2, R28.2)
+
+ ALIAS(videomix, R29.2)
+
+ /* -----------------------------------------------------------------------
+ * Audio signal
+ * -----------------------------------------------------------------------*/
+
+ ALIAS(sound, E1.6)
+
+ /* -----------------------------------------------------------------------
+ * Inputs not used
+ * -----------------------------------------------------------------------*/
+
+ NET_C(V5, A1.s3.A, A1.s3.B, B5.s6.A)
+ NET_C(V5, B3.2.CLK, B3.2.CLRQ, B3.2.J, B3.2.K)
+ NET_C(V5, F3.2.CLK, F3.2.CLRQ, F3.2.J, F3.2.K)
+ NET_C(V5, F9.s1.A, F9.s5.A, F9.s6.A)
+
+NETLIST_END()