Antenne RFM70

#include "meinRFM70P.h"

//************  Bank0 

uint8_t bank0Init[][2]=

{

//    address      data

    { (0x20|0x00),  0x0B },  //Alle Int's am IRQ Pin active low ausgeben, CRC an, CRC Encoding 1 byte, Power Up, Transmitter

    { (0x20|0x01),  0x3F },  //Auto Acknowledge auf alle pipes aktivieren

    { (0x20|0x02),  0x3F },  //alle Datenpipes aktivieren

    { (0x20|0x03),  0x03 },  //RX/TX 5 byte lange Adresse für Empfänger/Sender

    { (0x20|0x04),  0x27 },  //Auto Retransmition delay 500us, Auto Retransmision aus

    { (0x20|0x05),  0x3F },  //kanal = 18

    { (0x20|0x06),  0x37 },  //Air Data Rate 2Mbps, Transmit Power 5dBm, LNA gain -20dB

    { (0x20|0x07),  0x00 },   // Statusregister

    { (0x20|0x08),  0x00 },  //Read only Transmit Observe Register, zählt Packet loss und retransmits

    { (0x20|0x09),  0x00 },  //Read only Carrier Detect (?)

    { (0x20|0x0C),  0xC3 },  //LSB Addr pipe 2

    { (0x20|0x0D),  0xC4 },  //LSB Addr pipe 3

    { (0x20|0x0E),  0xC5 },  //LSB Addr pipe 4

    { (0x20|0x0F),  0xC6 },  //LSB Addr pipe 5

    { (0x20|0x11),  0x32 },  // 32 bytes RX Payload in pipe0 ------>?

    { (0x20|0x12),  0x32 },  // 32 bytes RX Payload in pipe1 ------>?

    { (0x20|0x13),  0x32 },  // 32 bytes RX Payload in pipe2 ------>?

    { (0x20|0x14),  0x32 },  // 32 bytes RX Payload in pipe3 ------>?

    { (0x20|0x15),  0x32 },  // 32 bytes RX Payload in pipe4 ------>?

    { (0x20|0x16),  0x32 },  // 32 bytes RX Payload in pipe5 ------>?

    { (0x20|0x17),  0x11 },  // FIFO Flag Register, ansich Read Only

    { (0x20|0x1C),  0x3F },  //  Dynamic Payload length für alle pipes aktiviert

    { (0x20|0x1D),  0x07 }   //Enables Dynamic Payload Length,Enables Payload with ACK

};

//**************32 bit Register 0A,0B,10 Bank0 Initialisierungsbefehle

uint8_t bank0R0A0B10Init[][6]=

{

  {(0x20|0x0A),  0xE7,  0xE7,  0xE7,  0xE7,  0xE7},   //Empfangsadresse pipe0

  {(0x20|0x0B),  0xC2,  0xC2,  0xC2,  0xC2,  0xC2},  //Empfangsadresse pipe1

  {(0x20|0x10),  0xE7,  0xE7,  0xE7,  0xE7,  0xE7}  //Sendeadresse, Nur für Sendemodus verwendet

};

//****************  Bank1 Addresse 0-5, MSBByte->LSBByte, Addresse 6;7;8 ist reserved oder Read Only

uint8_t bank1Init[][5]= {       

//    address      data

    { (0x20|0x00),  0x40,  0x4B,  0x01,  0xE2 },  //ok

    { (0x20|0x01),  0xC0,  0x4B,  0x00,  0x00 },  //ok

    { (0x20|0x02),  0xD0,  0xFC,  0x8C,  0x02 },  //ok

    { (0x20|0x03),  0x99,  0x00,  0x39,  0x41 },  //ok

    { (0x20|0x04),  0xD9,  0x9E,  0x86,  0x0B },   //High Power Mode als Sender

    { (0x20|0x05),  0x24,  0x06,  0x7F,  0xA6 },  //ok

};

//************  Bank1 register 0C-0D Initialisierungsbefehle, LSBByte-MSBByte, 09;0A;0B sind reserved

