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(ifNotifier):
        self.ownerNotifier = ifNotifier
       
    def start(self):
        self.stimThread = CanStimThread(self.pktHandler, self.ifNotifier)
        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 739	Rev 750
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	~~ifNotifier~~ = None	88	ownerNotifier = None
89	pktHandler = None	89	pktHandler = None
90		90
91	def __init__ (self, cfg = None, pktHandler ~~= None~~, ~~ifNotifier~~ = 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	if ifNotifier:	-
95	self.ifNotifier = ifNotifier	-
96		94
97	self.pktHandler = pktHandler	95	self.pktHandler = pktHandler
98	NodeIfBase.__init__(self, cfg, pktHandler)	96	NodeIfBase.__init__(self, cfg, pktHandler)
-		97
-		98	def setPktHandler(self, pktHandler):
-		99	self.pktHandler = pktHandler
-		100
-		101	def setIfNotifier(ifNotifier):
-		102	self.ownerNotifier = ifNotifier
99		103
100	def start(self):	104	def start(self):
101	self.stimThread = CanStimThread(self.pktHandler, self.ifNotifier)	105	self.stimThread = CanStimThread(self.pktHandler, self.ifNotifier)
102	tempDummy = TempNode()	106	tempDummy = TempNode()
103	self.stimThread.dummyList.append(tempDummy)	107	self.stimThread.dummyList.append(tempDummy)
104	self.stimThread.start()	108	self.stimThread.start()
105	return True	109	return True
106		110
107	def stop(self):	111	def stop(self):
108	if self.stimThread is not None and not self.stimThread.terminated:	112	if self.stimThread is not None and not self.stimThread.terminated:
109	self.stimThread.terminate()	113	self.stimThread.terminate()
110	else:	114	else:
111	log.debug('CanStim interface not started, or already stopped')	115	log.debug('CanStim interface not started, or already stopped')
112		116
113	def running(self):	117	def running(self):
114	if self.stimThread is not None:	118	if self.stimThread is not None:
115	return not self.stimThread.terminated	119	return not self.stimThread.terminated
116	else:	120	else:
117	return False	121	return False
118		122
119	def removeDummy(self, DummyNode):	123	def removeDummy(self, DummyNode):
120	''' if possible'''	124	''' if possible'''
121	self.stimThread.dummyList.remove(DummyNode)	125	self.stimThread.dummyList.remove(DummyNode)
122		126
123	def addDummy(self, DummyNode):	127	def addDummy(self, DummyNode):
124	'''if possible'''	128	'''if possible'''
125	self.stimThread.dummyList.add(DummyNode)	129	self.stimThread.dummyList.add(DummyNode)
126		130
127		131

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/pyCanDaemon/NodeIfCanStim.py @ 751 – Rev 739 → 750