TinyScreen+, or How to Add Animated Miniature Displays to an EVA Pod Model

MAY 2023 UPDATE:

I no longer recommend this product. If you want a quick and simple solution like this, the new TinyTV 2 is out, and has a much higher resolution screen.

Alternatively you can use an 0.85" screen such as the M5Stack AtomS3 or the Lilygo T-QT Pro for the two front screens. You can then use build an animated GIF and display it using the Arduino_GFX library by moononournation. (ie: ignore the video approach)

However, the best solution is a Lilygo AMOLED device, which has an absolutely perfect high-resolution screen with excellent off-axis viewing. I would now recommend that instead, though it's a bit large and will take some work to fit inside the Moebius kit.

I'm keeping this page here for historical reasons, though the information here is now obsolete.

Introduction

I wanted to find the simplest way to make working video screens for Moebius' model kit of the EVA pod from 2001: a Space Odyssey. The solution here is pretty good. But it’s not quite effortless or plug and play.

When the TinyScreen+ product is updated it should be a simple matter of copying a movie onto a memory card, clipping a couple of bits of hardware together, and plugging it into a USB power source.

Until then it’s an open source device which requires one line of code deleted. Not too bad if you’re familiar with Arduino boards. Read on for more details!

Movie magic

All the spacecraft featured in 2001 boasted full complements of digital flat-panel displays, continuously updated by on-board computers. High tech stuff!

So high tech, in fact, that the filmmakers didn’t use a single computer to create this futuristic illusion. Because digital technology like that simply did not exist in 1968.

Instead the film's effects team laboriously constructed loops of movie film and projected these handcrafted “computer” sequences onto flat screens built into the sets. Those sleek modernistic consoles were actually concealing clunky 1960s 16mm projectors and miles of wiring!

Working model displays

Fast forward to the year 2019, and we now have actual digital flatscreen technology. In fact, we have screens so small they can fit inside scale models. And I thought it’d be fun to put working LCDs inside the Moebius EVA pod. This model kit is scaled to 1:8 of the original, making it possible to put working displays in the control panels.

The screens look like this. Are they are sharp as a decal or a printed slide? Nope. And they do look pretty crappy in photos and in video.

But they make up for this limitation with the fact that they glow and flash and draw your eye to the animation. In real life, especially in the context of a model cockpit filled with lights, the screens buried in the panels look pretty great.

I decided to go for something as simple as possible for the displays. The problem turned out to be trickier than I expected.

Basically the ideal would be:

• A set of colourful and high resolution displays, controlled by as few microcontroller computers as possible.

• Using TFT LCD or OLED technology; ideally the latter for improved off-axis viewing.

• The displays would show either carefully constructed slideshows or else premade movie loops.

• They would need to be driven by microcontroller devices capable of being powered down and powered up without having special shutdown sequences used, (ie: unlike a desktop computer).

• They should be able to run off battery or power adapters.

• They should require a minimum of hacking and coding to work, since that would limit the people who would be able to use the thing.

• They should immediately start playing a video when powered on.

• Ideally they should be cheap, though I was resigned to this being one area I'd have to compromise on!

Screen clearance

The biggest problem is actually physical clearances. The two frontmost displays aren’t bad. As long as you have small enough LCDs, there’s plenty of separation. You definitely need two LCDs here since the front screens aren’t at the same angle. The front display openings are each about 13.5 x 14.5mm in size.

There's adequate clearance to fit a pair of 1 inch square display boards under the front screens. This is a TinyScreen+.

It’s the two pairs of side displays that are kind of a problem. This is partly because they’re closely spaced with only a narrow bar between them, and partly because one of the screens is fairly close to the interior wall, especially in one corner. The side display openings are about 16.5 x 17.3mm in size, with a 1.6mm separator bar between them.

One other problem is that you're going to end up with some of the buttons around the left and right screen pairs being light-blocked by the display boards. This means it's going to be difficult to illuminate them properly. Oh well.

This 1.54" diagonal LCD panel is too small to cover both display openings, and too large for two of them to be installed. You need a 1.8" display to cover both openings.

So your choices for the side displays are:

• two very small displays, side by side. These probably will need a black mask around the edge.

• one 1.8" rectangular display that covers the opening for both screens.

  • just have one of the screen pairs active and the other one a static backlit picture.

