next topic »

[on:]

Hallo, Ich habe ein kleineres Problem, Ich habe eine Funkverbindung mit den RFM12 zwischen 2 Arduinos. einer sendet der andere empfängt. Das senden von 8 bit werten (ein Potivalue auf 0-255 gemappt) funktioniert sehr gut. Allerdings reicht mir  die auflösung nicht aus, Ich möchte gern den 16 Bit wert des Potis (0-1024) versenden. also müsste ich die 16bit zahl mittels lowByte(); und highByte(); ersteinmal aufsplitten, um sie auf der empfängerseite mit word(h,l) ; wieder zusammen zu fügen. Jetzt meine Frage...
Wie" markiere" ich die 2 Werte die ich nacheinander sende, das der empfänger mit der reihenfolge nicht durcheinander kommt?
Hier ist ein Link zur Bibliotheksreferenz der RFM12. sehe ich nicht so richtig durch.http://jeelabs.net/projects/cafe/wiki/RF12

das hier sind die funktionierenden .Pdes zum 8bit wert Senden...

Code:

//SENDEN

#include <Ports.h>
#include <RF12.h>
#include <RF12sio.h>

int sensorPin = A0;  
int sensorValue = 1;


RF12 RF12;

void setup() {
    Serial.begin(57600);
    rf12_config();
    rf12_easyInit(0);
}

void loop()
{
 rf12_easyPoll();
  
  sensorValue = analogRead(sensorPin);
  sensorValue = map( sensorValue,0,1024,0,255)

 
 rf12_easySend(&sensorValue, sizeof sensorValue);

 // Serial.println(sensorValue);
 }

Und die Empfänger seite:...

Code:

//EMPFANGEN



#include <Ports.h>
#include <RF12.h>
#include <RF12sio.h>

byte ReadA = 0;        // Header Signal

RF12 RF12;             // kein Plan kann evtl weg.

void setup() {
    Serial.begin(57600);
    rf12_config();  // RFM12 muss vorher zb. Mit der RFDemo.pde auf group 212 und ID 1 bzw2   gesetzt werden
}

void loop()
{
 if (RF12.poll())
    {
     ReadA = RF12.read();
     Serial.println(ReadA);
     delay(10);
     }      
}

Könnt Ihr mir bitte helfen einen 16 bit wert zu verschicken und im empfänger wieder sinnfoll zusammen zu bauen? Bekomme es nicht hin.....

[Reply #1 on:]

Du sendest ein Paket das zb mit 3 gleichen Zeichen anfängt und dann di 2 BYTE kommen Danach gegebenen falls noch ein "Stop"Zeichen..
zB aaa12b.
Grüße Uwe

[Reply #2 on:]

Würden nicht 2 gleiche byte am Anfangen reichen? das wären ZB 2x 255. danach mein Hsb und Lsb und danach eine 0. Da ich nur 0-1024 werte benötige werden niemals das Hsb und das Lsb aus 2x255 bestehen.
Hab ich das so richtig verstanden? und die frage ist ja , in der Theorie klingt das ziehmlich gut, in der Praxis wüsste ich nicht wie ich das schreibe....bzw wie sage ich auf der empfänger seite: warte auf 2x 255 dann merke Hsb und darauf Lsb und wenn die 0 kommt, kann ich Hsb und Lsb zusammenfüren. Des Sender sendet im moment so oft es ihm Möglich ist, wenn der empfäner aber gerade ein paket vom RFM12 abhohlt und das nächste schon geschickt wird, verpasst er das ja, giebt es da irgend ein timing an das sich die beiden seiten halten, oder ist das irrelevant??

[Reply #3 on:]

UART haben einen internen Buffer; da geht erst was verloren wenn sich einiges angesammelt hat.
Du ladst 5 Byte runter kontrollierst ob die ersten 255 sind und das letzte 0 dann sind die anderen beiden Bytes die Zahl.
Ich weiß nicht ob 2 Bytes reichen, Daß siehst Du experimentiell.
Grüße Uwe

[Reply #4 on:]

Hätte noch eine andere Idee was vieleicht optimaler ablauft. und zwar Benötige ich ja nur 1024 werte also weit unter 32767 (was bedeutet ich benötige die 16 Bitstelle des Int wertes nicht. somit könnte ich 3x 5 bits übertragen wobei in jedem der 3 bits die vorderen 2 und das letzte als "marker dienen könnten. also ich könnte mir mittels bitshifting meine bits so schieben das ich die vorderen 2 und das letzte bit manuel "beschreibe" . somit könnte ich an der reciver seite nur die ersten 2 bits abfragen, somit weiss ich welcher teil der 3 pakete gerade ankommt. die abfrage des letzten bits (merke ich gerade) wäre irrelevant, brauch ich da nich..naja weiß nich ob ich mich jetzt bisschen vermorxt ausgedrückt hab, aber das könnte doch auch klappen, somit wären die daten auch schneller zur verfügung da ich weniger pakete senden müsste...Oder?

[Reply #5 on:]

Müßte funktionieren; ist halt mehr rechenaufwand.
Grüße Uwe

[Reply #6 on:]

Hallo Uwe, schau mal bitte, ich hab jetz mal etwas zusammen geschrieben, was im grunde Funktioniert, ich habe nur ein problem (vermutlich mit dem addieren der bits  beim wieder zusammen setzen) Die Pakete werden gesendet, und auch empfangen und zugeordnet, allerdings ist irgendwo ein klitze Fehler.Wenn ich das Poti einlese bekomme ich nur 0 heraus, wenn ich den TEST_counter hochzählen lasse, funktioniert das ganze nur in 256er schritten, als würden die ersten 8 bit nicht anerkannt 0oder wären Nullen, weiß nicht. Kannst du mir vieleicht nochmal Helfen und mal kurz reinlesen..Lach bitte nich über meine Programmierweise ich weiß es nich anders....:-)

Die Sende Seite...

Code:

//SENDEN

#include <Ports.h>
#include <RF12.h>
#include <RF12sio.h>

int sensorPin = A0;  
unsigned int  Value1 = 0;

byte Send_A = 0;     //besteht aus 2 Header Bits (10) und den ersten 6 Datenbits von Value1
byte Send_B = 0;     //besteht aus 2 Header Bits (01) und den bits 7-12 von Value1
byte Send_C = 0;     //besteht aus 2 Header Bits (00) und den bits 13-16 und 4 Nullen von Value1

byte Send_X = 0;     // Wert zum Senden

int TEST_counter = 0;     //Testcounter

RF12 RF12;

void setup()
{
    Serial.begin(57600);
    rf12_config();
    rf12_easyInit(0);
}

void loop()
{
 //Value1 = analogRead(sensorPin);      // Poti einlesen /testcounter
   Value1 = TEST_counter;
   TEST_counter++;
 
 
 Send_A = Value1;         //8bit Sendepaket A und Header eintragen
 bitWrite(Send_A, 7, 0);
 bitWrite(Send_A, 8, 1);
 
 Send_B = Value1 >> 6;     //8bit Sendepaket B und Header eintragen
 bitWrite(Send_B, 7, 1);
 bitWrite(Send_B, 8, 0);

 Send_C = Value1 >> 12;     //8bit Sendepaket C und Header eintragen + nichtbenötigte bits werden 0
 bitWrite(Send_C, 5, 0);    
 bitWrite(Send_C, 6, 0);  
 bitWrite(Send_C, 7, 0);
 bitWrite(Send_C, 8, 0);





rf12_easyPoll();                     // RFM12 Pollen (wird benötigt)
     for (byte i = 0; i < 4; i++)     // 3 Sendepackete nacheinander Senden
         {
           if (i == 1)
               {Send_X =Send_A;
               Serial.println("A");
               }
           if (i == 2)
               {Send_X =Send_B;
                Serial.println("B");  
               }              
           if (i == 3)
               {Send_X =Send_C;
                Serial.println("C");  
               }              
        
               rf12_easySend(&Send_X, sizeof Send_X);  // und Senden!!
          
         }
}

und Die Empfänger Seite....

Code:

//EMPFANGEN



#include <Ports.h>
#include <RF12.h>
#include <RF12sio.h>


byte readarduino_8bit = 0;     // empfangener 8bit Wert
unsigned int Value_1 = 0;      // Ausgabe Varriable

byte LowBitV1 = 0;              // wert für ersten 8 bits von Value1
byte HighBitV1 = 0;             // wert für bit 9 bis 16 von Value1


byte Read_A = 0;              // 3 verschiedene empfangene Daten
byte Read_B = 0;
byte Read_C = 0;



RF12 RF12;    // wird irgendwie benötigt warum weiß ich nicht

void setup() {
    Serial.begin(57600);
    rf12_config();        // initialisieren von RFM12 ( wie mans voreingestellt hat(demo.PDE))
}

void loop()
{

    if (RF12.poll())                          //wenn RFM12 verfügbar ist...
        readarduino_8bit = RF12.read();      // lese das.....
  
  
    if ( bitRead(readarduino_8bit,8)==1)         //wenn bit 8 eine 1 ist kanns nur Read_A sein      
        {
         if ( bitRead(readarduino_8bit,7)==0)
              Read_A = readarduino_8bit;
        }
  
    if ( bitRead(readarduino_8bit,8)==0)         // weitere Paketidentifikation      
        {
         if ( bitRead(readarduino_8bit,7)==1)
              Read_B = readarduino_8bit;
         if ( bitRead(readarduino_8bit,7)==0)
              Read_C = readarduino_8bit;
        }

 bitWrite(Read_A, 8, 0);                             // den Header wieder mit nullen Füllen
 bitWrite(Read_B, 7, 0);
 bitWrite(Read_C, 5, 0);
 bitWrite(Read_C, 6, 0);

 LowBitV1 = (Read_B << 6) + Read_A;                 // die ersten 8 bits vom Value1 zusammen kleben
 HighBitV1 =(Read_B >> 2) + Read_C;                 // bit 9 bis 16 zusammenkleben
 
 Value_1 = word(HighBitV1,LowBitV1);                // beide 8bit werte zu 16bit wert zusammenbauen

 Serial.println(Value_1);                           // und siehe da da sollte unser gesendeter 16bit sein
    
}

viele Grüße Tobias