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

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/pyCanDaemon/NodeIfCanStim.py @ 746 – Rev 738 → 739