Perihelion tutorial 2 - Revision history

>Zchris: Cleaned up some characters that displayed oddly

2012-10-08T10:48:49Z

Cleaned up some characters that displayed oddly

>Wongck at 03:29, 19 February 2012

2012-02-19T03:29:57Z

← Older revision		Revision as of 23:29, 18 February 2012
Line 67:		Line 67:

	Last edited 2002-06-14		Last edited 2002-06-14
			<br/><br/>
			proceed to [[Perihelion tutorial 3]]

	[[Category: Perihelions Atari ST M68000 tutorial]]		[[Category: Perihelions Atari ST M68000 tutorial]]

>Wongck at 14:33, 12 October 2011

2011-10-12T14:33:40Z

← Older revision		Revision as of 10:33, 12 October 2011
Line 67:		Line 67:

	Last edited 2002-06-14		Last edited 2002-06-14
	[[Category:~~Category~~ Perihelions Atari ST M68000 tutorial]]
	~~[[Category:Programming]]~~		[[Category: Perihelions Atari ST M68000 tutorial]]
	~~[[Category:Assembly Language~~]]

>Silver Surfer: clean up

2009-05-03T15:37:28Z

clean up

← Older revision		Revision as of 11:37, 3 May 2009
Line 69:		Line 69:
	[[Category:Category Perihelions Atari ST M68000 tutorial]]		[[Category:Category Perihelions Atari ST M68000 tutorial]]
	[[Category:Programming]]		[[Category:Programming]]
			[[Category:Assembly Language]]

>Silver Surfer: clean up

2009-05-03T15:31:21Z

clean up

← Older revision		Revision as of 11:31, 3 May 2009
Line 1:		Line 1:
	~~[[Category:Category Perihelions Atari ST M68000 tutorial]]~~

	'''The Atari ST M68000 tutorial part 2 â€“ of the workings of Devpac 3 and the realisation of some code'''		'''The Atari ST M68000 tutorial part 2 â€“ of the workings of Devpac 3 and the realisation of some code'''

Line 69:		Line 67:

	Last edited 2002-06-14		Last edited 2002-06-14
			[[Category:Category Perihelions Atari ST M68000 tutorial]]
			[[Category:Programming]]

>Muguk at 13:30, 31 January 2006

2006-01-31T13:30:29Z

>Muguk at 13:29, 31 January 2006

2006-01-31T13:29:28Z

