
;; Atmel Probe - Copyright 2007 by Michael Kohn
;; Email: mike ta mikekohn.net
;;   Web: http://www.mikekohn.net/
;;
;; Simple example of how to use the UART of an Atmel ATmega168
;; Tx/Rx on the ATmega168 are connected to a DS275 to convert
;; TTL serial values to rs232
;;
;; Extended rs232 test (as described above) to have a simple command
;; line interface to sdram and i/o ports

.include "m168def.inc"

; note: CLKSEL 0010

.dseg

.cseg
  ;; Set up stack ptr
  ldi r16, RAMEND>>8
  out SPH, r16
  ldi r16, RAMEND&255
  out SPL, r16

  ;; Set up LED default
  ser r17
  out DDRB, r17             ; entire port B is output
  ldi r18, 2
  out PORTB, r18            ; turn on bit 1

  ;; Set up rs232 baud rate
  ;; 25 @ 4MHz = 9600 baud
  ;; 103 @ 4MHz = 2400 baud
  ;; 25 @ 8MHz = 19200 baud
  ;; 51 @ 8MHz = 9600 baud
  eor r16, r16
  sts UBRR0H, r16
  ldi r16, 51
  sts UBRR0L, r16

  ;; Set up rs232 options
  ldi r16, (1<<UCSZ00)+(1<<UCSZ01)    ; sets up data as 8N1
  sts UCSR0C, r16
  ldi r17, (1<<TXEN0)+(1<<RXEN0)      ; enables send/receive
  sts UCSR0B, r17
  eor r17, r17
  sts UCSR0A, r17

  ;; Send copyright message
  ldi r30, (copyright*2)&255
  ldi r31, (copyright*2)>>8
  call send_string

  ;; Send prompt
  ldi r30, (prompt*2)&255
  ldi r31, (prompt*2)>>8
  call send_string

  ;; Set pointer to input data (start of sram)
  ldi r26, SRAM_START&255
  ldi r27, SRAM_START>>8

  ; ldi r17, SRAM_START>>8
  ; call print_hex
  ; ldi r17, SRAM_START&255
  ; call print_hex
  ldi r17, 0xf2
  sts 0x200, r17

main_loop:
  lds r20, UCSR0A         ; poll uart to see if there is a data waiting
  sbrs r20, RXC0
  rjmp main_loop          ; if no data, loop around

  lds r17, UDR0           ; read char from uart
  call send_char          ; echo char back to source

  cpi r17, 0x7f           ; check DEL
  breq do_del
  cpi r17, 0x08           ; check BACKSPACE
  breq do_del
  cpi r17, '\n'           ; check ENTER key
  breq do_cr
  cpi r17, '\r'           ; check other ENTER key
  breq do_cr

  st X+, r17

  rjmp main_loop


;; User pressed a delete key
;; Erase last character
do_del:
  cpi r26, SRAM_START&255
  brne del_not_zero
  cpi r27, SRAM_START>>8
  brne del_not_zero
  ldi r17, ' '             ; fugly.  fix this.
  rcall send_char
  rjmp main_loop

del_not_zero:
  sbiw r26, 1
  rjmp main_loop

;; The user pressed enter
;; Time to process input
do_cr:
  cpi r26, SRAM_START&255
  brne cr_not_zero
  cpi r27, SRAM_START>>8
  brne cr_not_zero
  rjmp exit_cr

cr_not_zero:
  ldi r17, '\r'
  rcall send_char
  ldi r17, '\n'
  rcall send_char

  ldi r16, 0
  st X+, r16

  ;; read from sram section
  ldi r30, (read_str*2)&255   ; compare command buffer
  ldi r31, (read_str*2)>>8    ; with the text "read "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_read
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip1
  rjmp cr_err
skip1:
  cpi r18, 2
  brne skip2
  rjmp ov_err
skip2:
  ld r17, X                   ; read what's in what X points to in SRAM
  rcall print_hex
  rjmp exit_cr

not_read:
  ;; write to sram section
  ldi r30, (write_str*2)&255  ; compare command buffer
  ldi r31, (write_str*2)>>8   ; with the text "write "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_write
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip3
  rjmp cr_err
skip3:
  cpi r18, 2
  brne skip4
  rjmp ov_err
skip4:
  movw r30, r26               ; move X into Z
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip5
  rjmp cr_err
