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

#![no_std]
#![no_main]

use adafruit_feather_rp2040 as bsp;

use bsp::{entry, hal, XOSC_CRYSTAL_FREQ};
use hal::{
    fugit::RateExtU32,
    gpio::PinState,
    spi::Spi,
    uart::{DataBits, StopBits, UartConfig, UartPeripheral},
    Clock,
};

use embedded_hal::{delay::DelayNs, digital::OutputPin, spi::MODE_3};
use embedded_hal_0_2_x::blocking::spi::{Transfer as SpiTransfer, Write as SpiWrite};
use embedded_io::Write;

#[cfg(not(feature = "defmt"))]
#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
    loop {}
}

#[cfg(feature = "defmt")]
use {defmt_rtt as _, panic_probe as _};

#[entry]
fn main() -> ! {
    let mut pac = hal::pac::Peripherals::take().unwrap();
    let _core = hal::pac::CorePeripherals::take().unwrap();

    let mut watchdog = hal::watchdog::Watchdog::new(pac.WATCHDOG);

    let clocks = hal::clocks::init_clocks_and_plls(
        XOSC_CRYSTAL_FREQ,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .unwrap();

    let mut timer = hal::Timer::new(pac.TIMER, &mut pac.RESETS, &clocks);

    let sio = hal::Sio::new(pac.SIO);
    let pins = hal::gpio::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    let pins_uart = (pins.gpio0.into_function(), pins.gpio1.into_function());
    let mut uart = UartPeripheral::new(pac.UART0, pins_uart, &mut pac.RESETS)
        .enable(
            UartConfig::new(115_200.Hz(), DataBits::Eight, None, StopBits::One),
            clocks.peripheral_clock.freq(),
        )
        .unwrap();

    let mut adt7310_csn = pins.gpio6.into_push_pull_output_in_state(PinState::High);

    let pins_spi = (
        pins.gpio19.into_function(),
        pins.gpio20.into_function(),
        pins.gpio18.into_function(),
    );
    let mut spi = Spi::<_, _, _, 8>::new(pac.SPI0, pins_spi).init(
        &mut pac.RESETS,
        clocks.peripheral_clock.freq(),
        5.MHz(),
        MODE_3,
    );

    // serial interface reset
    {
        adt7310_csn.set_low().unwrap();
        spi.write(&[0xff_u8; 4]).unwrap();
        adt7310_csn.set_high().unwrap();
        timer.delay_us(1);
    }

    // レジスタ読み出し
    //                    ┌───────── 1: read, 0: write
    //                    │   ┌───── address
    //                    │   │ ┌─── 1: continuos read (temperature value register only)
    //    spi.write(&[0b0_0_001_0_00, ...]).unwrap();
    //
    // let mut buf = [0b0_1_010_0_00, 0xff, ...];
    // spi.transfer(buf.as_mut_slice()).unwrap();

    loop {
        adt7310_csn.set_low().unwrap();

        #[allow(clippy::unusual_byte_groupings)]
        //                  ┌───── configuration register
        //                  │         ┌───── Resolution (16-bit)
        //                  │         │  ┌───── Operation mode (One shot)
        spi.write(&[0b0_0_001_0_00, 0b1_01_0_0_0_00]).unwrap();

        timer.delay_ms(240);

        #[allow(clippy::unusual_byte_groupings)]
        //                     ┌───── temperature value register
        let mut buf = [0b0_1_010_0_00, 0, 0];
        spi.transfer(buf.as_mut_slice()).unwrap();

        let temp = i16::from_be_bytes([buf[1], buf[2]]);
        let temp_int = temp / 128;
        let temp_frac = 78125_u32 * (temp % 128).unsigned_abs() as u32;
        write!(
            uart,
            "\r\ntemp = {:3}.{:07} ({:#06x})",
            temp_int, temp_frac, temp
        )
        .unwrap();

        adt7310_csn.set_high().unwrap();

        timer.delay_ms(760);
    }
}