Script to send IP address through email

#!/bin/bash
text=""
until [ ${#text} -gt 0 ]; do
    echo "waiting for ip"
    text=$(ip route ls)
    sleep 3
done
echo $text | mail -s "Raspberry Pi IP" email@gmail.com

Camera.py

import picamera

class Camera: 


    def __init__(self):
        self.camera = picamera.PiCamera()

    def takePicture(self, path):
        # camera = picamera.PiCamera()
        self.camera.capture(path)

DB.py

from firebase import firebase
import time

base_url = 'https://mars-rover-ece5725-16fa.firebaseio.com/'
db = firebase.FirebaseApplication(base_url)


class DB:

    def __init__(self):
        pass       

    def readDirection(self):
        dir = db.get('/direction', None)
        return dir

    def readSpeed(self):
        speed = db.get('/speed', None)
        return speed

    def readMode(self):
        mode = db.get('/auto', None)
        return mode

ImageExtract.py

import cv2
import numpy as np
import math

HEIGHT = 15
WIDTH = 20
BLACK_THRESHOLD = 10
STOP_THRESHOLD = 0.2
RGB_BLACK_THRESHOLD = 20

ROW = [1, 0, -1, 0]
COL = [0, -1, 0, 1]

class ImageExtract:
    """
    find the center of the largest black object in given image.
    """
    def __init__(self):
        self.debug = False

    def set_debug(self, debug):
        self.debug = debug


    def find_center_quick(self, image):
        """
        find the center of the biggest cluster in obj (using 'number of island' algorithm)
        :param image:
        :return:
        """
        area = 0
        height_center = -1
        width_center = -1
        for i in range(HEIGHT):
            for j in range(WIDTH):
                if image[i][j] == 255:
                    res = self.dfs(i, j, image)
                    if res[0] > area:
                        height_center = res[1] / res[0]
                        width_center = res[2] / res[0]
        return height_center, width_center

    def dfs(self, row, col, matrix):
        area_sum = 1
        height_sum = row
        width_sum = col
        matrix[row][col] = 0
        for i in range(4):
            r = row + ROW[i]
            c = col + COL[i]
            if 0 <= r < HEIGHT and 0 <= c < WIDTH and matrix[r][c] == 255:
                res = self.dfs(r, c, matrix)
                area_sum += res[0]
                height_sum += res[1]
                width_sum += res[2]
        return area_sum, height_sum, width_sum

    def filter_out_background(self, image_path):
        """
        filter out background to get only black objects
        :param image_path:
        :return:
        """
        img = cv2.imread(image_path)
        resized_img = cv2.resize(img, (WIDTH, HEIGHT), interpolation=cv2.INTER_AREA)

        # define range of black color
        lower_black = np.array([0, 0, 0])
        upper_black = np.array([RGB_BLACK_THRESHOLD, RGB_BLACK_THRESHOLD, RGB_BLACK_THRESHOLD])

        # Threshold the image to get only black colors
        mask = cv2.inRange(resized_img, lower_black, upper_black)
        if self.debug:
            print 'view matrix:', mask
        return mask

    @staticmethod
    def find_center(img):
        """
        find the center of the biggest cluster in obj
        :param obj:
        :return: height_center, width_center
        """
        # create distance matrix (the square distance of every pixel to every black pixel)
        distance_matrix = np.zeros((HEIGHT, WIDTH))
        for target_i in range(HEIGHT):
            for target_j in range(WIDTH):
                for i in range(HEIGHT):
                    for j in range(WIDTH):
                        if img[i][j] > BLACK_THRESHOLD:
                            distance_matrix[target_i][target_j] += \
                                math.pow(target_i - i, 2) + math.pow(target_j - j, 2)

        # find center in the distance matrix
        center_i = 0
        center_j = 0
        for i in range(HEIGHT):
            for j in range(WIDTH):
                if distance_matrix[i][j] < distance_matrix[center_i][center_j]:
                    center_i = i
                    center_j = j

        return center_i, center_j

    def most_area_are_black(self, img):
        """
        if black pixels is larger than STOP_THRESHOLD, return True, otherwise return False
        :param obj:
        :return:
        """
        height = img.shape[0]
        width = img.shape[1]
        count = 0
        for i in range(height):
            for j in range(width):
                if img[i][j] > BLACK_THRESHOLD:
                    count += 1
        if self.debug:
            print 'count of black:', count
            print 'stop required count of black:', height * width * STOP_THRESHOLD
        if count > height * width * STOP_THRESHOLD:
            return True
        else:
            return False


if __name__ == '__main__':
    extract = ImageExtract()
    extract.set_debug(True)
    mask = extract.filter_out_background('left.JPG')
    cv2.imwrite('mask.jpg', mask)
    print extract.most_area_are_black(mask)
    ImageExtract.find_center(mask)

ImageUploader.py

import cloudinary
import cloudinary.uploader
import cloudinary.api
from firebase import firebase
import time
import cv2


base_url = ''
db = firebase.FirebaseApplication(base_url)

cloudinary.config(
  cloud_name = "",
  api_key = "",
  api_secret = ""
)

class ImageUploader:

    def __init__(self):
        pass

    def deletePrevImages(self):
        db.delete('/image', None)

    def uploadImage(self, path, width, height):
        path = self.resizeImage(path, width, height)
        attList = cloudinary.uploader.upload(path)
        self.deletePrevImages()
        url = attList['secure_url']
        result = db.post('/image', url)
        print "post image to", url

    def resizeImage(self, path, width, height):
        img = cv2.imread(path)
        if img.shape[0] < height or img.shape[1] < width:
            return path
        resized_img = cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)
        cv2.imwrite('resized_img.jpg', resized_img)
        return 'resized_img.jpg'

Servo.py

import time
import RPi.GPIO as GPIO

# low pulse always 20 ms per cycle. 
low_pulse_time = 20

# to get speed zero, we shall set high_pulse_time to 1.5 ms
high_pulse_time_offset = 1.5 

# the max adjustable range for high pulse is 0.75 ms [1.5-0.75, 1.5+0.75]
high_pulse_max_range = 0.2 


class Servo:

    def __init__(self, port_num):
        self.port_num = port_num
        GPIO.setmode(GPIO.BCM)
        GPIO.setwarnings(False)
        GPIO.setup(port_num, GPIO.OUT)
        self.p = GPIO.PWM(port_num, 1000.0 / (low_pulse_time + high_pulse_time_offset))
        self.p.start(high_pulse_time_offset / (low_pulse_time + high_pulse_time_offset))
        self.debug = False
        self.set_speed(0)

    def set_debug(self, debug):
        self.debug = debug

    def set_speed(self, speed):
        """
        The speed is an integer with the range of [-10, 10]. 
        -10 means turning in full speed toward one direction. 
        10  means turning in full speed toward another direction.
        0   means steady. 
        """
        assert speed <= 10 and speed >= -10

        high_pulse_time = high_pulse_time_offset + high_pulse_max_range * speed / 10.0
        total_pulse_time = high_pulse_time + low_pulse_time
        frequency = 1000.0 / total_pulse_time
        duty_cycle = (high_pulse_time / total_pulse_time) * 100
        self.p.ChangeFrequency(frequency)
        self.p.ChangeDutyCycle(duty_cycle)

        if self.debug: 
            print 'high_pulse_time is', high_pulse_time, 'ms'
            print 'total_pulse_time is', total_pulse_time, 'ms'
            print 'frequency is', frequency
            print 'duty cycle is ', duty_cycle
            print ''


# Test
if __name__ == '__main__':

    left_servo = Servo(18)
    left_servo.set_debug(True)
    time.sleep(3)
    left_servo.set_speed(5)
    time.sleep(3)
    left_servo.set_speed(10)
    time.sleep(3)
    left_servo.set_speed(-7.5)
    time.sleep(3)
    left_servo.set_speed(50)
    time.sleep(3)

ServoControl.py

import time
from Servo import Servo

half_speed = 5
zero_speed = 0

left_servo_orientation = 1
right_servo_orientation = -1

class ServoController:

    """
    Control both servos to make the car move forward, backward or turn round. 
    """
    def __init__(self, left_servo_port_number, right_servo_port_number):
        self.debug = False
        self.left_servo = Servo(left_servo_port_number)
        self.right_servo = Servo(right_servo_port_number)
        self.left_servo_speed = 0   # 0 means stop, 10 means full speed forward
        self.right_servo_speed = 0
        self.set_speed()

    def set_speed(self): 
        if self.debug:
            self.print_speed()
        self.left_servo.set_speed(self.left_servo_speed)
        self.right_servo.set_speed(self.right_servo_speed)

    def turn_right(self):
        self.left_servo_speed = half_speed * left_servo_orientation
        self.right_servo_speed = zero_speed
        self.set_speed()

    def turn_left(self):
        self.right_servo_speed = half_speed * right_servo_orientation
        self.left_servo_speed = zero_speed
        self.set_speed()

    def go_left_forward(self, speed):
        assert speed <= 10 and speed >= 0
        self.left_servo_speed = speed * left_servo_orientation * 3 / 4
        self.right_servo_speed = speed * right_servo_orientation
        self.set_speed()    

    def go_right_forward(self, speed):
        assert speed <= 10 and speed >= 0
        self.left_servo_speed = speed * left_servo_orientation 
        self.right_servo_speed = speed * right_servo_orientation * 1 / 2
        self.set_speed()


    def go_straight_ahead(self, speed):
        """
        speed: 0 means stop, 10 means full speed forward
        """
        assert speed <= 10 and speed >= 0
        self.left_servo_speed = speed * left_servo_orientation
        self.right_servo_speed = speed * right_servo_orientation
        self.set_speed()

    def print_speed(self):
        print 'left servo speed:', self.left_servo_speed
        print 'right servo speed:', self.right_servo_speed

    def set_debug(self, debug):
        self.debug = debug



if __name__ == '__main__':

    try: 
        servo_controller = ServoController(5, 6)
        print 'servos have been activated'
        time.sleep(3)

        while 1:

            #servo_controller.go_straight_ahead(0)
            servo_controller.go_left_forward(5)
            #servo_controller.go_right_forward(5)
            print 'go'
            time.sleep(10)

    except KeyboardInterrupt:
        pass

new_main.py

import time
from Servo import Servo
from ServoController import ServoController
from Camera import Camera
from ImageUploader import ImageUploader
from ImageExtract import ImageExtract
from DB import DB

dir = 0
speed = 5

def auto_mode(servo_controller, camera, imageUploader, imageExtract):
    camera.takePicture("image.jpg")       
    image = imageExtract.filter_out_background("image.jpg")
    shallStop = imageExtract.most_area_are_black(image)
    image_center = imageExtract.find_center_quick(image);
    print 'image center:', image_center

    if image_center[1] <= 6:
        servo_controller.go_right_forward(5)
    elif image_center[1] >= 14:
        servo_controller.go_left_forward(5)
    else:
        servo_controller.go_straight_ahead(5)

    return shallStop

def manualMode(servo_controller, camera, imageUploader):
    global dir
    global speed
    dir = DB.readDirection()
    if dir == -1:
        servo_controller.turn_left()
    elif dir == 1:
        servo_controller.turn_right()
    else:
        servo_controller.go_straight_ahead(speed)
        speed = DB.readSpeed()
    #camera.takePicture("image.jpg")
    #imageUploader.uploadImage("image.jpg", 200, 150)

if __name__ == '__main__':

    camera = Camera()
    imageUploader = ImageUploader()
    imageExtract = ImageExtract()
    DB = DB()

    try:
        servo_controller = ServoController(5, 6)
        print 'servos have been activated'

        while 1:
            mode = DB.readMode()
            if mode == 1:
                if auto_mode(servo_controller, camera, imageUploader, imageExtract):
                    servo_controller.go_straight_ahead(0)
                    imageUploader.uploadImage("image.jpg", 200, 150)
                    break
            else:
                manualMode(servo_controller, camera, imageUploader)

    except KeyboardInterrupt:
        pass