def ignite(debuglevel):
threshold=340 #150mv threshold
threshigh=1024 #450mv upper threshold
ADC.setup()
ADC.read_raw("AIN4") #Flush this
baseline=ADC.read_raw("AIN4")
GPIO.setup("P8_14",GPIO.OUT) #This pin fires the ignition
GPIO.output("P8_14",GPIO.LOW)
PWM.start("P8_19",15,49500) #works best with an 11 turn primary
time.sleep(0.05) #50ms Settling time for the analogue front end
ADC.read_raw("AIN4")
selftest=ADC.read_raw("AIN4")
if selftest>threshold and selftest<threshigh and baseline<128:
GPIO.output("P8_14",GPIO.HIGH)
if debuglevel:
print "Igniting"
time.sleep(2) #plenty of time for ignition
failure=0
else:
if debuglevel:
print "Failed"
failure=1
GPIO.output("P8_14",GPIO.LOW)
PWM.stop("P8_19")
PWM.cleanup()
#Debug output
if debuglevel:
print baseline
print selftest
return {'failure':failure, 'baseline':baseline ,'selftest':selftest }
def shutdown(self):
""" stop motors and PWM signals """
print 'Signals Stopped'
PWM.stop(Motor.motor1) # stop the motor
PWM.stop(Motor.motor2)
PWM.stop(Motor.motor3)
PWM.cleanup() # stop all pwm
def Speaker_enable(self, status=True):
if status:
PWM.start(self.channel, 0)
else:
PWM.set_duty_cycle(self.channel, 0)
PWM.stop(self.channel)
PWM.cleanup()
def motor_setup(dir1_pin, dir2_pin, pwm_pin):
"""
Sets up context for operating a motor.
"""
# Initialize GPIO pins
GPIO.setup(dir1_pin, GPIO.OUT)
GPIO.setup(dir2_pin, GPIO.OUT)
# Initialize PWM pins: PWM.start(channel, duty, freq=2000, polarity=0)
PWM.start(pwm_pin, 0)
def run_motor(speed):
if speed > 100:
speed = 100
elif speed < -100:
speed = -100
if speed > 0:
GPIO.output(dir1_pin, GPIO.LOW)
GPIO.output(dir2_pin, GPIO.HIGH)
PWM.set_duty_cycle(pwm_pin, abs(speed))
elif speed < 0:
GPIO.output(dir1_pin, GPIO.HIGH)
GPIO.output(dir2_pin, GPIO.LOW)
PWM.set_duty_cycle(pwm_pin, abs(speed))
else:
GPIO.output(dir1_pin, GPIO.LOW)
GPIO.output(dir2_pin, GPIO.LOW)
PWM.set_duty_cycle(pwm_pin, 0)
yield run_motor
GPIO.cleanup()
PWM.cleanup()
def shutDown(self):
#shutdown PWM cleanly
PWM.stop(pan_pin)
PWM.stop(tilt_pin)
PWM.cleanup()
#shutdown cherrypy cleanly
cherrypy.engine.exit()
def shutdown(self):
#print ('System Shutdown')
#Kill both motor and signals
PWM.stop(Motor.motor1)
PWM.stop(Motor.motor2)
PWM.stop(Motor.motor3)
PWM.cleanup()
def launchBaby(distance):
# GPIO.wait_for_edge(startButton, GPIO.RISING) #no turning back
# GPIO.cleanup()
RPM = 586.5670268*math.sqrt(distance)
print RPM
dutyCycle = (0.0002114464417*RPM+0.03844561492)*100
dutyCycle = dutyCycle*3.5*2
dutyCycle = int(round(dutyCycle))
if dutyCycle > 100:
dutyCycle = 99
print dutyCycle
if dutyCycle <= 60:
PWM.start(motorPin, dutyCycle, 20000)
else:
# thing = dutyCycle-60
remainder = dutyCycle%10
tens = dutyCycle//10
# x = []
# for i in range(0,tens):
# x.append(10)
for i in range(0,dutyCycle-60,10):
PWM.start(motorPin,60+i,20000)
time.sleep(1)
finalDutyCycle = 60+i
PWM.start(motorPin, finalDutyCycle+remainder, 20000)
# PWM.start(motorPin, dutyCycle, 20000)
time.sleep(5)
PWM.start(loaderPin, 4, 60)
time.sleep(3.5)
PWM.stop(motorPin)
PWM.stop(loaderPin)
PWM.cleanup()
def listener():
rospy.init_node('listener', anonymous=True)
rospy.Subscriber("turn_rate", Float32, callback)
rospy.spin()
print ("test")
PWM.stop(pwm_pin)
PWM.cleanup()
def finish():
for pin in motor_pins:
PWM.stop(pin)
PWM.cleanup()
sys.exit(0)
def listener():
rospy.init_node('listener', anonymous=True)
rospy.Subscriber("turn_rate", Float32, callback)
rospy.spin()
print("test")
PWM.stop(servo_pin)
PWM.cleanup()
def test_start_pwm_with_polarity_one(self):
PWM.cleanup()
PWM.start("P9_14", 0, 2000, 1)
pwm_dir = get_pwm_dir()
assert os.path.exists(pwm_dir)
if kernel >= '4.1.0':
duty = open(pwm_dir + '/duty_cycle').read()
else:
duty = open(pwm_dir + '/duty').read()
period = open(pwm_dir + '/period').read()
polarity = open(pwm_dir + '/polarity').read()
assert int(duty) == 0
assert int(period) == 500000
# TEMPORARY FIX: disable polarity check
# due to issue in 4.9.x+ kernels
# refer to issue #170:
# https://github.com/adafruit/adafruit-beaglebone-io-python/issues/170
# and commit c35e4cb from pull request #173:
# "source/c_pwm.c: disable pwm_set_polarity (broken in v4.9.x/v4.14.x)"
# https://github.com/adafruit/adafruit-beaglebone-io-python/pull/173/commits/c35e4cb98a1f14c85aca7259132bcc97e93d78f8
#if kernel >= '4.1.0':
# assert polarity == "inversed\n"
#else:
# assert int(polarity) == 1
PWM.cleanup()
def cleanup(self):
"""Stop pwm services."""
print(
'stop PWM duty cycle 0 Prportional Valve ', self.name)
PWM.stop(self.pwm_pin)
PWM.cleanup()
async def handle_alarm():
while True:
# Wait for one of the two events
h = asyncio.ensure_future(smoke_event.wait())
b = asyncio.ensure_future(button_event.wait())
done, pending = await asyncio.wait({h, b},
return_when=asyncio.FIRST_COMPLETED)
# Cancel the other waiting task
for task in pending:
task.cancel()
# If there is smoke, set the alarm
smoke_event.clear()
async with smoke_lock:
smoke = is_smoke
if smoke:
print("Fire!")
PWM.start("P8_13", 25, 1000)
else:
# Otherwise, check to see if the button has been pressed,
# and if so clear the alarm
if button_event.is_set():
print("Reset!")
PWM.stop("P8_13")
PWM.cleanup()
button_event.clear()
def shutItDown():
#turn pump off
PWM.start(SERVO_PIN, MINDUT, SERVO_FREQUENCY, 0)
PWM.stop(SERVO_PIN)
GPIO.output(OUT_PIN, GPIO.LOW)
GPIO.cleanup()
PWM.cleanup()
def avoid_():
def readfile_coordinates():
global line
f = open('temp.txt', 'r')
temp = f.readlines(line)
f.close()
latitude = temp.split("")[0]
longitude = temp.split("")[1]
while True:
try:
while True:
readfile_coordinates(line)
scheduler()
arbiter()
except KeyboardInterrupt: # pressing ctrl C stops operation and cleans up
PWM.stop(left_wheel)
PWM.stop(right_wheel)
PWM.cleanup()
GPIO.cleanup()
ADC.cleanup()
def exit_signal(self, sig, frame):
print('You pressed Ctrl+C!')
PWM.stop("P9_21")
PWM.stop("P9_22")
PWM.stop("P9_16")
PWM.cleanup()
sys.exit(0)
def exit_gracefully(signum, frame):
global pan_servo_pin
global tilt_servo_pin
pwm.stop(pan_servo_pin)
pwm.stop(tilt_servo_pin)
pwm.cleanup()
def motor_setup(dir1_pin, dir2_pin, pwm_pin):
"""
Sets up context for operating a motor.
"""
# Initialize GPIO pins
GPIO.setup(dir1_pin, GPIO.OUT)
GPIO.setup(dir2_pin, GPIO.OUT)
# Initialize PWM pins: PWM.start(channel, duty, freq=2000, polarity=0)
PWM.start(pwm_pin, 0)
def run_motor(speed):
if speed > 100:
speed = 100
elif speed < -100:
speed = -100
if speed > 0:
GPIO.output(dir1_pin, GPIO.LOW)
GPIO.output(dir2_pin, GPIO.HIGH)
PWM.set_duty_cycle(pwm_pin, abs(speed))
elif speed < 0:
GPIO.output(dir1_pin, GPIO.HIGH)
GPIO.output(dir2_pin, GPIO.LOW)
PWM.set_duty_cycle(pwm_pin, abs(speed))
else:
GPIO.output(dir1_pin, GPIO.LOW)
GPIO.output(dir2_pin, GPIO.LOW)
PWM.set_duty_cycle(pwm_pin, 0)
yield run_motor
GPIO.cleanup()
PWM.cleanup()
def zelda_Sun_Song():
"""Plays the Sun's Song from The Legend of Zelda."""
play_note(NOTE_A4, 0.15)
play_note(NOTE_F4, 0.15)
play_note(NOTE_D5, 0.3)
PWM.stop(piezo_pin)
time.sleep(0.3)
play_note(NOTE_A4, 0.15)
play_note(NOTE_F4, 0.15)
play_note(NOTE_D5, 0.3)
PWM.stop(piezo_pin)
time.sleep(0.3)
play_note(NOTE_G4, 0.1)
play_note(NOTE_A4, 0.1)
play_note(NOTE_B4, 0.1)
play_note(NOTE_C5, 0.1)
play_note(NOTE_D5, 0.1)
play_note(NOTE_E5, 0.1)
play_note(NOTE_F5, 0.1)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
play_note(NOTE_G5, 0.125)
PWM.stop(piezo_pin)
PWM.cleanup()
def SetAngle(self,input):
"""
Recieve an input from 0 to 100 and sets the position following this input
"""
PWM.set_duty_cycle(self.__pin, input)
PWM.stop(self.__pin)
PWM.cleanup()
def __init__(self,pin):
"""
When started, the library puts the servo at -90°
"""
self.__pin=pin
PWM.start(self.__pin, 0) #PWM set at 0% so the servo goes to -90° (50% = 0° and 100%= 90°)
PWM.stop(self.__pin)#Close the PWM connection
PWM.cleanup()
def triggerStepper(self):
time.sleep(0.5)
PWM.start("P9_16", 25, 100, 1)
time.sleep(2)
PWM.set_frequency("P9_16", 250)
time.sleep(90)
PWM.stop("P9_16")
PWM.cleanup()
def testp:
while 1:
PWM.start("P8_19",15,49500)
time.sleep(2)
PWM.stop("P8_19")
time.sleep(0.15)
PWM.cleanup()
time.sleep(0.1)
def cleanup(cls):
PWM.stop(PWMA)
PWM.stop(PWMB)
PWM.cleanup()
GPIO.cleanup()
GPIO.output(STBY, GPIO.LOW)
def cleanup(cls):
PWM.stop(PWMA)
PWM.stop(PWMB)
PWM.cleanup()
GPIO.cleanup()
GPIO.output(STBY, GPIO.LOW)
def stop(self):
print "[Collector.run] Collector stopped"
self.is_running = False
for c in self.components:
c.stop()
PWM.cleanup()
def cleanup(self):
print "Clean up"
self.setPWM([0, 0])
self.robotSocket.close()
GPIO.cleanup()
PWM.cleanup()
# tictocPrint()
self.writeBufferToFile()
def cleanup():
"""Cleanup the hardware components. Returns 'dead' if cleaned up"""
# Set Display to something fun to show program is complete
PWM.cleanup()
HT16K33.display_set_digit(0, 13) # "D"
HT16K33.display_set_digit(1, 14) # "E"
HT16K33.display_set_digit(2, 10) # "A"
HT16K33.display_set_digit(3, 13) # "D"
def clear(self):
"""Cleans and disables the PMW channel"""
PWM.stop(self.piezzo)
PWM.cleanup()
# End def
# End class
def shutdown(self):
self.stopAllMotors()
self.backLeftMotor.disable()
self.frontLeftMotor.disable()
self.backRightMotor.disable()
self.frontRightMotor.disable()
PWM.cleanup()
GPIO.cleanup()
return
def zelda_Serenade_of_Water():
"""Plays the Serenade of Water from The Legend of Zelda."""
play_note(NOTE_D5, 0.5)
play_note(NOTE_F5, 0.5)
play_note(NOTE_A5, 0.5)
play_note(NOTE_A5, 0.5)
play_note(NOTE_B5, 1.0)
PWM.stop(piezo_pin)
PWM.cleanup()
def readCtrlLoop():
PWM.start(PWM_VENTILO, 0)
try:
while True:
val = ADC.read(AIN) # read_raw()
PWM.set_duty_cycle(PWM_VENTILO, val * 100)
time.sleep(.001)
except KeyboardInterrupt:
print('Ok, end')
PWM.cleanup()
def cleanup(signum, frame): global exitStatus print "\nRollE, signing out." exitStatus = True sleep(0.2) GPIO.cleanup() PWM.cleanup() exit()
def showTacky():
GPIO.setup(IN_TACKY, GPIO.IN)
PWM.start(PWM_VENTILO, 100)
try:
while True:
print(GPIO.input(IN_TACKY))
time.sleep(.5)
except KeyboardInterrupt:
print('Ok, end')
PWM.cleanup()
def readCtrlLoop():
PWM.start(PWM_VENTILO, 0)
try:
while True:
val = ADC.read(AIN) # read_raw()
PWM.set_duty_cycle(PWM_VENTILO, val*100)
time.sleep(.001)
except KeyboardInterrupt:
print('Ok, end')
PWM.cleanup()
def showTacky():
GPIO.setup(IN_TACKY, GPIO.IN)
PWM.start(PWM_VENTILO, 100)
try:
while True:
print(GPIO.input(IN_TACKY))
time.sleep(.5)
except KeyboardInterrupt:
print('Ok, end')
PWM.cleanup()
def zelda_Requiem_of_Spirit():
"""Plays the Requiem of Spirit from The Legend of Zelda."""
play_note(NOTE_D5, 0.75)
play_note(NOTE_F5, 0.375)
play_note(NOTE_D5, 0.375)
play_note(NOTE_A5, 0.75)
play_note(NOTE_F5, 0.75)
play_note(NOTE_D5, 1.5)
PWM.stop(piezo_pin)
PWM.cleanup()
def zelda_Minuet_of_Forest():
"""Plays the Minuet of Forest from The Legend of Zelda."""
play_note(NOTE_D5, 0.225)
play_note(NOTE_D6, 0.225)
play_note(NOTE_B5, 0.9)
play_note(NOTE_A5, 0.225)
play_note(NOTE_B5, 0.225)
play_note(NOTE_A5, 0.9)
PWM.stop(piezo_pin)
PWM.cleanup()
def zelda_Zelda_Lullaby():
"""Plays Zelda's Lullaby from The Legend of Zelda."""
play_note(NOTE_B4, 1.2)
play_note(NOTE_D5, 0.6)
play_note(NOTE_A4, 1.8)
play_note(NOTE_B4, 1.2)
play_note(NOTE_D5, 0.6)
play_note(NOTE_A4, 1.8)
PWM.stop(piezo_pin)
PWM.cleanup()
def callback(data):
rospy.loginfo(rospy.get_caller_id() + "I heard %s", data)
angle = data.angular.z
if angle == 42:
PWM.stop(servo_pin)
PWM.cleanup()
return
angle_f = float(angle)
duty = ((-angle_f/2 + 0.5) * duty_span + duty_min)
PWM.set_duty_cycle(servo_pin, duty)
def shutdown(sig, frame):
if 'bbb_test' in build_params:
GPIO.output(pin_map["enable"], GPIO.LOW)
PWM.stop(pin_map["pwm"])
PWM.cleanup()
GPIO.cleanup()
curses.nocbreak()
curses.echo()
curses.endwin()
sys.exit(0)
def cleanup(self):
sys.stdout.write("Shutting down...")
self.setPWM([0, 0])
self.robotSocket.close()
GPIO.cleanup()
PWM.cleanup()
if DEBUG:
# tictocPrint()
self.writeBuffersToFile()
sys.stdout.write("Done\n")
def listener():
rospy.init_node('joint_target_listener', anonymous=True)
rospy.Subscriber("servo_angle_target", JointTarget, sendArmCommand)
rospy.spin()
#shutdown channels and cleanup
PWM.stop("P9_14")
PWM.stop("P9_16")
PWM.cleanup()
def zelda_Preulde_of_Light():
"""Plays the Prelude of Light from The Legend of Zelda."""
play_note(NOTE_D5, 0.25)
play_note(NOTE_A4, 0.75)
play_note(NOTE_D5, 0.25)
play_note(NOTE_A4, 0.25)
play_note(NOTE_B4, 0.25)
play_note(NOTE_D5, 1.25)
PWM.stop(piezo_pin)
PWM.cleanup()
def test_multiple_PWM(self):
try:
PWM.start("P9_16")
PWM.start("P9_14")
PWM.start("P8_19")
PWM.set_duty_cycle("P9_16", 0.1)
PWM.set_duty_cycle("P9_16", 0)
PWM.set_duty_cycle("P9_14", 0.1)
PWM.set_duty_cycle("P9_14", 0)
finally:
PWM.cleanup()
def cleanup(self):
""" Clean up before shutting down. """
sys.stdout.write("Shutting down...")
self.set_pwm([0, 0])
self.robotSocket.close()
GPIO.cleanup()
PWM.cleanup()
if DEBUG:
pass
# tictocPrint()
# self.writeBuffersToFile()
sys.stdout.write("Done\n")
def servo(whichDevice, where):
# This function activates the servo motor
# Import important libraries
import Adafruit_BBIO.PWM as PWM
import time
import os
from animals import animal
from random import randint
os.system('clear')
# Time at which the servo starts to work
cur_time = time.time()
# Set pin
if whichDevice == 1:
servo_pin = "P8_13"
elif whichDevice == 2:
servo_pin = "P9_14"
# print whichDevice
# print servo_pin
# Set duty cycle parameters
duty_min = 3
duty_max = 14.5
duty_span = duty_max - duty_min
# Set duty cycle and frequency to pin
PWM.start(servo_pin, (100-duty_min), 200.0)
# Give direction/angle and a random animal to display
if where == 'open':
angle = 90
print('\n\nOpening device!\n\n')
animal_out = randint(1, 6)
animal(animal_out)
else:
angle = 0
print('\n\nClosing device...\n\n')
animal_out = randint(1, 6)
animal(animal_out)
# Activate servo for 3 seconds
while True:
angle_f = float(angle)
duty = 100 - ((angle_f / 180) * duty_span + duty_min)
PWM.set_duty_cycle(servo_pin, duty)
if time.time() > (cur_time + 3.1):
PWM.stop(servo_pin)
PWM.cleanup()
break
def simple_ignite(debuglevel):
GPIO.setup("P8_14",GPIO.OUT) #This pin fires the ignition
GPIO.output("P8_14",GPIO.LOW)
PWM.start("P8_19",15,49500) #works best with an 11 turn primary
GPIO.output("P8_14",GPIO.HIGH)
if debuglevel:
print "Igniting"
time.sleep(2) #plenty of time for ignition
GPIO.output("P8_14",GPIO.LOW)
PWM.stop("P8_19")
PWM.cleanup()
failure=0
return {'failure':failure}
def listener():
rospy.init_node('listener', anonymous=False)
PWM.start(servo_pin,93, 60.0,1)
rospy.Subscriber('angle', Float32, callback)
# spin() simply keeps python from exiting until this node is stopped
rospy.spin()
PWM.stop(servo_pin)
PWM.cleanup()
def test_start_pwm_ecap0(self):
print("test_start_pwm_ecap0\n");
PWM.cleanup()
PWM.start("P9_42", 0)
pwm_dir = get_pwm_dir()
assert os.path.exists(pwm_dir)
if kernel >= '4.1.0':
duty = open(pwm_dir + '/duty_cycle').read()
else:
duty = open(pwm_dir + '/duty').read()
period = open(pwm_dir + '/period').read()
assert int(duty) == 0
assert int(period) == 500000
PWM.cleanup()
def __init__(self, blower_pin):
"""
Initializes the controller for a blower and sets the blower speed to 0
:param blower_pin: The BBB PWM to use, e.g. P9_14
:type blower_pin: str
"""
self._blower_pin = blower_pin
self._speed = 0
self._low_speed_handle = None
PWM.start(blower_pin, 0)
PWM.stop(blower_pin)
PWM.cleanup()
def test_start_pwm(self):
PWM.start("P9_14", 0)
files = os.listdir('/sys/devices')
ocp = '/sys/devices/'+[s for s in files if s.startswith('ocp')][0]
files = os.listdir(ocp)
pwm_test = ocp+'/'+[s for s in files if s.startswith('pwm_test_P9_14')][0]
assert os.path.exists(pwm_test)
duty = open(pwm_test + '/duty').read()
period = open(pwm_test + '/period').read()
assert int(duty) == 0
assert int(period) == 500000
PWM.cleanup()
def main():
#print 'Enter source co:ordinates \nEnter Xi:'
#Xi = input()
Xi = 0.0
#print 'Enter Yi:'
#Yi = input()
Yi = 0.0
#print 'Enter Thetai:'
#Thetai = input()
Thetai = 0.0
print 'Intital steering orientation taken to be zero'
psi = 0.0
intl = [Xi,Yi,Thetai]
#print 'Enter destination co:ordinates \nEnter Xf:'
#Xf = input()
Xf = 7.0
#print 'Enter Yf:'
#Yf = input()
Yf = 7.0
#print 'Enter Thetaf:'
#Thetaf = input()
Thetaf = 3.14
dsrd = [Xf,Yf,Thetaf]
print 'Creating trajecory\n'
conpoints = path(intl,dsrd)
print 'Auto Drive engaged:::\n'
prev = intl
for mov in range(1,np.size(conpoints,1)):
print '\nCon.point :',conpoints[0,mov],' : ',conpoints[1,mov]
jntvar = invkin2(prev,[conpoints[0,mov],conpoints[1,mov]])
attnd = fwdkin(prev,jntvar)
print 'Attained :',attnd[0],' : ',attnd[1]
srvdrv(jntvar[1])
motodrv(jntvar[0])
prev = attnd
PWM.cleanup()
return
def exit_gracefully(signum, frame):
global pan_servo_pin
global tilt_servo_pin
global original_sigterm
global original_sigabrt
global original_sigint
signal.signal(signal.SIGTERM, original_sigterm)
signal.signal(signal.SIGABRT, original_sigabrt)
signal.signal(signal.SIGINT, original_sigint)
pwm.stop(pan_servo_pin)
pwm.stop(tilt_servo_pin)
pwm.cleanup()
signal.signal(signal.SIGTERM, exit_gracefully)
signal.signal(signal.SIGABRT, exit_gracefully)
signal.signal(signal.SIGINT, exit_gracefully)
def MotorLoop():
global PWM_frequency
PWM.cleanup()
PWM.start("P8_13",0,PWM_frequency,0)
PWM.start("P9_14",0,PWM_frequency,0)
PWM.start("P9_21",0,PWM_frequency,0)
PWM.start("P9_42",0,PWM_frequency,0)
while True:
global Angle1
global Angle2
global Angle3
global Angle4
global Angle5
global Angle6
PWM.set_duty_cycle("P8_13",Angle1)
PWM.set_duty_cycle("P9_14",Angle2)
PWM.set_duty_cycle("P9_21",Angle3)
PWM.set_duty_cycle("P9_42",Angle4)
def pwmcontrol ():
global input_percentage
global changed
global kill
changed = False
PWM.cleanup()
start_freq = 300.0
start_duty = 0.0
period = 1.0 / start_freq
minimum = 100.0 * (.001 / period)
maximum = 100.0 * (.002 / period)
print "Frequency:" + str(start_freq)
print "Period:" + str(period)
print "Minimum:" + str(minimum)
print "Maximum:" + str(maximum)
PWM.start("P9_14",start_duty,start_freq)
PWM.start("P8_13",start_duty,start_freq)
PWM.start("P9_21",start_duty,start_freq)
PWM.start("P9_42",start_duty,start_freq)
print "Start"
while input_percentage >= 0:
if changed == True:
changed = False
duty_cycle = ((0.01*input_percentage) * (maximum - minimum)) + minimum
print "Duty Cycle: " + str(duty_cycle)
PWM.set_duty_cycle("P8_13",duty_cycle)
PWM.set_duty_cycle("P9_14",duty_cycle)
PWM.set_duty_cycle("P9_21",duty_cycle)
PWM.set_duty_cycle("P9_42",duty_cycle)
else:
time.sleep(0.1)
PWM.stop("P9_14")
PWM.stop("P8_13")
PWM.stop("P9_21")
PWM.stop("P9_42")
PWM.cleanup()
quit()
return
def test_start_pwm_with_polarity_one(self):
PWM.cleanup()
PWM.start("P9_14", 0, 2000, 1)
pwm_dir = get_pwm_dir()
assert os.path.exists(pwm_dir)
if kernel >= '4.1.0':
duty = open(pwm_dir + '/duty_cycle').read()
else:
duty = open(pwm_dir + '/duty').read()
period = open(pwm_dir + '/period').read()
polarity = open(pwm_dir + '/polarity').read()
assert int(duty) == 0
assert int(period) == 500000
if kernel >= '4.1.0':
assert polarity == "inversed\n"
else:
assert int(polarity) == 1
PWM.cleanup()
def _init():
global _cathode, _anodes
try:
_cathode = _PWM('P9_22')
_anodes = (_PWM('P9_16'), _PWM('P8_19'), _PWM('P9_14'))
_cathode.duty = 1.0
except:
pwm.cleanup()
raise
try:
_thread.daemon = True
_thread.start()
except:
_cathode.duty = 0.0
pwm.cleanup()
raise
try:
atexit.register(_exit)
except:
_exit()
raise
