The complexity of this endeavor is hidden beneath its sleek surface: The 13-meter-long display of 18 letters results in 54 meters of LED strip, a total of 252 individually controlled segments made up of 6.480 LEDs, all connected by a custom-engineered three cable system: two carrying 24V and one carrying data. At the heart of this 13-meter-long installation lies a the controller - the "brain" of the display - which we had to design, program and assemble from scratch.

Each letter is composed of electrically connected segments, with each segment containing four units (pixels), each of which 5 centimeters long and equipped with 6 LEDs. Each letter has a total of 60 pixels.
One of the big technical challenges was the delicate web of electrical connections. We made custom electric cabling and used LED connectors to link the segments, attached the LED strips onto anodized aluminum strips to ensure heat dissipation and inserted them into opal plexiglass tubes. Every joint between the segments was designed, engineered, and fabricated in-house using 3D-printed PLA filament. Finally, each letter was anchored to a robust aluminum support.

In addition we had to connect the eighteen letters together to form a 13-meter display. Those who have worked with long LED strips powered by direct current are familiar with voltage drop, which occurs when an electrical cable's intrinsic resistance limits the current. The longer the cable, the greater the resistance. For instance, connecting a 24V power supply to a long cable may result in the last LEDs not lighting up due to reduced voltage, ranging from 20 to 22 volts. 
The issue we faced was precisely this: with 54 meters of LEDs and roughly 1.7 meters of internal wiring for each letter, the total line length ends up being around 85 meters. Therefore, we divided the display into three sections, each consisting of six letters. Each section was powered at several points, with the power supply reinjected every two letters. This guaranteed a stable 24V throughout the line. The data line, on the other hand, remained continuous from start to finish.

The letter display was powered from only one direction. This meant that the first section was close to the power supply, the second section was about six meters away, and the third section was over twelve meters away. To compensate for the initial voltage drop, we used cables with a larger diameter. The three 24V/13A (312W) power supplies were housed in a single power supply box.
All of these cables made assembly a real challenge. To speed up the process, which had to be completed in a single day, we numbered each component, labeled each cable, and designed dedicated connectors. Lastly, we organized all the wiring within the metal support structure of the display.

Lastly, the outdoor environment added another level of complexity because it could rain during the two-week installation period. Therefore, every joint had to be waterproof. All electrical contacts had to be protected. To this end, we covered the LED strips with special insulating paint and used gaskets in all the joints of the letter segments. We also used IP68 cable glands for all our cable connectors. 
For the record, there was light rain, and we had no problems with water :)

Let's take a deep dive into some technical details: The controller, software, pixels, and text strings:
The controller turns on individual pixels on the LED strip that runs across our display. It is based on a Wemos microcontroller with an ESP8266 chip. The created program allows you to control each pixel individually.
This is how the segment logic (14-Bit Array) works: By numbering the segments of a character from 0 to 13, we can build a 14-element array, where each element can have a value of either 1 (on) or 0 (off).

We can therefore map each character to a configuration stored in a 14-bit array. For example, the number 1 can be drawn with a sequence of bits in which bits 1, 2, and 10 are ON.
This is the number 1:   01100000001000
This is the letter A:      11101111000000
This is the letter B:      10011110001001
This is the letter C:      10011100000000
And so on, for each character on our display we can store an array of 14 bits describing the ON or OFF state of each segment.

To control individual pixels on a led strip by connecting a pin on the Wemos board to the strip's data cable we used the Adafruit's Neopixel software library.
With this library, we control the chain of pixels as a single object. The pixels are numbered from 0-N depending on the length of the strip. For example, for a letter with 60 pixels, they range from 0 to 59.
If we want to light up segment 0 of the letter, we must light up pixels 0, 1, 2, 3, 4 (it is made up of 5 pixels); to light up segment 1, we must light up 5, 6, 7, 8 (4 pixels).
To make a dash with segments 6 and 7, we need to turn on pixels 26, 27, 28, 29, 30, and 31. 
With two letters, we can access pixels 0-119. To turn on the first pixel of the second letter, we need to activate pixel 60. The first pixel of the third letter will be at position 120; the first pixel of the fourth letter will be at position 180; and so on. For each letter, add 60 to find the initial pixel.
To display 18 letters, we must control pixels from 0 to 1.079.

At the heart of our controller's software is a function that receives a string to write on the 18 letters. This function divides the string into characters, identifies which segment to light up for each character, and identifies which pixels on the strip to light up for each segment. It takes into account the 60-pixel offset for each character. 
The data is then sent to the Neopixel library function, which communicates with all the chips on the strip. The chips then light up the corresponding LEDs.

Moreover, the controller has an integrated internet connection via ESP microcontrollers. We developped a small web interface to change the displayed text from our cell phones without touching anything. We can even do it remotely!