Team TheSensorBros: William Page, Ian Conklin

Published April 12, 2017

Is Your 3D Print Sliding?

This is a sensor designed to send a notification to your phone and OLED Remote Screen whenever a 3D print is sliding on the print bed.

IntermediateFull instructions provided5 hours818

Things used in this project

Hardware components

Capacitor 100 µF

Sharp GP2Y0A51SK0F Analog Distance Sensor 2-15cm

Particle Photon

Adafruit Monochrome 0.96" 128x64 OLED graphic display

Software apps and online services

IFTTT Maker service

Hand tools and fabrication machines

MP Select Mini 3D Printer

Story

Ideation

This sensor was designed specifically for the MP Select Mini. I had left my printer running in order to run a very long print. When I came home, I was greeted by a large spaghetti monster and a large nugget melted to the extruder nozzle. In order to combat this, I scoured the web to search for a sensor design to inform me when a slip has occurred, but there was none. So, Ian and myself decided to make our own sensor for this very issue.

Instructional Video

When the build was finished, Ian shot a video of me explaining and demonstrating how everything communicated with each other to let you know when a print had slid off the bed.

Demonstration of our project *NOTE: When I said "cm" I really meant "mm".

Components

The overall build consists of three basic components. The "Remote" is an OLED screen provided in the Particle Photon Maker kit. It's sole purpose is to deliver the message "Your 3D Print is Slipping" when it retrieves data from the printers Photon. This allows it to be semi-portable, it's limitations of use being anywhere it can both receive power and a wifi connection.

OLED Remote Used to Provide Instant Notification

Circuit for the Remote

Record Voltages

The last two portions are the IR Distance Sensors connected into the "3D Printer" photon. When this project was started, there were no libraries of the IR Sensors used. In order to get accurate distance readings, it was necessary to record the voltage output of the sensors at different distances. These readings were imported into Excel, and the below chart and formula was created. Do note that the decimal points are not rounded as they are defaulted. If the equation is left in its rounded state, it will provide extremely inaccurate results.

Chart of the Voltage to Distance Conversion

IR Distance Sensor

The first part being the IR Distance Sensor connected to the top of the tower. It is programmed to determine its distance away from the top of the gantry, and tell when it has risen a certain amount. In this case, it looks for a height of 30mm. This prevents the IR sensor on the print bed from mistaking the moving extruder nozzle as a printing slip.

IR DIstance Sensor Mounted on Tower

Print Bed Sensor

The final component is the aforementioned print bed sensor. It is focused on the center line of the print bed where most prints will be created. Its job is to register how far away the print is and determine when that distance has changed more than 15mm. This is done by averaging the old reading with a new reading and comparing it to the old average from previous iterations. The bright red cases housing the sensors were designed by William Page specifically for the MP Select Mini.

Sensor Connected to Base

Circuit for the IR Distance Sensors

How it Works

When both the gantry height is high enough, and a change in distance on the print bed is above 15mm, it changes a "warning" variable in the code from 0 to 1, triggering a notification to be sent from IFTTT to my phone. The setup for this applet is shown below.

"If This" Portion of Applet to Send Notification to Phone

"Then That" Portion of Applet to Send Notification to Phone

Graph

This data is also recorded in a Google Sheet as a time stamp to see when exactly the print began to experience slipping issues, as seen below.

Chart 1: Printing Time Stamps

In this chart, 1 signifies a time when the print was slipping and 0 signifies when the print was stationary. This graph was simulated by using a false print and moving it by hand. It is created using the two IFTTT applets shown below. When the applets are created, be sure to disable notifications for both the Time Stamp recording applets, otherwise you will receive an update every 15 seconds when it writes a new line in the Google sheet.

"IF This" Setup for Applet Recording When Print is Not Slipping

"IF This" Setup for Applet Recording When Print is Slipping

Same "Then That" Portion of Applet Used by Both Slipping and Non-Slipping Applets

