Previous

199869 Revisions

Next

r35035 Saturday 14th February, 2015 at 17:48:58 UTC by hap
renamed generic leds_decay stuff to display_decay so it makes sense on vfd/lamp/lcd devices

[src/mess/drivers]

cnsector.c comp4.c elecdet.c splitsec.c starwbc.c stopthie.c ticalc1x.c tispeak.c wildfire.c

trunk/src/mess/drivers/cnsector.c

r243546	r243547
38	38
39	39	UINT16 m_o;
40	40
41		UINT16 m_leds_state[0x10];
42		UINT16 m_leds_cache[0x10];
43		UINT8 m_leds_decay[0x100];
	41	UINT16 m_display_state[0x10];
	42	UINT16 m_display_cache[0x10];
	43	UINT8 m_display_decay[0x100];
44	44
45	45	DECLARE_READ8_MEMBER(read_k);
46	46	DECLARE_WRITE16_MEMBER(write_o);
47	47	DECLARE_WRITE16_MEMBER(write_r);
48	48
49		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
50		void leds_update();
	49	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	50	void display_update();
51	51
52	52	virtual void machine_start();
53	53	};
r243546	r243547
56	56
57	57	/***************************************************************************
58	58
59		LEDs
	59	LED Display
60	60
61	61	***************************************************************************/
62	62
r243546	r243547
64	64	// To prevent flickering here, we need to simulate a decay.
65	65
66	66	// decay time, in steps of 10ms
67		#define LEDS_DECAY_TIME 4
	67	#define DISPLAY_DECAY_TIME 4
68	68
69		void cnsector_state::leds_update()
	69	void cnsector_state::display_update()
70	70	{
71	71	UINT16 active_state[0x10];
72	72
r243546	r243547
78	78	{
79	79	int di = j << 4 | i;
80	80
81		// turn on powered leds
82		if (m_leds_state[i] >> j & 1)
83		m_leds_decay[di] = LEDS_DECAY_TIME;
	81	// turn on powered segments
	82	if (m_display_state[i] >> j & 1)
	83	m_display_decay[di] = DISPLAY_DECAY_TIME;
84	84
85	85	// determine active state
86		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	86	int ds = (m_display_decay[di] != 0) ? 1 : 0;
87	87	active_state[i] |= (ds << j);
88	88	}
89	89	}
90	90
91	91	// on difference, send to output
92	92	for (int i = 0; i < 0x10; i++)
93		if (m_leds_cache[i] != active_state[i])
	93	if (m_display_cache[i] != active_state[i])
94	94	output_set_digit_value(i, active_state[i]);
95	95
96		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	96	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
97	97	}
98	98
99		TIMER_DEVICE_CALLBACK_MEMBER(cnsector_state::leds_decay_tick)
	99	TIMER_DEVICE_CALLBACK_MEMBER(cnsector_state::display_decay_tick)
100	100	{
101		// slowly turn off unpowered leds
	101	// slowly turn off unpowered segments
102	102	for (int i = 0; i < 0x100; i++)
103		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
104		m_leds_decay[i]--;
	103	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	104	m_display_decay[i]--;
105	105
106		leds_update();
	106	display_update();
107	107	}
108	108
109	109
r243546	r243547
130	130	{
131	131	// R0-R5: select digit (right-to-left)
132	132	for (int i = 0; i < 6; i++)
133		m_leds_state[i] = (data >> i & 1) ? m_o : 0;
134		leds_update();
	133	m_display_state[i] = (data >> i & 1) ? m_o : 0;
	134	display_update();
135	135
136	136	// R6-R9: direction leds
137	137	for (int i = 6; i < 10; i++)
r243546	r243547
196	196	void cnsector_state::machine_start()
197	197	{
198	198	// zerofill
199		memset(m_leds_state, 0, sizeof(m_leds_state));
200		memset(m_leds_cache, 0, sizeof(m_leds_cache));
201		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	199	memset(m_display_state, 0, sizeof(m_display_state));
	200	memset(m_display_cache, 0, sizeof(m_display_cache));
	201	memset(m_display_decay, 0, sizeof(m_display_decay));
202	202
203	203	m_o = 0;
204	204
205	205	// register for savestates
206		save_item(NAME(m_leds_state));
207		save_item(NAME(m_leds_cache));
208		save_item(NAME(m_leds_decay));
	206	save_item(NAME(m_display_state));
	207	save_item(NAME(m_display_cache));
	208	save_item(NAME(m_display_decay));
209	209
210	210	save_item(NAME(m_o));
211	211	}
r243546	r243547
219	219	MCFG_TMS1XXX_WRITE_O_CB(WRITE16(cnsector_state, write_o))
220	220	MCFG_TMS1XXX_WRITE_R_CB(WRITE16(cnsector_state, write_r))
221	221
222		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", cnsector_state, leds_decay_tick, attotime::from_msec(10))
	222	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", cnsector_state, display_decay_tick, attotime::from_msec(10))
223	223
224	224	MCFG_DEFAULT_LAYOUT(layout_cnsector)
225	225

trunk/src/mess/drivers/comp4.c

r243546	r243547
41	41
42	42	UINT16 m_o;
43	43
44		UINT16 m_leds_state;
45		UINT8 m_leds_decay[0x10];
	44	UINT16 m_display_state;
	45	UINT8 m_display_decay[0x10];
46	46
47	47	DECLARE_READ8_MEMBER(read_k);
48	48	DECLARE_WRITE16_MEMBER(write_o);
49	49	DECLARE_WRITE16_MEMBER(write_r);
50	50
51		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
52		void leds_update();
	51	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	52	void display_update();
53	53
54	54	virtual void machine_start();
55	55	};
r243546	r243547
57	57
58	58	/***************************************************************************
59	59
60		LEDs
	60	LED Display
61	61
62	62	***************************************************************************/
63	63
r243546	r243547
65	65	// To prevent flickering here, we need to simulate a decay.
66	66
67	67	// decay time, in steps of 10ms
68		#define LEDS_DECAY_TIME 2
	68	#define DISPLAY_DECAY_TIME 2
69	69
70		void comp4_state::leds_update()
	70	void comp4_state::display_update()
71	71	{
72	72	for (int i = 0; i < 0x10; i++)
73	73	{
74		// turn on powered leds
75		if (m_leds_state >> i & 1)
76		m_leds_decay[i] = LEDS_DECAY_TIME;
	74	// turn on powered segments
	75	if (m_display_state >> i & 1)
	76	m_display_decay[i] = DISPLAY_DECAY_TIME;
77	77
78	78	// send to output
79		output_set_lamp_value(i, (m_leds_decay[i] != 0) ? 1 : 0);
	79	output_set_lamp_value(i, (m_display_decay[i] != 0) ? 1 : 0);
80	80	}
81	81	}
82	82
83		TIMER_DEVICE_CALLBACK_MEMBER(comp4_state::leds_decay_tick)
	83	TIMER_DEVICE_CALLBACK_MEMBER(comp4_state::display_decay_tick)
84	84	{
85		// slowly turn off unpowered leds
	85	// slowly turn off unpowered segments
86	86	for (int i = 0; i < 0x10; i++)
87		if (!(m_leds_state >> i & 1) && m_leds_decay[i])
88		m_leds_decay[i]--;
	87	if (!(m_display_state >> i & 1) && m_display_decay[i])
	88	m_display_decay[i]--;
89	89
90		leds_update();
	90	display_update();
91	91	}
92	92
93	93
r243546	r243547
118	118	// R2    R7
119	119	// R1    R6
120	120	// R0    R5
121		m_leds_state = data;
122		leds_update();
	121	m_display_state = data;
	122	display_update();
123	123	}
124	124
125	125	WRITE16_MEMBER(comp4_state::write_o)
r243546	r243547
169	169	void comp4_state::machine_start()
170	170	{
171	171	// zerofill
172		m_leds_state = 0;
173		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	172	m_display_state = 0;
	173	memset(m_display_decay, 0, sizeof(m_display_decay));
174	174
175	175	m_o = 0;
176	176
177	177	// register for savestates
178		save_item(NAME(m_leds_state));
179		save_item(NAME(m_leds_decay));
	178	save_item(NAME(m_display_state));
	179	save_item(NAME(m_display_decay));
180	180
181	181	save_item(NAME(m_o));
182	182	}
r243546	r243547
190	190	MCFG_TMS1XXX_WRITE_O_CB(WRITE16(comp4_state, write_o))
191	191	MCFG_TMS1XXX_WRITE_R_CB(WRITE16(comp4_state, write_r))
192	192
193		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", comp4_state, leds_decay_tick, attotime::from_msec(10))
	193	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", comp4_state, display_decay_tick, attotime::from_msec(10))
194	194
195	195	MCFG_DEFAULT_LAYOUT(layout_comp4)
196	196

trunk/src/mess/drivers/elecdet.c

r243546	r243547
44	44	UINT16 m_o;
45	45	bool m_power_on;
46	46
47		UINT16 m_leds_state[0x10];
48		UINT16 m_leds_cache[0x10];
49		UINT8 m_leds_decay[0x100];
	47	UINT16 m_display_state[0x10];
	48	UINT16 m_display_cache[0x10];
	49	UINT8 m_display_decay[0x100];
50	50
51	51	DECLARE_READ8_MEMBER(read_k);
52	52	DECLARE_WRITE16_MEMBER(write_o);
r243546	r243547
55	55	DECLARE_INPUT_CHANGED_MEMBER(power_button);
56	56	DECLARE_WRITE_LINE_MEMBER(auto_power_off);
57	57
58		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
59		void leds_update();
	58	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	59	void display_update();
60	60
61	61	virtual void machine_reset();
62	62	virtual void machine_start();
r243546	r243547
66	66
67	67	/***************************************************************************
68	68
69		LEDs
	69	LED Display
70	70
71	71	***************************************************************************/
72	72
r243546	r243547
74	74	// To prevent flickering here, we need to simulate a decay.
75	75
76	76	// decay time, in steps of 10ms
77		#define LEDS_DECAY_TIME 4
	77	#define DISPLAY_DECAY_TIME 4
78	78
79		void elecdet_state::leds_update()
	79	void elecdet_state::display_update()
80	80	{
81	81	UINT16 active_state[0x10];
82	82
r243546	r243547
88	88	{
89	89	int di = j << 4 | i;
90	90
91		// turn on powered leds
92		if (m_power_on && m_leds_state[i] >> j & 1)
93		m_leds_decay[di] = LEDS_DECAY_TIME;
	91	// turn on powered segments
	92	if (m_power_on && m_display_state[i] >> j & 1)
	93	m_display_decay[di] = DISPLAY_DECAY_TIME;
94	94
95	95	// determine active state
96		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	96	int ds = (m_display_decay[di] != 0) ? 1 : 0;
97	97	active_state[i] |= (ds << j);
98	98	}
99	99	}
100	100
101	101	// on difference, send to output
102	102	for (int i = 0; i < 0x10; i++)
103		if (m_leds_cache[i] != active_state[i])
	103	if (m_display_cache[i] != active_state[i])
104	104	output_set_digit_value(i, active_state[i]);
105	105
106		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	106	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
107	107	}
108	108
109		TIMER_DEVICE_CALLBACK_MEMBER(elecdet_state::leds_decay_tick)
	109	TIMER_DEVICE_CALLBACK_MEMBER(elecdet_state::display_decay_tick)
110	110	{
111		// slowly turn off unpowered leds
	111	// slowly turn off unpowered segments
112	112	for (int i = 0; i < 0x100; i++)
113		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
114		m_leds_decay[i]--;
	113	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	114	m_display_decay[i]--;
115	115
116		leds_update();
	116	display_update();
117	117	}
118	118
119	119
r243546	r243547
145	145	// R0-R6: select digit
146	146	UINT8 o = BITSWAP8(m_o,7,5,2,1,4,0,6,3) & 0x7f;
147	147	for (int i = 0; i < 7; i++)
148		m_leds_state[i] = (data >> i & 1) ? o : 0;
	148	m_display_state[i] = (data >> i & 1) ? o : 0;
149	149
150		leds_update();
	150	display_update();
