def turn_on_pwm(pin): PWM.start(pin, 50) PWM.set_duty_cycle(pin, 25.5) PWM.set_frequency(pin, 10) print sys._getframe().f_code.co_name, print(' '+pin) raw_input('press a key to continue')
def play_tone(self): """ This method will play a tone using PWM. """ # clear out any residual problem strings self.last_problem = '5-0\n' pin = self.validate_pin(self.pwm_pins) if pin == 99: self.last_problem = '5-1\n' return # get pin information index = self.pwm_pins.index(pin) pin_entry = self.pwm_pin_states[index] if not pin_entry['enabled']: self.last_problem = '5-2\n' return frequency = int(self.payload['frequency']) duration = float(self.payload['duration']) / 1000 PWM.set_duty_cycle(pin, 50) PWM.set_frequency(pin, frequency) if duration == 0: return time.sleep(duration) PWM.set_duty_cycle(pin, 0.0)
def jouer_note(self,note, duty): PWM.set_frequency("P9_14", note) PWM.set_duty_cycle("P9_14", duty) time.sleep(0.5) PWM.set_duty_cycle("P9_14", 0) time.sleep(0.3) PWM.set_duty_cycle("P9_14", duty)
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 setDutyFrequency(self, dutyFrequency): """Set device duty frequency.""" if (dutyFrequency in self._settings['dutyFrequencies']): self._dutyFrequency = dutyFrequency PWM.set_frequency(self._pin, int( self._dutyFrequency[:-3])) # Set the duty frequency self._update = True # Raise update flag else: raise ValueError( 'duty frequency {} is not allowed'.format(dutyFrequency))
def spin_left(duty): PWM.set_duty_cycle(right, duty) PWM.set_duty_cycle(left, duty) PWM.set_frequency(right, 200) PWM.set_frequency(left, 200) GPIO.output("P8_14", GPIO.LOW) GPIO.output("P8_15", GPIO.HIGH) GPIO.output("P8_16", GPIO.HIGH) GPIO.output("P8_17", GPIO.LOW) return None
def sound_game(self, audio_frequency): """ Control the I/O of the sound """ PWM.start(self.piezzo, self.init_duty) #Starts with 66% of 5V, 3.3V supply to piezzo buzzer # Play the sound for frequency in audio_frequency: PWM.set_frequency(self.piezzo, frequency) time.sleep(self.sound_delay) # Stop the sound PWM.stop(self.piezzo)
def forward(): PWM.set_duty_cycle(right, 50) PWM.set_duty_cycle(left, 50) PWM.set_frequency(right, 75) PWM.set_frequency(left, 75) GPIO.output("P8_14", GPIO.LOW) GPIO.output("P8_15", GPIO.HIGH) GPIO.output("P8_16", GPIO.LOW) GPIO.output("P8_17", GPIO.HIGH) return None
def __speaker(self): if self.SPEAKER: return self.SPEAKER = True PWM.start(self.SPEAKER_PWM, 50, 3000) for dir in [-1,2]: for x in range(3,20): PWM.set_frequency(self.SPEAKER_PWM, 3000 + (dir * x * 100)) sleep(0.05) PWM.stop(self.SPEAKER_PWM) self.SPEAKER = False return
def setup_io_init(): logger.info("Initializing IO") PWM.start(PUMP, 0) PWM.set_frequency(PUMP, 1000) water_pump(0) GPIO.setup(HEATER,GPIO.OUT) GPIO.setup(LAMP_1,GPIO.OUT) GPIO.setup(LAMP_2,GPIO.OUT) lamp(False, LAMP_1) lamp(False, LAMP_2) heater(False) ADC.setup()
def __speaker(self): if self.SPEAKER: return self.SPEAKER = True PWM.start(self.SPEAKER_PWM, 50, 3000) for dir in [-1, 2]: for x in range(3, 20): PWM.set_frequency(self.SPEAKER_PWM, 3000 + (dir * x * 100)) sleep(0.05) PWM.stop(self.SPEAKER_PWM) self.SPEAKER = False return
def jouer_note(note, duty): PWM.set_frequency("P9_22", note) PWM.set_duty_cycle("P9_22", duty) time.sleep(0.5) PWM.set_duty_cycle("P9_22", 0) ''' lst = range(duty, -1, -1) for i in lst: PWM.set_duty_cycle("P9_22", i) time.sleep(0.008) ''' time.sleep(0.3) PWM.set_duty_cycle("P9_22", duty)
def takeInput(): global freq, dutyCycle, pin while(True): choice = int(raw_input("1.Change Frequency 2.Change DutyCycle 3.EXIT: ")) if choice == 1: freq = int(raw_input("Enter Frequency: ")) PWM.set_frequency(pin,freq) elif choice == 2: dutyCycle = int(raw_input("Enter Duty Cycle: ")) PWM.set_duty_cycle(pin,dutyCycle) elif choice == 3: break else: print "Invalid choice! Try Again"
def takeInput(): global freq, dutyCycle, pin while (True): choice = int( raw_input("1.Change Frequency 2.Change DutyCycle 3.EXIT: ")) if choice == 1: freq = int(raw_input("Enter Frequency: ")) PWM.set_frequency(pin, freq) elif choice == 2: dutyCycle = int(raw_input("Enter Duty Cycle: ")) PWM.set_duty_cycle(pin, dutyCycle) elif choice == 3: break else: print "Invalid choice! Try Again"
def timed_backward(t,duty): PWM.set_duty_cycle(right, duty) PWM.set_duty_cycle(left, duty) PWM.set_frequency(right, 75) PWM.set_frequency(left, 75) GPIO.output("P8_14", GPIO.HIGH) GPIO.output("P8_15", GPIO.LOW) GPIO.output("P8_16", GPIO.HIGH) GPIO.output("P8_17", GPIO.LOW) time.sleep(t) GPIO.output("P8_14", GPIO.LOW) GPIO.output("P8_16", GPIO.LOW) return None
def getPWMWriteFun(pin): if(pin[0]=='P'): PWM.start(pin, 0) PWM.set_frequency(pin, pwm_freq) return partial(PWM.set_duty_cycle,pin) elif(pin[0]=='I'): l=self.pinB.rsplit("_") if ( l[2] in i2cMap): i2c=i2cMap[l[2]] else: i2c=Adafruit_I2C(l[2],1 , False) i2c.write8(PCA9685_MODE1, 0x01) time.sleep(0.05) i2cMap[l[2]]=i2c return partial(setI2CDutyCycle, i2c, l[3]) elif (pin[0]=='D'): def funt(d): return d return partial(funt) else exit(-1)
def init_rover(): GPIO.setup(channel_1_dir, GPIO.OUT) GPIO.setup(channel_2_dir, GPIO.OUT) GPIO.setup(channel_3_dir, GPIO.OUT) GPIO.setup(channel_4_dir, GPIO.OUT) GPIO.output(channel_1_dir, GPIO.HIGH) GPIO.output(channel_2_dir, GPIO.HIGH) GPIO.output(channel_3_dir, GPIO.LOW) GPIO.output(channel_4_dir, GPIO.LOW) PWM.start(channel_1_pwm, 0.0) PWM.start(channel_2_pwm, 0.0) PWM.start(channel_3_pwm, 0.0) PWM.start(channel_4_pwm, 0.0) time.sleep(0.2) PWM.set_frequency(channel_1_pwm, 250) PWM.set_frequency(channel_2_pwm, 250) PWM.set_frequency(channel_3_pwm, 250) PWM.set_frequency(channel_4_pwm, 250)
def __init__(self,pin): PWM.start(pin, 50) PWM.set_frequency(pin, Fe) PWM.set_duty_cycle(pin,0)
pulley = 2 if h['pulley-A']: pulley = 0 if h['pulley-B']: pulley = 1 if h['pulley-C']: pulley = 2 if h['pulley-D']: pulley = 3 new_gear = h['gear-hi'] new_speed = h['speed'] new_direction = h['direction'] if (pulley != old_pulley) or (new_gear != old_gear) or ( new_speed != old_speed) or (new_direction != old_direction): old_gear = h['gear-hi'] old_pulley = pulley old_speed = new_speed old_direction = new_direction ratio = (ratios[pulley])[new_gear] h['vfd-hz'] = new_speed / 60 # Kludge. cannot set freq to 0, but at 1 HZ the VFD will stop speed = new_speed if speed == 0: speed = 1 PWM.set_frequency(pin_name, speed * ratio) h['vfd-direction'] = new_direction ^ (not new_gear) except KeyboardInterrupt: PWM.stop(pin_name) PWM.cleanup() raise SystemExit
def test_pwm_frequency_invalid_value_negative(self): PWM.start("P9_14", 0) with pytest.raises(ValueError): PWM.set_frequency("P9_14", -1) PWM.cleanup()
def marche_imperiale(): #PWM.start("P9_22", 50) jouer_note(sol, 50) jouer_note(sol, 50) jouer_note(sol, 50) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", si) time.sleep(0.15) PWM.set_frequency("P9_22", sol) time.sleep(0.6) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", si) time.sleep(0.15) PWM.set_frequency("P9_22", sol) time.sleep(0.45) PWM.set_duty_cycle("P9_22", 0) time.sleep(0.6) jouer_note(re,50) jouer_note(re,50) jouer_note(re,50) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", si) time.sleep(0.15) PWM.set_frequency("P9_22", fad) time.sleep(0.6) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", si) time.sleep(0.15) jouer_note(sol,50) jouer_note(sol,50) PWM.set_duty_cycle("P9_22", 0)
def test_pwm_frequency_invalid_value_string(self): PWM.start("P9_14", 0) with pytest.raises(TypeError): PWM.set_frequency("P9_14", "11") PWM.cleanup()
def test_pwm_freq_non_setup_key(self): with pytest.raises(ValueError): PWM.set_frequency("P9_15", 100) PWM.cleanup()
def set_frequency(self, frequency): if not self.mock_hardware: PWM.set_frequency(self.pin, frequency) else: print("%s Setting Frequency to %f" % (self.pin, frequency))
PWMstarted = 1 countIDLE = 0 #open file to append file=open(filename,"a") #add first column date/time stamp file.write(pt) #add next columns with raw reading, and converted voltage file.write(",%f,%f\n" % (flow,totalflow)) file.close() #if MM/DD/YR changes, update filename #this translates to a new file every day ##!!!!header row is dropped from subsequent days filename = "{0}_{1}_{2}_FIXTURE-flow.csv".format(currentyear, currentmonth, currentday) elif stepf >= 60 and PWMstarted == 1: PWM.set_frequency(stepperSTEP, stepf) countIDLE = 0 #open file to append file=open(filename,"a") #add first column date/time stamp file.write(pt) #add next columns with raw reading, and converted voltage file.write(",%f,%f\n" % (flow,totalflow)) file.close() #if MM/DD/YR changes, update filename #this translates to a new file every day ##!!!!header row is dropped from subsequent days filename = "{0}_{1}_{2}_FIXTURE-flow.csv".format(currentyear, currentmonth, currentday) elif stepf < 60 and PWMstarted == 1: PWM.stop(stepperSTEP)
#!/usr/bin/env python3 # From: https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black/pwm # From: https://adafruit-beaglebone-io-python.readthedocs.io/en/latest/PWM.html import Adafruit_BBIO.PWM as PWM LED="P9_14" # PWM.start(channel, duty, freq=2000, polarity=0) PWM.start(LED, 50) # Optionally, you can set the frequency as well as the polarity from their defaults: PWM.start(LED, 50, 1, 1) # The valid values for duty are 0.0 to 100.0. The start method activate # pwm on that channel. There is no need to setup the channels with Adafruit_BBIO.PWM. # Once you've started, you can then set the duty cycle, or the frequency: PWM.set_duty_cycle(LED, 25.5) PWM.set_frequency(LED, 10) # You'll also want to either disable that specific channel, or cleanup all of them when you're done: # PWM.stop(LED) # PWM.cleanup()
def changePWMFreq(self, desiredFreq): #This function is used to change the frequency of the pwm signal pwm.set_frequency("P9_14", desiredFreq)
def setPWMFrequency(self,freq): PWM.set_frequency(pin_pwm,freq)
import Adafruit_BBIO.PWM as PWM myPWM = "P8_13" PWM.start(myPWM, 0, 1000) for i in range(0,5): V = input("What voltage would you like? ") DC = (V/3.365)*100 if DC > 100: DC=100 PWM.set_duty_cycle(myPWM, DC) PWM.set_frequency(myPWM, 100) PWM.stop(myPWM) PWM.cleanup()
def hymne_joie(): PWM.set_frequency("P9_22", mi) time.sleep(tempo) PWM.set_frequency("P9_22", mi) time.sleep(tempo) PWM.set_frequency("P9_22", fa) time.sleep(tempo) PWM.set_frequency("P9_22", sol) time.sleep(tempo) PWM.set_frequency("P9_22", sol) time.sleep(tempo) PWM.set_frequency("P9_22", fa) time.sleep(tempo) PWM.set_frequency("P9_22", mi) time.sleep(tempo) PWM.set_frequency("P9_22", re) time.sleep(tempo) PWM.set_frequency("P9_22", do) time.sleep(tempo) PWM.set_frequency("P9_22", do) time.sleep(tempo) PWM.set_frequency("P9_22", re) time.sleep(tempo) PWM.set_frequency("P9_22", mi) time.sleep(tempo) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", re) time.sleep(0.3) PWM.set_frequency("P9_22", re) time.sleep(0.6) time.sleep(3)
import Adafruit_BBIO.PWM as PWM #set polarity to 1 on start: #PWM.start("P9_14", 50, 2000, 1) #PWM.start(channel, duty, freq=2000, polarity=0) #duty values are valid 0 (off) to 100 (on) PWM.start("P9_14", 50) PWM.set_duty_cycle("P9_14", 25.5) PWM.set_frequency("P9_14", 10) PWM.stop("P9_14") PWM.cleanup()
signal = signal0 + signal1 + signal2 + signal3 + signal4 + signal5 + signal6 + signal7 + signal8 + signal9 + signal10 + signal11 + signal12 + signal13 GPIO.setup("P9_22", GPIO.OUT) def lecture_son(signal): for i in range(33984 / Fe): if signal[i] > 0: GPIO.output("P9_22", GPIO.HIGH) else: GPIO.output("P9_22", GPIO.LOW) time.sleep(1 / Fe) PWM.start("P9_22", 50) PWM.set_frequency("P9_22", Fe) tempo = 0.3 do = 523 #261 re = 587 #293 mi = 659 #329 fa = 698 #349 sol = 783 #391 la = 880 #440 si = 987 #493 if __name__ == "__main__": while True: ''' PWM.set_frequency("P9_22", mi) time.sleep(tempo)
def setSpeed(pin, speed=0.5): if pin and 0 <= speed <= 1: PWM.set_frequency(pin, 1000 / (1 + speed)) PWM.set_duty_cycle(pin, 0.7) #(0.7+speed)/(1+speed)) print("The speed is setted to %s" % speed)
dmx = EnttecUsbDmxProWidget.EnttecUsbDmxProWidget() dmx.setPort("/dev/ttyO2", 115200) dmx.connect() dmx.sendDMX([1,2,3,4]) # Continuously read and print packets while True: rx = dmx.getRecievedFrame() ResponseArray = rx['frame'] print(ResponseArray) try: if ResponseArray != []: if ((ResponseArray[0] == 1) and ((ResponseArray[1] < .15) and (ResponseArray[1] > -.15))): #Brake PWM.start("P9_14", 50, 1000, 1) PWM.set_duty_cycle("P9_14", 25.5) #Input A CHANGE ONCE JACK/RYAN GET HERE PWM.set_frequency("P9_14", 10) #Frequency A PWM.start("P9_15", 50, 1000, 1) PWM.set_duty_cycle("P9_15", 25.5) #Input B PWM.set_frequency("P9_15", 10) #Frequency B sleep(.02) PWM.stop("P9_14") #stops for a second PWM.stop("P9_15") #stops for a second if ((ResponseArray[0] == 1) and (ResponseArray[1] >= .25)): #Reverse PWM.start("P9_15", 50, 1000, 1) PWM.set_duty_cycle("P9_15", 25.5) #Input B PWM.set_frequency("P9_15", 10) sleep(.02) PWM.stop("P9_14") #stops for a second PWM.stop("P9_15") #stops for a second
#!/usr/bin/env python3 import Adafruit_BBIO.PWM as PWM #set polarity to 1 on start: #PWM.start("P9_14", 50, 2000, 1) #PWM.start(channel, duty, freq=2000, polarity=0) #duty values are valid 0 (off) to 100 (on) SERVO="P9_14" PWM.start(SERVO, 50) PWM.set_duty_cycle(SERVO, 25.5) PWM.set_frequency(SERVO, 10) PWM.stop(SERVO) PWM.cleanup()
def SetPWM(index, new_dc, new_freq): PWM.set_duty_cycle(colors[index], new_dc) PWM.set_frequency(colors[index], new_freq)
signal13=A*B*np.array([0]*31620+[1]*1700+[0]*(33984-31620-1700)) signal=signal0+signal1+signal2+signal3+signal4+signal5+signal6+signal7+signal8+signal9+signal10+signal11+signal12+signal13 GPIO.setup("P9_22", GPIO.OUT) def lecture_son(signal): for i in range(33984/Fe): if signal[i]>0: GPIO.output("P9_22", GPIO.HIGH) else: GPIO.output("P9_22", GPIO.LOW) time.sleep(1/Fe) PWM.start("P9_22", 50) PWM.set_frequency("P9_22", Fe) tempo=0.3 do=523#261 re=587#293 mi=659#329 fa=698#349 sol=783#391 la=880#440 si=987#493 if __name__ == "__main__": while True: ''' PWM.set_frequency("P9_22", mi)
import time import Adafruit_BBIO.GPIO as GPIO import Adafruit_BBIO.PWM as PWM import Adafruit_I2C as I2C import time PWM.start("P9_22", 50) sol=783 if __name__ == "__main__": while True: PWM.set_frequency("P9_22", sol) lst = range(100, -1, -1) for i in lst: print(i) PWM.set_duty_cycle("P9_22", i) time.sleep(0.005)
def setSpeed(self, rpm): if rpm != 0: PWM.set_frequency(self.stepPin, SteppingMode.getFrequency(rpm)) PWM.set_duty_cycle(self.stepPin, 50) else: PWM.set_duty_cycle(self.stepPin, 0)
########################################## try: while True: GPIO.output(my_led, GPIO.HIGH) time.sleep(0.5) GPIO.output(my_led, GPIO.LOW) time.sleep(0.5) print("\nenter new frequency in MHz: ") new_value = input() new_freq_Hz = 1000 try: new_freq_Hz = int(float(new_value) * 1000 * 1000) except ValueError as e: print("Exception: ", e) print("calculated frequency: \n" "{:}MHz (= {:}Hz)" "".format(new_freq_Hz / (1000 * 1000), new_freq_Hz)) PWM.set_frequency(my_pwm, new_freq_Hz) PWM.set_duty_cycle(my_pwm, 50) except KeyboardInterrupt: print("exit") finally: print("cleanup") GPIO.output(my_led, GPIO.LOW) GPIO.cleanup() PWM.stop(my_pwm) PWM.cleanup()
countIDLE = 0 #open file to append file = open(filename, "a") #add first column date/time stamp file.write(pt) #add next columns with raw reading, and converted voltage file.write(",%f,%f\n" % (flow, totalflow)) file.close() #if MM/DD/YR changes, update filename #this translates to a new file every day ##!!!!header row is dropped from subsequent days filename = "{0}_{1}_{2}_FIXTURE-flow.csv".format( currentyear, currentmonth, currentday) elif stepf >= 60 and PWMstarted == 1: PWM.set_frequency(stepperSTEP, stepf) countIDLE = 0 #open file to append file = open(filename, "a") #add first column date/time stamp file.write(pt) #add next columns with raw reading, and converted voltage file.write(",%f,%f\n" % (flow, totalflow)) file.close() #if MM/DD/YR changes, update filename #this translates to a new file every day ##!!!!header row is dropped from subsequent days filename = "{0}_{1}_{2}_FIXTURE-flow.csv".format( currentyear, currentmonth, currentday) elif stepf < 60 and PWMstarted == 1:
def marche_imperiale(self,pin): self.jouer_note(sol, 50) self.jouer_note(sol, 50) self.jouer_note(sol, 50) PWM.set_frequency(pin, mi) time.sleep(0.45) PWM.set_frequency(pin, si) time.sleep(0.15) PWM.set_frequency(pin, sol) time.sleep(0.6) PWM.set_frequency(pin, mi) time.sleep(0.45) PWM.set_frequency(pin, si) time.sleep(0.15) PWM.set_frequency(pin, sol) time.sleep(0.45) PWM.set_duty_cycle(pin, 0) time.sleep(0.6) self.jouer_note(re,50) self.jouer_note(re,50) self.jouer_note(re,50) PWM.set_frequency(pin, mi) time.sleep(0.45) PWM.set_frequency(pin, si) time.sleep(0.15) PWM.set_frequency(pin, fad) time.sleep(0.6) PWM.set_frequency(pin, mi) time.sleep(0.45) PWM.set_frequency(pin, si) time.sleep(0.15) self.jouer_note(sol,50) self.jouer_note(sol,50) PWM.set_duty_cycle(pin, 0)
dmx.connect() dmx.sendDMX([1, 2, 3, 4]) # Continuously read and print packets while True: rx = dmx.getRecievedFrame() ResponseArray = rx['frame'] print(ResponseArray) try: if ResponseArray != []: if ((ResponseArray[0] == 1) and ((ResponseArray[1] < .15) and (ResponseArray[1] > -.15))): #Brake PWM.start("P9_14", 50, 1000, 1) PWM.set_duty_cycle( "P9_14", 25.5) #Input A CHANGE ONCE JACK/RYAN GET HERE PWM.set_frequency("P9_14", 10) #Frequency A PWM.start("P9_15", 50, 1000, 1) PWM.set_duty_cycle("P9_15", 25.5) #Input B PWM.set_frequency("P9_15", 10) #Frequency B sleep(.02) PWM.stop("P9_14") #stops for a second PWM.stop("P9_15") #stops for a second if ((ResponseArray[0] == 1) and (ResponseArray[1] >= .25)): #Reverse PWM.start("P9_15", 50, 1000, 1) PWM.set_duty_cycle("P9_15", 25.5) #Input B PWM.set_frequency("P9_15", 10) sleep(.02) PWM.stop("P9_14") #stops for a second PWM.stop("P9_15") #stops for a second
def set(self, duty, freq=1000): PWM.set_duty_cycle(self.pin, duty) PWM.set_frequency(self.pin, freq)
adc_values = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] i2c_values = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] i2c = Adafruit_I2C(9) #communication with Teensy at address 9 #Motor DIR GPIO.setup("P8_26", GPIO.OUT) GPIO.setup("P8_14", GPIO.OUT) GPIO.setup("P8_15", GPIO.OUT) GPIO.setup("P8_16", GPIO.OUT) GPIO.setup("P8_17", GPIO.OUT) #Motor PWM PWM.start("P9_31", 0.0) PWM.set_frequency("P9_31", 1000.0) PWM.start("P9_14", 0.0) PWM.set_frequency("P9_14", 1000.0) PWM.start("P8_19", 0.0) PWM.set_frequency("P8_19", 1000.0) PWM.start("P9_42", 0.0) PWM.set_frequency("P9_42", 1000.0) PWM.start("P9_28", 0.0) PWM.set_frequency("P9_28", 1000.0) print "Handexos started" while True: ####################################################################### #######################################################################
omega = 2*pi*freq sampleRate = 133333.333333 samples = int(sampleRate/freq) pwms = [0 for _ in range(2000)] for i in range(2000): pwms[i]=0 #pwms[0] = (samples+1)*4 #print pwms[0] PWM.start("P9_14",50) for i in range(1,samples+1): if i < 2000: pwms[i] = 50+int(50*sin(omega*(i-1)/sampleRate)) print "Frequency="+str(freq)+"\n" freq=float(raw_input()) PWM.set_frequency("P9_14",freq) if freq < 67: print "Frequency: "+str(freq)+" is too low. Enter a number higher than 67\n" freq = 67 print "Frequency="+str(freq)+"\n" while True: if freq >=67: omega = 2*pi*freq; samples = int(sampleRate/freq); #pwms[0] = (samples+1)*4; for i in range (1,samples+1): if(i < 2000): pwms[i] = 50+int(50*sin(omega*(i-1)/sampleRate)); print pwms[i] PWM.set_duty_cycle("P9_14",pwms[i])
jouer_note(re,50) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", si) time.sleep(0.15) PWM.set_frequency("P9_22", fad) time.sleep(0.6) PWM.set_frequency("P9_22", mi) time.sleep(0.45) PWM.set_frequency("P9_22", si) time.sleep(0.15) jouer_note(sol,50) jouer_note(sol,50) PWM.set_duty_cycle("P9_22", 0) PWM.start("P9_22", 50) PWM.set_frequency("P9_22", Fe) if __name__ == "__main__": while True: #hymne_joie() marche_imperiale() time.sleep(1)