def __init__(self):
self.tcp_flag = False
self.led = Led()
self.adc = ADS7830()
self.servo = Servo()
self.buzzer = Buzzer()
self.control = Control()
self.sonic = Ultrasonic()
self.control.Thread_conditiona.start()
def __init__(self):
self.PWM = Motor()
self.servo = Servo()
self.led = Led()
self.ultrasonic = Ultrasonic()
self.buzzer = Buzzer()
self.adc = Adc()
self.light = Light()
self.infrared = Line_Tracking()
self.tcp_Flag = True
self.sonic = False
self.Light = False
self.Mode = 'one'
self.endChar = '\n'
self.intervalChar = '#'
def __init__(self, car_name):
self.car = Car(car_name)
self.car.steering.turning_max = 50
self.color = self.car.color_getter
self.flag = True
self.buzzer = Buzzer.Buzz()
self.led = LED.Led()
self.song = Buzzer_Elise.Elise()
def __init__(self, car_name):
self.car = Car(car_name)
#self.car.steering.turning_max = 50
self.color = self.car.color_getter
self.line = self.car.line_detector
self.average_speed = 70
self.flag = True
self.buzzer = Buzzer.Buzz()
def setup(self):
"""Setup pins, calibrate sensors, initialize variables """
try:
self.temp_sensor = Temperature(20, interrupt=True, log_data=True)
self.motion_sensor = Ultrasonic()
self.camera = PiCam()
self.human_detector = Detector()
self.flame_sensor = FlameSensor(21)
self.sms_service = SMS()
self.buzzer = Buzzer(23)
#self.gas_sensor = GasSensor()
#if any of this failed -> stop
print("Setup complete.")
return True
except Exception as e:
print("Setup Failed. {}".format(e))
return False
def __init__(self, api_creds, frame_order_info):
self.wp_rest_interface = WPRestInterface(wcapi=api_creds["wcapi"],
wpapi=api_creds["wpapi"])
self.usb_camera = UsbCamera.UsbCamera(os.getcwd() + "/captures/",
resolution=(1920, 1080))
self.usb_camera.remove_old_captures(days_old=3)
self.buzzer = Buzzer.Buzzer(pin=18)
self.photo_only_mode = False
self.set_state("READY")
self.frame_order_info = frame_order_info
def __init__(self):
self.headUpDownAngle = 90
self.headLeftRightAngle = 90
self.PWM = Motor()
self.servo = Servo()
self.horn = Buzzer()
self.speed = 1000
# corrected servo positions
# adjust these to suit your car
# so head is front and centre at start
self.headLRcorrect = -3
self.headUDcorrect = 4
self.reset_head()
self.selector = DefaultSelector()
# set true for mecanum wheels
self.mecanum = False
self.useLights = True
self.led = Led()
self.mouse = evdev.InputDevice('/dev/input/event1')
self.keybd = evdev.InputDevice('/dev/input/event0')
self.readingKeys = False
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
self.brake = False
self.reverse = False
self.indicating = False
self.leftTurn = False
self.rightTurn = False
self.moving = False
self.indi_time = datetime.now()
self.indi_off = True
self.brake_time = datetime.now()
self.brake_off = True
atexit.register(self.keybd.ungrab) # Don't forget to ungrab the keyboard on exit!
atexit.register(self.mouse.ungrab)
self.keybd.grab() # Grab, i.e. prevent the keyboard from emitting original events.#
self.mouse.grab()
# This works because InputDevice has a `fileno()` method.
self.selector.register(self.mouse, EVENT_READ)
self.selector.register(self.keybd, EVENT_READ)
def __init__(self):
#Get initial time offset
self.initial_time = time.time() * 1000.0
self.current_time = 0
#Define timer variables
self.previous_start_up_time = 0
self.previous_data_read_time = 0
self.previous_buzzer_time = 0
self.previous_cut_time = 0
self.previous_beep_time = 0
#Define data read variable
self.previous_IMU_read = 0
self.previous_GPS_read = 0
self.previous_BMP_read = 0
#Buzzer variables
self.beep = 0 #0 = idle, 1 = on
#GPS initial conditions
self.locked = False
self.initialPosition = []
self.boundary_cutdown = False
#Initiate Peripherals
self.buzzer = Buzzer.Buzzer(
self.buzzer_pin1, self.buzzer_pin2, self.current_time,
self.buzzer_start_time,
self.altitude_threshold) #Create Buzzer Object
self.CutDown = CutDown.CutDown(self.current_time, self.cut_down_pin,
self.cut_time) #Create CutDown Object
self.lsm = LSM303DLM.LSM303DLM()
self.lsm.enableDefault()
self.l3g = L3G4200D.L3G4200D()
self.l3g.enableDefault()
self.bmp = BMP085.BMP085()
self.gps = GPS.GPS()
#Create log files
newpath = './log'
if not os.path.exists(newpath):
os.makedirs(newpath)
self.imu_file = open(newpath + "/IMUData.txt", "w")
self.bmp_file = open(newpath + "/BMPData.txt", "w")
self.gps_file = open(newpath + "/GPSData.txt", "w")
#temp variables, remove later
self.previous_time_temp = 0
self.count = 0
def main():
score1 = 0
score2 = 0
server = 1
won = 0
gameover = False
effects_timer = 0
effects_count = 0
effects_colour = ''
effect = False
sound_timer = 0
start = True
start_time = time.time()
## Graphics class
screen = Screen(constants.WIDTH, constants.HEIGHT)
player1 = Paddle(screen, 3, constants.HEIGHT/2-1, constants.PLAYER1_COLOUR)
player2 = Paddle(screen, constants.WIDTH-4, constants.HEIGHT/2-1, constants.PLAYER2_COLOUR)
net = Net(screen, constants.NET_COLOUR)
ball = Ball(screen, 5, 20, constants.BALL_COLOUR)
pyglow = PyGlow()
led = Led(5)
net.draw()
screen.draw_num(constants.SCORE1[0], constants.SCORE1[1], score1, constants.SCORE_COLOUR)
screen.draw_num(constants.SCORE2[0], constants.SCORE2[1], score2, constants.SCORE_COLOUR)
# Initial value
ball.velocity = [10.0,10.0] #Roughly 8 seconds to cross screen?
screen.draw_str(25, 20, 'START', constants.WHITE)
screen.draw_str(25, 26, 'GAME!', constants.WHITE)
Buzzer.startMusic()
while (True):
# Calculate time since last frame
end_time = time.time()
frame_time = end_time - start_time
start_time = end_time
# Pyglow effects
if (effect):
effects_timer += frame_time
if (won == 0):
if ((effects_timer)%0.4 > 0.2 and (effects_timer - frame_time)%0.4 <= 0.2):
pyglow.all(0)
effects_count += 1
elif ((effects_timer)%0.4 <= 0.2 and (effects_timer - frame_time)%0.4 > 0.2):
pyglow.color(effects_colour, 150)
if (effects_count >= 5):
effect = False
effects_count = 0
else:
if (effects_timer < 0.2):
pyglow.color('white', 150)
elif (effects_timer < 0.4):
pyglow.color('blue', 150)
elif (effects_timer < 0.6):
pyglow.color('green', 150)
elif (effects_timer < 0.8):
pyglow.color('yellow', 150)
elif (effects_timer < 1.0):
pyglow.color('orange', 150)
elif (effects_timer < 1.2):
pyglow.color('red', 150)
elif (effects_timer < 1.4):
pyglow.all(0)
pyglow.color('white', 150)
effects_timer = 0
sound_timer += frame_time
if (sound_timer / 0.15 >= 1):
Buzzer.stopSound()
sound_timer = 0
# Noise reduction for ADC
value1 = 0
value2 = 0
for i in range(20):
value1 += read_adc(CHAN2)
value2 += read_adc(CHAN3)
value1 /= 20
value2 /= 20
# Button inputs
if (won == 0):
# Hardware debounce
# Player1 Serve
if (GPIO.input(10) == 1):
if (start):
start = False
screen.draw_str(25, 20, 'START', constants.BACKGROUND_COLOUR)
screen.draw_str(25, 26, 'GAME!', constants.BACKGROUND_COLOUR)
net.draw()
time.sleep(0.2)
ball.served = True
start_time = time.time()-0.01
continue
if (server == 1):
ball.served = True
# Player1 Power up
if (GPIO.input(9) == 1 and not start):
player1.power_up()
# Software debounce
# Player2 Serve
if (read_adc(CHAN4) < 100):
if (server == 2):
ball.served = True
# Player2 Power up
if (debounce(1, 11) and not start):
player2.power_up()
# Lose condition
if (ball.x >= screen.width-1):
score1 += 1
ball.served = False
# Draw new score
screen.draw_num(constants.SCORE1[0], constants.SCORE1[1], score1, constants.SCORE_COLOUR)
pyglow.color('blue', 150)
effects_timer = 0
effects_colour = 'blue'
effect = True
# Work out who's turn to serve
if ((score1+score2)%10 >= 5):
server = 2
ball.x = player2.x-1
ball.y = player2.y + player2.size[1]/2
ball.velocity = [-10, 10]
else:
ball.x = player1.x+1
ball.y = player1.y + player1.size[1]/2
ball.velocity = [10, 10]
# Lose condition
if (ball.x <= 1):
score2 += 1
ball.served = False
# Draw new score
screen.draw_num(constants.SCORE2[0], constants.SCORE2[1], score2, constants.SCORE_COLOUR)
pyglow.color('red', 150)
effects_timer = 0
effects_colour = 'red'
effect = True
# Work out who's turn to serve
if ((score1+score2)%10 >= 5):
server = 2
ball.x = player2.x-1
ball.y = player2.y + player2.size[1]/2
ball.velocity = [-10, 10]
else:
ball.x = player1.x+1
ball.y = player1.y + player1.size[1]/2
ball.velocity = [10, 10]
# Has someone won?
if (score1 >= 10):
won = 1
elif (score2 >= 10):
won = 2
# Move player paddles
player1.move(value1)
player2.move(value2)
# Update paddles; if powerup
player1.update(frame_time)
player2.update(frame_time)
# Move ball with paddle if not served
if (not ball.served):
if (server == 1):
ball.last_pos = [ball.roundx, ball.roundy]
ball.y = player1.y + player1.size[1] / 2
ball.x = player1.x + 1
ball.roundx = int(round(ball.x))
ball.roundy = int(round(ball.y))
if (ball.last_pos != [ball.roundx, ball.roundy]):
ball._moved = True
if (server == 2):
ball.last_pos = [ball.roundx, ball.roundy]
ball.y = player2.y + player2.size[1] / 2
ball.x = player2.x - 1
ball.roundx = int(round(ball.x))
ball.roundy = int(round(ball.y))
if (ball.last_pos != [ball.roundx, ball.roundy]):
ball._moved = True
# Collision Detection
if (ball.roundx == player1.x):
# Random speed
rx = random.randint(5,15)
ry = random.randint(5,15)
# Different trajectories, depending on where the paddle was hit
if (ball.roundy >= player1.y and ball.roundy <= player1.y + player1.size[1]/3):
ball.velocity[1] = -ry
ball.velocity[0] = rx
Buzzer.hitSound()
if (ball.roundy >= player1.y + player1.size[1]/3 and ball.roundy <= player1.y + player1.size[1]/3*2):
ball.velocity[1] = 0
ball.velocity[0] = rx
Buzzer.hitSound()
if (ball.roundy >= player1.y + player1.size[1]/3*2 and ball.roundy <= player1.y + player1.size[1]):
ball.velocity[1] = ry
ball.velocity[0] = rx
Buzzer.hitSound()
# Redraw paddle
player1._moved = True
if (ball.roundx == player2.x):
rx = random.randint(5,15)
ry = random.randint(5,15)
if (ball.roundy >= player2.y and ball.roundy <= player2.y + player2.size[1]/3):
ball.velocity[1] = -ry
ball.velocity[0] = -rx
Buzzer.hitSound()
if (ball.roundy >= player2.y + player2.size[1]/3 and ball.roundy <= player2.y + player2.size[1]/3*2):
ball.velocity[1] = 0
ball.velocity[0] = -rx
Buzzer.hitSound()
if (ball.roundy >= player2.y + player2.size[1]/3*2 and ball.roundy <= player2.y + player2.size[1]):
ball.velocity[1] = ry
ball.velocity[0] = -rx
Buzzer.hitSound()
# Redraw paddle
player2._moved = True
# Update ball's position
ball.update(frame_time)
led.update(ball.x)
# Draw ball
ball.draw()
# Draw player paddles
player1.draw()
player2.draw()
# Draw net and score if ball was over them
if (ball. last_pos != [ball.roundx, ball.roundy]):
net.spot_draw(ball.last_pos[0], ball.last_pos[1])
screen.spot_num(constants.SCORE1[0], constants.SCORE1[1], score1, constants.SCORE_COLOUR, ball.last_pos[0], ball.last_pos[1])
screen.spot_num(constants.SCORE2[0], constants.SCORE2[1], score2, constants.SCORE_COLOUR, ball.last_pos[0], ball.last_pos[1])
# Print winner once
if (won > 0 and not gameover):
screen.draw_str(17, 20, 'PLAYER ' + str(won), constants.WHITE)
screen.draw_str(25, 26, 'WINS!', constants.WHITE)
gameover = True
# This loop keeps checking for chips. If one is near it will get the UID and authenticate
while continue_reading:
# Scan for cards
(status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
# If a card is found
if status == MIFAREReader.MI_OK:
print "Card detected"
# Get the UID of the card
(status,uid) = MIFAREReader.MFRC522_Anticoll()
# If we have the UID, continue
if status == MIFAREReader.MI_OK:
Buzzer.setup()
LED.setup()
Buzzer.beep()
LED.led()
# Print UID
print "Card read UID: "+str(uid[0])+","+str(uid[1])+","+str(uid[2])+","+str(uid[3])
if uid[0]==150 and uid[1]==110 and uid[2]==1 and uid[3]==164:
print "Welcom, Jason :)"
if uid[0]==133 and uid[1]==94 and uid[2]==233 and uid[3]==171:
print "Welcom, Lucy :)"
# This is the default key for authentication
key = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF]
# This loop keeps checking for chips. If one is near it will get the UID and authenticate
while continue_reading:
# Scan for cards
(status, TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
# If a card is found
if status == MIFAREReader.MI_OK:
print "Card detected"
# Get the UID of the card
(status, uid) = MIFAREReader.MFRC522_Anticoll()
# If we have the UID, continue
if status == MIFAREReader.MI_OK:
Buzzer.setup()
LED.setup()
Buzzer.beep()
LED.led()
# Print UID
print "Card read UID: " + str(uid[0]) + "," + str(uid[1]) + "," + str(
uid[2]) + "," + str(uid[3])
if uid[0] == 150 and uid[1] == 110 and uid[2] == 1 and uid[3] == 164:
print "Welcom, Jason :)"
if uid[0] == 133 and uid[1] == 94 and uid[2] == 233 and uid[3] == 171:
print "Welcom, Lucy :)"
# This is the default key for authentication
key = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
class localKeyboard:
def __init__(self):
self.headUpDownAngle = 90
self.headLeftRightAngle = 90
self.PWM = Motor()
self.servo = Servo()
self.horn = Buzzer()
self.speed = 1000
# corrected servo positions
# adjust these to suit your car
# so head is front and centre at start
self.headLRcorrect = -3
self.headUDcorrect = 4
self.reset_head()
self.selector = DefaultSelector()
# set true for mecanum wheels
self.mecanum = False
self.useLights = True
self.led = Led()
self.mouse = evdev.InputDevice('/dev/input/event1')
self.keybd = evdev.InputDevice('/dev/input/event0')
self.readingKeys = False
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
self.brake = False
self.reverse = False
self.indicating = False
self.leftTurn = False
self.rightTurn = False
self.moving = False
self.indi_time = datetime.now()
self.indi_off = True
self.brake_time = datetime.now()
self.brake_off = True
atexit.register(self.keybd.ungrab) # Don't forget to ungrab the keyboard on exit!
atexit.register(self.mouse.ungrab)
self.keybd.grab() # Grab, i.e. prevent the keyboard from emitting original events.#
self.mouse.grab()
# This works because InputDevice has a `fileno()` method.
self.selector.register(self.mouse, EVENT_READ)
self.selector.register(self.keybd, EVENT_READ)
def read_keys_loop(self):
self.readingKeys = True
while self.readingKeys:
self.read_keys()
# only manage lights after a key press so brake lights, if on,
# will stay on until next key event
if self.useLights: self.manage_lights()
def manage_lights(self):
# indicators
if not self.indicating and not self.reverse:
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
else:
if self.indicating:
if (datetime.now() - self.indi_time).microseconds > 250000:
self.indi_off = not self.indi_off
self.indi_time = datetime.now()
if self.indi_off:
if self.leftTurn:
self.led.strip.setPixelColor(2, Color(125,85,0) )
self.led.strip.setPixelColor(5, Color(125,85,0) )
if self.rightTurn:
self.led.strip.setPixelColor(1, Color(125,85,0) )
self.led.strip.setPixelColor(6, Color(125,85,0) )
self.led.strip.show()
else:
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
if self.reverse:
self.led.strip.setPixelColor(1, Color(255,255,255) )
self.led.strip.setPixelColor(2, Color(255,255,255) )
self.led.strip.show()
if self.brake:
self.brake = False
if self.brake_off:
self.brake_off = False
self.brake_time = datetime.now()
self.led.strip.setPixelColor(1, Color(255,0,0) )
self.led.strip.setPixelColor(2, Color(255,0,0) )
self.led.strip.show()
if not self.brake_off:
#this is a minimum time on, they stay on until next key press
if (datetime.now() - self.brake_time).microseconds > 250000:
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
self.brake = False
self.brake_off = True
def read_keys(self):
for key, mask in self.selector.select():
device =key.fileobj
for event in device.read():
if event.type == evdev.ecodes.EV_KEY:
# print("key press")
# print(evdev.ecodes.bytype[evdev.ecodes.EV_KEY][event.code])
if event.value == 1 or event.value == 2:
self.key_press(event, self.keybd)
elif event.value == 0:
self.drive_stop()
elif event.type == evdev.ecodes.EV_REL:
if event.code == evdev.ecodes.REL_X:
if event.value < 0:
self.head_left()
else:
self.head_right()
if event.code == evdev.ecodes.REL_Y:
if event.value < 0:
self.head_down()
else:
self.head_up()
else:
pass
#print(event)
def key_press(self, ev, kbd):
if (ev.value == 1 or ev.value == 2): # 1 PRESS or 2 HOLD
# EVENTS CALLED ON PRESS AND ON HOLD
# HEAD POSITION
if ev.code == evdev.ecodes.KEY_Z: self.head_down()
elif ev.code == evdev.ecodes.KEY_A: self.head_left()
elif ev.code == evdev.ecodes.KEY_S: self.head_right()
elif ev.code == evdev.ecodes.KEY_W: self.head_up()
# HORN
elif ev.code == evdev.ecodes.KEY_T: self.toot()
# not interested in any other held keys
elif ev.value == 2: pass
#EVENTS THAT SHOULD ONLY BE CALLED ON PRESS AND NOT HOLD
# SPEED SETTING
elif ev.code == evdev.ecodes.KEY_1: self.speed = 1000
elif ev.code == evdev.ecodes.KEY_2: self.speed = 1200
elif ev.code == evdev.ecodes.KEY_3: self.speed = 1400
elif ev.code == evdev.ecodes.KEY_4: self.speed = 1700
elif ev.code == evdev.ecodes.KEY_5: self.speed = 2000
elif ev.code == evdev.ecodes.KEY_6: self.speed = 2400
elif ev.code == evdev.ecodes.KEY_7: self.speed = 2800
elif ev.code == evdev.ecodes.KEY_8: self.speed = 3200
elif ev.code == evdev.ecodes.KEY_9: self.speed = 3600
elif ev.code == evdev.ecodes.KEY_0: self.speed = 4000
# DRIVE FUNCTIONS
elif ev.code == evdev.ecodes.KEY_UP: self.drive_forward()
elif ev.code == evdev.ecodes.KEY_DOWN: self.drive_backward()
elif ev.code == evdev.ecodes.KEY_LEFT: self.turn_left()
elif ev.code == evdev.ecodes.KEY_RIGHT: self.turn_right()
elif ev.code == evdev.ecodes.KEY_COMMA: self.crab_left()
elif ev.code == evdev.ecodes.KEY_DOT: self.crab_right()
elif ev.code == evdev.ecodes.KEY_SEMICOLON: self.diag_right()
elif ev.code == evdev.ecodes.KEY_K: self.diag_left()
elif ev.code == evdev.ecodes.KEY_SLASH: self.diag_rev_right()
elif ev.code == evdev.ecodes.KEY_M: self.diag_rev_left()
elif ev.code == evdev.ecodes.KEY_U: self.curve_right()
elif ev.code == evdev.ecodes.KEY_Y: self.curve_left()
elif ev.code == evdev.ecodes.KEY_J: self.curve_rev_right()
elif ev.code == evdev.ecodes.KEY_H: self.curve_rev_left()
# USE OR DONT USE LIGHTS
elif ev.code == evdev.ecodes.KEY_L:
self.useLights = not self.useLights
if not self.useLights: self.led.colorWipe(self.led.strip, Color(0,0,0),0)
# RESET TO START STATE
elif ev.code == evdev.ecodes.KEY_HOME: #RESET TO START STATE
self.drive_stop()
self.servo.setServoPwm('0', int(self.headLeftRightAngle))
self.servo.setServoPwm('1', int(self.headUpDownAngle))
self.speed = 1000
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
# PROG FUNCTIONS
elif ev.code == evdev.ecodes.KEY_LEFTMETA: self.close()
elif ev.code == evdev.ecodes.KEY_END: self.shutdown_pi()
elif ev.code == evdev.ecodes.KEY_SYSRQ: self.reboot_pi()
else:
print("UNUSED KEY CODE")
print(evdev.ecodes.bytype[evdev.ecodes.EV_KEY][ev.code])
if ev.value == 0:
self.drive_stop()
# flush backed up key presses
while kbd.read_one() is not None:
if ev.value == 0 :
self.drive_stop()
def close(self):
self.readingKeys = False
self.selector.unregister(self.mouse)
self.selector.unregister(self.keybd)
self.led.colorWipe(self.led.strip, Color(0,0,0),0)
# kbd should be ungrabbed by atexit
# but belt and braces
try:
self.keybd.ungrab
self.mouse.ungrab
except:
pass
sys.exit()
def shutdown_pi(self):
self.readingKeys = False
self.toot()
time.sleep(0.2)
self.toot()
call("sudo nohup shutdown -h now", shell=True)
def reboot_pi(self):
self.readingKeys = False
self.toot()
call("sudo nohup reboot", shell=True)
def toot(self):
self.horn.run('1')
time.sleep(0.2)
self.horn.run('0')
def drive_forward(self):
self.moving = True
PWM.setMotorModel(self.speed, self.speed, self.speed, self.speed)
def turn_left(self):
self.moving = True
self.indicating = True
self.leftTurn = True
self.rightTurn = False
PWM.setMotorModel(-self.speed, -self.speed, self.speed, self.speed)
def drive_backward(self):
self.moving = True
self.reverse = True
PWM.setMotorModel(-self.speed, -self.speed, -self.speed, -self.speed)
def turn_right(self):
self.moving = True
self.indicating = True
self.leftTurn = False
self.rightTurn = True
PWM.setMotorModel(self.speed, self.speed, -self.speed, -self.speed)
def curve_left(self, biasPcent=20):
self.moving = True
PWM.setMotorModel(int(self.speed * (100 - biasPcent) / 100), int(self.speed * (100 - biasPcent) / 100),
int(self.speed * (100 + biasPcent) / 100), int(self.speed * (100 + biasPcent) / 100))
def curve_right(self, biasPcent=20):
self.moving = True
PWM.setMotorModel(int(self.speed * (100 + biasPcent) / 100), int(self.speed * (100 + biasPcent) / 100),
int(self.speed * (100 - biasPcent) / 100), int(self.speed * (100 - biasPcent) / 100))
def curve_rev_left(self, biasPcent=20):
self.moving = True
self.reverse = True
PWM.setMotorModel(-int(self.speed * (100 - biasPcent) / 100), -int(self.speed * (100 - biasPcent) / 100),
-int(self.speed * (100 + biasPcent) / 100), -int(self.speed * (100 + biasPcent) / 100))
def curve_rev_right(self, biasPcent=20):
self.moving = True
self.reverse = True
PWM.setMotorModel(-int(self.speed * (100 + biasPcent) / 100), -int(self.speed * (100 + biasPcent) / 100),
-int(self.speed * (100 - biasPcent) / 100), -int(self.speed * (100 - biasPcent) / 100))
def crab_left(self): #REQUIRES MECANUM WHEELS
if self.mecanum:
self.moving = True
self.indicating = True
self.leftTurn = True
self.rightTurn = False
PWM.setMotorModel(-self.speed, self.speed, self.speed, -self.speed)
def crab_right(self): #REQUIRES MECANUM WHEELS
if self.mecanum:
self.moving = True
self.indicating = True
self.leftTurn = False
self.rightTurn = True
PWM.setMotorModel(self.speed, -self.speed, -self.speed, self.speed)
def diag_right(self): #REQUIRES MECANUM WHEELS
if self.mecanum:
self.moving = True
PWM.setMotorModel(self.speed, 0, 0, self.speed)
def diag_left(self): #REQUIRES MECANUM WHEELS
if self.mecanum:
self.moving = True
PWM.setMotorModel(0, self.speed, self.speed, 0)
def diag_rev_left(self): #REQUIRES MECANUM WHEELS
if self.mecanum:
self.moving = True
self.reverse = True
PWM.setMotorModel(-self.speed, 0, 0, -self.speed)
def diag_rev_right(self): #REQUIRES MECANUM WHEELS
if self.mecanum:
self.moving = True
self.reverse = True
PWM.setMotorModel(0, -self.speed, -self.speed, 0)
def drive_stop(self):
if self.moving:
self.brake = True
self.moving = False
PWM.setMotorModel(0, 0, 0, 0)
self.reverse = False
self.indicating = False
self.leftTurn = False
self.rightTurn = False
def head_up(self):
self.headUpDownAngle += 1
if self.headUpDownAngle > 180 + self.headUDcorrect:
self.headUpDownAngle = 180 + self.headUDcorrect
self.servo.setServoPwm('1', self.headUpDownAngle)
# print("Up/down " + str(self.headUpDownAngle))
def head_down(self):
self.headUpDownAngle -= 1
if self.headUpDownAngle < 80 + self.headUDcorrect:
self.headUpDownAngle = 80 + self.headUDcorrect
self.servo.setServoPwm('1', self.headUpDownAngle)
# print("Up/down " + str(self.headUpDownAngle))
def head_left(self):
self.headLeftRightAngle -= 1
if self.headLeftRightAngle < 10 + self.headLRcorrect:
self.headLeftRightAngle = 10 + self.headLRcorrect
self.servo.setServoPwm('0', self.headLeftRightAngle)
# print("Left/Right " + str(self.headLeftRightAngle))
def head_LRpos(self, angle):
# print("Move head to " + str(self.headLeftRightAngle))
self.headLeftRightAngle = angle + self.headLRcorrect
self.servo.setServoPwm('0', self.headLeftRightAngle)
def head_right(self):
self.headLeftRightAngle += 1
if self.headLeftRightAngle > 170 + self.headLRcorrect:
self.headLeftRightAngle = 170 + self.headLRcorrect
self.servo.setServoPwm('0', self.headLeftRightAngle)
# print("Left/Right " + str(self.headLeftRightAngle))
def reset_head(self):
self.headLeftRightAngle = 90 + self.headLRcorrect
self.headUpDownAngle = 90 + self.headUDcorrect
self.servo.setServoPwm('0', int(self.headLeftRightAngle))
self.servo.setServoPwm('1', int(self.headUpDownAngle))
class Server:
def __init__(self):
self.tcp_flag = False
self.led = Led()
self.servo = Servo()
self.adc = ADS7830()
self.buzzer = Buzzer()
self.control = Control()
self.sonic = Ultrasonic()
self.control.Thread_conditiona.start()
self.battery_voltage = [8.4, 8.4, 8.4, 8.4, 8.4]
def get_interface_ip(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s',
b'wlan0'[:15]))[20:24])
def turn_on_server(self):
#ip adress
HOST = self.get_interface_ip()
#Port 8000 for video transmission
self.server_socket = socket.socket()
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT,
1)
self.server_socket.bind((HOST, 8001))
self.server_socket.listen(1)
#Port 5000 is used for instruction sending and receiving
self.server_socket1 = socket.socket()
self.server_socket1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT,
1)
self.server_socket1.bind((HOST, 5001))
self.server_socket1.listen(1)
print('Server address: ' + HOST)
def turn_off_server(self):
try:
self.connection.close()
self.connection1.close()
except:
print('\n' + "No client connection")
def reset_server(self):
self.turn_off_server()
self.turn_on_server()
self.video = threading.Thread(target=self.transmission_video)
self.instruction = threading.Thread(target=self.receive_instruction)
self.video.start()
self.instruction.start()
def send_data(self, connect, data):
try:
connect.send(data.encode('utf-8'))
#print("send",data)
except Exception as e:
print(e)
def transmission_video(self):
try:
self.connection, self.client_address = self.server_socket.accept()
self.connection = self.connection.makefile('wb')
except:
pass
self.server_socket.close()
try:
with picamera.PiCamera() as camera:
camera.resolution = (400, 300) # pi camera resolution
camera.framerate = 15 # 15 frames/sec
camera.saturation = 80 # Set image video saturation
camera.brightness = 50 # Set the brightness of the image (50 indicates the state of white balance)
start = time.time()
stream = io.BytesIO()
# send jpeg format video stream
print("Start transmit ... ")
for foo in camera.capture_continuous(stream,
'jpeg',
use_video_port=True):
try:
self.connection.flush()
stream.seek(0)
b = stream.read()
lengthBin = struct.pack('L', len(b))
self.connection.write(lengthBin)
self.connection.write(b)
stream.seek(0)
stream.truncate()
except BaseException as e:
#print (e)
print("End transmit ... ")
break
except BaseException as e:
#print(e)
print("Camera unintall")
def measuring_voltage(self, connect):
try:
for i in range(5):
self.battery_voltage[i] = round(self.adc.power(0), 2)
command = cmd.CMD_POWER + '#' + str(max(
self.battery_voltage)) + "\n"
self.send_data(connect, command)
self.sednRelaxFlag()
self.battery_reminder()
except Exception as e:
print(e)
def battery_reminder(self):
if max(self.battery_voltage) < 6.4:
self.turn_off_server()
self.control.relax(True)
print(
"The batteries power are too low. Please recharge the batteries or replace batteries."
)
print("Close the server")
os._exit(0)
def sednRelaxFlag(self):
if self.control.move_flag != 2:
command = cmd.CMD_RELAX + "#" + str(self.control.move_flag) + "\n"
self.send_data(self.connection1, command)
self.control.move_flag = 2
def receive_instruction(self):
try:
self.connection1, self.client_address1 = self.server_socket1.accept(
)
print("Client connection successful !")
except:
print("Client connect failed")
self.server_socket1.close()
while True:
try:
allData = self.connection1.recv(1024).decode('utf-8')
#print(allData)
except:
if self.tcp_flag:
if max(self.battery_voltage) > 6.4:
self.reset_server()
break
else:
break
if allData == "" and self.tcp_flag:
self.reset_server()
break
else:
cmdArray = allData.split('\n')
#print(cmdArray)
if cmdArray[-1] != "":
cmdArray == cmdArray[:-1]
for oneCmd in cmdArray:
data = oneCmd.split("#")
if data == None or data[0] == '':
continue
elif cmd.CMD_BUZZER in data:
self.buzzer.run(data[1])
elif cmd.CMD_LED in data:
try:
stop_thread(thread_led)
except:
pass
thread_led = threading.Thread(target=self.led.light,
args=(data, ))
thread_led.start()
elif cmd.CMD_LED_MOD in data:
try:
stop_thread(thread_led)
except:
pass
thread_led = threading.Thread(target=self.led.light,
args=(data, ))
thread_led.start()
elif cmd.CMD_HEAD in data:
self.servo.setServoAngle(15, int(data[1]))
elif cmd.CMD_SONIC in data:
command = cmd.CMD_SONIC + '#' + str(
self.sonic.getDistance()) + "\n"
self.send_data(self.connection1, command)
elif cmd.CMD_POWER in data:
self.measuring_voltage(self.connection1)
elif cmd.CMD_WORKING_TIME in data:
if self.control.move_timeout != 0 and self.control.relax_flag == True:
if self.control.move_count > 180:
command = cmd.CMD_WORKING_TIME + '#' + str(
180) + '#' + str(
round(self.control.move_count -
180)) + "\n"
else:
if self.control.move_count == 0:
command = cmd.CMD_WORKING_TIME + '#' + str(
round(
self.control.move_count)) + '#' + str(
round((time.time() -
self.control.move_timeout) +
60)) + "\n"
else:
command = cmd.CMD_WORKING_TIME + '#' + str(
round(self.control.move_count)
) + '#' + str(
round(time.time() -
self.control.move_timeout)) + "\n"
else:
command = cmd.CMD_WORKING_TIME + '#' + str(
round(
self.control.move_count)) + '#' + str(0) + "\n"
self.send_data(self.connection1, command)
else:
self.control.order = data
self.control.timeout = time.time()
try:
stop_thread(thread_power)
except:
pass
try:
stop_thread(thread_led)
except:
pass
print("close_recv")
self.control.relax_flag = False
self.control.order[0] = cmd.CMD_RELAX
def buzzer():
Buzzer.Buzzer(13).alarm_bg(5)
return redirect('/')
# Capture SIGINT for cleanup when the script is aborted
def end_read(signal, frame):
global continue_reading
print ""
continue_reading = False
GPIO.cleanup()
# Hook the SIGINT
signal.signal(signal.SIGINT, end_read)
# Create an object of the class MFRC522
MIFAREReader = MFRC522.MFRC522()
# Create an object of the class Buzzer
buzzer = Buzzer.Buzzer(15)
# Welcome message
print bcolors.WARNING + "Press Ctrl-C to stop...\n" + bcolors.ENDC
# This loop keeps checking for chips. If one is near it will get the UID and authenticate
while continue_reading:
# Scan for cards
(status, TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
time.sleep(0.1)
# If a card isn't found
if status != MIFAREReader.MI_OK:
continue
def __init__(self, pin, pinBuzzer, duration, frequency):
self.pin = pin
self.handler = None
self.state = False
self.buzzer = Buzzer.Buzzer(pinBuzzer, duration, frequency)
import Buzzer
from time import sleep
import json
with open('notes.json') as f:
notes = json.load(f)
b = Buzzer.Buzzer(18)
b.set_duty_cycle(.1)
seq = ((notes['E4'], .5), (notes['D4'], .5), (notes['C4'], 1))
b.playSequence(seq)
b.loadNotes('notes.json')
seq = (('E4', .5), ('D4', .5), ('C4', 1), ('B3', 1))
b.playNotes(seq)
def Run_Cart4(self):
#------------------------------------------Ultrasonic sensor and Servo Motor Class
self.Ultrasonic = Ultrasonic()
self.LED = Led()
self.Buzzer = Buzzer()
self.Junction = 0
#--------------------------------------------------------------------------------------
while True:
self.Movement_Type = 0
Distance = self.Ultrasonic.get_distance()
IR_Left = GPIO.input(IR01)
IR_Mid = GPIO.input(IR02)
IR_Right = GPIO.input(IR03)
if (Distance > 15.0):
if ((IR_Left == 0) and (IR_Mid == 1) and (IR_Right == 0)):
if (self.Moved_Reverse_New != self.Moved_Reverse_Old):
self.Movement_Type = 11 #Move Reverse
else:
self.Movement_Type = 5 #Move Forward
self.Junction = 0 #Clear the Junction Variable
elif ((IR_Left == 1) and (IR_Mid == 0) and (IR_Right == 0)):
self.Movement_Type = 3 #Take Slight Left
elif ((IR_Left == 1) and (IR_Mid == 1) and (IR_Right == 0)):
self.Movement_Type = 3 #Take Slight Left
elif ((IR_Left == 0) and (IR_Mid == 0) and (IR_Right == 1)):
self.Movement_Type = 7 #Take Slight Right
elif ((IR_Left == 0) and (IR_Mid == 1) and (IR_Right == 1)):
self.Movement_Type = 7 #Take Slight Right
elif ((IR_Mid == 1) and (IR_Left == 1) and (IR_Right == 1)):
if (self.Junction == 0):
self.Movement_Type = self.Mov_According_To_Specified_position(
)
self.Junction = 1
else:
pass
else:
self.Movement_Type = 0 #Stop Movement
self.LED.ledIndex(0x20, 255, 125, 0) #Orange
self.LED.ledIndex(0x40, 255, 125, 0) #Orange
time.sleep(1)
self.LED.ledIndex(0x60, 0, 0, 0)
#Actuate the motors to move cart to the specific Coordinate
self.Move_Cart(self.Movement_Type)
if (self.Is_Intermediate_DestinTion_Reached()):
break
def update_game():
global servesremaining, game_state
# Collide with the sides
if ball.position.x >= constants.COLUMNS:
ball.velocity.x *= -1
score1.value += 1
PiGlow.blueWin()
Buzzer.playTone(constants.left_right, 0.15)
setup_serve()
elif ball.position.x <= 0:
ball.velocity.x *= -1
score2.value += 1
PiGlow.redWin()
Buzzer.playTone(constants.left_right, 0.15)
setup_serve()
ball.lastposition = Point(ball.position.x, ball.position.y)
ball.position.x += ball.velocity.x
ball.position.y += ball.velocity.y
ball.position.y = max(ball.position.y, 0)
ball.position.y = min(ball.position.y, constants.ROWS)
# Collide with the ceiling/floor
if ball.position.y >= constants.ROWS - 1 or ball.position.y <= 0:
ball.velocity.y *= -1
Buzzer.playTone(constants.up_down, 0.25)
if ball.position.x == bat1.position.x + 1 and ball.velocity.x < 0:
if ball.position.y >= bat1.position.y and ball.position.y < (
bat1.position.y + bat1.length):
if constants.randomSpeed:
ball.velocity.x = random.randint(1, 3)
else:
ball.velocity.x = 1
Buzzer.playTone(constants.touch_bat_blue, 0.25)
positiononbat = int(bat1.position.y - ball.position.y)
if bat1.length == 3:
if positiononbat == 0:
ball.velocity.y = -1
elif positiononbat == -1:
ball.velocity.y = 0
elif positiononbat == -2:
ball.velocity.y = 1
else:
pass
else:
if (positiononbat == 0) or (positiononbat == -1):
ball.velocity.y = -1
elif (positiononbat == -2) or (positiononbat == -3):
ball.velocity.y = 0
elif (positiononbat == -4) or (positiononbat == -5):
ball.velocity.y = 1
else:
pass
elif ball.position.x == bat2.position.x - 1 and ball.velocity.x > 0:
if ball.position.y >= bat2.position.y and ball.position.y < (
bat2.position.y + bat2.length):
if constants.randomSpeed:
ball.velocity.x = -random.randint(1, 3)
else:
ball.velocity.x = -1
Buzzer.playTone(constants.touch_bat_red, 0.25)
positiononbat = int(bat2.position.y - ball.position.y)
if bat2.length == 3:
if positiononbat == 0:
ball.velocity.y = -1
elif positiononbat == -1:
ball.velocity.y = 0
elif positiononbat == -2:
ball.velocity.y = 1
else:
pass
else:
if (positiononbat == 0) or (positiononbat == -1):
ball.velocity.y = -1
elif (positiononbat == -2) or (positiononbat == -3):
ball.velocity.y = 0
elif (positiononbat == -4) or (positiononbat == -5):
ball.velocity.y = 1
else:
pass
from evdev import InputDevice, categorize, ecodes
from Motor import *
from Buzzer import *
dev = InputDevice('/dev/input/event0')
print(dev)
PWM = Motor()
buzzer = Buzzer()
for event in dev.read_loop():
if event.type == ecodes.EV_KEY:
if event.value == 0:
PWM.setMotorModel(0, 0, 0, 0)
buzzer.run('0')
elif event.value == 1:
if event.code == 103:
PWM.setMotorModel(1000, 1000, 1000, 1000)
elif event.code == 108:
PWM.setMotorModel(-1000, -1000, -1000, -1000)
elif event.code == 105:
PWM.setMotorModel(-1500, -1500, 2000, 2000)
elif event.code == 106:
PWM.setMotorModel(2000, 2000, -1500, -1500)
elif event.code == 28:
buzzer.run('1')
class Server:
def __init__(self):
self.PWM = Motor()
self.servo = Servo()
self.led = Led()
self.ultrasonic = Ultrasonic()
self.buzzer = Buzzer()
self.adc = Adc()
self.light = Light()
self.infrared = Line_Tracking()
self.tcp_Flag = True
self.sonic = False
self.Light = False
self.Mode = 'one'
self.endChar = '\n'
self.intervalChar = '#'
def get_interface_ip(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s',
b'wlan0'[:15]))[20:24])
def StartTcpServer(self):
HOST = str(self.get_interface_ip())
self.server_socket1 = socket.socket()
self.server_socket1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT,
1)
self.server_socket1.bind((HOST, 5000))
self.server_socket1.listen(1)
self.server_socket = socket.socket()
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT,
1)
self.server_socket.bind((HOST, 8000))
self.server_socket.listen(1)
print('Server address: ' + HOST)
def StopTcpServer(self):
try:
self.connection.close()
self.connection1.close()
except Exception as e:
print('\n' + "No client connection")
def Reset(self):
self.StopTcpServer()
self.StartTcpServer()
self.SendVideo = Thread(target=self.sendvideo)
self.ReadData = Thread(target=self.readdata)
self.SendVideo.start()
self.ReadData.start()
def send(self, data):
self.connection1.send(data.encode('utf-8'))
def sendvideo(self):
try:
self.connection, self.client_address = self.server_socket.accept()
self.connection = self.connection.makefile('wb')
except:
pass
self.server_socket.close()
try:
with picamera.PiCamera() as camera:
camera.resolution = (400, 300) # pi camera resolution
camera.framerate = 15 # 15 frames/sec
time.sleep(2) # give 2 secs for camera to initilize
start = time.time()
stream = io.BytesIO()
# send jpeg format video stream
print("Start transmit ... ")
for foo in camera.capture_continuous(stream,
'jpeg',
use_video_port=True):
try:
self.connection.flush()
stream.seek(0)
b = stream.read()
length = len(b)
if length > 5120000:
continue
lengthBin = struct.pack('L', length)
self.connection.write(lengthBin)
self.connection.write(b)
stream.seek(0)
stream.truncate()
except Exception as e:
print(e)
print("End transmit ... ")
break
except:
#print "Camera unintall"
pass
def stopMode(self):
try:
stop_thread(self.infraredRun)
self.PWM.setMotorModel(0, 0, 0, 0)
except:
pass
try:
stop_thread(self.lightRun)
self.PWM.setMotorModel(0, 0, 0, 0)
except:
pass
try:
stop_thread(self.ultrasonicRun)
self.PWM.setMotorModel(0, 0, 0, 0)
self.servo.setServoPwm('0', 90)
self.servo.setServoPwm('1', 90)
except:
pass
def readdata(self):
try:
try:
self.connection1, self.client_address1 = self.server_socket1.accept(
)
print("Client connection successful ! ---- SURE?")
except:
print("Client connect failed")
restCmd = ""
self.server_socket1.close()
while True:
try:
AllData = restCmd + self.connection1.recv(1024).decode(
'utf-8')
except:
if self.tcp_Flag:
self.Reset()
break
print('AllData is', AllData)
if len(AllData) < 5:
restCmd = AllData
if restCmd == '' and self.tcp_Flag:
self.Reset()
break
restCmd = ""
if AllData == '':
break
else:
cmdArray = AllData.split("\n")
if (cmdArray[-1] != ""):
restCmd = cmdArray[-1]
cmdArray = cmdArray[:-1]
for oneCmd in cmdArray:
data = oneCmd.split("#")
if data == None:
continue
elif cmd.CMD_MODE in data:
if data[1] == 'one':
self.stopMode()
self.Mode = 'one'
elif data[1] == 'two':
self.stopMode()
self.Mode = 'two'
self.lightRun = Thread(target=self.light.run)
self.lightRun.start()
elif data[1] == 'three':
self.stopMode()
self.Mode = 'three'
self.ultrasonicRun = threading.Thread(
target=self.ultrasonic.run)
self.ultrasonicRun.start()
elif data[1] == 'four':
self.stopMode()
self.Mode = 'four'
self.infraredRun = threading.Thread(
target=self.infrared.run)
self.infraredRun.start()
elif (cmd.CMD_MOTOR in data) and self.Mode == 'one':
print('Data is', data)
try:
data1 = int(data[1])
data2 = int(data[2])
data3 = int(data[3])
data4 = int(data[4])
if data1 == None or data2 == None or data2 == None or data3 == None:
continue
self.PWM.setMotorModel(data1, data2, data3, data4)
except:
pass
elif cmd.CMD_SERVO in data:
try:
data1 = data[1]
data2 = int(data[2])
if data1 == None or data2 == None:
continue
self.servo.setServoPwm(data1, data2)
except:
pass
elif cmd.CMD_LED in data:
try:
data1 = int(data[1])
data2 = int(data[2])
data3 = int(data[3])
data4 = int(data[4])
if data1 == None or data2 == None or data2 == None or data3 == None:
continue
self.led.ledIndex(data1, data2, data3, data4)
except:
pass
elif cmd.CMD_LED_MOD in data:
self.LedMoD = data[1]
if self.LedMoD == '0':
try:
stop_thread(Led_Mode)
except:
pass
self.led.ledMode(self.LedMoD)
time.sleep(0.1)
self.led.ledMode(self.LedMoD)
else:
try:
stop_thread(Led_Mode)
except:
pass
time.sleep(0.1)
Led_Mode = Thread(target=self.led.ledMode,
args=(data[1], ))
Led_Mode.start()
elif cmd.CMD_SONIC in data:
if data[1] == '1':
self.sonic = True
self.ultrasonicTimer = threading.Timer(
0.5, self.sendUltrasonic)
self.ultrasonicTimer.start()
else:
self.sonic = False
elif cmd.CMD_BUZZER in data:
try:
self.buzzer.run(data[1])
except:
pass
elif cmd.CMD_LIGHT in data:
if data[1] == '1':
self.Light = True
self.lightTimer = threading.Timer(
0.3, self.sendLight)
self.lightTimer.start()
else:
self.Light = False
elif cmd.CMD_POWER in data:
ADC_Power = self.adc.recvADC(2) * 3
try:
self.send(cmd.CMD_POWER + '#' + str(ADC_Power) +
'\n')
except:
pass
except Exception as e:
print(e)
self.StopTcpServer()
def sendUltrasonic(self):
if self.sonic == True:
ADC_Ultrasonic = self.ultrasonic.get_distance()
if ADC_Ultrasonic == self.ultrasonic.get_distance():
try:
self.send(cmd.CMD_SONIC + "#" + str(ADC_Ultrasonic) + '\n')
except:
self.sonic = False
self.ultrasonicTimer = threading.Timer(0.13, self.sendUltrasonic)
self.ultrasonicTimer.start()
def sendLight(self):
if self.Light == True:
ADC_Light1 = self.adc.recvADC(0)
ADC_Light2 = self.adc.recvADC(1)
try:
self.send(cmd.CMD_LIGHT + '#' + str(ADC_Light1) + '#' +
str(ADC_Light2) + '\n')
except:
self.Light = False
self.lightTimer = threading.Timer(0.17, self.sendLight)
self.lightTimer.start()
def Power(self):
while True:
ADC_Power = self.adc.recvADC(2) * 3
time.sleep(3)
if ADC_Power < 6.8:
for i in range(4):
self.buzzer.run('1')
time.sleep(0.1)
self.buzzer.run('0')
time.sleep(0.1)
elif ADC_Power < 7:
for i in range(2):
self.buzzer.run('1')
time.sleep(0.1)
self.buzzer.run('0')
time.sleep(0.1)
else:
self.buzzer.run('0')
class Server:
def __init__(self):
self.tcp_flag = False
self.led = Led()
self.adc = ADS7830()
self.servo = Servo()
self.buzzer = Buzzer()
self.control = Control()
self.sonic = Ultrasonic()
self.control.Thread_conditiona.start()
def get_interface_ip(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s',
b'wlan0'[:15]))[20:24])
def turn_on_server(self):
#ip adress
HOST = self.get_interface_ip()
#Port 8002 for video transmission
self.server_socket = socket.socket()
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT,
1)
self.server_socket.bind((HOST, 8002))
self.server_socket.listen(1)
#Port 5002 is used for instruction sending and receiving
self.server_socket1 = socket.socket()
self.server_socket1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT,
1)
self.server_socket1.bind((HOST, 5002))
self.server_socket1.listen(1)
print('Server address: ' + HOST)
def turn_off_server(self):
try:
self.connection.close()
self.connection1.close()
except:
print('\n' + "No client connection")
def reset_server(self):
self.turn_off_server()
self.turn_on_server()
self.video = threading.Thread(target=self.transmission_video)
self.instruction = threading.Thread(target=self.receive_instruction)
self.video.start()
self.instruction.start()
def send_data(self, connect, data):
try:
connect.send(data.encode('utf-8'))
#print("send",data)
except Exception as e:
print(e)
def transmission_video(self):
try:
self.connection, self.client_address = self.server_socket.accept()
self.connection = self.connection.makefile('wb')
except:
pass
self.server_socket.close()
try:
with picamera.PiCamera() as camera:
camera.resolution = (400, 300) # pi camera resolution
camera.framerate = 15 # 15 frames/sec
camera.saturation = 80 # Set image video saturation
camera.brightness = 50 # Set the brightness of the image (50 indicates the state of white balance)
#camera.iso = 400
time.sleep(2) # give 2 secs for camera to initilize
start = time.time()
stream = io.BytesIO()
# send jpeg format video stream
print("Start transmit ... ")
for foo in camera.capture_continuous(stream,
'jpeg',
use_video_port=True):
try:
self.connection.flush()
stream.seek(0)
b = stream.read()
lengthBin = struct.pack('L', len(b))
self.connection.write(lengthBin)
self.connection.write(b)
stream.seek(0)
stream.truncate()
except BaseException as e:
#print (e)
print("End transmit ... ")
break
except BaseException as e:
#print(e)
print("Camera unintall")
def receive_instruction(self):
try:
self.connection1, self.client_address1 = self.server_socket1.accept(
)
print("Client connection successful !")
except:
print("Client connect failed")
self.server_socket1.close()
while True:
try:
allData = self.connection1.recv(1024).decode('utf-8')
except:
if self.tcp_flag:
self.reset_server()
break
else:
break
if allData == "" and self.tcp_flag:
self.reset_server()
break
else:
cmdArray = allData.split('\n')
print(cmdArray)
if cmdArray[-1] != "":
cmdArray == cmdArray[:-1]
for oneCmd in cmdArray:
data = oneCmd.split("#")
if data == None or data[0] == '':
continue
elif cmd.CMD_BUZZER in data:
self.buzzer.run(data[1])
elif cmd.CMD_POWER in data:
batteryVoltage = self.adc.batteryPower()
command = cmd.CMD_POWER + "#" + str(
batteryVoltage[0]) + "#" + str(
batteryVoltage[1]) + "\n"
#print(command)
self.send_data(self.connection1, command)
if batteryVoltage[0] < 5.5 or batteryVoltage[1] < 6:
for i in range(3):
self.buzzer.run("1")
time.sleep(0.15)
self.buzzer.run("0")
time.sleep(0.1)
elif cmd.CMD_LED in data:
try:
stop_thread(thread_led)
except:
pass
thread_led = threading.Thread(target=self.led.light,
args=(data, ))
thread_led.start()
elif cmd.CMD_LED_MOD in data:
try:
stop_thread(thread_led)
#print("stop,yes")
except:
#print("stop,no")
pass
thread_led = threading.Thread(target=self.led.light,
args=(data, ))
thread_led.start()
elif cmd.CMD_SONIC in data:
command = cmd.CMD_SONIC + "#" + str(
self.sonic.getDistance()) + "\n"
self.send_data(self.connection1, command)
elif cmd.CMD_HEAD in data:
if len(data) == 3:
self.servo.setServoAngle(int(data[1]), int(data[2]))
elif cmd.CMD_CAMERA in data:
if len(data) == 3:
x = self.control.restriction(int(data[1]), 50, 180)
y = self.control.restriction(int(data[2]), 0, 180)
self.servo.setServoAngle(0, x)
self.servo.setServoAngle(1, y)
elif cmd.CMD_RELAX in data:
#print(data)
if self.control.relax_flag == False:
self.control.relax(True)
self.control.relax_flag = True
else:
self.control.relax(False)
self.control.relax_flag = False
elif cmd.CMD_SERVOPOWER in data:
if data[1] == "0":
GPIO.output(self.control.GPIO_4, True)
else:
GPIO.output(self.control.GPIO_4, False)
else:
self.control.order = data
self.control.timeout = time.time()
try:
stop_thread(thread_led)
except:
pass
try:
stop_thread(thread_sonic)
except:
pass
print("close_recv")
class FSM(object):
# control loop attr
state = ""
running = True
# devices
temp_sensor = None
motion_sensor = None
camera = None
human_detector = None
flame_sensor = None
sms_service = None
buzzer = None
gas_sensor = None
def __init__(self):
if (self.setup()):
self.running = True
else:
try:
self.exit()
except:
pass
GPIO.cleanup()
def setup(self):
"""Setup pins, calibrate sensors, initialize variables """
try:
self.temp_sensor = Temperature(20, interrupt=True, log_data=True)
self.motion_sensor = Ultrasonic()
self.camera = PiCam()
self.human_detector = Detector()
self.flame_sensor = FlameSensor(21)
self.sms_service = SMS()
self.buzzer = Buzzer(23)
#self.gas_sensor = GasSensor()
#if any of this failed -> stop
print("Setup complete.")
return True
except Exception as e:
print("Setup Failed. {}".format(e))
return False
#Functions are created for each state with default case
def temp(self):
print("Entering temperature monitoring state...")
temp = 0
while (temp < 30):
temp = self.temp_sensor.get_current_temperature()
print("Current temperature is: {}C".format(temp))
time.sleep(1)
print("High temperature of {} C".format(temp))
self.setState("2") # high temperature. Changes state
# time dependence
def motion(self):
print("Entering motion sensor state...")
# When the device enter this state it will dedicate a certain amount of time
# to determine whether the stove is occupied or not before it decided to move on to the next state.
time_left = 30 # time until trigger
self.setState("") # presumes state changes
while (time_left > 0):
motion_signal = self.motion_sensor.get_current_result()
if (motion_signal):
print("Motion detected.")
self.camera.record()
if (self.human_detector.detect()):
print("Stove occupied.")
print("Wait 10 mins..")
#time.sleep(600)
self.setState("1")
else:
print(
"Stove unattended.\n{} more second(s) without human present will trigger the next state."
.format(time_left))
else:
print(
"No motion is detected.\n{} more second(s) without human present will trigger the next state."
.format(time_left))
time_left -= 1
time.sleep(1)
def flame(self):
print("Entering flame detection state...")
flame_output = self.flame_sensor.get_current_result()
if (flame_output):
print("Flame detected.")
self.setState("5")
else:
print("No flame detected.")
self.setState("4")
time.sleep(2)
# time dependence
def app(self):
print("Entering app alert routine...")
#self.sms_service.send_sms_image(text = "I think your stove is on and unattended. ")
time.sleep(5)
self.setState("5")
def emergency(self):
print("Entering emmergency alert routine...")
#self.sms_service.send_sms_image(text = "I think your stove is literally on fire. ")
time.sleep(5)
self.setState("")
def Exit(self):
print("{} : Exit loop.".format(__name__))
# kill all remain threads
self.temp_sensor.stop()
self.flame_sensor.stop()
self.buzzer.stop()
#self.gas_sensor.stop()
self.running = False
time.sleep(3)
#TODO: get all the thread stop before gpio clean up to prevent error when shutdown
GPIO.cleanup()
sys.exit()
def Default_state(self):
print("Wrong entry! The number must be 1-3")
self.setState("1")
def run(self):
# Main control loop
try:
while (self.running):
self.States.get(self.state, self.Default_state)(self)
# buzzer is active on state 4 and 5
if (self.state == "4" or self.state == "5"):
self.buzzer.buzz(True)
else:
self.buzzer.buzz(False)
except KeyboardInterrupt or Exception as e:
#self.Exit()
raise e
def setState(self, s: str):
self.state = s
#Dictionary containing all possible states
States = {
"1": temp, # temp_or_gas
"2": motion,
"3": flame,
"4": app,
"5": emergency,
"": Exit
}
Left_IDR = adc.recvADC(0)
print("The photoresistor voltage on the left is " + str(Left_IDR) +
"V")
Right_IDR = adc.recvADC(1)
print("The photoresistor voltage on the right is " +
str(Right_IDR) + "V")
Power = adc.recvADC(2)
print("The battery voltage is " + str(Power * 3) + "V")
time.sleep(1)
print '\n'
except KeyboardInterrupt:
print "\nEnd of program"
from Buzzer import *
buzzer = Buzzer()
def test_Buzzer():
try:
buzzer.run('1')
time.sleep(1)
print "1S"
time.sleep(1)
print "2S"
time.sleep(1)
print "3S"
buzzer.run('0')
print "\nEnd of program"
except KeyboardInterrupt:
buzzer.run('0')
time.sleep(0.05)
if __name__ == '__main__':
print('Initialize gamepad control...')
myPad = gamepad.Gamepad()
myPad.set_scale(.05, 800, .95, 4095)
print('Initialize motor control...')
myEngine = Motor.Motor()
print('Initialize servo control ... ')
myServo = ServoControl(debug = True)
print('Initialize Buzzer Driver...')
myBuzzer = Buzzer.Buzzer()
print('Initialize ADC Driver...')
myAdc = ADC.Adc()
Thread_Monitor = threading.Thread(target = monitorBattery, args=[myAdc, myBuzzer])
Thread_Monitor.start()
print('Initialize LED Driver...')
myLed = Led.Led()
try:
print('Center camera head...')
myServo.center()
time.sleep(2)
print('Enter 50ms control loop...')
