Takeru dev

.github/workflows/build-tof-software.yml

@@ -0,0 +1,113 @@
+name: Build GAPS Time-of-Flight Software
+
+on:
+  push:
+    branches:
+      - main
+      - takeru-dev
+  pull_request:
+
+env:
+  SELECTED_BIN_FILES: "rat_control.rs rat_init.rs rat_reset.rs rat_tui.rs"
+  RUST_TARGET: armv7-unknown-linux-musleabi
+  CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABI_RUSTFLAGS: -C relocation-model=dynamic-no-pic -C target-feature=+crt-static
+
+jobs:
+  build-tof-software:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Get version from Cargo.toml
+        id: get_version
+        shell: bash
+        run: |
+          VERSION=$(grep '^version' Cargo.toml | head -1 | sed -E 's/version = "(.*)"/\1/')
+          VERSION_SAFE="${VERSION//./_}"
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+          echo "VERSION_SAFE=$VERSION_SAFE" >> $GITHUB_ENV
+          echo "VERSION=$VERSION"
+          echo "VERSION_SAFE=$VERSION_SAFE"
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ env.RUST_TARGET }}
+
+      - name: Install cross
+        run: cargo install cross --locked
+
+      - name: Build selected src/bin files with cross
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if [ -z "${SELECTED_BIN_FILES:-}" ]; then
+            echo "No SELECTED_BIN_FILES specified; nothing to build."
+            exit 0
+          fi
+
+          echo "Selected src/bin files: ${SELECTED_BIN_FILES}"
+
+          for relfile in ${SELECTED_BIN_FILES}; do
+            src_path="src/bin/${relfile}"
+
+            if [ ! -f "$src_path" ]; then
+              echo "ERROR: File '$src_path' not found."
+              exit 1
+            fi
+
+            bin="$(basename "$relfile" .rs)"
+            bin_name="${bin//_/-}"
+            echo "=== Building for source: $src_path (bin name: $bin_name) ==="
+            cross build --release --target "$RUST_TARGET" --bin "$bin_name"
+            echo "Successfully built bin '$bin_name'"
+          done
+
+      - name: Collect built binaries into artifacts directory
+        shell: bash
+        run: |
+          OUTDIR="tof-software_v${VERSION_SAFE}"
+          mkdir -p "$OUTDIR"
+
+          find "target/$RUST_TARGET/release" \
+            -maxdepth 1 \
+            -type f \
+            -executable \
+            -exec cp {} "$OUTDIR/" \;
+
+          echo "Placed artifacts in: $OUTDIR"
+
+      - name: Install zip
+        run: sudo apt-get update && sudo apt-get install -y zip
+
+      - name: Create ZIP and SHA-256 checksums
+        run: |
+          OUTDIR="tof-software_v${VERSION_SAFE}"
+          ZIPFILE="${OUTDIR}.zip"
+          SHA_FILE="${OUTDIR}_SHA256SUMS.txt"
+
+          # zip archive
+          zip -r "$ZIPFILE" "$OUTDIR"
+
+          # SHA-256 of binaries
+          sha256sum "$OUTDIR"/* > "$SHA_FILE"
+
+          # SHA-256 of the zip file
+          sha256sum "$ZIPFILE" >> "$SHA_FILE"
+
+          echo "Created:"
+          echo " - $ZIPFILE"
+          echo " - $SHA_FILE"
+
+      - name: Upload binary artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: tof-software_v${{ env.VERSION_SAFE }}
+          path: |
+            tof-software_v${{ env.VERSION_SAFE }}.zip
+            tof-software_v${{ env.VERSION_SAFE }}_SHA256SUMS.txt
+
+

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tof-control"
-version = "1.0.4"
+version = "1.0.5"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/rb_control/rb_info.rs

@@ -10,64 +10,39 @@ use crate::rb_control::rb_mode;
 
 impl RBInfo {
     pub fn new() -> Self {
-
-        match Self::read_all_info() {
-            Ok(rb_info) => {
-                rb_info
-            }
-            Err(_) => {
-                Self {
-                    board_id: u8::MAX,
-                    sub_board: u8::MAX,
-                    lol: u8::MAX,
-                    lol_stable: u8::MAX,
-                    trig_rate: u16::MAX,
-                    fw_version: "0.0.0".to_string(),
-                    fw_hash: "XXXXX".to_string(),
-                    uptime: u32::MAX,
-                    sd_usage: u8::MAX,
-                    input_mode: "Input Mode Error".to_string(),
-                    rat_num: u8::MAX,
-                    rat_pos: u8::MAX,
-                    rb_pos: u8::MAX,
-                }
-            }
-        }
-
+        Self::read_all_info()
     }
-    pub fn read_all_info() -> Result<RBInfo, RBError> {
-        let board_id = Self::read_board_id()?;
-        let sub_board = Self::read_sub_board()?;
-        let lol = Self::read_lol()?;
-        let lol_stable = Self::read_lol_stable()?;
-        let trig_rate = Self::read_trig_rate()?;
+    pub fn read_all_info() -> RBInfo {
+        let board_id = Self::read_board_id().unwrap_or(u8::MAX);
+        let sub_board = Self::read_sub_board().unwrap_or(u8::MAX);
+        let lol = Self::read_lol().unwrap_or(u8::MAX);
+        let lol_stable = Self::read_lol_stable().unwrap_or(u8::MAX);
+        let trig_rate = Self::read_trig_rate().unwrap_or(u16::MAX);
         // Additional Info
-        let fw_version = Self::read_fw_version()?;
-        let fw_hash = Self::read_fw_hash()?;
+        let fw_version = Self::read_fw_version().unwrap_or("0.0.0".to_string());
+        let fw_hash = Self::read_fw_hash().unwrap_or("XXXXX".to_string());
         let uptime = Self::read_uptime();
         let sd_usage = Self::read_sd_usage();
-        let input_mode = Self::read_input_mode()?;
-        let rat_num = Self::read_rat_num()?;
-        let rat_pos = Self::read_rat_pos()?;
-        let rb_pos = Self::read_rb_pos()?;
-
-        Ok(
-            RBInfo {
-                board_id,
-                sub_board,
-                lol,
-                lol_stable,
-                trig_rate,
-                fw_version,
-                fw_hash,
-                uptime,
-                sd_usage,
-                input_mode,
-                rat_num,
-                rat_pos,
-                rb_pos,
-            }
-        )
+        let input_mode = Self::read_input_mode().unwrap_or("Input Mode Error".to_string());
+        let rat_num = Self::read_rat_num().unwrap_or(u8::MAX);
+        let rat_pos = Self::read_rat_pos().unwrap_or(u8::MAX);
+        let rb_pos = Self::read_rb_pos().unwrap_or(u8::MAX);
+
+        RBInfo {
+            board_id,
+            sub_board,
+            lol,
+            lol_stable,
+            trig_rate,
+            fw_version,
+            fw_hash,
+            uptime,
+            sd_usage,
+            input_mode,
+            rat_num,
+            rat_pos,
+            rb_pos,
+        }
     }
     pub fn read_board_id() -> Result<u8, RBError> {
         let mut board_id = read_control_reg(BOARD_ID)? as u8;