Published November 20, 2020 © GPL3+

Ironman

Programmable, circular, wearable LED array.

AdvancedFull instructions provided2,593

Things used in this project

Hardware components

IC & Component Socket, 8 Contacts

Not actually that one, but a 16-bit IO expander controlled via I2C that fits the footprint. Check the schematic

LED (generic)

SMD 0603, 32x

Resistor 1M ohm

Not actually this one. 0402 SMD sized according to the schematic. For the undocumented I2C PUs, you can go 1k

Arduino Nano R3

I probably used a knockoff from uncle Bezos

Female Header 8 Position 1 Row (0.1")

0.1" but sized to the Nano's pin count

Software apps and online services

Arduino IDE

Story

Intro:

This project was done to have a Halloween costume that "fit my style". I wanted something representative of my geek-tendencies. The end product is small but technical with respect to a normal costume.

Design:

The basic premise is that an Arduino Nano controls 2 16-bit IO expanders over I2C to PWM 32 LEDs (arranged in a circular pattern) into any configurable pattern desired. An additional 6 LEDs are driven directly from the 6 PWM outputs of the Nano itself.

The LED arrays rest behind the fabric of whatever shirt I would choose to wear, and the headers that the Nano uses to connect to the board hosting the LEDs bridges through the fabric to both hold the system in place and also proudly display the Arduino to the world

The power for the system is input through a mini USB connector at 5V, such that any portable USB charger can run the system. It is cabled beneath the fabric to hide cables. This wasn't terribly comfortable, but it got the job done!

Implementation:

All this functionality was implemented and the LED positions were calculated in a spreadsheet (Spreadsheets are wonderful). The PCB was laid out in a 3" diameter circle, centering the Nano headers:

PCB Design

I had the board fabricated overseas. 2-sided with no special fabrication requirements and plenty of lead time made it quite affordable, even with black solder masking :D

Actual PCB

I hand-soldered the pieces on (I had a microscope so even the 0402 resistors and the SMD I/O expanders weren't bad at all). I did find that I needed an additional PU resistor for the SCL/SDA lines of the I2C interface (operating at 400 kHz), so I spliced those in manually. Finally, I wrapped up the electrical work with a push button on the Arduino itself (2x3 header, pin 1 to pin 6) to be able to cycle through patterns

I finished it out at a mechanical system level with a few pieces of foam to offset the PCB from myself to avoid short circuiting anything out

Programming:

The fun part! Given the processor speed on the Nano and the interface I had chosen (I2C), I needed to be creative on how to optimize the update rate of the LEDs to achieve a truly imperceptible PWM dimming. The first logical step was to speed up the I2C bus to 400 kHz. This was a simple internet search and register write, but not wholly sufficient.

My initial attempt of calculating the pattern and dimming values between each and every write to the LEDs turned out to be too intensive for the poor processor so, through some external advice, I opted to buffer the patterns in an array. 32 LEDs with 32 8-bit value states comes to a total of 1kB of RAM, which is 50% of the available space, so it works out as long as I don't add a bunch of other things in.

I then created a software sawtooth wave comparator to handle the PWM logic. Since < vs > operations are quick, it was easily handled by the processor. I then added a simple timer to handle progression through the pattern, and voila, I had an algorithm simple enough for the processor to run.

I implemented a variety of pattern functions, from simple decaying swirls and randomized starburst pattern to a linearized "swipe" across the polar LED pattern. The pattern was changed by pressing the button (SW debounced) which then reset all the values in the 32x32 array and then resumed the PWM and pattern progression logic.

Further work:

I sourced enough parts to make 3 of them and ultimately decided to use another set to make an RGB variant. I programmed in some "disco-themed" patterns and put it in a carved pumpkin for a bit of pumpkin spice fun

The design needs to be updated to reflect the needed pullup resistors, but I haven't enough interest to make it happen. Ideally, a SPI controlled CC LED driver configuration would reduce the processor load and allow for other interesting possibilities, like accelerometer input or wireless connectivity. Putting in a battery would also ease the system strain of having a cabled portable power pack tethered to you at all times. All in all though, it turned out as well as I had hoped!

Code

Arduino sketch

/*
 *  Program for Ironman logo
 *  By: JJ
 */

#include <Wire.h>

unsigned char button_id = 12;
bool button_press = true;
unsigned long int debouncer = 0;
char pattern_num = 5;

int alternateFlag = 0;

unsigned char pattern_buffer[32][32];
unsigned char ledstate[38];
unsigned char sawtooth_poly[32];
unsigned int pwm_pin_nums[6];
unsigned char sawtooth = 0;
unsigned long int triangle = 0;
bool triangle_up = true;

char buffer_index = 0;

unsigned long int timeTracker;

// the setup function runs once when you press reset or power the board
void setup() {
   
  // Polynomial delinearization via the following formula
  //     ((x^0.5) * 32^0.5) + 1
  // This will allow us to linearize the apparent brightness of the LEDs
  // We will use a lookup table to improve runtime efficiency
  float sqrt_32 = sqrt(32);
  for (int i = 0; i < 32; i++)
  {
    //sawtooth_poly[i] = ( i * i / 32 ) + 1;
    sawtooth_poly[i] = (sqrt(i) * sqrt_32 + 1) * 8;
  }
  
  for (int i = 0; i < 38; i++)
  {
    ledstate[i] = 0;
  }
  
  int ledPin1 = 3;  
  int ledPin2 = 5; 
  int ledPin3 = 6;   
  int ledPin4 = 9;  
  int ledPin5 = 10;  
  int ledPin6 = 11;   
  
  pwm_pin_nums[0] = ledPin1;
  pwm_pin_nums[1] = ledPin2;
  pwm_pin_nums[2] = ledPin3;
  pwm_pin_nums[3] = ledPin4;
  pwm_pin_nums[4] = ledPin5;
  pwm_pin_nums[5] = ledPin6;
  
  
  // initialize digital pins as outputs
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);
  pinMode(ledPin5, OUTPUT);
  pinMode(ledPin6, OUTPUT);
  
  pinMode(button_id, INPUT_PULLUP);

  //timeTracker = millis();

  // Open up the floodgates of I2C
  Wire.begin(); // join i2c bus (address optional for master)

  // Change the I2C clock rate from 100k to 400k by knocking the TWBR value down from 72 to 18
  TWBR = 18;
  
  Wire.beginTransmission(0x20); // Select the first chip
  Wire.write(0x06);             // Enter command to configure this bubby
  Wire.write(0x00);             // Enable outputs on P0
  Wire.write(0x00);             // Enable outputs on P1
  Wire.endTransmission();       // Finish up the transaction
  
  Wire.beginTransmission(0x21); // Select the first chip
  Wire.write(0x06);             // Enter command to configure this bubby
  Wire.write(0x00);             // Enable outputs on P0
  Wire.write(0x00);             // Enable outputs on P1
  Wire.endTransmission();       // Finish up the transaction  
}

// the loop function runs over and over again forever
void loop() 
{
  if (button_press)
  {
    buffer_index = 0;
    button_press = false; 
    generate_new_pattern();
  }
  
  // If we got a button press, do some rudimentary debouncing and set a flag for later
  if (!digitalRead(button_id))
  {
    if (debouncer < millis() && !button_press)
    {
       debouncer = millis() + 1000;
       button_press = true;
    }
  }
  calculate_values();

  write_values();
}

void generate_new_pattern()
{
  switch (++pattern_num)
  {
    case 1:
        for (int led_iter = 0; led_iter < 32; led_iter++)
        {
            for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
            {
               pattern_buffer[led_iter][buffer_iter] = max( ( (32 - ((led_iter + buffer_iter) % 32)) << 3) - 64, 0);
            }
        }
        break;
    case 2:
        for (int led_iter = 0; led_iter < 32; led_iter++)
        {
            for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
            {
               pattern_buffer[led_iter][buffer_iter] = max((abs(16 - buffer_iter) << 3) - 33, 0); ;
            }
        }
        break;
    case 3:      
      for (int led_iter = 0; led_iter < 32; led_iter++)
      {
          for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
          {
              if (buffer_iter == 0) pattern_buffer[led_iter][buffer_iter] = (rand() % 50) + 15;
              else pattern_buffer[led_iter][buffer_iter] = min(max(pattern_buffer[led_iter][buffer_iter - 1] + ((rand() % 3) - 1) * 10, 0), 255);
          }
      }
      break;
    case 4:
      for (int led_iter = 0; led_iter < 32; led_iter++)
      {
          for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
          {
              pattern_buffer[led_iter][buffer_iter] = max( (((led_iter % 16 + (32 - buffer_iter)) % 16) << 5) - 256, 0);
          }
      }
      break;
    case 5:
      for (int led_iter = 0; led_iter < 32; led_iter++)
      {
          int peaks = 3;
          for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
          {
              pattern_buffer[led_iter][buffer_iter] = min(max(300 * (sin(2 * PI * peaks * (buffer_iter + led_iter) / 32.0) + 1) - 400, 0), 255);
          }
      }
      break;
    case 6:
      for (int led_iter = 0; led_iter < 32; led_iter++)
      {
          // Left to right. Convert LED number into an angle (radians)
          float led_pos_x = cos(((led_iter - 8) % 32) / 32.0 * 2 * PI);
          float led_pos_y = sin(((led_iter - 8) % 32) / 32.0 * 2 * PI);
          float led_pos_xn = cos(((led_iter + 8) % 32) / 32.0 * 2 * PI);
          float led_pos_yn = sin(((led_iter + 8) % 32) / 32.0 * 2 * PI);
          float width = 0.2;
          for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
          {
              // Convert our buffer position into a horizontal displacement
              float buffer_pos = (buffer_iter % 8) / 3.0 - 1.25;

              if (buffer_iter < 8)
              {
                float horiz_dist = abs(buffer_pos - led_pos_x);
  
                if (horiz_dist < width)
                {
                    pattern_buffer[led_iter][buffer_iter] = (width - horiz_dist) / width * 255;
                }
                else
                {
                    pattern_buffer[led_iter][buffer_iter] = 0;
                }
              }
              else if (buffer_iter < 16)
              {
                float vert_dist = abs(buffer_pos - led_pos_y);
  
                if (vert_dist < width)
                {
                    pattern_buffer[led_iter][buffer_iter] = (width - vert_dist) / width * 255;
                }
                else
                {
                    pattern_buffer[led_iter][buffer_iter] = 0;
                }
              }
              else if (buffer_iter < 24)
              {
                float horiz_dist = abs(buffer_pos - led_pos_xn);
  
                if (horiz_dist < width)
                {
                    pattern_buffer[led_iter][buffer_iter] = (width - horiz_dist) / width * 255;
                }
                else
                {
                    pattern_buffer[led_iter][buffer_iter] = 0;
                }
              }
              else
              {
                float vert_dist = abs(buffer_pos - led_pos_yn);
  
                if (vert_dist < width)
                {
                    pattern_buffer[led_iter][buffer_iter] = (width - vert_dist) / width * 255;
                }
                else
                {
                    pattern_buffer[led_iter][buffer_iter] = 0;
                }
              }
              
          }
      }
      break;
    default:
      for (int led_iter = 0; led_iter < 32; led_iter++)
      {
          for (int buffer_iter = 0; buffer_iter < 32; buffer_iter++)
          {
             unsigned char cw  = max( ( (32 - ((led_iter + buffer_iter) % 32)) << 5) - 768, 0);
             unsigned char ccw = max( ( (((led_iter + 32 - buffer_iter) % 32)) << 5) - 768, 0);
             
             pattern_buffer[led_iter][buffer_iter] = max(cw, ccw);
          }
      }
      pattern_num = 0;
      break;
  }
}

void calculate_values()
{
  sawtooth += 8;
  
  if (timeTracker <= millis())
  {
     buffer_index++;
     if (buffer_index >= 32)
     {
        buffer_index %= 32;
     } 
     timeTracker += 50;
  }

  for (int i = 0; i < 32; i++)
  {
    ledstate[i] = pattern_buffer[i][buffer_index];
  }  
  
  for ( int i = 32; i < 38; i ++)
  {
     ledstate[i] = max((abs(16 - buffer_index) << 4) - 33, 0); 
  }
}


void write_values()
{ 
  unsigned char byte1 = 0;
  unsigned char byte2 = 0;
  unsigned char byte3 = 0;
  unsigned char byte4 = 0;
  
  for (int iter = 0; iter < 8; iter++)
  {
    if (ledstate[iter] <= sawtooth_poly[sawtooth >> 3])
    {
      byte1 = byte1 | (1 << (iter % 8));
    }
  }

  for (int iter = 8; iter < 16; iter++)
  {
    if (ledstate[iter] <= sawtooth_poly[sawtooth >> 3])
    {
      byte2 = byte2 | (1 << (iter % 8));
    }
  }
  for (int iter = 16; iter < 24; iter++)
  {
    if (ledstate[iter] <= sawtooth_poly[sawtooth >> 3])
    {
      byte3 = byte3 | (1 << (iter % 8));
    }
  }
  for (int iter = 24; iter < 32; iter++)
  {
    if (ledstate[iter] <= sawtooth_poly[sawtooth >> 3])
    {
      byte4 = byte4 | (1 << (iter % 8));
    }
  }
  
  Wire.beginTransmission(0x20); // Select the first chip
  Wire.write(0x02);             // Enter command to configure this bubby
  Wire.write(byte1);     // Enable outputs on P0
  Wire.write(byte2);     // Enable outputs on P1
  Wire.endTransmission();       // Finish up the transaction  
  
  Wire.beginTransmission(0x21); // Select the first chip
  Wire.write(0x02);             // Enter command to configure this bubby
  Wire.write(byte3);     // Enable outputs on P0
  Wire.write(byte4);     // Enable outputs on P1
  Wire.endTransmission();       // Finish up the transaction  
  
  for (int i = 32; i < 38; i++)
  {
    analogWrite(pwm_pin_nums[i - 32], ledstate[i]);  
  }

}

Credits

theaccordionist

1 project • 3 followers

Ironman

Things used in this project

Hardware components

Software apps and online services

Story

Intro:

Design:

Implementation:

Programming:

Further work:

Schematics

Schematic

Code

Arduino sketch

Credits

theaccordionist

Comments

Embed the widget on your own site

Ironman

Ironman

Things used in this project

Hardware components

Software apps and online services

Story

Intro:

Design:

Implementation:

Programming:

Further work:

Schematics

Schematic

Code

Arduino sketch

Credits

theaccordionist

Comments

Related channels and tags