def __init__(self):
num = NumericOutput("hello")
num((1, 2))
m1ena = Pin(3, Pin.OUT)
m1enb = Pin(4, Pin.OUT)
m1pwm = PWM(Pin(5))
m1pwm.freq(1000)
self.driver1 = MotorDriver()
self.driver1.config(m1ena, m1enb, m1pwm)
self.homingEncoder1 = HomingEncoder(10000)
self.homingEncoder1.config(6, 7, 28)
self.controller1 = MotorController(10000)
self.controller1.config(self.driver1, self.homingEncoder1, 0.0003)
self.taskScheduler = TackScheduler()
#self.taskScheduler.addTask( Beacon() )
self.taskScheduler.addTask(FastBeacon())
#self.taskScheduler.addTask( self.controller1 )
#self.taskScheduler.addTask( self.homingEncoder1 )
self.commands = {
"info": self.cmdInfo,
"move": self.cmdSimpleMove,
"const": self.cmdMoveAtConstantSpeed,
"stats": self.cmdStats,
"exit": self.cmdExit
}
# Start the infitine loop
self.run()
def play_mario():
"""
play Mario Bros tone example
source from here http://www.linuxcircle.com/2013/03/31/playing-mario-bros-tune-with-arduino-and-piezo-buzzer/
"""
p5 = Pin(5, Pin.OUT)
pwm5 = PWM(p5)
# mario = [E7, E7, 0, E7, 0, C7, E7, 0, G7, 0, 0, 0, G6, 0, 0, 0, C7, 0, 0, G6, 0, 0, E6, 0, 0, A6, 0, B6, 0, AS6, A6, 0, G6, E7, 0, G7, A7, 0, F7, G7, 0, E7, 0,C7, D7, B6, 0, 0, C7, 0, 0, G6, 0, 0, E6, 0, 0, A6, 0, B6, 0, AS6, A6, 0, G6, E7, 0, G7, A7, 0, F7, G7, 0, E7, 0,C7, D7, B6, 0, 0]
mario = [
E5, E5, 0, E5, 0, C5, E5, 0, G5, 0, 0, 0, G4, 0, 0, 0, C5, 0, 0, G4, 0,
0, E4, 0, 0, A4, 0, B4, 0, AS4, A4, 0, G4, E5, 0, G5, A5, 0, F5, G5, 0,
E5, 0, C5, D5, B4, 0, 0, C5, 0, 0, G4, 0, 0, E4, 0, 0, A4, 0, B4, 0,
AS4, A4, 0, G4, E5, 0, G5, A5, 0, F5, G5, 0, E5, 0, C5, D5, B4, 0, 0
]
for note in mario:
if note == 0:
pwm5.duty(0)
else:
pwm5.freq(note) # change frequency for change tone
pwm5.duty(30)
sleep_ms(150)
pwm5.deinit()
class SOUND():
def __init__(self):
pin = Pin(piNo)
self.buzzer = PWM(pin)
self.buzzer.duty(0)
self.pr = False
def __del__(self):
self.buzzer.duty(0)
self.buzzer.deinit()
def debug(self, deb=True):
self.pr = deb
def sound(self, freq, duration=1, duty=512):
if self.pr:
print("sound start:" + str(freq) + " :" + str(duration) + " :" +
str(duty))
self.buzzer.duty(duty)
self.buzzer.freq(freq)
sleep_ms(int(duration * 1000))
self.buzzer.duty(0)
#self.buzzer.deinit()
def sound_off(self):
self.buzzer.freq(0)
self.buzzer.duty(0)
class Stepper:
def __init__(self, dirPin, stepPin, msPin):
self.dirPin = dirPin
self.stepPin = PWM(stepPin, freq=0, duty=0)
self.msPin = msPin #microstep pin M0
#M0,M1,M2,ms
self.timeTable = [(1, 0, 0, 2000), (0, 0, 0, 20000), (1, 0, 0, 2000)]
self.tim = Timer(-1)
self.stepPin.freq(1000)
self.index = 0
#travel (in steps), speed (in steps / seconds)
def Schedule(self, travel, speed):
#converti les steps en millisecondes en tenant compte
#cree une rampe d'acceleration / deceleration par paliers
#en utilisant les microsteps
#for i in
# self.timeTable[]int(steps/self.freq)*1000)
pass
#integre une compensation du temps du retard moyen du Timer (1_ms)
def Run(self, t):
self.stepPin.duty(32)
try:
print(time.ticks_us())
self.msPin.value(self.timeTable[self.index][0])
self.tim.init(period=(self.timeTable[self.index][3]) - 1,
mode=Timer.ONE_SHOT,
callback=self.Run)
self.index += 1
except:
self.stepPin.duty(0)
class StatusLED():
def __init__(self, gpio=2):
self.led = Pin(gpio, Pin.OUT)
self.pwm = PWM(self.led)
def on(self):
self.pwm.deinit()
self.led.off()
sleep_ms(200)
self.led.off()
def off(self):
self.pwm.deinit()
self.led.on()
sleep_ms(200)
self.led.on()
def invert(self):
self.pwm.deinit()
self.led.value(not led.value())
def set(self, state):
if state:
self.on()
else:
self.off()
def slow_blink(self):
self.pwm.freq(1)
self.pwm.duty(512)
def fast_blink(self):
self.pwm.freq(3)
self.pwm.duty(512)
def sound_after_1_count():
buzzer = 0
for i in range(2):
buzzer = PWM(Pin(25))
buzzer.freq(10)
sleep(1)
buzzer.deinit()
class BuzzerDrum(AbstractInstrument, M5StackPlatform):
FREQ_NORMAL = 500
FREQ_ACCENT = 800
VOLUME = 500
BEEP_LENGTH = 0.07
pinNumber = None
def __init__(self, pin):
super().__init__()
self.pinNumber = pin
self.buzzer = PWM(Pin(self.pinNumber))
# stáva sa že na začiatku defaultné bzučí, tak ho tu stíšim:
self.buzzer.duty(0)
def playNormal(self, note):
self.buzzer.freq(self.FREQ_NORMAL)
self.buzzer.duty(self.VOLUME)
sleep(self.BEEP_LENGTH)
self.buzzer.duty(0)
return self.BEEP_LENGTH
def playAccent(self, note):
self.buzzer.freq(self.FREQ_ACCENT)
self.buzzer.duty(self.VOLUME)
sleep(self.BEEP_LENGTH)
self.buzzer.duty(0)
return self.BEEP_LENGTH
class Motor:
def __init__(self, m1, m2, dir, step, freq=50, duty=0):
self.m1 = Pin(m1, Pin.OUT)
self.m2 = Pin(m2, Pin.OUT)
self.dir = Pin(dir, Pin.OUT)
self.drive = PWM(Pin(step), freq, 0)
self.duty = getDuty(duty)
self.m1.value(0)
self.m2.value(0)
self.dir.value(0)
def setDuty(self, duty):
self.duty = duty
self.drive.duty(duty)
def setFreq(self, freq):
self.drive.freq(freq)
def setStepMode(self, mode):
if 0 <= mode and mode <= 3:
self.m1.value(1 & mode)
self.m2.value(1 & (mode >> 1))
def setDir(self, dir):
if 0 == dir or 1 == dir:
self.dir.value(dir)
def driveOn(self):
self.drive.init()
self.drive.duty(self.duty)
def driveOff(self):
self.drive.deinit()
def play_show(tune, pin=27, display=matrix.display, duration=None):
from machine import Pin, PWM
from utime import sleep_ms
try:
pwm = PWM(Pin(pin))
if duration is None:
set_default(tune[0])
else:
set_duration(duration)
for tone in tune:
tone = tone.upper() # all to upper
if tone[0] not in Letter:
continue
if len(tone) == 4:
display.showstatic(tone.replace(":", ""))
else:
display.showstatic(tone)
m = midi(tone)
pwm.freq(m[0]) # set frequency
pwm.duty(m[1]) # set duty cycle
sleep_ms(m[1])
display.clear()
finally:
pwm.deinit()
def angle(self, angle, pin):
pwm = PWM(Pin(pin)) #Set pin
pwm.freq(50) #Set Frequency
servo_position = (
(angle * 650 / 3 + 9500) / 6
) # Formula to convert angle to correct pwm; Don't worry I wont repeat that formula again ;) DRY - Don't Repeat Yourself.
pwm.duty_u16(int(servo_position)) #Set servo position
def pitch(freq, tim):
pwm = PWM(Pin(25))
pwm.freq(freq) # set frequency
# print('pwm.freq ' + str(pwm.freq())) # get current frequency
pwm.duty(500) # set duty cycle
sleep_ms(tim)
pwm.deinit()
def sound_on_off():
buzzer = 0
for i in range(5):
buzzer = PWM(Pin(25))
buzzer.freq(10)
sleep(1)
buzzer.deinit()
def laser():
global statBuzzer
#statBuzzer = 'off'
while (1):
infra.value(1)
sleep(2)
if ldr.read() > 4000 and infra.value() == 1:
while (1):
buzzer = PWM(Pin(2))
buzzer.freq(20)
#statBuzzer = 'on'
R.value(1)
G.value(0)
B.value(0)
sleep(0.5)
R.value(0)
G.value(0)
B.value(1)
sleep(0.5)
#print(SW.value())
if SW.value() == 0 or count % 2 == 1:
buzzer.deinit()
#statBuzzer = 'off'
R.value(0)
G.value(0)
B.value(0)
break
sleep(0.2)
if SW.value() == 0 or count % 2 == 1:
infra.value(0)
break
def setup():
#setup light to voltage sensor
adc = ADC(Pin(34)) # define the pin as an analog-to-digital converter
adc.atten(ADC.ATTN_11DB) # set the atten..?
adc.width(ADC.WIDTH_12BIT) # set the width of the available bits
#setup measurement LED for PWM
dpin = Pin(12)
pwm = PWM(dpin)
pwm.freq(78000) # set frequency
pwm.duty(0) # set current
#setup RGB LED
red = Pin(15, Pin.OUT)
green = Pin(32, Pin.OUT)
blue = Pin(14, Pin.OUT)
#setup embedded LED
emb = Pin(13, Pin.OUT)
#setup button 1
button = Pin(33, Pin.IN, Pin.PULL_UP)
# setup button 2
button2 = Pin(27, Pin.IN, Pin.PULL_UP)
return (adc, pwm, button, button2, red, green, blue, emb)
def play_show(tune, pin=27, display=matrix.display, duration=None):
from machine import Pin, PWM
from utime import sleep_ms
try:
pwm = PWM(Pin(pin))
if duration is None:
set_default(tune[0])
else:
set_duration(duration)
for tone in tune:
tone = tone.upper() # all to upper
if tone[0] not in Letter:
continue
if len(tone)==4:
display.showstatic(tone.replace(":",""))
else:
display.showstatic(tone)
m = midi(tone)
pwm.freq(m[0]) # set frequency
pwm.duty(m[1]) # set duty cycle
sleep_ms(m[1])
display.clear()
finally:
pwm.deinit()
class Servo:
def __init__(self,
pin: int or Pin or PWM,
minVal=2500,
maxVal=7500,
maxDegrees=180):
if isinstance(pin, int):
pin = Pin(pin, Pin.OUT)
if isinstance(pin, Pin):
self.__pwm = PWM(pin)
if isinstance(pin, PWM):
self.__pwm = pin
self.__pwm.freq(50)
self.minVal = minVal
self.maxVal = maxVal
self.maxDegrees = maxDegrees
def deinit(self):
self.__pwm.deinit()
def goto(self, value: int):
delta = self.maxVal - self.minVal
target = int(self.minVal + ((value / 1024) * delta))
self.__pwm.duty_u16(target)
def gotoDeg(self, value: int):
diff = int(self.maxVal - self.minVal)
oneDegree = int(diff / self.maxDegrees)
self.__pwm.duty_u16(self.minVal + (oneDegree * value))
def free(self):
self.__pwm.duty_u16(0)
def initialise(settings):
global duty_cycle_max, duty_cycle_min, pwm_frequency
global left_motor1, left_motor2, right_motor1, right_motor2
global servo
global i2c_bus
if "duty_cycle_max" in settings:
duty_cycle_max = int(settings["duty_cycle_max"])
if "duty_cycle_min" in settings:
duty_cycle_min = int(settings["duty_cycle_min"])
if "pwm_frequency" in settings:
pwm_frequency = int(settings["pwm_frequency"])
left_motor1 = initialise_motor(settings, "left_motor_pin1")
left_motor2 = initialise_motor(settings, "left_motor_pin2")
right_motor1 = initialise_motor(settings, "right_motor_pin1")
right_motor2 = initialise_motor(settings, "right_motor_pin2")
servo_pin = Pin(settings["servo_pin"], Pin.OUT)
servo = PWM(servo_pin)
servo.freq(50) # Set 50Hz PWM
servo.duty(77) # Off
scl = settings["scl_pin"]
sda = settings["sda_pin"]
i2c_bus = machine.I2C(scl=machine.Pin(scl), sda=machine.Pin(sda))
class Servo:
def __init__(self, p, name):
self.name = name
self.port = p
self.pin = Pin(p,Pin.OUT)
self.pulser = PWM(self.pin)
self.pulser.freq(50)
def setRaw(self, value):
print ("raw %s %d" % (self.name, value))
self.pulser.duty(value)
def setPercentage(self, angle):
if angle > 90:
angle = 90
if angle < 0:
angle = 0
#33 - 130 33= top 130 = min
val = (angle)+33
val = int(val)
print ("%s %d %d" % (self.name, angle, val))
self.pulser.duty(val)
class Motor:
def __init__(self,in1,in2,pwm):
self.pwm = PWM(Pin(pwm))
self.in1 = Pin(in1,Pin.OUT)
self.in2 = Pin(in2,Pin.OUT)
self.pwm.freq(1000)
def aus(self):
self.pwm.duty_u16(0)
self.in1.off()
self.in2.off()
def vor(self,geschw):
if geschw<0:
self.back(geschw*(-1))
if geschw>100:
geschw=100
self.in1.on()
self.in2.off()
self.pwm.duty_u16(650*geschw)
def back(self,geschw):
if geschw<=0:
self.aus()
if geschw>100:
geschw=100
self.in1.off()
self.in2.on()
self.pwm.duty_u16(650*geschw)
class BuzzerDrum(AbstractInstrument, PikoPlatform):
FREQ_NORMAL = 500
FREQ_ACCENT = 800
VOLUME = 150
BEEP_LENGTH = 0.07
pin = None
def __init__(self, pin):
super().__init__()
self.pin = pin
self.buzzer = PWM(Pin(self.pin))
def playNormal(self, note):
self.buzzer.freq(self.FREQ_NORMAL)
self.buzzer.duty_u16(self.VOLUME)
sleep(self.BEEP_LENGTH)
self.buzzer.duty_u16(0)
return self.BEEP_LENGTH
def playAccent(self, note):
self.buzzer.freq(self.FREQ_ACCENT)
self.buzzer.duty_u16(self.VOLUME)
sleep(self.BEEP_LENGTH)
self.buzzer.duty_u16(0)
return self.BEEP_LENGTH
def onofflight():
SWon = False
while (1):
buzzer = PWM(Pin(2))
if SW.value() == 0 and SWon == False:
SWon = True
while (1):
buzzer.freq(20)
R.value(1)
G.value(0)
B.value(0)
sleep(0.5)
R.value(0)
G.value(0)
B.value(1)
sleep(0.5)
if SW.value() == 0:
break
buzzer.deinit()
R.value(0)
G.value(0)
B.value(0)
SWon = False
class GPIO():
def __init__(self,pin,pulse=0):
self.pin = pin
self.pulse = pulse
if pulse == 0:
self.pin=Pin(self.pin,Pin.OUT)
self.pin.value(0)
elif pulse == 1:
self.pin=PWM(Pin(self.pin),Pin.OUT)
self.pin.freq(500)
def on(self):
self.pin.value(1)
def off(self):
self.pin.value(0)
def toggle(self):
self.pin.value(not self.pin.value())
def repeat(self,n,t=0.5):
for i in range(n):
self.toggle()
time.sleep(t)
self.off()
def scale(self,n):
if n > 100:
n = 100
elif n < 0:
n = 0
percent = n*10
self.pin.duty(percent)
return (percent)
def fade_in(self,step=5,t=0.1):
for i in range(0,100,step):
self.scale(i)
time.sleep(t)
def fade_out(self,step=5, t=0.1):
for i in range(0,100,step):
self.scale(100-i)
time.sleep(t)
self.scale(0)
def help():
print("")
print("Cheat Sheet Wemos D1 Mini")
print("-------------------------")
print(" ____________")
print(" / |")
print(" RST-| = |- TX")
print(" A0-| ESP8266 |- RX")
print("NO PWM GPIO16 D0-| SCL-|- D1 GPIO5")
print(" GPIO14 D5-|-SCK SDA-|- D2 GPIO4")
print(" GPIO12 D6-|-MISO |- D3 GPIO0 PullUp")
print(" GPIO13 D7-|-MOSI |- D4 GPIO2 PullUp Built-in Led")
print("PullDn GPIO15 D8-| |- G")
print(" 3v3-|_____________|- 5V")
print("")
class Servo:
# This class holds the methods to control the servo motor
# A single instance of this class will be insantized during the lifetime of the main program
def __init__(self):
self.servo = PWM(Pin(config.pins["servo_pin"]))
self.servo.freq(frequency) #This has to do with the servo expecting a pulse every 20ms
self.servo.duty(smallDuty)
def changeSize(self, size):
if size == 'big':
self.servo.duty(bigDuty)
elif size == 'small':
self.servo.duty(smallDuty)
#The following function will toggle between the sizes of the servo
def toggleSize(self):
if(self.servo.duty() == smallDuty):
self.servo.duty(bigDuty)
else:
self.servo.duty(smallDuty)
class PWMOut(object):
"""PWM output."""
def __init__(self, pin, freq=50, duty=0, verbose=False, channel=-1):
self._pin = PWM(Pin(pin))
self._pin.freq(freq)
self._pin.duty_u16(duty)
self._verbose = verbose
if self._verbose:
self.__logFrequency()
def deinit(self):
self._pin.deinit()
@property
def duty_percent(self):
""" duty in percent
"""
return self._pin.duty_u16() / MAX_DUTY * 100
@duty_percent.setter
def duty_percent(self, value):
self._pin.duty_u16(int(min(max(0, value / 100.0 * MAX_DUTY),
MAX_DUTY)))
@property
def duty(self):
""" duty as raw value
"""
return self._pin.duty_u16()
@duty.setter
def duty(self, value):
self._pin.duty_u16(int(value))
@property
def freq_Hz(self):
""" frequency in [Hz]
"""
return self._pin.freq()
@freq_Hz.setter
def freq_Hz(self, value):
self._pin.freq(value)
if self._verbose:
self.__logFrequency()
@property
def max_duty(self):
return MAX_DUTY
@property
def uses_rmt(self):
return False
def __logFrequency(self):
print("PWM frequency is {0:.1f} kHz".format(self.freq_Hz / 1000))
def __setRMTDuty(self, value):
pass
class PulseGenerator:
def __init__(self):
#self._pin = Pin(4, mode=Pin.OPEN_DRAIN, value=1, pull=Pin.PULL_DOWN)
self._pin = Pin(4, mode=Pin.OUT, value=1, pull=Pin.PULL_DOWN)
self._timer = None
self._sleep_ms = 0
self._pwm = None
def reset(self):
if self._timer is not None:
self._timer.deinit()
self._timer = None
if self._pwm is not None:
self._pwm.deinit()
self._pwm = None
self._pin.value(1)
def run(self):
while True:
self.print_menu()
try:
value = int(input('Enter selection: '))
selected = OPTIONS[value]
except Exception:
print('Invalid input')
continue
self.reset()
if selected[0] == 0 and selected[1] == 0:
self.reset()
elif selected[0] == 0:
self.handle_slow(selected[1])
else:
self.handle_fast(selected[1])
print('Set to: %s' % selected[2])
def print_menu(self):
for idx, item in enumerate(OPTIONS):
print('%d) %s' % (idx, item[2]))
def handle_fast(self, freq):
self._pwm = PWM(self._pin)
self._pwm.freq(freq)
self._pwm.duty(512)
def handle_slow(self, sleep_ms):
self._sleep_ms = sleep_ms
self._timer = Timer(0)
self._timer.init(period=self._sleep_ms,
mode=Timer.ONE_SHOT,
callback=self.slow_timer_callback)
self.slow_timer_callback()
def slow_timer_callback(self, *args):
self._pin.value(0)
sleep_ms(2)
self._pin.value(1)
self._timer.init(period=self._sleep_ms,
mode=Timer.ONE_SHOT,
callback=self.slow_timer_callback)
class Motor:
class MotorDirection(enumerate):
FORWARD = 1
REVERSE = 0
def __init__(self,
pin_dir,
pin_speed,
duty_ratio=65535,
reverse_sense=False):
self._pin_dir = pin_dir
self._pin_dir.init(Pin.OUT)
self._pin_dir.off()
self._pin_speed = pin_speed
self._pwm = PWM(self._pin_speed)
self._pwm.duty_u16(0)
self._pwm.freq(1000)
if reverse_sense:
self._rev_sense = True
else:
self._rev_sense = False
self._duty_ratio = duty_ratio
self._dir = self.MotorDirection.FORWARD
def set_direction(self, dir):
if dir != self.MotorDirection.FORWARD and dir != self.MotorDirection.REVERSE:
return
if self.MotorDirection.FORWARD == dir:
if self._rev_sense:
self._dir = self.MotorDirection.REVERSE
else:
self._dir = self.MotorDirection.FORWARD
else:
if self._rev_sense:
self._dir = self.MotorDirection.FORWARD
else:
self._dir = self.MotorDirection.REVERSE
if self._dir == self.MotorDirection.FORWARD:
self._pin_dir.on()
else:
self._pin_dir.off()
def set_speed(self, duty):
if duty < 0 or duty > 100:
return
duty = round(duty / 100 * self._duty_ratio)
self._pwm.duty_u16(duty)
def on(self, direction, duty):
self.set_direction(direction)
self.set_speed(duty)
def off(self):
self.set_speed(0)
class MPythonPin():
def __init__(self, pin, mode=PinMode.IN, pull=None):
if mode not in [PinMode.IN, PinMode.OUT, PinMode.PWM, PinMode.ANALOG]:
raise TypeError("mode must be 'IN, OUT, PWM, ANALOG'")
if pin == 4:
raise TypeError("P4 is used for light sensor")
if pin == 10:
raise TypeError("P10 is used for sound sensor")
try:
self.id = pins_remap_esp32[pin]
except IndexError:
raise IndexError("Out of Pin range")
if mode == PinMode.IN:
if pin in [3]:
raise TypeError('IN not supported on P%d' % pin)
self.Pin = Pin(self.id, Pin.IN, pull)
if mode == PinMode.OUT:
if pin in [2, 3]:
raise TypeError('OUT not supported on P%d' % pin)
self.Pin = Pin(self.id, Pin.OUT, pull)
if mode == PinMode.PWM:
if pin not in [
0, 1, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 19, 20, 23, 24,
25, 26, 27, 28
]:
raise TypeError('PWM not supported on P%d' % pin)
self.pwm = PWM(Pin(self.id), duty=0)
if mode == PinMode.ANALOG:
if pin not in [0, 1, 2, 3, 4, 10]:
raise TypeError('ANALOG not supported on P%d' % pin)
self.adc = ADC(Pin(self.id))
self.adc.atten(ADC.ATTN_11DB)
self.mode = mode
def irq(self, handler=None, trigger=Pin.IRQ_RISING):
if not self.mode == PinMode.IN:
raise TypeError('the pin is not in IN mode')
return self.Pin.irq(handler, trigger)
def read_digital(self):
if not self.mode == PinMode.IN:
raise TypeError('the pin is not in IN mode')
return self.Pin.value()
def write_digital(self, value):
if not self.mode == PinMode.OUT:
raise TypeError('the pin is not in OUT mode')
self.Pin.value(value)
def read_analog(self):
if not self.mode == PinMode.ANALOG:
raise TypeError('the pin is not in ANALOG mode')
return self.adc.read()
def write_analog(self, duty, freq=1000):
if not self.mode == PinMode.PWM:
raise TypeError('the pin is not in PWM mode')
self.pwm.freq(freq)
self.pwm.duty(duty)
def stop(pin=27):
from machine import Pin, PWM
try:
pwm = PWM(Pin(pin))
pwm.duty(0)
pwm.freq(1)
finally:
pwm.deinit()
def kick():
motor = PWM(Pin(16))
motor.freq(50)
motor.duty(25)
time.sleep(1)
motor.duty(0)
def stop(pin=27):
from machine import Pin, PWM
try:
pwm = PWM(Pin(pin))
pwm.duty(0)
pwm.freq(1)
finally:
pwm.deinit()
def tone(frequency, duration=100, pin=None, volume=1):
if pin is None:
pin = Pin(SPEAKER_PIN)
pwm = PWM(pin, duty=volume % 50)
pwm.freq(frequency)
time.sleep_ms(duration)
pwm.deinit()
async def _blink(self, led: PWM) -> None:
""" Blink led 3 times and wait
"""
led.freq(10)
led.duty(round(self.rgb_intensity / self.INTENSITY_MAX_SCALE * 100, 2))
await asyn.sleep(0.3, 10)
led.duty(0)
await asyn.sleep(0.2, 10)
def pitch(freq,pin=27,tim=1000): from machine import Pin,PWM from utime import sleep_ms try: pwm=PWM(Pin(pin)) pwm.freq(freq) pwm.duty(tim) sleep_ms(tim) finally: pwm.deinit()
def pitch(self,pin=27,freq=440,tim=0): from machine import Pin,PWM from utime import sleep_ms pwm=PWM(Pin(pin)) if freq>0: pwm.freq(int(freq)) else: pwm.duty(0) if tim>0: sleep_ms(tim) pwm.deinit()
class MPythonPin(Pin):
def __init__(self, pin, mode=PinMode.IN):
if mode not in [PinMode.IN, PinMode.OUT, PinMode.PWM, PinMode.ANALOG]:
raise TypeError("mode must be 'IN, OUT, PWM, ANALOG'")
if pin == 3:
raise TypeError("pin3 is used for resistance sensor")
if pin == 4:
raise TypeError("pin4 is used for light sensor")
if pin == 10:
raise TypeError("pin10 is used for sound sensor")
self.id = pins_remap_esp32[pin]
if mode == PinMode.IN:
super().__init__(self.id, Pin.IN, Pin.PULL_UP)
if mode == PinMode.OUT:
if pin == 2:
raise TypeError('pin2 only can be set "IN, ANALOG"')
super().__init__(self.id, Pin.OUT)
if mode == PinMode.PWM:
if pin == 2:
raise TypeError('pin2 only can be set "IN, ANALOG"')
self.pwm = PWM(Pin(self.id), duty=0)
if mode == PinMode.ANALOG:
if pin not in [0, 1, 2, 3, 4, 10]:
raise TypeError('the pin can~t be set as analog')
self.adc = ADC(Pin(self.id))
self.adc.atten(ADC.ATTN_11DB)
self.mode = mode
def read_digital(self):
if not self.mode == PinMode.IN:
raise TypeError('the pin is not in IN mode')
return super().value()
def write_digital(self, value):
if not self.mode == PinMode.OUT:
raise TypeError('the pin is not in OUT mode')
super().value(value)
def read_analog(self):
if not self.mode == PinMode.ANALOG:
raise TypeError('the pin is not in ANALOG mode')
return self.adc.read()
def write_analog(self, duty, freq=1000):
if not self.mode == PinMode.PWM:
raise TypeError('the pin is not in PWM mode')
self.pwm.freq(freq)
self.pwm.duty(duty)
def play(self,tune,pin=27,duration=None):
from machine import Pin,PWM
from utime import sleep_ms
pwm=PWM(Pin(pin))
if duration is None:
self.set_default(tune[0])
else:
self.set_duration(duration)
for tone in tune:
tone=tone.upper()
if tone[0]not in Letter:
continue
midi=self.midi(tone)
pwm.freq(midi[0])
sleep_ms(midi[1])
pwm.deinit()
class Buzz(object): def __init__(self,pin=6): self.id=pins_remap_esp32[pin] self.io=Pin(self.id) self.io.value(1) self.isOn=False def on(self,freq=500): if self.isOn is False: self.pwm=PWM(self.io,freq,512) self.isOn=True def off(self): if self.isOn: self.pwm.deinit() self.io.init(self.id,Pin.OUT) self.io.value(1) self.isOn=False def freq(self,freq): self.pwm.freq(freq)
def play(tune,pin=27,duration=None):
from machine import Pin,PWM
from utime import sleep_ms
try:
pwm=PWM(Pin(pin))
if duration is None:
set_default(tune[0])
else:
set_duration(duration)
for tone in tune:
tone=tone.upper()
if tone[0]not in Letter:
continue
m=midi(tone)
pwm.freq(m[0])
pwm.duty(m[1])
sleep_ms(m[1])
finally:
pwm.deinit()
def play_show(self,tune,pin=27,display=matrix.display,duration=None):
from machine import Pin,PWM
from utime import sleep_ms
pwm=PWM(Pin(pin))
if duration is None:
self.set_default(tune[0])
else:
self.set_duration(duration)
for tone in tune:
tone=tone.upper()
if tone[0]not in Letter:
continue
if len(tone)==4:
display.showstatic(tone.replace(":",""))
else:
display.showstatic(tone)
midi=self.midi(tone)
pwm.freq(midi[0])
sleep_ms(midi[1])
display.clear()
pwm.deinit()
def stop(self, pin=27):
from machine import Pin, PWM
pwm = PWM(Pin(pin))
pwm.duty(0)
pwm.freq(1)
pwm.deinit()
def servo_write_angle(pin,angle): pwm=PWM(Pin(pin)) pwm.duty(int(40 + 75 * angle / 180)) pwm.freq(50)
