nRF24l01 и Arduino – примеры использования

16.10.2023Вольтик.руИнструкции и решения проблемКомментариев нет

В современном «умном» мире появилась необходимость получать данные от удалённых устройств. Все методы получения условно делятся на два – проводные и беспроводные. Проводные надежны, сложны в перехвате, но дорогие и заметные, а также присутствует такая вещь, как токовая петля и падение напряжения. Беспроводные легче перехватить, они больше подвержены наводкам, но не имеют минусов, связанных с потерями или токовой петлёй. Однако, они требуют питания, в том числе и на удалённой стороне. Но есть один факт, который убивает провода в пух и прах – те самые передатчики, которые мы сегодня рассматриваем – nRF24l01 – стоят дешевле метра провода 22AWG.

Ну и, естественно, если у вас нет сверхспособностей, то данные в виде электромагнитного излучения вы не заметите, поэтому модуль можно спрятать в аккуратную коробочку, подходящую под интерьер, и не морочиться со вскрыванием стены и поиском оптимального пути для многометрового провода.

Обзор модуля nRF24l01

Nrf24l01

Модуль представляет собой непосредственно микросхему nRF, кварцевый резонатор, антенну и минимальную обвязку. Программа в микросхему зашита на производстве и изменению не подлежит; у Nordic есть микросхемы, в которых элемент радиопередачи добавлен как периферия (nRF24LE1 и прочие), но их мы рассматривать не будем.

Модуль поддерживает двунаправленное общение по интерфейсу SPI (Serial Peripheral Interface). Модуль самостоятельно формирует и отправляет пакет, мы снаружи можем лишь выставить нужные настройки, как скорость, частота и канал передачи, и загрузить данные в буфер на отправку, равно как и считать принятые данные.Низкоуровневая работа с радиоканалом недоступна конечному пользователю.

Каждый модуль имеет уникальный трёх-, четырёх- или пятибайтный адрес в пределах сети, что позволяет объединить большое количество модулей в единую сеть.

Для работы с модулем написано множество библиотек, основное отличие которых – в уровне общения. Некоторые из них просто предоставляют удобный доступ к регистрам, некоторые позволяют делать настройку с помощью удобных функций, а также есть библиотеки, которые даже реализуют свой протокол обмена! Одной из таких мы и будем пользоваться. Знакомьтесь – Mirf! Хотя, сначала стоит просто «железно» подключить модуль к микроконтроллеру.

Подключение nRF24l01 к Arduino

К сожалению, модуль нельзя подключить через макетную плату, так как в этом случае у него попарно замкнутся контакты. Поэтому мы сделали переходнички из кусочка макетной платы и гребёнок типа «папа» и типа «мама».

Всё, что нужно сделать – впаять с одной стороны две female-гребёнки рядом, а с другой стороны разнести male-гребёнки на шаг, кратный 2.54.Собственно, вот фотографии того, что у нас получилось:

Однако, если вам лениво ваять переходник, можно использовать обычные DuPont-коннекторы «папа-мама» для Arduino или «мама-мама» для Nano и ей подобных. Для организации обмена необходимо собрать минимум две «станции», состоящие из Arduino и nRF24l01.

Наиболее распространены модули, имеющие маску зелёного или чёрного цвета. На «зелёных» модулях распиновка нанесена шелкографией, а на чёрных нет (нанесена, но на усиленной ревизии +PALNA), поэтому мы сочли нужным привести картинку с распиновкой модуля:

Внимание! На зелёном модуле дублируются некоторые контакты, поэтому у него больше выводов, чем у чёрного, на функциональности это никак не сказывается.

Но, так как там, где у «чёрного» VCC, у «зелёного» – GND, то при подключении «хот плагом» можно сжечь модуль! Всегда проверяйте распиновку и правильность подключения перед включением питания!

На разных платах выводы интерфейса SPI находятся на разных пинах, как и в случае с почти всеми интерфейсами. Поэтому мы приводим таблицу распиновки интерфейса SPI на разных платах:

Плата Arduino	MOSI	MISO	SCK
Arduino Nano, Uno	11	12	13
Arduino Mega2560	51	50	52
Arduino Leonardo	ICSP-4	ICSP-1	ICSP-3

На платах Arduino, построенных на микроконтроллере ATMega32U4, то есть Arduino Leonardo и Arduino Pro Micro, интерфейс SPI присутствует толькона ICSP-разъёме (ICSP – In-Circuit System Programming, внутрисхемное программирование).

Распиновка ICSP-разъёма

Итак, теперь, когда нам известно всё необходимо для подключения, подсоединим же модуль! Подключение производится напрямую (MISO-MISO, MOSI-MOSI, SCK-SCK). Выводы CE (ChipEnable) и CSN (ChipSelectNot) можно подключить к любому цифровому пину. Мы выбрали D8 для CE и D7 для CSN, во всех наших примерах будут использоваться именно эти пины, так что либо подключайте так же, как мы, либо не забудьте потом поменять настройки в программе.

