Post updates on your projects here, or give other authors your feedback on their works in progress.

When posting about an upcoming program of yours, please include a link to any relevant information (screen shots, etc.) in the URL field.

To have an entry removed, please Contact Us.

I'm working on a preliminary design for a calc-based modem. As soon as I finish getting the details of PPP and DHCP worked out, I'll start on the hardware design. Calc-end software would handle the browser/e-mail functions. Sorry, broadband users, this would only work with dial-up connections. If this version works, I might design one for Ethernet...

I'm creating the framework to draw on the screen and manipulate almost any type of dialog widget such as text boxes, scroll boxes (spin or slider controls), push buttons, and drop-down menus. This is similar to but simpler and more extensible than the dialog box controls found on the TI-89/92(+) calcs.

Currently it's written in C (I can translate it by hand to ASM in a day or so) and supports spin boxes but will support user-defined widget types and some of the common widget types.

For now the framework has no hierarchy of widgets, but I *might* make it support nested widgets, such as to allow control widgets inside a dialog box widget, and the widget system would have cascading widget handlers.

With cascading widget handlers, each widget (a dialog box, for instance) can have a handler which can either ignore or handle any event not handled by a lower-level widget (e.g., a push button); this is similar to class hierarchies in OOP, having the qualities of inheritance, polymorphism, as well as override (though handler control is top-down to allow mandatory global behavior). This can give a great deal of flexibility in widget behavior.

I started this because I needed spin boxes, so I decided to make a general-purpose widget handler instead of limiting it to just spin boxes.

Any questions/comments/flames? Bueller?
Please reply by email.

Navigate! '04.26 for the ti-83 (plus/Se) will be redisigned for the use on Ti-86.

After starting the project on a solo base, I have had a lot of questions and suggestions. The first result was the release of an English version on the 83 platform.

And now we are with 3 people working on Navigate!. This will give the program a more steady base for longer support. (the just started timepatches are an example of this)

If you can't wait a little, you have to pay 129 us dollars for a commercial product. With some patience you get a freeware program that can do more than the commercial program.

The Ti 86 version will be released in English, there won't be a Dutch version yet.

I have spent over a year working on this; it is a whole new programming language for z80 TI-Calcs, and the compiler program for it. It looks like C++/Java with some interchangable BASIC-like syntax. High-Level OOP code compiles into assembly code (asm programs) for all models from TI-82 to TI-86

You can use this to do ANYTHING that can be done in assembly. Antidisassemblage is not big and easy to learn because only the fundamentals are built into it. Everything else (once finished) will be defined in "include files" (there is a special command to output asm code so you can integerate assembly into the language; most of this will be done in the background so that you don't have to worry about it).

I am looking for people who want to help test it, play with it, and when it is done (which will be soon) help write stuff for it. THIS MIGHT BE SOMETHING REVOLUTIONARY; people can make assembly programs from an easy to use High-Level OOP programming context (this is NOT ASSEMBLY, it compiles into assembly)

The language has these standard features: preprocessor commands, user defined variables of various datatypes, MULTIDIMENSIONAL arrays, functions (aka: subroutines procedures methods) that take and return values (parameters / arguments),
Global vars that can be used anywhere and local vars (temporary vars) that only have the scope of the function they are in, Static (fixed var addresses, more efficient) or dynamic (uses a stack to allow instances = RECURSION) functions, and a nice bunch of control-constructs to control program-flow

If you want to know more, or if you want to help, see my group: Antidisassemblage (the link is below my user-ID in the title bar of this post)

sorry, the link is:

http://groups.yahoo.com/ group/Antidisassemblage

(remove the SPACE before "/group")

You can email me at shkaboinka@yahoo.com
or send an IM to CrazyProgrammer

I am SO close to finishing up my compiler and everything, but before I finish it I am looking for a little help with some assembly stuff.

brief description:
when handling expressions, I'd use register-A or HL for general stuff, and then maybe B or BC during higher-order operations (order of ops), but * / and % ops require more complicated asm routines that use up lots of operators and there are different ways to do them, and I don't know which registers are the best to save info in and what the costs of "destroying" their values could be; I am not an expert at assembly. I am questioning whether I should do that, or not allow expressions but allow single operations that take one value like += *= /= etc, or just not allow * / and % (a combo of asm macros/routines can be made to do it anyways)...either way I need help. I can be more specific and detailed if you want to help.

If you can help me out (or know anyone who can), my info is in the title-bar of this post

ONCE AGAIN it puts HighLevelz80 as the link, though I have told it a million times to change the link Antidisassemablage!

If you want to help with my compiler (see above post), the group page is http://groups.yahoo.com /Antidisassemblage/
(withouth the space after groups.yahoo.com/; I had to put it there because ticalc wont allow words longer than 40 characters)

From experience with interpreters and just assembly in general: Never completely reserve any registers for a single purpose, and if you need to use a routine that destroys some registers with your data, just use push r/ pop r to save them.

I'm currently in the process of writing an RPN language for the Z80 processor. I've modeled the language after PostScript's generic RPN operators, excluding all graphics and string operators, but including the loop and flow control operators "loop", "for", "repeat", "if", "ifelse", and "exit".

The interpreter and the interpreted program are together in the same assembled program. It works in the same style as Sweet 16 for the Apple ][ (see link), in that the RPN code is in-line with Z80 code, delimited only by a CALL to the interpreter and a statement to return to Z80 code.

For example, assuming the interpreter is called "rpn" and the RPN operators begin with "r", here's a short program using this language:

call rpn ; start the interpreter
rpush 6 ; stack: 6
rpush 7 ; stack: 6 7
rmul ; stack: 42
rret ; return to Z80 code
; we're back in Z80 mode here

So far the interpreter is less than 400 bytes, but as I finish it more I expect it to grow up to 600 or possibly up to 800 bytes.

Right now, I'm planning (soon to begin) a collection of BASIC programs called Storm Suite. It will have four components (probably):
+ Tsunami (a shell using [omega]bscshll by Kirk Meyer)
+ Avalanche (a 7-class homework organizer)
+ Inferno (no clue)
+ Tornado (no clue)
+ Storm Launcher (just used to launch all the other programs)

Does anyone have an idea as to what I should do for Inferno or Tornado, or any ideas in general? (I'm thinking that I may have a draw tool, or possibly a chat program.)

At the moment I am creating X-Band a real time chat program (no update button) 30% done so far

I have a program in mind (ASM) that would allow you to send programs and maybe other types of data to other calculators. If you assigned a hex number to every character (a-z, A-Z, 0-9, + , -, *, /, and greek symbols) on the calculator, then transformed a program imto this hex code, sent it over a link onto another's calculator, and had his program identical to mine (made for the type of calculator he or she has) translate the code back into charcters and pasted it into a program of the same name as the original program. It would be done this way rather than translating a program into another calcs way of reading it so that I wouldn't have to make 42 different programs, only 7. I just need help as I am not affluent in Z80 ASM, and can't even contemplate 68000 ASM. I do not expect to be able to run 86 programs on an 83, just so that I can make 83 programs for friends and use my 86 to pass them on.

Great idea, but one problem. Computers and calculators alike transfer all data in the only language they know, which is binary and all those 1's and 0's can't be stored in memory as anything else but energy or 1's and 0's.
If only it were possible programs could be encoded to be much smaller than their binary size.

This is possible. ASM gives control over the voltage sent over the link, meaning you could make your own language especially made to transfer data called a protocol. This is how both an IBM and Mac can communicate over the internet. The variable could be converted into this protocol and sent over the line. The recieving calculator reads it then interprets it into its own variable format. This is well suited for sending strings, reals, or matrixes, but not programs due to the nature in which they are read. Assembly programs make calls to the ROM of the calculator it runs on, making it extreamely difficult since none of the ROMS between calculator models are the same. Basic programs are stored in compressed format, making them difficult to read. These also make calls to the ROM in the form of functions, but these are much more similar than ROM ASM calls. So some simple basic programs could be transmitted.

BASIC programs aren't hard to read! Just look at my 86BasicFormat in the Calc Technical Info section to see.

What do you mean, "converting to hex"? Hexadecimal is a way of REPRESENTING the number. Each character already has its own binary code-just look at Ciarin McCreesh's calculator ~ASCII reference. I think what you're talking about is a new transfer program/method, not converting anything. Still sounds like a good idea.

I have an idia for a SCREEN SAVER/ (GAME?) BASED ON the matrix the screen saver would be the matrix code going up and down the screen if you know how to do this email me at zorkon65@hotmail.com

Easiest:
k2=0
for(a,1,123,1)
while k2 is not equal to 103
getKy store to k2
if k2 does not equal 103:Then:dispG:Else:Goto Stop:End
rndInt(1,30,15) stored to F
Text(a,1,F)
if a==123:Then:a=1:End
End
Lbl Stop

Are you doing something similar to:
Program: ntoya3
ss=1
A=" "
A->B
B->C
While lngth A<33
If rand*1>=.5: Then: A+"1"->A: Else: A+"0"->A: End
If rand*1>=.5: Then: B+"1"->B: Else:B+"0"->B: End
If rand*1>=.5: Then: C+"1"->C: Else: C+"0"->C: End
End
ntoya2
Program: ntoya2
s=1
k2=0
While k2==0
getKy->k2
Text(s,1,A)
s+6->s: If s>=55: Then: s=1: End
Text(s,1,B)
s+6->s: If s>=55: Then: s=1: End
Text(s,1,C)
s+6->s: If s>=55: Then: s=1: End
End
ClLCD
?

Hey guys, are you trying to do this?
Here's the code, just gimme credit.

:ClDrw
:0\->\K
:While K\!=\22
:getKy\->\K
:
:randInt(0,30)*4\->\X
:randInt(0,9)\->\Y
:For(Y,0,Y)
:randInt(0,1)\->\A
:Text(Y*6,X,A)
:End
:
:randInt(0,30)*4\->\X
:randInt(0,9)\->\Y
:
:For(Y,0,Y)
:Text(Y*6,X," ")
:End
:
:End

I'm mostly done with an RPG dice program (yes, I know there're already n+1 of them out there) for TI-86 Basic. The difference between this and other die rollers (at least all the ones I've ever seen) is that mine allows you to type in an "equation" (for lack of a better term) such as '3d6+3', and it will parse it and determine a result.
The parser is mostly finished, with only a few bugs left to be worked out. Once I get done with that, all I'll have to do is implement the dice-rolling code, which won't take long.
What I really want to do is code this in assembly, but I don't know Z80 assembly yet. I'm learning, though - give me a month or two, and I'll probably have it to the point where I can rewrite the program in it.
Anyone who's interested in receiving a copy, has any other ideas they'd like to see me implement in the program, or already has a program that does the same thing, email me at <mamiller@olemiss.edu>.

Well, guess frigging what. The 'Fortune' program (available on the ASM Miscellaneous section of the 86 archive, though given what it did to my calculator, I wouldn't recommend you get it) crashed my calculator today, and I hadn't backed up the (finished) dice roller.

So here's to rewriting a program I'd already finished.