Беспроводной канал связи 2,4 ГГц на базе трансивера nRF24L01+ от Nordic Semiconductor. Часть 1

// Определяем регистры и выводы согласно выбранного МК и варианта SPI. 
// Здесь, для примера, приведён вариант - ATmega8/ ATmega328P, аппаратный SPI 
#define nRF_DDR DDRB
#define nRF_PORT PORTB
#define nRF_PIN PINB 
#define SCK_pin PB5 
#define MISO_pin PB4 
#define MOSI_pin PB3 
#define CSN_pin PB2
#define CE_pin PB1

// макрофункции установки/сброса выводов
#define sbi(pin) nRF_PORT |= (1<<pin) 
#define cbi(pin) nRF_PORT &= ~(1<<pin)

void SPI_init(void)
{
 // все выводы, кроме MISO, работают как выход
 nRF_DDR = (1<<CE_pin) | (1<<SCK_pin) | (1<<CSN_pin) | (1<<MOSI_pin);
 // неактивное состояние вывода CSN - высокое
 sbi(CSN_pin);
 // МК работает как Master: MSTR = 1
 // прерывания по SPI нам не нужны: SPIE = 0
 // старший бит – всегда первый: DORD = 0
 // полярность SCK-импульса – положительная: CPOL = 0
 // обмен данными - по переднему фронту SCK-импульса: CPHA = 0
 // скорость SPI МК уменьшать не требуется: SPR1 и SPR0 = 0
 // всё настроили – включаем модуль SPI: SPE = 1
 SPCR = (1<<MSTR) | (1<<SPE);
}

uint8_t SPI_byte(uint8_t byte)
{
 // помещаем записываемый байт в регистр данных МК
 SPDR = byte;
 // ждём завершения записи байта в трансивер
 while(!(SPSR & (1<<SPIF)));
 // возвращаем в вызвавшую функцию полученный из трансивера байт
 return SPDR;
}

void SPI_init(void)
{
 // две первые строки остаются без изменений
 nRF_DDR = (1<<CE_pin) | (1<<SCK_pin) | (1<<CSN_pin) | (1<<MOSI_pin);
 sbi(CSN_pin); 
 // прерывания по SPI нам не нужны: USISIE и USIOIE = 0 
 // настраиваем USI-модуль как SPI: USIWM1 = 0, USIWM0 = 1 
 // учитываем полярность и фронт SCK-импульса: USICS1 и USICLK = 1, USICS0 = 0
 USICR = (1 << USIWM0) | (1 << USICS1) | (1 << USICLK);
}

uint8_t SPI_byte(uint8_t byte)
{
 // помещаем записываемый байт в регистр данных МК
 USIDR = byte;
 // сбрасываем флаг переполнения – особенность модуля USI
 USISR |= (1<<USIOIF);
 // до тех пор, пока в трансивер не запишется весь байт
 while(!(USISR &(1<<USIOIF)))
 {
 // тактируем процесс
 USICR |= (1<<USITC);
 } 
 // возвращаем в вызвавшую функцию полученный из трансивера байт
 return USIDR;
}

// Чтобы не мучиться с магическими числами добавим в имеющийся
// список пару макросов для идентификации старшего 
#define MSBit 0x80
// и младшего бита байта
#define LSBit 0x01

void SPI_init(void)
{
 // спец-регистры мы не используем, поэтому оставляем только две верхние строки 
 nRF_DDR = (1<<CE_pin) | (1<<SCK_pin) | (1<<CSN_pin) | (1<<MOSI_pin);
 sbi(CSN_pin); 
}

uint8_t SPI_byte(uint8_t byte)
{
 // организовываем побитный обмен 
 for(uint8_t counter = 8; counter; counter--)
 {
 // если записываемый в трансивер старший бит - 1
 if (byte & MSBit)
 // выставляем на линию MOSI высокий уровень
 sbi(MOSI_pin);
 // в противном случае - 
 else
 //низкий
 cbi(MOSI_pin);
 // для размещения считываемого из трансивера байта используем 
 // имеющуюся переменную byte, поэтому сдвигаем её
 byte <<= 1;
 // формируем положительный передний фронт SCK-импульса 
 sbi(SCK_pin); 
 // если считываемый из трансивера бит - 1
 if (nRF_PIN & (1<<MISO_pin))
 // устанавливаем младший бит переменной byte в 1 
 byte |= LSBit;
 // если считываемый из трансивера бит – 0, ничего не делаем, т.к. 
 // после сдвига переменной byte её младший бит уже равен 0 
 // закрываем SCK-импульс 
 cbi(SCK_pin); 
 }
 // возвращаем в вызвавшую функцию полученный из трансивера байт
 return byte;
}

// команды nRF24l01+ 
#define R_REGISTER 0x00
#define W_REGISTER 0x20
#define R_RX_PAYLOAD 0x61
#define W_TX_PAYLOAD 0xA0
#define FLUSH_TX 0xE1
#define FLUSH_RX 0xE2
#define NOP 0xFF

// регистры nRF24l01+ и их биты
#define CONFIG 0x00
 #define MASK_RX_DR 6
 #define MASK_TX_DS 5
 #define MASK_MAX_RT 4
 #define EN_CRC 3
 #define CRCO 2
 #define PWR_UP 1
 #define PRIM_RX 0
#define STATUS 0x07
 #define RX_DR 6
 #define TX_DS 5
 #define MAX_RT 4
 #define RX_P_NO 1
 #define TX_FULL 0
#define RX_PW_P0 0x11

