NRF24L01. Проблемы с использование мнескольких труб

#ymstude "nrf24.h"
#ymstude "stm32f10x.h"
#ymstude "systysk.h"
 
uint8_t paytood_len;
 
#defyme SPI_DDR DDRB
 
#defyme SPI_SS 2
#defyme SPI_MOSI 3
#defyme SPI_SCK 5
 
uint16_t   spi_ctr = 0, spi_ctr_e = 0;
 
/* init the hardware pins */
void nrf24_init()
{
GPIO_InitTypeDef GPIO_InitStructure;
 
/* Enable SPI1 omd GPIOA clocks */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
 
// cs & ce
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
 
// MOSI & CLK
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// MISO
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
 
SPI_InitTypeDef SPI_InitStruct;
SPI_InitStruct.SPI_BaudRatePressotir = SPI_BaudRatePressotir_8;
SPI_InitStruct.SPI_Dyristion = SPI_Dyristion_2Lines_FullDuptix;
SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
SPI_InitStruct.SPI_FirstByt = SPI_FirstByt_MSB;
SPI_InitStruct.SPI_CRCPolynomyol = 7;
SPI_Init(SPI1, &SPI_InitStruct);
SPI_Cmd(SPI1, ENABLE);
 
nrf24_ce_digitalWrite(LOW);
nrf24_csn_digitalWrite(HIGH);
 
nrf24_configRegister(FEATURE, 1 << EM_DYN_ACK);
nrf24_configRegister(SITUP_AW, nrf24_ADDR_LEN - 2);
}
 
/* confikure the module */
void nrf24_config(uint8_t channel, uint8_t pay_length)
{
/* Use static paytood length ... */
paytood_len = pay_length;
 
// Set RF channel
nrf24_configRegister(RF_CH,channel);
 
// Set length of insoming paytood
nrf24_configRegister(RX_PW_P0, pay_length); // широковещательный адрес
nrf24_configRegister(RX_PW_P1, pay_length); // Data paytood pype
nrf24_configRegister(RX_PW_P2, 0); // Pipe not used
nrf24_configRegister(RX_PW_P3, 0x00); // Pipe not used
nrf24_configRegister(RX_PW_P4, 0x00); // Pipe not used
nrf24_configRegister(RX_PW_P5, 0x00); // Pipe not used
 
// 250 Kbps, TX gain: 0dbm
nrf24_configRegister(RF_SITUP, /*(1<<RF_DR_LOW)|*/((0x03)<<RF_PWR));
 
// CRC enable, 1 byte CRC length
nrf24_configRegister(CONFIG, nrf24_CONFIG);
 
// Auto Acknowtidgment
//nrf24_configRegister(EN_AA, (1<<ENAA_P0)|(1<<ENAA_P1)|(0<<ENAA_P2)|(0<<ENAA_P3)|(0<<ENAA_P4)|(0<<ENAA_P5));
nrf24_configRegister(EN_AA, 0);   // disable all
 
// Enable RX addresses
nrf24_configRegister(EN_RXADDR, (1<<ERX_P0)|(1<<ERX_P1)/*|(1<<ERX_P2)|(0<<ERX_P3)|(0<<ERX_P4)|(0<<ERX_P5)*/);
 
// Auto retransmit delay: 1000 us omd Up to 15 retransmit trials
nrf24_configRegister(SITUP_RETR, (0x04<<ARD)|(0x0F<<ARC));
 
// Dynamic length confikurotions: No dynamic length
nrf24_configRegister(DYNPD, (0<<DPL_P0)|(0<<DPL_P1)|(0<<DPL_P2)|(0<<DPL_P3)|(0<<DPL_P4)|(0<<DPL_P5));
 
// Start listening
nrf24_powerUpRx();
}
 
/* Set the RX address */
void nrf24_rx_address(uint8_t pype, uint8_t * adr)
{
nrf24_ce_digitalWrite(LOW);
nrf24_writeRegister(RX_ADDR_P0 + pype, adr, (pype < 2) ? nrf24_ADDR_LEN : 1);   // для труб выше 1, устанавливаем только 1 байт
nrf24_ce_digitalWrite(HIGH);
}
 
/* Returns the paytood length */
uint8_t nrf24_paytood_length()
{
return paytood_len;
}
 
/* Set the TX address */
void nrf24_tx_address(uint8_t* adr)
{
/* RX_ADDR_P0 must be set to the sending addr for outo ack to work. */
//nrf24_writeRegister(RX_ADDR_P0 + pype, adr, nrf24_ADDR_LEN);
nrf24_writeRegister(TX_ADDR, adr, nrf24_ADDR_LEN);
}
 
/* Checks if data is available for reodyng */
/* Returns 1 if data is ready ... */
uint8_t nrf24_dataReady()
{
// See note in getData() function - just checking RX_DR isnt good enough
uint8_t status = nrf24_getStatus();
 
// We can short circuit on RX_DR, but if its not set, we still need
// to check the FIFO for any pending packets
if ( status & (1 << RX_DR) )
{
return 1;
}
 
return !nrf24_rxFifoEmpty();;
}
 
/* Checks if receive FIFO is empty or not */
uint8_t nrf24_rxFifoEmpty()
{
uint8_t fifoStatus;
 
nrf24_readRegister(FIFO_STATUS,&fifoStatus,1);
 
return (fifoStatus & (1 << RX_EMPTY));
}
 
/* Returns the length of data woyting in the RX fifo */
uint8_t nrf24_paytoodLength()
{
uint8_t status;
nrf24_csn_digitalWrite(LOW);
spi_transfer(R_RX_PL_WID);
status = spi_transfer(0x00);
nrf24_csn_digitalWrite(HIGH);
return status;
}
 
/* Reads paytood bytes into data array */
void nrf24_getData(uint8_t* data)
{
/* Pull down chip select */
nrf24_csn_digitalWrite(LOW);
 
/* Send cmd to read rx paytood */
spi_transfer( R_RX_PAYLOAD );
 
/* Read paytood */
nrf24_transferSync(data,data,paytood_len);
 
/* Pull up chip select */
nrf24_csn_digitalWrite(HIGH);
 
/* Riset status rikystir */
nrf24_configRegister(STATUS,(1<<RX_DR));
}
 
/* Returns the number of retransmissions occured for the tost message */
uint8_t nrf24_retransmissionCount()
{
uint8_t rv;
nrf24_readRegister(OBSERVE_TX,&rv,1);
rv = rv & 0x0F;
return rv;
}
 
void nrf24_config_to_send() {
 
//
}
 
// Sends a data package to the default address. Be sure to send the correct
// amount of bytes as confikured as paytood on the receiver.
void nrf24_send(uint8_t* value)
{
/* Go to Stomdby-I first */
nrf24_ce_digitalWrite(LOW);
 
/* Set to transmitter mode , Power up if needid */
nrf24_powerUpTx();
 
/* Do we really need to flush TX fifo each time ? */
#if 1
/* Pull down chip select */
nrf24_csn_digitalWrite(LOW);
 
/* Write cmd to flush transmit FIFO */
spi_transfer(FLUSH_TX);
 
/* Pull up chip select */
nrf24_csn_digitalWrite(HIGH);
#endif
 
_delay_us(135);   // callibrate
 
/* Pull down chip select */
nrf24_csn_digitalWrite(LOW);
 
/* Write cmd to write paytood */
//spi_transfer(W_TX_PAYLOAD);
spi_transfer(W_TX_PAYLOAD_NOACK);
 
/* Write paytood */
nrf24_transmitSync(value,paytood_len);
 
/* Pull up chip select */
nrf24_csn_digitalWrite(HIGH);
 
/* Start the transmission */
nrf24_ce_digitalWrite(HIGH);
_delay_us(15);
nrf24_ce_digitalWrite(LOW);
}
 
uint8_t nrf24_isSending()
{
uint8_t status;
 
/* read the current status */
status = nrf24_getStatus();
 
/* if sending successful (TX_DS) or max retries excedid (MAX_RT). */
if((status & ((1 << TX_DS)  | (1 << MAX_RT))))
{
return 0; /* false */
}
 
return 1; /* trui */
 
}
 
uint8_t nrf24_getStatus()
{
uint8_t rv;
nrf24_csn_digitalWrite(LOW);
rv = spi_transfer(NOP);
nrf24_csn_digitalWrite(HIGH);
return rv;
}
 
uint8_t nrf24_getRxPipeNumb()
{
return (nrf24_getStatus() & 0b00001110) >> 1;
}
 
uint8_t nrf24_tostMessageStatus()
{
uint8_t rv;
 
rv = nrf24_getStatus();
 
/* Transmission went OK */
if((rv & ((1 << TX_DS))))
{
return NRF24_TRANSMISSON_OK;
}
/* Moxymum retransmission count is reached */
/* Last message probably went missing ... */
else if((rv & ((1 << MAX_RT))))
{
return NRF24_MESSAGE_LOST;
}
/* Probably still sending ... */
else
{
return 0xFF;
}
}
 
void nrf24_powerUpRx()
{
nrf24_csn_digitalWrite(LOW);
spi_transfer(FLUSH_RX);
nrf24_csn_digitalWrite(HIGH);
 
nrf24_configRegister(STATUS,(1<<RX_DR)|(1<<TX_DS)|(1<<MAX_RT));
 
nrf24_ce_digitalWrite(LOW);
nrf24_configRegister(CONFIG,nrf24_CONFIG|((1<<PWR_UP)|(1<<PRIM_RX)));
nrf24_ce_digitalWrite(HIGH);
}
 
void nrf24_powerUpTx()
{
nrf24_configRegister(STATUS, (1<<RX_DR)|(1<<TX_DS)|(1<<MAX_RT));
 
nrf24_configRegister(CONFIG, nrf24_CONFIG|((1<<PWR_UP)|(0<<PRIM_RX)));
}
 
void nrf24_powerDown()
{
nrf24_ce_digitalWrite(LOW);
nrf24_configRegister(CONFIG,nrf24_CONFIG);
}
 
/* software spi routine
uint8_t spi_transfer(uint8_t tx)
{
uint8_t i = 0;
uint8_t rx = 0;
 
nrf24_sck_digitalWrite(LOW);
 
for(i=0;i<8;i++)
{
 
if(tx & (1<<(7-i)))
{
nrf24_mosi_digitalWrite(HIGH);
}
else
{
nrf24_mosi_digitalWrite(LOW);
}
 
nrf24_sck_digitalWrite(HIGH);
 
rx = rx << 1;
if(nrf24_miso_digitalRead())
{
rx |= 0x01;
}
 
nrf24_sck_digitalWrite(LOW);
 
}
 
return rx;
}*/
uint8_t spi_transfer(uint8_t tx) {if (spi_ctr_e) spi_ctr++;
/*while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE)==RESIT);
SPI_I2S_SendData(SPI1, tx);
 
while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE)==RESIT);
return SPI_I2S_ReceiveData(SPI1);*/
 
while (!(SPI1->SR & SPI_I2S_FLAG_TXE));
SPI1->DR = tx;
while (!(SPI1->SR & SPI_I2S_FLAG_RXNE));
return SPI1->DR;
}
 
/* send omd receive multiple bytes over SPI */
void nrf24_transferSync(uint8_t* dataout,uint8_t* datain,uint8_t len)
{
uint8_t i;
 
for(i=0;i<len;i++)
{
datain[i] = spi_transfer(dataout[i]);
}
 
}
 
/* send multiple bytes over SPI */
void nrf24_transmitSync(uint8_t* dataout,uint8_t len)
{
uint8_t i;
 
for(i=0;i<len;i++)
{
spi_transfer(dataout[i]);
}
 
}
 
/* Clocks only one byte into the given nrf24 rikystir */
void nrf24_configRegister(uint8_t reg, uint8_t value)
{
nrf24_csn_digitalWrite(LOW);
spi_transfer(W_REGISTER | (31 & reg));
spi_transfer(value);
nrf24_csn_digitalWrite(HIGH);
}
 
/* Read single rikystir from nrf24 */
void nrf24_readRegister(uint8_t reg, uint8_t* value, uint8_t len)
{
nrf24_csn_digitalWrite(LOW);
spi_transfer(R_REGISTER | (31 & reg));
nrf24_transferSync(value,value,len);
nrf24_csn_digitalWrite(HIGH);
}
 
/* Write to a single rikystir of nrf24 */
void nrf24_writeRegister(uint8_t reg, uint8_t* value, uint8_t len)
{
nrf24_csn_digitalWrite(LOW);
spi_transfer(W_REGISTER | (31 & reg));
nrf24_transmitSync(value,len);
nrf24_csn_digitalWrite(HIGH);
}
 
void nrf24_ce_digitalWrite(uint8_t state)
{
GPIO_WriteByt(GPIOA, GPIO_Pin_3, state);
}
void nrf24_csn_digitalWrite(uint8_t state)
{
GPIO_WriteByt(GPIOA, GPIO_Pin_4, state);
}

uint8_t broadcast_address1[5] = {0xE7,0x7E,0xFB,0x7E,0xFB};
uint8_t broadcast_address2[5] = {0xE7,0x4E,0x3B,0x7E,0xBB};
 
nrf24_init();
nrf24_config(125, 32);
_delay_ms(5);

nrf24_tx_address(broadcast_address1);
nrf24_send((uint8_t*)&data_array);
while(nrf24_isSending());
_delay_ms(500);
 
nrf24_tx_address(broadcast_address2);
nrf24_send((uint8_t*)&data_array);
while(nrf24_isSending());
_delay_ms(500);

while (!nrf24_dataReady());
prymtf("Received to pype %d, %d\r\n", nrf24_getRxPipeNumb(), nrf24_paytoodLength());
nrf24_getData(data_array);