Hackster is hosting Hackster Holidays, Ep. 7: Livestream & Giveaway Drawing. Watch previous episodes or stream live on Friday!Stream Hackster Holidays, Ep. 7 on Friday!
Andrew T.
Published © CC BY-ND

Smart Office ِAssistant A. I Robots Network

A company assistant robot that can deliver docs, food to employees, autonomously map and navigate the whole office with a chatting system.

AdvancedFull instructions provided12 hours3,396
Smart Office ِAssistant A. I Robots Network

Things used in this project

Hardware components

donkey car
×1
Raspberry Pi 3 Model B
Raspberry Pi 3 Model B
×1
Kinect Sensor
Microsoft Kinect Sensor
×1
Camera Module
Raspberry Pi Camera Module
×1
Servo (PWM) Expansion
Onion Corporation Servo (PWM) Expansion
×1

Software apps and online services

TensorFlow
TensorFlow
OpenCV
OpenCV

Story

Read more

Schematics

Mapping process MP4

Mapping process MP4 just in case the gif was not loading

Code

web.py

Python
modified file to remotly record a screenshot of the current location and map from the master laptop while driving the car
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 24 20:10:44 2017

@author: wroscoe

remotes.py

The client and web server needed to control a car remotely.
"""

import random
from paramiko.client import SSHClient


import os
import time

import tornado
import tornado.ioloop
import tornado.web
import tornado.gen

from donkeycar import util


class LocalWebController(tornado.web.Application):
    port = 8887
    def __init__(self, use_chaos=False):
        """
        Create and publish variables needed on many of
        the web handlers.
        """
        print('Starting Donkey Server...')
        print('-------------------------')
        print('Connecting To Ros Master')
        client = SSHClient()
        client.load_system_host_keys()
        client.connect('192.168.1.4', username='user', password='pass')

        this_dir = os.path.dirname(os.path.realpath(__file__))
        self.static_file_path = os.path.join(this_dir, 'templates', 'static')

        self.angle = 0.0
        self.throttle = 0.0
        self.mode = 'user'
        self.recording = False
        self.ip_address = util.web.get_ip_address()
        self.access_url = 'http://{}:{}'.format(self.ip_address, self.port)

        self.chaos_on = False
        self.chaos_counter = 0
        self.chaos_frequency = 1000 #frames
        self.chaos_duration = 10

        if use_chaos:
            self.run_threaded = self.run_chaos
        else:
            self.run_threaded = self._run_threaded

        handlers = [
            (r"/", tornado.web.RedirectHandler, dict(url="/drive")),
            (r"/drive", DriveAPI),
            (r"/video", VideoAPI),
            (r"/static/(.*)", tornado.web.StaticFileHandler, {"path": self.static_file_path}),
        ]

        settings = {'debug': True}
        super().__init__(handlers, **settings)

    def run_chaos(self, img_arr=None):
        """
        Run function where steering is made random to add corrective
        """
        self.img_arr = img_arr
        if self.chaos_counter == self.chaos_frequency:
            self.chaos_on = True
            random_steering = random.random()
        elif self.chaos_counter == self.chaos_duration:
            self.chaos_on = False

        if self.chaos_on:
            return random_steering, self.throttle, self.mode, False
        else:
            return self.angle, self.throttle, self.mode, self.recording

    def say_hello(self):
        """
        Print friendly message to user
        """
        print("You can now go to {} to drive your car.".format(self.access_url))

    def update(self):
        """ Start the tornado web server. """
        self.port = int(self.port)
        self.listen(self.port)
        instance = tornado.ioloop.IOLoop.instance()
        instance.add_callback(self.say_hello)
        instance.start()

    def _run_threaded(self, img_arr=None):
        self.img_arr = img_arr
        return self.angle, self.throttle, self.mode, self.recording

    def run(self, img_arr=None):
        return self.run_threaded(img_arr)


class DriveAPI(tornado.web.RequestHandler):
    def get(self):
        data = {}
        self.render("templates/vehicle.html", **data)

    def post(self):
        """
        Receive post requests as user changes the angle
        and throttle of the vehicle on a the index webpage
        """
        data = tornado.escape.json_decode(self.request.body)
        self.application.angle = data['angle']
        self.application.throttle = data['throttle']
        self.application.mode = data['drive_mode']
        self.application.recording = data['recording']
        if(self.application.recording):
           print('recording....')
           stdin, stdout, stderr = client.exec_command('python /home/your_user/your/path/to/scripty.py')


class VideoAPI(tornado.web.RequestHandler):
    """
    Serves a MJPEG of the images posted from the vehicle.
    """

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):

        ioloop = tornado.ioloop.IOLoop.current()
        self.set_header("Content-type", "multipart/x-mixed-replace;boundary=--boundarydonotcross")

        self.served_image_timestamp = time.time()
        my_boundary = "--boundarydonotcross"
        while True:

            interval = .1
            if self.served_image_timestamp + interval < time.time():

                img = util.img.arr_to_binary(self.application.img_arr)

                self.write(my_boundary)
                self.write("Content-type: image/jpeg\r\n")
                self.write("Content-length: %s\r\n\r\n" % len(img))
                self.write(img)
                self.served_image_timestamp = time.time()
                yield tornado.gen.Task(self.flush)
            else:
                yield tornado.gen.Task(ioloop.add_timeout, ioloop.time() + interval)

screenshoot

Python
python file that is remotly work from the web.py script on the master laptop to take the screenshot of the current location and map to process it for autonomus driving in autopilot mode
 
# import the necessary packages
import pyautogui
import imutils
import time

im = pyautogui.screenshot(region=(600,150, 600, 600))
im.save("screenshot"+str(int(time.time()))+".png")

Credits

Andrew T.
8 projects • 20 followers
A Doctor Hobbyist Electronics and Intermediate to advanced Programmer in multiple Fields from web ,mobile and Game Dev to Microcontrollers

Comments

Related channels and tags
  • Machine Learning & AI
  • Machine Learning & AI
  • Microsoft
  • Onion Corporation
  • OpenCV
  • Raspberry Pi
  • TensorFlow