skip5:
  cpi r18, 2
  brne skip6
  rjmp ov_err
skip6:
  st Z, r26
  rjmp exit_cr

not_write:
  ;; read from i/o port
  ldi r30, (readi_str*2)&255  ; compare command buffer
  ldi r31, (readi_str*2)>>8   ; with the text "readi "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_readi
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip7
  rjmp cr_err
skip7:
  cpi r18, 2
  brne skip8
  rjmp ov_err
skip8:
  mov r17, r26
  rcall read_io
  rcall print_hex
  rjmp exit_cr

not_readi:
  ;; write to i/o port
  ldi r30, (writei_str*2)&255 ; compare command buffer
  ldi r31, (writei_str*2)>>8  ; with the text "writei "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  brne skip9
  rjmp not_writei
skip9:
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip10
  rjmp cr_err
skip10:
  cpi r18, 2
  brne skip11
  rjmp ov_err
skip11:
  mov r7, r26
  rcall hex2int               ; read in hex data into X
  cpi r18, 1
  brne skip12
  rjmp cr_err
skip12:
  cpi r18, 2
  brne skip13
  rjmp ov_err
skip13:
  mov r17, r7
  mov r18, r26
  rcall write_io
  rjmp exit_cr

not_writei:
  ;; read from program flash
  ldi r30, (readf_str*2)&255  ; compare command buffer
  ldi r31, (readf_str*2)>>8   ; with the text "readf "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_readf
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip14
  rjmp cr_err
skip14:
  cpi r18, 2
  brne skip15
  rjmp ov_err
skip15:
  mov r30, r26
  lpm r17, Z                  ; read what's in what Z points to in flash
  rcall print_hex
  rjmp exit_cr

not_readf:
  ;; write to program flash
  ldi r30, (writef_str*2)&255 ; compare command buffer
  ldi r31, (writef_str*2)>>8  ; with the text "writef "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_writef
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  brne skip16
  rjmp cr_err
skip16:
  cpi r18, 2
  brne skip17
  rjmp ov_err
skip17:
  movw r30, r26
  rcall hex2int               ; read in hex data into X
  cpi r18, 1
  breq cr_err
  cpi r18, 2
  breq ov_err
  mov r0, r26
  mov r1, r27
  spm
  rjmp exit_cr

not_writef:
  ;; read from eeprom
  ldi r30, (reade_str*2)&255  ; compare command buffer
  ldi r31, (reade_str*2)>>8   ; with the text "reade "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_reade
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  breq cr_err
  cpi r18, 2
  breq ov_err
ee_againr:
  sbic EECR, EEPE
  rjmp ee_againr
  out EEARL, r26
  out EEARH, r27
  sbi EECR, EERE
  in r17, EEDR
  rcall print_hex
  rjmp exit_cr

not_reade:
  ;; write to eeprom
  ldi r30, (writee_str*2)&255 ; compare command buffer
  ldi r31, (writee_str*2)>>8  ; with the text "writee "
  ldi r28, SRAM_START&255
  ldi r29, SRAM_START>>8
  rcall strcmp
  cpi r18, 1
  breq not_writee
  rcall hex2int               ; read in hex address into X
  cpi r18, 1
  breq cr_err
  cpi r18, 2
  breq ov_err
  movw r0, r26
  rcall hex2int               ; read in hex data into X
  cpi r18, 1
  breq cr_err
  cpi r18, 2
  breq ov_err
ee_again:
  sbic EECR, EEPE
  rjmp ee_again
  out EEARL, r0
  out EEARH, r1
  out EEDR, r26
  sbi EECR, EEMPE
  sbi EECR, EEPE


  rjmp exit_cr

not_writee:
cr_err:
  ldi r30, (syntax_error*2)&255   ; send syntax error message
  ldi r31, (syntax_error*2)>>8
  call send_string
  rjmp exit_cr

ov_err:
  ldi r30, (overflow_error*2)&255   ; send syntax error message
  ldi r31, (overflow_error*2)>>8
  call send_string

exit_cr:
  ldi r26, SRAM_START&255   ; set Y to point back to start of 
  ldi r27, SRAM_START>>8  ; command input buffer

  ldi r30, (prompt*2)&255   ; send prompt message
  ldi r31, (prompt*2)>>8
  call send_string

  rjmp main_loop


;; code should never reach this point.. if it does, take the
;; process to vet and put it to sleep

  sleep

