CC2500 Funkmodul empfängt nur das erste byte korrekt

[C. H. (hedie)]

Guten Abend

Ich habe hier ein CC2500 Funkmodul welches an einem Atmega48 hängt.

Die Kommunikation funktioniert grundsätzlich.
Jedoch nur mit dem ersten Byte...



Ich würde mich sehr freuen, wenn jemand was auffäliges sieht oder sonst 
eine ideee hat...

Die bytes, welche nach dem erfolgreich empfangenen kommen, mehr oder 
weniger zufällig... siehe unten:

Hier ein Empfang: (es sollte von 1..50 empfangen werden)

Data: {0x01,0x08,0x09,0x0A,0x0C,0x0E,0x0F,0x10,0x12,0x14,
0x15,0x16,0x18,0x1A,0x1B,0x1D,0x1E,0x20,0x21,0x23,0x24,
0x26,0x27,0x29,0x2A,0x2C,0x2D,0x2F,0x30,0x32,0x7F,0xFD,
0xDB,0x62,0xDF,0x9F,0x51,0x69,0xBF,0xFD,0xFF,0xDB,0xBF,
0xFF,0xCE,0x1E,0xFF,0xEE,0xBA,0x6E};

Ein weiterer Empfang:

Data: {0x01,0x07,0x09,0x0A,0x0C,0x0D,0x0F,0x10,0x12,0x13,
0x15,0x16,0x18,0x19,0x1B,0x1C,0x1E,0x1F,0x21,0x22,0x24,
0x26,0x27,0x28,0x2A,0x2C,0x2D,0x2E,0x30,0x32,0x3F,0xFF,
0xFF,0xFC,0xA8,0xA7,0xE2,0xD7,0xB6,0xF9,0xE0,0xAF,0x4A,
0xFF,0x5B,0x75,0xDD,0x69,0xFC,0x1C};


Danke schonmal :)


Hier wie ich sende mit pseudocode:


Ich schreibe 0x10 ins FREND0 Register (DB Seite 79)
Ich leere den TXFIFO mit dem Burstbefehl SFTX
warte 10ms
Ich schreibe mit einem kontinuierlichen Schreibzugirff in den TXFIFO
warte 10ms
Ich aktiviere das Senden mit STX
warte 10ms
Warte solange bis (TXBYTES & 0x7F) auf 0 ist


Hier mein Code

//-------------------------------------------------------------------------------------------------------
//  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

Hier noch die Konfig des Modules:

   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.