151	151
152	152	// R7,R8: speaker on
153	153	m_speaker->level_w((data & 0x180 && m_o & 0x80) ? 1 : 0);
r243546	r243547
249	249	void elecdet_state::machine_start()
250	250	{
251	251	// zerofill
252		memset(m_leds_state, 0, sizeof(m_leds_state));
253		memset(m_leds_cache, 0, sizeof(m_leds_cache));
254		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	252	memset(m_display_state, 0, sizeof(m_display_state));
	253	memset(m_display_cache, 0, sizeof(m_display_cache));
	254	memset(m_display_decay, 0, sizeof(m_display_decay));
255	255
256	256	m_o = 0;
257	257	m_power_on = false;
258	258
259	259	// register for savestates
260		save_item(NAME(m_leds_state));
261		save_item(NAME(m_leds_cache));
262		save_item(NAME(m_leds_decay));
	260	save_item(NAME(m_display_state));
	261	save_item(NAME(m_display_cache));
	262	save_item(NAME(m_display_decay));
263	263
264	264	save_item(NAME(m_o));
265	265	save_item(NAME(m_power_on));
r243546	r243547
275	275	MCFG_TMS1XXX_WRITE_R_CB(WRITE16(elecdet_state, write_r))
276	276	MCFG_TMS1XXX_POWER_OFF_CB(WRITELINE(elecdet_state, auto_power_off))
277	277
278		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", elecdet_state, leds_decay_tick, attotime::from_msec(10))
	278	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", elecdet_state, display_decay_tick, attotime::from_msec(10))
279	279
280	280	MCFG_DEFAULT_LAYOUT(layout_elecdet)
281	281

trunk/src/mess/drivers/splitsec.c

r243546	r243547
72	72	UINT16 m_r;
73	73	UINT16 m_o;
74	74
75		UINT16 m_leds_state[0x10];
76		UINT16 m_leds_cache[0x10];
77		UINT8 m_leds_decay[0x100];
	75	UINT16 m_display_state[0x10];
	76	UINT16 m_display_cache[0x10];
	77	UINT8 m_display_decay[0x100];
78	78
79	79	DECLARE_READ8_MEMBER(read_k);
80	80	DECLARE_WRITE16_MEMBER(write_o);
81	81	DECLARE_WRITE16_MEMBER(splitsec_write_r);
82	82	DECLARE_WRITE16_MEMBER(bankshot_write_r);
83	83
84		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
85		void leds_update();
	84	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	85	void display_update();
86	86
87	87	virtual void machine_start();
88	88	};
r243546	r243547
91	91
92	92	/***************************************************************************
93	93
94		LEDs
	94	LED Display
95	95
96	96	***************************************************************************/
97	97
r243546	r243547
99	99	// To prevent flickering here, we need to simulate a decay.
100	100
101	101	// decay time, in steps of 10ms
102		#define LEDS_DECAY_TIME 4
	102	#define DISPLAY_DECAY_TIME 4
103	103
104	104	/* display layout, where number xy is lamp R(x),O(y)
105	105
r243546	r243547
122	122
123	123	*/
124	124
125		void splitsec_state::leds_update()
	125	void splitsec_state::display_update()
126	126	{
127	127	UINT16 active_state[0x10];
128	128
129	129	for (int i = 0; i < 0x10; i++)
130	130	{
131	131	// update current state
132		m_leds_state[i] = (m_r >> i & 1) ? m_o : 0;
	132	m_display_state[i] = (m_r >> i & 1) ? m_o : 0;
133	133
134	134	active_state[i] = 0;
135	135
r243546	r243547
137	137	{
138	138	int di = j << 4 | i;
139	139
140		// turn on powered leds
141		if (m_leds_state[i] >> j & 1)
142		m_leds_decay[di] = LEDS_DECAY_TIME;
	140	// turn on powered segments
	141	if (m_display_state[i] >> j & 1)
	142	m_display_decay[di] = DISPLAY_DECAY_TIME;
143	143
144	144	// determine active state
145		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	145	int ds = (m_display_decay[di] != 0) ? 1 : 0;
146	146	active_state[i] |= (ds << j);
147	147	}
148	148	}
149	149
150	150	// on difference, send to output
151	151	for (int i = 0; i < 0x10; i++)
152		if (m_leds_cache[i] != active_state[i])
	152	if (m_display_cache[i] != active_state[i])
153	153	{
154	154	for (int j = 0; j < 8; j++)
155	155	output_set_lamp_value(i*10 + j, active_state[i] >> j & 1);
156	156	}
157	157
158		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	158	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
159	159	}
160	160
161		TIMER_DEVICE_CALLBACK_MEMBER(splitsec_state::leds_decay_tick)
	161	TIMER_DEVICE_CALLBACK_MEMBER(splitsec_state::display_decay_tick)
162	162	{
163		// slowly turn off unpowered leds
	163	// slowly turn off unpowered segments
164	164	for (int i = 0; i < 0x100; i++)
165		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
166		m_leds_decay[i]--;
	165	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	166	m_display_decay[i]--;
167	167
168		leds_update();
	168	display_update();
169	169	}
170	170
171	171
r243546	r243547
193	193	// O0-O6: led rows
194	194	// O7: N/C
195	195	m_o = data;
196		leds_update();
	196	display_update();
197	197	}
198	198
199	199	WRITE16_MEMBER(splitsec_state::splitsec_write_r)
r243546	r243547
206	206
207	207	// R0-R7: led columns
208	208	m_r = data & 0xff;
209		leds_update();
	209	display_update();
210	210	}
211	211
212	212	WRITE16_MEMBER(splitsec_state::bankshot_write_r)
r243546	r243547
219	219
220	220	// R2-R10: led columns
221	221	m_r = data & ~3;
222		leds_update();
	222	display_update();
