Ansteuerung von Funkmodul RFM12

Hallo,

ich habe eine Frage zur Ansteuerung der RFM12 Funkmodule von Pollin.

Igendwo hab ich mal gelesen (ich weiß nicht mehr wo), dass man die Pin nIRQ am Funkmodul mit dem Anschluss INT0 am Microcontroller verbinden soll. Ich weiß aber nicht was das bringen soll. Wird ein Interrupt ausgelöst, wenn Daten empfangen werden? Oder wenn nicht, was muss ich machen, das dann ein Interrupt ausgelöst wird und zu was soll ich dann nIRQ mit INT0 verbinden?

Ich bedanke mich schom mal im voraus für eure Hilfe.
mfg _R2D2

nach einem kurzen blick ins datenblatt würde ich sagen JA es gibt eine flanke wenn ein byte empfangen wurde .... ich hab das megax datenblatt grad net da aber der mega8 müsste glaube selbst einen interrupt auslösen wenn er meint ein komplettes byte empfangen zu haben

Es gibt einen SPI Interrupt (die Funkmodule werden ja über SPI angesteuert), der denke ich ausgelöst wird wenn über SPI etwas empfangen wurde. Aber bei den Fukmodulen muss man ja bevor sie die empfangenen Daten an den Microcontroller übergeben als ersten eine Funktion zur Ausgabe der Daten aufrufen. Deshalb wäre es mir schon lieber, wenn es mit nIRQ und INT0 funktionieren würde.

ah tschuldigung das mit SPI hab cih übersehen ... der empfang eines bytes sollte per interrupt ausgegeben werden (also ein byte von einem anderen sender)
mittels der ISR sollte dann das byte abgerufen werden

zumindest klingt das für mcih so wie cih das gelesen habe ... SPI an sich kenn cih noch nicht ..... wird da nicht mit ACK und NACK gearbeitet ? wozu dann die externe empfangsbestätigung ?

Hallo

ich sitze hier auch gerad an dem rfm12 und benutze das Pollin Evaluations Board zusammen mit dem addonboard.

seit stunden versuche ich rauszubekommen wie ich die Verbindungen vom ATmega 16 zum rfm12 setzen muss. Da das auf dem addon board mit brücken gemacht wird.

nun wollte ich wissen ob mir einer sagen kann welche Pins vom ATmega16 nun für welche pins vom rfm12 sind

hier die pins vom rfm12 und was ich vermute wie sie verbunden werden:

rfm12 --> ATmega16
------------------------
NIRQ --> INT0 (PD2)
NINT --> INT1 (PD3)

FSK -->
DCLK -->
EN -->
NSEL --> SS(PB4)
SDI --> MOSI (PB5)
SDO --> MISO (PB6)
SCK --> SCK (PB7)
-----------------------
der NRES steht als pin in dem rfm12 datenblatt aber auf meinem board kann ich für den keine brücke setzen...

kann mir einer sagen wie die richtig verbunden werden?
grüße und danke schon mal

Also ich habe jetzt irgendwo im Internet die Beschaltung so gefunden:
VDD -> VCC
SDI -> MOSI
SCK -> SCK
nSEL -> SS
SDO -> MISO
nIRQ -> INT0
GND -> GND
FSK/DATA/nFFS -> über R mit 10kOhm nach VDD
ANT = Antenne

Den Rest muss man nicht verbinden.

mfg

Hi,

das mit den Funkmodulen interressiert mich auch brennend, ich hab die auch bald daheim, die müssen eine Joysticksteuerung für mich werden

könnt ihr hier auch dann ein Feedback posten, ob die Beschaltung so passt und wie man die dann genau ansteuert, also ob jetzt mit UART oder wie auch immer

DANKE :)

MfG Pr0gm4n

Das gemeine an diesen Modulen ist, das man sie in sehr unterschiedlichen Betriebsmodi laufen lassen kann.
Zudem muss man sehr aufpassen von welchem Modul man spricht.
Das RFM01 ist ein Sender
Das RFM02 ein Empfänger
Das RFM12 kann sowohl als Sender als auch als Empfänger betrieben werden.

Ich hab bis jetzt nur mit RFM 01 und RFM 02 gebastelt.

Jedes dieser Module benötigt eine etwas andere Anschlußbelegung am Microcontroller.

Der Sender RFM01 kann mit dem internen Baudrategenerator des RFM betrieben werden. Sobald nun ein neues Bit zur Übertragung dran ist kann er einen Interrupt auslösen ( interner Baudrategenerator ) und das neue Bit über die Data Leitung, aber auch über die FSK Leitung in das Funkmodul geschoben werden.
Man kann aber ebenso den USART des Microcontrollers verwenden, der dann die Übertragungsgeschwindigkeit vorgibt.

Was ich damit sagen will ist, das es im Prinzip keine 100% richtige Beschaltung für diese Module gibt. Sondern sehr vieles ist möglich und von der Software im Microcontroller und den gewünschten Features abhängig.
Die Anschlußbelegung zwischen Microcontroller und Funkmodul ist ausserdem abhängig vom verwendeten Betriebsmodus.

Ich hab z.B. bei meiner Entwicklung beim Empfänger nicht den USART des Microcontrollers verwendet, weil ich den für die Verbindung zum PC gebraucht hab. Also läuft da die Leerung des FiFo Puffers über einen Interrupt und SPI.

Eine Beschaltung für so eine Verbindung rauszugeben macht also nur Sinn, wenn man auch die nötige Software dafür liefert.
Idealerweise für den Sender, sowie den Empfänger.

Ein weiterer Knackpunkt ist noch die grottenschlechte Dokumentation die Po.... auf seiner Homepage zur Verfügung stellt.
Die von hope rf http://www.hoperf.com/ ist etwas besser und auch einigermassen vollständig, auch wenn da nicht jedes Detail erklärt ist.

