Skip to content

Dancing Hip-Hop Shoes

Introduction

Along this documentation you will find first a description justifying why this project is developed. It explains the importance of shoes for Hip Hop dancers and what they are looking for their performances. After this there is a research of the state of art about similar projects that have been created. Also some inspiration of what can be done in shape, color, function materials and morphology. The reading continuous with the experimentation process and insights divided in the shoes making such the designing, 3D printing and the electronic circuit making. Finally is shown the steps of how the final prototype was made and the files to download to be made by anyone who wants to go into 3D printed and interactive shoes.

Why Hip-Hop Shoes

From the very beginning of the human history we can find shoes as an important element. The first protective garment for shoes data from 15.000 years ago. Since then they have been done using different materiales such fabric, straw, tree leaves, leather and also many purposes like protect the feet for hunting, as a symbolism of power, sports, war or beauty.

The shoes are used as a tool for the activities the human has done in life along years of evolution. Many different technologies have been developed to their production. Understanding the word "Technology" not us a latest gadget but by its real meaning which is:

"science of craft", from Greek τέχνη, techne, "art, skill, cunning of hand"; and -λογία, -logia[2]) is the collection of techniques, skills, methods, and processes used in the production of goods or services or in the accomplishment of objectives, such as scientific investigation. Technology can be the knowledge of techniques, processes, and the like, or it can be embedded in machines to allow for operation without detailed knowledge of their workings. Systems (e. g. machines) applying technology by taking an input, changing it according to the system's use, and then producing an outcome are referred to as technology systems or technological systems."

Technology is the creation of tools and the mix of them to create anything. In this order of ideas shoes are an innovation itself and their production have taken the making process to the invention of new machines, the use of different and new materials and create new designs to find the perfection of their performance. An example of this are Bill Bowerman who developed the Waffle sole using the Waffle machine of his wife adding rubber on it creating the Nike shoes for athletic runners and Adolph Dassler who started creating shoes using the few materials he found and without energy in his mother lavatory after the first world war with the mission of give athlets the best shoes ever done.

As says in the book Sneakers:

"... If we take in account the invention of sports shoes they are origin from Industrial Revolution and they are a product of revolutionary industrial, economic and cultural changes in the last ages"

But not everything is just traditional sports... subcultures take shoes and create another symbolism to them into their expressive lifestyle. We are talking about alternative sports like skateboarding and also music like punk rock, rap and hip hop. Here, shoes not only perform as comfort but a way of thinking. In the HIP HOP boom and lifestyle adopted in 1979 wear a pair of Adidas was the best way to be known as part of the movement. Graffiti artists, musicians and break-dancers started to adopt sport shoes in their garment as an expression of who they are.. free spirit, the voice of the opression and the expression of the life on the streets.

The HIP HOP culture is the result of the necessity to communicate, illustrate and show to the world how was like to live oppresive in the best possible way: ART. Combining music with DJ´s, singers as MC´s, dancers with breakdance and street artist with graffities. All this with the same rule: Freestyle.

All this has happened in the last years... What is happening now and how is going to be in the future?

Today, the society is interested in mixing art and technology as a system where different tools or machines are used by everybody in our everyday life. The reality is not many people know how it works but everyone enjoy the results and final products. Today, exists the possibility to produce anything through Digital Fabrication, the access of CNC machines, share knowledge by the Open Source Community all around the globe and Cowork enriching the creative process where each part receives benefits. The Waffle sole is an example of hacking machines to find different results, an impulse to use 3D printers to create final products and mix materials such fabric and filaments, to design using parametric software like Grasshoper and 3D scanning with traditional production processes.

Nowadays exists the chance to use new and accesible technology as an expression tool in the evolution of arts where the body isn´t the principal character in the show. Now it is an instrument. What I called: The performance in another level. I see the dancing performance finding new ways to amaze the spectator by provoking and generating different feelings and emotions through new human experiences changing the perception of the world.

Planning Grantt Diagram

For the realisation of this project this is the planning along the weeks to come.

State of Art Research

The research starts from the history of Sneakers shoes. Then the history of Hip-Hop, music, styles, dance styles, the usage of the feet and what they want to express. After this the investigation goes for designers, inspiration, soles, manufacturing processes, aliances. Finally shoes done with the latest digital fabrication technology and some basic 3D modelling using rhinoceros to 3D print over fabric.

Books first.

I subscribed myself to HIP HOP dance classes. I understood to have better movement of the body they use the front of the feet palm to move faster having control of every step. This means the front part of the outsole should be flat and also is possible to use sensors. An insight from the books is personalization. It is very important in the HIPHOP style to add a personal touch to their accesories like shoes. This idea can be expressed through the interaction with the shoes using different actuators. Dancers prefer medium thick soles .. not so heavy and not so wide because it can be difficult to move.

