# Create a ZED camera object
zed = sl.Camera()

# Set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD1080
init_params.camera_fps = 30

# Close the camera
zed.close()

# Create a ZED camera object
zed = sl.Camera()

# Set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD1080  # Use HD1080 video mode
init_params.camera_fps = 30  # Set fps at 30

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

# Grab an image
runtime_parameters = sl.RuntimeParameters()
if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
    # A new image is available if grab() returns ERROR_CODE.SUCCESS

# Capture 50 frames and stop
i = 0
image = sl.Mat()
runtime_parameters = sl.RuntimeParameters()
while i < 50:
    # Grab an image, a RuntimeParameters object must be given to grab()
    if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
        # A new image is available if grab() returns ERROR_CODE.SUCCESS
        zed.retrieve_image(image, sl.VIEW.LEFT) # Get the left image
        timestamp = zed.get_timestamp(sl.TIME_REFERENCE.IMAGE)  # Get the image timestamp
        print("Image resolution: {0} x {1} || Image timestamp: {2}\n".format(image.get_width(), image.get_height(), timestamp.get_milliseconds()))
        i = i + 1

# Close the camera
zed.close()

# Create a ZED camera
zed = sl.Camera()
init_params = sl.InitParameters()
init_params.sdk_verbose = True # Enable verbose logging
init_params.depth_mode = sl.DEPTH_MODE.PERFORMANCE # Set the depth mode to performance (fastest)
init_params.coordinate_units = sl.UNIT.MILLIMETER  # Use millimeter units

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
    print("Error {}, exit program".format(err)) # Display the error
    exit()

# Capture 50 images and depth, then stop
i = 0
image = sl.Mat()
depth = sl.Mat()
point_cloud = sl.Mat()
runtime_parameters = sl.RuntimeParameters()
while i < 50:
    # Grab an image
    if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
        # A new image is available if grab() returns sl.ERROR_CODE.SUCCESS
        zed.retrieve_image(image, sl.VIEW.LEFT) # Get the left image
        zed.retrieve_measure(depth, sl.MEASURE.DEPTH) # Retrieve depth matrix. Depth is aligned on the left RGB image
        zed.retrieve_measure(point_cloud, sl.MEASURE.XYZRGBA) # Retrieve colored point cloud
        i = i + 1

# Get and print distance value in mm at the center of the image
# We measure the distance camera - object using Euclidean distance
x = round(image.get_width() / 2)
y = round(image.get_height() / 2)
err, point_cloud_value = point_cloud.get_value(x, y)
distance = math.sqrt(point_cloud_value[0] * point_cloud_value[0] +
                     point_cloud_value[1] * point_cloud_value[1] +
                     point_cloud_value[2] * point_cloud_value[2])
print("Distance to Camera at ({0}, {1}): {2} mm".format(x, y, distance), end="\r")

x = round(image.get_width() / 2)
y = round(image.get_height() / 2)
err, depth_value = depth.get_value(x, y)
print("Distance to Camera at ({0}, {1}): {2} mm".format(x, y, depth_value), end="\r")

# Close the camera
zed.close()

#include <Servo.h>
Servo __myservo16;
Servo __myservo11;
Servo __myservo9;
Servo __myservo8;
Servo __myservo7;

if (Serial.available()) {
    // 讀取傳入的字串直到"\n"結尾
    str = Serial.readStringUntil('\n');

    String_to_Int(str, 2);
    Serial.println(SA[0]);
    Serial.println(A[1]);
  }

  if (SA[0] == "數值") {
    int PRE_angle = __myservo16.read();
    if (A[1] >= PRE_angle) {
      for (int angle=PRE_angle;angle<=A[1];angle++){
         __myservo16.write(angle);
         delay(20);
      }
      Serial.println("Servo_OK");
    }
    if (A[1] < PRE_angle) {
      for (int angle=PRE_angle;angle>=A[1];angle--){
         __myservo16.write(angle);
         delay(20);
      }
      Serial.println("Servo_OK");
    }    
  }

void String_to_Int(String temp, int count)
{
  int index;

  index = temp.indexOf(',');
  SA[0] = temp.substring(0, index);

  for (int i = 1; i < count; i++) {
    temp = temp.substring(index + 1, temp.length());
    index = temp.indexOf(',');
    SA[i] = temp.substring(0, index);
    A[i] = SA[i].toInt();
  }
}

python3 PHOTO_ARM.py --video 攝影機編號 --com UART連接埠編號
#例如
python3 PHOTO_ARM.py --video 0 --com 5

python PHOTO_ARM.py --video 攝影機編號 --com UART連接埠編號
#例如
python PHOTO_ARM.py --video 0 --com 5

Condition_1 = 'OBJ_1'
Condition_2 = 'OBJ_2'
Condition_3 = 'OBJ_3'
Condition_4 = 'OBJ_4'
Condition_Other = 'Other'

def get_prediction(image, interpreter, signature):
    影像推論的程式片段(略)
    return outputs
#image是即時影像資料
#interpreter是神經網路模型
#signature是模型參數檔內容

def process_image(image, input_shape):
    #影像前處理的程式片段(略)
    return image.reshape(input_shape).astype(np.float32)
#image是即時影像資料
#input_shape是輸入影像的解析度資訊

    COM_PORT = args.com  #COM_PORT變數設定UART通訊連接埠的編號
    BAUD_RATES = 9600  #BAUD_RATES變數設定RAUD為9600BPS
    ser = serial.Serial(COM_PORT, BAUD_RATES)  # 建立 ser 物件啟動序列通訊

