WikiTI - User contributions [en]

83Plus:Basic:Tricks

2006-12-11T10:45:16Z

RobbieMc: Added more to the "Get rid of the "Done" section

[[Category:83Plus:Basic|Tricks]]

There is a whole list of tricks that one can implement, once one is comfortable programming in TI-Basic which allow for a whole onslaught of capabilities, such as using less memory or making the program run faster. There used to be a site called Kevtiva Inc. which had the largest list of TI-BASIC hacks I (Saibot84) have ever seen, including how to force a RAM reset (without the use of asm programs) but I've forgotten most of the meanest hacks. Here are some of the many tricks: (Please use common sense in deciding whether a "-" is a minus or a negative sign. When the use is un-common-sense-ical or possibly confusing, it will be specified.)

__TOC__

==Memory==
===Memory Management===
;Number values:In order to be able to save memory on the calculator, it helps to have a bit of an understanding as to how the calc manages the memory, especially in regards to numbers. Because TIOS is designed for school, and so is oriented for precision, it saves all real number values as 14-digits and an exponent of 10. In other words, it saves the number π as 3.1415926535898 × 100, but in memory, it is something more similar (not exact) to <code>0 31415926535898</code> where the 0 tells TIOS what the exponent of 10 is that need to be applied to the 31415926535898. However, this also applies to smaller values, such that a 13 is saved as <code>1 13000000000000</code>. For small, rational, terminating values, it can be seen that a good deal of memory is being wasted. I've created the following formula which, when saved to Y0 (or any other Y function, works with numbers in the same way that the sub( function works with strings:
int(fPart(X/10^(int(2-A+log(X))))*10^(F))
:translated as a sub( statement, it would be the equivalent of sub(X,A,F) regardless of the position of the decimal point in X. If you don't understand what the formula is doing, it's dividing X by 10value so that the digit we're looking for (identified in A) is "moved" to be the first digit to the right of the decimal point, then ignores anything to the left or the decimal piont, then multiplies the value left over by 10F and ignores anything to the right of the decimal point, thus providing the sub(X,A,F).
;use more than 27 vars:If you need to use more than the 27 vars TIOS gives you with A-Z, other than using lists, matrices, strings, or Ans, you can go look in the [VARS] menu under Window. Of these, being that the calculator is usually in function mode, you can use any of the window vars under T/theta (which are for parametric mode) and/or under U/V/W (which are for polar). It is recommended that you prefer those under U/V/W because this mode is usually never used, whereas parametric has been used on more than one occasion by programs, such as for drawing X in terms of Y. You can also go into the Finance menu under [APPS] and go to Vars, but IIRC, some are read-only vars, so you will need to experiment to see if a var is accessible or not, but it is certain, that at least the '''N''' can be used problemlessly in your programs. You can also use the ''n'', which is found by going to the catalog and pressing "N" as a variable, as well as the sequential functions u,v, and w.
;Debugging:One of the easiest ways to help you debug your program is through the use of the Pause command. You can use the Pause command to display the value of a var, or just to track the progress of your program. During any of the Pause commands, you can press [ON] to break the program and choose Goto so that the calc will automatically bring you to the point in your program where it was Pause-ing when you interrupted it with the [ON] key. Some common bugs include using the Y var or the X var while drawing to the screen (TIOS tends to change the value of Y and/or X when doing certain things on the graph screen, so avoid using Y or X when working on the graph screen.

===Memory Saving===
;Never write out closing ''')''' parentheses at the end of a line:You save '''1''' byte. The reason for this is that TIOS closes all still-open parentheses when it encounters $3F, which is the new-line character that is input when you press enter in the Program Editor, or when it encounters the store arrow.
;Never write out closing '''"''' quotes at the end of a line: You save '''1''' byte. The reason for this is that TIOS closes any still-open quotes when it encounters $3F, which is the new-line character that is input when you press enter in the Program Editor, or when it encounters the store arrow.
;Never use a Pause right after a Disp, unless the Pause has text:This is because both Disp and Pause can display text to the homescreen. Disp writes the text to the screen and then continues forward, but Pause waits for the [ENTER] key to be pressed. When Pause is used with text, such as in
:Pause "TEXT"
:then it writes the text to the homescreen first, and then waits for the user to press [ENTER].
;CAPITALIZE:For the most part, yes, it is nice to see that not EVERY character is in UPPERCASE on the calculator, but if you're looking to save space, don't use lower case letters. Each lowercase letter takes up twice as much space as the uppercase ones.
;Read-Only Lists and Matrices:If you have a list or matrix that will be read-only, it behooves you to save it to a string or Y function (Y1-Y0). Instead of doing
:{1,2,3,4,5,6,7,8,9â†’L1
:L1(5 (to retrieve the 5th element of the list)
:try doing
:"{1,2,3,4,5,6,7,8,9â†’Str1
:expr(Str1
:Ans(5
:or
:"{1,2,3,4,5,6,7,8,9â†’Y1
:Y1:Ans(5
:The benefit is that you are now no longer wasting the space, as explained in the [[83Plus:Basic:Tricks#Memory_Management|Number Values]]. When choosing between storing your list to a string and storing it to a function, keep in mind that string values are somewhat editable, while functions are completely read-only. If you needed to edit something in the function, you'd have to convert it to a string first before editing, and then overwrite the original function. It is therefore recommended that you save your lists to strings.
;No NewLine Required:The following commands do not require that you neither begin a new line, nor use a colon before the next command: Archive, Unarchive, DelVar. Example:
Archive XArchive YArchive ZUnarchive ZUnarchive TDelVar ADelVar BFor(X,0,1
:this doesn't work with Lists, or labels, and presumably neither with the prgm token.

==Speed Boosters==
;Use For( loops:In light of research I once read online, as well as through personal research and experimentation, it is fairly simple to see that For( loops are the fastest of the looping options. To prove this, try running the following program on your calc, and see which one is the fastest:
<nowiki>Program:LOOPTEST
:Disp "FOR
:For(X,1,10000
:End
:Pause "FOR IS DONE
:1â†’X
:Disp "WHILE
:While X<10001
:X+1â†’X
:End
:Pause "WHILE IS DONE
:0â†’X
:Disp "GOTO
:Lbl XX
:X+1â†’X
:If X<10001
:Goto XX
Pause "GOTO DONE</nowiki>
:You will notice, especially if using a stopwatch, that the For( loop, IIRC, should even run a FEW SECONDS faster than the While loop, and/or the Goto loop. Therefore, see if you can't change your loops to use For( instead. In the case of the While, change
:While X<Y
:to
:X-1â†’X
:For(X,X,Y
:X-1â†’X
:You most likely will be losing a few more bytes in memory, but it's very much worth it for the speed... and you've already saved much speed by doing the tricks above ;-)
;Get Returns on your IfThens, Fors, etc.:Each time you do an If-Then statement or a For( statement (among others), when the calc is "waiting" for an End statement, these conditions are taking up memory, which, after a while, slow down your BASIC programs. However, the benefit is that this is only the case, as long as your program is running... as soon as the calculator returns to the homescreen, these used memory is cleared again and you are ready to go at it again. The benefit of this is that when the calculator encounters a Return statement in a BASIC program, it "cancels" any conditions for its waiting for an End.
;Avoid storing to vars in a loop:Brandon Green writes in his BASIC Guru Online that his experiments have led to the conclusion that storing variables is a prime cause of slowdowns in TI-BASIC programs. Therefore, try to restructure your code so as to avoid using the â†’ as much as possible.

==Graphical Touches==
;Use Text(-1,X,Y,value or text:I learned this from Kevtiva Inc. Normally, you do something like this:
:Text(15,10,"MY TEXT
:following this, the text "MY TEXT" will be written on the 15th row, in the 10th column, in the small font... however, try adding a "-1" (without the quotation marks) as the first argument...
:Text(-1,15,10,"MY TEXT
:This time, the text "MY TEXT" will be written on the 15th row in the 10th column, in the LARGE font
;Write blank spaces to the graph screen when needing to erase stuff:as long as what you are trying to erase is at least 6 pixels high, it is srongly recommeded that you use the Text( command to write blank spaces to the screen instead of creating a Line(A,B,C,D,0 loop. This is because to write a line, white or black, the calculator needs to do a lot of math to convert the X and Y coordinates into pixel coordinates, while writing text to the screen is almost at the same speed as it would take to draw a sprite to the screen in any asm program (since for the calc, text chars are just sprites) and so writing (blank) text to clear the screen is much faster.
;Try drawing graphics to the screen using text instead of lines: With access to the lowercase letters, as well as the Catalog menu, it is possible to draw graphics to the screen using text. For example, to draw a heart for a Zelda game would be much faster if you do something like the following:
<nowiki>:"vQ6Qv "
:For(X,1,7
:Text(10,9+X,sub(Ans,X,1
:End</nowiki>
:Another typical example is that of "drawing" a status bar to the screen using something such as:
<nowiki>(P is the percent to be shaded in)
(L is the length of the bar in pixels)
(H is the horizontal position)
(V is the vertical position, using the top-left corner of the screen as point 0,0)
:Text(V,H,"(
:For(X,0,PL/100
:Text(V,H+X+1,"8
:End
:For(X,1,(100-P)L/100
:Text(V,H+PL/100+X,")
:End</nowiki>
:Using this technique, small graphics such as these can be drawn much faster than if we tried to draw them using lines and/or pixels and/or points.
;Simplify your Life:Save a GDB at the beginning of your program. "Graph Databases (GDBs) are useful storage centers of graph informaiton. This means that it saves not only the Zoom settings, but also Axes on/off, coord on/off, and the Y= equations. Using these can reduce the size of your program." (quoted from http://web.archive.org/web/20021020121625/www.kevtiva.com/calc/gdb.htm) Turn off the axes with AxesOff, turn off functions with FuncOff, and set the Window to Xmin=0, Xmax=94, Xscl=8, Ymin=-62, Ymax=0, Yscl=8. When your program is exiting, have it reset the previous GDB so that you don't mess up the gamer's graph settings. While debugging your graphics, moving your cursor on the graph screen will now tell you both the pixel coordinates, as well as the point coordinates since you have synchronized them. http://www.meebo.com//skin/default/img/emoticons/big_smile.gif
;Convert Pts into Pxls:If you have not used the previous tip, it is important to know that the coordinates you give to any Pt command will be different from those you give to any Pxl command (if you want to use, say Pt-On/Pt-Off, with Pxl-Test). The reason for this is that Pt commands take your window settings into account, while Pxl commands don't.Here is one set of formulas you can use to convert your Pt coordinates into Pxl coordinates:
<nowiki>round(94X/(Xmax-Xmin)+47,0)->A
round(-62Y/(Ymax-Ymin)+31,0)->B
-RobbieMc</nowiki>
:With this formula, the Pxl command is Pxl-XX(B,A), where XX is On, Off, Test, or Change. Another formula can be found in the Ans your answers section of Cool Hacks. http://meebo.com/skin/default/img/emoticons/smile.gif
;Get rid of the "Done":Use the following right before your program exits to avoid having the calc display the "Done" text on the homescreen
<nowiki>:ClrHome
:"</nowiki>
:When used immediately before a "Stop" token, "Done" is still displayed after the program quits. This also moves the cursor down one line before quitting. To avoid both these, use <code>Output(1,1,"</code>.
;Get rid of the RunIndic:On the homescreen, do <code>Output(1,16,"_</code> in the loop that is displaying the run indicator. On the graph screen, do <code>Text(-1,0,90,"_</code> in the loop that is displaying the run indicator. (_ in this context refers to the space character.)

==Cool Hacks==
;Have " and the store arrow in a string:(IIRC, brought to you by Kevtiva Inc.) Type a " and the store arrow at the homescreen and press enter. An error message will appear; choose to Quit. Press [Y=] and go to Y1. Press [2nd] [ENTER] to paste the previous homescreen entry into Y1. Press [2nd] [MODE] to {ESC}. At the homescreen, type Equ>Str(Y1,Str1 (or whatever Str you want to store it to and press [ENTER]. You now have the " quote and the store arrow in your string. http://www.meebo.com//skin/default/img/emoticons/wink.gif
;If condition<nowiki>:</nowiki>End:This will need a bigger explanation, but in short, you can have a conditional End statement that helps your loops run faster by only executing the End statement if needed. The reason this works is because you didn't use a Then statement: an If followed by a single non-Then statement is interpreted as an If with no Else clause and the single statement as the equivalent of the Then clause, even if the statement is End. You can therefore also insert comments into your code (which is not recommended for BASIC unless you're still debugging it) by doing If 0:Whatever. For instance:
<nowiki>(untested...)(lines are numbered)
01:For(X,0,1
02:getKeyâ†’K
03:Kâ†’X
04:If not(Ans
05:End
06:0â†’X
07:"-
08:If K=25
09:"LEFT
10:If K=26
11:"UP
12:If K=27
13:"RIGHT
14:If K=34
15:"DOWN
16:If K=45
17:"CLEAR
18:If Ans="-
19:End
20:Disp Ans
21:If K=45
22:1â†’X
23:End</nowiki>
:Explanation: Lines 1-2 are normal. Line 3 resets X if there was no key, which will loop back to the For( statement, or allow the routine to continue if there WAS a key. The answer from the getKey is in Ans, so if no key was pressed, Line 5 will be executed, which loops back to Line 1 without wasting any more time. http://www.meebo.com//skin/default/img/emoticons/smile.gif ... If a key was pressed, X is reset, which will cause the routine to loop back to the For( statement the next time it encounters an End statement. If the condition in Line 4 is not met, it automatically skips to Line 6. The string "-" is stored in Ans. We then go into a series of checks looking for any of the arrow keys, and changing Ans to reflect that. Line 8 is executed, and if the condition is not met, it skips to Line 10; if that condition is not met, it skips to Line 12; if that condition is not met, it skips to Line 14; if that condition is not met, it skips to Line 16; if that condition is not met, it skips to Line 18. Then, it checks the Ans var. If the Ans var is still unchanged, then none of the keys we are looking for have been found, so we End, which we've already said will loop back to the For( statement, essentially beginning the getKey loop once more. If Ans is different, then one of our keys was found, so we Disp the value in Ans (which is a String). We then check to see if it was the [CLEAR] key., and if it was, we set X so that the next End statement that is encountered will essentially close the loop and the routine will continue beyond this part of the code. We then End, which checks the value of X. If X is 0, it loops back to the For( statement, recommencing the whole loop, but if X is 1, it "closes" the loop, forgets about it completely, and moves on with its life. Thus can you build in looping conditions into your programs without having to use Lbl or Goto statements. http://www.meebo.com//skin/default/img/emoticons/cool.gif
;Ans your answers:the Ans var is, IMHO, the most useful yet most unsafe var on the whole calculator because it can be so many different variable types (real, complex, list, matrix, string)... One way to reduce the number of varables you're using in your program is to carefully structure your program so that it stores as much information into the Ans var as possible. One way to do this is to setup Ans to be a list, say {3,1,4,2,5}. Doing Ans(4) is not going to multiply each value in the list by four, but rather going to give you the 4th value in the list:2. This happens because the OS will treat the Ans variable exactly the same as if it were L1 or any other list variable. I've already demonstrated that the Ans var can be used to keep track of whether one of the keys we were looking for was found or not, but there are other things you can do with the Ans var (as long as you're careful not to change the value in Ans unintentionally). For instance, doing {Ans(2),Ans(4),Ans(1),Ans(3),Ans(5) will change Ans to be the list {1,2,3,4,5}... Note that the Ans var is changed AFTER the whole command has been executed. There will probably be more examples of using Ans in a program at a later date. Therefore, you can do something like this:
<nowiki>(50% tested)
(to convert from Pt coordinates to Pxl coordinates)
A is the X-coord
B is the Y-coord

{63/(Ymax-Ymin),95/(Xmax-Xmin

;{pixels per Y, pixels per X

{abs(Ymax-B),abs(Xmin+A),int(Ans(2))+(0=fPart(Ans(2))),int(Ans(1))+(0=fPart(Ans(1

;{Y,X,int ppY,int ppX
;Ans(1)Ans(3) is now the Pxl-Y
;Ans(2)Ans(4) is now the Pxl-X</nowiki>
;Autodetect Degree or Radian Mode:Robert Maresh states that this is one thing he learned from James Matthew's Asmguru.hlp
<nowiki>:If 0<cos(9)
:Then
:Disp "Degree Mode
:Else
:Disp "Radian Mode
:End</nowiki>
;Ans as a list:It is possible to use the Ans variable as a list in replacement to using any of the real or complex variables. The trick is knowing how to use the augment( and the seq( commands so that you won't be destroying Ans and inadvertedly converting it into something other than a list. '''NOTE: '''extensive usage of this, as in the case of replacing all variables from a program can/will slow down the program, as well as use up more memory than if you just used variables. A shellsort program using variables A,B,C,D,L,Z, and θ used up 143 bytes, while its variable-free counterpart used up 645 bytes and was significantly slower. However, this doesn't mean the technique is completely useless.
:*augment({1,2},{3,4} will return {1,2,3,4}... it can only augment 2 lists at a time, so repeated usage will be necessary to maintain the Ans variable as a list
:*seq(formula,tempvar,start,end will return a list of what the formula evaluats to when the tempvar is (start-to-finish). I think an example is necessary: seq(X^2,X,1,5 will For(X,1,5) evaluate X^2 and store that value to a list, thus producing {1,4,9,16,25}, without changing the value of X ;)
:We can therefore use seq(Ans(X),X,start,end as a list-equivalent to sub(String,start,len... using a sequence of augment( and seq( commands, we can therefore store values into specific Ans-list elements.
<nowiki>{0,0,0,0,0,0,0,0}:augment(seq(Ans(X),X,1,3),augment({2,3},seq(Ans(X),X,6,8</nowiki>
:That returns the list {0,0,0,2,3,0,0,0}.
;Autodetect if the Calculator is an 82 or 83/+:Robert Maresh states that
<nowiki>abs -1+1 would return 2 on a TI-82
abs(-1+1 would return 0 on a TI-83 (this is because the abs is followed by a parenthese)</nowiki>
:and that one can therefore use the following to display whether the calc is an 82 or 83
Text(0,0,"YOU HAVE A TI-",83-.5(abs -1+1
==Miscellaneous==
;Have conditions built into your formulas:This will probably need a better explanation, but I have found it useful to build certain conditions into my formulas, instead of having to write all those If statements... for instance, for piece-wise graphing, you can do Y=(X^2)(X>0)+(2X)(X<1), which is the same as If X>0:Y=X^2:If X<1:Y=2X ...right now, I can't really say what you'll be saving by doing this (memory/speed/etc) because I don't remember, but I can assure you this come quite in handy because you can then have one formula solve a variety of different problems, without the hassle of dealing with a lot of If-Then statements. For example, if you were to save that formula as Y1, then you'd only need to do Y1(number) to have it do the whole sequence of conditionals. I consider this one of the more complicated tricks to implement (because one can easily get confused as to how to build it as well as to what conditions one is looking for) but I have found it to be extremely useful. For example, let us say you write a text editor program in BASIC that allows the user to edit Str1, as displayed on the homescreen using Output(1,1,Str1. However, you run into a problem when Str1 is longer than the 96 chars that fit on the homescreen, so you can, using the sub( and length( functions, you could have one line of code something like
<nowiki>:length(Str1
:Output(1,1,sub(Str1,1(Ans<96)+16frac(Ans/16)(Ans>95)+(16int(Ans/16)-80)(Ans>95),Ans+80-16int(Ans/16</nowiki>
:should make the Output scroll up one line whenever the screen has been filled (untested, please verify). What this line is saying is: give me from Str1, starting at the first byte if Str1 is smaller than 96 charachters, otherwise, calculate the beginning to be one "row" less than the total, and give me all the rest of the chars till the end. If you could not follow that, don't worry, as that is what I meant when I said this is one of the harder tricks. If you did follow with what I was trying to do, Kudos to you! Keep in mind that the conditions within the () can hold any of the condition-elements of If statements, i.e. and, not, or, =, â‰ , >, <, â‰¥, â‰¤. BTW, this BASIC trick does '''NOT''' work on the 89. I tried, but there I could not get the 89 to convert a binary operation into a numerical value, the way the z80s do. (I could be wrong about this working on all z80s... I've tested it on an 82 and an 83+)
;See program in MirageOS:If you want to see your program in a shell, like MirageOS, you must type the following code in the first line of the program:
<nowiki>::"Description</nowiki>
:That will show the program name with the description you typed.
;User-friendly Error Messages:(brought to you by Kevtiva Inc.) Write an error message to the screen before calling any subroutine programs, and have the subroutines program erase the error message. This way, if the subroutine program is missing, the user will be informed about the specifics of the problem. Example:
<nowiki>PROGRAM:MYSHELL
:program code
:Output(1,1,"ERR:prgmMYSUB MISSING
:prgmMYSUB
:more program code

PROGRAM:MYSUB
:Output(1,1," "
:The rest of program MYSUB.</nowiki>

==Further Reading==
'''The Complete TI-83 BASIC Optimization Guide, Version 2''' [http://www.ticalc.org/archives/files/fileinfo/145/14542.html]

==Special Thanks==
Special thanks to:

'''Kevtiva Inc.''' [http://web.archive.org/web/*sr_1nr_315/http://kevtiva.com/* Â© 2000 Kevtiva Interactive]

'''BASIC Guru Online''' [http://bgo.netfirms.com/ Copyright Â© 2000-2006 BASIC Guru Online. All Rights Reserved.]

'''Detached Solutions''' [http://www.detachedsolutions.com/forum/ Â© 2000-2006 Detached Solutions]

83Plus:BCALLs:4BE5

2006-10-22T13:18:26Z

RobbieMc: fixed type (axis to axes)

[[Category:83Plus:BCALLs:By Name:Graph|DispAxes]] [[Category:83Plus:BCALLs:By Name|DispAxes]] [[Category:83Plus:BCALLs:By Address|4BE5 - DispAxes]]
== Synopsis ==
'''Official Name:''' DispAxes

'''BCALL Address:''' 4BE5

Displays the X & Y axes on the screen

=== Inputs ===
''None''

=== Outputs ===
''None''

83Plus:RAM:9776

2006-10-22T12:42:07Z

RobbieMc:

[[Category:83Plus:RAM:By_Name|GY1-GW]] [[Category:83Plus:RAM:By_Address|9776 - GY1-GW]]
== Synopsis ==
'''Official Name:''' GY1-GW

'''Memory Address:''' 9776

'''Length:''' 25 bytes

This area of memory stores the draw style for all function, parametric, polar, and sequence equations.

== Comments ==
Each byte corresponds to a different equation:
* GY1 - GY0 = Graph style for equations Y1 - Y0
* GX1 - GX6 = Graph style for equations X2 - X6
* GR1 - GR6 = Graph style for equations R1 - R6
* GU,GV,GW = Graph style for sequence equations U,V,W

Each byte can contain a value of 0-6

83Plus:BCALLs:4BE5

2006-10-19T14:33:43Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name:Graph|DispAxis]] [[Category:83Plus:BCALLs:By Name|DispAxis]] [[Category:83Plus:BCALLs:By Address|4BE5 - CentCursor]]
== Synopsis ==
'''Official Name:''' DispAxis

'''BCALL Address:''' 4BE5

Displays the X & Y axis on the screen

=== Inputs ===
''None''

=== Outputs ===
''None''

83Plus:BCALLs:4318

2006-10-03T13:47:03Z

RobbieMc: typo

[[Category:83Plus:BCALLs:By Name|CreateTempCList]][[Category:83Plus:BCALLs:By Name:Variable|CreateTempCList]][[Category:83Plus:BCALLs:By Address|4318 - CreateTempCList]]
== Synopsis ==
'''(Un)Official Name:''' CreateTempCList

'''BCALL Address:''' 4318

Creates a temporary complex list.

=== Inputs ===
* HL = Number of elements

=== Outputs ===
* HL points to symbol table entry
* DE points to data section
* [[83Plus:RAM:8499|OP4]] contains the name.

=== Registers Destroyed ===
* AF,BC,[[83Plus:RAM:8478|OP1]],[[83Plus:RAM:8483|OP2]]

== Comments ==
If there are 65536 temporarily variables or if there isn't enough RAM a memory error will be generated. Contents of the list are random.

== Example ==
ld hl,4
B_CALL CreateTempCList

83Plus:BCALLs:4312

2006-10-03T13:42:43Z

RobbieMc: typo

[[Category:83Plus:BCALLs:By Name|CreateTempRList]][[Category:83Plus:BCALLs:By Name:Variable|CreateTempRList]][[Category:83Plus:BCALLs:By Address|4312 - CreateTempRList]]
== Synopsis ==
'''(Un)Official Name:''' CreateTempRList

'''BCALL Address:''' 4312

Creates a temporary real list.

=== Inputs ===
* HL = Number of elements

=== Outputs ===
* HL points to symbol table entry
* DE points to data section
* [[83Plus:RAM:8499|OP4]] contains the name.

=== Registers Destroyed ===
* AF,BC,[[83Plus:RAM:8478|OP1]],[[83Plus:RAM:8483|OP2]]

== Comments ==
If there are 65536 temporarily variables or if there isn't enough RAM a memory error will be generated. Contents of the list are random.

== Example ==
ld hl,4
B_CALL CreateTempRList

83Plus:OS:Small Edit Buffers

2006-09-10T10:01:41Z

RobbieMc:

[[Category:83Plus:OS Information|Small Edit Buffers]]
The TI-OS offers a number of undocumented B_CALLs and B_JUMPs that allow for input to be performed using the small font. Perhaps the best example of these functions is TI's Conics app, which uses them for inputting the variables for the relations. You can use the small edit routines for either one-line input (which scrolls left to right), or multi-line input (which will scroll up/down, wrapping text like on the homescreen.)

The following entry points are used with the small editing routines:

<nowiki>_InitSmallEditBox EQU 4CDBh
_InitSmallEditBoxOP1 EQU 4D38h
_InitSmallEditBoxVar EQU 4D35h
_InitSmallEditLine EQU 4CA5h
_InitSmallEditLineOP1 EQU 4D32h
_InitSmallEditLineVar EQU 4D2Fh
_ReleaseSEdit EQU 4CA2h
_SmallEditCxErrorEP EQU 4CC6h
_SmallEditCxMain EQU 4CABh
_SmallEditCxPPutaway EQU 4CC3h
_SmallEditCxPutaway EQU 4CC0h
_SmallEditCxRedisp EQU 4CBAh
_SmallEditCxSizeWind EQU 4D2Ch
_StartSmallEdit EQU 4CA8h
_StartSmallEditReturn EQU 4E1Fh</nowiki>

Customization of the small edit buffer occurs by setting up certain areas of the RAM, with their equates listed below. Interestingly, all of these equates fall between ramCode and ramCodeEnd.

<nowiki>SmallEditCancelParse EQU 8194h
SmallEditColumnLeft EQU 8177h
SmallEditColumnRight EQU 8179h
SmallEditRow EQU 8178h
SmallEditRowCount EQU 81B7h
SmallEditPromptString EQU 81CCh</nowiki>

To begin an edit session, you first must setup some of the settings in RAM. All of the small edit routines require the following to be set:

'''SmallEditCancelParse:''' Set to 03h if you do not want the small edit routines to parse the string typed, set to anything else for automatic parsing. This will be discussed later.

'''SmallEditColumnLeft:''' The leftmost column for the small edit buffer.

'''SmallEditColumnRight:''' The rightmost column. If the text would extend past this point, the edit routines will automatically handle scrolling.

'''SmallEditRow:''' The row (in pixels, from the top of the screen) for the first row of the edit buffer.

'''SmallEditPromptString:''' The string to display. This is analogous to the first string argument for the Input command in TI-BASIC. SmallEditPromptString should contain the length, in characters, and SmallEditPromptString + 1 should contain the actual string. If you don't want a string, simply set SmallEditPromptString to zero.

Also, if you are doing multi-line input ("box" input), then you must also set SmallEditRowCount, which is the number of rows to use for editing.

Once the various settings in RAM are setup, you must then B_CALL one of the Init entrypoints. There are six of them, with their names describing exactly what behaviors should occur, the format being _InitSmallEdit[Type][WhatToEdit]. Type is either line, which is for one line input, or Box, which does multi-line. WhatToEdit describes what should appear in the edit buffer by default. If WhatToEdit isn't there (either _InitSmallEditLine or _InitSmallEditBox), then the edit buffer is initially empty. If WhatToEdit is Var, the contents of the variable given in OP1 is used. If WhatToEdit is OP1, then OP1 is treated as a real and converted to a string, the resulting string then is placed in the edit buffer.

The following actions are taken by the _InitSmallEdit entry points:

* An edit buffer is opened on the "text_buf" equation, with the contents requested (if any) placed inside.
* The prompt string and contents of the edit buffer are displayed based on the settings in RAM and the form of InitSmallEdit called.
* Monitor vectors are installed to prepare for the editing. The previous monitor vectors are backed up. I believe appFlags is not touched.

Once the small edit buffer is open, you perform the actual editing by B_CALLing _StartSmallEdit. This entrypoint saves the return page / address combination for the B_CALL to RAM, and then passes control to Mon, and editing starts.

Editing is completed by pressing Enter or 2nd+Quit, and if you are doing line input, then also up or down. _StartSmallEdit returns with A being the key pressed that caused the edit session to complete. If you didn't disable parsing, parsing will occur (a system error is thrown if a parse error occurs), with OP1 (and maybe OP2 in the case of complex results) containing the result. Otherwise, OP1 contains the name of "text_buf", which is:

EquObj, 0

Notes about _StartSmallEdit:

* appBackUpScreen is used when backing up the image during a cxPPutAway for restoration during cxRedisp.
* Switching to other contexts (say by doing 2nd+Mem, 2) can cause unexpected behaviors. TI's Conics app uses a keyhook to disable various keys that open menus that contain problematic items (the memory, stat and program menus are blocked entirely, for example.)
* 2nd-Off also causes problems. Conics handles this by installing it's own monitor vectors, as mentioned later.
* If a parse error occurs, you can call this again to continue input, but it appears some internal states are messed up, so errors are always thrown (at least if we're asking it to parse for us.) If anyone can clear this up, tell me!

Once you are done with the edit buffer, B_CALL ReleaseSEdit. This closes the edit buffer, and restores the original monitor vectors. You must do this under all conditions.

There is an extra B_CALL _StartSmallEditReturn, which is a very odd and not very useful routine. When you B_CALL _StartSmallEdit, the top three items on the stack (placed there by the B_CALL routine itself) are popped off (and stored at 818Bh for the curious), and the SP is then saved (saved to 9D88h.) This is used so StartSmallEdit can actually return (the sp is restored, the values are pushed back, and the OS then does ret.) _StartSmallEditReturn basically restores the SP to what it was before you B_CALLed _StartSmallEdit. Incidently, this also changes the same pieces of RAM where _StartSmallEdit saved the return location, so if you were to call _StartSmallEditReturn in a hook (key hook for example), the edit session may continue, but when it's done, _StartSmallEdit will return to the op-code after where you B_CALLed _StartSmallEditReturn!

Notes about Conic's use of the small edit routines:

* A _GetKey hook is used for disabling various keys that open uneeded menus. Also, the softkeys are also implemented with this hook. If the user presses Graph for example, the hook sets an internal flag and changes the key to kEnter. This causes the small edit to finish (_StartSmallEdit returns), at which point the app then checks the internal flag to see if extra actions should be taken.
* Conics installs it's own monitor vectors before calling _StartSmallEdit (but after it calls one of the _InitSmallEdit routines.) This allows it to get putaway notification to cleanly handle 2nd+Off. It's cxMain, cxPPutaway and cxRedisp handlers simply B_JUMP to _SmallEditCxMain, _SmallEditCxPPutaway, and _SmallEditCxRedisp for handling. _SmallEditCxErrorEP and _SmallEditCxSizeWind can also be used for the same purpose. (thanks to mmartin for this info!) _SmallEditCxPutaway loads SP from 9D88h, pushes three saved items on the stack and does a ret. Which is the routine used to return in the _StartSmallEdit B_CALL.
* Conics parses text_buf manually by setting the SmallEditCancelParse byte, and then calling ParseInp with an error handler.

== Credits and Contributions ==
* '''mmartin:''' For helping figure out some of the extra B_JUMPs

83Plus:Hooks:9BA0

2006-08-19T05:30:22Z

RobbieMc:

[[Category:83Plus:Hooks:By Address|9BA0 - Regraph Hook]]
[[Category:83Plus:Hooks:By Name|Regraph Hook]]
== Synopsis ==
'''Name:''' Regraph Hook

'''Hook Pointer Block Address:''' [[83Plus:RAM:9BA0|9BA0]]

'''Hook Enable BCALL:''' [[83Plus:BCALLs:4FEA|4FEA]]

'''Hook Disable BCALL:''' [[83Plus:BCALLs:4FED|4FED]]

'''Hook Call BCALL:''' [[83Plus:BCALLs:4FF0|4FF0]]

'''Hook Active Flag:''' [[83Plus:Flags:35#Bit_6|6, (iy + 35h)]]

This hook allows one to intercept various events that occur during a regraph, and optionally cancel them. Be aware that this hook is called if a function is being drawn on top of a currently existing graph ("smart graph.")

'''Note:''' This was only extensively researched in function mode.

== Using the Hook ==
In most cases, returning with zero set will allow something to occur, and returning with zero reset will cancel something. Like some hooks, this hook is rather messy.

These events are listed in the order below to match the order they are actually called in.

* '''A = 00h:''' Graphing has started, otherwise nothing has occured. Returning with zero reset will cancel the entire graphing procedure.
* '''A = 01h:''' Graph about to be erased if required, otherwise presented (from plotSScreen) Returning with zero reset will cancel the entire graphing process.
* '''A = 02h:''' About to draw axes and grid. Returning with zero reset will cancel this drawing only.
* '''A = 09h:''' Stat plots drawn. About to draw equations. Returning with zero reset will cancel drawing of all equations (or at least the ones being drawn in this graph.)
* '''A = 03h:''' About to evaluate a point. OP1 contains the value of the independant variable. E contains the equation number only if this is the first time this message is sent for this function, otherwise may hold C9h. Return value ignored. Message skipped in Simultaneous mode.
* '''A = 08h:''' About to evaluate a point---this is somewhat a duplicate of event 03h. OP1 contains equation name. Called twice in the case of Parametric graphs (one time for X and one time for Y). Value of E here the same as value of E during the message A = 3, or if in Simultaneous mode then the number of the equation. During the first call per equation (when not in Simultaneous mode), OP4 may contain the name of the independant variable. This event can also be called when the next location of the trace cursor has to be calculated. Returning with zero reset will make the os try to use the value in OP1 as result. Returning with zero set will make the os try to execute the equation, resulting in event 04h. (Changing the name of the equation in OP1 has no effect.)
* '''A = 04h:''' Function evaluated. OP1 is the X coordinate after evaluation. OP2 is the Y coordinate after evaluation, assuming that zero was set as a return value when A = 08h, otherwise contains function name. Canceling this event will cancel drawing of that point, as well as any line connecting to it. This event is skipped if an error occured in parsing.
* '''A = 05h:''' Called after A = 4 regardless of return value or if A = 4 wasn't called due to parse error. Skipped in Simultaneous mode.
* '''A = 06h:''' B contains pixel x-coordinate of the next point to be drawn. Can be modified if desired (but not sure on exact behavior.) Skipped in Simultaneous mode.
* '''A = 07h:''' About to draw axes labels, and done drawing equations. Return values ingored.

== Comments ==
Below is a table of the order of events that are called for each point to be evaluated. In parametric mode the event 08h is called twice because it has to evaluate both X and Y (in that order).

{| border="1"
! Function (sequential)
| 03h || 08h || 04h || 05h || 06h
|-
! Function (simultaneous)
| || 08h || 04h
|-
! Parametric
| 08h || 08h || 04h
|-
! Polar
| || 08h || 04h
|-
! Sequential
| || || 04h
|}

As mentioned, this hook's behavior is rather erratic and messy; the best way to learn it is to just mess with it.

83Plus:BCALLs:4345

2006-08-18T07:10:09Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name|UpdatePointers]]
[[Category:83Plus:BCALLs:By Name:Utility|UpdatePointers]]
[[Category:83Plus:BCALLs:By Address|4345 - UpdatePointers]]

== Synopsis ==
'''Unofficial Name:''' UpdatePointers

'''BCALL Address:''' 4345

Updates 23 pointers after memory has been inserted or deleted

=== Inputs ===
* DE = Location in RAM where memory was inserted/deleted
* BC = Number of bytes to decrease each pointer by (use signed integer to increase the pointers)

=== Outputs ===
''none''

=== Destroys ===
All

== Comments ==
These 23 pointers in RAM are updated:
* iMathPtr1
* iMathPtr2
* iMathPtr3
* iMathPtr4
* iMathPtr5
* asm_data_ptr1
* asm_data_ptr2
* fmtMatMem
* newDataPtr
* EQS
* 9319h
* 9302h
* insDelPtr
* 9306h
* 9311h
* editDat
* chkDelPtr1
* XOutDat
* YOutDat
* fOutDat
* 84E7h
* inputDat
* chkDelPtr2

83Plus:Hooks:9BA0

2006-08-17T14:52:14Z

RobbieMc:

[[Category:83Plus:Hooks:By Address|9BA0 - Regraph Hook]]
[[Category:83Plus:Hooks:By Name|Regraph Hook]]
== Synopsis ==
'''Name:''' Regraph Hook

'''Hook Pointer Block Address:''' [[83Plus:RAM:9BA0|9BA0]]

'''Hook Enable BCALL:''' [[83Plus:BCALLs:4FEA|4FEA]]

'''Hook Disable BCALL:''' [[83Plus:BCALLs:4FED|4FED]]

'''Hook Call BCALL:''' [[83Plus:BCALLs:4FF0|4FF0]]

'''Hook Active Flag:''' [[83Plus:Flags:35#Bit_6|6, (iy + 35h)]]

This hook allows one to intercept various events that occur during a regraph, and optionally cancel them. Be aware that this hook is called if a function is being drawn on top of a currently existing graph ("smart graph.")

'''Note:''' This was only extensively researched in function mode.

== Using the Hook ==
In most cases, returning with zero set will allow something to occur, and returning with zero reset will cancel something. Like some hooks, this hook is rather messy.

These events are listed in the order below to match the order they are actually called in.

* '''A = 00h:''' Graphing has started, otherwise nothing has occured. Returning with zero reset will cancel the entire graphing procedure.
* '''A = 01h:''' Graph about to be erased if required, otherwise presented (from plotSScreen) Returning with zero reset will cancel the entire graphing process.
* '''A = 02h:''' About to draw axes and grid. Returning with zero reset will cancel this drawing only.
* '''A = 09h:''' Stat plots drawn. About to draw equations. Returning with zero reset will cancel drawing of all equations (or at least the ones being drawn in this graph.)
* '''A = 03h:''' About to evaluate a point. OP1 contains the value of the independant variable. E contains the equation number only if this is the first time this message is sent for this function, otherwise may hold C9h. Return value ignored. Message skipped in Simultaneous mode.
* '''A = 08h:''' About to evaluate a point---this is somewhat a duplicate of event 03h. OP1 contains equation name. Called twice in the case of Parametric graphs (one time for X and one time for Y). Value of E here the same as value of E during the message A = 3, or if in Simultaneous mode then the number of the equation. During the first call per equation (when not in Simultaneous mode), OP4 may contain the name of the independant variable. This event can also be called when the next location of the trace cursor has to be calculated. Returning with zero reset will make the os try to use the value in OP1 as result. Returning with zero set will make the os try to execute the equation, resulting in event 04h. (Changing the name of the equation in OP1 has no effect.)
* '''A = 04h:''' Function evaluated. OP1 is the X coordinate after evaluation. OP2 is the Y coordinate after evaluation, assuming that zero was set as a return value when A = 08h, otherwise contains function name. Canceling this event will cancel drawing of that point, as well as any line connecting to it. This event is skipped if an error occured in parsing.
* '''A = 05h:''' A = 5 - Called after A = 4 regardless of return value or if A = 4 wasn't called due to parse error. Skipped in Simultaneous mode.
* '''A = 06h:''' B contains pixel x-coordinate of the next point to be drawn. Can be modified if desired (but not sure on exact behavior.) Skipped in Simultaneous mode.
* '''A = 07h:''' About to draw axes labels, and done drawing equations. Return values ingored.

== Comments ==
Below is a table of the order of events that are called for each point to be evaluated. In parametric mode the event 08h is called twice because it has to evaluate both X and Y (in that order).

{| border="1"
! Function (sequential)
| 03h || 08h || 04h || 05h || 06h
|-
! Function (simultaneous)
| || 08h || 04h
|-
! Parametric
| 08h || 08h || 04h
|-
! Polar
| || 08h || 04h
|-
! Sequential
| || || 04h
|}

As mentioned, this hook's behavior is rather erratic and messy; the best way to learn it is to just mess with it.

83Plus:BCALLs:4360

2006-08-12T05:19:12Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name|UpdateVATandPointersADD]]
[[Category:83Plus:BCALLs:By Name:Memory|UpdateVATandPointersADD]]
[[Category:83Plus:BCALLs:By Address|4360 - UpdateVATandPointersADD]]

== Synopsis ==
'''Official Name:''' UpdateVATandPointersADD

'''BCALL Address:''' 4360

Updates VAT and pointers after memory has been inserted

=== Inputs ===
* DE = Location in RAM where memory was inserted
* BC = Number of bytes to increase each VAT entry and pointer by (amount of memory inserted)

=== Outputs ===
''none''

=== Destroys ===
All

== Comments ==
Along with the VAT entries, these 29 pointers in RAM will be updated:
* iMathPtr1
* iMathPtr2
* iMathPtr3
* iMathPtr4
* iMathPtr5
* asm_data_ptr1
* asm_data_ptr2
* fmtMatMem
* newDataPtr
* EQS
* 9319h
* 9302h
* insDelPtr
* 9306h
* 9311h
* editDat
* chkDelPtr1
* XOutDat
* YOutDat
* fOutDat
* 84E7h
* inputDat
* chkDelPtr2
* fpBase
* FPS
* 965Bh
* 965Dh
* 965Fh
* tempMem

83Plus:BCALLs:4345

2006-08-12T05:19:11Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name|UpdatePointers]]
[[Category:83Plus:BCALLs:By Name:Utility|UpdatePointers]]
[[Category:83Plus:BCALLs:By Address|4345 - UpdatePointers]]

== Synopsis ==
'''Official Name:''' UpdatePointers

'''BCALL Address:''' 4345

Updates 23 pointers after memory has been inserted or deleted

=== Inputs ===
* DE = Location in RAM where memory was inserted/deleted
* BC = Number of bytes to decrease each pointer by (use signed integer to increase the pointers)

=== Outputs ===
''none''

=== Destroys ===
All

== Comments ==
These 23 pointers in RAM will be updated:
* iMathPtr1
* iMathPtr2
* iMathPtr3
* iMathPtr4
* iMathPtr5
* asm_data_ptr1
* asm_data_ptr2
* fmtMatMem
* newDataPtr
* EQS
* 9319h
* 9302h
* insDelPtr
* 9306h
* 9311h
* editDat
* chkDelPtr1
* XOutDat
* YOutDat
* fOutDat
* 84E7h
* inputDat
* chkDelPtr2

83Plus:BCALLs:4360

2006-08-12T04:59:22Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name|UpdateVATandPointersADD]]
[[Category:83Plus:BCALLs:By Name:Memory|UpdateVATandPointersADD]]
[[Category:83Plus:BCALLs:By Address|4360 - UpdateVATandPointersADD]]

== Synopsis ==
'''Official Name:''' UpdateVATandPointersADD

'''BCALL Address:''' 4360

Updates VAT and pointers after memory has been inserted

=== Inputs ===
* DE = Location in RAM where memory was inserted
* BC = Number of bytes to increase each VAT entry and pointer by

=== Outputs ===
''none''

=== Destroys ===
All

== Comments ==
Along with the VAT entries, these 29 pointers in RAM will be updated:
* iMathPtr1
* iMathPtr2
* iMathPtr3
* iMathPtr4
* iMathPtr5
* asm_data_ptr1
* asm_data_ptr2
* fmtMatMem
* newDataPtr
* EQS
* 9319h
* 9302h
* insDelPtr
* 9306h
* 9311h
* editDat
* chkDelPtr1
* XOutDat
* YOutDat
* fOutDat
* 84E7h
* inputDat
* chkDelPtr2
* fpBase
* FPS
* 965Bh
* 965Dh
* 965Fh
* tempMem

83Plus:BCALLs:42FA

2006-08-11T17:27:15Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name|InsertMemNoUpdateVAT]]
[[Category:83Plus:BCALLs:By Name:Memory|InsertMemNoUpdateVAT]]
[[Category:83Plus:BCALLs:By Address|42FA - InsertMemNoUpdateVAT]]

== Synopsis ==
'''Official Name:''' InsertMemNoUpdateVAT

'''BCALL Address:''' 42FA

Inserts memory to a given location without updating the VAT pointers

=== Inputs ===
* HL = Number of bytes to insert
* DE = Location to insert memory

=== Outputs ===
''none''

=== Destroys ===
* HL,BC

== Comments ==
This routine works by copying everything from DE to (fps) forward HL bytes in RAM.

83Plus:BCALLs:42FA

2006-08-11T16:17:41Z

RobbieMc:

[[Category:83Plus:BCALLs:By Name|InsertMemNoUpdateVAT]]
[[Category:83Plus:BCALLs:By Name:Utility|InsertMemNoUpdateVAT]]
[[Category:83Plus:BCALLs:By Address|42FA - InsertMemNoUpdateVAT]]

== Synopsis ==
'''Official Name:''' InsertMemNoUpdateVAT

'''BCALL Address:''' 42FA

Inserts memory to a given location without updating the VAT pointers

=== Inputs ===
* HL = Number of bytes to insert
* DE = Location to insert memory

=== Outputs ===
''none''

=== Destroys ===
* HL,BC

== Comments ==
This routine works by copying everything from DE to (fps) forward HL bytes in RAM.

83Plus:Ports:04

2006-08-04T05:52:51Z

RobbieMc:

[[Category:83Plus:Ports:By_Address|04 - Memory Map / Interrupt]] [[Category:83Plus:Ports:By_Name|Memory Map / Interrupt]]
== Synopsis ==
'''Port Number:''' 04h

'''Function:''' Interrupting Device Identification and Memory Map Control

This port serves two purposes. When read it indicates the device that triggered an interrupt. When written it sets the memory map mode and hardware timer speed.

=== Read Values ===
* Bits 0~2 and 4~7 are set according to which device triggered the running interrupt.
** Bit 0: Set if pressing the ON Key triggered the interrupt.
** Bit 1: Set if the first hardware timer triggered the interrupt.
** Bit 2: Set if the second hardware timer triggered the interrupt.
** Bit 4: Link activity generated an interrupt.
** '''83+SE / 84+ only:''' Bit 5: First crystal timer has expired.
** '''83+SE / 84+ only:''' Bit 6: Second crystal timer has expired.
** '''83+SE / 84+ only:''' Bit 7: Third crystal timer has expired.
* Bit 3 is reset if the ON key is being pressed, set otherwise.

=== Write Values ===
* Bit 0 reset to select memory map mode 0. In mode 0 the RAM and ROM is mapped to CPU memory as follows:
** Address 0000h ~ 3FFFh: ROM Page 0
** Address 4000h ~ 7FFFh: Memory Bank A (Page selected in [[83Plus:Ports:06|Port 06h]])
** Address 8000h ~ BFFFh: Memory Bank B (Page selected in [[83Plus:Ports:07|Port 07h]])
** '''83+ Basic''': Address C000h ~ FFFFh: RAM Page 0
** '''Everything else''': Address C000h ~ FFFFh: Page selected in [[83Plus:Ports:05|Port 05h]]
* Bit 0 set to select memory map mode 1. In mode 1 the RAM and ROM is mapped to CPU memory as follows:
** Address 0000h ~ 3FFFh: ROM Page 0
** Address 4000h ~ 7FFFh: RAM Page 0
** Address 8000h ~ BFFFh: Memory Bank A (Page selected in [[83Plus:Ports:06|Port 06h]])
** Address C000h ~ FFFFh: Memory Bank B (Page selected in [[83Plus:Ports:07|Port 07h]])
* Bits 1 and 2 control the hardware timer frequency. Setting both 0 sets the timer to the fastest speed, and both 1 is the slowest speed. The normal speed is with both bits 1.
{| width="90%" border="1" cellpadding="2" cellspacing="0" align="center" style="text-align: center"
|+Frequency (Hz)
|-
! 
!colspan="2"|first timer
!colspan="2"|second timer
!colspan="2"|both enabled
|-
!value
!width="15%"|83+
!width="15%"|83+SE 84+(SE)
!width="15%"|83+
!width="15%"|83+SE 84+(SE)
!width="15%"|83+
!width="15%"|83+SE 84+(SE)
|-
!00
|560||512||1120||1024||1680||1536
|-
!01
|248||227||497||455||746||682
|-
!10
|170||156||344||315||517||473
|-
!11
|118||108||236||216||353||323
|}
* Bits 4~6 should be 1 on the 83+ and 83+SE, and 0 on the 84+ and 84+SE.

== Comments ==
The calculator uses mode 0 for normal operation. If you change the memory map mode be sure to change it back before returning control.
Also, do not switch from mode 0 to mode 1 inside the 4000h ~ 7FFFh range, as it will basically crash the calculator because RAM Page 0 will take over that section and RAM Page 0 cannot execute code.

Interrupt timers seem to be independant of the CPU speed, so setting an SE calculator to 15mhz will not increase the timer frequency.

== Example ==
This example shows successful use of this port, switching to mode 1 and back. Mode 1 is the only way to execute code beyond address C000h on the 83+ Basic. (Assumes code is running from 4000h (i.e. an application))
<nowiki> in a, (7) ;Save current Bank B page because we'll trash it.
push af
in a,(6) ;Put this app's page into 8000
out (7), a
jp $ + 4003h ;This will actually jump to the next statement, but in Bank B.
ld a, 77h ;Select mode 1 and keep the timer speed at normal...
out (4), a ;Now we're in mode 1.
;We're still at 8000h here but we are back in Bank A.
;Now to go back.
ld a, 76h ;I could dec a for this example, but...
out (4), a ;Back in mode 0 and bank B.
jp $ - 3FFDh ;Jump back to bank A.
pop af
out (7), a ;Restore bank B.</nowiki>

== Credits and Contributions ==
* '''Dan Englender''': Originally documented memory map modes [http://www.detachedsolutions.com/forum/viewtopic.php?p=21593#21593 here]
* '''Michael Vincent''': For his docs [http://www.michaelv.org/programs/calcs/ports/port4.html here], which helped me figure out the interrupt device bits.
* '''James Montelongo''': For his docs [http://www.geocities.com/jimm09876/calc/port4.html here] on the hardware timer.

83Plus:Ports:04

2006-08-04T05:52:32Z

RobbieMc:

[[Category:83Plus:Ports:By_Address|04 - Memory Map / Interrupt]] [[Category:83Plus:Ports:By_Name|Memory Map / Interrupt]]
== Synopsis ==
'''Port Number:''' 04h

'''Function:''' Interrupting Device Identification and Memory Map Control

This port serves two purposes. When read it indicates the device that triggered an interrupt. When written it sets the memory map mode and hardware timer speed.

=== Read Values ===
* Bits 0~2 and 4~7 are set according to which device triggered the running interrupt.
** Bit 0: Set if pressing the ON Key triggered the interrupt.
** Bit 1: Set if the first hardware timer triggered the interrupt.
** Bit 2: Set if the second hardware timer triggered the interrupt.
** Bit 3: Set if the ON Key is not pressed
** Bit 4: Link activity generated an interrupt.
** '''83+SE / 84+ only:''' Bit 5: First crystal timer has expired.
** '''83+SE / 84+ only:''' Bit 6: Second crystal timer has expired.
** '''83+SE / 84+ only:''' Bit 7: Third crystal timer has expired.
* Bit 3 is reset if the ON key is being pressed, set otherwise.

=== Write Values ===
* Bit 0 reset to select memory map mode 0. In mode 0 the RAM and ROM is mapped to CPU memory as follows:
** Address 0000h ~ 3FFFh: ROM Page 0
** Address 4000h ~ 7FFFh: Memory Bank A (Page selected in [[83Plus:Ports:06|Port 06h]])
** Address 8000h ~ BFFFh: Memory Bank B (Page selected in [[83Plus:Ports:07|Port 07h]])
** '''83+ Basic''': Address C000h ~ FFFFh: RAM Page 0
** '''Everything else''': Address C000h ~ FFFFh: Page selected in [[83Plus:Ports:05|Port 05h]]
* Bit 0 set to select memory map mode 1. In mode 1 the RAM and ROM is mapped to CPU memory as follows:
** Address 0000h ~ 3FFFh: ROM Page 0
** Address 4000h ~ 7FFFh: RAM Page 0
** Address 8000h ~ BFFFh: Memory Bank A (Page selected in [[83Plus:Ports:06|Port 06h]])
** Address C000h ~ FFFFh: Memory Bank B (Page selected in [[83Plus:Ports:07|Port 07h]])
* Bits 1 and 2 control the hardware timer frequency. Setting both 0 sets the timer to the fastest speed, and both 1 is the slowest speed. The normal speed is with both bits 1.
{| width="90%" border="1" cellpadding="2" cellspacing="0" align="center" style="text-align: center"
|+Frequency (Hz)
|-
! 
!colspan="2"|first timer
!colspan="2"|second timer
!colspan="2"|both enabled
|-
!value
!width="15%"|83+
!width="15%"|83+SE 84+(SE)
!width="15%"|83+
!width="15%"|83+SE 84+(SE)
!width="15%"|83+
!width="15%"|83+SE 84+(SE)
|-
!00
|560||512||1120||1024||1680||1536
|-
!01
|248||227||497||455||746||682
|-
!10
|170||156||344||315||517||473
|-
!11
|118||108||236||216||353||323
|}
* Bits 4~6 should be 1 on the 83+ and 83+SE, and 0 on the 84+ and 84+SE.

== Comments ==
The calculator uses mode 0 for normal operation. If you change the memory map mode be sure to change it back before returning control.
Also, do not switch from mode 0 to mode 1 inside the 4000h ~ 7FFFh range, as it will basically crash the calculator because RAM Page 0 will take over that section and RAM Page 0 cannot execute code.

Interrupt timers seem to be independant of the CPU speed, so setting an SE calculator to 15mhz will not increase the timer frequency.

== Example ==
This example shows successful use of this port, switching to mode 1 and back. Mode 1 is the only way to execute code beyond address C000h on the 83+ Basic. (Assumes code is running from 4000h (i.e. an application))
<nowiki> in a, (7) ;Save current Bank B page because we'll trash it.
push af
in a,(6) ;Put this app's page into 8000
out (7), a
jp $ + 4003h ;This will actually jump to the next statement, but in Bank B.
ld a, 77h ;Select mode 1 and keep the timer speed at normal...
out (4), a ;Now we're in mode 1.
;We're still at 8000h here but we are back in Bank A.
;Now to go back.
ld a, 76h ;I could dec a for this example, but...
out (4), a ;Back in mode 0 and bank B.
jp $ - 3FFDh ;Jump back to bank A.
pop af
out (7), a ;Restore bank B.</nowiki>

== Credits and Contributions ==
* '''Dan Englender''': Originally documented memory map modes [http://www.detachedsolutions.com/forum/viewtopic.php?p=21593#21593 here]
* '''Michael Vincent''': For his docs [http://www.michaelv.org/programs/calcs/ports/port4.html here], which helped me figure out the interrupt device bits.
* '''James Montelongo''': For his docs [http://www.geocities.com/jimm09876/calc/port4.html here] on the hardware timer.

83Plus:Hooks:9B88

2006-01-22T05:26:08Z

RobbieMc: /* Synopsis */

[[Category:83Plus:Hooks:By_Name|GetCSC Hook]] [[Category:83Plus:Hooks:By_Address|9B88 - GetCSC Hook]]
== Synopsis ==
'''Name:''' GetCSC ''(officially GetKey; there is some disagreement as to the appropriateness of both names)''

'''Hook Pointer Block Address:''' [[83Plus:RAM:9B88|9B88]]

'''Hook Enable BCALL:''' [[83Plus:BCALLs:4F7B|4F7B]]

'''Hook Disable BCALL:''' [[83Plus:BCALLs:4F7E|4F7E]]

'''Hook Call BCALL:''' [[83Plus:BCALLs:4F78|4F78]]

'''Hook Active Flag:''' [[83Plus:Flags:34#Bit_0|0, (iy + 34h)]]

This hook is called when the OS scans for keypad activity. (Note, however, that it is only called when the OS is idle in the [[83Plus:BCALLs:4972|GetKey]] routine.) It is called once before the key scan begins, and a second time after the keypad has been scanned. It thus operates at a lower level than the [[83Plus:Hooks:9B84|Raw Key hook]], which operates on actual GetKey values.

== Using the Hook ==
These different values, passed in A, determine what the hook should do.

* 1Ah: Before the keypad is scanned
** Return with Z set and A = keycode to force a key to be "pressed."
** Return with NZ set and A = 1Ah to scan the keypad normally.
* 1Bh: After the keypad is scanned
** B = scancode found (or 0 if no key pressed)
** Return with NZ set and A = scancode to be returned.

== Comments ==
Officially named the "GetKeyHook" by ti83plus.inc. Although it has been pointed out that it is only called during GetKey, referring to it as the "GetKeyHook" is rather misleading, because it deals only with raw scan codes ("GetCSC values") as opposed to the full keypresses returned by GetKey (which depend, for example, on whether 2nd or Alpha are active.)

== Example ==
The following code will swap the 2nd and Alpha keys:

<nowiki>GetKeyHook:
.db 83h ; Required for all hooks
cp 1Bh ; which condition?
ret nz
ld a,b ; which key was pressed?
cp skAlpha ; was it Alpha?
jr z,AlphaKey
cp sk2nd ; was it 2nd?
ret nz
ld a,skAlpha-1 ; change to Alpha
inc a ; set NZ
ret
AlphaKey:
ld a,sk2nd-1 ; change to 2nd
inc a ; set NZ
ret</nowiki>

== Credits and Contributions ==
* '''Texas Instruments''' (thanks for all the confusing equates)

83Plus:Hooks:9B88

2006-01-22T05:15:05Z

RobbieMc: /* Using the Hook */

[[Category:83Plus:Hooks:By_Name|GetCSC Hook]] [[Category:83Plus:Hooks:By_Address|9B88 - GetCSC Hook]]
== Synopsis ==
'''Name:''' GetCSC ''(officially GetKey; there is some disagreement as to the appropriateness of both names)''

'''Hook Pointer Block Address:''' [[83Plus:RAM:9B88|9B88]]

'''Hook Enable BCALL:''' [[83Plus:BCALLs:4F7B|4F7B]]

'''Hook Disable BCALL:''' [[83Plus:BCALLs:4F7E|4F7E]]

'''Hook Call BCALL:''' [[83Plus:BCALLs:4F78|4F78]]

'''Hook Active Flag:''' [[83Plus:Flags:34#Bit_0|0, (iy + 34h)]]

This hook is called when the OS scans for keypad activity. (Note, however, that it is only called when the OS is idle in the [[83Plus:BCALLs:4972|GetKey]] routine.) It is called once before the key scan begins, and a second time if the scan finds a key pressed. It thus operates at a lower level than the [[83Plus:Hooks:9B84|Raw Key hook]], which operates on actual GetKey values.

== Using the Hook ==
These different values, passed in A, determine what the hook should do.

* 1Ah: Before the keypad is scanned
** Return with Z set and A = keycode to force a key to be "pressed."
** Return with NZ set and A = 1Ah to scan the keypad normally.
* 1Bh: After the keypad is scanned
** B = scancode found (or 0 if no key pressed)
** Return with NZ set and A = scancode to be returned.

== Comments ==
Officially named the "GetKeyHook" by ti83plus.inc. Although it has been pointed out that it is only called during GetKey, referring to it as the "GetKeyHook" is rather misleading, because it deals only with raw scan codes ("GetCSC values") as opposed to the full keypresses returned by GetKey (which depend, for example, on whether 2nd or Alpha are active.)

== Example ==
The following code will swap the 2nd and Alpha keys:

<nowiki>GetKeyHook:
.db 83h ; Required for all hooks
cp 1Bh ; which condition?
ret nz
ld a,b ; which key was pressed?
cp skAlpha ; was it Alpha?
jr z,AlphaKey
cp sk2nd ; was it 2nd?
ret nz
ld a,skAlpha-1 ; change to Alpha
inc a ; set NZ
ret
AlphaKey:
ld a,sk2nd-1 ; change to 2nd
inc a ; set NZ
ret</nowiki>

== Credits and Contributions ==
* '''Texas Instruments''' (thanks for all the confusing equates)