• scrap the LCD idea altogether, but that would be sad.

I wasn’t able to find any animation-capable LCDs that were the perfect size to cover the display area. Larger displays exist of course, but it’s hard to find one big enough to cover both screens but small enough to fit neatly into the console. A 1.8" display capable of showing video is probably the best solution here in terms of coverage, though of course you'll have to construct complex video files that show both screens' images at once. Having one working screen and one fake screen seems kind of lame to me. So the compromise I found was to use two slightly smaller screens. Of course, the 2001 screens were square, and commercial LCDs are basically all rectangles, so you have to have dead and covered areas on either side of the display anyway.

I looked at a number of options, but many display/microcontroller combinations (especially a bunch of really nice high resolution ones) weren't able to redraw instantly, which resulted in a pretty awful window-blind effect. I had to rule those out, since the display has to be able to show an image without a visible redraw period.

Ultimately the TinyScreen+ seemed a reasonable way to go. Unfortunately it requires a minor software change to be fully usable, which will put it out of the reach of less experienced users.

A TinyScreen+, with its optional silver battery pack, over top of one of the side panels. Note how the screen has been rotated 90° to clear the other display opening more easily. Even with a screen this tiny you're still blocking the light to the buttons running around the perimeter of the display. And there isn't enough room to fit the opposite display easily. You have to rotate the board so that the memory card is at the bottom, and cut a notch out of the diagonal angled plastic frame.

This page gives some detailed instructions on how to use the TinyScreen+ solution to create your animated screens.

TinyCircuits

The TinyScreen+ product from TinyCircuits is a fairly self-contained way to build a working display for a Moebius EVA pod. The main advantage of this product is simplicity - the thing is basically turnkey in operation. Just load a movie file onto a memory card, clip the bits together, and turn it on! The second advantage is size – at about an inch square, the product is indeed tiny.

The OLED display they use is also perfect for the front two screens. It's just a tiny bit smaller than the openings on the front, which is fine. Unfortunately the screen areas are slightly too small for the outer pair of screens, so you will have a bit of a black strip all the way around the screen edges, but it's not too bad. Especially since the console and frame are both painted black anyway. You'll also have to cut a notch in the angled side of the kit's styrene frame to handle the screen that's furthest from the window, and install the screens at angles to each other.

TinyScreen+ Tech Specs

<begin nerdy stuff>

The screen, if you're interested, is an OLED device (not an LCD or TFT LCD) capable of displaying 96 pixels horizontally by 64 pixels vertically. The active display area (the actual glowy bit) is about 20mm wide and 13mm tall. This is an unusual aspect ratio of about 1:5. Since it's an OLED it does not have an LCD-style backlight; each pixel lights independently.

It supports 16 bits of colour, and video at up to 40 fps, CPU/bus traffic dependent. The display is marketed as a 0.96" or 24.4mm screen, and is a UG-9664HDDAG01 developed by Univision Technology of Taiwan. The total size of the device is 25.8 x 25.0mm. It uses an SSD1331 display controller chip developed by Solomon Systech of Hong Kong.

This display and driver combo is also sold by Adafruit as their 0.96" mini color OLED, incidentally. Sadly, I don't recommend the Adafruit version for two reasons. First, it's not capable of rapid redraw the way the TinyScreen+ is (see the section on Adafruit at the bottom of this page) and second, the Adafruit panel is mounted on a large board which makes it impossible to place two OLEDs side by side with a small gap.

The CPU is an Atmel ATSAMD21G18A; basically the same ARM Cortex-M0+ microcontroller used by the Arduino Zero. It's compatible with the Arduino development environment.

<end nerdy stuff>

TinyScreen+ versions

There are a couple of ways of buying the product, including buying a TinyDuino CPU (computer) board and TinyScreen video screen separately. This does give you some flexibility of placement, since the board and display are separate pieces.

However, the easiest approach is to buy the full TinyScreen+ product, which combines the CPU board and video screen, glued together into one package. However the CPU doesn't come with much by the way of onboard storage, so you need to add a daughterboard (a "TinyShield") with a memory card reader. This is where you'll store the actual movie file.

The board on the left is the TinyScreen+, seen from the bottom. The display isn't visible since it's glued to the front. The wide rectangular connector is for attaching add-on boards, known as "shields".

