def GPIO_PULL_UPDW_TESTING():
checkPins = []
print('== Testing GPIO PULL_UP_DOWN ==')
testPin = gpioUsedPins
print("Check that nothing connects to those pins: %s" %
(','.join([str(x) for x in testPin])))
GPIO.setmode(GPIO.BOARD)
GPIO.setup(testPin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
for pin in testPin:
if (GPIO.input(pin) !=
InternalPullUpDnValue[PullUpDnPins[pin] if pin in
PullUpDnPins else GPIO.PUD_UP]):
checkPins.append(pin)
GPIO.setup(testPin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
for pin in testPin:
if (GPIO.input(pin) !=
InternalPullUpDnValue[PullUpDnPins[pin] if pin in
PullUpDnPins else GPIO.PUD_DOWN]):
checkPins.append(pin)
print("[%s] Pull Up and Down" %
('PASS' if len(checkPins) <= 0 else 'FAILED'))
if (len(checkPins) > 0):
print('Please check those pins: %s' %
(','.join([str(x) for x in checkPins])))
GPIO.cleanup()
print('===============================')
def __init__(self, dev='/dev/spidev2.0', spd=1000000):
spi.openSPI(device=dev, speed=spd)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.NRSTPD, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
GPIO.output(self.NRSTPD, 1)
self.MFRC522_Init()
def readLevel():
try:
GPIO.setWarnings(False)
GPIO.setmode(GPIO.BOARD)
Trigger_AusgangsPin = 7
Echo_EingangsPin = 8
GPIO.setup(Trigger_AusgangsPin, GPIO.OUT)
GPIO.setup(Echo_EingangsPin, GPIO.IN)
GPIO.output(Trigger_AusgangsPin, False)
AusschaltZeit = 0
GPIO.output(Trigger_AusgangsPin, True)
time.sleep(0.00001)
GPIO.output(Trigger_AusgangsPin, False)
EinschaltZeit = time.time()
while GPIO.input(Echo_EingangsPin) == 0:
EinschaltZeit = time.time(
) # Es wird solange die aktuelle Zeit gespeichert, bis das Signal aktiviert wird
while GPIO.input(Echo_EingangsPin) == 1:
AusschaltZeit = time.time(
) # Es wird die letzte Zeit aufgenommen, wo noch das Signal aktiv war
Dauer = AusschaltZeit - EinschaltZeit
Abstand = (Dauer * 34300) / 2
return Abstand
except:
return 0
def GPIO_IO_TESTING():
print('== Testing GPIO INPUT/OUTPUT ==')
for mode in ['phys', 'TB', 'BCM']:
GPIO.setmode(modeMap[mode])
LPin = [pinTable[pins[0] - 1][mode] for pins in pairPins]
RPin = [pinTable[pins[1] - 1][mode] for pins in pairPins]
if (-1 in LPin or -1 in RPin):
print('Some pins use the 3.3V or GND pin.')
exit()
for IPin, OPin in [(LPin, RPin), (RPin, LPin)]:
GPIO.setup(IPin, GPIO.IN)
GPIO.setup(OPin, GPIO.OUT)
if (False in [GPIO.gpio_function(pin) == GPIO.IN for pin in IPin]
or False
in [GPIO.gpio_function(pin) == GPIO.OUT for pin in OPin]):
print('Check GPIO.gpio_function or GPIO.setup.')
exit()
for volt in [GPIO.HIGH, GPIO.LOW]:
GPIO.output(OPin, volt)
OResult = [GPIO.input(pin) == volt for pin in OPin]
IResult = [
GPIO.input(IPin[i]) == GPIO.input(OPin[i])
for i in range(len(IPin))
]
if (False in OResult):
print('Check Pin[%d].' % (OPin[OResult.index(False)]))
exit()
if (False in IResult):
print('Check Pin[%d].' % (IPin[IResult.index(False)]))
exit()
print("[PASS] GPIO.setmode(%s)" % (modeNameMap[mode]))
GPIO.cleanup()
print('===============================')
def ProjectorOnOffSwitch(pin, state):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(5, GPIO.OUT)
if state == 'off':
GPIO.output(5, GPIO.HIGH)
if state == 'on':
GPIO.output(5, GPIO.LOW)
return True
def glass(command):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT)
print "in glass function", command
if command == "opaque":
GPIO.output(3, GPIO.LOW)
stm.sleep(1)
if command == "transparent":
GPIO.output(3, GPIO.HIGH)
stm.sleep(1)
return True
def servo(angle):
dutyCycle = (angle + 45) / 18 #convert degrees to duty cycle
GPIO.setmode(GPIO.ASUS)
GPIO.setwarnings(False)
servo = 32
GPIO.setup(servo, GPIO.OUT)
pwm = GPIO.PWM(servo, 50)
pwm.ChangeDutyCycle(dutyCycle)
time.sleep(1)
def sensorData():
readPin = 0
GPIO.setup(photoPin, GPIO.OUT)
GPIO.output(photoPin, GPIO.LOW)
time.sleep(0.1)
GPIO.setup(photoPin, GPIO.IN)
while (GPIO.input(photoPin) == GPIO.LOW):
readPin += 1
return readPin
def __init__(self, doorId, config):
self.id = doorId
self.name = config['name']
self.relay_pin = config['relay_pin']
self.state_pin = config['state_pin']
self.state_pin_closed_value = config.get('state_pin_closed_value', 0)
self.time_to_close = config.get('time_to_close', 10)
self.time_to_open = config.get('time_to_open', 10)
self.openhab_name = config.get('openhab_name')
self.open_time = time.time()
gpio.setup(self.relay_pin, gpio.OUT)
gpio.setup(self.state_pin, gpio.IN, pull_up_down=gpio.PUD_UP)
gpio.output(self.relay_pin, False)
def _setup_sensor(self):
if self.sensor_enabled():
self._logger.info("Setting up sensor.")
if self.mode == 0:
self._logger.info("Using Board Mode")
GPIO.setmode(GPIO.BOARD)
else:
self._logger.info("Using BCM Mode")
GPIO.setmode(GPIO.BCM)
self._logger.info("Filament Sensor active on GPIO Pin [%s]"%self.pin)
GPIO.setup(self.pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
else:
self._logger.info("Pin not configured, won't work unless configured!")
def __init__(self,
pwm_pin,
n1_pin,
n2_pin,
tick_pin,
m_pr_tick,
pwm_speed=100,
control_loop_hz=100.0):
# pins
self.pwm_pin = pwm_pin
self.n1_pin = n1_pin
self.n2_pin = n2_pin
self.tick_pin = tick_pin
# options
self.pwm_speed = pwm_speed
self.control_loop_hz = control_loop_hz
self.m_pr_tick = m_pr_tick
self.p_gain = 0
self.i_gain = 0.01
# variables
self.last_tick = rospy.get_rostime()
self._set_speed = 0.0
self.speed = 0.0
self.direction = 0.0
self.p_reg = 0.0
self.i_reg = 0.0
self.last_pwm = 0.0
self.got_tick = False
self.direction = 0
# Pin setup
self.N1 = GpioTogglePin(self.n1_pin)
self.N2 = GpioTogglePin(self.n2_pin)
GPIO.setup(self.pwm_pin, GPIO.OUT)
GPIO.setup(self.tick_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.pwm = GPIO.PWM(self.pwm_pin, self.pwm_speed)
self.pwm.start(0.0)
GPIO.add_event_detect(self.tick_pin,
GPIO.FALLING,
callback=self.tick_callback,
bouncetime=1)
rospy.Timer(rospy.Duration(1.0 / self.control_loop_hz),
self.control_loop)
rospy.Timer(rospy.Duration(0.1), self.speed_resetter)
def triggerON(portNumber):
import ASUS.GPIO as GPIO
import time
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
light = portNumber
GPIO.setup(light, GPIO.OUT)
GPIO.output(light, GPIO.LOW)
try:
print("open led: {0}".format(light))
GPIO.output(light, GPIO.HIGH)
time.sleep(3)
GPIO.output(light, GPIO.LOW)
print("close led: {0}".format(light))
except KeyboardInterrupt:
GPIO.cleanup()
def pinSonar2(self, trig,echo):
#print pin
#print self.pinUse[pin]
self.pinUse[trig] = self.PSONAR
self.pinUse[echo] = self.PSONAR
GPIO.setup(trig,GPIO.OUT)
GPIO.setup(echo,GPIO.OUT)
ti = time.time()
# setup a list to hold 3 values and then do 3 distance calcs and store them
#print 'sonar started'
distlist = [0.0,0.0,0.0,0.0,0.0]
ts=time.time()
for k in range(5):
#print "sonar pulse" , k
GPIO.output(trig, 1) # Send Pulse high
time.sleep(0.00001) # wait
GPIO.output(trig, 0) # bring it back low - pulse over.
t0=time.time() # remember current time
GPIO.setup(echo,GPIO.IN)
#PIN_USE[i] = PINPUT don't bother telling system
t1=t0
# This while loop waits for input pin (7) to be low but with a 0.04sec timeout
while ((GPIO.input(echo)==0) and ((t1-t0) < 0.02)):
#time.sleep(0.00001)
t1=time.time()
t1=time.time()
#print 'low' , (t1-t0).microseconds
t2=t1
# This while loops waits for input pin to go high to indicate pulse detection
# with 0.04 sec timeout
while ((GPIO.input(echo)==1) and ((t2-t1) < 0.02)):
#time.sleep(0.00001)
t2=time.time()
t2=time.time()
#print 'high' , (t2-t1).microseconds
t3=(t2-t1) # t2 contains time taken for pulse to return
#print "total time " , t3
distance=t3*343/2*100 # calc distance in cm
distlist[k]=distance
#print distance
GPIO.setup(echo,GPIO.OUT)
tf = time.time() - ts
distance = sorted(distlist)[1] # sort the list and pick middle value as best distance
#print "total time " , tf
#for k in range(5):
#print distlist[k]
#print "pulse time" , distance*58
#print "total time in microsecs" , (tf-ti).microseconds
# only update Scratch values if distance is < 500cm
if (distance > 280):
distance = 299
if (distance < 2):
distance = 1
return distance
def __init__(self):
#GPIOs
self.led_pin = 7
self.fan_pin = 8
self.reset_pin = 3
self.power_pin = 5
self.check_pin = 10
#vars
self.fan_hysteresis = 5
self.fan_starttemp = 60
self.fan_hysteresis_pwm = 20
self.fan_starttemp_pwm = 60
self.reset_hold_short = 100
self.reset_hold_long = 500
self.debounce_time = 0.1
self.counter_time = 0.01
self.delay_until_reset = 2
self.is_pwm = False
#path
self.kintaro_folder = "/opt/KintaroSnes/"
self.start_folder = "start/"
self.intro_video = self.kintaro_folder + self.start_folder + "intro.mp4"
self.config_file = self.kintaro_folder + self.start_folder + "kintaro.config"
# self.temp_command = 'vcgencmd measure_temp'
#Set the GPIOs
GPIO.setmode(GPIO.BOARD) # Use the same layout as the pins
GPIO.setwarnings(False)
GPIO.setup(self.led_pin, GPIO.OUT) # LED Output
GPIO.setup(self.fan_pin, GPIO.OUT) # Fan normal Output
GPIO.setup(self.power_pin, GPIO.IN) # set pin as input
GPIO.setup(
self.reset_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP
) # set pin as input and switch on internal pull up resistor
GPIO.setup(self.check_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
if self.return_config_bool("PWM_FAN"):
self.is_pwm = True
self.pwm = GPIO.PWM(self.fan_pin, 50)
self.pwm.start(0)
def pinRCTime (self,pin):
reading = 0
#print "rc pin told to set to output"
self.pinUpdate(pin,0)
#print "rc changed to ouput"
time.sleep(0.1)
#print "sleep done"
GPIO.setup(pin,GPIO.IN)
#print "rc set to input"
#time.sleep(3)
#print "sleep 2 done"
# This takes about 1 millisecond per loop cycle
while (GPIO.input(pin) == GPIO.LOW) and (reading < 1000):
reading += 1
#print "change back to output"
GPIO.setup(pin,GPIO.OUT)
self.pinUpdate(pin,0)
return reading
def __init__(self, gpio_trigger, gpio_echo, range_min=10, range_max=400):
GPIO.setmode(GPIO.BCM)
self._gpio_trigger = gpio_trigger
self._gpio_echo = gpio_echo
self._range_min = range_min
self._range_max = range_max
self._is_reading = False
self._speed_sound = 17150.0 #- divided by 2 in cm/s
self._last_time_reading = 0
self._timeout = range_max / self._speed_sound * 2
GPIO.setup(gpio_trigger, GPIO.OUT)
GPIO.setup(gpio_echo, GPIO.IN)
#- Waiting for sensor to settle
GPIO.output(gpio_trigger, GPIO.LOW)
time.sleep(1)
def show():
"""Output the buffer to Blinkt!"""
global _gpio_setup
if not _gpio_setup:
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(DAT, GPIO.OUT)
GPIO.setup(CLK, GPIO.OUT)
_gpio_setup = True
_sof()
for pixel in pixels:
r, g, b, brightness = pixel
_write_byte(0b11100000 | brightness)
_write_byte(b)
_write_byte(g)
_write_byte(r)
_eof()
def setupGPIO(self):
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.DATA, GPIO.OUT)
GPIO.setup(self.SHIFT, GPIO.OUT)
GPIO.setup(self.STORE, GPIO.OUT)
GPIO.output(self.DATA, GPIO.LOW)
GPIO.output(self.SHIFT, GPIO.LOW)
GPIO.output(self.STORE, GPIO.LOW)
def resetPinMode(self):
#print "resetting pin mode"
self.stopServod()
for pin in self.validPins:
try:
self.pinRef[pin].stop() # stop PWM from running
self.pinRef[pin] = None
except:
pass
self.pinRef[pin] = None #reset pwm flag
try:
GPIO.remove_event_detect(pin) #Stop Any event detection for input and counting
except:
pass
try:
self.callbackInUse[pin] = False #reset event callback flags
except:
pass
if (self.pinUse[pin] == self.POUTPUT):
GPIO.setup(pin,GPIO.IN)
elif (self.pinUse[pin] == self.PINPUT):
GPIO.setup(pin,GPIO.IN)
elif (self.pinUse[pin] == self.PINPUTDOWN):
GPIO.setup(pin,GPIO.IN)
elif (self.pinUse[pin] == self.PINPUTNONE):
GPIO.setup(pin,GPIO.IN)
elif (self.pinUse[pin] == self.PCOUNT):
GPIO.setup(pin,GPIO.IN)
self.pinUse[pin] = self.PUNUSED
self.pinServoValue[pin] = None
print "reset pin", pin
self.pinValue[pin] = 0
self.pinInvert[pin] = False
def __init__(self, inputs=[[0x48, 0]], rdy_pin=17):
self.inputs = inputs
self.rdy_pin = rdy_pin
self.current_input = 0
self.last_val = 0
rospy.init_node('adc_node')
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
GPIO.setup(self.rdy_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(self.rdy_pin,
GPIO.FALLING,
callback=self.reading_ready,
bouncetime=1)
self.waiting_for_ready = False
# Setup adc hi/low tresh to use for conversion ready signal
for ind in inputs:
adr = ind[0]
bus.write_i2c_block_data(adr, 0x02, [0b00000000, 0b00000000])
bus.write_i2c_block_data(adr, 0x03, [0b10000000, 0b00000000])
rospy.sleep(0.1)
self.get_next_reading()
def __init__(self, headset):
Thread.__init__(self)
self.hs = headset
self.finish = False
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.DIAL_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.PULSE_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.HOOK_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
def setUp(self):
# GPIO.setmode(GPIO.BCM)
GPIO.setup(self.in1, GPIO.OUT)
GPIO.setup(self.in2, GPIO.OUT)
GPIO.setup(self.en, GPIO.OUT)
GPIO.output(self.in1, GPIO.LOW)
GPIO.output(self.in2, GPIO.LOW)
self.p = GPIO.PWM(self.en, 1000)
self.p.start(self.speeds[1])
def __init__(self, LED_OK, LED_NG, BTN_input):
""" Mamos setup"""
self.LED_OK = LED_OK
self.LED_NG = LED_NG
self.BTN_input = BTN_input
self.prev_input = False
try:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
GPIO.setup(LED_OK, GPIO.OUT)
GPIO.setup(LED_NG, GPIO.OUT)
GPIO.setup(BTN_input, GPIO.IN, pull_up_down=GPIO.PUD_UP)
except:
pass
def pinUpdate(self, pin, value,type = 'plain',stepDelay = 0.003):
print "pinUpdate p,v,t,pwmref: ",pin,value,type,self.pinRef[pin]
print "pin",pin
print "pvalue",self.pinValue
self.pinValue[pin] = value
self.mFreq = max(5,abs(value/2))
if (self.ledDim < 100) and (type == 'plain'):
type = "pwm"
value = value * self.ledDim
try:
print pin,value,type,self.pinUse[pin]
if type[0:3] == "pwm": #
print "processing pwm"
#return
if (self.pinInvert[pin] == True): # Invert data value (needed for active low devices)
value = 100 - abs(value)
print "motor freq calc", self.mFreq
try:
print "try jsut updating pwm"
self.pinRef[pin].ChangeDutyCycle(max(0,min(100,abs(value)))) # just update PWM value
if type == "pwmmotor":
#print "motor freq used a", self.mFreq
self.pinRef[pin].ChangeFrequency(self.mFreq) # change freq to motor freq
elif type != "pwmbeep":
#print "motor freq used a", self.mFreq
self.pinRef[pin].ChangeFrequency(self.pFreq) # change freq to motor freq
print "updating pwm suceceed"
except:
print "pwm not set so now setting up"
try:
GPIO.remove_event_detect(pin)
self.callbackInUse[pin] = False
except:
pass
GPIO.setup(pin,GPIO.OUT) # Setup
if type == "pwmmotor":
#print "motor freq used b", self.mFreq
self.pinRef[pin] = GPIO.PWM(pin,self.mFreq) # create new PWM instance
elif type != "pwmbeep":
#print "motor freq used a", self.mFreq
self.pinRef[pin] = GPIO.PWM(pin,self.pFreq) # create new PWM instance
self.pinRef[pin].start(max(0,min(100,abs(value)))) # update PWM value
print "pwm setup on pin",pin, "now has ref",self.pinRef[pin]
self.pinUse[pin] = self.PPWM # set pin use as PWM
elif type == "plain":
print "Plain processing- Pin " , pin , " commanded to be " , value
print "pinUpdate p,v,t,pwmref: ",pin,value,type,self.pinRef[pin]
if (self.pinInvert[pin] == True): # Invert data value (useful for 7 segment common anode displays)
value = 1 - abs(value)
if (self.pinUse[pin] == self.POUTPUT): # if already an output
GPIO.output(pin, int(value)) # set output to 1 ot 0
print 'pin' , pin , ' was already an output. Now set to' , value
elif (self.pinUse[pin] in [self.PINPUT,self.PINPUTNONE,self.PINPUTDOWN]): # if pin is an input
try:
GPIO.remove_event_detect(pin)
self.callbackInUse[pin] = False
except:
pass
self.pinUse[pin] = self.POUTPUT # switch it to output
GPIO.setup(pin,GPIO.OUT)
GPIO.output(pin, int(value)) # set output to 1 to 0
#print 'pin' , pin , ' was an input - change to output value' , value
elif (self.pinUse[pin] == self.PUNUSED): # if pin is not allocated
self.pinUse[pin] = self.POUTPUT # switch it to output
GPIO.setup(pin,GPIO.OUT)
GPIO.output(pin,int(value)) # set output to 1 or 0
print 'pin' , pin , ' was ununsed - now out value ' , value
elif (self.pinUse[pin] == self.PPWM): # pin was set as pwm
print "pinUpdate p,v,t,pwmref: ",pin,value,type,self.pinRef[pin]
print "pwm pin", pin , " sent digital on off: ",value
value = 100 if value else 0
self.pinRef[pin].ChangeDutyCycle(value)
except ValueError:
print "mistake made in trying to update an invalid pin"
print pin,value,type
pass
def setPinMode(self):
for pin in self.validPins:
#print pin
if (self.pinUse[pin] == self.POUTPUT):
print 'setting pin' , pin , ' to out'
try:
GPIO.remove_event_detect(pin)
except:
pass
try:
self.callbackInUse[pin] = False
except:
pass
GPIO.setup(pin,GPIO.OUT)
if (self.pinInvert[pin] == True):
GPIO.output(pin,1)
else:
GPIO.output(pin,0)
self.pinValue[pin] = 0
elif (self.pinUse[pin] == self.PINPUT):
print 'setting pin' , pin , ' to in with pull up'
GPIO.setup(pin,GPIO.IN,pull_up_down=GPIO.PUD_UP)
try:
GPIO.add_event_detect(pin, GPIO.BOTH, callback=self.gpioBoth,bouncetime=50) # add rising edge detection on a channel
except:
pass
elif (self.pinUse[pin] == self.PINPUTDOWN):
print 'setting pin' , pin , ' to in with pull down'
GPIO.setup(pin,GPIO.IN,pull_up_down=GPIO.PUD_DOWN)
try:
GPIO.add_event_detect(pin, GPIO.BOTH, callback=self.gpioBoth,bouncetime=50) # add rising edge detection on a channel
except:
pass
elif (self.pinUse[pin] == self.PINPUTNONE):
print 'setting pin' , pin , ' to in with pull down'
GPIO.setup(pin,GPIO.IN)
try:
GPIO.add_event_detect(pin, GPIO.BOTH, callback=self.gpioBoth,bouncetime=50) # add rising edge detection on a channel
except:
pass
elif (self.pinUse[pin] == self.PCOUNT):
if self.callbackInUse[pin] == False:
print 'setting pin' , pin , ' as counting pin'
GPIO.setup(pin,GPIO.IN)#,pull_up_down=GPIO.PUD_DOWN)#,pull_up_down=GPIO.PUD_DOWN)
try: # add event callback but use try block just in case its already set
if self.encoderCallback == 1:
#GPIO.add_event_detect(pin, GPIO.RISING, callback=self.my_callbackB)#,bouncetime=10) # add rising edge detection on a channel
self.callbackInUse[pin] = True
self.encoderCallback = 2
if self.debug:
print "callback B set for pin ", pin
if self.encoderCallback == 0:
#GPIO.add_event_detect(pin, GPIO.RISING, callback=self.my_callbackA)#,bouncetime=10) # add rising edge detection on a channel
self.callbackInUse[pin] = True
self.encoderCallback = 1
if self.debug:
print "callback A set for pin ", pin
except Exception,e:
print "Error on event detection setup on pin" ,pin
print str(e)
else:
print ("Callback already in use")
import ASUS.GPIO as GPIO
import unittest
import time
GPIO.setmode(GPIO.ASUS)
GPIO.setup(252, GPIO.OUT)
pwm = GPIO.PWM(252, 50)
pwm.start(100)
while True:
for i in range(0, 3):
for x in range(0, 101, 5):
pwm.ChangeDutyCycle(x)
time.sleep(0.1)
for x in range(100, -1, -5):
pwm.ChangeDutyCycle(x)
time.sleep(0.1)
import serial
import ASUS.GPIO as GPIO
import time
ser = serial.Serial("/dev/ttyS1", 9600, timeout=1)
GPIO.setwarnings(False)
GPIO.setmode(GPIO.ASUS)
GPIO.setup(224, GPIO.OUT)
GPIO.output(224, GPIO.LOW)
data_uart = [0, 0, 0, 0, 0, 0]
uart_coutner = 0
try:
while 1:
response = ser.read()
response = int.from_bytes(response, byteorder='big', signed=False)
if (response == 240 and uart_coutner == 0):
uart_coutner = 1
data_uart[0] = response
elif (uart_coutner > 0):
data_uart[uart_coutner] = response
uart_coutner = uart_coutner + 1
if (uart_coutner == 6):
if (data_uart[1] == 1):
print("send")
GPIO.output(224, GPIO.HIGH)
frame = bytearray()
frame.append(0xA2)
frame.append(0x0B)
frame.append(0x02)
import serial # serial kütüphanesi eklendi
GPIO.setwarnings(False) # GPIO ile ilgili hatalar göz ardı edildi
GPIO.setmode(
GPIO.ASUS
) # GPIO modu GPIO.ASUS a göre seçildi (ona göre pin numaraları belirlenecek)
mz80_1 = 252 # 1. MZ80 (Dijital kızılötesi) sensörü için giriş portu belirlendi
mz80_2 = 253 # 2. MZ80 (Dijital kızılötesi) sensörü için giriş portu belirlendi
IR_analog_warn = 257 # Kızılötesi analog sensörlerin uyarı çıkışı
Ultrason_warn = 256 # Ultrasonik sensörlerin uyarı çıkışı
IR_digital_warn = 254 # Kızılötesi dijital sensörlerin uyarı çıkışı
GPIO.setup(
mz80_1,
GPIO.IN) # 1. MZ80 sensörünün çıkışı GPIO'da giriş olarak tanımlandı
GPIO.setup(
mz80_2,
GPIO.IN) # 2. MZ80 sensörünün çıkışı GPIO'da giriş olarak tanımlandı
GPIO.setup(
IR_analog_warn,
GPIO.OUT) # Kızılötesi analog sensörlerin uyarı çıkışı GPIO'da tanımlandı
GPIO.setup(
IR_digital_warn,
GPIO.OUT) # Kızılötesi dijital sensörlerin uyarı çıkışı GPIO'da tanımlandı
GPIO.setup(Ultrason_warn,
GPIO.OUT) # Ultrasonik sensörlerin uyarı çıkışı GPIO'da tanımlandı
GPIO.output(
import time import datetime # config DHT11_PIN = 5 LED_G_PIN = 8 LED_Y_PIN = 10 LED_R_PIN = 12 DETECT_INTERVAL = 5 # initialize GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) GPIO.cleanup() GPIO.setup(LED_G_PIN, GPIO.OUT) GPIO.setup(LED_Y_PIN, GPIO.OUT) GPIO.setup(LED_R_PIN, GPIO.OUT) def resetled(): GPIO.output(LED_G_PIN, GPIO.LOW) GPIO.output(LED_Y_PIN, GPIO.LOW) GPIO.output(LED_R_PIN, GPIO.LOW) resetled() # read dht11 data instance = dht11.DHT11(pin=DHT11_PIN)
#GPIO.setmode(GPIO.BOARD)
GPIO.setmode(GPIO.ASUS)
# Pin en ASUS BOARD
# pin 3
powerPin = 253
# pin 2
resetPin = 252
# pin 8
ledPin = 161
# pin 7
powerenPin = 17
hold = 1
GPIO.setup(ledPin, GPIO.OUT)
GPIO.setup(powerenPin, GPIO.OUT)
GPIO.setup(powerPin, GPIO.IN)
GPIO.output(ledPin, GPIO.HIGH)
GPIO.output(powerenPin, GPIO.HIGH)
# Funciones
def ledon():
# Encender led
GPIO.output(ledPin, GPIO.HIGH)
def ledoff():
# Apagar led
GPIO.output(ledPin, GPIO.LOW)
