Illusionist's Locket Pt. 4

I did some work on the locket today. The first thing I did was I marked the sides of the magnets with a sharpie so I could distinguish between the N and S poles. To do this, I just stacked them all up and sharpie-d the tops one by one. 

The next thing I did was I heat treated a pin I turned from O1 tool steel. I used the furnace to gradually heat it to 1450F and let it soak for 15min. I then quenched it in oil. The subsequent hardness test shows a hardness of almost C59 Rockwell. It started out as B96. The spec sheet says it can be hardened up to C64, but I am satisfied with C59. This just means I don't have to temper it back down again. Next I'm going to turn down the diameter a bit more with a tungsten-carbide tool and finish it with a grindstone on the lathe. I would use a cylindrical grinding method, but we don't really have that capability at the shop. 

Experimenting With Copper Patinas

When debating what material to make the locket out of, I learned of an interesting technique used by metal artists/jewelers to give their work pieces interesting colors. By heating the work, you are speeding up the chemical corrosion of the surface of the copper. You can also submerge the work in chemical solutions to achieve the desired reaction. Using a torch requires less overhead, so I'm going to see if I can get this to work. 

The main problem with flame patination is creating/speeding up unwanted chemical reactions that may produce visual effects that interfere with the one you want. I'm still doing research to try and understand exactly what the red patina is, and how it's different than the black flaky firescale, which, as I understand, is also a type of oxidation reaction. 

I tried making a traditional boric acid flux. Typically, the powdered boric acid crystals are dissolved in denatured alcohol or methanol to form a saturated solution. The work is then coated in this solution, and when the alcohol evaporates/burns off, a thin layer of boric acid crystals remains on the surface of the work. I didn't realize that boric acid was different than borax, and so the flux wasn't very effective, and heating the borax turned it into a weak brittle glass. Boric acid can be easily made from borax simply by reacting it with hydrochloric acid, so I may try that tomorrow. 

Even without using the proper flux, I was able to get some decent purple-ish red colors. I will buff them tomorrow and see how they look, and try the flux as well. Then I'll need to figure out the best way to clear-coat them to protect the patina. 

Kinematics of Wheeled Mobile Robots Pt. 2

I discovered a few minor issues with my previous derivation. I had not converted the unit vectors from one frame to the other correctly, and I left some of the expressions in the unit vectors of an inappropriate frame. MATLAB was used to verify the equations. Simple inputs were sent to the equations and various outputs were plotted for evaluation. The rainbow plots show the physical path of the robot in the XY plane. The color indicates the angle of rotation in degrees. The last graph shows my original eureka moment when I finally realized I fixed the problem. Previously, there was a cusp in the magnitude of velocity when it should have been constant. When I saw the constant red line, I knew I was on the right track. 

Because the control inputs are centered to the robot's frame, if you hold constant translational inputs with a rotation, the robot will end up taking a curved path. However if you hold constant translational inputs with no rotation, the robot will travel straight. This is shown by the graphs with no color change.

A Hard Day's Work

I love working with my hands and making things. At the end of the day, I find it very satisfying to be able to look at the things I've made and say "this is what I did today".

What I did:

1. Finished assembling the scaled circuit breaker model for our senior design project. This involved gluing up the sides of the box, and screwing on the wheels and the rollers. We did not have a thin enough wrench to tighten the roller between the two surfaces, so I had to make one.

2. Began prototyping the device to reduce torsion in coils of optical fibers. I used the laser cutter with 1/4" acrylic. I designed the part so that I could prototype it in 1/4" layers, stacking and gluing together different profiles to get the correct geometry of the final part. The part on the bottom is composed of just two layers. The part on the top (with the spiraling slots) is a single layer part.

Isolating Pure Bending in Optical Fibers

One of the grad students from the nanophotonics lab I developed the microbend apparatus for contacted me regarding a question he had. He was trying to isolate bending and torsional loads in optical fibers to investigate their effects. Introducing pure bending in a fiber is difficult because the fibers have very little torsional stiffness. It's easy to eliminate bends to a twisted fiber by simply adding a bit of tension to the ends. But how do you eliminate twist? There is so little stiffness that you cannot rely on the restoring torque to eliminate small twists in the fiber. The current solution is to coil the fiber very loosely (coiling is just one very long continuous bend) whatever twist is inadvertently introduced by the act of coiling will distribute itself along the length of the entire fiber. In contrast, in fiber optic gyroscope winding, because the coils are so tight, the minor twists in the fiber get trapped between turns of the coil, leaving behind localized residual torsions in the fiber. 

The downside to a loose coil is that it is very hard to get each turn in the coil to the same diameter. A constant bending radius is required for accurate measurements. We decided to use an iris diaphragm mechanism to control the diameter of 6 pins, which the fiber will loosely be wrapped around as guides. This way, a very minimal amount of tension could be used to make sure the coils are all the same diameter, and the diameter can be adjusted using the iris mechanism. To go along with this, it would be helpful to have a limited slip fiber clamp and constant force spring loaded spool so the diameter could be adjusted either direction without having to manually pick up slack in the fiber or loosen the coils to reduce the tension. 

One other alternative to this 'loose coil' solution is to actively measure and correct the fiber twist. However, this method seems overly complex. It really depends on how much twist is tolerable. Once that is quantified, we will be able to determine what type of solution is required. I have a feeling the tolerance will not be so tight as to necessitate some type of active system. But I wonder if there is a better solution for an active system? Perhaps if instead of wrapping the fiber around pins, we could wrap it around an expanding cylinder controlled by the iris mechanism. But I have no idea how that could work. Time to start brainstorming...

Illusionist's Locket Pt. 3

I machined the first parts of a prototype today. I used a 3/8" ball-mill to get the central channel for the barrel pivot to rest in. I'm trying to see if there is a better way to do this, as the ballmill leaves a circular edge when I'd rather have a flat face. Also, slight errors in the depth of the ballmill correspond to the channel for the barrel not being cylindrical. There are still many improvements to be made!

Illusionist's Locket Pt. 2

Today I was able to reverse engineer the mechanism that switches the photos in the locket depending on the configuration. The key is having a two-part barrel that the halves pivot about. The two parts of the barrel are not attached, allowing them to separate when the locket is opened. Each half of the barrel is fixed to one of the movable heart pieces, allowing the other heart pieces to rotate around them, and allowing the barrel halves to slide over each other. 

The next step is to incorporate this mechanism into my existing design. I will probably need a few more magnets to hold the locket closed. I will also modify some of the geometry of the barrels and the barrel slots so they are machinable. 

New Project: Quantum Dot Lite Brite

My boss put me on a team to design and fabricate the hardware required for a new activity being developed. The activity is centered on Quantum Dot (QD) technology. The basic concept is that these nano-scale QDs emit single wavelengths of light when excited by UV light. The emitted wavelength is related to the radius of the QD, so larger QDs emit longer wavelengths. Typically, QDs are stored in a liquid solution which is toxic and dangerous for children to handle. However, it is possible to embed QDs in a plastic polymer which is safe for children to handle. The plastic is made by creating a solution of QDs in the polymer, pouring the solution into a mold, and vacuum baking the solution to harden the plastic in the mold.

The plastic itself is clear until you illuminate it with UV light. Once illuminated with UV light, the QDs inside the plastic will emit light, causing the plastic to glow! We plan on making lots of plastic pieces with different sized QDs in them (the QD sizes will correspond to different colors) and having students arrange the plastic pieces on a grid to make a picture of something. These plastic pieces will essentially be pixels in that sense. They will insert their arrangement of pixels into a UV light-box consisting of of a UV source, a UV transparent platform to lay the arrangement on, and a UV resistant shield for viewing the glowing arrangement. 

There are three issues I have identified as being critical to the success of the project:

1. Safety. We need to ensure that the children cannot activate the UV source while the UV shield is not installed, to be sure that the children will not be exposed to the UV rays. We also need to assess the effectiveness of the UV shield.

2. Light Source Requirements. We need to ensure that our light source emits UV light at the correct wavelength to excite the QDs, and that the intensity of the UV rays is high enough that the pixel arrangement will glow visibly and impressively to the students. We are currently leaning towards using an array of UV LEDs underneath the arrangement to ensure all the pixels receive an equal light intensity.

3. Casting the Pixels. Currently the pixels are cast in an off the shelf silicone mold used for baking. The plastic parts from the mold are roughly rectangular, but have many imperfections and low dimensional repeatability. We need to develop a mold/molding process that results in repeatable, rectangular plastic pieces that will fit together on a grid. Fitting together multiple pieces in a grid will result in a tolerance stackup. So the smaller we decide to make the pixels, the more we can fit in the grid, and therefore the tighter the tolerance on each pixel will have to be to guarantee the same degree of alignment on the grid.

Illusionist's Locket

This is a present I plan on making for my girlfriend for Valentine's Day. It is a metal heart made of two halves that are connected with a dowel pin and magnets. When the two halves are arranged in the heart configuration, the magnets attract each other and so the configuration is stable. When you twist the halves apart, the halves take the form of an oval. With the magnets' positions switched, the halves repel each other, allowing the user to separate the halves and gain access to the secret pockets inside each half. The secret pockets can be used to small rings, a small note, etc.

I've also decided to take advantage of the fact that our initials form a palindrome. If our initials are engraved a certain way on the two halves, on one side of the heart configuration the letters read "MD" (her initials) and on the other side the initials read "DM" (my initials). When rotated to the oval configuration, both sides are the same but are upside down relative to each other. So it reads "DM" or "MD" depending on how you look at it. I like to think of it as being symbolic of our partnership together.

Manufacturing should be relatively simple. The two halves can be CNC'd out of bar stock. I made the angle on each half 45 deg so that any standard shop gauge block could be used to mount the middle face parallel to the table of the mill for drilling the holes and milling the slot. I plan to use a 1/8" steel dowel pin for the center pivot shaft which can be turned on the lathe. Adhesive backed neodymium magnets will be used for retention. If I decide to do the engraving I will need to make some sort of fixture or jig for a flip milling operation on the reverse side of each half of the heart. Hopefully I can make a simple jig with some locating pins mounted on the mill table.

Note: This design is inspired by an Instructable I remembered seeing a while back. The author of the Instructable credits the design to a scene from the movie "The Illusionist". As you can see, the locket in the movie has 2 additional hinges that allow the locket to swing open in both the oval and heart configuration. The "illusion" is that when you open the locket in one configuration, one person's image appears. But when you open the locket in the other configuration, the other person's image appears. And the baffling thing is, it's hard to understand how twisting the locket from the heart to the oval configuration doesn't rip the picture in half. This is a *greatly* simplified version where there really is no illusion. I will use this design as a starting point and hopefully be able to design a locket that has the full functionality as seen in the movie.

Kinematics of Wheeled Mobile Robots

After many discussions, our group has decided that four-wheel drive simply does not permit adequate control of the robot for aligning with the circuit breaker cubicle. So we are reverting to our original drive train choice: swerve drive. Swerve drive is a holonomic locomotion system in which each wheel can pivot about its own vertical axis. Using a swerve drive, the robot will strafe sideways along the face of the circuit breaker cubicle, detecting the edges of the cubicle and using those edges to laterally align the robot. Then, the robot will perform an angular alignment to the face of the cubicle, and advance forward to extract the breaker. The angular alignment and subsequent forward motion would not have been possible with a four-wheel drive system; as the translation and rotation of the robot are coupled.

I derived the inverse kinematics of the robot for our computer engineers to use in their control algorithms. The derivation is quite simple mathematically, but it can easily get confusing to understand from a physical sense. I like to imagine what I would experience if I were sitting on the different points where the wheels are located on the robot. This helps me to see why certain terms are in the resulting equations and verify if the results make sense. 

PDF derivation of the kinematics.

Omniwheel Design

