/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/receiver.cc

  • Committer: Tim Marston
  • Date: 2013-10-23 20:08:35 UTC
  • Revision ID: tim@ed.am-20131023200835-zqu4je2gn0y79car
fixed receiver test code which is now working

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rc-interface/receiver.cc
1
 
//
2
 
// receiver.cc
3
 
//
4
 
 
5
 
 
6
 
#include "receiver.h"
7
 
#include "config.h"
8
 
#include "common.h"
9
 
#include <Arduino.h>
10
 
 
11
 
 
12
 
// channel sequence order
13
 
static const int channel_order_[] = { CHANNEL_ORDER };
14
 
 
15
 
// set to the time of the last pulse edges
16
 
static unsigned long new_pulse_up_[2] = { 0, 0 };
17
 
static unsigned long new_pulse_down_ = 0;
18
 
static char new_pulse_interrupt_;
19
 
 
20
 
 
21
 
// ISR to handle the PPM signals
22
 
inline void signal_handler( int interrupt, int pin )
23
 
{
24
 
        // record rising/falling edge
25
 
        if( digitalRead( pin ) )
26
 
                new_pulse_up_[ interrupt ] = micros();
27
 
        else {
28
 
                new_pulse_down_ = micros();
29
 
 
30
 
                // record which interrupt just had a falling edge
31
 
                new_pulse_interrupt_ = interrupt;
32
 
        }
33
 
}
34
 
 
35
 
 
36
 
static void signal_handler_0()
37
 
{
38
 
        signal_handler( 0, 2 );
39
 
}
40
 
 
41
 
 
42
 
static void signal_handler_1()
43
 
{
44
 
        signal_handler( 1, 3 );
45
 
}
46
 
 
47
 
 
48
 
void Receiver::setup()
49
 
{
50
 
        // set up an interrupts
51
 
        attachInterrupt( 0, signal_handler_0, CHANGE );
52
 
        attachInterrupt( 1, signal_handler_1, CHANGE );
53
 
        digitalWrite( 2, LOW );
54
 
        digitalWrite( 3, LOW );
55
 
}
56
 
 
57
 
 
58
 
bool Receiver::read_channels( int channel_values[] )
59
 
{
60
 
        static unsigned long last_pulse_down = 0;
61
 
        static int next_channel = 0;
62
 
 
63
 
        // capture pulse values atomically
64
 
        noInterrupts();
65
 
        unsigned long pulse_up = new_pulse_up_[ (int)new_pulse_interrupt_ ];
66
 
        unsigned long pulse_down = new_pulse_down_;
67
 
        char new_pulse_interrupt = new_pulse_interrupt_;
68
 
        interrupts();
69
 
 
70
 
        // if the amount of time that has passed since the last falling edge is
71
 
        // greater than the frame gap, reset the next channel so that we can start
72
 
        // reading them again
73
 
        if( next_channel &&
74
 
                new_pulse_interrupt == 1 &&
75
 
                calculate_duration( pulse_down, micros() ) > MIN_FRAME_GAP_WIDTH )
76
 
        {
77
 
                // reset the next channel (which restarts reading them)
78
 
                next_channel = 0;
79
 
        }
80
 
 
81
 
        // check for a new complete pulse
82
 
        if( pulse_down != last_pulse_down )
83
 
        {
84
 
                // are there still pulses to read?
85
 
                if( next_channel < NUM_CHANNELS )
86
 
                {
87
 
                        unsigned long duration =
88
 
                                calculate_duration( pulse_up, pulse_down );
89
 
 
90
 
                        // does this pulse look ok?
91
 
                        if( duration >= MIN_PULSE_WIDTH &&
92
 
                                duration <= MAX_PULSE_WIDTH )
93
 
                        {
94
 
                                // store channel value
95
 
                                int channel = channel_order_[ next_channel ] - 1;
96
 
                                channel_values[ channel ] = MAX_CHANNEL_VALUE *
97
 
                                        ( duration - MIN_PULSE_WIDTH ) /
98
 
                                        ( MAX_PULSE_WIDTH - MIN_PULSE_WIDTH );
99
 
 
100
 
                                // we got a channel
101
 
                                next_channel++;
102
 
                        }
103
 
                        else {
104
 
                                // set invalid channel number (to indicate error)
105
 
                                next_channel = NUM_CHANNELS + 1;
106
 
                        }
107
 
                }
108
 
 
109
 
                last_pulse_down = pulse_down;
110
 
        }
111
 
 
112
 
        // if we've read a frame, invalidate the frame (so we don't report it a
113
 
        // second time) and return true
114
 
        if( next_channel == NUM_CHANNELS ) {
115
 
                next_channel++;
116
 
                return true;
117
 
        }
118
 
        
119
 
        return false;
120
 
}