Z80:Control Structures - Revision history

KermMartian at 07:57, 6 February 2016

2016-02-06T07:57:53Z

← Older revision		Revision as of 07:57, 6 February 2016
Line 91:		Line 91:
	After you have set/reset certain flags with the [[Z80:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.		After you have set/reset certain flags with the [[Z80:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.

	To do this, we'll use jump instructions. The jump instructions are [[Z80:Opcodes:JP]] and [[Z80:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[Z80:Flags and Bit-Level Instructions\|flags]] we have changed with the [[Z80:~~Flags and Bit-Level Instructions~~:CP]] instruction.		To do this, we'll use jump instructions. The jump instructions are [[Z80:Opcodes:JP]] and [[Z80:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[Z80:Flags and Bit-Level Instructions\|flags]] we have changed with the [[Z80:Opcodes:CP\|CP]] instruction.

	We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[Z80:Macros:BCALL]], [[Z80:Opcodes:CALL]], and [[Z80:Opcodes:RET]]. Note that [[Z80:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.		We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[Z80:Macros:BCALL]], [[Z80:Opcodes:CALL]], and [[Z80:Opcodes:RET]]. Note that [[Z80:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.

KermMartian at 07:55, 6 February 2016

2016-02-06T07:55:58Z

← Older revision		Revision as of 07:55, 6 February 2016
Line 87:		Line 87:


	The [[Z80:Opcodes:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[Z80:Flags and Bit Level Instructions\|flags]] that are set, depending on the result of the [[Z80:Opcodes:CP]] instruction.		The [[Z80:Opcodes:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[Z80:Flags and Bit-Level Instructions\|flags]] that are set, depending on the result of the [[Z80:Opcodes:CP]] instruction.

	After you have set/reset certain flags with the [[Z80:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.		After you have set/reset certain flags with the [[Z80:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.

	To do this, we'll use jump instructions. The jump instructions are [[Z80:Opcodes:JP]] and [[Z80:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[Z80:Flags and Bit Level Instructions\|flags]] we have changed with the [[Z80:Flags and Bit Level Instructions:CP]] instruction.		To do this, we'll use jump instructions. The jump instructions are [[Z80:Opcodes:JP]] and [[Z80:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[Z80:Flags and Bit-Level Instructions\|flags]] we have changed with the [[Z80:Flags and Bit-Level Instructions:CP]] instruction.

	We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[Z80:Macros:BCALL]], [[Z80:Opcodes:CALL]], and [[Z80:Opcodes:RET]]. Note that [[Z80:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.		We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[Z80:Macros:BCALL]], [[Z80:Opcodes:CALL]], and [[Z80:Opcodes:RET]]. Note that [[Z80:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.

	Another way to test conditions is through [[Z80:Flags and Bit Level Instructions\|Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.		Another way to test conditions is through [[Z80:Flags and Bit-Level Instructions\|Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.

	= Loops =		= Loops =

KermMartian: Adjusted lowercase z80

2016-02-03T20:54:33Z

Adjusted lowercase z80

← Older revision		Revision as of 20:54, 3 February 2016
Line 1:		Line 1:


	= Existing tutorials =		= Existing tutorials =

	* Sigma's [~~http://~~http://media.taricorp.net/83pa28d/lesson/day07.html Learn Assembly in 28 days, Day 7].		* Sigma's [http://media.taricorp.net/83pa28d/lesson/day07.html Learn Assembly in 28 days, Day 7].
	* Iambian's [http://iambianet.freewebpage.org/t/asm06.html Some (z80) Assembly Required Controlling Flow]		* Iambian's [http://iambianet.freewebpage.org/t/asm06.html Some (z80) Assembly Required Controlling Flow]

Line 82:		Line 80:
	=== Program use ===		=== Program use ===

	Much more important is the use of conditions in programs. The z80 processor can handle conditions in 2 fundamental ways. One is to test the accumulator for a certain value. This is done through the [[~~z80~~:Opcodes:CP]] instruction.		Much more important is the use of conditions in programs. The z80 processor can handle conditions in 2 fundamental ways. One is to test the accumulator for a certain value. This is done through the [[Z80:Opcodes:CP]] instruction.


Line 89:		Line 87:


	The [[~~z80~~:Opcodes:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[~~z80~~:Flags and Bit Level Instructions\|flags]] that are set, depending on the result of the [[~~z80~~:Opcodes:CP]] instruction.		The [[Z80:Opcodes:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[Z80:Flags and Bit Level Instructions\|flags]] that are set, depending on the result of the [[Z80:Opcodes:CP]] instruction.

	After you have set/reset certain flags with the [[~~z80~~:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.		After you have set/reset certain flags with the [[Z80:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.

	To do this, we'll use jump instructions. The jump instructions are [[~~z80~~:Opcodes:JP]] and [[~~z80~~:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[~~z80~~:Flags and Bit Level Instructions\|flags]] we have changed with the [[~~z80~~:Flags and Bit Level Instructions:CP]] instruction.		To do this, we'll use jump instructions. The jump instructions are [[Z80:Opcodes:JP]] and [[Z80:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[Z80:Flags and Bit Level Instructions\|flags]] we have changed with the [[Z80:Flags and Bit Level Instructions:CP]] instruction.

	We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[~~z80~~:Macros:BCALL]], [[~~z80~~:Opcodes:CALL]], and [[~~z80~~:Opcodes:RET]]. Note that [[~~z80~~:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.		We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[Z80:Macros:BCALL]], [[Z80:Opcodes:CALL]], and [[Z80:Opcodes:RET]]. Note that [[Z80:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.

	Another way to test conditions is through [[~~z80~~:Flags and Bit Level Instructions\|Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.		Another way to test conditions is through [[Z80:Flags and Bit Level Instructions\|Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.

	= Loops =		= Loops =
Line 149:		Line 147:
	== For ==		== For ==

	A special kind of while loops, for loops are while loops that run on a counter. Lucky for us, the z80 processor has an instruction set specially built in for for loops (not a typo). This instruction is the [[~~z80~~:Opcodes:DJNZ]] instruction. [[~~z80~~:Opcodes:DJNZ]] does these things (in this order):		A special kind of while loops, for loops are while loops that run on a counter. Lucky for us, the z80 processor has an instruction set specially built in for for loops (not a typo). This instruction is the [[Z80:Opcodes:DJNZ]] instruction. [[Z80:Opcodes:DJNZ]] does these things (in this order):
	# Decreases B		# Decreases B
	# Checks if B is zero		# Checks if B is zero
Line 155:		Line 153:
	** Else, jump to specified label		** Else, jump to specified label

	Remember, [[~~z80~~:Opcodes:DJNZ]] decrements first, then jumps if not zero, so if B=0, [[~~z80~~:Opcodes:DJNZ]] will make it equal $FF (256), and since this isn't zero, it will repeat 256 times.		Remember, [[Z80:Opcodes:DJNZ]] decrements first, then jumps if not zero, so if B=0, [[Z80:Opcodes:DJNZ]] will make it equal $FF (256), and since this isn't zero, it will repeat 256 times.

	So, let's create a loop! Please note that this in '''not''' how you should multiply two numbers together, but for our purposes will demonstrate for loops. To learn the more efficient method of multiplication, see [[~~z80~~:Data Manipulation and Basic Math\|this page]].		So, let's create a loop! Please note that this in '''not''' how you should multiply two numbers together, but for our purposes will demonstrate for loops. To learn the more efficient method of multiplication, see [[Z80:Data Manipulation and Basic Math\|this page]].


Line 178:		Line 176:
	= Routines/Procedures =		= Routines/Procedures =

	So, let's say you want a program that performs a certain action at different parts of the code. You could re-type the code, but that's a waste of space, and if you jump to it, how will you know were to jump back to? This creates the idea of routines. A routine is a bunch of code that is called somewhere in the program, and then when it's done running, jumps back. For this, we'll use the [[~~z80~~:Opcodes:CALL]] instruction.		So, let's say you want a program that performs a certain action at different parts of the code. You could re-type the code, but that's a waste of space, and if you jump to it, how will you know were to jump back to? This creates the idea of routines. A routine is a bunch of code that is called somewhere in the program, and then when it's done running, jumps back. For this, we'll use the [[Z80:Opcodes:CALL]] instruction.

	=== What CALL does: ===		=== What CALL does: ===
Line 185:		Line 183:
	# Jumps to a point in memory		# Jumps to a point in memory

	However, at this point we've finished running the routine and want to get back. To get back, we'll use the [[~~z80~~:Opcodes:RET]] instruction.		However, at this point we've finished running the routine and want to get back. To get back, we'll use the [[Z80:Opcodes:RET]] instruction.

	=== What RET does: ===		=== What RET does: ===
Line 192:		Line 190:
	# Jumps to the address stored in the stack		# Jumps to the address stored in the stack

	Don't worry if you don't know what the stack is for now, but if you want, see [[~~z80~~:The Stack\|this page]].		Don't worry if you don't know what the stack is for now, but if you want, see [[Z80:The Stack\|this page]].

	So, let's put it all together now:		So, let's put it all together now:
Line 214:		Line 212:
	# Create code for a while loop that:		# Create code for a while loop that:
	** Checks if the accumulator is bigger than B		** Checks if the accumulator is bigger than B
	*** If it is, increase the accumulator and C (use the [[~~z80~~:Opcodes:INC]] instruction)		*** If it is, increase the accumulator and C (use the [[Z80:Opcodes:INC]] instruction)
	*** If it isn't, decrease the accumulator and C (use the [[~~z80~~:Opcodes:DEC]] instruction)		*** If it isn't, decrease the accumulator and C (use the [[Z80:Opcodes:DEC]] instruction)
	** Keeps doing this until the accumulator equals B		** Keeps doing this until the accumulator equals B

Line 262:		Line 260:


	For answers, see [[~~z80~~:Answers 3\|here]].		For answers, see [[Z80:Answers 3\|here]].

	= Conclusion =		= Conclusion =
Line 269:		Line 267:

	{{lowercase}}		{{lowercase}}
	[[Category:~~z80~~ Assembly]]		[[Category:Z80 Assembly]]
	[[Category:~~z80~~ Heaven]]		[[Category:Z80 Heaven]]

KermMartian: Fixed links to opcodes, macros.

2016-02-03T06:31:39Z

Fixed links to opcodes, macros.

← Older revision		Revision as of 06:31, 3 February 2016
Line 82:		Line 82:
	=== Program use ===		=== Program use ===

	Much more important is the use of conditions in programs. The z80 processor can handle conditions in 2 fundamental ways. One is to test the accumulator for a certain value. This is done through the [[~~instructions-set~~:CP]] instruction.		Much more important is the use of conditions in programs. The z80 processor can handle conditions in 2 fundamental ways. One is to test the accumulator for a certain value. This is done through the [[z80:Opcodes:CP]] instruction.


Line 89:		Line 89:


	The [[~~instructions-set~~:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[~~flags-~~and~~-bit-level-instructions~~ \|flags]] that are set, depending on the result of the [[~~instructions-set~~:CP]] instruction.		The [[z80:Opcodes:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[z80:Flags and Bit Level Instructions\|flags]] that are set, depending on the result of the [[z80:Opcodes:CP]] instruction.

	After you have set/reset certain flags with the [[~~instructions-set~~:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.		After you have set/reset certain flags with the [[z80:Opcodes:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.

	To do this, we'll use jump instructions. The jump instructions are [[~~instructions-set~~:JP]] and [[~~instructions-set~~:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[~~flags-~~and~~-bit-level-instructions~~ \|flags]] we have changed with the [[~~instructions-set~~:CP]] instruction.		To do this, we'll use jump instructions. The jump instructions are [[z80:Opcodes:JP]] and [[z80:Opcodes:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[z80:Flags and Bit Level Instructions\|flags]] we have changed with the [[z80:Flags and Bit Level Instructions:CP]] instruction.

	We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[~~macros~~:BCALL]], [[~~instructions-set~~:CALL]], and [[~~instructions-set~~:RET]]. Note that [[~~macros~~:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.		We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[z80:Macros:BCALL]], [[z80:Opcodes:CALL]], and [[z80:Opcodes:RET]]. Note that [[z80:Macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.

	Another way to test conditions is through [[~~flags-~~and~~-bit-level-instructions~~ \|Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.		Another way to test conditions is through [[z80:Flags and Bit Level Instructions\|Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.

	= Loops =		= Loops =
Line 149:		Line 149:
	== For ==		== For ==

	A special kind of while loops, for loops are while loops that run on a counter. Lucky for us, the z80 processor has an instruction set specially built in for for loops (not a typo). This instruction is the [[~~instructions-set~~:DJNZ]] instruction. [[~~instructions-set~~:DJNZ]] does these things (in this order):		A special kind of while loops, for loops are while loops that run on a counter. Lucky for us, the z80 processor has an instruction set specially built in for for loops (not a typo). This instruction is the [[z80:Opcodes:DJNZ]] instruction. [[z80:Opcodes:DJNZ]] does these things (in this order):
	# Decreases B		# Decreases B
	# Checks if B is zero		# Checks if B is zero
Line 155:		Line 155:
	** Else, jump to specified label		** Else, jump to specified label

	Remember, [[~~instructions-set~~:DJNZ]] decrements first, then jumps if not zero, so if B=0, [[~~instructions-set~~:DJNZ]] will make it equal $FF (256), and since this isn't zero, it will repeat 256 times.		Remember, [[z80:Opcodes:DJNZ]] decrements first, then jumps if not zero, so if B=0, [[z80:Opcodes:DJNZ]] will make it equal $FF (256), and since this isn't zero, it will repeat 256 times.

	So, let's create a loop! Please note that this in '''not''' how you should multiply two numbers together, but for our purposes will demonstrate for loops. To learn the more efficient method of multiplication, see [[~~data-manipulation-~~and~~-basic-math~~ \|this page]].		So, let's create a loop! Please note that this in '''not''' how you should multiply two numbers together, but for our purposes will demonstrate for loops. To learn the more efficient method of multiplication, see [[z80:Data Manipulation and Basic Math\|this page]].


Line 178:		Line 178:
	= Routines/Procedures =		= Routines/Procedures =

	So, let's say you want a program that performs a certain action at different parts of the code. You could re-type the code, but that's a waste of space, and if you jump to it, how will you know were to jump back to? This creates the idea of routines. A routine is a bunch of code that is called somewhere in the program, and then when it's done running, jumps back. For this, we'll use the [[~~instructions-set~~:CALL]] instruction.		So, let's say you want a program that performs a certain action at different parts of the code. You could re-type the code, but that's a waste of space, and if you jump to it, how will you know were to jump back to? This creates the idea of routines. A routine is a bunch of code that is called somewhere in the program, and then when it's done running, jumps back. For this, we'll use the [[z80:Opcodes:CALL]] instruction.

	=== What CALL does: ===		=== What CALL does: ===
Line 185:		Line 185:
	# Jumps to a point in memory		# Jumps to a point in memory

	However, at this point we've finished running the routine and want to get back. To get back, we'll use the [[~~instructions-set~~:RET]] instruction.		However, at this point we've finished running the routine and want to get back. To get back, we'll use the [[z80:Opcodes:RET]] instruction.

	=== What RET does: ===		=== What RET does: ===
Line 192:		Line 192:
	# Jumps to the address stored in the stack		# Jumps to the address stored in the stack

	Don't worry if you don't know what the stack is for now, but if you want, see [[~~the-stack~~ \|this page]].		Don't worry if you don't know what the stack is for now, but if you want, see [[z80:The Stack\|this page]].

	So, let's put it all together now:		So, let's put it all together now:
Line 214:		Line 214:
	# Create code for a while loop that:		# Create code for a while loop that:
	** Checks if the accumulator is bigger than B		** Checks if the accumulator is bigger than B
	*** If it is, increase the accumulator and C (use the [[~~instructions-set~~:INC]] instruction)		*** If it is, increase the accumulator and C (use the [[z80:Opcodes:INC]] instruction)
	*** If it isn't, decrease the accumulator and C (use the [[~~instructions-set~~:DEC]] instruction)		*** If it isn't, decrease the accumulator and C (use the [[z80:Opcodes:DEC]] instruction)
	** Keeps doing this until the accumulator equals B		** Keeps doing this until the accumulator equals B

Line 262:		Line 262:


	For answers, see [[~~answers3~~ \| here]].		For answers, see [[z80:Answers 3\|here]].

	= Conclusion =		= Conclusion =

KermMartian: Created page with " = Existing tutorials = * Sigma's [http://http://media.taricorp.net/83pa28d/lesson/day07.html Learn Assembly in 28 days, Day 7]. * Iambian's [http://iambianet.freewebpage.or..."

2016-02-03T00:53:45Z

Created page with " = Existing tutorials = * Sigma's [http://http://media.taricorp.net/83pa28d/lesson/day07.html Learn Assembly in 28 days, Day 7]. * Iambian's [http://iambianet.freewebpage.or..."

New page

= Existing tutorials =

* Sigma's [http://http://media.taricorp.net/83pa28d/lesson/day07.html Learn Assembly in 28 days, Day 7].
* Iambian's [http://iambianet.freewebpage.org/t/asm06.html Some (z80) Assembly Required Controlling Flow]

If you still don't understand, here's some more information that may help you.

Control structures help you determine the flow of the program. It would be really boring if the code executed each line once from the beginning of the program to the end. We need some variation. Control structures allow you to perform certain actions found elsewhere in the program, allow you to repeatedly perform that action, and also give you control of what conditions must be satisfied before the action is performed.

= If-then-else =

The idea here is this: test a condition. If it is true, then do something. Else, do something else.

== Example ==

If it is sunny,
then go for a walk.
Else do homework.

As you can see, you have a choice of either going on a walk or doing homework. You can't do both at the same time.

== Extension ==

It is also possible to chain if-then-else statements. There are a few ways you can chain, or expand the conditions:

=== Provide extra conditions ===

Self-explanatory, just add on extra conditions that must test to be true.

If it is sunny and I have no homework,
then go for a walk.
Else, do homework.

=== Else-If ===

Similar to tacking on extra conditions, except Else-If tacks on conditions if the initial statement is false.

If it is sunny,
then go for a walk.
Else if I have homework,
then do homework.

=== Then without Else ===

Sometimes, you don't need an else. This is because the other course of action is to do nothing.

If I'm hungry,
then eat something
(else, don't eat)

The stuff in parenthesis is optional, but as you can tell, unnecessary.

It is important to note that there is not an Else without a Then.

== Programming Connection ==

Obviously, testing conditions are a vital part to programming code. If a piece of code is continually run from start to finish without conditions, it's usually not useful in the real world. So, we need to apply this idea of conditions into programming. Z80 has 2 uses conditions:

=== Directives (compiler instruction) ===

These tell the compiler what to do under certain conditions. A common use is to compile a program for many platforms.

#If 83p
.include "ti83plus.inc"
#Else
#If 83
.include "ti83.inc"
#EndIf

=== Program use ===

Much more important is the use of conditions in programs. The z80 processor can handle conditions in 2 fundamental ways. One is to test the accumulator for a certain value. This is done through the [[instructions-set:CP]] instruction.

CP 5 ;compare the accumulator to 5
CP B ;compare the accumulator to the B register

The [[instructions-set:CP]] instruction is telling the processor to subtract the value of the argument (5, or B) from the accumulator. Note that the actual value of the accumulator is not changed, but there are a series of [[flags-and-bit-level-instructions |flags]] that are set, depending on the result of the [[instructions-set:CP]] instruction.

After you have set/reset certain flags with the [[instructions-set:CP]] instruction, you must do something with these flags. Unfortunately, the z80 processor doesn't directly support If-Else, so we need to create or own little work-around.

To do this, we'll use jump instructions. The jump instructions are [[instructions-set:JP]] and [[instructions-set:JR]]. Jump instructions jump to a location in memory, and execute the code at that point. The good part is that jump instructions can also take conditions, based on the [[flags-and-bit-level-instructions |flags]] we have changed with the [[instructions-set:CP]] instruction.

We can also use call instructions. Call instructions are similar to jump instructions with one key difference: you can easily jump back. Call instructions include [[macros:BCALL]], [[instructions-set:CALL]], and [[instructions-set:RET]]. Note that [[macros:BCALL]] is not actually an instruction directly recognized by the z80 processor. Instead, it is a macro that allows the programmer to call certain functions that the manufacturer (Texas Instruments) has coded into the calculator for the Operating System's use, as well as any programs' use.

Another way to test conditions is through [[flags-and-bit-level-instructions |Bit-Masking]]. This is a topic that will be discussed later, but if you want click on the link and it will explain the basics of bit-masking.

= Loops =

What if you want to perform an action repeatedly? You could type the code for the action over and over.

;repeatedly add a number 10 times, aka multiplication

xor a ;initial value
ld b,5 ;what to repeatedly add

add a,b ;add a and b 10 times
add a,b
add a,b
add a,b
add a,b
add a,b
add a,b
add a,b
add a,b
add a,b

However, this presents some problems. One, it's a waste of space if you need to add, say, two numbers together 100 times. It would also be a problem if you want to make the code so that it can add numbers any number of times in the program without having to change the code, only the inputs. Luckily, there are loops. Loops perform a certain action over and over again until certain conditions are met. These are the loop conditions. There are two kinds of loops: for loops, and while loops. They are be discussed in greater detail below.

== While ==

While loops perform an action until a condition is fulfilled, whether a certain key is pressed, a counter reaches a certain number, or any other sort of condition possible.

keyloop: ;keep getting key presses until the enter key is pressed
bcall(_GetKey)
cp kenter
jr nz,keyloop

See the last line of this code? It jumps to a label that gets key presses if the enter key was not pressed. As with regular control statements, it is possible to have multiple conditions for exiting the loop:

keyloop: ;keep getting key presses until either 2nd or enter is pressed
bcall(_GetCSC)
cp skenter
jr z,endloop
cp sk2nd
jr z,endloop
jr keyloop

endloop:

== For ==

A special kind of while loops, for loops are while loops that run on a counter. Lucky for us, the z80 processor has an instruction set specially built in for for loops (not a typo). This instruction is the [[instructions-set:DJNZ]] instruction. [[instructions-set:DJNZ]] does these things (in this order):
# Decreases B
# Checks if B is zero
** If it is, continue on in code
** Else, jump to specified label

Remember, [[instructions-set:DJNZ]] decrements first, then jumps if not zero, so if B=0, [[instructions-set:DJNZ]] will make it equal $FF (256), and since this isn't zero, it will repeat 256 times.

So, let's create a loop! Please note that this in '''not''' how you should multiply two numbers together, but for our purposes will demonstrate for loops. To learn the more efficient method of multiplication, see [[data-manipulation-and-basic-math |this page]].

;multiply
;
;inputs: accumulator=number1
; b=number2
;
;output: accumulator=number1*number2
;
;note: this routine is NOT how you should multiply. It also does not check if the 2nd operand is 0
;
multiply:
ld c,a
xor a
mLoop:
add a,c
djnz mLoop

= Routines/Procedures =

So, let's say you want a program that performs a certain action at different parts of the code. You could re-type the code, but that's a waste of space, and if you jump to it, how will you know were to jump back to? This creates the idea of routines. A routine is a bunch of code that is called somewhere in the program, and then when it's done running, jumps back. For this, we'll use the [[instructions-set:CALL]] instruction.

=== What CALL does: ===

# Pushes the program counter (where the processor is executing code from) onto the stack
# Jumps to a point in memory

However, at this point we've finished running the routine and want to get back. To get back, we'll use the [[instructions-set:RET]] instruction.

=== What RET does: ===

# Pops the stack
# Jumps to the address stored in the stack

Don't worry if you don't know what the stack is for now, but if you want, see [[the-stack |this page]].

So, let's put it all together now:

;Calling a routine
call testRoutine
...

;The routine
testRoutine:
inc a
dec b
ret

= Review =

Time to test your knowledge. See if you can answer these questions.

# Create code for a while loop that:
** Checks if the accumulator is bigger than B
*** If it is, increase the accumulator and C (use the [[instructions-set:INC]] instruction)
*** If it isn't, decrease the accumulator and C (use the [[instructions-set:DEC]] instruction)
** Keeps doing this until the accumulator equals B

== Identify the Error(s) ==
Find the error(s), if any, in each piece of code. They can either be run-time errors or logic errors.

2.

loop:
inc b
add a,b
djnz loop

3.

keyloop:
bcall(_GetKey)

cp kUp
jp mUp ;assume mUp exists somewhere

cp kDown
jp mDown ;assume mDown exists somewhere

jr keyloop

4.

mUp:
inc a
cp 6
jp c,maxUp ;assume maxUp exists somewhere
ret

5.

;
ld b,0 ;Let's repeat 256 times
ld a,6
loop:
dec a
djnz loop

For answers, see [[answers3 | here]].

= Conclusion =

Possible the most powerful thing in programming, control structures will allow you to dictate how to handle events and provide you with a powerful tool that can not be replaced by anything else. There are other parts to control structures, but they require knowledge of advanced topics not discussed here.

{{lowercase}}
[[Category:z80 Assembly]]
[[Category:z80 Heaven]]