ELEKTRO FORUM

Hier mal ein kleiner Tip. Hat mich gerade bestimmt eine Stunde ins
gruebeln gebracht bis ich darauf gekommen bin. :-)

Wenn man etwas sendet dann darf man den Sender nicht eher ausschalten
als bis auch die beiden Bytes im Puffer des RFM12 gesendet worden
sind.

Im einfachsten Falle einfach noch zwei beliebige Bytes an die eigenen
Nutzdaten anhaengen bevor man den Sender abschaltet, die werden
sowieso nicht gesendet.

Olaf

Olaf Kaluza schrieb:
> Hier mal ein kleiner Tip. Hat mich gerade bestimmt eine Stunde ins
> gruebeln gebracht bis ich darauf gekommen bin. :-)
> Wenn man etwas sendet dann darf man den Sender nicht eher ausschalten
> als bis auch die beiden Bytes im Puffer des RFM12 gesendet worden
> sind.
>
> Im einfachsten Falle einfach noch zwei beliebige Bytes an die eigenen
> Nutzdaten anhaengen bevor man den Sender abschaltet, die werden
> sowieso nicht gesendet.

Also einen kurzen blick in meinen Source:
...
rf12 TX(0x0); //dummy byte
...
rf12 loop until FFIT RGIT();
//enable receiver
rf12 cmd(RF12 POWER SETTING, RF12 ER | RF12 DISABLE CLOCK OUTPUT);

Ich sende also nur 1Byte dummy daten und polle dann das Statusbit auf
Receiver-FIFO ready.

Für welche CPU schreibst du?

Gruß Andy


PS: Jetzt gibt es ja doch wieder diverse Threads zu dem Modul, können
wir nicht mal irgendwo die Daten sammeln?

Andreas Weber <spam@tech-chat.de> wrote:


>rf12 TX(0x0); //dummy byte
>...
>rf12 loop until FFIT RGIT();

Letzteres spare ich mir da ich es ja indirekt mache wenn ich zwei Byte
sende oder sagen wir mal lieber in den Puffer schreibe. Gesendet
werden die naemlich nicht mehr.

>Für welche CPU schreibst du?

68338 (aka Dragonball) und M306020 (M16C/62A)

Ich werde aber auf jedenfall noch auf M16C/28 und vielleicht auch
R8Cxx implementieren.

>PS: Jetzt gibt es ja doch wieder diverse Threads zu dem Modul, können

>wir nicht mal irgendwo die Daten sammeln?

Mach doch. :-) Mir reicht Usenet.

Olaf

Olaf Kaluza wrote:
> Andreas Weber <spam@tech-chat.de> wrote:
>
>
> >rf12 TX(0x0); //dummy byte
> >...
> >rf12 loop until FFIT RGIT();
>
> Letzteres spare ich mir da ich es ja indirekt mache wenn ich zwei Byte
> sende oder sagen wir mal lieber in den Puffer schreibe. Gesendet
> werden die naemlich nicht mehr.
>
> >Für welche CPU schreibst du?
>
> 68338 (aka Dragonball) und M306020 (M16C/62A)
>
> Ich werde aber auf jedenfall noch auf M16C/28 und vielleicht auch
> R8Cxx implementieren.
>
> >PS: Jetzt gibt es ja doch wieder diverse Threads zu dem Modul,
können
> >wir nicht mal irgendwo die Daten sammeln?
>
> Mach doch. :-) Mir reicht Usenet.
>

Zitat aus dem Heinz Ruehmann Film "Der Luegner": Das ist zu einfach!

--
Gruesse, Joerg

http://www.analogconsultants.com/

Andreas Weber <spam@tech-chat.de> wrote:

>> Im einfachsten Falle einfach noch zwei beliebige Bytes an die eigenen
>> Nutzdaten anhaengen bevor man den Sender abschaltet, die werden
>> sowieso nicht gesendet.
>
> Also einen kurzen blick in meinen Source:
> ...
> rf12 TX(0x0); //dummy byte

heureka! das gestern beschriebene problem, daß ich die daten doppelt
senden muß, um sie 1.2 mal zu empfangen, hat sich grad gelöst.

ich glaub nämlich, das datasheet belügt uns: ich interpretiere
jedenfalls die graphik "Typical TX register usage" auf s. 24 in
rf12.pdf so, daß ein dummy-byte ausreichend ist. scheint aber nicht so
zu sein, wenn ich nämlich in rf12 send 2 dummy-bytes sende, schaut die
übertragung (im kurzen test) zuverlässig aus ohne doppeltes senden.

ich mach hier jetzt also

rf12 cmd(RF12 POWER SETTING, RF12 ET | RF12 DC); // turn on xmit
rf12 send((uint8 t *)&data, sizeof(data));
rf12 cmd(RF12 POWER SETTING, RF12 DC); // turn off

ciao,

cm.

--
Hat irgendwer schlechte Schwingungen in seiner globalen
Eierkuchen-Aura bekommen weil man ihm gesagt hat er soll bitte nicht
andauernd mit Vollquotes in 10 Gruppen gleichzeitig crossposten?
Albert Koellner in at.usenet

christian mock schrieb:

