def __init__(self, min_speed=50.0, flipLeft=False, flipRight=False):
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
# each motor will use seperate dma channel (not sure if completely necessary)
self.left_servo = PWM.Servo(dma_channel=0,
subcycle_time_us=self.SUBCYCLE_TIME)
self.right_servo = PWM.Servo(dma_channel=1,
subcycle_time_us=self.SUBCYCLE_TIME)
# RPIO.PWM module uses BCM GPIO numbering
self._gpio_lf = 24 # left forward
self._gpio_lr = 23 # left rear
self._gpio_rf = 22 # right forward
self._gpio_rr = 27 # right rear
# Holder for last commanded speed per motor
self.left_speed = 0
self.right_speed = 0
self.slope = math.floor(self.SUBCYCLE_TIME * (1 - min_speed/100.0) / 100.0)
self.offset = math.floor(self.SUBCYCLE_TIME * min_speed / 100.0)
if flipLeft:
self.flipLeftMotor()
if flipRight:
self.flipRightMotor()
def __init__(self, pin, location, rotation, name): #--------------------------------------------------------------------------- # The GPIO BCM numbered pin providing PWM signal for this ESC #--------------------------------------------------------------------------- self.bcm_pin = pin #--------------------------------------------------------------------------- # The location on the quad, and the direction of the motor controlled by this ESC #--------------------------------------------------------------------------- self.motor_location = location self.motor_rotation = rotation #--------------------------------------------------------------------------- # The PWM pulse width range required by this ESC in microseconds #--------------------------------------------------------------------------- self.min_pulse_width = 1000 self.max_pulse_width = 2000 #--------------------------------------------------------------------------- # The PWM pulse range required by this ESC #--------------------------------------------------------------------------- self.current_pulse_width = self.min_pulse_width self.name = name #--------------------------------------------------------------------------- # Initialize the RPIO DMA PWM #--------------------------------------------------------------------------- if not PWM.is_setup(): PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS) PWM.setup(1) # 1us increment PWM.init_channel(RPIO_DMA_CHANNEL, 3000) # 3ms carrier period PWM.add_channel_pulse(RPIO_DMA_CHANNEL, self.bcm_pin, 0, self.current_pulse_width)
def __init__(self, Chan, Upper, Lower): self.chan = Chan self.upper = Upper self.lower = Lower self.servo = PWM.Servo() PWM.set_loglevel(1) self.servo.set_servo(self.chan, self.upper)
def initGPIO(self):
if self.cnf.offline:
self.logger.info("TEST: import PWM")
self.logger.info("TEST: import MFRC522")
self.logger.info("TEST: initializing PWM")
return
# We're careful as to not import the
# RPIO itself; as it magically claims
# pin 22; thus conflicting with MFRC522.
#
import RPIO.PWM as PWM
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
PWM.setup(pulseInc)
PWM.init_channel(relayChannel, subcycle_time_us=int(1e6 / frequency))
PWM.init_channel(ledChannel, subcycle_time_us=int(
1e6 / 1)) # Cycle time in microSeconds == 1 second
# Flash top LED while we get our bearings.
#
self.setTopLED(20)
# Note: The current MFC522 library claims pin22/GPIO25
# as the reset pin -- set by the constant NRSTPD near
# the start of the file.
#
import MFRC522
MIFAREReader = MFRC522.MFRC522()
def __init__(self):
"""Initialise movement."""
PWM.setup()
#get rid of debug output
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
#pins
#i2c pins can be enabled high at boot - see http://www.raspberrypi.org/phpBB3/viewtopic.php?f=44&t=35321
self._l_enable_pin = 4
self._l_forward_pin = 3
self._l_backward_pin = 2
self._r_enable_pin = 17
self._r_forward_pin = 27
self._r_backward_pin = 22
#constants
self.LEFT = 1
self.RIGHT = 2
#setup the pins
RPIO.setup(self._l_forward_pin, RPIO.OUT)
RPIO.setup(self._r_forward_pin, RPIO.OUT)
RPIO.setup(self._l_backward_pin, RPIO.OUT)
RPIO.setup(self._r_backward_pin, RPIO.OUT)
#pwm setup
self._dma_l = 0
self._dma_r = 1
PWM.init_channel(self._dma_l)
PWM.init_channel(self._dma_r)
#this is silly, but otherwise pwm will complain if we try and clear a channel that hasn't been already used
PWM.add_channel_pulse(self._dma_l,self._l_enable_pin,0,0)
PWM.add_channel_pulse(self._dma_r,self._r_enable_pin,0,0)
def __init__(self, pin, minW = 0, maxW = 100): PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS) self.__pin = pin self.__minW = minW self.__maxW = maxW self.__servo = PWM.Servo() self.__W = 0
def __enter__(self):
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
GPIO.setup(self._gpios['solenoid'], GPIO.OUT)
GPIO.setup(self._gpios['echo_trigger'], GPIO.OUT)
GPIO.setup(self._gpios['echo'], GPIO.IN)
self._i2c_bus = SMBus()
self._i2c_bus.open(Monster.I2C_BUS_NUM)
self.close_door()
return self
def configureRPIO():
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
RPIO.setwarnings(False)
RPIO.setup(R, RPIO.OUT)
RPIO.setup(A, RPIO.OUT)
RPIO.setup(G, RPIO.OUT)
RPIO.output(R, False)
RPIO.output(A, False)
RPIO.output(G, False)
def __init__(self):
from RPIO import PWM
# Defaults for PWM.Servo, but we need to work with them
self._subcycle_time_us = 20000
self._pulse_incr_us = 10
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
self._servo = PWM.Servo(subcycle_time_us=self._subcycle_time_us,
pulse_incr_us=self._pulse_incr_us)
def init_pwm(self):
'''Initialize PWM configuration. We are using RPIO.PWM to
implement software PWM via DMA, using the PCM implementation. We
initalize three DMA channels, one for each color.'''
LOG.debug('initializting PWM configuration')
PWM.setup(delay_hw=PWM.DELAY_VIA_PCM)
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
for ch in [0, 1, 2]:
PWM.init_channel(ch)
def __init__(self):
from RPIO import PWM
# Defaults for PWM.Servo, but we need to work with them
self._subcycle_time_us = 20000
self._pulse_incr_us = 10
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
self._servo = PWM.Servo(
subcycle_time_us = self._subcycle_time_us,
pulse_incr_us = self._pulse_incr_us)
def __init__(self, channel=PWM_CHANNEL, pin=PWM_PIN, subcycle=PWM_SUBCYCLE, unit=PWM_UNIT):
self._channel = channel
self._pin = pin
self._subcycle = subcycle
self._range = int(subcycle / unit)
if not PWM.is_setup():
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
PWM.setup()
# work around bug in RPIO.PWM, https://www.raspberrypi.org/forums/viewtopic.php?p=509549
signal.signal(signal.SIGCHLD, signal.SIG_IGN)
if not PWM.is_channel_initialized(self._channel):
PWM.init_channel(self._channel, self._subcycle)
def main():
if len(sys.argv) != 2:
return
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
servo = Servo(subcycle_time_us=10000, pulse_incr_us=1)
servo.set_servo(23, int(sys.argv[1]))
servo.set_servo(24, int(sys.argv[1]))
servo.set_servo(25, int(sys.argv[1]))
servo.set_servo(8, int(sys.argv[1]))
input("hit Enber key")
servo.set_servo(23, int(1000))
servo.set_servo(24, int(1000))
servo.set_servo(25, int(1000))
servo.set_servo(8, int(1000))
input("hit Enber key")
def init_pickle(file='servo.conf', req_debug_info=0):
global debug_info, zero_pos, rico, left_val, right_val, zero_pos_man, servo, pin
debug_info = req_debug_info
# [ rico , zero_pos, left_val, right_val , manual zero , pin ]
with open(file, 'rb') as fp:
listRead = pickle.load(fp)
if listRead[4] != -1:
zero_pos_man = listRead[4]
else:
zero_pos_man = listRead[1]
zero_pos = listRead[1]
pin = listRead[5]
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
servo = PWM.Servo()
servo.set_servo(pin, int(zero_pos))
rico = listRead[0]
left_val = listRead[2]
right_val = listRead[3]
def __init__(self):
PWM.setup()
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
PWM.init_channel(0)
self.num = {
0: (1, 1, 1, 1, 1, 1, 0),
1: (0, 1, 1, 0, 0, 0, 0),
2: (1, 1, 0, 1, 1, 0, 1),
3: (1, 1, 1, 1, 0, 0, 1),
4: (0, 1, 1, 0, 0, 1, 1),
5: (1, 0, 1, 1, 0, 1, 1),
6: (1, 0, 1, 1, 1, 1, 1),
7: (1, 1, 1, 0, 0, 0, 0),
8: (1, 1, 1, 1, 1, 1, 1),
9: (1, 1, 1, 1, 0, 1, 1)
}
self.pulse = {0: 4, 1: 999}
PWM.add_channel_pulse(0, 20, 0, 999)
PWM.add_channel_pulse(0, 21, 1000, 999)
def setup():
# Setup PWM and DMA channel 0
PWM.set_loglevel(1)
print("Set loglevel\n")
# PWM.setup()
PWM.init_channel(0)
# polarity pins are outputs:
for pin in pins_pol:
RPIO.setup(pin, RPIO.OUT, initial=RPIO.LOW)
# defined as output
# all output off
for pin in pins_pwm:
# Set servo on GPIO17 to 0 us. 20ms is one PWM period.
servo.set_servo(pin, 0) #define pin as pwm output
# all magnets turned off
magnet(0, 0, 0)
magnet(1, 0, 0)
magnet(2, 0, 0)
magnet(3, 0, 0)
fo.write("Temperature: " + str(thread.temp))
fo.close()
copyfile("/var/www/js/sensors_temperature_tmp.html",
"/var/www/js/sensors_temperature.html")
time.sleep(1)
tReadMS5803 = threading.Thread(target=readMS5803)
tReadMS5803.start()
#tReadMS5803.do_run = False
import RPi.GPIO as G
G.setmode(G.BCM)
from RPIO import PWM
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
s = PWM.Servo(pulse_incr_us=1)
## Define pins for devices
## Step motor
pinStp = 21
pinDir = 20
pinSlp = 26
G.setup(pinStp, G.OUT)
G.setup(pinDir, G.OUT)
G.setup(pinSlp, G.OUT)
G.output(pinSlp, False)
## LED light
pinLED = 19
import RPIO.PWM as PWM
GPIO = 2
CHANNEL = 0
GPIO2 = 3
CHANNEL2 = 3
PWM.set_loglevel(PWM.LOG_LEVEL_DEBUG)
PWM.setup()
PWM.init_channel(CHANNEL)
PWM.print_channel(CHANNEL)
PWM.add_channel_pulse(CHANNEL, GPIO, 0, 500)
raw_input('Enter your input:')
PWM.init_channel(CHANNEL2)
PWM.print_channel(CHANNEL2)
PWM.add_channel_pulse(CHANNEL2, GPIO2, 600, 200)
raw_input('Enter your input:')
PWM.clear_channel(CHANNEL)
raw_input('Enter your input:')
PWM.clear_channel(CHANNEL2)
raw_input('Enter your input:')
#!/usr/bin/env python
import RPIO
from RPIO import PWM as PWM
import time
RPIO.setmode(RPIO.BOARD)
GPIO = 12
CHANNEL = 1
RPIO.setup(GPIO,RPIO.OUT)
# Setup PWM and DMA channel 0
PWM.set_loglevel(PWM.LOG_LEVEL_DEBUG)
PWM.setup()
PWM.init_channel(CHANNEL,20000)
PWM.print_channel(CHANNEL)
RPIO.output(GPIO, False)
def changespeed(current_speed,set_speed,step_size,delay):
for counter in range (current_speed, set_speed, step_size):
pwmmotor=int(round(counter*199,-1))
print(pwmmotor)
PWM.add_channel_pulse(CHANNEL,GPIO,0,pwmmotor)
time.sleep(delay)
# Add some pulses to the subcycle
PWM.add_channel_pulse(CHANNEL, GPIO, 0, 0)
def pwm_setup(): pwm.set_loglevel(pwm.LOG_LEVEL_ERRORS) pwm.setup(5) pwm.init_channel(0, 5000)
def io_init():
PWM.setup()
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
def io_init():
PWM.setup()
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
def pwm_setup():
pwm.set_loglevel(pwm.LOG_LEVEL_ERRORS)
pwm.setup(5)
pwm.init_channel(0, 5000)
def __init__(self, mode=0, start=False, sensors_min=7): # ignore sensor-values below sensors_min
atexit.register(self.clean)
self.lock = threading.Lock()
self.servo = PWM.Servo()
PWM.set_loglevel(1) # try to stop debug output
# initialize background-thread (not yet started)
threading.Thread.__init__(self)
# set thread-mode (if background-thread is started)
# mode: 0 = update all sensors in cycle 0-1-2-1-0-1-2-1-0-..., servo not moved
# 1 = scanning all sensors in cycle 0-1-2-1-0-1-2-1-0-..., servo scans: from left to right to left to right...
# 2 = scanning all sensors in cycle 0-1-2-1-0-1-2-1-0-..., servo scans: from left to right jump, form left to right, ...
# 3 = like mode 2, but averaging over two measurements
self.mode = mode
# set standart-Sensor- & Servo- PINS
# USE GPIO-NUMBERING, NOT BOARD-NUMBERING!
model_B = True # which model are we using? / which pins are used
# True -> Model B (Check cat /proc/cpuinfo --> Revision 000e), False -> Model B+
if model_B == True: # Model B
self.TRIG = [7, 8, 25]
self.ECHO = [11, 9, 10]
self.SERVO = 24
else: # Model B+ -> NOTE BY NEXT TEAM: USED GPIO PINS DO NOT CHANGE BETWEEN MODELS
self.TRIG = [21, 20, 16] # CAUTION! Numbering differs from old sheet....
self.ECHO = [26, 19, 13]
self.SERVO = 12
# are the pins initialized to the GPIO-Module?
self.pins_set = False
# is the background-thread running?
self.running = False
# is there a measurement ongoing?
self.is_at_measure = False
# constants for single distance-measurements
self.ECHO_in_timeout = 0.05 # max. waiting-time in seconds for echo-signal to come in
self.no_echo_in_value = -1.0 # return value if no echo is received after ECHO_in_timeout
self.out_of_sight_time = 0.05 # max. waiting-time in seconds for echo-signal-duration
# (according to data sheet: max 25ms for obstacle, exact 38ms for no-obstacle)
self.out_of_sight_value = 500.0 # return value of distance measurement after out_of_sight_time
self.dt_to_distance = 17000.0 # constant to convert time-difference to distance (standart: 17000cm/s; speed of sound/2)
self.scan_relaxation_time = 0.05 # time between single scannings in scanning-mode
self.unknown_error_value = 30000000.0 # return-value if unknown error occurs in get_sensor()
self.measure_tries = 5 # number of tries for single measurement (on no-echo-in- or unknown-error)
self.sensors_min = sensors_min # ignore sensor values below this
self.averaging_number = 3 # number of measurements for averaging in mode 3
# what are the most current distance values of the sensors and there measurement times?
# [[first_sensor, time], [[first_segment, time], [second_segment, time], ...], [third_sensor, time]]
# if you want to change servo_segment_size: update via update_segments(servo_segment_size)
self.measurements = [[0, 0], [[0, 0]], [0, 0]]
# constants for servo-positions
# CAUTION: HAS TO BE MULTIPLE OF 10!
# ALSO self.servo_segment_size HAS TO BE MULTIPLE OF 10!
# system-values
self.servo_OFFSET = 0
self.servo_NULL = 1500 + self.servo_OFFSET
self.servo_MAX = 2000 + self.servo_OFFSET
self.servo_MIN = 1000 + self.servo_OFFSET
# current position
self.servo_position = self.servo_NULL
# overall number of segments in scanning-mode & segment-size (in servo-values)
# if you want to change servo_segment_size: update via update_segments(servo_segment_size)
self.servo_segments = 10 # NOTE: There is one more measurement than segments!
self.servo_segment_size = 0
self.servo_segment_values = []
self.update_segments(0, new_segment_number=self.servo_segments)
# set servo to zero-position
self.servo.set_servo(self.SERVO, self.servo_NULL)
# initialize PINS
self.set_PINS()
# relax servos in beginning
for trig in self.TRIG:
GPIO.output(trig, False)
# start background-thread
if start:
time.sleep(0.1)
self.start()
# NOTE: SOME ERRORS MIGHT STILL COME FROM mysensors.get_sensor() # ESPECIALLY: SOME ABBORT-CRITERIA ARE DIFFICULT.... # # NOTE: No-Echo-In-Result will be returned, but not saved, # Out-Of-Sight-Result will be returned & saved # Wrong-Sensor-Number-Error will be returned, but not saved from __main__ import lg # for output-control import time import threading import RPi.GPIO as GPIO from RPIO import PWM servo = PWM.Servo() PWM.set_loglevel(1) # try to stop debug output class sensors(threading.Thread): def __init__(self, mode=0, start=False, sensors_min=7): # ignore sensor-values below sensors_min self.lock = threading.Lock() # initialize background-thread (not yet started) threading.Thread.__init__(self) # set thread-mode (if background-thread is started) # mode: 0 = update all sensors in cycle 0-1-2-1-0-1-2-1-0-..., servo not moved # 1 = scanning all sensors in cycle 0-1-2-1-0-1-2-1-0-..., servo scans: from left to right to left to right... # 2 = scanning all sensors in cycle 0-1-2-1-0-1-2-1-0-..., servo scans: from left to right jump, form left to right, ... # 3 = like mode 2, but averaging over two measurements self.mode = mode
def __init__(self, pin_list):
self.NUM_CH = len(pin_list)
self._pin_list = pin_list
self._servo = None
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
#!/usr/bin/env python
import logging
import RPIO, time, os
from RPIO import PWM
import requests
import sys
import threading
import time
logging.basicConfig(level=logging.WARN)
PWM.set_loglevel(PWM.LOG_LEVEL_ERRORS)
RPIO.setmode(RPIO.BCM)
servo = None
def decode_color(color):
if color.endswith('anime'):
return 0
elif color == 'blue':
return 1
else:
return -1
def get_config():
return { 'examplesvc' : {
'button' : 17,
'led' : 0,#4,
'status_url': "http://maria.saymedia.com/job/examplesvc/job/master/api/json?tree=color",
'action_url': "http://maria.saymedia.com/job/examplesvc/job/test-ci/build?delay=0sec"
}
}
def pwm_setup():
pwm.set_loglevel(pwm.LOG_LEVEL_ERRORS)
pwm.setup(INCREMENT_US)
pwm.init_channel(DMA_CHANNEL, 5000)
