| Command | Description |
|---|---|
| _ | Spaces are ignored in most situations. They mainly just help for code organization and readability. |
| : | The colon separates 2 statements in the same expression. Enter ends the expression, closing all unclosed parenthesis. |
| . | The period is a single line comment. Whatever follows will be ignored until the next newline. |
| ... | Start or end of a multi-line comment ignoring everything in between. Must be the first characters on the line. |
| DiagnosticOn | Turns on the run indicator (marching ants). Program will display "done" after finishing. |
| DiagnosticOff | Turns off the run indicator. Program will not display "done" after finishing. |
| Full | Full speed mode is activated if supported, making it 3 times faster on newer calculators. Returns 0 if not supported. |
| Normal | Full speed mode is deactivated. |
| Pause EXP | Pause for the given amount of time. A one second pause is a value of roughly 1800 at normal speed or 4500 in full speed mode. |
| getKey | Returns the last key pressed or zero if no keys are pressed. Its just like the BASIC getkey, but with different codes. |
| getKeyr | Pauses until a key or key combination is pressed and returns the key code. These are different codes than the normal getkeys. |
| getKey(KEY) | Returns 1 if the key is held down this instant and 0 otherwise. |
| getKey(0) | Returns a non-zero number if any key is held down and 0 otherwise. |
| Asm(HEX) | Native assembly code written in hexadecimal is inserted at the current position. |
| prgmNAME | The code from the external program is parsed as if it completely replaced this command in the main program. (Similar to the C++ "include") |
| #Axiom(NAME)
Key: AsmComp() |
The Axiom assembly library becomes useable in the program. No quotes needed, just type the name of the appvar case sensitive. |
| #Icon(HEX)
Key: identity() |
Tells the parser to replace the default icon with the new icon. The icon must be 64 hex characters long. |
| #Realloc(PTR)
Key: Real() |
Moves the variable buffer to another location in ram. If the field is left blank, the default location is restored. |
| Command | Description |
|---|---|
| DispGraph DispGraph(BUF) |
Draws the main buffer, or specified buffer, to the screen. |
| DispGraphClrDraw DispGraphClrDraw(BUF) |
Same as DispGraph:ClrDraw but much faster than doing them individually. |
| DispGraphr DispGraph(BUF1,BUF2)r |
Draws the main and back buffers, or specified buffers, to the screen to create 3 color grayscale. |
| DispGraphClrDrawr DispGraphClrDraw(BUF1,BUF2)r |
Same as DispGraphr:ClrDrawrr but much faster than doing them individually. |
| DispGraphrr DispGraph(BUF1,BUF2)r |
Draws the main and back buffers, or specified buffers, to the screen to create 4 color grayscale. |
| DispGraphClrDrawrr DispGraphClrDraw(BUF1,BUF2)r |
Same as DispGraphrr:ClrDrawrr but much faster than doing them individually. |
| ClrHome | Erases the screen and text shadow and moves the cursor to the upper left corner. |
| ClrDraw ClrDrawr ClrDraw(BUF) |
Erases the main buffer, back buffer, or specified buffer to white pixels. |
| ClrDrawrr | Erases both the front and back buffers. |
| DrawInv DrawInv r DrawInv (BUF) |
The colors on the main buffer, back buffer, or specified buffer are inverted. |
| StoreGDB | Copies the screen to the buffer. |
| StorePic | Copies the buffer to the back-buffer. |
| RecallPic | Copies the back-buffer to the buffer. |
| Horizontal + Horizontal +r Horizontal +(BUF) |
The main buffer, back buffer, or specified buffer is shifted right by 1 pixel. White pixels are shifted in. |
| Horizontal - Horizontal -r Horizontal -(BUF) |
The main buffer, back buffer, or specified buffer is shifted left by 1 pixel. White pixels are shifted in. |
| Vertical + Vertical +r Vertical +(BUF) |
The main buffer, back buffer, or specified buffer is shifted down by 1 pixel. New pixels are not shifted in, that row remains the same. |
| Vertical - Vertical -r Vertical -(BUF) |
The main buffer, back buffer, or specified buffer is shifted up by 1 pixel. New pixels are not shifted in, that row remains the same. |
| Shade() | Returns the operating system's contrast before the program started. |
| Shade(EXP) | Sets the contrast. 0 is lightest, 63 is darkest. |
| Command | Description |
|---|---|
| If EXP
code1 End |
If the expression is true, code1 will be executed. |
| If EXP
code1 Else code2 End |
If the expression is true, then only code1 is executed. Otherwise, only code 2 is executed. |
| ElseIf EXP | Can be used inside If blocks. If the condition is true, the block's code is executed and then goes to the end of the If block. |
| !If EXP
code1 End |
If the expression is false, code1 will be executed. |
| !If EXP
code1 Else code2 End |
If the expression is false, then only code1 is executed. Otherwise, only code 2 is executed. |
| Else!If EXP | Can be used inside If blocks. If the condition is false, the block's code is executed and then goes to the end of the If block. |
| While EXP
code1 End |
The expression is checked first. If its true, code1 will be executed over and over until its false. |
| Repeat EXP
code1 End |
The expression is checked first. If its false, code1 will be executed over and over until its true. |
| For(CONST)
code1 End |
Executes the block of code exactly a set number of times. This structure cannot quit out of the loop early. |
| For(VAR,EXP1,EXP2)
code1 End |
The variable is initialized with expression1. Until the variable is greater than expression2, code1 is executed and the variable is incremented by 1. |
| DS<(VAR,MAX)
code1 End |
The variable is decreased by 1. If its 0, code1 is executed and the variable resets back to Max. If its not 0 yet, code1 is skipped. |
| EndIf EXP | In loops, it works just like a regular "End" if the condition is true. But it will exit the loop if the condition is false. |
| End!If EXP | In loops, it works just like a regular "End" if the condition is false. But it will exit the loop if the condition is true. |
| Command | Description |
|---|---|
| Lbl LBL | Creates a label at the current position. |
| Goto LBL | Jumps to the label. |
| Goto (EXP) | Jumps to a label defined by an expression. |
| sub(LBL,...) | Loads 0 to 6 arguments to the r1 through r6 variables respectively. Then the subroutine is called. All subroutines should end with a Return. |
| sub(LBLr,...) | Same as above except the argument variables it uses are saved before the subroutine is called and restored when it returns. |
| LBL(...) | Same as sub( but with a simpler-to-type format. Also takes 0 to 6 arguments. |
| (EXP)(...) | Same as above but with a subroutine defined by an expression. |
| Return | Returns from a subroutine. If not in a subroutine, the program will end. |
| Returnr | Emergency exits the program from within any number of nested calls. |
| ReturnIf EXP | Returns only if the expression is true. |
| Return!If EXP | Returns only if the expression is false. |
| LLBL | Returns the address of the label. |
| λ(EXP) Key: log() |
Creates a subroutine that computes an expression in terms of r1-r6. Then returns the address of that subroutine. |
| Command | Description |
|---|---|
| VAR | Returns the variable. Uppercase A through Z, Theta, and r1 through r6 are variables. |
| VARr | Returns only the first 8 bits of the variable. |
| °VAR | Returns the address of the variable in memory. |
| EXP→VAR | Stores the expression into the variable. |
| EXP→VARr | Stores the expression into the first 8 bits of the variable. |
| 'CHAR' | Converts an ASCII constant into an integer. |
| -EXP | Returns the negative of the expression. That's a negative sign, not a minus sign! |
| EXP1+EXP2
EXP1-EXP2 |
Expression2 is added to or subtracted from expression1. |
| EXP++
EXP-- |
The variable or memory location is increased or decreased by 1. Memory locations need curly brackets. |
| EXP1*EXP2
EXP1/EXP2 EXP1^EXP2 |
Expression1 is multiplied, divided, or the modulus of expression2. |
| EXP2 | The expression is multiplied by itself. |
| EXP1=EXP2
EXP1≠EXP2 EXP1<EXP2 EXP1≤EXP2 EXP1>EXP2 EXP1≥EXP2 |
Returns 1 if the statement is true or 0 if its false. This is an unsigned comparison. |
| EXP1 or EXP2
EXP1 and EXP2 EXP1 xor EXP2 |
Returns the bitwise operation of the lower 8 bits of the expressions. You often need parenthesis on the second argument when used. |
| abs(EXP) | Returns the absolute value of the expression. |
| √(EXP) | Returns the square root of the expression. |
| sin(EXP) | Returns the sine of the expression. One Period is [0,256] and the value returned ranges from -127 to 127. |
| cos(EXP) | Returns the cosine of the expression. One Period is [0,256] and the value returned ranges from -127 to 127. |
| e^(EXP1) | Returns 2 to the power of the expression (modular). |
| ln(EXP1) | Returns the log base 2 of the expression, or 255 if undefined. |
| min(EXP1,EXP2) | Returns the minimum of the 2 expressions. |
| max(EXP1,EXP2) | Returns the maximum of the 2 expressions. |
| rand | Returns a random 16 bit number. |
| COND?EXP | If the condition is true, the expression is evaluated. Can be used as an "and" short circuit operator like "&&" in C syntax. |
| COND?EXP1,EXP2 | If the condition is true, the first expression is evaluated. Otherwise, the second expression is evaluated. |
| COND??EXP | If the condition is false, the expression is evaluated. Can be used as an "or" short circuit operator like "||" in C syntax. |
| COND??EXP1,EXP2 | If the condition is false, the first expression is evaluated. Otherwise, the second expression is evaluated. |
| Command | Description |
|---|---|
| EHEX | Converts a hexadecimal number into an integer. That prefix is the scientific notation "E". |
| πBIN | Converts a binary number into an integer. |
| TTOKEN | Converts the 1 or 2 byte token into an integer. That prefix is the transpose symbol "T". |
| INT.DEC | Converts a non-integer decimal number into an 8.8 fixed point number. Maximum 3 decimal places. |
| EXP1<<EXP2
EXP1≤≤EXP2 EXP1>>EXP2 EXP1≥≥EXP2 |
Signed comparisons for numbers that aren't always positive. Returns 1 if the statement is true or 0 if its false. |
| EXP1**EXP2 | The signed multiplication is performed using the high byte as the integer part and the low byte as the decimal part returning a number in the same format. |
| EXP1*^EXP2 | Computes the high order 16 bits of an unsigned multiplication. |
| EXP1//EXP2 | Performs a division, but it works for negative numbers too. |
| EXP1·EXP2 EXP1+EXP2 EXP1☐EXP2 |
Returns respectively the full 16 bit "and", "or", and "xor" of the two expressions. These are the plot style tokens. |
| not(EXP) | Returns the bitwise complement of the 8-bit number. |
| not(EXP)r | Returns the bitwise complement of the 16-bit number. |
| EXP1eEXP2 | Gets the expression2-th bit of the 8-bit number in expression1. Unlike assembly, the leftmost bit (high order) is bit 0 and the rightmost bit (low order) is bit 7. The bit checking is modular. That's the Euler's constant "e". |
| EXP1eeEXP2 | Gets the expression2-th bit of the 16-bit number in expression1. Unlike assembly, the leftmost bit (high order) is bit 0 and the rightmost bit (low order) is bit 15. The bit checking is modular. That's the Euler's constant "e". |
| EXP-1 | Finds the reciprocal of the 8.8 fixed point number. |
| Command | Description |
|---|---|
| Pxl-On(X,Y) Pxl-On(X,Y)r Pxl-On(X,Y,BUF) |
The pixel at (X,Y) becomes black on the main buffer, back buffer, or specified buffer respectively. |
| Pxl-Off(X,Y) Pxl-Off(X,Y)r Pxl-Off(X,Y,BUF) |
The pixel at (X,Y) becomes white on the main buffer, back buffer, or specified buffer respectively. |
| Pxl-Change(X,Y) Pxl-Change(X,Y)r Pxl-Change(X,Y,BUF) |
The pixel at (X,Y) inverts color on the main buffer, back buffer, or specified buffer respectively. |
| pxl-Test(X,Y) pxl-Test(X,Y)r pxl-Test(X,Y,BUF) |
Returns 1 if pixel is black and 0 if pixel is white at (X,Y) on the main buffer, back buffer, or specified buffer respectively. |
| Line(X1,Y1,X2,Y2) Line(X1,Y1,X2,Y2)r Line(X1,Y1,X2,Y2,BUF) |
Draws a black line from point (X1,Y1) to (X2,Y2) on the main buffer, back buffer, or specified buffer respectively. |
| Rect(X,Y,W,H) Rect(X,Y,W,H)r Rect(X,Y,W,H,BUF) Key: ref() |
Draws a filled rectangle with its upper left corner at (X,Y), a width of W, and a height H on the main buffer, back buffer, or specified buffer respectively. |
| RectI(X,Y,W,H) RectI(X,Y,W,H)r RectI(X,Y,W,H,BUF) Key: rref() |
Inverts a filled rectangle with its upper left corner at (X,Y), a width of W, and a height H on the main buffer, back buffer, or specified buffer respectively. |
| Circle(X,Y,R) | Draws a circle with center (X,Y) and radius R on the buffer. |
| Command | Description |
|---|---|
| Pt-On(X,Y,PIC) Pt-On(X,Y,PIC)r Pt-On(X,Y,PIC,BUF) |
The 8x8 sprite pointed to is drawn at (X,Y) to the main buffer, back buffer, or specified buffer respectively. Does not clear the area behind it. |
| Pt-Off(X,Y,PIC) Pt-Off(X,Y,PIC)r Pt-Off(X,Y,PIC,BUF) |
The 8x8 sprite pointed to is drawn at (X,Y) to the main buffer, back buffer, or specified buffer respectively, but clears the area behind it first. |
| Pt-Change(X,Y,PIC) Pt-Change(X,Y,PIC)r Pt-Change(X,Y,PIC,BUF) |
The 8x8 sprite pointed to inverts its pixels at (X,Y) to the main buffer, back buffer, or specified buffer respectively. Does not clear the area behind it. |
| pt-Get(X,Y) pt-Get(X,Y)r pt-Get(X,Y,BUF) Key: Plot2() |
Returns a temporary pointer to a copy of the 8x8 sprite at (X,Y) on the main buffer, back buffer, or specified buffer respectively. |
| pt-Get(X,Y,BUF,TEMP)
Key: Plot2() |
Copies the 8x8 sprite at (X,Y) on the specified buffer to 8 bytes starting at TEMP. Returns TEMP for convenience. |
| Pt-Mask(X,Y,PIC)
Key: Plot1() |
The 8x8 grayscale sprite (2 layers) pointed to is drawn to both buffers at (X,Y). Areas clear on both layers are transparent and the other combinations are 3-level grayscale. |
| Pt-Mask(X,Y,PIC)r
Key: Plot1() |
The 8x8 grayscale sprite (2 layers) pointed to is drawn the main buffer at (X,Y). Areas clear on both layers are transparent and the other combinations are black, white, and invert. |
| Bitmap(X,Y,BITMAP)
Key: Tangent() |
Draws a bitmap to the screen or buffer at (X,Y). The structure pointed to should be height (1 byte), then width (1 byte), then the rows of the image padded to the nearest byte. |
| rotC(PIC)
Key: ShadeNorm() |
A copy of the 8x8 sprite pointed to is rotated clockwise 90 degrees. Returns a pointer to that new rotated sprite. Cannot be used recursively. |
| rotCC(PIC)
Key: Shade_t() |
A copy of the 8x8 sprite pointed to is rotated counter-clockwise 90 degrees. Returns a pointer to that new rotated sprite. Cannot be used recursively. |
| flipV(PIC)
Key: ShadeX2() |
A copy of the 8x8 sprite pointed to is flipped vertically. Returns a pointer to that new flipped sprite. Cannot be used recursively. |
| flipH(PIC)
Key: ShadeF() |
A copy of the 8x8 sprite pointed to is flipped horizontally. Returns a pointer to that new flipped sprite. |
| Command | Description |
|---|---|
| Disp PTR | The string that is pointed to is displayed at the cursor position. The cursor moves with the string. If it reaches the end of the screen, it will loop around to the next line. |
| Disp EXP▶Dec | The number is displayed as a decimal at the cursor position. The cursor is then advanced 5 spaces. |
| Disp EXP▶Char
Key: ▶Frac |
The ASCII character is displayed at the cursor position. The cursor is advanced 1 space. A new line is added if it hits the edge. |
| Disp EXP▶Tok
Key: ▶DMS |
The 1 or 2 byte token is displayed at the cursor position. The cursor is advanced. A new line is added if it hits the edge. |
| Disp i | The cursor moves to the next line down. This is the imaginary, not lowercase 'i'. |
| Output(X) | The cursor moves to the cursor position (X/256,X%256). |
| Output(X,Y) | The cursor moves to the cursor position (X,Y). |
| Output(X,Y,... | The cursor moves to the cursor position (X,Y) and whatever follows is displayed at that position. |
| Text EXP | The text pointed to is drawn at the current pen location. See "Fix" command for drawing details. |
| Text EXP▶Dec | The number is drawn as a decimal at the current pen location. See "Fix" command for drawing details. |
| Text EXP▶Char
Key: ▶Frac |
The ASCII character is drawn at the current pen location. See "Fix" command for drawing details. |
| Text PTR▶Tok
Key: ▶DMS |
The 1 or 2 byte token POINTED TO is drawn at the current pen location. Notice how this is different than Disp. See "Fix" command for drawing details. |
| Text(X) | The text pen moves to the position (X%256,X/256). |
| Text(X,Y) | The text pen moves to the position (X,Y). |
| Text(X,Y,...) | The text pen moves to the position (X,Y). Whatever comes next becomes the "Text" command. |
| EXP▶Hex
Key: ▶Rect |
Converts the number to hexadecimal and returns the pointer to that string. |
| Fix 0 | Small size font. Calculator should exit in this mode if changed! |
| Fix 1 | Large size font. |
| Fix 2 | Normal colored font. Calculator should exit in this mode if changed! |
| Fix 3 | Inverted font. |
| Fix 4 | Text is drawn directly to the screen. Calculator should exit in this mode if changed! |
| Fix 5 | Text is drawn to the buffer. |
| Fix 6 | Automatic scrolling on last line of display. Calculator should exit in this mode if changed! |
| Fix 7 | No scrolling on last line of display |
| Fix 8 | Bitmaps are drawn directly to the screen. Calculator should exit in this mode if changed! |
| Fix 9 | Bitmaps are drawn to the buffer. |
| Command | Description |
|---|---|
| "" | Adds the string to program memory, but without the ending character. |
| [HEX] | Adds the hex to the program memory. |
| [PICVAR] | Absorbs the picture from RAM into the program (usually 96x63 and 756 bytes). Only the source needs the pic, not the executable. |
| [PICVARr] | Absorbs the tile map picture from RAM into the program. 12 tiles across, 7 tiles down (672 bytes). Only the source needs the pic, not the executable. |
| Data(NUM,...)
Key: ΔList() |
Adds the bytes to program memory. Numbers ending with r are added as 2 byte numbers. |
| Buff(SIZE) Buff(SIZE,CONST) Key: det() |
Creates a buffer that is size bytes large, filled with the byte constant, or with zero if unspecified. |
| DATA→NAME | Saves the data's pointer to the static variable. Also terminates current string if applicable. |
| CONST→NAME | Saves the constant's value to the static variable. |
| NAME | Returns a pointer to the start of the data. |
| L1 L2 L3 L4 L5 L6 |
Returns a pointer to some free memory. L1 = 714 bytes (saveSScreen) Volatility: LOW L2 = 531 bytes (statVars) Volatility: LOW (Do not use this area when custom interrupts are enabled, including Mirage OS) L3 = 768 bytes (appBackUpScreen) Volatility: MED (Saving to back-buffer will corrupt) L4 = 256 bytes (tempSwapArea) Volatility: MED (Corrupt when archiving/unarchiving in program) L5 = 128 bytes (textShadow) Volatility: MED ("Disp","Output", and "ClrHome" will corrupt) L6 = 768 bytes (plotSScreen) Volatility: HIGH (Any buffer drawing will corrupt) |
| {EXP} | Returns the single byte the expression points to. It will be in the range 0 to 255. |
| {EXP}r | Returns the 2 byte data the expression points to. |
| {EXP}rr | Returns the 2 byte data the expression points to but in reverse order. |
| EXP1→{EXP2} | The single byte of Expression1 is stored to where Expression2 points. |
| EXP1→{EXP2}r | The full 2 bytes of Expression1 is stored to where Expression2 points. |
| EXP1→{EXP2}rr | The full 2 bytes of Expression1 is stored to where Expression2 points but in reverse order. |
| sign{EXP}
Key: int() |
Returns the single byte the expression points to. It will be in the range -128 to 127. |
| nib{PTR}
Key: iPart() |
Returns the Nth nibble in RAM. Since there are twice as many nibbles as bytes, make sure pointers are multiplied by 2. |
| nib{PTR}r
Key: iPart() |
Returns the Nth nibble in an Application. Since there are twice as many nibbles as bytes, make sure pointers are multiplied by 2. |
| EXP→nib{PTR}
Key: iPart() |
Writes to the Nth nibble in RAM. Since there are twice as many nibbles as bytes, make sure pointers are multiplied by 2. |
| Fill(PTR,SIZE) | The byte already at Ptr is copied to all the bytes after it until Size bytes have been filled with that value. Zero is not a valid Size. |
| Fill(PTR,SIZE,NUM) | Size bytes of data starting at Ptr are filled with a value. Size must be greater than 1. |
| Copy(PTR1,PTR2,SIZE)
Key: conj() |
Size bytes starting from Ptr1 are copied to Ptr2 onwards. Zero is not a valid Size. |
| Copy(PTR1,PTR2,SIZE)r
Key: conj() |
Size bytes ending at Ptr1 are copied to Ptr2 moving backwards. Zero is not a valid Size. |
| Exch(PTR1,PTR2,SIZE)
Key: expr() |
Size bytes starting from Ptr1 are exchanged with Size bytes starting at Ptr2. Zero is not a valid Size. |
| length(PTR) | Returns the number of bytes from the pointer to the next zero data element. |
| inData(BYTE,PTR)
Key: inString() |
Searches for the byte in the zero-terminated data. If found, it returns the position it was found in (starting at 1). If not found, 0 is returned. |
| Equ▶String(STR1,STR2) | Checks if 2 null-terminated strings are equal. Returns 0 if equal and non-zero otherwise. |
| SortD(PTR,SIZE) | Sorts up to 256 bytes of data from largest to smallest starting at the pointed address. |
| cumSum(PTR,SIZE) | Calculates the checksum of some data starting at the pointer for size bytes. |
| Command | Description |
|---|---|
| Ans | Returns the OS's "Ans" variable as an integer. This is unrelated to any Axe value. Throws an error if out of range. |
| EXP→Ans | Stores the expression into the OS's "Ans" variable as an integer. This is unrelated to any Axe value. |
| GetCalc(PTR) | Finds the object who's name is pointed to and returns a pointer to the start of its data, or zero if it was archived or not found. |
| GetCalc(PTR,FILE) | Attempts to create a file of the OS variable who's name is pointed to so it can be read from archive. Returns 0 if the variable was not found, and non-zero otherwise. |
| GetCalc(PTR,SIZE) | Creates an OS variable who's name is pointed to in RAM and makes it Size bytes large. Returns a pointer to the start of data, or zero if there was not enough RAM. Overwrites existing variable, even if it was in archive. |
| UnArchive PTR | Tries to unarchive the object who's name is pointed to. Returns 1 if it could unarchive and 0 otherwise. Gives a memory error if not enough RAM. |
| Archive PTR | Tries to archive the object who's name is pointed to. Returns 1 if it could archive and 0 otherwise. Gives a memory error if not enough Flash Memory. |
| DelVar PTR | Deletes the OS variable who's name is pointed to even if in archive. Nothing happens if the variable does not exist. |
| input | Prompts for an input string just like BASIC then returns a pointer to the string structure. Don't forget, its a string of tokens, not characters. |
| float{PTR}
Key: iPart() |
Converts the float at the pointed address to an integer. Floats are 9 bytes large. |
| EXP→float{PTR}
Key: iPart() |
Converts the expression into a float and then stores it at the pointed address. Floats are 9 bytes large. |
| Command | Description |
|---|---|
| FnInt(LBL,FREQ) | Turns the subroutine into an interrupt and then turns interrupts on. The frequency can be (fastest) 0, 2, 4, or 6 (slowest). L2 is used for interrupt data so do not use L2 for storage when using interrupts. |
| FnOn | Turns on interrupts. |
| FnOff | Turns off interrupts. |
| Stop | Stops execution until the next interrupt occurs. Interrupts must be on or else the calculator will freeze. |
| LnReg | Returns the calculator to regular interrupt mode. MUST be called before exiting the program if using interrupts. |
| Command | Description |
|---|---|
| Port
Key: ClrTable |
Returns the status of the link port as a number 0-3. |
| EXP→Port
Key: ClrTable |
Sets the link port to a given status with a number 0-3. Must exit program with status 0 if changed! |
| Freq(WAVE,TIME)
Key: SinReg |
Sound is played out of the link port. Wave is inversely proportional to frequency and Time must be much greater than Wave to hear anything. |
| Send(BYTE,TIME) | Tries to send the byte across the linkport. It will keep trying until the other calculator receives the byte or time runs out. Returns 1 if the byte was sent successfully or 0 if it timed-out. Time is in the order of microseconds. |
| Get | Checks if the sender is trying to send anything. Returns the byte if it was received or -1 if nothing was sent. No waiting is done. |
| New In This Version |
| Changed From Last Version |
| Existing Command |