/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 src/rc-interface/main.ino

  • Committer: Tim Marston
  • Date: 2014-02-05 22:15:49 UTC
  • Revision ID: tim@ed.am-20140205221549-jmrvij7zyl1cn8j9
stabalised the PPM output on the rc-interface board

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
// main board (and software running on it) of the task of interfacing with any
10
10
// of the RC system.
11
11
//
 
12
// Receiver
 
13
// --------
 
14
//
12
15
// The 8 channels (from the RC receiver) need to be combined and fed to two
13
16
// interrupts on the Arduino.  They need to be combined in such a way as to
14
17
// alternate pulses between the two interrupts (which are alternately used to
21
24
//            ___    |    |    |    |    |    |    |    |     ___
22
25
//    GND ---|___|---+----+----+----+    +----+----+----+----|___|--- GND
23
26
//             R                    |    |                     R
24
 
//             ____________________ | __ | _____________________
25
 
//                                  |    |
 
27
//         ________________________ | __ | _____________________
 
28
//         ARDUINO                  |    |
26
29
//                           pin 2  o    o  pin 3
27
30
//                    (interrupt 0)        (interrupt 1)
28
31
//
31
34
//
32
35
// Note that your receiver may not send pulses sequentially, in "channel order".
33
36
// If this turns out to be the case, you will need to arrange for the pulses to
34
 
// wire up the channels in an order whereby the pulses alternatively alternately
35
 
// between the two interrupts and adjust the channel order below.
36
 
 
 
37
// wire up the channels in an order whereby the pulses arrive alternately
 
38
// between the two interrupts and adjust the channel order in config.h.
 
39
//
 
40
// Motor control
 
41
// -------------
 
42
//
 
43
// The four motor control outputs should be fed directly to the ESCs.
 
44
//
 
45
//                            ESC  ESC  ESC  ESC
 
46
//                             o    o    o    o
 
47
//                             |    |    |    |
 
48
//         ___________________ | __ | __ | __ | _____
 
49
//         ARDUINO             |    |    |    |
 
50
//                      pin 4  o    o    o    o  pin 7
 
51
//
 
52
// SERIAL INTERFACE
 
53
// ----------------
 
54
//
 
55
// The serial interface (pins 0 and 1) talk a very simple protocol.  When a
 
56
// complete set of 8 channel values have been read, it writes 0xffff followed by
 
57
// the 8, 16-bit unsigned channel values.  It expects to recieve 0xffff,
 
58
// followed by 4, 16-bit unsigned channel values.  All channel values are in the
 
59
// range specified in config.h.
37
60
 
38
61
#include "config.h"
39
62
#include "receiver.h"
40
 
 
41
 
 
42
 
// the width of the display of a single channel (in chars)
43
 
#define GRAPH_SIZE 7
44
 
 
45
 
// the channel's expected range for use in drawing (should be similar to
46
 
// {MAX,MIN}_PULSE_WIDTH values)
47
 
#define GRAPH_MIN 1000
48
 
#define GRAPH_MAX 2000
 
63
#include "motors.h"
 
64
#include "comms.h"
49
65
 
50
66
 
51
67
void setup()
52
68
{
53
69
        Receiver::setup();
54
 
        
55
 
        Serial.begin( 9600 );
 
70
        Motors::setup();
 
71
        Comms::setup();
 
72
 
 
73
        // led
 
74
        pinMode( LED_PIN, OUTPUT );
 
75
        digitalWrite( LED_PIN, LOW );
56
76
}
57
77
 
58
78
 
59
 
void draw_graph( unsigned long channel_values[] )
 
79
void flash_led()
60
80
{
61
 
        // init graph
62
 
        static char graph[ GRAPH_SIZE + 2 ];
63
 
        static char inited_graph = false;
64
 
        if( !inited_graph ) {
65
 
                for( int a = 1; a < GRAPH_SIZE + 1; a++ )
66
 
                        graph[ a ] = '_';
67
 
                graph[ 0 ] = '|';
68
 
                graph[ GRAPH_SIZE + 1 ] = 0;
69
 
                inited_graph = true;
70
 
        }
71
 
 
72
 
        // draw channels
73
 
        for( int a = 0; a < NUM_CHANNELS; a++ ) {
74
 
                unsigned long value = max( 0,
75
 
                        min( channel_values[ a ], GRAPH_MAX ) - GRAPH_MIN );
76
 
                int pos = ( GRAPH_SIZE ) * value / ( GRAPH_MAX - GRAPH_MIN );
77
 
                graph[ pos + 1 ] = '^';
78
 
                Serial.print( graph );
79
 
                graph[ pos + 1 ] = '_';
80
 
        }
81
 
        Serial.println( "|" );
 
81
        static bool on = false;
 
82
        on = !on;
 
83
        digitalWrite( LED_PIN, on? HIGH : LOW );
82
84
}
83
85
 
84
86
 
85
87
void loop()
86
88
{
87
 
        unsigned long channel_values[ NUM_CHANNELS ];
 
89
        int channel_values[ NUM_CHANNELS ];
88
90
 
89
91
        while( true )
90
92
        {
 
93
                // have we read a whole set of channel values?
91
94
                if( Receiver::read_channels( channel_values ) )
92
 
                        draw_graph( channel_values );
 
95
                {
 
96
                        // update motors
 
97
                        Motors::update();
 
98
 
 
99
                        // yes, flash led!
 
100
                        flash_led();
 
101
 
 
102
                        // send channel values to main board
 
103
                        Comms::write_channels( channel_values );
 
104
 
 
105
                        // set motor speeds
 
106
                        Motors::set_values( channel_values );
 
107
                }
 
108
 
 
109
                // update motors
 
110
                Motors::update();
93
111
        }
94
112
}