Hello everyone, long time no post!

As many of you may know I've done quite a bit of programming on the TI-84+CSE in the past, but I've been out of the calculator scene for awhile and I haven't been following anything regarding the CE. That said, I've had the hardware for awhile now, and I'm interested in programming it now that I'm out of school.

Anyways, a few questions:

Is the general consensus to go with C or assembly? I remember hearing about at least one project having reasonable success compiling C code for the CE, but I don't know if that project is still active, or how fast the resulting binaries were.

Leading from that, what compiler and/or assembler would I be using?

Are there any open source projects, or general guides for getting started with the CE? I remember a few key differences like the LCD being memory mapped, along with other I/O, but a list of interesting / useful things to know would be helpful if one exists. If not, I'm sure I can WikiTI my way to victory. Note that I'm not looking for a guide to eZ80 assembly; I've read way more than I ever cared to about how the processor itself works!

Have any emulators sprung up that would be helpful for development and debugging? (Sorry Kerm :/)

Also, and this is just sort of a general question, are there any cool projects I can look at to give an idea of just how fast this thing is at dealing with graphics?

Thank you all for your help!

The main difference between C and ASM is, that ASM is (much) faster, but C (much) easier. If you have any programming skills with C, or any language that looks like that, I would highly recommend that, and with the C SDK Libraries of our Mateo, you can create insane games. ASM is much harder, and therefore also more challenging, but I have the feeling that you can do more with pure ASM. It's your own choice

Depends on the chosen language. If you choose to create programs/games in ASM, you need to take a look at the ez80 docs, which gives a good explanation on how to install and use it. If you choose C, it's a little bit harder to set up , take a look at the CE toolchain, made by Mateo, and also the CE libraries, again made by Mateo.

There are some open-source projects in our archives. The best is (I think) to look at the source, and try to replicate what it does, both for C and ASM. The main difference with the CSE are
- memory-mapped screen, which is insane faster
- memory-mapped I/O
- 154K of RAM for the user, 256K in total
- simple calls instead of the idiot bcalls, which is again faster, and thus not memory mapping, what the old calculators have.
Other than this, I would just take a look at WikiTI (and also at the Recent Changes.. @Mateo ). This will give you a bunch of information, and of course, if that's not enough, feel free to post anything

The best, worst, easiest and hardest emulator that exists atm, is CEmu, cuz it's the only one . This is a highly-complicated, but user-friendly emulator, very good for debugging Many cool ideas have been added, and I need to say that I'm happy with it More information at GitHub and at least for Windows, you can download the latest version here.

Sure, take again a look at the archives, download some programs, and give it a try. As an example, I will take my Ultimate PONG 2.5. I think it's pretty fast and flexible, created in C, and I had to implement a slow-down, otherwise it was too fast. Now it updates both the paddles and the ball 1/8 of the time, at normal speed, so I hope you can imagine how fast it could be. For a program in pure ASM, I would like to highlight my ProgramViewer (which I still need to finish ), and take a look at that gif. No timer to slow it down, it's just pure ASM, and I would say it's really fast.


I hope I gave you enough information to start programming, either in C or ASM, and again, don't hesitate to post any questions. I had the same problem months ago, I started learning ASM, asked tons of questions (Mateo answered 95% of them ), and now I'm making a compiler, which is far from easy. Experience is very important. Good luck with everything!

Just to clarify, these tools, CEmu and the C SDK work on linux under wine, but there are certain things you need to do to make programs correctly. I really should write a guide/help contribute to the website they have...

Also, is ASM really that much faster? For pretty much everything, I thought Mateo mentioned that C was ASM, and that C is almost as fast as ASM. Not sure about that, but it seems plenty fast!

As PT_ said, C is easier and has a whole bunch of tool being develepode, there is an autotester now, and it is fast. For someone starting some sort of dev I'd say C,but you probably will use ez80 ASM

Don't forget that SourceCoder 3 lets you write ez80 ASM and TI-84 Plus CE C programs in your browser! TI-Planet also has a tool that lets you program C in the browser.

I'm glad to see you back and looking at TI-84 Plus CE development, Unknownloner! I look forward to seeing what you start creating.

There's still time to resolve this! I poked at it for a few days a month or four ago, and I don't think it would actually be that terrible for us to get rudimentary support working.

Just to clarify, C is assembly. While the compiler itself is not the best at optimizing, it can certainly create better assembly code than a lot of people. There are quite a few C programs that have been developed, here's a list if you need it. Some may use the older graphc library; the graphx library recently took the place of this in order to be easier to use and more optimized. One important thing to note that I think a lot of people forget is that you can make custom asm routines in .asm files inside your source directory, place a couple of xdefs in there, and the toolchain will assemble the asm source into your C code, if you need an efficient routine or something.

Programs in C:

Flappy Bird:
https://www.cemetech.net/programs/index.php?mode=file&id=1465

2048:
https://www.cemetech.net/programs/index.php?mode=file&id=1454

Stacker CE:
https://www.cemetech.net/programs/index.php?mode=file&id=1466

Mandragore:
https://tiplanet.org/forum/archives_voir.php?id=328137

Androides:
https://tiplanet.org/forum/archives_voir.php?id=335066

Crystann:
https://tiplanet.org/forum/archives_voir.php?id=353827

Minesweeper:
https://www.cemetech.net/programs/index.php?mode=file&id=1450

Game of Life CE:
https://www.cemetech.net/programs/index.php?mode=file&id=1445

1010 CE:
https://www.cemetech.net/programs/index.php?mode=file&id=1427

Ultimate Pong 2.5:
https://www.cemetech.net/programs/index.php?mode=file&id=1425

Checkers CE:
https://www.cemetech.net/programs/index.php?mode=file&path=/84pce/asm/games/CheckersCE.zip

Pokedex CE:
https://www.cemetech.net/forum/viewtopic.php?t=12717&postdays=0&postorder=asc&start=20

Pegs CE:
https://www.cemetech.net/programs/index.php?mode=file&id=1468

Text Viewer CE:
https://tiplanet.org/forum/viewtopic.php?f=12&t=18381&start=30

A small tilemap Pokémon Demo:
https://github.com/CE-Programming/libraries/tree/master/graphics/graphics_examples/demo_5

Happy Calc:
https://www.cemetech.net/programs/index.php?mode=file&id=1449

Misc question:

If I used LDIR (or similar) to copy data, logically the instruction will only be read once before entering the copy loop. This should result in much faster data copying than if I were to do it manually, because I'll only be hindered by the wait states on the memory I'm trying to move. Am I thinking about this correctly?

What then would the timing be on the instruction per byte? Read wait states + write wait states + 2? (The manual states that the instruction takes 2 cycles to execute)

True, you can find the timings here: https://wiki.tiplanet.org/Timings_des_instructions_eZ80