partition stringclasses 3 values | func_name stringlengths 1 134 | docstring stringlengths 1 46.9k | path stringlengths 4 223 | original_string stringlengths 75 104k | code stringlengths 75 104k | docstring_tokens listlengths 1 1.97k | repo stringlengths 7 55 | language stringclasses 1 value | url stringlengths 87 315 | code_tokens listlengths 19 28.4k | sha stringlengths 40 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|
valid | convert_avgpool | Convert Average pooling.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/pooling_layers.py | def convert_avgpool(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert Average pooling.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting pooling ...')
if names == 'short':
tf_name = 'P' + random_string(7)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
if 'kernel_shape' in params:
height, width = params['kernel_shape']
else:
height, width = params['kernel_size']
if 'strides' in params:
stride_height, stride_width = params['strides']
else:
stride_height, stride_width = params['stride']
if 'pads' in params:
padding_h, padding_w, _, _ = params['pads']
else:
padding_h, padding_w = params['padding']
input_name = inputs[0]
pad = 'valid'
if height % 2 == 1 and width % 2 == 1 and \
height // 2 == padding_h and width // 2 == padding_w and \
stride_height == 1 and stride_width == 1:
pad = 'same'
else:
padding_name = tf_name + '_pad'
padding_layer = keras.layers.ZeroPadding2D(
padding=(padding_h, padding_w),
name=padding_name
)
layers[padding_name] = padding_layer(layers[inputs[0]])
input_name = padding_name
# Pooling type AveragePooling2D
pooling = keras.layers.AveragePooling2D(
pool_size=(height, width),
strides=(stride_height, stride_width),
padding=pad,
name=tf_name,
data_format='channels_first'
)
layers[scope_name] = pooling(layers[input_name]) | def convert_avgpool(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert Average pooling.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting pooling ...')
if names == 'short':
tf_name = 'P' + random_string(7)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
if 'kernel_shape' in params:
height, width = params['kernel_shape']
else:
height, width = params['kernel_size']
if 'strides' in params:
stride_height, stride_width = params['strides']
else:
stride_height, stride_width = params['stride']
if 'pads' in params:
padding_h, padding_w, _, _ = params['pads']
else:
padding_h, padding_w = params['padding']
input_name = inputs[0]
pad = 'valid'
if height % 2 == 1 and width % 2 == 1 and \
height // 2 == padding_h and width // 2 == padding_w and \
stride_height == 1 and stride_width == 1:
pad = 'same'
else:
padding_name = tf_name + '_pad'
padding_layer = keras.layers.ZeroPadding2D(
padding=(padding_h, padding_w),
name=padding_name
)
layers[padding_name] = padding_layer(layers[inputs[0]])
input_name = padding_name
# Pooling type AveragePooling2D
pooling = keras.layers.AveragePooling2D(
pool_size=(height, width),
strides=(stride_height, stride_width),
padding=pad,
name=tf_name,
data_format='channels_first'
)
layers[scope_name] = pooling(layers[input_name]) | [
"Convert",
"Average",
"pooling",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/pooling_layers.py#L9-L71 | [
"def",
"convert_avgpool",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting pooling ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'P'",
"+",
"random_string",
"(",
"7",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"if",
"'kernel_shape'",
"in",
"params",
":",
"height",
",",
"width",
"=",
"params",
"[",
"'kernel_shape'",
"]",
"else",
":",
"height",
",",
"width",
"=",
"params",
"[",
"'kernel_size'",
"]",
"if",
"'strides'",
"in",
"params",
":",
"stride_height",
",",
"stride_width",
"=",
"params",
"[",
"'strides'",
"]",
"else",
":",
"stride_height",
",",
"stride_width",
"=",
"params",
"[",
"'stride'",
"]",
"if",
"'pads'",
"in",
"params",
":",
"padding_h",
",",
"padding_w",
",",
"_",
",",
"_",
"=",
"params",
"[",
"'pads'",
"]",
"else",
":",
"padding_h",
",",
"padding_w",
"=",
"params",
"[",
"'padding'",
"]",
"input_name",
"=",
"inputs",
"[",
"0",
"]",
"pad",
"=",
"'valid'",
"if",
"height",
"%",
"2",
"==",
"1",
"and",
"width",
"%",
"2",
"==",
"1",
"and",
"height",
"//",
"2",
"==",
"padding_h",
"and",
"width",
"//",
"2",
"==",
"padding_w",
"and",
"stride_height",
"==",
"1",
"and",
"stride_width",
"==",
"1",
":",
"pad",
"=",
"'same'",
"else",
":",
"padding_name",
"=",
"tf_name",
"+",
"'_pad'",
"padding_layer",
"=",
"keras",
".",
"layers",
".",
"ZeroPadding2D",
"(",
"padding",
"=",
"(",
"padding_h",
",",
"padding_w",
")",
",",
"name",
"=",
"padding_name",
")",
"layers",
"[",
"padding_name",
"]",
"=",
"padding_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")",
"input_name",
"=",
"padding_name",
"# Pooling type AveragePooling2D",
"pooling",
"=",
"keras",
".",
"layers",
".",
"AveragePooling2D",
"(",
"pool_size",
"=",
"(",
"height",
",",
"width",
")",
",",
"strides",
"=",
"(",
"stride_height",
",",
"stride_width",
")",
",",
"padding",
"=",
"pad",
",",
"name",
"=",
"tf_name",
",",
"data_format",
"=",
"'channels_first'",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"pooling",
"(",
"layers",
"[",
"input_name",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_maxpool3 | Convert 3d Max pooling.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/pooling_layers.py | def convert_maxpool3(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert 3d Max pooling.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting pooling ...')
if names == 'short':
tf_name = 'P' + random_string(7)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
if 'kernel_shape' in params:
height, width, depth = params['kernel_shape']
else:
height, width, depth = params['kernel_size']
if 'strides' in params:
stride_height, stride_width, stride_depth = params['strides']
else:
stride_height, stride_width, stride_depth = params['stride']
if 'pads' in params:
padding_h, padding_w, padding_d, _, _ = params['pads']
else:
padding_h, padding_w, padding_d = params['padding']
input_name = inputs[0]
if padding_h > 0 and padding_w > 0 and padding_d > 0:
padding_name = tf_name + '_pad'
padding_layer = keras.layers.ZeroPadding3D(
padding=(padding_h, padding_w, padding_d),
name=padding_name
)
layers[padding_name] = padding_layer(layers[inputs[0]])
input_name = padding_name
# Pooling type
pooling = keras.layers.MaxPooling3D(
pool_size=(height, width, depth),
strides=(stride_height, stride_width, stride_depth),
padding='valid',
name=tf_name
)
layers[scope_name] = pooling(layers[input_name]) | def convert_maxpool3(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert 3d Max pooling.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting pooling ...')
if names == 'short':
tf_name = 'P' + random_string(7)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
if 'kernel_shape' in params:
height, width, depth = params['kernel_shape']
else:
height, width, depth = params['kernel_size']
if 'strides' in params:
stride_height, stride_width, stride_depth = params['strides']
else:
stride_height, stride_width, stride_depth = params['stride']
if 'pads' in params:
padding_h, padding_w, padding_d, _, _ = params['pads']
else:
padding_h, padding_w, padding_d = params['padding']
input_name = inputs[0]
if padding_h > 0 and padding_w > 0 and padding_d > 0:
padding_name = tf_name + '_pad'
padding_layer = keras.layers.ZeroPadding3D(
padding=(padding_h, padding_w, padding_d),
name=padding_name
)
layers[padding_name] = padding_layer(layers[inputs[0]])
input_name = padding_name
# Pooling type
pooling = keras.layers.MaxPooling3D(
pool_size=(height, width, depth),
strides=(stride_height, stride_width, stride_depth),
padding='valid',
name=tf_name
)
layers[scope_name] = pooling(layers[input_name]) | [
"Convert",
"3d",
"Max",
"pooling",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/pooling_layers.py#L140-L196 | [
"def",
"convert_maxpool3",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting pooling ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'P'",
"+",
"random_string",
"(",
"7",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"if",
"'kernel_shape'",
"in",
"params",
":",
"height",
",",
"width",
",",
"depth",
"=",
"params",
"[",
"'kernel_shape'",
"]",
"else",
":",
"height",
",",
"width",
",",
"depth",
"=",
"params",
"[",
"'kernel_size'",
"]",
"if",
"'strides'",
"in",
"params",
":",
"stride_height",
",",
"stride_width",
",",
"stride_depth",
"=",
"params",
"[",
"'strides'",
"]",
"else",
":",
"stride_height",
",",
"stride_width",
",",
"stride_depth",
"=",
"params",
"[",
"'stride'",
"]",
"if",
"'pads'",
"in",
"params",
":",
"padding_h",
",",
"padding_w",
",",
"padding_d",
",",
"_",
",",
"_",
"=",
"params",
"[",
"'pads'",
"]",
"else",
":",
"padding_h",
",",
"padding_w",
",",
"padding_d",
"=",
"params",
"[",
"'padding'",
"]",
"input_name",
"=",
"inputs",
"[",
"0",
"]",
"if",
"padding_h",
">",
"0",
"and",
"padding_w",
">",
"0",
"and",
"padding_d",
">",
"0",
":",
"padding_name",
"=",
"tf_name",
"+",
"'_pad'",
"padding_layer",
"=",
"keras",
".",
"layers",
".",
"ZeroPadding3D",
"(",
"padding",
"=",
"(",
"padding_h",
",",
"padding_w",
",",
"padding_d",
")",
",",
"name",
"=",
"padding_name",
")",
"layers",
"[",
"padding_name",
"]",
"=",
"padding_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")",
"input_name",
"=",
"padding_name",
"# Pooling type",
"pooling",
"=",
"keras",
".",
"layers",
".",
"MaxPooling3D",
"(",
"pool_size",
"=",
"(",
"height",
",",
"width",
",",
"depth",
")",
",",
"strides",
"=",
"(",
"stride_height",
",",
"stride_width",
",",
"stride_depth",
")",
",",
"padding",
"=",
"'valid'",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"pooling",
"(",
"layers",
"[",
"input_name",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_adaptive_max_pool2d | Convert convert_adaptive_max_pool2d layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/pooling_layers.py | def convert_adaptive_max_pool2d(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert convert_adaptive_max_pool2d layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting adaptive_avg_pool2d...')
if names == 'short':
tf_name = 'APOL' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
global_pool = keras.layers.GlobalMaxPooling2D(data_format='channels_first', name=tf_name)
layers[scope_name] = global_pool(layers[inputs[0]])
def target_layer(x):
import keras
return keras.backend.expand_dims(x)
lambda_layer = keras.layers.Lambda(target_layer, name=tf_name + 'E')
layers[scope_name] = lambda_layer(layers[scope_name]) # double expand dims
layers[scope_name] = lambda_layer(layers[scope_name]) | def convert_adaptive_max_pool2d(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert convert_adaptive_max_pool2d layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting adaptive_avg_pool2d...')
if names == 'short':
tf_name = 'APOL' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
global_pool = keras.layers.GlobalMaxPooling2D(data_format='channels_first', name=tf_name)
layers[scope_name] = global_pool(layers[inputs[0]])
def target_layer(x):
import keras
return keras.backend.expand_dims(x)
lambda_layer = keras.layers.Lambda(target_layer, name=tf_name + 'E')
layers[scope_name] = lambda_layer(layers[scope_name]) # double expand dims
layers[scope_name] = lambda_layer(layers[scope_name]) | [
"Convert",
"convert_adaptive_max_pool2d",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/pooling_layers.py#L233-L264 | [
"def",
"convert_adaptive_max_pool2d",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting adaptive_avg_pool2d...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'APOL'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"global_pool",
"=",
"keras",
".",
"layers",
".",
"GlobalMaxPooling2D",
"(",
"data_format",
"=",
"'channels_first'",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"global_pool",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")",
"def",
"target_layer",
"(",
"x",
")",
":",
"import",
"keras",
"return",
"keras",
".",
"backend",
".",
"expand_dims",
"(",
"x",
")",
"lambda_layer",
"=",
"keras",
".",
"layers",
".",
"Lambda",
"(",
"target_layer",
",",
"name",
"=",
"tf_name",
"+",
"'E'",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"scope_name",
"]",
")",
"# double expand dims",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"scope_name",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_padding | Convert padding layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/padding_layers.py | def convert_padding(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert padding layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting padding...')
if params['mode'] == 'constant':
# raise AssertionError('Cannot convert non-constant padding')
if params['value'] != 0.0:
raise AssertionError('Cannot convert non-zero padding')
if names:
tf_name = 'PADD' + random_string(4)
else:
tf_name = w_name + str(random.random())
# Magic ordering
padding_name = tf_name
padding_layer = keras.layers.ZeroPadding2D(
padding=((params['pads'][2], params['pads'][6]), (params['pads'][3], params['pads'][7])),
name=padding_name
)
layers[scope_name] = padding_layer(layers[inputs[0]])
elif params['mode'] == 'reflect':
def target_layer(x, pads=params['pads']):
# x = tf.transpose(x, [0, 2, 3, 1])
layer = tf.pad(x, [[0, 0], [0, 0], [pads[2], pads[6]], [pads[3], pads[7]]], 'REFLECT')
# layer = tf.transpose(layer, [0, 3, 1, 2])
return layer
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | def convert_padding(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert padding layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting padding...')
if params['mode'] == 'constant':
# raise AssertionError('Cannot convert non-constant padding')
if params['value'] != 0.0:
raise AssertionError('Cannot convert non-zero padding')
if names:
tf_name = 'PADD' + random_string(4)
else:
tf_name = w_name + str(random.random())
# Magic ordering
padding_name = tf_name
padding_layer = keras.layers.ZeroPadding2D(
padding=((params['pads'][2], params['pads'][6]), (params['pads'][3], params['pads'][7])),
name=padding_name
)
layers[scope_name] = padding_layer(layers[inputs[0]])
elif params['mode'] == 'reflect':
def target_layer(x, pads=params['pads']):
# x = tf.transpose(x, [0, 2, 3, 1])
layer = tf.pad(x, [[0, 0], [0, 0], [pads[2], pads[6]], [pads[3], pads[7]]], 'REFLECT')
# layer = tf.transpose(layer, [0, 3, 1, 2])
return layer
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | [
"Convert",
"padding",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/padding_layers.py#L9-L52 | [
"def",
"convert_padding",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting padding...'",
")",
"if",
"params",
"[",
"'mode'",
"]",
"==",
"'constant'",
":",
"# raise AssertionError('Cannot convert non-constant padding')",
"if",
"params",
"[",
"'value'",
"]",
"!=",
"0.0",
":",
"raise",
"AssertionError",
"(",
"'Cannot convert non-zero padding'",
")",
"if",
"names",
":",
"tf_name",
"=",
"'PADD'",
"+",
"random_string",
"(",
"4",
")",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"# Magic ordering",
"padding_name",
"=",
"tf_name",
"padding_layer",
"=",
"keras",
".",
"layers",
".",
"ZeroPadding2D",
"(",
"padding",
"=",
"(",
"(",
"params",
"[",
"'pads'",
"]",
"[",
"2",
"]",
",",
"params",
"[",
"'pads'",
"]",
"[",
"6",
"]",
")",
",",
"(",
"params",
"[",
"'pads'",
"]",
"[",
"3",
"]",
",",
"params",
"[",
"'pads'",
"]",
"[",
"7",
"]",
")",
")",
",",
"name",
"=",
"padding_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"padding_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")",
"elif",
"params",
"[",
"'mode'",
"]",
"==",
"'reflect'",
":",
"def",
"target_layer",
"(",
"x",
",",
"pads",
"=",
"params",
"[",
"'pads'",
"]",
")",
":",
"# x = tf.transpose(x, [0, 2, 3, 1])",
"layer",
"=",
"tf",
".",
"pad",
"(",
"x",
",",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
",",
"[",
"pads",
"[",
"2",
"]",
",",
"pads",
"[",
"6",
"]",
"]",
",",
"[",
"pads",
"[",
"3",
"]",
",",
"pads",
"[",
"7",
"]",
"]",
"]",
",",
"'REFLECT'",
")",
"# layer = tf.transpose(layer, [0, 3, 1, 2])",
"return",
"layer",
"lambda_layer",
"=",
"keras",
".",
"layers",
".",
"Lambda",
"(",
"target_layer",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_batchnorm | Convert batch normalization layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/normalization_layers.py | def convert_batchnorm(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert batch normalization layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting batchnorm ...')
if names == 'short':
tf_name = 'BN' + random_string(6)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
bias_name = '{0}.bias'.format(w_name)
weights_name = '{0}.weight'.format(w_name)
mean_name = '{0}.running_mean'.format(w_name)
var_name = '{0}.running_var'.format(w_name)
if bias_name in weights:
beta = weights[bias_name].numpy()
if weights_name in weights:
gamma = weights[weights_name].numpy()
mean = weights[mean_name].numpy()
variance = weights[var_name].numpy()
eps = params['epsilon']
momentum = params['momentum']
if weights_name not in weights:
bn = keras.layers.BatchNormalization(
axis=1, momentum=momentum, epsilon=eps,
center=False, scale=False,
weights=[mean, variance],
name=tf_name
)
else:
bn = keras.layers.BatchNormalization(
axis=1, momentum=momentum, epsilon=eps,
weights=[gamma, beta, mean, variance],
name=tf_name
)
layers[scope_name] = bn(layers[inputs[0]]) | def convert_batchnorm(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert batch normalization layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting batchnorm ...')
if names == 'short':
tf_name = 'BN' + random_string(6)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
bias_name = '{0}.bias'.format(w_name)
weights_name = '{0}.weight'.format(w_name)
mean_name = '{0}.running_mean'.format(w_name)
var_name = '{0}.running_var'.format(w_name)
if bias_name in weights:
beta = weights[bias_name].numpy()
if weights_name in weights:
gamma = weights[weights_name].numpy()
mean = weights[mean_name].numpy()
variance = weights[var_name].numpy()
eps = params['epsilon']
momentum = params['momentum']
if weights_name not in weights:
bn = keras.layers.BatchNormalization(
axis=1, momentum=momentum, epsilon=eps,
center=False, scale=False,
weights=[mean, variance],
name=tf_name
)
else:
bn = keras.layers.BatchNormalization(
axis=1, momentum=momentum, epsilon=eps,
weights=[gamma, beta, mean, variance],
name=tf_name
)
layers[scope_name] = bn(layers[inputs[0]]) | [
"Convert",
"batch",
"normalization",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/normalization_layers.py#L9-L61 | [
"def",
"convert_batchnorm",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting batchnorm ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'BN'",
"+",
"random_string",
"(",
"6",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"bias_name",
"=",
"'{0}.bias'",
".",
"format",
"(",
"w_name",
")",
"weights_name",
"=",
"'{0}.weight'",
".",
"format",
"(",
"w_name",
")",
"mean_name",
"=",
"'{0}.running_mean'",
".",
"format",
"(",
"w_name",
")",
"var_name",
"=",
"'{0}.running_var'",
".",
"format",
"(",
"w_name",
")",
"if",
"bias_name",
"in",
"weights",
":",
"beta",
"=",
"weights",
"[",
"bias_name",
"]",
".",
"numpy",
"(",
")",
"if",
"weights_name",
"in",
"weights",
":",
"gamma",
"=",
"weights",
"[",
"weights_name",
"]",
".",
"numpy",
"(",
")",
"mean",
"=",
"weights",
"[",
"mean_name",
"]",
".",
"numpy",
"(",
")",
"variance",
"=",
"weights",
"[",
"var_name",
"]",
".",
"numpy",
"(",
")",
"eps",
"=",
"params",
"[",
"'epsilon'",
"]",
"momentum",
"=",
"params",
"[",
"'momentum'",
"]",
"if",
"weights_name",
"not",
"in",
"weights",
":",
"bn",
"=",
"keras",
".",
"layers",
".",
"BatchNormalization",
"(",
"axis",
"=",
"1",
",",
"momentum",
"=",
"momentum",
",",
"epsilon",
"=",
"eps",
",",
"center",
"=",
"False",
",",
"scale",
"=",
"False",
",",
"weights",
"=",
"[",
"mean",
",",
"variance",
"]",
",",
"name",
"=",
"tf_name",
")",
"else",
":",
"bn",
"=",
"keras",
".",
"layers",
".",
"BatchNormalization",
"(",
"axis",
"=",
"1",
",",
"momentum",
"=",
"momentum",
",",
"epsilon",
"=",
"eps",
",",
"weights",
"=",
"[",
"gamma",
",",
"beta",
",",
"mean",
",",
"variance",
"]",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"bn",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_instancenorm | Convert instance normalization layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/normalization_layers.py | def convert_instancenorm(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert instance normalization layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting instancenorm ...')
if names == 'short':
tf_name = 'IN' + random_string(6)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
assert(len(inputs) == 3)
bias_name = '{0}.bias'.format(w_name)
weights_name = '{0}.weight'.format(w_name)
# Use previously taken constants
if inputs[-2] + '_np' in layers:
gamma = layers[inputs[-2] + '_np']
else:
gamma = weights[weights_name].numpy()
if inputs[-1] + '_np' in layers:
beta = layers[inputs[-1] + '_np']
else:
beta = weights[bias_name].numpy()
def target_layer(x, epsilon=params['epsilon'], gamma=gamma, beta=beta):
layer = tf.contrib.layers.instance_norm(
x,
param_initializers={'beta': tf.constant_initializer(beta), 'gamma': tf.constant_initializer(gamma)},
epsilon=epsilon, data_format='NCHW',
trainable=False
)
return layer
lambda_layer = keras.layers.Lambda(target_layer, name=tf_name)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | def convert_instancenorm(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert instance normalization layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting instancenorm ...')
if names == 'short':
tf_name = 'IN' + random_string(6)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
assert(len(inputs) == 3)
bias_name = '{0}.bias'.format(w_name)
weights_name = '{0}.weight'.format(w_name)
# Use previously taken constants
if inputs[-2] + '_np' in layers:
gamma = layers[inputs[-2] + '_np']
else:
gamma = weights[weights_name].numpy()
if inputs[-1] + '_np' in layers:
beta = layers[inputs[-1] + '_np']
else:
beta = weights[bias_name].numpy()
def target_layer(x, epsilon=params['epsilon'], gamma=gamma, beta=beta):
layer = tf.contrib.layers.instance_norm(
x,
param_initializers={'beta': tf.constant_initializer(beta), 'gamma': tf.constant_initializer(gamma)},
epsilon=epsilon, data_format='NCHW',
trainable=False
)
return layer
lambda_layer = keras.layers.Lambda(target_layer, name=tf_name)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | [
"Convert",
"instance",
"normalization",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/normalization_layers.py#L64-L112 | [
"def",
"convert_instancenorm",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting instancenorm ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'IN'",
"+",
"random_string",
"(",
"6",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"assert",
"(",
"len",
"(",
"inputs",
")",
"==",
"3",
")",
"bias_name",
"=",
"'{0}.bias'",
".",
"format",
"(",
"w_name",
")",
"weights_name",
"=",
"'{0}.weight'",
".",
"format",
"(",
"w_name",
")",
"# Use previously taken constants",
"if",
"inputs",
"[",
"-",
"2",
"]",
"+",
"'_np'",
"in",
"layers",
":",
"gamma",
"=",
"layers",
"[",
"inputs",
"[",
"-",
"2",
"]",
"+",
"'_np'",
"]",
"else",
":",
"gamma",
"=",
"weights",
"[",
"weights_name",
"]",
".",
"numpy",
"(",
")",
"if",
"inputs",
"[",
"-",
"1",
"]",
"+",
"'_np'",
"in",
"layers",
":",
"beta",
"=",
"layers",
"[",
"inputs",
"[",
"-",
"1",
"]",
"+",
"'_np'",
"]",
"else",
":",
"beta",
"=",
"weights",
"[",
"bias_name",
"]",
".",
"numpy",
"(",
")",
"def",
"target_layer",
"(",
"x",
",",
"epsilon",
"=",
"params",
"[",
"'epsilon'",
"]",
",",
"gamma",
"=",
"gamma",
",",
"beta",
"=",
"beta",
")",
":",
"layer",
"=",
"tf",
".",
"contrib",
".",
"layers",
".",
"instance_norm",
"(",
"x",
",",
"param_initializers",
"=",
"{",
"'beta'",
":",
"tf",
".",
"constant_initializer",
"(",
"beta",
")",
",",
"'gamma'",
":",
"tf",
".",
"constant_initializer",
"(",
"gamma",
")",
"}",
",",
"epsilon",
"=",
"epsilon",
",",
"data_format",
"=",
"'NCHW'",
",",
"trainable",
"=",
"False",
")",
"return",
"layer",
"lambda_layer",
"=",
"keras",
".",
"layers",
".",
"Lambda",
"(",
"target_layer",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_dropout | Convert dropout.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/normalization_layers.py | def convert_dropout(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert dropout.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting dropout ...')
if names == 'short':
tf_name = 'DO' + random_string(6)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
dropout = keras.layers.Dropout(rate=params['ratio'], name=tf_name)
layers[scope_name] = dropout(layers[inputs[0]]) | def convert_dropout(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert dropout.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting dropout ...')
if names == 'short':
tf_name = 'DO' + random_string(6)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
dropout = keras.layers.Dropout(rate=params['ratio'], name=tf_name)
layers[scope_name] = dropout(layers[inputs[0]]) | [
"Convert",
"dropout",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/normalization_layers.py#L115-L138 | [
"def",
"convert_dropout",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting dropout ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'DO'",
"+",
"random_string",
"(",
"6",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"dropout",
"=",
"keras",
".",
"layers",
".",
"Dropout",
"(",
"rate",
"=",
"params",
"[",
"'ratio'",
"]",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"dropout",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_relu | Convert relu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_relu(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert relu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting relu ...')
if names == 'short':
tf_name = 'RELU' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
relu = keras.layers.Activation('relu', name=tf_name)
layers[scope_name] = relu(layers[inputs[0]]) | def convert_relu(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert relu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting relu ...')
if names == 'short':
tf_name = 'RELU' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
relu = keras.layers.Activation('relu', name=tf_name)
layers[scope_name] = relu(layers[inputs[0]]) | [
"Convert",
"relu",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L9-L32 | [
"def",
"convert_relu",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting relu ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'RELU'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"relu",
"=",
"keras",
".",
"layers",
".",
"Activation",
"(",
"'relu'",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"relu",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_lrelu | Convert leaky relu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_lrelu(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert leaky relu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting lrelu ...')
if names == 'short':
tf_name = 'lRELU' + random_string(3)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
leakyrelu = \
keras.layers.LeakyReLU(alpha=params['alpha'], name=tf_name)
layers[scope_name] = leakyrelu(layers[inputs[0]]) | def convert_lrelu(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert leaky relu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting lrelu ...')
if names == 'short':
tf_name = 'lRELU' + random_string(3)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
leakyrelu = \
keras.layers.LeakyReLU(alpha=params['alpha'], name=tf_name)
layers[scope_name] = leakyrelu(layers[inputs[0]]) | [
"Convert",
"leaky",
"relu",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L35-L59 | [
"def",
"convert_lrelu",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting lrelu ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'lRELU'",
"+",
"random_string",
"(",
"3",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"leakyrelu",
"=",
"keras",
".",
"layers",
".",
"LeakyReLU",
"(",
"alpha",
"=",
"params",
"[",
"'alpha'",
"]",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"leakyrelu",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_sigmoid | Convert sigmoid layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_sigmoid(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert sigmoid layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting sigmoid ...')
if names == 'short':
tf_name = 'SIGM' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
sigmoid = keras.layers.Activation('sigmoid', name=tf_name)
layers[scope_name] = sigmoid(layers[inputs[0]]) | def convert_sigmoid(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert sigmoid layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting sigmoid ...')
if names == 'short':
tf_name = 'SIGM' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
sigmoid = keras.layers.Activation('sigmoid', name=tf_name)
layers[scope_name] = sigmoid(layers[inputs[0]]) | [
"Convert",
"sigmoid",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L62-L85 | [
"def",
"convert_sigmoid",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting sigmoid ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'SIGM'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"sigmoid",
"=",
"keras",
".",
"layers",
".",
"Activation",
"(",
"'sigmoid'",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"sigmoid",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_softmax | Convert softmax layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_softmax(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert softmax layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting softmax ...')
if names == 'short':
tf_name = 'SMAX' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
def target_layer(x, dim=params['dim']):
import keras
return keras.activations.softmax(x, axis=dim)
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | def convert_softmax(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert softmax layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting softmax ...')
if names == 'short':
tf_name = 'SMAX' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
def target_layer(x, dim=params['dim']):
import keras
return keras.activations.softmax(x, axis=dim)
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | [
"Convert",
"softmax",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L88-L115 | [
"def",
"convert_softmax",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting softmax ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'SMAX'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"def",
"target_layer",
"(",
"x",
",",
"dim",
"=",
"params",
"[",
"'dim'",
"]",
")",
":",
"import",
"keras",
"return",
"keras",
".",
"activations",
".",
"softmax",
"(",
"x",
",",
"axis",
"=",
"dim",
")",
"lambda_layer",
"=",
"keras",
".",
"layers",
".",
"Lambda",
"(",
"target_layer",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_tanh | Convert tanh layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_tanh(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert tanh layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting tanh ...')
if names == 'short':
tf_name = 'TANH' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
tanh = keras.layers.Activation('tanh', name=tf_name)
layers[scope_name] = tanh(layers[inputs[0]]) | def convert_tanh(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert tanh layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting tanh ...')
if names == 'short':
tf_name = 'TANH' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
tanh = keras.layers.Activation('tanh', name=tf_name)
layers[scope_name] = tanh(layers[inputs[0]]) | [
"Convert",
"tanh",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L118-L141 | [
"def",
"convert_tanh",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting tanh ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'TANH'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"tanh",
"=",
"keras",
".",
"layers",
".",
"Activation",
"(",
"'tanh'",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"tanh",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_hardtanh | Convert hardtanh layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_hardtanh(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert hardtanh layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting hardtanh (clip) ...')
def target_layer(x, max_val=float(params['max_val']), min_val=float(params['min_val'])):
return tf.minimum(max_val, tf.maximum(min_val, x))
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | def convert_hardtanh(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert hardtanh layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting hardtanh (clip) ...')
def target_layer(x, max_val=float(params['max_val']), min_val=float(params['min_val'])):
return tf.minimum(max_val, tf.maximum(min_val, x))
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | [
"Convert",
"hardtanh",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L144-L163 | [
"def",
"convert_hardtanh",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting hardtanh (clip) ...'",
")",
"def",
"target_layer",
"(",
"x",
",",
"max_val",
"=",
"float",
"(",
"params",
"[",
"'max_val'",
"]",
")",
",",
"min_val",
"=",
"float",
"(",
"params",
"[",
"'min_val'",
"]",
")",
")",
":",
"return",
"tf",
".",
"minimum",
"(",
"max_val",
",",
"tf",
".",
"maximum",
"(",
"min_val",
",",
"x",
")",
")",
"lambda_layer",
"=",
"keras",
".",
"layers",
".",
"Lambda",
"(",
"target_layer",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_selu | Convert selu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/activation_layers.py | def convert_selu(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert selu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting selu ...')
if names == 'short':
tf_name = 'SELU' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
selu = keras.layers.Activation('selu', name=tf_name)
layers[scope_name] = selu(layers[inputs[0]]) | def convert_selu(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert selu layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting selu ...')
if names == 'short':
tf_name = 'SELU' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
selu = keras.layers.Activation('selu', name=tf_name)
layers[scope_name] = selu(layers[inputs[0]]) | [
"Convert",
"selu",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/activation_layers.py#L166-L189 | [
"def",
"convert_selu",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting selu ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'SELU'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"selu",
"=",
"keras",
".",
"layers",
".",
"Activation",
"(",
"'selu'",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"selu",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_upsample_bilinear | Convert upsample_bilinear2d layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/upsampling_layers.py | def convert_upsample_bilinear(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert upsample_bilinear2d layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting upsample...')
if names == 'short':
tf_name = 'UPSL' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
output_size = params['output_size']
align_corners = params['align_corners'] > 0
def target_layer(x, size=output_size, align_corners=align_corners):
import tensorflow as tf
x = tf.transpose(x, [0, 2, 3, 1])
x = tf.image.resize_images(x, size, align_corners=align_corners)
x = tf.transpose(x, [0, 3, 1, 2])
return x
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | def convert_upsample_bilinear(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert upsample_bilinear2d layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting upsample...')
if names == 'short':
tf_name = 'UPSL' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
output_size = params['output_size']
align_corners = params['align_corners'] > 0
def target_layer(x, size=output_size, align_corners=align_corners):
import tensorflow as tf
x = tf.transpose(x, [0, 2, 3, 1])
x = tf.image.resize_images(x, size, align_corners=align_corners)
x = tf.transpose(x, [0, 3, 1, 2])
return x
lambda_layer = keras.layers.Lambda(target_layer)
layers[scope_name] = lambda_layer(layers[inputs[0]]) | [
"Convert",
"upsample_bilinear2d",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/upsampling_layers.py#L9-L42 | [
"def",
"convert_upsample_bilinear",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting upsample...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'UPSL'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"output_size",
"=",
"params",
"[",
"'output_size'",
"]",
"align_corners",
"=",
"params",
"[",
"'align_corners'",
"]",
">",
"0",
"def",
"target_layer",
"(",
"x",
",",
"size",
"=",
"output_size",
",",
"align_corners",
"=",
"align_corners",
")",
":",
"import",
"tensorflow",
"as",
"tf",
"x",
"=",
"tf",
".",
"transpose",
"(",
"x",
",",
"[",
"0",
",",
"2",
",",
"3",
",",
"1",
"]",
")",
"x",
"=",
"tf",
".",
"image",
".",
"resize_images",
"(",
"x",
",",
"size",
",",
"align_corners",
"=",
"align_corners",
")",
"x",
"=",
"tf",
".",
"transpose",
"(",
"x",
",",
"[",
"0",
",",
"3",
",",
"1",
",",
"2",
"]",
")",
"return",
"x",
"lambda_layer",
"=",
"keras",
".",
"layers",
".",
"Lambda",
"(",
"target_layer",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"lambda_layer",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_upsample | Convert nearest upsampling layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/upsampling_layers.py | def convert_upsample(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert nearest upsampling layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting upsample...')
if params['mode'] != 'nearest':
raise AssertionError('Cannot convert non-nearest upsampling')
if names == 'short':
tf_name = 'UPSL' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
if 'height_scale' in params:
scale = (params['height_scale'], params['width_scale'])
elif len(inputs) == 2:
scale = layers[inputs[-1] + '_np'][-2:]
upsampling = keras.layers.UpSampling2D(
size=scale, name=tf_name
)
layers[scope_name] = upsampling(layers[inputs[0]]) | def convert_upsample(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert nearest upsampling layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting upsample...')
if params['mode'] != 'nearest':
raise AssertionError('Cannot convert non-nearest upsampling')
if names == 'short':
tf_name = 'UPSL' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
if 'height_scale' in params:
scale = (params['height_scale'], params['width_scale'])
elif len(inputs) == 2:
scale = layers[inputs[-1] + '_np'][-2:]
upsampling = keras.layers.UpSampling2D(
size=scale, name=tf_name
)
layers[scope_name] = upsampling(layers[inputs[0]]) | [
"Convert",
"nearest",
"upsampling",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/upsampling_layers.py#L45-L78 | [
"def",
"convert_upsample",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting upsample...'",
")",
"if",
"params",
"[",
"'mode'",
"]",
"!=",
"'nearest'",
":",
"raise",
"AssertionError",
"(",
"'Cannot convert non-nearest upsampling'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'UPSL'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"if",
"'height_scale'",
"in",
"params",
":",
"scale",
"=",
"(",
"params",
"[",
"'height_scale'",
"]",
",",
"params",
"[",
"'width_scale'",
"]",
")",
"elif",
"len",
"(",
"inputs",
")",
"==",
"2",
":",
"scale",
"=",
"layers",
"[",
"inputs",
"[",
"-",
"1",
"]",
"+",
"'_np'",
"]",
"[",
"-",
"2",
":",
"]",
"upsampling",
"=",
"keras",
".",
"layers",
".",
"UpSampling2D",
"(",
"size",
"=",
"scale",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"upsampling",
"(",
"layers",
"[",
"inputs",
"[",
"0",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | convert_gather | Convert gather (embedding) layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers | pytorch2keras/embedding_layers.py | def convert_gather(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert gather (embedding) layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting embedding ...')
if names == 'short':
tf_name = 'EMBD' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
weights_name = '{0}.weight'.format(w_name)
W = weights[weights_name].numpy()
input_channels, output_channels = W.shape
keras_weights = [W]
dense = keras.layers.Embedding(
input_channels,
weights=keras_weights, output_dim=output_channels, name=tf_name
)
layers[scope_name] = dense(layers[inputs[1]]) | def convert_gather(params, w_name, scope_name, inputs, layers, weights, names):
"""
Convert gather (embedding) layer.
Args:
params: dictionary with layer parameters
w_name: name prefix in state_dict
scope_name: pytorch scope name
inputs: pytorch node inputs
layers: dictionary with keras tensors
weights: pytorch state_dict
names: use short names for keras layers
"""
print('Converting embedding ...')
if names == 'short':
tf_name = 'EMBD' + random_string(4)
elif names == 'keep':
tf_name = w_name
else:
tf_name = w_name + str(random.random())
weights_name = '{0}.weight'.format(w_name)
W = weights[weights_name].numpy()
input_channels, output_channels = W.shape
keras_weights = [W]
dense = keras.layers.Embedding(
input_channels,
weights=keras_weights, output_dim=output_channels, name=tf_name
)
layers[scope_name] = dense(layers[inputs[1]]) | [
"Convert",
"gather",
"(",
"embedding",
")",
"layer",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/embedding_layers.py#L9-L42 | [
"def",
"convert_gather",
"(",
"params",
",",
"w_name",
",",
"scope_name",
",",
"inputs",
",",
"layers",
",",
"weights",
",",
"names",
")",
":",
"print",
"(",
"'Converting embedding ...'",
")",
"if",
"names",
"==",
"'short'",
":",
"tf_name",
"=",
"'EMBD'",
"+",
"random_string",
"(",
"4",
")",
"elif",
"names",
"==",
"'keep'",
":",
"tf_name",
"=",
"w_name",
"else",
":",
"tf_name",
"=",
"w_name",
"+",
"str",
"(",
"random",
".",
"random",
"(",
")",
")",
"weights_name",
"=",
"'{0}.weight'",
".",
"format",
"(",
"w_name",
")",
"W",
"=",
"weights",
"[",
"weights_name",
"]",
".",
"numpy",
"(",
")",
"input_channels",
",",
"output_channels",
"=",
"W",
".",
"shape",
"keras_weights",
"=",
"[",
"W",
"]",
"dense",
"=",
"keras",
".",
"layers",
".",
"Embedding",
"(",
"input_channels",
",",
"weights",
"=",
"keras_weights",
",",
"output_dim",
"=",
"output_channels",
",",
"name",
"=",
"tf_name",
")",
"layers",
"[",
"scope_name",
"]",
"=",
"dense",
"(",
"layers",
"[",
"inputs",
"[",
"1",
"]",
"]",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | set_training | A context manager to temporarily set the training mode of 'model'
to 'mode', resetting it when we exit the with-block. A no-op if
mode is None. | pytorch2keras/converter.py | def set_training(model, mode):
"""
A context manager to temporarily set the training mode of 'model'
to 'mode', resetting it when we exit the with-block. A no-op if
mode is None.
"""
if mode is None:
yield
return
old_mode = model.training
if old_mode != mode:
model.train(mode)
try:
yield
finally:
if old_mode != mode:
model.train(old_mode) | def set_training(model, mode):
"""
A context manager to temporarily set the training mode of 'model'
to 'mode', resetting it when we exit the with-block. A no-op if
mode is None.
"""
if mode is None:
yield
return
old_mode = model.training
if old_mode != mode:
model.train(mode)
try:
yield
finally:
if old_mode != mode:
model.train(old_mode) | [
"A",
"context",
"manager",
"to",
"temporarily",
"set",
"the",
"training",
"mode",
"of",
"model",
"to",
"mode",
"resetting",
"it",
"when",
"we",
"exit",
"the",
"with",
"-",
"block",
".",
"A",
"no",
"-",
"op",
"if",
"mode",
"is",
"None",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/converter.py#L23-L39 | [
"def",
"set_training",
"(",
"model",
",",
"mode",
")",
":",
"if",
"mode",
"is",
"None",
":",
"yield",
"return",
"old_mode",
"=",
"model",
".",
"training",
"if",
"old_mode",
"!=",
"mode",
":",
"model",
".",
"train",
"(",
"mode",
")",
"try",
":",
"yield",
"finally",
":",
"if",
"old_mode",
"!=",
"mode",
":",
"model",
".",
"train",
"(",
"old_mode",
")"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | pytorch_to_keras | By given pytorch model convert layers with specified convertors.
Args:
model: pytorch model
args: pytorch model arguments
input_shapes: keras input shapes (using for each InputLayer)
change_ordering: change CHW to HWC
training: switch model to training mode
verbose: verbose output
names: use short names, use random-suffix or keep original names for keras layers
Returns:
model: created keras model. | pytorch2keras/converter.py | def pytorch_to_keras(
model, args, input_shapes,
change_ordering=False, training=False, verbose=False, names=False,
):
"""
By given pytorch model convert layers with specified convertors.
Args:
model: pytorch model
args: pytorch model arguments
input_shapes: keras input shapes (using for each InputLayer)
change_ordering: change CHW to HWC
training: switch model to training mode
verbose: verbose output
names: use short names, use random-suffix or keep original names for keras layers
Returns:
model: created keras model.
"""
# PyTorch JIT tracing
if isinstance(args, torch.autograd.Variable):
args = (args, )
# Workaround for previous versions
if isinstance(input_shapes, tuple):
input_shapes = [input_shapes]
orig_state_dict_keys = _unique_state_dict(model).keys()
with set_training(model, training):
trace, torch_out = torch.jit.get_trace_graph(model, tuple(args))
if orig_state_dict_keys != _unique_state_dict(model).keys():
raise RuntimeError("state_dict changed after running the tracer; "
"something weird is happening in your model!")
# _optimize_trace(trace, False)
if version.parse('0.4.0') < version.parse(torch.__version__):
trace.set_graph(_optimize_graph(trace.graph(), OperatorExportTypes.ONNX))
else:
trace.set_graph(_optimize_graph(trace.graph(), False))
trace.graph().lint()
if verbose:
print(trace.graph())
# Get all graph nodes
nodes = list(trace.graph().nodes())
# Optimize Flatten:
# When we have something loke that:
#
# %523 : Long() = onnx::Constant[value={0}](), scope: ResNet
# %524 : Dynamic = onnx::Shape(%522), scope: ResNet
# %526 : Long() = onnx::Gather[axis=0](%524, %523), scope: ResNet
# %527 : Long() = onnx::Constant[value={-1}](), scope: ResNet
# %534 : Dynamic = onnx::Unsqueeze[axes=[0]](%526)
# %535 : Dynamic = onnx::Unsqueeze[axes=[0]](%527)
# %536 : Dynamic = onnx::Concat[axis=0](%534, %535)
# %529 : Float(1, 512) = onnx::Reshape(%522, %536), scope: ResNet
#
# It's better to replace it with onnx::Flatten
if six.PY3:
from types import SimpleNamespace
seq_to_find = \
['onnx::Constant', 'onnx::Shape', 'onnx::Gather',
'onnx::Constant', 'onnx::Unsqueeze', 'onnx::Unsqueeze', 'onnx::Concat', 'onnx::Reshape']
k = 0
s = 0
for i, node in enumerate(nodes):
if node.kind() == seq_to_find[k]:
if k == 0:
s = i
k += 1
if k == len(seq_to_find):
reshape_op = nodes[s + k - 1]
flatten_op = {
'kind': (lambda: 'onnx::Flatten'),
'attributeNames': (lambda: {}),
'outputs': (lambda: list(reshape_op.outputs())),
'scopeName': (lambda: reshape_op.scopeName()),
'inputs': (lambda: list(reshape_op.inputs())[:1]),
'__str__': (lambda: reshape_op.__str__()),
}
nodes = nodes[:s] + [SimpleNamespace(**flatten_op)] + nodes[s+k:]
break
else:
k = 0
s = -1
# Collect graph inputs and outputs
graph_outputs = [get_leaf_id(n) for n in trace.graph().outputs()]
graph_inputs = [get_leaf_id(n) for n in trace.graph().inputs()]
# Collect model state dict
state_dict = _unique_state_dict(model)
if verbose:
print('Graph inputs:', graph_inputs)
print('Graph outputs:', graph_outputs)
print('State dict:', list(state_dict))
import re
import keras
from keras import backend as K
K.set_image_data_format('channels_first')
layers = dict()
keras_inputs = []
for i in range(len(args)):
layers[graph_inputs[i]] = keras.layers.InputLayer(
input_shape=input_shapes[i], name='input{0}'.format(i)
).output
keras_inputs.append(layers[graph_inputs[i]])
outputs = []
group_indices = defaultdict(lambda: 0, {})
for node in nodes:
node_inputs = list(node.inputs())
node_input_names = []
for node_input in node_inputs:
node_input_names.append(get_leaf_id(node_input))
node_type = node.kind()
node_scope_name = node.scopeName()
node_id = get_node_id(node)
node_name_regex = re.findall(r'\[([\w\d.\-\[\]\s]+)\]', node_scope_name)
try:
int(node_name_regex[-1])
node_weigth_group_name = '.'.join(
node_name_regex[:-1]
)
node_weights_name = node_weigth_group_name + '.' + str(group_indices[node_weigth_group_name])
group_indices[node_weigth_group_name] += 1
except ValueError:
node_weights_name = '.'.join(
node_name_regex
)
except IndexError:
node_weights_name = '.'.join(node_input_names)
node_attrs = {k: node[k] for k in node.attributeNames()}
node_outputs = list(node.outputs())
node_outputs_names = []
for node_output in node_outputs:
if node_output.node().scopeName():
node_outputs_names.append(node_output.node().scopeName())
if verbose:
print(' ____ ')
print('graph node:', node_scope_name)
print('node id:', node_id)
print('type:', node_type)
print('inputs:', node_input_names)
print('outputs:', node_outputs_names)
print('name in state_dict:', node_weights_name)
print('attrs:', node_attrs)
print('is_terminal:', node_id in graph_outputs)
AVAILABLE_CONVERTERS[node_type](
node_attrs,
node_weights_name, node_id,
node_input_names,
layers, state_dict,
names
)
if node_id in graph_outputs:
outputs.append(layers[node_id])
model = keras.models.Model(inputs=keras_inputs, outputs=outputs)
if change_ordering:
import numpy as np
conf = model.get_config()
for layer in conf['layers']:
if layer['config'] and 'batch_input_shape' in layer['config']:
layer['config']['batch_input_shape'] = \
tuple(np.reshape(np.array(
[
[None] +
list(layer['config']['batch_input_shape'][2:][:]) +
[layer['config']['batch_input_shape'][1]]
]), -1
))
if layer['config'] and 'target_shape' in layer['config']:
if len(list(layer['config']['target_shape'][1:][:])) > 0:
layer['config']['target_shape'] = \
tuple(np.reshape(np.array(
[
list(layer['config']['target_shape'][1:][:]),
layer['config']['target_shape'][0]
]), -1
),)
if layer['config'] and 'data_format' in layer['config']:
layer['config']['data_format'] = 'channels_last'
if layer['config'] and 'axis' in layer['config']:
layer['config']['axis'] = 3
K.set_image_data_format('channels_last')
model_tf_ordering = keras.models.Model.from_config(conf)
# from keras.utils.layer_utils import convert_all_kernels_in_model
# convert_all_kernels_in_model(model)
for dst_layer, src_layer in zip(
model_tf_ordering.layers, model.layers
):
dst_layer.set_weights(src_layer.get_weights())
model = model_tf_ordering
print('Your model was (probably) successfully converted! '
'Please, follow the repository https://github.com/nerox8664/pytorch2keras and give a star :)')
return model | def pytorch_to_keras(
model, args, input_shapes,
change_ordering=False, training=False, verbose=False, names=False,
):
"""
By given pytorch model convert layers with specified convertors.
Args:
model: pytorch model
args: pytorch model arguments
input_shapes: keras input shapes (using for each InputLayer)
change_ordering: change CHW to HWC
training: switch model to training mode
verbose: verbose output
names: use short names, use random-suffix or keep original names for keras layers
Returns:
model: created keras model.
"""
# PyTorch JIT tracing
if isinstance(args, torch.autograd.Variable):
args = (args, )
# Workaround for previous versions
if isinstance(input_shapes, tuple):
input_shapes = [input_shapes]
orig_state_dict_keys = _unique_state_dict(model).keys()
with set_training(model, training):
trace, torch_out = torch.jit.get_trace_graph(model, tuple(args))
if orig_state_dict_keys != _unique_state_dict(model).keys():
raise RuntimeError("state_dict changed after running the tracer; "
"something weird is happening in your model!")
# _optimize_trace(trace, False)
if version.parse('0.4.0') < version.parse(torch.__version__):
trace.set_graph(_optimize_graph(trace.graph(), OperatorExportTypes.ONNX))
else:
trace.set_graph(_optimize_graph(trace.graph(), False))
trace.graph().lint()
if verbose:
print(trace.graph())
# Get all graph nodes
nodes = list(trace.graph().nodes())
# Optimize Flatten:
# When we have something loke that:
#
# %523 : Long() = onnx::Constant[value={0}](), scope: ResNet
# %524 : Dynamic = onnx::Shape(%522), scope: ResNet
# %526 : Long() = onnx::Gather[axis=0](%524, %523), scope: ResNet
# %527 : Long() = onnx::Constant[value={-1}](), scope: ResNet
# %534 : Dynamic = onnx::Unsqueeze[axes=[0]](%526)
# %535 : Dynamic = onnx::Unsqueeze[axes=[0]](%527)
# %536 : Dynamic = onnx::Concat[axis=0](%534, %535)
# %529 : Float(1, 512) = onnx::Reshape(%522, %536), scope: ResNet
#
# It's better to replace it with onnx::Flatten
if six.PY3:
from types import SimpleNamespace
seq_to_find = \
['onnx::Constant', 'onnx::Shape', 'onnx::Gather',
'onnx::Constant', 'onnx::Unsqueeze', 'onnx::Unsqueeze', 'onnx::Concat', 'onnx::Reshape']
k = 0
s = 0
for i, node in enumerate(nodes):
if node.kind() == seq_to_find[k]:
if k == 0:
s = i
k += 1
if k == len(seq_to_find):
reshape_op = nodes[s + k - 1]
flatten_op = {
'kind': (lambda: 'onnx::Flatten'),
'attributeNames': (lambda: {}),
'outputs': (lambda: list(reshape_op.outputs())),
'scopeName': (lambda: reshape_op.scopeName()),
'inputs': (lambda: list(reshape_op.inputs())[:1]),
'__str__': (lambda: reshape_op.__str__()),
}
nodes = nodes[:s] + [SimpleNamespace(**flatten_op)] + nodes[s+k:]
break
else:
k = 0
s = -1
# Collect graph inputs and outputs
graph_outputs = [get_leaf_id(n) for n in trace.graph().outputs()]
graph_inputs = [get_leaf_id(n) for n in trace.graph().inputs()]
# Collect model state dict
state_dict = _unique_state_dict(model)
if verbose:
print('Graph inputs:', graph_inputs)
print('Graph outputs:', graph_outputs)
print('State dict:', list(state_dict))
import re
import keras
from keras import backend as K
K.set_image_data_format('channels_first')
layers = dict()
keras_inputs = []
for i in range(len(args)):
layers[graph_inputs[i]] = keras.layers.InputLayer(
input_shape=input_shapes[i], name='input{0}'.format(i)
).output
keras_inputs.append(layers[graph_inputs[i]])
outputs = []
group_indices = defaultdict(lambda: 0, {})
for node in nodes:
node_inputs = list(node.inputs())
node_input_names = []
for node_input in node_inputs:
node_input_names.append(get_leaf_id(node_input))
node_type = node.kind()
node_scope_name = node.scopeName()
node_id = get_node_id(node)
node_name_regex = re.findall(r'\[([\w\d.\-\[\]\s]+)\]', node_scope_name)
try:
int(node_name_regex[-1])
node_weigth_group_name = '.'.join(
node_name_regex[:-1]
)
node_weights_name = node_weigth_group_name + '.' + str(group_indices[node_weigth_group_name])
group_indices[node_weigth_group_name] += 1
except ValueError:
node_weights_name = '.'.join(
node_name_regex
)
except IndexError:
node_weights_name = '.'.join(node_input_names)
node_attrs = {k: node[k] for k in node.attributeNames()}
node_outputs = list(node.outputs())
node_outputs_names = []
for node_output in node_outputs:
if node_output.node().scopeName():
node_outputs_names.append(node_output.node().scopeName())
if verbose:
print(' ____ ')
print('graph node:', node_scope_name)
print('node id:', node_id)
print('type:', node_type)
print('inputs:', node_input_names)
print('outputs:', node_outputs_names)
print('name in state_dict:', node_weights_name)
print('attrs:', node_attrs)
print('is_terminal:', node_id in graph_outputs)
AVAILABLE_CONVERTERS[node_type](
node_attrs,
node_weights_name, node_id,
node_input_names,
layers, state_dict,
names
)
if node_id in graph_outputs:
outputs.append(layers[node_id])
model = keras.models.Model(inputs=keras_inputs, outputs=outputs)
if change_ordering:
import numpy as np
conf = model.get_config()
for layer in conf['layers']:
if layer['config'] and 'batch_input_shape' in layer['config']:
layer['config']['batch_input_shape'] = \
tuple(np.reshape(np.array(
[
[None] +
list(layer['config']['batch_input_shape'][2:][:]) +
[layer['config']['batch_input_shape'][1]]
]), -1
))
if layer['config'] and 'target_shape' in layer['config']:
if len(list(layer['config']['target_shape'][1:][:])) > 0:
layer['config']['target_shape'] = \
tuple(np.reshape(np.array(
[
list(layer['config']['target_shape'][1:][:]),
layer['config']['target_shape'][0]
]), -1
),)
if layer['config'] and 'data_format' in layer['config']:
layer['config']['data_format'] = 'channels_last'
if layer['config'] and 'axis' in layer['config']:
layer['config']['axis'] = 3
K.set_image_data_format('channels_last')
model_tf_ordering = keras.models.Model.from_config(conf)
# from keras.utils.layer_utils import convert_all_kernels_in_model
# convert_all_kernels_in_model(model)
for dst_layer, src_layer in zip(
model_tf_ordering.layers, model.layers
):
dst_layer.set_weights(src_layer.get_weights())
model = model_tf_ordering
print('Your model was (probably) successfully converted! '
'Please, follow the repository https://github.com/nerox8664/pytorch2keras and give a star :)')
return model | [
"By",
"given",
"pytorch",
"model",
"convert",
"layers",
"with",
"specified",
"convertors",
"."
] | nerox8664/pytorch2keras | python | https://github.com/nerox8664/pytorch2keras/blob/750eaf747323580e6732d0c5ba9f2f39cb096764/pytorch2keras/converter.py#L147-L368 | [
"def",
"pytorch_to_keras",
"(",
"model",
",",
"args",
",",
"input_shapes",
",",
"change_ordering",
"=",
"False",
",",
"training",
"=",
"False",
",",
"verbose",
"=",
"False",
",",
"names",
"=",
"False",
",",
")",
":",
"# PyTorch JIT tracing",
"if",
"isinstance",
"(",
"args",
",",
"torch",
".",
"autograd",
".",
"Variable",
")",
":",
"args",
"=",
"(",
"args",
",",
")",
"# Workaround for previous versions",
"if",
"isinstance",
"(",
"input_shapes",
",",
"tuple",
")",
":",
"input_shapes",
"=",
"[",
"input_shapes",
"]",
"orig_state_dict_keys",
"=",
"_unique_state_dict",
"(",
"model",
")",
".",
"keys",
"(",
")",
"with",
"set_training",
"(",
"model",
",",
"training",
")",
":",
"trace",
",",
"torch_out",
"=",
"torch",
".",
"jit",
".",
"get_trace_graph",
"(",
"model",
",",
"tuple",
"(",
"args",
")",
")",
"if",
"orig_state_dict_keys",
"!=",
"_unique_state_dict",
"(",
"model",
")",
".",
"keys",
"(",
")",
":",
"raise",
"RuntimeError",
"(",
"\"state_dict changed after running the tracer; \"",
"\"something weird is happening in your model!\"",
")",
"# _optimize_trace(trace, False)",
"if",
"version",
".",
"parse",
"(",
"'0.4.0'",
")",
"<",
"version",
".",
"parse",
"(",
"torch",
".",
"__version__",
")",
":",
"trace",
".",
"set_graph",
"(",
"_optimize_graph",
"(",
"trace",
".",
"graph",
"(",
")",
",",
"OperatorExportTypes",
".",
"ONNX",
")",
")",
"else",
":",
"trace",
".",
"set_graph",
"(",
"_optimize_graph",
"(",
"trace",
".",
"graph",
"(",
")",
",",
"False",
")",
")",
"trace",
".",
"graph",
"(",
")",
".",
"lint",
"(",
")",
"if",
"verbose",
":",
"print",
"(",
"trace",
".",
"graph",
"(",
")",
")",
"# Get all graph nodes",
"nodes",
"=",
"list",
"(",
"trace",
".",
"graph",
"(",
")",
".",
"nodes",
"(",
")",
")",
"# Optimize Flatten:",
"# When we have something loke that:",
"#",
"# %523 : Long() = onnx::Constant[value={0}](), scope: ResNet",
"# %524 : Dynamic = onnx::Shape(%522), scope: ResNet",
"# %526 : Long() = onnx::Gather[axis=0](%524, %523), scope: ResNet",
"# %527 : Long() = onnx::Constant[value={-1}](), scope: ResNet",
"# %534 : Dynamic = onnx::Unsqueeze[axes=[0]](%526)",
"# %535 : Dynamic = onnx::Unsqueeze[axes=[0]](%527)",
"# %536 : Dynamic = onnx::Concat[axis=0](%534, %535)",
"# %529 : Float(1, 512) = onnx::Reshape(%522, %536), scope: ResNet",
"#",
"# It's better to replace it with onnx::Flatten",
"if",
"six",
".",
"PY3",
":",
"from",
"types",
"import",
"SimpleNamespace",
"seq_to_find",
"=",
"[",
"'onnx::Constant'",
",",
"'onnx::Shape'",
",",
"'onnx::Gather'",
",",
"'onnx::Constant'",
",",
"'onnx::Unsqueeze'",
",",
"'onnx::Unsqueeze'",
",",
"'onnx::Concat'",
",",
"'onnx::Reshape'",
"]",
"k",
"=",
"0",
"s",
"=",
"0",
"for",
"i",
",",
"node",
"in",
"enumerate",
"(",
"nodes",
")",
":",
"if",
"node",
".",
"kind",
"(",
")",
"==",
"seq_to_find",
"[",
"k",
"]",
":",
"if",
"k",
"==",
"0",
":",
"s",
"=",
"i",
"k",
"+=",
"1",
"if",
"k",
"==",
"len",
"(",
"seq_to_find",
")",
":",
"reshape_op",
"=",
"nodes",
"[",
"s",
"+",
"k",
"-",
"1",
"]",
"flatten_op",
"=",
"{",
"'kind'",
":",
"(",
"lambda",
":",
"'onnx::Flatten'",
")",
",",
"'attributeNames'",
":",
"(",
"lambda",
":",
"{",
"}",
")",
",",
"'outputs'",
":",
"(",
"lambda",
":",
"list",
"(",
"reshape_op",
".",
"outputs",
"(",
")",
")",
")",
",",
"'scopeName'",
":",
"(",
"lambda",
":",
"reshape_op",
".",
"scopeName",
"(",
")",
")",
",",
"'inputs'",
":",
"(",
"lambda",
":",
"list",
"(",
"reshape_op",
".",
"inputs",
"(",
")",
")",
"[",
":",
"1",
"]",
")",
",",
"'__str__'",
":",
"(",
"lambda",
":",
"reshape_op",
".",
"__str__",
"(",
")",
")",
",",
"}",
"nodes",
"=",
"nodes",
"[",
":",
"s",
"]",
"+",
"[",
"SimpleNamespace",
"(",
"*",
"*",
"flatten_op",
")",
"]",
"+",
"nodes",
"[",
"s",
"+",
"k",
":",
"]",
"break",
"else",
":",
"k",
"=",
"0",
"s",
"=",
"-",
"1",
"# Collect graph inputs and outputs",
"graph_outputs",
"=",
"[",
"get_leaf_id",
"(",
"n",
")",
"for",
"n",
"in",
"trace",
".",
"graph",
"(",
")",
".",
"outputs",
"(",
")",
"]",
"graph_inputs",
"=",
"[",
"get_leaf_id",
"(",
"n",
")",
"for",
"n",
"in",
"trace",
".",
"graph",
"(",
")",
".",
"inputs",
"(",
")",
"]",
"# Collect model state dict",
"state_dict",
"=",
"_unique_state_dict",
"(",
"model",
")",
"if",
"verbose",
":",
"print",
"(",
"'Graph inputs:'",
",",
"graph_inputs",
")",
"print",
"(",
"'Graph outputs:'",
",",
"graph_outputs",
")",
"print",
"(",
"'State dict:'",
",",
"list",
"(",
"state_dict",
")",
")",
"import",
"re",
"import",
"keras",
"from",
"keras",
"import",
"backend",
"as",
"K",
"K",
".",
"set_image_data_format",
"(",
"'channels_first'",
")",
"layers",
"=",
"dict",
"(",
")",
"keras_inputs",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"args",
")",
")",
":",
"layers",
"[",
"graph_inputs",
"[",
"i",
"]",
"]",
"=",
"keras",
".",
"layers",
".",
"InputLayer",
"(",
"input_shape",
"=",
"input_shapes",
"[",
"i",
"]",
",",
"name",
"=",
"'input{0}'",
".",
"format",
"(",
"i",
")",
")",
".",
"output",
"keras_inputs",
".",
"append",
"(",
"layers",
"[",
"graph_inputs",
"[",
"i",
"]",
"]",
")",
"outputs",
"=",
"[",
"]",
"group_indices",
"=",
"defaultdict",
"(",
"lambda",
":",
"0",
",",
"{",
"}",
")",
"for",
"node",
"in",
"nodes",
":",
"node_inputs",
"=",
"list",
"(",
"node",
".",
"inputs",
"(",
")",
")",
"node_input_names",
"=",
"[",
"]",
"for",
"node_input",
"in",
"node_inputs",
":",
"node_input_names",
".",
"append",
"(",
"get_leaf_id",
"(",
"node_input",
")",
")",
"node_type",
"=",
"node",
".",
"kind",
"(",
")",
"node_scope_name",
"=",
"node",
".",
"scopeName",
"(",
")",
"node_id",
"=",
"get_node_id",
"(",
"node",
")",
"node_name_regex",
"=",
"re",
".",
"findall",
"(",
"r'\\[([\\w\\d.\\-\\[\\]\\s]+)\\]'",
",",
"node_scope_name",
")",
"try",
":",
"int",
"(",
"node_name_regex",
"[",
"-",
"1",
"]",
")",
"node_weigth_group_name",
"=",
"'.'",
".",
"join",
"(",
"node_name_regex",
"[",
":",
"-",
"1",
"]",
")",
"node_weights_name",
"=",
"node_weigth_group_name",
"+",
"'.'",
"+",
"str",
"(",
"group_indices",
"[",
"node_weigth_group_name",
"]",
")",
"group_indices",
"[",
"node_weigth_group_name",
"]",
"+=",
"1",
"except",
"ValueError",
":",
"node_weights_name",
"=",
"'.'",
".",
"join",
"(",
"node_name_regex",
")",
"except",
"IndexError",
":",
"node_weights_name",
"=",
"'.'",
".",
"join",
"(",
"node_input_names",
")",
"node_attrs",
"=",
"{",
"k",
":",
"node",
"[",
"k",
"]",
"for",
"k",
"in",
"node",
".",
"attributeNames",
"(",
")",
"}",
"node_outputs",
"=",
"list",
"(",
"node",
".",
"outputs",
"(",
")",
")",
"node_outputs_names",
"=",
"[",
"]",
"for",
"node_output",
"in",
"node_outputs",
":",
"if",
"node_output",
".",
"node",
"(",
")",
".",
"scopeName",
"(",
")",
":",
"node_outputs_names",
".",
"append",
"(",
"node_output",
".",
"node",
"(",
")",
".",
"scopeName",
"(",
")",
")",
"if",
"verbose",
":",
"print",
"(",
"' ____ '",
")",
"print",
"(",
"'graph node:'",
",",
"node_scope_name",
")",
"print",
"(",
"'node id:'",
",",
"node_id",
")",
"print",
"(",
"'type:'",
",",
"node_type",
")",
"print",
"(",
"'inputs:'",
",",
"node_input_names",
")",
"print",
"(",
"'outputs:'",
",",
"node_outputs_names",
")",
"print",
"(",
"'name in state_dict:'",
",",
"node_weights_name",
")",
"print",
"(",
"'attrs:'",
",",
"node_attrs",
")",
"print",
"(",
"'is_terminal:'",
",",
"node_id",
"in",
"graph_outputs",
")",
"AVAILABLE_CONVERTERS",
"[",
"node_type",
"]",
"(",
"node_attrs",
",",
"node_weights_name",
",",
"node_id",
",",
"node_input_names",
",",
"layers",
",",
"state_dict",
",",
"names",
")",
"if",
"node_id",
"in",
"graph_outputs",
":",
"outputs",
".",
"append",
"(",
"layers",
"[",
"node_id",
"]",
")",
"model",
"=",
"keras",
".",
"models",
".",
"Model",
"(",
"inputs",
"=",
"keras_inputs",
",",
"outputs",
"=",
"outputs",
")",
"if",
"change_ordering",
":",
"import",
"numpy",
"as",
"np",
"conf",
"=",
"model",
".",
"get_config",
"(",
")",
"for",
"layer",
"in",
"conf",
"[",
"'layers'",
"]",
":",
"if",
"layer",
"[",
"'config'",
"]",
"and",
"'batch_input_shape'",
"in",
"layer",
"[",
"'config'",
"]",
":",
"layer",
"[",
"'config'",
"]",
"[",
"'batch_input_shape'",
"]",
"=",
"tuple",
"(",
"np",
".",
"reshape",
"(",
"np",
".",
"array",
"(",
"[",
"[",
"None",
"]",
"+",
"list",
"(",
"layer",
"[",
"'config'",
"]",
"[",
"'batch_input_shape'",
"]",
"[",
"2",
":",
"]",
"[",
":",
"]",
")",
"+",
"[",
"layer",
"[",
"'config'",
"]",
"[",
"'batch_input_shape'",
"]",
"[",
"1",
"]",
"]",
"]",
")",
",",
"-",
"1",
")",
")",
"if",
"layer",
"[",
"'config'",
"]",
"and",
"'target_shape'",
"in",
"layer",
"[",
"'config'",
"]",
":",
"if",
"len",
"(",
"list",
"(",
"layer",
"[",
"'config'",
"]",
"[",
"'target_shape'",
"]",
"[",
"1",
":",
"]",
"[",
":",
"]",
")",
")",
">",
"0",
":",
"layer",
"[",
"'config'",
"]",
"[",
"'target_shape'",
"]",
"=",
"tuple",
"(",
"np",
".",
"reshape",
"(",
"np",
".",
"array",
"(",
"[",
"list",
"(",
"layer",
"[",
"'config'",
"]",
"[",
"'target_shape'",
"]",
"[",
"1",
":",
"]",
"[",
":",
"]",
")",
",",
"layer",
"[",
"'config'",
"]",
"[",
"'target_shape'",
"]",
"[",
"0",
"]",
"]",
")",
",",
"-",
"1",
")",
",",
")",
"if",
"layer",
"[",
"'config'",
"]",
"and",
"'data_format'",
"in",
"layer",
"[",
"'config'",
"]",
":",
"layer",
"[",
"'config'",
"]",
"[",
"'data_format'",
"]",
"=",
"'channels_last'",
"if",
"layer",
"[",
"'config'",
"]",
"and",
"'axis'",
"in",
"layer",
"[",
"'config'",
"]",
":",
"layer",
"[",
"'config'",
"]",
"[",
"'axis'",
"]",
"=",
"3",
"K",
".",
"set_image_data_format",
"(",
"'channels_last'",
")",
"model_tf_ordering",
"=",
"keras",
".",
"models",
".",
"Model",
".",
"from_config",
"(",
"conf",
")",
"# from keras.utils.layer_utils import convert_all_kernels_in_model",
"# convert_all_kernels_in_model(model)",
"for",
"dst_layer",
",",
"src_layer",
"in",
"zip",
"(",
"model_tf_ordering",
".",
"layers",
",",
"model",
".",
"layers",
")",
":",
"dst_layer",
".",
"set_weights",
"(",
"src_layer",
".",
"get_weights",
"(",
")",
")",
"model",
"=",
"model_tf_ordering",
"print",
"(",
"'Your model was (probably) successfully converted! '",
"'Please, follow the repository https://github.com/nerox8664/pytorch2keras and give a star :)'",
")",
"return",
"model"
] | 750eaf747323580e6732d0c5ba9f2f39cb096764 |
valid | get_platform_pwm | Attempt to return a PWM instance for the platform which the code is being
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
exception if a PWM instance can't be created for the current platform. The
returned PWM object has the same interface as the RPi_PWM_Adapter and
BBIO_PWM_Adapter classes. | Adafruit_GPIO/PWM.py | def get_platform_pwm(**keywords):
"""Attempt to return a PWM instance for the platform which the code is being
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
exception if a PWM instance can't be created for the current platform. The
returned PWM object has the same interface as the RPi_PWM_Adapter and
BBIO_PWM_Adapter classes.
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI:
import RPi.GPIO
return RPi_PWM_Adapter(RPi.GPIO, **keywords)
elif plat == Platform.BEAGLEBONE_BLACK:
import Adafruit_BBIO.PWM
return BBIO_PWM_Adapter(Adafruit_BBIO.PWM, **keywords)
elif plat == Platform.UNKNOWN:
raise RuntimeError('Could not determine platform.') | def get_platform_pwm(**keywords):
"""Attempt to return a PWM instance for the platform which the code is being
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
exception if a PWM instance can't be created for the current platform. The
returned PWM object has the same interface as the RPi_PWM_Adapter and
BBIO_PWM_Adapter classes.
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI:
import RPi.GPIO
return RPi_PWM_Adapter(RPi.GPIO, **keywords)
elif plat == Platform.BEAGLEBONE_BLACK:
import Adafruit_BBIO.PWM
return BBIO_PWM_Adapter(Adafruit_BBIO.PWM, **keywords)
elif plat == Platform.UNKNOWN:
raise RuntimeError('Could not determine platform.') | [
"Attempt",
"to",
"return",
"a",
"PWM",
"instance",
"for",
"the",
"platform",
"which",
"the",
"code",
"is",
"being",
"executed",
"on",
".",
"Currently",
"supports",
"only",
"the",
"Raspberry",
"Pi",
"using",
"the",
"RPi",
".",
"GPIO",
"library",
"and",
"Beaglebone",
"Black",
"using",
"the",
"Adafruit_BBIO",
"library",
".",
"Will",
"throw",
"an",
"exception",
"if",
"a",
"PWM",
"instance",
"can",
"t",
"be",
"created",
"for",
"the",
"current",
"platform",
".",
"The",
"returned",
"PWM",
"object",
"has",
"the",
"same",
"interface",
"as",
"the",
"RPi_PWM_Adapter",
"and",
"BBIO_PWM_Adapter",
"classes",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L112-L128 | [
"def",
"get_platform_pwm",
"(",
"*",
"*",
"keywords",
")",
":",
"plat",
"=",
"Platform",
".",
"platform_detect",
"(",
")",
"if",
"plat",
"==",
"Platform",
".",
"RASPBERRY_PI",
":",
"import",
"RPi",
".",
"GPIO",
"return",
"RPi_PWM_Adapter",
"(",
"RPi",
".",
"GPIO",
",",
"*",
"*",
"keywords",
")",
"elif",
"plat",
"==",
"Platform",
".",
"BEAGLEBONE_BLACK",
":",
"import",
"Adafruit_BBIO",
".",
"PWM",
"return",
"BBIO_PWM_Adapter",
"(",
"Adafruit_BBIO",
".",
"PWM",
",",
"*",
"*",
"keywords",
")",
"elif",
"plat",
"==",
"Platform",
".",
"UNKNOWN",
":",
"raise",
"RuntimeError",
"(",
"'Could not determine platform.'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPi_PWM_Adapter.start | Enable PWM output on specified pin. Set to intiial percent duty cycle
value (0.0 to 100.0) and frequency (in Hz). | Adafruit_GPIO/PWM.py | def start(self, pin, dutycycle, frequency_hz=2000):
"""Enable PWM output on specified pin. Set to intiial percent duty cycle
value (0.0 to 100.0) and frequency (in Hz).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
# Make pin an output.
self.rpi_gpio.setup(pin, self.rpi_gpio.OUT)
# Create PWM instance and save a reference for later access.
self.pwm[pin] = self.rpi_gpio.PWM(pin, frequency_hz)
# Start the PWM at the specified duty cycle.
self.pwm[pin].start(dutycycle) | def start(self, pin, dutycycle, frequency_hz=2000):
"""Enable PWM output on specified pin. Set to intiial percent duty cycle
value (0.0 to 100.0) and frequency (in Hz).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
# Make pin an output.
self.rpi_gpio.setup(pin, self.rpi_gpio.OUT)
# Create PWM instance and save a reference for later access.
self.pwm[pin] = self.rpi_gpio.PWM(pin, frequency_hz)
# Start the PWM at the specified duty cycle.
self.pwm[pin].start(dutycycle) | [
"Enable",
"PWM",
"output",
"on",
"specified",
"pin",
".",
"Set",
"to",
"intiial",
"percent",
"duty",
"cycle",
"value",
"(",
"0",
".",
"0",
"to",
"100",
".",
"0",
")",
"and",
"frequency",
"(",
"in",
"Hz",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L42-L53 | [
"def",
"start",
"(",
"self",
",",
"pin",
",",
"dutycycle",
",",
"frequency_hz",
"=",
"2000",
")",
":",
"if",
"dutycycle",
"<",
"0.0",
"or",
"dutycycle",
">",
"100.0",
":",
"raise",
"ValueError",
"(",
"'Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).'",
")",
"# Make pin an output.",
"self",
".",
"rpi_gpio",
".",
"setup",
"(",
"pin",
",",
"self",
".",
"rpi_gpio",
".",
"OUT",
")",
"# Create PWM instance and save a reference for later access.",
"self",
".",
"pwm",
"[",
"pin",
"]",
"=",
"self",
".",
"rpi_gpio",
".",
"PWM",
"(",
"pin",
",",
"frequency_hz",
")",
"# Start the PWM at the specified duty cycle.",
"self",
".",
"pwm",
"[",
"pin",
"]",
".",
"start",
"(",
"dutycycle",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPi_PWM_Adapter.set_duty_cycle | Set percent duty cycle of PWM output on specified pin. Duty cycle must
be a value 0.0 to 100.0 (inclusive). | Adafruit_GPIO/PWM.py | def set_duty_cycle(self, pin, dutycycle):
"""Set percent duty cycle of PWM output on specified pin. Duty cycle must
be a value 0.0 to 100.0 (inclusive).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
if pin not in self.pwm:
raise ValueError('Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'.format(pin))
self.pwm[pin].ChangeDutyCycle(dutycycle) | def set_duty_cycle(self, pin, dutycycle):
"""Set percent duty cycle of PWM output on specified pin. Duty cycle must
be a value 0.0 to 100.0 (inclusive).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
if pin not in self.pwm:
raise ValueError('Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'.format(pin))
self.pwm[pin].ChangeDutyCycle(dutycycle) | [
"Set",
"percent",
"duty",
"cycle",
"of",
"PWM",
"output",
"on",
"specified",
"pin",
".",
"Duty",
"cycle",
"must",
"be",
"a",
"value",
"0",
".",
"0",
"to",
"100",
".",
"0",
"(",
"inclusive",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L55-L63 | [
"def",
"set_duty_cycle",
"(",
"self",
",",
"pin",
",",
"dutycycle",
")",
":",
"if",
"dutycycle",
"<",
"0.0",
"or",
"dutycycle",
">",
"100.0",
":",
"raise",
"ValueError",
"(",
"'Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).'",
")",
"if",
"pin",
"not",
"in",
"self",
".",
"pwm",
":",
"raise",
"ValueError",
"(",
"'Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'",
".",
"format",
"(",
"pin",
")",
")",
"self",
".",
"pwm",
"[",
"pin",
"]",
".",
"ChangeDutyCycle",
"(",
"dutycycle",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPi_PWM_Adapter.set_frequency | Set frequency (in Hz) of PWM output on specified pin. | Adafruit_GPIO/PWM.py | def set_frequency(self, pin, frequency_hz):
"""Set frequency (in Hz) of PWM output on specified pin."""
if pin not in self.pwm:
raise ValueError('Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'.format(pin))
self.pwm[pin].ChangeFrequency(frequency_hz) | def set_frequency(self, pin, frequency_hz):
"""Set frequency (in Hz) of PWM output on specified pin."""
if pin not in self.pwm:
raise ValueError('Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'.format(pin))
self.pwm[pin].ChangeFrequency(frequency_hz) | [
"Set",
"frequency",
"(",
"in",
"Hz",
")",
"of",
"PWM",
"output",
"on",
"specified",
"pin",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L65-L69 | [
"def",
"set_frequency",
"(",
"self",
",",
"pin",
",",
"frequency_hz",
")",
":",
"if",
"pin",
"not",
"in",
"self",
".",
"pwm",
":",
"raise",
"ValueError",
"(",
"'Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'",
".",
"format",
"(",
"pin",
")",
")",
"self",
".",
"pwm",
"[",
"pin",
"]",
".",
"ChangeFrequency",
"(",
"frequency_hz",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPi_PWM_Adapter.stop | Stop PWM output on specified pin. | Adafruit_GPIO/PWM.py | def stop(self, pin):
"""Stop PWM output on specified pin."""
if pin not in self.pwm:
raise ValueError('Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'.format(pin))
self.pwm[pin].stop()
del self.pwm[pin] | def stop(self, pin):
"""Stop PWM output on specified pin."""
if pin not in self.pwm:
raise ValueError('Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'.format(pin))
self.pwm[pin].stop()
del self.pwm[pin] | [
"Stop",
"PWM",
"output",
"on",
"specified",
"pin",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L71-L76 | [
"def",
"stop",
"(",
"self",
",",
"pin",
")",
":",
"if",
"pin",
"not",
"in",
"self",
".",
"pwm",
":",
"raise",
"ValueError",
"(",
"'Pin {0} is not configured as a PWM. Make sure to first call start for the pin.'",
".",
"format",
"(",
"pin",
")",
")",
"self",
".",
"pwm",
"[",
"pin",
"]",
".",
"stop",
"(",
")",
"del",
"self",
".",
"pwm",
"[",
"pin",
"]"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BBIO_PWM_Adapter.start | Enable PWM output on specified pin. Set to intiial percent duty cycle
value (0.0 to 100.0) and frequency (in Hz). | Adafruit_GPIO/PWM.py | def start(self, pin, dutycycle, frequency_hz=2000):
"""Enable PWM output on specified pin. Set to intiial percent duty cycle
value (0.0 to 100.0) and frequency (in Hz).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
self.bbio_pwm.start(pin, dutycycle, frequency_hz) | def start(self, pin, dutycycle, frequency_hz=2000):
"""Enable PWM output on specified pin. Set to intiial percent duty cycle
value (0.0 to 100.0) and frequency (in Hz).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
self.bbio_pwm.start(pin, dutycycle, frequency_hz) | [
"Enable",
"PWM",
"output",
"on",
"specified",
"pin",
".",
"Set",
"to",
"intiial",
"percent",
"duty",
"cycle",
"value",
"(",
"0",
".",
"0",
"to",
"100",
".",
"0",
")",
"and",
"frequency",
"(",
"in",
"Hz",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L87-L93 | [
"def",
"start",
"(",
"self",
",",
"pin",
",",
"dutycycle",
",",
"frequency_hz",
"=",
"2000",
")",
":",
"if",
"dutycycle",
"<",
"0.0",
"or",
"dutycycle",
">",
"100.0",
":",
"raise",
"ValueError",
"(",
"'Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).'",
")",
"self",
".",
"bbio_pwm",
".",
"start",
"(",
"pin",
",",
"dutycycle",
",",
"frequency_hz",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BBIO_PWM_Adapter.set_duty_cycle | Set percent duty cycle of PWM output on specified pin. Duty cycle must
be a value 0.0 to 100.0 (inclusive). | Adafruit_GPIO/PWM.py | def set_duty_cycle(self, pin, dutycycle):
"""Set percent duty cycle of PWM output on specified pin. Duty cycle must
be a value 0.0 to 100.0 (inclusive).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
self.bbio_pwm.set_duty_cycle(pin, dutycycle) | def set_duty_cycle(self, pin, dutycycle):
"""Set percent duty cycle of PWM output on specified pin. Duty cycle must
be a value 0.0 to 100.0 (inclusive).
"""
if dutycycle < 0.0 or dutycycle > 100.0:
raise ValueError('Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).')
self.bbio_pwm.set_duty_cycle(pin, dutycycle) | [
"Set",
"percent",
"duty",
"cycle",
"of",
"PWM",
"output",
"on",
"specified",
"pin",
".",
"Duty",
"cycle",
"must",
"be",
"a",
"value",
"0",
".",
"0",
"to",
"100",
".",
"0",
"(",
"inclusive",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/PWM.py#L95-L101 | [
"def",
"set_duty_cycle",
"(",
"self",
",",
"pin",
",",
"dutycycle",
")",
":",
"if",
"dutycycle",
"<",
"0.0",
"or",
"dutycycle",
">",
"100.0",
":",
"raise",
"ValueError",
"(",
"'Invalid duty cycle value, must be between 0.0 to 100.0 (inclusive).'",
")",
"self",
".",
"bbio_pwm",
".",
"set_duty_cycle",
"(",
"pin",
",",
"dutycycle",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | platform_detect | Detect if running on the Raspberry Pi or Beaglebone Black and return the
platform type. Will return RASPBERRY_PI, BEAGLEBONE_BLACK, or UNKNOWN. | Adafruit_GPIO/Platform.py | def platform_detect():
"""Detect if running on the Raspberry Pi or Beaglebone Black and return the
platform type. Will return RASPBERRY_PI, BEAGLEBONE_BLACK, or UNKNOWN."""
# Handle Raspberry Pi
pi = pi_version()
if pi is not None:
return RASPBERRY_PI
# Handle Beaglebone Black
# TODO: Check the Beaglebone Black /proc/cpuinfo value instead of reading
# the platform.
plat = platform.platform()
if plat.lower().find('armv7l-with-debian') > -1:
return BEAGLEBONE_BLACK
elif plat.lower().find('armv7l-with-ubuntu') > -1:
return BEAGLEBONE_BLACK
elif plat.lower().find('armv7l-with-glibc2.4') > -1:
return BEAGLEBONE_BLACK
elif plat.lower().find('tegra-aarch64-with-ubuntu') > -1:
return JETSON_NANO
# Handle Minnowboard
# Assumption is that mraa is installed
try:
import mraa
if mraa.getPlatformName()=='MinnowBoard MAX':
return MINNOWBOARD
except ImportError:
pass
# Couldn't figure out the platform, just return unknown.
return UNKNOWN | def platform_detect():
"""Detect if running on the Raspberry Pi or Beaglebone Black and return the
platform type. Will return RASPBERRY_PI, BEAGLEBONE_BLACK, or UNKNOWN."""
# Handle Raspberry Pi
pi = pi_version()
if pi is not None:
return RASPBERRY_PI
# Handle Beaglebone Black
# TODO: Check the Beaglebone Black /proc/cpuinfo value instead of reading
# the platform.
plat = platform.platform()
if plat.lower().find('armv7l-with-debian') > -1:
return BEAGLEBONE_BLACK
elif plat.lower().find('armv7l-with-ubuntu') > -1:
return BEAGLEBONE_BLACK
elif plat.lower().find('armv7l-with-glibc2.4') > -1:
return BEAGLEBONE_BLACK
elif plat.lower().find('tegra-aarch64-with-ubuntu') > -1:
return JETSON_NANO
# Handle Minnowboard
# Assumption is that mraa is installed
try:
import mraa
if mraa.getPlatformName()=='MinnowBoard MAX':
return MINNOWBOARD
except ImportError:
pass
# Couldn't figure out the platform, just return unknown.
return UNKNOWN | [
"Detect",
"if",
"running",
"on",
"the",
"Raspberry",
"Pi",
"or",
"Beaglebone",
"Black",
"and",
"return",
"the",
"platform",
"type",
".",
"Will",
"return",
"RASPBERRY_PI",
"BEAGLEBONE_BLACK",
"or",
"UNKNOWN",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/Platform.py#L31-L62 | [
"def",
"platform_detect",
"(",
")",
":",
"# Handle Raspberry Pi",
"pi",
"=",
"pi_version",
"(",
")",
"if",
"pi",
"is",
"not",
"None",
":",
"return",
"RASPBERRY_PI",
"# Handle Beaglebone Black",
"# TODO: Check the Beaglebone Black /proc/cpuinfo value instead of reading",
"# the platform.",
"plat",
"=",
"platform",
".",
"platform",
"(",
")",
"if",
"plat",
".",
"lower",
"(",
")",
".",
"find",
"(",
"'armv7l-with-debian'",
")",
">",
"-",
"1",
":",
"return",
"BEAGLEBONE_BLACK",
"elif",
"plat",
".",
"lower",
"(",
")",
".",
"find",
"(",
"'armv7l-with-ubuntu'",
")",
">",
"-",
"1",
":",
"return",
"BEAGLEBONE_BLACK",
"elif",
"plat",
".",
"lower",
"(",
")",
".",
"find",
"(",
"'armv7l-with-glibc2.4'",
")",
">",
"-",
"1",
":",
"return",
"BEAGLEBONE_BLACK",
"elif",
"plat",
".",
"lower",
"(",
")",
".",
"find",
"(",
"'tegra-aarch64-with-ubuntu'",
")",
">",
"-",
"1",
":",
"return",
"JETSON_NANO",
"# Handle Minnowboard",
"# Assumption is that mraa is installed",
"try",
":",
"import",
"mraa",
"if",
"mraa",
".",
"getPlatformName",
"(",
")",
"==",
"'MinnowBoard MAX'",
":",
"return",
"MINNOWBOARD",
"except",
"ImportError",
":",
"pass",
"# Couldn't figure out the platform, just return unknown.",
"return",
"UNKNOWN"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SpiDev.set_bit_order | Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first. | Adafruit_GPIO/SPI.py | def set_bit_order(self, order):
"""Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first.
"""
if order == MSBFIRST:
self._device.lsbfirst = False
elif order == LSBFIRST:
self._device.lsbfirst = True
else:
raise ValueError('Order must be MSBFIRST or LSBFIRST.') | def set_bit_order(self, order):
"""Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first.
"""
if order == MSBFIRST:
self._device.lsbfirst = False
elif order == LSBFIRST:
self._device.lsbfirst = True
else:
raise ValueError('Order must be MSBFIRST or LSBFIRST.') | [
"Set",
"order",
"of",
"bits",
"to",
"be",
"read",
"/",
"written",
"over",
"serial",
"lines",
".",
"Should",
"be",
"either",
"MSBFIRST",
"for",
"most",
"-",
"significant",
"first",
"or",
"LSBFIRST",
"for",
"least",
"-",
"signifcant",
"first",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L63-L73 | [
"def",
"set_bit_order",
"(",
"self",
",",
"order",
")",
":",
"if",
"order",
"==",
"MSBFIRST",
":",
"self",
".",
"_device",
".",
"lsbfirst",
"=",
"False",
"elif",
"order",
"==",
"LSBFIRST",
":",
"self",
".",
"_device",
".",
"lsbfirst",
"=",
"True",
"else",
":",
"raise",
"ValueError",
"(",
"'Order must be MSBFIRST or LSBFIRST.'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SpiDevMraa.set_mode | Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus | Adafruit_GPIO/SPI.py | def set_mode(self,mode):
"""Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
"""
if mode < 0 or mode > 3:
raise ValueError('Mode must be a value 0, 1, 2, or 3.')
self._device.mode(mode) | def set_mode(self,mode):
"""Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
"""
if mode < 0 or mode > 3:
raise ValueError('Mode must be a value 0, 1, 2, or 3.')
self._device.mode(mode) | [
"Set",
"SPI",
"mode",
"which",
"controls",
"clock",
"polarity",
"and",
"phase",
".",
"Should",
"be",
"a",
"numeric",
"value",
"0",
"1",
"2",
"or",
"3",
".",
"See",
"wikipedia",
"page",
"for",
"details",
"on",
"meaning",
":",
"http",
":",
"//",
"en",
".",
"wikipedia",
".",
"org",
"/",
"wiki",
"/",
"Serial_Peripheral_Interface_Bus"
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L111-L118 | [
"def",
"set_mode",
"(",
"self",
",",
"mode",
")",
":",
"if",
"mode",
"<",
"0",
"or",
"mode",
">",
"3",
":",
"raise",
"ValueError",
"(",
"'Mode must be a value 0, 1, 2, or 3.'",
")",
"self",
".",
"_device",
".",
"mode",
"(",
"mode",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BitBang.set_mode | Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus | Adafruit_GPIO/SPI.py | def set_mode(self, mode):
"""Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
"""
if mode < 0 or mode > 3:
raise ValueError('Mode must be a value 0, 1, 2, or 3.')
if mode & 0x02:
# Clock is normally high in mode 2 and 3.
self._clock_base = GPIO.HIGH
else:
# Clock is normally low in mode 0 and 1.
self._clock_base = GPIO.LOW
if mode & 0x01:
# Read on trailing edge in mode 1 and 3.
self._read_leading = False
else:
# Read on leading edge in mode 0 and 2.
self._read_leading = True
# Put clock into its base state.
self._gpio.output(self._sclk, self._clock_base) | def set_mode(self, mode):
"""Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
"""
if mode < 0 or mode > 3:
raise ValueError('Mode must be a value 0, 1, 2, or 3.')
if mode & 0x02:
# Clock is normally high in mode 2 and 3.
self._clock_base = GPIO.HIGH
else:
# Clock is normally low in mode 0 and 1.
self._clock_base = GPIO.LOW
if mode & 0x01:
# Read on trailing edge in mode 1 and 3.
self._read_leading = False
else:
# Read on leading edge in mode 0 and 2.
self._read_leading = True
# Put clock into its base state.
self._gpio.output(self._sclk, self._clock_base) | [
"Set",
"SPI",
"mode",
"which",
"controls",
"clock",
"polarity",
"and",
"phase",
".",
"Should",
"be",
"a",
"numeric",
"value",
"0",
"1",
"2",
"or",
"3",
".",
"See",
"wikipedia",
"page",
"for",
"details",
"on",
"meaning",
":",
"http",
":",
"//",
"en",
".",
"wikipedia",
".",
"org",
"/",
"wiki",
"/",
"Serial_Peripheral_Interface_Bus"
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L179-L199 | [
"def",
"set_mode",
"(",
"self",
",",
"mode",
")",
":",
"if",
"mode",
"<",
"0",
"or",
"mode",
">",
"3",
":",
"raise",
"ValueError",
"(",
"'Mode must be a value 0, 1, 2, or 3.'",
")",
"if",
"mode",
"&",
"0x02",
":",
"# Clock is normally high in mode 2 and 3.",
"self",
".",
"_clock_base",
"=",
"GPIO",
".",
"HIGH",
"else",
":",
"# Clock is normally low in mode 0 and 1.",
"self",
".",
"_clock_base",
"=",
"GPIO",
".",
"LOW",
"if",
"mode",
"&",
"0x01",
":",
"# Read on trailing edge in mode 1 and 3.",
"self",
".",
"_read_leading",
"=",
"False",
"else",
":",
"# Read on leading edge in mode 0 and 2.",
"self",
".",
"_read_leading",
"=",
"True",
"# Put clock into its base state.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"self",
".",
"_clock_base",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BitBang.set_bit_order | Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first. | Adafruit_GPIO/SPI.py | def set_bit_order(self, order):
"""Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first.
"""
# Set self._mask to the bitmask which points at the appropriate bit to
# read or write, and appropriate left/right shift operator function for
# reading/writing.
if order == MSBFIRST:
self._mask = 0x80
self._write_shift = operator.lshift
self._read_shift = operator.rshift
elif order == LSBFIRST:
self._mask = 0x01
self._write_shift = operator.rshift
self._read_shift = operator.lshift
else:
raise ValueError('Order must be MSBFIRST or LSBFIRST.') | def set_bit_order(self, order):
"""Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first.
"""
# Set self._mask to the bitmask which points at the appropriate bit to
# read or write, and appropriate left/right shift operator function for
# reading/writing.
if order == MSBFIRST:
self._mask = 0x80
self._write_shift = operator.lshift
self._read_shift = operator.rshift
elif order == LSBFIRST:
self._mask = 0x01
self._write_shift = operator.rshift
self._read_shift = operator.lshift
else:
raise ValueError('Order must be MSBFIRST or LSBFIRST.') | [
"Set",
"order",
"of",
"bits",
"to",
"be",
"read",
"/",
"written",
"over",
"serial",
"lines",
".",
"Should",
"be",
"either",
"MSBFIRST",
"for",
"most",
"-",
"significant",
"first",
"or",
"LSBFIRST",
"for",
"least",
"-",
"signifcant",
"first",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L201-L218 | [
"def",
"set_bit_order",
"(",
"self",
",",
"order",
")",
":",
"# Set self._mask to the bitmask which points at the appropriate bit to",
"# read or write, and appropriate left/right shift operator function for",
"# reading/writing.",
"if",
"order",
"==",
"MSBFIRST",
":",
"self",
".",
"_mask",
"=",
"0x80",
"self",
".",
"_write_shift",
"=",
"operator",
".",
"lshift",
"self",
".",
"_read_shift",
"=",
"operator",
".",
"rshift",
"elif",
"order",
"==",
"LSBFIRST",
":",
"self",
".",
"_mask",
"=",
"0x01",
"self",
".",
"_write_shift",
"=",
"operator",
".",
"rshift",
"self",
".",
"_read_shift",
"=",
"operator",
".",
"lshift",
"else",
":",
"raise",
"ValueError",
"(",
"'Order must be MSBFIRST or LSBFIRST.'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BitBang.write | Half-duplex SPI write. If assert_ss is True, the SS line will be
asserted low, the specified bytes will be clocked out the MOSI line, and
if deassert_ss is True the SS line be put back high. | Adafruit_GPIO/SPI.py | def write(self, data, assert_ss=True, deassert_ss=True):
"""Half-duplex SPI write. If assert_ss is True, the SS line will be
asserted low, the specified bytes will be clocked out the MOSI line, and
if deassert_ss is True the SS line be put back high.
"""
# Fail MOSI is not specified.
if self._mosi is None:
raise RuntimeError('Write attempted with no MOSI pin specified.')
if assert_ss and self._ss is not None:
self._gpio.set_low(self._ss)
for byte in data:
for i in range(8):
# Write bit to MOSI.
if self._write_shift(byte, i) & self._mask:
self._gpio.set_high(self._mosi)
else:
self._gpio.set_low(self._mosi)
# Flip clock off base.
self._gpio.output(self._sclk, not self._clock_base)
# Return clock to base.
self._gpio.output(self._sclk, self._clock_base)
if deassert_ss and self._ss is not None:
self._gpio.set_high(self._ss) | def write(self, data, assert_ss=True, deassert_ss=True):
"""Half-duplex SPI write. If assert_ss is True, the SS line will be
asserted low, the specified bytes will be clocked out the MOSI line, and
if deassert_ss is True the SS line be put back high.
"""
# Fail MOSI is not specified.
if self._mosi is None:
raise RuntimeError('Write attempted with no MOSI pin specified.')
if assert_ss and self._ss is not None:
self._gpio.set_low(self._ss)
for byte in data:
for i in range(8):
# Write bit to MOSI.
if self._write_shift(byte, i) & self._mask:
self._gpio.set_high(self._mosi)
else:
self._gpio.set_low(self._mosi)
# Flip clock off base.
self._gpio.output(self._sclk, not self._clock_base)
# Return clock to base.
self._gpio.output(self._sclk, self._clock_base)
if deassert_ss and self._ss is not None:
self._gpio.set_high(self._ss) | [
"Half",
"-",
"duplex",
"SPI",
"write",
".",
"If",
"assert_ss",
"is",
"True",
"the",
"SS",
"line",
"will",
"be",
"asserted",
"low",
"the",
"specified",
"bytes",
"will",
"be",
"clocked",
"out",
"the",
"MOSI",
"line",
"and",
"if",
"deassert_ss",
"is",
"True",
"the",
"SS",
"line",
"be",
"put",
"back",
"high",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L224-L246 | [
"def",
"write",
"(",
"self",
",",
"data",
",",
"assert_ss",
"=",
"True",
",",
"deassert_ss",
"=",
"True",
")",
":",
"# Fail MOSI is not specified.",
"if",
"self",
".",
"_mosi",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Write attempted with no MOSI pin specified.'",
")",
"if",
"assert_ss",
"and",
"self",
".",
"_ss",
"is",
"not",
"None",
":",
"self",
".",
"_gpio",
".",
"set_low",
"(",
"self",
".",
"_ss",
")",
"for",
"byte",
"in",
"data",
":",
"for",
"i",
"in",
"range",
"(",
"8",
")",
":",
"# Write bit to MOSI.",
"if",
"self",
".",
"_write_shift",
"(",
"byte",
",",
"i",
")",
"&",
"self",
".",
"_mask",
":",
"self",
".",
"_gpio",
".",
"set_high",
"(",
"self",
".",
"_mosi",
")",
"else",
":",
"self",
".",
"_gpio",
".",
"set_low",
"(",
"self",
".",
"_mosi",
")",
"# Flip clock off base.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"not",
"self",
".",
"_clock_base",
")",
"# Return clock to base.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"self",
".",
"_clock_base",
")",
"if",
"deassert_ss",
"and",
"self",
".",
"_ss",
"is",
"not",
"None",
":",
"self",
".",
"_gpio",
".",
"set_high",
"(",
"self",
".",
"_ss",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BitBang.read | Half-duplex SPI read. If assert_ss is true, the SS line will be
asserted low, the specified length of bytes will be clocked in the MISO
line, and if deassert_ss is true the SS line will be put back high.
Bytes which are read will be returned as a bytearray object. | Adafruit_GPIO/SPI.py | def read(self, length, assert_ss=True, deassert_ss=True):
"""Half-duplex SPI read. If assert_ss is true, the SS line will be
asserted low, the specified length of bytes will be clocked in the MISO
line, and if deassert_ss is true the SS line will be put back high.
Bytes which are read will be returned as a bytearray object.
"""
if self._miso is None:
raise RuntimeError('Read attempted with no MISO pin specified.')
if assert_ss and self._ss is not None:
self._gpio.set_low(self._ss)
result = bytearray(length)
for i in range(length):
for j in range(8):
# Flip clock off base.
self._gpio.output(self._sclk, not self._clock_base)
# Handle read on leading edge of clock.
if self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
# Return clock to base.
self._gpio.output(self._sclk, self._clock_base)
# Handle read on trailing edge of clock.
if not self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
if deassert_ss and self._ss is not None:
self._gpio.set_high(self._ss)
return result | def read(self, length, assert_ss=True, deassert_ss=True):
"""Half-duplex SPI read. If assert_ss is true, the SS line will be
asserted low, the specified length of bytes will be clocked in the MISO
line, and if deassert_ss is true the SS line will be put back high.
Bytes which are read will be returned as a bytearray object.
"""
if self._miso is None:
raise RuntimeError('Read attempted with no MISO pin specified.')
if assert_ss and self._ss is not None:
self._gpio.set_low(self._ss)
result = bytearray(length)
for i in range(length):
for j in range(8):
# Flip clock off base.
self._gpio.output(self._sclk, not self._clock_base)
# Handle read on leading edge of clock.
if self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
# Return clock to base.
self._gpio.output(self._sclk, self._clock_base)
# Handle read on trailing edge of clock.
if not self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
if deassert_ss and self._ss is not None:
self._gpio.set_high(self._ss)
return result | [
"Half",
"-",
"duplex",
"SPI",
"read",
".",
"If",
"assert_ss",
"is",
"true",
"the",
"SS",
"line",
"will",
"be",
"asserted",
"low",
"the",
"specified",
"length",
"of",
"bytes",
"will",
"be",
"clocked",
"in",
"the",
"MISO",
"line",
"and",
"if",
"deassert_ss",
"is",
"true",
"the",
"SS",
"line",
"will",
"be",
"put",
"back",
"high",
".",
"Bytes",
"which",
"are",
"read",
"will",
"be",
"returned",
"as",
"a",
"bytearray",
"object",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L248-L283 | [
"def",
"read",
"(",
"self",
",",
"length",
",",
"assert_ss",
"=",
"True",
",",
"deassert_ss",
"=",
"True",
")",
":",
"if",
"self",
".",
"_miso",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Read attempted with no MISO pin specified.'",
")",
"if",
"assert_ss",
"and",
"self",
".",
"_ss",
"is",
"not",
"None",
":",
"self",
".",
"_gpio",
".",
"set_low",
"(",
"self",
".",
"_ss",
")",
"result",
"=",
"bytearray",
"(",
"length",
")",
"for",
"i",
"in",
"range",
"(",
"length",
")",
":",
"for",
"j",
"in",
"range",
"(",
"8",
")",
":",
"# Flip clock off base.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"not",
"self",
".",
"_clock_base",
")",
"# Handle read on leading edge of clock.",
"if",
"self",
".",
"_read_leading",
":",
"if",
"self",
".",
"_gpio",
".",
"is_high",
"(",
"self",
".",
"_miso",
")",
":",
"# Set bit to 1 at appropriate location.",
"result",
"[",
"i",
"]",
"|=",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"else",
":",
"# Set bit to 0 at appropriate location.",
"result",
"[",
"i",
"]",
"&=",
"~",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"# Return clock to base.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"self",
".",
"_clock_base",
")",
"# Handle read on trailing edge of clock.",
"if",
"not",
"self",
".",
"_read_leading",
":",
"if",
"self",
".",
"_gpio",
".",
"is_high",
"(",
"self",
".",
"_miso",
")",
":",
"# Set bit to 1 at appropriate location.",
"result",
"[",
"i",
"]",
"|=",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"else",
":",
"# Set bit to 0 at appropriate location.",
"result",
"[",
"i",
"]",
"&=",
"~",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"if",
"deassert_ss",
"and",
"self",
".",
"_ss",
"is",
"not",
"None",
":",
"self",
".",
"_gpio",
".",
"set_high",
"(",
"self",
".",
"_ss",
")",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BitBang.transfer | Full-duplex SPI read and write. If assert_ss is true, the SS line
will be asserted low, the specified bytes will be clocked out the MOSI
line while bytes will also be read from the MISO line, and if
deassert_ss is true the SS line will be put back high. Bytes which are
read will be returned as a bytearray object. | Adafruit_GPIO/SPI.py | def transfer(self, data, assert_ss=True, deassert_ss=True):
"""Full-duplex SPI read and write. If assert_ss is true, the SS line
will be asserted low, the specified bytes will be clocked out the MOSI
line while bytes will also be read from the MISO line, and if
deassert_ss is true the SS line will be put back high. Bytes which are
read will be returned as a bytearray object.
"""
if self._mosi is None:
raise RuntimeError('Write attempted with no MOSI pin specified.')
if self._miso is None:
raise RuntimeError('Read attempted with no MISO pin specified.')
if assert_ss and self._ss is not None:
self._gpio.set_low(self._ss)
result = bytearray(len(data))
for i in range(len(data)):
for j in range(8):
# Write bit to MOSI.
if self._write_shift(data[i], j) & self._mask:
self._gpio.set_high(self._mosi)
else:
self._gpio.set_low(self._mosi)
# Flip clock off base.
self._gpio.output(self._sclk, not self._clock_base)
# Handle read on leading edge of clock.
if self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
# Return clock to base.
self._gpio.output(self._sclk, self._clock_base)
# Handle read on trailing edge of clock.
if not self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
if deassert_ss and self._ss is not None:
self._gpio.set_high(self._ss)
return result | def transfer(self, data, assert_ss=True, deassert_ss=True):
"""Full-duplex SPI read and write. If assert_ss is true, the SS line
will be asserted low, the specified bytes will be clocked out the MOSI
line while bytes will also be read from the MISO line, and if
deassert_ss is true the SS line will be put back high. Bytes which are
read will be returned as a bytearray object.
"""
if self._mosi is None:
raise RuntimeError('Write attempted with no MOSI pin specified.')
if self._miso is None:
raise RuntimeError('Read attempted with no MISO pin specified.')
if assert_ss and self._ss is not None:
self._gpio.set_low(self._ss)
result = bytearray(len(data))
for i in range(len(data)):
for j in range(8):
# Write bit to MOSI.
if self._write_shift(data[i], j) & self._mask:
self._gpio.set_high(self._mosi)
else:
self._gpio.set_low(self._mosi)
# Flip clock off base.
self._gpio.output(self._sclk, not self._clock_base)
# Handle read on leading edge of clock.
if self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
# Return clock to base.
self._gpio.output(self._sclk, self._clock_base)
# Handle read on trailing edge of clock.
if not self._read_leading:
if self._gpio.is_high(self._miso):
# Set bit to 1 at appropriate location.
result[i] |= self._read_shift(self._mask, j)
else:
# Set bit to 0 at appropriate location.
result[i] &= ~self._read_shift(self._mask, j)
if deassert_ss and self._ss is not None:
self._gpio.set_high(self._ss)
return result | [
"Full",
"-",
"duplex",
"SPI",
"read",
"and",
"write",
".",
"If",
"assert_ss",
"is",
"true",
"the",
"SS",
"line",
"will",
"be",
"asserted",
"low",
"the",
"specified",
"bytes",
"will",
"be",
"clocked",
"out",
"the",
"MOSI",
"line",
"while",
"bytes",
"will",
"also",
"be",
"read",
"from",
"the",
"MISO",
"line",
"and",
"if",
"deassert_ss",
"is",
"true",
"the",
"SS",
"line",
"will",
"be",
"put",
"back",
"high",
".",
"Bytes",
"which",
"are",
"read",
"will",
"be",
"returned",
"as",
"a",
"bytearray",
"object",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/SPI.py#L285-L328 | [
"def",
"transfer",
"(",
"self",
",",
"data",
",",
"assert_ss",
"=",
"True",
",",
"deassert_ss",
"=",
"True",
")",
":",
"if",
"self",
".",
"_mosi",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Write attempted with no MOSI pin specified.'",
")",
"if",
"self",
".",
"_miso",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Read attempted with no MISO pin specified.'",
")",
"if",
"assert_ss",
"and",
"self",
".",
"_ss",
"is",
"not",
"None",
":",
"self",
".",
"_gpio",
".",
"set_low",
"(",
"self",
".",
"_ss",
")",
"result",
"=",
"bytearray",
"(",
"len",
"(",
"data",
")",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"data",
")",
")",
":",
"for",
"j",
"in",
"range",
"(",
"8",
")",
":",
"# Write bit to MOSI.",
"if",
"self",
".",
"_write_shift",
"(",
"data",
"[",
"i",
"]",
",",
"j",
")",
"&",
"self",
".",
"_mask",
":",
"self",
".",
"_gpio",
".",
"set_high",
"(",
"self",
".",
"_mosi",
")",
"else",
":",
"self",
".",
"_gpio",
".",
"set_low",
"(",
"self",
".",
"_mosi",
")",
"# Flip clock off base.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"not",
"self",
".",
"_clock_base",
")",
"# Handle read on leading edge of clock.",
"if",
"self",
".",
"_read_leading",
":",
"if",
"self",
".",
"_gpio",
".",
"is_high",
"(",
"self",
".",
"_miso",
")",
":",
"# Set bit to 1 at appropriate location.",
"result",
"[",
"i",
"]",
"|=",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"else",
":",
"# Set bit to 0 at appropriate location.",
"result",
"[",
"i",
"]",
"&=",
"~",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"# Return clock to base.",
"self",
".",
"_gpio",
".",
"output",
"(",
"self",
".",
"_sclk",
",",
"self",
".",
"_clock_base",
")",
"# Handle read on trailing edge of clock.",
"if",
"not",
"self",
".",
"_read_leading",
":",
"if",
"self",
".",
"_gpio",
".",
"is_high",
"(",
"self",
".",
"_miso",
")",
":",
"# Set bit to 1 at appropriate location.",
"result",
"[",
"i",
"]",
"|=",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"else",
":",
"# Set bit to 0 at appropriate location.",
"result",
"[",
"i",
"]",
"&=",
"~",
"self",
".",
"_read_shift",
"(",
"self",
".",
"_mask",
",",
"j",
")",
"if",
"deassert_ss",
"and",
"self",
".",
"_ss",
"is",
"not",
"None",
":",
"self",
".",
"_gpio",
".",
"set_high",
"(",
"self",
".",
"_ss",
")",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.setup | Set the input or output mode for a specified pin. Mode should be
either GPIO.OUT or GPIO.IN. | Adafruit_GPIO/MCP230xx.py | def setup(self, pin, value):
"""Set the input or output mode for a specified pin. Mode should be
either GPIO.OUT or GPIO.IN.
"""
self._validate_pin(pin)
# Set bit to 1 for input or 0 for output.
if value == GPIO.IN:
self.iodir[int(pin/8)] |= 1 << (int(pin%8))
elif value == GPIO.OUT:
self.iodir[int(pin/8)] &= ~(1 << (int(pin%8)))
else:
raise ValueError('Unexpected value. Must be GPIO.IN or GPIO.OUT.')
self.write_iodir() | def setup(self, pin, value):
"""Set the input or output mode for a specified pin. Mode should be
either GPIO.OUT or GPIO.IN.
"""
self._validate_pin(pin)
# Set bit to 1 for input or 0 for output.
if value == GPIO.IN:
self.iodir[int(pin/8)] |= 1 << (int(pin%8))
elif value == GPIO.OUT:
self.iodir[int(pin/8)] &= ~(1 << (int(pin%8)))
else:
raise ValueError('Unexpected value. Must be GPIO.IN or GPIO.OUT.')
self.write_iodir() | [
"Set",
"the",
"input",
"or",
"output",
"mode",
"for",
"a",
"specified",
"pin",
".",
"Mode",
"should",
"be",
"either",
"GPIO",
".",
"OUT",
"or",
"GPIO",
".",
"IN",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L54-L66 | [
"def",
"setup",
"(",
"self",
",",
"pin",
",",
"value",
")",
":",
"self",
".",
"_validate_pin",
"(",
"pin",
")",
"# Set bit to 1 for input or 0 for output.",
"if",
"value",
"==",
"GPIO",
".",
"IN",
":",
"self",
".",
"iodir",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"|=",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
"elif",
"value",
"==",
"GPIO",
".",
"OUT",
":",
"self",
".",
"iodir",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"&=",
"~",
"(",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Unexpected value. Must be GPIO.IN or GPIO.OUT.'",
")",
"self",
".",
"write_iodir",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.output_pins | Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values. | Adafruit_GPIO/MCP230xx.py | def output_pins(self, pins):
"""Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values.
"""
[self._validate_pin(pin) for pin in pins.keys()]
# Set each changed pin's bit.
for pin, value in iter(pins.items()):
if value:
self.gpio[int(pin/8)] |= 1 << (int(pin%8))
else:
self.gpio[int(pin/8)] &= ~(1 << (int(pin%8)))
# Write GPIO state.
self.write_gpio() | def output_pins(self, pins):
"""Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values.
"""
[self._validate_pin(pin) for pin in pins.keys()]
# Set each changed pin's bit.
for pin, value in iter(pins.items()):
if value:
self.gpio[int(pin/8)] |= 1 << (int(pin%8))
else:
self.gpio[int(pin/8)] &= ~(1 << (int(pin%8)))
# Write GPIO state.
self.write_gpio() | [
"Set",
"multiple",
"pins",
"high",
"or",
"low",
"at",
"once",
".",
"Pins",
"should",
"be",
"a",
"dict",
"of",
"pin",
"name",
"to",
"pin",
"value",
"(",
"HIGH",
"/",
"True",
"for",
"1",
"LOW",
"/",
"False",
"for",
"0",
")",
".",
"All",
"provided",
"pins",
"will",
"be",
"set",
"to",
"the",
"given",
"values",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L75-L88 | [
"def",
"output_pins",
"(",
"self",
",",
"pins",
")",
":",
"[",
"self",
".",
"_validate_pin",
"(",
"pin",
")",
"for",
"pin",
"in",
"pins",
".",
"keys",
"(",
")",
"]",
"# Set each changed pin's bit.",
"for",
"pin",
",",
"value",
"in",
"iter",
"(",
"pins",
".",
"items",
"(",
")",
")",
":",
"if",
"value",
":",
"self",
".",
"gpio",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"|=",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
"else",
":",
"self",
".",
"gpio",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"&=",
"~",
"(",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
")",
"# Write GPIO state.",
"self",
".",
"write_gpio",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.input_pins | Read multiple pins specified in the given list and return list of pin values
GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low. | Adafruit_GPIO/MCP230xx.py | def input_pins(self, pins):
"""Read multiple pins specified in the given list and return list of pin values
GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.
"""
[self._validate_pin(pin) for pin in pins]
# Get GPIO state.
self.gpio = self._device.readList(self.GPIO, self.gpio_bytes)
# Return True if pin's bit is set.
return [(self.gpio[int(pin/8)] & 1 << (int(pin%8))) > 0 for pin in pins] | def input_pins(self, pins):
"""Read multiple pins specified in the given list and return list of pin values
GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low.
"""
[self._validate_pin(pin) for pin in pins]
# Get GPIO state.
self.gpio = self._device.readList(self.GPIO, self.gpio_bytes)
# Return True if pin's bit is set.
return [(self.gpio[int(pin/8)] & 1 << (int(pin%8))) > 0 for pin in pins] | [
"Read",
"multiple",
"pins",
"specified",
"in",
"the",
"given",
"list",
"and",
"return",
"list",
"of",
"pin",
"values",
"GPIO",
".",
"HIGH",
"/",
"True",
"if",
"the",
"pin",
"is",
"pulled",
"high",
"or",
"GPIO",
".",
"LOW",
"/",
"False",
"if",
"pulled",
"low",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L97-L105 | [
"def",
"input_pins",
"(",
"self",
",",
"pins",
")",
":",
"[",
"self",
".",
"_validate_pin",
"(",
"pin",
")",
"for",
"pin",
"in",
"pins",
"]",
"# Get GPIO state.",
"self",
".",
"gpio",
"=",
"self",
".",
"_device",
".",
"readList",
"(",
"self",
".",
"GPIO",
",",
"self",
".",
"gpio_bytes",
")",
"# Return True if pin's bit is set.",
"return",
"[",
"(",
"self",
".",
"gpio",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"&",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
")",
">",
"0",
"for",
"pin",
"in",
"pins",
"]"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.pullup | Turn on the pull-up resistor for the specified pin if enabled is True,
otherwise turn off the pull-up resistor. | Adafruit_GPIO/MCP230xx.py | def pullup(self, pin, enabled):
"""Turn on the pull-up resistor for the specified pin if enabled is True,
otherwise turn off the pull-up resistor.
"""
self._validate_pin(pin)
if enabled:
self.gppu[int(pin/8)] |= 1 << (int(pin%8))
else:
self.gppu[int(pin/8)] &= ~(1 << (int(pin%8)))
self.write_gppu() | def pullup(self, pin, enabled):
"""Turn on the pull-up resistor for the specified pin if enabled is True,
otherwise turn off the pull-up resistor.
"""
self._validate_pin(pin)
if enabled:
self.gppu[int(pin/8)] |= 1 << (int(pin%8))
else:
self.gppu[int(pin/8)] &= ~(1 << (int(pin%8)))
self.write_gppu() | [
"Turn",
"on",
"the",
"pull",
"-",
"up",
"resistor",
"for",
"the",
"specified",
"pin",
"if",
"enabled",
"is",
"True",
"otherwise",
"turn",
"off",
"the",
"pull",
"-",
"up",
"resistor",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L108-L117 | [
"def",
"pullup",
"(",
"self",
",",
"pin",
",",
"enabled",
")",
":",
"self",
".",
"_validate_pin",
"(",
"pin",
")",
"if",
"enabled",
":",
"self",
".",
"gppu",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"|=",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
"else",
":",
"self",
".",
"gppu",
"[",
"int",
"(",
"pin",
"/",
"8",
")",
"]",
"&=",
"~",
"(",
"1",
"<<",
"(",
"int",
"(",
"pin",
"%",
"8",
")",
")",
")",
"self",
".",
"write_gppu",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.write_gpio | Write the specified byte value to the GPIO registor. If no value
specified the current buffered value will be written. | Adafruit_GPIO/MCP230xx.py | def write_gpio(self, gpio=None):
"""Write the specified byte value to the GPIO registor. If no value
specified the current buffered value will be written.
"""
if gpio is not None:
self.gpio = gpio
self._device.writeList(self.GPIO, self.gpio) | def write_gpio(self, gpio=None):
"""Write the specified byte value to the GPIO registor. If no value
specified the current buffered value will be written.
"""
if gpio is not None:
self.gpio = gpio
self._device.writeList(self.GPIO, self.gpio) | [
"Write",
"the",
"specified",
"byte",
"value",
"to",
"the",
"GPIO",
"registor",
".",
"If",
"no",
"value",
"specified",
"the",
"current",
"buffered",
"value",
"will",
"be",
"written",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L119-L125 | [
"def",
"write_gpio",
"(",
"self",
",",
"gpio",
"=",
"None",
")",
":",
"if",
"gpio",
"is",
"not",
"None",
":",
"self",
".",
"gpio",
"=",
"gpio",
"self",
".",
"_device",
".",
"writeList",
"(",
"self",
".",
"GPIO",
",",
"self",
".",
"gpio",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.write_iodir | Write the specified byte value to the IODIR registor. If no value
specified the current buffered value will be written. | Adafruit_GPIO/MCP230xx.py | def write_iodir(self, iodir=None):
"""Write the specified byte value to the IODIR registor. If no value
specified the current buffered value will be written.
"""
if iodir is not None:
self.iodir = iodir
self._device.writeList(self.IODIR, self.iodir) | def write_iodir(self, iodir=None):
"""Write the specified byte value to the IODIR registor. If no value
specified the current buffered value will be written.
"""
if iodir is not None:
self.iodir = iodir
self._device.writeList(self.IODIR, self.iodir) | [
"Write",
"the",
"specified",
"byte",
"value",
"to",
"the",
"IODIR",
"registor",
".",
"If",
"no",
"value",
"specified",
"the",
"current",
"buffered",
"value",
"will",
"be",
"written",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L127-L133 | [
"def",
"write_iodir",
"(",
"self",
",",
"iodir",
"=",
"None",
")",
":",
"if",
"iodir",
"is",
"not",
"None",
":",
"self",
".",
"iodir",
"=",
"iodir",
"self",
".",
"_device",
".",
"writeList",
"(",
"self",
".",
"IODIR",
",",
"self",
".",
"iodir",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | MCP230xxBase.write_gppu | Write the specified byte value to the GPPU registor. If no value
specified the current buffered value will be written. | Adafruit_GPIO/MCP230xx.py | def write_gppu(self, gppu=None):
"""Write the specified byte value to the GPPU registor. If no value
specified the current buffered value will be written.
"""
if gppu is not None:
self.gppu = gppu
self._device.writeList(self.GPPU, self.gppu) | def write_gppu(self, gppu=None):
"""Write the specified byte value to the GPPU registor. If no value
specified the current buffered value will be written.
"""
if gppu is not None:
self.gppu = gppu
self._device.writeList(self.GPPU, self.gppu) | [
"Write",
"the",
"specified",
"byte",
"value",
"to",
"the",
"GPPU",
"registor",
".",
"If",
"no",
"value",
"specified",
"the",
"current",
"buffered",
"value",
"will",
"be",
"written",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/MCP230xx.py#L135-L141 | [
"def",
"write_gppu",
"(",
"self",
",",
"gppu",
"=",
"None",
")",
":",
"if",
"gppu",
"is",
"not",
"None",
":",
"self",
".",
"gppu",
"=",
"gppu",
"self",
".",
"_device",
".",
"writeList",
"(",
"self",
".",
"GPPU",
",",
"self",
".",
"gppu",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | disable_FTDI_driver | Disable the FTDI drivers for the current platform. This is necessary
because they will conflict with libftdi and accessing the FT232H. Note you
can enable the FTDI drivers again by calling enable_FTDI_driver. | Adafruit_GPIO/FT232H.py | def disable_FTDI_driver():
"""Disable the FTDI drivers for the current platform. This is necessary
because they will conflict with libftdi and accessing the FT232H. Note you
can enable the FTDI drivers again by calling enable_FTDI_driver.
"""
logger.debug('Disabling FTDI driver.')
if sys.platform == 'darwin':
logger.debug('Detected Mac OSX')
# Mac OS commands to disable FTDI driver.
_check_running_as_root()
subprocess.call('kextunload -b com.apple.driver.AppleUSBFTDI', shell=True)
subprocess.call('kextunload /System/Library/Extensions/FTDIUSBSerialDriver.kext', shell=True)
elif sys.platform.startswith('linux'):
logger.debug('Detected Linux')
# Linux commands to disable FTDI driver.
_check_running_as_root()
subprocess.call('modprobe -r -q ftdi_sio', shell=True)
subprocess.call('modprobe -r -q usbserial', shell=True) | def disable_FTDI_driver():
"""Disable the FTDI drivers for the current platform. This is necessary
because they will conflict with libftdi and accessing the FT232H. Note you
can enable the FTDI drivers again by calling enable_FTDI_driver.
"""
logger.debug('Disabling FTDI driver.')
if sys.platform == 'darwin':
logger.debug('Detected Mac OSX')
# Mac OS commands to disable FTDI driver.
_check_running_as_root()
subprocess.call('kextunload -b com.apple.driver.AppleUSBFTDI', shell=True)
subprocess.call('kextunload /System/Library/Extensions/FTDIUSBSerialDriver.kext', shell=True)
elif sys.platform.startswith('linux'):
logger.debug('Detected Linux')
# Linux commands to disable FTDI driver.
_check_running_as_root()
subprocess.call('modprobe -r -q ftdi_sio', shell=True)
subprocess.call('modprobe -r -q usbserial', shell=True) | [
"Disable",
"the",
"FTDI",
"drivers",
"for",
"the",
"current",
"platform",
".",
"This",
"is",
"necessary",
"because",
"they",
"will",
"conflict",
"with",
"libftdi",
"and",
"accessing",
"the",
"FT232H",
".",
"Note",
"you",
"can",
"enable",
"the",
"FTDI",
"drivers",
"again",
"by",
"calling",
"enable_FTDI_driver",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L52-L69 | [
"def",
"disable_FTDI_driver",
"(",
")",
":",
"logger",
".",
"debug",
"(",
"'Disabling FTDI driver.'",
")",
"if",
"sys",
".",
"platform",
"==",
"'darwin'",
":",
"logger",
".",
"debug",
"(",
"'Detected Mac OSX'",
")",
"# Mac OS commands to disable FTDI driver.",
"_check_running_as_root",
"(",
")",
"subprocess",
".",
"call",
"(",
"'kextunload -b com.apple.driver.AppleUSBFTDI'",
",",
"shell",
"=",
"True",
")",
"subprocess",
".",
"call",
"(",
"'kextunload /System/Library/Extensions/FTDIUSBSerialDriver.kext'",
",",
"shell",
"=",
"True",
")",
"elif",
"sys",
".",
"platform",
".",
"startswith",
"(",
"'linux'",
")",
":",
"logger",
".",
"debug",
"(",
"'Detected Linux'",
")",
"# Linux commands to disable FTDI driver.",
"_check_running_as_root",
"(",
")",
"subprocess",
".",
"call",
"(",
"'modprobe -r -q ftdi_sio'",
",",
"shell",
"=",
"True",
")",
"subprocess",
".",
"call",
"(",
"'modprobe -r -q usbserial'",
",",
"shell",
"=",
"True",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | enable_FTDI_driver | Re-enable the FTDI drivers for the current platform. | Adafruit_GPIO/FT232H.py | def enable_FTDI_driver():
"""Re-enable the FTDI drivers for the current platform."""
logger.debug('Enabling FTDI driver.')
if sys.platform == 'darwin':
logger.debug('Detected Mac OSX')
# Mac OS commands to enable FTDI driver.
_check_running_as_root()
subprocess.check_call('kextload -b com.apple.driver.AppleUSBFTDI', shell=True)
subprocess.check_call('kextload /System/Library/Extensions/FTDIUSBSerialDriver.kext', shell=True)
elif sys.platform.startswith('linux'):
logger.debug('Detected Linux')
# Linux commands to enable FTDI driver.
_check_running_as_root()
subprocess.check_call('modprobe -q ftdi_sio', shell=True)
subprocess.check_call('modprobe -q usbserial', shell=True) | def enable_FTDI_driver():
"""Re-enable the FTDI drivers for the current platform."""
logger.debug('Enabling FTDI driver.')
if sys.platform == 'darwin':
logger.debug('Detected Mac OSX')
# Mac OS commands to enable FTDI driver.
_check_running_as_root()
subprocess.check_call('kextload -b com.apple.driver.AppleUSBFTDI', shell=True)
subprocess.check_call('kextload /System/Library/Extensions/FTDIUSBSerialDriver.kext', shell=True)
elif sys.platform.startswith('linux'):
logger.debug('Detected Linux')
# Linux commands to enable FTDI driver.
_check_running_as_root()
subprocess.check_call('modprobe -q ftdi_sio', shell=True)
subprocess.check_call('modprobe -q usbserial', shell=True) | [
"Re",
"-",
"enable",
"the",
"FTDI",
"drivers",
"for",
"the",
"current",
"platform",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L72-L86 | [
"def",
"enable_FTDI_driver",
"(",
")",
":",
"logger",
".",
"debug",
"(",
"'Enabling FTDI driver.'",
")",
"if",
"sys",
".",
"platform",
"==",
"'darwin'",
":",
"logger",
".",
"debug",
"(",
"'Detected Mac OSX'",
")",
"# Mac OS commands to enable FTDI driver.",
"_check_running_as_root",
"(",
")",
"subprocess",
".",
"check_call",
"(",
"'kextload -b com.apple.driver.AppleUSBFTDI'",
",",
"shell",
"=",
"True",
")",
"subprocess",
".",
"check_call",
"(",
"'kextload /System/Library/Extensions/FTDIUSBSerialDriver.kext'",
",",
"shell",
"=",
"True",
")",
"elif",
"sys",
".",
"platform",
".",
"startswith",
"(",
"'linux'",
")",
":",
"logger",
".",
"debug",
"(",
"'Detected Linux'",
")",
"# Linux commands to enable FTDI driver.",
"_check_running_as_root",
"(",
")",
"subprocess",
".",
"check_call",
"(",
"'modprobe -q ftdi_sio'",
",",
"shell",
"=",
"True",
")",
"subprocess",
".",
"check_call",
"(",
"'modprobe -q usbserial'",
",",
"shell",
"=",
"True",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | enumerate_device_serials | Return a list of all FT232H device serial numbers connected to the
machine. You can use these serial numbers to open a specific FT232H device
by passing it to the FT232H initializer's serial parameter. | Adafruit_GPIO/FT232H.py | def enumerate_device_serials(vid=FT232H_VID, pid=FT232H_PID):
"""Return a list of all FT232H device serial numbers connected to the
machine. You can use these serial numbers to open a specific FT232H device
by passing it to the FT232H initializer's serial parameter.
"""
try:
# Create a libftdi context.
ctx = None
ctx = ftdi.new()
# Enumerate FTDI devices.
device_list = None
count, device_list = ftdi.usb_find_all(ctx, vid, pid)
if count < 0:
raise RuntimeError('ftdi_usb_find_all returned error {0}: {1}'.format(count, ftdi.get_error_string(self._ctx)))
# Walk through list of devices and assemble list of serial numbers.
devices = []
while device_list is not None:
# Get USB device strings and add serial to list of devices.
ret, manufacturer, description, serial = ftdi.usb_get_strings(ctx, device_list.dev, 256, 256, 256)
if serial is not None:
devices.append(serial)
device_list = device_list.next
return devices
finally:
# Make sure to clean up list and context when done.
if device_list is not None:
ftdi.list_free(device_list)
if ctx is not None:
ftdi.free(ctx) | def enumerate_device_serials(vid=FT232H_VID, pid=FT232H_PID):
"""Return a list of all FT232H device serial numbers connected to the
machine. You can use these serial numbers to open a specific FT232H device
by passing it to the FT232H initializer's serial parameter.
"""
try:
# Create a libftdi context.
ctx = None
ctx = ftdi.new()
# Enumerate FTDI devices.
device_list = None
count, device_list = ftdi.usb_find_all(ctx, vid, pid)
if count < 0:
raise RuntimeError('ftdi_usb_find_all returned error {0}: {1}'.format(count, ftdi.get_error_string(self._ctx)))
# Walk through list of devices and assemble list of serial numbers.
devices = []
while device_list is not None:
# Get USB device strings and add serial to list of devices.
ret, manufacturer, description, serial = ftdi.usb_get_strings(ctx, device_list.dev, 256, 256, 256)
if serial is not None:
devices.append(serial)
device_list = device_list.next
return devices
finally:
# Make sure to clean up list and context when done.
if device_list is not None:
ftdi.list_free(device_list)
if ctx is not None:
ftdi.free(ctx) | [
"Return",
"a",
"list",
"of",
"all",
"FT232H",
"device",
"serial",
"numbers",
"connected",
"to",
"the",
"machine",
".",
"You",
"can",
"use",
"these",
"serial",
"numbers",
"to",
"open",
"a",
"specific",
"FT232H",
"device",
"by",
"passing",
"it",
"to",
"the",
"FT232H",
"initializer",
"s",
"serial",
"parameter",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L96-L124 | [
"def",
"enumerate_device_serials",
"(",
"vid",
"=",
"FT232H_VID",
",",
"pid",
"=",
"FT232H_PID",
")",
":",
"try",
":",
"# Create a libftdi context.",
"ctx",
"=",
"None",
"ctx",
"=",
"ftdi",
".",
"new",
"(",
")",
"# Enumerate FTDI devices.",
"device_list",
"=",
"None",
"count",
",",
"device_list",
"=",
"ftdi",
".",
"usb_find_all",
"(",
"ctx",
",",
"vid",
",",
"pid",
")",
"if",
"count",
"<",
"0",
":",
"raise",
"RuntimeError",
"(",
"'ftdi_usb_find_all returned error {0}: {1}'",
".",
"format",
"(",
"count",
",",
"ftdi",
".",
"get_error_string",
"(",
"self",
".",
"_ctx",
")",
")",
")",
"# Walk through list of devices and assemble list of serial numbers.",
"devices",
"=",
"[",
"]",
"while",
"device_list",
"is",
"not",
"None",
":",
"# Get USB device strings and add serial to list of devices.",
"ret",
",",
"manufacturer",
",",
"description",
",",
"serial",
"=",
"ftdi",
".",
"usb_get_strings",
"(",
"ctx",
",",
"device_list",
".",
"dev",
",",
"256",
",",
"256",
",",
"256",
")",
"if",
"serial",
"is",
"not",
"None",
":",
"devices",
".",
"append",
"(",
"serial",
")",
"device_list",
"=",
"device_list",
".",
"next",
"return",
"devices",
"finally",
":",
"# Make sure to clean up list and context when done.",
"if",
"device_list",
"is",
"not",
"None",
":",
"ftdi",
".",
"list_free",
"(",
"device_list",
")",
"if",
"ctx",
"is",
"not",
"None",
":",
"ftdi",
".",
"free",
"(",
"ctx",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.close | Close the FTDI device. Will be automatically called when the program ends. | Adafruit_GPIO/FT232H.py | def close(self):
"""Close the FTDI device. Will be automatically called when the program ends."""
if self._ctx is not None:
ftdi.free(self._ctx)
self._ctx = None | def close(self):
"""Close the FTDI device. Will be automatically called when the program ends."""
if self._ctx is not None:
ftdi.free(self._ctx)
self._ctx = None | [
"Close",
"the",
"FTDI",
"device",
".",
"Will",
"be",
"automatically",
"called",
"when",
"the",
"program",
"ends",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L171-L175 | [
"def",
"close",
"(",
"self",
")",
":",
"if",
"self",
".",
"_ctx",
"is",
"not",
"None",
":",
"ftdi",
".",
"free",
"(",
"self",
".",
"_ctx",
")",
"self",
".",
"_ctx",
"=",
"None"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H._write | Helper function to call write_data on the provided FTDI device and
verify it succeeds. | Adafruit_GPIO/FT232H.py | def _write(self, string):
"""Helper function to call write_data on the provided FTDI device and
verify it succeeds.
"""
# Get modem status. Useful to enable for debugging.
#ret, status = ftdi.poll_modem_status(self._ctx)
#if ret == 0:
# logger.debug('Modem status {0:02X}'.format(status))
#else:
# logger.debug('Modem status error {0}'.format(ret))
length = len(string)
try:
ret = ftdi.write_data(self._ctx, string, length)
except TypeError:
ret = ftdi.write_data(self._ctx, string); #compatible with libFtdi 1.3
# Log the string that was written in a python hex string format using a very
# ugly one-liner list comprehension for brevity.
#logger.debug('Wrote {0}'.format(''.join(['\\x{0:02X}'.format(ord(x)) for x in string])))
if ret < 0:
raise RuntimeError('ftdi_write_data failed with error {0}: {1}'.format(ret, ftdi.get_error_string(self._ctx)))
if ret != length:
raise RuntimeError('ftdi_write_data expected to write {0} bytes but actually wrote {1}!'.format(length, ret)) | def _write(self, string):
"""Helper function to call write_data on the provided FTDI device and
verify it succeeds.
"""
# Get modem status. Useful to enable for debugging.
#ret, status = ftdi.poll_modem_status(self._ctx)
#if ret == 0:
# logger.debug('Modem status {0:02X}'.format(status))
#else:
# logger.debug('Modem status error {0}'.format(ret))
length = len(string)
try:
ret = ftdi.write_data(self._ctx, string, length)
except TypeError:
ret = ftdi.write_data(self._ctx, string); #compatible with libFtdi 1.3
# Log the string that was written in a python hex string format using a very
# ugly one-liner list comprehension for brevity.
#logger.debug('Wrote {0}'.format(''.join(['\\x{0:02X}'.format(ord(x)) for x in string])))
if ret < 0:
raise RuntimeError('ftdi_write_data failed with error {0}: {1}'.format(ret, ftdi.get_error_string(self._ctx)))
if ret != length:
raise RuntimeError('ftdi_write_data expected to write {0} bytes but actually wrote {1}!'.format(length, ret)) | [
"Helper",
"function",
"to",
"call",
"write_data",
"on",
"the",
"provided",
"FTDI",
"device",
"and",
"verify",
"it",
"succeeds",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L177-L198 | [
"def",
"_write",
"(",
"self",
",",
"string",
")",
":",
"# Get modem status. Useful to enable for debugging.",
"#ret, status = ftdi.poll_modem_status(self._ctx)",
"#if ret == 0:",
"#\tlogger.debug('Modem status {0:02X}'.format(status))",
"#else:",
"#\tlogger.debug('Modem status error {0}'.format(ret))",
"length",
"=",
"len",
"(",
"string",
")",
"try",
":",
"ret",
"=",
"ftdi",
".",
"write_data",
"(",
"self",
".",
"_ctx",
",",
"string",
",",
"length",
")",
"except",
"TypeError",
":",
"ret",
"=",
"ftdi",
".",
"write_data",
"(",
"self",
".",
"_ctx",
",",
"string",
")",
"#compatible with libFtdi 1.3",
"# Log the string that was written in a python hex string format using a very",
"# ugly one-liner list comprehension for brevity.",
"#logger.debug('Wrote {0}'.format(''.join(['\\\\x{0:02X}'.format(ord(x)) for x in string])))",
"if",
"ret",
"<",
"0",
":",
"raise",
"RuntimeError",
"(",
"'ftdi_write_data failed with error {0}: {1}'",
".",
"format",
"(",
"ret",
",",
"ftdi",
".",
"get_error_string",
"(",
"self",
".",
"_ctx",
")",
")",
")",
"if",
"ret",
"!=",
"length",
":",
"raise",
"RuntimeError",
"(",
"'ftdi_write_data expected to write {0} bytes but actually wrote {1}!'",
".",
"format",
"(",
"length",
",",
"ret",
")",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H._check | Helper function to call the provided command on the FTDI device and
verify the response matches the expected value. | Adafruit_GPIO/FT232H.py | def _check(self, command, *args):
"""Helper function to call the provided command on the FTDI device and
verify the response matches the expected value.
"""
ret = command(self._ctx, *args)
logger.debug('Called ftdi_{0} and got response {1}.'.format(command.__name__, ret))
if ret != 0:
raise RuntimeError('ftdi_{0} failed with error {1}: {2}'.format(command.__name__, ret, ftdi.get_error_string(self._ctx))) | def _check(self, command, *args):
"""Helper function to call the provided command on the FTDI device and
verify the response matches the expected value.
"""
ret = command(self._ctx, *args)
logger.debug('Called ftdi_{0} and got response {1}.'.format(command.__name__, ret))
if ret != 0:
raise RuntimeError('ftdi_{0} failed with error {1}: {2}'.format(command.__name__, ret, ftdi.get_error_string(self._ctx))) | [
"Helper",
"function",
"to",
"call",
"the",
"provided",
"command",
"on",
"the",
"FTDI",
"device",
"and",
"verify",
"the",
"response",
"matches",
"the",
"expected",
"value",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L200-L207 | [
"def",
"_check",
"(",
"self",
",",
"command",
",",
"*",
"args",
")",
":",
"ret",
"=",
"command",
"(",
"self",
".",
"_ctx",
",",
"*",
"args",
")",
"logger",
".",
"debug",
"(",
"'Called ftdi_{0} and got response {1}.'",
".",
"format",
"(",
"command",
".",
"__name__",
",",
"ret",
")",
")",
"if",
"ret",
"!=",
"0",
":",
"raise",
"RuntimeError",
"(",
"'ftdi_{0} failed with error {1}: {2}'",
".",
"format",
"(",
"command",
".",
"__name__",
",",
"ret",
",",
"ftdi",
".",
"get_error_string",
"(",
"self",
".",
"_ctx",
")",
")",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H._poll_read | Helper function to continuously poll reads on the FTDI device until an
expected number of bytes are returned. Will throw a timeout error if no
data is received within the specified number of timeout seconds. Returns
the read data as a string if successful, otherwise raises an execption. | Adafruit_GPIO/FT232H.py | def _poll_read(self, expected, timeout_s=5.0):
"""Helper function to continuously poll reads on the FTDI device until an
expected number of bytes are returned. Will throw a timeout error if no
data is received within the specified number of timeout seconds. Returns
the read data as a string if successful, otherwise raises an execption.
"""
start = time.time()
# Start with an empty response buffer.
response = bytearray(expected)
index = 0
# Loop calling read until the response buffer is full or a timeout occurs.
while time.time() - start <= timeout_s:
ret, data = ftdi.read_data(self._ctx, expected - index)
# Fail if there was an error reading data.
if ret < 0:
raise RuntimeError('ftdi_read_data failed with error code {0}.'.format(ret))
# Add returned data to the buffer.
response[index:index+ret] = data[:ret]
index += ret
# Buffer is full, return the result data.
if index >= expected:
return str(response)
time.sleep(0.01)
raise RuntimeError('Timeout while polling ftdi_read_data for {0} bytes!'.format(expected)) | def _poll_read(self, expected, timeout_s=5.0):
"""Helper function to continuously poll reads on the FTDI device until an
expected number of bytes are returned. Will throw a timeout error if no
data is received within the specified number of timeout seconds. Returns
the read data as a string if successful, otherwise raises an execption.
"""
start = time.time()
# Start with an empty response buffer.
response = bytearray(expected)
index = 0
# Loop calling read until the response buffer is full or a timeout occurs.
while time.time() - start <= timeout_s:
ret, data = ftdi.read_data(self._ctx, expected - index)
# Fail if there was an error reading data.
if ret < 0:
raise RuntimeError('ftdi_read_data failed with error code {0}.'.format(ret))
# Add returned data to the buffer.
response[index:index+ret] = data[:ret]
index += ret
# Buffer is full, return the result data.
if index >= expected:
return str(response)
time.sleep(0.01)
raise RuntimeError('Timeout while polling ftdi_read_data for {0} bytes!'.format(expected)) | [
"Helper",
"function",
"to",
"continuously",
"poll",
"reads",
"on",
"the",
"FTDI",
"device",
"until",
"an",
"expected",
"number",
"of",
"bytes",
"are",
"returned",
".",
"Will",
"throw",
"a",
"timeout",
"error",
"if",
"no",
"data",
"is",
"received",
"within",
"the",
"specified",
"number",
"of",
"timeout",
"seconds",
".",
"Returns",
"the",
"read",
"data",
"as",
"a",
"string",
"if",
"successful",
"otherwise",
"raises",
"an",
"execption",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L209-L232 | [
"def",
"_poll_read",
"(",
"self",
",",
"expected",
",",
"timeout_s",
"=",
"5.0",
")",
":",
"start",
"=",
"time",
".",
"time",
"(",
")",
"# Start with an empty response buffer.",
"response",
"=",
"bytearray",
"(",
"expected",
")",
"index",
"=",
"0",
"# Loop calling read until the response buffer is full or a timeout occurs.",
"while",
"time",
".",
"time",
"(",
")",
"-",
"start",
"<=",
"timeout_s",
":",
"ret",
",",
"data",
"=",
"ftdi",
".",
"read_data",
"(",
"self",
".",
"_ctx",
",",
"expected",
"-",
"index",
")",
"# Fail if there was an error reading data.",
"if",
"ret",
"<",
"0",
":",
"raise",
"RuntimeError",
"(",
"'ftdi_read_data failed with error code {0}.'",
".",
"format",
"(",
"ret",
")",
")",
"# Add returned data to the buffer.",
"response",
"[",
"index",
":",
"index",
"+",
"ret",
"]",
"=",
"data",
"[",
":",
"ret",
"]",
"index",
"+=",
"ret",
"# Buffer is full, return the result data.",
"if",
"index",
">=",
"expected",
":",
"return",
"str",
"(",
"response",
")",
"time",
".",
"sleep",
"(",
"0.01",
")",
"raise",
"RuntimeError",
"(",
"'Timeout while polling ftdi_read_data for {0} bytes!'",
".",
"format",
"(",
"expected",
")",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H._mpsse_enable | Enable MPSSE mode on the FTDI device. | Adafruit_GPIO/FT232H.py | def _mpsse_enable(self):
"""Enable MPSSE mode on the FTDI device."""
# Reset MPSSE by sending mask = 0 and mode = 0
self._check(ftdi.set_bitmode, 0, 0)
# Enable MPSSE by sending mask = 0 and mode = 2
self._check(ftdi.set_bitmode, 0, 2) | def _mpsse_enable(self):
"""Enable MPSSE mode on the FTDI device."""
# Reset MPSSE by sending mask = 0 and mode = 0
self._check(ftdi.set_bitmode, 0, 0)
# Enable MPSSE by sending mask = 0 and mode = 2
self._check(ftdi.set_bitmode, 0, 2) | [
"Enable",
"MPSSE",
"mode",
"on",
"the",
"FTDI",
"device",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L234-L239 | [
"def",
"_mpsse_enable",
"(",
"self",
")",
":",
"# Reset MPSSE by sending mask = 0 and mode = 0",
"self",
".",
"_check",
"(",
"ftdi",
".",
"set_bitmode",
",",
"0",
",",
"0",
")",
"# Enable MPSSE by sending mask = 0 and mode = 2",
"self",
".",
"_check",
"(",
"ftdi",
".",
"set_bitmode",
",",
"0",
",",
"2",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H._mpsse_sync | Synchronize buffers with MPSSE by sending bad opcode and reading expected
error response. Should be called once after enabling MPSSE. | Adafruit_GPIO/FT232H.py | def _mpsse_sync(self, max_retries=10):
"""Synchronize buffers with MPSSE by sending bad opcode and reading expected
error response. Should be called once after enabling MPSSE."""
# Send a bad/unknown command (0xAB), then read buffer until bad command
# response is found.
self._write('\xAB')
# Keep reading until bad command response (0xFA 0xAB) is returned.
# Fail if too many read attempts are made to prevent sticking in a loop.
tries = 0
sync = False
while not sync:
data = self._poll_read(2)
if data == '\xFA\xAB':
sync = True
tries += 1
if tries >= max_retries:
raise RuntimeError('Could not synchronize with FT232H!') | def _mpsse_sync(self, max_retries=10):
"""Synchronize buffers with MPSSE by sending bad opcode and reading expected
error response. Should be called once after enabling MPSSE."""
# Send a bad/unknown command (0xAB), then read buffer until bad command
# response is found.
self._write('\xAB')
# Keep reading until bad command response (0xFA 0xAB) is returned.
# Fail if too many read attempts are made to prevent sticking in a loop.
tries = 0
sync = False
while not sync:
data = self._poll_read(2)
if data == '\xFA\xAB':
sync = True
tries += 1
if tries >= max_retries:
raise RuntimeError('Could not synchronize with FT232H!') | [
"Synchronize",
"buffers",
"with",
"MPSSE",
"by",
"sending",
"bad",
"opcode",
"and",
"reading",
"expected",
"error",
"response",
".",
"Should",
"be",
"called",
"once",
"after",
"enabling",
"MPSSE",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L241-L257 | [
"def",
"_mpsse_sync",
"(",
"self",
",",
"max_retries",
"=",
"10",
")",
":",
"# Send a bad/unknown command (0xAB), then read buffer until bad command",
"# response is found.",
"self",
".",
"_write",
"(",
"'\\xAB'",
")",
"# Keep reading until bad command response (0xFA 0xAB) is returned.",
"# Fail if too many read attempts are made to prevent sticking in a loop.",
"tries",
"=",
"0",
"sync",
"=",
"False",
"while",
"not",
"sync",
":",
"data",
"=",
"self",
".",
"_poll_read",
"(",
"2",
")",
"if",
"data",
"==",
"'\\xFA\\xAB'",
":",
"sync",
"=",
"True",
"tries",
"+=",
"1",
"if",
"tries",
">=",
"max_retries",
":",
"raise",
"RuntimeError",
"(",
"'Could not synchronize with FT232H!'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.mpsse_set_clock | Set the clock speed of the MPSSE engine. Can be any value from 450hz
to 30mhz and will pick that speed or the closest speed below it. | Adafruit_GPIO/FT232H.py | def mpsse_set_clock(self, clock_hz, adaptive=False, three_phase=False):
"""Set the clock speed of the MPSSE engine. Can be any value from 450hz
to 30mhz and will pick that speed or the closest speed below it.
"""
# Disable clock divisor by 5 to enable faster speeds on FT232H.
self._write('\x8A')
# Turn on/off adaptive clocking.
if adaptive:
self._write('\x96')
else:
self._write('\x97')
# Turn on/off three phase clock (needed for I2C).
# Also adjust the frequency for three-phase clocking as specified in section 2.2.4
# of this document:
# http://www.ftdichip.com/Support/Documents/AppNotes/AN_255_USB%20to%20I2C%20Example%20using%20the%20FT232H%20and%20FT201X%20devices.pdf
if three_phase:
self._write('\x8C')
else:
self._write('\x8D')
# Compute divisor for requested clock.
# Use equation from section 3.8.1 of:
# http://www.ftdichip.com/Support/Documents/AppNotes/AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
# Note equation is using 60mhz master clock instead of 12mhz.
divisor = int(math.ceil((30000000.0-float(clock_hz))/float(clock_hz))) & 0xFFFF
if three_phase:
divisor = int(divisor*(2.0/3.0))
logger.debug('Setting clockspeed with divisor value {0}'.format(divisor))
# Send command to set divisor from low and high byte values.
self._write(str(bytearray((0x86, divisor & 0xFF, (divisor >> 8) & 0xFF)))) | def mpsse_set_clock(self, clock_hz, adaptive=False, three_phase=False):
"""Set the clock speed of the MPSSE engine. Can be any value from 450hz
to 30mhz and will pick that speed or the closest speed below it.
"""
# Disable clock divisor by 5 to enable faster speeds on FT232H.
self._write('\x8A')
# Turn on/off adaptive clocking.
if adaptive:
self._write('\x96')
else:
self._write('\x97')
# Turn on/off three phase clock (needed for I2C).
# Also adjust the frequency for three-phase clocking as specified in section 2.2.4
# of this document:
# http://www.ftdichip.com/Support/Documents/AppNotes/AN_255_USB%20to%20I2C%20Example%20using%20the%20FT232H%20and%20FT201X%20devices.pdf
if three_phase:
self._write('\x8C')
else:
self._write('\x8D')
# Compute divisor for requested clock.
# Use equation from section 3.8.1 of:
# http://www.ftdichip.com/Support/Documents/AppNotes/AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
# Note equation is using 60mhz master clock instead of 12mhz.
divisor = int(math.ceil((30000000.0-float(clock_hz))/float(clock_hz))) & 0xFFFF
if three_phase:
divisor = int(divisor*(2.0/3.0))
logger.debug('Setting clockspeed with divisor value {0}'.format(divisor))
# Send command to set divisor from low and high byte values.
self._write(str(bytearray((0x86, divisor & 0xFF, (divisor >> 8) & 0xFF)))) | [
"Set",
"the",
"clock",
"speed",
"of",
"the",
"MPSSE",
"engine",
".",
"Can",
"be",
"any",
"value",
"from",
"450hz",
"to",
"30mhz",
"and",
"will",
"pick",
"that",
"speed",
"or",
"the",
"closest",
"speed",
"below",
"it",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L259-L287 | [
"def",
"mpsse_set_clock",
"(",
"self",
",",
"clock_hz",
",",
"adaptive",
"=",
"False",
",",
"three_phase",
"=",
"False",
")",
":",
"# Disable clock divisor by 5 to enable faster speeds on FT232H.",
"self",
".",
"_write",
"(",
"'\\x8A'",
")",
"# Turn on/off adaptive clocking.",
"if",
"adaptive",
":",
"self",
".",
"_write",
"(",
"'\\x96'",
")",
"else",
":",
"self",
".",
"_write",
"(",
"'\\x97'",
")",
"# Turn on/off three phase clock (needed for I2C).",
"# Also adjust the frequency for three-phase clocking as specified in section 2.2.4",
"# of this document:",
"# http://www.ftdichip.com/Support/Documents/AppNotes/AN_255_USB%20to%20I2C%20Example%20using%20the%20FT232H%20and%20FT201X%20devices.pdf",
"if",
"three_phase",
":",
"self",
".",
"_write",
"(",
"'\\x8C'",
")",
"else",
":",
"self",
".",
"_write",
"(",
"'\\x8D'",
")",
"# Compute divisor for requested clock.",
"# Use equation from section 3.8.1 of:",
"# http://www.ftdichip.com/Support/Documents/AppNotes/AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf",
"# Note equation is using 60mhz master clock instead of 12mhz.",
"divisor",
"=",
"int",
"(",
"math",
".",
"ceil",
"(",
"(",
"30000000.0",
"-",
"float",
"(",
"clock_hz",
")",
")",
"/",
"float",
"(",
"clock_hz",
")",
")",
")",
"&",
"0xFFFF",
"if",
"three_phase",
":",
"divisor",
"=",
"int",
"(",
"divisor",
"*",
"(",
"2.0",
"/",
"3.0",
")",
")",
"logger",
".",
"debug",
"(",
"'Setting clockspeed with divisor value {0}'",
".",
"format",
"(",
"divisor",
")",
")",
"# Send command to set divisor from low and high byte values.",
"self",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"0x86",
",",
"divisor",
"&",
"0xFF",
",",
"(",
"divisor",
">>",
"8",
")",
"&",
"0xFF",
")",
")",
")",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.mpsse_read_gpio | Read both GPIO bus states and return a 16 bit value with their state.
D0-D7 are the lower 8 bits and C0-C7 are the upper 8 bits. | Adafruit_GPIO/FT232H.py | def mpsse_read_gpio(self):
"""Read both GPIO bus states and return a 16 bit value with their state.
D0-D7 are the lower 8 bits and C0-C7 are the upper 8 bits.
"""
# Send command to read low byte and high byte.
self._write('\x81\x83')
# Wait for 2 byte response.
data = self._poll_read(2)
# Assemble response into 16 bit value.
low_byte = ord(data[0])
high_byte = ord(data[1])
logger.debug('Read MPSSE GPIO low byte = {0:02X} and high byte = {1:02X}'.format(low_byte, high_byte))
return (high_byte << 8) | low_byte | def mpsse_read_gpio(self):
"""Read both GPIO bus states and return a 16 bit value with their state.
D0-D7 are the lower 8 bits and C0-C7 are the upper 8 bits.
"""
# Send command to read low byte and high byte.
self._write('\x81\x83')
# Wait for 2 byte response.
data = self._poll_read(2)
# Assemble response into 16 bit value.
low_byte = ord(data[0])
high_byte = ord(data[1])
logger.debug('Read MPSSE GPIO low byte = {0:02X} and high byte = {1:02X}'.format(low_byte, high_byte))
return (high_byte << 8) | low_byte | [
"Read",
"both",
"GPIO",
"bus",
"states",
"and",
"return",
"a",
"16",
"bit",
"value",
"with",
"their",
"state",
".",
"D0",
"-",
"D7",
"are",
"the",
"lower",
"8",
"bits",
"and",
"C0",
"-",
"C7",
"are",
"the",
"upper",
"8",
"bits",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L289-L301 | [
"def",
"mpsse_read_gpio",
"(",
"self",
")",
":",
"# Send command to read low byte and high byte.",
"self",
".",
"_write",
"(",
"'\\x81\\x83'",
")",
"# Wait for 2 byte response.",
"data",
"=",
"self",
".",
"_poll_read",
"(",
"2",
")",
"# Assemble response into 16 bit value.",
"low_byte",
"=",
"ord",
"(",
"data",
"[",
"0",
"]",
")",
"high_byte",
"=",
"ord",
"(",
"data",
"[",
"1",
"]",
")",
"logger",
".",
"debug",
"(",
"'Read MPSSE GPIO low byte = {0:02X} and high byte = {1:02X}'",
".",
"format",
"(",
"low_byte",
",",
"high_byte",
")",
")",
"return",
"(",
"high_byte",
"<<",
"8",
")",
"|",
"low_byte"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.mpsse_gpio | Return command to update the MPSSE GPIO state to the current direction
and level. | Adafruit_GPIO/FT232H.py | def mpsse_gpio(self):
"""Return command to update the MPSSE GPIO state to the current direction
and level.
"""
level_low = chr(self._level & 0xFF)
level_high = chr((self._level >> 8) & 0xFF)
dir_low = chr(self._direction & 0xFF)
dir_high = chr((self._direction >> 8) & 0xFF)
return str(bytearray((0x80, level_low, dir_low, 0x82, level_high, dir_high))) | def mpsse_gpio(self):
"""Return command to update the MPSSE GPIO state to the current direction
and level.
"""
level_low = chr(self._level & 0xFF)
level_high = chr((self._level >> 8) & 0xFF)
dir_low = chr(self._direction & 0xFF)
dir_high = chr((self._direction >> 8) & 0xFF)
return str(bytearray((0x80, level_low, dir_low, 0x82, level_high, dir_high))) | [
"Return",
"command",
"to",
"update",
"the",
"MPSSE",
"GPIO",
"state",
"to",
"the",
"current",
"direction",
"and",
"level",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L303-L311 | [
"def",
"mpsse_gpio",
"(",
"self",
")",
":",
"level_low",
"=",
"chr",
"(",
"self",
".",
"_level",
"&",
"0xFF",
")",
"level_high",
"=",
"chr",
"(",
"(",
"self",
".",
"_level",
">>",
"8",
")",
"&",
"0xFF",
")",
"dir_low",
"=",
"chr",
"(",
"self",
".",
"_direction",
"&",
"0xFF",
")",
"dir_high",
"=",
"chr",
"(",
"(",
"self",
".",
"_direction",
">>",
"8",
")",
"&",
"0xFF",
")",
"return",
"str",
"(",
"bytearray",
"(",
"(",
"0x80",
",",
"level_low",
",",
"dir_low",
",",
"0x82",
",",
"level_high",
",",
"dir_high",
")",
")",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.setup | Set the input or output mode for a specified pin. Mode should be
either OUT or IN. | Adafruit_GPIO/FT232H.py | def setup(self, pin, mode):
"""Set the input or output mode for a specified pin. Mode should be
either OUT or IN."""
self._setup_pin(pin, mode)
self.mpsse_write_gpio() | def setup(self, pin, mode):
"""Set the input or output mode for a specified pin. Mode should be
either OUT or IN."""
self._setup_pin(pin, mode)
self.mpsse_write_gpio() | [
"Set",
"the",
"input",
"or",
"output",
"mode",
"for",
"a",
"specified",
"pin",
".",
"Mode",
"should",
"be",
"either",
"OUT",
"or",
"IN",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L339-L343 | [
"def",
"setup",
"(",
"self",
",",
"pin",
",",
"mode",
")",
":",
"self",
".",
"_setup_pin",
"(",
"pin",
",",
"mode",
")",
"self",
".",
"mpsse_write_gpio",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.setup_pins | Setup multiple pins as inputs or outputs at once. Pins should be a
dict of pin name to pin mode (IN or OUT). Optional starting values of
pins can be provided in the values dict (with pin name to pin value). | Adafruit_GPIO/FT232H.py | def setup_pins(self, pins, values={}, write=True):
"""Setup multiple pins as inputs or outputs at once. Pins should be a
dict of pin name to pin mode (IN or OUT). Optional starting values of
pins can be provided in the values dict (with pin name to pin value).
"""
# General implementation that can be improved by subclasses.
for pin, mode in iter(pins.items()):
self._setup_pin(pin, mode)
for pin, value in iter(values.items()):
self._output_pin(pin, value)
if write:
self.mpsse_write_gpio() | def setup_pins(self, pins, values={}, write=True):
"""Setup multiple pins as inputs or outputs at once. Pins should be a
dict of pin name to pin mode (IN or OUT). Optional starting values of
pins can be provided in the values dict (with pin name to pin value).
"""
# General implementation that can be improved by subclasses.
for pin, mode in iter(pins.items()):
self._setup_pin(pin, mode)
for pin, value in iter(values.items()):
self._output_pin(pin, value)
if write:
self.mpsse_write_gpio() | [
"Setup",
"multiple",
"pins",
"as",
"inputs",
"or",
"outputs",
"at",
"once",
".",
"Pins",
"should",
"be",
"a",
"dict",
"of",
"pin",
"name",
"to",
"pin",
"mode",
"(",
"IN",
"or",
"OUT",
")",
".",
"Optional",
"starting",
"values",
"of",
"pins",
"can",
"be",
"provided",
"in",
"the",
"values",
"dict",
"(",
"with",
"pin",
"name",
"to",
"pin",
"value",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L345-L356 | [
"def",
"setup_pins",
"(",
"self",
",",
"pins",
",",
"values",
"=",
"{",
"}",
",",
"write",
"=",
"True",
")",
":",
"# General implementation that can be improved by subclasses.",
"for",
"pin",
",",
"mode",
"in",
"iter",
"(",
"pins",
".",
"items",
"(",
")",
")",
":",
"self",
".",
"_setup_pin",
"(",
"pin",
",",
"mode",
")",
"for",
"pin",
",",
"value",
"in",
"iter",
"(",
"values",
".",
"items",
"(",
")",
")",
":",
"self",
".",
"_output_pin",
"(",
"pin",
",",
"value",
")",
"if",
"write",
":",
"self",
".",
"mpsse_write_gpio",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.output | Set the specified pin the provided high/low value. Value should be
either HIGH/LOW or a boolean (true = high). | Adafruit_GPIO/FT232H.py | def output(self, pin, value):
"""Set the specified pin the provided high/low value. Value should be
either HIGH/LOW or a boolean (true = high)."""
if pin < 0 or pin > 15:
raise ValueError('Pin must be between 0 and 15 (inclusive).')
self._output_pin(pin, value)
self.mpsse_write_gpio() | def output(self, pin, value):
"""Set the specified pin the provided high/low value. Value should be
either HIGH/LOW or a boolean (true = high)."""
if pin < 0 or pin > 15:
raise ValueError('Pin must be between 0 and 15 (inclusive).')
self._output_pin(pin, value)
self.mpsse_write_gpio() | [
"Set",
"the",
"specified",
"pin",
"the",
"provided",
"high",
"/",
"low",
"value",
".",
"Value",
"should",
"be",
"either",
"HIGH",
"/",
"LOW",
"or",
"a",
"boolean",
"(",
"true",
"=",
"high",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L364-L370 | [
"def",
"output",
"(",
"self",
",",
"pin",
",",
"value",
")",
":",
"if",
"pin",
"<",
"0",
"or",
"pin",
">",
"15",
":",
"raise",
"ValueError",
"(",
"'Pin must be between 0 and 15 (inclusive).'",
")",
"self",
".",
"_output_pin",
"(",
"pin",
",",
"value",
")",
"self",
".",
"mpsse_write_gpio",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.output_pins | Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values. | Adafruit_GPIO/FT232H.py | def output_pins(self, pins, write=True):
"""Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values.
"""
for pin, value in iter(pins.items()):
self._output_pin(pin, value)
if write:
self.mpsse_write_gpio() | def output_pins(self, pins, write=True):
"""Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values.
"""
for pin, value in iter(pins.items()):
self._output_pin(pin, value)
if write:
self.mpsse_write_gpio() | [
"Set",
"multiple",
"pins",
"high",
"or",
"low",
"at",
"once",
".",
"Pins",
"should",
"be",
"a",
"dict",
"of",
"pin",
"name",
"to",
"pin",
"value",
"(",
"HIGH",
"/",
"True",
"for",
"1",
"LOW",
"/",
"False",
"for",
"0",
")",
".",
"All",
"provided",
"pins",
"will",
"be",
"set",
"to",
"the",
"given",
"values",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L372-L380 | [
"def",
"output_pins",
"(",
"self",
",",
"pins",
",",
"write",
"=",
"True",
")",
":",
"for",
"pin",
",",
"value",
"in",
"iter",
"(",
"pins",
".",
"items",
"(",
")",
")",
":",
"self",
".",
"_output_pin",
"(",
"pin",
",",
"value",
")",
"if",
"write",
":",
"self",
".",
"mpsse_write_gpio",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | FT232H.input_pins | Read multiple pins specified in the given list and return list of pin values
GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low. | Adafruit_GPIO/FT232H.py | def input_pins(self, pins):
"""Read multiple pins specified in the given list and return list of pin values
GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low."""
if [pin for pin in pins if pin < 0 or pin > 15]:
raise ValueError('Pin must be between 0 and 15 (inclusive).')
_pins = self.mpsse_read_gpio()
return [((_pins >> pin) & 0x0001) == 1 for pin in pins] | def input_pins(self, pins):
"""Read multiple pins specified in the given list and return list of pin values
GPIO.HIGH/True if the pin is pulled high, or GPIO.LOW/False if pulled low."""
if [pin for pin in pins if pin < 0 or pin > 15]:
raise ValueError('Pin must be between 0 and 15 (inclusive).')
_pins = self.mpsse_read_gpio()
return [((_pins >> pin) & 0x0001) == 1 for pin in pins] | [
"Read",
"multiple",
"pins",
"specified",
"in",
"the",
"given",
"list",
"and",
"return",
"list",
"of",
"pin",
"values",
"GPIO",
".",
"HIGH",
"/",
"True",
"if",
"the",
"pin",
"is",
"pulled",
"high",
"or",
"GPIO",
".",
"LOW",
"/",
"False",
"if",
"pulled",
"low",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L387-L393 | [
"def",
"input_pins",
"(",
"self",
",",
"pins",
")",
":",
"if",
"[",
"pin",
"for",
"pin",
"in",
"pins",
"if",
"pin",
"<",
"0",
"or",
"pin",
">",
"15",
"]",
":",
"raise",
"ValueError",
"(",
"'Pin must be between 0 and 15 (inclusive).'",
")",
"_pins",
"=",
"self",
".",
"mpsse_read_gpio",
"(",
")",
"return",
"[",
"(",
"(",
"_pins",
">>",
"pin",
")",
"&",
"0x0001",
")",
"==",
"1",
"for",
"pin",
"in",
"pins",
"]"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SPI.set_mode | Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus | Adafruit_GPIO/FT232H.py | def set_mode(self, mode):
"""Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
"""
if mode < 0 or mode > 3:
raise ValueError('Mode must be a value 0, 1, 2, or 3.')
if mode == 0:
# Mode 0 captures on rising clock, propagates on falling clock
self.write_clock_ve = 1
self.read_clock_ve = 0
# Clock base is low.
clock_base = GPIO.LOW
elif mode == 1:
# Mode 1 capture of falling edge, propagate on rising clock
self.write_clock_ve = 0
self.read_clock_ve = 1
# Clock base is low.
clock_base = GPIO.LOW
elif mode == 2:
# Mode 2 capture on rising clock, propagate on falling clock
self.write_clock_ve = 1
self.read_clock_ve = 0
# Clock base is high.
clock_base = GPIO.HIGH
elif mode == 3:
# Mode 3 capture on falling edge, propagage on rising clock
self.write_clock_ve = 0
self.read_clock_ve = 1
# Clock base is high.
clock_base = GPIO.HIGH
# Set clock and DO as output, DI as input. Also start clock at its base value.
self._ft232h.setup_pins({0: GPIO.OUT, 1: GPIO.OUT, 2: GPIO.IN}, {0: clock_base}) | def set_mode(self, mode):
"""Set SPI mode which controls clock polarity and phase. Should be a
numeric value 0, 1, 2, or 3. See wikipedia page for details on meaning:
http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
"""
if mode < 0 or mode > 3:
raise ValueError('Mode must be a value 0, 1, 2, or 3.')
if mode == 0:
# Mode 0 captures on rising clock, propagates on falling clock
self.write_clock_ve = 1
self.read_clock_ve = 0
# Clock base is low.
clock_base = GPIO.LOW
elif mode == 1:
# Mode 1 capture of falling edge, propagate on rising clock
self.write_clock_ve = 0
self.read_clock_ve = 1
# Clock base is low.
clock_base = GPIO.LOW
elif mode == 2:
# Mode 2 capture on rising clock, propagate on falling clock
self.write_clock_ve = 1
self.read_clock_ve = 0
# Clock base is high.
clock_base = GPIO.HIGH
elif mode == 3:
# Mode 3 capture on falling edge, propagage on rising clock
self.write_clock_ve = 0
self.read_clock_ve = 1
# Clock base is high.
clock_base = GPIO.HIGH
# Set clock and DO as output, DI as input. Also start clock at its base value.
self._ft232h.setup_pins({0: GPIO.OUT, 1: GPIO.OUT, 2: GPIO.IN}, {0: clock_base}) | [
"Set",
"SPI",
"mode",
"which",
"controls",
"clock",
"polarity",
"and",
"phase",
".",
"Should",
"be",
"a",
"numeric",
"value",
"0",
"1",
"2",
"or",
"3",
".",
"See",
"wikipedia",
"page",
"for",
"details",
"on",
"meaning",
":",
"http",
":",
"//",
"en",
".",
"wikipedia",
".",
"org",
"/",
"wiki",
"/",
"Serial_Peripheral_Interface_Bus"
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L423-L455 | [
"def",
"set_mode",
"(",
"self",
",",
"mode",
")",
":",
"if",
"mode",
"<",
"0",
"or",
"mode",
">",
"3",
":",
"raise",
"ValueError",
"(",
"'Mode must be a value 0, 1, 2, or 3.'",
")",
"if",
"mode",
"==",
"0",
":",
"# Mode 0 captures on rising clock, propagates on falling clock",
"self",
".",
"write_clock_ve",
"=",
"1",
"self",
".",
"read_clock_ve",
"=",
"0",
"# Clock base is low.",
"clock_base",
"=",
"GPIO",
".",
"LOW",
"elif",
"mode",
"==",
"1",
":",
"# Mode 1 capture of falling edge, propagate on rising clock",
"self",
".",
"write_clock_ve",
"=",
"0",
"self",
".",
"read_clock_ve",
"=",
"1",
"# Clock base is low.",
"clock_base",
"=",
"GPIO",
".",
"LOW",
"elif",
"mode",
"==",
"2",
":",
"# Mode 2 capture on rising clock, propagate on falling clock",
"self",
".",
"write_clock_ve",
"=",
"1",
"self",
".",
"read_clock_ve",
"=",
"0",
"# Clock base is high.",
"clock_base",
"=",
"GPIO",
".",
"HIGH",
"elif",
"mode",
"==",
"3",
":",
"# Mode 3 capture on falling edge, propagage on rising clock",
"self",
".",
"write_clock_ve",
"=",
"0",
"self",
".",
"read_clock_ve",
"=",
"1",
"# Clock base is high.",
"clock_base",
"=",
"GPIO",
".",
"HIGH",
"# Set clock and DO as output, DI as input. Also start clock at its base value.",
"self",
".",
"_ft232h",
".",
"setup_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"OUT",
",",
"1",
":",
"GPIO",
".",
"OUT",
",",
"2",
":",
"GPIO",
".",
"IN",
"}",
",",
"{",
"0",
":",
"clock_base",
"}",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SPI.set_bit_order | Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first. | Adafruit_GPIO/FT232H.py | def set_bit_order(self, order):
"""Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first.
"""
if order == MSBFIRST:
self.lsbfirst = 0
elif order == LSBFIRST:
self.lsbfirst = 1
else:
raise ValueError('Order must be MSBFIRST or LSBFIRST.') | def set_bit_order(self, order):
"""Set order of bits to be read/written over serial lines. Should be
either MSBFIRST for most-significant first, or LSBFIRST for
least-signifcant first.
"""
if order == MSBFIRST:
self.lsbfirst = 0
elif order == LSBFIRST:
self.lsbfirst = 1
else:
raise ValueError('Order must be MSBFIRST or LSBFIRST.') | [
"Set",
"order",
"of",
"bits",
"to",
"be",
"read",
"/",
"written",
"over",
"serial",
"lines",
".",
"Should",
"be",
"either",
"MSBFIRST",
"for",
"most",
"-",
"significant",
"first",
"or",
"LSBFIRST",
"for",
"least",
"-",
"signifcant",
"first",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L457-L467 | [
"def",
"set_bit_order",
"(",
"self",
",",
"order",
")",
":",
"if",
"order",
"==",
"MSBFIRST",
":",
"self",
".",
"lsbfirst",
"=",
"0",
"elif",
"order",
"==",
"LSBFIRST",
":",
"self",
".",
"lsbfirst",
"=",
"1",
"else",
":",
"raise",
"ValueError",
"(",
"'Order must be MSBFIRST or LSBFIRST.'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SPI.write | Half-duplex SPI write. The specified array of bytes will be clocked
out the MOSI line. | Adafruit_GPIO/FT232H.py | def write(self, data):
"""Half-duplex SPI write. The specified array of bytes will be clocked
out the MOSI line.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (len(data) > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
# Build command to write SPI data.
command = 0x10 | (self.lsbfirst << 3) | self.write_clock_ve
logger.debug('SPI write with command {0:2X}.'.format(command))
# Compute length low and high bytes.
# NOTE: Must actually send length minus one because the MPSSE engine
# considers 0 a length of 1 and FFFF a length of 65536
# splitting into two lists for two commands to prevent buffer errors
data1 = data[:len(data)/2]
data2 = data[len(data)/2:]
len_low1 = (len(data1) - 1) & 0xFF
len_high1 = ((len(data1) - 1) >> 8) & 0xFF
len_low2 = (len(data2) - 1) & 0xFF
len_high2 = ((len(data2) - 1) >> 8) & 0xFF
self._assert_cs()
# Send command and length, then data, split into two commands, handle for length 1
if len(data1) > 0:
self._ft232h._write(str(bytearray((command, len_low1, len_high1))))
self._ft232h._write(str(bytearray(data1)))
if len(data2) > 0:
self._ft232h._write(str(bytearray((command, len_low2, len_high2))))
self._ft232h._write(str(bytearray(data2)))
self._deassert_cs() | def write(self, data):
"""Half-duplex SPI write. The specified array of bytes will be clocked
out the MOSI line.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (len(data) > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
# Build command to write SPI data.
command = 0x10 | (self.lsbfirst << 3) | self.write_clock_ve
logger.debug('SPI write with command {0:2X}.'.format(command))
# Compute length low and high bytes.
# NOTE: Must actually send length minus one because the MPSSE engine
# considers 0 a length of 1 and FFFF a length of 65536
# splitting into two lists for two commands to prevent buffer errors
data1 = data[:len(data)/2]
data2 = data[len(data)/2:]
len_low1 = (len(data1) - 1) & 0xFF
len_high1 = ((len(data1) - 1) >> 8) & 0xFF
len_low2 = (len(data2) - 1) & 0xFF
len_high2 = ((len(data2) - 1) >> 8) & 0xFF
self._assert_cs()
# Send command and length, then data, split into two commands, handle for length 1
if len(data1) > 0:
self._ft232h._write(str(bytearray((command, len_low1, len_high1))))
self._ft232h._write(str(bytearray(data1)))
if len(data2) > 0:
self._ft232h._write(str(bytearray((command, len_low2, len_high2))))
self._ft232h._write(str(bytearray(data2)))
self._deassert_cs() | [
"Half",
"-",
"duplex",
"SPI",
"write",
".",
"The",
"specified",
"array",
"of",
"bytes",
"will",
"be",
"clocked",
"out",
"the",
"MOSI",
"line",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L469-L499 | [
"def",
"write",
"(",
"self",
",",
"data",
")",
":",
"#check for hardware limit of FT232H and similar MPSSE chips",
"if",
"(",
"len",
"(",
"data",
")",
">",
"65536",
")",
":",
"print",
"(",
"'the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!'",
")",
"print",
"(",
"'use for loops for larger reads'",
")",
"exit",
"(",
"1",
")",
"# Build command to write SPI data.",
"command",
"=",
"0x10",
"|",
"(",
"self",
".",
"lsbfirst",
"<<",
"3",
")",
"|",
"self",
".",
"write_clock_ve",
"logger",
".",
"debug",
"(",
"'SPI write with command {0:2X}.'",
".",
"format",
"(",
"command",
")",
")",
"# Compute length low and high bytes.",
"# NOTE: Must actually send length minus one because the MPSSE engine",
"# considers 0 a length of 1 and FFFF a length of 65536",
"# splitting into two lists for two commands to prevent buffer errors",
"data1",
"=",
"data",
"[",
":",
"len",
"(",
"data",
")",
"/",
"2",
"]",
"data2",
"=",
"data",
"[",
"len",
"(",
"data",
")",
"/",
"2",
":",
"]",
"len_low1",
"=",
"(",
"len",
"(",
"data1",
")",
"-",
"1",
")",
"&",
"0xFF",
"len_high1",
"=",
"(",
"(",
"len",
"(",
"data1",
")",
"-",
"1",
")",
">>",
"8",
")",
"&",
"0xFF",
"len_low2",
"=",
"(",
"len",
"(",
"data2",
")",
"-",
"1",
")",
"&",
"0xFF",
"len_high2",
"=",
"(",
"(",
"len",
"(",
"data2",
")",
"-",
"1",
")",
">>",
"8",
")",
"&",
"0xFF",
"self",
".",
"_assert_cs",
"(",
")",
"# Send command and length, then data, split into two commands, handle for length 1",
"if",
"len",
"(",
"data1",
")",
">",
"0",
":",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"command",
",",
"len_low1",
",",
"len_high1",
")",
")",
")",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"data1",
")",
")",
")",
"if",
"len",
"(",
"data2",
")",
">",
"0",
":",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"command",
",",
"len_low2",
",",
"len_high2",
")",
")",
")",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"data2",
")",
")",
")",
"self",
".",
"_deassert_cs",
"(",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SPI.read | Half-duplex SPI read. The specified length of bytes will be clocked
in the MISO line and returned as a bytearray object. | Adafruit_GPIO/FT232H.py | def read(self, length):
"""Half-duplex SPI read. The specified length of bytes will be clocked
in the MISO line and returned as a bytearray object.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (1 > length > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
# Build command to read SPI data.
command = 0x20 | (self.lsbfirst << 3) | (self.read_clock_ve << 2)
logger.debug('SPI read with command {0:2X}.'.format(command))
# Compute length low and high bytes.
# NOTE: Must actually send length minus one because the MPSSE engine
# considers 0 a length of 1 and FFFF a length of 65536
#force odd numbers to round up instead of down
lengthR = length
if length % 2 == 1:
lengthR += 1
lengthR = lengthR/2
#when odd length requested, get the remainder instead of the same number
lenremain = length - lengthR
len_low = (lengthR - 1) & 0xFF
len_high = ((lengthR - 1) >> 8) & 0xFF
self._assert_cs()
# Send command and length.
# Perform twice to prevent error from hardware defect/limits
self._ft232h._write(str(bytearray((command, len_low, len_high))))
payload1 = self._ft232h._poll_read(lengthR)
self._ft232h._write(str(bytearray((command, len_low, len_high))))
payload2 = self._ft232h._poll_read(lenremain)
self._deassert_cs()
# Read response bytes
return bytearray(payload1 + payload2) | def read(self, length):
"""Half-duplex SPI read. The specified length of bytes will be clocked
in the MISO line and returned as a bytearray object.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (1 > length > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
# Build command to read SPI data.
command = 0x20 | (self.lsbfirst << 3) | (self.read_clock_ve << 2)
logger.debug('SPI read with command {0:2X}.'.format(command))
# Compute length low and high bytes.
# NOTE: Must actually send length minus one because the MPSSE engine
# considers 0 a length of 1 and FFFF a length of 65536
#force odd numbers to round up instead of down
lengthR = length
if length % 2 == 1:
lengthR += 1
lengthR = lengthR/2
#when odd length requested, get the remainder instead of the same number
lenremain = length - lengthR
len_low = (lengthR - 1) & 0xFF
len_high = ((lengthR - 1) >> 8) & 0xFF
self._assert_cs()
# Send command and length.
# Perform twice to prevent error from hardware defect/limits
self._ft232h._write(str(bytearray((command, len_low, len_high))))
payload1 = self._ft232h._poll_read(lengthR)
self._ft232h._write(str(bytearray((command, len_low, len_high))))
payload2 = self._ft232h._poll_read(lenremain)
self._deassert_cs()
# Read response bytes
return bytearray(payload1 + payload2) | [
"Half",
"-",
"duplex",
"SPI",
"read",
".",
"The",
"specified",
"length",
"of",
"bytes",
"will",
"be",
"clocked",
"in",
"the",
"MISO",
"line",
"and",
"returned",
"as",
"a",
"bytearray",
"object",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L501-L534 | [
"def",
"read",
"(",
"self",
",",
"length",
")",
":",
"#check for hardware limit of FT232H and similar MPSSE chips",
"if",
"(",
"1",
">",
"length",
">",
"65536",
")",
":",
"print",
"(",
"'the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!'",
")",
"print",
"(",
"'use for loops for larger reads'",
")",
"exit",
"(",
"1",
")",
"# Build command to read SPI data.",
"command",
"=",
"0x20",
"|",
"(",
"self",
".",
"lsbfirst",
"<<",
"3",
")",
"|",
"(",
"self",
".",
"read_clock_ve",
"<<",
"2",
")",
"logger",
".",
"debug",
"(",
"'SPI read with command {0:2X}.'",
".",
"format",
"(",
"command",
")",
")",
"# Compute length low and high bytes.",
"# NOTE: Must actually send length minus one because the MPSSE engine",
"# considers 0 a length of 1 and FFFF a length of 65536",
"#force odd numbers to round up instead of down",
"lengthR",
"=",
"length",
"if",
"length",
"%",
"2",
"==",
"1",
":",
"lengthR",
"+=",
"1",
"lengthR",
"=",
"lengthR",
"/",
"2",
"#when odd length requested, get the remainder instead of the same number",
"lenremain",
"=",
"length",
"-",
"lengthR",
"len_low",
"=",
"(",
"lengthR",
"-",
"1",
")",
"&",
"0xFF",
"len_high",
"=",
"(",
"(",
"lengthR",
"-",
"1",
")",
">>",
"8",
")",
"&",
"0xFF",
"self",
".",
"_assert_cs",
"(",
")",
"# Send command and length.",
"# Perform twice to prevent error from hardware defect/limits",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"command",
",",
"len_low",
",",
"len_high",
")",
")",
")",
")",
"payload1",
"=",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"lengthR",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"command",
",",
"len_low",
",",
"len_high",
")",
")",
")",
")",
"payload2",
"=",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"lenremain",
")",
"self",
".",
"_deassert_cs",
"(",
")",
"# Read response bytes",
"return",
"bytearray",
"(",
"payload1",
"+",
"payload2",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SPI.bulkread | Half-duplex SPI write then read. Send command and payload to slave as bytearray
then consequently read out response from the slave for length in bytes.
Designed for use with NOR or NAND flash chips, and possibly SD cards...etc...
Read command is cut in half and performed twice in series to prevent single byte errors.
Hardware limits per command are enforced before doing anything.
Read length is an optional argument, so that it can function similar to transfer
but still half-duplex.
For reading without writing, one can send a blank array or skip that argument. | Adafruit_GPIO/FT232H.py | def bulkread(self, data = [], lengthR = 'None', readmode = 1):
"""Half-duplex SPI write then read. Send command and payload to slave as bytearray
then consequently read out response from the slave for length in bytes.
Designed for use with NOR or NAND flash chips, and possibly SD cards...etc...
Read command is cut in half and performed twice in series to prevent single byte errors.
Hardware limits per command are enforced before doing anything.
Read length is an optional argument, so that it can function similar to transfer
but still half-duplex.
For reading without writing, one can send a blank array or skip that argument.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (1 > lengthR > 65536)|(len(data) > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
#default mode is to act like `transfer` but half-duplex
if (lengthR == 'None')&(readmode == 1):
lengthR = len(data)
#command parameters definition and math
#MPSSE engine sees length 0 as 1 byte, so - 1 lengths
commandW = 0x10 | (self.lsbfirst << 3) | self.write_clock_ve
lengthW = len(data) - 1
len_lowW = (lengthW) & 0xFF
len_highW = ((lengthW) >> 8) & 0xFF
commandR = 0x20 | (self.lsbfirst << 3) | (self.read_clock_ve << 2)
#force odd numbers to round up instead of down
length = lengthR
if lengthR % 2 == 1:
length += 1
length = length/2
#when odd length requested, get the remainder instead of the same number
lenremain = lengthR - length
len_lowR = (length - 1) & 0xFF
len_highR = ((length - 1) >> 8) & 0xFF
#logger debug info
logger.debug('SPI bulkread with write command {0:2X}.'.format(commandW))
logger.debug('and read command {0:2X}.'.format(commandR))
#begin command set
self._assert_cs()
#write command, these have to be separated due to TypeError
self._ft232h._write(str(bytearray((commandW, len_lowW, len_highW))))
self._ft232h._write(str(bytearray(data)))
#read command, which is divided into two commands
self._ft232h._write(str(bytearray((commandR, len_lowR, len_highR))))
payload1 = self._ft232h._poll_read(length)
self._ft232h._write(str(bytearray((commandR, len_lowR, len_highR))))
payload2 = self._ft232h._poll_read(lenremain)
self._deassert_cs()
#end command set
# Read response bytes
return bytearray(payload1 + payload2) | def bulkread(self, data = [], lengthR = 'None', readmode = 1):
"""Half-duplex SPI write then read. Send command and payload to slave as bytearray
then consequently read out response from the slave for length in bytes.
Designed for use with NOR or NAND flash chips, and possibly SD cards...etc...
Read command is cut in half and performed twice in series to prevent single byte errors.
Hardware limits per command are enforced before doing anything.
Read length is an optional argument, so that it can function similar to transfer
but still half-duplex.
For reading without writing, one can send a blank array or skip that argument.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (1 > lengthR > 65536)|(len(data) > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
#default mode is to act like `transfer` but half-duplex
if (lengthR == 'None')&(readmode == 1):
lengthR = len(data)
#command parameters definition and math
#MPSSE engine sees length 0 as 1 byte, so - 1 lengths
commandW = 0x10 | (self.lsbfirst << 3) | self.write_clock_ve
lengthW = len(data) - 1
len_lowW = (lengthW) & 0xFF
len_highW = ((lengthW) >> 8) & 0xFF
commandR = 0x20 | (self.lsbfirst << 3) | (self.read_clock_ve << 2)
#force odd numbers to round up instead of down
length = lengthR
if lengthR % 2 == 1:
length += 1
length = length/2
#when odd length requested, get the remainder instead of the same number
lenremain = lengthR - length
len_lowR = (length - 1) & 0xFF
len_highR = ((length - 1) >> 8) & 0xFF
#logger debug info
logger.debug('SPI bulkread with write command {0:2X}.'.format(commandW))
logger.debug('and read command {0:2X}.'.format(commandR))
#begin command set
self._assert_cs()
#write command, these have to be separated due to TypeError
self._ft232h._write(str(bytearray((commandW, len_lowW, len_highW))))
self._ft232h._write(str(bytearray(data)))
#read command, which is divided into two commands
self._ft232h._write(str(bytearray((commandR, len_lowR, len_highR))))
payload1 = self._ft232h._poll_read(length)
self._ft232h._write(str(bytearray((commandR, len_lowR, len_highR))))
payload2 = self._ft232h._poll_read(lenremain)
self._deassert_cs()
#end command set
# Read response bytes
return bytearray(payload1 + payload2) | [
"Half",
"-",
"duplex",
"SPI",
"write",
"then",
"read",
".",
"Send",
"command",
"and",
"payload",
"to",
"slave",
"as",
"bytearray",
"then",
"consequently",
"read",
"out",
"response",
"from",
"the",
"slave",
"for",
"length",
"in",
"bytes",
".",
"Designed",
"for",
"use",
"with",
"NOR",
"or",
"NAND",
"flash",
"chips",
"and",
"possibly",
"SD",
"cards",
"...",
"etc",
"...",
"Read",
"command",
"is",
"cut",
"in",
"half",
"and",
"performed",
"twice",
"in",
"series",
"to",
"prevent",
"single",
"byte",
"errors",
".",
"Hardware",
"limits",
"per",
"command",
"are",
"enforced",
"before",
"doing",
"anything",
".",
"Read",
"length",
"is",
"an",
"optional",
"argument",
"so",
"that",
"it",
"can",
"function",
"similar",
"to",
"transfer",
"but",
"still",
"half",
"-",
"duplex",
".",
"For",
"reading",
"without",
"writing",
"one",
"can",
"send",
"a",
"blank",
"array",
"or",
"skip",
"that",
"argument",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L536-L586 | [
"def",
"bulkread",
"(",
"self",
",",
"data",
"=",
"[",
"]",
",",
"lengthR",
"=",
"'None'",
",",
"readmode",
"=",
"1",
")",
":",
"#check for hardware limit of FT232H and similar MPSSE chips",
"if",
"(",
"1",
">",
"lengthR",
">",
"65536",
")",
"|",
"(",
"len",
"(",
"data",
")",
">",
"65536",
")",
":",
"print",
"(",
"'the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!'",
")",
"print",
"(",
"'use for loops for larger reads'",
")",
"exit",
"(",
"1",
")",
"#default mode is to act like `transfer` but half-duplex",
"if",
"(",
"lengthR",
"==",
"'None'",
")",
"&",
"(",
"readmode",
"==",
"1",
")",
":",
"lengthR",
"=",
"len",
"(",
"data",
")",
"#command parameters definition and math",
"#MPSSE engine sees length 0 as 1 byte, so - 1 lengths",
"commandW",
"=",
"0x10",
"|",
"(",
"self",
".",
"lsbfirst",
"<<",
"3",
")",
"|",
"self",
".",
"write_clock_ve",
"lengthW",
"=",
"len",
"(",
"data",
")",
"-",
"1",
"len_lowW",
"=",
"(",
"lengthW",
")",
"&",
"0xFF",
"len_highW",
"=",
"(",
"(",
"lengthW",
")",
">>",
"8",
")",
"&",
"0xFF",
"commandR",
"=",
"0x20",
"|",
"(",
"self",
".",
"lsbfirst",
"<<",
"3",
")",
"|",
"(",
"self",
".",
"read_clock_ve",
"<<",
"2",
")",
"#force odd numbers to round up instead of down",
"length",
"=",
"lengthR",
"if",
"lengthR",
"%",
"2",
"==",
"1",
":",
"length",
"+=",
"1",
"length",
"=",
"length",
"/",
"2",
"#when odd length requested, get the remainder instead of the same number",
"lenremain",
"=",
"lengthR",
"-",
"length",
"len_lowR",
"=",
"(",
"length",
"-",
"1",
")",
"&",
"0xFF",
"len_highR",
"=",
"(",
"(",
"length",
"-",
"1",
")",
">>",
"8",
")",
"&",
"0xFF",
"#logger debug info",
"logger",
".",
"debug",
"(",
"'SPI bulkread with write command {0:2X}.'",
".",
"format",
"(",
"commandW",
")",
")",
"logger",
".",
"debug",
"(",
"'and read command {0:2X}.'",
".",
"format",
"(",
"commandR",
")",
")",
"#begin command set",
"self",
".",
"_assert_cs",
"(",
")",
"#write command, these have to be separated due to TypeError",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"commandW",
",",
"len_lowW",
",",
"len_highW",
")",
")",
")",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"data",
")",
")",
")",
"#read command, which is divided into two commands",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"commandR",
",",
"len_lowR",
",",
"len_highR",
")",
")",
")",
")",
"payload1",
"=",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"length",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"commandR",
",",
"len_lowR",
",",
"len_highR",
")",
")",
")",
")",
"payload2",
"=",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"lenremain",
")",
"self",
".",
"_deassert_cs",
"(",
")",
"#end command set",
"# Read response bytes",
"return",
"bytearray",
"(",
"payload1",
"+",
"payload2",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | SPI.transfer | Full-duplex SPI read and write. The specified array of bytes will be
clocked out the MOSI line, while simultaneously bytes will be read from
the MISO line. Read bytes will be returned as a bytearray object. | Adafruit_GPIO/FT232H.py | def transfer(self, data):
"""Full-duplex SPI read and write. The specified array of bytes will be
clocked out the MOSI line, while simultaneously bytes will be read from
the MISO line. Read bytes will be returned as a bytearray object.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (len(data) > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
# Build command to read and write SPI data.
command = 0x30 | (self.lsbfirst << 3) | (self.read_clock_ve << 2) | self.write_clock_ve
logger.debug('SPI transfer with command {0:2X}.'.format(command))
# Compute length low and high bytes.
# NOTE: Must actually send length minus one because the MPSSE engine
# considers 0 a length of 1 and FFFF a length of 65536
data1 = data[:len(data)/2]
data2 = data[len(data)/2:]
len_low1 = (len(data1) - 1) & 0xFF
len_high1 = ((len(data1) - 1) >> 8) & 0xFF
len_low2 = (len(data2) - 1) & 0xFF
len_high2 = ((len(data2) - 1) >> 8) & 0xFF
payload1 = ''
payload2 = ''
#start command set
self._assert_cs()
# Perform twice to prevent error from hardware defect/limits
# Send command and length, then data, split into two commands, handle for length 1
if len(data1) > 0:
self._ft232h._write(str(bytearray((command, len_low1, len_high1))))
self._ft232h._write(str(bytearray(data1)))
payload1 = self._ft232h._poll_read(len(data1))
if len(data2) > 0:
self._ft232h._write(str(bytearray((command, len_low2, len_high2))))
self._ft232h._write(str(bytearray(data2)))
payload2 = self._ft232h._poll_read(len(data2))
#self._ft232h._write('\x87')
self._deassert_cs()
# Read response bytes.
return bytearray(payload1 + payload2) | def transfer(self, data):
"""Full-duplex SPI read and write. The specified array of bytes will be
clocked out the MOSI line, while simultaneously bytes will be read from
the MISO line. Read bytes will be returned as a bytearray object.
"""
#check for hardware limit of FT232H and similar MPSSE chips
if (len(data) > 65536):
print('the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!')
print('use for loops for larger reads')
exit(1)
# Build command to read and write SPI data.
command = 0x30 | (self.lsbfirst << 3) | (self.read_clock_ve << 2) | self.write_clock_ve
logger.debug('SPI transfer with command {0:2X}.'.format(command))
# Compute length low and high bytes.
# NOTE: Must actually send length minus one because the MPSSE engine
# considers 0 a length of 1 and FFFF a length of 65536
data1 = data[:len(data)/2]
data2 = data[len(data)/2:]
len_low1 = (len(data1) - 1) & 0xFF
len_high1 = ((len(data1) - 1) >> 8) & 0xFF
len_low2 = (len(data2) - 1) & 0xFF
len_high2 = ((len(data2) - 1) >> 8) & 0xFF
payload1 = ''
payload2 = ''
#start command set
self._assert_cs()
# Perform twice to prevent error from hardware defect/limits
# Send command and length, then data, split into two commands, handle for length 1
if len(data1) > 0:
self._ft232h._write(str(bytearray((command, len_low1, len_high1))))
self._ft232h._write(str(bytearray(data1)))
payload1 = self._ft232h._poll_read(len(data1))
if len(data2) > 0:
self._ft232h._write(str(bytearray((command, len_low2, len_high2))))
self._ft232h._write(str(bytearray(data2)))
payload2 = self._ft232h._poll_read(len(data2))
#self._ft232h._write('\x87')
self._deassert_cs()
# Read response bytes.
return bytearray(payload1 + payload2) | [
"Full",
"-",
"duplex",
"SPI",
"read",
"and",
"write",
".",
"The",
"specified",
"array",
"of",
"bytes",
"will",
"be",
"clocked",
"out",
"the",
"MOSI",
"line",
"while",
"simultaneously",
"bytes",
"will",
"be",
"read",
"from",
"the",
"MISO",
"line",
".",
"Read",
"bytes",
"will",
"be",
"returned",
"as",
"a",
"bytearray",
"object",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L588-L627 | [
"def",
"transfer",
"(",
"self",
",",
"data",
")",
":",
"#check for hardware limit of FT232H and similar MPSSE chips",
"if",
"(",
"len",
"(",
"data",
")",
">",
"65536",
")",
":",
"print",
"(",
"'the FTDI chip is limited to 65536 bytes (64 KB) of input/output per command!'",
")",
"print",
"(",
"'use for loops for larger reads'",
")",
"exit",
"(",
"1",
")",
"# Build command to read and write SPI data.",
"command",
"=",
"0x30",
"|",
"(",
"self",
".",
"lsbfirst",
"<<",
"3",
")",
"|",
"(",
"self",
".",
"read_clock_ve",
"<<",
"2",
")",
"|",
"self",
".",
"write_clock_ve",
"logger",
".",
"debug",
"(",
"'SPI transfer with command {0:2X}.'",
".",
"format",
"(",
"command",
")",
")",
"# Compute length low and high bytes.",
"# NOTE: Must actually send length minus one because the MPSSE engine",
"# considers 0 a length of 1 and FFFF a length of 65536",
"data1",
"=",
"data",
"[",
":",
"len",
"(",
"data",
")",
"/",
"2",
"]",
"data2",
"=",
"data",
"[",
"len",
"(",
"data",
")",
"/",
"2",
":",
"]",
"len_low1",
"=",
"(",
"len",
"(",
"data1",
")",
"-",
"1",
")",
"&",
"0xFF",
"len_high1",
"=",
"(",
"(",
"len",
"(",
"data1",
")",
"-",
"1",
")",
">>",
"8",
")",
"&",
"0xFF",
"len_low2",
"=",
"(",
"len",
"(",
"data2",
")",
"-",
"1",
")",
"&",
"0xFF",
"len_high2",
"=",
"(",
"(",
"len",
"(",
"data2",
")",
"-",
"1",
")",
">>",
"8",
")",
"&",
"0xFF",
"payload1",
"=",
"''",
"payload2",
"=",
"''",
"#start command set",
"self",
".",
"_assert_cs",
"(",
")",
"# Perform twice to prevent error from hardware defect/limits",
"# Send command and length, then data, split into two commands, handle for length 1",
"if",
"len",
"(",
"data1",
")",
">",
"0",
":",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"command",
",",
"len_low1",
",",
"len_high1",
")",
")",
")",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"data1",
")",
")",
")",
"payload1",
"=",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"len",
"(",
"data1",
")",
")",
"if",
"len",
"(",
"data2",
")",
">",
"0",
":",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"command",
",",
"len_low2",
",",
"len_high2",
")",
")",
")",
")",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"str",
"(",
"bytearray",
"(",
"data2",
")",
")",
")",
"payload2",
"=",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"len",
"(",
"data2",
")",
")",
"#self._ft232h._write('\\x87')",
"self",
".",
"_deassert_cs",
"(",
")",
"# Read response bytes.",
"return",
"bytearray",
"(",
"payload1",
"+",
"payload2",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._idle | Put I2C lines into idle state. | Adafruit_GPIO/FT232H.py | def _idle(self):
"""Put I2C lines into idle state."""
# Put the I2C lines into an idle state with SCL and SDA high.
self._ft232h.setup_pins({0: GPIO.OUT, 1: GPIO.OUT, 2: GPIO.IN},
{0: GPIO.HIGH, 1: GPIO.HIGH}) | def _idle(self):
"""Put I2C lines into idle state."""
# Put the I2C lines into an idle state with SCL and SDA high.
self._ft232h.setup_pins({0: GPIO.OUT, 1: GPIO.OUT, 2: GPIO.IN},
{0: GPIO.HIGH, 1: GPIO.HIGH}) | [
"Put",
"I2C",
"lines",
"into",
"idle",
"state",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L648-L652 | [
"def",
"_idle",
"(",
"self",
")",
":",
"# Put the I2C lines into an idle state with SCL and SDA high.",
"self",
".",
"_ft232h",
".",
"setup_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"OUT",
",",
"1",
":",
"GPIO",
".",
"OUT",
",",
"2",
":",
"GPIO",
".",
"IN",
"}",
",",
"{",
"0",
":",
"GPIO",
".",
"HIGH",
",",
"1",
":",
"GPIO",
".",
"HIGH",
"}",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._transaction_end | End I2C transaction and get response bytes, including ACKs. | Adafruit_GPIO/FT232H.py | def _transaction_end(self):
"""End I2C transaction and get response bytes, including ACKs."""
# Ask to return response bytes immediately.
self._command.append('\x87')
# Send the entire command to the MPSSE.
self._ft232h._write(''.join(self._command))
# Read response bytes and return them.
return bytearray(self._ft232h._poll_read(self._expected)) | def _transaction_end(self):
"""End I2C transaction and get response bytes, including ACKs."""
# Ask to return response bytes immediately.
self._command.append('\x87')
# Send the entire command to the MPSSE.
self._ft232h._write(''.join(self._command))
# Read response bytes and return them.
return bytearray(self._ft232h._poll_read(self._expected)) | [
"End",
"I2C",
"transaction",
"and",
"get",
"response",
"bytes",
"including",
"ACKs",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L660-L667 | [
"def",
"_transaction_end",
"(",
"self",
")",
":",
"# Ask to return response bytes immediately.",
"self",
".",
"_command",
".",
"append",
"(",
"'\\x87'",
")",
"# Send the entire command to the MPSSE.",
"self",
".",
"_ft232h",
".",
"_write",
"(",
"''",
".",
"join",
"(",
"self",
".",
"_command",
")",
")",
"# Read response bytes and return them.",
"return",
"bytearray",
"(",
"self",
".",
"_ft232h",
".",
"_poll_read",
"(",
"self",
".",
"_expected",
")",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._i2c_start | Send I2C start signal. Must be called within a transaction start/end. | Adafruit_GPIO/FT232H.py | def _i2c_start(self):
"""Send I2C start signal. Must be called within a transaction start/end.
"""
# Set SCL high and SDA low, repeat 4 times to stay in this state for a
# short period of time.
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Now drop SCL to low (again repeat 4 times for short delay).
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY) | def _i2c_start(self):
"""Send I2C start signal. Must be called within a transaction start/end.
"""
# Set SCL high and SDA low, repeat 4 times to stay in this state for a
# short period of time.
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Now drop SCL to low (again repeat 4 times for short delay).
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY) | [
"Send",
"I2C",
"start",
"signal",
".",
"Must",
"be",
"called",
"within",
"a",
"transaction",
"start",
"/",
"end",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L669-L678 | [
"def",
"_i2c_start",
"(",
"self",
")",
":",
"# Set SCL high and SDA low, repeat 4 times to stay in this state for a",
"# short period of time.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"HIGH",
",",
"1",
":",
"GPIO",
".",
"LOW",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")",
"# Now drop SCL to low (again repeat 4 times for short delay).",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"LOW",
",",
"1",
":",
"GPIO",
".",
"LOW",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._i2c_idle | Set I2C signals to idle state with SCL and SDA at a high value. Must
be called within a transaction start/end. | Adafruit_GPIO/FT232H.py | def _i2c_idle(self):
"""Set I2C signals to idle state with SCL and SDA at a high value. Must
be called within a transaction start/end.
"""
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY) | def _i2c_idle(self):
"""Set I2C signals to idle state with SCL and SDA at a high value. Must
be called within a transaction start/end.
"""
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY) | [
"Set",
"I2C",
"signals",
"to",
"idle",
"state",
"with",
"SCL",
"and",
"SDA",
"at",
"a",
"high",
"value",
".",
"Must",
"be",
"called",
"within",
"a",
"transaction",
"start",
"/",
"end",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L680-L685 | [
"def",
"_i2c_idle",
"(",
"self",
")",
":",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"HIGH",
",",
"1",
":",
"GPIO",
".",
"HIGH",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._i2c_stop | Send I2C stop signal. Must be called within a transaction start/end. | Adafruit_GPIO/FT232H.py | def _i2c_stop(self):
"""Send I2C stop signal. Must be called within a transaction start/end.
"""
# Set SCL low and SDA low for a short period.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Set SCL high and SDA low for a short period.
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Finally set SCL high and SDA high for a short period.
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY) | def _i2c_stop(self):
"""Send I2C stop signal. Must be called within a transaction start/end.
"""
# Set SCL low and SDA low for a short period.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Set SCL high and SDA low for a short period.
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.LOW}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Finally set SCL high and SDA high for a short period.
self._ft232h.output_pins({0: GPIO.HIGH, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY) | [
"Send",
"I2C",
"stop",
"signal",
".",
"Must",
"be",
"called",
"within",
"a",
"transaction",
"start",
"/",
"end",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L687-L698 | [
"def",
"_i2c_stop",
"(",
"self",
")",
":",
"# Set SCL low and SDA low for a short period.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"LOW",
",",
"1",
":",
"GPIO",
".",
"LOW",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")",
"# Set SCL high and SDA low for a short period.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"HIGH",
",",
"1",
":",
"GPIO",
".",
"LOW",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")",
"# Finally set SCL high and SDA high for a short period.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"HIGH",
",",
"1",
":",
"GPIO",
".",
"HIGH",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._i2c_read_bytes | Read the specified number of bytes from the I2C bus. Length is the
number of bytes to read (must be 1 or more). | Adafruit_GPIO/FT232H.py | def _i2c_read_bytes(self, length=1):
"""Read the specified number of bytes from the I2C bus. Length is the
number of bytes to read (must be 1 or more).
"""
for i in range(length-1):
# Read a byte and send ACK.
self._command.append('\x20\x00\x00\x13\x00\x00')
# Make sure pins are back in idle state with clock low and data high.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio())
# Read last byte and send NAK.
self._command.append('\x20\x00\x00\x13\x00\xFF')
# Make sure pins are back in idle state with clock low and data high.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio())
# Increase expected number of bytes.
self._expected += length | def _i2c_read_bytes(self, length=1):
"""Read the specified number of bytes from the I2C bus. Length is the
number of bytes to read (must be 1 or more).
"""
for i in range(length-1):
# Read a byte and send ACK.
self._command.append('\x20\x00\x00\x13\x00\x00')
# Make sure pins are back in idle state with clock low and data high.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio())
# Read last byte and send NAK.
self._command.append('\x20\x00\x00\x13\x00\xFF')
# Make sure pins are back in idle state with clock low and data high.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio())
# Increase expected number of bytes.
self._expected += length | [
"Read",
"the",
"specified",
"number",
"of",
"bytes",
"from",
"the",
"I2C",
"bus",
".",
"Length",
"is",
"the",
"number",
"of",
"bytes",
"to",
"read",
"(",
"must",
"be",
"1",
"or",
"more",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L700-L716 | [
"def",
"_i2c_read_bytes",
"(",
"self",
",",
"length",
"=",
"1",
")",
":",
"for",
"i",
"in",
"range",
"(",
"length",
"-",
"1",
")",
":",
"# Read a byte and send ACK.",
"self",
".",
"_command",
".",
"append",
"(",
"'\\x20\\x00\\x00\\x13\\x00\\x00'",
")",
"# Make sure pins are back in idle state with clock low and data high.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"LOW",
",",
"1",
":",
"GPIO",
".",
"HIGH",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
")",
"# Read last byte and send NAK.",
"self",
".",
"_command",
".",
"append",
"(",
"'\\x20\\x00\\x00\\x13\\x00\\xFF'",
")",
"# Make sure pins are back in idle state with clock low and data high.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"LOW",
",",
"1",
":",
"GPIO",
".",
"HIGH",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
")",
"# Increase expected number of bytes.",
"self",
".",
"_expected",
"+=",
"length"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice._i2c_write_bytes | Write the specified number of bytes to the chip. | Adafruit_GPIO/FT232H.py | def _i2c_write_bytes(self, data):
"""Write the specified number of bytes to the chip."""
for byte in data:
# Write byte.
self._command.append(str(bytearray((0x11, 0x00, 0x00, byte))))
# Make sure pins are back in idle state with clock low and data high.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Read bit for ACK/NAK.
self._command.append('\x22\x00')
# Increase expected response bytes.
self._expected += len(data) | def _i2c_write_bytes(self, data):
"""Write the specified number of bytes to the chip."""
for byte in data:
# Write byte.
self._command.append(str(bytearray((0x11, 0x00, 0x00, byte))))
# Make sure pins are back in idle state with clock low and data high.
self._ft232h.output_pins({0: GPIO.LOW, 1: GPIO.HIGH}, write=False)
self._command.append(self._ft232h.mpsse_gpio() * _REPEAT_DELAY)
# Read bit for ACK/NAK.
self._command.append('\x22\x00')
# Increase expected response bytes.
self._expected += len(data) | [
"Write",
"the",
"specified",
"number",
"of",
"bytes",
"to",
"the",
"chip",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L718-L729 | [
"def",
"_i2c_write_bytes",
"(",
"self",
",",
"data",
")",
":",
"for",
"byte",
"in",
"data",
":",
"# Write byte.",
"self",
".",
"_command",
".",
"append",
"(",
"str",
"(",
"bytearray",
"(",
"(",
"0x11",
",",
"0x00",
",",
"0x00",
",",
"byte",
")",
")",
")",
")",
"# Make sure pins are back in idle state with clock low and data high.",
"self",
".",
"_ft232h",
".",
"output_pins",
"(",
"{",
"0",
":",
"GPIO",
".",
"LOW",
",",
"1",
":",
"GPIO",
".",
"HIGH",
"}",
",",
"write",
"=",
"False",
")",
"self",
".",
"_command",
".",
"append",
"(",
"self",
".",
"_ft232h",
".",
"mpsse_gpio",
"(",
")",
"*",
"_REPEAT_DELAY",
")",
"# Read bit for ACK/NAK.",
"self",
".",
"_command",
".",
"append",
"(",
"'\\x22\\x00'",
")",
"# Increase expected response bytes.",
"self",
".",
"_expected",
"+=",
"len",
"(",
"data",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.ping | Attempt to detect if a device at this address is present on the I2C
bus. Will send out the device's address for writing and verify an ACK
is received. Returns true if the ACK is received, and false if not. | Adafruit_GPIO/FT232H.py | def ping(self):
"""Attempt to detect if a device at this address is present on the I2C
bus. Will send out the device's address for writing and verify an ACK
is received. Returns true if the ACK is received, and false if not.
"""
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False)])
self._i2c_stop()
response = self._transaction_end()
if len(response) != 1:
raise RuntimeError('Expected 1 response byte but received {0} byte(s).'.format(len(response)))
return ((response[0] & 0x01) == 0x00) | def ping(self):
"""Attempt to detect if a device at this address is present on the I2C
bus. Will send out the device's address for writing and verify an ACK
is received. Returns true if the ACK is received, and false if not.
"""
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False)])
self._i2c_stop()
response = self._transaction_end()
if len(response) != 1:
raise RuntimeError('Expected 1 response byte but received {0} byte(s).'.format(len(response)))
return ((response[0] & 0x01) == 0x00) | [
"Attempt",
"to",
"detect",
"if",
"a",
"device",
"at",
"this",
"address",
"is",
"present",
"on",
"the",
"I2C",
"bus",
".",
"Will",
"send",
"out",
"the",
"device",
"s",
"address",
"for",
"writing",
"and",
"verify",
"an",
"ACK",
"is",
"received",
".",
"Returns",
"true",
"if",
"the",
"ACK",
"is",
"received",
"and",
"false",
"if",
"not",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L748-L761 | [
"def",
"ping",
"(",
"self",
")",
":",
"self",
".",
"_idle",
"(",
")",
"self",
".",
"_transaction_start",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"False",
")",
"]",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"response",
"=",
"self",
".",
"_transaction_end",
"(",
")",
"if",
"len",
"(",
"response",
")",
"!=",
"1",
":",
"raise",
"RuntimeError",
"(",
"'Expected 1 response byte but received {0} byte(s).'",
".",
"format",
"(",
"len",
"(",
"response",
")",
")",
")",
"return",
"(",
"(",
"response",
"[",
"0",
"]",
"&",
"0x01",
")",
"==",
"0x00",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.writeRaw8 | Write an 8-bit value on the bus (without register). | Adafruit_GPIO/FT232H.py | def writeRaw8(self, value):
"""Write an 8-bit value on the bus (without register)."""
value = value & 0xFF
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False), value])
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response) | def writeRaw8(self, value):
"""Write an 8-bit value on the bus (without register)."""
value = value & 0xFF
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False), value])
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response) | [
"Write",
"an",
"8",
"-",
"bit",
"value",
"on",
"the",
"bus",
"(",
"without",
"register",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L763-L772 | [
"def",
"writeRaw8",
"(",
"self",
",",
"value",
")",
":",
"value",
"=",
"value",
"&",
"0xFF",
"self",
".",
"_idle",
"(",
")",
"self",
".",
"_transaction_start",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"False",
")",
",",
"value",
"]",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"response",
"=",
"self",
".",
"_transaction_end",
"(",
")",
"self",
".",
"_verify_acks",
"(",
"response",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.write16 | Write a 16-bit value to the specified register. | Adafruit_GPIO/FT232H.py | def write16(self, register, value, little_endian=True):
"""Write a 16-bit value to the specified register."""
value = value & 0xFFFF
value_low = value & 0xFF
value_high = (value >> 8) & 0xFF
if not little_endian:
value_low, value_high = value_high, value_low
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False), register, value_low,
value_high])
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response) | def write16(self, register, value, little_endian=True):
"""Write a 16-bit value to the specified register."""
value = value & 0xFFFF
value_low = value & 0xFF
value_high = (value >> 8) & 0xFF
if not little_endian:
value_low, value_high = value_high, value_low
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False), register, value_low,
value_high])
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response) | [
"Write",
"a",
"16",
"-",
"bit",
"value",
"to",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L785-L799 | [
"def",
"write16",
"(",
"self",
",",
"register",
",",
"value",
",",
"little_endian",
"=",
"True",
")",
":",
"value",
"=",
"value",
"&",
"0xFFFF",
"value_low",
"=",
"value",
"&",
"0xFF",
"value_high",
"=",
"(",
"value",
">>",
"8",
")",
"&",
"0xFF",
"if",
"not",
"little_endian",
":",
"value_low",
",",
"value_high",
"=",
"value_high",
",",
"value_low",
"self",
".",
"_idle",
"(",
")",
"self",
".",
"_transaction_start",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"False",
")",
",",
"register",
",",
"value_low",
",",
"value_high",
"]",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"response",
"=",
"self",
".",
"_transaction_end",
"(",
")",
"self",
".",
"_verify_acks",
"(",
"response",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.writeList | Write bytes to the specified register. | Adafruit_GPIO/FT232H.py | def writeList(self, register, data):
"""Write bytes to the specified register."""
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False), register] + data)
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response) | def writeList(self, register, data):
"""Write bytes to the specified register."""
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False), register] + data)
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response) | [
"Write",
"bytes",
"to",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L801-L809 | [
"def",
"writeList",
"(",
"self",
",",
"register",
",",
"data",
")",
":",
"self",
".",
"_idle",
"(",
")",
"self",
".",
"_transaction_start",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"False",
")",
",",
"register",
"]",
"+",
"data",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"response",
"=",
"self",
".",
"_transaction_end",
"(",
")",
"self",
".",
"_verify_acks",
"(",
"response",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.readList | Read a length number of bytes from the specified register. Results
will be returned as a bytearray. | Adafruit_GPIO/FT232H.py | def readList(self, register, length):
"""Read a length number of bytes from the specified register. Results
will be returned as a bytearray."""
if length <= 0:
raise ValueError("Length must be at least 1 byte.")
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(True), register])
self._i2c_stop()
self._i2c_idle()
self._i2c_start()
self._i2c_read_bytes(length)
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response[:-length])
return response[-length:] | def readList(self, register, length):
"""Read a length number of bytes from the specified register. Results
will be returned as a bytearray."""
if length <= 0:
raise ValueError("Length must be at least 1 byte.")
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(True), register])
self._i2c_stop()
self._i2c_idle()
self._i2c_start()
self._i2c_read_bytes(length)
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response[:-length])
return response[-length:] | [
"Read",
"a",
"length",
"number",
"of",
"bytes",
"from",
"the",
"specified",
"register",
".",
"Results",
"will",
"be",
"returned",
"as",
"a",
"bytearray",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L811-L827 | [
"def",
"readList",
"(",
"self",
",",
"register",
",",
"length",
")",
":",
"if",
"length",
"<=",
"0",
":",
"raise",
"ValueError",
"(",
"\"Length must be at least 1 byte.\"",
")",
"self",
".",
"_idle",
"(",
")",
"self",
".",
"_transaction_start",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"True",
")",
",",
"register",
"]",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"self",
".",
"_i2c_idle",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_read_bytes",
"(",
"length",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"response",
"=",
"self",
".",
"_transaction_end",
"(",
")",
"self",
".",
"_verify_acks",
"(",
"response",
"[",
":",
"-",
"length",
"]",
")",
"return",
"response",
"[",
"-",
"length",
":",
"]"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.readRaw8 | Read an 8-bit value on the bus (without register). | Adafruit_GPIO/FT232H.py | def readRaw8(self):
"""Read an 8-bit value on the bus (without register)."""
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False)])
self._i2c_stop()
self._i2c_idle()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(True)])
self._i2c_read_bytes(1)
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response[:-1])
return response[-1] | def readRaw8(self):
"""Read an 8-bit value on the bus (without register)."""
self._idle()
self._transaction_start()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(False)])
self._i2c_stop()
self._i2c_idle()
self._i2c_start()
self._i2c_write_bytes([self._address_byte(True)])
self._i2c_read_bytes(1)
self._i2c_stop()
response = self._transaction_end()
self._verify_acks(response[:-1])
return response[-1] | [
"Read",
"an",
"8",
"-",
"bit",
"value",
"on",
"the",
"bus",
"(",
"without",
"register",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L829-L843 | [
"def",
"readRaw8",
"(",
"self",
")",
":",
"self",
".",
"_idle",
"(",
")",
"self",
".",
"_transaction_start",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"False",
")",
"]",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"self",
".",
"_i2c_idle",
"(",
")",
"self",
".",
"_i2c_start",
"(",
")",
"self",
".",
"_i2c_write_bytes",
"(",
"[",
"self",
".",
"_address_byte",
"(",
"True",
")",
"]",
")",
"self",
".",
"_i2c_read_bytes",
"(",
"1",
")",
"self",
".",
"_i2c_stop",
"(",
")",
"response",
"=",
"self",
".",
"_transaction_end",
"(",
")",
"self",
".",
"_verify_acks",
"(",
"response",
"[",
":",
"-",
"1",
"]",
")",
"return",
"response",
"[",
"-",
"1",
"]"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.readS8 | Read a signed byte from the specified register. | Adafruit_GPIO/FT232H.py | def readS8(self, register):
"""Read a signed byte from the specified register."""
result = self.readU8(register)
if result > 127:
result -= 256
return result | def readS8(self, register):
"""Read a signed byte from the specified register."""
result = self.readU8(register)
if result > 127:
result -= 256
return result | [
"Read",
"a",
"signed",
"byte",
"from",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L861-L866 | [
"def",
"readS8",
"(",
"self",
",",
"register",
")",
":",
"result",
"=",
"self",
".",
"readU8",
"(",
"register",
")",
"if",
"result",
">",
"127",
":",
"result",
"-=",
"256",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | I2CDevice.readS16 | Read a signed 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first). | Adafruit_GPIO/FT232H.py | def readS16(self, register, little_endian=True):
"""Read a signed 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = self.readU16(register, little_endian)
if result > 32767:
result -= 65536
return result | def readS16(self, register, little_endian=True):
"""Read a signed 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = self.readU16(register, little_endian)
if result > 32767:
result -= 65536
return result | [
"Read",
"a",
"signed",
"16",
"-",
"bit",
"value",
"from",
"the",
"specified",
"register",
"with",
"the",
"specified",
"endianness",
"(",
"default",
"little",
"endian",
"or",
"least",
"significant",
"byte",
"first",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/FT232H.py#L889-L896 | [
"def",
"readS16",
"(",
"self",
",",
"register",
",",
"little_endian",
"=",
"True",
")",
":",
"result",
"=",
"self",
".",
"readU16",
"(",
"register",
",",
"little_endian",
")",
"if",
"result",
">",
"32767",
":",
"result",
"-=",
"65536",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | get_default_bus | Return the default bus number based on the device platform. For a
Raspberry Pi either bus 0 or 1 (based on the Pi revision) will be returned.
For a Beaglebone Black the first user accessible bus, 1, will be returned. | Adafruit_GPIO/I2C.py | def get_default_bus():
"""Return the default bus number based on the device platform. For a
Raspberry Pi either bus 0 or 1 (based on the Pi revision) will be returned.
For a Beaglebone Black the first user accessible bus, 1, will be returned.
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI:
if Platform.pi_revision() == 1:
# Revision 1 Pi uses I2C bus 0.
return 0
else:
# Revision 2 Pi uses I2C bus 1.
return 1
elif plat == Platform.BEAGLEBONE_BLACK:
# Beaglebone Black has multiple I2C buses, default to 1 (P9_19 and P9_20).
return 1
else:
raise RuntimeError('Could not determine default I2C bus for platform.') | def get_default_bus():
"""Return the default bus number based on the device platform. For a
Raspberry Pi either bus 0 or 1 (based on the Pi revision) will be returned.
For a Beaglebone Black the first user accessible bus, 1, will be returned.
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI:
if Platform.pi_revision() == 1:
# Revision 1 Pi uses I2C bus 0.
return 0
else:
# Revision 2 Pi uses I2C bus 1.
return 1
elif plat == Platform.BEAGLEBONE_BLACK:
# Beaglebone Black has multiple I2C buses, default to 1 (P9_19 and P9_20).
return 1
else:
raise RuntimeError('Could not determine default I2C bus for platform.') | [
"Return",
"the",
"default",
"bus",
"number",
"based",
"on",
"the",
"device",
"platform",
".",
"For",
"a",
"Raspberry",
"Pi",
"either",
"bus",
"0",
"or",
"1",
"(",
"based",
"on",
"the",
"Pi",
"revision",
")",
"will",
"be",
"returned",
".",
"For",
"a",
"Beaglebone",
"Black",
"the",
"first",
"user",
"accessible",
"bus",
"1",
"will",
"be",
"returned",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L40-L57 | [
"def",
"get_default_bus",
"(",
")",
":",
"plat",
"=",
"Platform",
".",
"platform_detect",
"(",
")",
"if",
"plat",
"==",
"Platform",
".",
"RASPBERRY_PI",
":",
"if",
"Platform",
".",
"pi_revision",
"(",
")",
"==",
"1",
":",
"# Revision 1 Pi uses I2C bus 0.",
"return",
"0",
"else",
":",
"# Revision 2 Pi uses I2C bus 1.",
"return",
"1",
"elif",
"plat",
"==",
"Platform",
".",
"BEAGLEBONE_BLACK",
":",
"# Beaglebone Black has multiple I2C buses, default to 1 (P9_19 and P9_20).",
"return",
"1",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Could not determine default I2C bus for platform.'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | get_i2c_device | Return an I2C device for the specified address and on the specified bus.
If busnum isn't specified, the default I2C bus for the platform will attempt
to be detected. | Adafruit_GPIO/I2C.py | def get_i2c_device(address, busnum=None, i2c_interface=None, **kwargs):
"""Return an I2C device for the specified address and on the specified bus.
If busnum isn't specified, the default I2C bus for the platform will attempt
to be detected.
"""
if busnum is None:
busnum = get_default_bus()
return Device(address, busnum, i2c_interface, **kwargs) | def get_i2c_device(address, busnum=None, i2c_interface=None, **kwargs):
"""Return an I2C device for the specified address and on the specified bus.
If busnum isn't specified, the default I2C bus for the platform will attempt
to be detected.
"""
if busnum is None:
busnum = get_default_bus()
return Device(address, busnum, i2c_interface, **kwargs) | [
"Return",
"an",
"I2C",
"device",
"for",
"the",
"specified",
"address",
"and",
"on",
"the",
"specified",
"bus",
".",
"If",
"busnum",
"isn",
"t",
"specified",
"the",
"default",
"I2C",
"bus",
"for",
"the",
"platform",
"will",
"attempt",
"to",
"be",
"detected",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L59-L66 | [
"def",
"get_i2c_device",
"(",
"address",
",",
"busnum",
"=",
"None",
",",
"i2c_interface",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"busnum",
"is",
"None",
":",
"busnum",
"=",
"get_default_bus",
"(",
")",
"return",
"Device",
"(",
"address",
",",
"busnum",
",",
"i2c_interface",
",",
"*",
"*",
"kwargs",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | require_repeated_start | Enable repeated start conditions for I2C register reads. This is the
normal behavior for I2C, however on some platforms like the Raspberry Pi
there are bugs which disable repeated starts unless explicitly enabled with
this function. See this thread for more details:
http://www.raspberrypi.org/forums/viewtopic.php?f=44&t=15840 | Adafruit_GPIO/I2C.py | def require_repeated_start():
"""Enable repeated start conditions for I2C register reads. This is the
normal behavior for I2C, however on some platforms like the Raspberry Pi
there are bugs which disable repeated starts unless explicitly enabled with
this function. See this thread for more details:
http://www.raspberrypi.org/forums/viewtopic.php?f=44&t=15840
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI and os.path.exists('/sys/module/i2c_bcm2708/parameters/combined'):
# On the Raspberry Pi there is a bug where register reads don't send a
# repeated start condition like the kernel smbus I2C driver functions
# define. As a workaround this bit in the BCM2708 driver sysfs tree can
# be changed to enable I2C repeated starts.
subprocess.check_call('chmod 666 /sys/module/i2c_bcm2708/parameters/combined', shell=True)
subprocess.check_call('echo -n 1 > /sys/module/i2c_bcm2708/parameters/combined', shell=True) | def require_repeated_start():
"""Enable repeated start conditions for I2C register reads. This is the
normal behavior for I2C, however on some platforms like the Raspberry Pi
there are bugs which disable repeated starts unless explicitly enabled with
this function. See this thread for more details:
http://www.raspberrypi.org/forums/viewtopic.php?f=44&t=15840
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI and os.path.exists('/sys/module/i2c_bcm2708/parameters/combined'):
# On the Raspberry Pi there is a bug where register reads don't send a
# repeated start condition like the kernel smbus I2C driver functions
# define. As a workaround this bit in the BCM2708 driver sysfs tree can
# be changed to enable I2C repeated starts.
subprocess.check_call('chmod 666 /sys/module/i2c_bcm2708/parameters/combined', shell=True)
subprocess.check_call('echo -n 1 > /sys/module/i2c_bcm2708/parameters/combined', shell=True) | [
"Enable",
"repeated",
"start",
"conditions",
"for",
"I2C",
"register",
"reads",
".",
"This",
"is",
"the",
"normal",
"behavior",
"for",
"I2C",
"however",
"on",
"some",
"platforms",
"like",
"the",
"Raspberry",
"Pi",
"there",
"are",
"bugs",
"which",
"disable",
"repeated",
"starts",
"unless",
"explicitly",
"enabled",
"with",
"this",
"function",
".",
"See",
"this",
"thread",
"for",
"more",
"details",
":",
"http",
":",
"//",
"www",
".",
"raspberrypi",
".",
"org",
"/",
"forums",
"/",
"viewtopic",
".",
"php?f",
"=",
"44&t",
"=",
"15840"
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L68-L82 | [
"def",
"require_repeated_start",
"(",
")",
":",
"plat",
"=",
"Platform",
".",
"platform_detect",
"(",
")",
"if",
"plat",
"==",
"Platform",
".",
"RASPBERRY_PI",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"'/sys/module/i2c_bcm2708/parameters/combined'",
")",
":",
"# On the Raspberry Pi there is a bug where register reads don't send a",
"# repeated start condition like the kernel smbus I2C driver functions",
"# define. As a workaround this bit in the BCM2708 driver sysfs tree can",
"# be changed to enable I2C repeated starts.",
"subprocess",
".",
"check_call",
"(",
"'chmod 666 /sys/module/i2c_bcm2708/parameters/combined'",
",",
"shell",
"=",
"True",
")",
"subprocess",
".",
"check_call",
"(",
"'echo -n 1 > /sys/module/i2c_bcm2708/parameters/combined'",
",",
"shell",
"=",
"True",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.writeRaw8 | Write an 8-bit value on the bus (without register). | Adafruit_GPIO/I2C.py | def writeRaw8(self, value):
"""Write an 8-bit value on the bus (without register)."""
value = value & 0xFF
self._bus.write_byte(self._address, value)
self._logger.debug("Wrote 0x%02X",
value) | def writeRaw8(self, value):
"""Write an 8-bit value on the bus (without register)."""
value = value & 0xFF
self._bus.write_byte(self._address, value)
self._logger.debug("Wrote 0x%02X",
value) | [
"Write",
"an",
"8",
"-",
"bit",
"value",
"on",
"the",
"bus",
"(",
"without",
"register",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L106-L111 | [
"def",
"writeRaw8",
"(",
"self",
",",
"value",
")",
":",
"value",
"=",
"value",
"&",
"0xFF",
"self",
".",
"_bus",
".",
"write_byte",
"(",
"self",
".",
"_address",
",",
"value",
")",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Wrote 0x%02X\"",
",",
"value",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.write8 | Write an 8-bit value to the specified register. | Adafruit_GPIO/I2C.py | def write8(self, register, value):
"""Write an 8-bit value to the specified register."""
value = value & 0xFF
self._bus.write_byte_data(self._address, register, value)
self._logger.debug("Wrote 0x%02X to register 0x%02X",
value, register) | def write8(self, register, value):
"""Write an 8-bit value to the specified register."""
value = value & 0xFF
self._bus.write_byte_data(self._address, register, value)
self._logger.debug("Wrote 0x%02X to register 0x%02X",
value, register) | [
"Write",
"an",
"8",
"-",
"bit",
"value",
"to",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L113-L118 | [
"def",
"write8",
"(",
"self",
",",
"register",
",",
"value",
")",
":",
"value",
"=",
"value",
"&",
"0xFF",
"self",
".",
"_bus",
".",
"write_byte_data",
"(",
"self",
".",
"_address",
",",
"register",
",",
"value",
")",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Wrote 0x%02X to register 0x%02X\"",
",",
"value",
",",
"register",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.write16 | Write a 16-bit value to the specified register. | Adafruit_GPIO/I2C.py | def write16(self, register, value):
"""Write a 16-bit value to the specified register."""
value = value & 0xFFFF
self._bus.write_word_data(self._address, register, value)
self._logger.debug("Wrote 0x%04X to register pair 0x%02X, 0x%02X",
value, register, register+1) | def write16(self, register, value):
"""Write a 16-bit value to the specified register."""
value = value & 0xFFFF
self._bus.write_word_data(self._address, register, value)
self._logger.debug("Wrote 0x%04X to register pair 0x%02X, 0x%02X",
value, register, register+1) | [
"Write",
"a",
"16",
"-",
"bit",
"value",
"to",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L120-L125 | [
"def",
"write16",
"(",
"self",
",",
"register",
",",
"value",
")",
":",
"value",
"=",
"value",
"&",
"0xFFFF",
"self",
".",
"_bus",
".",
"write_word_data",
"(",
"self",
".",
"_address",
",",
"register",
",",
"value",
")",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Wrote 0x%04X to register pair 0x%02X, 0x%02X\"",
",",
"value",
",",
"register",
",",
"register",
"+",
"1",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.writeList | Write bytes to the specified register. | Adafruit_GPIO/I2C.py | def writeList(self, register, data):
"""Write bytes to the specified register."""
self._bus.write_i2c_block_data(self._address, register, data)
self._logger.debug("Wrote to register 0x%02X: %s",
register, data) | def writeList(self, register, data):
"""Write bytes to the specified register."""
self._bus.write_i2c_block_data(self._address, register, data)
self._logger.debug("Wrote to register 0x%02X: %s",
register, data) | [
"Write",
"bytes",
"to",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L127-L131 | [
"def",
"writeList",
"(",
"self",
",",
"register",
",",
"data",
")",
":",
"self",
".",
"_bus",
".",
"write_i2c_block_data",
"(",
"self",
".",
"_address",
",",
"register",
",",
"data",
")",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Wrote to register 0x%02X: %s\"",
",",
"register",
",",
"data",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.readList | Read a length number of bytes from the specified register. Results
will be returned as a bytearray. | Adafruit_GPIO/I2C.py | def readList(self, register, length):
"""Read a length number of bytes from the specified register. Results
will be returned as a bytearray."""
results = self._bus.read_i2c_block_data(self._address, register, length)
self._logger.debug("Read the following from register 0x%02X: %s",
register, results)
return results | def readList(self, register, length):
"""Read a length number of bytes from the specified register. Results
will be returned as a bytearray."""
results = self._bus.read_i2c_block_data(self._address, register, length)
self._logger.debug("Read the following from register 0x%02X: %s",
register, results)
return results | [
"Read",
"a",
"length",
"number",
"of",
"bytes",
"from",
"the",
"specified",
"register",
".",
"Results",
"will",
"be",
"returned",
"as",
"a",
"bytearray",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L133-L139 | [
"def",
"readList",
"(",
"self",
",",
"register",
",",
"length",
")",
":",
"results",
"=",
"self",
".",
"_bus",
".",
"read_i2c_block_data",
"(",
"self",
".",
"_address",
",",
"register",
",",
"length",
")",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Read the following from register 0x%02X: %s\"",
",",
"register",
",",
"results",
")",
"return",
"results"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.readRaw8 | Read an 8-bit value on the bus (without register). | Adafruit_GPIO/I2C.py | def readRaw8(self):
"""Read an 8-bit value on the bus (without register)."""
result = self._bus.read_byte(self._address) & 0xFF
self._logger.debug("Read 0x%02X",
result)
return result | def readRaw8(self):
"""Read an 8-bit value on the bus (without register)."""
result = self._bus.read_byte(self._address) & 0xFF
self._logger.debug("Read 0x%02X",
result)
return result | [
"Read",
"an",
"8",
"-",
"bit",
"value",
"on",
"the",
"bus",
"(",
"without",
"register",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L141-L146 | [
"def",
"readRaw8",
"(",
"self",
")",
":",
"result",
"=",
"self",
".",
"_bus",
".",
"read_byte",
"(",
"self",
".",
"_address",
")",
"&",
"0xFF",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Read 0x%02X\"",
",",
"result",
")",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.readU8 | Read an unsigned byte from the specified register. | Adafruit_GPIO/I2C.py | def readU8(self, register):
"""Read an unsigned byte from the specified register."""
result = self._bus.read_byte_data(self._address, register) & 0xFF
self._logger.debug("Read 0x%02X from register 0x%02X",
result, register)
return result | def readU8(self, register):
"""Read an unsigned byte from the specified register."""
result = self._bus.read_byte_data(self._address, register) & 0xFF
self._logger.debug("Read 0x%02X from register 0x%02X",
result, register)
return result | [
"Read",
"an",
"unsigned",
"byte",
"from",
"the",
"specified",
"register",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L148-L153 | [
"def",
"readU8",
"(",
"self",
",",
"register",
")",
":",
"result",
"=",
"self",
".",
"_bus",
".",
"read_byte_data",
"(",
"self",
".",
"_address",
",",
"register",
")",
"&",
"0xFF",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Read 0x%02X from register 0x%02X\"",
",",
"result",
",",
"register",
")",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | Device.readU16 | Read an unsigned 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first). | Adafruit_GPIO/I2C.py | def readU16(self, register, little_endian=True):
"""Read an unsigned 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = self._bus.read_word_data(self._address,register) & 0xFFFF
self._logger.debug("Read 0x%04X from register pair 0x%02X, 0x%02X",
result, register, register+1)
# Swap bytes if using big endian because read_word_data assumes little
# endian on ARM (little endian) systems.
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
return result | def readU16(self, register, little_endian=True):
"""Read an unsigned 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = self._bus.read_word_data(self._address,register) & 0xFFFF
self._logger.debug("Read 0x%04X from register pair 0x%02X, 0x%02X",
result, register, register+1)
# Swap bytes if using big endian because read_word_data assumes little
# endian on ARM (little endian) systems.
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
return result | [
"Read",
"an",
"unsigned",
"16",
"-",
"bit",
"value",
"from",
"the",
"specified",
"register",
"with",
"the",
"specified",
"endianness",
"(",
"default",
"little",
"endian",
"or",
"least",
"significant",
"byte",
"first",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/I2C.py#L162-L173 | [
"def",
"readU16",
"(",
"self",
",",
"register",
",",
"little_endian",
"=",
"True",
")",
":",
"result",
"=",
"self",
".",
"_bus",
".",
"read_word_data",
"(",
"self",
".",
"_address",
",",
"register",
")",
"&",
"0xFFFF",
"self",
".",
"_logger",
".",
"debug",
"(",
"\"Read 0x%04X from register pair 0x%02X, 0x%02X\"",
",",
"result",
",",
"register",
",",
"register",
"+",
"1",
")",
"# Swap bytes if using big endian because read_word_data assumes little",
"# endian on ARM (little endian) systems.",
"if",
"not",
"little_endian",
":",
"result",
"=",
"(",
"(",
"result",
"<<",
"8",
")",
"&",
"0xFF00",
")",
"+",
"(",
"result",
">>",
"8",
")",
"return",
"result"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | get_platform_gpio | Attempt to return a GPIO instance for the platform which the code is being
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
exception if a GPIO instance can't be created for the current platform. The
returned GPIO object is an instance of BaseGPIO. | Adafruit_GPIO/GPIO.py | def get_platform_gpio(**keywords):
"""Attempt to return a GPIO instance for the platform which the code is being
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
exception if a GPIO instance can't be created for the current platform. The
returned GPIO object is an instance of BaseGPIO.
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI:
import RPi.GPIO
return RPiGPIOAdapter(RPi.GPIO, **keywords)
elif plat == Platform.BEAGLEBONE_BLACK:
import Adafruit_BBIO.GPIO
return AdafruitBBIOAdapter(Adafruit_BBIO.GPIO, **keywords)
elif plat == Platform.MINNOWBOARD:
import mraa
return AdafruitMinnowAdapter(mraa, **keywords)
elif plat == Platform.JETSON_NANO:
import Jetson.GPIO
return RPiGPIOAdapter(Jetson.GPIO, **keywords)
elif plat == Platform.UNKNOWN:
raise RuntimeError('Could not determine platform.') | def get_platform_gpio(**keywords):
"""Attempt to return a GPIO instance for the platform which the code is being
executed on. Currently supports only the Raspberry Pi using the RPi.GPIO
library and Beaglebone Black using the Adafruit_BBIO library. Will throw an
exception if a GPIO instance can't be created for the current platform. The
returned GPIO object is an instance of BaseGPIO.
"""
plat = Platform.platform_detect()
if plat == Platform.RASPBERRY_PI:
import RPi.GPIO
return RPiGPIOAdapter(RPi.GPIO, **keywords)
elif plat == Platform.BEAGLEBONE_BLACK:
import Adafruit_BBIO.GPIO
return AdafruitBBIOAdapter(Adafruit_BBIO.GPIO, **keywords)
elif plat == Platform.MINNOWBOARD:
import mraa
return AdafruitMinnowAdapter(mraa, **keywords)
elif plat == Platform.JETSON_NANO:
import Jetson.GPIO
return RPiGPIOAdapter(Jetson.GPIO, **keywords)
elif plat == Platform.UNKNOWN:
raise RuntimeError('Could not determine platform.') | [
"Attempt",
"to",
"return",
"a",
"GPIO",
"instance",
"for",
"the",
"platform",
"which",
"the",
"code",
"is",
"being",
"executed",
"on",
".",
"Currently",
"supports",
"only",
"the",
"Raspberry",
"Pi",
"using",
"the",
"RPi",
".",
"GPIO",
"library",
"and",
"Beaglebone",
"Black",
"using",
"the",
"Adafruit_BBIO",
"library",
".",
"Will",
"throw",
"an",
"exception",
"if",
"a",
"GPIO",
"instance",
"can",
"t",
"be",
"created",
"for",
"the",
"current",
"platform",
".",
"The",
"returned",
"GPIO",
"object",
"is",
"an",
"instance",
"of",
"BaseGPIO",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L408-L429 | [
"def",
"get_platform_gpio",
"(",
"*",
"*",
"keywords",
")",
":",
"plat",
"=",
"Platform",
".",
"platform_detect",
"(",
")",
"if",
"plat",
"==",
"Platform",
".",
"RASPBERRY_PI",
":",
"import",
"RPi",
".",
"GPIO",
"return",
"RPiGPIOAdapter",
"(",
"RPi",
".",
"GPIO",
",",
"*",
"*",
"keywords",
")",
"elif",
"plat",
"==",
"Platform",
".",
"BEAGLEBONE_BLACK",
":",
"import",
"Adafruit_BBIO",
".",
"GPIO",
"return",
"AdafruitBBIOAdapter",
"(",
"Adafruit_BBIO",
".",
"GPIO",
",",
"*",
"*",
"keywords",
")",
"elif",
"plat",
"==",
"Platform",
".",
"MINNOWBOARD",
":",
"import",
"mraa",
"return",
"AdafruitMinnowAdapter",
"(",
"mraa",
",",
"*",
"*",
"keywords",
")",
"elif",
"plat",
"==",
"Platform",
".",
"JETSON_NANO",
":",
"import",
"Jetson",
".",
"GPIO",
"return",
"RPiGPIOAdapter",
"(",
"Jetson",
".",
"GPIO",
",",
"*",
"*",
"keywords",
")",
"elif",
"plat",
"==",
"Platform",
".",
"UNKNOWN",
":",
"raise",
"RuntimeError",
"(",
"'Could not determine platform.'",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BaseGPIO.output_pins | Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values. | Adafruit_GPIO/GPIO.py | def output_pins(self, pins):
"""Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values.
"""
# General implementation just loops through pins and writes them out
# manually. This is not optimized, but subclasses can choose to implement
# a more optimal batch output implementation. See the MCP230xx class for
# example of optimized implementation.
for pin, value in iter(pins.items()):
self.output(pin, value) | def output_pins(self, pins):
"""Set multiple pins high or low at once. Pins should be a dict of pin
name to pin value (HIGH/True for 1, LOW/False for 0). All provided pins
will be set to the given values.
"""
# General implementation just loops through pins and writes them out
# manually. This is not optimized, but subclasses can choose to implement
# a more optimal batch output implementation. See the MCP230xx class for
# example of optimized implementation.
for pin, value in iter(pins.items()):
self.output(pin, value) | [
"Set",
"multiple",
"pins",
"high",
"or",
"low",
"at",
"once",
".",
"Pins",
"should",
"be",
"a",
"dict",
"of",
"pin",
"name",
"to",
"pin",
"value",
"(",
"HIGH",
"/",
"True",
"for",
"1",
"LOW",
"/",
"False",
"for",
"0",
")",
".",
"All",
"provided",
"pins",
"will",
"be",
"set",
"to",
"the",
"given",
"values",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L81-L91 | [
"def",
"output_pins",
"(",
"self",
",",
"pins",
")",
":",
"# General implementation just loops through pins and writes them out",
"# manually. This is not optimized, but subclasses can choose to implement",
"# a more optimal batch output implementation. See the MCP230xx class for",
"# example of optimized implementation.",
"for",
"pin",
",",
"value",
"in",
"iter",
"(",
"pins",
".",
"items",
"(",
")",
")",
":",
"self",
".",
"output",
"(",
"pin",
",",
"value",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | BaseGPIO.setup_pins | Setup multiple pins as inputs or outputs at once. Pins should be a
dict of pin name to pin type (IN or OUT). | Adafruit_GPIO/GPIO.py | def setup_pins(self, pins):
"""Setup multiple pins as inputs or outputs at once. Pins should be a
dict of pin name to pin type (IN or OUT).
"""
# General implementation that can be optimized by derived classes.
for pin, value in iter(pins.items()):
self.setup(pin, value) | def setup_pins(self, pins):
"""Setup multiple pins as inputs or outputs at once. Pins should be a
dict of pin name to pin type (IN or OUT).
"""
# General implementation that can be optimized by derived classes.
for pin, value in iter(pins.items()):
self.setup(pin, value) | [
"Setup",
"multiple",
"pins",
"as",
"inputs",
"or",
"outputs",
"at",
"once",
".",
"Pins",
"should",
"be",
"a",
"dict",
"of",
"pin",
"name",
"to",
"pin",
"type",
"(",
"IN",
"or",
"OUT",
")",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L93-L99 | [
"def",
"setup_pins",
"(",
"self",
",",
"pins",
")",
":",
"# General implementation that can be optimized by derived classes.",
"for",
"pin",
",",
"value",
"in",
"iter",
"(",
"pins",
".",
"items",
"(",
")",
")",
":",
"self",
".",
"setup",
"(",
"pin",
",",
"value",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPiGPIOAdapter.setup | Set the input or output mode for a specified pin. Mode should be
either OUTPUT or INPUT. | Adafruit_GPIO/GPIO.py | def setup(self, pin, mode, pull_up_down=PUD_OFF):
"""Set the input or output mode for a specified pin. Mode should be
either OUTPUT or INPUT.
"""
self.rpi_gpio.setup(pin, self._dir_mapping[mode],
pull_up_down=self._pud_mapping[pull_up_down]) | def setup(self, pin, mode, pull_up_down=PUD_OFF):
"""Set the input or output mode for a specified pin. Mode should be
either OUTPUT or INPUT.
"""
self.rpi_gpio.setup(pin, self._dir_mapping[mode],
pull_up_down=self._pud_mapping[pull_up_down]) | [
"Set",
"the",
"input",
"or",
"output",
"mode",
"for",
"a",
"specified",
"pin",
".",
"Mode",
"should",
"be",
"either",
"OUTPUT",
"or",
"INPUT",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L183-L188 | [
"def",
"setup",
"(",
"self",
",",
"pin",
",",
"mode",
",",
"pull_up_down",
"=",
"PUD_OFF",
")",
":",
"self",
".",
"rpi_gpio",
".",
"setup",
"(",
"pin",
",",
"self",
".",
"_dir_mapping",
"[",
"mode",
"]",
",",
"pull_up_down",
"=",
"self",
".",
"_pud_mapping",
"[",
"pull_up_down",
"]",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPiGPIOAdapter.add_event_detect | Enable edge detection events for a particular GPIO channel. Pin
should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a
function for the event. Bouncetime is switch bounce timeout in ms for
callback | Adafruit_GPIO/GPIO.py | def add_event_detect(self, pin, edge, callback=None, bouncetime=-1):
"""Enable edge detection events for a particular GPIO channel. Pin
should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a
function for the event. Bouncetime is switch bounce timeout in ms for
callback
"""
kwargs = {}
if callback:
kwargs['callback']=callback
if bouncetime > 0:
kwargs['bouncetime']=bouncetime
self.rpi_gpio.add_event_detect(pin, self._edge_mapping[edge], **kwargs) | def add_event_detect(self, pin, edge, callback=None, bouncetime=-1):
"""Enable edge detection events for a particular GPIO channel. Pin
should be type IN. Edge must be RISING, FALLING or BOTH. Callback is a
function for the event. Bouncetime is switch bounce timeout in ms for
callback
"""
kwargs = {}
if callback:
kwargs['callback']=callback
if bouncetime > 0:
kwargs['bouncetime']=bouncetime
self.rpi_gpio.add_event_detect(pin, self._edge_mapping[edge], **kwargs) | [
"Enable",
"edge",
"detection",
"events",
"for",
"a",
"particular",
"GPIO",
"channel",
".",
"Pin",
"should",
"be",
"type",
"IN",
".",
"Edge",
"must",
"be",
"RISING",
"FALLING",
"or",
"BOTH",
".",
"Callback",
"is",
"a",
"function",
"for",
"the",
"event",
".",
"Bouncetime",
"is",
"switch",
"bounce",
"timeout",
"in",
"ms",
"for",
"callback"
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L209-L220 | [
"def",
"add_event_detect",
"(",
"self",
",",
"pin",
",",
"edge",
",",
"callback",
"=",
"None",
",",
"bouncetime",
"=",
"-",
"1",
")",
":",
"kwargs",
"=",
"{",
"}",
"if",
"callback",
":",
"kwargs",
"[",
"'callback'",
"]",
"=",
"callback",
"if",
"bouncetime",
">",
"0",
":",
"kwargs",
"[",
"'bouncetime'",
"]",
"=",
"bouncetime",
"self",
".",
"rpi_gpio",
".",
"add_event_detect",
"(",
"pin",
",",
"self",
".",
"_edge_mapping",
"[",
"edge",
"]",
",",
"*",
"*",
"kwargs",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPiGPIOAdapter.wait_for_edge | Wait for an edge. Pin should be type IN. Edge must be RISING,
FALLING or BOTH. | Adafruit_GPIO/GPIO.py | def wait_for_edge(self, pin, edge):
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
FALLING or BOTH.
"""
self.rpi_gpio.wait_for_edge(pin, self._edge_mapping[edge]) | def wait_for_edge(self, pin, edge):
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
FALLING or BOTH.
"""
self.rpi_gpio.wait_for_edge(pin, self._edge_mapping[edge]) | [
"Wait",
"for",
"an",
"edge",
".",
"Pin",
"should",
"be",
"type",
"IN",
".",
"Edge",
"must",
"be",
"RISING",
"FALLING",
"or",
"BOTH",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L241-L245 | [
"def",
"wait_for_edge",
"(",
"self",
",",
"pin",
",",
"edge",
")",
":",
"self",
".",
"rpi_gpio",
".",
"wait_for_edge",
"(",
"pin",
",",
"self",
".",
"_edge_mapping",
"[",
"edge",
"]",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | RPiGPIOAdapter.cleanup | Clean up GPIO event detection for specific pin, or all pins if none
is specified. | Adafruit_GPIO/GPIO.py | def cleanup(self, pin=None):
"""Clean up GPIO event detection for specific pin, or all pins if none
is specified.
"""
if pin is None:
self.rpi_gpio.cleanup()
else:
self.rpi_gpio.cleanup(pin) | def cleanup(self, pin=None):
"""Clean up GPIO event detection for specific pin, or all pins if none
is specified.
"""
if pin is None:
self.rpi_gpio.cleanup()
else:
self.rpi_gpio.cleanup(pin) | [
"Clean",
"up",
"GPIO",
"event",
"detection",
"for",
"specific",
"pin",
"or",
"all",
"pins",
"if",
"none",
"is",
"specified",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L247-L254 | [
"def",
"cleanup",
"(",
"self",
",",
"pin",
"=",
"None",
")",
":",
"if",
"pin",
"is",
"None",
":",
"self",
".",
"rpi_gpio",
".",
"cleanup",
"(",
")",
"else",
":",
"self",
".",
"rpi_gpio",
".",
"cleanup",
"(",
"pin",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | AdafruitBBIOAdapter.add_event_callback | Add a callback for an event already defined using add_event_detect().
Pin should be type IN. Bouncetime is switch bounce timeout in ms for
callback | Adafruit_GPIO/GPIO.py | def add_event_callback(self, pin, callback, bouncetime=-1):
"""Add a callback for an event already defined using add_event_detect().
Pin should be type IN. Bouncetime is switch bounce timeout in ms for
callback
"""
kwargs = {}
if bouncetime > 0:
kwargs['bouncetime']=bouncetime
self.bbio_gpio.add_event_callback(pin, callback, **kwargs) | def add_event_callback(self, pin, callback, bouncetime=-1):
"""Add a callback for an event already defined using add_event_detect().
Pin should be type IN. Bouncetime is switch bounce timeout in ms for
callback
"""
kwargs = {}
if bouncetime > 0:
kwargs['bouncetime']=bouncetime
self.bbio_gpio.add_event_callback(pin, callback, **kwargs) | [
"Add",
"a",
"callback",
"for",
"an",
"event",
"already",
"defined",
"using",
"add_event_detect",
"()",
".",
"Pin",
"should",
"be",
"type",
"IN",
".",
"Bouncetime",
"is",
"switch",
"bounce",
"timeout",
"in",
"ms",
"for",
"callback"
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L318-L326 | [
"def",
"add_event_callback",
"(",
"self",
",",
"pin",
",",
"callback",
",",
"bouncetime",
"=",
"-",
"1",
")",
":",
"kwargs",
"=",
"{",
"}",
"if",
"bouncetime",
">",
"0",
":",
"kwargs",
"[",
"'bouncetime'",
"]",
"=",
"bouncetime",
"self",
".",
"bbio_gpio",
".",
"add_event_callback",
"(",
"pin",
",",
"callback",
",",
"*",
"*",
"kwargs",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | AdafruitBBIOAdapter.wait_for_edge | Wait for an edge. Pin should be type IN. Edge must be RISING,
FALLING or BOTH. | Adafruit_GPIO/GPIO.py | def wait_for_edge(self, pin, edge):
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
FALLING or BOTH.
"""
self.bbio_gpio.wait_for_edge(pin, self._edge_mapping[edge]) | def wait_for_edge(self, pin, edge):
"""Wait for an edge. Pin should be type IN. Edge must be RISING,
FALLING or BOTH.
"""
self.bbio_gpio.wait_for_edge(pin, self._edge_mapping[edge]) | [
"Wait",
"for",
"an",
"edge",
".",
"Pin",
"should",
"be",
"type",
"IN",
".",
"Edge",
"must",
"be",
"RISING",
"FALLING",
"or",
"BOTH",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L335-L339 | [
"def",
"wait_for_edge",
"(",
"self",
",",
"pin",
",",
"edge",
")",
":",
"self",
".",
"bbio_gpio",
".",
"wait_for_edge",
"(",
"pin",
",",
"self",
".",
"_edge_mapping",
"[",
"edge",
"]",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
valid | AdafruitBBIOAdapter.cleanup | Clean up GPIO event detection for specific pin, or all pins if none
is specified. | Adafruit_GPIO/GPIO.py | def cleanup(self, pin=None):
"""Clean up GPIO event detection for specific pin, or all pins if none
is specified.
"""
if pin is None:
self.bbio_gpio.cleanup()
else:
self.bbio_gpio.cleanup(pin) | def cleanup(self, pin=None):
"""Clean up GPIO event detection for specific pin, or all pins if none
is specified.
"""
if pin is None:
self.bbio_gpio.cleanup()
else:
self.bbio_gpio.cleanup(pin) | [
"Clean",
"up",
"GPIO",
"event",
"detection",
"for",
"specific",
"pin",
"or",
"all",
"pins",
"if",
"none",
"is",
"specified",
"."
] | adafruit/Adafruit_Python_GPIO | python | https://github.com/adafruit/Adafruit_Python_GPIO/blob/a92a23d6b5869663b2bc1ccf78bb11585076a9c4/Adafruit_GPIO/GPIO.py#L341-L348 | [
"def",
"cleanup",
"(",
"self",
",",
"pin",
"=",
"None",
")",
":",
"if",
"pin",
"is",
"None",
":",
"self",
".",
"bbio_gpio",
".",
"cleanup",
"(",
")",
"else",
":",
"self",
".",
"bbio_gpio",
".",
"cleanup",
"(",
"pin",
")"
] | a92a23d6b5869663b2bc1ccf78bb11585076a9c4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.