Currently working on a high load capacity omniwheel design for our circuit breaker removal robot (BreakerBot). Off the shelf omniwheels of this load capacity (750lb) are very expensive! This design is an exercise to see if constructing our own wheels is a feasible solution. Our other options are to choose an alternative drive train system that doesn't require these expensive and complex omniwheels. However, those systems are either non-holonomic (ackerman steering) or even more complex (swerve drive). I am hoping that we will be able to use these wheels with sort of H-drive system. We do not need full holonomic control, but the ability to strafe and turn on a point would be very useful for aligning the robot with the breaker's cubicle for extraction. 

MATLAB Project: Aircraft Designer

This is the master program which all the functions described in previous posts feed into. This takes inputs from the fuselage designer, wing designer, and empennage designer and puts all the components together. The motivation for this project was to be able to quickly and easily iterate through aircraft designs. All of the performance calculations were done in an excel spreadsheet, but Excel is not good at making custom plots or managing data. This program receives the geometric parameters of the airplane calculated by the Excel sheet, and uses them to 'build' the airplane for visualization and accurate component layout.

The component layout in the spreadsheet does not account for the form of the volume components (passenger cabin, cockpit, galley, wing box, etc.). On more than one occasion we had designed a fuselage that seemed to contain all the components, only to realize that the calculated cabin length was longer than the fuselage of the aircraft! This program was intended to solve that problem by visualizing the components for instantaneous feedback on the quality of the layout. 

The other main goal of the program was to facilitate the rapid 3-D modeling of the aircraft. Unlike most other objects undergraduates are used to CADing, aircraft often have complex curvatures and geometries that take a long time to make manually. This program produces curves for the fuselage, main wing, and tail surfaces and positions them according to the design specifications. The coordinates for the curves are then exported as .txt files, which can be uploaded into SolidWorks as curves and lofted together. This drastically reduces the time required to produce a solid model and thus enables more rapid design iteration and evaluation.

I'd like to continue adding more to this program, but it looks like there simply isn't enough room on the UI to add more input boxes. Already, many of the parameters cannot be changed from the UI; the code must be manually altered. I was thinking of adding tabbed panels to increase the number of inputs possible, but from my [limited] research they don't seem to be well supported. I think this version should do for now.

MATLAB Mini Project: Propeller Design

As part of my ongoing aircraft design project, I wrote another MATLAB function to produce propellers whose cross sections could be exported for making models in SolidWorks. The function takes inputs from the design calculations of an Excel spreadsheet. The diameter of the rotor, the number of blades, the twist of the blade, and the airfoils comprising the blade are all used to determine the shape of the propeller. For now, only straight tapered blades defined by a root and tip airfoil can be produced. But this code serves as a first step for designing and plotting more complicated blades with curved planforms and nonlinear twists. Right now the twists are user defined, whereas in reality the twist is set to produce a certain coefficient of lift stated in the Hamilton Standard propeller efficiency chart; this is something else that must be accounted for in the future.

I considered having this function calculate all performance parameters of the propeller, but the only performance estimation method that seemed feasible was the blade element method. This method is far less accurate than the Hamilton Standard propeller efficiency charts used to calculate performance in the Excel sheet. So I decided to stick with the standard method of propeller sizing using the propeller charts and just let my program calculate the propeller's shape.

MATLAB Project: Fuselage Designer

This project builds off my previous MATLAB project for designing and making wings in CAD. I have added basic fuselage plotting capabilities. The user simply defines the maximum diameter and fineness ratios to determine the fuselage length. Then, 11 cross sections are defined by their widths and heights. The shapes of the cross sections are assumed to be ellipses. The tail angle can also be changed. Wing twist has also been added; root and chord angles can now be set.

10/14/15 - Added 3 additional plots: fuselage side view, top view, and max diameter section view. The program can now display seating arrangements, galley, and lavatory locations.

MATLAB Project: Wing Designer

Introduction

