// license:BSD-3-Clause // copyright-holders:K.Wilkins /************************************************************************ * * MAME - Discrete sound system emulation library * * Written by K.Wilkins (mame@esplexo.co.uk) * * (c) K.Wilkins 2000 * *********************************************************************** * * DST_CRFILTER - Simple CR filter & also highpass filter * DST_FILTER1 - Generic 1st order filter * DST_FILTER2 - Generic 2nd order filter * DST_OP_AMP_FILT - Op Amp filter circuits * DST_RC_CIRCUIT_1 - RC charge/discharge circuit * DST_RCDISC - Simple discharging RC * DST_RCDISC2 - Simple charge R1/C, discharge R0/C * DST_RCDISC3 - Simple charge R1/c, discharge R0*R1/(R0+R1)/C * DST_RCDISC4 - Various charge/discharge circuits * DST_RCDISC5 - Diode in series with R//C * DST_RCDISC_MOD - RC triggered by logic and modulated * DST_RCFILTER - Simple RC filter & also lowpass filter * DST_RCFILTER_SW - Usage of node_description values for switchable RC filter * DST_RCINTEGRATE - Two diode inputs, transistor and a R/C charge * discharge network * DST_SALLEN_KEY - Sallen-Key filter circuit * ************************************************************************/ /************************************************************************ * * DST_CRFILTER - Usage of node_description values for CR filter * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * input[4] - Voltage reference. Usually 0V. * ************************************************************************/ #define DST_CRFILTER__IN DISCRETE_INPUT(0) #define DST_CRFILTER__R DISCRETE_INPUT(1) #define DST_CRFILTER__C DISCRETE_INPUT(2) #define DST_CRFILTER__VREF DISCRETE_INPUT(3) DISCRETE_STEP(dst_crfilter) { if (UNEXPECTED(m_has_rc_nodes)) { double rc = DST_CRFILTER__R * DST_CRFILTER__C; if (rc != m_rc) { m_rc = rc; m_exponent = RC_CHARGE_EXP(rc); } } double v_out = DST_CRFILTER__IN - m_vCap; double v_diff = v_out - DST_CRFILTER__VREF; set_output(0, v_out); m_vCap += v_diff * m_exponent; } DISCRETE_RESET(dst_crfilter) { m_has_rc_nodes = this->input_is_node() & 0x6; m_rc = DST_CRFILTER__R * DST_CRFILTER__C; m_exponent = RC_CHARGE_EXP(m_rc); m_vCap = 0; set_output(0, DST_CRFILTER__IN); } /************************************************************************ * * DST_FILTER1 - Generic 1st order filter * * input[0] - Enable input value * input[1] - input value * input[2] - Frequency value (initialization only) * input[3] - Filter type (initialization only) * ************************************************************************/ #define DST_FILTER1__ENABLE DISCRETE_INPUT(0) #define DST_FILTER1__IN DISCRETE_INPUT(1) #define DST_FILTER1__FREQ DISCRETE_INPUT(2) #define DST_FILTER1__TYPE DISCRETE_INPUT(3) static void calculate_filter1_coefficients(discrete_base_node *node, double fc, double type, struct discrete_filter_coeff &coeff) { double den, w, two_over_T; /* calculate digital filter coefficents */ /*w = 2.0*M_PI*fc; no pre-warping */ w = node->sample_rate()*2.0*tan(M_PI*fc/node->sample_rate()); /* pre-warping */ two_over_T = 2.0*node->sample_rate(); den = w + two_over_T; coeff.a1 = (w - two_over_T)/den; if (type == DISC_FILTER_LOWPASS) { coeff.b0 = coeff.b1 = w/den; } else if (type == DISC_FILTER_HIGHPASS) { coeff.b0 = two_over_T/den; coeff.b1 = -(coeff.b0); } else { /* FIXME: reenable */ //node->m_device->discrete_log("calculate_filter1_coefficients() - Invalid filter type for 1st order filter."); } } DISCRETE_STEP(dst_filter1) { double gain = 1.0; double v_out; if (DST_FILTER1__ENABLE == 0.0) { gain = 0.0; } v_out = -m_fc.a1*m_fc.y1 + m_fc.b0*gain*DST_FILTER1__IN + m_fc.b1*m_fc.x1; m_fc.x1 = gain*DST_FILTER1__IN; m_fc.y1 = v_out; set_output(0, v_out); } DISCRETE_RESET(dst_filter1) { calculate_filter1_coefficients(this, DST_FILTER1__FREQ, DST_FILTER1__TYPE, m_fc); set_output(0, 0); } /************************************************************************ * * DST_FILTER2 - Generic 2nd order filter * * input[0] - Enable input value * input[1] - input value * input[2] - Frequency value (initialization only) * input[3] - Damping value (initialization only) * input[4] - Filter type (initialization only) * ************************************************************************/ #define DST_FILTER2__ENABLE DISCRETE_INPUT(0) #define DST_FILTER2__IN DISCRETE_INPUT(1) #define DST_FILTER2__FREQ DISCRETE_INPUT(2) #define DST_FILTER2__DAMP DISCRETE_INPUT(3) #define DST_FILTER2__TYPE DISCRETE_INPUT(4) static void calculate_filter2_coefficients(discrete_base_node *node, double fc, double d, double type, struct discrete_filter_coeff &coeff) { double w; /* cutoff freq, in radians/sec */ double w_squared; double den; /* temp variable */ double two_over_T = 2 * node->sample_rate(); double two_over_T_squared = two_over_T * two_over_T; /* calculate digital filter coefficents */ /*w = 2.0*M_PI*fc; no pre-warping */ w = node->sample_rate() * 2.0 * tan(M_PI * fc / node->sample_rate()); /* pre-warping */ w_squared = w * w; den = two_over_T_squared + d*w*two_over_T + w_squared; coeff.a1 = 2.0 * (-two_over_T_squared + w_squared) / den; coeff.a2 = (two_over_T_squared - d * w * two_over_T + w_squared) / den; if (type == DISC_FILTER_LOWPASS) { coeff.b0 = coeff.b2 = w_squared/den; coeff.b1 = 2.0 * (coeff.b0); } else if (type == DISC_FILTER_BANDPASS) { coeff.b0 = d * w * two_over_T / den; coeff.b1 = 0.0; coeff.b2 = -(coeff.b0); } else if (type == DISC_FILTER_HIGHPASS) { coeff.b0 = coeff.b2 = two_over_T_squared / den; coeff.b1 = -2.0 * (coeff.b0); } else { /* FIXME: reenable */ //node->device->discrete_log("calculate_filter2_coefficients() - Invalid filter type for 2nd order filter."); } } DISCRETE_STEP(dst_filter2) { double gain = 1.0; double v_out; if (DST_FILTER2__ENABLE == 0.0) { gain = 0.0; } v_out = -m_fc.a1 * m_fc.y1 - m_fc.a2 * m_fc.y2 + m_fc.b0 * gain * DST_FILTER2__IN + m_fc.b1 * m_fc.x1 + m_fc.b2 * m_fc.x2; m_fc.x2 = m_fc.x1; m_fc.x1 = gain * DST_FILTER2__IN; m_fc.y2 = m_fc.y1; m_fc.y1 = v_out; set_output(0, v_out); } DISCRETE_RESET(dst_filter2) { calculate_filter2_coefficients(this, DST_FILTER2__FREQ, DST_FILTER2__DAMP, DST_FILTER2__TYPE, m_fc); set_output(0, 0); } /************************************************************************ * * DST_OP_AMP_FILT - Op Amp filter circuit RC filter * * input[0] - Enable input value * input[1] - IN0 node * input[2] - IN1 node * input[3] - Filter Type * * also passed discrete_op_amp_filt_info structure * * Mar 2004, D Renaud. ************************************************************************/ #define DST_OP_AMP_FILT__ENABLE DISCRETE_INPUT(0) #define DST_OP_AMP_FILT__INP1 DISCRETE_INPUT(1) #define DST_OP_AMP_FILT__INP2 DISCRETE_INPUT(2) #define DST_OP_AMP_FILT__TYPE DISCRETE_INPUT(3) DISCRETE_STEP(dst_op_amp_filt) { DISCRETE_DECLARE_INFO(discrete_op_amp_filt_info) double v_out = 0; double i, v = 0; if (DST_OP_AMP_FILT__ENABLE) { if (m_is_norton) { v = DST_OP_AMP_FILT__INP1 - OP_AMP_NORTON_VBE; if (v < 0) v = 0; } else { /* Millman the input voltages. */ i = m_iFixed; switch (m_type) { case DISC_OP_AMP_FILTER_IS_LOW_PASS_1_A: i += (DST_OP_AMP_FILT__INP1 - DST_OP_AMP_FILT__INP2) / info->r1; if (info->r2 != 0) i += (m_vP - DST_OP_AMP_FILT__INP2) / info->r2; if (info->r3 != 0) i += (m_vN - DST_OP_AMP_FILT__INP2) / info->r3; break; default: i += (DST_OP_AMP_FILT__INP1 - m_vRef) / info->r1; if (info->r2 != 0) i += (DST_OP_AMP_FILT__INP2 - m_vRef) / info->r2; break; } v = i * m_rTotal; } switch (m_type) { case DISC_OP_AMP_FILTER_IS_LOW_PASS_1: m_vC1 += (v - m_vC1) * m_exponentC1; v_out = m_vC1 * m_gain + info->vRef; break; case DISC_OP_AMP_FILTER_IS_LOW_PASS_1_A: m_vC1 += (v - m_vC1) * m_exponentC1; v_out = m_vC1 * m_gain + DST_OP_AMP_FILT__INP2; break; case DISC_OP_AMP_FILTER_IS_HIGH_PASS_1: v_out = (v - m_vC1) * m_gain + info->vRef; m_vC1 += (v - m_vC1) * m_exponentC1; break; case DISC_OP_AMP_FILTER_IS_BAND_PASS_1: v_out = (v - m_vC2); m_vC2 += (v - m_vC2) * m_exponentC2; m_vC1 += (v_out - m_vC1) * m_exponentC1; v_out = m_vC1 * m_gain + info->vRef; break; case DISC_OP_AMP_FILTER_IS_BAND_PASS_0 | DISC_OP_AMP_IS_NORTON: m_vC1 += (v - m_vC1) * m_exponentC1; m_vC2 += (m_vC1 - m_vC2) * m_exponentC2; v = m_vC2; v_out = v - m_vC3; m_vC3 += (v - m_vC3) * m_exponentC3; i = v_out / m_rTotal; v_out = (m_iFixed - i) * info->rF; break; case DISC_OP_AMP_FILTER_IS_HIGH_PASS_0 | DISC_OP_AMP_IS_NORTON: v_out = v - m_vC1; m_vC1 += (v - m_vC1) * m_exponentC1; i = v_out / m_rTotal; v_out = (m_iFixed - i) * info->rF; break; case DISC_OP_AMP_FILTER_IS_BAND_PASS_1M: case DISC_OP_AMP_FILTER_IS_BAND_PASS_1M | DISC_OP_AMP_IS_NORTON: v_out = -m_fc.a1 * m_fc.y1 - m_fc.a2 * m_fc.y2 + m_fc.b0 * v + m_fc.b1 * m_fc.x1 + m_fc.b2 * m_fc.x2 + m_vRef; m_fc.x2 = m_fc.x1; m_fc.x1 = v; m_fc.y2 = m_fc.y1; break; } /* Clip the output to the voltage rails. * This way we get the original distortion in all it's glory. */ if (v_out > m_vP) v_out = m_vP; if (v_out < m_vN) v_out = m_vN; m_fc.y1 = v_out - m_vRef; set_output(0, v_out); } else set_output(0, 0); } DISCRETE_RESET(dst_op_amp_filt) { DISCRETE_DECLARE_INFO(discrete_op_amp_filt_info) /* Convert the passed filter type into an int for easy use. */ m_type = (int)DST_OP_AMP_FILT__TYPE & DISC_OP_AMP_FILTER_TYPE_MASK; m_is_norton = (int)DST_OP_AMP_FILT__TYPE & DISC_OP_AMP_IS_NORTON; if (m_is_norton) { m_vRef = 0; m_rTotal = info->r1; if (m_type == (DISC_OP_AMP_FILTER_IS_BAND_PASS_0 | DISC_OP_AMP_IS_NORTON)) m_rTotal += info->r2 + info->r3; /* Setup the current to the + input. */ m_iFixed = (info->vP - OP_AMP_NORTON_VBE) / info->r4; /* Set the output max. */ m_vP = info->vP - OP_AMP_NORTON_VBE; m_vN = info->vN; } else { m_vRef = info->vRef; /* Set the output max. */ m_vP = info->vP - OP_AMP_VP_RAIL_OFFSET; m_vN = info->vN; /* Work out the input resistance. It is all input and bias resistors in parallel. */ m_rTotal = 1.0 / info->r1; /* There has to be an R1. Otherwise the table is wrong. */ if (info->r2 != 0) m_rTotal += 1.0 / info->r2; if (info->r3 != 0) m_rTotal += 1.0 / info->r3; m_rTotal = 1.0 / m_rTotal; m_iFixed = 0; m_rRatio = info->rF / (m_rTotal + info->rF); m_gain = -info->rF / m_rTotal; } switch (m_type) { case DISC_OP_AMP_FILTER_IS_LOW_PASS_1: case DISC_OP_AMP_FILTER_IS_LOW_PASS_1_A: m_exponentC1 = RC_CHARGE_EXP(info->rF * info->c1); m_exponentC2 = 0; break; case DISC_OP_AMP_FILTER_IS_HIGH_PASS_1: m_exponentC1 = RC_CHARGE_EXP(m_rTotal * info->c1); m_exponentC2 = 0; break; case DISC_OP_AMP_FILTER_IS_BAND_PASS_1: m_exponentC1 = RC_CHARGE_EXP(info->rF * info->c1); m_exponentC2 = RC_CHARGE_EXP(m_rTotal * info->c2); break; case DISC_OP_AMP_FILTER_IS_BAND_PASS_1M | DISC_OP_AMP_IS_NORTON: if (info->r2 == 0) m_rTotal = info->r1; else m_rTotal = RES_2_PARALLEL(info->r1, info->r2); case DISC_OP_AMP_FILTER_IS_BAND_PASS_1M: { double fc = 1.0 / (2 * M_PI * sqrt(m_rTotal * info->rF * info->c1 * info->c2)); double d = (info->c1 + info->c2) / sqrt(info->rF / m_rTotal * info->c1 * info->c2); double gain = -info->rF / m_rTotal * info->c2 / (info->c1 + info->c2); calculate_filter2_coefficients(this, fc, d, DISC_FILTER_BANDPASS, m_fc); m_fc.b0 *= gain; m_fc.b1 *= gain; m_fc.b2 *= gain; if (m_is_norton) m_vRef = (info->vP - OP_AMP_NORTON_VBE) / info->r3 * info->rF; else m_vRef = info->vRef; break; } case DISC_OP_AMP_FILTER_IS_BAND_PASS_0 | DISC_OP_AMP_IS_NORTON: m_exponentC1 = RC_CHARGE_EXP(RES_2_PARALLEL(info->r1, info->r2 + info->r3 + info->r4) * info->c1); m_exponentC2 = RC_CHARGE_EXP(RES_2_PARALLEL(info->r1 + info->r2, info->r3 + info->r4) * info->c2); m_exponentC3 = RC_CHARGE_EXP((info->r1 + info->r2 + info->r3 + info->r4) * info->c3); break; case DISC_OP_AMP_FILTER_IS_HIGH_PASS_0 | DISC_OP_AMP_IS_NORTON: m_exponentC1 = RC_CHARGE_EXP(info->r1 * info->c1); break; } /* At startup there is no charge on the caps and output is 0V in relation to vRef. */ m_vC1 = 0; m_vC1b = 0; m_vC2 = 0; m_vC3 = 0; set_output(0, info->vRef); } /************************************************************************ * * DST_RC_CIRCUIT_1 - RC charge/discharge circuit * ************************************************************************/ #define DST_RC_CIRCUIT_1__IN0 DISCRETE_INPUT(0) #define DST_RC_CIRCUIT_1__IN1 DISCRETE_INPUT(1) #define DST_RC_CIRCUIT_1__R DISCRETE_INPUT(2) #define DST_RC_CIRCUIT_1__C DISCRETE_INPUT(3) #define CD4066_R_ON 270 DISCRETE_STEP( dst_rc_circuit_1 ) { if (DST_RC_CIRCUIT_1__IN0 == 0) if (DST_RC_CIRCUIT_1__IN1 == 0) /* cap is floating and does not change charge */ /* output is pulled to ground */ set_output(0, 0); else { /* cap is discharged */ m_v_cap -= m_v_cap * m_exp_2; set_output(0, m_v_cap * m_v_drop); } else if (DST_RC_CIRCUIT_1__IN1 == 0) { /* cap is charged */ m_v_cap += (5.0 - m_v_cap) * m_exp_1; /* output is pulled to ground */ set_output(0, 0); } else { /* cap is charged slightly less */ m_v_cap += (m_v_charge_1_2 - m_v_cap) * m_exp_1_2; set_output(0, m_v_cap * m_v_drop); } } DISCRETE_RESET( dst_rc_circuit_1 ) { /* the charging voltage across the cap based on in2*/ m_v_drop = RES_VOLTAGE_DIVIDER(CD4066_R_ON, CD4066_R_ON + DST_RC_CIRCUIT_1__R); m_v_charge_1_2 = 5.0 * m_v_drop; m_v_cap = 0; /* precalculate charging exponents */ /* discharge cap - in1 = 0, in2 = 1*/ m_exp_2 = RC_CHARGE_EXP((CD4066_R_ON + DST_RC_CIRCUIT_1__R) * DST_RC_CIRCUIT_1__C); /* charge cap - in1 = 1, in2 = 0 */ m_exp_1 = RC_CHARGE_EXP(CD4066_R_ON * DST_RC_CIRCUIT_1__C); /* charge cap - in1 = 1, in2 = 1 */ m_exp_1_2 = RC_CHARGE_EXP(RES_2_PARALLEL(CD4066_R_ON, CD4066_R_ON + DST_RC_CIRCUIT_1__R) * DST_RC_CIRCUIT_1__C); /* starts at 0 until cap starts charging */ set_output(0, 0); } /************************************************************************ * * DST_RCDISC - Usage of node_description values for RC discharge * (inverse slope of DST_RCFILTER) * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCDISC__ENABLE DISCRETE_INPUT(0) #define DST_RCDISC__IN DISCRETE_INPUT(1) #define DST_RCDISC__R DISCRETE_INPUT(2) #define DST_RCDISC__C DISCRETE_INPUT(3) DISCRETE_STEP(dst_rcdisc) { switch (m_state) { case 0: /* waiting for trigger */ if(DST_RCDISC__ENABLE) { m_state = 1; m_t = 0; } set_output(0, 0); break; case 1: if (DST_RCDISC__ENABLE) { set_output(0, DST_RCDISC__IN * exp(m_t / m_exponent0)); m_t += this->sample_time(); } else { m_state = 0; } } } DISCRETE_RESET(dst_rcdisc) { set_output(0, 0); m_state = 0; m_t = 0; m_exponent0=-1.0 * DST_RCDISC__R * DST_RCDISC__C; } /************************************************************************ * * DST_RCDISC2 - Usage of node_description values for RC discharge * Has switchable charge resistor/input * * input[0] - Switch input value * input[1] - input[0] value * input[2] - Resistor0 value (initialization only) * input[3] - input[1] value * input[4] - Resistor1 value (initialization only) * input[5] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCDISC2__ENABLE DISCRETE_INPUT(0) #define DST_RCDISC2__IN0 DISCRETE_INPUT(1) #define DST_RCDISC2__R0 DISCRETE_INPUT(2) #define DST_RCDISC2__IN1 DISCRETE_INPUT(3) #define DST_RCDISC2__R1 DISCRETE_INPUT(4) #define DST_RCDISC2__C DISCRETE_INPUT(5) DISCRETE_STEP(dst_rcdisc2) { double diff; /* Works differently to other as we are always on, no enable */ /* exponential based in difference between input/output */ diff = ((DST_RCDISC2__ENABLE == 0) ? DST_RCDISC2__IN0 : DST_RCDISC2__IN1) - m_v_out; diff = diff - (diff * ((DST_RCDISC2__ENABLE == 0) ? m_exponent0 : m_exponent1)); m_v_out += diff; set_output(0, m_v_out); } DISCRETE_RESET(dst_rcdisc2) { m_v_out = 0; m_state = 0; m_t = 0; m_exponent0 = RC_DISCHARGE_EXP(DST_RCDISC2__R0 * DST_RCDISC2__C); m_exponent1 = RC_DISCHARGE_EXP(DST_RCDISC2__R1 * DST_RCDISC2__C); } /************************************************************************ * * DST_RCDISC3 - Usage of node_description values for RC discharge * * * input[0] - Enable * input[1] - input value * input[2] - Resistor0 value (initialization only) * input[4] - Resistor1 value (initialization only) * input[5] - Capacitor Value (initialization only) * input[6] - Diode Junction voltage (initialization only) * ************************************************************************/ #define DST_RCDISC3__ENABLE DISCRETE_INPUT(0) #define DST_RCDISC3__IN DISCRETE_INPUT(1) #define DST_RCDISC3__R1 DISCRETE_INPUT(2) #define DST_RCDISC3__R2 DISCRETE_INPUT(3) #define DST_RCDISC3__C DISCRETE_INPUT(4) #define DST_RCDISC3__DJV DISCRETE_INPUT(5) DISCRETE_STEP(dst_rcdisc3) { double diff; /* Exponential based in difference between input/output */ if(DST_RCDISC3__ENABLE) { diff = DST_RCDISC3__IN - m_v_out; if (m_v_diode > 0) { if (diff > 0) { diff = diff * m_exponent0; } else if (diff < -m_v_diode) { diff = diff * m_exponent1; } else { diff = diff * m_exponent0; } } else { if (diff < 0) { diff = diff * m_exponent0; } else if (diff > -m_v_diode) { diff = diff * m_exponent1; } else { diff = diff * m_exponent0; } } m_v_out += diff; set_output(0, m_v_out); } else { set_output(0, 0); } } DISCRETE_RESET(dst_rcdisc3) { m_v_out = 0; m_state = 0; m_t = 0; m_v_diode = DST_RCDISC3__DJV; m_exponent0 = RC_CHARGE_EXP(DST_RCDISC3__R1 * DST_RCDISC3__C); m_exponent1 = RC_CHARGE_EXP(RES_2_PARALLEL(DST_RCDISC3__R1, DST_RCDISC3__R2) * DST_RCDISC3__C); } /************************************************************************ * * DST_RCDISC4 - Various charge/discharge circuits * * input[0] - Enable input value * input[1] - input value * input[2] - R1 Resistor value (initialization only) * input[2] - R2 Resistor value (initialization only) * input[4] - C1 Capacitor Value (initialization only) * input[4] - vP power source (initialization only) * input[4] - circuit type (initialization only) * ************************************************************************/ #define DST_RCDISC4__ENABLE DISCRETE_INPUT(0) #define DST_RCDISC4__IN DISCRETE_INPUT(1) #define DST_RCDISC4__R1 DISCRETE_INPUT(2) #define DST_RCDISC4__R2 DISCRETE_INPUT(3) #define DST_RCDISC4__R3 DISCRETE_INPUT(4) #define DST_RCDISC4__C1 DISCRETE_INPUT(5) #define DST_RCDISC4__VP DISCRETE_INPUT(6) #define DST_RCDISC4__TYPE DISCRETE_INPUT(7) DISCRETE_STEP(dst_rcdisc4) { int inp1 = (DST_RCDISC4__IN == 0) ? 0 : 1; double v_out = 0; if (DST_RCDISC4__ENABLE == 0) { set_output(0, 0); return; } switch (m_type) { case 1: case 3: m_vC1 += ((m_v[inp1] - m_vC1) * m_exp[inp1]); v_out = m_vC1; break; } /* clip output */ if (v_out > m_max_out) v_out = m_max_out; if (v_out < 0) v_out = 0; set_output(0, v_out); } DISCRETE_RESET( dst_rcdisc4) { double v, i, r, rT; m_type = 0; /* some error checking. */ if (DST_RCDISC4__R1 <= 0 || DST_RCDISC4__R2 <= 0 || DST_RCDISC4__C1 <= 0 || (DST_RCDISC4__R3 <= 0 && m_type == 1)) { m_device->discrete_log("Invalid component values in NODE_%d.\n", this->index()); return; } if (DST_RCDISC4__VP < 3) { m_device->discrete_log("vP must be >= 3V in NODE_%d.\n", this->index()); return; } if (DST_RCDISC4__TYPE < 1 || DST_RCDISC4__TYPE > 3) { m_device->discrete_log("Invalid circuit type in NODE_%d.\n", this->index()); return; } m_vC1 = 0; /* store type as integer */ m_type = (int)DST_RCDISC4__TYPE; /* setup the maximum op-amp output. */ m_max_out = DST_RCDISC4__VP - OP_AMP_VP_RAIL_OFFSET; switch (m_type) { case 1: /* We will simulate this as a voltage divider with 2 states depending * on the input. But we have to take the diodes into account. */ v = DST_RCDISC4__VP - .5; /* diode drop */ /* When the input is 1, both R1 & R3 are basically in parallel. */ r = RES_2_PARALLEL(DST_RCDISC4__R1, DST_RCDISC4__R3); rT = DST_RCDISC4__R2 + r; i = v / rT; m_v[1] = i * r + .5; rT = RES_2_PARALLEL(DST_RCDISC4__R2, r); m_exp[1] = RC_CHARGE_EXP(rT * DST_RCDISC4__C1); /* When the input is 0, R1 is out of circuit. */ rT = DST_RCDISC4__R2 + DST_RCDISC4__R3; i = v / rT; m_v[0] = i * DST_RCDISC4__R3 + .5; rT = RES_2_PARALLEL(DST_RCDISC4__R2, DST_RCDISC4__R3); m_exp[0] = RC_CHARGE_EXP(rT * DST_RCDISC4__C1); break; case 3: /* We will simulate this as a voltage divider with 2 states depending * on the input. The 1k pullup is in parallel with the internal TTL * resistance, so we will just use .5k in series with R1. */ r = 500.0 + DST_RCDISC4__R1; m_v[1] = RES_VOLTAGE_DIVIDER(r, DST_RCDISC4__R2) * (5.0 - 0.5); rT = RES_2_PARALLEL(r, DST_RCDISC4__R2); m_exp[1] = RC_CHARGE_EXP(rT * DST_RCDISC4__C1); /* When the input is 0, R1 is out of circuit. */ m_v[0] = 0; m_exp[0] = RC_CHARGE_EXP(DST_RCDISC4__R2 * DST_RCDISC4__C1); break; } } /************************************************************************ * * DST_RCDISC5 - Diode in series with R//C * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCDISC5__ENABLE DISCRETE_INPUT(0) #define DST_RCDISC5__IN DISCRETE_INPUT(1) #define DST_RCDISC5__R DISCRETE_INPUT(2) #define DST_RCDISC5__C DISCRETE_INPUT(3) DISCRETE_STEP( dst_rcdisc5) { double diff,u; /* Exponential based in difference between input/output */ u = DST_RCDISC5__IN - 0.7; /* Diode drop */ if( u < 0) u = 0; diff = u - m_v_cap; if(DST_RCDISC5__ENABLE) { if(diff < 0) diff = diff * m_exponent0; m_v_cap += diff; set_output(0, m_v_cap); } else { if(diff > 0) m_v_cap = u; set_output(0, 0); } } DISCRETE_RESET( dst_rcdisc5) { set_output(0, 0); m_state = 0; m_t = 0; m_v_cap = 0; m_exponent0 = RC_CHARGE_EXP(DST_RCDISC5__R * DST_RCDISC5__C); } /************************************************************************ * * DST_RCDISC_MOD - RC triggered by logic and modulated * * input[0] - Enable input value * input[1] - input value 1 * input[2] - input value 2 * input[3] - Resistor 1 value (initialization only) * input[4] - Resistor 2 value (initialization only) * input[5] - Resistor 3 value (initialization only) * input[6] - Resistor 4 value (initialization only) * input[7] - Capacitor Value (initialization only) * input[8] - Voltage Value (initialization only) * ************************************************************************/ #define DST_RCDISC_MOD__IN1 DISCRETE_INPUT(0) #define DST_RCDISC_MOD__IN2 DISCRETE_INPUT(1) #define DST_RCDISC_MOD__R1 DISCRETE_INPUT(2) #define DST_RCDISC_MOD__R2 DISCRETE_INPUT(3) #define DST_RCDISC_MOD__R3 DISCRETE_INPUT(4) #define DST_RCDISC_MOD__R4 DISCRETE_INPUT(5) #define DST_RCDISC_MOD__C DISCRETE_INPUT(6) #define DST_RCDISC_MOD__VP DISCRETE_INPUT(7) DISCRETE_STEP(dst_rcdisc_mod) { double diff, v_cap, u, vD; int mod_state, mod1_state, mod2_state; /* Exponential based in difference between input/output */ v_cap = m_v_cap; mod1_state = DST_RCDISC_MOD__IN1 > 0.5; mod2_state = DST_RCDISC_MOD__IN2 > 0.6; mod_state = (mod2_state << 1) + mod1_state; u = mod1_state ? 0 : DST_RCDISC_MOD__VP; /* Clamp */ diff = u - v_cap; vD = diff * m_vd_gain[mod_state]; if (vD < -0.6) { diff = u + 0.6 - v_cap; diff -= diff * m_exp_low[mod1_state]; v_cap += diff; set_output(0, mod2_state ? 0 : -0.6); } else { diff -= diff * m_exp_high[mod_state]; v_cap += diff; /* neglecting current through R3 drawn by next8 node */ set_output(0, mod2_state ? 0: (u - v_cap) * m_gain[mod1_state]); } m_v_cap = v_cap; } DISCRETE_RESET(dst_rcdisc_mod) { double rc[2], rc2[2]; /* pre-calculate fixed values */ /* DST_RCDISC_MOD__IN1 <= 0.5 */ rc[0] = DST_RCDISC_MOD__R1 + DST_RCDISC_MOD__R2; if (rc[0] < 1) rc[0] = 1; m_exp_low[0] = RC_DISCHARGE_EXP(DST_RCDISC_MOD__C * rc[0]); m_gain[0] = RES_VOLTAGE_DIVIDER(rc[0], DST_RCDISC_MOD__R4); /* DST_RCDISC_MOD__IN1 > 0.5 */ rc[1] = DST_RCDISC_MOD__R2; if (rc[1] < 1) rc[1] = 1; m_exp_low[1] = RC_DISCHARGE_EXP(DST_RCDISC_MOD__C * rc[1]); m_gain[1] = RES_VOLTAGE_DIVIDER(rc[1], DST_RCDISC_MOD__R4); /* DST_RCDISC_MOD__IN2 <= 0.6 */ rc2[0] = DST_RCDISC_MOD__R4; /* DST_RCDISC_MOD__IN2 > 0.6 */ rc2[1] = RES_2_PARALLEL(DST_RCDISC_MOD__R3, DST_RCDISC_MOD__R4); /* DST_RCDISC_MOD__IN1 <= 0.5 && DST_RCDISC_MOD__IN2 <= 0.6 */ m_exp_high[0] = RC_DISCHARGE_EXP(DST_RCDISC_MOD__C * (rc[0] + rc2[0])); m_vd_gain[0] = RES_VOLTAGE_DIVIDER(rc[0], rc2[0]); /* DST_RCDISC_MOD__IN1 > 0.5 && DST_RCDISC_MOD__IN2 <= 0.6 */ m_exp_high[1] = RC_DISCHARGE_EXP(DST_RCDISC_MOD__C * (rc[1] + rc2[0])); m_vd_gain[1] = RES_VOLTAGE_DIVIDER(rc[1], rc2[0]); /* DST_RCDISC_MOD__IN1 <= 0.5 && DST_RCDISC_MOD__IN2 > 0.6 */ m_exp_high[2] = RC_DISCHARGE_EXP(DST_RCDISC_MOD__C * (rc[0] + rc2[1])); m_vd_gain[2] = RES_VOLTAGE_DIVIDER(rc[0], rc2[1]); /* DST_RCDISC_MOD__IN1 > 0.5 && DST_RCDISC_MOD__IN2 > 0.6 */ m_exp_high[3] = RC_DISCHARGE_EXP(DST_RCDISC_MOD__C * (rc[1] + rc2[1])); m_vd_gain[3] = RES_VOLTAGE_DIVIDER(rc[1], rc2[1]); m_v_cap = 0; set_output(0, 0); } /************************************************************************ * * DST_RCFILTER - Usage of node_description values for RC filter * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * input[4] - Voltage reference. Usually 0V. * ************************************************************************/ #define DST_RCFILTER__VIN DISCRETE_INPUT(0) #define DST_RCFILTER__R DISCRETE_INPUT(1) #define DST_RCFILTER__C DISCRETE_INPUT(2) #define DST_RCFILTER__VREF DISCRETE_INPUT(3) DISCRETE_STEP(dst_rcfilter) { if (EXPECTED(m_is_fast)) m_v_out += ((DST_RCFILTER__VIN - m_v_out) * m_exponent); else { if (UNEXPECTED(m_has_rc_nodes)) { double rc = DST_RCFILTER__R * DST_RCFILTER__C; if (rc != m_rc) { m_rc = rc; m_exponent = RC_CHARGE_EXP(rc); } } /************************************************************************/ /* Next Value = PREV + (INPUT_VALUE - PREV)*(1-(EXP(-TIMEDELTA/RC))) */ /************************************************************************/ m_vCap += ((DST_RCFILTER__VIN - m_v_out) * m_exponent); m_v_out = m_vCap + DST_RCFILTER__VREF; } set_output(0, m_v_out); } DISCRETE_RESET(dst_rcfilter) { m_has_rc_nodes = this->input_is_node() & 0x6; m_rc = DST_RCFILTER__R * DST_RCFILTER__C; m_exponent = RC_CHARGE_EXP(m_rc); m_vCap = 0; m_v_out = 0; /* FIXME --> we really need another class here */ if (!m_has_rc_nodes && DST_RCFILTER__VREF == 0) m_is_fast = 1; else m_is_fast = 0; } /************************************************************************ * * DST_RCFILTER_SW - Usage of node_description values for switchable RC filter * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * input[4] - Voltage reference. Usually 0V. * ************************************************************************/ #define DST_RCFILTER_SW__ENABLE DISCRETE_INPUT(0) #define DST_RCFILTER_SW__VIN DISCRETE_INPUT(1) #define DST_RCFILTER_SW__SWITCH DISCRETE_INPUT(2) #define DST_RCFILTER_SW__R DISCRETE_INPUT(3) #define DST_RCFILTER_SW__C(x) DISCRETE_INPUT(4+x) /* 74HC4066 : 15 * 74VHC4066 : 15 * UTC4066 : 270 @ 5VCC, 80 @ 15VCC * CD4066BC : 270 (Fairchild) * * The choice below makes scramble sound about "right". For future error reports, * we need the exact type of switch and at which voltage (5, 12?) it is operated. */ #define CD4066_ON_RES (40) // FIXME: This needs optimization ! DISCRETE_STEP(dst_rcfilter_sw) { int i; int bits = (int)DST_RCFILTER_SW__SWITCH; double us = 0; double vIn = DST_RCFILTER_SW__VIN; double v_out; if (EXPECTED(DST_RCFILTER_SW__ENABLE)) { switch (bits) { case 0: v_out = vIn; break; case 1: m_vCap[0] += (vIn - m_vCap[0]) * m_exp0; v_out = m_vCap[0] + (vIn - m_vCap[0]) * m_factor; break; case 2: m_vCap[1] += (vIn - m_vCap[1]) * m_exp1; v_out = m_vCap[1] + (vIn - m_vCap[1]) * m_factor; break; default: for (i = 0; i < 4; i++) { if (( bits & (1 << i)) != 0) us += m_vCap[i]; } v_out = m_f1[bits] * vIn + m_f2[bits] * us; for (i = 0; i < 4; i++) { if (( bits & (1 << i)) != 0) m_vCap[i] += (v_out - m_vCap[i]) * m_exp[i]; } } set_output(0, v_out); } else { set_output(0, 0); } } DISCRETE_RESET(dst_rcfilter_sw) { int i, bits; for (i = 0; i < 4; i++) { m_vCap[i] = 0; m_exp[i] = RC_CHARGE_EXP( CD4066_ON_RES * DST_RCFILTER_SW__C(i)); } for (bits=0; bits < 15; bits++) { double rs = 0; for (i = 0; i < 4; i++) { if (( bits & (1 << i)) != 0) rs += DST_RCFILTER_SW__R; } m_f1[bits] = RES_VOLTAGE_DIVIDER(rs, CD4066_ON_RES); m_f2[bits] = DST_RCFILTER_SW__R / (CD4066_ON_RES + rs); } /* fast cases */ m_exp0 = RC_CHARGE_EXP((CD4066_ON_RES + DST_RCFILTER_SW__R) * DST_RCFILTER_SW__C(0)); m_exp1 = RC_CHARGE_EXP((CD4066_ON_RES + DST_RCFILTER_SW__R) * DST_RCFILTER_SW__C(1)); m_factor = RES_VOLTAGE_DIVIDER(DST_RCFILTER_SW__R, CD4066_ON_RES); set_output(0, 0); } /************************************************************************ * * DST_RCINTEGRATE - Two diode inputs, transistor and a R/C charge * discharge network * * input[0] - Enable input value * input[1] - input value 1 * input[2] - input value 2 * input[3] - Resistor 1 value (initialization only) * input[4] - Resistor 2 value (initialization only) * input[5] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCINTEGRATE__IN1 DISCRETE_INPUT(0) #define DST_RCINTEGRATE__R1 DISCRETE_INPUT(1) #define DST_RCINTEGRATE__R2 DISCRETE_INPUT(2) #define DST_RCINTEGRATE__R3 DISCRETE_INPUT(3) #define DST_RCINTEGRATE__C DISCRETE_INPUT(4) #define DST_RCINTEGRATE__VP DISCRETE_INPUT(5) #define DST_RCINTEGRATE__TYPE DISCRETE_INPUT(6) /* Ebers-Moll large signal model * Couriersud: * The implementation avoids all iterative approaches in order not to burn cycles * We will calculate Ic from vBE and use this as an indication where to go. * The implementation may oscillate if you change the weighting factors at the * end. * * This implementation is not perfect, but does it's job in dkong' */ /* reverse saturation current */ #define IES 7e-15 #define ALPHAT 0.99 #define KT 0.026 #define EM_IC(x) (ALPHAT * IES * exp( (x) / KT - 1.0 )) DISCRETE_STEP( dst_rcintegrate) { double diff, u, iQ, iQc, iC, RG, vE; double vP; u = DST_RCINTEGRATE__IN1; vP = DST_RCINTEGRATE__VP; if ( u - 0.7 < m_vCap * m_gain_r1_r2) { /* discharge .... */ diff = 0.0 - m_vCap; iC = m_c_exp1 * diff; /* iC */ diff -= diff * m_exp_exponent1; m_vCap += diff; iQ = 0; vE = m_vCap * m_gain_r1_r2; RG = vE / iC; } else { /* charging */ diff = (vP - m_vCE) * m_f - m_vCap; iC = 0.0 - m_c_exp0 * diff; /* iC */ diff -= diff * m_exp_exponent0; m_vCap += diff; iQ = iC + (iC * DST_RCINTEGRATE__R1 + m_vCap) / DST_RCINTEGRATE__R2; RG = (vP - m_vCE) / iQ; vE = (RG - DST_RCINTEGRATE__R3) / RG * (vP - m_vCE); } u = DST_RCINTEGRATE__IN1; if (u > 0.7 + vE) { vE = u - 0.7; //iQc = EM_IC(u - vE); iQc = m_EM_IC_0_7; } else iQc = EM_IC(u - vE); m_vCE = std::min(vP - 0.1, vP - RG * iQc); /* Avoid oscillations * The method tends to largely overshoot - no wonder without * iterative solution approximation */ m_vCE = std::max(m_vCE, 0.1 ); m_vCE = 0.1 * m_vCE + 0.9 * (vP - vE - iQ * DST_RCINTEGRATE__R3); switch (m_type) { case DISC_RC_INTEGRATE_TYPE1: set_output(0, m_vCap); break; case DISC_RC_INTEGRATE_TYPE2: set_output(0, vE); break; case DISC_RC_INTEGRATE_TYPE3: set_output(0, std::max(0.0, vP - iQ * DST_RCINTEGRATE__R3)); break; } } DISCRETE_RESET(dst_rcintegrate) { double r; double dt = this->sample_time(); m_type = DST_RCINTEGRATE__TYPE; m_vCap = 0; m_vCE = 0; /* pre-calculate fixed values */ m_gain_r1_r2 = RES_VOLTAGE_DIVIDER(DST_RCINTEGRATE__R1, DST_RCINTEGRATE__R2); r = DST_RCINTEGRATE__R1 / DST_RCINTEGRATE__R2 * DST_RCINTEGRATE__R3 + DST_RCINTEGRATE__R1 + DST_RCINTEGRATE__R3; m_f = RES_VOLTAGE_DIVIDER(DST_RCINTEGRATE__R3, DST_RCINTEGRATE__R2); m_exponent0 = -1.0 * r * m_f * DST_RCINTEGRATE__C; m_exponent1 = -1.0 * (DST_RCINTEGRATE__R1 + DST_RCINTEGRATE__R2) * DST_RCINTEGRATE__C; m_exp_exponent0 = exp(dt / m_exponent0); m_exp_exponent1 = exp(dt / m_exponent1); m_c_exp0 = DST_RCINTEGRATE__C / m_exponent0 * m_exp_exponent0; m_c_exp1 = DST_RCINTEGRATE__C / m_exponent1 * m_exp_exponent1; m_EM_IC_0_7 = EM_IC(0.7); set_output(0, 0); } /************************************************************************ * * DST_SALLEN_KEY - Sallen-Key filter circuit * * input[0] - Enable input value * input[1] - IN0 node * input[3] - Filter Type * * also passed discrete_op_amp_filt_info structure * * 2008, couriersud ************************************************************************/ #define DST_SALLEN_KEY__ENABLE DISCRETE_INPUT(0) #define DST_SALLEN_KEY__INP0 DISCRETE_INPUT(1) #define DST_SALLEN_KEY__TYPE DISCRETE_INPUT(2) DISCRETE_STEP(dst_sallen_key) { double gain = 1.0; double v_out; if (DST_SALLEN_KEY__ENABLE == 0.0) { gain = 0.0; } v_out = -m_fc.a1 * m_fc.y1 - m_fc.a2 * m_fc.y2 + m_fc.b0 * gain * DST_SALLEN_KEY__INP0 + m_fc.b1 * m_fc.x1 + m_fc.b2 * m_fc.x2; m_fc.x2 = m_fc.x1; m_fc.x1 = gain * DST_SALLEN_KEY__INP0; m_fc.y2 = m_fc.y1; m_fc.y1 = v_out; set_output(0, v_out); } DISCRETE_RESET(dst_sallen_key) { DISCRETE_DECLARE_INFO(discrete_op_amp_filt_info) double freq, q; switch ((int) DST_SALLEN_KEY__TYPE) { case DISC_SALLEN_KEY_LOW_PASS: freq = 1.0 / ( 2.0 * M_PI * sqrt(info->c1 * info->c2 * info->r1 * info->r2)); q = sqrt(info->c1 * info->c2 * info->r1 * info->r2) / (info->c2 * (info->r1 + info->r2)); break; default: fatalerror("Unknown sallen key filter type\n"); } calculate_filter2_coefficients(this, freq, 1.0 / q, DISC_FILTER_LOWPASS, m_fc); set_output(0, 0); } /* !!!!!!!!!!! NEW FILTERS for testing !!!!!!!!!!!!!!!!!!!!! */ /************************************************************************ * * DST_RCFILTERN - Usage of node_description values for RC filter * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCFILTERN__ENABLE DISCRETE_INPUT(0) #define DST_RCFILTERN__IN DISCRETE_INPUT(1) #define DST_RCFILTERN__R DISCRETE_INPUT(2) #define DST_RCFILTERN__C DISCRETE_INPUT(3) #if 0 DISCRETE_RESET(dst_rcfilterN) { #if 0 double f=1.0/(2*M_PI* DST_RCFILTERN__R * DST_RCFILTERN__C); /* !!!!!!!!!!!!!! CAN'T CHEAT LIKE THIS !!!!!!!!!!!!!!!! */ /* Put this stuff in a context */ this->m_input[2] = f; this->m_input[3] = DISC_FILTER_LOWPASS; /* Use first order filter */ dst_filter1_reset(node); #endif } #endif /************************************************************************ * * DST_RCDISCN - Usage of node_description values for RC discharge * (inverse slope of DST_RCFILTER) * * input[0] - Enable input value * input[1] - input value * input[2] - Resistor value (initialization only) * input[3] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCDISCN__ENABLE DISCRETE_INPUT(0) #define DST_RCDISCN__IN DISCRETE_INPUT(1) #define DST_RCDISCN__R DISCRETE_INPUT(2) #define DST_RCDISCN__C DISCRETE_INPUT(3) DISCRETE_RESET(dst_rcdiscN) { #if 0 double f = 1.0 / (2 * M_PI * DST_RCDISCN__R * DST_RCDISCN__C); /* !!!!!!!!!!!!!! CAN'T CHEAT LIKE THIS !!!!!!!!!!!!!!!! */ /* Put this stuff in a context */ this->m_input[2] = f; this->m_input[3] = DISC_FILTER_LOWPASS; /* Use first order filter */ dst_filter1_reset(node); #endif } DISCRETE_STEP(dst_rcdiscN) { double gain = 1.0; double v_out; if (DST_RCDISCN__ENABLE == 0.0) { gain = 0.0; } /* A rise in the input signal results in an instant charge, */ /* else discharge through the RC to zero */ if (gain* DST_RCDISCN__IN > m_x1) v_out = gain* DST_RCDISCN__IN; else v_out = -m_a1*m_y1; m_x1 = gain* DST_RCDISCN__IN; m_y1 = v_out; set_output(0, v_out); } /************************************************************************ * * DST_RCDISC2N - Usage of node_description values for RC discharge * Has switchable charge resistor/input * * input[0] - Switch input value * input[1] - input[0] value * input[2] - Resistor0 value (initialization only) * input[3] - input[1] value * input[4] - Resistor1 value (initialization only) * input[5] - Capacitor Value (initialization only) * ************************************************************************/ #define DST_RCDISC2N__ENABLE DISCRETE_INPUT(0) #define DST_RCDISC2N__IN0 DISCRETE_INPUT(1) #define DST_RCDISC2N__R0 DISCRETE_INPUT(2) #define DST_RCDISC2N__IN1 DISCRETE_INPUT(3) #define DST_RCDISC2N__R1 DISCRETE_INPUT(4) #define DST_RCDISC2N__C DISCRETE_INPUT(5) DISCRETE_STEP(dst_rcdisc2N) { double inp = ((DST_RCDISC2N__ENABLE == 0) ? DST_RCDISC2N__IN0 : DST_RCDISC2N__IN1); double v_out; if (DST_RCDISC2N__ENABLE == 0) v_out = -m_fc0.a1*m_y1 + m_fc0.b0*inp + m_fc0.b1 * m_x1; else v_out = -m_fc1.a1*m_y1 + m_fc1.b0*inp + m_fc1.b1*m_x1; m_x1 = inp; m_y1 = v_out; set_output(0, v_out); } DISCRETE_RESET(dst_rcdisc2N) { double f1,f2; f1 = 1.0 / (2 * M_PI * DST_RCDISC2N__R0 * DST_RCDISC2N__C); f2 = 1.0 / (2 * M_PI * DST_RCDISC2N__R1 * DST_RCDISC2N__C); calculate_filter1_coefficients(this, f1, DISC_FILTER_LOWPASS, m_fc0); calculate_filter1_coefficients(this, f2, DISC_FILTER_LOWPASS, m_fc1); /* Initialize the object */ set_output(0, 0); }