Process Final Project

Final Project

Originally, my plan for my final project was to make a wearable technology device that would regulate body temperature. Essentially, my plan was to create a leotard that could manually warm the wearer up before class and then automatically cool them down during class. My original prototype was a circuit where a change in temperature resulted in different LED’s lighting up based on how great the change in temperature was from the baseline. Moving forward with the mechanical process, however, proved to be quite difficult. From substantial research regarding textiles and wearable technology, I discovered that this project did not seem very feasabile. In my research, I stumbled upon researchers at the University of Maryland who developed a cloth coated in nanotubes that effectively could regulate body temperature. How this works is that when the wearer warms up, the fibers in the cloth tighten, allowing for bigger gaps in the cloth, and thus more ventalation. When the wearer cooled down, the cloth expanded to allow for greater insulation.

For a more detailed description of this initial protype, plans, and process click here.

I decided to move on to a different final project topic. My idea now is to create five frets of a guitar with LED’s that will light up when a finger touches the fret that the LED is on. My idea is to use copper tape to create this circuit. I think this can be used as a pratice instrument on-the-go. I also hope to add in a component that will allow the note of the string to play when pressed. My initial ideas are to implement this with a buzzer.

Lecture - 7/18

Today in lecture, we learned about capacitors. A capacitor consits of two plates that conduct and then an insulated material in between. The capacitance increases with an increase in area of the plates or a decrease in the distance between the plates. Next, using just one copper plate, we created a touch sensor. To create this, we put a resistor (1-10 Mega-Ohm’s) into the digital 5 and 7 pin and then the end of the copper plate into digital pin 5. At first I had trouble fitting both the resistor and the wire attached to the copper plate into the same pin, but then I found out that it is much easier if you just twist the resistor around the part of the wire that is stripped. Once this set-up is complete, you can copy the arduino code for this from here. Also make sure to download the capacitance library in arduino or the program will not run. For sketches and a fully fleshed out explanation and documentation of this process click here.
This was a particularly interesting assigment in lecture because it related quite directly to my final project. As mentioned above, I was planning on using copper tape that would complete the circuit to the LED once pressed by a finger. This was a great way to get some exposure into this aspect of my final project. Prior to this, I created a simple circuit with four LED’s solder to copper tape in parallel with jumper cables attached to the anode end and one jumper cable connected to the cathode of all four LED’s. This was a very initial prototype, but it was helpful to learn about and pratice soldering on copper tape as well as have an initial vision for my project. (The micro arduino can be used to power this circuit).

Next, I moved on to designing how the electronics would fit in fusion. My plan was to laser cut the neck with specially designed compartments for electronics, such as the pro micro, LED on copper tape, resistor, and wires. I used an add-on called Guitar Engine which can be downloaded here to sketch the electronics on. I originally chose to go with this add-on because I found it very hard to model a guitar as not only are there many complex pieces, but it is not very uniform as the neck widens slightly and every fret is smaller than the previous one. This is what the guitar neck from the add-on looks like in fusion.

I took some measurements of the pro micro arduino board and then decided how much space I wanted for the LED’s. After changing the measurements around, I settled on this design as the compartment for four of the LEDs.

Then, using the Guitar Engine add-on, I wanted to add these skecthes for the electronics onto the back of the neck to see how it would look spaced. This was quite difficult as the guitar engine add-on proved to be trying to work with. Although it was a great starting off point, it ended up being very difficult to manipulate the pieces how I wanted them. For instance, I was unable to copy, paste, or isolate certain sections as well as make sketches on top of the guitar.

After talking with Nathan, we concluded that it would not be feasible or realistic to design the entire neck for many reasons. First, I could not make a functional neck as there is nearly a whole science about information about necks mainting a certain temperature due to humidity or outside tmperatures. Also, my current design required a seperate pro micro arduino for each LED (4-6 depending on how many LEDs I chose). Latsly, it just made more sense to devlop a pratice tool that consisted of about five frets.

My next step was to work in fusion to design this guitar neck with five frets. I decided to import a photo from the internet as a canvas and trace around that to create the five frets of the neck. I also added a hole on each fret for the LED. This is the guitar that I used and this is how it looked in fusion when I traced around it using the line tool, primarily.

I then used this sketch and exported it to the laser cutter. In order to make sure that the frets did not end up as distict pieces, I highlet all of the fret lines (the four ones in the middle) and made them a different color. I then chose for the power to be a maximum of 1% on all of these lines so that the laser cutter would just score across this part rather than actually cutting through the material (the setting used for the other cuts was 60%).

You can also Download my DXF file here
It took quite a few trys to get this to fit the strip of LED's, but eventually after some measuring and trial and error, it worked! Next, my plan is to implement the touch component and the electronics. My vision is that this could be a pratice tool for people who want to play guitar on the go.