The board on the right is the memory card reader shield which fastens onto the bottom of the TinyScreen+. Note how it has a microSD memory card already plugged into it.

So. Attach a microSD card reader board to the TinyScreen+, load your movie onto the device using a micro SD card, plug the TinyScreen into USB power using a micro USB cable (the kind that come with older Android phones and many other devices), and off you go.

There are two ways of buying this combination of components.

TinyScreen+ purchasing options

First, you could buy a TinyScreen+ and purchase the microSD card reader board separately from TinyCircuits, for a combined price of about $55 USD. Clip these boards together, load a movie onto any micro SD card, put the card into the card reader on the board, plug it into USB for power, and you’re done! This is the cheapest option they sell.

Second, TinyCircuits sell a combo pack for about $60 USD. The Tiny Video Player Kit contains a TinyScreen+ CPU board and display, the SD card reader, an insanely tiny loudspeaker, and a lithium cell. This bundled pack is cheaper than buying all the ingredients separately. However since microSD cards are so inexpensive, if you don't need a battery then it's probably cheaper to buy the TinyScreen+ and SD reader board as above.

Clockwise from top: the TinyScreen+ CPU and OLED display, a 290 mAH lithium cell, a 16x9mm speaker, a clip-on microSD card reader and audio device. microSD card in the middle.

TinyScreen+ features

There are a few things of note on the TinyScreen+ board:

• • There's a wide tan-coloured expansion socket for attaching additional functionality. In our case we just need a microSD card reader board, but you could add other stuff such as Bluetooth boards that permit remote control features. This would allow you to control your screens using a mobile phone, but would take some work to implement.

  • a silver-coloured micro USB port for data and power.

  • a small slider switch for turning the board on and off.

  • an amber LED. This flashes briefly when the board is connected to USB power - it's not a spark or anything! It also glows when the battery is charging

  • a small tan-coloured plug for fastening a 3.7 volt lithium cell.

  • four pushbuttons for controlling optional features, such as cycling through different movies.

    • To put the device into bootloader mode for software updates, press the button nearest the USB port while turning the unit on.

Lithium cell

The integration with an optional 290 mAh lithium pack is pretty convenient. Just plug it into the main board and it’ll charge up when the board is plugged into USB. Then, when USB power is pulled, the device automatically switches to battery power. Handy!

Whether you need this for an EVA pod, I don’t know. Since the teeny lithium cells can’t really power many LEDs as well. But it is a cool feature.

The power socket for the battery can also be used to supply power to the device if you aren’t able to use the micro USB port. So if you need to put the display up against something in a way that blocks the USB port then you’ll have to use the battery socket instead.

Audio

The SD card reader board also contains an audio decoder and socket. This can drive a small loudspeaker, allowing you to add monaural sound loops to your movies.

The speaker that ships bundled with the Tiny package is a really minuscule 16x9mm ovoid-shaped loudspeaker designed for mobile phones etc. It’s not big enough to be particularly useful for the pod model I’d say. But you could plug in a slightly bigger one for sound effects purposes.

Multiple speakers

Multiple loudspeakers are probably not useful in most EVA pod contexts. Though I can think of one way they could be really cool. And that is synchronizing audio.

For example, you could have one CPU playing a movie containing a background audio loop of general pod sound effects. Then, if you wanted to reenact the scene where Bowman attempts to rescue Frank, you could have a separate CPU playing the radar loop with the audio track synchronized to the flashing image on the screen. Since the “radar beep” sound would be independent of the general background noise you could enable it or disable it at will. For example you could have a pushbutton that you could press to switch between video loops.

Multiple displays

It’s possible to drive two LCDs using a single CPU, which of course would lower costs. However this is more complex to implement than the simple turnkey option since you'll have to modify the software yourself. You also lose framerate, but frankly that doesn’t matter for the EVA pod displays - smooth real-time video playback isn’t that important here, as the movie's displays were basically glorified slideshows.

For this option you'd need to buy an additional TinyScreen and a Ribbon Cable Extender.

Static image slideshow

I've basically focused on video playback, since I think it's the easiest way of slapping together a slideshow that resembles the animated display screens used in the movies. However, it's not the only way to do it. You could, if you wanted to, design some pretty elaborate code that would load up bitmap images, (converted to .tsv files in the context of the TinyScreen products), display them with varying time values, and could even output text onto the screen to simulate the sort of terminal displays seen in the films.

However, I think this is a pretty labour-intensive way to do things, and also requires writing and compiling code. So I don't see the point of taking this approach, especially given the low-resolution displays in question.

Drawbacks of the Tiny products

The main drawbacks of the Tiny screens are:

• • They’re not very high resolution and the colour they produce isn’t very bright or saturated. If you're used to the modern high-rez displays used by mobile phones and smart watches, this display will look a bit old-fashioned.

  • Like most OLEDs and LCDs of this type they tend to flicker when recorded by a video camera or a phone, because of screen redraw rate issues.

  • Their display areas are slightly too small for the side screens of the Moebius model, so you have to put a thin black frame around the screen in order to conceal the edges.

  • Despite their small size they're still a bit fiddly to install on the side screens, because of the aforementioned clearance problems with the boards as a whole.

  • They’re a bit expensive if you plan on animating all six displays. It'll cost you nearly as much as two Moebius EVA pod kits, in fact! Yow.

  • Finally, there's an issue with the current firmware – it displays the movie's filename over top of the movie. This is kind of a show-stopper, but TinyCircuits are working on an upgrade to the TinyScreen+ device that will eliminate the problem. Until then, it's not quite ready for widespread use unless you're an experienced computer hobbyist who can follow the steps I list below.

Using the TinyScreen+

These are the basic steps for setting stuff up.

Prepare a video

First, make the video. This I did by capturing screenshots of the EVA pod scenes from the movie. I then rotated and distortion corrected each frame that I wanted using Photoshop, and exported the images as JPEGs. Since the screens are so tiny and low-resolution, it doesn't matter that the screenshots are a little bit on the low-rez and blurry side. There's no point reconstructing the images as vector art for super-precise pictures when you're scaling the stuff back down to the size of a thumbnail anyway.

Note that some people have used shots from the movie of the HAL 9000 displays. The problem with this is that the HAL displays aboard the Discovery One spaceship show a bunch of stuff that doesn't make sense inside an EVA pod, like HIB for hibernation status or NUC for the nuclear engines. If you're going to the effort of making these damn displays, I figure you may as well make them look accurate!

Assemble your screenshots into a video timeline using an editor program. I used iMovie, since it's free with Macs, but anything will do, really. You can copy and paste various screens to get the repeated flashing effects of various displays. Video editors make it easy to display static images for the varying periods of time required (a second here, 1/10 second there).

The main limitation with iMovie here is that it's not capable of letting you move static images easily within the frame. Which is a problem if you want to generate a movie where the image is right up against the side of the frame rather than centred in the middle. One way around this is to import the movie into Keynote and move the movie where you want it to be, then export it again. You can also specify the exact pixel size and aspect ratio within Keynote this way.

The Keynote method is also a simple way to rotate the movie and align the square image up against the end of the rectangle. This makes it easy to produce a rotated image if you want to place one of the screens 90° from the others, for ease of installation.

Convert the video

Export the movie from your video editor as an .mp4 video file. Other formats probably work also, but this worked for me.

TinyCircuits have created their own video format for the screen. This is called the .tsv (TinyScreen Video) format, and is proprietary to the board. The TinyScreen+ is not capable of playing back standard video files, so you have to convert your movie into a TinyScreen+ movie. There's no way to preview your .tsv file – it can only be played back by the TinyScreen hardware.

Launch the TinyCircuits TSVConverter program on a Windows machine. You then simply select your video file and click the "convert" button.

Mac users will soon be able to run TSVConverter natively on macOS, but for now you either have to find a Windows machine or else run an emulation program such as WINE or VirtualBox to use the Windows program.

I haven't finished making videos for all six screens. Maybe I should make the stuff available that I've completed so far...

Copy the file onto a microSD card

Once you've converted your movie, copy it onto a microSD card. This can be done using a USB card reader or an SD card adapter if your computer has an SD card slot. You'll probably want to delete all the sample movies off the card first, of course.

Supply power to the TinyScreen+

