Finisher Prize for Light Up Your Life Design Challenge

misaz 19 days ago

Hello Element14 Community,

Right before leaving to Christmas holidays, I receive my finisher prize for participating in Light Up Your Life Design Challenge sponsored by Würth Elektronik. Before digging into reward, let’s rewind what I did as part of challenge. I joined as non-sponsored challenger with intention to make device for automated analysis and testing of RGB LED strips. Most likely it was not the coolest contest entry, but I like it. As part of challenge, I dig into interesting topics like fault tolerant LEDs, described various types of interfaces, tried combine multiple types of LEDs on single chain, and so on. After all, I combined all these and made prototype of automated testing tool. For more details, you can read over forum and project posts which I wrote as part of challenge:

I did not win any of main prize. It was obvious considering very high quality of entries of others (and their fun and cool ideas, compared to my pretty boring helper technical tool). But participation still qualified me for at least finisher prize and this post is about it. Helping hands, magnifier and shrink tubes were offered as finisher prize, but because I all of these already have, I asked Element14 for replacement prize and they did their best to get it. So, instead, I’ve got brand new Arduino Uno Q which cost slightly less than originally offered kit.

Arduino Uno Q (2GB)

While you probably heard about it, let’s briefly explain it. It is new board from Arduino. On a single board it combines MPU running Linux with MCU running Zephyr. Main processor is no longer MCU clocked in range of MHz, but rather CPU clocked in range of GHz. The idea is not completely new concept, for example Latte Panda do the same on many of their x86 boards for years, but it is still quite unique on the market.

This combination allows completely new applications. While most people speak about AI, Machine Learning, Computer Vision etc, I would like to mention that it also allows many “conservative” applications like logging to hard drives, much better HMI displays with reasonably well working 3D GPU, full featured networking stack in Linux and many other while still somehow remaining most properties of Arduino.

But none of these was actually my motivation for getting it. My motivation was mainly opportunity to dive into Qualcomm platform. While the platform is very closed source similarly to Broadcom on Raspberry Pi, there is huge amount of “documentation” available online which come from long-term running reverse engineering efforts. Compared to Broadcom chips which originally designed for TV Set Top Boxes and similar, these Qualcomm chip targeted smart phones primarily, and obviously, there was much bigger demand on reverse engineering these. In fact, it is obvious for example from pinout. On pin header near power button there are two signals called Volume+ and Volume-. I think you have idea what device typically has these buttons. Despite acquisition of Arduino by Qualcomm is kind of shady, I think, community will enjoy hacking this device for several next years.

Power-up and first thought

You can use it as “normal” Arduino by connecting it to PC using USB cable, but this one you can use in Single Board Computer mode and you can use it as a standalone computer. For SBC mode, you need USB-C Hub. It may sound quite weird at the first look, but technically it does not restrict this Arduino to some predefined list of connectors which Arduino think that they should be enough for everybody. Instead, you can use any set of ports you need – you just buy hub which satisfy your requirements. If you need 2 USB you buy hub with 2 USB, if you need 5 USBs, you buy hub with 5 USBs, etc. While there are many options, for using it “as PC”, you need at least HDMI for display, PD for powering and at least one USB for mouse/keyboard. Especially, do not forget about powering, otherwise you will likely need to power it through pin headers.

Considering CPU is not flagship and there is quite low of memory, system is surprisingly fast and responsive. It is obviously not as seamless as my i7-9700K desktop, but compared to the older generations of Raspberry Pi with similar processors, it is quite good and I was very surprised. Software is quite optimized as well. It uses decent mix of Arduino modifications with otherwise standard Debian system. You can find modifications on Arduino Github.

While feeling is generally good, it has some limitations, for example, Chromium can very quickly trigger Out of Memory killer. 2GB is not much memory for Chromium. It is quite limiting when searching for documentation, forums, etc directly on device.

First Sketch

Considering it is reward for RGB LED Design Challenge organized by Würth Elektronik, first electronic part which I connected to this Arduino was RGB LEDs from Würth. Little bit challenging was that FastLED library is not ported to new Uno Q yet and fails to compile, but after design challenge I am experienced enough to quickly write my own driver. I did not want to bother with complex Arduino-Zephyr-STM32HAL environment, so I write my own driver for generating properly timed signal using STM32 timer. I controlled it manually controlled by directly writing and reading registers. It makes sketch quite long, bot work nicely.

#include <Arduino.h>
#include <Arduino_RouterBridge.h>
#include <ArduinoGraphics.h>
#include <Arduino_LED_Matrix.h>

#define LEDS 4
uint32_t buff[LEDS * 3];

ArduinoLEDMatrix matrix;

