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
|
**************************************************************************
*
* Title: Hardware Controller
*
* Objective: CMPEN 472 Homework 5
*
* Revision: V1.0
*
* Date: Feb. 21, 2025
*
* Programmer: Jacob McDonnell
*
* Company: The Pennsylvania State University
* Department of Computer Science and Engineering
*
* Algorithm: Simple Serial I/O, Parallel I/O use, time delay-loop, and PWM control
*
* Register Use: A & B to control LEDS initially, Light Level, current byte, etc
* X & Y to hold the counter in the loop and address of strings and length of string.
*
* Memory Use: RAM Locations from $3000 for data,
* RAM Locations from $3100 for program
*
* Input: Parameters hard-coded in the program - PORTB
* Serial Port for User Input
*
* Output: LED 1 at PORTB bit 4
* LED 2 at PORTB bit 5
* LED 3 at PORTB bit 6
* LED 4 at PORTB bit 7
* Serial Port for String Output
*
* Observation: This program will respond to user input to turn on and off LEDs 1, 2, & 3,
* Dim LED 4 from 100% to 0%, Dim LED 4 from 0% to 100%, and echo user input
* back to the terminal in Type Writer Mode.
*
* Note: ON CSM-12C128 board,
* Switch 1 is at PORTB bit 0, and
* LED 4 is at PORTB bit 7.
*
* 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
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
Counter dc.w $0036 ; X register count number for time Delay
; loop for 10 useconds
; The work to calculate this number is in
; the comments for the delay10usec subroutine.
LEVEL dc.b $0005 ; Light Level that the LED should be
str ds.b $0005 ; Array of 5 bytes to read a string
dc.b NULL
lenStr dc.w $0005 ; Length of str array
* There is a second Data Section at the end of the file.
*
**************************************************************************
* 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
mainLoop
ldx #msg ; Load the address of msg into X
jsr WriteString ; Jump to WriteString to output message on serial
ldx #str ; Load the address of str into X
ldy lenStr ; Load length of str into Y
jsr Zeros ; jump to Zeros to zero out str
ldx #str ; Reload address of str into X
jsr ReadString ; Jump to ReadString to read user input into str
ldx #str ; Reload Address of str into X
jsr CheckInput ; Jump to CheckInput to handle user input
bra mainLoop ; Loop back to mainLoop always
TypeWriter ldx #twMsg ; Load Type Writer welcome message address
jsr WriteString ; Jump to WriteString to write message to serial
twReadLoop jsr getchar ; Read Character from Serial
beq twReadLoop ; While Character == 0, branch to twReadLoop
jsr putchar ; Write Character back to terminal
staa PORTB ; Write Character to PORTB
bra twReadLoop ; Branch always to twReadLoop
**************************************************************************
* Subroutine Section: address used [ $3100 to $3FFF ] RAM Memory
*
;*************************************************************************
; CheckInput subroutine
;
; This subroutine will check the input string and match the option.
;
; Input: Address of null terminated string in X.
; Output: No Output, Control flow changed to proper subroutine.
; Registers in use: X for the address of the string, Y for the address of the
; option to compare against, and A for the return value of strcmp
; Memory locations in use: Memory Address for serial line, address of the string
;
; Comments: This subroutine will not return a value, it will jump to the proper subroutine
; based on the input given.
;
CheckInput
pshy ; Save Y to the stack
psha ; Save A to the stack
ldy #option1 ; Load address of option1 string into Y
jsr strcmp ; Compare input string and option1 string
bne check2 ; If not equal, branch to next check
ldaa #1 ; Load 1 into A to specify LED number
jsr TurnOnLED ; Jump to TurnOnLED to turn on LED 1
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check2 ldy #option2 ; Load address of option2 string into Y
jsr strcmp ; Compare input string and option2 string
bne check3 ; If not equal, branch to next check
ldaa #1 ; Load 1 into A to specify LED number
jsr TurnOffLED ; Jump to TurnOffLED to turn on LED 1
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check3 ldy #option3 ; Load address of option3 string into Y
jsr strcmp ; Compare input string and option3 string
bne check4 ; If not equal, branch to next check
ldaa #2 ; Load 2 into A to specify LED number
jsr TurnOnLED ; Jump to TurnOnLED to turn on LED 2
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check4 ldy #option4 ; Load address of option4 string into Y
jsr strcmp ; Compare input string and option4 string
bne check5 ; If not equal, branch to next check
ldaa #2 ; Load 2 into A to specify LED number
jsr TurnOffLED ; Jump to TurnOffLED to turn on LED 2
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check5 ldy #option5 ; Load address of option5 string into Y
jsr strcmp ; Compare input string and option5 string
bne check6 ; If not equal, branch to next check
ldaa #3 ; Load 3 into A to specify LED number
jsr TurnOnLED ; Jump to TurnOnLED to turn on LED 3
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check6 ldy #option6 ; Load address of option6 string into Y
jsr strcmp ; Compare input string and option6 string
bne check7 ; If not equal, branch to next check
ldaa #3 ; Load 3 into A to specify LED number
jsr TurnOffLED ; Jump to TurnOffLED to turn off LED 3
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check7 ldy #option7 ; Load address of option7 string into Y
jsr strcmp ; Compare input string and option7 string
bne check8 ; If not equal, branch to next check
jsr LowToHigh ; Jump to LowToHigh to dim LED 4 from 0% to 100%
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check8 ldy #option8 ; Load address of option8 string into Y
jsr strcmp ; Compare input string and option8 string
bne check9 ; If not equal, branch to next check
jsr HighToLow ; Jump to LowToHigh to dim LED 4 from 100% to 0%
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
check9 ldy #option9 ; Load address of option9 string into Y
jsr strcmp ; Compare input string and option9 string
bne none ; If not equal, branch to unknown result
jmp TypeWriter ; Jump to TypeWriter portion of main routine
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
none ldx #unknown ; Load address of uknown command string into X
jsr WriteString ; Write unknown command string to serial
pula ; Restore A from the stack
puly ; Restore Y from the stack
rts ; Return to caller
;*************************************************************************
; 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
;*************************************************************************
; strcmp subroutine
;
; This subroutine will compare two null terminated strings.
;
; Input: Address of 2 null terminated strings in X & Y
; Output: 0 or 1 in accumulator A to signal same and different respectively
; Registers in use: X & Y for the address of the strings and A & B for the current bytes
; Memory locations in use: Memory Address for serial line, address of the strings
;
; Comments: This subroutine requires null terminated strings otherwise it will not work.
;
strcmp
pshb ; Save A to the Stack
pshx ; Save X to the Stack
pshy ; Save Y to the Stack
cmpLoop ldaa 1,x+ ; Load byte at X into A
beq diffX ; If A == 0, branch to diffX
ldab 1,y+ ; Load byte at Y into B
beq diffY ; If B == 0, branch to diffY
sba ; Subtract B from A and store in A
beq cmpLoop ; If zero Loop, the characters are the same
ldaa #1 ; Load 1 into A to signal difference
puly ; Restore Y from the Stack
pulx ; Restore X from the Stack
pulb ; Restore B from the Stack
rts ; Return to Caller
diffX ldaa y ; Load character at Y into A
beq equal ; If A == 0, Y and X are the same, branch to equal
diffY ldaa #1 ; Load 1 into A to signal difference
puly ; Restore Y from the Stack
pulx ; Restore X from the Stack
pulb ; Restore B from the stack
rts ; Return to caller
equal clra ; Clear A to signal similarity
puly ; Restore Y from the Stack
pulx ; Restore X from the Stack
pulb ; Restore B from the stack
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 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
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
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
pula ; restore A from the stack
rts ; return to caller
;*************************************************************************
; TurnOnLED subroutine
;
; This subroutine will dim turn on a specified LED
;
; Input: LED number 1 to 3, in accumulator A
; Output: Specified LED turned on
; Registers in use: A accumulator to specify the LED
; Memory locations in use: PORTB memory location associated with PORTB on the chip
;
; Comments: This subroutine requires PORTB to be setup
;
TurnOnLED
cmpa #1 ; Compare A to 1
bne onCheckTwo ; If A != 1, check next number
bset PORTB,%00010000 ; Turn On LED 1
bra onDone ; Jump to onDone
onCheckTwo cmpa #2 ; Compare A to 2
bne onCheckThr ; If A != 2, check next number
bset PORTB,%00100000 ; Turn On LED 2
bra onDone ; Jump to onDone
onCheckThr bset PORTB,%01000000 ; Turn On LED 3
onDone rts ; Return to caller
;*************************************************************************
; TurnOffLED subroutine
;
; This subroutine will dim turn of a specified LED
;
; Input: LED number 1 to 3, in accumulator A
; Output: Specified LED turned of
; Registers in use: A accumulator to specify the LED
; Memory locations in use: PORTB memory location associated with PORTB on the chip
;
; Comments: This subroutine requires PORTB to be setup
;
TurnOffLED
cmpa #1 ; Compare A to 1
bne ofCheckTwo ; If A != 1, check next number
bclr PORTB,%00010000 ; Turn Off LED 1
bra ofDone ; Jump to onDone
ofCheckTwo cmpa #2 ; Compare A to 2
bne ofCheckThr ; If A != 2, check next number
bclr PORTB,%00100000 ; Turn Off LED 2
bra ofDone ; Jump to onDone
ofCheckThr bclr PORTB,%01000000 ; Turn Off LED 3
ofDone rts ; Return to caller
;*************************************************************************
; HighToLow subroutine
;
; This subroutine will dim LED4 from 100% to 0% in 400ms
;
; Input: No Input, all parameters are hard coded
; Output: LED4 dimmed from 100% to 0% in 400ms, wasted cycles
; Registers in use: A accumulator to control the light level of the LED
; Memory locations in use: PORTB memory location associated with PORTB on the chip
;
; Comments: This subroutine requires dimmer subroutine
;
HighToLow
psha ; Save accumulator A to the stack
ldaa #100 ; load 100 into accumulator A
decrease tbeq A,doneDec ; Test if A == 0, skip loop if so
staa LEVEL ; Save A to LEVEL
jsr dimmer ; jump to dimmer subroutine
jsr dimmer ; jump to dimmer subroutine
jsr dimmer ; jump to dimmer subroutine
jsr dimmer ; jump to dimmer subroutine
deca ; decrement accumulator A by 1
bra decrease ; loop to decrease always
doneDec pula ; Restore A from the stack
rts ; Return to caller
;*************************************************************************
; HighToLow subroutine
;
; This subroutine will dim LED4 from 100% to 0% in 400ms
;
; Input: No Input, all parameters are hard coded
; Output: LED4 dimmed from 100% to 0% in 400ms, wasted cycles
; Registers in use: A accumulator to control the light level of the LED
; Memory locations in use: PORTB memory location associated with PORTB on the chip
;
; Comments: This subroutine requires dimmer subroutine
;
LowToHigh
psha ; Save accumulator A to the stack
ldaa #0 ; load 100 into accumulator A
increase cmpa #100 ; Compare A to 100
beq doneInc ; Test if A == 100, jump to doneInc
staa LEVEL ; Save A to LEVEL
jsr dimmer ; jump to dimmer subroutine
jsr dimmer ; jump to dimmer subroutine
jsr dimmer ; jump to dimmer subroutine
jsr dimmer ; jump to dimmer subroutine
inca ; increment accumulator A by 1
bra increase ; loop to increase always
doneInc pula ; Restore A from the stack
rts ; Return to caller
;*************************************************************************
; dimmer subroutine
;
; This subroutine will dim LED4 to a given level
;
; Input: Two 1 byte counters, ONN and OFF, for how many times
; LED4 should be on and off for.
; Output: LED4 dimmed to a given level, wasted cycles
; Registers in use: A accumulator to counter number of times looped
; Memory locations in use: Two bytes ONN and OFF used to dim the LED4 to a given level
;
; Comments: This subroutine requires delay10usec subroutine
;
dimmer
bset PORTB,%10000000 ; Turn LED4 on
psha ; Save A to the stack
ldaa LEVEL ; Load the light level into accumulator A
onDelay tbeq A, skipToOff ; Test if A == 0, skip loop if so
jsr delay10usec ; delay for 10 microseconds
deca ; decrement accumulator A by 1
bra onDelay ; jump back to onDelay always
skipToOff bclr PORTB,%10000000 ; Turn off LED4
ldaa #100 ; load 100 into accumulator A
suba LEVEL ; Subtract LEVEL to get off count
offDelay tbeq A,doneLoop ; Test if A == 0, skip loop if so
jsr delay10usec ; delay 10 microseconds
deca ; decrement accumulator A by 1
bra offDelay ; jump back to offDelay always
doneLoop pula ; restore A from the stack
rts ; return to caller
;*************************************************************************
; delay10usec subroutine
;
; This subroutine causes a 10 usec. delay
;
; Input: a 16bit count number in 'Counter'
; Output: time delay, cpu cycle wasted
; Registers in use: X register, as counter
; Memory locations in use: a 16bit input number at 'Counter'
;
; Comments: Code relies on counter being $39 to be exactly 10 usec work is below
; Given: freq = 24MHz = 24000000 sec = 10 usec = 0.00001
; freq = cycles / seconds
;
; cycles = freq * seconds = 24000000Hz * 0.00001 = 240
;
; This sub routine is 12 + 4 * 'Counter' cycles long, solving for 'Counter'
; the result is found to be 57.
;
delay10usec
pshx ; Save register x to the stack
ldx Counter ; load counter into register x
innerLoop dex ; decrement register x by 1
bne innerLoop ; loop while register x is not 0
pulx ; restore register x from the stack
nop ; extra nop to make exactly 10 usec
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: address used [ $3100 to $3FFF ] RAM Memory
*
; unknown: string to warn the user of unknown output
unknown dc.b 'Error: Unknown Command',CR,LF,NULL
; twMsg: welcome message when type writer loads
twMsg dc.b 'Welcome to Type Writer, you may type below.',CR,LF,NULL
; Below are strings of the options to compare in CheckInput
option1 dc.b 'L1',NULL
option2 dc.b 'F1',NULL
option3 dc.b 'L2',NULL
option4 dc.b 'F2',NULL
option5 dc.b 'L3',NULL
option6 dc.b 'F3',NULL
option7 dc.b 'L4',NULL
option8 dc.b 'F4',NULL
option9 dc.b 'QUIT',NULL
; msg: this is the main option menu string
msg dc.b 'L1: Turn on LED1',CR,LF
dc.b 'F1: Turn off LED1',CR,LF
dc.b 'L2: Turn on LED2',CR,LF
dc.b 'F2: Turn off LED2',CR,LF
dc.b 'L3: Turn on LED3',CR,LF
dc.b 'F3: Turn off LED3',CR,LF
dc.b 'L4: LED4 goes from 0% light level to 100% light level in 0.4 seconds',CR,LF
dc.b 'F4: LED4 goes from 100% light level to 0% light level in 0.4 seconds',CR,LF
dc.b 'QUIT: Quit menu program, run Type writer program.',CR,LF,NULL
|