This semester I am taking an aircraft design and performance class. The term project is to complete a conceptual aircraft design - each group will be designing a different type of aircraft. Our group is designing an MSA, or Maritime Surveillance Aircraft. The purpose of this aircraft is to loiter for long periods of time at low altitudes to observe/monitor maritime vessels, act as an airborne control center for nearby aircraft, and even deliver payloads (sonobuoys) and ordnance (torpedoes, air-surface missiles). Our professor provided us with Excel spreadsheets that have many of the calculations programmed into them; our goal is to optimize the parameters to meet the requirements. We also need to produce a 3-D model of our design. This is where the Excel sheets lack in ability. They provide very rudimentary 3-views of the aircraft. I decided to use MATLAB to take the results from the Excel spreadsheet and produce coordinates for a wireframe model of the airplane, which could be loaded into CAD software and turned into a 3-D model.

Currently, my MATLAB program can only produce the wireframe of a wing (or any similar aerodynamic surface). I am actively working on expanding it to create fuselage cross sections which will be used to create a 3-D model.

Design

I adapted this program for one I previously made for an aerodynamics class. The inputs were reversed - for that class, the area needed to be calculated for a given wingspan, whereas in the design scenario the wingspan is determined by the area and the aspect ratio, so the inputs needed to be changed. I also added the capability to sweep the wing. I also added the a section on the planform view to show the MAC - this is an important thing to visualize. The 'Export' button creates .txt files with the tip and root airfoil coordinates. These can be loaded into SolidWorks or any other CAD program as a curve, and the tip and root curves can be lofted together into a solid wing. Then the wing is simply mirrored about the root to create the other half and complete the wing.

Capabilities

Plot any 4-digit or 5-digit airfoil (uses my airfoil generator function). Create basic trapezoidal aerodynamic surfaces with airfoil cross sections. Wing twist or washout, and angle of incidence (not visible in GUI yet). Parameters include NACA airfoil, wing reference area, aspect ratio, taper ratio, and LE sweep. Plots MAC and spanwise location of MAC. Export coordinates of root and tip airfoils to create a 3-D model in CAD software.

Improvements

The current method in which the wing is swept is inaccurate, as it 'drags' the tip rearwards (or forwards) to achieve the required leading edge sweep. However the wing should really be rotated such that the airfoils are no longer parallel to the airstream; this is what makes a swept wing effective. Rotating is difficult though, because then you have to account for the fact that tip and the root will be at the incorrect angle, and you have to adjust for that. This is okay to make a model for viewing/aesthetics, but I should look into updating this in the future.  I should also plot points on the quarter chord MAC as this is another important location. I will continue working on this GUI to add fuselage plotting capability. Also the wing washout/twist/angle of incidence parameters can only be accessed from within the code; I need to make boxes on the interface to change these parameters.

Bike Brake Light: Part 1

I've been thinking a lot about developing a brake light for a bicycle. The need for such a device has always been obvious to me, but for those of you who may think otherwise, let me explain. Cyclists communicate with drivers and other road users primarily using hand signals. So if you are stopping, you have to let go with one hand and signal. However, if you are doing an emergency stop, it is both difficult and unsafe to signal - both hands need to be on the handlebars to control the bike during an emergency stop. Unfortunately, that's also the most important time when those behind you need to know you're stopping. The situation is essentially a catch-22: if you need to stop quickly, then you should signal to those behind you; but if you signal to those behind you, you won't be able to stop quickly.

In my mind, a brake light is the most effective way for cyclists to signal to other road users. But this isn't a new idea, and this certainly won't be the first to come to fruition. So why don't we see any bikes with brake lights now? From the bike lights I have seen online, there seem to be a few problems with current bike brake lights:

1. Can't properly sense braking
   This mainly applies to those brake lights that use accelerometers to detect the braking. Accelerometers tend to misinterpret bumps and other vibrations as brake applications, causing erroneous lights.

2. Incompatible with certain types of bikes
   Other brake lights use a separate mechanical switch that connects to the caliper or the cable. These may not fit all bikes. Also, they are susceptible to all the wires and the wear and tear of a separate mechanical switch.

