The project is finished!
Download here!

Compatible with:
• TI-83 Premium CE
• TI-84 Plus CE*
• TI-84 Plus CE -T*

Not compatible with:
• TI-83 Premium CE Edition Python (More information below)
• TI-84 Plus C Silver Edition
• Any monochrome calculator

*This program is not compatible with TI 84 Plus CE (-t) that are revision M or newer. To see what revision your calculator is, look on the back of it.
Look for a code that is formatted as <letter> - <number> <number> <number> <number> <letter (optional)>
For example: L-0315 or L-519M
If you see an M or a later letter at the end, then your calculator is revision M or newer. If you do not have an M or a latter letter OR you do not see a letter at all then you have a compatible calculator.

Video:


TI-Planet article here!

---

Yes, I know the topic name sounds scary and we already have a program (also incompatible with the Edition Python) that reduces the wait states. However, speeding up your calculator is only half the fun. Sometimes (such as when debugging a display issue in a BASIC program) it is useful to increase the wait states. Therefore I, with lots of help from Jacobly and MateoC, would like to introduce another small utility for the CE, a program that lets you change the wait states to any level! (above the hardware set value 5 of course)

I know messing with the wait states makes it very likely that you could end up crashing your calculator. That's why in my program I have added restrictions to the values so the average user will be less likely to freeze anything. If the general consensus of the members would like me to upload, I'll be including tips on how to prevent a reset.

My current protections cover:

• Detecting if Edition Python or Revision M or newer (wont run on those calcs)
  
• Setting the states too high without USB peripheral (255)
  
• Setting the states too high with USB peripheral (max 35)
  
• Setting the states too low with & without USB peripheral (min 1)
  
• Pressing [on] during the program. This is impossible since OnBlock doesn't work with the most recent OS.
  
• The authors from being held responsible if the user tampers with the source code or decides to bypass the restrictions and crashes their calculator

---

More information about the TI-83 Premium CE Edition Python and the TI 84 Plus CE Revision M or newer:
As some of you know, the TI-84 Plus CE Revision M and the TI-83 Premium CE Edition Python (which I'll refer to as the EP) has a different FLASH storage chip from the original TI-83 Premium CE (83PCE) and TI-84 Plus CE (84PCE). This means that the EP's FLASH storage is faster and has only 1 wait state (unlike the 9 wait states on the 83PCE and 84PCE). Therefor the FLASH 5 times faster than the 83PCE and 84PCE causing the OS to run 2 times as fast! Unfortunately, this means that TI had to change some things in the OS. Not only does the 1 wait state confuse my program, there's new evidence that the wait state port my program utilizes is completely ignored on the EP causing my program to have no effect on the EP! I'm unsure if this is bypassable, but until there's a way to bypass it I have to block the program from running on the EP to avoid any confusion.

TL;DR Due to the new, faster storage in the TI-84 Plus CE Revision M and TI-83 Premium CE Edition Python, my program will have no effect on the speed of that calculator. The original TI-83 Premium CE and the TI-84 Plus CEs that are older than revision M are still perfectly compatible.

For those interested in random tech facts:

• The old FLASH chips are parallel interface chips
  
• The new FLASH chip is a serial interface chip
  
• The new EP's FLASH chip is faster than the EP's RAM.
  
• If you attempt to run old versions of this program on an EP, it will whine about unsafe wait state values and report 0 wait states.

A few questions:
1) What's the purpose of this? If you want to debug BASIC, you use Pause's and Disp's. If you want to debug assembly you will use CEmu, so I don't really see why this is necessary.
2) Why would increasing wait states infect USB stuff, despite being slower than normally?
3) How can you set the wait states above 255 (as in "Setting the states too high without USB peripheral (undecided, likely less than 500)")?

