The bright red boards of the second generation hardware started to come in. Why red? Simple. If the board was green we could share photos, if it was red it was forbidden to share any pictures or details about it. Simple enough.
​

I was busy performing the last handover bits of the first generation hardware to the cloud team while Greg was doing the first power up of the main board. I was eager to work on the board but I did not have the skills (yet) to do the checks and first power up. He would test different positions on the board with a multimeter to make sure there were no short circuits or other defects.
​

Once he got the board power up for the first time, I jumped in and started working towards the first boot. This time, I was completely by myself. The Internet was useless to get help. The vendor CPU for the board was under NDA. The only information that I had was from our schematics, the vendors documentation and the vendor source code. Some of our tools could also be helpful to detect signal or code errors.
​

To make that first boot, I had to modify a version of Linux that was already very heavily modified by the vendor. I had to dive into the schematics to know how he had wired some of the chip pins, then cross reference the pins in the pin datasheet and then edit the code accordingly to add devices, functionality or change settings. Back and forth between PDFs, vendor source code and the operating system code. I was building the software, testing the expected hardware values and following the chip setup sequence.
​

The chip in question was a specialized chip, an ASIC, that did hardware networking. There was a simple power up sequence to get the operating system running, but then you had to power up the network part of it which required following a detailed multi step sequence. It was a dance between our code, the multi platform vendor code and the operating system code. One flag set wrongly, one value not written correctly and it just didn't work. No errors, no crashes, it just didn't work.
​

Every component was standard and documented. What made the difference was how you wired everything together and configured the components. Because of the developpement cycle of hardware, the most important thing at that time, was to validate every electrical signal on the board. Every feature that was software only and didn't require a dedicated track on the board could wait.
​

Any mistake in how the components were connected together had to be found. Or at least, we needed to find as many issues as we could. We would add small wires and solder some tracks and components differently to fix the issues we needed to continue to test and at the same time Greg would patch the design in the EDA tool. The bug was labeled and only closed when we got the next revision of the board a few months later and after we had checked that the patch was correct.
​

As we had tested as much as we could, we slowly started to write actual software features. I knew how networking worked basically, but I did not expect that my next focus would be a great dive into how networking worked.
​

If you have missed it, you can read the previous episode here​

To pair with :

• Sunburn (Timo Maas'Sunstroke Remix) - Muse, Timo Maas
• Mockingbird by Walter Tevis​​