Using 5V 3Amp power supply for RPI4, and usbc3 cable to connect to Oak-1 camera.
The first few minutes of this running for the day does not crash at all, and then it begins to give X_LINK_ERROR every few seconds. It works fine when running on my mac, but not on RPI.
What can be causing this?
Console Logs:
First Image is on first initiation, second is while running.
Code:
from pathlib import Path
import sys
import os
import cv2
import depthai as dai
import numpy as np
import time
import argparse
import json
import blobconverter
import datetime
# Print count at set interval
def print_count(count, previous_time):
# Print every X seconds
TIME_INTERVAL = 60
timestamp = datetime.datetime.utcnow()
# Interval time hasn't passed, do nothing and pass same previous_time out
if ((timestamp - previous_time).seconds < TIME_INTERVAL):
return previous_time
# Interval time passed, print
else:
print(count)
return timestamp
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument("-m", "--model", help="Provide model name or model path for inference",
default='best_openvino_2022.1_6shave.blob', type=str)
parser.add_argument("-c", "--config", help="Provide config path for inference",
default='best_openvino_2022.1_6shave.json', type=str)
parser.add_argument('-roi', '--roi_position', type=float,
default=0.25, help='ROI Position (0-1)')
parser.add_argument('-a', '--axis', default=False, action='store_false',
help='Axis for cumulative counting (default=x axis)')
args = parser.parse_args()
# parse config
configPath = Path(args.config)
if not configPath.exists():
raise ValueError("Path {} does not exist!".format(configPath))
with configPath.open() as f:
config = json.load(f)
nnConfig = config.get("nn_config", {})
# parse input shape
if "input_size" in nnConfig:
W, H = tuple(map(int, nnConfig.get("input_size").split('x')))
# extract metadata
metadata = nnConfig.get("NN_specific_metadata", {})
classes = metadata.get("classes", {})
coordinates = metadata.get("coordinates", {})
anchors = metadata.get("anchors", {})
anchorMasks = metadata.get("anchor_masks", {})
iouThreshold = metadata.get("iou_threshold", {})
confidenceThreshold = metadata.get("confidence_threshold", {})
print(metadata)
# parse labels
nnMappings = config.get("mappings", {})
labels = nnMappings.get("labels", {})
# get model path
nnPath = args.model
if not Path(nnPath).exists():
print("No blob found at {}.".format(nnPath))
nnPath = str(blobconverter.from_zoo(args.model, shaves = 6, zoo_type = "depthai", use_cache=True))
# sync outputs
syncNN = True
# Create pipeline
pipeline = dai.Pipeline()
# Define sources and outputs
camRgb = pipeline.create(dai.node.ColorCamera)
detectionNetwork = pipeline.create(dai.node.YoloDetectionNetwork)
objectTracker = pipeline.create(dai.node.ObjectTracker)
configIn = pipeline.create(dai.node.XLinkIn)
xlinkOut = pipeline.create(dai.node.XLinkOut)
trackerOut = pipeline.create(dai.node.XLinkOut)
xlinkOut.setStreamName("preview")
trackerOut.setStreamName("tracklets")
configIn.setStreamName('config')
# Properties
camRgb.setPreviewSize(W, H)
camRgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
camRgb.setInterleaved(False)
camRgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.BGR)
camRgb.setFps(35)
camRgb.setPreviewKeepAspectRatio(False)
# Network specific settings
detectionNetwork.setConfidenceThreshold(confidenceThreshold)
detectionNetwork.setNumClasses(classes)
detectionNetwork.setCoordinateSize(coordinates)
detectionNetwork.setAnchors(anchors)
detectionNetwork.setAnchorMasks(anchorMasks)
detectionNetwork.setIouThreshold(iouThreshold)
detectionNetwork.setBlobPath(nnPath)
detectionNetwork.setNumInferenceThreads(2)
detectionNetwork.input.setBlocking(False)
objectTracker.setDetectionLabelsToTrack([0]) # track only person
# possible tracking types: ZERO_TERM_COLOR_HISTOGRAM, ZERO_TERM_IMAGELESS, SHORT_TERM_IMAGELESS, SHORT_TERM_KCF
objectTracker.setTrackerType(dai.TrackerType.ZERO_TERM_COLOR_HISTOGRAM)
# take the smallest ID when new object is tracked, possible options: SMALLEST_ID, UNIQUE_ID
objectTracker.setTrackerIdAssignmentPolicy(dai.TrackerIdAssignmentPolicy.UNIQUE_ID)
objectTracker.setTrackerThreshold(0.5)
# Linking
camRgb.preview.link(detectionNetwork.input)
objectTracker.passthroughTrackerFrame.link(xlinkOut.input)
configIn.out.link(camRgb.inputConfig)
camRgb.preview.link(objectTracker.inputTrackerFrame)
#detectionNetwork.passthrough.link(objectTracker.inputTrackerFrame)
detectionNetwork.passthrough.link(objectTracker.inputDetectionFrame)
detectionNetwork.out.link(objectTracker.inputDetections)
objectTracker.out.link(trackerOut.input)
# from https://www.pyimagesearch.com/2018/08/13/opencv-people-counter/
class TrackableObject:
def __init__(self, objectID, centroid):
# store the object ID, then initialize a list of centroids
# using the current centroid
self.objectID = objectID
self.centroids = [centroid]
# initialize a boolean used to indicate if the object has
# already been counted or not
self.counted = False
# Set initial timestamp for print interval
timestamp = datetime.datetime.utcnow()
# Set initial count from counter.txt file
objectCounter = int(open("counter.txt", "r").read())
while True:
try:
# Connect to device and start pipeline
with dai.Device(pipeline) as device:
#preview = device.getOutputQueue("preview", 4, False)
preview = device.getOutputQueue("preview", 1, False)
tracklets = device.getOutputQueue("tracklets", 4, False)
configQueue = device.getInputQueue("config")
# Max cropX & cropY
maxCropX = (camRgb.getIspWidth() - camRgb.getVideoWidth()) / camRgb.getIspWidth()
maxCropY = (camRgb.getIspHeight() - camRgb.getVideoHeight()) / camRgb.getIspHeight()
print(maxCropX, maxCropY, camRgb.getIspWidth(), camRgb.getVideoHeight())
# Default crop
cropX = 0
cropY = 0
sendCamConfig = True
if sendCamConfig:
cfg = dai.ImageManipConfig()
cfg.setCropRect(cropX, cropY, maxCropX, maxCropY)
configQueue.send(cfg)
print('crop - x: ', cropX, 'crop - y: ', cropY)
startTime = time.monotonic()
counter = 0
fps = 0
frame = None
trackableObjects = {}
while(True):
try:
imgFrame = preview.get()
track = tracklets.get()
counter+=1
current_time = time.monotonic()
if (current_time - startTime) > 1 :
fps = counter / (current_time - startTime)
counter = 0
startTime = current_time
color = (255, 0, 0)
frame = imgFrame.getCvFrame()
height = frame.shape[0]
width = frame.shape[1]
trackletsData = track.tracklets
for t in trackletsData:
to = trackableObjects.get(t.id, None)
# calculate centroid
roi = t.roi.denormalize(frame.shape[1], frame.shape[0])
x1 = int(roi.topLeft().x)
y1 = int(roi.topLeft().y)
x2 = int(roi.bottomRight().x)
y2 = int(roi.bottomRight().y)
centroid = (int((x2-x1)/2+x1), int((y2-y1)/2+y1))
newX = int((x2-x1)/2+x1)
newY = int((y2-y1)/2+y1)
# If new tracklet, save its centroid
if t.status == dai.Tracklet.TrackingStatus.NEW:
to = TrackableObject(t.id, centroid)
elif to is not None:
if not to.counted:
y = [c[1] for c in to.centroids]
direction = centroid[1] - np.mean(y)
if centroid[1] > args.roi_position*height and direction > 0 and np.mean(y) < args.roi_position*height:
objectCounter += 1
if objectCounter > 999999 :
objectCounter = 0
open("counter.txt", "w").write(str(objectCounter))
to.counted = True
to.centroids.append(centroid)
trackableObjects[t.id] = to
#Update timestamp and print if interval time passed
timestamp = print_count(objectCounter, timestamp)
except RuntimeError as e:
print(datetime.datetime.utcnow())
print(f"Error reading data from depthAI device: {e}")
break # Break out of loop and reinitialize
except:
continue