Another point of the requirements is the style. The final intention is to look like futuristic but some shoes that can be wore in todays streetstyle. For the esthetics may be used curved shapes playing with different thickness levels and clean lines.

Possible alliances

During the developing time we had the visit and experience with Chordata.cc which are creating a motion capture system that receives the data of the body movement creating different interfaces. His system can be a possible solution to the use of sensors and the way of read the information. Also a collaboration now that the feet for them are the most complicated elements to keep calibrated.

The shoes workshop Taller de Calzado Barcelona is another possible alliance to work with.

Prototyping technics

Finally different technics of how the This was the last I researched because I don't want to close my creativity in the same way of fabricate shoes. But it gives me security to know it is possible to create 3D printed shoes using convencional 3D printers. Not just powder with excelents result but also flexible filaments.

Experimentation and Insights

The starting point is the most difficult one when is the first time to create something. It is important to believe it can be done and not fall into frustration.. mistakes are the best way to learn. As I haven't done 3D printed shoes before I had no idea how to start. So I thought to start probably doing the same as normal shoes making: The mold. But this time with digital fabrication softwares.

3D Modeling

I am a big fan of Keep It Simple. So the first step was create the shoe pattern from a basic one and then add it complexity redefining the designs. I had a mold of just one piece from before so I used it. To export it to Rhinoceros I converted the illustrator file in an .png image and then imported in the programm using the command PictureFrame. Keep the canvas size of the illustrator file and use this numbers when placing the image. Then started to draw over it playing a little bit with the thickness of the material.

Also I was thinking in a way to stitch the 3D printed into textile to help the filament stay in position. So I draw holes into it.

Once the file was ready I made a first trial 3D printing over this fabric. I used a REPRAP 3D printer because it has a direct motor to use flexible filaments. I found the filaflex sticks pretty well in ¨hairy fabric¨ because it can get into the fibers. During the test I realized the calibration of the machine must be done again and better during the printing process, the reason is you can see when the extruder is not blocked by the textile and the distance between them is perfect to print with a little bit of pression from the extruder.

Trial 1. 3D printing over fabric from Ana Correa on Vimeo.

"Filaflex sticks well in hairy and porus fabric and because it can fill into the fibers"

After checking the results and I knew the printing over this fabric was a viable option I continued with the design process. You can see in the last picture I was using a LAST from another kind of shoes. It is very important to use the adecuate one otherwise the prototype isn't going to work.

THE SHOE DESIGN PROCESS

This is an advice I give to everyone who is coming into the MAKER WORLD. If you feel stuck or have no idea how to start something the way to flow is JUST DO whatever you think can work. Really can be anything as much as you start experiencing with materials, processes, parts and everything that will going to be involved in the project. Something full of knowledge will came up and there is this FAIL FAST concept that I enjoy so much. Once you know what can't be done then you know what CAN work.. after this anything is possible. In this case I really didnt know what kind of shoes I would be able to create... So I just started designing from basic shapes, nothing complicated but maybe reachable.

After choosing the design it comes the pattern making. If you don't have a proper LAST I recomend to use ready made SHOES as LAST. The traditional way to do the pattern is to wrap the last in tape and draw over it. There are tecnical issues to have in consideration before starting. Here is a video tutorial video I followed to do mine.

Don't forget to think about the pieces to assemble the shoe and the pieces that can fit the printer bed size.

When the pattern is ready in 2D plane it can be scanned and used in Rhinoceros to create the pieces to print. Export the image into Rhinoceros the same way as the first mold.

3D Printing

To learn how to print over fabric you can see my documentation of Computational Couture

The filament I decided to use is FILAFLEX 95A color Black from RECREUS. When I worked with it in past projects it was easy to use, doesn't need heated bed, is stable during the printing process, flexible but soft, and the mechanical properties work pretty fine for what I need in a material to perform well during the usage of the shoes.. You can buy it here or find more information about how to use it with different type of printers and which ones are the best to use it. There also exists the 82A appareantly for printeing clothes. Even do I need to try the Filaflex 70A which seems to be softer and made for insoles.

Remember the files may be exported in .stl format and as closed objects. Then the file is saved in the .gcode format using the software CURA. While I was printing I realized the thousands of possibilities the design can be. Now we can go far beyond conventional desings. With Digital fabrication the pattern designs are infinite.

Trial 2. 3D printing over fabric from Ana Correa on Vimeo.

When I started working with the printings it was important to understand how the thickness affects the performance. At the front of the pattern was too thick and too difficult to work with.. impossible to assemble. Knowing this I redesigned the proposal and used the software grasshopper.

Designing with Grasshopper

For me was a very interesting exploration using it. The different curve shapes that can be created using it is mind blowing. Just at the end.. cleaning the lines to extrude and make the solid object took me a lot of time. Probably is just a question of practice. But if you are new with this software as I am you need to understand this is going to take time.

For this I used the functions of Graph Mapper connected with Tween Two Curves and then Trim with Region which in my case the region where the shoes pattern curve. After baking the result I had to clean the lines and create areas to extrude. This extrutions are the shape of the final design.

Here are the final files of the design I did with Grasshopper. Even do is not the final one.

The printing results were too thin and didn't look nice for this experiment. But thanks to this I had to create a test of how the filament printed over the fabric and keep the samples with me all the time when I was going to design. This was key for the final shoe.

At this point it was very important to re-check the filament settings in the CURA software. After printing for a long time in a preset profile I realized this details weren't correct. Usually the packaging were the filament is from has written the right details. Then I created my own profile so I always knew the printing quality was going to be OK.

Trial 3. 3D printing over fabric from Ana Correa on Vimeo.

The result after this experiment is.. the upper part must be a balance between big areas of filament and different thicknesses. Finally I had enough knowledge to start making adjustments to reach the final design.

FINAL UPPER PART

The upper part of the shoe must give support to mantain the feet in shape and give comfort at the same time. I used one of the first designs that could have enough printed area around the foot and also the production process could be possible taking in count the machine bed size, assembly parts, assembly process. It is very important to remember the basic technic knowledge to design a shoe with the ergonomic parameters.

The design that gives structure to the shoes giving shape to the feet and also allows the assembly is this one. Here you can see the process from the idea to the shoe pattern and finally the 3D modeling.

Assembling the upper part

    1. Get the molds ready for the fabric. Cut the textiles after the 3D printing.

Copy and paste the url to get the .PDF file. https://drive.google.com/drive/folders/141KxJhusLG7YUSSL1nWLUeWsLtR_olLN?usp=sharing

  • Print the parts

Use the same settings I used in the Designing with Grasshopper. Here are the final files ready to print. The parts I did print over fabric were just the Toecap and the Heel. The side parts are printed without fabric because there is no need to waste more material.

3D printed shoes: Side Part from Ana Correa on Vimeo.

  • Cut the fabric and sew the toecap with the heel and place the side parts and make some stitches to keep it in place.

  • Cut the linning and sew it from the front part and fold it. Then knot the laces

Done!

THE SOLE

There are 3 different type of soles. INSOLE (the one the foot thouches directly) - MIDSOLE (the coushioning part) - OUTSOLE (the part that touches the ground).

At the beggining I wasn't sure which material to use between Filaflex or TPU. The TPU (Thermoplastic polyurethane) has been used for soles and shoes making a long ago. So I made a trial with both.

MIDSOLE.

The principal idea was to create something similar to the auxetic shape. It was super difficult with flexible filaments using a fused deposition modeling (FDM) process. For this is needed another technology like Adidas does. So, the second option was to create a pattern design with similar shape functionality. The principal aspect is coushioning and force absorption. For this I used grasshopper and 2 different designs with filaflex and TPU filaments.

The settings to print were the same. Just changed the INFILL for the sole is 80%. This means it consume a lot of material.

3D printed shoes: Midsole from Ana Correa on Vimeo.

The filaflex trial with the pattern worked pretty well. When you step on it you can feel the perfect coushining. The flexibility of the material mixed with the pattern design make it strong but soft at the same time. The TPU trial didn't work that well. The properties of the material are too strong to make the coushioning work. Also the pattern used in this trial didn't allow to push up and down. Another challenge was the way it must be printed. It couldn't be in horizontal way because of the geometry so I did it in a vertical way that worked pretty well. But now the complete shape can't be like a sole.. must be a blocked which means I had to give the sole shape by hand.

This is the final file to print in Filaflex.

This file is trial 2 for TPU. In case anyone find it usefull.

The design of the pattern is very important to make it work. {picture of the process in grasshopper}

3D printed shoes: Midsole from Ana Correa on Vimeo.

Then I gave shape by hand using the Insole line as reference.

INSOLE

This piece needs to unite the upper part with the rest of the soles. For this I thought in a stitch solution. So I included in the design of the Insole holes to be able to sew. I used as a reference the Last I had an also a pair of ready made soles to do an inverse engineering. I drew the line of the LAST and measured the highness the insole can go over the foot. With this parameters I started the 3D model.

The first print wasn't good because the 3D model object was not water tight. Remember to create open meshes and then unit them in one closed object. After I solved this the result was very good. I was afraid about how the holes were going to print but they came out pretty well. When I tried them into the LAST they fitted the size.

3D printed shoes: Insole from Ana Correa on Vimeo.

{Pic of the final result printed insole}

To print the left side the only thing needed is to reflect in the object in the CURA program.

OUTSOLE

It is important to understand the Outsole is the one who is going to receive the direct impact while we are walking. Thinking about this I designed it with a highness of 4mm minimum. I also wanted to play with the footprint the shoe will leave while walking. So I did the pattern using grasshopper and a plug-in called pufferfish and a command called NET ON SURFACE.

While working with this command I realized it doesn't work well in plane surfaces. As I wanted the pattern smaller at the front and bigger at the back I used an sphere to create the NET and then project the points in Z on the plane surface.

{Pictures of the whole process}

Sometimes there are a lot of curves and is not easy to extrude the lines to create a solid object. Probably the curves are not closed in some point and is difficult to find it in a pattern. In this case I did use the Software Illustrator and the tool pathfinder to close the curves to extrude and then export it to Rhino in a clean and effective line map ready to be converted in a 3D object.

{ pictures of how to do it - Do the illustrator and Pathfinder and MAKE 2D - Export to Rhino - Extrude - Do the .stl - Do the g.code (video) - Result }

The printing options are almost alwasy the same. The only difference is the INFILL changes to 30%. Also in Infill pattern I found better to use Lines option.

{Picture of the Final result}

ASSEMBLY OF THE SHOE

Assembling the sole

I decided to assemble first this part otherwise should be difficult to paste the fabric into the other part. The original idea is to create an interlocking system to assemble the shoe parts but this will be the second level of the project. The way to assemble it was with the traditional process of shoes making: Contact Cement. There is a concept to help surfaces glue better by augmenting the contact area. In the case of the soles the way to increase the area was creating thin channels along the surfaces.

// I don't have pictures on this part because I was using gloves and glue to be able of take pictures //

Even do, I highly recommend to ask an expert on this part. If the sole sticks a little wrong it won't be possible to fix it.

Here is a video of how to paste the sole. Start from the toecap, then the heel and then the middle.

Steps of: Assembling the upper part

  1. Put the upper part to the LAST and knot the laces very well.
  2. Add pins to keep it stable.
  3. Place the Last to the sole and mark the final line in the fabric. Apply contact cement and let it dry.
  4. Once is dried double sew the parts trough the holes of the sole.
  5. Once is finished try the shoe on and walk with it.
  6. If is needed you can add contact cement to the fabric to join it with the filaflex.

The shoes are done.

via GIPHY

MID Term Presentation

Click here to see the presentation

Electronics

As a reference I found this project ready in the market. It does almost the same what I want to reach. Tracks the movement to unify it with the performance and use lights as part of the outfit.

What I want to do is convert the movement into a digital part of the performance and express the language of the body.

For this I am using - Microcontroler ESP8266 Node MCU with WiFi connection - 9 Axis Absolute Orientation BNO055 from Adafruit - Microphone Electret Amplifier from Adafruit - Neopixels Ring from Adafruit - Switch - Lipo Battery 3.7 Volts and 400mA

The most important point in electronics was transfer the data wireless from the microcontroler to the visual pattern projected in Processing. I first tried with the Bluefruit from Adafruit and a Flora as the main microcontroller. But I found the ESP8266 has integrated the connection via WiFi through a communication I2C (Inter Integrated Circuit) and the Analog and Digital pins I needed for my circuit.

The connection I2C was created to communicate different devices including microcontrolers. The connection must follow a certain protocol and the pins programmed to this are Serial Clock Time (SCL) setting the time to share data sincronized between a Master (the one who sends the data) and a Slave (the one who receives the information) and the or Serial Data Line (SDA) being the signal where travel the information. Here you can find more details about it.

Understanding the components and making the circuit diagram.

The NODEMCU or ESP8266 microcontroller is a lot different from any other board I learnt to use. At the beginning was frustrating because the pins I was using weren't the correct and I thought they were right. Is easy to commit errors when you don't understand what's all it about. The right pins to connect to I2C are D1 (GPIO number 5) for SCL and D2 (GIPO number 4) for SDA.

The 9 axis Orientation is a sensor with a lot of reading options and also works with I2C protocol. In this case I was able to use the Orientation (Euler) and the Accelerometer (or the change in the acceleration) data. The most important is to understand which plane (X,Y or Z) is every number of the Euler (Orientation in a 360 degrees sphere) and the Acceleration.

I started connecting this 2 components .

   BNO055           NODEMCU

   SCL  -------->   D1
   SDA  -------->   D2
   3vo  -------->   3V3
   GND  -------->   GND

Now, Arduino programming. Here is the complete tutorial from Adafruit of the libraries for arduino to program the BNO055 sensor Here is the tutorial of how to install the NodeMCU boards

After installing I used the samples of both libraries to create the code.


include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>

/* This driver reads raw data from the BNO055

   Connections
   ===========
   Connect SCL to analog 5
   Connect SDA to analog 4
   Connect VDD to 3.3V DC
   Connect GROUND to common ground

   History
   =======
   2015/MAR/03  - First release (KTOWN)
*/

/* Set the delay between fresh samples */
#define BNO055_SAMPLERATE_DELAY_MS 100

Adafruit_BNO055 bno = Adafruit_BNO055();

/**************************************************************************/
/*
    Arduino setup function (automatically called at startup)
*/
/**************************************************************************/

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <OSCMessage.h>

