def lecture_son(signal): for i in range(33984/Fe): if signal[i]>0: GPIO.output("P9_22", GPIO.HIGH) else: GPIO.output("P9_22", GPIO.LOW) time.sleep(1/Fe)
def on_success(self, data): if 'text' in data: print data['text'].encode('utf-8') print GPIO.output(LED, GPIO.HIGH) time.sleep(0.5) GPIO.output(LED, GPIO.LOW)
def __init__(self, pin, name=None): self._pin = pin if name: self._name = name else: self._name = self._pin GPIO.setup(self._pin, GPIO.IN)
def init_LEDs(): PWM.start(RED, 100) # red PWM.start(GREEN, 100) # green PWM.start(BLUE, 100) # blue GPIO.setup(DOORPORT, GPIO.OUT) # LockPort GPIO.output(DOORPORT, GPIO.LOW) # Default low: locked
def main(): GPIO.setup(LED_PIN, GPIO.OUT) GPIO.output(LED_PIN, GPIO.LOW) radio = rfm69.RFM69() radio.initialize(FREQUENCY,NODEID,NETWORKID) radio.readAllRegs(); if IS_RFM69HW: radio.setHighPower(IS_RFM69HW) #uncomment only for RFM69HW! radio.setEncryptionKey(ENCRYPTKEY) print "Transmitting at {} Mhz...".format(433 if FREQUENCY==rfm69.RF69_433MHZ else (868 if FREQUENCY==rfm69.RF69_868MHZ else 915)) lastPeriod = 0 sendSize = 0 while True: #check for any received packets if (radio.receiveDone()): print "[{}] {} [RX_RSSI: {}]".format(radio.SENDERID, radio.DATA, radio.RSSI) if (radio.ACKRequested()): radio.sendACK() print " - ACK sent" Blink(LED_PIN, .003) currPeriod = radio._millis()/TRANSMITPERIOD if (currPeriod != lastPeriod): lastPeriod = currPeriod s = "Sending[{}]: {} ".format(sendSize, payload[:sendSize]) if (radio.sendWithRetry(GATEWAYID, payload, sendSize, retries=RETRIES, retryWaitTime=ACK_TIME)): s += "ok!" else: s += "nothing..." print s sendSize = (sendSize + 1) % 31 Blink(LED_PIN, .003)
def callRight(data): #gets time time = rospy.get_time() #reads encoder inputs channelA = GPIO.input("P8_17") channelB = GPIO.input("P8_26") #puts inputs into the quadrature decoder program quadCalcR.update(channelA, channelB, time) #creates messages rightFMSG = JointState() rightRMSG = JointState() header = Header() #appends velocity and position data to the joinstate message #front wheel rightFMSG.header.stamp.secs = rospy.get_time() rightFMSG.name.append('front_right_wheel') rightFMSG.position.append(quadCalcL.position) #rear wheel rightRMSG.header.stamp.secs = rospy.get_time() rightRMSG.name.append('rear_right_wheel') rightRMSG.position.append(quadCalcL.position) #publishes message pubFR.publish(rightFMSG) pubRR.publish(rightRMSG)
def turn_on(self): self._state['lastchange'] = str(datetime.datetime.today()) print 'vars pin on', self._pin,self._on GPIO.output(self._pin, self._on) log.info('Turning {pin} on...',pin=self._pin) self._event_bus.publish_command(self.state)
def run(self): # Create new threads self.dialer.start() self.dialer.spawn() print 'Linphone Running: ' + str(self.dialer.isrunning()) self.inUse = False while True: feedback = self.dialer.getLineStatus() if feedback == 'Incoming Call' and self.inUse is False: self.answerIncoming() elif feedback == 'Call ended': self.inUse = False else: pass if gpio.input(self.hook3) and self.dialer.isOnCall() is False and self.inUse is False and self.prevHookState == 'Low': self.inUse = True self.prevHookState = 'High' success = False while not success and gpio.input(self.hook3): success = self.makeCall() elif not gpio.input(self.hook3) and self.prevHookState == 'High': if self.dialer.isOnCall(): self.dialer.terminateCall() else: pass
def callLeft(data): #gets time time = rospy.get_time() #reads encoder inputs channelA = GPIO.input("P9_23") channelB = GPIO.input("P9_30") #puts inputs into the quadrature decoder program quadCalcL.update(channelA, channelB, time) #creates messages leftFMSG = JointState() leftRMSG = JointState() header = Header() #appends velocity and position data to the joinstate message #front wheel leftFMSG.header.stamp.secs = rospy.get_time() leftFMSG.name.append('front_left_wheel') leftFMSG.position.append(quadCalcL.position) #rear wheel leftRMSG.header.stamp.secs = rospy.get_time() leftRMSG.name.append('rear_left_wheel') leftRMSG.position.append(quadCalcL.position) #publishes message pubFL.publish(leftFMSG) pubRL.publish(leftRMSG)
def display_char(char, font=FONT): try: GPIO.output(DC, GPIO.HIGH) writebytes(font[char]+[0]) except KeyError: pass # Ignore undefined characters.
def __init__(self , note2buttons , actuatorno , isinv , chan): #initialize con lista de notas (en notacion anglosajona), numero de puchabotones necesarios, si se usa logica negada y el canal MIDI a escuchar self.actuatorno = actuatorno self.isinv = isinv self.chan=chan #Not implemented self.mid2gpio = self.__convert2Gpios(note2buttons) #obtener los gpios necesarios a encender o apagar cuando llega un msg de noteOn o noteOff for i in range(0 , actuatorno): GPIO.setup(self.bbb_gpios[i], GPIO.OUT)
def selectDigit(digitArr, display): for i in range(0, len(digitArr)): comPinId = display[1][i] if digitArr[i] == 1: GPIO.output(comPinId, GPIO.LOW) else: GPIO.output(comPinId, GPIO.HIGH)
def irqWait(self): # A race condition may occur here. # TODO: Should set a timeout if GPIO.input(self.irq_pin) == 0: return GPIO.wait_for_edge(self.irq_pin, GPIO.FALLING)
def set_state(self, state): self._On = state _state = 0 if state: _state = 1 if self.verbose: print str(self.ssr.name) + " digitalWrite: " + str(self.ssr.pin) + " " + str(_state) #save the state if self.ssr.state != _state: self.ssr.state = _state self.ssr.save() #reverse if needed if self.ssr.reverse_polarity and self.enabled: _state = not _state if wiringpi2_available: wiringpi2.digitalWrite(int(self.ssr.pin), _state) elif bbb_available: if _state: GPIO.output(self.ssr.pin, GPIO.HIGH) else: GPIO.output(self.ssr.pin, GPIO.LOW)
def displayDigit(segmentArr, display): for i in range(0, len(segmentArr)): pinId = display[0][i] if segmentArr[i] == 1: GPIO.output(pinId, GPIO.HIGH) else: GPIO.output(pinId, GPIO.LOW)
def tx_start(self): if not self.ptt_pin: return GPIO.setup(self.ptt_pin, GPIO.OUT) GPIO.output(self.ptt_pin, GPIO.HIGH) time.sleep(self.ptt_high)
def new_msg(): pygame.display.init() print_echo("new CLP command") screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN) pygame.mouse.set_visible(0) x = 8*GPIO.input("P8_18")+4*GPIO.input("P8_16")+2*GPIO.input("P8_14")+GPIO.input("P8_12") # Tenta carregar a imagem do diretorio compartilhado. Caso nao consiga, carrega do diretorio interno try: directory_shared = "/home/debian/Desktop/shared/" + str(x) + ".png" image = pygame.image.load(directory_shared) print_echo(directory_shared) except: directory_interno = "/home/debian/Desktop/Project_display/images/" + str(x) + ".png" image = pygame.image.load(directory_interno) print_echo(directory_interno) image = pygame.transform.scale(image, (screen.get_size()[0], screen.get_size()[1])) back = pygame.Surface(screen.get_size()) back = back.convert() back.blit(image,(0,0)) screen.blit(back,(0,0)) while GPIO.input("P8_11"): pygame.display.flip() #time.sleep(0.5) print_echo("end of command") pygame.display.quit()
def enable(parameters = None): """ Name: enable Desc: This enables the Main Power for the board. The board is powered on with AUX enabled. Params: parameters (list) None """ global EN for key in PINS.keys(): GPIO.output(PINS[key], GPIO.LOW) GPIO.output(PINS["MAINPW_EN"], GPIO.HIGH) with open("EN", "wb") as ENFile: ENFile.write("1") EN = True time.sleep(1) aux([1]) i2c = Adafruit_I2C(address, busNum) pll = si5338POST(i2c = i2c, regs = VCOREGS) pll._init() print "Main Power Enabled" print "Note: When finished use 'disable' or 'quit'"
def setup_input(pin, pull_mode): """Set up a GPIO as input.""" # pylint: disable=import-error from Adafruit_BBIO import GPIO GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN if pull_mode == 'DOWN' else GPIO.PUD_UP)
def testSwitch(): t0 = time.time() GPIO.output(O_TEST, GPIO.HIGH) GPIO.output(O_TEST, GPIO.LOW) t1 = time.time() t2 = time.time() print(t1-t0, t2-t1)
def __init__(self, node_name_override = 'read_encoders'): # rospy.init_node(node_name_override) self.nodename = rospy.get_name() rospy.loginfo("Node starting with name %s", self.nodename) self.rate = float(rospy.get_param("rate", 10)) # Pines de los encoders self.cs1 = "P9_31" self.cs2 = "P9_29" self.do = "P9_25" self.clk = "P9_23" # GPIO.cleanup() GPIO.setup(self.cs1, GPIO.OUT) GPIO.setup(self.cs2, GPIO.OUT) GPIO.setup(self.do, GPIO.IN) GPIO.setup(self.clk, GPIO.OUT) # self.closeComm(self.cs1) self.closeComm(self.cs2) # self.e1val = 0 self.e2val = 0 # self.e1Pub = rospy.Publisher("e1", Int16) self.e2Pub = rospy.Publisher("e2", Int16)
def setup_input(pin, pull_mode): """Setup a GPIO as input.""" # pylint: disable=import-error,undefined-variable import Adafruit_BBIO.GPIO as GPIO GPIO.setup(pin, GPIO.IN, # noqa: F821 GPIO.PUD_DOWN if pull_mode == 'DOWN' # noqa: F821 else GPIO.PUD_UP) # noqa: F821
def _setup_gpio(self): """Initialize GPIO pins""" GPIO.setup(self.dir1Pin[LEFT], GPIO.OUT) GPIO.setup(self.dir2Pin[LEFT], GPIO.OUT) GPIO.setup(self.dir1Pin[RIGHT], GPIO.OUT) GPIO.setup(self.dir2Pin[RIGHT], GPIO.OUT) GPIO.setup(self.led, GPIO.OUT)
def screenInit(): #GPIO.output(SCE, GPIO.LOW) time.sleep(0.050) # Toggle RST low to reset. GPIO.output(RST, GPIO.LOW) time.sleep(0.100) GPIO.output(RST, GPIO.HIGH)
def __init__(self, baseIP, robotIP): # Initialize GPIO pins GPIO.setup(self.dir1Pin[LEFT], GPIO.OUT) GPIO.setup(self.dir2Pin[LEFT], GPIO.OUT) GPIO.setup(self.dir1Pin[RIGHT], GPIO.OUT) GPIO.setup(self.dir2Pin[RIGHT], GPIO.OUT) GPIO.setup(self.ledPin, GPIO.OUT) # Initialize PWM pins: PWM.start(channel, duty, freq=2000, polarity=0) PWM.start(self.pwmPin[LEFT], 0) PWM.start(self.pwmPin[RIGHT], 0) # Set motor speed to 0 self.setPWM([0, 0]) # Initialize ADC ADC.setup() self.encoderRead = encoderRead(self.encoderPin) # Set IP addresses self.baseIP = baseIP self.robotIP = robotIP self.robotSocket.bind((self.robotIP, self.port))
def moveUP(self): PWM.start(self.pwmPIN, self.duty, self.freq, 0) GPIO.output(self.upDIR, GPIO.HIGH) status = 1 print "Moving motor UP" time.sleep(1.5) return status
def moveDOWN(self): PWM.start(self.pwmPIN, self.duty, self.freq, 0) GPIO.output(self.downDIR, GPIO.HIGH) status = 0 print "Moving motor DOWN" time.sleep(1.5) return status
def ButtonFunction(void): global alertFlag print "ButtonFunction" if alertFlag == 0: alertFlag = 1 alertTime = time.time()+60 GPIO.output(led,GPIO.LOW)
def set_beeper(self, value): if value: if gpio_available: GPIO.output(config.gpio_beeper, GPIO.HIGH) else: if gpio_available: GPIO.output(config.gpio_beeper, GPIO.LOW)
def hold(): GPIO.output(ledPin, GPIO.HIGH) printer.printImage(Image.open('gfx/goodbye.png'), True) printer.feed(3) subprocess.call("sync") subprocess.call(["shutdown", "-h", "now"]) GPIO.output(ledPin, GPIO.LOW)
import Adafruit_BBIO.PWM as PWM import Adafruit_BBIO.GPIO as GPIO import time GPIO.setup("P8_12", GPIO.IN) old_switch_state = 0 servo_pin = "P8_19" duty_min = 3 duty_max = 14.5 duty_span = duty_max - duty_min flag = 0 PWM.start(servo_pin, (100 - duty_min), 60.0, 1) while True: new_switch_state = GPIO.input("P8_12") if new_switch_state == 1 and old_switch_state == 0: time.sleep(0.2) flag = flag + 1 print(flag) angle = flag * 45 angle_f = float(angle) duty = 100 - ((angle_f / 180) * duty_span + duty_min) PWM.set_duty_cycle(servo_pin, duty)
def disp2(t): if (t == 1): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.LOW) GPIO.output(disp23, GPIO.LOW) GPIO.output(disp24, GPIO.HIGH) elif (t == 2): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.LOW) GPIO.output(disp23, GPIO.HIGH) GPIO.output(disp24, GPIO.LOW) elif (t == 3): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.LOW) GPIO.output(disp23, GPIO.HIGH) GPIO.output(disp24, GPIO.HIGH) elif (t == 4): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.HIGH) GPIO.output(disp23, GPIO.LOW) GPIO.output(disp24, GPIO.LOW) elif (t == 5): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.HIGH) GPIO.output(disp23, GPIO.LOW) GPIO.output(disp24, GPIO.HIGH) elif (t == 6): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.HIGH) GPIO.output(disp23, GPIO.HIGH) GPIO.output(disp24, GPIO.LOW) elif (t == 7): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.HIGH) GPIO.output(disp23, GPIO.HIGH) GPIO.output(disp24, GPIO.HIGH) elif (t == 8): GPIO.output(disp21, GPIO.HIGH) GPIO.output(disp22, GPIO.LOW) GPIO.output(disp23, GPIO.LOW) GPIO.output(disp24, GPIO.LOW) elif (t == 9): GPIO.output(disp21, GPIO.HIGH) GPIO.output(disp22, GPIO.LOW) GPIO.output(disp23, GPIO.LOW) GPIO.output(disp24, GPIO.HIGH) elif (t == 0): GPIO.output(disp21, GPIO.LOW) GPIO.output(disp22, GPIO.LOW) GPIO.output(disp23, GPIO.LOW) GPIO.output(disp24, GPIO.LOW) elif (t == 10): GPIO.output(disp11, GPIO.HIGH) GPIO.output(disp12, GPIO.HIGH) GPIO.output(disp13, GPIO.HIGH) GPIO.output(disp14, GPIO.HIGH) return
disp34 = "P8_19" #LSB disp41 = "P9_21" #MSB disp42 = "P9_16" disp43 = "P9_15" disp44 = "P9_14" #LSB x = 0 #This is the value of state t = 0 #This is the value to be displayed st = 5 #This is the time for each signal state #Setup mode for leds of particular mode GPIO.setup(road1r, GPIO.OUT) GPIO.setup(road1y, GPIO.OUT) GPIO.setup(road1g, GPIO.OUT) GPIO.setup(road2r, GPIO.OUT) GPIO.setup(road2y, GPIO.OUT) GPIO.setup(road2g, GPIO.OUT) GPIO.setup(road3r, GPIO.OUT) GPIO.setup(road3y, GPIO.OUT) GPIO.setup(road3g, GPIO.OUT) GPIO.setup(road4r, GPIO.OUT) GPIO.setup(road4y, GPIO.OUT) GPIO.setup(road4g, GPIO.OUT) #Setup mode for displays GPIO.setup(disp11, GPIO.OUT) GPIO.setup(disp12, GPIO.OUT) GPIO.setup(disp13, GPIO.OUT)
def teardown_module(module): GPIO.cleanup()
def test_direction_readback(self): GPIO.setup("P8_10", GPIO.IN) direction = GPIO.gpio_function("P8_10") assert direction == GPIO.IN
def release_pump(self): GPIO.cleanup()
def cleanup(self): GPIO.cleanup()
def step(pin): GPIO.output(pin, GPIO.HIGH) time.sleep(1E-3) GPIO.output(pin, GPIO.LOW) time.sleep(1E-3)
def do_tck(state): global TCK GPIO.output(TCK, state)
THE POSSIBILITY OF SUCH DAMAGE. -------------------------------------------------------------------------- UPDATES THIS PART -------------------------------------------------------------------------- """ # ------------------------------------------------------------------------ # Constants # ------------------------------------------------------------------------ import Adafruit_BBIO.GPIO as GPIO import time # ------------------------------------------------------------------------ # Global variables # ------------------------------------------------------------------------ GPIO.setup("USR3", GPIO.OUT) # ------------------------------------------------------------------------ # Main script # ------------------------------------------------------------------------ while True: GPIO.output("USR3", GPIO.HIGH) time.sleep(0.1) GPIO.output("USR3", GPIO.LOW) time.sleep(0.1)
def do_tdo(): global TDO return '0' if GPIO.input(TDO) == GPIO.LOW else '1'
#!/usr/bin/python import serial import Adafruit_BBIO.GPIO as GPIO import time import math # initialize serial port # ser1 = serial.Serial('/dev/ttyUSB0', 9600) # ser2 = serial.Serial('/dev/ttyUSB1', 9600) # wrong usb ports, dont replug, reboot and pray ser2 = serial.Serial('/dev/ttyUSB0', 9600) ser1 = serial.Serial('/dev/ttyUSB1', 9600) # initialize GPIOs # Motor1 step GPIO.setup("P8_8", GPIO.OUT) # Motor1 direction GPIO.setup("P8_10", GPIO.OUT) # Motor2 step GPIO.setup("P8_12", GPIO.OUT) # Motor2 direction GPIO.setup("P8_14", GPIO.OUT) # some variables delta = 100 # single step on rising edge def step(pin): GPIO.output(pin, GPIO.HIGH) time.sleep(1E-3)
""" # UART TX (GPIO_15) / RX (GPIO_14) config-pin P9.24 uart config-pin P9.26 uart # GPIO config-pin P8.07 gpio config-pin P8.08 gpio config-pin P8.09 gpio config-pin P8.10 gpio """ TDI = "P8_7" # GPIO_66 / A4 TDO = "P8_8" # GPIO_67 / A5 TCK = "P8_9" # GPIO_69 / A2 TMS = "P8_10" # GPIO_68 / A3 GPIO.setup(TDI, GPIO.OUT) GPIO.setup(TDO, GPIO.IN) GPIO.setup(TCK, GPIO.OUT) GPIO.setup(TMS, GPIO.OUT) PASSWORD_FILE = 'passwords' def cleanup(signal, frame): global STOP STOP = True signal.signal(signal.SIGINT, cleanup)
def do_tms(low): global TMS GPIO.output(TMS, GPIO.LOW if low else GPIO.HIGH)
import Adafruit_BBIO.GPIO as GPIO import time import signal import sys import multiprocessing import random pins = [7, 8, 9, 10, 11, 12, 14, 16] processes = [] for pin in pins: GPIO.setup("P8_%s" % pin, GPIO.OUT) GPIO.output("P8_%s" % pin, GPIO.HIGH) def signal_handler(signal, frame): print '\nCaught interrupt, cleaning up...' for process in processes: process.terminate() for pin in pins: GPIO.output("P8_%s" % pin, GPIO.HIGH) sys.exit(0) signal.signal(signal.SIGINT, signal_handler) def pin_process(pin): signal.signal(signal.SIGINT, signal.SIG_IGN) while 1: rand_time = random.random()
def do_tdi(b): global TDI GPIO.output(TDI, GPIO.LOW if b == '0' else GPIO.HIGH)
import Adafruit_BBIO.GPIO as GPIO import time import requests import json stationID = "123" url = "http://192.168.1.79:5000/api/stationstate/" + stationID GPIO.setup("PB_1O", GPIO.OUT) # GPIO - 68 onStatus = False while True: r = requests.get(url) r = str(r.text) result = json.loads(r) if (onStatus == False): if (results[0] == True): print "Switch ON" onStatus = True GPIO.output("PB_1O", GPIO.LOW) elif (onStatus == True): if (result[0] == True): print "Switch OFF" onStatus = False GPIO.output("PB_1O", GPIO.HIGH) time.sleep(2)
import Adafruit_BBIO.GPIO as GPIO from flask import Flask, render_template, request app = Flask(__name__) led = "P8_10" GPIO.setup(led, GPIO.OUT) @app.route('/switch.html', methods=['GET', 'POST']) def change_LED_state(): if request.method == 'POST': current_state = request.form['state'] print current_state if (current_state == 'on'): GPIO.output(led, GPIO.HIGH) elif (current_state == "off"): GPIO.output(led, GPIO.LOW) return render_template('switch.html') app.run('0.0.0.0', 3005)
def __init__(self): GPIO.setup(self.M1_IN1, GPIO.OUT) GPIO.setup(self.M1_IN2, GPIO.OUT) GPIO.setup(self.MLeft_IN1, GPIO.OUT) GPIO.setup(self.MLeft_IN2, GPIO.OUT) GPIO.setup(self.MRight_IN1, GPIO.OUT) GPIO.setup(self.MRight_IN2, GPIO.OUT) print("UAV __init__ has been executed!")
def power_off(self=None): logging.debug("[ADC] Powering the ADC off") GPIO.output("P9_18", GPIO.LOW) self.close_file() self.stop_gps_polling()
def main(): GPIO.setup(leds, GPIO.OUT) GPIO.output(leds, GPIO.HIGH) lcm_.subscribe("/rgb_leds", rgb_led_callback) run_coroutines(lcm_.loop(), publish_rgb_readings())
from flask_cors import CORS def convertToU16(value, little_endian=True): value = value & 0xFFFF if not little_endian: value = ((value << 8) & 0xFF00) + (value >> 8) return value workshop.setPinMux("P9_29", "gpio") workshop.setPinMux("P9_19", "i2c") workshop.setPinMux("P9_20", "i2c") GPIO.setup("P9_29", GPIO.IN, pull_up_down=GPIO.PUD_DOWN) ADC.setup() bus = smbus.SMBus(2) ## Solution TSL2561_I2C_ADDR = (0x29) # Default address (pin left floating) TSL2561_COMMAND_BIT = (0x80) # Must be 1 TSL2561_WORD_BIT = (0x20) # 1 = read/write word (rather than byte) TSL2561_CONTROL_POWERON = (0x03) TSL2561_CONTROL_POWEROFF = (0x00) TSL2561_REGISTER_CONTROL = 0x00
def __init__(self, PORT, SPI): #Configurações iniciais self.spi = SPI self.port = PORT GPIO.setup(self.port, GPIO.OUT) GPIO.output(self.port, 1) #Configuração do ADC GPIO.output(self.port, 0) self.spi.xfer2([0xff, 0xff]) GPIO.output(self.port, 1) #Envio de setup inicial GPIO.output(self.port, 0) self.spi.xfer2([0x83, 0x10]) GPIO.output(self.port, 1)
def __stop(self): GPIO.cleanup() self.serialPort.close()
import time import dac #------------------------------------------------------- # initialize the bus and device /dev/spidev1.0 spi0 = SPI(0, 0) #defining mode (CPOL = 0; CPHA = 1) spi0.mode = 1 #defining speed (in bps) spi0.msh = 10000000 #------------------------------------------------------- # mnemonics for GPIO BUSY = "P9_20" CNV = "P9_23" #------------------------------------------------------- # defining outputs GPIO.setup(CNV, GPIO.OUT) #------------------------------------------------------- # defining inputs GPIO.setup(BUSY, GPIO.IN) #------------------------------------------------------- # initialization of outputs GPIO.output(CNV, GPIO.LOW) #======================================================= # ADC calibration parameters #======================================================= # global variables global GAIN global OFFSET global REFERENCE #REFERENCE = 13107 #GAIN = 1
def commandlistener(cmdmessage): GPIO.setup(OUT_PIN, GPIO.OUT) GPIO.setup(IN_PIN, GPIO.IN) rospy.sleep(2) msg = EFStatus() msg.status = msg.EF_BUSY pub.publish(msg) if (cmdmessage.command == cmdmessage.CMD_GRAB): #initialize suckage GPIO.output(OUT_PIN, GPIO.HIGH) #reset servo just in case angle = 0.0 #move in to grab while ((not GPIO.input(IN_PIN)) and (angle < ANGLE_LOWERED)): dutycyc = MINDUT + (MAXDUT - MINDUT) * (angle / SERVOMAX) PWM.start(SERVO_PIN, dutycyc, SERVO_FREQUENCY, 0) angle += 5 rospy.sleep(0.25) if GPIO.input(IN_PIN): #we have contacted something #carefully retract while ((angle > ANGLE_RAISED)): dutycyc = MINDUT + (MAXDUT - MINDUT) * (angle / SERVOMAX) PWM.start(SERVO_PIN, dutycyc, SERVO_FREQUENCY, 0) angle -= 5 rospy.sleep(0.5) if not (GPIO.input(IN_PIN)): #we dropped it or never got it in the first place while ((angle > ANGLE_RAISED)): dutycyc = MINDUT + (MAXDUT - MINDUT) * (angle / SERVOMAX) PWM.start(SERVO_PIN, dutycyc, SERVO_FREQUENCY, 0) angle -= 5 rospy.sleep(0.5) #for now, retract as usual #we made it this far, this probably still have it msg = EFStatus() msg.status = msg.EF_READY pub.publish(msg) else: #kinda like in reverse GPIO.output(OUT_PIN, GPIO.LOW) #end suckage #reset angle angle = 0.0 dutycyc = MINDUT + (MAXDUT - MINDUT) * (angle / SERVOMAX) PWM.start(SERVO_PIN, dutycyc, SERVO_FREQUENCY, 0) msg = EFStatus() msg.status = msg.EF_READY pub.publish(msg)
# !/usr/bin/python3 # -*- coding: utf-8 -*- # Toggeln des GPIO P9_25 (GPIO 117) ueber die Adafruit_BBIO-Bibliothek. # S. Mack, 5.3.20 import Adafruit_BBIO.GPIO as GPIO import time import sys print("Python-Interpreter: {}\n".format(sys.version)) pin = "P9_25" GPIO.setup(pin, GPIO.OUT) print("Pin enabled...") try: while True: GPIO.output(pin, GPIO.HIGH) time.sleep(0.5) GPIO.output(pin, GPIO.LOW) time.sleep(0.5) except KeyboardInterrupt: print("") GPIO.output(pin, GPIO.LOW) print("...Pin disabled.") print("Byebye...")
def calibration(): # global variables global GAIN, OFFSET, REFERENCE # set up DAC dac.config() calibration = [-9, 9] total_measures = 10000 # defining variables for MAX, MIN and MEAN (ADC measure) min_adc = [0] * 5 max_adc = [0] * 5 mean_adc = [0] * 5 std_var = [0] * 5 i = 0 j = 0 ############################################################ interval = [] for x in calibration: measure = [] #print " ============================================================================" #print " | CALIBRATION: |" #print " ============================================================================" # select DAC and write correspondent value base = int(((x + 10) / (20 / float(262144)))) interval.append(base) dac.write(base) time.sleep(30) measure = [] for i in range(total_measures): #------------------------------------------------------ # "adc_value = read()" without considering previous calibration # CNVST = 0 --> start conversion GPIO.output(CNV, GPIO.LOW) # bring CNVST back to "1" state GPIO.output(CNV, GPIO.HIGH) # read three bytes data = spi0.readbytes(3) adc_value = (data[0] << 10) + (data[1] << 2) + (data[2] >> 6) #------------------------------------------------------ measure.append(adc_value) # check if it is the first measure if (i == 0): min_adc[j] = measure[0] max_adc[j] = measure[0] mean_adc[j] = measure[0] * 1.0 # if not, calculate max, min and mean else: if (measure[i] < min_adc[j]): min_adc[j] = measure[i] if (measure[i] > max_adc[j]): max_adc[j] = measure[i] mean_adc[j] = (mean_adc[j] * i + measure[i]) / (i + 1) i += 1 adc_volt = float(adc_value) / 262143 * 20 - 10 adc_volt_str = str(adc_volt) adc_volt_str = adc_volt_str[0:adc_volt_str.find(".") + 8] #sys.stdout.write(" | " + str(adc_value) + "\t" + str(adc_value) + "\t\t\t\t\t\t\t" + "|" + "\n") j += 1 REFERENCE = mean_adc[0] # calculating gain correction theoretical_step = 20.0 / 262143 calibrated_step = 18.0 / (mean_adc[1] - mean_adc[0]) GAIN = calibrated_step / theoretical_step # calculating offset correction (around code 131072, 0V) interval = 9.0 / theoretical_step OFFSET = 131072 - interval - mean_adc[0] # return two parameters: gain and offset #output = [REFERENCE, GAIN, OFFSET] print "\treference = " + str(REFERENCE) print "\tgain = " + str(GAIN) print "\toffset = " + str(OFFSET)
import sys import numpy as np import Adafruit_BBIO.GPIO as GPIO import time import smbus bus = smbus.SMBus(2) # Use i2c bus 1 matrix = 0x70 # Use address 0x70 newcur_y = 1 newcur_x = 0 cur_x = 0 cur_y = 1 #setting up the GPIO pins that the buttons are using GPIO.setup("P9_11", GPIO.IN) #left GPIO.setup("P9_13", GPIO.IN) #right GPIO.setup("P9_23", GPIO.IN) #up GPIO.setup("P9_17", GPIO.IN) #down GPIO.setup("P9_27", GPIO.IN) #clear GPIO.setup("P9_24", GPIO.IN) #exit #initilizing button events GPIO.add_event_detect("P9_11", GPIO.FALLING) GPIO.add_event_detect("P9_13", GPIO.FALLING) GPIO.add_event_detect("P9_23", GPIO.FALLING) GPIO.add_event_detect("P9_17", GPIO.FALLING) GPIO.add_event_detect("P9_27", GPIO.FALLING) GPIO.add_event_detect("P9_24", GPIO.FALLING) print( "Welcome to Etch-A-Sketch! To start playing simply enter the dimensions ",
display(roundconfig['instructions'], 20, 0) for ctrlid in controlids: controlsetup = roundconfig[ctrlid] lcdwrite(controlsetup['name'], ctrlid) #there's more to setup of course def displayBar(num): lcd[0].setCursor(0, 3) lcd[0].message(chr(255) * num + ' ' * (20 - num)) #LCDs share a data bus but have different enable pins for i in range(3): lcd[i].pin_e = lcdpins[i] GPIO.setup(lcdpins[i], GPIO.OUT) GPIO.output(lcdpins[i], GPIO.LOW) lcd[0].begin(20, 4) display("Awaiting instructions!", 20, 0) lcd[1].begin(16, 2) display("Ready control 1!", 16, 1) lcd[2].begin(16, 2) display("Ready control 2!", 16, 2) for i in range(21): displayBar(i) for i in range(21): displayBar(20 - i)