Модуль требует 3.3В/20мА для питания. Несмотря на все заверения в Интернете, что модуль работает и от 5В, datasheet устанавливает верхнюю границу напряжения питания в 3.6В (выводы толерантны к 5В), поэтому и мы питали его от 3.3В. Если на вашей плате нет встроенного преобразователя напряжения, необходимо использовать внешний, например LM1117 или XC2606. Мы крайне не рекомендуем подключать модуль к 5В и не отвечаем за последствия!

Для более стабильной работы рекомендуется напаять конденсатор не менее, чем на 10мкф прямо на ножки питания модуля, соблюдая полярность! Конденсатор для nRF24l01 – как подорожник, решает почти все проблемы с передачей и приёмом.

Итак, а вот теперь наступило время для программирования! Наконец-то вы познакомитесь с Mirf.

Обзор библиотеки Mirf

Для начала Библиотеку Mirf нужно скачать с сайта Arduino.

Установка стандартная (распакуйте папку с библиотекой в %папка_установки_Arduino_IDE%/libraries)

Теперь можно проверить работу наших модулей. Залейте в один модуль пример “ping_client”, а в другой – “ping_server” или просто следующие два скетча:

Пример кода для сервера:

/**
 *
 * Подключение:
 * Hardware SPI:
 * MISO -> 12
 * MOSI -> 11
 * SCK -> 13
 *
 * Настраиваемые пины:
 * CE -> 8
 * CSN -> 7
 *
 */

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

void setup(){
  Serial.begin(9600);

  /*
   * Подключение SPI драйвера.
   */

  Mirf.spi = &MirfHardwareSpi;

  /*
   * Установка пинов.
   */

  Mirf.init();

  /*
   * Задаём адрес приёмника.
   */

  Mirf.setRADDR((byte *)"serv1");

  /*
   * Устанавливаем размер полезной нагрузки (payload)
   * Значение должно совпадать для сервера и для клиента
   */

  Mirf.payload = sizeof(unsigned long);

  /*
   * Включаем приём
   */

  Mirf.config();

  Serial.println("Listening..."); 
}

void loop(){
  /*
   * Приёмный буфер
   */

  byte data[Mirf.payload];

  /*
   * Если пакет получен
   *
   * isSending так же восстанавливает режим прослушивания эфира
   * при переходе от true к false
   */

  if(!Mirf.isSending() && Mirf.dataReady()){
    Serial.println("Got packet");

    /*
     * Загружаем пакет в буфер
     */

    Mirf.getData(data);
    Mirf.setTADDR((byte *)"clie1");

    /*
     * Отправляем данные назад клиенту
     */

    Mirf.send(data);

    /*
     * Ожидаем окончания передачи
     */

    Serial.println("Reply sent.");
  }
}

/**

* Подключение:

* Hardware SPI:

* MISO -> 12

* MOSI -> 11

* SCK -> 13

* Настраиваемые пины:

* CE -> 8

* CSN -> 7

#include <SPI.h>

#include <Mirf.h>

#include <nRF24L01.h>

#include <MirfHardwareSpiDriver.h>

void setup(){

Serial.begin(9600);

* Подключение SPI драйвера.

Mirf.spi = &MirfHardwareSpi;

* Установка пинов.

Mirf.init();

* Задаём адрес приёмника.

Mirf.setRADDR((byte *)"serv1");

* Устанавливаем размер полезной нагрузки (payload)

* Значение должно совпадать для сервера и для клиента

Mirf.payload = sizeof(unsigned long);

* Включаем приём

Mirf.config();

Serial.println("Listening...");

}

void loop(){

* Приёмный буфер

byte data[Mirf.payload];

* Если пакет получен

* isSending так же восстанавливает режим прослушивания эфира

* при переходе от true к false

if(!Mirf.isSending() && Mirf.dataReady()){

Serial.println("Got packet");

* Загружаем пакет в буфер

Mirf.getData(data);

Mirf.setTADDR((byte *)"clie1");

* Отправляем данные назад клиенту

Mirf.send(data);

* Ожидаем окончания передачи

Serial.println("Reply sent.");

}

Пример кода для клиента:

/**
 * Пример, который позволяет определить задержку передачи
 *
 * Подключение:
 * SPI:
 * MISO -> 12
 * MOSI -> 11
 * SCK -> 13
 *
 * Настраиваемые:
 * CE -> 8
 * CSN -> 7
 *
 */

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

void setup(){

  Serial.begin(9600);
  /* Для указания пинов, к которым подключены
   * пины модуля, можно использовать переменные:
   *
   * Mirf.csnPin = 9;
   * Mirf.cePin = 7;
   */
  //Если переменные не заданы, используются значения по умолчанию (CE->8, CSN->7)

  // Инициализируем SPI интерфейс:
  Mirf.spi = &MirfHardwareSpi;
  // Инициализируем модуль:
  Mirf.init();

  // Устанавливаем адрес модуля

  Mirf.setRADDR((byte *)"clie1");

  // Устанавливаем размер пакета (payload)
  // Здесь устанавливаем payload равным размеру переменной unsigned long
  Mirf.payload = sizeof(unsigned long);

  // Включаем передатчик
  Mirf.config();
  Serial.println("Beginning ... ");
}