← Older revision		Revision as of 09:29, 31 January 2006
Line 11:		Line 11:
	OK, we have our environment (Devpac) correctly configured, now we want to do something. Remembering the past lesson, we soon realize that to change the background colour, we will have to know what controls the background colour. With this tutorial should be a file called MEMORY.TXT, it's a listing of the ST's memory, great for reference, in it we find the following lines:		OK, we have our environment (Devpac) correctly configured, now we want to do something. Remembering the past lesson, we soon realize that to change the background colour, we will have to know what controls the background colour. With this tutorial should be a file called MEMORY.TXT, it's a listing of the ST's memory, great for reference, in it we find the following lines:

	$FF8240\|word \|Video palette register 0		*$FF8240\|word \|Video palette register 0
	..		*..
	$FF825E\|word \|Video palette register 15		*$FF825E\|word \|Video palette register 15

	As you may know, the ST is capable of displaying 16 colours at once, with a palette of 512 colours. Having a palette means that you donâ€™t have to stay with 16 fixed colours, by changing the palette you can, say have 16 hues of red, and then 16 hues of blue on the next screen. Imagine an artist that can only have 16 colours on each of his paintings, however, he doesnâ€™t have to stick with the same 16 colours each time. OK, it seems that the first colour starts at $ff8240, this is indeed colour 0 and itâ€™s the background colour, so by merely changing the value here, we should change the background colour.		As you may know, the ST is capable of displaying 16 colours at once, with a palette of 512 colours. Having a palette means that you donâ€™t have to stay with 16 fixed colours, by changing the palette you can, say have 16 hues of red, and then 16 hues of blue on the next screen. Imagine an artist that can only have 16 colours on each of his paintings, however, he doesnâ€™t have to stick with the same 16 colours each time. OK, it seems that the first colour starts at $ff8240, this is indeed colour 0 and itâ€™s the background colour, so by merely changing the value here, we should change the background colour.
			*
	I talked about palettes just now, the ST is built on what you call RGB, Red Blue Green, colour. Every colour is made up of 8 levels of Red, Green and Blue, because the computer always counts form 0, the range is between 0 â€“ 7. 8 * 8 * 8 = 512. So, the colour $700 would mean as red as you can get (maximum value of Red, zero value of Green and Blue). $770 would be yellow, $777 would be white and $000 would be black. Equipped with this knowledge we enter this single line as our source code		I talked about palettes just now, the ST is built on what you call RGB, Red Blue Green, colour. Every colour is made up of 8 levels of Red, Green and Blue, because the computer always counts form 0, the range is between 0 â€“ 7. 8 * 8 * 8 = 512. So, the colour $700 would mean as red as you can get (maximum value of Red, zero value of Green and Blue). $770 would be yellow, $777 would be white and $000 would be black. Equipped with this knowledge we enter this single line as our source code
			*
	move.w #$700,$ffff8240 ; red background color		*move.w #$700,$ffff8240 ; red background color
			*
	Move is the command used for moving values around other values, in this case, we move the value #$700 into memory position $ffff8240. The # indicates that what comes after is an absolute value, and the $ means that the value is hexadecimal, instead of decimal (more on this later, accept for now). The .w after the move instruction means that the move instruction should move a word, indicating the size of the thing you want moved (more on this later also, accept for now). So, the line above means in clear (?) English; move a value of word size, an absolute value expressed as a hexadecimal value 700 into the memory address $ffff8240. This should be enough to change the background colour to red.		Move is the command used for moving values around other values, in this case, we move the value #$700 into memory position $ffff8240. The # indicates that what comes after is an absolute value, and the $ means that the value is hexadecimal, instead of decimal (more on this later, accept for now). The .w after the move instruction means that the move instruction should move a word, indicating the size of the thing you want moved (more on this later also, accept for now). So, the line above means in clear (?) English; move a value of word size, an absolute value expressed as a hexadecimal value 700 into the memory address $ffff8240. This should be enough to change the background colour to red.
			*
	Now we want to assemble the source code, and get our executable. Short command for this in Devpac is alt + a. Now, a window will pop up, displaying some statistics, what we want to search for is especially the line â€œ0 errors foundâ€. If there are errors found, the pointer will automatically move to the error so that you can correct it. By pressing alt + number, you can cycle through the available windows. So, if you do get an error, but you donâ€™t understand it, press for example alt + 2, which will take you to the second window, where the error report probably is, try to understand something, then hit alt + 1 to go back and edit your source code. ctrl + w will close a window. Okidok, the source code has compiled successfully, now we need to run it; hit alt + x (eXecute). Now you will be asked to pass parameters to the program, donâ€™t, just hit enter. Ohh, the expectation, will the background change to red?		Now we want to assemble the source code, and get our executable. Short command for this in Devpac is alt + a. Now, a window will pop up, displaying some statistics, what we want to search for is especially the line â€œ0 errors foundâ€. If there are errors found, the pointer will automatically move to the error so that you can correct it. By pressing alt + number, you can cycle through the available windows. So, if you do get an error, but you donâ€™t understand it, press for example alt + 2, which will take you to the second window, where the error report probably is, try to understand something, then hit alt + 1 to go back and edit your source code. ctrl + w will close a window. Okidok, the source code has compiled successfully, now we need to run it; hit alt + x (eXecute). Now you will be asked to pass parameters to the program, donâ€™t, just hit enter. Ohh, the expectation, will the background change to red?
			*
	NO! We get two bombs for all our effort. What the f***? Is there anything wrong with the source code, no, it seems not. Is there anything wrong with the address? Double-checking the address value, no, $ffff8240 means colour 0, which is the background colour.		NO! We get two bombs for all our effort. What the f***? Is there anything wrong with the source code, no, it seems not. Is there anything wrong with the address? Double-checking the address value, no, $ffff8240 means colour 0, which is the background colour.
			*
	Well, the ST can operate in two modes, user and super mode. In the user mode, we arenâ€™t allowed to access certain things in memory, for example the palette, the result if we try to do this is two bombs. So we need to go into super mode. Referring to a list of the so called trap functions of GEMDOS, ideally the ST Internals, we find out how to enter super mode, the code looks like this:		Well, the ST can operate in two modes, user and super mode. In the user mode, we arenâ€™t allowed to access certain things in memory, for example the palette, the result if we try to do this is two bombs. So we need to go into super mode. Referring to a list of the so called trap functions of GEMDOS, ideally the ST Internals, we find out how to enter super mode, the code looks like this:
			*
			* clr.l -(a7) clear stack
	clr.l -(a7) clear stack		* move.w #32,-(a7) prepare for super mode
	move.w #32,-(a7) prepare for super mode		* trap #1 call gemdos
	trap #1 call gemdos		* addq.l #6,a7 clear up stack
	addq.l #6,a7 clear up stack		* move.l d0,old_stack backup old stack pointer
	move.l d0,old_stack backup old stack pointer		*

	''(ok, so the code looks somewhat different than in ST Internals, a good lesson for you that you can write differently, but still achieve the same)''		''(ok, so the code looks somewhat different than in ST Internals, a good lesson for you that you can write differently, but still achieve the same)''
			*
	Perhaps I shouldnâ€™t go to deeply into this, it will come in the next tutorial where Iâ€™ll take up the different registers and talk about traps and so on. For now, youâ€™ll just have to accept it, but for you curious types, hereâ€™s a short one.		Perhaps I shouldnâ€™t go to deeply into this, it will come in the next tutorial where Iâ€™ll take up the different registers and talk about traps and so on. For now, youâ€™ll just have to accept it, but for you curious types, hereâ€™s a short one.
			*
	The GEMDOS have several special functions, which are accessed by the trap #1 command (calling trap #13 calls BIOS functions). The controlling value is put on the stack, which is address register a7 (you can also type sp, short for stack pointer, instead of a7). The move.l d0, old_stack is for backing up the old user stack, that gets replaced when we go into super mode.		The GEMDOS have several special functions, which are accessed by the trap #1 command (calling trap #13 calls BIOS functions). The controlling value is put on the stack, which is address register a7 (you can also type sp, short for stack pointer, instead of a7). The move.l d0, old_stack is for backing up the old user stack, that gets replaced when we go into super mode.
			*
	This code obviously goes at the top of our source code, the first thing we want is to go into super mode, then we put red colour in palette register 0, lastly, we want to go back into user mode and also add another two lines of accept now, understand later code, which will make a clean exit of the program. The total code looks like this:		This code obviously goes at the top of our source code, the first thing we want is to go into super mode, then we put red colour in palette register 0, lastly, we want to go back into user mode and also add another two lines of accept now, understand later code, which will make a clean exit of the program. The total code looks like this:
			*
			* clr.l -(a7) clear stack
	clr.l -(a7) clear stack		* move.w #32,-(a7) prepare for super mode
	move.w #32,-(a7) prepare for super mode		* trap #1 call gemdos
	trap #1 call gemdos		* addq.l #6,a7 clear up stack
	addq.l #6,a7 clear up stack		* move.l d0,old_stack backup old stack pointer
	move.l d0,old_stack backup old stack pointer		*
			* move.w #$700,$ffff8240 red background color
	move.w #$700,$ffff8240 red background color		* move.l old_stack,-(a7) restore old stack pointer
	move.l old_stack,-(a7) restore old stack pointer		* move.w #32,-(a7) back to user mode
	move.w #32,-(a7) back to user mode		* trap #1 call gemdos
	trap #1 call gemdos		* addq.l #6,a7 clear stack
	addq.l #6,a7 clear stack		*
			* clr.l -(a7) clean exit
	clr.l -(a7) clean exit		* trap #1 call gemdos
	trap #1 call gemdos		*
			*old_stack dc.l 0
	old_stack dc.l 0		*

	Running this program will successfully change the background colour to red, and then make a nice and clean exit, restoring the Atari to user mode once again. Problem is, we now have a red background. Not to good you might think. This can be easily remedied however, we have made a program that changes background colour, letâ€™s use it! Change the value #$700 to #$777 and run the program again. The background colour will now be white as snow, like weâ€™re used to.		Running this program will successfully change the background colour to red, and then make a nice and clean exit, restoring the Atari to user mode once again. Problem is, we now have a red background. Not to good you might think. This can be easily remedied however, we have made a program that changes background colour, letâ€™s use it! Change the value #$700 to #$777 and run the program again. The background colour will now be white as snow, like weâ€™re used to.

	In the next tutorial, I plan to cover hexadecimal, binary and decimal numbers, program flow and talk some about traps and registers.		In the next tutorial, I plan to cover hexadecimal, binary and decimal numbers, program flow and talk some about traps and registers.
			*
			*
	Warrior Munk of poSTmortem, 2002-04-02		Warrior Munk of poSTmortem, 2002-04-02
	''â€œNo immovable roots, no stirring of dust, only the tao; the way of nature. This is called tai chi.â€'' - Tai Chi Master		''â€œNo immovable roots, no stirring of dust, only the tao; the way of nature. This is called tai chi.â€'' - Tai Chi Master

	Last edited 2002-06-14		Last edited 2002-06-14

