# 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`

# Generated by Cargo - will have compiled files and executables
debug/
target/
vendor/

# Removing Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock

# These are backup files generated by rustfmt
**/*.rs.bk

# MSVC Windows builds of rustc generate these, which store debugging information
*.pdb

# General Items
.DS_Store
Thumbs.db
*.log
*.tmp
*.swp
*.env
*.bak

# IDE Specific Configurations
.idea/
.vscode/
*.sublime-project
*.sublime-workspace
.project
Session.vim
.Session.vim

[toolchain]

# Specifies using the nightly version of Rust, which has the latest experimental features
channel = "nightly"

# Lists the Rust components to include in the toolchain
components = ["rust-src", "rust-std", "rustc-dev", "cargo", "rustfmt", "clippy"]

# Defines the cross-compilation target for bare-metal ARM Cortex-M33 (ARMv8-M) devices
# Format: <ARCHITECTURE>-<PLATFORM_VENDOR>-<OPERATING_SYSTEM>-<APP_BINARY_INTERFACE>
targets = ["thumbv8m.main-none-eabihf"] # "hf" indicates floating-point support

# Reference: https://doc.rust-lang.org/cargo/reference/config.html

##############################################################################
# Build and Compiler Settings
# Reference: https://doc.rust-lang.org/cargo/reference/config.html#build
[build]
4 collapsed lines
target = "thumbv8m.main-none-eabihf" # Chip: Cortex-M33 (ARMv8-M) (RP2350)
rustc = "rustc"                      # Rust Compiler
rustdoc = "rustdoc"                  # Rust Documentation Generator
jobs = 1                             # Number of parallel jobs to run

##############################################################################
# Run Specification for Spcific Target Platform
# Reference: https://doc.rust-lang.org/cargo/reference/config.html#target
[target.thumbv8m.main-none-eabihf]
9 collapsed lines
runner = [
  "probe-rs",
  "run",
  "--chip=RP235x",
  "--log-format",
  "[{t}] {[{L}]%dimmed%bold} {{f:dimmed}:{l:dimmed}%30}: {s}",
]
# Custom flags for compiler for this target
rustflags = ["-C", "link-args=-Tlink.x -Tdefmt.x", "-C", "no-vectorize-loops"]

##############################################################################
# Environmental Variables
# Reference: https://doc.rust-lang.org/cargo/reference/config.html#env
[env]
2 collapsed lines
# Logger Formatting: https://defmt.ferrous-systems.com/custom-log-output
DEFMT_LOG = { value = "debug", force = true }

########################################################################################
# This Project/Package Metadata
# Reference: https://doc.rust-lang.org/cargo/reference/workspaces.html#the-package-table
[package]
6 collapsed lines
authors = ["YOUR OWN NAME"] # HEY YOU! UPDATE ME!
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]
31 collapsed lines
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.5", features = ["defmt"] }
embassy-executor = { version = "0.9", features = [
  "arch-cortex-m",
  "executor-thread",
  "executor-interrupt",
  "defmt",
] }
embassy-rp = { version = "0.8", features = [
  "critical-section-impl",
  "time-driver",
  "defmt",
  "unstable-pac",
  "rp235xb",
  "binary-info",
] }
embassy-time = { version = "0.5", features = [
  "defmt",
  "defmt-timestamp-uptime",
] }
embassy-sync = { version = "0.7", features = ["defmt"] }
embassy-futures = { version = "0.1", features = ["defmt"] }

########################################################################################
# Compiler profile for when running cargo run --release
# Reference: https://doc.rust-lang.org/cargo/reference/profiles.html
[profile.release]
9 collapsed lines
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 - enabled
panic = "abort"          # Panic strategy - abort: terminate process upon panic
rpath = false            # Relative path - disabled

/* memory.x - Tell linker how much memory is available and where it is */
/* Note that these values are specific to our microcontroller */
/* Source (Thank you!): https://github.com/embassy-rs/embassy/blob/main/examples/rp/memory.x */

MEMORY {
20 collapsed lines
    /*
     * The RP2350 has either external or internal flash.
     *
     * 2 MiB is a safe default here, although a Pico 2 has 4 MiB.
     */
    FLASH : ORIGIN = 0x10000000, LENGTH = 2048K
    /*
     * RAM consists of 8 banks, SRAM0-SRAM7, with a striped mapping.
     * This is usually good for performance, as it distributes load on
     * those banks evenly.
     */
    RAM : ORIGIN = 0x20000000, LENGTH = 512K
    /*
     * RAM banks 8 and 9 use a direct mapping. They can be used to have
     * memory areas dedicated for some specific job, improving predictability
     * of access times.
     * Example: Separate stacks for core0 and core1.
     */
    SRAM8 : ORIGIN = 0x20080000, LENGTH = 4K
    SRAM9 : ORIGIN = 0x20081000, LENGTH = 4K
}

SECTIONS {
12 collapsed lines
    /* ### Boot ROM info
     *
     * Goes after .vector_table, to keep it in the first 4K of flash
     * where the Boot ROM (and picotool) can find it
     */
    .start_block : ALIGN(4)
    {
        __start_block_addr = .;
        KEEP(*(.start_block));
        KEEP(*(.boot_info));
    } > FLASH

} INSERT AFTER .vector_table;

/* move .text to start /after/ the boot info */
_stext = ADDR(.start_block) + SIZEOF(.start_block);

SECTIONS {
16 collapsed lines
    /* ### Picotool 'Binary Info' Entries
     *
     * Picotool looks through this block (as we have pointers to it in our
     * header) to find interesting information.
     */
    .bi_entries : ALIGN(4)
    {
        /* We put this in the header */
        __bi_entries_start = .;
        /* Here are the entries */
        KEEP(*(.bi_entries));
        /* Keep this block a nice round size */
        . = ALIGN(4);
        /* We put this in the header */
        __bi_entries_end = .;
    } > FLASH
} INSERT AFTER .text;

SECTIONS {
10 collapsed lines
    /* ### Boot ROM extra info
     *
     * Goes after everything in our program, so it can contain a signature.
     */
    .end_block : ALIGN(4)
    {
        __end_block_addr = .;
        KEEP(*(.end_block));
    } > FLASH

} INSERT AFTER .uninit;

PROVIDE(start_to_end = __end_block_addr - __start_block_addr);
PROVIDE(end_to_start = __start_block_addr - __end_block_addr);

//! This build script runs during code complilation
//! Runs on host computer, where `std` Rust tools are available here

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

fn main() {
    // Put `memory.x` in our output directory and ensure it's on the linker search path.
    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
    File::create(out.join("memory.x"))
        .unwrap()
        .write_all(include_bytes!("memory.x"))
        .unwrap();
    println!("cargo:rustc-link-search={}", out.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");
}

#![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;

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

    // Start an infinite loop
    loop {
        info!("Hello World!");
        Timer::after_secs(1).await;

        info!("Goodbye World!");
        Timer::after_secs(1).await;
    }
}