;; send char over rs232 function
send_char:
  lds r14, UCSR0A     ; check to see if it's okay to send a char
  sbrs r14, UDRE0
  rjmp send_char      ; if it's not okay, loop around :)
  sts UDR0, r17       ; output a char over rs232
  ret

;; send string over rs232 function
send_string:
  lpm r17, Z+              ; read next char in string buffer (from flash)
  tst r17                  ; check for null termination
  breq exit_send_string
  rcall send_char
  rjmp send_string
exit_send_string:
  ret

;; string compare Z in program memory with Y in SRAM
;; compare chars until the Z buffer hits a 0 or a char
;; differs
strcmp:
  lpm r17, Z+
  tst r17
  breq matched
  ld r18, Y+
  cp r18, r17
  breq strcmp
nomatch:
  ldi r18, 1
  ret
matched:
  ldi r18, 0
  ret

;; hex ascii to int16 from Y buffer
hex2int:
  ldi r18, 0             ; r18 will be a status return
  ldi r26, 0             ; X (r27:r26) will have the int16 value
  ldi r27, 0
  ;movw r30, r28          ; move Y to Z
hex2int_loop:
  ld r17, Y+
  tst r17                ; if null terminated then exit
  breq exit_hex2int
  cpi r17, ' '           ; if ' ' then exit
  breq exit_hex2int
  cpi r17, 'a'           ; check if 'a' <= r17 <= 'f'
  brlo not_a_to_f        ; branch less than
  cpi r17, 'g'
  brsh not_a_to_f        ; branch greater than or equal
  subi r17, 'a'
  subi r17, -10          ; r17=r17-'a'+10
  rjmp add_in_hex_value

not_a_to_f:
  cpi r17, '0'           ; check if '0' <= r17 <= '9'
  brlo not_0_to_9        ; branch less than
  cpi r17, 'g'
  brsh not_0_to_9        ; branch greater than or equal
  subi r17, '0'
add_in_hex_value:
  lsl r26
  rol r27
  brvs hex2int16_overflow
  lsl r26
  rol r27
  brvs hex2int16_overflow
  lsl r26
  rol r27
  brvs hex2int16_overflow
  lsl r26
  rol r27
  brvs hex2int16_overflow
  add r26, r17
  rjmp hex2int_loop

hex2int16_overflow:
  ldi r18, 2
  rjmp exit_hex2int

not_0_to_9:
  ldi r18, 1
exit_hex2int:
  ; movw r28, r30          ; move Y to Z
  ret

;; print_hex_nibble - outputs lower nibble of r17
print_hex_nibble:
  cpi r17, 10
  brlo hex_nibble_under_10
  subi r17, 10
  ldi r19, 'a'
  add r17, r19
  rcall send_char
  ret
hex_nibble_under_10:
  ldi r19, '0'
  add r17, r19
  rcall send_char
  ret

;; print int8 (r17) as hex over uart
print_hex:
  mov r18, r17
  lsr r17
  lsr r17
  lsr r17
  lsr r17
  andi r18, 15
  rcall print_hex_nibble
  mov r17, r18
  rcall print_hex_nibble
  ret

read_io:
  cpi r17, 0
  brne readio_skip0
  in r17, 0
  ret
readio_skip0:
  cpi r17, 1
  brne readio_skip1
  in r17, 1
  ret
readio_skip1:
  cpi r17, 2
  brne readio_skip2
  in r17, 2
  ret
readio_skip2:
  cpi r17, 3
  brne readio_skip3
  in r17, 3
  ret
readio_skip3:
  cpi r17, 4
  brne readio_skip4
  in r17, 4
  ret
readio_skip4:
  cpi r17, 5
  brne readio_skip5
  in r17, 5
  ret
readio_skip5:
  cpi r17, 6
  brne readio_skip6
  in r17, 6
  ret
readio_skip6:
  cpi r17, 7
  brne readio_skip7
  in r17, 7
  ret
readio_skip7:
  cpi r17, 8
  brne readio_skip8
  in r17, 8
  ret
readio_skip8:
  cpi r17, 9
  brne readio_skip9
  in r17, 9
  ret
readio_skip9:
  cpi r17, 10
  brne readio_skip10
  in r17, 10
  ret
readio_skip10:
  cpi r17, 11
  brne readio_skip11
  in r17, 11
  ret
