Crafts from idle HDDs - mini pump

    Somehow I needed a water pump for future home-made products. Yes, it’s not simple - with restrictions on dimensions - thickness up to 25mm, width up to 50mm (length - you can already vary). Of the desired characteristics - a pressure of 1m and a flow rate of 100l / h. Having not found what he wanted in sales (mainly in terms of size), in his obstinate stubborn nature he set about implementing his solution to this issue!

    Attention - a lot of photos!

    "Brains" and a little background:

    Strictly speaking, the idea of ​​using HDD motors for pumps is not new. Since 2009, a whole branch has been maintained at one well-known forum . So, it was originally aimed at manufacturing a pump from a “laptop” hard drive and finding a suitable driver with integrated power keys and sensorless control.

    But “out of the box” I could not learn from experience. A series of tests with different drivers (MTD6501C, DRV11873 and a number of other Chinese crafts) gave a disappointing result: larger motors from 3.5 drives work perfectly. But with small motors, at best, they manage to start units, and they work extremely unstably. With such a disappointing result, an old idea was abandoned and was on the verge of oblivion.

    But relatively recently I came across a rather interesting driver from TI -DRV10987 . With its modest dimensions, it has a rather impressive potential:

    • Operating voltage from 6v to 28v
    • Integrated 5v step-down converter (you can power the MK for control)
    • Constant operating current up to 2A (peak - 3A)
    • A huge number of software-defined parameters (setting the values ​​of configuration registers on the I2C bus) to control the operation of the motor
    • Automatic restart of the motor after an emergency stop / failure (if the conditions for the failure have passed)
    • Over current protection
    • Surge protection
    • Rotor stop / lock detection
    • Shutdown when the controller overheats

    Armed with an arduino (forgive me for this abusive word by local electronics engineers) to set the parameters made by the LUT board for this driver, I went deeper into experiments on starting motors. Well, this controller did not disappoint me! Despite the applied method of "scientific poking" in the selection of parameters, it was possible to find an approach to any motor from the HDD!

    Helped me in this self-made online settings configurator . Use on health!)

    Here is a sketch on pouring parameters through arduino:
    #define I2C_DRV10983_Q1_ADR 0x52
    #define Fault_Reg 0x00 
    #define MotorSpeed_Reg 0x01 
    #define DeviceIDRevisionID_Reg 0x08
    #define SpeedCtrl_Reg 0x30 
    #define EEPROM_Access_Code_Reg 0x31
    #define EEPROM_EeReady_Reg 0x32
    #define EEPROM_Iindividual_Access_Adr_Reg 0x33
    #define EEPROM_Individual_Access_Data_Reg 0x34
    #define EEPROM_Access_Reg 0x35
    #define EECTRL_Reg 0x60
    void setup() {
    byte readByAdress(byte reg_adr,  unsigned int &result) { //I2C write 2-byte register
        byte i = 0, err = 0;
        byte bytes[2] = {0, 0}; 
        err = Wire.endTransmission();
            return err;
        Wire.requestFrom(I2C_DRV10983_Q1_ADR, 2);
            bytes[i] =;
        result = ((bytes[0] << 8) | bytes[1]);
        return 0;
    byte writeByAdress(byte reg_adr,  unsigned int value) { //I2C read 2-byte register
        byte bytes[2]; 
        bytes[1] = value & 0xFF;
        bytes[0] = (value >> 8) & 0xFF;
        return Wire.endTransmission();
    boolean flag = true;
    void loop() {
            unsigned int onReady = 0;
            writeByAdress(EECTRL_Reg, 0xFFFF);
            writeByAdress(EEPROM_Access_Code_Reg, 0x0000); //Reset EEPROM_Access_Code_Reg
            writeByAdress(EEPROM_Access_Code_Reg, 0xC0DE); //Set EEPROM_Access_Code_Reg
            while(onReady == 0){ // Wait EEPROM ready
                readByAdress(EEPROM_EeReady_Reg, onReady);
            onReady = 0;
            //Write values on shadow registers
            //writeByAdress(EEPROM_Access_Reg, 0x1000); //Not use EEPROM storage. Store values in shadow registers
            writeByAdress(0x90, 0x154F);
            writeByAdress(0x91, 0x042C);
            writeByAdress(0x92, 0x0090);
            writeByAdress(0x93, 0x09EA);
            writeByAdress(0x94, 0x3FAF);   
            writeByAdress(0x95, 0xFC33);
            writeByAdress(0x96, 0x016A);
            writeByAdress(EEPROM_Access_Reg,0x0006); //EEPROM mass access enabled && update 
            while(onReady == 0 ){ // Wait EEPROM ready
                readByAdress(EEPROM_EeReady_Reg, onReady);
            writeByAdress(EECTRL_Reg, 0x0000); //Run motor
            flag = false;

    Then, more presentable shawls were ordered in the Middle Kingdom:

    After registration (well, this is what they require), you can download the project files for free. Or immediately order the boards here .

    About the "heart transplant"

    The only thing left is to get the motor out of the HDD enclosure, which by the way, in 2.5 disks (and in most 3.5) is an integral part of it. Briefly, the process can be described by the well-known phrase “ Saw, Shura, saw! ”: An

    external guide under the crown for metal with fastening to the disk case is made of plywood. For safety, the motor cable is glued to its base so that it is not cut off with a crown.

    After drilling, we get rounds with a motor. After file processing, we obtain a base diameter of about 25 mm.

    Preparation of the recipient for transplantation:

    The brains and heart of the future pump get along well with each other and are ready to find a new habitat. So it's time to think about the casing and the impeller.

    Since it is necessary to obtain high pressure with a small working volume, the impeller was designed with 7 rays:

    Printing on a 3D printer with polycarbonate The
    3D model

    Polycarbonate is an excellent thing for the case. But printing the whole building is expensive for them. Pieces of thick sheets are very difficult to find and milling is not free (for me). But for the thanks to the advertisers, you can beg for scraps from sheets 4 mm and 2 mm thick. So the case was designed for subsequent laser cutting of parts and their gluing into a single unit without the need for milling. Only drilling holes for fittings and nuts is required.

    View of a 3D model
    3D model

    A set of parts for gluing the "top" of the pump. In the places where the channels of the inflow and outflow are connected, the faces

    Operation progress:

    Here I would like to make a digression and remind those who wish to repeat, and not only that the dichloroethane, which was glued together, contains few vitamins and you need to inhale a rather toxic and volatile substance. Work with it should be carried out either outdoors or in a well-ventilated area.

    The stack of “top” parts on drying after gluing is the top-inflow-separator-impeller-rotor. Similarly, the base for the motor is glued together (or made entirely from a 6mm piece of polycarbonate)

    After gluing, holes for the fitting are drilled - an 8mm brass tube through the notches on the “separator”


    The base of the motor at the bottom of the pump is glued with the same glue. In the upper part, holes ( not through and through!) Are drilled for gluing M3 rivet nuts. And the photo shows a thin silicone gasket


    So the time has come to check the homemade work. For this, a test bench was hastily assembled. Since serious developers read the Habr’s children , whose appearance and composition of the stand can cause bouts of panic, horror and disorientation, I wanted to hide it under a spoiler ... but I hope everything will work out, and then don’t say that I didn’t warn you, dear readers !

    Arduinka sends a control signal PWM, the duty cycle of which is set manually by a variable resistor, reads the value of the configuration registers, and also determines the rotation speed both through the internal driver registers (RPMrg) and the signal FG (RPMfg). Motor Power - 12v

    Starting the motor without load. Speed ​​control and power consumption metering The

    motor starts successfully from 6% of the PWM control signal. And at the end of the video you can see how at high speeds the speed values ​​in the internal register “hang” in the interval from 10k to 13k revolutions, although the frequency is fixed through the FG output unchanged.

    Idling, everything is clear - they got 13k revolutions at a voltage of 12v and a consumption of 0.16A. But a water pump was going, and here I am chasing the air. So the next stage is escorting household members to the street, so as not to interfere, and the occupation of the bathroom!

    Alas, I failed to take measurements and shoot videos. So let’s get by with a general photo. A stopwatch and a 3L can were added to the measuring equipment.

    Based on the measurement results, we got such a table

    Schedule of consumption

    As a result, this craft entirely satisfies my requirements. And in the event of a breakdown, thanks to the collapsible design and the presence of boxes with dead 2.5HDD in any repair shops / service centers, it will not be difficult to repair. And the path to the further construction of the NWO is open! So to be continued!

    Also popular now: