def blinking():
if keepalive:
threading.Timer(10.0, blinking).start()
# Only blink when we are actually building
if building or error:
# If error, blink red.
if error:
color = "red"
else:
color = "yellow"
alloff()
pin = getcode(color)
GPIO.output(pin, True)
time.sleep(3)
GPIO.output(pin, False)
# Check every 10s if we are building, if not or done get latest status
python类output()的实例源码
def __init__(self, lr, s_size, a_size):
self.state_in = tf.placeholder(shape=[1], dtype=tf.int32)
state_in_OH = slim.one_hot_encoding(self.state_in, s_size)
output = slim.fully_connected(state_in_OH,
a_size,
biases_initializer=None,
activation_fn=tf.nn.sigmoid,
weights_initializer=tf.ones_initializer())
self.output = tf.reshape(output, [-1])
self.chosen_action = tf.argmax(self.output, 0)
self.reward_holder = tf.placeholder(shape=[1], dtype=tf.float32)
self.action_holder = tf.placeholder(shape=[1], dtype=tf.int32)
self.responsible_weight = tf.slice(self.output, self.action_holder, [1])
self.loss = -(tf.log(self.responsible_weight) * self.reward_holder)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=lr)
self.update = optimizer.minimize(self.loss)
def reverse(t=wheel_pulse/2):
gpio.output(reverse_left, gpio.HIGH)
gpio.output(reverse_right, gpio.HIGH)
sleep(t)
gpio.output(reverse_left, gpio.LOW)
gpio.output(reverse_right, gpio.LOW)
##########################################################################
# cleanup
##########################################################################
testWheels_Individual_4WD.py 文件源码
项目：RaspberryPi-Robot
作者: timestocome
项目源码
文件源码
阅读 32
收藏 0
点赞 0
评论 0
def reverse_left(t):
gpio.output(15, gpio.HIGH)
gpio.output(36, gpio.HIGH)
sleep(t)
gpio.output(15, gpio.LOW)
gpio.output(36, gpio.LOW)
# test
def set_up_gpio(self):
GPIO.setmode(GPIO.BCM)
#GPIO.setup(camera_led_pin, GPIO.OUT, initial=False) # Set GPIO to output
GPIO.setup(config.led_pin_select,GPIO.OUT) # The 'Select' button LED
GPIO.setup(config.led_pin_left,GPIO.OUT) # The 'Left' button LED
GPIO.setup(config.led_pin_right,GPIO.OUT) # The 'Right' button LED
# Detect falling edge on all buttons
GPIO.setup(config.button_pin_select, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(config.button_pin_left, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(config.button_pin_right, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(config.button_pin_exit, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Drumminhands found it necessary to switch off LEDs initially
GPIO.output(config.led_pin_select, False)
GPIO.output(config.led_pin_left, False)
GPIO.output(config.led_pin_right, False)
def __init__(self, dev='/dev/spidev0.0', speed=1000000, pin_rst=22, pin_ce=0):
self.pin_rst = pin_rst
self.pin_ce = pin_ce
SPI.openSPI(device=dev, speed=speed)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(pin_rst, GPIO.OUT)
GPIO.output(pin_rst, 1)
if pin_ce != 0:
GPIO.setup(pin_ce, GPIO.OUT)
GPIO.output(pin_ce, 1)
self.reset()
self.dev_write(0x2A, 0x8D)
self.dev_write(0x2B, 0x3E)
self.dev_write(0x2D, 30)
self.dev_write(0x2C, 0)
self.dev_write(0x15, 0x40)
self.dev_write(0x11, 0x3D)
self.set_antenna(True)
def _GPIO_Power_Set(pins, on):
if on==1:
GPIO.output( pins, GPIO.HIGH)
else :
GPIO.output( pins, GPIO.LOW )
return
#=====================================
def startwalking():
# Make the buzzer buzz on and off, half a second of
# sound followed by half a second of silence
# GPIO.output(PinRedPedestrian, GPIO.LOW)
# GPIO.output(PinGreenPedestrian, GPIO.HIGH)
iCount = 1
while iCount <= 4:
GPIO.output(PinBuzzer, GPIO.HIGH)
time.sleep(0.5)
GPIO.output(PinBuzzer, GPIO.LOW)
time.sleep(0.5)
iCount += 1
# Turn the buzzer off and wait for 2 seconds
# (If you have a second green 'pedestrian' LED, make it flash on and
# off for the two seconds)
def send_gpio_order(param):
"""
GPIO????
type in(GPIO.IN) out(GPIO.OUT)
value 1 GPIO.HIGH 0 GPIO.LOW
:param param:
:return:
"""
print param
channel, type, value = param
try:
import RPi.GPIO as GPIO
except RuntimeError:
print("????")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
if type == 'in':
GPIO.setup(channel, GPIO.IN)
GPIO.input(channel, value)
else:
GPIO.setup(channel, GPIO.OUT)
GPIO.output(channel, value)
def setup_output(self, name, pwm=False, initial=False):
""" Set pin as output.
:param name: Numer of the pin.
:type name: int
:param pwm: If value if PWM.
:type pwm: bool
:param initial: Initial value to set.
:type initial: bool
"""
self._pins[name] = {"name": name, "type": "out", "pwm": None}
GPIO.setup(name, GPIO.OUT)
if pwm:
pwm = GPIO.PWM(name, 200)
pwm.start(initial * 100.0)
self._pins[name]["pwm"] = pwm
else:
self[name] = initial
def start():
last = GPIO.input(button)
while True:
val = GPIO.input(button)
GPIO.wait_for_edge(button, GPIO.FALLING) # we wait for the button to be pressed
GPIO.output(lights[1], GPIO.HIGH)
inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device)
inp.setchannels(1)
inp.setrate(16000)
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
inp.setperiodsize(500)
audio = ""
while(GPIO.input(button)==0): # we keep recording while the button is pressed
l, data = inp.read()
if l:
audio += data
rf = open(path+'recording.wav', 'w')
rf.write(audio)
rf.close()
inp = None
alexa()
def init(self,bitrate,SDAPIN,SCLPIN):
if(SDAPIN != SCLPIN):
self.SCL = SCLPIN
self.SDA = SDAPIN
else:
print "SDA = GPIO"+str(self.SDA)+" SCL = GPIO"+str(self.SCL)
#configer SCL as output
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self.SCL, GPIO.OUT)
GPIO.setup(self.SDA, GPIO.OUT)
GPIO.output(self.SDA, GPIO.HIGH)
GPIO.output(self.SCL, GPIO.HIGH)
if bitrate == 100:
self.int_clk = 0.0000025
elif bitrate == 400:
self.int_clk = 0.000000625
elif bitrate == 1000:
self.int_clk = 1
elif bitrate == 3200:
self.int_clk = 1
def Start(self):
#SCL
# ______
# | |______
#SDA
# ___
# | |_________
GPIO.setup(self.SDA, GPIO.OUT) #cnfigure SDA as output
GPIO.output(self.SDA, GPIO.HIGH)
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(1)
GPIO.output(self.SDA, GPIO.LOW)
self.tick(1)
GPIO.output(self.SCL, GPIO.LOW)
self.tick(2)
def ReadAck(self):
GPIO.setup(self.SDA, GPIO.IN)
readbuffer =0
for i in range(8):
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
readbuffer |= (GPIO.input(self.SDA)<< 7) >> i
GPIO.output(self.SCL, GPIO.LOW)
self.tick(2)
GPIO.setup(self.SDA, GPIO.OUT)
GPIO.output(self.SDA, GPIO.LOW)
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
GPIO.output(self.SCL, GPIO.LOW)
GPIO.output(self.SDA, GPIO.LOW)
self.tick(2)
return readbuffer
def ReadNack(self):
GPIO.setup(self.SDA, GPIO.IN)
readbuffer =0
for i in range(8):
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
readbuffer |= (GPIO.input(self.SDA)<< 7) >> i
GPIO.output(self.SCL, GPIO.LOW)
self.tick(2)
GPIO.setup(self.SDA, GPIO.OUT)
GPIO.output(self.SDA, GPIO.HIGH)
GPIO.output(self.SCL, GPIO.HIGH)
self.tick(2)
GPIO.output(self.SCL, GPIO.LOW)
GPIO.output(self.SDA, GPIO.LOW)
self.tick(2)
return readbuffer
def calculateDistance():
GPIO.output(TRIG, False)
time.sleep(0.000002)
GPIO.output(TRIG, True)
time.sleep(0.00001)
GPIO.output(TRIG, False)
try:
pulse_start = pulseIn(ECHO, 0)
pulse_end = pulseIn(ECHO, 1)
except ValueError as error:
logging.warning(str(error))
return False
# Speed of sound 34300 cm/s
distance = round((pulse_end - pulse_start) * 17150)
# round distance to upper multiple of 5, e.g. 146 -> 150; 140 -> 145
distance += READING_ROUND - distance % READING_ROUND
return distance if 0 < distance < HEIGHT_CAN else False
# determines how full the can is
def start():
last = GPIO.input(button)
while True:
val = GPIO.input(button)
GPIO.wait_for_edge(button, GPIO.FALLING) # we wait for the button to be pressed
GPIO.output(lights[1], GPIO.HIGH)
inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device)
inp.setchannels(1)
inp.setrate(16000)
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
inp.setperiodsize(500)
audio = ""
while(GPIO.input(button)==0): # we keep recording while the button is pressed
l, data = inp.read()
if l:
audio += data
rf = open(path+'recording.wav', 'w')
rf.write(audio)
rf.close()
inp = None
alexa()
def test_relay():
"""Test relay on and off cycle"""
# check if the output is high
print 'current control output is: ', is_output_high(), ' (should be off)'
# start the relay
start_relay()
print 'current control output is: ', is_output_high(), ' (should be on)'
# setup a timer to stop the relay after 5 seconds
t = Timer(5, stop_relay)
t.start()
# wait for the timer to finish
t.join()
def quit(self):
""" Cleanup function """
log.debug("Quitting")
log.debug("Cleaning the photobooth")
self.queue.put("exit")
self.camera.close()
self.lamp.set_level(0)
self.count_display.switch_off()
GPIO.output(self.trigger_led_channel, 0)
GPIO.output(self.shutdown_led_channel, 0)
GPIO.cleanup()
sys.exit()
#################
### Functions ###
#################
def __init__(self, channel, invert=False):
from navio import adafruit_pwm_servo_driver as pwm
from navio import util
import RPi.GPIO as GPIO
util.check_apm()
#Navio+ requires the GPIO line 27 to be set to low
#before the PCA9685 is accesed
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(27, GPIO.OUT)
GPIO.output(27,GPIO.LOW)
#GPIO.cleanup()
self.frequency = 60
self.channel = channel
self.invert = invert
self.pwm = pwm.PWM()
self.pwm.setPWMFreq(self.frequency)
def __init__(self, ready):
Thread.__init__(self)
self.ready = ready
self.picked_up = False
self.on = True
self._ringer1 = 11
self._ringer2 = 13
self._button = 7
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(self._ringer1, GPIO.OUT)
GPIO.output(self._ringer1, GPIO.LOW)
GPIO.setup(self._ringer2, GPIO.OUT)
GPIO.output(self._ringer2, GPIO.LOW)
GPIO.setup(self._button, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
self._last_state = 0
self._last_ts = time.time()
self._last_check = time.time()
self._ring = 1
self.max_ring_cnt = 2
def _v2_init(self):
self.reset()
self._send_command(0x74, 0x54) # Set analog control block
self._send_command(0x75, 0x3b) # Sent by dev board but undocumented in datasheet
# Driver output control
self._send_command(0x01, [0xd3, 0x00, 0x00])
# Dummy line period
# Default value: 0b-----011
# See page 22 of datasheet
self._send_command(0x3a, 0x07)
# Gate line width
self._send_command(0x3b, 0x04)
# Data entry mode
self._send_command(0x11, 0x03)
def _pin_pulse(pin, initial_state=GPIO.LOW, pulse_width=PULSE_WIDTH_SEC):
# type: (int, bool, Union[int, float]) -> None
"""Sends one pulse to the specified pin.
The pin will be returned to the specified initial state after the pulse
Args:
pin: The pin to pulse.
initial_state: The negation of this will be used as the pulse.
Defaults to GPIO.LOW.
pulse_width: how long, in seconds, to pulse the pin.
Defaults to PULSE_WIDTH_SEC.
"""
GPIO.output(pin, not initial_state)
try:
time.sleep(pulse_width)
finally:
GPIO.output(pin, initial_state)
def _int_to_bcd(value):
# type: (Optional[int]) -> Tuple[bool, bool, bool, bool]
"""Converts an integer to a tuple representing the input bits to a BCD.
If the input value is None, an all high output will be produced. This will
typically make the BCD to turn its corresponding output off.
Args:
value: The value to be converted.
Returns:
tuple of bool corresponding to the BCD representation of the
inputted value.
"""
if value is None:
output = (GPIO.HIGH,) * 4
elif 0 <= value <= 9:
output = tuple(int(digit, 2) for digit in "{:04b}".format(value))
assert len(output) == 4
else:
raise ValueError("Specified input must be either None or between "
"0 and 9. Input was: {!r}.".format(value))
logger.debug("Converted %s to %s", value, output)
return output
def pulsetest():
dir=True
for freq in [200, 400, 800, 1000]:
halfpulse=.5/freq
# for j in range(0,i):
logging.debug("start")
for i in range(0,1600):
GPIO.output(pulse_pin, True)
time.sleep(halfpulse)
GPIO.output(pulse_pin, False)
time.sleep(halfpulse)
logging.debug("stop")
dir=not dir
GPIO.output(dir_pin, dir)
time.sleep(.5)
# logging.debug(i)
def __init__(self):
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.dir_pin, GPIO.OUT)
GPIO.setup(self.pulse_pin, GPIO.OUT)
GPIO.setup(self.ms1_pin, GPIO.OUT)
GPIO.setup(self.ms2_pin, GPIO.OUT)
GPIO.setup(self.sleep_pin, GPIO.OUT)
GPIO.setup(self.reset_pin, GPIO.OUT)
dir=False
GPIO.output(self.dir_pin, dir)
GPIO.output(self.pulse_pin, False)
GPIO.output(self.ms1_pin, True)
GPIO.output(self.ms2_pin, False)
GPIO.output(self.sleep_pin, False)
GPIO.output(self.reset_pin, True)
self.p1 = GPIO.PWM(self.pulse_pin, self.pulse_freq)
def beep(self):
if self.state is False:
cbpi.app.logger.error("BUZZER not working")
return
def play(sound):
try:
for i in sound:
if (isinstance(i, str)):
if i == "H" and self.beep_level == "HIGH":
GPIO.output(int(self.gpio), GPIO.HIGH)
elif i == "H" and self.beep_level != "HIGH":
GPIO.output(int(self.gpio), GPIO.LOW)
elif i == "L" and self.beep_level == "HIGH":
GPIO.output(int(self.gpio), GPIO.LOW)
else:
GPIO.output(int(self.gpio), GPIO.HIGH)
else:
time.sleep(i)
except Exception as e:
pass
start_new_thread(play, (self.sound,))
def main():
try:
while True:
for led in LEDS:
for idx, pin in enumerate(led):
if pin == O:
GPIO.setup(PINS[idx], GPIO.IN)
else:
GPIO.setup(PINS[idx], GPIO.OUT)
GPIO.output(PINS[idx], pin)
time.sleep(.1)
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()
def value(self, v=None):
if v is None:
return GPIO.input(self.gpio_no)
GPIO.output(self.gpio_no, v)
print("GPIO ########## GPIO.output({},{})={}".format(self.gpio_no,v,GPIO.input(self.gpio_no)))
def alloff():
GPIO.output(getcode('red'), False)
GPIO.output(getcode('buzzer'), False)
GPIO.output(getcode('yellow'), False)
GPIO.output(getcode('green'), False)
return
# Toggle function with parameter output and duration
