/******************************************************************************
*                                                                             *
*        **********                                                           *
*       ************                                                          *
*      ***        ***                                                         *
*     ***    ++    ***                                                        *
*     ***   +  +   ***                      CHIPCON                           *
*     ***   +                                                                 *
*     ***   +  +   ***                                                        *
*     ***    ++    ***                                                        *
*      ***        ***                                                         *
*       ************                                                          *
*        **********                                                           *
*                                                                             *
*******************************************************************************

Filename:     rf_test.c
Target:       cc2430
Author:       efu
Revised:      16/12-2005
Revision:     1.0

Description:
    This file provides 4 small tests which demonstrates use of the radio.

******************************************************************************/


#include "app_ex.h"
#include "cul.h"
#include "pingPong.h"


#define ADDRESS_0 0x01
#define ADDRESS_1 0x02

#define SEND     0
#define RECEIVE  1

#define SINGLE      0
#define CONTINUOUS  1
#define PING_PONG   2
#define PER_TEST    3
#define EXIT        4

#define RECEIVE_TIMEOUT               1200

#define PING_PONG_TIMEOUT             1200
#define PING_PONG_REQUEST             0x80
#define PING_PONG_RESPONSE            0x40

#define PER_RECEIVE_TIMEOUT          10000
#define PER_TOTAL_PACKET_NUMBER       1000
#define PER_TEST_REQUEST              0x20


void initRfTest(void);
void rf_test_main(void);
void receivePacket(UINT8 *receiveByte);
void sendPacket(UINT8 sendByte);
void printAddress(UINT8 address);
void printRSSI(INT8 rssi);
UINT32 getFrequency(void);
UINT8 getAddress(UINT8 a);


void receiveMode(void);
void singleMode(void);
void contionuousMode(void);
void pingPongMode(void);
void perTestMode(void);
void showState(void);
void conductPerTest(void);
void pingPongResponse(void);


//UINT8 address0; //my adresse
//UINT8 address1; //other adress
UINT8 RxTxState;
UINT8 myAddr;
UINT8 remoteAddr;
BOOL remoteAddressSet = FALSE;
BOOL myAddressSet = FALSE;


/******************************************************************************
* @fn  initRfTest
*
* @brief
*      Initializes components for the RF test application example.
*
* Parameters:
*
* @param  void
*
* @return void
*
******************************************************************************/
void initRfTest(void)
{
   char *menuText[] = {(char *)" Sender?", (char *)" Receiver?", (char *)" Set Freq?", (char *)" Set MyAddr?", (char *)" Set RemoteAddr?"};
   BYTE result;
   UINT32 frequency = 2405000;


   initLcd();

   INIT_JOYSTICK();
   INIT_BUTTON();

   SET_MAIN_CLOCK_SOURCE(CRYSTAL);

   INIT_GLED();
   INIT_YLED();

   remoteAddressSet = FALSE;
   myAddressSet = FALSE;

   while((result = lcdMenu(menuText, 5)) > 1)
   {
      if(result == 2)
      {
         frequency = getFrequency();
      }
      else if(result == 3)
      {
         lcdUpdate((char *)"Set myAddress",(char *)"");
         myAddr = getAddress(myAddr);
         myAddressSet = TRUE;
      }
      else if(result == 4)
      {
         lcdUpdate((char *)"Set remoteAddr",(char *)"");
         remoteAddr = getAddress(remoteAddr);
         remoteAddressSet = TRUE;
      }
      else{ // ABORT_MENU
         return;
      }


   }

   if(result == 1) // Receiver
   {
      RxTxState = RECEIVE;
      if(myAddressSet == FALSE)
      {
         myAddr = ADDRESS_1;
      }
      if(remoteAddressSet == FALSE)
      {
         remoteAddr = ADDRESS_0;
      }
      lcdUpdate((char *)"Receiver",(char *)"");
   }
   else // Sender
   {
      RxTxState = SEND;
      if(myAddressSet == FALSE)
      {
         myAddr = ADDRESS_0;
      }
      if(remoteAddressSet == FALSE)
      {
         remoteAddr = ADDRESS_1;
      }
      lcdUpdate((char *)"Sender",(char *)"");
   }
   waitVisible(CLEARLY_VISIBLE);
   radioInit(frequency, myAddr);
}


