def human(w): if(w > 250): control.append(2) elif( w > 200 and w <= 250): control.append(1) else: control.append(0) if len(control) == 10: control.remove(control[0]) if control.count(2) > 2: print("Stop") GPIO.output(15, GPIO.HIGH) GPIO.output(22, GPIO.HIGH) elif control.count(1) > 4: print("Caution") GPIO.output(15, GPIO.LOW) GPIO.output(22, GPIO.HIGH) else: print("Go") GPIO.output(15, GPIO.LOW) GPIO.output(22, GPIO.LOW)
def off(self): for pin in range(4): GPIO.output(self.pins[pin], 0)
def human(w, xm, detections): det_hum = False for detection in detections: if detection[0].decode() == "person": det_hum = True # Human is detected in an image print("Human") #Classification of Distnace if (w > 100 and det_hum): print("Very close") control.append(2) elif (w > 60 and w <= 100 and det_hum): print("Close") control.append(1) else: print("Far") control.append(0) #Set Intervals if len(control) == 10: control.remove(control[0]) if len(signal) == 2: signal.remove(signal[0]) #Stop Definition if control.count(2) > 2: signal.append(2) if signal[0] == 0: # Go if xm > 240: robot.set_motors(0.1, 0.2) time.sleep(0.3) print("Stop and left turn") for aa in range(10): robot.forward(0.2 - aa * 0.02) time.sleep(0.2) else: robot.set_motors(0.2, 0.1) time.sleep(0.3) print("Stop and right turn") for ab in range(10): robot.forward(0.2 - ab * 0.02) time.sleep(0.2) elif signal[0] == 1: # Caution if xm > 240: robot.set_motors(0.1, 0.2) time.sleep(0.3) print("Stop and left turn") for aa in range(10): robot.forward(0.2 - aa * 0.02) time.sleep(0.2) else: robot.set_motors(0.2, 0.1) time.sleep(0.3) print("Stop and right turn") for ab in range(10): robot.forward(0.2 - ab * 0.02) time.sleep(0.2) robot.stop() time.sleep(1) for i in range(4): GPIO.output(31, GPIO.HIGH) time.sleep(0.125) GPIO.output(31, GPIO.LOW) time.sleep(0.125) # Caution Definition elif control.count(1) > 4: signal.append(1) print("Caution") if signal[0] == 2: # Stop for b in range(10): robot.forward(b * 0.02) time.sleep(0.2) robot.forward(speed=0.2) GPIO.output(31, GPIO.HIGH) # Go Definition else: signal.append(0) print("Go") if signal[0] == 2: # Stop for b in range(10): robot.forward(0.02 * b) time.sleep(0.2) GPIO.output(31, GPIO.LOW) robot.forward(0.2)
def motorFunc(self, rightCase, leftCase): if leftCase == True and rightCase == False: GPIO.output(self.rightPin, GPIO.LOW) GPIO.output(self.leftPin, GPIO.HIGH) elif rightCase == True and leftCase == False: GPIO.output(self.leftPin, GPIO.LOW) GPIO.output(self.rightPin, GPIO.HIGH) else: GPIO.output(self.rightPin, GPIO.LOW) GPIO.output(self.leftPin, GPIO.LOW)
def mov_detector(gpio_sensor=0, cm_hole=0, distance_interval=0, start_photo_inference=0, start_photo_check=0, spray_line1=0, spray_line2=0): ''' In this function we will use a disk with 20 or 40 holes and a radius of 5.1 cm, the the end of the disk (perpendicular), we will use an infrared sensor to detect interruptions, every interruption is a movement. It will also be used to check the speed, trigger a photo for inference and checage. Parameters: gpio_sensor: this is the device port to connect as an input cm_hole: it means how many centimeters each hole in the disk has (it's one step in the disk) distance_interval: This is the distance in CM to be defined to trigger a photo start_photo_inference: the minimal distance to trigger the photo for inference start_photo_check: the minimal distance to trigger the check photo (check the spray) spray_line1: if KeyBoard interrupt is triggered it turns off the solenoids in the first line spray_line2: if KeyBoard interrupt is triggered it turns off the solenoids in the second line # TODO: Use two sensors to detect the direction of the disk ''' # Setting initial time to measure the speed global curr_position global counter_speed global counter_infer_photo global counter_check_photo global start global speed try: if counter_speed == 0: start = datetime.now() if GPIO.wait_for_edge(gpio_sensor, GPIO.RISING): pass if GPIO.wait_for_edge( gpio_sensor, GPIO.FALLING): # Change in signal, counting steps curr_position += 1 counter_speed += 1 counter_infer_photo += 1 counter_check_photo += 1 # Measuring distance travelled distance = curr_position * cm_hole # LOOK AT THIS print('[WEEDS] Distance Traveled: ', round(distance / 100, 4), ' meters') # Measuring variation on time and distance if counter_speed == 10: end = datetime.now() diff = end - start delta_time = diff.seconds + diff.microseconds / 1e6 delta_distance = counter_speed * cm_hole / 100 #in meters speed = delta_distance / delta_time # m/sec counter_speed = 0 if curr_position > 10: print('[WEEDS] Current speed: ', round(speed, 2), ' m/sec or: ', round(speed * 3.6, 2), ' km/h.') # Triggering Inference Photo if curr_position >= start_photo_inference: if counter_infer_photo * cm_hole >= distance_interval: infer_trigger = True counter_infer_photo = 0 print('[WEEDS] Inference Photo Triggered') else: infer_trigger = False # Triggering Check Photo if curr_position >= start_photo_check: if counter_check_photo * cm_hole >= distance_interval: check_trigger = True counter_check_photo = 0 print('[WEEDS] Check Photo Triggered') else: check_trigger = False print('[WEEDS] Position:', curr_position, ', Infer Trigger:', infer_trigger, ', Check Trigger:', check_trigger) except KeyboardInterrupt: print("[WEEDS] KeyboardInterrupt has been caught.") GPIO.output(spray_line1, GPIO.LOW) GPIO.output(spray_line2, GPIO.LOW) GPIO.cleanup() sys.exit() return curr_position, infer_trigger, check_trigger
def digital_read(pin): return GPIO.input(BUSY_PIN)
#!/usr/bin/env python3 import Jetson.GPIO as GPIO from time import sleep # Set up du board (reférence n° port) GPIO.setmode(GPIO.BOARD) # definition de la pin comme pin d'entrée GPIO.setup(7, GPIO.IN) GPIO.setup(11, GPIO.IN) #GPIO.setup(12, GPIO.OUT) # initialisation de l'expérience => TEST #GPIO.output(12, GPIO.LOW) # Lecture de la Pin # GPIO.input(7) # GPAIO 4 # GPIO.input(11) # GPAIO 17 def experience(): GPIO.output(12, GPIO.HIGH) # Attente de réponse => TODO: test def tirette(): Tirrette = [0 for i in range(10)] # niveau bas = 0 while 1: print("attente tirette") for i in range(0, 10): if GPIO.input(7) == 0: # boucle de check tirette relevée Tirrette[i] = 0
# This is a sample Python script. import Jetson.GPIO as GPIO from car.car import Car from directory_manager.dir_manager import DirectoryManager from mqtt_connection.mqtt_car import MqttCar from distance_sensor.distance_sensor import DistanceSensor from camera.car_camera import CarCamera from led.single_led import SingleLED import utils.constants as const import sys import os from utils.keyboard_reader import KeyboardReader # Set Jetson GPIO Mode GPIO.setmode(GPIO.BCM) # Create mqtt car class mqtt = MqttCar() # Create directory manager class dir_manager = DirectoryManager() # Crete keyboard reader class keyboard_reader = KeyboardReader() # Create LED class led = SingleLED(GPIO) # Create Car class car = Car(GPIO, 45) # Create Distance sensor class distance_sensor = DistanceSensor(GPIO) # Create car camera class car_camera = CarCamera(autopilot=False, record_stops=False, video_output=True) # Set initial values
import Jetson.GPIO as GPIO valve_pin = 16 GPIO.setmode(GPIO.BOARD) GPIO.setup(valve_pin, GPIO.OUT) def gripper_open(): GPIO.output(valve_pin, GPIO.HIGH) def gripper_close(): GPIO.output(valve_pin, GPIO.LOW) if __name__ == '__main__': import time while (True): gripper_open() time.sleep(2) gripper_close() time.sleep(2)
import Jetson.GPIO as GPIO import time import cv2 import numpy as np import os os.environ["CUDA_VISIBLE_DEVICES"] = "-1" import tensorflow as tf # Set GPIO led_pin = [23, 21, 19, 15, 13, 11] button_pin = 7 all_off = [1, 1, 1, 1, 1, 1] GPIO.setmode(GPIO.BOARD) GPIO.setup(led_pin, GPIO.OUT) GPIO.setup(button_pin, GPIO.IN) GPIO.output(led_pin, all_off) button_state = GPIO.input(button_pin) previous_state = GPIO.input(button_pin) # Input Model Name h5name = input('\n\nInput H5 File Name: ') if h5name[-3:] != '.h5': h5name = h5name + '.h5' try: model = tf.keras.models.load_model(h5name) except Exception as e: print('\n\nModel not found!!!') print(e) exit() # Set Label Name
import Jetson.GPIO as GPIO import time as time LED_Pin = 11 GPIO.setwarnings(False) def main(): GPIO.setmode(GPIO.BOARD) GPIO.setup(LED_Pin, GPIO.OUT, initial=GPIO.HIGH) try: while True: GPIO.output(LED_Pin, GPIO.HIGH) time.sleep(0.1) GPIO.output(LED_Pin, GPIO.LOW) time.sleep(0.1) finally: GPIO.cleanup() if __name__ == '__main__': main()
#!/usr/bin/env python import sys from time import sleep sys.path.append('/opt/nvidia/jetson-gpio/lib/python/') sys.path.append('/opt/nvidia/jetson-gpio/lib/python/GPIO') import Jetson.GPIO as gpio import rospy from funcase_msgs.msg import JoyCmd gpio.setmode(gpio.BCM) switch = 18 ## Pin 12 gpio.setup(switch, gpio.OUT, initial=gpio.LOW) #gpio.setwarnings(False) swit = False def callback(data): global swit joy_cmd = data button = joy_cmd.joy[0].encode("hex") sum_ = int(button[0]) * 16 + int(button[1]) * 1 #print(c) if sum_ == 4: swit = True gpio.output(switch, gpio.HIGH) if sum_ == 2: swit = False gpio.output(switch, gpio.LOW) print(swit)
def listener(): rospy.init_node('arm', anonymous=False) rospy.set_param('base_station/drive_mode', 'XboxDrive') rospy.Subscriber("/base_station/rjs_raw_ctrl", RawCtrl, RightCallback) rospy.Subscriber("/base_station/ljs_raw_ctrl", RawCtrl, LeftCallback) rospy.Subscriber("/heartbeat", Empty, HBeatCb) GPIO.setmode(GPIO.BOARD) GPIO.setwarnings(False) GPIO.setup(31, GPIO.OUT) while (True): global finger_debouncer global toggle_finger global hbeat_cnt global ignore_endstops global reset global values global prev_finger rospy.loginfo(ignore_endstops) hbeat_cnt += 1 if False and ((hbeat_cnt > max_hbeat) or (reset == True)): hbeat = False values = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] for i in range(0, len(values)): #Sending stop commands to all field = 0x0 complete_id = ( ids[i] << 4) + field #Embedding ID's with 0 command msg = can.Message( arbitration_id=complete_id, data=[], extended_id=False) #Creating can message to send bus.send(msg) else: for i in range(0, len(values)): if (i == 4 or i == 6) and (ignore_endstops == True): #If on ignore endstops mode field = 0x5 if values[i] < 0: field = 0x6 value = int(abs(values[i]) * 4095) else: #If not on ignore end_stops mode or not an endeffector one field = 0x3 if values[i] < 0: field = 0x4 value = int(abs(values[i]) * 4095) if (i == 6): if toggle_finger == True: #field = 0x7 toggle_finger = False #Finger toggle debouncer if prev_finger == True: GPIO.output(31, GPIO.LOW) rospy.loginfo("Off") prev_finger = False else: GPIO.output(31, GPIO.HIGH) prev_finger = True rospy.loginfo("On") complete_id = ( ids[i] << 4 ) + field #Embedding ID's with chosen directional PWM command if value < 10: value = 0 #Getting rid of off centre bit1 = value >> 8 & 0xFF bit2 = value & 0xFF #rospy.loginfo(value) msg = can.Message(arbitration_id=complete_id, data=[bit1, bit2], extended_id=False) bus.send(msg) if finger_debouncer < 15: finger_debouncer += 1 time.sleep(0.1)
def __init__(self, wheel_distance=0.6, wheel_diameter=0.4): rospy.loginfo("Setting Up the Node...") rospy.init_node('scooby_llc') GPIO.setmode(GPIO.BCM) self.PIN_LIGHT = 5 self.PIN_HORN = 6 self.gain = 0.75 GPIO.setup(self.PIN_LIGHT, GPIO.OUT) GPIO.setup(self.PIN_HORN, GPIO.OUT) GPIO.output(self.PIN_LIGHT, GPIO.HIGH) GPIO.output(self.PIN_HORN, GPIO.HIGH) self._wheel_distance = wheel_distance self._wheel_radius = wheel_diameter / 2.0 self.actuators = {} self.actuators['left_a'] = ServoConvert(id=1) self.actuators['left_b'] = ServoConvert(id=2, direction=1) #-- positive left self.actuators['right_a'] = ServoConvert(id=3) self.actuators['right_b'] = ServoConvert(id=4, direction=1) rospy.loginfo("> Actuators corrrectly initialized") self._servo_msg = ServoArray() #self._imu_data_msg = Imu() self._joint_stat = JointState() self._velocity_msg = Float32MultiArray() for i in range(4): self._servo_msg.servos.append(Servo()) #--- Create the servo array publisher self.ros_pub_velocity_array = rospy.Publisher("/wheel_velocity", Float32MultiArray, queue_size=1) self.ros_pub_servo_array = rospy.Publisher("/servos_absolute", ServoArray, queue_size=1) #self.ros_pub_imu_data = rospy.Publisher("/imu/data_raw", Imu, queue_size=1) self.ros_pub_joint_stat = rospy.Publisher("/joint_stat", JointState, queue_size=10) rospy.loginfo("> Publisher corrrectly initialized") #--- Create imu subscriber #self.ros_sub_imu = rospy.Subscriber("/rtimulib_node/imu", Imu, self.send_imu_data_msg) #--- Create the Subscriber to Joy commands self.ros_sub_joy = rospy.Subscriber("/joy_teleop/joy", Joy, self.set_actuators_from_joy) #--- Create the Subscriber to Twist commands self.ros_sub_twist = rospy.Subscriber("/joy_teleop/cmd_vel", Twist, self.set_actuators_from_cmdvel) rospy.loginfo("> Subscriber corrrectly initialized") #--- Get the last time e got a commands self._last_time_cmd_rcv = time.time() self._timeout_s = 5 self.anglez = 0.00 rospy.loginfo("Initialization complete")
import Jetson.GPIO as GPIO import time GPIO.setmode(GPIO.BOARD) GPIO.setup(33, GPIO.OUT) GPIO.output(33, GPIO.HIGH) time.sleep(5) GPIO.output(33, GPIO.LOW) GPIO.cleanup()
def gripper_close(): GPIO.output(valve_pin, GPIO.LOW)
def digital_write(pin, value): GPIO.output(pin, value)
def gripper_open(): GPIO.output(valve_pin, GPIO.HIGH)
def module_init(): # print("module_init") GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) # print("RST_PIN") GPIO.setup(RST_PIN, GPIO.OUT) # print("DC_PIN") GPIO.setup(DC_PIN, GPIO.OUT) # print("CS_PIN") GPIO.setup(CS_PIN, GPIO.OUT) # print("BUSY_PIN") GPIO.setup(BUSY_PIN, GPIO.IN) # SPI.max_speed_hz = 2000000 # SPI.mode = 0b00 # gpio2.SYSFS_GPIO_Export(15) # gpio2.SYSFS_GPIO_Direction(15, 0) spi.SYSFS_software_spi_begin() return 0
# This is a simple test of the Jetson.GPIO library # To understand more about this library, read /opt/nvidia/jetson-gpio/doc/README.txt import sys import Jetson.GPIO as GPIO from periphery import PWM import time # set GPIO mode to BOARD GPIO.setmode(GPIO.BOARD) mode = GPIO.getmode() print(mode) # Open PWM channel 0, pin 32 pins = range(0, 41) """ for pin in pins: try: pwm = PWM(0, pin) print("** Channel 0 pin {} works!".format(pin)) except: print("Pin {} does not work".format(pin)) """ pwm = PWM(0, 2) pwm = PWM(0, 0) #Channel 0 pin 2 # Set frequency to 1 kHz pwm.frequency = 2e3
def experience(): GPIO.output(12, GPIO.HIGH)
# 초음파 도착 시간 얻기 time2 = time.time() during = time2 - time1 dist = during * 340 / 2 * 100 print(during) return dist if __name__ == "__main__": try: bz = Buzzer.ActiveBuzzer(13) sensor = HcSr04(trigpin=11, echopin=12) while True: distance = sensor.distance() print("거리: {}".format(distance)) if distance <= 30: bz.on() else: bz.off() time.sleep(0.3) except KeyboardInterrupt: print() finally: GPIO.cleanup() print("Program Exit")
def __init__(self, leftPin, rightPin): self.leftPin = leftPin self.rightPin = rightPin GPIO.setmode(GPIO.BOARD) GPIO.setup(self.leftPin, GPIO.OUT) GPIO.setup(self.rightPin, GPIO.OUT)
"""Tegra T186 pin names""" import atexit import Jetson.GPIO as GPIO GPIO.setmode(GPIO.TEGRA_SOC) GPIO.setwarnings(False) # shh! class Pin: """Pins dont exist in CPython so...lets make our own!""" IN = 0 OUT = 1 LOW = 0 HIGH = 1 PULL_NONE = 0 PULL_UP = 1 PULL_DOWN = 2 id = None _value = LOW _mode = IN def __init__(self, bcm_number): self.id = bcm_number def __repr__(self): return str(self.id) def __eq__(self, other):
def step(self, wait=0.001): for pin in range(4): GPIO.output(self.pins[pin], self.seq[self.actual_position % 8][pin]) time.sleep(wait)
def cleanup(): """Clean up pins""" print("Exiting... \nCleaning up pins") GPIO.cleanup()
from ctypes import * import math import random import os import cv2 import numpy as np import time import darknet import Jetson.GPIO as GPIO from jetbot import Robot robot = Robot() for a in range(10): robot.forward(0.02 * a) time.sleep(0.2) GPIO.setmode(GPIO.BOARD) GPIO.setup(31, GPIO.OUT) control = [] def convertBack(x, y, w, h): xmin = int(round(x - (w / 2))) xmax = int(round(x + (w / 2))) ymin = int(round(y - (h / 2))) ymax = int(round(y + (h / 2))) return xmin, ymin, xmax, ymax signal = []
def interrupt_handler(sig, frame): print("You've pressed Ctrl+C!") logging.info("Program ending") GPIO.cleanup(output_pin) sys.exit(0)
from __future__ import print_function import time try: import Jetson.GPIO as GPIO except ImportError: import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) class Motor(object): def __init__(self, pwm_pin, pwm_min, pwm_max, pwm_init_duty_cycle=0, pwm_frequency=50, pwm_neutral=None): self.pwm_pin = pwm_pin self.pwm_min = pwm_min self.pwm_max = pwm_max self.pwm_init_duty_cycle = pwm_init_duty_cycle self.pwm_frequency = pwm_frequency self.pwm = None if pwm_neutral is None: self.pwm_neutral = (pwm_min + pwm_max) / 2 self.setup() def setup(self): GPIO.setup(self.pwm_pin, GPIO.OUT) self.pwm = GPIO.PWM(self.pwm_pin, self.pwm_frequency) self.pwm.start(self._clip_value(self.pwm_init_duty_cycle))
from ctypes import * import math import random import os import cv2 import numpy as np import time import darknet import Jetson.GPIO as GPIO GPIO.setmode(GPIO.BOARD) GPIO.setup(15,GPIO.OUT) GPIO.setup(22,GPIO.OUT) control=[] def convertBack(x, y, w, h): xmin = int(round(x - (w / 2))) xmax = int(round(x + (w / 2))) ymin = int(round(y - (h / 2))) ymax = int(round(y + (h / 2))) return xmin, ymin, xmax, ymax def human(w): if(w > 250): control.append(2) elif( w > 200 and w <= 250): control.append(1) else: control.append(0)