279 lines
9.4 KiB
Rust
279 lines
9.4 KiB
Rust
use std::fmt::Display;
|
|
use crate::download_wrapper::DownloadError::JlinkNotFindError;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use std::io::Write;
|
|
|
|
pub struct DownloadWrapper {
|
|
commander_path: PathBuf,
|
|
bin_path: PathBuf,
|
|
bootloader_name: String,
|
|
app_name: String,
|
|
rail_name: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum DownloadType {
|
|
Bootloader,
|
|
App,
|
|
Rail,
|
|
}
|
|
|
|
impl Display for DownloadType {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let str = match self {
|
|
DownloadType::Bootloader => "BootLoader".to_string(),
|
|
DownloadType::App => "App".to_string(),
|
|
DownloadType::Rail => "Rail".to_string(),
|
|
};
|
|
write!(f, "{}", str)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum DownloadError {
|
|
JlinkNotFindError,
|
|
DeviceNotFindError,
|
|
EraseError,
|
|
DownloadBootloaderError,
|
|
DownloadAppError,
|
|
DownloadRailError,
|
|
NoLabel,
|
|
}
|
|
|
|
impl Default for DownloadWrapper {
|
|
fn default() -> Self {
|
|
Self {
|
|
commander_path: PathBuf::from(std::env::current_dir().unwrap())
|
|
.join("commander/Simplicity Commander/commander.exe"),
|
|
bin_path: PathBuf::from(std::env::current_dir().unwrap()).join("bin/"),
|
|
bootloader_name: String::from("RAWM00-2-0-0_silicon-wisun_bootloader_D20241008.s37"),
|
|
app_name: String::from("RAWM00-2-0-0_silicon-combine-V1-D20241230-BZ.hex"),
|
|
rail_name: String::from("rail_soc_railtest_sisdk(silabs).hex"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DownloadWrapper {
|
|
pub(crate) fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
pub fn check_jlink(&self) -> Result<Vec<String>, DownloadError> {
|
|
let commander_path_str = self.commander_path.to_str().unwrap();
|
|
let output = Command::new(commander_path_str)
|
|
.arg("adapter")
|
|
.arg("list")
|
|
.output()
|
|
.expect("Failed to execute command");
|
|
if output.status.success() {
|
|
let result_str = String::from_utf8_lossy(&output.stdout).to_string();
|
|
let result = result_str.split("\r\n").collect::<Vec<&str>>();
|
|
let device_index_str: Vec<String> = result
|
|
.iter()
|
|
.filter(|&&str| str.starts_with("deviceCount"))
|
|
.map(|&str| str.to_string())
|
|
.collect();
|
|
if device_index_str.is_empty()
|
|
|| device_index_str[0].split("=").collect::<Vec<&str>>()[1] == "0"
|
|
{
|
|
Err(JlinkNotFindError)
|
|
} else {
|
|
let device_ids = result
|
|
.iter()
|
|
.filter(|&&str| str.trim().starts_with("serialNumber"))
|
|
.map(|&str| {
|
|
let temp = str.to_string();
|
|
return temp.split("=").collect::<Vec<&str>>()[1].to_string();
|
|
})
|
|
.collect::<Vec<String>>();
|
|
Ok(device_ids)
|
|
}
|
|
} else {
|
|
Err(JlinkNotFindError)
|
|
}
|
|
}
|
|
|
|
pub fn check_device(&self) -> Result<(), DownloadError> {
|
|
let commander_path_str = self.commander_path.to_str().unwrap();
|
|
let output = Command::new(commander_path_str)
|
|
.arg("device")
|
|
.arg("info")
|
|
.arg("--device")
|
|
.arg("Cortex-M4")
|
|
.output()
|
|
.expect("Failed to execute command");
|
|
let stdout = String::from_utf8_lossy(&output.stdout).to_string();
|
|
let result = stdout.split("\r\n").collect::<Vec<&str>>();
|
|
let error_log = result
|
|
.iter()
|
|
.filter(|&&str| str.trim().starts_with("ERROR"))
|
|
.collect::<Vec<&&str>>();
|
|
if error_log.is_empty() {
|
|
Ok(())
|
|
} else {
|
|
Err(DownloadError::DeviceNotFindError)
|
|
}
|
|
}
|
|
|
|
pub fn erase(&self, label: Option<String>) -> Result<String, DownloadError> {
|
|
let commander_path_str = self.commander_path.to_str().unwrap();
|
|
let output = Command::new(commander_path_str)
|
|
.arg("device")
|
|
.arg("masserase")
|
|
.arg("--device")
|
|
.arg("Cortex-M4")
|
|
.output()
|
|
.expect("Failed to execute command");
|
|
let result_str = String::from_utf8_lossy(&output.stdout).to_string();
|
|
let result = result_str.split("\r\n").collect::<Vec<&str>>();
|
|
if !result
|
|
.iter()
|
|
.filter(|&&str| str.trim().starts_with("ERROR"))
|
|
.collect::<Vec<&&str>>()
|
|
.is_empty()
|
|
|| result
|
|
.iter()
|
|
.filter(|&&str| str.trim().contains("successfully"))
|
|
.collect::<Vec<&&str>>()
|
|
.is_empty()
|
|
{
|
|
Err(DownloadError::EraseError)
|
|
} else {
|
|
let Some(label) = label else { return Err(DownloadError::NoLabel) };
|
|
match self.save_log(label, result_str.clone()) {
|
|
Ok(_) => {
|
|
Ok(result_str)
|
|
}
|
|
Err(_) => {
|
|
Err(DownloadError::DownloadBootloaderError)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn download(&self, download_type: DownloadType, label: Option<String>) -> Result<String, DownloadError> {
|
|
let mut binding: PathBuf;
|
|
match download_type {
|
|
DownloadType::Bootloader => {
|
|
binding = self.bin_path.join(&self.bootloader_name);
|
|
}
|
|
DownloadType::App => {
|
|
binding = self.bin_path.join(&self.app_name);
|
|
}
|
|
DownloadType::Rail => {
|
|
binding = self.bin_path.join(&self.rail_name);
|
|
}
|
|
}
|
|
let bin_path = binding.to_str().unwrap();
|
|
println!("{:?}", bin_path);
|
|
let commander_path_str = self.commander_path.to_str().unwrap();
|
|
let output = Command::new(commander_path_str)
|
|
.arg("flash")
|
|
.arg(bin_path)
|
|
.arg("--device")
|
|
.arg("Cortex-M4")
|
|
.output()
|
|
.expect("Failed to execute command");
|
|
let result_str = String::from_utf8_lossy(&output.stdout).to_string();
|
|
let result = result_str.split("\r\n").collect::<Vec<&str>>();
|
|
println!("{:?}", result);
|
|
if !result
|
|
.iter()
|
|
.filter(|&&str| str.trim().starts_with("ERROR"))
|
|
.collect::<Vec<&&str>>()
|
|
.is_empty()
|
|
|| result
|
|
.iter()
|
|
.filter(|&&str| str.trim().contains("successfully"))
|
|
.collect::<Vec<&&str>>()
|
|
.is_empty()
|
|
{
|
|
Err(DownloadError::DownloadBootloaderError)
|
|
} else {
|
|
let Some(label) = label else { return Err(DownloadError::NoLabel) };
|
|
match self.save_log(label, result_str.clone()) {
|
|
Ok(_) => {
|
|
Ok(result_str)
|
|
}
|
|
Err(_) => {
|
|
Err(DownloadError::DownloadBootloaderError)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn save_log(& self, label: String, log: String) -> Result<bool, DownloadError> {
|
|
if !fs::exists("./log").unwrap() {
|
|
fs::create_dir("./log").expect("Cant Create Log Folder");
|
|
}
|
|
let mut file = fs::OpenOptions::new()
|
|
.create(true)
|
|
.append(true)
|
|
.open(format!("./log/{label}.txt"))
|
|
.expect("file not found");
|
|
writeln!(file, "{}",log).expect("write failed");
|
|
Ok(true)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::download_wrapper::DownloadType;
|
|
use crate::download_wrapper::DownloadWrapper;
|
|
|
|
#[test]
|
|
fn test_download_wrapper() {
|
|
let dw = DownloadWrapper::new();
|
|
println!("{:?}", dw.commander_path);
|
|
println!("{:?}", dw.bin_path);
|
|
println!("{:?}", dw.bootloader_name);
|
|
println!("{:?}", dw.app_name);
|
|
println!("{:?}", dw.rail_name);
|
|
}
|
|
|
|
#[test]
|
|
fn test_check_jlink() {
|
|
let dw = DownloadWrapper::new();
|
|
let result = dw.check_jlink();
|
|
assert_eq!(result.is_ok(), true);
|
|
println!("ids:{:?}", result.unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_check_device() {
|
|
let dw = DownloadWrapper::new();
|
|
let result = dw.check_device();
|
|
assert_eq!(result.is_ok(), true);
|
|
}
|
|
|
|
#[test]
|
|
fn test_erase_device() {
|
|
let dw = DownloadWrapper::new();
|
|
let result = dw.erase(Some("111".to_string()));
|
|
assert_eq!(result.is_ok(), true);
|
|
}
|
|
|
|
#[test]
|
|
fn test_download_bootloader() {
|
|
let dw = DownloadWrapper::new();
|
|
let result = dw.download(DownloadType::Bootloader, Some("111".to_string()));
|
|
assert_eq!(result.is_ok(), true);
|
|
}
|
|
|
|
#[test]
|
|
fn test_download_app() {
|
|
let dw = DownloadWrapper::new();
|
|
let result = dw.download(DownloadType::App, Some("111".to_string()));
|
|
assert_eq!(result.is_ok(), true);
|
|
}
|
|
|
|
#[test]
|
|
fn test_download_rail() {
|
|
let dw = DownloadWrapper::new();
|
|
let result = dw.download(DownloadType::Rail, Some("111".to_string()));
|
|
assert_eq!(result.is_ok(), true);
|
|
}
|
|
}
|