close-circle
Close
0%
0%

The Dragonfly: Nature's Guided Missile

Examining the neural activity of dragonfly predatory behavior to discover the mechanics of its highly accurate prey capture

Similar projects worth following
The dragonfly can capture its prey mid-air with a 95% accuracy rate. What biological equipment does the dragonfly have that allows it to do this amazing feat? To examine this very question, I will be replicating Paloma T. Gonzalez-Bellido's 2012 PNAS paper using DIY open source tools. Gonzalez-Bellido found that there are neurons that run from the dragonfly's compound eyes to its wings that help the dragonfly track and catch its prey with such accuracy. My version of this experiment will control a laser using a laser-light show set up (instead of a expensive custom-made projector) that shines a laser dot (representing a fly) as the stimulus. I will simultaneously be recording on open source bio-amplifiers the activity from these target selective neurons as the dragonflies watches its "prey" move across a screen.

The goal of this experiment is to provide a way for amateur scientists to replicate professional research.

Background:

The dragonfly is nature's guided missile. They can use their 360° visual span to swoop down and devour their prey mid-flight with a 95% kill rate. They can individually manipulate the trajectory of each wing to switch directions rapidly in mid-flight. Ant-Man? Spider-Man? They really should have Dragonfly-Man. To illustrate this insect’s abilities, I invite you to google “dragonfly catching fly slow motion video,” or something of that sort. You will be amazed.

Despite their stunning predatory accuracy, dragonflies are deceptively simple creatures. 300 million years ago, they were still buzzing around like little killer drones. The source of the accuracy of dragonflies is also deceptively simple. Eight pairs of neurons (called TSDNs for target selective descending neurons) that run from the dragonfly’s visual system to their flight center, help them encode the direction of their target (their prey) and track it with such incredible accuracy. Through examination of this surprisingly simple yet adept insect, it is my hope that my research can be used for the purpose of furthering technology, such as building a faster, more accurate helicopter, and education, by providing a cheap, DIY method of producing a professional experiment.

In my project, I will be replicating and extending Paloma Gonzalez- Bellido’s 2012 paper, “Eight pairs of descending visual neurons in the dragonfly give wing motor centers accurate population vector of prey direction.” This paper studies the relationship between eight pairs of neurons and the dragonfly’s predatory abilities. The results of the paper show that these neurons, aptly named the target-selective descending neurons (TSDNs), encode a population vector that is strongly correlated with the position of the target (the fly). This means that these eight pairs of neurons are direction-oriented, or that they have a preferred direction and show more activity when their direction is favored.

The Original Set-Up:

As previously mentioned, this project will be replicating a academic paper, "Eight pairs of descending visual in the dragonfly give wing motor centers accurate population vector of prey direction." In this paper, Gonzalez-Bellido used a modified projector to shine a black dot (representing prey) on a curved screen and measured the neural activity of the dragonfly. Below is Gonzalez- Bellido's set up:

The set-up in the original 2012 paper

My Set-Up:

In my set up I will use a laser light show system instead of an expensive modified projector. The laser show is very replicable because it is cheap and made with materials that most makers have around. My laser light show includes two servos and an Arduino Uno. These servos have mirrors attached to them. As different voltages pass through these galvos, the mirror will change position. The two servos, one moving in the x direction and one in the y, will change the position of the laser. The laser and the two servos are connected to an Arduino Uno, making the position of the laser both reliably and easily manipulated through Arduino software. Furthermore, a Spikerbox (Backyard Brains) is connected to two electrodes (one in the dragonfly's abdomen and acting as a ground, and one in the TSDN) to measure the neural activity of the target neurons, and displaying it on an laptop. This set-up is pictured below:

My modified set-up


If all works, the essential goal of my experiment is to provide a way for anyone to replicate professional laboratory neuroscience!

servo_laser_draft1.ino

First draft for the final laser show

ino - 4.15 kB - 07/11/2016 at 12:43

download-circle
Download

  • 1 × Spikerbox pro and electrodes
  • 1 × Arduino Uno
  • 1 × Laser
  • 2 × Servo
  • 2 × mirror

View all 9 components

  • The next steps

    Patricia Aguiar07/11/2016 at 05:41 0 comments

    The next steps of the project are...

    1) set up a coordinate system in Matlab so by inputing the change in degrees of the servos, I can know the change in position on the screen.

    2) Using Matlab, create figures that relate the neural activity to the position and direction of the laser beam.

    3) Test with dragonfly using entire set-up (new laser light show, Spikerbox pro double events recorder, etc)

  • Manipulating the code for the laser set-up

    Patricia Aguiar07/11/2016 at 05:34 0 comments

    In order to replicate Paloma Gonzalez-Bellido's experiment, I need to be able to manipulate the direction and position of the laser beam. In Paloma Gonzalez- Bellido's 2012 paper she publish these results:

    Gonzalez-Bellido, P. T., H. Peng, J. Yang, A. P. Georgopoulos, and R. M. Olberg. "Cozzarelli Prize Winner: Eight Pairs of Descending Visual Neurons in the Dragonfly Give Wing Motor Centers Accurate Population Vector of Prey Direction." Proceedings of the National Academy of Sciences 110.2 (2012): 696-701. Web.

    The diagrams on the left column plot the preferred direction of a certain neuron (labeled DIT.., MD... etc). Imagine that in the centers of the circles are the dragonflies, and that each color represents a position the target could be moving in. The red arrow points to the position that is preferred. The next column represents the flattened out screen. Each colored dot represents a pixel that the target has either started or passed through, and each color represents the direction. By looking at the left column, we can determine the direction the target was moving. The last column represents the firing rate- yellow being the greatest and black being the weakest.

    I wrote a first draft of code, using Arduino, to mimic the experiment. Using the data collected about the preferred direction and the preferred starting location of the target, I designed code that would move the laser beam from each of the preferred starting locations for each of the neurons and travel in each of the neurons preferred directions.

    For example, I wrote code for the neuron MDT3:

    #include <Servo.h>
      
      const int servo = 10;       // The servo motor pin
      const int servo2 = 11;
      int laserPin = 12;
      Servo myservo;  // create servo object to control a servo
      Servo myservo2;
      int servoAngle= 0;
      
      void setup() {
      
        // Servo  
      pinMode(laserPin, OUTPUT); // set up the laser pin
      
        myservo.attach(servo);  // X servo
        myservo2.attach(servo2); // Y servo
      
    
      }
      
      
      void loop(){
        
        for (int i = 0; i < 11; i ++)
        {
        
        for (int j =0; j < 5; j ++)
        {
          
        digitalWrite(laserPin, LOW);
         
          myservo.write(30); // X servo starting point
          myservo2.write(60 - i*(2.5)); // Y starting point - moves with i
          delay(100); // 100 millisecond delay
          digitalWrite(laserPin, HIGH); // turns the laser on
          for(servoAngle = 30; servoAngle < 55 ; servoAngle ++)
        {    
          myservo.write(servoAngle); // X servo moves
    
           delay(50);
        
        }
        }
        
        delay(1000);
        }
      
      
      }
     
    
    The result is:

    Here is the first draft of the code for the final testing:

    #include <Servo.h>
      
      const int servo = 10;       // The servo motor pin
      const int servo2 = 11;
      int laserPin = 12;
      Servo myservo;  // create servo object to control a servo
      Servo myservo2;
      int servoAngle=0;
      
      
      void setup() {
      
        // Servo  
      pinMode(laserPin, OUTPUT); // set up the laser pin
      
        myservo.attach(servo);  // attaches the servo to the servo pin
        myservo2.attach(servo2);
      
        // Inizialize Serial
    
      }
      
      void loop(){
        
        //DIT1
        
        for (int i = 8; i < 11; i ++)
        {
        
        for (int j = 0; j < 5; j ++)
        {
         
         
          myservo.write(55);
          myservo2.write(60 - i*(2.5));
          delay(100);
          digitalWrite(laserPin, HIGH); // turns the laser on
          for(servoAngle = 30; servoAngle >10 ; servoAngle --)
        {    
          myservo.write(servoAngle);
    
           delay(50);
        
        }
        digitalWrite(laserPin, LOW);
        delay(2000);
        }
        delay(10000);
        }
        
        //DIT3
            for (int i = 0; i < 11; i ++)
        {
        
        for (int j =0; j <5; j ++)
        {
          
    
         
          myservo.write(55);
          myservo2.write(60 - i*(2.5));
          delay(100);
          digitalWrite(laserPin, HIGH); // turns the laser on
          for(servoAngle = 45; servoAngle >20 ; servoAngle --)
        {    
          myservo.write(servoAngle);
    
           delay(50);
        
        }
           digitalWrite(laserPin, LOW);
        delay(2000);
        }
    
        
        delay(10000);
        }
        
        //MDT1
            for (int i = 0; i < 11; i ++)
        {
        
        for (int j =0; j <5; j ++)
        {
          
      
         
          myservo.write(55);
          myservo2.write(60 - i*(2.5));
          delay(100);
          digitalWrite(laserPin, HIGH); // turns the laser on
          for(servoAngle = 55; servoAngle >20 ; servoAngle --)
        {    
    ...
    Read more »

  • Laser set-up: version 3

    Patricia Aguiar07/11/2016 at 03:21 0 comments

    Given the previous problems, I then started on a new set-up hopeing to 1) solve the curvature of the beam problem 2) make a more stable, cleaner set-up.

    The final result:

    What I did:

    I cut wood to use for a stand, and used an acrylic sheet for a base. I made the Y servo mirror much longer horizontally so that the Y servo would reflect a wider range of movement fro the X servo. I met one of my goals, to create a more stable, cleaner set-up. However, I still found that there was some curvature of the laser beam. I am afraid that that might be unavoidable, but also could be easy to work around using code.

  • Building a servo laser set-up: prototype 2

    Patricia Aguiar07/11/2016 at 01:21 0 comments

    I built a servo laser set-up (prototype 2) that allows me to control the movement of the laser beam across a curved screen using an X direction servo and a Y direction servo.

    Below is the final result of prototype 2:

    The problems:

    The hot glue on the mirrors makes the mirrors tilt at an angle, and not line up exactly with the wooden sticks.

    This curves the laser beam, and does not make it perfectly straight. Furthermore, my set-up was altered many times to get the laser, the mirrors and the screen to line up. Thus, the set-up is overall very messy and filled with scraps of old glue, tape, and wood.

  • Connecting the laser to the Spikerbox

    Patricia Aguiar06/29/2016 at 03:32 0 comments

    From previous neural recordings, I have data of the spikes of the TSDNs. However, I had yet to find a way to record the onset of the stimulus (turning on the laser) so that I could correlate it to the spikes. In order to both simultaneously record the event of the laser turning on and the neural recording of the daringly TSDN, I exchanged my neuron Spikerbox for a Muscle Spikerbox Pro, which allows me two channels (later I would find that I didn't even need the second).

    Basic schematic for how this will be accomplished:

    This allows me to simultaneously record whether the laser is on and record from the neuron of the dragonfly.

    Here are some more pictures of how I accomplished this:

    Below is a video of the final result:

    The red lines on the laptop screen represent the laser turning on. I do not yet have an event marking the laser turning off-- maybe that's the next step! Also, the white recording on the laptop screen is the recording from the electrodes (which will be recording from the dragonfly neuron.)

  • Laser show: the first prototype

    Patricia Aguiar06/29/2016 at 03:22 0 comments

    Today I started working on the first prototype for the laser set-up. Previously, I had tried to make a laser show out of bass speakers. However, I found that the bass speakers that I had did not allow me the range of motion that I wanted.

    A picture of the bass speaker set up that I chose not to use:

    So, I instead decided to rig up a laser show out of servos. Starting simple, I only used one servo, meaning only one degree of freedom.

    My laser set up:

    Using a servo motor (I started with the continuous rotation, then moved on to the stepper) and an Arduino Uno, I connected the two so that the servo moved in an angle of about 40 degrees, paused for a second, then returned. I found that the stepper motor was best for this (not the continuous rotation) because it allowed me to plug the desired angle right into the code. By connecting a mirror onto the servo, I could shine a laser onto the servo, reflect it onto a screen, and move the laser beam by controlling the movement of the servo. Additionally, through the Arduino, I could turn on and off the laser easily.

    Below is a picture of the set up:

    The servo and the laser are both connected to the breadboard, and then to the Arduino.

    Here is the code I used to power the laser and servo:

      #include <Servo.h>
      
      const int servo = 10;       // The servo motor pin
      int laserPin = 12;
      Servo myservo;  // create servo object to control a servo
      int servoAngle = 0;   // servo position in degrees
      
      
      void setup() {
      
        // Servo  
      pinMode(laserPin, OUTPUT); // set up the laser pin
      
        myservo.attach(servo);  // attaches the servo to the servo pin
      
        // Inizialize Serial
        Serial.begin(9600);
        myservo.write(servoAngle); 
        delay(1000);
      
      }
      
      
      void loop(){
       
      
      
        
          digitalWrite(laserPin, HIGH); // turns the laser on
          for(servoAngle = 0; servoAngle < 40; servoAngle++)  //move the micro servo from 0 degrees to 40 degrees
        {    
          myservo.write(servoAngle); 
          delay(50); 
       
        }
        
        digitalWrite(laserPin, LOW); // turn the laser off
        myservo.write(0); // return to zero degrees
      
        delay(1000); // pause for one second
        
    }
    
    

    This moves the servo in a 40 degree wedge and turns off the laser once the servo has hit the 40 degree mark and has moved back to 0. I connected the laser by removing the batteries, connecting an alligator clip to the spring in the center of the laser (ground) and connecting another alligator clip to the metal surrounding it. Connect the ground to ground on the Arduino and the other to the 12 pin.

    After I got the servo and laser working, it looked like this:

    The problems with this set up are that the servo is a little unstable, meaning the laser beam is quite jerky when it moves. Maybe this does not matter to the dragonfly TSDNs. I will see. The next step, trying to find some way to record on the computer when the laser turns on and when it turns off!

  • Dragonfly neural recordings

    Patricia Aguiar06/23/2016 at 11:14 1 comment

    Neural recordings:

    Yesterday, I recorded from the neuron of the dragonfly without the lasers, just to ensure the materials are working and that I can find the TSDNs. For the neural recordings of the dragonfly, I aimed to place the electrode in the TSDN. These neurons run down the dragonfly's neck, on the right and left side, just above the thoracic ganglia. (Pictured below)

    The TSDNs are the thin white lines running on both sides of the dragonfly's neck, as shown by the red arrows. I placed the electrode on the right one. As seen below, I placed a thin wire in the right TSDN.

    But before I placed the electrode in I anesthetized my dragonfly (about 2 hours in a refrigerator).

    Materials needed of the neural recordings:

    - Spikerbox (from Backyard Brains)

    - a speaker (optional) and audio cable

    - one dragonfly

    - insect wax (or tape)

    - popsicle stick

    - silly putty (or tape)

    - clips, stand or clamp

    - string

    - electrodes

    - micromanipulator (optional, you can just use free delicate wires if you have a steady hand)

    - laptop, iPad, or iPhone

    The finalized set up should look like this:

    Make sure to set as much as you can up before you take the dragonfly out of the refrigerator, to make sure that the dragonfly does not wake up before you have the electrodes in. Once the dragonfly is anesthetized, secure the dragonfly ventral side up on a popsicle stick with insect wax and silly putty. Make sure not to touch the wings with either substance, the wings are extremely fragile! After securing the body, I used string to keep the neck exposed. While I was securing the dragonfly, it woke up so I put it in ice water (leaving the lower abdomen exposed to that it could breathe). After 15 minutes, I took it out.

    After the dragonfly is secured onto the popsicle stick with his back waxed onto the stick with insect wax and his legs secured with silly putty, place the electrode in the right TSDN (as shown in above pictures) and place the ground electrode in the side of the lower abdomen. (This ground is cut off by the picture but I placed in the "tail" on the right side. I placed the electrode so that it was almost parallel to the dragonfly, not perpendicular, to cause as little damage as possible.

    I placed the dragonfly on the Spikerbox (a device for measuring action potentials), and plugged in the speakers. I heard a rattling sound- the sound of action potentials firing. I waved a wooden stick around the front of the dragonfly and heard the action potentials greatly increase in frequency. The increase in frequency corresponded to the movement of the stick.

    Alternatively, you can wave a piece of paper with a black dot on it. Actually, basically any movement (including laser beams) cause firing. I also placed a paper towel 'screen' around the set up to shine the laser beam (as seen in the project pictures).

  • Catching Dragonflies

    Patricia Aguiar06/22/2016 at 15:35 0 comments

    Catching the dragonflies:

    The first step of my project is to collect the dragonflies. Dragonflies love vegetation near waterways (rivers, streams, ponds, lakes etc.) All you need to catch them is a butterfly net and a mesh cage. Once I caught enough, I put the dragonflies in individual cups and place them in the refrigerator (this will anesthetize them).

    Above is a dragonfly perched in my mesh cage

    Note: It is important not to catch a damselfly! They look a lot like dragonflies but they are thinner, and when they perch their wings touch (as opposed to dragonflies, whose wings remain spread).

    Above is a dragonfly in a bag (not closed to let in air) ready to go in the refrigerator.

    Dragonflies in the refrigerator (5 dragonflies). The dragonflies are in the petri dishes and the plastic bags are lightly placed on top to ensure that the dragonflies do not get out. The bag is open enough to let in plenty of air and big enough not to squish the dragonfly.

View all 8 project logs

  • 1
    Step 1

    Essential materials:

    (from top left to bottom right)

    1. Spikerbox pro (with appropriate cord to plug into laptop and electrodes)

    2. breadboard

    3. Arduino Uno and jumper cables/ wires

    4. Mirrors (two)

    5. servos (two)

    6 USB chord (for Arduino to laptop)

    7. laser (not pictured)

    Non-essential materials:

    1. materials for stand and base for laser light show (I used wood and acrylic)

    2. supports for mirror (I used wooden sticks and popsicle sticks)

    3. microscope (not needed, just helpful)

    4. insect wax and popsicle sticks

    5. thread and silly putty (for the neural recordings)

    6. paper (for the curved screen)

    7. solder and soldering iron

    optional: Neuron spikerbox (pictured above)

  • 2
    Step 2

    Set up the laser light show:

    Gather the following materials for the next couple of steps:

    1. servos (two)

    2. mirrors (two)

    3. jumper cables

    4. breadboard

    5. Arduino

    In this step we will connect the servos to the Arduino so that we can control their movement through code.

    This fritz shows how one servo is hooked up, do the same for the other servo.

    These are the servos I used:

    Each servo has a brown, yellow and a red cable. The brown and red are for ground and power, respectively, and the yellow is for the signal. The yellow can be plugged into the Arduino pin 10. Do the same for the other servo, except plug the yellow into pin 11.

    Try this test code:

    include <Servo.h>
      
      const int servo = 10;       // The servo motor pin
      const int servo2 = 11;
     
      Servo myservo;  // create servo object to control a servo
      Servo myservo2;
    
      
      void setup() {
      
        // Servo  
      
        myservo.attach(servo);  // attaches the servo to the servo pin
        myservo2.attach(servo2);
      
      }
      
      
      void loop(){
        
    
          for(servoAngle = 0; servoAngle < 20; servoAngle++)  //move the micro servo from 0 degrees to 20 degrees
        {    
         
          myservo.write(servoAngle); 
          myservo2.write(servoAngle);
          delay(50); 
          
        }
        
        
        digitalWrite(laserPin, LOW); // turn the laser off
        myservo.write(0); // return to zero degrees
        myservo2.write(0);
      
        delay(1000); // pause for one second
        
    }

  • 3
    Step 3

    Next step is to glue the mirrors onto the servos. I used wooden sticks and mirror pieces that I cut from a large hand mirror.

    Try to get the mirrors flush on the wooden sticks.

View all 9 instructions

Enjoy this project?

Share

Discussions

harayz wrote 07/16/2016 at 06:57 point

  Are you sure? yes | no

Jeremy g. wrote 07/08/2016 at 18:06 point

awsome project, learned something about dragonflies I did not previously know. Awsome creatures.

Keep it up!

  Are you sure? yes | no

Patricia Aguiar wrote 07/10/2016 at 16:37 point

I'm glad! Thank you!

  Are you sure? yes | no

zakqwy wrote 07/06/2016 at 21:15 point

Super cool project! Watching dragonflies hunt is a ton of fun. Do you know the BYB folks? If not, you should drop in on them and show off your project--they're HQ'd in Ann Arbor.

  Are you sure? yes | no

Patricia Aguiar wrote 07/07/2016 at 14:22 point

Thank you! Yeah, it's super fun. I do know them- I'm actually an intern there right now!

  Are you sure? yes | no

Jarrett wrote 06/22/2016 at 18:11 point

Needs more pictures of dragonflies!

They're rad.

  Are you sure? yes | no

Patricia Aguiar wrote 06/23/2016 at 11:09 point

True true! I just caught some today, more pictures to come!

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates