A personal rust firmware for the Badger 2040 W
a little clean up
+36
-18
+1
src/control_driver.rs
src/cyw43_driver.rs
+1
src/control_driver.rs
src/cyw43_driver.rs
···
47
47
let cs = Output::new(p_25, Level::High);
48
48
let mut pio = Pio::new(pio0, Irqs);
49
49
let spi = PioSpi::new(&mut pio.common, pio.sm0, pio.irq0, cs, p_24, p_29, dma_ch0);
50
+
// let input = Input::new(p_29, Pull::Up);
50
51
51
52
static STATE: StaticCell<cyw43::State> = StaticCell::new();
52
53
let state = STATE.init(cyw43::State::new());
+35
-18
src/main.rs
+35
-18
src/main.rs
···
4
4
5
5
#![no_std]
6
6
#![no_main]
7
-
use control_driver::setup_cyw43;
7
+
use core::sync::atomic::AtomicU32;
8
+
9
+
use cyw43_driver::setup_cyw43;
8
10
use defmt::info;
9
11
use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
10
12
use embassy_executor::Spawner;
11
13
use embassy_rp::gpio;
12
14
use embassy_rp::gpio::Input;
15
+
use embassy_rp::peripherals::SPI0;
13
16
use embassy_rp::spi::Spi;
14
17
use embassy_rp::spi::{self};
15
18
use embassy_sync::blocking_mutex::raw::NoopRawMutex;
16
19
use embassy_sync::mutex::Mutex;
17
20
use embassy_time::{Delay, Duration, Timer};
18
-
use embedded_graphics::pixelcolor::Rgb565;
19
21
use embedded_graphics::primitives::PrimitiveStyleBuilder;
20
22
use embedded_graphics::text::Text;
21
23
use embedded_graphics::{
···
31
33
};
32
34
use gpio::{Level, Output, Pull};
33
35
use heapless::String;
36
+
use static_cell::StaticCell;
34
37
use uc8151::asynch::Uc8151;
38
+
use uc8151::LUT;
35
39
use uc8151::WIDTH;
36
-
use uc8151::{UpdateRegion, LUT};
37
40
use {defmt_rtt as _, panic_probe as _};
38
-
mod control_driver;
41
+
mod cyw43_driver;
42
+
43
+
type Spi0Bus = Mutex<NoopRawMutex, Spi<'static, SPI0, spi::Async>>;
44
+
static WIFI_COUNT: AtomicU32 = AtomicU32::new(0);
39
45
40
46
#[embassy_executor::main]
41
47
async fn main(spawner: Spawner) {
···
45
51
)
46
52
.await;
47
53
54
+
// let input = gpio::Input::new(p.PIN_29, gpio::Pull::Up);
55
+
48
56
let miso = p.PIN_16;
49
57
let mosi = p.PIN_19;
50
58
let clk = p.PIN_18;
···
82
90
p.DMA_CH2,
83
91
spi::Config::default(),
84
92
);
85
-
let spi_bus: Mutex<NoopRawMutex, _> = Mutex::new(spi);
93
+
// let spi_bus: Mutex<NoopRawMutex, _> = Mutex::new(spi);
94
+
static SPI_BUS: StaticCell<Spi0Bus> = StaticCell::new();
95
+
let spi_bus = SPI_BUS.init(Mutex::new(spi));
96
+
97
+
info!("led on!");
98
+
control.gpio_set(0, true).await;
99
+
spawner.must_spawn(run_the_display(spi_bus, cs, dc, busy, reset));
100
+
}
101
+
102
+
#[embassy_executor::task]
103
+
async fn run_the_display(
104
+
spi_bus: &'static Spi0Bus,
105
+
cs: Output<'static>,
106
+
dc: Output<'static>,
107
+
busy: Input<'static>,
108
+
reset: Output<'static>,
109
+
) {
86
110
let spi_dev = SpiDevice::new(&spi_bus, cs);
111
+
87
112
let mut display = Uc8151::new(spi_dev, dc, busy, reset, Delay);
88
113
89
114
display.reset().await;
···
115
140
116
141
let _ = display.update().await;
117
142
118
-
let delay: Duration = Duration::from_secs(1);
119
-
let mut count = 0;
143
+
let delay: Duration = Duration::from_secs(30);
120
144
let mut text: String<16> = String::<16>::new();
121
145
122
146
loop {
123
-
info!("led on!");
124
-
control.gpio_set(0, true).await;
125
-
Timer::after(delay).await;
126
-
127
-
info!("led off!");
128
-
control.gpio_set(0, false).await;
129
-
130
-
Timer::after(delay).await;
131
-
147
+
let count = WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed);
132
148
let _ = core::fmt::write(&mut text, format_args!("Count: {}", count));
133
149
let count_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
134
150
count_bounds
···
159
175
text.clear();
160
176
// let _ = display.clear(Rgb565::WHITE.into());
161
177
// let _ = display.update().await;
162
-
count += 1;
163
-
// Timer::after(Duration::from_secs(10)).await;
178
+
WIFI_COUNT.store(count + 1, core::sync::atomic::Ordering::Relaxed);
179
+
180
+
Timer::after(delay).await;
164
181
}
165
182
}