Introduction: Data Generated Surfboards

This is taken from my senior thesis in Industrial Design from about a year ago so sorry if theres some holes in it my memory might be a little off. It is an experimental project and there are so many things that could have been done differently, don't hesitate to let me know.

This project is on a system which gathers data to run a surfboard-building program. A device which logs readings from force sensors as you surf and applying that data in a way which optimizes the shape of your surfboard through generative modeling.

What makes this project work is that the surfboard is an interesting object where the force applying to the top of the object has an equal and opposite reaction to the bottom. Meaning if you press more or less with your toes or heel when you turn your surfboard should dictate where your surfboard needs to be shaped differently.

SURFBOARD DESIGN

I am going to assume that not everyone is an expert in contemporary surfboard design and I can't call myself one either, though here is my condensed explanation. Surfboards are vehicles for moving water through the fins, it does this through channeling water through the bottom concave and overall board outline. The surfboard can be exaggerated through asymmetrical shapes where you are creating a surfboard which identifies toe / heel weight distribution and attempts to capitalize on that. Through identifying where the surfer is applying the most pressure to turn their surfboard we can optimize an asymmetrical shape for the individual surfer.

WHO IS THIS FOR

This is a project which caterers to an intermediate to advanced surfer, someone who might be getting their second or third surfboard. At this stage you will have started to develop a style which dictates how your surfboard should function under your feet.

RESOURCES & SKILLS

The data is logged using an Arduino mini and parsed with excel. For the modeling of the surfboard you will need to have a copy of Rhinocerous 3D with Grasshopper installed on it. To actually produce the surfboard you will need to have access to a CNC large enough to mill a surfboard.

Step 1: The Sensor Pad

THE PAD

The pad is essentially a waterproof bag that protects the network of sensors while allowing you to access the arduino and sd card after you surf.

The bag is constructed of pond liner which is adhered using PVC glue.

// Materials //

+ pond liner http://www.homedepot.com/p/Total-Pond-7-ft-x-10-ft...

+ pvc glue http://www.homedepot.com/p/Weld-On-PVC-717-16-oz-H...

+ FPT Cap http://www.homedepot.com/p/Charlotte-Pipe-2-in-PVC...

+ Male Adaptor http://www.homedepot.com/p/Charlotte-Pipe-2-in-PVC...

+ VHB Tape https://www.uline.com/Product/Detail/S-10113/3M-VH...

+ 3mm styrene

+ Double Sided film tape https://www.uline.com/Product/Detail/S-17123/Doubl...

// Tools //

+Vinyl Cutter http://www.ebay.com/itm/like/281910397159?lpid=82&... or X-Acto knife

+ Soldering Iron

+ Ruler

THE SENSOR

+ Force Sensor Resistor (11) https://www.sparkfun.com/products/9375

+ 10k ohm Resistor (11) https://www.sparkfun.com/products/8374

+ Stranded wire

+ Arduino mini https://www.sparkfun.com/products/13614?gclid=CLa5...

+ Arduino Datalogging Shield https://www.adafruit.com/products/1141?gclid=CIDwi...

+ Battery http://www.mouser.com/ProductDetail/Adafruit/258/?...

Step 2: The Test Board

// Intro //

To properly generate a new surfboard you have to start with a demo model. This demo is re-created in the grasshopper definition and is the base for where the shape is generated from. For this reason your going to have to make a test model which you can either hand shape if your good enough or get CNCd. I included the AKU shaper file. The other option is to use a 5'8 Hayden Shapes hypto-krypto http://www.haydenshapes.com/pages/hypto-krypto which is pretty similar to the base model.

// Details //

+ Blank - EPS ( It floats slightly better than Polyurethane, and is a little lighter. The pad is pretty heavy)

+ Resin - Epoxy ( Its a little less likely to ding and also its springiness gives the sensors a better reading you also have to use Epoxy when fiberglassing a EPS blank)

+ Fiberglass - 4x6 ( This is a heavier glass job than a standard surfboard, its important for the board not to get too many dings, its already pretty heavy with the pad and since the board is a little hefty it can still float you pretty well with all this glass)

Step 3: Cutting the Pad

// Intro //

The pad is constructed from pond liner. I used A vinyl cutter with a cutting board under it to cut out all the pieces but I would think that printing out the pattern then cutting it out with an X-Acto knife would work.

// Steps //

1. Each of these cuts are going to need to be done for both sides like in the illustration

2. Cut 1, 2 & 3 are going to be used for the inside of the sensor pad. These pieces primary function are to keep the sensors in the right place and organize the wires.

3. piece 4 & 5 make up the bag that all the sensors will go into

4. I also cut out styrene pieces that go over the enclosures, the theory behind this is to broaden the through of the sensors by increasing the surface.

Step 4: Wiring the Pad

// Intro //

The network which makes up this project is wired to an arduino mini with an data logging shield. It can be made more or less complicated depending on how exact you want your data set to be. I settled for 11 pins taking two measurements from the center front and one from the edges. This allows you to identify where the pressure is being applied, though broad, is enough to give the program a good idea of how the surfboard should be generated.

// Resources //

https://learn.adafruit.com/adafruit-micro-sd-break...

// Steps //

1. Follow the schematic and wire each of the sensors, I used stackable headers https://www.sparkfun.com/products/11417 to solder each of the sensors, I'm not the best at soldering and this is a safe way to prevent melting your sensors.

2. I also used a bread board to organize my board, resistors and battery Its not totally necessary but it was nice to have it in a nice package

3. I used double sided tape to adhere all of the pad parts https://www.uline.com/Product/Detail/S-17123/Doubl...

its not totally necessary to use PVC glue though you could

Step 5: Glueing the Pad

// Intro //

