290 lines
7.8 KiB
Rust
290 lines
7.8 KiB
Rust
use crate::serial_core::codecs::test::{export_recording_csv, TestCodec, TestCsvImporter, TestHandler};
|
|
use crate::serial_core::error::SerialError;
|
|
use crate::serial_core::record::CsvImporter;
|
|
use crate::serial_core::{TestRecording, serial};
|
|
use log::info;
|
|
use serde::Serialize;
|
|
use std::fs::File;
|
|
use std::io::Cursor;
|
|
use std::sync::{Arc, Mutex};
|
|
use std::time::{Instant, SystemTime, UNIX_EPOCH};
|
|
use tauri::{async_runtime::JoinHandle, AppHandle, Manager, State};
|
|
use tokio_serial::{available_ports, SerialPortBuilderExt};
|
|
use tokio_util::sync::CancellationToken;
|
|
|
|
type SharedTestRecording = Arc<Mutex<TestRecording>>;
|
|
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SerialConnectResponse {
|
|
pub port: String,
|
|
pub connected: bool,
|
|
pub message: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SerialExportResponse {
|
|
pub path: String,
|
|
pub frame_count: usize,
|
|
pub message: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SerialImportFrame {
|
|
pub data: Vec<i32>,
|
|
pub dts_ms: u64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SerialImportResponse {
|
|
pub file_name: String,
|
|
pub frame_count: usize,
|
|
pub channel_count: usize,
|
|
pub frames: Vec<SerialImportFrame>,
|
|
pub message: String,
|
|
}
|
|
|
|
struct SerialSession {
|
|
port: String,
|
|
cancel: CancellationToken,
|
|
task: JoinHandle<()>,
|
|
current_record: SharedTestRecording,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct SerialConnectionState {
|
|
session: Mutex<Option<SerialSession>>,
|
|
last_record: Mutex<Option<SharedTestRecording>>
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn serial_enum() -> Result<Vec<String>, SerialError> {
|
|
let ports = available_ports()
|
|
.map_err(|_| SerialError::ScanError)?
|
|
.into_iter()
|
|
.map(|info| info.port_name)
|
|
.collect();
|
|
|
|
Ok(ports)
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn serial_connect(
|
|
app: AppHandle,
|
|
port: String,
|
|
state: State<'_, SerialConnectionState>,
|
|
) -> Result<SerialConnectResponse, SerialError> {
|
|
let port_name = port.trim().to_string();
|
|
if port_name.is_empty() {
|
|
return Err(SerialError::InvalidConfig);
|
|
}
|
|
|
|
{
|
|
let session = state.session.lock().map_err(|_| SerialError::StateError)?;
|
|
if session.is_some() {
|
|
return Err(SerialError::AlreadyConnected);
|
|
}
|
|
}
|
|
|
|
let cancel = CancellationToken::new();
|
|
let current_record = Arc::new(Mutex::new(TestRecording::new()));
|
|
let task_record = current_record.clone();
|
|
let task_cancel = cancel.clone();
|
|
let task_app = app.clone();
|
|
let task_port_name = port_name.clone();
|
|
|
|
let port = tokio_serial::new(&port_name, 115200)
|
|
.open_native_async()
|
|
.map_err(|_| SerialError::OpenError)?;
|
|
let session_started_at = Instant::now();
|
|
|
|
let task = tauri::async_runtime::spawn(async move {
|
|
let codec = TestCodec::new();
|
|
let handler = TestHandler;
|
|
|
|
if let Err(error) = serial::run_serial(
|
|
task_app.clone(),
|
|
port,
|
|
codec,
|
|
handler,
|
|
session_started_at,
|
|
task_record.clone(),
|
|
task_cancel,
|
|
)
|
|
.await
|
|
{
|
|
eprintln!("serial task exited with error: {error}");
|
|
}
|
|
|
|
let manager = task_app.state::<SerialConnectionState>();
|
|
if let Ok(mut last_record) = manager.last_record.lock() {
|
|
*last_record = Some(task_record);
|
|
}
|
|
|
|
let mut session = match manager.session.lock() {
|
|
Ok(session) => session,
|
|
Err(_) => return,
|
|
};
|
|
|
|
{
|
|
let should_clear = session
|
|
.as_ref()
|
|
.map(|current| current.port.as_str() == task_port_name.as_str())
|
|
.unwrap_or(false);
|
|
|
|
if should_clear {
|
|
session.take();
|
|
}
|
|
}
|
|
});
|
|
|
|
let mut session = state.session.lock().map_err(|_| SerialError::StateError)?;
|
|
if session.is_some() {
|
|
cancel.cancel();
|
|
task.abort();
|
|
return Err(SerialError::AlreadyConnected);
|
|
}
|
|
|
|
*session = Some(SerialSession {
|
|
port: port_name.clone(),
|
|
cancel,
|
|
task,
|
|
current_record
|
|
});
|
|
|
|
Ok(SerialConnectResponse {
|
|
port: port_name,
|
|
connected: true,
|
|
message: "connected".to_string(),
|
|
})
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn serial_disconnect(
|
|
state: State<'_, SerialConnectionState>,
|
|
) -> Result<SerialConnectResponse, SerialError> {
|
|
let session = {
|
|
let mut guard = state.session.lock().map_err(|_| SerialError::StateError)?;
|
|
guard.take()
|
|
};
|
|
|
|
let Some(SerialSession {
|
|
port,
|
|
cancel,
|
|
task,
|
|
current_record,
|
|
}) = session
|
|
else {
|
|
return Ok(SerialConnectResponse {
|
|
port: String::new(),
|
|
connected: false,
|
|
message: "already disconnected".to_string(),
|
|
});
|
|
};
|
|
|
|
cancel.cancel();
|
|
let _ = task.await;
|
|
let frame_count = current_record.lock().map(|record| {
|
|
record.frames.len()
|
|
}).unwrap_or(0);
|
|
|
|
info!("last_record has {} frames", frame_count);
|
|
|
|
if let Ok(mut last_record) = state.last_record.lock() {
|
|
*last_record = Some(current_record);
|
|
}
|
|
|
|
|
|
Ok(SerialConnectResponse {
|
|
port,
|
|
connected: false,
|
|
message: "disconnected".to_string(),
|
|
})
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn serial_export_csv(
|
|
app: AppHandle,
|
|
state: State<'_, SerialConnectionState>,
|
|
) -> Result<SerialExportResponse, SerialError> {
|
|
let current_record = {
|
|
let session = state.session.lock().map_err(|_| SerialError::StateError)?;
|
|
session
|
|
.as_ref()
|
|
.map(|current_session| current_session.current_record.clone())
|
|
};
|
|
|
|
let record = if let Some(recording) = current_record {
|
|
recording
|
|
} else {
|
|
let last_record = state.last_record.lock().map_err(|_| SerialError::StateError)?;
|
|
last_record.clone().ok_or(SerialError::NoRecordedData)?
|
|
};
|
|
|
|
let mut output_dir = match app.path().desktop_dir() {
|
|
Ok(path) => path,
|
|
Err(_) => std::env::current_dir().map_err(|_| SerialError::ExportError)?,
|
|
};
|
|
|
|
let timestamp = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.map(|duration| duration.as_millis())
|
|
.unwrap_or_default();
|
|
|
|
output_dir.push(format!("joyson_export_{timestamp}.csv"));
|
|
let mut file = File::create(&output_dir).map_err(|_| SerialError::ExportError)?;
|
|
|
|
let frame_count = {
|
|
let recording = record.lock().map_err(|_| SerialError::StateError)?;
|
|
if recording.frames.is_empty() {
|
|
return Err(SerialError::NoRecordedData);
|
|
}
|
|
|
|
export_recording_csv(&recording, &mut file).map_err(|_| SerialError::ExportError)?;
|
|
recording.frames.len()
|
|
};
|
|
|
|
let path = output_dir.display().to_string();
|
|
info!("csv exported to {path}, frame_count={frame_count}");
|
|
|
|
Ok(SerialExportResponse {
|
|
path,
|
|
frame_count,
|
|
message: "exported".to_string(),
|
|
})
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn serial_import_csv(file_name: String, csv_content: String) -> Result<SerialImportResponse, SerialError> {
|
|
let mut importer = TestCsvImporter::new(file_name.as_str());
|
|
let packets = importer
|
|
.load(Cursor::new(csv_content.into_bytes()))
|
|
.map_err(|_| SerialError::ImportError)?;
|
|
|
|
if packets.is_empty() {
|
|
return Err(SerialError::NoRecordedData);
|
|
}
|
|
|
|
let channel_count = packets.first().map(|item| item.data.len()).unwrap_or(0);
|
|
let frame_count = packets.len();
|
|
let frames = packets
|
|
.into_iter()
|
|
.map(|packet| SerialImportFrame {
|
|
data: packet.data,
|
|
dts_ms: packet.dts_ms,
|
|
})
|
|
.collect();
|
|
|
|
Ok(SerialImportResponse {
|
|
file_name,
|
|
frame_count,
|
|
channel_count,
|
|
frames,
|
|
message: "imported".to_string(),
|
|
})
|
|
}
|