Here is a list of the operands and their meanings:
addr1: Subroutine address
.Description: Instruction unconditionally calls a subroutine located at the specified code address. Therefore, the current address and the address of called subroutine must be within the same 2K byte block of the program memory, starting from the first byte of the instruction following ACALL. Syntax: ACALL [subroutine name]; Bytes: 2 (instruction code, subroutine address); STATUS register flags: No flags are affected. EXAMPLE: Before execution: PC=0123h After execution: PC=0345h ADD A,Rn - Adds the register Rn to the accumulatorA: accumulator Rn: any R register (R0-R7)
Description: Instruction adds the register Rn (R0-R7) to the accumulator. After addition, the result is stored in the accumulator. Syntax: ADD A,Rn; Byte: 1 (instruction code); STATUS register flags: C, OV and AC; EXAMPLE: Before execution: A=2Eh (46 dec.) R4=12h (18 dec.) After execution: A=40h (64 dec.) R4=12h ADD A,@Ri - Adds the indirect RAM to the accumulatorA: accumulator Ri: Register R0 or R1
Description: Instruction adds the indirect RAM to the accumulator. Address of indirect RAM is stored in the Ri register (R0 or R1). After addition, the result is stored in the accumulator. Syntax: ADD A,@Ri; Byte: 1 (instruction code); STATUS register flags: C, OV and AC; EXAMPLE: Register address: SUM = 4Fh R0=4Fh Before execution: A= 16h (22 dec.) SUM= 33h (51 dec.) After execution : A= 49h (73 dec.) ADD A,direct - Adds the direct byte to the accumulatorA: accumulator Direct: Arbitrary register with address 0 - 255 (0 - FFh)
Description: Instruction adds the direct byte to the accumulator. As it is direct addressing, the direct can be any SFR or general-purpose register with address 0-7 Fh. The result is stored in the accumulator. Syntax: ADD A, register name; Bytes: 2 (instruction code, direct byte address); STATUS register flags: C, OV and AC; EXAMPLE: Before execution: SUM= 33h (51 dec.) A= 16h (22 dec.) After execution: SUM= 33h (73 dec.) A= 49h (73 dec.) ADDC A,Rn - Adds the register to the accumulator with a carry flagA: accumulator Rn: any R register (R0-R7)
Description: Instruction adds the accumulator with a carry flag and Rn register (R0-R7). After addition, the result is stored in the accumulator. Syntax: ADDC A,Rn; Byte: 1 (instruction code); STATUS register flags: C, OV and AC; EXAMPLE: Before execution: A= C3h (195 dec.) R0= AAh (170 dec.) C=1 After execution: A= 6Eh (110 dec.) AC=0, C=1, OV=1 ADD A,#data - Adds the immediate data to the accumulatorA: accumulator
Data: constant within 0-255 (0-FFh)
Description: Instruction adds data (0-255) to the accumulator. After addition, the result is stored in the accumulator. Syntax: ADD A,#data; Bytes: 2 (instruction code, data); STATUS register flags: C, OV and AC; EXAMPLE: Before execution: A= 16h (22 dec.) After execution: A= 49h (73 dec.) ADDC A,direct - Adds the direct byte to the acumulator with a carry flagA: accumulator
Direct: arbitrary register with address 0-255 (0-FFh)
Description: Instruction adds the direct byte to the accumulator with a carry flag. As it is direct addressing, the register can be any SFRs or general purpose register with address 0-7Fh (0-127dec.). The result is stored in the accumulator. Syntax: ADDC A, register address; Bytes: 2 (instruction code, direct); STATUS register flags: C, OV and AC; EXAMPLE: Before execution: A= C3h (195 dec.) TEMP = AAh (170 dec.) C=1 After execution: A= 6Eh (110 dec.) AC=0, C=1, OV=1 ADDC A,@Ri - Adds the indirect RAM to the accumulator with a carry flagA: accumulator
Ri: Register R0 or R1
Description: Instruction adds the indirect RAM to the accumulator with a carry flag. RAM address is stored in the Ri register (R0 or R1). After addition, the result is stored in the accumulator. Syntax: ADDC A,@Ri; Byte: 1 (instruction code); STATUS register flags: C, OV and AC; EXAMPLE: Register address: SUM = 4Fh R0=4Fh Before execution: A= C3h (195 dec.) SUM = AAh (170 dec.) C=1 After execution: A= 6Eh (110 dec.) AC=0, C=1, OV=1 ADDC A,#data - Adds the immediate data to the accumulator with a carry flagA: accumulator
Data: constant with address 0-255 (0-FFh)
Description: Instruction adds data (0-255) to the accumulator with a carry flag. After addition, the result is stored in the accumulator. Syntax: ADDC A,#data; Bytes: 2 (instruction code, data); STATUS register flags: C, OV and AC; EXAMPLE: Before execution: A= C3h (195 dec.) C=1 After execution: A= 6Dh (109 dec.) AC=0, C=1, OV=1 AJMP addr11 - Absoulte jumpaddr11: Jump address
Description: Program continues execution after executing a jump to the specified address. Similar to the ACALL instruction, the jump must be executed within the same 2K byte block of program memory starting from the first byte of the instruction following AJMP. Syntax: AJMP address (label); Bytes: 2 (instruction code, jump address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0345h SP=07h After execution: PC=0123h SP=09h ANL A,Rn - AND register to the accumulatorA: accumulator
Rn: any R register (R0-R7)
Description: Instruction performs logic AND operation between the accumulator and Rn register. The result is stored in the accumulator. Syntax: ANL A,Rn; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A= C3h (11000011 Bin.) R5= 55h (01010101 Bin.) After execution: A= 41h (01000001 Bin.) ANL A,direct - AND direct byte to the accumulatorA: accumulator
Direct: arbitrary register with address 0 - 255 (0 - FFh)
Description: Instruction performs logic AND operation between the accumulator and drect register. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (o-127 dec.). The result is stored in the accumulator. Syntax: ANL A,direct; Byte: 2 (instruction code, direct); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A= C3h (11000011 Bin.) MASK= 55h (01010101 Bin.) After execution: A= 41h (01000001 Bin.) ANL A,@Ri - AND indirect RAM to the accumulatorA: accumulator
Ri: Register R0 or R1
Description: Instruction performs logic AND operation between the accumulator and register. As it is indirect addressing, the register address is stored in the Ri register (R0 or R1). The result is stored in the accumulator. Syntax: ANL A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register address SUM = 4Fh R0=4Fh Before execution: A= C3h (11000011 Bin.) R0= 55h (01010101 Bin.) After execution: A= 41h (01000001 Bin.) ANL A,#data - AND immediate data to the accumulator A: accumulator Data: constant in the range of 0-255 (0-FFh) Description: Instruction performs logic AND operation between the accumulator and data. The result is stored in the accumulator. Syntax: ANL A,#data; Bytes: 2 (instruction code, data); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A= C3h (11000011 Bin.) After execution: A= 41h (01000001 Bin.) ANL direct,A - AND accumulator to direct byteDirect: arbitrary register with address 0-255 (0-FFh)
A: accumulator
Description: Instruction performs logic AND operation between direct byte and accumulator. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the direct byte. Syntax: ANL register address,A; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected. EXAMPLE: Before execution: A= C3h (11000011 Bin.) MASK= 55h (01010101 Bin.) After execution: MASK= 41h (01000001 Bin.) ANL direct,#data - AND immediate data to direct byteDirect: Arbitrary register with address 0 - 255 (0 - FFh)
Data: constant in the range between 0-255 (0-FFh)
Description: Instruction performs logic AND operation between direct byte and data. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the direct byte. Syntax: ANL register address ,#data; Bytes: 3 (instruction code, direct byte address, data); STATUS register flags: No flags are affected; EXAMPLE: Before execution: X= C3h (11000011 Bin.) MASK= 55h (01010101 Bin.) After execution: MASK= 41h (01000001 Bin.) ANL C,bit - AND direct bit to the carry flagC: Carry flag Bit: any bit of RAM
Description: Instruction performs logic AND operation between the direct bit and the carry flag.BIT | C | C AND BIT |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
C: carry flag Bit: any bit of RAM
Description: Instruction performs logic AND operation between inverted addressed bit and the carry flag. The result is stored in the carry flag.BIT | BIT | C | C AND BIT |
---|---|---|---|
0 | 1 | 0 | 0 |
0 | 1 | 1 | 1 |
1 | 0 | 0 | 0 |
1 | 0 | 1 | 0 |
A: accumulator
Direct: arbitrary register with address 0-255 (0-FFh)
addr: jump address
Description: Instruction first compares the number in the accumulator with the directly addressed byte. If they are equal, the program proceeds with execution. Otherwise, a jump to the specified address will be executed. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-128 to +127 locations relative to the first following instruction). Syntax: CJNE A,direct,[jump address]; Bytes: 3 (instruction code, direct byte address, jump address); STATUS register flags: C; EXAMPLE: Before execution: PC=0145h A=27h After execution: if MAX≠27: PC=0123h If MAX=27: PC=0146h CJNE A,#data,rel - Compares immediate data to the accumulator and jumps if not equalA: accumulator
Data: constant in the range of 0-255 (0-FFh)
Description: Instruction first compares the number in the accumulator with the immediate data. If they are equal, the program proceeds with execution. Otherwise, a jump to the specified address will be executed. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-128 to +127 locations relative to the first following instruction). Syntax: CJNE A,X,[jump address]; Bytes: 3 (instruction code, data, jump address); STATUS register flags: C; EXAMPLE: Before execution: PC=0445h After execution: If A≠33: PC=0423h If A=33: PC=0446h CJNE Rn,#data,rel - Compares immediate data to the register Rn and jumps if not equalRn: Any R register (R0-R7)
Data: Constant in the range of 0 - 255 (0-FFh)
addr: Jump address
Description: Instruction first compares immediate data to the register Rn. If they are equal, the program proceeds with execution. Otherwise, a jump to the specified address will be executed. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-128 to + 127 locations relative to the first following instruction). Syntax: CJNE Rn,data,[jump address]; Bytes: 3 (instruction code, data, jump address); STATUS register flags: C; EXAMPLE: Before execution: PC=0345h After execution: If R5≠44h: PC=0323h If R5=44h: PC=0346h CJNE @Ri,#data,rel - Compares immediate data to indirectly addressed register and jumps if not equalRi: Register R0 or R1
Data: Constant in the range of 0 - 255 (0-FFh)
Description: This instruction first compares immediate data to indirectly addressed register. If they are equal, the program proceeds with execution. Otherwise, a jump to the specified address in the program will be executed. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-128 to +127 locations relative to the next instruction). Syntax: CJNE @Ri,data,[jump address]; Bytes: 3 (instruction code, data, jump address); STATUS register flags: C; EXAMPLE: Before execution: Register Address SUM=F3h PC=0345h R0=F3h After execution: If SUM≠44h: PC=0323h If SUM=44h: PC=0346h CLR A - Clears the accumulatorA: accumulator
Description: Instruction clears the accumulator. Syntax: CLR A; Byte: 1 (instruction code); STATUS register flags: No flags are affected. EXAMPLE: After execution: A=0 CLR C - clears the carry flagC: Carry flag
Description: Instruction clears the carry flag. Syntax: CLR C; Byte: 1 (instruction code); STATUS register flags: C; EXAMPLE: After execution: C=0 CLR bit - clears the direct bitBit: any bit of RAM
Description: Instruction clears the specified bit. Syntax: CLR [bit address]; Bytes: 2 (instruction code, bit address); STATUS register flags: No flags are affected. EXAMPLE: Before execution: P0.3=1 (input pin) After execution: P0.3=0 (output pin) CPL A - Complements the accumulatorA: accumulator
Description: Instruction complements all the bits in the accumulator (1==>0, 0==>1). Syntax: CPL A; Bytes: 1 (instruction code); STATUS register flags: No flags are affected. EXAMPLE: Before execution: A= (00110110) After execution: A= (11001001) CPL bit - Complements the direct bitBit: any bit of RAM
Description: Instruction coplements the specified bit of RAM (0==>1, 1==>0). Syntax: CPL [bit address]; Bytes: 2 (instruction code, bit address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: P0.3=1 (input pin) After execution: P0.3=0 (output pin) CPL C - Complements the carry flagC: Carry flag
Description: Instruction complements the carry flag (0==>1, 1==>0). Syntax: CPL C; Byte: 1 (instruction code); STATUS register flags: C; EXAMPLE: Before execution: C=1 After execution: C=0 DA A - Decimal adjust accumulatorA: accumulator
Description: Instruction adjusts the contents of the accumulator to correspond to a BCD number after two BCD numbers have been added by the ADD and ADDC instructions. The result in form of two 4-digit BCD numbers is stored in the accumulator. Syntax: DA A; Byte: 1 (instruction code); STATUS register flags: C; EXAMPLE: Before execution: A=56h (01010110) 56 BCD B=67h (01100111) 67BCD After execution: A=BDh (10111101) After BCD conversion: A=23h (00100011), C=1 (Overflow) (C+23=123) = 56+67 DEC A - Decrements the accumulator by 1A: accumulator
Description: Instruction decrements the value in the accumulator by 1. If there is a 0 in the accumulator, the result of the operation is FFh. (255 dec.) Syntax: DEC A; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=E4h After execution: A=E3h DEC Rn - Decrements the register Rn by 1Rn: any R register (R0-R7)
Description: Instruction decrements the value in the Rn register by 1. If there is a 0 in the register, the result of the operation will be FFh. (255 dec.) Syntax: DEC Rn; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: R3=B0h After execution: R3=AFh DEC direct - Decrements the direct byte by 1Direct: arbitrary register with address 0-255 (0-FFh)
Description: Instruction decrements the value of directly addressed register by 1. As it is direct addressing, the register must be within the first 255 locations of RAM. If there is a 0 in the register, the result will be FFh. Syntax: DEC [register address]; Byte: 2 (instruction code, direct); STATUS register flags: No flags are affected; EXAMPLE: Before execution: CNT=0 After execution: CNT=FFh DIV AB - Divides the accumulator by the register BA: accumulator
B: Register B
Description: Instruction divides the value in the accumulator by the value in the B register. After division the integer part of result is stored in the accumulator while the register contains the remainder. In case of dividing by 1, the flag OV is set and the result of division is unpredictable. The 8-bit quotient is stored in the accumulator and the 8-bit remainder is stored in the B register. Syntax: DIV AB; Byte: 1 (instruction code); STATUS register flags: C, OV; EXAMPLE: Before execution: A=FBh (251dec.) B=12h (18 dec.) After execution: A=0Dh (13dec.) B=11h (17dec.) 13·18 + 17 =251 DEC @Ri - Decrements the indirect RAM by 1Ri: Register R0 or R1
Description: This instruction decrements the value in the indirectly addressed register of RAM by 1. The register address is stored in the Ri register (R0 or R1). If there is a 0 in the register, the result will be FFh. Syntax: DEC @Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register Address CNT = 4Fh R0=4Fh Before execution: CNT=35h After execution: CNT= 34h DJNZ direct,rel - Decrements direct byte by 1 and jumps if not 0Direct: arbitrary register with address 0-255 (0-FFh) addr: Jump address
Description: This instruction first decrements value in the register. If the result is 0, the program proceeds with execution. Otherwise, a jump to the specified address in the program will be executed. As it is direct addressing, the register must be within the first 255 locations of RAM. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-128 to +127 locations relative to the first following instruction). Syntax: DJNZ direct,[jump address]; Bytes: 3 (instruction code, direct, jump address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0445h After execution: If CNT≠0: PC=0423h If CNT=0: PC=0446h DJNZ Rn,rel - Decrements the Rn register by 1 and jumps if not 0Rn: any R register (R0-R7)
addr: jump address
Description: This instruction first decrements the value in the Rn register. If the result is 0, the program proceeds with execution. Otherwise, a jump to the specified address in the program will be executed. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (- 128 to +127 locations relative to the first following instruction). Syntax: DJNZ Rn, [jump address]; Bytes: 2 (instruction code, jump address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0445h After execution: If R1≠0: PC=0423h If R1=0: PC=0446h INC Rn - Increments the Rn register by 1Rn: any R register (R0-R7)
Description: Instruction increments the value in the Rn register by 1. If the register includes the number 255, the result of the operation will be 0. Syntax: INC Rn; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: R4=18h After execution: R4=19h INC A - Increments the accumulator by 1A: accumulator
Description: This instruction increments the value in the accumulator by 1. If the accumulator includes the number 255, the result of the operation will be 0. Syntax: INC A; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=E4h After execution: A=E5h INC @Ri - Increments the value of indirectly addressed register of RAM by 1Ri: Register R0 or R1
Description: This instruction increments the value in the directly addressed register of RAM by 1. The register address is stored in the Ri Register (R0 or R1). If the register includes the number 255, the result of the operation will be 0. Syntax: INC @Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register Address CNT = 4Fh Before execution: CNT=35h R1=4Fh After execution: CNT=36h INC direct - Increments the direct byte by 1Direct: arbitrary register with address 0-255 (0-FFh)
Description: Instruction increments the direct byte by 1. If the register includes the number 255, the result of the operation will be 0. As it is direct addressing, the register must be within the first 255 RAM locations. Syntax: INC direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: CNT=33h After execution: CNT=34h JB bit,rel - Jump if direct bit is setaddr: Jump address Bit: any bit of RAM
Description: If the bit is set, a jump to the specified address will be executed. Otherwise, if the value of bit is 0, the program proceeds with the next instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-128 to + 127 locations relative to the first following instruction). Syntax: JB bit, [jump address]; Bytes: 3 (instruction code, bit address, jump address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0323h After execution: If P0.5=0: PC=0324h If P0.5=1: PC=0345h INC DPTR - Increments the Data Pointer by 1DPTR: Data Pointer
Description: Instruction increments the value of the 16-bit data pointer by 1. This is the only 16-bit register upon which this operation can be performed. Syntax: INC DPTR; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: DPTR = 13FF (DPH = 13h DPL = FFh ) After execution: DPTR = 1400 (DPH = 14h DPL = 0) JC rel - Jump if carry flag is setaddr: Jump address
Description: Instruction first checks if the carry flag is set. If set, a jump to the specified address is executed. Otherwise, the program proceeds with the next instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-129 to + 127 locations relative to the first following instruction). Syntax: JC [jump address]; Bytes: 2 (instruction code, jump value); STATUS register flags: No flags are affected; EXAMPLE: Before instruction: PC=0323h After instruction: If C=0: PC=0324h If C=1: PC=0345h JBC bit,rel - Jump if direct bit is setBit: any bit of RAM addr: Jump Address
Description: This instruction first checks if the bit is set. If set, a jump to the specified address is executed and the bit is cleared. Otherwise, the program proceeds with the first following instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-129 to + 127 locations relative to the first following instruction). Syntax: JBC bit, [jump address]; Bytes: 3 (instruction code, bit address, jump address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0323h After execution: If TEST0.4=1: PC=0345h, TEST0.4=0 If TEST0.4=0: PC=0324h, TEST0,4=0 JNB bit,rel - Jump if direct bit is not setaddr: Jump address Bit: any bit of RAM
Description: If the bit is cleared, a jump to the specified address will be executed. Otherwise, if the bit value is 1, the program proceeds with the first following instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-129 to + 127 locations relative to the first following instruction). Syntax: JNB bit,[jump address]; Bytes: 3 (instruction code, bit address, jump address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0323h After execution: If P0.5=1: PC=0324h If P0.5=0: PC=0345h JMP @A+DPTR - Jump indirect relative to the DPTRA: accumulator
DPTR: Data Pointer
Description: This instruction causes a jump to the address calculated by adding value stored in the accumulator to the 16-bit number in the DPTR Register. It is used with complex program branching where the accumulator affects jump address, for example when reading a table. Neither accumulator nor DPTR register are affected. Syntax: JMP @A+DPTR; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=223 DPTR=1400h After execution: PC = 1402h if A=2 PC = 1404h if A=4 PC = 1406h if A=6 Note: As instructions AJMP LABELS occupy two locations each, the values in the accumulator specifying them must be different from each other by 2. JNZ rel - Jump if accumulator is not zeroaddr: Jump Address
Description: This instruction checks if the value stored in the accumulator is 0. If not, a jump to the specified address will be executed. Otherwise, the program proceeds with the first following instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-129 to + 127 locations relative to the first following instruction). Syntax: JNZ [jump address]: Bytes: 2 (instruction code, jump value); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0323h After execution: If A=0: PC=324h If A≠0: PC=283h JNC rel - Jump if carry flag is not setaddr: Jump Address
Description: This instruction first checks whether the carry flag is set. If not, a jump to the specified address will be executed. Otherwise, the program proceeds with the first following instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-129 to + 127 locations relative to the first following instruction). Syntax: JNC [jump address]; Bytes: 2 (instruction code, jump value); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0323h After execution: If C=0: PC=360h If C=1: PC=324h LCALL addr16 - Long subroutine calladdr16: Subroutine Address
Description: This instruction unconditionally calls a subroutine located at the specified address. The current address and the start of the subroutine called can be located anywhere within the memory space of 64K. Syntax: LCALL [subroutine name]; Bytes: 3 (instruction code, address (15-8), address (7-0)); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0123h After execution: PC=1234h JZ rel - Jump if accumulator is zero addr: Jump Address Description: The instruction checks whether the value stored in the accumulator is 0. If yes, a jump to the specified address will be executed. Otherwise, the program proceeds with the following instruction. This is a short jump instruction, which means that the address of a new location must be relatively near the current one (-129 to + 127 locations relative to the first following instruction). Syntax: JZ [jump address]; Bytes: 2 (instruction code, jump value); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0323h After execution: If A0: PC=324h If A=0: PC=283h MOV A,Rn - Moves the Rn register to the accumulatorRn: any R register (R0-R7) A: accumulator
Description: The instruction moves the Rn register to the accumulator. The Rn register is not affected. Syntax: MOV A,Rn; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: R3=58h After execution: R3=58h A=58h LJMP addr16 - Long jumpaddr16: jump address
Description: Instruction causes a jump to the specified 16-bit address. Syntax: LJMP [jump address]; Bytes: 3 (instruction code, address (15-8), address (7-0)); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=0123h After execution: PC=1234h MOV A,@Ri - Moves the indirect RAM to the accumulatorRi: Register R0 or R1 A: accumulator
Description: Instruction moves the indirectly addressed register of RAM to the accumulator. The register address is stored in the Ri register (R0 or R1). The result is stored in the accumulator. The register is not affected. Syntax: MOV A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register Address SUM=F2h R0=F2h Before execution: SUM=58h After execution: A=58h SUM=58h MOV A,direct - Moves the direct byte to the accumulatorDirect: arbitrary register with address 0-255 (0-FFh)
A: accumulator
Description: Instruction moves the direct byte to the accumulator. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). After executing the instruction, the register is not affected. Syntax: MOV A,direct; Byte: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: Rx=68h After execution: Rx=68h A=68h MOV Rn,A - Moves the accumulator to the Rn registerRn: any R register (R0-R7) A: accumulator
Desription: Instruction moves the accumulator to the Rn register. The accumulator is not affected. Syntax: MOV Rn,A; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=58h After execution: R3=58h A=58h MOV A,#data - Moves the immediate data to the accumulatorA: accumulator
Data: Constant in the range of 0-255 (0-FFh)
Desription: Instruction moves the immediate data to the accumulator. Syntax: MOV A,#data; Bytes: 2 (instruction code, data); STATUS register flags: No flags are affected; EXAMPLE: After execution: A=28h MOV Rn,#data - Moves the immediate data to the Rn registerRn: any R register (R0-R7)
Data: Constant in the range of 0-255 (0-FFh)
Description: Instruction moves the immediate data to the Rn register. Syntax: MOV Rn,#data; Bytes: 2 (instruction code, data); STATUS register flags: No flags are affected; EXAMPLE: After execution: R5=32h MOV Rn,direct - Moves the direct byte to the Rn registerRn: Any R registar (R0-R7)
Direct: arbitrary register with address 0-255 (0-FFh)
Description: Instruction moves the direct byte to the Rn register. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). After executing the instruction, the register is not affected. Syntax: MOV Rn,direct; Bytes: 2 (instruction code, direct); STATUS register flags: No flags are affected; EXAMPLE: Before execution: SUM=58h After execution: SUM=58h R3=58h MOV direct,Rn - Moves the Rn register to the direct byteRn: any R register (R0-R7)
Direct: arbitrary register with address 0-255 (0 - FFh)
Description: Instruction moves the Rn register to the direct byte. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). After executing the instruction, the register is not affected. Syntax: MOV direct,Rn; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: R3=18h After execution: R3=18h CIF=18h MOV direct,A - Moves the accumulator to the direct byteDirect: arbitrary register with address 0-255 (0 - FFh)
A: accumulator
Description: Instruction moves the accumulator to the direct byte. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). After executing the instruction, the register is not affected. Syntax: MOV direct,A; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=98h After execution: A=98h REG=98h MOV direct,@Ri - Moves the indirect RAM to the direct byteDirect: arbitrary register with address 0-255 (0 - FFh)
Ri: Register R0 or R1
Description: Instruction moves the indirectly adressed register of RAM to the direct byte. The register is not affected. Syntax: MOV direct,@Ri; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Register Address SUM=F3 Before execution: SUM=58h R1=F3 After execution: SUM=58h TEMP=58h MOV direct1,direct2 - Moves the direct byte to the direct byteDirect: Arbitrary register with address 0-255 (0-FFh)
Direct: Arbitrary register with address 0-255 (0-FFh)
Description: Instruction moves the direct byte to another direct byte. As it is direct addressing, both registers can be any SFRs or general-purpose registers with address 0-7Fh. (0-127 dec.). The direct1 is not affected. Syntax: MOV direct1,direct2; Bytes: 3 (instruction code, direct1 address, direct2 address); STATUS register flags: No flags are affected. EXAMPLE: Before execution: TEMP=58h After execution: TEMP=58h SUM=58h MOV @Ri,A - Moves the accumulator to the indirect RAMA: accumulator
Ri: register R0 or R1
Description: Instruction moves the accumulator to the indirectly addressed register of RAM. The register address is stored in the Ri register (R0 or R1). After executing the instruction, the accumulator is not affected. Syntax: MOV @Ri,A; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register Address SUM=F2h Before execution: R0=F2h A=58h After execution: SUM=58h A=58h MOV direct,#data - Moves the immediate data to the direct byteDirect: Arbitrary register with address 0-255 (0-FFh)
Data: Constant in the range of 0-255 (0-FFh)
Description: Instruction moves the immediate data to the direct byte. As it is direct addressing, the direct byte can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). Syntax: MOV direct,#data; Bytes: 3 (instruction code, direct byte address, data); STATUS register flags: No flags are affected; EXAMPLE: After execution: TEMP=22h MOV @Ri,#data - Moves the immediate data to the indirect RAMRi: Register R0 or R1
Data: Constant in the range of 0-255 (0-FFh)
Description: Instruction moves the immediate data to the idirectly addressed register of RAM. The register address is stored in the Ri register (R0 or R1). Syntax: MOV @Ri,#data; Bytes: 2 (instruction code, data); STATUS register flags: No flags are affected; EXAMPLE: Register address TEMP=E2h Before execution: R1=E2h After execution: TEMP=44h MOV @Ri,direct - Moves the direct byte to the indirect RAMDirect: Arbitrary register with address 0-255 (0-FFh)
Ri: Register R0 or R1
Description: Instruction moves the direct byte to a register the address of which is stored in the Ri register (R0 or R1). After executing the instruction, the direct byte is not affected. Syntax: MOV @Ri,direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Register address TEMP=E2h Before execution: SUM=58h R1=E2h After execution: SUM=58h TEMP=58h MOV bit,C - Moves the carry flag to the direct bitC: Carry flag
Bit: any bit of RAM
Description: Instruction moves the carry flag to the direct bit. After executing the instruction, the carry flag is not affected. Syntax: MOV bit,C; Bytes: 2 (instruction code, bit address); STATUS register flags: No flags are affected; EXAMPLE: After execution: If C=0 P1.2=0 If C=1 P1.2=1 MOV C,bit - Moves the direct bit to the carry flagC: Carry flag
Bit: any bit of RAM
Description: Instruction moves the direct bit to the carry flag. After executing the instruction, the bit is not affected. Syntax: MOV C,bit; Bytes: 2 (instruction code, bit address); STATUS register flags: C; EXAMPLE: After execution: If P1.4=0 C=0 If P1.4=1 C=1 MOVC A,@A+DPTR - Moves the code byte relative to the DPTR to the accumulatorA: accumulator
DPTR: Data Pointer
Description: Instruction first adds the 16-bit DPTR register to the accumulator. The result of addition is then used as a memory address from which the 8-bit data is moved to the accumulator. Syntax: MOVC A,@A+DPTR; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Before execution: DPTR=1000: A=0 A=1 A=2 A=3 After execution: A=66h A=77h A=88h A=99h Note: DB (Define Byte) is a directive in assembly language used to define constant. MOV DPTR,#data16 - Loads the data pointer with a 16-bit constantData: constant in the range of 0-65535 (0-FFFFh)
DPTR: Data Pointer
Description: Instruction stores a 16-bit constant to the DPTR register. The 8 high bits of the constant are stored in the DPH register, while the 8 low bits are stored in the DPL register. Syntax: MOV DPTR,#data; Bytes: 3 (instruction code, constant (15-8), constant (7-0)); STATUS register flags: No flags affected; EXAMPLE: After execution: DPH=12h DPL=34h MOVX A,@Ri - Moves the external RAM (8-bit address) to the accumulatorRi: register R0 or R1
A: accumulator
Description: Instruction reads the content of a register in external RAM and moves it to the accumulator. The register address is stored in the Ri register (R0 or R1). Syntax: MOVX A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Register Address: SUM=12h Before execution: SUM=58h R0=12h After execution: A=58h Note: SUM Register is stored in external RAM which is 256 bytes in size. MOVC A,@A+PC - Moves the code byte relative to the PC to the accumulatorA: accumulator
PC: Program Counter
Description: Instruction first adds the 16-bit PC register to the accumulator (the current program address is stored in the PC register). The result of addition is then used as a memory address from which the 8-bit data is moved to the accumulator. Syntax: MOVC A,@A+PC; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: After the subroutine "Table" has been executed, one of four values is stored in the accumulator: Before execution: A=0 A=1 A=2 A=3 After execution: A=66h A=77h A=88h A=99h Note: DB (Define Byte) is a directive in assembly language used to define constant. MOVX @Ri,A - Moves the accumulator to the external RAM (8-bit address)Ri: register R0 or R1
A: accumulator
Description: Instruction moves the accumulator to a register stored in external RAM. Its address is stored in the Ri register. Syntax: MOVX @Ri,A; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Register address: SUM=34h Before execution: A=58 R1=34h After execution: SUM=58h NOTE: Register SUM is located in external RAM which is 256 bytes in size. MOVX A,@DPTR - Moves the external memory (16-bit address) to the accumulatorA: accumulator DPRTR: Data Pointer
Description: Instruction moves the content of a register in external memory to the accumulator. The 16-bit address of the register is stored in the DPTR register (DPH and DPL). Syntax: MOVX A,@DPTR; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Register address: SUM=1234h Before execution: DPTR=1234h SUM=58 After execution: A=58h Note: Register SUM is located in external RAM which is up to 64K in size. MUL AB - Multiplies A and BA: accumulator
B: Register B
Description: Instruction multiplies the value in the accumulator with the value in the B register. The low-order byte of the 16-bit result is stored in the accumulator, while the high byte remains in the B register. If the result is larger than 255, the overflow flag is set. The carry flag is not affected. Syntax: MUL AB; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Before execution: A=80 (50h) B=160 (A0h) After execution: A=0 B=32h A·B=80·160=12800 (3200h) MOVX @DPTR,A - Moves the accumulator to the external RAM (16-bit address)A: accumulator
DPTR: Data Pointer
Description: Instruction moves the accumulator to a register stored in external RAM. The 16-bit address of the register is stored in the DPTR register (DPH and DPL). Syntax: MOVX @DPTR,A; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Register address: SUM=1234h Before execution: A=58 DPTR=1234h After execution: SUM=58h Note: Register SUM is located in RAM which is up to 64K in size. ORL A,Rn - OR register to the accumulatorRn: any R register (R0-R7)
A: accumulator
Description: Instruction performs logic OR operation between the accumulator and Rn register. The result is stored in the accumulator. Syntax: ORL A,Rn; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Before execution: A= C3h (11000011 Bin.) R5= 55h (01010101 Bin.) After execution: A= D7h (11010111 Bin.) NOP - No operation Description: Instruction doesn’t perform any operation and is used when additional time delays are needed. Syntax: NOP; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Such a sequence provides a negative pulse which lasts exactly 5 machine cycles on the P2.3. If a 12 MHz quartz crystal is used then 1 cycle lasts 1uS, which means that this output will be a low-going output pulse for 5 uS. ORL A,@Ri - OR indirect RAM to the accumulatorRi: register R0 or R1
A: accumulator
Description: Instruction performs logic OR operation between the accumulator and a register. As it is indirect addressing, the register address is stored in the Ri register (R0 or R1). The result is stored in the accumulator. Syntax: ANL A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Register address: TEMP=FAh Before execution: R1=FAh TEMP= C2h (11000010 Bin.) A= 54h (01010100 Bin.) After execution: A= D6h (11010110 Bin.) ORL A,direct - OR direct byte to the accumulatorDirect: arbitrary register with address 0-255 (0-FFh)
A: accumulator
Description: Instruction performs logic OR operation between the accumulator and a register. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the accumulator. Syntax: ORL A,direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags affected; EXAMPLE: Before execution: A= C2h (11000010 Bin.) LOG= 54h (01010100 Bin.) After execution: A= D6h (11010110 Bin.) ORL direct,A - OR accumulator to the direct byteDirect: arbitrary register with address 0-255 (0-FFh)
A: accumulator
Description: Instruction performs logic OR operation between a register and accumulator. As it is direct addressing, the register can be any SFRs or general- purpose register with address 0-7Fh (0-127 dec.). The result is stored in the register. Syntax: ORL [register address], A; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags affected; EXAMPLE: Before execution: TEMP= C2h (11000010 Bin.) A= 54h (01010100 Bin.) After execution: A= D6h (11010110 Bin.) ORL A,#data - OR immediate data to the accumulatorData: constant in the range of 0-255 (0-FFh)
A: accumulator
Description: Instruction performs logic OR operation between the accumulator and the immediate data. The result is stored in the accumulator. Syntax: ORL A, #data; Bytes: 2 (instruction code, data); STATUS register flags: No flags affected; EXAMPLE: Before execution: A= C2h (11000010 Bin.) After execution: A= C3h (11000011 Bin.) ORL C,bit - OR direct bit to the carry flagC: Carry flag
Bit: any bit of RAM
Description: Instruction performs logic OR operation between the direct bit and the carry flag. The result is stored in the carry flag. Syntax: ORL C,bit; Bytes: 2 (instruction code, direct bit address); STATUS register flags: No flags affected; EXAMPLE: Before execution: ACC= C6h (11001010 Bin.) C=0 After execution: C=1 ORL direct,#data - OR immediate data to direct byteDirect: arbitrary register with address 0-255 (0-FFh)
Data: constant in the range of 0-255 (0-FFh)
Description: Instruction performs logic OR operation between the immediate data and the direct byte. As it is direct addressing, the direct byte can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the direct byte. Syntax: ORL [register address],#data; Bytes: 3 (instruction code, direct byte address, data); STATUS register flags: No flags affected; EXAMPLE: Before execution: TEMP= C2h (11000010 Bin.) After execution: A= D2h (11010010 Bin.) POP direct - Pop the direct byte from the stackDirect: arbitrary register with address 0-255 (0-FFh)
Description: Instruction first reads data from the location being pointed to by the Stack. The data is then copied to the direct byte and the value of the Stack Pointer is decremented by 1. As it is direct addressing, the direct byte can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). Syntax: POP direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags affected; EXAMPLE: Before execution: Address Value 030h 20h 031h 23h SP==> 032h 01h DPTR=0123h (DPH=01, DPL=23h) After execution: Address Value SP==> 030h 20h 031h 23h 032h 01h ORL C,/bit - OR complements of direct bit to the carry flagC: carry flag
Bit: any bit of RAM
Description: Instruction performs logic OR operation between the addressed inverted bit and the carry flag. The result is stored in the carry flag.BIT | BIT | C | C AND BIT |
---|---|---|---|
0 | 1 | 0 | 0 |
0 | 1 | 1 | 1 |
1 | 0 | 0 | 0 |
1 | 0 | 1 | 0 |
Syntax: RET;
Byte: 1 (instruction code);
STATUS register flags: No flags affected;
EXAMPLE: PUSH direct - Pushes the direct byte onto the stackData: Arbitrary register with address 0-255 (0-FFh)
Description: Address currently pointed to by the Stack Pointer is first incremented by 1 and afterwards the data from the register Rx is copied to it. As it is direct addressing, the direct byte can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.) Syntax: PUSH direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags affected; EXAMPLE: Before execution: Address Value SP==> 030h 20h DPTR=0123h (DPH=01, DPL=23h) After execution: Address Value 030h 20h 031h 23h SP==> 032h 01h RL A - Rotates the accumulator one bit leftA: accumulator
Description: Eight bits in the accumulator are rotated one bit left, so that the bit 7 is rotated into the bit 0 position. Syntax: RL A; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Before execution: A= C2h (11000010 Bin.) After execution: A=85h (10000101 Bin.) RETI - Return from interrupt Description: This instruction ends every interrupt routine and informs processor about it. After executing the instruction, the program proceeds from where it left off. The PSW is not automatically returned its pre-interrupt status. Syntax: RETI; Byte: 1 (instruction code); STATUS register flags: No flags affected; RR A - Rotates the accumulator one bit right A: accumulator Description: All eight bits in the accumulator are rotated one bit right so that the bit 0 is rotated into the bit 7 position. Syntax: RR A; Byte: 1 (instruction code); STATUS register flags: No flags affected; EXAMPLE: Before execution: A= C2h (11000010 Bin.) After execution: A= 61h (01100001 Bin.) RLC A - Rotates the accumulator one bit left through the carry flag A: accumulator Description: All eight bits in the accumulator and carry flag are rotated one bit left. After this operation, the bit 7 is rotated into the carry flag position and the carry flag is rotated into the bit 0 position. Syntax: RLC A; Byte: 1 (instruction code); STATUS register flags: C; EXAMPLE: Before execution: A= C2h (11000010 Bin.) C=0 After execution: A= 85h (10000100 Bin.) C=1 SETB C - Sets the carry flag C: Carry flag Description: Instruction sets the carry flag. Syntax: SETB C; Byte: 1 (instruction code); STATUS register flags: C; EXAMPLE: After execution: C=1 RRC A - Rotates the accumulator one bit right through the carry flag A: accumulator Description: All eight bits in the accumulator and carry flag are rotated one bit right. After this operation, the carry flag is rotated into the bit 7 position and the bit 0 is rotated into the carry flag position. Syntax: RRC A; Byte: 1 (instruction code); STATUS register flags: C; EXAMPLE: Before execution: A= C2h (11000010 Bin.) C=0 After execution: A= 61h (01100001 Bin.) C=0 SJMP rel - Short Jump (relative address) addr: Jump Address Description: Instruction enables jump to the new address which should be in the range of -128 to +127 locations relative to the first following instruction. Syntax: SJMP [jump address]; Bytes: 2 (instruction code, jump value); STATUS register flags: No flags are affected; EXAMPLE: Before execution: PC=323 After execution: PC=345 SETB bit - Sets the direct bit Bit: any bit of RAM Description: Instruction sets the specified bit. The register containing that bit must belong to the group of the so called bit addressable registers. Syntax: SETB [bit address]; Bytes: 2 (instruction code, bit address); STATUS register flags: No flags affected; EXAMPLE: Before execution: P0.1 = 34h (00110100) pin 1 is configured as an output After execution: P0.1 = 35h (00110101) pin 1 is configured as an input SUBB A,direct - Subtracts the direct byte from the accumulator with a borrow Direct: arbitrary register with address 0-255 (0-FFh) A: accumulator Description: Instruction subtracts the direct byte from the accumulator with a borrow. If the higher bit is subtracted from the lower bit then the carry flag is set. As it is direct addressing, the direct byte can be any SFRs or general-purpose register with address 0-7Fh. (0-127 dec.). The result is stored in the accumulator. Syntax: SUBB A,direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: C, OV, AC; EXAMPLE: Before execution: A=C9h, DIF=53h, C=0 After execution: A=76h, C=0 SUBB A,Rn - Subtracts the Rn register from the accumulator with a borrow Rn: any R register (R0-R7) A: accumulator Description: Instruction subtracts the Rn register from the accumulator with a borrow. If the higher bit is subtracted from the lower bit then the carry flag is set. The result is stored in the accumulator. Syntax: SUBB A,Rn; Byte: 1 (instruction code); STATUS register flags: C, OV, AC; EXAMPLE: Before execution: A=C9h, R4=54h, C=1 After execution: A=74h, C=0 Note: The result is different (C9 - 54=75) because the carry flag is set (C=1) before the instruction starts execution. SUBB A,#data - Subtracts the immediate data from the accumulator with a borrow A: accumulator Data: constant in the range of 0-255 (0-FFh) Description: Instruction subtracts the immediate data from the accumulator with a borrow. If the higher bit is subtracted from the lower bit then the carry flag is set. The result is stored in the accumulator. Syntax: SUBB A,#data; Bytes: 2 (instruction code, data); STATUS register flags: C, OV, AC; EXAMPLE: Before execution: A=C9h, C=0 After execution: A=A7h, C=0 SUBB A,@Ri - Subtracts the indirect RAM from the accumulator with a borrow Ri: register R0 or R1 A: accumulator Description: Instruction subtracts the indirectly addressed register of RAM from the accumulator with a borrow. If the higher bit is subtracted from the lower bit then the carry flag is set. As it is indirect addressing, the register address is stored in the Ri register (R0 or R1). The result is stored in the accumulator. Syntax: SUBB A,@Ri; Byte: 1 (instruction code); STATUS register flags: C, OV, AC; EXAMPLE: Register address: MIN=F4 Before execution: A=C9h, R1=F4h, MIN=04, C=0 After execution: A=C5h, C=0 XCH A,Rn - Exchanges the Rn register with the accumulator Rn: any R register (R0-R7) A: accumulator Description: Instruction causes the accumulator and Rn register to exchange data. The content of the accumulator is moved to the Rn register and vice versa. Syntax: XCH A,Rn; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=C6h, R3=29h After execution: R3=C6h, A=29h SWAP A - Swaps nibbles within the accumulator A: accumulator Description: A nibble refers to a group of 4 bits within one register (bit0-bit3 and bit4-bit7). This instruction interchanges high and low nibbles of the accumulator. Syntax: SWAP A; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=E1h (11100001)bin. After execution: A=1Eh (00011110)bin. XCH A,@Ri - Exchanges the indirect RAM with the accumulator Ri: register R0 or R1 A: accumulator Description: Instruction moves the contents of accumulator to the indirectly addressed register of RAM and vice versa. As it is indirect addressing, the register address is stored in the register Ri (R0 or R1). Syntax: XCH A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register address: SUM=E3 Before execution: R0=E3, SUM=29h, A=98h After execution: A=29h, SUM=98h XCH A,direct - Exchanges the direct byte with the accumulator Direct: arbitrary register with address 0-255 (0-FFh) A: accumulator Description: Instruction moves the contents of the accumulator into the direct byte and vice versa. As it is direct addressing, the direct byte can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). Syntax: XCH A,direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A=FFh, SUM=29h After execution: SUM=FFh A=29h XRL A,Rn - Exclusive OR register to accumulator Rn: any R register (R0-R7) A: accumulator Description: Instruction performs exclusive OR operation between the accumulator and the Rn register. The result is stored in the accumulator. Syntax: XRL A,Rn; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A= C3h (11000011 Bin.) R3= 55h (01010101 Bin.) After execution: A= 96h (10010110 Bin.) XCHD A,@Ri - Exchanges the low-order nibble indirect RAM with the accumulator Ri: register R0 or R1 A: accumulator Description: This instruction interchanges the low-order nibbles (bits 0-3) of the accumulator with the low-order nibbles of the indirectly addressed register of RAM. High-order nibbles of the accumulator and register are not affected. This instruction is mainly used when operating with BCD values. As it is indirect addressing, the register address is stored in the register Ri (R0 or R1). Syntax: XCHD A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register address: SUM=E3 Before execution: R0=E3 SUM=29h A=A8h, After execution: A=A9h, SUM=28h XRL A,@Ri - Exclusive OR indirect RAM to the accumulator Ri: Register R0 or R1 A: accumulator Description: Instruction performs exclusive OR operation between the accumulator and the indirectly addressed register. As it is indirect addressing, the register address is stored in the Ri register (R0 or R1). The result is stored in the accumulator. Syntax: XRL A,@Ri; Byte: 1 (instruction code); STATUS register flags: No flags are affected; EXAMPLE: Register address: TEMP=FAh, R1=FAh Before execution: TEMP= C2h (11000010 Bin.) A= 54h (01010100 Bin.) After execution: A= 96h (10010110 Bin.) XRL A,direct - Exclusive OR direct byte to the accumulator Direct: Arbitrary register with address 0-255 (0-FFh) A: accumulator Description: Instruction performs exclusive OR operation between the accumulator and the direct byte. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the accumulator. Syntax: XRL A,direct; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A= C2h (11000010 Bin.) LOG= 54h (01010100 Bin.) After execution: A= 96h (10010110 Bin.) XRL direct,A - Exclusive OR accumulator to the direct byte Direct: arbitrary register with address 0-255 (0-FFh) A: accumulator Description: Instruction performs exclusive OR operation between the direct byte and the accumulator. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the register. Syntax: XRL direct,A; Bytes: 2 (instruction code, direct byte address); STATUS register flags: No flags affected; EXAMPLE: Before execution: TEMP= C2h (11000010 Bin.) A= 54h (01010100 Bin.) After execution: A= 96h (10010110 Bin.) XRL A,#data - Exclusive OR immediate data to the accumulator Data: constant in the range of 0-255 (0-FFh) A: accumulator Description: Instruction performs exclusive OR operation between the accumulator and the immediate data. The result is stored in the accumulator. Syntax: XRL A,#data; Bytes: 2 (instruction code, data); STATUS register flags: No flags are affected; EXAMPLE: Before execution: A= C2h (11000010 Bin.) X= 11h (00010001 Bin.) After execution: A= D3h (11010011 Bin.) XRL direct,#data - Exclusive OR immediate data to direct byte Direct: arbitrary register with address 0-255 (0-FFh) Data: constant in the range of 0-255 (0-FFh) Description: Instruction performs exclusive OR operation between the immediate data and the direct byte. As it is direct addressing, the register can be any SFRs or general-purpose register with address 0-7Fh (0-127 dec.). The result is stored in the register. Syntax: XRL direct,#data; Bytes: 3 (instruction code, direct byte address, data); STATUS register flags: No flags affected; EXAMPLE: Before execution: TEMP= C2h (11000010 Bin.) X=12h (00010010 Bin.) After execution: A= D0h (11010000 Bin.)