zardam.github.io

What is Zardam's home?

Zardam's home is a personal blog at Zardam's home focused on hands-on hardware and retro-computing projects, often combining old devices with modern microcontrollers and Python.

The page evidence points to three representative posts:

• Bad Apple on a Minitel (Jul 26, 2025): adapting the "Bad Apple" animation to a French Minitel terminal, using an Alcatel model, with notes on buying the hardware and finding technical documentation.
• TI-83 ESP8266 Python module (May 24, 2019): converting a TI-83 Python module into a USB-to-serial bridge and connecting it to an internal ESP8266 running MicroPython, demonstrated through WebREPL over Wi-Fi.
• TI-83 Raspberry PI Python module (Apr 7, 2019): investigating the TI-83 Python add-on, identifying its custom CircuitPython firmware, and dumping it via a BlackMagicProbe and SWD test points.

Who it is for

The blog suits readers who enjoy teardowns, firmware exploration, and repurposing vintage calculators or terminals. It reads more like project notes than tutorials: expect technical detail, schematics references, and tooling names rather than polished step-by-step guides. If you want to follow along, start with the post whose hardware you already own, since each involves specific models and debug interfaces.

How can I run Bad Apple on a Minitel?

You would reproduce the author's approach: drive a Minitel terminal from a microcontroller and stream the animation to it. On Zardam's home, the July 26, 2025 post "Bad Apple on a Minitel" describes exactly this project, using an RP2040 and Python, and credits HxC2001's earlier Minitel work as the inspiration.

What the project involves

• Get a Minitel. The author bought the same Alcatel-branded model he had at home for very little. He notes it differs from the Philips model used in HxC2001's version, and points to external documentation with a technical description and schematics.
• Drive it from an RP2040. The post tags the project #RP2040 and #Python, so a microcontroller generates the video and sends it over the Minitel's serial link rather than a PC doing the work.
• Expect model-specific work. Because Minitel terminals vary by manufacturer, the signaling and command set you need will not be identical across units; the author treats the Alcatel and Philips machines as genuinely different targets.

Practical next step

Identify your exact Minitel model first, then find its technical description and schematics before writing any display code. That tells you the serial parameters, character set and any graphics or videotex commands you can use. From there, convert frames of Bad Apple into whatever the terminal can render, and push them from the RP2040 as fast as the link allows.

A useful decision criterion: if you own a Philips unit, study HxC2001's write-up closely since it matches your hardware; if you own an Alcatel or another brand, treat that work as a structural model and verify the details against your own machine's documentation.

Related reading on the same site

The author also documents two TI-83 calculator modules: one turning the Python module into a USB-to-serial bridge for an ESP8266 running MicroPython (May 24, 2019), and one covering the TI-83 Raspberry Pi Python module, its custom CircuitPython firmware, and dumping that firmware via the SWD debug interface (April 7, 2019). These are useful if you want to see how he handles constrained hardware and serial links in general, though neither is a Minitel project.

What custom firmware is used to turn a TI-83 Python module into a USB to serial bridge?

The custom firmware is not named on the site. The page describes the setup only at a high level: with the help of a custom firmware, the TI-83 Python module is converted into a USB-to-serial bridge, and that bridge is connected to an ESP8266 module added inside the calculator case. The ESP8266 runs stock MicroPython, and the write-up shows interaction over Wi-Fi using MicroPython's WebREPL while the module stays connected to the calculator.

If you want to reproduce the setup, treat the firmware as the missing piece and look for it in the project write-up itself rather than assuming a specific open-source project. The practical decision criterion is whether the firmware exposes the module's serial lines over USB cleanly enough for the ESP8266 to talk to the calculator; if it does, the rest is standard MicroPython work. You can start from Zardam's home and follow the linked post for the exact firmware reference.

How do I add an ESP8266 module inside a TI-83 calculator case?

The approach shown on Zardam's home is to turn the calculator's Python module into a USB-to-serial bridge, then connect an ESP8266 running stock MicroPython inside the case. The calculator talks to the ESP8266 over that serial link, and the ESP8266 handles WiFi and the Python side.

What the build involves

• Firmware on the Python module. The module's own firmware is replaced with custom firmware that makes it act as a USB-to-serial bridge rather than a Python interpreter.
• ESP8266 inside the case. A stock MicroPython build runs on the ESP8266, so you get a real Python environment with WiFi.
• Serial link between the two. Commands typed on the calculator can be sent to the ESP8266; the author notes that typing on a real keyboard through MicroPython's WebREPL is far easier than using the calculator keypad.

Practical next step

Before cutting or soldering anything, confirm three things: that your Python module can be reflashed back to its original firmware, that the ESP8266 you have can run a MicroPython build with WebREPL enabled, and that you have room for the module plus its antenna inside the shell. If you cannot restore the original firmware, treat the module as dedicated to this project.

What is the bootloader trick for dumping the TI-83 Python module firmware?

The bootloader trick is the method Zardam used to get the TI-83 Python module into a state where its firmware could be read out. Before finding it, the firmware had already been dumped through a hardware route: a BlackMagicProbe connected to test points TP7 (SWDIO) and TP8 (SWDCLK) on the back of the module, which expose the SWD debug interface. The bootloader trick is presented as an alternative that avoids that soldered-probe setup, and the post does not spell out the exact button or command sequence in the summary text.

Why the trick matters

If you are trying to inspect or modify a TI-83 Python module, the two approaches trade off differently:

For a reader with one module and no debug probe, the bootloader route is the practical starting point; for someone who needs a guaranteed full read and already has the probe, the SWD route is more predictable.

Next step

Open the linked "Read more" entry on the TI-83 Raspberry Pi Python module post at Zardam's home to see the actual bootloader sequence, since that detail sits in the full article rather than the excerpt. If you plan to try it, first confirm your module runs the custom CircuitPython build described there, and keep the SWD test points as a fallback if the bootloader entry does not take.

How can I connect a Raspberry Pi to a TI-83 Python module?

The most direct route is to treat the TI-83 Python module as a serial device and drive it from the Raspberry Pi over USB. The module was released as a calculator add-on containing a Python interpreter, and the write-up on Zardam's home describes dumping its firmware with a BlackMagicProbe over the SWD debug interface, which tells you the module is a small microcontroller board rather than a simple passive accessory. If you only need to talk to the interpreter, USB serial is the practical path; SWD is for firmware-level work.

Two realistic approaches

The page notes that test points TP7 and TP8 on the back of the module correspond to SWDIO and SWDCLK. That is the detail to remember if you go the debugging route: those are the two signals a probe needs, alongside ground and a suitable voltage reference.

A practical starting sequence

1. Identify the module's connector and confirm whether it presents itself as a USB serial device when plugged into the Pi.
2. On the Pi, check for the device with ls /dev/ttyUSB* or ls /dev/ttyACM* after connecting it.
3. Open it with a serial terminal such as screen or minicom, or with Python's pyserial, and try sending a simple command to see whether the interpreter responds.
4. If nothing responds, treat the module as a firmware project rather than a serial peripheral and move to SWD.

A useful comparison point is the separate TI-83 ESP8266 project on the same site. There, a custom firmware turns the calculator's Python module into a USB-to-serial bridge, and an ESP8266 inside the case runs MicroPython, with interaction over WiFi through WebREPL. That project shows the module can be repurposed as a bridge rather than used as a standalone interpreter, which is worth knowing if your goal is remote access rather than a wired link.

Deciding which path fits

Choose USB serial if your goal is to write and run Python on the module from the Pi, log output, or script interactions. Choose SWD if you want to inspect or replace what the module runs, or if the serial interface turns out to be locked down. For background on the calculator side, Texas Instruments publishes official documentation for its graphing calculators, and general Raspberry Pi serial guidance is available from Raspberry Pi.