def __init__(self, config, firebase):
self.config = config
self.firebase = firebase
self.data = {}
self.led = 3
pinMode(self.led, "OUTPUT")
# Set solutions and food amount
self.acidAmount = self.config["acidAmount"]
self.alkaliAmount = self.config["alkaliAmount"]
self.foodAmount = self.config["foodAmount"]
# Set rate for solutions and food
self.acidRate = self.config["acidRate"]
self.alkaliRate = self.config["alkaliRate"]
self.foodRate = self.config["foodRate"]
# Setup servos
self.pHServo = Servo(self.config["pHServoPin"])
self.feederServo = Servo(self.config["feederServoPin"])
self.feederInterval = self.config["feederInterval"]
# Setup board
self.ser = serial.Serial(self.config["acmNumber"],
self.config['baudrate'])
self.ser.baudrate = self.config['baudrate']
def init():
global pushServoPin, laneServoLeftPin, laneServoRightPin
global servoPush, servoLaneLeft, servoLaneRight
global camera, parser
global button
# Prepare GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
# Initialize variables
pushServoPin = config.pushServoPin
laneServoLeftPin = config.laneServoLeftPin
laneServoRightPin = config.laneServoRightPin
# Instantiate Servo motors
servoPush = Servo(pushServoPin, 0)
servoLaneLeft = Servo(laneServoLeftPin, config.returnAngle)
servoLaneRight = Servo(laneServoRightPin, config.returnAngle)
# Instantiate image capturer
camera = ImageCapturer()
camera.setZoom(config.cropArea)
# Instantiate image parser
parser = ImageParser()
# Instantiate button
button = Button(config.buttonPin, bounce_time=0.5)
button.when_pressed = buttonPressed
def __init__(self, pi, servoX_pin, servoY_pin): self.pi = pi self.servo_X = Servo(pi, servoX_pin) self.servo_Y = Servo(pi, servoY_pin) self.pwm = PWM(pi) self.pwm.set_frequency(50) # for servo
def __init__(self, panPin, tiltPin):
self.panPin = panPin
self.tiltPin = tiltPin
self.pan = Servo(self.panPin, pwMin=.0010,
pwCtr=.00150, pwMax=.0020, dir=1)
self.tilt = Servo(self.tiltPin, pwMin=.0008,
pwCtr=.00143, pwMax=.00207, dir=-1)
def test_that_position_is_set_for_multiple_servos(self):
from executor import Executor
exe = Executor()
servos = [Servo(1, 100), Servo(2, 80)]
states = [State(servos)]
movement = Move(states)
exe.run(movement)
self._pwm.set_pwm.assert_has_calls(
[call(1, 0, 600), call(2, 0, 575)], any_order=False)
def __init__(self, inital_angle=0):
self.__left_leg = Servo(17, inital_angle)
self.__left_arm = Servo(18, inital_angle, reverse=True)
self.__right_arm = Servo(27, inital_angle)
self.__right_leg = Servo(22, inital_angle, reverse=True)
sleep(0.5)
self.__left_leg.angle = None
self.__left_arm.angle = None
self.__right_arm.angle = None
self.__right_leg.angle = None
def __init__(self, i2c, pca9685, shoulder_pin, foot_pin, name=None):
self.shoulder = Servo(i2c=i2c,
pca9685=pca9685,
name='shoulder',
channel=shoulder_pin)
self.foot = Servo(i2c=i2c,
pca9685=pca9685,
name="foot",
channel=foot_pin)
if name is not None:
self.__name = name
def __init__(self, baseId, name, origin, angle):
self.name = name
self.origin = origin
self.angle = angle
#joints in each leg
numJoints = 4
self.coxa = Servo(baseId * numJoints + 1)
self.femur = Servo(baseId * numJoints + 2)
self.tibia = Servo(baseId * numJoints + 3)
self.tarsus = Servo(baseId * numJoints + 4)
def randomMove(self, statesCount):
states = []
for n in range(0, statesCount):
state = State([])
for i in range(1, 7):
if n != 0:
servo = Servo(i, random.randint(-90, 90))
else:
servo = Servo(i, 0)
state.addServo(servo)
states.append(state)
return Move(states)
def main():
pi = pigpio.pi()
srv = Servo(pi)
swi = Switch(pi, srv)
door = Door(pi)
try:
while True:
logger.debug("waiting id card")
# ここでカード読み込み
if database.confirm("ここに番号"), "ここにIDm"):
srv.open_lock()
slack.send_slack("ここになまえ")
time.sleep(10)
while door.door_status() == door.OPEN:
time.sleep(0.5)
srv.close_lock()
else:
led.red_led_on()
print("Can't confirm.")
time.sleep(3)
led.red_led_off()
except:
pi.stop()
r.close()
main()
def main():
broker = redis.StrictRedis()
sub = broker.pubsub()
sub.subscribe(SC_CH)
try:
'''
UP/DOWN servo => pin 13
LEFT/RIGHT servo => pin 19
'''
sc = Servo()
while True:
message = sub.get_message()
if message and not isinstance(
message['data'], int) and message['type'] == 'message':
log.debug(type(message['data']))
data = json.loads(message['data'].decode('utf-8'))
log.debug("SC: received data:")
log.debug(data)
action = data['action']
angle = int(data['angle'])
if not (sc is None):
execute_action(sc, action, angle)
else:
log.error(
"servos were not initialized not performing action!")
sleep(0.2)
except Exception as ex:
log.error("exception in ServosController")
log.error(ex, exc_info=True)
sc.clean_up()
def __init__(self):
self.is_initialized = False
rospy.init_node('servo_interface', anonymous=False)
self.sub = rospy.Subscriber('camera_position', std_msgs.msg.Float64,
self.callback)
rospy.on_shutdown(self.shutdown)
try:
self.tilt_servo = Servo(SERVO_PWM_PIN, PWM_FREQUENCY,
DUTY_CYCLE_MIN, DUTY_CYCLE_MAX,
SCALE_RANGE, COMPUTER)
self.tilt_position = 0
except NameError:
rospy.logfatal(
'Could not initialize servo.py. Is /computer parameter set correctly? '
'Shutting down node...')
rospy.signal_shutdown('')
except:
rospy.logfatal("Unexpected error:", sys.exc_info()[0])
raise
self.tilt_servo.set_position(self.tilt_position)
rospy.loginfo('Initialized camera tilt servo in neutral position.')
self.is_initialized = True
self.spin()
def run(self):
"""
Infinitely loops, waiting for socket connections and commands.
"""
try:
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('127.0.0.1', self.__port))
servo_queue = ServoQueue()
servo_queue.start()
while True:
try:
server_socket.listen(2)
client_socket, _ = server_socket.accept()
message = client_socket.recv(2048).decode("utf-8")
re_result = re.match(
'^(?P<pin>[0-9]+) (?P<angle>[0-9]{1,3})$', message)
if re_result:
pin = int(re_result.group('pin'))
angle = int(re_result.group('angle'))
servo_queue.add_servo(Servo(pin, angle))
client_socket.shutdown(socket.SHUT_RDWR)
client_socket.close()
except Exception as e:
print('Socket exception %s' % e)
time.sleep(ERROR_TIMEOUT)
except Exception as e:
print('Server exception %s' % e)
return
def get_graph():
sensor = HC_SR04()
servo = Servo()
mapa = []
while servo.angle <= 180:
ang = servo.move2()
sleep(0.05)
dst1 = sensor.get_distance()
dst2 = sensor.get_distance()
dst = (dst1 + dst2) / 2
medida = {'angle': ang * np.pi / 180, 'distance': dst}
mapa.append(medida)
theta = list(map(itemgetter('angle'), mapa))
#theta = [x-np.pi/2 for x in theta]
distance = list(map(itemgetter('distance'), mapa))
graph = plt.subplot(111, projection='polar')
graph.plot(theta, distance)
graph.set_rmax(50)
graph.set_rmin(0)
graph.set_rticks([10, 20, 30, 40])
graph.set_rlabel_position(0)
graph.grid(True)
graph.set_thetamin(0)
graph.set_thetamax(180)
GPIO.cleanup()
plt.savefig('static/images/grafico.png')
graph.clear()
def __init__(self,gps=False,servo_port=SERVO_PORT):
# devices
self.compass = Compass(I2C(COMPASS_I2C_ADDRESS),I2C(ACCELEROMETER_I2C_ADDRESS))
self.rudder_servo = Servo(serial.Serial(servo_port),RUDDER_SERVO_CHANNEL,RUDDER_MIN_PULSE,RUDDER_MIN_ANGLE,RUDDER_MAX_PULSE,RUDDER_MAX_ANGLE)
try:
while True:
current_bearing = self.compass.bearing
difference = angle_between(TARGET_BEARING, current_bearing)
# for definite rudder deflection at low angles for difference:
# scaled_diff = max(5, abs(difference/3))
# rudder_angle = copysign(scaled_diff,difference)
# for tolerance of small differences
rudder_angle = difference/3 if abs(difference) > 5 else 0
self.rudder_servo.set_position(rudder_angle)
print('Current bearing {:+.1f}, target {:+.1f}, rudder {:+.1f}'.format(current_bearing, TARGET_BEARING, rudder_angle))
# smooth response with a sleep time of less than 100ms ?
time.sleep(0.1)
except (KeyboardInterrupt, SystemExit):
quit()
def __init__(self, identity):
self.id = identity
#make sum servos
self.joints = [Servo(i*4+self.id) for i in range(3)]
self.joints[0].angle = 90
self.joints[1].angle = 90
self.joints[2].angle = 90
#set servos to base position
for servo in self.joints:
servo.update(servo.angle)
#loving those constants
self.L1 = 88 #upper leg
self.L2 = 91 #lower leg
self.L3 = 47 #leg joint controller
self.L4 = 90 #lower leg straight
self.A = 28 #arm
self.B = 103 #beam
self.D = 25 #distance between servos
self.Dang = 23.6#angle between servos
#points in space for dem pivots
self.p1 = np.array([0,0]) #SHOULD ALWAYS BE CONSTANT
self.p2 = np.array([0,0])
self.p3 = np.array([-10, 23.5])
self.p4 = np.array([0,0])
self.p5 = np.array([0,0])
self.p6 = np.array([0,0])
def __init__(self, net, transformer, mean_file, labels, withoutservo,
config, bkb, Mem):
self.mean_file = mean_file
self.labels = labels
self.net = net
self.transformer = transformer
self.withoutservo = withoutservo
self.config = config
self.bkb = bkb
self.Mem = Mem
self.kernel_perto = np.ones(
(self.config.kernel_perto, self.config.kernel_perto), np.uint8)
self.kernel_perto2 = np.ones(
(self.config.kernel_perto2, self.config.kernel_perto2), np.uint8)
self.kernel_medio = np.ones(
(self.config.kernel_medio, self.config.kernel_medio), np.uint8)
self.kernel_medio2 = np.ones(
(self.config.kernel_medio2, self.config.kernel_medio2), np.uint8)
self.kernel_longe = np.ones(
(self.config.kernel_longe, self.config.kernel_longe), np.uint8)
self.kernel_longe2 = np.ones(
(self.config.kernel_longe2, self.config.kernel_longe2), np.uint8)
self.kernel_muito_longe = np.ones(
(self.config.kernel_muito_longe, self.config.kernel_muito_longe),
np.uint8)
self.kernel_muito_longe2 = np.ones(
(self.config.kernel_muito_longe2, self.config.kernel_muito_longe2),
np.uint8)
if self.withoutservo == False:
self.servo = Servo(self.config.CENTER_SERVO_PAN,
self.config.POSITION_SERVO_TILT)
def __init__(self, scl=_SCL_PIN, sda=_SDA_PIN):
"""
Initialize the turtleplotbot, optionally passing an i2c object to use.
"""
self._current_step = [0, 0] # current step indexes
self._step_delay = 1000 # us delay between steps
self._pen_delay = 250 # ms delay for pen raise or lower
self.mcp23017 = mcp23017.MCP23017(
machine.I2C(scl=machine.Pin(scl),
sda=machine.Pin(sda),
freq=100000), 0x20)
# pylint: disable=no-member
self.mcp23017.porta.mode = 0x00 # porta output
self.mcp23017.porta.gpio = 0x00 # all pins low
self._pen_servo = Servo(machine.Pin(_SERVO_PIN, machine.Pin.OUT),
freq=50,
min_us=600,
max_us=2400,
angle=180)
time.sleep_ms(100)
self._pen_servo.write_angle(degrees=_PEN_UP_ANGLE)
self.rst = machine.Pin(16,
machine.Pin.OUT) # power pin for LCD display
self.rst.value(1) # power on
super().__init__()
def test_that_position_stays_to_servo_max_when_limit_passed(self):
from executor import Executor
exe = Executor()
servos = [Servo(1, 100)]
states = [State(servos)]
movement = Move(states)
exe.run(movement)
self._pwm.set_pwm.assert_called_once_with(1, 0, 600)
def test_set_pwm_is_called_with_the_value_of_the_servo(self):
from executor import Executor
exe = Executor()
servos = [Servo(1, 80)]
states = [State(servos)]
movement = Move(states)
exe.run(movement)
self._pwm.set_pwm.assert_called_once_with(1, 0, 575)
def build_joint(joint_id: id, reverse_direction: int):
servo = Servo(joint_id, False)
joint = Joint(servo,
min_angle=0,
max_angle=180,
reverse_direction=reverse_direction,
instant_move=False)
return joint
def __init__(self, servoCount):
pca = ServoKit(channels=servoCount)
self.servos = []
for i in range(servoCount):
pca.servo[i].set_pulse_width_range(500, 2500)
self.servos.append(Servo(pca.servo[i], i))
self.servos[i].setAngle(5)
print("Initialized")
def __init__(self, port=None, baud=None, channels=32, auto=1000):
self.board = serial.Serial()
self.board.baudrate = baud
self.board.port = port
self.board.timeout = 1
self.auto = auto
self.myversion = ""
self._servos = [
Servo(self._servo_on_changed, i, "servo" + str(i))
for i in range(channels)
]
def __init__(self, withoutservo, config, bkb, Mem):
self.withoutservo = withoutservo
self.config = config
self.bkb = bkb
self.Mem = Mem
if self.withoutservo==False:
self.servo = Servo(self.config.CENTER_SERVO_PAN, self.config.POSITION_SERVO_TILT)
# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_CKPT = './nets/'+self.config.DNN_folder+'/frozen_inference_graph.pb'
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('./nets/'+self.config.DNN_folder+'/object-detection.pbtxt')
if (not os.path.exists(PATH_TO_CKPT) or not os.path.exists(PATH_TO_LABELS)):
print("\x1b[1;31mNão encontrou a pasta da rede DNN descrita no \x1b[1;36mconfig.ini \x1b[1;31mda visão\x1b[0m")
print("\x1b[1;31mOu não encontrou o arquivo frozen ou pbtxt da DNN\x1b[0m")
quit()
NUM_CLASSES = 1
# Reading network file.
self.__detection_graph = tf.Graph()
with self.__detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
self.category_index = label_map_util.create_category_index(categories)
# Creating a section to run the detection.
with self.__detection_graph.as_default():
self.__sess = tf.Session(
graph=self.__detection_graph,
config=tf.ConfigProto(
intra_op_parallelism_threads=1,
inter_op_parallelism_threads=1
)
)
self.__imagetensor = self.__detection_graph.get_tensor_by_name('image_tensor:0')
self.__detectionboxes = self.__detection_graph.get_tensor_by_name('detection_boxes:0')
self.__detectionscores = self.__detection_graph.get_tensor_by_name('detection_scores:0')
self.__detectionclasses = self.__detection_graph.get_tensor_by_name('detection_classes:0')
self.__numdetections = self.__detection_graph.get_tensor_by_name('num_detections:0')
def feed(config):
print("%s: feeding" % datetime.now(), file=sys.stderr)
servo = Servo(18)
servo.start()
base_duty = 7.5
base_delta_duty = 5
servo.do_cycle(base_duty - base_delta_duty)
servo.do_cycle(base_duty + base_delta_duty)
servo.do_cycle(base_duty - base_delta_duty)
servo.clean()
def __init__(self):
self._video = cv2.VideoCapture(
0) # capture video from source '0' - raspi camera
# load face detection instructions - Created by Rainer Lienhart.
self._cascade = cv2.CascadeClassifier(
'cascades/haarcascade_frontalface_default.xml')
self._face_detector = cv2.face.LBPHFaceRecognizer_create(
) # creates face recognizer
if self.trainer_exists(): # checks if trainer.yml exists
self.load_trainer()
self._servo = Servo()
self._fb = Firebase()
def test_servo():
print("Testing servo")
s = Servo()
s.angle(0, 90)
time.sleep(2)
s.angle(0, 0)
time.sleep(2)
s.angle(0, 180)
time.sleep(2)
s.angle(0, 90)
time.sleep(2)
s.angle(0, 180)
time.sleep(2)
def main():
servo = Servo()
#servo.test()
ctrl = Controller(servo)
cmd = [\
Rotate(horizontal=-90, deg=True),\
Rotate(horizontal=90, deg=True),\
Default(),\
Rotate(vertical=-90, deg=True),\
Rotate(vertical=90, deg=True),\
Default()\
]
ctrl.execute_commands(cmd)
def Unlock_door():
# statusLED = gpio(STATUS_LED_PIN)
# statusLED.blink()
msg = "OK"
try:
s = Servo(2)
s.setAngle(90)
del s
except Exception as e:
msg = str(e)
return msg
def __init__(self, gps=False, servo_port=SERVO_PORT):
# devices
self._gps = gps
self.windsensor = WindSensor(I2C(WINDSENSOR_I2C_ADDRESS))
self.compass = Compass(I2C(COMPASS_I2C_ADDRESS),
I2C(ACCELEROMETER_I2C_ADDRESS))
self.red_led = GpioWriter(17, os)
self.green_led = GpioWriter(18, os)
# Navigation
self.globe = Globe()
self.timer = Timer()
self.application_logger = self._rotating_logger(APPLICATION_NAME)
self.position_logger = self._rotating_logger("position")
self.exchange = Exchange(self.application_logger)
self.timeshift = TimeShift(self.exchange, self.timer.time)
self.event_source = EventSource(self.exchange, self.timer,
self.application_logger,
CONFIG['event source'])
self.sensors = Sensors(self.gps, self.windsensor, self.compass,
self.timer.time, self.exchange,
self.position_logger, CONFIG['sensors'])
self.gps_console_writer = GpsConsoleWriter(self.gps)
self.rudder_servo = Servo(serial.Serial(servo_port),
RUDDER_SERVO_CHANNEL, RUDDER_MIN_PULSE,
RUDDER_MIN_ANGLE, RUDDER_MAX_PULSE,
RUDDER_MAX_ANGLE)
self.steerer = Steerer(self.rudder_servo, self.application_logger,
CONFIG['steerer'])
self.helm = Helm(self.exchange, self.sensors, self.steerer,
self.application_logger, CONFIG['helm'])
self.course_steerer = CourseSteerer(self.sensors, self.helm,
self.timer,
CONFIG['course steerer'])
self.navigator = Navigator(self.sensors, self.globe, self.exchange,
self.application_logger,
CONFIG['navigator'])
self.self_test = SelfTest(self.red_led, self.green_led, self.timer,
self.rudder_servo, RUDDER_MIN_ANGLE,
RUDDER_MAX_ANGLE)
# Tracking
self.tracking_logger = self._rotating_logger("track")
self.tracking_sensors = Sensors(self.gps, self.windsensor,
self.compass, self.timer.time,
self.exchange, self.tracking_logger,
CONFIG['sensors'])
self.tracker = Tracker(self.tracking_logger, self.tracking_sensors,
self.timer)
