def api_softpwm(self, pin, command, option, req_method, req_args):
resp = copy.deepcopy(self.CHIP_INFO)
resp["connected"] = True
# Figure out our command
if command == "start" and req_method == 'GET':
# Get the arguments
duty_cycle = req_args.get('duty_cycle', 25.0)
frequency = req_args.get('frequency', 35.0)
polarity = req_args.get('polarity', 0)
# Start the SoftPWM
SPWM.start(pin, duty_cycle, frequency, polarity)
resp[
"message"] = "Setting {0} to duty cycle: {1}, frequency: {2}, and polarity {3}".format(
pin, duty_cycle, frequency, polarity)
elif command == "stop" and req_method == 'GET':
SPWM.stop(pin)
resp["message"] = "Stopping {0}".format(pin)
elif command == "cleanup" and req_method == 'GET':
SPWM.cleanup(pin)
resp["message"] = "Cleaning up {0}".format(pin)
elif command == "duty_cycle" and req_method in ['GET', 'PUT', 'POST']:
SPWM.set_duty_cycle(pin, float(option))
resp["message"] = "Changing duty cycle on {0} to {1}".format(
pin, option)
elif command == "frequency" and req_method in ['GET', 'PUT', 'POST']:
SPWM.set_frequency(pin, float(option))
resp["message"] = "Changing duty cycle on {0} to {1}".format(
pin, option)
return jsonify(resp)
def setup(): #PWM.start(channel, duty, freq=2000, polarity=0) #duty values are valid 0 (off) to 100 (on) GPIO.setup(pin_forward, GPIO.OUT) GPIO.setup(pin_back, GPIO.OUT) PWM.start(pin_pwm, 0, 800, 0) motorStop()
def test_start_pwm(self):
PWM.start("XIO-P7", 50, 10)
base = GPIO.get_gpio_base() + 7
gfile = '/sys/class/gpio/gpio%d' % base
assert os.path.exists(gfile)
direction = open(gfile + '/direction').read()
assert(direction == 'out\n')
PWM.cleanup()
def __init__(self, pin, freq=500, duty_min=49.0, duty_max=90.0, stop_on_zero=False):
self.pin = pin
self.freq = freq
self.duty_min = duty_min
self.duty_max = duty_max
self.stop_on_zero = stop_on_zero
sleep(0.1)
PWM.start(pin, 0, 500)
def test_start_pwm(self):
PWM.start("XIO-P7", 50, 10)
base = GPIO.get_gpio_base() + 7
gfile = '/sys/class/gpio/gpio%d' % base
assert os.path.exists(gfile)
direction = open(gfile + '/direction').read()
assert(direction == 'out\n')
PWM.cleanup()
def __init__(self,
pin,
freq=50,
duty_min=5,
duty_max=10,
stop_on_zero=False):
self.pin = pin
self.freq = freq
self.duty_min = duty_min
self.duty_max = duty_max
self.stop_on_zero = stop_on_zero
sleep(0.1)
PWM.start(pin, 0, freq)
def setup(self):
if not self.initialized:
# reset gpio
GPIO.cleanup(self.led)
# init gpio
pwm.start(self.led, 0, self.freq)
self.currenta_angle = 0
self.delta = self.max_value - self.min_value
self.angle_increment = (self.update_delay *
180) / (self.sweep_time * 60)
self.initialized = True
def setup(self):
if not self.initialized:
# reset gpio
GPIO.cleanup(self.red)
GPIO.cleanup(self.yellow)
# init gpio
pwm.start(self.red, 0, self.freq)
pwm.start(self.yellow, 0, self.freq)
self.initialized = True
# init variables
self.red_sweeping = False
self.red_sweep_increment = 0
self.red_duty = 0
self.red_target = 0
self.yellow_ud_percent = 0
self.yellow_cooldown = 0
def steer_left():
SPWM.start("CSID0", 50)
SPWM.set_duty_cycle("CSID0", 0)
SPWM.set_frequency("CSID0", freq)
SPWM.start("CSID1", 50)
SPWM.set_duty_cycle("CSID1", duty * 0.75)
SPWM.set_frequency("CSID1", freq)
SPWM.start("CSID2", 50)
SPWM.set_duty_cycle("CSID2", 0)
SPWM.set_frequency("CSID2", freq)
SPWM.start("CSID3", 50)
SPWM.set_duty_cycle("CSID3", duty)
SPWM.set_frequency("CSID3", freq)
def reverse():
SPWM.start("CSID0", 50)
SPWM.set_duty_cycle("CSID0", 0)
SPWM.set_frequency("CSID0", freq)
SPWM.start("CSID1", 50)
SPWM.set_duty_cycle("CSID1", duty)
SPWM.set_frequency("CSID1", freq)
SPWM.start("CSID2", 50)
SPWM.set_duty_cycle("CSID2", 0)
SPWM.set_frequency("CSID2", freq)
SPWM.start("CSID3", 50)
SPWM.set_duty_cycle("CSID3", duty)
SPWM.set_frequency("CSID3", freq)
def __init__(self):
green = 'XIO-P0'
blue = 'XIO-P1'
red = 'XIO-P2'
frequency = 100
self.green = green
self.red = red
self.blue = blue
GPIO.cleanup(red)
GPIO.cleanup(green)
GPIO.cleanup(blue)
SPWM.start(red, 0)
SPWM.set_frequency(red, frequency)
SPWM.start(green, 0)
SPWM.set_frequency(green, frequency)
SPWM.start(blue, 0)
SPWM.set_frequency(blue, frequency)
def test_pwm_start_invalid_frequency_negative(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 0, -1)
#!/usr/bin/python3
import sys, os, math, time
import CHIP_IO.SOFTPWM as PWM
i = 0
tsleep = 0.05
ttotal = 5
PWM.start("XIO-P4", 50, 100, 0)
def MachAnders(x):
#print(x)
PWM.set_duty_cycle("XIO-P4", x / 4)
if __name__ == "__main__": # Programmstart
try:
while True:
i = i + 1
x = ttotal / tsleep
x = ((math.sin(2 * math.pi * i / x) + 1) / 2) * 100
if x == 0:
x = 0.01
#print(x)
MachAnders(x)
if i > (ttotal / tsleep):
i = 0
time.sleep(tsleep)
# Beim Abbruch durch STRG+C resetten
def test_pwm_duty_cycle_invalid_value_string(self):
PWM.start("XIO-P7", 0)
with pytest.raises(TypeError):
PWM.set_duty_cycle("XIO-P7", "a")
PWM.cleanup()
def test_pwm_start_invalid_polarity_type(self):
with pytest.raises(TypeError):
PWM.start("XIO-P7", 0, 100, "1")
SPWMGPIO = "XIO-P7"
RECEIVERGPIO = "CSID0"
COUNT = 200
SLEEPTIME = 0.01
# CLEANUP THE GPIO
GPIO.cleanup()
SPWM.cleanup()
# ISSUE #16 VERIFICATION
try:
print(
"VERIFYING FIX FOR ISSUE #16, GPIO CONFIGURED THAT SPWM WANTS TO USE"
)
GPIO.setup(SPWMGPIO, GPIO.OUT)
SPWM.start(SPWMGPIO, 50, 1)
except Exception as e:
print("EXCEPTION: {}".format(e))
print("GPIO CLEANUP")
GPIO.cleanup()
# SETUP SOFTPWM
print("STARTING SOFTPWM TEST")
SPWM.start(SPWMGPIO, 50, 1)
SPWM.set_frequency(SPWMGPIO, 2)
# SETUP SOFTPWM RECEIVER
rcvr = SPWMReceiver(GPIO, RECEIVERGPIO, COUNT, SLEEPTIME)
rcvr.start()
time.sleep(COUNT * SLEEPTIME + 1)
def test_pwm_start_invalid_duty_cycle_negative(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", -1)
# Set which GPIO pins the drive outputs are connected to drive_0 = "GPIO6" drive_1 = "GPIO4" drive_2 = "GPIO2" drive_3 = "XIO-P1" PWM_0 = "LCD-VSYNC" PWM_1 = "LCD-HSYNC" # Set all of the drive pins as output pins GPIO.setup(drive_0, GPIO.OUT) GPIO.setup(drive_1, GPIO.OUT) GPIO.setup(drive_2, GPIO.OUT) GPIO.setup(drive_3, GPIO.OUT) # SoftPWM setup SPWM.start(PWM_0, 50) SPWM.start(PWM_1, 50) # Settings leftdrive = drive_0 # drive number for left motor rightdrive = drive_3 # drive number for right motor leftback = drive_1 # drive number for left motor, backwards rightback = drive_2 # drive number for right motor, backwards axisleftmotor = 1 # Joystick axis to read for up / down position axisleftmotorinverted = True # Set this to True if up and down appear to be swapped axisrightmotor = 3 # Joystick axis to read for left / right position axisrightmotorinverted = True # Set this to True if left and right appear to be swapped interval = 0.05 # Time between keyboard updates in seconds, smaller responds faster but uses more processor time drive0 = rightdrive drive1 = leftdrive
def test_pwm_frequency_invalid_value_negative(self):
PWM.start("XIO-P7", 0)
with pytest.raises(ValueError):
PWM.set_frequency("XIO-P7", -1)
PWM.cleanup()
def test_pwm_duty_cycle_invalid_value_negative(self):
PWM.start("XIO-P7", 0)
with pytest.raises(ValueError):
PWM.set_duty_cycle("XIO-P7", -1)
PWM.cleanup()
def test_pwm_start_invalid_positive_polarity(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 0, 100, 2)
def test_pwm_start_invalid_frequency_string(self):
with pytest.raises(TypeError):
PWM.start("XIO-P7", 0, "1")
import CHIP_IO.SOFTPWM as SPWM
import CHIP_IO.GPIO as GPIO
#GPIO.toggle_debug()
#SPWM.toggle_debug()
# Defining PocketCHIP IO pins
left = "XIO-P6"
right = "XIO-P7"
en_l_fw = "LCD-D3"
en_l_bw = "LCD-D4"
en_r_fw = "LCD-D5"
en_r_bw = "LCD-D6"
# # Initializing IO pins
SPWM.start(left, 0)
SPWM.start(right, 0)
GPIO.setup(en_l_fw, GPIO.OUT)
GPIO.setup(en_l_bw, GPIO.OUT)
GPIO.setup(en_r_fw, GPIO.OUT)
GPIO.setup(en_r_bw, GPIO.OUT)
# #Used for calculating
L_mag = 0
R_mag = 0
# The callback for when the client receives a CONNACK response from the server.
def on_connect(client, userdata, flags, rc):
print("Connected with result code " + str(rc))
def init_pins():
SPWM.start("CSID0", 0, 100)
SPWM.start("CSID1", 0, 100)
SPWM.start("CSID2", 0, 100)
SPWM.start("CSID3", 0, 100)
SPWM.start("CSID4", 0, 100)
SPWM.start("CSID5", 0, 100)
def test_start_pwm(self):
PWM.start("XIO-P7", 50, 10)
assert os.path.exists('/sys/class/gpio/gpio415')
direction = open('/sys/class/gpio/gpio415/direction').read()
assert direction == 'out\n'
PWM.cleanup()
def test_pwm_start_negative_polarity(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 0, 100, -1)
import CHIP_IO.GPIO as GPIO
import CHIP_IO.SOFTPWM as SPWM
import time
# Setup the pins
GPIO.setup("XIO-P0", GPIO.OUT)
GPIO.setup("XIO-P1", GPIO.OUT)
SPWM.start("XIO-P7", 100, 100, 0)
# Run the test
try:
GPIO.output("XIO-P0", GPIO.HIGH)
GPIO.output("XIO-P1", GPIO.LOW)
print("Testing duty cycle...")
# Test duty cycle
# for x in range(0,100):
# SPWM.set_duty_cycle("XIO-P7", x)
# print(x)
# time.sleep(.1)
# Test frequency
SPWM.set_duty_cycle("XIO-P7", 50)
print("Testing frequency at 50% duty")
for f in range(100, 5000, 100):
SPWM.set_frequency("XIO-P7", f)
print(f)
time.sleep(.1)
# Hold at high 50%
def test_pwm_start_invalid_polarity_type(self):
with pytest.raises(TypeError):
PWM.start("XIO-P7", 0, 100, "1")
def test_pwm_frequency_invalid_value_string(self):
PWM.start("XIO-P7", 0)
with pytest.raises(TypeError):
PWM.set_frequency("XIO-P7", "11")
PWM.cleanup()
def test_pwm_duty_cycle_invalid_value_string(self):
PWM.start("XIO-P7", 0)
with pytest.raises(TypeError):
PWM.set_duty_cycle("XIO-P7", "a")
PWM.cleanup()
def test_pwm_start_invalid_duty_cycle_high(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 101)
def test_pwm_frequency_invalid_value_string(self):
PWM.start("XIO-P7", 0)
with pytest.raises(TypeError):
PWM.set_frequency("XIO-P7", "11")
PWM.cleanup()
def test_pwm_start_invalid_frequency_negative(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 0, -1)
def test_pwm_start_invalid_pwm_key(self):
with pytest.raises(ValueError):
PWM.start("P8_25", -1)
def test_pwm_start_negative_polarity(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 0, 100, -1)
def test_pwm_start_valid_duty_cycle_max(self):
# testing an exception isn't thrown
PWM.start("XIO-P7", 100)
PWM.cleanup()
import datetime
if __name__ == "__main__":
# SETUP VARIABLES
PWMGPIO = "XIO-P7"
#PWMGPIO = "LCD-D4"
COUNT = 150
SLEEPTIME = 0.01
time.sleep(1)
# SETUP PWM
try:
print("PWM START")
#PWM.toggle_debug()
PWM.start(PWMGPIO, 50, 45, 1)
# UNCOMMENT FOR CRASH
print("PWM SET FREQUENCY")
PWM.set_frequency(PWMGPIO, 10)
# UNCOMMENT FOR CRASH
print("PWM SET DUTY CYCLE")
PWM.set_duty_cycle(PWMGPIO, 25)
#time.sleep(COUNT*SLEEPTIME + 1)
raw_input("PRESS ENTER WHEN DONE")
except:
raise
finally:
def test_pwm_start_invalid_duty_cycle_string(self):
with pytest.raises(TypeError):
PWM.start("XIO-P7", "1")
def test_pwm_start_invalid_pwm_key(self):
with pytest.raises(ValueError):
PWM.start("P8_25", -1)
def test_pwm_start_invalid_frequency_string(self):
with pytest.raises(TypeError):
PWM.start("XIO-P7", 0, "1")
def test_pwm_start_invalid_duty_cycle_negative(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", -1)
def test_pwm_start_invalid_positive_polarity(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 0, 100, 2)
def test_pwm_start_valid_duty_cycle_max(self):
# testing an exception isn't thrown
PWM.start("XIO-P7", 100)
PWM.cleanup()
def test_pwm_duty_cycle_invalid_value_negative(self):
PWM.start("XIO-P7", 0)
with pytest.raises(ValueError):
PWM.set_duty_cycle("XIO-P7", -1)
PWM.cleanup()
def test_pwm_start_invalid_duty_cycle_high(self):
with pytest.raises(ValueError):
PWM.start("XIO-P7", 101)
def test_pwm_frequency_invalid_value_negative(self):
PWM.start("XIO-P7", 0)
with pytest.raises(ValueError):
PWM.set_frequency("XIO-P7", -1)
PWM.cleanup()
def test_pwm_start_invalid_duty_cycle_string(self):
with pytest.raises(TypeError):
PWM.start("XIO-P7", "1")