From 6daeb4b4d14ca313be5b386ca61b6c4222d2e002 Mon Sep 17 00:00:00 2001 From: couriersud Date: Tue, 15 Oct 2019 11:30:05 +0200 Subject: [PATCH] netlist: Use unique_ptr where possible. (nw) Also improve code readability. --- src/devices/machine/netlist.cpp | 22 +- src/devices/machine/netlist.h | 2 +- src/lib/netlist/devices/nld_system.cpp | 2 +- src/lib/netlist/devices/nlid_truthtable.cpp | 4 +- src/lib/netlist/nl_base.cpp | 55 +- src/lib/netlist/nl_base.h | 134 +- src/lib/netlist/nl_factory.cpp | 4 +- src/lib/netlist/nl_factory.h | 8 +- src/lib/netlist/nl_setup.cpp | 31 +- src/lib/netlist/nltypes.h | 2 +- src/lib/netlist/plib/pmempool.h | 2 +- src/lib/netlist/prg/nltool.cpp | 2 +- src/lib/netlist/solver/nld_matrix_solver.cpp | 4 +- src/lib/netlist/solver/nld_matrix_solver.h | 2 +- src/lib/netlist/solver/nld_solver.cpp | 2 +- src/mame/machine/nl_breakout.cpp | 2521 +++++++++--------- 16 files changed, 1460 insertions(+), 1337 deletions(-) diff --git a/src/devices/machine/netlist.cpp b/src/devices/machine/netlist.cpp index 04b6aed587a..e8b28792656 100644 --- a/src/devices/machine/netlist.cpp +++ b/src/devices/machine/netlist.cpp @@ -499,9 +499,9 @@ public: for (int i = 0; i < MAX_INPUT_CHANNELS; i++) { - m_channels[i].m_param_name = netlist::pool().make_poolptr(*this, plib::pfmt("CHAN{1}")(i), ""); - m_channels[i].m_param_mult = netlist::pool().make_poolptr(*this, plib::pfmt("MULT{1}")(i), 1.0); - m_channels[i].m_param_offset = netlist::pool().make_poolptr(*this, plib::pfmt("OFFSET{1}")(i), 0.0); + m_channels[i].m_param_name = netlist::pool().make_unique(*this, plib::pfmt("CHAN{1}")(i), ""); + m_channels[i].m_param_mult = netlist::pool().make_unique(*this, plib::pfmt("MULT{1}")(i), 1.0); + m_channels[i].m_param_offset = netlist::pool().make_unique(*this, plib::pfmt("OFFSET{1}")(i), 0.0); } } @@ -548,11 +548,11 @@ public: struct channel { - netlist::pool_owned_ptr m_param_name; + netlist::unique_pool_ptr m_param_name; netlist::param_double_t *m_param; stream_sample_t *m_buffer; - netlist::pool_owned_ptr m_param_mult; - netlist::pool_owned_ptr m_param_offset; + netlist::unique_pool_ptr m_param_mult; + netlist::unique_pool_ptr m_param_offset; }; channel m_channels[MAX_INPUT_CHANNELS]; netlist::netlist_time m_inc; @@ -732,10 +732,10 @@ void netlist_mame_analog_output_device::custom_netlist_additions(netlist::netlis if (owner()->has_running_machine()) m_delegate.bind_relative_to(owner()->machine().root_device()); - auto dev = netlist::pool().make_poolptr(nlstate, dfqn); + auto dev = netlist::pool().make_unique(nlstate, dfqn); //static_cast(dev.get())->register_callback(std::move(m_delegate)); dev->register_callback(std::move(m_delegate)); - nlstate.add_dev(dfqn, std::move(dev)); + nlstate.register_device(dfqn, std::move(dev)); nlstate.setup().register_link(dname + ".IN", pin); } @@ -772,9 +772,9 @@ void netlist_mame_logic_output_device::custom_netlist_additions(netlist::netlist if (owner()->has_running_machine()) m_delegate.bind_relative_to(owner()->machine().root_device()); - auto dev = netlist::pool().make_poolptr(nlstate, dfqn); + auto dev = netlist::pool().make_unique(nlstate, dfqn); dev->register_callback(std::move(m_delegate)); - nlstate.add_dev(dfqn, std::move(dev)); + nlstate.register_device(dfqn, std::move(dev)); nlstate.setup().register_link(dname + ".IN", pin); } @@ -1127,7 +1127,7 @@ void netlist_mame_device::device_start() { LOGDEVCALLS("device_start entry\n"); - m_netlist = netlist::pool().make_poolptr(*this, "netlist"); + m_netlist = netlist::pool().make_unique(*this, "netlist"); if (!machine().options().verbose()) { m_netlist->nlstate().log().verbose.set_enabled(false); diff --git a/src/devices/machine/netlist.h b/src/devices/machine/netlist.h index 946d1322ddc..0667f4e41fc 100644 --- a/src/devices/machine/netlist.h +++ b/src/devices/machine/netlist.h @@ -111,7 +111,7 @@ private: netlist::netlist_time m_rem; netlist::netlist_time m_old; - netlist::pool_owned_ptr m_netlist; + netlist::unique_pool_ptr m_netlist; func_type m_setup_func; }; diff --git a/src/lib/netlist/devices/nld_system.cpp b/src/lib/netlist/devices/nld_system.cpp index 5a1868bb775..d75dd7d0fe9 100644 --- a/src/lib/netlist/devices/nld_system.cpp +++ b/src/lib/netlist/devices/nld_system.cpp @@ -111,7 +111,7 @@ namespace netlist NETLIB_DEVICE_IMPL(clock, "CLOCK", "FREQ") NETLIB_DEVICE_IMPL(varclock, "VARCLOCK", "FUNC") NETLIB_DEVICE_IMPL(extclock, "EXTCLOCK", "FREQ,PATTERN") - NETLIB_DEVICE_IMPL(res_sw, "RES_SWITCH", "+IN,+P1,+P2") + NETLIB_DEVICE_IMPL(res_sw, "RES_SWITCH", "+I,+1,+2") NETLIB_DEVICE_IMPL(mainclock, "MAINCLOCK", "FREQ") NETLIB_DEVICE_IMPL(gnd, "GND", "") NETLIB_DEVICE_IMPL(netlistparams, "PARAMETER", "") diff --git a/src/lib/netlist/devices/nlid_truthtable.cpp b/src/lib/netlist/devices/nlid_truthtable.cpp index c62c67da3c1..cd8e9e1ed1b 100644 --- a/src/lib/netlist/devices/nlid_truthtable.cpp +++ b/src/lib/netlist/devices/nlid_truthtable.cpp @@ -223,7 +223,7 @@ namespace netlist : netlist_base_factory_truthtable_t(name, classname, def_param, sourcefile) { } - pool_owned_ptr Create(netlist_state_t &anetlist, const pstring &name) override + unique_pool_ptr Create(netlist_state_t &anetlist, const pstring &name) override { using tt_type = nld_truthtable_t; truthtable_parser desc_s(m_NO, m_NI, &m_ttbl.m_initialized, @@ -239,7 +239,7 @@ namespace netlist if (m_family_desc == nullptr) throw nl_exception("family description not found for {1}", m_family_name); - return pool().make_poolptr(anetlist, name, m_family_desc, m_ttbl, m_desc); + return pool().make_unique(anetlist, name, m_family_desc, m_ttbl, m_desc); } private: typename nld_truthtable_t::truthtable_t m_ttbl; diff --git a/src/lib/netlist/nl_base.cpp b/src/lib/netlist/nl_base.cpp index 1210c6a4d41..7035aa73b2e 100644 --- a/src/lib/netlist/nl_base.cpp +++ b/src/lib/netlist/nl_base.cpp @@ -49,17 +49,17 @@ public: m_R_low = 1.0; m_R_high = 130.0; } - pool_owned_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override; - pool_owned_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override; + unique_pool_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override; + unique_pool_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override; }; -pool_owned_ptr logic_family_ttl_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const +unique_pool_ptr logic_family_ttl_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const { - return pool().make_poolptr(anetlist, name, proxied); + return pool().make_unique(anetlist, name, proxied); } -pool_owned_ptr logic_family_ttl_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const +unique_pool_ptr logic_family_ttl_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const { - return pool().make_poolptr(anetlist, name, proxied); + return pool().make_unique(anetlist, name, proxied); } class logic_family_cd4xxx_t : public logic_family_desc_t @@ -76,18 +76,18 @@ public: m_R_low = 10.0; m_R_high = 10.0; } - pool_owned_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override; - pool_owned_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override; + unique_pool_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override; + unique_pool_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override; }; -pool_owned_ptr logic_family_cd4xxx_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const +unique_pool_ptr logic_family_cd4xxx_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const { - return pool().make_poolptr(anetlist, name, proxied); + return pool().make_unique(anetlist, name, proxied); } -pool_owned_ptr logic_family_cd4xxx_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const +unique_pool_ptr logic_family_cd4xxx_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const { - return pool().make_poolptr(anetlist, name, proxied); + return pool().make_unique(anetlist, name, proxied); } const logic_family_desc_t *family_TTL() @@ -409,7 +409,8 @@ void netlist_t::process_queue_stats(const netlist_time delta) NL_NOEXCEPT while (e.m_object != nullptr) { e.m_object->template update_devs(); - if (KEEP_STATS) m_perf_out_processed.inc(); + if (KEEP_STATS) + m_perf_out_processed.inc(); e = m_queue.pop(); m_time = e.m_exec_time; } @@ -435,7 +436,8 @@ void netlist_t::process_queue_stats(const netlist_time delta) NL_NOEXCEPT if (e.m_object != nullptr) { e.m_object->template update_devs(); - if (KEEP_STATS) m_perf_out_processed.inc(); + if (KEEP_STATS) + m_perf_out_processed.inc(); } else break; @@ -568,7 +570,7 @@ core_device_t::core_device_t(core_device_t &owner, const pstring &name) set_logic_family(owner.logic_family()); if (logic_family() == nullptr) set_logic_family(family_TTL()); - state().add_dev(this->name(), pool_owned_ptr(this, false)); + state().register_device(this->name(), owned_pool_ptr(this, false)); if (exec().stats_enabled()) m_stats = pool().make_unique(); } @@ -725,6 +727,7 @@ void detail::net_t::process(const T mask, netlist_sig_t sig) template void detail::net_t::update_devs() NL_NOEXCEPT { +#if 0 nl_assert(this->isRailNet()); const unsigned int new_Q(m_new_Q); @@ -743,6 +746,24 @@ void detail::net_t::update_devs() NL_NOEXCEPT /* do nothing */ break; } +#else + nl_assert(this->isRailNet()); + + const unsigned int mask((m_new_Q << core_terminal_t::INP_LH_SHIFT) + | (m_cur_Q << core_terminal_t::INP_HL_SHIFT)); + + m_in_queue = queue_status::DELIVERED; /* mark as taken ... */ + switch (mask) + { + case core_terminal_t::STATE_INP_HL: + case core_terminal_t::STATE_INP_LH: + process(mask | core_terminal_t::STATE_INP_ACTIVE, m_new_Q); + break; + default: + /* do nothing */ + break; + } +#endif } void detail::net_t::reset() @@ -897,7 +918,7 @@ logic_output_t::logic_output_t(core_device_t &dev, const pstring &aname) , m_my_net(dev.state(), name() + ".net", this) { this->set_net(&m_my_net); - state().register_net(pool_owned_ptr(&m_my_net, false)); + state().register_net(owned_pool_ptr(&m_my_net, false)); set_logic_family(dev.logic_family()); state().setup().register_term(*this); } @@ -927,7 +948,7 @@ analog_output_t::analog_output_t(core_device_t &dev, const pstring &aname) : analog_t(dev, aname, STATE_OUT) , m_my_net(dev.state(), name() + ".net", this) { - state().register_net(pool_owned_ptr(&m_my_net, false)); + state().register_net(owned_pool_ptr(&m_my_net, false)); this->set_net(&m_my_net); //net().m_cur_Analog = NL_FCONST(0.0); diff --git a/src/lib/netlist/nl_base.h b/src/lib/netlist/nl_base.h index 9946bc8cd43..e58a439a35c 100644 --- a/src/lib/netlist/nl_base.h +++ b/src/lib/netlist/nl_base.h @@ -144,7 +144,7 @@ class NETLIB_NAME(name) : public device_t #define NETLIB_TIMESTEP(chip) void NETLIB_NAME(chip) :: timestep(const nl_double step) #define NETLIB_SUB(chip) nld_ ## chip -#define NETLIB_SUBXX(ns, chip) pool_owned_ptr< ns :: nld_ ## chip > +#define NETLIB_SUBXX(ns, chip) unique_pool_ptr< ns :: nld_ ## chip > #define NETLIB_HANDLER(chip, name) void NETLIB_NAME(chip) :: name() NL_NOEXCEPT #define NETLIB_UPDATE(chip) NETLIB_HANDLER(chip, update) @@ -249,9 +249,9 @@ namespace netlist virtual ~logic_family_desc_t() noexcept = default; - virtual pool_owned_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, + virtual unique_pool_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const = 0; - virtual pool_owned_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, + virtual unique_pool_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const = 0; double fixed_V() const { return m_fixed_V; } @@ -698,14 +698,14 @@ namespace netlist netlist_sig_t Q() const noexcept { return m_cur_Q; } /* only used for logic nets */ - void initial(const netlist_sig_t val) noexcept + void initial(netlist_sig_t val) noexcept { m_cur_Q = m_new_Q = val; update_inputs(); } /* only used for logic nets */ - void set_Q_and_push(const netlist_sig_t newQ, const netlist_time delay) NL_NOEXCEPT + void set_Q_and_push(netlist_sig_t newQ, netlist_time delay) NL_NOEXCEPT { if (newQ != m_new_Q) { @@ -715,7 +715,7 @@ namespace netlist } /* only used for logic nets */ - void set_Q_time(const netlist_sig_t newQ, const netlist_time at) NL_NOEXCEPT + void set_Q_time(netlist_sig_t newQ, netlist_time at) NL_NOEXCEPT { if (newQ != m_new_Q) { @@ -935,14 +935,14 @@ namespace netlist logic_output_t(core_device_t &dev, const pstring &aname); - void initial(const netlist_sig_t val); + void initial(netlist_sig_t val); - void push(const netlist_sig_t newQ, const netlist_time delay) NL_NOEXCEPT + void push(netlist_sig_t newQ, netlist_time delay) NL_NOEXCEPT { m_my_net.set_Q_and_push(newQ, delay); // take the shortcut } - void set_Q_time(const netlist_sig_t newQ, const netlist_time at) NL_NOEXCEPT + void set_Q_time(netlist_sig_t newQ, netlist_time at) NL_NOEXCEPT { m_my_net.set_Q_time(newQ, at); // take the shortcut } @@ -1260,9 +1260,9 @@ namespace netlist const setup_t &setup() const; template - void create_and_register_subdevice(const pstring &name, pool_owned_ptr &dev, Args&&... args) + void create_and_register_subdevice(const pstring &name, unique_pool_ptr &dev, Args&&... args) { - dev = pool().make_poolptr(*this, name, std::forward(args)...); + dev = pool().make_unique(*this, name, std::forward(args)...); } void register_subalias(const pstring &name, detail::core_terminal_t &term); @@ -1338,10 +1338,10 @@ namespace netlist { public: - using nets_collection_type = std::vector>; + using nets_collection_type = std::vector>; /* need to preserve order of device creation ... */ - using devices_collection_type = std::vector>>; + using devices_collection_type = std::vector>>; netlist_state_t(const pstring &aname, netlist_t & anetlist, plib::unique_ptr &&callbacks); @@ -1360,10 +1360,38 @@ namespace netlist core_device_t *get_single_device(const pstring &classname, bool (*cc)(core_device_t *)) const; + /** + * @brief Get single device filtered by class and name + * + * @tparam C Device class for which devices will be returned + * @param name Name of the device + * + * @return pointers to device + */ template - C *get_single_device(const pstring &classname) const + C *get_single_device(const pstring &name) const { - return dynamic_cast(get_single_device(classname, check_class)); + return dynamic_cast(get_single_device(name, check_class)); + } + + /** + * @brief Get vector of devices + * + * @tparam C Device class for which devices will be returned + * + * @return vector with pointers to devices + */ + template + inline std::vector get_device_list() + { + std::vector tmp; + for (auto &d : m_devices) + { + auto dev = dynamic_cast(d.second.get()); + if (dev != nullptr) + tmp.push_back(dev); + } + return tmp; } /* logging and name */ @@ -1396,21 +1424,16 @@ namespace netlist std::size_t find_net_id(const detail::net_t *net) const; template - void register_net(pool_owned_ptr &&net) { m_nets.push_back(std::move(net)); } - - template - inline std::vector get_device_list() - { - std::vector tmp; - for (auto &d : m_devices) - { - auto dev = dynamic_cast(d.second.get()); - if (dev != nullptr) - tmp.push_back(dev); - } - return tmp; - } + void register_net(owned_pool_ptr &&net) { m_nets.push_back(std::move(net)); } + /** + * @brief Get device pointer by name + * + * + * @param name Name of the device + * + * @return core_device_t pointer if device exists, else nullptr + */ core_device_t *find_device(const pstring &name) { for (auto & d : m_devices) @@ -1419,8 +1442,17 @@ namespace netlist return nullptr; } + /** + * @brief Register device using owned_ptr + * + * Used to register owned devices. These are devices declared as objects + * in another devices. + * + * @param name Name of the device + * @param dev Device to be registered + */ template - void add_dev(const pstring &name, pool_owned_ptr &&dev) + void register_device(const pstring &name, owned_pool_ptr &&dev) { for (auto & d : m_devices) if (d.first == name) @@ -1432,6 +1464,20 @@ namespace netlist m_devices.insert(m_devices.end(), { name, std::move(dev) }); } + /** + * @brief Register device using unique_ptr + * + * Used to register devices. + * + * @param name Name of the device + * @param dev Device to be registered + */ + template + void register_device(const pstring &name, unique_pool_ptr &&dev) + { + register_device(name, owned_pool_ptr(dev.release(), true, dev.get_deleter())); + } + /** * @brief Remove device * @@ -1440,7 +1486,7 @@ namespace netlist * * @param dev Device to be removed */ - void remove_dev(core_device_t *dev) + void remove_device(core_device_t *dev) { for (auto it = m_devices.begin(); it != m_devices.end(); it++) if (it->second.get() == dev) @@ -1451,20 +1497,20 @@ namespace netlist } } - /* sole use is to manage lifetime of family objects */ - std::unordered_map> m_family_cache; - setup_t &setup() NL_NOEXCEPT { return *m_setup; } const setup_t &setup() const NL_NOEXCEPT { return *m_setup; } - nets_collection_type & nets() { return m_nets; } - devices_collection_type & devices() { return m_devices; } - // FIXME: make a postload member and include code there void rebuild_lists(); /* must be called after post_load ! */ static void compile_defines(std::vector> &defs); + nets_collection_type & nets() { return m_nets; } + devices_collection_type & devices() { return m_devices; } + + /* sole use is to manage lifetime of family objects */ + std::unordered_map> m_family_cache; + private: void reset(); @@ -1503,7 +1549,7 @@ namespace netlist netlist_time time() const NL_NOEXCEPT { return m_time; } - void process_queue(const netlist_time delta) NL_NOEXCEPT; + void process_queue(netlist_time delta) NL_NOEXCEPT; void abort_current_queue_slice() NL_NOEXCEPT { m_queue.retime(detail::queue_t::entry_t(m_time, nullptr)); } const detail::queue_t &queue() const NL_NOEXCEPT { return m_queue; } @@ -1559,7 +1605,7 @@ namespace netlist private: template - void process_queue_stats(const netlist_time delta) NL_NOEXCEPT; + void process_queue_stats(netlist_time delta) NL_NOEXCEPT; plib::unique_ptr m_state; devices::NETLIB_NAME(solver) * m_solver; @@ -1708,27 +1754,25 @@ namespace netlist } } - inline void detail::net_t::push_to_queue(const netlist_time delay) NL_NOEXCEPT + inline void detail::net_t::push_to_queue(netlist_time delay) NL_NOEXCEPT { if ((num_cons() != 0)) { - auto &lexec(exec()); - const auto nst(lexec.time() + delay); + m_next_scheduled_time = exec().time() + delay; if (is_queued()) - lexec.qremove(this); + exec().qremove(this); if (!m_list_active.empty()) { m_in_queue = queue_status::QUEUED; - lexec.qpush(queue_t::entry_t(nst, this)); + exec().qpush(queue_t::entry_t(m_next_scheduled_time, this)); } else { m_in_queue = queue_status::DELAYED_DUE_TO_INACTIVE; update_inputs(); } - m_next_scheduled_time = nst; } } diff --git a/src/lib/netlist/nl_factory.cpp b/src/lib/netlist/nl_factory.cpp index f8fc40d27db..74e91ea2ee1 100644 --- a/src/lib/netlist/nl_factory.cpp +++ b/src/lib/netlist/nl_factory.cpp @@ -76,9 +76,9 @@ namespace netlist { namespace factory // factory_lib_entry_t: factory class to wrap macro based chips/elements // ----------------------------------------------------------------------------- - pool_owned_ptr library_element_t::Create(netlist_state_t &anetlist, const pstring &name) + unique_pool_ptr library_element_t::Create(netlist_state_t &anetlist, const pstring &name) { - return pool().make_poolptr(anetlist, name); + return pool().make_unique(anetlist, name); } void library_element_t::macro_actions(nlparse_t &nparser, const pstring &name) diff --git a/src/lib/netlist/nl_factory.h b/src/lib/netlist/nl_factory.h index b0c73a6a198..f633962d86d 100644 --- a/src/lib/netlist/nl_factory.h +++ b/src/lib/netlist/nl_factory.h @@ -55,7 +55,7 @@ namespace factory { COPYASSIGNMOVE(element_t, default) - virtual pool_owned_ptr Create(netlist_state_t &anetlist, const pstring &name) = 0; + virtual unique_pool_ptr Create(netlist_state_t &anetlist, const pstring &name) = 0; virtual void macro_actions(nlparse_t &nparser, const pstring &name) { plib::unused_var(nparser); @@ -85,9 +85,9 @@ namespace factory { const pstring &def_param, const pstring &sourcefile) : element_t(name, classname, def_param, sourcefile) { } - pool_owned_ptr Create(netlist_state_t &anetlist, const pstring &name) override + unique_pool_ptr Create(netlist_state_t &anetlist, const pstring &name) override { - return pool().make_poolptr(anetlist, name); + return pool().make_unique(anetlist, name); } }; @@ -147,7 +147,7 @@ namespace factory { { } - pool_owned_ptr Create(netlist_state_t &anetlist, const pstring &name) override; + unique_pool_ptr Create(netlist_state_t &anetlist, const pstring &name) override; void macro_actions(nlparse_t &nparser, const pstring &name) override; diff --git a/src/lib/netlist/nl_setup.cpp b/src/lib/netlist/nl_setup.cpp index 5d6f283bf56..bb942fdaab1 100644 --- a/src/lib/netlist/nl_setup.cpp +++ b/src/lib/netlist/nl_setup.cpp @@ -474,7 +474,7 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(detail::core_terminal_t &out) proxy = new_proxy.get(); - m_nlstate.add_dev(new_proxy->name(), std::move(new_proxy)); + m_nlstate.register_device(new_proxy->name(), std::move(new_proxy)); } return proxy; } @@ -513,7 +513,7 @@ devices::nld_base_proxy *setup_t::get_a_d_proxy(detail::core_terminal_t &inp) inp.net().core_terms().clear(); // clear the list } ret->out().net().add_terminal(inp); - m_nlstate.add_dev(new_proxy->name(), std::move(new_proxy)); + m_nlstate.register_device(new_proxy->name(), std::move(new_proxy)); return ret; } } @@ -635,7 +635,7 @@ void setup_t::connect_terminals(detail::core_terminal_t &t1, detail::core_termin { log().debug("adding analog net ...\n"); // FIXME: Nets should have a unique name - auto anet = pool().make_poolptr(m_nlstate,"net." + t1.name()); + auto anet = pool().make_owned(m_nlstate,"net." + t1.name()); auto anetp = anet.get(); m_nlstate.register_net(std::move(anet)); t1.set_net(anetp); @@ -824,7 +824,7 @@ void setup_t::register_dynamic_log_devices() auto nc = factory().factory_by_name("LOG")->Create(m_nlstate, name); register_link(name + ".I", ll); log().debug(" dynamic link {1}: <{2}>\n",ll, name); - m_nlstate.add_dev(nc->name(), std::move(nc)); + m_nlstate.register_device(nc->name(), std::move(nc)); } } } @@ -970,19 +970,19 @@ class logic_family_std_proxy_t : public logic_family_desc_t { public: logic_family_std_proxy_t() = default; - pool_owned_ptr create_d_a_proxy(netlist_state_t &anetlist, + unique_pool_ptr create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const override; - pool_owned_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override; + unique_pool_ptr create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const override; }; -pool_owned_ptr logic_family_std_proxy_t::create_d_a_proxy(netlist_state_t &anetlist, +unique_pool_ptr logic_family_std_proxy_t::create_d_a_proxy(netlist_state_t &anetlist, const pstring &name, logic_output_t *proxied) const { - return pool().make_poolptr(anetlist, name, proxied); + return pool().make_unique(anetlist, name, proxied); } -pool_owned_ptr logic_family_std_proxy_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const +unique_pool_ptr logic_family_std_proxy_t::create_a_d_proxy(netlist_state_t &anetlist, const pstring &name, logic_input_t *proxied) const { - return pool().make_poolptr(anetlist, name, proxied); + return pool().make_unique(anetlist, name, proxied); } @@ -1043,7 +1043,7 @@ void setup_t::delete_empty_nets() { m_nlstate.nets().erase( std::remove_if(m_nlstate.nets().begin(), m_nlstate.nets().end(), - [](pool_owned_ptr &x) + [](owned_pool_ptr &x) { if (x->num_cons() == 0) { @@ -1071,7 +1071,7 @@ void setup_t::prepare_to_run() if ( factory().is_class(e.second) || factory().is_class(e.second)) { - m_nlstate.add_dev(e.first, pool_owned_ptr(e.second->Create(m_nlstate, e.first))); + m_nlstate.register_device(e.first, e.second->Create(m_nlstate, e.first)); } } @@ -1093,8 +1093,8 @@ void setup_t::prepare_to_run() if ( !factory().is_class(e.second) && !factory().is_class(e.second)) { - auto dev = pool_owned_ptr(e.second->Create(m_nlstate, e.first)); - m_nlstate.add_dev(dev->name(), std::move(dev)); + auto dev = e.second->Create(m_nlstate, e.first); + m_nlstate.register_device(dev->name(), std::move(dev)); } } @@ -1151,7 +1151,7 @@ void setup_t::prepare_to_run() t->name(), t->m_N.net().name(), t->m_P.net().name())); t->m_N.net().remove_terminal(t->m_N); t->m_P.net().remove_terminal(t->m_P); - m_nlstate.remove_dev(t); + m_nlstate.remove_device(t); } else { @@ -1175,7 +1175,6 @@ void setup_t::prepare_to_run() for (auto &n : m_nlstate.nets()) for (auto & term : n->core_terms()) { - //core_device_t *dev = reinterpret_cast(term->m_delegate.object()); core_device_t *dev = &term->device(); dev->set_default_delegate(*term); } diff --git a/src/lib/netlist/nltypes.h b/src/lib/netlist/nltypes.h index 91dc83547e5..3fb78d5e35b 100644 --- a/src/lib/netlist/nltypes.h +++ b/src/lib/netlist/nltypes.h @@ -99,7 +99,7 @@ namespace netlist * */ template - using pool_owned_ptr = nlmempool::owned_pool_ptr; + using owned_pool_ptr = nlmempool::owned_pool_ptr; /*! Unique pointer type for pooled allocations. * diff --git a/src/lib/netlist/plib/pmempool.h b/src/lib/netlist/plib/pmempool.h index 7dff02cf573..7a59097afe3 100644 --- a/src/lib/netlist/plib/pmempool.h +++ b/src/lib/netlist/plib/pmempool.h @@ -189,7 +189,7 @@ namespace plib { using unique_pool_ptr = std::unique_ptr>; template - owned_pool_ptr make_poolptr(Args&&... args) + owned_pool_ptr make_owned(Args&&... args) { auto *mem = this->allocate(alignof(T), sizeof(T)); try diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp index f7ff843801c..11ca83c9aa5 100644 --- a/src/lib/netlist/prg/nltool.cpp +++ b/src/lib/netlist/prg/nltool.cpp @@ -714,7 +714,7 @@ void tool_app_t::listdevices() nt.setup().prepare_to_run(); - std::vector> devs; + std::vector> devs; for (auto & f : list) { diff --git a/src/lib/netlist/solver/nld_matrix_solver.cpp b/src/lib/netlist/solver/nld_matrix_solver.cpp index 2ad6cae7903..d081ad06464 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.cpp +++ b/src/lib/netlist/solver/nld_matrix_solver.cpp @@ -114,9 +114,9 @@ namespace devices { pstring nname(this->name() + "." + pstring(plib::pfmt("m{1}")(m_inps.size()))); nl_assert(p->net().is_analog()); - auto net_proxy_output_u = pool().make_poolptr(*this, nname, static_cast(&p->net())); + auto net_proxy_output_u = pool().make_unique(*this, nname, static_cast(&p->net())); net_proxy_output = net_proxy_output_u.get(); - m_inps.push_back(std::move(net_proxy_output_u)); + m_inps.emplace_back(std::move(net_proxy_output_u)); } net_proxy_output->net().add_terminal(*p); // FIXME: repeated calling - kind of brute force diff --git a/src/lib/netlist/solver/nld_matrix_solver.h b/src/lib/netlist/solver/nld_matrix_solver.h index c96163a7e54..1a452917f0f 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.h +++ b/src/lib/netlist/solver/nld_matrix_solver.h @@ -370,7 +370,7 @@ namespace devices std::vector> m_terms; - std::vector> m_inps; + std::vector> m_inps; std::vector> m_rails_temp; diff --git a/src/lib/netlist/solver/nld_solver.cpp b/src/lib/netlist/solver/nld_solver.cpp index 397ef0ef4b0..c428a08ce25 100644 --- a/src/lib/netlist/solver/nld_solver.cpp +++ b/src/lib/netlist/solver/nld_solver.cpp @@ -227,13 +227,13 @@ namespace devices switch (net_count) { - #if 0 case 1: ms = plib::make_unique>(state(), sname, &m_params); break; case 2: ms = plib::make_unique>(state(), sname, &m_params); break; +#if 1 case 3: ms = create_solver(3, sname); break; diff --git a/src/mame/machine/nl_breakout.cpp b/src/mame/machine/nl_breakout.cpp index 30bef51046b..3d57a511cf5 100644 --- a/src/mame/machine/nl_breakout.cpp +++ b/src/mame/machine/nl_breakout.cpp @@ -1,8 +1,11 @@ // license:GPL-2.0+ // copyright-holders:DICE Team,Couriersud + /* * Changelog: * + * - Drop dice syntax (Couriersud) + * - Fix brick display (Couriersud) * - Added led and lamp components (Couriersud) * - Start2 works (Couriersud) * - Added discrete paddle potentiometers (Couriersud) @@ -63,108 +66,98 @@ * */ +#include "netlist/devices/net_lib.h" -// identify unknown devices in IDE +#define SLOW_BUT_ACCURATE (0) -#define NETLIST_DEVELOPMENT 0 - -#include "netlist/nl_dice_compat.h" - -#define SLOW_BUT_ACCURATE 0 - -//2 555 timers -static Astable555Desc b2_555_desc(OHM(560.0), M_OHM(1.8), U_FARAD(0.1)); - -static Mono555Desc c9_555_desc(OHM(47000.0), U_FARAD(1.0)); // R33, C21 - -static CapacitorDesc c32_desc(U_FARAD(0.1)); -static CapacitorDesc c36_desc(N_FARAD(1.0*.7)); //0.001uF = 1nF - determines horizontal gap between bricks -static CapacitorDesc c37_desc(P_FARAD(330.0)); - -static Mono9602Desc n8_desc(K_OHM(33.0), U_FARAD(100.0), K_OHM(5.6), P_FARAD(0)); // No capacitor on 2nd 9602 -static Mono9602Desc f3_desc(K_OHM(47.0), U_FARAD(1.0), K_OHM(47.0), U_FARAD(1.0)); - -static Mono9602Desc a7_desc(K_OHM(68.0), U_FARAD(1.0), K_OHM(22.0), U_FARAD(10.0)); -static Mono9602Desc a8_desc(K_OHM(27.0), U_FARAD(1.0), K_OHM(27.0), U_FARAD(1.0)); - -CIRCUIT_LAYOUT( breakout ) +NETLIST_START(breakout) #if (SLOW_BUT_ACCURATE) - SOLVER(Solver, 48000) + //SOLVER(Solver, 48000) + SOLVER(Solver, 16000) PARAM(Solver.ACCURACY, 1e-7) // less accuracy and diode will not work + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_LTE, 1e-2) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 1e-8) PARAM(Solver.METHOD, "MAT_CR") #else - SOLVER(Solver, 48000) - PARAM(Solver.ACCURACY, 1e-6) - PARAM(Solver.DYNAMIC_TS, 0) - //PARAM(Solver.LTE, 1e-10) + //SOLVER(Solver, 48000) + SOLVER(Solver, 16000) + PARAM(Solver.ACCURACY, 1e-4) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_LTE, 1e-2) PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 1e-8) PARAM(Solver.METHOD, "MAT_CR") #endif PARAM(NETLIST.USE_DEACTIVATE, 1) - // DIPSWITCH - Free game + //---------------------------------------------------------------- + // Dip-Switch - Free game + //---------------------------------------------------------------- SWITCH(S1_1) SWITCH(S1_2) SWITCH(S1_3) SWITCH(S1_4) - SWITCH2(COIN1) // Coin 1 - SWITCH2(COIN2) // Coin 2 + SWITCH2(COIN1) // Coin 1 + SWITCH2(COIN2) // Coin 2 - SWITCH(START1) // Start 1 - SWITCH(START2) // Start 2 + SWITCH(START1) // Start 1 + SWITCH(START2) // Start 2 - SWITCH(SERVE) // Start 2 + SWITCH(SERVE) // Start 2 - SWITCH(S2) // Cocktail - SWITCH(S3) // 2 Plays / 25c + SWITCH(S2) // Cocktail + SWITCH(S3) // 2 Plays / 25c SWITCH2(S4) // Three Balls / 5 Balls ANALOG_INPUT(V5, 5) ALIAS(VCC, V5) -#define GNDD "GND", Q -#define P "V5", Q + ALIAS(GNDD ,GND.Q) + ALIAS(P ,V5.Q) //---------------------------------------------------------------- // Clock circuit //---------------------------------------------------------------- + #if (SLOW_BUT_ACCURATE) MAINCLOCK(Y1, 14318000.0) - CHIP("F1", 9316) + TTL_9316_DIP(F1) NET_C(Y1.Q, F1.2) - CONNECTION("F1", 14, "H1", 13) - CONNECTION("F1", 13, "H1", 12) - CONNECTION("F1", 15, "E1", 5) - CONNECTION(P, "F1", 1) - CONNECTION(P, "F1", 7) - CONNECTION(P, "F1", 10) - CONNECTION(GNDD, "F1", 3) - CONNECTION(P, "F1", 4) - CONNECTION(GNDD, "F1", 5) - CONNECTION(GNDD, "F1", 6) - CONNECTION("E1", 6, "F1", 9) + NET_C(F1.14, H1.13) + NET_C(F1.13, H1.12) + NET_C(F1.15, E1.5) + NET_C(P, F1.1) + NET_C(P, F1.7) + NET_C(P, F1.10) + NET_C(GNDD, F1.3) + NET_C(P, F1.4) + NET_C(GNDD, F1.5) + NET_C(GNDD, F1.6) + NET_C(E1.6, F1.9) + + ALIAS(CKBH, F1.13) + ALIAS(CLOCK, H1.11) -#define CKBH "F1", 13 -#define DICECLOCK "H1", 11 #else /* * 9316 2 3 4 5 6 7 8 9 10 11 12 13 14 15 2 3 4 5 6 * A 0 1 0 1 0 1 0 1 0 1 0 1 0 1 * B 1 1 0 0 1 1 0 0 1 1 0 0 1 1 - * CKBH 1 1 0 0 1 1 0 0 1 1 0 0 1 1 1 1 - * ^--- Pattern Start - * CLOCK 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 0 1 1 1 - * ^--- Pattern Start - * <--------> 3 Clocks Offset + * CKBH 1 1 0 0 1 1 0 0 1 1 0 0 1 1 + * ^--- Pattern Start + * CLOCK 1 0 1 1 1 0 1 1 1 0 1 1 1 0 + * ^--- Pattern Start + * <------> 2 Clocks Offset */ - EXTCLOCK(Y2, 14318000.0, "2,6,2,6,2,2,2,6") - EXTCLOCK(Y1, 14318000.0, "4,4,4,4,4,8") - PARAM(Y2.OFFSET, 3.0 / 14318000.0 + 20.0e-9 ) -#define CKBH "Y1", Q -#define DICECLOCK "Y2", Q + //EXTCLOCK(Y2, 14318000.0, "2,6,2,6,2,2,2,6") + EXTCLOCK(Y2, 14318000.0, "6,2,6,2,2,2,6,2") + EXTCLOCK(Y1, 14318000.0, "4,4,4,4,8,4") + PARAM(Y2.OFFSET, 1.047632350887E-07) // 1.5 clocks / 14318000.0 + ALIAS(CKBH, Y1.Q) + ALIAS(CLOCK, Y2.Q) NET_C(ttlhigh, H1.13) NET_C(ttlhigh, H1.12) @@ -199,359 +192,449 @@ CIRCUIT_LAYOUT( breakout ) NET_C(GND, CR5.A, Q2.E, C16.2, R25.2, Q3.E) NET_C(CR5.K, Q2.B, antenna) NET_C(Q2.C, C16.1, R25.1, Q3.B, R27.2) - NET_C(R27.1, CR7.A, R31.2) //CR7.K == IN + NET_C(R27.1, CR7.A, R31.2) //CR7.K == IN NET_C(R31.1, Q1.C) NET_C(Q3.C, R26.2, CR3.A, CR4.A, E9.5) // E9.6 = Q Q3.C=QQ CR3.K = COIN*1 CR4.K = COIN*2 NET_C(R26.1, Q1.B, C19.2, R32.2) NET_C(Q1.E, C19.1, R32.1, V5) - #define LAT_Q "E9", 6 - #define Q_n "Q3", C - #define COIN1_n "F8", 5 - #define COIN2_n "H9", 5 + ALIAS(LAT_Q ,E9.6) + ALIAS(Q_n ,Q3.C) + ALIAS(COIN1_n ,F8.5) + ALIAS(COIN2_n ,H9.5) - CONNECTION("CR7", K, "D8", 11) //set - CONNECTION("CR3", K, COIN1_n) //reset - CONNECTION("CR4", K, COIN2_n) //reset + NET_C(CR7.K, D8.11) //set + NET_C(CR3.K, COIN1_n) //reset + NET_C(CR4.K, COIN2_n) //reset - CHIP_CAPACITOR(C32, &c32_desc) - CHIP_CAPACITOR(C36, &c36_desc) - CHIP_CAPACITOR(C37, &c37_desc) + //static CapacitorDesc c32_desc(CAP_U(0.1)); + //NETDEV_DELAY(C32) NETDEV_PARAMI(C32, L_TO_H, CAPACITOR_tc_lh((&c32_desc)->c, (&c32_desc)->r)) NETDEV_PARAMI(C32, H_TO_L, CAPACITOR_tc_hl((&c32_desc)->c, (&c32_desc)->r)) - CHIP("A3", 7474) - CHIP("A4", 7408) - CHIP("A5", 7400) - CHIP("A6", 7474) - CHIP_9602_Mono(A7, &a7_desc) - CHIP_9602_Mono(A8, &a8_desc) + CAP(C32, CAP_U(0.1)) + NET_C(GND, C32.2) - CHIP_555_Astable(B2, &b2_555_desc) - CHIP("B3", 7402) - CHIP("B4", 9316) - CHIP("B5", 74193) - CHIP("B6", 7400) - CHIP("B7", 9316) - CHIP("B8", 9316) - CHIP("B9", 7408) +#if (SLOW_BUT_ACCURATE) + CAP(C36, CAP_N(1.0)) //0.001uF = 1nF - determines horizontal gap between bricks + NET_C(GND, C36.2) +#else + NETDEV_DELAY(C36) + PARAM(C36.L_TO_H, 93) + PARAM(C36.H_TO_L, 2) +#endif + + CAP(C37, CAP_P(330)) + NET_C(GND, C37.2) + + TTL_7474_DIP(A3) + TTL_7408_DIP(A4) + TTL_7400_DIP(A5) + TTL_7474_DIP(A6) + + + TTL_9602_DIP(A7) + NET_C(VCC, A7.16) + NET_C(GND, A7.8) + RES(R45, RES_K(68)) + CAP(CC24, CAP_U(1)) + RES(R46, RES_K(22)) + NET_C(A7.1, CC24.1) + NET_C(A7.2, CC24.2) + NET_C(A7.2, R45.2) + NET_C(VCC, R45.1) + CAP(CC25, CAP_U(10)) + NET_C(A7.15, CC25.1) + NET_C(A7.14, CC25.2) + NET_C(A7.14, R46.2) + NET_C(VCC, R46.1) + + TTL_9602_DIP(A8) + NET_C(VCC, A8.16) + NET_C(GND, A8.8) + RES(R47, RES_K(27)) + CAP(CC26, CAP_U(1)) + RES(R48, RES_K(27)) + NET_C(A8.1, CC26.1) + NET_C(A8.2, CC26.2) + NET_C(A8.2, R47.2) + NET_C(VCC, R47.1) + CAP(CC27, CAP_U(1)) + NET_C(A8.15, CC27.1) + NET_C(A8.14, CC27.2) + NET_C(A8.14, R48.2) + NET_C(VCC, R48.1) + + NE555_DIP(B2) + RES(R55, 560) + RES(R54, RES_M(1.8)) + CAP(C34, CAP_U(0.1)) + NET_C(B2.7, R55.1) + NET_C(B2.7, R54.1) + NET_C(B2.6, R54.2) + NET_C(B2.6, C34.1) + NET_C(B2.2, C34.1) + NET_C(R55.2, V5) + NET_C(C34.2, GND) + NET_C(B2.8, V5) + NET_C(B2.1, GND) + TTL_7402_DIP(B3) + TTL_9316_DIP(B4) + TTL_74193_DIP(B5) + TTL_7400_DIP(B6) + TTL_9316_DIP(B7) + TTL_9316_DIP(B8) + TTL_7408_DIP(B9) + + TTL_7400_DIP(C2) + TTL_7400_DIP(C3) + TTL_7486_DIP(C4) + TTL_7404_DIP(C5) + TTL_7486_DIP(C6) + TTL_9316_DIP(C7) + TTL_9316_DIP(C8) - CHIP("C2", 7400) - CHIP("C3", 7400) - CHIP("C4", 7486) - CHIP("C5", 7404) - CHIP("C6", 7486) - CHIP("C7", 9316) - CHIP("C8", 9316) - //CHIP_555_Mono(C9, &c9_555_desc) NE555_DIP(C9) - CHIP("D2", 7432) - CHIP("D3", 7474) - CHIP("D4", 9316) - CHIP("D5", 7474) - CHIP("D6", 7408) - CHIP("D7", 7411) - CHIP("D8", 7400) -// CHIP("D9", 4016) //quad bilateral switch + TTL_7432_DIP(D2) + TTL_7474_DIP(D3) + TTL_9316_DIP(D4) + TTL_7474_DIP(D5) + TTL_7408_DIP(D6) + TTL_7411_DIP(D7) + TTL_7400_DIP(D8) + // CHIP("D9", 4016) //quad bilateral switch - CHIP("E1", 7404) - CHIP("E2", 7486) - CHIP("E3", 7402) - CHIP("E4", 7432) - CHIP("E5", 7408) - CHIP("E6", 7474) - CHIP("E7", 7402) - CHIP("E8", 7474) - CHIP("E9", 7404) + TTL_7404_DIP(E1) + TTL_7486_DIP(E2) + TTL_7402_DIP(E3) + TTL_7432_DIP(E4) + TTL_7408_DIP(E5) + TTL_7474_DIP(E6) + TTL_7402_DIP(E7) + TTL_7474_DIP(E8) + TTL_7404_DIP(E9) - CHIP("F2", 7411) - CHIP_9602_Mono(F3, &f3_desc) - CHIP("F4", 7474) - CHIP("F5", 7474) - CHIP("F6", 74193) - CHIP("F7", 74279) - CHIP("F8", 7474) - CHIP("F9", 7404) + TTL_7411_DIP(F2) - CHIP("H1", 7437) - CHIP("H2", 7408) - CHIP("H3", 7427) - CHIP("H4", 7400) + TTL_9602_DIP(F3) + NET_C(VCC, F3.16) + NET_C(GND, F3.8) + RES(R22, RES_K(47)) + CAP(CC14, CAP_U(1)) + RES(R23, RES_K(47)) + NET_C(F3.1, CC14.1) + NET_C(F3.2, CC14.2) + NET_C(F3.2, R22.2) + NET_C(VCC, R22.1) + CAP(CC15, CAP_U(1)) + NET_C(F3.15, CC15.1) + NET_C(F3.14, CC15.2) + NET_C(F3.14, R23.2) + NET_C(VCC, R23.1) + + TTL_7474_DIP(F4) + TTL_7474_DIP(F5) + TTL_74193_DIP(F6) + TTL_74279_DIP(F7) + TTL_7474_DIP(F8) + TTL_7404_DIP(F9) + + TTL_7437_DIP(H1) + TTL_7408_DIP(H2) + TTL_7427_DIP(H3) + TTL_7400_DIP(H4) DM9312_DIP(H5) - CHIP("H6", 9310) - CHIP("H7", 7408) //sometimes looks like N7 on schematic - //PARAM(H7.USE_DEACTIVATE, 0) - CHIP("H8", 7474) - CHIP("H9", 7474) + TTL_9310_DIP(H6) + TTL_7408_DIP(H7) - CHIP("J1", 74175) - CHIP("J2", 7404) - CHIP("J3", 7402) + TTL_7474_DIP(H8) + TTL_7474_DIP(H9) + + TTL_74175_DIP(J1) + TTL_7404_DIP(J2) + TTL_7402_DIP(J3) DM9312_DIP(J4) - CHIP("J5", 7448) - CHIP("J6", 9310) - CHIP("J7", 7420) - CHIP("J8", 74279) - CHIP("J9", 7410) + TTL_7448_DIP(J5) + TTL_9310_DIP(J6) + TTL_7420_DIP(J7) + TTL_74279_DIP(J8) + TTL_7410_DIP(J9) - CHIP("K1", 9316) - CHIP("K2", 7486) - CHIP("K3", 7430) - CHIP("K4", 7408) + TTL_9316_DIP(K1) + TTL_7486_DIP(K2) + TTL_7430_DIP(K3) + TTL_7408_DIP(K4) DM9312_DIP(K5) - CHIP("K6", 9310) - CHIP("K7", 7486) - CHIP("K8", 7474) //TODO: one more than bom? - CHIP("K9", 74107) + TTL_9310_DIP(K6) + TTL_7486_DIP(K7) + TTL_7474_DIP(K8) + TTL_74107_DIP(K9) - CHIP("L1", 9316) - CHIP("L2", 7486) - CHIP("L3", 82S16) //RAM - CHIP("L4", 7411) + TTL_9316_DIP(L1) + TTL_7486_DIP(L2) + TTL_82S16_DIP(L3) // Ram chip + TTL_7411_DIP(L4) DM9312_DIP(L5) - CHIP("L6", 9310) - CHIP("L7", 7486) - CHIP("L8", 74193) - CHIP("L9", 7400) //TODO: 1 more chip than on bom? + TTL_9310_DIP(L6) + TTL_7486_DIP(L7) + TTL_74193_DIP(L8) + TTL_7400_DIP(L9) - CHIP("M1", 9316) - CHIP("M2", 7483) - CHIP("M3", 7486) - CHIP("M4", 7410) + TTL_9316_DIP(M1) + TTL_7483_DIP(M2) + TTL_7486_DIP(M3) + TTL_7410_DIP(M4) DM9312_DIP(M5) - CHIP("M6", 9310) - CHIP("M8", 7427) - CHIP("M9", 7404) + TTL_9310_DIP(M6) + TTL_7427_DIP(M8) + TTL_7404_DIP(M9) - CHIP("N1", 9316) - CHIP("N2", 7483) - CHIP("N3", 7486) - CHIP("N4", 7411) + TTL_9316_DIP(N1) + TTL_7483_DIP(N2) + TTL_7486_DIP(N3) + TTL_7411_DIP(N4) DM9312_DIP(N5) - CHIP("N6", 9310) - CHIP("N7", 7408) //sometimes looks like H7 on schematic - CHIP_9602_Mono(N8, &n8_desc) - CHIP("N9", 74192) + TTL_9310_DIP(N6) + TTL_7408_DIP(N7) - //LM380 //speaker amplifier - //LM323 //regulator + TTL_9602_DIP(N8) + NET_C(VCC, N8.16) + NET_C(GND, N8.8) + RES(R2, RES_K(33)) + CAP(CC2, CAP_U(100)) + RES(R3, RES_K(5.6)) + NET_C(N8.1, CC2.1) + NET_C(N8.2, CC2.2) + NET_C(N8.2, R2.2) + NET_C(VCC, R2.1) + NET_C(N8.14, R3.2) + NET_C(VCC, R3.1) + TTL_74192_DIP(N9) - //HSYNC and VSYNC - #define H1_d "L1", 14 - #define H2_d "L1", 13 - #define H4_d "L1", 12 - #define H8_d "L1", 11 - #define H8_n "J2", 2 - #define H16_d "K1", 14 - #define H16_n "J2", 6 - #define H32_d "K1", 13 - #define H32_n "J2", 4 - #define H64_d "K1", 12 - #define H128_d "K1", 11 + //LM380 //speaker amplifier - not emulated + //LM323 //regulator - not emulated - #define V1_d "M1", 14 - #define V2_d "M1", 13 - #define V4_d "M1", 12 - #define V8_d "M1", 11 - #define V16_d "N1", 14 - #define V16_n "J2", 10 - #define V32_d "N1", 13 - #define V64_d "N1", 12 - #define V64I "H7", 11 - #define V64_n "M9", 10 - #define V128_d "N1", 11 + //---------------------------------------------------------------- + // HSYNC and VSYNC + //---------------------------------------------------------------- - #define H1 "L2", 8 - #define H2 "L2", 11 - #define H4 "L2", 3 - #define H8 "L2", 6 - #define H16 "K2", 8 - #define H32 "K2", 11 - #define H64 "K2", 3 - #define H128 "K2", 6 + ALIAS(H1_d ,L1.14) + ALIAS(H2_d ,L1.13) + ALIAS(H4_d ,L1.12) + ALIAS(H8_d ,L1.11) + ALIAS(H8_n ,J2.2) + ALIAS(H16_d ,K1.14) + ALIAS(H16_n ,J2.6) + ALIAS(H32_d ,K1.13) + ALIAS(H32_n ,J2.4) + ALIAS(H64_d ,K1.12) + ALIAS(H128_d ,K1.11) - //#define V1 - #define V2 "M3", 3 - #define V4 "M3", 6 - #define V8 "M3", 11 - #define V16 "N3", 8 - #define V32 "N3", 3 - #define V64 "N3", 6 - #define V128 "N3", 11 + ALIAS(V1_d ,M1.14) + ALIAS(V2_d ,M1.13) + ALIAS(V4_d ,M1.12) + ALIAS(V8_d ,M1.11) + ALIAS(V16_d ,N1.14) + ALIAS(V16_n ,J2.10) + ALIAS(V32_d ,N1.13) + ALIAS(V64_d ,N1.12) + ALIAS(V64I ,H7.11) + ALIAS(V64_n ,M9.10) + ALIAS(V128_d ,N1.11) - #define HSYNC "J1", 2 - #define HSYNC_n "J1", 3 - #define VSYNC "J1", 7 - #define VSYNC_n "J1", 6 - #define PSYNC "J1", 11 - #define PSYNC_n "J1", 10 - #define BSYNC "J1", 15 - #define BSYNC_n "J1", 14 + ALIAS(H1 ,L2.8) + ALIAS(H2 ,L2.11) + ALIAS(H4 ,L2.3) + ALIAS(H8 ,L2.6) + ALIAS(H16 ,K2.8) + ALIAS(H32 ,K2.11) + ALIAS(H64 ,K2.3) + ALIAS(H128 ,K2.6) - #define BALL "D7", 6 - #define BALL_DISPLAY "A4", 6 - #define PLAYFIELD "H4", 3 - #define SCORE "D3", 5 - #define VERT_TRIG_n "H1", 8 + ALIAS(V2 ,M3.3) + ALIAS(V4 ,M3.6) + ALIAS(V8 ,M3.11) + ALIAS(V16 ,N3.8) + ALIAS(V32 ,N3.3) + ALIAS(V64 ,N3.6) + ALIAS(V128 ,N3.11) - #define SCLOCK "K1", 15 + ALIAS(HSYNC ,J1.2) + ALIAS(HSYNC_n ,J1.3) + ALIAS(VSYNC ,J1.7) + ALIAS(VSYNC_n ,J1.6) + ALIAS(PSYNC ,J1.11) + ALIAS(PSYNC_n ,J1.10) + ALIAS(BSYNC ,J1.15) + ALIAS(BSYNC_n ,J1.14) - #define PAD_n "K3", 8 - #define PAD_EN_n "C2", 8 + ALIAS(BALL ,D7.6) + ALIAS(BALL_DISPLAY ,A4.6) + ALIAS(PLAYFIELD ,H4.3) + ALIAS(SCORE ,D3.5) + ALIAS(VERT_TRIG_n ,H1.8) - #define COIN "L9", 6 - #define CREDIT_1_OR_2 "L9", 3 - #define CREDIT_1_OR_2_n "F9", 8 - #define CREDIT2 "F9", 6 - #define CREDIT2_n "M8", 8 - #define CR_START1 "E8", 5 - #define CR_START1_n "E8", 6 //Schematic shows E8.6 as positive CR_START1, but this can't be right? - #define CR_START2 "E8", 9 - #define CR_START2_n "E8", 8 - #define CSW1 "F9", 12 - #define CSW2 "F9", 2 + ALIAS(SCLOCK ,K1.15) - #define P2_CONDITIONAL "H1", 3 - #define P2_CONDITIONAL_dash "H7", 8 - #define PLAYER_2 "B4", 14 - #define PLAYER_2_n "M9", 8 + ALIAS(PAD_n ,K3.8) + ALIAS(PAD_EN_n ,C2.8) - #define START_GAME "D8", 6 - #define START_GAME1_n "M9", 4 - #define START_GAME_n "M9", 6 + ALIAS(COIN ,L9.6) + ALIAS(CREDIT_1_OR_2 ,L9.3) + ALIAS(CREDIT_1_OR_2_n ,F9.8) + ALIAS(CREDIT2 ,F9.6) + ALIAS(CREDIT2_n ,M8.8) + ALIAS(CR_START1 ,E8.5) + ALIAS(CR_START1_n ,E8.6) //Schematic shows E8.6 as positive CR_START1, but this can't be right? + ALIAS(CR_START2 ,E8.9) + ALIAS(CR_START2_n ,E8.8) + ALIAS(CSW1 ,F9.12) + ALIAS(CSW2 ,F9.2) - #define BG1_n "K8", 9 - #define BG1 "K8", 8 - #define BG2_n "K8", 5 - #define BG2 "K8", 6 + ALIAS(P2_CONDITIONAL ,H1.3) + ALIAS(P2_CONDITIONAL_dash ,H7.8) + ALIAS(PLAYER_2 ,B4.14) + ALIAS(PLAYER_2_n ,M9.8) - #define FREE_GAME_TONE "N7", 3 - #define BONUS_COIN "L9", 11 + ALIAS(START_GAME ,D8.6) + ALIAS(START_GAME1_n ,M9.4) + ALIAS(START_GAME_n ,M9.6) - #define SBD_n "D2", 11 + ALIAS(BG1_n ,K8.9) + ALIAS(BG1 ,K8.8) + ALIAS(BG2_n ,K8.5) + ALIAS(BG2 ,K8.6) - #define PLAY_CP "D2", 8 - #define PLGM2_n "F7", 7 - #define VB_HIT_n "A5", 6 + ALIAS(FREE_GAME_TONE ,N7.3) + ALIAS(BONUS_COIN ,L9.11) - #define SERVE_n "SERVE", 1 - #define SERVE_WAIT "A3", 9 - #define SERVE_WAIT_n "A3", 8 + ALIAS(SBD_n ,D2.11) - #define BRICK_DISPLAY "E3", 1 - #define BRICK_HIT "E6", 5 - #define BRICK_HIT_n "E6", 6 + ALIAS(PLAY_CP ,D2.8) + ALIAS(PLGM2_n ,F7.7) + ALIAS(VB_HIT_n ,A5.6) - //#define EGL "A4", 3 - #define EGL "C37" , 2 - #define EGL_n "C5", 2 + ALIAS(SERVE_n ,SERVE.1) + ALIAS(SERVE_WAIT ,A3.9) + ALIAS(SERVE_WAIT_n ,A3.8) - #define RAM_PLAYER1 "E7", 4 - #define A1 "H6", 14 - #define B1 "H6", 13 - #define C1 "H6", 12 - #define D1 "H6", 11 - #define E1 "J6", 14 - #define F1 "J6", 13 - #define G1 "J6", 12 - #define H01 "J6", 11 - #define I1 "K6", 14 - #define J1 "K6", 13 - #define K1 "K6", 12 - #define L1 "K6", 11 - #define A2 "N6", 14 - #define B2 "N6", 13 - #define C2 "N6", 12 - #define D2 "N6", 11 - #define E2s "M6", 14 - #define F2 "M6", 13 - #define G2 "M6", 12 - #define H02 "M6", 11 //TODO: better name for these signals - #define I2 "L6", 14 - #define J2 "L6", 13 - #define K2 "L6", 12 - #define L2 "L6", 11 + ALIAS(BRICK_DISPLAY ,E3.1) + ALIAS(BRICK_HIT ,E6.5) + ALIAS(BRICK_HIT_n ,E6.6) - #define CX0 "C6", 11 - #define CX1 "C6", 6 - #define X0 "C5", 10 - #define X1 "B6", 3 - #define X2 "C6", 3 - #define Y0 "B6", 11 - #define Y1 "B6", 6 - #define Y2 "A6", 6 - #define DN "C4", 3 - #define PC "D4", 12 - #define PD "D4", 11 - #define SU_n "D5", 8 - #define V_SLOW "C5", 8 + //ALIAS(EGL ,A4.3) + ALIAS(EGL ,C37.1) + ALIAS(EGL_n ,C5.2) - #define PLNR "E3", 4 - #define SCI_n "H4", 6 - #define SFL_n "E9", 12 //score flash - #define TOP_n "E9", 2 + ALIAS(RAM_PLAYER1 ,E7.4) + ALIAS(A1 ,H6.14) + ALIAS(B1 ,H6.13) + ALIAS(C1 ,H6.12) + ALIAS(D1 ,H6.11) + ALIAS(E1 ,J6.14) + ALIAS(F1 ,J6.13) + ALIAS(G1 ,J6.12) + ALIAS(H01 ,J6.11) + ALIAS(I1 ,K6.14) + ALIAS(J1 ,K6.13) + ALIAS(K1 ,K6.12) + ALIAS(L1 ,K6.11) + ALIAS(A2 ,N6.14) + ALIAS(B2 ,N6.13) + ALIAS(C2 ,N6.12) + ALIAS(D2 ,N6.11) + ALIAS(E2s ,M6.14) + ALIAS(F2 ,M6.13) + ALIAS(G2 ,M6.12) + ALIAS(H02 ,M6.11) + ALIAS(I2 ,L6.14) + ALIAS(J2 ,L6.13) + ALIAS(K2 ,L6.12) + ALIAS(L2 ,L6.11) - #define BP_HIT_n "A5", 8 - #define BTB_HIT_n "C3", 3 + ALIAS(CX0 ,C6.11) + ALIAS(CX1 ,C6.6) + ALIAS(X0 ,C5.10) + ALIAS(X1 ,B6.3) + ALIAS(X2 ,C6.3) + ALIAS(Y0 ,B6.11) + ALIAS(Y1 ,B6.6) + ALIAS(Y2 ,A6.6) + ALIAS(DN ,C4.3) + ALIAS(PC ,D4.12) + ALIAS(PD ,D4.11) + ALIAS(SU_n ,D5.8) + ALIAS(V_SLOW ,C5.8) - #define SET_BRICKS "D3", 9 - #define SET_BRICKS_n "D3", 8 + ALIAS(PLNR ,E3.4) + ALIAS(SCI_n ,H4.6) + ALIAS(SFL_n ,E9.12) // Score Flash + ALIAS(TOP_n ,E9.2) - #define BALL_A "B4", 13 - #define BALL_B "B4", 12 - #define BALL_C "B4", 11 + ALIAS(BP_HIT_n ,A5.8) + ALIAS(BTB_HIT_n ,C3.3) - #define FPD1 "F3", 10 - #define FPD1_n "F3", 9 - #define FPD2 "F3", 6 - #define FPD2_n "F3", 7 + ALIAS(SET_BRICKS ,D3.9) + ALIAS(SET_BRICKS_n ,D3.8) - #define COUNT "N7", 11 - #define COUNT_1 "N7", 8 - #define COUNT_2 "N7", 6 + ALIAS(BALL_A ,B4.13) + ALIAS(BALL_B ,B4.12) + ALIAS(BALL_C ,B4.11) - #define ATTRACT "E6", 8 - #define ATTRACT_n "E6", 9 + ALIAS(FPD1 ,F3.10) + ALIAS(FPD1_n ,F3.9) + ALIAS(FPD2 ,F3.6) + ALIAS(FPD2_n ,F3.7) - #define BRICK_SOUND "B8", 14 - #define P_HIT_SOUND "B7", 12 - #define VB_HIT_SOUND "B7", 11 + ALIAS(COUNT ,N7.11) + ALIAS(COUNT_1 ,N7.8) + ALIAS(COUNT_2 ,N7.6) - #define LH_SIDE "J3", 13 - #define RH_SIDE "H2", 3 - #define TOP_BOUND "K4", 6 + ALIAS(ATTRACT ,E6.8) + ALIAS(ATTRACT_n ,E6.9) - //Audio - CONNECTION("M9", 2, "F6", 5) - CONNECTION("M9", 2, "F7", 15) - CONNECTION("F6", 13, "F7", 14) - CONNECTION(START_GAME_n, "F6", 11) - CONNECTION(P, "F6", 15) - CONNECTION(P, "F6", 1) - CONNECTION(P, "F6", 10) - CONNECTION(P, "F6", 9) - CONNECTION(GNDD, "F6", 14) - CONNECTION("F7", 13, "J9", 2) - CONNECTION(VSYNC, "J9", 1) - CONNECTION("A7", 9, "J9", 13) - CONNECTION("J9", 12, "F6", 4) - CONNECTION("J9", 12, "A7", 11) - CONNECTION(GNDD, "A7", 12) - CONNECTION(ATTRACT_n, "A7", 13) - CONNECTION("J9", 12, "A8", 11) - CONNECTION(GNDD, "A8", 12) - CONNECTION(ATTRACT_n, "A8", 13) - CONNECTION(VB_HIT_n, "A7", 5) - CONNECTION(GNDD, "A7", 4) - CONNECTION(ATTRACT_n, "A7", 3) - CONNECTION(BP_HIT_n, "A8", 5) - CONNECTION(GNDD, "A8", 4) - CONNECTION(ATTRACT_n, "A8", 3) - CONNECTION("A8", 6, "B9", 13) - CONNECTION(P_HIT_SOUND, "B9", 12) - CONNECTION("A8", 10, "B9", 10) - CONNECTION(BRICK_SOUND, "B9", 9) - CONNECTION("A7", 6, "B9", 4) - CONNECTION(VB_HIT_SOUND, "B9", 5) + ALIAS(BRICK_SOUND ,B8.14) + ALIAS(P_HIT_SOUND ,B7.12) + ALIAS(VB_HIT_SOUND ,B7.11) + + ALIAS(LH_SIDE ,J3.13) + ALIAS(RH_SIDE ,H2.3) + ALIAS(TOP_BOUND ,K4.6) + + //---------------------------------------------------------------- + // Audio circuit + //---------------------------------------------------------------- + + NET_C(M9.2, F6.5) + NET_C(M9.2, F7.15) + NET_C(F6.13, F7.14) + NET_C(START_GAME_n, F6.11) + NET_C(P, F6.15) + NET_C(P, F6.1) + NET_C(P, F6.10) + NET_C(P, F6.9) + NET_C(GNDD, F6.14) + NET_C(F7.13, J9.2) + NET_C(VSYNC, J9.1) + NET_C(A7.9, J9.13) + NET_C(J9.12, F6.4) + NET_C(J9.12, A7.11) + NET_C(GNDD, A7.12) + NET_C(ATTRACT_n, A7.13) + NET_C(J9.12, A8.11) + NET_C(GNDD, A8.12) + NET_C(ATTRACT_n, A8.13) + NET_C(VB_HIT_n, A7.5) + NET_C(GNDD, A7.4) + NET_C(ATTRACT_n, A7.3) + NET_C(BP_HIT_n, A8.5) + NET_C(GNDD, A8.4) + NET_C(ATTRACT_n, A8.3) + NET_C(A8.6, B9.13) + NET_C(P_HIT_SOUND, B9.12) + NET_C(A8.10, B9.10) + NET_C(BRICK_SOUND, B9.9) + NET_C(A7.6, B9.4) + NET_C(VB_HIT_SOUND, B9.5) NET_C(S1_1.1, GND) NET_C(S1_2.1, GND) @@ -573,1049 +656,1066 @@ CIRCUIT_LAYOUT( breakout ) NET_C(S1_3.2, R9.2) NET_C(S1_4.2, R10.2) - //Free Game Selector - CONNECTION(I1, "K7", 2) - //CONNECTION("S1", 15, "K7", 1) - CONNECTION("S1_1", 2, "K7", 1) - CONNECTION(J1, "K7", 12) - //CONNECTION("S1", 14, "K7", 13) - CONNECTION("S1_2", 2, "K7", 13) - CONNECTION(K1, "K7", 5) - //CONNECTION("S1", 6, "K7", 4) - CONNECTION("S1_3", 2, "K7", 4) - CONNECTION(L1, "K7", 9) - //CONNECTION("S1", 7, "K7", 10) - CONNECTION("S1_4", 2, "K7", 10) + //---------------------------------------------------------------- + // Free Game + //---------------------------------------------------------------- - CONNECTION(I2, "L7", 2) - //CONNECTION("S1", 15, "L7", 1) - CONNECTION("S1_1", 2, "L7", 1) - CONNECTION(J2, "L7", 12) - //CONNECTION("S1", 14, "L7", 13) - CONNECTION("S1_2", 2, "L7", 13) - CONNECTION(K2, "L7", 5) - //CONNECTION("S1", 6, "L7", 4) - CONNECTION("S1_3", 2, "L7", 4) - CONNECTION(L2, "L7", 9) - //CONNECTION("S1", 7, "L7", 10) - CONNECTION("S1_4", 2, "L7", 10) + NET_C(I1, K7.2) + NET_C(S1_1.2, K7.1) + NET_C(J1, K7.12) + NET_C(S1_2.2, K7.13) + NET_C(K1, K7.5) - CONNECTION("K7", 3, "J7", 13) - CONNECTION("K7", 11, "J7", 12) - CONNECTION("K7", 6, "J7", 10) - CONNECTION("K7", 8, "J7", 9) + NET_C(S1_3.2, K7.4) + NET_C(L1, K7.9) - CONNECTION("L7", 3, "J7", 1) - CONNECTION("L7", 11, "J7", 2) - CONNECTION("L7", 6, "J7", 4) - CONNECTION("L7", 8, "J7", 5) + NET_C(S1_4.2, K7.10) - CONNECTION(START_GAME1_n, "J8", 12) - CONNECTION(BG1_n, "J8", 11) - CONNECTION("J7", 8, "J8", 10) + NET_C(I2, L7.2) + NET_C(S1_1.2, L7.1) + NET_C(J2, L7.12) + NET_C(S1_2.2, L7.13) + NET_C(K2, L7.5) + NET_C(S1_3.2, L7.4) + NET_C(L2, L7.9) + NET_C(S1_4.2, L7.10) - CONNECTION(START_GAME1_n, "J8", 2) - CONNECTION(BG2_n, "J8", 3) - CONNECTION("J7", 6, "J8", 1) + NET_C(K7.3, J7.13) + NET_C(K7.11, J7.12) + NET_C(K7.6, J7.10) + NET_C(K7.8, J7.9) - CONNECTION("J8", 9, "K8", 12) - CONNECTION(EGL, "K8", 11) - CONNECTION(P, "K8", 13) - CONNECTION(LAT_Q, "K8", 10) + NET_C(L7.3, J7.1) + NET_C(L7.11, J7.2) + NET_C(L7.6, J7.4) + NET_C(L7.8, J7.5) - CONNECTION("J8", 4, "K8", 2) - CONNECTION(EGL, "K8", 3) - CONNECTION(P, "K8", 1) - CONNECTION(LAT_Q, "K8", 4) + NET_C(START_GAME1_n, J8.12) + NET_C(BG1_n, J8.11) + NET_C(J7.8, J8.10) - CONNECTION(P, "K9", 8) - CONNECTION("J8", 9, "K9", 9) - CONNECTION(GNDD, "K9", 11) - CONNECTION(HSYNC_n, "K9", 10) + NET_C(START_GAME1_n, J8.2) + NET_C(BG2_n, J8.3) + NET_C(J7.6, J8.1) - CONNECTION(P, "K9", 1) - CONNECTION("J8", 4, "K9", 12) - CONNECTION(GNDD, "K9", 4) - CONNECTION(HSYNC_n, "K9", 13) + NET_C(J8.9, K8.12) + NET_C(EGL, K8.11) + NET_C(P, K8.13) + NET_C(LAT_Q, K8.10) - CONNECTION("K9", 6, "L9", 12) - CONNECTION("K9", 2, "L9", 13) + NET_C(J8.4, K8.2) + NET_C(EGL, K8.3) + NET_C(P, K8.1) + NET_C(LAT_Q, K8.4) - CONNECTION(P, "N8", 5) - CONNECTION(BONUS_COIN, "N8", 4) - CONNECTION(ATTRACT_n, "N8", 3) + NET_C(P, K9.8) + NET_C(J8.9, K9.9) + NET_C(GNDD, K9.11) + NET_C(HSYNC_n, K9.10) - CONNECTION(V4_d, "N7", 2) - CONNECTION("N8", 6, "N7", 1) - // - CONNECTION(GNDD, "M2", 13) - CONNECTION(V1_d, "M2", 10) - CONNECTION(V2_d, "M2", 8) - CONNECTION(V4_d, "M2", 3) - CONNECTION(V8_d, "M2", 1) - CONNECTION(GNDD, "M2", 11) - CONNECTION(P2_CONDITIONAL, "M2", 7) - CONNECTION(GNDD, "M2", 4) - CONNECTION(GNDD, "M2", 16) + NET_C(P, K9.1) + NET_C(J8.4, K9.12) + NET_C(GNDD, K9.4) + NET_C(HSYNC_n, K9.13) - CONNECTION("M2", 14, "N2", 13) - CONNECTION(V16_d, "N2", 10) - CONNECTION(V32_d, "N2", 8) - CONNECTION(V64_d, "N2", 3) - CONNECTION(V128_d, "N2", 1) - CONNECTION(GNDD, "N2", 11) - CONNECTION(P2_CONDITIONAL, "N2", 7) - CONNECTION(GNDD, "N2", 4) - CONNECTION(GNDD, "N2", 16) + NET_C(K9.6, L9.12) + NET_C(K9.2, L9.13) - CONNECTION("M2", 6, "M3", 2) - CONNECTION(P2_CONDITIONAL, "M3", 1) - CONNECTION("M2", 2, "M3", 5) - CONNECTION(P2_CONDITIONAL, "M3", 4) - CONNECTION("M2", 15, "M3", 12) - CONNECTION(P2_CONDITIONAL, "M3", 13) + NET_C(P, N8.5) + NET_C(BONUS_COIN, N8.4) + NET_C(ATTRACT_n, N8.3) - CONNECTION(P2_CONDITIONAL, "N3", 10) - CONNECTION("N2", 9, "N3", 9) - CONNECTION(P2_CONDITIONAL, "N3", 1) - CONNECTION("N2", 6, "N3", 2) - CONNECTION(P2_CONDITIONAL, "N3", 4) - CONNECTION("N2", 2, "N3", 5) - CONNECTION(P2_CONDITIONAL, "N3", 13) - CONNECTION("N2", 15, "N3", 12) + NET_C(V4_d, N7.2) + NET_C(N8.6, N7.1) - CONNECTION(H1_d, "L2", 9) - CONNECTION(P2_CONDITIONAL, "L2", 10) - CONNECTION(H2_d, "L2", 12) - CONNECTION(P2_CONDITIONAL, "L2", 13) - CONNECTION(H4_d, "L2", 2) - CONNECTION(P2_CONDITIONAL, "L2", 1) - CONNECTION(H8_d, "L2", 5) - CONNECTION(P2_CONDITIONAL, "L2", 4) + NET_C(GNDD, M2.13) + NET_C(V1_d, M2.10) + NET_C(V2_d, M2.8) + NET_C(V4_d, M2.3) + NET_C(V8_d, M2.1) + NET_C(GNDD, M2.11) + NET_C(P2_CONDITIONAL, M2.7) + NET_C(GNDD, M2.4) + NET_C(GNDD, M2.16) - CONNECTION(P2_CONDITIONAL, "K2", 10) - CONNECTION(H16_d, "K2", 9) - CONNECTION(P2_CONDITIONAL, "K2", 13) - CONNECTION(H32_d, "K2", 12) - CONNECTION(P2_CONDITIONAL, "K2", 1) - CONNECTION(H64_d, "K2", 2) - CONNECTION(P2_CONDITIONAL, "K2", 4) - CONNECTION(H128_d, "K2", 5) + NET_C(M2.14, N2.13) + NET_C(V16_d, N2.10) + NET_C(V32_d, N2.8) + NET_C(V64_d, N2.3) + NET_C(V128_d, N2.1) + NET_C(GNDD, N2.11) + NET_C(P2_CONDITIONAL, N2.7) + NET_C(GNDD, N2.4) + NET_C(GNDD, N2.16) + NET_C(M2.6, M3.2) + NET_C(P2_CONDITIONAL, M3.1) + NET_C(M2.2, M3.5) + NET_C(P2_CONDITIONAL, M3.4) + NET_C(M2.15, M3.12) + NET_C(P2_CONDITIONAL, M3.13) - CONNECTION(V64, "M9", 11) - CONNECTION(H16, "J2", 5) - CONNECTION(H32, "J2", 3) - CONNECTION(V16, "J2", 11) - CONNECTION(H8, "J2", 1) + NET_C(P2_CONDITIONAL, N3.10) + NET_C(N2.9, N3.9) + NET_C(P2_CONDITIONAL, N3.1) + NET_C(N2.6, N3.2) + NET_C(P2_CONDITIONAL, N3.4) + NET_C(N2.2, N3.5) + NET_C(P2_CONDITIONAL, N3.13) + NET_C(N2.15, N3.12) - CONNECTION(DICECLOCK, "J1", 9) - CONNECTION(SCLOCK, "J1", 4) - CONNECTION("N4", 6, "J1", 5) - CONNECTION(PAD_n, "J1", 12) - CONNECTION(BALL_DISPLAY, "J1", 13) - CONNECTION(P, "J1", 1) + NET_C(H1_d, L2.9) + NET_C(P2_CONDITIONAL, L2.10) + NET_C(H2_d, L2.12) + NET_C(P2_CONDITIONAL, L2.13) + NET_C(H4_d, L2.2) + NET_C(P2_CONDITIONAL, L2.1) + NET_C(H8_d, L2.5) + NET_C(P2_CONDITIONAL, L2.4) - CONNECTION(P, "K1", 1) - CONNECTION(P, "K1", 3) - CONNECTION(P, "K1", 4) - CONNECTION(P, "K1", 5) - CONNECTION(P, "K1", 6) - CONNECTION(P, "K1", 9) - CONNECTION(P, "K1", 10) - CONNECTION(DICECLOCK, "K1", 2) - CONNECTION("L1", 15, "K1", 7) + NET_C(P2_CONDITIONAL, K2.10) + NET_C(H16_d, K2.9) + NET_C(P2_CONDITIONAL, K2.13) + NET_C(H32_d, K2.12) + NET_C(P2_CONDITIONAL, K2.1) + NET_C(H64_d, K2.2) + NET_C(P2_CONDITIONAL, K2.4) + NET_C(H128_d, K2.5) - CONNECTION(P, "L1", 1) - CONNECTION(P, "L1", 3) - CONNECTION(GNDD, "L1", 4) - CONNECTION(P, "L1", 5) - CONNECTION(GNDD, "L1", 6) - CONNECTION(VERT_TRIG_n, "L1", 9) - CONNECTION(P, "L1", 10) - CONNECTION(DICECLOCK, "L1", 2) - CONNECTION(P, "L1", 7) + NET_C(V64, M9.11) + NET_C(H16, J2.5) + NET_C(H32, J2.3) + NET_C(V16, J2.11) + NET_C(H8, J2.1) - CONNECTION(P, "N1", 1) - CONNECTION(P, "N1", 10) - CONNECTION(P, "N1", 3) - CONNECTION(P, "N1", 4) - CONNECTION(P, "N1", 5) - CONNECTION(P, "N1", 6) - CONNECTION(P, "N1", 9) - CONNECTION(DICECLOCK, "N1", 2) - CONNECTION("H2", 6, "N1", 7) + NET_C(CLOCK, J1.9) + NET_C(SCLOCK, J1.4) + NET_C(N4.6, J1.5) + NET_C(PAD_n, J1.12) + NET_C(BALL_DISPLAY, J1.13) + NET_C(P, J1.1) - CONNECTION("M1", 15, "H2", 5) - CONNECTION("L1", 15, "H2", 4) + NET_C(P, K1.1) + NET_C(P, K1.3) + NET_C(P, K1.4) + NET_C(P, K1.5) + NET_C(P, K1.6) + NET_C(P, K1.9) + NET_C(P, K1.10) + NET_C(CLOCK, K1.2) + NET_C(L1.15, K1.7) - CONNECTION(V128_d, "N4", 5) - CONNECTION(V64_d, "N4", 3) - CONNECTION(V32_d, "N4", 4) - CONNECTION("N4", 6, "H1", 10) - CONNECTION(VSYNC_n, "H1", 9) + NET_C(P, L1.1) + NET_C(P, L1.3) + NET_C(GNDD, L1.4) + NET_C(P, L1.5) + NET_C(GNDD, L1.6) + NET_C(VERT_TRIG_n, L1.9) + NET_C(P, L1.10) + NET_C(CLOCK, L1.2) + NET_C(P, L1.7) - CONNECTION(P, "M1", 1) - CONNECTION(GNDD, "M1", 3) - CONNECTION(GNDD, "M1", 4) - CONNECTION(P, "M1", 5) - CONNECTION(GNDD, "M1", 6) - CONNECTION(VERT_TRIG_n, "M1", 9) - CONNECTION(DICECLOCK, "M1", 2) - CONNECTION("L1", 15, "M1", 7) - CONNECTION("K1", 15, "M1", 10) + NET_C(P, N1.1) + NET_C(P, N1.10) + NET_C(P, N1.3) + NET_C(P, N1.4) + NET_C(P, N1.5) + NET_C(P, N1.6) + NET_C(P, N1.9) + NET_C(CLOCK, N1.2) + NET_C(H2.6, N1.7) + NET_C(M1.15, H2.5) + NET_C(L1.15, H2.4) - //9312 circuit - CONNECTION(PLAYER_2, "M9", 9) - CONNECTION(BALL_A, "C5", 5) - CONNECTION(BALL_A, "C4", 13) - CONNECTION(BALL_B, "C4", 12) - CONNECTION(BALL_A, "A4", 13) - CONNECTION(BALL_B, "A4", 12) - CONNECTION(BALL_C, "C4", 10) - CONNECTION("A4", 11, "C4", 9) + NET_C(V128_d, N4.5) + NET_C(V64_d, N4.3) + NET_C(V32_d, N4.4) + NET_C(N4.6, H1.10) + NET_C(VSYNC_n, H1.9) - CONNECTION(A2, "N5", 1) - CONNECTION(E2s, "N5", 2) - CONNECTION(I2, "N5", 3) - CONNECTION("C5", 6, "N5", 4) - CONNECTION(A1, "N5", 5) - CONNECTION(E1, "N5", 6) - CONNECTION(I1, "N5", 7) - CONNECTION(PLAYER_2_n, "N5", 9) - CONNECTION(H32_n, "N5", 10) - CONNECTION(V16, "N5", 11) - CONNECTION(V64, "N5", 12) - CONNECTION(V128, "N5", 13) + NET_C(P, M1.1) + NET_C(GNDD, M1.3) + NET_C(GNDD, M1.4) + NET_C(P, M1.5) + NET_C(GNDD, M1.6) + NET_C(VERT_TRIG_n, M1.9) + NET_C(CLOCK, M1.2) + NET_C(L1.15, M1.7) + NET_C(K1.15, M1.10) - CONNECTION(B2, "M5", 1) - CONNECTION(F2, "M5", 2) - CONNECTION(J2, "M5", 3) - CONNECTION("C4", 11, "M5", 4) - CONNECTION(B1, "M5", 5) - CONNECTION(F1, "M5", 6) - CONNECTION(J1, "M5", 7) - CONNECTION(PLAYER_2, "M5", 9) - CONNECTION(H32_n, "M5", 10) - CONNECTION(V16, "M5", 11) - CONNECTION(V64, "M5", 12) - CONNECTION(V128, "M5", 13) + NET_C(PLAYER_2, M9.9) + NET_C(BALL_A, C5.5) + NET_C(BALL_A, C4.13) + NET_C(BALL_B, C4.12) + NET_C(BALL_A, A4.13) + NET_C(BALL_B, A4.12) + NET_C(BALL_C, C4.10) + NET_C(A4.11, C4.9) - CONNECTION(C2, "L5", 1) - CONNECTION(G2, "L5", 2) - CONNECTION(K2, "L5", 3) - CONNECTION("C4", 8, "L5", 4) - CONNECTION(C1, "L5", 5) - CONNECTION(G1, "L5", 6) - CONNECTION(K1, "L5", 7) - CONNECTION(GNDD, "L5", 9) - CONNECTION(H32_n, "L5", 10) - CONNECTION(V16, "L5", 11) - CONNECTION(V64, "L5", 12) - CONNECTION(V128, "L5", 13) + NET_C(A2, N5.1) + NET_C(E2s, N5.2) + NET_C(I2, N5.3) + NET_C(C5.6, N5.4) + NET_C(A1, N5.5) + NET_C(E1, N5.6) + NET_C(I1, N5.7) + NET_C(PLAYER_2_n, N5.9) + NET_C(H32_n, N5.10) + NET_C(V16, N5.11) + NET_C(V64, N5.12) + NET_C(V128, N5.13) - CONNECTION(D2, "K5", 1) - CONNECTION(H02, "K5", 2) - CONNECTION(L2, "K5", 3) - CONNECTION(GNDD, "K5", 4) - CONNECTION(D1, "K5", 5) - CONNECTION(H01, "K5", 6) - CONNECTION(L1, "K5", 7) - CONNECTION(GNDD, "K5", 9) - CONNECTION(H32_n, "K5", 10) - CONNECTION(V16, "K5", 11) - CONNECTION(V64, "K5", 12) - CONNECTION(V128, "K5", 13) + NET_C(B2, M5.1) + NET_C(F2, M5.2) + NET_C(J2, M5.3) + NET_C(C4.11, M5.4) + NET_C(B1, M5.5) + NET_C(F1, M5.6) + NET_C(J1, M5.7) + NET_C(PLAYER_2, M5.9) + NET_C(H32_n, M5.10) + NET_C(V16, M5.11) + NET_C(V64, M5.12) + NET_C(V128, M5.13) - CONNECTION(P, "J5", 4) - CONNECTION(P, "J5", 3) - CONNECTION("N5", 15, "J5", 7) - CONNECTION("M5", 15, "J5", 1) - CONNECTION("L5", 15, "J5", 2) - CONNECTION("K5", 15, "J5", 6) - CONNECTION(H32, "J5", 5) + NET_C(C2, L5.1) + NET_C(G2, L5.2) + NET_C(K2, L5.3) + NET_C(C4.8, L5.4) + NET_C(C1, L5.5) + NET_C(G1, L5.6) + NET_C(K1, L5.7) + NET_C(GNDD, L5.9) + NET_C(H32_n, L5.10) + NET_C(V16, L5.11) + NET_C(V64, L5.12) + NET_C(V128, L5.13) - CONNECTION("J5", 13, "H5", 1) - CONNECTION(GNDD, "H5", 2) - CONNECTION(GNDD, "H5", 3) - CONNECTION("J5", 14, "H5", 4) - CONNECTION(GNDD, "H5", 5) - CONNECTION(GNDD, "H5", 6) - CONNECTION("J5", 10, "H5", 7) - CONNECTION(GNDD, "H5", 9) + NET_C(D2, K5.1) + NET_C(H02, K5.2) + NET_C(L2, K5.3) + NET_C(GNDD, K5.4) + NET_C(D1, K5.5) + NET_C(H01, K5.6) + NET_C(L1, K5.7) + NET_C(GNDD, K5.9) + NET_C(H32_n, K5.10) + NET_C(V16, K5.11) + NET_C(V64, K5.12) + NET_C(V128, K5.13) - CONNECTION(V4, "K4", 12) - CONNECTION(V8, "K4", 13) + NET_C(P, J5.4) + NET_C(P, J5.3) + NET_C(N5.15, J5.7) + NET_C(M5.15, J5.1) + NET_C(L5.15, J5.2) + NET_C(K5.15, J5.6) + NET_C(H32, J5.5) - CONNECTION("K4", 11, "H5", 10) - CONNECTION(H2, "H5", 11) - CONNECTION(H4, "H5", 12) - CONNECTION(H8, "H5", 13) + NET_C(J5.13, H5.1) + NET_C(GNDD, H5.2) + NET_C(GNDD, H5.3) + NET_C(J5.14, H5.4) + NET_C(GNDD, H5.5) + NET_C(GNDD, H5.6) + NET_C(J5.10, H5.7) + NET_C(GNDD, H5.9) - CONNECTION(H2, "L4", 3) - CONNECTION(H4, "L4", 5) - CONNECTION(H8, "L4", 4) + NET_C(V4, K4.12) + NET_C(V8, K4.13) - CONNECTION("J5", 12 , "J4", 1) - CONNECTION("J5", 11, "J4", 2) - CONNECTION(GNDD, "J4", 3) - CONNECTION(GNDD, "J4", 4) - CONNECTION("J5", 15, "J4", 5) - CONNECTION("J5", 9, "J4", 6) - CONNECTION(GNDD, "J4", 7) - CONNECTION(GNDD, "J4", 9) - CONNECTION("L4", 6, "J4", 10) - CONNECTION(H8, "J4", 11) - CONNECTION(V4, "J4", 12) - CONNECTION(V8, "J4", 13) + NET_C(K4.11, H5.10) + NET_C(H2, H5.11) + NET_C(H4, H5.12) + NET_C(H8, H5.13) - CONNECTION("H5", 14, "H4", 13) - CONNECTION("J4", 14, "H4", 12) + NET_C(H2, L4.3) + NET_C(H4, L4.5) + NET_C(H8, L4.4) - //PADDLES - CONNECTION(ATTRACT_n, "B2", 4) + NET_C(J5.12 , J4.1) + NET_C(J5.11, J4.2) + NET_C(GNDD, J4.3) + NET_C(GNDD, J4.4) + NET_C(J5.15, J4.5) + NET_C(J5.9, J4.6) + NET_C(GNDD, J4.7) + NET_C(GNDD, J4.9) + NET_C(L4.6, J4.10) + NET_C(H8, J4.11) + NET_C(V4, J4.12) + NET_C(V8, J4.13) - CONNECTION("B2", 3, "E9", 13) - CONNECTION(PLAYER_2_n, "M3", 9) - CONNECTION(V128, "M3", 10) - CONNECTION(H64, "J3", 8) - CONNECTION(H128, "J3", 9) - CONNECTION(V32, "E3", 5) - CONNECTION(V16_n, "E3", 6) + NET_C(H5.14, H4.13) + NET_C(J4.14, H4.12) - CONNECTION(SFL_n, "M8", 1) - CONNECTION("M3", 8, "M8", 2) - CONNECTION(PLNR, "M8", 13) - CONNECTION("J3", 10, "E9", 1) - CONNECTION(V64, "E2", 5) - CONNECTION(V32, "E2", 4) - CONNECTION(PLNR, "E2", 10) - CONNECTION(H16, "E2", 9) + //---------------------------------------------------------------- + // Paddles + //--------------------------------------------------------------- - CONNECTION("M8", 12, "M8", 3) - CONNECTION(TOP_n, "M8", 4) - CONNECTION(TOP_n, "M8", 5) - CONNECTION("H4", 11, "F2", 11) - CONNECTION("E2", 6, "F2", 10) - CONNECTION("E2", 8, "F2", 9) + NET_C(ATTRACT_n, B2.4) - CONNECTION("M8", 6, "H4", 5) - CONNECTION("F2", 8, "H4", 4) + NET_C(B2.3, E9.13) + NET_C(PLAYER_2_n, M3.9) + NET_C(V128, M3.10) + NET_C(H64, J3.8) + NET_C(H128, J3.9) + NET_C(V32, E3.5) + NET_C(V16_n, E3.6) -#if 0 - CONNECTION(PAD_EN_n, "PAD_EN_BUF", 1) + NET_C(SFL_n, M8.1) + NET_C(M3.8, M8.2) + NET_C(PLNR, M8.13) + NET_C(J3.10, E9.1) + NET_C(V64, E2.5) + NET_C(V32, E2.4) + NET_C(PLNR, E2.10) + NET_C(H16, E2.9) + + NET_C(M8.12, M8.3) + NET_C(TOP_n, M8.4) + NET_C(TOP_n, M8.5) + NET_C(H4.11, F2.11) + NET_C(E2.6, F2.10) + NET_C(E2.8, F2.9) + + NET_C(M8.6, H4.5) + NET_C(F2.8, H4.4) - CONNECTION("PAD_EN_BUF", 2, "C9", 4) - CONNECTION("PAD_EN_BUF", 2, "C9", 2) -#else // NOTE: Stabilizing CAP C20 not modelled. - CONNECTION(PAD_EN_n, "C9", 4) - CONNECTION(PAD_EN_n, "C9", 2) + + NET_C(PAD_EN_n, C9.4) + NET_C(PAD_EN_n, C9.2) NET_C(C9.8, V5) NET_C(C9.1, GND) - RES(R53, RES_K(12)) // 12k + RES(R53, RES_K(12)) // 12k CAP(C21, CAP_U(1)) NET_C(GND, C21.2, R53.2) NET_C(C21.1, R53.1, C9.6, C9.7) -#endif + NET_C(BTB_HIT_n, C5.3) + NET_C(P, F5.10) + NET_C(P, F5.12) + NET_C(C5.4, F5.11) + NET_C(SERVE_WAIT_n, F5.13) + NET_C(H64, E5.13) + NET_C(F5.9, E5.12) + NET_C(H128, E5.10) + NET_C(F5.8, E5.9) + NET_C(E5.11, E4.12) + NET_C(E5.8, E4.13) + NET_C(E4.11, D4.2) + NET_C(P, D4.3) + NET_C(P, D4.4) + NET_C(P, D4.5) + NET_C(P, D4.6) + NET_C(P, D4.9) + NET_C(P, D4.10) + NET_C(C3.11, D4.7) + NET_C(VSYNC_n, D4.1) - CONNECTION(BTB_HIT_n, "C5", 3) - CONNECTION(P, "F5", 10) - CONNECTION(P, "F5", 12) - CONNECTION("C5", 4, "F5", 11) - CONNECTION(SERVE_WAIT_n, "F5", 13) - CONNECTION(H64, "E5", 13) - CONNECTION("F5", 9, "E5", 12) - CONNECTION(H128, "E5", 10) - CONNECTION("F5", 8, "E5", 9) - CONNECTION("E5", 11, "E4", 12) - CONNECTION("E5", 8, "E4", 13) - CONNECTION("E4", 11, "D4", 2) - CONNECTION(P, "D4", 3) - CONNECTION(P, "D4", 4) - CONNECTION(P, "D4", 5) - CONNECTION(P, "D4", 6) - CONNECTION(P, "D4", 9) - CONNECTION(P, "D4", 10) - CONNECTION("C3", 11, "D4", 7) - CONNECTION(VSYNC_n, "D4", 1) + NET_C(D4.15, E4.10) + NET_C(H7.6, E4.9) + NET_C(C9.3, H7.5) + NET_C(PAD_EN_n, H7.4) + NET_C(E4.8, C3.12) + NET_C(ATTRACT_n, C3.13) + NET_C(H8, J3.2) + NET_C(H32, J3.3) - CONNECTION("D4", 15, "E4", 10) - CONNECTION("H7", 6, "E4", 9) - CONNECTION("C9", 3, "H7", 5) - CONNECTION(PAD_EN_n, "H7", 4) - CONNECTION("E4", 8, "C3", 12) - CONNECTION(ATTRACT_n, "C3", 13) - CONNECTION(H8, "J3", 2) - CONNECTION(H32, "J3", 3) + NET_C(C3.11, K3.12) + NET_C(H128, K3.5) + NET_C(H64, K3.6) + NET_C(H16, K3.11) + NET_C(H4, K3.4) + NET_C(J3.1, K3.1) + NET_C(P, K3.3) + NET_C(P, K3.2) - CONNECTION("C3", 11, "K3", 12) - CONNECTION(H128, "K3", 5) - CONNECTION(H64, "K3", 6) - CONNECTION(H16, "K3", 11) - CONNECTION(H4, "K3", 4) - CONNECTION("J3", 1, "K3", 1) - CONNECTION(P, "K3", 3) - CONNECTION(P, "K3", 2) + NET_C(V16_d, D7.1) + NET_C(V64_d, D7.13) + NET_C(V128_d, D7.2) + NET_C(D7.12, H1.4) + NET_C(V8_d, H1.5) + NET_C(H1.6, C2.4) + NET_C(H1.6, C2.5) + NET_C(V32_d, J2.9) + NET_C(J2.8, C2.10) + NET_C(C2.6, C2.9) - CONNECTION(V16_d, "D7", 1) - CONNECTION(V64_d, "D7", 13) - CONNECTION(V128_d, "D7", 2) - CONNECTION("D7", 12, "H1", 4) - CONNECTION(V8_d, "H1", 5) - CONNECTION("H1", 6, "C2", 4) - CONNECTION("H1", 6, "C2", 5) - CONNECTION(V32_d, "J2", 9) - CONNECTION("J2", 8, "C2", 10) - CONNECTION("C2", 6, "C2", 9) + //---------------------------------------------------------------- + // Score circuit + //--------------------------------------------------------------- + NET_C(SCI_n, D3.4) + NET_C(GNDD, D3.2) + NET_C(GNDD, D3.3) + NET_C(GNDD, D3.1) - //SCORE - CONNECTION(SCI_n, "D3", 4) - CONNECTION(GNDD, "D3", 2) - CONNECTION(GNDD, "D3", 3) - CONNECTION(GNDD, "D3", 1) + //---------------------------------------------------------------- + // Player 2 + //--------------------------------------------------------------- - //PLAYER2_CONDITIONAL - CONNECTION(PLAYER_2, "H7", 10) -#if 0 - CONNECTION(GNDD, "S2", 1) - CONNECTION(P, "S2", 2) - CONNECTION("S2", 3, "H7", 9) -#else + NET_C(PLAYER_2, H7.10) NET_C(S2.2, GND) NET_C(S2.1, H7.9) RES(R18, RES_K(1)) NET_C(R18.2, V5) NET_C(R18.1, S2.1) -#endif //A-L 1 and 2 - CONNECTION(SET_BRICKS_n, "B3", 2) - CONNECTION(H2, "B3", 3) - CONNECTION("B3", 1, "E7", 6) - CONNECTION(PLAYER_2, "E7", 5) - CONNECTION(P, "N6", 9) - CONNECTION(P, "M6", 9) - CONNECTION(P, "L6", 9) - CONNECTION(P, "H6", 9) - CONNECTION(P, "J6", 9) - CONNECTION(P, "K6", 9) + NET_C(SET_BRICKS_n, B3.2) + NET_C(H2, B3.3) + NET_C(B3.1, E7.6) + NET_C(PLAYER_2, E7.5) + NET_C(P, N6.9) + NET_C(P, M6.9) + NET_C(P, L6.9) + NET_C(P, H6.9) + NET_C(P, J6.9) + NET_C(P, K6.9) - CONNECTION(P, "N6", 10) - CONNECTION(PLAYER_2, "N6", 7) - CONNECTION(COUNT_2, "N6", 2) - CONNECTION(START_GAME_n, "N6", 1) + NET_C(P, N6.10) + NET_C(PLAYER_2, N6.7) + NET_C(COUNT_2, N6.2) + NET_C(START_GAME_n, N6.1) - CONNECTION("N6", 15, "M6", 10) - CONNECTION(PLAYER_2, "M6", 7) - CONNECTION(COUNT_2, "M6", 2) - CONNECTION(START_GAME_n, "M6", 1) + NET_C(N6.15, M6.10) + NET_C(PLAYER_2, M6.7) + NET_C(COUNT_2, M6.2) + NET_C(START_GAME_n, M6.1) - CONNECTION("M6", 15, "L6", 10) - CONNECTION(PLAYER_2, "L6", 7) - CONNECTION(COUNT_2, "L6", 2) - CONNECTION(START_GAME_n, "L6", 1) + NET_C(M6.15, L6.10) + NET_C(PLAYER_2, L6.7) + NET_C(COUNT_2, L6.2) + NET_C(START_GAME_n, L6.1) - CONNECTION(P, "H6", 10) - CONNECTION(RAM_PLAYER1, "H6", 7) - CONNECTION(COUNT_1, "H6", 2) - CONNECTION(START_GAME_n, "H6", 1) + NET_C(P, H6.10) + NET_C(RAM_PLAYER1, H6.7) + NET_C(COUNT_1, H6.2) + NET_C(START_GAME_n, H6.1) - CONNECTION("H6", 15, "J6", 10) - CONNECTION(RAM_PLAYER1, "J6", 7) - CONNECTION(COUNT_1, "J6", 2) - CONNECTION(START_GAME_n, "J6", 1) - - CONNECTION("J6", 15, "K6", 10) - CONNECTION(RAM_PLAYER1, "K6", 7) - CONNECTION(COUNT_1, "K6", 2) - CONNECTION(START_GAME_n, "K6", 1) + NET_C(H6.15, J6.10) + NET_C(RAM_PLAYER1, J6.7) + NET_C(COUNT_1, J6.2) + NET_C(START_GAME_n, J6.1) + NET_C(J6.15, K6.10) + NET_C(RAM_PLAYER1, K6.7) + NET_C(COUNT_1, K6.2) + NET_C(START_GAME_n, K6.1) //CX0 and CX1 - CONNECTION(BRICK_HIT, "H2", 9) - CONNECTION(H16_n, "H2", 10) - CONNECTION(P, "D5", 10) - CONNECTION(P, "D5", 12) - CONNECTION("H2", 8, "D5", 11) - CONNECTION(SERVE_WAIT_n, "D5", 13) - CONNECTION(X0, "C6", 13) - CONNECTION("D5", 9, "C6", 12) - CONNECTION("D5", 9, "D6", 12) - CONNECTION(DN, "D6", 13) - CONNECTION("D6", 11, "C6", 4) - CONNECTION(X1, "C6", 5) + NET_C(BRICK_HIT, H2.9) + NET_C(H16_n, H2.10) + NET_C(P, D5.10) + NET_C(P, D5.12) + NET_C(H2.8, D5.11) + NET_C(SERVE_WAIT_n, D5.13) + NET_C(X0, C6.13) + NET_C(D5.9, C6.12) + NET_C(D5.9, D6.12) + NET_C(DN, D6.13) + NET_C(D6.11, C6.4) + NET_C(X1, C6.5) - //COUNT1 and COUNT2 - CONNECTION(P, "N8", 11) - CONNECTION(BRICK_HIT, "N8", 12) - CONNECTION(ATTRACT_n, "N8", 13) - CONNECTION("N8", 9, "N9", 11) - CONNECTION(P, "N9", 15) - CONNECTION(P, "N9", 5) + //---------------------------------------------------------------- + // COUNT1 and COUNT2 + //--------------------------------------------------------------- - CONNECTION(COUNT, "N9", 4) - CONNECTION(START_GAME, "N9", 14) - CONNECTION(H8_n, "N9", 1) - CONNECTION(H16_n, "N9", 10) - CONNECTION(GNDD, "N9", 9) + NET_C(P, N8.11) + NET_C(BRICK_HIT, N8.12) + NET_C(ATTRACT_n, N8.13) + NET_C(N8.9, N9.11) + NET_C(P, N9.15) + NET_C(P, N9.5) - CONNECTION("N9", 13, "N7", 13) - CONNECTION(SCLOCK, "N7", 12) + NET_C(COUNT, N9.4) + NET_C(START_GAME, N9.14) + NET_C(H8_n, N9.1) + NET_C(H16_n, N9.10) + NET_C(GNDD, N9.9) - CONNECTION(PLAYER_2, "N7", 5) - CONNECTION(COUNT, "N7", 4) + NET_C(N9.13, N7.13) + NET_C(SCLOCK, N7.12) - CONNECTION(COUNT, "M9", 1) - CONNECTION(COUNT, "N7", 10) - CONNECTION(RAM_PLAYER1, "N7", 9) + NET_C(PLAYER_2, N7.5) + NET_C(COUNT, N7.4) + NET_C(COUNT, M9.1) + NET_C(COUNT, N7.10) + NET_C(RAM_PLAYER1, N7.9) - //Ball Logic - CONNECTION(P, "C7", 1) - CONNECTION(P, "C7", 10) - CONNECTION(P, "C7", 7) - CONNECTION(CX0, "C7", 3) - CONNECTION(CX1, "C7", 4) - CONNECTION(X2, "C7", 5) - CONNECTION(GNDD, "C7", 6) - CONNECTION("D8", 8, "C7", 9) - CONNECTION("C7", 15, "C8", 7) - CONNECTION("C7", 11, "C8", 10) - CONNECTION("C7", 12, "D7", 10) - CONNECTION("C7", 13, "D7", 11) - CONNECTION(DICECLOCK, "C7", 2) + //---------------------------------------------------------------- + // DSW - Free Game and Ball Logic + //--------------------------------------------------------------- - CONNECTION(P, "C8", 1) - CONNECTION(P, "C8", 3) - CONNECTION(P, "C8", 4) - CONNECTION(P, "C8", 5) - CONNECTION(P, "C8", 6) - CONNECTION(P, "C8", 9) - CONNECTION(DICECLOCK, "C8", 2) - CONNECTION("C8", 15, "B7", 7) - CONNECTION("C7", 15, "B7", 10) + NET_C(P, C7.1) + NET_C(P, C7.10) + NET_C(P, C7.7) + NET_C(CX0, C7.3) + NET_C(CX1, C7.4) + NET_C(X2, C7.5) + NET_C(GNDD, C7.6) + NET_C(D8.8, C7.9) + NET_C(C7.15, C8.7) + NET_C(C7.11, C8.10) + NET_C(C7.12, D7.10) + NET_C(C7.13, D7.11) + NET_C(CLOCK, C7.2) - CONNECTION(P, "B7", 1) - CONNECTION(Y0, "B7", 3) - CONNECTION(Y1, "B7", 4) - CONNECTION(Y2, "B7", 5) - CONNECTION(GNDD, "B7", 6) - CONNECTION("D8", 8, "B7", 9) - CONNECTION(DICECLOCK, "B7", 2) - CONNECTION("B7", 15, "B8", 7) + NET_C(P, C8.1) + NET_C(P, C8.3) + NET_C(P, C8.4) + NET_C(P, C8.5) + NET_C(P, C8.6) + NET_C(P, C8.9) + NET_C(CLOCK, C8.2) + NET_C(C8.15, B7.7) + NET_C(C7.15, B7.10) - CONNECTION(VB_HIT_SOUND, "D7", 9) + NET_C(P, B7.1) + NET_C(Y0, B7.3) + NET_C(Y1, B7.4) + NET_C(Y2, B7.5) + NET_C(GNDD, B7.6) + NET_C(D8.8, B7.9) + NET_C(CLOCK, B7.2) + NET_C(B7.15, B8.7) - CONNECTION(P, "B8", 1) - CONNECTION(P, "B8", 3) - CONNECTION(P, "B8", 4) - CONNECTION(P, "B8", 5) - CONNECTION(P, "B8", 6) - CONNECTION(P, "B8", 9) - CONNECTION("C8", 15, "B8", 10) - CONNECTION(DICECLOCK, "B8", 2) + NET_C(VB_HIT_SOUND, D7.9) - CONNECTION("B8", 15, "D8", 10) - CONNECTION("B7", 15, "D8", 9) + NET_C(P, B8.1) + NET_C(P, B8.3) + NET_C(P, B8.4) + NET_C(P, B8.5) + NET_C(P, B8.6) + NET_C(P, B8.9) + NET_C(C8.15, B8.10) + NET_C(CLOCK, B8.2) - CONNECTION("D7", 8, "D7", 5) - CONNECTION(P_HIT_SOUND, "D7", 4) - CONNECTION("B8", 15, "D7", 3) + NET_C(B8.15, D8.10) + NET_C(B7.15, D8.9) + NET_C(D7.8, D7.5) + NET_C(P_HIT_SOUND, D7.4) + NET_C(B8.15, D7.3) + + //---------------------------------------------------------------- // RH and LH Sides - CONNECTION(V128, "N4", 1) - CONNECTION(V64, "N4", 2) - CONNECTION(V16, "N4", 13) - CONNECTION("N4", 12, "N4", 11) - CONNECTION(V8, "N4", 10) - CONNECTION(V4, "N4", 9) - CONNECTION("N4", 8, "H2", 2) - CONNECTION(V32, "H2", 1) - CONNECTION("N4", 8, "J2", 13) - CONNECTION("J2", 12, "J3", 11) - CONNECTION(V32, "J3", 12) + //--------------------------------------------------------------- + NET_C(V128, N4.1) + NET_C(V64, N4.2) + NET_C(V16, N4.13) + NET_C(N4.12, N4.11) + NET_C(V8, N4.10) + NET_C(V4, N4.9) + NET_C(N4.8, H2.2) + NET_C(V32, H2.1) + NET_C(N4.8, J2.13) + NET_C(J2.12, J3.11) + NET_C(V32, J3.12) + + //---------------------------------------------------------------- // Top Bound - CONNECTION(H128, "H3", 4) - CONNECTION(H64, "H3", 5) - CONNECTION(H32, "H3", 3) - CONNECTION("H3", 6, "L4", 9) - CONNECTION(H16, "L4", 10) - CONNECTION(H8, "L4", 11) - CONNECTION("L4", 8, "K4", 5) - CONNECTION(VSYNC_n, "K4", 4) + //--------------------------------------------------------------- - //Cabinet type + NET_C(H128, H3.4) + NET_C(H64, H3.5) + NET_C(H32, H3.3) + NET_C(H3.6, L4.9) + NET_C(H16, L4.10) + NET_C(H8, L4.11) + NET_C(L4.8, K4.5) + NET_C(VSYNC_n, K4.4) + //---------------------------------------------------------------- + // Cabinet type + // + // FIXME: missing? + //--------------------------------------------------------------- + + //---------------------------------------------------------------- // Coin Circuit - CONNECTION("COIN1", 2, "F9", 13) - CONNECTION("COIN1", 1, "F9", 11) + //--------------------------------------------------------------- + + NET_C(COIN1.2, F9.13) + NET_C(COIN1.1, F9.11) NET_C(COIN1.Q, GND) - //CONNECTION(CSW1, "F9", 11) - CONNECTION(CSW1, "COIN1", 1) + NET_C(CSW1, COIN1.1) + NET_C(F9.10, COIN1.2) - //CONNECTION("F9", 10, "F9", 13) //TODO: causes lots of bouncing, commented out since this trace is not implemented in gotcha - CONNECTION("F9", 10, "COIN1", 2) //TODO: causes lots of bouncing, commented out since this trace is not implemented in gotcha + NET_C(V64, H7.12) + NET_C(V64, H7.13) - CONNECTION(V64, "H7", 12) - CONNECTION(V64, "H7", 13) + NET_C(CSW1, F8.10) + NET_C(F9.10, F8.12) + NET_C(V64I, F8.11) + NET_C(P, F8.13) + NET_C(P, F8.1) + NET_C(V64I, F8.3) + NET_C(F8.9, F8.2) + NET_C(CSW1, F8.4) - CONNECTION(CSW1, "F8", 10) - CONNECTION("F9", 10, "F8", 12) - CONNECTION(V64I, "F8", 11) - CONNECTION(P, "F8", 13) - CONNECTION(P, "F8", 1) - CONNECTION(V64I, "F8", 3) - CONNECTION("F8", 9, "F8", 2) - CONNECTION(CSW1, "F8", 4) + NET_C(F8.6, H8.12) + NET_C(P, H8.10) + NET_C(V16_d, H8.11) + NET_C(P, H8.13) + NET_C(H8.9, J8.15) + NET_C(H8.9, J9.9) + NET_C(V16_d, J8.14) + NET_C(J8.13, J9.10) - CONNECTION("F8", 6, "H8", 12) - CONNECTION(P, "H8", 10) - CONNECTION(V16_d, "H8", 11) - CONNECTION(P, "H8", 13) - CONNECTION("H8", 9, "J8", 15) - CONNECTION("H8", 9, "J9", 9) - CONNECTION(V16_d, "J8", 14) - CONNECTION("J8", 13, "J9", 10) - - CONNECTION(V4_d, "S3", 1) - CONNECTION("S3", 2, "J9", 11) + NET_C(V4_d, S3.1) + NET_C(S3.2, J9.11) RES(R15, RES_K(1)) NET_C(R15.1, V5) NET_C(R15.2, S3.2) - CONNECTION("J9", 8, "L9", 5) - CONNECTION("J9", 6, "L9", 4) + NET_C(J9.8, L9.5) + NET_C(J9.6, L9.4) - CONNECTION("COIN2", 2, "F9", 1) - CONNECTION("COIN2", 1, "F9", 3) + NET_C(COIN2.2, F9.1) + NET_C(COIN2.1, F9.3) NET_C(COIN2.Q, GND) - CONNECTION(CSW2, "COIN2", 1) - CONNECTION(CSW2, "H9", 10) - CONNECTION("F9", 4, "H9", 12) - CONNECTION("F9", 4, "COIN2", 2) - CONNECTION(V64_n, "H9", 11) - CONNECTION(V64_n, "H9", 3) - CONNECTION(P, "H9", 13) - CONNECTION("H9", 9, "H9", 2) - CONNECTION(CSW2, "H9", 4) - CONNECTION(P, "H9", 1) + NET_C(CSW2, COIN2.1) + NET_C(CSW2, H9.10) + NET_C(F9.4, H9.12) + NET_C(F9.4, COIN2.2) + NET_C(V64_n, H9.11) + NET_C(V64_n, H9.3) + NET_C(P, H9.13) + NET_C(H9.9, H9.2) + NET_C(CSW2, H9.4) + NET_C(P, H9.1) - CONNECTION(P, "H8", 4) - CONNECTION("H9", 6, "H8", 2) - CONNECTION(V16_d, "H8", 3) - CONNECTION(P, "H8", 1) - CONNECTION("H8", 5, "J8", 6) - CONNECTION(V16_d, "J8", 5) - CONNECTION(P, "J9", 3) - CONNECTION("H8", 5, "J9", 5) - CONNECTION("J8", 7, "J9", 4) + NET_C(P, H8.4) + NET_C(H9.6, H8.2) + NET_C(V16_d, H8.3) + NET_C(P, H8.1) + NET_C(H8.5, J8.6) + NET_C(V16_d, J8.5) + NET_C(P, J9.3) + NET_C(H8.5, J9.5) + NET_C(J8.7, J9.4) - CONNECTION(P2_CONDITIONAL_dash, "E9", 9) - CONNECTION("E9", 8, "H1", 1) - CONNECTION("E9", 8, "H1", 2) + NET_C(P2_CONDITIONAL_dash, E9.9) + NET_C(E9.8, H1.1) + NET_C(E9.8, H1.2) + + //---------------------------------------------------------------- + // Start 1 & 2 logic + //--------------------------------------------------------------- - //Start2 Input - //Start1 Input RES(R58, RES_K(1)) - //CONNECTION("START", 2, "E9", 11) NET_C(START2.2, GND) NET_C(R58.1, V5) NET_C(START2.1, R58.2, E9.11) - CONNECTION("E9", 10, "E8", 12) - CONNECTION(P, "E8", 10) - CONNECTION(V64I, "E8", 11) + NET_C(E9.10, E8.12) + NET_C(P, E8.10) + NET_C(V64I, E8.11) - CONNECTION(V128_d, "F7", 2) - CONNECTION(V128_d, "F7", 3) - CONNECTION(CREDIT2_n, "F7", 1) - CONNECTION(ATTRACT_n, "E7", 12) - CONNECTION("F7", 4, "E7", 11) - CONNECTION("E7", 13, "E8", 13) + NET_C(V128_d, F7.2) + NET_C(V128_d, F7.3) + NET_C(CREDIT2_n, F7.1) + NET_C(ATTRACT_n, E7.12) + NET_C(F7.4, E7.11) + NET_C(E7.13, E8.13) //Start1 Input RES(R57, RES_K(1)) - //CONNECTION("START", 1, "E9", 3) NET_C(START1.2, GND) NET_C(R57.1, V5) NET_C(START1.1, R57.2, E9.3) - CONNECTION("E9", 4, "E8", 2) - CONNECTION(P, "E8", 4) - CONNECTION(V64_d, "E8", 3) + NET_C(E9.4, E8.2) + NET_C(P, E8.4) + NET_C(V64_d, E8.3) + NET_C(CREDIT_1_OR_2_n, E7.2) + NET_C(ATTRACT_n, E7.3) + NET_C(E7.1, E8.1) - CONNECTION(CREDIT_1_OR_2_n, "E7", 2) - CONNECTION(ATTRACT_n, "E7", 3) - CONNECTION("E7", 1, "E8", 1) + NET_C(CR_START1_n, D8.4) + NET_C(CR_START2_n, D8.5) - CONNECTION(CR_START1_n, "D8", 4) // Schematic shows CR_START1 ? - CONNECTION(CR_START2_n, "D8", 5) + NET_C(START_GAME, M9.3) + NET_C(START_GAME, M9.5) + NET_C(V32, D6.4) + NET_C(ATTRACT, D6.5) + NET_C(P, E6.10) + NET_C(START_GAME, E6.12) + NET_C(D6.6, E6.11) + NET_C(D6.3, E6.13) - CONNECTION(START_GAME, "M9", 3) - CONNECTION(START_GAME, "M9", 5) + NET_C(CREDIT_1_OR_2_n, D8.13) + NET_C(EGL, D8.12) - CONNECTION(V32, "D6", 4) - CONNECTION(ATTRACT, "D6", 5) - CONNECTION(P, "E6", 10) - CONNECTION(START_GAME, "E6", 12) - CONNECTION("D6", 6, "E6", 11) - CONNECTION("D6", 3, "E6", 13) + NET_C(LAT_Q, D6.1) + NET_C(EGL_n, D6.2) - //TODO: hows this whole latch stuff work? what about Q_n going to COIN1_n and COIN2_n - CONNECTION(CREDIT_1_OR_2_n, "D8", 13) - CONNECTION(EGL, "D8", 12) - - - CONNECTION(LAT_Q, "D6", 1) - CONNECTION(EGL_n, "D6", 2) - - //Serve + //---------------------------------------------------------------- + // Serve logic + //--------------------------------------------------------------- RES(R30, RES_K(1)) NET_C(SERVE.2, GND) NET_C(SERVE.1, R30.2) NET_C(R30.1, V5) - CONNECTION(H64, "J3", 6) - CONNECTION(H32, "J3", 5) - CONNECTION("J3", 4, "L4", 13) - CONNECTION(H128, "L4", 2) - CONNECTION(H16, "L4", 1) + NET_C(H64, J3.6) + NET_C(H32, J3.5) + NET_C(J3.4, L4.13) + NET_C(H128, L4.2) + NET_C(H16, L4.1) - CONNECTION(BALL_DISPLAY, "H2", 13) - CONNECTION(H128, "H2", 12) - CONNECTION("H2", 11, "C3", 9) - CONNECTION(HSYNC, "C3", 10) - CONNECTION("C3", 8, "B3", 5) - CONNECTION(H8_d, "B3", 6) - CONNECTION("B3", 4, "C3", 4) - CONNECTION(H4, "C3", 5) - CONNECTION("C3", 6, "A4", 9) - CONNECTION(START_GAME1_n, "A4", 10) + NET_C(BALL_DISPLAY, H2.13) + NET_C(H128, H2.12) + NET_C(H2.11, C3.9) + NET_C(HSYNC, C3.10) + NET_C(C3.8, B3.5) + NET_C(H8_d, B3.6) + NET_C(B3.4, C3.4) + NET_C(H4, C3.5) + NET_C(C3.6, A4.9) + NET_C(START_GAME1_n, A4.10) - CONNECTION(SERVE_WAIT_n, "D2", 13) + NET_C(SERVE_WAIT_n, D2.13) - CONNECTION(SERVE_n, "D2", 12) - CONNECTION(SERVE_n, "A3", 4) - CONNECTION(P, "A3", 2) - CONNECTION(ATTRACT, "A3", 3) - CONNECTION(SERVE_WAIT, "A3", 1) + NET_C(SERVE_n, D2.12) + NET_C(SERVE_n, A3.4) + NET_C(P, A3.2) + NET_C(ATTRACT, A3.3) + NET_C(SERVE_WAIT, A3.1) - CONNECTION(BALL, "E1", 13) - CONNECTION("E1", 12, "B3", 8) - CONNECTION("A3", 6, "B3", 9) - CONNECTION("B3", 10, "B3", 11) - CONNECTION(SERVE_WAIT_n, "B3", 12) - CONNECTION("B3", 13, "A3", 12) - CONNECTION("A4", 8, "A3", 10) - CONNECTION("L4", 12, "A3", 11) - CONNECTION(P, "A3", 13) + NET_C(BALL, E1.13) + NET_C(E1.12, B3.8) + NET_C(A3.6, B3.9) + NET_C(B3.10, B3.11) + NET_C(SERVE_WAIT_n, B3.12) + NET_C(B3.13, A3.12) + NET_C(A4.8, A3.10) + NET_C(L4.12, A3.11) + NET_C(P, A3.13) - //Set Bricks - CONNECTION(P, "D3", 10) - CONNECTION(P, "D3", 12) - CONNECTION(START_GAME, "D3", 11) - CONNECTION(SERVE_n, "D3", 13) + //---------------------------------------------------------------- + // Bricks logic + //--------------------------------------------------------------- - //Playfield - CONNECTION(LH_SIDE, "H3", 1) - CONNECTION(TOP_BOUND, "H3", 13) - CONNECTION(RH_SIDE, "H3", 2) - CONNECTION("H3", 12, "H4", 2) - CONNECTION("E1", 2, "C36", 1) - CONNECTION("C36", 2, "H4", 1) + NET_C(P, D3.10) + NET_C(P, D3.12) + NET_C(START_GAME, D3.11) + NET_C(SERVE_n, D3.13) - CONNECTION(BALL_DISPLAY, "A5", 10) - CONNECTION(PSYNC, "A5", 9) - CONNECTION(BSYNC, "C3", 2) - CONNECTION(TOP_BOUND, "C3", 1) + //---------------------------------------------------------------- + // Playfield logic + //--------------------------------------------------------------- - CONNECTION(PC, "C4", 4) - CONNECTION(PD, "C4", 5) - CONNECTION(BP_HIT_n, "C5", 13) - CONNECTION(PD, "A5", 1) - CONNECTION("C5", 12, "A5", 2) - CONNECTION(BSYNC, "A5", 5) - CONNECTION(VSYNC, "A5", 4) + NET_C(LH_SIDE, H3.1) + NET_C(TOP_BOUND, H3.13) + NET_C(RH_SIDE, H3.2) + NET_C(H3.12, H4.2) + NET_C(E1.2, C36.1) +#if (SLOW_BUT_ACCURATE) + NET_C(C36.1, H4.1) +#else + NET_C(C36.2, H4.1) +#endif + NET_C(BALL_DISPLAY, A5.10) + NET_C(PSYNC, A5.9) + NET_C(BSYNC, C3.2) + NET_C(TOP_BOUND, C3.1) - CONNECTION("C5", 12, "A5", 13) - CONNECTION("A5", 3, "A5", 12) + NET_C(PC, C4.4) + NET_C(PD, C4.5) + NET_C(BP_HIT_n, C5.13) + NET_C(PD, A5.1) + NET_C(C5.12, A5.2) + NET_C(BSYNC, A5.5) + NET_C(VSYNC, A5.4) - CONNECTION(BRICK_HIT, "D5", 3) - CONNECTION("E5", 3, "D5", 1) - CONNECTION("D5", 6, "D5", 2) - CONNECTION(BP_HIT_n, "D5", 4) + NET_C(C5.12, A5.13) + NET_C(A5.3, A5.12) - CONNECTION(P, "A6", 10) - CONNECTION("C4", 6, "A6", 12) - CONNECTION(BP_HIT_n, "A6", 11) - CONNECTION(P, "A6", 13) + NET_C(BRICK_HIT, D5.3) + NET_C(E5.3, D5.1) + NET_C(D5.6, D5.2) + NET_C(BP_HIT_n, D5.4) - CONNECTION("A5", 3, "A6", 4) - CONNECTION(V16_d, "A6", 2) - CONNECTION(VB_HIT_n, "A6", 3) - CONNECTION("A5", 11, "A6", 1) + NET_C(P, A6.10) + NET_C(C4.6, A6.12) + NET_C(BP_HIT_n, A6.11) + NET_C(P, A6.13) - CONNECTION(P2_CONDITIONAL, "C6", 1) - CONNECTION("D5", 5, "C6", 2) - CONNECTION("D5", 6, "C4", 2) - CONNECTION(P2_CONDITIONAL, "C4", 1) + NET_C(A5.3, A6.4) + NET_C(V16_d, A6.2) + NET_C(VB_HIT_n, A6.3) + NET_C(A5.11, A6.1) - CONNECTION(V_SLOW, "B6", 12) - CONNECTION("A6", 8, "B6", 13) - CONNECTION(V_SLOW, "C6", 10) - CONNECTION("A6", 5, "C6", 9) + NET_C(P2_CONDITIONAL, C6.1) + NET_C(D5.5, C6.2) + NET_C(D5.6, C4.2) + NET_C(P2_CONDITIONAL, C4.1) - CONNECTION(Y0, "B6", 4) - CONNECTION("C6", 8, "B6", 5) + NET_C(V_SLOW, B6.12) + NET_C(A6.8, B6.13) + NET_C(V_SLOW, C6.10) + NET_C(A6.5, C6.9) - CONNECTION(X2, "D6", 10) - CONNECTION("B6", 8, "D6", 9) - CONNECTION("B5", 7, "B6", 9) - CONNECTION("B5", 6, "B6", 10) - CONNECTION(X0, "B6", 1) - CONNECTION(X2, "B6", 2) + NET_C(Y0, B6.4) + NET_C(C6.8, B6.5) - CONNECTION("B5", 6, "C5", 11) - CONNECTION("B5", 7, "C5", 9) + NET_C(X2, D6.10) + NET_C(B6.8, D6.9) + NET_C(B5.7, B6.9) + NET_C(B5.6, B6.10) + NET_C(X0, B6.1) + NET_C(X2, B6.2) - CONNECTION(SU_n, "B5", 11) - CONNECTION(P, "B5", 15) - CONNECTION(P, "B5", 1) - CONNECTION(P, "B5", 10) - CONNECTION(P, "B5", 9) - CONNECTION(P, "B5", 4) - CONNECTION("D6", 8, "B5", 5) - CONNECTION(SERVE_WAIT, "B5", 14) + NET_C(B5.6, C5.11) + NET_C(B5.7, C5.9) - CONNECTION(BTB_HIT_n, "E5", 1) - CONNECTION(SBD_n, "E5", 2) + NET_C(SU_n, B5.11) + NET_C(P, B5.15) + NET_C(P, B5.1) + NET_C(P, B5.10) + NET_C(P, B5.9) + NET_C(P, B5.4) + NET_C(D6.8, B5.5) + NET_C(SERVE_WAIT, B5.14) - CONNECTION(BP_HIT_n, "E5", 4) - CONNECTION(BTB_HIT_n, "E5", 5) - CONNECTION("E5", 6, "F7", 11) - CONNECTION("E5", 6, "F7", 12) - CONNECTION(BRICK_HIT_n, "F7", 10) - CONNECTION("F7", 9, "C2", 2) - CONNECTION(BALL_DISPLAY, "C2", 1) - CONNECTION("L3", 6, "E3", 11) - CONNECTION("C2", 3, "E3", 12) + NET_C(BTB_HIT_n, E5.1) + NET_C(SBD_n, E5.2) - CONNECTION(SET_BRICKS_n, "E6", 4) - CONNECTION("E3", 13, "E6", 2) - CONNECTION(CKBH, "E6", 3) - CONNECTION("E3", 13, "D2", 2) - CONNECTION(SET_BRICKS, "D2", 1) - CONNECTION("D2", 3, "E6", 1) + NET_C(BP_HIT_n, E5.4) + NET_C(BTB_HIT_n, E5.5) + NET_C(E5.6, F7.11) + NET_C(E5.6, F7.12) + NET_C(BRICK_HIT_n, F7.10) + NET_C(F7.9, C2.2) + NET_C(BALL_DISPLAY, C2.1) + NET_C(L3.6, E3.11) + NET_C(C2.3, E3.12) - CONNECTION(BRICK_DISPLAY, "E1", 1) - CONNECTION(H1, "K4", 9) - CONNECTION(H2, "K4", 10) - CONNECTION("K4", 8, "E3", 2) - CONNECTION("L3", 6, "E3", 3) + NET_C(SET_BRICKS_n, E6.4) + NET_C(E3.13, E6.2) + NET_C(CKBH, E6.3) + NET_C(E3.13, D2.2) + NET_C(SET_BRICKS, D2.1) + NET_C(D2.3, E6.1) - CONNECTION(ATTRACT_n, "C2", 13) - CONNECTION(SET_BRICKS_n, "C2", 12) - CONNECTION("C2", 11, "H3", 10) - CONNECTION(FPD1, "H3", 9) - CONNECTION(FPD2, "H3", 11) - CONNECTION("H3", 8, "E1", 3) - CONNECTION("E1", 4, "C32", 1) - CONNECTION("C32", 2, "L3", 13) - CONNECTION(H4, "L3", 2) - CONNECTION(H8, "L3", 1) - CONNECTION(H16, "L3", 15) - CONNECTION(V32, "L3", 14) - CONNECTION(V64, "L3", 7) - CONNECTION(V128, "L3", 9) - CONNECTION(V16, "L3", 10) - CONNECTION(RAM_PLAYER1, "L3", 11) - CONNECTION(H32, "L3", 3) - CONNECTION(H128, "L3", 4) - CONNECTION("H4", 8, "L3", 5) + NET_C(BRICK_DISPLAY, E1.1) + NET_C(H1, K4.9) + NET_C(H2, K4.10) + NET_C(K4.8, E3.2) + NET_C(L3.6, E3.3) - CONNECTION(V2, "M4", 5) - CONNECTION(V4, "M4", 4) - CONNECTION(V8, "M4", 3) - CONNECTION("M4", 6, "H4", 9) - CONNECTION(VSYNC_n, "K4", 2) - CONNECTION(H64, "K4", 1) - CONNECTION("K4", 3, "H4", 10) - CONNECTION(FPD1_n, "F2", 13) - CONNECTION(BRICK_HIT_n, "F2", 2) - CONNECTION(FPD2_n, "F2", 1) + NET_C(ATTRACT_n, C2.13) + NET_C(SET_BRICKS_n, C2.12) + NET_C(C2.11, H3.10) + NET_C(FPD1, H3.9) + NET_C(FPD2, H3.11) + NET_C(H3.8, E1.3) + NET_C(E1.4, C32.1) + NET_C(C32.1, L3.13) + NET_C(H4, L3.2) + NET_C(H8, L3.1) + NET_C(H16, L3.15) + NET_C(V32, L3.14) + NET_C(V64, L3.7) + NET_C(V128, L3.9) + NET_C(V16, L3.10) + NET_C(RAM_PLAYER1, L3.11) + NET_C(H32, L3.3) + NET_C(H128, L3.4) + NET_C(H4.8, L3.5) - CONNECTION("F2", 12, "L3", 12) + NET_C(V2, M4.5) + NET_C(V4, M4.4) + NET_C(V8, M4.3) + NET_C(M4.6, H4.9) + NET_C(VSYNC_n, K4.2) + NET_C(H64, K4.1) + NET_C(K4.3, H4.10) + NET_C(FPD1_n, F2.13) + NET_C(BRICK_HIT_n, F2.2) + NET_C(FPD2_n, F2.1) - //FPD circuits - CONNECTION(K2, "M4", 2) - CONNECTION(G2, "M4", 13) - CONNECTION(D2, "M4", 1) - CONNECTION(K1, "M4", 9) - CONNECTION(G1, "M4", 10) - CONNECTION(D1, "M4", 11) - CONNECTION(BP_HIT_n, "E4", 2) - CONNECTION("M4", 12, "E4", 1) - CONNECTION(BP_HIT_n, "E4", 4) - CONNECTION("M4", 8, "E4", 5) + NET_C(F2.12, L3.12) - CONNECTION(P, "F4", 4) - CONNECTION(P, "F4", 2) - CONNECTION("E4", 3, "F4", 3) - CONNECTION(START_GAME1_n, "F4", 1) + //---------------------------------------------------------------- + // Hit circuits and start logic + //--------------------------------------------------------------- - CONNECTION(P, "F4", 10) - CONNECTION(P, "F4", 12) - CONNECTION("E4", 6, "F4", 11) - CONNECTION(START_GAME1_n, "F4", 13) + NET_C(K2, M4.2) + NET_C(G2, M4.13) + NET_C(D2, M4.1) + NET_C(K1, M4.9) + NET_C(G1, M4.10) + NET_C(D1, M4.11) + NET_C(BP_HIT_n, E4.2) + NET_C(M4.12, E4.1) + NET_C(BP_HIT_n, E4.4) + NET_C(M4.8, E4.5) - CONNECTION("F4", 6, "F3", 5) - CONNECTION(GNDD, "F3", 4) - CONNECTION("F4", 8, "F3", 11) - CONNECTION(GNDD, "F3", 12) + NET_C(P, F4.4) + NET_C(P, F4.2) + NET_C(E4.3, F4.3) + NET_C(START_GAME1_n, F4.1) - CONNECTION(P, "F3", 3) - CONNECTION(P, "F3", 13) + NET_C(P, F4.10) + NET_C(P, F4.12) + NET_C(E4.6, F4.11) + NET_C(START_GAME1_n, F4.13) + NET_C(F4.6, F3.5) + NET_C(GNDD, F3.4) + NET_C(F4.8, F3.11) + NET_C(GNDD, F3.12) - //CREDIT_COUNTER - CONNECTION(BONUS_COIN, "E7", 8) - CONNECTION(COIN, "E7", 9) - CONNECTION(CR_START1_n, "H7", 2) - CONNECTION(V8, "D8", 1) - CONNECTION(CR_START2, "D8", 2) - CONNECTION("D8", 3, "H7", 1) + NET_C(P, F3.3) + NET_C(P, F3.13) - CONNECTION("L8", 12, "L8", 11) // not on schematic, on rollover load 16, keeps you from losing all credits - CONNECTION(P, "L8", 15) - CONNECTION(P, "L8", 1) - CONNECTION(P, "L8", 10) - CONNECTION(P, "L8", 9) - CONNECTION("E7", 10, "L8", 5) - CONNECTION("H7", 3, "L8", 4) + //---------------------------------------------------------------- + // Credit counter logic + //--------------------------------------------------------------- - CONNECTION(LAT_Q, "L9", 10) - CONNECTION("L8", 13, "L9", 9) - CONNECTION("L9", 8, "L8", 14) - CONNECTION("L8", 7, "M8", 9) - CONNECTION("L8", 6, "M8", 10) - CONNECTION("L8", 2, "M8", 11) - CONNECTION("L8", 3, "M9", 13) + NET_C(BONUS_COIN, E7.8) + NET_C(COIN, E7.9) + NET_C(CR_START1_n, H7.2) + NET_C(V8, D8.1) + NET_C(CR_START2, D8.2) + NET_C(D8.3, H7.1) - CONNECTION(CREDIT2_n, "F9", 5) - CONNECTION(CREDIT2_n, "L9", 2) - CONNECTION("M9", 12, "L9", 1) - CONNECTION(CREDIT_1_OR_2, "F9", 9) + NET_C(L8.12, L8.11) // FIXME: not on schematic, on rollover load 16, keeps you from losing all credits + NET_C(P, L8.15) + NET_C(P, L8.1) + NET_C(P, L8.10) + NET_C(P, L8.9) + NET_C(E7.10, L8.5) + NET_C(H7.3, L8.4) - //PLGM2_n - CONNECTION(CR_START1_n, "F7", 6) - CONNECTION(CR_START2_n, "F7", 5) + NET_C(LAT_Q, L9.10) + NET_C(L8.13, L9.9) + NET_C(L9.8, L8.14) + NET_C(L8.7, M8.9) + NET_C(L8.6, M8.10) + NET_C(L8.2, M8.11) + NET_C(L8.3, M9.13) - //PLAY_CP - CONNECTION(PLGM2_n, "F2", 5) - CONNECTION(PLAYER_2, "F2", 4) - CONNECTION(H1, "F2", 3) + NET_C(CREDIT2_n, F9.5) + NET_C(CREDIT2_n, L9.2) + NET_C(M9.12, L9.1) + NET_C(CREDIT_1_OR_2, F9.9) - CONNECTION(P, "F5", 4) - CONNECTION(P, "F5", 2) - CONNECTION(SERVE_WAIT, "F5", 3) - CONNECTION(H128, "F5", 1) - CONNECTION("F2", 6, "D2", 9) - CONNECTION("F5", 5, "D2", 10) + NET_C(CR_START1_n, F7.6) + NET_C(CR_START2_n, F7.5) - //EGL - CONNECTION(P, "B4", 10) - CONNECTION(P, "B4", 7) - CONNECTION(P, "B4", 9) - CONNECTION(PLAY_CP, "B4", 2) + NET_C(PLGM2_n, F2.5) + NET_C(PLAYER_2, F2.4) + NET_C(H1, F2.3) - CONNECTION(EGL, "C5", 1) + NET_C(P, F5.4) + NET_C(P, F5.2) + NET_C(SERVE_WAIT, F5.3) + NET_C(H128, F5.1) + NET_C(F2.6, D2.9) + NET_C(F5.5, D2.10) + NET_C(P, B4.10) + NET_C(P, B4.7) + NET_C(P, B4.9) + NET_C(PLAY_CP, B4.2) + NET_C(EGL, C5.1) - CONNECTION(START_GAME1_n, "B4", 1) - CONNECTION(BALL_A, "A4", 2) - CONNECTION(BALL_B, "S4", 1) // Three balls - CONNECTION(BALL_C, "S4", 2) // Five balls - //CONNECTION("S4", 3, "A4", 1) + //---------------------------------------------------------------- + // Ball logic + //--------------------------------------------------------------- + + NET_C(START_GAME1_n, B4.1) + NET_C(BALL_A, A4.2) + NET_C(BALL_B, S4.1) // Three balls + NET_C(BALL_C, S4.2) // Five balls NET_C(S4.Q, A4.1) - CONNECTION("A4", 3, "C37", 1) + NET_C(A4.3, C37.1) - CONNECTION(SERVE_WAIT_n, "A4", 5) - CONNECTION(BALL, "A4", 4) + NET_C(SERVE_WAIT_n, A4.5) + NET_C(BALL, A4.4) - // Ball Circuit + //---------------------------------------------------------------- + // Video output logic + //--------------------------------------------------------------- + NET_C(V16_d, D2.4) + NET_C(V8_d, D2.5) + NET_C(D2.6, E3.8) + NET_C(VSYNC_n, E3.9) + NET_C(HSYNC_n, E2.12) + NET_C(E3.10, E2.13) + NET_C(PSYNC, B9.1) + NET_C(VSYNC_n, B9.2) - // Video Summing - CONNECTION(V16_d, "D2", 4) - CONNECTION(V8_d, "D2", 5) - CONNECTION("D2", 6, "E3", 8) - CONNECTION(VSYNC_n, "E3", 9) - CONNECTION(HSYNC_n, "E2", 12) - CONNECTION("E3", 10, "E2", 13) - CONNECTION(PSYNC, "B9", 1) - CONNECTION(VSYNC_n, "B9", 2) - - // VIDEO SUMMING RES(R41, RES_K(3.9)) RES(R42, RES_K(3.9)) RES(R43, RES_K(3.9)) RES(R51, RES_K(3.9)) RES(R52, RES_K(3.9)) -#if (0 && SLOW_BUT_ACCURATE) +#if (SLOW_BUT_ACCURATE) DIODE(CR6, "1N914") NET_C(E2.11, CR6.K) NET_C(CR6.A, R41.1, R42.1, R43.1, R51.1, R52.1) #else - //RES_SWITCH(CR6, E2.11, R41.1, GND) RES_SWITCH(CR6, E2.11, R41.1, GND) PARAM(CR6.RON, 1e20) PARAM(CR6.ROFF, 1) NET_C(R41.1, R42.1, R43.1, R51.1, R52.1) #endif - CONNECTION("R51", 2, PLAYFIELD) - CONNECTION("R43", 2, BSYNC) - CONNECTION("R52", 2, SCORE) + NET_C(R51.2, PLAYFIELD) + NET_C(R43.2, BSYNC) + NET_C(R52.2, SCORE) NET_C(R41.2, B9.3) NET_C(R42.2, V5) ALIAS(videomix, R41.1) - // Audio Summing + //---------------------------------------------------------------- + // Audio logic + //--------------------------------------------------------------- + RES(R36, RES_K(47)) RES(R37, RES_K(47)) RES(R38, RES_K(47)) RES(R39, RES_K(47)) - CONNECTION("R36", 2, "B9", 11) - CONNECTION("R38", 2, "B9", 8) - CONNECTION("R39", 2, FREE_GAME_TONE) - CONNECTION("R37", 2, "B9", 6) + NET_C(R36.2, B9.11) + NET_C(R38.2, B9.8) + NET_C(R39.2, FREE_GAME_TONE) + NET_C(R37.2, B9.6) NET_C(R36.1, R37.1, R38.1, R39.1) ALIAS(sound, R36.1) - // POTS - POT2(POTP1, RES_K(5)) // 5k - PARAM(POTP1.DIALLOG, 1) // Log Dial ... - PARAM(POTP1.REVERSE, 1) // Log Dial ... + //---------------------------------------------------------------- + // Potentiometer logic + //--------------------------------------------------------------- + + POT2(POTP1, RES_K(5)) // 5k + PARAM(POTP1.DIALLOG, 1) // Log Dial ... + PARAM(POTP1.REVERSE, 1) // Log Dial ... NET_C(POTP1.1, V5) - POT2(POTP2, RES_K(5)) // 5k - PARAM(POTP2.DIALLOG, 1) // Log Dial ... - PARAM(POTP2.REVERSE, 1) // Log Dial ... + POT2(POTP2, RES_K(5)) // 5k + PARAM(POTP2.DIALLOG, 1) // Log Dial ... + PARAM(POTP2.REVERSE, 1) // Log Dial ... NET_C(POTP2.1, V5) RES(R33, 47) @@ -1624,7 +1724,7 @@ CIRCUIT_LAYOUT( breakout ) NET_C(D9.7, GND) NET_C(D9.14, V5) - CONNECTION(P2_CONDITIONAL_dash, "D9", 6) + NET_C(P2_CONDITIONAL_dash, D9.6) NET_C(D9.12, E9.8) NET_C(D9.8, POTP2.2) // Connect P2 dial here NET_C(D9.11, POTP1.2) @@ -1641,7 +1741,7 @@ CIRCUIT_LAYOUT( breakout ) /* Below is the upright cabinet configuration * cocktail has two leds connected to R40.1 */ - CONNECTION(SERVE_WAIT_n, "R21", 2) + NET_C(SERVE_WAIT_n, R21.2) NET_C(R21.1, R40.2) NET_C(LED1.K, R40.1) NET_C(LED1.A, V5) @@ -1663,8 +1763,8 @@ CIRCUIT_LAYOUT( breakout ) // Coin Counter //---------------------------------------------------------------- - CONNECTION(CSW1, "E2", 1) - CONNECTION(CSW2, "E2", 2) + NET_C(CSW1, E2.1) + NET_C(CSW2, E2.2) RES(R14, 150) QBJT_SW(Q6, "2N5190") DIODE(CR8, "1N4001") @@ -1732,7 +1832,6 @@ CIRCUIT_LAYOUT( breakout ) NET_C(GND, F1.8) #endif -#if 1 // 163% -- manually optimized HINT(B6.C, NO_DEACTIVATE) HINT(C4.C, NO_DEACTIVATE) @@ -1746,11 +1845,7 @@ CIRCUIT_LAYOUT( breakout ) HINT(H2.A, NO_DEACTIVATE) HINT(H3.A, NO_DEACTIVATE) HINT(J3.D, NO_DEACTIVATE) -#if (USE_TRUTHTABLE_7448) - HINT(J5.s, NO_DEACTIVATE) // 7448 needs to be disabled in all cases -#else - HINT(J5, NO_DEACTIVATE) // 7448 needs to be disabled in all cases -#endif + HINT(J5, NO_DEACTIVATE) // 7448 needs to be disabled in all cases HINT(J6, NO_DEACTIVATE) HINT(J8.A, NO_DEACTIVATE) HINT(J8.C, NO_DEACTIVATE) @@ -1762,44 +1857,8 @@ CIRCUIT_LAYOUT( breakout ) HINT(M8.A, NO_DEACTIVATE) HINT(N7.C, NO_DEACTIVATE) -#else - // 167% hints provided by log output - manually optimized - HINT(M4.B, NO_DEACTIVATE) // 29.001761 197676 6816 - HINT(M3.C, NO_DEACTIVATE) // inf 129571 0 - HINT(N7.C, NO_DEACTIVATE) // inf 7850387 0 xx - HINT(M3.B, NO_DEACTIVATE) // 23.234535 395870 17038 - HINT(M3.A, NO_DEACTIVATE) // 14.500880 197676 13632 - HINT(L7.C, NO_DEACTIVATE) // 122672.000000 122672 1 - HINT(L7.B, NO_DEACTIVATE) // 122672.000000 122672 1 - HINT(K7.D, NO_DEACTIVATE) // 122673.000000 122673 1 - HINT(K7.C, NO_DEACTIVATE) // 122672.000000 122672 1 - HINT(K7.B, NO_DEACTIVATE) // 122673.000000 122673 1 - HINT(K7.A, NO_DEACTIVATE) // 122673.000000 122673 1 - HINT(K4.D, NO_DEACTIVATE) // 1438.774735 4202661 2921 xx - HINT(K4.B, NO_DEACTIVATE) // 3.939380 847790 215209 xx - HINT(E2.B, NO_DEACTIVATE) // 108.050000 315506 2920 xx - HINT(L7.D, NO_DEACTIVATE) // 122672.000000 122672 1 - HINT(E9.F, NO_DEACTIVATE) // inf 129571 0 - //HINT(J2.F, NO_DEACTIVATE) // 493.408951 959187 1944 - HINT(C5.C, NO_DEACTIVATE) // inf 195514 0 - HINT(M3.D, NO_DEACTIVATE) // 27.744898 418726 15092 xx - HINT(J8.A, NO_DEACTIVATE) // 40890.000000 122670 3 - HINT(E3.B, NO_DEACTIVATE) // 203581.000000 203581 1 - HINT(M9.D, NO_DEACTIVATE) // inf 323268 0 - //HINT(L4.B, NO_DEACTIVATE) // 7.290053 1192536 163584 - HINT(J3.D, NO_DEACTIVATE) // 393.639951 957726 2433 xx - HINT(L7.A, NO_DEACTIVATE) // inf 122672 0 - HINT(F2.A, NO_DEACTIVATE) // 286289.000000 286289 1 - HINT(M8.A, NO_DEACTIVATE) // 129571.000000 129571 1 - HINT(J7.B, NO_DEACTIVATE) // inf 122672 0 - //HINT(H2.A, NO_DEACTIVATE) // 393.839704 958212 2433 - HINT(H3.A, NO_DEACTIVATE) // 3.932473 850122 216180 xx - HINT(J2.E, NO_DEACTIVATE) // 26.140344 203581 7788 - HINT(J7.A, NO_DEACTIVATE) // inf 122672 0 - HINT(J8.C, NO_DEACTIVATE) // 40890.000000 122670 3 -#endif -CIRCUIT_LAYOUT_END +NETLIST_END() /* * MCR106-2 model from http://www.duncanamps.com/