summaryrefslogtreecommitdiffstats
path: root/Src/eclipse/.metadata/.plugins/org.eclipse.core.resources/.history/56/a0aab0d478f2001019c79f38f40e52ba
blob: 16f9c2908bba132a1fb4a31e510ef25ab64f1c65 (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
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('',line)
                        if match:
                            base_station.neighbours
                        #get provider
                        line = line = scan_process.stdout.readline()
                        #get arfcn
                        line = line = scan_process.stdout.readline()
                        #get rx
                        line = line = scan_process.stdout.readline()
                        #get neighbours
                        line = line = scan_process.stdout.readline()
                        #endinfo
                        line = line = scan_process.stdout.readline()
                        
                        self._base_station_found_callback(base_station)
            print 'killing scan'
            scan_process.kill()