CC430 hängt zu lange fest

[Rangi J. (rangi)]

Hallo Forum,
ich habe ein Problem mit dem CC430 von TI. Ich hoffe jemand kennt sich 
damit aus.
Wenn ich den Radio-Core aus dem Sleep aufwecke braucht dieser sehr lange 
um nach Idle oder Rx zu wechseln. Im Datenblatt steht:

"When the radio needs to transition from the SLEEP state to an active 
state (e.g., IDLE, RX or TX) the CPU must not go into a low power mode 
until the  Radio is active. This is reflected by the RF_RDYn signal 
transitioning from 1 to 0. This can be observed best on the programmable 
RFINx signals, e.g., the GDO2 signal fed to RFIN2 is programmed by 
default to RF_RDYn."

Das ist im Code auch so implementiert.

  TP1_ON();   //Zeitmessung
  while ((RF1AIN&0x04)== 0x04);                   // c-ready ?
  TP1_OFF();  //Zeitmessung

Jedoch dauert das bei mir ca. 200 ms. Ich habe auch keine weitere Angabe 
gefunden wie lange das dauern darf ausser das danach nochmal 810µs 
gewartet werden soll.
Was kann da falsch sein? 200 ms ist mich echt zu lange.

[Rangi J. (rangi)]

Keiner eine Idee?

Der TI-Support hat seinen Namen auch verdient:
"The ASKTEXAS team is unfortunately not able to provide technical 
support on this range of products."
ASKTEXAS = Fragen ja, von Antworten haben wir nix gesagt.
und weiter:
"The WiLink family products are intended for High volume (OEM) 
manufacturers. If you are interested on technologies such as Bluetooth, 
WiFi and GPS, you could use our 3rd parties modules as a ready to use 
solution for your design."
Bitte verwende nicht diesen Schrott sonderen den anderen. Aha, jetzt 
soll ich meine Hardware komplett ändern weil die keine Antworten für 
dieses Produkt geben? Aber sie verkaufen es doch. aufreg

Keiner eine Idee? Ich bin wirklich in meinem Projekt darauf angewiesen 
das keine Wartezeit auftritt. Währenddessen werden Daten aufgenommen und 
die müssen gespeichert werden und soviel Speicher für nochmal 100ms hab 
ich einfach nicht.

[CC430 (Gast)]

Hallo,

also 200ms sind definitiv zu lange. Irgendetwas stimmt mit deinem Code 
nicht.
Poste den doch mal.

Und zu deinem Projekt:
Du hast also irgendeine Form von Datenlogger. Dieser nimmt 
kontinuierlich  Daten auf und zu einem bestimmten Zeitpunkt erwartest du 
ein Signal von außen, weshalb du den Receiver benötigst?

[Rangi J. (rangi)]

Zum Projekt: Viele Funkknoten lauschen auf einem Medium. Jetzt wird ein 
externes Ereignis festgestellt und alles anderen Teilnehmer müssen per 
Funk darüber informiert werden. Diese lauschen ständig und halten 
rückwirkend nur eine bestimmte Zeit an Daten vorrätig. Und wenn der 
initiierende Knoten schon so lange braucht um seinen eigenen Funk 
aufzuwecken, dann überschreiben die anderen Funkknoten bereits ihre 
Daten und das Ereigns ist verloren.
Quelltext ist ganz schön viel, ich habe den Code TI zum lesen und 
schreiben der Register verwendet. siehe slac525a.zip
"SLAA465 - CC430 RF Examples\CC430x613x RF 
examples\RF_Examples_CCS\Asynchronous_Communication\HAL\RF1A.c"
Der entscheidende Punkt ist in der Funktion

u8 Strobe(u8 _bStrobe)
{
   u8 statusByte = 0;
   //u16 gdo_state;
 
   // Check for valid strobe command
   if((_bStrobe == 0xBD) || ((_bStrobe >= RF_SRES) && (_bStrobe <= RF_SNOP)))
   {     
     
      // Clear the Status read flag
      RF1AIFCTL1 &= ~(RFSTATIFG);
     
      // Wait for radio to be ready for next instruction
      while( !(RF1AIFCTL1 & RFINSTRIFG));
#if 1
      // Write the strobe instruction
      if ((_bStrobe > RF_SRES) && (_bStrobe < RF_SNOP))
      {
         //IOCFG steht dauerhaft auf 0x29 und muss nicht immer umkonfiguriert werden
         //gdo_state = GetRegister(IOCFG2); // buffer IOCFG2 state
         //SetRegister(IOCFG2, 0x29); // c-ready to GDO2
       
         RF1AINSTRB = _bStrobe;
         if ( (RF1AIN&0x04)== 0x04 )             // chip at sleep mode
         {
            if ( (_bStrobe == RF_SXOFF) || (_bStrobe == RF_SPWD) || (_bStrobe == RF_SWOR) ) { }
            else   
            {
               IO_TP1_ON();  // Zeitmessung
               while ((RF1AIN&0x04)== 0x04);                   // c-ready ?
               IO_TP1_OFF();  // Zeitmessung
               TIM_vDelay(900 us);   // Delay for ~810usec at 12MHz CPU clock
            }
         }
         //SetRegister(IOCFG2, gdo_state); // restore IOCFG2 setting
      }
      else      // chip active mode
      {
         RF1AINSTRB = _bStrobe;     
      }
#else
      // Versuch ohne Abprüfung von C-READY - kein Erfolg
      RF1AINSTRB = _bStrobe;
#endif
      statusByte = RF1ASTATB;

   }
   return statusByte;
}