char ssid[] = "Wifi Name";          // your network SSID (name)
char pass[] = "Wifi Password";                    // your network password

WiFiUDP Udp;                                // A UDP instance to let us send and receive packets over UDP
const IPAddress outIp(192,168,5,255);        // remote IP of your computer
const unsigned int outPort = 9999;          // remote port to receive OSC
const unsigned int localPort = 8888;  


void setup()
{
  Serial.begin(115200);
  Serial.println("Orientation Sensor Raw Data Test"); Serial.println("");

  /* Initialise the sensor */
  if(!bno.begin())
  {
    /* There was a problem detecting the BNO055 ... check your connections */
    Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }

  delay(2000);

  /* Display the current temperature */
  int8_t temp = bno.getTemp();
  Serial.print("Current Temperature: ");
  Serial.print(temp);
  Serial.println(" C");
  Serial.println("");

  bno.setExtCrystalUse(true);

  Serial.println("Calibration status values: 0=uncalibrated, 3=fully calibrated");

  // Connect to WiFi network
    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);
    WiFi.begin(ssid, pass);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("");

    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());

    Serial.println("Starting UDP");
    Udp.begin(localPort);
    Serial.print("Local port: ");
    Serial.println(Udp.localPort());

}

/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete (your own code
    should go here)
*/
/**************************************************************************/
void loop()
{
  // Possible vector values can be:
  // - VECTOR_ACCELEROMETER - m/s^2
  // - VECTOR_MAGNETOMETER  - uT
  // - VECTOR_GYROSCOPE     - rad/s
  // - VECTOR_EULER         - degrees
  // - VECTOR_LINEARACCEL   - m/s^2
  // - VECTOR_GRAVITY       - m/s^2

  imu::Vector<3> euler = bno.getVector(Adafruit_BNO055::VECTOR_EULER);

  imu::Vector<3> accel = bno.getVector(Adafruit_BNO055::VECTOR_ACCELEROMETER);

  /* Display the floating point data */
//  Serial.print("X: ");
//  Serial.print(euler.x());
//  Serial.print(" Y: ");
//  Serial.print(euler.y());
//  Serial.print(" Z: ");
//  Serial.print(euler.z());
//  Serial.print("\t\t");

Serial.print(euler.x());
Serial.print("\t");
Serial.print(euler.y());
Serial.print("\t");
Serial.print(euler.z());
Serial.print("\t");
Serial.print(accel.x()*10);
Serial.print("\t");
Serial.print(accel.y()*10);
Serial.print("\t");
Serial.println(accel.z()*10);

OSCMessage msg("/IMU");
    msg.add(euler.x());
    msg.add(euler.y());
    msg.add(euler.z());
    msg.add(accel.x()*10);
    msg.add(accel.y()*10);
    msg.add(accel.z()*10);
    Udp.beginPacket(outIp, outPort);
    msg.send(Udp);
    Udp.endPacket();
    msg.empty();
    //delay(500);

  /*
  // Quaternion data
  imu::Quaternion quat = bno.getQuat();
  Serial.print("qW: ");
  Serial.print(quat.w(), 4);
  Serial.print(" qX: ");
  Serial.print(quat.y(), 4);
  Serial.print(" qY: ");
  Serial.print(quat.x(), 4);
  Serial.print(" qZ: ");
  Serial.print(quat.z(), 4);
  Serial.print("\t\t");
  */

  /* Display calibration status for each sensor. */
//  uint8_t system, gyro, accel, mag = 0;
//  bno.getCalibration(&system, &gyro, &accel, &mag);
//  Serial.print("CALIBRATION: Sys=");
//  Serial.print(system, DEC);
//  Serial.print(" Gyro=");
//  Serial.print(gyro, DEC);
//  Serial.print(" Accel=");
//  Serial.print(accel, DEC);
//  Serial.print(" Mag=");
//  Serial.println(mag, DEC);

  delay(BNO055_SAMPLERATE_DELAY_MS);
}

The result in Serial Plotter is the graphic version of the change in data. Every value has a different color. For the Orientation the X was Red, Y was Green and Z was Purpule. For the Acceleration the line Grey with strong picks in every change.

Is working!!! But not all the time. In a certain point I couldn't be able to receive data. I had to delete the Arduino program and re install everything. Then it worked again.

Next step was the Microphone Electret and the Neopixels Ring. For this part I fellow this tutorial from Adafruit for the coding. The connection in this case for the Microphone is to the Analog pin which in the NodeMCU board is A0 and the Neopixel to a Digital PIN in this case D4 or GPIO2 as explained here.

     Microphone        NodeMCU
        OUT   ------>    A0
        VCC   ------>    3V3
        GND   ------>    GND

     Neopixel 
        IN    ------>    D4
        PWR   ------>    3V3
        GND   ------>    GND

It should look like this.

