def setup(self, direction, resistor=GPIO.PULL_UP):
if not direction in [GPIO.OUTPUT, GPIO.INPUT]:
raise IoTPy_APIError(
"Invalid GPIO direction. Should be GPIO.INPUT or GPIO.OUTPUT")
if direction == GPIO.INPUT and not resistor in [
GPIO.NONE, GPIO.PULL_UP, GPIO.PULL_DOWN
]:
raise IoTPy_APIError(
"Invalid GPIO resistor setting. Should be GPIO.NONE, GPIO.PULL_UP or GPIO.PULL_DOWN"
)
self.direction = direction
if direction == GPIO.INPUT:
self.resistor = resistor
if resistor == GPIO.PULL_UP:
mode = 4 # PULL_UP
elif resistor == GPIO.PULL_DOWN:
mode = 2 # PULL_DOWN
else:
mode = 0 # HIGH_Z
else:
mode = 1 # OUTPUT
self.board.uper_io(
0,
self.board.encode_sfp(
3, [self._logical_pins,
chr(mode) * len(self._logical_pins)]))
def __init__(self, pinout, serial_port=None):
"""__init__(self, pinout, serial_port=None)"""
ser = serial_port
if serial_port is None:
my_platform = platform.system()
if my_platform == "Windows":
ports_list = []
for i in xrange(256):
try:
ser = serial.Serial(i)
ports_list.append('COM' + str(i + 1))
ser.close()
except serial.SerialException:
pass
elif my_platform == "Darwin":
ports_list = glob.glob("/dev/tty.usbmodem*")
elif my_platform == "Linux":
ports_list = glob.glob("/dev/ttyACM*")
for my_port in ports_list:
try:
port_to_try = serial.Serial(
port=my_port,
baudrate=
230400, #virtual com port on USB is always max speed
parity=serial.PARITY_ODD,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=0.1)
port_to_try.write(self.encode_sfp(255, []))
uper_response = port_to_try.read(1) # read one, blocking
n = port_to_try.inWaiting() # look if there is more
if n:
uper_response = uper_response + port_to_try.read(n)
if self.decode_sfp(uper_response
)[0] == -1: # found port with UPER
ser = port_to_try
break
port_to_try.close()
except:
raise IoTPy_APIError("Unrecoverable serial port error.")
if not ser:
raise IoTPy_APIError("No UPER found on USB/serial ports.")
self.interrupts = [None] * 8
self.callbackdict = {}
self.ser = ser
self.ser.flush()
self.outq = Queue.Queue()
self.reader = Reader(self.ser, self.outq, self.internalCallBack,
self.decode_sfp)
self.devicename = "uper"
self.version = __version__
self.pinout = pinout
def uper_io(self, ret, output_buf):
try:
self.ser.write(output_buf)
except:
raise IoTPy_APIError(
"Unrecoverable serial port writing error, dying.")
data = None
if ret != 0:
try:
data = self.outq.get(True, 1)
except Queue.Empty:
raise IoTPy_APIError(
"Nothing to read on serial port exception.")
return data
def detach(self):
try:
interruptID = self.board.interrupts.index(self.logical_pin)
except ValueError:
errmsg("UPER API: trying to detach non existing interrupt.")
IoTPy_APIError("trying to detaching non existing interrupt.")
self.board.interrupts[interruptID] = None
try:
del self.board.callbackdict[self.logical_pin]
except KeyError:
errmsg("UPER API: trying to detach non existing interrupt.")
IoTPy_APIError("trying to detaching non existing interrupt.")
self.board.uper_io(0, self.board.encode_sfp(7, [interruptID]))
return True
def __init__(self, *args, **kw):
super(IoPinout, self).__init__(*args, **kw)
for key in self:
if not isinstance(key, int) or not isinstance(self[key], IoParams):
raise IoTPy_APIError(
"IoPinout must consist of integer keys and IoParams values."
)
def set_pulse_time(self, pulse_us):
"""
Set PWM high (on state) time.
:param pulse_us: Pulse time in microseconds.
:type pulse_us: int
:raise: IoTPy_APIError
"""
if self.primary:
self.board.uper_io(0, self.board.encode_sfp(
2, [self.logical_pin])) # set pin secondary function
self.primary = False
if 0 <= pulse_us <= PWM_PORT_RUNNING[self.pwm_port]['period']:
self.pulse_time = pulse_us
high_time = pulse_us
if self.polarity == 0:
high_time = PWM_PORT_RUNNING[
self.pwm_port]['period'] - pulse_us
self.board.uper_io(
0,
self.board.encode_sfp(
UPER1_PWM._PWM_PORT_FUNCTIONS[self.pwm_port][1],
[self.pwm_pin, high_time]))
else:
errmsg(
"UPER error: PWM high time is out of range on logical pin %d."
% self.logical_pin)
raise IoTPy_APIError("PWM high time is out of range.")
def width_us(self, hightime):
"""
Set PWM high (on state) time.
:param hightime: On state time in microseconds.
:type hightime: int
:raise: IoTPy_APIError
"""
if self.primary:
self.board.uper_io(0, self.board.encode_sfp(
2, [self.logical_pin])) # set pin secondary function
self.primary = False
if 0 <= hightime <= PWM_PORT_RUNNING[self.pwm_port]['period']:
self.hightime = hightime
if self.polarity == 1:
hightime = PWM_PORT_RUNNING[self.pwm_port]['period'] - hightime
self.board.uper_io(
0,
self.board.encode_sfp(
PWM._PWM_PORT_FUNCTIONS[self.pwm_port][1],
[self.pwm_pin, hightime]))
else:
errmsg(
"UPER error: PWM high time is out of range on logical pin %d."
% self.logical_pin)
raise IoTPy_APIError("PWM high time is out of range.")
def attach(self, mode, callback, user_object=None, debounce_time=50):
"""
Attach (enable) or reconfigure GPIO interrupt event.
:param mode: GPIO interrupt mode.
:param callback: User callback function. This function is executed when the interrupt event is received.
:param user_object: Optional user defined object, which will be passed back to the callback function.
:param debounce_time: Interrupt disable time in milliseconds after the triggering event. This is used to "debounce" buttons or \
to protect communication channel from data flood. Optional, default is 50ms.
:return: True
:raise: IoTPy_APIError
"""
try:
interruptID = self.board.interrupts.index(self.logical_pin)
self.board.uper_io(0, self.board.encode_sfp(
7, [interruptID])) #detach interrupt
except ValueError:
try:
interruptID = self.board.interrupts.index(None)
self.board.interrupts[interruptID] = self.logical_pin
except ValueError:
errmsg("UPER API: more than 8 interrupts requested")
raise IoTPy_APIError("Too many interrupts.")
self.board.callbackdict[self.logical_pin] = {
'mode': mode,
'callback': callback,
'userobject': user_object
}
self.board.uper_io(
0,
self.board.encode_sfp(
6, [interruptID, self.logical_pin, mode, debounce_time]))
return True
def SPI(self, name, clock=1000000, mode=SPI.MODE_0, *args, **kwargs):
_names = {"SPI0": 0, "SPI1": 1}
if isinstance(name, int):
port = name
elif isinstance(name, str):
if _names.has_key(name):
port = _names[name]
else:
raise IoTPy_APIError(
"Invalid SPI name %s. Must be one of %s." %
(name, ", ".join(sorted(_names.keys()))))
else:
raise IoTPy_APIError("PWM name must be an integer or a string")
divider = int(round(2.0e6 / clock))
return UPER1_SPI(self, port, divider, mode)
def decode_sfp(self, buffer):
"""
Decode SFP command from byte buffer.
:param buffer: A byte buffer which stores SFP command.
:type buffer: str
:return: A list containing decoded SFP function ID and arguments (if any).
"""
result = []
if buffer[0:1] != '\xd4':
return result
buflen = struct.unpack('>H', buffer[1:3])[0] + 3
result.append(struct.unpack('b', buffer[3:4])[0])
pointer = 4
args = []
while pointer < buflen:
argtype = ord(buffer[pointer:pointer + 1])
pointer += 1
if argtype < 64: # short int
args.append(argtype)
elif argtype < 128: # short str
arglen = argtype & 0x3f
args.append(buffer[pointer:pointer + arglen])
pointer += arglen
else:
arglen = argtype & 0x0f
if arglen < 4: # decoding integers
if arglen == 0:
args.append(ord(buffer[pointer:pointer + 1]))
elif arglen == 1:
args.append(
struct.unpack('>H',
buffer[pointer:pointer + 2])[0])
elif arglen == 2:
args.append(
struct.unpack('>I', '\x00' +
buffer[pointer:pointer + 3])[0])
elif arglen == 3:
args.append(
struct.unpack('>I',
buffer[pointer:pointer + 4])[0])
pointer += arglen + 1
else:
if argtype == 0xc4: # decoding strings
arglen = ord(buffer[pointer:pointer + 1])
elif argtype == 0xc5:
arglen = struct.unpack('>H',
buffer[pointer:pointer + 2])[0]
pointer += 1
else:
raise IoTPy_APIError(
"UPER API: Bad parameter type in decodeSFP method."
)
pointer += 1
args.append(buffer[pointer:pointer + arglen])
pointer += arglen
result.append(args)
return result
def __init__(self, board, pin):
self.board = board
if self.board.pinout[pin].capabilities & CAP_GPIO:
self.logical_pin = self.board.pinout[pin].pinID
else:
errmsg(
"UPER API: Pin No:%d is not GPIO pin, can't attach interrupt.",
pin)
raise IoTPy_APIError("Wrong Pin number.")
def __init__(self, board, pin):
self.board = board
if self.board.pinout[pin][0] & self.board.cap_gpio:
self.logical_pin = self.board.pinout[pin][1][0]
else:
errmsg(
"UPER API: Pin No:%d is not GPIO pin, can't attach interrupt.",
pin)
raise IoTPy_APIError("Wrong Pin number.")
def stop(self):
#for i in range(7):
# self.detachInterrupt(i)
try:
self.reader.stop()
self.ser.flush()
self.ser.close()
except:
raise IoTPy_APIError("UPER API: Serial/USB port disconnected.")
def _encode_bytes(self, bytestr):
if len(bytestr) < 64:
return chr(0x40 | len(bytestr)) + bytestr
packedlen = struct.pack('>I', len(bytestr)).lstrip('\x00')
if len(packedlen) == 1:
return '\xc4' + packedlen + bytestr
elif len(packedlen) == 2:
return '\xc5' + packedlen + bytestr
else:
raise IoTPy_APIError(
"UPER API: - too long string passed to UPER, encode_bytes can't handle it."
)
def __init__(self, board, pin):
self.board = board
if self.board.pinout[pin][0] & self.board.cap_adc:
self.logical_pin = self.board.pinout[pin][1][0]
else:
errmsg("UPER API: Pin No:%d is not an ADC pin.", pin)
raise IoTPy_APIError("Trying to assign ADC function to non ADC pin.")
self.adc_pin = self.board.pinout[pin][1][1]
self.board.uper_io(0, self.board.encode_sfp(3, [self.logical_pin, self.HIGH_Z]))
self.board.uper_io(0, self.board.encode_sfp(2, [self.logical_pin])) # set secondary pin function
self.pull = self.HIGH_Z
self.primary = False
def PWM(self, name, freq=100, polarity=1, *args, **kwargs):
_names = {
"PWM0_0": 27,
"PWM0_1": 28,
"PWM0_2": 34,
"PWM1_0": 10,
"PWM1_1": 39,
"PWM1_2": 3
}
if isinstance(name, int):
pin = name
elif isinstance(name, str):
if _names.has_key(name):
pin = _names[name]
else:
raise IoTPy_APIError(
"Invalid PWM name %s. Must be one of %s." %
(name, ", ".join(sorted(_names.keys()))))
else:
raise IoTPy_APIError("PWM name must be an integer or a string")
return UPER1_PWM(self, pin, freq, polarity)
def decode_sfp(self, buffer):
result = []
if buffer[0:1] != '\xd4':
return result
buflen = struct.unpack('>H', buffer[1:3])[0] + 3
result.append(struct.unpack('b', buffer[3:4])[0])
pointer = 4
args = []
while pointer < buflen:
argtype = ord(buffer[pointer:pointer + 1])
pointer += 1
if argtype < 64: #short int
args.append(argtype)
elif argtype < 128: #short str
arglen = argtype & 0x3f
args.append(buffer[pointer:pointer + arglen])
pointer += arglen
else:
arglen = argtype & 0x0f
if arglen < 4: #decoding integers
if arglen == 0:
args.append(ord(buffer[pointer:pointer + 1]))
elif arglen == 1:
args.append(
struct.unpack('>H',
buffer[pointer:pointer + 2])[0])
elif arglen == 2:
args.append(
struct.unpack('>I', '\x00' +
buffer[pointer:pointer + 3])[0])
elif arglen == 3:
args.append(
struct.unpack('>I',
buffer[pointer:pointer + 4])[0])
pointer += arglen + 1
else:
if argtype == 0xc4: #decoding strings
arglen = ord(buffer[pointer:pointer + 1])
elif argtype == 0xc5:
arglen = struct.unpack('>H',
buffer[pointer:pointer + 2])[0]
pointer += 1
else:
raise IoTPy_APIError(
"UPER API: Bad parameter type in decodeSFP method."
)
pointer += 1
args.append(buffer[pointer:pointer + arglen])
pointer += arglen
result.append(args)
return result
def __init__(self, board, pin):
self.board = board
if self.board.pinout[pin].capabilities & CAP_GPIO:
self.logical_pin = self.board.pinout[pin].pinID
else:
errmsg("UPER API: Pin No:%d is not GPIO pin.", pin)
raise IoTPy_APIError(
"Trying to assign GPIO function to non GPIO pin.")
self.direction = self.INPUT
self.pull = self.PULL_UP
self.board.uper_io(0, self.board.encode_sfp(
1, [self.logical_pin])) # set primary
self.primary = True
self.input_pullmode = self.PULL_UP
def __init__(self, board, pin):
self.board = board
if self.board.pinout[pin].capabilities & CAP_ADC:
self.logical_pin = self.board.pinout[pin].pinID
else:
errmsg("UPER API: Pin No:%d is not an ADC pin.", pin)
raise IoTPy_APIError(
"Trying to assign ADC function to non ADC pin.")
self.adc_pin = self.board.pinout[pin].extra[0]
self.board.uper_io(0, self.board.encode_sfp(
3, [self.logical_pin, 0])) # set GPIO to HIGH_Z
self.board.uper_io(0, self.board.encode_sfp(
2, [self.logical_pin])) # set secondary pin function
self.primary = False
def period(self, period):
if 0 <= period <= self.PWM_PORT_MAX[self.pwm_port]:
if PWM_PORT_RUNNING[self.pwm_port][1] != period:
self.board.uper_io(
0,
self.board.encode_sfp(
self.PWM_PORT_FUNCTIONS[self.pwm_port][0], [period]))
PWM_PORT_RUNNING[self.pwm_port][1] = period
self.PWM_PERIOD = period
else:
errmsg(
"UPER API: PWM period for port %d can be only between 0-%d" %
(self.pwm_port, self.PWM_PORT_MAX[self.pwm_port]))
raise IoTPy_APIError("PWM period is out of range.")
def setup(self, direction, resistor=GPIO.PULL_UP):
"""
Configure GPIO.
:param direction: GPIO direction: GPIO.OUTPUT or GPIO.INPUT
:param resistor: GPIO internal resistor mode. Used when direction is GPIO.INPUT. Should be GPIO.PULL_UP, \
GPIO.PULL_DOWN or GPIO.NONE.
:raise: IoTPy_APIError
"""
if not direction in [GPIO.OUTPUT, GPIO.INPUT]:
raise IoTPy_APIError(
"Invalid GPIO direction. Should be GPIO.INPUT or GPIO.OUTPUT")
if direction == GPIO.INPUT and not resistor in [
GPIO.NONE, GPIO.PULL_UP, GPIO.PULL_DOWN
]:
raise IoTPy_APIError(
"Invalid GPIO resistor setting. Should be GPIO.NONE, GPIO.PULL_UP or GPIO.PULL_DOWN"
)
self.direction = direction
if direction == GPIO.INPUT:
self.resistor = resistor
if resistor == GPIO.PULL_UP:
mode = 4 # PULL_UP
elif resistor == GPIO.PULL_DOWN:
mode = 2 # PULL_DOWN
else:
mode = 0 # HIGH_Z
else:
mode = 1 # OUTPUT
self.board.uper_io(0, self.board.encode_sfp(3,
[self.logical_pin, mode]))
def mode(self, pin_mode):
if pin_mode in [
self.HIGH_Z, self.PULL_UP, self.PULL_DOWN, self.OUTPUT
]:
if pin_mode != self.OUTPUT:
self.direction = self.INPUT
self.input_pullmode = pin_mode
self.pull = pin_mode
else:
self.direction = self.OUTPUT
self.board.uper_io(
0, self.board.encode_sfp(3, [self.logical_pin, pin_mode]))
else:
errmsg("UPER API: pinMode - Illegal pin mode - %d", pin_mode)
raise IoTPy_APIError("Illegal pin mode.")
def stop(self):
"""
Stop all communications with the board and close serial communication port.
:raise: IoTPy_APIError
"""
#for i in range(7):
# self.detachInterrupt(i)
try:
self.reader.stop()
self.ser.flush()
self.ser.close()
except:
raise IoTPy_APIError("UPER API: Serial/USB port disconnected.")
def __init__(self, board, pin):
self.board = board
if self.board.pinout[pin].capabilities & CAP_GPIO:
self.logical_pin = self.board.pinout[pin].pinID
else:
errmsg("UPER API: Pin No:%d is not GPIO pin.", pin)
raise IoTPy_APIError(
"Trying to assign GPIO function to non GPIO pin.")
# Configure default state to be input with pull-up resistor
self.direction = GPIO.INPUT
self.resistor = GPIO.PULL_UP
self.setup(self.direction, self.resistor)
self.board.uper_io(0, self.board.encode_sfp(
1, [self.logical_pin])) # set primary
def ADC(self, name, *args, **kwargs):
_names = {
"ADC0": 23,
"ADC1": 24,
"ADC2": 25,
"ADC3": 26,
"ADC4": 30,
"ADC5": 31,
"ADC6": 32,
"ADC7": 33
}
if isinstance(name, int):
pin = name
elif isinstance(name, str):
if _names.has_key(name):
pin = _names[name]
else:
raise IoTPy_APIError(
"Invalid ADC name %s. Must be one of %s." %
(name, ", ".join(sorted(_names.keys()))))
else:
raise IoTPy_APIError("ADC name must be an integer or a string")
return UPER1_ADC(self, pin)
def __init__(self, board, pin, polarity=1):
self.board = board
if self.board.pinout[pin][0] & self.board.cap_pwm:
self.logical_pin = self.board.pinout[pin][1][0]
else:
errmsg("UPER API: Pin No:%d is not a PWM pin.", pin)
raise IoTPy_APIError(
"Trying to assign PWM function to non PWM pin.")
self.pwm_port = self.board.pinout[pin][1][1]
self.pwm_pin = self.board.pinout[pin][1][2]
self.primary = True
self.hightime = 0
self.polarity = polarity
PWM_PORT_RUNNING[self.pwm_port][0] += 1
if PWM_PORT_RUNNING[self.pwm_port][0] == 1:
self.period(self.PWM_PERIOD)
def attach(self, mode, callback):
try:
interruptID = self.board.interrupts.index(self.logical_pin)
self.board.uper_io(0, self.board.encode_sfp(
7, [interruptID])) #detach interrupt
except ValueError:
try:
interruptID = self.board.interrupts.index(None)
self.board.interrupts[interruptID] = self.logical_pin
except ValueError:
errmsg("UPER API: more than 8 interrupts requested")
raise IoTPy_APIError("Too many interrupts.")
self.board.callbackdict[self.logical_pin] = [mode, callback]
self.board.uper_io(
0, self.board.encode_sfp(6, [interruptID, self.logical_pin, mode]))
return True
def __init__(self, board, pin, polarity=1):
self.board = board
if self.board.pinout[pin].capabilities & CAP_PWM:
self.logical_pin = self.board.pinout[pin].pinID
else:
errmsg("UPER API: Pin No:%d is not a PWM pin.", pin)
raise IoTPy_APIError(
"Trying to assign PWM function to non PWM pin.")
self.pwm_port = self.board.pinout[pin].extra[0]
self.pwm_pin = self.board.pinout[pin].extra[1]
self.primary = True
self.hightime = 0
self.polarity = polarity
PWM_PORT_RUNNING[self.pwm_port]['channels'] += 1
if PWM_PORT_RUNNING[self.pwm_port]['channels'] == 1:
self.period(10000)
def get_device_info(self):
device_info = []
result = self.decode_sfp(self.uper_io(1, self.encode_sfp(255, [])))
if result[0] != -1:
errmsg("UPER error: get_device_info wrong code.")
raise IoTPy_APIError("")
result = result[1]
if result[0] >> 24 != 0x55: # 0x55 == 'U'
print "UPER error: getDeviceInfo unknown device/firmware type"
return
device_info.append("UPER") # type
device_info.append((result[0] & 0x00ff0000) >> 16) #fw major
device_info.append(result[0] & 0x0000ffff) #fw minor
device_info.append(result[1]) # 16 bytes long unique ID from UPER CPU
device_info.append(result[2]) # UPER LPC CPU part number
device_info.append(result[3]) # UPER LPC CPU bootload code version
return device_info
def attach_irq(self,
event,
callback=None,
user_object=None,
debounce_time=50):
"""
Attach (enable) or reconfigure GPIO interrupt event.
:param event: GPIO interrupt event. Can have one of these values: GPIO.RISE, GPIO.FALL, GPIO.CHANGE, \
GPIO.LOW or GPIO.HIGH.
:param callback: User callback function. This function is executed when the interrupt event is received. \
It should take two arguments: interrupt event description and user object. Interrupt event descriptor is \
dictionary with three fields: 'id' - the interrupt ID (interrupt channel), 'event' - interrupt event type \
and 'values' - the logical values on each of interrupt channel (N-th bit represents logical pin value of \
interrupt channel N). User object is the same object as user_object.
:param user_object: User defined object, which will be passed back to the callback function. Optional, \
default is None.
:param debounce_time: Interrupt disable time in milliseconds after the triggering event. This is used to \
"debounce" buttons or to protect communication channel from data flood. Optional, default is 50ms.
:return: Logical interrupt ID
:rtype: int
:raise: IoTPy_APIError
"""
try:
irq_id = self.board.interrupts.index(self.logical_pin)
self.board.uper_io(0, self.board.encode_sfp(
7, [irq_id])) # detach interrupt
except ValueError:
try:
irq_id = self.board.interrupts.index(None)
self.board.interrupts[irq_id] = self.logical_pin
except ValueError:
errmsg("UPER API: more than 8 interrupts requested")
raise IoTPy_APIError("Too many interrupts.")
self.board.callbackdict[self.logical_pin] = {
'mode': event,
'callback': callback,
'userobject': user_object
}
self.board.uper_io(
0,
self.board.encode_sfp(
6, [irq_id, self.logical_pin, event, debounce_time]))
return irq_id