OpenCores
URL https://opencores.org/ocsvn/a-z80/a-z80/trunk

Subversion Repositories a-z80

[/] [a-z80/] [trunk/] [tools/] [Arduino/] [Z80_dongle/] [Z80_dongle.ino] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 3 gdevic
//------------------------------------------------------------------------
2
// This Arduino sketch should be used with a Mega board connected to a
3
// dongle hosting a Z80 CPU. The Arduino fully controls and senses all
4
// Z80 CPU pins. This software runs physical Z80 CPU by providing clock
5
// ticks and setting various control pins.
6
//
7
// There is a limited RAM buffer simulated by this sketch. All Z80 memory
8
// accesses are directed to use that buffer.
9
//
10
// Address and data buses from Z80 are connected to analog Arduino pins.
11
// Along with a resistor network on the dongle, this allows the software
12
// to sense when Z80 tri-states those two buses.
13
//
14
// Notes:
15
//      - Use serial set to 115200
16
//      - In the Arduino serial monitor window, set line ending to "CR"
17
//      - Memory access is simulated using a 256-byte pseudo-RAM memory
18
//      - I/O map is _not_ implemented. Reads will return whatever happens
19
//        to be on the data bus
20
//
21
// Copyright 2014 by Goran Devic
22
// This source code is released under the GPL v2 software license.
23
//------------------------------------------------------------------------
24
#include 
25
#include "WString.h"
26
 
27
// Define Arduino Mega pins that are connected to a Z80 dongle board.
28
// Pin numbers appear out-of-order, but they cleanly connect in complete
29
// blocks to sets of pins on Arduino Mega! This will become obvious once
30
// you start connecting them...
31
#define DB0         A9      // DB pin line-up on a Z80 is a bit swizzled...
32
#define DB1         A8
33
#define DB2         A11
34
#define DB3         A14
35
#define DB4         A15
36
#define DB5         A13
37
#define DB6         A12
38
#define DB7         A10
39
// Address bus pins from Z80 are connected to A0..A7 on Arduino.
40
 
41
#define INT         52      // This is a block of control signals from the
42
#define NMI         50      // bottom-left corner of Z80
43
#define HALT        48
44
#define MREQ        46
45
#define IORQ        44
46
 
47
#define RFSH        53      // This is a block of control signals from the
48
#define M1          51      // bottom-right corner of Z80
49
#define RESET       49
50
#define BUSRQ       47
51
#define WAIT        45
52
#define BUSAK       43
53
#define WR          41
54
#define RD          39
55
 
56
#define CLK         13      // Clock is also toggling Arduino LED (fast, though)
57
 
58
// Tri-state detection values: the values that are read on analog pins
59
// sensing the "high-Z" will differ based on the resistor values that make
60
// up your voltage divider. Print your particular readings and adjust these:
61
#define HI_Z_LOW    50      // Upper "0" value; low tri-state boundary
62
#define HI_Z_HIGH   600     // Low "1" value; upper tri-state boundary
63
 
64
// Control *output* pins of Z80, we read them into these variables
65
int  halt;
66
int  mreq;
67
int  iorq;
68
int  rfsh;
69
int  m1;
70
int  busak;
71
int  wr;
72
int  rd;
73
 
74
// Control *input* pins of Z80, we write them into the dongle
75
int zint = 1;
76
int nmi = 1;
77
int reset = 1;
78
int busrq = 1;
79
int wait = 1;
80
 
81
// Content of address and data wires
82
int ab;
83
byte db;
84
 
85
// Clock counter after reset
86
int clkCount;
87
int clkCountHi;
88
 
89
// T-cycle counter
90
int T;
91
int Mlast;
92
 
93
// M1-cycle counter
94
int m1Count;
95
 
96
// Detection if the address or data bus is tri-stated
97
bool abTristated = false;
98
bool dbTristated = false;
99
 
100
// Simulation control variables
101
bool running = 1;           // Simulation is running or is stopped
102
int traceShowBothPhases;    // Show both phases of a clock cycle
103
int traceRefresh;           // Trace refresh cycles
104
int tracePause;             // Pause for a key press every so many clocks
105
int tracePauseCount;        // Current clock count for tracePause
106
int stopAtClk;              // Stop the simulation after this many clocks
107
int stopAtM1;               // Stop at a specific M1 cycle number
108
int stopAtHalt;             // Stop when HALT signal gets active
109
int intAtClk;               // Issue INT signal at that clock number
110
int nmiAtClk;               // Issue NMI signal at that clock number
111
int busrqAtClk;             // Issue BUSRQ signal at that clock number
112
int resetAtClk;             // Issue RESET signal at that clock number
113
int waitAtClk;              // Issue WAIT signal at that clock number
114
int clearAtClk;             // Clear all control signals at that clock number
115
byte iorqVector;            // Push IORQ vector (default is FF)
116
 
117
// Buffer containing RAM memory for Z80 to access
118
byte ram[256];
119
 
120
// Temp buffer to store input line
121
#define TEMP_SIZE   512
122
char temp[TEMP_SIZE];
123
 
124
// Temp buffer to store extra dump information
125
char extraInfo[64] = { "" };
126
 
127
// Utility function to provide a meaningful printf to a serial port
128
void p(char *fmt, ... ){
129
    char tmp[256];          // resulting string limited to 256 chars
130
    va_list args;
131
    va_start (args, fmt );
132
    vsnprintf(tmp, 256, fmt, args);
133
    va_end (args);
134
    Serial.print(tmp);
135
}
136
 
137
// Read and return one ASCII hex value from a string
138
byte hex(char *s){
139
    byte nibbleH = (*s - '0') & ~(1<<5);
140
    byte nibbleL = (*(s+1) - '0') & ~(1<<5);
141
    if (nibbleH>9) nibbleH -= 7;
142
    if (nibbleL>9) nibbleL -= 7;
143
    return (nibbleH << 4) | nibbleL;
144
}
145
 
146
// Read and return one ASCII hex value from a temp buffer given the index
147
// of that hex number. This is used only to read Intel HEX format buffer.
148
byte hexFromTemp(char *pTemp, int index)
149
{
150
    int start = (index*2)+1;
151
    return hex(pTemp + start);
152
}
153
 
154
// -----------------------------------------------------------
155
// Arduino initialization entry point
156
// -----------------------------------------------------------
157
void setup()
158
{
159
    Serial.begin(115200);
160
    Serial.flush();
161
    Serial.setTimeout(1000*60*60);
162
 
163
    ResetSimulationVars();
164
 
165
    // By default, all Arduino pins are set as inputs
166
    // Configure all output pins, *inputs* into Z80
167
    pinMode(CLK, OUTPUT);
168
    digitalWrite(CLK, HIGH);
169
    pinMode(INT, OUTPUT);
170
    pinMode(NMI, OUTPUT);
171
    pinMode(RESET, OUTPUT);
172
    pinMode(BUSRQ, OUTPUT);
173
    pinMode(WAIT, OUTPUT);
174
    WriteControlPins();
175
 
176
    // Perform a Z80 CPU reset
177
    DoReset();
178
}
179
 
180
// Resets all simulation variables to their defaults
181
void ResetSimulationVars()
182
{
183
    traceShowBothPhases = 0;// Show both phases of a clock cycle
184
    traceRefresh = 1;       // Trace refresh cycles
185
    tracePause = -1;        // Pause for a keypress every so many clocks
186
    stopAtClk = 40;         // Stop the simulation after this many clocks
187
    stopAtM1 = -1;          // Stop at a specific M1 cycle number
188
    stopAtHalt = 1;         // Stop when HALT signal gets active
189
    intAtClk = -1;          // Issue INT signal at that clock number
190
    nmiAtClk = -1;          // Issue NMI signal at that clock number
191
    busrqAtClk = -1;        // Issue BUSRQ signal at that clock number
192
    resetAtClk = -1;        // Issue RESET signal at that clock number
193
    waitAtClk = -1;         // Issue WAIT signal at that clock number
194
    clearAtClk = -1;        // Clear all control signals at that clock number
195
    iorqVector = 0xFF;      // Push IORQ vector
196
}
197
 
198
// Issue a RESET sequence to Z80 and reset internal counters
199
void DoReset()
200
{
201
    p("\r\n:Starting the clock\r\n");
202
    digitalWrite(RESET, LOW);    delay(1);
203
    // Reset should be kept low for 3 full clock cycles
204
    for(int i=0; i<3; i++)
205
    {
206
        digitalWrite(CLK, HIGH); delay(1);
207
        digitalWrite(CLK, LOW);  delay(1);
208
    }
209
    p(":Releasing RESET\r\n");
210
    digitalWrite(RESET, HIGH);   delay(1);
211
    // Do not count initial 2 clocks after the reset
212
    clkCount = -2;
213
    T = 0;
214
    Mlast = 1;
215
    tracePauseCount = 0;
216
    m1Count = 0;
217
}
218
 
219
// Write all control pins into the Z80 dongle
220
void WriteControlPins()
221
{
222
    digitalWrite(INT, zint ? HIGH : LOW);
223
    digitalWrite(NMI, nmi ? HIGH : LOW);
224
    digitalWrite(RESET, reset ? HIGH : LOW);
225
    digitalWrite(BUSRQ, busrq ? HIGH : LOW);
226
    digitalWrite(WAIT,  wait ? HIGH : LOW);
227
}
228
 
229
// Set new data value into the Z80 data bus
230
void SetDataToDB(byte data)
231
{
232
    pinMode(DB0, OUTPUT);
233
    pinMode(DB1, OUTPUT);
234
    pinMode(DB2, OUTPUT);
235
    pinMode(DB3, OUTPUT);
236
    pinMode(DB4, OUTPUT);
237
    pinMode(DB5, OUTPUT);
238
    pinMode(DB6, OUTPUT);
239
    pinMode(DB7, OUTPUT);
240
 
241
    digitalWrite(DB0, (data & (1<<0)) ? HIGH : LOW);
242
    digitalWrite(DB1, (data & (1<<1)) ? HIGH : LOW);
243
    digitalWrite(DB2, (data & (1<<2)) ? HIGH : LOW);
244
    digitalWrite(DB3, (data & (1<<3)) ? HIGH : LOW);
245
    digitalWrite(DB4, (data & (1<<4)) ? HIGH : LOW);
246
    digitalWrite(DB5, (data & (1<<5)) ? HIGH : LOW);
247
    digitalWrite(DB6, (data & (1<<6)) ? HIGH : LOW);
248
    digitalWrite(DB7, (data & (1<<7)) ? HIGH : LOW);
249
    db = data;
250
    dbTristated = false;
251
}
252
 
253
// Read Z80 data bus and store into db variable
254
void GetDataFromDB()
255
{
256
    pinMode(DB0, INPUT);
257
    pinMode(DB1, INPUT);
258
    pinMode(DB2, INPUT);
259
    pinMode(DB3, INPUT);
260
    pinMode(DB4, INPUT);
261
    pinMode(DB5, INPUT);
262
    pinMode(DB6, INPUT);
263
    pinMode(DB7, INPUT);
264
 
265
    digitalWrite(DB0, LOW);
266
    digitalWrite(DB1, LOW);
267
    digitalWrite(DB2, LOW);
268
    digitalWrite(DB3, LOW);
269
    digitalWrite(DB4, LOW);
270
    digitalWrite(DB5, LOW);
271
    digitalWrite(DB6, LOW);
272
    digitalWrite(DB7, LOW);
273
 
274
    // Detect if the data bus is tri-stated
275
    delay(1);
276
    int test0 = analogRead(DB0);
277
    // These numbers might need to be adjusted for each Arduino board
278
    dbTristated = test0>HI_Z_LOW && test0
279
 
280
    byte d0 = digitalRead(DB0);
281
    byte d1 = digitalRead(DB1);
282
    byte d2 = digitalRead(DB2);
283
    byte d3 = digitalRead(DB3);
284
    byte d4 = digitalRead(DB4);
285
    byte d5 = digitalRead(DB5);
286
    byte d6 = digitalRead(DB6);
287
    byte d7 = digitalRead(DB7);
288
    db = (d7<<7)|(d6<<6)|(d5<<5)|(d4<<4)|(d3<<3)|(d2<<2)|(d1<<1)|d0;
289
}
290
 
291
// Read a value of Z80 address bus and store it into the ab variable.
292
// In addition, try to detect when a bus is tri-stated and write 0xFFF if so.
293
void GetAddressFromAB()
294
{
295
    // Detect if the address bus is tri-stated
296
    int test0 = analogRead(A0);
297
    // These numbers might need to be adjusted for each Arduino board
298
    abTristated = test0>HI_Z_LOW && test0
299
 
300
    int a0 = digitalRead(A0);
301
    int a1 = digitalRead(A1);
302
    int a2 = digitalRead(A2);
303
    int a3 = digitalRead(A3);
304
    int a4 = digitalRead(A4);
305
    int a5 = digitalRead(A5);
306
    int a6 = digitalRead(A6);
307
    int a7 = digitalRead(A7);
308
    ab = (a7<<7)|(a6<<6)|(a5<<5)|(a4<<4)|(a3<<3)|(a2<<2)|(a1<<1)|a0;
309
}
310
 