readio_skip11:
  cpi r17, 12
  brne readio_skip12
  in r17, 12
  ret
readio_skip12:
  cpi r17, 13
  brne readio_skip13
  in r17, 13
  ret
readio_skip13:
  cpi r17, 14
  brne readio_skip14
  in r17, 14
  ret
readio_skip14:
  cpi r17, 15
  brne readio_skip15
  in r17, 15
  ret
readio_skip15:
  cpi r17, 16
  brne readio_skip16
  in r17, 16
  ret
readio_skip16:
  cpi r17, 17
  brne readio_skip17
  in r17, 17
  ret
readio_skip17:
  cpi r17, 18
  brne readio_skip18
  in r17, 18
  ret
readio_skip18:
  cpi r17, 19
  brne readio_skip19
  in r17, 19
  ret
readio_skip19:
  cpi r17, 20
  brne readio_skip20
  in r17, 20
  ret
readio_skip20:
  cpi r17, 21
  brne readio_skip21
  in r17, 21
  ret
readio_skip21:
  cpi r17, 22
  brne readio_skip22
  in r17, 22
  ret
readio_skip22:
  cpi r17, 23
  brne readio_skip23
  in r17, 23
  ret
readio_skip23:
  cpi r17, 24
  brne readio_skip24
  in r17, 24
  ret
readio_skip24:
  cpi r17, 25
  brne readio_skip25
  in r17, 25
  ret
readio_skip25:
  cpi r17, 26
  brne readio_skip26
  in r17, 26
  ret
readio_skip26:
  cpi r17, 27
  brne readio_skip27
  in r17, 27
  ret
readio_skip27:
  cpi r17, 28
  brne readio_skip28
  in r17, 28
  ret
readio_skip28:
  cpi r17, 29
  brne readio_skip29
  in r17, 29
  ret
readio_skip29:
  cpi r17, 30
  brne readio_skip30
  in r17, 30
  ret
readio_skip30:
  cpi r17, 31
  brne readio_skip31
  in r17, 31
  ret
readio_skip31:
  cpi r17, 32
  brne readio_skip32
  in r17, 32
  ret
readio_skip32:
  cpi r17, 33
  brne readio_skip33
  in r17, 33
  ret
readio_skip33:
  cpi r17, 34
  brne readio_skip34
  in r17, 34
  ret
readio_skip34:
  cpi r17, 35
  brne readio_skip35
  in r17, 35
  ret
readio_skip35:
  cpi r17, 36
  brne readio_skip36
  in r17, 36
  ret
readio_skip36:
  cpi r17, 37
  brne readio_skip37
  in r17, 37
  ret
readio_skip37:
  cpi r17, 38
  brne readio_skip38
  in r17, 38
  ret
readio_skip38:
  cpi r17, 39
  brne readio_skip39
  in r17, 39
  ret
readio_skip39:
  cpi r17, 40
  brne readio_skip40
  in r17, 40
  ret
readio_skip40:
  cpi r17, 41
  brne readio_skip41
  in r17, 41
  ret
readio_skip41:
  cpi r17, 42
  brne readio_skip42
  in r17, 42
  ret
readio_skip42:
  cpi r17, 43
  brne readio_skip43
  in r17, 43
  ret
readio_skip43:
  cpi r17, 44
  brne readio_skip44
  in r17, 44
  ret
readio_skip44:
  cpi r17, 45
  brne readio_skip45
  in r17, 45
  ret
readio_skip45:
  cpi r17, 46
  brne readio_skip46
  in r17, 46
  ret
readio_skip46:
  cpi r17, 47
  brne readio_skip47
  in r17, 47
  ret
readio_skip47:
  cpi r17, 48
  brne readio_skip48
  in r17, 48
  ret
readio_skip48:
  cpi r17, 49
  brne readio_skip49
  in r17, 49
  ret
readio_skip49:
  cpi r17, 50
  brne readio_skip50
  in r17, 50
  ret
readio_skip50:
  cpi r17, 51
  brne readio_skip51
  in r17, 51
  ret
readio_skip51:
  cpi r17, 52
  brne readio_skip52
  in r17, 52
  ret
readio_skip52:
  cpi r17, 53
  brne readio_skip53
  in r17, 53
  ret
readio_skip53:
  cpi r17, 54
  brne readio_skip54
  in r17, 54
  ret
readio_skip54:
  cpi r17, 55
  brne readio_skip55
  in r17, 55
  ret
