/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/receiver/pulse-width/main.ino

  • Committer: Tim Marston
  • Date: 2012-11-28 23:18:38 UTC
  • Revision ID: tim@ed.am-20121128231838-r2t1dyawkzb6nxhe
initial commit, and a couple of receiver test programs

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/receiver/pulse-width/main.ino
8
8
// microseconds.  It takes several measurements and prints it the average over
9
9
// serial.
10
10
//
11
 
// NOTES: Due to the way our receiver works (by varying the position of the
12
 
// rising edge of the pulse and keeping the falling edge fixed), it is
13
 
// sufficient for us to measure the pule width to determine the channel value
14
 
// (e.g., throttle position).  But it should be noted that this relies on a
15
 
// quirk of our receiver/transmitter and it is not truly measuring PPM.  Our
16
 
// next experiment is measuring PPM (../ppm-read).
 
11
 
17
12
 
18
13
// number of signal pulses to average
19
 
#define AVERAGE_SAMPLES 1
20
 
 
21
 
// should average be result, or damping?
22
 
#define AVERAGE_DAMP 1
23
 
 
24
 
// graphic display
25
 
#define GRAPH 1
26
 
#define GRAPH_MIN 1000
27
 
#define GRAPH_MAX 2000
28
 
#define GRAPH_SIZE 30
 
14
#define SIGNAL_SAMPLES 10
29
15
 
30
16
 
31
17
// set to the time that the last signal pulse was at
53
39
        Serial.begin( 9600 );
54
40
}
55
41
 
56
 
 
57
42
void loop()
58
43
{
59
 
        unsigned long last_pulse_off = 0;
60
 
        unsigned long intervals[ AVERAGE_SAMPLES ];     
 
44
        unsigned long last_pulse = 0;
 
45
        unsigned long intervals[ SIGNAL_SAMPLES ] = {0};
61
46
        int interval_idx = 0;
62
47
 
63
 
        // reset intervals
64
 
        for( int a = 0; a < AVERAGE_SAMPLES; a++ )
65
 
                intervals[ a ] = 0;
66
 
 
67
 
#ifdef GRAPH
68
 
        // init graph
69
 
        char graph[ GRAPH_SIZE + 3 ];
70
 
        for( int a = 1; a < GRAPH_SIZE + 1; a++ )
71
 
                graph[ a ] = '-';
72
 
        graph[ 0 ] = '[';
73
 
        graph[ GRAPH_SIZE + 1 ] = ']';
74
 
        graph[ GRAPH_SIZE + 2 ] = 0;
75
 
#endif // GRAPH
76
 
 
77
48
        while( true )
78
49
        {
79
50
                // detect pulse falling-edge
80
 
                unsigned long pulse_on = _new_pulse_on;
81
 
                unsigned long pulse_off = _new_pulse_off;
 
51
                unsigned long new_pulse_on = _new_pulse_on;
 
52
                unsigned long new_pulse_off = _new_pulse_off;
82
53
                bool got_pulse = false;
83
 
                if( pulse_off > last_pulse_off )
 
54
                if( new_pulse_off > last_pulse )
84
55
                {
85
 
                        // sanity check
86
 
                        unsigned long interval = pulse_off - pulse_on;
87
 
                        if( interval > 800 && interval < 3000 )
88
 
                        {
89
 
                                // update interval buffer
90
 
                                intervals[ interval_idx ] = pulse_off - pulse_on;
91
 
                                if( ++interval_idx >= AVERAGE_SAMPLES )
92
 
                                        interval_idx = 0;
93
 
 
94
 
                                got_pulse = true;
95
 
                        }
96
 
 
97
 
                        last_pulse_off = pulse_off;
 
56
                        // update interval buffer
 
57
                        intervals[ interval_idx ] = new_pulse_off - new_pulse_on;
 
58
                        if( ++interval_idx >= SIGNAL_SAMPLES )
 
59
                                interval_idx = 0;
 
60
 
 
61
                        last_pulse = new_pulse_off;
 
62
                        got_pulse = true;
98
63
                }
99
64
 
100
65
                // display average?
101
 
                if( got_pulse &&
102
 
                        ( AVERAGE_DAMP || interval_idx == 0 ) )
 
66
                if( interval_idx == 0 && got_pulse )
103
67
                {
104
68
                        // calculate average
105
 
                        unsigned long ave = 0;
106
 
                        for( int a = 0; a < AVERAGE_SAMPLES; a++ )
 
69
                        double ave = 0;
 
70
                        for( int a = 0; a < SIGNAL_SAMPLES; a++ )
107
71
                                ave += intervals[ a ];
108
 
                        ave /= AVERAGE_SAMPLES;
109
 
 
110
 
#ifdef GRAPH
111
 
 
112
 
                        // draw graph
113
 
                        int pos = ( GRAPH_SIZE ) *
114
 
                                ( ave - GRAPH_MIN ) / ( GRAPH_MAX - GRAPH_MIN );
115
 
                        graph[ pos + 1 ] = '|';
116
 
                        Serial.println( graph );
117
 
                        graph[ pos + 1 ] = '-';
118
 
 
119
 
#else // GRAPH
 
72
                        ave /= SIGNAL_SAMPLES;
120
73
 
121
74
                        // tell it like it is
122
 
                        Serial.println( ave );
123
 
 
124
 
#endif // GRAPH
 
75
                        Serial.println( round( ave ) );
125
76
                }               
126
77
        }
127
78
}