Drip Governor - A most valuble first hack

[rylangrayston]

Having used the peachy printer alot, I think one of the most valuable hacks That almost everyone will want is some way to automatically speed up and slow down the drip feed in the peachy printer. Id love to include such a feature in every kit

but as of now it looks like it will have to be an add on.



An auto governed dripper would improve 4 situations that really slow down the printing process.


1. If you have a 1000 layer print and 999 of your layers take 1 second to complete

but one of the layers takes 1 minute, then optimal your print could take 1059 seconds, however with out changing your drip speed dynamically during the print

you will have to wait one min in between all the 1 second layers just so you will have time to print the 1 min layer when you get to it. This makes printing without dynamic drip speed take 999 * 60 + 60 = 60000 seconds. This is bad because in this example you wait 16 hours for a print that could have taken 17 minutes with a dynamic drip rate ( of course this is and extreme situation but you get the point


2. Setting the drip speed really slow and just leaving the printer over night can simply result in the drip feed randomly stopping all together.


3 Changing the drip rate by hand works great, until you bump the printer because

its hard to stay focused on such a simple task for hours of time, time which is better spent ells ware


4. The size of a drip gets bigger when dripping very fast compared to very slow

we can account for this by measuring the time between drips but It would be better if we could avoid the slow dripping range entirely.




There are lots and lots of ways you could govern drips but since the printer costs so little iv been trying to find an ultra inexpensive drip governor. Ive been thinking about it for about 9 months now and Im finally starting to like one of my ideas on this topic.. so tonight while waiting for prints to finish i wiped up this little animation:






Important points

- The tapered points glued to ether end of the magnet would have just the right density to float the magnet in salt water


- The entire moving part would be dipped in enamel to prevent corrosion.


- The hope is that you could charge a capacitor and give each coil a pulse causing the printer to drip rapidly or not at all.


- The pules to the coils could be followed by some small holding current



- the wedge shape on the open end is important to help the moving part stick in place

- The flow of the water is typically very very slow not enough to push the moving part around


- If a magnet as apposed to a soft iron core is used its possible to pulse both coils at the same time (one pushing and the other pulling)


- The peachy software and hardware will be developed specifically to make it easy to add such modifications.


- When held vertical the floating magnet would sink indicating that your printer needs more salt.


- it seems quite likely that this could be further modified to be a pump.


I may work on this soon as it would really help the peachy team print faster.


Ill probably just drive mine with an Arduino sending codes over the serial port to open the drip governor

when ever the print is less that 5 drips ahead of the current layer.


Im also very interested in a pump that can do really repeatable pulses of water.


This is a great project for those of you that are dieing to work on the peachy printer before you get it!


Some points of importance in making a great drip detector are

- low cost

- the hole assembly must be air tight from top to bottom as to maximize siphon and stop bumbles from pushing into the bottom resivior

- drips must make clean and reliable contact between microphone input wires.



Well if i do get time to work on this ill be sure to post my results here

hope you will do the same


Rylan Grayston

[mike_biddell]

Rylan............. love the idea........... the drip from your valve could be software demanded, without the use of arduino. You simply have a light dependent resistor or photocell at a know location on the side of the tank and above the resin. This location would be known and calibrated. Every time the software wants a drip, it would switch the laser off, move the galvos, so the laser pointed at the LDR/photocell and then switch the laser on. This pulse of light could be used to switch a transistor on to deliver the current to your valve. You could demand a number of drips, one after the other by pulsing the laser on and off if required, or demanding a single drip...... it's totally flexible. This solution requires no digital components, just a single transistor and LDR and a reserved switching location in 3d space. The software would have a demand drip function, which would handle firing at the ldr on the side of the tank. The only parameter you would pass is number of drips required (demand-drip(n)).

[mike_biddell]

Forgot to say, if the valve works reliably, there would be no need for the microphone input. The software would simply count the demands it has made. The demand-drip circuit could replace the mic input conditioning circuit.

[Pete]

Been thinking about this too Rylan and as you know with my solution I pretty much get extra free control and feedback mechanisms, although there might be a simple hack for the basic printer in here somewhere.

So most pumps seem pretty useless for salt water and on Friday I had an idea and went for it.
IMG_20140308_174318.jpg
This is basically a, badly built, piston pump using a reciprocating servo and a syringe. Generally pumps would have two one way valves so that you get a metered dose each stroke. I actually wanted to have two controllable valves so that i could add extra to the print side and then take it out again to get over this surface tension/flowing issue . I might finish this off, surprisingly controlling it over 20 cycles I got within a few % of my expected volume (although this was a fag of set position move pipe set position move pipe between reservoirs since I don't have any valves yet [Could have 3d printed a couple!])
I'm thinking on the fly here but for the basic you could implement this with two 555 timers and an opto feedback which would replace the drip feedback to the sound card (just happens each drip is a pretty mega one!).
I can't find any reasonable price looking commercial pumps like this....suggestions anyone?

Another Idea that I had last night is to use a peristaltic pump. These are often used to dose fish tanks but essentially mean that the fluid your pumping only ever is contained in a silicone pipe. I've ordered one of these. Again I would like to be able to pump both ways and I was thinking opto or reed switch to sense the rotor arm, like the above this gives much larger 'drips' but I imagine you could sacrifice some of your Z resolution? This could also be added to the basic, I imagine that this could be hooked directly to the USB (you could even control on and off with a similar laser control circuit) and again feedback to the mic port, although the flow rate on some of these pumps might be good enough just to add a timer in software (this seems to be how they're used in fish tanks).

[Slatye]

Pete - I think that what you require is a diaphragm pump (this is pretty much what you've built, except that the pump would include two one-way valves). They're very good at handling relatively nasty liquids (like salt water) and each cycle should give a constant amount of water (depending largely on how consistent the one-way valves are).

eBay has such things very cheaply. The challenge with these ones is that there's no feedback of any sort - you don't know how many cycles it's done. If there's just a cam on the end of the motor shaft then it should be simple to replace that with a servo (as per your design) which gives perfect feedback. There might be a nice analogue way to integrate this, but (as always) I'd just stick an STM32F0 in there and call it finished. In this system I'd also need two pumps, since they're not reversible - one to transfer water from the source container to the printing container, and one to handle surface tension issues.



With that said, I can see the attraction of Rylan's design. A pump would give you direct control over the water level but often that's not actually the best approach. The direct electromagnetic valve approach seems fairly simple and is definitely mostly analogue, which would make integration easier.

[Feign]

Another possibility is to have the flow rate set manually very high, and have a solenoid valve before that that listens to the printing output for the 'laser on' signal and shuts off the flow when the laser is on for more than a few hundredths of a second (to keep it from fluttering while the laser is rapidly turning on and off to make a multi-line image.)

Making sure to have a simple "laser is on" signal output from the Peachy would make this (and other hacks/accessories) even easier, since other devices wouldn't have to listen to the signal from the computer that way.

[nka]

Electronic valve seems the best way to go for it. But I would keep the mic input to monitor if everything goes as it should.

[Feign]

I agree on keeping the mic monitor, since the computer needs some kind of feedback on the z-position.

Having an additional on/off valve would benefit from the valve itself listening to the drip sensor as well as the "laser on" signal, so it can simply cut the water off if the laser is "on" for more drips than it would take for one layer (or one sublayer) until the laser is "off" again for long enough to indicate that the sublayer is done. Just having "Laser On" equal "Valve Off" is a pretty simple way of doing things on the hardware side, but it would slow down prints during simple layers, though .

[harpo99999]

back during the ks for the peachy, I had an idea somewhat similar to rylan's, BUT using the mass/weight of the magnet/seal to close and a electromagnet to open the valve by drawing the magnet (in the top part of the valve) toward OR away from vertical thereby opening the valve

[rylangrayston]

Hey everyone, Im a bit pressed for time today.. so sorry in advance for the short reply's.

here we go
@Mike_biddell
Great Ideas .. quite possibly part of what could make it low cost enough to be a part of the peachy basic, be sure to post your hack if you build it! You will likely pave the way for many others!
The drip governor is my aim at doing it super low cost, pumps will most likely be the answer for the pro.

@pete
Nice work! take a look at the valve i made below .. i think it would act as a nice Super low pressure one way valve simply using gravity instead of a spring.
I like the idea that the pump could be help the surface tension issue... we plan to do this in the pro! Thanks for the link to the pump they look great so im purchasing a few now

@Slatye
Those pumps look great also .. again possibly exactly what we need for the pro, we could simply put a photo interrupt on the back end of the motor and use and interrupt pin on a micro to count how many cam pulses the pump has done.

@Feign
Right not only is the circuit easy to listen in on its also easy to control, we are breaking out important wires like that into terminal headers and solder pads.
We are doing this specifically to encourage hacks, the peachy printer isnt just open its actually designed to be hacked. and on that note .. I did get a few hours to work on my version of the drip governor hack... so here are some pics!

20140308_200509.jpg
20140308_200550.jpg
20140310_134749.jpg


also here is a python script:

import serial

import time
connected = False
ser = serial.Serial("COM4", 9600)



while not connected:
    serin = ser.read()
    connected = True


for i in range(0,300):
    print (ser.outWaiting())
    print (ser.inWaiting())
    try:
        ser.write("1")
    except ser.SerialTimeoutException:
        print('gerr')

    print('wrote1',i)
    time.sleep(1.5)
    try:
        ser.write("0")
    except ser.SerialTimeoutException:
        print('gerr2')

    time.sleep(1.5)
    #ser.flushInput()








#while ser.read() == '1':

#    ser.read()



ser.close()

and an arduino script that the python script talks to over serial

// Open a serial connection and flash LED when input is received
int led = 13;
int on = 2;
int off = 3;
int onTime = 400;
int pulseValve = 10;
char code = '0';
int powerTime = 500;


void setup(){
  // Open serial connection.
  Serial.begin(9600);
  pinMode(13, OUTPUT);
  Serial.write('1'); 
  pinMode(led, OUTPUT);    
  pinMode(on, OUTPUT);
  pinMode(off, OUTPUT);
  pinMode(pulseValve, INPUT);
  
}


void testValve(){
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  digitalWrite(on, LOW);
  digitalWrite(off, HIGH);
  delay(powerTime);
  digitalWrite(off, LOW);
  


  delay(2000);
  
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(off, LOW);
  digitalWrite(on, HIGH);
  delay(powerTime);
  digitalWrite(on, LOW);


  delay(2000);
  }
  








void loop(){ 
  //Serial.write(2);
  
  if (digitalRead(pulseValve) == HIGH){
  testValve();
  }
  
  
  if(Serial.available() > 0){      // if data present, blink
  code = Serial.read();
  
  if (code == '1'){
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(off, LOW);
  digitalWrite(on, HIGH);
  delay(powerTime);
  digitalWrite(on, LOW);
  //Serial.write(1);
  }
  
  if (code == '0'){
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  digitalWrite(on, LOW);
  digitalWrite(off, HIGH);
  delay(powerTime);
  digitalWrite(off, LOW);
  //Serial.write(0);
  //delay(onTime);               // wait for a second
  }
  }
}

ok that code is rather ruff, its just an excerpt from my playground branch.. Townly is making it into a proper class right now.
Soon you will just be able to script the printer like this
dripGovernor.stopDripping()
dripGovernor.startDripping()


Ill be making some major improvements to this ..
- change to a single coil driven by an h bridge reversing the power to the coil turn the valve on and off.( use a stopper to keep the magnet alwase off center of the coil so the coil alwase pushes it in one direction.
- make the hole thing smaller
- machine the moving pin with a lathe then use the machined pice to and make a mould to cast the magnet into the pin
- reduce the hose length between the driper and the governor valve to increase the responsiveness of the system.
- use clear plastic for all outer components ( easier to see what happens when it stops working)
- change from 34 gage wire to 36 or 38 gage wire, ( reducing the current required to do the same work with everyting on a smaller scale )
- adjust the size density of the moving part so its the same density as saturated salt water

looking forward to seeing all the different ways there are to govern dripping!
Im sure some of the best ways to do it will be a combination of all the posts here.