Skip to content

Instantly share code, notes, and snippets.

@ryan-mcclue

ryan-mcclue/functions.asm

Last active October 13, 2022 04:46
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ryan-mcclue/1eb50602ba2d9a491337db34c771de97 to your computer and use it in GitHub Desktop.
Save ryan-mcclue/1eb50602ba2d9a491337db34c771de97 to your computer and use it in GitHub Desktop.
Download ZIP
comp9032 lab3 task3
Raw
functions.asm
.include "m2560def.inc"
.cseg
.org 0x0000
jmp reset
.org 0x0008
jmp int0_isr
int0_isr:
reti
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; NOTE(Ryan): Functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.set CYCLES_PER_300MS=((CPU_HZ / 1000) * 3)
.set DELAY_300MS_COUNTER = CPU_HZ / 1000 / 4
; NOTE(Ryan): To caculate:
; CPU_HZ = 16000000
; CYCLES_PER_X_MS = (CPU_HZ / 1000) * X
; divide loop body, subtract startup
.set MSB_DELAY_VALUE=255
.set MB_DELAY_VALUE=255
.set LSB_DELAY_VALUE=255
.def u24_delay_lsb=r16
.def u24_delay_mb=r17
.def u24_delay_msb=r18
.def u24_delay_lsb_counter=r24
.def u24_delay_mb_counter=r25
.def u24_delay_msb_counter=r21
.def u24_delay_zero_reg=r22
u24_delay:
push u24_delay_lsb
push u24_delay_mb
push u24_delay_msb
push u24_delay_lsb_counter
push u24_delay_mb_counter
push u24_delay_msb_counter
push u24_delay_zero_reg
ldi u24_delay_lsb, LSB_DELAY_VALUE
ldi u24_delay_mb, MB_DELAY_VALUE
ldi u24_delay_msb, MSB_DELAY_VALUE
clr u24_delay_lsb_counter
clr u24_delay_mb_counter
clr u24_delay_msb_counter
clr u24_delay_zero_reg
delay_loop:
cp u24_delay_lsb_counter, u24_delay_lsb
cpc u24_delay_mb_counter, u24_delay_mb
cpc u24_delay_msb_counter, u24_delay_msb
brsh delay_done
adiw u24_delay_mb_counter:u24_delay_lsb_counter, 1
adc u24_delay_msb_counter, u24_delay_zero_reg
rjmp delay_loop
delay_done:
pop u24_delay_zero_reg
pop u24_delay_msb_counter
pop u24_delay_mb_counter
pop u24_delay_lsb_counter
pop u24_delay_msb
pop u24_delay_mb
pop u24_delay_lsb
ret
.undef u24_delay_lsb
.undef u24_delay_mb
.undef u24_delay_msb
.undef u24_delay_lsb_counter
.undef u24_delay_mb_counter
.undef u24_delay_msb_counter
.undef u24_delay_zero_reg
; Have this 8kb up
.org 0x2000
reset:
.set button_debounce_counter=10000
.def led_zero_pattern=r1
.def led_pattern0=r2
.def led_pattern1=r3
.def led_pattern2=r4
.def cur_led_pattern=r5
.def pattern_index=r20
.def pattern_button_is_down=r21
.def pattern_button_was_down=r22
start:
ldi r16, 0
mov led_zero_pattern, r16
ldi r16, 0x12
mov led_pattern0, r16
ldi r16, 0x44
mov led_pattern1, r16
ldi r16, 0x08
mov led_pattern2, r16
; NOTE(Ryan): Buttons
clr r17
sbi DDRD, 0
sbi PORTD, 0
; NOTE(Ryan): LEDS
ser r16
out DDRC, r16
out PORTD, r16
ldi pattern_index, 0
mov cur_led_pattern, led_zero_pattern
loop:
out PINC, cur_led_pattern
sbis PIND, 0
rjmp pattern_button_debounce
ldi pattern_button_is_down, 0
rjmp pattern_button_continue
pattern_button_debounce:
ldi r24, LOW(button_debounce_counter)
ldi r25, HIGH(button_debounce_counter)
pattern_button_debounce_delay:
sbiw r25:r24, 1
brne pattern_button_debounce_delay
sbis PIND, PD0
ldi pattern_button_is_down, 1
pattern_button_continue:
cpi pattern_button_is_down, 1
brsh set_pattern_button_was_down
cpi pattern_button_was_down, 1
breq pattern_button_was_pressed
rjmp pattern_button_finished
pattern_button_was_pressed:
ldi pattern_button_was_down, 0
cpi pattern_index, 0
breq set_led_pattern0
cpi pattern_index, 1
breq set_led_pattern1
cpi pattern_index, 2
breq set_led_pattern2
set_led_pattern0:
ldi pattern_index, 1
mov cur_led_pattern, led_pattern0
rjmp pattern_button_finished
set_led_pattern1:
ldi pattern_index, 2
mov cur_led_pattern, led_pattern1
rjmp pattern_button_finished
set_led_pattern2:
ldi pattern_index, 0
mov cur_led_pattern, led_pattern2
rjmp pattern_button_finished
set_pattern_button_was_down:
ldi pattern_button_was_down, 1
pattern_button_finished:
rjmp loop
Raw
hacky.asm
;
; LAB3_Task1.asm
;
; Created: 2018/9/4 15:28:16
; FUNCTION: Implement a LED control system to repeatedly display a sequence of three patterns,
; And the display will be halted when the user presses a button.
.include"m2560def.inc"
.def a = r16
.def count1 = r18 ; 0xFF
.def count2 = r19 ; 0x69
.def count3 = r20 ; 0x18,1599999
.def M1 = r24
.def M2 = r25
.macro OneSecondDelay
ldi count1, 0xFF ; 1, load 0xff to r18
ldi count2, 0x69 ; 1, load 0x69 to r19
ldi count3, 0x18 ; 1, load 0x18 to r20
clr r16 ; 1
clr r24 ; 1
clr r25 ; 1
clr r26 ; 1
loop:
cp M1,count1 ; 1 ,compare M1 with count1
cpc M2,count2 ; 1 ,compare M2 with count2 with carry
cpc r26,count3 ; 1 ,compare r26 with count3 with carry
brsh done ; 1/2
adiw M2:M1,1 ; 2, add immediate to word
adc r26,a ; 1, add with carry
nop ; 1, do nothing
rjmp loop ; 2
done:
.endmacro
;main
ldi r21, 0x3
cbi DDRD,0 ; set Port D bit 0 for input
out PORTD, r21 ; set Port D bit 0 to 1
ser r21 ; set register
out DDRC,r21 ; set Port C for output
out PORTC,r21 ; active the pull up
P1:
ldi r21, 0x44 ; write the pattern£¨01000100£©
out PORTC,r21 ; output the pattern1
switch1:
sbic PIND, 0
rjmp switch1 ; check if that bit is clear ; if yes skip the next instruction
OneSecondDelay
sbis PIND, 0
rjmp switch1
rjmp P2 ; rjmp to switch1
P2:
ldi r21,0x22 ; write the pattern£¨00100010£©
out PORTC,r21 ; output the pattern2
; delay
switch2:
sbic PIND, 0
rjmp switch2 ; check if that bit is clear ; if yes skip the next instruction
OneSecondDelay
sbis PIND, 0
rjmp switch2
rjmp P3 ; rjmp to switch2
P3:
; write the pattern£¨11111111£©
ldi r21, 0xff ; write the pattern£¨01000100£©
out PORTC,r21 ; output the pattern3
; delay
switch3:
sbic PIND, 0
rjmp switch3 ; check if that bit is clear ; if yes skip the next instruction
OneSecondDelay
sbis PIND, 0
rjmp switch3
rjmp P1_1
P1_1:
ldi r21, 0x44 ; write the pattern£¨01000100£©
out PORTC,r21 ; output the pattern1
OneSecondDelay ; delay
switch1_1:
sbic PIND,1 ; check if that bit is clear ; if yes skip the next instruction
rjmp P2_1 ; rjmp to p2
rjmp P1 ; rjmp to switch1
P2_1:
ldi r21,0x22 ; write the pattern£¨00100010£©
out PORTC,r21 ; output the pattern2
OneSecondDelay ; delay
switch2_1:
sbic PIND,1 ; check if that bit is clear ; if yes skip the next instruction
rjmp P3_1 ; rjmp to p3
rjmp P1 ; rjmp to switch2
P3_1:
ldi r21,0xFF ; write the pattern£¨11111111£©
out PORTC,r21 ; output the pattern3
OneSecondDelay ; delay
switch3_1:
sbic PIND,1 ; check if that bit is clear ; if yes skip the next instruction
rjmp P1_1 ; rjmp to p1
rjmp P1 ; rjmp to switch3
Raw
task3.asm
.include "m2560def.inc"
.set button_debounce_counter=10000
.def led_pattern0=r2
.def led_pattern1=r3
.def led_pattern2=r4
.def next_pattern=r20
.def pattern_button_is_down=r21
.def pattern_button_was_down=r22
.def pattern_button_press=r23
start:
ldi r16, 0b11111111
mov led_pattern0, r16
ldi r16, 0b11111110
mov led_pattern1, r16
ldi r16, 0b11111100
mov led_pattern2, r16
; NOTE(Ryan): LEDS
ser r16
out DDRC, r16
; NOTE(Ryan): Buttons
clr r17
out DDRD, r17
out PORTD, r17
ldi next_pattern, 0
loop:
in r18, PIND
; invert, as 0 is down
com r18
andi r18, 0b00000001
cpi r18, 1
brsh pattern_button_debounce
ldi pattern_button_is_down, 0
rjmp pattern_button_continue
pattern_button_debounce:
ldi r24, LOW(button_debounce_counter)
ldi r25, HIGH(button_debounce_counter)
pattern_button_debounce_delay:
sbiw r25:r24, 1
brne pattern_button_debounce_delay
sbis PIND, PD0
ldi pattern_button_is_down, 1
pattern_button_continue:
cpi pattern_button_is_down, 1
brsh set_pattern_button_was_down
cpi pattern_button_was_down, 1
breq pattern_button_was_pressed
rjmp pattern_button_finished
pattern_button_was_pressed:
ldi pattern_button_was_down, 0
cpi next_pattern, 0
breq set_pattern0
cpi next_pattern, 1
breq set_pattern1
cpi next_pattern, 2
breq set_pattern2
rjmp pattern_button_finished
set_pattern0:
out PINC, led_pattern0
ldi next_pattern, 1
rjmp pattern_button_finished
set_pattern1:
out PINC, led_pattern1
ldi next_pattern, 2
rjmp pattern_button_finished
set_pattern2:
out PINC, led_pattern2
ldi next_pattern, 0
rjmp pattern_button_finished
set_pattern_button_was_down:
ldi pattern_button_was_down, 1
pattern_button_finished:
rjmp loop
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment