summaryrefslogtreecommitdiffstats
path: root/Src/eclipse/.metadata/.plugins/org.eclipse.core.resources/.history/1c/00ad039779f2001019c79f38f40e52ba
blob: f1e12918cf71dd0bdb5ca8d9f460c47ccbcba75b (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
from pyCatcherModel import BaseStationInformation
import subprocess
import threading 
import re
from pyCatcherSettings import Commands
import sys
import time
import gtk #@UnresolvedImport

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
        
    def start_scanning (self, base_station_found_callback):
        self._scan_thread_break = False
        self._base_station_found_callback = base_station_found_callback
        self._scanThread = ScanThread(self._base_station_found_callback, self._scan_thread_break)
        self._scanThread.start()

    def start_firmware(self, firmware_waiting_callback, firmware_loaded_callback):
        self._firmware_thread_break = False
        self._firmware_waiting_callback = firmware_waiting_callback
        self._firmware_loaded_callback = firmware_loaded_callback      
        self._firmThread = FirmwareThread(self._firmware_waiting_callback, self._firmware_loaded_callback, self._firmware_thread_break)
        self._firmThread.start()
        
    def stop_scanning (self):
        self._scan_thread_break = True
        
    def stop_firmware(self):
        self._firmware_thread_break = True
        
    def shutdown(self):
        self._firmThread.join(10)
        self._scanThread.join(10)
        
class FirmwareThread(threading.Thread):
    def __init__(self, firmware_waiting_callback, firmware_loaded_callback, thread_break):
        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 = thread_break
       
    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)
        print 'killing firmware'
        loader_process_object.kill()

class ScanThread(threading.Thread):
        def __init__(self, base_station_found_callback, thread_break):
            gtk.gdk.threads_init()
            threading.Thread.__init__(self)
            self._base_station_found_callback = base_station_found_callback
            self._thread_break = thread_break
        
        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 = line = scan_process.stdout.readline()
                        match = re.search(r'country\s(\w+)',line)
                        if match:
                            base_station.country = match.group(1)
                        #get provider
                        line = line = scan_process.stdout.readline()
                        match = re.search(r'provider\s(.+)',line)
                        if match:
                            base_station.country = match.group(1)
                        #get arfcn
                        line = line = scan_process.stdout.readline()
                        match = re.search(r'arfcn\s(\d+)',line)
                        if match:
                            base_station.country = match.group(1)
                        #get rx
                        line = line = scan_process.stdout.readline()
                        match = re.search(r'',line)
                        if match:
                            base_station.country = match.group(1)
                        #get neighbours
                        line = line = scan_process.stdout.readline()
                        match = re.search(r'',line)
                        if match:
                            base_station.country = match.group(1)
                        #endinfo
                        line = line = scan_process.stdout.readline()
                        
                        self._base_station_found_callback(base_station)
            print 'killing scan'
            scan_process.kill()