Hlídač předmětů založený na otřesovém čidle MPU6050 a radiových modulech nRF24L01+.
Zdrojové kódy
CMakeLists.txt pro projekt examples_pico/CMakeLists.txt
cmake_minimum_required(VERSION 3.12)
# Pull in SDK (must be before project)
include(../cmake/pico_sdk_import.cmake)
# generate a compilation database for static analysis by clang-tidy
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
project(pico_examples C CXX ASM)
# Initialize the Pico SDK
pico_sdk_init()
# In YOUR project, include RF24's CMakeLists.txt
# giving the path depending on where the library
# is cloned to in your project
include(../CMakeLists.txt)
# iterate over a list of examples by name
set(EXAMPLES_LIST
hlidac_vysilac
hlidac_prijimac
)
foreach(example ${EXAMPLES_LIST})
# make a target
add_executable(${example} ${example}.cpp MPU6050.c defaultPins.h)
# link the necessary libs to the target
target_link_libraries(${example} PUBLIC
RF24
pico_stdlib
hardware_spi
hardware_gpio
hardware_i2c
hardware_pwm
)
# specify USB port as default serial communication's interface (not UART RX/TX pins)
pico_enable_stdio_usb(${example} 1)
pico_enable_stdio_uart(${example} 0)
# create map/bin/hex file etc.
pico_add_extra_outputs(${example})
endforeach()Otřesové čidlo MPU6050 examples_pico/MPU6050.h
/**
* InvenSense MPU6050 3-axis accelerometer and 3-axis gyroscope sensor stand-alone library for pico-sdk.
*
* This library eases the use of the MPU6050 by hiding calculations and comparisons, while still maintaining
* a flexible setup. My libraries have usually the following patterns -> Initialization, Setup and in the program
* loop, only one event call, so I2C is only used at one place in your program. See the example file for more
* information.
*
* Version History:
* 1.0 -- Initial release
*
* @file MPU6050.h
* @author Maik Steiger (maik.steiger@tu-dortmund.de)
* @brief
* @version 1.0
* @date 2021-11-14
*
* @copyright Copyright (c) 2021
*
*/
#ifndef MPU6050_H_
#define MPU6050_H_
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#define MPU6050_ADDRESS_A0_VCC 0x69
#define MPU6050_ADDRESS_A0_GND 0x68
#ifdef __cplusplus
extern "C"
{
#endif
#ifndef I2C_INFORMATION_S_
#define I2C_INFORMATION_S_
struct i2c_information
{
i2c_inst_t *instance;
uint8_t address;
};
#endif
struct mpu6050_vector16
{
int16_t x;
int16_t y;
int16_t z;
};
typedef struct mpu6050_vectorf
{
float x;
float y;
float z;
} mpu6050_vectorf_t;
struct mpu6050_configuration
{
uint8_t use_calibrate;
uint8_t actual_threshold;
float dps_per_digit;
float range_per_digit;
uint8_t meas_temp;
uint8_t meas_acce;
uint8_t meas_gyro;
uint8_t dhpf;
uint8_t dlpf;
};
struct mpu6050_calibration_data
{
struct mpu6050_vectorf tg; // Theshold for gyroscope
struct mpu6050_vectorf dg; // Delta for gyroscope
struct mpu6050_vectorf th; // Threshold
};
enum MPU6050_CLOCK_SOURCE
{
MPU6050_CLOCK_INTERNAL = 0,
MPU6050_CLOCK_PLL_XGYRO = 1,
MPU6050_CLOCK_PLL_YGYRO = 2,
MPU6050_CLOCK_PLL_ZGYRO = 3,
MPU6050_CLOCK_EXTERNAL_32KHZ = 4,
MPU6050_CLOCK_EXTERNAL_19MHZ = 5,
MPU6050_CLOCK_KEEP_RESET = 7,
};
enum MPU6050_SCALE
{
MPU6050_SCALE_250DPS = 0,
MPU6050_SCALE_500DPS = 1,
MPU6050_SCALE_1000DPS = 2,
MPU6050_SCALE_2000DPS = 3
};
enum MPU6050_RANGE
{
MPU6050_RANGE_2G = 0,
MPU6050_RANGE_4G = 1,
MPU6050_RANGE_8G = 2,
MPU6050_RANGE_16G = 3,
};
enum MPU6050_DHPF
{
MPU6050_DHPF_RESET = 0,
MPU6050_DHPF_5HZ = 1,
MPU6050_DHPF_2_5HZ = 2,
MPU6050_DHPF_1_25HZ = 3,
MPU6050_DHPF_0_63HZ = 4,
MPU6050_DHPF_HOLD = 7
};
enum MPU6050_DLPF
{
MPU6050_DLPF_0 = 0,
MPU6050_DLPF_1 = 1,
MPU6050_DLPF_2 = 2,
MPU6050_DLPF_3 = 3,
MPU6050_DLPF_4 = 4,
MPU6050_DLPF_5 = 5,
MPU6050_DLPF_6 = 6,
};
/**
* @brief MPU6050 Interrupt flags struct. It stores all the interrupt flags internally, which can be read and checked if a condition is met.
* These flags are reset automatically by the sensor itself, so READ-ONLY.
*/
typedef struct mpu6050_activity
{
uint8_t isOverflow;
uint8_t isFreefall;
uint8_t isInactivity;
uint8_t isActivity;
uint8_t isPosActivityOnX;
uint8_t isPosActivityOnY;
uint8_t isPosActivityOnZ;
uint8_t isNegActivityOnX;
uint8_t isNegActivityOnY;
uint8_t isNegActivityOnZ;
uint8_t isDataReady;
} mpu6050_activity_t;
/**
* @brief Main MPU6050 struct. It holds all the needed informations to make the MPU6050 work correcly.
* Never change any attributes directly, do so only by calling their appropriate functions.
*/
typedef struct mpu6050
{
struct i2c_information i2c;
struct mpu6050_configuration config;
struct mpu6050_calibration_data calibration_data;
struct mpu6050_activity activity;
struct mpu6050_vector16 ra; // Raw accelerometer vector
struct mpu6050_vector16 rg; // Raw gyroscope vector
struct mpu6050_vectorf na; // Normalized accelerometer vector
struct mpu6050_vectorf ng; // Normalized gyroscope vector
struct mpu6050_vectorf sa; // Scaled accelerometer vector
int16_t raw_temperature;
float temperature;
float temperaturef;
} mpu6050_t;
/**
* @brief Initialized a MPU6050 struct and returns it.
*
* @param i2c_inst_t* i2c_instance: I2C bus instance. Needed for multicore applications.
* @param uint8_t address: Slave device address, which can be modified by tying pin A0 either to GND or VCC.
* @return struct mpu6050
*/
struct mpu6050 mpu6050_init(i2c_inst_t *i2c_instance, const uint8_t address);
/**
* @brief Checks if MPU6050 is connected to the bus and runs a default setup.
*
* @param mpu6050_t* self: Reference to itself
* @return uint8_t: 1 if setup is successful, otherwise 0
*/
uint8_t mpu6050_begin(struct mpu6050 *self);
/**
* @brief Sets the scale of gyroscope readings. The higher, the preciser but slower.
*
* @param mpu6050_t* self: Reference to itself
* @param MPU6050_SCALE scale: Scale of gyroscope readings
*/
void mpu6050_set_scale(struct mpu6050 *self, enum MPU6050_SCALE scale);
/**
* @brief Sets the range of accelerometer readings. The higher, the preciser but slower.
*
* @param mpu6050_t* self: Reference to itself
* @param MPU6050_RANGE range: Range of accelerometer readings
*/
void mpu6050_set_range(struct mpu6050 *self, enum MPU6050_RANGE range);
/**
* @brief Sets the clock input for the MPU6050. If not specified, it automatically uses the internal 8MHz oscillator.
*
* @param mpu6050_t* self: Reference to itself
* @param MPU6050_CLOCK_SOURCE clock_source: Source of the clock signal
*/
void mpu6050_set_clock_source(struct mpu6050 *self, enum MPU6050_CLOCK_SOURCE clock_source);
/**
* @brief Puts the MPU6050 into sleep mode if set to 0. If set to 1, the device awakes.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: State to put the device in
*/
void mpu6050_set_sleep_enabled(struct mpu6050 *self, uint8_t state);
/**
* @brief Returns the WHO_AM_I identification of the device, which is always by default 0x68.
*
* @param mpu6050_t* self: Reference to itself
* @return uint8_t: WHO_AM_I identification (0x68)
*/
uint8_t mpu6050_who_am_i(struct mpu6050 *self);
/**
* @brief Fetches all the data from the device. The results are getting store into their buffers.
*
* @param mpu6050_t* self: Reference to itself
* @return uint8_t: 1 if readings were successful, otherwise 0
*/
uint8_t mpu6050_event(struct mpu6050 *self);
/**
* @brief Enables or disables temperature measurement readings. If state is set to 1, then
* the temperature will be read after an event call. Otherwise temperature readings will be
* skipped. Keep in mind however, that this is not a temperature sensor. So the resulted
* temperatures might be not precise.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: 1 to enable or 0 to disable
*/
void mpu6050_set_temperature_measuring(struct mpu6050 *self, uint8_t state);
/**
* @brief Enables or disables accelerometer measurement readings. If state is set to 1, then
* the accelerometer will be read after an event call. Otherwise accelerometer readings will be
* skipped.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: 1 to enable or 0 to disable
*/
void mpu6050_set_accelerometer_measuring(struct mpu6050 *self, uint8_t state);
/**
* @brief Enables or disables gyroscope measurement readings. If state is set to 1, then
* the gyroscope will be read after an event call. Otherwise gyroscope readings will be
* skipped.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: 1 to enable or 0 to disable
*/
void mpu6050_set_gyroscope_measuring(struct mpu6050 *self, uint8_t state);
/**
* @brief Calibrates the gyroscope by taking n amounts of samples and
* average them out to later be used in gyroscope calculations.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t samples: Amount of samples to take (Default 50 if you are unsure)
*/
void mpu6050_calibrate_gyro(struct mpu6050 *self, uint8_t samples);
/**
* @brief Sets the threshold value of the device, which are stored
* as calibration values.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t multiple: Treshold value (Default 1 if you are unsure)
*/
void mpu6050_set_threshold(struct mpu6050 *self, uint8_t multiple);
/**
* @brief Sets the gyroscope x-axis offset.
*
* @param mpu6050_t* self: Reference to itself
* @param uint16_t offset: Offset amount
*/
void mpu6050_set_gyro_offset_x(struct mpu6050 *self, uint16_t offset);
/**
* @brief Sets the gyroscope y-axis offset.
*
* @param mpu6050_t* self: Reference to itself
* @param uint16_t offset: Offset amount
*/
void mpu6050_set_gyro_offset_y(struct mpu6050 *self, uint16_t offset);
/**
* @brief Sets the gyroscope z-axis offset.
*
* @param mpu6050_t* self: Reference to itself
* @param uint16_t offset: Offset amount
*/
void mpu6050_set_gyro_offset_z(struct mpu6050 *self, uint16_t offset);
/**
* @brief Sets the accelerometer x-axis offset.
*
* @param mpu6050_t* self: Reference to itself
* @param uint16_t offset: Offset amount
*/
void mpu6050_set_accel_offset_x(struct mpu6050 *self, uint16_t offset);
/**
* @brief Sets the accelerometer y-axis offset.
*
* @param mpu6050_t* self: Reference to itself
* @param uint16_t offset: Offset amount
*/
void mpu6050_set_accel_offset_y(struct mpu6050 *self, uint16_t offset);
/**
* @brief Sets the accelerometer z-axis offset.
*
* @param mpu6050_t* self: Reference to itself
* @param uint16_t offset: Offset amount
*/
void mpu6050_set_accel_offset_z(struct mpu6050 *self, uint16_t offset);
/**
* @brief Calculates and returns a pointer to the accelerometer data.
*
* @param mpu6050_t* self: Reference to itself
* @return mpu6050_vectorf_t*: Pointer to float vector of accelerometer data
*/
struct mpu6050_vectorf *mpu6050_get_accelerometer(struct mpu6050 *self);
/**
* @brief Calculates and returns a pointer to the accelerometer data. The calculations will
* ignore the relative gravitation to earth.
*
* @param mpu6050_t* self: Reference to itself
* @return mpu6050_vectorf_t*: Pointer to float vector of accelerometer data
*/
struct mpu6050_vectorf *mpu6050_get_scaled_accelerometer(struct mpu6050 *self);
/**
* @brief Calculates and returns a pointer to the gyroscope data.
*
* @param mpu6050_t* self: Reference to itself
* @return mpu6050_vectorf_t*: Pointer to float vector of gyroscope data
*/
struct mpu6050_vectorf *mpu6050_get_gyroscope(struct mpu6050 *self);
/**
* @brief Calculates and returns the temperature in celsius.
*
* @param mpu6050_t* self: Reference to itself
* @return float: Temperature in celsius
*/
float mpu6050_get_temperature_c(struct mpu6050 *self);
/**
* @brief Calculates and returns the temperature in fahrenheit.
*
* @param mpu6050_t* self: Reference to itself
* @return float: Temperature in fahrenheit
*/
float mpu6050_get_temperature_f(struct mpu6050 *self);
/**
* @brief Returns a pointer to the activity struct which contains all the
* interrupt flags, which are reset automatically the the device. That means READ-ONLY.
*
* @param mpu6050_t* self: Reference to itself
* @return mpu6050_activity_t*: Pointer to activity struct
*/
struct mpu6050_activity *mpu6050_read_activities(struct mpu6050 *self);
/**
* @brief Enables or disables interrupt flags for motion detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: 1 to enable or 0 to disable
*/
void mpu6050_set_int_motion(struct mpu6050 *self, uint8_t state);
/**
* @brief Enables or disables interrupt flags for zero motion detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: 1 to enable or 0 to disable
*/
void mpu6050_set_int_zero_motion(struct mpu6050 *self, uint8_t state);
/**
* @brief Enables or disables interrupt flags for free fall detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t state: 1 to enable or 0 to disable
*/
void mpu6050_set_int_free_fall(struct mpu6050 *self, uint8_t state);
/**
* @brief Sets the DHPF (Digital High Pass Filter)
*
* @param mpu6050_t* self: Reference to itself
* @param MPU6050_DHPF dhpf
*/
void mpu6050_set_dhpf_mode(struct mpu6050 *self, enum MPU6050_DHPF dhpf);
/**
* @brief Sets the DLPF (Digital Low Pass Filter)
*
* @param mpu6050_t* self: Reference to itself
* @param MPU6050_DLPF dlpf
*/
void mpu6050_set_dlpf_mode(struct mpu6050 *self, enum MPU6050_DLPF dlpf);
/**
* @brief Sets the threshold for motion detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t threshold: Threshold value
*/
void mpu6050_set_motion_detection_threshold(struct mpu6050 *self, uint8_t threshold);
/**
* @brief Sets the duration for motion detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t duration: Duration value
*/
void mpu6050_set_motion_detection_duration(struct mpu6050 *self, uint8_t duration);
/**
* @brief Sets the threshold for zero motion detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t threshold: Threshold value
*/
void mpu6050_set_zero_motion_detection_threshold(struct mpu6050 *self, uint8_t threshold);
/**
* @brief Sets the duration for zero motion detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t duration: Duration value
*/
void mpu6050_set_zero_motion_detection_duration(struct mpu6050 *self, uint8_t duration);
/**
* @brief Sets the threshold for free fall detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t threshold: Threshold value
*/
void mpu6050_set_free_fall_detection_threshold(struct mpu6050 *self, uint8_t threshold);
/**
* @brief Sets the duration for free fall detection.
*
* @param mpu6050_t* self: Reference to itself
* @param uint8_t duration: Duration value
*/
void mpu6050_set_free_fall_detection_duration(struct mpu6050 *self, uint8_t duration);
#ifdef __cplusplus
}
#endif
#endifOtřesové čidlo MPU6050 examples_pico/MPU6050.c
#include "MPU6050.h"
#include "math.h"
#include "stdlib.h"
#define ACCEL_XOFFS_H 0x06
#define ACCEL_XOFFS_L 0x07
#define ACCEL_YOFFS_H 0x08
#define ACCEL_YOFFS_L 0x09
#define ACCEL_ZOFFS_H 0x0A
#define ACCEL_ZOFFS_L 0x0B
#define GYRO_XOFFS_H 0x13
#define GYRO_XOFFS_L 0x14
#define GYRO_YOFFS_H 0x15
#define GYRO_YOFFS_L 0x16
#define GYRO_ZOFFS_H 0x17
#define GYRO_ZOFFS_L 0x18
#define CONFIG 0x1A
#define GYRO_CONFIG 0x1B // Gyroscope Configuration
#define ACCEL_CONFIG 0x1C // Accelerometer Configuration
#define FF_THRESHOLD 0x1D
#define FF_DURATION 0x1E
#define MOT_THRESHOLD 0x1F
#define MOT_DURATION 0x20
#define ZMOT_THRESHOLD 0x21
#define ZMOT_DURATION 0x22
#define INT_PIN_CFG 0x37 // INT Pin. Bypass Enable Configuration
#define INT_ENABLE 0x38 // INT Enable
#define INT_STATUS 0x3A
#define ACCEL_XOUT_H 0x3B
#define ACCEL_XOUT_L 0x3C
#define ACCEL_YOUT_H 0x3D
#define ACCEL_YOUT_L 0x3E
#define ACCEL_ZOUT_H 0x3F
#define ACCEL_ZOUT_L 0x40
#define TEMP_OUT_H 0x41
#define TEMP_OUT_L 0x42
#define GYRO_XOUT_H 0x43
#define GYRO_XOUT_L 0x44
#define GYRO_YOUT_H 0x45
#define GYRO_YOUT_L 0x46
#define GYRO_ZOUT_H 0x47
#define GYRO_ZOUT_L 0x48
#define MOT_DETECT_STATUS 0x61
#define MOT_DETECT_CTRL 0x69
#define USER_CTRL 0x6A // User Control
#define PWR_MGMT_1 0x6B // Power Management 1
#define WHO_AM_I 0x75 // Who Am I
#define GRAVITY_CONSTANT 9.80665f
int i2c_read_reg(struct i2c_information *i2c, const uint8_t reg, uint8_t *buf, const size_t len)
{
i2c_write_blocking(i2c->instance, i2c->address, ®, 1, true);
return i2c_read_blocking(i2c->instance, i2c->address, buf, len, false);
}
int i2c_write(struct i2c_information *i2c, const uint8_t data)
{
return i2c_write_blocking(i2c->instance, i2c->address, &data, 1, false);
}
void read_raw_gyro(struct mpu6050 *self)
{
uint8_t data[6];
i2c_read_reg(&self->i2c, GYRO_XOUT_H, data, 6);
self->rg.x = data[0] << 8 | data[1];
self->rg.y = data[2] << 8 | data[3];
self->rg.z = data[4] << 8 | data[5];
}
void read_raw_accel(struct mpu6050 *self)
{
uint8_t data[6];
i2c_read_reg(&self->i2c, ACCEL_XOUT_H, data, 6);
self->ra.x = data[0] << 8 | data[1];
self->ra.y = data[2] << 8 | data[3];
self->ra.z = data[4] << 8 | data[5];
}
inline static void i2c_write_u16_inline(struct i2c_information *i2c, uint8_t reg, uint16_t value)
{
uint8_t data[3] = {reg, (value >> 8), (value & 0xFF)};
i2c_write_blocking(i2c->instance, i2c->address, data, 3, false);
}
inline static void i2c_write_bit_in_reg_inline(struct i2c_information *i2c, uint8_t reg, uint8_t pos, uint8_t state)
{
uint8_t reg_value;
i2c_read_reg(i2c, reg, ®_value, 1);
if (state)
{
reg_value |= (1 << pos);
}
else
{
reg_value &= ~(1 << pos);
}
uint8_t data[2] = {reg, reg_value};
i2c_write_blocking(i2c->instance, i2c->address, data, 2, false);
}
struct mpu6050 mpu6050_init(i2c_inst_t *i2c_instance, const uint8_t address)
{
struct mpu6050 mpu6050;
mpu6050.i2c.instance = i2c_instance;
mpu6050.i2c.address = address;
mpu6050.calibration_data.dg.x = 0;
mpu6050.calibration_data.dg.y = 0;
mpu6050.calibration_data.dg.z = 0;
mpu6050.config.use_calibrate = 0;
mpu6050.calibration_data.tg.x = 0;
mpu6050.calibration_data.tg.y = 0;
mpu6050.calibration_data.tg.z = 0;
mpu6050.config.actual_threshold = 0;
mpu6050.config.meas_temp = 0;
mpu6050.config.meas_acce = 0;
mpu6050.config.meas_gyro = 0;
return mpu6050;
}
uint8_t mpu6050_begin(struct mpu6050 *self)
{
if (mpu6050_who_am_i(self) != 0x68) // 0x68 default WHO_AM_I value
{
return 0;
}
mpu6050_set_clock_source(self, MPU6050_CLOCK_INTERNAL); // Default Clock
mpu6050_set_range(self, MPU6050_RANGE_4G); // Default Range
mpu6050_set_scale(self, MPU6050_SCALE_500DPS); // Default Scale
mpu6050_set_sleep_enabled(self, 0); // Disable Sleep Mode
return 1;
}
uint8_t mpu6050_event(struct mpu6050 *self)
{
self->rg.x = 0;
self->rg.y = 0;
self->rg.z = 0;
self->ra.x = 0;
self->ra.y = 0;
self->ra.z = 0;
self->ng.x = 0.0f;
self->ng.y = 0.0f;
self->ng.z = 0.0f;
self->na.x = 0.0f;
self->na.y = 0.0f;
self->na.z = 0.0f;
self->raw_temperature = 0;
self->temperature = 0.0f;
self->temperaturef = 0.0f;
if (self->config.meas_gyro)
{
read_raw_gyro(self);
}
if (self->config.meas_acce)
{
read_raw_accel(self);
}
if (self->config.meas_temp)
{
uint8_t data[2];
i2c_read_reg(&self->i2c, TEMP_OUT_H, data, 2);
self->raw_temperature = data[0] << 8 | data[1];
}
uint8_t int_status;
i2c_read_reg(&self->i2c, INT_STATUS, &int_status, 1);
self->activity.isOverflow = ((int_status >> 4) & 1);
self->activity.isFreefall = ((int_status >> 7) & 1);
self->activity.isInactivity = ((int_status >> 5) & 1);
self->activity.isActivity = ((int_status >> 6) & 1);
self->activity.isDataReady = ((int_status >> 8) & 1);
uint8_t mot_detect_status;
i2c_read_reg(&self->i2c, MOT_DETECT_STATUS, &mot_detect_status, 1);
self->activity.isNegActivityOnX = ((mot_detect_status >> 7) & 1);
self->activity.isPosActivityOnX = ((mot_detect_status >> 6) & 1);
self->activity.isNegActivityOnY = ((mot_detect_status >> 5) & 1);
self->activity.isPosActivityOnY = ((mot_detect_status >> 4) & 1);
self->activity.isNegActivityOnZ = ((mot_detect_status >> 3) & 1);
self->activity.isPosActivityOnZ = ((mot_detect_status >> 2) & 1);
}
void mpu6050_set_scale(struct mpu6050 *self, enum MPU6050_SCALE scale)
{
uint8_t gyro_config;
switch (scale)
{
case MPU6050_SCALE_250DPS:
self->config.dps_per_digit = .007633f;
break;
case MPU6050_SCALE_500DPS:
self->config.dps_per_digit = .015267f;
break;
case MPU6050_SCALE_1000DPS:
self->config.dps_per_digit = .030487f;
break;
case MPU6050_SCALE_2000DPS:
self->config.dps_per_digit = .060975f;
break;
}
i2c_read_reg(&self->i2c, GYRO_CONFIG, &gyro_config, 1);
gyro_config &= 0xE7;
gyro_config |= (scale << 3);
uint8_t data[2] = {GYRO_CONFIG, gyro_config};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_range(struct mpu6050 *self, enum MPU6050_RANGE range)
{
uint8_t accel_config;
switch (range)
{
case MPU6050_RANGE_2G:
self->config.range_per_digit = .000061f;
break;
case MPU6050_RANGE_4G:
self->config.range_per_digit = .000122f;
break;
case MPU6050_RANGE_8G:
self->config.range_per_digit = .000244f;
break;
case MPU6050_RANGE_16G:
self->config.range_per_digit = .0004882f;
break;
}
i2c_read_reg(&self->i2c, ACCEL_CONFIG, &accel_config, 1);
accel_config &= 0xE7;
accel_config |= (range << 3);
uint8_t data[2] = {ACCEL_CONFIG, accel_config};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_clock_source(struct mpu6050 *self, enum MPU6050_CLOCK_SOURCE clock_source)
{
uint8_t power_managment_1;
i2c_read_reg(&self->i2c, PWR_MGMT_1, &power_managment_1, 1);
power_managment_1 &= 0xF8;
power_managment_1 |= clock_source;
uint8_t data[2] = {PWR_MGMT_1, power_managment_1};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_sleep_enabled(struct mpu6050 *self, uint8_t state)
{
uint8_t data[2] = {PWR_MGMT_1};
if (state)
{
data[1] = 1;
}
else
{
data[1] = 0;
}
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
uint8_t mpu6050_who_am_i(struct mpu6050 *self)
{
uint8_t who_am_i;
i2c_read_reg(&self->i2c, WHO_AM_I, &who_am_i, 1);
return who_am_i;
}
void mpu6050_set_temperature_measuring(struct mpu6050 *self, uint8_t state)
{
if (state)
{
self->config.meas_temp = 1;
}
else
{
self->config.meas_temp = 0;
}
}
void mpu6050_set_accelerometer_measuring(struct mpu6050 *self, uint8_t state)
{
if (state)
{
self->config.meas_acce = 1;
}
else
{
self->config.meas_acce = 0;
}
}
void mpu6050_set_gyroscope_measuring(struct mpu6050 *self, uint8_t state)
{
if (state)
{
self->config.meas_gyro = 1;
}
else
{
self->config.meas_gyro = 0;
}
}
void mpu6050_calibrate_gyro(struct mpu6050 *self, uint8_t samples)
{
self->config.use_calibrate = 1;
float sumX = 0;
float sumY = 0;
float sumZ = 0;
float sigmaX = 0;
float sigmaY = 0;
float sigmaZ = 0;
for (uint8_t i = 0; i < samples; i++)
{
read_raw_gyro(self);
sumX += self->rg.x;
sumY += self->rg.y;
sumZ += self->rg.z;
sigmaX += self->rg.x * self->rg.x;
sigmaY += self->rg.y * self->rg.y;
sigmaZ += self->rg.z * self->rg.z;
sleep_ms(5);
}
self->calibration_data.dg.x = sumX / samples;
self->calibration_data.dg.y = sumY / samples;
self->calibration_data.dg.z = sumZ / samples;
self->calibration_data.th.x = sqrtf((sigmaX / samples) - (self->calibration_data.dg.x * self->calibration_data.dg.x));
self->calibration_data.th.y = sqrtf((sigmaY / samples) - (self->calibration_data.dg.y * self->calibration_data.dg.y));
self->calibration_data.th.z = sqrtf((sigmaZ / samples) - (self->calibration_data.dg.z * self->calibration_data.dg.z));
if (self->config.actual_threshold > 0)
{
mpu6050_set_threshold(self, 1);
}
}
void mpu6050_set_threshold(struct mpu6050 *self, uint8_t multiple)
{
if (multiple > 0)
{
if (!self->config.use_calibrate)
{
mpu6050_calibrate_gyro(self, 50);
}
self->calibration_data.tg.x = self->calibration_data.th.x * multiple;
self->calibration_data.tg.y = self->calibration_data.th.y * multiple;
self->calibration_data.tg.z = self->calibration_data.th.z * multiple;
}
else
{
self->calibration_data.tg.x = 0;
self->calibration_data.tg.y = 0;
self->calibration_data.tg.z = 0;
}
self->config.actual_threshold = multiple;
}
struct mpu6050_vectorf *mpu6050_get_scaled_accelerometer(struct mpu6050 *self)
{
if (self->sa.x != 0.0f || self->sa.y != 0.0f || self->sa.z != 0.0f)
{
return &self->sa;
}
else if (self->ra.x != 0 || self->ra.y != 0 || self->ra.z != 0)
{
self->sa.x = self->ra.x * self->config.range_per_digit;
self->sa.y = self->ra.y * self->config.range_per_digit;
self->sa.z = self->ra.z * self->config.range_per_digit;
return &self->sa;
}
return NULL;
}
struct mpu6050_vectorf *mpu6050_get_accelerometer(struct mpu6050 *self)
{
if (self->na.x != 0.0f || self->na.y != 0.0f || self->na.z != 0.0f)
{
return &self->na;
}
else if (self->ra.x != 0 || self->ra.y != 0 || self->ra.z != 0)
{
self->na.x = self->ra.x * self->config.range_per_digit * GRAVITY_CONSTANT;
self->na.y = self->ra.y * self->config.range_per_digit * GRAVITY_CONSTANT;
self->na.z = self->ra.z * self->config.range_per_digit * GRAVITY_CONSTANT;
return &self->na;
}
return NULL;
}
struct mpu6050_vectorf *mpu6050_get_gyroscope(struct mpu6050 *self)
{
if (self->ng.x != 0.0f || self->ng.y != 0.0f || self->ng.z != 0.0f)
{
return &self->ng;
}
else if (self->ra.x != 0 || self->ra.y != 0 || self->ra.z != 0)
{
if (self->config.use_calibrate)
{
self->ng.x = (self->rg.x - self->calibration_data.dg.x) * self->config.dps_per_digit;
self->ng.y = (self->rg.y - self->calibration_data.dg.y) * self->config.dps_per_digit;
self->ng.z = (self->rg.z - self->calibration_data.dg.z) * self->config.dps_per_digit;
}
else
{
self->ng.x = self->rg.x * self->config.dps_per_digit;
self->ng.y = self->rg.y * self->config.dps_per_digit;
self->ng.z = self->rg.z * self->config.dps_per_digit;
}
if (self->config.actual_threshold)
{
if (abs(self->ng.x) < self->calibration_data.tg.x)
self->ng.x = 0.0f;
if (abs(self->ng.y) < self->calibration_data.tg.y)
self->ng.y = 0.0f;
if (abs(self->ng.z) < self->calibration_data.tg.z)
self->ng.z = 0.0f;
}
return &self->ng;
}
return NULL;
}
float mpu6050_get_temperature_c(struct mpu6050 *self)
{
if (self->temperature != 0.0f)
{
return self->temperature;
}
else if (self->raw_temperature != 0)
{
self->temperature = (float)self->raw_temperature / 340 + 36.53f;
return self->temperature;
}
return 0.0f;
}
float mpu6050_get_temperature_f(struct mpu6050 *self)
{
if (self->temperaturef != 0.0f)
{
return self->temperaturef;
}
else if (mpu6050_get_temperature_c(self) != 0.0f)
{
self->temperaturef = (mpu6050_get_temperature_c(self) * 1.8) + 32;
return self->temperaturef;
}
return 0.0f;
}
void mpu6050_set_gyro_offset_x(struct mpu6050 *self, uint16_t offset)
{
i2c_write_u16_inline(&self->i2c, GYRO_XOFFS_H, offset);
}
void mpu6050_set_gyro_offset_y(struct mpu6050 *self, uint16_t offset)
{
i2c_write_u16_inline(&self->i2c, GYRO_YOFFS_H, offset);
}
void mpu6050_set_gyro_offset_z(struct mpu6050 *self, uint16_t offset)
{
i2c_write_u16_inline(&self->i2c, GYRO_ZOFFS_H, offset);
}
void mpu6050_set_accel_offset_x(struct mpu6050 *self, uint16_t offset)
{
i2c_write_u16_inline(&self->i2c, ACCEL_XOFFS_H, offset);
}
void mpu6050_set_accel_offset_y(struct mpu6050 *self, uint16_t offset)
{
i2c_write_u16_inline(&self->i2c, ACCEL_YOFFS_H, offset);
}
void mpu6050_set_accel_offset_z(struct mpu6050 *self, uint16_t offset)
{
i2c_write_u16_inline(&self->i2c, ACCEL_ZOFFS_H, offset);
}
struct mpu6050_activity *mpu6050_read_activities(struct mpu6050 *self)
{
return &self->activity;
}
void mpu6050_set_int_motion(struct mpu6050 *self, uint8_t state)
{
i2c_write_bit_in_reg_inline(&self->i2c, INT_ENABLE, 6, state);
}
void mpu6050_set_int_zero_motion(struct mpu6050 *self, uint8_t state)
{
i2c_write_bit_in_reg_inline(&self->i2c, INT_ENABLE, 5, state);
}
void mpu6050_set_int_free_fall(struct mpu6050 *self, uint8_t state)
{
i2c_write_bit_in_reg_inline(&self->i2c, INT_ENABLE, 7, state);
}
void mpu6050_set_dhpf_mode(struct mpu6050 *self, enum MPU6050_DHPF dhpf)
{
uint8_t value;
i2c_read_reg(&self->i2c, ACCEL_CONFIG, &value, 1);
value &= 0xF8;
value |= dhpf;
uint8_t data[2] = {ACCEL_CONFIG, value};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_dlpf_mode(struct mpu6050 *self, enum MPU6050_DLPF dlpf)
{
uint8_t value;
i2c_read_reg(&self->i2c, CONFIG, &value, 1);
value &= 0xF8;
value |= dlpf;
uint8_t data[2] = {CONFIG, value};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_motion_detection_threshold(struct mpu6050 *self, uint8_t threshold)
{
uint8_t data[2] = {MOT_THRESHOLD, threshold};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_motion_detection_duration(struct mpu6050 *self, uint8_t duration)
{
uint8_t data[2] = {MOT_DURATION, duration};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_zero_motion_detection_threshold(struct mpu6050 *self, uint8_t threshold)
{
uint8_t data[2] = {ZMOT_THRESHOLD, threshold};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_zero_motion_detection_duration(struct mpu6050 *self, uint8_t duration)
{
uint8_t data[2] = {ZMOT_DURATION, duration};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_free_fall_detection_threshold(struct mpu6050 *self, uint8_t threshold)
{
uint8_t data[2] = {FF_THRESHOLD, threshold};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}
void mpu6050_set_free_fall_detection_duration(struct mpu6050 *self, uint8_t duration)
{
uint8_t data[2] = {FF_DURATION, duration};
i2c_write_blocking(self->i2c.instance, self->i2c.address, data, 2, false);
}Vysílač s otřesovým čidlem examples_pico/hlidac_vysilac.cpp
/* hlidac_vysilac.cpp
* vysílač nRF24L01+ pro hlídač s pohybovým čidlem MPU6050
* (c) Jirka Chráska 2026, jirka@lixis.cz
* BSD 3 clause licence
*/
#include "stdio.h"
#include <math.h>
#include "pico/stdlib.h" // printf(), sleep_ms(), getchar_timeout_us(), to_us_since_boot(), get_absolute_time()
#include "pico/bootrom.h" // reset_usb_boot()
#include <tusb.h> // tud_cdc_connected()
#include <RF24.h> // RF24 radio objekt
#include "defaultPins.h" // konfigurace pinů
#include "MPU6050.h"
// pokud se čísla h1 a h2 neliší od sebe o toleranci, vrací false, pokud se liší vrací true
bool porovnej_s_toleranci( int h1, int h2, int tolerance )
{
if( h1 == h2) return false;
if( h1+tolerance >= h2 && h1-tolerance <= h2 ) return false;
return true;
}
// konfigurace pohybového čidla MPU5060
#define I2C_SDA_PIN 4
#define I2C_SCL_PIN 5
void init_i2c()
{
gpio_init(PICO_DEFAULT_I2C_SDA_PIN);
gpio_init(PICO_DEFAULT_I2C_SCL_PIN);
gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);
gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);
gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);
gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);
}
// konfigurace vysílače nRF24L01
RF24 radio(CE_PIN, CSN_PIN);
// role radia
bool role = true; // true = vysílač, false = přijímač
// payload se posílá na druhý konec
// pokud je payload 0.0 tak nastal pohyb
float payload = 10.0;
// nastavení LED
#define LED_PIN 2
#define DLED_PIN 25
#define POHYB_PIN 22
#define TL_PIN 15
bool pohyb = false;
// instance otřesového čidla
mpu6050_t mpu6050;
// ----------------------------------------------------------------------------------------
// nastavení pohybového čidla, LED a radia
bool setup()
{
// názvy radií
uint8_t address[][6] = {"1Node", "2Node"};
bool radioNumber = 0; // 0 uses address[0] pro vysílání, 1 uses address[1] pro vysílání
// debugging: čekáme na sériovou linku přes USB
// while (!tud_cdc_connected()) {
// sleep_ms(10);
// }
printf("Vysílač s otřesovým čidlem.\n");
// incializace LED a tlačítka
gpio_set_function(LED_PIN,GPIO_FUNC_SIO);
gpio_set_dir(LED_PIN,GPIO_OUT);
gpio_put(LED_PIN,1);
sleep_ms(200);
gpio_put(LED_PIN,0);
gpio_set_function(DLED_PIN,GPIO_FUNC_SIO);
gpio_set_dir(DLED_PIN,GPIO_OUT);
gpio_put(DLED_PIN,1);
sleep_ms(200);
gpio_put(DLED_PIN,0);
gpio_set_function(POHYB_PIN,GPIO_FUNC_SIO);
gpio_set_dir(POHYB_PIN,GPIO_OUT);
gpio_put(POHYB_PIN,1);
sleep_ms(200);
gpio_put(POHYB_PIN,0);
gpio_set_function(TL_PIN,GPIO_FUNC_SIO);
gpio_set_dir(TL_PIN,GPIO_IN);
gpio_pull_down(TL_PIN);
// inicializace otřesového čidla MPU6050
init_i2c();
mpu6050 = mpu6050_init(i2c_default, MPU6050_ADDRESS_A0_VCC);
// test zda MPU6050 funguje
if (mpu6050_begin(&mpu6050))
{
// nastavení citlivosti gyroskopu
mpu6050_set_scale(&mpu6050, MPU6050_SCALE_250DPS);
// Set range of accelerometer
mpu6050_set_range(&mpu6050, MPU6050_RANGE_2G);
// digital highpass filtr
mpu6050_set_dhpf_mode(&mpu6050, MPU6050_DHPF_0_63HZ);
// Enable temperature, gyroscope and accelerometer readings
mpu6050_set_temperature_measuring(&mpu6050, false);
mpu6050_set_gyroscope_measuring(&mpu6050, false);
mpu6050_set_accelerometer_measuring(&mpu6050, true);
// Enable free fall, motion and zero motion interrupt flags
mpu6050_set_int_free_fall(&mpu6050, true);
mpu6050_set_int_motion(&mpu6050, true);
mpu6050_set_int_zero_motion(&mpu6050, true);
// Set motion detection threshold and duration
mpu6050_set_motion_detection_threshold(&mpu6050, 1);
mpu6050_set_motion_detection_duration(&mpu6050, 20);
// Set zero motion detection threshold and duration
mpu6050_set_zero_motion_detection_threshold(&mpu6050, 4);
mpu6050_set_zero_motion_detection_duration(&mpu6050, 2);
}
else
{
printf("MPU6050 hardware nefunguje!\n");
gpio_put(DLED_PIN,1);
return false;
}
printf("MPU6050 čidlo inicializováno.\n");
// inicializace radia na SPI sběrnici
if (!radio.begin()) {
printf("nRF24L01+ radio hardware nefunguje!\n");
gpio_put(DLED_PIN,1);
return false;
}
gpio_put(DLED_PIN,0);
printf("Radio inicializováno.\n");
// nastavení vysílacího výkonu
radio.setPALevel(RF24_PA_MAX); // RF24_PA_LOW je pro testování.
// Nastavení rychlosti přenosu na 1Mbit/s
radio.setDataRate(RF24_1MBPS);
// šetříme radio pásmo a dobu doručení, budeme posílat float (4 byty)
radio.setPayloadSize(sizeof(payload));
// nastavení vysílací adresy pro přijímač TX pipe (pipe 0)
radio.stopListening(address[radioNumber]);
// nastavení přijímací adresy pro vysílač
// a vysílací na RX pipe
radio.openReadingPipe(1, address[!radioNumber]); // pipe 1
// nastavení role radia
if (role) {
radio.stopListening(); // radio do TX režimu
}
else {
radio.startListening(); // radio do RX režimu
}
return true;
}
// ----------------------------------------------------------------------------------------
// smyčka, co beží neustále
void loop()
{
static int x,y,z, ox,oy,oz;
static int i, j;
// získání dat z MPU605, I2C se používá jenom zde
mpu6050_event(&mpu6050);
// Pointers to float vectors with all the results
mpu6050_vectorf_t *accel = mpu6050_get_accelerometer(&mpu6050);
mpu6050_vectorf_t *gyro = mpu6050_get_gyroscope(&mpu6050);
// Activity struct holding all interrupt flags
mpu6050_activity_t *activities = mpu6050_read_activities(&mpu6050);
// Rough temperatures as float -- Keep in mind, this is not a temperature sensor!!!
float tempC = mpu6050_get_temperature_c(&mpu6050);
float tempF = mpu6050_get_temperature_f(&mpu6050);
x = round(accel->x*10);
y = round(accel->y*10);
z = round(accel->z*10);
// tisk měření pro nastavení citlivosti
// printf("Accelerometer: %d, %d, %d Overflow: %d - Freefall: %d - Inactivity: %d, "
// "Activity: %d, DataReady: %d PosX: %d - NegX: %d -- PosY: %d - NegY: %d "
// "-- PosZ: %d - NegZ: %d 22=%d , i=%d\r", x, y, z,
// activities->isOverflow,
// activities->isFreefall,
// activities->isInactivity,
// activities->isActivity,
// activities->isDataReady,
// activities->isPosActivityOnX,
// activities->isNegActivityOnX,
// activities->isPosActivityOnY,
// activities->isNegActivityOnY,
// activities->isPosActivityOnZ,
// activities->isNegActivityOnZ,
// pohyb,
// i);
// I když je čidlo v klidu, tak se hodnoty naměřené akcelerometrem malinko od sebe liší
// Toto malinko je tolerance.
// Porovnáváme předchozí hodnotu akcelerometru se současnou hodnotou
// i > 20 dělá prodlevu při zapnutí
printf("x=%d, y=%d, z=%d: ox=%d, oy=%d, oz=%d: i=%d\n", x,y,z,ox,oy,oz,i);
if(i>100 && ( porovnej_s_toleranci(x, ox, 2) || porovnej_s_toleranci(y, oy, 2) || porovnej_s_toleranci(z, oz, 2)) ) {
pohyb = true; // zaznamenali jsme pohyb předmětu
printf("Pohyb\n");
j = i;
payload = 0.0;
} else {
pohyb = false; // předmět je v klidu
printf("V klidu.\n");
}
gpio_put(POHYB_PIN,pohyb);
mpu6050_set_sleep_enabled(&mpu6050, false);
sleep_ms(180);
mpu6050_set_sleep_enabled(&mpu6050, true);
sleep_ms(20);
ox = x; oy = y; oz = z;
i++;
// tlačítko zmáčknuto
if( gpio_get(TL_PIN) ) {
payload = 0.0;
}
if (role) {
// vysílač
uint64_t start_timer = to_us_since_boot(get_absolute_time()); // start the timer
bool report = radio.write(&payload, sizeof(payload)); // transmit & save the report
uint64_t end_timer = to_us_since_boot(get_absolute_time()); // end the timer
if (report) {
gpio_put(LED_PIN,1);
// přidáváme do payloudu
payload += 0.01;
}
else {
// payload nebyl doručen
gpio_put(LED_PIN,0);
}
sleep_ms(500); // zpomalíme vysílání na 0.5 sekundy
gpio_put(LED_PIN,0);
}
}
// ----------------------------------------------------------------------------------------
int main()
{
stdio_init_all(); // std input a output RP2040
while (!setup()) { // pokud radio nebo čidlo nefunguje
gpio_put(DLED_PIN,1);
sleep_ms(200);
gpio_put(DLED_PIN,0);
sleep_ms(200);
}
while (true) {
loop();
}
return 0;
}
// ----------------------------------------------------------------------------------------Přijímač se sirénou examples_pico/hlidac_prijimac.cpp
/* hlidac_prijimac.cpp
* přijímač nRF24L01+ pro hlídač s pohybovým čidlem MPU6050
* (c) Jirka Chráska 2026, jirka@lixis.cz
* BSD 3 clause licence
*/
#include "pico/stdlib.h" // printf(), sleep_ms(), getchar_timeout_us(), to_us_since_boot(), get_absolute_time()
#include "pico/bootrom.h" // reset_usb_boot()
#include <tusb.h> // tud_cdc_connected()
#include <RF24.h> // RF24 radio object
#include "defaultPins.h" // konfigurace pinů
// instance objektu a konfigurace radia nRF24L01
RF24 radio(CE_PIN, CSN_PIN);
// role radia
bool role = false; // true = vysílač (TX), false = přijímač (RX)
// pokud je payload 0.0 tak nastal pohyb
float payload = 10.0;
float payload_old = 10.1;
// nastavení LED
#define LED_PIN 2
#define DLED_PIN 25
bool stav = true;
#include "hardware/pwm.h"
#define PIN_BZUCAK 15
// ----------------------------------------------------------------------------------------
// Funkce pro zvuk sirény
uint slice_num;
void hraj_ton(uint frekvence)
{
if (frekvence == 0) {
pwm_set_gpio_level(PIN_BZUCAK, 0);
return;
}
slice_num = pwm_gpio_to_slice_num(PIN_BZUCAK);
uint32_t clock = 125000000;
uint32_t divider = clock / (frekvence * 4096) + 1;
uint32_t top = clock / (divider * frekvence) - 1;
pwm_set_clkdiv(slice_num, divider);
pwm_set_wrap(slice_num, top);
pwm_set_gpio_level(PIN_BZUCAK, top / 2);
}
// pro pohyb chráněného předmětu
void sirena()
{
hraj_ton(600);
sleep_ms(80);
hraj_ton(500);
sleep_ms(80);
hraj_ton(450);
sleep_ms(80);
hraj_ton(0);
}
// pro ztrátu signálu
void sirena2()
{
hraj_ton(400);
sleep_ms(180);
hraj_ton(800);
sleep_ms(180);
hraj_ton(400);
sleep_ms(180);
hraj_ton(0);
}
// ----------------------------------------------------------------------------------------
bool setup()
{
// názvy radií
uint8_t address[][6] = {"1Node", "2Node"};
bool radioNumber = 1; // 0 je address[0] pro vysílání, 1 je address[1] pro vysílání
// debugging: čekáme na sériovou linku přes USB
// while (!tud_cdc_connected()) {
// sleep_ms(10);
// }
// inicializace radia na SPI sběrnici
if (!radio.begin()) {
printf("radio hardware is not responding!!\n");
gpio_put(DLED_PIN,1);
return false;
}
gpio_put(DLED_PIN,0);
printf("Přijímač.\n");
// nastavení vysílacího výkonu
radio.setPALevel(RF24_PA_MAX); // RF24_PA_MAX je default.
// Nastavení rychlosti přenosu na 1Mbit/s
radio.setDataRate(RF24_1MBPS);
// šetříme radio pásmo a dobu doručení, budeme posílat float (4 byty)
radio.setPayloadSize(sizeof(payload)); // float datatype occupies 4 bytes
// set the TX address of the RX node for use on the TX pipe (pipe 0)
radio.stopListening(address[radioNumber]);
// set the RX address of the TX node into a RX pipe
radio.openReadingPipe(1, address[!radioNumber]); // using pipe 1
if (role) {
radio.stopListening(); // radio do TX režimu
}
else {
radio.startListening(); // radio do RX režimu
}
return true;
}
// ----------------------------------------------------------------------------------------
void loop()
{
// zařízení v přijímacím režimu (RX node)
uint8_t pipe;
static long i = 0;
if (radio.available(&pipe)) { // je něco k příjmu? získáme rouru a přijmeme
uint8_t bytes = radio.getPayloadSize(); // velikost dat payload
radio.read(&payload, bytes); // vezmeme payload z FIFO
}
if( payload < 0.2) {
gpio_put(LED_PIN,1);
sirena();
} else {
gpio_put(LED_PIN,0);
}
// test ztráty spojení s vysílačem
if( i%60000 == 0 ) {
if(payload_old != payload ) {
gpio_put(DLED_PIN,0);
} else { // neslyšíme vysílač
sirena2();
gpio_put(DLED_PIN,1);
}
payload_old = payload;
}
i++;
}
// ----------------------------------------------------------------------------------------
int main(void)
{
stdio_init_all(); // stdio pro RP2040
gpio_set_function(LED_PIN,GPIO_FUNC_SIO);
gpio_set_dir(LED_PIN,GPIO_OUT);
gpio_put(LED_PIN,1);
sleep_ms(200);
gpio_put(LED_PIN,0);
gpio_set_function(DLED_PIN,GPIO_FUNC_SIO);
gpio_set_dir(DLED_PIN,GPIO_OUT);
gpio_put(DLED_PIN,1);
sleep_ms(200);
gpio_put(DLED_PIN,0);
// nastavení bzučáku
gpio_set_function(PIN_BZUCAK, GPIO_FUNC_PWM);
uint slice_num = pwm_gpio_to_slice_num(PIN_BZUCAK);
pwm_set_enabled(slice_num, true);
while (!setup()) { // pokud radio nefunguje
gpio_put(DLED_PIN,1);
sleep_ms(200);
gpio_put(DLED_PIN,0);
sleep_ms(200);
}
while (true) {
loop();
}
return 0;
}
// ----------------------------------------------------------------------------------------Konfigurace pinů pro nRF24L01+ radio jednotku examples_pico/defaultPins.h
// pre-chosen pins for different boards
#ifndef DEFAULTPINS_H
#define DEFAULTPINS_H
#if defined(ADAFRUIT_QTPY_RP2040)
// for this board, you can still use the Stemma QT connector as a separate I2C bus (`i2c1`)
#define CE_PIN PICO_DEFAULT_I2C_SDA_PIN // the pin labeled SDA
#define CSN_PIN PICO_DEFAULT_I2C_SCL_PIN // the pin labeled SCL
#define IRQ_PIN PICO_DEFAULT_UART_RX_PIN // the pin labeled RX
#elif defined(PIMORONI_TINY2040)
// default SPI_SCK_PIN = 6
// default SPI_TX_PIN = 7
// default SPI_RX_PIN = 4
#define CE_PIN PICO_DEFAULT_I2C_SCL_PIN // pin 3
#define CSN_PIN PICO_DEFAULT_SPI_CSN_PIN // pin 5
#define IRQ_PIN PICO_DEFAULT_I2C_SDA_PIN // pin 2
#elif defined(SPARFUN_THINGPLUS)
#define CSN_PIN 16 // the pin labeled 16
#define CE_PIN 7 // the pin labeled SCL
#define IRQ_PIN 6 // the pin labeled SDA
#else
// pins available on (ADAFRUIT_ITSYBITSY_RP2040 || ADAFRUIT_FEATHER_RP2040 || Pico_board || Sparkfun_ProMicro || SparkFun MicroMod)
#define CE_PIN 20
#define CSN_PIN 17
#define IRQ_PIN 21
#endif // board detection macro defs
#endif // DEFAULTPINS_HSestavení projektu
mkdir hlidac_radio
cd hlidac_radio
# rozbalit hlidac_radio.tar.gz
tar xvzf hlidac_radio.tar.gz
mkdir build
cd build
cmake ../examples_pico/ -DCMAKE_BUILD_TYPE=Release -DPICO_BOARD=pico
make -j8Knihovna RF24
Projekt používá jenom některé části z knihovny RF24.
Získání knihovny RF24
git clone https://github.com/nRF24/RF24CMakeLists.txt pro knihovnu CMakeLists.txt
# Check if we are building a pico-sdk based project
# (or more exactly: if we just got included in a pico-sdk based project)
if (PICO_SDK_PATH)
# If so, load the relevant CMakeLists-file but don't do anything else
include(${CMAKE_CURRENT_LIST_DIR}/utility/rp2/CMakeLists.txt)
return()
endif()
cmake_minimum_required(VERSION 3.15)
# generate a compilation database for static analysis by clang-tidy
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Set the project name to your project name
project(RF24 C CXX)
include(${CMAKE_CURRENT_LIST_DIR}/cmake/StandardProjectSettings.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/cmake/PreventInSourceBuilds.cmake)
# get library info from Arduino IDE's required library.properties file
include(${CMAKE_CURRENT_LIST_DIR}/cmake/GetLibInfo.cmake)
# allow CMake CLI options to configure RF24_config.h macros
option(RF24_DEBUG "enable/disable debugging output" OFF)
option(MINIMAL "exclude optional source code to keep compile size compact" OFF)
# Link this 'library' to set the c++ standard / compile-time options requested
add_library(${LibTargetName}_project_options INTERFACE)
target_compile_features(${LibTargetName}_project_options INTERFACE cxx_std_17)
add_compile_options(-Ofast -Wall -pthread)
if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
option(ENABLE_BUILD_WITH_TIME_TRACE "Enable -ftime-trace to generate time tracing .json files on clang" OFF)
if(ENABLE_BUILD_WITH_TIME_TRACE)
add_compile_definitions(${LibTargetName}_project_options INTERFACE -ftime-trace)
endif()
endif()
# Link this 'library' to use the warnings specified in CompilerWarnings.cmake
add_library(${LibTargetName}_project_warnings INTERFACE)
# enable cache system
include(${CMAKE_CURRENT_LIST_DIR}/cmake/Cache.cmake)
# standard compiler warnings
include(${CMAKE_CURRENT_LIST_DIR}/cmake/CompilerWarnings.cmake)
set_project_warnings(${LibTargetName}_project_warnings)
# sanitizer options if supported by compiler
include(${CMAKE_CURRENT_LIST_DIR}/cmake/Sanitizers.cmake)
enable_sanitizers(${LibTargetName}_project_options)
# allow for static analysis options
include(${CMAKE_CURRENT_LIST_DIR}/cmake/StaticAnalyzers.cmake)
option(BUILD_SHARED_LIBS "Enable compilation of shared libraries" OFF)
option(ENABLE_TESTING "Enable Test Builds" OFF) # for end-user projects
option(ENABLE_FUZZING "Enable Fuzzing Builds" OFF) # for end-user projects
if(ENABLE_TESTING)
enable_testing()
message("Building Tests.")
add_subdirectory(test) # directory doesn't exist, so this does nothing.
endif()
if(ENABLE_FUZZING)
message("Building Fuzz Tests, using fuzzing sanitizer https://www.llvm.org/docs/LibFuzzer.html")
add_subdirectory(fuzz_test) # directory doesn't exist, so this does nothing.
endif()
#####################################
### Now we actually build the library
#####################################
# detect the CPU make and type
include(${CMAKE_CURRENT_LIST_DIR}/cmake/detectCPU.cmake) # sets the variable SOC accordingly
# auto-detect what driver to use
# auto-detect can be overridden using `cmake .. -D RF24_DRIVER=<supported driver>`
include(${CMAKE_CURRENT_LIST_DIR}/cmake/AutoConfig_RF24_DRIVER.cmake)
#[[ adding the utility sub-directory will
1. set variables RF24_DRIVER, RF24_LINKED_DRIVER, and RF24_DRIVER_SOURCES
2. copy the appropriate /utility/*/includes.h file to the /utility folder
3. set additional install rules according to the RF24_DRIVER specified
]]
add_subdirectory(utility)
# setup CPack options
# package dependencies are resolved correctly only after utility subdirectory is added
include(${CMAKE_CURRENT_LIST_DIR}/cmake/CPackInfo.cmake)
add_library(${LibTargetName} SHARED
RF24.cpp
${RF24_DRIVER_SOURCES}
)
target_include_directories(${LibTargetName} PUBLIC utility)
set_target_properties(
${LibTargetName}
PROPERTIES
SOVERSION ${${LibName}_VERSION_MAJOR}
VERSION ${${LibName}_VERSION_STRING}
)
if(NOT "${RF24_LINKED_DRIVER}" STREQUAL "") # linking to a pre-compiled utility driver
message(STATUS "Using utility library: ${RF24_LINKED_DRIVER}")
target_link_libraries(${LibTargetName} INTERFACE
${LibTargetName}_project_options
${LibTargetName}_project_warnings
STATIC RF24_LINKED_DRIVER
)
else() # utility driver is compiled with the library - not linking to a pre-compiled utility driver
target_link_libraries(${LibTargetName} INTERFACE
${LibTargetName}_project_options
${LibTargetName}_project_warnings
)
endif()
# assert the appropriate preprocessor macros for RF24_config.h
if(RF24_DEBUG)
message(STATUS "RF24_DEBUG asserted")
target_compile_definitions(${LibTargetName} PUBLIC RF24_DEBUG)
endif()
if(MINIMAL)
message(STATUS "MINIMAL asserted")
target_compile_definitions(${LibTargetName} PUBLIC MINIMAL)
endif()
# for RF24_POWERUP_DELAY & RF24_SPI_SPEED, let the default be configured in source code
if(DEFINED RF24_POWERUP_DELAY)
message(STATUS "RF24_POWERUP_DELAY set to ${RF24_POWERUP_DELAY}")
target_compile_definitions(${LibTargetName} PUBLIC
RF24_POWERUP_DELAY=${RF24_POWERUP_DELAY}
)
endif()
if(DEFINED RF24_SPI_SPEED)
message(STATUS "RF24_SPI_SPEED set to ${RF24_SPI_SPEED}")
target_compile_definitions(${LibTargetName} PUBLIC
RF24_SPI_SPEED=${RF24_SPI_SPEED}
)
endif()
# allow user customization of default GPIO chip used with the SPIDEV driver
if(DEFINED RF24_LINUX_GPIO_CHIP)
message(STATUS "RF24_LINUX_GPIO_CHIP set to ${RF24_LINUX_GPIO_CHIP}")
target_compile_definitions(${LibTargetName} PUBLIC
RF24_LINUX_GPIO_CHIP="${RF24_LINUX_GPIO_CHIP}"
)
endif()
#####################################
### Install rules for root source dir
### There are separate install rules defined for each utility driver
### Installing the library requires sudo privileges
#####################################
install(TARGETS ${LibTargetName}
DESTINATION lib
)
install(FILES
RF24.h
nRF24L01.h
printf.h
RF24_config.h
DESTINATION include/RF24
)
install(FILES
utility/includes.h
DESTINATION include/RF24/utility
)
# CMAKE_CROSSCOMPILING is only TRUE when CMAKE_TOOLCHAIN_FILE is specified via CLI
if("${CMAKE_CROSSCOMPILING}" STREQUAL "FALSE")
install(CODE "message(STATUS \"Updating ldconfig\")")
install(CODE "execute_process(COMMAND ldconfig)")
endif()Konfigurace knihovny RF24_config.h
/*
Copyright (C)
2011 J. Coliz <maniacbug@ymail.com>
2015-2019 TMRh20
2015 spaniakos <spaniakos@gmail.com>
2015 nerdralph
2015 zador-blood-stained
2016 akatran
2017-2019 Avamander <avamander@gmail.com>
2019 IkpeohaGodson
2021 2bndy5
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
*/
#ifndef RF24_CONFIG_H_
#define RF24_CONFIG_H_
/*** USER DEFINES: ***/
#define FAILURE_HANDLING
//#define RF24_DEBUG
//#define MINIMAL
//#define SPI_UART // Requires library from https://github.com/TMRh20/Sketches/tree/master/SPI_UART
//#define SOFTSPI // Requires library from https://github.com/greiman/DigitalIO
/**
* User access to internally used delay time (in microseconds) during RF24::powerUp()
* @warning This default value compensates for all supported hardware. Only adjust this if you
* know your radio's hardware is, in fact, genuine and reliable.
*/
#if !defined(RF24_POWERUP_DELAY)
#define RF24_POWERUP_DELAY 5000
#endif
/**********************/
#define rf24_max(a, b) ((a) > (b) ? (a) : (b))
#define rf24_min(a, b) ((a) < (b) ? (a) : (b))
/** @brief The default SPI speed (in Hz) */
#ifndef RF24_SPI_SPEED
#define RF24_SPI_SPEED 10000000
#endif
//ATXMega
#if defined(__AVR_ATxmega64D3__) || defined(__AVR_ATxmega128D3__) || defined(__AVR_ATxmega192D3__) || defined(__AVR_ATxmega256D3__) || defined(__AVR_ATxmega384D3__)
// In order to be available both in Windows and Linux this should take presence here.
#define XMEGA
#define XMEGA_D3
#include "utility/ATXMegaD3/RF24_arch_config.h"
// RaspberryPi rp2xxx-based devices (e.g. RPi Pico board)
#elif defined(PICO_BUILD) && !defined(ARDUINO)
#include "utility/rp2/RF24_arch_config.h"
#define sprintf_P sprintf
#elif (!defined(ARDUINO)) // Any non-arduino device is handled via configure/Makefile
// The configure script detects device and copies the correct includes.h file to /utility/includes.h
// This behavior can be overridden by calling configure with respective parameters
// The includes.h file defines either RF24_RPi, MRAA, LITTLEWIRE or RF24_SPIDEV and includes the correct RF24_arch_config.h file
#include "utility/includes.h"
#ifndef sprintf_P
#define sprintf_P sprintf
#endif // sprintf_P
//ATTiny
#elif defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) || defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny2313__) || defined(__AVR_ATtiny4313__) || defined(__AVR_ATtiny861__) || defined(__AVR_ATtinyX5__) || defined(__AVR_ATtinyX4__) || defined(__AVR_ATtinyX313__) || defined(__AVR_ATtinyX61__)
#define RF24_TINY
#include "utility/ATTiny/RF24_arch_config.h"
#elif defined(LITTLEWIRE) //LittleWire
#include "utility/LittleWire/RF24_arch_config.h"
#elif defined(TEENSYDUINO) //Teensy
#include "utility/Teensy/RF24_arch_config.h"
#else //Everything else
#include <Arduino.h>
#ifdef NUM_DIGITAL_PINS
#if NUM_DIGITAL_PINS < 255
typedef uint8_t rf24_gpio_pin_t;
#define RF24_PIN_INVALID 0xFF
#else
typedef uint16_t rf24_gpio_pin_t;
#define RF24_PIN_INVALID 0xFFFF
#endif
#else
typedef uint16_t rf24_gpio_pin_t;
#define RF24_PIN_INVALID 0xFFFF
#endif
#if defined(ARDUINO) && !defined(__arm__) && !defined(__ARDUINO_X86__)
#if defined SPI_UART
#include <SPI_UART.h>
#define _SPI uspi
#elif defined(SOFTSPI)
// change these pins to your liking
//
#ifndef SOFT_SPI_MISO_PIN
#define SOFT_SPI_MISO_PIN 9
#endif // SOFT_SPI_MISO_PIN
#ifndef SOFT_SPI_MOSI_PIN
#define SOFT_SPI_MOSI_PIN 8
#endif // SOFT_SPI_MOSI_PIN
#ifndef SOFT_SPI_SCK_PIN
#define SOFT_SPI_SCK_PIN 7
#endif // SOFT_SPI_SCK_PIN
const uint8_t SPI_MODE = 0;
#define _SPI spi
#elif defined(ARDUINO_SAM_DUE)
#include <SPI.h>
#define _SPI SPI
#else // !defined (SPI_UART) && !defined (SOFTSPI)
#include <SPI.h>
#define _SPI SPIClass
#define RF24_SPI_PTR
#endif // !defined (SPI_UART) && !defined (SOFTSPI)
#else // !defined(ARDUINO) || defined (__arm__) || defined (__ARDUINO_X86__)
// Define _BV for non-Arduino platforms and for Arduino DUE
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#if defined(__arm__) || defined(__ARDUINO_X86__)
#if defined(__arm__) && defined(SPI_UART)
#include <SPI_UART.h>
#define _SPI uspi
#else // !defined (__arm__) || !defined (SPI_UART)
#include <SPI.h>
#define _SPI SPIClass
#define RF24_SPI_PTR
#endif // !defined (__arm__) || !defined (SPI_UART)
#elif !defined(__arm__) && !defined(__ARDUINO_X86__)
// fallback to unofficially supported Hardware (courtesy of ManiacBug)
extern HardwareSPI SPI;
#define _SPI HardwareSPI
#define RF24_SPI_PTR
#endif // !defined(__arm__) && !defined (__ARDUINO_X86__)
#ifndef _BV
#define _BV(x) (1 << (x))
#endif
#endif // defined (ARDUINO) && !defined (__arm__) && !defined (__ARDUINO_X86__)
#ifdef RF24_DEBUG
#define IF_RF24_DEBUG(x) ({ x; })
#else
#define IF_RF24_DEBUG(x)
#if defined(RF24_TINY)
#define printf_P(...)
#endif // defined(RF24_TINY)
#endif // RF24_DEBUG
#if defined(__ARDUINO_X86__)
#define printf_P printf
#define _BV(bit) (1 << (bit))
#endif // defined (__ARDUINO_X86__)
// Progmem is Arduino-specific
#if defined(ARDUINO_ARCH_ESP8266) || defined(ESP32) || (defined(ARDUINO_ARCH_RP2040) && !defined(ARDUINO_ARCH_MBED))
#include <pgmspace.h>
#define PRIPSTR "%s"
#ifndef pgm_read_ptr
#define pgm_read_ptr(p) (*(void* const*)(p))
#endif
// Serial.printf() is no longer defined in the unifying Arduino/ArduinoCore-API repo
// Serial.printf() is defined if using the arduino-pico/esp32/8266 repo
#if defined(ARDUINO_ARCH_ESP32) // do not `undef` when using the espressif SDK only
#undef printf_P // needed for ESP32 core
#endif
#define printf_P Serial.printf
#elif defined(ARDUINO) && !defined(ESP_PLATFORM) && !defined(__arm__) && !defined(__ARDUINO_X86__) || defined(XMEGA)
#include <avr/pgmspace.h>
#define PRIPSTR "%S"
#else // !defined (ARDUINO) || defined (ESP_PLATFORM) || defined (__arm__) || defined (__ARDUINO_X86__) && !defined (XMEGA)
#if !defined(ARDUINO) // This doesn't work on Arduino DUE
typedef char const char;
#else // Fill in pgm_read_byte that is used
#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_SAM_DUE)
#include <avr/pgmspace.h> // added to ArduinoCore-sam (Due core) in 2013
#endif
// Since the official arduino/ArduinoCore-samd repo switched to a unified API in 2016,
// Serial.printf() is no longer defined in the unifying Arduino/ArduinoCore-API repo
#if defined(ARDUINO_ARCH_SAMD) && defined(ARDUINO_SAMD_ADAFRUIT)
// it is defined if using the adafruit/ArduinoCore-samd repo
#define printf_P Serial.printf
#endif // defined (ARDUINO_ARCH_SAMD)
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char*)(addr))
#endif
#endif // !defined (ARDUINO)
#ifndef prog_uint16_t
typedef uint16_t prog_uint16_t;
#endif
#ifndef PSTR
#define PSTR(x) (x)
#endif
#ifndef printf_P
#define printf_P printf
#endif
#ifndef strlen_P
#define strlen_P strlen
#endif
#ifndef PROGMEM
#define PROGMEM
#endif
#ifndef pgm_read_word
#define pgm_read_word(p) (*(const unsigned short*)(p))
#endif
#if !defined pgm_read_ptr || defined ARDUINO_ARCH_MBED
#define pgm_read_ptr(p) (*(void* const*)(p))
#endif
#ifndef PRIPSTR
#define PRIPSTR "%s"
#endif
#endif // !defined (ARDUINO) || defined (ESP_PLATFORM) || defined (__arm__) || defined (__ARDUINO_X86__) && !defined (XMEGA)
#endif //Everything else
#if defined(SPI_HAS_TRANSACTION) && !defined(SPI_UART) && !defined(SOFTSPI)
#define RF24_SPI_TRANSACTIONS
#endif // defined (SPI_HAS_TRANSACTION) && !defined (SPI_UART) && !defined (SOFTSPI)
#endif // RF24_CONFIG_H_Hlavičkový soubor RF24.h
/*
Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
*/
/**
* @file RF24.h
*
* Class declaration for RF24 and helper enums
*/
#ifndef RF24_H_
#define RF24_H_
#include "RF24_config.h"
#if defined(RF24_LINUX) || defined(LITTLEWIRE)
#include "utility/includes.h"
#elif defined SOFTSPI
#include <DigitalIO.h>
#endif
/**
* @defgroup PALevel Power Amplifier level
* Power Amplifier level. The units dBm (decibel-milliwatts or dB<sub>mW</sub>)
* represents a logarithmic signal loss.
* @see
* - RF24::setPALevel()
* - RF24::getPALevel()
* @{
*/
typedef enum
{
/**
* (0) represents:
* nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
* :-------:|:-----------------------------:|:----------------------------:
* -18 dBm | -6 dBm | -12 dBm
*/
RF24_PA_MIN = 0,
/**
* (1) represents:
* nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
* :-------:|:-----------------------------:|:----------------------------:
* -12 dBm | 0 dBm | -4 dBm
*/
RF24_PA_LOW,
/**
* (2) represents:
* nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
* :-------:|:-----------------------------:|:----------------------------:
* -6 dBm | 3 dBm | 1 dBm
*/
RF24_PA_HIGH,
/**
* (3) represents:
* nRF24L01 | Si24R1 with<br>lnaEnabled = 1 | Si24R1 with<br>lnaEnabled = 0
* :-------:|:-----------------------------:|:----------------------------:
* 0 dBm | 7 dBm | 4 dBm
*/
RF24_PA_MAX,
/**
* (4) This should not be used and remains for backward compatibility.
*/
RF24_PA_ERROR
} rf24_pa_dbm_e;
/**
* @}
* @defgroup Datarate datarate
* How fast data moves through the air. Units are in bits per second (bps).
* @see
* - RF24::setDataRate()
* - RF24::getDataRate()
* @{
*/
typedef enum
{
/** (0) represents 1 Mbps */
RF24_1MBPS = 0,
/** (1) represents 2 Mbps */
RF24_2MBPS,
/** (2) represents 250 kbps */
RF24_250KBPS
} rf24_datarate_e;
/**
* @}
* @defgroup CRCLength CRC length
* The length of a CRC checksum that is used (if any). Cyclical Redundancy
* Checking (CRC) is commonly used to ensure data integrity.
* @see
* - RF24::setCRCLength()
* - RF24::getCRCLength()
* - RF24::disableCRC()
* @{
*/
typedef enum
{
/** (0) represents no CRC checksum is used */
RF24_CRC_DISABLED = 0,
/** (1) represents CRC 8 bit checksum is used */
RF24_CRC_8,
/** (2) represents CRC 16 bit checksum is used */
RF24_CRC_16
} rf24_crclength_e;
/**
* @}
* @defgroup fifoState FIFO state
* The state of a single FIFO (RX or TX).
* Remember, each FIFO has a maximum occupancy of 3 payloads.
* @see RF24::isFifo()
* @{
*/
typedef enum
{
/// @brief The FIFO is not full nor empty, but it is occupied with 1 or 2 payloads.
RF24_FIFO_OCCUPIED,
/// @brief The FIFO is empty.
RF24_FIFO_EMPTY,
/// @brief The FIFO is full.
RF24_FIFO_FULL,
/// @brief Represents corruption of data over SPI (when observed).
RF24_FIFO_INVALID,
} rf24_fifo_state_e;
/**
* @}
* @defgroup StatusFlags Status flags
* @{
*/
/**
* @brief An enumeration of constants used to configure @ref StatusFlags
*/
typedef enum
{
#include "nRF24L01.h"
/// An alias of `0` to describe no IRQ events enabled.
RF24_IRQ_NONE = 0,
/// Represents an event where TX Data Failed to send.
RF24_TX_DF = 1 << MASK_MAX_RT,
/// Represents an event where TX Data Sent successfully.
RF24_TX_DS = 1 << TX_DS,
/// Represents an event where RX Data is Ready to `RF24::read()`.
RF24_RX_DR = 1 << RX_DR,
/// Equivalent to `RF24_RX_DR | RF24_TX_DS | RF24_TX_DF`.
RF24_IRQ_ALL = (1 << MASK_MAX_RT) | (1 << TX_DS) | (1 << RX_DR),
} rf24_irq_flags_e;
/**
* @}
* @brief Driver class for nRF24L01(+) 2.4GHz Wireless Transceiver
*/
class RF24
{
private:
#ifdef SOFTSPI
SoftSPI<SOFT_SPI_MISO_PIN, SOFT_SPI_MOSI_PIN, SOFT_SPI_SCK_PIN, SPI_MODE> spi;
#elif defined(SPI_UART)
SPIUARTClass uspi;
#endif
#if defined(RF24_LINUX) || defined(XMEGA_D3) /* XMEGA can use SPI class */
SPI spi;
#endif // defined (RF24_LINUX) || defined (XMEGA_D3)
#if defined(RF24_SPI_PTR)
_SPI* _spi;
#endif // defined (RF24_SPI_PTR)
rf24_gpio_pin_t ce_pin; /* "Chip Enable" pin, activates the RX or TX role */
rf24_gpio_pin_t csn_pin; /* SPI Chip select */
uint32_t spi_speed; /* SPI Bus Speed */
#if defined(RF24_LINUX) || defined(XMEGA_D3) || defined(RF24_RP2)
uint8_t spi_rxbuff[32 + 1]; //SPI receive buffer (payload max 32 bytes)
uint8_t spi_txbuff[32 + 1]; //SPI transmit buffer (payload max 32 bytes + 1 byte for the command)
#endif
uint8_t status; /* The status byte returned from every SPI transaction */
uint8_t payload_size; /* Fixed size of payloads */
uint8_t pipe0_reading_address[5]; /* Last address set on pipe 0 for reading. */
uint8_t pipe0_writing_address[5]; /* Last address set on pipe 0 for writing. */
uint8_t config_reg; /* For storing the value of the NRF_CONFIG register */
bool _is_p_variant; /* For storing the result of testing the toggleFeatures() affect */
bool _is_p0_rx; /* For keeping track of pipe 0's usage in user-triggered RX mode. */
protected:
/**
* SPI transactions
*
* Common code for SPI transactions including CSN toggle
*
*/
inline void beginTransaction();
inline void endTransaction();
/** Whether ack payloads are enabled. */
bool ack_payloads_enabled;
/** The address width to use (3, 4 or 5 bytes). */
uint8_t addr_width;
/** Whether dynamic payloads are enabled. */
bool dynamic_payloads_enabled;
/**
* Read a chunk of data in from a register
*
* @param reg Which register. Use constants from nRF24L01.h
* @param[out] buf Where to put the data
* @param len How many bytes of data to transfer
* @note This returns nothing. Older versions of this function returned the status
* byte, but that it now saved to a private member on all SPI transactions.
*/
void read_register(uint8_t reg, uint8_t* buf, uint8_t len);
/**
* Read single byte from a register
*
* @param reg Which register. Use constants from nRF24L01.h
* @return Current value of register @p reg
*/
uint8_t read_register(uint8_t reg);
public:
/**
* @name Primary public interface
*
* These are the main methods you need to operate the chip
*/
/**@{*/
/**
* RF24 Constructor
*
* Creates a new instance of this driver. Before using, you create an instance
* and send in the unique pins that this chip is connected to.
*
* See [Related Pages](pages.html) for device specific information
*
* @param _cepin The pin attached to Chip Enable on the RF module.
* Review our [Linux general](rpi_general.md) doc for details about selecting pin numbers on Linux systems.
* @param _cspin The pin attached to Chip Select (often labeled CSN) on the radio module.
* - For the Arduino Due board, the [Arduino Due extended SPI feature](https://www.arduino.cc/en/Reference/DueExtendedSPI)
* is not supported. This means that the Due's pins 4, 10, or 52 are not mandated options (can use any digital output pin) for
* the radio's CSN pin.
* @param _spi_speed The SPI speed in Hz ie: 1000000 == 1Mhz
* - Users can specify default SPI speed by modifying @ref RF24_SPI_SPEED in @ref RF24_config.h
* - For Arduino, the default SPI speed will only be properly configured this way on devices supporting SPI TRANSACTIONS
* - Older/Unsupported Arduino devices will use a default clock divider & settings configuration
* - For Linux: The old way of setting SPI speeds using BCM2835 driver enums has been removed as of v1.3.7
*/
RF24(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin, uint32_t _spi_speed = RF24_SPI_SPEED);
/**
* A constructor for initializing the radio's hardware dynamically
* @warning You MUST use begin(rf24_gpio_pin_t, rf24_gpio_pin_t) or begin(_SPI*, rf24_gpio_pin_t, rf24_gpio_pin_t) to pass both the
* digital output pin numbers connected to the radio's CE and CSN pins.
* @param _spi_speed The SPI speed in Hz ie: 1000000 == 1Mhz
* - Users can specify default SPI speed by modifying @ref RF24_SPI_SPEED in @ref RF24_config.h
* - For Arduino, the default SPI speed will only be properly configured this way on devices supporting SPI TRANSACTIONS
* - Older/Unsupported Arduino devices will use a default clock divider & settings configuration
* - For Linux: The old way of setting SPI speeds using BCM2835 driver enums has been removed as of v1.3.7
*/
RF24(uint32_t _spi_speed = RF24_SPI_SPEED);
#if defined(RF24_LINUX)
virtual ~RF24() {};
#endif
/**
* Begin operation of the chip
*
* Call this in setup(), before calling any other methods.
* @code
* if (!radio.begin()) {
* Serial.println(F("radio hardware not responding!"));
* while (1) {} // hold program in infinite loop to prevent subsequent errors
* }
* @endcode
* @return
* - `true` if the radio was successfully initialized
* - `false` if the MCU failed to communicate with the radio hardware
*/
bool begin(void);
#if defined(RF24_SPI_PTR) || defined(DOXYGEN_FORCED)
/**
* Same as begin(), but allows specifying a non-default SPI bus to use.
*
* @note This function assumes the `SPI::begin()` method was called before to
* calling this function.
*
* @warning This function is for the Arduino platforms only
*
* @param spiBus A pointer or reference to an instantiated SPI bus object.
* The `_SPI` datatype is a "wrapped" definition that will represent
* various SPI implementations based on the specified platform.
* @see Review the [Arduino support page](arduino.md).
*
* @return same result as begin()
*/
bool begin(_SPI* spiBus);
/**
* Same as begin(), but allows dynamically specifying a SPI bus, CE pin,
* and CSN pin to use.
*
* @note This function assumes the `SPI::begin()` method was called before to
* calling this function.
*
* @warning This function is for the Arduino platforms only
*
* @param spiBus A pointer or reference to an instantiated SPI bus object.
* The `_SPI` datatype is a "wrapped" definition that will represent
* various SPI implementations based on the specified platform.
* @param _cepin The pin attached to Chip Enable on the RF module.
* Review our [Linux general](rpi_general.md) doc for details about selecting pin numbers on Linux systems.
* @param _cspin The pin attached to Chip Select (often labeled CSN) on the radio module.
* - For the Arduino Due board, the [Arduino Due extended SPI feature](https://www.arduino.cc/en/Reference/DueExtendedSPI)
* is not supported. This means that the Due's pins 4, 10, or 52 are not mandated options (can use any digital output pin) for the radio's CSN pin.
*
* @see Review the [Arduino support page](arduino.md).
*
* @return same result as begin()
*/
bool begin(_SPI* spiBus, rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin);
#endif // defined (RF24_SPI_PTR) || defined (DOXYGEN_FORCED)
/**
* Same as begin(), but allows dynamically specifying a CE pin
* and CSN pin to use.
* @param _cepin The pin attached to Chip Enable on the RF module
* @param _cspin The pin attached to Chip Select (often labeled CSN) on the radio module.
* - For the Arduino Due board, the [Arduino Due extended SPI feature](https://www.arduino.cc/en/Reference/DueExtendedSPI)
* is not supported. This means that the Due's pins 4, 10, or 52 are not mandated options (can use any digital output pin) for the radio's CSN pin.
* @return same result as begin()
*/
bool begin(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin);
/**
* Checks if the chip is connected to the SPI bus
*/
bool isChipConnected();
/**
* Start listening on the pipes opened for reading.
*
* 1. Be sure to call openReadingPipe() first.
* 2. Do not call write() while in this mode, without first calling stopListening().
* 3. Call available() to check for incoming traffic, and read() to get it.
*
* Open reading pipe 1 using address `0xCCCECCCECC`
* @code
* byte address[] = {0xCC, 0xCE, 0xCC, 0xCE, 0xCC};
* radio.openReadingPipe(1,address);
* radio.startListening();
* @endcode
*
* @note If there was a call to openReadingPipe() about pipe 0 prior to
* calling this function, then this function will re-write the address
* that was last set to reading pipe 0. This is because openWritingPipe()
* will overwrite the address to reading pipe 0 for proper auto-ack
* functionality.
*/
void startListening(void);
/**
* Stop listening for incoming messages, and switch to transmit mode.
*
* Do this before calling write().
* @code
* radio.stopListening();
* radio.write(&data, sizeof(data));
* @endcode
*
* @warning When the ACK payloads feature is enabled, the TX FIFO buffers are
* flushed when calling this function. This is meant to discard any ACK
* payloads that were not appended to acknowledgment packets.
*/
void stopListening(void);
/**
* @brief Similar to startListening(void) but changes the TX address.
* @param txAddress The new TX address.
* This value will be cached for auto-ack purposes.
*/
void stopListening(const uint8_t* txAddress);
/**
* Check whether there are bytes available to be read
* @code
* if(radio.available()){
* radio.read(&data,sizeof(data));
* }
* @endcode
*
* @see available(uint8_t*)
*
* @return True if there is a payload available, false if none is
*
* @warning This function relies on the information about the pipe number
* that received the next available payload. According to the datasheet,
* the data about the pipe number that received the next available payload
* is "unreliable" during a FALLING transition on the IRQ pin. This means
* you should call clearStatusFlags() before calling this function
* during an ISR (Interrupt Service Routine). For example:
* @code
* void isrCallbackFunction() {
* bool tx_ds, tx_df, rx_dr;
* uint8_t flags = radio.clearStatusFlags(); // resets the IRQ pin to HIGH
* radio.available(); // returned data should now be reliable
* }
*
* void setup() {
* pinMode(IRQ_PIN, INPUT);
* attachInterrupt(digitalPinToInterrupt(IRQ_PIN), isrCallbackFunction, FALLING);
* }
* @endcode
*/
bool available(void);
/**
* Read payload data from the RX FIFO buffer(s).
*
* The length of data read is usually the next available payload's length
* @see
* - getPayloadSize()
* - getDynamicPayloadSize()
*
* @note I specifically chose `void*` as a data type to make it easier
* for beginners to use. No casting needed.
*
* @param buf Pointer to a buffer where the data should be written
* @param len Maximum number of bytes to read into the buffer. This
* value should match the length of the object referenced using the
* `buf` parameter. The absolute maximum number of bytes that can be read
* in one call is 32 (for dynamic payload lengths) or whatever number was
* previously passed to setPayloadSize() (for static payload lengths).
* @remark
* @parblock
* Remember that each call to read() fetches data from the
* RX FIFO beginning with the first byte from the first available
* payload. A payload is not removed from the RX FIFO until it's
* entire length (or more) is fetched using read().
*
* - If `len` parameter's value is less than the available payload's
* length, then the payload remains in the RX FIFO.
* - If `len` parameter's value is greater than the first of multiple
* available payloads, then the data saved to the `buf`
* parameter's object will be supplemented with data from the next
* available payload.
* - If `len` parameter's value is greater than the last available
* payload's length, then the last byte in the payload is used as
* padding for the data saved to the `buf` parameter's object.
* The nRF24L01 will repeatedly use the last byte from the last
* payload even when read() is called with an empty RX FIFO.
* @endparblock
* @note To use this function in the python wrapper, remember that
* only the `len` parameter is required because this function (in the
* python wrapper) returns the payload data as a buffer protocol object
* (bytearray object).
* @code{.py}
* # let `radio` be the instantiated RF24 object
* if radio.available():
* length = radio.getDynamicPayloadSize() # or radio.getPayloadSize() for static payload sizes
* received_payload = radio.read(length)
* @endcode
*
* @note This function no longer returns a boolean. Use available to
* determine if packets are available. The `RX_DR` Interrupt flag is now
* cleared with this function instead of when calling available().
* @code
* if(radio.available()) {
* radio.read(&data, sizeof(data));
* }
* @endcode
*/
void read(void* buf, uint8_t len);
/**
* Be sure to call openWritingPipe() first to set the destination
* of where to write to.
*
* This blocks until the message is successfully acknowledged by
* the receiver or the timeout/retransmit maxima are reached. In
* the current configuration, the max delay here is 60-70ms.
*
* The maximum size of data written is the fixed payload size, see
* getPayloadSize(). However, you can write less, and the remainder
* will just be filled with zeroes.
*
* TX/RX/RT interrupt flags will be cleared every time write is called
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
*
* @code
* radio.stopListening();
* radio.write(&data,sizeof(data));
* @endcode
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.write(buffer)
* @endcode
*
* @return
* - `true` if the payload was delivered successfully and an acknowledgement
* (ACK packet) was received. If auto-ack is disabled, then any attempt
* to transmit will also return true (even if the payload was not
* received).
* - `false` if the payload was sent but was not acknowledged with an ACK
* packet. This condition can only be reported if the auto-ack feature
* is on.
*/
bool write(const void* buf, uint8_t len);
/**
* New: Open a pipe for writing via byte array. Old addressing format retained
* for compatibility.
*
* @deprecated Use `RF24::stopListening(uint8_t*)` instead.
*
* Only one writing pipe can be opened at once, but this function changes
* the address that is used to transmit (ACK payloads/packets do not apply
* here). Be sure to call stopListening() prior to calling this function.
*
* Addresses are assigned via a byte array, default is 5 byte address length
*
* @code
* uint8_t addresses[][6] = {"1Node", "2Node"};
* radio.openWritingPipe(addresses[0]);
* @endcode
* @code
* uint8_t address[] = { 0xCC, 0xCE, 0xCC, 0xCE, 0xCC };
* radio.openWritingPipe(address);
* address[0] = 0x33;
* radio.openReadingPipe(1, address);
* @endcode
*
* @warning This function will overwrite the address set to reading pipe 0
* as stipulated by the datasheet for proper auto-ack functionality in TX
* mode. Use this function to ensure proper transmission acknowledgement
* when the address set to reading pipe 0 (via openReadingPipe()) does not
* match the address passed to this function. If the auto-ack feature is
* disabled, then this function will still overwrite the address for
* reading pipe 0 regardless.
*
* @see
* - setAddressWidth()
* - startListening()
* - stopListening()
*
* @param address The address to be used for outgoing transmissions (uses
* pipe 0). Coordinate this address amongst other receiving nodes (the
* pipe numbers don't need to match). This address is cached to ensure proper
* auto-ack behavior; stopListening() will always restore the latest cached TX
* address.
*
* @remark There is no address length parameter because this function will
* always write the number of bytes that the radio addresses are configured
* to use (set with setAddressWidth()).
*/
void openWritingPipe(const uint8_t* address);
/**
* Open a pipe for reading
*
* Up to 6 pipes can be open for reading at once. Open all the required
* reading pipes, and then call startListening().
*
* @see
* - openWritingPipe()
* - setAddressWidth()
*
* @note Pipes 0 and 1 will store a full 5-byte address. Pipes 2-5 will technically
* only store a single byte, borrowing up to 4 additional bytes from pipe 1 per the
* assigned address width.
* Pipes 1-5 should share the same address, except the first byte.
* Only the first byte in the array should be unique, e.g.
* @code
* uint8_t addresses[][6] = {"Prime", "2Node", "3xxxx", "4xxxx"};
* openReadingPipe(0, addresses[0]); // address used is "Prime"
* openReadingPipe(1, addresses[1]); // address used is "2Node"
* openReadingPipe(2, addresses[2]); // address used is "3Node"
* openReadingPipe(3, addresses[3]); // address used is "4Node"
* @endcode
*
* @warning
* @parblock
* If the reading pipe 0 is opened by this function, the address
* passed to this function (for pipe 0) will be restored at every call to
* startListening().
*
* Read
* http://maniacalbits.blogspot.com/2013/04/rf24-addressing-nrf24l01-radios-require.html
* to understand how to avoid using malformed addresses. This address
* restoration is implemented because of the underlying necessary
* functionality of openWritingPipe().
* @endparblock
*
* @param number Which pipe to open. Only pipe numbers 0-5 are available,
* an address assigned to any pipe number not in that range will be ignored.
* @param address The 24, 32 or 40 bit address of the pipe to open.
*
* There is no address length parameter because this function will
* always write the number of bytes (for pipes 0 and 1) that the radio
* addresses are configured to use (set with setAddressWidth()).
*/
void openReadingPipe(uint8_t number, const uint8_t* address);
/**@}*/
/**
* @name Advanced Operation
*
* Methods you can use to drive the chip in more advanced ways
*/
/**@{*/
/**
* Set radio's CE (Chip Enable) pin state.
*
* @warning Please see the datasheet for a much more detailed description of this pin.
*
* @note This is only publicly exposed for advanced use cases such as complex networking or
* streaming consecutive payloads without robust error handling.
* Typical uses are satisfied by simply using `startListening()` for RX mode or
* `stopListening()` and `write()` for TX mode.
*
* @param level In RX mode, `HIGH` causes the radio to begin actively listening.
* In TX mode, `HIGH` (+ 130 microsecond delay) causes the radio to begin transmitting.
* Setting this to `LOW` will cause the radio to stop transmitting or receiving in any mode.
*/
void ce(bool level);
/**
* Print a giant block of debugging information to stdout
*
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
* The printf.h file is included with the library for Arduino.
* @code
* #include <printf.h>
* setup() {
* Serial.begin(115200);
* printf_begin();
* // ...
* }
* @endcode
*/
void printDetails(void);
/**
* Decode and print the given STATUS byte to stdout.
*
* @param flags The STATUS byte to print.
* This value is fetched with update() or getStatusFlags().
*
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
*/
void printStatus(uint8_t flags);
/**
* Print a giant block of debugging information to stdout. This function
* differs from printDetails() because it makes the information more
* understandable without having to look up the datasheet or convert
* hexadecimal to binary. Only use this function if your application can
* spare extra bytes of memory.
*
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
* The printf.h file is included with the library for Arduino.
* @code
* #include <printf.h>
* setup() {
* Serial.begin(115200);
* printf_begin();
* // ...
* }
* @endcode
*
* @note If the automatic acknowledgements feature is configured differently
* for each pipe, then a binary representation is used in which bits 0-5
* represent pipes 0-5 respectively. A `0` means the feature is disabled, and
* a `1` means the feature is enabled.
*/
void printPrettyDetails(void);
/**
* Put a giant block of debugging information in a char array. This function
* differs from printPrettyDetails() because it uses `sprintf()` and does not use
* a predefined output stream (like `Serial` or stdout). Only use this function if
* your application can spare extra bytes of memory. This can also be used for boards that
* do not support `printf()` (which is required for printDetails() and printPrettyDetails()).
*
* @remark
* The C standard function [sprintf()](http://www.cplusplus.com/reference/cstdio/sprintf)
* formats a C-string in the exact same way as `printf()` but outputs (by reference)
* into a char array. The formatted string literal for sprintf() is stored
* in nonvolatile program memory.
*
* @warning Use a buffer of sufficient size for the `debugging_information`. Start
* with a char array that has at least 870 elements. There is no overflow protection when using
* sprintf(), so the output buffer must be sized correctly or the resulting behavior will
* be undefined.
* @code
* char buffer[870] = {'\0'};
* uint16_t used_chars = radio.sprintfPrettyDetails(buffer);
* Serial.println(buffer);
* Serial.print(F("strlen = "));
* Serial.println(used_chars + 1); // +1 for c-strings' null terminating byte
* @endcode
*
* @param debugging_information The c-string buffer that the debugging
* information is stored to. This must be allocated to a minimum of 870 bytes of memory.
* @returns The number of characters altered in the given buffer. Remember that,
* like `sprintf()`, this returned number does not include the null terminating byte.
*
* This function is available in the python wrapper, but it accepts no parameters and
* returns a string. It does not return the number of characters in the string.
* @code{.py}
* debug_info = radio.sprintfPrettyDetails()
* print(debug_info)
* print("str_len =", len(debug_info))
* @endcode
*
* @note If the automatic acknowledgements feature is configured differently
* for each pipe, then a binary representation is used in which bits 0-5
* represent pipes 0-5 respectively. A `0` means the feature is disabled, and
* a `1` means the feature is enabled.
*/
uint16_t sprintfPrettyDetails(char* debugging_information);
/**
* Encode radio debugging information into an array of uint8_t. This function
* differs from other debug output methods because the debug information can
* be decoded by an external program.
*
* This function is not available in the python wrapper because it is intended for
* use on processors with very limited available resources.
*
* @remark
* This function uses much less ram than other `*print*Details()` methods.
*
* @code
* uint8_t encoded_details[43] = {0};
* radio.encodeRadioDetails(encoded_details);
* @endcode
*
* @param encoded_status The uint8_t array that RF24 radio details are
* encoded into. This array must be at least 43 bytes in length; any less would surely
* cause undefined behavior.
*
* Registers names and/or data corresponding to the index of the `encoded_details` array:
* | index | register/data |
* |------:|:--------------|
* | 0 | NRF_CONFIG |
* | 1 | EN_AA |
* | 2 | EN_RXADDR |
* | 3 | SETUP_AW |
* | 4 | SETUP_RETR |
* | 5 | RF_CH |
* | 6 | RF_SETUP |
* | 7 | NRF_STATUS |
* | 8 | OBSERVE_TX |
* | 9 | CD (aka RPD) |
* | 10-14 | RX_ADDR_P0 |
* | 15-19 | RX_ADDR_P1 |
* | 20 | RX_ADDR_P2 |
* | 21 | RX_ADDR_P3 |
* | 22 | RX_ADDR_P4 |
* | 23 | RX_ADDR_P5 |
* | 24-28 | TX_ADDR |
* | 29 | RX_PW_P0 |
* | 30 | RX_PW_P1 |
* | 31 | RX_PW_P2 |
* | 32 | RX_PW_P3 |
* | 33 | RX_PW_P4 |
* | 34 | RX_PW_P5 |
* | 35 | FIFO_STATUS |
* | 36 | DYNPD |
* | 37 | FEATURE |
* | 38-39 | ce_pin |
* | 40-41 | csn_pin |
* | 42 | SPI speed (in MHz) or'd with (isPlusVariant << 4) |
*/
void encodeRadioDetails(uint8_t* encoded_status);
/**
* Test whether there are bytes available to be read from the
* FIFO buffers.
*
* @note This function is named `available_pipe()` in the python wrapper.
* @parblock
* Additionally, the `available_pipe()` function (which
* takes no arguments) returns a 2 item tuple containing (ordered by
* tuple's indices):
* - A boolean describing if there is a payload available to read from
* the RX FIFO buffers.
* - The pipe number that received the next available payload in the RX
* FIFO buffers. If the item at the tuple's index 0 is `False`, then
* this pipe number is invalid.
*
* To use this function in python:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* has_payload, pipe_number = radio.available_pipe() # expand the tuple to 2 variables
* if has_payload:
* print("Received a payload with pipe", pipe_number)
* @endcode
* @endparblock
*
* @param[out] pipe_num Which pipe has the payload available
* @code
* uint8_t pipeNum;
* if(radio.available(&pipeNum)){
* radio.read(&data, sizeof(data));
* Serial.print("Received data on pipe ");
* Serial.println(pipeNum);
* }
* @endcode
*
* @warning According to the datasheet, the data saved to `pipe_num` is
* "unreliable" during a FALLING transition on the IRQ pin. This means you
* should call clearStatusFlags() before calling this function during
* an ISR (Interrupt Service Routine). For example:
* @code
* void isrCallbackFunction() {
* radio.clearStatusFlags(); // resets the IRQ pin to inactive HIGH
* uint8_t pipe = 7; // initialize pipe data
* radio.available(&pipe); // pipe data should now be reliable
* }
*
* void setup() {
* pinMode(IRQ_PIN, INPUT);
* attachInterrupt(digitalPinToInterrupt(IRQ_PIN), isrCallbackFunction, FALLING);
* }
* @endcode
*
* @return
* - `true` if there is a payload available in the top (first out)
* level RX FIFO.
* - `false` if there is nothing available in the RX FIFO because it is
* empty.
*/
bool available(uint8_t* pipe_num);
/**
* Use this function to check if the radio's RX FIFO levels are all
* occupied. This can be used to prevent data loss because any incoming
* transmissions are rejected if there is no unoccupied levels in the RX
* FIFO to store the incoming payload. Remember that each level can hold
* up to a maximum of 32 bytes.
* @return
* - `true` if all three 3 levels of the RX FIFO buffers are occupied.
* - `false` if there is one or more levels available in the RX FIFO
* buffers. Remember that this does not always mean that the RX FIFO
* buffers are empty; use available() to see if the RX FIFO buffers are
* empty or not.
*/
bool rxFifoFull();
/**
* @param about_tx `true` focuses on the TX FIFO, `false` focuses on the RX FIFO
* @return
* - @ref RF24_FIFO_OCCUPIED (`0`) if the specified FIFO is neither full nor empty.
* - @ref RF24_FIFO_EMPTY (`1`) if the specified FIFO is empty.
* - @ref RF24_FIFO_FULL (`2`) if the specified FIFO is full.
* - @ref RF24_FIFO_INVALID (`3`) if the data fetched over SPI was malformed.
*/
rf24_fifo_state_e isFifo(bool about_tx);
/**
* @deprecated Use RF24::isFifo(bool about_tx) instead.
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* @param about_tx `true` focuses on the TX FIFO, `false` focuses on the RX FIFO
* @param check_empty
* - `true` checks if the specified FIFO is empty
* - `false` checks is the specified FIFO is full.
* @return A boolean answer to the question "is the [TX/RX] FIFO [empty/full]?"
*/
bool isFifo(bool about_tx, bool check_empty);
/**
* Enter low-power mode
*
* To return to normal power mode, call powerUp().
*
* @note After calling startListening(), a basic radio will consume about 13.5mA
* at max PA level.
* During active transmission, the radio will consume about 11.5mA, but this will
* be reduced to 26uA (.026mA) between sending.
* In full powerDown mode, the radio will consume approximately 900nA (.0009mA)
*
* @code
* radio.powerDown();
* avr_enter_sleep_mode(); // Custom function to sleep the device
* radio.powerUp();
* @endcode
*/
void powerDown(void);
/**
* Leave low-power mode - required for normal radio operation after calling powerDown()
*
* To return to low power mode, call powerDown().
* @note This will take up to 5ms for maximum compatibility
*/
void powerUp(void);
/**
* Write for single NOACK writes. Optionally disable
* acknowledgements/auto-retries for a single payload using the
* multicast parameter set to true.
*
* Can be used with enableAckPayload() to request a response
* @see
* - setAutoAck()
* - write()
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
* @param multicast Request ACK response (false), or no ACK response
* (true). Be sure to have called enableDynamicAck() at least once before
* setting this parameter.
* @return
* - `true` if the payload was delivered successfully and an acknowledgement
* (ACK packet) was received. If auto-ack is disabled, then any attempt
* to transmit will also return true (even if the payload was not
* received).
* - `false` if the payload was sent but was not acknowledged with an ACK
* packet. This condition can only be reported if the auto-ack feature
* is on.
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.write(buffer, False) # False = the multicast parameter
* @endcode
*/
bool write(const void* buf, uint8_t len, const bool multicast);
/**
* This will not block until the 3 FIFO buffers are filled with data.
* Once the FIFOs are full, writeFast() will simply wait for a buffer to
* become available or a transmission failure (returning `true` or `false`
* respectively).
*
* @warning
* @parblock
* It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
* retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
* to clear by issuing txStandBy() or ensure appropriate time between transmissions.
*
* Use txStandBy() when this function returns `false`.
*
* Example (Partial blocking):
* @code
* radio.writeFast(&buf,32); // Writes 1 payload to the buffers
* txStandBy(); // Returns 0 if failed. 1 if success. Blocks only until MAX_RT timeout or success. Data flushed on fail.
*
* radio.writeFast(&buf,32); // Writes 1 payload to the buffers
* txStandBy(1000); // Using extended timeouts, returns 1 if success. Retries failed payloads for 1 seconds before returning 0.
* @endcode
* @endparblock
*
* @see
* - setAutoAck()
* - txStandBy()
* - write()
* - writeBlocking()
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
* @return
* - `true` if the payload passed to `buf` was loaded in the TX FIFO.
* - `false` if the payload passed to `buf` was not loaded in the TX FIFO
* because a previous payload already in the TX FIFO failed to
* transmit. This condition can only be reported if the auto-ack feature
* is on.
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.writeFast(buffer)
* @endcode
*/
bool writeFast(const void* buf, uint8_t len);
/**
* Similar to writeFast(const void*, uint8_t) but allows for single NOACK writes.
* Optionally disable acknowledgements/auto-retries for a single payload using the
* multicast parameter set to `true`.
*
* @warning If the auto-ack feature is enabled, then it is strongly encouraged to call
* txStandBy() when this function returns `false`.
*
* @see
* - setAutoAck()
* - txStandBy()
* - write()
* - writeBlocking()
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
* @param multicast Request ACK response (false), or no ACK response
* (true). Be sure to have called enableDynamicAck() at least once before
* setting this parameter.
* @return
* - `true` if the payload passed to `buf` was loaded in the TX FIFO.
* - `false` if the payload passed to `buf` was not loaded in the TX FIFO
* because a previous payload already in the TX FIFO failed to
* transmit. This condition can only be reported if the auto-ack feature
* is on (and the multicast parameter is set to false).
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.writeFast(buffer, False) # False = the multicast parameter
* @endcode
*/
bool writeFast(const void* buf, uint8_t len, const bool multicast);
/**
* This function extends the auto-retry mechanism to any specified duration.
* It will not block until the 3 FIFO buffers are filled with data.
* If so the library will auto retry until a new payload is written
* or the user specified timeout period is reached.
* @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
* retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
* to clear by issuing txStandBy() or ensure appropriate time between transmissions.
*
* Example (Full blocking):
* @code
* radio.writeBlocking(&buf, sizeof(buf), 1000); // Wait up to 1 second to write 1 payload to the buffers
* radio.txStandBy(1000); // Wait up to 1 second for the payload to send. Return 1 if ok, 0 if failed.
* // Blocks only until user timeout or success. Data flushed on fail.
* @endcode
* @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
* @see
* - txStandBy()
* - write()
* - writeFast()
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
* @param timeout User defined timeout in milliseconds.
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.writeBlocking(buffer, 1000) # 1000 means wait at most 1 second
* @endcode
*
* @return
* - `true` if the payload passed to `buf` was loaded in the TX FIFO.
* - `false` if the payload passed to `buf` was not loaded in the TX FIFO
* because a previous payload already in the TX FIFO failed to
* transmit. This condition can only be reported if the auto-ack feature
* is on.
*/
bool writeBlocking(const void* buf, uint8_t len, uint32_t timeout);
/**
* This function should be called as soon as transmission is finished to
* drop the radio back to STANDBY-I mode. If not issued, the radio will
* remain in STANDBY-II mode which, per the data sheet, is not a recommended
* operating mode.
*
* @note When transmitting data in rapid succession, it is still recommended by
* the manufacturer to drop the radio out of TX or STANDBY-II mode if there is
* time enough between sends for the FIFOs to empty. This is not required if auto-ack
* is enabled.
*
* Relies on built-in auto retry functionality.
*
* Example (Partial blocking):
* @code
* radio.writeFast(&buf, 32);
* radio.writeFast(&buf, 32);
* radio.writeFast(&buf, 32); //Fills the FIFO buffers up
* bool ok = radio.txStandBy(); //Returns 0 if failed. 1 if success.
* //Blocks only until MAX_RT timeout or success. Data flushed on fail.
* @endcode
* @see txStandBy(uint32_t timeout, bool startTx)
* @return
* - `true` if all payloads in the TX FIFO were delivered successfully and
* an acknowledgement (ACK packet) was received for each. If auto-ack is
* disabled, then any attempt to transmit will also return true (even if
* the payload was not received).
* - `false` if a payload was sent but was not acknowledged with an ACK
* packet. This condition can only be reported if the auto-ack feature
* is on.
*/
bool txStandBy();
/**
* This function allows extended blocking and auto-retries per a user defined timeout
*
* Fully Blocking Example:
* @code
* radio.writeFast(&buf, 32);
* radio.writeFast(&buf, 32);
* radio.writeFast(&buf, 32); //Fills the FIFO buffers up
* bool ok = radio.txStandBy(1000); //Returns 0 if failed after 1 second of retries. 1 if success.
* //Blocks only until user defined timeout or success. Data flushed on fail.
* @endcode
* @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
* @param timeout Number of milliseconds to retry failed payloads
* @param startTx If this is set to `true`, then this function puts the nRF24L01
* in TX Mode. `false` leaves the primary mode (TX or RX) as it is, which can
* prevent the mandatory wait time to change modes.
* @return
* - `true` if all payloads in the TX FIFO were delivered successfully and
* an acknowledgement (ACK packet) was received for each. If auto-ack is
* disabled, then any attempt to transmit will also return true (even if
* the payload was not received).
* - `false` if a payload was sent but was not acknowledged with an ACK
* packet. This condition can only be reported if the auto-ack feature
* is on.
*/
bool txStandBy(uint32_t timeout, bool startTx = 0);
/**
* Write an acknowledgement (ACK) payload for the specified pipe
*
* The next time a message is received on a specified `pipe`, the data in
* `buf` will be sent back in the ACK payload.
*
* @see
* - enableAckPayload()
* - enableDynamicPayloads()
*
* @note ACK payloads are handled automatically by the radio chip when a
* regular payload is received. It is important to discard regular payloads
* in the TX FIFO (using flush_tx()) before loading the first ACK payload
* into the TX FIFO. This function can be called before and after calling
* startListening().
*
* @warning Only three of these can be pending at any time as there are
* only 3 FIFO buffers. Dynamic payloads must be enabled.
*
* @note ACK payloads are dynamic payloads. Calling enableAckPayload()
* will automatically enable dynamic payloads on pipe 0 (required for TX
* mode when expecting ACK payloads) & pipe 1. To use ACK payloads on any other
* pipe in RX mode, call enableDynamicPayloads().
*
* @param pipe Which pipe# (typically 1-5) will get this response.
* @param buf Pointer to data that is sent
* @param len Length of the data to send, up to 32 bytes max. Not affected
* by the static payload size set by setPayloadSize().
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.writeAckPayload(1, buffer) # load an ACK payload for response on pipe 1
* @endcode
*
* @return
* - `true` if the payload was loaded into the TX FIFO.
* - `false` if the payload wasn't loaded into the TX FIFO because it is
* already full or the ACK payload feature is not enabled using
* enableAckPayload().
*/
bool writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
/**
* Clear the Status flags that caused an interrupt event.
*
* @remark This function is similar to `whatHappened()` because it also returns the
* Status flags that caused the interrupt event. However, this function returns
* a STATUS byte instead of bit-banging into 3 1-byte booleans
* passed by reference.
*
* @note When used in an ISR (Interrupt Service routine), there is a chance that the
* returned bits 0b1110 (rx_pipe number) is inaccurate. See available(uint8_t*) (or the
* datasheet) for more detail.
*
* @param flags The IRQ flags to clear. Default value is all of them (`RF24_IRQ_ALL`).
* Multiple flags can be cleared by OR-ing rf24_irq_flags_e values together.
*
* @returns The STATUS byte from the radio's register before it was modified. Use
* enumerations of rf24_irq_flags_e as masks to interpret the STATUS byte's meaning(s).
*
* @ingroup StatusFlags
*/
uint8_t clearStatusFlags(uint8_t flags = RF24_IRQ_ALL);
/**
* Set which flags shall be reflected on the radio's IRQ pin.
*
* @remarks This function is similar to maskIRQ() but with less confusing parameters.
*
* @param flags A value of rf24_irq_flags_e to influence the radio's IRQ pin.
* The default value (`RF24_IRQ_NONE`) will disable the radio's IRQ pin.
* Multiple events can be enabled by OR-ing rf24_irq_flags_e values together.
* ```cpp
* radio.setStatusFlags(RF24_IRQ_ALL);
* // is equivalent to
* radio.setStatusFlags(RF24_RX_DR | RF24_TX_DS | RF24_TX_DF);
* ```
*
* @ingroup StatusFlags
*/
void setStatusFlags(uint8_t flags = RF24_IRQ_NONE);
/**
* Get the latest STATUS byte returned from the last SPI transaction.
*
* @note This does not actually perform any SPI transaction with the radio.
* Use `RF24::update()` instead to get a fresh copy of the Status flags at
* the slight cost of performance.
*
* @returns The STATUS byte from the radio's register as the latest SPI transaction. Use
* enumerations of rf24_irq_flags_e as masks to interpret the STATUS byte's meaning(s).
*
* @ingroup StatusFlags
*/
uint8_t getStatusFlags();
/**
* Get an updated STATUS byte from the radio.
*
* @returns The STATUS byte fetched from the radio's register. Use enumerations of
* rf24_irq_flags_e as masks to interpret the STATUS byte's meaning(s).
*
* @ingroup StatusFlags
*/
uint8_t update();
/**
* Non-blocking write to the open writing pipe used for buffered writes
*
* @note Optimization: This function now leaves the CE pin high, so the radio
* will remain in TX or STANDBY-II Mode until a txStandBy() command is issued. Can be used as an alternative to startWrite()
* if writing multiple payloads at once.
* @warning It is important to never keep the nRF24L01 in TX mode with FIFO full for more than 4ms at a time. If the auto
* retransmit/autoAck is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
* to clear by issuing txStandBy() or ensure appropriate time between transmissions.
*
* @see
* - write()
* - writeFast()
* - startWrite()
* - writeBlocking()
* - setAutoAck() (for single noAck writes)
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
* @param multicast Request ACK response (false), or no ACK response
* (true). Be sure to have called enableDynamicAck() at least once before
* setting this parameter.
* @param startTx If this is set to `true`, then this function sets the
* nRF24L01's CE pin to active (enabling TX transmissions). `false` has no
* effect on the nRF24L01's CE pin and simply loads the payload into the
* TX FIFO.
*
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.startFastWrite(buffer, False, True) # 3rd parameter is optional
* # False means expecting ACK response (multicast parameter)
* # True means initiate transmission (startTx parameter)
* @endcode
*/
void startFastWrite(const void* buf, uint8_t len, const bool multicast, bool startTx = 1);
/**
* Non-blocking write to the open writing pipe
*
* Just like write(), but it returns immediately. To find out what happened
* to the send, catch the IRQ and then call clearStatusFlags() or update().
*
* @see
* - write()
* - writeFast()
* - startFastWrite()
* - clearStatusFlags()
* - setAutoAck() (for single noAck writes)
*
* @param buf Pointer to the data to be sent
* @param len Number of bytes to be sent
* @param multicast Request ACK response (false), or no ACK response
* (true). Be sure to have called enableDynamicAck() at least once before
* setting this parameter.
*
* @return
* - `true` if payload was written to the TX FIFO buffers and the
* transmission was started.
* - `false` if the TX FIFO is full and the payload could not be written. In
* this condition, the transmission process is restarted.
* @note The `len` parameter must be omitted when using the python
* wrapper because the length of the payload is determined automatically.
* To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* buffer = b"Hello World" # a `bytes` object
* radio.startWrite(buffer, False) # False = the multicast parameter
* @endcode
*/
bool startWrite(const void* buf, uint8_t len, const bool multicast);
/**
* The function will instruct the radio to re-use the payload in the
* top level (first out) of the TX FIFO buffers. This is used internally
* by writeBlocking() to initiate retries when a TX failure
* occurs. Retries are automatically initiated except with the standard
* write(). This way, data is not flushed from the buffer until calling
* flush_tx(). If the TX FIFO has only the one payload (in the top level),
* the re-used payload can be overwritten by using write(), writeFast(),
* writeBlocking(), startWrite(), or startFastWrite(). If the TX FIFO has
* other payloads enqueued, then the aforementioned functions will attempt
* to enqueue the a new payload in the TX FIFO (does not overwrite the top
* level of the TX FIFO). Currently, stopListening() also calls flush_tx()
* when ACK payloads are enabled (via enableAckPayload()).
*
* Upon exiting, this function will set the CE pin HIGH to initiate the
* re-transmission process. If only 1 re-transmission is desired, then the
* CE pin should be set to LOW after the mandatory minumum pulse duration
* of 10 microseconds.
*
* @remark This function only applies when taking advantage of the
* auto-retry feature. See setAutoAck() and setRetries() to configure the
* auto-retry feature.
*
* @note This is to be used AFTER auto-retry fails if wanting to resend
* using the built-in payload reuse feature. After issuing reUseTX(), it
* will keep resending the same payload until a transmission failure
* occurs or the CE pin is set to LOW (whichever comes first). In the
* event of a re-transmission failure, simply call this function again to
* resume re-transmission of the same payload.
*/
void reUseTX();
/**
* Empty all 3 of the TX (transmit) FIFO buffers. This is automatically
* called by stopListening() if ACK payloads are enabled. However,
* startListening() does not call this function.
*
* @return Current value of status register
*/
uint8_t flush_tx(void);
/**
* Empty all 3 of the RX (receive) FIFO buffers.
*
* @return Current value of status register
*/
uint8_t flush_rx(void);
/**
* Test whether there was a carrier on the line for the
* previous listening period.
*
* Useful to check for interference on the current channel.
*
* @return true if was carrier, false if not
*/
bool testCarrier(void);
/**
* Test whether a signal (carrier or otherwise) greater than
* or equal to -64dBm is present on the channel. Valid only
* on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
*
* Useful to check for interference on the current channel and
* channel hopping strategies.
*
* @code
* bool goodSignal = radio.testRPD();
* if(radio.available()){
* Serial.println(goodSignal ? "Strong signal > -64dBm" : "Weak signal < -64dBm" );
* radio.read(&payload,sizeof(payload));
* }
* @endcode
* @return true if a signal greater than or equal to -64dBm was detected,
* false if not.
*/
bool testRPD(void);
/**
* Test whether this is a real radio, or a mock shim for
* debugging. Setting either pin to 0xff is the way to
* indicate that this is not a real radio.
*
* @return true if this is a legitimate radio
*/
bool isValid();
/**
* Close a pipe after it has been previously opened.
* Can be safely called without having previously opened a pipe.
* @param pipe Which pipe number to close, any integer not in range [0, 5]
* is ignored.
*/
void closeReadingPipe(uint8_t pipe);
#if defined(FAILURE_HANDLING)
/**
*
* If a failure has been detected, it usually indicates a hardware issue. By default the library
* will cease operation when a failure is detected.
* This should allow advanced users to detect and resolve intermittent hardware issues.
*
* In most cases, the radio must be re-enabled via radio.begin(); and the appropriate settings
* applied after a failure occurs, if wanting to re-enable the device immediately.
*
* The three main failure modes of the radio include:
*
* 1. Writing to radio: Radio unresponsive
* - Fixed internally by adding a timeout to the internal write functions in RF24 (failure handling)
* 2. Reading from radio: Available returns true always
* - Fixed by adding a timeout to available functions by the user. This is implemented internally in RF24Network.
* 3. Radio configuration settings are lost
* - Fixed by monitoring a value that is different from the default, and re-configuring the radio if this setting reverts to the default.
*
* See the included example, GettingStarted_HandlingFailures
*
* @code
* if(radio.failureDetected) {
* radio.begin(); // Attempt to re-configure the radio with defaults
* radio.failureDetected = 0; // Reset the detection value
* radio.openWritingPipe(addresses[1]); // Re-configure pipe addresses
* radio.openReadingPipe(1, addresses[0]);
* report_failure(); // Blink LEDs, send a message, etc. to indicate failure
* }
* @endcode
*/
bool failureDetected;
#endif // defined (FAILURE_HANDLING)
/**@}*/
/**
* @name Optional Configurators
*
* Methods you can use to get or set the configuration of the chip.
* None are required. Calling begin() sets up a reasonable set of
* defaults.
*/
/**@{*/
/**
* Set the address width from 3 to 5 bytes (24, 32 or 40 bit)
*
* @param a_width The address width (in bytes) to use; this can be 3, 4 or
* 5.
*/
void setAddressWidth(uint8_t a_width);
/**
* Set the number of retry attempts and delay between retry attempts when
* transmitting a payload. The radio is waiting for an acknowledgement
* (ACK) packet during the delay between retry attempts.
*
* @param delay How long to wait between each retry, in multiples of
* 250 us. The minimum of 0 means 250 us, and the maximum of 15 means
* 4000 us. The default value of 5 means 1500us (5 * 250 + 250).
* @param count How many retries before giving up. The default/maximum is 15. Use
* 0 to disable the auto-retry feature all together.
*
* @note Disable the auto-retry feature on a transmitter still uses the
* auto-ack feature (if enabled), except it will not retry to transmit if
* the payload was not acknowledged on the first attempt.
*/
void setRetries(uint8_t delay, uint8_t count);
/**
* Set RF communication channel. The frequency used by a channel is
* calculated as:
* @verbatim 2400 MHz + <channel number> @endverbatim
* Meaning the default channel of 76 uses the approximate frequency of
* 2476 MHz.
*
* @note In the python wrapper, this function is the setter of the
* `channel` attribute.To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* radio.channel = 2 # set the channel to 2 (2402 MHz)
* @endcode
*
* @param channel Which RF channel to communicate on, 0-125
*/
void setChannel(uint8_t channel);
/**
* Get RF communication channel
*
* @note In the python wrapper, this function is the getter of the
* `channel` attribute.To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* chn = radio.channel # get the channel
* @endcode
*
* @return The currently configured RF Channel
*/
uint8_t getChannel(void);
/**
* Set Static Payload Size
*
* This implementation uses a pre-established fixed payload size for all
* transmissions. If this method is never called, the driver will always
* transmit the maximum payload size (32 bytes), no matter how much
* was sent to write().
*
* @note In the python wrapper, this function is the setter of the
* `payloadSize` attribute.To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* radio.payloadSize = 16 # set the static payload size to 16 bytes
* @endcode
*
* @param size The number of bytes in the payload
*/
void setPayloadSize(uint8_t size);
/**
* Get Static Payload Size
*
* @note In the python wrapper, this function is the getter of the
* `payloadSize` attribute.To use this function in the python wrapper:
* @code{.py}
* # let `radio` be the instantiated RF24 object
* pl_size = radio.payloadSize # get the static payload size
* @endcode
*
* @see setPayloadSize()
*
* @return The number of bytes in the payload
*/
uint8_t getPayloadSize(void);
/**
* Get Dynamic Payload Size
*
* For dynamic payloads, this pulls the size of the payload off
* the chip
*
* @note Corrupt packets are now detected and flushed per the
* manufacturer.
* @code
* if(radio.available()){
* if(radio.getDynamicPayloadSize() < 1){
* // Corrupt payload has been flushed
* return;
* }
* radio.read(&data,sizeof(data));
* }
* @endcode
*
* @return Payload length of last-received dynamic payload
*/
uint8_t getDynamicPayloadSize(void);
/**
* Enable custom payloads in the acknowledge packets
*
* ACK payloads are a handy way to return data back to senders without
* manually changing the radio modes on both units.
*
* @remarks The ACK payload feature requires the auto-ack feature to be
* enabled for any pipe using ACK payloads. This function does not
* automatically enable the auto-ack feature on pipe 0 since the auto-ack
* feature is enabled for all pipes by default.
*
* @see setAutoAck()
*
* @note ACK payloads are dynamic payloads. This function automatically
* enables dynamic payloads on pipes 0 & 1 by default. Call
* enableDynamicPayloads() to enable on all pipes (especially for RX nodes
* that use pipes other than pipe 0 to receive transmissions expecting
* responses with ACK payloads).
*/
void enableAckPayload(void);
/**
* Disable custom payloads on the acknowledge packets
*
* @see enableAckPayload()
*/
void disableAckPayload(void);
/**
* Enable dynamically-sized payloads
*
* This way you don't always have to send large packets just to send them
* once in a while. This enables dynamic payloads on ALL pipes.
*
*/
void enableDynamicPayloads(void);
/**
* Disable dynamically-sized payloads
*
* This disables dynamic payloads on ALL pipes. Since Ack Payloads
* requires Dynamic Payloads, Ack Payloads are also disabled.
* If dynamic payloads are later re-enabled and ack payloads are desired
* then enableAckPayload() must be called again as well.
*
*/
void disableDynamicPayloads(void);
/**
* Enable dynamic ACKs (single write multicast or unicast) for chosen
* messages.
*
* @note This function must be called once before using the multicast
* parameter for any functions that offer it. To use multicast behavior
* about all outgoing payloads (using pipe 0) or incoming payloads
* (concerning all RX pipes), use setAutoAck()
*
* @see
* - setAutoAck() for all pipes
* - setAutoAck(uint8_t, bool) for individual pipes
*
* @code
* radio.write(&data, 32, 1); // Sends a payload with no acknowledgement requested
* radio.write(&data, 32, 0); // Sends a payload using auto-retry/autoACK
* @endcode
*/
void enableDynamicAck();
/**
* Determine whether the hardware is an nRF24L01+ or not.
*
* @return true if the hardware is nRF24L01+ (or compatible) and false
* if its not.
*/
bool isPVariant(void);
/**
* Enable or disable the auto-acknowledgement feature for all pipes. This
* feature is enabled by default. Auto-acknowledgement responds to every
* received payload with an empty ACK packet. These ACK packets get sent
* from the receiving radio back to the transmitting radio. To attach an
* ACK payload to a ACK packet, use writeAckPayload().
*
* If this feature is disabled on a transmitting radio, then the
* transmitting radio will always report that the payload was received
* (even if it was not). Please remember that this feature's configuration
* needs to match for transmitting and receiving radios.
*
* @warning When using the `multicast` parameter to write(), this feature
* can be disabled for an individual payload. However, if this feature is
* disabled, then the `multicast` parameter will have no effect.
*
* @note If disabling auto-acknowledgment packets, the ACK payloads
* feature is also disabled as this feature is required to send ACK
* payloads.
*
* @see
* - write()
* - writeFast()
* - startFastWrite()
* - startWrite()
* - writeAckPayload()
*
* @param enable Whether to enable (true) or disable (false) the
* auto-acknowledgment feature for all pipes
*/
void setAutoAck(bool enable);
/**
* Enable or disable the auto-acknowledgement feature for a specific pipe.
* This feature is enabled by default for all pipes. Auto-acknowledgement
* responds to every received payload with an empty ACK packet. These ACK
* packets get sent from the receiving radio back to the transmitting
* radio. To attach an ACK payload to a ACK packet, use writeAckPayload().
*
* Pipe 0 is used for TX operations, which include sending ACK packets. If
* using this feature on both TX & RX nodes, then pipe 0 must have this
* feature enabled for the RX & TX operations. If this feature is disabled
* on a transmitting radio's pipe 0, then the transmitting radio will
* always report that the payload was received (even if it was not).
* Remember to also enable this feature for any pipe that is openly
* listening to a transmitting radio with this feature enabled.
*
* @warning If this feature is enabled for pipe 0, then the `multicast`
* parameter to write() can be used to disable this feature for an
* individual payload. However, if this feature is disabled for pipe 0,
* then the `multicast` parameter will have no effect.
*
* @note If disabling auto-acknowledgment packets on pipe 0, the ACK
* payloads feature is also disabled as this feature is required on pipe 0
* to send ACK payloads.
*
* @see
* - write()
* - writeFast()
* - startFastWrite()
* - startWrite()
* - writeAckPayload()
* - enableAckPayload()
* - disableAckPayload()
*
* @param pipe Which pipe to configure. This number should be in range
* [0, 5].
* @param enable Whether to enable (true) or disable (false) the
* auto-acknowledgment feature for the specified pipe
*/
void setAutoAck(uint8_t pipe, bool enable);
/**
* Set Power Amplifier (PA) level and Low Noise Amplifier (LNA) state
*
* @param level The desired @ref PALevel as defined by @ref rf24_pa_dbm_e.
* @param lnaEnable Enable or Disable the LNA (Low Noise Amplifier) Gain.
* See table for Si24R1 modules below. @p lnaEnable only affects
* nRF24L01 modules with an LNA chip.
*
* | @p level (enum value) | nRF24L01<br>description | Si24R1<br>description when<br> @p lnaEnable = 1 | Si24R1<br>description when<br> @p lnaEnable = 0 |
* |:---------------------:|:-------:|:--------:|:-------:|
* | @ref RF24_PA_MIN (0) | -18 dBm | -6 dBm | -12 dBm |
* | @ref RF24_PA_LOW (1) | -12 dBm | -0 dBm | -4 dBm |
* | @ref RF24_PA_HIGH (2) | -6 dBm | 3 dBm | 1 dBm |
* | @ref RF24_PA_MAX (3) | 0 dBm | 7 dBm | 4 dBm |
*
* @note The getPALevel() function does not care what was passed @p lnaEnable parameter.
*/
void setPALevel(uint8_t level, bool lnaEnable = 1);
/**
* Fetches the current @ref PALevel.
*
* @return One of the values defined by @ref rf24_pa_dbm_e.
* See tables in @ref rf24_pa_dbm_e or setPALevel()
*/
uint8_t getPALevel(void);
/**
* Returns automatic retransmission count (ARC_CNT)
*
* Value resets with each new transmission. Allows roughly estimating signal strength.
*
* @return Returns values from 0 to 15.
*/
uint8_t getARC(void);
/**
* Set the transmission @ref Datarate
*
* @warning setting @ref RF24_250KBPS will fail for non-plus modules (when
* isPVariant() returns false).
*
* @param speed Specify one of the following values (as defined by
* @ref rf24_datarate_e):
* | @p speed (enum value) | description |
* |:---------------------:|:------------:|
* | @ref RF24_1MBPS (0) | for 1 Mbps |
* | @ref RF24_2MBPS (1) | for 2 Mbps |
* | @ref RF24_250KBPS (2) | for 250 kbps |
*
* @return true if the change was successful
*/
bool setDataRate(rf24_datarate_e speed);
/**
* Fetches the currently configured transmission @ref Datarate
*
* @return One of the values defined by @ref rf24_datarate_e.
* See table in @ref rf24_datarate_e or setDataRate()
*/
rf24_datarate_e getDataRate(void);
/**
* Set the @ref CRCLength (in bits)
*
* CRC cannot be disabled if auto-ack is enabled
* @param length Specify one of the values (as defined by @ref rf24_crclength_e)
* | @p length (enum value) | description |
* |:--------------------------:|:------------------------------:|
* | @ref RF24_CRC_DISABLED (0) | to disable using CRC checksums |
* | @ref RF24_CRC_8 (1) | to use 8-bit checksums |
* | @ref RF24_CRC_16 (2) | to use 16-bit checksums |
*/
void setCRCLength(rf24_crclength_e length);
/**
* Get the @ref CRCLength (in bits)
*
* CRC checking cannot be disabled if auto-ack is enabled
* @return One of the values defined by @ref rf24_crclength_e.
* See table in @ref rf24_crclength_e or setCRCLength()
*/
rf24_crclength_e getCRCLength(void);
/**
* Disable CRC validation
*
* @warning CRC cannot be disabled if auto-ack/ESB is enabled.
*/
void disableCRC(void);
/**
*
* The driver will delay for this duration when stopListening() is called
*
* When responding to payloads, faster devices like ARM(RPi) are much faster than Arduino:
* 1. Arduino sends data to RPi, switches to RX mode
* 2. The RPi receives the data, switches to TX mode and sends before the Arduino radio is in RX mode
* 3. If AutoACK is disabled, this can be set as low as 0. If AA/ESB enabled, set to 100uS minimum on RPi
*
* @warning If set to 0, ensure 130uS delay after stopListening() and before any sends
*/
uint32_t txDelay;
/**
*
* On all devices but Linux and ATTiny, a small delay is added to the CSN toggling function
*
* This is intended to minimize the speed of SPI polling due to radio commands
*
* If using interrupts or timed requests, this can be set to 0 Default:5
*/
uint32_t csDelay;
/**
* Transmission of constant carrier wave with defined frequency and output power
*
* @param level Output power to use
* @param channel The channel to use
*
* @warning If isPVariant() returns true, then this function takes extra
* measures that alter some settings. These settings alterations include:
* - setAutoAck() to false (for all pipes)
* - setRetries() to retry `0` times with a delay of 250 microseconds
* - set the TX address to 5 bytes of `0xFF`
* - flush_tx()
* - load a 32 byte payload of `0xFF` into the TX FIFO's top level
* - disableCRC()
*/
void startConstCarrier(rf24_pa_dbm_e level, uint8_t channel);
/**
* Stop transmission of constant wave and reset PLL and CONT registers
*
* @warning this function will powerDown() the radio per recommendation of
* datasheet.
* @note If isPVariant() returns true, please remember to re-configure the radio's settings
* @code
* // re-establish default settings
* setCRCLength(RF24_CRC_16);
* setAutoAck(true);
* setRetries(5, 15);
* @endcode
* @see startConstCarrier()
*/
void stopConstCarrier(void);
/**
* @brief Open or close all data pipes.
*
* This function does not alter the addresses assigned to pipes. It is simply a
* convenience function that allows controlling all pipes at once.
* @param isEnabled `true` opens all pipes; `false` closes all pipes.
*/
void toggleAllPipes(bool isEnabled);
/**
* @brief configure the RF_SETUP register in 1 transaction
* @param level This parameter is the same input as setPALevel()'s `level` parameter.
* See @ref rf24_pa_dbm_e enum for accepted values.
* @param speed This parameter is the same input as setDataRate()'s `speed` parameter.
* See @ref rf24_datarate_e enum for accepted values.
* @param lnaEnable This optional parameter is the same as setPALevel()'s `lnaEnable`
* optional parameter. Defaults to `true` (meaning LNA feature is enabled) when not specified.
*/
void setRadiation(uint8_t level, rf24_datarate_e speed, bool lnaEnable = true);
/**@}*/
/**
* @name Deprecated
*
* Methods provided for backwards compatibility.
*/
/**@{*/
/**
* Open a pipe for reading
* @deprecated For compatibility with old code only, see newer function
* openReadingPipe().
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* @note Pipes 1-5 should share the first 32 bits.
* Only the least significant byte should be unique, e.g.
* @code
* openReadingPipe(1, 0xF0F0F0F0AA);
* openReadingPipe(2, 0xF0F0F0F066);
* @endcode
*
* @warning
* @parblock
* Pipe 0 is also used by the writing pipe so should typically be avoided as a reading pipe.
* If used, the reading pipe 0 address needs to be restored at every call to startListening().
*
* See http://maniacalbits.blogspot.com/2013/04/rf24-addressing-nrf24l01-radios-require.html
* @endparblock
*
* @param number Which pipe# to open, 0-5.
* @param address The 40-bit address of the pipe to open.
*/
void openReadingPipe(uint8_t number, uint64_t address);
/**
* Open a pipe for writing
* @deprecated For compatibility with old code only, see newer function
* openWritingPipe().
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* Addresses are 40-bit hex values, e.g.:
*
* @code
* openWritingPipe(0xF0F0F0F0F0);
* @endcode
*
* @param address The 40-bit address of the pipe to open.
*/
void openWritingPipe(uint64_t address);
/**
* Determine if an ack payload was received in the most recent call to
* write(). The regular available() can also be used.
*
* @deprecated For compatibility with old code only, see synonymous function available().
* Use read() to retrieve the ack payload and getDynamicPayloadSize() to get the ACK payload size.
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* @return True if an ack payload is available.
*/
bool isAckPayloadAvailable(void);
/**
* This function is used to configure what events will trigger the Interrupt
* Request (IRQ) pin active LOW.
*
* @deprecated Use setStatusFlags() instead.
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* The following events can be configured:
* 1. "data sent": This does not mean that the data transmitted was
* received, only that the attempt to send it was complete.
* 2. "data failed": This means the data being sent was not received. This
* event is only triggered when the auto-ack feature is enabled.
* 3. "data received": This means that data from a receiving payload has
* been loaded into the RX FIFO buffers. Remember that there are only 3
* levels available in the RX FIFO buffers.
*
* By default, all events are configured to trigger the IRQ pin active LOW.
* When the IRQ pin is active, use clearStatusFlags() or getStatusFlags() to
* determine what events triggered it.
* Remember that calling clearStatusFlags() also clears these
* events' status, and the IRQ pin will then be reset to inactive HIGH.
*
* The following code configures the IRQ pin to only reflect the "data received"
* event:
* @code
* radio.maskIRQ(1, 1, 0);
* @endcode
*
* @param tx_ok `true` ignores the "data sent" event, `false` reflects the
* "data sent" event on the IRQ pin.
* @param tx_fail `true` ignores the "data failed" event, `false` reflects the
* "data failed" event on the IRQ pin.
* @param rx_ready `true` ignores the "data received" event, `false` reflects the
* "data received" event on the IRQ pin.
*/
void maskIRQ(bool tx_ok, bool tx_fail, bool rx_ready);
/**
* Call this when you get an Interrupt Request (IRQ) to find out why
*
* This function describes what event triggered the IRQ pin to go active
* LOW and clears the status of all events.
*
* @deprecated Use clearStatusFlags() instead.
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* @see setStatusFlags()
*
* @param[out] tx_ok The transmission attempt completed (TX_DS). This does
* not imply that the transmitted data was received by another radio, rather
* this only reports if the attempt to send was completed. This will
* always be `true` when the auto-ack feature is disabled.
* @param[out] tx_fail The transmission failed to be acknowledged, meaning
* too many retries (MAX_RT) were made while expecting an ACK packet. This
* event is only triggered when auto-ack feature is enabled.
* @param[out] rx_ready There is a newly received payload (RX_DR) saved to
* RX FIFO buffers. Remember that the RX FIFO can only hold up to 3
* payloads. Once the RX FIFO is full, all further received transmissions
* are rejected until there is space to save new data in the RX FIFO
* buffers.
*
* @note This function expects no parameters in the python wrapper.
* Instead, this function returns a 3 item tuple describing the IRQ
* events' status. To use this function in the python wrapper:
* @code{.py}
* # let`radio` be the instantiated RF24 object
* tx_ds, tx_df, rx_dr = radio.whatHappened() # get IRQ status flags
* print("tx_ds: {}, tx_df: {}, rx_dr: {}".format(tx_ds, tx_df, rx_dr))
* @endcode
*/
void whatHappened(bool& tx_ok, bool& tx_fail, bool& rx_ready);
/**
* Similar to startListening(void) but changes the TX address.
*
* @deprecated Use stopListening(const uint8_t*) instead.
* See our [migration guide](migration.md) to understand what you should update in your code.
*
* @param txAddress The new TX address.
* This value will be cached for auto-ack purposes.
*/
void stopListening(const uint64_t txAddress);
private:
/**@}*/
/**
* @name Low-level internal interface.
*
* Protected methods that address the chip directly. Regular users cannot
* ever call these. They are documented for completeness and for developers who
* may want to extend this class.
*/
/**@{*/
/**
* initializing function specific to all constructors
* (regardless of constructor parameters)
*/
void _init_obj();
/**
* initialize radio by performing a soft reset.
* @warning This function assumes the SPI bus object's begin() method has been
* previously called.
*/
bool _init_radio();
/**
* initialize the GPIO pins
*/
bool _init_pins();
/**
* Set chip select pin
*
* Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data
* and best of all, we make use of the radio's FIFO buffers. A lower speed
* means we're less likely to effectively leverage our FIFOs and pay a higher
* AVR runtime cost as toll.
*
* @param mode HIGH to take this unit off the SPI bus, LOW to put it on
*/
void csn(bool mode);
/**
* Write a chunk of data to a register
*
* @param reg Which register. Use constants from nRF24L01.h
* @param buf Where to get the data
* @param len How many bytes of data to transfer
* @return Nothing. Older versions of this function returned the status
* byte, but that it now saved to a private member on all SPI transactions.
*/
void write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
/**
* Write a single byte to a register
*
* @param reg Which register. Use constants from nRF24L01.h
* @param value The new value to write
* @return Nothing. Older versions of this function returned the status
* byte, but that it now saved to a private member on all SPI transactions.
*/
void write_register(uint8_t reg, uint8_t value);
/**
* Write the transmit payload
*
* The size of data written is the fixed payload size, see getPayloadSize()
*
* @param buf Where to get the data
* @param len Number of bytes to be sent
* @param writeType Specify if individual payload should be acknowledged
* @return Nothing. Older versions of this function returned the status
* byte, but that it now saved to a private member on all SPI transactions.
*/
void write_payload(const void* buf, uint8_t len, const uint8_t writeType);
/**
* Read the receive payload
*
* The size of data read is the fixed payload size, see getPayloadSize()
*
* @param buf Where to put the data
* @param len Maximum number of bytes to read
* @return Nothing. Older versions of this function returned the status
* byte, but that it now saved to a private member on all SPI transactions.
*/
void read_payload(void* buf, uint8_t len);
#if !defined(MINIMAL)
/**
* Decode and print the given 'observe_tx' value to stdout
*
* @param value The observe_tx value to print
*
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
*/
void print_observe_tx(uint8_t value);
/**
* Print the name and value of an 8-bit register to stdout
*
* Optionally it can print some quantity of successive
* registers on the same line. This is useful for printing a group
* of related registers on one line.
*
* @param name Name of the register
* @param reg Which register. Use constants from nRF24L01.h
* @param qty How many successive registers to print
*/
void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
/**
* Print the name and value of a 40-bit address register to stdout
*
* Optionally it can print some quantity of successive
* registers on the same line. This is useful for printing a group
* of related registers on one line.
*
* @param name Name of the register
* @param reg Which register. Use constants from nRF24L01.h
* @param qty How many successive registers to print
*/
void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
/**
* Put the value of a 40-bit address register into a char array
*
* Optionally it can print some quantity of successive
* registers on the same line. This is useful for printing a group
* of related registers on one line.
*
* @param out_buffer Output buffer, char array
* @param reg Which register. Use constants from nRF24L01.h
* @param qty How many successive registers to print
* @return The total number of characters written to the given buffer.
*/
uint8_t sprintf_address_register(char* out_buffer, uint8_t reg, uint8_t qty = 1);
#endif
/**
* Turn on or off the special features of the chip
*
* The chip has certain 'features' which are only available when the 'features'
* are enabled. See the datasheet for details.
*/
void toggle_features(void);
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
void errNotify(void);
#endif
/**
* @brief Manipulate the @ref Datarate and txDelay
*
* This is a helper function to setRadiation() and setDataRate()
* @param speed The desired data rate.
*/
inline uint8_t _data_rate_reg_value(rf24_datarate_e speed);
/**
* @brief Manipulate the @ref PALevel
*
* This is a helper function to setRadiation() and setPALevel()
* @param level The desired @ref PALevel.
* @param lnaEnable Toggle the LNA feature.
*/
inline uint8_t _pa_level_reg_value(uint8_t level, bool lnaEnable);
/**@}*/
};
/**
* @example{lineno} examples/GettingStarted/GettingStarted.ino
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use the Serial Monitor to change each node's behavior.
*/
/**
* @example{lineno} examples/AcknowledgementPayloads/AcknowledgementPayloads.ino
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another
* with Acknowledgement (ACK) payloads attached to ACK packets.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use the Serial Monitor to change each node's behavior.
*/
/**
* @example{lineno} examples/ManualAcknowledgements/ManualAcknowledgements.ino
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another
* with manually transmitted (non-automatic) Acknowledgement (ACK) payloads.
* This example still uses ACK packets, but they have no payloads. Instead the
* acknowledging response is sent with `write()`. This tactic allows for more
* updated acknowledgement payload data, where actual ACK payloads' data are
* outdated by 1 transmission because they have to loaded before receiving a
* transmission.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use the Serial Monitor to change each node's behavior.
*/
/**
* @example{lineno} examples/StreamingData/StreamingData.ino
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of streaming data from 1 nRF24L01 transceiver to another.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use the Serial Monitor to change each node's behavior.
*/
/**
* @example{lineno} examples/MulticeiverDemo/MulticeiverDemo.ino
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from as many as 6 nRF24L01 transceivers to
* 1 receiving transceiver. This technique is trademarked by
* Nordic Semiconductors as "MultiCeiver".
*
* This example was written to be used on up to 6 devices acting as TX nodes &
* only 1 device acting as the RX node (that's a maximum of 7 devices).
* Use the Serial Monitor to change each node's behavior.
*/
/**
* @example{lineno} examples/InterruptConfigure/InterruptConfigure.ino
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This example uses Acknowledgement (ACK) payloads attached to ACK packets to
* demonstrate how the nRF24L01's IRQ (Interrupt Request) pin can be
* configured to detect when data is received, or when data has transmitted
* successfully, or when data has failed to transmit.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use the Serial Monitor to change each node's behavior.
*/
/**
* @example{lineno} examples/old_backups/GettingStarted_HandlingFailures/GettingStarted_HandlingFailures.ino
* Written by [TMRh20](http://github.com/TMRh20) in 2019
*
* This example demonstrates the basic getting started functionality, but with
* failure handling for the radio chip. Addresses random radio failures etc,
* potentially due to loose wiring on breadboards etc.
*/
/**
* @example{lineno} examples/old_backups/TransferTimeouts/TransferTimeouts.ino
* Written by [TMRh20](https://github.com/TMRh20)
*
* This example demonstrates the use of and extended timeout period and
* auto-retries/auto-reUse to increase reliability in noisy or low signal scenarios.
*
* Write this sketch to two different nodes. Put one of the nodes into 'transmit'
* mode by connecting with the serial monitor and sending a 'T'. The data <br>
* transfer will begin, with the receiver displaying the payload count and the
* data transfer rate.
*/
/**
* @example{lineno} examples/old_backups/pingpair_irq/pingpair_irq.ino
* Updated by [TMRh20](https://github.com/TMRh20)
*
* This is an example of how to user interrupts to interact with the radio, and a demonstration
* of how to use them to sleep when receiving, and not miss any payloads.<br>
* The pingpair_sleepy example expands on sleep functionality with a timed sleep option for the transmitter.
* Sleep functionality is built directly into my fork of the RF24Network library<br>
*/
/**
* @example{lineno} examples/old_backups/pingpair_sleepy/pingpair_sleepy.ino
* Updated by [TMRh20](https://github.com/TMRh20)
*
* This is an example of how to use the RF24 class to create a battery-
* efficient system. It is just like the GettingStarted_CallResponse example, but the<br>
* ping node powers down the radio and sleeps the MCU after every
* ping/pong cycle, and the receiver sleeps between payloads. <br>
*/
/**
* @example{lineno} examples/rf24_ATTiny/rf24ping85/rf24ping85.ino
* <b>2014 Contribution by [tong67](https://github.com/tong67)</b><br>
* Updated 2020 by [2bndy5](http://github.com/2bndy5) for the
* [SpenceKonde ATTinyCore](https://github.com/SpenceKonde/ATTinyCore)<br>
* The RF24 library uses the [ATTinyCore by
* SpenceKonde](https://github.com/SpenceKonde/ATTinyCore)
*
* This sketch is a duplicate of the ManualAcknowledgements.ino example
* (without all the Serial input/output code), and it demonstrates
* a ATTiny25/45/85 or ATTiny24/44/84 driving the nRF24L01 transceiver using
* the RF24 class to communicate with another node.
*
* A simple example of sending data from 1 nRF24L01 transceiver to another
* with manually transmitted (non-automatic) Acknowledgement (ACK) payloads.
* This example still uses ACK packets, but they have no payloads. Instead the
* acknowledging response is sent with `write()`. This tactic allows for more
* updated acknowledgement payload data, where actual ACK payloads' data are
* outdated by 1 transmission because they have to loaded before receiving a
* transmission.
*
* This example was written to be used on 2 devices acting as "nodes".
*/
/**
* @example{lineno} examples/rf24_ATTiny/timingSearch3pin/timingSearch3pin.ino
* <b>2014 Contribution by [tong67](https://github.com/tong67)</b><br>
* Updated 2020 by [2bndy5](http://github.com/2bndy5) for the
* [SpenceKonde ATTinyCore](https://github.com/SpenceKonde/ATTinyCore)<br>
* The RF24 library uses the [ATTinyCore by
* SpenceKonde](https://github.com/SpenceKonde/ATTinyCore)
*
* This sketch can be used to determine the best settle time values to use for
* RF24::csDelay in RF24::csn() (private function).
* @see RF24::csDelay
*
* The settle time values used here are 100/20. However, these values depend
* on the actual used RC combination and voltage drop by LED. The
* intermediate results are written to TX (PB3, pin 2 -- using Serial).
*
* For schematic details, see introductory comment block in the rf24ping85.ino sketch.
*/
/**
* @example{lineno} examples/old_backups/pingpair_dyn/pingpair_dyn.ino
*
* This is an example of how to use payloads of a varying (dynamic) size on Arduino.
*/
/**
* @example{lineno} examples_linux/getting_started.py
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This is a simple example of using the RF24 class on a Raspberry Pi.
*
* Remember to install the [Python wrapper](python_wrapper.md), then
* navigate to the "RF24/examples_linux" folder.
* <br>To run this example, enter
* @code{.sh}python3 getting_started.py @endcode and follow the prompts.
*
* @note this example requires python v3.7 or newer because it measures
* transmission time with `time.monotonic_ns()`.
*/
/**
* @example{lineno} examples_linux/acknowledgement_payloads.py
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This is a simple example of using the RF24 class on a Raspberry Pi to
* transmit and retrieve custom automatic acknowledgment payloads.
*
* Remember to install the [Python wrapper](python_wrapper.md), then
* navigate to the "RF24/examples_linux" folder.
* <br>To run this example, enter
* @code{.sh}python3 acknowledgement_payloads.py @endcode and follow the prompts.
*
* @note this example requires python v3.7 or newer because it measures
* transmission time with `time.monotonic_ns()`.
*/
/**
* @example{lineno} examples_linux/manual_acknowledgements.py
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This is a simple example of using the RF24 class on a Raspberry Pi to
* transmit and respond with acknowledgment (ACK) transmissions. Notice that
* the auto-ack feature is enabled, but this example doesn't use automatic ACK
* payloads because automatic ACK payloads' data will always be outdated by 1
* transmission. Instead, this example uses a call and response paradigm.
*
* Remember to install the [Python wrapper](python_wrapper.md), then
* navigate to the "RF24/examples_linux" folder.
* <br>To run this example, enter
* @code{.sh}python3 manual_acknowledgements.py @endcode and follow the prompts.
*
* @note this example requires python v3.7 or newer because it measures
* transmission time with `time.monotonic_ns()`.
*/
/**
* @example{lineno} examples_linux/streaming_data.py
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This is a simple example of using the RF24 class on a Raspberry Pi for
* streaming multiple payloads.
*
* Remember to install the [Python wrapper](python_wrapper.md), then
* navigate to the "RF24/examples_linux" folder.
* <br>To run this example, enter
* @code{.sh}python3 streaming_data.py @endcode and follow the prompts.
*
* @note this example requires python v3.7 or newer because it measures
* transmission time with `time.monotonic_ns()`.
*/
/**
* @example{lineno} examples_linux/interrupt_configure.py
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This is a simple example of using the RF24 class on a Raspberry Pi to
* detecting (and verifying) the IRQ (interrupt) pin on the nRF24L01.
*
* Remember to install the [Python wrapper](python_wrapper.md), then
* navigate to the "RF24/examples_linux" folder.
* <br>To run this example, enter
* @code{.sh}python3 interrupt_configure.py @endcode and follow the prompts.
*
* @note this example requires python v3.7 or newer because it measures
* transmission time with `time.monotonic_ns()`.
*/
/**
* @example{lineno} examples_linux/multiceiver_demo.py
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* This is a simple example of using the RF24 class on a Raspberry Pi for
* using 1 nRF24L01 to receive data from up to 6 other transceivers. This
* technique is called "multiceiver" in the datasheet.
*
* Remember to install the [Python wrapper](python_wrapper.md), then
* navigate to the "RF24/examples_linux" folder.
* <br>To run this example, enter
* @code{.sh}python3 multiceiver_demo.py @endcode and follow the prompts.
*
* @note this example requires python v3.7 or newer because it measures
* transmission time with `time.monotonic_ns()`.
*/
/**
* @example{lineno} examples_linux/scanner.cpp
*
* Example to detect interference on the various channels available.
* This is a good diagnostic tool to check whether you're picking a
* good channel for your application.
*
* Inspired by cpixip.
* See http://arduino.cc/forum/index.php/topic,54795.0.html
*
* Use ctrl+C to exit
*/
/**
* @example{lineno} examples/scanner/scanner.ino
*
* Example to detect interference on the various channels available.
* This is a good diagnostic tool to check whether you're picking a
* good channel for your application.
*
* Inspired by cpixip.
* See http://arduino.cc/forum/index.php/topic,54795.0.html
*/
/**
* @example{lineno} examples_linux/gettingstarted.cpp
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another.
*
* This example was written * This example was written to be used on up to 6 devices acting as TX nodes &
* only 1 device acting as the RX node (that's a maximum of 7 devices).
acting as "nodes".
* Use `ctrl+c` to quit at any time.
*/
/**
* @example{lineno} examples_linux/acknowledgementPayloads.cpp
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another
* with Acknowledgement (ACK) payloads attached to ACK packets.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use `ctrl+c` to quit at any time.
*/
/**
* @example{lineno} examples_linux/manualAcknowledgements.cpp
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another
* with manually transmitted (non-automatic) Acknowledgement (ACK) payloads.
* This example still uses ACK packets, but they have no payloads. Instead the
* acknowledging response is sent with `write()`. This tactic allows for more
* updated acknowledgement payload data, where actual ACK payloads' data are
* outdated by 1 transmission because they have to loaded before receiving a
* transmission.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use `ctrl+c` to quit at any time.
*/
/**
* @example{lineno} examples_linux/streamingData.cpp
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from 1 nRF24L01 transceiver to another.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use `ctrl+c` to quit at any time.
*/
/**
* @example{lineno} examples_linux/multiceiverDemo.cpp
* Written by [2bndy5](http://github.com/2bndy5) in 2020
*
* A simple example of sending data from as many as 6 nRF24L01 transceivers to
* 1 receiving transceiver. This technique is trademarked by
* Nordic Semiconductors as "MultiCeiver".
*
* This example was written to be used on up to 6 devices acting as TX nodes &
* only 1 device acting as the RX node (that's a maximum of 7 devices).
* Use `ctrl+c` to quit at any time.
*/
#endif // RF24_H_Knihovna RF24 RF24_config.h
/*
Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
*/
#include "nRF24L01.h"
#include "RF24_config.h"
#include "RF24.h"
/****************************************************************************/
void RF24::csn(bool mode)
{
#if defined(RF24_TINY)
if (ce_pin != csn_pin) {
digitalWrite(csn_pin, mode);
}
else {
if (mode == HIGH) {
PORTB |= (1 << PINB2); // SCK->CSN HIGH
delayMicroseconds(RF24_CSN_SETTLE_HIGH_DELAY); // allow csn to settle.
}
else {
PORTB &= ~(1 << PINB2); // SCK->CSN LOW
delayMicroseconds(RF24_CSN_SETTLE_LOW_DELAY); // allow csn to settle
}
}
// Return, CSN toggle complete
return;
#elif defined(ARDUINO) && !defined(RF24_SPI_TRANSACTIONS)
// Minimum ideal SPI bus speed is 2x data rate
// If we assume 2Mbs data rate and 16Mhz clock, a
// divider of 4 is the minimum we want.
// CLK:BUS 8Mhz:2Mhz, 16Mhz:4Mhz, or 20Mhz:5Mhz
#if !defined(SOFTSPI)
// applies to SPI_UART and inherent hardware SPI
#if defined(RF24_SPI_PTR)
_spi->setBitOrder(MSBFIRST);
_spi->setDataMode(SPI_MODE0);
#if !defined(F_CPU) || F_CPU < 20000000
_spi->setClockDivider(SPI_CLOCK_DIV2);
#elif F_CPU < 40000000
_spi->setClockDivider(SPI_CLOCK_DIV4);
#elif F_CPU < 80000000
_spi->setClockDivider(SPI_CLOCK_DIV8);
#elif F_CPU < 160000000
_spi->setClockDivider(SPI_CLOCK_DIV16);
#elif F_CPU < 320000000
_spi->setClockDivider(SPI_CLOCK_DIV32);
#elif F_CPU < 640000000
_spi->setClockDivider(SPI_CLOCK_DIV64);
#elif F_CPU < 1280000000
_spi->setClockDivider(SPI_CLOCK_DIV128);
#else // F_CPU >= 1280000000
#error "Unsupported CPU frequency. Please set correct SPI divider."
#endif // F_CPU to SPI_CLOCK_DIV translation
#else // !defined(RF24_SPI_PTR)
_SPI.setBitOrder(MSBFIRST);
_SPI.setDataMode(SPI_MODE0);
#if !defined(F_CPU) || F_CPU < 20000000
_SPI.setClockDivider(SPI_CLOCK_DIV2);
#elif F_CPU < 40000000
_SPI.setClockDivider(SPI_CLOCK_DIV4);
#elif F_CPU < 80000000
_SPI.setClockDivider(SPI_CLOCK_DIV8);
#elif F_CPU < 160000000
_SPI.setClockDivider(SPI_CLOCK_DIV16);
#elif F_CPU < 320000000
_SPI.setClockDivider(SPI_CLOCK_DIV32);
#elif F_CPU < 640000000
_SPI.setClockDivider(SPI_CLOCK_DIV64);
#elif F_CPU < 1280000000
_SPI.setClockDivider(SPI_CLOCK_DIV128);
#else // F_CPU >= 1280000000
#error "Unsupported CPU frequency. Please set correct SPI divider."
#endif // F_CPU to SPI_CLOCK_DIV translation
#endif // !defined(RF24_SPI_PTR)
#endif // !defined(SOFTSPI)
#elif defined(RF24_RPi)
if (!mode)
_SPI.chipSelect(csn_pin);
#endif // defined(RF24_RPi)
#if !defined(RF24_LINUX)
digitalWrite(csn_pin, mode);
delayMicroseconds(csDelay);
#else
static_cast<void>(mode); // ignore -Wunused-parameter
#endif // !defined(RF24_LINUX)
}
/****************************************************************************/
void RF24::ce(bool level)
{
#ifndef RF24_LINUX
//Allow for 3-pin use on ATTiny
if (ce_pin != csn_pin) {
#endif
digitalWrite(ce_pin, level);
#ifndef RF24_LINUX
}
#endif
}
/****************************************************************************/
inline void RF24::beginTransaction()
{
#if defined(RF24_SPI_TRANSACTIONS)
#if defined(RF24_SPI_PTR)
#if defined(RF24_RP2)
_spi->beginTransaction(spi_speed);
#else // ! defined (RF24_RP2)
_spi->beginTransaction(SPISettings(spi_speed, MSBFIRST, SPI_MODE0));
#endif // ! defined (RF24_RP2)
#else // !defined(RF24_SPI_PTR)
_SPI.beginTransaction(SPISettings(spi_speed, MSBFIRST, SPI_MODE0));
#endif // !defined(RF24_SPI_PTR)
#endif // defined (RF24_SPI_TRANSACTIONS)
csn(LOW);
}
/****************************************************************************/
inline void RF24::endTransaction()
{
csn(HIGH);
#if defined(RF24_SPI_TRANSACTIONS)
#if defined(RF24_SPI_PTR)
_spi->endTransaction();
#else // !defined(RF24_SPI_PTR)
_SPI.endTransaction();
#endif // !defined(RF24_SPI_PTR)
#endif // defined (RF24_SPI_TRANSACTIONS)
}
/****************************************************************************/
void RF24::read_register(uint8_t reg, uint8_t* buf, uint8_t len)
{
#if defined(RF24_LINUX) || defined(RF24_RP2)
beginTransaction(); //configures the spi settings for RPi, locks mutex and setting csn low
uint8_t* prx = spi_rxbuff;
uint8_t* ptx = spi_txbuff;
uint8_t size = static_cast<uint8_t>(len + 1); // Add register value to transmit buffer
*ptx++ = reg;
while (len--) {
*ptx++ = RF24_NOP; // Dummy operation, just for reading
}
#if defined(RF24_RP2)
_spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size);
#else // !defined (RF24_RP2)
_SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size);
#endif // !defined (RF24_RP2)
status = *prx++; // status is 1st byte of receive buffer
// decrement before to skip status byte
while (--size) {
*buf++ = *prx++;
}
endTransaction(); // unlocks mutex and setting csn high
#else // !defined(RF24_LINUX) && !defined(RF24_RP2)
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(reg);
while (len--) {
*buf++ = _spi->transfer(0xFF);
}
#else // !defined(RF24_SPI_PTR)
status = _SPI.transfer(reg);
while (len--) {
*buf++ = _SPI.transfer(0xFF);
}
#endif // !defined(RF24_SPI_PTR)
endTransaction();
#endif // !defined(RF24_LINUX) && !defined(RF24_RP2)
}
/****************************************************************************/
uint8_t RF24::read_register(uint8_t reg)
{
uint8_t result;
#if defined(RF24_LINUX) || defined(RF24_RP2)
beginTransaction();
uint8_t* prx = spi_rxbuff;
uint8_t* ptx = spi_txbuff;
*ptx++ = reg;
*ptx++ = RF24_NOP; // Dummy operation, just for reading
#if defined(RF24_RP2)
_spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, 2);
#else // !defined(RF24_RP2)
_SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), 2);
#endif // !defined(RF24_RP2)
status = *prx; // status is 1st byte of receive buffer
result = *++prx; // result is 2nd byte of receive buffer
endTransaction();
#else // !defined(RF24_LINUX) && !defined(RF24_RP2)
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(reg);
result = _spi->transfer(0xff);
#else // !defined(RF24_SPI_PTR)
status = _SPI.transfer(reg);
result = _SPI.transfer(0xff);
#endif // !defined(RF24_SPI_PTR)
endTransaction();
#endif // !defined(RF24_LINUX) && !defined(RF24_RP2)
return result;
}
/****************************************************************************/
void RF24::write_register(uint8_t reg, const uint8_t* buf, uint8_t len)
{
#if defined(RF24_LINUX) || defined(RF24_RP2)
beginTransaction();
uint8_t* prx = spi_rxbuff;
uint8_t* ptx = spi_txbuff;
uint8_t size = static_cast<uint8_t>(len + 1); // Add register value to transmit buffer
*ptx++ = (W_REGISTER | reg);
while (len--) {
*ptx++ = *buf++;
}
#if defined(RF24_RP2)
_spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size);
#else // !defined(RF24_RP2)
_SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size);
#endif // !defined(RF24_RP2)
status = *prx; // status is 1st byte of receive buffer
endTransaction();
#else // !defined(RF24_LINUX) && !defined(RF24_RP2)
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(W_REGISTER | reg);
while (len--) {
_spi->transfer(*buf++);
}
#else // !defined(RF24_SPI_PTR)
status = _SPI.transfer(W_REGISTER | reg);
while (len--) {
_SPI.transfer(*buf++);
}
#endif // !defined(RF24_SPI_PTR)
endTransaction();
#endif // !defined(RF24_LINUX) && !defined(RF24_RP2)
}
/****************************************************************************/
void RF24::write_register(uint8_t reg, uint8_t value)
{
IF_RF24_DEBUG(printf_P(PSTR("write_register(%02x,%02x)\r\n"), reg, value));
#if defined(RF24_LINUX) || defined(RF24_RP2)
beginTransaction();
uint8_t* prx = spi_rxbuff;
uint8_t* ptx = spi_txbuff;
*ptx++ = (W_REGISTER | reg);
*ptx = value;
#if defined(RF24_RP2)
_spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, 2);
#else // !defined(RF24_RP2)
_SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), 2);
#endif // !defined(RF24_RP2)
status = *prx++; // status is 1st byte of receive buffer
endTransaction();
#else // !defined(RF24_LINUX) && !defined(RF24_RP2)
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(W_REGISTER | reg);
_spi->transfer(value);
#else // !defined(RF24_SPI_PTR)
status = _SPI.transfer(W_REGISTER | reg);
_SPI.transfer(value);
#endif // !defined(RF24_SPI_PTR)
endTransaction();
#endif // !defined(RF24_LINUX) && !defined(RF24_RP2)
}
/****************************************************************************/
void RF24::write_payload(const void* buf, uint8_t data_len, const uint8_t writeType)
{
const uint8_t* current = reinterpret_cast<const uint8_t*>(buf);
uint8_t blank_len = !data_len ? 1 : 0;
if (!dynamic_payloads_enabled) {
data_len = rf24_min(data_len, payload_size);
blank_len = static_cast<uint8_t>(payload_size - data_len);
}
else {
data_len = rf24_min(data_len, static_cast<uint8_t>(32));
}
//printf("[Writing %u bytes %u blanks]",data_len,blank_len);
IF_RF24_DEBUG(printf_P("[Writing %u bytes %u blanks]\n", data_len, blank_len););
#if defined(RF24_LINUX) || defined(RF24_RP2)
beginTransaction();
uint8_t* prx = spi_rxbuff;
uint8_t* ptx = spi_txbuff;
uint8_t size;
size = static_cast<uint8_t>(data_len + blank_len + 1); // Add register value to transmit buffer
*ptx++ = writeType;
while (data_len--) {
*ptx++ = *current++;
}
while (blank_len--) {
*ptx++ = 0;
}
#if defined(RF24_RP2)
_spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size);
#else // !defined(RF24_RP2)
_SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size);
#endif // !defined(RF24_RP2)
status = *prx; // status is 1st byte of receive buffer
endTransaction();
#else // !defined(RF24_LINUX) && !defined(RF24_RP2)
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(writeType);
while (data_len--) {
_spi->transfer(*current++);
}
while (blank_len--) {
_spi->transfer(0);
}
#else // !defined(RF24_SPI_PTR)
status = _SPI.transfer(writeType);
while (data_len--) {
_SPI.transfer(*current++);
}
while (blank_len--) {
_SPI.transfer(0);
}
#endif // !defined(RF24_SPI_PTR)
endTransaction();
#endif // !defined(RF24_LINUX) && !defined(RF24_RP2)
}
/****************************************************************************/
void RF24::read_payload(void* buf, uint8_t data_len)
{
uint8_t* current = reinterpret_cast<uint8_t*>(buf);
uint8_t blank_len = 0;
if (!dynamic_payloads_enabled) {
data_len = rf24_min(data_len, payload_size);
blank_len = static_cast<uint8_t>(payload_size - data_len);
}
else {
data_len = rf24_min(data_len, static_cast<uint8_t>(32));
}
//printf("[Reading %u bytes %u blanks]",data_len,blank_len);
IF_RF24_DEBUG(printf_P("[Reading %u bytes %u blanks]\n", data_len, blank_len););
#if defined(RF24_LINUX) || defined(RF24_RP2)
beginTransaction();
uint8_t* prx = spi_rxbuff;
uint8_t* ptx = spi_txbuff;
uint8_t size;
size = static_cast<uint8_t>(data_len + blank_len + 1); // Add register value to transmit buffer
*ptx++ = R_RX_PAYLOAD;
while (--size) {
*ptx++ = RF24_NOP;
}
size = static_cast<uint8_t>(data_len + blank_len + 1); // Size has been lost during while, re affect
#if defined(RF24_RP2)
_spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size);
#else // !defined(RF24_RP2)
_SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size);
#endif // !defined(RF24_RP2)
status = *prx++; // 1st byte is status
if (data_len > 0) {
// Decrement before to skip 1st status byte
while (--data_len) {
*current++ = *prx++;
}
*current = *prx;
}
endTransaction();
#else // !defined(RF24_LINUX) && !defined(RF24_RP2)
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(R_RX_PAYLOAD);
while (data_len--) {
*current++ = _spi->transfer(0xFF);
}
while (blank_len--) {
_spi->transfer(0xFF);
}
#else // !defined(RF24_SPI_PTR)
status = _SPI.transfer(R_RX_PAYLOAD);
while (data_len--) {
*current++ = _SPI.transfer(0xFF);
}
while (blank_len--) {
_SPI.transfer(0xff);
}
#endif // !defined(RF24_SPI_PTR)
endTransaction();
#endif // !defined(RF24_LINUX) && !defined(RF24_RP2)
}
/****************************************************************************/
uint8_t RF24::flush_rx(void)
{
read_register(FLUSH_RX, (uint8_t*)nullptr, 0);
IF_RF24_DEBUG(printf_P("[Flushing RX FIFO]"););
return status;
}
/****************************************************************************/
uint8_t RF24::flush_tx(void)
{
read_register(FLUSH_TX, (uint8_t*)nullptr, 0);
IF_RF24_DEBUG(printf_P("[Flushing RX FIFO]"););
return status;
}
/****************************************************************************/
#if !defined(MINIMAL)
void RF24::printStatus(uint8_t flags)
{
printf_P(PSTR("RX_DR=%x TX_DS=%x TX_DF=%x RX_PIPE=%x TX_FULL=%x\r\n"),
(flags & RF24_RX_DR) ? 1 : 0,
(flags & RF24_TX_DS) ? 1 : 0,
(flags & RF24_TX_DF) ? 1 : 0,
(flags >> RX_P_NO) & 0x07,
(flags & _BV(TX_FULL)) ? 1 : 0);
}
/****************************************************************************/
void RF24::print_observe_tx(uint8_t value)
{
printf_P(PSTR("OBSERVE_TX=%02x: PLOS_CNT=%x ARC_CNT=%x\r\n"), value, (value >> PLOS_CNT) & 0x0F, (value >> ARC_CNT) & 0x0F);
}
/****************************************************************************/
void RF24::print_byte_register(const char* name, uint8_t reg, uint8_t qty)
{
printf_P(PSTR(PRIPSTR
"\t="),
name);
while (qty--) {
printf_P(PSTR(" 0x%02x"), read_register(reg++));
}
printf_P(PSTR("\r\n"));
}
/****************************************************************************/
void RF24::print_address_register(const char* name, uint8_t reg, uint8_t qty)
{
printf_P(PSTR(PRIPSTR
"\t="),
name);
while (qty--) {
uint8_t* buffer = new uint8_t[addr_width];
read_register(reg++, buffer, addr_width);
printf_P(PSTR(" 0x"));
uint8_t* bufptr = buffer + addr_width;
while (--bufptr >= buffer) {
printf_P(PSTR("%02x"), *bufptr); // NOLINT: clang-tidy seems to emit a false positive about zero-allocated memory here (*bufptr)
}
delete[] buffer;
}
printf_P(PSTR("\r\n"));
}
/****************************************************************************/
uint8_t RF24::sprintf_address_register(char* out_buffer, uint8_t reg, uint8_t qty)
{
uint8_t offset = 0;
uint8_t* read_buffer = new uint8_t[addr_width];
while (qty--) {
read_register(reg++, read_buffer, addr_width);
uint8_t* bufptr = read_buffer + addr_width;
while (--bufptr >= read_buffer) {
offset += sprintf_P(out_buffer + offset, PSTR("%02X"), *bufptr); // NOLINT(clang-analyzer-cplusplus.NewDelete)
}
}
delete[] read_buffer;
return offset;
}
#endif // !defined(MINIMAL)
/****************************************************************************/
RF24::RF24(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin, uint32_t _spi_speed)
: ce_pin(_cepin),
csn_pin(_cspin),
spi_speed(_spi_speed),
payload_size(32),
_is_p_variant(false),
_is_p0_rx(false),
addr_width(5),
dynamic_payloads_enabled(true),
#if defined FAILURE_HANDLING
failureDetected(0),
#endif
csDelay(5)
{
_init_obj();
}
/****************************************************************************/
RF24::RF24(uint32_t _spi_speed)
: ce_pin(RF24_PIN_INVALID),
csn_pin(RF24_PIN_INVALID),
spi_speed(_spi_speed),
payload_size(32),
_is_p_variant(false),
_is_p0_rx(false),
addr_width(5),
dynamic_payloads_enabled(true),
#if defined FAILURE_HANDLING
failureDetected(0),
#endif
csDelay(5)
{
_init_obj();
}
/****************************************************************************/
void RF24::_init_obj()
{
// Use a pointer on the Arduino platform
#if defined(RF24_SPI_PTR) && !defined(RF24_RP2)
_spi = &SPI;
#endif // defined (RF24_SPI_PTR)
if (spi_speed <= 35000) { //Handle old BCM2835 speed constants, default to RF24_SPI_SPEED
spi_speed = RF24_SPI_SPEED;
}
}
/****************************************************************************/
void RF24::setChannel(uint8_t channel)
{
const uint8_t max_channel = 125;
write_register(RF_CH, rf24_min(channel, max_channel));
}
uint8_t RF24::getChannel()
{
return read_register(RF_CH);
}
/****************************************************************************/
void RF24::setPayloadSize(uint8_t size)
{
// payload size must be in range [1, 32]
payload_size = static_cast<uint8_t>(rf24_max(1, rf24_min(32, size)));
// write static payload size setting for all pipes
for (uint8_t i = 0; i < 6; ++i) {
write_register(static_cast<uint8_t>(RX_PW_P0 + i), payload_size);
}
}
/****************************************************************************/
uint8_t RF24::getPayloadSize(void)
{
return payload_size;
}
/****************************************************************************/
#if !defined(MINIMAL)
static const PROGMEM char rf24_datarate_e_str_0[] = "= 1 MBPS";
static const PROGMEM char rf24_datarate_e_str_1[] = "= 2 MBPS";
static const PROGMEM char rf24_datarate_e_str_2[] = "= 250 KBPS";
static const PROGMEM char* const rf24_datarate_e_str_P[] = {
rf24_datarate_e_str_0,
rf24_datarate_e_str_1,
rf24_datarate_e_str_2,
};
static const PROGMEM char rf24_model_e_str_0[] = "nRF24L01";
static const PROGMEM char rf24_model_e_str_1[] = "nRF24L01+";
static const PROGMEM char* const rf24_model_e_str_P[] = {
rf24_model_e_str_0,
rf24_model_e_str_1,
};
static const PROGMEM char rf24_crclength_e_str_0[] = "= Disabled";
static const PROGMEM char rf24_crclength_e_str_1[] = "= 8 bits";
static const PROGMEM char rf24_crclength_e_str_2[] = "= 16 bits";
static const PROGMEM char* const rf24_crclength_e_str_P[] = {
rf24_crclength_e_str_0,
rf24_crclength_e_str_1,
rf24_crclength_e_str_2,
};
static const PROGMEM char rf24_pa_dbm_e_str_0[] = "= PA_MIN";
static const PROGMEM char rf24_pa_dbm_e_str_1[] = "= PA_LOW";
static const PROGMEM char rf24_pa_dbm_e_str_2[] = "= PA_HIGH";
static const PROGMEM char rf24_pa_dbm_e_str_3[] = "= PA_MAX";
static const PROGMEM char* const rf24_pa_dbm_e_str_P[] = {
rf24_pa_dbm_e_str_0,
rf24_pa_dbm_e_str_1,
rf24_pa_dbm_e_str_2,
rf24_pa_dbm_e_str_3,
};
static const PROGMEM char rf24_feature_e_str_on[] = "= Enabled";
static const PROGMEM char rf24_feature_e_str_allowed[] = "= Allowed";
static const PROGMEM char rf24_feature_e_str_open[] = " open ";
static const PROGMEM char rf24_feature_e_str_closed[] = "closed";
static const PROGMEM char* const rf24_feature_e_str_P[] = {
rf24_crclength_e_str_0,
rf24_feature_e_str_on,
rf24_feature_e_str_allowed,
rf24_feature_e_str_closed,
rf24_feature_e_str_open,
};
void RF24::printDetails(void)
{
#if defined(RF24_LINUX)
printf("================ SPI Configuration ================\n");
uint8_t bus_ce = static_cast<uint8_t>(csn_pin % 10);
uint8_t bus_numb = static_cast<uint8_t>((csn_pin - bus_ce) / 10);
printf("CSN Pin\t\t= /dev/spidev%d.%d\n", bus_numb, bus_ce);
printf("CE Pin\t\t= Custom GPIO%d\n", ce_pin);
#endif
printf_P(PSTR("SPI Speedz\t= %d Mhz\n"), static_cast<uint8_t>(spi_speed / 1000000)); //Print the SPI speed on non-Linux devices
#if defined(RF24_LINUX)
printf("================ NRF Configuration ================\n");
#endif // defined(RF24_LINUX)
uint8_t status = update();
printf_P(PSTR("STATUS\t\t= 0x%02x "), status);
printStatus(status);
print_address_register(PSTR("RX_ADDR_P0-1"), RX_ADDR_P0, 2);
print_byte_register(PSTR("RX_ADDR_P2-5"), RX_ADDR_P2, 4);
print_address_register(PSTR("TX_ADDR\t"), TX_ADDR);
print_byte_register(PSTR("RX_PW_P0-6"), RX_PW_P0, 6);
print_byte_register(PSTR("EN_AA\t"), EN_AA);
print_byte_register(PSTR("EN_RXADDR"), EN_RXADDR);
print_byte_register(PSTR("RF_CH\t"), RF_CH);
print_byte_register(PSTR("RF_SETUP"), RF_SETUP);
print_byte_register(PSTR("CONFIG\t"), NRF_CONFIG);
print_byte_register(PSTR("DYNPD/FEATURE"), DYNPD, 2);
printf_P(PSTR("Data Rate\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_datarate_e_str_P[getDataRate()])));
printf_P(PSTR("Model\t\t= " PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_model_e_str_P[isPVariant()])));
printf_P(PSTR("CRC Length\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_crclength_e_str_P[getCRCLength()])));
printf_P(PSTR("PA Power\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_pa_dbm_e_str_P[getPALevel()])));
printf_P(PSTR("ARC\t\t= %d\r\n"), getARC());
}
void RF24::printPrettyDetails(void)
{
#if defined(RF24_LINUX)
printf("================ SPI Configuration ================\n");
uint8_t bus_ce = static_cast<uint8_t>(csn_pin % 10);
uint8_t bus_numb = static_cast<uint8_t>((csn_pin - bus_ce) / 10);
printf("CSN Pin\t\t\t= /dev/spidev%d.%d\n", bus_numb, bus_ce);
printf("CE Pin\t\t\t= Custom GPIO%d\n", ce_pin);
#endif
printf_P(PSTR("SPI Frequency\t\t= %d Mhz\n"), static_cast<uint8_t>(spi_speed / 1000000)); //Print the SPI speed on non-Linux devices
#if defined(RF24_LINUX)
printf("================ NRF Configuration ================\n");
#endif // defined(RF24_LINUX)
uint8_t channel = getChannel();
uint16_t frequency = static_cast<uint16_t>(channel + 2400);
printf_P(PSTR("Channel\t\t\t= %u (~ %u MHz)\r\n"), channel, frequency);
printf_P(PSTR("Model\t\t\t= " PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_model_e_str_P[isPVariant()])));
printf_P(PSTR("RF Data Rate\t\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_datarate_e_str_P[getDataRate()])));
printf_P(PSTR("RF Power Amplifier\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_pa_dbm_e_str_P[getPALevel()])));
printf_P(PSTR("RF Low Noise Amplifier\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((read_register(RF_SETUP) & 1) * 1)])));
printf_P(PSTR("CRC Length\t\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_crclength_e_str_P[getCRCLength()])));
printf_P(PSTR("Address Length\t\t= %d bytes\r\n"), (read_register(SETUP_AW) & 3) + 2);
printf_P(PSTR("Static Payload Length\t= %d bytes\r\n"), getPayloadSize());
uint8_t setupRetry = read_register(SETUP_RETR);
printf_P(PSTR("Auto Retry Delay\t= %d microseconds\r\n"), (setupRetry >> ARD) * 250 + 250);
printf_P(PSTR("Auto Retry Attempts\t= %d maximum\r\n"), setupRetry & 0x0F);
uint8_t observeTx = read_register(OBSERVE_TX);
printf_P(PSTR("Packets lost on\n current channel\t= %d\r\n"), observeTx >> 4);
printf_P(PSTR("Retry attempts made for\n last transmission\t= %d\r\n"), observeTx & 0x0F);
uint8_t features = read_register(FEATURE);
printf_P(PSTR("Multicast\t\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(features & _BV(EN_DYN_ACK)) * 2)])));
printf_P(PSTR("Custom ACK Payload\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(features & _BV(EN_ACK_PAY)) * 1)])));
uint8_t dynPl = read_register(DYNPD);
printf_P(PSTR("Dynamic Payloads\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((dynPl && (features & _BV(EN_DPL))) * 1)])));
uint8_t autoAck = read_register(EN_AA);
if (autoAck == 0x3F || autoAck == 0) {
// all pipes have the same configuration about auto-ack feature
printf_P(PSTR("Auto Acknowledgment\t" PRIPSTR
"\r\n"),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(autoAck) * 1)])));
}
else {
// representation per pipe
printf_P(PSTR("Auto Acknowledgment\t= 0b%c%c%c%c%c%c\r\n"),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P5)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P4)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P3)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P2)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P1)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P0)) + 48));
}
config_reg = read_register(NRF_CONFIG);
printf_P(PSTR("Primary Mode\t\t= %cX\r\n"), config_reg & _BV(PRIM_RX) ? 'R' : 'T');
print_address_register(PSTR("TX address\t"), TX_ADDR);
uint8_t openPipes = read_register(EN_RXADDR);
for (uint8_t i = 0; i < 6; ++i) {
bool isOpen = openPipes & _BV(i);
printf_P(PSTR("pipe %u (" PRIPSTR
") bound"),
i, (char*)(pgm_read_ptr(&rf24_feature_e_str_P[isOpen + 3])));
if (i < 2) {
print_address_register(PSTR(""), static_cast<uint8_t>(RX_ADDR_P0 + i));
}
else {
print_byte_register(PSTR(""), static_cast<uint8_t>(RX_ADDR_P0 + i));
}
}
}
/****************************************************************************/
uint16_t RF24::sprintfPrettyDetails(char* debugging_information)
{
const char* format_string = PSTR(
"================ SPI Configuration ================\n"
"CSN Pin\t\t\t= %d\n"
"CE Pin\t\t\t= %d\n"
"SPI Frequency\t\t= %d Mhz\n"
"================ NRF Configuration ================\n"
"Channel\t\t\t= %u (~ %u MHz)\n"
"RF Data Rate\t\t" PRIPSTR "\n"
"RF Power Amplifier\t" PRIPSTR "\n"
"RF Low Noise Amplifier\t" PRIPSTR "\n"
"CRC Length\t\t" PRIPSTR "\n"
"Address Length\t\t= %d bytes\n"
"Static Payload Length\t= %d bytes\n"
"Auto Retry Delay\t= %d microseconds\n"
"Auto Retry Attempts\t= %d maximum\n"
"Packets lost on\n current channel\t= %d\r\n"
"Retry attempts made for\n last transmission\t= %d\r\n"
"Multicast\t\t" PRIPSTR "\n"
"Custom ACK Payload\t" PRIPSTR "\n"
"Dynamic Payloads\t" PRIPSTR "\n"
"Auto Acknowledgment\t");
const char* format_str2 = PSTR("\nPrimary Mode\t\t= %cX\nTX address\t\t= 0x");
const char* format_str3 = PSTR("\nPipe %d (" PRIPSTR ") bound\t= 0x");
uint16_t offset = sprintf_P(
debugging_information, format_string, csn_pin, ce_pin,
static_cast<uint8_t>(spi_speed / 1000000), getChannel(),
static_cast<uint16_t>(getChannel() + 2400),
(char*)(pgm_read_ptr(&rf24_datarate_e_str_P[getDataRate()])),
(char*)(pgm_read_ptr(&rf24_pa_dbm_e_str_P[getPALevel()])),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((read_register(RF_SETUP) & 1) * 1)])),
(char*)(pgm_read_ptr(&rf24_crclength_e_str_P[getCRCLength()])),
((read_register(SETUP_AW) & 3) + 2), getPayloadSize(),
((read_register(SETUP_RETR) >> ARD) * 250 + 250),
(read_register(SETUP_RETR) & 0x0F), (read_register(OBSERVE_TX) >> 4),
(read_register(OBSERVE_TX) & 0x0F),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(read_register(FEATURE) & _BV(EN_DYN_ACK)) * 2)])),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(read_register(FEATURE) & _BV(EN_ACK_PAY)) * 1)])),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((read_register(DYNPD) && (read_register(FEATURE) & _BV(EN_DPL))) * 1)])));
uint8_t autoAck = read_register(EN_AA);
if (autoAck == 0x3F || autoAck == 0) {
// all pipes have the same configuration about auto-ack feature
offset += sprintf_P(
debugging_information + offset, PSTR("" PRIPSTR ""),
(char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(autoAck) * 1)])));
}
else {
// representation per pipe
offset += sprintf_P(
debugging_information + offset, PSTR("= 0b%c%c%c%c%c%c"),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P5)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P4)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P3)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P2)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P1)) + 48),
static_cast<char>(static_cast<bool>(autoAck & _BV(ENAA_P0)) + 48));
}
offset += sprintf_P(
debugging_information + offset, format_str2,
(read_register(NRF_CONFIG) & _BV(PRIM_RX) ? 'R' : 'T'));
offset += sprintf_address_register(debugging_information + offset, TX_ADDR);
uint8_t openPipes = read_register(EN_RXADDR);
for (uint8_t i = 0; i < 6; ++i) {
offset += sprintf_P(
debugging_information + offset, format_str3,
i, ((char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<bool>(openPipes & _BV(i)) + 3]))));
if (i < 2) {
offset += sprintf_address_register(
debugging_information + offset, static_cast<uint8_t>(RX_ADDR_P0 + i));
}
else {
offset += sprintf_P(
debugging_information + offset, PSTR("%02X"),
read_register(static_cast<uint8_t>(RX_ADDR_P0 + i)));
}
}
return offset;
}
/****************************************************************************/
void RF24::encodeRadioDetails(uint8_t* encoded_details)
{
uint8_t end = FEATURE + 1;
for (uint8_t i = NRF_CONFIG; i < end; ++i) {
if (i == RX_ADDR_P0 || i == RX_ADDR_P1 || i == TX_ADDR) {
// get 40-bit registers
read_register(i, encoded_details, 5);
encoded_details += 5;
}
else if (i != 0x18 && i != 0x19 && i != 0x1a && i != 0x1b) { // skip undocumented registers
// get single byte registers
*encoded_details++ = read_register(i);
}
}
*encoded_details++ = ce_pin >> 4;
*encoded_details++ = ce_pin & 0xFF;
*encoded_details++ = csn_pin >> 4;
*encoded_details++ = csn_pin & 0xFF;
*encoded_details = static_cast<uint8_t>((spi_speed / 1000000) | _BV(_is_p_variant * 4));
}
#endif // !defined(MINIMAL)
/****************************************************************************/
#if defined(RF24_SPI_PTR) || defined(DOXYGEN_FORCED)
// does not apply to RF24_LINUX
bool RF24::begin(_SPI* spiBus)
{
_spi = spiBus;
return _init_pins() && _init_radio();
}
/****************************************************************************/
bool RF24::begin(_SPI* spiBus, rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin)
{
ce_pin = _cepin;
csn_pin = _cspin;
return begin(spiBus);
}
#endif // defined (RF24_SPI_PTR) || defined (DOXYGEN_FORCED)
/****************************************************************************/
bool RF24::begin(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin)
{
ce_pin = _cepin;
csn_pin = _cspin;
return begin();
}
/****************************************************************************/
bool RF24::begin(void)
{
#if defined(RF24_LINUX)
#if defined(RF24_RPi)
switch (csn_pin) { // Ensure valid hardware CS pin
case 0: break;
case 1: break;
// Allow BCM2835 enums for RPi
case 8: csn_pin = 0; break;
case 7: csn_pin = 1; break;
case 18: csn_pin = 10; break; // to make it work on SPI1
case 17: csn_pin = 11; break;
case 16: csn_pin = 12; break;
default: csn_pin = 0; break;
}
#endif // RF24_RPi
_SPI.begin(csn_pin, spi_speed);
#elif defined(XMEGA_D3)
_spi->begin(csn_pin);
#elif defined(RF24_RP2)
_spi = new SPI();
_spi->begin(PICO_DEFAULT_SPI ? spi1 : spi0);
#else // using an Arduino platform || defined (LITTLEWIRE)
#if defined(RF24_SPI_PTR)
_spi->begin();
#else // !defined(RF24_SPI_PTR)
_SPI.begin();
#endif // !defined(RF24_SPI_PTR)
#endif // !defined(XMEGA_D3) && !defined(RF24_LINUX)
return _init_pins() && _init_radio();
}
/****************************************************************************/
bool RF24::_init_pins()
{
if (!isValid()) {
// didn't specify the CSN & CE pins to c'tor nor begin()
return false;
}
#if defined(RF24_LINUX)
pinMode(ce_pin, OUTPUT);
ce(LOW);
delay(100);
#elif defined(LITTLEWIRE)
pinMode(csn_pin, OUTPUT);
csn(HIGH);
#elif defined(XMEGA_D3)
if (ce_pin != csn_pin) {
pinMode(ce_pin, OUTPUT);
};
ce(LOW);
csn(HIGH);
delay(200);
#else // using an Arduino platform
// Initialize pins
if (ce_pin != csn_pin) {
pinMode(ce_pin, OUTPUT);
pinMode(csn_pin, OUTPUT);
}
ce(LOW);
csn(HIGH);
#if defined(__ARDUINO_X86__)
delay(100);
#endif
#endif // !defined(XMEGA_D3) && !defined(LITTLEWIRE) && !defined(RF24_LINUX)
return true; // assuming pins are connected properly
}
/****************************************************************************/
bool RF24::_init_radio()
{
// Must allow the radio time to settle else configuration bits will not necessarily stick.
// This is actually only required following power up but some settling time also appears to
// be required after resets too. For full coverage, we'll always assume the worst.
// Enabling 16b CRC is by far the most obvious case if the wrong timing is used - or skipped.
// Technically we require 4.5ms + 14us as a worst case. We'll just call it 5ms for good measure.
// WARNING: Delay is based on P-variant whereby non-P *may* require different timing.
delay(5);
// Set 1500uS (minimum for 32B payload in ESB@250KBPS) timeouts, to make testing a little easier
// WARNING: If this is ever lowered, either 250KBS mode with AA is broken or maximum packet
// sizes must never be used. See datasheet for a more complete explanation.
setRetries(5, 15);
// Then set the data rate to the slowest (and most reliable) speed supported by all hardware.
setDataRate(RF24_1MBPS);
// detect if is a plus variant & use old toggle features command accordingly
uint8_t before_toggle = read_register(FEATURE);
toggle_features();
uint8_t after_toggle = read_register(FEATURE);
_is_p_variant = before_toggle == after_toggle;
if (after_toggle) {
if (_is_p_variant) {
// module did not experience power-on-reset (#401)
toggle_features();
}
// allow use of multicast parameter and dynamic payloads by default
write_register(FEATURE, 0);
}
ack_payloads_enabled = false; // ack payloads disabled by default
write_register(DYNPD, 0); // disable dynamic payloads by default (for all pipes)
dynamic_payloads_enabled = false;
write_register(EN_AA, 0x3F); // enable auto-ack on all pipes
write_register(EN_RXADDR, 3); // only open RX pipes 0 & 1
setPayloadSize(32); // set static payload size to 32 (max) bytes by default
setAddressWidth(5); // set default address length to (max) 5 bytes
// Set up default configuration. Callers can always change it later.
// This channel should be universally safe and not bleed over into adjacent
// spectrum.
setChannel(76);
// Reset current status
// Notice reset and flush is the last thing we do
write_register(NRF_STATUS, RF24_IRQ_ALL);
// Flush buffers
flush_rx();
flush_tx();
// Clear CONFIG register:
// Reflect all IRQ events on IRQ pin
// Enable PTX
// Power Up
// 16-bit CRC (CRC required by auto-ack)
// Do not write CE high so radio will remain in standby I mode
// PTX should use only 22uA of power
write_register(NRF_CONFIG, (_BV(EN_CRC) | _BV(CRCO)));
config_reg = read_register(NRF_CONFIG);
powerUp();
// if config is not set correctly then there was a bad response from module
return config_reg == (_BV(EN_CRC) | _BV(CRCO) | _BV(PWR_UP)) ? true : false;
}
/****************************************************************************/
bool RF24::isChipConnected()
{
return read_register(SETUP_AW) == (addr_width - static_cast<uint8_t>(2));
}
/****************************************************************************/
bool RF24::isValid()
{
return ce_pin != RF24_PIN_INVALID && csn_pin != RF24_PIN_INVALID;
}
/****************************************************************************/
void RF24::startListening(void)
{
#if !defined(RF24_TINY) && !defined(LITTLEWIRE)
powerUp();
#endif
config_reg |= _BV(PRIM_RX);
write_register(NRF_CONFIG, config_reg);
write_register(NRF_STATUS, RF24_IRQ_ALL);
ce(HIGH);
// Restore the pipe0 address, if exists
if (_is_p0_rx) {
write_register(RX_ADDR_P0, pipe0_reading_address, addr_width);
}
else {
closeReadingPipe(0);
}
}
/****************************************************************************/
static const PROGMEM uint8_t child_pipe_enable[] = {ERX_P0, ERX_P1, ERX_P2,
ERX_P3, ERX_P4, ERX_P5};
void RF24::stopListening(void)
{
ce(LOW);
//delayMicroseconds(100);
delayMicroseconds(static_cast<int>(txDelay));
if (ack_payloads_enabled) {
flush_tx();
}
config_reg = static_cast<uint8_t>(config_reg & ~_BV(PRIM_RX));
write_register(NRF_CONFIG, config_reg);
#if defined(RF24_TINY) || defined(LITTLEWIRE)
// for 3 pins solution TX mode is only left with additional powerDown/powerUp cycle
if (ce_pin == csn_pin) {
powerDown();
powerUp();
}
#endif
write_register(RX_ADDR_P0, pipe0_writing_address, addr_width);
write_register(EN_RXADDR, static_cast<uint8_t>(read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[0])))); // Enable RX on pipe0
}
/****************************************************************************/
void RF24::stopListening(const uint64_t txAddress)
{
memcpy(pipe0_writing_address, &txAddress, addr_width);
stopListening();
write_register(TX_ADDR, pipe0_writing_address, addr_width);
}
/****************************************************************************/
void RF24::stopListening(const uint8_t* txAddress)
{
memcpy(pipe0_writing_address, txAddress, addr_width);
stopListening();
write_register(TX_ADDR, pipe0_writing_address, addr_width);
}
/****************************************************************************/
void RF24::powerDown(void)
{
ce(LOW); // Guarantee CE is low on powerDown
config_reg = static_cast<uint8_t>(config_reg & ~_BV(PWR_UP));
write_register(NRF_CONFIG, config_reg);
}
/****************************************************************************/
//Power up now. Radio will not power down unless instructed by MCU for config changes etc.
void RF24::powerUp(void)
{
// if not powered up then power up and wait for the radio to initialize
if (!(config_reg & _BV(PWR_UP))) {
config_reg |= _BV(PWR_UP);
write_register(NRF_CONFIG, config_reg);
// For nRF24L01+ to go from power down mode to TX or RX mode it must first pass through stand-by mode.
// There must be a delay of Tpd2stby (see Table 16.) after the nRF24L01+ leaves power down mode before
// the CEis set high. - Tpd2stby can be up to 5ms per the 1.0 datasheet
delayMicroseconds(RF24_POWERUP_DELAY);
}
}
/******************************************************************/
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
void RF24::errNotify()
{
#if defined(RF24_DEBUG) || defined(RF24_LINUX)
printf_P(PSTR("RF24 HARDWARE FAIL: Radio not responding, verify pin connections, wiring, etc.\r\n"));
#endif
#if defined(FAILURE_HANDLING)
failureDetected = 1;
#else
delay(5000);
#endif
}
#endif
/******************************************************************/
//Similar to the previous write, clears the interrupt flags
bool RF24::write(const void* buf, uint8_t len, const bool multicast)
{
//Start Writing
startFastWrite(buf, len, multicast);
//Wait until complete or failed
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
uint32_t timer = millis();
#endif // defined(FAILURE_HANDLING) || defined(RF24_LINUX)
while (!(update() & (RF24_TX_DS | RF24_TX_DF))) {
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
if (millis() - timer > 95) {
errNotify();
#if defined(FAILURE_HANDLING)
return 0;
#else
delay(100);
#endif
}
#endif
}
ce(LOW);
write_register(NRF_STATUS, RF24_IRQ_ALL);
//Max retries exceeded
if (status & RF24_TX_DF) {
flush_tx(); // Only going to be 1 packet in the FIFO at a time using this method, so just flush
return 0;
}
//TX OK 1 or 0
return 1;
}
bool RF24::write(const void* buf, uint8_t len)
{
return write(buf, len, 0);
}
/****************************************************************************/
//For general use, the interrupt flags are not important to clear
bool RF24::writeBlocking(const void* buf, uint8_t len, uint32_t timeout)
{
//Block until the FIFO is NOT full.
//Keep track of the MAX retries and set auto-retry if seeing failures
//This way the FIFO will fill up and allow blocking until packets go through
//The radio will auto-clear everything in the FIFO as long as CE remains high
uint32_t timer = millis(); // Get the time that the payload transmission started
while (update() & _BV(TX_FULL)) { // Blocking only if FIFO is full. This will loop and block until TX is successful or timeout
if (status & RF24_TX_DF) { // If MAX Retries have been reached
reUseTX(); // Set re-transmit and clear the MAX_RT interrupt flag
if (millis() - timer > timeout) {
return 0; // If this payload has exceeded the user-defined timeout, exit and return 0
}
}
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
if (millis() - timer > (timeout + 95)) {
errNotify();
#if defined(FAILURE_HANDLING)
return 0;
#endif
}
#endif
}
//Start Writing
startFastWrite(buf, len, 0); // Write the payload if a buffer is clear
return 1; // Return 1 to indicate successful transmission
}
/****************************************************************************/
void RF24::reUseTX()
{
ce(LOW);
write_register(NRF_STATUS, RF24_TX_DF); //Clear max retry flag
read_register(REUSE_TX_PL, (uint8_t*)nullptr, 0);
IF_RF24_DEBUG(printf_P("[Reusing payload in TX FIFO]"););
ce(HIGH); //Re-Transfer packet
}
/****************************************************************************/
bool RF24::writeFast(const void* buf, uint8_t len, const bool multicast)
{
//Block until the FIFO is NOT full.
//Keep track of the MAX retries and set auto-retry if seeing failures
//Return 0 so the user can control the retries and set a timer or failure counter if required
//The radio will auto-clear everything in the FIFO as long as CE remains high
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
uint32_t timer = millis();
#endif
//Blocking only if FIFO is full. This will loop and block until TX is successful or fail
while (update() & _BV(TX_FULL)) {
if (status & RF24_TX_DF) {
return 0; //Return 0. The previous payload has not been retransmitted
// From the user perspective, if you get a 0, call txStandBy()
}
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
if (millis() - timer > 95) {
errNotify();
#if defined(FAILURE_HANDLING)
return 0;
#endif // defined(FAILURE_HANDLING)
}
#endif
}
startFastWrite(buf, len, multicast); // Start Writing
return 1;
}
bool RF24::writeFast(const void* buf, uint8_t len)
{
return writeFast(buf, len, 0);
}
/****************************************************************************/
//Per the documentation, we want to set PTX Mode when not listening. Then all we do is write data and set CE high
//In this mode, if we can keep the FIFO buffers loaded, packets will transmit immediately (no 130us delay)
//Otherwise we enter Standby-II mode, which is still faster than standby mode
//Also, we remove the need to keep writing the config register over and over and delaying for 150 us each time if sending a stream of data
void RF24::startFastWrite(const void* buf, uint8_t len, const bool multicast, bool startTx)
{ //TMRh20
write_payload(buf, len, multicast ? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD);
if (startTx) {
ce(HIGH);
}
}
/****************************************************************************/
//Added the original startWrite back in so users can still use interrupts, ack payloads, etc
//Allows the library to pass all tests
bool RF24::startWrite(const void* buf, uint8_t len, const bool multicast)
{
// Send the payload
write_payload(buf, len, multicast ? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD);
ce(HIGH);
#if !defined(F_CPU) || F_CPU > 20000000
delayMicroseconds(10);
#endif
#ifdef ARDUINO_ARCH_STM32
if (F_CPU > 20000000) {
delayMicroseconds(10);
}
#endif
ce(LOW);
return !(status & _BV(TX_FULL));
}
/****************************************************************************/
bool RF24::rxFifoFull()
{
return read_register(FIFO_STATUS) & _BV(RX_FULL);
}
/****************************************************************************/
rf24_fifo_state_e RF24::isFifo(bool about_tx)
{
uint8_t state = (read_register(FIFO_STATUS) >> (4 * about_tx)) & 3;
return static_cast<rf24_fifo_state_e>(state);
}
/****************************************************************************/
bool RF24::isFifo(bool about_tx, bool check_empty)
{
return static_cast<bool>(static_cast<uint8_t>(isFifo(about_tx)) & _BV(!check_empty));
}
/****************************************************************************/
bool RF24::txStandBy()
{
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
uint32_t timeout = millis();
#endif
while (!(read_register(FIFO_STATUS) & _BV(TX_EMPTY))) {
if (status & RF24_TX_DF) {
write_register(NRF_STATUS, RF24_TX_DF);
ce(LOW);
flush_tx(); //Non blocking, flush the data
return 0;
}
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
if (millis() - timeout > 95) {
errNotify();
#if defined(FAILURE_HANDLING)
return 0;
#endif
}
#endif
}
ce(LOW); //Set STANDBY-I mode
return 1;
}
/****************************************************************************/
bool RF24::txStandBy(uint32_t timeout, bool startTx)
{
if (startTx) {
stopListening();
ce(HIGH);
}
uint32_t start = millis();
while (!(read_register(FIFO_STATUS) & _BV(TX_EMPTY))) {
if (status & RF24_TX_DF) {
write_register(NRF_STATUS, RF24_TX_DF);
ce(LOW); // Set re-transmit
ce(HIGH);
if (millis() - start >= timeout) {
ce(LOW);
flush_tx();
return 0;
}
}
#if defined(FAILURE_HANDLING) || defined(RF24_LINUX)
if (millis() - start > (timeout + 95)) {
errNotify();
#if defined(FAILURE_HANDLING)
return 0;
#endif
}
#endif
}
ce(LOW); //Set STANDBY-I mode
return 1;
}
/****************************************************************************/
void RF24::maskIRQ(bool tx, bool fail, bool rx)
{
/* clear the interrupt flags */
config_reg = static_cast<uint8_t>(config_reg & ~(1 << MASK_MAX_RT | 1 << MASK_TX_DS | 1 << MASK_RX_DR));
/* set the specified interrupt flags */
config_reg = static_cast<uint8_t>(config_reg | fail << MASK_MAX_RT | tx << MASK_TX_DS | rx << MASK_RX_DR);
write_register(NRF_CONFIG, config_reg);
}
/****************************************************************************/
uint8_t RF24::getDynamicPayloadSize(void)
{
uint8_t result = read_register(R_RX_PL_WID);
if (result > 32 || !result) {
flush_rx();
return 0;
}
return result;
}
/****************************************************************************/
bool RF24::available(void)
{
return (read_register(FIFO_STATUS) & 1) == 0;
}
/****************************************************************************/
bool RF24::available(uint8_t* pipe_num)
{
if (available()) { // if RX FIFO is not empty
*pipe_num = (update() >> RX_P_NO) & 0x07;
return 1;
}
return 0;
}
/****************************************************************************/
void RF24::read(void* buf, uint8_t len)
{
// Fetch the payload
read_payload(buf, len);
//Clear the only applicable interrupt flags
write_register(NRF_STATUS, RF24_RX_DR);
}
/****************************************************************************/
void RF24::whatHappened(bool& tx_ok, bool& tx_fail, bool& rx_ready)
{
// Read the status & reset the status in one easy call
// Or is that such a good idea?
write_register(NRF_STATUS, RF24_IRQ_ALL);
// Report to the user what happened
tx_ok = status & RF24_TX_DS;
tx_fail = status & RF24_TX_DF;
rx_ready = status & RF24_RX_DR;
}
/****************************************************************************/
uint8_t RF24::clearStatusFlags(uint8_t flags)
{
write_register(NRF_STATUS, flags & RF24_IRQ_ALL);
return status;
}
/****************************************************************************/
void RF24::setStatusFlags(uint8_t flags)
{
// flip the `flags` to translate from "human understanding"
config_reg = (config_reg & ~RF24_IRQ_ALL) | (~flags & RF24_IRQ_ALL);
write_register(NRF_CONFIG, config_reg);
}
/****************************************************************************/
uint8_t RF24::getStatusFlags()
{
return status;
}
/****************************************************************************/
uint8_t RF24::update()
{
read_register(RF24_NOP, (uint8_t*)nullptr, 0);
return status;
}
/****************************************************************************/
void RF24::openWritingPipe(uint64_t value)
{
// Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
// expects it LSB first too, so we're good.
write_register(RX_ADDR_P0, reinterpret_cast<uint8_t*>(&value), addr_width);
write_register(TX_ADDR, reinterpret_cast<uint8_t*>(&value), addr_width);
memcpy(pipe0_writing_address, &value, addr_width);
}
/****************************************************************************/
void RF24::openWritingPipe(const uint8_t* address)
{
// Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
// expects it LSB first too, so we're good.
write_register(RX_ADDR_P0, address, addr_width);
write_register(TX_ADDR, address, addr_width);
memcpy(pipe0_writing_address, address, addr_width);
}
/****************************************************************************/
static const PROGMEM uint8_t child_pipe[] = {RX_ADDR_P0, RX_ADDR_P1, RX_ADDR_P2,
RX_ADDR_P3, RX_ADDR_P4, RX_ADDR_P5};
void RF24::openReadingPipe(uint8_t child, uint64_t address)
{
// If this is pipe 0, cache the address. This is needed because
// openWritingPipe() will overwrite the pipe 0 address, so
// startListening() will have to restore it.
if (child == 0) {
memcpy(pipe0_reading_address, &address, addr_width);
_is_p0_rx = true;
}
if (child <= 5) {
// For pipes 2-5, only write the LSB
if (child > 1) {
write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), 1);
}
// avoid overwriting the TX address on pipe 0 while still in TX mode.
// NOTE, the cached RX address on pipe 0 is written when startListening() is called.
else if (static_cast<bool>(config_reg & _BV(PRIM_RX)) || child != 0) {
write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), addr_width);
}
// Note it would be more efficient to set all of the bits for all open
// pipes at once. However, I thought it would make the calling code
// more simple to do it this way.
write_register(EN_RXADDR, static_cast<uint8_t>(read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child]))));
}
}
/****************************************************************************/
void RF24::setAddressWidth(uint8_t a_width)
{
a_width = static_cast<uint8_t>(a_width - 2);
if (a_width) {
write_register(SETUP_AW, static_cast<uint8_t>(a_width % 4));
addr_width = static_cast<uint8_t>((a_width % 4) + 2);
}
else {
write_register(SETUP_AW, static_cast<uint8_t>(0));
addr_width = static_cast<uint8_t>(2);
}
}
/****************************************************************************/
void RF24::openReadingPipe(uint8_t child, const uint8_t* address)
{
// If this is pipe 0, cache the address. This is needed because
// openWritingPipe() will overwrite the pipe 0 address, so
// startListening() will have to restore it.
if (child == 0) {
memcpy(pipe0_reading_address, address, addr_width);
_is_p0_rx = true;
}
if (child <= 5) {
// For pipes 2-5, only write the LSB
if (child > 1) {
write_register(pgm_read_byte(&child_pipe[child]), address, 1);
}
// avoid overwriting the TX address on pipe 0 while still in TX mode.
// NOTE, the cached RX address on pipe 0 is written when startListening() is called.
else if (static_cast<bool>(config_reg & _BV(PRIM_RX)) || child != 0) {
write_register(pgm_read_byte(&child_pipe[child]), address, addr_width);
}
// Note it would be more efficient to set all of the bits for all open
// pipes at once. However, I thought it would make the calling code
// more simple to do it this way.
write_register(EN_RXADDR, static_cast<uint8_t>(read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child]))));
}
}
/****************************************************************************/
void RF24::closeReadingPipe(uint8_t pipe)
{
write_register(EN_RXADDR, static_cast<uint8_t>(read_register(EN_RXADDR) & ~_BV(pgm_read_byte(&child_pipe_enable[pipe]))));
if (!pipe) {
// keep track of pipe 0's RX state to avoid null vs 0 in addr cache
_is_p0_rx = false;
}
}
/****************************************************************************/
void RF24::toggle_features(void)
{
beginTransaction();
#if defined(RF24_SPI_PTR)
status = _spi->transfer(ACTIVATE);
_spi->transfer(0x73);
#else
status = _SPI.transfer(ACTIVATE);
_SPI.transfer(0x73);
#endif
endTransaction();
}
/****************************************************************************/
void RF24::enableDynamicPayloads(void)
{
// Enable dynamic payload throughout the system
//toggle_features();
write_register(FEATURE, read_register(FEATURE) | _BV(EN_DPL));
IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(FEATURE)));
// Enable dynamic payload on all pipes
//
// Not sure the use case of only having dynamic payload on certain
// pipes, so the library does not support it.
write_register(DYNPD, read_register(DYNPD) | _BV(DPL_P5) | _BV(DPL_P4) | _BV(DPL_P3) | _BV(DPL_P2) | _BV(DPL_P1) | _BV(DPL_P0));
dynamic_payloads_enabled = true;
}
/****************************************************************************/
void RF24::disableDynamicPayloads(void)
{
// Disables dynamic payload throughout the system. Also disables Ack Payloads
//toggle_features();
write_register(FEATURE, 0);
IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(FEATURE)));
// Disable dynamic payload on all pipes
//
// Not sure the use case of only having dynamic payload on certain
// pipes, so the library does not support it.
write_register(DYNPD, 0);
dynamic_payloads_enabled = false;
ack_payloads_enabled = false;
}
/****************************************************************************/
void RF24::enableAckPayload(void)
{
// enable ack payloads and dynamic payload features
if (!ack_payloads_enabled) {
write_register(FEATURE, read_register(FEATURE) | _BV(EN_ACK_PAY) | _BV(EN_DPL));
IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(FEATURE)));
// Enable dynamic payload on pipes 0 & 1
write_register(DYNPD, read_register(DYNPD) | _BV(DPL_P1) | _BV(DPL_P0));
dynamic_payloads_enabled = true;
ack_payloads_enabled = true;
}
}
/****************************************************************************/
void RF24::disableAckPayload(void)
{
// disable ack payloads (leave dynamic payload features as is)
if (ack_payloads_enabled) {
write_register(FEATURE, static_cast<uint8_t>(read_register(FEATURE) & ~_BV(EN_ACK_PAY)));
IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(FEATURE)));
ack_payloads_enabled = false;
}
}
/****************************************************************************/
void RF24::enableDynamicAck(void)
{
//
// enable dynamic ack features
//
//toggle_features();
write_register(FEATURE, read_register(FEATURE) | _BV(EN_DYN_ACK));
IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(FEATURE)));
}
/****************************************************************************/
bool RF24::writeAckPayload(uint8_t pipe, const void* buf, uint8_t len)
{
if (ack_payloads_enabled) {
const uint8_t* current = reinterpret_cast<const uint8_t*>(buf);
write_register(W_ACK_PAYLOAD | (pipe & 0x07), current, rf24_min(len, static_cast<uint8_t>(32)));
return !(status & _BV(TX_FULL));
}
return 0;
}
/****************************************************************************/
bool RF24::isAckPayloadAvailable(void)
{
return available();
}
/****************************************************************************/
bool RF24::isPVariant(void)
{
return _is_p_variant;
}
/****************************************************************************/
void RF24::setAutoAck(bool enable)
{
if (enable) {
write_register(EN_AA, 0x3F);
}
else {
write_register(EN_AA, 0);
// accommodate ACK payloads feature
if (ack_payloads_enabled) {
disableAckPayload();
}
}
}
/****************************************************************************/
void RF24::setAutoAck(uint8_t pipe, bool enable)
{
if (pipe < 6) {
uint8_t en_aa = read_register(EN_AA);
if (enable) {
en_aa |= static_cast<uint8_t>(_BV(pipe));
}
else {
en_aa = static_cast<uint8_t>(en_aa & ~_BV(pipe));
if (ack_payloads_enabled && !pipe) {
disableAckPayload();
}
}
write_register(EN_AA, en_aa);
}
}
/****************************************************************************/
bool RF24::testCarrier(void)
{
return (read_register(CD) & 1);
}
/****************************************************************************/
bool RF24::testRPD(void)
{
return (read_register(RPD) & 1);
}
/****************************************************************************/
void RF24::setPALevel(uint8_t level, bool lnaEnable)
{
uint8_t setup = read_register(RF_SETUP) & static_cast<uint8_t>(0xF8);
setup |= _pa_level_reg_value(level, lnaEnable);
write_register(RF_SETUP, setup);
}
/****************************************************************************/
uint8_t RF24::getPALevel(void)
{
return (read_register(RF_SETUP) & (_BV(RF_PWR_LOW) | _BV(RF_PWR_HIGH))) >> 1;
}
/****************************************************************************/
uint8_t RF24::getARC(void)
{
return read_register(OBSERVE_TX) & 0x0F;
}
/****************************************************************************/
bool RF24::setDataRate(rf24_datarate_e speed)
{
bool result = false;
uint8_t setup = read_register(RF_SETUP);
// HIGH and LOW '00' is 1Mbs - our default
setup = static_cast<uint8_t>(setup & ~(_BV(RF_DR_LOW) | _BV(RF_DR_HIGH)));
setup |= _data_rate_reg_value(speed);
write_register(RF_SETUP, setup);
// Verify our result
if (read_register(RF_SETUP) == setup) {
result = true;
}
return result;
}
/****************************************************************************/
rf24_datarate_e RF24::getDataRate(void)
{
rf24_datarate_e result;
uint8_t dr = read_register(RF_SETUP) & (_BV(RF_DR_LOW) | _BV(RF_DR_HIGH));
// switch uses RAM (evil!)
// Order matters in our case below
if (dr == _BV(RF_DR_LOW)) {
// '10' = 250KBPS
result = RF24_250KBPS;
}
else if (dr == _BV(RF_DR_HIGH)) {
// '01' = 2MBPS
result = RF24_2MBPS;
}
else {
// '00' = 1MBPS
result = RF24_1MBPS;
}
return result;
}
/****************************************************************************/
void RF24::setCRCLength(rf24_crclength_e length)
{
config_reg = static_cast<uint8_t>(config_reg & ~(_BV(CRCO) | _BV(EN_CRC)));
// switch uses RAM (evil!)
if (length == RF24_CRC_DISABLED) {
// Do nothing, we turned it off above.
}
else if (length == RF24_CRC_8) {
config_reg |= _BV(EN_CRC);
}
else {
config_reg |= _BV(EN_CRC);
config_reg |= _BV(CRCO);
}
write_register(NRF_CONFIG, config_reg);
}
/****************************************************************************/
rf24_crclength_e RF24::getCRCLength(void)
{
rf24_crclength_e result = RF24_CRC_DISABLED;
uint8_t AA = read_register(EN_AA);
config_reg = read_register(NRF_CONFIG);
if (config_reg & _BV(EN_CRC) || AA) {
if (config_reg & _BV(CRCO)) {
result = RF24_CRC_16;
}
else {
result = RF24_CRC_8;
}
}
return result;
}
/****************************************************************************/
void RF24::disableCRC(void)
{
config_reg = static_cast<uint8_t>(config_reg & ~_BV(EN_CRC));
write_register(NRF_CONFIG, config_reg);
}
/****************************************************************************/
void RF24::setRetries(uint8_t delay, uint8_t count)
{
write_register(SETUP_RETR, static_cast<uint8_t>(rf24_min(15, delay) << ARD | rf24_min(15, count)));
}
/****************************************************************************/
void RF24::startConstCarrier(rf24_pa_dbm_e level, uint8_t channel)
{
stopListening();
write_register(RF_SETUP, read_register(RF_SETUP) | _BV(CONT_WAVE) | _BV(PLL_LOCK));
if (isPVariant()) {
setAutoAck(0);
setRetries(0, 0);
uint8_t dummy_buf[32];
for (uint8_t i = 0; i < 32; ++i)
dummy_buf[i] = 0xFF;
// use write_register() instead of openWritingPipe() to bypass
// truncation of the address with the current RF24::addr_width value
write_register(TX_ADDR, reinterpret_cast<uint8_t*>(&dummy_buf), 5);
flush_tx(); // so we can write to top level
// use write_register() instead of write_payload() to bypass
// truncation of the payload with the current RF24::payload_size value
write_register(W_TX_PAYLOAD, reinterpret_cast<const uint8_t*>(&dummy_buf), 32);
disableCRC();
}
setPALevel(level);
setChannel(channel);
IF_RF24_DEBUG(printf_P(PSTR("RF_SETUP=%02x\r\n"), read_register(RF_SETUP)));
ce(HIGH);
if (isPVariant()) {
delay(1); // datasheet says 1 ms is ok in this instance
reUseTX(); // CE gets toggled here
}
}
/****************************************************************************/
void RF24::stopConstCarrier()
{
/*
* A note from the datasheet:
* Do not use REUSE_TX_PL together with CONT_WAVE=1. When both these
* registers are set the chip does not react when setting CE low. If
* however, both registers are set PWR_UP = 0 will turn TX mode off.
*/
powerDown(); // per datasheet recommendation (just to be safe)
write_register(RF_SETUP, static_cast<uint8_t>(read_register(RF_SETUP) & ~_BV(CONT_WAVE) & ~_BV(PLL_LOCK)));
ce(LOW);
flush_tx();
if (isPVariant()) {
// restore the cached TX address
write_register(TX_ADDR, pipe0_writing_address, addr_width);
}
}
/****************************************************************************/
void RF24::toggleAllPipes(bool isEnabled)
{
write_register(EN_RXADDR, static_cast<uint8_t>(isEnabled ? 0x3F : 0));
}
/****************************************************************************/
uint8_t RF24::_data_rate_reg_value(rf24_datarate_e speed)
{
#if !defined(F_CPU) || F_CPU > 20000000
txDelay = 280;
#else //16Mhz Arduino
txDelay = 85;
#endif
if (speed == RF24_250KBPS) {
#if !defined(F_CPU) || F_CPU > 20000000
txDelay = 505;
#else //16Mhz Arduino
txDelay = 155;
#endif
// Must set the RF_DR_LOW to 1; RF_DR_HIGH (used to be RF_DR) is already 0
// Making it '10'.
return static_cast<uint8_t>(_BV(RF_DR_LOW));
}
else if (speed == RF24_2MBPS) {
#if !defined(F_CPU) || F_CPU > 20000000
txDelay = 240;
#else // 16Mhz Arduino
txDelay = 65;
#endif
// Set 2Mbs, RF_DR (RF_DR_HIGH) is set 1
// Making it '01'
return static_cast<uint8_t>(_BV(RF_DR_HIGH));
}
// HIGH and LOW '00' is 1Mbs - our default
return static_cast<uint8_t>(0);
}
/****************************************************************************/
uint8_t RF24::_pa_level_reg_value(uint8_t level, bool lnaEnable)
{
// If invalid level, go to max PA
// Else set level as requested
// + lnaEnable (1 or 0) to support the SI24R1 chip extra bit
return static_cast<uint8_t>(((level > RF24_PA_MAX ? static_cast<uint8_t>(RF24_PA_MAX) : level) << 1) + lnaEnable);
}
/****************************************************************************/
void RF24::setRadiation(uint8_t level, rf24_datarate_e speed, bool lnaEnable)
{
uint8_t setup = _data_rate_reg_value(speed);
setup |= _pa_level_reg_value(level, lnaEnable);
write_register(RF_SETUP, setup);
}Pomocné funkce printf.h
/*
Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.
*/
/* Galileo support from spaniakos <spaniakos@gmail.com> */
/**
* @file printf.h
*
* Setup necessary to direct stdout to the Arduino Serial library, which
* enables 'printf'
*/
#ifndef RF24_PRINTF_H_
#define RF24_PRINTF_H_
#if defined(ARDUINO_ARCH_AVR) || defined(__ARDUINO_X86__) || defined(ARDUINO_ARCH_MEGAAVR)
int serial_putc(char c, FILE*)
{
Serial.write(c);
return c;
}
#elif defined(ARDUINO_ARCH_MBED)
REDIRECT_STDOUT_TO(Serial);
#endif // defined (ARDUINO_ARCH_AVR) || defined (__ARDUINO_X86__) || defined (ARDUINO_ARCH_MBED) || defined (ARDUINO_ARCH_MEGAAVR)
void printf_begin(void)
{
#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
fdevopen(&serial_putc, 0);
#elif defined(__ARDUINO_X86__)
// For redirect stdout to /dev/ttyGS0 (Serial Monitor port)
stdout = freopen("/dev/ttyGS0", "w", stdout);
delay(500);
printf("Redirecting to Serial...");
#endif // defined(__ARDUINO_X86__)
}
#endif // RF24_PRINTF_H_Celý projekt ke stažení ../hlidac_radio.tar.gz
Konstrukce
Viz předchozí článek nRF24L01+ 2.4GHz rádio.