Raspberry Pi 2Pin = Register 1K pin = Switch first pin
Raspberry Pi 4pin = ultrasonic sensor Vcc pin
Raspberry Pi 5pin = Switch second pin
Raspberry Pi 6pin = ultrasonic sensor GND pin
Raspberry Pi 16pin = ultrasonic sensor Trig pin
Raspberry Pi 18pin = Register 2K pin = ultrasonic sensor Echo pin
Raspberry Pi 20pin = Register 1K pin = ultrasonic sensor Echo pin
Raspberry Pi 39pin = Switch third pin

import RPi.GPIO as GPIO
from time import sleep
import os
import argparse
import cv2
import numpy as np
import sys
import time
from threading import Thread
import importlib.util
import signal

left_switch = 3 #Switch assumed as signal light

#GPIO Setting
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(left_switch,GPIO.IN,GPIO.PUD_UP)
GPIO.setup(right_switch,GPIO.IN,GPIO.PUD_UP)

def distanceInCm(duration): #Function that returns duration as distance in cm
return (duration/2)/29.1

def print_distance(distance): #A function that sets the distanceMsg differently depending on the distance value.
if distance == 0:
distanceMsg = ‘Distance : out of range \r’
else:
distanceMsg = ‘Distance : ‘+str(distance)+’cm’+’ \r’
return distanceMsg

#Set pin number of ultrasonic sensor
TRIG = 23 #TRIG Numbering
ECHO = 24 #ECHO Numbering

MAX_DISTANCE_CM = 300
MAX_DURATION_TIMEOUT = (MAX_DISTANCE_CM * 2 * 29.1)

GPIO.setmode(GPIO.BCM)

GPIO.setup(TRIG, GPIO.OUT) #TRIG Ultrasonic Signal Transmission Pin Designation and Specify Output
GPIO.setup(ECHO, GPIO.IN) #Specify ECHO Ultrasonic Signal Receiving Pin and Specify Output

#Thread to manage webcam
class VideoStream:
“”"Camera object that controls video streaming from the Picamera”"”
def __init__(self, resolution=(640,480), framerate=30):
self.stream = cv2.VideoCapture(0) #Trun on the camera
ret = self.stream.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*’MJPG’))
#frame size init
ret = self.stream.set(3, resolution[0])
ret = self.stream.set(4, resolution[1])

# Read first frame from the stream
(self.grabbed, self.frame) = self.stream.read()

# Variable to control when the camera is stopped
self.stopped = False

def start(self): # Start the thread that reads frames from the video stream
Thread(target=self.update,args=()).start()
return self
def update(self): #Keep looping indefinitely until the thread is stopped
while True:
#If the camera is stopped, stop the thread
if self.stopped:
#Close camera resources
self.stream.release()
return
#Otherwise, grab the next frame from the stream
(self.grabbed, self.frame) = self.stream.read()

def read(self): #Return the most recent frame
return self.frame

def stop(self): #Indicate that the camera and thread should be stopped
self.stopped = True

#Define and parse input arguments
parser = argparse.ArgumentParser()
parser.add_argument(‘–modeldir’, help=’Folder the .tflite file is located in’, required=True)

parser.add_argument(‘–edgetpu’, help=’Use Coral Edge TPU Accelerator to speed up detection’, action=’store_true’)

args = parser.parse_args()

MODEL_NAME = args.modeldir
GRAPH_NAME = args.graph
LABELMAP_NAME = args.labels
min_conf_threshold = float(args.threshold)
resW, resH = args.resolution.split(‘x’)
imW, imH = int(resW), int(resH)
use_TPU = args.edgetpu

#Import TensorFlow libraries
#If tensorflow is not installed, import interpreter from tflite_runtime, else import from regular tensorflow
#If using Coral Edge TPU, import the load_delegate library
pkg = importlib.util.find_spec(‘tensorflow’)
if pkg is None:
from tflite_runtime.interpreter import Interpreter
if use_TPU:
from tflite_runtime.interpreter import load_delegate
else:
from tensorflow.lite.python.interpreter import Interpreter
if use_TPU:
from tensorflow.lite.python.interpreter import load_delegate

#If using Edge TPU, assign filename for Edge TPU model
if use_TPU: #If user has specified the name of the .tflite file, use that name, otherwise use default ‘edgetpu.tflite’
if (GRAPH_NAME == ‘detect.tflite’):
GRAPH_NAME = ‘edgetpu.tflite’

#Get path to current working directory
CWD_PATH = os.getcwd()

#Path to .tflite file, which contains the model that is used for object detection
PATH_TO_CKPT = os.path.join(CWD_PATH,MODEL_NAME,GRAPH_NAME)

#Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH,MODEL_NAME,LABELMAP_NAME)

#Load the label map
with open(PATH_TO_LABELS, ‘r’) as f:
labels = [line.strip() for line in f.readlines()]

#Have to do a weird fix for label map if using the COCO “starter model” from
#https://www.tensorflow.org/lite/models/object_detection/overview
#First label is ‘???’, which has to be removed.
if labels[0] == ‘???’:
del(labels[0])

#Load the Tensorflow Lite model.
#If using Edge TPU, use special load_delegate argument
if use_TPU:
interpreter = Interpreter(model_path=PATH_TO_CKPT,
experimental_delegates=[load_delegate('libedgetpu.so.1.0')])
print(PATH_TO_CKPT)
else:
interpreter = Interpreter(model_path=PATH_TO_CKPT)

interpreter.allocate_tensors()

#Get model details
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
height = input_details[0]['shape'][1] width = input_details[0]['shape'][2]

floating_model = (input_details[0]['dtype'] == np.float32)

input_mean = 127.5
input_std = 127.5

#Initialize frame rate calculation
frame_rate_calc = 1
freq = cv2.getTickFrequency()

#Initialize video stream
videostream = VideoStream(resolution=(imW,imH),framerate=30).start()
time.sleep(1)

#for frame1 in camera.capture_continuous(rawCapture, format=”bgr”,use_video_port=True):
while True:
if GPIO.input(left_switch) == 1: #Start timer (for calculating frame rate)
t1 = cv2.getTickCount()

#Grab frame from video stream
frame1 = videostream.read()

#Acquire frame and resize to expected shape [1xHxWx3] frame = frame1.copy()
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frame_resized = cv2.resize(frame_rgb, (width, height))
input_data = np.expand_dims(frame_resized, axis=0)

#Normalize pixel values if using a floating model (i.e. if model is non-quantized)
if floating_model:
input_data = (np.float32(input_data) – input_mean) / input_std

#Perform the actual detection by running the model with the image as input
interpreter.set_tensor(input_details[0]['index'],input_data)
interpreter.invoke()

#Retrieve detection results
boxes = interpreter.get_tensor(output_details[0]['index'])[0] #Bounding box coordinates of detected objects
classes = interpreter.get_tensor(output_details[1]['index'])[0] #Class index of detected objects
scores = interpreter.get_tensor(output_details[2]['index'])[0] #Confidence of detected objects
#num = interpreter.get_tensor(output_details[3]['index'])[0] #Total number of detected objects (inaccurate and not needed)

pulse_start=0
pulse_end=0

GPIO.output(TRIG, False) #Keep the trigger pin off.
time.sleep(2)

GPIO.output(TRIG, True) #Exits 10us pulse.
time.sleep(0.00001) #At Python, this pulse will be almost 100 us.
GPIO.output(TRIG, False)

timeout = time.time()
while GPIO.input(ECHO) == 0:
pulse_start = time.time() #Set the start time when the echo pin is turned on.
if ((pulse_start – timeout)*1000000) >= MAX_DURATION_TIMEOUT:
fail = True
break

timeout = time.time()
while GPIO.input(ECHO) == 1:
pulse_end = time.time() #Set the reflector receiving time when the echo pin is turned off.
if ((pulse_end – pulse_start)*1000000) >= MAX_DURATION_TIMEOUT:
print_distance(0)
fail = True
break

pulse_duration = (pulse_end – pulse_start) * 1000000
pulse_duration=pulse_end-pulse_start #Calculate pulse length
distance = distanceInCm(pulse_duration)
distance=(pulse_duration*34000.0)/2 #The duration is divided in half.
distance = round(distance, 2)
MSG=print_distance(distance)

#Loop over all detections and draw detection box if confidence is above minimum threshold
for i in range(len(scores)):
if ((scores[i] > min_conf_threshold) and (scores[i] <= 1.0)):

#Get bounding box coordinates and draw box
#Interpreter can return coordinates that are outside of image dimensions, need to force them to be within image using max() and min()
ymin = int(max(1,(boxes[i][0] * imH)))
xmin = int(max(1,(boxes[i][1] * imW)))
ymax = int(min(imH,(boxes[i][2] * imH)))
xmax = int(min(imW,(boxes[i][3] * imW)))

cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (10, 255, 0), 2)
a=(xmax-xmin)/2
b = int(a)
if distance < 16:
frame = cv2.line(frame, (650, 720), (xmin+b, ymax), (0, 0, 255), 3)
elif distance >=16 and distance < 20:
frame = cv2.line(frame, (650, 720), (xmin+b, ymax), (0, 150, 255), 3)
else:
frame = cv2.line(frame, (650, 720), (xmin+b, ymax), (0, 255, 0), 3)

#Draw label
object_name = labels[int(classes[i])] #Look up object name from “labels” array using class index
label = ‘%s: %d%%’ % (object_name, int(scores[i]*100)) #Example: ‘person: 72%’
labelSize, baseLine = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2) #Get font size
label_ymin = max(ymin, labelSize[1] + 10) #Make sure not to draw label too close to top of window
cv2.rectangle(frame, (xmin, label_ymin-labelSize[1]-10), (xmin+labelSize[0], label_ymin+baseLine-10), (255, 255, 255), cv2.FILLED) #Draw white box to put label text in
cv2.putText(frame, label, (xmin, label_ymin-7), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2) #Draw label text

#Draw distance in corner of frame
cv2.putText(frame, MSG,(30,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,0),2,cv2.LINE_AA)

#All the results have been drawn on the frame, so it’s time to display it.
cv2.imshow(‘Object detector’, frame)

#Calculate framerate
t2 = cv2.getTickCount()
time1 = (t2-t1)/freq
frame_rate_calc= 1/time1

#Press ‘q’ to quit
if cv2.waitKey(1) == ord(‘q’):
break
else: #Exit program if switch off
break
#Clean up
GPIO.cleanup()
cv2.destroyAllWindows()
videostream.stop()