summaryrefslogtreecommitdiffstats
path: root/Src/PyCatcher/src/driverConnector.py
blob: dea253f20db9614d7867191d50260ca2841783f7 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
from pyCatcherModel import BaseStationInformation
import subprocess
import threading 
import re
from settings import Commands
import time
import gtk 

class DriverConnector:        
    def __init__ (self):
        self._scan_thread_break = False
        self._firmware_thread_break = False
        self._firmware_waiting_callback = None
        self._firmware_loaded_callback = None
        self._base_station_found_callback = None
        self._firmware_thread = None
        self._scan_thread = None
        
    def start_scanning (self, base_station_found_callback):
        self._base_station_found_callback = base_station_found_callback
        self._scan_thread = ScanThread(self._base_station_found_callback)
        self._scan_thread.start()

    def start_firmware(self, firmware_waiting_callback, firmware_loaded_callback):
        self._firmware_waiting_callback = firmware_waiting_callback
        self._firmware_loaded_callback = firmware_loaded_callback      
        self._firmware_thread = FirmwareThread(self._firmware_waiting_callback, self._firmware_loaded_callback)
        self._firmware_thread.start()
        
    def stop_scanning (self):
        self._scan_thread.terminate()
        
    def stop_firmware(self):
        self._firmware_thread_break = True
        
    def shutdown(self):
        if self._firmware_thread:
            self._firmware_thread.join(3)
        if self._scan_thread:
            self._scan_thread.join(3)
        
class FirmwareThread(threading.Thread):
    def __init__(self, firmware_waiting_callback, firmware_loaded_callback):
        gtk.gdk.threads_init()
        threading.Thread.__init__(self)
        self._firmware_waiting_callback = firmware_waiting_callback
        self._firmware_loaded_callback = firmware_loaded_callback
        self._thread_break = False

    def terminate(self):
        self._thread_break = True
       
    def run(self):
        loader_process_object = subprocess.Popen(Commands['osmocon_command'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        time.sleep(3)
        self._firmware_waiting_callback()
        while not self._thread_break:
            line = loader_process_object.stdout.readline()
            #if line:
            #    print line
            if line.strip() == 'Finishing download phase':
                self._firmware_loaded_callback()
            #time.sleep(0.5)
        loader_process_object.terminate()

class ScanThread(threading.Thread):
        def __init__(self, base_station_found_callback):
            gtk.gdk.threads_init()
            threading.Thread.__init__(self)
            self._base_station_found_callback = base_station_found_callback
            self._thread_break = False
            
        def terminate(self):
            self._thread_break = True
        
        def run(self): 
            scan_process = subprocess.Popen(Commands['scan_command'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
            time.sleep(2)
            while not self._thread_break:
                line = scan_process.stdout.readline()
                if line:
                    #print line
                    #sys.stdout.flush()
                    if re.search('SysInfo', line):
                        base_station = BaseStationInformation()
                        #get country
                        line = scan_process.stdout.readline()
                        match = re.search(r'Country:\s(\w+)',line)
                        if match:
                            base_station.country = match.group(1)
                        #get provider
                        line = scan_process.stdout.readline()
                        match = re.search(r'Provider:\s(.+)',line)
                        if match:
                            base_station.provider = match.group(1)
                        #get arfcn
                        line = scan_process.stdout.readline()
                        match = re.search(r'ARFCN:\s(\d+)',line)
                        if match:
                            base_station.arfcn = int(match.group(1))
                        #get cell id
                        line = scan_process.stdout.readline()
                        match = re.search(r'Cell ID:\s(\d+)',line)
                        if match:
                            base_station.cell = int(match.group(1))
                        #get lac
                        line = scan_process.stdout.readline()
                        match = re.search(r'LAC:\s(\d+)',line)
                        if match:
                            base_station.lac = int(match.group(1))
                        #get bsic
                        line = scan_process.stdout.readline()
                        match = re.search(r'BSIC:\s(\d+,\d+)',line)
                        if match:
                            base_station.bsic = match.group(1)
                        #get rxlev
                        line = scan_process.stdout.readline()
                        match = re.search(r'rxlev:\s(.\d+)',line)
                        if match:
                            base_station.rxlev = int(match.group(1))
                        line = scan_process.stdout.readline()
                        match = re.search(r'\s((\d+)\s)*',line)
                        if match:
                            base_station.neighbours = map(int,match.group(0).strip().split(' '))
                        #get si1
                        line = scan_process.stdout.readline()
                        match = re.search(r'SI1:\s(.+)',line)
                        if match:
                            base_station.system_info_t1 = match.group(1).split(' ')
                        #get si3
                        line = scan_process.stdout.readline()
                        match = re.search(r'SI3:\s(.+)',line)
                        if match:
                            base_station.system_info_t3 = match.group(1).split(' ')
                        #get si4
                        line = scan_process.stdout.readline()
                        match = re.search(r'SI4:\s(.+)',line)
                        if match:
                            base_station.system_info_t4 = match.group(1).split(' ')
                        #get si2
                        line = scan_process.stdout.readline()
                        match = re.search(r'SI2:\s(.+)',line)
                        if match:
                            base_station.system_info_t2 = match.group(1).split(' ')
                        #get si2ter
                        line = scan_process.stdout.readline()
                        match = re.search(r'SI2ter:\s(.+)',line)
                        if match:
                            base_station.system_info_t2ter = match.group(1).split(' ')
                        #get si2bis
                        line = scan_process.stdout.readline()
                        match = re.search(r'SI2bis:\s(.+)',line)
                        if match:
                            base_station.system_info_t2bis = match.group(1).split(' ')
                        #endinfo
                        scan_process.stdout.readline()
                        
                        self._base_station_found_callback(base_station)
            scan_process.terminate()