Schematics

Code

//William Page's IR Sensor Coding to See Slipping of 3D Print


/*                                   +-----+
 *                        +----------| USB |----------+
 *                        |          +-----+       *  |
 * All Component Power -->| [*] VIN           3V3 [ ] |
 *                        | [ ] GND           RST [ ] |
 *                        | [ ] TX           VBAT [ ] |
 *                        | [ ] RX  [S]   [R] GND [*] |<-- All Components Ground
 *                        | [ ] WKP            D7 [ ] |
 *                        | [ ] DAC +-------+  D6 [ ] |
 *                        | [ ] A5  |   *   |  D5 [ ] |
 *                        | [ ] A4  |Photon |  D4 [ ] |
 *                        | [ ] A3  |       |  D3 [ ] |
 *                        | [ ] A2  +-------+  D2 [ ] |
 * Gantry Tower Sensor -->| [*] A1             D1 [ ] |
 * Build Plate Sensor  -->| [*] A0             D0 [ ] |
 *                        |                           |
 *                         \    []         [______]  /
 *                          \_______________________/
 *
 *
 */



//NOTE: All variables labeled "A" belong to the IR Sensor used on the build plate. All variables labeled "B" are used with the IR sensor on the Z-Axis tower

//SENSOR ON Z-AXIS TOWER
int sensor_B=A1; //(need to connect the sensor output to A1)
double voltage_B=0;
int reading_B=0;
double distance_B=0;
double new_B=0;
double old_B=0;
double avg_B=0;
double height_B=0;

//SENSOR ON BUILD PLATE
int sensor_A=A0; //(need to connect the sensor output to A0)
double voltage_A=0;
int reading_A=0;
double distance_A=0;
double new_A=0;
double old_A=0;
double avg_A=0;
double trigger=0;





//Warning If-Statement
int warning=0;

void setup() {
    
   
    //Sensor on the Build PLate
    Particle.variable("voltage_A",voltage_A);
    Particle.variable("distance_A",distance_A);
    Particle.variable("avg_A",avg_A);
    
    Particle.variable("new_A",new_A);
    Particle.variable("trigger",trigger);
    
    //Sensor on the Z-Axis Tower
    Particle.variable("voltage_B",voltage_B);
    Particle.variable("distance_B",distance_B);
    Particle.variable("avg_B",avg_B);
        Particle.variable("height_B",height_B);
    
    //if statement
    Particle.variable("warning",warning);
    
    
}

