Skip to content

Commit 95e3f78

Browse files
astapletonastapleton
committed
fix example again
1 parent 6f3aa81 commit 95e3f78

File tree

1 file changed

+39
-131
lines changed

1 file changed

+39
-131
lines changed

‎examples/dma.rs

Lines changed: 39 additions & 131 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,7 @@
44

55
mod utilities;
66

7-
use core::mem::MaybeUninit;
8-
7+
use cortex_m::singleton;
98
use cortex_m_rt::entry;
109
use cortex_m_semihosting::debug;
1110
use stm32h5xx_hal::{
@@ -14,114 +13,6 @@ use stm32h5xx_hal::{
1413
prelude::*,
1514
};
1615

17-
static mut SOURCE_BYTES: MaybeUninit<[u8; 40]> = MaybeUninit::uninit();
18-
static mut DEST_BYTES: MaybeUninit<[u8; 40]> = MaybeUninit::zeroed();
19-
static mut DEST_HALF_WORDS: MaybeUninit<[u16; 20]> = MaybeUninit::uninit();
20-
static mut SOURCE_WORDS: MaybeUninit<[u32; 10]> = MaybeUninit::uninit();
21-
static mut DEST_WORDS: MaybeUninit<[u32; 10]> = MaybeUninit::uninit();
22-
23-
fn u8_to_u8_sequential() -> (&'static [u8; 40], &'static mut [u8; 40]) {
24-
let buf: &mut [MaybeUninit<u8>; 40] = unsafe {
25-
&mut *(core::ptr::addr_of_mut!(SOURCE_BYTES)
26-
as *mut [MaybeUninit<u8>; 40])
27-
};
28-
29-
for (i, value) in buf.iter_mut().enumerate() {
30-
unsafe {
31-
value.as_mut_ptr().write(i as u8);
32-
}
33-
}
34-
#[allow(static_mut_refs)] // TODO: Fix this
35-
let src = unsafe { SOURCE_BYTES.assume_init_ref() };
36-
37-
let dest =
38-
unsafe { (*core::ptr::addr_of_mut!(DEST_BYTES)).assume_init_mut() };
39-
40-
dest.fill(0);
41-
42-
(src, dest)
43-
}
44-
45-
fn u32_to_u32_transform() -> (&'static [u32; 10], &'static mut [u32; 10]) {
46-
let buf: &mut [MaybeUninit<u32>; 10] = unsafe {
47-
&mut *(core::ptr::addr_of_mut!(SOURCE_WORDS)
48-
as *mut [MaybeUninit<u32>; 10])
49-
};
50-
51-
buf.fill(MaybeUninit::new(0x12345678));
52-
53-
#[allow(static_mut_refs)] // TODO: Fix this
54-
let src = unsafe { SOURCE_WORDS.assume_init_ref() };
55-
56-
let dest =
57-
unsafe { (*core::ptr::addr_of_mut!(DEST_WORDS)).assume_init_mut() };
58-
59-
dest.fill(0);
60-
(src, dest)
61-
}
62-
63-
fn u32_to_u16_truncate() -> (&'static [u32; 10], &'static mut [u16; 20]) {
64-
let buf: &mut [MaybeUninit<u32>; 10] = unsafe {
65-
&mut *(core::ptr::addr_of_mut!(SOURCE_WORDS)
66-
as *mut [MaybeUninit<u32>; 10])
67-
};
68-
69-
buf.fill(MaybeUninit::new(0x12345678));
70-
71-
#[allow(static_mut_refs)] // TODO: Fix this
72-
let src = unsafe { SOURCE_WORDS.assume_init_ref() };
73-
74-
let dest = unsafe {
75-
(*core::ptr::addr_of_mut!(DEST_HALF_WORDS)).assume_init_mut()
76-
};
77-
78-
dest.fill(0);
79-
(src, dest)
80-
}
81-
82-
fn u32_to_u8_unpack() -> (&'static [u32; 10], &'static mut [u8; 40]) {
83-
let buf: &mut [MaybeUninit<u32>; 10] = unsafe {
84-
&mut *(core::ptr::addr_of_mut!(SOURCE_WORDS)
85-
as *mut [MaybeUninit<u32>; 10])
86-
};
87-
88-
buf.fill(MaybeUninit::new(0x12345678));
89-
90-
#[allow(static_mut_refs)] // TODO: Fix this
91-
let src = unsafe { SOURCE_WORDS.assume_init_ref() };
92-
93-
let dest =
94-
unsafe { (*core::ptr::addr_of_mut!(DEST_BYTES)).assume_init_mut() };
95-
96-
dest.fill(0);
97-
(src, dest)
98-
}
99-
100-
fn u8_to_u32_pack() -> (&'static [u8; 40], &'static mut [u32; 10]) {
101-
let buf: &mut [MaybeUninit<u8>; 40] = unsafe {
102-
&mut *(core::ptr::addr_of_mut!(SOURCE_BYTES)
103-
as *mut [MaybeUninit<u8>; 40])
104-
};
105-
106-
for chunk in buf.chunks_mut(4) {
107-
unsafe {
108-
chunk[0].as_mut_ptr().write(0x78);
109-
chunk[1].as_mut_ptr().write(0x56);
110-
chunk[2].as_mut_ptr().write(0x34);
111-
chunk[3].as_mut_ptr().write(0x12);
112-
}
113-
}
114-
115-
#[allow(static_mut_refs)] // TODO: Fix this
116-
let src = unsafe { SOURCE_BYTES.assume_init_ref() };
117-
118-
let dest =
119-
unsafe { (*core::ptr::addr_of_mut!(DEST_WORDS)).assume_init_mut() };
120-
121-
dest.fill(0);
122-
(src, dest)
123-
}
124-
12516
#[entry]
12617
fn main() -> ! {
12718
utilities::logger::init();
@@ -137,73 +28,90 @@ fn main() -> ! {
13728

13829
let channels = dp.GPDMA1.channels(ccdr.peripheral.GPDMA1);
13930

140-
let (source_buf, dest_buf) = u8_to_u8_sequential();
141-
let source_copy = unsafe { &*(source_buf.as_ptr() as *const [u8; 40]) };
142-
let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u8; 40]) };
31+
log::info!("u8 to u8");
32+
let src =
33+
singleton!(: [u8; 40] = core::array::from_fn(|i| i as u8)).unwrap();
34+
let dest = singleton!(: [u8; 40] = [0u8; 40]).unwrap();
35+
let source_copy = unsafe { &*(src.as_ptr() as *const [u8; 40]) };
36+
let dest_copy = unsafe { &*(dest.as_ptr() as *const [u8; 40]) };
14337