if (times==1) and (key_flag == 0) and (Motion_Busy ==0):
    prediction = get_prediction(image, interpreter, signature)

if (classification_flag == 1) and (Label_name == Condition_1) and (prob > 0.5):
    Condition_1_count = Condition_1_count + 1
    Condition_2_count = 0
    Condition_3_count = 0
    Condition_4_count = 0

if (Condition_1_count == 50):
    Motion_Busy = 1
    伺服馬達動作角度設定片段程式(略)
     Motion_Busy = 0

read_dir_key = cv2.waitKeyEx(1)
if (read_dir_key != -1):
    print(read_dir_key)
    #進行各種按鍵偵測的動作程式片段(略)
    # 按 q鍵 或 Esc鍵 結束程式    
elif ((read_dir_key == 113) or (read_dir_key == 27)):
    key_detect = 1

if (key_flag == 1):
    cv2.rectangle(image_src,
        (box_left,box_top),(box_left+scale,box_top+scale),
        (0,255,0),2)
elif (key_flag == 0):
    cv2.rectangle(image_src,
         (box_left,box_top),(box_left+scale,box_top+scale),
        (0,0,255),2)

box_center_x = box_left + int(scale / 2)
box_center_y = box_top + int(scale / 2)

dw = int(frame_width / 2) - box_center_x
dh = frame_height - box_center_y
angle = (math.atan(dw / dh)) / math.pi * 180

cv2.line(image_src,
     (int(frame_width / 2),frame_height),
     (box_center_x,box_center_y),
     (0,255,255),2)

 cv2.putText(image_src, str(round(angle,3)),
     (int(frame_width * 0.6),30), cv2.FONT_HERSHEY_SIMPLEX, 1,
     (0,255,255), 6, cv2.LINE_AA)
cv2.putText(image_src, str(round(angle,3)),
    (int(frame_width * 0.6),30), cv2.FONT_HERSHEY_SIMPLEX, 1,
    (0,0,0), 2, cv2.LINE_AA)

cv2.imshow('Detecting_1 ....',image_src)

# Create a ZED camera object
zed = sl.Camera()

# Set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD720  # Use HD720 video mode (default fps: 60)
# Use a right-handed Y-up coordinate system
init_params.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP
init_params.coordinate_units = sl.UNIT.METER  # Set units in meters

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

# Enable positional tracking with default parameters
tracking_parameters = sl.PositionalTrackingParameters()
err = zed.enable_positional_tracking(tracking_parameters)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

# Track the camera position during 1000 frames
i = 0
zed_pose = sl.Pose()
runtime_parameters = sl.RuntimeParameters()
while i < 1000:
    if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
        # Get the pose of the left eye of the camera with reference to the world frame
        zed.get_position(zed_pose, sl.REFERENCE_FRAME.WORLD)

        # Display the translation and timestamp
        py_translation = sl.Translation()
        tx = round(zed_pose.get_translation(py_translation).get()[0], 3)
        ty = round(zed_pose.get_translation(py_translation).get()[1], 3)
        tz = round(zed_pose.get_translation(py_translation).get()[2], 3)
        print("Translation: Tx: {0}, Ty: {1}, Tz {2}, Timestamp: {3}\n".format(tx, ty, tz, zed_pose.timestamp.get_milliseconds()))

        # Display the orientation quaternion
        py_orientation = sl.Orientation()
        ox = round(zed_pose.get_orientation(py_orientation).get()[0], 3)
        oy = round(zed_pose.get_orientation(py_orientation).get()[1], 3)
        oz = round(zed_pose.get_orientation(py_orientation).get()[2], 3)
        ow = round(zed_pose.get_orientation(py_orientation).get()[3], 3)
        print("Orientation: Ox: {0}, Oy: {1}, Oz {2}, Ow: {3}\n".format(ox, oy, oz, ow))

sensors_data = sl.SensorsData()
zed.get_sensors_data(sensors_data, sl.TIME_REFERENCE.IMAGE)
zed_imu = zed_sensors.get_imu_data()
# Get IMU orientation
zed_imu_pose = sl.Transform()
ox = round(zed_imu.get_pose(zed_imu_pose).get_orientation().get()[0], 3)
oy = round(zed_imu.get_pose(zed_imu_pose).get_orientation().get()[1], 3)
oz = round(zed_imu.get_pose(zed_imu_pose).get_orientation().get()[2], 3)
ow = round(zed_imu.get_pose(zed_imu_pose).get_orientation().get()[3], 3)
print("IMU Orientation: Ox: {0}, Oy: {1}, Oz {2}, Ow: {3}\n".format(ox, oy, oz, ow))
# Get IMU acceleration
acceleration = [0,0,0]
zed_imu.get_linear_acceleration(acceleration)
ax = round(acceleration[0], 3)
ay = round(acceleration[1], 3)
az = round(acceleration[2], 3)
print("IMU Acceleration: Ax: {0}, Ay: {1}, Az {2}\n".format(ax, ay, az))

# Disable positional tracking and close the camera
zed.disable_positional_tracking();
zed.close()

# Create a ZED camera object
zed = sl.Camera()

# Set configuration parameters
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD720  # Use HD720 video mode (default fps: 60)
init_params.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP # Use a right-handed Y-up coordinate system
init_params.coordinate_units = sl.UNIT.METER  # Set units in meters

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

tracking_parameters = sl.PositionalTrackingParameters()
err = zed.enable_positional_tracking(tracking_parameters)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