readio_skip55:
  cpi r17, 56
  brne readio_skip56
  in r17, 56
  ret
readio_skip56:
  cpi r17, 57
  brne readio_skip57
  in r17, 57
  ret
readio_skip57:
  cpi r17, 58
  brne readio_skip58
  in r17, 58
  ret
readio_skip58:
  cpi r17, 59
  brne readio_skip59
  in r17, 59
  ret
readio_skip59:
  cpi r17, 60
  brne readio_skip60
  in r17, 60
  ret
readio_skip60:
  cpi r17, 61
  brne readio_skip61
  in r17, 61
  ret
readio_skip61:
  cpi r17, 62
  brne readio_skip62
  in r17, 62
  ret
readio_skip62:
  cpi r17, 63
  brne readio_skip63
  in r17, 63
  ret
readio_skip63:
  ldi r30, (io_range_error*2)&255
  ldi r31, (io_range_error*2)>>8
  rcall send_string
  ret

write_io:
  cpi r17, 0
  brne writeio_skip0
  out 0, r18
  ret
writeio_skip0:
  cpi r17, 1
  brne writeio_skip1
  out 1, r18
  ret
writeio_skip1:
  cpi r17, 2
  brne writeio_skip2
  out 2, r18
  ret
writeio_skip2:
  cpi r17, 3
  brne writeio_skip3
  out 3, r18
  ret
writeio_skip3:
  cpi r17, 4
  brne writeio_skip4
  out 4, r18
  ret
writeio_skip4:
  cpi r17, 5
  brne writeio_skip5
  out 5, r18
  ret
writeio_skip5:
  cpi r17, 6
  brne writeio_skip6
  out 6, r18
  ret
writeio_skip6:
  cpi r17, 7
  brne writeio_skip7
  out 7, r18
  ret
writeio_skip7:
  cpi r17, 8
  brne writeio_skip8
  out 8, r18
  ret
writeio_skip8:
  cpi r17, 9
  brne writeio_skip9
  out 9, r18
  ret
writeio_skip9:
  cpi r17, 10
  brne writeio_skip10
  out 10, r18
  ret
writeio_skip10:
  cpi r17, 11
  brne writeio_skip11
  out 11, r18
  ret
writeio_skip11:
  cpi r17, 12
  brne writeio_skip12
  out 12, r18
  ret
writeio_skip12:
  cpi r17, 13
  brne writeio_skip13
  out 13, r18
  ret
writeio_skip13:
  cpi r17, 14
  brne writeio_skip14
  out 14, r18
  ret
writeio_skip14:
  cpi r17, 15
  brne writeio_skip15
  out 15, r18
  ret
writeio_skip15:
  cpi r17, 16
  brne writeio_skip16
  out 16, r18
  ret
writeio_skip16:
  cpi r17, 17
  brne writeio_skip17
  out 17, r18
  ret
writeio_skip17:
  cpi r17, 18
  brne writeio_skip18
  out 18, r18
  ret
writeio_skip18:
  cpi r17, 19
  brne writeio_skip19
  out 19, r18
  ret
writeio_skip19:
  cpi r17, 20
  brne writeio_skip20
  out 20, r18
  ret
writeio_skip20:
  cpi r17, 21
  brne writeio_skip21
  out 21, r18
  ret
writeio_skip21:
  cpi r17, 22
  brne writeio_skip22
  out 22, r18
  ret
writeio_skip22:
  cpi r17, 23
  brne writeio_skip23
  out 23, r18
  ret
writeio_skip23:
  cpi r17, 24
  brne writeio_skip24
  out 24, r18
  ret
writeio_skip24:
  cpi r17, 25
  brne writeio_skip25
  out 25, r18
  ret
writeio_skip25:
  cpi r17, 26
  brne writeio_skip26
  out 26, r18
  ret
writeio_skip26:
  cpi r17, 27
  brne writeio_skip27
  out 27, r18
  ret
writeio_skip27:
  cpi r17, 28
  brne writeio_skip28
  out 28, r18
  ret
writeio_skip28:
  cpi r17, 29
  brne writeio_skip29
  out 29, r18
  ret
writeio_skip29:
  cpi r17, 30
  brne writeio_skip30
  out 30, r18
  ret
writeio_skip30:
  cpi r17, 31
  brne writeio_skip31
  out 31, r18
  ret
writeio_skip31:
  cpi r17, 32
  brne writeio_skip32
  out 32, r18
  ret
writeio_skip32:
  cpi r17, 33
  brne writeio_skip33
  out 33, r18
  ret
writeio_skip33:
  cpi r17, 34
  brne writeio_skip34
  out 34, r18
  ret
writeio_skip34:
  cpi r17, 35
  brne writeio_skip35
  out 35, r18
  ret
writeio_skip35:
  cpi r17, 36
  brne writeio_skip36
  out 36, r18
  ret
writeio_skip36:
  cpi r17, 37
  brne writeio_skip37
  out 37, r18
  ret
writeio_skip37:
  cpi r17, 38
  brne writeio_skip38
  out 38, r18
  ret
writeio_skip38:
  cpi r17, 39
  brne writeio_skip39
  out 39, r18
  ret
writeio_skip39:
  cpi r17, 40
  brne writeio_skip40
  out 40, r18
  ret
writeio_skip40:
  cpi r17, 41
  brne writeio_skip41
  out 41, r18
  ret
writeio_skip41:
  cpi r17, 42
  brne writeio_skip42
  out 42, r18
  ret
writeio_skip42:
  cpi r17, 43
  brne writeio_skip43
  out 43, r18
  ret
writeio_skip43:
  cpi r17, 44
  brne writeio_skip44
  out 44, r18
  ret
writeio_skip44:
  cpi r17, 45
  brne writeio_skip45
  out 45, r18
  ret
writeio_skip45:
  cpi r17, 46
  brne writeio_skip46
  out 46, r18
  ret
writeio_skip46:
  cpi r17, 47
  brne writeio_skip47
  out 47, r18
  ret
writeio_skip47:
  cpi r17, 48
  brne writeio_skip48
  out 48, r18
  ret
writeio_skip48:
  cpi r17, 49
  brne writeio_skip49
  out 49, r18
  ret
writeio_skip49:
  cpi r17, 50
  brne writeio_skip50
  out 50, r18
  ret
writeio_skip50:
  cpi r17, 51
  brne writeio_skip51
  out 51, r18
  ret
writeio_skip51:
  cpi r17, 52
  brne writeio_skip52
  out 52, r18
  ret
writeio_skip52:
  cpi r17, 53
  brne writeio_skip53
  out 53, r18
  ret
writeio_skip53:
  cpi r17, 54
  brne writeio_skip54
  out 54, r18
  ret
writeio_skip54:
  cpi r17, 55
  brne writeio_skip55
  out 55, r18
  ret
writeio_skip55:
  cpi r17, 56
  brne writeio_skip56
  out 56, r18
  ret
writeio_skip56:
  cpi r17, 57
  brne writeio_skip57
  out 57, r18
  ret
writeio_skip57:
  cpi r17, 58
  brne writeio_skip58
  out 58, r18
  ret
writeio_skip58:
  cpi r17, 59
  brne writeio_skip59
  out 59, r18
  ret
writeio_skip59:
  cpi r17, 60
  brne writeio_skip60
  out 60, r18
  ret
writeio_skip60:
  cpi r17, 61
  brne writeio_skip61
  out 61, r18
  ret
writeio_skip61:
  cpi r17, 62
  brne writeio_skip62
  out 62, r18
  ret
writeio_skip62:
  cpi r17, 63
  brne writeio_skip63
  out 63, r18
  ret
writeio_skip63:
  ldi r30, (io_range_error*2)&255
  ldi r31, (io_range_error*2)>>8
  rcall send_string
  ret

prompt:
.db "\r\ncommand> ",0
syntax_error:
.db "?Syntax Error\r\n",0
overflow_error:
.db "?Overflow Error\r\n",0
notimpl_error:
.db "?Not Implemented Error\r\n",0
io_range_error:
.db "?I/O Address Out Of Range\r\n",0
read_str:
.db "read ",0
write_str:
.db "write ",0
readi_str:
.db "readi ",0
writei_str:
.db "writei ",0
reade_str:
.db "reade ",0
writee_str:
.db "writee ",0
readf_str:
.db "readf ",0
writef_str:
.db "writef ",0
eol_str:
.db "\r\n",0
copyright:
.db "\r\nAtmel Probe for Atmel ATmega168\r\nCopyright 2007 - Michael Kohn\r\nVersion 0.25\r\n",0