223	223	}
224	224
225	225
r243546	r243547
281	281	void splitsec_state::machine_start()
282	282	{
283	283	// zerofill
284		memset(m_leds_state, 0, sizeof(m_leds_state));
285		memset(m_leds_cache, 0, sizeof(m_leds_cache));
286		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	284	memset(m_display_state, 0, sizeof(m_display_state));
	285	memset(m_display_cache, 0, sizeof(m_display_cache));
	286	memset(m_display_decay, 0, sizeof(m_display_decay));
287	287
288	288	m_input_mux = 0;
289	289	m_r = 0;
290	290	m_o = 0;
291	291
292	292	// register for savestates
293		save_item(NAME(m_leds_state));
294		save_item(NAME(m_leds_cache));
295		save_item(NAME(m_leds_decay));
	293	save_item(NAME(m_display_state));
	294	save_item(NAME(m_display_cache));
	295	save_item(NAME(m_display_decay));
296	296
297	297	save_item(NAME(m_input_mux));
298	298	save_item(NAME(m_r));
r243546	r243547
308	308	MCFG_TMS1XXX_WRITE_O_CB(WRITE16(splitsec_state, write_o))
309	309	MCFG_TMS1XXX_WRITE_R_CB(WRITE16(splitsec_state, splitsec_write_r))
310	310
311		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", splitsec_state, leds_decay_tick, attotime::from_msec(10))
	311	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", splitsec_state, display_decay_tick, attotime::from_msec(10))
312	312
313	313	MCFG_DEFAULT_LAYOUT(layout_splitsec)
314	314

trunk/src/mess/drivers/starwbc.c

r243546	r243547
39	39	UINT16 m_r;
40	40	UINT16 m_o;
41	41
42		UINT16 m_leds_state[0x10];
43		UINT16 m_leds_cache[0x10];
44		UINT8 m_leds_decay[0x100];
	42	UINT16 m_display_state[0x10];
	43	UINT16 m_display_cache[0x10];
	44	UINT8 m_display_decay[0x100];
45	45
46	46	DECLARE_READ8_MEMBER(read_k);
47	47	DECLARE_WRITE16_MEMBER(write_o);
48	48	DECLARE_WRITE16_MEMBER(write_r);
49	49
50		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
51		void leds_update();
	50	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	51	void display_update();
52	52	void prepare_and_update();
53	53
54	54	virtual void machine_start();
r243546	r243547
58	58
59	59	/***************************************************************************
60	60
61		LEDs
	61	LED Display
62	62
63	63	***************************************************************************/
64	64
r243546	r243547
66	66	// To prevent flickering here, we need to simulate a decay.
67	67
68	68	// decay time, in steps of 10ms
69		#define LEDS_DECAY_TIME 4
	69	#define DISPLAY_DECAY_TIME 4
70	70
71		void starwbc_state::leds_update()
	71	void starwbc_state::display_update()
72	72	{
73	73	UINT16 active_state[0x10];
74	74
r243546	r243547
80	80	{
81	81	int di = j << 4 | i;
82	82
83		// turn on powered leds
84		if (m_leds_state[i] >> j & 1)
85		m_leds_decay[di] = LEDS_DECAY_TIME;
	83	// turn on powered segments
	84	if (m_display_state[i] >> j & 1)
	85	m_display_decay[di] = DISPLAY_DECAY_TIME;
86	86
87	87	// determine active state
88		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	88	int ds = (m_display_decay[di] != 0) ? 1 : 0;
89	89	active_state[i] |= (ds << j);
90	90	}
91	91	}
92	92
93	93	// on difference, send to output
94	94	for (int i = 0; i < 0x10; i++)
95		if (m_leds_cache[i] != active_state[i])
	95	if (m_display_cache[i] != active_state[i])
96	96	{
97	97	output_set_digit_value(i, active_state[i]);
98	98
r243546	r243547
100	100	output_set_lamp_value(i*10 + j, active_state[i] >> j & 1);
101	101	}
102	102
103		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	103	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
104	104	}
105	105
106		TIMER_DEVICE_CALLBACK_MEMBER(starwbc_state::leds_decay_tick)
	106	TIMER_DEVICE_CALLBACK_MEMBER(starwbc_state::display_decay_tick)
107	107	{
108		// slowly turn off unpowered leds
	108	// slowly turn off unpowered segments
109	109	for (int i = 0; i < 0x100; i++)
110		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
111		m_leds_decay[i]--;
	110	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	111	m_display_decay[i]--;
112	112
113		leds_update();
	113	display_update();
114	114	}
115	115
116	116	void starwbc_state::prepare_and_update()
r243546	r243547
120	120
121	121	// R0,R2,R4,R6,R8
122	122	for (int i = 0; i < 5; i++)
123		m_leds_state[i*2] = (m_r >> (i*2) & 1) ? (o & mask[i]) : 0;
	123	m_display_state[i*2] = (m_r >> (i*2) & 1) ? (o & mask[i]) : 0;
124	124
125		leds_update();
	125	display_update();
126	126	}
127	127
128	128
r243546	r243547
227	227	void starwbc_state::machine_start()
228	228	{
229	229	// zerofill
230		memset(m_leds_state, 0, sizeof(m_leds_state));
231		memset(m_leds_cache, 0, sizeof(m_leds_cache));
232		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	230	memset(m_display_state, 0, sizeof(m_display_state));
	231	memset(m_display_cache, 0, sizeof(m_display_cache));
	232	memset(m_display_decay, 0, sizeof(m_display_decay));
233	233
234	234	m_r = 0;
235	235	m_o = 0;
236	236
237	237	// register for savestates
238		save_item(NAME(m_leds_state));
239		save_item(NAME(m_leds_cache));
240		save_item(NAME(m_leds_decay));
	238	save_item(NAME(m_display_state));
	239	save_item(NAME(m_display_cache));
	240	save_item(NAME(m_display_decay));
241	241
242	242	save_item(NAME(m_r));
243	243	save_item(NAME(m_o));
r243546	r243547
252	252	MCFG_TMS1XXX_WRITE_O_CB(WRITE16(starwbc_state, write_o))
253	253	MCFG_TMS1XXX_WRITE_R_CB(WRITE16(starwbc_state, write_r))
254	254
255		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", starwbc_state, leds_decay_tick, attotime::from_msec(10))
	255	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", starwbc_state, display_decay_tick, attotime::from_msec(10))
256	256
257	257	MCFG_DEFAULT_LAYOUT(layout_starwbc)
258	258

trunk/src/mess/drivers/stopthie.c

r243546	r243547
43	43	UINT16 m_o;
44	44	bool m_power_on;
45	45
46		UINT16 m_leds_state[0x10];
47		UINT16 m_leds_cache[0x10];
48		UINT8 m_leds_decay[0x100];
	46	UINT16 m_display_state[0x10];
	47	UINT16 m_display_cache[0x10];
	48	UINT8 m_display_decay[0x100];
49	49
50	50	DECLARE_READ8_MEMBER(read_k);
51	51	DECLARE_WRITE16_MEMBER(write_o);
r243546	r243547
54	54	DECLARE_INPUT_CHANGED_MEMBER(power_button);
55	55	DECLARE_WRITE_LINE_MEMBER(auto_power_off);
56	56
57		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
58		void leds_update();
	57	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	58	void display_update();
59	59
60	60	virtual void machine_reset();
61	61	virtual void machine_start();
r243546	r243547
65	65
66	66	/***************************************************************************
67	67
68		LEDs
	68	LED Display
69	69
70	70	***************************************************************************/
71	71
r243546	r243547
73	73	// To prevent flickering here, we need to simulate a decay.
74	74
75	75	// decay time, in steps of 10ms
76		#define LEDS_DECAY_TIME 4
	76	#define DISPLAY_DECAY_TIME 4
77	77
78		void stopthief_state::leds_update()
	78	void stopthief_state::display_update()
79	79	{
80	80	UINT16 active_state[0x10];
81	81
r243546	r243547
87	87	{
88	88	int di = j << 4 | i;
89	89
90		// turn on powered leds
91		if (m_power_on && m_leds_state[i] >> j & 1)
92		m_leds_decay[di] = LEDS_DECAY_TIME;
	90	// turn on powered segments
	91	if (m_power_on && m_display_state[i] >> j & 1)
	92	m_display_decay[di] = DISPLAY_DECAY_TIME;
93	93
94	94	// determine active state
95		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	95	int ds = (m_display_decay[di] != 0) ? 1 : 0;
96	96	active_state[i] |= (ds << j);
97	97	}
98	98	}
99	99
100	100	// on difference, send to output
101	101	for (int i = 0; i < 0x10; i++)
102		if (m_leds_cache[i] != active_state[i])
	102	if (m_display_cache[i] != active_state[i])
103	103	output_set_digit_value(i, active_state[i]);
104	104
105		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	105	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
106	106	}
107	107
108		TIMER_DEVICE_CALLBACK_MEMBER(stopthief_state::leds_decay_tick)
	108	TIMER_DEVICE_CALLBACK_MEMBER(stopthief_state::display_decay_tick)
109	109	{
110		// slowly turn off unpowered leds
	110	// slowly turn off unpowered segments
111	111	for (int i = 0; i < 0x100; i++)
112		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
113		m_leds_decay[i]--;
	112	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	113	m_display_decay[i]--;
114	114
115		leds_update();
	115	display_update();
116	116	}
117	117
118	118
r243546	r243547
144	144	// R0-R2: select digit
145	145	UINT8 o = BITSWAP8(m_o,3,5,2,1,4,0,6,7) & 0x7f;
146	146	for (int i = 0; i < 3; i++)
147		m_leds_state[i] = (data >> i & 1) ? o : 0;
	147	m_display_state[i] = (data >> i & 1) ? o : 0;
148	148
149		leds_update();
	149	display_update();
150	150
151	151	// R3-R8: speaker on
152	152	m_speaker->level_w((data & 0x1f8 && m_o & 8) ? 1 : 0);
r243546	r243547
234	234	void stopthief_state::machine_start()
235	235	{
236	236	// zerofill
237		memset(m_leds_state, 0, sizeof(m_leds_state));
238		memset(m_leds_cache, 0, sizeof(m_leds_cache));
239		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	237	memset(m_display_state, 0, sizeof(m_display_state));
	238	memset(m_display_cache, 0, sizeof(m_display_cache));
	239	memset(m_display_decay, 0, sizeof(m_display_decay));
240	240
241	241	m_o = 0;
242	242	m_power_on = false;
243	243
244	244	// register for savestates
245		save_item(NAME(m_leds_state));
246		save_item(NAME(m_leds_cache));
247		save_item(NAME(m_leds_decay));
	245	save_item(NAME(m_display_state));
	246	save_item(NAME(m_display_cache));
	247	save_item(NAME(m_display_decay));
248	248
249	249	save_item(NAME(m_o));
250	250	save_item(NAME(m_power_on));
r243546	r243547
260	260	MCFG_TMS1XXX_WRITE_R_CB(WRITE16(stopthief_state, write_r))
261	261	MCFG_TMS1XXX_POWER_OFF_CB(WRITELINE(stopthief_state, auto_power_off))
262	262
263		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", stopthief_state, leds_decay_tick, attotime::from_msec(10))
	263	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", stopthief_state, display_decay_tick, attotime::from_msec(10))
264	264
265	265	MCFG_DEFAULT_LAYOUT(layout_stopthie)
266	266

trunk/src/mess/drivers/ticalc1x.c

r243546	r243547
37	37	UINT16 m_o;
38	38	bool m_power_on;
39	39
40		UINT16 m_leds_state[0x10];
41		UINT16 m_leds_cache[0x10];
42		UINT8 m_leds_decay[0x100];
	40	UINT16 m_display_state[0x10];
	41	UINT16 m_display_cache[0x10];
	42	UINT8 m_display_decay[0x100];
43	43
44	44	DECLARE_READ8_MEMBER(tisr16_read_k);
45	45	DECLARE_WRITE16_MEMBER(tisr16_write_o);
46	46	DECLARE_WRITE16_MEMBER(tisr16_write_r);
47		void tisr16_leds_update();
	47	void tisr16_display_update();
48	48
49	49	DECLARE_READ8_MEMBER(ti1270_read_k);
50	50	DECLARE_WRITE16_MEMBER(ti1270_write_o);
r243546	r243547
61	61	DECLARE_INPUT_CHANGED_MEMBER(power_button);
62	62	DECLARE_WRITE_LINE_MEMBER(auto_power_off);
63	63
64		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
65		void leds_update();
	64	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	65	void display_update();
66	66
67	67	virtual void machine_reset();
68	68	virtual void machine_start();
r243546	r243547
72	72
73	73	/***************************************************************************
74	74
75		LEDs
	75	LED Display
76	76
77	77	***************************************************************************/
78	78
r243546	r243547
80	80	// To prevent flickering here, we need to simulate a decay.
81	81
82	82	// decay time, in steps of 10ms
83		#define LEDS_DECAY_TIME 5
	83	#define DISPLAY_DECAY_TIME 5
84	84
85		void ticalc1x_state::leds_update()
	85	void ticalc1x_state::display_update()
86	86	{
87	87	UINT16 active_state[0x10];
88	88
r243546	r243547
94	94	{
95	95	int di = j << 4 | i;
96	96
97		// turn on powered leds
98		if (m_power_on && m_leds_state[i] >> j & 1)
99		m_leds_decay[di] = LEDS_DECAY_TIME;
	97	// turn on powered segments
	98	if (m_power_on && m_display_state[i] >> j & 1)
	99	m_display_decay[di] = DISPLAY_DECAY_TIME;
100	100
101	101	// determine active state
102		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	102	int ds = (m_display_decay[di] != 0) ? 1 : 0;
103	103	active_state[i] |= (ds << j);
104	104	}
105	105	}
106	106
107	107	// on difference, send to output
108	108	for (int i = 0; i < 0x10; i++)
109		if (m_leds_cache[i] != active_state[i])
	109	if (m_display_cache[i] != active_state[i])
110	110	{
111	111	output_set_digit_value(i, active_state[i]);
112	112
r243546	r243547
114	114	output_set_lamp_value(i*10 + j, active_state[i] >> j & 1);
115	115	}
116	116
117		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	117	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
118	118	}
119	119
120		TIMER_DEVICE_CALLBACK_MEMBER(ticalc1x_state::leds_decay_tick)
	120	TIMER_DEVICE_CALLBACK_MEMBER(ticalc1x_state::display_decay_tick)
121	121	{
122		// slowly turn off unpowered leds
	122	// slowly turn off unpowered segments
123	123	for (int i = 0; i < 0x100; i++)
124		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
125		m_leds_decay[i]--;
	124	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	125	m_display_decay[i]--;
126	126
127		leds_update();
	127	display_update();
128	128	}
129	129
130	130
r243546	r243547
137	137
138	138	// SR-16: TMS1000 MCU labeled TMS1001NL. die labeled 1001A
139	139
140		void ticalc1x_state::tisr16_leds_update()
	140	void ticalc1x_state::tisr16_display_update()
141	141	{
142	142	// update leds state
143	143	for (int i = 0; i < 11; i++)
144	144	if (m_r >> i & 1)
145		m_leds_state[i] = m_o;
	145	m_display_state[i] = m_o;
146	146
147	147	// exponent sign (not 100% sure this is correct)
148		m_leds_state[11] = (m_leds_state[0] | m_leds_state[1]) ? 0x40 : 0;
	148	m_display_state[11] = (m_display_state[0] | m_display_state[1]) ? 0x40 : 0;
149	149
150	150	// send to output
151	151	for (int i = 0; i < 12; i++)
152		output_set_digit_value(i, m_leds_state[i]);
	152	output_set_digit_value(i, m_display_state[i]);
153	153	}
154	154
155	155	READ8_MEMBER(ticalc1x_state::tisr16_read_k)
r243546	r243547
170	170	// R0-R10: select digit (right-to-left)
171	171	m_r = data;
172	172
173		tisr16_leds_update();
	173	tisr16_display_update();
174	174	}
175	175
176	176	WRITE16_MEMBER(ticalc1x_state::tisr16_write_o)
r243546	r243547
178	178	// O0-O7: digit segments
179	179	m_o = data;
180	180
181		tisr16_leds_update();
	181	tisr16_display_update();
182	182	}
183	183
184	184
r243546	r243547
200	200	{
201	201	// R0-R7: select digit (right-to-left)
202	202	for (int i = 0; i < 8; i++)
203		m_leds_state[i] = (data >> i & 1) ? m_o : 0;
	203	m_display_state[i] = (data >> i & 1) ? m_o : 0;
204	204
205		leds_update();
	205	display_update();
206	206	}
207	207
208	208	WRITE16_MEMBER(ticalc1x_state::ti1270_write_o)
r243546	r243547
232	232	// R0-R8: select digit (right-to-left)
233	233	// note: 3rd digit is custom(not 7seg), for math symbols
234	234	for (int i = 0; i < 9; i++)
235		m_leds_state[i] = (data >> i & 1) ? m_o : 0;
	235	m_display_state[i] = (data >> i & 1) ? m_o : 0;
236	236
237	237	// 6th digit only has A and G for =
238		m_leds_state[3] &= 0x41;
	238	m_display_state[3] &= 0x41;
239	239
240		leds_update();
	240	display_update();
241	241	}
242	242
243	243	WRITE16_MEMBER(ticalc1x_state::wizatron_write_o)
r243546	r243547
271	271	// R0-R8: select digit
272	272	UINT8 o = BITSWAP8(m_o,7,5,2,1,4,0,6,3);
273	273	for (int i = 0; i < 9; i++)
274		m_leds_state[i] = (data >> i & 1) ? o : 0;
	274	m_display_state[i] = (data >> i & 1) ? o : 0;
275	275
276	276	// 1st digit only has segments B,F,G,DP
277		m_leds_state[0] &= 0xe2;
	277	m_display_state[0] &= 0xe2;
278	278
279		leds_update();
	279	display_update();