void loop(){
  // Получаем количество миллисекунд, прошедших с момента включения платы:
  unsigned long time = millis();
  // Устанавливаем адрес модуля. которому будем передавать пакет:
  Mirf.setTADDR((byte *)"serv1");
  // Передаём значение переменной time в виде массива байт:
  Mirf.send((byte *) &time);

  // Ждём окончания передачи
  while(Mirf.isSending()){
  }

  Serial.println("Finished sending");
  delay(10);
  // Если ничего не получено в ответ
  while(!Mirf.dataReady()){
    Serial.println("Waiting");
    // В течении секунды
    if ( ( millis() - time ) > 1000 ) {
      // Считаем. что пакет потерян
      Serial.println("Timeout on response from server!");
      return;
    }
  }
  // пробуем получить ответный пакет:
  Mirf.getData((byte *) &time);
  // Вычисляем задержку передачи
  // и выводим полученное значение в серийный порт:
  Serial.print("Ping: ");
  Serial.println((millis() - time));

  delay(1000);
}

/**

* Пример, который позволяет определить задержку передачи

* Подключение:

* SPI:

* MISO -> 12

* MOSI -> 11

* SCK -> 13

* Настраиваемые:

* CE -> 8

* CSN -> 7

#include <SPI.h>

#include <Mirf.h>

#include <nRF24L01.h>

#include <MirfHardwareSpiDriver.h>

void setup(){

Serial.begin(9600);

/* Для указания пинов, к которым подключены

* пины модуля, можно использовать переменные:

* Mirf.csnPin = 9;

* Mirf.cePin = 7;

//Если переменные не заданы, используются значения по умолчанию (CE->8, CSN->7)

// Инициализируем SPI интерфейс:

Mirf.spi = &MirfHardwareSpi;

// Инициализируем модуль:

Mirf.init();

// Устанавливаем адрес модуля

Mirf.setRADDR((byte *)"clie1");

// Устанавливаем размер пакета (payload)

// Здесь устанавливаем payload равным размеру переменной unsigned long

Mirf.payload = sizeof(unsigned long);

// Включаем передатчик

Mirf.config();

Serial.println("Beginning ... ");

}

void loop(){

// Получаем количество миллисекунд, прошедших с момента включения платы:

unsigned long time = millis();

// Устанавливаем адрес модуля. которому будем передавать пакет:

Mirf.setTADDR((byte *)"serv1");

// Передаём значение переменной time в виде массива байт:

Mirf.send((byte *) &time);

// Ждём окончания передачи

while(Mirf.isSending()){

}

Serial.println("Finished sending");

delay(10);

// Если ничего не получено в ответ

while(!Mirf.dataReady()){

Serial.println("Waiting");

// В течении секунды

if ( ( millis() - time ) > 1000 ) {

// Считаем. что пакет потерян

Serial.println("Timeout on response from server!");

return;

}

// пробуем получить ответный пакет:

Mirf.getData((byte *) &time);

// Вычисляем задержку передачи

// и выводим полученное значение в серийный порт:

Serial.print("Ping: ");

Serial.println((millis() - time));

delay(1000);

}

Если вы не напутали с подключением или с чем-нибудь ещё, то в мониторе последовательного порта вы увидите поток данных от одной платы к другой с указание времени “пинга” в миллисекундах. Но эти данные «бесполезны», хоть и позволяют оценить качество передачи данных. Попробуем же передать что-нибудь осмысленное! Для этого потребуется существенно увеличить код.

Передача полезных данных с помощью nRF24l01

Пример, рассмотренные выше, могут пригодиться для проверки новых приёмопередатчиков или как пример-основа для своего проекта. Но они не очень явно показывают, как передать пакет полезных данных с платы на плату. Поэтому сейчас мы напишем две программы – одну для «клиента», другую «для сервера» – которые реализуют простейший консольный интерфейс.

Клиент сможет отправлять на сервер команды, которые тот будет обрабатывать; к примеру, одной командой будем считывать напряжение на 0 канале АЦП, а другой – запрашивать значение millis(). Результаты обеих команд будут отправляться обратно клиенту. Также, на клиенте мы реализуем таймаут команды для предотвращения зависания в случае использования неправильной команды.

Чтобы не усложнять задачу, обе команды будут отправляться просто в цикле, к ним мы добавим третью команду для отработки таймаута. Для понимания кода ниже советуем изучить такие понятия как «указатель» и «ссылка» – на этих двух вещах в C держится очень многое. Познаете указатели – познаете Си. Хотя, в условиях Arduino можно жить и без этих понятий.

В приведённой ниже программе для светодиодной индикации используется пин 4 (на него надо повесить светодиод через резистор на 1кОм к земле). Если вы хотите переназначить пин, сверьтесь с таблицей выше, чтобы не выбрать пин, работающий в интерфейсе SPI.

Код сервера:

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

// Адрес модуля
#define ADDR "serv1"
// Размер полезной нагрузки
#define PAYLOAD sizeof(unsigned long)
// Светодиод для индикации - 4 пин
#define StatusLed 4
// Переменная для приёма и передачи данных
unsigned long data=0;
unsigned long command=0;

void setup(){
  Serial.begin(9600);
  // Мигнём светодиодом:
  pinMode(StatusLed, OUTPUT);
  for (byte i=0; i<3; i++) {
    digitalWrite(StatusLed, HIGH);
    delay(100);
    digitalWrite(StatusLed, LOW);
  }

  Mirf.cePin = 8;
  Mirf.csnPin = 7;
  Mirf.spi = &MirfHardwareSpi;
  MirfHardwareSpi;
  Mirf.init();

  Mirf.setRADDR((byte*)ADDR);
  Mirf.payload = sizeof(unsigned long);
  Mirf.config();
  Serial.println("Beginning ... ");
}
void loop() {
  // Обнуляем переменную с данными:
  data=0;
  command=0;
  // Ждём данных
  if(!Mirf.isSending() && Mirf.dataReady()){
    Serial.println("Got packet");
    //Сообщаем коротким миганием светодиода о наличии данных
    digitalWrite(StatusLed, HIGH);
    delay(100);
    digitalWrite(StatusLed, LOW);
    // Принимаем пакет данные в виде массива байт в переменную data:
    Mirf.getData((byte *) &command);
    // Сообщаем длинным миганием светодиода о получении данных
    digitalWrite(StatusLed, HIGH);
    delay(500);
    digitalWrite(StatusLed, LOW);
    // Выводим полученные данные в монитор серийного порта
    Serial.print("Get data: ");
    Serial.println(command);
  }
  // Если переменная не нулевая, формируем ответ:
  if (command!=0) {
    switch(command) {
    case 1:
      // Команда 1 - отправить число милисекунд,
      // прошедших с последней перезагрузки платы
      Serial.println("Command 1. Send millis().");
      data=millis();
      break;
    case 2:
      // команда 2 - отправить значение с пина AnalogPin0
      Serial.println("Command 2. Send A0 reference.");
      data=analogRead(A0);
      break;
    default:
      // Нераспознанная команда. Сердито мигаем светодиодом 10 раз и
      // жалуемся в последовательный порт
      Serial.println("Unknown command");
      for (byte i=0; i<10; i++) {
        digitalWrite(StatusLed, HIGH);
        delay(100);
        digitalWrite(StatusLed, LOW);
      }
      break;
    }
    // Отправляем ответ:

    Mirf.setTADDR((byte *)"clie1");
    //Отправляем ответ в виде массива байт:
    Mirf.send((byte *)&data);
  }
  // Экспериментально вычисленная задержка.
  // Позволяет избежать проблем с модулем.
  delay(10);
}

#include <SPI.h>

#include <Mirf.h>

#include <nRF24L01.h>

#include <MirfHardwareSpiDriver.h>

// Адрес модуля

#define ADDR "serv1"

// Размер полезной нагрузки

#define PAYLOAD sizeof(unsigned long)

// Светодиод для индикации - 4 пин

#define StatusLed 4

// Переменная для приёма и передачи данных

unsigned long data=0;

unsigned long command=0;

void setup(){

Serial.begin(9600);

// Мигнём светодиодом:

pinMode(StatusLed, OUTPUT);

for (byte i=0; i<3; i++) {

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

}

Mirf.cePin = 8;

Mirf.csnPin = 7;

Mirf.spi = &MirfHardwareSpi;

MirfHardwareSpi;

Mirf.init();

Mirf.setRADDR((byte*)ADDR);

Mirf.payload = sizeof(unsigned long);

Mirf.config();

Serial.println("Beginning ... ");

}

void loop() {

// Обнуляем переменную с данными:

data=0;

command=0;

// Ждём данных

if(!Mirf.isSending() && Mirf.dataReady()){

Serial.println("Got packet");

//Сообщаем коротким миганием светодиода о наличии данных

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

// Принимаем пакет данные в виде массива байт в переменную data:

Mirf.getData((byte *) &command);

// Сообщаем длинным миганием светодиода о получении данных

digitalWrite(StatusLed, HIGH);

delay(500);

digitalWrite(StatusLed, LOW);

// Выводим полученные данные в монитор серийного порта

Serial.print("Get data: ");

Serial.println(command);

}

// Если переменная не нулевая, формируем ответ:

if (command!=0) {

switch(command) {

case 1:

// Команда 1 - отправить число милисекунд,

// прошедших с последней перезагрузки платы

Serial.println("Command 1. Send millis().");

data=millis();

break;

case 2:

// команда 2 - отправить значение с пина AnalogPin0

Serial.println("Command 2. Send A0 reference.");

data=analogRead(A0);

break;

default:

// Нераспознанная команда. Сердито мигаем светодиодом 10 раз и

// жалуемся в последовательный порт

Serial.println("Unknown command");

for (byte i=0; i<10; i++) {

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

}

break;

}

// Отправляем ответ:

Mirf.setTADDR((byte *)"clie1");

//Отправляем ответ в виде массива байт:

Mirf.send((byte *)&data);

}

// Экспериментально вычисленная задержка.

// Позволяет избежать проблем с модулем.

delay(10);

}

Код клиента:

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

// Адрес модуля
#define ADDR "clie1"
#define PAYLOAD sizeof(unsigned long)
// Светодиод для индикации - 4 пин
#define StatusLed 4
// Переменная для приёма и передачи данных
unsigned long data=0;
unsigned long command=0;
// Флаг для определения выхода по таймауту
boolean timeout=false;
// Таймаут ожидания ответа от сервера - 1 секунда
#define TIMEOUT 1000
// Переменная для запоминания времени отправки
unsigned long timestamp=0;

void setup(){
  Serial.begin(9600);
  // Мигнём светодиодом:
  pinMode(StatusLed, OUTPUT);
  for (byte i=0; i<3; i++) {
    digitalWrite(StatusLed, HIGH);
    delay(100);
    digitalWrite(StatusLed, LOW);
  }

  Mirf.cePin = 8;
  Mirf.csnPin = 7;
  Mirf.spi = &MirfHardwareSpi;
  Mirf.init();

  Mirf.setRADDR((byte*)ADDR);
  Mirf.payload = sizeof(unsigned long);
  Mirf.config();
  Serial.println("Beginning ... ");
}

void loop() {
  timeout=false;
  // Устанавливаем адрес передачи
  Mirf.setTADDR((byte *)&"serv1");
  // Запрашиваем число милисекунд,
  // прошедших с последней перезагрузки сервера:
  Serial.println("Request millis()");
  command=1;
  Mirf.send((byte *)&command);
  // Мигнули 1 раз - команда отправлена
  digitalWrite(StatusLed, HIGH);
  delay(100);
  digitalWrite(StatusLed, LOW);
  // Запомнили время отправки:
  timestamp=millis();
  // Запускаем профедуру ожидания ответа
  waitanswer();

  // Запрашиваем число милисекунд,
  // прошедших с последней перезагрузки сервера:
  Serial.println("Request A0 reference");
  command=2;
  Mirf.send((byte *)&command);
  // Мигнули 1 раз - команда отправлена
  digitalWrite(StatusLed, HIGH);
  delay(100);
  digitalWrite(StatusLed, LOW);
  // Запомнили время отправки:
  timestamp=millis();
  // Запускаем профедуру ожидания ответа
  waitanswer();

  // Отправляем невалидную команду
  // прошедших с последней перезагрузки сервера:
  Serial.println("Invalid command");
  command=42;
  Mirf.send((byte *)&command);
  // Мигнули 1 раз - команда отправлена
  digitalWrite(StatusLed, HIGH);
  delay(100);
  digitalWrite(StatusLed, LOW);
  // Запомнили время отправки:
  timestamp=millis();
  // Запускаем профедуру ожидания ответа
  waitanswer();
  // Эксперимаентально вычисленная задержка.
  // Позволяет избежать проблем с модулем.
  delay(10);
  Serial.println("-----------------------------------------");
  delay(1000);
}

void waitanswer() {
  // Немного плохого кода:
  // Устанавливаем timeout в ИСТИНУ
  // Если ответ будет получен, установим переменную в ЛОЖЬ
  // Если ответа не будет - считаем ситуацию выходом по таймауту
  timeout=true;
  // Ждём ответ или таймута ожидания
  while(millis()-timestamp

100

101

#include <SPI.h>

#include <Mirf.h>

#include <nRF24L01.h>

#include <MirfHardwareSpiDriver.h>

// Адрес модуля

#define ADDR "clie1"

#define PAYLOAD sizeof(unsigned long)

// Светодиод для индикации - 4 пин

#define StatusLed 4

// Переменная для приёма и передачи данных

unsigned long data=0;

unsigned long command=0;

// Флаг для определения выхода по таймауту

boolean timeout=false;

// Таймаут ожидания ответа от сервера - 1 секунда

#define TIMEOUT 1000

// Переменная для запоминания времени отправки

unsigned long timestamp=0;

void setup(){

Serial.begin(9600);

// Мигнём светодиодом:

pinMode(StatusLed, OUTPUT);

for (byte i=0; i<3; i++) {

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

}

Mirf.cePin = 8;

Mirf.csnPin = 7;

Mirf.spi = &MirfHardwareSpi;

Mirf.init();

Mirf.setRADDR((byte*)ADDR);

Mirf.payload = sizeof(unsigned long);

Mirf.config();

Serial.println("Beginning ... ");

}

void loop() {

timeout=false;

// Устанавливаем адрес передачи

Mirf.setTADDR((byte *)&"serv1");

// Запрашиваем число милисекунд,

// прошедших с последней перезагрузки сервера:

Serial.println("Request millis()");

command=1;

Mirf.send((byte *)&command);

// Мигнули 1 раз - команда отправлена

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

// Запомнили время отправки:

timestamp=millis();

// Запускаем профедуру ожидания ответа

waitanswer();

// Запрашиваем число милисекунд,

// прошедших с последней перезагрузки сервера:

Serial.println("Request A0 reference");

command=2;

Mirf.send((byte *)&command);

// Мигнули 1 раз - команда отправлена

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

// Запомнили время отправки:

timestamp=millis();

// Запускаем профедуру ожидания ответа

waitanswer();

// Отправляем невалидную команду

// прошедших с последней перезагрузки сервера:

Serial.println("Invalid command");

command=42;

Mirf.send((byte *)&command);

// Мигнули 1 раз - команда отправлена

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

// Запомнили время отправки:

timestamp=millis();

// Запускаем профедуру ожидания ответа

waitanswer();

// Эксперимаентально вычисленная задержка.

// Позволяет избежать проблем с модулем.

delay(10);

Serial.println("-----------------------------------------");

delay(1000);

}

void waitanswer() {

// Немного плохого кода:

// Устанавливаем timeout в ИСТИНУ

// Если ответ будет получен, установим переменную в ЛОЖЬ

// Если ответа не будет - считаем ситуацию выходом по таймауту

timeout=true;

// Ждём ответ или таймута ожидания

while(millis()-timestamp

После заливки кода, если вы не ошиблись в подключении, то увидите в мониторе порта клиента примерно такую картину:

Ответ клиента после настройки NRF24L01

А со стороны сервера такую:

Ответ сервера после настройки NRF24L01

Особенности использования библиотеки Mirf

Хотим отметить небольшие особенности использования библиотеки Mirf: например, данные отправляемые и данные принимаемые лучше хранить в разных переменных, не объединяя их. Если в переменную data внести значение, потом передать его, а потом снова считать значение в переменную data, то там появится рандомное число. Возможно, мы где-то намудрили со ссылками или указателями, потому как не постигли этот дзен. Одно можем сказать точно – вышеприведённый код работает.

Ещё в коде присутствует задержка в 10 миллисекунд между отправкой пакетов – без этой задержки модуль зависал при обращении к нему после считывания данных. Но это, скорее всего, аппаратная проблема nRF24l01.

Мы взяли на себя перевод описания некоторых функций библиотеки Mirf и приводим его тут.

mirf.payload = PAYLOAD, гдеPAYLOAD – размер буфера отправки в байтах. Его можно задать как явно (просто цифрой), так и через какую-либо функцию. Мы использовали sizeof – она возвращает размер аргумента в байтах. В качестве аргумента можно передать как тип (мы использовали unsignedlong = 4 байта – sizeof(unsignedlong)), так и имя переменной. Размер буфера нельзя задавать меньше размера отправляемых данных и не рекомендуется задавать больше, так как возникают неуловимые баги. Размер буфера не может быть больше размера внутренних FIFO-буферов nRF24l01 (FIFO – FirstInput, FirstOutput–первый пришел, первый ушёл), который составляет 32 байта. Приёмопередатчик с лёгкостью примет в себя такой размер, но что будет на выходе – не знает никто. Если же вам нужно передавать пакеты более 32 байт, то надо разрабатывать собственный протокол и делить пакет на 32-байтные куски.Mirf.setRADDR((byte*)’serv1′) – задаёт адрес для приёма, именно на него надо отправлять данные, если они хотят попасть на данный модуль. R- Receive, «приём».

Mirf.setTADDR((byte*)’clie1′) – задаёт адрес для отправки данных. Алгоритм применения этих функций у нас таков – первый модуль выставляет свой адрес для приёмника как «serv1» и слушает эфир как сервер. Второй модуль устанавливает адрес для приёма как «clie1» и тоже начинает слушать эфир. Сервер устанавливает адрес для отправки в «clie1» и отправляет пакет с данными. По приёму пакета, клиент устанавливает адрес для отправки в «serv1» и отвечает серверу. Адреспередаётся в виде массива. Его размер должен быть от 3 до 5 байт!

Mirf.isSending() – с помощью этой функции можно узнать, идёт ли в текущий момент передача или нет. Так как буферы приёма и передачи совпадают друг с другом, то есть вероятность чтения отправляемых, а не принимаемых данных – чтобы исключить это, используйте эту функцию.

Mirf.dataReady() – проверяет готовность модуля отдать микроконтроллеру свежепринятый пакет с данными. Мы не можем повлиять на приём, можем только констатировать его факт.

Mirf.getData((byte *) &data) – читает принятый пакет в переменную или массив переменных. Функции передаётся ссылка на переменную.

Mirf.send((byte *) &data) инициирует начало отправки пакета данных. Как аргумент принимает ссылку на массив с данными или переменную. Ссылку можно понять так – это адрес в памяти, который указывает на блок данных библиотеке. Библиотека выкопирует эти данные в буфер, оттуда – в ФИФО приёмопередатчика, а потом они полетят электромагнитными волнами к приёмнику. Передавать таким образом можно абсолютно любые данные с известными ограничениями в их размере.

А теперь давайте попробуем передать структуру данных!

Передача структуры данных

Структура может объединить в себе множество переменных разного вида и упростить доступ к ним. Повторяющиеся пакеты данных, к примеру, телефонная книга (имя – номер – адрес etc) легче реализуются с помощью структур – пропадает необходимость создавать огромное количество переменных. При объявлении структуры ей можно присвоить тип – тогда создание новых структур ничем не отличится от создания переменных.

В качестве примера реализуем передачу команды по цепочке (инициатором начала передачи тоже будет команда, допустим, «1»). Также реализуем отчёт в случае успешной передачи (ответом будет смысл Вселенной, Жизни и Всего Такого – число 42). Каждый модуль знает только свой адрес и адрес следующего модуля; для наглядности цепи сделаем сеть из трёх модулей, первый из которых будет инициировать передачу. Пример не очень нагляден, но нам важна техническая сторона передачи структуры.

Собственно в структуре мы будем хранить и передавать адрес предыдущего модуля (для отчёта) и команду. Передача строк внутри структуры так же проста, как передача простых переменных. Самое сложное – грамотно посчитать размер структуры и внести его в payload. Естественно, структуры у всех участников сети должны быть одинаковы, иначе возникнут ошибки.

Программа для трёх модулей отличается лишь парой переменных в начале:

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

// Адрес модуля
#define ADDR "mod0"
// Адрес следующего в цепочке модуля
#define NEXT "mod1"
//Этот модуль начинает цепочку?
boolean iamfirst=true;
// Размер полезной нагрузки
#define PAYLOAD 6
// Светодиод для индикации - 4 пин
#define StatusLed 4
// Структуры для приёма и передачи данных
typedef struct { //Структура ответа
  byte From[5];//Адрес отправителя
  byte Result;//Результат выполнения команды (в нашем случае всегда 1)
}
AnswerStruct;
typedef struct { //Структура запроса
  byte From[5];//Адрес отправителя
  byte Command;//Команда (в нашем случае всегда 1)
}
RequestStruct;
//Принимаем мы всегда AnswerStruct , а оправляем RequestStruct. Так проще.
//Отличать ответ на наш запрос от нового запроса нужно логикой внутри программы.

//Обнулим структуры на всякий случай:
AnswerStruct Ans={
  "0000", 255}; 
RequestStruct Req={
 "0000", 255};
// Флаг для определения выхода по таймауту
boolean timeout=false;
// Таймаут ожидания ответа - 1 секунда
#define TIMEOUT 1000
// Переменная для запоминания времени отправки
unsigned long timestamp=0;

void setup(){
  Serial.begin(9600);
  // Мигнём светодиодом:
  pinMode(StatusLed, OUTPUT);
  for (byte i=0; i<3; i++) {
    digitalWrite(StatusLed, HIGH);
    delay(100);
    digitalWrite(StatusLed, LOW);
  }

  Mirf.cePin = 8;
  Mirf.csnPin = 7;
  Mirf.spi = &MirfHardwareSpi;
  Mirf.init();

  Mirf.setRADDR((byte*)ADDR);
  Mirf.payload = PAYLOAD;
  Mirf.config();
  Serial.println("Beginning ..");
}

void loop() {
  // Если нужно начинать цепочку, то начинаем:
  if (iamfirst) {
    Serial.println("I am first!!!");
    iamfirst = false;
    sendStruct(1, (byte*)NEXT);
  }
  //Проверяем, не получили мы данные:
  if(!Mirf.isSending() && Mirf.dataReady()) {

    // Принимаем пакет данных в виде массива байт в структуру :
    Mirf.getData((byte *)&Ans);
    // Выводим полученные данные в монитор серийного порта
    Serial.print("Get data from: ");
    Serial.print((char*)Ans.From);
    Serial.print(":");
    Serial.println(Ans.Result);
  }
  //Если что-то пришло, действуем:
  if (Ans.Result==1) {
    //Это запроc на продолжение цепочки. Ждём секунду и отправляем назад отчёт:
    delay(1000);
    Serial.print("Need to send OK to ");
    Serial.println((char*)Ans.From);
    sendStruct(42, (byte*)Ans.From);
    //Ещё секунда и продолжаем цепочку:
    delay(1000);
    sendStruct(1, (byte*)NEXT);

  }
  if (Ans.Result==42) {
    //А это просто подтверждение
    Serial.println("OK");
  }
  //Обнуляем:
  Ans.Result=0;
}

void sendStruct(byte command, byte* addr) {
  memcpy(&Req.From, &ADDR, 4);
  Req.Command=command;
  Serial.print("Send ");
  Serial.print(Req.Command);
  Serial.print(" to ");
  Serial.println((char*)addr);
  // Устанавливаем адрес передачи
  Mirf.setTADDR(addr);
  //Отправляем
  Mirf.send((byte *)&Req);
  // Эксперимаентально вычисленная задержка.
  // Позволяет избежать проблем с модулем.
  delay(10);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

#include <SPI.h>

#include <Mirf.h>

#include <nRF24L01.h>

#include <MirfHardwareSpiDriver.h>

// Адрес модуля

#define ADDR "mod0"

// Адрес следующего в цепочке модуля

#define NEXT "mod1"

//Этот модуль начинает цепочку?

boolean iamfirst=true;

// Размер полезной нагрузки

#define PAYLOAD 6

// Светодиод для индикации - 4 пин

#define StatusLed 4

// Структуры для приёма и передачи данных

typedef struct { //Структура ответа

byte From[5];//Адрес отправителя

byte Result;//Результат выполнения команды (в нашем случае всегда 1)

}

AnswerStruct;

typedef struct { //Структура запроса

byte From[5];//Адрес отправителя

byte Command;//Команда (в нашем случае всегда 1)

}

RequestStruct;

//Принимаем мы всегда AnswerStruct , а оправляем RequestStruct. Так проще.

//Отличать ответ на наш запрос от нового запроса нужно логикой внутри программы.

//Обнулим структуры на всякий случай:

AnswerStruct Ans={

"0000", 255};

RequestStruct Req={

"0000", 255};

// Флаг для определения выхода по таймауту

boolean timeout=false;

// Таймаут ожидания ответа - 1 секунда

#define TIMEOUT 1000

// Переменная для запоминания времени отправки

unsigned long timestamp=0;

void setup(){

Serial.begin(9600);

// Мигнём светодиодом:

pinMode(StatusLed, OUTPUT);

for (byte i=0; i<3; i++) {

digitalWrite(StatusLed, HIGH);

delay(100);

digitalWrite(StatusLed, LOW);

}

Mirf.cePin = 8;

Mirf.csnPin = 7;

Mirf.spi = &MirfHardwareSpi;

Mirf.init();

Mirf.setRADDR((byte*)ADDR);

Mirf.payload = PAYLOAD;

Mirf.config();

Serial.println("Beginning ..");

}

void loop() {

// Если нужно начинать цепочку, то начинаем:

if (iamfirst) {

Serial.println("I am first!!!");

iamfirst = false;

sendStruct(1, (byte*)NEXT);

}

//Проверяем, не получили мы данные:

if(!Mirf.isSending() && Mirf.dataReady()) {

// Принимаем пакет данных в виде массива байт в структуру :

Mirf.getData((byte *)&Ans);

// Выводим полученные данные в монитор серийного порта

Serial.print("Get data from: ");

Serial.print((char*)Ans.From);

Serial.print(":");

Serial.println(Ans.Result);

}

//Если что-то пришло, действуем:

if (Ans.Result==1) {

//Это запроc на продолжение цепочки. Ждём секунду и отправляем назад отчёт:

delay(1000);

Serial.print("Need to send OK to ");

Serial.println((char*)Ans.From);

sendStruct(42, (byte*)Ans.From);

//Ещё секунда и продолжаем цепочку:

delay(1000);

sendStruct(1, (byte*)NEXT);

}

if (Ans.Result==42) {

//А это просто подтверждение

Serial.println("OK");

}

//Обнуляем:

Ans.Result=0;

}

void sendStruct(byte command, byte* addr) {

memcpy(&Req.From, &ADDR, 4);

Req.Command=command;

Serial.print("Send ");

Serial.print(Req.Command);

Serial.print(" to ");

Serial.println((char*)addr);

// Устанавливаем адрес передачи

Mirf.setTADDR(addr);

//Отправляем

Mirf.send((byte *)&Req);

// Эксперимаентально вычисленная задержка.

// Позволяет избежать проблем с модулем.

delay(10);

}

Код выше можно загрузить в первую Arduino. Для участника №2 код будет отличаться лишь переменными ADDR, NEXT, iamfirst, то есть для второго модуля код будет выглядеть так:

// Адрес модуля
#define ADDR "mod1"
// Адрес следующего в цепочке модуля
#define NEXT "mod2"
//Этот модуль начинает цепочку?
boolean iamfirst=false;

// Адрес модуля

#define ADDR "mod1"

// Адрес следующего в цепочке модуля

#define NEXT "mod2"

//Этот модуль начинает цепочку?

boolean iamfirst=false;

И для третьего вот так:

// Адрес модуля
#define ADDR "mod2"
// Адрес следующего в цепочке модуля
#define NEXT "mod0"
//Этот модуль начинает цепочку?
boolean iamfirst=false;

// Адрес модуля

#define ADDR "mod2"

// Адрес следующего в цепочке модуля

#define NEXT "mod0"

//Этот модуль начинает цепочку?

boolean iamfirst=false;

Третий модуль замыкает сеть

Вот как выглядят скриншоты трёх окон монитора последовательного порта (1 участник – 2 участник – 3 участник):

На этом наше ознакомление с модулем завершено, напоминаем, что модуль можно купить в нашем магазине с доставкой в любую точку мира!

Вольтик.ру

Вольтик - это слаженная команда амбициозных и заядлых инженеров. Мы создали этот проект с целью вовлечения вас, талантливых и начинающих профессионалов, в увлекательный мир мейкерской микроэлектроники!

nRF24l01 и Arduino – примеры использования

Обзор модуля nRF24l01

Подключение nRF24l01 к Arduino

Обзор библиотеки Mirf

Передача полезных данных с помощью nRF24l01

Особенности использования библиотеки Mirf

Передача структуры данных

Добавить комментарий Отменить ответ