Apologies for multiple posts, but I’d like to offer the whole project in one hit to make it easy for others to follow should they wish to do so. Hope it’s of interest.

Preamble…

Having owned my ML7 for some 30+ years I learned to live with the vagaries of the spindle drip lubrication system. However, fitting an inverter and 3ph motor and running it at higher speeds set me wondering if such hit and miss lubrication was adequate.

After much pondering I came up with the idea of using a peristaltic pump driven by a stepper motor turning X number of steps to deliver a metered quantity of oil to each bearing, the stepper timing being controlled by an Arduino. After several prototypes and may hours of testing, it worked to a degree but I wasn’t happy with the repeatability nor my ability to write code for the Arduino.

At this point I turned to a very good and long suffering friend who, to say the least, is a bit of a whiz when it comes to programming. Mark had previously helped me sort out problems I was having with my electronic lead screw by writing software that counted encoder pulses and highlighted when the system was picking up spurious signals … a fantastic bit of work without which I’d have never got the system working accurately.

Now with some brains on the project things could progress to add more features and allowing a change to DC motors (although we have retained the code for stepper motors if people wish to use them). This is a relatively cheap, fully automated, oiling system which I believe solves most of the problems people experience with mechanical oilers.

The system is basically as follows … An Arduino controls two motors which drive two separate peristaltic pumps. The pumps draw from a small oil tank and pump oil to two sight glasses mounted on each spindle bearing. A thin pipe at the top of the sight glass drips oil into the bearing and triggers a photo interrupter (PI) sensor to confirm that the bearing has been oiled. The system will give an alert if no drip has occurred.

Above are all the components which comprise the system. It should be possible to build this for less than the cost of new manual oilers.

The system can work in three modes …

1) Oiling frequency irrespective of the lathe running. Whenever the Arduino is powered up a drips occur at a preset time interval until power is switched off. This is default mode and relies on the operator remembering to switch it on and off.

2) Oiling based on the lathe running. A signal to the Arduino whenever the lathe starts and stops initiates drips at a preset time interval. This set up will require the lathe to have both an isolator switch and a start/stop switch. Turning on the isolator also powers the Arduino which does an initial drip prior to the lathe running. It then operates at a preset time frequency based on whenever the lathe is running.

3) Oiling frequency based on lathe rpm. An isolator and a start/stop switch are required for this mode which again allows for oiling prior to the lathe being started. A tachometer or encoder is required or a PI sensor similar to the drip sensor can be used. With this mode drips are delivered based on a preset number of spindle revolutions so the faster the spindle is turning the more frequent the drip. This is the system I’ve built.

The system has an alert function which triggers if a drip is not detected after a preset number of seconds or revs.

Number of drips per cycle can be preset.

If required the Arduino sketches can control up to 6 motors.

Below are photos and brief explanations of the system I built. I employed the use of a 3D printer, but it would be quite possible to build a system using alternative components such as hobby electronic boxes and to fabricate the pump to motor adapter.

A full down load of Arduino sketches, software to write sketches, an in depth wiki explaining the Arduino library, electrical schematics, .stl files for 3D printing and a BOM can be made from on Marks GitHub at …

https://github.com/naylom/OilerLib

All the code on GitHub is freely available without restrictions on use.

Edited By Julian Palmer on 13/09/2021 21:05:38

Edited By Julian Palmer on 13/09/2021 21:09:56

PI sensors and cables …

I used USB cables as these have the correct number of cores, are cheap and are readily available as are the sockets into which they plug. The PI sensors are ref number H92B4 also readily available on eBay. To pre-empt questions… yes they seem to work just fine doused in oil.

Wires were soldered to the PI sensor and it was then potted with hot melt glue using a simple mould machined out of a suitable plastic. Be careful not to use too much glue when potting as it’s possible to fill the sensor completely and obscure the LED and photo transistor. If you buy fabric braided cable, putting a drop of superglue on the braid before cutting keeps everything neat and tidy until you pot it.

Oil tank …

The oil tank in my design is made from 20mm acrylic tube glued to a printed manifold and the assembly glued on to the motor housing. Making it separate to the housing made for easier printing.

Brass hose tails were turned with an M5 thread, heated up and screw into M5 modelled threads in the manifold. If you get the temperature right and don’t mess them around whilst cooling, this fixing method forms an exceptionally strong and oil tight joint.

A press fit lid was printed to cover the top of the tank.

I had considered other ways of making an oil tank. Top of the list was a Tic Tac sweets container which is transparent and has a ready made cap. It seemed a little large so I made my own, but the idea may be of use to those without a 3D printer.

Pulsed signal for spindle revs …

This is only required if using “work done” mode. On my system I used a spare phase from a spindle driven encoder fitted for my electronic lead screw. However for completeness and to assist others who may be interested in implementing the “work done” mode I made a quick lash-up of an encoder using the same PI sensor as used to monitor the oil drips and tested it with Marks Oilerlib sketch to in excess of 1200 rpm. The total cost is probably no less than a couple of quid depending on materials to hand.

My version really was a lash-up using a hose clip, a bit of bent aluminium clamped to the collar on the left of the spindle ‘V’ pulleys and I used the mould I made for potting the PI sensors and a G clamp on the front edge of the head stock casting.

A far more elegant solution could be fabricated with a custom made clamp round the spindle. The sensor would be better located behind the spindle where there is more space and bracketed off the casting which supports the counter shaft, down here…

Motor 1 tab

This first page defaults to a DC motor but at the top is an option to set up a 4 pin stepper motor if preferred.

‘Inputs Pin#’ is the pin to which you’ve connected the output from the PI sensor pertaining to motor 1.

‘Inputs PinMode’ selects INPUT or INPUT_PULLUP. The electrical schematic shows a pull down resistor so INPUT is appropriate, but if you are using an alternative circuit internal pull up resistors can be set here if required.

‘Inputs # Drips to stop motor' is pretty self explanatory, it’s the number of oil drips required from this motor each time it oils.

‘Inputs Debounce time (ms)’ This setting determines the minimum number of milliseconds required between valid signals from the Photo Interrupter. By setting a minimum value, it prevents duplicate or spurious signals implying a drip has occurred when it hasn’t. If for any reason you find that one drip is being recorded as multiple drips this value can be increased.

‘Outputs Pin 1#’ is the out put pin which drives the relay to operate motor 1

Edited By Julian Palmer on 13/09/2021 21:51:50

Alert tab

‘Alert pin#’ sets which pin gives the alert signal.

‘Level held at during alert’ dictates how the pin behaves. High means it out puts 5v in alert condition and low means it sits at 5v all the time there is no alert, dropping to 0v in alert condition.

‘Alert threshold’ sets the number of seconds or revs (dependant on later configuration) should pass between the start of an oiling operation and the alert being triggered. Be aware that the pumps will take time to produce a drip so don’t set this number too low or the system will trigger the alert before the drip has occurred.

Final tab

‘Set Motor Restart Mode’. Here you set the event that triggers motors to (re)start oiling. Not all options will be visible depending on previous settings, but the three options are:

‘On elapsed time (secs)’. Default mode, where the system restarts the motors after a configured number of seconds. Irrespective of what the lathe is doing.

‘On powered time (secs)’. System counts seconds that the lathe has been running and when this hits the configured limit it restarts the motors

‘On machine work (units)’. System restarts the motors after a configured number of revolutions of the lathe spindle.

Select whichever mode you are using then, in the ‘Threshold’ box, enter the number of seconds or revs. between oiling operations.

And finally ‘Sketch pathname’. If you have the Arduino IDE installed, then it will attempt to create the sketch in a folder called OilerBuilder in the standard Arduino sketch directory (i.e. in the same place the Arduino IDE normally stores sketches).

If this cannot be found it will create the OilerBuilder sketch in the temp directory.

You can change the path to another destination if you wish.

That should be it, click ‘Create Sketch’ and open the file. You should have a sketch similar to this …

Upload it to your Arduino and things should spring into life.

You can change any of the #define parameters in the sketch. Each has a description of its purpose. Alternatively you can make changes in OilerBuilder application and create another sketch which will overwrite the first.

In the time I’ve been running the completed version of this system it’s worked well. I’d welcome any suggestions, improvements and corrections.