Nano versus UnoR3 met NRF24

[eikneh Profiel PrivéberichtWebsite]

In mijn bezit een UNO R3 en een NANO
Een stukje software laat de NANO,met een NRF24 ontvanger, luisteren naar een NANO, NRF24 zender.
Dat werkt uitstekend.

Een NRF24 aan een UNO R3. Zelfde software als in de NANO.
Jammer werkt niet.
de software:
QUOTE
cpp code

/*
arduino nano    NRF24
13      SCK       5 
12      MISO      7
11      MOS       6
10      CSN       4
09      CE        3
02      IRQ       8
gnd     gnd       1
v+      +5        2

DHT22
V+
gnd
Data    4

Receiver is active listen. On receive data interrupt(IRQ) will go low.
ISR sets a flag. 
In the loop routine the flag is tested.
If set >> read out data. reset flag.
If not >> nothing happend.

cpp code

/**
 * Simplest possible example of using RF24Network,
 *
 * RECEIVER NODE
 * Listens for messages from the transmitter and prints them out.
 */

#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>


int RecData = 2;     // This is the INT0 Pin of the nano
int test;
int counter = 0;

RF24 radio(9,10);                // nRF24L01(+) radio attached using Getting Started board 

RF24Network network(radio);      // Network uses that radio
const uint16_t this_node = 00;    // Address of our node in Octal format ( 04,031, etc)
const uint16_t other_node = 01;   // Address of the other node in Octal format

struct payload_t {                 // Structure of our payload
  unsigned long wt;
  unsigned long rt;
  float h;
  float t;
  float hic;
  unsigned long counter;
};


void setup(void)
{
    pinMode(2, INPUT);
    digitalWrite(2, HIGH);    // Enable pullup resistor
  test = 0;
  Serial.begin(57600);
  Serial.println("Meteo/NanoNRF24_Wi_Re_Hu_Te_rx3.ino");
 
  SPI.begin();
  radio.begin();
  network.begin(/*channel*/ 90, /*node address*/ this_node);
    EIMSK |= (1 << INT0);     // Enable external interrupt INT0
    EICRA |= (1 << ISC01);    // Trigger INT0 on falling edge

}

void loop(void)
{
  
  network.update();                  // Check the network regularly
//      Serial.print("Network update = ");
//      Serial.println(counter);
      counter++;
      delay(100);
  
  while ( network.available() )  // Is there anything ready for us?
  {     
    if (test == 1 )
    {   
      RF24NetworkHeader header;        // If so, grab it and print it out
      payload_t payload;
      network.read(header,&payload,sizeof(payload));
      test = 0;
      Serial.print("  Received packet ");
      Serial.print(" wt ");
      Serial.print(payload.wt);
      Serial.print(" rt ");
      Serial.print(payload.rt);
      Serial.print(" h= ");
      Serial.print(payload.h);
      Serial.print(" t= ");
      Serial.print(payload.t);
      Serial.print(" hic= ");
      Serial.print(payload.hic);
      Serial.print(" co= ");
      Serial.println(payload.counter);

      
      
//      Serial.print(payload.counter);
//      Serial.print(" rt ");
//      Serial.println(payload.ms);
      counter = 0;
    }
  }
}

ISR(INT0_vect)
{
//  receiver ready for reading data;
  test = 1;
}

Question:
Wat gaat er fout bij de UNO.

Hopelijk weet iemand dat, of heeft een vermoeden met een oplossing.

Nog veel plezier
geniet van het leven.

[nicoverduin Profiel PrivéberichtWebsite]

Vreemd, Ik neem tenminste aan dat je de pinnen 9-13 goed hebt aangesloten?

[Koepel Profiel Privébericht]

Gebruik je een breadboard ? Die maken vaak slecht contact. Je kunt proberen om alles te verplaatsen op het breadboard.

De Uno en de Nano hebben beide de ATmega328P microcontroller. Dus erg groot kunnen de verschillen niet zijn.
Gebruik je Arduino.cc IDE 1.6.12 ?

Zou je me een plezier willen doen ? Maak van "int test" een "volatile byte test".

Code: Alles selecteren

// int test;
volatile byte test;    // it is used in a interrupt routine


De "volatile" betekent dat de compiler de variabele van zijn geheugenplaats gebruikt. De ATmega328P heeft 32 interne registers, en de compiler zou de variabele "test" in de loop() in de registers kunnen laten. Dan kan de interrupt het niet wijzigen.
Een integer is twee bytes. Als zo'n variabele wordt geschreven of gelezen, dan gaat dat byte voor byte. Daar tussendoor zou de interrupt kunnen komen. Dus een interrupt terwijl die variabele maar voor de helft geschreven of gelezen is. Door de variable "test" een byte te maken, voorkom je dat.