311
// Read all control pins on the Z80 and store them into internal variables
312
void ReadControlState()
313
{
314
    halt  = digitalRead(HALT);
315
    mreq  = digitalRead(MREQ);
316
    iorq  = digitalRead(IORQ);
317
    rfsh  = digitalRead(RFSH);
318
    m1    = digitalRead(M1);
319
    busak = digitalRead(BUSAK);
320
    wr    = digitalRead(WR);
321
    rd    = digitalRead(RD);
322
}
323
 
324
// Dump the Z80 state as stored in internal variables
325
void DumpState(bool suppress)
326
{
327
    if (!suppress)
328
    {
329
        // Select your character for tri-stated bus
330
        char abStr[4] = { "---" };
331
        char dbStr[3] = { "--" };
332
        if (!abTristated) sprintf(abStr, "%03X", ab);
333
        if (!dbTristated) sprintf(dbStr, "%02X", db);
334
        if (T==1 && clkCountHi)
335
            p("-----------------------------------------------------------+\r\n");
336
        p("#%03d%c T%-2d AB:%s DB:%s  %s %s %s %s %s %s %s %s |%s%s%s%s %s\r\n",
337
        clkCount<0? 0 : clkCount, clkCountHi ? 'H' : 'L', T,
338
        abStr, dbStr,
339
        m1?"  ":"M1", rfsh?"    ":"RFSH", mreq?"    ":"MREQ", rd?"  ":"RD", wr?"  ":"WR", iorq?"    ":"IORQ", busak?"     ":"BUSAK",halt?"    ":"HALT",
340
        zint?"":"[INT]", nmi?"":"[NMI]", busrq?"":"[BUSRQ]", wait?"":"[WAIT]",
341
        extraInfo);
342
    }
343
    extraInfo[0] = 0;
344
}
345
 
