Brock Tower Lights Project

Creative Engineering

// Designing a live architectural lighting control system for students of Brock University

Letting students control the lights on a building

This year, I had the pleasure of working with Brock University to build out an interactive lighting exhibit that allows students to control the lights of the Brock Tower in real time.

About The Project

Brock University, located in St. Catharines, Canada has a giant tower in the centre of campus. Since the university is located on the top of the Niagara escarpment, the Schmon Tower is visible throughout the Niagara region.

The university recently upgraded the lighting on the tower, installing a series of Signify ColorKinetics exterior lighting fixtures. Members of the Brock community are able to submit requests to have the lights changed a certain colour for certain events - but the possibilities are limited.

Working with several stakeholders at the university, I created and implemented a system which allows students to control the exterior building lights live from their phones.

How It Was Done

The first, and most intensive step of this project was researching the capabilities of the lights. Due to the control system and networking constraints, using the existing lighting controller was deemed not possible.

With the next-step professional controller required to implement this kind of a project costing well into the tens of thousands of dollars, I got a bit creative and brushed up on my DMX protocol knowledge.

The lights, use a modified DMX protocol and can thus be controlled with a DMX control module. Using a USB bridge, I wrote and implemented a custom DMX protocol for controlling the fixtures, mapping out each individual one to a band of channels, and coding special lighting effects in by hand.

class Fixture:
    """Class for representing a DMX fixture"""

    def __init__(self, **kwargs):
        """Set up the fixture"""
        self.dmx_id = kwargs['id']
        logging.debug(f'instantiating fixture {self.dmx_id}')
        self.tower_face = kwargs['face']
        self.dmx_controller = kwargs['controller']
        self.rgb = [0, 0, 0]

    def _update_dmx_controller(self):
        """Updates the DMX controller"""
        self.dmx_controller.set_fixture_colour(self.dmx_id, self.rgb)

    def set_colour(self, rgb):
        """Sets the RGB colour of the lights"""
        self.rgb = rgb
        self._update_dmx_controller()

    def clear(self):
        """Clears the fixture - turns it off"""
        self.rgb = [0, 0, 0]
        self._update_dmx_controller()

    def set_white(self):
        """Sets the fixture to white with full intensity"""
        self.rgb = [255, 255, 255]
        self._update_dmx_controller()

An in-cloud architecture was chosen for the user-facing portion of the application, allowing students to interact with the exhibit without risking the integrity of the lights or subsequent systems.

This project involved cooordination of multiple university departments and services, low and high level programming, hardware modifications and low voltage electrical wiring - it was a ton of fun.

Let's Work Together

I solve problems with DevOps, Developer Relations, IoT, and Artificial Intelligence.