//! This crate provides a platform agnostic Rust driver for the nRF24L01+ single chip 2.4 GHz
//! transceiver by Nordic Semiconduct for communicating data wirelessly using the [`embedded-hal`] traits.
//!
//! [`embedded-hal`]: https://github.com/rust-embedded/embedded-hal
//!
//! # Usage
//!
//! This crate can be used by adding `nrf24-rs` to your dependencies in your project's `Cargo.toml`.
//!
//! ```toml
//! [dependencies]
//! nrf24-rs = "0.1"
//! ```
//!
//! # Overview
//!
//! # Example: Sending data
//! This simple example will send a simple "Hello world" message.
//! ```rust
//! use panic_halt as _;
//!
//! use atmega168_hal as hal;
//! use hal::prelude::*;
//! use hal::spi;
//! use nrf24_rs::config::{NrfConfig, PALevel};
//! use nrf24_rs::{Nrf24l01, SPI_MODE};
//!
//! #[atmega168_hal::entry]
//! fn main() -> ! {
//! // Take peripherals
//! let dp = hal::pac::Peripherals::take().unwrap();
//!
//! // Initialize the different pins
//! let mut portb = dp.PORTB.split();
//! let ncs = portb.pb2.into_output(&mut portb.ddr);
//! let mosi = portb.pb3.into_output(&mut portb.ddr);
//! let miso = portb.pb4.into_pull_up_input(&mut portb.ddr);
//! let sclk = portb.pb5.into_output(&mut portb.ddr);
//!
//! // Initialize SPI
//! let settings = spi::Settings {
//! data_order: spi::DataOrder::MostSignificantFirst,
//! clock: spi::SerialClockRate::OscfOver4,
//! mode: SPI_MODE, // SPI Mode defined in this crate
//! };
//! let (spi, ncs) = spi::Spi::new(dp.SPI, sclk, mosi, miso, ncs, settings);
//!
//! let mut delay = hal::delay::Delay::<hal::clock::MHz16>::new();
//!
//! let message = b"Hello world!"; // The message we will be sending
//!
//! // Setup some configuration values
//! let config = NrfConfig::default()
//! .channel(8)
//! .pa_level(PALevel::Min)
//! // We will use a payload size the size of our message
//! .payload_size(message.len());
//!
//! // Initialize the chip
//! let mut nrf_chip = Nrf24l01::New(spi, ce, ncs, &mut delay, config).unwrap();
//! if !nrf_chip.is_connected().unwrap() {
//! panic!("Chip is not connected.");
//! }
//!
//! // Open a writing pipe on address "Node1".
//! // The listener will have to open a reading pipe with the same address
//! // in order to recieve this message.
//! nrf.open_writing_pipe(b"Node1").unwrap();
//!
//! // Keep trying to send the message
//! while let Err(e) = nrf.write(&mut delay, &message) {
//! // Something went wrong while writing, try again in 50ms
//! delay.delay_ms(50u16);
//! }
//!
//! // Message should now successfully have been sent!
//! loop {}
//! }
//! ```
//!
//!
//! # Example: Reading data
//! This simple example will read a "Hello world" message.
//! ```rust
//! use panic_halt as _;
//!
//! use atmega168_hal as hal;
//! use hal::prelude::*;
//! use hal::spi;
//! use nrf24_rs::config::{NrfConfig, PALevel, DataPipe};
//! use nrf24_rs::{Nrf24l01, SPI_MODE};
//!
//! #[atmega168_hal::entry]
//! fn main() -> ! {
//! // Take peripherals
//! let dp = hal::pac::Peripherals::take().unwrap();
//!
//! // Initialize the different pins
//! let mut portb = dp.PORTB.split();
//! let ncs = portb.pb2.into_output(&mut portb.ddr);
//! let mosi = portb.pb3.into_output(&mut portb.ddr);
//! let miso = portb.pb4.into_pull_up_input(&mut portb.ddr);
//! let sclk = portb.pb5.into_output(&mut portb.ddr);
//!
//! // Initialize SPI
//! let settings = spi::Settings {
//! data_order: spi::DataOrder::MostSignificantFirst,
//! clock: spi::SerialClockRate::OscfOver4,
//! mode: SPI_MODE, // SPI Mode defined in this crate
//! };
//! let (spi, ncs) = spi::Spi::new(dp.SPI, sclk, mosi, miso, ncs, settings);
//!
//! let mut delay = hal::delay::Delay::<hal::clock::MHz16>::new();
//!
//! // Setup some configuration values
//! let config = NrfConfig::default()
//! .channel(8)
//! .pa_level(PALevel::Min)
//! // We will use a payload size the size of our message
//! .payload_size(b"Hello world!".len());
//!
//! // Initialize the chip
//! let mut nrf_chip = Nrf24l01::New(spi, ce, ncs, &mut delay, config).unwrap();
//! if !nrf_chip.is_connected().unwrap() {
//! panic!("Chip is not connected.");
//! }
//!
//! // Open reading pipe 0 with address "Node1".
//! // The sender will have to open its writing pipe with the same address
//! // in order to transmit this message successfully.
//! nrf_chip.open_reading_pipe(DataPipe::DP0, b"Node1").unwrap();
//! // Set the chip in RX mode
//! nrf_chip.start_listening().unwrap();
//!
//! // Keep checking if there is any data available to read
//! while !nrf_chip.data_available().unwrap() {
//! // No data availble, wait 50ms, then check again
//! delay.delay_ms(50u16);
//! }
//! // Now there is some data availble to read
//!
//! // Initialize empty buffer
//! let mut buffer = [0; b"Hello world!".len()];
//! nrf_chip.read(&mut buffer).unwrap();
//!
//! assert_eq!(buffer, b"Hello world!");
//!
//! loop {}
//! }
//! ```
//!
//! # Feature-flags
//!
//! - **micro-fmt:** provides a `uDebug` implementation from the [ufmt crate](https://docs.rs/ufmt) for all public structs and enums.
extern crate embedded_hal as hal;
use spi;
pub use crate TransferError;
pub use crate Nrf24l01;
/// SPI mode. Use this when initializing the SPI instance.
pub const SPI_MODE: Mode = MODE_0;
/// Max size in bytes of a single payload to be sent or recieved.
pub const MAX_PAYLOAD_SIZE: u8 = 32;