>Muguk at 13:28, 31 January 2006

2006-01-31T13:28:11Z

Show changes

>Admin at 23:05, 30 January 2006

2006-01-30T23:05:00Z

Show changes

>Admin at 22:40, 30 January 2006

2006-01-30T22:40:38Z

← Older revision		Revision as of 18:40, 30 January 2006
Line 1:		Line 1:
	<table border="0" width="70%">		[[Category:Category Perihelions Atari ST M68000 tutorial]]

			<table border="0" width="70%">
	<tr>		<tr>
	<td width="100%">		<td width="100%">

← Older revision		Revision as of 06:48, 8 October 2012
Line 1:		Line 1:
	'''The Atari ST M68000 tutorial part 2 ~~â€“~~ of the workings of Devpac 3 and the realisation of some code'''		'''The Atari ST M68000 tutorial part 2 of the workings of Devpac 3 and the realisation of some code'''

	Hello again. ~~Itâ€™s~~ only been some days since the last tutorial, but ~~Iâ€™m~~ bored right now and I ~~donâ€™t~~ have any computer game I feel like playing. This weekend went great, as it was GothCon (game convention here in ~~GÃ¶teborg~~, Sweden) which meant games were afoot. I met Aldebaran for the first time IRL and he demonstrated the game Illuminati, which I plan to play later on this evening. But you ~~donâ€™t~~ really want to listen to that, do you?		Hello again. It's only been some days since the last tutorial, but I'm bored right now and I don't have any computer game I feel like playing. This weekend went great, as it was GothCon (game convention here in Göteborg, Sweden) which meant games were afoot. I met Aldebaran for the first time IRL and he demonstrated the game Illuminati, which I plan to play later on this evening. But you don't really want to listen to that, do you?

	In the last tutorial, we went through some basic theory behind programming, and now we are going to put that theory into practice. We want to do something so awfully cool as to change the background colour to something else. First, we need to gather and learn how to use the tools. The tools in this case are only one; Devpac 3.00 by HiSoft. It can be acquired from Pompey Pirates CD #114, other places, or perhaps you can even buy it :)		In the last tutorial, we went through some basic theory behind programming, and now we are going to put that theory into practice. We want to do something so awfully cool as to change the background colour to something else. First, we need to gather and learn how to use the tools. The tools in this case are only one; Devpac 3.00 by HiSoft. It can be acquired from Pompey Pirates CD #114, other places, or perhaps you can even buy it :)

	Once we start up Devpac, we want to change some settings to make our lives easier. Go into options ~~â€“~~ control, under the setting format, select ST RAM, depending on your memory size, you may also wish to change the memory buffer. The only two interesting settings here are ST RAM and Atari Executable. If you choose Atari Executable, you will get a .prg file every time you assemble (also known as compile) your source code, so in order to test your source code, you will have to quit Devpac, and run the .prg file, then start Devpac again; enormously clumsy. Instead, we put the .prg file directly into the ST RAM (memory, RAM stands for Random Access Memory), from where it can be executed directly. So for now, set the setting to ST RAM. ~~Itâ€™s~~ only when you are done coding something, that you will want to change this setting to Atari Executable in order to get a normal .prg file. Go into options ~~â€“~~ options, and uncheck the ~~â€œCheck~~ absolutes for missing #~~â€~~. This eliminates lots of error reports than usually ~~arenâ€™t~~ error reports. In the options ~~â€“~~ environment you can set the environment variables, if you run from diskette, they should probably be something like PATH=a:\bin, INCDIR=a:\incdir. Go into options ~~â€“~~ resident and make sure both Assembler and Debugger are checked, this will also save you lots of time if you have the memory (since I run on 4 megs, I ~~donâ€™t~~ have to worry). ~~Thatâ€™s~~ about it I think, you can play around with settings on your own if you like, but these are essentials in my opinion.		Once we start up Devpac, we want to change some settings to make our lives easier. Go into options - control, under the setting format, select ST RAM, depending on your memory size, you may also wish to change the memory buffer. The only two interesting settings here are ST RAM and Atari Executable. If you choose Atari Executable, you will get a .prg file every time you assemble (also known as compile) your source code, so in order to test your source code, you will have to quit Devpac, and run the .prg file, then start Devpac again; enormously clumsy. Instead, we put the .prg file directly into the ST RAM (memory, RAM stands for Random Access Memory), from where it can be executed directly. So for now, set the setting to ST RAM. It's only when you are done coding something, that you will want to change this setting to Atari Executable in order to get a normal .prg file. Go into options - options, and uncheck the "Check absolutes for missing #". This eliminates lots of error reports than usually aren't error reports. In the options - environment you can set the environment variables, if you run from diskette, they should probably be something like PATH=a:\bin, INCDIR=a:\incdir. Go into options - resident and make sure both Assembler and Debugger are checked, this will also save you lots of time if you have the memory (since I run on 4 megs, I don't have to worry). That's about it I think, you can play around with settings on your own if you like, but these are essentials in my opinion.

	OK, we have our environment (Devpac) correctly configured, now we want to do something. Remembering the past lesson, we soon realize that to change the background colour, we will have to know what controls the background colour. With this tutorial should be a file called MEMORY.TXT, it's a listing of the ST's memory, great for reference, in it we find the following lines:		OK, we have our environment (Devpac) correctly configured, now we want to do something. Remembering the past lesson, we soon realize that to change the background colour, we will have to know what controls the background colour. With this tutorial should be a file called MEMORY.TXT, it's a listing of the ST's memory, great for reference, in it we find the following lines:
Line 13:		Line 13:
	*$FF825E\|word \|Video palette register 15		*$FF825E\|word \|Video palette register 15

	As you may know, the ST is capable of displaying 16 colours at once, with a palette of 512 colours. Having a palette means that you ~~donâ€™t~~ have to stay with 16 fixed colours, by changing the palette you can, say have 16 hues of red, and then 16 hues of blue on the next screen. Imagine an artist that can only have 16 colours on each of his paintings, however, he ~~doesnâ€™t~~ have to stick with the same 16 colours each time. OK, it seems that the first colour starts at $ff8240, this is indeed colour 0 and ~~itâ€™s~~ the background colour, so by merely changing the value here, we should change the background colour.		As you may know, the ST is capable of displaying 16 colours at once, with a palette of 512 colours. Having a palette means that you don't have to stay with 16 fixed colours, by changing the palette you can, say have 16 hues of red, and then 16 hues of blue on the next screen. Imagine an artist that can only have 16 colours on each of his paintings, however, he doesn't have to stick with the same 16 colours each time. OK, it seems that the first colour starts at $ff8240, this is indeed colour 0 and it's the background colour, so by merely changing the value here, we should change the background colour.

	I talked about palettes just now, the ST is built on what you call RGB, Red Blue Green, colour. Every colour is made up of 8 levels of Red, Green and Blue, because the computer always counts form 0, the range is between 0 ~~â€“~~ 7. 8 * 8 * 8 = 512. So, the colour $700 would mean as red as you can get (maximum value of Red, zero value of Green and Blue). $770 would be yellow, $777 would be white and $000 would be black. Equipped with this knowledge we enter this single line as our source code		I talked about palettes just now, the ST is built on what you call RGB, Red Blue Green, colour. Every colour is made up of 8 levels of Red, Green and Blue, because the computer always counts form 0, the range is between 0 - 7. 8 * 8 * 8 = 512. So, the colour $700 would mean as red as you can get (maximum value of Red, zero value of Green and Blue). $770 would be yellow, $777 would be white and $000 would be black. Equipped with this knowledge we enter this single line as our source code

	*move.w #$700,$ffff8240 ; red background color		*move.w #$700,$ffff8240 ; red background color
Line 21:		Line 21:
	Move is the command used for moving values around other values, in this case, we move the value #$700 into memory position $ffff8240. The # indicates that what comes after is an absolute value, and the $ means that the value is hexadecimal, instead of decimal (more on this later, accept for now). The .w after the move instruction means that the move instruction should move a word, indicating the size of the thing you want moved (more on this later also, accept for now). So, the line above means in clear (?) English; move a value of word size, an absolute value expressed as a hexadecimal value 700 into the memory address $ffff8240. This should be enough to change the background colour to red.		Move is the command used for moving values around other values, in this case, we move the value #$700 into memory position $ffff8240. The # indicates that what comes after is an absolute value, and the $ means that the value is hexadecimal, instead of decimal (more on this later, accept for now). The .w after the move instruction means that the move instruction should move a word, indicating the size of the thing you want moved (more on this later also, accept for now). So, the line above means in clear (?) English; move a value of word size, an absolute value expressed as a hexadecimal value 700 into the memory address $ffff8240. This should be enough to change the background colour to red.

	Now we want to assemble the source code, and get our executable. Short command for this in Devpac is alt + a. Now, a window will pop up, displaying some statistics, what we want to search for is especially the line ~~â€œ0~~ errors ~~foundâ€~~. If there are errors found, the pointer will automatically move to the error so that you can correct it. By pressing alt + number, you can cycle through the available windows. So, if you do get an error, but you ~~donâ€™t~~ understand it, press for example alt + 2, which will take you to the second window, where the error report probably is, try to understand something, then hit alt + 1 to go back and edit your source code. ctrl + w will close a window. Okidok, the source code has compiled successfully, now we need to run it; hit alt + x (eXecute). Now you will be asked to pass parameters to the program, ~~donâ€™t~~, just hit enter. Ohh, the expectation, will the background change to red?		Now we want to assemble the source code, and get our executable. Short command for this in Devpac is alt + a. Now, a window will pop up, displaying some statistics, what we want to search for is especially the line "0 errors found". If there are errors found, the pointer will automatically move to the error so that you can correct it. By pressing alt + number, you can cycle through the available windows. So, if you do get an error, but you don't understand it, press for example alt + 2, which will take you to the second window, where the error report probably is, try to understand something, then hit alt + 1 to go back and edit your source code. ctrl + w will close a window. Okidok, the source code has compiled successfully, now we need to run it; hit alt + x (eXecute). Now you will be asked to pass parameters to the program, don't, just hit enter. Ohh, the expectation, will the background change to red?

	NO! We get two bombs for all our effort. What the f***? Is there anything wrong with the source code, no, it seems not. Is there anything wrong with the address? Double-checking the address value, no, $ffff8240 means colour 0, which is the background colour.		NO! We get two bombs for all our effort. What the f***? Is there anything wrong with the source code, no, it seems not. Is there anything wrong with the address? Double-checking the address value, no, $ffff8240 means colour 0, which is the background colour.

	Well, the ST can operate in two modes, user and super mode. In the user mode, we ~~arenâ€™t~~ allowed to access certain things in memory, for example the palette, the result if we try to do this is two bombs. So we need to go into super mode. Referring to a list of the so called trap functions of GEMDOS, ideally the ST Internals, we find out how to enter super mode, the code looks like this:		Well, the ST can operate in two modes, user and super mode. In the user mode, we aren't allowed to access certain things in memory, for example the palette, the result if we try to do this is two bombs. So we need to go into super mode. Referring to a list of the so called trap functions of GEMDOS, ideally the ST Internals, we find out how to enter super mode, the code looks like this:

	* clr.l -(a7) clear stack		* clr.l -(a7) clear stack
Line 35:		Line 35:
	''(ok, so the code looks somewhat different than in ST Internals, a good lesson for you that you can write differently, but still achieve the same)''		''(ok, so the code looks somewhat different than in ST Internals, a good lesson for you that you can write differently, but still achieve the same)''

	Perhaps I ~~shouldnâ€™t~~ go to deeply into this, it will come in the next tutorial where ~~Iâ€™ll~~ take up the different registers and talk about traps and so on. For now, ~~youâ€™ll~~ just have to accept it, but for you curious types, ~~hereâ€™s~~ a short one.		Perhaps I shouldn't go to deeply into this, it will come in the next tutorial where I'll take up the different registers and talk about traps and so on. For now, you'll just have to accept it, but for you curious types, here's a short one.

	The GEMDOS have several special functions, which are accessed by the trap #1 command (calling trap #13 calls BIOS functions). The controlling value is put on the stack, which is address register a7 (you can also type sp, short for stack pointer, instead of a7). The move.l d0, old_stack is for backing up the old user stack, that gets replaced when we go into super mode.		The GEMDOS have several special functions, which are accessed by the trap #1 command (calling trap #13 calls BIOS functions). The controlling value is put on the stack, which is address register a7 (you can also type sp, short for stack pointer, instead of a7). The move.l d0, old_stack is for backing up the old user stack, that gets replaced when we go into super mode.
Line 58:		Line 58:
	*old_stack dc.l 0		*old_stack dc.l 0

	Running this program will successfully change the background colour to red, and then make a nice and clean exit, restoring the Atari to user mode once again. Problem is, we now have a red background. Not to good you might think. This can be easily remedied however, we have made a program that changes background colour, ~~letâ€™s~~ use it! Change the value #$700 to #$777 and run the program again. The background colour will now be white as snow, like ~~weâ€™re~~ used to.		Running this program will successfully change the background colour to red, and then make a nice and clean exit, restoring the Atari to user mode once again. Problem is, we now have a red background. Not to good you might think. This can be easily remedied however, we have made a program that changes background colour, let's use it! Change the value #$700 to #$777 and run the program again. The background colour will now be white as snow, like we're used to.

	In the next tutorial, I plan to cover hexadecimal, binary and decimal numbers, program flow and talk some about traps and registers.		In the next tutorial, I plan to cover hexadecimal, binary and decimal numbers, program flow and talk some about traps and registers.
Line 64:		Line 64:

	Warrior Munk of poSTmortem, 2002-04-02		Warrior Munk of poSTmortem, 2002-04-02
	''~~â€œNo~~ immovable roots, no stirring of dust, only the tao; the way of nature. This is called tai chi.~~â€~~'' - Tai Chi Master		''"No immovable roots, no stirring of dust, only the tao; the way of nature. This is called tai chi."'' - Tai Chi Master

	Last edited 2002-06-14		Last edited 2002-06-14

← Older revision		Revision as of 09:30, 31 January 2006
Line 12:		Line 12:

	*$FF8240\|word \|Video palette register 0		*$FF8240\|word \|Video palette register 0
	*..		..
	*$FF825E\|word \|Video palette register 15		*$FF825E\|word \|Video palette register 15

	As you may know, the ST is capable of displaying 16 colours at once, with a palette of 512 colours. Having a palette means that you donâ€™t have to stay with 16 fixed colours, by changing the palette you can, say have 16 hues of red, and then 16 hues of blue on the next screen. Imagine an artist that can only have 16 colours on each of his paintings, however, he doesnâ€™t have to stick with the same 16 colours each time. OK, it seems that the first colour starts at $ff8240, this is indeed colour 0 and itâ€™s the background colour, so by merely changing the value here, we should change the background colour.		As you may know, the ST is capable of displaying 16 colours at once, with a palette of 512 colours. Having a palette means that you donâ€™t have to stay with 16 fixed colours, by changing the palette you can, say have 16 hues of red, and then 16 hues of blue on the next screen. Imagine an artist that can only have 16 colours on each of his paintings, however, he doesnâ€™t have to stick with the same 16 colours each time. OK, it seems that the first colour starts at $ff8240, this is indeed colour 0 and itâ€™s the background colour, so by merely changing the value here, we should change the background colour.
	*
	I talked about palettes just now, the ST is built on what you call RGB, Red Blue Green, colour. Every colour is made up of 8 levels of Red, Green and Blue, because the computer always counts form 0, the range is between 0 â€“ 7. 8 * 8 * 8 = 512. So, the colour $700 would mean as red as you can get (maximum value of Red, zero value of Green and Blue). $770 would be yellow, $777 would be white and $000 would be black. Equipped with this knowledge we enter this single line as our source code		I talked about palettes just now, the ST is built on what you call RGB, Red Blue Green, colour. Every colour is made up of 8 levels of Red, Green and Blue, because the computer always counts form 0, the range is between 0 â€“ 7. 8 * 8 * 8 = 512. So, the colour $700 would mean as red as you can get (maximum value of Red, zero value of Green and Blue). $770 would be yellow, $777 would be white and $000 would be black. Equipped with this knowledge we enter this single line as our source code
	*
	*move.w #$700,$ffff8240 ; red background color		*move.w #$700,$ffff8240 ; red background color
	*
	Move is the command used for moving values around other values, in this case, we move the value #$700 into memory position $ffff8240. The # indicates that what comes after is an absolute value, and the $ means that the value is hexadecimal, instead of decimal (more on this later, accept for now). The .w after the move instruction means that the move instruction should move a word, indicating the size of the thing you want moved (more on this later also, accept for now). So, the line above means in clear (?) English; move a value of word size, an absolute value expressed as a hexadecimal value 700 into the memory address $ffff8240. This should be enough to change the background colour to red.		Move is the command used for moving values around other values, in this case, we move the value #$700 into memory position $ffff8240. The # indicates that what comes after is an absolute value, and the $ means that the value is hexadecimal, instead of decimal (more on this later, accept for now). The .w after the move instruction means that the move instruction should move a word, indicating the size of the thing you want moved (more on this later also, accept for now). So, the line above means in clear (?) English; move a value of word size, an absolute value expressed as a hexadecimal value 700 into the memory address $ffff8240. This should be enough to change the background colour to red.
	*
	Now we want to assemble the source code, and get our executable. Short command for this in Devpac is alt + a. Now, a window will pop up, displaying some statistics, what we want to search for is especially the line â€œ0 errors foundâ€. If there are errors found, the pointer will automatically move to the error so that you can correct it. By pressing alt + number, you can cycle through the available windows. So, if you do get an error, but you donâ€™t understand it, press for example alt + 2, which will take you to the second window, where the error report probably is, try to understand something, then hit alt + 1 to go back and edit your source code. ctrl + w will close a window. Okidok, the source code has compiled successfully, now we need to run it; hit alt + x (eXecute). Now you will be asked to pass parameters to the program, donâ€™t, just hit enter. Ohh, the expectation, will the background change to red?		Now we want to assemble the source code, and get our executable. Short command for this in Devpac is alt + a. Now, a window will pop up, displaying some statistics, what we want to search for is especially the line â€œ0 errors foundâ€. If there are errors found, the pointer will automatically move to the error so that you can correct it. By pressing alt + number, you can cycle through the available windows. So, if you do get an error, but you donâ€™t understand it, press for example alt + 2, which will take you to the second window, where the error report probably is, try to understand something, then hit alt + 1 to go back and edit your source code. ctrl + w will close a window. Okidok, the source code has compiled successfully, now we need to run it; hit alt + x (eXecute). Now you will be asked to pass parameters to the program, donâ€™t, just hit enter. Ohh, the expectation, will the background change to red?
	*
	NO! We get two bombs for all our effort. What the f***? Is there anything wrong with the source code, no, it seems not. Is there anything wrong with the address? Double-checking the address value, no, $ffff8240 means colour 0, which is the background colour.		NO! We get two bombs for all our effort. What the f***? Is there anything wrong with the source code, no, it seems not. Is there anything wrong with the address? Double-checking the address value, no, $ffff8240 means colour 0, which is the background colour.
	*
	Well, the ST can operate in two modes, user and super mode. In the user mode, we arenâ€™t allowed to access certain things in memory, for example the palette, the result if we try to do this is two bombs. So we need to go into super mode. Referring to a list of the so called trap functions of GEMDOS, ideally the ST Internals, we find out how to enter super mode, the code looks like this:		Well, the ST can operate in two modes, user and super mode. In the user mode, we arenâ€™t allowed to access certain things in memory, for example the palette, the result if we try to do this is two bombs. So we need to go into super mode. Referring to a list of the so called trap functions of GEMDOS, ideally the ST Internals, we find out how to enter super mode, the code looks like this:
	*
	* clr.l -(a7) clear stack		* clr.l -(a7) clear stack
	* move.w #32,-(a7) prepare for super mode		* move.w #32,-(a7) prepare for super mode