I love pond liner, it is some really cool stuff, I had never even heard about it before doing this project but through some research settled on this as being a great material for building the pad. Pond liner is a PVC coated nylon which means you can use PVC pipe glue to weld it together creating a fully waterproof enclosure. Its also great because then you can use it to weld PVC pipes to it adding access points to the Arduino.

// Steps //

1. To make the composite lay all the pieces on the pad bottom piece

2. You can adhere all the sensor pieces using either double sided tape or PVC glue

3. Use the PVC fittings to create the access point to the Arduino on the top pad piece.

+ Theres a fine line when applying the pvc glue too much makes it bubble up and brittle though too little makes the bond weak. You kinda just have to experiment with some pieces and get a understanding of how it works

3. Once all of the pieces are dry adhere the top and bottom of the pad, you pretty much have one chance to do this so be patient, I did it in sections and made two glue lines to make sure that it would not leak.

+ The pad I built lasted two sessions before it started to break down, salt water is pretty brutal.

4. To adhere the pad to the surfboard use VHB tape

+ Be sure to wipe down the deck with paint thinner and be sure its super clean before laying down the pad

+ VHB tape is really strong, I didn't have any problems with the pad falling off

Step 6: Arduino Data Logging Program

// Intro //

The Arduino program logs data from the sensor network to an SD card. Included are some resources on formatting and trouble shooting SD cards. They Can be a bit finicky. The code is taken from https://www.arduino.cc/en/Tutorial/Datalogger and modified to include all the sensor readings.

// Resources //

https://learn.adafruit.com/adafruit-micro-sd-break...

// Code //

/*
SD card datalogger

This example shows how to log data from three analog sensors
to an SD card using the SD library.

The circuit:
* analog sensors on analog ins 0, 1, and 2
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)

created 24 Nov 2010
modified 9 Apr 2012
by Tom Igoe

This example code is in the public domain.

*/

#include <SPI.h>
#include <SD.h>

const int chipSelect = 4;

void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}


Serial.print("Initializing SD card...");

// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
// don't do anything more:
return;
}
Serial.println("card initialized.");
}

void loop() {
// make a string for assembling the data to log:
String dataString = "";

// read three sensors and append to the string:
for (int analogPin = 0; analogPin = 1; analogPin = 2;analogPin = 3; analogPin = 4; analogPin = 5; analogPin = 6; analogPin = 7; analogPin < 3; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2) {
dataString += ",";
}
}

// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
File dataFile = SD.open("datalog.txt", FILE_WRITE);

// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
}

Step 7: Collecting the Data

// Intro //

Now its time to try out the pad. Plug in the battery and insert the SD card. Its a good idea to test the program to make sure its logging the data properly before going out. Be careful when tightening the PVC cap so that you don't rip the pad, the threads are pretty hefty though its also a good idea to dust off the threading so that its super water tight

Its kind of a crazy thing surfing with this pad, the ocean is not always the nicest and the pad is a pretty clunky object. I gathered data using the pad two times and after that I was afraid that the pad would not last another. You should be pretty confident in the water and take it out on pretty tame days so that it doesn't get ripped off by big waves or you get yourself in a situation with a heavier than normal surfboard.

Step 8: Parcing the Data

// Intro //

When you finish collecting the data insert your SD card into you computer and you should have a folder containing a very long log of numbers. Since logging works by continuously running a string of contentious readings your going to have to copy the log into excel or google sheets to organize each of the sensor sets. Your going to want to take the average reading of each sensor to get it ready to insert into the grasshopper definition.

Its pretty easy to identify when you were applying pressure because you get drastically different readings than when you were sitting on your board. It becomes pretty spastic for a while then goes back to being consistent. The times of chaos is what you want... just delete the rest.

Step 9: Generating the Custom Surfboard

// Intro //

For this step your going to need to be somewhat proficient in Rhinocerous and grasshopper its not too advanced by any means though. In the grasshopper definition your going to notice that there are a bunch of nodes attached to various points, what your going to have to do is replace each of the nodes with the appropriate sensor readings. After gathering the data and parsing it in excel you should be be sure to keep track of where each of the readings came from so that you can adjust the grasshopper model to appropriately generate the optimal shape.

// Steps //

1. Open grasshopper and load the generative surfboard def

2. Insert the readings from the data log, I used the mediums from each readings.

3. Bake the model in grasshopper

+ your going to have a framework of the surfboard with just vectors

4. SWEEP2 using rails along the center and outside curves

+ This takes a bit of time and patience you may also need to blend surfaces to get it all watertight

Step 10: Milling the Surfboard

The final step is Milling the Surfboard. I used a two styrofoam blocks that I bought from home depot http://www.homedepot.com/p/2-in-x-4-ft-x-8-ft-R-8-... and spray adhesived them together so that it was thick enough to accommodate the rocker and board thickness. I used a Multicam 3000 using RhinoCAM. I am no CNC expert and had a lot of help in this step so I really can't offer any advice other than get someone to do this step for you ;)

Step 11: Final Thoughts

This project took me about a year and I finished it almost a year ago. I showed it at both the CCA industrial design senior show and Maker Faire. I am put it on here now because it took me that much time to actually look at it again... I was so sick of looking at this stuff. I hope you appreciate it, I think this type of research and work might be useful in other projects, if anyone actually attempts to do this Instructable please let me know its kind of a crazy thing and it would be great to see other peoples take on it. I think that there is a wealth of data that can be captured and used in creating products in a new way. I think were coming into a new age of customization and things that can be bespoke this type of rapid prototyping might be coming into rapid personal manufacturing.

I am happy to answer any questions regarding the process, theories, any of the programs or surfboard design in general.

Comments

About This Instructable

1,241views

22favorites

License:

More by rob.renn.9:Data generated surfboardsLight Therapy goggles Make a no weld metal hanging lantern
Add instructable to: