def __init__(self, name, sensor_id, port, baud, trigger_period,
image_filename_prefix, time_source, data_handlers):
'''Save properties for opening serial port later.'''
Sensor.__init__(self, 'canon_mcu', name, sensor_id, time_source,
data_handlers)
self.port = port
self.baud = baud
self.trigger_period = float(trigger_period)
self.image_filename_prefix = image_filename_prefix
self.stop_triggering = False # If true then will stop taking pictures.
self.connection = None
# Command to send to MCU to trigger camera.
self.trigger_command = '\x74' # ascii t
# Last image filename received by camera.
self.last_image_filename = None
# How many dump messages that filename couldn't be extracted from.
self.failed_image_name_parse_count = 0
self.image_count = 0
self.input_stream = '' # data buffer received from MCU that hasn't been used yet
self.max_closing_time = self.trigger_period + 2
def __init__(self, sensorNode):
"""\brief Initializes the class
\param sensorNode (\c SensorNode) A SensorNode object containing
information to instantiate the class with
"""
Sensor.__init__(self, sensorNode)
self.__ipAddress = sensorNode.getInterfaces("infrastructure")[0].getIP()
def __init__(self, buffLen = 11, period = 60, sem = None, on_read = None, nattempts = 3, maxTimeOffset = 15, **kwargs):
## Tamaño del buffer de mediciones
self.buffLen = buffLen
## Periodo de tiempo entre mediciones
self.period = period
## Semáforo i2c para evitar conflictos
self.semI2C = sem
## Buffer de mediciones de voltaje
self.voltBuff = None
## Buffer de mediciones de corriente
self.currBuff = None
## Callback a llamar cada vez que se llenan los buffers de mediciones
self.on_read = on_read
## Argumentos extra a pasar a la función callback
self.kwargs = kwargs
## Cantidad de intentos de lectura por medición
self.nattempts = nattempts
## Último valor de voltaje
self.voltage = None
## Último valor de corriente
self.current = None
## Último valor de potencia
self.power = None
## Cantidad máxima de tiempo extra que puede tardar en tomar todas las muestras
self.maxTimeOffset = maxTimeOffset
#Inicializa hilo
Sensor.__init__(self)
def __init__( self ):
self.streamID = "Environment"
# Specify the STREAM-ID as it's specified in your stream definition on the SeaaS platform
Sensor.__init__(self, self.streamID)
# Copy/Paste from web portal
# Call API to get LATEST stream information .....
self.sensorValue[self.streamID] = {}
#Override if it exists
self.hasCCINdefinition = True
self.stream_def["title"] = self.streamID
self.stream_def["properties"] = {
self.streamID: {
"type": "object",
"properties": {
"temperature": {
"type": "integer"
},
"humidity": {
"type": "integer"
},
"airpressure": {
"type": "integer"
}
},
"additionalProperties": False
}
}
def __init__(self,
sens_dir=None,
sens_id=None,
sens_file=None,
id=None,
label=DS1820_STR,
verbose=False):
Sensor.__init__(self, sens_id, id, label, verbose)
if sens_dir is None or sens_file is None:
if self.verbose:
print 'DBG: CHIP platform detected: {}'.format(
config.chip_platform)
if sens_dir is None:
if config.chip_platform:
sens_dir = config.chip_w1_dir
else:
sens_dir = config.default_w1_dir
if sens_file is None:
if config.chip_platform:
sens_file = config.chip_w1_file
else:
sens_file = config.default_w1_file
if not sens_dir.endswith('/'):
sens_dir += '/'
if self.verbose:
print 'DBG: DS1820 sensor \'{}\': {}{}'.format(
label, sens_dir, sens_id)
self.temperature = self.read_temp(sens_dir, sens_id, sens_file)
def __init__(self, sensorName, mongoServer, mongoPort, mongoDBName,
mongoCollName):
Sensor.__init__(self, sensorName, mongoServer, mongoPort, mongoDBName,
mongoCollName)
self.avValueAtInterval = 0
self.isOld = False
def __init__(self):
Sensor.__init__(self)
self.have_serial = False
try:
self.ser = serial.Serial(port=self.PORT, baudrate=115200, timeout=1)
self.have_serial = True
except:
pass
def __init__(self, source, metric_prefix, output, code, pin, format):
Sensor.__init__(self, source, metric_prefix, output)
if code == 'DHT22':
self.code = Adafruit_DHT.DHT22
else:
self.code = Adafruit_DHT.DHT11
self.pin = pin
self.format = format
self.tag_label = code
def __init__(self, source, metric_prefix, output, code, pin_trigger,
pin_echo, format):
Sensor.__init__(self, source, metric_prefix, output)
self.pin_trigger = pin_trigger
self.pin_echo = pin_echo
self.format = format
self.tag_label = code
self.initPins()
def __init__(self, dataset, datadir='.'):
"""
Initialization.
:param dataset: Filename.
:param datadir: Directory of the file default '.'
"""
self.scans, width = self.load_data(datadir, dataset)
Sensor.__init__(self, width, self.scan_rate_hz, self.viewangle, self.distance_no_detection_mm,
self.detectionMargin, self.offsetMillimeters)
def __init__(self):
"""@todo: to be defined1. """
Sensor.__init__(self)
self.have_sensor = False
try:
self.i2c = Adafruit_I2C(self.I2C_ADDRESS)
self.have_sensor = True
except:
pass
def __init__(self, dataset, datadir='.'):
"""
Initialization.
:param dataset: Filename.
:param datadir: Directory of the file default '.'.
"""
self.scans, width = self.load_data(datadir, dataset)
Sensor.__init__(self, width, self.scan_rate_hz, self.viewangle,
self.distance_no_detection_mm, self.detectionMargin,
self.offsetMillimeters)
def __init__(self, source, metric_prefix, output, code, pin, metric_name):
Sensor.__init__(self, source, metric_prefix, output)
self.pin = pin
self.tag_label = code
self.name = self.metric_prefix + metric_name.lower()
if self.output == 'WF':
self.name = metric_name
if len(self.metric_prefix) > 0:
self.name = self.metric_prefix + '.' + self.name
self.initPins()
def __init__(self, log=True):
self.log = log
if (log):
self.out = open('log', 'w')
self.reader = Reader()
self.width = self.reader.getWidth()
self.height = self.reader.getHeight()
self.row = self.height / 2 # row to read
Sensor.__init__(self, self.width, self.scan_rate_hz, self.viewangle, self.distance_no_detection_mm,
self.detectionMargin, self.offsetMillimeters)
def __init__(self, name, sensor_id, port, baud, time_source, data_handlers):
'''Save properties for opening serial port later.'''
Sensor.__init__(self, 'green_seeker', name, sensor_id, time_source, data_handlers)
self.port = port
self.baud = baud
self.read_timeout = 2
self.stop_reading = False # If true then sensor will stop reading data.
self.connection = None
self.max_closing_time = self.read_timeout + 1
def __init__(self, name, sensor_id, time_source, position_source, data_handlers):
'''Constructor.'''
Sensor.__init__(self, 'position', name, sensor_id, time_source, data_handlers)
self.position_source = position_source
self.stop_passing = False # If true then sensor will passing data to handlers.
self.is_open = False # internally flag to keep track of whether or not sensor is open.
self.last_utc_time = 0 # last position timestamp that was passed onto data handlers.
self.max_closing_time = 3 # seconds
def __init__(self, log=True):
self.log = log
if log:
self.out = open('log', 'w')
self.reader = Reader()
self.width = self.reader.getWidth()
self.height = self.reader.getHeight()
self.row = self.height / 2 # row to read
Sensor.__init__(self, self.width, self.scan_rate_hz, self.viewangle,
self.distance_no_detection_mm, self.detectionMargin,
self.offsetMillimeters)
def __init__(self, param='0', id=None, label=BMP085_STR, verbose=False):
Sensor.__init__(self, param, id, label, verbose)
bus_nb = parse_number(param, 0)
if self.verbose:
print 'DBG: BMP085 sensor \'{}\' bus number {:d}'.format(
label, bus_nb)
bmp = BMP085(busnum=bus_nb)
self.temperature = bmp.read_temperature()
self.pressure = bmp.read_pressure()
self.altitude = bmp.read_altitude()
def __init__(self, name, sensor_id, port, baud, time_source,
data_handlers):
'''Save properties for opening serial port later.'''
Sensor.__init__(self, 'green_seeker', name, sensor_id, time_source,
data_handlers)
self.port = port
self.baud = baud
self.read_timeout = 2
self.stop_reading = False # If true then sensor will stop reading data.
self.connection = None
self.max_closing_time = self.read_timeout + 1
def __init__(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.connection = socket.socket()
self.width = 0
self.scan_rate_hz = 0
self.viewangle = 0
self.distance_no_detection_mm = 0
self.detection_margin = 0
self.offset_millimeters = 0
self.initialize()
Sensor.__init__(self, self.width, self.scan_rate_hz, self.viewangle,
self.distance_no_detection_mm, self.detection_margin, self.offset_millimeters)
def __init__(self, name, sensor_id, time_source, orientation_source,
data_handlers):
'''Constructor.'''
Sensor.__init__(self, 'orientation', name, sensor_id, time_source,
data_handlers)
self.orientation_source = orientation_source
self.stop_passing = False # If true then sensor will passing data to handlers.
self.is_open = False # internally flag to keep track of whether or not sensor is open.
self.last_utc_time = 0 # last orientation timestamp that was passed onto data handlers.
self.max_closing_time = 3 # seconds
def __init__(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.connection = socket.socket()
self.width = 0
self.scan_rate_hz = 0
self.viewangle = 0
self.distance_no_detection_mm = 0
self.detection_margin = 0
self.offset_millimeters = 0
self.initialize()
Sensor.__init__(self, self.width, self.scan_rate_hz, self.viewangle,
self.distance_no_detection_mm, self.detection_margin,
self.offset_millimeters)
def __init__(self, name, sensor_id, port, baud, sample_rate, time_source,
data_handlers):
'''Save properties for opening serial port later.'''
Sensor.__init__(self, 'irt_ue', name, sensor_id, time_source,
data_handlers)
self.port = port
self.baud = baud
self.sample_period = 0.0
if sample_rate != 0.0:
self.sample_period = 1.0 / sample_rate
self.stop_reading = False # If true then sensor will stop reading data.
self.connection = None
self.max_closing_time = self.sample_period + 1
def __init__(self, param='0', id=None, label=HTU21D_STR, verbose=False):
Sensor.__init__(self, param, id, label, verbose)
bus_nb = parse_number(param, 0)
if self.verbose:
print 'DBG: HTU21D sensor \'{}\' bus number {:d}'.format(
label, bus_nb)
self.dev = None
try:
self.dev = I2CSystem(self.__HTU21DF_I2CADDR, bus_nb)
self.__htu_reset()
self.temperature = self.__read_temperature()
self.__htu_reset()
self.humidity = self.__read_humidity(self.temperature)
finally:
if self.dev is not None:
self.dev.close()
def __init__(self, sensor_type='22', pin='4', id=None, label=DHT_STR, verbose=False):
Sensor.__init__(self, pin, id, label, verbose)
self.sensor_type_nb = parse_number(sensor_type, 22)
self.pin = pin
if self.sensor_type_nb == 11:
sensor = Adafruit_DHT.DHT11
elif self.sensor_type_nb == 2302:
sensor = Adafruit_DHT.AM2302
else :
sensor = Adafruit_DHT.DHT22
if self.verbose:
print 'DBG: DHT{} sensor \'{}\' pin {}'.format(
self.sensor_type_nb, label, pin)
self.humidity, self.temperature = Adafruit_DHT.read_retry(sensor, pin)
if self.verbose:
print 'DBG: Temperature = {:.2f} °C'.format(self.temperature)
print 'DBG: Humidity = {:.2f} %'.format(self.humidity)
def __init__(self, bezeichnung, status=0):
Sensor.__init__(self, bezeichnung, status)
def __init__(self, logger=None):
Sensor.__init__(self, self.name, logger)
self.bmp = BMP085(0x77, 1)
self.initSMBus()
def __init__(self, m2mContainerId, streamName):
Sensor.__init__(self, streamName)
self.m2mContainerId = m2mContainerId
self.sensorValue["value"] = None
self.stream_def["title"] = streamName
self.stream_def["properties"] = {"value": {"type": "boolean"}}
def __init__(self,sensorName, mongoServer, mongoPort, mongoDBName, mongoCollName,t_evidence,t_sample,maxSystemEntr):
Sensor.__init__(self,sensorName, mongoServer, mongoPort, mongoDBName, mongoCollName,t_evidence,t_sample,maxSystemEntr)
self.avValueAtInterval = float('nan')
self.avValue= float('nan')
self.isOld = False
self.prob=0
def __init__(self, serialPath, serialBaud, logger=None):
Sensor.__init__(self, self.name, logger)
self.serialPath = serialPath
self.serialBaud = serialBaud
self.connect()
def __init__( self ):
streamName = self.__class__.__name__
Sensor.__init__(self, streamName)
self.hasCCINdefinition = True
self.binaryMeterValue = None
def __init__(self, datasource, rangeInMeters, maxVal):
Sensor.__init__(self, datasource)
self.rangeInMeters = rangeInMeters
self.maxVal = maxVal
def __init__(self, name):
Sensor.__init__(self, name)
self.update()
def __init__(self, env, parent, range, shouldDraw=False): Sensor.__init__(self, env, parent, shouldDraw) self.range = range
def __init__(self, log = True):
self.log = log #Whether information should be saved in a log file
#if(log):
# self.out = open('log', 'w')
self.sensor = nr.NeatoReader()
Sensor.__init__(self, self.width, self.scan_rate_hz, self.viewangle, self.distance_no_detection_mm, self.detectionMargin, self.offsetMillimeters)
def __init__(self, datasource):
Sensor.__init__(self, datasource)
def __init__(self, source, metric_prefix, output):
Sensor.__init__(self, source, metric_prefix, output)
def __init__(self):
streamName = self.__class__.__name__
Sensor.__init__(self, streamName)
self.hasCCINdefinition = True
self.binaryMeterValue = None
def __init__( self, m2mContainerId, streamName ):
Sensor.__init__(self, streamName)
self.m2mContainerId = m2mContainerId
self.sensorValue["value"] = None
self.stream_def["title"] = streamName
self.stream_def["properties"]={"value":{"type":"boolean"}}
def __init__(self, pin, logger=None): Sensor.__init__(self, self.name, logger) self.pin = pin self.connect()
def __init__(self):
Sensor.__init__(self)
ADC.setup()
def __init__(self):
Sensor.__init__(self, 'TestSensor')
self.value = 0
def __init__(self):
"""@todo: to be defined1. """
Sensor.__init__(self)
self.i = 0
self.clip = 100.
def __init__(self, name=None, sensor=None, speed=1):
if not name and sensor:
name = sensor.name + "_speed"
Sensor.__init__(self, name=name)
self.sensor = deepcopy(sensor)
def __init__(self):
'''
Constructor
'''
Sensor.__init__(self)
def __init__(self):
'''
Constructor
'''
Sensor.__init__(self)
def __init__(self, name, admin_in, admin_out, sensor_spec, sensors_dir,
sensor_in, store, swarm):
threading.Thread.__init__(self)
#self.config = config
self.sensor_in = sensor_in
self.store = store
self.swarm = swarm
self.name = name
self.brain_available = False
threading.Thread.__init__(self)
Sensor.__init__(self,
name=name,
admin_in=admin_in,
admin_out=admin_out,
sensor_spec=sensor_spec,
sensors_dir=sensors_dir)
swarm_config_path = sensors_dir + sensor_in + '/stores/' + store + '/swarms/' + swarm + '/'
#store_path = sensors_dir + sensor_in +'/stores/' + store + '/out.csv'
#model = ModelFactory.loadFromCheckpoint('/home/hans/cortical_one_var/sensors/cpu/stores/store_3/swarms/swarm_1/model_save')
print swarm_config_path
#load original swarm config file
with open(swarm_config_path + 'swarm_config.json') as json_file:
self.swarm_config = json.load(json_file)
print(self.swarm_config)
self.swarm_config_ng = SwarmConfig(self.swarm_config)
print self.swarm_config_ng.get_predicted_field()
#if there is a 'brain', then tae the existing brain
self.possible_brain_path = str(swarm_config_path + 'model_save')
if os.path.exists(self.possible_brain_path):
possible_brain_2 = '/home/hans/cortical_one_var/sensors/cpu/stores/store_3/swarms/swarm_1/model_save'
print "load existing brain..."
print self.possible_brain_path
#model = ModelFactory.loadFromCheckpoint(possible_brain_2)
model = ModelFactory.loadFromCheckpoint(self.possible_brain_path)
#use this case to add the availabilty of a 'brain' (???!!!) to your annuncement
else:
#laod model configuration
model = ModelFactory.create(
getModelParamsFromFileNG(swarm_config_path))
#configure prediction
model.enableInference(
{"predictedField": self.swarm_config_ng.get_predicted_field()})
self.connection_sensor_in = stomp.Connection()
self.connection_sensor_in.set_listener(
name=self.name,
lstnr=AbstractSensorListener(self.name,
topic='/topic/' + self.sensor_in,
config=self.swarm_config_ng,
model=model))
self.connection_sensor_in.start()
self.connection_sensor_in.connect(self.user, self.password, wait=True)
#self.connection_sensor_in.connect('admin', 'password', wait=True)
self.abstract_listener = self.connection_sensor_in.get_listener(
name=self.name)
self.connection_sensor_in.subscribe(destination='/topic/' +
self.sensor_in,
id=2,
ack='auto')
self.values = []
self.self_announcement()
