Brock Tower Lights Project

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.

Some Background

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 (and even across the lake in Toronto).

The Idea

I came up with the idea for controlling the lights as an exhibit after I noticed the university had installed them. I was inspired by the SpireWorks application I had seen in place in New York, and wanted to see if I could bring a little bit of that to Canada.

Lighting Fixtures & Limitations

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.

The Brock University campus, located on the top of the Niagara Escarpment.

Extending the capabilities of the lights

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. I worked with university administration to price out a controller that would allow this to happen, but it was ultimately deemed too expensive to purchase the advanced controller.

ColorKinetics fixtures use a modified DMX protocol

The lights however, 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()

User Control Architecture

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, allowing them to remain in a firewalled environment, only reaching out for querying from an external source.

In Conclusion

This project was a massive undertaking involving buy-in from multiple departments and university senior administration. As a summary, it included

• Convincing senior administration to trial the project
• Researching
• Network Provisioning
• High Level Programming
• Low Level Programming
• Low Voltage Wiring
• In person visits and testing

In layman's, it was a ton of fun.