/******************************************************************************
* @fn  rf_test_main
*
* @brief
*      Main function.
*
* Parameters:
*
* @param  void
*
* @return void
*
******************************************************************************/
#ifdef COMPLETE_APPLICATION
void rf_test_main(void){
#else
void main(void){
#endif
   UINT8 mode = 0;
   char *menuText[] = {(char *)" Single?", (char *)" Continuous?", (char *)" PingPong?", (char *)" PER Test?"};


   while(getJoystickDirection() != CENTRED);
   initRfTest();

   // Turning on interrupts
   INT_GLOBAL_ENABLE(INT_ON);


   while(!stopApplication())
   {

      // If set up as slave, the unit will only be in receive
      if(RxTxState == RECEIVE)
      {
         lcdUpdate((char *)"Receive",(char *)"Node");
         waitVisible(CLEARLY_VISIBLE);
         receiveMode();
         return;
      }
      else
      {
         mode = lcdMenu(menuText, 4);

         switch (mode){
         case SINGLE:
            lcdUpdate((char *)"Single mode", (char *)"");
            waitVisible(CLEARLY_VISIBLE);
            singleMode();
            break;

         case CONTINUOUS:
            lcdUpdate((char *)"Continuous Mode", (char *)"");
            waitVisible(CLEARLY_VISIBLE);
            contionuousMode();
            break;

         case PING_PONG:
            lcdUpdate((char *)"Ping Pong Mode", (char *)"");
            waitVisible(CLEARLY_VISIBLE);
            pingPongMode();
            break;

         case PER_TEST:
            lcdUpdate((char *)"PER Mode", (char *)"");
            waitVisible(CLEARLY_VISIBLE);
            perTestMode();
            break;

         case ABORT_MENU:
            return;
         }
      }
      while(getJoystickDirection() != CENTRED);
      GLED = YLED = LED_OFF;
   }
   return;
}


/******************************************************************************
* @fn  singleMode
*
* @brief
*      Function for transferring one packet
*
* Parameters:
*
* @param  void
*
* @return void
*
******************************************************************************/
void singleMode(void)
{
   char *singleMenu[] = {(char *)" Send?"};
   BYTE sendBuffer[] = "Hello";
   BOOL res;


   while(TRUE)
   {
      if(lcdMenu(singleMenu, 1) == 0)
      {
         YLED = LED_ON;
         res = radioSend(sendBuffer, sizeof(sendBuffer), remoteAddr, DO_ACK);
         YLED = LED_OFF;
         if(res == TRUE)
         {
            GLED = LED_ON;
            lcdUpdateLine(LINE1, (char *)"OK!");

         }
         else
         {
            GLED = LED_OFF;
            lcdUpdateLine(LINE1, (char *)"Failed...");
         }
         waitVisible(CLEARLY_VISIBLE);
         GLED = LED_OFF;
      }
      else
      {   // exit is selected...
         return;
      }
   }
}


/******************************************************************************
* @fn  contionuousMode
*
* @brief
*      Function for transferring packets until stopped by user.
*
* Parameters:
*
* @param  void
*
* @return void
*
******************************************************************************/
void contionuousMode(void)
{
   BOOL res;
   BYTE sendBuffer[] = "Hello";
   showState();

   while(!stopApplication()){
      GLED = LED_OFF;
      YLED = LED_ON;
      res = radioSend(sendBuffer, sizeof(sendBuffer), remoteAddr, DO_ACK);
      YLED = LED_OFF;

      if(res == TRUE)
      {
         GLED = LED_ON;
         lcdUpdateLine(LINE1, (char *)"OK!");
         //printRSSI();
      }
      else
      {
         GLED = LED_OFF;
         lcdUpdateLine(LINE1, (char *)"Failed...");
      }
      waitVisible(CLEARLY_VISIBLE);
   }
}


/******************************************************************************
* @fn  pingPongMode
*
* @brief
*      Function for sending packets between two nodes.
*
* Parameters:
*
* @param  void
*
* @return void
*
******************************************************************************/
void pingPongMode(void)
{
    BOOL res;
    BYTE sendBuffer = PING_PONG_REQUEST;
    BYTE* buffer;
    BYTE length;
    BYTE sender;


    //showState();

    pingPongInit();