source: buchla-68k/ram/sqexec.c@ b28a12e

Last change on this file since b28a12e was b28a12e, checked in by Thomas Lopatic <thomas@…>, 7 years ago

Zero redundant declarations.
  • Property mode set to 100644
File size: 6.9 KB
Line 
1/*
2 =============================================================================
3 sqexec.c -- MIDAS-VII sequence action execution code
4 Version 12 -- 1988-12-13 -- D.N. Lynx Crowe
5 =============================================================================
6*/
7
8#define DEBUGSX 0
9#define DEBUGSP 0
10
11#define UPD_LINE 1
12
13#include "ram.h"
14
15#if DEBUGSP
16short debugsp = 1;
17#endif
18
19#if DEBUGSX
20short debugsx = 1;
21#endif
22
23int16_t seqdspn;
24
25int16_t rtab[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F,
26 0x003F, 0x003F, 0x003F };
27
28/*
29
30*/
31
32/*
33 =============================================================================
34 evaltv() -- evaluate a typed value
35 =============================================================================
36*/
37
38uint16_t evaltv(uint16_t dat)
39{
40 switch (SQ_MTYP & dat) {
41
42 case SQ_REG: /* register contents */
43
44 return(sregval[SQ_MVAL & dat]);
45
46 case SQ_VAL: /* constant value */
47
48 return(SQ_MVAL & dat);
49
50 case SQ_VLT: /* voltage input */
51
52 return(0);
53
54 case SQ_RND: /* random number */
55
56 return((int16_t)rand24() & rtab[SQ_MVAL & dat]);
57
58 default: /* something weird got in here ... */
59
60 return(0);
61 }
62}
63
64/*
65
66*/
67
68/*
69 =============================================================================
70 dosqact() -- do a sequence action
71 =============================================================================
72*/
73
74int16_t dosqact(uint16_t seq, uint16_t act, uint16_t dat)
75{
76 register uint16_t obj, val;
77 register int16_t sv;
78
79 obj = (SQ_MOBJ & act) >> 8;
80 val = SQ_MVAL & dat;
81
82 switch (SQ_MACT & act) {
83
84 case SQ_NULL: /* null action */
85
86 return(0);
87
88 case SQ_CKEY: /* Key closure */
89
90 putwq(&ptefifo, dat & TRG_MASK);
91 return(0);
92
93 case SQ_RKEY: /* Key release */
94
95 putwq(&ptefifo, dat | 0x8000);
96 return(0);
97
98 case SQ_TKEY: /* Key transient */
99
100 putwq(&ptefifo, dat & TRG_MASK); /* closure */
101 putwq(&ptefifo, dat | 0x8000); /* release */
102 return(0);
103
104 case SQ_IKEY: /* If key active */
105
106 if (trgtab[TRG_MASK & dat])
107 return(0);
108 else
109 return(1);
110/*
111
112*/
113 case SQ_STRG: /* Trigger on */
114
115 trstate[val] = 1;
116 putwq(&ptefifo, (0x1100 | val));
117 seqdupd |= (1 << val);
118 return(0);
119
120 case SQ_CTRG: /* Trigger off */
121
122 trstate[val] = 0;
123 seqdupd |= (1 << val);
124 return(0);
125
126 case SQ_TTRG: /* Trigger toggle */
127
128 trstate[val] = trstate[val] ? 0 : 1;
129
130 if (trstate[val])
131 putwq(&ptefifo, (0x1100 | val));
132
133 seqdupd |= (1 << val);
134 return(0);
135
136 case SQ_ITRG: /* If trigger active */
137
138 return(trstate[val] ? 0 : 1);
139/*
140
141*/
142 case SQ_SREG: /* Set register */
143
144 sregval[obj] = evaltv(dat);
145 seqdupd |= (1 << obj);
146 return(0);
147
148 case SQ_AREG: /* Increment register */
149
150 if (dat & SQ_MFLG) {
151
152 sv = sregval[obj] - evaltv(dat);
153
154 if (sv < 0)
155 sv = 0;
156
157 sregval[obj] = sv;
158
159 } else {
160
161 sv = sregval[obj] + evaltv(dat);
162
163 if (sv > 99)
164 sv = 99;
165
166 sregval[obj] = sv;
167
168 }
169
170 seqdupd |= (1 << obj);
171 return(0);
172
173 case SQ_IREQ: /* If register = */
174
175 val = evaltv(dat);
176
177 if (sregval[obj] EQ val)
178 return(0);
179 else
180 return(1);
181
182 case SQ_IRLT: /* If register < */
183
184 val = evaltv(dat);
185
186 if (sregval[obj] < val)
187 return(0);
188 else
189 return(1);
190
191 case SQ_IRGT: /* If register > */
192
193 val = evaltv(dat);
194
195 if (sregval[obj] > val)
196 return(0);
197 else
198 return(1);
199/*
200
201*/
202 case SQ_ISTM: /* If stimulus active */
203
204 if (trgtab[TRG_MASK & seqstim[seq]])
205 return(0);
206 else
207 return(1);
208
209 case SQ_JUMP: /* Jump to sequence line */
210
211 seqline[seq] = dat;
212 seqtime[seq] = seqtab[dat].seqtime;
213 seqflag[seq] |= SQF_CLK;
214
215 seqdupd |= (1 << seq);
216 return(-1);
217
218
219 case SQ_STOP: /* Stop sequence */
220 default:
221
222 seqflag[seq] = 0;
223 seqtime[seq] = 0;
224
225 seqdupd |= (1 << seq);
226 return(-1);
227
228 }
229}
230
231/*
232
233*/
234
235/*
236 =============================================================================
237 sqexec() -- execute a line for a sequence
238 =============================================================================
239*/
240
241void sqexec(uint16_t seq)
242{
243 register uint16_t act, dat, line;
244 register struct seqent *sp;
245 register int16_t rc;
246
247 line = seqline[seq];
248 sp = &seqtab[line];
249
250 act = sp->seqact1; /* do Action 1 */
251 dat = sp->seqdat1;
252
253 rc = dosqact(seq, act, dat);
254
255#if DEBUGSX
256 if (debugsw AND debugsx)
257 printf("sqexec(%02u): Line %03u Act 1 $%04.4X $%04.4X $%04.4X %d\n",
258 seq, line, act, dat, seqflag[seq], rc);
259#endif
260
261 if (rc EQ 1) /* skip action 2 */
262 goto act3;
263 else if (rc EQ -1) /* jump or stop */
264 return;
265
266 act = sp->seqact2; /* do Action 2 */
267 dat = sp->seqdat2;
268
269 rc = dosqact(seq, act, dat);
270
271#if DEBUGSX
272 if (debugsw AND debugsx)
273 printf("sqexec(%02u): Line %03u Act 2 $%04.4X $%04.4X $%04.4X %d\n",
274 seq, line, act, dat, seqflag[seq], rc);
275#endif
276
277 if (rc EQ 1) /* skip action 3 */
278 goto nxtline;
279 else if (rc EQ -1) /* jump or stop */
280 return;
281
282act3:
283 act = sp->seqact3; /* do Action 3 */
284 dat = sp->seqdat3;
285
286 rc = dosqact(seq, act, dat);
287
288#if DEBUGSX
289 if (debugsw AND debugsx)
290 printf("sqexec(%02u): Line %03u Act 3 $%04.4X $%04.4X $%04.4X %d\n",
291 seq, line, act, dat, seqflag[seq], rc);
292#endif
293
294 if (rc EQ -1) /* jump or stop */
295 return;
296
297nxtline: /* increment line counter */
298
299 if (++seqline[seq] GE NSLINES)
300 seqline[seq] = 0;
301
302 seqtime[seq] = seqtab[seqline[seq]].seqtime;
303 seqflag[seq] |= SQF_CLK;
304
305#if DEBUGSX
306 if (debugsw AND debugsx)
307 printf("sqexec(%02u): Next %03u %5u $%04.4X\n",
308 seq, line, seqtime[seq], seqflag[seq]);
309#endif
310
311 seqdupd |= (1 << seq);
312}
313
314/*
315
316*/
317
318/*
319 =============================================================================
320 seqproc() -- process sequences
321 =============================================================================
322*/
323
324void seqproc(void)
325{
326 register uint16_t oldsr, seq;
327 register int16_t dspn;
328 register uint16_t *fp;
329 int8_t linbuf[66];
330
331 if (0 EQ timers[SQTIMER]) {
332
333 for (seq = 0; seq < 16; seq++) {
334
335 fp = &seqflag[seq];
336
337 if ( (SQF_RUN|SQF_CLK) EQ
338 ((SQF_RUN|SQF_CLK) & *fp) ) {
339
340 if (seqtime[seq]) {
341
342 if (0 EQ --seqtime[seq])
343 *fp &= ~SQF_CLK;
344
345 } else {
346
347 *fp &= ~SQF_CLK;
348 }
349 }
350 }
351
352 oldsr = setsr(0x2700);
353 timers[SQTIMER] = SEQTIME;
354 setsr(oldsr);
355 }
356
357 for (seq = 0; seq < 16; seq++)
358 if (SQF_RUN EQ ((SQF_RUN|SQF_CLK) & seqflag[seq]) )
359 sqexec(seq);
360/*
361
362*/
363 if (((ndisp EQ 1) OR (ndisp EQ 3)) AND dsp_ok AND seqdupd) {
364
365#if DEBUGSX
366 if (debugsw AND debugsx)
367 printf("seqproc(): ndisp = %d seqdupd = $%04.4X\n",
368 ndisp, seqdupd);
369#endif
370 if (seqdupd & (1 << seqdspn)) {
371
372 dspn = seqdspn;
373
374 if (v_regs[5] & 0x0180)
375 vbank(0);
376
377 sprintf(linbuf, " %03d %02d %c ",
378 seqline[dspn],
379 sregval[dspn],
380 '0' + trstate[dspn]);
381
382 vvputsv(obj10, 16, PDSEQFG, PDSEQBG,
383 dspn, 1, linbuf, 14, 14, cg3);
384
385#if UPD_LINE
386 sprintf(linbuf, "%02d", dspn + 1);
387
388 vvputsv(obj10, 16,
389 (seqflag[dspn] & SQF_RUN) ?
390 PDSEQRN : PDSEQFG, PDSEQBG,
391 dspn, 2, linbuf, 14, 14, cg3);
392#else
393 vsetcv(obj10, dspn, 2,
394 ( ( (seqflag[dspn] & SQF_RUN) ?
395 PDSEQRN : PDSEQFG) << 4) | PDSEQBG, 16);
396#endif
397 seqdupd &= ~(1 << dspn);
398 }
399
400 if (++seqdspn > 15)
401 seqdspn = 0;
402 }
403}
404
Note: See TracBrowser for help on using the repository browser.