Once the Neopixel library is installed as says in the tutorial the complete code should include everything. This is the final code.

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>
#include <Adafruit_NeoPixel.h>


#define N_PIXELS  12  // Number of pixels in strand
#define MIC_PIN   A0  // Microphone is attached to this analog pin
#define LED_PIN   D4  // NeoPixel LED strand is connected to this pin
#define DC_OFFSET  0  // DC offset in mic signal - if unusure, leave 0
#define NOISE     50  // Noise/hum/interference in mic signal
#define SAMPLES   60  // Length of buffer for dynamic level adjustment
#define TOP       (N_PIXELS + 2) // Allow dot to go slightly off scale
#define PEAK_FALL 40  // Rate of peak falling dot

byte
  peak      = 0,      // Used for falling dot
  dotCount  = 0,      // Frame counter for delaying dot-falling speed
  volCount  = 0;      // Frame counter for storing past volume data
int
  vol[SAMPLES],       // Collection of prior volume samples
  lvl       = 10,      // Current "dampened" audio level
  minLvlAvg = 0,      // For dynamic adjustment of graph low & high
  maxLvlAvg = 512;
Adafruit_NeoPixel
  strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);



/* This driver reads raw data from the BNO055

   Connections
   ===========
   Connect SCL to analog 5
   Connect SDA to analog 4
   Connect VDD to 3.3V DC
   Connect GROUND to common ground

   History
   =======
   2015/MAR/03  - First release (KTOWN)
*/

/* Set the delay between fresh samples */
#define BNO055_SAMPLERATE_DELAY_MS 100

Adafruit_BNO055 bno = Adafruit_BNO055();

/**************************************************************************/
/*
    Arduino setup function (automatically called at startup)
*/
/**************************************************************************/

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <OSCMessage.h>

char ssid[] = "Wifi name";          // your network SSID (name)
char pass[] = "Wifi password";                    // your network password

WiFiUDP Udp;                                // A UDP instance to let us send and receive packets over UDP
const IPAddress outIp(192,168,5,255);        // remote IP of your computer
const unsigned int outPort = 9999;          // remote port to receive OSC
const unsigned int localPort = 8888;  


void setup()
{

  memset(vol, 0, sizeof(vol));
  strip.begin();

Serial.println(analogRead(A0));

  Serial.begin(115200);
  Serial.println("Orientation Sensor Raw Data Test"); Serial.println("");

  /* Initialise the sensor */
  if(!bno.begin())
  {
    /* There was a problem detecting the BNO055 ... check your connections */
    Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }

  delay(2000);

  /* Display the current temperature */
  int8_t temp = bno.getTemp();
  Serial.print("Current Temperature: ");
  Serial.print(temp);
  Serial.println(" C");
  Serial.println("");

  bno.setExtCrystalUse(true);

  Serial.println("Calibration status values: 0=uncalibrated, 3=fully calibrated");

  // Connect to WiFi network

    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);
    WiFi.begin(ssid, pass);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");

    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());

    Serial.println("Starting UDP");
    Udp.begin(localPort);
    Serial.print("Local port: ");
    Serial.println(Udp.localPort());

    }

/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete (your own code
    should go here)
