Beispiel #1
0
def pystream_single(args, unk):
    iparser = instalparser.makeInstalParser()
    iparser.instal_input = open(args.input_files[0], "r")
    if args.output_file:
        iparser.instal_output = open(args.output_file, "w")
    iparser.mode = "default"
    idocument = ""
    idocument = idocument + iparser.instal_input.read(-1)
    iparser.instal_parse(idocument)
    if args.domain_file:
        iparser.print_domain(args.domain_file)
    iparser.instal_print_all()
    iparser.instal_input.close()
    if args.output_file:
        iparser.instal_output.close()
    ##### start of multi-shot solving cycle
    if args.output_file and args.fact_file:
        institution = ["externals.lp", "time.lp", args.output_file]
        initial_state = open(args.fact_file, "r").readlines()
        print(initial_state)
        sensor = Sensor(iparser, dummy, initial_state, institution, args)
        # print("initially:")
        # for i in initial_state:
        #     print(i.name(),i.args())
        # print("events from:",args.event_file)
        # with open(args.event_file,'r') as events:
        #     for e in events:
        for event in fileinput.input(unk):
            sensor.solve(event)
Beispiel #2
0
 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
                                     }
                                   }
Beispiel #3
0
 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()
Beispiel #4
0
def main(argv):

    config_file = None
   
    try:
        opts, args = getopt.getopt(argv,"hc:",["cfgfile="])
    except getopt.GetoptError:
        print 'repository.py -c <cfgfile>'
        sys.exit(2)

    for opt, arg in opts:
        if opt == '-h':
            print 'repository.py -c <cfgfile>'
            sys.exit()
        elif opt in ("-c", "--cfgfile"):
            config_file = arg
        
    if config_file is None:
        print 'repository.py -c <cfgfile>'
        sys.exit(2)

    repository = Repository(config_file)
    
    sensor = Sensor('ground', config_file)
    readings = sensor.get_readings()

    if readings is not None:
        s=json.dumps(readings, sort_keys=True, indent=4, separators=(',', ': '))
        print s
        repository.save_readings(readings)
Beispiel #5
0
def main():
    global sensor
    sensor = Sensor()
    try:
        sensor.connect()
    except:
        print("Error connecting to sensor")
        raise
        return

    #cv.namedWindow("Threshold", cv.WINDOW_AUTOSIZE);
    cv.namedWindow("Contours", cv.WINDOW_AUTOSIZE);
    nfunc = np.vectorize(normalize)
    images = get_next_image()
    baseline_frame = images[-1]
    baseline = baseline_frame['image']
    width = baseline_frame['cols']
    height = baseline_frame['rows']
    while 1:
        images = get_next_image();
        frame = images[-1]
        pixels = np.array(frame['image'])
        pixels_zeroed = np.subtract(baseline, pixels);
        min = np.amin(pixels_zeroed)
        max = np.amax(pixels_zeroed)
        pixels_normalized = nfunc(pixels_zeroed, min, max)
        large = sp.ndimage.zoom(pixels_normalized, 10, order=1)
        large = large.astype(np.uint8);
        large = cv.medianBlur(large,7)
        #large = cv.GaussianBlur(large,(7,7),0)
        #stuff, blobs = cv.threshold(large,150,255,cv.THRESH_BINARY)
        stuff, blobs = cv.threshold(large,160,255,cv.THRESH_BINARY+cv.THRESH_OTSU)
        contours, hierarchy = cv.findContours(blobs, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
        out = np.zeros((height*10,width*10,3), np.uint8)
        cv.drawContours(out,contours,-1,(255,255,0),3)

        regions_found = len(contours)

        contours = np.vstack(contours).squeeze()
        rect = cv.minAreaRect(contours)
        box = cv.cv.BoxPoints(rect)
        box = np.int0(box)
        cv.drawContours(out,[box],0,(0,255,255),2)

        #cv.imshow("Threshold", blobs);
        cv.imshow("Contours", out)
        cv.waitKey(1)

        x = rect[0][0]
        y = rect[0][1]
        angle = rect[2];

        if(regions_found < 10):
            send(x, y, angle)

        time.sleep(0.4)

    sensor.close()
    print "Done. Everything cleaned up."
 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
Beispiel #7
0
 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)
Beispiel #8
0
    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
