Project tutorial
Blue Light DNA Transilluminator

Blue Light DNA Transilluminator © CC BY-SA

The design and assembly of a DNA transilluminator allowing to examine the results of gel-electrophoresis procedures.

  • 642 views
  • 0 comments
  • 1 respect

Components and supplies

26y8461 40
Adafruit NeoPixel Digital RGB LED Strip 144 LED, 1m White
Source of illumination allowing the emission of blue light at wavelengths between 465 - 475 nm.
×1
3D Printing PLA Filament - Black
PLA plastic to 3D print the base and covers of the system.
×1
3D Printing PLA Filament - Transparent
PLA transparent plastic in order to print a thin sheet serving as an optical diffuser.
×1
Cover Hinges
Cover hinges in order to mount the cover onto the box containing the LED strip.
×1
Orange UV Plastic Shield
The orange plastic shield allows to filter off the lights arising from the staining dye and consequently enhancing the contrast for better visualization.
×1
Ard nano
Arduino Nano R3
The microcontroller in order to control the colour and behaviour of the LED strip.
×1
95y1410 40
Rocker Switch, SPST
Toggle switch to power the unit ON/OFF.
×1
Metallic Foil Board Sheets
Metallic reflective sheets to maximize the reflection of the light upward toward the light diffuser.
×1
Krazy Glue
Glue to mount the plastic sheet onto the cover and bottom of the LED box.
×1
11026 02
Jumper wires (generic)
Jumper wire allowing to connect the electronic components.
×1
PCB Board
PCB board to mount the Arduino and connect the jumper wires.
×1
DC Power Adapter
DC power jack allowing the unit to power via a 5V source.
×1

Necessary tools and machines

Apps and online services

Autodesk fusion 360 logo 4szx21llea
Autodesk Fusion 360
Utilized to design all the 3D printed components.
Ide web
Arduino IDE
IDE utilized to program the Arduino Nano.
Ultimaker Cura
Software utilized to create the gcode files required for 3D printing.

About this project

Gel electrophoresis arises as an efficient method for comparing various macromolecules such as DNA and RNA based on their size and charge properties. The molecules under analysis are pipetted within a gel made of agarose. The gel is then placed between two electrodes having opposite charges and submerged within an electrolyte buffer solution. An electric field is consequently created once voltage is applied to the electrodes. As a result, the negatively charged molecules gravitate towards the positively charged anode by the action of the electric field. The difference in size becomes apparent as smaller molecules will travel through the gel matrix faster than larger molecules. Further details about the protocols can be found elsewhere. ***

Once the action of the electric field has separated the molecules, a DNA transilluminator is used to observe the location of each molecule within the gel matrix. In detail, the addition of a staining dye within the gel allows the molecules to be fluorescently excited by light having wavelengths within the UV or blue region of the electromagnetic spectrum. Various staining dyes exist with different excitable wavelengths *. A transilluminator is therefore critical for reaching meaningful conclusions from the gel-electrophoresis procedure. However, as demonstrated below, such devices tend to be highly expensive.

Commercially available transilluminators:

Students or small laboratories with limited financial support for scientific investigations are often forced to search for alternative methods for analyzing their gels. The present project demonstrates the design and assembly of a DNA transilluminator system using easily accessible components at a respectable cost. The project can be tackled by young students aiming at gaining practical skills in building laboratory equipment or experienced scientists searching for a rapid and cost-efficient method for analyzing gels. The complexity of the project is kept at a minimum. Further modifications can be undertaken to improve the performance of the device. No professional experience in electronics design or software programming is needed.

The project is divided as follow:

1. Designing and 3D printing the required plastic parts.

2. Assembling the mechanical components.

3. Assembling the electronics components as well as programming the microcontroller.

4. Testing the device and proposing potential improvement.

1. Designing and 3D printing the required plastic parts:

The design procedures have been separated into three sections:

  • Cover (Screen_Perimeters.stl + cover.stl)
  • LED Box (Illuminator_Box.stl + Transparent_Glass.stl)
  • Electronic Box (Electronics_Box.stl + Box_Cover.stl)

The design of each component was created within Fusion 360. The STL files and the Fusion 360 model can be downloaded from the appropriate section below.

2. Assembling the mechanical components:

1.1 --> A small amount of Krazy Glue is deposited onto the black perimeter surface (Labelled as #1).

1.2 --> The orange UV shield (Labelled as #2) is gently deposited onto the black perimeter component having a small amount of glue onto the surface. Wait 5 minutes before proceeding to the next step for the glue to solidify.

1.3 --> Apply a small amount of Krazy Glue onto the interior perimeter of the black upper cover (Labelled as #3). Gently align the upper cover onto the orange UV shield. Wait 5 minutes for the glue to fully solidify.

1.4 --> Briefly measure two equally distanced positions on the exterior of the LED box for gluing two cover hinges. The measurement is only for aesthetic purposes and does not necessarily affect the performance of the unit. Next, apply a small amount of Krazy Glue onto the two selected areas and gently depose one side of the door hinge. Be careful not to apply any glue onto the rotating area. Wait 5 minutes for the glue to be fully solidified.

To maximize the reflection of light from the LED towards the UV orange shield, a total of 5 mirror metallic pieces are cut and glued at the bottom of the LED box.

2.1 --> Carefully measure and mark the dimension of the bottom surface of the box onto the mirror surface of the sheet. Then, gently cut with scissors the desired area of interest.

2.2 --> Proceed similarly by measuring each side of the LED box and marking the measurement onto the mirror glassy sheet. Next, cut with scissors a total of 4 pieces that will cover each inner side of the box.

2.3 --> By applying Krazy glue onto each inner side of the box, gently glue each metallic component.

2.3 --> To allow the wires from the LED to connect to the electronic circuit located within the electronic box, a small hole having a diameter of 0.3'' is created using a tool of preference. A conventional drill has been used for the purpose.

2.4 --> To diffuse the light emitted by the series of LEDs, the plastic PLA sheet previously printed is deposited on the upper surface of the box. Different thicknesses could be tested to optimize the diffusion of light throughout the PLA plastic sheet.

3.1 --> Drill a hole on the right side of the electronic box to allow the insertion of the power jack. Ensure to select the hole diameter following the size of the power jack.

3.2 --> Apply a small amount of Krazy glue onto the back perimeter of the box. Gently align the box onto the LED box. Wait 5 min for the glue to solidify. Do not glue the cover onto the electronic box as the circuit components will have to be soldered and inserted.

3. Assembling the electronics components as well as programming the microcontroller:

  • Solder the Arduino Nano onto the PCB board.
  • Utilizing a black jumper wire, connect the ground pin of the power jack to the ground pin of the switch.
  • Utilizing a red jumper wire, connect the power pin of the jack to the middle power pin of the switch. This will allow the LED indicator of the switch to be lit up once power is turned ON.
  • Solder the green data line from the LED strip to digital PIN6 of the Arduino board.
  • Solder the white data line from the LED strip to the GND PIN of the Arduino board.
  • Solder the RED power line from the LED strip to the remaining power PIN of the switch.
  • Solder an additional jumper wire from the power PIN of the switch to the VIN PIN of the Arduino board. This will allow the input voltage from the jack to power the Arduino.

- Arduino Programming

Library Required: Adafruit NeoPixel

Software from the Adafruit NeoPixel library: strandtest

If not already downloaded, the Adafruit NeoPixel library can be download by following:

  • Tools
  • Manage Libraries
  • Searching with keyword --> NEO
  • Click install on--> Adafruit NeoPixel

As demonstrated in the image provided, the colour dynamics of the LED strip can be adjusted by adding "//" to the lines of code associated with the undesired colour. Since only blue is desired for the application, all other lines are commented by adding --> "//."

void loop() {
// Fill along the length of the strip in various colors...
//colorWipe(strip.Color(255, 0, 0), 50); // Red
//colorWipe(strip.Color( 0, 255, 0), 50); // Green
colorWipe(strip.Color( 0, 0, 255), 50); // Blue

// Do a theater marquee effect in various colors...
//theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
//theaterChase(strip.Color(127, 0, 0), 50); // Red, half brightness
//theaterChase(strip.Color( 0, 0, 127), 50); // Blue, half brightness

//rainbow(10); // Flowing rainbow cycle along the whole strip
//theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}

4. Testing the device and proposing potential improvement:

  • The thickness of the transparent PLA plastic sheet can be adjusted to provide optimal light diffusion.
  • Additional LED strips could be added to increase the light intensity.
  • Selecting LED strips with the ability to emit within the UV range of the electromagnetic spectrum would allow greater flexibility during the selection of staining dye.

Code

LED Neopixel CodeC/C++
// A basic everyday NeoPixel strip test program.

// NEOPIXEL BEST PRACTICES for most reliable operation:
// - Add 1000 uF CAPACITOR between NeoPixel strip's + and - connections.
// - MINIMIZE WIRING LENGTH between microcontroller board and first pixel.
// - NeoPixel strip's DATA-IN should pass through a 300-500 OHM RESISTOR.
// - AVOID connecting NeoPixels on a LIVE CIRCUIT. If you must, ALWAYS
//   connect GROUND (-) first, then +, then data.
// - When using a 3.3V microcontroller with a 5V-powered NeoPixel strip,
//   a LOGIC-LEVEL CONVERTER on the data line is STRONGLY RECOMMENDED.
// (Skipping these may work OK on your workbench but can fail in the field)

#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?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN    6

// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 60

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 3 = Pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)


// setup() function -- runs once at startup --------------------------------

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.

  strip.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)
  strip.show();            // Turn OFF all pixels ASAP
  strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}


// loop() function -- runs repeatedly as long as board is on ---------------

void loop() {
  // Fill along the length of the strip in various colors...
  //colorWipe(strip.Color(255,   0,   0), 50); // Red
  //colorWipe(strip.Color(  0, 255,   0), 50); // Green
  colorWipe(strip.Color(  0,   0, 255), 50); // Blue

  // Do a theater marquee effect in various colors...
  //theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
  //theaterChase(strip.Color(127,   0,   0), 50); // Red, half brightness
  //theaterChase(strip.Color(  0,   0, 127), 50); // Blue, half brightness

  //rainbow(10);             // Flowing rainbow cycle along the whole strip
  //theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}


// Some functions of our own for creating animated effects -----------------

// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
  for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
    strip.setPixelColor(i, color);         //  Set pixel's color (in RAM)
    strip.show();                          //  Update strip to match
    delay(wait);                           //  Pause for a moment
  }
}

// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
  for(int a=0; a<10; a++) {  // Repeat 10 times...
    for(int b=0; b<3; b++) { //  'b' counts from 0 to 2...
      strip.clear();         //   Set all pixels in RAM to 0 (off)
      // 'c' counts up from 'b' to end of strip in steps of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
      }
      strip.show(); // Update strip with new contents
      delay(wait);  // Pause for a moment
    }
  }
}

// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
  // Hue of first pixel runs 5 complete loops through the color wheel.
  // Color wheel has a range of 65536 but it's OK if we roll over, so
  // just count from 0 to 5*65536. Adding 256 to firstPixelHue each time
  // means we'll make 5*65536/256 = 1280 passes through this outer loop:
  for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
    for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
      // Offset pixel hue by an amount to make one full revolution of the
      // color wheel (range of 65536) along the length of the strip
      // (strip.numPixels() steps):
      int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
      // strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
      // optionally add saturation and value (brightness) (each 0 to 255).
      // Here we're using just the single-argument hue variant. The result
      // is passed through strip.gamma32() to provide 'truer' colors
      // before assigning to each pixel:
      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
    }
    strip.show(); // Update strip with new contents
    delay(wait);  // Pause for a moment
  }
}

// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
  int firstPixelHue = 0;     // First pixel starts at red (hue 0)
  for(int a=0; a<30; a++) {  // Repeat 30 times...
    for(int b=0; b<3; b++) { //  'b' counts from 0 to 2...
      strip.clear();         //   Set all pixels in RAM to 0 (off)
      // 'c' counts up from 'b' to end of strip in increments of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        // hue of pixel 'c' is offset by an amount to make one full
        // revolution of the color wheel (range 65536) along the length
        // of the strip (strip.numPixels() steps):
        int      hue   = firstPixelHue + c * 65536L / strip.numPixels();
        uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
        strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
      }
      strip.show();                // Update strip with new contents
      delay(wait);                 // Pause for a moment
      firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
    }
  }
}

Custom parts and enclosures

Fusion 360 Model
uv_illuminator_box_v16_Dk2Kd1BUb0.f3z

Schematics

Circuit Diagram
F11q3zsko8m3mjt 60tqvilzz9

Comments

Similar projects you might like

BLElectric Light 101

Project tutorial by Gregory O. Voronin

  • 4,612 views
  • 3 comments
  • 15 respects

COVID-19 Simple Friendly Social Distance Robot Watchzi

Project tutorial by draakje156

  • 6,110 views
  • 0 comments
  • 6 respects

Arduino Audio Reactive Desk Light

Project tutorial by Haziq Azri

  • 30,139 views
  • 6 comments
  • 51 respects

Open Source Pulse Oximeter for COVID-19

Project tutorial by Arduino “having11” Guy

  • 81,893 views
  • 36 comments
  • 141 respects

Skype Status Light

Project tutorial by Matheus Fenner

  • 14,114 views
  • 3 comments
  • 17 respects
Add projectSign up / Login