mapping_parameters = sl.SpatialMappingParameters()
err = zed.enable_spatial_mapping(mapping_parameters)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

# Grab data during 3000 frames
i = 0
py_mesh = sl.Mesh()  # Create a Mesh object
runtime_parameters = sl.RuntimeParameters()
while i < 3000:
    if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS:
        # In background, spatial mapping will use new images, depth and pose to create and update the mesh. No specific functions are required here.
        mapping_state = zed.get_spatial_mapping_state()
        # Print spatial mapping state
        print("\rImages captured: {0} / 3000 || {1}".format(i, mapping_state))
        i = i + 1

err = zed.extract_whole_spatial_map(py_mesh) # Extract the whole mesh

filter_params = sl.MeshFilterParameters()
filter_params.set(sl.MESH_FILTER.LOW)
py_mesh.filter(filter_params) # Filter the mesh (remove unnecessary vertices and faces)
py_mesh.save("mesh.obj") # Save the mesh in an obj file

# Disable tracking and mapping and close the camera
zed.disable_spatial_mapping()
zed.disable_positional_tracking()
zed.close()

/*************************************************************

  You’ll need:
   - Blynk IoT app (download from App Store or Google Play)
   - Wio Terminal board
   - Decide how to connect to Blynk
     (USB, Ethernet, Wi-Fi, Bluetooth, ...)

  There is a bunch of great example sketches included to show you how to get
  started. Think of them as LEGO bricks  and combine them as you wish.
  For example, take the Ethernet Shield sketch and combine it with the
  Servo example, or choose a USB sketch and add a code from SendData
  example.
 *************************************************************/

// Template ID, Device Name and Auth Token are provided by the Blynk.Cloud
// See the Device Info tab, or Template settings
#define BLYNK_TEMPLATE_ID           "TMPLxxxxxx"
#define BLYNK_DEVICE_NAME           "Device"
#define BLYNK_AUTH_TOKEN            "YourAuthToken"


// Comment this out to disable prints and save space
#define BLYNK_PRINT Serial


#include <rpcWiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleWioTerminal.h>

char auth[] = BLYNK_AUTH_TOKEN;

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "YourNetworkName";
char pass[] = "YourPassword";

void setup()
{
  // Debug console
  Serial.begin(115200);

  Blynk.begin(auth, ssid, pass);
  // You can also specify server:
  //Blynk.begin(auth, ssid, pass, "blynk.cloud", 80);
  //Blynk.begin(auth, ssid, pass, IPAddress(192,168,1,100), 8080);
}

void loop()
{
  Blynk.run();
  // You can inject your own code or combine it with other sketches.
  // Check other examples on how to communicate with Blynk. Remember
  // to avoid delay() function!
}

# Create ZED objects
zed = sl.Camera()
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD720
init_params.depth_mode = sl.DEPTH_MODE.ULTRA
init_params.sdk_verbose = True

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
    # Quit if an error occurred
    exit()

# Define the Object Detection module parameters
detection_parameters = sl.ObjectDetectionParameters()
detection_parameters.image_sync = True
detection_parameters.enable_tracking = True
detection_parameters.enable_mask_output = True

# Object tracking requires camera tracking to be enabled
if detection_parameters.enable_tracking:
    zed.enable_positional_tracking()

print("Object Detection: Loading Module...")
err = zed.enable_object_detection(detection_parameters)
if err != sl.ERROR_CODE.SUCCESS:
    print("Error {}, exit program".format(err))
    zed.close()
    exit()

# Set runtime parameter confidence to 40
detection_parameters_runtime = sl.ObjectDetectionRuntimeParameters()
detection_parameters_runtime.detection_confidence_threshold = 40

objects = sl.Objects()

# Grab new frames and detect objects
while zed.grab() == sl.ERROR_CODE.SUCCESS:
    err = zed.retrieve_objects(objects, detection_parameters_runtime)

    if objects.is_new:
        # Count the number of objects detected
        print("{} Object(s) detected".format(len(objects.object_list)))

        if len(objects.object_list):
            # Display the 3D location of an object
            first_object = objects.object_list[0]
            position = first_object.position
            print(" 3D position : [{0},{1},{2}]".format(position[0],position[1],position[2]))

            # Display its 3D bounding box coordinates
            bounding_box = first_object.bounding_box
            print(" Bounding box 3D :")
            for it in bounding_box:            
                print(" " + str(it),end='')

# Disable object detection and close the camera
zed.disable_object_detection()
zed.close()

# Create a ZED camera object
zed = sl.Camera()

# Set configuration parameters
init_params = sl.InitParameters()
# No depth computation required here
init_params.depth_mode = sl.DEPTH_MODE.NONE

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS :
    print(repr(err))
    zed.close()
    exit(1)

sensors_data = sl.SensorsData()
while zed.grab() == sl.ERROR_CODE_SUCCESS:
    zed.get_sensors_data(sensors_data, sl.TIME_REFERENCE.CURRENT)

ts_handler = TimestampHandler()
if ts_handler.is_new(sensors_data.get_imu_data()):
    # sensors_data.get_imu_data() contains new data

# Check if IMU data has been updated
if ts_handler.is_new(sensors_data.get_imu_data()):
    quaternion = sensors_data.get_imu_data().get_pose().get_orientation().get()
    print("IMU Orientation: {}".format(quaternion))
    linear_acceleration = sensors_data.get_imu_data().get_linear_acceleration()
    print("IMU Acceleration: {} [m/sec^2]".format(linear_acceleration))
    angular_velocity = sensors_data.get_imu_data().get_angular_velocity()
    print("IMU Angular Velocity: {} [deg/sec]".format(angular_velocity))

# Check if Magnetometer data has been updated
if ts_handler.is_new(sensors_data.get_magnetometer_data()):
    magnetic_field_calibrated = sensors_data.get_magnetometer_data().get_magnetic_field_calibrated()
    print("Magnetometer Magnetic Field: {} [uT]".format(magnetic_field_calibrated))

# Check if Barometer data has been updated 
if ts_handler.is_new(sensors_data.get_barometer_data()):
    magnetic_field_calibrated = sensors_data.get_barometer_data().pressure
    print("Barometer Atmospheric pressure: {} [hPa]".format(sensors_data.get_barometer_data().pressure))

# Close the camera
zed.close()

#define BLYNK_TEMPLATE_ID           ""
#define BLYNK_DEVICE_NAME           ""
#define BLYNK_AUTH_TOKEN            ""

// Comment this out to disable prints and save space
#define BLYNK_PRINT Serial

#include <rpcWiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleWioTerminal.h>

char auth[] = BLYNK_AUTH_TOKEN;

char ssid[] = "";      // wifi settings
char pass[] = "";

// built-in blynk functions when specified Vpin is changed
BLYNK_WRITE(V1) // slider
{
  int pin1Value = param.asInt(); // assigning incoming value from pin V1 to a variable
  Serial.print("V1 Slider value is: ");
  Serial.println(pin1Value);
}

BLYNK_WRITE(V2)  //switch
{
  int pin2Value = param.asInt(); 
  Serial.print("V2 switch value is: ");
  Serial.println(pin2Value);
}

void setup()
{
  // Debug console
  Serial.begin(115200);

  Blynk.begin(auth, ssid, pass);
  // You can also specify server:
  //Blynk.begin(auth, ssid, pass, "blynk.cloud", 80);
  //Blynk.begin(auth, ssid, pass, IPAddress(192,168,1,100), 8080);
}

void loop()
{
  Blynk.run();
}

pip install Mediapipe==0.8.7.1

pip install pyserial

python MediaPipeHandPose.py --video 2 --com 3

#主要程式來源來自:https://www.youtube.com/c/MurtazasWorkshopRoboticsandAI/featured

import serial
import argparse
import cv2
import time
import numpy as np
import math
import mediapipe as mp

########## 手部追蹤偵測 #############
class handDetector():
    def __init__(self, mode=False, maxHands=2, detectionCon=0.5, trackCon=0.5):
        self.mode = mode
        self.maxHands = maxHands
        self.detectionCon = detectionCon
        self.trackCon = trackCon

        self.mpHands = mp.solutions.hands
        self.hands = self.mpHands.Hands(self.mode, self.maxHands,
                                        self.detectionCon, self.trackCon)
        self.mpDraw = mp.solutions.drawing_utils

    def findHands(self, img, draw=True):
        imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        self.results = self.hands.process(imgRGB)
        # print(results.multi_hand_landmarks)

        if self.results.multi_hand_landmarks:
            for handLms in self.results.multi_hand_landmarks:
                if draw:
                    self.mpDraw.draw_landmarks(img, handLms,
                                               self.mpHands.HAND_CONNECTIONS)
        return img

    def findPosition(self, img, handNo=0, draw=True):

        lmList = []
        if self.results.multi_hand_landmarks:
            myHand = self.results.multi_hand_landmarks[handNo]
            for id, lm in enumerate(myHand.landmark):
                # print(id, lm)
                h, w, c = img.shape
                cx, cy = int(lm.x * w), int(lm.y * h)
                # print(id, cx, cy)
                lmList.append( [id, cx, cy])
                if draw:
                    cv2.circle(img, (cx, cy), 15, (255, 0, 255), cv2.FILLED)

        return lmList

def main():
    
############## 各參數設定 ##################
    pTime  = 0
    minPwm = 0
    maxPwm = 255
    briArd = 0
    briBar = 400
    briPer = 0
    
############## 指定WEBCAM和Arduino Serial Port編號的指令 ##################
    
    parser = argparse.ArgumentParser(
      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument(
    '--video', help='Video number', required=False, type=int, default=0)
    parser.add_argument(
      '--com', help='Number of UART prot.', required=True)
    args = parser.parse_args()
    
    COM_PORT = 'COM'+str(args.com)
    BAUD_RATES = 9600
    ser = serial.Serial(COM_PORT, BAUD_RATES)
    
    args = parser.parse_args()
    
    
############## WEBCAM相關參數定義 ##################
    wCam, hCam = 640, 480   
    cap = cv2.VideoCapture(args.video) # 攝影機編號預設為0，也可以輸入其他編號!
    cap.set(3, wCam)
    cap.set(4, hCam)
    detector = handDetector(detectionCon=0.7)

    try:
        while True:
            success, img = cap.read()
            img = detector.findHands(img)
            lmList = detector.findPosition(img, draw=False)
            #print(lmList)
            
            
            if len(lmList) != 0:
                x1, y1 = lmList[4][1], lmList[4][2]
                x2, y2 = lmList[8][1], lmList[8][2]
                cx, cy = (x1 + x2) // 2, (y1 + y2) // 2

                cv2.circle(img, (x1, y1), 15, (255, 0, 255), cv2.FILLED)
                cv2.circle(img, (x2, y2), 15, (255, 0, 255), cv2.FILLED)
                
                #計算大拇指和食指的直線中點距離
                cv2.line(img, (x1, y1), (x2, y2), (255, 0, 255), 3)
                cv2.circle(img, (cx, cy), 15, (255, 0, 255), cv2.FILLED)
                
                #計算大拇指和食指的直線距離
                length = math.hypot(x2 - x1, y2 - y1)
                #print(length)

                #將大拇指和食指的直線距離換算成0~255，Arduino PWM控制數值亦為0~255
                brightness = np.interp(length, [50, 300], [minPwm, maxPwm])
                
                briBar = np.interp(length, [50, 300], [400, 150])  
                briArd = np.around(brightness,2)
               
                
                if length < 50:
                    cv2.circle(img, (cx, cy), 15, (0, 255, 0), cv2.FILLED)
                         
            #畫出直方圖
            cv2.rectangle(img,(50,150),(85,400),(255, 0, 255),3)    
            cv2.rectangle(img,(50, int(briBar)),(85,400),(255, 0, 255),cv2.FILLED)
            cv2.putText(img, f'brightness: {int(briArd)}', (15, 140), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 0, 255), 3)
            
            #送出數值給Arduino
            ser.write(str(briArd).encode())
      
      
            #計算每秒跑幾張
            cTime = time.time()
            fps = 1 / (cTime - pTime)
            pTime = cTime
            cv2.putText(img, f'FPS: {int(fps)}', (40, 50), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 0, 0), 3)

            #顯示畫面 
            cv2.imshow("HandDetector", img)
           
                      
            #按q停止程式          
            if cv2.waitKey(10) & 0xFF == ord('q'):
                break
                
    except KeyboardInterrupt:
        ser.close()
        cap.release()
        cv2.destroyAllWindows()
    
if __name__ == '__main__' :
    main()

//Arduno D3腳位
int LEDPin = 3;
String number = "" ;
int i = 0 ;
long pwm_val ;

void setup()
{
  //各協定通訊初始化
  Serial.begin(9600);
  pinMode(LEDPin, OUTPUT);
}

void loop()
{
  //執行command副函式
  command();
}

long command() {
  while (Serial.available()) {
    if (i == 0) {
      number = "";
    }
    // 扣除ASCII碼值
    number += Serial.read() - 48; 
    i++;
  }
  // 字串轉換成整數值
  pwm_val = number.toInt(); 
  i = 0 ;
  
  Serial.println(pwm_val);

  //PWM控制LED
  analogWrite(LEDPin, (pwm_val));
  delay(100);
}

# Create ZED objects
zed = sl.Camera()
init_params = sl.InitParameters()
init_params.camera_resolution = sl.RESOLUTION.HD720
init_params.depth_mode = sl.DEPTH_MODE.ULTRA
init_params.sdk_verbose = True

# Open the camera
err = zed.open(init_params)
if err != sl.ERROR_CODE.SUCCESS:
    # Quit if an error occurred
    exit()

# Define the Object Detection module parameters
obj_param = sl.ObjectDetectionParameters()
# Different model can be chosen, optimizing the runtime or the accuracy
obj_param.detection_model = sl.DETECTION_MODEL.HUMAN_BODY_FAST
# run detection for every Camera grab
obj_param.image_sync = True
# Enable tracking to detect objects across time and space
obj_param.enable_tracking = True
# Optimize the person joints position, requires more computations
obj_param.enable_body_fitting = True

# If you want to have object tracking you need to enable positional tracking first
if obj_param.enable_tracking:
    positional_tracking_param = sl.PositionalTrackingParameters()
    zed.enable_positional_tracking(positional_tracking_param)

print("Object Detection: Loading Module...")
err = zed.enable_object_detection(obj_param)
if err != sl.ERROR_CODE.SUCCESS:
    print(repr(err))
    zed.close()
    exit(1)

# Set runtime parameter confidence to 40
obj_runtime_param = sl.ObjectDetectionRuntimeParameters()
obj_runtime_param.detection_confidence_threshold = 40

objects = sl.Objects()

# Grab new frames and detect objects
while zed.grab() == sl.ERROR_CODE.SUCCESS:
    err = zed.retrieve_objects(objects, obj_runtime_param)

    if objects.is_new:
        # Count the number of objects detected
        obj_array = objects.object_list
        print(str(len(obj_array)) + " Person(s) detected\n")

        if len(obj_array) > 0:
            first_object = objects.object_list[0]
            # Display the 3D keypoint coordinates of the first detected person
            print("\n Keypoint 3D ")
            keypoint = first_object.keypoint
            for it in keypoint:
                print("    " + str(it))

/**************************************************/
/*  Copyright © 2021 CAVEDU. All rights reserved.

  The AirBox program is suitable for sensors:

  Grove-DHT20:
  https://robotkingdom.com.tw/product/grove-%e6%ba%ab%e6%ba%bc%e5%ba%a6%e6%84%9f%e6%b8%ac%e5%99%a8temperature-humidity-sensor-v2-0-dht20-upgraded-dht11-i2c-port/

  SPG30:
  https://robotkingdom.com.tw/product/grove-voc-and-eco2-gas-sensor-sgp30/

  OLED Display 0.96:
  https://robotkingdom.com.tw/product/grove-oled-display-0-96/
  (Also suitable for Grove-OLED Display 0.96”:https://robotkingdom.com.tw/product/oled-display-0-96/)

  Education Kit 001 Button :
  https://robotkingdom.com.tw/product/rk-education-kit-001/

  You can see the AirBox Technical article:
  https://blog.cavedu.com/2021/01/20/linkit-7697-airbox/

  https://blog.cavedu.com/2021/11/25/linkit-7697-airbox-2/

*/
/***************************************************/

#include "PMS.h"
#include  <SoftwareSerial.h>
#include "U8g2lib.h"
#include <DHT.h>
#include "sensirion_common.h"
#include "sgp30.h"
#include <LRTC.h>
#include <WiFiUdp.h>
#include <ctime>
#include "Wire.h"
#include "MCS.h"



/*============Pins==================*/
#define buttonPin 4
#define PMSTx     2
#define PMSRx     3
//#define DHT11Pin 10
#define DHTTYPE DHT20   // DHT 20
/*====================================*/

//Enter WIFI SSID & Password
#include <LWiFi.h>
char _lwifi_ssid[] = "_lwifi_ssid";
char _lwifi_pass[] = "_lwifi_pass";

//Enter IFTTT_key & Event_name
char IFTTT_key[] = "IFTTT_KEY";
char Event_name[] = "Event_Name";

unsigned long current_time = 0;//record current time
unsigned long previous_IFTTT_time = 0;//Record the last time of IFTTT
int IFTTT_upload_time = 2000;//IFTTT intervals of time

int frame = 0;

/*ThingSpeak value*/
unsigned long previous_ThingSpeak_time = 0;//record current time
int ThingSpeak_upload_time = 1000*60*10;//ThingSpeak intervals of time 

String Write_API_key= "Write_API_key";//輸入ThingSpeak的 Write_API_Key

/*MCSLITE value*/
unsigned long previous_mcslite_time = 0;//record current time
int mcslite_upload_time = 1000*60*10;//MCSLITE intervals of time 

#define _your_MCSLite_DeviceId   "_your_MCSLite_DeviceId"  //輸入MCSLite的DeviceId
#define _your_MCSLite_DeviceKey  "_your_MCSLite_DeviceKey" //輸入MCSLite的Devicekey
#define _your_MCSLite_IP         "_your_MCSLite_IP" //輸入MCSLite的IP                         
MCSLiteDevice mcs(_your_MCSLite_DeviceId , _your_MCSLite_DeviceKey, _your_MCSLite_IP, 3000);

MCSDisplayInteger _1F_CO2("_1F_CO2");
MCSDisplayInteger _1F_TVOC("_1F_TVOC");
MCSDisplayInteger _1F_PM10("_1F_PM10");
MCSDisplayInteger _1F_PM1_0("_1F_PM1_0");
MCSDisplayInteger _1F_PM2_5("_1F_PM2_5");
MCSDisplayInteger _1F_TEMP("_1F_TEMP");
MCSDisplayInteger _1F_HUMI("_1F_HUMI");

SoftwareSerial PMSSerial(PMSTx, PMSRx);
PMS pms(PMSSerial);
PMS::DATA data;
U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
/*Monitor rotate angle
   U8G2_R0     0   degrees
   U8G2_R1     90  degrees
   U8G2_R2     180 degrees
   U8G2_R3     270 degrees
   U8G2_MIRROR mirror
*/
#define imgWidth 128
#define imgHeight 48

int pms1_0, pms2_5, pms10_0;
int temp;
int humi;
int button_state;

s16 err = 0;
u16 tvoc_ppb, co2_eq_ppm;


//DHT dht11_p10(DHT11Pin, DHT11);  //define dht11 PIN
DHT dht(DHTTYPE);

#if defined(ARDUINO_ARCH_AVR)
#define debug  Serial

#elif defined(ARDUINO_ARCH_SAMD) ||  defined(ARDUINO_ARCH_SAM)
#define debug  SerialUSB
#else
#define debug  Serial
#endif


float temp_hum_val[2];

void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  debug.println("DHT20 test!");
  Wire.begin();
  dht.begin();
  //dht11_p10.begin();

  PMSSerial.begin(9600);
  LRTC.begin();
  SGP30_int();
  oled_int();
  msclite_channel_int();
  pinMode(buttonPin, INPUT);

}

void loop()
{
  float temp_hum_val[2] = {0};
  button_state = digitalRead(buttonPin);
  //temp = dht11_p10.readTemperature();
  //humi = dht11_p10.readHumidity();


  while (!pms.read(data)) {}      //PM2.5 read Data
  pms1_0 = data.PM_AE_UG_1_0;
  pms2_5 = data.PM_AE_UG_2_5;
  pms10_0 = data.PM_AE_UG_10_0;

  err = sgp_measure_iaq_blocking_read(&tvoc_ppb, &co2_eq_ppm);
  if (err == STATUS_OK) {
    Serial.print("tVOC  Concentration:");
    Serial.print(tvoc_ppb);
    Serial.println("ppb");

    Serial.print("CO2eq Concentration:");
    Serial.print(co2_eq_ppm);
    Serial.println("ppm");
  } else {
    Serial.println("error reading IAQ values\n");
  }



  sensor_oled_task(); //OLED show sensor value
  button_oled_show_time();//Press Button to show time
  //IFTTT_pm25_temp_humi_task();//Upload sensor value to IFTTT
  upload_to_msclite_task();//Upload sensor value to msclite
  upload_to_ThingSpeak();//Upload sensor value to ThingSpeak
}

#define LED_G 4
#define LED_B 3
#define LED_R 2

String str;

String SA[2];
int A[2];

void setup(void)
{
  pinMode(LED_G, OUTPUT);
  pinMode(LED_B, OUTPUT);
  pinMode(LED_R, OUTPUT);
  digitalWrite(LED_G, LOW);
  digitalWrite(LED_B, LOW);
  digitalWrite(LED_R, LOW);

  Serial.begin(9600);
}

void loop(void)
{
  str = "";
  if (Serial.available()) {
    // 讀取傳入的字串直到"#"結尾
    str = Serial.readStringUntil('#');

    String_to_Int(str, 2);
  }
  
  if (str.length() != 0) {
    
    if (SA[0] == "G") {
      if (A[1] == 1) {
        digitalWrite(LED_G, HIGH);
        Serial.println("Green ON");
      }
      if (A[1] == 0) {
        digitalWrite(LED_G, LOW);
        Serial.println("Green OFF");
      }
    }

    if (SA[0] == "B") {
      if (A[1] == 1) {
        digitalWrite(LED_B, HIGH);
        Serial.println("Blue ON");
      }
      if (A[1] == 0) {
        digitalWrite(LED_B, LOW);
        Serial.println("Blue OFF");
      }
    }

    if (SA[0] == "R") {
      if (A[1] == 1) {
        digitalWrite(LED_R, HIGH);
        Serial.println("Red ON");
      }
      if (A[1] == 0) {
        digitalWrite(LED_R, LOW);
        Serial.println("Red OFF");
      }
    }
  }
}

void String_to_Int(String temp, int count)
{
  int index;

  index = temp.indexOf(',');
  SA[0] = temp.substring(0, index);

  for (int i = 1; i < count; i++) {
    temp = temp.substring(index + 1, temp.length());
    index = temp.indexOf(',');
    SA[i] = temp.substring(0, index);
    A[i] = SA[i].toInt();
  }
}

import serial
import argparse
import io
import time
import numpy as np
import cv2

from PIL import Image

parser = argparse.ArgumentParser(
    formatter_class=argparse.ArgumentDefaultsHelpFormatter)

parser.add_argument(
    '--com', help='Number of UART prot.', required=True)
args = parser.parse_args()

COM_PORT = args.com
BAUD_RATES = 9600
ser = serial.Serial(COM_PORT, BAUD_RATES,timeout=0, parity=serial.PARITY_EVEN, stopbits=1)

while(True):
    COMMAND = input('請輸入控制命令=')

    Data_flag = 0
    while(Data_flag == 0):
        Send_UART_command = COMMAND.encode(encoding='utf-8')    
        ser.write(Send_UART_command)  # 訊息必須是位元組類型

        time.sleep(0.5)
        while ser.in_waiting:
            mcu_feedback = ser.readline().decode()  # 接收回應訊息並解碼
            Data = mcu_feedback.strip('\r\n')

            if 'ON' in Data:
                Data_flag = 1
                print('MCU 回應：', Data)
            elif 'OFF' in Data:
                Data_flag = 1
                print('MCU 回應：', Data)
            else:
                Data_flag = 0

pip3 install pyserial

sudo apt-get install python-dev
sudo apt-get install libbluetooth-dev
pip3 install pybluez --user
sudo apt-get install pkg-config
sudo apt-get install libboost-python-dev
sudo apt-get install libboost-thread-dev
sudo apt-get install libglib2.0-dev 
pip3 install pybluez[ble]==0.22 --user
sudo pip3 install gattlib

#define LED_G 4
#define LED_B 3
#define LED_R 2

String str;

String SA[2];
int A[2];

UART Serial2(8, 9, 0, 0);

void setup(void)
{
  pinMode(LED_G, OUTPUT);
  pinMode(LED_B, OUTPUT);
  pinMode(LED_R, OUTPUT);
  digitalWrite(LED_G, LOW);
  digitalWrite(LED_B, LOW);
  digitalWrite(LED_R, LOW);

  Serial2.begin(9600);
}

void loop(void)
{
  str = "";
  if (Serial2.available()) {
    // 讀取傳入的字串直到"#"結尾
    str = Serial2.readStringUntil('#');

    String_to_Int(str, 2);
  }

  if (str.length() != 0) {
    if (SA[0] == "G") {
      if (A[1] == 1) {
        digitalWrite(LED_G, HIGH);
        Serial2.println("Green ON");
      }
      if (A[1] == 0) {
        digitalWrite(LED_G, LOW);
        Serial2.println("Green OFF");
      }
    }

    if (SA[0] == "B") {
      if (A[1] == 1) {
        digitalWrite(LED_B, HIGH);
        Serial2.println("Blue ON");
      }
      if (A[1] == 0) {
        digitalWrite(LED_B, LOW);
        Serial2.println("Blue OFF");
      }
    }

    if (SA[0] == "R") {
      if (A[1] == 1) {
        digitalWrite(LED_R, HIGH);
        Serial2.println("Red ON");
      }
      if (A[1] == 0) {
        digitalWrite(LED_R, LOW);
        Serial2.println("Red OFF");
      }
    }
  }
}

void String_to_Int(String temp, int count)
{
  int index;

  index = temp.indexOf(',');
  SA[0] = temp.substring(0, index);

  for (int i = 1; i < count; i++) {
    temp = temp.substring(index + 1, temp.length());
    index = temp.indexOf(',');
    SA[i] = temp.substring(0, index);
    A[i] = SA[i].toInt();
  }
}

nano SERIAL_DATA_IO.py

import serial
import argparse
import io
import time
import numpy as np
import cv2

from PIL import Image

parser = argparse.ArgumentParser(
    formatter_class=argparse.ArgumentDefaultsHelpFormatter)

parser.add_argument(
    '--com', help='Number of UART prot.', required=True)
args = parser.parse_args()

COM_PORT = args.com
BAUD_RATES = 9600
ser = serial.Serial(COM_PORT, BAUD_RATES,timeout=0, parity=serial.PARITY_EVEN, stopbits=1)

while(True):
    COMMAND = input('請輸入控制命令=')

    Data_flag = 0
    while(Data_flag == 0):
        Send_UART_command = COMMAND.encode(encoding='utf-8')    
        ser.write(Send_UART_command)  # 訊息必須是位元組類型

        time.sleep(0.5)
        while ser.in_waiting:
            mcu_feedback = ser.readline().decode()  # 接收回應訊息並解碼
            Data = mcu_feedback.strip('\r\n')

            if 'ON' in Data:
                Data_flag = 1
                print('MCU 回應：', Data)
            elif 'OFF' in Data:
                Data_flag = 1
                print('MCU 回應：', Data)
            else:
                Data_flag = 0

python3 SERIAL_DATA_IO.py --com /dev/rfccomm1

#include <LBLE.h>
#include <LBLEPeriphral.h>


#define LED_G 10
#define LED_B 11
#define LED_R 12


String Send_Data;


String SA[2];
int A[2];


// Define a simple GATT service with only 1 characteristic
LBLEService ledService("19B10010-E8F2-537E-4F6C-D104768A1214");
//LBLECharacteristicInt switchCharacteristic("19B10011-E8F2-537E-4F6C-D104768A1214", LBLE_READ | LBLE_WRITE);
LBLECharacteristicString switchCharacteristic("19B10011-E8F2-537E-4F6C-D104768A1214", LBLE_READ | LBLE_WRITE);


void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);


  Serial.begin(9600);


  //初始化BLE
  Serial.println("BLE begin");
  LBLE.begin();
  while (!LBLE.ready()) {
    delay(100);
  }
  Serial.println("BLE ready");
  Serial.print("device address is:");
  Serial.println(LBLE.getDeviceAddress()); //顯示7697 BLE addr


  //設定廣播資料
  // In this case, we simply create an advertisement that represents an
  // connectable device with a device name
  LBLEAdvertisementData advertisement;
  advertisement.configAsConnectableDevice("BLE Jack");


  // Configure our device's Generic Access Profile's device name
  // Ususally this is the same as the name in the advertisement data.
  LBLEPeripheral.setName("BLE Jack");


  // Add characteristics into ledService
  ledService.addAttribute(switchCharacteristic);


  // Add service to GATT server (peripheral)
  LBLEPeripheral.addService(ledService);


  //啟動GATT伺服器，此時已可被連線
  LBLEPeripheral.begin();


  //開始廣播
  LBLEPeripheral.advertise(advertisement);
}


void loop()
{
  if (switchCharacteristic.isWritten()) {
    String value = switchCharacteristic.getValue();


    String_to_Int(value, 2);


    Serial.print(SA[0]);
    Serial.print(",");
    Serial.println(A[1]);


    if (SA[0] == "G") {
      if (A[1] == 1) {
        digitalWrite(LED_G, HIGH);
        Send_Data = "Green ON";
        switchCharacteristic.setValue(Send_Data);
      }
      if (A[1] == 0) {
        digitalWrite(LED_G, LOW);
        Send_Data = "Green OFF";
        switchCharacteristic.setValue(Send_Data);
      }
      value = "";
    }


    if (SA[0] == "B") {
      if (A[1] == 1) {
        digitalWrite(LED_B, HIGH);
        Send_Data = "Blue ON";
        switchCharacteristic.setValue(Send_Data);
      }
      if (A[1] == 0) {
        digitalWrite(LED_B, LOW);
        Send_Data = "Blue OFF";
        switchCharacteristic.setValue(Send_Data);
      }
      value = "";
    }


    if (SA[0] == "R") {
      if (A[1] == 1) {
        digitalWrite(LED_R, HIGH);
        Send_Data = "Red ON";
        switchCharacteristic.setValue(Send_Data);
      }
      if (A[1] == 0) {
        digitalWrite(LED_R, LOW);
        Send_Data = "Red OFF";
        switchCharacteristic.setValue(Send_Data);
      }
      value = "";
    }
  }
  delay(100);
}


void String_to_Int(String temp, int count)
{
  int index;


  index = temp.indexOf(',');
  SA[0] = temp.substring(0, index);


  for (int i = 1; i < count; i++) {
    temp = temp.substring(index + 1, temp.length());
    index = temp.indexOf(',');
    SA[i] = temp.substring(0, index);
    A[i] = SA[i].toInt();
  }
}

from gattlib import GATTRequester


import io
import time
import os
import sys


MAC_BT = 'F5:7C:00:2B:88:8C'
requester = GATTRequester(MAC_BT,False)


data_list = []


def BLE_connect():
  print("Connecting...", end='')
  sys.stdout.flush()
  requester.connect(True)
  print("OK!")


def send_data(Data_String):
  requester.write_by_handle(0xa2,Data_String)


def request_data():
  data = requester.read_by_handle(0xa2)[0]
  data_string = data.decode()
  # data_list = data_string.split(',')
  # return data_list
  return data_string


def main():
  BLE_connect()


  while (True):
    COMMAND = input('請輸入控制命令=')


    send_data(COMMAND)
    recive_data = request_data()


    print(recive_data)


if __name__ == '__main__':
  main()

python3 BLE_DATA_IO.py