def test_gpio_setup():
chassis = Chassis()
for pin in chassis.get_stepper_pins():
assert GPIO.gpio_function(pin) == GPIO.OUT
for pin in chassis.get_sensor_pins():
assert GPIO.gpio_function(pin) == GPIO.IN
chassis.cleanup()
def main():
print("Executing Program")
counter = 0 #counter variable for progression in bit counter
sleep(1)
func = GPIO.gpio_function(31)
print(func)
func2 = GPIO.gpio_function(33)
print(func2)
while(True):
#if decrement button is pressed
if GPIO.event_detected(31): #listen for event(button press) on port 31
counter = counter-1
if counter == -1:
counter=7 #implement wrap around if it gets to 0
print(sequenceList[counter])
GPIO.output(outputList, sequenceList[counter]) #display counter value on LED's
sleep(.1)
print("Decrement button is working")
#if increment button is pressed
if GPIO.event_detected(29): #listen for event(button press) on port 29
counter = counter+1
if counter == 8:
counter=0 #implement wrap around if it gets to 7
print(sequenceList[counter])
GPIO.output(outputList, sequenceList[counter]) #display counter value on LED's
sleep(.1)
print("Increment button is working")
sleep(1)
def __exit__(self, exc_type, exc_val, exc_tb):
self.logger.info('GPIO channel function status:\nData pin [{0}]: {1}\nClock pin [{2}]: {3}'
.format(self.data_pin, GPIO_FUNCS[GPIO.gpio_function(self.data_pin)],
self.sck_pin, GPIO_FUNCS[GPIO.gpio_function(self.sck_pin)]))
GPIO.cleanup()
if exc_type is not None:
self.logger.error('Exception in with block: {0}\n{1}\n{2}'.format(exc_type, exc_val, exc_tb))
return False
def __exit__(self, exc_type, exc_val, exc_tb):
self.logger.info('GPIO channel function status:\nData pin [{0}]: {1}\nClock pin [{2}]: {3}'
.format(self.data_pin, GPIO_FUNCS[GPIO.gpio_function(self.data_pin)],
self.sck_pin, GPIO_FUNCS[GPIO.gpio_function(self.sck_pin)]))
GPIO.cleanup()
if exc_type is not None:
self.logger.error('Exception in with block: {0}\n{1}\n{2}'.format(exc_type, exc_val, exc_tb))
return False
def setup_pins():
GPIO.setup(pin_0_data_to_pet, GPIO.OUT, initial=GPIO.LOW) # DATA to PET (init. val. shouldn't matter).
GPIO.setup(pin_1_read_ack_from_pet, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # READ ACK from PET.
GPIO.setup(pin_2_wrt_rdy_to_pet, GPIO.OUT, initial=GPIO.HIGH) # WRITE READY to PET.
print('Pin 0 / ' + str(pin_0_data_to_pet) + ' (DATA to PET): ' + str(GPIO.gpio_function(pin_0_data_to_pet)))
print('Pin 1 / ' + str(pin_1_read_ack_from_pet) + ' (READ ACK from PET): ' + str(GPIO.gpio_function(pin_1_read_ack_from_pet)))
print('Pin 2 / ' + str(pin_2_wrt_rdy_to_pet) + ' (WRITE READY to PET): ' + str(GPIO.gpio_function(pin_2_wrt_rdy_to_pet)))
def test_cleanall(self):
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup()
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
def test_cleanall(self):
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup()
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
def main(self, args):
warnings.showwarning = self.showwarning
warnings.filterwarnings('ignore', category=CompoundPiStaleSequence)
warnings.filterwarnings('ignore', category=CompoundPiStaleClientTime)
pidfile = daemon.runner.make_pidlockfile(args.pidfile, 5)
if daemon.runner.is_pidfile_stale(pidfile):
pidfile.break_lock()
address = socket.getaddrinfo(
args.bind, args.port, 0, socket.SOCK_DGRAM)[0][-1]
logging.info('Listening on %s:%d', address[0], address[1])
self.server = CompoundPiUDPServer(address, CameraRequestHandler)
# Test GPIO before entering the daemon context (GPIO access usually
# requires root privileges for access to /dev/mem - better to bomb out
# earlier than later)
GPIO.setmode(GPIO.BCM)
GPIO.gpio_function(5)
# Ensure the server's socket, any log file, and stderr are preserved
# (if not forking)
files_preserve = [self.server.socket]
for handler in logging.getLogger().handlers:
if isinstance(handler, logging.FileHandler):
files_preserve.append(handler.stream)
logging.info('Entering daemon context')
with daemon.DaemonContext(
# The following odd construct is to ensure detachment only
# where sensible (see default setting of detach_process)
detach_process=None if args.daemon else False,
stderr=None if args.daemon else sys.stderr,
uid=args.user, gid=args.group,
files_preserve=files_preserve,
pidfile=pidfile,
signal_map={
signal.SIGTERM: self.terminate,
signal.SIGINT: self.interrupt,
}
):
# seed the random number generator from the system clock
random.seed()
logging.info('Initializing camera')
self.server.seqno = 0
self.server.client_address = None
self.server.client_timestamp = None
self.server.responders = {}
self.server.images = []
self.server.camera = picamera.PiCamera()
try:
logging.info('Starting server thread')
thread = threading.Thread(target=self.server.serve_forever)
thread.start()
while thread.is_alive():
thread.join(1)
logging.info('Server thread ended')
finally:
logging.info('Closing camera')
self.server.camera.close()
logging.info('Exiting daemon context')
def test_gpio_function():
GPIO_DEVEL.Reset()
GPIO.setmode(GPIO.BCM)
assert GPIO.gpio_function(16) == 16
GPIO_DEVEL.Reset()
GPIO.setmode(GPIO.BOARD)
assert GPIO.gpio_function(16) == 11
def runTest(self):
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN_BCM, GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN_BCM), GPIO.IN)
GPIO.setup(LED_PIN_BCM, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN_BCM), GPIO.OUT)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(LED_PIN, GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
GPIO.setup(LED_PIN, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
def runTest(self):
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN_BCM, GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN_BCM), GPIO.IN)
GPIO.setup(LED_PIN_BCM, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN_BCM), GPIO.OUT)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(LED_PIN, GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
GPIO.setup(LED_PIN, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
def privileged_setup(self, args):
# Bind to the socket before entering daemon context in case the port
# requested is privileged
address = socket.getaddrinfo(args.bind, args.port, 0,
socket.SOCK_DGRAM)[0][-1]
logging.info('Listening on %s:%d', address[0], address[1])
self.server = CompoundPiUDPServer(address, CompoundPiServerProtocol)
# Test GPIO before entering the daemon context (GPIO access usually
# requires root privileges for access to /dev/mem - better to bomb out
# earlier than later)
GPIO.setmode(GPIO.BCM)
GPIO.gpio_function(5)
def __del__( self ): """ ---------------------------------------------------------------------- Destructs this ultrasonic sensor, closing any open GPIO pins ---------------------------------------------------------------------- """ GPIO.setmode( GPIO.BCM ) if( GPIO.gpio_function( self._trigger_pin ) != GPIO.UNKNOWN ): GPIO.cleanup( self._trigger_pin ) if( GPIO.gpio_function( self._echo_pin ) != GPIO.UNKNOWN ): GPIO.cleanup( self._echo_pin )
def privileged_setup(self, args):
# Bind to the socket before entering daemon context in case the port
# requested is privileged
address = socket.getaddrinfo(
args.bind, args.port, 0, socket.SOCK_DGRAM)[0][-1]
logging.info('Listening on %s:%d', address[0], address[1])
self.server = CompoundPiUDPServer(address, CompoundPiServerProtocol)
# Test GPIO before entering the daemon context (GPIO access usually
# requires root privileges for access to /dev/mem - better to bomb out
# earlier than later)
GPIO.setmode(GPIO.BCM)
GPIO.gpio_function(5)
def __exit__(self, exc_type, exc_val, exc_tb):
self.logger.info('GPIO channel function status:\n'
'Clock pin [{0}]: {1}\n'
'MOSI pin [{2}]: {3}\n'
'MISO pin [{4}]: {5}\n'
'CS pin [{6}]: {7}'
.format(self._sck_pin, GPIO_FUNCS[GPIO.gpio_function(self._sck_pin)],
self._mosi_pin, GPIO_FUNCS[GPIO.gpio_function(self._mosi_pin)],
self._miso_pin, GPIO_FUNCS[GPIO.gpio_function(self._miso_pin)],
self._cs_pin, GPIO_FUNCS[GPIO.gpio_function(self._cs_pin)]))
GPIO.cleanup()
if exc_type is not None:
self.logger.error('Exception in with block: {0}\n{1}\n{2}'.format(exc_type, exc_val, exc_tb))
return False
def test_cleanone(self):
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
GPIO.setup(SWITCH_PIN, GPIO.IN)
GPIO.setup(LOOP_IN, GPIO.IN)
GPIO.add_event_detect(SWITCH_PIN, GPIO.FALLING)
GPIO.add_event_detect(LOOP_IN, GPIO.RISING)
time.sleep(0.2) # wait for udev to set permissions
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
self.assertEqual(GPIO.gpio_function(SWITCH_PIN), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LOOP_IN), GPIO.IN)
self.assertTrue(
os.path.exists('/sys/class/gpio/gpio%s' % SWITCH_PIN_BCM))
self.assertTrue(os.path.exists('/sys/class/gpio/gpio%s' % LOOP_IN_BCM))
GPIO.cleanup(SWITCH_PIN)
time.sleep(0.2) # wait for udev to set permissions
self.assertFalse(
os.path.exists('/sys/class/gpio/gpio%s' % SWITCH_PIN_BCM))
self.assertTrue(os.path.exists('/sys/class/gpio/gpio%s' % LOOP_IN_BCM))
GPIO.cleanup(LOOP_IN)
time.sleep(0.2) # wait for udev to set permissions
self.assertFalse(
os.path.exists('/sys/class/gpio/gpio%s' % SWITCH_PIN_BCM))
self.assertFalse(os.path.exists('/sys/class/gpio/gpio%s' %
LOOP_IN_BCM))
GPIO.cleanup(LOOP_OUT)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup(LED_PIN)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
def __init__(self, input_a, input_b, start_speed = 100.0, speed_change = 10.0, start_direction = 0):
#if speed_change < 0.0 or speed_change > 100.0:
#raise ValueError("Speed change must be between 0.0 and 100.0")
GPIO.setmode(GPIO.BOARD)
self._input_a_original = GPIO.gpio_function(input_a)
self._input_b_original = GPIO.gpio_function(input_b)
self._input_a = input_a
self._input_b = input_b
GPIO.setup(self._input_a, GPIO.OUT)
GPIO.setup(self._input_b, GPIO.OUT)
self._direction = start_direction
self._pwm = None
self._pwm_duty_cycle = 100.0 - start_speed
self._pwm_duty_cycle_step = speed_change
self._status = L9110MotorController.STATUS_STOPPED
def index(request):
context = {}
mode = _handle_mode(request)
context["mode"] = MODE_TO_STR[mode]
if mode == io.BCM:
MAX_PINS = 26
else:
MAX_PINS = 40
pin_states = []
for i in range(1, MAX_PINS+1):
try:
m = io.gpio_function(i)
if m <= 1:
io.setup(i, m)
s = io.input(i)
else:
s = 'NA'
pin_states.append(dict(number=i,
type=LOOKUP[m],
state=s,
is_input=s==io.IN,
is_serial=s not in [io.IN,io.OUT],
min=0,
max=100,
value=0))
except ValueError:
logging.debug("Bad pin {}".format(i))
context["pin_states"] = pin_states
return render(request, 'pinner.html', context)
def test_gpio_function():
GPIO.setmode(GPIO.BCM)
for chan in range(54):
try:
f = GPIO.gpio_function(chan)
if f == GPIO.IN:
func = 'INPUT'
elif f == GPIO.OUT:
func = 'OUTPUT'
elif f == GPIO.SERIAL:
func = 'SERIAL'
elif f == GPIO.I2C:
func = 'I2C'
elif f == GPIO.SPI:
func = 'SPI'
elif f == GPIO.PWM:
func = 'PWM'
elif f == GPIO.UNKNOWN:
func = 'UNKNOWN'
else:
func = 'ERROR'
print('GPIO %s func=%s'%(chan,func))
except ValueError: # ignore unused channels
pass
GPIO.setmode(GPIO.BOARD)
def on_api_command(self, command, data):
try:
selected_power = int(data.get("power"))
selected_pin = int(data.get("pin"))
GPIO.setmode(GPIO.BOARD)
# first check pins not in use already
usage = GPIO.gpio_function(selected_pin)
self._logger.debug("usage on pin %s is %s" % (selected_pin, usage))
# 1 = input
if usage is not 1:
# 555 is not http specific so I chose it
return "", 555
# before read don't let the pin float
if selected_power is 0:
GPIO.setup(selected_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
else:
GPIO.setup(selected_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
pin_value = GPIO.input(selected_pin)
# reset input to pull down after read
GPIO.cleanup(selected_pin)
triggered_bool = pin_value is selected_power
return flask.jsonify(triggered=triggered_bool)
except ValueError:
# ValueError occurs when reading from power or ground pins
return "", 556
def readIOState(self, pins):
states = {}
for pin in pins:
states['pin' + str(pin)] = \
{'function': self.pins_functions[GPIO.gpio_function(pin)],
'value': GPIO.input(pin), 'pin': pin}
return states
def mode(environ, response, parameter = None):
pin_modes = {
1: "GPIO.IN",
0: "GPIO.OUT",
41: "GPIO.SPI",
42: "GPIO.I2C",
43: "GPIO.HARD_PWM",
40: "GPIO.SERIAL",
-1: "GPIO.UNKNOWN"
}
status = "200 OK"
header = [
("Content-Type", "application/json"),
("Cache-Control", "no-store, no-cache, must-revalidate"),
("Expires", "0")
]
try:
result = pin_modes[ GPIO.gpio_function(int(parameter[0])) ]
except Exception as e:
status = "400 Bad Request"
result = str(e)
response(status, header)
return [json.dumps(result).encode()]
def __init__(self,pinlist):
self._pins = pinlist
for p in pinlist:
if GPIO.gpio_function(p)==GPIO.OUT:
GPIO.setup(p,GPIO.OUT)
else:
GPIO.setup(p,GPIO.OUT,initial=GPIO.LOW)
def inner(pins, *args, **kwargs):
if pins is None:
raise NoSuchPinException
for pin in pins:
if GPIO.gpio_function(pin) != GPIO.OUT:
raise InvalidIOMode
return func(pins, *args, **kwargs)
def pincheck(self):
bRet = True
dummy = gpio.gpio_function(self.PinIn1)
if dummy not in [-1,1]:
self.Log = ('PinIn1: %s!') % pin_use[dummy]
bRet = False
dummy = gpio.gpio_function(self.PinIn2)
if dummy not in [-1,1]:
self.Log = ('PinIn2: %s!') % pin_use[dummy]
bRet = False
if self.PinEnable > 0:
dummy = gpio.gpio_function(self.PinEnable)
if dummy not in [-1,1]:
self.Log = ('PinEnable: %s!') % pin_use[dummy]
bRet = False
return bRet
def test_gpio_function():
GPIO.setmode(GPIO.BCM)
for chan in range(54):
try:
f = GPIO.gpio_function(chan)
if f == GPIO.IN:
func = 'INPUT'
elif f == GPIO.OUT:
func = 'OUTPUT'
elif f == GPIO.SERIAL:
func = 'SERIAL'
elif f == GPIO.I2C:
func = 'I2C'
elif f == GPIO.SPI:
func = 'SPI'
elif f == GPIO.PWM:
func = 'PWM'
elif f == GPIO.UNKNOWN:
func = 'UNKNOWN'
else:
func = 'ERROR'
print('GPIO %s func=%s' % (chan, func))
except ValueError: # ignore unused channels
pass
GPIO.setmode(GPIO.BOARD)
def DataFile():
pinNum = []
mode = []
voltage = []
for i in range(32):
pinNum.append(i)
thisMode = GPIO.gpio_function(i)
if thisMode == 1:
mode.append("IN")
GPIO.setup(i, GPIO.IN)
voltage.append(GPIO.input(i))
elif thisMode == 0:
mode.append("OUT")
GPIO.setup(i, GPIO.OUT)
voltage.append(GPIO.input(i))
else:
mode.append("ALT[#]")
voltage.append(-1)
file = open("data.txt", "w")
simplejson.dump(pinNum, file)
file.write("\n")
simplejson.dump(mode, file)
file.write("\n")
simplejson.dump(voltage, file)
file.write("\n")
file.close()
total = []
for i in range(32):
total.append("Pin " + str(i) + ",type " + mode[i] + ", voltage " +
str(voltage[i]) + "\n")
showinfo("All data", total)
def checkPin(pinNumber):
cPin = pinList[pinNumber]
cPin.type.value = pinTypeKey[boardType[pinNumber]]
if cPin.type.value == 'GPIO':
cPin.usage.value = portUse[GPIO.gpio_function(pinNumber)]
cPin.voltage.value = voltageDict[voltage(pinNumber)]
cPin.bcm.value = bcmDict[pinNumber]
def on_settings_save(self, data):
if "pin" in data and "gpio_mode" in data:
mode_to_save = int(data.get("gpio_mode"))
pin_to_save = int(data.get("pin"))
if pin_to_save is not None:
# check if pin is not power/ground pin or out of range but allow -1
if pin_to_save is not self.pin_num_disabled:
try:
# BOARD
if mode_to_save is 10:
# before saving check if pin not used by others
usage = GPIO.gpio_function(pin_to_save)
self._logger.debug("usage on pin %s is %s" %
(pin_to_save, usage))
if usage is not 1:
self._logger.info(
"You are trying to save pin %s which is already used by others"
% (pin_to_save))
self._plugin_manager.send_plugin_message(
self._identifier,
dict(
type="error",
autoClose=True,
msg=
"Settings not saved, you are trying to save pin which is already used by others"
))
return
# BCM
elif mode_to_save is 11:
if pin_to_save > 27:
self._logger.info(
"You are trying to save pin %s which is out of range"
% (pin_to_save))
self._plugin_manager.send_plugin_message(
self._identifier,
dict(
type="error",
autoClose=True,
msg=
"Settings not saved, you are trying to save pin which is out of range"
))
except ValueError:
self._logger.info(
"You are trying to save pin %s which is ground/power pin or out of range"
% (pin_to_save))
self._plugin_manager.send_plugin_message(
self._identifier,
dict(
type="error",
autoClose=True,
msg=
"Settings not saved, you are trying to save pin which is ground/power pin or out of range"
))
return
octoprint.plugin.SettingsPlugin.on_settings_save(self, data)
def registerHandler(self, icallback):
print("icallback")
print(icallback)
print(self.pinNum)
print("Self")
print(self)
self.inputcallback = icallback
print(GPIO.gpio_function(self.pinNum))
def init():
"""Prepare the GPIO pins by setting the mode they will be referenced
and running cleanup"""
gpio.setmode(REFMODE)
for i in PINS:
if gpio.gpio_function(i) == gpio.OUT:
gpio.cleanup()
break
def setupPin(self, pin, force=False):
func = GPIO.gpio_function(pin)
if func != 0 and force != True:
raise PinInUseError(pin, func)
else:
GPIO.setup(pin, GPIO.IN)
return 0
def init():
"""Prepare the GPIO pins by setting the mode they will be referenced
and running cleanup"""
gpio.setmode(REFMODE)
for i in PINS:
if gpio.gpio_function(i) == gpio.OUT:
gpio.cleanup()
break
def _pin_direction(self, pin):
pin = self.__pin_to_int(pin)
function = GPIO.gpio_function(pin)
if function == GPIO.IN:
return ahio.Direction.Input
elif function == GPIO.OUT or function == GPIO.PWM:
return ahio.Direction.Output
else:
return None
def PWM_Fun (pin, duty_cycle) :
GPIO.setmode (GPIO.BOARD)
frequence = 50
GPIO.setup (pin, GPIO.OUT)
state = GPIO.gpio_function (pin)
print ("On est dans l'etat {0} pour la pin {1} avec un duty cycle de {2} !".format (state, pin, duty_cycle))
pwm = GPIO.PWM (pin, frequence)
pwm.start (duty_cycle)
return pwm
def getPinFunctionName(pin):
functions = {GPIO.IN:'Input',
GPIO.OUT:'Output',
GPIO.I2C:'I2C',
GPIO.SPI:'SPI',
GPIO.HARD_PWM:'HARD_PWM',
GPIO.SERIAL:'Serial',
GPIO.UNKNOWN:'Unknown'}
return functions[GPIO.gpio_function(pin)]
def getPinFunctionName(self):
pin = self.pin
functions = {pi.IN:'Input',
pi.OUT:'Output',
pi.I2C:'I2C',
pi.SPI:'SPI',
pi.HARD_PWM:'HARD_PWM',
pi.SERIAL:'Serial',
pi.UNKNOWN:'Unknown'}
return functions[pi.gpio_function(pin)]
def rpi_gpio_chk_function(self): retstr = '' pin=10 func = GPIO.gpio_function(pin) if func == GPIO.SPI: retstr += 'SPI ' pin=2 func = GPIO.gpio_function(pin) if func == GPIO.I2C: retstr += 'I2C ' pin=14 func = GPIO.gpio_function(pin) if func == GPIO.SERIAL: retstr += 'Serial ' pin=18 func = GPIO.gpio_function(pin) if func == GPIO.HARD_PWM: retstr += 'PWM ' return(retstr)
def getPinFunctionName(self):
pin = self.pin
functions = {pi.IN:'Input',
pi.OUT:'Output',
pi.I2C:'I2C',
pi.SPI:'SPI',
pi.HARD_PWM:'HARD_PWM',
pi.SERIAL:'Serial',
pi.UNKNOWN:'Unknown'}
return functions[pi.gpio_function(pin)]
def gpio_function_name_from_pin(self,gpio):
typestr = "Unknown"
try:
pinnum = int(gpio)
if pinnum>0:
typeint = GPIO.gpio_function(pinnum)
typestr = self.gpio_function_name(typeint)
except Exception as e:
typestr = "Unknown"
return typestr
def gpio_is_in_use(gpio):
"""
check if GPIO is in use
"""
gpio_used = gpio.gpio_function(gpio)
if gpio_used == -1:
return False
else:
return True
def __init__(self,
input_a,
input_b,
start_speed=100.0,
speed_change=10.0,
start_direction=0):
#if speed_change < 0.0 or speed_change > 100.0:
#raise ValueError("Speed change must be between 0.0 and 100.0")
GPIO.setmode(GPIO.BOARD)
self._input_a_original = GPIO.gpio_function(input_a)
self._input_b_original = GPIO.gpio_function(input_b)
self._input_a = input_a
self._input_b = input_b
GPIO.setup(self._input_a, GPIO.OUT)
GPIO.setup(self._input_b, GPIO.OUT)
self._direction = start_direction
self._pwm = None
self._pwm_duty_cycle = 100.0 - start_speed
self._pwm_duty_cycle_step = speed_change
self._status = L9110MotorController.STATUS_STOPPED
def __init__(self, firstPin, lastPin):
self.pins = []
for p in range(firstPin, lastPin + 1):
func = ""
try:
func = GPIO.gpio_function(p)
except ValueError:
func = -2
self.pins.append(PinIO(p, func, False))
print("RPi constructor")
def status(self):
port_list = {0:"GPIO.OUT", 1:"GPIO.IN",40:"GPIO.SERIAL",41:"GPIO.SPI",42:"GPIO.I2C",43:"GPIO.HARD_PWM", -1:"GPIO.UNKNOWN"}
# loop through the list of ports/pins querying and displaying the status of each
nothing = "Pin type not available in port_list"
port_used = GPIO.gpio_function(self.pin)
for k,v in port_list.items():
if port_used == k:
return v
else:
logging.info(" Status Unknown ")
return "none"
def getgpiomode(self, pin, text=False):
if not self._init:
return 10
if not pin in self._gpioavailable:
return 5
tmp = GPIO.gpio_function(pin)
if text:
return self._gpiostate[tmp]
return tmp
def getPinFunctionName(pin):
# Unused
functions = {GPIO.IN:'Input',
GPIO.OUT:'Output',
GPIO.I2C:'I2C',
GPIO.SPI:'SPI',
GPIO.HARD_PWM:'HARD_PWM',
GPIO.SERIAL:'Serial',
GPIO.UNKNOWN:'Unknown'}
return functions[GPIO.gpio_function(pin)]
def getgpiomode(self,pin,text=False):
if not self._init:
return 10
if not pin in self._gpioavailable:
return 5
tmp=GPIO.gpio_function(pin)
if text:
return self._gpiostate[tmp]
return tmp
def test_gpio_function():
for chan in range(54):
f = GPIO.gpio_function(chan)
if f == GPIO.IN:
func = 'INPUT'
elif f == GPIO.OUT:
func = 'OUTPUT'
elif f == GPIO.ALT0:
func = 'ALT0'
else:
func = 'UNKNOWN'
print('chan=%s func=%s' % (chan, func))
def test_gpio_function():
for chan in range(54):
f = GPIO.gpio_function(chan)
if f == GPIO.IN:
func = 'INPUT'
elif f == GPIO.OUT:
func = 'OUTPUT'
elif f == GPIO.ALT0:
func = 'ALT0'
else:
func = 'UNKNOWN'
print('chan=%s func=%s'%(chan,func))
def setGpioInput(pin_number, pull_up_down, call_back_func, bounce_time):
if (pin_number not in Pi_Non_GPIO_Pin_List) and pin_number<=30:
setting = GPIO.gpio_function(pin_number)
#if setting==GPIO.IN:
# return
GPIO.setup(pin_number, GPIO.IN, pull_up_down)
GPIO.add_event_detect(pin_number, GPIO.BOTH)
#if pull_up_down==GPIO.PUD_UP:
# GPIO.add_event_detect(pin_number, GPIO.FALLING)
#elif pull_up_down==GPIO.PUD_DOWN:
# GPIO.add_event_detect(pin_number, GPIO.RISING)
#if call_back_func in vars():
GPIO.add_event_callback(pin_number, call_back_func, bounce_time)
def test_cleanlist(self):
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup([LOOP_OUT])
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup([LED_PIN])
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
GPIO.cleanup([LOOP_OUT,LED_PIN])
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
def gpio_status(pin):
status = "on"
direction = GPIO.gpio_function(pin)
if (direction == GPIO.IN):
status = "off"
elif (direction == GPIO.OUT):
GPIO.setup(pin, GPIO.OUT)
if (GPIO.input(pin) == GPIO.HIGH):
status = "off"
else:
return "Unknown GPIO" + str(pin) + " function: " + str(direction)
return "GPIO" + str(pin) + ": " + status
def diag():
print("Revision:", GPIO.RPI_INFO['REVISION'])
print("Version:", GPIO.VERSION)
print('Board mode', nrmodes[GPIO.getmode()])
GPIO.setmode(GPIO.BCM)
print('Board mode', nrmodes[GPIO.getmode()])
for i in range(2,28):
pm = pinmodes[GPIO.gpio_function(i)]
if pm == 'IN':
GPIO.setup(i, GPIO.IN)
print('Pin {:2d} {:4s} {} {}'.format(i, pm, GPIO.input(i), tctl[i]))
else:
print('Pin {:2d} {:6s} {}'.format(i, pm, tctl[i]))
def piGpioCommandCallback(handler):
command_string_list = commandStringSplit(handler.data)
if len(command_string_list)<4 or (not 'pi' in command_string_list):
return
if 'io' in command_string_list:
pin_number = int(command_string_list[2])
if 'out' in command_string_list and '1' in command_string_list:
print pin_number
setGpioOutput(pin_number, GPIO.HIGH)
return handler.data
elif 'out' in command_string_list and '0' in command_string_list:
print pin_number
setGpioOutput(pin_number, GPIO.LOW)
return handler.data
#elif 'in' in command_string_list:
#setGpioInput(pin_number, GPIO.PUD_UP, gpioInputCallback, 10)
#return handler.data
#elif 'Input:PullDown' in command_string_list:
#setGpioInput(pin_number, GPIO.PUD_DOWN, gpioInputCallback, 10)
elif 'req' in command_string_list:
setting = GPIO.gpio_function(pin_number)
if setting==GPIO.IN:
return (handler.data+'in')
else:
return (handler.data+'out')
elif 'set' in command_string_list and 'In' in command_string_list:
setGpioInput(pin_number, GPIO.PUD_UP, gpioInputCallback, 10)
return handler.data
elif 'set' in command_string_list and 'Out' in command_string_list:
print "set pin to output"
GPIO.remove_event_detect(pin_number)
GPIO.setup(pin_number, GPIO.OUT)
return handler.data
elif 'level' in command_string_list:
if GPIO.input(pin_number)==1:
msgOut = 'pi.io.level.1.' + str(pin_number)
else:
msgOut = 'pi.io.level.0.' + str(pin_number)
sendToTcpServer(msgOut)
return ''
return 'error'
def reset_pin(_M, _time):
import RPi.GPIO as GPIO
from models import session
from models import Device
from models import Module
from models import Event_Log
from time import sleep
from sys import stdout
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
if GPIO.gpio_function(_M.gpio) == 0:
switch_on(_M)
sleep(_time)
switch_off(_M)
else:
print 'ERROR! This pin is set as a input'
def switch_off(_M):
import RPi.GPIO as GPIO
from models import session
from models import Device
from models import Module
from models import Event_Log
from time import sleep
from sys import stdout
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
if GPIO.gpio_function(_M.gpio) == 0:
GPIO.setup(_M.gpio, GPIO.OUT, initial=GPIO.HIGH)
GPIO.output(_M.gpio, GPIO.LOW)
_M.status = False
session.commit()
else:
print 'ERROR! This pin is set as a input'
def test_cleantuple(self):
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.OUT)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup((LOOP_OUT,))
GPIO.setmode(GPIO.BOARD)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.OUT)
GPIO.cleanup((LED_PIN,))
GPIO.setmode(GPIO.BOARD)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
GPIO.setup(LOOP_OUT, GPIO.OUT)
GPIO.setup(LED_PIN, GPIO.OUT)
GPIO.cleanup((LOOP_OUT,LED_PIN))
GPIO.setmode(GPIO.BOARD)
self.assertEqual(GPIO.gpio_function(LOOP_OUT), GPIO.IN)
self.assertEqual(GPIO.gpio_function(LED_PIN), GPIO.IN)
def main(args=None):
cli = argparse.ArgumentParser()
cli.add_argument(
'-s', '--status',
dest='exitcode', default=False, action='store_true',
help='use the exit status to indicate pin state (with no output)')
cli.add_argument(
metavar='PIN',
dest='pin', type=int,
help='the GPIO pin number to read from or write to')
cli.add_argument(
metavar='STATE', nargs='?',
dest='state', default=None, type=boolstr,
help='if specified, the boolean state to write to PIN')
options = cli.parse_args(args)
# todo: figure out how to leave the state of a pin permanent...
# (then i can re-enable the ".cleanup")
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
curfunc = GPIO.gpio_function(options.pin)
try:
if options.state is None:
GPIO.setup(options.pin, curfunc)
if options.exitcode:
return GPIO.input(options.pin)
print 'function:',function_map.get(curfunc, '[invalid]')
print 'state:',GPIO.input(options.pin)
return 0
GPIO.setup(options.pin, GPIO.OUT)
GPIO.output(options.pin, options.state)
return 0
finally:
pass
def state(self):
state = {}
mode = {}
mode_strs = {
GPIO.IN: "input",
GPIO.OUT: "output",
GPIO.SPI: "SPI",
GPIO.I2C: "I2C",
GPIO.HARD_PWM: "hard PWM",
GPIO.SERIAL: "serial",
GPIO.UNKNOWN: "unknown"
}
pin = 1
try:
while pin < 100:
state[pin] = GPIO.input(pin)
mode[pin] = mode_strs[GPIO.gpio_function(pin)]
pin += 1
except Exception as e:
print(e)
return ok_msg({ 'state': state, 'mode': mode })
def _handle_mode(request):
"""
given a request, look for mode= in the query args and set the current mode to that if needed
update the mode
add a message to the request
return the MODES
"""
strmode = request.GET.get('mode', "")
old_mode = io.getmode()
if not strmode:
mode = old_mode
else:
mode = MODES[strmode.lower()]
if old_mode != mode:
io.setup(3, io.gpio_function(3)) # THIS IS A HACK TO GET CLEANUP TO WORK
io.cleanup()
try:
io.setmode(mode)
messages.warning(request, "New io mode: {}. All pins reset".format(MODE_TO_STR[mode]))
except ValueError:
messages.error(request, "Could not switch to new io mode: {}".format(MODE_TO_STR[mode]))
mode = old_mode
return mode
