1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
|
**************************************************************************
*
* Title: Calculator
*
* Objective: CMPEN 472 Homework 7
*
* Revision: V1.0
*
* Date: Mar. 7, 2025
*
* Programmer: Jacob McDonnell
*
* Company: The Pennsylvania State University
* Department of Computer Science and Engineering
*
* Algorithm: Simple Serial I/O, address poking and modifying
*
* Register Use: A & B to current byte, etc,
* X & Y holds address of strings and length of string,
* D to hold data and address of the memory location to work on.
*
* Memory Use: RAM Locations from $3000 for data,
* RAM Locations from $3100 for program
*
* Input: Serial Port for User Input
*
* Output: Serial Port for String Output
* Memory locations changed if modified by user
*
* Observation: This program is a simple 16-bit calculator. The input can be
* any 4 digit positive decimal integer, the output can be negative.
* The +, -, *, and / operators are supported. Only two numbers at
* a time.
*
* Note: ON CSM-12C128 board,
*
* Comments: This program is developed and simulated using CodeWarrior
* development software and targeted for Axion
* Manufacturing's CSM-12C128 board running at 24MHz.
*
**************************************************************************
* Parameter Declearation Section
*
* Export Symbols
xdef pgstart ; export 'pgstart' symbol
absentry pgstart ; for assembly entry point
* Symbols and Macros
PORTA equ $0000 ; i/o port A addresses
DDRA equ $0002 ; data direction register for PORTA
PORTB equ $0001 ; i/o port B addresses
DDRB equ $0003 ; data direction register for PORTB
SCIBDH equ $00C8 ; Serial port (SCI) Baud Register H
SCIBDL equ $00C9 ; Serial port (SCI) Baud Register L
SCICR2 equ $00CB ; Serial port (SCI) Control Register 2
SCISR1 equ $00CC ; Serial port (SCI) Status Register 1
SCIDRL equ $00CF ; Serial port (SCI) Data Register
CRGFLG EQU $0037 ; Clock and Reset Generator Flags
CRGINT EQU $0038 ; Clock and Reset Generator Interrupts
RTICTL EQU $003B ; Real Time Interrupt Control
CR equ $0d ; carriage return, ASCII 'Return' key
LF equ $0a ; line feed, ASCII 'next line' character
NULL equ $00 ; NULL Terminator character
**************************************************************************
* Data Section: address used [ $3000 to $30FF ] RAM Memory
*
org $3000 ; Reserved RAM memory starting address
; for Data for CMPEN 472 class
buffer ds.b $0010 ; Array of 16 bytes to read a string
dc.b NULL ; NULL terminated
lenBuf dc.w $0010 ; Length of buffer array
buffer2 ds.b $0010 ; Array of 16 bytes for reading and reversal
dc.b NULL ; NULL terminated
lenBuf2 dc.w $0010 ; length of buffer2
hours dc.w $0000 ; Buffer to hold the hours of the time
minutes dc.w $0000 ; Buffer to hold the minutes of the time
seconds dc.w $0000 ; Buffer to hold the seconds of the time
counter dc.w $0000 ; Counter for RTI ISR for 1 second
numBuf dc.b $0000 ; Used by ReadDecimal for reading numbers
operator dc.b $0000 ; Used by ReadDecimal for reading numbers
inputBuffer ds.b $0010 ; Input Buffer Length
lenInput dc.w $0010 ; Length of the Input Buffer
outputBuf dc.b 'h' ; Used to control what to output on 7 segment display
*
* There is a section Data Section at the end of the file
**************************************************************************
* Interrupt Vector Section: address used [ $FFF0 to $FFFF ] RAM Memory
*
org $FFF0 ; Memory location for Interrupt vector section for simulator
dc.w rtiisr ; Real Time Interrupt vector
*
**************************************************************************
* Program Section: address used [ $3100 to $3FFF ] RAM Memory
*
org $3100 ; Program start address, in RAM
pgstart lds #$3100 ; initialize the stack pointer
ldaa #%11110001 ; LED 1,2,3,4 at PORTB bit 4,5,6,7
staa DDRB ; set PORTB bit 4,5,6,7 as output
ldaa #$0C ; Enable SCI port Tx and Rx units
staa SCICR2 ; disable SCI interrupts
ldd #$0001 ; Set SCI Baud Register = $0001 => 1.5M baud at 24MHz (for simulation)
std SCIBDH ; SCI port baud rate change
ldx #msg ; Load the address of the welcome message into X
jsr WriteString ; Write the string to the serial console
bset RTICTL,%00011001; set RTI: dev=10*(2**10)=2.555msec for C128 board
; 4MHz quartz oscillator clock
bset CRGINT,%10000000; enable RTI interrupt
bset CRGFLG,%10000000; clear RTI IF (Interrupt Flag)
ldx #inputBuffer ; Load the address of inputBuffer into X
ldy lenInput ; Load the length of inputBuffer into Y
jsr Zeros ; Zero out inputBuffer
cli ; Enable interrupts
jsr PrintTime ; Jump to PrintTime to write to serial console
mainLoop
ldx #inputBuffer ; Load the address of inputBuffer into X
ldy lenInput ; Load the length of inputBuffer into Y
jsr ReadString ; Jump to ReadString to read input
ldx #inputBuffer ; Load the address of inputBuffer into X
jsr ExecuteCommand ; Jump to ExecuteCommand
ldx #inputBuffer ; Load the address of inputBuffer into X
ldy lenInput ; Load the length of inputBuffer into Y
jsr Zeros ; Zero out inputBuffer
bra mainLoop ; Loop back to mainLoop always
TypeWrite
sei ; Disable Interrupts
bclr CRGINT,%10000000; Disable RTI interrupt
ldx #twMsg ; Load the address of twMsg into X
jsr WriteString ; Write the string to the serial console
twLoop jsr getchar ; Read a character from the serial console
tsta ; Compare A to 0
beq twLoop ; If A == 0, branch to twLoop
jsr putchar ; Write character to serial console
bra twLoop ; Branch always to twLoop
**************************************************************************
* Subroutine Section: address used [ $3100 to $3FFF ] RAM Memory
*
rtiisr bset CRGFLG,%10000000; Clear RTI Interrupt Flag
pshx ; Save X to the stack
ldx counter ; Load counter into X
inx ; Increment counter by 1
stx counter ; Save X to counter
cpx #9000 ; Compare counter to 9000, This is about 1 second on my computer
bne rtiSkip ; If counter != 400, branch to rtiSkip
ldx #0 ; Load 0 into X
stx counter ; Save X to counter
ldx seconds ; Load the seconds into X
inx ; Increment the seconds by 1
stx seconds ; Save the new seconds to the location
cpx #60 ; Compare X to 60
bne rtidone ; If X != 60, exit isr
ldx #0 ; Reset the seconds
stx seconds ; Save the new seconds to the location
ldx minutes ; load the minutes into X
inx ; Increment the minutes by 1
stx minutes ; Save the updated minutes
cpx #60 ; Compare the minutes to 60
bne rtidone ; If X != 60, exit isr
ldx #0 ; Reset the minutes
stx minutes ; Save the updated minutes
ldx hours ; Load the hours into X
inx ; Increment the hours by 1
stx hours ; Save the updated hours
cpx #24 ; Compare the hours to 24
bne rtidone ; If X != 24, exit the isr
ldx #0 ; Reset the hours
stx hours ; Save the updated hours
rtidone jsr PrintTime ; Jump to PrintTime
rtiSkip pulx ; Restore X from the stack
RTI
PrintTime pshd ; Save D to the stack
pshy ; Save Y to the stack
pshx ; Save X to the stack
ldaa #CR ; Load the character CR into A
jsr putchar ; Write the character to the serial
ldaa #LF ; Load the character LF into A
jsr putchar ; Write the character to the serial
ldx #clock ; Load the address of the clock prompt into X
jsr WriteString ; Write the string to serial
ldd hours ; Load the hours into D
cpd #10 ; Compare D to 10
bhs goodHours ; If D >= goodHours
psha ; Save A to the stack
ldaa #'0' ; Load '0' character into A
jsr putchar ; Print '0' to the serial
pula ; Restore A from the stack
goodHours ldy #buffer ; Load the address of buffer into Y
jsr PrintDecimalWord; Print the number to the serial
ldaa #':' ; Load the character ':' into A
jsr putchar ; Write the character to the serial
ldd minutes ; Load the minutes into D
cpd #10 ; Compare D to 10
bhs goodMins ; If D >= goodMins
psha ; Save A to the stack
ldaa #'0' ; Load '0' character into A
jsr putchar ; Print '0' to the serial
pula ; Restore A from the stack
goodMins ldy #buffer ; Load the address of buffer into Y
jsr PrintDecimalWord; Print the number to the serial
ldaa #':' ; Load the character ':' into A
jsr putchar ; Write the character to the serial
ldd seconds ; Load the seconds into D
cpd #10 ; Compare D to 10
bhs goodSecs ; If D >= goodSecs
psha ; Save A to the stack
ldaa #'0' ; Load '0' character into A
jsr putchar ; Print '0' to the serial
pula ; Restore A from the stack
goodSecs ldy #buffer ; Load the address of buffer into Y
jsr PrintDecimalWord; Print the number to the serial
ldaa #' ' ; Load ' ' character into A
jsr putchar ; Write the character to the serial console
jsr putchar ; Write the character to the serial console
jsr putchar ; Write the character to the serial console
jsr putchar ; Write the character to the serial console
ldx #CMD ; Load the address of CMD into X
jsr WriteString ; Write the string to the serial
ldx #inputBuffer ; Load the address of the inputBuffer into X
jsr WriteString ; Write the string to the serial
pulx ; Restore X from the stack
puly ; Restore Y from the stack
puld ; Restore D from the stack
rts ; Return to caller
ExecuteCommand
pshd ; Save D to the stack
ldaa 1,x+ ; Load the character from X into A
beq ecDone ; If A == 0, jump to ecDone
cmpa #'t' ; Compare A to 't'
bne isH ; If A != 't', branch to isH
bra ecDone ; Branch to ecDone
isH cmpa #'h' ; Compare A to 'h'
bne isM ; If A != 'h', branch to isM
ldab 1,x+ ; Load next character into B
cmpb #NULL ; Compare B to NULL
bne badCommand ; If B != CR, bad command
staa outputBuf ; Store A into outputBuf
bra ecDone ; Branch to ecDone
isM cmpa #'m' ; Compare A to 'm'
bne isS ; If A != 'm', branch to isS
ldab 1,x+ ; Load next character into B
cmpb #NULL ; Compare B to NULL
bne badCommand ; If B != CR, bad command
staa outputBuf ; Store A into outputBuf
bra ecDone ; Branch to ecDone
isS cmpa #'s' ; Compare A to 's'
bne isQ ; If A != 's', branch to isQ
ldab 1,x+ ; Load next character into B
cmpb #NULL ; Compare B to NULL
bne badCommand ; If B != CR, bad command
staa outputBuf ; Store A into outputBuf
bra ecDone ; Branch to ecDone
isQ cmpa #'q' ; Compare A to 'q'
bne badCommand ; If A != 'q', branch to badCommand
ldab 1,x+ ; Load next character into B
cmpb #NULL ; Compare B to NULL
bne badCommand ; If B != NULL, branch to ecDone
jmp TypeWrite ; Jump to TypeWrite
badCommand pshx ; Save X to the stack
ldx #error ; Load the address of the error prompt into X
jsr WriteString ; Jump to WriteString
ldx #badInput ; Load the address of badInput into X
jsr WriteString ; Jump to WriteString
pulx ; Restore X from stack
ecDone puld ; Restore D from the stack
rts ; Return to caller
;*************************************************************************
; ReadDecimal subroutine
;
; This subroutine will read an ASCII string of a number in decimal and convert it to
; its value.
;
; Input: A memory address in register X.
; Output: The value of the number in the Y register, and any errors printed
; to the serial line. Zero bit is set if error occurs.
; Registers in use: X for the address of the contents and for a buffer while printing,
; D for multiplication, B for the character, Y for output value.
; Memory locations in use: Memory Address for serial line, address of the string
;
; Comments: This subroutine will return the value in the Y register, and if an error occurs,
; the Zero bit in the CCR will be set.
;
ReadDecimal
pshd ; Save D to the stack
ldy #0 ; Clear Y register
dHLoop ldab 1,x+ ; Read Next character from X
beq dHDone ; If B == 0, exit loop
cmpb #'+' ; Compare B to '+'
beq dHDone ; If B == '+', end of number
cmpb #'-' ; Compare B to '-'
beq dHDone ; If B == '-', end of number
cmpb #'*' ; Compare B to '*'
beq dHDone ; If B == '+', end of number
cmpb #'/' ; Compare B to '/'
beq dHDone ; If B == '-', end of number
cmpb #' ' ; Compare B to space character
beq dHDone ; If B == ' ', exit loop
cmpb #'0' ; Compare B to '0' character
blt dHError ; If B < '0', bad address, exit loop
cmpb #'9' ; Compare B to '9' character
bhi dHError ; If B > '9', check if 'A'-'F' characters
subb #'0' ; Subtract '0' from B to get true value
pshb ; Save B to the stack
ldd #10 ; load 10 into D
emul ; Multiply Y and D
exg d,y ; Transfer data from D to Y
pulb ; Restore b from the stack
aby ; Add B to Y
bra dHLoop ; Branch always to rHLoop
dHDone clra ; clear A accumulator
tap ; Transfer A into CCR to clear zero bit
puld ; Restore D from the stack
rts ; Return to caller
dHError ldaa #4 ; Load 4 into A to set zero bit in CCR
tap ; Transfer A into CCR to set zero bit and warn error
puld ; Restore D from the stack
rts ; Return to caller
;*************************************************************************
; strrev subroutine
;
; This subroutine will reverse a string from one buffer into another.
;
; Input: Address of null terminated string in X, address of a large enough
; buffer in Y.
; Output: The string in X reversed in Y.
; Registers in use: X for the address of the string, Y for the address of the buffer,
; A to read characters from the string.
; Memory locations in use: Memory Address for serial line, address of the string & buffer
;
; Comments: This subroutine will not check that the output buffer is large enough, that
; is the job of the caller.
;
strrev
pshx ; Save X to the stack
pshy ; Save Y to the stack
psha ; Save A to the stack
revLoop ldaa 1,y- ; Load Character from Y into A, decrement Y
beq revDone ; If Character is 0, exit loop
staa 1,x+ ; Save character in address in X, increment X
bra revLoop ; Loop back always
clra ; Set A to Zero
revDone staa 1,x+ ; Copy Null terminator into new string
pula ; Restore A from the stack
puly ; Restore Y from the stack
pulx ; Restore X from the stack
rts ; Return to caller
;*************************************************************************
; PrintDecimalWord subroutine
;
; This subroutine will print a given word of data to the serial in binary.
;
; Input: 1 word of data in register D, Buffer Address in Y
; Output: Decimal representation of the data on the serial console
; Registers in use: Y for the address of the buffer, X to count the number of bits
; written and for division, D for the input, A for characters.
; Memory locations in use: Memory addresses for serial, and operator to hold sign
;
; Comments: This subroutine requires serial to be setup and putchar subroutine.
;
PrintDecimalWord
pshx ; Save X to the stack
pshy ; Save Y to the stack
pshd ; Save D (A:B) to the stack
cpd #0 ; Compare D to zero
beq dIsZero ; Branch to hIsZero
blt dIsNegative ; If D < 0, Jump to dIsNegative
dAfterNeg psha ; Save A to the stack
pshy ; Save Y to the stack
pshx ; Save x to the stack
ldaa #'0' ; Load the '0' character into A
ldx #buffer2 ; Load the address of buffer2 into X
ldy #5 ; Load 5 into Y
jsr memset ; Write '0' to the first 5 bytes in buffer2
pulx ; Restore X from the stack
puly ; Restore Y from the stack
clra ; Set A to zero
staa 0,y ; Load Zero into Y for Null Terminator
pula ; Restore A from the stack
dPrintLoop ldx #10 ; Load 10 in X for division
idiv ; Divide D / 10 to get Hex Digit
cpx #0 ; Compare X to 0
beq dCheck ; If X == 0, branch to check D is zero
dDNotZero addb #'0' ; Add '0' to B to get ASCII Character
stab 1,+y ; Save character from B to Y
exg X,D ; Swap values in X and D
bra dPrintLoop ; Loop to hPrintLoop
dCheck cpd #0 ; Compare D to 0
bne dDNotZero ; If D != 0, branch back to hDNotZero
dPrintDone ldaa operator ; Load operator into A to see if negative
cmpa #'-' ; Compare A to '-'
bne dNotNeg ; If A != '-', jump to dNotNeg
staa 1,+y ; Save '-' into buffer
dNotNeg ldx #buffer2 ; Load the address of buffer2 in X
jsr strrev ; Reverse string in Y in buffer in X
jsr WriteString ; Jump to write string to write the number
ldy lenBuf2 ; Load the length of buffer2 into Y
ldx #buffer2 ; Load the address of buffer2 into X
jsr Zeros ; Fill buffer2 with zeros
puld ; Restore D (A:B) from the stack
puly ; Restore Y from the stack
pulx ; Restore X from the stack
rts ; Return to caller
dIsZero ldaa #'0' ; Load '0' character into A
jsr putchar ; Print character to the screen
puld ; Restore D (A:B) from the stack
puly ; Restore Y from the stack
pulx ; Restore X from the stack
rts ; Return to caller
dIsNegative psha ; Save A to the stack
ldaa #'-' ; Load '-' into A
staa operator ; Save '-' to operator buffer
pula ; Restore A from the stack
nega ; Two's complement of A
suba #1 ; Subtract 1 from A
negb ; Two'complement of B
subb #1 ; Subtract 1 from B
addd #1 ; Add 1 to D
bra dAfterNeg ; Jump back to dAfterNeg
;*************************************************************************
; Zeros subroutine
;
; This subroutine will write zeros to every byte in a given array.
;
; Input: Address of an array in X and its length in Y
; Output: Zeros in every byte of an array.
; Registers in use: X for the address of the array, Y for the length, and A for 0
; Memory locations in use: Memory Address of the array
;
; Comments: This subroutine requires serial to be setup and putchar subroutine.
;
Zeros
psha ; Save A to the Stack
clra ; Clear A
zerosLoop staa 1,x+ ; Load A into byte at X
dbne y,zerosLoop ; Decrement Y and loop if Y != 0
pula ; Restore A from the stack
rts ; Return to caller
;*************************************************************************
; memset subroutine
;
; This subroutine will write a given byte to every byte in a given array.
;
; Input: Address of an array in X and its length in Y, the byte in A
; Output: The given byte in every byte of an array.
; Registers in use: X for the address of the array, Y for the length, and A for the given byte
; Memory locations in use: Memory Address of the array
;
; Comments: This subroutine requires serial to be setup and putchar subroutine.
;
memset
staa 1,x+ ; Load A into byte at X
dbne y,memset ; Decrement Y and loop if Y != 0
rts ; Return to caller
;*************************************************************************
; WriteString subroutine
;
; This subroutine will write a given null terminated string to the serial.
;
; Input: Address of null terminated string in X
; Output: Null terminated string written to serial
; Registers in use: X for the address of the string and A for the current byte
; Memory locations in use: Memory Address for serial line, address of the string
;
; Comments: This subroutine requires serial to be setup and putchar subroutine.
;
WriteString
psha ; Save A to the stack
writeLoop ldaa 1,x+ ; Load the byte at addr in X, then add 1
beq doneWrite ; if A == 0, branch to doneWrite
jsr putchar ; Jump to putchar to write byte to serial
bra writeLoop ; branch always to writeLoop
doneWrite pula ; restore A from the stack
rts ; return to caller
;*************************************************************************
; ReadString subroutine
;
; This subroutine will read a string from the serial line to a given address.
;
; Input: Address of an array in X
; Output: Null terminated string in the given array
; Registers in use: X for the address of the string Y for the length of the string,
; and A for the current byte
; Memory locations in use: Memory Address for serial line, address of the string
;
; Comments: This subroutine requires serial to be setup and getchar subroutine.
;
ReadString
psha ; Save accumulator A to the stack
pshy ; Save Y to the stack
pshx ; Save X to the stack
readLoop jsr getchar ; Jump to putchar to write byte to serial
beq readLoop ; While A == 0, loop
cmpa #CR ; If A == CR, exit loop
beq doneRead ; Branch to doneRead if A == CR
staa 1,x+ ; Save the byte to the addr in X, then add 1
jsr putchar ; Write Character back to the terminal
dey ; Decrement Y by 1
beq doneRead ; If Y == 0, no more room, stop reading
bra readLoop ; branch always to readLoop
doneRead ldaa #LF ; Load Line Feed into A
jsr putchar ; Write LF to terminal
pulx ; Restore X from the stack
pulY ; Restore Y from the stack
pula ; restore A from the stack
rts ; return to caller
;*************************************************************************
; putchar subroutine
;
; This subroutine writes a single byte to a serial line
;
; Input: A single ASCII byte in accumulator A
; Output: Sends one character to SCI port
; Registers in use: Accumulator A with input byte
; Memory locations in use: SCISR1 and SCIDRL status and data registers
;
putchar brclr SCISR1,#%10000000,putchar ; wait for transmit buffer empty
staa SCIDRL ; send a character
rts ; Return to caller
;*************************************************************************
; putchar subroutine
;
; This subroutine reads one byte from the SCI port
;
; Input: One byte from the SCI port
; Output: One byte in accumulator A
; Registers in use: Accumulator A for output byte
; Memory locations in use: SCISR1 and SCIDRL status and data registers
;
getchar brclr SCISR1,#%00100000,getchar7 ; If no input on SCI port, return 0
ldaa SCIDRL ; Read one byte from SCI port into A
rts ; Return to caller
getchar7 clra ; Set A to 0
rts ; Return to caller
*
**************************************************************************
* Data Section 2: address used [ $3100 to $3FFF ] RAM Memory
*
invalidStr dc.b 'Invalid Input',CR,LF,NULL ; Invalid input error message
clock dc.b 'Clock> ',NULL ; Prompt string for clock
CMD dc.b 'CMD> ',NULL ; Prompt string for CMD
error dc.b 'Error> ',NULL ; Prompt string for errors
badInput dc.b 'Invalid Input',CR,LF,NULL ; Invalid Input Prompt
overflow dc.b 'Overflow Error',CR,LF,NULL ; Overflow error message
; twMsg: welcome message for typewrite
twMsg dc.b 'Clock stopped and Typewrite program started.',CR,LF
dc.b 'You may type below.',CR,LF,NULL
; msg: this is the main option menu string
msg dc.b 'Commands:',CR,LF
dc.b 't: Set the time in format HH:MM:SS',CR,LF
dc.b 'h: Display the hours on the 7 segment displays',CR,LF
dc.b 'm: Display the minutes on the 7 segment displays',CR,LF
dc.b 's: Display the seconds on the 7 segment displays',CR,LF
dc.b 'q: Stop the clock and enter typewriter',CR,LF,NULL
|
