;****************************************************************************** ; * ; Filename: xmasR.asm * ; Date: * ; File Version: * ; * ; Author: Jim Gurley * ; Company: * ; * ; Version 2 protocol * ;****************************************************************************** radix dec LIST P=18F2620 ;directive to define processor #include ;processor specific variable definitions mymask equ 0x01 ;mask for this instance ;****************************************************************************** ;Configuration bits ; Oscillator Selection: CONFIG OSC = HSPLL CONFIG WDT = OFF ;Disabled CONFIG LVP = OFF ;Disabled ;****************************************************************************** ;Variable definitions ; These variables are only needed if low priority interrupts are used. ; More variables may be needed to store other special function registers used ; in the interrupt routines. ; FSR2 for receiver message pointer ; FSR1 for parser ; FSR0 for auto table CBLOCK 0x000 ; global variables temp temp1 temp2 temp3 cur_mask cur_adr cur_bg cur_r cur_inten current_cmd rom_index auto_index flags ; b0 - transmitter in use ; b1 - tick flag ; b2 - macro skip flag ; b3 - ; b4 - message received ; b5 - march tick ; b6 - escaping mode ; b0 - run/_halt ; b1 - ram/_prom ; b2 - march/_free ptr_hi ptr_lo dptr_lo ;stack for call dptr_hi dptr_lo2 ;stack for call dptr_hi2 r_width r_bits r_data r_pass ;bytes to let through receiver parse filter msg_bytes auto_adr auto_inten auto_bg auto_r auto_mask auto_bcds adrl adrh pass fail rd_ptrl ;msg buffer read pointer rd_ptrh pushed_cur_adr ;one deep stack for PUSH/SWAP pushed_cur_bg pushed_cur_mask pushed_cur_r back_bg ;background color back_r ; interrupt variable rdata1 rdata2 r_bytes iflags ; b0 write address ; b1 write ram temp_FSR0L temp_FSR0H ram_bytes r_aptrl ;write ram address pointers r_aptrh count ; bit counter state ; 0=idle ; 1=set ; 2=clear ; 3=f(data) ; 4=stop ; b5 - receiver active ; b6 - receiver active and SYN received mask sr0 ; xxadr sr1 ;inten sr2 ;bg sr3 ;r status_temp wreg_temp itemp ENDC CBLOCK 0x100 auto_table: 0x100 ;table of auto decay values (4 bytes per LED) ; byte0 b7:active, b6:b4=blink cnt, b3-0:colorwheel index ; byte1 inten ; byte2 blue+green ; byte3 red*16|bcds (blink,colorwheel,decay,slow) ENDC CBLOCK 0x200 r_buf: 0x200 ; receiver buffer ENDC CBLOCK 0x400 ;sequence storage d_buf: ENDC CBLOCK 0x700 debug: ENDC ; program constants xmt_count equ .27 ;bits in serial message hun_msec equ .50 refresh_rate equ 0x61a8 ;ccp1 value for 10hz interrupt with 8x prescaler ;****************************************************************************** ;EEPROM data ; Data to be programmed into the Data EEPROM is defined here ORG 0xf00000 ;******************************** start of initialization code ;****************************************************************************** ;High priority interrupt vector ; This code will start executing ********************************************** ;Reset vector ; This code will start executing when a reset occurs. ORG 0x0000 bra init ORG 0x0008 bra hi_int ;go to high priority interrupt routine ORG 0x0018 bra low_int ;special dispatch code needs to be in first page of memory dispatch: addwf PCL bra op0x bra op0x bra op0x bra op0x bra op4x bra op4x bra op4x bra op4x bra op8x bra op8x bra opax bra opbx bra opcx bra opdx bra opex bra opfx opcx: rlncf current_cmd,w andlw 0x1e addwf PCL bra opc0 bra opc1 bra opc2 bra opc3 bra opc4 bra opc5 bra opc6 bra opc7 bra opc8 bra opc9 bra opca bra opcb bra opcc bra opcd bra opce bra opcf r_dispatch: addwf PCL bra ra1 ;8x bra ra1 ;9x bra ra1 ;ax bra ra1 ;bx bra ra1 ;cx bra rdex ;dx bra rdex ;ex rfx: rlncf r_data,w andlw 0x1e addwf PCL bra r_f0 bra r_f1 bra r_f2 bra r_f3 bra r_f4 bra r_f5 bra ra1 ;reserved for Write ROM bra r_f7 get_auto_bg: addwf PCL retlw 0xf0 retlw 0xc8 retlw 0x8f retlw 0x2f retlw 0x0f retlw 0x08 retlw 0x08 retlw 0x04 retlw 0x00 retlw 0x80 retlw 0xc0 retlw 0xe0 get_auto_r: addwf PCL retlw 0x00 retlw 0x00 retlw 0x00 retlw 0x00 retlw 0x00 retlw 0x80 retlw 0xf0 retlw 0xf0 retlw 0xf0 retlw 0xe0 retlw 0x80 retlw 0x40 hi_dispatch: addwf PCL bra s0 bra s1 bra s2 bra s3 bra s4 bra s5 ORG 0x100 ;****************************************************************************** ; hi priority interrupt deals with LED output data ; state maching 0 - idle, goto 1 if Flag ; 1 - set data (start bit or 3rd phase) ; 2 - clr data, advance or goto 4 if done ; 3 - data=f(data), goto 1 ; 4 - stop bit ; 5 - stop bit hi_int: btg LATC,1 bcf PIR1,1 ;clear interrupt flag rlncf state,w bra hi_dispatch s0: bcf LATC,6 btfsc flags,0 incf state retfie FAST s1: bsf LATC,6 incf state retfie FAST s2: bcf LATC,6 dcfsnz count incf state incf state retfie FAST s3: btfss sr0,5 bsf LATC,6 rlcf sr3 rlcf sr2 rlcf sr1 rlcf sr0 bcf STATUS,0 rrcf state retfie FAST s4: incf state retfie FAST s5: clrf state movlw xmt_count movwf count bcf flags,0 retfie FAST ;Low priority interrupt vector and routine ; This code will start executing when a low priority interrupt occurs. ; This code can be removed if low priority interrupts are not used. ; Timer interrupts for realtime and incoming FSK data low_int: ; movff BSR,bsr_temp btfss INTCON3,0 ;INT1 interrupt bra timer_int ;no movff STATUS,status_temp movwf wreg_temp bcf INTCON3,0 ;clear INT1 flag movff TMR1H,r_width ;get high byte of counter ;debug pulse widths ; movff FSR0L,temp_FSR0L ;borrow pointer ; movff FSR0H,temp_FSR0H ; movlw high debug ; movwf FSR0H ; clrf FSR0L ; movf r_width,w ; incf PLUSW0 ;record widths seen, clamp at 255 ; bnz debug1 ; decf PLUSW0 ;debug1: movff temp_FSR0L,FSR0L ;return pointer ; movff temp_FSR0H,FSR0H ; end of debug clrf TMR1L ;clear timer1 clrf TMR1H btfsc iflags,4 ;receiver active? bra r_active movlw .20 ;24 bad data! bra r_exit r_firstSYN: btfsc iflags,6 ;second SYN already? bra r_good movlw 0x96 ;SYN character? xorwf r_data,w bnz r_a1 bsf iflags,6 ;set 2nd SYN bra r_exit r_good: movf ram_bytes bnz r_write movf r_bytes ;first byte of packet? bnz ra1 incf r_bytes btfss r_data,7 ;>0x80? bra ra1 swapf r_data,w andlw 0x07 rlncf WREG bra r_dispatch ;dispatch on high nibble rdex: movlw 0x1f ;start in ROM andwf r_data,w btg WREG,4 ;make up for bass-ackwards bit movwf rom_index movlw 4 movwf mode bra r_setm r_f0: movlw 6 ;start from RAM movwf mode r_setm: bsf flags,4 ;set alert bit bra r_exit r_f1 bsf flags,5 ;set marching tick bra r_exit r_f2: bsf mode,0 ;halt bra r_setm r_f3: clrf mode bra r_setm r_f4: bsf iflags,0 ;set write adr bra r_exit r_f5: bsf iflags,1 ;set wrtie ram bra r_exit r_f7: bsf iflags,7 ;link test bcf iflags,4 ;ignore dyte stream bra r_exit ra1: btfsc iflags,0 bra r_adr btfsc iflags,1 bra r_ram movff r_data,POSTINC2 ;write data movlw high r_buf btfsc FSR2H,2 movwf FSR2H bra r_exit r_end bcf iflags,4 ;clear active movf r_bits ;check for fractional byte bnz r_error bra r_exit r_error: bcf iflags,4 ;clear active bcf INTCON3,3 ;turn off receiver for a tick bra r_exit r_adr: btfss iflags,2 ;got first byte yet? bra r_adr1 ;no movff r_data,r_aptrh bcf iflags,2 bcf iflags,0 movlw low d_buf addwf r_aptrl movlw high d_buf addwfc r_aptrh bra r_exit r_adr1: movff r_data,r_aptrl ;load first byte bsf iflags,2 bra r_exit r_ram: movff r_data,ram_bytes ;load byte count bcf iflags,1 bra r_exit ; write RAM r_write:btfsc iflags,3 ;escape in process? bra r_w2 movlw 0x33 ;look for escape character xorwf r_data,w bnz r_w1 bsf iflags,3 bra r_exit r_w1: movff FSR0L,temp_FSR0L ;borrow pointer movff FSR0H,temp_FSR0H movff r_aptrl,FSR0L movff r_aptrh,FSR0H movff r_data,POSTINC0 movff FSR0L,r_aptrl movff FSR0H,r_aptrh decf ram_bytes movff temp_FSR0L,FSR0L ;return pointer movff temp_FSR0H,FSR0H bra r_exit r_w2: movlw 0x33 ;escape character substitution btfsc r_data,0 movlw 0x96 movwf r_data bcf iflags,3 bra r_w1 timer_int: bcf flags,1 ;clear flag btg LATC,0 bcf INTCON,2 ;clear interrupt flag bsf INTCON3,3 ;turn receiver back on ; movff bsr_temp,BSR retfie ;****************************************************************************** ;Start of main program ; The main program code is placed here. ; ;register initialization init_table: ; db low OSCCON,0x70 db low TRISA,0x00 db low TRISB,2 ;unused outputs db low TRISC,0 db low PORTB,0 db low T0CON,0x82 ;Timer 0 is real time clock, prescale=1:8 db low T1CON,0x01 ;Timer 1 on, /1, 8bit r/w mode for receiver db low T2CON,0x04 ;1:1 pre/post scale, ON for LED output timing db low PR2,.108 ;10 usec interrupt for timer 2 db low RCON,0x80 ;enable priorities db low PIE1,2 ;Timer 2 interrupt enable db low PIE2,0 db low IPR1,0x02 ;timer2 is high priority db low IPR2,0 db low FSR0H,2 ;load indirect pointer for decay table db low INTCON2,0x30 ;INT1 on rising edge db low INTCON3,0x08 ;INT1 enabled, low priority ; db low INTCON3,0x0 ;INT1 enabled, low priority db low TMR1L,0 ;clear timer 1 db low TMR1H,0 db low ADCON1,0x0f db low FSR2L,low r_buf ;initialize WRITE pointer db low FSR2H,high r_buf db low INTCON,0xe0 ;this should be last!!! db 0 ;end of list ; power-on reset starts here ; init: clrf FSR1L ;clear ram (0 to 7ff) clrf FSR1H init1: clrf POSTINC1 btfss FSR1H,3 bra init1 clrf TBLPTRU movlw high init_table movwf TBLPTRH movlw low init_table movwf TBLPTRL movlw 0x0f movwf FSR1H init_loop: tblrd*+ movf TABLAT,0 ;read register bz init_done ;zero is end of list movwf FSR1L tblrd*+ movff TABLAT,INDF1 bra init_loop init_done: movlw low r_buf ;initialize READ pointer movwf rd_ptrl movlw high r_buf movwf rd_ptrh, movlw xmt_count movwf count ; ennumerate LEDS movlw 2 call wait ;delay while LEDs power up setf mask ;enumerate all strings the same movlw .50 movwf temp clrf temp1 enum_wait: btfsc flags,0 ;transmitter busy? bra enum_wait movff temp1,sr0 bsf flags,0 ;start transmitter incf temp1 decfsz temp bra enum_wait ; ; *** main code goes here *** ; main: bcf flags,4 ;clear alert bit btfsc mode,0 ;am I halted? bra parse btfss mode,1 bra run_rom movlw low d_buf ;running out of RAM movwf FSR1L movlw high d_buf movwf FSR1H bra parse run_rom: rlncf rom_index,w addlw low rom_table movwf TBLPTRL movlw high rom_table movwf TBLPTRH bnc rr1 incf TBLPTRH rr1: tblrd*+ movf TABLAT,w tblrd*+ movwf TBLPTRL movff TABLAT,TBLPTRH bnz parse movf TBLPTRL bnz parse ; bra main ;got a command to run a non-existent ROM seqence mloop: btfsc mode,1 bra main ;running from RAM btfsc mode,2 ;running free? bra main incf rom_index btfsc rom_index,5 clrf rom_index ;wrap at 31 rlncf rom_index,w addlw low rom_table movwf TBLPTRL movlw high rom_table bnc mloop1 incf WREG mloop1: movwf TBLPTRH tblrd*+ ; try another one if empty movf TABLAT bnz main tblrd*+ movf TABLAT bnz main bra mloop parse: btfsc flags,4 ;check for message bra main call fetch ;get command movwf current_cmd swapf WREG andlw 0x0f rlncf WREG bra dispatch ;dispatch to corrent opcode ; fetch next instruction byte ;**********still need to fix fetch for direct commands fetch: btfsc mode,0 ;halted? bra fetch_direct btfss mode,1 ;where is data bra fetch_rom fetch_ram: movf POSTINC1,w return fetch_rom: tblrd*+ movf TABLAT,w return fetch_direct: movf rd_ptrl,w cpfseq FSR2L bra got_data movf rd_ptrh,w cpfseq FSR2H bra got_data btfss flags,4 bra fetch_direct bra main got_data: movff rd_ptrl,FSR1L movff rd_ptrh,FSR1H movff POSTINC1,temp ;fetch operand movlw high r_buf btfsc FSR1H,2 movwf FSR1H ;wrap buffer at 400 movff FSR1L,rd_ptrl movff FSR1H,rd_ptrh btfsc flags,6 ;already escaping? bra g_d2 movlw 0x96 btfss temp,0 movlw 0x33 bra g_d1 g_d2: movlw 0x33 xorwf temp,w ;escape character? bnz g_d1 bsf flags,6 ;set escaping bit bra fetch_direct g_d1 movf temp,w return ; Long Write and Write commands op0x: op4x: movff current_cmd,cur_adr movlw 0xcc movwf cur_inten btfsc cur_adr,6 bra op4x1 call fetch movwf cur_bg call fetch movwf cur_r op4x1: call fetch movwf cur_mask bcf cur_adr,6 ;clear extra bit from op4x call write_led bra parse ; Delay Commands op8x: movf current_cmd,w ;wait x1/20 second andlw 0x3f bz parse ;0 delay is NOP btfsc mode,2 ;lockstep? bra op8x_locked op8x1: bsf flags,1 ;ask for tick op8x2: btfsc flags,1 ;check for acknowledge bra op8x3 decfsz WREG bra op8x1 op8x_exit: call exec_auto bra parse op8x3: btfsc flags,4 ;alert bra main btfss mode,0 ;halted bra op8x2 bra parse op8x_locked: btfss flags,5 bra ol1 bcf flags,5 ;wait complete dcfsnz WREG bra op8x_exit ol1: btfss flags,4 ;alert bit? bra op8x_locked bra main ; Short Write command opax: bcf flags,2 ;clear flag movf current_cmd,w btfss WREG,3 ;mask shift? bra opax1 btfss WREG,2 ;left or right bra opa8 rlncf cur_mask bra opax1 opa8: rrncf cur_mask opax1: btfss WREG,1 ;address change? bra opax_done btfss WREG,0 ;up or down? bra opa2 movlw .49 cpfseq cur_adr ;=49? incf cur_adr cpfslt cur_adr bsf flags,2 ;set branch flag bra opax_done opa2: decf cur_adr bc opa21 clrf cur_adr ;don't increment below zero opa21: bnz opax_done ;check if zero bsf flags,2 ; and set branch flag opax_done: call write_led goto parse ; RGB inc/dec commands opbx: bcf flags,2 ;clear skip flag btfsc current_cmd,3 bra opb0 btfsc current_cmd,0 call dec_red btfsc current_cmd,1 call dec_green btfsc current_cmd,2 call dec_blue bra parse opb0: btfsc current_cmd,0 call inc_red btfsc current_cmd,1 call inc_green btfsc current_cmd,2 call inc_blue swapf cur_bg,w ;check if andlw 0x0f ;R+G+B >= 36 movwf temp1 movf cur_bg,w andlw 0x0f addwf temp1 swapf cur_r,w andlw 0x0f addwf temp1,w sublw .36 bc opb1 bsf flags,2 ; max value hit movlw 0xdd ; force color to DDD movwf cur_bg ; if ceiling hit movf cur_r,w andlw 0x0f iorlw 0xd0 movwf cur_r bra parse opb1: goto parse ; JMP command opc0: call fetch movwf adrl call fetch movwf adrh call move_ptr bra parse ;fix pointer after call/jmp move_ptr: movlw 0xfd ;-3 addwf adrl ;decrement new address by 3 btfss STATUS,0 ;carry? decf adrh btfss mode,1 bra rom_ptr ram_ptr: movf adrl,w addwf FSR1L movf adrh,w addwfc FSR1H return rom_ptr: movf adrl,w addwf TBLPTRL movf adrh,w addwfc TBLPTRH return ; JMPC command opc1: call fetch movwf adrl call fetch movwf adrh btfsc flags,2 bra parse call move_ptr bra parse ;CALLsubroutine opc2: call fetch movwf adrl call fetch movwf adrh movff dptr_lo,dptr_lo2 ;two deep stack movff dptr_hi,dptr_hi2 btfss mode,1 bra save_rom_ptr save_ram_ptr: movff FSR1L,dptr_lo movff FSR1H,dptr_hi bra opc21 save_rom_ptr: movff TBLPTRL,dptr_lo ;save return movff TBLPTRH,dptr_hi opc21: call move_ptr bra parse ;return opc3: btfss mode,1 bra rtn_rom_ptr movff dptr_lo,FSR1L movff dptr_hi,FSR1H movff dptr_lo2,dptr_lo ;two deep stack movff dptr_hi2,dptr_hi bra parse rtn_rom_ptr: movff dptr_lo,TBLPTRL ;return movff dptr_hi,TBLPTRH bra parse opc4: bcf cur_r,1 ;clear decay bit bra parse opc5: bsf cur_r,1 ;set decay bit bra parse opc6: bcf cur_r,2 ;clear colorwheel bit bra parse opc7: bsf cur_r,2 ;clear colorwheel bit bra parse opc8: setf cur_mask ;erase everything clrf cur_adr movff back_bg,cur_bg movff back_r,cur_r ;then fall into FLOOD opc9: clrf temp ;FLOOD movlw .50 movwf temp1 opc91: movff temp,cur_adr call write_led incf temp decfsz temp1 bra opc91 bra parse opca: movff cur_adr,pushed_cur_adr ;Push movff cur_bg,pushed_cur_bg movff cur_mask,pushed_cur_mask movff cur_r,pushed_cur_r bra parse opcb: movf pushed_cur_adr,w ;SWAP movff cur_adr,pushed_cur_adr movwf cur_adr movf pushed_cur_bg,w movff cur_bg,pushed_cur_bg movwf cur_bg movf pushed_cur_r,w movff cur_r,pushed_cur_r movwf cur_r movf pushed_cur_mask,w movff cur_mask,pushed_cur_mask movwf cur_mask bra parse opcc: bcf flags,2 ;Clear branch flad bra parse opcd: call clear_auto_buffer bra parse clear_auto_buffer: movlw high auto_table ;clear auto table movwf FSR0H clrf FSR0L cab1: clrf POSTINC0 btfss FSR0H,2 bra cab1 return opce: bra parse ;(spare) opcf: movlw .10 ;end of program call wait bra mloop opdx: ;shouldn't see these commands opex: opfx: bra parse ; Write to LED, checking auto bits write_led: movlw mymask andwf cur_mask,w bz xmit_exit movlw 62 xorwf cur_adr,w bnz wr1 movff cur_bg,back_bg ;set background color movff cur_r,back_r wr1: call insert_auto wr2: btfsc flags,0 ;wait for transmitter bra wr2 movff cur_adr,sr0 movff cur_inten,sr1 movff cur_bg,sr2 movff cur_r,sr3 ; movff cur_mask,mask ;not on single channel hardware bsf flags,0 ;start transmitter xmit_exit: return inc_red: movlw 0x10 addwf cur_r bc ir0 return ir0: subwf cur_r ;was already 15 bsf flags,2 ;set skip flag return inc_blue: movlw 0x10 addwf cur_bg bc ib0 return ib0: subwf cur_bg ;was already 15 bsf flags,2 ;set skip flag return inc_green: movlw 0x0f andwf cur_bg,w xorlw 0x0f bz ig0 incf cur_bg return ig0: bsf flags,2 return dec_red: movlw 0xf0 andwf cur_r,w bz dr0 movlw 0x10 subwf cur_r return dr0: bsf flags,2 return dec_blue: movlw 0xf0 andwf cur_bg,w bz db0 movlw 0x10 subwf cur_bg return db0: bsf flags,2 return dec_green: movlw 0x0f andwf cur_bg,w bz dg0 decf cur_bg return dg0: bsf flags,2 return wait: andlw 0x3f wloop: bsf flags,1 ;ask for tick wloopa: btfsc flags,1 ;check for acknowledge bra wloopa decfsz WREG bra wloop return ; update current value into the decay table insert_auto: movf cur_adr,w mullw 4 movlw high auto_table movwf FSR0H movf PRODH,w addwf FSR0H movff PRODL,FSR0L movf cur_r,w andlw 0x0f ; bz ia0 movlw 0x80 ia0: movwf POSTINC0 ;set "in use" and clear color wheel index, blink count movff cur_inten,POSTINC0 movff cur_bg,POSTINC0 movff cur_r,POSTINC0 return ; execute all the decay entries exec_auto: clrf auto_index ea_loop:btfsc flags,4 bra main movf auto_index,w mullw 4 movlw high auto_table movwf FSR0H movf PRODH,w addwf FSR0H movff PRODL,FSR0L btfsc INDF0,7 ;check if occupied bra ea_exec ea_loop1: incf auto_index btfss auto_index,6 bra ea_loop return ea_exec:movlw 1 movff PLUSW0,auto_inten movlw 2 movff PLUSW0,auto_bg movlw 3 movff PLUSW0,auto_r movff PLUSW0,auto_bcds movff auto_index,auto_adr setf auto_mask btfsc auto_bcds,3 ;blinking? bra auto_blink ea5: btfsc auto_bcds,2 ;color wheeling? bra auto_wheel auto_int: btfsc auto_bcds,0 ;momentary bra auto_momen btfss auto_bcds,1 ;decaying also? bra ea_loop1 movf auto_inten,w xorlw 0xcc ;initial value? bnz a_i_1 setf auto_inten ;if CC, change to FF a_i_1: bcf STATUS,0 ;clear CARRY rrcf auto_inten bnz ea4 clrf INDF0 ;empty buffer cell movff back_bg,auto_bg movff back_r,auto_r movlw 0xcc movwf auto_inten ea4: movlw 1 movff auto_inten,PLUSW0 ;store new inten call wr_auto_led bra ea_loop1 auto_momen: clrf INDF0 movff back_bg,auto_bg movff back_r,auto_r call wr_auto_led bra ea_loop1 auto_wheel: movf INDF0,w andlw 0x0f rlncf WREG call get_auto_bg movwf auto_bg movf INDF0,w andlw 0x0f rlncf WREG call get_auto_r movwf auto_r call wr_auto_led incf INDF0 movf INDF0,w andlw 0x0f xorlw 0x0c ;=12? bnz ea_loop1 movf INDF0,w andlw 0xf0 movwf INDF0 bra auto_int auto_blink: movf INDF0,w addlw 0x10 ;increment blink counter movwf INDF0 btfss WREG,7 ;overflow? bra blink_wrap movwf INDF0 andlw 0x30 ;=4? bz blink_off bra ea_loop1 blink_off: movff back_bg,auto_bg movff back_r,auto_r call wr_auto_led bra ea_loop1 blink_wrap: call wr_auto_led bsf INDF0,7 ;fix wrapped bit bra ea5 wr_auto_led: btfsc flags,0 ;wait for transmitter bra wr_auto_led movff auto_adr,sr0 movff auto_inten,sr1 movff auto_bg,sr2 movff auto_r,sr3 movff auto_mask,mask bsf flags,0 ;start transmitter return rom_table: dw pong ; dw spirals ; dw wheel ; dw chasing ; dw colors ; dw file3 ; dw file4 ; dw file5 ; dw file6 ; dw file7 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 dw 0 ; ORG rom_table+.64 #include ../sequences/pong.inc ;#include spirals.inc ;#include wheel.inc ;#include chasing.inc ;#include colors.inc END