Subversion Repositories Projects

Rev

Rev 629 | Rev 633 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
584 FredericG 1
#!/usr/bin/env python
2
# -*- coding: iso-8859-15 -*-
3
# generated by wxGlade 0.6.3 on Thu Sep 24 15:46:36 2009
4
 
586 FredericG 5
import sys
606 FredericG 6
import os
612 FredericG 7
import time
8
import thread
9
import ConfigParser
10
 
584 FredericG 11
import wx
585 FredericG 12
import wx.lib
13
import wx.lib.plot
612 FredericG 14
import wx.lib.newevent
623 FredericG 15
import wx.lib.agw.speedmeter as speedmeter
584 FredericG 16
 
613 FredericG 17
import mkProto
18
 
19
 
20
 
21
CHANNEL_NAMES = ["GyroYaw", "GyroRoll", "GyroNick", "Pressure", "Batt", "AccTop", "AccRoll", "AccNick"]
615 FredericG 22
FS = 11111
623 FredericG 23
pi = 3.14
613 FredericG 24
 
626 FredericG 25
rootPath = ""
26
 
585 FredericG 27
# Needs Numeric or numarray or NumPy
28
try:
29
    import numpy.oldnumeric as _Numeric
30
except:
31
    try:
32
        import numarray as _Numeric  #if numarray is used it is renamed Numeric
33
    except:
34
        try:
35
            import Numeric as _Numeric
36
        except:
37
            msg= """
38
            This module requires the Numeric/numarray or NumPy module,
39
            which could not be imported.  It probably is not installed
40
            (it's not part of the standard Python distribution). See the
41
            Numeric Python site (http://numpy.scipy.org) for information on
42
            downloading source or binaries."""
43
            raise ImportError, "Numeric,numarray or NumPy not found. \n" + msg
44
 
584 FredericG 45
# begin wxGlade: extracode
46
# end wxGlade
47
 
48
 
612 FredericG 49
# This creates a new Event class and a EVT binder function
613 FredericG 50
(MeasStatusUpdateEvent, EVT_MEAS_STATUS_UPDATE) = wx.lib.newevent.NewEvent()  
51
(MeasDataEvent, EVT_MEAS_DATA) = wx.lib.newevent.NewEvent()  
584 FredericG 52
 
612 FredericG 53
class MeasureDialog(wx.Dialog):
54
    def __init__(self, *args, **kwds):
55
        # begin wxGlade: MeasureDialog.__init__
626 FredericG 56
        kwds["style"] = wx.CAPTION|wx.RESIZE_BORDER|wx.THICK_FRAME
612 FredericG 57
        wx.Dialog.__init__(self, *args, **kwds)
58
        self.text_ctrl_1 = wx.TextCtrl(self, -1, "", style=wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
59
        self.button = wx.Button(self, -1, "STOP")
623 FredericG 60
        self.voltageCtrl = speedmeter.SpeedMeter(self, extrastyle=speedmeter.SM_DRAW_HAND | speedmeter.SM_DRAW_PARTIAL_SECTORS |  speedmeter.SM_DRAW_MIDDLE_ICON )
61
        self.speedCtrl = speedmeter.SpeedMeter(self, extrastyle=speedmeter.SM_DRAW_HAND | speedmeter.SM_DRAW_PARTIAL_SECTORS | speedmeter.SM_DRAW_MIDDLE_TEXT | speedmeter.SM_DRAW_SECONDARY_TICKS)
626 FredericG 62
 
612 FredericG 63
        self.__set_properties()
64
        self.__do_layout()
65
 
66
        self.Bind(wx.EVT_BUTTON, self.onButton, self.button)
67
        # end wxGlade
68
 
626 FredericG 69
        self.button.SetFocus()
70
 
623 FredericG 71
        YELLOW = wx.Colour(255, 240, 0)
72
        BG = wx.Colour(0x80, 0x80, 0x80)
73
        # Configure Voltage Ctrl
74
        self.voltageCtrl.SetAngleRange(0,pi)
75
        intervals = range(0, 5)
76
        self.voltageCtrl.SetIntervals(intervals)
77
        colours = [wx.RED, wx.GREEN, wx.GREEN, YELLOW]
78
        self.voltageCtrl.SetIntervalColours(colours)
79
        ticks = ["", "", "", "", ""]
80
        self.voltageCtrl.SetTicks(ticks)
81
        self.voltageCtrl.SetTicksColour(wx.WHITE)
82
        self.voltageCtrl.SetHandColour(YELLOW)
83
 
626 FredericG 84
        icon = wx.Icon("%s/Resources/fuel.ico" % rootPath, wx.BITMAP_TYPE_ICO)
623 FredericG 85
        icon.SetWidth(24)
86
        icon.SetHeight(24)
87
 
88
        self.voltageCtrl.SetMiddleIcon(icon)        
89
        self.voltageCtrl.SetSpeedBackground(BG)        
90
        self.voltageCtrl.SetArcColour(wx.WHITE)
91
        self.voltageCtrl.SetSpeedValue(2)
92
 
93
 
94
        # Configure Speed Ctr;
95
        self.speedCtrl.SetAngleRange(0,pi)        
96
        intervals = range(0, 261, 20)
97
        self.speedCtrl.SetIntervals(intervals)
98
 
99
        colours = [BG]*(len(intervals)-1)
100
        for i in range(5,10):
101
          colours[i] = wx.GREEN
102
        self.speedCtrl.SetIntervalColours(colours)
103
        ticks = [str(interval) for interval in intervals]
104
        self.speedCtrl.SetTicks(ticks)
105
        self.speedCtrl.SetTicksColour(wx.WHITE)
106
        self.speedCtrl.SetNumberOfSecondaryTicks(1)
107
        self.speedCtrl.SetTicksFont(wx.Font(7, wx.SWISS, wx.NORMAL, wx.NORMAL))
108
        self.speedCtrl.SetMiddleText("Speed")
109
        self.speedCtrl.SetMiddleTextColour(wx.WHITE)
110
        self.speedCtrl.SetMiddleTextFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.BOLD))
111
        self.speedCtrl.SetHandColour(YELLOW)
112
        self.speedCtrl.SetSpeedBackground(BG)  
113
        self.speedCtrl.SetArcColour(wx.WHITE)        
114
        self.speedCtrl.SetSpeedValue(0)
115
 
116
 
612 FredericG 117
        self.running = True
118
        self.Bind(EVT_MEAS_STATUS_UPDATE, self.OnUpdate)
613 FredericG 119
        self.Bind(EVT_MEAS_DATA, self.OnData)
120
        # The first argument that is passed to the constructor is the parent
121
        self.app = args[0].app
122
        self.error = False
623 FredericG 123
        self.firstVoltage = True
612 FredericG 124
 
623 FredericG 125
 
612 FredericG 126
    def __set_properties(self):
127
        # begin wxGlade: MeasureDialog.__set_properties
128
        self.SetTitle("Measuring Status")
129
        self.text_ctrl_1.SetMinSize((400,300))
623 FredericG 130
        self.voltageCtrl.SetMinSize((50,-1))
131
        self.speedCtrl.SetMinSize((50,-1))
612 FredericG 132
        # end wxGlade
133
 
134
    def __do_layout(self):
135
        # begin wxGlade: MeasureDialog.__do_layout
136
        sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
623 FredericG 137
        sizer_4 = wx.BoxSizer(wx.VERTICAL)
612 FredericG 138
        sizer_2 = wx.BoxSizer(wx.VERTICAL)
139
        sizer_1.Add((20, 20), 0, 0, 0)
140
        sizer_2.Add((20, 20), 0, 0, 0)
141
        sizer_2.Add(self.text_ctrl_1, 1, wx.EXPAND, 0)
142
        sizer_2.Add((20, 20), 0, 0, 0)
143
        sizer_2.Add(self.button, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
144
        sizer_2.Add((20, 20), 0, 0, 0)
145
        sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
146
        sizer_1.Add((20, 20), 0, 0, 0)
623 FredericG 147
        sizer_4.Add(self.voltageCtrl, 1, wx.EXPAND, 0)
148
        sizer_4.Add(self.speedCtrl, 1, wx.EXPAND, 0)
149
        sizer_1.Add(sizer_4, 1, wx.EXPAND, 0)
150
        sizer_1.Add((20, 20), 0, 0, 0)
612 FredericG 151
        self.SetSizer(sizer_1)
152
        sizer_1.Fit(self)
153
        self.Layout()
154
        # end wxGlade
613 FredericG 155
 
156
    def OnData(self, evt):
157
        print "Received Data"
158
        self.app.AddTest2(evt.vibTest)
623 FredericG 159
 
612 FredericG 160
    def OnUpdate(self, evt):
613 FredericG 161
        print "Status update"
612 FredericG 162
        self.running = evt.running
613 FredericG 163
        if evt.error:
164
            self.error = True;
165
            self.text_ctrl_1.WriteText("ERROR: ")
166
            self.text_ctrl_1.SetBackgroundColour("Red")  
612 FredericG 167
        self.text_ctrl_1.WriteText("%s\n"%evt.msg)
168
        if (not self.running):
613 FredericG 169
            if (not self.error):
170
                self.text_ctrl_1.SetBackgroundColour("Green")
171
                self.text_ctrl_1.write(" ") # so that the background is redrawn
623 FredericG 172
            self.button.SetLabel("Close")
613 FredericG 173
 
623 FredericG 174
        if evt.speed != None:
175
            self.speedCtrl.SetSpeedValue(evt.speed)
176
 
177
        if evt.voltage != None:
178
            vmin,vmax,v = evt.voltage
179
            if self.firstVoltage:
180
                ticks = ["", "%.1f V"%vmin, "", "%.1f V"%vmax, ""]
181
                self.voltageCtrl.SetTicks(ticks)
182
                self.firstVoltage = False
183
            i = (v-vmin)/(vmax-vmin)  # 0..1
184
            i *= 2
185
            i = i+1
629 FredericG 186
            i = min(max(i,0.1),4.9)
623 FredericG 187
            self.voltageCtrl.SetSpeedValue(i)
188
 
189
 
612 FredericG 190
 
191
    def onButton(self, event): # wxGlade: MeasureDialog.<event_handler>
192
        if (not self.running):
193
            self.Destroy()
613 FredericG 194
        else:
195
            self.app.cancelMeasurement()
612 FredericG 196
 
197
# end of class MeasureDialog
198
 
199
 
607 FredericG 200
class SettingsDialog(wx.Dialog):
601 FredericG 201
    def __init__(self, *args, **kwds):
607 FredericG 202
        # begin wxGlade: SettingsDialog.__init__
203
        kwds["style"] = wx.DEFAULT_DIALOG_STYLE
204
        wx.Dialog.__init__(self, *args, **kwds)
608 FredericG 205
        self.button_5 = wx.Button(self, wx.ID_CANCEL, "")
206
        self.button_6 = wx.Button(self, wx.ID_OK, "")
601 FredericG 207
 
208
        self.__set_properties()
209
        self.__do_layout()
611 FredericG 210
 
211
        self.Bind(wx.EVT_BUTTON, self.onOK, self.button_6)
601 FredericG 212
        # end wxGlade
213
 
608 FredericG 214
        # The first argument that is passed to the constructor is the parent
611 FredericG 215
        self.settings = args[0].app.settings
608 FredericG 216
        # Add text-boxes for all settings
611 FredericG 217
        self.tb = []
218
        self.grid_sizer_2.SetRows(len(self.settings))
219
        for setting in self.settings.iteritems():
608 FredericG 220
            lb = wx.StaticText(self, -1, setting[1].descr, style=wx.ALIGN_RIGHT)
221
            tb = wx.TextCtrl(self, -1, str(setting[1].value))
222
            self.grid_sizer_2.Add(lb, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
223
            self.grid_sizer_2.Add(tb, 0, 0, 0)
611 FredericG 224
            self.tb.append(tb)
608 FredericG 225
        self.sizer_5.Fit(self)
226
        self.Layout()
227
 
601 FredericG 228
    def __set_properties(self):
607 FredericG 229
        # begin wxGlade: SettingsDialog.__set_properties
601 FredericG 230
        self.SetTitle("Settings")
231
        # end wxGlade
232
 
233
    def __do_layout(self):
607 FredericG 234
        # begin wxGlade: SettingsDialog.__do_layout
608 FredericG 235
        sizer_5 = wx.BoxSizer(wx.VERTICAL)
236
        grid_sizer_3 = wx.GridSizer(1, 2, 0, 0)
237
        sizer_6 = wx.BoxSizer(wx.HORIZONTAL)
238
        grid_sizer_2 = wx.GridSizer(1, 2, 4, 4)
239
        sizer_5.Add((20, 20), 0, 0, 0)
240
        sizer_6.Add((20, 20), 0, 0, 0)
241
        sizer_6.Add(grid_sizer_2, 0, 0, 0)
242
        sizer_6.Add((20, 20), 0, 0, 0)
243
        sizer_5.Add(sizer_6, 1, wx.EXPAND, 0)
244
        sizer_5.Add((20, 20), 0, 0, 0)
245
        grid_sizer_3.Add(self.button_5, 0, wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 0)
246
        grid_sizer_3.Add(self.button_6, 0, wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 0)
247
        sizer_5.Add(grid_sizer_3, 0, wx.EXPAND, 0)
248
        sizer_5.Add((20, 20), 0, 0, 0)
249
        self.SetSizer(sizer_5)
250
        sizer_5.Fit(self)
601 FredericG 251
        self.Layout()
252
        # end wxGlade
253
 
608 FredericG 254
        # Store some of the items, we will need them later
255
        self.grid_sizer_2 = grid_sizer_2  
256
        self.sizer_5 = sizer_5
257
 
258
 
611 FredericG 259
    def onOK(self, event): # wxGlade: SettingsDialog.<event_handler>
260
        print "Updating parameters"
261
        try:
262
            i=0
263
            for setting in self.settings.iteritems():
264
              print setting[0], self.tb[i].GetValue()
265
              setting[1].set(self.tb[i].GetValue())
266
              i += 1
267
            event.Skip()
268
        except:
269
            wx.MessageBox("Invalid format for \"%s\" setting." % setting[1].descr)
270
 
607 FredericG 271
# end of class SettingsDialog
272
 
273
 
274
 
584 FredericG 275
class MainFrame(wx.Frame):
276
    def __init__(self, *args, **kwds):
277
        # begin wxGlade: MainFrame.__init__
278
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
279
        wx.Frame.__init__(self, *args, **kwds)
587 FredericG 280
 
281
        # Menu Bar
282
        self.frame_1_menubar = wx.MenuBar()
283
        wxglade_tmp_menu = wx.Menu()
607 FredericG 284
        wxglade_tmp_menu.Append(101, "Settings", "", wx.ITEM_NORMAL)
616 FredericG 285
        wxglade_tmp_menu.AppendSeparator()
607 FredericG 286
        wxglade_tmp_menu.Append(150, "Exit", "", wx.ITEM_NORMAL)
587 FredericG 287
        self.frame_1_menubar.Append(wxglade_tmp_menu, "File")
288
        wxglade_tmp_menu = wx.Menu()
616 FredericG 289
        wxglade_tmp_menu.Append(301, "Clear All", "", wx.ITEM_NORMAL)
290
        wxglade_tmp_menu.Append(302, "Clear Selected", "", wx.ITEM_NORMAL)
291
        wxglade_tmp_menu.AppendSeparator()
627 FredericG 292
        wxglade_tmp_menu.Append(310, "Select All", "", wx.ITEM_NORMAL)
293
        wxglade_tmp_menu.AppendSeparator()
616 FredericG 294
        wxglade_tmp_menu.Append(303, "Load", "", wx.ITEM_NORMAL)
295
        wxglade_tmp_menu.Append(304, "Save", "", wx.ITEM_NORMAL)
587 FredericG 296
        self.frame_1_menubar.Append(wxglade_tmp_menu, "TestSet")
297
        wxglade_tmp_menu = wx.Menu()
626 FredericG 298
        wxglade_tmp_menu.Append(401, "Flash VibTest FC software", "", wx.ITEM_NORMAL)
299
        wxglade_tmp_menu.Append(402, "Restore original FC software", "", wx.ITEM_NORMAL)
587 FredericG 300
        self.frame_1_menubar.Append(wxglade_tmp_menu, "MK")
301
        wxglade_tmp_menu = wx.Menu()
626 FredericG 302
        wxglade_tmp_menu.Append(1099, "About", "", wx.ITEM_NORMAL)
587 FredericG 303
        self.frame_1_menubar.Append(wxglade_tmp_menu, "Help")
304
        self.SetMenuBar(self.frame_1_menubar)
305
        # Menu Bar end
600 FredericG 306
        self.Description = wx.StaticText(self, -1, "Description")
613 FredericG 307
        self.tcDescr = wx.TextCtrl(self, -1, "Test")
600 FredericG 308
        self.label_37 = wx.StaticText(self, -1, "Speed(s)")
613 FredericG 309
        self.tcSpeeds = wx.TextCtrl(self, -1, "100-200:10")
600 FredericG 310
        self.label_35 = wx.StaticText(self, -1, "Motor(s)")
613 FredericG 311
        self.tcMotors = wx.TextCtrl(self, -1, "1")
600 FredericG 312
        self.label_38 = wx.StaticText(self, -1, "")
626 FredericG 313
        self.panel_2 = wx.Panel(self, -1)
613 FredericG 314
        self.label_36 = wx.StaticText(self, -1, "Channel(s)")
315
        self.tcChannels = wx.TextCtrl(self, -1, "6")
600 FredericG 316
        self.label_39 = wx.StaticText(self, -1, "")
626 FredericG 317
        self.panel_3 = wx.Panel(self, -1)
318
        self.button_4 = wx.Button(self, -1, "Measure")
319
        self.graphCtrl = wx.lib.plot.PlotCanvas(self, size=(800,300))
600 FredericG 320
        self.label_40 = wx.StaticText(self, -1, "Graph Type ")
321
        self.graphTypeChoice = wx.Choice(self, -1, choices=["Raw Signal", "Filtered Signal", "Spectrum"])
322
        self.label_41 = wx.StaticText(self, -1, "Y Axis Range ")
323
        self.yAxisChoice = wx.Choice(self, -1, choices=["25", "50", "100", "200"])
627 FredericG 324
        self.copyGraphButton = wx.Button(self, -1, "Copy Graph Data")
586 FredericG 325
        self.TestListCtrl = wx.ListCtrl(self, -1, style=wx.LC_REPORT|wx.SUNKEN_BORDER)
584 FredericG 326
 
327
        self.__set_properties()
328
        self.__do_layout()
587 FredericG 329
 
607 FredericG 330
        self.Bind(wx.EVT_MENU, self.OnSettings, id=101)
626 FredericG 331
        self.Bind(wx.EVT_MENU, self.onExit, id=150)
607 FredericG 332
        self.Bind(wx.EVT_MENU, self.onClear, id=301)
616 FredericG 333
        self.Bind(wx.EVT_MENU, self.onClearSelected, id=302)
627 FredericG 334
        self.Bind(wx.EVT_MENU, self.onSelectAll, id=310)
616 FredericG 335
        self.Bind(wx.EVT_MENU, self.OnImport, id=303)
336
        self.Bind(wx.EVT_MENU, self.onExport, id=304)
626 FredericG 337
        self.Bind(wx.EVT_MENU, self.onAbout, id=1099)
612 FredericG 338
        self.Bind(wx.EVT_BUTTON, self.onStartMeasure, self.button_4)
600 FredericG 339
        self.Bind(wx.EVT_CHOICE, self.onGraphTypeChange, self.graphTypeChoice)
340
        self.Bind(wx.EVT_CHOICE, self.onYAxisChange, self.yAxisChoice)
627 FredericG 341
        self.Bind(wx.EVT_BUTTON, self.onCopyGraphData, self.copyGraphButton)
584 FredericG 342
        # end wxGlade
626 FredericG 343
        favicon = wx.Icon('%s/Resources/60px-Procman.ico' % rootPath, wx.BITMAP_TYPE_ICO, 32, 32)
344
        wx.Frame.SetIcon(self, favicon)
584 FredericG 345
 
587 FredericG 346
    def setApp(self, app):
347
        self.app = app
585 FredericG 348
 
584 FredericG 349
    def __set_properties(self):
350
        # begin wxGlade: MainFrame.__set_properties
587 FredericG 351
        self.SetTitle("VibrationTest")
600 FredericG 352
        self.SetSize((850, 700))
353
        self.Description.SetMinSize((53, 13))
601 FredericG 354
        self.button_4.SetMinSize((80, 80))
626 FredericG 355
        self.graphCtrl.SetMinSize((800,300))
600 FredericG 356
        self.graphTypeChoice.SetSelection(0)
357
        self.yAxisChoice.SetSelection(1)
358
        self.TestListCtrl.SetMinSize((800,300))
584 FredericG 359
        # end wxGlade
360
 
361
    def __do_layout(self):
362
        # begin wxGlade: MainFrame.__do_layout
600 FredericG 363
        sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
364
        sizer_8 = wx.BoxSizer(wx.VERTICAL)
365
        sizer_11 = wx.BoxSizer(wx.VERTICAL)
366
        sizer_12 = wx.BoxSizer(wx.HORIZONTAL)
367
        sizer_9 = wx.BoxSizer(wx.HORIZONTAL)
368
        sizer_10 = wx.BoxSizer(wx.HORIZONTAL)
369
        grid_sizer_1 = wx.GridSizer(3, 4, 4, 5)
370
        sizer_3.Add((20, 20), 0, 0, 0)
371
        sizer_8.Add((20, 20), 0, 0, 0)
372
        grid_sizer_1.Add(self.Description, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
613 FredericG 373
        grid_sizer_1.Add(self.tcDescr, 0, 0, 0)
600 FredericG 374
        grid_sizer_1.Add(self.label_37, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
613 FredericG 375
        grid_sizer_1.Add(self.tcSpeeds, 0, 0, 0)
600 FredericG 376
        grid_sizer_1.Add(self.label_35, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
613 FredericG 377
        grid_sizer_1.Add(self.tcMotors, 0, 0, 0)
600 FredericG 378
        grid_sizer_1.Add(self.label_38, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
626 FredericG 379
        grid_sizer_1.Add(self.panel_2, 1, wx.EXPAND, 0)
600 FredericG 380
        grid_sizer_1.Add(self.label_36, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
613 FredericG 381
        grid_sizer_1.Add(self.tcChannels, 0, 0, 0)
600 FredericG 382
        grid_sizer_1.Add(self.label_39, 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL, 0)
626 FredericG 383
        grid_sizer_1.Add(self.panel_3, 1, wx.EXPAND, 0)
600 FredericG 384
        sizer_9.Add(grid_sizer_1, 0, 0, 0)
385
        sizer_10.Add((50, 20), 0, 0, 0)
386
        sizer_10.Add(self.button_4, 0, wx.ALIGN_CENTER_VERTICAL, 0)
387
        sizer_9.Add(sizer_10, 1, wx.EXPAND, 0)
388
        sizer_8.Add(sizer_9, 0, 0, 0)
389
        sizer_8.Add((20, 30), 0, 0, 0)
626 FredericG 390
        sizer_11.Add(self.graphCtrl, 1, wx.EXPAND, 0)
600 FredericG 391
        sizer_11.Add((20, 5), 0, 0, 0)
392
        sizer_12.Add(self.label_40, 0, wx.ALIGN_CENTER_VERTICAL, 0)
393
        sizer_12.Add(self.graphTypeChoice, 0, 0, 0)
394
        sizer_12.Add((40, 20), 0, 0, 0)
395
        sizer_12.Add(self.label_41, 0, wx.ALIGN_CENTER_VERTICAL, 0)
396
        sizer_12.Add(self.yAxisChoice, 0, 0, 0)
627 FredericG 397
        sizer_12.Add((80, 20), 0, 0, 0)
398
        sizer_12.Add(self.copyGraphButton, 0, 0, 0)
600 FredericG 399
        sizer_11.Add(sizer_12, 0, 0, 0)
400
        sizer_8.Add(sizer_11, 0, 0, 0)
401
        sizer_8.Add((20, 30), 0, 0, 0)
402
        sizer_8.Add(self.TestListCtrl, 1, 0, 0)
403
        sizer_8.Add((20, 20), 0, 0, 0)
404
        sizer_3.Add(sizer_8, 1, wx.EXPAND, 0)
405
        self.SetSizer(sizer_3)
584 FredericG 406
        self.Layout()
600 FredericG 407
        self.SetSize((850, 700))
584 FredericG 408
        # end wxGlade
409
 
590 FredericG 410
        # List events
411
        self.TestListCtrl.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnTestSelected, self.TestListCtrl)
412
 
586 FredericG 413
        # Configure Graph
626 FredericG 414
        #self.graphCtrl = wx.lib.plot.PlotCanvas(self.GraphPanel, size=(800,300))
593 FredericG 415
 
626 FredericG 416
        self.graphCtrl.SetPointLabelFunc(self.DrawPointLabel)
585 FredericG 417
 
626 FredericG 418
        self.graphCtrl.SetFont(wx.Font(10,wx.SWISS,wx.NORMAL,wx.NORMAL))
419
        self.graphCtrl.SetFontSizeAxis(10)
420
        self.graphCtrl.SetFontSizeLegend(7)
421
        self.graphCtrl.setLogScale((False,False))
585 FredericG 422
 
586 FredericG 423
 
424
        # Configure TestListCtrl
594 FredericG 425
        self.TestListCtrl.InsertColumn(0, "Description")
619 FredericG 426
        self.TestListCtrl.InsertColumn(1, "Voltage")
427
        self.TestListCtrl.InsertColumn(2, "Speed")
428
        self.TestListCtrl.InsertColumn(3, "Channel")
429
        self.TestListCtrl.InsertColumn(4, "Vibration Value")
430
        self.TestListCtrl.SetColumnWidth(4, 500)
586 FredericG 431
 
585 FredericG 432
    def DrawPointLabel(self, dc, mDataDict):
433
        """This is the fuction that defines how the pointLabels are plotted
434
            dc - DC that will be passed
435
            mDataDict - Dictionary of data that you want to use for the pointLabel
436
 
437
            As an example I have decided I want a box at the curve point
438
            with some text information about the curve plotted below.
439
            Any wxDC method can be used.
440
        """
441
        # ----------
442
        dc.SetPen(wx.Pen(wx.BLACK))
443
        dc.SetBrush(wx.Brush( wx.BLACK, wx.SOLID ) )
444
 
445
        sx, sy = mDataDict["scaledXY"] #scaled x,y of closest point
446
        dc.DrawRectangle( sx-5,sy-5, 10, 10)  #10by10 square centered on point
447
        px,py = mDataDict["pointXY"]
448
        cNum = mDataDict["curveNum"]
449
        pntIn = mDataDict["pIndex"]
450
        legend = mDataDict["legend"]
451
        #make a string to display
452
        s = "Crv# %i, '%s', Pt. (%.2f,%.2f), PtInd %i" %(cNum, legend, px, py, pntIn)
453
        dc.DrawText(s, sx , sy+1)
454
        # -----------
455
 
596 FredericG 456
 
457
    def onNewTest(self, test):
458
        index = self.TestListCtrl.InsertStringItem(sys.maxint, test.descr)
619 FredericG 459
        self.TestListCtrl.SetStringItem(index, 1, "%.1f V" %test.voltage)
460
        self.TestListCtrl.SetStringItem(index, 2, str(test.speed))
461
        self.TestListCtrl.SetStringItem(index, 3, test.channel)
607 FredericG 462
 
615 FredericG 463
        vv = int(test.getVibValue(self.app.settings["hpf"].value, self.app.settings["lpf"].value))
607 FredericG 464
        vvs = "|%s| (%d)" % ("----------------------------------------------------------------------------------------------------"[0:min(vv,100)], vv)
619 FredericG 465
        self.TestListCtrl.SetStringItem(index, 4, vvs)
613 FredericG 466
        self.TestListCtrl.Select(index)
596 FredericG 467
 
468
 
590 FredericG 469
    def OnTestSelected(self, event):
470
         testId = event.m_itemIndex
471
         print "Test Selected id=%d" % (testId)
592 FredericG 472
         self.activeTestId = testId
473
         self.drawGraph()
590 FredericG 474
 
592 FredericG 475
    def drawGraph(self):
607 FredericG 476
 
600 FredericG 477
         y = int(self.yAxisChoice.GetStringSelection())
590 FredericG 478
 
607 FredericG 479
         nbSelected = self.TestListCtrl.SelectedItemCount
596 FredericG 480
 
616 FredericG 481
         if nbSelected == 0:
626 FredericG 482
              self.graphCtrl.Clear()
616 FredericG 483
 
484
         elif nbSelected > 1:
607 FredericG 485
             self.graphTypeChoice.Disable()
627 FredericG 486
             self.copyGraphButton.Enable()
607 FredericG 487
             x = 1
488
             data = []
489
             idx = self.TestListCtrl.GetFirstSelected()
490
             while idx != -1:
615 FredericG 491
                 data.append([x,self.app.getTest(idx).getVibValue(self.app.settings["hpf"].value, self.app.settings["lpf"].value)])
607 FredericG 492
                 x += 1
493
                 idx = self.TestListCtrl.GetNextSelected(idx)
494
             line = wx.lib.plot.PolyLine(data, legend= 'Vibrations', colour='red', width=2)
495
             markers = wx.lib.plot.PolyMarker(data, legend= '', colour='red', marker='circle',size=2)
496
             title = "Comparing tests"
629 FredericG 497
             self.graphCtrl.setLogScale((False,False))
626 FredericG 498
             self.graphCtrl.Draw(wx.lib.plot.PlotGraphics([line, markers], title, "Test", "Vibration Value"), xAxis=(1,max(x,10)), yAxis=(0,y))
499
             self.graphCtrl.SetEnableGrid('Horizontal')
600 FredericG 500
 
607 FredericG 501
         else:
502
             self.graphTypeChoice.Enable()
627 FredericG 503
             self.copyGraphButton.Disable()
607 FredericG 504
             vibTest = self.app.getTest(self.activeTestId)
505
             nb = vibTest.getDataLen()
590 FredericG 506
 
607 FredericG 507
             if self.graphTypeChoice.GetSelection() == 0:
508
                 xydata = _Numeric.linspace(0,0.09*nb,2*nb)
509
                 xydata.shape = (nb, 2)
510
                 xydata[:,1] = vibTest.getRawData()
511
                 line = wx.lib.plot.PolyLine(xydata, legend= 'Raw Data', colour='red', width=2)
512
 
513
                 title = "Raw Signal: %s %s %d" %(vibTest.descr, vibTest.channel, vibTest.speed)
629 FredericG 514
                 self.graphCtrl.setLogScale((False,False))
626 FredericG 515
                 self.graphCtrl.Draw(wx.lib.plot.PlotGraphics([line], title, "Time (ms)", "Acc"), yAxis= (-y,y))
516
                 self.graphCtrl.SetEnableGrid('Horizontal')
599 FredericG 517
 
607 FredericG 518
             if self.graphTypeChoice.GetSelection() == 1:
519
                 xydata = _Numeric.linspace(0,0.09*nb,2*nb)
520
                 xydata.shape = (nb, 2)
615 FredericG 521
                 xydata[:,1] = vibTest.getFilteredData(self.app.settings["hpf"].value, self.app.settings["lpf"].value)
607 FredericG 522
                 line = wx.lib.plot.PolyLine(xydata, legend= 'Raw Data', colour='red', width=2)
523
 
524
                 title = "Filtered Signal: %s %s %d" %(vibTest.descr, vibTest.channel, vibTest.speed)
629 FredericG 525
                 self.graphCtrl.setLogScale((False,False))
626 FredericG 526
                 self.graphCtrl.Draw(wx.lib.plot.PlotGraphics([line], title, "Time (ms)", "Acc"), yAxis= (-y,y))
527
                 self.graphCtrl.SetEnableGrid('Horizontal')
607 FredericG 528
 
529
             elif self.graphTypeChoice.GetSelection() == 2:
615 FredericG 530
                 xydata = _Numeric.linspace(0,FS/2,nb)
607 FredericG 531
                 xydata.shape = (nb/2, 2)
532
 
533
                 xydata[:,1] = vibTest.getSpectrum()
629 FredericG 534
 
535
                 #print xydata
607 FredericG 536
 
537
                 line = wx.lib.plot.PolyLine(xydata, legend= 'Spectrum', colour='red')
538
                 markers = wx.lib.plot.PolyMarker(xydata, legend= '', colour='red', marker='circle',size=2)
615 FredericG 539
 
540
                 fc = self.app.settings["hpf"].value
541
                 filterLine1 = wx.lib.plot.PolyLine(((fc,0),(fc,y)), legend='HP Filter', colour='Black', width=4)
542
                 fc = self.app.settings["lpf"].value
543
                 filterLine2 = wx.lib.plot.PolyLine(((fc,0),(fc,y)), legend='HP Filter', colour='Black', width=4)
607 FredericG 544
 
545
                 title = "Spectrum: %s %s %d" %(vibTest.descr, vibTest.channel, vibTest.speed)
626 FredericG 546
                 self.graphCtrl.SetEnableGrid(True)
632 FredericG 547
                 self.graphCtrl.setLogScale((True,False))
548
                 self.graphCtrl.Draw(wx.lib.plot.PlotGraphics([line,markers, filterLine1, filterLine2], title, "Freq (Hz)", "Acc"), xAxis=(20,500), yAxis= (0,y))
629 FredericG 549
 
590 FredericG 550
 
599 FredericG 551
 
587 FredericG 552
    def OnImport(self, event): # wxGlade: MainFrame.<event_handler>
606 FredericG 553
        dlg = wx.FileDialog(
554
            self, message="Choose a file",
619 FredericG 555
            defaultDir="%s/Data/" % os.getcwd(),
606 FredericG 556
            defaultFile="*.txt",
619 FredericG 557
            wildcard="*.txt",
606 FredericG 558
            style=wx.OPEN | wx.CHANGE_DIR
559
            )
560
        if dlg.ShowModal() == wx.ID_OK:
561
            paths = dlg.GetPaths();
619 FredericG 562
            self.app.loadTests(paths[0])
606 FredericG 563
        dlg.Destroy()
587 FredericG 564
 
619 FredericG 565
    def onExport(self, event): # wxGlade: MainFrame.<event_handler>
566
        dlg = wx.FileDialog(
567
              self, message="Save file as ...",
568
              defaultDir="%s/Data/" % os.getcwd(),
569
              defaultFile="*.txt",
570
              wildcard="",
571
              style=wx.SAVE
572
              )
573
        if dlg.ShowModal() == wx.ID_OK:
574
            paths = dlg.GetPaths();
575
            self.app.saveTests(paths[0])
576
        dlg.Destroy()
577
 
599 FredericG 578
    def onYAxisChange(self, event): # wxGlade: MainFrame.<event_handler>
592 FredericG 579
        self.drawGraph()
580
 
600 FredericG 581
    def onGraphTypeChange(self, event): # wxGlade: MainFrame.<event_handler>
599 FredericG 582
        self.drawGraph()
583
 
607 FredericG 584
    def OnSettings(self, event): # wxGlade: MainFrame.<event_handler>
585
        dlg = SettingsDialog(self, -1, "Sample Dialog", size=(350, 200),
586
                         #style=wx.CAPTION | wx.SYSTEM_MENU | wx.THICK_FRAME,
587
                         style=wx.DEFAULT_DIALOG_STYLE, # & ~wx.CLOSE_BOX
588
                         )
589
        dlg.CenterOnScreen()
611 FredericG 590
        val = dlg.ShowModal()  # this does not return until the dialog is closed.
607 FredericG 591
        dlg.Destroy()
611 FredericG 592
        self.app.onSettingsChanged()
607 FredericG 593
 
612 FredericG 594
    def onStartMeasure(self, event): # wxGlade: MainFrame.<event_handler>
613 FredericG 595
        # Collect measure parameters
596
        mp = MeasureParameters()
597
        mp.descr = self.tcDescr.GetValue()
598
        mp.motors = map(int,self.tcMotors.GetValue().split(','))
599
        mp.channels = map(int,self.tcChannels.GetValue().split(','))
600
        s = self.tcSpeeds.GetValue()
619 FredericG 601
        if s=="test":
602
          mp.speeds = (100,100,100,100,100, 150,150,150,150,150, 200,200,200,200,200, 100,150,200, 100,150,200, 100,150,200, 100,150,200)
603
        elif s.count("-") == 1:
613 FredericG 604
            # assume from-to:step format
605
            s = s.split("-")
606
            if len(s) != 2: raise Exception("Invalid format")
607
            s[1] = s[1].split(":")
608
            if len(s[1]) != 2: raise Exception("Invalid format")
609
            mp.speeds = range(int(s[0]),int(s[1][0])+int(s[1][1]),int(s[1][1]))
610
        else:
614 FredericG 611
            mp.speeds = map(int,s.split(','))
612
 
613 FredericG 613
 
612 FredericG 614
        # create the dialog that will show the satus
615
        dlg = MeasureDialog(self)
616
        dlg.CenterOnScreen()
613 FredericG 617
 
618
        # Signal the application
619
        self.app.startMeasure(mp, dlg)
620
 
612 FredericG 621
        # Show the dialog
622
        val = dlg.ShowModal()  # this does not return until the dialog is closed.
623
        dlg.Destroy()
624
 
616 FredericG 625
    def _removeTest(self, idx):
626
        print "Deleting test %d" % idx
627
        self.app.removeTest(idx)
628
        self.TestListCtrl.DeleteItem(idx)
629
 
630
 
631
    def onClear(self, event): # wxGlade: MainFrame.<event_handler>
632
        print "Clear all tests"
633
        for i in range(len(self.app.VibTests)-1, -1, -1):
634
            self._removeTest(i)
635
        self.drawGraph()
636
 
637
 
638
    def onClearSelected(self, event): # wxGlade: MainFrame.<event_handler>
639
        while True:
640
            idx = self.TestListCtrl.GetFirstSelected()
641
            if idx == -1: break
642
            self._removeTest(idx)
643
 
627 FredericG 644
 
626 FredericG 645
 
646
    def onAbout(self, event): # wxGlade: MainFrame.<event_handler>
647
         # First we create and fill the info object
648
        print "about"
649
        info = wx.AboutDialogInfo()
650
        info.Name = "MK Vibration Test"
651
        info.Version = "0.2"
652
        info.Copyright = ""
653
        info.Developers=["Frederic Goddeeris"]
654
        info.Description = "Please consult the WIKI page for a complete description of the tool:"
655
        info.WebSite = ("http://www.mikrokopter.de/ucwiki/en/VibrationTest", "VibrationTest WIKI page")
656
        wx.AboutBox(info)
657
 
658
 
659
    def onExit(self, event): # wxGlade: MainFrame.<event_handler>
660
        self.Close(True)
661
 
662
 
627 FredericG 663
    def onSelectAll(self, event): # wxGlade: MainFrame.<event_handler>
664
        for i in xrange(self.TestListCtrl.GetItemCount()):
665
          self.TestListCtrl.Select(i)
666
 
667
    def onCopyGraphData(self, event): # wxGlade: MainFrame.<event_handler>
668
        clipdata = wx.TextDataObject()
669
        txt = ""
670
        idx = self.TestListCtrl.GetFirstSelected()
671
        while idx != -1:
672
             txt += ("%d\n" % self.app.getTest(idx).getVibValue(self.app.settings["hpf"].value, self.app.settings["lpf"].value))
673
             idx = self.TestListCtrl.GetNextSelected(idx)
674
        clipdata.SetText(txt)
675
        wx.TheClipboard.Open()
676
        wx.TheClipboard.SetData(clipdata)
677
        wx.TheClipboard.Close()
678
 
584 FredericG 679
# end of class MainFrame
680
 
607 FredericG 681
class Setting:
682
    def __init__(self, descr, defaultValue):
683
        self.descr = descr
684
        self.value = defaultValue
611 FredericG 685
 
686
    def set(self, newValue):
687
        if isinstance(self.value, int):
688
            self.value = int(newValue)
689
        else:
690
            self.value = str(newValue)
584 FredericG 691
 
613 FredericG 692
class MeasureParameters:
693
      pass
612 FredericG 694
 
695
class MeasureThread:
613 FredericG 696
    def __init__(self, measureParameters, evtConsumer):
697
        self.mk = mkProto.MkComm()
698
        self.param = measureParameters
612 FredericG 699
        self.evtConsumer = evtConsumer
613 FredericG 700
        self.cancel = False
701
        self.running = False
612 FredericG 702
 
703
    def start(self):
704
        thread.start_new_thread(self._run, ())
705
 
613 FredericG 706
    def stop(self):
707
        self.cancel = True
708
 
709
    def _testCancel(self):
710
        if self.cancel:
711
            raise Exception("Operation cancelled")
712
 
623 FredericG 713
    def _sendEvent(self, msg=None, error=False, parVoltage=None, speed=None):
714
        evt = MeasStatusUpdateEvent(running=self.running, msg=msg, error=error, voltage=parVoltage, speed=speed)
613 FredericG 715
        wx.PostEvent(self.evtConsumer, evt)
716
 
717
    def _setMotorSpeed(self, speed, settlingTime):
718
        speeds = [0,0,0,0]
719
        for motor in self.param.motors:
720
            speeds[motor-1] = speed
721
        for i in range(int(settlingTime*10)):
722
          self._testCancel()
723
          self.mk.setMotorTest(speeds)
724
          time.sleep(.1)
725
 
726
 
612 FredericG 727
    def _run(self):
613 FredericG 728
        self.running = True
729
        self._sendEvent("Starting test \"%s\"" % self.param.descr)    
730
 
731
        try:
732
            self._sendEvent("Opening SerialPort \"%s\"" % self.param.serialPort)
733
            self.mk.open(comPort=self.param.serialPort)
612 FredericG 734
 
613 FredericG 735
            msg = self.mk.getVersionMsg()
736
            version = msg.getVersion()
737
            self._sendEvent("Version: %d.%d" % version)
738
 
739
            msg = self.mk.getDebugMsg()
740
            voltage = msg.getVoltage()
741
            if (voltage == 0):
628 FredericG 742
              # Board is probably fed by USB
613 FredericG 743
              minVoltage = 0
623 FredericG 744
              maxVoltage = 1
613 FredericG 745
            else:
628 FredericG 746
              # Determine the n umber of cells
613 FredericG 747
              if (voltage > 4.2*3):
623 FredericG 748
                nbCells = 4  
613 FredericG 749
              else:
623 FredericG 750
                nbCells = 3
628 FredericG 751
              # Set minimum and maximum voltages
752
              if self.param.minVoltage > 0:
753
                minVoltage =  self.param.minVoltage
754
              else:
755
                minVoltage = nbCells*3.5  # auto
756
              if self.param.maxVoltage > 0:
757
                maxVoltage =  self.param.maxVoltage
758
              else:
759
                maxVoltage = nbCells*3.9  
760
 
613 FredericG 761
            self._sendEvent("Voltage: %2.1fV" % voltage)
623 FredericG 762
            self._sendEvent("Min/Max Voltage: %2.1fV-%2.1fV" % (minVoltage, maxVoltage), parVoltage=(minVoltage, maxVoltage, voltage))
763
 
764
            self._sendEvent("Starting motor(s) (speed=%d)... " % self.param.motorStartupSpeed, speed=self.param.motorStartupSpeed)
613 FredericG 765
            self._setMotorSpeed(self.param.motorStartupSpeed, self.param.motorStartupSettlingTime)
766
 
767
            for speed in self.param.speeds:
623 FredericG 768
                self._sendEvent("Changing motor speed to %d... " % speed, speed=speed)
613 FredericG 769
                self._setMotorSpeed(speed, 1)
770
 
771
                for channel in self.param.channels:
772
                    self._setMotorSpeed(speed, .1)
619 FredericG 773
                    msg = self.mk.getDebugMsg()
774
                    voltage = msg.getVoltage()
775
 
623 FredericG 776
                    self._sendEvent("Getting data from channel %s" % CHANNEL_NAMES[channel], parVoltage=(minVoltage, maxVoltage, voltage))
613 FredericG 777
                    data = self.mk.doVibrationTest(1000, channel)
778
 
619 FredericG 779
                    vt = VibTest(self.param.descr, voltage, self.param.motors, speed, CHANNEL_NAMES[channel], data)
613 FredericG 780
                    evt = MeasDataEvent(vibTest = vt)
781
                    wx.PostEvent(self.evtConsumer, evt)
782
 
619 FredericG 783
                    if voltage<minVoltage:
784
                        raise Exception("Voltage too low")
785
 
613 FredericG 786
            self._sendEvent("Done !")            
629 FredericG 787
            self._setMotorSpeed(speed, .1)
612 FredericG 788
 
613 FredericG 789
        except Exception, e:
790
            self._sendEvent("Exception \"%s\"" % e, error=True)  
791
 
792
        self.running = False
629 FredericG 793
        self._sendEvent("", speed = 0)    
613 FredericG 794
 
612 FredericG 795
 
586 FredericG 796
class VibTest:
619 FredericG 797
    def __init__(self, descr, voltage, motor, speed, channel, rawData):
594 FredericG 798
        self.descr = descr
619 FredericG 799
        self.voltage = voltage
594 FredericG 800
        self.motor = motor
801
        self.speed = speed
596 FredericG 802
        self.channel = channel
599 FredericG 803
 
804
        self.dataLen = len(rawData)
805
 
590 FredericG 806
        self.rawData = _Numeric.array(rawData)
807
        self.dc = self.rawData.mean()
808
        self.rawData -= self.dc
586 FredericG 809
 
600 FredericG 810
        self.fft = _Numeric.fft.rfft(self.rawData)
811
 
812
        self.spectrum = None
813
        self.filteredData = None
615 FredericG 814
        self.fc1 = None
815
        self.fc2 = None
599 FredericG 816
 
602 FredericG 817
        self.vibValue = None
818
 
594 FredericG 819
    def getDescr(self):
820
        return self.Descr
587 FredericG 821
 
590 FredericG 822
    def getRawData(self):
823
        return self.rawData
824
 
825
    def getDataLen(self):
826
        return self.dataLen
827
 
599 FredericG 828
    def getSpectrum(self):
600 FredericG 829
        if self.spectrum == None:
830
            self.spectrum = _Numeric.absolute(self.fft[1:self.dataLen/2+1]) / (self.dataLen/2)
831
        return self.spectrum
590 FredericG 832
 
615 FredericG 833
    def getFilteredData(self, fc1, fc2):
834
        if self.fc1 != fc1 or self.fc2 != fc2:
835
            self.filteredData = None  
836
 
600 FredericG 837
        if self.filteredData == None:
838
            tmpfft = self.fft.copy()
615 FredericG 839
            fc = (float(fc1))/(FS/2)*len(tmpfft)
840
            print "fc1=%d => fc=%d" % (fc1,fc)
841
            for i in range(0,int(fc)):
600 FredericG 842
                tmpfft[i] = 0
615 FredericG 843
            fc = (float(fc2))/(FS/2)*len(tmpfft)
844
            print "fc2=%d => fc=%d" % (fc2,fc)
845
            for i in range(int(fc), len(tmpfft)):
600 FredericG 846
                tmpfft[i] = 0
847
            self.filteredData = _Numeric.fft.irfft(tmpfft)
615 FredericG 848
            self.fc1 = fc1
849
            self.fc2 = fc2
850
 
600 FredericG 851
        return self.filteredData
602 FredericG 852
 
615 FredericG 853
    def getVibValue(self, fc1, fc2):
854
      if self.fc1 != fc1 or self.fc2 != fc2:
855
        self.vibValue = None  
602 FredericG 856
      if self.vibValue == None:
615 FredericG 857
        fd = self.getFilteredData(fc1, fc2)[100:-100];
602 FredericG 858
        self.vibValue = max(fd)-min(fd)
859
      return self.vibValue
599 FredericG 860
 
607 FredericG 861
 
862
 
584 FredericG 863
class App(wx.App):
607 FredericG 864
 
865
    SETTINGSFILE = "settings.cfg"
866
 
586 FredericG 867
    def __init__(self, par):
868
        self.VibTests = []
869
        wx.App.__init__(self, par)
870
 
607 FredericG 871
        # Init settings
872
        self.settings={}
611 FredericG 873
        self.settings["serialport"] = Setting("Serial Port", "COM1")
613 FredericG 874
        self.settings["startupspeed"] = Setting("Motor Startup Speed", 25)
875
        self.settings["startupsettling"] = Setting("Motor Startup Setting time (s)", 3)
876
        self.settings["serialport"] = Setting("Serial Port", "COM1")
607 FredericG 877
        self.settings["hpf"] = Setting("HP Filter cutoff (Hz)", 50)
632 FredericG 878
        self.settings["lpf"] = Setting("LP Filter cutoff (Hz)", 400)
628 FredericG 879
        self.settings["minvoltage"] = Setting("Minimum Bettery Voltage (0=Automatic) (V) ", 0)
880
        self.settings["maxvoltage"] = Setting("Maximum Bettery Voltage (0=Automatic) (V) ", 0)
607 FredericG 881
 
628 FredericG 882
 
607 FredericG 883
        self.readSettings()
884
 
606 FredericG 885
        if len(sys.argv)>1:
619 FredericG 886
            self.loadTests(sys.argv[1])
586 FredericG 887
 
606 FredericG 888
 
607 FredericG 889
    def readSettings(self):
890
        print "Reading settings"
891
        cp = ConfigParser.ConfigParser()
892
 
893
        try:
894
            cp.read(App.SETTINGSFILE)
895
            for setting in cp.items("DEFAULT"):
896
                print " ",setting
897
                try:
613 FredericG 898
                    self.settings[setting[0]].set(setting[1])
607 FredericG 899
                except:
900
                    print "WARNING, unknown setting"
901
        except:
902
            print "ERROR reading settingsfile"
903
 
904
 
905
    def storeSettings(self):
906
        print "Storing settings"
907
 
908
        cp = ConfigParser.ConfigParser()
909
        for setting in self.settings.iteritems():
910
            cp.set("", setting[0], setting[1].value)
911
 
912
        file = open(App.SETTINGSFILE, "w")
913
        cp.write(file)
914
        file.close()
915
 
611 FredericG 916
 
917
    def onSettingsChanged(self):
918
        self.storeSettings()
613 FredericG 919
 
920
    def AddTest2(self, vibTest):
921
        self.VibTests.append(vibTest)
922
        self.frame_1.onNewTest(vibTest)
611 FredericG 923
 
619 FredericG 924
    def AddTest(self, descr, voltage, motor, speed, channel, rawData):
925
        test = VibTest(descr, voltage, motor, speed, channel, rawData)
613 FredericG 926
        self.AddTest2(test)
586 FredericG 927
 
616 FredericG 928
    def removeTest(self, idx):
929
        del(self.VibTests[idx])
930
 
590 FredericG 931
    def getTest(self, testId):
932
        return self.VibTests[testId]
933
 
584 FredericG 934
    def OnInit(self):
935
        wx.InitAllImageHandlers()
586 FredericG 936
        self.frame_1 = MainFrame(None, -1, "")
587 FredericG 937
        self.frame_1.setApp(self);
586 FredericG 938
        self.SetTopWindow(self.frame_1)
939
 
607 FredericG 940
        self.frame_1.CenterOnScreen()
587 FredericG 941
        self.frame_1.Show()
942
        return 1
943
 
619 FredericG 944
    def saveTests(self, filePath):
945
        try:
946
          logfile = open(filePath, "r")
947
          newFile = False
948
          logfile.close()
949
        except:
950
          newFile = True
951
 
952
        for test in self.VibTests:
953
          if newFile:
954
            logfile = open(filePath, "w")
955
            print "Writing result to %s ..." % filePath,
956
            logfile.write("%s %d %s\n" % (test.descr, test.speed, test.channel))
957
            for value in test.rawData:
958
              logfile.write("%d\n" % value)
959
            logfile.close()  
960
            print "OK"
961
          else:
962
            print "Appending result to %s ..." % filePath,
963
            logfile = open(filePath, "r")
964
            prevData = []
965
            for line in logfile:
966
              prevData.append(line[:-1])
967
            logfile.close()
968
            logfile = open(filePath, "w")
969
            logfile.write("%s,%s %d %s\n" % (prevData[0], test.descr, test.speed, test.channel))
970
            i = 1
971
            for value in test.rawData:
972
              logfile.write("%s,%d\n" % (prevData[i], value))
973
              i += 1
974
            logfile.close()
975
            print "OK"
976
          newFile = False
977
 
978
 
979
    def loadTests(self, filePath):
596 FredericG 980
 
606 FredericG 981
        print "Importing file \"%s\"" % filePath
596 FredericG 982
 
983
        logfile = open(filePath, "r")
590 FredericG 984
        data = None
596 FredericG 985
 
619 FredericG 986
        headers = (logfile.readline()[:-1]).split(',')
596 FredericG 987
        nbCols = len(headers)
988
        print "NbCols =", nbCols
989
 
990
        data = []
991
        descr = []
992
        speed = []
993
        channel = []
994
        for c in range(nbCols):
995
            data.append([])
996
            h = headers[c].split(' ')
997
            descr.append(h[0]);
998
            speed.append(h[1]);
999
            channel.append(h[2]);
1000
 
590 FredericG 1001
        for line in logfile:
1002
            values = line.split(',')
596 FredericG 1003
            for i in range(nbCols):
1004
                data[i].append(int(values[i]))
590 FredericG 1005
        logfile.close()
596 FredericG 1006
 
1007
        for c in range(nbCols):
599 FredericG 1008
            if (len(data[c]) % 2) != 0:
1009
                data[c].append(data[c][-1])
619 FredericG 1010
            self.AddTest(descr[c], 0, 0, int(speed[c]), channel[c], data[c])
612 FredericG 1011
 
613 FredericG 1012
    def startMeasure(self, measureParams, dialog):
612 FredericG 1013
        print "Start measuring"
590 FredericG 1014
 
613 FredericG 1015
        measureParams.serialPort = self.settings["serialport"].value
1016
        measureParams.motorStartupSpeed = self.settings["startupspeed"].value
1017
        measureParams.motorStartupSettlingTime = self.settings["startupsettling"].value
628 FredericG 1018
        measureParams.minVoltage = self.settings["minvoltage"].value
1019
        measureParams.maxVoltage = self.settings["maxvoltage"].value        
613 FredericG 1020
 
1021
        self.measureThread = MeasureThread(measureParams, dialog)
612 FredericG 1022
        self.measureThread.start()
590 FredericG 1023
 
613 FredericG 1024
    def cancelMeasurement(self):
1025
        print "Measuring CANCEL"
1026
 
1027
        self.measureThread.stop()
1028
 
612 FredericG 1029
 
1030
 
1031
 
1032
 
590 FredericG 1033
 
586 FredericG 1034
 
590 FredericG 1035
 
584 FredericG 1036
# end of class App
1037
 
1038
if __name__ == "__main__":
626 FredericG 1039
 
1040
    rootPath = os.path.abspath(os.path.dirname(sys.argv[0]))
1041
 
1042
    print rootPath
1043
 
584 FredericG 1044
    VibrationTestGui = App(0)
1045
    VibrationTestGui.MainLoop()