blizzardfinnegan/seymourLifeRust
1
1
Fork 0
Code Issues 1 Pull requests Projects Releases 7 Packages Wiki Activity Actions

Compare commits

base: blizzardfinnegan:stable
Branches Tags
blizzardfinnegan:stable
blizzardfinnegan:devel
blizzardfinnegan:v2.3.3
blizzardfinnegan:v2.3.2
blizzardfinnegan:v2.3.1
blizzardfinnegan:v2.3.0
blizzardfinnegan:v2.2.0
blizzardfinnegan:v2.1.0
blizzardfinnegan:v2.0.1
..
compare: blizzardfinnegan:v2.3.0
Branches Tags
blizzardfinnegan:devel
blizzardfinnegan:stable
blizzardfinnegan:v2.3.3
blizzardfinnegan:v2.3.2
blizzardfinnegan:v2.3.1
blizzardfinnegan:v2.3.0
blizzardfinnegan:v2.2.0
blizzardfinnegan:v2.1.0
blizzardfinnegan:v2.0.1

No commits in common. "stable" and "v2.3.0" have entirely different histories.
stable ... v2.3.0

14 changed files with 289 additions and 426 deletions
Show stats Expand all files Collapse all files

2
.cargo/config.toml
View file

@ -1,2 +0,0 @@
[target.aarch64-unknown-linux-musl]
linker = "lld"

43
.forgejo/workflows/buildcheck.yaml Normal file
View file

@ -0,0 +1,43 @@
name: Basic Cargo Checks
run-name: ${{ github.actor }} is testing
on: [push]
jobs:
docker-check:
runs-on: docker
steps:
- name: Grab misc. dependencies
run: |
apt update && apt install -y librust-libudev-sys-dev build-essential
- name: Check out repository code
uses: actions/checkout@v3
- name: Grab Rust toolchain
uses: https://github.com/actions-rs/toolchain@v1
with:
profile: minimal
toolchain: stable
target: aarch64-unknown-linux-gnu
override: true
- name: Run check
uses: https://github.com/actions-rs/cargo@v1
with:
command: check
docker-build:
runs-on: docker
steps:
- name: Grab misc. dependencies
run: |
apt update && apt install -y librust-libudev-sys-dev build-essential
- name: Check out repository code
uses: actions/checkout@v3
- name: Grab Rust toolchain
uses: https://github.com/actions-rs/toolchain@v1
with:
profile: minimal
toolchain: stable
target: aarch64-unknown-linux-gnu
override: true
- name: Run check
uses: https://github.com/actions-rs/cargo@v1
with:
command: build
args: --release

4
.gitignore vendored
View file

@ -1,5 +1,3 @@
/target
/logs
/output
.cargo
.rustup
/output

23
.woodpecker.yml
View file

@ -1,23 +0,0 @@
pipeline:
build:
image: nixos/nix:latest
commands:
- nix-shell --run 'cargo build --release --target aarch64-unknown-linux-musl'
# publish:
# when:
# event: tag
# image: woodpeckerci/plugin-gitea-release
# settings:
# base_url: https://git.blizzard.systems
# files:
# - "target/aarch64-unknown-linux-musl/release/seymour_life"
# checksum:
# - "target/aarch64-unknown-linux-musl/release/seymour_life"
# api_key: ${FORGEJO_API}
# secrets:
# - source: forgejo_api
# target: FORGEJO_API
# target: ${CI_COMMIT_TAG}
# draft: true
# prerelease: true
# title: .woodpecker/title.txt

1
.woodpecker/title.txt
View file

@ -1 +0,0 @@
v2.3.2

38
Cargo.lock generated
View file