346
// -----------------------------------------------------------
347
// Main loop routine runs over and over again forever
348
// -----------------------------------------------------------
349
void loop()
350
{
351
    //--------------------------------------------------------
352
    // Clock goes high
353
    //--------------------------------------------------------
354
    delay(1); digitalWrite(CLK, HIGH); delay(1);
355
 
356
    clkCountHi = 1;
357
    clkCount++;
358
    T++;
359
    tracePauseCount++;
360
    ReadControlState();
361
    GetAddressFromAB();
362
    if (Mlast==1 && m1==0)
363
        T = 1, m1Count++;
364
    Mlast = m1;
365
    bool suppressDump = false;
366
    if (!traceRefresh & !rfsh) suppressDump = true;
367
 
368
    // If the number of M1 cycles has been reached, skip the rest since we dont
369
    // want to execute this M1 phase
370
    if (m1Count==stopAtM1)
371
    {
372
        sprintf(extraInfo, "Number of M1 cycles reached"), running = false;
373
        p("-----------------------------------------------------------+\r\n");
374
        goto control;
375
    }
376
 
377
    // If the address is tri-stated, skip checking various combinations of
378
    // control signals since they may also be floating and we can't detect that
379
    if (!abTristated)
380
    {
381
        // Simulate read from RAM
382
        if (!mreq && !rd)
383
        {
384
            SetDataToDB(ram[ab & 0xFF]);
385
            if (!m1)
386
                sprintf(extraInfo, "Opcode read from %03X -> %02X", ab, ram[ab & 0xFF]);
387
            else
388
                sprintf(extraInfo, "Memory read from %03X -> %02X", ab, ram[ab & 0xFF]);
389
        }
390
        else
391
        // Simulate interrupt requesting a vector
392
        if (!m1 && !iorq)
393
        {
394
            SetDataToDB(iorqVector);
395
            sprintf(extraInfo, "Pushing vector %02X", iorqVector);
396
        }
397
        else
398
            GetDataFromDB();
399
 
400
        // Simulate write to RAM
401
        if (!mreq && !wr)
402
        {
403
            ram[ab & 0xFF] = db;
404
            sprintf(extraInfo, "Memory write to  %03X <- %02X", ab, db);
405
        }
406
 
407
        // Detect I/O read: We don't place anything on the bus
408
        if (!iorq && !rd)
409
        {
410
            sprintf(extraInfo, "I/O read from %03X", ab);
411
        }
412
 
413
        // Detect I/O write
414
        if (!iorq && !wr)
415
        {
416
            sprintf(extraInfo, "I/O write to %03X <- %02X", ab, db);
417
        }
418
 
419
        // Capture memory refresh cycle
420
        if (!mreq && !rfsh)
421
        {
422
            sprintf(extraInfo, "Refresh address  %03X", ab);
423
        }
424
    }
425
    else
426
        GetDataFromDB();
427
 
428
    DumpState(suppressDump);
429
 
430
    // If the user wanted to pause simulation after a certain number of
431
    // clocks, handle it here. If the key pressed to continue was not Enter,
432
    // stop the simulation to issue that command
433
    if (tracePause==tracePauseCount)
434
    {
435
        while(Serial.available()==0) ;
436
        if (Serial.peek()!='\r')
437
            sprintf(extraInfo, "Continue keypress was not Enter"), running = false;
438
        else
439
            Serial.read();
440
        tracePauseCount = 0;
441
    }
442
 
443
    //--------------------------------------------------------
444
    // Clock goes low
445
    //--------------------------------------------------------
446
    delay(1); digitalWrite(CLK, LOW); delay(1);
447
 
448
    clkCountHi = 0;
449
    if (traceShowBothPhases)
450
    {
451
        ReadControlState();
452
        GetAddressFromAB();
453
        DumpState(suppressDump);
454
    }
455
 
456
    // Perform various actions at the requested clock number
457
    // if the count is positive (we start it at -2 to skip initial 2T)
458
    if (clkCount>=0)
459
    {
460
        if (clkCount==intAtClk) zint = 0;
461
        if (clkCount==nmiAtClk) nmi = 0;
462
        if (clkCount==busrqAtClk) busrq = 0;
463
        if (clkCount==resetAtClk) reset = 0;
464
        if (clkCount==waitAtClk) wait = 0;
465
        // De-assert all control pins at this clock number
466
        if (clkCount==clearAtClk)
467
            zint = nmi = busrq = reset = wait = 1;
468
        WriteControlPins();
469
 
470
        // Stop the simulation under some conditions
471
        if (clkCount==stopAtClk)
472
            sprintf(extraInfo, "Number of clocks reached"), running = false;
473
        if (stopAtHalt&!halt)
474
            sprintf(extraInfo, "HALT instruction"), running = false;
475
    }
476
 
477
    //--------------------------------------------------------
478
    // Trace/simulation control handler
479
    //--------------------------------------------------------
480
control:
481
    if (!running)
482
    {
483
        p(":Simulation stopped: %s\r\n", extraInfo);
484
        extraInfo[0] = 0;
485
        digitalWrite(CLK, HIGH);
486
        zint = nmi = busrq = wait = 1;
487
        WriteControlPins();
488
 
489
        while(!running)
490
        {
491
            // Expect a command from the serial port
492
            if (Serial.available()>0)
493
            {
494
                memset(temp, 0, TEMP_SIZE);
495
                Serial.readBytesUntil('\r', temp, TEMP_SIZE-1);
496
 
497
                // Option ":"  : this is not really a user option. This is used to
498
                //               Intel HEX format values into the RAM buffer
499
                // Multiple lines may be pasted. They are separated by a space character.
500
                char *pTemp = temp;
501
                while (*pTemp==':')
502
                {
503
                    byte bytes = hexFromTemp(pTemp, 0);
504
                    if (bytes>0)
505
                    {
506
                        int address = (hexFromTemp(pTemp, 1)<<8) + hexFromTemp(pTemp, 2);
507
                        byte recordType = hexFromTemp(pTemp, 3);
508
                        p("%04X:", address);
509
                        for (int i=0; i
510
                        {
511
                            ram[(address + i) & 0xFF] = hexFromTemp(pTemp, 4+i);
512
                            p(" %02X", hexFromTemp(pTemp, 4+i));
513
                        }
514
                        p("\r\n");
515
                    }
516
                    pTemp += bytes*2 + 12;  // Skip to the next possible line of hex entry
517
                }
518
                // Option "r"  : reset and run the simulation
519
                if (temp[0]=='r')
520
                {
521
                    // If the variable 9 (Issue RESET) is not set, perform a RESET and run the simulation.
522
                    // If the variable was set, skip reset sequence since we might be testing it.
523
                    if (resetAtClk<0)
524
                        DoReset();
525
                    running = true;
526
                }
527
                // Option "sc" : clear simulation variables to their default values
528
                if (temp[0]=='s' && temp[1]=='c')
529
                {
530
                    ResetSimulationVars();
531
                    temp[1] = 0;            // Proceed to dump all variables...
532
                }
533
                // Option "s"  : show and set internal control variables
534
                if (temp[0]=='s' && temp[1]!='c')
535
                {
536
                    // Show or set the simulation parameters
537
                    int var = 0, value;
538
                    int args = sscanf(&temp[1], "%d %d\r\n", &var, &value);
539
                    // Parameter for the option #12 is read in as a hex; others are decimal by default
540
                    if (var==12)
541
                        args = sscanf(&temp[1], "%d %x\r\n", &var, &value);
542
                    if (args==2)
543
                    {
544
                        if (var==0) traceShowBothPhases = value;
545
                        if (var==1) traceRefresh = value;
546
                        if (var==2) tracePause = value;
547
                        if (var==3) stopAtClk = value;
548
                        if (var==4) stopAtM1 = value;
549
                        if (var==5) stopAtHalt = value;
550
                        if (var==6) intAtClk = value;
551
                        if (var==7) nmiAtClk = value;
552
                        if (var==8) busrqAtClk = value;
553
                        if (var==9) resetAtClk = value;
554
                        if (var==10) waitAtClk = value;
555
                        if (var==11) clearAtClk = value;
556
                        if (var==12) iorqVector = value & 0xFF;
557
                    }
558
                    p("------ Simulation variables ------\r\n");
559
                    p("#0  Trace both clock phases  = %d\r\n", traceShowBothPhases);
560
                    p("#1  Trace refresh cycles     = %d\r\n", traceRefresh);
561
                    p("#2  Pause for keypress every = %d\r\n", tracePause);
562
                    p("#3  Stop after clock #       = %d\r\n", stopAtClk);
563
                    p("#4  Stop after # M1 cycles   = %d\r\n", stopAtM1);
564
                    p("#5  Stop at HALT             = %d\r\n", stopAtHalt);
565
                    p("#6  Issue INT at clock #     = %d\r\n", intAtClk);
566
                    p("#7  Issue NMI at clock #     = %d\r\n", nmiAtClk);
567
                    p("#8  Issue BUSRQ at clock #   = %d\r\n", busrqAtClk);
568
                    p("#9  Issue RESET at clock #   = %d\r\n", resetAtClk);
569
                    p("#10 Issue WAIT at clock #    = %d\r\n", waitAtClk);
570
                    p("#11 Clear all at clock #     = %d\r\n", clearAtClk);
571
                    p("#12 Push IORQ vector #(hex)  = %2X\r\n", iorqVector);
572
                }
573
                // Option "m"  : dump RAM memory
574
                if (temp[0]=='m' && temp[1]!='c')
575
                {
576
                    // Dump the content of a RAM buffer
577
                    p("    00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\r\n");
578
                    p("   +-----------------------------------------------\r\n");
579
                    for(int i=0; i<16; i++)
580
                    {
581
                        p("%02X |", i);
582
                        for(int j=0; j<16; j++)
583
                        {
584
                            p("%02X ", ram[i*16+j]);
585
                        }
586
                        p("\r\n");
587
                    }
588
                }
589
                // Option "mc"  : clear RAM memory
590
                if (temp[0]=='m' && temp[1]=='c')
591
                {
592
                    memset(ram, 0, sizeof(ram));
593
                    p("RAM cleared\r\n");
594
                }
595
                // Option "?"  : print help
596
                if (temp[0]=='?' || temp[0]=='h')
597
                {
598
                    p("s            - show simulation variables\r\n");
599
                    p("s #var value - set simulation variable number to a value\r\n");
600
                    p("sc           - clear simulation variables to their default values\r\n");
601
                    p("r            - restart the simulation\r\n");
602
                    p(":INTEL-HEX   - reload RAM buffer with a given data stream\r\n");
603
                    p("m            - dump the content of the RAM buffer\r\n");
604
                    p("mc           - clear the RAM buffer\r\n");
605
                }
606
            }
607
        }
608
    }
609
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.