1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

use crate::{Receiver, ReceiverState};

const BUF_LEN: usize = 128;

pub struct TraceReceiver {
    pub data: [u32; BUF_LEN],
    pub samplerate: u32,
    pub prev_pinval: bool,
    pub st_prev: u32,
    pub event_id: usize,
    pub enabled: bool,
}

pub struct TraceResult {
    pub buf: [u32; BUF_LEN],
    pub buf_len: usize,
}

fn pin_changed(prev: bool, pinval: bool) -> Option<bool> {
    match (pinval, prev) {
        (false, true) => Some(true),
        (true, false) => Some(false),
        _ => None,
    }
}


const TIMEOUT: u32 = 1000;

impl Receiver for TraceReceiver {
    type Command = TraceResult;
    type ReceiveError = ();

    fn event(&mut self, pinvalue: bool, st: u32) -> ReceiverState<TraceResult, ()> {

        if !self.enabled {
            return ReceiverState::Disabled;
        }

        // Number of  samples since last pin value change
        let sampledelta = match self.st_prev {
            0 => 0,
            _ => st.wrapping_sub(self.st_prev),
        };

        if sampledelta > TIMEOUT {
            // Set the receiver in disabled state but return the Done state
            self.enabled = false;
            return ReceiverState::Done(TraceResult {
                buf: self.data,
                buf_len: self.event_id,
            });
        }

        if let Some(_rising) = pin_changed(self.prev_pinval, pinvalue) {
            // Change detected
            self.data[self.event_id] = sampledelta;
            self.event_id += 1;
            self.st_prev = st;

            self.prev_pinval = pinvalue;

            if self.event_id == BUF_LEN {
                ReceiverState::Done(TraceResult {
                    buf: self.data,
                    buf_len: self.event_id,
                })
            } else {
                ReceiverState::Receiving
            }
        } else {
            ReceiverState::Receiving
        }
    }

    fn reset(&mut self) {
        self.st_prev = 0;
        self.event_id = 0;
        self.prev_pinval = false;
        self.enabled = true;
    }

    fn disable(&mut self) {
        self.enabled = false;
    }
}

impl TraceReceiver {
    pub const fn new(samplerate: u32) -> Self {

        Self {
            data: [0; BUF_LEN],
            samplerate,
            prev_pinval: false,
            st_prev: 0,
            event_id: 0,
            enabled: true,
        }
    }
}