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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Read VCD files and set pins accordingly.
//!
//!

use crate::pins::*;
use core::borrow::Borrow;
use embedded_time::duration::*;
use fnv::FnvHashMap;
use std::io::Result as IOResult;
use std::sync::atomic::Ordering;
use std::sync::Arc;

/// A reader for VCD files
pub struct VcdReader<R>
where
    R: std::io::Read,
{
    parser: vcd::Parser<R>,
    scale: Generic<u64>,
    header: vcd::Header,
    pins: FnvHashMap<vcd::IdCode, Arc<AtomicPinState>>,
}

impl<R> VcdReader<R>
where
    R: std::io::Read,
{
    /// Create a new VCD reader from a reader that implements [std::io::Read].
    pub fn new(read: R) -> IOResult<Self> {
        let mut parser = vcd::Parser::new(read);
        let header = parser.parse_header()?;
        let scale = Self::timescale_to_duration(&header).unwrap();
        Ok(Self {
            parser,
            header,
            scale,
            pins: FnvHashMap::default(),
        })
    }

    /// Return the scale that is used by the VCD file.
    ///
    /// The scale defines the timescale fraction the VCD file is based on.
    pub fn scale(&self) -> Generic<u64> {
        self.scale
    }

    /// Convert the timescale fraction from the VCD header to an
    /// [embedded_time::Generic] duration.
    fn timescale_to_duration(header: &vcd::Header) -> Option<Generic<u64>> {
        if let Some((scale, unit)) = header.timescale {
            let fraction = Fraction::new(1, unit.divisor() as u32);
            Some(Generic::new(scale as u64, fraction))
        } else {
            None
        }
    }

    /// Create a new pin from a named variable in the VCD file.
    ///
    /// Returns an [InputPin] that can be used for any [embedded_hal]
    /// driver implementation that needs an [embedded_hal::digital::InputPin].
    pub fn get_pin<S>(&mut self, path: &[S]) -> Option<InputPin>
    where
        S: Borrow<str>,
    {
        if let Some(v) = self.header.find_var(path) {
            let state = Arc::new(AtomicPinState::new_with_state(PinState::Floating));
            let pin = InputPin::new(state.clone());
            self.pins.insert(v.code, state);
            Some(pin)
        } else {
            None
        }
    }
}

impl<R> Iterator for VcdReader<R>
where
    R: std::io::Read,
{
    type Item = Generic<u64>;

    fn next(&mut self) -> Option<Self::Item> {
        use vcd::Command::*;
        let mut timestamp = None;
        for cmd in self.parser.by_ref() {
            match cmd {
                Ok(Timestamp(t)) => {
                    timestamp = Some(Generic::new(
                        self.scale.integer() * t,
                        *self.scale.scaling_factor(),
                    ));
                    break;
                }
                Ok(ChangeScalar(id, val)) => {
                    if let Some(pin) = self.pins.get_mut(&id) {
                        (*pin).store(val.into(), Ordering::SeqCst);
                    }
                }
                _ => {}
            }
        }
        timestamp
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use embedded_hal::digital::InputPin;

    #[test]
    fn read_simple() {
        let vcd = "
$timescale 1ns $end
$scope module logic $end
$var wire 1 t test $end
$upscope $end
$enddefinitions $end
#0
0t
#100
1t
#200
1t
#300
0t
#400
#500
"
        .as_bytes();
        let states = vec![
            (0, false),
            (100, false),
            (200, true),
            (300, true),
            (400, false),
            (500, false),
        ];
        let mut reader = VcdReader::new(vcd).unwrap();
        let pin = reader.get_pin(&["logic", "test"]).unwrap();
        for (vcd_time, (state_time, state_pin)) in reader.zip(states) {
            let vcd_time: Nanoseconds<u64> = vcd_time.try_into().unwrap();
            assert_eq!(vcd_time, state_time.nanoseconds());
            assert_eq!(
                pin.is_high(),
                Ok(state_pin),
                "testing pin state at timestamp {}",
                vcd_time
            );
        }
    }
}