INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
09.10.2015, 12:35
Beitrag #1
Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
Hallo Zusammen,

ich bastel inzwischen an der Generation 2 meines Lampennetzwerkes...

Es soll nun ein Außensensor aus 3 Lichtwiderständen mit Farbfiltern Informationen zu Helligekeit und Farbe des Außenlichts liefern.

Die Verbindung zur Zentrale steht schon mal... allerdings ist der Sensorwert nicht 3- oder 4 stellig, sondern 9-stellig... ich kann aber beim besten Willen den Fehler nicht finden.

Hier zunächst ein Sketch, der zwar die Sensorwerte korrekt im seriellen Monitor darstellt, aber von den Funkfunktionen nicht der Generation 2 entspricht...

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


int sensorblauPIN = A7;  
int sensorblau = 0;
int sensorgruenPIN = A6;  
int sensorgruen = 0;
int sensorrotPIN = A5;  
int sensorrot = 0;

RF24 radio(9,10);

RF24Network network(radio);
const uint16_t this_node = 2;
const uint16_t other_node = 1;
const unsigned long interval = 2000;
unsigned long last_sent;
unsigned long packets_sent;

struct payload_t
{
  unsigned long ms;
  unsigned long counter;
};

void setup(void)
{
  Serial.begin(57600);
  Serial.println("RF24Network/examples/helloworld_tx/");

  SPI.begin();
  radio.begin();
  network.begin(/*channel*/ 90, /*node address*/ this_node);
}

void loop(void)
{
  sensorblau = analogRead(sensorblauPIN);
  sensorgruen = analogRead(sensorgruenPIN);
  sensorrot = analogRead(sensorrotPIN);
  network.update();

  unsigned long now = millis();
  if ( now - last_sent >= interval  )
  {
    last_sent = now;

    Serial.print("blau: ");
    Serial.println(sensorblau);
    Serial.print("gruen: ");
    Serial.println(sensorgruen);
    Serial.print("rot: ");
    Serial.println(sensorrot);
    Serial.println(",  Sending...");
    payload_t payload = { millis(), sensorblau };
    RF24NetworkHeader header(/*to node*/ other_node);
    bool ok = network.write(header,&payload,sizeof(payload));
    if (ok)
      Serial.println("ok.");
    else
      Serial.println("failed.");
  }
}

und nun das Sketch, was zwar mal schon einen Wert sendet, aber eben mit viel zu vielen Stellen:
Code:
#include <SPI.h>
#include <EEPROM.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

RF24 radio(9,10);

int sensorblauPIN = A7;  
int sensorblau = 0;
int sensorgruenPIN = A6;  
int sensorgruen = 0;
int sensorrotPIN = A5;  
int sensorrot = 0;
int sensorwerte[3] = {sensorblau, sensorgruen, sensorrot};

const uint64_t talking_pipes[5] = { 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL };
const uint64_t listening_pipes[5] = { 0x3A3A3A3AD2LL, 0x3A3A3A3AC3LL, 0x3A3A3A3AB4LL, 0x3A3A3A3AA5LL, 0x3A3A3A3A96LL };

typedef enum { role_invalid = 0, role_ping_out, role_pong_back } role_e;
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

role_e role;

const uint8_t address_at_eeprom_location = 0;
uint8_t node_address;

void setup(void)
{
    role = role_ping_out;
    node_address = 2;


  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/starping/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("ADDRESS: %i\n\r",node_address);
  
  radio.begin();
  radio.openWritingPipe(talking_pipes[node_address-2]);
    // Listen on our listening pipe
    radio.openReadingPipe(1,listening_pipes[node_address-2]);
  radio.startListening();
  radio.printDetails();
  if ( role == role_invalid )
  {
    printf("\n\r*** NO NODE ADDRESS ASSIGNED *** Send 1 through 6 to assign an address\n\r");
  }
}

void loop(void)
{
    radio.stopListening();
    unsigned long time = millis();
    sensorblau = analogRead(A7);
    sensorgruen = analogRead(A6);
    sensorrot = analogRead(A5);
    printf("Now sending %lu...",sensorblau); //ersetze "time" durch den Sensorwert
    radio.write( &sensorblau, sizeof(const long) );//ersetze "time" durch den Sensorwert
    radio.startListening();
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 250 )
        timeout = true;
    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(100);

}

Vielleicht seh ich ja auch grad einfach den Wald vor Bäumen nicht... Undecided

Anbei auch gleich die Frage, wie ich es schaffe alle 3 Werte zu senden- z.b. als array?

und der Vollständigkeit halber das Sketch der Zentrale, die ein 3,2" TFT zur Anzeige hat:
Code:
#include <SPI.h>
#include <EEPROM.h>
#include <UTFT.h>
#include <DS3232RTC.h>
#include <Time.h>
#include <TimeAlarms.h>
#include <Wire.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

#define TIME_MSG_LEN  11   // time sync to PC is HEADER followed by Unix time_t as ten ASCII digits
#define TIME_HEADER  'T'   // Header tag for serial time sync message
#define TIME_REQUEST  7    // ASCII bell character requests a time sync message

// T1444334730  //20:05  08.10.2015

extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];
UTFT myGLCD(HX8357B,38,39,40,41);

tmElements_t tm;
int sensorValue = 140; // hier den Wert vom externen Lichtsensor "Node 2" einfügen
int Scene = 1;
char scene[2];
int Sende = 1;
char sende[2];
int inSwitch1 = 5;
int inSwitch2 = 9;
unsigned long switch1ActiveTime = 0;
const unsigned long intervalSwitch1Active = 100;

RF24 radio(7,8);

const uint64_t talking_pipes[5] = { 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL };
const uint64_t listening_pipes[5] = { 0x3A3A3A3AD2LL, 0x3A3A3A3AC3LL, 0x3A3A3A3AB4LL, 0x3A3A3A3AA5LL, 0x3A3A3A3A96LL };

typedef enum { role_invalid = 0, role_ping_out, role_pong_back } role_e;
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

role_e role;

const uint8_t address_at_eeprom_location = 0;
uint8_t node_address;

void setup(void)
{
  // Setup the LCD
  myGLCD.InitLCD();
  myGLCD.clrScr();
  myGLCD.setFont(BigFont);
  setSyncProvider(RTC.get);   // the function to get the time from the RTC
    // create the alarms
  //Alarm.alarmRepeat(6,20,0,Scene02);
  //Alarm.alarmRepeat(7,30,0,Scene03);
  Alarm.alarmRepeat(13,30,0,Scene04);
  Alarm.alarmRepeat(17,30,0,Scene05);
  Alarm.alarmRepeat(19,30,0,Scene06);
  Alarm.alarmRepeat(22,0,0,Scene07);
  Alarm.alarmRepeat(22,20,0,Scene08);
  //Alarm.alarmRepeat(21,45,0,Scene09);
  //Alarm.alarmRepeat(23,10,0,Scene10);
  //Alarm.alarmRepeat(22,10,0,Scene0);
  Alarm.alarmRepeat(dowMonday,7,30,30,Scene01);  
  Alarm.alarmRepeat(dowTuesday,7,30,30,Scene01);
  Alarm.alarmRepeat(dowWednesday,7,30,30,Scene01);
  Alarm.alarmRepeat(dowThursday,7,30,30,Scene01);
  Alarm.alarmRepeat(dowFriday,7,30,30,Scene01);
  Alarm.alarmRepeat(dowSaturday,7,40,30,Scene01);
  Alarm.alarmRepeat(dowSunday,7,40,30,Scene01);
  Alarm.alarmRepeat(dowMonday,8,50,30,Scene02);  
  Alarm.alarmRepeat(dowTuesday,8,50,30,Scene02);
  Alarm.alarmRepeat(dowWednesday,8,50,30,Scene02);
  Alarm.alarmRepeat(dowThursday,8,50,30,Scene02);
  Alarm.alarmRepeat(dowFriday,8,50,30,Scene02);
  Alarm.alarmRepeat(dowSaturday,8,40,30,Scene02);
  Alarm.alarmRepeat(dowSunday,8,40,30,Scene02);
  Alarm.alarmRepeat(dowMonday,11,0,30,Scene03);  
  Alarm.alarmRepeat(dowTuesday,11,0,30,Scene03);
  Alarm.alarmRepeat(dowWednesday,11,0,30,Scene03);
  Alarm.alarmRepeat(dowThursday,11,0,30,Scene03);
  Alarm.alarmRepeat(dowFriday,11,0,30,Scene03);
  Alarm.alarmRepeat(dowSaturday,10,45,30,Scene03);
  Alarm.alarmRepeat(dowSunday,10,45,30,Scene03);
  Alarm.alarmRepeat(dowMonday,21,55,30,Scene10);  
  Alarm.alarmRepeat(dowTuesday,21,55,30,Scene10);
  Alarm.alarmRepeat(dowWednesday,21,55,30,Scene10);
  Alarm.alarmRepeat(dowThursday,21,55,30,Scene10);
  Alarm.alarmRepeat(dowFriday,22,45,30,Scene10);
  Alarm.alarmRepeat(dowSaturday,22,45,30,Scene10);
  Alarm.alarmRepeat(dowSunday,21,55,30,Scene10);
  //Alarm.timerRepeat(30, Repeats);
    
  SPI.begin();
      if(timeStatus() != timeSet)
    {
          myGLCD.setColor(25, 0, 255);
          myGLCD.setBackColor(0, 0, 0);
          myGLCD.print("Die Uhrzeit kann nicht synchronisiert werden", RIGHT, 23);
          delay(5000);
          myGLCD.clrScr();
    }
   else
          myGLCD.setColor(255, 55, 0);
          myGLCD.setBackColor(0, 0, 0);
          myGLCD.print("Die Uhrzeit wurde synchronisiert", RIGHT, 23);
          delay(1000);
          myGLCD.clrScr();
                          
tmElements_t tm;
setSyncProvider(RTC.get); // holen Zeit von RTC(Uhr)
  
    role = role_pong_back;
    node_address = 1;
  
  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/starping/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("ADDRESS: %i\n\r",node_address);

  radio.begin();

    radio.openReadingPipe(1,talking_pipes[0]);
    radio.openReadingPipe(2,talking_pipes[1]);
    radio.openReadingPipe(3,talking_pipes[2]);
    radio.openReadingPipe(4,talking_pipes[3]);
    radio.openReadingPipe(5,talking_pipes[4]);

  radio.startListening();
  radio.printDetails();
  if ( role == role_invalid )
  {
    printf("\n\r*** NO NODE ADDRESS ASSIGNED *** Send 1 through 6 to assign an address\n\r");
  }
}

void Scene0()
{
  Serial.println("00");
  Scene = 0;
}
void Scene01()
{
  Serial.println("01");
  Scene = 1;
}

void Scene02()
{
  Serial.println("02");
  Scene = 2;
}
void Scene03()
{
  Serial.println("03");
  Scene = 3;
}
void Scene04()
{
  Serial.println("04");
  Scene = 4;
}
void Scene05()
{
  Serial.println("05");
  Scene = 5;
}
void Scene06()
{
  Serial.println("06");
  Scene = 6;
}
void Scene07()
{
  Serial.println("07");
  Scene = 7;
}
void Scene08()
{
  Serial.println("08");
  Scene = 8;
}

void Scene09()
{
  Serial.println("09");
  Scene = 9;
}

void Scene10()
{
  Serial.println("10");
  Scene = 10;
}

void Scene11()
{
  Serial.println("11");
  Scene = 11;
}

void Scene12()
{
  Serial.println("12");
  Scene = 12;
}
void Scene13()
{
  Serial.println("13");
  Scene = 13;
}
void Scene14()
{
  Serial.println("14");
  Scene = 14;
}
void Scene15()
{
  Serial.println("15");
  Scene = 15;
}
void Scene16()
{
  Serial.println("16");
  Scene = 16;
}
void Scene17()
{
  Serial.println("17");
  Scene = 17;
}


void loop(void)
{
  myGLCD.setColor(205, 15, 55);
  myGLCD.setBackColor(0, 0, 0);
  myGLCD.setFont(BigFont);
  myGLCD.print("Lampensteuerung Eltern", 5, 13);
  myGLCD.setFont(BigFont);
  myGLCD.setColor(255, 255, 0);
  myGLCD.print(".", 65, 150);
  myGLCD.print(".", 140, 150);
  myGLCD.print(":", 80, 75);
  myGLCD.print(":", 180, 75);
int t = RTC.temperature();
float celsius = t / 4.0;
float fahrenheit = celsius * 9.0 / 5.0 + 32.0;
  myGLCD.print("Temp", 295, 75);
  myGLCD.print("O", 425, 45);
  myGLCD.setFont(SevenSegNumFont);
  myGLCD.printNumI(hour(), 10, 45);
  myGLCD.printNumI(minute(), 100, 45);
  myGLCD.printNumI(second(), 200, 45);
  myGLCD.printNumI(day(), 5, 115);
  myGLCD.printNumI(month(), 75, 115);
  myGLCD.printNumI(year(), 155, 115);
  myGLCD.printNumI(RTC.temperature()/4.0, 365, 45);
  myGLCD.setFont(BigFont);
  myGLCD.print("zugeordnetes", 5, 175);
  myGLCD.print("Programm:", 5, 195);
  myGLCD.print("gesendetes", 5, 215);
  myGLCD.print("Programm:", 5, 235);
  String scene = String(Scene);
  String sende = String(Sende);
  myGLCD.setColor(25, 155, 255);
  myGLCD.print(scene, 170, 195);
  myGLCD.print(sende, 170, 235);
  Alarm.delay(10);
  
    if ((digitalRead(inSwitch1) == HIGH) && Scene < 10)
  {
        myGLCD.setColor(25, 155, 105);
                myGLCD.print("Programm ++", RIGHT, 175);
                Scene = Scene + 1;
                delay(200);
                myGLCD.print("             ", RIGHT, 175);
  }
  if ((digitalRead(inSwitch2) == HIGH) && Scene > 0)
  {
        myGLCD.setColor(25, 155, 105);
        myGLCD.print("Programm --", RIGHT, 195);
                Scene = Scene - 1;
                delay(200);
                myGLCD.print("            ", RIGHT, 195);
  }
      if (sensorValue < 2000)
  {
    Sende = Scene;
  }  
  
  else
  {
    Sende = 0;
  }
  
    uint8_t pipe_num;
    if ( radio.available(&pipe_num) )
    {
      unsigned long Sende;
      bool done = false;
      while (!done)
      {
        done = radio.read( &Sende, sizeof(const long) );
        printf("Got payload %lu from node %i...",Sende,pipe_num+1);
      }

      radio.stopListening();
      radio.openWritingPipe(listening_pipes[pipe_num-1]);
      uint16_t pipe_id = listening_pipes[pipe_num-1] & 0xffff;
      radio.write( &Sende, sizeof(unsigned long) );
      printf("Sent response to %04x.\n\r",pipe_id);
      radio.startListening();
    }

}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.10.2015, 15:07
Beitrag #2
RE: Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
Hi,
ich werde jetzt bestimmt nicht das ganze Coding durcharbeiten, aber das hier ist mir aufgefallen:
Code:
radio.write( &sensorblau, sizeof(const long) );//ersetze "time" durch den Sensorwert
Weiter oben hast Du sensorblau als int deklariert. D.h. wenn Du die Daten an der Adresse von sensorblau, aber mit der Laenge eines long sendest, dann wirst Du zum Teil Bloedsinn erhalten.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.10.2015, 22:09
Beitrag #3
RE: Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
Danke Thorsten,

jetzt hab ich verschiedene Varianten versucht,
Code:
radio.write( &sensorblau, sizeof(char[2]) );
damit bekomme ich erstaunlicherweise die Antwort als 3-stelligen Wert.... abwohl die Antwort von hier kommen sollte:
Code:
unsigned long got_time;
      radio.read( &got_time, sizeof(unsigned long) );
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.10.2015, 22:50 (Dieser Beitrag wurde zuletzt bearbeitet: 09.10.2015 23:22 von HaWe.)
Beitrag #4
RE: Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
nach meiner Erfahrung ist Serielle Übertragung eine unglaublich wackelige Angelegenheit und läuft schnell in einen unsynchronisierten Zustand.
Ich verwende einen Array von 32 Bytes und wandle alle Zahlen erst in einzelne Bytes um (das geht auch per memcpy).
Der Array hat einen Startwert zum Synchronisieren an 1. Stelle = array[0] (0xff) und eine Prüfsumme an 2. Stelle=array[1] (Summer aller Bytes ab 3.Stelle, davon Lowbyte). Hierauf prüft der Empfänger, bevor er den Array verwendet.

Außerdem muss ein Puffer eingerichtet werden samt time-out bei Verbindungsunterbrechung.

Hier ist der Code - er sendet zwei verschiedene Arrays von A nach B und wieder zurück, ist schnell und fehlersicher:

http://www.mindstormsforum.de/viewtopic....=15#p67556

Vielleicht kannst du dich daran für radio orientieren.
HTH!

(ps,
welche radio Hardware verwendest du?)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
10.10.2015, 16:58 (Dieser Beitrag wurde zuletzt bearbeitet: 10.10.2015 17:12 von MaHaI976.)
Beitrag #5
RE: Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
Ich nutze die nrf24- funktionieren super...

Ich schua mir mal deinen Tipp an- vielleicht komm ich damit weiter.. danke

aaaahhhh..... bin etwas weiter.... das was mir der serielle Monitor vom Außensensor als gesendeten Wert zeigt entspricht nicht der Wahrheit... denn im seriellen Monitor der Zentrale kommt der empfangene so wie erwartet an. Und das was er dann als Feedback an den Außensensor zurückgibt entspricht auf beiden Seiten der Funkstrecke dem gleichen Wert....
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
10.10.2015, 21:59 (Dieser Beitrag wurde zuletzt bearbeitet: 10.10.2015 22:42 von MaHaI976.)
Beitrag #6
RE: Sensorwerte unplausibel bei Funknetzwerk - Variablenzuordnung???
Aaaalso... ich komme der Lösung nicht näher.... hab jetzt mal 2 Dummys gebaut- lediglich je ein nano + ein nrf24, einen davon mit einem Helligkeitssensor... Beide haben jetzt einen minimalen Sketch, wo die Werte im seriellen Monitor angezeigt werden- beim Sender ist es noch unplausibel, beim Empfänger kommt es zumindest nachvollziehbarer an....

Code:
#include <SPI.h>
#include <EEPROM.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

int Szene = 1;

RF24 radio(9,10);

const uint64_t talking_pipes[5] = { 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL };
const uint64_t listening_pipes[5] = { 0x3A3A3A3AD2LL, 0x3A3A3A3AC3LL, 0x3A3A3A3AB4LL, 0x3A3A3A3AA5LL, 0x3A3A3A3A96LL };

typedef enum { role_invalid = 0, role_ping_out, role_pong_back } role_e;
const char* role_friendly_name[] = { "Ungueltig", "Antworter", "Sender"};
role_e role;
const uint8_t address_at_eeprom_location = 0;
uint8_t node_address;

void setup(void)
{
    role = role_pong_back;
    node_address = 1;
  
  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/starping/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("ADDRESS: %i\n\r",node_address);
  
  radio.begin();

    radio.openReadingPipe(1,talking_pipes[0]);
    radio.openReadingPipe(2,talking_pipes[1]);
    radio.openReadingPipe(3,talking_pipes[2]);
    radio.openReadingPipe(4,talking_pipes[3]);
    radio.openReadingPipe(5,talking_pipes[4]);
    
  radio.startListening();
  radio.printDetails();
}

void loop(void)
{
    uint8_t pipe_num;
    if ( radio.available(&pipe_num) )
    {
      unsigned long Status;
      bool done = false;
      while (!done)
      {
        done = radio.read( &Status, sizeof(unsigned long) );
        printf("Empfange payload %lu von node %i...",Status,pipe_num+1);
      }
      
      radio.stopListening();
      radio.openWritingPipe(listening_pipes[pipe_num-1]);
      uint16_t pipe_id = listening_pipes[pipe_num-1] & 0xffff;

      radio.write( &Szene, sizeof(unsigned long) );
      printf("Sende Rueckmeldung %lu an %04x.\n\r",Szene,pipe_id);

      radio.startListening();
    }
}

Code:
#include <SPI.h>
#include <EEPROM.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

int Sensor = 1;
int SensorPIN = A7;

RF24 radio(9,10);

const uint64_t talking_pipes[5] = { 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL };
const uint64_t listening_pipes[5] = { 0x3A3A3A3AD2LL, 0x3A3A3A3AC3LL, 0x3A3A3A3AB4LL, 0x3A3A3A3AA5LL, 0x3A3A3A3A96LL };

typedef enum { role_invalid = 0, role_ping_out, role_pong_back } role_e;
const char* role_friendly_name[] = { "Ungültig", "Sender", "Anwortender"};
role_e role;
const uint8_t address_at_eeprom_location = 0;
uint8_t node_address;

void setup(void)
{
  pinMode(SensorPIN, INPUT);
  
    role = role_ping_out;
    node_address = 2; //Adresse 2- 6 gültige

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/starping/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("ADDRESS: %i\n\r",node_address);
  
  radio.begin();

    radio.openWritingPipe(talking_pipes[node_address-2]);
    radio.openReadingPipe(1,listening_pipes[node_address-2]);
  
  radio.startListening();
  radio.printDetails();
}

void loop(void)
{
    Sensor = analogRead(SensorPIN);
  
    radio.stopListening();
    printf("Sende Sensorwert %lu...",Sensor);
    radio.write( &Sensor, sizeof(unsigned long) );
    
    radio.startListening();
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 250 )
        timeout = true;
        
    if ( timeout )
    {
      printf("fehlgeschlagen- die Zeit wurde ueberschritten.\n\r");
    }
    else
    {
      unsigned long Szene;
      radio.read( &Szene, sizeof(unsigned long) );
      printf("Antwort erhalten %lu\n\r",Szene);
    }
    delay(1000);
}

OK, hab mir eben noch mal Thorstens Antwort in Ruhe durchgelesen und einfach die Variablen durchgängig mit "long" deklariert... jetzt paßt es... manchmal sieht man den Wald vor Bäumen nicht... danke!!!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Funknetzwerk mit Uhr und Wecker - Sketch stoppt bei Funk MaHa1976 4 1.535 02.01.2015 19:43
Letzter Beitrag: MaHa1976

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste