def misc_init(): print("misc_init()\n") wp.wiringPiSetup() for i in range(len(misc_dev_status)): pin = misc_dev_status[i][0] wp.pinMode(pin, wp.OUTPUT) wp.digitalWrite(pin, wp.LOW)
def init(mission): global state, setpoint, run, pose, home, init global arming_client, set_mode_client #Global variable initialisation state, pose, setpoint, home = State(), PoseStamped(), Point(), Point() run = True init = True # Node initiation rospy.init_node(NODE_NAME) rospy.loginfo('node initializeed') time.sleep(1) # setting up the pins for electromagnet wpi.wiringPiSetup() wpi.pinMode(0,1) # Publishers, subscribers and services pose_sub = rospy.Subscriber('/mavros/local_position/pose', PoseStamped, Pose_Callback) state_sub = rospy.Subscriber('/mavros/state', State, State_Callback) rospy.wait_for_service('mavros/set_mode') set_mode_client = rospy.ServiceProxy('mavros/set_mode', SetMode) rospy.wait_for_service('mavros/cmd/arming') arming_client = rospy.ServiceProxy('mavros/cmd/arming', CommandBool) # Thread to send setpoints - mission execution tSetPoints = Thread(target=sendSetpoint,args=(mission,)).start() # Monitor security while not rospy.is_shutdown(): InterfaceKeyboard()
def Change_Gpio_Mode(pin, mode): wiringpi.wiringPiSetup() if mode == 1: wiringpi.pinMode(pin, wiringpi.OUTPUT) else: wiringpi.pinMode(pin, wiringpi.INPUT) return (0)
def __init__(self, gpio=0): global _linearEncoder # singleton if _linearEncoder is not None: raise Exception("Already created!") _linearEncoder = weakref.ref(self) # safety self.lock = threading.Lock() # tracking self.prevSampleTime = 0 self.prevNumPulses = 0 self.numPulses = 0 # calibrations self.Calibration = calibration_pb2.Calibration() self.calMiles = None self.calDurationSec = None self.calRevolutions = None self.calRevToMilesScale = 0.0 # GPIO wiringpi.wiringPiSetup() self.gpio = gpio wiringpi.wiringPiISR(self.gpio, wiringpi.INT_EDGE_FALLING, LinearEncoder._myInterrupt) wiringpi.piHiPri(99)
def main(): # setup wiringpi wipi.wiringPiSetup() # wPi 9 corresponds to Pin 5 WPI_PORT = 9 # time delay in milliseconds T = 0.05 # 0.05 ~ 50 ms # '1' means output wipi.pinMode(WPI_PORT, 1) # initial state state = 1 print("blinking Pin 5") while True: # blink wipi.digitalWrite(WPI_PORT, state) # waiting time.sleep(T) # switch state state = not state
def __init__(self, bname, bport, num_channels): super(mcp23017, self).__init__(bname, bport, num_channels) # set the pin base for this i2c device, it doesn't matter which # mcp device get which set of pin numbers- it's all internal to # this driver. externally, we use 0-15 global pin_base self.pin_base = pin_base pin_base += 16 # convert the 'port' to the device i2c address # port should be defined with leading '0x' i2c_addr = int(bport, 0) # initialise wiringpi and setup mcpdriver for device wiringpi.wiringPiSetup() wiringpi.mcp23017Setup(self.pin_base, i2c_addr) self.channel_dirs = dict() self.channel_sense = dict() self.channel_configured = dict() # initialise all gpio as inputs first of all for pin in range(self.pin_base, 16): wiringpi.pinMode(pin, INPUT_PIN)
def Init_Drive_ESC(): global l_drive l_drive = 0 global r_drive r_drive = 0 wiringpi.wiringPiSetup() global Motor1PWM Motor1PWM = 1 # gpio pin 12 = wiringpi no 1 (BCM 18) global Motor1AIN1 Motor1AIN1 = 4 # gpio pin 16 = wiringpi no. 4 (BCM 23) global Motor1AIN2 Motor1AIN2 = 5 # gpio pin 18 = wiringpi no. 5 (BCM 24) global MotorStandby MotorStandby = 6 # gpio pin 22 = wiringpi no. 6 (BCM 25) global Motor2PWM Motor2PWM = 23 # gpio pin 33 = wiringpi no. 23 (BCM 13) global Motor2AIN1 Motor2AIN1 = 21 # gpio pin 29 = wiringpi no. 21 (BCM 5) global Motor2AIN2 Motor2AIN2 = 22 # gpio pin 31 = wiringpi no. 22 (BCM 6) wiringpi.pinMode(Motor1PWM, 2) # PWM mode wiringpi.pinMode(Motor1AIN1, 1) # Digital out mode wiringpi.pinMode(Motor1AIN2, 1) # Digital out mode # wiringpi.pinMode(MotorStandby, 1) # Ditial out mode wiringpi.pinMode(Motor2PWM, 2) # PWM mode wiringpi.pinMode(Motor2AIN1, 1) # Digital out mode wiringpi.pinMode(Motor2AIN2, 1) # Digital out mode
def main(): plogger = init_logger('rasptea1.player') # init WiringPi wp.wiringPiSetup() # set pin 4 to input mode wp.pinMode(4, 0) # keep player status playerActive = False # infinite loop while True: try: # read sensor state motionState = wp.digitalRead(4) if motionState == 1 and not playerActive: player = subprocess.Popen( ['omxplayer', '-o', 'local', AUDIOFILE], stdout=subprocess.PIPE, stderr=subprocess.PIPE) plogger.info('Player started') playerActive = True # wait for audio played completely player.wait() plogger.info('Player stopped') playerActive = False except Exception as e: plogger.error('Player error in loop occured %s' % (e, )) # wait for 100 ms wp.delay(100)
def gpioSetup(): # Access global variables global dcRange global clockDivisor global pwm global pwm2 try: # Setup board pin layout wiringpi.wiringPiSetup() wiringpi.pinMode(1, wiringpi.PWM_OUTPUT) GPIO.setmode(GPIO.BCM) GPIO.setup(13, GPIO.OUT) GPIO.setup(19, GPIO.OUT) pwm = GPIO.PWM(13, 1000) # Set output to mark:space mode (to avoid frequency change) wiringpi.pwmSetMode(wiringpi.PWM_MODE_MS) # Set output to approximately 100 kHz wiringpi.pwmSetClock(2) wiringpi.pwmSetRange(dcRange) # Initialize duty cycles wiringpi.pwmWrite(1, 0) pwm.start(50) # pwmWrite requires numbers in range [0, dcRange] finally: print("Completed setup")
def __init__(self): if GpioController.__instance != None: raise Exception('Do not call GpioController() directly. Use static get_instance') else: GpioController.__instance = self wpi.wiringPiSetup()
def main(): delay = 1E-2 # seconds # set up pins wiringpi.wiringPiSetup() for pin in pinsA: wiringpi.pinMode( pin, 1 ) for pin in pinsB: wiringpi.pinMode( pin, 1 ) for pin in pinsOut: wiringpi.pinMode( pin, 0 ) wiringpi.pinMode( isSignedPin, 1 ) wiringpi.pinMode( isSupportedPin, 0 ) numFails = testUnsigned(delay) numFails += testSigned(delay) # magic for coloured printing from https://pythonadventures.wordpress.com/2011/03/16/print-colored-text-in-terminal/ colorred = "\033[01;31m{0}\033[00m" colorgrn = "\033[1;36m{0}\033[00m" if numFails > 0: print colorred.format("%d tests were failed" % numFails) else: print colorgrn.format("All tests passed")
def setupPWM(motor11, motor12, motor21, motor22, motor31, motor32, motor41, motor42): # setup wiringpi and pwm outputs wiringpi.wiringPiSetup() wiringpi.pinMode(motor11, 1) wiringpi.pinMode(motor12, 1) wiringpi.pinMode(motor21, 1) wiringpi.pinMode(motor22, 1) wiringpi.pinMode(motor31, 1) wiringpi.pinMode(motor32, 1) wiringpi.pinMode(motor41, 1) wiringpi.pinMode(motor42, 1) wiringpi.pwmSetMode(wiringpi.PWM_MODE_MS) wiringpi.pwmSetClock(2) wiringpi.pwmSetRange(1000) wiringpi.softPwmCreate(motor11, 0, 100) wiringpi.softPwmCreate(motor12, 0, 100) wiringpi.softPwmCreate(motor21, 0, 100) wiringpi.softPwmCreate(motor22, 0, 100) wiringpi.softPwmCreate(motor31, 0, 100) wiringpi.softPwmCreate(motor32, 0, 100) wiringpi.softPwmCreate(motor41, 0, 100) wiringpi.softPwmCreate(motor42, 0, 100) wiringpi.softPwmWrite(motor11, 100) wiringpi.softPwmWrite(motor12, 100) wiringpi.softPwmWrite(motor21, 100) wiringpi.softPwmWrite(motor22, 100) wiringpi.softPwmWrite(motor31, 100) wiringpi.softPwmWrite(motor32, 100) wiringpi.softPwmWrite(motor41, 100) wiringpi.softPwmWrite(motor42, 100)
def setup(): wpi.wiringPiSetup() wpi.pinMode(pCLK, wpi.INPUT) wpi.pinMode(pDT, wpi.INPUT) wpi.pinMode(pSW, wpi.INPUT) wpi.pullUpDnControl(pSW, wpi.PUD_UP) rotaryClear()
def setup(): wiringpi.wiringPiSetup() global boiler global tr2 global valves global call_for_heats global ufh_pump boiler = Boiler.Boiler() tr2 = TR2.TR2() zv1 = zonevalve.ZoneValve(1, zone_valve_state_changed) zv2 = zonevalve.ZoneValve(2, zone_valve_state_changed) zv3 = zonevalve.ZoneValve(3, zone_valve_state_changed) valves = {'ufh': zv1, 'downstairs':zv2, 'upstairs': zv3} cfh1 = cfh.CFH(1,cfh_state_changed) cfh2 = cfh.CFH(2,cfh_state_changed) cfh3 = cfh.CFH(3,cfh_state_changed) call_for_heats = {'kitchen':cfh1, 'lounge': cfh2, 'landing': cfh3} ufh_pump = relays.Relay(0) # boiler.set_temp(2000) boiler.off() for v in valves: valves[v].close()
def output_to_MC(self, data=list, baudrate=int): length = len(data) #Checks if the list is of length 4. If it isn't, immediately return if(length!=4): print("Invalid list size. Needed size of 4, you provided a list whose size is {}".format(length)) return wiringpi.wiringPiSetup() #opens the Raspberry Pi's UART port, w/ a data transfer rate of #115200 bits/s serial = wiringpi.serialOpen('/dev/ttyS0', baudrate) #sleep a few seconds to make sure the port opens and sets connections #properly sleep(2) #signals to start data transmission, uses start of header char wiringpi.serialPuts(serial, chr(1).encode('ascii')) wiringpi.serialPuts(serial, data[0].encode('ascii')) for index in range(1, length, 1): #signals that the next data is being sent, uses start of text char wiringpi.serialPuts(serial, chr(2).encode('ascii')) #write the string data, as ascii, to the Raspberry Pi wiringpi.serialPuts(serial, data[index].encode('ascii')) #signals that data transmission is ending, uses end of transmission char wiringpi.serialPuts(serial, chr(4).encode('ascii')) #closes the serial port wiringpi.serialClose(serial) return
def __init__(self, dev=(0,0),speed=4000000, brightness=256, contrast=CONTRAST): self.spi = spidev.SpiDev() self.speed = speed self.dev = dev self.spi.open(self.dev[0],self.dev[1]) self.spi.max_speed_hz=self.speed # Set pin directions. self.dc = DC self.rst = RST wiringpi.wiringPiSetup() for pin in [self.dc, self.rst]: wiringpi.pinMode(pin, 1) self.contrast=contrast self.brightness=brightness # Toggle RST low to reset. wiringpi.digitalWrite(self.rst, OFF) time.sleep(0.100) wiringpi.digitalWrite(self.rst, ON) # Extended mode, bias, vop, basic mode, non-inverted display. wiringpi.digitalWrite(self.dc, OFF) self.spi.writebytes([0x21, 0x14, self.contrast, 0x20, 0x0c]) # cls() self.ledpin = LED if self.ledpin == 1: wiringpi.pinMode(self.ledpin, 2) wiringpi.pwmWrite(self.ledpin, self.brightness) else: wiringpi.pinMode(self.ledpin, 1) wiringpi.digitalWrite(self.ledpin, ON)
def io_setup(): wiringpi.wiringPiSetup() # initialise wiringpi in native pin mode # bteak beam sensor wiringpi.pinMode(15, 0) # sets GPIO14 to input wiringpi.pullUpDnControl(15, 2) # set internal pull-up # Relay boards wiringpi.pinMode(0, 1) # sets GPIO0 to output wiringpi.pinMode(2, 1) # sets GPIO2 to output wiringpi.pinMode(3, 1) # sets GPIO3 to ouput # expander IO pin_base = 65 # lowest available starting number is 65 i2c_addr = 0x20 # A0, A1, A2 pins all wired to GND wiringpi.mcp23017Setup(pin_base, i2c_addr) # set up the pins and i2c address # Note: MCP23017 has no internal pull-down, so we use pull-up instead and a NC contact to GND wiringpi.pinMode(65, 0) # sets GPA0 to input wiringpi.pullUpDnControl(65, 2) # set internal pull-up wiringpi.pinMode(66, 0) # sets GPA1 to input wiringpi.pullUpDnControl(66, 2) # set internal pull-up # Our second chip is now ready to use pins 81 (GPA0) – 96 (GPB7). wiringpi.mcp23017Setup(81, 0x21)
def __init__(self, gpioexp_address=GPIO_EXPANDER_DEFAULT_I2C_ADDRESS): # Setup I2C interface for accelerometer and magnetometer. wp.wiringPiSetup() self._i2c = wp.I2C() self._io = self._i2c.setupInterface( '/dev/i2c-' + str(getPiI2CBusNumber()), gpioexp_address)
def raspberry_node1_moving(self): wiringpi.wiringPiSetup() wiringpi.pinMode(1, 1) wiringpi.pinMode(2, 1) wiringpi.pinMode(3, 1) wiringpi.pinMode(4, 1) #wiringpi.softPwmCreate(2, 0, 100);wiringpi.softPwmCreate(3, 0, 100);wiringpi.softPwmCreate(4, 0, 100) while not rospy.is_shutdown(): if self.X == 1: wiringpi.digitalWrite(1, 1) wiringpi.digitalWrite(2, 0) wiringpi.digitalWrite(3, 1) wiringpi.digitalWrite(4, 0) self.pub.publish( "From Raspberry_node1: Forward Done with success") elif self.X == -1: wiringpi.digitalWrite(1, 0) wiringpi.digitalWrite(2, 1) self.pub.publish( "From Raspberry_node1: Backward Done with success") #print("hi") if self.X_angular == 1: #wiringpi.softPwmWrite(1, 100) # Change PWM duty cycle self.pub.publish("From Raspberry_node1: Done with success") self.rate.sleep()
def init_steppers(): #current_units.x = 0.0; #current_units.y = 0.0; #current_units.z = 0.0; #target_units.x = 0.0; #target_units.y = 0.0; #target_units.z = 0.0; #-----------引脚初始化--------# gpio.wiringPiSetup() #初始化 gpio.pinMode(X_STEP_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(X_DIR_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(X_ENABLE_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(X_MIN_PIN, GPIO.INPUT) # 把pin25设置为输入模式 gpio.pinMode(X_MAX_PIN, GPIO.INPUT) # 把pin25设置为输入模式 gpio.pinMode(Y_STEP_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(Y_DIR_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(Y_ENABLE_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(Y_MIN_PIN, GPIO.INPUT) # 把pin25设置为输入模式 gpio.pinMode(Y_MAX_PIN, GPIO.INPUT) # 把pin25设置为输入模式 gpio.pinMode(Z_STEP_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(Z_DIR_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(Z_ENABLE_PIN, GPIO.OUTPUT) # 把pin25设置为输出模式 gpio.pinMode(Z_MIN_PIN, GPIO.INPUT) # 把pin25设置为输入模式 gpio.pinMode(Z_MAX_PIN, GPIO.INPUT) # 把pin25设置为输入模式 gpio.digitalWrite(X_ENABLE_PIN, GPIO.LOW) #pin25输出为高电平 gpio.digitalWrite(Y_ENABLE_PIN, GPIO.LOW) #pin25输出为高电平 gpio.digitalWrite(Z_ENABLE_PIN, GPIO.LOW) #pin25输出为高电平
def __init__(self, connector): # *** User variables *** self.drive_motor_forward_pin = 5 self.drive_motor_reverse_pin = 6 self.turn_motor_left_pin = 2 self.turn_motor_right_pin = 3 self.pwm0_pin = 1 self.clock_pin = 7 self.led_one_pin = 4 # Serial depends on how PyBluez sets it up, but it's usually this self.serial_dev = "/dev/ttyAMA0" self.serial_baud = 9600 # Internal setup self.rc = connector self.rc.setBlocking(True) wiringpi.wiringPiSetup() self.serial = wiringpi.serialOpen(self.serial_dev, self.serial_baud) wiringpi.pinMode(self.drive_motor_forward_pin, 1) wiringpi.pinMode(self.drive_motor_reverse_pin, 1) wiringpi.pinMode(self.turn_motor_left_pin, 1) wiringpi.pinMode(self.turn_motor_right_pin, 1) # Just output a constant high on drive PWM for now... wiringpi.pinMode(self.pwm0_pin, 1) wiringpi.digitalWrite(self.pwm0_pin, 1)
def initialize(): """Set pins as outputs and start all lights in the off state.""" wiringpi.wiringPiSetup() enable_device() set_pins_as_outputs() turn_off_lights()
def init(HOSTNAME): global main # setup LED control and door sensor #io_init() wpi.wiringPiSetup() # global network network = network_init( hostname=HOSTNAME, role="server", discovery_multicastGroup=settings.discovery_multicastGroup, discovery_multicastPort=settings.discovery_multicastPort, discovery_responsePort=settings.discovery_responsePort, pubsub_pubPort=settings.pubsub_pubPort, message_callback=network_message_handler, status_callback=network_status_handler) network.subscribe_to_topic("system") # subscribe to all system messages network.subscribe_to_topic("found_beer") network.subscribe_to_topic("update_complete") network.subscribe_to_topic("image_capture_from_camera_unit") network.subscribe_to_topic("client_monitor_response") network.subscribe_to_topic("receive_image_overlay") network.subscribe_to_topic("receive_image_data") network.subscribe_to_topic("classification_data_to_conductor") main = Main(network) return main
def __init__(self, оctoliner_address=OCTOLINER_DEFAULT_I2C_ADDRESS): # Setup I2C interface for accelerometer and magnetometer. wp.wiringPiSetup() self._i2c = wp.I2C() self._io = self._i2c.setupInterface( '/dev/i2c-' + str(getPiI2CBusNumber()), оctoliner_address) self._i2c.write(self._io, OCTOLINER_RESET)
def run(self): logging.info(__name__ + ":initializing WiringPi2") wiringpi.wiringPiSetup() localNode = Node.local localEvent = Event(0,localNode.id,localNode.devStr,localNode.devNum,[]) localEvent.values = [0]*len(Sensor.instances) lastReport = time.time() lastRead = 0.0 sigChange = False needToReport = False while not self.cancelled: now = time.time() if now - lastRead > localNode.monitorInterval: #Read all sensors and schedule their updates and reporting lastRead = now for key in Sensor.instances: sigChange |= Sensor.instances[key].update() # read sensor if sigChange or (now - lastReport) > localNode.reportInterval: for i,sensor in enumerate(self.sensors): localEvent.values[i] = round(sensor.report()*10) localEvent.time = now evt = localEvent.tuple() logging.debug(__name__ + "Local event:" + str(evt)) localNode.eventlog.qEvent(evt) needToReport = True sigChange = False if needToReport and (now - lastReport) > localNode.minServerEventInterval: localNode.server.qEvent(evt) logging.debug(__name__+":logged event for-"+str(evt)) lastReport = now needToReport = False time.sleep(max(0, min(2, lastRead + localNode.monitorInterval - now, lastReport + localNode.reportInterval - now)))
def __init__(self,i1,i2,i3,i4): w.wiringPiSetup() self.inp=[i1,i2,i3,i4] w.pinMode(i1,w.OUTPUT) w.pinMode(i2,w.OUTPUT) w.pinMode(i3,w.OUTPUT) w.pinMode(i4,w.OUTPUT) w.digitalWrite(i1,0) w.digitalWrite(i2,0) w.digitalWrite(i3,0) w.digitalWrite(i4,0) self.numstep=0 self.half=[] self.half.append([1,0,0,1]) # setp 0 self.half.append([1,0,0,0]) # step 1 self.half.append([1,1,0,0]) # step 2 self.half.append([0,1,0,0]) # step 3 self.half.append([0,1,1,0]) # step 4 self.half.append([0,0,1,0]) # step 5 self.half.append([0,0,1,1]) # step 6 self.half.append([0,0,0,1]) # step 7 self.acc= 500 # passi self.dec= 500 # passi self.actspeed=0 self.t=threading.Thread(target=self.update_pos) self.t.start() time.sleep(1) self.update=False
def getval(self): tl = [] tb = [] wiringpi.wiringPiSetup() wiringpi.pinMode(self.owpin, 1) wiringpi.digitalWrite(self.owpin, 1) wiringpi.delay(1) wiringpi.digitalWrite(self.owpin, 0) wiringpi.delay(25) wiringpi.digitalWrite(self.owpin, 1) wiringpi.delayMicroseconds(20) wiringpi.pinMode(self.owpin, 0) while (wiringpi.digitalRead(self.owpin) == 1): pass for i in range(45): tc = wiringpi.micros() while (wiringpi.digitalRead(self.owpin) == 0): pass while (wiringpi.digitalRead(self.owpin) == 1): if wiringpi.micros() - tc > 500: break if wiringpi.micros() - tc > 500: break tl.append(wiringpi.micros() - tc) tl = tl[1:] for i in tl: if i > 100: tb.append(1) else: tb.append(0) return tb
def __init__(self, LATCH, CLCK, SER, PWM1=None, PWM2=None, PWM3=None, PWM4=None): wiringpi.wiringPiSetup() self.LATCH = LATCH wiringpi.pinMode(self.LATCH, 1) self.CLCK = CLCK wiringpi.pinMode(self.CLCK, 1) self.SER = SER wiringpi.pinMode(self.SER, 1) self.pwmPins = [] self.pwmPins.append(PWM1) # index 0 self.pwmPins.append(PWM2) self.pwmPins.append(PWM3) self.pwmPins.append(PWM4) self.motors = [] for motorNum in range(0, 4): if self.pwmPins[motorNum] is not None: self.motors.append(Motor(motorNum+1, 0, None, self.pwmPins[motorNum])) else: self.motors.append(None) self.allDirections = 0 if PWM1 is not None: self.PWM1 = PWM1 wiringpi.pinMode(self.PWM1, 1) if PWM2 is not None: self.PWM2 = PWM2 wiringpi.pinMode(self.PWM2, 1) if PWM3 is not None: self.PWM3 = PWM3 wiringpi.pinMode(self.PWM3, 1) if PWM4 is not None: self.PWM4 = PWM4 wiringpi.pinMode(self.PWM4, 1)
def __init__(self): print "Hello from ccraspberry" wiringpi.wiringPiSetup() wiringpi.pinMode(self.pinDC, GPIO.OUTPUT) wiringpi.pinMode(self.pinDD, GPIO.OUTPUT) wiringpi.pinMode(self.pinRST, GPIO.OUTPUT) wiringpi.pinMode(self.pinSEND, GPIO.OUTPUT) wiringpi.digitalWrite(self.pinDC, GPIO.LOW) wiringpi.digitalWrite(self.pinDD, GPIO.LOW) wiringpi.digitalWrite(self.pinRST, GPIO.LOW) wiringpi.digitalWrite(self.pinSEND, GPIO.HIGH) # Default CCDebug instruction set for CC254x self.instr[INSTR_VERSION] = 1 self.instr[I_HALT] = 0x40 self.instr[I_RESUME] = 0x48 self.instr[I_RD_CONFIG] = 0x20 self.instr[I_WR_CONFIG] = 0x18 self.instr[I_DEBUG_INSTR_1] = 0x51 self.instr[I_DEBUG_INSTR_2] = 0x52 self.instr[I_DEBUG_INSTR_3] = 0x53 self.instr[I_GET_CHIP_ID] = 0x68 self.instr[I_GET_PC] = 0x28 self.instr[I_READ_STATUS] = 0x30 self.instr[I_STEP_INSTR] = 0x58 self.instr[I_CHIP_ERASE] = 0x10 self.enter()
def main (): # states STATES = {'OFF': 0, 'ON': 1 } # wPi 9 corresponds to Pin 5 WPI_PORT = 9; # time delay in milliseconds T = 0.05 # 0.05 ~ 50 ms wipi.wiringPiSetup () # '1' means output wipi.pinMode ( WPI_PORT, 1 ) # initial state state = STATES [ 'ON' ] print ( "blinking pin 5" ) print ( "To finish press: 'Ctrl + c'" ) try: while True: # blink wipi.digitalWrite ( WPI_PORT, state ) # waiting time.sleep ( T ) # switch state state = not state except KeyboardInterrupt: wipi.digitalWrite ( WPI_PORT, STATES [ 'OFF' ] ) print ( "\nprogram is closing..." ) sys.exit ( 0 )
def main(): """ Main function """ wp.wiringPiSetup() datasocket = DateDataPullSocket('furnaceroom_controller', ['temperature', 'setpoint', 'dutycycle', 'pid_p', 'pid_i'], timeouts=999999, port=9000) datasocket.start() pushsocket = DataPushSocket('furnaceroom_push_control', action='store_last') pushsocket.start() power_calculator = PowerCalculatorClass(datasocket, pushsocket) power_calculator.daemon = True power_calculator.start() heater = HeaterClass(power_calculator, datasocket) heater.start() tui = CursesTui(heater) tui.daemon = True tui.start() # make sure tui close down properly and the T setpoint is put low. try: while not heater.quit: time.sleep(1) except KeyboardInterrupt: print("Keyboard Interrupt detected, closing program") heater.quit = True finally: power_calculator.quit = True time.sleep(0.1) tui.stop()
def setup(self): GPIO.setup(self.GPIO_PWM, GPIO.OUT) GPIO.setup(self.GPIO_control1, GPIO.OUT) GPIO.setup(self.GPIO_control2, GPIO.OUT) wiringpi.wiringPiSetup() wiringpi.pinMode(self.WIRING_PIN, 1) wiringpi.softPwmCreate(self.WIRING_PIN, 0, 100)
def init_wiringpi(sCon): wiringpi.wiringPiSetup() wiringpi.pinMode(sCon.mosipin, 1) wiringpi.pinMode(sCon.misopin, 0) wiringpi.pinMode(sCon.clkpin, 1) wiringpi.pinMode(sCon.cspin, 1) wiringpi.pullUpDnControl(sCon.misopin, 0)
def init(): GPIO.wiringPiSetup() GPIO.pinMode(pinLed, 0) # sets WP pin 6 to input GPIO.pinMode(pinPwr, 1) GPIO.pinMode(pin1Cup, 1) GPIO.pinMode(pin2Cup, 1) # mise à 1 de tous les boutons GPIO.digitalWrite(pinPwr, GPIO.GPIO.HIGH) GPIO.digitalWrite(pin1Cup, GPIO.GPIO.HIGH) GPIO.digitalWrite(pin2Cup, GPIO.GPIO.HIGH)
def setup(): # Set pin directions. wiringpi.wiringPiSetup() for pin in [DC, RST]: wiringpi.pinMode(pin, ON) wiringpi.pinMode(LED,2) wiringpi.pwmWrite(LED,128) spi.open(0,0) spi.max_speed_hz=5000000
def setup(self): """ Setup to use the GPIO. """ wiringpi.wiringPiSetup() # setup the wiringPi library self.A = self.DigitalInputPin(0) # the rotary encorder A self.B = self.DigitalInputPin(1) # the rotary encorder B self.RED = self.LED(2) # the LED on the rotary encorder RED self.GREEN = self.LED(3) # the LED on the rotary encorder GREEN self.SW = self.DigitalInputPin(4) # the push switch on the rotary encorder self.A.pullUp() # set default level HIGH self.B.pullUp() # set default level HIGH self.SW.pullUp() # set default level HIGH
def __init__(self, valves, pullsocket, pushsocket): threading.Thread.__init__(self) wp.wiringPiSetup() time.sleep(1) for index in range(0, 21): # Set GPIO pins to output wp.pinMode(index, 1) wp.digitalWrite(index, 0) # Now that all output are low, we can open main safety output wp.digitalWrite(20, 1) self.pullsocket = pullsocket self.pushsocket = pushsocket self.running = True self.valves = valves
def create( self ): # Addresses: 0x20, 0x21, 0x22 # Setup WIRING PI in Pin Mode wiringpi.wiringPiSetup() # Setup the chips wiringpi.mcp23017Setup( 65, 0x20 ) wiringpi.mcp23017Setup( 81, 0x21 ) wiringpi.mcp23017Setup( 97, 0x22 ) # Setup pins on the I2C Controller chip for x in range( 65, 114 ): wiringpi.pinMode( x, 1 ) # Set pin to output wiringpi.digitalWrite( x, 1 ) # Set pin to off
def main(): if wp.wiringPiSetup() == -1: print ("Unable to start wiringPi") sys.exit(1) if wp.wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1: print ("wiringPiSPISetup Failed") sys.exit(1) wp.pinMode(CS_MCP3208, wp.OUTPUT) while 1: t = time.time() vt = read_adc(0) R = (10000*vt)/(5-vt) vt = 5*R/(R+10000) temp = -0.3167*(vt**6) + 4.5437*(vt**5) - 24.916*(vt**4) + 63.398*(vt**3) - 67.737*vt*vt - 13.24*vt + 98.432 vh = read_adc(1) humidity = (((vh/5.0)-0.16)/0.0062)/(1.0546-0.00216*temp) print('{} Temp={}C, Humid={}%'.format(t, temp, humidity)) data = 'rasptest temp={},hum={} {:d}'.format(temp, humidity, int(t * (10**9))) print("Send data to DB") r = requests.post('http://192.168.1.231:8086/write', auth=('mydb', 'O7Bf3CkiaK6Ou8eqYttU'), params={'db': 'mydb'}, data=data) print("Return status: {}", r.status_code) time.sleep(30)
def setup_gpio(): wiringpi.wiringPiSetup() # Set pin directions. # outputs : for pin in [DIN, SCLK, DC, RST, SCE]: wiringpi.pinMode(pin, OUT) # inputs : for pin in [UP, RIGHT, DOWN, LEFT, SELECT]: wiringpi.pinMode(pin, IN) # enable pull downs for the switches wiringpi.pullUpDnControl(UP, wiringpi.PUD_DOWN) wiringpi.pullUpDnControl(RIGHT, wiringpi.PUD_DOWN) wiringpi.pullUpDnControl(DOWN, wiringpi.PUD_DOWN) wiringpi.pullUpDnControl(LEFT, wiringpi.PUD_DOWN) wiringpi.pullUpDnControl(SELECT, wiringpi.PUD_DOWN) wiringpi.pinMode(LED,2) # pwm mode wiringpi.pwmWrite(LED,128) # mid-level
def __init__(self, CS1, CS2, E, RS, D0, D1, D2, D3, D4, D5, D6, D7, PWM): self.CS1 = CS1 self.CS2 = CS2 self.E = E self.RS = RS self.D0 = D0 self.D1 = D1 self.D2 = D2 self.D3 = D3 self.D4 = D4 self.D5 = D5 self.D6 = D6 self.D7 = D7 self.PWM = PWM # initialize new framebuffer self.myFrameBuffer = Framebuffer() # setup wiringPi for backlight PWM wiringpi.wiringPiSetup() wiringpi.pinMode(self.PWM,2) # setup wiringPi pin for PWM GPIO.setmode(GPIO.BCM) GPIO.setup(self.CS1, GPIO.OUT, initial=0) GPIO.setup(self.CS2, GPIO.OUT, initial=0) GPIO.setup(self.E, GPIO.OUT, initial=0) GPIO.setup(self.RS, GPIO.OUT, initial=1) GPIO.setup(self.D0, GPIO.OUT, initial=0) GPIO.setup(self.D1, GPIO.OUT, initial=0) GPIO.setup(self.D2, GPIO.OUT, initial=0) GPIO.setup(self.D3, GPIO.OUT, initial=0) GPIO.setup(self.D4, GPIO.OUT, initial=0) GPIO.setup(self.D5, GPIO.OUT, initial=0) GPIO.setup(self.D6, GPIO.OUT, initial=0) GPIO.setup(self.D7, GPIO.OUT, initial=0) sleep(self.DELAY_E) self.turnOn() self.setStartLine(0) self.clearScreen() self.setPage(0) # start on top left self.setAddress(1)
def main(): context = zmq.Context() socket = context.socket(zmq.SUB) socket.setsockopt(zmq.SUBSCRIBE, '') socket.connect('tcp://192.168.2.1:7777') wiringpi.wiringPiSetup() wiringpi.softPwmCreate(RED_PIN, 0, 255) wiringpi.softPwmCreate(GREEN_PIN, 0, 255) wiringpi.softPwmCreate(BLUE_PIN, 0, 255) while True: rgb = int(socket.recv()) red = (rgb >> 16) & 0xFF green = (rgb >> 8) & 0xFF blue = rgb & 0xFF wiringpi.softPwmWrite(RED_PIN, red) wiringpi.softPwmWrite(GREEN_PIN, green) wiringpi.softPwmWrite(BLUE_PIN, blue)
def __init__(self, dev=(0,0),speed=5000000, brightness=256, contrast=0xc0): self.spi = spidev.SpiDev() self.speed = speed self.dev = dev self.spi.open(self.dev[0],self.dev[1]) self.spi.max_speed_hz=self.speed spiConfig() # Set pin directions. self.dc = DC self.rst = RST wiringpi.wiringPiSetup() for pin in [self.dc, self.rst]: wiringpi.pinMode(pin, 1) self.contrast=contrast self.brightness=brightness # Toggle RST low to reset. wiringpi.digitalWrite(self.rst, OFF) time.sleep(0.100) wiringpi.digitalWrite(self.rst, ON) # Initialise LCD # 0x21 = Function set (0x20) + Power-down mode (0x04) + Vertical addressing (0x02) + Extended instruction set (0x01) # 0x14 = Bias system (0x10) + BS2 (0x04) + BS1 (0x02) + BS0 (0x01) # 0xXX = Vop (Operation Voltage) = 0x80 + 7 bits # 0x20 = Back to basic instruction set # 0x0c = Display Control = 0x08 + 3 bits: D,0,E. 0x04 = Normal mode self.lcd_cmd([0x21, 0x14, self.contrast, 0x20, 0x0c]) self.row = -1 self.col = -1 # Clear the screen. This will also initialise self.row and self.col self.cls() self.ledpin = LED if self.ledpin == 1: wiringpi.pinMode(self.ledpin, 2) else: wiringpi.pinMode(self.ledpin, 1) self.set_brightness(self.brightness)
def main(): """ Main function """ wp.wiringPiSetup() datasocket = DateDataPullSocket('furnaceroom_controller', ['temperature', 'setpoint', 'dutycycle', 'pid_p', 'pid_i'], timeouts=999999, port=9000) datasocket.start() pushsocket = DataPushSocket('furnaceroom_push_control', action='store_last') pushsocket.start() power_calculator = PowerCalculatorClass(datasocket, pushsocket) power_calculator.daemon = True power_calculator.start() heater = HeaterClass(power_calculator, datasocket) heater.start() tui = CursesTui(heater) tui.daemon = True tui.start()
def __init__(self, keyPad=default.defaultKeyPad, row=default.row, col=default.col): # wiringPi instance creation # (print SETUP for debugging, success value is SETUP=1) self.SETUP=wiringpi.wiringPiSetup() # keypad dimension vs assigned GPIO checking # (must be of the same m x n size) self.__matrixSanity(keyPad, row, col) # in class 'global' constants self.keyPad = keyPad self.row = row self.col = col
def __init__(self, ssr): self.verbose = False self.ssr = ssr threading.Thread.__init__(self) # set up the pin in out mode if wiringpi_available: #call(["/usr/local/bin/gpio", "mode", str(ssr.pin), "out"]) #wiringpi.wiringPiSetupSys() #rasp numbering wiringpi.wiringPiSetup() #gpio numbering #wiringpi.wiringPiSetupGpio() #set the pinmode wiringpi.pinMode(int(ssr.pin), 1) elif bbb_available: GPIO.setup(ssr.pin, GPIO.OUT) #GPIO.cleanup() self.daemon = True self.duty_cycle = 0 self.cycle_time = 0 self.power = 100 self.enabled = False self._On = False self.pid_controller = pid_controller.pidpy(ssr.pid) #create an event so we can stop self._stop = threading.Event()
def RFIDSetup(): # setup up the serial port and the wiringpi software for use # call setup for the wiringpi2 software response = wiringpi2.wiringPiSetup() # set the GPIO pin for input wiringpi2.pinMode(GPIO_PIN, 0) # open the serial port and set the speed accordingly fd = wiringpi2.serialOpen('/dev/serial0', 9600) # clear the serial buffer of any left over data wiringpi2.serialFlush(fd) if response == 0 and fd >0: # if wiringpi is setup and the opened channel is greater than zero (zero = fail) print ("PI setup complete on channel %d" %fd) else: print ("Unable to Setup communications") sys.exit() return fd
sensor_name = collections.OrderedDict() sensor_name["041637c1bcff"]="AlexanderBedroom" sensor_name["041637f543ff"]="GuestBedroom" sensor_name["041637bd5bff"]="NikitaBedroom" sensor_name["041637ffddff"]="DanielBedroom" sensor_name["0416380260ff"]="UpstairsHall" sensor_name["80000027968e"]="KitchenDiningRoomTheatre" sensor_name["800000046e8c"]="GreatRoomOffice" thermostat = { "UpstairsHall", "KitchenDiningRoomTheatre", "GreatRoomOffice", "MasterBedroom" } sensor_avg = {} sensor_current = {} temp_target = {} wpi.wiringPiSetup() CALL_HEAT_COOL_PIN=1 HEAT_COOL_PIN=2 FAN_PIN=3 thermostat_pinlist={} thermostat_pinlist[("GreatRoomOffice",CALL_HEAT_COOL_PIN)]=21 # brown/white thermostat_pinlist[("GreatRoomOffice",HEAT_COOL_PIN)]=22 # orange/white thermostat_pinlist[("GreatRoomOffice",FAN_PIN)]=23 # green/white thermostat_pinlist[("UpstairsHall",CALL_HEAT_COOL_PIN)]=12 # brown/white thermostat_pinlist[("UpstairsHall",HEAT_COOL_PIN)]=13 # orange/white thermostat_pinlist[("UpstairsHall",FAN_PIN)]=14 # green/white thermostat_pinlist[("KitchenDiningRoomTheatre",CALL_HEAT_COOL_PIN)]=6 # brown/white thermostat_pinlist[("KitchenDiningRoomTheatre",HEAT_COOL_PIN)]=10 # orange/white
elif shutdownBtn.is_pressed: shutdown() elif monitorBtn.is_pressed: toggleState() elif wifiBtn.is_pressed: wifiToggle() elif bluetoothBtn.is_pressed: bluetoothToggle() elif cheatBtn.is_pressed: showCheat() # Initial File Setup try: comboStates = readData(statePath) wiringpi.wiringPiSetup() wiringpi.pinMode(led, 2) wiringpi.pwmWrite(led, comboStates['brightness']) os.system("amixer sset -q 'PCM' " + str(comboStates['volume']) + "%") if comboStates['wifi'] == 1: os.system("sudo rfkill unblock wifi") else: os.system("sudo rfkill block wifi") if comboStates['bluetooth'] == 1: os.system("sudo rfkill unblock bluetooth") else: os.system("sudo rfkill block bluetooth") except: writeData(statePath) wiringpi.wiringPiSetup() wiringpi.pinMode(led, 2)
import wiringpi as wiringpi from time import sleep pin_base = 65 # lowest available starting number is 65 i2c_addr = 0x20 # A0, A1, A2 pins all wired to GND wiringpi.wiringPiSetup() # initialise wiringpi wiringpi.mcp23017Setup(pin_base, i2c_addr) # set up the pins and i2c address wiringpi.pinMode(65, 1) # sets GPA0 to output wiringpi.digitalWrite(65, 0) # sets GPA0 to 0 (0V, off) wiringpi.pinMode(80, 0) # sets GPB7 to input wiringpi.pullUpDnControl(80, 2) # set internal pull-up # Note: MCP23017 has no internal pull-down, so I used pull-up and inverted # the button reading logic with a "not" try: while True: wiringpi.digitalWrite(65, 1) # sets port GPA1 to 1 (3V3, on) sleep(1) wiringpi.digitalWrite(65, 0) # sets port GPA1 to 0 (0V, off) sleep(1) finally: wiringpi.digitalWrite(65, 0) # sets port GPA1 to 0 (0V, off) wiringpi.pinMode(65, 0) # sets GPIO GPA1 back to input Mode # GPB7 is already an input, so no need to change anything
def Init(): global timeDelay global theTotalDistance global theTotalDistanceToday global counter global theGPSDevice global previousGeoPoint global currentGeoPoint global previousTime global theVelocity global theBearing global theDate global previousDate global theTotalDistance global theTotalDistanceToday global currentTime global previousTime global mesur_dist global Generator_Time global CRPO CRPO = 1 #----------------------------------------------------------------# # Init Serial port #----------------------------------------------------------------# timeDelay = 10 signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) wiringpi.wiringPiSetup() wiringpi.pinMode(21, 0) wiringpi.pinMode(22, 0) wiringpi.pinMode(26, 1) thePortNumber = '' # hopefully this will become non-empty later listOfCOMPorts = list(serial.tools.list_ports.comports()) for i in range(len(listOfCOMPorts)): if listOfCOMPorts[i][1][0:12] == 'USB-Serial C': thePortNumber = listOfCOMPorts[i][0] # get the active/used port number if thePortNumber == '': log.info('Sorry but the GPS device is not plugged in') sys.exit() if len(sys.argv) == 1 or len(sys.argv) == 3: theGPSDevice = serial.Serial(port=thePortNumber, baudrate=4800, bytesize=8, stopbits=1, parity='N', xonxoff=False, timeout=0) if len(sys.argv) == 2: theGPSDevice = open('/home/pi/GPS/testgps.txt', 'r') log.info(str_color("blue", thePortNumber)) #-----------------------------------------------# # Read retain from file #-----------------------------------------------# try: outputFile_dist = open('/home/pi/GPS/retain', 'r') # open log file line = outputFile_dist.readline() theTotalDistance = float(line) line = outputFile_dist.readline() mesur_dist = ast.literal_eval(line) line = outputFile_dist.readline() Generator_Time = ast.literal_eval(line) outputFile_dist.close() log.info("RETAIN : Get Distance from saved file " + str(theTotalDistance)) log.info("RETAIN : Get mesure from saved file " + str(mesur_dist)) log.info("RETAIN : Get Generator_Time from saved file " + str(Generator_Time)) except: log.info("Error not get Retain")
import time import wiringpi as wp # pylint: disable=F0401 from qhue import Bridge BRIDGE_ADRESS = '192.168.1.3' USERNAME = '******' def main(): bridge = Bridge(BRIDGE_ADRESS, USERNAME) lights = bridge.lights vindue = lights[14] print(vindue()) #vindue.state(bri=255) vindue.state(on=False) if __name__ == '__main__': wp.wiringPiSetup() while wp.digitalRead(0) == 0: time.sleep(0.1) main()
def turn_on_alarm_mode(self): """ Keep an eye on movement and turn on all lights """ wp.wiringPiSetup() self.alarm_mode = True print('Alarm mode_activated')
# ch02_04.py file import wiringpi import time # initialize wiringpi.wiringPiSetup() # WiPi mode # define shift reg pins DATA = 6 LATCH = 5 CLK = 4 OUTPUT = 1 LOW = 0 HIGH = 1 # common anode digital tube 16 BCD code LED_BCD = [0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e] wiringpi.pinMode(DATA, OUTPUT) wiringpi.pinMode(LATCH, OUTPUT) wiringpi.pinMode(CLK, OUTPUT) # initialization print("Initialization...") wiringpi.digitalWrite(LATCH, LOW) wiringpi.digitalWrite(CLK, LOW) def LED_display(LED_number, LED_display, LED_dp):
#Thermostat test script This tests all functionality import wiringpi as io import time import Adafruit_CharLCD as LCD import sht31 sht31 = sht31.SHT31(0) LOW = 0 HIGH = 1 OUTPUT = 1 RELAY = 7 io.wiringPiSetup() io.pinMode(RELAY,OUTPUT) lcd = LCD.Adafruit_CharLCDPlate() # Test Relay io.digitalWrite(RELAY,HIGH) time.sleep(1) io.digitalWrite(RELAY,LOW) time.sleep(1) # activate screen lcd.set_color(1,1,1) lcd.clear() time.sleep(1) lcd.message('Hello!') time.sleep(1) # initialize temp temperature, humidity = sht31.get_temp_and_humidity()
parser.add_argument("-k", "--key", help="Private key file path") parser.add_argument("-p", "--pin", help="gpio pin (using BCM numbering)", type=int, required=True) parser.add_argument("-t", "--topic", help="MQTT topic(s)", nargs='+', required=True) parser.add_argument("-f", "--input_file", help="input file (yaml format)", default=None) parser.add_argument("-l", "--log_level", help="Log Level", default=logging.INFO) args = parser.parse_args() logging.basicConfig(filename=LOG_FILE, level=args.log_level) subscriber = Subscriber(args.endpoint, args.rootCA, args.key, args.cert, args.clientID) relay.wiringPiSetup() # Load configuration file if args.input_file is not None: f = open(args.input_file) topics = yaml.safe_load(f) for t in topics[args.endpoint]: logging.info("Subscribing to {}".format(t)) subscriber.subscribe(t, my_callback) time.sleep(2) # pause between subscribes (maybe not needed?) for t in args.topic: logging.info("Subscribing to {}".format(t)) subscriber.subscribe(t, my_callback) time.sleep(2) # pause
def __init__(self, communication_style = "WIFI"): # parameters self.communication_style = communication_style self.HOST = '' self.CONNECTION_PORT = 2525 self.DRIVING_PORT = 2526 self.DRIVING_SERVICE_UUID = "94f39d29-7d6d-437d-973b-fba39e49d4ed" self.SONAR_PORT = 2527 self.CAMERA_PORT = 2528 self.CAMERA_DRIVING_PORT = 2529 self.CAMERA_DRIVING_SERVICE_UUID = "94f39d29-7d6d-437d-973b-fba39e49d4ec" # MOTORS' PINS ----> still to be set correctly # Nomenclature: _F : forward _B : backward self.MOTOR_LEFT_F = 7 self.MOTOR_LEFT_B = 11 self.MOTOR_RIGHT_F = 15 self.MOTOR_RIGHT_B = 13 # we know map them to the wiringPi gpio map # http://wiringpi.com/pins/ self.MOTOR_LEFT_F = mapGPIO2WIRINGPI(self.MOTOR_LEFT_F) self.MOTOR_LEFT_B = mapGPIO2WIRINGPI(self.MOTOR_LEFT_B) self.MOTOR_RIGHT_F = mapGPIO2WIRINGPI(self.MOTOR_RIGHT_F) self.MOTOR_RIGHT_B = mapGPIO2WIRINGPI(self.MOTOR_RIGHT_B) # STATE OF THE ROBOT # The possible states are: # IDLE : don't move # FORWARD : moving forward # BACKWARD : moving backward # TURNING_LEFT : turning left # TURNING_RIGHT : turning right self.state = 'IDLE' # Then these states are enriched by the velocity for each well self.MAX_SPEED = 100 self.MIN_SPEED = 70 self.velocity_left_weel = 0 self.velocity_right_weel = 0 # The "connection socket" is the one with the only aim to establish a connection to the computer if self.communication_style == "WIFI": self.connection_socket = udpsocket.UDPSocket() # We make all the sockets as servers here for the robot. Once they have binded they can be used for normal communication self.connection_socket.bind(self.CONNECTION_PORT, self.HOST) else: self.connection_socket = bluetooth.BluetoothSocket( bluetooth.RFCOMM ) # bind the socket to an address, this format bounds the socket to any port and any address. You can bound the socket to a specific address and a specific port. self.connection_socket.bind(("", bluetooth.PORT_ANY)) # Listen to connections made to the socket. The argument specified the maximum number of queded connections. It has to be at least 0 but in that case it does not listen anyone. self.connection_socket.listen(1) # The "driving socket" has the aim to receive data regarding the driving of the robot (direction and velocity) if self.communication_style == "WIFI": self.driving_socket = udpsocket.UDPSocket() self.driving_socket.bind(self.DRIVING_PORT, self.HOST) else: self.driving_socket = bluetooth.BluetoothSocket( bluetooth.RFCOMM ) # bind the socket to an address, this format bounds the socket to any port and any address. You can bound the socket to a specific address and a specific port. self.driving_socket.bind(("", bluetooth.PORT_ANY)) # Listen to connections made to the socket. The argument specified the maximum number of queded connections. It has to be at least 0 but in that case it does not listen anyone. self.driving_socket.listen(1) # The "driving socket" has the aim to receive data regarding the driving of the robot (direction and velocity) if self.communication_style == "WIFI": self.camera_driving_socket = udpsocket.UDPSocket() self.camera_driving_socket.bind(self.CAMERA_DRIVING_PORT, self.HOST) else: self.camera_driving_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM) # bind the socket to an address, this format bounds the socket to any port and any address. You can bound the socket to a specific address and a specific port. self.camera_driving_socket.bind(("", bluetooth.PORT_ANY)) # Listen to connections made to the socket. The argument specified the maximum number of queded connections. It has to be at least 0 but in that case it does not listen anyone. self.camera_driving_socket.listen(1) # The "sonar socket" send data regarding the measurement of the SONAR self.sonar_socket = udpsocket.UDPSocket() self.sonar_socket.bind(self.SONAR_PORT, self.HOST) # The "picamera socket" send data regarding the picamera self.picamera_socket = udpsocket.UDPSocket() self.picamera_socket.bind(self.CAMERA_PORT, self.HOST) # set up the wiringPi library wiringpi.wiringPiSetup() wiringpi.pinMode(self.MOTOR_LEFT_F, 1) wiringpi.pinMode(self.MOTOR_LEFT_B, 1) wiringpi.pinMode(self.MOTOR_RIGHT_F, 1) wiringpi.pinMode(self.MOTOR_RIGHT_B, 1) wiringpi.softPwmCreate(self.MOTOR_LEFT_F, 0, 100) wiringpi.softPwmCreate(self.MOTOR_LEFT_B, 0, 100) wiringpi.softPwmCreate(self.MOTOR_RIGHT_F, 0, 100) wiringpi.softPwmCreate(self.MOTOR_RIGHT_B, 0, 100) # CAMERA SERVO MOTORS ----------------------------------- # set pwm for servo motors (motor for the camera) self.yaw_motor_pin = 12 self.pitch_motor_pin = 16 self.PWM_FREQUENCY = 50 # Hz self.camera_motors_max_time = 0.3 #sec - Maximum time to send a pwm (for noise reduction) GPIO.setmode(GPIO.BOARD) GPIO.setup(self.yaw_motor_pin, GPIO.OUT) GPIO.setup(self.pitch_motor_pin, GPIO.OUT) self.yaw_motor_pwm = GPIO.PWM(self.yaw_motor_pin,self.PWM_FREQUENCY ) self.yaw_motor_pwm.start(0.0) self.pitch_motor_pwm = GPIO.PWM(self.pitch_motor_pin, self.PWM_FREQUENCY) self.pitch_motor_pwm.start(0.0) # initial angle self.yaw_angle = 0 self.pitch_angle = 0 self.PULSES2DEGREE = 180/200 # 180 degree/ 200 pulses self.yaw_angle_old = self.yaw_angle self.pitch_angle_old = self.pitch_angle self.new_yaw_angle = False # this is set to true when tehre is a new yaw angle self.new_yaw_angle_arrived = time.time() # time at which the new yaw angle arrived self.new_pitch_angle = False self.new_pitch_angle_arrived = time.time() # the servo motors are controlled with pulses, from 50 to 250 # we use the term pulse because it refers to the pwm with (50=0.5ms,250=2.5ms) # we are going to set the zero value of the servo with the central pulse # ideally 50 is -90 degree and 250 is + 90 degree (- is on the rigth for the yaw, and down for the pitch) self.yaw_angle_zero_pulse = 140 self.pitch_angle_zero_pulse = 145 # iF the zero values are not perfectly calibrated to 150 we are going to center with saturation values self.yaw_range_pulse = min( self.yaw_angle_zero_pulse - 50, 250 - self.yaw_angle_zero_pulse) self.yaw_max_pulse = self.yaw_angle_zero_pulse + self.yaw_range_pulse + 50 self.yaw_min_pulse = self.yaw_angle_zero_pulse - self.yaw_range_pulse self.pitch_range_pulse = min(self.pitch_angle_zero_pulse - 50, 250 - self.pitch_angle_zero_pulse) self.pitch_max_pulse = self.pitch_angle_zero_pulse + self.pitch_range_pulse + 50 self.pitch_min_pulse = self.pitch_angle_zero_pulse - self.pitch_range_pulse # 180degree/200pulses = degree/pulses is the resolution self.yaw_range_degree = 180/200 * 2 * self.yaw_range_pulse self.pitch_range_degree = 180/200 * 2 * self.pitch_range_pulse self.yaw_max_angle = self.yaw_range_degree/2 self.yaw_min_angle = - self.yaw_max_angle self.pitch_max_angle = self.pitch_range_degree / 2 self.pitch_min_angle = - self.pitch_max_angle print "YAW/PITCH RANGES [+/-degree]: ", self.yaw_range_degree/2, "/",self.pitch_range_degree/2 # let's give the motors 0.3s to set to the zero position # we have to give it some times to reach a certain position # but we have to stop after sometime the motors because of noise problem t_start = time.time() yaw_duty_cycle = (self.yaw_angle_zero_pulse / 1000) * self.PWM_FREQUENCY pitch_duty_cycle = (self.pitch_angle_zero_pulse / 1000) * self.PWM_FREQUENCY while time.time() - t_start <= 0.3: #self.yaw_motor_pwm.ChangeDutyCycle(yaw_duty_cycle) self.yaw_motor_pwm.ChangeDutyCycle(self.yawDegreeToDutyCycle(0.0)) self.pitch_motor_pwm.ChangeDutyCycle(self.pitchDegreeToDutyCycle(0.0)) #self.pitch_motor_pwm.ChangeDutyCycle(pitch_duty_cycle) self.yaw_motor_pwm.ChangeDutyCycle(0.0) self.pitch_motor_pwm.ChangeDutyCycle(0.0)
def __init(self): self.gpio = wiringpi.wiringPiSetup() wiringpi.softPwmCreate(PIN_RED, 0, LED_MAX) wiringpi.softPwmCreate(PIN_GREEN, 0, LED_MAX) wiringpi.softPwmCreate(PIN_BLUE, 0, LED_MAX) self.off()
def __init__(self): self.port = None wiringpi.wiringPiSetup() wiringpi.pinMode(5,INPUT) #Physical pin 18, BCM GPIO 24 wiringpi.pinMode(6,OUTPUT) #Physical pin 22, BCM GPIO 25 wiringpi.digitalWrite(6,1) #Set output high