uint8_t bank1R090BInit[][5] = {

  {(0x20|0x0C),  0x00,  0x12,  0x73,  0x00},      //ok

  {(0x20|0x0D),  0x36,  0xB4,  0x08,  0x00},      //ok

};

//************  Bank1 register 0E Initialisierungsbefehle, LSBByte->MSBByte

uint8_t bank1R0EInit[]=

{

//  address  Data...

  (0x20|0x0E),   0x41,0x20,0x08,0x04,0x81,0x20,0xCF,0xF7,0xFE,0xFF,0xFF

};

void rfm_Init_Bank0()          //Bank0 mit Standartwerten Initialisieren

{                    //funktion begin

uint8_t zeile = 0, spalte = 0 , dummy = 0;

//#####  Schleife zum übertragen von Datenarray bank0Init ###########

for(zeile=0;zeile<=22;zeile++)          //Zeilenzählerschleife

  {  //outer Loop begin

  SPI_START;                  //RFM70P Selektieren

    for(spalte=0;spalte<=1;spalte++)    //Spaltenzählerschleife

      {  //inner Loop begin

        SPDR = bank0Init[zeile][spalte];//Datenregister mit dem aktuellen Befehl/Daten laden

        SPI_COMPLETE;          //warten bis SPI Übertragung komplett

        dummy = SPDR;          //Datenregister auslesen um INTFlag zu löschen

      }  //inner Loop end

  SPI_STOP;                  //RFM70P deselektieren

  }  //outer Loop end

//#####  Schleife zum übertragen von Datenarray bank0R0A0B10Init ###########

for(zeile=0;zeile<=2;zeile++)              //Zeilenzählerschleife

  {  //outer Loop begin

  SPI_START;                      //RFM70P Selektieren

    for(spalte=0;spalte<=5;spalte++)        //Spaltenzählerschleife

      {  //inner Loop begin

        SPDR = bank0R0A0B10Init[zeile][spalte];  //Datenregister mit dem aktuellen Befehl/Daten laden

        SPI_COMPLETE;              //warten bis SPI Übertragung komplett

        dummy = SPDR;              //Datenregister auslesen um INTFlag zu löschen

      }  //inner Loop end

  SPI_STOP;                  //RFM70P deselektieren

  }  //outer Loop end

}                    //funktion end

void rfm_Init_Bank1()          //Bank1 mit Standartwerten Initialisieren

{

uint8_t zeile = 0, spalte = 0 , dummy = 0;

//#####  Schleife zum übertragen von Datenarray bank1Init ###########

for(zeile=0;zeile<=5;zeile++)          //Zeilenzählerschleife

  {  //outer Loop begin

  SPI_START;                  //RFM70P Selektieren

    for(spalte=0;spalte<=4;spalte++)    //Spaltenzählerschleife

      {  //inner Loop begin

        SPDR = bank1Init[zeile][spalte];//Datenregister mit dem aktuellen Befehl/Daten laden

        SPI_COMPLETE;          //warten bis SPI Übertragung komplett

        dummy = SPDR;          //Datenregister auslesen um INTFlag zu löschen

      }  //inner Loop end

  SPI_STOP;                  //RFM70P deselektieren

  }  //outer Loop end

//#####  Schleife zum übertragen von Datenarray bank1R090BInit ###########

for(zeile=0;zeile<=1;zeile++)          //Zeilenzählerschleife

  {  //outer Loop begin

  SPI_START;                  //RFM70P Selektieren

    for(spalte=0;spalte<=4;spalte++)    //Spaltenzählerschleife

      {  //inner Loop begin

        SPDR = bank1R090BInit[zeile][spalte];//Datenregister mit dem aktuellen Befehl/Daten laden

        SPI_COMPLETE;          //warten bis SPI Übertragung komplett

        dummy = SPDR;          //Datenregister auslesen um INTFlag zu löschen

      }  //inner Loop end

  SPI_STOP;                  //RFM70P deselektieren

  }  //outer Loop end

//#####  Schleife zum übertragen von eindimensionalem Datenarray bank1R0EInit ###########

SPI_START;                  //RFM70P Selektieren

    for(spalte=0;spalte<=11;spalte++)    //Spaltenzählerschleife

      {  //inner Loop begin

        SPDR = bank1R0EInit[spalte];//Datenregister mit dem aktuellen Befehl/Daten laden

        SPI_COMPLETE;          //warten bis SPI Übertragung komplett

        dummy = SPDR;          //Datenregister auslesen um INTFlag zu löschen

      }  //inner Loop end

  SPI_STOP;        

return;

}

//Port und Pinbelegung 

#define DDR_SPI DDRB

#define PORT_SPI PORTB

#define CE PB3

#define CSN PB4              

#define SCK PB7

#define MISO PB6

#define MOSI PB5

#define IRQ PD6

//SPI Befehle

#define R_REGISTER       0x00        //Register lesen

#define W_REGISTER       0x20        //Register schreiben

#define R_RX_PAYLOAD     0x61        //Empfangene Datenpakete lesen (1-32 bytes)

#define W_TX_PAYLOAD     0xA0        //zu Sendende Datenpakete schreiben(1-32 bytes)

#define FLUSH_TX      0xE1        //Sendepuffer leeren (Sendemodus)

#define FLUSH_RX      0xE2        //Empfangspuffer leeren (Empfangsmodus)

#define REUSE_TX_PL      0xE3        //Letzete Datenpakete nochmal Senden (solange CE high ist..)

#define ACTIVATE      0x50        //ACTIVATE gefolgt von 0x73 aktiviert R_RX_PL_WID,W_ACK_PAYLOAD,W_TX_PAYLOAD_NOACK

#define R_RX_PL_WID      0x60        //Länge des Empfangenen Datenpaketes im Empfangspuffer auslesen

#define W_ACK_PAYLOAD    0xA8        //

#define W_TX_PAYLOAD_NOACK  0xB0        //AUTOACK im Sendemodus für das nächste Paket abschalten

#define RFM_NOP        0xFF        //No Operation

//Makros und Nützliches

#define SPI_COMPLETE while(!(SPSR & 0b10000000)){asm("NOP");}  //NOP Schleife solange SPI INT nicht gesetzt    

#define SPI_START PORT_SPI &= ~(1<<CSN)        //Übertragung beginnen

#define SPI_STOP PORT_SPI |= (1<<CSN)        //Übertragung beenden

//in Struktur verpackter Array damit Funktionen ihn zurückgeben können

struct retData  {

  int data[32];

        };

uint8_t rfm_Read_Reg(uint8_t READ_ADRESS);  //8 Bit Register lesen

uint8_t rfm_Get_Chip_ID(void);      //Chip ID auslesen

struct retData rfm_Read_Reg_long(uint8_t READ_ADRESS, uint8_t length);  //Register > 8 Bit lesen

struct retData rfm_Get_Payload();    //Empfangenes Datenpaket aus Empfangsregister Lesen

void rfm_init_SPI(void);

void rfm_Write_Reg(uint8_t WRITE_ADRESS , uint8_t length , uint8_t data[32]);  //Register schreiben, länge 8 Bit *length

void rfm_Set_Bank(int8_t bank);      //aktive Registerbank einstellen

void rfm_Set_Mode(uint8_t mode);    //0 = Sender, 1 = Empfänger

void rfm_Flush_TX();          //Sendespeicher leeren

void rfm_Flush_RX();          //Empfangsspeicher leeren

void rfm_Init_Bank0();          //Bank0 mit Standartwerten Initialisieren

void rfm_Init_Bank1();          //Bank1 mit Standartwerten Initialisieren

void rfm_Activate_73(void);        //Aktivieren(Toggle) der Register R_RX_PL_WID;W_ACK_PAYLOAD;W_TX_PAYLOAD_NOACK

void rfm_Send_Payload(uint8_t Payload[32]);    //Datenpaket ins Senderegister Schreiben