def recv(self,msg):
		if msg.type is MT_MULTILINE:
			for x in msg.msg:
				if x == "":
					continue
				m = _num.match(x)
				if m is None:
					continue
				mon = int(m.group(0))
				self.data[mon]=x[m.end():]
				recvs,self.queue.receivers = self.queue.receivers,[]
				for r in recvs:
					mid = getattr(r,"msgid",None)
					if mid is None or mid in self.data:
						log("wago",TRACE,"found monitor",r)
						self.queue.receivers.append(r)
					else:
						try:
							raise DroppedMonitor(mid)
						except DroppedMonitor as ex:
							fix_exception(ex)
							res = r.error(ex)
							if res is SEND_AGAIN:
								log("wago",TRACE,"retry monitor",r)
								self.queue.enqueue(r)
							else:
								log("wago",TRACE,"drop monitor",r)
								assert res is None or res is False, "%s.error returned %s"%(repr(r),repr(res))

			return MINE
		if msg.type is MT_NAK or msg.type is MT_ERROR:
			simple_event("wago","monitor","error", msg=msg.msg)
			return MINE
		return NOT_MINE

	def delete(self,ctx=None):
		self.server.stop_gevent()
		self.server = None
		if self.evt is not None:
			self.evt.delete()
		super(QBconn,self).delete()
		simple_event("qbroker","disconnect",*self.name)

	def get(self, state, ext=None, handler=None):
		simple_event("fs20","state", *self.name, state=state, ext=ext)

		ctx = Context(value=state)
		if ext is not None:
			ctx.ext = ext
		simple_event(ctx, "input","fs20", *self.name)

	def on_disconnect(self):
		simple_event("rpc","disconnect",*self.name)
		if self.workers is not None:
			for w in self.workers:
				unregister_worker(w)
			self.workers = None
		super(RPCconn,self).delete()

	def retime(self, dest):
		simple_event("wait","update",*self.name,dest=dest, loglevel=TRACE, deprecated=True)
		simple_event("wait","state",*self.name, end_time=dest, loglevel=TRACE, state="update")
		with log_wait("wait","delete1",self.name):
			with self._lock:
				self.end = dest
				self._set_pling()

	def delete(self,ctx=None):
		self.conn.close()
		self.conn = None
		self.stop_job("job")
		simple_event("amqp","disconnect",*self.name, deprecated=True)
		simple_event("amqp","state",*self.name, state="disconnect")
		super(AMQPclient,self).delete()

	def lineReceived(self,data):
		db = ""
		e = ""
		if not data: return # empty line
		if data[0] in PREFIX:
			for d in data[1:]:
				if e:
					try:
						db += chr(eval("0x"+e+d))
					except SyntaxError:
						simple_event("fs20","unknown","hex", data=data)
						return
					e=""
				else:
					e=d
			if e:
				log("fs20",WARN,"fs20 odd length "+data)

			self.datagramReceived(data[0], db, timestamp=self.timestamp)
			self.timestamp = None
		elif data[0] == PREFIX_TIMESTAMP:
			self.timestamp = float(data[1:])
		elif data[0] == "P":
			pass # idle
		elif data[0] == "+":
			log("fs20",DEBUG,"fs20 trace "+data)
		else:
			simple_event("fs20","unknown","prefix", prefix=data[0],data=data[1:])

	def _start(self):
		reported = False
		while True:
			sleep(self.freq)
			try:
				self.time_start = now()
				self.old_seen = self.seen.copy()
				# log(DEBUG,"SCAN",self.path,"IN",self.bus)
				self.bus.dir(path=self.path+('alarm',), proc=self._reporter, cached=False)
				for id in self.old_seen:
					simple_event("onewire","alarm","state",id, bus=self.bus.bus.name, path=self.path, id=id, state="off")
					self.seen.remove(id)
			except Exception as e:
				self.last_error = e
				if not reported:
					reported = True
					fix_exception(e)
					process_failure(e)
				self.time_len = now()-self.time_start
				sleep(self.freq*10)
			else:
				reported = False
				self.time_len = now()-self.time_start
				for x in self.simul:
					x[0] += 1
					if x[0] >= x[1]:
						x[0] = 0
						self.bus.set(self.path+('simultaneous',x[2]),x[3])

	def datagramReceived(self, prefix, data, handler=None, timestamp=None):
		try:
			ext = PREFIX[prefix]
		except KeyError:
			simple_event("fs20","unknown","prefix",prefix=prefix,data=data)
		else:
			return ext.datagramReceived(self.ctx, data, handler, timestamp)

	def go_down(self, _=None):
		if not self.is_up:
			return
		self.is_up = False
		if _ is not None:
			process_failure(_)
		simple_event("onewire","down",typ=self.typ,id=self.id,bus=self.bus.name,path=self.path, deprecated=True)
		simple_event("onewire","device","state",self.id, typ=self.typ,id=self.id,bus=self.bus.name,path=self.path, state="down")

def tx_proc_hygro(ctx, data):
	if len(data) != 7:
		simple_event("fs20","tx","bad_length","hygro",len=len(data),data=data)
		return None
	if data[2] != data[5] or data[3] != data[6]:
		simple_event("fs20","tx","bad_repeat","hygro",data=data)
		return None
	hum = data[2]*10 + data[3] + data[4]/10
	return {"humidity":hum}

def tx_proc_thermo(ctx, data):
	if len(data) != 7:
		simple_event("fs20","tx","bad_length","thermo",len=len(data),data=data)
		return None
	if data[2] != data[5] or data[3] != data[6]:
		simple_event("fs20","tx","bad_repeat","thermo",data=data)
		return None
	temp = data[2]*10 + data[3] + data[4]/10 -50
	return {"temperature":temp}

	def delete(self,ctx=None):
		if self.working:
			raise StateChangeError(self,u"‹deleted›")
		self.working = True
		self.time = now()
		try:
			if self.value is not None:
				simple_event("state","delete",*self.name, prev_value=self.value)
		finally:
			super(State,self).delete()

	def one_value(self, step):
		"""\
			Get one value from some "set monitor" command.
			Override this for active monitoring.
			"""
		if self.send_check_event and step==1:
			simple_event(self.ectx, "monitor","checking",*self.name)

		with log_wait("monitor","one_value",*self.name):
			return self.watcher.get(block=True, timeout=None)

	def on_connect(self):
		global conn_seq
		conn_seq += 1
		self.name = self.dest + ("n"+str(conn_seq),)
		self.ctx = Context()
		self.ctx.out = Reporter(self)
		self.ctx.words = global_words(self.ctx)
		self.workers = set()
		simple_event("rpc","connect",*self.name)
		Collected.__init__(self)

	def do_post(self):
		self.slotter = None
		if self.running != "during" or self.waiter is not None:
			log(ERROR,"timeslot error post",self.running,*self.name)
			return

		self.running = "next"
		simple_event("timeslot","end",*self.name, deprecated=True)
		simple_event("timeslot","state",*self.name, state="end")
		self.next = time_delta(self.interval, now=self.next)-dt.timedelta(0,self.duration)
		self.waiter = callLater(False, self.next, self.do_pre)

	def event(self,ctx,data):
		d={}
		for m,n in data.items():
			try: n = n * self.faktor[m]
			except KeyError: pass
			try: n = n + self.offset[m]
			except KeyError: pass
			d[m]=n

		simple_event("fs20","tx", *self.name, **d)
		self.last = now()
		self.last_data = data

	def delete(self,ctx=None):
		if self.timer:
			self.timer.cancel()
			self.timer = None
		try:
			if self.state:
				simple_event("pwm","change",*self.name, value=0)
		except Exception as ex:
			fix_exception(ex)
			process_failure(ex)
		finally:
			super(CommonPM,self).delete()

	def on_info_msg(self,msg):
		if not self._direct and not TESTING and getattr(msg,'message_id','').startswith(base_mseq):
			return # dup
		typ = getattr(msg,'content_type','')
		try:
			codec = get_codec(typ)
			data = codec.decode(msg.body)
		except Exception as e:
			data = { "raw": msg.body, "content_type": typ, "error": e }
		self.last_recv = msg.__dict__
		if 'timestamp' not in data:
			data['timestamp'] = now()
		simple_event(*(self.prefix+tuple(msg.routing_key.split('.')[self.strip:])), _direct=self._direct, **data)

	def up(self):
		with log_wait("monitor up "+repr(self)):
			while self.job and self.job.dead:
				gevent.sleep(0.1) # link will clear

		if not self.job:
			self.value = None
			simple_event("monitor","start",*self.name)
			self.start_job("job",self._run_loop)
			self.state_change_at = now()

			def tell_ended(_):
				simple_event("monitor","stop",*self.name)
			self.job.link(tell_ended)