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

All netlist devices now follow new syntax. Removed dead code. All sub

Browse Source 
devices are now forced to be initialized in the constructor. Device
setup now completely in constructor. Removed start call. [Couriersud]
This commit is contained in:
couriersud 2016-05-17 00:49:38 +02:00
parent 9102271ef7
commit fdf63818de
71 changed files with 1965 additions and 2155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/devices/machine/netlist.cpp
View File

@ -383,8 +383,8 @@ void netlist_mame_device_t::device_timer(emu_timer &timer, device_timer_id id, i
ATTR_HOT ATTR_ALIGN void netlist_mame_device_t::update_time_x()
{
const netlist::netlist_time newt = netlist().time();
const netlist::netlist_time delta = newt - m_old + m_rem;
const netlist::netlist_time newt(netlist().time());
const netlist::netlist_time delta(newt - m_old + m_rem);
const UINT64 d = delta / m_div;
m_old = newt;
m_rem = delta - (m_div * d);
@ -629,7 +629,7 @@ void netlist_mame_sound_device_t::sound_stream_update(sound_stream &stream, stre
m_in->m_buffer[i] = inputs[i];
}
netlist::netlist_time cur = netlist().time();
netlist::netlist_time cur(netlist().time());
netlist().process_queue(m_div * samples);

34
src/devices/machine/netlist.h
View File

@ -121,7 +121,7 @@ public:
ATTR_HOT inline netlist::setup_t &setup() { return *m_setup; }
ATTR_HOT inline netlist_mame_t &netlist() { return *m_netlist; }
ATTR_HOT inline netlist::netlist_time last_time_update() { return m_old; }
ATTR_HOT inline const netlist::netlist_time last_time_update() { return m_old; }
ATTR_HOT void update_time_x();
ATTR_HOT void check_mame_abort_slice();
@ -504,9 +504,7 @@ class NETLIB_NAME(analog_callback) : public netlist::device_t
{
public:
NETLIB_NAME(analog_callback)(netlist::netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name), m_cpu_device(nullptr), m_last(0) { }
ATTR_COLD void start() override
: device_t(anetlist, name), m_cpu_device(nullptr), m_last(0)
{
enregister("IN", m_in);
m_cpu_device = downcast<netlist_mame_cpu_device_t *>(&downcast<netlist_mame_t &>(netlist()).parent());
@ -523,7 +521,7 @@ public:
m_callback = callback;
}
ATTR_HOT void update() override
NETLIB_UPDATEI()
{
nl_double cur = INPANALOG(m_in);
@ -553,11 +551,7 @@ class NETLIB_NAME(sound_out) : public netlist::device_t
{
public:
NETLIB_NAME(sound_out)(netlist::netlist_t &anetlist, const pstring &name)
: netlist::device_t(anetlist, name) { }
static const int BUFSIZE = 2048;
ATTR_COLD void start() override
: netlist::device_t(anetlist, name)
{
enregister("IN", m_in);
register_param("CHAN", m_channel, 0);
@ -567,6 +561,8 @@ public:
save(NAME(m_last_buffer));
}
static const int BUFSIZE = 2048;
ATTR_COLD void reset() override
{
m_cur = 0.0;
@ -574,7 +570,7 @@ public:
m_last_buffer = netlist::netlist_time::zero;
}
ATTR_HOT void sound_update(const netlist::netlist_time upto)
ATTR_HOT void sound_update(const netlist::netlist_time &upto)
{
int pos = (upto - m_last_buffer) / m_sample;
if (pos >= BUFSIZE)
@ -585,7 +581,7 @@ public:
}
}
ATTR_HOT void update() override
NETLIB_UPDATEI()
{
nl_double val = INPANALOG(m_in) * m_mult.Value() + m_offset.Value();
sound_update(netlist().time());
@ -599,7 +595,8 @@ public:
}
ATTR_HOT void buffer_reset(netlist::netlist_time upto)
public:
ATTR_HOT void buffer_reset(const netlist::netlist_time &upto)
{
m_last_pos = 0;
m_last_buffer = upto;
@ -627,11 +624,7 @@ class NETLIB_NAME(sound_in) : public netlist::device_t
{
public:
NETLIB_NAME(sound_in)(netlist::netlist_t &anetlist, const pstring &name)
: netlist::device_t(anetlist, name) { }
static const int MAX_INPUT_CHANNELS = 10;
ATTR_COLD void start() override
: netlist::device_t(anetlist, name)
{
// clock part
enregister("Q", m_Q);
@ -650,6 +643,8 @@ public:
m_num_channel = 0;
}
static const int MAX_INPUT_CHANNELS = 10;
ATTR_COLD void reset() override
{
m_pos = 0;
@ -673,7 +668,7 @@ public:
return m_num_channel;
}
ATTR_HOT void update() override
NETLIB_UPDATEI()
{
for (int i=0; i<m_num_channel; i++)
{
@ -686,6 +681,7 @@ public:
OUTLOGIC(m_Q, !m_Q.net().as_logic().new_Q(), m_inc );
}
public:
ATTR_HOT void buffer_reset()
{
m_pos = 0;

50
src/lib/netlist/analog/nld_bjt.cpp
View File

@ -44,15 +44,6 @@ private:
// nld_Q
// ----------------------------------------------------------------------------------------
NETLIB_START(Q)
{
register_param("MODEL", m_model, "");
}
NETLIB_RESET(Q)
{
}
NETLIB_UPDATE(Q)
{
// netlist().solver()->schedule1();
@ -62,26 +53,6 @@ NETLIB_UPDATE(Q)
// nld_QBJT_switch
// ----------------------------------------------------------------------------------------
NETLIB_START(QBJT_switch)
{
NETLIB_NAME(Q)::start();
enregister("B", m_RB.m_P);
enregister("E", m_RB.m_N);
enregister("C", m_RC.m_P);
enregister("_E1", m_RC.m_N);
enregister("_B1", m_BC_dummy.m_P);
enregister("_C1", m_BC_dummy.m_N);
connect_late(m_RB.m_N, m_RC.m_N);
connect_late(m_RB.m_P, m_BC_dummy.m_P);
connect_late(m_RC.m_P, m_BC_dummy.m_N);
save(NLNAME(m_state_on));
}
NETLIB_RESET(QBJT_switch)
{
@ -160,27 +131,6 @@ NETLIB_UPDATE_TERMINALS(QBJT_switch)
// nld_Q - Ebers Moll
// ----------------------------------------------------------------------------------------
NETLIB_START(QBJT_EB)
{
NETLIB_NAME(Q)::start();
enregister("E", m_D_EB.m_P); // Cathode
enregister("B", m_D_EB.m_N); // Anode
enregister("C", m_D_CB.m_P); // Cathode
enregister("_B1", m_D_CB.m_N); // Anode
enregister("_E1", m_D_EC.m_P);
enregister("_C1", m_D_EC.m_N);
connect_late(m_D_EB.m_P, m_D_EC.m_P);
connect_late(m_D_EB.m_N, m_D_CB.m_N);
connect_late(m_D_CB.m_P, m_D_EC.m_N);
m_gD_BE.save("m_D_BE", *this);
m_gD_BC.save("m_D_BC", *this);
}
NETLIB_UPDATE(QBJT_EB)
{

63
src/lib/netlist/analog/nld_bjt.h
View File

@ -42,17 +42,19 @@ public:
NETLIB_CONSTRUCTOR(Q)
, m_qtype(BJT_NPN)
{ }
{
register_param("MODEL", m_model, "");
}
NETLIB_DYNAMIC()
//NETLIB_RESETI();
NETLIB_UPDATEI();
inline q_type qtype() const { return m_qtype; }
inline bool is_qtype(q_type atype) const { return m_qtype == atype; }
inline void set_qtype(q_type atype) { m_qtype = atype; }
protected:
virtual void start() override;
virtual void reset() override;
ATTR_HOT void update() override;
param_model_t m_model;
private:
@ -93,7 +95,6 @@ private:
NETLIB_OBJECT_DERIVED(QBJT_switch, QBJT)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(QBJT_switch, QBJT)
, m_RB(owner, "m_RB")
, m_RC(owner, "m_RC")
@ -101,9 +102,28 @@ public:
, m_gB(NETLIST_GMIN_DEFAULT)
, m_gC(NETLIST_GMIN_DEFAULT)
, m_V(0.0)
, m_state_on(0) { }
, m_state_on(0)
{
enregister("B", m_RB.m_P);
enregister("E", m_RB.m_N);
enregister("C", m_RC.m_P);
enregister("_E1", m_RC.m_N);
ATTR_HOT void virtual update() override;
enregister("_B1", m_BC_dummy.m_P);
enregister("_C1", m_BC_dummy.m_N);
connect_late(m_RB.m_N, m_RC.m_N);
connect_late(m_RB.m_P, m_BC_dummy.m_P);
connect_late(m_RC.m_P, m_BC_dummy.m_N);
save(NLNAME(m_state_on));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
NETLIB_UPDATE_PARAMI();
NETLIB_UPDATE_TERMINALSI();
nld_twoterm m_RB;
nld_twoterm m_RC;
@ -114,10 +134,6 @@ public:
protected:
virtual void start() override;
ATTR_HOT virtual void update_param() override;
virtual void reset() override;
NETLIB_UPDATE_TERMINALSI();
nl_double m_gB; // base conductance / switch on
nl_double m_gC; // collector conductance / switch on
@ -141,14 +157,29 @@ public:
, m_D_EC(owner, "m_D_EC")
, m_alpha_f(0)
, m_alpha_r(0)
{ }
{
enregister("E", m_D_EB.m_P); // Cathode
enregister("B", m_D_EB.m_N); // Anode
enregister("C", m_D_CB.m_P); // Cathode
enregister("_B1", m_D_CB.m_N); // Anode
enregister("_E1", m_D_EC.m_P);
enregister("_C1", m_D_EC.m_N);
connect_late(m_D_EB.m_P, m_D_EC.m_P);
connect_late(m_D_EB.m_N, m_D_CB.m_N);
connect_late(m_D_CB.m_P, m_D_EC.m_N);
m_gD_BE.save("m_D_BE", *this);
m_gD_BC.save("m_D_BC", *this);
}
protected:
virtual void start() override;
virtual void reset() override;
ATTR_HOT void update_param() override;
ATTR_HOT void virtual update() override;
NETLIB_RESETI();
NETLIB_UPDATEI();
NETLIB_UPDATE_PARAMI();
NETLIB_UPDATE_TERMINALSI();
generic_diode m_gD_BC;

32
src/lib/netlist/analog/nld_fourterm.cpp
View File

@ -73,12 +73,6 @@ NETLIB_UPDATE(VCCS)
// nld_LVCCS
// ----------------------------------------------------------------------------------------
NETLIB_START(LVCCS)
{
NETLIB_NAME(VCCS)::start();
register_param("CURLIM", m_cur_limit, 1000.0);
}
NETLIB_RESET(LVCCS)
{
NETLIB_NAME(VCCS)::reset();
@ -121,12 +115,6 @@ NETLIB_UPDATE_TERMINALS(LVCCS)
// nld_CCCS
// ----------------------------------------------------------------------------------------
NETLIB_START(CCCS)
{
start_internal(1.0);
m_gfac = NL_FCONST(1.0) / m_RI.Value();
}
NETLIB_RESET(CCCS)
{
NETLIB_NAME(VCCS)::reset();
@ -146,22 +134,6 @@ NETLIB_UPDATE(CCCS)
// nld_VCVS
// ----------------------------------------------------------------------------------------
NETLIB_START(VCVS)
{
NETLIB_NAME(VCCS)::start();
register_param("RO", m_RO, 1.0);
enregister("_OP2", m_OP2);
enregister("_ON2", m_ON2);
m_OP2.m_otherterm = &m_ON2;
m_ON2.m_otherterm = &m_OP2;
connect_late(m_OP2, m_OP1);
connect_late(m_ON2, m_ON1);
}
NETLIB_RESET(VCVS)
{
m_gfac = NL_FCONST(1.0) / m_RO.Value();
@ -171,8 +143,4 @@ NETLIB_RESET(VCVS)
m_ON2.set(NL_FCONST(1.0) / m_RO.Value());
}
NETLIB_UPDATE_PARAM(VCVS)
{
}
NETLIB_NAMESPACE_DEVICES_END()

43
src/lib/netlist/analog/nld_fourterm.h
View File

@ -93,17 +93,18 @@ NETLIB_OBJECT_DERIVED(LVCCS, VCCS)
public:
NETLIB_CONSTRUCTOR_DERIVED(LVCCS, VCCS)
, m_vi(0.0)
{ }
{
register_param("CURLIM", m_cur_limit, 1000.0);
}
NETLIB_DYNAMIC()
param_double_t m_cur_limit; /* current limit */
protected:
virtual void start() override;
virtual void reset() override;
virtual void update_param() override;
ATTR_HOT virtual void update() override;
NETLIB_UPDATEI();
NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
NETLIB_UPDATE_TERMINALSI();
nl_double m_vi;
@ -137,13 +138,14 @@ NETLIB_OBJECT_DERIVED(CCCS, VCCS)
public:
NETLIB_CONSTRUCTOR_DERIVED(CCCS, VCCS)
, m_gfac(1.0)
{ }
{
m_gfac = NL_FCONST(1.0) / m_RI.Value();
}
protected:
virtual void start() override;
virtual void reset() override;
virtual void update_param() override;
ATTR_HOT void update() override;
NETLIB_UPDATEI();
NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
nl_double m_gfac;
};
@ -180,15 +182,26 @@ protected:
NETLIB_OBJECT_DERIVED(VCVS, VCCS)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(VCVS, VCCS) { }
NETLIB_CONSTRUCTOR_DERIVED(VCVS, VCCS)
{
register_param("RO", m_RO, 1.0);
enregister("_OP2", m_OP2);
enregister("_ON2", m_ON2);
m_OP2.m_otherterm = &m_ON2;
m_ON2.m_otherterm = &m_OP2;
connect_late(m_OP2, m_OP1);
connect_late(m_ON2, m_ON1);
}
param_double_t m_RO;
protected:
virtual void start() override;
virtual void reset() override;
virtual void update_param() override;
//ATTR_HOT void update();
//NETLIB_UPDATEI();
NETLIB_RESETI();
//NETLIB_UPDATE_PARAMI();
terminal_t m_OP2;
terminal_t m_ON2;

5
src/lib/netlist/analog/nld_switches.cpp
View File

@ -19,8 +19,6 @@ NETLIB_NAMESPACE_DEVICES_START()
NETLIB_RESET(switch1)
{
m_R.do_reset();
m_R.set_R(R_OFF);
}
@ -50,9 +48,6 @@ NETLIB_UPDATE_PARAM(switch1)
NETLIB_RESET(switch2)
{
m_R1.do_reset();
m_R2.do_reset();
m_R1.set_R(R_ON);
m_R2.set_R(R_OFF);
}

83
src/lib/netlist/analog/nld_twoterm.cpp
View File

@ -48,22 +48,17 @@ ATTR_COLD void generic_diode::save(pstring name, object_t &parent)
// nld_twoterm
// ----------------------------------------------------------------------------------------
NETLIB_START(twoterm)
{
}
NETLIB_RESET(twoterm)
{
}
NETLIB_UPDATE(twoterm)
{
/* FIXME: some proxies created seem to be disconnected again
* or not even properly connected.
* Example: pong proxy_da_c9c.Q_1.RV
*/
/* only called if connected to a rail net ==> notify the solver to recalculate */
/* we only need to call the non-rail terminal */
if (!m_P.net().isRailNet())
if (m_P.has_net() && !m_P.net().isRailNet())
m_P.schedule_solve();
else
else if (m_N.has_net() && !m_N.net().isRailNet())
m_N.schedule_solve();
}
@ -71,18 +66,6 @@ NETLIB_UPDATE(twoterm)
// nld_POT
// ----------------------------------------------------------------------------------------
NETLIB_RESET(POT)
{
m_R1.do_reset();
m_R2.do_reset();
}
NETLIB_UPDATE(POT)
{
m_R1.update_dev();
m_R2.update_dev();
}
NETLIB_UPDATE_PARAM(POT)
{
nl_double v = m_Dial.Value();
@ -101,16 +84,6 @@ NETLIB_UPDATE_PARAM(POT)
// nld_POT2
// ----------------------------------------------------------------------------------------
NETLIB_RESET(POT2)
{
m_R1.do_reset();
}
NETLIB_UPDATE(POT2)
{
m_R1.update_dev();
}
NETLIB_UPDATE_PARAM(POT2)
{
nl_double v = m_Dial.Value();
@ -129,18 +102,6 @@ NETLIB_UPDATE_PARAM(POT2)
// nld_C
// ----------------------------------------------------------------------------------------
NETLIB_START(C)
{
enregister("1", m_P);
enregister("2", m_N);
register_param("C", m_C, 1e-6);
// set up the element
//set(netlist().gmin(), 0.0, -5.0 / netlist().gmin());
//set(1.0/NETLIST_GMIN, 0.0, -5.0 * NETLIST_GMIN);
}
NETLIB_RESET(C)
{
set(netlist().gmin(), 0.0, -5.0 / netlist().gmin());
@ -162,17 +123,6 @@ NETLIB_UPDATE(C)
// nld_D
// ----------------------------------------------------------------------------------------
NETLIB_START(D)
{
enregister("A", m_P);
enregister("K", m_N);
register_param("MODEL", m_model, "");
m_D.save("m_D", *this);
}
NETLIB_UPDATE_PARAM(D)
{
nl_double Is = m_model.model_value("IS");
@ -196,17 +146,6 @@ NETLIB_UPDATE_TERMINALS(D)
// nld_VS
// ----------------------------------------------------------------------------------------
NETLIB_START(VS)
{
NETLIB_NAME(twoterm)::start();
register_param("R", m_R, 0.1);
register_param("V", m_V, 0.0);
enregister("P", m_P);
enregister("N", m_N);
}
NETLIB_RESET(VS)
{
NETLIB_NAME(twoterm)::reset();
@ -222,16 +161,6 @@ NETLIB_UPDATE(VS)
// nld_CS
// ----------------------------------------------------------------------------------------
NETLIB_START(CS)
{
NETLIB_NAME(twoterm)::start();
register_param("I", m_I, 1.0);
enregister("P", m_P);
enregister("N", m_N);
}
NETLIB_RESET(CS)
{
NETLIB_NAME(twoterm)::reset();

81
src/lib/netlist/analog/nld_twoterm.h
View File

@ -112,10 +112,11 @@ public:
terminal_t m_P;
terminal_t m_N;
NETLIB_UPDATE_TERMINALSI()
{
}
NETLIB_UPDATE_TERMINALSI() { }
NETLIB_RESETI() { }
NETLIB_UPDATEI();
public:
ATTR_HOT /* inline */ void set(const nl_double G, const nl_double V, const nl_double I)
{
/* GO, GT, I */
@ -135,15 +136,9 @@ public:
m_N.set(-a21, a22, -r2);
}
protected:
ATTR_HOT virtual void start() override;
ATTR_HOT virtual void reset() override;
ATTR_HOT void update() override;
private:
};
// -----------------------------------------------------------------------------
// nld_R
// -----------------------------------------------------------------------------
@ -188,8 +183,8 @@ NETLIB_OBJECT_DERIVED(R, R_base)
protected:
NETLIB_RESETI() { NETLIB_NAME(R_base)::reset(); }
NETLIB_UPDATEI() { NETLIB_NAME(twoterm)::update(); }
//NETLIB_RESETI() { }
//NETLIB_UPDATEI() { }
NETLIB_UPDATE_PARAMI()
{
update_dev();
@ -222,8 +217,8 @@ NETLIB_OBJECT(POT)
register_param("DIALLOG", m_DialIsLog, 0);
}
NETLIB_UPDATEI();
NETLIB_RESETI();
//NETLIB_UPDATEI();
//NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
private:
@ -249,8 +244,8 @@ NETLIB_OBJECT(POT2)
register_param("DIALLOG", m_DialIsLog, 0);
}
NETLIB_UPDATEI();
NETLIB_RESETI();
//NETLIB_UPDATEI();
//NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
private:
@ -272,7 +267,13 @@ NETLIB_OBJECT_DERIVED(C, twoterm)
public:
NETLIB_CONSTRUCTOR_DERIVED(C, twoterm)
, m_GParallel(0.0)
{ }
{
enregister("1", m_P);
enregister("2", m_N);
register_param("C", m_C, 1e-6);
}
NETLIB_TIMESTEP()
{
@ -286,10 +287,9 @@ public:
param_double_t m_C;
protected:
virtual void start() override;
virtual void reset() override;
virtual void update_param() override;
ATTR_HOT void update() override;
NETLIB_RESETI();
NETLIB_UPDATEI();
NETLIB_UPDATE_PARAMI();
private:
nl_double m_GParallel;
@ -377,7 +377,13 @@ NETLIB_OBJECT_DERIVED(D, twoterm)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(D, twoterm)
{ }
{
enregister("A", m_P);
enregister("K", m_N);
register_param("MODEL", m_model, "");
m_D.save("m_D", *this);
}
NETLIB_DYNAMIC()
@ -386,9 +392,9 @@ public:
param_model_t m_model;
protected:
virtual void start() override;
virtual void update_param() override;
ATTR_HOT void update() override;
//NETLIB_RESETI();
NETLIB_UPDATEI();
NETLIB_UPDATE_PARAMI();
generic_diode m_D;
};
@ -403,12 +409,18 @@ protected:
NETLIB_OBJECT_DERIVED(VS, twoterm)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(VS, twoterm) { }
NETLIB_CONSTRUCTOR_DERIVED(VS, twoterm)
{
register_param("R", m_R, 0.1);
register_param("V", m_V, 0.0);
enregister("P", m_P);
enregister("N", m_N);
}
protected:
virtual void start() override;
virtual void reset() override;
ATTR_HOT void update() override;
NETLIB_UPDATEI();
NETLIB_RESETI();
param_double_t m_R;
param_double_t m_V;
@ -421,12 +433,17 @@ protected:
NETLIB_OBJECT_DERIVED(CS, twoterm)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(CS, twoterm) { }
NETLIB_CONSTRUCTOR_DERIVED(CS, twoterm)
{
register_param("I", m_I, 1.0);
enregister("P", m_P);
enregister("N", m_N);
}
NETLIB_UPDATEI();
NETLIB_RESETI();
protected:
virtual void start() override;
virtual void reset() override;
ATTR_HOT void update() override;
param_double_t m_I;
};

5
src/lib/netlist/devices/nld_4020.h
View File

@ -109,10 +109,7 @@ NETLIB_OBJECT(CD4020)
register_subalias("VDD", m_supply.m_vdd);
register_subalias("VSS", m_supply.m_vss);
}
NETLIB_RESETI()
{
m_sub.do_reset();
}
NETLIB_RESETI() { }
NETLIB_UPDATEI();
private:

5
src/lib/netlist/devices/nld_4066.h
View File

@ -43,10 +43,7 @@ NETLIB_OBJECT(CD4066_GATE)
enregister("CTL", m_control);
}
NETLIB_RESETI()
{
m_R.do_reset();
}
NETLIB_RESETI() { }
NETLIB_UPDATEI();
public:

101
src/lib/netlist/devices/nld_74107.cpp
View File

@ -9,17 +9,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(74107Asub)
{
enregister("CLK", m_clk);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
save(NLNAME(m_Q1));
save(NLNAME(m_Q2));
save(NLNAME(m_F));
}
NETLIB_RESET(74107Asub)
{
m_clk.set_state(logic_t::STATE_INP_HL);
@ -31,24 +20,6 @@ NETLIB_RESET(74107Asub)
m_F = 0;
}
NETLIB_START(74107A)
{
register_sub("sub", sub);
register_subalias("CLK", sub->m_clk);
enregister("J", m_J);
enregister("K", m_K);
enregister("CLRQ", m_clrQ);
register_subalias("Q", sub->m_Q);
register_subalias("QQ", sub->m_QQ);
}
NETLIB_RESET(74107A)
{
sub->reset();
}
ATTR_HOT inline void NETLIB_NAME(74107Asub)::newstate(const netlist_sig_t state)
{
const netlist_time delay[2] = { NLTIME_FROM_NS(25), NLTIME_FROM_NS(40) };
@ -72,25 +43,25 @@ NETLIB_UPDATE(74107A)
switch (JK)
{
case 0:
sub->m_Q1 = 0;
sub->m_Q2 = 1;
sub->m_F = 0;
sub->m_clk.inactivate();
m_sub.m_Q1 = 0;
m_sub.m_Q2 = 1;
m_sub.m_F = 0;
m_sub.m_clk.inactivate();
break;
case 1: // (!INPLOGIC(m_J) & INPLOGIC(m_K))
sub->m_Q1 = 0;
sub->m_Q2 = 0;
sub->m_F = 0;
m_sub.m_Q1 = 0;
m_sub.m_Q2 = 0;
m_sub.m_F = 0;
break;
case 2: // (INPLOGIC(m_J) & !INPLOGIC(m_K))
sub->m_Q1 = 0;
sub->m_Q2 = 0;
sub->m_F = 1;
m_sub.m_Q1 = 0;
m_sub.m_Q2 = 0;
m_sub.m_F = 1;
break;
case 3: // (INPLOGIC(m_J) & INPLOGIC(m_K))
sub->m_Q1 = 1;
sub->m_Q2 = 0;
sub->m_F = 0;
m_sub.m_Q1 = 1;
m_sub.m_Q2 = 0;
m_sub.m_F = 0;
break;
default:
break;
@ -98,50 +69,12 @@ NETLIB_UPDATE(74107A)
if (!INPLOGIC(m_clrQ))
{
sub->m_clk.inactivate();
sub->newstate(0);
m_sub.m_clk.inactivate();
m_sub.newstate(0);
}
else if (!sub->m_Q2)
sub->m_clk.activate_hl();
else if (!m_sub.m_Q2)
m_sub.m_clk.activate_hl();
}
NETLIB_START(74107_dip)
{
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1->m_J);
register_subalias("2", m_1->sub->m_QQ);
register_subalias("3", m_1->sub->m_Q);
register_subalias("4", m_1->m_K);
register_subalias("5", m_2->sub->m_Q);
register_subalias("6", m_2->sub->m_QQ);
// register_subalias("7", ); ==> GND
register_subalias("8", m_2->m_J);
register_subalias("9", m_2->sub->m_clk);
register_subalias("10", m_2->m_clrQ);
register_subalias("11", m_2->m_K);
register_subalias("12", m_1->sub->m_clk);
register_subalias("13", m_1->m_clrQ);
// register_subalias("14", ); ==> VCC
}
NETLIB_RESET(74107_dip)
{
m_1->do_reset();
m_2->do_reset();
}
NETLIB_UPDATE(74107_dip)
{
/* only called during startup */
m_1->update_dev();
m_2->update_dev();
}
NETLIB_NAMESPACE_DEVICES_END()

83
src/lib/netlist/devices/nld_74107.h
View File

@ -76,7 +76,27 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74107Asub,
NETLIB_OBJECT(74107Asub)
{
NETLIB_CONSTRUCTOR(74107Asub)
, m_Q1(0)
, m_Q2(0)
, m_F(0)
{
enregister("CLK", m_clk);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
save(NLNAME(m_Q1));
save(NLNAME(m_Q2));
save(NLNAME(m_F));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
logic_input_t m_clk;
logic_output_t m_Q;
@ -88,17 +108,32 @@ NETLIB_SUBDEVICE(74107Asub,
ATTR_HOT void newstate(const netlist_sig_t state);
);
};
NETLIB_DEVICE(74107A,
NETLIB_OBJECT(74107A)
{
NETLIB_CONSTRUCTOR(74107A)
, m_sub(*this, "sub")
{
register_subalias("CLK", m_sub.m_clk);
enregister("J", m_J);
enregister("K", m_K);
enregister("CLRQ", m_clrQ);
register_subalias("Q", m_sub.m_Q);
register_subalias("QQ", m_sub.m_QQ);
}
//NETLIB_RESETI();
NETLIB_UPDATEI();
public:
NETLIB_SUBXX(74107Asub) sub;
NETLIB_SUB(74107Asub) m_sub;
logic_input_t m_J;
logic_input_t m_K;
logic_input_t m_clrQ;
);
};
NETLIB_OBJECT_DERIVED(74107, 74107A)
{
@ -107,11 +142,41 @@ public:
};
NETLIB_DEVICE(74107_dip,
NETLIB_OBJECT(74107_dip)
{
NETLIB_CONSTRUCTOR(74107_dip)
, m_1(*this, "1")
, m_2(*this, "2")
{
NETLIB_SUBXX(74107) m_1;
NETLIB_SUBXX(74107) m_2;
);
register_subalias("1", m_1.m_J);
register_subalias("2", m_1.m_sub.m_QQ);
register_subalias("3", m_1.m_sub.m_Q);
register_subalias("4", m_1.m_K);
register_subalias("5", m_2.m_sub.m_Q);
register_subalias("6", m_2.m_sub.m_QQ);
// register_subalias("7", ); ==> GND
register_subalias("8", m_2.m_J);
register_subalias("9", m_2.m_sub.m_clk);
register_subalias("10", m_2.m_clrQ);
register_subalias("11", m_2.m_K);
register_subalias("12", m_1.m_sub.m_clk);
register_subalias("13", m_1.m_clrQ);
// register_subalias("14", ); ==> VCC
}
//NETLIB_RESETI();
//NETLIB_UPDATEI();
private:
NETLIB_SUB(74107) m_1;
NETLIB_SUB(74107) m_2;
};
NETLIB_NAMESPACE_DEVICES_END()

166
src/lib/netlist/devices/nld_74123.cpp
View File

@ -12,49 +12,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(74123)
{
if ((m_dev_type != 9602) && (m_dev_type != 4538) )
m_dev_type = 74123;
register_sub("RP", m_RP);
register_sub("RN", m_RN);
enregister("A", m_A);
enregister("B", m_B);
enregister("CLRQ", m_CLRQ);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
enregister("_RP_Q", m_RP_Q); // internal
enregister("_RN_Q", m_RN_Q); // internal
enregister("_CV", m_CV); // internal
register_subalias("GND", m_RN->m_R.m_N);
register_subalias("VCC", m_RP->m_R.m_P);
register_subalias("C", m_RN->m_R.m_N);
register_subalias("RC", m_RN->m_R.m_P);
if (m_dev_type == 4538)
register_param("K", m_K, 0.4);
else
register_param("K", m_K, 0.4);
register_param("RI", m_RI, 400.0); // around 250 for HC series, 400 on LS/TTL, estimated from datasheets
connect_late(m_RP_Q, m_RP->m_I);
connect_late(m_RN_Q, m_RN->m_I);
connect_late(m_RN->m_R.m_P, m_RP->m_R.m_N);
connect_late(m_CV, m_RN->m_R.m_P);
save(NLNAME(m_last_trig));
save(NLNAME(m_state));
save(NLNAME(m_KP));
}
NETLIB_UPDATE(74123)
{
netlist_sig_t m_trig;
@ -107,7 +64,7 @@ NETLIB_UPDATE(74123)
if (m_state == 1)
{
const nl_double vLow = m_KP * TERMANALOG(m_RP->m_R.m_P);
const nl_double vLow = m_KP * TERMANALOG(m_RP.m_R.m_P);
if (INPANALOG(m_CV) < vLow)
{
OUTLOGIC(m_RN_Q, 0, NLTIME_FROM_NS(10)); // R_OFF
@ -116,7 +73,7 @@ NETLIB_UPDATE(74123)
}
if (m_state == 2)
{
const nl_double vHigh = TERMANALOG(m_RP->m_R.m_P) * (1.0 - m_KP);
const nl_double vHigh = TERMANALOG(m_RP.m_R.m_P) * (1.0 - m_KP);
if (INPANALOG(m_CV) > vHigh)
{
OUTLOGIC(m_RP_Q, 0, NLTIME_FROM_NS(10)); // R_OFF
@ -132,140 +89,53 @@ NETLIB_RESET(74123)
{
m_KP = 1.0 / (1.0 + exp(m_K.Value()));
m_RP->do_reset();
m_RN->do_reset();
m_RP.do_reset();
m_RN.do_reset();
//m_RP->set_R(R_OFF);
//m_RN->set_R(R_OFF);
//m_RP.set_R(R_OFF);
//m_RN.set_R(R_OFF);
m_last_trig = 0;
m_state = 0;
}
NETLIB_START(74123_dip)
{
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1->m_A);
register_subalias("2", m_1->m_B);
register_subalias("3", m_1->m_CLRQ);
register_subalias("4", m_1->m_QQ);
register_subalias("5", m_2->m_Q);
register_subalias("6", m_2->m_RN->m_R.m_N);
register_subalias("7", m_2->m_RN->m_R.m_P);
register_subalias("8", m_1->m_RN->m_R.m_N);
connect_late(m_1->m_RN->m_R.m_N, m_2->m_RN->m_R.m_N);
register_subalias("9", m_2->m_A);
register_subalias("10", m_2->m_B);
register_subalias("11", m_2->m_CLRQ);
register_subalias("12", m_2->m_QQ);
register_subalias("13", m_1->m_Q);
register_subalias("14", m_1->m_RN->m_R.m_N);
register_subalias("15", m_1->m_RN->m_R.m_P);
register_subalias("16", m_1->m_RP->m_R.m_P);
connect_late(m_1->m_RP->m_R.m_P, m_2->m_RP->m_R.m_P);
}
NETLIB_UPDATE(74123_dip)
{
/* only called during startup */
m_1->update_dev();
m_2->update_dev();
//_1.update_dev();
//m_2.update_dev();
}
NETLIB_RESET(74123_dip)
{
m_1->do_reset();
m_2->do_reset();
}
NETLIB_START(9602_dip)
{
register_sub("1", m_1);
register_sub("2", m_2);
m_1->m_dev_type = 9602;
m_2->m_dev_type = 9602;
register_subalias("1", m_1->m_RN->m_R.m_N); // C1
register_subalias("2", m_1->m_RN->m_R.m_P); // RC1
register_subalias("3", m_1->m_CLRQ);
register_subalias("4", m_1->m_B);
register_subalias("5", m_1->m_A);
register_subalias("6", m_1->m_Q);
register_subalias("7", m_1->m_QQ);
register_subalias("8", m_1->m_RN->m_R.m_N);
connect_late(m_1->m_RN->m_R.m_N, m_2->m_RN->m_R.m_N);
register_subalias("9", m_2->m_QQ);
register_subalias("10", m_2->m_Q);
register_subalias("11", m_2->m_A);
register_subalias("12", m_2->m_B);
register_subalias("13", m_2->m_CLRQ);
register_subalias("14", m_2->m_RN->m_R.m_P); // RC2
register_subalias("15", m_2->m_RN->m_R.m_N); // C2
register_subalias("16", m_1->m_RP->m_R.m_P);
connect_late(m_1->m_RP->m_R.m_P, m_2->m_RP->m_R.m_P);
//m_1.do_reset();
//m_2.do_reset();
}
NETLIB_UPDATE(9602_dip)
{
/* only called during startup */
m_1->update_dev();
m_2->update_dev();
//m_1.update_dev();
//m_2.update_dev();
}
NETLIB_RESET(9602_dip)
{
m_1->do_reset();
m_2->do_reset();
}
NETLIB_START(4538_dip)
{
set_logic_family(family_CD4XXX());
register_sub("1", m_1);
register_sub("2", m_2);
m_1->m_dev_type = 4538;
m_2->m_dev_type = 4538;
register_subalias("1", m_1->m_RN->m_R.m_N); // C1
register_subalias("2", m_1->m_RN->m_R.m_P); // RC1
register_subalias("3", m_1->m_CLRQ);
register_subalias("4", m_1->m_A);
register_subalias("5", m_1->m_B);
register_subalias("6", m_1->m_Q);
register_subalias("7", m_1->m_QQ);
register_subalias("8", m_1->m_RN->m_R.m_N);
connect_late(m_1->m_RN->m_R.m_N, m_2->m_RN->m_R.m_N);
register_subalias("9", m_2->m_QQ);
register_subalias("10", m_2->m_Q);
register_subalias("11", m_2->m_B);
register_subalias("12", m_2->m_A);
register_subalias("13", m_2->m_CLRQ);
register_subalias("14", m_2->m_RN->m_R.m_P); // RC2
register_subalias("15", m_2->m_RN->m_R.m_N); // C2
register_subalias("16", m_1->m_RP->m_R.m_P);
connect_late(m_1->m_RP->m_R.m_P, m_2->m_RP->m_R.m_P);
//m_1.do_reset();
//m_2.do_reset();
}
NETLIB_UPDATE(4538_dip)
{
/* only called during startup */
m_1->update_dev();
m_2->update_dev();
//m_1.update_dev();
//m_2.update_dev();
}
NETLIB_RESET(4538_dip)
{
m_1->do_reset();
m_2->do_reset();
m_1.do_reset();
m_2.do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

167
src/lib/netlist/devices/nld_74123.h
View File

@ -58,10 +58,58 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(74123,
NETLIB_OBJECT(74123)
{
NETLIB_CONSTRUCTOR_EX(74123, int dev_type = 74123)
, m_dev_type(dev_type)
, m_RP(*this, "RP")
, m_RN(*this, "RN")
{
if ((m_dev_type != 9602) && (m_dev_type != 4538) )
m_dev_type = 74123;
enregister("A", m_A);
enregister("B", m_B);
enregister("CLRQ", m_CLRQ);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
enregister("_RP_Q", m_RP_Q); // internal
enregister("_RN_Q", m_RN_Q); // internal
enregister("_CV", m_CV); // internal
register_subalias("GND", m_RN.m_R.m_N);
register_subalias("VCC", m_RP.m_R.m_P);
register_subalias("C", m_RN.m_R.m_N);
register_subalias("RC", m_RN.m_R.m_P);
if (m_dev_type == 4538)
register_param("K", m_K, 0.4);
else
register_param("K", m_K, 0.4);
register_param("RI", m_RI, 400.0); // around 250 for HC series, 400 on LS/TTL, estimated from datasheets
connect_late(m_RP_Q, m_RP.m_I);
connect_late(m_RN_Q, m_RN.m_I);
connect_late(m_RN.m_R.m_P, m_RP.m_R.m_N);
connect_late(m_CV, m_RN.m_R.m_P);
save(NLNAME(m_last_trig));
save(NLNAME(m_state));
save(NLNAME(m_KP));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
private:
int m_dev_type;
public:
NETLIB_SUBXX(res_sw) m_RP;
NETLIB_SUBXX(res_sw) m_RN;
NETLIB_SUB(res_sw) m_RP;
NETLIB_SUB(res_sw) m_RN;
logic_output_t m_RP_Q;
logic_output_t m_RN_Q;
@ -80,19 +128,43 @@ public:
param_double_t m_K;
param_double_t m_RI;
int m_dev_type;
);
};
#define TTL_74123_DIP(_name) \
NET_REGISTER_DEV(TTL_74123_DIP, _name)
NETLIB_DEVICE(74123_dip,
NETLIB_OBJECT(74123_dip)
{
NETLIB_CONSTRUCTOR(74123_dip)
, m_1(*this, "1", 74123)
, m_2(*this, "2", 74123)
{
register_subalias("1", m_1.m_A);
register_subalias("2", m_1.m_B);
register_subalias("3", m_1.m_CLRQ);
register_subalias("4", m_1.m_QQ);
register_subalias("5", m_2.m_Q);
register_subalias("6", m_2.m_RN.m_R.m_N);
register_subalias("7", m_2.m_RN.m_R.m_P);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
NETLIB_SUBXX(74123) m_1;
NETLIB_SUBXX(74123) m_2;
);
register_subalias("9", m_2.m_A);
register_subalias("10", m_2.m_B);
register_subalias("11", m_2.m_CLRQ);
register_subalias("12", m_2.m_QQ);
register_subalias("13", m_1.m_Q);
register_subalias("14", m_1.m_RN.m_R.m_N);
register_subalias("15", m_1.m_RN.m_R.m_P);
register_subalias("16", m_1.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
private:
NETLIB_SUB(74123) m_1;
NETLIB_SUB(74123) m_2;
};
/* The 9602 is very similar to the 123. Input triggering is slightly different
* THe 9602 uses an OR gate instead of an AND gate.
@ -101,12 +173,38 @@ NETLIB_DEVICE(74123_dip,
#define TTL_9602_DIP(_name) \
NET_REGISTER_DEV(TTL_9602_DIP, _name)
NETLIB_DEVICE(9602_dip,
NETLIB_OBJECT(9602_dip)
{
NETLIB_CONSTRUCTOR(9602_dip)
, m_1(*this, "1", 9602)
, m_2(*this, "2", 9602)
{
register_subalias("1", m_1.m_RN.m_R.m_N); // C1
register_subalias("2", m_1.m_RN.m_R.m_P); // RC1
register_subalias("3", m_1.m_CLRQ);
register_subalias("4", m_1.m_B);
register_subalias("5", m_1.m_A);
register_subalias("6", m_1.m_Q);
register_subalias("7", m_1.m_QQ);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
NETLIB_SUBXX(74123) m_1;
NETLIB_SUBXX(74123) m_2;
);
register_subalias("9", m_2.m_QQ);
register_subalias("10", m_2.m_Q);
register_subalias("11", m_2.m_A);
register_subalias("12", m_2.m_B);
register_subalias("13", m_2.m_CLRQ);
register_subalias("14", m_2.m_RN.m_R.m_P); // RC2
register_subalias("15", m_2.m_RN.m_R.m_N); // C2
register_subalias("16", m_1.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
private:
NETLIB_SUB(74123) m_1;
NETLIB_SUB(74123) m_2;
};
/*
* The CD4538 is pretty similar to the 9602
@ -115,10 +213,39 @@ NETLIB_DEVICE(9602_dip,
#define CD4538_DIP(_name) \
NET_REGISTER_DEV(CD4538_DIP, _name)
NETLIB_DEVICE(4538_dip,
NETLIB_SUBXX(74123) m_1;
NETLIB_SUBXX(74123) m_2;
);
NETLIB_OBJECT(4538_dip)
{
NETLIB_CONSTRUCTOR(4538_dip)
NETLIB_FAMILY("CD4XXX")
, m_1(*this, "1", 4538)
, m_2(*this, "2", 4538)
{
register_subalias("1", m_1.m_RN.m_R.m_N); // C1
register_subalias("2", m_1.m_RN.m_R.m_P); // RC1
register_subalias("3", m_1.m_CLRQ);
register_subalias("4", m_1.m_A);
register_subalias("5", m_1.m_B);
register_subalias("6", m_1.m_Q);
register_subalias("7", m_1.m_QQ);
register_subalias("8", m_1.m_RN.m_R.m_N);
connect_late(m_1.m_RN.m_R.m_N, m_2.m_RN.m_R.m_N);
register_subalias("9", m_2.m_QQ);
register_subalias("10", m_2.m_Q);
register_subalias("11", m_2.m_B);
register_subalias("12", m_2.m_A);
register_subalias("13", m_2.m_CLRQ);
register_subalias("14", m_2.m_RN.m_R.m_P); // RC2
register_subalias("15", m_2.m_RN.m_R.m_N); // C2
register_subalias("16", m_1.m_RP.m_R.m_P);
connect_late(m_1.m_RP.m_R.m_P, m_2.m_RP.m_R.m_P);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
private:
NETLIB_SUB(74123) m_1;
NETLIB_SUB(74123) m_2;
};
NETLIB_NAMESPACE_DEVICES_END()

74
src/lib/netlist/devices/nld_74153.cpp
View File

@ -14,20 +14,6 @@ NETLIB_NAMESPACE_DEVICES_START()
* Convert this to sub-devices at some time.
*/
NETLIB_START(74153sub)
{
enregister("C0", m_C[0]);
enregister("C1", m_C[1]);
enregister("C2", m_C[2]);
enregister("C3", m_C[3]);
enregister("G", m_G);
enregister("AY", m_Y); //FIXME: Change netlists
m_chan = 0;
save(NLNAME(m_chan));
}
NETLIB_RESET(74153sub)
{
@ -49,68 +35,18 @@ NETLIB_UPDATE(74153sub)
}
NETLIB_START(74153)
{
register_sub("sub", m_sub);
register_subalias("C0", m_sub->m_C[0]);
register_subalias("C1", m_sub->m_C[1]);
register_subalias("C2", m_sub->m_C[2]);
register_subalias("C3", m_sub->m_C[3]);
enregister("A", m_A);
enregister("B", m_B);
register_subalias("G", m_sub->m_G);
register_subalias("AY", m_sub->m_Y); //FIXME: Change netlists
}
NETLIB_RESET(74153)
{
}
NETLIB_UPDATE(74153)
{
m_sub->m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_sub->update();
m_sub.m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_sub.do_update();
}
NETLIB_START(74153_dip)
{
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1->m_G);
enregister("2", m_B); // m_2->m_B
register_subalias("3", m_1->m_C[3]);
register_subalias("4", m_1->m_C[2]);
register_subalias("5", m_1->m_C[1]);
register_subalias("6", m_1->m_C[0]);
register_subalias("7", m_1->m_Y);
register_subalias("9", m_2->m_Y);
register_subalias("10", m_2->m_C[0]);
register_subalias("11", m_2->m_C[1]);
register_subalias("12", m_2->m_C[2]);
register_subalias("13", m_2->m_C[3]);
enregister("14", m_A); // m_2->m_B
register_subalias("15", m_2->m_G);
}
NETLIB_UPDATE(74153_dip)
{
m_2->m_chan = m_1->m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_1->update();
m_2->update();
}
NETLIB_RESET(74153_dip)
{
m_1->do_reset();
m_2->do_reset();
m_2.m_chan = m_1.m_chan = (INPLOGIC(m_A) | (INPLOGIC(m_B)<<1));
m_1.do_update();
m_2.do_update();
}
NETLIB_NAMESPACE_DEVICES_END()

81
src/lib/netlist/devices/nld_74153.h
View File

@ -62,29 +62,92 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74153sub,
NETLIB_OBJECT(74153sub)
{
NETLIB_CONSTRUCTOR(74153sub)
, m_chan(0)
{
enregister("C0", m_C[0]);
enregister("C1", m_C[1]);
enregister("C2", m_C[2]);
enregister("C3", m_C[3]);
enregister("G", m_G);
enregister("AY", m_Y); //FIXME: Change netlists
save(NLNAME(m_chan));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
logic_input_t m_C[4];
logic_input_t m_G;
logic_output_t m_Y;
int m_chan;
);
};
NETLIB_DEVICE(74153,
NETLIB_OBJECT(74153)
{
NETLIB_CONSTRUCTOR(74153)
, m_sub(*this, "sub")
{
register_subalias("C0", m_sub.m_C[0]);
register_subalias("C1", m_sub.m_C[1]);
register_subalias("C2", m_sub.m_C[2]);
register_subalias("C3", m_sub.m_C[3]);
enregister("A", m_A);
enregister("B", m_B);
register_subalias("G", m_sub.m_G);
register_subalias("AY", m_sub.m_Y); //FIXME: Change netlists
}
NETLIB_RESETI() { }
NETLIB_UPDATEI();
public:
NETLIB_SUBXX(74153sub) m_sub;
NETLIB_SUB(74153sub) m_sub;
logic_input_t m_A;
logic_input_t m_B;
);
};
NETLIB_DEVICE(74153_dip,
NETLIB_OBJECT(74153_dip)
{
NETLIB_CONSTRUCTOR(74153_dip)
, m_1(*this, "1")
, m_2(*this, "2")
{
NETLIB_SUBXX(74153sub) m_1;
NETLIB_SUBXX(74153sub) m_2;
register_subalias("1", m_1.m_G);
enregister("2", m_B); // m_2.m_B
register_subalias("3", m_1.m_C[3]);
register_subalias("4", m_1.m_C[2]);
register_subalias("5", m_1.m_C[1]);
register_subalias("6", m_1.m_C[0]);
register_subalias("7", m_1.m_Y);
register_subalias("9", m_2.m_Y);
register_subalias("10", m_2.m_C[0]);
register_subalias("11", m_2.m_C[1]);
register_subalias("12", m_2.m_C[2]);
register_subalias("13", m_2.m_C[3]);
enregister("14", m_A); // m_2.m_B
register_subalias("15", m_2.m_G);
}
//NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
NETLIB_SUB(74153sub) m_1;
NETLIB_SUB(74153sub) m_2;
logic_input_t m_A;
logic_input_t m_B;
);
};
NETLIB_NAMESPACE_DEVICES_END()

95
src/lib/netlist/devices/nld_74175.cpp
View File

@ -12,23 +12,6 @@ NETLIB_NAMESPACE_DEVICES_START()
static const netlist_time delay[2] = { NLTIME_FROM_NS(25), NLTIME_FROM_NS(25) };
static const netlist_time delay_clear[2] = { NLTIME_FROM_NS(40), NLTIME_FROM_NS(25) };
NETLIB_START(74175_sub)
{
enregister("CLK", m_CLK);
enregister("Q1", m_Q[0]);
enregister("Q1Q", m_QQ[0]);
enregister("Q2", m_Q[1]);
enregister("Q2Q", m_QQ[1]);
enregister("Q3", m_Q[2]);
enregister("Q3Q", m_QQ[2]);
enregister("Q4", m_Q[3]);
enregister("Q4Q", m_QQ[3]);
save(NLNAME(m_clrq));
save(NLNAME(m_data));
}
NETLIB_RESET(74175_sub)
{
m_CLK.set_state(logic_t::STATE_INP_LH);
@ -57,86 +40,26 @@ NETLIB_UPDATE(74175)
{
d |= (INPLOGIC(m_D[i]) << i);
}
m_sub->m_clrq = INPLOGIC(m_CLRQ);
if (!m_sub->m_clrq)
m_sub.m_clrq = INPLOGIC(m_CLRQ);
if (!m_sub.m_clrq)
{
for (int i=0; i<4; i++)
{
OUTLOGIC(m_sub->m_Q[i], 0, delay_clear[0]);
OUTLOGIC(m_sub->m_QQ[i], 1, delay_clear[1]);
OUTLOGIC(m_sub.m_Q[i], 0, delay_clear[0]);
OUTLOGIC(m_sub.m_QQ[i], 1, delay_clear[1]);
}
m_sub->m_data = 0;
} else if (d != m_sub->m_data)
m_sub.m_data = 0;
} else if (d != m_sub.m_data)
{
m_sub->m_data = d;
m_sub->m_CLK.activate_lh();
m_sub.m_data = d;
m_sub.m_CLK.activate_lh();
}
}
NETLIB_START(74175)
{
register_sub("sub", m_sub);
register_subalias("CLK", m_sub->m_CLK);
enregister("CLRQ", m_CLRQ);
enregister("D1", m_D[0]);
register_subalias("Q1", m_sub->m_Q[0]);
register_subalias("Q1Q", m_sub->m_QQ[0]);
enregister("D2", m_D[1]);
register_subalias("Q2", m_sub->m_Q[1]);
register_subalias("Q2Q", m_sub->m_QQ[1]);
enregister("D3", m_D[2]);
register_subalias("Q3", m_sub->m_Q[2]);
register_subalias("Q3Q", m_sub->m_QQ[2]);
enregister("D4", m_D[3]);
register_subalias("Q4", m_sub->m_Q[3]);
register_subalias("Q4Q", m_sub->m_QQ[3]);
}
NETLIB_RESET(74175)
{
m_sub->do_reset();
}
NETLIB_START(74175_dip)
{
register_sub("sub", m_sub);
register_subalias("9", m_sub->m_CLK);
enregister("1", m_CLRQ);
enregister("4", m_D[0]);
register_subalias("2", m_sub->m_Q[0]);
register_subalias("3", m_sub->m_QQ[0]);
enregister("5", m_D[1]);
register_subalias("7", m_sub->m_Q[1]);
register_subalias("6", m_sub->m_QQ[1]);
enregister("12", m_D[2]);
register_subalias("10", m_sub->m_Q[2]);
register_subalias("11", m_sub->m_QQ[2]);
enregister("13", m_D[3]);
register_subalias("15", m_sub->m_Q[3]);
register_subalias("14", m_sub->m_QQ[3]);
}
NETLIB_RESET(74175_dip)
{
NETLIB_NAME(74175)::reset();
}
NETLIB_UPDATE(74175_dip)
{
NETLIB_NAME(74175)::update();
//m_sub.do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

87
src/lib/netlist/devices/nld_74175.h
View File

@ -27,7 +27,7 @@
*
* Q0 The output logic level of Q before the indicated input conditions were established
*
* R: 0 --> 1
* R: 0 -> 1
*
* Naming conventions follow National Semiconductor datasheet
*
@ -45,24 +45,97 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(74175_sub,
NETLIB_OBJECT(74175_sub)
{
NETLIB_CONSTRUCTOR(74175_sub)
, m_data(0)
{
enregister("CLK", m_CLK);
enregister("Q1", m_Q[0]);
enregister("Q1Q", m_QQ[0]);
enregister("Q2", m_Q[1]);
enregister("Q2Q", m_QQ[1]);
enregister("Q3", m_Q[2]);
enregister("Q3Q", m_QQ[2]);
enregister("Q4", m_Q[3]);
enregister("Q4Q", m_QQ[3]);
save(NLNAME(m_clrq));
save(NLNAME(m_data));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
logic_input_t m_CLK;
logic_output_t m_Q[4];
logic_output_t m_QQ[4];
netlist_sig_t m_clrq;
UINT8 m_data;
);
};
NETLIB_DEVICE(74175,
NETLIB_OBJECT(74175)
{
NETLIB_CONSTRUCTOR(74175)
, m_sub(*this, "sub")
{
register_subalias("CLK", m_sub.m_CLK);
NETLIB_SUBXX(74175_sub) m_sub;
enregister("CLRQ", m_CLRQ);
enregister("D1", m_D[0]);
register_subalias("Q1", m_sub.m_Q[0]);
register_subalias("Q1Q", m_sub.m_QQ[0]);
enregister("D2", m_D[1]);
register_subalias("Q2", m_sub.m_Q[1]);
register_subalias("Q2Q", m_sub.m_QQ[1]);
enregister("D3", m_D[2]);
register_subalias("Q3", m_sub.m_Q[2]);
register_subalias("Q3Q", m_sub.m_QQ[2]);
enregister("D4", m_D[3]);
register_subalias("Q4", m_sub.m_Q[3]);
register_subalias("Q4Q", m_sub.m_QQ[3]);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
NETLIB_SUB(74175_sub) m_sub;
logic_input_t m_D[4];
logic_input_t m_CLRQ;
);
};
NETLIB_DEVICE_DERIVED_PURE(74175_dip, 74175);
NETLIB_OBJECT_DERIVED(74175_dip, 74175)
{
NETLIB_CONSTRUCTOR_DERIVED(74175_dip, 74175)
{
register_subalias("9", m_sub.m_CLK);
register_subalias("1", m_CLRQ);
register_subalias("4", m_D[0]);
register_subalias("2", m_sub.m_Q[0]);
register_subalias("3", m_sub.m_QQ[0]);
register_subalias("5", m_D[1]);
register_subalias("7", m_sub.m_Q[1]);
register_subalias("6", m_sub.m_QQ[1]);
register_subalias("12", m_D[2]);
register_subalias("10", m_sub.m_Q[2]);
register_subalias("11", m_sub.m_QQ[2]);
register_subalias("13", m_D[3]);
register_subalias("15", m_sub.m_Q[3]);
register_subalias("14", m_sub.m_QQ[3]);
}
};
NETLIB_NAMESPACE_DEVICES_END()

63
src/lib/netlist/devices/nld_74192.cpp
View File

@ -11,31 +11,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(74192)
{
register_sub("subABCD", m_ABCD);
register_subalias("A", m_ABCD->m_A);
register_subalias("B", m_ABCD->m_B);
register_subalias("C", m_ABCD->m_C);
register_subalias("D", m_ABCD->m_D);
enregister("CLEAR", m_CLEAR);
enregister("LOADQ", m_LOADQ);
enregister("CU", m_CU);
enregister("CD", m_CD);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
enregister("BORROWQ", m_BORROWQ);
enregister("CARRYQ", m_CARRYQ);
save(NLNAME(m_cnt));
save(NLNAME(m_last_CU));
save(NLNAME(m_last_CD));
}
NETLIB_RESET(74192)
{
m_cnt = 0;
@ -62,7 +37,7 @@ NETLIB_UPDATE(74192)
}
else if (!INPLOGIC(m_LOADQ))
{
m_cnt = m_ABCD->read_ABCD();
m_cnt = m_ABCD.read_ABCD();
}
else
{
@ -97,40 +72,4 @@ NETLIB_UPDATE(74192)
OUTLOGIC(m_CARRYQ, tCarry, NLTIME_FROM_NS(20)); //FIXME
}
NETLIB_FUNC_VOID(74192, update_outputs, (void))
{
}
NETLIB_START(74192_dip)
{
NETLIB_NAME(74192)::start();
register_subalias("1", m_ABCD->m_B);
register_subalias("2", m_Q[1]);
register_subalias("3", m_Q[0]);
register_subalias("4", m_CD);
register_subalias("5", m_CU);
register_subalias("6", m_Q[2]);
register_subalias("7", m_Q[3]);
register_subalias("9", m_ABCD->m_D);
register_subalias("10", m_ABCD->m_C);
register_subalias("11", m_LOADQ);
register_subalias("12", m_CARRYQ);
register_subalias("13", m_BORROWQ);
register_subalias("14", m_CLEAR);
register_subalias("15", m_ABCD->m_A);
}
NETLIB_UPDATE(74192_dip)
{
NETLIB_NAME(74192)::update();
}
NETLIB_RESET(74192_dip)
{
NETLIB_NAME(74192)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

57
src/lib/netlist/devices/nld_74192.h
View File

@ -40,10 +40,37 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(74192,
ATTR_HOT void update_outputs();
NETLIB_OBJECT(74192)
{
NETLIB_CONSTRUCTOR(74192)
, m_ABCD(*this, "subABCD")
{
register_subalias("A", m_ABCD.m_A);
register_subalias("B", m_ABCD.m_B);
register_subalias("C", m_ABCD.m_C);
register_subalias("D", m_ABCD.m_D);
enregister("CLEAR", m_CLEAR);
enregister("LOADQ", m_LOADQ);
enregister("CU", m_CU);
enregister("CD", m_CD);
NETLIB_SUBXX(9316_subABCD) m_ABCD;
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
enregister("BORROWQ", m_BORROWQ);
enregister("CARRYQ", m_CARRYQ);
save(NLNAME(m_cnt));
save(NLNAME(m_last_CU));
save(NLNAME(m_last_CD));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
NETLIB_SUB(9316_subABCD) m_ABCD;
logic_input_t m_CLEAR;
logic_input_t m_LOADQ;
logic_input_t m_CU;
@ -56,9 +83,29 @@ NETLIB_DEVICE(74192,
logic_output_t m_Q[4];
logic_output_t m_BORROWQ;
logic_output_t m_CARRYQ;
);
};
NETLIB_DEVICE_DERIVED_PURE(74192_dip, 74192);
NETLIB_OBJECT_DERIVED(74192_dip, 74192)
{
NETLIB_CONSTRUCTOR_DERIVED(74192_dip, 74192)
{
register_subalias("1", m_ABCD.m_B);
register_subalias("2", m_Q[1]);
register_subalias("3", m_Q[0]);
register_subalias("4", m_CD);
register_subalias("5", m_CU);
register_subalias("6", m_Q[2]);
register_subalias("7", m_Q[3]);
register_subalias("9", m_ABCD.m_D);
register_subalias("10", m_ABCD.m_C);
register_subalias("11", m_LOADQ);
register_subalias("12", m_CARRYQ);
register_subalias("13", m_BORROWQ);
register_subalias("14", m_CLEAR);
register_subalias("15", m_ABCD.m_A);
}
};
NETLIB_NAMESPACE_DEVICES_END()

59
src/lib/netlist/devices/nld_74193.cpp
View File

@ -11,30 +11,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(74193)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("CLEAR", m_CLEAR);
enregister("LOADQ", m_LOADQ);
enregister("CU", m_CU);
enregister("CD", m_CD);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
enregister("BORROWQ", m_BORROWQ);
enregister("CARRYQ", m_CARRYQ);
save(NLNAME(m_cnt));
save(NLNAME(m_last_CU));
save(NLNAME(m_last_CD));
}
NETLIB_RESET(74193)
{
m_cnt = 0;
@ -97,40 +73,5 @@ NETLIB_UPDATE(74193)
OUTLOGIC(m_CARRYQ, tCarry, NLTIME_FROM_NS(20)); //FIXME
}
NETLIB_FUNC_VOID(74193, update_outputs, (void))
{
}
NETLIB_START(74193_dip)
{
NETLIB_NAME(74193)::start();
register_subalias("1", m_B);
register_subalias("2", m_Q[1]);
register_subalias("3", m_Q[0]);
register_subalias("4", m_CD);
register_subalias("5", m_CU);
register_subalias("6", m_Q[2]);
register_subalias("7", m_Q[3]);
register_subalias("9", m_D);
register_subalias("10", m_C);
register_subalias("11", m_LOADQ);
register_subalias("12", m_CARRYQ);
register_subalias("13", m_BORROWQ);
register_subalias("14", m_CLEAR);
register_subalias("15", m_A);
}
NETLIB_UPDATE(74193_dip)
{
NETLIB_NAME(74193)::update();
}
NETLIB_RESET(74193_dip)
{
NETLIB_NAME(74193)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

58
src/lib/netlist/devices/nld_74193.h
View File

@ -36,9 +36,38 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(74193,
ATTR_HOT void update_outputs();
NETLIB_OBJECT(74193)
{
NETLIB_CONSTRUCTOR(74193)
, m_cnt(0)
, m_last_CU(0)
, m_last_CD(0)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("CLEAR", m_CLEAR);
enregister("LOADQ", m_LOADQ);
enregister("CU", m_CU);
enregister("CD", m_CD);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
enregister("BORROWQ", m_BORROWQ);
enregister("CARRYQ", m_CARRYQ);
save(NLNAME(m_cnt));
save(NLNAME(m_last_CU));
save(NLNAME(m_last_CD));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
@ -55,9 +84,30 @@ NETLIB_DEVICE(74193,
logic_output_t m_Q[4];
logic_output_t m_BORROWQ;
logic_output_t m_CARRYQ;
);
};
NETLIB_DEVICE_DERIVED_PURE(74193_dip, 74193);
NETLIB_OBJECT_DERIVED(74193_dip, 74193)
{
NETLIB_CONSTRUCTOR_DERIVED(74193_dip, 74193)
{
register_subalias("1", m_B);
register_subalias("2", m_Q[1]);
register_subalias("3", m_Q[0]);
register_subalias("4", m_CD);
register_subalias("5", m_CU);
register_subalias("6", m_Q[2]);
register_subalias("7", m_Q[3]);
register_subalias("9", m_D);
register_subalias("10", m_C);
register_subalias("11", m_LOADQ);
register_subalias("12", m_CARRYQ);
register_subalias("13", m_BORROWQ);
register_subalias("14", m_CLEAR);
register_subalias("15", m_A);
}
};
NETLIB_NAMESPACE_DEVICES_END()

43
src/lib/netlist/devices/nld_74279.cpp
View File

@ -119,48 +119,21 @@ const char *nld_74279B::m_desc[] = {
#endif
#endif
NETLIB_START(74279_dip)
{
register_sub("1", m_1);
register_sub("2", m_2);
register_sub("3", m_3);
register_sub("4", m_4);
register_subalias("1", m_1->m_I[2]); //R
register_subalias("2", m_1->m_I[0]);
register_subalias("3", m_1->m_I[1]);
register_subalias("4", m_1->m_Q[0]);
register_subalias("5", m_2->m_I[1]); //R
register_subalias("6", m_2->m_I[0]);
register_subalias("7", m_2->m_Q[0]);
register_subalias("9", m_3->m_Q[0]);
register_subalias("10", m_3->m_I[2]); //R
register_subalias("11", m_3->m_I[0]);
register_subalias("12", m_3->m_I[1]);
register_subalias("13", m_4->m_Q[0]);
register_subalias("14", m_4->m_I[1]); //R
register_subalias("15", m_4->m_I[0]);
}
NETLIB_UPDATE(74279_dip)
{
/* only called during startup */
m_1->update_dev();
m_2->update_dev();
m_3->update_dev();
m_4->update_dev();
//m_1.update_dev();
//m_2.update_dev();
//m_3.update_dev();
//m_4.update_dev();
}
NETLIB_RESET(74279_dip)
{
m_1->do_reset();
m_2->do_reset();
m_3->do_reset();
m_4->do_reset();
//m_1.do_reset();
//m_2.do_reset();
//m_3.do_reset();
//m_4.do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

42
src/lib/netlist/devices/nld_74279.h
View File

@ -53,13 +53,43 @@ NETLIB_TRUTHTABLE(74279B, 4, 1, 0);
//NETLIB_TRUTHTABLE(74279B, 5, 2, 0);
#endif
NETLIB_DEVICE(74279_dip,
NETLIB_OBJECT(74279_dip)
{
NETLIB_CONSTRUCTOR(74279_dip)
, m_1(*this, "1")
, m_2(*this, "2")
, m_3(*this, "3")
, m_4(*this, "4")
{
register_subalias("1", m_1.m_I[2]); //R
register_subalias("2", m_1.m_I[0]);
register_subalias("3", m_1.m_I[1]);
register_subalias("4", m_1.m_Q[0]);
NETLIB_SUBXX(74279B) m_1;
NETLIB_SUBXX(74279A) m_2;
NETLIB_SUBXX(74279B) m_3;
NETLIB_SUBXX(74279A) m_4;
);
register_subalias("5", m_2.m_I[1]); //R
register_subalias("6", m_2.m_I[0]);
register_subalias("7", m_2.m_Q[0]);
register_subalias("9", m_3.m_Q[0]);
register_subalias("10", m_3.m_I[2]); //R
register_subalias("11", m_3.m_I[0]);
register_subalias("12", m_3.m_I[1]);
register_subalias("13", m_4.m_Q[0]);
register_subalias("14", m_4.m_I[1]); //R
register_subalias("15", m_4.m_I[0]);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
NETLIB_SUB(74279B) m_1;
NETLIB_SUB(74279A) m_2;
NETLIB_SUB(74279B) m_3;
NETLIB_SUB(74279A) m_4;
};
NETLIB_NAMESPACE_DEVICES_END()

32
src/lib/netlist/devices/nld_7448.cpp
View File

@ -135,38 +135,6 @@ const UINT8 NETLIB_NAME(7448_sub)::tab7448[16][7] =
{ 0, 0, 0, 1, 1, 1, 1 }, /* 14 */
{ 0, 0, 0, 0, 0, 0, 0 }, /* 15 */
};
NETLIB_START(7448_dip)
{
NETLIB_NAME(7448)::start();
register_subalias("1", m_sub.m_B);
register_subalias("2", m_sub.m_C);
register_subalias("3", m_LTQ);
register_subalias("4", m_BIQ);
register_subalias("5",m_sub.m_RBIQ);
register_subalias("6", m_sub.m_D);
register_subalias("7", m_sub.m_A);
register_subalias("9", m_sub.m_Q[4]); // e
register_subalias("10", m_sub.m_Q[3]); // d
register_subalias("11", m_sub.m_Q[2]); // c
register_subalias("12", m_sub.m_Q[1]); // b
register_subalias("13", m_sub.m_Q[0]); // a
register_subalias("14", m_sub.m_Q[6]); // g
register_subalias("15", m_sub.m_Q[5]); // f
}
#endif
NETLIB_UPDATE(7448_dip)
{
NETLIB_NAME(7448)::update();
}
NETLIB_RESET(7448_dip)
{
NETLIB_NAME(7448)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

22
src/lib/netlist/devices/nld_7448.h
View File

@ -129,7 +129,27 @@ public:
};
#endif
NETLIB_DEVICE_DERIVED_PURE(7448_dip, 7448);
NETLIB_OBJECT_DERIVED(7448_dip, 7448)
{
NETLIB_CONSTRUCTOR_DERIVED(7448_dip, 7448)
{
register_subalias("1", m_sub.m_B);
register_subalias("2", m_sub.m_C);
register_subalias("3", m_LTQ);
register_subalias("4", m_BIQ);
register_subalias("5",m_sub.m_RBIQ);
register_subalias("6", m_sub.m_D);
register_subalias("7", m_sub.m_A);
register_subalias("9", m_sub.m_Q[4]); // e
register_subalias("10", m_sub.m_Q[3]); // d
register_subalias("11", m_sub.m_Q[2]); // c
register_subalias("12", m_sub.m_Q[1]); // b
register_subalias("13", m_sub.m_Q[0]); // a
register_subalias("14", m_sub.m_Q[6]); // g
register_subalias("15", m_sub.m_Q[5]); // f
}
};
NETLIB_NAMESPACE_DEVICES_END()

48
src/lib/netlist/devices/nld_7450.cpp
View File

@ -9,19 +9,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(7450)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("Q", m_Q);
}
NETLIB_RESET(7450)
{
}
NETLIB_UPDATE(7450)
{
m_A.activate();
@ -56,39 +43,4 @@ NETLIB_UPDATE(7450)
}
NETLIB_START(7450_dip)
{
register_sub("1", m_1);
register_sub("2", m_2);
register_subalias("1", m_1->m_A);
register_subalias("2", m_2->m_A);
register_subalias("3", m_2->m_B);
register_subalias("4", m_2->m_C);
register_subalias("5", m_2->m_D);
register_subalias("6", m_2->m_Q);
//register_subalias("7",); GND
register_subalias("8", m_1->m_Q);
register_subalias("9", m_1->m_C);
register_subalias("10", m_1->m_D);
//register_subalias("11", m_1->m_X1);
//register_subalias("12", m_1->m_X1Q);
register_subalias("13", m_1->m_B);
//register_subalias("14",); VCC
}
NETLIB_UPDATE(7450_dip)
{
/* only called during startup */
m_1->update_dev();
m_2->update_dev();
}
NETLIB_RESET(7450_dip)
{
m_1->do_reset();
m_2->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

50
src/lib/netlist/devices/nld_7450.h
View File

@ -27,7 +27,7 @@
#include "nl_base.h"
#define TTL_7450_ANDORINVERT(_name, _I1, _I2, _I3, _I4) \
NET_REGISTER_DEV(TTL_7450_ANDORINVERT, _name) \
NET_REGISTER_DEV(TTL_7450_ANDORINVERT, _name) \
NET_CONNECT(_name, A, _I1) \
NET_CONNECT(_name, B, _I2) \
NET_CONNECT(_name, C, _I3) \
@ -38,20 +38,56 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7450,
NETLIB_OBJECT(7450)
{
NETLIB_CONSTRUCTOR(7450)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
enregister("Q", m_Q);
}
//NETLIB_RESETI();
NETLIB_UPDATEI();
public:
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
logic_input_t m_D;
logic_output_t m_Q;
);
};
NETLIB_DEVICE(7450_dip,
NETLIB_OBJECT(7450_dip)
{
NETLIB_CONSTRUCTOR(7450_dip)
, m_1(*this, "1")
, m_2(*this, "2")
{
NETLIB_SUBXX(7450) m_1;
NETLIB_SUBXX(7450) m_2;
);
register_subalias("1", m_1.m_A);
register_subalias("2", m_2.m_A);
register_subalias("3", m_2.m_B);
register_subalias("4", m_2.m_C);
register_subalias("5", m_2.m_D);
register_subalias("6", m_2.m_Q);
//register_subalias("7",); GND
register_subalias("8", m_1.m_Q);
register_subalias("9", m_1.m_C);
register_subalias("10", m_1.m_D);
//register_subalias("11", m_1.m_X1);
//register_subalias("12", m_1.m_X1Q);
register_subalias("13", m_1.m_B);
//register_subalias("14",); VCC
}
//NETLIB_RESETI();
//NETLIB_UPDATEI();
NETLIB_SUB(7450) m_1;
NETLIB_SUB(7450) m_2;
};
NETLIB_NAMESPACE_DEVICES_END()

8
src/lib/netlist/devices/nld_7474.cpp
View File

@ -68,14 +68,14 @@ NETLIB_RESET(7474sub)
NETLIB_RESET(7474_dip)
{
m_1.do_reset();
m_2.do_reset();
// m_1.do_reset();
//m_2.do_reset();
}
NETLIB_UPDATE(7474_dip)
{
m_1.update_dev();
m_2.update_dev();
//m_1.update_dev();
//m_2.update_dev();
}
NETLIB_NAMESPACE_DEVICES_END()

54
src/lib/netlist/devices/nld_7483.cpp
View File

@ -9,27 +9,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(7483)
{
enregister("A1", m_A1);
enregister("A2", m_A2);
enregister("A3", m_A3);
enregister("A4", m_A4);
enregister("B1", m_B1);
enregister("B2", m_B2);
enregister("B3", m_B3);
enregister("B4", m_B4);
enregister("C0", m_C0);
enregister("S1", m_S1);
enregister("S2", m_S2);
enregister("S3", m_S3);
enregister("S4", m_S4);
enregister("C4", m_C4);
save(NLNAME(m_lastr));
}
NETLIB_RESET(7483)
{
m_lastr = 0;
@ -53,37 +32,4 @@ NETLIB_UPDATE(7483)
}
}
NETLIB_START(7483_dip)
{
NETLIB_NAME(7483)::start();
register_subalias("1", m_A4);
register_subalias("2", m_S3);
register_subalias("3", m_A3);
register_subalias("4", m_B3);
// register_subalias("5", ); --> VCC
register_subalias("6", m_S2);
register_subalias("7", m_B2);
register_subalias("8", m_A2);
register_subalias("9", m_S1);
register_subalias("10", m_A1);
register_subalias("11", m_B1);
// register_subalias("12", ); --> GND
register_subalias("13", m_C0);
register_subalias("14", m_C4);
register_subalias("15", m_S4);
register_subalias("16", m_B4);
}
NETLIB_UPDATE(7483_dip)
{
NETLIB_NAME(7483)::update();
}
NETLIB_RESET(7483_dip)
{
NETLIB_NAME(7483)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

56
src/lib/netlist/devices/nld_7483.h
View File

@ -46,7 +46,33 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7483,
NETLIB_OBJECT(7483)
{
NETLIB_CONSTRUCTOR(7483)
, m_lastr(0)
{
enregister("A1", m_A1);
enregister("A2", m_A2);
enregister("A3", m_A3);
enregister("A4", m_A4);
enregister("B1", m_B1);
enregister("B2", m_B2);
enregister("B3", m_B3);
enregister("B4", m_B4);
enregister("C0", m_C0);
enregister("S1", m_S1);
enregister("S2", m_S2);
enregister("S3", m_S3);
enregister("S4", m_S4);
enregister("C4", m_C4);
save(NLNAME(m_lastr));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
logic_input_t m_C0;
logic_input_t m_A1;
logic_input_t m_A2;
@ -65,9 +91,33 @@ NETLIB_DEVICE(7483,
logic_output_t m_S4;
logic_output_t m_C4;
);
};
NETLIB_DEVICE_DERIVED_PURE(7483_dip, 7483);
NETLIB_OBJECT_DERIVED(7483_dip, 7483)
{
NETLIB_CONSTRUCTOR_DERIVED(7483_dip, 7483)
{
register_subalias("1", m_A4);
register_subalias("2", m_S3);
register_subalias("3", m_A3);
register_subalias("4", m_B3);
// register_subalias("5", ); --> VCC
register_subalias("6", m_S2);
register_subalias("7", m_B2);
register_subalias("8", m_A2);
register_subalias("9", m_S1);
register_subalias("10", m_A1);
register_subalias("11", m_B1);
// register_subalias("12", ); --> GND
register_subalias("13", m_C0);
register_subalias("14", m_C4);
register_subalias("15", m_S4);
register_subalias("16", m_B4);
}
//NETLIB_RESETI();
//NETLIB_UPDATEI();
};
NETLIB_NAMESPACE_DEVICES_END()

52
src/lib/netlist/devices/nld_7490.cpp
View File

@ -9,26 +9,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(7490)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("R1", m_R1);
enregister("R2", m_R2);
enregister("R91", m_R91);
enregister("R92", m_R92);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
save(NLNAME(m_cnt));
save(NLNAME(m_last_A));
save(NLNAME(m_last_B));
}
NETLIB_RESET(7490)
{
m_cnt = 0;
@ -83,36 +63,4 @@ NETLIB_FUNC_VOID(7490, update_outputs, (void))
OUTLOGIC(m_Q[i], (m_cnt >> i) & 1, delay[i]);
}
NETLIB_START(7490_dip)
{
NETLIB_NAME(7490)::start();
register_subalias("1", m_B);
register_subalias("2", m_R1);
register_subalias("3", m_R2);
// register_subalias("4", ); --> NC
// register_subalias("5", ); --> VCC
register_subalias("6", m_R91);
register_subalias("7", m_R92);
register_subalias("8", m_Q[2]);
register_subalias("9", m_Q[1]);
// register_subalias("10", ); --> GND
register_subalias("11", m_Q[3]);
register_subalias("12", m_Q[0]);
// register_subalias("13", ); --> NC
register_subalias("14", m_A);
}
NETLIB_UPDATE(7490_dip)
{
NETLIB_NAME(7490)::update();
}
NETLIB_RESET(7490_dip)
{
NETLIB_NAME(7490)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

54
src/lib/netlist/devices/nld_7490.h
View File

@ -71,7 +71,34 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(7490,
NETLIB_OBJECT(7490)
{
NETLIB_CONSTRUCTOR(7490)
, m_cnt(0)
, m_last_A(0)
, m_last_B(0)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("R1", m_R1);
enregister("R2", m_R2);
enregister("R91", m_R91);
enregister("R92", m_R92);
enregister("QA", m_Q[0]);
enregister("QB", m_Q[1]);
enregister("QC", m_Q[2]);
enregister("QD", m_Q[3]);
save(NLNAME(m_cnt));
save(NLNAME(m_last_A));
save(NLNAME(m_last_B));
}
NETLIB_UPDATEI();
NETLIB_RESETI();
protected:
ATTR_HOT void update_outputs();
logic_input_t m_R1;
@ -86,9 +113,30 @@ NETLIB_DEVICE(7490,
UINT8 m_last_B;
logic_output_t m_Q[4];
);
};
NETLIB_DEVICE_DERIVED_PURE(7490_dip, 7490);
NETLIB_OBJECT_DERIVED(7490_dip, 7490)
{
NETLIB_CONSTRUCTOR_DERIVED(7490_dip, 7490)
{
register_subalias("1", m_B);
register_subalias("2", m_R1);
register_subalias("3", m_R2);
// register_subalias("4", ); --> NC
// register_subalias("5", ); --> VCC
register_subalias("6", m_R91);
register_subalias("7", m_R92);
register_subalias("8", m_Q[2]);
register_subalias("9", m_Q[1]);
// register_subalias("10", ); --> GND
register_subalias("11", m_Q[3]);
register_subalias("12", m_Q[0]);
// register_subalias("13", ); --> NC
register_subalias("14", m_A);
}
};
NETLIB_NAMESPACE_DEVICES_END()

41
src/lib/netlist/devices/nld_7493.cpp
View File

@ -10,14 +10,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_RESET(7493)
{
A.do_reset();
B.do_reset();
C.do_reset();
D.do_reset();
}
NETLIB_RESET(7493ff)
{
@ -59,37 +51,4 @@ NETLIB_UPDATE(7493)
}
}
NETLIB_START(7493_dip)
{
NETLIB_NAME(7493)::start();
register_subalias("1", B.m_I);
register_subalias("2", m_R1);
register_subalias("3", m_R2);
// register_subalias("4", ); --> NC
// register_subalias("5", ); --> VCC
// register_subalias("6", ); --> NC
// register_subalias("7", ); --> NC
register_subalias("8", C.m_Q);
register_subalias("9", B.m_Q);
// register_subalias("10", ); -. GND
register_subalias("11", D.m_Q);
register_subalias("12", A.m_Q);
// register_subalias("13", ); -. NC
register_subalias("14", A.m_I);
}
NETLIB_UPDATE(7493_dip)
{
NETLIB_NAME(7493)::update();
}
NETLIB_RESET(7493_dip)
{
NETLIB_NAME(7493)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

25
src/lib/netlist/devices/nld_7493.h
View File

@ -115,7 +115,7 @@ NETLIB_OBJECT(7493)
connect_late(D.m_I, C.m_Q);
}
NETLIB_RESETI();
NETLIB_RESETI() { }
NETLIB_UPDATEI();
logic_input_t m_R1;
@ -127,7 +127,28 @@ NETLIB_OBJECT(7493)
NETLIB_SUB(7493ff) D;
};
NETLIB_DEVICE_DERIVED_PURE(7493_dip, 7493);
NETLIB_OBJECT_DERIVED(7493_dip, 7493)
{
NETLIB_CONSTRUCTOR_DERIVED(7493_dip, 7493)
{
register_subalias("1", B.m_I);
register_subalias("2", m_R1);
register_subalias("3", m_R2);
// register_subalias("4", ); --> NC
// register_subalias("5", ); --> VCC
// register_subalias("6", ); --> NC
// register_subalias("7", ); --> NC
register_subalias("8", C.m_Q);
register_subalias("9", B.m_Q);
// register_subalias("10", ); -. GND
register_subalias("11", D.m_Q);
register_subalias("12", A.m_Q);
// register_subalias("13", ); -. NC
register_subalias("14", A.m_I);
}
};
NETLIB_NAMESPACE_DEVICES_END()

56
src/lib/netlist/devices/nld_82S16.cpp
View File

@ -37,29 +37,6 @@ NETLIB_UPDATE(82S16)
}
}
NETLIB_START(82S16)
{
enregister("A0", m_A[0]);
enregister("A1", m_A[1]);
enregister("A2", m_A[2]);
enregister("A3", m_A[3]);
enregister("A4", m_A[4]);
enregister("A5", m_A[5]);
enregister("A6", m_A[6]);
enregister("A7", m_A[7]);
enregister("CE1Q", m_CE1Q);
enregister("CE2Q", m_CE2Q);
enregister("CE3Q", m_CE3Q);
enregister("WEQ", m_WEQ);
enregister("DIN", m_DIN);
enregister("DOUTQ",m_DOUTQ);
save(NLNAME(m_ram));
}
NETLIB_RESET(82S16)
{
for (int i=0; i<4; i++)
@ -68,37 +45,4 @@ NETLIB_RESET(82S16)
}
}
NETLIB_START(82S16_dip)
{
enregister("2", m_A[0]);
enregister("1", m_A[1]);
enregister("15", m_A[2]);
enregister("14", m_A[3]);
enregister("7", m_A[4]);
enregister("9", m_A[5]);
enregister("10", m_A[6]);
enregister("11", m_A[7]);
enregister("3", m_CE1Q);
enregister("4", m_CE2Q);
enregister("5", m_CE3Q);
enregister("12", m_WEQ);
enregister("13", m_DIN);
enregister("6", m_DOUTQ);
save(NLNAME(m_ram));
}
NETLIB_RESET(82S16_dip)
{
NETLIB_NAME(82S16)::reset();
}
NETLIB_UPDATE(82S16_dip)
{
NETLIB_NAME(82S16)::update();
}
NETLIB_NAMESPACE_DEVICES_END()

56
src/lib/netlist/devices/nld_82S16.h
View File

@ -33,8 +33,36 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(82S16,
NETLIB_OBJECT(82S16)
{
NETLIB_CONSTRUCTOR(82S16)
{
enregister("A0", m_A[0]);
enregister("A1", m_A[1]);
enregister("A2", m_A[2]);
enregister("A3", m_A[3]);
enregister("A4", m_A[4]);
enregister("A5", m_A[5]);
enregister("A6", m_A[6]);
enregister("A7", m_A[7]);
enregister("CE1Q", m_CE1Q);
enregister("CE2Q", m_CE2Q);
enregister("CE3Q", m_CE3Q);
enregister("WEQ", m_WEQ);
enregister("DIN", m_DIN);
enregister("DOUTQ",m_DOUTQ);
save(NLNAME(m_ram));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
logic_input_t m_A[8];
logic_input_t m_CE1Q;
logic_input_t m_CE2Q;
@ -45,9 +73,31 @@ NETLIB_DEVICE(82S16,
//netlist_state_t<UINT8[256]> m_ram;
UINT64 m_ram[4]; // 256 bits
);
};
NETLIB_DEVICE_DERIVED_PURE(82S16_dip, 82S16);
NETLIB_OBJECT_DERIVED(82S16_dip, 82S16)
{
NETLIB_CONSTRUCTOR_DERIVED(82S16_dip, 82S16)
{
enregister("2", m_A[0]);
enregister("1", m_A[1]);
enregister("15", m_A[2]);
enregister("14", m_A[3]);
enregister("7", m_A[4]);
enregister("9", m_A[5]);
enregister("10", m_A[6]);
enregister("11", m_A[7]);
enregister("3", m_CE1Q);
enregister("4", m_CE2Q);
enregister("5", m_CE3Q);
enregister("12", m_WEQ);
enregister("13", m_DIN);
enregister("6", m_DOUTQ);
}
};
NETLIB_NAMESPACE_DEVICES_END()

111
src/lib/netlist/devices/nld_9310.cpp
View File

@ -11,45 +11,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(9310)
{
register_sub("subABCD", subABCD);
register_sub("sub", sub);
sub->m_ABCD = &(*subABCD);
register_subalias("CLK", sub->m_CLK);
enregister("ENP", m_ENP);
enregister("ENT", m_ENT);
enregister("CLRQ", m_CLRQ);
enregister("LOADQ", m_LOADQ);
register_subalias("A", subABCD->m_A);
register_subalias("B", subABCD->m_B);
register_subalias("C", subABCD->m_C);
register_subalias("D", subABCD->m_D);
register_subalias("QA", sub->m_QA);
register_subalias("QB", sub->m_QB);
register_subalias("QC", sub->m_QC);
register_subalias("QD", sub->m_QD);
register_subalias("RC", sub->m_RC);
}
NETLIB_RESET(9310)
{
sub->do_reset();
subABCD->do_reset();
}
NETLIB_START(9310_subABCD)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
sub.do_reset();
subABCD.do_reset();
}
NETLIB_RESET(9310_subABCD)
@ -62,25 +27,6 @@ NETLIB_RESET(9310_subABCD)
#endif
}
NETLIB_UPDATE(9310_subABCD)
{
}
NETLIB_START(9310_sub)
{
enregister("CLK", m_CLK);
enregister("QA", m_QA);
enregister("QB", m_QB);
enregister("QC", m_QC);
enregister("QD", m_QD);
enregister("RC", m_RC);
save(NLNAME(m_cnt));
save(NLNAME(m_loadq));
save(NLNAME(m_ent));
}
NETLIB_RESET(9310_sub)
{
m_CLK.set_state(logic_t::STATE_INP_LH);
@ -126,25 +72,25 @@ NETLIB_UPDATE(9310_sub)
NETLIB_UPDATE(9310)
{
sub->m_loadq = INPLOGIC(m_LOADQ);
sub->m_ent = INPLOGIC(m_ENT);
sub.m_loadq = INPLOGIC(m_LOADQ);
sub.m_ent = INPLOGIC(m_ENT);
const netlist_sig_t clrq = INPLOGIC(m_CLRQ);
if ((!sub->m_loadq || (sub->m_ent & INPLOGIC(m_ENP))) && clrq)
if ((!sub.m_loadq || (sub.m_ent & INPLOGIC(m_ENP))) && clrq)
{
sub->m_CLK.activate_lh();
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
sub.m_CLK.activate_lh();
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
else
{
sub->m_CLK.inactivate();
if (!clrq && (sub->m_cnt>0))
sub.m_CLK.inactivate();
if (!clrq && (sub.m_cnt>0))
{
sub->update_outputs_all(0, NLTIME_FROM_NS(36));
sub->m_cnt = 0;
sub.update_outputs_all(0, NLTIME_FROM_NS(36));
sub.m_cnt = 0;
//return;
}
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
}
@ -201,37 +147,4 @@ inline NETLIB_FUNC_VOID(9310_sub, update_outputs, (const UINT8 cnt))
#endif
}
NETLIB_START(9310_dip)
{
NETLIB_NAME(9310)::start();
register_subalias("1", m_CLRQ);
register_subalias("2", sub->m_CLK);
register_subalias("3", subABCD->m_A);
register_subalias("4", subABCD->m_B);
register_subalias("5", subABCD->m_C);
register_subalias("6", subABCD->m_D);
register_subalias("7", m_ENP);
// register_subalias("8", ); --> GND
register_subalias("9", m_LOADQ);
register_subalias("10", m_ENT);
register_subalias("11", sub->m_QD);
register_subalias("12", sub->m_QC);
register_subalias("13", sub->m_QB);
register_subalias("14", sub->m_QA);
register_subalias("15", sub->m_RC);
// register_subalias("16", ); --> VCC
}
NETLIB_UPDATE(9310_dip)
{
NETLIB_NAME(9310)::update();
}
NETLIB_RESET(9310_dip)
{
NETLIB_NAME(9310)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

103
src/lib/netlist/devices/nld_9310.h
View File

@ -64,7 +64,20 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(9310_subABCD,
NETLIB_OBJECT(9310_subABCD)
{
NETLIB_CONSTRUCTOR(9310_subABCD)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
}
NETLIB_RESETI();
//NETLIB_UPDATEI();
public:
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
@ -75,9 +88,31 @@ NETLIB_SUBDEVICE(9310_subABCD,
//return (INPLOGIC_PASSIVE(m_D) << 3) | (INPLOGIC_PASSIVE(m_C) << 2) | (INPLOGIC_PASSIVE(m_B) << 1) | (INPLOGIC_PASSIVE(m_A) << 0);
return (INPLOGIC(m_D) << 3) | (INPLOGIC(m_C) << 2) | (INPLOGIC(m_B) << 1) | (INPLOGIC(m_A) << 0);
}
);
};
NETLIB_SUBDEVICE(9310_sub,
NETLIB_OBJECT(9310_sub)
{
NETLIB_CONSTRUCTOR(9310_sub)
, m_cnt(0)
, m_ABCD(nullptr)
, m_loadq(0)
, m_ent(0)
{
enregister("CLK", m_CLK);
enregister("QA", m_QA);
enregister("QB", m_QB);
enregister("QC", m_QC);
enregister("QD", m_QD);
enregister("RC", m_RC);
save(NLNAME(m_cnt));
save(NLNAME(m_loadq));
save(NLNAME(m_ent));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
ATTR_HOT inline void update_outputs_all(const UINT8 cnt, const netlist_time out_delay);
ATTR_HOT inline void update_outputs(const UINT8 cnt);
@ -93,19 +128,69 @@ NETLIB_SUBDEVICE(9310_sub,
logic_output_t m_QC;
logic_output_t m_QD;
logic_output_t m_RC;
);
};
NETLIB_DEVICE(9310,
NETLIB_SUBXX(9310_sub) sub;
NETLIB_SUBXX(9310_subABCD) subABCD;
NETLIB_OBJECT(9310)
{
NETLIB_CONSTRUCTOR(9310)
, subABCD(*this, "subABCD")
, sub(*this, "sub")
{
sub.m_ABCD = &(subABCD);
register_subalias("CLK", sub.m_CLK);
enregister("ENP", m_ENP);
enregister("ENT", m_ENT);
enregister("CLRQ", m_CLRQ);
enregister("LOADQ", m_LOADQ);
register_subalias("A", subABCD.m_A);
register_subalias("B", subABCD.m_B);
register_subalias("C", subABCD.m_C);
register_subalias("D", subABCD.m_D);
register_subalias("QA", sub.m_QA);
register_subalias("QB", sub.m_QB);
register_subalias("QC", sub.m_QC);
register_subalias("QD", sub.m_QD);
register_subalias("RC", sub.m_RC);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
NETLIB_SUB(9310_subABCD) subABCD;
NETLIB_SUB(9310_sub) sub;
logic_input_t m_ENP;
logic_input_t m_ENT;
logic_input_t m_CLRQ;
logic_input_t m_LOADQ;
);
};
NETLIB_DEVICE_DERIVED_PURE(9310_dip, 9310);
NETLIB_OBJECT_DERIVED(9310_dip, 9310)
{
NETLIB_CONSTRUCTOR_DERIVED(9310_dip, 9310)
{
register_subalias("1", m_CLRQ);
register_subalias("2", sub.m_CLK);
register_subalias("3", subABCD.m_A);
register_subalias("4", subABCD.m_B);
register_subalias("5", subABCD.m_C);
register_subalias("6", subABCD.m_D);
register_subalias("7", m_ENP);
// register_subalias("8", ); -. GND
register_subalias("9", m_LOADQ);
register_subalias("10", m_ENT);
register_subalias("11", sub.m_QD);
register_subalias("12", sub.m_QC);
register_subalias("13", sub.m_QB);
register_subalias("14", sub.m_QA);
register_subalias("15", sub.m_RC);
// register_subalias("16", ); -. VCC
}
};
NETLIB_NAMESPACE_DEVICES_END()
#endif /* NLD_9310_H_ */

55
src/lib/netlist/devices/nld_9312.cpp
View File

@ -124,59 +124,4 @@ NETLIB_RESET(9312)
}
#endif
NETLIB_START(9312_dip)
{
register_sub("1", m_sub);
#if (1 && USE_TRUTHTABLE)
register_subalias("13", m_sub->m_I[0]);
register_subalias("12", m_sub->m_I[1]);
register_subalias("11", m_sub->m_I[2]);
register_subalias("10", m_sub->m_I[3]);
register_subalias("1", m_sub->m_I[4]);
register_subalias("2", m_sub->m_I[5]);
register_subalias("3", m_sub->m_I[6]);
register_subalias("4", m_sub->m_I[7]);
register_subalias("5", m_sub->m_I[8]);
register_subalias("6", m_sub->m_I[9]);
register_subalias("7", m_sub->m_I[10]);
register_subalias("9", m_sub->m_I[11]);
register_subalias("15", m_sub->m_Q[0]); // Y
register_subalias("14", m_sub->m_Q[1]); // YQ
#else
register_subalias("13", m_sub->m_C);
register_subalias("12", m_sub->m_B);
register_subalias("11", m_sub->m_A);
register_subalias("10", m_sub->m_G);
register_subalias("1", m_sub->m_D[0]);
register_subalias("2", m_sub->m_D[1]);
register_subalias("3", m_sub->m_D[2]);
register_subalias("4", m_sub->m_D[3]);
register_subalias("5", m_sub->m_D[4]);
register_subalias("6", m_sub->m_D[5]);
register_subalias("7", m_sub->m_D[6]);
register_subalias("9", m_sub->m_D[7]);
register_subalias("15", m_sub->m_Y); // Y
register_subalias("14", m_sub->m_YQ); // YQ
#endif
}
NETLIB_UPDATE(9312_dip)
{
/* only called during startup */
m_sub->update_dev();
}
NETLIB_RESET(9312_dip)
{
m_sub->do_reset();
}
NETLIB_NAMESPACE_DEVICES_END()

56
src/lib/netlist/devices/nld_9312.h
View File

@ -71,9 +71,59 @@ public:
#endif
NETLIB_DEVICE(9312_dip,
NETLIB_SUBXX(9312) m_sub;
);
NETLIB_OBJECT(9312_dip)
{
NETLIB_CONSTRUCTOR(9312_dip)
, m_sub(*this, "1")
{
#if (1 && USE_TRUTHTABLE)
register_subalias("13", m_sub.m_I[0]);
register_subalias("12", m_sub.m_I[1]);
register_subalias("11", m_sub.m_I[2]);
register_subalias("10", m_sub.m_I[3]);
register_subalias("1", m_sub.m_I[4]);
register_subalias("2", m_sub.m_I[5]);
register_subalias("3", m_sub.m_I[6]);
register_subalias("4", m_sub.m_I[7]);
register_subalias("5", m_sub.m_I[8]);
register_subalias("6", m_sub.m_I[9]);
register_subalias("7", m_sub.m_I[10]);
register_subalias("9", m_sub.m_I[11]);
register_subalias("15", m_sub.m_Q[0]); // Y
register_subalias("14", m_sub.m_Q[1]); // YQ
#else
register_subalias("13", m_sub.m_C);
register_subalias("12", m_sub.m_B);
register_subalias("11", m_sub.m_A);
register_subalias("10", m_sub.m_G);
register_subalias("1", m_sub.m_D[0]);
register_subalias("2", m_sub.m_D[1]);
register_subalias("3", m_sub.m_D[2]);
register_subalias("4", m_sub.m_D[3]);
register_subalias("5", m_sub.m_D[4]);
register_subalias("6", m_sub.m_D[5]);
register_subalias("7", m_sub.m_D[6]);
register_subalias("9", m_sub.m_D[7]);
register_subalias("15", m_sub.m_Y); // Y
register_subalias("14", m_sub.m_YQ); // YQ
#endif
}
//NETLIB_RESETI();
//NETLIB_UPDATEI();
protected:
NETLIB_SUB(9312) m_sub;
};
NETLIB_NAMESPACE_DEVICES_END()

111
src/lib/netlist/devices/nld_9316.cpp
View File

@ -11,45 +11,10 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(9316)
{
register_sub("sub", sub);
register_sub("subABCD", subABCD);
sub->m_ABCD = &(*subABCD);
register_subalias("CLK", sub->m_CLK);
enregister("ENP", m_ENP);
enregister("ENT", m_ENT);
enregister("CLRQ", m_CLRQ);
enregister("LOADQ", m_LOADQ);
register_subalias("A", subABCD->m_A);
register_subalias("B", subABCD->m_B);
register_subalias("C", subABCD->m_C);
register_subalias("D", subABCD->m_D);
register_subalias("QA", sub->m_QA);
register_subalias("QB", sub->m_QB);
register_subalias("QC", sub->m_QC);
register_subalias("QD", sub->m_QD);
register_subalias("RC", sub->m_RC);
}
NETLIB_RESET(9316)
{
sub->do_reset();
subABCD->do_reset();
}
NETLIB_START(9316_subABCD)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
sub.do_reset();
subABCD.do_reset();
}
NETLIB_RESET(9316_subABCD)
@ -62,25 +27,6 @@ NETLIB_RESET(9316_subABCD)
#endif
}
NETLIB_UPDATE(9316_subABCD)
{
}
NETLIB_START(9316_sub)
{
enregister("CLK", m_CLK);
enregister("QA", m_QA);
enregister("QB", m_QB);
enregister("QC", m_QC);
enregister("QD", m_QD);
enregister("RC", m_RC);
save(NLNAME(m_cnt));
save(NLNAME(m_loadq));
save(NLNAME(m_ent));
}
NETLIB_RESET(9316_sub)
{
m_CLK.set_state(logic_t::STATE_INP_LH);
@ -121,25 +67,25 @@ NETLIB_UPDATE(9316_sub)
NETLIB_UPDATE(9316)
{
sub->m_loadq = INPLOGIC(m_LOADQ);
sub->m_ent = INPLOGIC(m_ENT);
sub.m_loadq = INPLOGIC(m_LOADQ);
sub.m_ent = INPLOGIC(m_ENT);
const netlist_sig_t clrq = INPLOGIC(m_CLRQ);
if (((sub->m_loadq ^ 1) | (sub->m_ent & INPLOGIC(m_ENP))) & clrq)
if (((sub.m_loadq ^ 1) | (sub.m_ent & INPLOGIC(m_ENP))) & clrq)
{
sub->m_CLK.activate_lh();
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
sub.m_CLK.activate_lh();
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
else
{
sub->m_CLK.inactivate();
if (!clrq && (sub->m_cnt>0))
sub.m_CLK.inactivate();
if (!clrq && (sub.m_cnt>0))
{
sub->update_outputs_all(0, NLTIME_FROM_NS(36));
sub->m_cnt = 0;
sub.update_outputs_all(0, NLTIME_FROM_NS(36));
sub.m_cnt = 0;
//return;
}
OUTLOGIC(sub->m_RC, sub->m_ent & (sub->m_cnt == MAXCNT), NLTIME_FROM_NS(27));
OUTLOGIC(sub.m_RC, sub.m_ent & (sub.m_cnt == MAXCNT), NLTIME_FROM_NS(27));
}
}
@ -196,37 +142,4 @@ inline NETLIB_FUNC_VOID(9316_sub, update_outputs, (const UINT8 cnt))
#endif
}
NETLIB_START(9316_dip)
{
NETLIB_NAME(9316)::start();
register_subalias("1", m_CLRQ);
register_subalias("2", sub->m_CLK);
register_subalias("3", subABCD->m_A);
register_subalias("4", subABCD->m_B);
register_subalias("5", subABCD->m_C);
register_subalias("6", subABCD->m_D);
register_subalias("7", m_ENP);
// register_subalias("8", ); --> GND
register_subalias("9", m_LOADQ);
register_subalias("10", m_ENT);
register_subalias("11", sub->m_QD);
register_subalias("12", sub->m_QC);
register_subalias("13", sub->m_QB);
register_subalias("14", sub->m_QA);
register_subalias("15", sub->m_RC);
// register_subalias("16", ); --> VCC
}
NETLIB_UPDATE(9316_dip)
{
NETLIB_NAME(9316)::update();
}
NETLIB_RESET(9316_dip)
{
NETLIB_NAME(9316)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

106
src/lib/netlist/devices/nld_9316.h
View File

@ -68,7 +68,20 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_SUBDEVICE(9316_subABCD,
NETLIB_OBJECT(9316_subABCD)
{
NETLIB_CONSTRUCTOR(9316_subABCD)
{
enregister("A", m_A);
enregister("B", m_B);
enregister("C", m_C);
enregister("D", m_D);
}
NETLIB_RESETI();
//NETLIB_UPDATEI();
public:
logic_input_t m_A;
logic_input_t m_B;
logic_input_t m_C;
@ -79,9 +92,33 @@ NETLIB_SUBDEVICE(9316_subABCD,
//return (INPLOGIC_PASSIVE(m_D) << 3) | (INPLOGIC_PASSIVE(m_C) << 2) | (INPLOGIC_PASSIVE(m_B) << 1) | (INPLOGIC_PASSIVE(m_A) << 0);
return (INPLOGIC(m_D) << 3) | (INPLOGIC(m_C) << 2) | (INPLOGIC(m_B) << 1) | (INPLOGIC(m_A) << 0);
}
);
};
NETLIB_SUBDEVICE(9316_sub,
NETLIB_OBJECT(9316_sub)
{
NETLIB_CONSTRUCTOR(9316_sub)
, m_cnt(0)
, m_ABCD(nullptr)
, m_loadq(0)
, m_ent(0)
{
enregister("CLK", m_CLK);
enregister("QA", m_QA);
enregister("QB", m_QB);
enregister("QC", m_QC);
enregister("QD", m_QD);
enregister("RC", m_RC);
save(NLNAME(m_cnt));
save(NLNAME(m_loadq));
save(NLNAME(m_ent));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
public:
ATTR_HOT inline void update_outputs_all(const UINT8 cnt, const netlist_time out_delay);
ATTR_HOT inline void update_outputs(const UINT8 cnt);
@ -97,19 +134,70 @@ NETLIB_SUBDEVICE(9316_sub,
NETLIB_NAME(9316_subABCD) *m_ABCD;
netlist_sig_t m_loadq;
netlist_sig_t m_ent;
};
);
NETLIB_OBJECT(9316)
{
NETLIB_CONSTRUCTOR(9316)
, sub(*this, "sub")
, subABCD(*this, "subABCD")
{
sub.m_ABCD = &(subABCD);
NETLIB_DEVICE(9316,
NETLIB_SUBXX(9316_sub) sub;
NETLIB_SUBXX(9316_subABCD) subABCD;
register_subalias("CLK", sub.m_CLK);
enregister("ENP", m_ENP);
enregister("ENT", m_ENT);
enregister("CLRQ", m_CLRQ);
enregister("LOADQ", m_LOADQ);
register_subalias("A", subABCD.m_A);
register_subalias("B", subABCD.m_B);
register_subalias("C", subABCD.m_C);
register_subalias("D", subABCD.m_D);
register_subalias("QA", sub.m_QA);
register_subalias("QB", sub.m_QB);
register_subalias("QC", sub.m_QC);
register_subalias("QD", sub.m_QD);
register_subalias("RC", sub.m_RC);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
NETLIB_SUB(9316_sub) sub;
NETLIB_SUB(9316_subABCD) subABCD;
logic_input_t m_ENP;
logic_input_t m_ENT;
logic_input_t m_CLRQ;
logic_input_t m_LOADQ;
);
};
NETLIB_DEVICE_DERIVED_PURE(9316_dip, 9316);
NETLIB_OBJECT_DERIVED(9316_dip, 9316)
{
NETLIB_CONSTRUCTOR_DERIVED(9316_dip, 9316)
{
register_subalias("1", m_CLRQ);
register_subalias("2", sub.m_CLK);
register_subalias("3", subABCD.m_A);
register_subalias("4", subABCD.m_B);
register_subalias("5", subABCD.m_C);
register_subalias("6", subABCD.m_D);
register_subalias("7", m_ENP);
// register_subalias("8", ); -. GND
register_subalias("9", m_LOADQ);
register_subalias("10", m_ENT);
register_subalias("11", sub.m_QD);
register_subalias("12", sub.m_QC);
register_subalias("13", sub.m_QB);
register_subalias("14", sub.m_QA);
register_subalias("15", sub.m_RC);
// register_subalias("16", ); -. VCC
}
};
NETLIB_NAMESPACE_DEVICES_END()

24
src/lib/netlist/devices/nld_legacy.cpp
View File

@ -10,14 +10,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(nicRSFF)
{
enregister("S", m_S);
enregister("R", m_R);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
}
NETLIB_RESET(nicRSFF)
{
m_Q.initial(0);
@ -38,27 +30,11 @@ NETLIB_UPDATE(nicRSFF)
}
}
NETLIB_START(nicDelay)
{
enregister("1", m_I);
enregister("2", m_Q);
register_param("L_TO_H", m_L_to_H, 10);
register_param("H_TO_L", m_H_to_L, 10);
save(NLNAME(m_last));
}
NETLIB_RESET(nicDelay)
{
m_Q.initial(0);
}
NETLIB_UPDATE_PARAM(nicDelay)
{
}
NETLIB_UPDATE(nicDelay)
{
netlist_sig_t nval = INPLOGIC(m_I);

39
src/lib/netlist/devices/nld_legacy.h
View File

@ -31,16 +31,47 @@ NETLIB_NAMESPACE_DEVICES_START()
// Devices ...
// ----------------------------------------------------------------------------------------
NETLIB_DEVICE(nicRSFF,
NETLIB_OBJECT(nicRSFF)
{
NETLIB_CONSTRUCTOR(nicRSFF)
{
enregister("S", m_S);
enregister("R", m_R);
enregister("Q", m_Q);
enregister("QQ", m_QQ);
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
logic_input_t m_S;
logic_input_t m_R;
logic_output_t m_Q;
logic_output_t m_QQ;
);
};
NETLIB_DEVICE_WITH_PARAMS(nicDelay,
NETLIB_OBJECT(nicDelay)
{
NETLIB_CONSTRUCTOR(nicDelay)
, m_last(0)
{
enregister("1", m_I);
enregister("2", m_Q);
register_param("L_TO_H", m_L_to_H, 10);
register_param("H_TO_L", m_H_to_L, 10);
save(NLNAME(m_last));
}
//NETLIB_UPDATE_PARAMI();
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
logic_input_t m_I;
logic_output_t m_Q;
@ -49,7 +80,7 @@ NETLIB_DEVICE_WITH_PARAMS(nicDelay,
param_int_t m_H_to_L;
UINT8 m_last;
);
};
NETLIB_NAMESPACE_DEVICES_END()

22
src/lib/netlist/devices/nld_log.cpp
View File

@ -12,18 +12,6 @@ NETLIB_NAMESPACE_DEVICES_START()
//FIXME: what to do with save states?
NETLIB_START(log)
{
enregister("I", m_I);
pstring filename = pfmt("{1}.log")(name());
m_strm = std::make_unique<pofilestream>(filename);
}
NETLIB_RESET(log)
{
}
NETLIB_UPDATE(log)
{
/* use pstring::sprintf, it is a LOT faster */
@ -35,16 +23,6 @@ NETLIB_NAME(log)::~NETLIB_NAME(log)()
m_strm->close();
}
NETLIB_START(logD)
{
NETLIB_NAME(log)::start();
enregister("I2", m_I2);
}
NETLIB_RESET(logD)
{
}
NETLIB_UPDATE(logD)
{
m_strm->writeline(pfmt("{1} {2}").e(netlist().time().as_double(),".9").e((nl_double) (INPANALOG(m_I) - INPANALOG(m_I2))));

42
src/lib/netlist/devices/nld_log.h
View File

@ -18,30 +18,50 @@
#ifndef NLD_LOG_H_
#define NLD_LOG_H_
#include <memory>
#include "nl_base.h"
#include "plib/pstream.h"
#include "plib/pfmtlog.h"
#define LOG(_name, _I) \
NET_REGISTER_DEV(??PG, _name) \
NET_CONNECT(_name, I, _I)
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(log,
~NETLIB_NAME(log)();
analog_input_t m_I;
protected:
std::unique_ptr<pofilestream> m_strm;
);
#define LOGD(_name, _I, _I2) \
NET_REGISTER_DEV(LOGD, _name) \
NET_CONNECT(_name, I, _I) \
NET_CONNECT(_name, I2, _I2)
NETLIB_DEVICE_DERIVED(logD, log,
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_OBJECT(log)
{
NETLIB_CONSTRUCTOR(log)
{
enregister("I", m_I);
pstring filename = pfmt("{1}.log")(this->name());
m_strm = std::make_unique<pofilestream>(filename);
}
NETLIB_DESTRUCTOR(log);
NETLIB_UPDATEI();
NETLIB_RESETI() { }
protected:
analog_input_t m_I;
std::unique_ptr<pofilestream> m_strm;
};
NETLIB_OBJECT_DERIVED(logD, log)
{
NETLIB_CONSTRUCTOR_DERIVED(logD, log)
{
enregister("I2", m_I2);
}
NETLIB_UPDATEI();
NETLIB_RESETI() { };
analog_input_t m_I2;
);
};
#if 0
NETLIB_DEVICE(wav,

36
src/lib/netlist/devices/nld_mm5837.cpp
View File

@ -14,38 +14,14 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(MM5837_dip)
{
/* clock */
enregister("Q", m_Q);
enregister("FB", m_feedback);
m_inc = netlist_time::from_hz(56000);
connect_late(m_feedback, m_Q);
/* output */
register_sub("RV", m_RV);
enregister("_RV1", m_RV->m_P);
enregister("_RV2", m_RV->m_N);
enregister("_Q", m_V0);
connect_late(m_RV->m_N, m_V0);
/* device */
enregister("1", m_VDD);
enregister("2", m_VGG);
register_subalias("3", m_RV->m_P);
enregister("4", m_VSS);
save(NLNAME(m_shift));
}
NETLIB_RESET(MM5837_dip)
{
m_V0.initial(0.0);
m_RV->do_reset();
m_RV->set(NL_FCONST(1.0) / R_LOW, 0.0, 0.0);
m_RV.do_reset();
m_RV.set(NL_FCONST(1.0) / R_LOW, 0.0, 0.0);
m_shift = 0x1ffff;
m_is_timestep = m_RV->m_P.net().solver()->is_timestep();
m_is_timestep = m_RV.m_P.net().solver()->is_timestep();
}
NETLIB_UPDATE(MM5837_dip)
@ -70,9 +46,9 @@ NETLIB_UPDATE(MM5837_dip)
// We only need to update the net first if this is a time stepping net
if (m_is_timestep)
m_RV->update_dev();
m_RV->set(NL_FCONST(1.0) / R, V, 0.0);
m_RV->m_P.schedule_after(NLTIME_FROM_NS(1));
m_RV.update_dev();
m_RV.set(NL_FCONST(1.0) / R, V, 0.0);
m_RV.m_P.schedule_after(NLTIME_FROM_NS(1));
}
}

35
src/lib/netlist/devices/nld_mm5837.h
View File

@ -27,14 +27,43 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE(MM5837_dip,
NETLIB_OBJECT(MM5837_dip)
{
NETLIB_CONSTRUCTOR(MM5837_dip)
,m_RV(*this, "RV")
{
/* clock */
enregister("Q", m_Q);
enregister("FB", m_feedback);
m_inc = netlist_time::from_hz(56000);
connect_late(m_feedback, m_Q);
/* output */
enregister("_RV1", m_RV.m_P);
enregister("_RV2", m_RV.m_N);
enregister("_Q", m_V0);
connect_late(m_RV.m_N, m_V0);
/* device */
enregister("1", m_VDD);
enregister("2", m_VGG);
register_subalias("3", m_RV.m_P);
enregister("4", m_VSS);
save(NLNAME(m_shift));
}
NETLIB_RESETI();
NETLIB_UPDATEI();
protected:
NETLIB_SUB(twoterm) m_RV;
analog_input_t m_VDD;
analog_input_t m_VGG;
analog_input_t m_VSS;
/* output stage */
std::unique_ptr<nld_twoterm> m_RV;
analog_output_t m_V0; /* could be gnd as well */
/* clock stage */
@ -47,7 +76,7 @@ NETLIB_DEVICE(MM5837_dip,
/* cache */
bool m_is_timestep;
);
};
NETLIB_NAMESPACE_DEVICES_END()

25
src/lib/netlist/devices/nld_ne555.cpp
View File

@ -77,29 +77,4 @@ NETLIB_UPDATE(NE555)
}
NETLIB_START(NE555_dip)
{
NETLIB_NAME(NE555)::start();
register_subalias("1", m_R3.m_N); // Pin 1
register_subalias("2", m_TRIG); // Pin 2
register_subalias("3", m_OUT); // Pin 3
register_subalias("4", m_RESET); // Pin 4
register_subalias("5", m_R1.m_N); // Pin 5
register_subalias("6", m_THRES); // Pin 6
register_subalias("7", m_RDIS.m_P); // Pin 7
register_subalias("8", m_R1.m_P); // Pin 8
}
NETLIB_UPDATE(NE555_dip)
{
NETLIB_NAME(NE555)::update();
}
NETLIB_RESET(NE555_dip)
{
NETLIB_NAME(NE555)::reset();
}
NETLIB_NAMESPACE_DEVICES_END()

15
src/lib/netlist/devices/nld_ne555.h
View File

@ -80,7 +80,20 @@ private:
#define NE555_DIP(_name) \
NET_REGISTER_DEV(NE555_DIP, _name)
NETLIB_DEVICE_DERIVED_PURE(NE555_dip, NE555);
NETLIB_OBJECT_DERIVED(NE555_dip, NE555)
{
NETLIB_CONSTRUCTOR_DERIVED(NE555_dip, NE555)
{
register_subalias("1", m_R3.m_N); // Pin 1
register_subalias("2", m_TRIG); // Pin 2
register_subalias("3", m_OUT); // Pin 3
register_subalias("4", m_RESET); // Pin 4
register_subalias("5", m_R1.m_N); // Pin 5
register_subalias("6", m_THRES); // Pin 6
register_subalias("7", m_RDIS.m_P); // Pin 7
register_subalias("8", m_R1.m_P); // Pin 8
}
};
NETLIB_NAMESPACE_DEVICES_END()

21
src/lib/netlist/devices/nld_r2r_dac.cpp
View File

@ -9,27 +9,6 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_START(r2r_dac)
{
NETLIB_NAME(twoterm)::start();
enregister("VOUT", m_P);
enregister("VGND", m_N);
register_param("R", m_R, 1.0);
register_param("VIN", m_VIN, 1.0);
register_param("N", m_num, 1);
register_param("VAL", m_val, 1);
}
NETLIB_RESET(r2r_dac)
{
NETLIB_NAME(twoterm)::reset();
}
NETLIB_UPDATE(r2r_dac)
{
NETLIB_NAME(twoterm)::update();
}
NETLIB_UPDATE_PARAM(r2r_dac)
{
update_dev();

20
src/lib/netlist/devices/nld_r2r_dac.h
View File

@ -57,12 +57,28 @@
NETLIB_NAMESPACE_DEVICES_START()
NETLIB_DEVICE_WITH_PARAMS_DERIVED(r2r_dac, twoterm,
NETLIB_OBJECT_DERIVED(r2r_dac, twoterm)
{
NETLIB_CONSTRUCTOR_DERIVED(r2r_dac, twoterm)
{
enregister("VOUT", m_P);
enregister("VGND", m_N);
register_param("R", m_R, 1.0);
register_param("VIN", m_VIN, 1.0);
register_param("N", m_num, 1);
register_param("VAL", m_val, 1);
}
NETLIB_UPDATE_PARAMI();
//NETLIB_RESETI();
//NETLIB_UPDATEI();
protected:
param_double_t m_VIN;
param_double_t m_R;
param_int_t m_num;
param_int_t m_val;
);
};
NETLIB_NAMESPACE_DEVICES_END()

161
src/lib/netlist/devices/nld_system.cpp
View File

@ -15,43 +15,11 @@ NETLIB_NAMESPACE_DEVICES_START()
// netlistparams
// ----------------------------------------------------------------------------------------
NETLIB_START(netlistparams)
{
register_param("USE_DEACTIVATE", m_use_deactivate, 0);
}
NETLIB_RESET(netlistparams)
{
}
NETLIB_UPDATE_PARAM(netlistparams)
{
}
NETLIB_UPDATE(netlistparams)
{
}
// ----------------------------------------------------------------------------------------
// clock
// ----------------------------------------------------------------------------------------
NETLIB_START(clock)
{
enregister("Q", m_Q);
enregister("FB", m_feedback);
register_param("FREQ", m_freq, 7159000.0 * 5.0);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
connect_late(m_feedback, m_Q);
}
NETLIB_RESET(clock)
{
}
NETLIB_UPDATE_PARAM(clock)
{
m_inc = netlist_time::from_hz(m_freq.Value()*2);
@ -66,42 +34,6 @@ NETLIB_UPDATE(clock)
// extclock
// ----------------------------------------------------------------------------------------
NETLIB_START(extclock)
{
enregister("Q", m_Q);
enregister("FB", m_feedback);
register_param("FREQ", m_freq, 7159000.0 * 5.0);
register_param("PATTERN", m_pattern, "1,1");
register_param("OFFSET", m_offset, 0.0);
m_inc[0] = netlist_time::from_hz(m_freq.Value()*2);
connect_late(m_feedback, m_Q);
{
netlist_time base = netlist_time::from_hz(m_freq.Value()*2);
pstring_vector_t pat(m_pattern.Value(),",");
m_off = netlist_time::from_double(m_offset.Value());
int pati[256];
m_size = pat.size();
int total = 0;
for (int i=0; i<m_size; i++)
{
pati[i] = pat[i].as_long();
total += pati[i];
}
netlist_time ttotal = netlist_time::zero;
for (int i=0; i<m_size - 1; i++)
{
m_inc[i] = base * pati[i];
ttotal += m_inc[i];
}
m_inc[m_size - 1] = base * total - ttotal;
}
save(NLNAME(m_cnt));
save(NLNAME(m_off));
}
NETLIB_RESET(extclock)
{
m_cnt = 0;
@ -109,10 +41,6 @@ NETLIB_RESET(extclock)
m_Q.initial(0);
}
NETLIB_UPDATE_PARAM(extclock)
{
}
NETLIB_UPDATE(extclock)
{
if (m_cnt != 0)
@ -132,25 +60,6 @@ NETLIB_UPDATE(extclock)
// logic_input
// ----------------------------------------------------------------------------------------
NETLIB_START(logic_input)
{
/* make sure we get the family first */
register_param("FAMILY", m_FAMILY, "FAMILY(TYPE=TTL)");
set_logic_family(netlist().setup().family_from_model(m_FAMILY.Value()));
enregister("Q", m_Q);
register_param("IN", m_IN, 0);
}
NETLIB_RESET(logic_input)
{
}
NETLIB_STOP(logic_input)
{
}
NETLIB_UPDATE(logic_input)
{
OUTLOGIC(m_Q, m_IN.Value() & 1, netlist_time::from_nsec(1));
@ -165,16 +74,6 @@ NETLIB_UPDATE_PARAM(logic_input)
// analog_input
// ----------------------------------------------------------------------------------------
NETLIB_START(analog_input)
{
enregister("Q", m_Q);
register_param("IN", m_IN, 0.0);
}
NETLIB_RESET(analog_input)
{
}
NETLIB_UPDATE(analog_input)
{
OUTANALOG(m_Q, m_IN.Value());
@ -189,22 +88,6 @@ NETLIB_UPDATE_PARAM(analog_input)
// nld_d_to_a_proxy
// ----------------------------------------------------------------------------------------
void nld_d_to_a_proxy::start()
{
nld_base_d_to_a_proxy::start();
register_sub(m_RV);
enregister("1", m_RV.m_P);
enregister("2", m_RV.m_N);
enregister("_Q", m_Q);
register_subalias("Q", m_RV.m_P);
connect_late(m_RV.m_N, m_Q);
save(NLNAME(m_last_state));
}
void nld_d_to_a_proxy::reset()
{
m_Q.initial(0.0);
@ -214,7 +97,7 @@ void nld_d_to_a_proxy::reset()
m_RV.set(NL_FCONST(1.0) / logic_family().m_R_low, logic_family().m_low_V, 0.0);
}
ATTR_HOT void nld_d_to_a_proxy::update()
NETLIB_UPDATE(d_to_a_proxy)
{
const int state = INPLOGIC(m_I);
if (state != m_last_state)
@ -272,48 +155,6 @@ NETLIB_UPDATE_PARAM(res_sw)
* nld_function
* ----------------------------------------------------------------------------- */
NETLIB_START(function)
{
register_param("N", m_N, 2);
register_param("FUNC", m_func, "");
enregister("Q", m_Q);
for (int i=0; i < m_N; i++)
enregister(pfmt("A{1}")(i), m_I[i]);
pstring_vector_t cmds(m_func.Value(), " ");
m_precompiled.clear();
for (std::size_t i=0; i < cmds.size(); i++)
{
pstring cmd = cmds[i];
rpn_inst rc;
if (cmd == "+")
rc.m_cmd = ADD;
else if (cmd == "-")
rc.m_cmd = SUB;
else if (cmd == "*")
rc.m_cmd = MULT;
else if (cmd == "/")
rc.m_cmd = DIV;
else if (cmd.startsWith("A"))
{
rc.m_cmd = PUSH_INPUT;
rc.m_param = cmd.substr(1).as_long();
}
else
{
bool err = false;
rc.m_cmd = PUSH_CONST;
rc.m_param = cmd.as_double(&err);
if (err)
netlist().log().fatal("nld_function: unknown/misformatted token <{1}> in <{2}>", cmd, m_func.Value());
}
m_precompiled.push_back(rc);
}
}
NETLIB_RESET(function)
{
m_Q.initial(0.0);

286
src/lib/netlist/devices/nld_system.h
View File

@ -81,16 +81,51 @@ NETLIB_NAMESPACE_DEVICES_START()
// netlistparams
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(netlistparams,
NETLIB_OBJECT(netlistparams)
{
NETLIB_CONSTRUCTOR(netlistparams)
{
register_param("USE_DEACTIVATE", m_use_deactivate, 0);
}
NETLIB_UPDATEI() { }
//NETLIB_RESETI() { }
NETLIB_UPDATE_PARAMI() { }
public:
param_logic_t m_use_deactivate;
);
param_logic_t m_use_deactivate;
};
// -----------------------------------------------------------------------------
// mainclock
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(mainclock,
NETLIB_OBJECT(mainclock)
{
NETLIB_CONSTRUCTOR(mainclock)
{
enregister("Q", m_Q);
register_param("FREQ", m_freq, 7159000.0 * 5);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
NETLIB_RESETI()
{
m_Q.net().set_time(netlist_time::zero);
}
NETLIB_UPDATE_PARAMI()
{
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
NETLIB_UPDATEI()
{
logic_net_t &net = m_Q.net().as_logic();
// this is only called during setup ...
net.toggle_new_Q();
net.set_time(netlist().time() + m_inc);
}
public:
logic_output_t m_Q;
@ -98,56 +133,134 @@ public:
netlist_time m_inc;
ATTR_HOT inline static void mc_update(logic_net_t &net);
);
};
// -----------------------------------------------------------------------------
// clock
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(clock,
NETLIB_OBJECT(clock)
{
NETLIB_CONSTRUCTOR(clock)
{
enregister("Q", m_Q);
enregister("FB", m_feedback);
register_param("FREQ", m_freq, 7159000.0 * 5.0);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
connect_late(m_feedback, m_Q);
}
NETLIB_UPDATEI();
//NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
protected:
logic_input_t m_feedback;
logic_output_t m_Q;
param_double_t m_freq;
netlist_time m_inc;
);
};
// -----------------------------------------------------------------------------
// extclock
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(extclock,
logic_input_t m_feedback;
logic_output_t m_Q;
NETLIB_OBJECT(extclock)
{
NETLIB_CONSTRUCTOR(extclock)
{
enregister("Q", m_Q);
enregister("FB", m_feedback);
register_param("FREQ", m_freq, 7159000.0 * 5.0);
register_param("PATTERN", m_pattern, "1,1");
register_param("OFFSET", m_offset, 0.0);
m_inc[0] = netlist_time::from_hz(m_freq.Value()*2);
connect_late(m_feedback, m_Q);
{
netlist_time base = netlist_time::from_hz(m_freq.Value()*2);
pstring_vector_t pat(m_pattern.Value(),",");
m_off = netlist_time::from_double(m_offset.Value());
int pati[256];
m_size = pat.size();
int total = 0;
for (int i=0; i<m_size; i++)
{
pati[i] = pat[i].as_long();
total += pati[i];
}
netlist_time ttotal = netlist_time::zero;
for (int i=0; i<m_size - 1; i++)
{
m_inc[i] = base * pati[i];
ttotal += m_inc[i];
}
m_inc[m_size - 1] = base * total - ttotal;
}
save(NLNAME(m_cnt));
save(NLNAME(m_off));
}
NETLIB_UPDATEI();
NETLIB_RESETI();
//NETLIB_UPDATE_PARAMI();
protected:
param_double_t m_freq;
param_str_t m_pattern;
param_double_t m_offset;
UINT8 m_cnt;
UINT8 m_size;
netlist_time m_off;
logic_input_t m_feedback;
logic_output_t m_Q;
UINT32 m_cnt;
UINT32 m_size;
netlist_time m_inc[32];
);
netlist_time m_off;
};
// -----------------------------------------------------------------------------
// Special support devices ...
// -----------------------------------------------------------------------------
NETLIB_DEVICE_WITH_PARAMS(logic_input,
NETLIB_OBJECT(logic_input)
{
NETLIB_CONSTRUCTOR(logic_input)
{
/* make sure we get the family first */
register_param("FAMILY", m_FAMILY, "FAMILY(TYPE=TTL)");
set_logic_family(netlist().setup().family_from_model(m_FAMILY.Value()));
virtual void stop() override;
enregister("Q", m_Q);
register_param("IN", m_IN, 0);
}
NETLIB_UPDATEI();
//NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
protected:
logic_output_t m_Q;
param_logic_t m_IN;
param_model_t m_FAMILY;
);
};
NETLIB_DEVICE_WITH_PARAMS(analog_input,
NETLIB_OBJECT(analog_input)
{
NETLIB_CONSTRUCTOR(analog_input)
{
enregister("Q", m_Q);
register_param("IN", m_IN, 0.0);
}
NETLIB_UPDATEI();
//NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
protected:
analog_output_t m_Q;
param_double_t m_IN;
);
};
// -----------------------------------------------------------------------------
// nld_gnd
@ -155,28 +268,17 @@ NETLIB_DEVICE_WITH_PARAMS(analog_input,
NETLIB_OBJECT(gnd)
{
public:
NETLIB_CONSTRUCTOR(gnd) {}
protected:
void start() override
NETLIB_CONSTRUCTOR(gnd)
{
enregister("Q", m_Q);
}
void reset() override
{
}
void update() override
NETLIB_UPDATEI()
{
OUTANALOG(m_Q, 0.0);
}
private:
NETLIB_RESETI() { }
protected:
analog_output_t m_Q;
};
// -----------------------------------------------------------------------------
@ -186,22 +288,15 @@ private:
NETLIB_OBJECT_DERIVED(dummy_input, base_dummy)
{
public:
NETLIB_CONSTRUCTOR_DERIVED(dummy_input, base_dummy) { }
protected:
void start() override
NETLIB_CONSTRUCTOR_DERIVED(dummy_input, base_dummy)
{
enregister("I", m_I);
}
void reset() override
{
}
protected:
void update() override
{
}
NETLIB_RESETI() { }
NETLIB_UPDATEI() { }
private:
analog_input_t m_I;
@ -218,11 +313,6 @@ public:
NETLIB_CONSTRUCTOR_DERIVED(frontier, base_dummy)
, m_RIN(netlist(), "m_RIN")
, m_ROUT(netlist(), "m_ROUT")
{ }
protected:
void start() override
{
register_param("RIN", m_p_RIN, 1.0e6);
register_param("ROUT", m_p_ROUT, 50.0);
@ -238,13 +328,13 @@ protected:
connect_late(m_Q, m_ROUT.m_P);
}
void reset() override
NETLIB_RESETI()
{
m_RIN.set(1.0 / m_p_RIN.Value(),0,0);
m_ROUT.set(1.0 / m_p_ROUT.Value(),0,0);
}
void update() override
NETLIB_UPDATEI()
{
OUTANALOG(m_Q, INPANALOG(m_I));
}
@ -267,15 +357,53 @@ private:
NETLIB_OBJECT(function)
{
public:
NETLIB_CONSTRUCTOR(function)
{ }
{
register_param("N", m_N, 2);
register_param("FUNC", m_func, "");
enregister("Q", m_Q);
for (int i=0; i < m_N; i++)
enregister(pfmt("A{1}")(i), m_I[i]);
pstring_vector_t cmds(m_func.Value(), " ");
m_precompiled.clear();
for (std::size_t i=0; i < cmds.size(); i++)
{
pstring cmd = cmds[i];
rpn_inst rc;
if (cmd == "+")
rc.m_cmd = ADD;
else if (cmd == "-")
rc.m_cmd = SUB;
else if (cmd == "*")
rc.m_cmd = MULT;
else if (cmd == "/")
rc.m_cmd = DIV;
else if (cmd.startsWith("A"))
{
rc.m_cmd = PUSH_INPUT;
rc.m_param = cmd.substr(1).as_long();
}
else
{
bool err = false;
rc.m_cmd = PUSH_CONST;
rc.m_param = cmd.as_double(&err);
if (err)
netlist().log().fatal("nld_function: unknown/misformatted token <{1}> in <{2}>", cmd, m_func.Value());
}
m_precompiled.push_back(rc);
}
}
protected:
void start() override;
void reset() override;
void update() override;
NETLIB_RESETI();
NETLIB_UPDATEI();
private:
@ -386,6 +514,8 @@ public:
nld_a_to_d_proxy(netlist_t &anetlist, const pstring &name, logic_input_t *in_proxied)
: nld_base_proxy(anetlist, name, in_proxied, &m_I)
{
enregister("I", m_I);
enregister("Q", m_Q);
}
virtual ~nld_a_to_d_proxy() {}
@ -394,17 +524,10 @@ public:
logic_output_t m_Q;
protected:
void start() override
{
enregister("I", m_I);
enregister("Q", m_Q);
}
void reset() override
{
}
NETLIB_RESETI() { }
ATTR_HOT void update() override
NETLIB_UPDATEI()
{
if (m_I.Q_Analog() > logic_family().m_high_thresh_V)
OUTLOGIC(m_Q, 1, NLTIME_FROM_NS(1));
@ -432,10 +555,6 @@ public:
protected:
nld_base_d_to_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *out_proxied, core_terminal_t &proxy_out)
: nld_base_proxy(anetlist, name, out_proxied, &proxy_out)
{
}
virtual void start() override
{
enregister("I", m_I);
}
@ -450,24 +569,32 @@ NETLIB_OBJECT_DERIVED(d_to_a_proxy, base_d_to_a_proxy)
public:
nld_d_to_a_proxy(netlist_t &anetlist, const pstring &name, logic_output_t *out_proxied)
: nld_base_d_to_a_proxy(anetlist, name, out_proxied, m_RV.m_P)
, m_RV(anetlist, "RV")
, m_RV(*this, "RV")
, m_last_state(-1)
, m_is_timestep(false)
{
//register_sub(m_RV);
enregister("1", m_RV.m_P);
enregister("2", m_RV.m_N);
enregister("_Q", m_Q);
register_subalias("Q", m_RV.m_P);
connect_late(m_RV.m_N, m_Q);
save(NLNAME(m_last_state));
}
virtual ~nld_d_to_a_proxy() {}
protected:
virtual void start() override;
virtual void reset() override;
ATTR_HOT void update() override;
NETLIB_RESETI();
NETLIB_UPDATEI();
private:
analog_output_t m_Q;
nld_twoterm m_RV;
NETLIB_SUB(twoterm) m_RV;
int m_last_state;
bool m_is_timestep;
};
@ -493,9 +620,8 @@ public:
anetlist.setup().namespace_pop();
}
protected:
void start() override { }
void reset() override { }
void update() override { }
NETLIB_RESETI() { }
NETLIB_UPDATEI() { }
pstring m_dev_name;
};

120
src/lib/netlist/devices/nld_truthtable.h
View File

@ -128,7 +128,7 @@ public:
m_desc.push_back(*desc);
desc++;
}
startxx();
}
template <class C>
@ -142,9 +142,10 @@ public:
, m_ttp(ttbl)
{
m_desc = desc;
startxx();
}
virtual void start() override
void startxx()
{
pstring header = m_desc[0];
@ -199,7 +200,7 @@ public:
save(NLNAME(m_active));
}
void reset() override
NETLIB_RESETI()
{
m_active = 0;
m_ign = 0;
@ -211,24 +212,69 @@ public:
m_last_state = 0;
}
NETLIB_UPDATEI()
{
process<true>();
}
public:
ATTR_HOT void inc_active() override
{
nl_assert(netlist().use_deactivate());
if (has_state == 0)
if (++m_active == 1)
{
process<false>();
}
}
ATTR_HOT void dec_active() override
{
nl_assert(netlist().use_deactivate());
/* FIXME:
* Based on current measurements there is no point to disable
* 1 input devices. This should actually be a parameter so that we
* can decide for each individual gate whether it is benefitial to
* ignore deactivation.
*/
if (m_NI > 1 && has_state == 0)
if (--m_active == 0)
{
for (unsigned i = 0; i< m_NI; i++)
m_I[i].inactivate();
m_ign = (1<<m_NI)-1;
}
}
logic_input_t m_I[m_NI];
logic_output_t m_Q[m_NO];
protected:
private:
template<bool doOUT>
inline void process()
{
netlist_time mt = netlist_time::zero;
UINT32 state = 0;
for (unsigned i = 0; i < m_NI; i++)
{
if (!doOUT || (m_ign & (1<<i)))
m_I[i].activate();
}
for (unsigned i = 0; i < m_NI; i++)
{
state |= (INPLOGIC(m_I[i]) << i);
if (!doOUT)
if (this->m_I[i].net().time() > mt)
mt = this->m_I[i].net().time();
}
if (m_NI > 1 && !has_state)
for (unsigned i = 0; i < m_NI; i++)
{
if (!doOUT || (m_ign & (1<<i)))
m_I[i].activate();
}
if (!doOUT)
for (unsigned i = 0; i < m_NI; i++)
{
state |= (INPLOGIC(m_I[i]) << i);
mt = std::max(this->m_I[i].net().time(), mt);
}
else
for (unsigned i = 0; i < m_NI; i++)
state |= (INPLOGIC(m_I[i]) << i);
const UINT32 nstate = state | (has_state ? (m_last_state << m_NI) : 0);
const UINT32 outstate = m_ttp->m_outs[nstate];
@ -252,7 +298,7 @@ public:
for (unsigned i = 0; i < m_NO; i++)
m_Q[i].net().set_Q_time((out >> i) & 1, mt + m_ttp->m_timing_nt[m_ttp->m_timing[timebase + i]]);
if (m_NI > 1 || has_state)
if (m_NI > 1 && !has_state)
{
for (unsigned i = 0; i < m_NI; i++)
if (m_ign & (1 << i))
@ -260,48 +306,6 @@ public:
}
}
ATTR_HOT void update() override
{
process<true>();
}
ATTR_HOT void inc_active() override
{
nl_assert(netlist().use_deactivate());
if (has_state == 0)
if (++m_active == 1)
{
process<false>();
}
}
ATTR_HOT void dec_active() override
{
nl_assert(netlist().use_deactivate());
/* FIXME:
* Based on current measurements there is no point to disable
* 1 input devices. This should actually be a parameter so that we
* can decide for each individual gate whether it is benefitial to
* ignore deactivation.
*/
if (m_NI < 2)
return;
else if (has_state == 0)
{
if (--m_active == 0)
{
for (unsigned i = 0; i< m_NI; i++)
m_I[i].inactivate();
m_ign = (1<<m_NI)-1;
}
}
}
logic_input_t m_I[m_NI];
logic_output_t m_Q[m_NO];
private:
UINT32 m_last_state;
UINT32 m_ign;
INT32 m_active;

105
src/lib/netlist/nl_base.cpp
View File

@ -20,6 +20,33 @@ const netlist::netlist_time netlist::netlist_time::zero = netlist::netlist_time(
namespace netlist
{
#if 0
static pmempool p(65536, 16);
void * object_t::operator new (size_t size)
{
return p.alloc(size);
}
void object_t::operator delete (void * mem)
{
if (mem)
p.free(mem);
}
#else
void * object_t::operator new (size_t size)
{
return ::operator new(size);
}
void object_t::operator delete (void * mem)
{
if (mem)
::operator delete(mem);
}
#endif
// ----------------------------------------------------------------------------------------
// logic_family_ttl_t
// ----------------------------------------------------------------------------------------
@ -151,12 +178,6 @@ ATTR_COLD object_t::~object_t()
{
}
ATTR_COLD void object_t::init_object(const pstring &aname)
{
m_name = aname;
save_register();
}
ATTR_COLD void object_t::init_object(netlist_t &nl, const pstring &aname)
{
m_netlist = &nl;
@ -255,14 +276,6 @@ ATTR_COLD void netlist_t::start()
m_gnd = get_single_device<devices::NETLIB_NAME(gnd)>("gnd");
m_params = get_single_device<devices::NETLIB_NAME(netlistparams)>("parameter");
if (m_solver != nullptr)
m_solver->start_dev();
if (m_params != nullptr)
{
m_params->start_dev();
}
m_use_deactivate = (m_params->m_use_deactivate.Value() ? true : false);
/* create devices */
@ -279,11 +292,6 @@ ATTR_COLD void netlist_t::start()
}
}
log().debug("Initializing devices ...\n");
for (auto &dev : m_devices)
if (dev.get() != m_solver && dev.get() != m_params)
dev->start_dev();
}
ATTR_COLD void netlist_t::stop()
@ -365,7 +373,7 @@ ATTR_HOT void netlist_t::process_queue(const netlist_time &delta)
} else {
logic_net_t &mc_net = m_mainclock->m_Q.net().as_logic();
const netlist_time inc = m_mainclock->m_inc;
netlist_time mc_time = mc_net.time();
netlist_time mc_time(mc_net.time());
while (m_time < m_stop)
{
@ -402,9 +410,9 @@ void netlist_t::print_stats() const
{
#if (NL_KEEP_STATISTICS)
{
for (std::size_t i = 0; i < m_started_devices.size(); i++)
for (std::size_t i = 0; i < m_devices.size(); i++)
{
core_device_t *entry = m_started_devices[i];
core_device_t *entry = m_devices[i].get();
printf("Device %20s : %12d %12d %15ld\n", entry->name().cstr(), entry->stat_call_count, entry->stat_update_count, (long int) entry->stat_total_time / (entry->stat_update_count + 1));
}
printf("Queue Pushes %15d\n", queue().m_prof_call);
@ -420,7 +428,7 @@ void netlist_t::print_stats() const
// ----------------------------------------------------------------------------------------
// net_core_device_t
// core_device_t
// ----------------------------------------------------------------------------------------
ATTR_COLD core_device_t::core_device_t(netlist_t &owner, const pstring &name)
@ -448,13 +456,14 @@ ATTR_COLD core_device_t::core_device_t(core_device_t &owner, const pstring &name
if (logic_family() == nullptr)
set_logic_family(family_TTL());
init_object(owner.netlist(), owner.name() +"." + name);
owner.netlist().m_devices.push_back(powned_ptr<core_device_t>(this, false));
}
ATTR_COLD core_device_t::~core_device_t()
{
}
ATTR_COLD void core_device_t::start_dev()
ATTR_COLD void core_device_t::set_delegate_pointer()
{
#if (NL_KEEP_STATISTICS)
netlist().m_started_devices.push_back(this);
@ -468,14 +477,13 @@ ATTR_COLD void core_device_t::start_dev()
#elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL)
m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this);
#endif
start();
}
ATTR_COLD void core_device_t::stop_dev()
{
#if (NL_KEEP_STATISTICS)
#endif
stop();
//stop();
}
ATTR_HOT netlist_sig_t core_device_t::INPLOGIC_PASSIVE(logic_input_t &inp)
@ -506,13 +514,6 @@ ATTR_COLD setup_t &device_t::setup()
return netlist().setup();
}
ATTR_COLD void device_t::register_sub_p(device_t &dev)
{
// subdevices always first inherit the logic family of the parent
//dev.set_logic_family(this->logic_family());
dev.start_dev();
}
ATTR_COLD void device_t::register_subalias(const pstring &name, core_terminal_t &term)
{
pstring alias = this->name() + "." + name;
@ -707,12 +708,24 @@ ATTR_HOT /* inline */ void net_t::update_devs()
m_in_queue = 2; /* mark as taken ... */
m_cur_Q = m_new_Q;
#if 1
for (core_terminal_t *p = m_list_active.first(); p != nullptr; p = p->next())
{
inc_stat(p->device().stat_call_count);
if ((p->state() & mask) != 0)
p->device().update_dev();
}
#else
for (auto p = &m_list_active.m_head; *p != nullptr; )
{
auto pn = &((*p)->m_next);
inc_stat(p->device().stat_call_count);
if (((*p)->state() & mask) != 0)
(*p)->device().update_dev();
p = pn;
}
#endif
}
ATTR_COLD void net_t::reset()
@ -1043,30 +1056,6 @@ ATTR_HOT /* inline */ void NETLIB_NAME(mainclock)::mc_update(logic_net_t &net)
net.update_devs();
}
NETLIB_START(mainclock)
{
enregister("Q", m_Q);
register_param("FREQ", m_freq, 7159000.0 * 5);
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
NETLIB_RESET(mainclock)
{
m_Q.net().set_time(netlist_time::zero);
}
NETLIB_UPDATE_PARAM(mainclock)
{
m_inc = netlist_time::from_hz(m_freq.Value()*2);
}
NETLIB_UPDATE(mainclock)
{
logic_net_t &net = m_Q.net().as_logic();
// this is only called during setup ...
net.toggle_new_Q();
net.set_time(netlist().time() + m_inc);
}
NETLIB_NAMESPACE_DEVICES_END()

158
src/lib/netlist/nl_base.h
View File

@ -180,6 +180,11 @@ using netlist_sig_t = std::uint32_t;
// MACROS / New Syntax
//============================================================
#define NETLIB_NAMESPACE_DEVICES_START() namespace netlist { namespace devices {
#define NETLIB_NAMESPACE_DEVICES_END() }}
#define NETLIB_NAME(_chip) nld_ ## _chip
#define NETLIB_OBJECT_DERIVED(_name, _pclass) \
class NETLIB_NAME(_name) : public NETLIB_NAME(_pclass)
@ -196,38 +201,31 @@ class NETLIB_NAME(_name) : public device_t
public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name) \
: device_t(owner, name)
#define NETLIB_DESTRUCTOR(_name) public: ATTR_HOT virtual ~NETLIB_NAME(_name)()
#define NETLIB_CONSTRUCTOR_EX(_name, _args...) \
private: family_setter_t m_famsetter; \
public: template <class _CLASS> ATTR_COLD NETLIB_NAME(_name)(_CLASS &owner, const pstring name, _args) \
: device_t(owner, name)
#define NETLIB_DYNAMIC() \
ATTR_HOT public: virtual bool is_dynamic1() const override { return true; }
public: ATTR_HOT virtual bool is_dynamic1() const override { return true; }
#define NETLIB_TIMESTEP() \
ATTR_HOT public: virtual bool is_timestep() const override { return true; } \
ATTR_HOT public: void step_time(const nl_double step) override
public: ATTR_HOT virtual bool is_timestep() const override { return true; } \
public: ATTR_HOT virtual void step_time(const nl_double step) override
#define NETLIB_FAMILY(_family) , m_famsetter(*this, _family)
#define NETLIB_UPDATE_TERMINALSI() public: ATTR_HOT virtual void update_terminals(void) override
#define NETLIB_UPDATEI() protected: ATTR_HOT virtual void update(void) override
#define NETLIB_UPDATE_PARAMI() public: ATTR_HOT virtual void update_param(void) override
#define NETLIB_RESETI() protected: ATTR_COLD virtual void reset(void) override
#define NETLIB_UPDATE_TERMINALSI() public: ATTR_HOT virtual void update_terminals() override
#define NETLIB_UPDATEI() protected: ATTR_HOT virtual void update() NOEXCEPT override
#define NETLIB_UPDATE_PARAMI() public: ATTR_HOT virtual void update_param() override
#define NETLIB_RESETI() protected: ATTR_HOT virtual void reset() override
#define NETLIB_SUB(_chip) nld_ ## _chip
//============================================================
// MACROS / netlist devices
//============================================================
#define NETLIB_NAMESPACE_DEVICES_START() namespace netlist { namespace devices {
#define NETLIB_NAMESPACE_DEVICES_END() }}
#define NETLIB_NAME(_chip) nld_ ## _chip
#define NETLIB_SUBXX(_chip) std::unique_ptr< nld_ ## _chip >
#define NETLIB_NAME_STR_S(_s) # _s
#define NETLIB_NAME_STR(_chip) NETLIB_NAME_STR_S(nld_ ## _chip)
#define NETLIB_UPDATE(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update(void)
#define NETLIB_START(_chip) ATTR_COLD void NETLIB_NAME(_chip) :: start(void)
#define NETLIB_UPDATE(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update(void) NOEXCEPT
#define NETLIB_RESET(_chip) ATTR_COLD void NETLIB_NAME(_chip) :: reset(void)
@ -238,53 +236,11 @@ class NETLIB_NAME(_name) : public device_t
#define NETLIB_UPDATE_TERMINALS(_chip) ATTR_HOT void NETLIB_NAME(_chip) :: update_terminals(void)
#define NETLIB_DEVICE_BASE(_name, _pclass, _extra, _priv) \
class _name : public _pclass \
{ \
public: \
template <class C> \
_name(C &owner, const pstring &name) \
: _pclass(owner, name) { } \
protected: \
_extra \
ATTR_HOT void update() override; \
ATTR_HOT void start() override; \
ATTR_HOT void reset() override; \
_priv \
}
#define NETLIB_DEVICE_DERIVED_PURE(_name, _pclass) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), NETLIB_NAME(_pclass), protected:, private:)
//============================================================
// MACROS / netlist devices
//============================================================
#define NETLIB_DEVICE_DERIVED(_name, _pclass, _priv) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), NETLIB_NAME(_pclass), protected:, _priv)
#define NETLIB_DEVICE(_name, _priv) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), device_t, protected:, _priv)
#define NETLIB_SUBDEVICE(_name, _priv) \
class NETLIB_NAME(_name) : public device_t \
{ \
public: \
NETLIB_CONSTRUCTOR(_name) \
{ } \
/*protected:*/ \
ATTR_HOT void update() override; \
ATTR_HOT void start() override; \
ATTR_HOT void reset() override; \
public: \
_priv \
}
#define NETLIB_DEVICE_WITH_PARAMS(_name, _priv) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), device_t, \
ATTR_HOT void update_param() override; \
, _priv)
#define NETLIB_DEVICE_WITH_PARAMS_DERIVED(_name, _pclass, _priv) \
NETLIB_DEVICE_BASE(NETLIB_NAME(_name), NETLIB_NAME(_pclass), \
ATTR_HOT void update_param() override; \
, _priv)
//============================================================
// Asserts
@ -415,7 +371,6 @@ namespace netlist
virtual ~object_t();
ATTR_COLD void init_object(const pstring &aname);
ATTR_COLD void init_object(netlist_t &nl, const pstring &aname);
ATTR_COLD bool isInitialized() { return (m_netlist != nullptr); }
@ -437,14 +392,20 @@ namespace netlist
protected:
virtual void reset() = 0;
virtual void reset() { }
// must call parent save_register !
virtual void save_register() { };
virtual void save_register() { }
private:
pstring m_name;
const type_t m_objtype;
netlist_t * m_netlist;
#if 1
public:
void * operator new (size_t size);
void operator delete (void * mem);
#endif
};
// -----------------------------------------------------------------------------
@ -725,15 +686,15 @@ namespace netlist
ATTR_HOT void update_devs();
ATTR_HOT const netlist_time &time() const { return m_time; }
ATTR_HOT const netlist_time time() const { return m_time; }
ATTR_HOT void set_time(const netlist_time &ntime) { m_time = ntime; }
ATTR_HOT bool isRailNet() const { return !(m_railterminal == nullptr); }
ATTR_HOT core_terminal_t & railterminal() const { return *m_railterminal; }
ATTR_HOT void push_to_queue(const netlist_time &delay);
ATTR_HOT void reschedule_in_queue(const netlist_time &delay);
ATTR_HOT bool is_queued() const { return m_in_queue == 1; }
ATTR_HOT void push_to_queue(const netlist_time &delay) NOEXCEPT;
ATTR_HOT void reschedule_in_queue(const netlist_time &delay) NOEXCEPT;
ATTR_HOT bool is_queued() const { return m_in_queue == 1; }
ATTR_HOT int num_cons() const { return m_core_terms.size(); }
@ -801,7 +762,7 @@ namespace netlist
return m_new_Q;
}
ATTR_HOT void set_Q(const netlist_sig_t &newQ, const netlist_time &delay)
ATTR_HOT void set_Q(const netlist_sig_t &newQ, const netlist_time &delay) NOEXCEPT
{
if (newQ != m_new_Q)
{
@ -901,7 +862,7 @@ namespace netlist
ATTR_COLD void initial(const netlist_sig_t val);
ATTR_HOT void set_Q(const netlist_sig_t newQ, const netlist_time &delay)
ATTR_HOT void set_Q(const netlist_sig_t newQ, const netlist_time &delay) NOEXCEPT
{
net().as_logic().set_Q(newQ, delay);
}
@ -1050,7 +1011,7 @@ namespace netlist
end_timing(stat_total_time);
}
ATTR_HOT void do_update()
ATTR_HOT void do_update() NOEXCEPT
{
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
(this->*m_static_update)();
@ -1061,7 +1022,7 @@ namespace netlist
#endif
}
ATTR_COLD void start_dev();
ATTR_COLD void set_delegate_pointer();
ATTR_COLD void stop_dev();
ATTR_HOT netlist_sig_t INPLOGIC_PASSIVE(logic_input_t &inp);
@ -1072,7 +1033,7 @@ namespace netlist
return inp.Q();
}
ATTR_HOT void OUTLOGIC(logic_output_t &out, const netlist_sig_t val, const netlist_time &delay)
ATTR_HOT void OUTLOGIC(logic_output_t &out, const netlist_sig_t val, const netlist_time &delay) NOEXCEPT
{
out.set_Q(val, delay);
}
@ -1099,9 +1060,8 @@ namespace netlist
protected:
ATTR_HOT virtual void update() { }
virtual void start() { }
virtual void stop() { }
/*ATTR_HOT*/ virtual void update() NOEXCEPT { }
ATTR_HOT virtual void stop() { }
public:
ATTR_HOT virtual void step_time(ATTR_UNUSED const nl_double st) { }
@ -1139,18 +1099,11 @@ namespace netlist
ATTR_COLD setup_t &setup();
#if 1
template<class C>
void register_sub(const pstring &name, std::unique_ptr<C> &dev)
{
dev.reset(new C(*this, name));
register_sub_p(*dev);
}
#if 1
void register_sub(device_t &dev)
{
register_sub_p(dev);
}
#endif
@ -1170,9 +1123,8 @@ namespace netlist
protected:
ATTR_HOT virtual void update() override { }
ATTR_HOT virtual void start() override { }
ATTR_HOT virtual void update_terminals() override { }
NETLIB_UPDATEI() { }
NETLIB_UPDATE_TERMINALSI() { }
template <class C, class T>
ATTR_COLD void register_param(const pstring &sname, C &param, const T initialVal);
@ -1249,12 +1201,12 @@ namespace netlist
ATTR_HOT const queue_t &queue() const { return m_queue; }
ATTR_HOT queue_t &queue() { return m_queue; }
ATTR_HOT const netlist_time &time() const { return m_time; }
ATTR_HOT const netlist_time time() const { return m_time; }
ATTR_HOT devices::NETLIB_NAME(solver) *solver() const { return m_solver; }
ATTR_HOT devices::NETLIB_NAME(gnd) *gnd() const { return m_gnd; }
ATTR_HOT nl_double gmin() const;
ATTR_HOT void push_to_queue(net_t &out, const netlist_time &attime);
ATTR_HOT void push_to_queue(net_t &out, const netlist_time &attime) NOEXCEPT;
ATTR_HOT void remove_from_queue(net_t &out);
ATTR_HOT void process_queue(const netlist_time &delta);
@ -1313,7 +1265,7 @@ namespace netlist
void print_stats() const;
pvector_t<powned_ptr<device_t>> m_devices;
pvector_t<powned_ptr<core_device_t>> m_devices;
/* sole use is to manage lifetime of net objects */
net_t::list_t m_nets;
@ -1392,25 +1344,25 @@ protected:
ATTR_HOT inline logic_net_t & net_t::as_logic()
{
nl_assert(is_logic());
return static_cast<logic_net_t &>(*this);
return reinterpret_cast<logic_net_t &>(*this);
}
ATTR_HOT inline const logic_net_t & net_t::as_logic() const
{
nl_assert(is_logic());
return static_cast<const logic_net_t &>(*this);
return reinterpret_cast<const logic_net_t &>(*this);
}
ATTR_HOT inline analog_net_t & net_t::as_analog()
{
nl_assert(is_analog());
return static_cast<analog_net_t &>(*this);
return reinterpret_cast<analog_net_t &>(*this);
}
ATTR_HOT inline const analog_net_t & net_t::as_analog() const
{
nl_assert(is_analog());
return static_cast<const analog_net_t &>(*this);
return reinterpret_cast<const analog_net_t &>(*this);
}
@ -1451,7 +1403,7 @@ protected:
}
ATTR_HOT inline void net_t::push_to_queue(const netlist_time &delay)
ATTR_HOT inline void net_t::push_to_queue(const netlist_time &delay) NOEXCEPT
{
if (!is_queued() && (num_cons() > 0))
{
@ -1464,7 +1416,7 @@ protected:
}
}
ATTR_HOT inline void net_t::reschedule_in_queue(const netlist_time &delay)
ATTR_HOT inline void net_t::reschedule_in_queue(const netlist_time &delay) NOEXCEPT
{
if (is_queued())
netlist().remove_from_queue(*this);
@ -1507,7 +1459,7 @@ protected:
}
}
ATTR_HOT inline void netlist_t::push_to_queue(net_t &out, const netlist_time &attime)
ATTR_HOT inline void netlist_t::push_to_queue(net_t &out, const netlist_time &attime) NOEXCEPT
{
m_queue.push(queue_t::entry_t(attime, &out));
}

4
src/lib/netlist/nl_config.h
View File

@ -14,6 +14,8 @@
// SETUP
//============================================================
#define NOEXCEPT noexcept
/*
* The following options determine how object::update is called.
* NL_PMF_TYPE_VIRTUAL
@ -52,7 +54,7 @@
*/
// This will be autodetected
#define NL_PMF_TYPE 0
//#define NL_PMF_TYPE 0
#define NL_PMF_TYPE_VIRTUAL 0
#define NL_PMF_TYPE_GNUC_PMF 1

3
src/lib/netlist/nl_dice_compat.h
View File

@ -39,6 +39,9 @@ sed -e 's/#define \(.*\)"\(.*\)"[ \t]*,[ \t]*\(.*\)/NET_ALIAS(\1,\2.\3)/' src/ma
* a temporary support and not be used in commits.
*/
#define NETLIB_NAME_STR_S(_s) # _s
#define NETLIB_NAME_STR(_chip) NETLIB_NAME_STR_S(nld_ ## _chip)
#ifndef NL_CONVERT_CPP
#ifndef NETLIST_DEVELOPMENT
#define NETLIST_DEVELOPMENT 0

21
src/lib/netlist/nl_lists.h
View File

@ -33,16 +33,19 @@ namespace netlist
public:
ATTR_HOT entry_t()
: m_exec_time(), m_object() {}
ATTR_HOT entry_t(const _Time &atime, const _Element &elem) : m_exec_time(atime), m_object(elem) {}
ATTR_HOT entry_t(entry_t &&right) NOEXCEPT
: m_exec_time(right.m_exec_time), m_object(right.m_object) {}
ATTR_HOT entry_t(const entry_t &right) NOEXCEPT
: m_exec_time(right.m_exec_time), m_object(right.m_object) {}
ATTR_HOT entry_t(const _Time &atime, const _Element &elem) NOEXCEPT
: m_exec_time(atime), m_object(elem) {}
ATTR_HOT const _Time &exec_time() const { return m_exec_time; }
ATTR_HOT const _Element &object() const { return m_object; }
ATTR_HOT entry_t &operator=(const entry_t &right) {
ATTR_HOT entry_t &operator=(const entry_t &right) NOEXCEPT {
m_exec_time = right.m_exec_time;
m_object = right.m_object;
return *this;
}
private:
_Time m_exec_time;
_Element m_object;
@ -61,13 +64,13 @@ namespace netlist
ATTR_HOT bool is_empty() const { return (m_end == &m_list[1]); }
ATTR_HOT bool is_not_empty() const { return (m_end > &m_list[1]); }
ATTR_HOT void push(const entry_t &e)
ATTR_HOT void push(const entry_t &e) NOEXCEPT
{
#if HAS_OPENMP && USE_OPENMP
/* Lock */
while (m_lock.exchange(1)) { }
#endif
const _Time &t = e.exec_time();
const _Time t = e.exec_time();
entry_t * i = m_end++;
for (; t > (i - 1)->exec_time(); i--)
{
@ -83,17 +86,17 @@ namespace netlist
//nl_assert(m_end - m_list < _Size);
}
ATTR_HOT const entry_t & pop()
ATTR_HOT const entry_t & pop() NOEXCEPT
{
return *(--m_end);
}
ATTR_HOT const entry_t & top() const
ATTR_HOT const entry_t & top() const NOEXCEPT
{
return *(m_end-1);
}
ATTR_HOT void remove(const _Element &elem)
ATTR_HOT void remove(const _Element &elem) NOEXCEPT
{
/* Lock */
#if HAS_OPENMP && USE_OPENMP

17
src/lib/netlist/nl_setup.cpp
View File

@ -501,8 +501,7 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out)
out_cast.logic_family()->create_d_a_proxy(netlist(), x, &out_cast);
m_proxy_cnt++;
proxy = new_proxy.get();
new_proxy->start_dev();
//new_proxy->start_dev();
/* connect all existing terminals to new net */
@ -515,9 +514,10 @@ devices::nld_base_proxy *setup_t::get_d_a_proxy(core_terminal_t &out)
out.net().m_core_terms.clear(); // clear the list
out.net().register_con(new_proxy->in());
out_cast.set_proxy(new_proxy.get());
out_cast.set_proxy(proxy);
proxy = new_proxy.get();
register_dev_s(std::move(new_proxy));
}
return proxy;
@ -533,8 +533,6 @@ void setup_t::connect_input_output(core_terminal_t &in, core_terminal_t &out)
incast.set_proxy(proxy.get());
m_proxy_cnt++;
proxy->start_dev();
proxy->m_Q.net().register_con(in);
out.net().register_con(proxy->m_I);
@ -573,7 +571,6 @@ void setup_t::connect_terminal_input(terminal_t &term, core_terminal_t &inp)
incast.set_proxy(proxy.get());
m_proxy_cnt++;
proxy->start_dev();
connect_terminals(term, proxy->m_I);
if (inp.has_net())
@ -837,6 +834,12 @@ void setup_t::resolve_inputs()
else
netlist().solver()->post_start();
/* finally, set the pointers */
log().debug("Initializing devices ...\n");
for (auto &dev : netlist().m_devices)
dev->set_delegate_pointer();
}
void setup_t::start_devices()
@ -901,8 +904,6 @@ const logic_family_desc_t *setup_t::family_from_model(const pstring &model)
auto retp = ret.get();
printf("placing %s in cache\n", model.cstr());
//netlist().m_family_cache.push_back(std::pair<pstring, std::unique_ptr<logic_family_desc_t>>(model, std::move(ret)));
netlist().m_family_cache.emplace_back(model, std::move(ret));
return retp;

5
src/lib/netlist/nl_time.h
View File

@ -42,7 +42,10 @@ namespace netlist
static const INTERNALTYPE RESOLUTION = NETLIST_INTERNAL_RES;
ATTR_HOT netlist_time() : m_time(0) {}
ATTR_HOT netlist_time(const netlist_time &rhs) : m_time(rhs.m_time) {}
//ATTR_HOT netlist_time(const netlist_time &rhs) NOEXCEPT : m_time(rhs.m_time) {}
//ATTR_HOT netlist_time(netlist_time &&rhs) NOEXCEPT : m_time(rhs.m_time) {}
ATTR_HOT netlist_time(const netlist_time &rhs) NOEXCEPT = default;
ATTR_HOT netlist_time(netlist_time &&rhs) NOEXCEPT = default;
ATTR_HOT friend const netlist_time operator-(const netlist_time &left, const netlist_time &right);
ATTR_HOT friend const netlist_time operator+(const netlist_time &left, const netlist_time &right);

73
src/lib/netlist/plib/palloc.cpp
View File

@ -54,3 +54,76 @@ void pfree_raw(void *p)
_mm_free(p);
}
#endif
pmempool::pmempool(int min_alloc, int min_align)
: m_min_alloc(min_alloc), m_min_align(min_align)
{
}
pmempool::~pmempool()
{
for (auto & b : m_blocks)
{
if (b.m_num_alloc != 0)
fprintf(stderr, "Found block with dangling allocations\n");
delete b.data;
}
m_blocks.clear();
}
int pmempool::new_block()
{
block b;
b.data = new char[m_min_alloc];
b.cur_ptr = b.data;
b.m_free = m_min_alloc;
b.m_num_alloc = 0;
m_blocks.push_back(b);
return m_blocks.size() - 1;
}
void *pmempool::alloc(size_t size)
{
size_t rs = (size + sizeof(info) + m_min_align - 1) & ~(m_min_align - 1);
for (int bn=0; bn < m_blocks.size(); bn++)
{
auto &b = m_blocks[bn];
if (b.m_free > rs)
{
b.m_free -= rs;
b.m_num_alloc++;
info *i = (info *) b.cur_ptr;
i->m_block = bn;
void *ret = (void *) (b.cur_ptr + sizeof(info));
b.cur_ptr += rs;
return ret;
}
}
{
int bn = new_block();
auto &b = m_blocks[bn];
b.m_num_alloc = 1;
b.m_free = m_min_alloc - rs;
info *i = (info *) b.cur_ptr;
i->m_block = bn;
void *ret = (void *) (b.cur_ptr + sizeof(info));
b.cur_ptr += rs;
return ret;
}
}
void pmempool::free(void *ptr)
{
char *p = (char *) ptr;
info *i = (info *) (p - sizeof(info));
block *b = &m_blocks[i->m_block];
if (b->m_num_alloc == 0)
fprintf(stderr, "Argh .. double free\n");
else
{
b->m_free = m_min_alloc;
b->cur_ptr = b->data;
}
b->m_num_alloc--;
}

35
src/lib/netlist/plib/palloc.h
View File

@ -9,6 +9,7 @@
#define PALLOC_H_
#include <exception>
#include <vector>
#include "pconfig.h"
#include "pstring.h"
@ -117,4 +118,38 @@ inline void pfree_array_t(T *p)
#endif
class pmempool
{
private:
struct block
{
block() : m_num_alloc(0), m_free(0), cur_ptr(nullptr), data(nullptr) { }
int m_num_alloc;
int m_free;
char *cur_ptr;
char *data;
};
int new_block();
struct info
{
info() : m_block(0) { }
size_t m_block;
};
public:
pmempool(int min_alloc, int min_align);
~pmempool();
void *alloc(size_t size);
void free(void *ptr);
int m_min_alloc;
int m_min_align;
std::vector<block> m_blocks;
};
#endif /* NLCONFIG_H_ */

10
src/lib/netlist/plib/plists.h
View File

@ -156,7 +156,7 @@ public:
plinkedlist_element_t() : m_next(nullptr) {}
_ListClass *next() const { return m_next; }
private:
//private:
_ListClass * m_next;
};
@ -166,13 +166,13 @@ class plinkedlist_t
public:
plinkedlist_t() : m_head(nullptr) {}
#if 0
ATTR_HOT void insert(const _ListClass &before, _ListClass &elem)
{
if (m_head == &before)
{
elem.m_next = m_head;
m_head = elem;
m_head = &elem;
}
else
{
@ -190,7 +190,7 @@ public:
//throw pexception("element not found");
}
}
#endif
ATTR_HOT void insert(_ListClass &elem)
{
elem.m_next = m_head;
@ -222,7 +222,7 @@ public:
ATTR_HOT void clear() { m_head = nullptr; }
ATTR_HOT bool is_empty() const { return (m_head == nullptr); }
private:
//private:
_ListClass *m_head;
};
#else

1
src/lib/netlist/prg/nltool.cpp
View File

@ -304,7 +304,6 @@ static void listdevices()
pstring terms("");
auto d = f->Create(nt.setup().netlist(), pfmt("dummy{1}")(i));
d->start_dev();
// get the list of terminals ...
for (unsigned j=0; j < d->m_terminals.size(); j++)

37
src/lib/netlist/solver/nld_matrix_solver.h
View File

@ -85,29 +85,52 @@ public:
};
matrix_solver_t(netlist_t &anetlist, const pstring &name,
const eSortType sort, const solver_parameters_t *params);
const eSortType sort, const solver_parameters_t *params)
: device_t(anetlist, name),
m_stat_calculations(0),
m_stat_newton_raphson(0),
m_stat_vsolver_calls(0),
m_iterative_fail(0),
m_iterative_total(0),
m_params(*params),
m_cur_ts(0),
m_sort(sort)
{
enregister("Q_sync", m_Q_sync);
enregister("FB_sync", m_fb_sync);
connect_post_start(m_fb_sync, m_Q_sync);
save(NLNAME(m_last_step));
save(NLNAME(m_cur_ts));
save(NLNAME(m_stat_calculations));
save(NLNAME(m_stat_newton_raphson));
save(NLNAME(m_stat_vsolver_calls));
save(NLNAME(m_iterative_fail));
save(NLNAME(m_iterative_total));
}
virtual ~matrix_solver_t();
void setup(analog_net_t::list_t &nets) { vsetup(nets); }
netlist_time solve_base();
const netlist_time solve_base();
netlist_time solve();
const netlist_time solve();
inline bool has_dynamic_devices() const { return m_dynamic_devices.size() > 0; }
inline bool has_timestep_devices() const { return m_step_devices.size() > 0; }
void update_forced();
void update_after(const netlist_time after)
void update_after(const netlist_time &after)
{
m_Q_sync.net().reschedule_in_queue(after);
}
/* netdevice functions */
virtual void update() override;
virtual void start() override;
virtual void reset() override;
NETLIB_UPDATEI();
NETLIB_RESETI();
public:
ATTR_COLD int get_net_idx(net_t *net);
plog_base<NL_DEBUG> &log() { return netlist().log(); }

78
src/lib/netlist/solver/nld_solver.cpp
View File

@ -94,20 +94,6 @@ ATTR_COLD void terms_t::set_pointers()
// matrix_solver
// ----------------------------------------------------------------------------------------
ATTR_COLD matrix_solver_t::matrix_solver_t(netlist_t &anetlist, const pstring &name,
const eSortType sort, const solver_parameters_t *params)
: device_t(anetlist, name),
m_stat_calculations(0),
m_stat_newton_raphson(0),
m_stat_vsolver_calls(0),
m_iterative_fail(0),
m_iterative_total(0),
m_params(*params),
m_cur_ts(0),
m_sort(sort)
{
}
ATTR_COLD matrix_solver_t::~matrix_solver_t()
{
m_inps.clear_and_free();
@ -391,28 +377,12 @@ void matrix_solver_t::update_dynamic()
m_dynamic_devices[i]->update_terminals();
}
ATTR_COLD void matrix_solver_t::start()
{
enregister("Q_sync", m_Q_sync);
enregister("FB_sync", m_fb_sync);
connect_post_start(m_fb_sync, m_Q_sync);
save(NLNAME(m_last_step));
save(NLNAME(m_cur_ts));
save(NLNAME(m_stat_calculations));
save(NLNAME(m_stat_newton_raphson));
save(NLNAME(m_stat_vsolver_calls));
save(NLNAME(m_iterative_fail));
save(NLNAME(m_iterative_total));
}
ATTR_COLD void matrix_solver_t::reset()
{
m_last_step = netlist_time::zero;
}
ATTR_COLD void matrix_solver_t::update()
ATTR_COLD void matrix_solver_t::update() NOEXCEPT
{
const netlist_time new_timestep = solve();
@ -435,7 +405,7 @@ void matrix_solver_t::step(const netlist_time &delta)
m_step_devices[k]->step_time(dd);
}
netlist_time matrix_solver_t::solve_base()
const netlist_time matrix_solver_t::solve_base()
{
m_stat_vsolver_calls++;
if (has_dynamic_devices())
@ -465,7 +435,7 @@ netlist_time matrix_solver_t::solve_base()
return this->compute_next_timestep();
}
netlist_time matrix_solver_t::solve()
const netlist_time matrix_solver_t::solve()
{
const netlist_time now = netlist().time();
const netlist_time delta = now - m_last_step;
@ -591,46 +561,10 @@ void matrix_solver_t::log_stats()
NETLIB_START(solver)
{
enregister("Q_step", m_Q_step);
register_param("SYNC_DELAY", m_sync_delay, NLTIME_FROM_NS(10).as_double());
register_param("FREQ", m_freq, 48000.0);
/* iteration parameters */
register_param("SOR_FACTOR", m_sor, 1.059);
register_param("ITERATIVE", m_iterative_solver, "SOR");
register_param("ACCURACY", m_accuracy, 1e-7);
register_param("GS_THRESHOLD", m_gs_threshold, 6); // below this value, gaussian elimination is used
register_param("GS_LOOPS", m_gs_loops, 9); // Gauss-Seidel loops
/* general parameters */
register_param("GMIN", m_gmin, NETLIST_GMIN_DEFAULT);
register_param("PIVOT", m_pivot, 0); // use pivoting - on supported solvers
register_param("NR_LOOPS", m_nr_loops, 250); // Newton-Raphson loops
register_param("PARALLEL", m_parallel, 0);
/* automatic time step */
register_param("DYNAMIC_TS", m_dynamic, 0);
register_param("DYNAMIC_LTE", m_lte, 5e-5); // diff/timestep
register_param("MIN_TIMESTEP", m_min_timestep, 1e-6); // nl_double timestep resolution
register_param("LOG_STATS", m_log_stats, 1); // nl_double timestep resolution
// internal staff
enregister("FB_step", m_fb_step);
connect_late(m_fb_step, m_Q_step);
}
NETLIB_RESET(solver)
{
for (std::size_t i = 0; i < m_mat_solvers.size(); i++)
m_mat_solvers[i]->reset();
m_mat_solvers[i]->do_reset();
}
@ -891,8 +825,8 @@ ATTR_COLD void NETLIB_NAME(solver)::post_start()
break;
}
register_sub(*ms);
// FIXME ...
ms->set_delegate_pointer();
ms->setup(grp);
m_mat_solvers.push_back(ms);

48
src/lib/netlist/solver/nld_solver.h
View File

@ -51,11 +51,42 @@ struct solver_parameters_t
class matrix_solver_t;
class NETLIB_NAME(solver) : public device_t
NETLIB_OBJECT(solver)
{
public:
NETLIB_NAME(solver)(netlist_t &anetlist, const pstring &name)
: device_t(anetlist, name) { }
NETLIB_CONSTRUCTOR(solver)
{
enregister("Q_step", m_Q_step);
register_param("SYNC_DELAY", m_sync_delay, NLTIME_FROM_NS(10).as_double());
register_param("FREQ", m_freq, 48000.0);
/* iteration parameters */
register_param("SOR_FACTOR", m_sor, 1.059);
register_param("ITERATIVE", m_iterative_solver, "SOR");
register_param("ACCURACY", m_accuracy, 1e-7);
register_param("GS_THRESHOLD", m_gs_threshold, 6); // below this value, gaussian elimination is used
register_param("GS_LOOPS", m_gs_loops, 9); // Gauss-Seidel loops
/* general parameters */
register_param("GMIN", m_gmin, NETLIST_GMIN_DEFAULT);
register_param("PIVOT", m_pivot, 0); // use pivoting - on supported solvers
register_param("NR_LOOPS", m_nr_loops, 250); // Newton-Raphson loops
register_param("PARALLEL", m_parallel, 0);
/* automatic time step */
register_param("DYNAMIC_TS", m_dynamic, 0);
register_param("DYNAMIC_LTE", m_lte, 5e-5); // diff/timestep
register_param("MIN_TIMESTEP", m_min_timestep, 1e-6); // nl_double timestep resolution
register_param("LOG_STATS", m_log_stats, 1); // nl_double timestep resolution
// internal staff
enregister("FB_step", m_fb_step);
connect_late(m_fb_step, m_Q_step);
}
virtual ~NETLIB_NAME(solver)();
@ -66,12 +97,11 @@ public:
void create_solver_code(postream &strm);
protected:
void update() override;
void start() override;
void reset() override;
void update_param() override;
NETLIB_UPDATEI();
NETLIB_RESETI();
NETLIB_UPDATE_PARAMI();
protected:
logic_input_t m_fb_step;
logic_output_t m_Q_step;