Raspberry PI 500 released! Arduino Nano Matter released! AI Scale... prototyped!

0:00:00 / -

Watch now on YouTube Watch now

Lego Waterbot

Made by ashokr

About the project

Lego's 1st voice controlled robot for home garden irrigation.

Project info

Difficulty: Moderate

Platforms: Amazon Alexa, Amazon Web Services, LEGO MindStorms, Microsoft, Raspberry Pi

Estimated time: 7 days

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	Switched JST-PH 2-Pin SMT Right Angle Breakout Board	x 1
	Resistor Network - 10K Ohm (6-pin bussed)	x 1
	Through-Hole Resistors - 100K ohm 5% 1/4W - Pack of 25	x 1
	Raspberry Pi 1 Model B+ Starter Pack - Includes a Raspberry Pi 1	x 1
	Grove - Water Sensor	x 1
	Resistor Network - 10K Ohm (6-pin bussed)	x 1
	Jumper Wire Kit - 140pcs	x 1

Software apps and online services

	Soldering Station, 110 V
	Amazon Alexa Alexa Skills Kit
	Microsoft VS Code

Hand tools and fabrication machines

	9v Power Adapter	x 1
	Hot glue gun (generic)	x 1

Story

This project demonstrate the idea that, make a robot for irrigation and voice controlled via amazon echo dot.

I brought the Lego Mindstorms EV3 Kit, 10 days took for me to reach my home. Started working on Missions , Assembled the robot then completed the missions one by one.

Tthen i have implemented my concepts by adding new skills set in Amazon

1 / 2

a) GOTO commends -> PLANT or POT, STATION example "GOTO PLANT TWO"

b) ACTIVATE WATERBOT, RELEASE WATER, CHECK WATER LEVEL and etc.

used the IR sensors for detecting the PLANT or POT, The Waterbot will check the IR distance before releasing the water.

For my requirement I need to control the external pump so did some basic research on Lego wiring connections and got some ideas from that. I just curious about it so I broken a touch sensor to see what is inside :) Also this Hardware Kit document helps me in understanding about Auto ID detection

Execution:

I created the simple resistor voltage divider circuits to detect the dc motor pump on lego control unit.

I tested this circuit with detection and controlling the dc pump motor. In the python code the following changes required to detect this dc pump as motor.

import OUTPUT_A, SpeedPercent,  Motor,waterpump = Motor(OUTPUT_A)  waterpump.on_for_seconds(SpeedPercent(50),1)  // To Turn ON the Motorwaterpump.on_for_seconds(SpeedPercent(-100),1) // To Turn OFF the Motor

As next step I have created small PCB with this circuit and sticked into theone of small Lego blocks. Setup the motor inside the water bottle along with 1/4 inch tube and did wiring with the help of fevistick and glue gum so that the water wont leak outside. Now the small adapter RJ12 board can go into the top of the tank (water bottle). Due to time limitation I couldn't install the water level sensing in tank.

1 / 2

Plants/Pots Mapping:

After setting up the Waterbot, its important to map the location of plants/pots to the Waterbot, I used the basic relation between speed & time to predict the distance

speed = distance/time

Assume speed =1 (for 25% as per the experiments)

distance = time,

Yes if we run the Lego bot for 1sec with 25% speed it wil cross 10cm

in my case I set the speed to 50%, so mapped all the pots/plants distance accordingly in my python scripts.

For rotating left and right, I have to maintain the speed at 45% to get complete 90 degree rotation for seconds. This also relatively same,

distance traveled ( 2sec x 45% speed) = degree of rotation. (90 Degree)

water released in percentage, 10% is equal to running the pump for 1sec, 50% is for 5sec.

Finally I setup everything and fill the water in bottle, The Waterbot is ready to serve the water.

This Waterbot enables the new product version for LEGO kit with water pump and tank system.

Working:

Opening the "Waterbot" by issuing the command "Alexa Open WaterBots"

Alexa: Welcome Ashok, voice interface activated

(background music playing)

Ashok: Alexa, GOTO PLANT ONE,

Alexa: Command "PLANT ONE"activated

(Water-bot started moving )

Ashok: Alexa, ACTIVATE "Water-bot Mode",

Alexa: "Water-bot" mode Activated

Ashok: Alexa, RELEASE water 50%,

Does Alexa, release the water??

Checkout the full working video here

Schematics, diagrams and documents

Motor Pump Circuit

Code

Main Code

#!/usr/bin/env python3
# Copyright 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
# 
# You may not use this file except in compliance with the terms and conditions 
# set forth in the accompanying LICENSE.TXT file.
#
# THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY DISCLAIMS, WITH 
# RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING 
# THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.

import os
import sys
import time
import logging
import json
import random
import threading
from enum import Enum

from agt import AlexaGadget

from ev3dev2.led import Leds
from ev3dev2.sound import Sound
from ev3dev2.motor import OUTPUT_A, OUTPUT_B, OUTPUT_C, MoveTank, SpeedPercent, MediumMotor, Motor, SpeedValue, SpeedRPS, SpeedRPM
from ev3dev2.sensor.lego import InfraredSensor

# Set the logging level to INFO to see messages from AlexaGadget
logging.basicConfig(level=logging.INFO, stream=sys.stdout, format='%(message)s')
logging.getLogger().addHandler(logging.StreamHandler(sys.stderr))
logger = logging.getLogger(__name__)


class Direction(Enum):
    """
    The list of directional commands and their variations.
    These variations correspond to the skill slot values.
    """
    FORWARD = ['forward', 'forwards', 'go forward']
    BACKWARD = ['back', 'backward', 'backwards', 'go backward']
    LEFT = ['left', 'go left']
    RIGHT = ['right', 'go right']
    STOP = ['stop', 'brake', 'halt']


class Command(Enum):
    """
    The list of preset commands and their invocation variation.
    These variations correspond to the skill slot values.
    """
    MOVE_CIRCLE = ['circle', 'move around']
    MOVE_SQUARE = ['square']
    WATERBOT = ['waterbot', 'water mode', 'waterbots', 'waterbot mode']
    PATROL = ['patrol', 'patrol mode']
    RELEASE = ['water 25%', 'water 50%', 'water 100%']
    GOTO_PLANT1 = ['plant one','plant 1','pot 1','pot one']
    GOTO_PLANT2 = ['plant two','plant 2','pot 2','pot two']
    GOTO_PLANT3 = ['plant three','plant 3','pot 3','pot three']
    GOTO_HOME = ['station']

class EventName(Enum):
    """
    The list of custom event name sent from this gadget
    """
    WATERBOT = "Waterbot"
    PROXIMITY = "Proximity"
    SPEECH = "Speech"


class MindstormsGadget(AlexaGadget):
    """
    A Mindstorms gadget that can perform bi-directional interaction with an Alexa skill.
    """

    def __init__(self):
        """
        Performs Alexa Gadget initialization routines and ev3dev resource allocation.
        """
        super().__init__()

        # Robot state
        self.waterbot_mode = False
        self.patrol_mode = False

        # Connect two large motors on output ports B and C
        self.drive = MoveTank(OUTPUT_B, OUTPUT_C)
        self.waterpump = Motor(OUTPUT_A)   # MediumMotor(OUTPUT_A)
        self.sound = Sound()
        self.leds = Leds()
        self.ir = InfraredSensor()

        # Start threads
        threading.Thread(target=self._patrol_thread, daemon=True).start()
        threading.Thread(target=self._proximity_thread, daemon=True).start()

    def on_connected(self, device_addr):
        """
        Gadget connected to the paired Echo device.
        :param device_addr: the address of the device we connected to
        """
        self.leds.set_color("LEFT", "GREEN")
        self.leds.set_color("RIGHT", "GREEN")
        logger.info("{} connected to Echo device".format(self.friendly_name))

    def on_disconnected(self, device_addr):
        """
        Gadget disconnected from the paired Echo device.
        :param device_addr: the address of the device we disconnected from
        """
        self.leds.set_color("LEFT", "BLACK")
        self.leds.set_color("RIGHT", "BLACK")
        logger.info("{} disconnected from Echo device".format(self.friendly_name))

    def on_custom_mindstorms_gadget_control(self, directive):
        """
        Handles the Custom.Mindstorms.Gadget control directive.
        :param directive: the custom directive with the matching namespace and name
        """
        try:
            payload = json.loads(directive.payload.decode("utf-8"))
            print("Control payload: {}".format(payload), file=sys.stderr)
            control_type = payload["type"]
            if control_type == "move":

                # Expected params: [direction, duration, speed]
                self._move(payload["direction"], int(payload["duration"]), int(payload["speed"]))

            if control_type == "command":
                # Expected params: [command]
                self._activate(payload["command"])

        except KeyError:
            print("Missing expected parameters: {}".format(directive), file=sys.stderr)

    def _move(self, direction, duration: int, speed: int, is_blocking=False):
        """
        Handles move commands from the directive.
        Right and left movement can under or over turn depending on the surface type.
        :param direction: the move direction
        :param duration: the duration in seconds
        :param speed: the speed percentage as an integer
        :param is_blocking: if set, motor run until duration expired before accepting another command
        """
        print("Move command: ({}, {}, {}, {})".format(direction, speed, duration, is_blocking), file=sys.stderr)
        if direction in Direction.FORWARD.value:
            self.drive.on_for_seconds(SpeedPercent(speed), SpeedPercent(speed), duration, block=is_blocking)

        if direction in Direction.BACKWARD.value:
            self.drive.on_for_seconds(SpeedPercent(-speed), SpeedPercent(-speed), duration, block=is_blocking)

        if direction in (Direction.RIGHT.value + Direction.LEFT.value):
            self._turn(direction, speed)
            self.drive.on_for_seconds(SpeedPercent(speed), SpeedPercent(speed), duration, block=is_blocking)

        if direction in Direction.STOP.value:
            self.drive.off()
            self.patrol_mode = False

    def _activate(self, command, speed=50):
        """
        Handles preset commands.
        :param command: the preset command
        :param speed: the speed if applicable
        """
        print("Activate command: ({}, {})".format(command, speed), file=sys.stderr)
        if command in Command.MOVE_CIRCLE.value:
            self.drive.on_for_seconds(SpeedPercent(int(speed)), SpeedPercent(5), 12)

        if command in Command.MOVE_SQUARE.value:
            for i in range(4):
                self._move("right", 2, speed, is_blocking=True)

        if command in Command.GOTO_HOME.value:
            #for i in range(4):
            self._move("back", 8, speed, is_blocking=True)
            self._move("left", 2, speed-5, is_blocking=True)
            self._move("forward", 8, speed, is_blocking=True)
        if command in Command.GOTO_PLANT1.value:
            self._move("forward", 6, speed, is_blocking=True)
        if command in Command.GOTO_PLANT2.value:
            self._move("forward", 2, speed, is_blocking=True)
            self._move("left", 2, speed-5, is_blocking=True)
            self._move("forward", 2, speed, is_blocking=True)
        if command in Command.GOTO_PLANT3.value:
            self._move("forward", 4, speed, is_blocking=True)

        if command in Command.PATROL.value:
            # Set patrol mode to resume patrol thread processing
            self.patrol_mode = True

        if command in Command.WATERBOT.value:
            self.waterbot_mode = True
            self._send_event(EventName.SPEECH, {'speechOut': "Waterbot mode activated"})

            # Perform Shuffle posture
            #self.drive.on_for_seconds(SpeedPercent(80), SpeedPercent(-80), 0.2)
            #time.sleep(0.3)
            #self.drive.on_for_seconds(SpeedPercent(-40), SpeedPercent(40), 0.2)

            self.leds.set_color("LEFT", "YELLOW", 1)
            self.leds.set_color("RIGHT", "YELLOW", 1)

        if command in Command.RELEASE.value:
            print("Release Water", file=sys.stderr)
            #self.weapon.on_for_rotations(SpeedPercent(100), 3)
            self.waterpump.on_for_seconds(SpeedPercent(50),1)
            self._send_event(EventName.WATERBOT, {'release': 1})
            if "25%" in Command.RELEASE.value:
              time.sleep(2.5)
            if "50%" in Command.RELEASE.value:
              time.sleep(5)
            if "100%" in Command.RELEASE.value:
              time.sleep(10)
            
            self.waterpump.on_for_seconds(SpeedPercent(-100),1)
            self.waterbot_mode = False
            #print("Sent sentry event - 1 shot, alarm reset", file=sys.stderr)
            self.leds.set_color("LEFT", "GREEN", 1)
            self.leds.set_color("RIGHT", "GREEN", 1)

    def _turn(self, direction, speed):
        """
        Turns based on the specified direction and speed.
        Calibrated for hard smooth surface.
        :param direction: the turn direction
        :param speed: the turn speed
        """
        if direction in Direction.LEFT.value:
            self.drive.on_for_seconds(SpeedPercent(0), SpeedPercent(speed), 2)

        if direction in Direction.RIGHT.value:
            self.drive.on_for_seconds(SpeedPercent(speed), SpeedPercent(0), 2)

    def _send_event(self, name: EventName, payload):
        """
        Sends a custom event to trigger a sentry action.
        :param name: the name of the custom event
        :param payload: the sentry JSON payload
        """
        self.send_custom_event('Custom.Mindstorms.Gadget', name.value, payload)

    def _proximity_thread(self):
        """
        Monitors the distance between the robot and an obstacle when sentry mode is activated.
        If the minimum distance is breached, send a custom event to trigger action on
        the Alexa skill.
        """
        count = 0
        while True:
            while self.waterbot_mode:
                distance = self.ir.proximity
                print("Proximity: {}".format(distance), file=sys.stderr)
                count = count + 1 if distance < 10 else 0
                if count > 10:
                    print("Proximity breached. Sending event to skill", file=sys.stderr)
                    self.leds.set_color("LEFT", "RED", 1)
                    self.leds.set_color("RIGHT", "RED", 1)

                    self._send_event(EventName.PROXIMITY, {'distance': distance})
                    #self.waterbot_mode = False

                time.sleep(0.2)
            time.sleep(1)

    def _patrol_thread(self):
        """
        Performs random movement when patrol mode is activated.
        """
        while True:
            while self.patrol_mode:
                print("Patrol mode activated randomly picks a path", file=sys.stderr)
                direction = random.choice(list(Direction))
                duration = random.randint(1, 5)
                speed = random.randint(1, 4) * 25

                while direction == Direction.STOP:
                    direction = random.choice(list(Direction))

                # direction: all except stop, duration: 1-5s, speed: 25, 50, 75, 100
                self._move(direction.value[0], duration, speed)
                time.sleep(duration)
            time.sleep(1)


if __name__ == '__main__':

    gadget = MindstormsGadget()

    # Set LCD font and turn off blinking LEDs
    os.system('setfont Lat7-Terminus12x6')
    gadget.leds.set_color("LEFT", "BLACK")
    gadget.leds.set_color("RIGHT", "BLACK")

    # Startup sequence
    gadget.sound.play_song((('C4', 'e'), ('D4', 'e'), ('E5', 'q')))
    gadget.leds.set_color("LEFT", "GREEN")
    gadget.leds.set_color("RIGHT", "GREEN")

    # Gadget main entry point
    gadget.main()

    # Shutdown sequence
    gadget.sound.play_song((('E5', 'e'), ('C4', 'e')))
    gadget.leds.set_color("LEFT", "BLACK")
    gadget.leds.set_color("RIGHT", "BLACK")

Credits

ashokr

Hello! I’m Ashok. I’m currently working as software engineer. passionate about doing Hobbies Projects and Animations works.

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Lego Waterbot

About the project

Project info