280	280	}
281	281
282	282	WRITE16_MEMBER(ticalc1x_state::ti30_write_o)
r243546	r243547
654	654	void ticalc1x_state::machine_start()
655	655	{
656	656	// zerofill
657		memset(m_leds_state, 0, sizeof(m_leds_state));
658		memset(m_leds_cache, 0, sizeof(m_leds_cache));
659		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	657	memset(m_display_state, 0, sizeof(m_display_state));
	658	memset(m_display_cache, 0, sizeof(m_display_cache));
	659	memset(m_display_decay, 0, sizeof(m_display_decay));
660	660
661	661	m_r = 0;
662	662	m_o = 0;
663	663	m_power_on = false;
664	664
665	665	// register for savestates
666		save_item(NAME(m_leds_state));
667		save_item(NAME(m_leds_cache));
668		save_item(NAME(m_leds_decay));
	666	save_item(NAME(m_display_state));
	667	save_item(NAME(m_display_cache));
	668	save_item(NAME(m_display_decay));
669	669
670	670	save_item(NAME(m_r));
671	671	save_item(NAME(m_o));
r243546	r243547
688	688	static MACHINE_CONFIG_START( t9base, ticalc1x_state )
689	689
690	690	/* basic machine hardware */
691		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", ticalc1x_state, leds_decay_tick, attotime::from_msec(10))
	691	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", ticalc1x_state, display_decay_tick, attotime::from_msec(10))
692	692
693	693	/* no video! */
694	694

trunk/src/mess/drivers/tispeak.c

r243546	r243547
54	54	UINT16 m_o;
55	55	int m_power_on;
56	56
57		UINT16 m_leds_state[0x10];
58		UINT16 m_leds_cache[0x10];
59		UINT8 m_leds_decay[0x100];
60		void leds_update();
61		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
	57	UINT16 m_display_state[0x10];
	58	UINT16 m_display_cache[0x10];
	59	UINT8 m_display_decay[0x100];
	60	void display_update();
	61	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
62	62
63	63	UINT32 m_cart_max_size;
64	64	UINT8* m_cart_base;
r243546	r243547
128	128	// To prevent flickering here, we need to simulate a decay.
129	129
130	130	// decay time, in steps of 10ms
131		#define LEDS_DECAY_TIME 4
	131	#define DISPLAY_DECAY_TIME 4
132	132
133		void tispeak_state::leds_update()
	133	void tispeak_state::display_update()
134	134	{
135	135	int filament_on = (m_r & 0x8000) ? 1 : 0;
136	136	UINT16 active_state[0x10];
r243546	r243547
138	138	for (int i = 0; i < 0x10; i++)
139	139	{
140	140	// update current state
141		m_leds_state[i] = (m_r >> i & 1) ? m_o : 0;
	141	m_display_state[i] = (m_r >> i & 1) ? m_o : 0;
142	142
143	143	active_state[i] = 0;
144	144
r243546	r243547
146	146	{
147	147	int di = j << 4 | i;
148	148
149		// turn on powered leds
150		if (m_power_on && filament_on && m_leds_state[i] >> j & 1)
151		m_leds_decay[di] = LEDS_DECAY_TIME;
	149	// turn on powered segments
	150	if (m_power_on && filament_on && m_display_state[i] >> j & 1)
	151	m_display_decay[di] = DISPLAY_DECAY_TIME;
152	152
153	153	// determine active state
154		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	154	int ds = (m_display_decay[di] != 0) ? 1 : 0;
155	155	active_state[i] |= (ds << j);
156	156	}
157	157	}
158	158
159	159	// on difference, send to output
160	160	for (int i = 0; i < 0x10; i++)
161		if (m_leds_cache[i] != active_state[i])
	161	if (m_display_cache[i] != active_state[i])
162	162	{
163	163	output_set_digit_value(i, active_state[i] & 0x3fff);
164	164
r243546	r243547
166	166	output_set_lamp_value(i*0x10 + j, active_state[i] >> j & 1);
167	167	}
168	168
169		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	169	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
170	170	}
171	171
172		TIMER_DEVICE_CALLBACK_MEMBER(tispeak_state::leds_decay_tick)
	172	TIMER_DEVICE_CALLBACK_MEMBER(tispeak_state::display_decay_tick)
173	173	{
174		// slowly turn off unpowered leds
	174	// slowly turn off unpowered segments
175	175	for (int i = 0; i < 0x100; i++)
176		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
177		m_leds_decay[i]--;
	176	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	177	m_display_decay[i]--;
178	178
179		leds_update();
	179	display_update();
180	180	}
181	181
182	182
r243546	r243547
212	212
213	213	// other bits: MCU internal use
214	214	m_r = data;
215		leds_update();
	215	display_update();
216	216	}
217	217
218	218	WRITE16_MEMBER(tispeak_state::snspell_write_o)
r243546	r243547
221	221	// E,D,C,G,B,A,I,M,L,K,N,J,[AP],H,F,[DP] (sidenote: TI KLMN = MAME MLNK)
222	222	m_o = BITSWAP16(data,12,15,10,7,8,9,11,6,13,3,14,0,1,2,4,5);
223	223
224		leds_update();
	224	display_update();
225	225	}
226	226
227	227
r243546	r243547
243	243	// [DP],D,C,H,F,B,I,M,L,K,N,J,[AP],E,G,A (sidenote: TI KLMN = MAME MLNK)
244	244	m_o = BITSWAP16(data,12,0,10,7,8,9,11,6,3,14,4,13,1,2,5,15);
245	245
246		leds_update();
	246	display_update();
