Lawn Sprinkler

Introduction

The idea is to create a simple 3D sprinkler design controlling the flow from a garden hose in 3D style with two motors. For a proof of concept we start with one motor.

Please find below how the project made progress so far.

Parts List

Part Name	Description	Quantity	Price (EUR)
Stepper Motor	ACT Motor 23HS8430 1.9 Nm	1	17.90
Stepper Motor Driver	TB6600 Stepper Motor Driver	1	9.90
Raspberry Pi 3 Model B	ARM Cortex-A53 with Wi-Fi and Bluetooth	1	44.45
Couplings	4 flange couplings	4	9.99
Adapter for Aldi Ferrex Battery	Option 1: Adapter for Aldi Ferrex battery, charging cradle, gray PLA+	1	11.90
AC/DC Converter	Option 2: Power supply transformer for LED strips and lighting	1	12.99
Jumper Wire Cables	Jumper wire cables for breadboard connections	1	4.99
Raspberry Pi Case with Cooling	Aluminum case with cooling fan and heatsinks for Raspberry Pi	1	14.99
Total (Price Range)			114 - 116

Note: Prices are based on Amazon.de listings as of June 2024 and may be subject to change.

Datasheets

ACT Motor 23HS8430 1.9 Nm Stepper Motor

TB6600 Stepper Motor Driver

Assembly Instructions

This guide has been adapted from https://www.heimkino-praxis.de/leinwand-maskierung-schrittmotor-steuerung/ - many thanks to the author Bert Kößler

Mounting the Stepper Motor

• Secure the ACT Motor 23HS8430 (from the parts list) to a stable base using a mounting bracket. For initial testing, cable ties can be used.
• Connect one of the flange couplings (from the parts list) to the motor shaft.
• Secure the garden hose to the flange coupling using a cable tie or hose clamp.

Wiring

• Connect the ACT Motor 23HS8430 wires to the TB6600 driver (from the parts list):
  • Black wire to A+
  • Green wire to A-
  • Red wire to B+
  • Blue wire to B-

This color coding is specific to the ACT Motor 23HS8430. Always verify these connections against the motor's datasheet, as even within the same model, there can be variations.

• Connect the TB6600 driver to the Raspberry Pi 3 Model B (from the parts list):

Raspberry Pi GPIO Pin Layout

• • DIR- to a GND pin (recommend using Pin 39, 34, or 30 as they're closest)
  • PUL- to a GND pin (recommend using Pin 39, 34, or 30 as they're closest)
  • ENA- to a GND pin (recommend using Pin 39, 34, or 30 as they're closest)
  • DIR+ to GPIO 33 (Pin 33 on the board)
  • PUL+ to GPIO 35 (Pin 35 on the board)
  • ENA+ to GPIO 37 (Pin 37 on the board)
• Connect the power supply (either the Aldi Ferrex battery adapter or the AC/DC converter from the parts list) to the TB6600 driver:
  • VCC to positive terminal
  • GND to negative terminal

Setting up the TB6600 Driver Switches

On one side of the driver, you'll find 6 small switches that configure the driver for your motor. The top of the driver should have a printed table explaining the switch settings. A barely visible arrow on the switch should indicate which position is "On".

• Switches 1-3 set the step size:
  • Set to on-on-off for full steps (typically 200 steps per full rotation, 1.8° per step)
  • Can be set to on-off-on later for half-steps (400 steps per rotation, 0.9° per step) for smoother operation
• Switches 4-6 set the output current for the motor:
  • Refer to your motor's datasheet for the rated current (usually in Amperes or "Amps")
  • For example, if your motor is rated at 2.0A, set switches 4-6 to on-off-off (which provides 2.0A continuous, 2.2A peak according to the driver's table)

Important: Always start with lower current settings and gradually increase. Too little current can cause weak motor performance and missed steps, while too much current can overheat and damage the motor.

Additional Setup

• Use the jumper wire cables (from the parts list) for any necessary connections between components.
• Install the Raspberry Pi in the aluminum case with cooling fan (from the parts list) for protection and temperature management.

Software Setup

• Install Raspbian OS on the Raspberry Pi
• Enable SSH for headless setup
• Use the provided Python script as a starting point, modifying parameters like step counts and speeds for your specific sprinkler setup.

Testing and Calibration

• Start with lower speeds and gradually increase
• Determine the number of steps needed for full range of motion
• Adjust acceleration ramps if needed for smoother operation

Safety Considerations

• Ensure all electrical connections are properly insulated
• Protect the electronics from water exposure
• Use caution when testing, as the motor can generate significant torque

Software

Stepper Motor Control Script

Save the following code as stepper.py:

"""
stepper.py

Control a stepper motor connected to a Raspberry Pi through a TB6600 driver.

Author: Wolfgang, ChatGPT
Date: 2023-03-28 (ISO 8601 format)
"""

import RPi.GPIO as GPIO
import time
import argparse

class StepperMotor:
    """
    Controls a stepper motor connected to a TB6600 driver on a Raspberry Pi.
    """
    def __init__(self, dir_pin: int = 33, pul_pin: int = 35, ena_pin: int = 37, frequency_hz: int = 500, rpm: int = 30):
        """
        Initializes the stepper motor with the provided pin numbers, pulse frequency, and RPM.

        Args:
            dir_pin (int): Pin number for direction control (default 33)
            pul_pin (int): Pin number for pulse control (default 35)
            ena_pin (int): Pin number for enable control (default 37)
            frequency_hz (int): Pulse frequency in Hz (default 500 Hz)
            rpm (int): Motor speed in RPM (default 30 RPM)
        """
        self.dir_pin = dir_pin
        self.pul_pin = pul_pin
        self.ena_pin = ena_pin
        self.frequency_hz = frequency_hz
        self.rpm = rpm
        self.half_period_s = 1 / (2 * self.frequency_hz)  # Pulse width based on frequency
        self.step_delay_s = 60 / (self.rpm * 200)  # Time delay between steps based on RPM

        # Set up GPIO pins
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(self.dir_pin, GPIO.OUT)
        GPIO.setup(self.pul_pin, GPIO.OUT)
        GPIO.setup(self.ena_pin, GPIO.OUT)

    def move(self, angle: float, direction: str):
        """
        Moves the stepper motor by the specified angle in the given direction.

        Args:
            angle (float): Angle in degrees to move the motor
            direction (str): Direction to move ('left' or 'right')
        """
        steps = abs(angle) * 200 / 360  # Calculate number of steps based on angle
        GPIO.output(self.ena_pin, GPIO.LOW)  # Lock motor

        # Set direction
        if direction == 'left':
            GPIO.output(self.dir_pin, GPIO.HIGH)
        elif direction == 'right':
            GPIO.output(self.dir_pin, GPIO.LOW)
        else:
            raise ValueError(f"Invalid direction: {direction}")

        # Pulse modulation
        for _ in range(int(steps)):
            GPIO.output(self.pul_pin, GPIO.HIGH)
            time.sleep(self.half_period_s)
            GPIO.output(self.pul_pin, GPIO.LOW)
            time.sleep(self.step_delay_s)  # Use RPM based delay between steps

    def usage(self):
        """
        Prints usage instructions for the StepperMotor class.
        """
        print(f"Usage: {self.__class__.__name__}(dir_pin, pul_pin, ena_pin, frequency_hz, rpm)")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Control a stepper motor connected to a Raspberry Pi through a TB6600 driver.')
    parser.add_argument('--dir-pin', type=int, default=33, help='Pin number for direction control')
    parser.add_argument('--pul-pin', type=int, default=35, help='Pin number for pulse control')
    parser.add_argument('--ena-pin', type=int, default=37, help='Pin number for enable control')
    parser.add_argument('--frequency-hz', type=int, default=500, help='Pulse frequency in Hz')
    parser.add_argument('--rpm', type=int, default=30, help='Motor speed in RPM')
    parser.add_argument('--angle', type=float, help='Angle in degrees', default=90)
    parser.add_argument('--direction', choices=['left', 'right'], help='Movement direction', default='left')

    args = parser.parse_args()

    # Create StepperMotor instance with RPM and frequency
    stepper = StepperMotor(args.dir_pin, args.pul_pin, args.ena_pin, args.frequency_hz, args.rpm)

    # Move the stepper motor based on command line arguments
    stepper.move(args.angle, args.direction)

Water Control Script

Save the following code as water and make it executable

chmod +x water

#!/bin/bash
# Bash script to control a garden hose motor for watering a lawn
# Utilizes stepper.py to turn the motor

# Define the path to your stepper.py script
STEPPER_SCRIPT_PATH="./stepper.py"

# Define motor movement parameters
ANGLE=170  # Angle to rotate, slightly less than 170 degrees for better control
FREQ=200   # Stepper frequency - 200 = 1 sec per full turn
RPM=10     # Motor speed in RPM
DIRECTION_LEFT="left"
DIRECTION_RIGHT="right"

# Get the number of cycles from the command line argument or set default to 5
CYCLES=${1:-5}

# Main loop to rotate motor left and right for specified cycles
for (( i=0; i<CYCLES; i++ )); do
    # Move motor to the left
    echo "Cycle $((i+1)) of $CYCLES: Turning motor left"
    sudo python3 $STEPPER_SCRIPT_PATH --angle $ANGLE --direction $DIRECTION_LEFT --frequency-hz $FREQ --rpm $RPM
    
    # Move motor to the right
    echo "Cycle $((i+1)) of $CYCLES: Turning motor right"
    sudo python3 $STEPPER_SCRIPT_PATH --angle $ANGLE --direction $DIRECTION_RIGHT --frequency-hz $FREQ --rpm $RPM
done

echo "Completed $CYCLES cycles of watering."

Usage

To control the stepper motor directly: sudo python3 stepper.py --angle 90 --direction left --frequency-hz 500 --rpm 30

sudo is necessary for accessing the kernel memory directly.

To run the water control script: ./water 10

This will run 10 cycles of watering. Adjust the number as needed.

Patents

When searching for relevant patents we found:

• US5366157A - Robotic lawn sprinkler

Please note that this might not be the only patent relevant for this system

This patent, filed in 1993 (over 30 years ago), already attempted to create a "3D sprinkling" system by controlling the hose direction with two angles and the water flow. Key features include:

1. A water-powered articulated actuation and control system
2. Ability to aim a continuous stream of water to all coordinates within a polar coordinate system
3. A manually programmable base assembly anchored to the ground, containing size-specific range data
4. An azimuth rotor assembly mounted horizontally and a range rotor assembly mounted vertically
5. Separate actuation and control systems for azimuth and range
6. A mechanism for variably controlling range rate and flow volume

The patent abstract states:

An automatic robotic lawn sprinkler providing a water powered articulated, actuation and control system aiming a continuous stream of water to all coordinates within a polar coordinate system comprising a manually programmable base assembly for anchoring to the ground and containing size specific range data, an azimuth rotor assembly rotatably mounted to the base in a horizontal plane, a range rotor assembly rotatably mounted in a vertical plane substantially perpendicular to the azimuth rotor an azimuth actuation and control system range actuation and control system, and a mechanism for variably controlling range rate and flow volume.

This early attempt at robotic lawn sprinkler technology shows how much easier things are these days.

Legal Disclaimer

While the patent mention above has expired, it is important to note that there may be other active patents related to this system. The expiration of one patent does not guarantee freedom from all patent restrictions.

The effect of expired and potentially unknown patents on this DIY project:

• Expired patents: The technology described in expired patents is generally considered to be in the public domain and available for use without licensing.
• Unknown patents: There is always a possibility that other active patents may cover aspects of this system.
• DIY projects: While personal, non-commercial use is generally less likely to face patent infringement issues, it's important to be aware that patent laws can still apply to DIY projects.

Builders of this system are advised to use this information for personal, non-commercial purposes only. If you plan to commercialize or distribute this system, it is strongly recommended to consult with a patent attorney to ensure compliance with current patent laws.

This project is provided for educational and informational purposes only. The authors and contributors to this wiki page do not assume any legal responsibility for the use or misuse of this information.