def on_mqtt_message(mosq, obj, msg):
"""
Handle incoming messages
"""
if msg.topic == MONITOR_REFRESH:
logging.debug("Refreshing the state of all monitored pins...")
refresh()
return
logging.debug("Received message %s, %s" % (msg.topic, msg.payload))
topicparts = msg.topic.split("/")
pin = int(topicparts[len(topicparts) - 1])
value = int(msg.payload)
try:
changedPort = PINS[pin]
logging.debug("Incoming message for pin %d -> %d" % (pin, value))
print("Incoming message for pin %d -> %d" % (pin, value))
print("change port is %s" % (changedPort))
if value == 1:
gpio.setcfg(changedPort, gpio.OUTPUT)
gpio.output(changedPort, gpio.HIGH)
else:
gpio.setcfg(changedPort, gpio.OUTPUT)
gpio.output(changedPort, gpio.LOW)
except Exception as e:
logging.error("Error %s" % (str(e)))
def Buttons(triggers):
buttons = triggers.sections()
GPIO.init()
pins = []
gpioType = []
i = 0
for button in buttons:
gpioType.append(button[0])
pins.append(h3pin[int(button[1:])])
if gpioType[i] == "B":
GPIO.setcfg(pins[i], GPIO.INPUT)
GPIO.pullup(pins[i], GPIO.PULLUP)
if gpioType[i] == "M":
GPIO.setcfg(pins[i], GPIO.INPUT)
i = i + 1
global buttonPressed
while True:
i = 0
for pin in pins:
if gpioType[i] == "B":
if not GPIO.input(pin):
buttonPressed = "B" + str(pipin[pin])
if gpioType[i] == "M":
if GPIO.input(pin):
buttonPressed = "M" + str(pipin[pin])
i = i + 1
time.sleep(0.020)
def __init__ (self, pin_id, direction = 1, value = 0):
self._pinid = pin_id
self._direction = direction
self._value = value
gpio.init()
gpio.setcfg (pin_id, direction)
gpio.output (pin_id, value)
def __init__(self, dev='/dev/spidev1.0', spd=1000000):
spi.openSPI(device=dev, speed=spd)
# GPIO.setmode(GPIO.BOARD)
GPIO.setcfg(22, GPIO.OUTPUT)
GPIO.output(self.NRSTPD, 1)
self.Write_MFRC522(self.RFCfgReg, (0x07 << 4))
self.MFRC522_Init()
def shutdowner():
rospy.init_node('shutdown_node')
rate = rospy.Rate(10) # 10hz
if not os.getegid() == 0:
sys.exit('Script must be run as root')
delay = 5
portToListen = port.PE5
portToWrite = port.PE4
gpio.init()
gpio.setcfg(portToListen, gpio.INPUT)
gpio.setcfg(portToWrite, gpio.OUTPUT)
while not rospy.is_shutdown():
try:
print("Press CTRL+C to exit")
while True:
v = gpio.input(portToListen)
if (v == 1):
sleep(2)
v = gpio.input(portToListen)
if (v == 1):
print("shutdown of the Olimex")
gpio.output(portToWrite, 1)
os.system("sudo halt -p")
break
sleep(delay)
except KeyboardInterrupt:
print("Goodbye.")
def shutdowner():
rospy.init_node('shutdown_node')
rate = rospy.Rate(10) # 10hz
if not os.getegid() == 0:
sys.exit('Script must be run as root')
delay=5
portToListen = port.PE5
portToWrite = port.PE4
gpio.init()
gpio.setcfg(portToListen, gpio.INPUT)
gpio.setcfg(portToWrite, gpio.OUTPUT)
while not rospy.is_shutdown():
try:
print ("Press CTRL+C to exit")
while True:
v=gpio.input(portToListen)
if(v==1):
sleep(2)
v=gpio.input(portToListen)
if(v==1):
print("shutdown of the Olimex")
gpio.output(portToWrite, 1)
os.system("sudo halt -p")
break
sleep(delay)
except KeyboardInterrupt:
print ("Goodbye.")
def blink2():
gpio.init()
blink = port.PA10
gpio.setcfg(blink, gpio.OUTPUT)
gpio.output(blink, gpio.HIGH)
sleep(1)
gpio.output(blink, gpio.LOW)
def RUN_INIT():
print "--> RUN_INIT : "
gpio.init()
gpio.setcfg(port.PA6, gpio.OUTPUT)
gpio.pullup(port.PA6, gpio.PULLDOWN)
gpio.output(port.PA6, gpio.HIGH)
time.sleep(0.1)
def __init__(self):
self._loop = False
self.detected = False
self._line1 = port.PA2
gpio.init()
gpio.setcfg(self._line1, gpio.INPUT)
gpio.pullup(self._line1, gpio.PULLUP)
def __init__(self):
self._led = port.PA10
self._ledstate = 0
self._loop = False
gpio.init()
gpio.setcfg(self._led, gpio.OUTPUT)
gpio.output(self._led, 0)
def fan_control():
# GPIO初始化输出
args = sys.argv
# 引脚
Pin = int(args[1]) # Pin = 2
# 电平
Act = int(args[2])
# 设置
gpio.setcfg(Pin, gpio.OUTPUT)
# 输出电平
gpio.output(Pin, 1 if Act == 1 else 0)
while True:
# output = os.popen('cat /sys/devices/virtual/hwmon/hwmon1/temp1_input')
output = os.popen(
'cat /sys/devices/virtual/thermal/thermal_zone0/temp')
wd = output.read()
temp = int(wd)
print("cpu温度: ", temp)
if temp > 50000:
gpio.output(Pin, 1)
else:
gpio.output(Pin, 0)
time.sleep(1)
def shutdowner():
if not os.getegid() == 0:
sys.exit('Script must be run as root')
delay = 5
portToListen = port.PI2 #13
portToWrite = port.PI1 #11
gpio.init()
gpio.setcfg(portToListen, gpio.INPUT)
gpio.setcfg(portToWrite, gpio.OUTPUT)
gpio.output(portToWrite,
1) #this tells EPS that shutdown script is running fine
while 1:
v = gpio.input(portToListen)
print v
if (v == 1):
sleep(delay)
v = gpio.input(portToListen)
if (v == 1):
print("shutdown of the Olimex")
gpio.output(portToWrite, 1)
os.system("sudo halt -p")
break
sleep(delay)
def __init__(self, input_dict):
gpio.init()
for key in input_dict:
tup = input_dict[key]
gpio.setcfg(key, gpio.INPUT)
gpio.pullup(key, gpio.PULLUP)
self.__hk_add_to_dict(key, tup)
def main(argv):
initial_button_state = 0
gpio.init()
gpio.setcfg(POWER_BUTTON, gpio.INPUT)
gpio.pullup(POWER_BUTTON, gpio.PULLUP)
gpio.setcfg(LED, gpio.OUTPUT)
while True:
# Returns a 1 if open and a 0 if pressed/closed
current_button_state = gpio.input(POWER_BUTTON)
#print(initial_button_state, current_button_state)
#sys.stdout.flush()
# Check if button state has changed
if current_button_state != initial_button_state:
#print('Button pressed')
gpio.output(LED, 1)
subprocess.call(CMD,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
time.sleep(0.1)
def run():
ErrorMessage = "ERROR : arguments is not true! "
gpio.init()
try:
#print ("Press CTRL+C to exit")
if len(sys.argv) != 3:
print(ErrorMessage)
return ErrorMessage
else:
pin = pinName(sys.argv[1])
if int(sys.argv[2]) == 2:
gpio.setcfg(pin, GPIO.INPUT)
status = gpio.input(pin)
print("status => ", status)
return status
elif int(sys.argv[2]) == 1 or int(sys.argv[2]) == 0:
gpio.setcfg(pin, gpio.OUTPUT)
gpio.output(pin, int(sys.argv[2]))
print("output => OK")
return "OK"
else:
return ErrorMessage
except KeyboardInterrupt:
#print ("Goodbye.")
return ErrorMessage
def Buttons(triggers):
buttons = triggers.sections()
GPIO.init()
pins = []
gpioType = []
i = 0
for button in buttons:
gpioType.append(button[0])
pins.append(h3pin[int(button[1:])])
if gpioType[i] == "B":
GPIO.setcfg(pins[i], GPIO.INPUT)
GPIO.pullup(pins[i], GPIO.PULLUP)
if gpioType[i] == "M":
GPIO.setcfg(pins[i], GPIO.INPUT)
i = i + 1
global buttonPressed
while True:
i = 0
for pin in pins:
if gpioType[i] == "B":
if not GPIO.input(pin):
buttonPressed = "B" + str(pipin[pin])
if gpioType[i] == "M":
if GPIO.input(pin):
buttonPressed = "M" + str(pipin[pin])
i = i + 1
time.sleep(0.020)
def init_gpio_monitoring(self):
# Init gpio module
gpio.init()
self.log("[ MO-INFO ] GPIO initialized.")
# Set directions
gpio_inputs = self.config.get("gpio_inputs", {})
gpio_outputs = self.config.get("gpio_outputs", {})
for func_name, pin_name in gpio_inputs.items():
if pin_name.startswith("gpio"):
self.gpio[func_name] = _gpio_input = getattr(
connector, pin_name)
else:
self.gpio[func_name] = _gpio_input = getattr(port, pin_name)
gpio.setcfg(_gpio_input, gpio.INPUT)
for func_name, pin_name in gpio_outputs.items():
if pin_name.startswith("gpio"):
self.gpio[func_name] = _gpio_output = getattr(
connector, pin_name)
else:
self.gpio[func_name] = _gpio_output = getattr(port, pin_name)
gpio.setcfg(_gpio_output, gpio.OUTPUT)
self.log("[ MO-INFO ] GPIO configured:"
"\n\tgpio_inputs:"
"\n\t\t%s"
"\n\tgpio_outputs:"
"\n\t\t%s" % ("emitting", "emitting"))
def soft_pwm(conn):
freq = 222 # Hz, mimic Panasonic output
duty = 0.5 # Start by doing everything
pwm_port = port.PI19
gpio.setcfg(pwm_port, gpio.OUTPUT)
period = 1.0/freq
period_high = period*duty
period_low = period*(1-duty)
while True:
if conn.poll():
duty = conn.recv()
period_high = period*duty
period_low = period*(1-duty)
if duty:
gpio.output(pwm_port, gpio.LOW)
sleep(period_low)
gpio.output(pwm_port, gpio.HIGH)
sleep(period_high)
else:
# No pulsing, wait a while and recheck
gpio.output(pwm_port, gpio.LOW)
sleep(period)
def __init__(self, pin):
log.debug("Initializing PIR...")
self.pin = pin
gpio.setcfg(self.pin, gpio.INPUT)
self.motion = False
self.last_update = False
log.debug("...PIR initialized!")
def __init__(self):
gpio.init()
for column in self.columns:
gpio.setcfg(column, gpio.OUTPUT)
for row in self.rows:
gpio.setcfg(row, gpio.INPUT)
gpio.pullup(row, gpio.PULLDOWN)
def direction (self, direction):
if self._direction != direction: #changes needed?
self._direction = direction
gpio.setcfg (self._pinid, dir)
return True
else:
return False
def __init__(self, out_gpio=None, invert=False):
self.out_gpio = out_gpio
self.invert = invert
self.__power = 0
self.__brightness = 100
if self.out_gpio:
gpio.setcfg(self.out_gpio, gpio.OUTPUT)
gpio.output(self.out_gpio, invert)
def enablePin(pinnumber):
PIN = pinnumber
argvs = sys.argv
argc = len(argvs)
if argc == 2:
PIN = int(argvs[1])
gpio.setcfg(PIN, gpio.OUTPUT)
gpio.output(PIN, True)
def setcfg(self, pin, mode):
if EMU:
print(f"PIN {pin}: mode {mode}")
self.state[pin] = {'mode': mode, 'val': 0}
return
if pin > self.expin:
self.expander.setcfg(pin, mode)
G.setcfg(pin, mode)
def __init__(self, port, timeout):
self.port = port
self.timeout = timeout
self.timers = {'last': 0}
self.events = {}
gpio.init()
gpio.setcfg(port, gpio.INPUT) #Configure PE11 as input
gpio.setcfg(port, 0) #Same as above
def __init__(self):
self.TRIG = port.PA21 # change this if necessary
self.ECHO = port.PC3 # change this if necessary
gpio.init()
gpio.setcfg(self.TRIG, gpio.OUTPUT)
gpio.setcfg(self.ECHO, gpio.INPUT)
async def set(self, *values):
if not self._initialized:
gpio.init()
for led in leds:
gpio.setcfg(led, gpio.OUTPUT)
self._initialized = True
assert (len(values) == len(leds))
for i in range(len(leds)):
gpio.output(leds[i], 0 if values[i] else 1)
def read(self):
gpio.setcfg(self.__pin, gpio.OUTPUT)
# send initial high
self.__send_and_sleep(gpio.HIGH, 0.05)
# pull down to low
self.__send_and_sleep(gpio.LOW, 0.02)
# change to input using pull up
#gpio.setcfg(self.__pin, gpio.INPUT, gpio.PULLUP)
gpio.setcfg(self.__pin, gpio.INPUT)
gpio.pullup(self.__pin, gpio.PULLUP)
# collect data into an array
data = self.__collect_input()
# parse lengths of all data pull up periods
pull_up_lengths = self.__parse_data_pull_up_lengths(data)
# if bit count mismatch, return error (4 byte data + 1 byte checksum)
# Fix issue on my Board with AM2301 to ensure at least the data is
# available
pull_up_lengths_size = len(pull_up_lengths)
if (self.__sensor == 22 and pull_up_lengths_size < 40) or (
self.__sensor == 11 and pull_up_lengths_size != 40):
return DHTResult(DHTResult.ERR_MISSING_DATA, 0, 0)
# calculate bits from lengths of the pull up periods
bits = self.__calculate_bits(pull_up_lengths)
# we have the bits, calculate bytes
the_bytes = self.__bits_to_bytes(bits)
# calculate checksum and check
checksum = self.__calculate_checksum(the_bytes)
if the_bytes[4] != checksum:
return DHTResult(DHTResult.ERR_CRC, 0, 0)
if self.__sensor == 22:
# Compute to ensure negative values are taken into account
c = (float)(((the_bytes[2] & 0x7F) << 8) + the_bytes[3]) / 10
# ok, we have valid data, return it
if (c > 125):
c = the_bytes[2]
if (the_bytes[2] & 0x80):
c = -c
return DHTResult(DHTResult.ERR_NO_ERROR, c,
((the_bytes[0] << 8) + the_bytes[1]) / 10.00)
else:
# ok, we have valid data, return it
return DHTResult(DHTResult.ERR_NO_ERROR, the_bytes[2],
the_bytes[0])
def blink3():
gpio.init()
blink = port.PA7
gpio.setcfg(blink, gpio.OUTPUT)
gpio.output(blink, gpio.HIGH)
sleep(0.03)
gpio.output(blink, gpio.LOW)
sleep(0.03)
def pindown(pin_code):
if RELETYPE == 1:
gpiolevel = gpio.HIGH
else:
gpiolevel = gpio.LOW
gpio.init()
gpio.setcfg(pin_code, gpio.OUTPUT)
gpio.output(pin_code, gpiolevel)
def __init__(self, savque, ports):#quelock, ports): threading.Thread.__init__(self) self.savque = savque #self.quelock = quelock self.ports = ports gpio.init() for p in self.ports: gpio.setcfg(p, gpio.INPUT) gpio.pullup(p, gpio.PULLDOWN) self.led = connector.LEDp2 gpio.setcfg(self.led, gpio.OUTPUT)
def okno():
window_pin = 14
gpio.setcfg(window_pin, gpio.INPUT)
gpio.pullup(window_pin, gpio.PULLUP)
if gpio.input(window_pin):
stan_gpio_okno = str('OKNO JEST OTWARTE')
else:
stan_gpio_okno = str('OKNO JEST ZAMKNIETE')
return jsonify(stan_gpio_okno)
def __init__(self, port):
"""
инициализация объекта
"""
self.port = port
self.state = gpio.LOW
gpio.setcfg(self.port, gpio.OUTPUT)
gpio.pullup(self.port, gpio.PULLDOWN)
self.off()
def stop(self):
"""
Stops PWM output.
"""
self.toTerminate = True
while self.terminated == False:
# Just wait
time.sleep(0.01)
GPIO.output(self.gpioPin, GPIO.LOW)
GPIO.setcfg(self.gpioPin, GPIO.INPUT)
def initiatePin(): #Initialiser les GPIO gpio.init() pin = port.PG6 gpio.setcfg(pin, gpio.OUTPUT) gpio.input(pin) gpio.setcfg(pin, 0) gpio.pullup(pin, 0) gpio.pullup(pin, gpio.PULLDOWN) gpio.pullup(pin, gpio.PULLUP)
def __init__( self, id, params ):
self.id = id
self.name = params['name']
self.pin = getPin( params['pin'] )
self.type = params['type']
devices['id'] = self
if self.type == 'switch' or self.type == 'pulse':
gpio.setcfg( self.pin, gpio.OUTPUT )
if self.type == 'pulse':
self.interval = params['interval']
gpio.output( self.pin, 0)
elif self.type == 'switch':
self.state = gpio.input( self.pin ) == 1
def begin(self, major, minor, ce_pin):
# Initialize SPI bus
self.spidev = spidev.SpiDev()
self.spidev.open(major, minor)
self.ce_pin = ce_pin
gpio.init()
gpio.setcfg(self.ce_pin, gpio.OUTPUT)
time.sleep(5 / 1000000.0)
# Set 1500uS (minimum for 32B payload in ESB@250KBPS) timeouts, to make testing a little easier
# WARNING: If this is ever lowered, either 250KBS mode with AA is broken or maximum packet
# sizes must never be used. See documentation for a more complete explanation.
self.write_register(NRF24.SETUP_RETR, (int('0100', 2) << NRF24.ARD) | (int('1111', 2) << NRF24.ARC))
# Restore our default PA level
self.setPALevel(NRF24.PA_MAX)
# Determine if this is a p or non-p RF24 module and then
# reset our data rate back to default value. This works
# because a non-P variant won't allow the data rate to
# be set to 250Kbps.
if self.setDataRate(NRF24.BR_250KBPS):
self.p_variant = True
# Then set the data rate to the slowest (and most reliable) speed supported by all
# hardware.
self.setDataRate(NRF24.BR_1MBPS)
# Initialize CRC and request 2-byte (16bit) CRC
self.setCRCLength(NRF24.CRC_16)
# Disable dynamic payloads, to match dynamic_payloads_enabled setting
self.write_register(NRF24.DYNPD, 0)
# Reset current status
# Notice reset and flush is the last thing we do
self.write_register(NRF24.STATUS, _BV(NRF24.RX_DR) | _BV(NRF24.TX_DS) | _BV(NRF24.MAX_RT))
# Set up default configuration. Callers can always change it later.
# This channel should be universally safe and not bleed over into adjacent
# spectrum.
self.setChannel(self.channel)
# Flush buffers
self.flush_rx()
self.flush_tx()
def __init__(self, params):
self.value=0
self.steps_pin = params['steps_pin'] if 'steps_pin' in params else 1
self.dir_pin = params['dir_pin'] if 'dir_pin' in params else 2
self.steps = params['steps'] if 'steps' in params else 0
self.dir = params['dir'] if 'dir' in params else 0
self.interval = params['interval'] if 'interval' in params else 0.25
self.steps2sync = params['steps2sync'] if 'steps2sync' in params else 100
self.stop=1
if self.steps:
self.buzy=1
else:
self.buzy=0
signal.signal(signal.SIGALRM, self.alarm_handler)
gpio.init()
gpio.setcfg(self.steps_pin, gpio.OUTPUT)
gpio.setcfg(self.dir_pin, gpio.OUTPUT)
gpio.output(self.steps_pin, 0)
gpio.output(self.dir_pin, 0)
def __init__(self):
logger = logging.getLogger("Microwave")
logger.info("Initialising microwave")
# GPIO 0 is port PI19, wired to PWM
pwm_port = port.PI19 # NOTE: Also set in soft_pwm()
gpio.setcfg(pwm_port, gpio.OUTPUT)
# GPIO5 is port PH21, wired to magentron power on/off relay
relay_port = port.PH21
gpio.setcfg(relay_port, gpio.OUTPUT)
# TODO: PI11 clashes with SPI0 which is connected in the DTS
# Header 23 is port PI11, wired to extra stuff relay - light & mixer
extra_port = port.PI11
gpio.setcfg(extra_port, gpio.OUTPUT)
# TODO: Door sensor
self._pwm_port = pwm_port
self._relay_port = relay_port
self._extra_port = extra_port
self._time = 0
self._temperature = 0
self._target_temperature = 80
self._power = 100
self._state = "stopped"
self._stop_time = datetime.now()
self.logger = logger
def __init__(self): self.pos = 0 self.testmode = False try: from pyA20.gpio import gpio from pyA20.gpio import port from pyA20.gpio import connector global pins gpio.init() #Initialize module. Always called first pins = [ port.PA8, port.PA9, port.PA10, port.PA20 ] for p in pins: gpio.setcfg(p, gpio.OUTPUT) #Configure LED1 as output gpio.output(p, 1) time.sleep(0.01) gpio.output(p, 0) gpio.output(pins[0], 1) self.gpio = gpio except: print "Focuser test mode" self.testmode = True
def __init__(self): gpio.init() self.sensorPin = port.PA8 #Port for the light barrier on the column bottom self.sleepPin = port.PA9 #Sleep Pin of the Polulu self.stepPin = port.PA10 #Step Pin of the Polulu self.dirPin = port.PA20 #Direction Pin of the Polulu self.height = 8450 #Configure the Pins gpio.setcfg(self.sensorPin, gpio.INPUT) gpio.pullup(self.sensorPin, gpio.PULLUP) gpio.setcfg(self.sleepPin, gpio.OUTPUT) gpio.setcfg(self.stepPin, gpio.OUTPUT) gpio.setcfg(self.dirPin, gpio.OUTPUT)
def setup(self): GPIO.init() GPIO.setcfg(self._pconfig['button'], GPIO.INPUT) GPIO.pullup(self._pconfig['button'], GPIO.PULLUP) GPIO.setcfg(self._pconfig['rec_light'], GPIO.OUTPUT) GPIO.setcfg(self._pconfig['plb_light'], GPIO.OUTPUT)
#!/usr/bin/env python from pyA20.gpio import gpio from pyA20.gpio import port from pyA20.gpio import connector from time import sleep gpio.init() gpio.setcfg(port.PI0,gpio.OUTPUT) #gpio.pullup(port.PI0,gpio.PULLUP) gpio.output(port.PI0,gpio.HIGH) sleep(0.1) gpio.output(port.PI0,gpio.LOW) gpio.output(port.PI0,gpio.HIGH)
import sys
from ADS1220 import ADS1220
from pyA20.gpio import gpio
from pyA20.gpio import port
def wait_data():
while gpio.input(irq):
pass
# We will use PH0 port for IRQ
irq = port.PH0
gpio.init()
gpio.setcfg(irq, gpio.INPUT)
# ADS1120 is connected to UEXT1
ads = ADS1220("/dev/spidev2.0")
# Reset device
ads.command_reset()
time.sleep(0.1)
# First we will read temperature
ads.set_temperature_sensor_mode(1)
ads.command_start()
# Wait for IRQ gpio to be pulled low
wait_data()
if (gpio.input(MISO)):
adcout |= 0x1
gpio.output(CS, 1)
adcout >>= 1 # first bit is 'null' so drop it
return adcout
# set ports
SPICLK = port.PI17
SPIMISO = port.PI19
SPIMOSI = port.PI18
SPICS = port.PI16
# set pins I/O
gpio.setcfg(SPIMOSI, 1) #MOSI
gpio.setcfg(SPIMISO, 0) #MISO
gpio.setcfg(SPICLK, 1) #CLK
gpio.setcfg(SPICS, 1) #CS
ch0 = readadc(0, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch1 = readadc(1, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch2 = readadc(2, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch3 = readadc(3, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch4 = readadc(4, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch5 = readadc(5, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch6 = readadc(6, SPICLK, SPIMOSI, SPIMISO, SPICS)
ch7 = readadc(7, SPICLK, SPIMOSI, SPIMISO, SPICS)
print "CO-sens:", ch0
__author__ = "Stefan Mavrodiev"
__copyright__ = "Copyright 2014, Olimex LTD"
__credits__ = ["Stefan Mavrodiev"]
__license__ = "GPL"
__version__ = "2.0"
__maintainer__ = __author__
__email__ = "*****@*****.**"
led = connector.gpio0p0 # This is the same as port.PH2
button = connector.gpio3p40
"""Init gpio module"""
gpio.init()
"""Set directions"""
gpio.setcfg(led, gpio.OUTPUT)
gpio.setcfg(button, gpio.INPUT)
"""Enable pullup resistor"""
gpio.pullup(button, gpio.PULLUP)
#gpio.pullup(button, gpio.PULLDOWN) # Optionally you can use pull-down resistor
try:
print ("Press CTRL+C to exit")
while True:
state = gpio.input(button) # Read button state
"""Since we use pull-up the logic will be inverted"""
gpio.output(led, not state)
except KeyboardInterrupt:
if l:
audio += data
print("{}Recording Finished.{}".format(bcolors.OKBLUE, bcolors.ENDC))
rf = open(path+'recording.wav', 'w')
rf.write(audio)
rf.close()
inp = None
alexa_speech_recognizer()
if __name__ == "__main__":
# GPIO.setwarnings(False)
# GPIO.cleanup()
# GPIO.setmode(GPIO.BCM)
gpio.init()
# GPIO.setup(button, GPIO.IN, pull_up_down=GPIO.PUD_UP)
gpio.setcfg(button, gpio.INPUT)
gpio.pullup(button, gpio.PULLUP)
# GPIO.setup(lights, GPIO.OUT)
gpio.setcfg(lights[0], gpio.OUTPUT)
gpio.setcfg(lights[1], gpio.OUTPUT)
# GPIO.output(lights, GPIO.LOW)
gpio.output(lights[0], gpio.LOW)
gpio.output(lights[1], gpio.LOW)
while internet_on() == False:
print(".")
token = gettoken()
play_audio("hello.mp3")
for x in range(0, 3):
time.sleep(.1)
# GPIO.output(plb_light, GPIO.HIGH)
gpio.output(plb_light, gpio.HIGH)
#!/usr/bin/python
from pyA20.gpio import gpio as GPIO
from pyA20.gpio import port
import sys
# Check if there are 2 parameters
if len(sys.argv) == 3:
# Arguments
ledPin = int(sys.argv[1])
state = int(sys.argv[2])
# Setup GPIO
GPIO.init()
# Setup led
if state == 1:
# Setup LED as OUTPUT
GPIO.setcfg(ledPin, GPIO.OUTPUT)
# Turn on LED (we keep the state)
GPIO.output(ledPin, True)
if state == 0:
# Setup LED as OUTPUT
# Clean state (this will turn off the led)
GPIO.setcfg(ledPin, GPIO.OUTPUT)
GPIO.output(ledPin, False)
else:
print "usage:onoff_orange.py pin state"
from pyA20.gpio import gpio
from pyA20.gpio import port
__author__ = "Stefan Mavrodiev"
__copyright__ = "Copyright 2014, Olimex LTD"
__credits__ = ["Stefan Mavrodiev"]
__license__ = "GPL"
__version__ = "2.0"
__maintainer__ = __author__
__email__ = "*****@*****.**"
led = port.PH2
gpio.init()
gpio.setcfg(led, gpio.OUTPUT)
try:
print ("Press CTRL+C to exit")
while True:
gpio.output(led, 1)
sleep(0.1)
gpio.output(led, 0)
sleep(0.1)
gpio.output(led, 1)
sleep(0.1)
gpio.output(led, 0)
sleep(0.1)
sleep(0.6)
from pyA20.gpio import gpio
from pyA20.gpio import port
from pyA20.gpio import connector
from relay_status import RelayStatus
global STATUS
STATUS = RelayStatus.OFF
__led = connector.LEDp2
__HEATING_PIN = __led # TODO: specify the heating PIN, it will switch the inbuilt LED for now.
gpio.init()
gpio.setcfg(__led, gpio.OUTPUT)
gpio.setcfg(__HEATING_PIN, gpio.OUTPUT)
def off(pin=__HEATING_PIN, led=False):
global STATUS
STATUS = RelayStatus.OFF.value
gpio.output(pin, 0)
if led:
turn_led_on()
def on(pin=__HEATING_PIN, led=False):
global STATUS
STATUS = RelayStatus.ON.value
gpio.output(pin, 1)
