// Example using a constant that is hardcoded
let mut iteration_count = 0;
while iteration_count < 5 {
  iteration_count += 1;
}

// Example using a constant from configurations
let mut iteration_count = 0;
while iteration_count < MAX_ITERATION_COUNT {
  iteration_count += 1;
}

{
  "number_of_messages": "5"
}

46 collapsed lines
########################################################################################
# This Project/Package Metadata
# Reference: https://doc.rust-lang.org/cargo/reference/workspaces.html#the-package-table
[package]
authors = ["YOUR OWN NAME"]
edition = "2024"            # Rust code edition: https://doc.rust-lang.org/edition-guide/rust-2021/index.html
license = "MIT"
name = "big-button"
version = "0.1.0"           # This project version
readme = "README.md"

########################################################################################
# Rust program dependencies
# Reference: https://doc.rust-lang.org/cargo/guide/dependencies.html
[dependencies]
cortex-m = "0.7"    # Core support for ARM Cortex-M microcontrollers (M33 for RP2350)
cortex-m-rt = "0.7" # Startup code and minimal runtime for Cortex-M
panic-halt = "1.0"  # Basic panic handler that halts on panic
defmt = "1.0"       # Deferred formatting for embedded logging
defmt-rtt = "1.0"   # RTT (Real-Time Transfer) transport for defmt

# Debug probe panic handler with defmt support
panic-probe = { version = "1.0", features = ["print-defmt"] }

# Embassy Rust embedded framework dependencies
embassy-embedded-hal = { version = "0.4", features = ["defmt"] }
embassy-executor = { version = "0.8", features = [
  "arch-cortex-m",
  "executor-thread",
  "executor-interrupt",
  "defmt",
] }
embassy-rp = { version = "0.7", features = [
  "critical-section-impl",
  "time-driver",
  "defmt",
  "unstable-pac",
  "rp235xb",
  "binary-info",
] }
embassy-time = { version = "0.4", features = [
  "defmt",
  "defmt-timestamp-uptime",
] }
embassy-sync = { version = "0.7", features = ["defmt"] }
embassy-futures = { version = "0.1", features = ["defmt"] }

########################################################################################
# Dependencies required during build process (ie. build.rs)
# Reference: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#build-dependencies
[build-dependencies]
serde = "1.0"
serde_json = "1.0"

13 collapsed lines
########################################################################################
# Compiler profile for when running cargo run --release
# Reference: https://doc.rust-lang.org/cargo/reference/profiles.html
[profile.release]
codegen-units = 1        # Number of codegen units - 1
debug = 2                # Debug info included in compiled binary - 0: none, 1: line numbers, 2: full
debug-assertions = false # Debug assertion - disabled
incremental = false      # Incremental compilation - disabled
lto = 'fat'              # Link-time optimization - fat: Perform optimization across all crates
opt-level = "s"          # Optimize compile - s: optimize for binary size
overflow-checks = true   # Integer overflow checks - disabled
panic = "abort"          # Panic strategy - abort: terminate process upon panic
rpath = false            # Relative path - disabled

//! This build script runs during code compilation
//! Runs on host computer, where `std` Rust tools are available here
//! Reference: https://doc.rust-lang.org/cargo/reference/build-scripts.html

use std::env;
use std::fs;
use std::io::Write;
use std::io;
use std::path::Path;
use std::path::PathBuf;

// ... continued existing code ...

// ^^^ previous existing code ^^^

/// Loads configuration values from configs.json and generates a configs.rs file
/// with Rust constants for use in the embedded application
///
/// # Arguments
/// * `out_dir` - The target build directory path
/// * `config_keys` - Array of configuration keys to extract from configs.json
fn load_configs(out_dir: &str, config_keys: [&str; 1]) -> io::Result<()> {
    println!("[BUILD TASK] LOADING PROGRAM CONFIGURATIONS");
    println!("Configuration output directory: {out_dir:?}");

    println!("Creating new blank 'configs.rs' file within the output directory ...");
    let dest_path = Path::new(&out_dir).join("configs.rs");
    let mut f = fs::File::create(dest_path)?;

    let project_root_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
    println!("Project root directory: {project_root_dir:?}");

    let configs_path = Path::new(&project_root_dir).join("configs.json");
    println!("Looking for configs file at filepath: {configs_path:?}");
    if !configs_path.exists() {
        let error_message = "Failed to find 'configs.json' in the project root directory.
                             Please see instructions within README.md on creating this file";
        return Err(io::Error::new(io::ErrorKind::NotFound, error_message));
    };

    println!("Reading raw text from 'configs.json' ...");
    let contents_raw_string = fs::read_to_string(configs_path)?;

    println!("Parsing 'configs.json' as a JSON file ...");
    let config_values: serde_json::Value = serde_json::from_str(&contents_raw_string)?;
    for config_key in config_keys.iter() {
        if !config_values.as_object().unwrap().contains_key(*config_key) {
            let error_message = format!("Key '{}' not found in 'configs.json' file", config_key);
            return Err(io::Error::new(io::ErrorKind::InvalidData, error_message));
        }
    }

    println!("Successfully loaded all program configurations from 'configs.json'!");

    Ok(())
}