Beispiel #9
0
    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)
Beispiel #10
0
    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
Beispiel #11
0
    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
Beispiel #12
0
    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)
Beispiel #13
0
    def info(inData):
        from user import User
        from sensor import Sensor
        from station import Station
        pureData=Auth.select(inData)

        userInfo={}
        sensorInfo={}
        stationInfo={}
        #print(pureData)

        for tmp in pureData['data']:
            t=tmp['sensorId']
            if(not(t in sensorInfo)):
                curSensor=Sensor.select({'id': t})
                sensorInfo[t]=curSensor
            tmp['sensorName']=sensorInfo[t]['data'][0]['name']

            t=sensorInfo[t]['data'][0]['stationId']
            if(not(t in stationInfo)):
                curStation=Station.select({id: t})
                stationInfo[t]=curStation
            tmp['stationName']=stationInfo[t]['data'][0]['name']

            t=tmp['userId']
            if(not(t in userInfo)):
                curUser=User.select({'id':t})
                userInfo[t]=curUser
            tmp['userName']=userInfo[t]['data'][0]['username']


        return pureData
Beispiel #14
0
    def delete_station2(inData):
        '''
        :param inData:
        :return:{
            2:'there is no id in inData',
            3:'there is no such id'
        }
        '''
        ret=0
        if(not inData.has_key('id')):
            ret=2
            return ret

        query=session.query(Station)
        tmpStation=query.filter(Station.id==inData['id']).first()
        if(tmpStation==None):
            ret=3
            return ret
        else:
            from sensor import Sensor
            tmpAllSensor=Sensor.select({'stationId': tmpStation.id})
            for tmpSensor in tmpAllSensor['pureData']:
                tmpSensor.stationId=0
            session.delete(tmpStation)
            session.commit()
            ret=1
            return ret
    def load_sensors(self):
        if "sensors" not in config:
            print("can not find the sensors segment in setting.cfg")
            return

        all_sensors = config["sensors"]
        for sensor_id in all_sensors:
            if sensor_id not in self.__sensors__:
                sensor_object = all_sensors[sensor_id]
                if "kind" in sensor_object:
                    sensor_object_kind = sensor_object["kind"]
                    if sensor_object_kind in self.__models__:
                        new_sensor = SensorLogic.copy_with_info(self.__models__[sensor_object_kind], sensor_id, sensor_object["name"])
                        self.__sensors__[sensor_id] = new_sensor
                    else:
                        new_sensor = Sensor(sensor_object_kind, sensor_id, sensor_object["name"])
                        if sensor_object["type"] is "action":
                            on_action = SAction("on")
                            off_action = SAction("off")
                            new_sensor.add_action(on_action)
                            new_sensor.add_action(off_action)
                        else:
                            value_property = SProperty("value", 0, None, 0)
                            new_sensor.add_property(value_property)
                        self.__sensors__[sensor_id] = new_sensor
                else:
                    print("{0:s} sensor in setting.cfg lost kind property".format(sensor_id))
 def sample(self):
     s = Sensor.sample(self)
     # Exceeded the max value...probably out of range.
     if s > self.maxVal:
         ret = Sensor.UNKNOWN
     else:
         ret = s * self.rangeInMeters / self.maxVal
     
     return ret
Beispiel #17
0
def run_sensor(player):
    sensor = Sensor()
    last_reading = sensor.get_light_sensor_reading()
    current_reading = sensor.get_light_sensor_reading()

    start_time = datetime.now()
    while True:
        reading = sensor.get_light_sensor_reading()
        print reading, last_reading, current_reading
        last_reading = current_reading
        current_reading = reading
        if current_reading - last_reading > 100:
            player.play()
            start_time = datetime.now()

        if (datetime.now() - start_time).seconds > 30 and player.is_playing():
            player.stop()

        yield From(asyncio.sleep(0.1))
Beispiel #18
0
 def delStation(inData):
     '''
     :param: inData
     :return: {1:'success', 2:'failed', 3:'permission denied', 4:'param wrong'}
     ''' 
     from user import User
     from sensor import Sensor
     if(('UserId' in inData) and ('StationId' in inData)):
         updateUserLevel = session.query(User.level).filter(User.id == inData['UserId'], User.valid == 1).first()
         if(updateUserLevel == None or int(updateUserLevel[0] != 0)):
             return 3
         else:
             session.query(Station).filter(Station.id == inData['StationId'], Station.valid == 1).update({'valid':0, 'time':datetime.now()})
             delSensorId = session.query(Sensor.id).filter(Sensor.stationId == inData['StationId'], Sensor.valid == 1).all()
             for sensorId in delSensorId:
                 Sensor.delSensor({'UserId':inData['UserId'], 'SensorId':int(sensorId[0])})
             session.commit()
             return 1
     else:
         return 4
Beispiel #19
0
 def algoritmoReducao(self, colunas, numTotEpocas, numAmostrasCiclo):
     sensor = Sensor(self.ARQUIVO)
     
     for var in colunas:
         saida = []
         erroAc = []
         medidas = []
         
         variavel = sensor.obterLeitura(var, 0, numTotEpocas-1)
         if(self.remOutlier):
             variavel = Estatistica.removeOutliers(variavel)
         
         numIter = int(ceil(float(numTotEpocas)/numAmostrasCiclo))
         erro = 0
         limSup = limInf = 0
         
         i = 1
         while(i <= numIter):
             limInf = (i-1)*numAmostrasCiclo
             limSup = i*numAmostrasCiclo-1
             if(limSup >= numTotEpocas):
                 limSup = (numTotEpocas%numAmostrasCiclo)+limInf-1
             
             medidas = variavel[limInf:limSup+1]
             
             informacoes = Estatistica.regSimples(range(limInf+1, limSup+2), medidas, True)
             saida = saida.__add__(informacoes[2])
             erro = informacoes[4]
             erroAc.append(erro)
             i += 1 
         
         residuo = Estatistica.erroResidual(variavel, saida);
                     
         DIC = {'variavel': VARIAVEL[var%len(VARIAVEL)], 'media': Estatistica.media(erroAc), 'minimo': Estatistica.minimo(erroAc),
                'maximo': Estatistica.maximo(erroAc), 'eqm': sum(erroAc), 'pkt-gerados': numIter, 'mecanismo': 'Regressao'}
         Log.registraLog(ARQUIVO_SAIDA, FORMAT, DIC)
         
         if(self.plot):
             Estatistica.plotar((range(1, numTotEpocas+1), range(1, numTotEpocas+1)), (variavel, saida), "Filtro Medio", "Epoca", VARIAVEL[var%len(VARIAVEL)], ["Valores Reais", "Valores Preditos"])
         
     return [numIter, saida, variavel, residuo]
Beispiel #20
0
class Slice(Thread):
    def __init__(self, local=False, interval=INTERVAL):
        Thread.__init__(self)
        self.done = None
        self.interval = interval
        self.local = local
        self.sensor = Sensor()

    def run(self):
        self.done = Event()
        while not self.done.wait(self.interval):
            info = self.sensor.read()
            if info:
                if self.local:
                    print info
                else:
                    self.send(info)
            else:
                print('The sensor could not be read')

    def send(self, info):
        # search for the server service
        service_matches = bt.find_service(uuid=UUID)

        if not service_matches:
            print('The server could not be found')

        first_match = service_matches[0]
        port = first_match['port']
        name = first_match['name']
        host = first_match['host']

        print('Attempting to connect to \'%s\' on %s' % (name, host))

        # Create the client socket
        sock = bt.BluetoothSocket(bt.RFCOMM)
        sock.connect((host, port))
        print('The connection has been accepted by the server')

        sock.send(str(info))
        print('The information has been sent')

        sock.close()
        print('The client socket has been closed')

    def stop(self):
        try:
            self.done.set()
        except AttributeError:
            print('The client cannot be stopped. It is not running')
        else:
            print('The client has been stopped')
Beispiel #21
0
 def algoritmoReducao(self, colunas, numTotEpocas, numAmostrasCiclo):
     sensor = Sensor(self.ARQUIVO)
     
     for var in colunas:
         saida = []
         erroAc = 0
         medidas = []
         
         variavel = sensor.obterLeitura(var, 0, numTotEpocas-1)
         numIter = int(ceil(float(numTotEpocas)/numAmostrasCiclo))
         erro = 0
         coefGerados = 1
         limSup = limInf = 0
         
         i = 1
         while(i <= numIter):
             limSup = i*numAmostrasCiclo-1
             if(limSup >= numTotEpocas):
                 limSup = (numTotEpocas%numAmostrasCiclo)+limInf-1
                 
             medidas = variavel[limInf:limSup+1]                                                
             informacoes = Estatistica.regSimples(range(limInf+1, limSup+2), medidas, (True))                    
             erro = informacoes[3]
             if(erro <= self.limiar or (limInf == limSup-numAmostrasCiclo+1)):
                 saida[limInf:limSup+1] = informacoes[limInf:limSup+1]
                 print len(saida) 
                 erroAc.append(sum(erro))                    
                 if(erro > self.limiar):                        
                     limInf = i*numAmostrasCiclo
                     coefGerados += 1
                     
                 i += 1
             else:
                 limInf = (i-1)*numAmostrasCiclo
                 coefGerados += 1
             
         DIC = {'variavel': VARIAVEL[var%len(VARIAVEL)], 'media': Estatistica.media(erroAc), 'minimo': Estatistica.minimo(erroAc),
                'maximo': Estatistica.maximo(erroAc), 'Erro-Acumulativo': sum(erroAc), 'pkt-gerados': coefGerados}
         Log.registraLog('cumulativo', FORMAT, DIC)         
Beispiel #22
0
class Alarm(object):

    def __init__(self):
        self._low_pressure_threshold = 17
        self._high_pressure_threshold = 21
        self._sensor = Sensor()
        self._is_alarm_on = False

    def check(self):
        psi_pressure_value = self._sensor.sample_pressure()
        if psi_pressure_value < self._low_pressure_threshold or self._high_pressure_threshold < psi_pressure_value:
            self._is_alarm_on = True

    @property
    def is_alarm_on(self):
        return self._is_alarm_on
Beispiel #23
0
    def info(inData):
        from user import User
        from sensor import Sensor
        from station import Station
        from auth import Auth
        allEqpData=Eqp.select(inData)

        userInfo={}
        sensorInfo={}
        stationInfo={}
        authInfo={}
        #print(allEqpData)

        for tmp in allEqpData['data']:
            
            t=tmp['number']
            tmpAllSensor=Sensor.select({'number': t})
            if(len(tmpAllSensor['data'])==0):
                tmp['sensorName']='not find'
                tmp['stationName']='not find'
                tmp['username']='******'
            else:
                curSensor=tmpAllSensor['pureData'][0]
                tmp['sensorName']=curSensor.name

                tmpAllStation=Station.select({'id': curSensor.stationId})
                if(len(tmpAllStation['data'])==0):
                    tmp['stationName']='not find'
                else:
                    curStation=tmpAllStation['pureData'][0]
                    tmp['stationName']=curStation.name
                    tmp['userName']=curStation.supervisor

                tmpAllAuth=Auth.select({'sensorId': curSensor.id})
                # if(len(tmpAllAuth['data'])==0):
                #     tmp['username']='******'
                # else:
                #     tmpAllUser=User.select({'id': tmpAllAuth['pureData'][0].userId})
                #     if(len(tmpAllUser['data'])==0):
                #         tmp['username']='******'
                #     else:
                #         tmp['username']=tmpAllUser['data'][0]['username']


        return allEqpData
class Alarm(object):

    def __init__(self):
        self._low_pressure_threshold = 17
        self._high_pressure_threshold = 21
        self._sensor = Sensor()
        self._is_alarm_on = False
        self._alarm_count = 0

    def check(self):
        psi_pressure_value = self._sensor.pop_next_pressure_psi_value()
        if psi_pressure_value < self._low_pressure_threshold or self._high_pressure_threshold < psi_pressure_value:
            self._is_alarm_on = True
            self._alarm_count += 1

    @property
    def is_alarm_on(self):
        return self._is_alarm_on
Beispiel #25
0
 def __init__(self, sensor_server="172.17.5.180", 
                    sensor_port=5555,
                    sensor_sample_rate=100000,
                    sensor_tx_freq=1000,
                    gantry_server="172.17.5.100", 
                    gantry_port=5007,
                    store_filename="data.log"):
     
     self.robot = Gantry(host=gantry_server,port=gantry_port)
     self.sensor = Sensor(server=sensor_server,
                     port=sensor_port,
                     sample_rate=sensor_sample_rate,
                     tx_freq=sensor_tx_freq)
                     
     self.transmitter = siggen
     self.transmitter.setFrequency(sensor_tx_freq)
     self.transmitter.setVoltage(-2,2)
     self.transmitter.turnOn()
     self._tx_freq = sensor_tx_freq
     
     self.store = DataStorage(store_filename)
     self.pos = Pos(0,0)
Beispiel #26
0
    def __init__(self,instal_texts,domain_texts,fact_text,options=""):
	#instal_texts is a list of strings
	ipath = []
	for i in instal_texts:
		ipath.append(self.temporary_text_file(i))

        dpath = []
	for d in domain_texts:
		dpath.append(self.temporary_text_file(d))
        fpath = self.temporary_text_file(fact_text)
        opath = mkdtemp()

	#-o needs to be a directory if >1 input file and a .lp file otherwise. This is a hack but it crashes otherwise.
	if len(instal_texts) > 1:
		opath_end = "/"
	else:
		opath_end = "/tmp.lp"

	#Construct argument list using temp files
        argparser = instalargparse.buildargparser()
	topass = ['-o',opath+opath_end,'-f',fpath,options]
	topass += ['-i'] + ipath
	topass += ['-d'] + dpath
        (args,unk) = argparser.parse_known_args(topass)
        # assumes input files are .ial not .lp
        args.ial_files = args.input_files
        args.lp_files = []
        model_files = instal_compile(args)
        initial_state = instal_state_facts(args)
        domain_facts = instal_domain_facts(args)
        self.sensor = Sensor(dummy,initial_state,model_files,domain_facts,args)

	# Clean up files. 
	for i in ipath:
        	os.remove(i)
	for d in dpath:
        	os.remove(d)
        os.remove(fpath)
        shutil.rmtree(opath)
Beispiel #27
0
 def __init__(self, serialPath, serialBaud, logger=None):
     Sensor.__init__(self, self.name, logger)
     self.serialPath = serialPath
     self.serialBaud = serialBaud
     self.connect()
Beispiel #28
0
parser.add_argument("-q", "--qos", help="MQTT QoS", type=int, default=1)
parser.add_argument("-o", "--topic2", help="Additional MQTT topic")
parser.add_argument("-t", "--topic", help="MQTT topic", required=True)
# specific
parser.add_argument("-s", "--topic_key", help="MQTT topic key", required=True)
parser.add_argument("-w", "--wait", help="time between readings", type=float, default=0.5)
parser.add_argument("-i", "--pin", help="gpio pin (BCM)", type=int, required=True)
parser.add_argument("-y", "--high_value", help="high value", default=Sensor.HIGH)
parser.add_argument("-z", "--low_value", help="low value", default=Sensor.LOW)
parser.add_argument("-g", "--log_level", help="logging level", type=int, default=logging.INFO)
args = parser.parse_args()

# logging setup
logger = set_logger(level=args.log_level)

sensor = Sensor(args.pin)
sensor.start()

last_state = None
status = None
while True:
    current_state = sensor.reading()
    if current_state != last_state:
        last_state = current_state  # reset state value
        if current_state == Sensor.LOW:
            status = args.low_value
        else:
            status = args.high_value
        logger.debug("sensor-monitor: changed %s %s" % (args.topic_key, str(status)))
        # publish
        MqttClient.publish(args, args.topic, {'state': {'reported': {args.topic_key: status}}})
Beispiel #29
0
 def __init__(self):
     self._low_pressure_threshold = 17
     self._high_pressure_threshold = 21
     self._sensor = Sensor()
     self._is_alarm_on = False
Beispiel #30
0
class Echidna(object):
    
    def __init__(self, sensor_server="172.17.5.180", 
                       sensor_port=5555,
                       sensor_sample_rate=100000,
                       sensor_tx_freq=1000,
                       gantry_server="172.17.5.100", 
                       gantry_port=5007,
                       store_filename="data.log"):
        
        self.robot = Gantry(host=gantry_server,port=gantry_port)
        self.sensor = Sensor(server=sensor_server,
                        port=sensor_port,
                        sample_rate=sensor_sample_rate,
                        tx_freq=sensor_tx_freq)
                        
        self.transmitter = siggen
        self.transmitter.setFrequency(sensor_tx_freq)
        self.transmitter.setVoltage(-2,2)
        self.transmitter.turnOn()
        self._tx_freq = sensor_tx_freq
        
        self.store = DataStorage(store_filename)
        self.pos = Pos(0,0)
    
    def setStore(self,fname):
        if self.store.db.isopen:
            self.store.close()
        self.store = DataStorage(fname)
        
    def setTxFreq(self,freq):
        self._tx_freq = freq
        self.transmitter.setFrequency(freq)
        self.sensor.tx_freq = freq
        
    def stepOverTank(self,fname="tank"):
        self.pos = self.discretizeTank()
        x_size = self.pos.shape[0]
        y_size = self.pos.shape[1]
        for x in range(x_size):            
            for y in range(y_size):
                p = self.pos[x,y]                
                logger.info("Moving to (%f, %f)" % (p[0],p[1]))
                self.robot.moveAndWait(p[0],p[1], 60)
                d = self.sensor.getSample(100)
                fig, samp = self.plotRadar(5)
                fig.savefig(fname + "-x%3.2f-y%3.2f(x%d,y%d).tiff" % (p[0],p[1],x,y))
                plt.close(fig)
                d.setPos(p, (x,y))
                self.store.save(d)                
                    
    def stepOverPos(self,pos,fname="target"):
        self.count = 0
        self.pos = pos
        x_size = self.pos.shape[0]
        y_size = self.pos.shape[1]
        for x in range(x_size):            
            for y in range(y_size):
                p = self.pos[x,y]                
                logger.info("Moving to (%f, %f)" % (p[0],p[1]))
                self.robot.move(p[0],p[1], 70)
                #d = self.sensor.getSample(25)
                fig, d = self.plotRadar()
                d.setPos(p)
                self.store.save(d)                            
                fig.savefig("%d-" % self.count + fname + "-x%3.2f-y%3.2f.tiff" % (p[0],p[1]))
                plt.close(fig)                
                while(self.robot.busy()):
                    time.sleep(0.5)                
                self.count = self.count + 1
                        
    def freqSweep(self,start,stop,step=1, nsamps=100):
        self.count = 0                
        range = np.arange(start,stop,step)   
        samples = []
        for freq in range:
            logger.info("%d | Sampling frequency: %f" % (self.count,freq))
            self.setTxFreq(freq)
            d = self.sensor.getSample(nsamps)            
            d.setPos(self.pos.astuple())
            self.store.save(d)                                                                    
            self.count = self.count + 1
            samples.append(d)
        
        return samples     
        
    def discretizeTank(self, width=23.5, length=23.5, steps=50.0):
        x_steps = np.round(np.arange(0,width,width/steps),2)
        y_steps = np.round(np.arange(0,length,length/steps),2)
        pos = np.zeros((x_steps.size,y_steps.size, 2))
        for i in range(x_steps.size):
            for j in range(y_steps.size):
                pos[i][j][0] = x_steps[i]
                pos[i][j][1] = y_steps[j]
        
        return pos
         

    def learn_baseline(self, samples=250):
        self.sample_baseline = self.sensor.getSample(samples)
        
    def getDiffSignal(self, samples=10, baseline_samples=250):
        if not hasattr(self,"sample_baseline"):
            self.learn_baseline(baseline_samples)
        sample = self.sensor.getSample(samples)
        data = sample.getMeanPower()
        return (data - self.sample_baseline.getMeanPower()), sample
                
    def plotRadar(self, samples=15, baseline_samples=250):
     
        fig = plt.figure()
        ax = fig.add_axes([0.1,0.1,0.8,0.8], polar=True)
        lines  = ax.get_lines()
        ax.set_rmax(0.1)
        y, samp = self.getDiffSignal(samples, baseline_samples)
        for val in y:                
            sys.stdout.write("%3.6f,"% val)
        sys.stdout.write("\n")
                
        x = np.arange(y.size)/np.float(y.size)*np.pi*2.0
        data = zip(x,y)
        lines = ax.get_lines()
        for vec in data:
            ax.set_rmax(0.15)
            ax.plot([vec[0],vec[0]],[0,vec[1]],linewidth=3.0)    
        ax.set_rmax(0.1)
        plt.show()
        return fig, samp

        
    def __del__(self):
        self.store.close()