Novastar H Series Api Guide

It is highly recommended to place Novastar H Series devices on a dedicated AV VLAN. While the API is robust, exposing these devices directly to the public internet poses a security risk, as the protocol generally lacks advanced encryption or authentication tokens (it relies on IP trust).

Professional AV control systems (Crestron, Extron, QSC Q-SYS) support TCP/IP clients with regex parsing.

The true power of the API emerges in custom integrations. Consider a broadcast virtual production studio using LED volumes. The H Series API can be integrated with camera tracking systems: as the camera’s shutter speed changes, the API adjusts the LED’s refresh rate and grayscale settings dynamically to eliminate scan lines. Similarly, in a command-and-control center, the API allows the building’s automation system to dim the LED wall based on ambient light sensors or time of day, reducing energy consumption and extending panel life. novastar h series api

For large-scale permanent installations, the API enables redundancy management. If a primary receiving card fails, the API can instruct neighboring cards to remap data streams, keeping the display functional (though perhaps at reduced resolution) until physical repairs occur.

Novastar’s H Series (including H2, H5, H7, H9, and H15 models) represents the company’s high-performance line of LED display controllers and video processors. Unlike the older "S Series" sending cards which relied heavily on proprietary software (NovaLCT), the H Series is designed with modern integration in mind. It is highly recommended to place Novastar H

This report details the API capabilities of the H Series. The primary method of programmatic control is the Novastar Control Platform (VNNOX) via cloud APIs, though local control via TCP/IP socket communication is also supported for specialized implementations. The transition to the H Series marks a shift from monolithic local software to web-based and network-programmable management.

Understanding the packet structure is critical for developers writing custom drivers. The Novastar protocol generally follows a "Header + Payload + Checksum" structure. self.port)) def _checksum(self

import socket
import struct
import time
class NovaStarHSeries:
def init(self, ip="192.168.1.10", port=5000):
self.ip = ip
self.port = port
self.sock = None
def connect(self):
    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    self.sock.connect((self.ip, self.port))
def _checksum(self, data_bytes):
    cs = 0
    for b in data_bytes:
        cs ^= b
    return cs
def _send_command(self, cmd, data=b""):
    payload = bytes([cmd]) + data
    length = len(payload)
    cs = self._checksum(bytes([length]) + payload)
    frame = b"\xAA\xAA\xAA" + bytes([length]) + payload + bytes([cs]) + b"\xBB\xBB\xBB"
    self.sock.send(frame)
    return self.sock.recv(1024)
def set_brightness(self, percent):
    if 0 <= percent <= 100:
        return self._send_command(0x20, bytes([percent]))
def blackout(self, enable):
    return self._send_command(0x21, bytes([1 if enable else 0]))
def load_preset(self, scene_num):
    if 1 <= scene_num <= 8:
        return self._send_command(0x30, bytes([scene_num]))
def get_device_info(self):
    resp = self._send_command(0x10)
    # Parse ASCII part after cmd byte
    return resp[8:-5].decode(errors="ignore")
def close(self):
    if self.sock:
        self.sock.close()