/elec/quadcopter

To get this branch, use:
bzr branch http://bzr.ed.am/elec/quadcopter

« back to all changes in this revision

Viewing changes to test/rc-interface/rc-interface-test

  • Committer: Tim Marston
  • Date: 2014-02-05 19:19:00 UTC
  • Revision ID: tim@ed.am-20140205191900-vsc9juuji1zjn7tc
added project dir

Show diffs side-by-side

added added

removed removed

test/rc-interface/rc-interface-test
15
15
        # number of channels to read
16
16
        NUM_CHANNELS = 8
17
17
 
18
 
        # number of motor channels
19
 
        NUM_MOTORS = 4
20
 
 
21
18
        # maximum channel value
22
19
        MAX_CHANNEL_VALUE = 1000
23
20
 
26
23
 
27
24
 
28
25
        def __init__( self ):
29
 
                try:
30
 
                        self.link = serial.Serial( self.SERIAL_DEVICE, 9600 )
31
 
                        self.link_error = None
32
 
                except serial.serialutil.SerialException as e:
33
 
                        self.link = None
34
 
                        self.link_error = e
 
26
                self.link = serial.Serial( self.SERIAL_DEVICE, 9600 )
35
27
                self.got_one = False
36
 
                self.motor_values = [ 0 ] * self.NUM_MOTORS
 
28
                self.channel_values = []
37
29
                self.quit = False
38
30
                self.buffer = bytearray()
39
31
 
40
32
 
41
 
        def add_info( self, vbox, heading = False, text = '' ):
42
 
                label = gtk.Label()
43
 
                if( heading ):
44
 
                        label.set_markup( "<b>%s</b>" % text )
45
 
                else:
46
 
                        label.set_label( text )
47
 
#               label.set_justify( gtk.JUSTIFY_LEFT )
48
 
                label.set_alignment( 0, 0 )
49
 
                vbox.pack_start( label, False, False )
50
 
 
51
33
        def setup_window( self ):
52
34
 
53
35
                # create and set up window
59
41
                self.window.set_modal( True )
60
42
                self.window.connect( "key-press-event", self.key_press_event )
61
43
 
62
 
                hbox = gtk.HBox( False, 10 )
63
 
                self.window.add( hbox )
64
 
 
65
 
                # controls frame
66
 
                frame = gtk.Frame( "Channels" )
67
 
                frame.set_shadow_type( gtk.SHADOW_IN )
68
 
                hbox.pack_start( frame )
69
 
 
70
 
                table = gtk.Table( 2, self.NUM_CHANNELS )
71
 
                table.set_border_width( 25 )
72
 
                table.set_row_spacings( 10 )
73
 
                table.set_col_spacings( 15 )
74
 
                frame.add( table )
 
44
                # add widgets
 
45
                table = gtk.Table( self.NUM_CHANNELS, 2 )
 
46
                table.set_row_spacings( 20 )
 
47
                table.set_col_spacings( 10 )
 
48
                self.window.add( table )
75
49
 
76
50
                # add channels
77
51
                self.controls = []
78
 
                for a in range( self.NUM_CHANNELS ):
 
52
                for a in range( 0, self.NUM_CHANNELS ):
79
53
 
80
 
                        label = gtk.Label( a + 1 )
81
 
                        table.attach( label, a, a + 1, 1, 2 )
 
54
                        label = gtk.Label( "Channel %d" % ( a + 1 ) )
 
55
                        table.attach( label, 0, 1, a, a + 1 )
82
56
 
83
57
                        adj = gtk.Adjustment( 0, 0, self.MAX_CHANNEL_VALUE, 1, 0, 0 )
84
 
                        control = gtk.VScale( adj )
 
58
                        control = gtk.HScale( adj )
85
59
                        control.set_draw_value( False )
86
 
                        control.set_inverted( True )
87
 
                        control.set_size_request( -1, 200 )
 
60
                        control.set_property( 'width-request', 300 )
88
61
                        control.set_sensitive( False )
89
 
                        table.attach( control, a, a + 1, 0, 1 )
 
62
                        table.attach( control, 1, 2, a, a + 1 )