@ -302,12 +302,6 @@ dependencies = [
"log",
]
[[package]]
name = "glob"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
[[package]]
name = "heck"
version = "0.4.1"
@ -388,6 +382,26 @@ version = "0.2.142"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
[[package]]
name = "libudev"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78b324152da65df7bb95acfcaab55e3097ceaab02fb19b228a9eb74d55f135e0"
dependencies = [
"libc",
"libudev-sys",
]
[[package]]
name = "libudev-sys"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c8469b4a23b962c1396b9b451dda50ef5b283e8dd309d69033475fa9b334324"
dependencies = [
"libc",
"pkg-config",
]
[[package]]
name = "link-cplusplus"
version = "1.0.8"
@ -472,6 +486,12 @@ version = "1.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
[[package]]
name = "pkg-config"
version = "0.3.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
[[package]]
name = "proc-macro-hack"
version = "0.5.20+deprecated"
@ -610,6 +630,7 @@ dependencies = [
"IOKit-sys",
"bitflags",
"cfg-if",
"libudev",
"mach 0.3.2",
"nix",
"regex",
@ -617,14 +638,13 @@ dependencies = [
]
[[package]]
name = "seymour_life"
version = "2.3.3"
name = "seymour_life_rust"
version = "2.3.0"
dependencies = [
"chrono",
"clap",
"derivative",
"fern",
"glob",
"log",
"once_cell",
"rppal",

10
Cargo.toml
View file

@ -1,18 +1,15 @@
#This feature is currently limited to nightly versions of cargo.
#cargo-features = ["per-package-target"]
[package]
name = "seymour_life"
version = "2.3.3"
name = "seymour_life_rust"
version = "2.3.0"
edition = "2021"
#This feature is currently limited to nightly versions of cargo.
#forced-target="aarch64-unknown-linux-musl"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
rppal = "0.14.1"
serialport = { version = "4.2.0", default-features = false }
serialport = "4.2.0"
log = "0.4"
fern = "0.6.2"
chrono = "0.4.24"
@ -20,7 +17,6 @@ once_cell = "1.17.1"
derivative = "2.2.0"
time = "0.2.23"
clap = { version = "4.3.2", features = ["derive"] }
glob = "0.3.1"
[dev-dependencies]
time = "0.2.23"

61
README.md
View file

@ -1,61 +0,0 @@
[![status-badge](https://ci.blizzard.systems/api/badges/blizzardfinnegan/seymourLifeRust/status.svg?branch=stable)](https://ci.blizzard.systems/blizzardfinnegan/seymourLifeRust)
# Seymour Life
This is a personal/professional project, which makes use of serial communications (tty over USB via UART) and Raspberry Pi GPIO to simulate long term use of a Seymour device.
Note that this project will ONLY run properly on a Raspberry Pi. It is developed on, and tested for, the Raspberry Pi 400. This should also be compatible with the Raspberry Pi 4, and Raspberry Pi 3, although they have not been explicitly tested. Older models of Raspberry Pi may work properly, however as this project is originally intended for the `aarch64`/`ARM64` architecture, and older compatibility will not be tested.
## Install
### Precompiled Binary
Pre-compiled binaries can be found in the [releases tab](https://git.blizzard.systems/blizzardfinnegan/seymourLifeRust/releases/latest). Download the preferred version to your preferred directory, then run the following command to make the code executable:
```bash
sudo chmod u+x ./seymour_life
```
To run the binary, simply run:
```bash
sudo ./seymour_life
```
Note that this command MUST be run as `sudo`/root, due to the way it interacts with GPIO. For more information, please see [the GPIO documentation](https://github.com/golemparts/rppal).
## Build From Source
To build this project from source *ON A RASPBERRY PI*, first, download the repository. This can be done by using the Download ZIP button, or running the following command in a terminal where `git` is installed:
```bash
git clone https://git.blizzard.systems/blizzardfinnegan/seymourLifeRust
```
Once the repository has been downloaded, the project can be built with `cargo`. This can be done using any of the listed install methods on [the Rust install website](https://rustup.rs/).
Once cargo has been installed, run the following to build the project:
```bash
cargo build --release
```
The runnable command can then be run by the following:
```bash
sudo ./target/release/seymour_life
```
You can also build without the `--release` flag, which wil take less time, but will be less optimised for the hardware. If you do this, substitue `./target/release/seymour_life` for `./target/debug/seymour_life` in the above command.
## Cross-Compilation
Cross compilation is possible with this project, if you do not have a Raspberry Pi available specifically for compilation. Compilation directly on the Pi is rather intensive, and takes significantly longer than cross-compiling.
If you are compiling on Linux, cross-compilation has a dependency of `lld`. This can be found in your distribution's package manager, or directly distributed by LLVM. For Nix users, a predefined `shell.nix` file has been provided for your convenience.
If you are compiling on Windows, to safely cross-compile, you must modify the `.cargo/config.toml` file. Replace `lld` with `rust-lld`, then cross-compilation should work properly.
```bash
cargo build --target aarch64-unknown-linux-musl
# OR
cargo build --release --target aarch64-unknown-linux-musl
```

2
build_requirements.md Normal file
View file

@ -0,0 +1,2 @@
librust-udev-sys-dev
pkg-config

7
notes.md Normal file
View file

@ -0,0 +1,7 @@
Auto-serial:
`echo 'y1q' | python3 -m debugmenu` contains the serial number. Search keyword is: "DtCtrlCfgDeviceSerialNum"
split on `\n`, collect into Vec<&str>. Iterate over Vec:
if doesn't contain colon, continue
split_once on colon
if first half is keyword, trim second half, remove `"` characters, save as serial

15
shell.nix
View file

@ -1,15 +1,4 @@
{pkgs ? import <nixpkgs> {} }:
pkgs.mkShell rec {
buildInputs = with pkgs; [ lld rustup ];
RUSTUP_HOME = toString ./.rustup;
CARGO_HOME = toString ./.cargo;
RUSTUP_TOOLCHAIN = "stable";
HOST_ARCH = "x86_64-unknown-linux-gnu";
CARGO_BUILD_TARGET = "aarch64-unknown-linux-musl";
shellHook = ''
export PATH=$PATH:${CARGO_HOME}/bin
export PATH=$PATH:${RUSTUP_HOME}/toolchains/${RUSTUP_TOOLCHAIN}-${HOST_ARCH}/bin/
rustup target add "${CARGO_BUILD_TARGET}"
'';
pkgs.mkShell {
nativeBuildInputs = with pkgs; [ cargo rustc pkg-config libudev-zero ];
}

189
src/device.rs
View file

@ -3,11 +3,10 @@ use crate::tty::{TTY, Response,Command};
use rppal::gpio::{Gpio,OutputPin};
const TEMP_WAIT:Duration = Duration::from_secs(3);
const REBOOTS_SECTION: &str = "Reboots";
const BP_SECTION: &str = "Successful BP tests";
const TEMP_SECTION: &str = "Successful temp tests";
const REBOOTS_SECTION: &str = "Reboots: ";
const BP_SECTION: &str = "Successful BP tests: ";
const TEMP_SECTION: &str = "Successful temp tests: ";
const OUTPUT_FOLDER: &str = "output/";
const SECTION_SEPARATOR: &str = ": ";
const UNINITIALISED_SERIAL: &str = "uninitialised";
const SERIAL_HEADER: &str = "DtCtrlCfgDeviceSerialNum";
#[derive(PartialEq,Debug)]
@ -16,8 +15,7 @@ pub enum State{
LoginPrompt,
DebugMenu,
LifecycleMenu,
BrightnessMenu,
ShellPrompt
BrightnessMenu
}
#[derive(Debug)]
@ -32,7 +30,6 @@ pub struct Device{
reboots: u64,
temps: u64,
init_temps: u64,
temp_offset: u64,
bps: u64
}
@ -41,7 +38,7 @@ impl Device{
if ! Path::new(&OUTPUT_FOLDER).is_dir(){
_ = fs::create_dir(&OUTPUT_FOLDER);
};
//log::debug!("{:?}",&self.serial);
log::debug!("{:?}",&self.serial);
let output_path:String = OUTPUT_FOLDER.to_owned() + &self.serial + ".txt";
if ! Path::new(&output_path).exists(){
log::debug!("Creating file {}",&output_path);
@ -64,29 +61,24 @@ impl Device{
log::trace!("{:?}",file_contents);
for line in file_lines {
if line.len() > 0{
//log::trace!("{:?}",line);
let section_and_data:Vec<&str> = line.split(SECTION_SEPARATOR).collect();
log::trace!("{:?}",line);
let section_and_data:Vec<&str> = line.split(": ").collect();
let section:&str = section_and_data[0];
let possible_value:Result<u64, std::num::ParseIntError> = section_and_data[1].trim().parse::<u64>();
match possible_value{
Ok(value) => {
//log::trace!("{:?} value: [{:?}]",section,value);
log::trace!("{:?} value: [{:?}]",section,value);
match section {
REBOOTS_SECTION => {
self.reboots = value;
//log::trace!("Reboots set to {:?}",self.reboots);
},
BP_SECTION => {
self.bps = value.clone();
//log::trace!("BPS set to {:?}",self.bps);
self.bps = value;
},
TEMP_SECTION => {
self.temp_offset = value;
//log::trace!("Temp offset set to {:?}",self.temp_offset);
self.temps = value;
},
_ => {
log::warn!("Invalid import value: [{:?}]. Please ensure that the output directory is clean.",section_and_data);
}
_ => ()
};
}
Err(_) => {
@ -113,11 +105,6 @@ impl Device{
usb_port.write_to_device(Command::Newline);
_ = usb_port.read_from_device(None);
initial_state = State::LoginPrompt;
},
Response::UBoot=>{
usb_port.write_to_device(Command::Boot);
while usb_port.read_from_device(None) != Response::LoginPrompt {}
initial_state = State::LoginPrompt;
},
//Response::Empty parsing here is potentially in bad faith
Response::Other | Response::Empty | Response::ShellPrompt | Response::FailedDebugMenu | Response::DebugInit |
@ -126,40 +113,26 @@ impl Device{
Response::BPOn | Response::BPOff | Response::TempCount(_) |
Response::DebugMenu=>{
usb_port.write_to_device(Command::Quit);
_ = usb_port.read_from_device(None);
usb_port.write_to_device(Command::Newline);
match usb_port.read_from_device(None){
Response::ShuttingDown | Response::Rebooting => {
Response::Rebooting => {
while usb_port.read_from_device(None) != Response::LoginPrompt {}
initial_state = State::LoginPrompt;
},
Response::ShellPrompt => {
initial_state = State::ShellPrompt;
},
Response::DebugMenu => {
usb_port.write_to_device(Command::Newline);
match usb_port.read_from_device(None) {
Response::DebugMenu | Response::ShellPrompt => {
initial_state = State::ShellPrompt;
},
_ => {
log::error!("Unknown state for TTY {:?}!!! Consult logs immediately.",usb_port);
log::debug!("Last known state: DebugMenu.");
log::debug!("Assumed but incorrect current state: successfully exited debug menu");
return Err("Failed TTY init. Unknown state, cannot trust.".to_string());
}
};
usb_port.write_to_device(Command::Shutdown);
while usb_port.read_from_device(None) != Response::LoginPrompt {}
initial_state = State::LoginPrompt;
},
_ => {
log::error!("Unknown state for TTY {:?}!!! Consult logs immediately.",usb_port);
log::debug!("Last known state: DebugMenu.");
log::debug!("Assumed but incorrect current state: attempted to exit debug menu");
return Err("Failed TTY init. Unknown state, cannot trust.".to_string());
}
};
},
//Serial response shouldn't exist, emptynewline is already filtered in main
Response::Serial(_) | Response::EmptyNewline => {
log::error!("Unknown state for TTY {:?}!!! Consult logs immediately.",usb_port);
log::debug!("How did I get here???");
return Err("Failed TTY init. Unknown state, cannot trust.".to_string());
},
};
@ -179,7 +152,6 @@ impl Device{
current_state: initial_state,
reboots: 0,
temps: 0,
temp_offset: 0,
init_temps: 0,
bps: 0
};
@ -218,18 +190,16 @@ impl Device{
Response::PreShellPrompt | Response::Empty | Response::ShuttingDown |
Response::DebugInit | Response::EmptyNewline | Response::Rebooting => {},
Response::PasswordPrompt => {self.usb_tty.write_to_device(Command::Newline);},
Response::FailedDebugMenu | Response::ShellPrompt => break,
Response::ShellPrompt => break,
_ => {
log::error!("Unexpected response from device {}!",self.serial);
log::debug!("brightness menu, catch-all, login loop, {}, {:?}",self.serial,self.usb_tty);
log::debug!("brightness menu, catch-all, first loop, {}, {:?}",self.serial,self.usb_tty);
log::error!("Unsure how to continue. Expect data from device {} to be erratic until next cycle.",self.serial);
//break;
break;
},
};
};
self.current_state = State::ShellPrompt;
},
State::ShellPrompt => {
//_ = self.usb_tty.read_from_device(None);
self.usb_tty.write_to_device(Command::DebugMenu);
loop {
match self.usb_tty.read_from_device(None) {
@ -243,13 +213,16 @@ impl Device{
Response::DebugMenu =>
break,
Response::FailedDebugMenu => {
while self.usb_tty.read_from_device(None) != Response::LoginPrompt {};
self.usb_tty.write_to_device(Command::Login);
while self.usb_tty.read_from_device(None) != Response::ShellPrompt {};
self.usb_tty.write_to_device(Command::DebugMenu);
},
_ => {
log::error!("Unexpected response from device {}!", self.serial);
log::debug!("brightness menu, catch-all, shell prompt loop, {}, {:?}",self.serial,self.usb_tty);
log::debug!("brightness menu, catch-all, second loop, {}, {:?}",self.serial,self.usb_tty);
log::error!("Unsure how to continue. Expect data from device {} to be erratic until next cycle.",self.serial);
//break;
break;
},
};
};
@ -288,18 +261,15 @@ impl Device{
Response::PreShellPrompt | Response::Empty | Response::ShuttingDown |
Response::DebugInit | Response::EmptyNewline | Response::Rebooting => {},
Response::PasswordPrompt => {self.usb_tty.write_to_device(Command::Newline);},
Response::FailedDebugMenu | Response::ShellPrompt => break,
Response::ShellPrompt => break,
_ => {
log::error!("Unexpected response from device {}!",self.serial);
log::debug!("lifecycle menu, catch-all, first loop, {}, {:?}",self.serial,self.usb_tty);
log::error!("Unsure how to continue. Expect data from device {} to be erratic until next cycle.",self.serial);
//break;
break;
},
};
};
self.current_state = State::ShellPrompt;
},
State::ShellPrompt => {
self.usb_tty.write_to_device(Command::DebugMenu);
loop {
let read_in = self.usb_tty.read_from_device(None);
@ -307,18 +277,23 @@ impl Device{
Response::PreShellPrompt | Response::Empty | Response::ShuttingDown |
Response::DebugInit | Response::EmptyNewline | Response::Rebooting => {},
Response::LoginPrompt => {
self.usb_tty.write_to_device(Command::Login);
while self.usb_tty.read_from_device(None) != Response::ShellPrompt {};
self.usb_tty.write_to_device(Command::DebugMenu);
},
Response::DebugMenu =>
break,
Response::FailedDebugMenu => {
while self.usb_tty.read_from_device(None) != Response::LoginPrompt {};
self.usb_tty.write_to_device(Command::Login);
while self.usb_tty.read_from_device(None) != Response::ShellPrompt {};
self.usb_tty.write_to_device(Command::DebugMenu);
},
_ => {
log::error!("Unexpected response from device {}! {:?}", self.serial, read_in);
log::debug!("lifecycle menu, catch-all, second loop, {}, {:?}",self.serial,self.usb_tty);
log::error!("Unsure how to continue. Expect data from device {} to be erratic until next cycle.",self.serial);
//break;
break;
},
};
};
@ -343,21 +318,21 @@ impl Device{
return false
}
}
log::trace!("Writing to file: {:?}",self.output_file);
if let Some(ref mut file_name) = self.output_file{
log::debug!("Writing to file!");
let mut output_data = REBOOTS_SECTION.to_string();
output_data.push_str(SECTION_SEPARATOR);
output_data.push_str(&self.reboots.to_string());
output_data.push_str("\n");
output_data.push_str(BP_SECTION);
output_data.push_str(SECTION_SEPARATOR);
output_data.push_str(&self.bps.to_string());
output_data.push_str("\n");
output_data.push_str(TEMP_SECTION);
output_data.push_str(SECTION_SEPARATOR);
let saved_temps = (self.temps - self.init_temps) + self.temp_offset;
log::trace!("Current temps: [{}]",self.temps);
log::trace!("Initial temps: [{}]",self.init_temps);
let saved_temps = self.temps - self.init_temps;
output_data.push_str(&saved_temps.to_string());
output_data.push_str("\n");
log::debug!("final data to write to '{:?}': [{:?}]",file_name,output_data);
let temp = file_name.write_all(output_data.as_bytes());
match temp{
Err(error) => {
@ -371,64 +346,41 @@ impl Device{
}
return true
}
pub fn auto_set_serial(&mut self) -> bool{
loop {
match self.current_state {
State::LoginPrompt => {
self.usb_tty.write_to_device(Command::Login);
while self.usb_tty.read_from_device(None) != Response::ShellPrompt {};
self.current_state = State::ShellPrompt;
},
State::Shutdown => {
while self.usb_tty.read_from_device(None) != Response::LoginPrompt{};
self.current_state = State::LoginPrompt;
},
State::DebugMenu | State::LifecycleMenu | State::BrightnessMenu => {
self.usb_tty.write_to_device(Command::Quit);
_ = self.usb_tty.read_from_device(None);
self.current_state = State::ShellPrompt;
},
State::ShellPrompt => {
self.usb_tty.write_to_device(Command::GetSerial);
loop{
let return_value = self.usb_tty.read_from_device(None);
match return_value{
Response::Serial(Some(contains_serial)) =>{
for line in contains_serial.split("\n").collect::<Vec<&str>>(){
if !line.contains(':') { continue; }
let (section,value) = line.split_once(':').unwrap();
if section.contains(SERIAL_HEADER){
self.serial = value.trim().replace("\"","");
}
}
log::info!("Serial found for device {}",self.serial);
break;
},
Response::DebugInit | Response::Empty | Response::EmptyNewline => { continue; }
_ => {
log::error!("Bad value: {:?}",return_value);
return false
},
pub fn set_serial(&mut self) -> &mut Self{
self.reboot();
self.usb_tty.write_to_device(Command::Login);
while self.usb_tty.read_from_device(None) != Response::ShellPrompt {}
self.usb_tty.write_to_device(Command::GetSerial);
loop{
let return_value = self.usb_tty.read_from_device(None);
match return_value{
Response::Serial(Some(contains_serial)) =>{
for line in contains_serial.split("\n").collect::<Vec<&str>>(){
if !line.contains(':') { continue; }
let (section,value) = line.split_once(':').unwrap();
if section.contains(SERIAL_HEADER){
self.serial = value.trim().replace("\"","");
}
}
self.usb_tty.write_to_device(Command::DebugMenu);
while self.usb_tty.read_from_device(None) != Response::DebugMenu {}
self.current_state = State::DebugMenu;
self.load_values();
self.save_values();
return true
log::info!("Serial found for device {}",self.serial);
break;
},
Response::DebugInit | Response::Empty | Response::EmptyNewline => { continue; }
_ => {
log::error!("Bad value: {:?}",return_value);
todo!();
},
}
}
}
pub fn manual_set_serial(&mut self, serial:&str) -> &mut Self{
self.serial = serial.to_string();
self.usb_tty.write_to_device(Command::DebugMenu);
while self.usb_tty.read_from_device(None) != Response::DebugMenu {}
self.current_state = State::DebugMenu;
self.reboot();
self.load_values();
self.save_values();
return self;
}
pub fn get_serial(&self) -> &str{
pub fn get_serial(&mut self) -> &str{
&self.serial
}
pub fn get_location(&mut self) -> String{
@ -565,22 +517,19 @@ impl Device{
}
pub fn reboot(&mut self) -> () {
self.usb_tty.write_to_device(Command::Quit);
self.usb_tty.write_to_device(Command::Reboot);
let mut successful_reboot:bool = false;
//let mut exited_menu:bool = false;
let mut exited_menu:bool = false;
loop{
match self.usb_tty.read_from_device(None){
Response::LoginPrompt => break,
Response::Rebooting => {
log::trace!("Successful reboot detected for device {}.",self.serial);
successful_reboot = true;
//This error message is turning out to be more false positive than anything
//else. Reboots can sometimes dump both reboot flag and shutdown flag at once.
//if !exited_menu { log::info!("Unusual reboot detected for device {}. Please check logs.",self.serial); }
if !exited_menu { log::info!("Unusual reboot detected for device {}. Please check logs.",self.serial); }
},
Response::ShuttingDown => {
log::trace!("Exiting debug menu on device {}.",self.serial);
//exited_menu = true;
exited_menu = true;
},
_ => {}
}
@ -615,7 +564,7 @@ impl Device{
log::trace!("Has bp ended on device {}? : {:?}",self.serial,bp_end);
if bp_start != bp_end {
self.bps +=1;
log::trace!("Increasing bp count for device {} to {}",self.serial,self.bps);
log::debug!("Increasing bp count for device {} to {}",self.serial,self.bps);
self.save_values();
}
}

256
src/main.rs
View file

@ -1,6 +1,6 @@
use seymour_life::{device::Device,
tty::{self,TTY,Response},
gpio_facade::GpioPins};
use seymour_life_rust::{device::Device,
tty::{self,TTY,Response},
gpio_facade::GpioPins};
use std::{io::{stdin,stdout,Write},
thread::{self, JoinHandle},
path::Path,
@ -11,22 +11,11 @@ use clap::Parser;
#[derive(Parser,Debug)]
#[command(author,version,about)]
struct Args{
/// Print all logs to screen, improves log verbosity. Sets iteration count to 50000
#[arg(short,long,action)]
debug:bool,
/// Force manually setting serial numbers
#[arg(short,long,action)]
manual:bool,
/// Set iteration count from command line. Overrides debug iteration count.
#[arg(short,long)]
iterations:Option<u64>
debug:bool
}
const VERSION:&str="2.3.3";
const DEBUG_ITERATION_COUNT:u64=50000;
const VERSION:&str="2.3.0";
fn int_input_filtering(prompt:Option<&str>) -> u64{
let internal_prompt = prompt.unwrap_or(">>>");
@ -58,19 +47,18 @@ fn input_filtering(prompt:Option<&str>) -> String{
log::debug!("{}:{}",internal_prompt,user_input);
return user_input;
}
//Path::new(&&str).is_dir() -> bool
fn main(){
let args = Args::parse();
setup_logs(&args.debug);
log::info!("Seymour Life Testing version: {}",VERSION);
log::trace!("Debug enabled!");
if args.debug{
log::debug!("Debug enabled!");
}
loop{
let mut iteration_count:u64 = 0;
if let Some(value) = args.iterations{
iteration_count = value;
}
else if args.debug {
iteration_count = DEBUG_ITERATION_COUNT;
if args.debug {
iteration_count = 10000;
}
else {
while iteration_count < 1{
@ -78,132 +66,98 @@ fn main(){
}
}
log::info!("Testing all available USB ports for connected devices. This may take several minutes, and devices may reboot several times.");
let gpio = &mut GpioPins::new();
let mut available_ttys:Vec<Box<Path>> = Vec::new();
for entry in glob::glob("/dev/serial/*").expect("Failed to read glob pattern"){
match entry{
Ok(real_path) =>{
match fs::read_dir::<&Path>(real_path.as_ref()){
Ok(possible_ttys) =>{
possible_ttys.into_iter().for_each(|tty| {
if let Ok(single_tty) = tty {
available_ttys.push(single_tty.path().into());
}
});
break;
}
Err(error) =>{
log::error!("Invalid permissions to /dev directory... did you run with sudo?");
log::error!("{}",error);
return;
}
}
}
Err(error) =>{
log::error!("{}",error);
}
}
}
if available_ttys.is_empty(){
for entry in glob::glob("/dev/ttyUSB*").expect("Unable to read glob"){
match entry{
Ok(possible_tty) => available_ttys.push(Path::new(&possible_tty).into()),
Err(error) => {
log::error!("Invalid permissions to /dev directory... did you run with sudo?");
log::error!("{}",error);
return;
}
};
}
}
if available_ttys.is_empty(){
log::error!("No serial devices detected! Please ensure all connections.");
return;
}
let mut possible_devices:Vec<Option<Device>> = Vec::new();
let mut tty_test_threads:Vec<JoinHandle<Option<Device>>> = Vec::new();
for possible_tty in available_ttys.into_iter(){
tty_test_threads.push(
thread::spawn(move ||{
let tty_name = possible_tty.to_string_lossy();
log::debug!("Testing port {}",&tty_name);
let possible_port = TTY::new(&tty_name);
match possible_port{
Some(mut port) =>{
port.write_to_device(tty::Command::Newline);
let response = port.read_from_device(Some(":"));
if response != Response::Empty{
log::debug!("{} is valid port!",tty_name);
let new_device = Device::new(port,Some(response));
match new_device{
Ok(mut device) => {
device.darken_screen();
if !args.manual {
device.auto_set_serial();
}
Some(device)
},
Err(_) => None
match std::fs::read_dir("/dev/serial/by-path"){
Ok(available_ttys)=>{
let mut possible_devices:Vec<Option<Device>> = Vec::new();
let mut tty_test_threads:Vec<JoinHandle<Option<Device>>> = Vec::new();
for possible_tty in available_ttys.into_iter(){
tty_test_threads.push(
thread::spawn(move ||{
let tty_ref = possible_tty.as_ref();
match tty_ref{
Ok(tty_real_ref)=>{
let tty_path = tty_real_ref.path();
let tty_name = tty_path.to_string_lossy();
log::info!("Testing port {}. This may take a moment...",&tty_name);
let possible_port = TTY::new(&tty_name);
match possible_port{
Some(mut port) =>{
port.write_to_device(tty::Command::Newline);
let response = port.read_from_device(Some(":"));
if response != Response::Empty{
log::debug!("{} is valid port!",tty_name);
let new_device = Device::new(port,Some(response));
match new_device{
Ok(mut device) => {
device.darken_screen();
device.set_serial();
Some(device)
},
Err(_) => None
}
}
else { None }
},
None=>{None}
}
},
Err(error)=>{
log::debug!("{}",error);
None
}
}
else { None }
},
None=>{None}
}));
}
for thread in tty_test_threads{
let output = thread.join().unwrap_or_else(|x|{log::trace!("{:?}",x); None});
possible_devices.push(output);
}
let mut devices:Vec<Device> = Vec::new();
for possible_device in possible_devices.into_iter(){
if let Some(device) = possible_device{
devices.push(device);
}
}));
}
for thread in tty_test_threads{
let output = thread.join().unwrap_or_else(|x|{log::trace!("{:?}",x); None});
possible_devices.push(output);
}
let mut serials_set:bool = true;
let mut devices:Vec<Device> = Vec::new();
for possible_device in possible_devices.into_iter(){
if let Some(device) = possible_device{
if device.get_serial().eq("uninitialised"){
serials_set = false;
}
devices.push(device);
}
}
log::info!("--------------------------------------");
log::info!("Number of devices detected: {}",devices.len());
log::info!("--------------------------------------\n\n");
log::info!("--------------------------------------");
log::info!("Number of devices detected: {}",devices.len());
log::info!("--------------------------------------\n\n");
log::info!("Setting up probe wells for all devices. This may take several minutes...");
for device in devices.iter_mut(){
if !serials_set || args.manual {
device.brighten_screen();
device.manual_set_serial(&input_filtering(Some("Enter the serial of the device with the bright screen: ")).to_string());
device.darken_screen();
}
log::info!("Checking probe well of device {}",device.get_serial());
log::debug!("Number of unassigned addresses: {}",gpio.get_unassigned_addresses().len());
if !find_gpio(device, gpio){
device.set_pin_address(21);
log::error!("Unable to find probe-well for device {}. Please ensure that the probe well is installed properly, and the calibration key is plugged in.",device.get_serial());
device.brighten_screen();
panic!();
}
}
let mut iteration_threads = Vec::new();
while let Some(mut device) = devices.pop(){
iteration_threads.push(thread::spawn(move||{
device.init_temp_count();
for i in 1..=iteration_count{
log::info!("Starting iteration {} of {} for device {}...",
i,iteration_count,device.get_serial());
device.test_cycle(None);
for device in devices.iter_mut(){
//device.brighten_screen();
//device.set_serial();
//device.darken_screen();
log::info!("Checking probe well of device {}",device.get_serial());
log::debug!("Number of unassigned addresses: {}",gpio.get_unassigned_addresses().len());
if !find_gpio(device, gpio){
device.set_pin_address(21);
log::error!("Unable to find probe-well for device {}. Please ensure that the probe well is installed properly, and the calibration key is plugged in.",device.get_serial());
device.brighten_screen();
return;
}
}
}));
}
for thread in iteration_threads{
thread.join().unwrap();
let mut iteration_threads = Vec::new();
while let Some(mut device) = devices.pop(){
iteration_threads.push(thread::spawn(move||{
device.init_temp_count();
for i in 1..=iteration_count{
log::info!("Starting iteration {} of {} for device {}...",
i,iteration_count,device.get_serial());
device.test_cycle(None);
}
}));
}
for thread in iteration_threads{
thread.join().unwrap();
}
}
Err(_)=>{
log::error!("Invalid serial location! Please make sure that /dev/serial/by-path exists.");
break;
}
}
if input_filtering(Some("Would you like to run the tests again? (y/N): ")).to_string().contains("y") {}
else { break; }
@ -241,18 +195,14 @@ pub fn setup_logs(debug:&bool){
message
))
})
.chain({
let mut file_logger = fern::Dispatch::new();
let date_format = chrono_now.format("%Y-%m-%d_%H.%M").to_string();
let local_log_file = fern::log_file(format!("logs/{}.log",date_format)).unwrap();
if *debug{
file_logger = file_logger.level(log::LevelFilter::Trace);
}
else {
file_logger = file_logger.level(log::LevelFilter::Debug);
}
file_logger.chain(local_log_file)
})
.chain(
fern::Dispatch::new()
.level(log::LevelFilter::Trace)
.chain(fern::log_file(
format!("logs/{0}.log",
chrono_now.format("%Y-%m-%d_%H.%M").to_string()
)).unwrap()),
)
.chain({
let mut stdout_logger = fern::Dispatch::new();
if *debug {

64
src/tty.rs
View file

@ -7,7 +7,7 @@ use serialport::SerialPort;
use derivative::Derivative;
const BAUD_RATE:u32 = 115200;
const SERIAL_TIMEOUT: std::time::Duration = Duration::from_millis(500);
const SERIAL_READ_TIMEOUT: std::time::Duration = Duration::from_millis(500);
#[derive(Eq,Derivative,Debug)]
@ -26,9 +26,8 @@ pub enum Command{
Login,
DebugMenu,
Newline,
Reboot,
Shutdown,
GetSerial,
Boot,
}
#[derive(Clone,Eq,Derivative,Debug)]
@ -50,7 +49,6 @@ pub enum Response{
EmptyNewline,
DebugInit,
Serial(Option<String>),
UBoot,
}
@ -66,39 +64,31 @@ const COMMAND_MAP:Lazy<HashMap<Command,&str>> = Lazy::new(||HashMap::from([
(Command::UpMenuLevel, "\\"),
(Command::Login,"root\n"),
(Command::RedrawMenu,"?"),
(Command::DebugMenu,"python3 -m debugmenu\n"),
(Command::DebugMenu," python3 -m debugmenu; shutdown -r now\n"),
(Command::Newline,"\n"),
(Command::Reboot,"shutdown -r now\n"),
(Command::Boot,"boot\n"),
(Command::Shutdown,"shutdown -r now\n"),
(Command::GetSerial,"echo 'y1q' | python3 -m debugmenu\n"),
]));
const COMMAND_RESPONSES: [&str;3] = [
"python3 -m debugmenu",
"q",
"root",
];
const RESPONSES:[(&str,Response);14] = [
("uboot=>",Response::UBoot),
const RESPONSES:[(&str,Response);13] = [
("Last login:",Response::PreShellPrompt),
("reboot: Restarting",Response::Rebooting),
("command not found",Response::FailedDebugMenu),
("login:",Response::LoginPrompt),
("Password:",Response::PasswordPrompt),
("DtCtrlCfgDeviceSerialNum",Response::Serial(None)),
("root@",Response::ShellPrompt),
("EXIT Debug menu",Response::ShuttingDown),
("Check NIBP In Progress: True",Response::BPOn),
("Check NIBP In Progress: False",Response::BPOff),
("SureTemp Probe Pulls:",Response::TempCount(None)),
(">",Response::DebugMenu),
("Loading App-Framework",Response::DebugInit),
("root@",Response::ShellPrompt),
("EXIT Debug menu",Response::ShuttingDown),
];
pub struct TTY{
tty: Box<dyn SerialPort>,
last: Command,
failed_read_count: u8
}
impl std::fmt::Debug for TTY{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result{
@ -122,24 +112,23 @@ impl std::fmt::Debug for TTY{
impl TTY{
pub fn new(serial_location:&str) -> Option<Self>{
let possible_tty = serialport::new(serial_location,BAUD_RATE).timeout(SERIAL_TIMEOUT).open();
let possible_tty = serialport::new(serial_location,BAUD_RATE).timeout(SERIAL_READ_TIMEOUT).open();
if let Ok(tty) = possible_tty{
Some(TTY{tty,last:Command::Quit})
Some(TTY {
tty,
failed_read_count: 0
})
} else{
None
}
}
pub fn write_to_device(&mut self,command:Command) -> bool {
if command == self.last{
log::trace!("retry send {}",self.tty.name().unwrap_or("unknown".to_string()));
}else{
log::debug!("writing {:?} to tty {}...", command, self.tty.name().unwrap_or("unknown".to_string()));
};
log::trace!("writing {:?} to tty {}...", command, self.tty.name().unwrap_or("unknown".to_string()));
let output = self.tty.write_all(COMMAND_MAP.get(&command).unwrap().as_bytes()).is_ok();
self.last = command;
_ = self.tty.flush();
std::thread::sleep(SERIAL_TIMEOUT);
if command == Command::Login { std::thread::sleep(std::time::Duration::from_secs(2)); }
std::thread::sleep(std::time::Duration::from_millis(500));
return output;
}
@ -151,12 +140,7 @@ impl TTY{
let read_line:String = String::from_utf8_lossy(read_buffer.as_slice()).to_string();
if read_line.eq("\r\n") {
return Response::EmptyNewline;
}
for command in COMMAND_RESPONSES{
if read_line.trim().eq(command.trim()){
return self.read_from_device(None);
}
};
}
for (string,enum_value) in RESPONSES{
if read_line.contains(string){
if(enum_value == Response::BPOn) || (enum_value == Response::BPOff) {
@ -166,6 +150,7 @@ impl TTY{
else{
log::trace!("Successful read of {:?} from tty {}, which matches pattern {:?}",read_line,self.tty.name().unwrap_or("unknown shell".to_string()),enum_value);
};
self.failed_read_count = 0;
if enum_value == Response::TempCount(None){
let mut lines = read_line.lines();
while let Some(single_line) = lines.next(){
@ -180,6 +165,7 @@ impl TTY{
return Response::TempCount(None)
},
Ok(parsed_temp_count) => {
//log::trace!("Header: {}",header);
log::trace!("parsed temp count for device {}: {}",self.tty.name().unwrap_or("unknown shell".to_string()),temp_count);
return Response::TempCount(Some(parsed_temp_count))
}
@ -206,7 +192,17 @@ impl TTY{
return Response::Other;
}
else {
log::trace!("Read an empty string from device {:?}. Possible read error.", self);
log::debug!("Read an empty string from device {:?}. Possible read error.", self);
//Due to a linux kernel power-saving setting that is overly complicated to fix,
//Serial connections will drop for a moment before re-opening, at seemingly-random
//intervals. The below is an attempt to catch and recover from this behaviour.
self.failed_read_count += 1;
if self.failed_read_count >= 15{
self.failed_read_count = 0;
let tty_location = self.tty.name().expect("Unable to read tty name!");
self.tty = serialport::new(tty_location,BAUD_RATE).timeout(SERIAL_READ_TIMEOUT).open().expect("Unable to open serial connection!");
return self.read_from_device(_break_char);
}
return Response::Empty;
};
}