Crate nrf24_rs

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.

Usage

This crate can be used by adding nrf24-rs to your dependencies in your project’s Cargo.toml.

[dependencies]
nrf24-rs = "0.1"

Overview

Example: Sending data

This simple example will send a simple “Hello world” message.

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.

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 for all public structs and enums.

Modules

config

Different structs and values for configuration of the chip.

status

Status datastructures.

Structs

Nrf24l01

The nRF24L01 driver type. This struct encapsulates all functionality.

Enums

TransferError

Errors that can occur when sending and receiving data.

Constants

MAX_PAYLOAD_SIZE

Max size in bytes of a single payload to be sent or recieved.

SPI_MODE

SPI mode. Use this when initializing the SPI instance.