/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: dan
  • Date: 2014-04-02 19:55:44 UTC
  • mto: This revision was merged to the branch mainline in revision 32.
  • Revision ID: dan-20140402195544-bnr43lzb5ndvqg53
Updated ignore file to remove ds_store

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
18
21
        # maximum channel value
19
22
        MAX_CHANNEL_VALUE = 1000
20
23
 
21
24
        # serial device to use
22
 
        SERIAL_DEVICE = '/dev/ttyACM0'
 
25
        SERIAL_DEVICE = '/dev/ttyUSB0'
23
26
 
24
27
 
25
28
        def __init__( self ):
26
 
                self.link = serial.Serial( self.SERIAL_DEVICE, 9600 )
 
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
27
35
                self.got_one = False
28
 
                self.channel_values = []
 
36
                self.motor_values = [ 0 ] * self.NUM_MOTORS
29
37
                self.quit = False
30
38
                self.buffer = bytearray()
31
39
 
32
40
 
 
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
 
33
51
        def setup_window( self ):
34
52
 
35
53
                # create and set up window
41
59
                self.window.set_modal( True )
42
60
                self.window.connect( "key-press-event", self.key_press_event )
43
61
 
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 )
 
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 )
49
75
 
50
76
                # add channels
51
77
                self.controls = []
52
 
                for a in range( 0, self.NUM_CHANNELS ):
 
78
                for a in range( self.NUM_CHANNELS ):
53
79
 
54
 
                        label = gtk.Label( "Channel %d" % ( a + 1 ) )
55
 
                        table.attach( label, 0, 1, a, a + 1 )
 
80
                        label = gtk.Label( a + 1 )
 
81
                        table.attach( label, a, a + 1, 1, 2 )
56
82
 
57
83
                        adj = gtk.Adjustment( 0, 0, self.MAX_CHANNEL_VALUE, 1, 0, 0 )
58
 
                        control = gtk.HScale( adj )
 
84
                        control = gtk.VScale( adj )
59
85
                        control.set_draw_value( False )
60
 
                        control.set_property( 'width-request', 300 )
 
86
                        control.set_inverted( True )
 
87
                        control.set_size_request( -1, 200 )
61
88
                        control.set_sensitive( False )
62
 
                        table.attach( control, 1, 2, a, a + 1 )
 
89
                        table.attach( control, a, a + 1, 0, 1 )
63
90
 
64
91
                        self.controls.append( control )
65
92
 
 
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
 
66
145
                # show it
67
146
                self.window.show_all()
68
147
 
69
148
 
 
149
        def on_motor_change( self, widget, motor ):
 
150
                self.motor_values[ motor ] = int( widget.get_value() )
 
151
                self.write_serial()
 
152
 
 
153
 
70
154
        def key_press_event( self, widget, event ):
71
155
                if event.keyval == gtk.keysyms.Escape:
72
156
                        self.window.destroy()
79
163
 
80
164
 
81
165
        def process_serial_data_at( self, pos ):
82
 
                for a in range( 0, self.NUM_CHANNELS ):
 
166
                for a in range( self.NUM_CHANNELS ):
83
167
                        at = 2 * a + pos
84
168
                        value = struct.unpack( "h", self.buffer[ at : at + 2 ] )[ 0 ]
85
169
 
89
173
 
90
174
        def read_serial( self ):
91
175
 
 
176
                # serial problem?
 
177
                if self.link is None: return
 
178
 
92
179
                # try and read
93
180
                in_waiting = self.link.inWaiting()
94
181
                if( in_waiting ):
117
204
                                        i += 1
118
205
 
119
206
 
 
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
 
120
222
        def main( self ):
121
223
                self.setup_window()
122
224
                while not self.quit: