from gpiozero import AngularServo from time import sleep servo = AngularServo(5, min_angle=0, max_angle=90) servo.angle = 0 servo.min() sleep(1) servo.mid() sleep(1) servo.max() sleep(1)
servo32 = AngularServo(7, min_angle=-90, max_angle=90) servo33 = AngularServo(1, min_angle=-90, max_angle=90) servo41 = AngularServo(0, min_angle=-90, max_angle=90) servo42 = AngularServo(5, min_angle=-90, max_angle=90) servo43 = AngularServo(6, min_angle=-90, max_angle=90) servo11.max() servo12.max() servo13.max() sleep(1) servo11.mid() servo12.mid() servo13.mid() sleep(1) servo11.min() servo12.min() servo13.min() sleep(1) servo21.max() servo22.max() servo23.max() sleep(1) servo21.mid() servo22.mid() servo23.mid() sleep(1) servo21.min() servo22.min() servo23.min()
class Robot:
def __init__(self,
websocket,
servo_pin1=PWM_PIN1,
servo_pin2=PWM_PIN2,
max_pulse=DEFAULT_MAX_PULSE,
min_pulse=DEFAULT_MIN_PULSE):
self.init_at = datetime.datetime.now().time()
self.left_servo = Servo(PWM_PIN1,
frame_width=20 / 1000,
max_pulse_width=max_pulse,
min_pulse_width=min_pulse)
self.right_servo = Servo(servo_pin2,
frame_width=20 / 1000,
max_pulse_width=max_pulse,
min_pulse_width=min_pulse)
self.command_type_to_method = {
'movement': self.execute_movement,
'playback': self.handle_playback_task,
'reverse': self.handle_reverse_task,
'upload': self.save_command_sets,
'sonar': self.handle_sonar
}
self.movement_commands = {
'ArrowUp': self.move_forward,
'ArrowRight': self.turn_right,
'ArrowLeft': self.turn_left,
'ArrowDown': self.move_backwards,
'stop': self.stop
}
self.command_database_url = ""
self.database_path = ""
self.websocket = websocket
self.sonic_sensor = DistanceSensor(echo=17, trigger=4)
self.angular_servo = AngularServo(21,
max_pulse_width=2 / 1000,
min_pulse_width=1 / 10000)
self.current_background_tasks = {}
def handle_sonar(self, message):
if message == 'start':
sonar_task = asyncio.ensure_future(self.transmit_sonar_data())
self.current_background_tasks['sonar'] = sonar_task
elif message == 'stop':
self.current_background_tasks['sonar'].cancel()
async def transmit_sonar_data(self):
self.angular_servo.min()
await asyncio.sleep(1)
while True:
for i in chain(range(-90, 91), range(90, -81, -1)):
self.angular_servo.angle = i
await asyncio.sleep(.024) # fastest is like .004
angle_and_distance = json.dumps(
(i, round(self.sonic_sensor.distance * 100, 2)))
await self.websocket.send(angle_and_distance)
def move_forward(self):
self.left_servo.max()
self.right_servo.min()
def turn_right(self):
self.right_servo.min()
self.left_servo.min()
def turn_left(self):
self.left_servo.max()
self.right_servo.max()
def move_backwards(self):
self.left_servo.min()
self.right_servo.max()
def stop(self):
self.left_servo.mid()
self.right_servo.mid()
def handle_reverse_task(self, command_set):
reverse_task = asyncio.ensure_future(self.execute_reverse(command_set))
self.current_background_tasks['movement'] = reverse_task
async def execute_reverse(self, command_set):
reversed_directions = {
'ArrowUp': 'ArrowDown',
'ArrowDown': 'ArrowUp',
'ArrowRight': 'ArrowLeft',
'ArrowLeft': 'ArrowRight'
}
direction_duration_tups = RobotUtils.process_command_set(
command_set) #[('ArrowRight',3411),('ArrowDown',5000)]
direction_duration_tups.reverse()
for direction, duration in direction_duration_tups:
direction = reversed_directions[direction]
print("Executing {} for {} ms".format(direction, duration))
self.movement_commands[direction]()
await asyncio.sleep(duration / 1000)
self.stop()
def handle_playback_task(self, command_set):
playback_task = asyncio.ensure_future(
self.execute_playback(command_set))
self.current_background_tasks['movement'] = playback_task
async def execute_playback(self, command_set):
direction_duration_tups = RobotUtils.process_command_set(
command_set) #[('ArrowRight',3411),('ArrowDown',5000)]
for direction, duration in direction_duration_tups:
print("Executing {} for {} ms".format(direction, duration))
self.movement_commands[direction]()
await asyncio.sleep(duration / 1000)
self.stop()
def execute_movement(self, direction):
if 'movement' in self.current_background_tasks and self.current_background_tasks[
'movement']:
self.current_background_tasks['movement'].cancel()
self.current_background_tasks['movement'] = None
correct_method = self.movement_commands[direction]
correct_method()
def save_command_sets(self, command_set):
with open(self.database_path, 'w') as database:
database.write(command_set)
def send_command_sets(self):
with open(self.database_path) as database:
return database.read()
def process_message(self, message):
message_type, message_data = message['type'], message['data']
correct_method = self.command_type_to_method[
message_type] #returns a method
return correct_method(
message_data
) #this can potentially return a coroutine which can be cancelled in the main loop
myGPIO1 = 4 #right wheel
myGPIO2 = 25 # left wheel
myGPIO3 = 23 # mini front gate
myGPIO4 = 24 #right pick
myGPIO5 = 22 #left pick
myGPIO6 = 17 #leftbackgate
myGPIO7 = 18 #rightbackgate
myGPIO8 = 27 #classifier
leftWheel = Servo(myGPIO2)
rightWheel = AngularServo(25, min_angle=45, max_angle=-45)
#rightWheel = Servo(myGPIO1)
#miniFrontGate = Servo(myGPIO3)
#rightPick = Servo(myGPIO4)
#leftPick = Servo(myGPIO5)
'''
myCorrection=0
maxPW=(2.0+myCorrection)/1000
minPW=(1.0-myCorrection)/1000
servo = Servo(myGPIO5,min_pulse_width=minPW,max_pulse_width=maxPW)
while True:
print("Set value range -1.0 to +1.0")
for value in range(0,21):
value2=(float(value)-10)/10
servo.value=value2
print(value2)
sleep(0.5)
class Gpio:
def __init__(self):
self.cuarto1 = LED(5)
self.cuarto2 = LED(6)
self.cuarto3 = LED(13)
self.cuarto4 = LED(19)
self.cuarto5 = LED(26)
self.detectar = LED(21)
self.RELAY_PIN = 12
self.RELAY_PIN1 = 18
self.relay = gpiozero.OutputDevice(self.RELAY_PIN,
active_high=False,
initial_value=False)
self.relayV = gpiozero.OutputDevice(self.RELAY_PIN1,
active_high=False,
initial_value=False)
self.pir = MotionSensor(17)
self.puerta1 = AngularServo(20, min_angle=0, max_angle=90)
self.puerta2 = AngularServo(16, min_angle=0, max_angle=90)
self.puerta3 = AngularServo(7, min_angle=0, max_angle=90)
self.DHT_READ_TIMEOUT = 10
self.DHT_DATA_PIN = 4
self.dht22_sensor = Adafruit_DHT.DHT11
self.temperature = 0
def getCuarto1(self):
return self.cuarto1
def setCuarto1(self, estado):
if estado == 'ON':
self.cuarto1.on()
elif estado == 'OFF':
self.cuarto1.off()
def getCuarto2(self):
return self.cuarto2
def setCuarto2(self, estado):
if estado == 'ON':
self.cuarto2.on()
elif estado == 'OFF':
self.cuarto2.off()
def getCuarto3(self):
return self.cuarto3
def setCuarto3(self, estado):
if estado == 'ON':
self.cuarto3.on()
elif estado == 'OFF':
self.cuarto3.off()
def getCuarto4(self):
return self.cuarto4
def setCuarto4(self, estado):
if estado == 'ON':
self.cuarto4.on()
elif estado == 'OFF':
self.cuarto4.off()
def getCuarto5(self):
return self.cuarto5
def setCuarto5(self, estado):
if estado == 'ON':
self.cuarto5.on()
elif estado == 'OFF':
self.cuarto5.off()
def getRele(self):
return self.relay
def setRele(self, estado):
if estado == 'ON':
self.relay.on()
elif estado == 'OFF':
self.relay.off()
def getPir(self):
return self.pir
def setPir(self):
if self.pir.motion_detected:
self.detectar.on()
time.sleep(5)
self.detectar.off()
print('Movimiento')
else:
self.detectar.off()
print('NO Movimiento')
def getPuerta1(self):
return self.puerta1
def setPuerta1(self, estado):
if estado == 'ON':
self.puerta1.max()
elif estado == 'OFF':
self.puerta1.min()
def getPuerta2(self):
return self.puerta2
def getPuerta3(self):
return self.puerta3
def setPuerta3(self, estado):
if estado == 'ON':
self.puerta3.max()
elif estado == 'OFF':
self.puerta3.min()
def getDetectar(self):
return self.detectar
def getTemperatura(self):
return self.temperature
def setTemperatura(self):
humidity, temperature = Adafruit_DHT.read_retry(
self.dht22_sensor, self.DHT_DATA_PIN)
if humidity is not None and temperature is not None:
self.temperature = '%.0f' % (temperature)
print(self.temperature)
if int(self.temperature) >= 30:
self.relayV.on()
else:
self.relayV.off()
return True