After fidling around with the eletronics, I decided it would be best to use strip LEDs instead of the individual LED. My next step was to see if I could use a guitar string pressing against a copper wire to complete a circuit and ultimatley turn on an LED. I used the [touch sensor setup](https://roberthart56.github.io/SCFAB/SC_lab/Sensors/CapacitiveTouch/index.html) as a basis for this. I cut a piece of copper conductive tape and placed it at the bottom of one of the frets. I then soldered a wire to this. Next, I connected the LED to digital pin 13 and the ground. You can find the code I used for this below. As you can see, I added an averaging function to the touch sensor and LED code.

#include <CapacitiveSensor.h>
long int sum;
int N_samples = 50;

CapacitiveSensor Sensor = CapacitiveSensor(7, 5);

void setup() {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  sum = 0;
  for (int i = 0; i < N_samples; i++){
   long sampleValue = Sensor.capacitiveSensor(300);
   sum += sampleValue;
  }
  long sensorValue = sum/N_samples;
  Serial.println(sensorValue);
  delay(10);
  if (sensorValue > 900)
  { digitalWrite(LED_BUILTIN, HIGH);
  }
  else {
    digitalWrite(LED_BUILTIN, LOW);
  }
}

Here is a video of my circuit working well.


Since this was successful, I moved on to working on my cardboard prototype. I cut copper tape and put it right above where the fret would go. I extended the tape so that it went around the back of the "neck" so that I could solder wires to that part. I then soldered a wire to each the copper for each LED. On the end of each wire I also soldered a 1-Mega Ohm resistor. Essentially, I extened the basic touch sensor setup for each strip LED light.

Then, I decided to work on the coding process of this. My goal was to get it so that when you press the copper strip on the bottom of one fret, that LED light will turn on. To begin, I used code from my work on the [output devices week](https://juliaodavis.github.io/PHYS-S12-Assigments/09/). What this did was it connectted all of the LEDs to one resistor and copper tape.

After this, I messed around with different ways to control the individual LEDs. Souyma suggested I use a 2D array since each capacitive sensor had two sets of corresponding pins. This is what my original code for this looked like.

#include <CapacitiveSensor.h>
#include <Adafruit_NeoPixel.h>

#define NUMPIXELS 5
Adafruit_NeoPixel pixels(5, 6, NEO_GRB + NEO_KHZ800);
{ 
  {2, 1}, {4, 3}, {7, 5}, {9, 8}, {11, 10} };

for (int i; i < n_list; i++) {
  int Pins[] = list[i];
  capacitiveSensor(pins[0], pins[1], pins[2], pins[3], pins[4]);
  pixels.setPixelColor(i);
}

After trying out different things with this code, we decided it would be best to just program the arduino with many differnet capacitive sensors. Before finalizing this (i.e., editing the capacitor numebers and changing the pixel colors), this is what the code looked like.

#include <CapacitiveSensor.h>
#include <Adafruit_NeoPixel.h>


#define NUMPIXELS 5
Adafruit_NeoPixel pixels(5, 6, NEO_GRB + NEO_KHZ800);

CapacitiveSensor Sensor1 = CapacitiveSensor(3, 2);
CapacitiveSensor Sensor2 = CapacitiveSensor(7, 5);
CapacitiveSensor Sensor3 = CapacitiveSensor(11, 10);
CapacitiveSensor Sensor4 = CapacitiveSensor(11, 10);
CapacitiveSensor Sensor5 = CapacitiveSensor(11, 10);


void setup() {
  Serial.begin(9600);
  pixels.begin();
}

void loop() {
  pixels.clear();
  long sensor1Value = Sensor1.capacitiveSensor(300);
  Serial.println(sensor1Value);
  long sensor2Value = Sensor2.capacitiveSensor(300);
  Serial.println(sensor2Value);
   long sensor3Value = Sensor3.capacitiveSensor(300);
  Serial.println(sensor3Value);
  long sensor4Value = Sensor4.capacitiveSensor(300);
  Serial.println(sensor4Value);
  long sensor5Value = Sensor5.capacitiveSensor(300);
  Serial.println(sensor5Value);
  delay(10);


  if (sensor1Value >= 300)
  { pixels.setPixelColor(1, pixels.Color(255, 255, 2));
    pixels.show();
    Serial.print(sensor1Value);
  }
    else {
      pixels.setPixelColor(1, pixels.Color(0, 0, 0));
    pixels.show();
    }
    if (sensor2Value >= 300)
  { pixels.setPixelColor(2, pixels.Color(255, 0, 0));
    pixels.show();
    Serial.print(sensor2Value);
  }
    else {
      pixels.setPixelColor(2, pixels.Color(0, 0, 0));
    pixels.show();
    }
    if (sensor3Value >= 300)
  { pixels.setPixelColor(3, pixels.Color(0, 0, 255));
    pixels.show();
    Serial.print(sensor3Value);
  }
    else {
      pixels.setPixelColor(3, pixels.Color(0, 0, 0));
    pixels.show();
    }
     if (sensor4Value >= 300)
  { pixels.setPixelColor(4, pixels.Color(0, 0, 255));
    pixels.show();
    Serial.print(sensor4Value);
  }
    else {
      pixels.setPixelColor(4, pixels.Color(0, 0, 0));
    pixels.show();
    }
     if (sensor5Value >= 300)
  { pixels.setPixelColor(5, pixels.Color(0, 0, 255));
    pixels.show();
    Serial.print(sensor5Value);
  }
    else {
      pixels.setPixelColor(5, pixels.Color(0, 0, 0));
    pixels.show();
    }
  delay(100);
}

We found that this was not working, however. The sensor was functioning as when we opened the serial monitor there was a clear distiction in the numbers outputed when nothing was touching the copper and the numbers outputed when someone was touching the monitor. Additionally, we tested the state of the sensor further using the serial monitor, and this was the result when the copper was not being held down, thus indicating that the issue was not in the connection of the sensor itself.

After swithcing out the capcitor ports, we concluded that there was actually an issue with one of the ports in the arduino board. The code still failed to work, however. I then determined that it was an issue with the LED strip. Lana generously gave me hers and I was able to upload the code! Due to the difference in spacing between the LED lights, however, I only programmed three LED lights, and I also did it off of the cardboard fretboad.

Next, I took an LED strip that did not work but was the right spacing and cut it so that the middle line read input (if it says output, then this will not work). I soldered new wires on and was able to upload the code with the three LED's onto it! The only issue was that the LEDs did not correspond to the correct frets. Lab was over, but I plan to work on editing the colors, implementing the other two LEDs, and getting it so that the correct LEDs correspond to the correct fret. Overall, I feel this was pretty successful though!

Next, I decided it was time to move onto making the actual freboard in wood. I uploaded my sketch to the laser cutter and cut it out of wood. You can download my DXF file here. I then cut copper strips and placed them across the bottom of each fret. I made them all realatively 8mm in width and the short length of the copper tape for length.

Then, I decided to us the Japanese pull saw to cut my breaboard for the final project. I knew that soldering the connections onto a protoboard would have been a cleaner and more organized alterantive, but given the constraints of my time and skill set, I felt this would be the better choice. In the end, I truly think it was as the cut breaboard was easily encourperated into my final project. I used a clamp for the breadboard and then rearranged it a couple of times before getting the final size that I wanted.

Next, the new LED strips that were ordered arrived and so I decided to solder them. When I soldered the strips the first time and then ran the strandest code (found below), the LED strip did not light up.

// 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    2

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

// 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
    }
  }
}

