Basically what I want to do is use a microcontroller (RP2040) to serve a web interface whose backend controls a couple GPIO pins which are then connected to a TI-84+ SE's 2.5mm link port.

I have to ask, is there any real documentation out there on how exactly you're supposed to serially read and write data from the TI-84+ SE's link port? Does it use a standardized protocol such as UART? (Highly unlikely from what I've seen of TI so far)

Going a step further: is it possible, at all, for the TI-84+ SE to take keypad input via the link port? So for example, if I click a button on my microcontroller-hosted web page, then the backend of the webserver could send a specific set of signals down the link line and the TI-84+SE could somehow be "tricked" into thinking that a specific key was pressed. I am aware that this calculator has no concept of multithreading or concurrency, but what I basically want to do is build a product that hosts a webpage to a PC, that the user can interact with to remotely control the calculator connected to the product with a 2.5mm link cable. Perhaps by emulating a keyboard, like the official TI-Keyboard but simulated.

The physical layer of the link port is kind of similar to I2C, but without a clock. Both lines (the tip and ring of the 2.5mm jack) have a pull-up to Vcc, and to send a 0 bit you pull the tip low then wait for the ring to be pulled down as an achnowledgement from the other device; then release the lines and wait for both to go high before doing the next bit. To send a 1 bit instead of 0, pull the ring down and wait for the partner to acknowledge on the tip. Bytes are sent least-significant bit first.

The ArTICL library is a handy reference; in particular, check out the TICL class which seems fairly clear. I suspect there's actual documentation of the physical layer somewhere, but it was easier for me to figure it out from the ArTICL code than figure out where that is.

---

Fortunately for what you want to do with regard to sending keypresses, it's supported by default by the calculator OS with a set of linking-related features that are collectively referred to as "silent linking" (in contrast with older calculators where you needed to go into a menu to get into receive mode, the 83+ family is always listening for incoming commands when in the OS). All you do is send two bytes 23 87 as a command, followed by a two-byte keycode (transmitted LSB-first). You'll get back two acknowledgement packets as detailed in the linkguide's Packet Formats page.

There's even a ArTICL example that uses this feature which I expect can get you started.

It's convenient that Merth keeps a copy of the linkguide online for us to link to, but that's simply a copy of the linkguide package from ticalc.org so if you want to see everything documented there it might be easier to download a copy.

Thank you so much @Tari for the resources; given the realtime nature of the Internet and seeing how data can occasionally disappear without a trace, I now host my own copy of the linkguide at https://gitea.hdg57.eu.org/hackerdagreat57/ticalc/raw/branch/main/linkguide/index.html. Plus a few other things at https://gitea.hdg57.eu.org/hackerdagreat57/ticalc, including a version of ti83plus.inc by Brandon Wilson. Just in case, you never know when a copy might be handy.

Anyway, the things you pointed me to will immensely help with this project. The linkguide is so expansive that I also learned it is possible to passively capture screenshots of the TI-84+SE's monochrome screen after each keypress according to /linkguide/ti83+/screenshot.html!

In fact, there's an ArTICL demo of that feature as well: https://github.com/KermMartian/ArTICL/blob/master/examples/Screenshot/Screenshot.ino

Let us know if you have any additional questions as you pursue the project.

FTR, the linkguide has been at https://github.com/debrouxl/tilp-linkguide -> https://debrouxl.github.io/tilp-linkguide/ for a long time
But as hinted in the description or the tilp-linkguide repo, the implementation, namely https://github.com/debrouxl/tilibs , is both more complete and more correct than the linkguide, which I basically left alone since I became the libti*/gfm/tilp stack maintainer... nearly 15 years ago.

I can believe the "more complete" part for sure. There are a few holes in the link guide itself, like the real number format for the TI-89 Titanium. And there was one section in the TI-83+ link protocol page that just had "sdf" under it LOL, I forgot which section exactly it was though.

I may try looking through the tilibs source code if I deem it necessary, thanks! (Mirrored it to my server as well)

Well, you won't find that in libti* either: these libraries deal with the file envelopes, the link cables, and the protocols, but the content they read/write/transport isn't a concern to them

The generic TI-68k expression format is:
2 bytes: size of variable data, i.e. excluding the size bytes;
... expression data ...
1 (usually) or 2 bytes (for several types): EStack tag, see https://debrouxl.github.io/gcc4ti/estack.html#Tags .

For real variables, from memory, it should be [00 0A] [2 bytes exponent + 7 bytes mantissa, SMAP II BCD format] [1 byte: FLOAT_TAG=0x23]. On the computer side, that's wrapped in a 80+-byte header (variable name, variable type, etc.) and a 2-byte footer (checksum).

Ah, I see. Thanks.