Junction Relay
the data middleware tool for PC enthusiasts
Hello folks! I’m excited to share a development update for Junction Relay. This software is a data middleware tool aimed at connecting the ever-increasing variety of data sources in modern computing. It consolidates, manipulates, and relays data to the forward devices/systems that you need.
Beta Phase:
Junction Relay is entering a hybrid beta phase soon, but you can test the software with the freemium version, or by purchasing a discounted early-access license.
The application can run unlicensed with up to 4 unique sensors active. My thought process here is that 4 sensors are sufficient to relay key sensors for one screen on a machine.
Anyone can download the alpha/beta builds from github
Please log issues on the GitHub page here
Early-Access Sale
During the beta, a 40% discount is available on a perpetual lifetime license, which is the best way to support me as a solo developer. The beta is essential for gathering any bugs, issues, and feedback before the first release. Expect bugs, and thank you for supporting the project.
Purchase a license here https://store.catapultcase.com/products/junctionrelay
Important notes:
• As a beta release, the code is currently unsigned – the application will be submitted for code signing certification when v1.0 launches.
• Windows Defender false positives are possible/likely.
• Even if a false positive doesn’t occur, it’s likely you’ll need to unblock the DLLs contained in the folders DataSources, DataSourceTargetCombos, and DataTargets. This can be done by right-clicking on a DLL, selecting Properties, and pressing ‘Unblock’.
Project Background:
The project began with simple origins – I wanted to display system stats on an OLED panel for the cases I design at http://catapultcase.com. It is pretty simple to create a python script to do this, leveraging existing tools and libraries like OpenHardwareMonitor or PSUTIL. However, it quickly became clear that what I needed was multiple data sources, like extracting true power consumption from my IoT devices that connect to HomeAssistant. Again, I was able to achieve this with a python approach but found myself repeating efforts from years of mini coding projects, repeatedly having to re-learn what’s different for each new device, adapt, overcome… Whilst this is for sure a worthwhile pursuit if you want to be a full-time developer, I just wanted software to already exist that would handle the task at hand.
And so, Junction Relay was born. Built with expandability in mind, data sources and data targets can be reused and iterated upon whilst the core application handles the messy middle. To receive/display data, my screens of choice are sold by https://www.lilygo.cc/products/t4-s3 and have embedded ESP32 devices, meaning you can use a very small script to receive data from the HTTP data target in Junction Relay. There are lots of tutorials online for how to do this, but I of course share some example code with the application. I will purchase additional displays and continue to provide templates and ready to use solutions as time goes by.
Core Features:
• Connect to multiple data sources over various protocols
• Connect to multiple data targets over various protocols
• Build Junctions that consolidate the desired sensors from multiple data sources into packets for your data targets
• Use the Formula Engine to manipulate sensor data (for example, combine, change the measure of units, etc)
• Define override poll/send rates for each data source/data target and the application will apply the required rate for each data stream automatically.
Data Sources:
• Generic HTTP Server
Connect to an existing service over a HTTP connection. The application includes example python scripts that set up Flask servers, piping fake sensors for testing purposes. I have also created a docker container https://github.com/catapultcase/JunctionRelayAgent_Unraid that has been designed to run on Unraid to broadcast system statistics via PSUTIL. An AccessToken can be set to secure the connection at both ends, and you can customize the refresh rate of sensor data/history of data collected for averages.
• LibreHardwareMonitor Remote Web Server
This wonderful application has it’s own ability to broadcast to a Remote Web Server. This data source is based on the Generic HTTP Server, but is tailored to include the additional data that can be provided, such as component names and hierarchy. This is a preferred data source since all of the heavy lifting when it comes to gathering system data is handled by the 3rd party application – I have no desire to create my own monitoring tools.
• HomeAssistant
With the use of a Long-Lived Access Token, connect to your HomeAssistant instances and bring in all the data from your IoT devices. This is perfect for pairing up true power consumption data into your system stats.
OpenHardwareMonitor v0.9.6 and LibreHardwareMonitor v0.9.2
Native implementations of these opensource projects – no modifications have been made to the libraries but their performance can be impacted by whether or not you allow the application to run as administrator or not.
• Heart Beat Ping
Specify a frequency to send a ping to the URL or IP Address to receive either a TRUE or FALSE response. Useful to validating that a remote system is alive.
Data Targets:
• Generic HTTP Client
Connect to a device that has been configured to receive sensor data at a specified interval via a HTTP connection. In my opinion, this is the gold standard of displaying system data on an external display. I have provided example python scripts that receive sensor data, and also Arduino code for a couple Lilygo OLED displays that I think are superb.
• Local COM Device
Directly relay your data to a device connected via USB. The old school way – I haven’t spent too much time developing this data target yet, for example if the payload exceeds 200 bytes (about 8 sensors, depending on the sensor tag you assign), it’s exceeding a buffer limit I believe. To mitigate this, I will be implementing a burst-transmission solution where it paginates the data as needed. But that’s for later.
• HomeAssistant
Thanks to the API based connection, the data source for HomeAssistant can actually double as a data target. That means that you can relay that lovely system data back into HomeAssistant if you prefer to consolidate it into existing solutions there.