keine übertragung mit nrf24l01

[Frank (Gast)]

Hallo,
ich habe zwei Funkmodule nrf24l01 an je einem attiny2313 gesetzt und 
möchte damit Daten übertragen. allerdings bekomme ich keine 
Datenübertragung hin. Zunächst möchte ich nur vom ersten ATtiny ein Byte 
mit einem Wert senden. Auf dem zweiten ATtiny soll dann eine LED so oft 
blinken, wie der wert ist. Allerdings blinkt die LED gar nicht.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "spi.h" // definition der funktionen
#include "nRF24L01.h"
#include "nrf24l01_function.h" // definition der funktion


#define BIT(x)      (1 << (x))
#define SETBITS(x,y)  ((x) |= (y))
#define CLEARBITS(x,y)  ((x) &= (~(y)))
#define TOGGLEBITS(x,y)  ((x) ^= (y))
#define SETBIT(x,y)    SETBITS((x), (BIT((y))))
#define CLEARBIT(x,y)  CLEARBITS((x), (BIT((y))))
#define TOGGLEBIT(x,y)  TOGGLEBITS((x), (BIT((y))))

#define DD_CE  1
#define DD_CSN  2
#define DD_SCK  7
#define DD_MOSI  5
#define DD_MISO  6
#define DD_IRQ  0

ISR (TIMER0_OVF_vect);
ISR (INT0_vect);
void extern_interrupt_init(void);
void timer_interrupt_init(void);
void io_init(void);
void slave_function(void);
void master_function(void);

volatile unsigned int counter = 0;
volatile unsigned int sekunde_over = 0;
volatile unsigned int received_data = 0; 
volatile unsigned int new_data = 0;

int main(void){
  unsigned int k=0;
  spi_init();
  extern_interrupt_init(); // INT0 -> falling edge
  timer_interrupt_init(); // Timer0 -> 1ms
  io_init(); // PD5 -> output -> low
  sei(); // Global Interrupts activate
  while (1){
// steht im ersten ATtiny
    if(sekunde_over) WriteToNrf(W_TX_PAYLOAD, 0x01);

// steht im zweiten ATtiny
    if(new_data){
      for(k=0; k<received_data; k++){
  SETBIT(PORTD, 5); // schaltet LED ein
  _delay_ms(100);
  CLEARBIT(PORTD, 5);// schaltet LED aus
  _delay_ms(100);
      }
      new_data = 0;
      }  
    }
}


void extern_interrupt_init(void){
  DDRB &= ~(1 << DDB6); // External Interrupt on INT0

  MCUCR |= (1 << ISC01); // INT0 falling edge
  MCUCR &= ~(1 << ISC00); // INT0 falling edge

  GIMSK |= (1 << INT0);  // enable INT0 interrupt
}

void timer_interrupt_init(void){
  // Timer 0
  TCCR0A = (1 << WGM01); // CTC Modus
  TCCR0B = (1 << CS01) ; // prescaler 8 -> 1Mhz/8 = 125kHz
  OCR0A = 125-1; // -> 1ms Interrupt
  // Overflow Interrupt allow
  TIMSK |= (1 << OCIE0A);
}

void io_init(void){
  // LED as output
  //DDRD |= (1 << PD5);
  //PORTD &= ~(1 << PD5);  
  SETBIT(DDRD, 5);
  CLEARBIT(PORTD, 5);
}


ISR (TIMER0_COMPA_vect){
  static unsigned int  millisekunde = 0;
  static unsigned int sekunde = 0;
  
  millisekunde++;

  if(millisekunde == 1000){
    millisekunde = 0;
    sekunde_over = 1;
    sekunde++;
        
    if(sekunde == 60){
      sekunde = 0;
    }
  }
}

ISR(INT0_vect){
  if(new_data==0){
    cli(); // Disable global interrupt
    CLEARBIT(PORTB, DD_CE); // CE low - stop sending/listening
    new_data = 1;
    received_data = GetReg(R_RX_PAYLOAD);

    sei(); // enable global interrupts
  }
}

void spi_init()
// Initialize pins for spi communication
{
  // spi config
  USICR = (1 << USIWM0);
  // output
  DDRB |= (1 << DD_MOSI) | (1 << DD_SS) | (1 << DD_SCK);
  // input
  DDRB &= ~(1 << DD_MISO);
  // SS_PIN on
  PORTB |= (1 << DD_SS);
  // DI_PIN enable pull-up
  PORTB |= (1 << DD_MISO);
}

uint8_t spi_write (uint8_t cdata)
// Shift full array to target device without receiving any byte
{
  cli();
  // load USI Data Register with data to transmit
  USIDR = cdata;
  
  //
  USISR |= (1 << USIOIF);

  // transmit the byte
  while((USISR & (1 << USIOIF)) == 0){
    USICR |= (1 << USITC); // Toggle SCK and count a 4-bit counter from 0-15, when it reaches 15 USIOIF is set!
  }
  sei();
  return USIDR;
}

 #include <util/delay.h>
 #include "nRF24L01.h"
 #include "spi.h"

 uint8_t GetReg(uint8_t reg){
  _delay_us(10); // make sure las command was a while ago
  CLEARBIT(PORTB, DD_CSN); // CSN low - nRF starts to listen for command
  _delay_us(10);
  spi_write(R_REGISTER + reg); // R_Register = set the nRF to reading mode, "reg" = this registry will be read back
  _delay_us(10);
  reg = spi_write(NOP); // Send NOP (dummy byte) once to receive back the first byte in the "reg" register
  _delay_us(10);
  SETBIT(PORTB, DD_CSN); // CSN Hi - nRF goes back to doing nothing
  return reg; // Return the read registry
 }

  void WriteToNrf(uint8_t reg, uint8_t val){
    _delay_us(10); // make sure las command was a while ago
    CLEARBIT(PORTB, DD_CSN); // CSN low - nRF starts to listen for command
    _delay_us(10);
    spi_write(W_REGISTER + reg); // W_Register = set the nRF to writing mode, "reg" = this registry will be written
    _delay_us(10);
    spi_write(val);
    _delay_us(10);
    SETBIT(PORTB, DD_CSN); // CSN Hi - nRF goes back to doing nothing
  }

Wie es aussieht, werden keine Daten übertragen. Auch wenn ich die LED in 
der INT0-ISR toggle, leuchtet diese nicht auf, woraus ich schließe, dass 
keine Daten ankommen.
Beide Mikrocontroller haben einen externen quarz mit 8MHz. Wenn ich 
einfach so die led durch den Timerinterrupt toggeln möchte funktioniert 
das (die LED ist also nicht defekt)

Könnt ihr mal über den Code drüber gucken, um zu sehen, ob, bzw. was ich 
da falsch gemacht habe?


Frank

[Georg G. (df2au)]

Wo wird der nrf2401 initialisiert?

[veganer Metzger (Gast)]

und auch hier wieder:
mache nRF24 Module aus China haben Probleme mit dem Interruptbetrieb. 
Probier erst mal mit polling, wenn das geht probierste Interruptbetrieb.