Subversion Repositories Projects

Rev

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