3. Not bright enough
   Some of the bike brake lights have only 1-2 small, low power LEDs. What is the use of a brake light if no one can see it?

4. Concern that other users won't understand the signal
   This is the only issue that cannot be solved directly with the device. Perhaps some experiments can be done to test brake lights on unsuspecting motorists/cyclists and see if they understand what the signal means in time to brake. This could end badly...

I will attempt to create a bicycle brake light that solves these problems. Right now I am leaning towards an improved accelerometer sensing brake, that may incorporate another sensor to improve the accuracy of identifying braking periods. But I will also investigate other methods for activating the brake light. Who knows; maybe I'll find some elegant and unobtrusive way to mount a mechanical switch to trigger the brake.

Wind Turbine Analysis

One of my tasks as an engineering education developer at BU is to beef up the content of some activities with some higher level concepts. Recently I've been working on an activity where students get to design, build, and test their own wind turbines. Right now the activity works great with middle school students, but we want to improve the activity and make it more challenging so that we can bring it to high schools as well. The activity uses store bought wind turbine kits with a variety of blade types. Students can choose the material of the blades, the size of the blades, how many blades, and how to angle the blades. Then, once they've built their turbine, it's placed in front of a box fan and connected to a volt meter to measure the power. After their first design, students are allowed to make changes and test a second time before the teacher gathers everyone for a recap. 

Our goal is to enable students to use data obtained from their first test to quantitatively evaluate and improve the performance of their design. This requires some type of quantitative analysis of the wind turbine. So I began doing some math. I just finished a course in aerodynamics, where we learned all about airfoils and wings, so I felt I had a good handle on the concepts at hand. After all, a wind turbine is just a bunch of rotating wings, right?

Well regardless, that's how I modeled it. But unlike regular airplane wings, rotating wings (aka blades) don't all feel the same wind. The ends of the blades travel much faster than the inward portions, meaning the airspeed for that section of blade is faster. So the normal approach doesn't work in this case, because the wind is quite different everywhere across the wing. 

This image shows how much the actual speed of the blade varies with distance from the hub. Image Credit: http://www.cfinotebook.net/notebook/operation-of-aircraft-systems/propeller.php

So what can be done to solve the problem? Well when engineers come across a problem like this, they usually try to reduce it to something they already know how to solve. To give an example of how this is done, imagine taking a thin slice of the blade. Because it is so thin, the wind speed on one end is almost the same as the wind speed on the other end. Because the wind speed is *essentially* the same all across this tiny wing, we can use our original method on this tiny wing and get a good approximation. And it turns out if you add up an infinitely large number of infinitely thin blades, you can actually end up with a complete, finite blade; and no error! This technique of adding radial sections of the blade is called the Blade Element Method (BEM). 

Here is a picture showing the 'slice' of the blade. Image Credit: http://fessrg.ucsd.edu/Research/Wind/

BEM seems to be pretty widely used for getting preliminary performance estimates when designing a new propeller, helicopter rotor, wind turbine, or really anything else that has rotating wings. However there are limitations. The most significant limitation is that BEM cannot account for any radial flow - that is, if there is air moving along the blade from one tiny wing to the next. When engineers are satisfied with results from preliminary estimates such as BEM, they may move on to more accurate and sophisticated methods like a numerical simulation. But for my purpose, I think BEM is just fine. 

MATLAB Project: Boids, AKA Artificial Swarm Intelligence Simulator

If you've ever seen a flock of starlings flying in seemingly effortless coordination, or a school of fish avoiding some hungry sharks, you know what swarm intelligence is. The mesmerizing patterns make it appear like the flock or school is one (or several) cohesive unit(s) being guided - but it's not. The amazing thing about swarms like these is that there is no 'leader'. These patterns arise naturally as a result of a few simple rules that each swarm member follows. For example, each member in the school of fish wants to get into the center of all the other fish, to avoid the predators. In the flock of starlings, each bird has this centering tendency, but also must maintain some separation from other birds to avoid crashing. The swarm members also tend to travel in the same direction/speed as the other swarm members. For example, if they see one member turn, they'll turn too. 