Es ist wirklich schade, das diese eigentlich sehr vielseitigen und preisgünstigen Module, durch eine schlechte Dokumentation an Praxistauglichkeit verlieren.

Will man wirklich selber mit diesen Funkmodulen etwas entwickeln muss man sich wohl oder übel mit diesen Datenblättern beschäftigen, auch wenn das mühsam ist und Zeit kostet.

Man kann aber auch auf die hier im roboternetz zahlreich vorhandenen Codeschnipsel ( + Beschaltung ) zugreifen und sie für seine Bedürfnisse anpassen.

Hey danke,

ich mach mich dann mal irgendwann dran, ne Platine dafür zu entwerfen, auf der noch ein ATMega8 sitzt, der dann entweder über I²C, UART oder wie beim RN-Funk die Daten empfängt bzw. auch zurückgibt

MfG Pr0gm4n

Hallo nochmal,

ich hätte noch so ne Frage dazu:

da steht was von Differential-Antennen-Eingang, was heisst das im Bezug darauf, welche Antenne ich anschließen kann?

Ich würde gerne je eine WLan Antenne anschliessen, liegen daheim rum, gehn die dann und wie müssen die angeschlossen werden, einfach einen Pin an ANT?

bzw. glaube sind 2 Pins oder so, dann beide an ANT oder maximal 1?

MfG Pr0gm4n

Also, als Antenne reicht eigentlich ein ganz normales Stück Draht, das ca. 16,7cm lang sein sollte. Ob das auch mit einer W-Lan Antenne funktioniert weiß ich nicht.

mfg

Zitat:

da steht was von Differential-Antennen-Eingang

Das hast Du sicher vom Datenblatt des RF01 (oder ähnlichem) Modul.
Das RFMxx hat sowas meines Wissens nach nicht.

W-Lan arbeitet, soweit ich weiß auf 2,4GHz.
Also dürfte so eine Antenne denkbar ungeeignet sein.

Die Funkmodule RFMxx arbeiten auf 433MHz.
Du braucht also eine Antenne für diesen Frequenzbereich und den richtigen Wellenwiderstand, soweit ich mich entsinne waren das 75Ohm - oder eben das berühmte Stück Draht in der richtigen Länge.

Hi,

ja und nein, das steht im Datenblatt des RFM12 und auch bei Pollin, wenn man direkt auf den Artikel geht

Wie kann ich das mit dem richtigen Widerstand rausfinden?

ich dachte das wegen Wlan antenne, weil ich meinte, das wäre doch auch blos Draht, der in diesem Antennenteil verlegt ist, oder?

Wie kommst du auf 75 Ohm und wie kommt R2D2 auf 16,7 cm, das isst doch voll die schwachsinnige Angabe, oder ist das nur die richtige Länge für den 75 Ohm Widerstand?

Ich kann ja mal an der WLan Antenne schauen, wie viel Widerstand die hat, glaube die hat 2 Pole

Muss ich bei der Antenne auch 2 Pole verwenden oder reicht auch einfach einer an ANT ?

MfG Pr0gm4n

Zitat:

Wie kann ich das mit dem richtigen Widerstand rausfinden?...Wie kommst du auf 75 Ohm und wie kommt R2D2 auf 16,7 cm

75Ohm - Ich dachte, das hätte ich im Dateblatt mal wo gelesen.
16,7cm entspricht in etwa 1/4 der Wellenlänge bei 433MHz ( = 69cm ) .
Ein 1/4 Strahler ( Antenne mit 1/4 der Wellenlänge ) hat meines Wissens eine impedanz von rund 75Ohm ( unsere HF Techniker hier werden das aber sicher noch besser erklären können ) . Dazu kommen dann noch diverse Kürzungsfaktoren und so kommt man dann auf eine Antennenlänge von 16,7cm.
Die Wellenlänge bei 2,4GHz 12,5cm, ein viertel davon wären dann rund 3cm.
Da die Antenne auf die verwendete Frequenz abgestimmt sein muß wird das so nicht gehen.

Zitat:

Muss ich bei der Antenne auch 2 Pole verwenden oder reicht auch einfach einer an ANT ?

Wenn Du den Draht direkt an den Antennenanschluß des RFM Moduls lötest brauchst Du keinen zusätzlichen Masse Anschluß.
Willst Du aber die Antenne ausserhalb des Gehäuses anbringen wirst Du ein geschirmtes HF Kabel ( mit dem richtigen Wellenwiderstand ) verwenden müssen und die Abschirmung gehört dabei natürlich auf Masse.
Es sei denn Du verwendest eine Dipol Antenne, die natürlich 2 aktive Anschlüsse hat.
Eigentlich alle Stabantennen ( ~Draht ) brauchen ein sog. Gegengewicht.
Idealerweise ist das eine Verbindung mit Erde.
Da das in transportablen Geräten nur schwer realisierbar ist, behilft man sich mit einer ausgedehnten Masse Fläche auf der Platine.
Lies mal ein wenig über die Grundlagen der Antennentechnik nach, dann wird Dir sicher vieles klarer werden.

Was ist dann das mit diesem Differential-Antennen-Eingang, der bei Pollin beim RFM12 dabeisteht?

MfG Pr0gm4n

Zitat:

Was ist dann das mit diesem Differential-Antennen-Eingang, der bei Pollin beim RFM12 dabeisteht?

Schau dir bitte mal das Datenblatt des RF12 an http://www.hoperf.com/pdf/RF12.pdf dieses Modul hat tatsächlich einen Differential Antennen Eingang.
Wir haben hier aber das RFM12 und nicht das RF12 Modul vor uns.
Im Datenblatt des RFM12 kann ich keinen Hinweis auf einen differential Eingang entdecken, ich werd das halt überlesen haben.
Anscheinend hat P.... den dafür nötigen 2ten Antenneneingang dann auch gleich einer Streichung unterzogen.
Warscheinlicher ist aber, das die Information auf der P.... Seite eine Fehlinformation ist, die aus dem RF12 Datenblatt stammt.
Hab nun auch auf der Seite von HopeRF rumgestöbert. Auch da steht in der Produktbeschreibung so was drin, im Datenblatt auch, aber die Zeichnung wie beim RF12 Modul fehlt!

Viele Seiten aus dem von P... herunterladbaren Datenblatt scheinen ohnehin aus dem HopeRF RF12 Datenblatt zu stammen.

Die oben gestellte Frage solltest Du mal dem P.... Service schicken, mit der Bitte den entsprechenden zweiten Antennenpin zu identifizieren, bin gespannt was Du da für eine Antwort kriegst.

Ok, werde das mal in Angriff nehmen, am besten wäre ne antwort wie:

"Entschuldigen sie meine Fragen, aber was ist bitte ein Differential-Antennen-Eingang? Ich kenne mich damit leider nicht aus."

Ich hab sie zwar so nicht gekriegt, muss ja erst losschicken, aber wie gesagt, wäre schon cool^^

MfG Pr0gm4n

Hallo zusammen

ich bin nun schon einiges weiter als die pinbelegung

die sieht bei meinem rfm12 zu ATmega16 jetzt bei mir so aus:

SCK -> SCK
SDI -> MOSI
SDO -> MISO
nSEL -> SS
FSK -> mit 1kohm auf 5V gelegt

und soll laut microcontroller.net auch funktionieren da dort schon ein probeprogramm zu bekommen ist welches diese pinbelegung benutzt

desweiteren habe ich nun im hope rf datenblatt des rfm12 die initregister gefunden und um die soll es in meiner frage gehen:

also:
kann mir einer erklären welche einstellungen ich wie vornehmen muss damit ich zwischen meinen beiden Pollin evaluation boards mit ATmega16 und rfm12 hin und her senden kann?

sprich Frequenz, FIFO einstellungen und all das was man so in den registern einstellen kann bzw muss
da ich ehrlich gesagt von den initialisierungsregistern fast erschlagen werde, so viele einstellungsmöglichkeiten sind dort.

desweiteren habe ich erfahren das es in bascom eine funktion gibt die automatisch seriel eine mehrere bytes lange hexzahl über den SDI schickt und die eingabe sogar passend taktet
kann mir dazu einer eine alternative in C geben oder sagen was alles gemacht werden muss damit ich sachen an den rfm12 schicken kann
sprich wie soll ich SCK(Clock) und SS (nSEL) benutzen.
und muss ich dann bei jedem takt vom SCK ein bit einzelnd an den rfm12 schicken oder kann ich direkt das word auf einmal schicken?

für nähere erläuterungen und hilfen bin ich sehr dankbar, also dann gruß Grandalf

Liste der Anhänge anzeigen (Anzahl: 1)

Hallo Grandalf,

ich habe mal irgendwo im Internet diese Datei gefunden (waren eigentlich mehere, hab sie aber zusammengefügt und noch ein bisschen bearbeitet):
RFM12.h
Die def.h Datei braucht man, wenn der Compiller die Makros sbi und cbi nicht kennt (zb. AVR-GCC). Sie werden in dieser Datei definiert.

Code:

#include <avr/io.h> #ifdef _C_ #define true 1 #define false 0 #endif #ifndef cbi #define cbi(sfr, bit) sfr &= ~(1 << bit) #endif #ifndef sbi #define sbi(sfr, bit) sfr |= (1 << bit) #endif #ifndef bit_is_set #define bit_is_set(sfr, bit) sfr & (1 << bit) #endif #ifndef bit_is_clear #define bit_is_clear(sfr, bit) !(sfr & (1 << bit)) #endif #ifndef loop_until_bit_is_set #define loop_until_bit_is_set(sfr, bit) while(sfr & (1 << bit)) #endif #ifndef loop_until_bit_is_clear #define loop_until_bit_is_clear(sfr, bit) while(!(sfr & (1 << bit))) #endif #ifndef BV #define BV(bit) (1 << bit) #endif

Um das Modul nun zu initialisieren muss man folgende Funktionen aufrufen:

Code:

rf12_init(); // ein paar Register setzen (z.B. CLK auf 10MHz) rf12_setfreq(RF12FREQ(433.92)); // Sende/Empfangsfrequenz auf 433,92MHz einstellen rf12_setbandwidth(4, 1, 4); // 200kHz Bandbreite, -6dB Verstärkung, DRSSI threshold: -79dBm rf12_setbaud(19200); // 19200 baud rf12_setpower(0, 6); // 1mW Ausgangangsleistung, 120kHz Frequenzshift

(Vielleicht vor und nach den Funktionen noch ein paar ms warten.)

Es stehen insgesamt folgende Funktionen zur Verfügung:

Code:

extern unsigned short rf12_trans(unsigned short wert); // transfer 1 word to/from module extern void rf12_init(void); // initialize module extern void rf12_setfreq(unsigned short freq); // set center frequency extern void rf12_setbaud(unsigned short baud); // set baudrate extern void rf12_setpower(unsigned char power, unsigned char mod); // set transmission settings extern void rf12_setbandwidth(unsigned char bandwidth, unsigned char gain, unsigned char drssi); // set receiver settings extern void rf12_txdata(unsigned char *data, unsigned char number); // transmit number of bytes from array extern void rf12_rxdata(unsigned char *data, unsigned char number); // receive number of bytes into array extern void rf12_ready(void); // wait until FIFO ready (to transmit/read data)

mfg _R2D2

Hi, hört sich vielversprechend an!!

ich kanns zwar nur überfliegen weil ich grad keine Zeit habe (habs erst grad gesehen dass neuer Beitrag war, war Urlaub)

Mich interessiert grade noch, ob denn überhaupt eine Antenne benötigt wird^^

also wahrscheinlich ist sie doch nur nötig, um die Reichweite zu erhöhen, kurze Strecken dürften doch auch so gehen, oder?

Für meine Joystick-Funksteuerung von meinem Projekt würde ich dann aber wenn eine richtige Antenne ranschrauben wollen, vom Aussehen her also ungefähr wie so eine WLan Antenne

Kann mir jemand sagen, wo ich sowas kriege?

Ich hoffe die sind nicht zu teuer :)

MfG Pr0gm4n

hi

also mehr als du in deinem post einstellst muss man nicht einstellen oder wie?
ok dann muss ich jetzt nur noch die übertragungsfunktion haben!

kannst du mir etwas genauer beschreiben wofür sbi und cbi gut sind?
kenn das nämlich noch nicht!

gruß Grandalf

@Grandalf
sbi und cbi sind Assembler Befehle.
sbi = Set Bit in IO
cbi = Clear Bit in IO
Die Befehle dienen zum direkten Setzen, bzw. Löschen von einzelnen Bits in Port Registern.
Siehe auch das Datenblatt des gewünschten Controllers ziemlich weit hinten.

ok also wenn ich das nun richtig deute muss ich nun einen takt erzeugen und dann die initialisierungs bytes (2bytes pro einstellung) per sbi und cbi bit für bit in den MOSI eingeben (pro takt 1bit) um mein rfm12 zu konfigurieren

hört isch aber ziemlich kompliziert an oder?
ich mein woher weiß ich wie schnell der takt sein muss und woher weiß ich das ich nicht einen takt ausversehen üerspringe
oder funktioniert da ganze über den CLK

um ehrlich zu sein bin ich gerad verwirrt

Zitat:

funktioniert da ganze über den CLK

So ist es.
Du aktivierst den Enable Eingang des RFM ( der heisst meines Wissens nSEL ) . Dann legst Du das erste Bit deines zu Übertragenden Bytes an den Din Eingang deines RFM. Nun Setzt due den Takt Eingang deines RFM auf High und gleich wieder auf Low ( pass auf, der Compiler könnte diese Befehlsfolge wegoptimieren ! ) .
Jetzt das 2te Bit des Bytes anlegen und wieder einen CLK Impuls erzeugen.
Das Spielchen geht so lange weiter bist alle Bits in das RFM eingeschoben wurden. Danach wird die nSEL Leitung wieder deaktiviert und fertig ist der Lack. Das Ganze funktioniert wie ein Schieberegister mit seriellem Eingang.
Daten anlegen - Schiebetakt anlegen - Daten + 1 anlegen - Schiebetakt anlegen ...
Ich meine das ist eigentlich nicht sonderlich schwer zu verstehen.
Sollte der Schiebetakt zu schnell sein ( Datenblatt des RFM ) kann man noch ein paar "NOP" Befehle zwischen dem Setzen und löschen des CLK Pins einfügen.

Eine Besonderheit gibt es noch, wenn man Daten für die Funkstrecke über Din einspeist. Dabei muss man auf das Timing achten ( Timer oder Interrupt des RFM verwenden ) und es dürfen keine ! CLK Impulse generiert werden. Dieser Modus ist nicht SPI kompatibel, deshalb halte ich es auch für sinnvoller eine Software SPI zu verwenden, auch wenn das ein wenig Rechenleistung kostet.

ok dann hab ichs verstanden, denke ich

nur dein letzter absatz war nicht sehr verständlich, aber naja ich meld mich wenn sich was neues ergibt

hallo nochmal habe jetzt mal einen kleinen code geschrieben
aber wie ich schon dachte funktioniert er nicht

vllt schau sich das ja mal jemand von euch an

also hier meine rfm12.c

Code:

#ifndef F_CPU #define F_CPU 4000000L //Controllerfrequenz für die util/delay.h #endif #include <avr/io.h> #include <avr/iom16.h> #include <util/delay.h> #include <inttypes.h> #include <math.h> #include "RFM12.h" #define SCK PB7 #define MOSI PB5 #define SS PB4 #ifndef SPI #define SPI PINB #endif #ifndef MISO #define MISO PINB6 #endif #define DCLK PIND3 #define nIRQ PIND2 void senden_mit_rfm12(int wert) { int werte_array[16]; int pruefung=wert; int i=0; for(i = 0; i<=15; i=i+1) { pruefung=pruefung - pow(2,i); if (pruefung >=0) { werte_array[i]=1; } else { pruefung=pruefung + pow(2,i); werte_array[i]=0; } } while(!(PIND & (1<<nIRQ))) { } int j=0; for(j = 0; j<=15; j=j+1) { if(werte_array[j] == 1); { PORTB |= (1<<MOSI); } if(werte_array[j] == 0); { PORTB &= ~(1<<MOSI); } PORTB |= (1<<SCK); _delay_ms(1); PORTB &= ~(1<<SCK); } } void register_setzen_an_rfm12(int wert) { PORTB |= (1<<SS); senden_mit_rfm12(wert); PORTB &= ~(1<<SS); } void init_rfm12(void) { DDRB |= (1<<SCK)|(1<<MOSI)|(1<<SS); PORTB = 0; register_setzen_an_rfm12(0x80D7); //433Mhz register_setzen_an_rfm12(0x82B9); //enable transmitter enable synthesizer enable crystal oszilator disable CLK-PIN register_setzen_an_rfm12(0xA4B0); //433Mhz register_setzen_an_rfm12(0xC6BD); //9600Baud }

und hier der interrupt in meiner main.c

Code:

#define SPI PINB #define MISO PINB6 int abfangarray[16]; int empf_wert; int x = 0; ISR(INT0_vect) { abfangarray[x] = (SPI & (1<<MISO)); if(x<15) x=x+1; else { x=0; int y; empf_wert=0; for(y=0;y<=15;y=y+1) { if(abfangarray[y]==1) { empf_wert = empf_wert + pow(2,y); } } } }

ich denke mal der Haken liegt an der art und weise wie ich die daten an den rfm12 übergeben nur hab ich verstanden das es so sein soll

da ich kein assembler beherrsche bzw benutze hab ich die genannte sbi und cbi methode durch einfache ausgangsbeschaltung ersetzt
das dürfte aber doch auch funktionieren oder?

bei meinem interrupt bin ich mir gerad garnich sicher wie das signal vom MISO ausgelesen wird
sprich woher weiß der controller (außer er zählt wie in meinem fall mit) das wenn ein bit kommt das es das erste ist und nicht irgendeins mitten drin
und kommt beim empfangen auch das 2byte große signal an oder nur ein byte im ASCII-format?

bedanke mich schonmal für jede antwort oder verbesserung meines codes

grüße

@Grandalf

Ich hab deinen Code nach Codevision umgestrickt und durch den Simulator von AVR Studio gejagt.

Erstmal wurden da eine ganze Menge Compilerfehler gemeldet.

Zum Beispiel der Ausdruck
pruefung=pruefung - pow(2,i);

Kann der stimmen oder gehören da nicht eckige Klammern hin ?
also
pruefung=pruefung - pow[2,i];

Zum zweiten wurde nach dem rausmachen dieser Fehler nur der Port B.0 aktiv. Alle Aktionen gingen nur auf diesen Port.

Über diesen Ausdruck:

Code:

while(!(PIND & (1<<nIRQ))) { }

lief der Simulator auch nach änderung des DDR und des Pind nicht drüber.

Teste doch mal dein Programm mit AVR - Studio 4 aus, dann wird es auch in der realen Welt wahrscheinlicher das es funktionieren wird.

hi wkrug

ich benutze AVR-Studio 4 und ich habe insgesamt nur ein warning und das bezieht sich auf eine funktion in der delay.h (die warnung erscheint aber bei all meinen programmen und ist zu vernachlässigen)

bei pow gehören laut c-buch normale klammern hin pow()

der PIND2 ist gleichzeitig der pin für den externen interrupt (von dem ich 2 stück habe PinD 2 und PinD3 und beide sind belegt einmal mit NIRQ und einmal mit DCLK)

ich habe in meinem gesamtprogramm auch noch andere funktionen drin (LCDansteuerung und rs232 übertragung) und ohne das neue rfm12.c funktionieren die auch ich kann ja mal alles hier reinstellen. im grunde will ich am ende per hyperterminal einen buchstaben eingeben und den dann von einem evalutations board zu anderen schicken und auf dem 2ten board in der lcd anzeige ausgeben.

also :)

die main.c

Code:

#ifndef F_CPU #define F_CPU 4000000L #endif #define SPI PINB #define MISO PINB6 #include <avr/io.h> #include <avr/iom16.h> #include <util/delay.h> #include <avr/interrupt.h> #include <inttypes.h> #include <math.h> #include "LCD-8bit.h" #include "RS232.h" #include "RFM12.h" //Eigenschaften festelgen; volatile char rs232_empf_zeichen; volatile int rs232_empf_gesetzt = 0; volatile char rs232_send_zeichen; volatile int rs232_send_gesetzt = 0; volatile char rfm12_empf_zeichen; volatile int rfm12_empf_gesetzt = 0; volatile char rfm12_send_zeichen; volatile int rfm12_send_gesetzt = 0; volatile char lcd8bit_zeichen; volatile int abfangarray[16]; volatile int x = 0; ISR(INT0_vect) { PORTC |= (1<<PC1); abfangarray[x] = (SPI & (1<<MISO)); if(x<15) x=x+1; else { x=0; int y; rfm12_empf_zeichen=0; for(y=0;y<=15;y=y+1) { if(abfangarray[y]==1) { rfm12_empf_zeichen = rfm12_empf_zeichen + pow(2,y); } } rfm12_empf_gesetzt = 1; } } ISR(USART_RXC_vect) { while(!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar { } PORTC |= (1<<PC0); rs232_empf_zeichen = UDR; // Zeichen aus UDR lesen rs232_empf_gesetzt = 1; } int main(void) { DDRC |= (1<<PC0)|(1<<PC1); sei(); init_8bitlcd(); init_uart(); init_rfm12(); while(1) { if(rs232_empf_gesetzt == 1) { daten_schreiben(rs232_empf_zeichen); rs232_empf_gesetzt = 0; rfm12_send_gesetzt = 1; } else { PORTC &= ~(1<<PC0); } if(rfm12_empf_gesetzt == 1) { daten_schreiben(rfm12_empf_zeichen); rfm12_empf_gesetzt = 0; rs232_send_gesetzt = 1; } else { PORTC &= ~(1<<PC1); } if(rs232_send_gesetzt == 1) { rs232_send_zeichen = rfm12_empf_zeichen; senden_mit_rs232(rs232_send_zeichen); senden_mit_rs232('5'-40); senden_mit_rs232(rs232_send_zeichen); rs232_send_gesetzt = 0; } if(rfm12_send_gesetzt == 1) { PORTC |= (1<<PC2); rfm12_send_zeichen = rs232_empf_zeichen; senden_mit_rfm12(rfm12_send_zeichen); senden_mit_rfm12('5'-40); senden_mit_rfm12(rfm12_send_zeichen+40); rfm12_send_gesetzt = 0; PORTC &= ~(1<<PC2); } } return 0; }

dann die rfm12.c

Code:

#ifndef F_CPU #define F_CPU 4000000L //Controllerfrequenz für die util/delay.h #endif #include <avr/io.h> #include <avr/iom16.h> #include <util/delay.h> #include <inttypes.h> #include <math.h> #include "RFM12.h" #define SCK PB7 #define MOSI PB5 #define SS PB4 #ifndef SPI #define SPI PINB #endif #ifndef MISO #define MISO PINB6 #endif #define DCLK PIND3 #define nIRQ PIND2 void senden_mit_rfm12(int wert) { int werte_array[16]; int pruefung = wert; int i = 0; for(i = 0; i<=15; i=i+1) { pruefung=pruefung - pow(2,i); if (pruefung >=0) { werte_array[i]=1; } else { pruefung=pruefung + pow(2,i); werte_array[i]=0; } } while(!(PIND & (1<<nIRQ))) { } int j = 0; for(j = 0; j<=15; j=j+1) { if(werte_array[j] == 1); { PORTB |= (1<<MOSI); } if(werte_array[j] == 0); { PORTB &= ~(1<<MOSI); } PORTB |= (1<<SCK); _delay_ms(1); PORTB &= ~(1<<SCK); } } void register_setzen_an_rfm12(int wert) { PORTB |= (1<<SS); senden_mit_rfm12(wert); PORTB &= ~(1<<SS); } void init_rfm12(void) { DDRB |= (1<<SCK)|(1<<MOSI)|(1<<SS); PORTB = 0; register_setzen_an_rfm12(0x80D7); //433Mhz register_setzen_an_rfm12(0x82B9); //enable transmitter enable synthesizer enable crystal oszilator disable CLK-PIN register_setzen_an_rfm12(0xA4B0); //433Mhz register_setzen_an_rfm12(0xC6BD); //9600Baud }

nun die lcd-8bit.c

Code:

#ifndef F_CPU #define F_CPU 4000000L //Controllerfrequenz für die util/delay.h #endif //------------------------------------//------------------------------------ //Ausgänge festlegen: #define datenposition DDRA #define datenwerte PORTA #define D0 PA0 #define D1 PA1 #define D2 PA2 #define D3 PA3 #define D4 PA4 #define D5 PA5 #define D6 PA6 #define D7 PA7 #define steuerungsposition DDRB #define steuerwerte PORTB #define E PB0 #define R_W PB1 #define RS PB2 //------------------------------------ #include <avr/io.h> #include <avr/iom16.h> #include <util/delay.h> #include <inttypes.h> #include "LCD-8bit.h" volatile int zaehler = 0; //------------------------------------ int _D = 1; //Display an(1)/aus(0) int _C = 0; //Cursor an(1)/aus(0) int _B = 0; //Cursor blinken an(1)/aus(0) int _N = 1; //zweizeiliges(1)/einzeiliges(0) Display int _F = 0; //5x10-Font(1)/5x7-Font(0) int _BF = 0; //ist beschäftigt(1)/Kann Kommandos annehmen(0) int LCD_stellen = 16; //anzahl der möglichen Zeichen pro zeile //------------------------------------ void enable(void) { steuerwerte |= (1<<E); _delay_ms(1);// kurze pause steuerwerte &= ~(1<<E); _delay_ms(1);// kurze pause } void init_8bitlcd(void) { datenposition = 0xFF; datenwerte = 0x00; steuerungsposition = (1<<E)|(1<<R_W)|(1<<RS); steuerwerte = 0x00; _delay_ms(16); funktionen(1,0,0); _delay_ms(5); funktionen(1,0,0); _delay_ms(1); funktionen(1,0,0); modus(1,0); display_und_cursor_optionen(1,0,0); bild_loeschen(); cursor_auf_startpos(); } void bild_loeschen(void) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0; datenwerte |= (1<<D0); enable(); } void cursor_auf_startpos(void) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D1); enable(); zaehler = 0; } // I_D => Curserposition Inkrement(1)/dekrement(0) (schreibrichtung festlegen) // S => Displayinhalt fest(1)/weiterschieben(0) void modus(int I_D, int S) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D2); if(I_D==1) datenwerte |= (1<<D1); if(S==1) datenwerte |= (1<<D0); enable(); } // D => Display an(1)/aus(0) // C => Cursor an(1)/aus(0) // B => Cursor blinken an(1)/aus(0) void display_und_cursor_optionen(int D, int C, int B) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D3); if(D==1) datenwerte |= (1<<D2); if(C==1) datenwerte |= (1<<D1); if(B==1) datenwerte |= (1<<D0); enable(); } // S_C => Displayinhalt schieben(1)/Cursor bewegen(0) // R_L => S_C nach rechts(1)/nach links(0) schieben void cursor_oder_display_schieben(int S_C, int R_L) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D4); if(S_C==1) datenwerte |= (1<<D3); if(R_L==1) datenwerte |= (1<<D2); enable(); } // DL => 8bit-Interface(1)/4bit-Interface(0) // N => zweizeilig(1)/einzeilig(0) // F => 5x10-Font(1)/5x7-Font(0) void funktionen(int DL, int N, int F) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D5); if(DL==1) datenwerte |= (1<<D4); if(N==1) datenwerte |= (1<<D3); if(F==1) datenwerte |= (1<<D2); enable(); } //adresse => CGRAM-Adresse (6stellig) void CGRAM(int adresse) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D6); enable(); } //adresse => DDRAM-Adresse (7stellig) void DDRAM(int adresse) { steuerwerte &= ~((1<<RS)|(1<<R_W)); datenwerte = 0x00; datenwerte |= (1<<D7); enable(); } //adresse => CG-/DDRAM-Adresse (7stellig) //BF => ist beschäftigt(1)/Kann Kommandos annehmen(0) void adresse_oder_status_lesen(int adresse, int BF) { steuerwerte |= (1<<R_W); steuerwerte &= ~(1<<RS); datenwerte = 0x00; datenwerte = adresse; if(BF==1) datenwerte |= (1<<D7); enable(); } //zeichen => Dezimalzahl des zu schreibenden Zeichens nach ASCII-Tabelle void daten_schreiben(int zeichen) { if(zaehler<=(LCD_stellen - 1)) zaehler = zaehler + 1; if(zaehler==LCD_stellen) cursor_oder_display_schieben(1,0); steuerwerte |= (1<<RS); steuerwerte &= ~(1<<R_W); datenwerte = 0x00; datenwerte = zeichen; enable(); } // *text => Zeiger auf ein char array mit den anzugeigenden Zeichen (länge egal) // LCD_stellen => hier angeben wie viele Zweichen pro zeile auf dem Display angezeigt werden können void text_schreiben(char *text) { while(*text) { daten_schreiben(*text); text++; } }

und als letztes die rs232.c

Code:

#ifndef F_CPU #define F_CPU 4000000L //Controllerfrequenz für die util/delay.h #endif #ifndef Baudrate #define Baudrate 9600L #endif #include <avr/io.h> #include <avr/iom16.h> #include <util/delay.h> #include <inttypes.h> #include "RS232.h" void senden_mit_rs232(char x) { while (!(UCSRA & (1<<UDRE))) // warten bis Senden moeglich { } UDR = x; // schreibt das Zeichen x auf die Schnittstelle } void init_uart(void) { UCSRB =0; // Definition zum senden + Interupt wenn gesendet wurde + interupt wenn sendeplatz wieder frei UCSRB |= (1<<TXEN); UCSRC |= (1<<URSEL)|(3<<UCSZ0); //Asynchron 8N1 // Definition zum empfangen + Interupt wenn signal empfangen wird UCSRB |= (1<<RXEN)|(1<<RXCIE); //Definition für 9bit übertragung mit paritätsbit (optional) //UCSRB |= (1<<CHR9) //UCSRB|=(1<<RXB8) stellt das 9. empfangsbit dar //UCSRB|=(1<<TXB8) stellt das 9. sendebit dar //Definierung der Übertragungsgeschwindigkeit int UBRR_VAL = (F_CPU/(Baudrate*16))-1; UBRRH = UBRR_VAL >> 8; UBRRL = UBRR_VAL & 0xFF; }

die dazugehörigen .h dateien müssten noch ebend nacherzeugt werden
da ich ja leider von einem interrupt schlecht ein return zurück bekommen kann stehen diese in der main statt ihrer passenden unterdatei und beziehen sich auf globale variablen.

der fehler liegt sicherlich bei meiner rfm12.c nur weiß ich nicht wo.
wenn ich den code auf meinen controller überspiele und teste kann ich beim hyperterminal eingeben was ich will es passier NIX außer das die rs232 übertragungs LED leuchtet.

Gut, wenns bei Dir so funktioniert solls mir recht sein.

pow(2,i) ist demnach ein Funktionsaufruf und keine indizierte Variable.

Ich hab bei meinem Programm auch immer nur 8 Bit an das RFM02 übertragen, weil mir das einfacher erschien.
Die Steuerung des CS ( SS? ) hab ich vor dem Aufruf der Software SPI gemacht.

Wenn Du schon mit Studio arbeitest, was macht dein Programm wenn Du im Einzelschritt modus die RFM Routinen durchlaufen lässt.

Werden tatsächlich alle Steuerleitungen so wie im Datenblatt des RFM12 beschrieben angesteuert? Dann müsste es auch gehen.

Ich denk mal, das Du AVR-GCC benutz und den Code kann ich hier nicht austesten.

ja als compiler benutze ich den AVR-GCC

und pow() ist die potenzierungsfunktion aus der math.h

was ich nur wissen wollte, ist denn die art und weise wie ich die daten in den rfm12 einspeise richtig? und wie sieht das beim auslesen aus?

Debugging kann ich leider nicht machen (die standart AVR-Studio compiler funktionieren nicht, auch ein grund warum ich den GCC benutze)

zum testesn meines codes spiele ich ihn immer auf den controller und schaue mir sein verhalten an

naja und es leuchtet dauerhaft die LED für den rfm12 (PORTC PC2)
und ansonsten nichts (keine lcd anzeige oder ander LED die leuchtet)

ok ich hab gerad nen bischen rumgetestet mit dem programm und kann nur sagen es verhält sich sehr seltsam :)

also ich habe beide pollin boards identisch aufgebaut (brücken setzen auf dem addon board) habe auf beide das programm was ich oben gepostet habe aufgespielt

sprich sie müssten absolut gleich sein

naja sie verhalten sich aber unterschiedlich ](*,)

am anfang (nachem resetknopf drücken) verhalten sich beide gleich und bis auf die LED an PC2 leuchtet nix
bei platine 1 leuchtet sie aber nur halb so stark wie bei der 2ten

so nun gebe ich per hyperterminal einige buchstaben etc an die erste platine: die LED PC2 geht aus und die LED an PC0 geht an und so bleibt es dann auch solange ich nicht den reset knopf drücke egal was ich nun mache
platine 2 lässt das völlig kalt^^

so nun wenn ich per hyperterminal buchstaben an platine 2 übergebe:
auch hier fängt die LED an PC0 an zu leuchten aber die LED an PC2 geht nur halb aus :)
dazu kommt dass wenn die platine 1 auf reset steht (sprich PC2 dort halb leuchtet) und ich an platine 2 werte eingebe oder an platine 2 taster drücke oder resette dann flackert die LED an PC2 einmal kurz bei jedem signal

ok beide platinen haben eine stromquelle was das flackern erklären könnte da es nur bei den LED's vor kommt die halbhell leuchten.

ich weiß es hört sich nach jede menge zu tun an aber vllt is hie ja noch wer der lust hat sich das mal anzusehen und mir zu helfen
grüße

Zitat:

die standart AVR-Studio compiler funktionieren nicht, auch ein grund warum ich den GCC benutze

Also Code Vision erzeugt ein .cof File.
Wenn ich dieses File in AVR Studio einlade und die Taktfrequenz, sowie den Controllertyp einstelle, kann ich den Code Schritt für Schritt im Studio abarbeiten lassen.

Compilieren kann ich den CodeVision Code mit AVR Studio natürlich auch nicht. Das muß ich machen bevor ich das Studio aufrufe.

Soweit ich weiß, haben aber die neueren Studio Versionen eine Anbindung an AVR GCC.

Also mein Sendeablauf für das RFM02 schaut so aus.

nSEL auf L
Das MSB des zu sendenden Wortes auf SDI anlegen.
CLK setzen und wieder löschen.
Das nächste Bit auf SDI anlegen
CLK setzen und wieder löschen
usw...
bis alle Bits Übertragen wurden.
Anschließend nSEL wieder auf H

Das nächste Konfigurationswort vorbereiten
nSEL auf L
...
das Spielchen beginnt von vorne.

Welche Leitungen beim RFM 12 dafür benutzt werden kann ich nicht sagen.

das funktioniert bei rfm01 02 und 12 immer gleich

der 01er und 02er sind sozusagen teilstücke vom 12er

und der nSEL is bei meinem Controller am Pin namens SS und ich mach das so wie du auch

die ob die init bei mir aber angenommen wird oder nicht weiß ich nicht

hmm naja ok montag gehts dann für mich weiter ich hab nun wochenende
grüße

Die Init von meinem RFM 02 schaut so aus:

Code:

volatile unsigned char uc_frequ[2]; /* Frequenz tuningword */ uc_frequ[1]=ui_frequ[uc_kanal]/256; uc_frequ[1]|=0b10100000; uc_frequ[0]=ui_frequ[uc_kanal]%256; /* Configuration Setting: 433MHz, CLK 5MHz, 11,5pf Kapaz., +/-60kHz */ #asm ("cbi portb,nsel"); sendbyte(0b10001110); sendbyte(0b01100000); #asm ("sbi portb,nsel"); #asm ("nop"); /* Frequency Setting: eingestellter Kanal*/ #asm ("cbi portb,nsel"); sendbyte(uc_frequ[1]); sendbyte(uc_frequ[0]); #asm ("sbi portb,nsel"); #asm ("nop"); /* Output Power Command: Max Power */ #asm ("cbi portb,nsel"); sendbyte(0b10110000); #asm ("sbi portb,nsel"); #asm ("nop"); /* Data Rate Command: 2400 bit/s */ #asm ("cbi portb,nsel"); sendbyte(0b11001000); sendbyte(0b10001111); #asm ("sbi portb,nsel"); #asm ("nop"); /* Low Batt + Sync Command: enable Sync Circuit */ #asm ("cbi portb,nsel"); sendbyte(0b11000010); sendbyte(0b00100000); #asm ("sbi portb,nsel"); #asm ("nop"); /* PLL Setting Command: 0xD240 up to 19,2kbit/s*/ #asm ("cbi portb,nsel"); sendbyte(0b11010010); sendbyte(0b01000000); #asm ("sbi portb,nsel"); #asm ("nop"); /* Power Managment Command= Enable Clock; disable Synthesizer; disable pow. Ampl. */ #asm ("cbi portb,nsel"); sendbyte(0b11000000); sendbyte(0b00100000); #asm ("sbi portb,nsel");

Das Frequenz Setting Word wird bei mir von einer Tabelle und DIP FIX Schaltern gesteuert.
Hier die Tabelle:

Code:

flash unsigned int ui_frequ[32]={1240,1270,1300,1330,1360,1390,1420,1450,1480,1510,1540,1570,1600,1630,1660,1690,1720,1750,1780,1810,1840,1870,1900,1900,1900,1900,1900,1900,1900,1900,1900,1900};

Vieleicht hilft Dir das ja weiter.

wkrug

ja in gewisser weise hilft das weiter nur was steht bei dir in der #asm() und in der sendbyte() funktion drin?

und sbi sowie cbi hab ich nicht zur verfügung. (wobei ich immernoch der meinung bin das ein einfaches ausgang zuweisen den gleichen effekt hat, oder?)

gruß

Mit
#define cbi(sfr, bit) sfr &= ~(1 << bit)
und
#define sbi(sfr, bit) sfr |= (1 << bit)
kann man sbi() und cbi() einfach als Makro definieren und wie eine Funktion aufrufen. Wenn man dann zB. sbi(PORTC, 2) schreibt, wird das durch PORTC |= (1 << 2) ersetzt.

ja lol. ok also kann ich das auch gleich so lassen wie ich des hab statt sbi und cbi halt PORTx |= (1<<Pxy) für an
bzw PORTx &= ~(1<<Pxy) für aus

und genau das tu ich ja auch alles so wies soll, oder? (siehe quellcode oben)
aber es funktioniert ja nicht.

achja ich habe gestern gelesesn das solange der nSEL an is (also der SS am Controller) das solange das modul auf stop schaltet weil es sozusagen der befehl für den conntroller is "so jetzt wirst du programmiert!" kann das eins meiner fehler sein (denke mal da sind noch mehr weil irgendwie tut sich garnix hier)

gruß

Wenn man einen Befehl an das Mudul senden will, muss man es erst aktivieren, in dem man nSEL auf low setzt (also Port am µC löschen).

also erst LOW
dann wieder HIGH
dann die 2 byte durch jagen
und dann den nSEL wie LOW

oder

LOW
dann die 2 bytes durchjagen
dann wieder HIGH

weil irgendwie is mein nSEL durchgehend high sprich variante 2 würde sinn machen