Completing ZigbeeTest with doorlock test
[iot2.git] / benchmarks / other / XbeePythonDriver / xbee_digi.py
1 from zigbee import *
2 from socket import *
3 from select import *
4 import serial
5 import time
6 import collections
7 import sys
8 import getopt
9 import traceback
10 from threading import Thread, Lock
11 import random
12 import threading
13
14
15 # -----------------------------------------------------------------------------
16 # Constants ans Pseudo-Constants
17 # -----------------------------------------------------------------------------
18 UDP_RECEIVE_PORT = 5005        # port used for incoming UDP data
19 UDP_RECEIVE_BUFFER_SIZE = 4096  # max buffer size of an incoming UDP packet
20
21 # time for messages to wait for a response before the system clears away that 
22 # sequence identifier
23 ZIGBEE_SEQUENCE_NUMBER_CLEAR_TIME_SEC = 5 
24
25 # address of our local zigbee radio
26 ZIGBEE_DEVICE_ADDRESS = "xxxxxxxxxxxxxxxx"
27
28 SYSTEM_MASTER_ADDRESS = ("192.168.2.108", 12345) # ip address and portof the system master node
29
30
31 # -----------------------------------------------------------------------------
32 # Global Variables and Objects
33 # -----------------------------------------------------------------------------
34
35 # zigbee communications object and its mutex
36 zigbeeConnection = None
37 zigbeeConnectionMutex = Lock()
38
39 # zigbee mapping from long to short object dict
40 zigbeeLongShortAddr = dict()
41 zigbeeLongShortAddrMutex = Lock()
42
43 # zigbee mapping from a sequence number to a client 
44 # for correct response handling
45 zigbeeSeqNumberToClient = dict()
46 zigbeeSeqNumberToClientMutex = Lock()
47
48 zigbeeBindRequest = dict()
49 zigbeeBindRequestMutex = Lock()
50
51 # Keeps record of where to send callbacks to when an HA message is received
52 zigbeeHACallback = dict()
53 zigbeeHACallbackMutex = Lock()
54
55 # Keeps a record of device addresses whose short addresses have not been 
56 # determined yet
57 zigbeeUnregisteredAddresses = []
58 zigbeeUnregisteredAddressesMutex = Lock()
59
60 # used to signal all threads to end
61 doEndFlag = False
62
63
64 # 2 sockets, one for sending (not bound to a port manually)
65 # and one for receiving, known port binding by application
66 # both UDP sockets
67 sendSocket = socket(AF_INET, SOCK_DGRAM)
68 receiveSocket = socket(AF_INET, SOCK_DGRAM)
69
70 # zigbee address authority list
71 zigbeeAddressAuthorityDict = dict()
72
73
74
75 # -----------------------------------------------------------------------------
76 # Helper Methods
77 # -----------------------------------------------------------------------------
78
79
80 def parseCommandLineArgs(argv):
81     try:
82         opts, args = getopt.getopt(
83             argv, "h:u:", ["udpport="])
84
85     except getopt.GetoptError:
86         print 'test.py -u <udp_port>'
87         sys.exit(2)
88
89     for opt, arg in opts:
90         if opt == '-h':
91             print 'test.py -u <udp_port>'
92             sys.exit()
93
94
95 # -------------
96 # Convenience (Stateless)
97 # -------------
98
99 def shortToStr(short):
100     s=chr(short>>8) + chr(short & 0xff)
101     return s
102
103 def hexToInt(str):
104     ret = 0
105     for h in str:
106         ret = ret << 4
107         ret += int(h, 16)
108     return ret
109
110 def hexListToChar(hexList):
111     ''' Method to convert a list/string of characters into their corresponding values
112
113         hexList -- list or string of hex characters
114     '''
115     retString = ""
116     for h in hexList:
117         retString += chr(int(h, 16))
118     return retString
119
120 def splitByN(seq, n):
121     ''' Method to split a string into groups of n characters
122
123         seq -- string
124         n -- group by number
125     '''
126     return [seq[i:i+n] for i in range(0, len(seq), n)]
127
128 def changeEndian(hexString):
129     ''' Method to change endian of a hex string
130
131         hexList -- string of hex characters
132     '''
133     split = splitByN(hexString, 2) # get each byte
134     split.reverse();               # reverse ordering of the bytes
135
136     # reconstruct 
137     retString = ''
138     for s in split:
139         retString += s
140     return retString
141
142 def reverse(string):
143     ''' Method to change endian of a hex string
144
145         hexList -- string of hex characters
146     '''
147     return string[::-1]
148
149 def printMessageData(data):
150     ''' Method to print a zigbee message to the console
151
152         data -- pre-parsed zigbee message
153     '''
154     for d in data:
155         print d, ' : ',
156         for e in data[d]:
157             print "{0:02x}".format(ord(e)),
158         if (d == 'id'):
159             print "({})".format(data[d]),
160         print
161
162 def hexStringToZigbeeHexString(hexString):
163     ''' Method to change a hex string to a string of characters with the hex values
164
165         hexList -- string of hex characters
166     '''
167     return hexListToChar(splitByN(hexString, 2))
168
169 def hexStringToAddr(hexString):
170     ''' Method to change a hex string to a string of characters with the hex values
171
172         hexList -- string of hex characters
173     '''
174     split = splitByN(hexString, 2)
175     newstring = '[' + split[0]
176     for h in split[1:]:
177         newstring += ':' + h
178     newstring += ']!'
179     return newstring
180
181 def addrToHexString(addr):
182     hex=addr[1:25]
183     list=[hex[i:i+2] for i in range(0, len(hex), 3)]    
184     retstring = ''
185     for e in list:
186         retstring += e
187     return retstring
188     
189 def zigbeeHexStringToHexString(zigbeeHexString):
190     ''' Method to change string of characters with the hex values to a hex string
191
192         hexList -- string of characters with hex values
193     '''
194
195     retString = ''
196     for e in zigbeeHexString:
197         retString += "{0:02x}".format(ord(e))
198     return retString
199
200 def zclDataTypeToBytes(zclPayload):
201     ''' Method to determine data length of a zcl attribute
202
203         zclPayload -- ZCL payload data, must have dataType as first byte
204     '''
205     attrType = ord(zclPayload[0])
206
207     if(attrType == 0x00):
208         return 0
209     elif (attrType == 0x08):
210         return 1
211     elif (attrType == 0x09):
212         return 2
213     elif (attrType == 0x0a):
214         return 3
215     elif (attrType == 0x0b):
216         return 4
217     elif (attrType == 0x0c):
218         return 5
219     elif (attrType == 0x0d):
220         return 6
221     elif (attrType == 0x0e):
222         return 7
223     elif (attrType == 0x0f):
224         return 8
225     elif (attrType == 0x10):
226         return 1
227     elif (attrType == 0x18):
228         return 1
229     elif (attrType == 0x19):
230         return 2
231     elif (attrType == 0x1a):
232         return 3
233     elif (attrType == 0x1b):
234         return 4
235     elif (attrType == 0x1c):
236         return 5
237     elif (attrType == 0x1d):
238         return 6
239     elif (attrType == 0x1e):
240         return 7
241     elif (attrType == 0x1f):
242         return 8
243     elif (attrType == 0x20):
244         return 1
245     elif (attrType == 0x21):
246         return 2
247     elif (attrType == 0x22):
248         return 3
249     elif (attrType == 0x23):
250         return 4
251     elif (attrType == 0x24):
252         return 5
253     elif (attrType == 0x25):
254         return 6
255     elif (attrType == 0x26):
256         return 7
257     elif (attrType == 0x27):
258         return 8
259     elif (attrType == 0x28):
260         return 1
261     elif (attrType == 0x29):
262         return 2
263     elif (attrType == 0x2a):
264         return 3
265     elif (attrType == 0x2b):
266         return 4
267     elif (attrType == 0x2c):
268         return 5
269     elif (attrType == 0x2d):
270         return 6
271     elif (attrType == 0x2e):
272         return 7
273     elif (attrType == 0x2f):
274         return 8
275     elif (attrType == 0x30):
276         return 1
277     elif (attrType == 0x31):
278         return 2
279     elif (attrType == 0x38):
280         return 2
281     elif (attrType == 0x39):
282         return 4
283     elif (attrType == 0x3a):
284         return 8
285     elif (attrType == 0x41):
286         return ord(zclPayload[1])
287     elif (attrType == 0x42):
288         return ord(zclPayload[1])
289     elif (attrType == 0x43):
290         return ord(zclPayload[1]) + (256 * ord(zclPayload[2]))
291     elif (attrType == 0x44):
292         return ord(zclPayload[1]) + (256 * ord(zclPayload[2]))
293     elif (attrType == 0xe0):
294         return 4
295     elif (attrType == 0xe1):
296         return 4
297     elif (attrType == 0xe2):
298         return 4
299     elif (attrType == 0xe8):
300         return 2
301     elif (attrType == 0xe9):
302         return 2
303     elif (attrType == 0xea):
304         return 4
305     elif (attrType == 0xf0):
306         return 8
307     elif (attrType == 0xf1):
308         return 16
309     elif (attrType == 0xff):
310         return 0
311
312 # -------------
313 # Other
314 # -------------
315
316 def createSequenceNumberForClient(addr, packetId):
317     ''' Method to get and store a sequence number with a specific client 
318         for a specific message.
319
320         addr -- UDP address of the client to associate with the seq. number
321         packetId -- packet id from the UDP packet
322     '''
323     # keep trying to find a number to return
324     while(True):
325
326         # get the current time
327         epoch_time = int(time.time())
328
329         # get the current list of used numbers
330         zigbeeSeqNumberToClientMutex.acquire()
331         keysList = zigbeeSeqNumberToClient.keys()
332         zigbeeSeqNumberToClientMutex.release()
333     
334         # if all the numbers are already used
335         if(len(keysList) == 256):
336
337             # get a list of all the items
338             zigbeeSeqNumberToClientMutex.acquire()
339             itemsList = zigbeeSeqNumberToClient.items()
340             zigbeeSeqNumberToClientMutex.release()
341
342             # search for a number that is old enough to get rid of otherwise use -1
343             seqNum = -1
344             for item in itemsList:
345                 if((epoch_time - item[1][1]) > ZIGBEE_SEQUENCE_NUMBER_CLEAR_TIME_SEC):
346                     seqNumber = item[0]
347                     break
348
349             if(seqNum != -1):
350                 # replace the record with new data if we found one to replace
351                 zigbeeSeqNumberToClientMutex.acquire()
352                 zigbeeSeqNumberToClient[seqNumber] = (addr, epoch_time, packetId)
353                 zigbeeSeqNumberToClientMutex.release()
354
355             return seqNumber
356             
357         else:
358             # not all numbers used yet so pick one randomly
359             randNum = random.randrange(0,256)
360
361             # check if we are using the number yet
362             if(randNum not in keysList):
363
364                 # we are not so insert to keep track who this number is for and return it
365                 zigbeeSeqNumberToClientMutex.acquire()
366                 zigbeeSeqNumberToClient[randNum] = (addr, epoch_time, packetId)
367                 zigbeeSeqNumberToClientMutex.release()
368                 return randNum
369
370 def getConnectedRadioLongAddress():
371     """ Method to make sure we get the MAC address of our local radio"""
372     global zigbeeConnection
373     global zigbeeMutex
374     global ZIGBEE_DEVICE_ADDRESS
375     
376     data = ddo_get_param(None, 'SH')
377     valuehi = ""
378     for e in data:
379         valuehi += "{0:02x}".format(ord(e))
380
381     data = ddo_get_param(None, 'SL')
382     valuelo = ""
383     for e in data:
384         valuelo += "{0:02x}".format(ord(e))
385     ZIGBEE_DEVICE_ADDRESS = valuehi + valuelo
386     
387 def addressUpdateWorkerMethod():
388     ''' Method to keep refreshing the short addresses of the known zigbee devices'''
389     global doEndFlag
390     global zigbeeLongShortAddr
391     global zigbeeLongShortAddrMutex
392     global zigbeeUnregisteredAddresses
393     global zigbeeUnregisteredAddressesMutex
394     global zigbeeConnectionMutex
395     global zigbeeConnection
396
397     # keep looping until signaled to quit
398     while(not doEndFlag):
399
400         addrList = []
401
402         # add unregistered (short addresses unknown) devices so
403         # that we can look them up
404         zigbeeUnregisteredAddressesMutex.acquire()
405         addrList.extend(zigbeeUnregisteredAddresses)
406         zigbeeUnregisteredAddressesMutex.release()
407
408         # add the devices that we have short addresses for so we can 
409         # get their most recent short addresses
410         zigbeeLongShortAddrMutex.acquire()
411         addrList.extend(zigbeeLongShortAddr.keys())
412         zigbeeLongShortAddrMutex.release()
413
414         # Loop through all the addresses and send messages for each address
415         for ad in addrList:
416             # create payload for a query on the network for a short address
417             payload = '\x00'
418             payload += hexStringToZigbeeHexString(changeEndian(ad))
419             payload += '\x00'
420
421             # create and send binding command
422             zigbeeConnectionMutex.acquire()
423             # The Format of the tuple is:
424             #  (address_string, endpoint, profile_id, cluster_id)
425            
426             DESTINATION=(hexStringToAddr(ad), 0x0, 0x0, 0x0)
427
428             zigbeeConnection.sendto(payload, 0, DESTINATION);
429             zigbeeConnectionMutex.release()
430
431         time.sleep(30)
432
433
434 # -------------
435 # UDP 
436 # -------------
437
438 def sendUdpSuccessFail(addr, packetTypeStr, packetIdStr, sucOrFail, reason=None):
439     ''' Method to send a success or fail back to a client.
440
441         addr -- UDP address to send packet to
442         packetTypeStr -- name of this specific packet
443         packetIdStr -- packet id to send
444         sucOrFail -- whether this is a success or fail message (True = success)
445         reason -- reason of failure (if needed, default is None)
446
447     '''
448
449     global sendSocket
450
451     # construct the message
452     message = "type: " + packetTypeStr.strip() + "\n"
453     message += "packet_id: " + packetIdStr + "\n"
454
455     if(sucOrFail):
456         message += "response: success \n"
457     else:
458         message += "response: fail \n"
459         message += "reason: " + reason + "\n"
460
461     # send message in a UDP packet
462     sendSocket.sendto(message,addr)
463
464 def processUdpZdoBindReqMessage(parsedData, addr):
465     ''' Method handle a zdo bind request message
466
467         parsedData -- Pre-parsed Data that was in the UDP packet.
468         addr -- Address (IP and Port) of the UDP packet origin.
469     '''
470     global zigbeeLongShortAddr
471     global zigbeeLongShortAddrMutex
472     global zigbeeBindRequestMutex
473     global zigbeeBindRequest
474     global zigbeeConnectionMutex
475     global zigbeeConnection
476
477
478     shortAddr = None
479     
480     if(zigbeeAddressAuthorityDict.has_key(addr)):
481         l = zigbeeAddressAuthorityDict[addr]
482         if(parsedData['device_address_long'] not in l):
483             return
484     else:
485         return
486     
487     # get the short address for this device long address if possible
488     zigbeeLongShortAddrMutex.acquire()
489     if(zigbeeLongShortAddr.has_key(parsedData['device_address_long'])):
490         shortAddr = zigbeeLongShortAddr[parsedData['device_address_long']]
491     zigbeeLongShortAddrMutex.release()
492
493     # if there is a short address than we can send the message
494     # if there is not one then we cannot since we need both the short and
495     # the long address
496     if(shortAddr != None):
497
498         # get a request number
499         seqNumber = createSequenceNumberForClient(addr, parsedData['packet_id'])
500         
501         # send back failure
502         if(seqNumber == -1):
503
504             # send an error message, could not get a sequence number to use at this time
505             sendUdpSuccessFail(addr, 'zdo_bind_request', parsedData['packet_id'], False, 'out_of_space')
506             return
507
508         # a bind request was made so must store and wait for response 
509         # before we setup callbacks, so keep just the data we need to create the callback
510         zigbeeBindRequestMutex.acquire()
511         zigbeeBindRequest[seqNumber] = (parsedData['device_address_long'],
512                                         parsedData['cluster_id'], 
513                                         parsedData['packet_id'], 
514                                         addr)
515         zigbeeBindRequestMutex.release()
516
517         # construct the short and long addresses of the message for sending
518         # make sure they are in the correct format
519         destLongAddr = parsedData['device_address_long']
520         destShortAddr = hexStringToZigbeeHexString(shortAddr)
521
522         # create the payload data
523         payloadData = ""
524         payloadData += chr(seqNumber)
525         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['device_address_long']))
526         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['device_endpoint']))
527         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['cluster_id'])) 
528         payloadData += '\x03' 
529         payloadData += hexStringToZigbeeHexString(changeEndian(ZIGBEE_DEVICE_ADDRESS))
530         payloadData += '\x01'
531
532         # create and send binding command
533         zigbeeConnectionMutex.acquire()
534
535         # The Format of the tuple is:
536         #  (address_string, endpoint, profile_id, cluster_id)
537         DESTINATION = (hexStringToAddr(destLongAddr), 0x0, 0x0, 0x21)
538         zigbeeConnection.sendto(payloadData, 0, DESTINATION)
539
540         zigbeeConnectionMutex.release()
541
542
543     else:
544         # send a failure packet since there is no short address available
545         sendUdpSuccessFail(addr, 'zdo_bind_request', parsedData['packet_id'], False, 'short_address_unknown')
546         pass
547
548
549 def processUdpZdoUnBindReqMessage(parsedData, addr):
550     zigbeeHACallbackMutex.acquire();
551     if(zigbeeHACallback.has_key(parsedData['device_address_long'], parsedData['cluster_id'])):
552         zigbeeHACallback(parsedData['device_address_long'], parsedData['cluster_id']).remove(addr)
553     zigbeeHACallbackMutex.release()
554     sendUdpSuccessFail(addr, 'zdo_unbind_request', parsedData['packet_id'], True)
555
556     
557 def processUdpSendAddressMessage(parsedData, addr):
558     ''' Method handle a send address command
559
560         parsedData -- Pre-parsed Data that was in the UDP packet.
561         addr -- Address (IP and Port) of the UDP packet origin.
562     '''
563     global zigbeeLongShortAddr
564     global zigbeeLongShortAddrMutex
565     global zigbeeUnregisteredAddresses
566     global zigbeeUnregisteredAddressesMutex
567     global sendSocket
568
569     if(zigbeeAddressAuthorityDict.has_key(addr)):
570         l = zigbeeAddressAuthorityDict[addr]
571         if(parsedData['device_address_long'] not in l):
572             return
573     else:
574         return
575
576     
577     # construct success message
578     message = "type: send_address_response\n"
579     message += "packet_id: " + parsedData['packet_id'] + "\n"
580     message += "response: success\n"
581
582     # tell client that we got their request
583     sendSocket.sendto(message,addr)
584
585     # construct 
586     zigbeeLongShortAddrMutex.acquire()
587     doesHaveKey = zigbeeLongShortAddr.has_key(parsedData['device_address_long'])
588     zigbeeLongShortAddrMutex.release()
589
590     if(doesHaveKey):
591         # long address is already registered with the system so no need to do anything
592         return
593
594     # long address not registered so add it for short address lookup
595     zigbeeUnregisteredAddressesMutex.acquire()
596     zigbeeUnregisteredAddresses.append(parsedData['device_address_long'])
597     zigbeeUnregisteredAddressesMutex.release()
598
599 def processUdpZclReadAttributesMessage(parsedData, addr):
600     ''' Method handle a ZCL read attribute command
601
602         parsedData -- Pre-parsed Data that was in the UDP packet.
603         addr -- Address (IP and Port) of the UDP packet origin.
604     '''
605
606     global zigbeeLongShortAddr
607     global zigbeeLongShortAddrMutex
608     global zigbeeBindRequestMutex
609     global zigbeeBindRequest
610     global zigbeeConnectionMutex
611     global zigbeeConnection
612
613
614     if(zigbeeAddressAuthorityDict.has_key(addr)):
615         l = zigbeeAddressAuthorityDict[addr]
616         if(parsedData['device_address_long'] not in l):
617             return
618     else:
619         return
620
621     
622     shortAddr = None
623
624     # get the short address for this device long address if possible
625     zigbeeLongShortAddrMutex.acquire()
626     if(zigbeeLongShortAddr.has_key(parsedData['device_address_long'])):
627         shortAddr = zigbeeLongShortAddr[parsedData['device_address_long']]
628     zigbeeLongShortAddrMutex.release()
629
630
631     # if there is a short address than we can send the message
632     # if there is not one then we cannot since we need both the short and
633     # the long address
634     if(shortAddr != None):
635
636         # get a request number
637         seqNumber = createSequenceNumberForClient(addr, parsedData['packet_id'])
638         
639         # send back failure
640         if(seqNumber == -1):
641
642             # send an error message, could not get a sequence number to use at this time
643             sendUdpSuccessFail(addr, 'zcl_read_attributes', parsedData['packet_id'], False, 'out_of_space')
644             return
645
646         # get the info for sending
647         destLongAddr = hexStringToZigbeeHexString(parsedData['device_address_long'])
648         destShortAddr = hexStringToZigbeeHexString(shortAddr)
649         profileId = parsedData['profile_id']
650         clusterId = parsedData['cluster_id']
651         dstEndpoint = parsedData['device_endpoint']
652
653         # get all the attributes
654         attributeIds = parsedData['attribute_ids'].split(',')
655
656         # create the payload data
657         payloadData = ""
658         payloadData += '\x00'
659         payloadData += chr(seqNumber)
660         payloadData += '\x00'
661
662         # make all the attributes payloads
663         for attr in attributeIds:
664             attr = attr.strip()
665             attr = changeEndian(attr)
666             payloadData += hexStringToZigbeeHexString(attr)
667
668
669         #  (address_string, endpoint, profile_id, cluster_id)
670         DESTINATION = (hexStringToAddr(zigbeeHexStringToHexString(destLongAddr)), hexToInt(dstEndpoint), hexToInt(profileId), hexToInt(clusterId))
671
672         # create and send binding command
673         zigbeeConnectionMutex.acquire()
674         zigbeeConnection.sendto(payloadData, 0, DESTINATION)
675         zigbeeConnectionMutex.release()
676
677
678     else:
679         # send a fail response
680         sendUdpSuccessFail(addr, 'zcl_read_attributes', parsedData['packet_id'], False, 'short_address_unknown')
681         pass
682
683 def processUdpZclConfigureReportingMessage(parsedData, addr):
684     ''' Method handle a zcl configure reporting message
685
686         parsedData -- Pre-parsed Data that was in the UDP packet.
687         addr -- Address (IP and Port) of the UDP packet origin.
688     '''
689
690     global zigbeeLongShortAddr
691     global zigbeeLongShortAddrMutex
692     global zigbeeBindRequestMutex
693     global zigbeeBindRequest
694     global zigbeeConnectionMutex
695     global zigbeeConnection
696
697
698     if(zigbeeAddressAuthorityDict.has_key(addr)):
699         l = zigbeeAddressAuthorityDict[addr]
700         if(parsedData['device_address_long'] not in l):
701             return
702     else:
703         return
704
705     shortAddr = None
706
707     # get the short address for this device long address if possible
708     zigbeeLongShortAddrMutex.acquire()
709     if(zigbeeLongShortAddr.has_key(parsedData['device_address_long'])):
710         shortAddr = zigbeeLongShortAddr[parsedData['device_address_long']]
711     zigbeeLongShortAddrMutex.release()
712
713     # if there is a short address than we can send the message
714     # if there is not one then we cannot since we need both the short and
715     # the long address
716     if(shortAddr != None):
717
718         # get a request number
719         seqNumber = createSequenceNumberForClient(addr, parsedData['packet_id'])
720         
721         # send back failure
722         if(seqNumber == -1):
723             sendUdpSuccessFail(addr, 'zcl_configure_reporting', parsedData['packet_id'], False, 'out_of_space')
724             return
725
726         destLongAddr = hexStringToZigbeeHexString(parsedData['device_address_long'])
727         destShortAddr = hexStringToZigbeeHexString(shortAddr)
728         profileId = parsedData['profile_id']
729         clusterId = parsedData['cluster_id']
730         dstEndpoint = parsedData['device_endpoint']
731
732         # create the payload data
733         payloadData = ""
734         payloadData += '\x00'
735         payloadData += chr(seqNumber)
736         payloadData += '\x06'
737         payloadData += '\x00'
738         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['attribute_id']))
739         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['data_type']))
740         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['min_reporting_interval']))
741         payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['max_reporting_interval']))
742
743         if(parsedData.has_key('reportable_change')):
744             payloadData += hexStringToZigbeeHexString(changeEndian(parsedData['reportable_change']))
745
746        DESTINATION = (hexStringToAddr(zigbeeHexStringToHexString(destLongAddr)), hexToInt(dstEndpoint), hexToInt(profileId), hexToInt(clusterId))
747
748         # create and send binding command
749         zigbeeConnectionMutex.acquire()
750
751         zigbeeConnection.sendto(payloadData, 0, DESTINATION)
752         zigbeeConnectionMutex.release()
753
754
755     else:
756         sendUdpSuccessFail(addr, 'zcl_configure_reporting', parsedData['packet_id'], False, 'short_address_unknown')
757         pass
758
759 def processUdpPolicySet(parsedData, addr):
760     ''' Method handle a policy set message
761
762         parsedData -- Pre-parsed Data that was in the UDP packet.
763         addr -- Address (IP and Port) of the UDP packet origin.
764     '''
765     print "=================================================================="
766     print "Policy set: ", parsedData
767     
768     # do nothing if wrong source
769     if addr == SYSTEM_MASTER_ADDRESS:
770         key = (parsedData['ip_address'], int(parsedData['port']))
771         if (zigbeeAddressAuthorityDict.has_key(key)):
772             zigbeeAddressAuthorityDict[key].append(parsedData['device_address_long'])
773         else:
774             zigbeeAddressAuthorityDict[key] = [parsedData['device_address_long']]
775
776 def processUdpPolicyClear(parsedData, addr):
777     ''' Method handle a policy set message
778
779         parsedData -- Pre-parsed Data that was in the UDP packet.
780         addr -- Address (IP and Port) of the UDP packet origin.
781     '''
782     print "=================================================================="
783     print "Clear policy: ", parsedData
784     
785     # do nothing if wrong source
786     if addr == SYSTEM_MASTER_ADDRESS:
787         zigbeeAddressAuthorityDict.clear()
788
789     
790 def processZigbeeRxExplicitCommandMessage(rawData, src_addr):
791     ''' Method to process a rx-explicit zigbee message
792
793         parsedData -- Pre-parsed (into a dict) data from message.
794     '''
795
796 #    The format for addr is the tuple (address_string, endpoint, profile_id, cluster_id).
797     global zigbeeBindRequestMutex
798     global zigbeeBindRequest
799     parsedData = dict()
800     parsedData['source_addr_long']=hexStringToZigbeeHexString(addrToHexString(src_addr[0]))
801     parsedData['cluster']=shortToStr(src_addr[3])
802     parsedData['profile']=shortToStr(src_addr[2])
803     parsedData['rf_data']=rawData
804     
805     # get the long and short addresses from the message payload since we can 
806     # use these to update the short addresses since this short address is fresh
807     longAddr = zigbeeHexStringToHexString(parsedData['source_addr_long'])
808
809     # check if this short address is for a device that has yet to be 
810     # registered
811
812     # if this is a ZDO message/response
813     if(parsedData['profile'] == '\x00\x00'):
814
815         # if this is a device announcement so we can get some useful data from it
816         if(parsedData['cluster'] == '\x00\x13'):
817             
818             # pick out the correct parts of the payload
819             longAddr = zigbeeHexStringToHexString(parsedData['rf_data'][3:11])
820             shortAddr = zigbeeHexStringToHexString(parsedData['rf_data'][1:3])
821
822             # change the endian of the address
823             longAddr = changeEndian(longAddr)
824             shortAddr = changeEndian(shortAddr)
825
826             # update the table with the new information
827             zigbeeLongShortAddrMutex.acquire()
828             zigbeeLongShortAddr[longAddr] = shortAddr
829             zigbeeLongShortAddrMutex.release()
830
831             # check if this short address is for a device that has yet to be 
832             # registered
833             zigbeeUnregisteredAddressesMutex.acquire()
834             if(longAddr in zigbeeUnregisteredAddresses):
835                 zigbeeUnregisteredAddresses.remove(longAddr)
836             zigbeeUnregisteredAddressesMutex.release()
837
838         # if this is a response to a zdo bind_req message
839         elif(parsedData['cluster'] == '\x80\x21'):
840
841             # get the status and sequence number from the message
842             seqNumber = parsedData['rf_data'][0]
843             statusCode = parsedData['rf_data'][1]
844
845             # get the bind tuple information
846             # for this specific bind request
847             tup = None
848             zigbeeBindRequestMutex.acquire() 
849             if(zigbeeBindRequest.has_key(ord(seqNumber))):
850                 tup = zigbeeBindRequest[ord(seqNumber)]
851             zigbeeBindRequestMutex.release()
852
853             if(tup == None):
854                 # cant really do anything in this case...
855                 # don't have any information on who the data is for
856                 return
857
858             # successful binding
859             if(ord(statusCode) == 0):
860
861                 # add a callback for this specific device and cluster 
862                 # to the HA callback dict 
863                 if(zigbeeHACallback.has_key((tup[0], tup[1]))):
864                     if(tup[3] not in zigbeeHACallback[(tup[0], tup[1])]):
865                         zigbeeHACallback[(tup[0], tup[1])].append(tup[3])
866                 else:
867                     zigbeeHACallback[(tup[0], tup[1])] = [tup[3]]
868
869                 # send success message
870                 sendUdpSuccessFail(tup[3], 'zdo_bind_request', tup[2], True)
871
872             # Not Supported
873             elif (ord(statusCode) == 170):
874                 sendUdpSuccessFail(tup[3], 'zdo_bind_request', tup[2], False, 'not_supported')
875
876             # Table Full
877             elif (ord(statusCode) == 174):
878                 sendUdpSuccessFail(tup[3], 'zdo_bind_request', tup[2], False, 'table_full')
879
880             # Other issue, dont have code for
881             else:
882                 sendUdpSuccessFail(tup[3], 'zdo_bind_request', tup[2], False, 'other')
883
884         # if this is a response to a short address query
885         elif(parsedData['cluster'] == '\x80\x00'):
886             
887             # get a status code
888             statusCode = parsedData['rf_data'][0]
889
890             # does not matter if this is not a success, we can try again later
891             if(statusCode != '\x00'):
892                 # status code was not success so do not do anything
893                 return
894
895             # get the short and long address information
896             longAddr = changeEndian(zigbeeHexStringToHexString(parsedData['rf_data'][2:10]))
897             shortAddr = changeEndian(zigbeeHexStringToHexString( parsedData['rf_data'][10:12]))
898
899             # remove device from list of unregistered devices if it is in it
900             zigbeeUnregisteredAddressesMutex.acquire()
901             if(longAddr in zigbeeUnregisteredAddresses):
902                 zigbeeUnregisteredAddresses.remove(longAddr)
903             zigbeeUnregisteredAddressesMutex.release()
904
905             # update/insert the short address
906             zigbeeLongShortAddrMutex.acquire()
907             zigbeeLongShortAddr[longAddr] = shortAddr
908             zigbeeLongShortAddrMutex.release()
909
910     # if this is a home automation zcl message/response
911     elif (parsedData['profile'] == '\x01\x04'):
912
913         # get the zcl message header
914         zclFrameControl = parsedData['rf_data'][0]
915         zclSeqNumber = parsedData['rf_data'][1]
916         zclCommand = parsedData['rf_data'][2]
917
918         # this is a zcl read attribute response
919         if(zclCommand == '\x01'):
920
921             # get the zcl payload
922             zclPayload = parsedData['rf_data'][3:]
923             attibuteResponseList = []
924
925             # get the data for each data
926             while(len(zclPayload) > 0):
927                 attributeId = zclPayload[0:2]
928                 attributeStatus = zclPayload[2]
929                 zclPayload = zclPayload[3:]
930                 
931                 if(ord(attributeStatus) != 0):
932                     # if attribute is not supported then it has no data
933                     # package the data and add it to the list
934                     attibuteResponseList.append((attributeId,"not_supported"))
935                 else:
936
937                     # get the data type and data length of the attributre
938                     attributeType = zclPayload[0]
939                     dataLength = zclDataTypeToBytes(zclPayload)
940
941                     # consume zcl payload data
942                     if ((ord(attributeType) == 0x41) or (ord(attributeType) == 0x42)):
943                         zclPayload = zclPayload[2:]
944                     elif ((ord(attributeType) == 0x43) or (ord(attributeType) == 0x44)):
945                         zclPayload = zclPayload[3:]
946                     else:
947                         zclPayload = zclPayload[1:]
948
949                     # package the data and add it to the list
950                     newData = (attributeId,"success", attributeType ,zclPayload[0:dataLength])
951                     attibuteResponseList.append(newData)
952
953                     # consume the data size of the payload
954                     zclPayload = zclPayload[dataLength:]
955
956             # find who to send response to 
957             tup = None
958             zigbeeSeqNumberToClientMutex.acquire()
959             if(zigbeeSeqNumberToClient.has_key(ord(zclSeqNumber))):
960                 tup = zigbeeSeqNumberToClient[ord(zclSeqNumber)]
961                 del zigbeeSeqNumberToClient[ord(zclSeqNumber)]
962             zigbeeSeqNumberToClientMutex.release()
963
964             # no one to send the response to so just move on
965             if(tup == None):
966                 # cant really do anything here
967                 return
968             
969             # create the response message
970             packetId = tup[2]
971             message = "type : zcl_read_attributes_response \n"
972             message += "packet_id: " + packetId + "\n"
973             message += "cluster_id: " + zigbeeHexStringToHexString(parsedData['cluster']) + "\n"
974             message += "profile_id: " + zigbeeHexStringToHexString(parsedData['profile']) + "\n"
975             message += "attributes: " 
976
977             # create the message for each attribute
978             for t in attibuteResponseList:
979                 attrId = ord(t[0][0]) + (256 * ord(t[0][1]))
980                 if(t[1] == "success"):
981                     attrIdStr = "%0.4x" % attrId
982                     attrIdStr = changeEndian(attrIdStr)
983
984                     message += attrIdStr
985                     message += ", "
986                     message +=  "success"
987                     message += ", "
988                     message += "%0.2x" % ord(t[2])
989                     message += ", "
990
991                     dat = ""
992                     for c in (t[3]):
993                         dat += "%0.2x" % ord(c)
994                     dat = changeEndian(dat)
995                     message += dat
996                     message += ";"
997                 else:
998                     attrIdStr = "%0.4x" % attrId
999                     attrIdStr = changeEndian(attrIdStr)
1000
1001                     message += attrIdStr
1002                     message += ", "
1003                     message +=  "not_supported"
1004                     message += ";"
1005
1006             message = message[0:len(message) - 1]
1007             message += "\n"
1008
1009             # send the socket
1010             sendSocket.sendto(message,tup[0])
1011
1012         # this is a zcl configure attribute response
1013         elif(zclCommand == '\x07'):
1014
1015             # find who to send response to 
1016             tup = None
1017             zigbeeSeqNumberToClientMutex.acquire()
1018             if(zigbeeSeqNumberToClient.has_key(ord(zclSeqNumber))):
1019                 tup = zigbeeSeqNumberToClient[ord(zclSeqNumber)]
1020                 del zigbeeSeqNumberToClient[ord(zclSeqNumber)]
1021             zigbeeSeqNumberToClientMutex.release()
1022
1023             # no one to send the response to so just move on
1024             if(tup == None):
1025                 # cant really do anything here
1026                 return
1027
1028             # get zcl payload
1029             zclPayload = parsedData['rf_data'][3:]
1030             
1031             # construct the message
1032             packetId = tup[2]
1033             message = "type : zcl_configure_reporting_response \n"
1034             message += "packet_id: " + packetId + "\n"
1035             message += "cluster_id: " + zigbeeHexStringToHexString(parsedData['cluster']) + "\n"
1036             message += "profile_id: " + zigbeeHexStringToHexString(parsedData['profile']) + "\n"
1037             message += "attributes: " 
1038
1039             if(len(zclPayload) == 1):
1040                 # if all the configurations are a success then only send back a success
1041                 # based on zigbee specs
1042                 message +=  "all_success \n";
1043                 sendSocket.sendto(message,tup[0])
1044             
1045             else:
1046                 attibuteResponseList = []
1047                 
1048                 # get each attributes data
1049                 while(len(zclPayload) > 0):
1050                     attributeStatus = zclPayload[0]
1051                     attributeDirection = zclPayload[1]
1052                     attributeId = zclPayload[2:4]
1053                     zclPayload = zclPayload[4:]
1054
1055                     newData = (attributeStatus,attributeDirection, attributeId)
1056                     attibuteResponseList.append(newData)
1057
1058                 # package each attribute 
1059                 for t in attibuteResponseList:
1060                     attrId = ord(t[2][0]) + (256 * ord(t[2][1]))
1061                     attrIdStr = "%0.4x" % attrId
1062                     attrIdStr = changeEndian(attrIdStr)
1063
1064                     message += attrIdStr
1065                     message += ", "
1066                     if(ord(t[0]) == 0):
1067                         message +=  "success"
1068                     else:
1069                         message +=  "error"
1070
1071                     message += ", "
1072
1073                     if(ord(t[1]) == 0):
1074                         message +=  "reported"
1075                     else:
1076                         message +=  "received"
1077                     message += ";"
1078
1079                 message = message[0:len(message) - 1]
1080                 message += "\n"
1081                 sendSocket.sendto(message,tup[0])
1082
1083         # this is a zcl report attribute message
1084         elif(zclCommand == '\x0a'):
1085
1086             # get teh zcl payload
1087             zclPayload = parsedData['rf_data'][3:]
1088             attibuteResponseList = []
1089  
1090             # extract the attribute data
1091             while(len(zclPayload) > 0):
1092                 attributeId = zclPayload[0:2]
1093                 zclPayload = zclPayload[2:]
1094                 attributeType = zclPayload[0]
1095                 dataLength = zclDataTypeToBytes(zclPayload)
1096
1097                 if ((ord(attributeType) == 0x41) or (ord(attributeType) == 0x42)):
1098                     zclPayload = zclPayload[2:]
1099                 elif ((ord(attributeType) == 0x43) or (ord(attributeType) == 0x44)):
1100                     zclPayload = zclPayload[3:]
1101                 else:
1102                     zclPayload = zclPayload[1:]
1103
1104                 newData = (attributeId, attributeType ,zclPayload[0:dataLength])
1105                 attibuteResponseList.append(newData)
1106                 zclPayload = zclPayload[dataLength:]
1107
1108
1109             # get callback clients to respond to
1110             callbackIndex = (zigbeeHexStringToHexString(parsedData['source_addr_long']), zigbeeHexStringToHexString(parsedData['cluster']))
1111             retAddr = None
1112             zigbeeHACallbackMutex.acquire()
1113             if(zigbeeHACallback.has_key(callbackIndex)):
1114                 retAddr = zigbeeHACallback[callbackIndex]
1115             zigbeeHACallbackMutex.release()
1116
1117             # no one to respond to so do nothing here
1118             if(retAddr == None):
1119                 return
1120
1121             # construct the message
1122             message = "type : zcl_report_attributes \n"
1123             message += "packet_id: " + ("%0.2x" % ord(zclSeqNumber)) + "\n"
1124             message += "cluster_id: " + zigbeeHexStringToHexString(parsedData['cluster']) + "\n"
1125             message += "profile_id: " + zigbeeHexStringToHexString(parsedData['profile']) + "\n"
1126             message += "attributes: " 
1127
1128             # package the attributes
1129             for t in attibuteResponseList:
1130                 attrId = ord(t[0][0]) + (256 * ord(t[0][1]))
1131                 attrIdStr = "%0.4x" % attrId
1132                 attrIdStr = changeEndian(attrIdStr)
1133
1134                 message += attrIdStr
1135                 message += ", "
1136                 message += "%0.2x" % ord(t[1])
1137                 message += ", "
1138
1139                 dat = ""
1140                 for c in (t[2]):
1141                     dat += "%0.2x" % ord(c)
1142                 dat = changeEndian(dat)
1143                 message += dat
1144                 message += ";"
1145
1146             message = message[0:len(message) - 1]
1147             message += "\n"
1148
1149             # send to all client that want this callback
1150             for ra in retAddr:
1151                 sendSocket.sendto(message,ra)
1152
1153
1154 # -----------------------------------------------------------------------------
1155 # Communication Callback/Parse Methods
1156 # -----------------------------------------------------------------------------
1157 def handleNewZigbeeMessage(parsedData, src_addr):
1158     ''' Method to process a zigbee message from the local radio.
1159
1160         parsedData -- Pre-parsed (into a dict) data from message.
1161     '''
1162     processZigbeeRxExplicitCommandMessage(parsedData, src_addr)
1163
1164
1165 def handleNewUdpPacket(data, addr):
1166     ''' Method to parse and handle an incoming UDP packet.
1167
1168         data -- Data that was in the UDP packet.
1169         addr -- Address (IP and Port) of the UDP packet origin.
1170     '''
1171
1172
1173
1174     # data comes in as 'key: value\n key: value...' string and so needs to be
1175     # parsed into a dict
1176     parsedData = dict()
1177
1178     # 1 key, value pair per line
1179     for line in data.split('\n'):
1180
1181         # key and values are split based on a ':'
1182         fields = line.split(':')
1183
1184         # make sure properly formated otherwise just ignore it
1185         if len(fields) == 2:
1186
1187             # do strips to remove any white spacing that may have resulted
1188             # from improper packing on the sender side
1189             parsedData[fields[0].strip()] = fields[1].strip()
1190
1191     # wrap in try statement just in case there is an improperly formated packet we
1192     # can deal with it
1193     try:
1194         # dispatch to the correct process method
1195         if(parsedData["type"] == "zdo_bind_request"):
1196             processUdpZdoBindReqMessage(parsedData, addr)
1197         elif(parsedData["type"] == "zdo_unbind_request"):
1198             processUdpZdoUnBindReqMessage(parsedData, addr)
1199         elif(parsedData["type"] == "send_address"):
1200             processUdpSendAddressMessage(parsedData, addr)
1201         elif(parsedData["type"] == "zcl_read_attributes"):
1202             processUdpZclReadAttributesMessage(parsedData, addr)
1203         elif(parsedData["type"] == "zcl_configure_reporting"):
1204             processUdpZclConfigureReportingMessage(parsedData, addr)
1205         elif(parsedData["type"] == "policy_set"):
1206             processUdpPolicySet(parsedData, addr)
1207         elif(parsedData["type"] == "policy_clear"):
1208             processUdpPolicyClear(parsedData, addr)
1209         else:
1210             pass
1211     except:
1212         # if we ever get here then something went wrong and so just ignore this
1213         # packet and try again later
1214         print "I didn't expect this error:", sys.exc_info()[0]
1215         traceback.print_exc()
1216
1217
1218
1219 def pollMessages():
1220     payload, src_addr = zigbeeConnection.recvfrom(1024)
1221     handleNewZigbeeMessage(payload, src_addr)
1222
1223     
1224 # -----------------------------------------------------------------------------
1225 # Main Running Methods
1226 # -----------------------------------------------------------------------------
1227
1228 def main():
1229     '''Main function used for starting the application as the main driver'''
1230
1231     global UDP_RECEIVE_PORT
1232     global zigbeeConnection
1233     global zigbeeMutex
1234     global doEndFlag
1235
1236     parseCommandLineArgs(sys.argv[1:])
1237
1238
1239     # create a zigbee object that handles all zigbee communication
1240     # we use this to do all communication to and from the radio
1241     # when data comes from the radio it will get a bit of unpacking
1242     # and then a call to the callback specified will be done with the
1243     # unpacked data
1244     zigbeeConnection = socket(AF_ZIGBEE, SOCK_DGRAM, XBS_PROT_APS)
1245
1246     zigbeeConnection.bind(("", 0x0, 0, 0))
1247     
1248     # get the long address of our local radio before we start doing anything
1249     getConnectedRadioLongAddress();
1250
1251     # setup incoming UDP socket and bind it to self and specified UDP port
1252     # sending socket does not need to be bound to anything
1253     receiveSocket.bind(("", UDP_RECEIVE_PORT))
1254
1255     # create the thread that does short address lookups
1256     addressUpdateWorkerThread = threading.Thread(target=addressUpdateWorkerMethod)
1257     addressUpdateWorkerThread.start()
1258     zigbeeConnection.setblocking(0)
1259     receiveSocket.setblocking(0)
1260     
1261     
1262     try:
1263         # Main running loop
1264         while(True):
1265             rlist = [ receiveSocket, zigbeeConnection ]
1266             wlist = []
1267             xlist = []
1268             rlist, wlist, xlist = select(rlist, [], [])
1269             if zigbeeConnection in rlist:
1270                 pollMessages()
1271
1272             if receiveSocket in rlist:
1273                 data, addr = receiveSocket.recvfrom(4096)
1274                 handleNewUdpPacket(data, addr)
1275
1276     except KeyboardInterrupt:
1277         # use the keyboard interupt to catch a ctrl-c and kill the application
1278         pass
1279
1280     except:
1281         # something went really wrong and so exit with error message
1282         traceback.print_exc()
1283
1284     # signal all threads to exit
1285     doEndFlag = True
1286
1287     # wait for threads to finish before closing of the resources
1288     addressUpdateWorkerThread.join()
1289
1290
1291     # make sure to close all the connections
1292     zigbeeConnection.close()
1293     receiveSocket.close()
1294     sendSocket.close()
1295
1296 if __name__ == "__main__":
1297     # call main function since this is being run as the start
1298     main()