def grab_device(self, target):
# Do not try to grab targets that should not be grabbed
if hasattr(target, 'next_update') and target.next_update < 0:
return False
IPv6Str = binascii.hexlify(socket.inet_pton(socket.AF_INET6, self.udp_address))
payloadStr = "000000020000%04x"%self.udp_port + IPv6Str + "%08x"%self.grab_location + "00000000"
payload = binascii.unhexlify(payloadStr)
self.log.info("[%s] Grabbing device => %s (%s)", target, payloadStr, str(len(payload)))
t1 = tlvlib.create_set_tlv(0, tlvlib.VARIABLE_UNIT_CONTROLLER_ADDRESS, 3,
payload)
t2 = tlvlib.create_set_tlv32(0, tlvlib.VARIABLE_UNIT_CONTROLLER_WATCHDOG,
self.watchdog_time)
if hasattr(target, 'send_tlv'):
if target.has_pending_tlv(t2):
self.log.info("[%s] Already has pending grab request", target.address)
return False
if not target.send_tlv([t1,t2]):
self.log.info("[%s] Failed to grab device (time out)", target.address)
return False
return True
try:
tlvlib.send_tlv([t1,t2], target)
return True
except socket.timeout:
self.log.warning("[%s] Failed to grab device (time out)", str(target))
return False
def set_channel_panid(self):
# set radio channel
t1 = tlvlib.create_set_tlv32(self.radio_instance,
tlvlib.VARIABLE_RADIO_CHANNEL,
self.radio_channel)
# set radio PAN ID
t2 = tlvlib.create_set_tlv32(self.radio_instance,
tlvlib.VARIABLE_RADIO_PAN_ID,
self.radio_panid)
tlvlib.send_tlv([t1,t2], self.router_host)
def do_global_repair(ws):
global device_manager
print "Global Network Repair!"
tlv = tlvlib.create_set_tlv(device_manager.brm_instance, 0x10a,
tlvlib.SIZE32, struct.pack("!L", 1))
enc, tlvs = tlvlib.send_tlv([tlv], "localhost")
send_response(ws, "Global Network Repair!")
def fetch_nstats(address, instance):
t = create_nstats_tlv(instance)
enc,tlvs = tlvlib.send_tlv(t, address)
if enc.error == 0 and tlvs[0].error == 0:
nstats = Nstats(tlvs[0].value)
return nstats
return None
def fetch_nstats(address, instance):
t = create_nstats_tlv(instance)
enc, tlvs = tlvlib.send_tlv(t, address)
if enc.error == 0 and tlvs[0].error == 0:
nstats = Nstats(tlvs[0].value)
return nstats
return None
def do_global_repair(ws):
global device_manager
print "Global Network Repair!"
tlv = tlvlib.create_set_tlv(device_manager.brm_instance, 0x10a,
tlvlib.SIZE32, struct.pack("!L", 1))
enc, tlvs = tlvlib.send_tlv([tlv], "localhost")
send_response(ws, "Global Network Repair!")
def do_reboot(host, port, image=0):
if image == 0:
t = tlvlib.create_set_tlv32(0, tlvlib.VARIABLE_HARDWARE_RESET, 1)
else:
t = tlvlib.create_set_tlv32(0, tlvlib.VARIABLE_HARDWARE_RESET,
tlvlib.HARDWARE_RESET_KEY | image)
try:
tlvlib.send_tlv(t,
host,
port,
show_error=False,
retry=False,
timeout=0.2)
except socket.timeout:
# A timeout is expected since the node should reboot
pass
return True
def do_erase(instance, host, port):
# create Erase TLV
t1 = tlvlib.create_set_tlv32(instance, tlvlib.VARIABLE_WRITE_CONTROL,
tlvlib.FLASH_WRITE_CONTROL_ERASE)
try:
enc, tlvs = tlvlib.send_tlv(t1, host, port, 2.5)
except socket.timeout:
return False
return tlvs[0].error == 0
def set_panid(ws, panid):
global device_manager
print "setting pandid", panid
panid = tlvlib.decodevalue(panid)
tlv = tlvlib.create_set_tlv(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_PAN_ID,
tlvlib.SIZE32, struct.pack("!L", panid))
enc, tlvs = tlvlib.send_tlv([tlv], "localhost")
print "panid set to: " + str(panid)
send_response(ws, "Panid set to: " + str(panid))
# Update table
get_nbr_info(ws)
def set_panid(ws, panid):
global device_manager
print "setting pandid", panid
panid = tlvlib.decodevalue(panid)
tlv = tlvlib.create_set_tlv(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_PAN_ID, tlvlib.SIZE32,
struct.pack("!L", panid))
enc, tlvs = tlvlib.send_tlv([tlv], "localhost")
print "panid set to: " + str(panid)
send_response(ws, "Panid set to: " + str(panid))
# Update table
get_nbr_info(ws)
def tlvlamp(ws, ip, led):
de = ws.get_device_manager().get_device(ip)
if de and de.lamp_instance:
t1 = tlvlib.create_set_tlv32(de.lamp_instance, tlvlib.VARIABLE_LAMP_CONTROL, float(led)/100.0 * 0xffffffffL)
try:
enc, tlvs = tlvlib.send_tlv(t1, ip)
if tlvs[0].error == 0:
print "LAMP set to ", led, "%"
else:
print "LAMP Set error", tlvs[0].error
except socket.timeout:
print "LAMP No response from node", ip
ws.sendMessage(json.dumps({"error":"No response from node " + ip}))
def tlvled(ws, ip, led):
de = ws.get_device_manager().get_device(ip)
if de and de.leds_instance:
t1 = tlvlib.create_set_tlv32(de.leds_instance, tlvlib.VARIABLE_LED_TOGGLE, 1 << int(led))
try:
enc, tlvs = tlvlib.send_tlv(t1, ip)
if tlvs[0].error == 0:
print "LED ", led, " toggle."
else:
print "LED Set error", tlvs[0].error
except socket.timeout:
print "LED No response from node", ip
ws.sendMessage(json.dumps({"error":"No response from node " + ip}))
def get_nbr_info(ws):
global device_manager
info = {}
t1 = tlvlib.create_get_tlv64(0, tlvlib.VARIABLE_UNIT_BOOT_TIMER)
t2 = tlvlib.create_get_tlv128(0, tlvlib.VARIABLE_SW_REVISION)
t3 = tlvlib.create_get_tlv256(device_manager.brm_instance, 0x101)
enc, tlvs = tlvlib.send_tlv([t1,t2,t3], "localhost")
info['BootedAt'] = tlvlib.get_start_ieee64_time_as_string(tlvs[0].int_value)
info['Uptime'] = tlvlib.convert_ieee64_time_to_string(tlvs[0].int_value)
info['BorderRouterSW'] = tlvlib.convert_string(tlvs[1].value)
info['SerialInterface'] = "/dev/" + tlvlib.convert_string(tlvs[2].value)
t1 = tlvlib.create_get_tlv32(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_PAN_ID)
t2 = tlvlib.create_get_tlv32(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_CHANNEL)
t3 = tlvlib.create_get_tlv128(device_manager.brm_instance, 0x105)
enc, tlvs = tlvlib.send_tlv([t1,t2,t3], "localhost")
info['PanID'] = "0x%04x"%tlvs[0].int_value
info['Channel'] = tlvs[1].int_value
info['SerialRadioSW'] = tlvlib.convert_string(tlvs[2].value)
ws.sendMessage(json.dumps(info))
def get_nbr_info(ws):
global device_manager
info = {}
t1 = tlvlib.create_get_tlv64(0, tlvlib.VARIABLE_UNIT_BOOT_TIMER)
t2 = tlvlib.create_get_tlv128(0, tlvlib.VARIABLE_SW_REVISION)
t3 = tlvlib.create_get_tlv256(device_manager.brm_instance, 0x101)
enc, tlvs = tlvlib.send_tlv([t1, t2, t3], "localhost")
info['BootedAt'] = tlvlib.get_start_ieee64_time_as_string(
tlvs[0].int_value)
info['Uptime'] = tlvlib.convert_ieee64_time_to_string(tlvs[0].int_value)
info['BorderRouterSW'] = tlvlib.convert_string(tlvs[1].value)
info['SerialInterface'] = "/dev/" + tlvlib.convert_string(tlvs[2].value)
t1 = tlvlib.create_get_tlv32(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_PAN_ID)
t2 = tlvlib.create_get_tlv32(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_CHANNEL)
t3 = tlvlib.create_get_tlv128(device_manager.brm_instance, 0x105)
enc, tlvs = tlvlib.send_tlv([t1, t2, t3], "localhost")
info['PanID'] = "0x%04x" % tlvs[0].int_value
info['Channel'] = tlvs[1].int_value
info['SerialRadioSW'] = tlvlib.convert_string(tlvs[2].value)
ws.sendMessage(json.dumps(info))
def tlvled(ws, ip, led):
de = ws.get_device_manager().get_device(ip)
if de and de.leds_instance:
t1 = tlvlib.create_set_tlv32(de.leds_instance,
tlvlib.VARIABLE_LED_TOGGLE, 1 << int(led))
try:
enc, tlvs = tlvlib.send_tlv(t1, ip)
if tlvs[0].error == 0:
print "LED ", led, " toggle."
else:
print "LED Set error", tlvs[0].error
except socket.timeout:
print "LED No response from node", ip
ws.sendMessage(json.dumps({"error":
"No response from node " + ip}))
def set_channel(ws, channel):
global device_manager
channel = int(channel)
if channel >= 11 and channel <= 26:
tlv = tlvlib.create_set_tlv(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_CHANNEL,
tlvlib.SIZE32, struct.pack("!L", channel))
enc, tlvs = tlvlib.send_tlv([tlv], "localhost")
print "channel set to:", channel
send_response(ws, "Channel set to: " + str(channel))
# Update table
get_nbr_info(ws)
else:
print "Error trying to set channel to:" + str(channel)
send_error(ws, "Illegal channel: " + str(channel))
def tlvlamp(ws, ip, led):
de = ws.get_device_manager().get_device(ip)
if de and de.lamp_instance:
t1 = tlvlib.create_set_tlv32(de.lamp_instance,
tlvlib.VARIABLE_LAMP_CONTROL,
float(led) / 100.0 * 0xffffffffL)
try:
enc, tlvs = tlvlib.send_tlv(t1, ip)
if tlvs[0].error == 0:
print "LAMP set to ", led, "%"
else:
print "LAMP Set error", tlvs[0].error
except socket.timeout:
print "LAMP No response from node", ip
ws.sendMessage(json.dumps({"error":
"No response from node " + ip}))
def set_channel(ws, channel):
global device_manager
channel = int(channel)
if channel >= 11 and channel <= 26:
tlv = tlvlib.create_set_tlv(device_manager.radio_instance,
tlvlib.VARIABLE_RADIO_CHANNEL,
tlvlib.SIZE32, struct.pack("!L", channel))
enc, tlvs = tlvlib.send_tlv([tlv], "localhost")
print "channel set to:", channel
send_response(ws, "Channel set to: " + str(channel))
# Update table
get_nbr_info(ws)
else:
print "Error trying to set channel to:" + str(channel)
send_error(ws, "Illegal channel: " + str(channel))
def send_upgrade(segment, size, instance, host, port):
print "Upgrading ", segment[0] + 1, instance, len(
segment[1]), " at ", segment[0] * size, "\b" * 35,
sys.stdout.flush()
t1 = tlvlib.create_set_tlv32(instance, tlvlib.VARIABLE_WRITE_CONTROL,
tlvlib.FLASH_WRITE_CONTROL_WRITE_ENABLE)
t2 = tlvlib.create_set_vector_tlv(instance, tlvlib.VARIABLE_FLASH,
tlvlib.SIZE32, segment[0] * size / 4,
len(segment[1]) / 4, segment[1])
try:
enc, tlvs = tlvlib.send_tlv([t1, t2], host, port, 1.5)
if enc.error != 0 or tlvs[0].error != 0 or tlvs[1].error != 0:
print
print "ERROR: failed to write image segment"
return False
except socket.timeout:
return False
return True
def tlvtemp(ws, ip):
de = ws.get_device_manager().get_device(ip)
if de:
instance = de.get_instance(tlvlib.INSTANCE_TEMP_GENERIC)
if instance:
t1 = tlvlib.create_get_tlv32(instance, tlvlib.VARIABLE_TEMPERATURE)
try:
enc, tlvs = tlvlib.send_tlv(t1, ip)
if tlvs[0].error == 0:
temperature = tlvs[0].int_value
if temperature > 100000:
temperature = round((temperature - 273150) / 1000.0, 2)
print "\tTemperature:",temperature,"(C)"
ws.sendMessage(json.dumps({"temp":temperature,"address":ip}))
else:
print "\tTemperature error", tlvs[0].error
except socket.timeout:
print "Temperature - no response from node", ip
ws.sendMessage(json.dumps({"error":"No response from node " + ip}))
def tlvtemp(ws, ip):
de = ws.get_device_manager().get_device(ip)
if de:
instance = de.get_instance(tlvlib.INSTANCE_TEMP_GENERIC)
if instance:
t1 = tlvlib.create_get_tlv32(instance, tlvlib.VARIABLE_TEMPERATURE)
try:
enc, tlvs = tlvlib.send_tlv(t1, ip)
if tlvs[0].error == 0:
temperature = tlvs[0].int_value
if temperature > 100000:
temperature = round((temperature - 273150) / 1000.0, 2)
print "\tTemperature:", temperature, "(C)"
ws.sendMessage(
json.dumps({
"temp": temperature,
"address": ip
}))
else:
print "\tTemperature error", tlvs[0].error
except socket.timeout:
print "Temperature - no response from node", ip
ws.sendMessage(
json.dumps({"error": "No response from node " + ip}))
def setup(self):
# discover and - if it is a NBR then find serial radio and configure the
# beacons to something good!
d = tlvlib.discovery(self.router_host)
print "Product label:", d[0][0]
if d[0][1] != tlvlib.INSTANCE_BORDER_ROUTER:
print "Error - could not find the radio - not starting the device server"
return False
i = 1
for data in d[1]:
print "Instance:",i , " type: %016x"%data[0], " ", data[1]
# check for radio and if found - configure beacons
if data[0] == tlvlib.INSTANCE_RADIO:
self.radio_instance = i
elif data[0] == tlvlib.INSTANCE_ROUTER:
self.router_instance = i
t = tlvlib.create_get_tlv(i, tlvlib.VARIABLE_NETWORK_ADDRESS, 2)
enc, t = tlvlib.send_tlv(t, self.router_host)
self.router_address = socket.inet_ntop(socket.AF_INET6, t[0].value)
print "\tRouter address:", self.router_address
self.router_prefix = socket.inet_ntop(socket.AF_INET6, t[0].value[0:8] + binascii.unhexlify("0000000000000000"))
#while self.router_prefix.endswith("::"):
# self.router_prefix = self.router_prefix[0:len(self.router_prefix) - 1]
print "\tNetwork prefix:",self.router_prefix
if self.device_server_host:
self.udp_address = self.device_server_host
else:
self.udp_address = self._lookup_device_host(self.router_prefix, socket.inet_ntop(socket.AF_INET6, t[0].value[0:8] + binascii.unhexlify("0000000000000001")))
print "\tNetwork address:",self.udp_address
elif data[0] == tlvlib.INSTANCE_BORDER_ROUTER_MANAGEMENT:
self.brm_instance = i
elif data[0] == tlvlib.INSTANCE_NETWORK_STATISTICS:
self.nstats_instance = i
i = i + 1
if not self.radio_instance:
print "Error - could not find the radio instance - not starting the device server"
return False
if not self.router_instance:
print "Error - could not find the router instance - not starting the device server"
return False
# Setup socket to make sure it is possible to bind the address
try:
self._sock = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._sock.bind((self.udp_address, self.udp_port))
#self._sock.bind(('', self.udp_port))
self._sock.settimeout(1.0)
self._sock4 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self._sock4.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._sock4.bind(('localhost', self.udp_port))
self._sock4.settimeout(1.0)
except Exception as e:
print e
print "Error - could not bind to the address", self.udp_address
return False
# set radio channel and panid
self.set_channel_panid()
# set-up beacon to ...
IPv6Str = binascii.hexlify(socket.inet_pton(socket.AF_INET6, self.udp_address))
BEACON = "fe02010a020090da01%08x"%self.location + "18020090da03" + IPv6Str + "%4x"%self.udp_port + "000000"
beacon_payload = binascii.unhexlify(BEACON)
print "Setting beacon with length",len(beacon_payload),"in instance", self.radio_instance
print "\t",BEACON
t = tlvlib.create_set_vector_tlv(self.radio_instance,
tlvlib.VARIABLE_RADIO_BEACON_RESPONSE,
0, 0, len(beacon_payload) / 4,
beacon_payload)
enc, t = tlvlib.send_tlv(t, self.router_host)
# print "Result:"
# tlvlib.print_tlv(t[0])
return True
def set_location(self, address, location):
self.log.debug("[%s] Setting location to %d", address, location)
t = tlvlib.create_set_tlv32(0, tlvlib.VARIABLE_LOCATION_ID, location)
enc,tlvs = tlvlib.send_tlv(t, address)
return tlvs
def get_image_status(instance, host, port):
t = tlvlib.create_get_tlv32(instance, tlvlib.VARIABLE_IMAGE_STATUS)
enc, tlvs = tlvlib.send_tlv(t, host, port)
if tlvs[0].error == 0:
return tlvs[0].int_value
return None
if len(sys.argv) > arg:
instance = int(sys.argv[arg])
d = tlvlib.discovery(host)
print "Product label:", d[0][0], " type: %016x" % d[0][1], " instances:", len(
d[1])
print "Booted at:", tlvlib.get_start_ieee64_time_as_string(
d[0][2]), "-", tlvlib.convert_ieee64_time_to_string(d[0][2])
if verbose and instance <= 0:
t1 = tlvlib.create_get_tlv128(0, tlvlib.VARIABLE_SW_REVISION)
t2 = tlvlib.create_get_tlv32(0, tlvlib.VARIABLE_BOOTLOADER_VERSION)
t3 = tlvlib.create_get_tlv64(0, tlvlib.VARIABLE_CHASSIS_CAPABILITIES)
t4 = tlvlib.create_get_tlv32(0, tlvlib.VARIABLE_RESET_CAUSE)
enc, tlvs = tlvlib.send_tlv([t1, t2, t3, t4], host, show_error=False)
revision = ""
if tlvs[3].error == 0:
print "Last reset cause:", tlvlib.get_reset_cause_as_string(
tlvs[3].int_value)
if tlvs[0].error == 0:
revision += "SW revision: " + tlvlib.convert_string(tlvs[0].value)
if tlvs[1].error == 0:
revision += "\tBootloader: " + str(tlvs[1].int_value)
if tlvs[2].error == 0:
revision += " Cap.: %016x" % tlvs[2].int_value
if revision != "":
print revision
if verbose and instance == 0:
t0 = tlvlib.create_get_tlv32(0, tlvlib.VARIABLE_LOCATION_ID)
producttype = "%016x" % d[0][1]
print "---- Upgrading ----"
print "Product label:", d[0][0], " type:", producttype, "instances:", len(d[1])
print "Booted at:", tlvlib.get_start_ieee64_time_as_string(
d[0][2]), "-", tlvlib.convert_ieee64_time_to_string(d[0][2])
i = 1
upgrade = 0
for data in d[1]:
if data[0] == tlvlib.INSTANCE_IMAGE:
print "Instance " + str(
data[2]) + ": type: %016x" % data[0], " ", data[1]
t1 = tlvlib.create_get_tlv64(i, tlvlib.VARIABLE_IMAGE_VERSION)
t2 = tlvlib.create_get_tlv32(i, tlvlib.VARIABLE_IMAGE_STATUS)
t3 = tlvlib.create_get_tlv64(i, tlvlib.VARIABLE_IMAGE_TYPE)
enc, tlvs = tlvlib.send_tlv([t1, t2, t3], host, port)
tlv = tlvs[0]
tlvstatus = tlvs[1]
tlvtype = tlvs[2]
print "\tVersion: %016x" % tlv.int_value, " ", tlvlib.parse_image_version(
tlv.int_value), "inc:", str(tlv.int_value & 0x1f)
print "\tImage Type: %016x" % tlvtype.int_value, " Status:", tlvlib.get_image_status_as_string(
tlvstatus.int_value)
if (tlvstatus.int_value & tlvlib.IMAGE_STATUS_ACTIVE) == 0:
upgrade = i
label = data[1]
upgrade_status = tlvstatus.int_value
upgrade_version = tlv.int_value
upgrade_type = binascii.hexlify(tlvtype.value)
if label == "Primary firmware":
upgrade_image = 1
import tlvlib, sys, struct, socket, binascii
if len(sys.argv) < 2:
print "Usage ", sys.argv[0], " <host> <intensity in percent>"
exit(1)
host = sys.argv[1]
p = float(sys.argv[2])
if p > 100:
print "Too high value 0 - 100"
exit(1)
print "Setting lamp to ", p
d = tlvlib.discovery(host)
i = 1
for data in d[1]:
if data[0] == tlvlib.INSTANCE_LAMP:
print "Found LAMP instnace, setting intensity."
t1 = tlvlib.create_set_tlv32(i, 0x100, (p * 0.01) * 0xffffffff)
enc,tlvs = tlvlib.send_tlv([t1], host)
i = i + 1
instance = tlvlib.find_instance_with_type(host, tlvlib.INSTANCE_LEDS_GENERIC, verbose)
if not instance:
print "Could not find a leds instance in", host
exit()
ts = []
# Control leds via bit mask (only on/off)
if op is not None:
if led is not None:
t = tlvlib.create_set_tlv32(instance, op, led)
ts.append(t)
t = tlvlib.create_get_tlv32(instance, tlvlib.VARIABLE_LED_CONTROL)
ts.append(t)
enc,tlvs = tlvlib.send_tlv(ts, host)
t = tlvs[len(tlvs) - 1]
if t.error == 0:
print "Current leds:",bin(t.int_value)
exit()
# Control leds via states (supports multicolor leds)
VARIABLE_LED_STATE = 0x105
if state is not None:
t = tlvlib.create_set_vector_tlv(instance, VARIABLE_LED_STATE,
tlvlib.SIZE32, led - 1, 1,
struct.pack("!L", state))
ts.append(t)
if led is not None:
t = tlvlib.create_get_vector_tlv(instance, VARIABLE_LED_STATE,
print "HOST: ", host
arg += 1
if len(sys.argv) > arg:
instance = int(sys.argv[arg])
d = tlvlib.discovery(host)
print "Product label:", d[0][0], " type: %016x"%d[0][1], " instances:", len(d[1])
print "Booted at:",tlvlib.get_start_ieee64_time_as_string(d[0][2]),"-",tlvlib.convert_ieee64_time_to_string(d[0][2])
if verbose and instance <= 0:
t1 = tlvlib.create_get_tlv128(0, tlvlib.VARIABLE_SW_REVISION)
t2 = tlvlib.create_get_tlv32(0, tlvlib.VARIABLE_BOOTLOADER_VERSION)
t3 = tlvlib.create_get_tlv64(0, tlvlib.VARIABLE_CHASSIS_CAPABILITIES)
t4 = tlvlib.create_get_tlv32(0, tlvlib.VARIABLE_RESET_CAUSE)
enc, tlvs = tlvlib.send_tlv([t1,t2,t3,t4], host, show_error=False)
revision = ""
if tlvs[3].error == 0:
print "Last reset cause:", tlvlib.get_reset_cause_as_string(tlvs[3].int_value)
if tlvs[0].error == 0:
revision += "SW revision: " + tlvlib.convert_string(tlvs[0].value)
if tlvs[1].error == 0:
revision += "\tBootloader: " + str(tlvs[1].int_value)
if tlvs[2].error == 0:
revision += " Cap.: %016x"%tlvs[2].int_value
if revision != "":
print revision
if verbose and instance == 0:
t0 = tlvlib.create_get_tlv32(0, tlvlib.VARIABLE_LOCATION_ID)
enc,tlvs = tlvlib.send_tlv(t0, host, show_error=False)
instance = tlvlib.find_instance_with_type(host, tlvlib.INSTANCE_LEDS_GENERIC,
verbose)
if not instance:
print "Could not find a leds instance in", host
exit()
ts = []
# Control leds via bit mask (only on/off)
if op is not None:
if led is not None:
t = tlvlib.create_set_tlv32(instance, op, led)
ts.append(t)
t = tlvlib.create_get_tlv32(instance, tlvlib.VARIABLE_LED_CONTROL)
ts.append(t)
enc, tlvs = tlvlib.send_tlv(ts, host)
t = tlvs[len(tlvs) - 1]
if t.error == 0:
print "Current leds:", bin(t.int_value)
exit()
# Control leds via states (supports multicolor leds)
VARIABLE_LED_STATE = 0x105
if state is not None:
t = tlvlib.create_set_vector_tlv(instance, VARIABLE_LED_STATE,
tlvlib.SIZE32, led - 1, 1,
struct.pack("!L", state))
ts.append(t)
if led is not None:
t = tlvlib.create_get_vector_tlv(instance, VARIABLE_LED_STATE,