I found that I had cut the strip incorrectly. I needed to cut it so that there was only the 5V, Din, and ground rather than having the DOUT (along with the other 5V and ground) attached. I put a picture of when I correctly soldered it below.

Then, because the soldering connections were a little weak due to the minimal surface area avalible to be soldered, Nathan suggested that I use some heat shrink around the connections. This helped a lot! All you do is get the right size heat shrink and then use one of the heat guns to make the heat shrink fit snuggly around the wires.

I then tested this with the strandest code (found above) and it was successful! I then decided I would create a box for the electronics that would be inside of the guitar. I used the [MakerCase Wesbite](https://en.makercase.com) to do this. It was very simple. I just measured my dimensions, put them in, and then adjusted the settings accordingly. Also, you can download my dxf file here.

This is what my box looked like when implemented into the project (I used super glue to attach the breadboard and arduino to the bottom). I also decided to just laser cut it in cardboard since I had planned to have it inside the neck of the guitar.

Before adding the box to the project, I did a couple of things. First, as per suggestion of Andrei, I added heat shrink to all of the resistor wires. Not only did it make the arduino pin situation with the resistors a bit more organized, it also made my code more reliable because the metal resistors were not bumping into each other as much causing unwanted signals to be transferred. Again, I applied the same procedure for this as with the heat shrink on the bottom of the LED strip (found above).

I then cut a piece of acyrilic to attach the strip of LEDs on and then to eventually attach to the underside of the fret. You can download my very simple dxf file here. I made the dimesions the same as the dimensions of my fretboard.

Once this was all assembled, I soldered a new strip but with six LED's instead. I found that for some reason the LED closest to the soldering will not light up due to a capacitive touch, so I cut six instead.
Next, I uploaded my code and got a very successful outcome! The only issue was that the resistors were very fickle, largely in part due to the way that I have wired them. I tried to cut them, but they stopped working after I did that, and do to the time crunch, I decided to just stick with the way that I had it.

Also, in order to get this working project, I updated a couple areas of my code. First, I reversed the number that followed setPixel.color in the parathenses to switch the order of the LEDs as in my original prototype they were going in the reverse order. I also removed the pixel.show() function from after every if statment and just added one to the end (Nathan said that this was the correct way to do it). Finally, I added a ten millisecond delay in between each reading of the sensor. My finalized code can be found below.

#include <CapacitiveSensor.h>
#include <Adafruit_NeoPixel.h>


#define NUMPIXELS 5
Adafruit_NeoPixel pixels(6, 2, NEO_GRB + NEO_KHZ800);

CapacitiveSensor Sensor1 = CapacitiveSensor(12, 11);
CapacitiveSensor Sensor2 = CapacitiveSensor(10, 9);
CapacitiveSensor Sensor3 = CapacitiveSensor(8, 7);
CapacitiveSensor Sensor4 = CapacitiveSensor(6, 5);
CapacitiveSensor Sensor5 = CapacitiveSensor(4, 3);


void setup() {
  Serial.begin(9600);
  pixels.begin();
}

void loop() {
  pixels.clear();
  long sensor1Value = Sensor1.capacitiveSensor(300);
  Serial.println(sensor1Value);
  delay(10);
  long sensor2Value = Sensor2.capacitiveSensor(300);
  Serial.println(sensor2Value);
  delay(10);
  long sensor3Value = Sensor3.capacitiveSensor(300);
  Serial.println(sensor3Value);
  delay(10);
  long sensor4Value = Sensor4.capacitiveSensor(300);
  Serial.println(sensor4Value);
  delay(10);
  long sensor5Value = Sensor5.capacitiveSensor(300);
  Serial.println(sensor5Value);
  delay(10);


  if (sensor1Value >= 300)
  { pixels.setPixelColor(5, pixels.Color(255, 0, 0));

    Serial.print(sensor1Value);
  }
  else {
    pixels.setPixelColor(5, pixels.Color(0, 0, 0));

  }
  if (sensor2Value >= 300)
  { pixels.setPixelColor(4, pixels.Color(255, 69, 0));

    Serial.print(sensor2Value);
  }
  else {
    pixels.setPixelColor(4, pixels.Color(0, 0, 0));

  }
  if (sensor3Value >= 300)
  { pixels.setPixelColor(3, pixels.Color(255, 255, 0));

    Serial.print(sensor3Value);
  }
  else {
    pixels.setPixelColor(3, pixels.Color(0, 0, 0));

  }
  if (sensor4Value >= 300)
  { pixels.setPixelColor(2, pixels.Color(0, 255, 0));

    Serial.print(sensor4Value);
  }
  else {
    pixels.setPixelColor(2, pixels.Color(0, 0, 0));

  }
  if (sensor5Value >= 300)
  { pixels.setPixelColor(1, pixels.Color(0, 0, 255));

    Serial.print(sensor5Value);
  }
  else {
    pixels.setPixelColor(1, pixels.Color(0, 0, 0));

  }
  pixels.show();
  delay(100);
}

I then decided that I would use a 9V battery supply for my final project as I felt that that would be more compact and easier to add into the neck than a 5V USB power source. However, when I plugged the 9V in, I found that the sensors did not work very well at all. It often required me touching the part closest to the soldered wire to get a light to turn on. Rob thought it might have to do with the fact that my computer was plugged in to a charger so it was grounded. But when I tried without my computer plugged in, the code executed the way I wanted it to. Nathan and I used the bench power with 9V and it worked the way that I wanted to as well. Given that I was very short on time, I decided that I would just use my computer for the final project, but I am curious what this issue was with this battery. I also switched out the cable and battery three times, but again was presented with the same results. A video of what happened to my project when powered by the 9V battery is shown below.

Next, I decided it was time to move onto the back of the neck. Originally, I was planning on using the laser cutter to score lines in cardboard and then folding that over the back of the neck. Nathan suggested that I actually use wood and cut a repeating pattern of diamonds out of it. I made the sketch imaged below in Fusion 360 and then Nathan added the middle part in Rhino. You can download my dxf here

I then exported this to the laser cutter.

There were two diamonds (by accident) so this ended up making the final product very flimsy, but workable!

We also did a few pratice cuts trying different settings of the speed and power to see which would cut the best. We settled on a speed of 15%.

This is what it looked like once I took it out of the laser cutter. I then pushed out all of the diamonds and used the laser cut box to get this final object for the back of the neck.

Next, I used wood glue and smeared it all along the side of the fretboard and then attached the sides of the neck to it. Because the back of the neck was quite fragile, I decided to not use a regular clamp. When I did this, it began to snap the pieces of it. Instead, I used rubber bands.

Because the back of the neck was quite fragile, I decided to not use a regular clamp. When I did this, it began to snap the pieces of it. Instead, I used rubber bands.

I then plugged my computer into the board, and it worked!