bool WaitForIdle(void)
{
 u8 ba,bb;
  for(ba=25;ba;ba--)              /*maximal n loops warten*/
  {
    switch(GetChipState())  /* chipstate auslesen und fehlerbehandlung*/
    {
      case eneCSt_TX:          /*tue nichts - er ist am senden oder vorbereiten*/
      case eneCSt_FSTXOn:      /*ein folgender interrupt wird abgewartet*/
        break;
      case eneCSt_RX:
        Strobe(REG_SIDLE);
        /*nobreak*/
      case eneCSt_Idle:
        return (true); /*for-schleife und switch verlassen*/
      case eneCSt_Sleep:
        Strobe(REG_SIDLE);  // << - Hier ist die Wartezeit - RF war im Sleep und soll nach IDLE wechseln
        break;
      case eneCSt_RXFIFO_Overflow:
        bStrobe(REG_SFRX);
        break;
      case eneCSt_TXFIFO_Underflow:
        Strobe(REG_SFTX);
        break;
      default:
      /*alle anderen states die automatisch nach bestimmter zeit nach idle zurueckfallen*/
        break;
    }
    for(bb=64;bb;bb--)
    {
      asm(" NOP");   /*kurze wartezeit um zeit zugeben nach idle zu wechseln*/
    }
  }
  return (false);
}

[Rangi J. (rangi)]

Vergessen, diese Bits sind gesetzt:
MCSM0.XOSC_FORCE_ON=1
XT2OFF=0

[nur mal so (Gast)]

In der for Schleife steht "maximal" 25 loops warten. Die Schleife wird 
aber nie vorher abgebrochen!

[Rangi J. (rangi)]

@nur mal so
ausser in der Zeile wo steht : "/*for-schleife und switch verlassen*/"

[Rangi J. (rangi)]

Ich wollte meinen alten Beitrag mal wieder nach oben kehren. Ich habe 
noch immer keine Lösung für das Problem gefunden.
Ich habe jetzt den Wake-On-Radio Mode so eingestellt, dass er alle 210ms 
wach wird und sich danach wieder schlafen legt. Daten können auch 
empfangen werden, wenn ich von einem anderen Funksystem 220ms 
dauer-sende.
Möchte ich aber selber meinen Funkcore aus dem Wake-On-Radio aufwecken 
bleibt das Strobe "SIDLE" so lange hängen, bis der nächste Zylkus des 
WOR-Timers dran ist. Im schlimmsten Fall also 210ms.
Und Schuld ist diese Zeile:

 while ((RF1AIN&0x04)== 0x04);

in der Strobe-Funktion von TI. Hier wird so lange gewartet.
Programmablauf beim Senden ist:
- State des Core abfrage, Ergebnis 0 (Sleep)
- Strobe SIDLE ausführen (jetzt hängt der Befehlt wie oben beschrieben)
- Nach der Pause ist der Core wie normal im Idle

Kann ich den Radio-Core noch irgendwie anders aufwecken? Was ist das für 
ein merkwürdiges Verhalten?

[Rangi J. (rangi)]

Keiner ein Idee?

[Rangi J. (rangi)]

Nach langer Forschungsarbeit habe ich folgendes rausgefunden:
1. selbst mit dem Beispiel von TI hängt der RF-Core bis zum nächsten 
WOR-Timer-Event.
2. wenn man anstelle des IDLE-Strobes das RX-Strobe verwendet, geht die 
Umschaltung ganz schnell. Danach ist er allerdings nicht im RX sondern 
Trommelwirbel im Idle. Wer hätte das gedacht?

Jetzt ist noch ein Problem: Der Core sagt mir zwar ist ist Idle, macht 
aber scheinbar nicht das was er soll. Ein folgende TX-Strobe hat keine 
Wirkung.