diff options
| -rw-r--r-- | cmpen472hw9_McDonnell/Full_Chip_Simulation.ini | 2 | ||||
| -rw-r--r-- | cmpen472hw9_McDonnell/Sources/cpmen472hw9_McDonnell.asm | 974 | ||||
| -rw-r--r-- | cmpen472hw9_McDonnell/Sources/main.asm | 2 | ||||
| -rw-r--r-- | cmpen472hw9_McDonnell/bin/Project.abs | bin | 9384 -> 9384 bytes | |||
| -rw-r--r-- | cmpen472hw9_McDonnell/bin/main.dbg | 2 | ||||
| -rw-r--r-- | cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/ObjectCode/main.asm.o | bin | 9384 -> 9384 bytes | |||
| -rw-r--r-- | cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/TargetDataWindows.tdt | bin | 64818 -> 64818 bytes |
7 files changed, 977 insertions, 3 deletions
diff --git a/cmpen472hw9_McDonnell/Full_Chip_Simulation.ini b/cmpen472hw9_McDonnell/Full_Chip_Simulation.ini index 9b2a0df..e6799e8 100644 --- a/cmpen472hw9_McDonnell/Full_Chip_Simulation.ini +++ b/cmpen472hw9_McDonnell/Full_Chip_Simulation.ini @@ -10,7 +10,7 @@ Target=sim Layout=ASM_layout.hwl LoadDialogOptions=AUTOERASEANDFLASH NORUNAFTERLOAD CPU=HC12 -MainFrame=0,1,-1,-1,-1,-1,459,132,2322,1148 +MainFrame=0,1,-1,-1,-1,-1,1150,95,2453,1111 Configuration=Full_Chip_Simulation.hwc Statusbar=1 ShowToolbar=1 diff --git a/cmpen472hw9_McDonnell/Sources/cpmen472hw9_McDonnell.asm b/cmpen472hw9_McDonnell/Sources/cpmen472hw9_McDonnell.asm new file mode 100644 index 0000000..a97068d --- /dev/null +++ b/cmpen472hw9_McDonnell/Sources/cpmen472hw9_McDonnell.asm @@ -0,0 +1,974 @@ +************************************************************************** +* +* Title: Calculator Clock +* +* Objective: CMPEN 472 Homework 9 +* +* Revision: V1.0 +* +* Date: Apr. 2, 2025 +* +* Programmer: Jacob McDonnell +* +* Company: The Pennsylvania State University +* Department of Computer Science and Engineering +* +* Algorithm: Simple Serial I/O, Real Time Interrupts for Time Tracking +* +* Register Use: A & B to current byte, etc, +* X & Y holds address of strings and length of string, +* D to hold data for printing, reading, and updating time. +* +* 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 +* +* Observation: The HC12 will output the time and a command prompt every second. +* The user can input commands and the program will output a response +* based on the input. +* +* 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 +************************************************************************** +* RTI Vector Section: address used [ $FFF0 to $FFF1 ] RAM Memory +* + org $FFF0 ; Memory location for RTI 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) + + ldaa #$FF ; Two 7 segment displays on PORTB + staa DDRB ; Set all of PORTB as output + + 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 + ldx #spacer ; Load the address of spacer into X + jsr WriteString ; Write the spacer string to the output + jsr PrintPrompt ; Jump to PrintPrompt 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 + ldaa 0,x ; Load first character from inputBuffer into A + beq mainLoop ; If A == 0, branch to mainLoop, only zero if Solve was called + ldy lenInput ; Load the length of inputBuffer into Y + jsr Zeros ; Zero out inputBuffer + + sei ; Disable interrupts + jsr PrintTime ; Jump to PrintTime to print new time + ldx #spacer ; Load the address of spacer into X + jsr WriteString ; Write the spacer string to the output + jsr PrintPrompt ; Jump to PrintPrompt to write to serial console + cli ; Enable interrupts + + 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 + staa PORTB ; Write A to PORTB + jsr putchar ; Write character to serial console + bra twLoop ; Branch always to twLoop + +************************************************************************** +* Subroutine Section: address used [ $3100 to $3FFF ] RAM Memory +* + +;************************************************************************* +; rtiisr subroutine +; +; This subroutine will increment the counter, seconds, minutes, & hours counters +; to track the time. This subroutine will be called ~400 times a second. +; +; Input: No input other than the timer to call the isr. +; Output: The counter, seconds, minutes, & hours buffers will +; be updated to track the time, the time & prompt will be +; printed every second. +; Registers in use: X for adding to the counter, seconds, minutes, & hours buffers. +; Memory locations in use: Memory Address for serial line, Memory addresses for RTIISR control, +; Buffer words for counters, seconds, minutes, & hours buffers. +; +; Comments: The counter buffer should be compared to 400, but for the simulator, +; the counter is compared to 200 to better simulate 1 second on my computer. +; + +rtiisr bset CRGFLG,%10000000; Clear RTI Interrupt Flag + ldx counter ; Load counter into X + inx ; Increment counter by 1 + stx counter ; Save X to counter + cpx #200 ; Compare counter to 200, This is about 1 second on my computer + bne rtiSkip ; If counter != 200, 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 + ldx #spacer ; Load the address of spacer into X + jsr WriteString ; Write the spacer string to the output + jsr PrintPrompt ; Jump to PrintPrompt +rtiSkip RTI ; Return from RTI ISR + +;************************************************************************* +; PrintTime subroutine +; +; This subroutine will print the time, command prompt, and maybe an error prompt. +; +; Input: No input. +; Output: The time prompt, time, command prompt, the current input, +; and/or an error on the serial console. +; Registers in use: A for the characters to print, X for buffer addresses, +; Y for buffer lengths, D for the seconds/minutes/hours for calling TimeOnPortB +; Memory locations in use: Memory Address for serial line, Buffer words for counters, +; seconds, minutes, & hours buffers, and buffer to print time, +; outputBuf for tracking what to output on PORTB. +; +; Comments: This subroutine requires TimeOnPortB subroutine and to be setup. The subroutine +; will print the current user input if its not finished. +; + +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 outputBuf ; Load outputBuf into A + cmpa #'h' ; Compare A to 'h' + bne pTimeIsM ; If A != 'h', branch to pTimeIsM + ldd hours ; Load hours into B + bra skipRest ; Jump to skipRest +pTimeIsM cmpa #'m' ; Compare A to 'm' + bne pTimeIsS ; If A != 'm', branch to pTimeIsS + ldd minutes ; Load Minutes into D + bra skipRest ; Jump to skipRest +pTimeIsS ldd seconds ; Load seconds into D +skipRest jsr TimeOnPortB ; Call TimeOnPortB to output time + pulx ; Restore X from the stack + puly ; Restore Y from the stack + puld ; Restore D from the stack + rts ; Return to caller + +;************************************************************************* +; PrintPrompt subroutine +; +; This subroutine will output the CMD prompt and any current input to the serial console +; +; Input: No Input +; Output: The CMD prompt and any input onto the serial console +; Registers in use: X for addresses of strings +; Memory locations in use: PORTB memory location, CMD prompt memory locaiton, inputBuffer location +; +; Comments: This subroutine requires WriteString subroutine. +; + +PrintPrompt + pshx ; Save X to the stack + 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 + rts ; Return + +;************************************************************************* +; TimeOnPortB subroutine +; +; This subroutine will output the time given on on PORTB for two seven segment displays. +; +; Input: Two Digit Decimal number in register D. +; Output: The given two digit decimal number on PORTB for two 7 segment displays. +; Registers in use: D for the input, and for math to split the digits, X for math to split digits. +; Memory locations in use: PORTB memory location. +; +; Comments: This subroutine will only work with two digit decimal numbers, and one digit decimal +; numbers (leading zeros will be added). +; + +TimeOnPortB + pshd ; Save D to the stack + pshx ; Save X to the stack + ldx #10 ; Load 10 into X to get digit + idiv ; Divide D by X and save Digit into D + pshb ; Save B to the stack (Lower Byte of D) + exg x,d ; Swap X and D + ldx #10 ; Load 10 into X to get digit + lslb ; Shift B left by 1 + lslb ; Shift B left by 1 + lslb ; Shift B left by 1 + lslb ; Shift B left by 1 + orab 1,sp+ ; Or B with Digit on stack + stab PORTB ; Save B to PORTB + pulx ; Restore X from the stack + puld ; Restore D from the stack + rts ; Return from caller + +;************************************************************************* +; ExecuteCommand subroutine +; +; This subroutine will parse user input and execute the proper command or error out. +; +; Input: An address of a NULL terminated string in X. +; Output: The output of the proper command or an error message. +; Registers in use: X for the address of the user input, A for individual characters, +; D & Y for numbers read from user input. +; Memory locations in use: Serial console memory locations. +; +; Comments: This subroutine will disable interrupts while setting the time and will +; reenable them after setting the time. +; + +ExecuteCommand + pshd ; Save D to the stack + pshy ; Save Y to the stack + ldaa 1,x+ ; Load the character from X into A + lbeq ecDone ; If A == 0, jump to ecDone + cmpa #'t' ; Compare A to 't' + bne isH ; If A != 't', branch to isH +skipSpaces ldaa 1,+x ; Load the next character into X + cmpa #' ' ; Compare A to ' ' character + beq skipSpaces ; If A == ' ', loop to skipSpaces + sei ; Disable interrupts + ldd hours ; Load hours into D + pshd ; Save hours to the stack + jsr ReadDecimal ; Read Hour number + exg y,d ; Exchange Y and D + cpd #24 ; Compare D to 24 + lbhs badHours ; If D >= 24, badHours + cpd #0 ; Compare D to 0 + lblt badHours ; If D < 0, badHours + std hours ; Save D to hours + ldaa -1,x ; Load the next character into A + cmpa #':' ; Compare A to ':' + lbne badHours ; If A != ':', badHours + ldd minutes ; Load minutes into D + pshd ; Save minutes to the stack + jsr ReadDecimal ; Read minute number + exg y,d ; Exchange Y and D + cpd #60 ; Compare D to 60 + bhs badMinutes ; If D >= 60, badMinutes + cpd #0 ; Compare D to 0 + blt badMinutes ; If D < 0, badMinutes + std minutes ; Save D to minutes + ldaa -1,x ; Load the next character into A + cmpa #':' ; Compare A to ':' + bne badMinutes ; If A != ':', badMinutes + ldd seconds ; Load seconds into D + pshd ; Save seconds to the stack + jsr ReadDecimal ; Read second number + exg y,d ; Exchange Y and D + cpd #60 ; Compare D to 60 + bhs badSeconds ; If D >= 60, badSeconds + cpd #0 ; Compare D to 0 + blt badSeconds ; If D < 0, badSeconds + std seconds ; Save D to seconds + ldaa -1,x ; Load the next character into A + cmpa #NULL ; Compare A to NULL + bne badSeconds ; If A != ':', badSeconds + clra ; Set A to 0 + staa counter ; Clear Counter + cli ; Enable interrupts + puld ; Restore D from the stack + puld ; Restore D from the stack + puld ; Restore D from the stack + 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 isEquation ; If A != 'q', branch to isEquation + 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 +isEquation dex ; Decrement X by 1 + jsr VerifyInput ; Verify input is valid equation + beq badCommand ; If Z == 1, badCommand + jsr Solve ; Jump to Solve to solve equation + bra ecDone ; Branch always to ecDone +badSeconds puld ; Restore Seconds from the stack + std seconds ; Restore seconds before change +badMinutes puld ; Restore minutes from the stack + std minutes ; Restore minutes before change +badHours puld ; Restore hours from the stack + std hours ; Restore hours before change + cli ; Reenable interrupts +badCommand pshx ; Save X to the stack + ldaa #' ' ; Load Space character into A + jsr putchar ; Jump to putchar to write space character + jsr putchar ; Jump to putchar to write space character + jsr putchar ; Jump to putchar to write space character + jsr putchar ; Jump to putchar to write space character + 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 the stack +ecDone puly ; Restore Y from the stack + puld ; Restore D from the stack + rts ; Return to caller + +;************************************************************************* +; Solve subroutine +; +; This subroutine will solve the math equation in the given string. +; +; 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, A & B to read characters from +; from the string. +; Memory locations in use: Memory Address for serial line, address of the string, numBuf word +; +; Comments: This subroutine EXPECTS the input to be valid. RUN VerifyInput BEFORE +; TO MAKE SURE THE STRING IS VALID, OTHERWISE THERE WILL BE ERRORS. +; + +Solve + pshy ; Save Y to the stack + pshd ; Save D to the stack + pshx ; Save X to the stack + jsr ReadDecimal ; Read First number + pshy ; Save Y to the stack + ldaa -1,x ; Read operator from X and save to A + jsr ReadDecimal ; Read First number + cmpa #'+' ; Compare A to '+' + beq sAdd ; Jump to sAdd to add the numbers + cmpa #'-' ; Compare A to '-' + beq sSub ; Jump to sSub to add the numbers + cmpa #'*' ; Compare A to '*' + beq sMul ; Jump to sMul to add the numbers + exg y,x ; Exchange X and Y + puly ; Restore Y from the stack + exg y,d ; Exchange Y and D + idiv ; Divide D/X => X + exg x,d ; Exchange X & D + bra sDone ; Jump to sDone +sAdd sty numBuf ; Save Y to numBuf + puly ; Restore Y from the stack + exg y,d ; Exchange Y and D + addd numBuf ; Add D and numBuf + bra sDone ; Jump to sDone +sSub sty numBuf ; Save Y to numBuf + puly ; Restore Y from the stack + exg y,d ; Exchange Y and D + subd numBuf ; Subtract D and numBuf + bra sDone ; Jump to sDone +sMul exg y,d ; Exchange Y and D + puly ; Restore Y from the stack + emul ; Multiply Y*D => Y:D + cpy #0 ; Compare Y to 0 + bne sOverflow ; If Y != 0, Overflow +sDone cpd #9999 ; Compare D to 9999 (Max output) + bgt sOverflow ; Branch to sOverflow if D > 9999 + cpd #-9999 ; Compare D to -9999 (Min output) + blt sOverflow ; Branch to sOverflow if D < -9999 + sei ; Disable Interrupts + jsr PrintTime ; Print Time to serial + psha ; Save A to the stack + ldaa #' ' ; Load the space character into A + jsr putchar ; Print the space character to the serial console + jsr putchar ; Print the space character to the serial console + jsr putchar ; Print the space character to the serial console + jsr putchar ; Print the space character to the serial console + pula ; Restore A from the stack + pulx ; Restore X from the stack + pshx ; Save X to the stack + jsr WriteString ; Write original equation to serial console + pulx ; Restore X from the stack + ldy lenInput ; Load the length of the input buffer into Y + jsr Zeros ; Clear input buffer + psha ; Save A to the stack + ldaa #'=' ; Load '=' into A + jsr putchar ; Print '=' to serial console + pula ; Restore A from the stack + ldy #buffer ; Load address of buffer into Y + jsr PrintDecimalWord; Print the answer to the Serial console + clra ; Clear A + staa operator ; Clear operator + jsr PrintTime ; Print the time to the serial console + ldx #spacer ; Load the address of spacer into X + jsr WriteString ; Write the spacer string to the output + jsr PrintPrompt ; Write CMD prompt to serial + cli ; Enable Interrupts + puld ; Restore D from the stack + puly ; Restore Y from the stack + rts ; Return to caller +sOverflow ldaa #' ' ; Load a space character into A + jsr putchar ; Jump to putchar to write space character + jsr putchar ; Jump to putchar to write space character + jsr putchar ; Jump to putchar to write space character + jsr putchar ; Jump to putchar to write space character + ldx #error ; Load the address of the error prompt into X + jsr WriteString ; Write original string to serial console + ldaa #' ' ; Load a space character into A + jsr putchar ; Jump to putchar to write space character + ldx #overflow ; Load address of overflow string into X + jsr WriteString ; Write overflow string to serial + pulx ; Restore X from the stack + puld ; Restore D from the stack + puly ; Restore Y from the stack + rts ; Return to caller + +;************************************************************************* +; VerifyInput subroutine +; +; This subroutine will verify the user input is valid. +; +; Input: An address of a Null terminated string in register X. +; Output: If valid Zero bit = 0 in CCR, if invalid, Zero bit = 1 +; and the string is outputed up to the error on the serial +; console with an error message. +; Registers in use: X for the address of the string, A for reading characters. +; Y to count the number of digits in a number, & B to count the number of numbers +; Memory locations in use: Memory Address for serial line, address of the string, 1 byte for operator +; +; Comments: This subroutine will modify the user string if invalid. +; + +VerifyInput + pshy ; Save Y to the stack + pshd ; Save D to the stack + pshx ; Save X to the stack + clrb ; Set B to Zero + stab operator ; Clear operator + ldy #0 ; Load Zero into Y +vNumLoop ldaa 1,x+ ; Load character from X into A + cmpa #'9' ; Compare A to '9' + bhi vInvalid ; If A > '9', not valid string + cmpa #'0' ; Compare A to '0' + blt vIsOp ; If A < '0', check if operator + iny ; Increment Y by 1 to count numbers + cpy #4 ; Compare Y to 4 + bhi vInvalid ; If greater than 4, invalid + bra vNumLoop ; Loop back to check for more digits +vIsOp cmpa #'+' ; Compare A to '+' + beq vOp ; This is an operator + cmpa #'-' ; Compare A to '-' + beq vOp ; This is an operator + cmpa #'*' ; Compare A to '*' + beq vOp ; This is an operator + cmpa #'/' ; Compare A to '/' + beq vOp ; This is an operator + cmpa #NULL ; Compare A to NULL character + beq vEndOfLine ; Check if end of line +vInvalid clra ; Set A to zero + staa 0,X ; Write Null terminator to X + ldaa #4 ; Load 4 into A to set zero bit + tap ; Transfer A to CCR + pulx ; Restore X from the stack + puld ; Restore D from the stack + puly ; Restore Y from the stack + rts ; Return to caller +vOp staa operator ; Store operator in operator buffer + ldaa -2,x ; Load previous character into A + cmpa #'0' ; Compare A to '0' + blt vInvalid ; Invalid string since previous is not number + cmpa #'9' ; Compare A to '9' + bhi vInvalid ; Invalid string since previous is not number + addb #1 ; Increment B by 1 + cmpb #1 ; Compare B to 1 + bhi vInvalid ; Invalid string since B > 1 and we have another operator + ldy #0 ; Set Y to 0 + bra vNumLoop ; Check for next number +vEndOfLine ldaa -2,x ; Load previous character into A + cmpa #'0' ; Compare A to '0' + blt vInvalid ; Invalid string since previous is not number + cmpa #'9' ; Compare A to '9' + bhi vInvalid ; Invalid string since previous is not number + ldaa operator ; Load operator character from buffer + beq vInvalid ; If operator buffer is zero, invalid + clra ; Set A to zero + tap ; Transfer A to CCR + pulx ; Restore X from the stack + puld ; Restore D from the stack + puly ; Restore Y 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 ':' + 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 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 +* + +clock dc.b 'Tcalc> ',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',NULL ; Invalid Input Prompt + +overflow dc.b 'Overflow Error',NULL ; Overflow error message + +; twMsg: welcome message for typewrite +twMsg dc.b CR,LF,'Clock stopped and Typewrite program started.',CR,LF + dc.b 'You may type below.',CR,LF,NULL + +; spacer: the white space between time and cmd prompt +spacer dc.b ' ',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 + + end ; last line of the file diff --git a/cmpen472hw9_McDonnell/Sources/main.asm b/cmpen472hw9_McDonnell/Sources/main.asm index 70443e6..a97068d 100644 --- a/cmpen472hw9_McDonnell/Sources/main.asm +++ b/cmpen472hw9_McDonnell/Sources/main.asm @@ -323,7 +323,7 @@ PrintPrompt ldx #inputBuffer ; Load the address of the inputBuffer into X jsr WriteString ; Write the string to the serial pulx ; Restore X from the stack - rts + rts ; Return ;************************************************************************* ; TimeOnPortB subroutine diff --git a/cmpen472hw9_McDonnell/bin/Project.abs b/cmpen472hw9_McDonnell/bin/Project.abs Binary files differindex f6f1657..30d3567 100644 --- a/cmpen472hw9_McDonnell/bin/Project.abs +++ b/cmpen472hw9_McDonnell/bin/Project.abs diff --git a/cmpen472hw9_McDonnell/bin/main.dbg b/cmpen472hw9_McDonnell/bin/main.dbg index 252e481..69646bb 100644 --- a/cmpen472hw9_McDonnell/bin/main.dbg +++ b/cmpen472hw9_McDonnell/bin/main.dbg @@ -323,7 +323,7 @@ PrintPrompt ldx #inputBuffer ; Load the address of the inputBuffer into X jsr WriteString ; Write the string to the serial pulx ; Restore X from the stack - rts + rts ; Return ;************************************************************************* ; TimeOnPortB subroutine diff --git a/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/ObjectCode/main.asm.o b/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/ObjectCode/main.asm.o Binary files differindex f6f1657..30d3567 100644 --- a/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/ObjectCode/main.asm.o +++ b/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/ObjectCode/main.asm.o diff --git a/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/TargetDataWindows.tdt b/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/TargetDataWindows.tdt Binary files differindex abcc93c..2273a25 100644 --- a/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/TargetDataWindows.tdt +++ b/cmpen472hw9_McDonnell/cmpen472hw9_McDonnell_Data/Standard/TargetDataWindows.tdt |