Current Streamstar Live Sports Production And Streaming Solutions have no built-in hardware interfacing solution for “standard” broadcast camera tally light. Such an interfacing means a contact closure for the corresponding on-air camera, via GPI port connected to that camera CCU (or any other GPI-based camera tally solution). Perhaps not such a big issue for the way some studios or broadcasters are working today, but possibly a true problem for those who really need it.

Depending on Streamstar version, the maximum number of managed cameras can be 2 or 4 or 6 or 8. The following presents two variants of a GPI tally interface for Streamstar, right from the start for up to 8 cameras:

  1. Arduino-based DIY tally interface
  2. Dedicated hardware tally interface (postponed)

(i) Arduino-based DIY tally interface

Assuming you would like to build a hardware interface by yourself, you have to:

  • get one Arduino UNO board (either original or clone) or one SparkFun RedBoard board ;
  • compile & upload the ssgpitally open source software on it, by using the Arduino IDE PC software;
  • get one (if target is up to 4 cameras) or two (if target is 5 to 8 cameras) 4 relay shield(s) for Arduino;
  • if target is 5 to 8 cameras, then modify one of the relay shields by hacking a few board copper tracks on that shield;
  • (recommended) get three or six M3, 12mm body length nylon/polyamide male-female standoffs (something similar to item no. 1733429 from Farnell ) and use them to secure the boards to each other; get four M3, 5-6mm body length nylon/polyamide male-female standoffs (something similar to item no. 1733426 from Farnell) and use them as feets for the whole ensemble; four M3 nylon/polyamide nuts (something similar to items no. 7016943 or 2494507 from Farnell) are also required.
  • Note: the 12mm body length of the standoffs between boards is determined by the height of the Arduino Type B USB connector and/or the height of the relay bodies on the relay shield and/or the height of the ICSP connector sandwich between boards; feel free to consider any other isolated bolts/nuts/standoffs/spacers/whatever solution that you like or have at hand.

Each relay coil from the relay shield is typically a 0,2W / 5V version and each relay LED is in series with a 1kΩ resistor, therefore the relay shield(s) overall current consumption will never exceed the 0,5A maximum limit permitted on USB 2.0 ports, even assuming a maximum of 8 on-air cameras at once. Due to this, combined with the fact that a typical Arduino UNO board equipped with an ATMEGA328P single-chip microcontroller requires less than 0,02A power supply, it turns out that the whole ensemble can be powered exclusively via the USB connection.

Constructive issues

“Standard” Arduino UNO boards have a 10,9mm high Type B USB connector, which may pose a real problem when combined with these relay shields: when placing the first relay shield on top of the Arduino board, depending on the actual purchased shield, the through-hole pins of the J1 terminal connector on the relay shield may protrude way too much under the rear PCB surface and so those pins may touch the metallic case of the Arduino Type B USB connector.

If a “standard” Arduino UNO board is used and if the actual purchased shield(s) happens to have the terminal connector pins as described above, then the pins of the J1 terminal connector must be trimmed. In order to do that, the best option is desolder that terminal connector, trim its pins and then solder it back as flat as possible. To be on the safe side, a thin isolated material should also be glued somehow on top of the Arduino Type B USB connector.

Note: depending on the actual purchased shield, two pins (the outermost) of the J3 terminal connector on the relay shield may also require a little trimming – although not that critical – as they may touch the plastic body of the Arduino external power supply connector. However, in this case there is no need to desolder the connector. This trimming can be seen in the third image below.

Illustration of the Arduino Type B USB connector problem (if so the case) and the recommended solution to solve it:

This may be the case on some relay shields ...
... in which case the pins from J1 terminal connector must be trimmed ...
... so that the solder bumps become as flat as possible

Note: SparkFun RedBoard has a smaller mini-B USB connector and therefore it does not suffer from this problem, but take note that this one may present another disadvantage, in that the mini-B USB connector is not that reliable – when compared to the Type B USB connector – in terms of mechanical cable lock.

As already mentioned, the relay shield for camera tally 5 to 8 (if required) has to be modified, because the relays command must be moved from default digital pins 7, 6, 5 and 4 to digital pins 3, 2, 9 and 8 respectively. For this to happen, four copper tracks from the relay shield must be hacked and the command circuit must be redirected with the help of four additional wires. This hack can be seen in the image below.

Circuit redirection on relay shield for camera tally 5 to 8:

Digital pin 3 → trace from former pin 7
Digital pin 2 → trace from former pin 6
Digital pin 9 → trace from former pin 5
Digital pin 8 → trace from former pin 4

Note: the actual correspondence between the redirected tracks and the “new” digital pins is of no importance, as long as the software makes the proper association between camera numbers and the corresponding digital pins. The image above reflects the correspondence as currently set by parameter BOARD_OUT_PINS in the provided software. Feel free to consider it otherwise, both hardware and software.