Line 34:		Line 34:
	* addq.l #6,a7 clear up stack		* addq.l #6,a7 clear up stack
	* move.l d0,old_stack backup old stack pointer		* move.l d0,old_stack backup old stack pointer
	*
	''(ok, so the code looks somewhat different than in ST Internals, a good lesson for you that you can write differently, but still achieve the same)''		''(ok, so the code looks somewhat different than in ST Internals, a good lesson for you that you can write differently, but still achieve the same)''
	*
	Perhaps I shouldnâ€™t go to deeply into this, it will come in the next tutorial where Iâ€™ll take up the different registers and talk about traps and so on. For now, youâ€™ll just have to accept it, but for you curious types, hereâ€™s a short one.		Perhaps I shouldnâ€™t go to deeply into this, it will come in the next tutorial where Iâ€™ll take up the different registers and talk about traps and so on. For now, youâ€™ll just have to accept it, but for you curious types, hereâ€™s a short one.
	*
	The GEMDOS have several special functions, which are accessed by the trap #1 command (calling trap #13 calls BIOS functions). The controlling value is put on the stack, which is address register a7 (you can also type sp, short for stack pointer, instead of a7). The move.l d0, old_stack is for backing up the old user stack, that gets replaced when we go into super mode.		The GEMDOS have several special functions, which are accessed by the trap #1 command (calling trap #13 calls BIOS functions). The controlling value is put on the stack, which is address register a7 (you can also type sp, short for stack pointer, instead of a7). The move.l d0, old_stack is for backing up the old user stack, that gets replaced when we go into super mode.
	*
	This code obviously goes at the top of our source code, the first thing we want is to go into super mode, then we put red colour in palette register 0, lastly, we want to go back into user mode and also add another two lines of accept now, understand later code, which will make a clean exit of the program. The total code looks like this:		This code obviously goes at the top of our source code, the first thing we want is to go into super mode, then we put red colour in palette register 0, lastly, we want to go back into user mode and also add another two lines of accept now, understand later code, which will make a clean exit of the program. The total code looks like this:
	*
	* clr.l -(a7) clear stack		* clr.l -(a7) clear stack
	* move.w #32,-(a7) prepare for super mode		* move.w #32,-(a7) prepare for super mode
Line 48:		Line 48:
	* addq.l #6,a7 clear up stack		* addq.l #6,a7 clear up stack
	* move.l d0,old_stack backup old stack pointer		* move.l d0,old_stack backup old stack pointer
	*
	* move.w #$700,$ffff8240 red background color		* move.w #$700,$ffff8240 red background color
	* move.l old_stack,-(a7) restore old stack pointer		* move.l old_stack,-(a7) restore old stack pointer
Line 54:		Line 54:
	* trap #1 call gemdos		* trap #1 call gemdos
	* addq.l #6,a7 clear stack		* addq.l #6,a7 clear stack
	*
	* clr.l -(a7) clean exit		* clr.l -(a7) clean exit
	* trap #1 call gemdos		* trap #1 call gemdos
	*		*
	*old_stack dc.l 0		*old_stack dc.l 0
	*
	Running this program will successfully change the background colour to red, and then make a nice and clean exit, restoring the Atari to user mode once again. Problem is, we now have a red background. Not to good you might think. This can be easily remedied however, we have made a program that changes background colour, letâ€™s use it! Change the value #$700 to #$777 and run the program again. The background colour will now be white as snow, like weâ€™re used to.		Running this program will successfully change the background colour to red, and then make a nice and clean exit, restoring the Atari to user mode once again. Problem is, we now have a red background. Not to good you might think. This can be easily remedied however, we have made a program that changes background colour, letâ€™s use it! Change the value #$700 to #$777 and run the program again. The background colour will now be white as snow, like weâ€™re used to.

	In the next tutorial, I plan to cover hexadecimal, binary and decimal numbers, program flow and talk some about traps and registers.		In the next tutorial, I plan to cover hexadecimal, binary and decimal numbers, program flow and talk some about traps and registers.
	*
	*
	Warrior Munk of poSTmortem, 2002-04-02		Warrior Munk of poSTmortem, 2002-04-02
	''â€œNo immovable roots, no stirring of dust, only the tao; the way of nature. This is called tai chi.â€'' - Tai Chi Master		''â€œNo immovable roots, no stirring of dust, only the tao; the way of nature. This is called tai chi.â€'' - Tai Chi Master

	Last edited 2002-06-14		Last edited 2002-06-14