void loop() {
    
  
  delay(500); //delay to slow down the rate of recording
  
 
  //START OF z-AXIS TOWER IR SENSOR SEARCHING FOR GANTRY DISTANCE TO BE 1 UP
  
  
  reading_B=analogRead(sensor_B);  //Gets the ADC Reading
  voltage_B=3300.0*reading_B/4095.0; //converts to mV
  distance_B=-0.0000000505255603183952*(voltage_B*voltage_B*voltage_B)+0.000242612411146567*(voltage_B*voltage_B)-0.411007366409474*(voltage_B)+271.29413959704;
  //NOTE: When calculating the formula in Excel, you MUST change the available decimals in the formula to 15+ in order to get and accurate equation
  
  new_B=distance_B;
  

    

    avg_B=((new_B+((old_B)*16)))/17; //averages the new and old distances to ensure wild fluctuations are kept to a minium
    
    height_B=123-avg_B;
    
  
    old_B=new_B;
  
  
  
  
  //END of Z-AXIS TOWER IR SENSOR
  
  
  //START OF BUILD PLATE IR SENSOR CODE SEARCHING FOR CHANGE IN DISTANCE
    reading_A=analogRead(sensor_A);  //Gets the ADC Reading
    voltage_A=3300.0*reading_A/4095.0; //converts to mV
    distance_A=-0.0000000505255603183952*(voltage_A*voltage_A*voltage_A)+0.000242612411146567*(voltage_A*voltage_A)-0.411007366409474*(voltage_A)+271.29413959704;
  //NOTE: When calculating the formula in Excel, you MUST change the available decimals in the formula to 15+ in order to get and accurate equation
  
    new_A=distance_A;
  

    avg_A=((new_A+((old_A)*16)))/17; //averages the new and old distances to ensure wild fluctuations are kept to a minimum
    
    trigger=abs(avg_A-new_A);
 
  
    old_A=new_A;
  //END OF BUILD PLATE IR SENSOR CODE
  
  
  //Start of If Statement to Activate Readings from Base Sensor
  
 
  if (height_B > 30)   //if the height of the nozzle is above 30 mm
   {
    if (trigger > 10)  //and the change in distance on the build plate is more than 10 mm at any time
        {
         warning=1; //then the warning is changed from 0 to 1, thus informing IFTTT that a slip has occured and to send a notification to my phone
         
         delay(1000);
         Particle.publish("Slipping-Print","Your Print is Slipping!", PUBLIC);
        }
   }
   else //otherwise, continue with business as usual.
  {
      warning=0;
  }
 
}

 //OLED connections into Photon
 
 /*                           +-----+
 *                 +----------| USB |----------+
 *                 |          +-----+       *  |
 *                 | [ ] VIN           3V3 [*] |<-- VCC
 *                 | [ ] GND           RST [*] |<-- RES
 *                 | [ ] TX           VBAT [ ] |
 *                 | [ ] RX  [S]   [R] GND [*] |<-- Ground
 *                 | [ ] WKP            D7 [ ] |
 *                 | [ ] DAC +-------+  D6 [ ] |
 *           D1 -->| [*] A5  |   *   |  D5 [ ] |
 *                 | [ ] A4  |Photon |  D4 [*] |<-- CS
 *           D0 -->| [*] A3  |       |  D3 [*] |<-- DC
 *                 | [ ] A2  +-------+  D2 [ ] |
 *                 | [ ] A1             D1 [ ] |
 *                 | [ ] A0             D0 [ ] |
 *                 |                           |
 *                  \    []         [______]  /
 *                   \_______________________/
 *
 *
 */

// This #include statement was automatically added by the Particle IDE.
#include <Adafruit_SSD1306.h>

FuelGauge fuel;

// use hardware SPI
// OLED_D0 -> A3 (SPI CLK)
// OLED_D1 -> A5 (SPI MOSI)
#define OLED_DC     D3
#define OLED_CS     D4
#define OLED_RESET  D5
Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);


#define NUMFLAKES  10
#define XPOS  0
#define YPOS  1
#define DELTAY  2


#define LOGO16_GLCD_HEIGHT  16 
#define LOGO16_GLCD_WIDTH   16


#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

void setup()   {     

    Particle.subscribe("Slipping-Print", PrintDisplay, "290029001951353337343731");


 // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  display.begin(SSD1306_SWITCHCAPVCC);
  display.clearDisplay();
  delay(500);
}


void PrintDisplay(const char *event, const char *data)
{
   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0,0);
   display.print("Print is Sliding");
   
   
   display.display();
   delay(2000);
}




void loop() {
    
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  
  
  
  display.println("___________________");
  //Set time zone to EST
  Time.zone(-4);
  //Format time using : http://strftime.net/
  display.println(Time.format(Time.now(), "%a %b,%e %l:%M%p"));

  //Battery Voltage
  //display.print("BATT VOLTAGE: ");
  //display.print( fuel.getVCell() );
  //display.println("V");
  
  //Battery State Of Charge
  //display.print("SOC: ");
  //display.print( fuel.getSoC() );
  //display.println("%");
  
  


  display.display();
  delay(2000);
}

Credits

William Page

1 project • 0 followers

Ian Conklin

1 project • 0 followers

Mechanical Engineering student at UNCC

Is Your 3D Print Sliding?