The device is capable of detecting input from a typewriter, enabling it to send and receive text to and from a computer via USB. It was specifically designed as a platform for playing interactive fiction games, particularly for custom software developed by Jim Munroe. Notably, no permanent modifications have been made to the typewriter, which is significant for preserving typewriters of personal value. Each key is connected to a solenoid using fishing line; these solenoids, which are electromechanical devices, activate when electric current is applied. The solenoids are arranged in a multi-layer structure beneath the typewriter. They are controlled by MOSFETs, which manage the high-power solenoids while being driven by lower-power circuit components. The MOSFETs are grouped in sets of eight and linked to shift registers, integrated circuits that expand the number of outputs from a microcontroller. The shift registers connect to an Arduino, which interfaces with the computer via USB. When a character is sent from the computer, the Arduino determines which solenoid to activate and communicates this to the shift registers. Key detection employs a method similar to that used in USB Typewriters, utilizing flattened resistors that create contact when a key is pressed. The mechanism is grounded to the electrical circuit to facilitate detection. Shift registers are again utilized here to expand input capabilities. Upon detecting a key press, the Arduino sends the corresponding character to the computer via USB, functioning as a serial device rather than a traditional keyboard. The structure is primarily constructed from plywood and threaded rod, with significant assistance from Dana Sarafinchan. Efforts are underway to enhance the design for improved robustness and ease of assembly, as the current assembly process is time-consuming and requires disassembly for troubleshooting. A laser-cut acrylic piece helps prevent tangling of wires and is etched with corresponding letters for clarity. The Arduino software is straightforward, focusing on translating characters to solenoid numbers and vice versa, while also managing timing to prevent jamming and create a more natural typing rhythm. On the computer side, a Python script facilitates serial communication with the Arduino, interfacing with Rezrov, an interactive fiction interpreter modified for specific output formatting. Schematics for the circuit boards are being developed, with the caveat that they were not used in the initial construction, thus their accuracy is not guaranteed. Each layer of eight solenoids is controlled by these boards, which are daisy-chained; the serial input of the first 74HC595 is connected to the Arduino, with subsequent chips linked through their serial outputs.
The described electronic system integrates multiple components to create an interactive typewriter interface for computer communication. The primary interface utilizes an Arduino microcontroller, which acts as the central processing unit, receiving input from the computer and controlling the solenoids that simulate key presses. The use of fishing line to connect each key to a solenoid is a clever mechanical solution that preserves the integrity of the typewriter while allowing for electronic control.
The MOSFETs play a crucial role in managing the power requirements of the solenoids, enabling the Arduino to control these high-power devices without direct overload. The shift registers, specifically the 74HC595 ICs, facilitate the expansion of both input and output capabilities, allowing for a more complex interaction between the typewriter keys and the electronic components.
The detection mechanism for key presses is a significant aspect of the design, utilizing resistive contacts to signal the Arduino when a key is engaged. This method ensures reliable detection while maintaining the original feel of the typewriter. The grounding of the mechanism is essential for proper electrical operation, ensuring that the signals are correctly interpreted by the Arduino.
The construction materials, primarily plywood and threaded rods, suggest a focus on durability and ease of assembly, while the inclusion of an acrylic piece for wire management demonstrates attention to detail in the design process. The software architecture, involving both the Arduino code and the Python script, highlights the integration of hardware and software in creating a seamless user experience.
Future improvements to the design may include enhanced modularity for easier assembly and maintenance, as well as potential upgrades to the electronic components to increase reliability and performance. The ongoing development of schematics indicates a commitment to documenting the design process for future reference and potential iteration. This project exemplifies the intersection of traditional mechanical devices with modern electronic control systems, paving the way for innovative applications in interactive gaming and beyond.It can detect what`s being typed on it. It can be used to send text to and/or receive text from a computer via USB. It was designed as a platform for playing interactive fiction games, in particular to play custom software being developed for it by Jim Munroe. As always, I hope to one day flesh this explanation out more, but since this is awork in progress, this will have to do for now.
One important note, of which I am (unduly) proud: no permanent modifications have been made to the typewriter. This might be important if, in the future, I use a typewriter that I care about better preserving. Each key is attached by fishing line to a solenoid, an electromechanical device that pulls down when electric current is passed through it. The solenoids sit behind and underneath the typewriter in a multi-layer structure. The solenoids are connected to a MOSFET, which allows the lower-power parts of the circuit to control the high-power solenoids.
The MOSFETs are connected in sets of eight to shift registers (integrated circuits that can, amongst other things, expand the number of outputs on a microcontroller). The shift registers are connected to an Arduino, which is connected to a computer via USB. When the computer sends a character to the Arduino, the Arduino chooses which solenoid to fire and sends that information to the shift registers.
Detecting when a key is pressed uses a method very similar to that used by the USB Typewriter : a series of flattened resistors are placed such that when a typewriter key is pressed, the mechanism makes contact. The mechanism has been grounded to our electrical circuit to enable detection. Shift registers are used again here, this to to expand the number of inputs rather than the outputs. When the Arduino detects a contact, it sends the appropriate character to the computer via USB. It`s acting as a serial device, though, not a keyboard (i. e. you can`t use it to type in a normal program in this configuration). Right now, all of the structure has been built from plywood and threaded rod, with the generous assistance of Dana Sarafinchan.
(Assistance is an understatement: he did almost all of it. ) Dana and I are working on designs to make the whole thing more robust and easier to assemble and maintain; currently, the assembly process takes several hours, and if anything goes wrong the entire thing needs to be taken apart. One element that makes things a bit easier is a laser-cut piece of acrylic to keep the lines from getting tangled, conveniently etched with the corresponding letter for each line.
The Arduino software is fairly simple, as explained above: mostly it handles translating characters to solenoid numbers, and keypress numbers to characters. The one other thing it does is some timing to make sure the typewriter doesn`t jam, and also to make the rhythm of typing appear less mechanical and more realistic.
On the computer side of things, I`ve written a small Python script to handle serial communication to and from the Arduino. The script talks to Rezrov, an interactive fiction interpreter written in Perl by Michael Edmonson. I`ve slightly hacked the source code to format the output the way I want it. Because they were requested, I`ve started drawing up schematics for the circuit boards, and I`ll post them and update them here as they become available.
Since I didn`t actually use these schematics when building it, I can`t guarantee that they`re perfect, so use at your own risk! Each layer of eight solenoids is controlled by one of these boards. The boards are daisy-chained such that the serial in of the first 74HC595 (pin 14) is connected to the Arduino, and the serial in of each subsequent 595 is attached to the previous chips` serial out (pin 9).
We use cookies to enhance your experience, analyze traffic, and serve personalized ads.
By clicking "Accept", you agree to our use of cookies.
Learn more