Concept Modeling

This phase is all about figuring out the DNA of the product and core technologies that will be elemental to the design.

Objectives

The objective is to explore potential solutions to creating interesting photography effects in the form factor of a DSLR lens hood. For the initial exploration, the focus will be to create a device that will fit on the Sony SEL50F18 50mm F/1.8 lens that I use with my Sony A7 body. This is a lens that I am familiar with and has the low aperture setting that can take advantage of the effects I am trying to produce.

SEL50 Lens

Prototype

CAD Exploration and Initial Layout

I started by creating a CAD model of the lens and lens hood to use as reference for the design. For the lens, I found a silhouette CAD image of the cross section of the lens. So I brought that into SolidWorks and traced with with lines and splines and revolved it to form the shape. I then mated that in an assembly to a rough CAD model of a Sony A7 series camera. Since I am not building anything onto the camera, the camera body is just for aesthetics of the model.

I then created a CAD surface of the lens hood and used that as the basis for the component layout. I inserted downloaded CAD of the XIAO board as that may be the ultimate controller device, roughed in a PCB for LEDs that would create the ring light as well as a ring of SK6812 side-emmitting addressable LEDs that would illuminate the lens hood extension. I then roughed in a back cover, a lens, and a lens hood extension. I also made a ring for a strip of 5050 addressable LEDs to slide over the hood extension that would simulate light injection from the side emitting LEDs, as I do not have any to experiment with currently. I also roughed in the shape of a curved LiPo battery for a potential power source.

Hood CM CAD — Concept model CAD and layout exploration

Lens Hood Geometry

I wanted to explore injecting light into the lens hood. So I focussed on making printable CAD for a replacement hood. I used calipers and 2D printer bed scan to extract the geometry of the locking mechanism for the hood. Then I created the geometry in CAD and made a few iterations of just the locking mechanism until I was able to get it to work.

Paint — I used paint pen to highlight the locking geometry areas of the factory lens hood before scanning

Scan CAD — Tracing the scanned geometry to create the lens hood locking geometry.

Hood Comparison — Comparison of 3 iterations of the locking ring geometry. The green ones were done first. I added some small cutouts to allow the tab to flex for the grey one and that made it work.

Vignette Hood Build

Once I figured out the locking mechanism I went ahead and finished the CAD for the lens hood. I then made a cylindrical protrusion of the hood that going forward would be a flexible component and may have accordion geometry to fold down. As I wanted to add a string of addressable LEDs, I added a ring around the hood extension to hold the LEDs around the outside diameter but allow moving them axially to test. I 3D printed all of the components and did a mechanical fit on the parts.

Adding Electronics

I wanted a way to drive the LEDs strip without having to change the code to modify the color output. I had a couple of Adafruit Circuit Playground Bluefruit boards and I found a sample project using the Bluefruit Connect app to change the colors and effects of an addressable LED strip. So, I used this as a jumping off point.

As my boards were pretty old, the device firmware on them was old, so I had to first use the Arduino IDE to flash from version 0.2 to 0.9. Then I was able to upload the Circuit Python code to the devices. I soldered up a string of 15 WS2812 addressable LEDs to pin A1 and tested the code with the app.

sBluetooth Controlled Room Lights Code
# SPDX-FileCopyrightText: 2020 Kattni Rembor for Adafruit Industries
# SPDX-FileCopyrightText: 2020 Erin St Blaine for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""
Bluetooth Controlled Room Lights using a Circuit Playground Bluetooth
   Scroll between 7 modes and control brightness with your smartphone via Bluetooth
   Full tutorial: https://learn.adafruit.com/easy-no-solder-bluetooth-controlled-room-lights/overview
Code by Kattni Rembor & Erin St Blaine for Adafruit Industries
Adafruit invests time and resources to bring you this code! Please support our shop!
"""

# pylint: disable=attribute-defined-outside-init
# pylint: disable=too-few-public-methods

import board
import neopixel
from adafruit_led_animation.animation.solid import Solid
from adafruit_led_animation.animation.comet import Comet
from adafruit_led_animation.animation.rainbow import Rainbow
from adafruit_led_animation.animation.rainbowcomet import RainbowComet
from adafruit_led_animation.animation.sparkle import Sparkle
from adafruit_led_animation.animation.sparklepulse import SparklePulse
from adafruit_led_animation.sequence import AnimationSequence
from adafruit_led_animation.group import AnimationGroup
from adafruit_led_animation.animation import Animation
from adafruit_led_animation.sequence import AnimateOnce
from adafruit_led_animation.color import (
    AMBER,
    ORANGE,
    WHITE,
    RED,
    BLACK,
    colorwheel,
)


from adafruit_ble import BLERadio
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.nordic import UARTService

from adafruit_bluefruit_connect.packet import Packet
from adafruit_bluefruit_connect.button_packet import ButtonPacket
from adafruit_bluefruit_connect.color_packet import ColorPacket

NUM_LEDS = 240                   # change to reflect your LED strip
NEOPIXEL_PIN = board.A1        # change to reflect your wiring

# Declare a NeoPixel object on NEOPIXEL_PIN with NUM_LEDS pixels,
# no auto-write.
# Set brightness to max, we'll control it later in the code
pixels = neopixel.NeoPixel(NEOPIXEL_PIN, NUM_LEDS, brightness=1.0,
                           auto_write=False,
                           #pixel_order=(1,0,2,3) #uncomment if using RGBW NeoPixels
                           )


ble = BLERadio()
uart_service = UARTService()
advertisement = ProvideServicesAdvertisement(uart_service)

class RainbowFade(Animation):
    ''' fades the entire strip through the whole spectrum '''
    _color_index = 150 # choose start color (0-255)
    def __init__(self, pixel_object, speed, name): # define animation
        super().__init__(pixel_object, speed=speed, color=WHITE, name=name)

    def draw(self): # draw the animation
        ''' fades the entire strip through the whole spectrum '''
        self.color = colorwheel(self._color_index + 1)
        self._color_index = (self._color_index + 1) % 256
        self.fill(self.color)

# ANIMATION DEFINITIONS --
#    create as many animations as you'd like and define their attributes here.
#    They can be a single line or a group of animations - the groups will play
#    at the same time, overlaid on top of each other.


readingLight = Solid(pixels, color=0xFF7D13) #warm white color HEX code
brightWhite = Solid(pixels, color=(150, 150, 150))
rainbow = Rainbow(pixels, speed=0.1, period=10, step=0.5)
rainbowfade = RainbowFade(pixels, speed=0.4, name="rainbowfade")
powerup = RainbowComet(pixels, speed=0, tail_length=50, bounce=False)
off = Solid(pixels, color=BLACK)

#startup animation will play just once
startup = AnimateOnce(powerup)

#starrynight and fire are animation groups with layered effects.
starrynight = AnimationGroup(
    SparklePulse(pixels, speed=0.01, color=(0, 0, 150), period=1),
    Comet(pixels, speed=0, tail_length=8, color=(150, 150, 150), bounce=False),)

fire = AnimationGroup(
    Comet(pixels, speed=0, tail_length=1, color=BLACK),
    Sparkle(pixels, speed=0.05, num_sparkles=10, color=AMBER),
    Sparkle(pixels, speed=0.05, num_sparkles=10, color=RED),
    Sparkle(pixels, speed=0.05, num_sparkles=20, color=ORANGE),
    Sparkle(pixels, speed=0.05, num_sparkles=5, color=0xFF7D13),
    Sparkle(pixels, speed=0.05, num_sparkles=10, color=BLACK),
    )

# Here is the animation playlist where you set the order of modes

animations = AnimationSequence(
        readingLight,
        fire,
        rainbow,
        starrynight,
        rainbowfade,
        brightWhite,
        auto_clear=True,
        )



MODE = 0

while True:
    if MODE == 0:  # If currently off...
        startup.animate()
        while startup.animate():
            pass
        MODE = 1
    # Advertise when not connected

    elif MODE >= 1:  # If not OFF MODE...
        ble.start_advertising(advertisement)
        while not ble.connected:
            if MODE == 2:
                pass
            elif MODE == 1:
                animations.animate()
    # Now we're connected

    while ble.connected:
        if uart_service.in_waiting:
            packet = Packet.from_stream(uart_service)
            # Color Picker Functionality
            if isinstance(packet, ColorPacket):
                MODE = 2
                # Set all the pixels to one color and stay there.
                pixels.fill(packet.color)
                pixels.show()
            # Control Pad Functionality
            elif isinstance(packet, ButtonPacket):
                if packet.pressed:
                    if packet.button == ButtonPacket.BUTTON_1:
                        MODE = 1
                        animations.activate(1)
                    elif packet.button == ButtonPacket.BUTTON_2:
                        MODE = 1
                        animations.activate(2)
                    elif packet.button == ButtonPacket.BUTTON_3:
                        MODE = 1
                        animations.activate(3)
                    elif packet.button == ButtonPacket.BUTTON_4:
                        MODE = 1
                        animations.activate(4)
                    # change the mode with right arrow
                    elif packet.button == ButtonPacket.RIGHT:
                        MODE = 1
                        animations.next()
                    elif packet.button == ButtonPacket.LEFT:
                        MODE = 4
                        off.animate()
                    #change the brightness with up and down arrows
                    elif packet.button == ButtonPacket.UP:
                        pixels.brightness = pixels.brightness + 0.1
                        pixels.show()
                        if pixels.brightness > 1:
                            pixels.brightness = 1
                    elif packet.button == ButtonPacket.DOWN:
                        pixels.brightness = pixels.brightness - 0.1
                        pixels.show()
                        if pixels.brightness < 0.1:
                            pixels.brightness = 0.1
        if MODE == 1:
            animations.animate()
        if MODE == 4:
            animations.freeze()

Once the board and code was verified, I drilled a couple of holes through the flare hood and mounted the Bluefruit chip. I found a 3xAAA battery box and double sided taped it to power the chip and the LEDs. I slipped the LED ring over the flare hood extension and gave it a test.

Proto — Completed first prototype of the device.

Testing

I went ahead and gave it a test. I took a few photos with the device on the camera. The LEDs provided a very nice vignetting effect to the photos. The lens hood protruded into the frame ever so slightly and provided a good frame to the image.

However it did not provide the flaring effect that I was hoping for. So I had to go back to the drawing board for that. I still think the vignetting can be part of the final product so will keep this feature in mind going forward. Espcially if the flare hood is flexible and can manually be manipulated to create custom vignettes.

Sample Pics — Vignette effect of a picture of an orchid.

Flare LED Prototype

I realized that I do not have a good sense of where or how bright the LEDs need to be in order to create a good flare effect. So, I built a jig to mount the LEDs in a known and adjustable location.

Design

From my research watching YouTube videos it seemed like the best artificial flare effects were made from flashlights that were angled severely relative to the lens. So I wanted to create a way to hold an addressable LED strip at adjustable angle relative to the lens.

I started by making a collar that would lock on to the 50mm Sony lens. Then I built out a lasercut wood structure that would pivot on the collar and be lockable at different angles. The design rules from the week 3 assignment were used to make good stiff joints.

The wooden cross bars were built in such a way to be able to hold strips of 5050 and 2020 addressable LED strips. The pivot arms were given a few different locations so I could change the distance of the strip but keep the same rotational elements.

Electronics

For the electronics I used the XIAOESP32C3 board. I chose this to have the IoT capability if I wanted to use it later and the small footprint. I was able to get an LED strip up and running using the Adafruit Neopixel library. For testing I updated the test program to cycle through white, red, green and blue colors so I could see them cycling through the lens. The code is shown below.

The pins used were: D7- data 5V- power GND- ground

Neopixel Test Code
// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// Released under the GPLv3 license to match the rest of the
// Adafruit NeoPixel library

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
 #include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN        7 // On Trinket or Gemma, suggest changing this to 1

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS 12 // Popular NeoPixel ring size

// When setting up the NeoPixel library, we tell it how many pixels,
// and which pin to use to send signals. Note that for older NeoPixel
// strips you might need to change the third parameter -- see the
// strandtest example for more information on possible values.
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

#define DELAYVAL 500 // Time (in milliseconds) to pause between pixels

void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // END of Trinket-specific code.

  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)
}

void loop() {
  pixels.clear(); // Set all pixel colors to 'off'

  // The first NeoPixel in a strand is #0, second is 1, all the way up
  // to the count of pixels minus one.
  for(int i=0; i<NUMPIXELS; i++) { // For each pixel...

    // pixels.Color() takes RGB values, from 0,0,0 up to 255,255,255
    // Here we're using a moderately bright green color:
    pixels.setPixelColor(i, pixels.Color(255, 255, 255));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop

    pixels.setPixelColor(i, pixels.Color(255, 0, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop


    pixels.setPixelColor(i, pixels.Color(0, 255, 0));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop

    pixels.setPixelColor(i, pixels.Color(0, 0, 255));
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop

  }
}

Build

I used both 3D printing and laser cutting for the build. I 3D printing the locking ring that mounted to the lens. I added some M3 threaded inserts and felt the plastic would flex and lock onto the lens better. I used laser cut wood for the pivot and led mount elements as it was fast and easy to update. This was helpful as I added a mounting surface for the XIAO after I had tested the elements.

Once the mechanical elements were test fit, the LEDs were attached to the cross bars with the double sided tape and lead wires were soldered to them. Then the XIAO was double-sided taped to the pivots and the wires plugged onto the headers.

Iteration of the prototype showing the extra landing area created for the XIAO board.

Testing

After initial validation of the prototype function, I made a test setup to take some sample photos. I setup the camera on a metal table (normally used for our robotic arm) and put a Red Bull can on the table as the subject. Then I ran through a couple of different LED strips and tested the distance from the lens.

Test setup showing the camera, LED bar, and live display of the current image.

Results and Learnings

The main takeaway is that I do not think that either the 5050 or 2020 LEDs is powerful enough to create the striking flare effects that I want.

Power

Neither of the LED strips seemed to have enough power, even at full white to have enough flux into the lens to make the really staggered flare effect that I wanted. However, they were able to create some great halo effects that are plenty lovely.

Angle

What I want to avoid is putting the LED in frame. I just want the striking light. I was able to get enough angle out of the prototype to do this. I did not measure the angle at which they go off frame but can at a later time.

Distance

There did not seem to be a great influence from the distance the LEDs were from the lens in this setup. The LEDs were tested at 35mm, 45mm, and 55mm away from the lens. 45mm seemed to provide a little more color to the frame than 55mm, but there was no noticible difference going to 35mm.

Sample image with no attempted flare effect.

Sample image with blue LED flare effect. Most of the images were quite similar to this no matter the settings. I would call this more of a color wash than a flare effect.

Next Steps

I am going to test a higher power LED to see if I can get the flare that I want. I ordered a few 3W Neopixel LEDs from Adafruit and will see if they do the trick. I found similar ones inside of my kids disco ball LED light and they seemed to make some good effects when I played around with them. The Neopixel versions will give me some control for both color and brightness and hoping these work better.

Image shot using my kids disco ball with similar LEDs. Note the more well defined circular flare marks.

High Power Neopixel Testing

When I received the 3W LEDs I started testing them right away. To start, I hooked them up to the XIAO and ran them with the same program as I used for the strips above. I noticed right away that they were quite a bit brighter and were promising.

First Tests

I immediately wanted to have more control over the color of the LED so I changed the code to work with the Blynk app that I tested during a weekly assignment. I updated the code to have another button for white and off and pushed the following code.

Blynk Neopixel
/*************************************************************
  Blynk is a platform with iOS and Android apps to control
  ESP32, Arduino, Raspberry Pi and the likes over the Internet.
  You can easily build mobile and web interfaces for any
  projects by simply dragging and dropping widgets.

    Downloads, docs, tutorials: https://www.blynk.io
    Sketch generator:           https://examples.blynk.cc
    Blynk community:            https://community.blynk.cc
    Follow us:                  https://www.fb.com/blynkapp
                                https://twitter.com/blynk_app

  Blynk library is licensed under MIT license
  This example code is in public domain.

 *************************************************************
  This example runs directly on ESP32 chip.

  NOTE: This requires ESP32 support package:
    https://github.com/espressif/arduino-esp32

  Please be sure to select the right ESP32 module
  in the Tools -> Board menu!

  Change WiFi ssid, pass, and Blynk auth token to run :)
  Feel free to apply it to any other example. It's simple!
 *************************************************************/
#include <Adafruit_NeoPixel.h>    //neo


/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial

/* Fill in information from Blynk Device Info here */
#define BLYNK_TEMPLATE_ID           "my template"
#define BLYNK_TEMPLATE_NAME         "Quickstart Template"
#define BLYNK_AUTH_TOKEN            "my token"


#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>


// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "my wifi";
char pass[] = "my pass";

//Neo Stuff
#define PIN 7 // Pin for pixels
#define NUMPIXELS 21 // Popular NeoPixel ring size
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);
#define DELAYVAL 50 // Time (in milliseconds) to pause between pixels

// read rgb values and do the pixeling
BLYNK_WRITE(V4) {   
  // Called when virtual pin V2 is updated from the Blynk.App
  // V2 is a datastream of data type String assigned to a   
  // Blynk.App ZeRGBa widget.
  int r = param[0].asInt();
  int g = param[1].asInt();
  int b = param[2].asInt();
  Serial.print("V4: r = ");
  Serial.print(r);
  Serial.print("\t g=");
  Serial.print(g);
  Serial.print("\t b=");
  Serial.println(b);

  for(int i=0; i<NUMPIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(r, g, b)); //set pixel color, obvy
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop
  }
}


// read rgb values and do the pixeling
BLYNK_WRITE(V5) {   
  // Called when virtual pin V2 is updated from the Blynk.App
  // V2 is a datastream of data type String assigned to a   
  // Blynk.App ZeRGBa widget.
  int r = 255;
  int g = 255;
  int b = 255;
  Serial.print("White");

  for(int i=0; i<NUMPIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(r, g, b)); //set pixel color, obvy
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop
  }
}

// read rgb values and do the pixeling
BLYNK_WRITE(V6) {   
  // Called when virtual pin V2 is updated from the Blynk.App
  // V2 is a datastream of data type String assigned to a   
  // Blynk.App ZeRGBa widget.
  int r = 0;
  int g = 0;
  int b = 0;
  Serial.print("White");

  for(int i=0; i<NUMPIXELS; i++) {
    pixels.setPixelColor(i, pixels.Color(r, g, b)); //set pixel color, obvy
    pixels.show();   // Send the updated pixel colors to the hardware.
    delay(DELAYVAL); // Pause before next pass through loop
  }
}
void setup()
{
  // Debug console
  Serial.begin(9600);

  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)

  delay(200); //just in case
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
}

void loop()
{
  Blynk.run();
}

Then I tested it in my living room by just holding the LED with my left hand and seeing what came up on the live feed on my camera. I liked how I was able to get some really distint flare streaking in the images and felt that it was a potential path forward.

Testing the highpower LED in my living room.

Sample image showing the lens flare. Note the color setting was cyan so the green and blue elements are showing through distinctly.

Camera Mount

Since the images were looking good I decided to make a mount to hold the LEDs onto the lens. I did this to answer the question of where the LED should go to create the effects that I want. Ideally, if I use these I would like them to mount in a distinct location.

I went into SolidWorks and designed a hinged mounting system. I started with the laser cut hinge design from above but modified it to have a hinged fork that holds a pivoting LED sled. I felt this would give me the flexibility in the angle and distance from the lens I would need to do my testing.

LED carrier that will bolt into the fork

I 3D printed the parts on a Bambu A1 and did the assembly. I used M3 heat set inserts for the LED holder and the lens clamp, and used a long M3 screw to hold the fork to the lens mount.

Then I wired it up to the XIAO and gave it a test. I was a bit underwhelmed and was not getting the great streaking I was seeing before. It almost seemed like there was suddenly not enough light. Then I took a look at the prototype and realized that I was accidentally blocking a lot of light with the way the mounts were designed. If I kept the LED off camera the light was complete shielded by the mount.

LED showing the light blockage from the mount.

Even with full power and white color, there was not lens flaring with this design.

Second Camera Mount

I quickly updated the design to have shorter shoulders on the lens mount portion of the design and longer forks. This would keep the LED from being blocked. I kept the same LED sled design.

Updated design with longer forks and shorter mount arms

I then 3D printed the design in PLA. I decided to print 2 sets of forks and another LED sled so that I could setup 2 LEDs for more flexibility.

This brought the performance back to life and I was able to position the LEDS in such a way that they created the interesting streak pattern that I hand noticed before during my informal testing.

This is when I realized I had a new problem. The streaks are going right through the center of the image. I did not realize this before, but it was very obvious when shooting a portrait. The only way to make this look decent is to offset the subject to either side. This is not a big deal and may be advantageous. However, I am not sure that I like this anymore and may abandon it.