adv-shift-registers 0.2.3

Advanced shift registers control (for multiple chained shift-registers)
Documentation 
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

#![no_std]

use core::ops::Range;
use embedded_hal::digital::{OutputPin, PinState};
use wrappers::{ShifterPin, ShifterValue, ShifterValueRange};

pub mod wrappers;

pub struct AdvancedShiftRegister<const N: usize, OP: OutputPin> {
    /// Shifter data (currently set bits)
    pub shifters: [u8; N],

    /// Data pin
    data_pin: OP,

    /// Clock pin
    clk_pin: OP,

    /// Latch pin
    latch_pin: OP,
}

impl<const N: usize, OP: OutputPin> AdvancedShiftRegister<N, OP> {
    pub fn new(data_pin: OP, clk_pin: OP, latch_pin: OP, default_val: u8) -> Self {
        Self {
            shifters: [default_val; N],
            data_pin,
            clk_pin,
            latch_pin,
        }
    }

    /// Get wrapper for value of one shifter register (for easy modyfing)
    pub fn get_shifter_mut(&mut self, i: usize) -> ShifterValue {
        unsafe {
            ShifterValue {
                inner: core::ptr::addr_of_mut!(self.shifters[i]),
                update_shifters_ptr: UpdateShiftersFuncPtr::new(self),
            }
        }
    }

    /// Get wrapper for one bit of specifed shifter register (with embedded_hal digitalpin trait)
    pub fn get_pin_mut(&mut self, i: usize, bit: u8, auto_shift: bool) -> ShifterPin {
        unsafe {
            ShifterPin {
                bit,
                auto_update: auto_shift,
                inner: core::ptr::addr_of_mut!(self.shifters[i]),
                update_shifters_ptr: UpdateShiftersFuncPtr::new(self),
            }
        }
    }

    /// Get wrapper for range of shifter registers
    /// (for easy modyfing of multiple registers at the same time)
    pub fn get_shifter_range_mut(&mut self, range: Range<usize>) -> ShifterValueRange {
        unsafe {
            ShifterValueRange {
                //len: range.len(),
                inner: core::ptr::addr_of_mut!(self.shifters[range]),
                update_shifters_ptr: UpdateShiftersFuncPtr::new(self),
            }
        }
    }

    /// Push stored shifters data onto shifter registers
    pub fn update_shifters(&mut self) {
        for i in (0..N).rev() {
            let mut val = self.shifters[i];

            for _ in 0..8 {
                let state = PinState::from(val & 1 > 0);
                _ = self.data_pin.set_state(state);
                val >>= 1;

                _ = self.clk_pin.set_high();
                _ = self.clk_pin.set_low();
            }
        }

        _ = self.latch_pin.set_high();
        _ = self.latch_pin.set_low();
    }

    /// Trampoline function to execute `.update_shifters()` function outside this struct
    /// without using any generics
    unsafe extern "C" fn update_shifters_trampoline(this: *mut AdvancedShiftRegister<N, OP>) {
        (&mut *this).update_shifters();
    }
}

#[derive(Clone)]
struct UpdateShiftersFuncPtr {
    parent: *mut (),
    update_shifters_ptr: unsafe extern "C" fn(*mut ()),
}

impl UpdateShiftersFuncPtr {
    pub unsafe fn new<const N: usize, OP: OutputPin>(
        parent: &mut AdvancedShiftRegister<N, OP>,
    ) -> Self {
        Self {
            parent: parent as *mut _ as *mut (),
            update_shifters_ptr: core::mem::transmute(
                AdvancedShiftRegister::update_shifters_trampoline
                    as unsafe extern "C" fn(*mut AdvancedShiftRegister<N, OP>),
            ),
        }
    }

    pub unsafe fn call_update_shifters(&self) {
        (self.update_shifters_ptr)(self.parent);
    }
}