; ; SX macro library ; Developed by Karl Lunt, May 1999 ; translated from PIC to SX by Nikolai Golovchenko [golovchenko at mail.ru] ; messg "Karl Lunt's PIC macro library, version 1.0" ; ; This library provides macros for program structures such ; as FOR-NEXT, REPEAT-ALWAYS, REPEAT-UNTIL, and others. ; ; To incorporate this library in your PIC assembler program, ; add the following INCLUDE statement immediately after the ; INCLUDE statement that adds the Microchip equates for your ; specific processor: ; ; include "macros.asm" ; ; For example, if you are developing code for the 12c672, ; you would use equates similar to: ; ; include ".\p12c672.inc" ; include ".\macros.asm" ; ; ; Version 1.0 29 May 1999 ; Initial release. Includes WAITWHILE, WAITUNTIL, and POLL-ENDPOLL. ; Changed mov W, to movf ; in NEXTL macro on older PICs, since that macro uses the addlw ; instruction. ; ; ; Declare some variables used by the macro library. ; variable _forknt=0 variable _nxtknt=0 variable _rptknt=0 variable _alwknt=0 variable _untknt=0 variable _seltot=0 variable _selknt=0 variable _castot=0 variable _casknt=0 variable _waitk=0 variable _pollk=0 variable _pollt=0 ; ; Define the BEQ (branch-if-equal) ; ; Syntax: ; beq label ; ; The BEQ macro tests the current state of the Z-bit. It ; does not alter W or any registers. ; beq macro addr snb Z jmp addr endm ; ; BNE (branch-if-not-equal) ; ; Syntax: ; bne label ; ; The BNE macro tests the current state of the Z-bit. It ; does not alter W or any registers. ; bne macro addr sb Z jmp addr endm ; ; FOR (start of FOR-NEXT loop) ; ; Syntax: ; for var,begl,endl ; ; The FOR macro starts a FOR-NEXT loop. The arguments are: ; var is a RAM variable used as the loop index, ; begl is a literal value used as the initial index value, ; endl is a literal value used as the ending index value. ; ; Control will run through the FOR-NEXT loop until the value ; in var EQUALS the endl literal value; the value is tested ; at the top of the loop. At this point, control exits the ; loop at the corresponding NEXT macro. ; ; This macro destroys the contents of the W register. ; ; You may terminate a FOR loop with NEXT, NEXTL, or NEXTF. ; for macro var,begl,endl mov W, #begl mov var, W _for#v(_forknt) mov W, #endl mov W, var-w ; mov W, var ;*** WARNING: Manual replacement required for "SUBLW k" instruction (w = k - w). Check if previous instruction is a skip instruction. ; sublw endl beq _next#v(_forknt) _forknt set _forknt+1 _nxtknt set _forknt endm ; ; FORF (start of FORF-NEXT loop) ; ; Syntax: ; forf var,begl,endf ; ; The FORF macro starts a FORF-NEXT loop. The arguments are: ; var is a RAM variable used as the loop index, ; begl is a literal value used as the initial index value, ; endf is a flag or RAM variable used as the ending index ; value. ; ; Control will run through the FORF-NEXT loop until the value ; in var EQUALS the endf variable value; the value is tested ; at the top of the loop. At this point, control exits the ; loop at the corresponding NEXT macro. ; ; This macro destroys the contents of the W register. ; ; You may terminate a FORF loop with NEXT, NEXTL, or NEXTF. ; forf macro var,begl,endf mov W, #begl mov var, W _for#v(_forknt) mov W, var sub endf, W beq _next#v(_forknt) _forknt set _forknt+1 _nxtknt set _forknt endm ; ; NEXT (end of a FOR-NEXT loop) ; ; Syntax: ; next var ; ; The NEXT macro terminates a FOR-NEXT loop. The ; argument is: ; var is a RAM variable that is the index of the FOR-NEXT loop. ; ; Control will increment the value in var, then go back to ; the top of the FOR-NEXT loop for testing. Note that the var ; argument for the NEXT macro must match the var argument for ; the corresponding FOR macro. The macro library does not perform ; this check for you; you have to get it right yourself! ; ; This macro alters the contents of the W register and the index ; variable var. ; ; You may use NEXT to terminate a FOR-NEXT, FORF-NEXT, or ; FORL-NEXT loop. ; next macro var _nxtknt set _nxtknt-1 inc var jmp _for#v(_nxtknt) _next#v(_nxtknt) endm ; ; NEXTL (end of a FOR-NEXTL loop) ; ; Syntax: ; nextl var,incl ; ; The NEXTL macro terminates a FOR-NEXTL loop. The ; arguments are: ; var is a RAM variable that is the index of the FOR-NEXTL loop, ; incl is a literal value used to modify the index. ; ; Control will add the literal incl to the value in var, then ; go back to the top of the FOR-NEXTL loop for testing. Note ; that the var argument for the NEXTL macro must match the var ; argument for the corresponding FOR macro. The macro library ; does not perform this check for you; you have to get it right ; yourself! ; ; This macro alters the contents of the W register and the index ; variable var. ; ; You may use NEXTL to terminate a FOR-NEXTL, FORF-NEXTL, or ; FORL-NEXTL loop. ; ; NOTE: This macro uses the addlw instruction, which is not ; supported on the older PICs, such as the 16c54. Using this ; macro in a source file for such a chip will generate assembler ; errors. ; nextl macro var,incl _nxtknt set _nxtknt-1 mov W, var ;*** WARNING: ADDLW was expanded in three instructions! Check if previous instruction is a skip instruction. ; addlw incl mov Hack, W mov W, #incl add W, Hack mov var, W jmp _for#v(_nxtknt) _next#v(_nxtknt) endm ; ; NEXTF (end of a FOR-NEXTF loop) ; ; Syntax: ; nextf var,incf ; ; The NEXTF macro terminates a FOR-NEXTF loop. The ; arguments are: ; var is a RAM variable that is the index of the FOR-NEXTL loop, ; inc is a register whose value is used to modify the index. ; ; Control will add the value in incf to the value in var, then ; go back to the top of the FOR-NEXTF loop for testing. Note ; that the var argument for the NEXTF macro must match the var ; argument for the corresponding FOR macro. The macro library ; does not perform this check for you; you have to get it right ; yourself! ; ; This macro alters the contents of the W register and the index ; variable var. ; ; You may use NEXTF to terminate a FOR-NEXTF, FORF-NEXTF, or ; FORL-NEXTF loop. ; nextf macro var,incf _nxtknt set _nxtknt-1 mov W, var add incf, W jmp _for#v(_nxtknt) _next#v(_nxtknt) endm ; ; REPEAT (start of a REPEAT-ALWAYS or REPEAT-UNTIL loop) ; ; Syntax: ; repeat ; ; The REPEAT macro marks the start of a REPEAT-ALWAYS or ; REPEAT-UNTILEQ or REPEAT-UNTILNE loop. Control will always ; ret ; terminated with an ALWAYS macro. Control will conditionally ; ret ; terminated with an UNTILEQ or UNTILNE macro. ; ; This macro does not alter the W register. ; repeat macro _rpt#v(_rptknt) _rptknt set _rptknt+1 _alwknt set _rptknt _untknt set _rptknt endm ; ; ALWAYS (returns to corresponding REPEAT macro) ; ; Syntax: ; always ; ; The ALWAYS macro marks the end of a REPEAT-ALWAYS loop. ; Control is automatically passed back to the corresponding ; REPEAT macro. ; ; This macro does not alter the W register. ; always macro _alwknt set _alwknt-1 jmp _rpt#v(_alwknt) endm ; ; UNTILEQ (conditionally returns to corresponding REPEAT macro) ; ; Syntax: ; untileq ; ; The UNTILEQ macro marks the end of a REPEAT-UNTILEQ loop. ; Control is passed back to the corresponding REPEAT macro only ; if the Z-bit is cleared at the time the UNTILEQ macro is ; processed. ; ; This macro does not alter the W register. ; untileq macro _untknt set _untknt-1 bne _rpt#v(_untknt) endm ; ; UNTILNE (conditionally returns to corresponding REPEAT macro) ; ; Syntax: ; untilne ; ; The UNTILEQ macro marks the end of a REPEAT-UNTILNE loop. ; Control is passed back to the corresponding REPEAT macro only ; if the Z-bit is set at the time the UNTILNE macro is processed. ; ; This macro does not alter the W register. ; untilne macro _untknt set _untknt-1 beq _rpt#v(_untknt) endm ; ; SELECT (declares start of SELECT-ENDSELECT structure) ; ; Syntax: ; select ; ; The SELECT macro marks the beginning of a SELECT-ENDSELECT ; structure. A typical SELECT-ENDSELECT structure looks like this: ; ; select ; start of SELECT block ; case 5 ; if W = 5... ; . ; do something ; endcase ; end of W = 5 clause ; casef foo ; if W = foo ; . ; do something else ; endcase ; end of W = foo clause ; . ; default action (all cases fail) ; endselect ; end of SELECT block ; ; This macro does not alter the W register. ; select macro _seltot set _seltot+1 _selknt set _seltot endm ; ; ENDSELECT (declares end of SELECT-ENDSELECT structure) ; ; Syntax: ; endselect ; ; The ENDSELECT macro marks the end of a SELECT-ENDSELECT ; structure. You must terminate each SELECT macro with ; a matching ENDSELECT macro or MPASM will report errors. ; ; This macro does not alter the W register. ; endselect macro sel#v(_selknt) _selknt set _selknt-1 endm ; ; CASE (declares start of a CASE-ENDCASE structure) ; ; Syntax: ; case lit ; ; where lit is a literal value used as the CASE selector. ; ; When the CASE macro is executed, the value in W is compared ; with the literal value lit. If W equals lit, code following ; the CASE macro is executed. If W does not equal lit, control ; passes to the code following the corresponding ENDCASE macro. ; ; W is preserved in the CASE macro. ; case macro lit _castot set _castot+1 _casknt set _castot xor W, #lit beq cas#v(_casknt) xor W, #lit jmp ecas#v(_casknt) cas#v(_casknt) xor W, #lit endm ; ; CASEF (declares start of a CASEF-ENDCASE structure) ; ; Syntax: ; casef var ; ; where var is a register or variable used as the CASEF selector. ; ; When the CASEF macro is executed, the value in W is compared ; with the value in var. If W equals var, code following ; the CASEF macro is executed. If W does not equal var, control ; passes to the code following the corresponding ENDCASE macro. ; ; W is preserved in the CASEF macro. ; casef macro var _castot set _castot+1 _casknt set _castot xor W, var beq cas#v(_casknt) xor W, var jmp ecas#v(_casknt) cas#v(_casknt) xor W, var endm ; ; ENDCASE (declares end of a CASE-ENDCASE or CASEF-ENDCASE structure) ; ; Syntax: ; endcase ; ; The ENDCASE macro marks the end of a CASE-ENDCASE or CASEF-ENDCASE ; structure. This macro serves as a jump address for the corresponding ; CASE or CASEF macro. ; ; You must have an ENDCASE macro for each CASE or CASEF macro. If ; not, MPASM will report errors when it assembles your code. ; ; This macro preserves the W register. ; endcase macro jmp sel#v(_selknt) ecas#v(_casknt) _casknt set _casknt-1 endm ; ; WAITWHILE (declares a high-speed WAIT-WHILE loop) ; ; Syntax: ; ; waitwhile addr,andl,xorl ; ; The WAITWHILE macro creates a tight loop that reads the byte ; in address addr, ANDs it with the literal andl, then XORs the ; result with the literal xorl. If the result is TRUE (non-zero), ; the loop repeats. If the result is FALSE (zero), control exits ; the macro. ; ; This macro destroys the W register. It does not modify addr. ; waitwhile macro addr,andl,xorl waitw#v(_waitk) mov W, addr and W, #andl if xorl != 0 xor W, #xorl endif bne waitw#v(_waitk) _waitk set _waitk+1 endm ; ; WAITUNTIL (declares a high-speed WAIT-UNTIL loop) ; ; Syntax: ; ; waituntil addr,andl,xorl ; ; The WAITUNTIL macro creates a tight loop that reads the byte ; in address addr, ANDs it with the literal andl, then XORs the ; result with the literal xorl. If the result is TRUE (non-zero), ; control exits the macro. If the result is FALSE (zero), ; the loop repeats. ; ; This macro destroys the W register. It does not modify addr. ; waituntil macro addr,andl,xorl waitw#v(_waitk) mov W, addr and W, #andl if xorl != 0 xor W, #xorl endif beq waitw#v(_waitk) _waitk set _waitk+1 endm ; ; POLL (starts a POLL-ENDPOLL structure) ; ; Syntax: ; ; poll addr,andl,xorl ; ; The POLL macro reads the byte in address addr, ANDs it with ; the literal andl, then XORs the result with the literal xorl. ; If the result is TRUE (non-zero), control passes to the code ; immediately following the macro. If the result is FALSE ; (zero), control jumps to the corresponding ENDPOLL macro. ; ; For example, the following POLL command will test the address ; SPORT for bit 3 high: ; ; poll SPORT,8,0 test bit 3 ; nop ; endpoll ; ; The following POLL command will test the address SPORT for ; bit 3 high while either bits 2 or 1 are low: ; ; poll SPORT,0x0e,0x06 test bits 1-3 ; nop ; endpoll ; ; This macro destroys the W register. It does not modify addr. ; poll macro addr,andl,xorl _pollt set _pollt+1 _pollk set _pollt mov W, addr and W, #andl xor W, #xorl beq poll#v(_pollk) endm ; ; ENDPOLL (marks end of a POLL-ENDPOLL structure) ; ; The ENDPOLL macro terminates a POLL-ENDPOLL structure. ; Control reaches this macro if the associated POLL macro ; fails. ; endpoll macro poll#v(_pollk) _pollk set _pollk-1 endm
file: /Techref/scenix/lib/flow/macros-kl_sx.htm, 13KB, , updated: 2001/4/17 12:12, local time: 2024/8/14 13:23,
3.17.80.242:LOG IN
|
©2024 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions? <A HREF="http://sxlist.com/techref/scenix/lib/flow/macros-kl_sx.htm"> scenix lib flow macros-kl_sx</A> |
Did you find what you needed? |
Welcome to sxlist.com!sales, advertizing, & kind contributors just like you! Please don't rip/copy (here's why Copies of the site on CD are available at minimal cost. |
Welcome to sxlist.com! |
.