ATMEGA 128RFA1 - Bit übertragen

[Florian J. (Firma: Ostfalia WF) (codef)]

Hallo,

im Rahmen einer Studienarbeit soll ich zum Thema HF-Technik eine Antenne 
für den 128RFA1 entwickeln.
Dabei stelle ich zwei Platinen mit Planar-Antennen her, an die jeweils 
ein 128RFA1 angeschlossen wird.

Um die korrekte Funktion zu demonstrieren, soll irgendwas übertragen 
werden. Da habe ich mir überlegt, dass es das einfachste ist 1 Bit zu 
übertragen. Bedeutet: Wenn ich bei dem einen Controler eine Taste 
drücke, so soll auf der anderen Platine eine LED leuchten.

Leider habe ich bisher nicht herausfinden können, wie ich den RF-Kanal 
nutzen kann, und konnte bisher auch keine genauen Informationen im 
Internet finden.

Vieleicht kann mir jemand zeigen, wie ich dieses Problem am einfachsten 
lösen kann.


Vielen Dank schon einmal im Voraus.

Florian

[Karl H. (kbuchegg)]

Vergiss das Bit.
Die Leib und Mageneinheit eines µC ist 1 Byte. Alles andere ist 
zusätzlicher Aufwand.

Zum Thema: wie geht man mit der Funkeinheit um?
Würde mich wundern, wenn es da von Atmel keine AppNote zu dem Thema 
gäbe. Schon mal danach gesucht?

[Florian J. (Firma: Ostfalia WF) (codef)]

Ja das Bit habe ich jetzt vergessen und versuche nun ein Byte zu 
übertragen. Der Inhalt ist ja zunächst auch egal.

Folgendes Programm habe ich jetzt am laufen:

main.c

#include <asf.h>
#include <avr/io.h>
#include "RadioFunctions.h"


int main (void)
{
  board_init();
  
  DDRE  = 0b11111111;
  //DDRE |= (1 << DDE5);
  
  DDRE  &= ~(1<<PE5);  /* Pin PC7 als Eingang */
  PORTE |= (1<<PE5);    /* internen Pull-Up an PC7 aktivieren */
  rfBegin(11);  // Initialize ATmega128RFA1 radio on channel 11 (can be 11-26)
  
  
  while(1)
  {
    PORTE = 0xFF;

    if (  PINE & (1<<PINE5)  )   //Taste senden  
    {
      
      //PORTE |= (1<<PE4);

    } else
    {
       rfWrite(0xFF); // ...send it out the radio.
      //
      
    }
  
    if (rfAvailable()) // If data receievd on radio...
    {
             //ggf. LED ansteuern
    }
  }

}

RadioFunctions.h

uint8_t rssiRaw; // Global variable shared between RX ISRs
#include <asf.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <util/delay.h>
#define F_CPU 20000000

const int RF_BUFFER_SIZE = 127;
struct ringBuffer
{
  unsigned char buffer[127];
  volatile unsigned int head;
  volatile unsigned int tail;
} radioRXBuffer;


// Initialize the RFA1's low-power 2.4GHz transciever.
// Sets up the state machine, and gets the radio into
// the RX_ON state. Interrupts are enabled for RX
// begin and end, as well as TX end.
uint8_t rfBegin(uint8_t channel)
{
  for (int i=0; i<128; i++)
  {
    radioRXBuffer.buffer[i] = 0;
  }
  radioRXBuffer.tail = 0;
  radioRXBuffer.head = 0;

  // Transceiver Pin Register -- TRXPR.
  // This register can be used to reset the transceiver, without
  // resetting the MCU.
  TRXPR |= (1<<TRXRST); // TRXRST = 1 (Reset state, resets all registers)

  // Transceiver Interrupt Enable Mask - IRQ_MASK
  // This register disables/enables individual radio interrupts.
  // First, we'll disable IRQ and clear any pending IRQ's
  IRQ_MASK = 0; // Disable all IRQs
  
  // Transceiver State Control Register -- TRX_STATE
  // This regiseter controls the states of the radio.
  // First, we'll set it to the TRX_OFF state.
  TRX_STATE = (TRX_STATE & 0xE0) | TRX_OFF; // Set to TRX_OFF state
  

  PORTE &= ~(1<<PE2); 
  _delay_ms(1000);
  PORTE |= (1<<PE2);

  // Transceiver Status Register -- TRX_STATUS
  // This read-only register contains the present state of the radio transceiver.
  // After telling it to go to the TRX_OFF state, we'll make sure it's actually
  // there.

  if ((TRX_STATUS & 0x1F) != TRX_OFF) // Check to make sure state is correct
  return 0;        // Error, TRX isn't off

  // Transceiver Control Register 1 - TRX_CTRL_1
  // We'll use this register to turn on automatic CRC calculations.
  TRX_CTRL_1 |= (1<<TX_AUTO_CRC_ON); // Enable automatic CRC calc.
  
  // Enable RX start/end and TX end interrupts
  IRQ_MASK = (1<<RX_START_EN) | (1<<RX_END_EN) | (1<<TX_END_EN);
  
  // Transceiver Clear Channel Assessment (CCA) -- PHY_CC_CCA
  // This register is used to set the channel. CCA_MODE should default
  // to Energy Above Threshold Mode.
  // Channel should be between 11 and 26 (2405 MHz to 2480 MHz)
  if ((channel < 11) || (channel > 26)) channel = 11;
  PHY_CC_CCA = (PHY_CC_CCA & 0xE0) | 11; // Set the channel to 11
  
  // Finally, we'll enter into the RX_ON state. Now waiting for radio RX's, unless
  // we go into a transmitting state.
  TRX_STATE = (TRX_STATE & 0xE0) | RX_ON; // Default to receiver

  return 1;
}


// This function will transmit a single byte out of the radio.
void rfWrite(uint8_t b)
{
  uint8_t length = 3;

  // Transceiver State Control Register -- TRX_STATE
  // This regiseter controls the states of the radio.
  // Set to the PLL_ON state - this state begins the TX.
  TRX_STATE = (TRX_STATE & 0xE0) | PLL_ON; // Set to TX start state
  while(!(TRX_STATUS & PLL_ON))
  ; // Wait for PLL to lock

  //digitalWrite(TX_LED, HIGH); // Turn on TX LED
  
  PORTE &= ~(1<<PE3); 

  // Start of frame buffer - TRXFBST
  // This is the first byte of the 128 byte frame. It should contain
  // the length of the transmission.
  TRXFBST = length;
  // Now copy the byte-to-send into the address directly after TRXFBST.
  memcpy((void *)(&TRXFBST+1), &b, 1);

  // Transceiver Pin Register -- TRXPR.
  // From the PLL_ON state, setting SLPTR high will initiate the TX.
  TRXPR |= (1<<SLPTR); // SLPTR = 1
  TRXPR &= ~(1<<SLPTR); // SLPTR = 0 // Then bring it back low

  // After sending the byte, set the radio back into the RX waiting state.
  TRX_STATE = (TRX_STATE & 0xE0) | RX_ON;
}

// Returns how many unread bytes remain in the radio RX buffer.
// 0 means the buffer is empty. Maxes out at RF_BUFFER_SIZE.
unsigned int rfAvailable()
{
  return (unsigned int)(RF_BUFFER_SIZE + radioRXBuffer.head - radioRXBuffer.tail) % RF_BUFFER_SIZE;
}

// This function reads the oldest data in the radio RX buffer.
// If the buffer is emtpy, it'll return a 255.
char rfRead()
{
  if (radioRXBuffer.head == radioRXBuffer.tail)
  {
    return -1;
  }
  else
  {
    // Read from the buffer tail, and update the tail pointer.
    char c = radioRXBuffer.buffer[radioRXBuffer.tail];
    radioRXBuffer.tail = (unsigned int)(radioRXBuffer.tail + 1) % RF_BUFFER_SIZE;
    return c;
  }
}