void setup() {
  Monitor.begin();
  matrix.begin();
  for (int i = 0; i < LEDS * 3; i++) {
    buff[i] = 0x88888888;
  }
  pinMode(5, OUTPUT); // PA11
  float scaleR = 0.07;
  float scaleG = 0.01;
  float scaleB = 0.12;
  setLED(0, (uint8_t)(scaleR * 40), (uint8_t)(scaleG * 101), (uint8_t)(scaleB * 181));
  setLED(1, (uint8_t)(scaleR * 51), (uint8_t)(scaleG * 71), (uint8_t)(scaleB * 186));
  setLED(2, (uint8_t)(scaleR * 115), (uint8_t)(scaleG * 140), (uint8_t)(scaleB * 216));
  setLED(3, (uint8_t)(scaleR * 130), (uint8_t)(scaleG * 90), (uint8_t)(scaleB * 238));
  Monitor.println("Init done");
}

void loop() {
  delay(1000);
  showLEDs();

  matrix.beginDraw();
  matrix.stroke(0xFFFFFFFF);
  matrix.textScrollSpeed(50);
  matrix.textFont(Font_5x7);
  matrix.beginText(0, 1, 0xFFFFFF);
  matrix.println("   Thank you");
  matrix.endText(SCROLL_LEFT);
  matrix.endDraw();
}

void setLED(int index, uint8_t r, uint8_t g, uint8_t b) {
  if (index >= LEDS) {
    return;
  }

  uint32_t data[3] = { g, r, b };
  for (int i = 0; i < 3; i++) {
    uint32_t bitmask_rd = 0x80;
    uint32_t bitmask_wr = 0x60000000;
    
    while (bitmask_rd) {
      if (data[i] & bitmask_rd) {
        buff[index * 3 + i] |= bitmask_wr;
      } else {
        buff[index * 3 + i] &= ~bitmask_wr;
      }

      bitmask_rd >>= 1;
      bitmask_wr >>= 4;
    }
    
  }
}

void showLEDs() {
  noInterrupts();
  
  RCC->APB1ENR1 |= (1 << 4);
  TIM6->PSC = 14; // 13.3333 MHz
  TIM6->ARR = 3; // ie. 4 but STM32 need one more clock cycle to update
  TIM6->CNT = 0;
  TIM6->CR1 = 1;

  for (int i = 0; i < LEDS * 3; i++) {
    uint32_t bitmask = 0x80000000;
    while (bitmask) {
      uint32_t bssr;
      if (buff[i] & bitmask) {
        bssr = (1 << 11);
      } else {
        bssr = (1 << (16 + 11));
      }

      while ((TIM6->SR & 1) == 0) {}
      TIM6->SR = 0;
      GPIOA->BSRR = bssr;

      bitmask >>= 1;
    }
  }
  
  TIM6->CR1 = 0;
  interrupts();
}

Bonus: USB Type-C Hub Disassembly

I bought cheapest USB Type-C hub which satisfy my requirements: PD, 1xHDMI, 1xUSB 3.0, >=2xUSB 2.0. There is quite a lot of hubs with these parameters, so I chose one which supports 4K@60Hz display output on HDMI, and it was surprisingly one of the cheapest while there are many more expensive supporting only 30Hz display at 4K resolution. (I am in Czech Republic, in your country, offering likely differs)

But buying cheapest sometimes is not the best idea. While hub satisfy everything I need, it broke when plugging HDMI cable for first time. Mechanical design is not good. I basically pushed cable into it, but I pushed whole PCB including USB cable from the back side of case. While it is easy to fix, I took that opportunity, pulled it out completely first and took a look to PCB before fixing it:

It is quite smart design, I thought there would be single SOC which will handle everything, but this has several chips for various purpose. After observing differential pairs, I think it is connected in this way:

Such diagram nicely shows possible bottlenecks of the devices but unluckily nowadays sellers typically show beautiful photos and visualization instead of technical description. I like that important signals and paths (USB 3.0) and PD (claimed as “up to 100W”) are almost direct paths and there are no possibly bugy or limiting chips on their paths. While I like it from electronics design point of view, mechanically it is disaster.

Closing

At the end I would like to say thank you to Würth Elektronik for sponsoring challenge and Element14 for organising it. I would like to thank all who spend time by reading contest forum posts. For me it was nice opportunity to test various Würth LEDs and play with them. They were on my wish list for long time and this challenge was perfect opportunity to buy them and play with them.

Finally, I would like to mention that if you are interested in getting free Arduino Uno Q which I briefly described in this article, there is still open RoadTest (at the time of writing this post) where you can get one for free. If you join and get selected, you get one free Arduino Uno Q for review.