Beginner An Idiots guide: DIY Water Drop Controller with Arduinos and stuff.

[GarethB]

An Idiots guide: DIY Water Drop Controller with Arduinos and stuff.

Hello there fellow TP folks.

Hands up who's seen those amazing images of water drop collisions?
I have. And I became so enthralled with them, I decided to embark on a journey to construct a device that can create such images.

This is what I did and the way I did it.

Firstly I should point out that I am not an expert in electronics or Arduino programming...far from it in fact.
Until a few weeks ago, I'd never even seen an Arduino, let alone knew what they were or what they did!
The last time I did anything electronics related was thirty years ago...and that was only 'O' level electronics!
So I won't be able to go into much technical detail about the components used in this build, sorry!
(I accept no responsibility for damage to any equipment used. Please be careful when messing around with electronics.
I created this thread purely as a record of what I did, it isn't meant to be an exact guide, rather an information resource to apply to your own project.
I encourage further research if you intend to embark upon a similar project.)

So you see I am perfectly qualified to create 'an idiots guide'!

Secondly, I wish to credit the following for their invaluable guides:

- Martyn Currey - Brilliant in depth guides on Arduino water drop controllers - LINK LINK
- Ted Kinsman - 'How to Build a DIY Double Water Drip System for High Speed Photos' on PetaPixel - LINK
- Paul McWhorter - His Arduino programming guides are invaluable for beginners - LINK
- Corrie White - For being awesome and inspirational - LINK LINK
- and our very own @Manxmaid for inspiring me to write my story...thank you Andrea!

I was able to adapt the information from these guides to suit the device I wanted to build.
Specifically I wanted a device that would release two timed drops of water and then trigger a camera to capture the collision event.
I didn't want to build a device that fired only the flashes (and use bulb mode in a dark room), since I wanted to have a light on whilst I'm working with cameras and water!
I will eliminate the ambient light in the room by setting my camera to its maximum flash sync, which for my Canon 7D is 250th of a second.



Clicky Contents:

• The start
• The circuit
• The Arduino
• Arduino code - updated: added a section to print time values to serial monitor
• The support structure
• The Mariotte Syphon
• Timings, mixes and finale
• Addendum I - nozzles and other stuff
• Addendum II - connecting the power supply and the solenoid
• Project Updates - adding variable control and LCD to be independent of a PC.
• The revised Arduino code - rewritten to accommodate the new control systems.
• The Buck Converter - powering the Arduino from a battery.
• LCD screens - more details and clearer diagrams
• Potentiometers - better info and diagram
• LCD display problems - weird numbers showing on the display
• Making a box - the ups and downs!
• Project updates - soldering (and ruining!) the circuit
• Revised sketch - possibly for the final time - special thanks to @Leebert @Picareto and @billbillbill
• Images of water drops - early shots and some test shots
• 
  
• The difficult second album - a late catch up of where the MK 2 version is now
• The button/keypad shield - how to build your own, and use it with a menu sketch

Here are some images I shot using the controller I built:

IMG_0494 by Gareth Bellamy, on Flickr


drop3 by Gareth Bellamy, on Flickr

I
MG_0579 by Gareth Bellamy, on Flickr

Equipment needed that I already had:

• thirty year old multimeter (not an absolute necessity, but handy to check voltages/resistances)
• hot glue gun (to seal the tubes for a Mariotte Syphon)
• soldering iron (not strictly necessary, but useful to neaten up wire ends etc)
• bits of wood, nuts & bolts (to make a support)
• helping hands rig (those bendy arm things with croc clips on the ends for holding small stuff)
• camera, tripod, macro lens and radio flashes (obviously!)
• an old laptop (to run the Arduino software and program it)
• PTFE also known as plumbers tape (to make water tight seals)
• masking tape for labelling

Equipment I needed to buy:

• Arduino Uno R3 - or similar clones...Arduino is open source so there are many good quality clones out there - AMAZON LINK

( I chose the Elegoo basic starter kit from Amazon, which comes with quite a few other useful components like resistors etc )​

• A cheap camera shutter release cable with the appropriate fitting for your camera. (Only need the plug fitting - don't need the button bit) - AMAZON LINK

(Some Canon cameras have the N3 style shutter trigger port (like mine), others have a 3.5mm jack plug fitting, but unfortunately I have no knowledge of other brands.)​

• A 12 volt DC 2 way N/C solenoid valve - I have used the AirTac valve from Amazon...N/C means normally closed, this is important. - AMAZON LINK

(Normally closed means that when no voltage is applied to it, the valve remains closed....so no leaking when you switch it off!)​

• A TIP120 transistor - used to control the higher currents needed for the solenoid valve - works like an electronic switch - BITSBOX LINK

• A 4N35 optoisolator - used to protect the DSLR by isolating it from the rest of the circuitry. - BITSBOX LINK

• A 1N4007 diode - used to eliminate any reverse voltage spikes when the solenoid is activated. - BITSBOX LINK

• A 12 volt DC power supply - used to power the solenoid valve through the transistor, should be able to supply at least 1 Amp current - BITSBOX LINK

(The Arduino board cannot supply enough current to power the solenoid valve alone)​

• Various croc leads - for making temporary connections without the need for a soldering iron. - BITSBOX LINK

• A 2.1mm barrel jack power socket - used to take power from the 12 volt power supply and route it to the solenoid circuit. - BITSBOX LINK

• Some lengths of wire - necessary for making longer connecting leads to the solenoid, comes in handy for some other things.

• 3 BSP/NPT 1/4 inch hosetails - 2 with 1/4 inch barbed tails and 1 with 1/8 inch barbed tail - MACHINE MART LINK

(The 1/4 inch barbs are used to connect the reservoir to the solenoid valve, and the 1/8 inch one will be the drop nozzle.​

I sourced these from a local plumbing supplier. They can also be obtained from Machine Mart)​

• A length of 8mm diameter PVC flexible tubing (about a metre would be plenty) - used to connect the valve to the reservoir.

(I bought this from B&Q, can't seem to link it because their website is rubbish!)​

• A length of rigid plastic tubing - anything around 8-10mm diameter - used to create a Mariotte syphon - approx 50cm length should be plenty.

(A Mariotte syphon is a simple device which retains a constant pressure in a sealed reservoir, regardless of the reduction in water level.​

Also purchased from B&Q)​

• A plastic, clear jar/bottle with an airtight plastic lid - used as a reservoir or Mariotte Syphon bottle. - LAKELAND LINK

(I bought these from the Lakeland shop in Norwich, but anything similar would do)​

This seems like a long list of things...but most of the electronic components only cost a few pence, and the whole build shouldn't cost more than around £50, which is much less than the commercially available systems.

(All images used in this guide were created by me)

 

[GarethB]

Lets build this thing.

This is what the Elegoo UNO R3 basic starter kit looks like

It comes in a neat little box and the bits I'll use are:

• The Elegoo UNO R3 board
• The small breadboard
• A 220 ohm resistor
• A 330 ohm resistor
• A 2 kilo ohm resistor
• A momentary switch (little bag bottom left...it's tiny!)
• Jumper wires
• The supplied USB cable

Here's my workplace showing the jumper wires and some other stuff:

This is how the rows and columns are connected on the breadboard:

The top red row is connected the entire length of the breadboard - used for power supply
The same with the blue row - used for ground
These are mirrored along the bottom of the breadboard
The middle is seperated into columns.
Each hole in the column (circled) is only connected to other holes on the same column.
There is a gap (grey line in the image) through the middle of the breadboard, the columns are not connected across this gap.

Now I will need some of the other bits:
(images are not acual size!)

A TIP 120 Darlington Transistor

A 1N4007 rectifier diode (note the grey bit on the right - must be connected the right way round)

A 4N35 optoisolator (note the dot bottom left, this is to identify the correct orientation)

And the momentary switch looks like this - it's used as a reset button to restart the program

 

[GarethB]

After some head scratching, I ended up with this:

I used some short bits of single core wire (lying around) for the grounds, but jumper wires would have been fine, though a bit 'bird-nesty', and I didn't add the switch yet, but it worked!
Note judicious use of masking tape to label stuff.
You'll also notice that there is a red LED in there...I took that out eventually - it's not really needed.

I created a diagram in the style of a Fritzing diagram (free circuit layout tool that I couldn't get to work!)

(Note the orientation of the diode, it's directional and the circuit won't work if it's put in the wrong way round.)

Here are some closeups of the two sides of the circuit
The Solenoid valve side:

And now the camera side - refer to the main diagram for Arduino pin details and power etc

I haven't created a proper circuit diagram for this circuit...I apologise - if anyone would like one I will try to make one.

To connect the power supply, I used the croc leads and the 2.1mm power socket. (Click here for Addendum II)
I carefully bent the two pins apart to make sure I didn't get any shorts.
Then I attached jumper wires to the relevant section of the breadboard.

I also snipped the button part off the shutter cable and stripped the necessary wires.
What are the necessary wires?
Canon cameras are remotely operated by shorting either the focus wire or the shutter wire to ground.
This is in fact what is going on inside the button bit...it's just a simple contact switch.
I will only need the shutter wire, because I shall be manually focusing.
For my cable it was orange and white wires, but it's easy to check...just connect the cable to the camera and touch the wires,
whichever ones trigger the shutter are the important ones.
So, with the right wires stripped and connected with croc leads, and hooked up to jumper wires onto the breadboard, it's almost complete.

Below is the Canon N3 style shutter release plug (OoF!!)
You'll see that I have used a phono/RCA connector on the other end...makes life a bit easier, but not strictly necessary for the basic build.

I connected up the solenoid valve in a similar way...croc leads and jumper wires onto the breadboard.
I eventually did something similar to the shutter cable, namely used a phono connector...and a much longer wire...for safety and convenience...in my small (microscopic) home studio!

So, that's the wiring done...felt quite pleased with it!

 

[GarethB]

Now is probably a good time to talk about the Arduino.
In order to program it, the Arduino IDE (Integrated Development Environment) software must be downloaded.

It's free and is in THIS LINK

Once downloaded and installed, I plugged in the board and it powered up...which was nice!

There's a few things to check:

• Make sure the correct board is active
• Make sure that the correct COM port is connected

To do this, go to the tools drop down (left circle) and select the UNO board
I want to use the serial monitor too (right circle), which is a tool in the software which allows users to input data into the Arduino directly.

(Since I didn't have my Arduino plugged in during the writing of this, you'll see that the 'port' section - underneath where it says 'board' - is greyed out.
When I plugged my board in for the first time, I just made sure it was the right one by trying them all to see which one worked!)

This is what I want the program to do:

• Ask for time duration of the 1st drop (in milliseconds)
• Ask for the duration of the 2nd drop (in milliseconds) - these will be the sizes of the drops, and are controlled by the opening and closing of the solenoid valve
• Ask for the time delay between the two drops (in milliseconds)
• Ask for the time delay between the drops and the camera triggering
• Open and close the valve for the 1st drop time
• Wait for the delay between drops
• Open and close the valve for the 2nd drop time
• Wait for the time entered between the drops and the camera trigger
• Trigger the camera to capture the collision
• Repeat the drop sequence again

 

[ecoleman]

Where are the pictures?

 

[GarethB]

And now the code:
(Ignore the 'C++ at the top left...there wasn't an Arduino code format, so I went with C++ format upon which the Ardiuno language is based, so it is formatted correctly)

After a number of trials (and failures) I succeeded with the following code:
(Update: added a section which prints the entered time values in the serial monitor, for ease of testing and record keeping.)

/*  Water Drop Controller V4
* 
*  By Gareth Bellamy
*/

//This is where we assign our Arduino pins and declare our variables

const int camPIN = 9;        //Set camPIN (camera) to pin 9
const int solPIN = 10;         //Set solPIN (soleniod valve) to pin 10

int DropOneSize;             //1st drop size input variable (milliseconds)
int DropTwoSize;             //2nd drop size input variable (milliseconds)
int SolDelay;                //Set delay between drops (milliseconds)
int CamDelay;                //Set delay between drops and camera activation (milliseconds)

void setup() {

//Here is where we turn on the serial monitor and tell the Arduino
  
   Serial.begin(9600);                //Start the Serial Monitor
   pinMode (camPIN, OUTPUT);          //Set camPIN to an output
   pinMode (solPIN, OUTPUT);          //Set solPIN to an output

//Here is where the time delays will be entered into the serial monitor

   Serial.println(" ");                                                  //Print a space for ease of reading the text

   Serial.println("Enter 1st drop size in milliseconds ");               //Print text asking for 1st drop size
   while(Serial.available()==0) {}                                       //Wait for user input for 1st drop size
   DropOneSize=Serial.parseInt();                                        //Read user input

   Serial.println("Enter 2nd drop size in milliseconds ");               //Print text asking for 2nd drop size
   while(Serial.available()==0) {}                                       //Wait for user input for 2nd drop size
   DropTwoSize=Serial.parseInt();                                        //Read user input

   Serial.println("Enter the delay between drops in milliseconds ");     //Print text asking for time delay between drops
   while(Serial.available()==0) {}                                       //Wait for user input for delay between drops
   SolDelay=Serial.parseInt();                                           //Read user input

   Serial.println("Enter camera delay in milliseconds ");                //Print text asking for camera delay
   while(Serial.available()==0) {}                                       //Wait for user input for camera delay   
   CamDelay=Serial.parseInt();                                           //Read user input

//This section will print the value entered above for clarity and record keeping

   Serial.println(" ");                               //Print a blank line for neatness
   Serial.print("1st drop size     ");                //Print 1st drop size
   Serial.println(DropOneSize);                       //Print value DropOneSize
   Serial.print("2nd drop size     ");                //Print 2nd drop size
   Serial.println(DropTwoSize);                       //Print value DropTwoSize
   Serial.print("Valve delay       ");                //Print Valve delay
   Serial.println(SolDelay);                          //Print value SolDelay
   Serial.print("Camera delay      ");                //Print Camera delay
   Serial.println(CamDelay);                          //Print value CamDelay

}

void loop() {


//This next section is where we will use the times entered above to activate the solenoid and camera
  
       digitalWrite (solPIN, HIGH);            //Opens solenoid valve
       delay (DropOneSize);                    //Valve stays open for time value DropOneSize - 1st drop size
       digitalWrite (solPIN, LOW);             //Closes solenoid valve
       delay (SolDelay);                       //Time delay between drops
       digitalWrite (solPIN, HIGH);            //Opens solenoid valve
       delay (DropTwoSize);                    //Valve stays open for time value DropTwoSize - 2nd drop size
       digitalWrite (solPIN, LOW);             //Closes solenoid valve
  
       delay (CamDelay);                       //Time delay for camera activation
  
       digitalWrite (camPIN, HIGH);            //Sets camPIN to high - fires camera
       delay (100);                             //Holds camPIN high for 100 milliseconds to ensure signal
       digitalWrite (camPIN, LOW);             //Sets camPIN to low -
     
       delay (5000);                           //Delays the cycle for 5 seconds
}

In order for this to run, the serial monitor must be opened, and there you will be presented with 4 questions:

• Enter 1st drop size in milliseconds (10-100)
• Enter 2nd drop size in milliseconds (10-100)
• Enter the delay between the drops in milliseconds
• Enter the camera delay in milliseconds

After the last question the sequence will start, and continue until the button on the breadboard is pressed.
I have placed this button here as a reset button, which will start the program from the beginning,
so that it's possible to tweak the timings without having to change the values in the program and re-upload every time.
There is already a reset button on the Arduino itself, but eventually I would like to put it all in a box (properly soldered of course)
and there would be no way to get to it.

Feel free to copy and paste it if you wish...I've tested it thoroughly and it is fully working.
(It's a pretty simple program really)

 

[GarethB]

Where are the pictures?

Flickr is being a bit rubbish at the moment...I'll post a couple in the first post when it lets me!

Oops...just realised that I have my album set to private!!!
That's what you meant, so sorry!!

Just reset it to public, should be able to see them now.

 

[GarethB]

It's probably a good time to get cracking on some woodwork and putting together a support structure.

I had a load of lengths of wood left over from a previous DIY project, and a load of nuts and bolts.
I'm sure my support is overkill, and anything fairly strong would do...I've seen some use just tables or chairs.
(The leftover wood was what I had after building the mini stage area that the support is stood on!)

Below is the upper section that supports the Mariotte syphon.

I mounted the valve with M4 bolts through a block of wood - the valve has two M4 threaded holes in it...handy.
I plan to expand to a triple valve system soon...so I gave myself plenty of space to mount another two valves either side of the one pictured.

Below is the bolt used to secure the valve. It also allows the valve to rotate.

When I install the other two valves, they will rotate like this, so that the drops can line up and collide at just the right position.

Below is the (crude) method I chose to build in some kind of height adjustment...it's not pretty but it works!

Wing nuts for easy take down...

The diffuser is made from an old sheet of perspex, which I 'scuffed' with an orbital sander to make it opaque.
Works pretty well.
Also shown are my cheapo Yongnou flashes!
Everything is low budget!!

 

[GarethB]

The Mariotte Syphon construction:

The main thing here is that I wanted an airtight plastic, see-through container, with a sealing lid.
I needed to have a nozzle at the bottom, which would be hot glued in place.
The flexible tubing would then attach to this and connect to the valve.
Again I want to expand to three valves, so in order to obtain the correct angles for the valves, I needed to have them able to move independently of the bottles...otherwise one could simply attach the valve directly to the Mariotte bottles, for a single valve system.

These plastic jars from Lakeland seemed to fit the bill...a little big perhaps...

I drilled a suitable hole and 'scuffed' the bottom for better adhesion with sandpaper, then hot glued the nozzle in
This is the 1/4" to 1/4" hosetail nozzle - the 8mm flexible tubing was not as tight as I would have liked,
so I applied lots of PTFE and all is well.
I'm still getting a tiny leak (from the glued joint), but it doesn't affect the operation...nothing that some kitchen roll can't fix!

Another hole in the lid, and a similar, generous application of hot glue secures the rigid pipe in place.

The glue hardened wonky, so the pipe isn't completely vertical...I don't think it makes a difference,
but the important thing is to have it roughly 2-3 cm above the level where the nozzle exits the bottle.

 

[GarethB]

Once all the tubing is connected (with plenty of PTFE everywhere) it's ready to fire up!

A quick word about timings and water mixes.

It's unlikely that there are two systems with the same dimensions (heights of valves etc)
so the time delays that I used are probably of limited use to anyone other than me, but for the record, some examples:

My valve is approx 51cm above the surface of the liquid in the drip tray (an old wine glass in this case)
(I apologise - the distance between the nozzle and the wine glass is actaully ~40 cm.
The above height was between the nozzle and the shallow plastic tray I was using - otherwise the timings are correct)

1st drop time - 30 milliseconds
2nd drop time - 18 milliseconds
delay between drops - 52 milliseconds
camera delay - 142 milliseconds

The 1st drop creates a nice tall 'Worthington Jet' (the bounced column of water)
The 2nd smaller drop creates a beautiful, thin 'parasol' as it hits the jet

The image below turned out better than I had hoped...the 'parasol' detached completely from the jet,
so it appears to hover!

IMG_0580 by Gareth Bellamy, on Flickr

For the water I first started with adding about a cupful of vegetable glycerin to a litre of water, but that began to get expensive.
So now I use Xantham gum. It can be bought in most supermarkets or health food shops.
I bought mine from Sainsburys, it costs a couple of quid, and it'll last for years.
You really don't need much...perhaps 1/4 teaspoon per litre of water.
I use hot water in a blender, dust the surface with the Xantham gum, then blend for a few minutes and allow to cool.
The mixture will need to be strained through something to filter out any bits (I used an old piece of bedsheet)
It isn't completely clear...just a touch opaque, but once I'm dripping, I can't even tell...it seems perfectly clear and has a smooth
consistency...a tiny bit thicker than milk.

I will be experimenting more with timings, more valves, mixes and adding food colourings too...who knows where it will go.
It's been great so far, it's everything I'd hoped for, for so long!

Well, that about wraps it up for now, I will post some images that were shot with my setup soon (Flickr is still misbehaving)

I hope I didn't make this seem too hard, it wasn't without its problems and glitches, but I was determined to make it work.
(And if it was all just instant success, I wouldn't have learned anything!)
I appreciate that experienced electronic engineers and programmers will maybe be a little perturbed at my methods!
I welcome any comments from those more experienced than me...I wouldn't have got this far without the excellent guides I have followed,
so I'm willing to learn better ways of doing things.
I've only just begun this journey into electronics and programming, and I feel positive so far...

I have lots of ideas for future builds...one is perhaps relating to sound triggers...stay tuned...

Thank you so much everyone for bearing with me and if you read all this then well done indeed!

 

[susiejb]

Wow Gareth you’ve certainly worked extremely hard creating that set up, well done to you. I had a dabble at this a couple of years ago for the 52’s but with nowhere near as much success as yours. Love the colours in that image, you’re going to have some fun now creating lots more, looking forward to seeing them, they fascinate me.

 

[GarethB]

Wow Gareth you’ve certainly worked extremely hard creating that set up, well done to you. I had a dabble at this a couple of years ago for the 52’s but with nowhere near as much success as yours. Love the colours in that image, you’re going to have some fun now creating lots more, looking forward to seeing them, they fascinate me.

Thank you so much Susie, you're too kind!

It was a fun build, though not without it's frustrations...and burns (zero soldering skills! )
The next few weeks will doubtless be full on experimentation, and when Flickr is mended I'll be sure to post some images here.
Thanks again for ploughing through all that....you did read it all didn't you?....there's a test you know?!

 

[Manxmaid]

Wow indeed, Gareth! When I suggested you wrote something about your set-up I never dreamed it would be so detailed and thorough! This is excellent and should become a great resource for the forum, and your results absolutely speak for themselves. Well done indeed, and thank you for taking so much time

 

[GarethB]

Wow indeed, Gareth! When I suggested you wrote something about your set-up I never dreamed it would be so detailed and thorough! This is excellent and should become a great resource for the forum, and your results absolutely speak for themselves. Well done indeed, and thank you for taking so much time

Thank you Andrea, for encouraging me to write it.
It could have gone on and on a lot more however!
I held back on some of the set backs I had...mainly due to me being a bit thick
Hopefully it might serve as a sort of guide, though it's not exhaustive.

I'm open to any questions though...I did a decent amount of research of all aspects of the build, like the best valves to use etc., which I didn't go into much detail about here.
I will update it when I learn or discover anything new on my journey.

 

[Marcel]

That is indeed an awesome guide Gareth, thanks for taking the time to share it with us
Would you mind if I added it to the Tutorials section?

 

[Fuji Dave]

Once all the tubing is connected (with plenty of PTFE everywhere) it's ready to fire up!

A quick word about timings and water mixes.

It's unlikely that there are two systems the same dimensions (heights of valves etc)
so the time delays that I used are probably of limited use to anyone other than me, but for the record, some examples:

My valve is approx 51cm above the surface of the liquid in the drip tray (an old wine glass in this case)

1st drop time - 30 milliseconds
2nd drop time - 18 milliseconds
delay between drops - 52 milliseconds
camera delay - 142 milliseconds

The 1st drop creates a nice tall 'Worthington Jet' (the bounced column of water)
The 2nd smaller drop creates a beautiful, thin 'parasol' as it hits the jet

The image below turned out better than I had hoped...the 'parasol' detached completely from the jet,
so it appears to hover!

IMG_0580 by Gareth Bellamy, on Flickr

For the water I first started with adding about a cupful of vegetable glycerin to a litre of water, but that began to get expensive.
So now I use Xantham gum. It can be bought in most supermarkets or health food shops.
I bought mine from Sainsburys, it costs a couple of quid, and it'll last for years.
You really don't need much...perhaps 1/4 teaspoon per litre of water.
I use hot water in a blender, dust the surface with the Xantham gum, then blend for a few minutes and allow to cool.
The mixture will need to be strained through something to filter out any bits (I used an old piece of bedsheet)
It isn't completely clear...just a touch opaque, but once I'm dripping, I can't even tell...it seems perfectly clear and has a smooth
consistency...a tiny bit thicker than milk.

I will be experimenting more with timings, more valves, mixes and adding food colourings too...who knows where it will go.
It's been great so far, it's everything I'd hoped for, for so long!

Well, that about wraps it up for now, I will post some images that were shot with my setup soon (Flickr is still misbehaving)

I hope I didn't make this seem too hard, it wasn't without its problems and glitches, but I was determined to make it work.
(And if it was all just instant success, I wouldn't have learned anything!)
I appreciate that experienced electronic engineers and programmers will maybe be a little perturbed at my methods!
I welcome any comments from those more experienced than me...I wouldn't have got this far without the excellent guides I have followed,
so I'm willing to learn better ways of doing things.
I've only just begun this journey into electronics and programming, and I feel positive so far...

I have lots of ideas for future builds...one is perhaps relating to sound triggers...stay tuned...

Thank you so much everyone for bearing with me and if you read all this then well done indeed!

WOW!!! Gareth a great and detailed account and typed out very well, and that image is just fantastic imo.

 

[GarethB]

That is indeed an awesome guide Gareth, thanks for taking the time to share it with us
Would you mind if I added it to the Tutorials section?

Wow...really?
I would feel honoured and proud, thank you so much Marcel!!

 

[GarethB]

WOW!!! Gareth a great and detailed account and typed out very well, and that image is just fantastic imo.

Thank you most kindly Dave, very kind words indeed.

 

[Baloo]

Awesome project you have come up with, will put it on my to do list. Top Stuff.

 

[GarethB]

Addendum:

Changes made to this guide​

• Images added to front page
• Added information and images about the Canon N3 shutter release cable
• Added information and images about the general cabling and connectors.
• Added a section at the end detailing nozzle issues and fixes.

​

I think I should briefly talk about nozzles.

I had some trouble getting small ones with the correct threads, and eventually bought some from a local plumbing supply warehouse.
The problem is with the solenoid valve threads.
They are 1/4" NPT (National Pipe Thread) and are mainly used in the USA.
In the UK, the only nozzles I was able to get were 1/4" BSP (British Standard Pipe).

They are almost the same...there is a one thread per inch of difference, which means that I can screw the nozzles about 3 or 4 turns before they wedge in.
Normally I would have (hoped) preferred them to seat all the way in, but with plenty of PTFE, I was able to make a water tight seal.
This is not a high pressure system, and I empty the Mariotte syphon and valve after every use, so it shouldn't be a problem.
It's not ideal, but it goes with the territory when buying the cheaper Chinese valves, which are otherwise excellent.

The valve of choice (no budget constraints) would be the Shako PU220AR solenoid valves, which are supposed to be excellent, but can cost a minimum of £40 each, delivered direct from Shako, with the right specs!...including the correct BSP thread - LINK

Another thing worth mentioning regarding nozzles....the smaller the nozzle, the better and more controllable the drop.
I was able to find 1/8" nozzles which are quite small...the smallest I could find anywhere.

Shown below on the left.

The 1/4" nozzles are a lot easier to find....Machine Mart...Amazon etc.
These can be 'necked down' using bits of flexible tube...

This is simply a piece of 8mm tube, with a piece of 3mm tube squeezed inside it.
It's not as small as the 1/8" nozzle, but would be good in a pinch.
I haven't tested it yet, but I have no reason the think that it won't work.

That's all for now folks...

 

[Chenti]

This is great, well done. I had a dabble a couple of years ago and I had a very manual process of squeezing an eyedropper and hitting the remote trigger by guesswork. was fun to do though I've been thinking about going electronic to improve my hit rate. tempting to go the DIY route now I've seen your example....

 

[GarethB]

Awesome project you have come up with, will put it on my to do list. Top Stuff.

Thanks Roger, best of luck!

This is great, well done. I had a dabble a couple of years ago and I had a very manual process of squeezing an eyedropper and hitting the remote trigger by guesswork. was fun to do though I've been thinking about going electronic to improve my hit rate. tempting to go the DIY route now I've seen your example....

Indeed @Chenti I know how frustrating the 'pinhole-in-a-bag' can be...I spent the best part of a year trying to get a drop collision with that method!
Never succeeded once!!

I got some nice images...but the collision images seemed impossible to me...although it is possible to do with patience...
Check out @RyanB images HERE - he didn't use any fangled device for these, and they're pretty ruddy good!!

 

[GarethB]

Addendum II

Connecting the power supply and the solenoid

The power supply that I bought (listed on the first page) has a number of connectors supplied with it.
I chose to use the 2.1mm barrel type connector - it's a standard one that a lot of devices use.
These connectors are attached to the power supply via a two pin connector.





Its important to have the correct orientation.
For this project I used the centre pin as the positive, so I lined up the appropriate side like so...



The way I connected this to the circuit was using the 2.1mm barrel socket.



It has one long leg and one short one...for this circuit I used the short leg for the positive...this is the central pin again



Then I gently bent the legs apart, so that when the croc leads are connected I wouldn't get any shorts.



The croc leads are attached.

 

[GarethB]

And the power supply is connected to it.



Now onto the solenoid valve.

The AirTac valves that I use, came without any wires...some valves do come with wires connected however, but it's quite simple to connect them if they don't.



Undo this screw on the top of the plastic housing...





Then separate the two sections.



Prise off the cover plate with a screwdriver.



These are the two terminal clamps - the positive (red) is on the right in my case...it doesn't matter which way round you connect it however, it will work either way round, but there is an tiny LED inside that will light when the valve is activated, and this will only work when connected the way I did.
There are no markings either, so for me it was trial and error.



Here's where having a few old lengths of wire lying around really came in handy.
I stripped the ends...

 

[GarethB]

...and gave them a twist...



Then inserted them into the clamps and tightened down the screws.
Positive (red) is on the right...so my LED will light.



Now to feed the wires back through the plastic housing.



And make sure it's orientated like this, so that the cylindrical section on the left does not cover the valve orifices.



Nice and neat, and the wires are routed away from the valve orifices



Now both the power supply and the solenoid valve can be connected to the correct places on the breadboard using croc leads and jumper wires.

This should work fine if care is taken not to jostle the wires around, but of course it will be better to make a more permanent version, which will be sturdier and safer.
This should only be considered just for the prototyping and testing stages.

 

[RyanB]

Thanks for sharing this awesome guide Gareth, so thorough even I 'might' be able to get it to work. Going to start getting the bits and pieces together and make it a project for my daughter and I to do over half term, should keep both of us entertained hopefully. (and keep my shutter count from breaching 500k to get a few collisions)

 

[GarethB]

Thanks for sharing this awesome guide Gareth, so thorough even I 'might' be able to get it to work. Going to start getting the bits and pieces together and make it a project for my daughter and I to do over half term, should keep both of us entertained hopefully. (and keep my shutter count from breaching 500k to get a few collisions)

You're most welcome Ryan, and thanks for the kind comments.
If there's any questions regarding anything I wrote here, please feel free to ask here or send me a PM.
I'll be updating this thread regularly with refinements etc, so if I discover better ways of doing things, I'll post them here, and link them from the main contents on page 1.

Sounds like it could be an awesome half term project...best of luck, I'm sure you'll have fun!

 

[RyanB]

You're most welcome Ryan, and thanks for the kind comments.
If there's any questions regarding anything I wrote here, please feel free to ask here or send me a PM.
I'll be updating this thread regularly with refinements etc, so if I discover better ways of doing things, I'll post them here, and link them from the main contents on page 1.

Sounds like it could be an awesome half term project...best of luck, I'm sure you'll have fun!

Thanks that would be most appreciated as I am pretty inexperienced with electrical work, had to google like hell to figure out what all the components do but I think I have the gist of it now. I'm sure there will be a few hiccups along the way but that's all part of the fun.

 

[GarethB]

Project Updates.

It's been a little while, so I thought I'd get up to date as to where this project is and where it's going.

When I first decided to build a water drop controller, I originally wanted it to be nice and neat, in a box with buttons and control knobs.
I have recently taken a step closer to this goal.
I thought it was going to be way too advanced for me, but it turned out to be not too bad....I was forced, however, to break out the soldering iron!
My soldering isn't pretty, but it works!

So, the plan is to have a set of four control knobs to adjust the time delays 'on the fly' and so that the whole controller can be independent of a computer, since at the moment it will only work when powered through my old laptop, and I am only able to adjust the time values using the serial monitor through the Arduino IDE software.

I also wanted to see the time delay values as they are adjusted, so I will need some sort of display.

And finally, because the Arduino UNO is rather bulky, and is only really suitable for prototyping with a breadboard, I wanted to use a much smaller version of the Arduino, but with the same functionality.

This is what was needed:

• 4 X 10 kilo ohm linear potentiometers - these are rotary adjustable resistors, used to vary the time delay values. - BITSBOX LINK
• A 16X2 LCD display panel - used to view the adjusted time delay values. - BITSBOX LINK
• An Arduino NANO - a tiny version of the Arduino micro controller (PCB headers are included in the ones I bought) - AMAZON LINK
• A length of trimmable PCB header - this is to solder to the LCD screen, so that it can be connected to either the breadboard or the PCB when I get to that stage. - BITSBOX LINK
• Another, larger breadboard, it's getting quite large now!! - BITSBOX LINK
• A soldering iron and some leaded solder....and some patience!!

Here is the complete, working prototype on (a few) breadboards.
The nearest breadboard has the original circuit, which is essentially unchanged, except that I've added a start button so that it doesn't cycle the drop program continuously.

This next pic shows the Arduino Nano....you can see how small it is - it's amazing that it can do exactly what the bigger UNO board can do.
It does, however, need to be set up correctly in the Ardiuno IDE software - CLICK HERE - to see the page on how to do it.
This needed to have the header pins soldered to it, to allow it to be mounted to the breadboard and later to the PCB.
My soldering is not very pretty, but it works!

Next is the LCD display that I'm using...it's a bog standard, dirt cheap 16X2 LCD screen, compatible with the Arduino libraries.
I needed to buy a length of standard PCB header and solder it to the LCD, again to mount to the breadboard and later the PCB.

If you are a professional electronic engineer, I urge you to look away now!!!
This pic shows a close up of some rather dodgy soldering!!
Oh well....practice makes perfect....maybe!

Next is a pic of the 10K potentiometers, or 'pots' as I believe they are called by the pros!
They are essentially variable resistors - at one end of their travel they have very low resistance, and at the other end they have 10 kilo ohm resistance.
I will use these to vary the time delays, and the Arduino will read the analogue resistance values from the pots, and translate them into a digital signal that is then fed back into the controller to change the time delay.

It works!!
This pic shows the LCD with the time delay values that I can change on the fly using the potentiometers
The top line shows my abbreviations:

• D1 - 1st drop size
• D2 - 2nd drop size
• DD - drop delay, this is the time between the two drops
• CD - camera delay, the time delay between the last drop and the camera firing.

I had to make some tweaks in the program so that I would get meaningful and accurate readings since all the values are in milliseconds.
I found that without some programming adjustments, you need only breathe on the pots to change a value....they were far too sensitive.

 

[GarethB]

And now for the revised code.

Paul McWhorters guides on Arduino programming really helped me out here - I highly recommend checking them out if you're a beginner Arduino programmer like me.
You can find his guides HERE

This will likely look like a mess to those who are not used to looking at code....it did to me!
In fact if you are an experienced programmer, it will probably still look like a mess!!

Note that all the bits that are preceded by a // (double forward slash) are not read by the Arduino - they are simply notes written by the programmer (me in this case) to help the reader understand what bits of the code do which actions.

/*Water Drop Controller V5
* LCD screen added
* Potentiometer (X4) added to enter time values for drop sizes and camrera/solenoid delays
* Start button added
* By Gareth Bellamy
*
*/

#include <LiquidCrystal.h>         //open LCD library
LiquidCrystal LCD(10,9,5,4,3,2);   //LCD to use pins 10, 9, 5, 4, 3, 2

const int solPIN = 7;              //assign pin 7 to solenoid
const int camPIN = 6;              //assign pin 6 to camera
const int potONE = A1;             //assign pin A1 to potentiometer 1
const int potTWO = A2;             //assign pin A2 to potentiometer 2
const int potTHREE = A3;           //assign pin A3 to potentiometer 3
const int potFOUR = A4;            //assign pin A4 to potentiometer 4
const int startBUTTON = 11;        //assign pin 11 to startBUTTON

int solDEL;                        //declare solDEL variable
int camDEL;                        //declare camDEL variable
int dropONE;                       //declare dropONE variable
int dropTWO;                       //declare dropTWO variable

int dropONEval;                    //declare dropONEval variable
int dropTWOval;                    //declare dropTWOval variable
int camDELval;                     //declare camDELval variable
int solDELval;                     //declare solDELval variable

int buttonSTATE=HIGH;              //set buttonSTATE variable to HIGH

void setup() {

  pinMode(solPIN, OUTPUT);          //set solPIN to output
  pinMode(camPIN, OUTPUT);          //set camPIN to output
  pinMode(potONE, INPUT);           //set potentiometer 1 as input
  pinMode(potTWO, INPUT);           //set potentiometer 2 as input
  pinMode(potTHREE, INPUT);         //set potentiometer 3 as input
  pinMode(potFOUR, INPUT);          //set potentiometer 4 as input
  pinMode(startBUTTON, INPUT);      //set startBUTTON as input

  LCD.begin(16,2);                  //start LCD with column/row parameters
  LCD.setCursor(0,0);               //set cursor position as 0,0 - top left
  LCD.print("D1  D2   DD  CD ");    //print the line "D1  D2   DD   CD" note spaces, whole line must not exceed 16 chars, Inc spaces


}

void loop() {

  dropONE=analogRead(potONE);               //read analogue value from potentiometer 1
  dropONEval=dropONE/(10.);                 //divide dropONE value from potONE by 10 to increase accuracy
  LCD.setCursor(0,1);                       //set cursor position as bottom left
  LCD.print(dropONEval);                    //print the calculated time value dropONEval

  dropTWO=analogRead(potTWO);               //read analogue value from potentiometer 2
  dropTWOval=dropTWO/(10.);                 //divide dropTWO value from potTWO by 10 to increase accuracy
  LCD.setCursor(4,1);                       //set cursor position as bottom line, 4 characters from left
  LCD.print(dropTWOval);                    //print the calculated time value dropTWOval

  solDEL=analogRead(potTHREE);              //read analogue value from potentiometer 3
  solDELval=solDEL/(5.);                    //divide dropTHREE value from potTHREE by 5 to increase accuracy
  LCD.setCursor(9,1);                       //set cursor position as bottom line, 9 characters from left
  LCD.print(solDELval);                     //print the calculated time value dropTHREEval

  camDEL=analogRead(potFOUR);               //read analogue value from potentiometer 4
  camDELval=camDEL/(5.);                    //divide dropFOUR value from potFOUR by 5 to increase accuracy
  LCD.setCursor(13,1);                      //set cursor position as bottom line, 13 characters from left
  LCD.print(camDELval);                     //print the calculated time value dropFOURval

  LCD.print("                ");            //print a blank line (16 spaces) to keep LCD clean

  buttonSTATE=digitalRead(startBUTTON);  
    if(buttonSTATE==LOW) {                    //Wait for start button to be pressed before continuing

    digitalWrite(solPIN, HIGH);               //set solPIN to HIGH - open the solenoid for first drop
    delay(dropONEval);                        //delay for time value dropONEval - first drop size
    digitalWrite(solPIN, LOW);                //set solPIN to LOW - close the solenoid

    delay(solDELval);                         //delay for time value solDELval

    digitalWrite(solPIN, HIGH);               //set solPIN to HIGH - open solenoid for second drop
    delay(dropTWOval);                        //delay for time value dropTWOval - second drop size
    digitalWrite(solPIN, LOW);                //set solPIN to LOW - close the solenoid

    delay(camDELval);                         //delay for time value camDELval - delay between second drop and camera activation

    digitalWrite(camPIN, HIGH);               //set camPIN to HIGH - trigger camera shutter
    delay(100);                               //delay for 100 milliseconds to ensure clean signal
    digitalWrite(camPIN, LOW);                //set camPIN to LOW - reset shutter button


  }
  else{
    digitalWrite(camPIN, LOW);              //set camPIN to LOW - reset pins
    digitalWrite(solPIN, LOW);              //set solPIN to LOW - reset pins
  }
}

This is fully tested and working.
The values can now be changed independent of a pc (providing a power source is connected to the Arduino Nano board - details later)

 

[GarethB]

Connecting the Arduino to a battery with a Buck Converter.

In order to be completely independent of a PC, it's necessary to power the drop controller via a battery.
(I will later implement a mains power source too, but I wanted it to be completely portable.)

To do this I used a DC/DC step down buck converter.
I bought mine from amazon, they came in a pack of six for only £8.99 - AMAZON LINK

This device can take any input voltage from 3 volts to 40 volts, and outputs a steady, regulated voltage of ones choosing (as long as it's between 1.5 volts and 35 volts)
The PP3 battery has a voltage of 9 volts, and I wanted to have a voltage of 5 volts to power the Arduino.
(I could have connected the battery straight into the Arduino, - it will take an input voltage of between 3 volts and 12 volts - but I want to play it safe - the buck converter is fully regulated, which means it's steady, consistent and reliable)
By turning this tiny screw (arrowed), I am able to adjust the output voltage to 5 volts, and then it's simply a case of just connecting it to the right pin on the Arduino.

A simple PP3 connecter I robbed from an old device which I used to connect the buck converter.
The wires on the other end will connect to the Arduino pin on the breadboard.

Here is the V in pin on the Arduino (arrowed)

...and a close up...
(it's upside down, but you can see that it says Vin....that's 'Voltage in')

This 9 volt battery provides enough power for both the Arduino board (through the buck converter) and the solenoid valve too - even though the solenoid valve is 12 volts....seems to work fine.
So I should be able to put it all in a nice, neat box....which I will be making very soon, and have it be completely portable.

 

[Leebert]

What a fantastic guide Gareth I feel some online shopping coming on

I have only had limited success with a pipette and a large portion of luck. I look forward to some more consistent results with this circuit when I build it. I can't get my head around how companies are able to produce these Arduino devices for

 

[GarethB]

What a fantastic guide Gareth I feel some online shopping coming on

I have only had limited success with a pipette and a large portion of luck. I look forward to some more consistent results with this circuit when I build it. I can't get my head around how companies are able to produce these Arduino devices for

Thanks Lee, I really appreciate your comments!
I understand fully how frustrating the pipette technique can be....my first technique wasn't even as sophisticated as that!!!
I started with the pinhole-in-a-bag technique...got some nice-ish images, but never a drop collision!
Fortunately I'd recently heard about how versatile Arduinos can be, and when I found out how expensive the commercial drop controllers are, I thought that it was the logical thing to do.
It's been a steep learning curve, but worth it in the end.

Good luck with your project Lee, and if you need any help with anything, let me know...I'm no expert, but I'll try to assist any way I can.

 

[Leroy4bz]

Wow great tutorial, although it was still way above my head. I went the Splashart kit route. I’m now ion my second one as I stored the first incorrectly and the solenoid developed a leak. I do want to replace the valve but once I found one I was bambuzzeled by the thread size and other options. Could you tell me where you got the 1/8 nozzle? So I can get the old one up and running, so I could have 2 different setups without changin* nozzles.

 

[GarethB]

Hi Leroy, thanks for taking the time to read and comment.
The Splashart kit is a very decent setup, and reasonably priced too.
It uses the Shako PU220 valve doesn't it?...the 'Rolls Royce' of precision drop valves!

The 1/8" nozzles that I use, were bought from a local hydraulic/plumbing supplies business in Norwich, near where I live.
The link to their hose-tail product page is here:

http://www.parkerhydraulics.co.uk/industrial/hose-tails/brass-male-hose-tails/

Unfortunately they don't seem to have any online purchase system, I think they primarily cater for trade.
I walked in to their business and paid cash for mine (approx £2.50 each)....
....not sure if you could ring or email them to place an order, but I'm sure there would be similar suppliers local to you.

Their part number is GT13/04K, which is a 1/4" male BSPT thread with a nozzle of 1/8" - the 'T' on the end is for 'tapered' thread.
(The tapered thread shouldn't be a problem with these low pressure systems....plenty of PTFE tape and it should seal up fine)

I had similar problems with thread types too....gets confusing fast!!
Suffice to say that I have learned there are two main types:

BSP - British Standard Pipe - primarily UK​

NPT - National Pipe Thread - primarily USA​

Since the Splashart kit is manufactured for (in?) the UK, I'm assuming your Shako valve has the 1/4" BSP thread, which makes life a bit easier.
(My cheapo Chinese valves are NPT, which is almost the same - one thread per inch difference- so I had to use a lot of PTFE tape to seal it properly - but it works)

The smallest nozzle I was able to find on Amazon is 6mm, which is about 1/4"...smaller would be better though.

If you have trouble getting 1/8" nozzles, there's a way to 'neck down' a 1/4" nozzle.
I stole got the idea from Martyn Curreys excellent guides on building drop controllers.
He talks about using various diameter tubes/drinking straws to reduce the nozzle diameter.

Click here for the link to his page....about half way down

I have tried something similar....

Click here to go straight to my post

I haven't had a chance to test it yet, but I see no reason why it wouldn't work well.

Best of luck Leroy, sorry about rambling on....this post got very wordy fast!!

 

[Leroy4bz]

Thank you Gareth for your detailed response ( not a ramble, just good advice) . I now have a bit more understanding of what I need. After checking Martyn’s site, I might have a go at cleaning the old head.

 

[Picareto]

=Here is the complete, working prototype on (a few) breadboards.
The nearest breadboard has the original circuit, which is essentially unchanged, except that I've added a start button so that it doesn't cycle the drop program continuously.

Thank you so much Gareth.....this project is really great!! I pretend to do it but i think i will trigger the flashes instead of the camera.....i will not need to do any changes to the original project...am i right? ...its only connect the remote flash trigger to the point where it suppose to be the camera conected.?
Can i ask you to clarify the diagram on this last update??....cause i did not understand the potenciometer connections and the lcd too.Is that possible to you to make some new diagram with all the connections?? Thank you very much.
Best regards from Portugal.
All the best.

Sérgio

 

[GarethB]

Thank you kindly Sérgio!

I think you should be able to substitute the camera for a flash without any changes to the circuit.
I would however, recommend researching your flashes, to make sure that the triggering works for them.
The triggering for my Canon 7D is very simple....it connects the trigger wire to ground, which activates the shutter.
Providing your flash triggers the same way, I see no reason why you can't swap the camera for a flash in the same circuit.

A very helpful guide is the one published on Petapixel by Ted Kinsman.

This guide shows how he connected a flash rather than a camera to a very simple Arduino water drop controller.
It's a guide that I found immensely helpful when I first built my simple controller.

You can find it HERE

Hope this helps Sérgio, best of luck!
Gareth.

(I'll put the diagrams for the potentiometer and LCD circuits in the next post.)

 

[GarethB]

LCD screens and how to connect them to an Arduino

I should probably go into a bit more detail about the way to connect the LCD screens.
(The previous chapter can be found HERE)
The photos I took earlier aren't very clear, so hopefully the following diagrams will be better to see what's going on.

Firstly I highly recommend reading and watching the tutorials by Paul McWhorter on TopTechBoy.com
Specifically lesson no. 19 where he introduces how to connect an LCD to an Arduino and make it work.

Click here for Arduino Lesson Number 19

I followed his guide very closely, and it worked very well with my LCD screens.
I believe that most 16X2 LCDs are the same and have the same pin layout, so it should work for most standard ones.

This first image shows the pin connections for the LCD screen.

The pin which says 'potentiometer centre pin' is the contrast control pin.
Connecting a potentiometer is optional however, because once you have set the contrast, you should never have to touch it again.
An alternative to a potentiometer is to use two resistors as a voltage divider - this is what I did.
After some trial and error I found that a 1KΩ resistor and a 5KΩ resistor worked well for me.

Here is what it looks like in diagram form:

Here is a table of the pins of the LCD, and which Arduino pins they connect to.
I sourced this information from Paul McWhorters lesson no. 19 on TopTechBoy.com, though it would be the same for any LCD of a similar type.

This next image is the datasheet for the LCD screen that I use - it was sourced from bitsbox.co.uk
And the link to the LCD page is HERE

Hopefully this is easier to follow than this...

But bear in mind that you will probably need to solder header pins to the screen, some may be supplied with the screen...mine were not however.
These are header pins....they can be trimmed to the correct number of pins to fit your LCD....in most cases it's 16 pins.
The product page for the header pins on bitsbox can be found by clicking HERE

Next....potentiometers....

 

[GarethB]

Potentiometers - how I connected them.

I use potentiometers (or pots from now on!) to vary the time delays for each drop and the delays between the drops and the camera firing, as discussed in a previous chapter HERE
Again, as the photos that I posted weren't terribly good, here is a diagram which I hope clarifies what's going on.

The pots that I used are small 10KΩ linear pots - linear means that they vary the resistance value evenly across the range of movement.
They were (as usual) sourced from bitsbox.co.uk.
The product page can be found HERE

You'll see that they are connected to Arduino pins with an 'A' prefix
These pins are analogue pins which are the only pins that can read an analogue input from...say...a pot.
It's the centre pin on each pot that generates the analogue resistance value that the Arduino reads through the analogue 'A' pins.
This resistance value is then turned into a number between 0 and 1023, which is sent to the digital pins that control either the camera or the solenoid valve.

Again, I highly recommend reading the guides by Paul McWhorter on toptechboy.com.
The relevant lessons on how to understand pots and Arduinos are lesson numbers 9 and 10

Lesson 9 is HERE
Lesson 10 is HERE

That's all for now folks.

Coming soon....some stuff about making a box for the controller out of plywood and a sheet of aluminium!