Temperatur messen und weiterleiten via NRF24

Hallihallo,

Ich bin komplett neu hier und brauche für ein Projekt unbedingt eure Hilfe.

Was ich machen will/muss ;) ist eine Temperatur messen (mit einem DHT11 SensorI, welcher bereits mit einem uno board verknüpft ist) und diese Temperatur dann via einen NRF24 weiterleiten an ein weiteren NRF24 + uno board.

Warum ich das machen muss?

Ich bin muss eine Raumtemperatur überwachen, welcher ca 20 meter entfernt ist, die Reichweite der NRF24 reichen, dies habe ich bereits getestet.

Nun zu meinem Problem:

Ich bekomme es hin mit dem Sensor die Temperatur zu messen und abzuschicken (zumindest glaube ich das), der andere Sensor empfängt auch etwas, kann aber nicht die Temperatur wiedergeben.

Erfahrungen im programmieren habe ich eher weniger, lediglich ein schnupperfach Informatik im 2ten Semester, zur Zeit studiere ich Maschinenbau, was auch der Grund für eine solche Aufgabe ist, die ich für mein Projekt brauche.

Falls jemand Ideen hat, wie ich das Problem mit diesen Geräten lösen kann wäre ich sehr dankbar :)

bis dahin Mfg

Na dann lass uns doch mal an deinem Code für die Sender- und für die Empfängerseite teilhaben...

der andere Sensor empfängt auch etwas, kann aber nicht die Temperatur wiedergeben.

Warum nicht ? Woher weisst du, dass "der andere Sensor " (meinst du den anderen Uno ?) was empfängt ? Was empfängt er denn ?

die Reichweite der NRF24 reichen, dies habe ich bereits getestet.

Haben die beiden Unos schon irgendwie miteinander "geredet" ?

Uns ( und auch dir ) würde auch helfen, wenn du dein Problem in einem möglichst kleinen Test isolierst. Statt "das Projekt ist zu groß um hier gepostet zu werden" zu antworten ...

Hi, da ich nicht wirklich peil vom programmieren habe, bitte ich jetzt schonmal um Entschuldigung, ich habe mir da was aus den Libarys zusammen gemixt.
Ich habe die gettingstarted verwendet aus der RF24 und etwas was ich sonst noch zum Dht11 gefunden habe.

[left]
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#include "DHT.h"

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 
RF24 radio(9,10);
#define DHTPIN 2     // what pin we're connected to
#define DHTTYPE DHT11   // DHT 11 
// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
DHT dht(DHTPIN, DHTTYPE);
//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

void setup()
{
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //
  dht.begin();
  radio.begin();
  
  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  //radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  //if ( role == role_ping_out )
  {
    //radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  //else
  {
    //radio.openWritingPipe(pipes[1]);
    //radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  // Ping out role.  Repeatedly send the current time
  //DHT dht(DHTPIN, DHTTYPE);

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the temp. , and send it.  This will block until complete
    if (isnan(t) || isnan(h)) {
    Serial.println("Failed to read from DHT");
  } else {
    Serial.print("Humidity: "); 
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperature: "); 
    Serial.print(t);
    Serial.println(" *C");
}
    
    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      unsigned long got_time;
      radio.read( &got_time, sizeof(unsigned long) );

      // Spew it
      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      unsigned long got_time;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_time, sizeof(unsigned long) );

        // Spew it
        printf("Got payload %lu...",got_time);

// Delay just a little bit to let the other unit
// make the transition to receiver
delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_time, sizeof(unsigned long) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    char c = toupper(Serial.read());
    if ( c == 'T' && role == role_pong_back )
    {
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    else if ( c == 'R' && role == role_ping_out )
    {
      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(pipes[1]);
      radio.openReadingPipe(1,pipes[0]);
    }
  }
}[/left]

Haben die beiden Unos schon irgendwie miteinander "geredet" ?

lediglich den gettingstarted code, mit der Zeit seit dem Start der Anwendung und dem Delay zwischen den einzelnen Reruns.

sth77: Na dann lass uns doch mal an deinem Code für die Sender- und für die Empfängerseite teilhaben...

für den Empfänger fällt mir zur Zeit nicht viel ein.. suche schon andere Themen ab, aber für einen kompletten Leihen ist dies verdammt schwer.

Das Ganze bitte noch in Code-Tags setzen, dann wirds übersichtlicher. ;)

Dann wird auch aus 8) kein 8)

Mal ein kleines update der Sender tut nun das was er soll und der Empfänger kann es sogar auslesen oh oh oh :P, sieht zwar noch hässlich aus, aber wer sowas brauch.

TX:

#include <SNESpadDual.h>
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <DHT.h>
#include <printf.h>
#define DHTPIN 2


#define DHTTYPE DHT11   

RF24 radio(9,10);

DHT dht(DHTPIN, DHTTYPE);

unsigned long state = 0;
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };


void setup() 
{
  dht.begin();
  radio.begin();
  radio.setRetries(15,15);
  Serial.begin(9600);

radio.openWritingPipe(pipes[0]);
radio.openReadingPipe(1,pipes[1]);
radio.startListening();

  radio.printDetails();
}

void loop(void) {
  
  //float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  radio.stopListening();
  
  
  Serial.print(t);
  Serial.print(" Now sending ");
  bool ok = radio.write(&t, sizeof(t));
  
/*  if (ok)
  printf("OK");
  
  else
  printf("fehler" );
*/ 
 /*      radio.startListening();
 
  unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;
 
  if ( timeout )
    {
      Serial.print("keine Verbindung...\n\r");
    }
    else
    {
     
         unsigned long got_time;
      radio.read( &t, sizeof(unsigned long) );

    }*/
    delay(50);
    }

RX:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <printf.h>


RF24 radio(9,10);

const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

void setup()
{
  radio.begin();
  radio.setRetries(15,15);
  Serial.begin(9600);
  
  radio.openWritingPipe(pipes[1]);
  radio.openReadingPipe(1,pipes[0]);

  radio.startListening();
//  Serial.print("ich hoere.\n");
  radio.printDetails();
  
 
 }
 
 
 
void loop()
{
  //radio.startListening();

//  radio.read(&t, sizeof(t));
//  Serial.print(t);    
      
//  radio.stopListening();  
  
     if ( radio.available() )
    {
      float t;
      //Serial.print("radio verfügbar");
      bool done = false;
      while (!done)
      {
        //Serial.print("nocht nicht ganz fertig");
        done = radio.read( &t, sizeof(t) );
      }
     // Serial.print("ich will schreiben");
      Serial.print(t);
      Serial.print("TempC\n");
     
      
 
  }
  delay(50);
}