14438
let channel = channels.0;
14539
let config = DmaConfig::new();
146-
let transfer =
147-
DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
40+
let transfer = DmaTransfer::memory_to_memory(config, &channel, src, dest);
14841
transfer.start().unwrap();
14942
transfer.wait_for_transfer_complete().unwrap();
15043
assert_eq!(source_copy, dest_copy);
15144

152-
let (source_buf, dest_buf) = u32_to_u32_transform();
153-
let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u32; 10]) };
45+
log::info!("u32 to u32 with data transform");
46+
let src = singleton!(: [u32; 10] = [0x12345678u32; 10]).unwrap();
47+
let dest = singleton!(: [u32; 10] = [0u32; 10]).unwrap();
48+
49+
let dest_copy = unsafe { &*(dest.as_ptr() as *const [u32; 10]) };
50+
15451
let config = DmaConfig::new().with_data_transform(
15552
DataTransform::builder()
15653
.swap_destination_half_words()
15754
.swap_destination_half_word_byte_order(),
15855
);
15956

160-
let transfer =
161-
DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
57+
let transfer = DmaTransfer::memory_to_memory(config, &channel, src, dest);
16258

16359
transfer.start().unwrap();
16460
transfer.wait_for_transfer_complete().unwrap();
16561
let expected = [0x78563412; 10];
16662
assert_eq!(expected, *dest_copy);
16763

168-
let (source_buf, dest_buf) = u32_to_u16_truncate();
169-
let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u16; 20]) };
64+
log::info!("u32 to u16 with truncate");
65+
let src = singleton!(: [u32; 10] = [0x12345678u32; 10]).unwrap();
66+
let dest = singleton!(: [u16; 20] = [0u16; 20]).unwrap();
67+
let dest_copy = unsafe { &*(dest.as_ptr() as *const [u16; 20]) };
17068
let config = DmaConfig::new().with_data_transform(
17169
DataTransform::builder().left_align_right_truncate(),
17270
);
173-
let transfer =
174-
DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
71+
let transfer = DmaTransfer::memory_to_memory(config, &channel, src, dest);
17572

17673
transfer.start().unwrap();
17774
transfer.wait_for_transfer_complete().unwrap();
17875
let expected = [0x1234; 10];
17976
assert_eq!(expected, (*dest_copy)[0..10]);
18077

181-
let (source_buf, dest_buf) = u32_to_u8_unpack();
182-
let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u8; 40]) };
78+
log::info!("u32 to u8 with unpack");
79+
let src = singleton!(: [u32; 10] = [0x12345678u32; 10]).unwrap();
80+
let dest = singleton!(: [u8; 40] = [0u8; 40]).unwrap();
81+
82+
let dest_copy = unsafe { &*(dest.as_ptr() as *const [u8; 40]) };
83+
18384
let config =
18485
DmaConfig::new().with_data_transform(DataTransform::builder().unpack());
185-
let transfer =
186-
DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
86+
let transfer = DmaTransfer::memory_to_memory(config, &channel, src, dest);
18787

18888
transfer.start().unwrap();
18989
transfer.wait_for_transfer_complete().unwrap();
19090
let expected = [0x78, 0x56, 0x34, 0x12];
19191
assert_eq!(expected, (*dest_copy)[0..4]);
19292
assert_eq!(expected, (*dest_copy)[36..40]);
19393

194-
let (source_buf, dest_buf) = u8_to_u32_pack();
195-
let dest_copy = unsafe { &*(dest_buf.as_ptr() as *const [u32; 10]) };
94+
log::info!("u8 to u32 with pack");
95+
let src = singleton!(: [u8; 40] = [0u8; 40]).unwrap();
96+
let dest = singleton!(: [u32; 10] = [0u32; 10]).unwrap();
97+
98+
for chunk in src.chunks_mut(4) {
99+
chunk.copy_from_slice(&[0x78, 0x56, 0x34, 0x12]);
100+
}
101+
102+
let dest_copy = unsafe { &*(dest.as_ptr() as *const [u32; 10]) };
103+
196104
let config =
197105
DmaConfig::new().with_data_transform(DataTransform::builder().pack());
198-
let transfer =
199-
DmaTransfer::memory_to_memory(config, &channel, source_buf, dest_buf);
106+
let transfer = DmaTransfer::memory_to_memory(config, &channel, src, dest);
200107

201108
transfer.start().unwrap();
202109
transfer.wait_for_transfer_complete().unwrap();
203110
let expected = [0x12345678; 10];
204111
assert_eq!(expected, (*dest_copy));
205112
assert_eq!(expected, (*dest_copy));
206113

114+
log::info!("All tests passed!");
207115
loop {
208116
debug::exit(debug::EXIT_SUCCESS)
209117
}

0 commit comments

Comments
 (0)