source: thinkgear_emulator/puzzlebox_thinkgear_serial_protocol.py @ 119

Last change on this file since 119 was 119, checked in by sc, 11 years ago

thinkgear_emulator/puzzlebox_thinkgear_serial_protocol.py:

  • initial checkin
  • Property svn:executable set to *
File size: 9.0 KB
Line 
1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3#
4# Puzzlebox - Brainstorms - Network - Server - ThinkGear - Serial Protocol
5#
6# Copyright Puzzlebox Productions, LLC (2010)
7#
8# This code is released under the GNU Pulic License (GPL) version 2
9# For more information please refer to http://www.gnu.org/copyleft/gpl.html
10#
11# Last Update: 2010.07.21
12#
13#####################################################################
14
15import sys
16import serial
17
18#from PyQt4 import QtCore, QtNetwork
19
20import puzzlebox_thinkgear_emulator_configuration as configuration
21#import puzzlebox_logger
22
23#####################################################################
24# Globals
25#####################################################################
26
27DEBUG = 1
28
29DEFAULT_SERIAL_PORT = '/dev/rfcomm0'
30#DEFAULT_SERIAL_PORT = 'COM6'
31DEFAULT_SERIAL_BAUDRATE = 57600
32
33DEFAULT_MINDSET_ADDRESS = '00:13:EF:00:1B:FE'
34
35#####################################################################
36# Classes
37#####################################################################
38
39class puzzlebox_thinkgear_serial_protocol:
40       
41        def __init__(self, log, \
42                               serial_port=DEFAULT_SERIAL_PORT, \
43                               DEBUG=DEBUG, \
44                               parent=None):
45               
46                self.log = log
47                self.DEBUG = DEBUG
48               
49                self.serial_port = serial_port
50                self.device = None
51               
52                self.device = self.initialize_device()
53       
54       
55        ##################################################################
56       
57        def initialize_device(self):
58               
59                baudrate = DEFAULT_SERIAL_BAUDRATE
60                bytesize = 8
61                parity = 'NONE'
62                stopbits = 1
63                software_flow_control = 'f'
64                rts_cts_flow_control = 'f'
65                #timeout = 15
66                timeout = 5
67               
68                # convert bytesize
69                if (bytesize == 5):
70                        init_byte_size = serial.FIVEBITS
71                elif (bytesize == 6):
72                        init_byte_size = serial.SIXBITS
73                elif (bytesize == 7):
74                        init_byte_size = serial.SEVENBITS
75                elif (bytesize == 8):
76                        init_byte_size = serial.EIGHTBITS
77                else:
78                        #self.log.perror("Invalid value for %s modem byte size! Using default (8)" % modem_type)
79                        init_byte_size = serial.EIGHTBITS
80               
81                # convert parity
82                if (parity == 'NONE'):
83                        init_parity = serial.PARITY_NONE
84                elif (parity == 'EVEN'):
85                        init_parity = serial.PARITY_EVEN
86                elif (parity == 'ODD'):
87                        init_parity = serial.PARITY_ODD
88                else:
89                        #self.log.perror("Invalid value for %s modem parity! Using default (NONE)" % modem_type)
90                        init_parity = serial.PARITY_NONE
91               
92                # convert stopbits
93                if (stopbits == 1):
94                        init_stopbits = serial.STOPBITS_ONE
95                elif (stopbits == 2):
96                        init_stopbits = serial.STOPBITS_TWO
97                else:
98                        #self.log.perror("Invalid value for %s modem stopbits! Using default (8)" % modem_type)
99                        init_byte_size = serial.STOPBITS_ONE
100               
101                # convert software flow control
102                if (software_flow_control == 't'):
103                        init_software_flow_control = 1
104                else:
105                        init_software_flow_control = 0
106
107                # convert rts cts flow control
108                if (rts_cts_flow_control == 't'):
109                        init_rts_cts_flow_control = 1
110                else:
111                        init_rts_cts_flow_control = 0
112               
113               
114                # Initialize the modem
115                #self.log.pdebug("Initializing %s modem" % modem_code)
116               
117                device = serial.Serial(port = serial_port, \
118                                            baudrate = baudrate, \
119                                            bytesize = init_byte_size, \
120                                            parity = init_parity, \
121                                            stopbits = init_stopbits, \
122                                            xonxoff = init_software_flow_control, \
123                                            rtscts = init_rts_cts_flow_control, \
124                                            timeout = timeout)
125               
126               
127                return(device)
128       
129       
130        ##################################################################
131       
132        def start(self):
133               
134                #"AT+CKPD=200" - Indicates a Bluetooth button press
135                #"AT+VGM=" - Indicates a microphone volume change
136                #"AT+VGS=" - Indicates a speakerphone volume change
137                #"AT+BRSF=" - The Headset is asking what features are supported
138                #"AT+CIND?" - The Headset is asking about the indicators that are signaled
139                #"AT+CIND=?" - The Headset is asking about the test indicators
140                #"AT+CMER=" - The Headset is asking which indicates are registered for updates
141                #"ATA" - When an incoming call has been answered, usually a Bluetooth button press
142                #"AT+CHUP" - When a call has been hung up, usually a Bluetooth button press
143                #"ATD>" - The Headset is requesting the local device to perform a memory dial
144                #"ATD" - The Headset is requesting to dial the number
145                #"AT+BLDN" - The Headset is requesting to perform last number dialed
146                #"AT+CCWA=" - The Headset has enabled call waiting
147                #"AT+CLIP=" - The Headset has enabled CLI (Calling Line Identification)
148                #"AT+VTS=" - The Headset is asking to send DTMF digits
149                #"AT+CHLD=" - The Headset is asking to put the call on Hold
150                #"AT+BVRA=" - The Headset is requesting voice recognition
151                #"ATH" - Call hang-up
152               
153                #self.device.write('\x29')
154                #self.device.write('AT+BRSF=24\r\n')
155               
156                buffer = ''
157               
158                while True:
159                        reply = self.device.read()
160                       
161                        if (len(reply) != 0):
162                                buffer += reply
163                       
164                        if buffer == "AT+BRSF=24\r":
165                                print "--> Received:",
166                                print buffer
167                                response = '\r\nOK\r\n'
168                                print "<-- Sending:",
169                                print response.replace('\r\n', '')
170                                self.device.write(response)
171                                buffer = ''
172                       
173                        elif buffer == 'AT+CIND=?\r':
174                                print "--> Received:",
175                                print buffer
176                                # first field indicates that we have cellular service [0-1]
177                                # second field indicates that we're in a call (0 for false) [0-1]
178                                # third field indicates the current call setup (0 for idle) [0-3]
179                                response = '\r\n+CIND: 1,0,0\r\n'
180                                print "<-- Sending:",
181                                print response.replace('\r\n', '')
182                                self.device.write(response)
183                                response = '\r\nOK\r\n'
184                                print "<-- Sending:",
185                                print response.replace('\r\n', '')
186                                self.device.write(response)
187                                buffer = ''
188                       
189                        elif buffer == 'AT+CMER=3, 0, 0, 1\r':
190                                print "--> Received:",
191                                print buffer
192                                response = '\r\nOK\r\n'
193                                print "<-- Sending:",
194                                print response.replace('\r\n', '')
195                                self.device.write(response)
196                                response = '\r\n+CIEV:2,1\r\n'
197                                print "<-- Sending:",
198                                print response.replace('\r\n', '')
199                                self.device.write(response)
200                                response = '\r\n+CIEV:3,0\r\n'
201                                print "<-- Sending:",
202                                print response.replace('\r\n', '')
203                                self.device.write(response)
204                                buffer = ''
205                       
206                        elif buffer == 'AT+VGS=15\r':
207                                print "--> Received:",
208                                print buffer
209                                response = '\r\nOK\r\n'
210                                print "<-- Sending:",
211                                print response.replace('\r\n', '')
212                                self.device.write(response)
213                                buffer = ''
214                       
215                        elif buffer == 'AT+VGM=08\r':
216                                print "--> Received:",
217                                print buffer
218                                response = '\r\nOK\r\n'
219                                print "<-- Sending:",
220                                print response.replace('\r\n', '')
221                                self.device.write(response)
222                                buffer = ''
223                               
224                                self.device.close()
225                                sys.exit()
226
227
228#####################################################################
229#####################################################################
230
231        def read_response(self, modem):
232
233                # This function is passed to the modem each time the software
234                # has asked the modem to perform a particular function.
235                # It looks for an "OK" message from the modem, and stores all
236                # data read back from the modem in a line, one entry per response
237                # line. The function returns that list of responses, as well as
238                # a status flag indicating whether the modem timed out while
239                # waiting for the "OK" response. The timeout gets set during
240                # modem initialization, based on the value stored in the database
241
242                modem_timed_out = 0
243
244                #self.log.pdebug("Waiting for 'OK' from %s modem..." % self.modem_type)
245
246                response = []
247
248                while 'OK\r\n' not in response:
249                        reply = modem.readline()
250                        if (len(reply) == 0):
251                                #self.log.perror("Modem timeout has been exceeded")
252                                modem_timed_out = 1
253                                break # The timeout has been exceeded
254                        else:
255                                if (reply != '\r\n'):
256                                        log_reply = string.replace(reply, '\r', '')
257                                        log_reply = string.replace(log_reply, '\n', '')
258                                        #self.log.pdebug(log_reply)
259                                response.append(reply)
260
261                #self.log.debug(response)
262                if self.DEBUG:
263                        print "DEBUG:",
264                        print response
265
266                return (response, modem_timed_out)
267
268
269        ##################################################################
270
271        def test_modem(self, modem):
272
273                # This function simply sends an "AT" command to the modem
274                # and checks for a reponse. It is useful for verifying
275                # that the modem is attached, configured, and functioning correctly
276
277                modem.write("AT\r")
278                (response, modem_timed_out) = read_response(modem)
279
280
281#####################################################################
282# Main
283#####################################################################
284
285if __name__ == '__main__':
286       
287        # Perform correct KeyboardInterrupt handling
288        #signal.signal(signal.SIGINT, signal.SIG_DFL)
289       
290        #log = puzzlebox_logger.puzzlebox_logger(logfile='server_thinkgear')
291        log = None
292       
293        # Collect default settings and command line parameters
294        serial_port = DEFAULT_SERIAL_PORT
295       
296        for each in sys.argv:
297               
298                if each.startswith("--port="):
299                        serial_port = each[ len("--port="): ]
300       
301       
302        #app = QtCore.QCoreApplication(sys.argv)
303       
304        server = puzzlebox_thinkgear_serial_protocol(log, \
305                                                           serial_port, \
306                                                           DEBUG=DEBUG)
307       
308        #sys.exit(app.exec_())
309       
310        server.start()
311       
312       
Note: See TracBrowser for help on using the repository browser.