// This interrupt is called when radio TX is complete. We'll just
// use it to turn off our TX LED.
ISR(TRX24_TX_END_vect)
{  
  PORTE |= (1<<PE3); 
}

// This interrupt is called the moment data is received by the radio.
// We'll use it to gather information about RSSI -- signal strength --
// and we'll turn on the RX LED.
ISR(TRX24_RX_START_vect)
{

  rssiRaw = PHY_RSSI; // Read in the received signal strength
  PORTE &= ~(1<<PE4);
}

// This interrupt is called at the end of data receipt. Here we'll gather
// up the data received. And store it into a global variable. We'll
// also turn off the RX LED.
ISR(TRX24_RX_END_vect)
{
  uint8_t length;
  // Maximum transmission is 128 bytes
  uint8_t tempFrame[RF_BUFFER_SIZE];

  // The received signal must be above a certain threshold.
  if (rssiRaw & RX_CRC_VALID)
  {
    // The length of the message will be the first byte received.
    length = TST_RX_LENGTH;
    // The remaining bytes will be our received data.
    memcpy(&tempFrame[0], (void*)&TRXFBST, length);
    
    // Now we need to collect the frame into our receive buffer.
    // k will be used to make sure we don't go above the length
    // i will make sure we don't overflow our buffer.
    unsigned int k = 0;
    unsigned int i = (radioRXBuffer.head + 1) % RF_BUFFER_SIZE; // Read buffer head pos and increment;
    while ((i != radioRXBuffer.tail) && (k < length-2))
    {
      // First, we update the buffer with the first byte in the frame
      radioRXBuffer.buffer[radioRXBuffer.head] = tempFrame[k++];
      radioRXBuffer.head = i; // Update the head
      i = (i + 1) % RF_BUFFER_SIZE; // Increment i % BUFFER_SIZE
    }
  }

  // Turn receive LED off, and we're out
  PORTE |= (1<<PE4);
}

Das Senden sollte meiner Meinung nach funktionieren, habe dies mittels 
Spektrumanalysater getestet (Beim Drücken der Sendetaste ist die 
Frequenz 2,405 GHz im Spektrum vorhanden). Wird die Taste gedrück, geht 
auch brav die TX-LED an.
Allerdings tut sich  beim zweiten uC nichts. Eigentlich sollte dort dann 
die RX Lampe agehen, gesteuert von der ISR. Auf beiden uC läuft das 
selbe Programm.

Mehr zu diesem Problem habe ich im Internet noch nicht herausfinden 
können.

[Jörg W. (dl8dtl) (Moderator)]

Karl Heinz Buchegger schrieb:
> Die Leib und Mageneinheit eines µC ist 1 Byte. Alles andere ist
> zusätzlicher Aufwand.

In diesem Falle ist die Leib- und Mageneinheit ein Frame, denn nur
einen solchen kann ein Transceiver nach IEEE 802.15.4 übertragen.

Ansonsten würde ich dem TE mal das µracoli-Projekt nahelegen,
besonders natürlich angesichts der Tatsache, dass sein Hauptaugenmerk
ja gar nicht auf der eigentlichen Datenübertragung, sondern auf dem
Antennendesign liegt.

Wenn du eine wirklich gute Vergleichsantenne haben willst: nimm die
aus der Appnote AVR2006.  An deren 6,5 dBi darfst du, gemessen am
vergleichsweise geringen Aufwand, den sie treibt, deine Experimente
messen lassen.  (Wenn du dich mal bei den Erklärungen zu meinen
Boards von „Tic-Tac-Toe Reloaded“ umsiehst, kann man diese Antenne
unter bestimmten Umständen direkt ohne Tiefpass an den ATmega128RFA1
klemmen, ohne die ETSI-Grenzwerte für die Störstrahlung zu 
überschreiten.
Nimm aber dann möglichst die Sendeleistung etwas zurück.)