void nRF_command(uint8_t command)
{
 cbi(CSN_pin);
 SPI_byte(command);
 sbi(CSN_pin);
}

void nRF_write_register(uint8_t reg, uint8_t data_out)
{
 reg |= W_REGISTER;
 cbi(CSN_pin);
 SPI_byte(reg);
 SPI_byte(data_out);
 sbi(CSN_pin);
}

uint8_t nRF_read_register(uint8_t reg)
{
 uint8_t data_in;
 cbi(CSN_pin); 
 data_in = SPI_byte(reg);
 if(reg != STATUS) 
 {
 data_in = SPI_byte(NOP); 
 }
 sbi(CSN_pin); 
 return data_in;
}

// Подключаем библиотеки и вспомогательные файлы
#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <util/delay.h>
// здесь хранятся созданные нами функции
#include “nRF.h”
// а здесь - наши макросы
#include “defines.h” 

uint8_t tx_ds_flag, max_rt_flag; 

ISR(INT0_vect) 
{
 // узнаём причину прерывания 
 uint8_t _status = nRF_read_register(STATUS);
 // если причина – успешная доставка пакета приёмнику 
 if(_status & (1<<TX_DS))
 {
 // можем порадовать основную программу, выставив соответствующий флаг 
 tx_ds_flag = 1; 
 }
 // если же доставка сорвалась 
 else if(_status & (1<<MAX_RT))
 {
 // что-то предпринимаем, а ещё лучше – сообщаем в main и пусть у них голова болит
 max_rt_flag = 1; 
 }
 // уходя, не забываем сбросить флаги трансивера 
 nRF_write_register(STATUS, 0x70); 
}

int main(void)
{
 // инициализируем всё, что связано с протоколом SPI 
 SPI_init(); 
 // после подачи питания nRF24L01+ нужно 100 мс, чтобы прийти в себя 
 _delay_ms(100); 
 // конфигурируем трансивер как передатчик PRIM_RX = 0
 // передатчику прерывание по приему не нужно: MASK_RX_DR = 1
 // а два других нужны: MASK_TX_DS и MASK_MAX_RT = 0
 // биты CRC оставляем без изменений: EN_CRC = 1, CRCO = 0;
 // выводим трансивер из спячки: PWR_UP = 1 
 nRF_write_register(CONFIG, (1<<MASK_RX_DR) | (1<<EN_CRC) | (1<<PWR_UP));
 // ждём ещё 1.5мс до перехода в состояние Standby
 _delay_ms(2); 

 // сбрасываем флаги 
 nRF_write_register(STATUS, 0x70); 
 // и очищаем стеки FIFO трансивера
 nRF_command(FLUSH_TX);
 nRF_command(FLUSH_RX);

 // настраиваем параметры прерывания 
 EICRA = (1<<ISC01) | (0<<ISC00); 
 EIMSK = (1<<INT0);
 // и разрешаем его глобально 
 sei(); 
 
 // ну и сама передача байта в эфир
 while(1)
 {
 // записываем в стек FIFO наш байт, например символ ‘D’ 
 nRF_write_register(W_TX_PAYLOAD, ‘D’);
 // передёргиваем вывод CE как минимум на 10мкс
 sbi(CE_pin);
 _delay_us(11);
 cbi(CE_pin);
 // и ждём не менее 130мкс
 _delay_us(135); 

 // периодически проверяем флаги обработчика прерываний, реагируем и сбрасываем их
 If(tx_ds_flag)
 {
 tx_ds_flag = 0;
 } 
 If(max_rt_flag)
 {
 max_rt_flag = 0;
 } 
 }
}

#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <util/delay.h>
#include “nRF.h”
#include “defines.h” 

uint8_t payload , rx_dr_flag;

ISR(INT0_vect) 
{
 // считываем из стека FIFO принятый байт и записываем в глобальную переменную
 payload = nRF_read_register(R_RX_PAYLOAD);
 // докладываем в main, 
 rx_dr_flag = 1;
 // сбрасываем флаги трансивера
 nRF_write_register(STATUS, 0x70); 
}

int main(void)
{
 SPI_init(); 
 _delay_ms(100); 
 // конфигурируем трансивер как приёмник PRIM_RX = 1
 // с прерываниями – всё наоборот: MASK_RX_DR = 0, MASK_TX_DS и MASK_MAX_RT = 1
 nRF_write_register(CONFIG, (1<<MASK_TX_DS) | (1<<MASK_MAX_RT) | (1<<EN_CRC) | (1<<PWR_UP) | (1<<PRIM_RX));
 _delay_ms(2); 
 // определяем длину принимаемых данных, в нашем случае – 1 байт 
 nRF_write_register(RX_PW_P0, 1);
 // чтобы трансивер начал работать как приёмник, надо перевести вывод CE в 1
 sbi(CE_pin);
 // и подождать как минимум 130мкс 
 _delay_us(135);

 // сбрасываем флаги 
 nRF_write_register(STATUS, 0x70); 
 // и очищаем стеки FIFO трансивера
 nRF_command(FLUSH_TX);
 nRF_command(FLUSH_RX);

 // настраиваем параметры прерывания 
 EICRA = (1<<ISC01) | (0<<ISC00); 
 EIMSK = (1<<INT0);
 // и разрешаем его глобально 
 sei(); 
 
 while(1)
 {
 // проверяем, нет ли сообщений от обработчика прерываний 
 If(rx_dr_flag)
 {
 // если да, делаем то, что считаем нужным и сбрасываем флаг 
 rx_dr_flag = 0;
 } 
 }
}