*/
/**************************************************************************/
void loop()
{


 uint8_t  i;
  uint16_t minLvl, maxLvl;
  int      n, height;

  // Possible vector values can be:
  // - VECTOR_ACCELEROMETER - m/s^2
  // - VECTOR_MAGNETOMETER  - uT
  // - VECTOR_GYROSCOPE     - rad/s
  // - VECTOR_EULER         - degrees
  // - VECTOR_LINEARACCEL   - m/s^2
  // - VECTOR_GRAVITY       - m/s^2

  imu::Vector<3> euler = bno.getVector(Adafruit_BNO055::VECTOR_EULER);

  imu::Vector<3> accel = bno.getVector(Adafruit_BNO055::VECTOR_ACCELEROMETER);

  /* Display the floating point data */
//  Serial.print("X: ");
//  Serial.print(euler.x());
//  Serial.print(" Y: ");
//  Serial.print(euler.y());
//  Serial.print(" Z: ");
//  Serial.print(euler.z());
//  Serial.print("\t\t");

Serial.print(euler.x());
Serial.print("\t");
Serial.print(euler.y());
Serial.print("\t");
Serial.print(euler.z());
Serial.print("\t");
Serial.print(accel.x()*10);
Serial.print("\t");
Serial.print(accel.y()*10);
Serial.print("\t");
Serial.println(accel.z()*10);

OSCMessage msg("/IMU");
    msg.add(euler.x());
    msg.add(euler.y());
    msg.add(euler.z());
    msg.add(accel.x()*10);
    msg.add(accel.y()*10);
    msg.add(accel.z()*10);
    Udp.beginPacket(outIp, outPort);
    msg.send(Udp);
    Udp.endPacket();
    msg.empty();
    //delay(500);

  /*
  // Quaternion data
  imu::Quaternion quat = bno.getQuat();
  Serial.print("qW: ");
  Serial.print(quat.w(), 4);
  Serial.print(" qX: ");
  Serial.print(quat.y(), 4);
  Serial.print(" qY: ");
  Serial.print(quat.x(), 4);
  Serial.print(" qZ: ");
  Serial.print(quat.z(), 4);
  Serial.print("\t\t");
  */

  /* Display calibration status for each sensor. */
//  uint8_t system, gyro, accel, mag = 0;
//  bno.getCalibration(&system, &gyro, &accel, &mag);
//  Serial.print("CALIBRATION: Sys=");
//  Serial.print(system, DEC);
//  Serial.print(" Gyro=");
//  Serial.print(gyro, DEC);
//  Serial.print(" Accel=");
//  Serial.print(accel, DEC);
//  Serial.print(" Mag=");
//  Serial.println(mag, DEC);

  delay(BNO055_SAMPLERATE_DELAY_MS);



  n   = analogRead(MIC_PIN);                        // Raw reading from mic 
  n   = abs(n - 512 - DC_OFFSET); // Center on zero
  n   = (n <= NOISE) ? 0 : (n - NOISE);             // Remove noise/hum
  lvl = ((lvl * 7) + n) >> 3;    // "Dampened" reading (else looks twitchy)

  Serial.println(lvl);
  // Calculate bar height based on dynamic min/max levels (fixed point):
  height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  if(height < 0L)       height = 0;      // Clip output
  else if(height > TOP) height = TOP;
  if(height > peak)     peak   = height; // Keep 'peak' dot at top


  // Color pixels based on rainbow gradient
  for(i=0; i<N_PIXELS; i++) {
    if(i >= height)               strip.setPixelColor(i,   0,   0, 0);
    else strip.setPixelColor(i,Wheel(map(i,0,strip.numPixels()-1,30,150)));
  }


  // Draw peak dot  

  if(peak > 0 && peak <= N_PIXELS-1) strip.setPixelColor(peak,Wheel(map(peak,0,strip.numPixels()-1,30,150)));

   strip.show(); // Update strip

// Every few frames, make the peak pixel drop by 1:

    if(++dotCount >= PEAK_FALL) { //fall rate 

      if(peak > 0) peak--;
      dotCount = 0;
    }



  vol[volCount] = n;                      // Save sample for dynamic leveling
  if(++volCount >= SAMPLES) volCount = 0; // Advance/rollover sample counter

  // Get volume range of prior frames
  minLvl = maxLvl = vol[0];
  for(i=1; i<SAMPLES; i++) {
    if(vol[i] < minLvl)      minLvl = vol[i];
    else if(vol[i] > maxLvl) maxLvl = vol[i];
  }
  // minLvl and maxLvl indicate the volume range over prior frames, used
  // for vertically scaling the output graph (so it looks interesting
  // regardless of volume level).  If they're too close together though
  // (e.g. at very low volume levels) the graph becomes super coarse
  // and 'jumpy'...so keep some minimum distance between them (this
  // also lets the graph go to zero when no sound is playing):
  if((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;
  minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; // Dampen min/max levels
  maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; // (fake rolling average)

}

// Input a value 0 to 255 to get a color value.
// The colors are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  if(WheelPos < 85) {
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if(WheelPos < 170) {
   WheelPos -= 85;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

Now that we had the data from the Sensors and the communication using Wifi then I continued to the Processing code. I found this sample in the Open Proccesing and I wanted to add it to the dancing performance. First the code needed to be fixed in Java language. Then code how to receive data from the microcontroller using the OSC. Once this was succesfull the code should transform the numbers into movement. It was done through the mouse coding.

Here is the complete code.

import oscP5.*;
import netP5.*;

OscP5 oscP5;
//NetAddress myRemoteLocation;

double ex,ey,ez,ax,ay,az;



int particlesQuantity = 18000;

float[] positionX = new float[particlesQuantity];
float[] positionY = new float[particlesQuantity];
float[] velocityX = new float[particlesQuantity];
float[] velocityY = new float[particlesQuantity];



void setup() {
  size(600, 600);
  stroke(64, 255, 255);
  oscP5 = new OscP5(this,9999);

  for (int particle = 1; particle < particlesQuantity; particle++) {
    positionX[particle] = random(0, width);
    positionY[particle] = random(0, height);
  }

  positionX[0] = 0;
  positionY[0] = 0;
}

void draw() {
  background(0, 128);
  int amplify = 6;
  //velocityX[0] = velocityX[0] * 0.5 + (mouseX - positionX[0]) * 0.1;
  //velocityY[0] = velocityY[0] * 0.5 + (mouseY - positionY[0]) * 0.1;
  velocityX[0] = velocityX[0] * 0.5 + ((float)ey * amplify - positionX[0]) * 0.1; // Here we used the Euler Y
  velocityY[0] = velocityY[0] * 0.5 + ((float)ez * amplify - positionY[0]) * 0.1; // Here we used the Euler Z

  positionX[0] += velocityX[0];
  positionY[0] += velocityY[0];

  for (int particle = 1; particle < particlesQuantity; particle++) {
    float whatever = 1024 / (sq(positionX[0] - positionX[particle]) + sq(positionY[0] - positionY[particle]));

    velocityX[particle] = velocityX[particle] * 0.95 + (velocityX[0] - velocityX[particle]) * whatever;
    velocityY[particle] = velocityY[particle] * 0.95 + (velocityY[0] - velocityY[particle]) * whatever;

    positionX[particle] += velocityX[particle];
    positionY[particle] += velocityY[particle];

    if ((positionX[particle] < 0 && velocityX[particle] < 0) || (positionX[particle] > width && velocityX[particle] > 0)) {
      velocityX[particle] = -velocityX[particle];
    }

    if ((positionY[particle] < 0 && velocityY[particle] < 0) || (positionY[particle] > height && velocityY[particle] > 0)) {
      velocityY[particle] = -velocityY[particle];
    }

    point(positionX[particle], positionY[particle]);
  }
}

void mousePressed() {
  for (int particle = 1; particle < particlesQuantity; particle++) {
    positionX[particle] = random(0, width);
    positionY[particle] = random(0, height);
  }
}





void oscEvent(OscMessage theOscMessage) {
  /* check if theOscMessage has the address pattern we are looking for. */
  //println(theOscMessage);
  if(theOscMessage.checkAddrPattern("/IMU")==true) {
    /* check if the typetag is the right one. */
    /*if(theOscMessage.checkTypetag("ifs")) {
      //parse theOscMessage and extract the values from the osc message arguments. 
      int firstValue = theOscMessage.get(0).intValue();  
      float secondValue = theOscMessage.get(1).floatValue();
      String thirdValue = theOscMessage.get(2).stringValue();*/
      ex = theOscMessage.get(0).doubleValue();
      ey = theOscMessage.get(1).doubleValue();
      ez = theOscMessage.get(2).doubleValue();
      ax = theOscMessage.get(3).doubleValue();
      ay = theOscMessage.get(4).doubleValue();
      az = theOscMessage.get(5).doubleValue();
      //println(theOscMessage.get(0).doubleValue());
      println(ex+" , "+ey+" , "+ez+" , "+ax+" , "+ay+" , "+az);
      //print("### received an osc message /test with typetag ifs.");
      //println(" values: "+firstValue+", "+secondValue+", "+thirdValue);
      return;
    //}  
  } 
  println("### received an osc message. with address pattern "+theOscMessage.addrPattern());
}

This is the result.

Processing Particles with Wifi MCU from Ana Correa on Vimeo.

3D printed shoes: Electronic system from Ana Correa on Vimeo.

After all this the circuit must be independant from the Computer power source. In this case I had to use 2 batteries of 3.7 volts each connected in series to supply the circuit. The NodeMCU has a voltage regulator integrated to all the Vin input pins making it easier.

Just at the end of the project I found the web page circuito.io helping with the circuit diagram. It has all the components and shows how to connect them without any shortcut. Now I know I need a more components to protect the circuit.

To adapt it into the shoe I placed it in a pocket between the fabric and the linning.

Conclutions

The next step of the project should have an upgrade of the sole design and the making. It was made this way thinking in the ergonomics and the way the shoes are actually made.. but now I am thinking maybe it can be all just 1 piece and the INFILL of the extrusion is enough for the coushioning. Maybe the sole must be printed totally vertical or totally horizontal. Between the Upper part and the Sole should exist an interlocking system to avoid the use of glues. About the electronics the integration with the shoe should be better and the design of the visual graphic output should be part of a choreography.

This are the first pair of shoes I made using digital fabrication technology and under the concept of using the body as an instrument. This project and the result made me think in the many applications to this mixture of tools and idiologist can create. The product shows and confirm the possibility to build ultra personalize garments with high quality in a FabLab. This changes the way we consume and produce. The concept of the project pretends to democritize a product categorized as smart and fashion to be used in a context of the street dancing and performing. Finally I think it can also take part people with disabled situations converted into opportunities to innovate. Can a blind person experiment dancing with different sensing methods? . . .

Thank you to Anastasia because she trusted and gave me the freedom and support to develop my ideas. Thank you to Fabricademy to create this programme that feels like a master.

Presentations

MIDTERM PRESENTATION Click here to see the presentation

PRESENTATION 2 Transforming HIPHOP into an interactive performance

STORYTELLING The Story

Final Presentation

Final Project2 from Ana Correa on Vimeo.

Contact

                                            ¡¡   ENJOY  !!
If you would like to contact me:                                            
E-mail: [email protected]

                                            ¡¡ THANK YOU !!