pca9535 2.0.0

PCA 9535 IO-Expander driver using embedded-hal
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

//! Contains the implementation to make an [`Expander`] Sync.
use core::marker::PhantomData;

use hal::i2c::{ErrorType, I2c};

use super::{Expander, ExpanderError, Register, SyncExpander};
use crate::ExpanderMutex;

/// A wrapper struct to make an Expander Sync.
/// This Expander type can be used to generate [`crate::ExpanderInputPin`] or [`crate::ExpanderOutputPin`].
#[derive(Debug)]
pub struct IoExpander<I2C, Ex, Em>
where
    I2C: I2c,
    Ex: Expander<I2C> + Send,
    Em: ExpanderMutex<Ex>,
{
    expander_mutex: Em,
    phantom_data: PhantomData<Ex>,
    phantom_data_2: PhantomData<I2C>,
}

impl<I2C, Em, Ex> IoExpander<I2C, Ex, Em>
where
    I2C: I2c,
    Em: ExpanderMutex<Ex>,
    Ex: Expander<I2C> + Send,
{
    /// Creates a new IoExpander instance out of an Expander.
    pub fn new(expander: Ex) -> IoExpander<I2C, Ex, Em> {
        IoExpander {
            expander_mutex: Em::new(expander),
            phantom_data: PhantomData,
            phantom_data_2: PhantomData,
        }
    }
}

impl<I2C, Em, Ex> SyncExpander<I2C> for IoExpander<I2C, Ex, Em>
where
    I2C: I2c,
    Em: ExpanderMutex<Ex>,
    Ex: Expander<I2C> + Send,
{
    fn write_byte(
        &self,
        register: Register,
        data: u8,
    ) -> Result<(), ExpanderError<<I2C as ErrorType>::Error>> {
        self.expander_mutex.lock(|ex| ex.write_byte(register, data))
    }
    fn read_byte(
        &self,
        register: Register,
        buffer: &mut u8,
    ) -> Result<(), ExpanderError<<I2C as ErrorType>::Error>> {
        self.expander_mutex
            .lock(|ex| ex.read_byte(register, buffer))
    }
    fn write_halfword(
        &self,
        register: Register,
        data: u16,
    ) -> Result<(), ExpanderError<<I2C as ErrorType>::Error>> {
        self.expander_mutex
            .lock(|ex| ex.write_halfword(register, data))
    }
    fn read_halfword(
        &self,
        register: Register,
        buffer: &mut u16,
    ) -> Result<(), ExpanderError<<I2C as ErrorType>::Error>> {
        self.expander_mutex
            .lock(|ex| ex.read_halfword(register, buffer))
    }
}