Cleaner

.gitignore

@@ -0,0 +1 @@
+images/

README.md

@@ -1,2 +1,7 @@
 # RaspberryDrive
 Use a Raspberry Pi 3 to drive an RC Car
+
+## Libraries
+Python 2
+SimpleCV
+PiCamera

analyzeLine.py

@@ -0,0 +1,24 @@
+import SimpleCV
+import cv2
+import time
+
+
+def findBlockingBlobs(img,blobs):
+	for blob in blobs:
+		if blockingBlob(img,blob):
+			return True
+		return False
+
+def blockingBlob(img,blob):
+	if heightBelowThreshold(img,blob):
+		if lengthSufficientToBlock(img,blob):
+			return True
+
+def heightBelowThreshold(img,blob):
+	if (blob.maxY() > img.size()[1] * 0.4):
+		return True
+
+def lengthSufficientToBlock(img,blob):
+	if (blob.width() > img.size()[0] * 0.55):
+			return True
+

connect.py

@@ -0,0 +1,23 @@
+import socket
+
+def new_connection():
+    host = '192.168.2.4'
+    port = 9000
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect((host, port))
+    return s;
+
+def send_command(connection,command,time):
+    connection.send('' + command + ' ; ' + time)
+
+def receive_confirmation(connection):
+  received = connection.recv(20)
+  return received;
+
+def send_end_connection(connection):
+  connection.send('quit')
+  return
+
+# example:
+# con = new_conntection
+# send_command(con,"forward",0.5)

controllers/controller.py

@@ -0,0 +1,56 @@
+import os
+import sys
+from time import sleep
+sys.path.insert(0, os.getcwd())
+from models import analyzeLine
+from models import runAnalyzeLine
+from models.runAnalyzeLine import runAnalyzeLines
+# from models.analyze import findBlockingBlobs
+from models.analyzeLine import findBlockingBlobs
+from get_images_from_pi import get_image, valid_image
+from connect import new_connection, send_command, receive_confirmation,send_end_connection
+from start_camera import start_camera
+from start_server import start_server
+import threading
+
+#Start-all
+threads = []
+#start the server listening on contr pi
+server_thread = threading.Thread(target=start_server)
+threads.append(server_thread)
+server_thread.start()
+#Sleep for testing
+sleep(2)
+#start the camera taking pictures on camera pi
+camera_thread = threading.Thread(target=start_camera)
+threads.append(camera_thread)
+camera_thread.start()
+# Sleep to make sure server connects
+sleep(5)
+#start the server connection on this current server
+s = new_connection()
+
+#Run-All.  X times do
+    #retrieve image.  #Blog Detection
+    #send instruction over server
+count = 0
+while (count < 20):
+  instruction = "forward"
+  get_image()
+  if valid_image(os.getcwd() + "/gregTest.jpg"):
+    in_way = runAnalyzeLines(os.getcwd() + "/gregTest.jpg")
+    if (in_way == True):
+      instruction = "stop"
+    send_command(s, instruction, "0.5")
+    receive_confirmation(s)
+    # sleep(0.25)
+    print instruction
+  count += 1
+
+# #End-all
+#   #Stop the camera taking pictures on the camera pi -- still needs to be implemented
+#   #close the server connection
+send_end_connection(s)
+#   #Kill the server listening process
+s.close()
+exit()

driving_server.py

@@ -0,0 +1,45 @@
+from socket import *
+import run_rc_car as picar
+
+def createPiReceiver():
+    	serversocket = socket(AF_INET, SOCK_STREAM)
+	port = 9000
+    	new_picar = picar.PiCar()
+    	serversocket.bind(('',port))
+   	serversocket.listen(5)
+	print "New Server Created, listening on port " + str(port)
+    	while(1):
+        	(clientsocket, address) = serversocket.accept()
+		print "accepted connection from " + str(address)
+		while(1):
+        		transfer = clientsocket.recv(20).split(';')
+			if not transfer: break 
+			if transfer == ['']: break	
+			print "received: " + transfer
+			try:
+				inputParser(transfer[0].strip(),float(transfer[1]),new_picar)
+				clientsocket.send("true")
+			except Exception:
+				clientsocket.send("false")
+			continue
+
+
+def inputParser(command,number,car):
+	print 'executing ' + command + ' for ' + str(number) +' seconds'
+	if   command == "forward":
+		car.go_forward(number)
+	elif command == "backward":
+		car.go_backward(number)
+	elif command == "right":
+		car.go_forward_right(number)
+	elif command == "left":
+		car.go_forward_left(number)
+	elif command == "backward right":
+		car.go_backward_right(number)
+	elif command == "backward left":
+		car.go_backward_left(number)
+	else:
+		car.stop()
+
+
+createPiReceiver()

get_images_from_pi.py

@@ -0,0 +1,15 @@
+import os
+from PIL import Image
+
+def get_image():
+	os.system('scp pi@192.168.2.5:Desktop/gregTest.jpg gregTest.jpg')
+	return
+	#if on a new computer and the pi address isn't connecting right away, need to create a key.  Use the following website to do so
+	#https://www.raspberrypi.org/documentation/remote-access/ssh/passwordless.md
+
+def valid_image(path):
+	try:
+		Image.open(path)
+	except IOError:
+		return False
+	return True

pseudocode.py

@@ -1,6 +1,3 @@
-
-
-
 def driveforward(time):
   FOR each second in time
     goforward(1)

runAnalyzeLine.py

@@ -0,0 +1,14 @@
+import SimpleCV
+import cv2
+import time
+from analyzeLine import *
+
+def runAnalyzeLines(image):
+  scvImg = SimpleCV.Image(image)
+  segmented = scvImg.stretch(160,161)
+  blobs = segmented.findBlobs(minsize=100)
+  if (blobs and (len(blobs) > 0)):
+    return findBlockingBlobs(scvImg,blobs)
+  return False
+  # print x
+	# print blob

run_rc_car.py

@@ -0,0 +1,63 @@
+import RPi.GPIO as GPIO
+from time import sleep
+
+class PiCar(object):
+
+	def __init__(self):
+		GPIO.setmode(GPIO.BOARD)
+        	self.pins = {'left'     : 11,
+                	     'right'    : 18,
+                	     'forward'  : 16,
+                     	     'backward' : 12 }
+        	for pin_number in self.pins.itervalues():
+            		GPIO.setup(pin_number,GPIO.OUT)
+		self.stop()
+
+
+	def stop(self):
+        	for pin_number in self.pins.itervalues():
+             		GPIO.output(pin_number,0)
+
+     	def go_forward(self,time):
+        	self.stop()
+         	GPIO.output(self.pins['forward'],1)
+         	sleep(int(time))
+         	self.stop()
+
+	def go_backward(self,time):
+        	self.stop()
+         	GPIO.output(self.pins['backward'],1)
+         	sleep(int(time))
+         	self.stop()
+
+     	def go_forward_right(self,time):
+        	self.stop()
+         	GPIO.output(self.pins['right'],1)
+         	GPIO.output(self.pins['forward'],1)
+         	sleep(int(time))
+         	self.stop()
+
+	def go_forward_left(self,time):
+		self.stop()
+         	GPIO.output(self.pins['left'],1)
+         	GPIO.output(self.pins['forward'],1)
+         	sleep(int(time))
+        	self.stop()
+
+	def go_backward_right(self,time):
+         	self.stop()
+         	GPIO.output(self.pins['right'],1)
+         	GPIO.output(self.pins['backward'],1)
+         	sleep(int(time))
+         	self.stop()
+
+	def go_backward_left(self,time):
+         	self.stop()
+         	GPIO.output(self.pins['left'],1)
+         	GPIO.output(self.pins['backward'],1)
+         	sleep(int(time))
+         	self.stop()
+
+
+picar = PiCar()
+

start_camera.py

@@ -0,0 +1,6 @@
+import os
+
+def start_camera():
+  os.system('ssh pi@192.168.2.5 python RaspberryDrive/views/takePicture.py &')
+  return
+

start_server.py

@@ -0,0 +1,6 @@
+import os
+
+def start_server():
+  os.system('ssh pi@192.168.2.4 python python-libs/RaspberryDrive/driving_server.py &')
+  return
+

takePicture.py

@@ -0,0 +1,20 @@
+import picamera as p
+import os
+import time
+
+os.chdir('/home/pi/Desktop')
+
+cam = p.PiCamera()
+cam.resolution = (320,240)
+cam.hflip = True
+cam.vflip = True
+
+x = 0
+
+while x < 50:
+	#os.unlink('greg.jpg')
+	img = cam.capture('gregTest.jpg')
+	time.sleep(.25)
+	#oc.rename('gregTemp.jpg', 'greg.jpg')
+	x +=1
+exit()