ericwood.org
A step sequencer for Adafruit's RP2040-based macropad
refactoring, working step menu
+282
-148
-1
Cargo.lock
-1
Cargo.lock
-1
Cargo.toml
-1
Cargo.toml
+1
-3
src/sequencer_timer.rs
+1
-3
src/sequencer_timer.rs
···
1
1
use embassy_time::Timer;
2
-
use num_enum::{FromPrimitive, IntoPrimitive};
3
2
4
3
use crate::{COLS, ROWS};
5
4
6
-
#[derive(Clone, Copy, IntoPrimitive, FromPrimitive, Default)]
7
-
#[repr(u8)]
5
+
#[derive(Clone, Copy, Default, PartialEq)]
8
6
pub enum TimingOption {
9
7
#[default]
10
8
Quarter,
+48
-8
src/tasks/controls.rs
+48
-8
src/tasks/controls.rs
···
1
-
use core::sync::atomic::Ordering;
2
-
3
1
use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, channel::Channel};
4
2
use smart_leds::RGB;
5
3
6
4
use crate::{
7
5
COLS, KeyGrid, ROWS,
8
6
key_leds::Coord,
7
+
menus::{SEQUENCER_MENU, SequencerMenuValue, StepMenuValue},
9
8
tasks::{
10
9
display::{DISPLAY_CHANNEL, DisplayUpdate},
11
10
lights::{LIGHTS_CHANNEL, LedUpdate},
···
19
18
RotaryButton { pressed: bool },
20
19
SequencerStep { coord: Coord },
21
20
RotaryEncoder { increment: i32 },
21
+
SequencerMenuChange { value: SequencerMenuValue },
22
+
StepMenuChange { value: StepMenuValue },
23
+
}
24
+
25
+
#[derive(Default, Clone, Copy)]
26
+
struct StepState {
27
+
active: bool,
28
+
pressed: bool,
29
+
value: StepMenuValue,
22
30
}
23
31
24
32
#[embassy_executor::task]
25
33
pub async fn read_controls() {
26
-
let mut key_state: KeyGrid<bool> = [[false; COLS]; ROWS];
34
+
let mut step_state: KeyGrid<StepState> = [[StepState::default(); COLS]; ROWS];
27
35
28
36
let active = RGB { r: 5, g: 5, b: 5 };
29
37
let off = RGB { r: 0, g: 0, b: 0 };
30
38
let current = RGB { r: 32, g: 0, b: 0 };
31
39
40
+
let mut num_keys_pressed = 0;
41
+
let mut selected_step: Option<Coord> = None;
32
42
let mut step: Coord = (0, 0);
33
43
34
44
loop {
35
45
match CONTROLS_CHANNEL.receive().await {
36
46
ControlEvent::Key { pressed, coord } => {
47
+
let state = &mut step_state[coord.1 as usize][coord.0 as usize];
48
+
37
49
if !pressed {
50
+
state.pressed = false;
51
+
num_keys_pressed -= 1;
52
+
if num_keys_pressed != 1 {
53
+
set_step_menu(None).await;
54
+
}
38
55
continue;
39
56
}
40
57
41
-
let mut state = key_state[coord.1 as usize][coord.0 as usize];
42
-
state = !state;
43
-
key_state[coord.1 as usize][coord.0 as usize] = state;
44
-
let color = if state { active } else { off };
58
+
state.pressed = true;
59
+
state.active = !state.active;
60
+
let color = if state.active { active } else { off };
45
61
update_key_light(coord, color).await;
62
+
63
+
num_keys_pressed += 1;
64
+
let value = if num_keys_pressed == 1 {
65
+
selected_step = Some(coord);
66
+
Some(state.value)
67
+
} else {
68
+
selected_step = None;
69
+
None
70
+
};
71
+
set_step_menu(value).await;
46
72
}
47
73
ControlEvent::RotaryButton { pressed } => {
48
74
if !pressed {
···
53
79
}
54
80
ControlEvent::RotaryEncoder { increment } => rotary_change(increment).await,
55
81
ControlEvent::SequencerStep { coord } => {
56
-
let prev_color = if key_state[step.1 as usize][step.0 as usize] {
82
+
let prev_color = if step_state[step.1 as usize][step.0 as usize].active {
57
83
active
58
84
} else {
59
85
off
···
63
89
update_key_light(coord, current).await;
64
90
step = coord;
65
91
}
92
+
ControlEvent::SequencerMenuChange { value } => unsafe {
93
+
SEQUENCER_MENU.lock_mut(|inner| *inner = Some(value));
94
+
},
95
+
ControlEvent::StepMenuChange { value } => {
96
+
if let Some(coord) = selected_step {
97
+
step_state[coord.1 as usize][coord.0 as usize].value = value;
98
+
}
99
+
}
66
100
}
67
101
}
102
+
}
103
+
104
+
async fn set_step_menu(value: Option<StepMenuValue>) {
105
+
DISPLAY_CHANNEL
106
+
.send(DisplayUpdate::StepMenu { value })
107
+
.await;
68
108
}
69
109
70
110
async fn rotary_press() {
+61
-17
src/tasks/display.rs
+61
-17
src/tasks/display.rs
···
1
-
use crate::menus::{Menu, SequencerMenuItems};
1
+
use crate::{
2
+
menus::{Menu, SequencerMenuItems, SequencerMenuValue, StepMenuItems, StepMenuValue},
3
+
tasks::{CONTROLS_CHANNEL, ControlEvent},
4
+
};
2
5
use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, channel::Channel};
3
6
4
7
use crate::display::Display;
···
8
11
pub enum DisplayUpdate {
9
12
RotaryMove { increment: i32 },
10
13
RotaryPress,
11
-
}
12
-
13
-
struct Menus<'a> {
14
-
pub sequencer: Menu<'a, 4>,
15
-
}
16
-
17
-
impl<'a> Menus<'a> {
18
-
pub fn new(sequencer: Menu<'a, 4>) -> Self {
19
-
Self { sequencer }
20
-
}
14
+
StepMenu { value: Option<StepMenuValue> },
21
15
}
22
16
23
17
#[embassy_executor::task]
···
25
19
display.init();
26
20
27
21
let mut sequencer_items = SequencerMenuItems::new();
28
-
let sequencer = Menu::new(
22
+
let mut sequencer_menu = Menu::new(
29
23
"Sequencer",
24
+
SequencerMenuValue::default(),
30
25
[
31
26
&mut sequencer_items.play_menu,
32
27
&mut sequencer_items.bpm_menu,
33
28
&mut sequencer_items.timing_menu,
34
29
&mut sequencer_items.swing_menu,
35
30
],
31
+
&|value| {
32
+
let _ = CONTROLS_CHANNEL.try_send(ControlEvent::SequencerMenuChange { value: *value });
33
+
},
36
34
);
37
35
38
-
let mut menus = Menus::new(sequencer);
39
-
menus.sequencer.render(&mut display.display);
36
+
let mut step_items = StepMenuItems::new();
37
+
let mut step_menu = Menu::new(
38
+
"Step",
39
+
StepMenuValue::default(),
40
+
[
41
+
&mut step_items.note_menu,
42
+
&mut step_items.octave_menu,
43
+
&mut step_items.velocity_menu,
44
+
],
45
+
&|_| {},
46
+
);
47
+
48
+
sequencer_menu.render(&mut display.display);
40
49
display.flush();
50
+
let mut show_step = false;
41
51
42
52
loop {
43
53
match DISPLAY_CHANNEL.receive().await {
44
54
DisplayUpdate::RotaryMove { increment } => {
45
-
menus.sequencer.on_change(increment);
55
+
if show_step {
56
+
step_menu.on_change(increment).await;
57
+
} else {
58
+
sequencer_menu.on_change(increment).await;
59
+
}
46
60
}
47
61
DisplayUpdate::RotaryPress => {
48
-
menus.sequencer.on_select();
62
+
if show_step {
63
+
step_menu.on_select();
64
+
} else {
65
+
sequencer_menu.on_select();
66
+
}
67
+
}
68
+
DisplayUpdate::StepMenu { value } => {
69
+
show_step = value.is_some();
70
+
if let Some(value) = value {
71
+
step_items = StepMenuItems::new();
72
+
step_items.note_menu.set(value.note);
73
+
step_items.octave_menu.value = value.octave;
74
+
step_items.velocity_menu.value = value.velocity;
75
+
step_menu = Menu::new(
76
+
"Step",
77
+
StepMenuValue::default(),
78
+
[
79
+
&mut step_items.note_menu,
80
+
&mut step_items.octave_menu,
81
+
&mut step_items.velocity_menu,
82
+
],
83
+
&|value| {
84
+
let _ = CONTROLS_CHANNEL
85
+
.try_send(ControlEvent::StepMenuChange { value: *value });
86
+
},
87
+
);
88
+
}
49
89
}
50
90
}
51
91
52
92
display.clear();
53
-
menus.sequencer.render(&mut display.display);
93
+
if show_step {
94
+
step_menu.render(&mut display.display);
95
+
} else {
96
+
sequencer_menu.render(&mut display.display);
97
+
}
54
98
display.flush();
55
99
}
56
100
}
+1
-1
src/tasks/mod.rs
+1
-1
src/tasks/mod.rs
···
6
6
mod sequencer;
7
7
8
8
pub use buttons::{read_button, read_key};
9
-
pub use controls::{CONTROLS_CHANNEL, read_controls};
9
+
pub use controls::{CONTROLS_CHANNEL, ControlEvent, read_controls};
10
10
pub use display::drive_display;
11
11
pub use lights::update_lights;
12
12
pub use rotary::read_rotary_encoder;