// ^^^ previous existing code ^^^

/// Loads configuration values from configs.json and generates a configs.rs file
/// with Rust constants for use in the embedded application
///
/// # Arguments
/// * `out_dir` - The target build directory path
/// * `config_keys` - Array of configuration keys to extract from configs.json
fn load_configs(out_dir: &str, config_keys: [&str; 1]) -> io::Result<()> {

    // ... previous existing code ...

    println!("Writing from 'configs.json' to 'configs.rs' as UPPERCASE constants ...");
    for config_key in config_keys.iter() {
        print!("  - {}", config_key.to_uppercase());
        writeln!(
            f,
            "pub const {}: &str = {:?};",
            config_key.to_uppercase(),
            config_values[config_key].as_str().unwrap()
        )?;
        println!(" ... value loaded!")
    }

    println!("Successfully loaded all program configurations from 'configs.json'!");

    Ok(())
}

12 collapsed lines
//! This build script runs during code compilation
//! Runs on host computer, where `std` Rust tools are available here
//! Reference: https://doc.rust-lang.org/cargo/reference/build-scripts.html

use std::env;
use std::fs;
use std::io;
use std::io::Write;
use std::path::Path;
use std::path::PathBuf;

/// Main build script entry point
fn main() {
    // Put `memory.x` in our output directory
    let out_dir = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
    fs::File::create(out_dir.join("memory.x"))
        .unwrap()
        .write_all(include_bytes!("memory.x"))
        .unwrap();

    // Ensure 'memory.x' is on the linker search path
    println!("cargo:rustc-link-search={}", out_dir.display());

    // Re-run for any changes to `memory.x` and `build.rs`
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rerun-if-changed=memory.x");

    // Load configurations from local 'configs.json' file
    let configs_keys = ["number_of_messages"];
    load_configs(out_dir.to_str().unwrap(), configs_keys)
        .unwrap_or_else(|error| panic!("[ERROR] {error:?}"))
}

// ... continued existing code ...

13 collapsed lines
#![no_std]
#![no_main]
#![allow(unused_variables)] // only used for development
#![allow(unused_imports)] // only used for development

use defmt::*;
use defmt_rtt as _;
use panic_probe as _;

use embassy_executor::Spawner;
use embassy_rp::config::Config;
use embassy_rp::gpio;
use embassy_time::Timer;

// Loading configurations
// Note: This comes from the 'configs.rs' file created in 'build.rs' from 'configs.json'
// Note: All loaded configurations will be UPPERCASE string slice (&str) constants
include!(concat!(env!("OUT_DIR"), "/configs.rs"));

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    // Initialize system with proper clock configuration
    let config = Config::default();
    let _peripherals = embassy_rp::init(config);

    // Parse and define a configuration value
    let number_of_messages = NUMBER_OF_MESSAGES.parse::<u8>().unwrap();

    // ... previous existing code ...
}

// ^^^ previously existing code ^^^

#[embassy_executor::main]
async fn main(spawner: Spawner) {

    // ... previously existing code ...

    // Parse and define a configuration value
    let number_of_messages = NUMBER_OF_MESSAGES.parse::<u8>().unwrap();

    info!("Number of Messages: {}", number_of_messages);

    for index in 1..=number_of_messages {
        info!("Hello there - {}", index);
        Timer::after_secs(1).await;
    }

    // Start an infinite loop
    loop {
        Timer::after_secs(5).await;
    }
}

# big-button

Just some interesting embedded Rust tutorial series I found floating around
the internet that I wanted to try.

Run me with `cargo run --release`

### Configurations

This project contains a `configs.json` file that contains various
configuration values for this program. The program will load these
values during the build process.

Currently the following configurations are supported:

```json
{
  "number_of_messages": "5"
}