CC2500 Funkmodul empfängt nur das erste byte korrekt

//-------------------------------------------------------------------------------------------------------

//  void halRfSendPacket(BYTE *txBuffer, UINT8 size)

//

//

//  ARGUMENTS:

//      BYTE *txBuffer

//          Pointer to a buffer containg the data that are going to be transmitted

//

//      UINT8 size

//          The size of the txBuffer

//-------------------------------------------------------------------------------------------------------

void halRfSendPacket(BYTE *txBuffer, UINT8 size)

{

//  unsigned char i=0Xff;

  halSpiStrobe(CC2500_SFTX);  //TX FIFO leeren

  _delay_ms(10);

  halSpiWriteBurstReg(CC2500_TXFIFO, txBuffer, size); //Daten ins FIFO schreiben

  _delay_ms(10);

  halSpiStrobe(CC2500_STX);  //Senden

  _delay_ms(10);

  while((halSpiReadStatus(CC2500_TXBYTES)&0x7F)!=0x00)

  {

    _delay_us(300);

    //if(TCNT0 == 255){ return; }

  }

  return ;

}// halRfSendPacket*/

//-------------------------------------------------------------------------------------------------------

//  BOOL halRfReceivePacket(BYTE *rxBuffer, UINT8 *length)

//

//

//  ARGUMENTS:

//      BYTE *rxBuffer

//          Pointer to the buffer where the incoming data should be stored

//      UINT8 *length

//          Pointer to a variable containing the size of the buffer where the incoming data should be

//          stored. After this function returns, that variable holds the packet length.

//

//  RETURN VALUE:

//      BOOL

//          TRUE:   CRC OK

//          FALSE:  CRC NOT OK

//-------------------------------------------------------------------------------------------------------

BYTE halRfReceivePacket(BYTE *rxBuffer, UINT8 length)

{

    BYTE status=0;

    UINT8 packetLength;

    unsigned char ucCounter = 0;

  status = halSpiReadStatus(CC2500_RXBYTES);  //Anzahl bytes im RX FIFO

  uart_puts("Status: ");

  uart_send_var(status);

  uart_putc('\n');

  if((status & 0x7F)==0x00)  //ist der RX FIFO leer?

  {

    if(halSpiReadStatus(CC2500_MARCSTATE)!=0x0D) halSpiStrobe(CC2500_SRX);  //Prüfen ob RX im gange ist (0x0D) wenn nicht, starte RX

    return 0;                                //kehre aus der Funktion zurück

  }

  ucTimeout = 0;

  while((halSpiReadStatus(CC2500_MARCSTATE)&0x1f)!=0x01)            //warte bis der chip im IDLE modus ist. (RX sollte dann abgeschlossen sein)

  {

    _delay_us(100);

    ucTimeout++;

    if(ucTimeout == 200)  //Timeout

    {

      //halSpiStrobe(CC2500_SFRX);  //Wenn Timeout eingetreten ist, leere den RX FIFO

      return 0;

    }

  }

    packetLength = halSpiReadReg(CC2500_RXFIFO);  //Vermutlich wird damit das erste Byte aus dem RX FIFO gelesen.

                            // dies ist nach dem benutzten Protokoll die Paketlänge

    uart_puts("PaketLange: ");

    uart_send_var(packetLength);

    uart_putc('\n');

    uart_puts("Soll-Lange: ");

    uart_send_var(length);

    uart_putc('\n');

      //halSpiStrobe(CC2500_SFRX);

    if (packetLength == length) {  //Stimmt die Länge mit der erwarteten Länge überrein?

      //packetLength = 10;

    halSpiReadBurstReg(CC2500_RXFIFO, rxBuffer, packetLength);  // Dann lese den gesamten RX FIFO in den Buffer ein.

    uart_puts("Data: ");

    ucCounter = 0;

    uart_putc('{');

    while(ucCounter != packetLength)

    {

      uart_puts("0x");

      uart_send_as_hex(rxBuffer[ucCounter]);

      ucCounter++;

      if(ucCounter < packetLength) uart_putc(',');

    }

    uart_putc('}');

    uart_putc(';');

    uart_putc('\n');

    uart_putc('\n');

        halSpiStrobe(CC2500_SFRX);  //Löschen den RX FIFO wieder.

        return 1;//(status & CRC_OK);

    } else {

    halSpiStrobe(CC2500_SFRX);  //Wenn die erwartete Länge nicht übereinstimmt, wird das Paket verworfen.

        return 0;

    }

}// halRfReceivePacket

   halSpiWriteReg(CC2500_FSCTRL1    ,0x07);

   halSpiWriteReg(CC2500_FSCTRL0    ,0x00);

   halSpiWriteReg(CC2500_FREQ2      ,0x5D);

   halSpiWriteReg(CC2500_FREQ1      ,0x44);

   halSpiWriteReg(CC2500_FREQ0      ,0xEC);

   halSpiWriteReg(CC2500_MDMCFG4    ,0x2D); //250kBaud

   halSpiWriteReg(CC2500_MDMCFG3    ,0x3B); //250kBaud

   halSpiWriteReg(CC2500_MDMCFG2    ,0x73); //30/32 SyncByte

   halSpiWriteReg(CC2500_MDMCFG1    ,0x23);

   halSpiWriteReg(CC2500_MDMCFG0    ,0x3B);

   halSpiWriteReg(CC2500_CHANNR     ,0x03);

   halSpiWriteReg(CC2500_DEVIATN    ,0x01);

   halSpiWriteReg(CC2500_FREND1     ,0xB6);

   halSpiWriteReg(CC2500_FREND0     ,0x10);

   halSpiWriteReg(CC2500_MCSM0      ,0x18);

   halSpiWriteReg(CC2500_FOCCFG     ,0x1D);

   halSpiWriteReg(CC2500_BSCFG      ,0x1C);

   halSpiWriteReg(CC2500_AGCCTRL2   ,0xC7);

   halSpiWriteReg(CC2500_AGCCTRL1   ,0x00);

   halSpiWriteReg(CC2500_AGCCTRL0   ,0xB0);

   halSpiWriteReg(CC2500_FSCAL3     ,0xEA);

   halSpiWriteReg(CC2500_FSCAL2     ,0x0A);

   halSpiWriteReg(CC2500_FSCAL1     ,0x00);

   halSpiWriteReg(CC2500_FSCAL0     ,0x11);

   halSpiWriteReg(CC2500_FSTEST     ,0x59);

   halSpiWriteReg(CC2500_TEST2      ,0x88);

   halSpiWriteReg(CC2500_TEST1      ,0x31);

   halSpiWriteReg(CC2500_TEST0      ,0x0B);

   halSpiWriteReg(CC2500_FIFOTHR    ,0x07);

   halSpiWriteReg(CC2500_IOCFG2     ,0x29);

   halSpiWriteReg(CC2500_IOCFG0     ,0x06);

   halSpiWriteReg(CC2500_PKTCTRL1   ,0x04);

   halSpiWriteReg(CC2500_PKTCTRL0   ,0x01);  //Variable Paketlänge (erstes byte nach dem syncword gibt länge an)

   halSpiWriteReg(CC2500_ADDR       ,0x00);

   halSpiWriteReg(CC2500_PKTLEN     ,0xFF);  //Maximale Paketlänge im RX. Wenn LenghtByte grösser ist als PKTLEN dann wird es verworfen.