1. For fun, why does anyone try do anything on their own? (After some thought I realized that there really wasn't a point to increase the wait states.)
2. I had to reduce the maximum wait states because; (wait states > 35) + being slower from the USB = a unusable (and sometimes frozen) calculator
3. I originally had the limit at 2000, but I didn't realize until 10 minutes ago that I had another piece of code that dropped the wait state limit down to 250. So I originally though that going up to 500 was possible. I'll edit my program and first post to reflect the max wait state change.

They say there is no such thing as a stupid question, so what is a wait state?

Essentially, when a processor asks for data from memory, it has to wait for it to come back because memory can't fetch data as fast as the cpu can process it. The number is just the amount of clock cycles that the processor waits when fetching things from memory, which is why it is directly correlated to the amount of instructions that you can do in a time slice, and therefore, how fast the device runs.

All right! I had forgotten about this project, but I just remembered it so I patched up (hopefully all) of the bugs and uploaded it to the Archives! It's currently pending...

Kind of a double post, but the file was accepted and you can download it here!

I would like to mention that, while a value of 1 will probably not result in an immediate crash like 0 will, it is definitely susceptible to occasional crashes. I do not recommend it for regular use.

See: http://wikiti.brandonw.net/index.php?title=84PCE:Ports:1005

Necro update! Now that the TI-83 Premium CE Edition Python has been released with no wait states at all, my program gets tripped up and I think actually slows down the calculator. So now I've got to account for this program being run on a Python Edition. Fortunately TI added a convenient P in the certificate at field 0x043!

My question is, how can I detect that P? Obviously I can't in BASIC, however is it possible to check the certificate in C? I found the os_GetSystemStats() command, however I'm not sure if it's compatible with field 43 since the docs don't show that field and since the Edition Python is the only calculator that has it. Could someone please clarify this?

Maybe something like this should do the trick, assuming TI doesn't decide to update the CE's OS to 5.6.x... I wouldn't put it past them though lol

Code:

I don't have access to a compiler, so maybe I've misunderstood the way GetBaseVer works, but I think it puts the major version in a and the minor version in b.

I appreciate your help mr womp womp but that's not quite what I'm looking for. I'm trying to read a field rather than getting the OS version. Is there a command that works in a similar way for the field I'm trying to read? I tried to compile the code with SC; the code compiles but it didn't seem to work, neither A or B changed values after running it on CEmu.

Code:

Thank you Mateo! Explaining what the code returns would have been welcome but I think we figured it out in SAX. The code returns 1 in Ans if the calculator is an Edition Python and 0 if it's any other CE.

Yeah but that code is wrong. Here's the correct code:


Code:

Ok, update time! Thanks to Mateo and DrDnar I got the Edition Python detection working!

While I was at that, I fixed some safety restrictions that were broken and I also added a hotkey! Now when you run the program, you can set the [+] key (conveniently right above [enter]) to immediately set the wait states to any safe value and get back to what you were doing. Press [mode] to change that value. (If there's no value or an unsafe value stored, then it will re prompt you to input a wait state value). Lastly, I Archived my settings list so it only gets deleted if you RAM reset within the program.

Hopefully you guys enjoy this update, I'm uploading it to the Archives right now! I just realized I'm gunna have to update my video on this project...

Haha, boy do I feel stupid. I accidentally update the project with everything except the main program! I've fixed that and uploaded another updated. Ugh, I can't believe I messed that up.

It has come to my attention that the new TI 84 Plus CE has the same, new FLASH that the Edition Python has. Therefor the program is not compatible with any type of TI 84 Plus CE that is revision M or newer. I have pushed out an update to address this and prevent the program from running on revision M (or newer) calculators.

I have 2 questions about this: will it stay the same after I do something like a memory reset? What is the default wait state?

No, the wait states will be reset to the default value of 4 when you do something like powercycle, RAM reset, or run an ASM program.

To account for this, I added a quick hotkey to the program so whenever you run it, you can just press [+] and it will automatically set the wait states to a value you decide on, then it will quit the program. Press [mode] to change the the hotkey value.

It appears I never linked my video about this project that answers those questions in more detail, I've added it to the first post!

Also hitting [MODE] resets the wait state.