|
| 1 | +// Copyright (c) 2018 The rust-gpio-cdev Project Developers. |
| 2 | +// |
| 3 | +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| 4 | +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| 5 | +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| 6 | +// option. This file may not be copied, modified, or distributed |
| 7 | +// except according to those terms. |
| 8 | + |
| 9 | +//! Wrapper for asynchronous programming using Tokio. |
| 10 | +
|
| 11 | +use futures::ready; |
| 12 | +use futures::stream::Stream; |
| 13 | +use futures::task::{Context, Poll}; |
| 14 | +use mio::event::Evented; |
| 15 | +use mio::unix::EventedFd; |
| 16 | +use mio::{PollOpt, Ready, Token}; |
| 17 | +use tokio::io::PollEvented; |
| 18 | + |
| 19 | +use std::io; |
| 20 | +use std::os::unix::io::AsRawFd; |
| 21 | +use std::pin::Pin; |
| 22 | + |
| 23 | +use super::errors::event_err; |
| 24 | +use super::{LineEvent, LineEventHandle, Result}; |
| 25 | + |
| 26 | +struct PollWrapper { |
| 27 | + handle: LineEventHandle, |
| 28 | +} |
| 29 | + |
| 30 | +impl Evented for PollWrapper { |
| 31 | + fn register( |
| 32 | + &self, |
| 33 | + poll: &mio::Poll, |
| 34 | + token: Token, |
| 35 | + interest: Ready, |
| 36 | + opts: PollOpt, |
| 37 | + ) -> io::Result<()> { |
| 38 | + EventedFd(&self.handle.file.as_raw_fd()).register(poll, token, interest, opts) |
| 39 | + } |
| 40 | + |
| 41 | + fn reregister( |
| 42 | + &self, |
| 43 | + poll: &mio::Poll, |
| 44 | + token: Token, |
| 45 | + interest: Ready, |
| 46 | + opts: PollOpt, |
| 47 | + ) -> io::Result<()> { |
| 48 | + EventedFd(&self.handle.file.as_raw_fd()).reregister(poll, token, interest, opts) |
| 49 | + } |
| 50 | + |
| 51 | + fn deregister(&self, poll: &mio::Poll) -> io::Result<()> { |
| 52 | + EventedFd(&self.handle.file.as_raw_fd()).deregister(poll) |
| 53 | + } |
| 54 | +} |
| 55 | + |
| 56 | +/// Wrapper around a `LineEventHandle` which implements a `futures::stream::Stream` for interrupts. |
| 57 | +/// |
| 58 | +/// # Example |
| 59 | +/// |
| 60 | +/// The following example waits for state changes on an input line. |
| 61 | +/// |
| 62 | +/// ```no_run |
| 63 | +/// # type Result<T> = std::result::Result<T, gpio_cdev::errors::Error>; |
| 64 | +/// use futures::stream::StreamExt; |
| 65 | +/// use gpio_cdev::{AsyncLineEventHandle, Chip, EventRequestFlags, LineRequestFlags}; |
| 66 | +/// |
| 67 | +/// async fn print_events(line: u32) -> Result<()> { |
| 68 | +/// let mut chip = Chip::new("/dev/gpiochip0")?; |
| 69 | +/// let line = chip.get_line(line)?; |
| 70 | +/// let mut events = AsyncLineEventHandle::new(line.events( |
| 71 | +/// LineRequestFlags::INPUT, |
| 72 | +/// EventRequestFlags::BOTH_EDGES, |
| 73 | +/// "gpioevents", |
| 74 | +/// )?)?; |
| 75 | +/// |
| 76 | +/// loop { |
| 77 | +/// match events.next().await { |
| 78 | +/// Some(event) => println!("{:?}", event?), |
| 79 | +/// None => break, |
| 80 | +/// }; |
| 81 | +/// } |
| 82 | +/// |
| 83 | +/// Ok(()) |
| 84 | +/// } |
| 85 | +/// |
| 86 | +/// # #[tokio::main] |
| 87 | +/// # async fn main() { |
| 88 | +/// # print_events(42).await.unwrap(); |
| 89 | +/// # } |
| 90 | +/// ``` |
| 91 | +pub struct AsyncLineEventHandle { |
| 92 | + evented: PollEvented<PollWrapper>, |
| 93 | +} |
| 94 | + |
| 95 | +impl AsyncLineEventHandle { |
| 96 | + /// Wraps the specified `LineEventHandle`. |
| 97 | + /// |
| 98 | + /// # Arguments |
| 99 | + /// |
| 100 | + /// * `handle` - handle to be wrapped. |
| 101 | + pub fn new(handle: LineEventHandle) -> Result<AsyncLineEventHandle> { |
| 102 | + // The file descriptor needs to be configured for non-blocking I/O for PollEvented to work. |
| 103 | + let fd = handle.file.as_raw_fd(); |
| 104 | + unsafe { |
| 105 | + let flags = libc::fcntl(fd, libc::F_GETFL, 0); |
| 106 | + libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK); |
| 107 | + } |
| 108 | + |
| 109 | + Ok(AsyncLineEventHandle { |
| 110 | + evented: PollEvented::new(PollWrapper { handle })?, |
| 111 | + }) |
| 112 | + } |
| 113 | +} |
| 114 | + |
| 115 | +impl Stream for AsyncLineEventHandle { |
| 116 | + type Item = Result<LineEvent>; |
| 117 | + |
| 118 | + fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> { |
| 119 | + let ready = Ready::readable(); |
| 120 | + if let Err(e) = ready!(self.evented.poll_read_ready(cx, ready)) { |
| 121 | + return Poll::Ready(Some(Err(e.into()))); |
| 122 | + } |
| 123 | + |
| 124 | + match self.evented.get_ref().handle.read_event() { |
| 125 | + Ok(Some(event)) => Poll::Ready(Some(Ok(event))), |
| 126 | + Ok(None) => Poll::Ready(Some(Err(event_err(nix::Error::Sys( |
| 127 | + nix::errno::Errno::EIO, |
| 128 | + ))))), |
| 129 | + Err(nix::Error::Sys(nix::errno::Errno::EAGAIN)) => { |
| 130 | + self.evented.clear_read_ready(cx, ready)?; |
| 131 | + Poll::Pending |
| 132 | + } |
| 133 | + Err(e) => Poll::Ready(Some(Err(event_err(e)))), |
| 134 | + } |
| 135 | + } |
| 136 | +} |
| 137 | + |
| 138 | +impl AsRef<LineEventHandle> for AsyncLineEventHandle { |
| 139 | + fn as_ref(&self) -> &LineEventHandle { |
| 140 | + &self.evented.get_ref().handle |
| 141 | + } |
| 142 | +} |
![bors[bot]](https://avatars.githubusercontent.com/in/1847?v=4&size=40){kind=avatar}
0 commit comments