WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/pyCanDaemon/NodeIfCanStim.py


###########################################################
#
# CanStim interface, used to emulate connected can nodes
#
# - Create fake node network
# - Replay log
#
###########################################################
import logging as log
from NodeIfBase import NodeIfBase
from threading import Thread
from CanPkt import CanPkt
import time
 
''' Generic dummy node '''
class DummyNode():
    def tick(self):
        pass
 
 
''' Temperature sensor node '''
class TempNode(DummyNode):
   
    frames = 0
   
    def __init__ (self):
        pass
   
    def read(self):
        self.frames = self.frames + 1
        if self.frames % 100 == 0:
            pktstr = CanPkt(0x1f8f0100,[0x5f,0x3a,0x40,0x01]).toString()
            return pktstr
 
''' Relay node, controls switches '''
class RelayNode(DummyNode):
    pass
 
''' View node, controls an LCD or similar '''
class ViewNode(DummyNode):
    pass
 
''' IO Node, a bridge to some other protocol over can '''
class IONode(DummyNode):
    pass
 
class CanStimThread(Thread):
    dummyList = []
    numDummies = 0
    terminated = False
    ownerNotifier = None
    pktHandler = None
   
    def __init__ (self, pktHandler, ownerNotifier):
        self.ownerNotifier = ownerNotifier
        self.pktHandler = pktHandler
        Thread.__init__(self)
       
       
    def run(self):
        log.debug('CanStimThread.run')
        try:
            readBuffer = None
            while not self.terminated:
                for dummy in self.dummyList:
                    readBuffer = dummy.read()
                    if readBuffer and len(readBuffer) > 0:
                        self.pktHandler.input(readBuffer)
                time.sleep(0.001)
               
            self.ownerNotifier.notify(self.ownerNotifier.TERMINATE)
           
        except: # sys.excepthook does not work in threads
            import traceback
            traceback.print_exc()
            self.terminate()
           
    def terminate(self):
        log.debug('CanStimThread.terminate')
        self.terminated = True
       
 
class NodeIfCanStim(NodeIfBase):
   
    DEFAULT_CONFIG = {'DummyNodes':[]}
    config = None
    stimThread = None
    ownerNotifier = None
    pktHandler = None
   
    def __init__ (self, pktHandler, cfg = None):
        if cfg is None:
            self.config = DEFAULT_CONFIG
           
        self.pktHandler = pktHandler
        NodeIfBase.__init__(self, cfg, pktHandler)
   
    def setPktHandler(self, pktHandler):
        self.pktHandler = pktHandler
       
    def setIfNotifier(self, ifNotifier):
        self.ownerNotifier = ifNotifier
       
    def start(self):
        self.stimThread = CanStimThread(self.pktHandler, self.ownerNotifier)
        tempDummy = TempNode()
        self.stimThread.dummyList.append(tempDummy)
        self.stimThread.start()
        return True
   
    def stop(self):
        if self.stimThread is not None and not self.stimThread.terminated:
            self.stimThread.terminate()
        else:
            log.debug('CanStim interface not started, or already stopped')
           
    def running(self):
        if self.stimThread is not None:
            return not self.stimThread.terminated
        else:
            return False
 
    def removeDummy(self, DummyNode):
        ''' if possible'''
        self.stimThread.dummyList.remove(DummyNode)
   
    def addDummy(self, DummyNode):
        '''if possible'''
        self.stimThread.dummyList.add(DummyNode)
 
 

Rev 750	Rev 752
1	###########################################################	1	###########################################################
2	#	2	#
3	# CanStim interface, used to emulate connected can nodes	3	# CanStim interface, used to emulate connected can nodes
4	#	4	#
5	# - Create fake node network	5	# - Create fake node network
6	# - Replay log	6	# - Replay log
7	#	7	#
8	###########################################################	8	###########################################################
9	import logging as log	9	import logging as log
10	from NodeIfBase import NodeIfBase	10	from NodeIfBase import NodeIfBase
11	from threading import Thread	11	from threading import Thread
12	from CanPkt import CanPkt	12	from CanPkt import CanPkt
13	import time	13	import time
14		14
15	''' Generic dummy node '''	15	''' Generic dummy node '''
16	class DummyNode():	16	class DummyNode():
17	def tick(self):	17	def tick(self):
18	pass	18	pass
19		19
20		20
21	''' Temperature sensor node '''	21	''' Temperature sensor node '''
22	class TempNode(DummyNode):	22	class TempNode(DummyNode):
23		23
24	frames = 0	24	frames = 0
25		25
26	def __init__ (self):	26	def __init__ (self):
27	pass	27	pass
28		28
29	def read(self):	29	def read(self):
30	self.frames = self.frames + 1	30	self.frames = self.frames + 1
31	if self.frames % 100 == 0:	31	if self.frames % 100 == 0:
32	pktstr = CanPkt(0x1f8f0100,[0x5f,0x3a,0x40,0x01]).toString()	32	pktstr = CanPkt(0x1f8f0100,[0x5f,0x3a,0x40,0x01]).toString()
33	return pktstr	33	return pktstr
34		34
35	''' Relay node, controls switches '''	35	''' Relay node, controls switches '''
36	class RelayNode(DummyNode):	36	class RelayNode(DummyNode):
37	pass	37	pass
38		38
39	''' View node, controls an LCD or similar '''	39	''' View node, controls an LCD or similar '''
40	class ViewNode(DummyNode):	40	class ViewNode(DummyNode):
41	pass	41	pass
42		42
43	''' IO Node, a bridge to some other protocol over can '''	43	''' IO Node, a bridge to some other protocol over can '''
44	class IONode(DummyNode):	44	class IONode(DummyNode):
45	pass	45	pass
46		46
47	class CanStimThread(Thread):	47	class CanStimThread(Thread):
48	dummyList = []	48	dummyList = []
49	numDummies = 0	49	numDummies = 0
50	terminated = False	50	terminated = False
51	ownerNotifier = None	51	ownerNotifier = None
52	pktHandler = None	52	pktHandler = None
53		53
54	def __init__ (self, pktHandler, ownerNotifier):	54	def __init__ (self, pktHandler, ownerNotifier):
55	self.ownerNotifier = ownerNotifier	55	self.ownerNotifier = ownerNotifier
56	self.pktHandler = pktHandler	56	self.pktHandler = pktHandler
57	Thread.__init__(self)	57	Thread.__init__(self)
58		58
59		59
60	def run(self):	60	def run(self):
61	log.debug('CanStimThread.run')	61	log.debug('CanStimThread.run')
62	try:	62	try:
63	readBuffer = None	63	readBuffer = None
64	while not self.terminated:	64	while not self.terminated:
65	for dummy in self.dummyList:	65	for dummy in self.dummyList:
66	readBuffer = dummy.read()	66	readBuffer = dummy.read()
67	if readBuffer and len(readBuffer) > 0:	67	if readBuffer and len(readBuffer) > 0:
68	self.pktHandler.input(readBuffer)	68	self.pktHandler.input(readBuffer)
69	time.sleep(0.001)	69	time.sleep(0.001)
70		70
71	self.ownerNotifier.notify(self.ownerNotifier.TERMINATE)	71	self.ownerNotifier.notify(self.ownerNotifier.TERMINATE)
72		72
73	except: # sys.excepthook does not work in threads	73	except: # sys.excepthook does not work in threads
74	import traceback	74	import traceback
75	traceback.print_exc()	75	traceback.print_exc()
76	self.terminate()	76	self.terminate()
77		77
78	def terminate(self):	78	def terminate(self):
79	log.debug('CanStimThread.terminate')	79	log.debug('CanStimThread.terminate')
80	self.terminated = True	80	self.terminated = True
81		81
82		82
83	class NodeIfCanStim(NodeIfBase):	83	class NodeIfCanStim(NodeIfBase):
84		84
85	DEFAULT_CONFIG = {'DummyNodes':[]}	85	DEFAULT_CONFIG = {'DummyNodes':[]}
86	config = None	86	config = None
87	stimThread = None	87	stimThread = None
88	ownerNotifier = None	88	ownerNotifier = None
89	pktHandler = None	89	pktHandler = None
90		90
91	def __init__ (self, pktHandler, cfg = None):	91	def __init__ (self, pktHandler, cfg = None):
92	if cfg is None:	92	if cfg is None:
93	self.config = DEFAULT_CONFIG	93	self.config = DEFAULT_CONFIG
94		94
95	self.pktHandler = pktHandler	95	self.pktHandler = pktHandler
96	NodeIfBase.__init__(self, cfg, pktHandler)	96	NodeIfBase.__init__(self, cfg, pktHandler)
97		97
98	def setPktHandler(self, pktHandler):	98	def setPktHandler(self, pktHandler):
99	self.pktHandler = pktHandler	99	self.pktHandler = pktHandler
100		100
101	def setIfNotifier(ifNotifier):	101	def setIfNotifier(self, ifNotifier):
102	self.ownerNotifier = ifNotifier	102	self.ownerNotifier = ifNotifier
103		103
104	def start(self):	104	def start(self):
105	self.stimThread = CanStimThread(self.pktHandler, self.~~ifNotifier~~)	105	self.stimThread = CanStimThread(self.pktHandler, self.ownerNotifier)
106	tempDummy = TempNode()	106	tempDummy = TempNode()
107	self.stimThread.dummyList.append(tempDummy)	107	self.stimThread.dummyList.append(tempDummy)
108	self.stimThread.start()	108	self.stimThread.start()
109	return True	109	return True
110		110
111	def stop(self):	111	def stop(self):
112	if self.stimThread is not None and not self.stimThread.terminated:	112	if self.stimThread is not None and not self.stimThread.terminated:
113	self.stimThread.terminate()	113	self.stimThread.terminate()
114	else:	114	else:
115	log.debug('CanStim interface not started, or already stopped')	115	log.debug('CanStim interface not started, or already stopped')
116		116
117	def running(self):	117	def running(self):
118	if self.stimThread is not None:	118	if self.stimThread is not None:
119	return not self.stimThread.terminated	119	return not self.stimThread.terminated
120	else:	120	else:
121	return False	121	return False
122		122
123	def removeDummy(self, DummyNode):	123	def removeDummy(self, DummyNode):
124	''' if possible'''	124	''' if possible'''
125	self.stimThread.dummyList.remove(DummyNode)	125	self.stimThread.dummyList.remove(DummyNode)
126		126
127	def addDummy(self, DummyNode):	127	def addDummy(self, DummyNode):
128	'''if possible'''	128	'''if possible'''
129	self.stimThread.dummyList.add(DummyNode)	129	self.stimThread.dummyList.add(DummyNode)
130		130
131		131

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/pyCanDaemon/NodeIfCanStim.py @ 1237 – Rev 750 → 752