SOLID for Raspberry Pi 4 (連載14)

use itron::{task::delay, time::duration};

#[no_mangle]
pub extern "C" fn slo_main() {
    const BW_RATE: u32 = 0x2c;
    const BW_RATE_VAL: u32 = 0x0b;
    const DATA_FORMAT: u32 = 0x31;
    const DATA_FORMAT_VAL: u32 = 0x0B; //(4 mg/LSB +-16g)
    const POWER_CTL: u32 = 0x2D;
    const POWER_CTL_VAL: u32 = 0x08;

    println!("Starting SPI control.");

    spi_gpio_control::init();
    spi_control::init();

    //ADXL345_init
    spi_control::regwrite(BW_RATE, BW_RATE_VAL);
    spi_control::regwrite(DATA_FORMAT, DATA_FORMAT_VAL);
    spi_control::regwrite(POWER_CTL, POWER_CTL_VAL);

	loop{
    //連続複数リードを行う。-> 0xc0とORをとる。
	 //0.0392266=(4/1000*9.80665)

		let x_axis = spi_control::regread(0xc0 | 0x32) as f32 * 0.0392266;
		let y_axis = spi_control::regread(0xc0 | 0x34) as f32 * 0.0392266;
		let z_axis = spi_control::regread(0xc0 | 0x36) as f32 * 0.0392266;

		println!("x_axis:{} y_axis:{} z_axis:{}", x_axis, y_axis, z_axis);

		delay(duration!(ms: 500)).unwrap(); //500ms待つ
	}
}

mod spi_gpio_control {
    use bcm2711_pac::gpio;
    use tock_registers::interfaces::ReadWriteable;

    fn gpio_regs() -> &'static gpio::Registers {
        // Safety: SOLID for RaPi4B provides an identity mapping in this area, and we don't alter
        // the mapping
        unsafe { &*(gpio::BASE.to_arm_pa().unwrap() as usize as *const gpio::Registers) }
    }

    pub fn init() {
        for pin in 8..=11 {
            gpio_regs().gpfsel[pin / gpio::GPFSEL::PINS_PER_REGISTER].modify(
                gpio::GPFSEL::pin(pin % gpio::GPFSEL::PINS_PER_REGISTER).val(gpio::GPFSEL::ALT0),
            );
        }
    }
}

mod spi_control {
    use bcm2711_pac::spi;
    use tock_registers::interfaces::{ReadWriteable, Readable, Writeable};

    fn spi_regs() -> &'static spi::Registers {
        // Safety: SOLID for RaPi4B provides an identity mapping in this area, and we don't alter
        // the mapping
        unsafe { &*(spi::BASE_SPI0.to_arm_pa().unwrap() as usize as *const spi::Registers) }
    }

    pub fn init() {
        const CLKSET: u32 = 0x00cb;

        //SPIのCLKレジスタにSPI周波数を設定
        spi_regs().clk.write(spi::CLK::CDIV.val(CLKSET));

        //CS : 00 = Chip select 0  -> CS.bit0 and 1
        //CPOL: Clock Polarity 1 = Rest state of clock = High -> CS.bit3
        //CPHA: Clock Phase 1 = First SCLK transition at beginning of data bit. -> CS.bit2
        spi_regs().cs.modify(spi::CS::CS::ChipSelect0);
        spi_regs().cs.modify(spi::CS::CPOL::RestStateIsHigh);
        spi_regs()
            .cs
            .modify(spi::CS::CPHA::FirstSclkTransitionAtBeginningOFDataBit);
    }

    pub fn regwrite(regaddr: u32, writeval: u32) {
        //(1)CSレジスタのTAビットを1にする。
        spi_regs().cs.modify(spi::CS::TA::SET);

        //(2)FIFOに送信データを書く（送信データ：ライト対象の加速度センサのレジスタ値）
        spi_regs().fifo.write(spi::FIFO::DATA.val(regaddr));

        //(3)CSレジスタのTXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::TXD) {}

        //(4)FIFOに送信データを書く（送信データ：先ほどのレジスタへのライト値）
        spi_regs().fifo.write(spi::FIFO::DATA.val(writeval));

        //(5)CSレジスタのDONEビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::DONE) {}

        //(6)CSレジスタのCLEARビットに0x01を書いてFIFOクリア
        spi_regs().cs.modify(spi::CS::CLEAR_TX::SET);

        //(7)CSレジスタのTAビットを0にして送信完了。
        spi_regs().cs.modify(spi::CS::TA::CLEAR);
    }

    //TODO: エラー処理は今回は考えず、後で考える
    pub fn regread(regval: u32) -> i32 {
        let retdata_h: u32;
        let retdata_l: u32;
        let mut retdata: i32;

        //(1)CSレジスタのTAビットを1にする。
        spi_regs().cs.modify(spi::CS::TA::SET);

        //(2)CSレジスタのCLEARビットに0x03を書いてTX-FIFO, RX-FIFOクリア
        spi_regs().cs.modify(spi::CS::CLEAR_TX::SET + spi::CS::CLEAR_RX::SET);

        //(3)FIFOに送信データを書く（送信データ：ライト対象の加速度センサのレジスタ値）
        spi_regs().fifo.write(spi::FIFO::DATA.val(regval));

        //(4)CSレジスタのTXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::TXD) {}

        //(5)CSレジスタのRXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::RXD) {}

        //(6)CSレジスタのCLEARビットに0x02を書いてRX-FIFOクリア
        spi_regs().cs.modify(spi::CS::CLEAR_RX::SET);

        //(7)FIFOに送信データを書く（送信データ：押し出すだけなのでダミーで0)
        spi_regs().fifo.write(spi::FIFO::DATA.val(0x00));

        //(8)CSレジスタのTXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::TXD) {}

        //(9)CSレジスタのRXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::RXD) {}

        //(10)待ち終わったらFIFOリード
        retdata_l = spi_regs().fifo.read(spi::FIFO::DATA);

        //(11)FIFOに送信データを書く（送信データ：押し出すだけなのでダミーで0）
        spi_regs().fifo.write(spi::FIFO::DATA.val(0x00));

        //(12)CSレジスタのTXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::TXD) {}

        //(13)CSレジスタのRXDビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::RXD) {}

        //(14)待ち終わったらFIFOリード
        retdata_h = spi_regs().fifo.read(spi::FIFO::DATA);

        //(15)CSレジスタのDONEビットが1になるまで待つ
        while !spi_regs().cs.is_set(spi::CS::DONE) {}

        //(16)CSレジスタのCLEARビットに0x03を書いてTX-FIFO, RX-FIFOクリア
        spi_regs().cs.modify(spi::CS::CLEAR_TX::SET + spi::CS::CLEAR_RX::SET);

        //(17)CSレジスタのTAビットを0にして送受信完了。
        spi_regs().cs.modify(spi::CS::TA::CLEAR);

        retdata = i32::try_from(retdata_l | (retdata_h << 8)).unwrap();

		//符号アリに変換
        if (retdata & 0x8000) != 0x0000 {
            retdata = (!retdata & 0xFFFF) + 1;
            retdata = 0 - retdata;
        }
        return retdata;
    }
}