Plug the TinyScreen+ board into a micro USB cable, and plug that into a USB power source. The device will start up. (if it doesn't, turn it on using the slider switch)

Since you won't be connecting each board to a data source, and you'll simply be using USB for power, you can buy a bunch of micro USB cables and solder the power leads together, then plug them into a regulated 5 volt power supply. You don't need a USB hub or anything. Just be really careful when you do this, as you don't want to send 5 volts down a data line on the cable!

If you find yourself in a situation where the USB socket is blocked you can also supply power to the board via the battery socket. This runs off 3-4 volts DC. You'll also need a tiny two-pin JST SH plug. These plugs are easily available on auction sites.

Awaiting a software update

There's one issue with the TinyScreen+ product which currently limits its usability as a turnkey device for your space pod screens. And that is that the current version of the device's firmware shows the filename over top of the animation by default.

The TinyScreen+ is showing the video file named "2001.tsv", which is why the black bar with the filename is shown.

I've been in conversation with Ben Rose at TinyCircuits, who was extremely helpful and has been working on a new version of the player software.

However if you're familiar with the Arduino coding environment, or feel like doing a little experimenting, I figured out a simple way to fix the playback issue. I outline it below, and it involves commenting out a single line of code. It is, incidentally, one of the awesome things about open source software. If you don't like something, just fix it yourself!

However it is a fiddly bunch of steps to get the Arduino environment working, and so inexperienced users will find it kind of daunting. I also offer no technical support for any of this, nor do I make any guarantees. This just worked for me!

But to reiterate, if you don't feel comfortable with the steps below, don't invest in a bunch of TinyScreens with the existing code, as you won't be able to fix them yourself. Wait until June, when the updated version is released.

Modifying the TinyScreen+ software

• First, download and install the Arduino IDE (integrated development environment) package onto your computer. It's available for macOS, Windows, and flavours of Linux.

https://www.arduino.cc/en/Main/Software

• Next, follow the exact steps listed on this page.

https://tinycircuits.com/blogs/learn/158833543-tinyscreen-setup

This procedure prepares the Arduino IDE for use with the TinyScreen+ device. Be sure not to skip any step, or else your IDE will be missing some critical component or other and will crap out on compilation! I'd recommend not following the "manually download the library" steps unless you're certain that the built-in Arduino method didn't work. I had problems that might have been related to that.

• Next, plug the TinyScreen+ into your computer using a micro USB cable. Be sure to use one that properly supports data (ie: can be used to sync or backup a phone to a computer) and isn't just a power-only USB cable.

• Get the TinyScreen+ into "bootloader" mode by turning it off if it's on, then pressing the pushbutton closest to the USB socket and turning the device on. The screen should indicate that it's in bootloader mode. If it doesn't do that, try again. You have to have the device in this mode for the ability to upload new software to it.

• Now you need to download the software that makes up the TinyScreen+ video player. Go to this page:

https://tinycircuits.com/blogs/learn/tiny-video-player-tutorial-in-progress

• Go to step 3 and find the word "Here". This links to the TinyScreenVideoKit code. Download the zip archive to your computer.

  • Open the file named "TinyScreenVideoKit.ino" using the Arduino IDE editor.

  • Look for the first line in the source that reads "printNicely(currentVideoName);" and comment it out (ie: prepend the line with a pair of forward slashes). That's it! The line should be in the "doVideo" statement, and should look like this when you're done:

  if (doVideo) {

    bufferVideoFrame();

    //printNicely(currentVideoName);

    writeToDisplay();

  } else {

• • Go to "Sketch > Verify/Compile" and make sure that the program compiles.

  • If it works, go to "Sketch > Upload" and upload your modified player program to the TinyScreen+ board.

  • The board should now reboot and, assuming you've got a .tsv video file on the board's microSD card reader, it should start playing the movie in a loop without any filenames or anything.

  • You're now ready to install your screen into your EVA pod!

Other ways to do it

There are, of course, a zillion ways to implement moving screens at this size, at all kinds of levels of cost and image quality. I've just come up with a solution that works for me.

• • Lou Dalmaso's five-part assembly video, including information on paint masks and LCD screens.

Contact

If you have any comments:

contact@theageofplastic.info

Note that I'm just a hobbyist doing all this for fun, so I can't guarantee that any information here is necessarily correct, nor can I necessarily support you with your projects! I have nothing to do with any of the companies mentioned here.