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.

Video

The video shows the principle of moving the garden hose with the motor.

• https://wiki.bitplan.com/images/wiki/3/39/LawnSprinkler2024-06-30_0956.mp4

File:LawnSprinkler2024-06-30 0956.mp4

Parts List

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

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 smaller motor to the coupling with two cable ties
• Connect one of the flange couplings with the motor
• Secure the garden hose to the flange coupling using a cable tie or hose clamp.

Wiring

The color codings are specific to the Motors. Always verify these connections against the motor's datasheet, as even within the same model, there can be variations.

• Connect the Motor wires to the TB6600 drivers (from the parts list):

23 HS 8430

• Black wire to A+
• Green wire to A-
• Red wire to B+
• Blue wire to B-

TB6600 to Raspberry

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

Raspberry Pi GPIO Pin Layout

First motor

• ENA- to GND pin (Pin 39) green
• ENA+ to GPIO 26 (Pin 37) blue
• DIR- to GND pin (Pin 34) pink
• DIR+ to GPIO 19 (Pin 35) grey
• PUL- to GND pin (Pin 30) white
• PUL+ to GPIO 13 (Pin 33) black

Second motor

• ENA- to GND pin (Pin 20) green
• ENA+ to GPIO 6 (Pin 31) blue
• DIR- to GND pin (Pin 14) pink
• DIR+ to GPIO 5 (Pin 29) grey
• PUL- to GND pin (Pin 6) white
• PUL+ to GPIO 11 (Pin 23) black

Make sure your software settings below fit the Pins you used!

Second motor

• 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")
  • Since our motors are rated at 3.0A, set switches 4-6 to off-on-off (which provides 3.0A continuous, 3.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 two stepper motors connected to a Raspberry Pi through a TB6600 driver to sprinkle a lawn.

Author: Wolfgang, ChatGPT, Claude AI
Date: 2024-07 to 2024-08
"""

import RPi.GPIO as GPIO
import time
import argparse
from typing import Dict

class StepperMotor:
    def __init__(self, name: str, ena_pin: int, dir_pin: int, pul_pin: int, steps_per_revolution: int = 200):
        self.name = name
        self.ena_pin = ena_pin
        self.dir_pin = dir_pin
        self.pul_pin = pul_pin
        self.steps_per_revolution = steps_per_revolution
        self.setup_gpio()

    def setup_gpio(self):
        GPIO.setup(self.ena_pin, GPIO.OUT)
        GPIO.setup(self.dir_pin, GPIO.OUT)
        GPIO.setup(self.pul_pin, GPIO.OUT)
        GPIO.output(self.ena_pin, GPIO.HIGH)  # Start with motor disabled

    def enable(self):
        GPIO.output(self.ena_pin, GPIO.LOW)

    def disable(self):
        GPIO.output(self.ena_pin, GPIO.HIGH)

    def set_direction(self, clockwise: bool):
        GPIO.output(self.dir_pin, GPIO.HIGH if clockwise else GPIO.LOW)

    def step(self, steps: int, delay: float):
        for _ in range(abs(steps)):
            GPIO.output(self.pul_pin, GPIO.HIGH)
            time.sleep(delay)
            GPIO.output(self.pul_pin, GPIO.LOW)
            time.sleep(delay)

class Move:
    def __init__(self):
        GPIO.setmode(GPIO.BOARD)
        self.motors: Dict[int, StepperMotor] = {
            1: StepperMotor("Motor1", 37, 35, 33),
            2: StepperMotor("Motor2", 31, 29, 23)
        }

    def enable_motor(self, motor_id: int):
        motor = self.motors.get(motor_id)
        if motor:
            motor.enable()
        else:
            print(f"Motor {motor_id} not found")

    def disable_motor(self, motor_id: int):
        motor = self.motors.get(motor_id)
        if motor:
            motor.disable()
        else:
            print(f"Motor {motor_id} not found")

    def move_motor(self, motor_id: int, angle: float, speed_rpm: float, keep_enabled: bool = False):
        motor = self.motors.get(motor_id)
        if not motor:
            print(f"Motor {motor_id} not found")
            return
        steps = int(abs(angle) / 360 * motor.steps_per_revolution)
        delay = 30 / (speed_rpm * motor.steps_per_revolution)
        motor.enable()
        motor.set_direction(angle >= 0)
        motor.step(steps, delay)
        if not keep_enabled:
            motor.disable()

    def perform_pattern(self,
        horizontal_angle: float,
        horizontal_steps: int,
        vertical_angle: float,
        rpm: float):
        # Enable both motors before starting the pattern
        self.enable_motor(1)
        self.enable_motor(2)

        for _ in range(horizontal_steps):
            self.move_motor(1, horizontal_angle, rpm, keep_enabled=True)
            self.move_motor(2, vertical_angle, rpm, keep_enabled=True)
            self.move_motor(2, -vertical_angle, rpm, keep_enabled=True)

        # Reset horizontal position
        self.move_motor(1, -horizontal_angle * horizontal_steps, rpm, keep_enabled=True)

        # Disable both motors after completing the pattern
        self.disable_motor(1)
        self.disable_motor(2)

    def perform_pattern_by_args(self, pattern_args):
        # Default values
        params = {
            'steps': 80,
            'hangle': 160,
            'vangle': 120,
            'rpm': 10
        }

        # Parse provided arguments
        for arg in pattern_args:
            key, value = arg.split('=')
            if key in params:
                params[key] = float(value)

        # Execute the pattern
        self.perform_pattern(
            horizontal_angle=params['hangle'] / params['steps'],
            horizontal_steps=int(params['steps']),
            vertical_angle=params['vangle'],
            rpm=params['rpm']
        )

    def cleanup(self):
        for motor in self.motors.values():
            motor.disable()
        GPIO.cleanup()
        time.sleep(0.1)

# Modify main function to use the new approach
def main():
    parser = argparse.ArgumentParser(description="Control stepper motors")
    parser.add_argument("-m", "--motor", type=int, default=1, help="Motor ID (default: 1)")
    parser.add_argument("-a", "--angle", type=float, default=15, help="Angle to rotate (default: 15, positive for CW, negative for CCW)")
    parser.add_argument("-r", "--rpm", type=float, default=20, help="Speed in RPM (default: 20)")
    parser.add_argument("-k", "--keep-enabled", action="store_true", help="Keep motor enabled after movement")
    parser.add_argument("-p", "--pattern", nargs='*', metavar="KEY=VALUE",
                        help="Perform pattern: [steps=N] [hangle=DEG] [vangle=DEG] [rpm=RPM] default: steps=20,hangle=160,vangle=90,rpm=10")

    args = parser.parse_args()
    move_controller = Move()

    if args.pattern is not None:
        # For pattern, we'll handle enabling/disabling within the perform_pattern method
        move_controller.perform_pattern_by_args(args.pattern)
    else:
        # For single motor movement
        move_controller.move_motor(args.motor, args.angle, args.rpm, args.keep_enabled)

    move_controller.cleanup()

if __name__ == "__main__":
    main()

Water Control Script

Save the following code as water and make it executable

chmod +x water

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

# Define the path to your stepper.py script
STEPPER_SCRIPT_PATH="./stepper.py"
python3 $STEPPER_SCRIPT_PATH -p

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.