投稿者: admin_wp

% python -u "/Users/usamiryuuichi/python/seismic.py"
2024-11-08 19:49:45.068661 scale: 0  frame: 0
2024-11-08 19:49:45.169671 scale: 0  frame: 20
2024-11-08 19:49:45.269686 scale: 0  frame: 40
2024-11-08 19:49:45.369185 scale: 4.141110582455145  frame: 60
2024-11-08 19:49:45.469702 scale: 5.676822095241448  frame: 80
2024-11-08 19:49:45.569745 scale: 5.676822095241448  frame: 100
2024-11-08 19:49:45.669175 scale: 5.676822095241448  frame: 120
2024-11-08 19:49:45.769694 scale: 5.676822095241448  frame: 140


% cargo run --release
    Finished `release` profile [optimized] target(s) in 0.01s
     Running `target/release/seismic`
time: 2024-11-08 22:28:28.151209 UTC, scale: 0, frame: 0
time: 2024-11-08 22:28:28.252217 UTC, scale: 0, frame: 20
time: 2024-11-08 22:28:28.351601 UTC, scale: 0, frame: 40
time: 2024-11-08 22:28:28.451895 UTC, scale: 4.18249, frame: 60
time: 2024-11-08 22:28:28.552350 UTC, scale: 5.681231, frame: 80
time: 2024-11-08 22:28:28.652210 UTC, scale: 5.681231, frame: 100
time: 2024-11-08 22:28:28.751913 UTC, scale: 5.681231, frame: 120
time: 2024-11-08 22:28:28.852249 UTC, scale: 5.681231, frame: 140

//
// https://doc.rust-lang.org/std/thread/fn.spawn.html
//
use std::thread;
use std::sync::mpsc::channel;
use std::time::Duration;

fn main() {
    // チャネルを作成
    let (tx, rx) = channel();

    // レシーバースレッドをspawn
    let _receiver = thread::spawn(move || {
        let value: String = rx.recv().expect("Unable to receive from channel");
        rcv(value.clone());
    });

    // センダースレッドをspawn
    let _sender = thread::spawn(move || {
        tx.send("Hello, thread".to_owned())
            .expect("Unable to send on channel");
    });

    // センダースレッドの終了を待つ
    //sender.join().expect("The sender thread has panicked");

    // レシーバースレッドの終了を待つ（但し、rcv関数の終了を待たない）
    //receiver.join().expect("The receiver thread has panicked");

    println!("reach to the end");
    thread::sleep(Duration::from_secs_f32(1.5));
}

fn rcv(value: String) {
    thread::sleep(Duration::from_secs_f32(1.0));
    println!("recieved : {}", value);
}

use rppal::spi::{Bus, Mode, SlaveSelect, Spi};
use std::thread;
use std::time::Duration;

const CHANNEL_0: u8 = 0x06 | 0x00; // Command byte for single-ended mode

fn main() {
    // Create a SPI object
    let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 1_000_000, Mode::Mode0).unwrap();

    // Define the buffers for reading and writing
    let mut read_buffer = [0u8; 3];
    let write_buffer = [CHANNEL_0, 0x00, 0x00];

    // Poll the sensor every n seconds
    let poll_rate = Duration::from_secs(1);
    loop {
        // Perform the SPI transfer
        spi.transfer(&mut read_buffer, &write_buffer).unwrap();

        // Extract the 12-bit ADC value
        // Note: MCP3204 returns 12-bit data, but the second byte contains status bit(0) and the MSB of the result.
        let msb = (read_buffer[1] & 0x0F) as u16;
        let lsb = read_buffer[2] as u16; // Convert third byte to u16
        let result = (msb << 8) | lsb;

        println!("Sensor value: {}", result);      

        println!("{:08b}, {:08b}", read_buffer[1], read_buffer[2]);

        thread::sleep(poll_rate);
    }
}

[dependencies]
rppal = "0.19.0"

$ ./adc_rppal
Sensor value: 2867
00001011, 00110011
Sensor value: 2867
00001011, 00110011
Sensor value: 2867
00001011, 00110011
Sensor value: 2867
00001011, 00110011
Sensor value: 2868
00001011, 00110100

    // absolute value calc
    let y: Vec<f32> = buffer.iter().map(|z| z.norm().log(10.0)*20.0).collect();