247	247	}
248	248
249	249
r243546	r243547
253	253	{
254	254	// same as default, except R13 is used for an extra digit
255	255	m_r = data;
256		leds_update();
	256	display_update();
257	257	}
258	258
259	259
r243546	r243547
442	442	void tispeak_state::machine_start()
443	443	{
444	444	// zerofill
445		memset(m_leds_state, 0, sizeof(m_leds_state));
446		memset(m_leds_cache, 0, sizeof(m_leds_cache));
447		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	445	memset(m_display_state, 0, sizeof(m_display_state));
	446	memset(m_display_cache, 0, sizeof(m_display_cache));
	447	memset(m_display_decay, 0, sizeof(m_display_decay));
448	448
449	449	m_r = 0;
450	450	m_o = 0;
451	451	m_power_on = 0;
452	452
453	453	// register for savestates
454		save_item(NAME(m_leds_state));
455		save_item(NAME(m_leds_cache));
456		save_item(NAME(m_leds_decay));
	454	save_item(NAME(m_display_state));
	455	save_item(NAME(m_display_cache));
	456	save_item(NAME(m_display_decay));
457	457
458	458	save_item(NAME(m_r));
459	459	save_item(NAME(m_o));
r243546	r243547
482	482	MCFG_TMS0270_WRITE_CTL_CB(DEVWRITE8("tms5100", tms5100_device, ctl_w))
483	483	MCFG_TMS0270_WRITE_PDC_CB(DEVWRITELINE("tms5100", tms5100_device, pdc_w))
484	484
485		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", tispeak_state, leds_decay_tick, attotime::from_msec(10))
	485	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", tispeak_state, display_decay_tick, attotime::from_msec(10))
486	486	MCFG_DEFAULT_LAYOUT(layout_snspell) // max 9 digits
487	487
488	488	/* no video! */

trunk/src/mess/drivers/wildfire.c

r243546	r243547
46	46	UINT8 m_d;
47	47	UINT16 m_a;
48	48
49		UINT16 m_leds_state[0x10];
50		UINT16 m_leds_cache[0x10];
51		UINT8 m_leds_decay[0x100];
	49	UINT16 m_display_state[0x10];
	50	UINT16 m_display_cache[0x10];
	51	UINT8 m_display_decay[0x100];
52	52
53	53	DECLARE_READ8_MEMBER(read_k);
54	54	DECLARE_WRITE8_MEMBER(write_d);
55	55	DECLARE_WRITE16_MEMBER(write_a);
56	56
57		TIMER_DEVICE_CALLBACK_MEMBER(leds_decay_tick);
58		void leds_update();
	57	TIMER_DEVICE_CALLBACK_MEMBER(display_decay_tick);
	58	void display_update();
59	59	bool index_is_7segled(int index);
60	60
61	61	virtual void machine_start();
r243546	r243547
65	65
66	66	/***************************************************************************
67	67
68		LEDs
	68	LED Display
69	69
70	70	***************************************************************************/
71	71
r243546	r243547
73	73	// To prevent flickering here, we need to simulate a decay.
74	74
75	75	// decay time, in steps of 10ms
76		#define LEDS_DECAY_TIME 4
	76	#define DISPLAY_DECAY_TIME 4
77	77
78	78	inline bool wildfire_state::index_is_7segled(int index)
79	79	{
r243546	r243547
81	81	return (index < 3);
82	82	}
83	83
84		void wildfire_state::leds_update()
	84	void wildfire_state::display_update()
85	85	{
86	86	UINT16 active_state[0x10];
87	87
88	88	for (int i = 0; i < 0x10; i++)
89	89	{
90	90	// update current state
91		m_leds_state[i] = (~m_a >> i & 1) ? m_d : 0;
	91	m_display_state[i] = (~m_a >> i & 1) ? m_d : 0;
92	92
93	93	active_state[i] = 0;
94	94
r243546	r243547
96	96	{
97	97	int di = j << 4 | i;
98	98
99		// turn on powered leds
100		if (m_leds_state[i] >> j & 1)
101		m_leds_decay[di] = LEDS_DECAY_TIME;
	99	// turn on powered segments
	100	if (m_display_state[i] >> j & 1)
	101	m_display_decay[di] = DISPLAY_DECAY_TIME;
102	102
103	103	// determine active state
104		int ds = (m_leds_decay[di] != 0) ? 1 : 0;
	104	int ds = (m_display_decay[di] != 0) ? 1 : 0;
105	105	active_state[i] |= (ds << j);
106	106	}
107	107	}
108	108
109	109	// on difference, send to output
110	110	for (int i = 0; i < 0x10; i++)
111		if (m_leds_cache[i] != active_state[i])
	111	if (m_display_cache[i] != active_state[i])
112	112	{
113	113	if (index_is_7segled(i))
114	114	output_set_digit_value(i, BITSWAP8(active_state[i],7,0,1,2,3,4,5,6) & 0x7f);
r243546	r243547
117	117	output_set_lamp_value(i*10 + j, active_state[i] >> j & 1);
118	118	}
119	119
120		memcpy(m_leds_cache, active_state, sizeof(m_leds_cache));
	120	memcpy(m_display_cache, active_state, sizeof(m_display_cache));
121	121	}
122	122
123		TIMER_DEVICE_CALLBACK_MEMBER(wildfire_state::leds_decay_tick)
	123	TIMER_DEVICE_CALLBACK_MEMBER(wildfire_state::display_decay_tick)
124	124	{
125		// slowly turn off unpowered leds
	125	// slowly turn off unpowered segments
126	126	for (int i = 0; i < 0x100; i++)
127		if (!(m_leds_state[i & 0xf] >> (i>>4) & 1) && m_leds_decay[i])
128		m_leds_decay[i]--;
	127	if (!(m_display_state[i & 0xf] >> (i>>4) & 1) && m_display_decay[i])
	128	m_display_decay[i]--;
129	129
130		leds_update();
	130	display_update();
131	131	}
132	132
133	133
r243546	r243547
147	147	WRITE8_MEMBER(wildfire_state::write_d)
148	148	{
149	149	m_d = data;
150		leds_update();
	150	display_update();
151	151	}
152	152
153	153	WRITE16_MEMBER(wildfire_state::write_a)
154	154	{
155	155	m_a = data;
156		leds_update();
	156	display_update();
157	157	}
158	158
159	159
r243546	r243547
183	183	void wildfire_state::machine_start()
184	184	{
185	185	// zerofill
186		memset(m_leds_state, 0, sizeof(m_leds_state));
187		memset(m_leds_cache, 0, sizeof(m_leds_cache));
188		memset(m_leds_decay, 0, sizeof(m_leds_decay));
	186	memset(m_display_state, 0, sizeof(m_display_state));
	187	memset(m_display_cache, 0, sizeof(m_display_cache));
	188	memset(m_display_decay, 0, sizeof(m_display_decay));
189	189
190	190	m_d = 0;
191	191	m_a = 0;
192	192
193	193	// register for savestates
194		save_item(NAME(m_leds_state));
195		save_item(NAME(m_leds_cache));
196		save_item(NAME(m_leds_decay));
	194	save_item(NAME(m_display_state));
	195	save_item(NAME(m_display_cache));
	196	save_item(NAME(m_display_decay));
197	197
198	198	save_item(NAME(m_d));
199	199	save_item(NAME(m_a));
r243546	r243547
209	209	MCFG_AMI_S2000_WRITE_D_CB(WRITE8(wildfire_state, write_d))
210	210	MCFG_AMI_S2000_WRITE_A_CB(WRITE16(wildfire_state, write_a))
211	211
212		MCFG_TIMER_DRIVER_ADD_PERIODIC("leds_decay", wildfire_state, leds_decay_tick, attotime::from_msec(10))
	212	MCFG_TIMER_DRIVER_ADD_PERIODIC("display_decay", wildfire_state, display_decay_tick, attotime::from_msec(10))
213	213
214	214	MCFG_DEFAULT_LAYOUT(layout_wildfire)
215	215

https://github.com/mamedev/mame/commit/d2c0b19c1b110b37b53dc70cd862d3bb7f4e00e8

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team