URL
https://opencores.org/ocsvn/copyblaze/copyblaze/trunk
Subversion Repositories copyblaze
[/] [copyblaze/] [trunk/] [copyblaze/] [sw/] [code/] [kcpsm/] [uclock/] [uclock.psm] - Rev 2
Compare with Previous | Blame | View Log
;KCPSM3 Program - Real Time Clock with UART communication.;;Ken Chapman - Xilinx Ltd - October 2003;;;Port definitions;CONSTANT UART_status_port, 00 ;UART status inputCONSTANT tx_half_full, 01 ; Transmitter half full - bit0CONSTANT tx_full, 02 ; FIFO full - bit1CONSTANT rx_half_full, 04 ; Receiver half full - bit2CONSTANT rx_full, 08 ; FIFO full - bit3CONSTANT rx_data_present, 10 ; data present - bit4;CONSTANT UART_read_port, 01 ;UART Rx data input;CONSTANT UART_write_port, 01 ;UART Tx data output;CONSTANT alarm_port, 00 ;Alarm outputCONSTANT alarm_control, 01 ; bit0;;Special Register usage;NAMEREG sF, UART_data ;used to pass data to and from the UART;NAMEREG sE, store_pointer ;used to pass location of data in scratch pad memory;;Two registers to form a 16-bit counter used to count;interrupt pulses generated at 1us intervals.;NAMEREG sD, int_counter_lsb ;lower 8-bitsNAMEREG sC, int_counter_msb ;upper 8-bits;;;Scratch Pad Memory Locations;;CONSTANT us_time_stamp_lsb, 00 ;16-bit micro-second time stampCONSTANT us_time_stamp_msb, 01;CONSTANT us_time_lsb, 02 ;16-bit micro-second real time valueCONSTANT us_time_msb, 03;CONSTANT ms_time_lsb, 04 ;16-bit milli-second real time valueCONSTANT ms_time_msb, 05;CONSTANT real_time_hours, 06 ;Current clock timeCONSTANT real_time_minutes, 07CONSTANT real_time_seconds, 08;CONSTANT alarm_time_hours, 09 ;Alarm timeCONSTANT alarm_time_minutes, 0ACONSTANT alarm_time_seconds, 0B;CONSTANT alarm_status, 0C ;Alarm statusCONSTANT alarm_active, 01 ; bit0 - Alarm is activeCONSTANT alarm_armed, 02 ; bit1 - Alarm is armed;CONSTANT time_preserve0, 10 ;storage for protection of registersCONSTANT time_preserve1, 11 ;used by the real time clock routine.CONSTANT time_preserve2, 12CONSTANT time_preserve3, 13CONSTANT time_preserve4, 14CONSTANT time_preserve5, 15;;UART character strings will be stored in scratch pad memory ending in carriage return.;A string can be up to 16 characters with the start location defined by this constant.;CONSTANT string_start, 20;;;Initialise the system;;cold_start: LOAD s0, 00 ;clear all time valuesSTORE s0, us_time_stamp_lsbSTORE s0, us_time_stamp_msbSTORE s0, us_time_lsbSTORE s0, us_time_msbSTORE s0, ms_time_lsbSTORE s0, ms_time_msbSTORE s0, real_time_hoursSTORE s0, real_time_minutesSTORE s0, real_time_secondsSTORE s0, alarm_time_hoursSTORE s0, alarm_time_minutesSTORE s0, alarm_time_secondsSTORE s0, alarm_status ;clear and disable alarmCALL alarm_drive ;turn off alarm control output portLOAD int_counter_lsb, 00 ;clear 'us' interrupt counterLOAD int_counter_msb, 00ENABLE INTERRUPT ;enable the 1us interrupts;;;Start of the main program loop.;;A prompt is transmitted to the UART transmitter and then;a command can be entered and interpreted.;;prompt_input: CALL send_prompt ;Prompt 'KCPSM3>'CALL receive_string ;obtain input string and maintain the time;;;Parse the string and perform actions as required;;;LOAD s1, string_startCALL fetch_char_from_memoryCOMPARE s0, character_CR ;carriage return does nothingJUMP Z, prompt_inputCOMPARE s0, character_T ;start of 'TIME' command?JUMP Z, test_for_TIMECOMPARE s0, character_A ;start of 'ALARM' command?JUMP Z, test_for_ALARM;;trap other command starts here;bad_input_command: CALL send_Syntax_Error ;no valid commandJUMP Z, prompt_input;;test_for_TIME: CALL fetch_char_from_memoryCOMPARE s0, character_I ;test for rest of 'TIME'JUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_MJUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_EJUMP NZ, bad_input_command;now have a valid TIME command to processCALL fetch_char_from_memoryCOMPARE s0, character_CR ;carriage return means display timeJUMP NZ, set_time_commandCALL transmit_time ;transmit time to UARTJUMP prompt_inputset_time_command: COMPARE s0, character_spaceJUMP NZ, bad_input_commandCALL test_time_string ;interpret 'hh:mm:ss' stringJUMP C, prompt_input ;test for invalid inputSTORE s6, real_time_hours ;set new time into clockSTORE s5, real_time_minutesSTORE s4, real_time_secondsSTORE s0, ms_time_lsb ;clear 'ms' counter (s0=00)STORE s0, ms_time_msbCALL transmit_time ;transmit new time to UARTJUMP prompt_input;;test_for_ALARM: CALL fetch_char_from_memoryCOMPARE s0, character_L ;test for rest of 'ALARM'JUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_AJUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_RJUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_MJUMP NZ, bad_input_command;now have a valid ALARM command to processCALL fetch_char_from_memoryCOMPARE s0, character_CR ;carriage return means display alarm timeJUMP NZ, set_alarm_commandCALL transmit_alarm_time ;transmit time to UARTJUMP prompt_inputset_alarm_command: COMPARE s0, character_space ;test for ON or OFF commandJUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_OJUMP Z, set_alarm_on_offSUB s1, 01 ;move memory pointer back to first character of 'hh:mm:ss' stringCALL test_time_string ;interpret 'hh:mm:ss' stringJUMP C, prompt_input ;test for invalid inputSTORE s6, alarm_time_hours ;set new time into clockSTORE s5, alarm_time_minutesSTORE s4, alarm_time_secondsCALL transmit_alarm_time ;transmit new alarm time and statusJUMP prompt_inputset_alarm_on_off: CALL fetch_char_from_memoryCOMPARE s0, character_N ;test for 'ON'JUMP NZ, test_OFFCALL fetch_char_from_memoryCOMPARE s0, character_CRJUMP NZ, bad_input_commandFETCH s0, alarm_status ;turn alarm onOR s0, alarm_armedSTORE s0, alarm_statusCALL transmit_alarm_time ;transmit alarm time and statusJUMP prompt_inputtest_OFF: COMPARE s0, character_F ;test for for 'OFF'JUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_FJUMP NZ, bad_input_commandCALL fetch_char_from_memoryCOMPARE s0, character_CRJUMP NZ, bad_input_commandLOAD s0, 00 ;turn alarm off and stop an active alarmSTORE s0, alarm_statusCALL alarm_drive ;turn off alarmCALL transmit_alarm_time ;transmit alarm time and statusJUMP prompt_input;;;;;Read an 'hh:mm:ss' time string and provide new values.;;The string must be provided in successive scratch pad memory locations;with the s1 register containing the location of the first character.;;A correct time specification will result in the return of new values;as follows:-;; s6 = hours; s5 = minutes; s4 = seconds;;If the syntax is incorrect or values are not in the correct ranges an;'Invalid Time' message will be transmitted and the CARRY flag will be set;;Registers used s0, s1, s6, s5 and s4;test_time_string: CALL 2char_to_value ;obtain hours valueJUMP C, invalid_time ;test for non-decimal charactersLOAD s6, s2 ;remember hoursADD s1, 01 ;increment memory pointer past hoursCALL fetch_char_from_memoryCOMPARE s0, character_colon ;test for colonJUMP NZ, invalid_timeCALL 2char_to_value ;obtain minutes valueJUMP C, invalid_time ;test for non-decimal charactersLOAD s5, s2 ;remember minutesADD s1, 01 ;increment memory pointer past minutesCALL fetch_char_from_memoryCOMPARE s0, character_colon ;test for colonJUMP NZ, invalid_timeCALL 2char_to_value ;obtain seconds valueJUMP C, invalid_time ;test for non-decimal charactersLOAD s4, s2 ;remember minutesADD s1, 01 ;increment memory pointer past secondsCALL fetch_char_from_memoryCOMPARE s0, character_CR ;finish with carriage returnJUMP NZ, invalid_time;Have values for hh:mm:ss but need to test if each is valid range.COMPARE s6, hours_in_a_dayJUMP NC, invalid_timeCOMPARE s5, minutes_in_an_hourJUMP NC, invalid_timeCOMPARE s4, seconds_in_a_minuteJUMP NC, invalid_timeLOAD s0, 00SR0 s0 ;reset CARRY flag (with s0=0)RETURN ;time string was OKinvalid_time: CALL send_InvalidCALL send_spaceCALL send_TimeLOAD s0, 01SR0 s0 ;set CARRY flagRETURN ;time string was bad;;;Fetch character from memory, convert to upper case;and increment memory pointer.;;The memory pointer is provided in register s1.;The character obtained is returned in register s0.;;Registers used s0 and s1.;fetch_char_from_memory: FETCH s0, (s1) ;read characterCALL upper_case ;convert to upper caseADD s1, 01 ;increment memory pointerRETURN;;;;Read one character from the UART;;Character read will be returned in a register called 'UART_data' and will be;echoed to the UART transmitter.;;The routine first tests the receiver FIFO buffer to see if data is present.;If the FIFO is empty, the routine waits until there is a character to read.;As this could take any amount of time the wait loop includes a call to the;subroutine which updates the real time clock.;;Registers used s0 and UART_data;read_from_UART: INPUT s0, UART_status_port ;test Rx_FIFO bufferTEST s0, rx_data_presentJUMP NZ, read_characterCALL update_time ;Perform useful operation whilst waitingJUMP read_from_UARTread_character: INPUT UART_data, UART_read_port ;read from FIFOCALL send_to_UART ;echo received characterRETURN;;;;Transmit one character to the UART;;Character supplied in register called 'UART_data'.;;The routine first tests the transmit FIFO buffer to see if it is full.;If the FIFO is full, the routine waits until there is space which could;be as long as it takes to transmit one complete character.;; Baud Rate Time per Character (10 bits); 9600 1,024us; 19200 521us; 38400 260us; 57600 174us; 115200 87us;;Since this is a relatively long duration, the wait loop includes a;call to the subroutine which updates the real time clock.;;Registers used s0;send_to_UART: INPUT s0, UART_status_port ;test Tx_FIFO bufferTEST s0, tx_fullJUMP Z, UART_writeCALL update_time ;Perform useful operation whilst waitingJUMP send_to_UARTUART_write: OUTPUT UART_data, UART_write_portRETURN;;;;;Alarm output;;Uses the alarm status scratch pad memory to set or reset the alarm;control bit on the alarm output port.;;Registers used s0;alarm_drive: FETCH s0, alarm_status ;read statusAND s0, alarm_active ;isolate bit0OUTPUT s0, alarm_portRETURN;;;;;;Transmit the time to the UART port in the format hh:mm:ss and end;with a carriage return.;;The time to converted must be stored in 3 scratch pad memory locations as;defined below. A register named 'store_pointer' must provide the address of;first location.;; Address Data;; store_pointer ----> hours; store_pointer + 1 ----> minutes; store_pointer + 1 ----> seconds;;The routine first converts the time into an ASCII string stored in scratch;pad memory starting at a location specified by a constant named 'string_start'.;The string will then be transmitted.;;Registers used s0, s1, s2, 'store_pointer' and 'UART_data'.;transmit_time: LOAD store_pointer, real_time_hours ;locate current time in memoryCALL time_to_ASCIICALL transmit_stringRETURN;;;Transmit the alarm time and status to the UART port in the format hh:mm:ss and;ending with carriage return.;;The alarm time to converted must be stored in 3 scratch pad memory locations as;defined below. A register named 'store_pointer' must provide the address of;first location.;; Address Data;; store_pointer ----> hours; store_pointer + 1 ----> minutes; store_pointer + 1 ----> seconds;;The routine first converts the time into an ASCII string stored in scratch;pad memory starting at a location specified by a constant named 'string_start'.;The string will then be transmitted.;;Registers used s0, s1, s2, 'store_pointer' and 'UART_data'.;transmit_alarm_time: LOAD store_pointer, alarm_time_hours ;locate alarm time in memoryCALL time_to_ASCIICALL transmit_stringCALL send_AlarmCALL send_spaceFETCH s0, alarm_status ;read alarm statusTEST s0, alarm_active ;test for activeJUMP Z, test_armedCALL send_ActiveRETURNtest_armed: TEST s0, alarm_armed ;test for onJUMP Z, alarm_is_offCALL send_ONRETURNalarm_is_off: CALL send_OFFRETURN;;;Transmit ASCII string to UART;;An ASCII string must be provided in scratch pad memory commencing at the;location specified by a constant named 'string_start'. The string must;end with a carriage return (0D).;;Registers used s1 and 'UART_data'.; s0 is then used in subroutine 'send_to_UART';transmit_string: LOAD s1, string_start ;locate start of stringnext_char_tx: FETCH UART_data, (s1) ;read character from memoryCALL send_to_UART ;transmit characterCOMPARE UART_data, character_CR ;test for last characterRETURN ZADD s1, 01 ;move to next characterJUMP next_char_tx;;;Receive ASCII string from UART;;An ASCII string will be read from the UART and stored in scratch pad memory;commencing at the location specified by a constant named 'string_start'.;The string will will have a maximum length of 16 characters including a;carriage return (0D) denoting the end of the string.;;As each character is read, it is echoed to the UART transmitter.;Some minor editing is supported using backspace (BS=08) which is used;to adjust what is stored in scratch pad memory and adjust the display;on the terminal screen using characters sent to the UART transmitter.;;A test is made for the receiver FIFO becoming full. A full status is treated as;a potential error situation and will result in a 'Overflow Error' message being;transmitted to the UART, the receiver FIFO being purged of all data and an;empty string being stored (carriage return at first location).;;Registers used s0, s1, s2 and 'UART_data'.;receive_string: LOAD s1, string_start ;locate start of stringLOAD s2, s1 ;compute 16 character addressADD s2, 10receive_full_test: INPUT s0, UART_status_port ;test Rx_FIFO buffer for fullTEST s0, rx_fullJUMP NZ, read_errorCALL read_from_UART ;obtain and echo characterSTORE UART_data, (s1) ;write to memoryCOMPARE UART_data, character_CR ;test for end of stringRETURN ZCOMPARE UART_data, character_BS ;test for back spaceJUMP Z, BS_editADD s1, 01 ;increment memory pointerCOMPARE s1, s2 ;test for pointer exceeding 16 charactersJUMP NZ, receive_full_test ;next characterCALL send_backspace ;hold end of string position on terminal displayBS_edit: SUB s1, 01 ;memory pointer back oneCOMPARE s1, string_start ;test for under flowJUMP C, string_start_againCALL send_space ;clear character at current positionCALL send_backspace ;position cursorJUMP receive_full_test ;next characterstring_start_again: CALL send_greater_than ;restore '>' at promptJUMP receive_string ;begin again;Receiver buffer overflow conditionread_error: CALL send_CR ;Transmit error messageSTORE UART_data, string_start ;empty string in memory (start with CR)CALL send_Overflow_ErrorCALL send_CRclear_UART_Rx_loop: INPUT s0, UART_status_port ;test Rx_FIFO buffer for dataTEST s0, rx_data_presentRETURN Z ;finish when buffer is emptyINPUT UART_data, UART_read_port ;read from FIFO and ignoreJUMP clear_UART_Rx_loop;;;;Send Carriage Return to the UART;send_CR: LOAD UART_data, character_CRCALL send_to_UARTRETURN;;;;Send a space to the UART;send_space: LOAD UART_data, character_spaceCALL send_to_UARTRETURN;;;Send a back space to the UART;send_backspace: LOAD UART_data, character_BSCALL send_to_UARTRETURN;;Send 'Syntax Error' to the UART;send_Syntax_Error: LOAD UART_data, character_SCALL send_to_UARTLOAD UART_data, character_yCALL send_to_UARTLOAD UART_data, character_nCALL send_to_UARTLOAD UART_data, character_tCALL send_to_UARTLOAD UART_data, character_aCALL send_to_UARTLOAD UART_data, character_xCALL send_to_UARTJUMP send_space_Error;;Send 'Overflow Error' to the UART;send_Overflow_Error: LOAD UART_data, character_OCALL send_to_UARTLOAD UART_data, character_vCALL send_to_UARTLOAD UART_data, character_eCALL send_to_UARTLOAD UART_data, character_rCALL send_to_UARTLOAD UART_data, character_fCALL send_to_UARTLOAD UART_data, character_lCALL send_to_UARTLOAD UART_data, character_oCALL send_to_UARTLOAD UART_data, character_wCALL send_to_UARTsend_space_Error: CALL send_space;;Send 'Error' to the UART;send_Error: LOAD UART_data, character_ECALL send_to_UARTLOAD UART_data, character_rCALL send_to_UARTCALL send_to_UARTLOAD UART_data, character_oCALL send_to_UARTLOAD UART_data, character_rCALL send_to_UARTRETURN;;Send 'KCPSM3>' prompt to the UART;send_prompt: CALL send_CR ;start new lineLOAD UART_data, character_KCALL send_to_UARTLOAD UART_data, character_CCALL send_to_UARTLOAD UART_data, character_PCALL send_to_UARTLOAD UART_data, character_SCALL send_to_UARTLOAD UART_data, character_MCALL send_to_UARTLOAD UART_data, character_3CALL send_to_UART;;Send '>' character to the UART;send_greater_than: LOAD UART_data, character_greater_thanCALL send_to_UARTRETURN;;Send 'Invalid' string to the UART;send_Invalid: LOAD UART_data, character_ICALL send_to_UARTLOAD UART_data, character_nCALL send_to_UARTLOAD UART_data, character_vCALL send_to_UARTLOAD UART_data, character_aCALL send_to_UARTLOAD UART_data, character_lCALL send_to_UARTLOAD UART_data, character_iCALL send_to_UARTLOAD UART_data, character_dCALL send_to_UARTRETURN;;Send 'Time' string to the UART;send_Time: LOAD UART_data, character_TCALL send_to_UARTLOAD UART_data, character_iCALL send_to_UARTLOAD UART_data, character_mCALL send_to_UARTLOAD UART_data, character_eCALL send_to_UARTRETURN;;Send 'Alarm' string to the UART;send_Alarm: LOAD UART_data, character_ACALL send_to_UARTLOAD UART_data, character_lCALL send_to_UARTLOAD UART_data, character_aCALL send_to_UARTLOAD UART_data, character_rCALL send_to_UARTLOAD UART_data, character_mCALL send_to_UARTRETURN;;Send 'OFF' string to the UART;send_OFF: LOAD UART_data, character_OCALL send_to_UARTLOAD UART_data, character_FCALL send_to_UARTCALL send_to_UARTRETURN;;Send 'ON' string to the UART;send_ON: LOAD UART_data, character_OCALL send_to_UARTLOAD UART_data, character_NCALL send_to_UARTRETURN;;Send 'Active' string to the UART;send_Active: LOAD UART_data, character_ACALL send_to_UARTLOAD UART_data, character_cCALL send_to_UARTLOAD UART_data, character_tCALL send_to_UARTLOAD UART_data, character_iCALL send_to_UARTLOAD UART_data, character_vCALL send_to_UARTLOAD UART_data, character_eCALL send_to_UARTRETURN;;;Convert time to ASCII string in scratch pad memory.;;The time to converted must be stored in 3 scratch pad memory locations as;defined below. A register named 'store_pointer' must provide the address of;first location.;; Address Data;; store_pointer ----> hours; store_pointer + 1 ----> minutes; store_pointer + 1 ----> seconds;;The resulting ASCII string will be stored in scratch pad memory starting at;a location specified by a constant named 'string_start'. The string will;take the format hh:mm:ss and end with a carriage return.;;Registers used s0, s1, s2 and 'store_pointer'.;time_to_ASCII: LOAD s2, string_start ;location for stringFETCH s0, (store_pointer) ;read hours valueCALL decimal_to_ASCII ;convert to ASCIISTORE s1, (s2) ;write hours to stringADD s2, 01STORE s0, (s2)ADD s2, 01LOAD s0, character_colon ;write ':' to stringSTORE s0, (s2)ADD s2, 01ADD store_pointer, 01 ;move to minutesFETCH s0, (store_pointer) ;read minutes valueCALL decimal_to_ASCII ;convert to ASCIISTORE s1, (s2) ;write minutes to stringADD s2, 01STORE s0, (s2)ADD s2, 01LOAD s0, character_colon ;write ':' to stringSTORE s0, (s2)ADD s2, 01ADD store_pointer, 01 ;move to secondsFETCH s0, (store_pointer) ;read seconds valueCALL decimal_to_ASCII ;convert to ASCIISTORE s1, (s2) ;write seconds to stringADD s2, 01STORE s0, (s2)ADD s2, 01LOAD s0, character_CR ;finish string with carriage returnSTORE s0, (s2)RETURN;;Convert value provided in register s0 into ASCII characters;;The value provided must in the range 0 to 99 and will be converted into;two ASCII characters.; The number of 'tens' will be representd by an ASCII character returned in register s1.; The number of 'units' will be representd by an ASCII character returned in register s0.;;The ASCII representations of '0' to '9' are 30 to 39 hexadecimal which is simply 30 hex added to;the actual decimal value.;;Registers used s0 and s1.;decimal_to_ASCII: LOAD s1, 30 ;load 'tens' counter with ASCII for '0'test_for_ten: ADD s1, 01 ;increment 'tens' valueSUB s0, 0A ;try to subtract 10 from the supplied valueJUMP NC, test_for_ten ;repeat if subtraction was possible without underflow.SUB s1, 01 ;'tens' value one less ten due to underflowADD s0, 3A ;restore units value (the remainder) and convert to ASCIIRETURN;;;;;Real Time Clock;;Uses the 1us interrupt counter [int_counter_msb,int_counter_lsb] to determine how many;micro-seconds have elapsed since the last update. This allows for just over 65ms between;updates. Complete multiples of 1000us are used to update a 16-bit milli-second counter held;in scratch pad memory locations [ms_time_stamp_msb,ms_time_stamp_msb] which in turn;is used to update the real time hours, minutes and seconds clock held in scratch pad;memory locations 'real_time_hours', 'real_time_minutes' and 'real_time_seconds'.;;The routine uses default register names s0,s1,s2,s3,s4,s5. These are preserved in scratch pad;memory during the routine and restored before returning.;;Useful constants for real time clock operations;CONSTANT count_1000_lsb, E8 ;lower 8-bits of 1000 count valueCONSTANT count_1000_msb, 03 ;upper 8-bits of 1000 count valueCONSTANT hours_in_a_day, 18 ;24 hours in a dayCONSTANT minutes_in_an_hour, 3C ;60 minutes in an hourCONSTANT seconds_in_a_minute, 3C ;60 seconds in a minute;update_time: STORE s0, time_preserve0 ;preserve contents of registers used during routineSTORE s1, time_preserve1STORE s2, time_preserve2STORE s3, time_preserve3STORE s4, time_preserve4STORE s5, time_preserve5;FETCH s2, us_time_stamp_lsb ;read the previous 'us' time stamp into [s3,s2]FETCH s3, us_time_stamp_msbDISABLE INTERRUPT ;Read and store current 'us' time stamp provided by the interruptSTORE int_counter_lsb, us_time_stamp_lsb ;counter. Interrupts are disabled to ensure that both bytes relateSTORE int_counter_msb, us_time_stamp_msb ;to the same count value.ENABLE INTERRUPTFETCH s4, us_time_stamp_lsb ;read the new 'us' time stamp in [s5,s4]FETCH s5, us_time_stamp_msb ;SUB s4, s2 ;calculate 'us' time difference [s5,s4] = [s5,s4] - [s3,s2]SUBCY s5, s3 ; (This works correctly even if counter has rolled over)FETCH s2, us_time_lsb ;read current 'us' time into [s3,s2]FETCH s3, us_time_msbADD s2, s4 ;add on the elapsed 'us' value [s3,s2] = [s3,s2] + [s5,s4]ADDCY s3, s5;determine how many 1000us (1ms) units there are (if any) in current 'us' timeLOAD s0, 00 ;reset 'ms' countertest_1000us: SUB s2, count_1000_lsb ;subtract 1000 from [s3,s2]SUBCY s3, count_1000_msbJUMP C, store_us_time ;Carry indicates [s3,s2] was less than 1000usADD s0, 01 ;increment 'ms' elapsed because [s3,s2] was more or equal to 1000usJUMP test_1000us ;repeat to see if more than 1ms has elapsedstore_us_time: ADD s2, count_1000_lsb ;add 1000 to restore 'us' valueADDCY s3, count_1000_msbSTORE s2, us_time_lsb ;store the current value of 'us'STORE s3, us_time_msb;s0 holds the number of 'ms' elapsed since last update (if any).FETCH s2, ms_time_lsb ;read current 'ms' time into [s3,s2]FETCH s3, ms_time_msbADD s2, s0 ;add on the elapsed 'ms' value [s3,s2] = [s3,s2] + s0ADDCY s3, 00;determine if there are now more than 1000ms to form 1 second.LOAD s0, 00 ;reset 'second' counterSUB s2, count_1000_lsb ;subtract 1000 from [s3,s2]SUBCY s3, count_1000_msbJUMP C, restore_ms_time ;Carry indicates [s3,s2] was less than 1000msADD s0, 01 ;increment 'second' elapsed because [s3,s2] was more or equal to 1000msJUMP store_ms_time ;new value of 'ms' is remainder of subtractionrestore_ms_time: ADD s2, count_1000_lsb ;add 1000 to restore 'ms' valueADDCY s3, count_1000_msbstore_ms_time: STORE s2, ms_time_lsb ;store the current value of 'ms'STORE s3, ms_time_msb;s0 currently determines if one second needs to be added to the hh:mm:ss clock timeFETCH s1, real_time_seconds ;read secondsADD s1, s0 ;add one second if required by s0COMPARE s1, seconds_in_a_minute ;test for 1 minuteJUMP Z, inc_minutesSTORE s1, real_time_seconds ;store updated secondsJUMP time_update_completeinc_minutes: LOAD s1, 00 ;seconds become zeroSTORE s1, real_time_secondsFETCH s1, real_time_minutes ;read minutesADD s1, 01 ;increment minutesCOMPARE s1, minutes_in_an_hour ;test for 1 hourJUMP Z, inc_hoursSTORE s1, real_time_minutes ;store updated minutesJUMP time_update_completeinc_hours: LOAD s1, 00 ;minutes become zeroSTORE s1, real_time_minutesFETCH s1, real_time_hours ;read hoursADD s1, 01 ;increment hoursCOMPARE s1, hours_in_a_day ;test for 24 hoursJUMP Z, reset_hoursSTORE s1, real_time_hours ;store updated hoursJUMP time_update_completereset_hours: LOAD s1, 00 ;hours become zeroSTORE s1, real_time_hours;;With the time updated, there is then a test for time=alarm time;time_update_complete: FETCH s0, real_time_hoursFETCH s1, alarm_time_hours ;compare hoursCOMPARE s0, s1JUMP NZ, finish_updateFETCH s0, real_time_minutes ;compare minutesFETCH s1, alarm_time_minutesCOMPARE s0, s1JUMP NZ, finish_updateFETCH s0, real_time_seconds ;compare secondsFETCH s1, alarm_time_secondsCOMPARE s0, s1JUMP NZ, finish_updateFETCH s0, alarm_status ;test if alarm is turned onTEST s0, alarm_armedJUMP Z, finish_update ;alarm was offOR s0, alarm_active ;activate alarmSTORE s0, alarm_statusCALL alarm_drivefinish_update: FETCH s0, time_preserve0 ;restore the register contentsFETCH s1, time_preserve1FETCH s2, time_preserve2FETCH s3, time_preserve3FETCH s4, time_preserve4FETCH s5, time_preserve5RETURN;;Convert character to upper case;;The character supplied in register s0.;If the character is in the range 'a' to 'z', it is converted;to the equivalent upper case character in the range 'A' to 'Z'.;All other characters remain unchanged.;;Registers used s0.;upper_case: COMPARE s0, 61 ;eliminate character codes below 'a' (61 hex)RETURN CCOMPARE s0, 7B ;eliminate character codes above 'z' (7A hex)RETURN NCAND s0, DF ;mask bit5 to convert to upper caseRETURN;;;Convert character '0' to '9' to numerical value in range 0 to 9;;The character supplied in register s0. If the character is in the;range '0' to '9', it is converted to the equivalent decimal value.;Characters not in the range '0' to '9' are signified by the return;with the CARRY flag set.;;Registers used s0.;1char_to_value: ADD s0, C6 ;reject character codes above '9' (39 hex)RETURN C ;carry flag is setSUB s0, F6 ;reject character codes below '0' (30 hex)RETURN ;carry is set if value not in range;;;Determine the numerical value of a two character decimal string held in;scratch pad memory such the result is in the range 0 to 99 (00 to 63 hex).;;The string must be stored as in two consecutive memory locations and the;location of the first (tens) character supplied in the s1 register.;The result is provided in register s2. Strings not using characters in the;range '0' to '9' are signified by the return with the CARRY flag set.;;Registers used s0, s1 and s2.;2char_to_value: FETCH s0, (s1) ;read 'tens' characterCALL 1char_to_value ;convert to numerical valueRETURN C ;bad character - CARRY setLOAD s2, s0SL0 s2 ;multiply 'tens' value by 10 (0A hex)SL0 s2ADD s2, s0SL0 s2ADD s1, 01 ;read 'units' characterFETCH s0, (s1)CALL 1char_to_value ;convert to numerical valueRETURN C ;bad character - CARRY setADD s2, s0 ;add units to result and clear CARRY flagRETURN;;;Interrupt service routine (ISR);;The interrupt is used to increment a 16-bit counter formed with two registers;called [int_counter_msb,int_counter_lsb]. This provides a count of the number;of micro-seconds elapsed. The counter is 'free running' in that it will count;up to 65,535 and then roll over to zero. The count value is then used in other;parts of the program as required and where it is less time critical.;;The ISR only uses the specified counter registers;ADDRESS 3FCISR: ADD int_counter_lsb, 01 ;add 1us to 16-bit counterADDCY int_counter_msb, 00RETURNI ENABLE;;Interrupt vector;ADDRESS 3FFJUMP ISR;;;Useful constants;;;ASCII table;CONSTANT character_a, 61CONSTANT character_b, 62CONSTANT character_c, 63CONSTANT character_d, 64CONSTANT character_e, 65CONSTANT character_f, 66CONSTANT character_g, 67CONSTANT character_h, 68CONSTANT character_i, 69CONSTANT character_j, 6ACONSTANT character_k, 6BCONSTANT character_l, 6CCONSTANT character_m, 6DCONSTANT character_n, 6ECONSTANT character_o, 6FCONSTANT character_p, 70CONSTANT character_q, 71CONSTANT character_r, 72CONSTANT character_s, 73CONSTANT character_t, 74CONSTANT character_u, 75CONSTANT character_v, 76CONSTANT character_w, 77CONSTANT character_x, 78CONSTANT character_y, 79CONSTANT character_z, 7ACONSTANT character_A, 41CONSTANT character_B, 42CONSTANT character_C, 43CONSTANT character_D, 44CONSTANT character_E, 45CONSTANT character_F, 46CONSTANT character_G, 47CONSTANT character_H, 48CONSTANT character_I, 49CONSTANT character_J, 4ACONSTANT character_K, 4BCONSTANT character_L, 4CCONSTANT character_M, 4DCONSTANT character_N, 4ECONSTANT character_O, 4FCONSTANT character_P, 50CONSTANT character_Q, 51CONSTANT character_R, 52CONSTANT character_S, 53CONSTANT character_T, 54CONSTANT character_U, 55CONSTANT character_V, 56CONSTANT character_W, 57CONSTANT character_X, 58CONSTANT character_Y, 59CONSTANT character_Z, 5ACONSTANT character_0, 30CONSTANT character_1, 31CONSTANT character_2, 32CONSTANT character_3, 33CONSTANT character_4, 34CONSTANT character_5, 35CONSTANT character_6, 36CONSTANT character_7, 37CONSTANT character_8, 38CONSTANT character_9, 39CONSTANT character_colon, 3ACONSTANT character_semi_colon, 3BCONSTANT character_less_than, 3CCONSTANT character_greater_than, 3ECONSTANT character_equals, 3DCONSTANT character_space, 20CONSTANT character_CR, 0D ;carriage returnCONSTANT character_question, 3F ;'?'CONSTANT character_dollar, 24CONSTANT character_BS, 08 ;Back Space command character;