def __init__(self):
super(Euglena_moto_port, self).__init__(0)
moto_pwm = PWM(0, 5000)
self.moto = {}
self.S1.mode(Pin.OUT)
self.S2.mode(Pin.OUT)
self.S3.mode(Pin.OUT)
self.S4.mode(Pin.OUT)
self.moto['left_direction'] = self.S1
self.moto['rigth_direction'] = self.S3
self.moto['left_pwm'] = moto_pwm.channel(0,
pin=self.S2.id(),
duty_cycle=0)
self.moto['right_pwm'] = moto_pwm.channel(1,
pin=self.S4.id(),
duty_cycle=0)
class ToolHead:
def __init__(self):
# create pwm channel on pin P12
self.pwm = PWM(
0, frequency=50) # use PWM timer 0, with a frequency of 50Hz
self.is_active = False
self.button_up = Pin('G4', mode=Pin.IN, pull=Pin.PULL_UP)
self.button_dwn = Pin('G5', mode=Pin.IN, pull=Pin.PULL_UP)
def activate(self):
# May not be switched on
if not self.is_active:
self.is_active = True
self.pwm_c = self.pwm.channel(0, pin='P12', duty_cycle=0.15)
def set_position(self, position): # Converts to 1 -2 ms pulses
self.activate()
# speed in %
dc = (position / 100.0) * (1 / 20) + (1 / 20)
self.pwm_c.duty_cycle(dc)
return dc
def park(self):
self.set_position(50)
def grip(self):
self.set_position(100)
def release(self):
self.set_position(0)
def shutdown(self):
# Ideally won't move servo
self.pwm_off = Pin('P12', mode=Pin.IN, pull=Pin.PULL_UP)
self.is_active = False
def buz(frequency=440):
buz = Pin("P10") # Buzzer
tim = PWM(0, frequency=frequency)
ch = tim.channel(2, duty_cycle=0.5, pin=buz)
time.sleep(1)
tim = PWM(0, frequency=0)
ch.duty_cycle(0)
def __init__motor(self, ENpin, PHpin, timer_id, channel_id, sensorApin,
sensorBpin):
#Assign IO as Enable and Phase output,pins
EN = PWM(self.timer_id, frequency=5000)
ENpin = EN.channel(self.channel_id, ENpin, duty_cycle=0)
PHpin = Pin(self.PHpin, Pin.OUT_PP)
#Preliminary Attributes
self.isRunning = False
self.currentDirection = None
self.speed = self.duty_cycle
#Assign hall effect sensor pins frrom encoder as input pins
hallsensorA = Pin(self.sensorApin, mode=Pin.IN, pull=Pin.PULL_UP)
hallsensorB = Pin(self.sensorBpin, mode=Pin.IN, pull=Pin.PULL_UP)
#Assign Trigger for when sensor hits falling edge
low_value_trigger_A = encoder_A.callback(
Pin.IRQ_FALLING,
rencoder) #Trigger is the falling edge; handler is rencoder event
low_value_trigger_B = encoder_B.callback(Pin.IRQ_FALLING, rencoder)
#Prelimnary Attributes
count = long(pulse=0)
def openDoor():
motorGND = Pin(
'P8', mode=Pin.OUT
) # Enable of LN298 is connected to 3V3 so we have to switch the input pins to turn the motor the other way
motorGND.value(
0
) # The DC motor needs GND on 1 pin and a PWM signal on the other pin (we use pin 8 as GND now)
pwm = PWM(0, frequency=5000) # use PWM timer 0, with a frequency of 5KHz
pwm_c_motor = pwm.channel(
0, pin='P9', duty_cycle=1.0
) # create pwm channel on pin P9 with a duty cycle of 100%
time.sleep(
DOOROPENTIME) # Let the motor run until the door is completely open
pwm_c_motor = pwm.channel(0, pin='P9',
duty_cycle=0.0) # Stop the door when opened
def __init__(self, pin, freq=50, min_us=600, max_us=2400, angle=180):
self.min_us = min_us
self.max_us = max_us
self.us = 0
self.freq = freq
self.angle = angle
print(freq)
pwm = PWM(0, frequency=freq)
self.pwm = pwm.channel(0, pin=pin, duty_cycle=0)
def do(self, freq=2000, duty=0.1, duration=0.1, pause=0.1, repeat=1, color=0x0000ff):
pycom.heartbeat(False)
for i in range(repeat):
pycom.rgbled(color)
pwm = PWM(0, freq)
pin = pwm.channel(0, pin='P10', duty_cycle=duty)
time.sleep(duration)
pycom.heartbeat(False)
pin.duty_cycle(0)
time.sleep(pause)
def __init__(self, ENpin, PHpin, timer_id, channel_id):
self.timer_id = timer_id
self.channel_id = channel_id
#Assign IO as Enable and Phase output,pins
EN = PWM(0, frequency=5000)
self.ENpin = EN.channel(0, pin=ENpin, duty_cycle=0)
self.PHpin = Pin(PHpin, mode=Pin.OUT)
#Preliminary Attributes
self.isRunning = False
self.current_direction = None
self.current_speed = 0
class PulseLED(object):
"""pulsing LED"""
def __init__(self, pin, freq=1000, timer=0):
#super(, self).__init__()
self.pwm = PWM(timer, frequency=freq)
self.led_c = self.pwm.channel(0, pin=pin, duty_cycle=0)
# pulse function
def pulse(self, t):
"""pulse led l with time interval t in ms"""
for i in range(17):
self.led_c.duty_cycle(math.sin(i / 10 * math.pi))
time.sleep_ms(t)
def controlClimate(
): # Read temperature and humidity from DHT 22 and activate fan if temp is to high.
result = th.read()
if result.is_valid():
if result.temperature > MAXTEMP:
fanGND = Pin('P10',
mode=Pin.OUT) #Declaring pin as digital output.
fanGND.value(0) # Setting pin to zero/ GND for fan.
pwm = PWM(
0, frequency=5000) # use PWM timer 0, with a frequency of 5KHz
pwm_c_fan = pwm.channel(
0, pin='P11', duty_cycle=1.0
) # create pwm channel on pin P11 with a duty cycle of 50%
class ToolHead:
def __init__(self):
# create pwm channel on pin P12
self.pwm = PWM(
0, frequency=50) # use PWM timer 0, with a frequency of 50Hz
self.pwm_c = self.pwm.channel(0, pin='P12', duty_cycle=0.15)
self.state = 0
def set_position(self, position): # Converts to 1 -2 ms pulses
# speed in %
dc = (position / 100.0) * (1 / 20) + (1 / 20)
self.pwm_c.duty_cycle(dc)
return dc
def park(self):
self.set_position(50)
def grip(self):
self.set_position(100)
def release(self):
self.set_position(0)
def run(self):
global running, btn
if self.state == 0:
pycom.rgbled(0x002000)
self.state = 1
self.park()
elif self.state == 1:
pycom.rgbled(0x008000)
if btn.pushed:
self.state = 2
self.release()
elif self.state == 2:
pycom.rgbled(0x000080)
if btn.pushed:
self.state = 3
self.grip()
elif self.state == 3:
pycom.rgbled(0x808000)
if btn.pushed:
self.state = 4
self.release()
else:
self.state == 4
pycom.rgbled(0x200000)
if btn.pushed:
running = False
self.park()
pycom.rgbled(0x800000)
def test_servo():
pwm = PWM(0, frequency=50) # create PWM, with a frequency of 50Hz
pwm_c = pwm.channel(
0, pin='P4',
duty_cycle=0.05) # .05 duty cycle starts servo all the way to the east
d_cycle = 0.05 # initial duty cycle value
while True:
# 0.03 and 0.12-0.16 work, though 0.12 seems to give best results
print("moving to d cycle 0.03")
pwm_c.duty_cycle(0.03)
time.sleep(2)
print("moving to d cycle 0.12")
pwm_c.duty_cycle(0.12)
time.sleep(5)
class Servo:
"""
WiPy servo object
Sets up Timer and Channel and performs calculation so servo angle is automatically converted to duty cycle.
"""
def __init__(self, gp_pin, channel, frequency, full_range100, pulse_min, pulse_max):
"""
:param gp_pin: GPIO pin
:channel: PWM unit
:param frequency: in Hz
:param full_range100: in deg
:param pulse_min: in µs (WiPy3.0) in Duty (for ESP32, it should be - 30)
:param pulse_max: in µs (WiPy3.0) in Duty (for ESP32, it should be - 30)
:return:
"""
# Store object properties
self.PWM_frame = frequency # in Hz
self.full_range100 = full_range100
self.pulse_min = pulse_min
self.pulse_diff = pulse_max - pulse_min
self.min_position = 0
self.max_position = 180
if (uname().sysname == 'WiPy'):
# Configure PWM timer to pin flow
self.pwm = PWM(0, frequency=self.PWM_frame)
self.servo = self.pwm.channel(channel, pin=gp_pin, duty_cycle=0.077) # initial duty cycle of 7.5%
else:
self.pwm = PWM(gp_pin, freq=self.PWM_frame)
def angle(self, angle100):
"""
Set timer duty cycle to specified angle
:param angle100: angle in deg * 100
:return:
"""
angle_fraction = float(angle100) / float(self.full_range100)
pulse_width = float(self.pulse_min + angle_fraction * self.pulse_diff) # in µs
if (uname().sysname == 'WiPy'):
duty_cycle = pulse_width * 100 / (1000 / self.PWM_frame) / 100
self.servo.duty_cycle(duty_cycle)
else:
self.pwm.duty(int(pulse_width))
def __configure_pwm_pin(self, pin_number):
# TODO: Add a check for WiPy 1.0
_PWMMap = {0: (0, 0),
1: (0, 1),
2: (0, 2),
3: (0, 3),
4: (0, 4),
8: (0, 5),
9: (0, 6),
10: (0, 7),
11: (1, 0),
12: (1, 1),
19: (1, 2),
20: (1, 3),
21: (1, 4),
22: (1, 5),
23: (1, 6)}
pwm = PWM(_PWMMap[pin_number][0], frequency=5000)
self.__pins[pin_number] = pwm.channel(_PWMMap[pin_number][1], pin="P" + str(pin_number),
duty_cycle=0)
def __init__(self,
p_pwm_id,
p_channel_enable_id,
channel_name,
pwm_timer_id=0,
pwm_channel_id=0):
"""
p_pwm_id -- the id of the pwm pin (e.g, connect pin to PWMA)
p_channel_enable_id -- the id of the motor enable pin (e.g., connect pin to AIN2)
channel_name -- the name of the channel used for logging
pwm_timer_id -- [0], id of the timer, must be 0 to 3
pwm_channel_id -- [0], id of the pwm channel, must be 0 to 7
"""
self.channel_name = channel_name
pwm = PWM(
pwm_timer_id,
frequency=5000) # use given pwm timer, with a frequency of 5KHz
self.p_pwm = pwm.channel(pwm_channel_id, pin=p_pwm_id, duty_cycle=0.0)
self.p_channel_enable = Pin(p_channel_enable_id, mode=Pin.OUT)
def start_servo():
LDR1 = adc.channel(Pin='P16', attn=ADC.ATTN_11DB)
LDR2 = adc.channel(Pin='P17', attn=ADC.ATTN_11DB)
pwm = PWM(0, frequency=50) # create PWM, with a frequency of 50Hz
pwm_c = pwm.channel(
0, pin='P4',
duty_cycle=0.05) # .05 duty cycle starts servo all the way to the east
d_cycle = 0.05 # initial duty cycle value
while True: # run continuosly
# read voltages (mV) at each node
LDReast_v = LDR1.voltage()
LDRwest_v = LDR2.voltage()
# compare voltages at each LDR node
v_diff = LDReast_v - LDRwest_v
threshold = 100 # millivolts
if v_diff > threshold:
moveservo = 1
elif v_diff < (-1) * threshold:
moveservo = -1
else:
moveservo = 0
# move servo in 1 degree increments every (interval) seconds
increment = 10 * 1 / 180 # 1 ms divided by 180 degrees =.0055555 increment
d_cycle += increment # new duty cycle
# check to make sure d_cycle is within allowable range
if d_cycle < 0.05:
d_cycle = 0.05
if d_cycle > 0.1:
d_cycle = 0.1
# move servo to new location (incrementally)
pwm_c.duty_cycle(d_cycle)
print("servo moved")
time.sleep(5)
self.dutycycle = servo.min_dutycycle + servo.step * self.position
self.dutycycle = min(max(self.dutycycle, servo.min_dutycycle),
servo.max_dutycycle)
if self.pwm_channel:
self.pwm_channel.duty_cycle(self.dutycycle)
if __name__ == "__main__":
from machine import Pin, PWM
import socket
import url
import gc
# servo setup
pwm = PWM(0, frequency=50)
servo1 = servo(50, pwm.channel(0, pin=Pin.exp_board.G15))
servo2 = servo(50, pwm.channel(1, pin=Pin.exp_board.G16))
# for demonstration purpose limit servo2's position
servo2.min_position = 20
servo2.max_position = 80
# webserver setup
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind(socket.getaddrinfo('0.0.0.0', 80)[0][-1])
serversocket.listen(1)
while True:
gc.collect()
conn, addr = serversocket.accept()
class LEDStrip:
DISABLED = const(-1)
def __init__(self, *args):
self.pin_r = args[0]
self.pin_g = args[1]
self.pin_b = args[2]
self.pin_r.mode(Pin.OUT)
self.pin_g.mode(Pin.OUT)
self.pin_b.mode(Pin.OUT)
self.pwm = PWM(0, frequency=5000)
self.pwm_r = self.pwm.channel(0, pin=self.pin_r, duty_cycle=0)
self.pwm_g = self.pwm.channel(1, pin=self.pin_g, duty_cycle=0)
self.pwm_b = self.pwm.channel(2, pin=self.pin_b, duty_cycle=0)
self.fader = Fader(self.pwm_r, self.pwm_g, self.pwm_b)
self._r = pycom.nvs_get('red') or 0
self._g = pycom.nvs_get('green') or 20
self._b = pycom.nvs_get('blue') or 40
self._fading = pycom.nvs_get('fading') or False
self._schedule_start = pycom.nvs_get('schedule_start') or self.DISABLED
self._schedule_stop = pycom.nvs_get('schedule_stop') or self.DISABLED
@property
def enabled(self):
return self.r > 0 or self.g > 0 or self.b > 0
# red
@property
def r(self):
return self._r
@r.setter
def r(self, value):
self._r = value
self.pwm_r.duty_cycle(value/255)
pycom.nvs_set('red', value)
# green
@property
def g(self):
return self._g
@g.setter
def g(self, value):
self._g = value
self.pwm_g.duty_cycle(value/255)
pycom.nvs_set('green', value)
# blue
@property
def b(self):
return self._b
@b.setter
def b(self, value):
self._b = value
self.pwm_b.duty_cycle(value/255)
pycom.nvs_set('blue', value)
# fading
@property
def fading(self):
return self._fading
@fading.setter
def fading(self, value):
self._fading = value
pycom.nvs_set('fading', value)
# schedule_stop (in minutes 0-1439)
@property
def schedule_stop(self):
return self._schedule_stop
@schedule_stop.setter
def schedule_stop(self, value):
self._schedule_stop = value
pycom.nvs_set('schedule_stop', value)
# schedule_start (in minutes 0-1439)
@property
def schedule_start(self):
return self._schedule_start
@schedule_start.setter
def schedule_start(self, value):
self._schedule_start = value
pycom.nvs_set('schedule_start', value)
def fade_in(self):
self.fader.fade_in(self.r, self.g, self.b)
def fade_out(self):
self.fader.fade_out(self.r, self.g, self.b)
from machine import Pin
import pycom
import time
from machine import PWM
pwm = PWM(0, frequency=50) # use PWM timer 0, with a frequency of 50Hz
# create pwm channel on pin P12 with a duty cycle of 50%
pwm_c = pwm.channel(0, pin='P12', duty_cycle=0.15)
# initialisation code
pycom.heartbeat(False)
pycom.rgbled(0xCC8080) # pale pink
# initialize `P9` in gpio mode and make it an output
p_out = Pin('P9', mode=Pin.OUT)
p_out.value(1)
p_out.value(0)
p_out.toggle()
p_out(True)
# make `P10` an input with the pull-up enabled
p_in = Pin('P10', mode=Pin.IN, pull=Pin.PULL_UP)
p_in() # get value, 0 or 1
time.sleep(2)
while p_in() == 1:
pycom.rgbled(0x008000) # Green
time.sleep(1)
pycom.rgbled(0x000080) # Blue
time.sleep(1)
p_out.toggle()
from machine import PWM
import time
pwm = PWM(0, frequency=5000) # use PWM timer 0, with a frequency of 5KHz
# create pwm channel on pin P11 with a duty cycle of 50%
pwm_c = pwm.channel(0, pin='P11', duty_cycle=0.5)
incVal = 0.5
valToSum = 0.05
# Faz o led alterar o brilho
i = 10000000000
while i > 0:
pwm_c.duty_cycle(incVal) # change the duty cycle to 50%
time.sleep(.05)
if incVal >= 1:
valToSum = -valToSum
elif incVal <= 0:
valToSum = -valToSum
incVal += valToSum
i -= 1
"""
if __name__ == "__main__":
from machine import Pin, PWM
import socket
import url
import gc
# setup for the servo
position = 50
dutycycle = 0.07
min_dutycycle = 0.03
max_dutycycle = 0.13
pwm = PWM(0, frequency=50)
servo = pwm.channel(0, pin=Pin.exp_board.G22, duty_cycle=dutycycle)
# setup for the webserver
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind(socket.getaddrinfo('0.0.0.0', 80)[0][-1])
serversocket.listen()
while True:
conn, addr = serversocket.accept()
request = conn.readline()
print("request:", request)
conn.recv(2048)
d = url.extract(request)
enable_gate = Pin(enableA, mode=Pin.OUT)
gate_open = Pin(in2, mode=Pin.OUT)
gate_close = Pin(in1, mode=Pin.OUT)
enable_fan = Pin(enableB, mode=Pin.OUT)
fan_1 = Pin(in3, mode=Pin.OUT)
fan_2 = Pin(in4, mode=Pin.OUT)
#schakelaar voor de poort open te doen
switch = Pin(switch_pin, mode=Pin.IN)
#maak een pwm aan met timer 0 & frequentie van 5KHz
pwm = PWM(0, frequency=5000)
#creer een pwm kaneel op pin enableA met een duty cycle van 0
gate_speed = pwm.channel(0, pin=enableA, duty_cycle=0)
fan_speed = pwm.channel(0, pin=enableB, duty_cycle=0)
#deze worden niet gebruikt want de motoren bewegen pas vanaf 90% duty cycle
#de load cell amplifier
load_amp = HX711(data_pin, clk_pin)
#wordt gebruikt om de load cell waarde op null te zetten
weight_offset = 969850
def main():
#kijkt of de poort open of dicht is en sluit/opent deze als de schakelaar gebruikt wordt (zie video)
gateIsOpen = False
while True:
if (switch.value() and gateIsOpen):
# off
MIN_VALUE = 0.0
# disable bright blue blink
# https://docs.pycom.io/chapter/tutorials/all/rgbled.html
pycom.heartbeat(False)
# setup two inputs
# https://docs.pycom.io/chapter/firmwareapi/pycom/machine/Pin.html
p_in_1 = Pin('P13', mode=Pin.IN, pull=Pin.PULL_UP)
p_in_2 = Pin('P14', mode=Pin.IN, pull=Pin.PULL_UP)
# create two pwm channels for the LEDs
# https://docs.pycom.io/chapter/firmwareapi/pycom/machine/PWM.html
pwm_1 = PWM(0, frequency=100)
pwm_c_1 = pwm_1.channel(0, pin='P10', duty_cycle=1.0)
# purely decorative
pwm_c_2 = pwm_1.channel(1, pin='P11', duty_cycle=1.0)
# piggyback buzzer to channel 0 (which drives the first led)
pwm_buz = pwm_1.channel(0, pin='P9', duty_cycle=0.5)
# initialize variables
c_1_cycle = MIN_VALUE
c_2_cycle = MIN_VALUE
cstep_1 = STEP_1
cstep_2 = STEP_2
# loop
while True:
# button 1 effect
def nvs_get(key, default_value=0):
""" Get value for key from NVRAM. Create the key if it does not exist.
:param str key:
:param int default_value: value to use when creating the key
:return value int: (NVRAM can only store integers)
"""
value = pycom.nvs_get(key)
if value is None:
pycom.nvs_set(key, int(default_value))
value = int(default_value)
return value
pwm = PWM(0, frequency=25000)
channel0 = pwm.channel(0, pin="P23", duty_cycle=1.0)
channel1 = pwm.channel(0, pin="P22", duty_cycle=1.0)
lock = _thread.allocate_lock()
temp0 = 0
temp1 = 0
dutycycle = 0 # unit %, where 0 if off and 100 is full speed
max_dutycycle = nvs_get("max_dutycycle", 100) # unit = %
min_dutycycle = nvs_get("min_dutycycle", 20) # unit = %
temp_fan_on = nvs_get("temp_fan_on", 40) # unit = degrees celsius
temp_fan_max = nvs_get("temp_fan_max", 60) # unit = degrees celsius
if led_value:
if led_value == False:
pycom.rgbled(0x000000)
elif events & LoRa.TX_PACKET_EVENT:
print('LoRa packet sent')
lora.callback(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT, lora_callback)
print('creating the i2c component')
pwm = PWM(0, frequency=5000) # use PWM timer 0, with a frequency of 5KHz
# create pwm channel on pin P12 with a duty cycle of 50%
pwm_c = pwm.channel(0, pin='P22', duty_cycle=1.0)
i2c = I2C(0, I2C.MASTER) # create and init as a master
sensor0 = drivers.adafruit_sht31d.SHT31D(
i2c, address=drivers.adafruit_sht31d._SHT31_ADDRESSES[0])
#sensor1 = drivers.adafruit_sht31d.SHT31D(i2c, address=drivers.adafruit_sht31d._SHT31_ADDRESSES[1])
print('i2c component created')
while True:
print('i2c component reading')
t0 = sensor0.temperature
RH0 = sensor0.relative_humidity
#t1 = sensor1.temperature
#RH1 = sensor1.relative_humidity
value_object = {
'temperature': "{0:.2f}".format(t0),
"""
Ricezione lettura pressione di un bottone (0|1) in frequenza "locale"
inviata da un'altra board LoPy con accensione di led e buzzer
--RICEZIONE
"""
from network import LoRa
import socket
import time
import pycom
from machine import PWM
# PWM per output buzzer
pwm = PWM(0, frequency=3000)
buzzer = pwm.channel(0, pin='G9', duty_cycle=0)
# Setup del socket
lora = LoRa(mode=LoRa.LORA, frequency=868000000) # 868 MHz
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
s.setblocking(False)
# Ferma la pulsazione del led e lo spegne
pycom.heartbeat(False)
pycom.rgbled(0x000000)
while True:
if s.recv(64) == b'1':
pycom.rgbled(0xffffff) # Led acceso bianco
buzzer.duty_cycle(0.5)
elif s.recv(64) == b'0':
pycom.rgbled(0x000000) # Led spento
from machine import Pin, PWM
import time
#import random
#red = Pin('P12', mode = Pin.OUT)
#green = Pin('P11', mode = Pin.OUT)
#blue = Pin('P10', mode = Pin.OUT)
pwm_timer = PWM(0, frequency = 5000)
red_pwm = pwm_timer.channel(0, pin = 'P12', duty_cycle = 0)
green_pwm = pwm_timer.channel(1, pin = 'P11', duty_cycle = 0)
blue_pwm = pwm_timer.channel(2, pin = 'P10', duty_cycle = 0)
def flash(led):
led.toggle()
time.sleep(1)
led.toggle()
def color_cycle():
for i in range(100):
j = randint(1, 100)
red_pwm.duty_cycle((abs(j-i))/100)
time.sleep(.300)
green_pwm.duty_cycle((j)/100)
time.sleep(.300)
blue_pwm.duty_cycle((i)/100)
time.sleep(.300)
def turn_off():
red_pwm.duty_cycle(0)
# 1. Pycom documentatie: https://docs.pycom.io/firmwareapi/pycom/machine/pwm
# 2. frequency parameter and pulse LED:
# http://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/pwm.html#control-a-hobby-servo
from time import sleep
from machine import PWM
# Servo configuration: GPIO6 / 'P19' Expansion board
# Vcc = 5V, signal=3V3 (GPIO)
# Servo type TG9e - assortimentsdoos
# trial-and-error values
duty_range = [0.025, 0.05]
pwm = PWM(0, frequency=50) #servo: frequency = 50 Hz
duty_mean = (duty_range[0] + duty_range[1]) / 2
servo = pwm.channel(0, pin='P19', duty_cycle=duty_mean)
def sweep(min_duty, max_duty, dt=2):
""" sweep servo between min_duty and max_duty and waittime dt. """
while True:
servo.duty_cycle(min_duty) # one side
sleep(dt)
servo.duty_cycle(max_duty) # other side
sleep(dt)
# demo: sweep the servo...
def demo():
""" demo sweep servo until Ctrl-C."""
try:
# Function to caculate the pwm value for the angle given.
def setServoPwn(angle):
servo.duty_cycle(
((angle / 180) * 0.05) +
0.05) # calculate the right value for PWM based on the angle given
bluetooth = Bluetooth() # Get a bluetooth instance
bluetooth.set_advertisement(name='FyPi') # Set the name
bluetooth.callback(
trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb) # set up the callbacks for connect and disconnect events
bluetooth.advertise(True) # advertise the device
print("Started BLE")
srv1 = bluetooth.service(
uuid=0x1815, isprimary=True
) # set up the service to display the current angle of the servo
chr1 = srv1.characteristic(
uuid=0x2763,
value=currentAngle) # set up the characteristic to get the server angle
char1_cb = chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT,
handler=char1_cb_handler
) # set up the callback when writen to characteristic
pwm = PWM(0, frequency=50) # make a pwm provider
servo = pwm.channel(0, pin='P23',
duty_cycle=0.0) # Setup the pwm for the servo
setServoPwn(currentAngle) # Set the servo the the initial angle
class DRV8833_V2:
def __init__(self, In1_pin, In2_pin, sleep_pin, timer_number, freq,
num_channel_pwm_In1, num_channel_pwm_In2, moteur_dg,
**kwargs):
# IN1_pin : entrée PWM 1 DRV8833
# IN2_pin : entrée PWM 2 DRV8833
# sleep_pin : SLP pin pour désactiver les ponts en H du DRV8833
# timer_number : dans [0,1,2,3]. Choix du timer utilisé pour générer le signal pwm
# freq : fréquence du signal pwm
# num_channel_pwm_In1 : numéro de l'Id du canal PWM associé à la broche In1_pin
# num_channel_pwm_In2 : numéro de l'Id du canal PWM associé à la broche In2_pin
# moteur_dg : permet de différencier le moteur droit du moteur gauche
self.DRV883_Sleep_Pin = Pin(
sleep_pin, mode=Pin.OUT
) # Initialiser la broche sleep_pin pour gérer le DRV8833
self.DRV883_Sleep_Pin.value(0) # Désactive le driver DRV8833
if timer_number not in [0, 1, 2, 3]:
raise ValueError(
'Unexpected timer_number value {0}.'.format(timer_number))
self.pwm = PWM(
timer_number, frequency=freq
) # Utiliser le timer n° timer_number en PWM avec une fréquence de base de freq Hz
self.DRV8833_Pwm_In1 = self.pwm.channel(num_channel_pwm_In1,
pin=In1_pin,
duty_cycle=0.0)
self.DRV8833_Pwm_In2 = self.pwm.channel(num_channel_pwm_In2,
pin=In2_pin,
duty_cycle=0.0)
self.consigne_rotation_roue = 0.0
self.sens = SENS_HORAIRE
self.moteur_dg = moteur_dg
time.sleep(0.05)
#---------------------------------------------------------------------------
# Commande d'un moteur :
# paramètres :
# sens : sens de rotation
# consigne_rotation_roue : en tours par seconde
def Cmde_moteur(self, sens, consigne_rotation_roue):
self.DRV883_Sleep_Pin.value(0) # Désactive le driver DRV8833
self.sens = sens
if consigne_rotation_roue < 0.0:
self.consigne_rotation_roue = 0.0
elif consigne_rotation_roue > VITESSE_MAX:
self.consigne_rotation_roue = VITESSE_MAX
else:
self.consigne_rotation_roue = consigne_rotation_roue
consigne_pwm_moteur = self.ToursParSeconde_vers_PWM(
self.consigne_rotation_roue)
self.DRV883_Sleep_Pin.value(
1
) # Activer le driver DRV8833.value(1) # Activer le driver DRV8833
if self.sens == SENS_HORAIRE: # forward
self.DRV8833_Pwm_In1.duty_cycle(
consigne_pwm_moteur) # Rapport cyclique à vitesse % sur IN1
self.DRV8833_Pwm_In2.duty_cycle(
0.0) # Rapport cyclique à 0.0 sur IN2 (soit 0%)
time.sleep(0.005)
elif self.sens == SENS_ANTI_HORAIRE: # reverse
self.DRV8833_Pwm_In1.duty_cycle(
0.0) # Rapport cyclique à 0.0 sur IN1
self.DRV8833_Pwm_In2.duty_cycle(
consigne_pwm_moteur) # Rapport cyclique à vitesse % sur IN2
time.sleep(0.005)
#---------------------------------------------------------------------------
# Définitions des mouvements de base de la plateforme robotique
def Arret_moteur(self):
self.DRV883_Sleep_Pin.value(1) # Activer le driver DRV8833
self.DRV8833_Pwm_In1.duty_cycle(0.0) # Rapport cyclique à 0.0 sur IN1
self.DRV8833_Pwm_In2.duty_cycle(0.0) # Rapport cyclique à 0.0 sur IN2
self.DRV883_Sleep_Pin.value(0) # Désactive le driver DRV8833
#---------------------------------------------------------------------------
@staticmethod
def ToursParSeconde_vers_PWM(consigne_rotation_roue):
# Permet de calculer le rapport cyclique de la PWM de commande d'un moteur
# en fonction de la vitesse de rotation de la roue
# consigne_rotation_roue dans [0.0 ; 1.78] tours/s
# Valeur retournée : rapport cyclique dans [0.0 ; 1.0]
# Interpolation polynomiale : y = ax^6+bx^5+cx^4+dx^3+ex^2+fx+g avec :
# a = -0.2903
# b = 1.9281
# c = -4.6062
# d = 5.2432
# e = -2.8844
# f = 0.8839
# g = 0.0611
# Validé le 06.03.2019
coeff = (-0.2903, 1.9281, -4.6062, 5.2432, -2.8844, 0.8839, 0.0611)
y = consigne_rotation_roue * coeff[0] + coeff[1]
for i in range(1, 6):
y = consigne_rotation_roue * y + coeff[i + 1]
return y