90
63
 
91
64
                        self.controls.append( control )
92
65
 
93
 
                # motors frame
94
 
                frame = gtk.Frame( "Motors" )
95
 
                frame.set_shadow_type( gtk.SHADOW_IN )
96
 
                hbox.pack_start( frame )
97
 
 
98
 
                table = gtk.Table( 2, self.NUM_MOTORS )
99
 
                table.set_border_width( 25 )
100
 
                table.set_row_spacings( 10 )
101
 
                table.set_col_spacings( 15 )
102
 
                frame.add( table )
103
 
 
104
 
                # add motor controls
105
 
                self.motors = []
106
 
                for a in range( self.NUM_MOTORS ):
107
 
 
108
 
                        label = gtk.Label( a + 1 )
109
 
                        table.attach( label, a, a + 1, 1, 2 )
110
 
 
111
 
                        adj = gtk.Adjustment( 0, 0, self.MAX_CHANNEL_VALUE, 1, 0, 0 )
112
 
                        control = gtk.VScale( adj )
113
 
                        control.set_draw_value( False )
114
 
                        control.set_inverted( True )
115
 
                        control.set_size_request( -1, 200 )
116
 
                        table.attach( control, a, a + 1, 0, 1 )
117
 
 
118
 
                        control.connect( "value-changed", self.on_motor_change, a )
119
 
 
120
 
                        self.motors.append( control )
121
 
 
122
 
                # info frame
123
 
                frame = gtk.Frame( "Info" )
124
 
                hbox.pack_start( frame )
125
 
 
126
 
                vbox = gtk.VBox()
127
 
                vbox.set_border_width( 10 )
128
 
                frame.add( vbox )
129
 
 
130
 
                self.add_info( vbox, True, "USB Device:" )
131
 
                self.add_info( vbox, False, self.SERIAL_DEVICE )
132
 
                self.add_info( vbox )
133
 
 
134
 
                if( self.link_error is not None ):
135
 
                        self.add_info( vbox, True, "USB Error:" )
136
 
                        label = gtk.Label( self.link_error )
137
 
                        label.set_line_wrap( True )
138
 
                        label.set_size_request( 150, -1 )
139
 
                        vbox.pack_start( label, False )
140
 
                else:
141
 
                        pass
142
 
 
143
 
                vbox.pack_start( gtk.Label( "" ) )
144
 
 
145
66
                # show it
146
67
                self.window.show_all()
147
68
 
148
69
 
149
 
        def on_motor_change( self, widget, motor ):
150
 
                self.motor_values[ motor ] = int( widget.get_value() )
151
 
                self.write_serial()
152
 
 
153
 
 
154
70
        def key_press_event( self, widget, event ):
155
71
                if event.keyval == gtk.keysyms.Escape:
156
72
                        self.window.destroy()
163
79
 
164
80
 
165
81
        def process_serial_data_at( self, pos ):
166
 
                for a in range( self.NUM_CHANNELS ):
 
82
                for a in range( 0, self.NUM_CHANNELS ):
167
83
                        at = 2 * a + pos
168
84
                        value = struct.unpack( "h", self.buffer[ at : at + 2 ] )[ 0 ]
169
85
 
173
89
 
174
90
        def read_serial( self ):
175
91
 
176
 
                # serial problem?
177
 
                if self.link is None: return
178
 
 
179
92
                # try and read
180
93
                in_waiting = self.link.inWaiting()
181
94
                if( in_waiting ):
204
117
                                        i += 1
205
118
 
206
119
 
207
 
        def write_serial( self ):
208
 
 
209
 
                # serial problem?
210
 
                if self.link is None: return
211
 
 
212
 
                # construct message
213
 
                bytes = bytearray()
214
 
                bytes.extend( struct.pack( "h", -1 ) )
215
 
                for i in range( self.NUM_MOTORS ):
216
 
                        bytes.extend( struct.pack( "h", self.motor_values[ i ] ) )
217
 
 
218
 
                # send
219
 
                self.link.write( bytes )
220
 
 
221
 
 
222
120
        def main( self ):
223
121
                self.setup_window()
224
122
                while not self.quit: