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 __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)