> ich glaub nämlich, das datasheet belügt uns: ich interpretiere
> jedenfalls die graphik "Typical TX register usage" auf s. 24 in
> rf12.pdf so, daß ein dummy-byte ausreichend ist. scheint aber nicht
so
> zu sein, wenn ich nämlich in rf12 send 2 dummy-bytes sende, schaut
die
> übertragung (im kurzen test) zuverlässig aus ohne doppeltes
senden.

> ich mach hier jetzt also
>
> rf12 cmd(RF12 POWER SETTING, RF12 ET | RF12 DC); // turn on xmit
> rf12 send((uint8 t *)&data, sizeof(data));
> rf12 cmd(RF12 POWER SETTING, RF12 DC); // turn off

Hint: rf12 TX (zumindest in der Version von Andreas) wartet nicht, bis
das TX-Register wieder aufnahmebereit ist. Dann benötigt man
natürlich
zwei Dummy-Bytes. Ein Dummy-Byte sollte reichen, wenn man ganz zum
Schluss von rf12 send noch einmal rf12 loop until FFIT RGIT aufruft.
Denn erst wenn ein Dummy-Byte geschrieben wurde und danach RGIT wieder
gesetzt ist, wurde das letzte Datenbyte gesendet.

Alternativ müsste man nach dem letzten Datenbyte auch auf ein "TX
register underrun" warten können.

Eigentlich alles ganz logisch.

CU Christian
--
Christian Zietz - CHZ-Soft - czietz (at) gmx.net
WWW: http://www.chzsoft.com.ar/
PGP/GnuPG-Key-ID: 0x6DA025CA

Christian Zietz <newsgroup@chzsoft.com.ar> wrote:

>Hint: rf12 TX (zumindest in der Version von Andreas) wartet nicht, bis
>das TX-Register wieder aufnahmebereit ist.

Warum sollte eine Senderoutine darauf warten das der Sender das Byte
gesendet hat? Damit verschwendet man doch Rechnenzeit die man
wohlmoeglich woanders, z.B zum bearbeiten/holen des naechstens Bytes
bitter noetig hat.
Ich warte immer vor dem reinschreiben bis wieder Platz fuer mein
frisches Byte ist.

Olaf

christian mock <cm@tahina.priv.at> wrote:


>ich glaub nämlich, das datasheet belügt uns: ich interpretiere
>jedenfalls die graphik "Typical TX register usage" auf s. 24 in
>rf12.pdf so, daß ein dummy-byte ausreichend ist. scheint aber nicht
so
>zu sein, wenn ich nämlich in rf12 send 2 dummy-bytes sende, schaut
die
>übertragung (im kurzen test) zuverlässig aus ohne doppeltes
senden.

Also jetzt wo ich das Diagramm sehe <BG>, muss ich dir zustimmen.

Wobei aber auch von der Baudrate und der Prozessorgeschwindigkeit
abhaengt. Wenn dir der RF12 sagt das er jetzt ein neues Byte
gebrauchen kann, dann hat er ja kurz vorher 8Bit freigemacht und
sendet das obere Bit der anderen 8Bit.

Wenn man jetzt eine sehr hohe Baudrate haette, und sich ausserdem beim
holen des naechstens Bytes etwas Zeit laesst, oder man selber die SPI
Anbindung relativ langsam betreibt dann koennte er ja schon mehr Bits
gesendet haben und dann ist bis zum abschalten bereits wieder ein Byte
ganz draussen.

Bei mir war es aber definitiv so das immer die letzten beiden Bytes
zerstoert waren.



> rf12 cmd(RF12 POWER SETTING, RF12 ET | RF12 DC); // turn on xmit
> rf12 send((uint8 t *)&data, sizeof(data));
> rf12 cmd(RF12 POWER SETTING, RF12 DC); // turn off

Wenn ich das richtig sehe dann sollte es nach dem einschalten noch
eine gewisse Wartezeit geben damit Clock, Pll hochfahren. Bei mir
klappte es zwar auch ohne dem, aber ich sende sichheiteshalber mal 6x
0xAA vor der Uebertragung.

Also so:

rf12 txmode(); /* RF12 in Sendebetrieb */

rf12 txbyte(0xaa); /* Das braucht der andere */
rf12 txbyte(0xaa); /* Empfaenger um sich zu */
rf12 txbyte(0xaa); /* syncronisieren */
rf12 txbyte(0xaa);
rf12 txbyte(0xaa);
rf12 txbyte(0xaa);

rf12 txbyte(0x2d); /* Kennung fuer Empfaenger */
rf12 txbyte(0xd4); /* Damit er seine Fifo einschaltet */

for (i=0;i<sizeof(union multibus def);i++)
{
rf12 txbyte(MultiBlockS.b[i]);

if ((RF12Err.bit.Timeout) || (RF12Err.bit.TxErr))
{
MultiErr.bit.TxErr=1;
rf12 off(); /* RF12 ausschalten zum Stromsparen!
*/
return(FALSE);
}
}

rf12 txbyte(0xaa); /* Zwei Dummybytes senden. Wir duerfen */
rf12 txbyte(0xaa); /* den Sender nicht abschalten bevor der */
/* Puffer der Nutzbytes leer ist! */

rf12 off(); /* RF12 ausschalten zum Stromsparen! */


Olaf