mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Atmega 8 Funk Eva Board RFM12


Autor: Sonke A. (soeni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo, nachdem ich leider daran gescheitert bin ein RFM12 Modul mit 
meiner Schaltung und einem Atmega128 in Betrieb zu nehmen, hab ich nun 
versucht mit dem Pollin Avr Funk Eval Board das Teil anzusprechen. 
Hierzu hab ich wie im Forum beschrieben einen Widerstand(10k) gegen vcc 
an den Pin nFFS ergänzt. in der Software die Pins eingetragen (Software 
ist von hier: Beitrag "Beispielprogramm für RFM12 433MHz Funk-Module") nun sollte 
doch zumindest der Status auszulesen sein, aber weit gefehlt, es klappt 
immer noch nicht. das ist einfach zum kotzen arrrrrrrgggggg.....

Aber ihr könnt nix dafür, dass ich dazu anscheinen zu doof bin.

Meine letzte Hoffnung: der tackt wird ja am Modul auf 10 Mhz gesetzt. 
der Atmega auf dem board läuft aber mit 12 Mhz, kann es da Probleme 
geben?

Ansonsten kennt ihr oder habt ihr vielleicht ein programm, welches 
einfach den Status des Moduls ausliest und ihn per UART rausschickt?

Oder habt ihr vielleicht eine Lösung?
//################ Datei TR-funk.c, Version 1.0, Datum 30.08.08 #################
/*

  Autor: Sönke Paschko

  Beschreibung:

       In dieser Datei werden die Hauptfunktionen für die Funkverbindung definiert.


*/
//##################################################################################


//###################                 Includes                   ###################
 
    #include "head.h"      // generelle Headdatei mit Definitionen  

//###################                 Funktionen                 ###################



//###################                 Variablen                  ###################







unsigned short rf12_trans(unsigned short wert)
{  unsigned short werti=0;
  unsigned char i;

  cbi(CS_RF_PORT, CS);
  for (i=0; i<16; i++)
  {  if (wert&32768)
      sbi(RF_PORT, SDI);
    else
      cbi(RF_PORT, SDI);
    werti<<=1;
    if (RF_PIN&(1<<SDO))
      werti|=1;
    sbi(RF_PORT, SCK);
    wert<<=1;
    _delay_us(0.3);
    cbi(RF_PORT, SCK);
  }
  sbi(CS_RF_PORT, CS);
  return werti;
}

void rf12_init(void)
{
  RF_DDR=(1<<SDI)|(1<<SCK);
  CS_RF_DDR=(1<<CS);
  CS_RF_PORT=(1<<CS);


    _delay_ms(100);      // wait until POR done
  
  //Ergänzung zum Debuggen

  rf12_trans(0x0000);      // Status auslesen
  char str[10];
  itoa(rf12_trans(0x0000), str, 2); // Binär anzeigen
  uart_puts("Status vor init:  0b");      // Ausgabe auf UART
  uart_puts(str);
  uart_puts("\r\n");
  // Ende ergänzung

  rf12_trans(0xC0E0);      // AVR CLK: 10MHz
  rf12_trans(0x80D7);      // Enable FIFO
  rf12_trans(0xC2AB);      // Data Filter: internal
  rf12_trans(0xCA81);      // Set FIFO mode
  rf12_trans(0xE000);      // disable wakeuptimer
  rf12_trans(0xC800);      // disable low duty cycle
  rf12_trans(0xC4F7);      // AFC settings: autotuning: -10kHz...+7,5kHz
  
  // Ursprünglich in Int main()
  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
  
  // Ergänzung zum debuggen
  rf12_trans(0x0000);      // Status auslesen
  itoa(rf12_trans(0x0000), str, 2); // Binär anzeigen
  uart_puts("Status nach init: 0b");      // Ausgabe auf UART
  uart_puts(str);
  uart_puts("\r\n");
  //Ende Ergänzung
}

void rf12_setbandwidth(unsigned char bandwidth, unsigned char gain, unsigned char drssi)
{
  rf12_trans(0x9400|((bandwidth&7)<<5)|((gain&3)<<3)|(drssi&7));
}

void rf12_setfreq(unsigned short freq)
{  if (freq<96)        // 430,2400MHz
    freq=96;
  else if (freq>3903)      // 439,7575MHz
    freq=3903;
  rf12_trans(0xA000|freq);
}

void rf12_setbaud(unsigned short baud)
{
  if (baud<663)
    return;
  if (baud<5400)          // Baudrate= 344827,58621/(R+1)/(1+CS*7)
    rf12_trans(0xC680|((43104/baud)-1));
  else
    rf12_trans(0xC600|((344828UL/baud)-1));
}

void rf12_setpower(unsigned char power, unsigned char mod)
{  
  rf12_trans(0x9800|(power&7)|((mod&15)<<4));
}

void rf12_ready(void)
{  cbi(CS_RF_PORT, CS);
  while (!(RF_PIN&(1<<SDO))); // wait until FIFO ready
}

void rf12_txdata(unsigned char *data, unsigned char number)
{  unsigned char i;
  rf12_trans(0x8238);      // TX on
  rf12_ready();
  rf12_trans(0xB8AA);
  rf12_ready();
  rf12_trans(0xB8AA);
  rf12_ready();
  rf12_trans(0xB8AA);
  rf12_ready();
  rf12_trans(0xB82D);
  rf12_ready();
  rf12_trans(0xB8D4);
  for (i=0; i<number; i++)
  {    rf12_ready();
    rf12_trans(0xB800|(*data++));
  }
  rf12_ready();
  rf12_trans(0x8208);      // TX off
}

void rf12_rxdata(unsigned char *data, unsigned char number)
{  unsigned char i;
  rf12_trans(0x82C8);      // RX on
  rf12_trans(0xCA81);      // set FIFO mode
  rf12_trans(0xCA83);      // enable FIFO
  for (i=0; i<number; i++)
  {  rf12_ready();
    *data++=rf12_trans(0xB000);
  }
  rf12_trans(0x8208);      // RX off
}

Die Initfunktion wird aus der Int Main aufgerufen:

[c]
//################## Datei PR-main.c, Version 1.0, Datum 30.08.08 
##################
/*

  Autor: Sönke Paschko

  Beschreibung:

         Diese Datei enthält die Mainfunktion

    Testprogramm für Funkmodul auf Pollinevaluationsboard


*/
//###################################################################### 
############

//###################                 Includes 
###################

   #include "head.h"      // generelle Headdatei mit Definitionen

//###################                 Funktionen 
###################

  int  main();        // Hauptprogramm


//###################                 Variablen 
###################

  char order[20];

  // Hauptprogramm
  int main(void){


  // USART initialisieren
    uart_init();

  // USART Ausgaben
  uart_puts("\x1B[2J \x1B[0;0f");   /* Bildschirm löschen und Cursor auf 
Position 1x1 um vorige
                       Programmausgaben zulöschen */

    // Ausgabe UART
  uart_puts("\a\r\n\r\n\r\n");
  uart_puts(" 
\x1B[41m*****************************\r\n\x1B[47m"); // \x1B[47m setzt 
den Hintergrund auf grau
  uart_puts("            \x1B[41m*** 
***\r\n\x1B[47m");
  uart_puts("            \x1B[41m***  "       PROG      " 
***\r\n\x1B[47m");
  uart_puts("            \x1B[41m*** 
***\r\n\x1B[47m");
  uart_puts(" 
\x1B[41m*****************************\r\n\r\n\x1B[47m");



  // Startbild abwarten (1 Sec)
  _delay_ms(2000);

    uart_puts("\r\nInitialisierung starten:\r\n");

    rf12_init();  // Funkmodul Initialisieren

    uart_puts("\r\nInitialisierung Funk   OK:\r\n");

    int i = 0;
  char str[1233];
  // Endlosschleife
    while(1){

  getorder(order);

    if(!strcmp(order, "funk")){
       //funk_Test();
       uart_puts("\r\nFunktest wird gestartet");
       _delay_ms(1000);
       uart_puts(".");
       _delay_ms(1000);
       uart_puts(".");
       _delay_ms(1000);
       uart_puts(".");
       _delay_ms(1000);
       uart_puts("Fertig\r\n");
    }

    sprintf(str, "%u\r", i);
    uart_puts(str);
    i++;
    _delay_ms(1000);

  }


  }

[\c]

Die gemeinsame Headerdatei:

[c]
//################## Datei main.h, Version 1.0, Datum 24.08.08 
##################
/*

  Autor: Sönke Paschko

  Beschreibung:

       Diese Datei enthält Deklarationen und dateiübergreifende 
Variablen.


  Anmerkung:

     In dieser Datei sind nur allgemein nutzbare Funtionen deklariert. 
Einzelne
     Treiberfunktionen, welche nicht öffentlich genutzt werden finden 
sich nur
     in den Treiberdateien.

*/
//###################################################################### 
############

//###################                 Includes 
###################

  #include <avr/interrupt.h>
  #include <avr/io.h>
  #include <avr/pgmspace.h>
  #include <stdint.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <util/delay.h>     // Für Delayfunktion



//###############  Definitionen 
##############################################

  // Allgemeine Defines

  #define PROG "Funktest RFM12 V0.1"

    // Defines UART
  #define BAUDRATE 1200





  // Funktionen USART
  void   uart_Transmit( unsigned char data );
  void   uart_init(void);
  uint8_t uart_getc(void);
  void   uart_gets( char* Buffer, uint8_t MaxLen );
  void   uart_puts(char *s);
  uint8_t uart_ask();











  // Funktionen Funk


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)

#define RF12FREQ(freq)  ((freq-430.0)/0.0025)              // macro for 
calculating frequency value out of frequency in MHz

#ifndef cbi
#define cbi(sfr, bit)     (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit)     (_SFR_BYTE(sfr) |= _BV(bit))
#endif

#define RF_PORT  PORTB
#define RF_DDR  DDRB
#define RF_PIN  PINB

// Ergänzt, da cs auf seperatem Port liegt.
#define CS_RF_PORT  PORTD
#define CS_RF_DDR  DDRD
#define CS_RF_PIN  PIND

#define SDI    3
#define SCK    5
#define CS    4
#define SDO    4


[\c]


Meine Ergänzungen / Änderungen habe ich durch Kommentare gekennzeichnet.

Danke schonmal für eure Hilfe.

Autor: Andreas (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Der 1. und wichtigste Tip(p)
"Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang"

Autor: Urs (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Meine letzte Hoffnung: der tackt wird ja am Modul auf 10 Mhz gesetzt.
>der Atmega auf dem board läuft aber mit 12 Mhz, kann es da Probleme
> geben?

Nein, der Takt des AVRs kann schneller oder langsamer als der des RF 
Moduls sein.

Hast Du die nötigen Jumper auch gesetzt? Keine Lötbrücken?

> Ansonsten kennt ihr oder habt ihr vielleicht ein programm, welches
> einfach den Status des Moduls ausliest und ihn per UART rausschickt?

Kann ich am WE posten, falls es bis dahin kein anderer tut.

NB: Wenn ich mich richtig erinnere, gehört ein ATMega128 nicht ins 
Pollin-Board, nur Tiny2313, Mega8, Mega16/32.

Autor: Sonke A. (soeni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke erstmal, ja das Pollinboard fasst nur atmega8 usw. kein 128, ich 
nutze auch ein amtmega8, hatte es vorher nur mit einer anderen Platine 
versucht. inzwischen hab ich auch schon die Pinbelegung gecheckt, da 
gabs einen fehler in der Doku des Pollinboardes, CS liegt auf PortB 
nicht auf PortD, das hab ich entsprechend korigiert. Hardwaretechnische 
Sachen kann ich also ausschließen.

Sind solche Module ansich robust oder eher nicht? Ich meine vonwegen 
ESD, eventuellen Leckströmen usw.

Autor: Sonke A. (soeni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
lese ich denn mit folgenden Befehlen den Status richtig aus?
  rf12_trans(0x0000);      // Status auslesen
  char str[10];
  itoa(rf12_trans(0x0000), str, 2); // Binär anzeigen
  uart_puts("Status vor init:  0b");      // Ausgabe auf UART
  uart_puts(str);
  uart_puts("\r\n");
  // Ende Ergänzung

Irgendwo hab ich gelesen, dass wenn man 0x0000 sendet als erstes der 
Status kommt und dann der Inhalt des FIFOs

Autor: Sonke A. (soeni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
kann mir nochmal jemand helfen bitte?

Autor: Jean Player (fubu1000)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sönke Paschko wrote:
> lese ich denn mit folgenden Befehlen den Status richtig aus?
>
>
>   rf12_trans(0x0000);      // Status auslesen
>   char str[10];
>   itoa(rf12_trans(0x0000), str, 2); // Binär anzeigen
>   uart_puts("Status vor init:  0b");      // Ausgabe auf UART
>   uart_puts(str);
>   uart_puts("\r\n");
>   // Ende Ergänzung
> 
>
> Irgendwo hab ich gelesen, dass wenn man 0x0000 sendet als erstes der
> Status kommt und dann der Inhalt des FIFOs


Datenblatt lesen könnte mal nit schaden. Ja mit 0x0000 liest du die 
Statusbits aus (kannst auch 0x0101 senden ist wurscht, Hauptsache Bit 15 
ist NULL). Das Statusbit RGIT sollte gesetzt sein, wenn du als TX in 
FIFO Mode initialisierst und ich glaube Bit FFEM, wenn als RX in FIFO 
Mode.

//Nach deinen Funktionen, soweit ich das beim überfliegen gesehen habe:
unsigned int status = rf12_trans(0x0000);
unsigned char UartData = (unsigned char) status >> 8;
uart_Transmit(UartData);
UartData = (unsigned char) status;
uart_Transmit(UartData);

Gruß

Autor: Jean Player (fubu1000)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und was soll das ???

int  main();        // Hauptprogramm

Autor: Sonke A. (soeni)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke ich werde das mal ausprobieren.

Ich schreibe mir der Übersichthalber alle Funktionen einer Datei an den 
Anfang, so kann man schnell sehen, welche Funktionen in welcher Datei 
liegen. (Deswegen das in main())

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.