The stacked ensemble can simply stay “as is”, i.e. each board inserted into the other one with their pins & headers, and that's it. However, in order to have a more robust ensemble, a few standoffs are to be mounted between the mounting holes of the boards. In this regard, on latest Arduino UNO revisions – and on SparkFun RedBoard as well – the mounting hole near the SCL pin does not allow any large diameter mounting hardware, so, just for that particular mounting hole, the standoff must be mechanically hacked with a help of a cutter or something. This hack can be seen in the image below, as well as the final ensemble.

Stiffening the whole ensemble using nylon/polyamide standoffs:

Hacked standoff near the SCL pin
Stacked ensemble for up to 8 cameras

The stacked order of the boards is of no importance. To be noted that, on these relay shields, each terminal connector provides both contact closure and contact opening, while a camera tally needs only the contact closure section.

If all these steps have been followed so far, then the correspondence of each terminal connector with the respective camera is as follows:

  • for unmodified relay shield:
    • J1 = CAM 1
    • J2 = CAM 2
    • J3 = CAM 3
    • J4 = CAM 4
  • for modified relay shield:
    • J1 = CAM 5
    • J2 = CAM 6
    • J3 = CAM 7
    • J4 = CAM 8

The effective relay contact closure on each terminal connector is between COMx and NOx, where x is the respective J number.

Software issues

The required software is available below for download. It can be directly compiled and uploaded by using the Arduino IDE PC software.

Current software version is 1.6 (click here for versions history).
The software is published under the GPLv3 license.
The software includes an optional I²C LCD display routine, disabled by default, originally created during the testing period. Although in normal use it has no practical purpose, it can be easily activated – and used for whatever – by changing the LCD_INSTALLED parameter to true. However, the actual code is customized for the LCD2S-162 interface from Modtronix (Serial LCD 16x2 Daughter Board); therefore, in order to use it with another I²C LCD display, the code has to be altered accordingly.
The details regarding the exact steps for compiling and uploading the above software by using the Arduino IDE exceed the purpose of the present page.

To connect the interface to Streamstar, a suitable virtual COM port driver for USB is required to be installed on PC. Different Arduino UNO boards may have different USB-to-serial converters, so the actual driver depends on the existing chip from the given board. A few known variants are as follows:

  • original Arduino UNO V3 uses a ATMEGA16U2 chip → drivers are available by installing the Arduino IDE PC software;
  • some Arduino UNO V3 clones use a CH340G chip → drivers should already be pre-installed in MS Windows 7/8/8.1/10; if not, suitable drivers can be obtained from the CH340 chipset manufacturer drivers web page ;
  • SparkFun RedBoard uses a FT321XS chip → drivers are available from the FTDI VCP drivers web page .

Note: the details regarding the exact steps for installing these drivers exceed the purpose of the present page.

Finally, the tally port has to be set up in the Streamstar own interface. This should be done via icon → GENERAL icon → TALLY PORT tab → STREAMSTAR TALLY item → select the corresponding COM port of the interface → click APPLY → that's it. However, please note that right after connecting the DIY tally interface to Streamstar, the very first camera switching will not trigger any tally relay at all – see the Important note under the next paragraph.

Testing (optional)

The interface functionality – and also its responsivity – can be tested without connecting it to Streamstar, just by using the small Python utility below. It should run under Python 3 and the SERIAL_PORT parameter must be set in accordance to the actual COM port as allocated by PC's OS. The easiest way to find that port is to look under the Arduino IDE menu > Tools > Port after connecting/disconnecting the Arduino board to PC's USB port.

Important: all Arduino UNO boards, regardless the variant or version, have the serial DTR signal connected to the nRESET line. This is required when programming the board via USB, in that the board gets reset first and only afterwards the compiled software gets uploaded. However, for the present case, this behaviour has also an undesired effect: upon connecting to Streamstar, the interface will react only after a few camera switchings, because at the very first switching the board will reset first and only then will do the right thing. This behaviour can be put in evidence also with the above small Python utility. In theory, the DTR circuit can be disabled (cut its trace or something), but in practice this is not feasible: the physical circuit is not that obvious and without it the board will no longer be programmable via USB (but it will continue to be programmable via ICSP header, though). The dedicated hardware tally interface presented in next chapter is not affected by this inconvenience.

(ii) Dedicated hardware tally interface (postponed)

GPI Tally Interface for Streamstar – dedicated hardware
GPI Tally Interface for Streamstar
(dedicated hardware)
This GPI tally interface for Streamstar is currently under development. Planned availability is Q4 2020 has been postponed for an unspecified date.

Here are some of its features:

  • Robust aluminium enclosure, good EMC shielding
  • 8 GPI floating outputs (relay contact closure), sharing a common 0V rail
  • One female DB-25 connector for all GPI outputs
  • Flexible pinout configuration for GPI outputs via internal jumper block, to accomodate various equipments
  • USB link to Streamstar via Type B USB connector
  • Powered through the USB connection
  • Optional wall brackets
  • Based on ATMEGA328P single-chip microcontroller
  • Based on the ssgpitally open source software

This is a commercial product. The price is estimated to be 380 € (ex-VAT).

Disclaimer: product availability, features, design, specifications and price are subject to change without notice.


Go to top