cargo-forge 0.1.5

An interactive Rust project generator with templates and common features
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

#![no_std]
#![no_main]

use cortex_m;
use cortex_m_rt::entry;
{% for feature in features %}
{% if feature == "panic-halt" %}use panic_halt as _;{% endif %}
{% if feature == "panic-rtt" %}use panic_rtt_target as _;{% endif %}
{% if feature == "rtt" %}use rtt_target::{rprintln, rtt_init_print};{% endif %}
{% if feature == "semihosting" %}use cortex_m_semihosting::hprintln;{% endif %}
{% endfor %}

// HAL imports - adjust based on your target microcontroller
{% for feature in features %}
{% if feature == "stm32f4" %}
use stm32f4xx_hal::{
    gpio::GpioExt,
    pac,
    prelude::*,
    timer::DelayMs,
};
{% endif %}
{% if feature == "stm32f1" %}
use stm32f1xx_hal::{
    gpio::GpioExt,
    pac,
    prelude::*,
    timer::DelayMs,
};
{% endif %}
{% if feature == "rp2040" %}
use rp_pico::{
    entry,
    hal::{
        clocks::{init_clocks_and_plls, Clock},
        pac,
        sio::Sio,
        watchdog::Watchdog,
        Timer,
    },
    XOSC_CRYSTAL_FREQ,
};
{% endif %}
{% endfor %}

#[entry]
fn main() -> ! {
    {% if "rtt" in features %}
    rtt_init_print!();
    rprintln!("{{ project_name }} starting up...");
    {% endif %}
    
    {% if "semihosting" in features %}
    hprintln!("{{ project_name }} starting up...").unwrap();
    {% endif %}

    // Initialize the hardware
    let mut peripherals = pac::Peripherals::take().unwrap();
    let core_peripherals = cortex_m::Peripherals::take().unwrap();
    
    {% if "stm32f4" in features %}
    // Configure the system clock
    let rcc = peripherals.RCC.constrain();
    let clocks = rcc.cfgr.freeze();
    
    // Configure GPIO
    let gpioa = peripherals.GPIOA.split();
    let mut led = gpioa.pa5.into_push_pull_output(); // Built-in LED on many F4 boards
    
    // Configure timer for delays
    let mut delay = core_peripherals.SYST.delay(&clocks);
    {% endif %}
    
    {% if "stm32f1" in features %}
    // Configure the system clock  
    let mut rcc = peripherals.RCC.constrain();
    let mut flash = peripherals.FLASH.constrain();
    let clocks = rcc.cfgr.freeze(&mut flash.acr);
    
    // Configure GPIO
    let mut gpioc = peripherals.GPIOC.split(&mut rcc.apb2);
    let mut led = gpioc.pc13.into_push_pull_output(&mut gpioc.crh); // Built-in LED on Blue Pill
    
    // Configure timer for delays
    let mut delay = core_peripherals.SYST.delay(&clocks);
    {% endif %}
    
    {% if "rp2040" in features %}
    // Initialize clocks
    let mut watchdog = Watchdog::new(peripherals.WATCHDOG);
    let clocks = init_clocks_and_plls(
        XOSC_CRYSTAL_FREQ,
        peripherals.XOSC,
        peripherals.CLOCKS,
        peripherals.PLL_SYS,
        peripherals.PLL_USB,
        &mut peripherals.RESETS,
        &mut watchdog,
    )
    .ok()
    .unwrap();
    
    // Initialize SIO
    let sio = Sio::new(peripherals.SIO);
    let pins = rp_pico::Pins::new(
        peripherals.IO_BANK0,
        peripherals.PADS_BANK0,
        sio.gpio_bank0,
        &mut peripherals.RESETS,
    );
    
    // Configure built-in LED
    let mut led = pins.led.into_push_pull_output();
    
    // Configure timer
    let timer = Timer::new(peripherals.TIMER, &mut peripherals.RESETS);
    let mut delay = timer.count_down();
    {% endif %}

    {% if "rtt" in features %}
    rprintln!("Hardware initialized successfully!");
    {% endif %}
    
    {% if "semihosting" in features %}
    hprintln!("Hardware initialized successfully!").unwrap();
    {% endif %}

    // Main application loop
    loop {
        {% if "stm32f4" in features or "stm32f1" in features %}
        led.set_high();
        delay.delay_ms(500u16);
        led.set_low();
        delay.delay_ms(500u16);
        {% endif %}
        
        {% if "rp2040" in features %}
        led.set_high().unwrap();
        delay.start(500.millis());
        let _ = nb::block!(delay.wait());
        led.set_low().unwrap();
        delay.start(500.millis());
        let _ = nb::block!(delay.wait());
        {% endif %}
        
        {% if "rtt" in features %}
        rprintln!("LED blink cycle completed");
        {% endif %}
    }
}