Parallax P2 Edge Module - Datasheet

LOC PA/PB/PTRA/PTRB,#{\}A
Get {12'b0, address[19:0]} into PA/PB/PTRA/PTRB (per W). If R = 1, address = PC + A, else address = A. "\"
forces R = 0.
2
MERGEB D
Merge bits of bytes in D. D = {D[31], D[23], D[15], D[7], ...D[24], D[16], D[8], D[0]}.
2
MERGEW D
Merge bits of words in D. D = {D[31], D[15], D[30], D[14], ...D[17], D[1], D[16], D[0]}.
2
MODC c {WC}
Modify C according to cccc. C = cccc[{C,Z}].
2
MODCZ c,z {WC/WZ/WCZ}
Modify C and Z according to cccc and zzzz. C = cccc[{C,Z}], Z = zzzz[{C,Z}].
2
MODZ z {WZ}
Modify Z according to zzzz. Z = zzzz[{C,Z}].
2
MOV D,{#}S {WC/WZ/WCZ}
Move S into D. D = S. C = S[31]. *
2
MOVBYTS D,{#}S
Move bytes within D, per S. D = {D.BYTE[S[7:6]], D.BYTE[S[5:4]], D.BYTE[S[3:2]], D.BYTE[S[1:0]]}.
2
MUL D,{#}S {WZ}
D = unsigned (D[15:0] * S[15:0]). Z = (S == 0) | (D == 0).
2
MULS D,{#}S {WZ}
D = signed (D[15:0] * S[15:0]). Z = (S == 0) | (D == 0).
2
MUXC D,{#}S {WC/WZ/WCZ}
Mux C into each D bit that is '1' in S. D = (!S & D ) | (S & {32{ C}}). C = parity of result. *
2
MUXNC D,{#}S {WC/WZ/WCZ}
Mux !C into each D bit that is '1' in S. D = (!S & D ) | (S & {32{!C}}). C = parity of result. *
2
MUXNIBS D,{#}S
For each non-zero nibble in S, copy that nibble into the corresponding D nibble, else leave that D nibble the
same.
2
MUXNITS D,{#}S
For each non-zero bit pair in S, copy that bit pair into the corresponding D bits, else leave that D bit pair the
same.
2
MUXNZ D,{#}S {WC/WZ/WCZ}
Mux !Z into each D bit that is '1' in S. D = (!S & D ) | (S & {32{!Z}}). C = parity of result. *
2
MUXQ D,{#}S
Used after SETQ. For each '1' bit in Q, copy the corresponding bit in S into D. D = (D & !Q) | (S & Q).
2
MUXZ D,{#}S {WC/WZ/WCZ}
Mux Z into each D bit that is '1' in S. D = (!S & D ) | (S & {32{ Z}}). C = parity of result. *
2
NEG D {WC/WZ/WCZ}
Negate D. D = -D. C = MSB of result. *
2
NEG D,{#}S {WC/WZ/WCZ}
Negate S into D. D = -S. C = MSB of result. *
2
NEGC D {WC/WZ/WCZ}
Negate D by C. If C = 1 then D = -D, else D = D. C = MSB of result. *
2
NEGC D,{#}S {WC/WZ/WCZ}
Negate S by C into D. If C = 1 then D = -S, else D = S. C = MSB of result. *
2
NEGNC D {WC/WZ/WCZ}
Negate D by !C. If C = 0 then D = -D, else D = D. C = MSB of result. *
2
NEGNC D,{#}S {WC/WZ/WCZ}
Negate S by !C into D. If C = 0 then D = -S, else D = S. C = MSB of result. *
2
NEGNZ D {WC/WZ/WCZ}
Negate D by !Z. If Z = 0 then D = -D, else D = D. C = MSB of result. *
2
NEGNZ D,{#}S {WC/WZ/WCZ}
Negate S by !Z into D. If Z = 0 then D = -S, else D = S. C = MSB of result. *
2
NEGZ D {WC/WZ/WCZ}
Negate D by Z. If Z = 1 then D = -D, else D = D. C = MSB of result. *
2
NEGZ D,{#}S {WC/WZ/WCZ}
Negate S by Z into D. If Z = 1 then D = -S, else D = S. C = MSB of result. *
2
NOT D {WC/WZ/WCZ}
Get !D into D. D = !D. C = !D[31]. *
2
NOT D,{#}S {WC/WZ/WCZ}
Get !S into D. D = !S. C = !S[31]. *
2
ONES D {WC/WZ/WCZ}
Get number of '1's in D into D. D = number of '1's in S (0..32). C = LSB of result. *
2
ONES D,{#}S {WC/WZ/WCZ}
Get number of '1's in S into D. D = number of '1's in S (0..32). C = LSB of result. *
2
OR D,{#}S {WC/WZ/WCZ}
OR S into D. D = D | S. C = parity of result. *
2
RCL D,{#}S {WC/WZ/WCZ}
Rotate carry left. D = [63:32] of ({D[31:0], {32{C}}} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[31]. *
2
RCR D,{#}S {WC/WZ/WCZ}
Rotate carry right. D = [31:0] of ({{32{C}}, D[31:0]} >> S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[0]. *
2
RCZL D {WC/WZ/WCZ}
Rotate C,Z left through D. D = {D[29:0], C, Z}. C = D[31], Z = D[30].
2
RCZR D {WC/WZ/WCZ}
Rotate C,Z right through D. D = {C, Z, D[31:2]}. C = D[1], Z = D[0].
2
REV D
Reverse D bits. D = D[0:31].
2
RGBEXP D
Expand 5:6:5 RGB value in D[15:0] into 8:8:8 value in D[31:8]. D = {D[15:11,15:13], D[10:5,10:9], D[4:0,4:2],
8'b0}.
2
RGBSQZ D
Squeeze 8:8:8 RGB value in D[31:8] into 5:6:5 value in D[15:0]. D = {15'b0, D[31:27], D[23:18], D[15:11]}.
2
ROL D,{#}S {WC/WZ/WCZ}
Rotate left. D = [63:32] of ({D[31:0], D[31:0]} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[31]. *
2
ROLBYTE D
Rotate-left byte established by prior ALTGB instruction into D.
2
ROLBYTE D,{#}S,#N
Rotate-left byte N of S into D. D = {D[23:0], S.BYTE[N]).
2
ROLNIB D
Rotate-left nibble established by prior ALTGN instruction into D.
2
ROLNIB D,{#}S,#N
Rotate-left nibble N of S into D. D = {D[27:0], S.NIBBLE[N]).
2
ROLWORD D
Rotate-left word established by prior ALTGW instruction into D.
2
ROLWORD D,{#}S,#N
Rotate-left word N of S into D. D = {D[15:0], S.WORD[N]).
2
ROR D,{#}S {WC/WZ/WCZ}
Rotate right. D = [31:0] of ({D[31:0], D[31:0]} >> S[4:0]). C = last bit shifted out if S[4:0] > 0, else D[0]. *
2
SAL D,{#}S {WC/WZ/WCZ}
Shift arithmetic left. D = [63:32] of ({D[31:0], {32{D[0]}}} << S[4:0]). C = last bit shifted out if S[4:0] > 0, else
2
Copyright © Parallax Inc. 2021/05/27 ▪ Parallax Propeller 2 (P2X8C4M64P) Datasheet ▪ Page 34