Adds snooping data, hopes to find the missing link

This commit is contained in:
Dandaedre 2024-09-20 09:24:35 -05:00
parent 9c7a718e98
commit 06f48849b6
5 changed files with 3283 additions and 32 deletions

View File

@ -4,9 +4,12 @@ version = "0.1.0"
edition = "2021"
[dependencies]
byteorder = "1.5.0"
clap = { version = "4.5.17", features = ["derive"] }
csv = "1.3.0"
hex = "0.4.3"
memchr = "2.7.4"
once_cell = "1.19.0"
packed_struct = "0.10.1"
serialport = "4.5.0"
thiserror = "1.0.63"

BIN
Snoop/COM3 Monitoring Session.spm Executable file

Binary file not shown.

3173
Snoop/snoop.txt Executable file

File diff suppressed because it is too large Load Diff

1
b.txt Executable file

File diff suppressed because one or more lines are too long

View File

@ -1,10 +1,12 @@
use byteorder::ReadBytesExt;
// use clap::Parser;
use memchr::memmem;
// use once_cell::sync::OnceCell;
use serialport::SerialPort;
use std::{
fs::File,
io::{BufWriter, Write},
io::{BufWriter, Read, Write},
sync::OnceLock,
thread::sleep,
time::Duration,
@ -47,40 +49,74 @@ fn main() -> Result<(), TinyError> {
println!("{}", p.port_name);
}
let mut port = serialport::new("/dev/ttyACM0", 115_200)
.timeout(Duration::from_millis(2000))
.timeout(Duration::from_millis(3000))
.open()
.expect("Failed to open port");
initialize(&mut port);
println!("{}", send_cmd(&mut port, "version\r", 10));
println!("{}", send_cmd(&mut port, "info\r", 10));
println!("{}", send_cmd(&mut port, "threads\r", 10));
println!("{}", send_cmd(&mut port, "help\r", 50));
println!("{}", send_cmd(&mut port, "version\r", 50));
println!("{}", send_cmd(&mut port, "info\r", 50));
// println!("{}", send_cmd(&mut port, "threads\r", 50));
println!("{}", send_cmd(&mut port, "leveloffset\r", 50));
println!("{}", send_cmd(&mut port, "deviceid\r", 50));
println!("{}", send_cmd(&mut port, "vbat offset\r", 50));
println!("{}", send_cmd(&mut port, "vbat\r", 50));
println!("{}", send_cmd(&mut port, "usart_cfg\r", 50));
println!("{}", send_cmd(&mut port, "marker\r", 50));
println!("{}", send_cmd(&mut port, "sweep\r", 50));
println!("{}", send_cmd(&mut port, "mode\r", 50));
println!("{}", send_cmd(&mut port, "lna\r", 50));
println!("{}", send_cmd(&mut port, "zero 250\r", 50));
println!("{}", send_cmd(&mut port, "pause\r", 50));
println!("{}", send_cmd(&mut port, "vbat\r", 50));
println!("{}", send_cmd(&mut port, "marker\r", 50));
println!("{}", send_cmd(&mut port, "sweep\r", 50));
println!("{}", send_cmd(&mut port, "mode high input\r", 50));
// println!("{}", send_cmd(&mut port, "sweep 240000000 960000000 290\r",10));
// println!("{}", send_cmd(&mut port, "frequencies\r",10));
// println!("{}", send_cmd(&mut port, "sweep\r",10));
// println!("{}", send_cmd(&mut port, "sweep start\r",10));
// println!("{}", send_cmd(&mut port, "frequencies\r",10));
println!("{}", send_cmd(&mut port, "repeat 2\r", 10));
println!("{}", send_cmd(&mut port, "pause\r", 10));
// println!("{}", send_cmd(&mut port, "repeat 2\r", 10));
// println!("{}", send_cmd(&mut port, "pause\r", 10));
println!("{}", send_cmd(&mut port, "mode high input\r", 10));
println!("{}", send_cmd(&mut port, "freq 935m\r", 10));
println!("{}", send_cmd(&mut port, "scan 940 950m 10 101\r", 2000));
initialize(&mut port);
println!("{}", send_cmd(&mut port, "freq 937m\r", 10));
// println!("{}", send_cmd(&mut port, "freq 935m\r", 10));
// println!("{}", send_cmd(&mut port, "freq 937m\r", 10));
println!("{}", send_cmd(&mut port, "sweep\r", 50));
println!(
"{}",
send_cmd(&mut port, &format!("sweep start {}\r", START), 50)
);
println!(
"{}",
send_cmd(&mut port, &format!("sweep stop {}\r", STOP), 50)
);
println!("{}", send_cmd(&mut port, "sweep\r", 50));
println!(
"{}",
send_cmd(&mut port, "scan 240000000 959000000 290 101\r", 2000)
);
// println!(
// "{}",
// send_cmd(&mut port, &format!("scan {} {} 100 101\r", START, STOP), 50)
// );
println!("{:?}", scanraw(&mut port));
println!("{}", send_cmd(&mut port, "resume\r", 10));
println!("{}", send_cmd(&mut port, "resume\r", 50));
wait_sync(200);
Ok(())
}
fn initialize(port: &mut Box<dyn SerialPort>) {
wait_sync(100);
wait_sync(50);
println!(
"Initializing ... \nUninialized bytes: {:?}",
read_port(port)
);
wait_sync(100)
wait_sync(50)
}
/// Bad synchronisation method to ensure data is truthfully sent/received
@ -88,17 +124,24 @@ fn wait_sync(duration: u64) {
sleep(Duration::from_millis(duration));
}
static START: usize = 930;
static STOP: usize = 940;
static POINTS: usize = (STOP - START) * 100;
static INCREMENT: usize = 10; // 1000/100
static START: usize = 240000000;
static STOP: usize = 959000000;
static POINTS: usize = 10000; //(STOP - START) * 10;
static INCREMENT: usize = (STOP - START) / POINTS; // 1000/100
/// Scan raw frequencies
fn scanraw(port: &mut Box<dyn SerialPort>) -> Result<(), TinyError> {
unsafe { send_raw(port, &format!("scanraw {}m {}m {}\r", START, STOP, POINTS)) }
// wait_sync();
read_scanraw(port)?;
wait_sync(100);
let mut f = File::open("b.txt")?;
let mut s = String::new();
let d = f.read_to_string(&mut s)?;
println!("{}", s);
let v = hex::decode(&s[..s.len() - 1]).unwrap();
println!("{:?}", v);
parse_data(v).unwrap();
// unsafe { send_raw(port, &format!("scanraw {} {} {}\r", START, STOP, POINTS)) }
// wait_sync(50);
// read_scanraw(port)?;
// wait_sync(100);
Ok(())
}
@ -107,7 +150,7 @@ fn send_cmd(port: &mut Box<dyn SerialPort>, command: &str, wait: u64) -> String
unsafe { send_raw(port, command) }
wait_sync(wait);
let r = read_utf8(port);
wait_sync(200);
wait_sync(100);
r
}
@ -141,6 +184,16 @@ fn read_port(port: &mut Box<dyn SerialPort>) -> Vec<u8> {
res
}
use packed_struct::prelude::*;
#[derive(PackedStruct, Debug)]
// #[packed_struct(bit_numbering = "lsb0", endian = "lsb")]
#[packed_struct(endian = "lsb")]
pub struct DataPoint {
// #[packed_field(bits = "0..=7")]
c: u8,
// #[packed_field(bits = "8..22")]
value: u16,
}
/// Scan for a raw frequencies, assumes everything is setup and the scan can proceed
/// Waits the normal start Character '{' and begins treating data as normal
///
@ -148,22 +201,40 @@ fn read_port(port: &mut Box<dyn SerialPort>) -> Vec<u8> {
fn read_scanraw(port: &mut Box<dyn SerialPort>) -> Result<(), TinyError> {
let v = read_port(port);
// Find the { marking the beggining
parse_data(v)
}
fn parse_data(v: Vec<u8>) -> Result<(), TinyError> {
let mut values: Vec<u16> = Vec::with_capacity(POINTS);
let mut out = BufWriter::new(File::create("test.csv")?);
if let Some(begining) = memchr::memchr(b'{', &v) {
// Finds the } marking the end
if let Some(end) = memchr::memchr(b'}', &v) {
let data = &v[begining + 1..end];
for (i, slice) in data.chunks_exact(3).enumerate() {
let (x, msb, lsb) = (slice[0], slice[1], slice[2]);
let s: &[u8; 3] = &[slice[0], slice[1], slice[2]];
let d = DataPoint::unpack(s).unwrap();
// let (x, b1, b2) = (slice[0], slice[1], slice[2]);
// println!("{} {} {} -> {}", x, msb, lsb, bytes_to_f64(msb, lsb));
// println!("{} -> {}", i * INCREMENT, bytes_to_f64(msb, lsb));
// let f = bytes_to_f64(b1, b2);
// values.push((msb.reverse_bits() as u16) << 8 | lsb.reverse_bits() as u16);
values.push(d.value);
writeln!(
out,
"{},{}",
(i * INCREMENT + START * 1000) as f64 / 1000.,
bytes_to_f64(msb, lsb)
(i * INCREMENT + START) as f64 / 1000000.,
d.value as f64 / 64. - 128. // bytes_to_f64(b1, b2)
)?;
}
println!(
"Found {} values, min: {:?}, max: {:?}",
values.len(),
(*values.iter().min().unwrap_or(&0) as f64 / 32.) - 128.,
(*values.iter().max().unwrap_or(&0) as f64 / 32.) - 128.
);
// scale 0..4095 -> -128..-0.03 dBm
// println!("Slice: {}:{}, Data:{:?}", begining, end, data);
Ok(())
} else {
@ -174,9 +245,9 @@ fn read_scanraw(port: &mut Box<dyn SerialPort>) -> Result<(), TinyError> {
}
}
fn bytes_to_f64(msb: u8, lsb: u8) -> f64 {
let a = (((lsb as u16) << 8) | msb as u16);
a as f64 / 32. - 128.
fn bytes_to_f64(b1: u8, b2: u8) -> f64 {
let a = (((b2 as u16) << 8) | b1 as u16);
(a as f64 / 32.) - 128.
}
/// The result of a scan
@ -204,6 +275,9 @@ pub enum ScanStatus {
// ProgressB: Indicatif
// Version: tinySA4: Ultra, tinySA_ Tiny
// Scan will start with 123 and end with 125
// https://groups.io/g/tinysa
// https://github.com/Ho-Ro/tinySA/blob/main/sa_cmd.c
// loop {
// // println!("{}", send_cmd(&mut port, "0\r"));
// print!("ch> ");
@ -217,6 +291,6 @@ pub enum ScanStatus {
// }
// // println!("{}", send_cmd(&mut port, "scan 240m 960m 240 11\r"));
// // println!("{}", send_cmd(&mut port, "scanraw 240m 960m 10000\r"));
// // println!("{}", send_cmd(&mut port, "scanraw 240m 960m 1000\r"));
// send_cmd(&mut port, "resume\r");
// // // println!("{}", send_cmd(&mut port, "scanraw 240m 960m 1000\r"));
// // send_cmd(&mut port, "resume\r");
// }