def __init__(self, device=None, datasource=None, gps=None): ''' Instantiates the KillerBee class. @type device: String @param device: Device identifier, either USB vendor:product, serial device node, or IP address @type datasource: String @param datasource: A known datasource type that is used by dblog to record how the data was captured. @type gps: String @param gps: Optional serial device identifier for an attached GPS unit. If provided, or if global variable has previously been set, KillerBee skips that device in initalization process. @return: None @rtype: None ''' global gps_devstring if gps_devstring is None and gps is not None: gps_devstring = gps self.dev = None self.__bus = None self.driver = None # IP devices may be the most straightforward, and we aren't doing # discovery, just connecting to defined addresses, so we'll check # first to see if we have an IP address given as our device parameter. if (device is not None) and kbutils.isIpAddr(device): from dev_sewio import isSewio if isSewio(device): from dev_sewio import SEWIO self.driver = SEWIO(dev=device) #give it the ip address else: del isSewio # Figure out a device is one is not set, trying USB devices next if self.driver is None: if device is None: result = kbutils.search_usb(None) if result != None: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: #TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result # Recognize if device is provided in the USB format (like a 012:456 string): elif ":" in device: result = kbutils.search_usb(device) if result == None: raise KBInterfaceError( "Did not find a USB device matching %s." % device) else: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: #TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result if self.dev is not None: if self.__device_is(RZ_USB_VEND_ID, RZ_USB_PROD_ID): from dev_rzusbstick import RZUSBSTICK self.driver = RZUSBSTICK(self.dev, self.__bus) elif self.__device_is(ZN_USB_VEND_ID, ZN_USB_PROD_ID): raise KBInterfaceError( "Zena firmware not yet implemented.") else: raise KBInterfaceError( "KillerBee doesn't know how to interact with USB device vendor=%04x, product=%04x." .format(self.dev.idVendor, self.dev.idProduct)) # Figure out a device from serial if one is not set #TODO be able to try more than one serial device here (merge with devlist code somehow) # if device == None: # seriallist = get_serial_ports() # if len(seriallist) > 0: # device = seriallist[0] # If a USB device driver was not loaded, now we try serial devices if self.driver is None: # If no device was specified if device is None: glob_list = get_serial_ports() if len(glob_list) > 0: #TODO be able to check other devices if this one is not correct device = glob_list[0] # Recognize if device specified by serial string: if (device is not None) and kbutils.isSerialDeviceString(device): self.dev = device if (self.dev == gps_devstring): pass elif (DEV_ENABLE_ZIGDUINO and kbutils.iszigduino(self.dev)): from dev_zigduino import ZIGDUINO self.driver = ZIGDUINO(self.dev) elif (DEV_ENABLE_FREAKDUINO and kbutils.isfreakduino(self.dev)): from dev_freakduino import FREAKDUINO self.driver = FREAKDUINO(self.dev) else: gfccspi, subtype = isgoodfetccspi(self.dev) if gfccspi and subtype == 0: from dev_telosb import TELOSB self.driver = TELOSB(self.dev) elif gfccspi and subtype == 1: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=1) elif gfccspi and subtype == 2: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=2) else: raise KBInterfaceError( "KillerBee doesn't know how to interact with serial device at '%s'." % self.dev) # Otherwise unrecognized device string type was provided: else: raise KBInterfaceError( "KillerBee doesn't understand device given by '%s'." % device) # Start a connection to the remote packet logging server, if able: if datasource is not None: try: import dblog self.dblog = dblog.DBLogger(datasource) except Exception as e: warn("Error initializing DBLogger (%s)." % e) datasource = None #give up nicely if error connecting, etc.
def __init__(self, device=None, datasource=None, gps=None): """ Instantiates the KillerBee class. @type device: String @param device: Device identifier, either USB vendor:product, serial device node, or IP address @type datasource: String @param datasource: A known datasource type that is used by dblog to record how the data was captured. @type gps: String @param gps: Optional serial device identifier for an attached GPS unit. If provided, or if global variable has previously been set, KillerBee skips that device in initalization process. @return: None @rtype: None """ global gps_devstring if gps_devstring is None and gps is not None: gps_devstring = gps self.dev = None self.__bus = None self.driver = None # IP devices may be the most straightforward, and we aren't doing # discovery, just connecting to defined addresses, so we'll check # first to see if we have an IP address given as our device parameter. if (device is not None) and kbutils.isIpAddr(device): from dev_sewio import isSewio if isSewio(device): from dev_sewio import SEWIO self.driver = SEWIO(dev=device) # give it the ip address else: del isSewio # Figure out a device is one is not set, trying USB devices next if self.driver is None: if device is None: result = kbutils.search_usb(None) if result != None: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: # TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result # Recognize if device is provided in the USB format (like a 012:456 string): elif ":" in device: result = kbutils.search_usb(device) if result == None: raise KBInterfaceError("Did not find a USB device matching %s." % device) else: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: # TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result if self.dev is not None: if self.__device_is(RZ_USB_VEND_ID, RZ_USB_PROD_ID): from dev_rzusbstick import RZUSBSTICK self.driver = RZUSBSTICK(self.dev, self.__bus) elif self.__device_is(ZN_USB_VEND_ID, ZN_USB_PROD_ID): raise KBInterfaceError("Zena firmware not yet implemented.") else: raise KBInterfaceError( "KillerBee doesn't know how to interact with USB device vendor=%04x, product=%04x.".format( self.dev.idVendor, self.dev.idProduct ) ) # Figure out a device from serial if one is not set # TODO be able to try more than one serial device here (merge with devlist code somehow) # if device == None: # seriallist = get_serial_ports() # if len(seriallist) > 0: # device = seriallist[0] # If a USB device driver was not loaded, now we try serial devices if self.driver is None: # If no device was specified if device is None: glob_list = get_serial_ports() if len(glob_list) > 0: # TODO be able to check other devices if this one is not correct device = glob_list[0] # Recognize if device specified by serial string: if (device is not None) and kbutils.isSerialDeviceString(device): self.dev = device if self.dev == gps_devstring: pass elif DEV_ENABLE_ZIGDUINO and kbutils.iszigduino(self.dev): from dev_zigduino import ZIGDUINO self.driver = ZIGDUINO(self.dev) elif DEV_ENABLE_FREAKDUINO and kbutils.isfreakduino(self.dev): from dev_freakduino import FREAKDUINO self.driver = FREAKDUINO(self.dev) else: gfccspi, subtype = isgoodfetccspi(self.dev) if gfccspi and subtype == 0: from dev_telosb import TELOSB self.driver = TELOSB(self.dev) elif gfccspi and subtype == 1: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=1) elif gfccspi and subtype == 2: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=2) else: raise KBInterfaceError( "KillerBee doesn't know how to interact with serial device at '%s'." % self.dev ) # Otherwise unrecognized device string type was provided: else: raise KBInterfaceError("KillerBee doesn't understand device given by '%s'." % device) # Start a connection to the remote packet logging server, if able: if datasource is not None: try: import dblog self.dblog = dblog.DBLogger(datasource) except Exception as e: warn("Error initializing DBLogger (%s)." % e) datasource = None # give up nicely if error connecting, etc.
class KillerBee: def __init__(self, device=None, datasource=None, gps=None): ''' Instantiates the KillerBee class. @type device: String @param device: Device identifier, either USB vendor:product, serial device node, or IP address @type datasource: String @param datasource: A known datasource type that is used by dblog to record how the data was captured. @type gps: String @param gps: Optional serial device identifier for an attached GPS unit. If provided, or if global variable has previously been set, KillerBee skips that device in initalization process. @return: None @rtype: None ''' global gps_devstring if gps_devstring is None and gps is not None: gps_devstring = gps self.dev = None self.__bus = None self.driver = None # IP devices may be the most straightforward, and we aren't doing # discovery, just connecting to defined addresses, so we'll check # first to see if we have an IP address given as our device parameter. if (device is not None) and kbutils.isIpAddr(device): from dev_sewio import isSewio if isSewio(device): from dev_sewio import SEWIO self.driver = SEWIO(dev=device) #give it the ip address else: del isSewio # Figure out a device is one is not set, trying USB devices next if self.driver is None: if device is None: result = kbutils.search_usb(None) if result != None: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: #TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result # Recognize if device is provided in the USB format (like a 012:456 string): elif ":" in device: result = kbutils.search_usb(device) if result == None: raise KBInterfaceError( "Did not find a USB device matching %s." % device) else: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: #TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result if self.dev is not None: if self.__device_is(RZ_USB_VEND_ID, RZ_USB_PROD_ID): from dev_rzusbstick import RZUSBSTICK self.driver = RZUSBSTICK(self.dev, self.__bus) elif self.__device_is(ZN_USB_VEND_ID, ZN_USB_PROD_ID): raise KBInterfaceError( "Zena firmware not yet implemented.") else: raise KBInterfaceError( "KillerBee doesn't know how to interact with USB device vendor=%04x, product=%04x." .format(self.dev.idVendor, self.dev.idProduct)) # Figure out a device from serial if one is not set #TODO be able to try more than one serial device here (merge with devlist code somehow) # if device == None: # seriallist = get_serial_ports() # if len(seriallist) > 0: # device = seriallist[0] # If a USB device driver was not loaded, now we try serial devices if self.driver is None: # If no device was specified if device is None: glob_list = get_serial_ports() if len(glob_list) > 0: #TODO be able to check other devices if this one is not correct device = glob_list[0] # Recognize if device specified by serial string: if (device is not None) and kbutils.isSerialDeviceString(device): self.dev = device if (self.dev == gps_devstring): pass elif (DEV_ENABLE_ZIGDUINO and kbutils.iszigduino(self.dev)): from dev_zigduino import ZIGDUINO self.driver = ZIGDUINO(self.dev) elif (DEV_ENABLE_FREAKDUINO and kbutils.isfreakduino(self.dev)): from dev_freakduino import FREAKDUINO self.driver = FREAKDUINO(self.dev) else: gfccspi, subtype = isgoodfetccspi(self.dev) if gfccspi and subtype == 0: from dev_telosb import TELOSB self.driver = TELOSB(self.dev) elif gfccspi and subtype == 1: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=1) elif gfccspi and subtype == 2: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=2) else: raise KBInterfaceError( "KillerBee doesn't know how to interact with serial device at '%s'." % self.dev) # Otherwise unrecognized device string type was provided: else: raise KBInterfaceError( "KillerBee doesn't understand device given by '%s'." % device) # Start a connection to the remote packet logging server, if able: if datasource is not None: try: import dblog self.dblog = dblog.DBLogger(datasource) except Exception as e: warn("Error initializing DBLogger (%s)." % e) datasource = None #give up nicely if error connecting, etc. # Allow 'with KillerBee(...) as kb:' syntax def __enter__(self): return self def __exit__(self, *exinfo): self.close() def __device_is(self, vendorId, productId): ''' Compares KillerBee class' device data to a known USB vendorId and productId @type vendorId: @type productId: @rtype: Boolean @return: True if KillerBee class has device matching the vendor and product IDs provided. ''' if self.dev.idVendor == vendorId and self.dev.idProduct == productId: return True else: return False def get_dev_info(self): ''' Returns device information in a list identifying the device. Implemented by the loaded driver. @rtype: List @return: List of 3 strings identifying device. ''' return self.driver.get_dev_info() def close(self): ''' Closes the device out. @return: None @rtype: None ''' if self.driver != None: self.driver.close() if hasattr(self, "dblog") and (self.dblog is not None): self.dblog.close() def check_capability(self, capab): ''' Uses the specified capability to determine if the opened device is supported. Returns True when supported, else False. @rtype: Boolean ''' return self.driver.capabilities.check(capab) def is_valid_channel(self, channel): ''' Use the driver's capabilities class to determine if a requested channel number is within the capabilities of that device. @rtype: Boolean ''' return self.driver.capabilities.is_valid_channel(channel) def get_capabilities(self): ''' Returns a list of capability information for the device. @rtype: List @return: Capability information for the opened device. ''' return self.driver.capabilities.getlist() def sniffer_on(self, channel=None): ''' Turns the sniffer on such that pnext() will start returning observed data. Will set the command mode to Air Capture if it is not already set. @type channel: Integer @param channel: Sets the channel, optional @rtype: None ''' return self.driver.sniffer_on(channel) def sniffer_off(self): ''' Turns the sniffer off, freeing the hardware for other functions. It is not necessary to call this function before closing the interface with close(). @rtype: None ''' return self.driver.sniffer_off() @property def channel(self): """Getter function for the channel that was last set on the device.""" # Driver must have this variable name set in it's set_channel function return self.driver._channel def set_channel(self, channel): ''' Sets the radio interface to the specifid channel. Currently, support is limited to 2.4 GHz channels 11 - 26. @type channel: Integer @param channel: Sets the channel, optional @rtype: None ''' if not self.is_valid_channel(channel): raise ValueError( 'Invalid channel ({0}) for this device'.format(channel)) if hasattr(self, "dblog"): self.dblog.set_channel(channel) self.driver.set_channel(channel) def inject(self, packet, channel=None, count=1, delay=0): ''' Injects the specified packet contents. @type packet: String @param packet: Packet contents to transmit, without FCS. @type channel: Integer @param channel: Sets the channel, optional @type count: Integer @param count: Transmits a specified number of frames, def=1 @type delay: Float @param delay: Delay between each frame, def=1 @rtype: None ''' return self.driver.inject(packet, channel, count, delay) def pnext(self, timeout=100): ''' Returns packet data as a string, else None. @type timeout: Integer @param timeout: Timeout to wait for packet reception in usec @rtype: List @return: Returns None is timeout expires and no packet received. When a packet is received, a list is returned, in the form [ String: packet contents | Bool: Valid CRC | Int: Unscaled RSSI ] ''' return self.driver.pnext(timeout) def jammer_on(self, channel=None): ''' Attempts reflexive jamming on all 802.15.4 frames. Targeted frames must be >12 bytes for reliable jamming in current firmware. @type channel: Integer @param channel: Sets the channel, optional. @rtype: None ''' return self.driver.jammer_on(channel=channel)
class KillerBee: def __init__(self, device=None, datasource=None, gps=None): """ Instantiates the KillerBee class. @type device: String @param device: Device identifier, either USB vendor:product, serial device node, or IP address @type datasource: String @param datasource: A known datasource type that is used by dblog to record how the data was captured. @type gps: String @param gps: Optional serial device identifier for an attached GPS unit. If provided, or if global variable has previously been set, KillerBee skips that device in initalization process. @return: None @rtype: None """ global gps_devstring if gps_devstring is None and gps is not None: gps_devstring = gps self.dev = None self.__bus = None self.driver = None # IP devices may be the most straightforward, and we aren't doing # discovery, just connecting to defined addresses, so we'll check # first to see if we have an IP address given as our device parameter. if (device is not None) and kbutils.isIpAddr(device): from dev_sewio import isSewio if isSewio(device): from dev_sewio import SEWIO self.driver = SEWIO(dev=device) # give it the ip address else: del isSewio # Figure out a device is one is not set, trying USB devices next if self.driver is None: if device is None: result = kbutils.search_usb(None) if result != None: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: # TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result # Recognize if device is provided in the USB format (like a 012:456 string): elif ":" in device: result = kbutils.search_usb(device) if result == None: raise KBInterfaceError("Did not find a USB device matching %s." % device) else: if USBVER == 0: (self.__bus, self.dev) = result elif USBVER == 1: # TODO remove self.__bus attribute, not needed in 1.x as all info in self.dev self.dev = result if self.dev is not None: if self.__device_is(RZ_USB_VEND_ID, RZ_USB_PROD_ID): from dev_rzusbstick import RZUSBSTICK self.driver = RZUSBSTICK(self.dev, self.__bus) elif self.__device_is(ZN_USB_VEND_ID, ZN_USB_PROD_ID): raise KBInterfaceError("Zena firmware not yet implemented.") else: raise KBInterfaceError( "KillerBee doesn't know how to interact with USB device vendor=%04x, product=%04x.".format( self.dev.idVendor, self.dev.idProduct ) ) # Figure out a device from serial if one is not set # TODO be able to try more than one serial device here (merge with devlist code somehow) # if device == None: # seriallist = get_serial_ports() # if len(seriallist) > 0: # device = seriallist[0] # If a USB device driver was not loaded, now we try serial devices if self.driver is None: # If no device was specified if device is None: glob_list = get_serial_ports() if len(glob_list) > 0: # TODO be able to check other devices if this one is not correct device = glob_list[0] # Recognize if device specified by serial string: if (device is not None) and kbutils.isSerialDeviceString(device): self.dev = device if self.dev == gps_devstring: pass elif DEV_ENABLE_ZIGDUINO and kbutils.iszigduino(self.dev): from dev_zigduino import ZIGDUINO self.driver = ZIGDUINO(self.dev) elif DEV_ENABLE_FREAKDUINO and kbutils.isfreakduino(self.dev): from dev_freakduino import FREAKDUINO self.driver = FREAKDUINO(self.dev) else: gfccspi, subtype = isgoodfetccspi(self.dev) if gfccspi and subtype == 0: from dev_telosb import TELOSB self.driver = TELOSB(self.dev) elif gfccspi and subtype == 1: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=1) elif gfccspi and subtype == 2: from dev_apimote import APIMOTE self.driver = APIMOTE(self.dev, revision=2) else: raise KBInterfaceError( "KillerBee doesn't know how to interact with serial device at '%s'." % self.dev ) # Otherwise unrecognized device string type was provided: else: raise KBInterfaceError("KillerBee doesn't understand device given by '%s'." % device) # Start a connection to the remote packet logging server, if able: if datasource is not None: try: import dblog self.dblog = dblog.DBLogger(datasource) except Exception as e: warn("Error initializing DBLogger (%s)." % e) datasource = None # give up nicely if error connecting, etc. def __device_is(self, vendorId, productId): """ Compares KillerBee class' device data to a known USB vendorId and productId @type vendorId: @type productId: @rtype: Boolean @return: True if KillerBee class has device matching the vendor and product IDs provided. """ if self.dev.idVendor == vendorId and self.dev.idProduct == productId: return True else: return False def get_dev_info(self): """ Returns device information in a list identifying the device. Implemented by the loaded driver. @rtype: List @return: List of 3 strings identifying device. """ return self.driver.get_dev_info() def close(self): """ Closes the device out. @return: None @rtype: None """ if self.driver != None: self.driver.close() if hasattr(self, "dblog") and (self.dblog is not None): self.dblog.close() def check_capability(self, capab): """ Uses the specified capability to determine if the opened device is supported. Returns True when supported, else False. @rtype: Boolean """ return self.driver.capabilities.check(capab) def is_valid_channel(self, channel): """ Use the driver's capabilities class to determine if a requested channel number is within the capabilities of that device. @rtype: Boolean """ return self.driver.capabilities.is_valid_channel(channel) def get_capabilities(self): """ Returns a list of capability information for the device. @rtype: List @return: Capability information for the opened device. """ return self.driver.capabilities.getlist() def sniffer_on(self, channel=None): """ Turns the sniffer on such that pnext() will start returning observed data. Will set the command mode to Air Capture if it is not already set. @type channel: Integer @param channel: Sets the channel, optional @rtype: None """ return self.driver.sniffer_on(channel) def sniffer_off(self): """ Turns the sniffer off, freeing the hardware for other functions. It is not necessary to call this function before closing the interface with close(). @rtype: None """ return self.driver.sniffer_off() @property def channel(self): """Getter function for the channel that was last set on the device.""" # Driver must have this variable name set in it's set_channel function return self.driver._channel def set_channel(self, channel): """ Sets the radio interface to the specifid channel. Currently, support is limited to 2.4 GHz channels 11 - 26. @type channel: Integer @param channel: Sets the channel, optional @rtype: None """ if hasattr(self, "dblog"): self.dblog.set_channel(channel) self.driver.set_channel(channel) def is_valid_channel(self, channel): """ Based on sniffer capabilities, return if this is an OK channel number. @rtype: Boolean """ return self.driver.capabilities.is_valid_channel(channel) def inject(self, packet, channel=None, count=1, delay=0): """ Injects the specified packet contents. @type packet: String @param packet: Packet contents to transmit, without FCS. @type channel: Integer @param channel: Sets the channel, optional @type count: Integer @param count: Transmits a specified number of frames, def=1 @type delay: Float @param delay: Delay between each frame, def=1 @rtype: None """ return self.driver.inject(packet, channel, count, delay) def pnext(self, timeout=100): """ Returns packet data as a string, else None. @type timeout: Integer @param timeout: Timeout to wait for packet reception in usec @rtype: List @return: Returns None is timeout expires and no packet received. When a packet is received, a list is returned, in the form [ String: packet contents | Bool: Valid CRC | Int: Unscaled RSSI ] """ return self.driver.pnext(timeout) def jammer_on(self, channel=None): """ Attempts reflexive jamming on all 802.15.4 frames. Targeted frames must be >12 bytes for reliable jamming in current firmware. @type channel: Integer @param channel: Sets the channel, optional. @rtype: None """ return self.driver.jammer_on(channel=channel)