;
           disp_VA: LOAD s5, character_V
                    CALL LCD_write_data
                    LOAD s5, character_A
                    CALL LCD_write_data
                    LOAD s5, character_equals
                    CALL LCD_write_data
                    RETURN
                    ;
                    ;
                    ;Display 'A/D' on LCD at current cursor position
                    ;
                    ;
           disp_AD: LOAD s5, character_A
                    CALL LCD_write_data
                    LOAD s5, character_divide
                    CALL LCD_write_data
                    LOAD s5, character_D
                    CALL LCD_write_data
                    LOAD s5, character_equals
                    CALL LCD_write_data
                    RETURN
                    ;
                    ;
                    ;
                    ;**************************************************************************************
                    ;Value to ASCII Conversions and LCD display
                    ;**************************************************************************************
                    ;
                    ;Convert hexadecimal value provided in register s0 into ASCII characters
                    ;
                    ;The value provided must can be any value in the range 00 to FF and will be converted into
                    ;two ASCII characters.
                    ;     The upper nibble will be represented by an ASCII character returned in register s2.
                    ;     The lower nibble will be represented by an ASCII character returned in register s1.
                    ;
                    ;The ASCII representations of '0' to '9' are 30 to 39 hexadecimal which is simply 30 hex
                    ;added to the actual decimal value. The ASCII representations of 'A' to 'F' are 41 to 46
                    ;hexadecimal requiring a further addition of 07 to the 30 already added.
                    ;
                    ;Registers used s0, s1 and s2.
                    ;
 hex_byte_to_ASCII: LOAD s1, s0                         ;remember value supplied
                    SR0 s0                              ;isolate upper nibble
                    SR0 s0
                    SR0 s0
                    SR0 s0
                    CALL hex_to_ASCII                   ;convert
                    LOAD s2, s0                         ;upper nibble value in s2
                    LOAD s0, s1                         ;restore complete value
                    AND s0, 0F                          ;isolate lower nibble
                    CALL hex_to_ASCII                   ;convert
                    LOAD s1, s0                         ;lower nibble value in s1
                    RETURN
                    ;
                    ;Convert hexadecimal value provided in register s0 into ASCII character
                    ;
                    ;Register used s0
                    ;
      hex_to_ASCII: SUB s0, 0A                          ;test if value is in range 0 to 9
                    JUMP C, number_char
                    ADD s0, 07                          ;ASCII char A to F in range 41 to 46
       number_char: ADD s0, 3A                          ;ASCII char 0 to 9 in range 30 to 40
                    RETURN
                    ;
                    ;
                    ;Display the two character HEX value of the register contents 's0' on
                    ;the LCD display at the current cursor position.
                    ;
                    ;Registers used s0, s1, s2, s4, s5, s6
                    ;
     disp_hex_byte: CALL hex_byte_to_ASCII
                    LOAD s6, s1                         ;remember lower hex character
                    LOAD s5, s2                         ;display upper hex character
                    CALL LCD_write_data
                    LOAD s5, s6                         ;display lower hex character
                    CALL LCD_write_data
                    RETURN
                    ;
                    ;
                    ;**************************************************************************************
                    ;Software delay routines
                    ;**************************************************************************************
                    ;
                    ;
                    ;
                    ;Delay of 1us.
                    ;
                    ;Constant value defines reflects the clock applied to KCPSM3. Every instruction
                    ;executes in 2 clock cycles making the calculation highly predictable. The '6' in
                    ;the following equation even allows for 'CALL delay_1us' instruction in the initiating code.
                    ;
                    ; delay_1us_constant =  (clock_rate - 6)/4       Where 'clock_rate' is in MHz
                    ;
                    ;Registers used s0
                    ;
         delay_1us: LOAD s0, delay_1us_constant
          wait_1us: SUB s0, 01
                    JUMP NZ, wait_1us
                    RETURN
                    ;
                    ;Delay of 40us.
                    ;
                    ;Registers used s0, s1
                    ;
        delay_40us: LOAD s1, 28                         ;40 x 1us = 40us
         wait_40us: CALL delay_1us
                    SUB s1, 01
                    JUMP NZ, wait_40us
                    RETURN
                    ;
                    ;
                    ;Delay of 1ms.
                    ;
                    ;Registers used s0, s1, s2
                    ;
         delay_1ms: LOAD s2, 19                         ;25 x 40us = 1ms
          wait_1ms: CALL delay_40us
                    SUB s2, 01
                    JUMP NZ, wait_1ms
                    RETURN
                    ;
                    ;Delay of 20ms.
                    ;
                    ;Delay of 20ms used during initialisation.
                    ;
                    ;Registers used s0, s1, s2, s3
                    ;
        delay_20ms: LOAD s3, 14                         ;20 x 1ms = 20ms
         wait_20ms: CALL delay_1ms
                    SUB s3, 01
                    JUMP NZ, wait_20ms
                    RETURN
                    ;
                    ;Delay of approximately 1 second.
                    ;
                    ;Registers used s0, s1, s2, s3, s4
                    ;
          delay_1s: LOAD s4, 32                         ;50 x 20ms = 1000ms
           wait_1s: CALL delay_20ms
                    SUB s4, 01
                    JUMP NZ, wait_1s
                    RETURN
                    ;
                    ;
                    ;
                    ;**************************************************************************************
                    ;LCD Character Module Routines
                    ;**************************************************************************************
                    ;
                    ;LCD module is a 16 character by 2 line display but all displays are very similar
                    ;The 4-wire data interface will be used (DB4 to DB7).
                    ;
                    ;The LCD modules are relatively slow and software delay loops are used to slow down
                    ;KCPSM3 adequately for the LCD to communicate. The delay routines are provided in
                    ;a different section (see above in this case).
                    ;
                    ;
                    ;Pulse LCD enable signal 'E' high for greater than 230ns (1us is used).
                    ;
                    ;Register s4 should define the current state of the LCD output port.
                    ;
                    ;Registers used s0, s4
                    ;
       LCD_pulse_E: XOR s4, LCD_E                       ;E=1
                    OUTPUT s4, LCD_output_port
                    CALL delay_1us
                    XOR s4, LCD_E                       ;E=0
                    OUTPUT s4, LCD_output_port
                    RETURN
                    ;
                    ;Write 4-bit instruction to LCD display.
                    ;
                    ;The 4-bit instruction should be provided in the upper 4-bits of register s4.
                    ;Note that this routine does not release the master enable but as it is only
                    ;used during initialisation and as part of the 8-bit instruction write it
                    ;should be acceptable.
                    ;
                    ;Registers used s4
                    ;
   LCD_write_inst4: AND s4, F8                          ;Enable=1 RS=0 Instruction, RW=0 Write, E=0
                    OUTPUT s4, LCD_output_port          ;set up RS and RW >40ns before enable pulse
                    CALL LCD_pulse_E
                    RETURN
                    ;
                    ;
                    ;Write 8-bit instruction to LCD display.
                    ;
                    ;The 8-bit instruction should be provided in register s5.
                    ;Instructions are written using the following sequence
                    ; Upper nibble
                    ; wait >1us
                    ; Lower nibble
                    ; wait >40us
                    ;
                    ;Registers used s0, s1, s4, s5
                    ;
   LCD_write_inst8: LOAD s4, s5
                    AND s4, F0                          ;Enable=0 RS=0 Instruction, RW=0 Write, E=0
                    OR s4, LCD_drive                    ;Enable=1
                    CALL LCD_write_inst4                ;write upper nibble
                    CALL delay_1us                      ;wait >1us
                    LOAD s4, s5                         ;select lower nibble with
                    SL1 s4                              ;Enable=1
                    SL0 s4                              ;RS=0 Instruction
                    SL0 s4                              ;RW=0 Write
                    SL0 s4                              ;E=0
                    CALL LCD_write_inst4                ;write lower nibble
                    CALL delay_40us                     ;wait >40us
                    LOAD s4, F0                         ;Enable=0 RS=0 Instruction, RW=0 Write, E=0
                    OUTPUT s4, LCD_output_port          ;Release master enable
                    RETURN
                    ;
                    ;
                    ;
                    ;Write 8-bit data to LCD display.
                    ;
                    ;The 8-bit data should be provided in register s5.
                    ;Data bytes are written using the following sequence
                    ; Upper nibble
                    ; wait >1us
                    ; Lower nibble
                    ; wait >40us
                    ;
                    ;Registers used s0, s1, s4, s5
                    ;
    LCD_write_data: LOAD s4, s5
                    AND s4, F0                          ;Enable=0 RS=0 Instruction, RW=0 Write, E=0
                    OR s4, 0C                           ;Enable=1 RS=1 Data, RW=0 Write, E=0
                    OUTPUT s4, LCD_output_port          ;set up RS and RW >40ns before enable pulse
                    CALL LCD_pulse_E                    ;write upper nibble
                    CALL delay_1us                      ;wait >1us
                    LOAD s4, s5