These are the fundamental rules that govern flocking/schooling behavior in animals. Using MATLAB, I made a simulation of this flocking behavior based on Craig Reynolds' original program, using the three aforementioned rules. In the code, each rule has a weighting term which indicates how important the rule is to the boids. By changing the weights, different types of swarms can be modeled. Fish, for example, tend to stay much closer together than birds. So the weighting factor for the cohesion rule would be greater. Insects, on the other hand, don't always tend towards a center or even in the same direction, so those weighting factors would be very low for insects . This yields much more random motion, as one might expect. 

Many other modifications can be made to this simple code. For example, in this version, each boid sees every other boid. But in reality, birds and fish obstruct each other, and so the perceived size of the swarm by each member would be different depending on the location. By defining a radius around each boid that constitutes the visual range of the boid, one can more accurately model the swarming behavior. Additionally, this reduces the number of calculations drastically, and thus increases the speed and number of boids the simulation can handle. For example, my simulation can only handle about 50 to 100 boids before MATLAB runs very slowly. 

Check out the video below to see what my boids look like! For more information about the actual boids programming, click here.

Update 4/22/15: Added mouse tracking capabilities. Boids now follow the mouse pointer! Apologies for the choppy video; it looks like this took up a good chunk of my memory.

MATLAB Project: Accelerometer Position Transducer GUI

For my Instrumentation class, we were tasked with determining the position of a mass on a mechanical oscillator using a transducer. We chose the accelerometer, which is the most difficult transducer to use compared to the others because it has a 2nd order response. Thus, a lot of signal conditioning steps need to be applied to the output of the transducer to find the actual displacement.

Originally, each signal conditioning step was its own MATLAB script. But because the scripts all had different authors, it was difficult for any one of us to go from start to finish with a set of raw data. My solution to this problem was to create a user interface that would allow us to quickly and easily analyze sets of data. The data acquisition would remain its own script and the raw data was saved as a MATLAB data file. The filename is then entered into the GUI and the data is loaded. The static sensitivity of the accelerometer (obtained via calibration) can be entered into the box, but the value from our calibration is already set as the default. The 'Analyze' button does several calculations and makes a few different plots.

The first plot made is just the raw data. The second plot is the magnitude spectrum of the data, so the frequency of our signal and of any noise can be identified. Then the data goes through a bandpass filter to remove the high frequency noise and the DC offset. This filtered voltage as well as its FFT are then plotted. Finally, the signal goes through a double numerical integration to convert the acceleration values into displacement. Because of the cumulative integration technique used, a high pass filter is needed in between integration steps to remove the offset.

Overall I'm quite pleased with how it turned out. I may add more functionality to achieve more of the project's deliverables, but for now this will do.

EDIT: Final Project Report

MATLAB Mini Project: Standing Wave Generator

One of my responsibilities as a teaching assistant at BU Academy was to cover any classes the teacher (Mr. Gary Garber) could not make. This week he is traveling with the BU Academy FIRST Robotics team to the FIRST competitions and I'm covering some of his classes. 

Right now, the class is just starting standing waves. It can be tricky to visualize how the waves actually reflect and interfere with each other. If you're using a spring or a rope to demonstrate this effect, damping is often an issue and other parameters can be difficult to control. If you're using a simulation, the waves usually travel too quickly and it can be difficult to see what's going on. I decided to write a quick MATLAB script to help my students visualize how standing waves form. 

The script basically plots several cycles of a sine wave as it travels down a 'string'. Both the input and the string's response (what we actually see the string doing) are plotted on top of each other so that they can be compared. I took some screencasts and some screenshots to better illustrate the process. It's important to note that this simulation doesn't model resonance or harmonics; it simply reflects the incoming waveform off the wall and adds it to the rest of the wave form. 

This video shows the typical standing wave we are used to seeing. The nodal points can clearly be seen. I took a few other videos showing different inputs, but they don't all fit here. Those videos have been left as an exercise for the reader.

Download the MATLAB file here.