We used this in production this week and it worked great! I decided quickly though that this needed some form and style, not just function.
I also added the ability to be able to send a custom message to the screen!
The two buttons, “Send to Screens” and “Screens Back to Normal” in this panel are for my team, we use them to control MiniMEs on our Ross Carbonite switchers that send to our confidence monitors in the auditoriums.
I’ve updated the files on Github, if you want to go grab them!
Accurate clocks and countdowns can be a huge help when it comes to keeping services and productions on time. In our control rooms, we use these clocks:
They’re made by a company called ESE and they are basically network-based POE-powered NTP clocks. Because they are synced to NTP (Network Time Protocol), they are all in sync to the exact same time down to the second. We like them because they are big and grab your attention. We have them mounted above the multiviewers in each control room along with a couple of others in the actual tech booths out in the auditoriums.
But what about everyone else, like the band or people on stage? We don’t have clocks like this where they can easily see. And, the ESE clocks just tell the time, they don’t count down to a specific time.
I decided to do something about that. We have a server in the video rack room that has a video out connection into the video systems. It’s just a simple output of the secondary monitor. So, I figured it would be pretty easy to display a clock in a browser, and run it full screen on that secondary monitor, that feeds into the video router where I can then easily send it to any screen in the system that needs it.
This computer’s time is synced to NTP, so it stays in sync with the clocks in the control rooms, too.
I quickly decided to take this a step further and incorporate some countdowns. I had a couple of self-imposed restrictions though:
I wanted the countdowns to be customizable as our needs change, not just always count down to the same date/time.
I didn’t want to run a web server just to accomplish this, in order to pass new data to the locally running page/JavaScript.
I decided an easy method would be to have a separate JavaScript file that defines some countdown data, and include that in my main clock page, and just refresh the page to get the new data. I set the page to reload every 30 seconds by putting this in the <head> of the HTML:
<meta http-equiv="refresh" content="30">
I want my volunteers to be able to easily change this countdown data, without having to know JavaScript. Time for Dashboard! My directors have a Dashboard Custom Panel that I created for them which they use every week. It has a myriad of control options for them, so it was simple to just add another tab for the new countdowns.
Dashboard has a built in date picker and time picker, which makes it super easy.
I added two options in addition to the date and time, publish time, and expire time.
I limited it to these few options, between 2 minutes and 7 days. This determines when the countdown will appear on the screen.When a countdown expires, it turns red so it grabs your attention.
When the user clicks, “Update”, it runs a simple function that grabs all of this data, writes the JavaScript into a string, and then saves that into a file using the ogscript.saveToFile function. The file is saved to a common Dropbox folder that the server running the web page clock has access to.
Here it is in action. The countdowns automatically update when the page reloads every 30 seconds.
I’ve made the files available on my Github, if you can benefit from them! We will be giving this a trial run on Sunday.
Wirecast is a great tool for live streaming. At Fellowship Greenville, we use it as our encoder to stream to YouTube Live, whether it be the regular Sunday morning sermon live stream, or for special events, conferences, funerals, etc.
Lately, I’ve been working specifically on some improvements to make it easier for me to operate a live stream from our second auditorium, where we typically host funeral services and special events. Our live stream server is located in our control rooms in the main building, so when I am working tech for an event in the second auditorium, I am completely separated from the control rooms.
For regular Sunday services, that’s not a problem to be separated because we have a great team of volunteers working in both areas who stay in communication with and support each other. But for smaller services like a funeral, where it is typically only me and one other staff member running everything, it can be challenging to run a full production while I am sitting in the tech booth, far away from the control room areas where the live stream server and video switcher are located.
This is where my Stream Deck Production Controller software is going to be a great help. I have created a button set that allows me to send RossTalk commands to the Ross Carbonite switcher, change the necessary routes on the BlackMagic VideoHub router, and start/stop the Wirecast live stream.
So how does this work? The Stream Deck software is sending a GPI trigger request to Dashboard, where I have these buttons in my production control custom panel:
Clicking the “Wirecast – Start Streaming” button runs a custom ogscript function that runs this AppleScript:
And that’s it! By using the existing infrastructure I’ve designed for our production control, I’m now able to easily run the live stream but still maintain high value in what is streamed. By using the stream deck to operate not only Wirecast, but the video switcher remotely, I can change sources as needed, play videos, show cameras, etc. I even have a button that jumps to my PTZ camera control where I can recall presets that I’ve designed specifically for special events like this!
My Stream Deck software is available on Github if you would like to use it, and feel free to reach out if I can help!
In Part 1 of this post, I wrote about the technical side of how to use Ross Dashboard to send a TCP message to a Blackmagic VideoHub video router.
I thought I would expand on that recently and now I have made available a panel that, when set up with the IP address and port of the router, will automatically load the input (source) and output (destination) names into dropdown lists where the user can easily choose a source and destination to make a route.
We have a Panasonic AW-HE40 located in each auditorium at my church to allow the control room operators to see the space. We also occasionally use them as on-screen cameras since they have HD-SDI outputs. The quality is surprising for the size of the device.
The cameras come with a fully functional webpage that allows you to control them.
By peeking around at the code some, I was able to figure out how to send HTTP requests to change presets of the camera.
Here is my Ross Dashboard custom panel that allows our volunteers to quickly pull up presets:
The panel allows the user to see the camera’s viewing angle and select a pre-defined preset. Presets can be modified within the existing web interface for the camera. A Setup tab is also available to configure the IP address of the camera you wish to control.
If you use my panel, you’ll still need to manage/modify the presets using the existing interface. We don’t change our presets often, so I didn’t feel the need to recreate any other functionality than recalling presets.
At my church, we use Unity Intercom to expand our wired intercom system. It is very useful to have users who can be mobile and still stay in communication.
We wanted to have the ability for our directors to see who is currently logged into Unity without having to log into the server or be logged into a Unity client on a device.
After doing some digging and consulting the forums, I found out that if you go to this address:
http://unityserverIPaddr:20101/userconfig
The Unity server will return a JSON dataset of the server information including the list of users.
I’ve had a few people ask about my custom panel in Ross Dashboard that controls Aja Ki Pro recorders using their built-in RESTful API, so I thought I would write a quick post about how that works.
AJA has done an excellent job of creating an accessible device with their API. The web browser interface is great and you can edit or control nearly every aspect of the device from there. The main reason I created the Dashboard interface was to limit that control and simplify the use for volunteers who may not want to get into the complexity of it all.
This is a screenshot of the built-in web interface of the Ki Pro.
Their RESTful API takes simple parameters as querystrings and returns JSON data that can be easily parsed for the results and manipulated.
My panel in Dashboard just takes advantage of this API to make all of the requests to get and set the data. By using a timer function, I am also able to keep the Dashboard panel in sync with the physical state of the actual Ki Pro deck, which is helpful in case someone manually presses a transport button or otherwise makes a change.
The setup tab is fairly basic, you can set the IP address of the Ki Pro and default video/audio input options. The API itself supports many more changes, so if you need to change those options more often, the panel could be modified to support that.Full transport control as well as custom clip names, changing slots (drives), etc. This will follow the state of the actual Ki Pro and update itself if the Ki Pro is armed or changed outside of the Dashboard panel.
Here is a screenshot of one of the functions that gets the current transport state.
If you are interested in everything the Aja Ki Pro API supports, you can get a list of all available parameters by going to:
If you work or serve in a church, chances are you use Planning Center Online a lot. We use their Services product to plan and organize our weekend services, schedule volunteers, etc.
Even though they have a mobile app and desktop interface, we still rely on printed reports on the weekend. It’s simple, fast, we don’t have to worry about the internet going down, the team members can write all over them, etc.
Out of the box, Planning Center comes with some great reports that you can print out. They can somewhat tailored to your organization with your church’s name or logo, etc.
Here’s an out of the box standard report. It gets the job done but it could be better.
In addition to their standard reports, they also support custom reporting. If you know a little HTML, CSS, and are ready to learn some custom tags, it’s pretty easy to jump right in.
Here is a screenshot of a custom report. You can see the HTML and CSS, along with the custom tags that help to generate the report. You can see that some variables have been created and are then referred to later in the document.
The reporting language that PCO uses is called Liquid. If you want a good resource to read that is outside of what PCO offers, here is one.
Liquid is an open source templating language that allows you to do simple conditional and iteration along with filters to parse and control the page as it loads. What this means for you as a user is that you have a lot of simple power at your fingertips to create custom reports designed for exactly what you need!
So, with these tools, I have created several custom reports that our teams use when it is time to print out paperwork for weekend services.
The report I use most often is for our tech team. It prints out a customized version for every person serving on the team that weekend, with their name, the general service flow, and information just for their position, notes, checklists, etc.
Here is an example page from the report. Every team member gets a page (or pages as needed) with their name and customized information for their position.
The nice thing about this report is that I only have to run it once and print once. It creates a new page for every person on the team, so I don’t have to remember how many copies I need to print – I just print the whole file and it has exactly what each person/position needs!
This report includes custom plan item notes per position. To add those, just add a plan item with an item note named:
Position Name
The name has to match exactly. The report also includes overall plan notes per position. To add those, just add plan notes like this:
Team Name – Position Name
When you add your plan notes or plan item notes, just type something specific in that field and only that position will see it when it prints. We like this a lot on our teams because it keeps the report looking a lot simpler for those who don’t need all the extra detail.
One thing you may not have noticed is that I include checklists, customized for each position on the team. We have found checklists to be very helpful so we don’t miss any of the mundane stuff, especially when volunteers may only be serving once a month.
If you use my custom report file, all of the checklist code is already created for you. You just need to create the Plan Note fields to correspond with each position. Each position that has a checklist item should have a Plan Note Field like this:
Checklist – Team Name – Position Name
Any item in the list that begins with a “*” (asterisk) will be printed in a “DURING REHEARSAL” section, and only printed once. Any item that begins with a “~” (tilde) will be printed in an “AFTER EACH SERVICE” section for each service time and will include a small blank line for notes. Any other item will be printed in a “BEFORE SERVICE” section and will be printed once for each service time.
So, for example, a plan note in the field “Checklist – Tech Team – Stage Manager”:
*Take out trash
This would only print one time in the checklist, in the “During Rehearsal” section. You can edit the report to rename that header if you’d like.
~Shut all doors
This would print multiple times, once for each service time, in the “After Each Service” section.
Check for presentation
This would print multiple times, once for each service time, in the “Before Each Service” section. This is likely going to be the most-used field, so it is the one with the simplest formatting requirements.
I like to keep all of my checklists in a Template Plan (with no other items or people) within PCO, and just import them each week to the plan before printing. This allows me to update the checklists from time to time without hardcoding it into the report file, and I can customize it per-plan if needed.
A few months ago, I picked up this nifty device called a Stream Deck made by Elgato Gaming. It’s a 15-button USB keyboard with LCD buttons. It’s primarily marketed towards gamers who live stream so they can have quick access to commands and functions as they stream. The programmer in me couldn’t resist trying it out to help us with our production setup.
The Stream Deck sells for about $140.
Using the base software provided, I was able to fairly quickly implement a workflow to allow volunteers to have easy access to buttons that then fire commands on our Ross Dashboard Production Control ecosystem. If you’ve not used Dashboard before, you can read about how we use it at my church here. It’s fairly easy to set up a custom panel in Dashboard that runs an HTTP web server at a specific port, which in turns allow you to “click” a button on the panel by calling that button’s trigger ID remotely via a specific URL.
Using the “URL” method provided in the base software, we are able to make web calls to the Dashboard custom panels to fire the commands. All the logic/code remains in Dashboard, and this just becomes a method of executing those commands remotely via an HTTP request.
Here is a screenshot of the base software provided by Elgato. It’s very functional as is.
We used the base software for a few months without issue, however quickly realized the limitation of not being able to have bi-directional communication between our Dashboard Production Control and the individual Stream Decks. For example, several of our commands act as “toggles”, meaning we can have a few different state options that represent the current status of a device. If I only had one person making changes or operating the system, it wouldn’t be a huge issue. That person would hopefully remember what button they pressed last. However, when there are a lot of moving parts and multiple people controlling systems, the ability to update status on all devices becomes very helpful.
Enter NodeJS. People smarter than me took the time to write a base NodeJS library to control the Stream Deck. I hadn’t written in NodeJS before, but being a programmer, I was ready to learn something new. I downloaded and installed all the necessary libraries, IDE, etc. and quickly whipped up some code using the base library to control our stream decks. In just a few hours, I had something operational and started running it from the command line. I then spent a couple of weeks refining it and now we have a fully functional, self contained app that can run on Mac, Windows or Linux. It’s packaged using the Electron libraries made freely available with the Node platform.
This was the quick icon I whipped up for the software.
My controller software uses a base JSON file which defines the button structure of the stream deck. This makes it very flexible and expandable as our needs grow as I can just modify the JSON file to change the button structure.
Here’s an example screenshot of one of my button files, written in JavaScript Object Notation. This allows me to add or remove buttons very easily and also programmatically.
The software then parses that JSON and builds the buttons on the Stream Deck in real time. If a button has a trigger action assigned, the command is sent to the corresponding device. I’ve written support for several protocols, including the Dashboard Web Call, RossTalk (good for sending messages to your Ross equipment), OSC, VideoHub routing, and more. You can even do internal stuff like jumping from one button page to another, changing button images during actions, etc. Each button can support an unlimited number of button actions, which I called triggers.
The app runs completely in the tray with a simple context menu.
It also supports defining a set of devices, so if there’s a device you want to send messages to often, you can define the device in a separate file along with its host, port, type, etc. and then only refer to that device in the button structure. That way, if any of those related variables change, you only have to change it in one place.
The software also runs a basic TCP listener server on a specific port, and this is where the bi-directional communication comes into play. Anytime a command is run on the master Dashboard Custom Panel Production Control, it relays a message to the remote Stream Deck via the TCP listener and updates the state of the button.
The settings menu allows you to choose the button/device files you want to use as well as whether the TCP listener service and notifications are turned on.A sample notification that can appear when a button is pressed. You can determine which triggers sent notifications.
This means that we can run commands from any originating location, whether it is the web-based production control (that I’m still developing), one of the remote Dashboard panels that connects to Production Control, one of the Stream Decks (we currently have 2 of them, one in each control room), or even the Master Control panel and every device will receive an updated status.
I also added a “Virtual Deck” option, which allows you to operate the software with or without having a physical Stream Deck attached. You can also choose to have the Virtual Deck operate independently of your physical Stream Deck, so it’s like having two decks in one!
Here is a screenshot of the Virtual Deck in action.Here is what some buttons that have been toggled look like on the Virtual Deck. It’s very clear to see the current state of those buttons!
I am making this software freely available to anyone who can benefit from it. My hope is that the local church can make use of this to allow their volunteers to more easily operate tech equipment during services.
I’ve only built a Mac binary, but you can easily package it for Windows or Linux if needed.
I am working on an Editor function right now that will allow you to add/edit buttons without having to write them in JSON, but until then, you’ll have to make do with that option. Here’s a good tutorial on learning JSON if you need help: https://www.codecademy.com/courses/javascript-beginner-en-xTAfX/0/1
If I can help you out along the way, don’t hesitate to reach out!
Here’s a quick post to share how to control your BlackMagic VideoHub from a Ross Dashboard Custom Panel.
If you have any BlackMagic VideoHub router, it comes with software that allows you to make routing changes over the network. It’s pretty simple and easy to use.
What you may not know is that it can also accept telnet commands by default over port 9990. This means you can control it from a command line, or by sending TCP messages.
Ross Dashboard has a built in function, rosstalk.sendMessage which is designed for sending simple TCP messages. Combine these two things together, and now you can have a button on your own custom panel where you can make a video route easily.
In Dashboard, create a new custom panel, and add a button to that panel.
The router operates with zero based indexes, which means if your destination number is 5, for example, the router treats it internally as 4. So, this script just substracts those numbers internally before submitting the command to the router.
This computer’s time is synced to NTP, so it stays in sync with the clocks in the control rooms, too.
