Skip to content

Commit cbaf315

Browse files
phil-oppphil-opp
committed
Move ethernet and sd card code to (commented out) tasks
1 parent e225883 commit cbaf315

File tree

1 file changed

+144
-127
lines changed

1 file changed

+144
-127
lines changed

‎src/bin/async-await.rs

Lines changed: 144 additions & 127 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,8 @@ use smoltcp::{
3838
time::Instant,
3939
wire::{EthernetAddress, IpAddress, IpEndpoint, Ipv4Address},
4040
};
41-
use stm32f7::stm32f7x6::{CorePeripherals, Interrupt, Peripherals, SAI2};
41+
use stm32f7::stm32f7x6::{CorePeripherals, Interrupt, Peripherals, SAI2, RCC, SYSCFG,
42+
ETHERNET_DMA, ETHERNET_MAC};
4243
use stm32f7_discovery::{
4344
ethernet,
4445
gpio::{GpioPort, InputPin, OutputPin},
@@ -245,62 +246,7 @@ fn run() -> ! {
245246
let idle_stream = task_runtime::IdleStream::new(idle_waker_sink.clone());
246247

247248
// ethernet
248-
let mut ethernet_task_idle_stream = task_runtime::IdleStream::new(idle_waker_sink.clone());
249-
let _ethernet_task = async move || {
250-
let mut ethernet_interface = ethernet::EthernetDevice::new(
251-
Default::default(),
252-
Default::default(),
253-
&mut rcc,
254-
&mut syscfg,
255-
&mut ethernet_mac,
256-
&mut ethernet_dma,
257-
ETH_ADDR,
258-
)
259-
.map(|device| device.into_interface(IP_ADDR));
260-
if let Err(e) = ethernet_interface {
261-
println!("ethernet init failed: {:?}", e);
262-
};
263-
264-
let mut sockets = SocketSet::new(Vec::new());
265-
266-
if ethernet_interface.is_ok() {
267-
let endpoint = IpEndpoint::new(IpAddress::Ipv4(IP_ADDR), 15);
268-
let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY; 3], vec![0u8; 256]);
269-
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY; 1], vec![0u8; 128]);
270-
let mut example_udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer);
271-
example_udp_socket.bind(endpoint).unwrap();
272-
sockets.add(example_udp_socket);
273-
274-
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; ethernet::MTU]);
275-
let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; ethernet::MTU]);
276-
let mut example_tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
277-
example_tcp_socket.listen(endpoint).unwrap();
278-
sockets.add(example_tcp_socket);
279-
}
280-
281-
// handle new ethernet packets
282-
if let Ok(ref mut eth) = ethernet_interface {
283-
loop {
284-
match eth.poll(
285-
&mut sockets,
286-
Instant::from_millis(system_clock::ms() as i64),
287-
) {
288-
Err(::smoltcp::Error::Exhausted) => {
289-
await!(ethernet_task_idle_stream.next()).expect("idle stream closed");
290-
},
291-
Err(::smoltcp::Error::Unrecognized) => {}
292-
Err(e) => println!("Network error: {:?}", e),
293-
Ok(socket_changed) => {
294-
if socket_changed {
295-
for mut socket in sockets.iter_mut() {
296-
poll_socket(&mut socket).expect("socket poll failed");
297-
}
298-
}
299-
}
300-
}
301-
}
302-
}
303-
};
249+
let ethernet_task = EthernetTask::new(idle_stream.clone(), rcc, syscfg, ethernet_mac, ethernet_dma);
304250

305251
let i2c_3_mutex = Arc::new(FutureMutex::new(i2c_3));
306252
let layer_1_mutex = Arc::new(FutureMutex::new(layer_1));
@@ -319,9 +265,15 @@ fn run() -> ! {
319265
executor.spawn_local(touch_task.run()).unwrap();
320266
executor.spawn_local(count_up_on_idle_task(idle_stream.clone())).unwrap();
321267
executor.spawn_local(audio_task.run()).unwrap();
322-
//executor.spawn_local(ethernet_task).unwrap();
268+
323269
//executor.spawn_local(print_x);
324270

271+
// FIXME: Causes link error: no memory region specified for section '.ARM.extab'
272+
//executor.spawn_local(_ethernet_task.run()).unwrap();
273+
274+
// FIXME: Does not work currently due to borrowing errors
275+
// executor.spawn_local(sd_card_task(sd, idle_stream.clone())).unwrap();
276+
325277
let idle = async move {
326278
loop {
327279
let next_waker = await!(idle_waker_stream.next()).expect("idle channel closed");
@@ -338,38 +290,7 @@ fn run() -> ! {
338290
}
339291
}
340292
},
341-
);
342-
343-
344-
//let mut previous_button_state = pins.button.get();
345-
loop {
346-
/*
347-
// poll button state
348-
let current_button_state = pins.button.get();
349-
if current_button_state != previous_button_state {
350-
if current_button_state {
351-
pins.led.toggle();
352-
353-
// trigger the `EXTI0` interrupt
354-
nvic.set_pending(Interrupt::EXTI0);
355-
}
356-
357-
previous_button_state = current_button_state;
358-
}
359-
*/
360-
361-
//unsafe { audio_writer_task.resume() };
362-
363-
364-
// Initialize the SD Card on insert and deinitialize on extract.
365-
if sd.card_present() && !sd.card_initialized() {
366-
if let Some(i_err) = sd::init(&mut sd).err() {
367-
println!("{:?}", i_err);
368-
}
369-
} else if !sd.card_present() && sd.card_initialized() {
370-
sd::de_init(&mut sd);
371-
}
372-
}
293+
)
373294
}
374295

375296

@@ -479,50 +400,146 @@ async fn count_up_on_idle_task(idle_stream: impl Stream<Item=()>) {
479400
}
480401
}
481402

482-
fn poll_socket(socket: &mut Socket) -> Result<(), smoltcp::Error> {
483-
match socket {
484-
&mut Socket::Udp(ref mut socket) => match socket.endpoint().port {
485-
15 => loop {
486-
let reply;
487-
match socket.recv() {
488-
Ok((data, remote_endpoint)) => {
489-
let mut data = Vec::from(data);
490-
let len = data.len() - 1;
491-
data[..len].reverse();
492-
reply = (data, remote_endpoint);
403+
async fn sd_card_task<S, P>(mut sd: sd::Sd<'static, P>, idle_stream: S) where S: Stream<Item=()>, P: InputPin {
404+
pin_mut!(idle_stream);
405+
// Initialize the SD Card on insert and deinitialize on extract.
406+
loop {
407+
await!(idle_stream.next());
408+
if sd.card_present() && !sd.card_initialized() {
409+
if let Some(i_err) = sd::init(&mut sd).err() {
410+
println!("{:?}", i_err);
411+
}
412+
} else if !sd.card_present() && sd.card_initialized() {
413+
sd::de_init(&mut sd);
414+
}
415+
}
416+
}
417+
418+
struct EthernetTask<S> where S: Stream<Item=()> {
419+
idle_stream: S,
420+
rcc: RCC,
421+
syscfg: SYSCFG,
422+
ethernet_mac: ETHERNET_MAC,
423+
ethernet_dma: ETHERNET_DMA,
424+
}
425+
426+
impl<S> EthernetTask<S> where S: Stream<Item=()> {
427+
fn new(idle_stream: S, rcc: RCC, syscfg: SYSCFG, ethernet_mac: ETHERNET_MAC,
428+
ethernet_dma: ETHERNET_DMA) -> Self
429+
{
430+
Self {
431+
idle_stream,
432+
rcc,
433+
syscfg,
434+
ethernet_mac,
435+
ethernet_dma,
436+
}
437+
}
438+
439+
async fn run(mut self) {
440+
let mut ethernet_interface = ethernet::EthernetDevice::new(
441+
Default::default(),
442+
Default::default(),
443+
&mut self.rcc,
444+
&mut self.syscfg,
445+
&mut self.ethernet_mac,
446+
&mut self.ethernet_dma,
447+
ETH_ADDR,
448+
)
449+
.map(|device| device.into_interface(IP_ADDR));
450+
if let Err(e) = ethernet_interface {
451+
println!("ethernet init failed: {:?}", e);
452+
};
453+
454+
let idle_stream = self.idle_stream;
455+
pin_mut!(idle_stream);
456+
457+
let mut sockets = SocketSet::new(Vec::new());
458+
459+
if ethernet_interface.is_ok() {
460+
let endpoint = IpEndpoint::new(IpAddress::Ipv4(IP_ADDR), 15);
461+
let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY; 3], vec![0u8; 256]);
462+
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY; 1], vec![0u8; 128]);
463+
let mut example_udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer);
464+
example_udp_socket.bind(endpoint).unwrap();
465+
sockets.add(example_udp_socket);
466+
467+
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; ethernet::MTU]);
468+
let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; ethernet::MTU]);
469+
let mut example_tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
470+
example_tcp_socket.listen(endpoint).unwrap();
471+
sockets.add(example_tcp_socket);
472+
}
473+
474+
// handle new ethernet packets
475+
if let Ok(ref mut eth) = ethernet_interface {
476+
loop {
477+
match eth.poll(
478+
&mut sockets,
479+
Instant::from_millis(system_clock::ms() as i64),
480+
) {
481+
Err(::smoltcp::Error::Exhausted) => {
482+
await!(idle_stream.next()).expect("idle stream closed");
483+
},
484+
Err(::smoltcp::Error::Unrecognized) => {}
485+
Err(e) => println!("Network error: {:?}", e),
486+
Ok(socket_changed) => {
487+
if socket_changed {
488+
for mut socket in sockets.iter_mut() {
489+
Self::poll_socket(&mut socket).expect("socket poll failed");
490+
}
491+
}
493492
}
494-
Err(smoltcp::Error::Exhausted) => break,
495-
Err(err) => return Err(err),
496493
}
497-
socket.send_slice(&reply.0, reply.1)?;
494+
}
495+
}
496+
}
497+
498+
fn poll_socket(socket: &mut Socket) -> Result<(), smoltcp::Error> {
499+
match socket {
500+
&mut Socket::Udp(ref mut socket) => match socket.endpoint().port {
501+
15 => loop {
502+
let reply;
503+
match socket.recv() {
504+
Ok((data, remote_endpoint)) => {
505+
let mut data = Vec::from(data);
506+
let len = data.len() - 1;
507+
data[..len].reverse();
508+
reply = (data, remote_endpoint);
509+
}
510+
Err(smoltcp::Error::Exhausted) => break,
511+
Err(err) => return Err(err),
512+
}
513+
socket.send_slice(&reply.0, reply.1)?;
514+
},
515+
_ => {}
498516
},
499-
_ => {}
500-
},
501-
&mut Socket::Tcp(ref mut socket) => match socket.local_endpoint().port {
502-
15 => {
503-
if !socket.may_recv() {
504-
return Ok(());
505-
}
506-
let reply = socket.recv(|data| {
507-
if data.len() > 0 {
508-
let mut reply = Vec::from("tcp: ");
509-
let start_index = reply.len();
510-
reply.extend_from_slice(data);
511-
reply[start_index..(start_index + data.len() - 1)].reverse();
512-
(data.len(), Some(reply))
513-
} else {
514-
(data.len(), None)
517+
&mut Socket::Tcp(ref mut socket) => match socket.local_endpoint().port {
518+
15 => {
519+
if !socket.may_recv() {
520+
return Ok(());
521+
}
522+
let reply = socket.recv(|data| {
523+
if data.len() > 0 {
524+
let mut reply = Vec::from("tcp: ");
525+
let start_index = reply.len();
526+
reply.extend_from_slice(data);
527+
reply[start_index..(start_index + data.len() - 1)].reverse();
528+
(data.len(), Some(reply))
529+
} else {
530+
(data.len(), None)
531+
}
532+
})?;
533+
if let Some(reply) = reply {
534+
assert_eq!(socket.send_slice(&reply)?, reply.len());
515535
}
516-
})?;
517-
if let Some(reply) = reply {
518-
assert_eq!(socket.send_slice(&reply)?, reply.len());
519536
}
520-
}
537+
_ => {}
538+
},
521539
_ => {}
522-
},
523-
_ => {}
540+
}
541+
Ok(())
524542
}
525-
Ok(())
526543
}
527544

528545
interrupt!(EXTI0, exti0, state: Option<HStdout> = None);

0 commit comments

Comments
 (0)