Category Archives: Vista Systems

ScreenMaster III 3216 – Restoring a Classic – Part 3

We’re going to keep the train moving in this post, and we’ll talk about taking the console interface software from the last post and connecting it to a message queue and finally to a new interface that will emulate the ‘Montage II’ console using by all variants of the Spyder video processor. By the end of this post, you’ll see a fully working console implementation. Better yet, project partitioning described here can be adapted to easily support different button board hardware, so stay tuned For those impatient like me, I’ve also put the final state demo video right below this sentence (you’re welcome).

First the obligatory high level picture of what we’re going to be walking through (below). On the console we’ve deployed three different applications running effectively as Windows Services. In reality the message queue writer and console emulator apps are running as scheduled tasks which launch on startup, purely due to it being easy to deploy, but they effectively are treated like automatically running services.

  1. ScreenMaster to Message Queue Writer: pushes hardware specific messages to a message Queue using standardized JSON messages
  2. RabbitMQ: Freeware message queue service maintained by a 3rd party
  3. Spyder Console Emulator: Translates messages between a message queue and a Spyder server. A Spyder server will think it’s talking to a ‘Montage II’ controller, which is the official console hardware platform for Spyder.

ScreenMaster to Message Queue Writer

Hardware interfaces come in all kinds of shapes and sizes, and in the case of the ScreenMaster III 3216 there is a hard-coded IP address scheme that makes it hard to develop and debug using a PC other than the built-in one. Other hardware interfaces, like on the ScreenMaster II 1608, use a serial connection inside the console between the hardware and the PC. Due to this, it became obvious early on that normalizing the specific hardware interface using standardized messages on a message queue would be a big help for development and debugging. Another positive outcome is that software can be written for any hardware interface, using any software language, and alas long as it implements the same standard JSON message structures it’ll ‘just work’ with the rest of the application stack.

The code repository for the message queue writer lives in GitHub here. As of this writing, the JSON message formats have not been documented, and so someone interested in making their own interface can look at the full set of classes in the messages folder for the existing project. The general messages from hardware to message queue include Key Action (press/release), Joystick Action, Rotary Action, and T-Bar action. Messages from message queue to hardware include setting lamp(s) on or off, and setting quick key LCDs (color and text). A key being pressed on the console, for instance, would generate a JSON message that looks something like this:

{
  "keyIndex": 102,
  "isPressed": true
}

The other message payloads are similarly simple. I encourage you to take a look at the GitHub project for details. It’s intentionally a small project, and should be easily replicated or adapted to work with other hardware consoles. Here’s a little demo using RabbitMQ’s built-in management interface to get and set messages to the ScreenMaster hardware.

RabbitMQ

I won’t spend a lot of time on this one, since it’s easily Googleable with Bing, but for those of you asking ‘What the hell is a Message Queue and why do I care’? The short version is that message queues allow multiple applications to send and receive messages between each other. There are several different implementations and vendors to chose from, but one (if not the) most popular offering is called RabbitMQ. I’ve installed RabbitMQ on my console, and it runs as a service in the background and launches when the internal computer boots. This works great for the message queue writer and Spyder emulator apps also running on the console, but it’s also REALLY great because I can connect to it from my desktop workstation for development and debugging. Before this I was actually slinging code directly on the console.

But wait a minute, you say, doesn’t putting a message queue between a hardware button board and some software processing create a noticeable degradation in performance? Short answer is no. Slightly longer answer (and in encourage you to look into it more if you’re interested) is that message queues are used as the backbone for enterprises and other environments like stock trading software that demand ultra low latency. There are some configuration options around delivery guarantees that can start to add up in some scenarios, but for our use case we won’t notice any performance impact.

Spyder Console Emulator

With the message queue in place, I have a bridge between a specific hardware interface and a generic messaging system. During that development, it occurred that it might make sense to make another application that would emulate a real Spyder console and translate between the message queue and the Spyder processor. It actually works quite well.

Quick (and relevant) history lesson. The ScreenMaster 3 (and subsequent Montage I console) drew a lot of criticism for having an embedded Windows computer. Other manufacturers (Barco comes to mind) took the opportunity to smear the product as being unreliable because of the internal PC. As a result, the Montage II debuted without any internal PC. The console is VERY simple – it has some simple menu capability to set a local IP and an IP for the upstream Spyder server, and listens for a handful of messages which set button lamps on/off (with an RGB color palette – see picture below) and set LCD text. It will also send network (UDP) messages to the Spyder when a button is pressed/released or if the joystick, rotary, or T-Bar position changes.

If you’re following along in the paragraph above, you may have noticed a couple things. First is that with the console effectively being a ‘dumb terminal’, the Spyder has to manage all of the console state and logic. Second thing is that the messages to and from the console follow a pattern quite similar to what I described earlier with the ScreenMaster to message queue application. Knowing these things, I decided to make one more translator; this time a translator between my message queue and the Spyder console interface.

To make this translation application, I need to do a few things:

  1. Determine the button mappings used on Spyder’s Montage II consoles
  2. Define a mapping between buttons on the Montage II and my ScreenMaster console
  3. Write some software to emulate a Spyder console on the network so the Spyder hardware will actually think it’s talking to a console
  4. Make that software in the prior step interact with the message queue and translate messages back and forth.
  5. Add a key macro capability to the app which will ‘press’ the correct buttons to configure each of the segments of the console to ensure a desired state for the emulator.

I created yet another Github repository for my ‘Spyder Translator’ with the code and relevant documentation. I created a Visio file with breakdowns of both the M2C-50 (smaller) and the M2C-100 (larger) console button assignments, and I also made a mapping of keys to my ScreenMaster console. Eventually this made it’s way into a JSON configuration file that I put into the repository, but a nice visual representation is always helpful for me. Some pictures from the Visio mapping doc below for reference:

The source code for the Spyder translator project in GitHub isn’t too crazy, and for those interested in looking further it offers a peek at a reference implementation for how the Spyder video processors communicate with networked controllers.

I’ll leave it to the reader to look further at the code repositories and refrain from turning this post into a code dump, but I’d love to hear from anyone who found it interesting or was able to build on it to incorporate some other cool hardware.

So Now Where are We?

At this point the ScreenMaster 3 3216 is an effective tool for controlling a Spyder video processor. The button mapping I’ve created has the quick key buttons mapped as Spyder Function keys, we have source selection and a full transition controller, command key and treatment control. Below is a walk-through video that I put up on YouTube to show off what the console is capable of. I was recording and trying to talk at the same time, so forgive me for the (low) production quality.

Now What’s Next?

The path I’ve gone down so far has been fruitful, but I very much would like to have some better and more native control of Spyder. There are some things I didn’t care for much with the Spyder controller, like only being able to access a single page of command keys or function keys, and not being able to create new items. This is due to the Spyder console never really getting much love – being a play-out device was generally just ‘good enough’.

All that said, I think it would be cool to make a ‘real’ control desk for Spyder, with full control of building things like treatments, command keys, and function keys. Deep integration of the screens to bring better selection context and more rich experiences would really make this thing shine. The timeline will likely come down to how much community interest exists, particularly now with the ability to relatively easily incorporate new and different hardware.

For now, thanks for reading and following along with my project. I hope it is able to tickle a few nostalgia bones out there, as it has for me. Until next time!

ScreenMaster III 3216 – Restoring a Classic – Part 2

In the first post in this series, we walked through upgrading the internal PC hardware within a ScreenMaster III 3216 hardware controller. In this post, we’re going to start creating the software to communicate between the internal computer and the hardware buttons, joystick, rotary encoders, and T-bar. All of the work discussed in this post lives in a GitHub repository that you can look through and use.

Before we dive in, let’s quickly agree on some terminology. I’m going to refer to the buttons, joystick, rotary encoders, and the T-bar collectively as the ‘keyboard’. Additionally, I’m going to refer to the Windows PC-based computer inside the console as the ‘host’. When we want to turn on or of a lamp for a button, for example, we’ll consider that to be a ‘host’ to ‘keyboard’ communication. Alternatively, when a user presses a key or moves the joystick a ‘keyboard’ to ‘host’ message will be generated. Hopefully this makes sense. Luckily the GitHub repository mentioned earlier in this post uses the same terminology in it’s documentation.

So how do we interact with the console hardware?

Communication between the host and keyboard is all performed using an internal Ethernet connection. This proved to be extremely helpful when upgrading the hardware, since we didn’t need esoteric connections to interface with the hardware. The keyboard has a hardcoded IP address of 192.168.1.3, and is hardcoded to send event messages to our host computer at the IP address of 192.168.1.2. This is quite limiting, but since it was initially designed to be an internal Ethernet connection we simply added a second USB network adapter during our PC upgrade dedicated to this interface. The image below shows the high-level Ethernet connectivity within the controller:

Over Ethernet, the messages between the host and keyboard are all simple UDP packets, with a very basic structure. I won’t detail the protocol here, but if you’re interested I’ve written up the protocol and published it within the GitHub repo here. Effectively, here’s the main list of things that you can do:

Host to Keyboard:
– Set lamp lights on or off for each button
– Set the LCD button background to Off, Red, Green, or some alternating combination
– Set the LCD button text – 3 lines, 6 characters per line

Keyboard to Host:
– Get event when button is pressed or released
– Get event when the joystick x, y, or z axis value changes
– Get event when a rotary encoder is turned (+/- change value)
– Get event when the T-Bar position changes

Time to write some software…

I’ve written and published a .Net Standard 2.0 library to implement the keyboard protocol and make it easy to consume from an application. The repository (listed at the beginning of this post) makes it simple to subscribe to events and control the simple pushbutton lights and LCD display buttons.

The repository contains a console test application that subscribes to events and writes these events to the console output. It’s a good example of how to use the library, and I’ve included a snippet of the test program’s Main function below for reference:

using Spyder.Controllers.ScreenMaster3;

static async Task Main(string[] args)
{
    // Initialize connection to keyboard
    var keyboard = new KeyboardInterface();
    await keyboard.StartupAsync();

    // Subscribe to events from the keyboard
    keyboard.TBarValueChanged += Keyboard_TBarValueChanged;
    keyboard.KeyPressed += Keyboard_KeyPressed;
    keyboard.KeyReleased += Keyboard_KeyReleased;
    keyboard.RotaryValueChanged += Keyboard_RotaryValueChanged;
    keyboard.JoystickValueChanged += Keyboard_JoystickValueChanged;
    keyboard.KeyAction += Keyboard_KeyAction;
    Console.WriteLine("Listening for events");

    Console.WriteLine("Press enter to exit");
    Console.ReadLine();

    Console.WriteLine("Shutting down...");
    await keyboard.ShutdownAsync(); 
}

If you’re playing along at home, you can pull down the library and build it from source, or for convenience I’ve also published it as a Nuget package for easier consumption.

Mapping out the buttons

With a software driver library and a test application created, we can now go through the process of pressing and releasing every button on the controller, and watching the event data to determine the logical button ID associated with each physical button and rotary encoder. The console has well over 200 buttons, so it took a bit. My GitHub repo has a Visio document with some different pages that include the index map, and below is an image of this as well as a keycap map for the ScreenMaster III 3216.

Now where are we, and where do we go next?

At this point we have a controller with a modern computer inside, and we have a software library that allows us to interact with the hardware keyboard. With these in place, the real technical challenges are out of the way and we can focus on building an application to control something similarly modern. With my history and existing software libraries and software applications to control Spyder video processors, it’s probably not a spoiler alert to say this is where I’m heading.

I’m not sure yet if the next blog post will be software heavy (yet) – I’m planning to spend some time planning a good console application before diving too far into code. That being said, I couldn’t resist getting some simple app(s) started. As such, I’ll leave you with a quick video showing an app framework that works with the keyboard interface and is setting the selected page based from menu button presses.

If you’re still with me reading through this blog series, thanks! I don’t expect this project to amount to much more than a love letter to an old product that holds nostalgic value to me, but I hope it might resonate with a couple people out there. And if you’re lucky enough to have one of your own ScreenMaster III or a Montage controller lying around, let me know about it!

ScreenMaster III 3216 Console

ScreenMaster III 3216 – Restoring a Classic – Part 1

The ScreenMaster III 3216 and it’s half-sized little sibling the 1608 were some of my favorite consoles every made at Vista Control Systems (later renamed to Vista Systems and later acquired by Christie Digital). These were the first consoles to incorporate 15″ touch screen displays to compliment the massive button boards from prior console generations. This console, like others before it, were purpose built to control a combination of Folsom (now Barco) VFC-2200 scalers and either Extron, Pesa, or Sierra routing switchers. We’re talking analog video only here – this was the nineties after all, when 1080p video was king.

It’s worth a note that this console would be appear again in the future as the control surface for the Vista Montage video processor, painted in blue and re-dubbed as the Montage SC-3200 console. This stuff is all but lost in time, even on the internet these days, and so I’ve included a picture below for full historic reference.

Let’s talk about this got started

Let’s talk about eBay. eBay is a great place to get great deals, and is a great place to troll late nights when you can’t sleep to find stuff you didn’t know you needed (and probably don’t need). One night I happen to be aimlessly looking around the internet, and somehow I made it to this posting on eBay:

This picture of the console immediately gave me ‘the feels’, as it has solid sentimental value. I remember shipping the first of these consoles, sometime back in the nineties. We had a problem with a driver for an internal USB network adapter, and it was causing the console to bluescreen. We weren’t sure it was fixed, but I ‘thought’ I had resolved the issue with an updated driver. We got the console in it’s case and brought it to the back door. After talking a bit about this bluescreen, Jeff Wilson and I opened the console up and made sure it booted successfully five times. As long as it could boot five times in a row, then we’d ship it. Good news – that was the day unit #1 shipped.

<rant>Just to touch briefly on that last point – this was a time when Windows was considered to be generally unstable, and we caught a lot of flack from rental and staging customers (and competitors). Here we were though, shipping a device with Windows (NT Embedded I vaguely recall) and asking customers to entrust their high-dollar live events on it. Software bugs aside, I think this ask proved to be a reasonable one and these consoles were way ahead of their time (my opinion). </rant>

So this console on eBay had an asking price of $599, and I sent an offer for $299 which was accepted. I don’t remember the real figure, but I think this console cost around $45,000 new. From the pictures I could see some button-board activity and a boot failure, and so I knew that (1) the embedded part of the console was alive and (2) the PC was ‘alive’ and the Compact Flash card we used for the hard drive had likely failed. After some back-and-forth on the shipping, we decided to drop the shipping case to avoid going freight, and all-in I think I was down $500.

The arrival

It took about a week for my console to arrive, and it showed up packed tight with instant-foam in a box that must have had a roll of fiber tape for additional support. It took a solid hour to practically chisel the console out of this foam tomb, but it shipped in pristine condition so I can’t complain.

After getting the console freed from it’s shipping cocoon, I gave it a good look over and powered it up. The screen showed the same hard drive failure message that I saw on the eBay post. The quick-keys (the top-right green button array) showed diagnostic counters that I was able to use to verify that the buttons, joystick, T-bar, and rotary encoders were all functional (minus a few burnt-out incandescent switch lamps). So far so good. Next up is to take inventory of the computer hardware and try to get it working again, but before we move on go ahead and take a hard look at that good-looking piece of hardware 🙂 .

Console internals

When you open the bottom of this console, you immediately see that there is a LOT going on. Luckily, when we look closely at the internals of the console there are two main subsystems – the embedded computer (PC) and the physical control interface (buttons / T-Bar / Joystick) subsystem. The picture below shows the console on it’s side with the bottom removed.

The application board is the main embedded component which houses the programming required to read and write the physical hardware. Luckily for us, the interface between the embedded computer and this application board is Ethernet. It’s difficult to see in the pictures, but there is an Ethernet crossover cable between a second Ethernet port on the SBC and the application board. This is great, because it means that we can upgrade the embedded computer without worrying about obscure hardware interface dependencies.

Before we move on to replacing the embedding computer, let’s take a second to talk about the embedded computer that came with the console. This was an EBX form factor computer called the ‘Olympus’ and was manufactured by Arcom Controls (datasheet here). This was a 1.0 Ghz Celeron processor and 128MB of RAM. The hard drive was provided with a 128MB Compact Flash card, which has limited read/write cycles and almost certainly explains why the console eventually stopped working. I did try jump-starting the console with a new Compact Flash module, but the SBC was so old that it felt that even if I could run a modern operating system on it (unlikely) that it would be terribly slow. It was also sporting a 3.5″ floppy disk drive, for those of you who remember what that even is, and I knew that needed to be brought into the modern age as well. With that back-story out of the way, let’s get to upgrading.

Upgrading the Embedded Computer Hardware

Full disclosure here – this console sat on it’s side in my living room for several weeks, and I’d give it occasional blocks of evening and weekend time. This wasn’t particularly hard, but there were some time-consuming parts of the effort that I’ll bullet point rather than writing a book about:

  • Removed the prior EBX form-factor PC board and graphics adapter
  • Removed the existing floppy disk drive
  • Drilled holes in the chassis to fit a new Mini-ITX form factor PC
  • Bought a +12V to ATX power adapter module to power the new SBC
  • Added two USB to RS-232 cables to drive the touch screens
  • Added a USB to Analog adapter to drive the second touch screen (the SBC had one VGA port I was able to use as well)
  • Replaced the Neutrik Ethernet connector running to the back of the console with a new one
  • Modeled and 3D Printed a custom bracket to hold a new Solid State hard disk and expose 2x USB 3.0 ports to fit in the old floppy disk drive spot.

The mounting and retro-fitting of the new SBC and parts was a pain, but I’m pretty happy with how it came out. This thing feels like it could travel and be as reliable as the original console was. I am particularly proud of the 3D printed module that I made to hold the hard drive and expose a couple USB ports, and you can see this along with a bunch of other build pictures below

After the aforementioned evenings and weekends spanning may weeks, the hardware for the console was done. It was now sporting an Intel i7 processor with 16GB RAM and a 512GB solid state disk, and was running quite nicely. I did sneak in a picture of installing Windows on the replacement Embedded PC / Single Board Computer (SBC), but I’ve saved this for the last section of this post.

Let’s put Windows 10 on this thing

A modern console needs a modern operating system. I actually considered installing Ubuntu Linux for the fun factor, however ultimately I decided to install Windows 10 Pro. It’s less ’embedded’, but it allows for wider flexibility for software to run (including Vista Advanced / Spyder Studio / Spyder Client software).

One wrinkle that I did run into was around the touch screens. They have RS-232 serial controllers, and the native 3M driver didn’t work. I remember running into this with my Car computer touch screen (same hardware), and so I knew I needed to pony up and buy a license for a software called touch-base that makes the touch controllers work with Windows 10. Related note – the screens for the console are each 1024×768 resolution and VGA, and if I were braver I would crack open the top and try to replace them with some newer displays. Maybe someday.

Big reveal time

I don’t need a lot of words for this – I’ll let the pictures of the console working speak for themselves. For those curious, the pretty looking Spyder control software is the Spyder Client application that is available on the Windows 8/10 Store.

So where are we, and what’s next?

So we have a large powerful hardware console alive and well, and we have a working PC operating system on it. Probably a way over-powered PC in there hardware spec-wise, but we still don’t know what we’ll do with it so hard to say. By the time I write this, the console has actually been sitting in my dining room for the past two months. I’ve already done some development and created a software interface to integrate the hardware with the PC, but I’ll save that for a future blog post.

In the next post, I’ll talk about how the PC-to-embedded hardware interface works, and we’ll probably have a simple app to show take a look at. I expect the next post will be a bit shorter – this one was a monster and it feels like it just skims the surface. With that, thank you for reading and see you next time!

Building a Camera Tally Controller for Spyder

Over this past weekend I set out to create a camera tally device for the Spyder video processor.  Specifically, I wanted to try to use my relatively new Raspberry Pi 2 board running the Windows 10 IoT Core operating system to make something useful.  If you’ve read through my older blog posts, you’ve likely noticed that the Spyder is still my go-to target platform for playing with new technologies.  Let’s face it – when you’re playing with shiny new toys, it helps to mate it up with something you know very well so you don’t feel completely lost.  Before I get into the details, check out this brief video showing a working tally controller in action:

The whole process of building this device was simply fantastic.  The barrier to entry for people making hardware devices has gotten incredibly low over the past couple years, both from a cost and ease of development perspective.  The whole build process was very quick, and I had such a great time with it that I went ahead and put together a full 30 minute hardware and software video walk-thru for the project (more on this below).

Getting Started Making your own

To get started making your own, here are a couple links for the main hardware used on this project, as well as the wiring diagram for your reference.

Raspberry Pi 2 Kit ($70):  Amazon Link
8-Channel Relay Board ($9):  Amazon Link

Tally Wiring Diagram

Hardware Wiring Diagram for our Tally Controller

Links to the full source code, documentation resources, and a full YouTube walk-thru video are below.  This video has a ton of valuable information in there, covering the hardware specifics, Spyder implementation details, and the full process of creating our software application.  This is the first time I’ve gone through and made something this elaborate (and narrated the video), and I’ll be very interested to know what you think of it (so leave me a comment below if you’re so inclined).

GitHub Project (Source Code and Documentation):  Click Here

Next Steps

The tally controller we’ve created is certainly functional. but in it’s initial form the server IP address and tally source lists are hard-coded.  In the next stage of this project, we’re going to build a desktop application that can connect to the device remotely over the network and view/configure these properties.  We’ll also explore creating a user interface to run on the Pi’s HDMI output, which could be useful for monitoring and troubleshooting the device.

Until next time, take a look through those walk-thru video and the resources in the Github repository, and try to make one yourself.  I hope you enjoy going through this content as much as I enjoyed making it.

Spyder Client for Windows 8.1 – Live Control

One of my favorite areas working on in the Spyder Client for Windows 8.1 was the live view, which not only shows a real-time visualization of the Spyder server’s PixelSpaces, but allows for live interaction and command key creation. While it’s not necessarily new, I thought it would be fun to create a Camtasia video showcasing the live control available from the Spyder Client.  I certainly enjoyed making it, and I hope you enjoy watching it (and using it).

Under the Hood – Leveraging Spyder’s External Control

Internally, the Spyder Client uses the Spyder server’s publicly accessible external control protocol for all control actions performed by the application.  This is for a few reasons, one of the more notable of which is that Windows Store applications do not support .Net Remoting (which is how the Vista Advanced client communicates to Spyder).   If your curious how the Spyder Client is doing something you can simply check out the Spyder server’s logs to see what commands are being executed (see screenshot below).  Just make sure to set the server tracing level to information or success so that the command logs actually appear.  Of course, if you have a specific question, feel free to leave a comment under this blog post.  I’m always happy to help out a fellow coder.

Viewing remote server logs in Vista Advanced

Viewing remote server logs in Vista Advanced

Just in case you don’t already know, the external control protocol documentation is included with the installation of the Vista Advanced client software. If you have Advanced installed, then the external control protocol PDF document is already available from your start menu.