Example #1
0
int NRF24L01_Reset()
{
    NRF24L01_FlushTx();
    NRF24L01_FlushRx();
    u8 status1 = Strobe(NOP);
    u8 status2 = NRF24L01_ReadReg(0x07);
    NRF24L01_SetTxRxMode(TXRX_OFF);
    return (status1 == status2 && (status1 & 0x0f) == 0x0e);
}
Example #2
0
File: radio.c Project: alkin/tidecc
// *************************************************************************************************
// @fn          radio_reset
// @brief       Reset radio core. 
// @param       none
// @return      none
// *************************************************************************************************
void radio_reset(void)
{
   volatile u16 i;
   u8 x;

   // Reset radio core
   Strobe(RF_SRES);
   // Wait before checking IDLE 
   for (i = 0; i < 100; i++) ;
   do
   {
      x = Strobe(RF_SIDLE);
   }
   while ((x & 0x70) != 0x00);

   // Clear radio error register
   RF1AIFERR = 0;
}
void ReceiveOn(void)
{
  RF1AIES |= BIT9;                          // Falling edge of RFIFG9
  RF1AIFG &= ~BIT9;                         // Clear a pending interrupt
  RF1AIE  |= BIT9;                          // Enable the interrupt

  // Radio is in IDLE following a TX, so strobe SRX to enter Receive Mode
  Strobe( RF_SRX );
}
Example #4
0
void rxtx_finish_isr()
{
    //Disable interrupts
    radioDisableGDO0Interrupt();
    radioDisableGDO2Interrupt();

    if (init_and_close_radio)
    {
        //Flush FIFOs and go to sleep
        Strobe(RF_SIDLE);
        Strobe(RF_SFRX);
        Strobe(RF_SFTX);
        Strobe(RF_SPWD);

        //Set radio state
        state = Idle;
    }
}
Example #5
0
void Joystick::write(unsigned char value)
{
	if (((value & 1) == 1) && (StrobeOnNext == false))
		StrobeOnNext = true;
	else if (((value & 1) == 0) && (StrobeOnNext == true))
	{
		Strobe();
		StrobeOnNext = false;
	}
}
void Transmit(unsigned char *buffer, unsigned char length)
{
  RF1AIES |= BIT9;
  RF1AIFG &= ~BIT9;                         // Clear pending interrupts
  RF1AIE |= BIT9;                           // Enable TX end-of-packet interrupt

  WriteBurstReg(RF_TXFIFOWR, buffer, length);

  Strobe( RF_STX );                         // Strobe STX
}
Example #7
0
void ReceiveOn(void)
{  
  RF1AIES &= ~BIT9; 
  RF1AIFG = 0;                              // Clear pending RFIFG interrupts
  RF1AIE  |= BIT9;                          // Enable the sync word received interrupt
  
  // Radio is in IDLE following a TX, so strobe SRX to enter Receive Mode
  Strobe( RF_SRX );        
  
  __no_operation(); 
}
Example #8
0
bool phy_init_tx()
{
    if(get_radiostate() != Idle)
    {
#ifdef LOG_PHY_ENABLED
        log_print_stack_string(LOG_PHY, "PHY radio not idle");
#endif

        return false;
    }

    //Set radio state
    state = Transmit;

    //Go to idle and flush the txfifo
    Strobe(RF_SIDLE);
    Strobe(RF_SFTX);

    return true;
}
void ReceiveOn(void)
{   

  RF1AIES |= BIT9;                          // Falling edge of RFIFG9
  RF1AIFG &= ~BIT9;                         // Clear a pending interrupt
  RF1AIE  |= BIT9;                          // Enable the interrupt 
 // P3OUT |= BIT1;
  // Radio is in IDLE following a TX, so strobe SRX to enter Receive Mode
  while( !(RF1AIFCTL1 & RFINSTRIFG));
  Strobe( RF_SRX );                      
}
Example #10
0
byte RADIOClass::ReceiveData(byte *rxBuffer)
{
	byte size;
	byte status[2];

	if(ReadStatusReg(RADIO_RXBYTES) & BURST_BYTES_IN_TXFIFO)  // 0x7F MULTIPLE TRY PRESENT BF
	{
		size=ReadSingleReg(RADIO_RXFIFO);
		ReadBurstReg(RADIO_RXFIFO,rxBuffer,size);
		ReadBurstReg(RADIO_RXFIFO,status,2);
		Strobe(RADIO_SFRX);
		return size;
	}
	else
	{
		Strobe(RADIO_SFRX);
		return 0;
	}
	
}
Example #11
0
unsigned char Joystick::read()
{
	char BitReturn = BitStream[BitIndex];
	BitIndex++;

	// Check to see if read past the joysticks data.  Not likely that this
	// will happen but its possible.
	if (BitIndex >= 24)
		Strobe();

	return BitReturn;
}
Example #12
0
void Init_RF(void){
  
  // Increase PMMCOREV level to 2 in order to avoid low voltage error 
  // when the RF core is enabled
  SetVCore(2);
  ResetRadioCore();     
  WriteBurstReg(IOCFG2, (unsigned char*)RF1A_REGISTER_CONFIG, CONF_REG_SIZE);
  WritePATable();
  InitButtonLed();
  ReceiveOn();  
  //Wait for RX status to be reached
  while((Strobe(RF_SNOP) & 0x70) != 0x10);
  
}
Example #13
0
//------------------------------------------------------------------------------
//  void pktRxHandler(void)
//
//  DESCRIPTION:
//      This function is called every time a timer interrupt occurs. The 
//      function starts by retreiving the status byte. Every time the status 
//      byte indicates that there are available bytes in the RX FIFO, bytes are 
//      read from the RX FIFO and written to RxBuffer. This is done until the 
//      whole packet is received. If the status byte indicates that there has 
//      been an RX FIFO overflow the RX FIFO is flushed. Please see the 
//      EM430F5137RF900 RF Examples User Manual for a flow chart describing this 
//      function.
//------------------------------------------------------------------------------
void pktRxHandler(void) {
  unsigned char RxStatus;
  unsigned char bytesInFifo;
  
  // Which state?
  RxStatus = Strobe(RF_SNOP);
  
  switch(RxStatus & CC430_STATE_MASK)
  {
    case CC430_STATE_RX:
      // If there's anything in the RX FIFO....
      if (bytesInFifo = MIN(rxBytesLeft, RxStatus & CC430_FIFO_BYTES_AVAILABLE_MASK))
      {         
        if((rxBytesLeft == PACKET_LEN + 2) && !lengthByteRead)
        {
          rxBytesLeft = ReadSingleReg(RXFIFO) + 2;  // For appended bytes
          lengthByteRead = 1; 
        }
        // Update how many bytes are left to be received
        rxBytesLeft -= bytesInFifo;
  
        // Read from RX FIFO and store the data in rxBuffer
        while (bytesInFifo--) {
          RxBuffer[rxPosition] = ReadSingleReg(RXFIFO);
          rxPosition++; 
        }  
        if (!rxBytesLeft){           
            packetReceived = 1; 
            receiving = 0;
            lengthByteRead = 0; 
            ReceiveOff();
            
            P1OUT ^= BIT0;                    // Toggle LED1             
        }      
      } 
      break;
    default:
      if(!packetReceived)
      {
        packetReceived = 1; 
      }
      
      rxBytesLeft = 0;
      receiving = 0; 
      ReceiveOff();

      break;  
  }
} // pktRxHandler
Example #14
0
// send data
extern bool phy_tx_data(phy_tx_cfg_t* cfg)
{

    //TODO Return error if fec not enabled but requested
#ifdef D7_PHY_USE_FEC
    if (fec) {
        //Initialize fec encoding
        fec_init_encode(cfg->data);

        //Configure length settings
        set_length_infinite(true);
        fec_set_length(cfg->length);
        remainingBytes = ((cfg->length & 0xFE) + 2) << 1;
        WriteSingleReg(PKTLEN, (uint8_t)(remainingBytes & 0x00FF));
    } else {
#endif

        //Set buffer position
        bufferPosition = cfg->data;

        //Configure length settings
        set_length_infinite(false);
        remainingBytes = cfg->length;
        WriteSingleReg(PKTLEN, (uint8_t)remainingBytes);
#ifdef D7_PHY_USE_FEC
    }
#endif


    //Write initial data to txfifo
    tx_data_isr();
    //Configure txfifo threshold
    WriteSingleReg(FIFOTHR, RADIO_FIFOTHR_FIFO_THR_17_48);

    //Enable interrupts
    radioClearInterruptPendingLines();
    phy_set_gdo_values(GDOLine2, GDO_EDGE_TXBelowThresh, GDO_SETTING_TXBelowThresh);
//	phy_set_gdo_values(GDOLine2, GDO_EDGE_TXUnderflow, GDO_SETTING_TXUnderflow);
    phy_set_gdo_values(GDOLine0, GDO_EDGE_EndOfPacket, GDO_SETTING_EndOfPacket);
    radioEnableGDO2Interrupt();
    radioEnableGDO0Interrupt();

    //Start transmitting
    Strobe(RF_STX);

    return true;
}
Example #15
0
extern int16_t phy_get_rssi(uint8_t spectrum_id, uint8_t sync_word_class)
{
    uint8_t rssi_raw = 0;

    if (!phy_translate_and_set_settings(spectrum_id, sync_word_class))
        return false;


    //Start receiving
    Strobe(RF_SRX);

    //FIXME wait for RSSI VALID!!!
    // Is this possible with CC1101?

    rssi_raw = ReadSingleReg(RSSI);
    rxtx_finish_isr();

    return calculate_rssi(rssi_raw);
}
Example #16
0
void TransmitPacket(void)
{  
  P3OUT |= BIT6;                        // Pulse LED during Transmit 

  txBytesLeft = PACKET_LEN;   
  txPosition = 0; 
  packetTransmit = 0; 
  transmitting = 1;       
  
  Strobe( RF_STX );                         // Strobe STX   
  
  TA0CCR1   = TX_TIMER_PERIOD;              // x cycles * 1/32768 = y us
  TA0CCTL1 |= CCIE; 
  TA0CTL |= MC_2 + TACLR;                   // Start the timer- continuous mode   

  __bis_SR_register(LPM3_bits + GIE); 
  __no_operation(); 
  
  TA0CCR1 = TX_TIMER_PERIOD;             // x cycles * 1/32768 = y us
  TA0CCTL1 &= ~(CCIE); 
  TA0CTL &= ~(MC_3);                  // Turn off timer         

  P3OUT &= ~BIT6;                     // Turn off LED after Transmit               
}
Example #17
0
u8 NRF24L01_FlushRx()
{
    return Strobe(FLUSH_RX);
}
void main()
{
	system_init(buffer, sizeof(buffer), buffer, sizeof(buffer));
#if RF == CC1101 || RF == CC1120
	spi_init();
#endif

	ResetRadioCore();
	int p = ReadSingleReg(PARTNUM);
	log_print_string("PARTNUM 0x%x", p);
	p = ReadSingleReg(VERSION);
	log_print_string("VERSION 0x%x", p);
	log_print_string("started");

	WriteRfSettings(&rfSettings);
//	WriteSingleReg(IOCFG2,0x0B);    //GDO2 Output Pin Configuration
//	WriteSingleReg(IOCFG0,0x0C);    //GDO0 Output Pin Configuration
//	WriteSingleReg(FIFOTHR,0x47);   //RX FIFO and TX FIFO Thresholds
//	WriteSingleReg(PKTCTRL0,0x22);  //Packet Automation Control
//	WriteSingleReg(FSCTRL1,0x08);   //Frequency Synthesizer Control
//	WriteSingleReg(FREQ2,0x10);     //Frequency Control Word, High Byte
//	WriteSingleReg(FREQ1,0xB1);     //Frequency Control Word, Middle Byte
//	WriteSingleReg(FREQ0,0x3A);     //Frequency Control Word, Low Byte
//	WriteSingleReg(MDMCFG4,0xCA);   //Modem Configuration
//	WriteSingleReg(MDMCFG3,0x83);   //Modem Configuration
//	WriteSingleReg(MDMCFG2,0xB0);   //Modem Configuration
//	WriteSingleReg(DEVIATN,0x35);   //Modem Deviation Setting
//	WriteSingleReg(MCSM0,0x18);     //Main Radio Control State Machine Configuration
//	WriteSingleReg(FOCCFG,0x16);    //Frequency Offset Compensation Configuration
//	WriteSingleReg(AGCCTRL2,0x43);  //AGC Control
//	WriteSingleReg(WORCTRL,0xFB);   //Wake On Radio Control
//	WriteSingleReg(FREND0,0x11);    //Front End TX Configuration
//	WriteSingleReg(FSCAL3,0xE9);    //Frequency Synthesizer Calibration
//	WriteSingleReg(FSCAL2,0x2A);    //Frequency Synthesizer Calibration
//	WriteSingleReg(FSCAL1,0x00);    //Frequency Synthesizer Calibration
//	WriteSingleReg(FSCAL0,0x1F);    //Frequency Synthesizer Calibration
//	WriteSingleReg(TEST2,0x81);     //Various Test Settings
//	WriteSingleReg(TEST1,0x35);     //Various Test Settings
//	WriteSingleReg(TEST0,0x09);     //Various Test Settings
//	WriteSingleReg(RSSI,0x80);      //Received Signal Strength Indication
//	WriteSingleReg(MARCSTATE,0x01); //Main Radio Control State Machine State
//	WriteSingleReg(VCO_VC_DAC,0x94);//Current Setting from PLL Calibration Module

	//phy_keep_radio_on(true);

	Strobe(RF_SIDLE);
	Strobe(RF_SFTX);

	//uint8_t spectrum_id[2] = { 4, 0 };
	//phy_translate_and_set_settings(spectrum_id, 0);

	//set_length_infinite(false);
	//WriteSingleReg(PKTLEN, 7);

	Strobe(RF_STX);

	//WriteSingleReg(PKTCTRL0, 0x22);

	//WriteSingleReg(FIFOTHR, RADIO_FIFOTHR_FIFO_THR_17_48);

	//WriteBurstReg(RF_TXFIFOWR, packet, 7);




	/*
	ResetRadioCore();
	log_state();
	Strobe(RF_SIDLE);
	WriteRfSettings(&rfSettings);
	log_print_string("wrote settings");
	log_state();
	Strobe(RF_STX);
	log_print_string("strobed TX");
	*/

	int i;
	for(i = 0; i < 50;i++)
	{
		log_state();
	}



	while(1);
}
Example #19
0
u8 NRF24L01_FlushTx()
{
    return Strobe(FLUSH_TX);
}
Example #20
0
bool phy_rx(phy_rx_cfg_t* cfg)
{
#ifdef LOG_PHY_ENABLED
    log_print_stack_string(LOG_PHY, "phy_rx");
#endif

    RadioState current_state = get_radiostate();
    if(current_state != Idle && current_state != Receive)
    {
#ifdef LOG_PHY_ENABLED
        log_print_stack_string(LOG_PHY, "PHY Cannot RX, PHy not idle");
#endif
        return false;
    }

    //Set radio state
    state = Receive;

    //Flush the txfifo
    Strobe(RF_SIDLE);
    Strobe(RF_SFRX);

    //Set configuration

    if (!phy_translate_and_set_settings(cfg->spectrum_id, cfg->sync_word_class))
        return false;

    set_timeout(cfg->timeout);

//TODO Return error if fec not enabled but requested
#ifdef D7_PHY_USE_FEC
    if (fec) {
        //Disable hardware data whitening
        set_data_whitening(false);

        //Initialize fec encoding
        fec_init_decode(buffer);

        //Configure length settings
        set_length_infinite(true);

        if(cfg->length == 0)
        {
            packetLength = 0;
            remainingBytes = 0;
            WriteSingleReg(PKTLEN, 0xFF);
            WriteSingleReg(FIFOTHR, RADIO_FIFOTHR_FIFO_THR_61_4);
        } else {
            fec_set_length(cfg->length);
            packetLength = ((cfg->length & 0xFE) + 2) << 1;
            remainingBytes = packetLength;
            WriteSingleReg(PKTLEN, (uint8_t)(packetLength & 0x00FF));
            WriteSingleReg(FIFOTHR, RADIO_FIFOTHR_FIFO_THR_17_48);
        }
    } else {
#endif
        //Enable hardware data whitening
        set_data_whitening(true);

        //Set buffer position
        bufferPosition = buffer;

        //Configure length settings and txfifo threshold
        set_length_infinite(false);

        if(cfg->length == 0)
        {
            packetLength = 0;
            remainingBytes = 0;
            WriteSingleReg(PKTLEN, 0xFF);
            WriteSingleReg(FIFOTHR, RADIO_FIFOTHR_FIFO_THR_61_4);
        } else {
            packetLength = cfg->length;
            remainingBytes = packetLength;
            WriteSingleReg(PKTLEN, packetLength);
            WriteSingleReg(FIFOTHR, RADIO_FIFOTHR_FIFO_THR_17_48);
        }
#ifdef D7_PHY_USE_FEC
    }
#endif

    //TODO: set minimum sync word rss to scan minimum energy
    //Enable interrupts
    phy_set_gdo_values(GDOLine2, GDO_EDGE_RXFilled, GDO_SETTING_RXFilled);
    phy_set_gdo_values(GDOLine0, GDO_EDGE_EndOfPacket, GDO_SETTING_EndOfPacket);
    radioClearInterruptPendingLines();
    radioEnableGDO2Interrupt();
    radioEnableGDO0Interrupt();

    //Start receiving
    Strobe(RF_SRX);

    return true;
}
Example #21
0
int main(void)
{
    //TURN OFF POWER TO THINGS I DON'T NEED
    ADCSRA = 0; //DISABLE ADC
    PRR0 = _BV(PRTWI) | _BV(PRADC) | _BV(PRSPI); //TURN OFF POWER TO ADC, TWI, SPI

    //SET UP GP TIMER
    TCCR2A = _BV(WGM21); //CTC MODE
    TCCR2B = _BV(CS20) | _BV(CS21) | _BV(CS22); // /1024 prescale
    TIMSK2 = _BV(OCIE2A); // CTCIE
    OCR2A = 155;  //100.16026 Hz (~10mS)

    //SET UP STATUS LED
    CONFIG_LED();

    /////////////////////////////////////////
    //SET UP STATE ENUMS
    enum D_State {SERIAL_DEBUG, NORMAL};
    enum V_State {INIT, WAIT, RUN, ERROR};
    enum V_NextState {LOWER, HEADLOWER, BODYTWITCH, INTERMISSION1, RAISE, HEADRAISE, HEADTILT, LOWERTILTROD, \
    LOWERHOIST, INTERMISSION2};

    //SET UP TIMING CONSTANTS
    //*_LONG = 0.5 SECONDS
    //*_SHORT = 10mS
    const uint16_t CHOP_PAUSE_LONG = SETTIMERSEC(20); //pause between intermission and blade lower
    const uint16_t HEAD_DROP_PAUSE_LONG = 1; ///////////turn to short
    const uint16_t BODY_TWITCH_START_PAUSE_LONG = 0; //////////turn to short
    const uint16_t INTERMISSION1_PAUSE_LONG = SETTIMERMIN(1); //pause between reset and lower
    const uint16_t RAISE_PAUSE_LONG = SETTIMERSEC(30); //pause after blade lower to raise again
    const uint16_t HEAD_RAISE_PAUSE_LONG = SETTIMERSEC(15); //pause after blade raised to raise head
    const uint16_t HEAD_TILT_PAUSE_LONG = SETTIMERSEC(1); //pause after head raise to tilt head into lock
    const uint16_t LOWER_TILT_ROD_PAUSE_LONG = SETTIMERSEC(1); //pause between reset and lower
    const uint16_t LOWER_HOIST_PAUSE_LONG = 0; //pause between reset and lower
    const uint16_t INTERMISSION2_PAUSE_LONG = SETTIMERMIN(1); //pause between reset and lower


    //SET UP GUILLOTINE OBJECTS
    DebugSerial DBSerial = DebugSerial(115200);
    MusicSerial myMusic = MusicSerial(38400);
    Blade myBlade = Blade(ptr_Timer);
    Head myHead = Head(ptr_Timer);
    Button myButton = Button(ptr_Timer);
    Strobe myStrobe = Strobe(ptr_Timer);
    Body myBody = Body(ptr_Timer);
    //Guy myGuy = Guy(ptr_Timer);
    //Music myMusic = Music();

    //SET UP LOCAL (MAIN SCOPED) VARIABLES
    D_State debugMode = NORMAL; //STARTS UP IN NORMAL MODE
    V_State state = INIT;       //INITIAL MAIN STATE
    V_NextState nextState = LOWER;  //HOLDS NEXT RUN STATE
    uint16_t longTime = 0;      //HOLDS SECONDS
    uint8_t forceNextState = 0; //FLAG THAT BUTTON PRESS WHILE IN WAIT STATE
    uint8_t pollState = 0;      //HOLDS POLLING INFO (WORKING, COMPLETE, ERROR)
    uint16_t nextWaitTime = 0;  //HOLDS PAUSE TO NEXT RUN STATE
    uint8_t errorTry = 0;

    sei();

    if (myButton.read()) debugMode = SERIAL_DEBUG;

    #ifdef DEBUG
        debugMode = SERIAL_DEBUG;
    #endif // DEBUG

    #ifdef SND_STARTUP
        myMusic.playHold(SND_STARTUP, &myButton);
    #endif // SND_STARTUP

    while(1)
    {
        if (DBSerial.available())
        {
            if (DBSerial.read() == 'D') debugMode = SERIAL_DEBUG;
        }

        switch (debugMode)
        {
        case NORMAL:

            switch (state)
            {
            //INIT: SET GUILLOTINE TO DEFAULT POSITIONS
            //      BLADE UP, HEAD UP, HEAD TILT UP
            case INIT:
            {
                LED_OFF();
                #ifdef SND_ENTERINIT
                    myMusic.playHold(SND_ENTERINIT, &myButton);
                #endif // SND_ENTERINIT
                if (myBlade.init() == Blade::ERROR)        //MOVE BLADE TO UP POSITION
                {
                    state = ERROR;
                    break;
                }
                else if (myHead.init() == Head::ERROR)   //MOVE HEAD TILT ROD TO HOME POSITION
                {
                    state = ERROR;
                    break;
                }
                else if (myBody.init() == Body::ERROR)    //MAKE SURE LEGS WORKING
                {
                    state = ERROR;
                    break;
                }
                //if (myGuy.isGuyHere()) myGuy.init();
                myStrobe.init();
                #ifdef SND_LEAVEINIT
                    myMusic.playHold(SND_LEAVEINIT, &myButton);
                #endif // SND_LEAVEINIT
                state = WAIT;
                nextState = LOWER;
                nextWaitTime = CHOP_PAUSE_LONG;
                #ifdef SND_LOWER_BEFORE
                    myMusic.playHold(SND_LOWER_BEFORE, &myButton);
                #endif // SND_LOWER_BEFORE
                setTimer(); //SO WAIT STATE STARTS WITH TIMER AT 0
                break;
            }
            //WAIT: WAIT UNTIL TIME TO DO nextState
            //      IF BUTTON PRESS, MOVE TO NEXT STATE NOW

            case WAIT:
                if (getTimer() >= 50) //Increment longTime at 1/2 second interval
                {
                    longTime++;
                    setTimer();
                }
                forceNextState = myButton.read();
                if (longTime >= nextWaitTime || forceNextState)
                {
                    state = RUN;
                    longTime = 0;
                }
                break;
            case RUN:
            {
                switch (nextState)
                {
                case LOWER:
                    #ifdef SND_LOWER_ON
                        myMusic.trigger(SND_LOWER_ON);
                    #endif // SND_LOWER_ON

/*                     pollState = Guy::WORKING;
 *                     myGuy.pullLeverPoll(Guy::RESET);
 *                     while (pollState != Guy::COMPLETE && pollState != Guy::ERROR)
 *                     {
 *                         pollState = myGuy.pullLeverPoll();
 *                         if(myButton.read())
 *                         {
 *                             break;
 *                         }
 *                     }
 */

                    pollState = Blade::WORKING;
                    myBlade.lowerBladePoll(Blade::RESET);
                    while (pollState != Blade::COMPLETE && pollState != Blade::ERROR)
                    {
                        pollState = myBlade.lowerBladePoll();
                        if(myButton.read())
                        {
                            pollState = Blade::ERROR;
                            break;
                        }
                    }
                    if (pollState == Blade::ERROR)
                    {
                        state = ERROR;
                    }

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_LOWER_AFTER
                            myMusic.trigger(SND_LOWER_AFTER);
                        #endif // SND_LOWER_AFTER
                        state = WAIT;
                        nextState = HEADLOWER;
                        nextWaitTime = HEAD_DROP_PAUSE_LONG;
                        #ifdef SND_HEAD_LOWER_BEFORE
                            myMusic.trigger(SND_HEAD_LOWER_BEFORE);
                        #endif // SND_HEAD_LOWER_BEFORE
                    }
                    break;

                case HEADLOWER:
                    #ifdef SND_HEAD_LOWER_ON
                        myMusic.playHold(SND_HEAD_LOWER_ON, &myButton);
                    #endif // SND_HEAD_LOWER_ON
                    pollState = Head::WORKING;
                    myHead.lowerHeadPoll(Head::RESET);
                    while (pollState != Head::COMPLETE && pollState != Head::ERROR)
                    {
                        pollState = myHead.lowerHeadPoll();
                        if(myButton.read())
                        {
                            pollState = Head::ERROR;
                            break;
                        }
                    }
                    if (pollState == Head::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_HEAD_LOWER_AFTER
                            myMusic.playHold(SND_HEAD_LOWER_AFTER, &myButton);
                        #endif // SND_HEAD_LOWER_AFTER
                        state = WAIT;
                        nextState = BODYTWITCH;
                        nextWaitTime = BODY_TWITCH_START_PAUSE_LONG;
                        #ifdef SND_BODY_BEFORE
                            myMusic.trigger(SND_BODY_BEFORE);
                        #endif // SND_BODY_BEFORE
                    }
                    break;

                case BODYTWITCH:
                    #ifdef SND_BODY_ON
                        myMusic.trigger(SND_BODY_ON);
                    #endif // SND_BODY_ON
                    //myBody.bodyTwitch();
                    pollState = Body::WORKING;
                    myBody.bodyKickPoll(Body::RESET);
                    while (pollState != Body::COMPLETE && pollState != Body::ERROR)
                    {
                        pollState = myBody.bodyKickPoll();
                        if(myButton.read())
                        {
                            pollState = Body::ERROR;
                            break;
                        }
                    }
                    if (pollState == Body::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_BODY_AFTER
                            myMusic.trigger(SND_BODY_AFTER);
                        #endif // SND_BODY_AFTER
                        state = WAIT;
                        nextState = INTERMISSION1;
                        nextWaitTime = INTERMISSION1_PAUSE_LONG;
                        #ifdef SND_INT1_BEFORE
                            myMusic.trigger(SND_INT1_BEFORE);
                        #endif // SND_INT1_BEFORE
                    }
                    break;

                case INTERMISSION1:
                    #ifdef SND_INT1_ON
                        myMusic.trigger(SND_INT1_ON);
                    #endif // SND_INT1_ON

                    myStrobe.strobeOn();
                    pollState = Body::WORKING;
                    myBody.bodyKickPoll(Body::RESET);
                    while (pollState != Body::COMPLETE && pollState != Body::ERROR)
                    {
                        pollState = myBody.bodyKickPoll();
                        if(myButton.read())
                        {
                            pollState = Body::ERROR;
                            break;
                        }
                    }
                    myStrobe.strobeOff();

                    #ifdef SND_INT1_AFTER
                        myMusic.trigger(SND_INT1_AFTER);
                    #endif // SND_INT1_AFTER

                    state = WAIT;
                    nextState = RAISE;
                    nextWaitTime = RAISE_PAUSE_LONG;
                    #ifdef SND_RAISE_BEFORE
                        myMusic.trigger(SND_RAISE_BEFORE);
                    #endif // SND_RAISE_BEFORE
                    break;

                case RAISE:
                    #ifdef SND_RAISE_ON
                        myMusic.trigger(SND_RAISE_ON);
                    #endif // SND_RAISE_ON

/*                     pollState = Guy::WORKING;
 *                     myGuy.resetLeverPoll(Guy::RESET);
 *                     while (pollState != Guy::COMPLETE && pollState != Guy::ERROR)
 *                     {
 *                         pollState = myGuy.resetLeverPoll();
 *                         if(myButton.read())
 *                         {
 *                             break;
 *                         }
 *                     }
 */

                    pollState = Blade::WORKING;
                    myBlade.raiseBladePoll(Blade::RESET);
                    while (pollState != Blade::COMPLETE && pollState != Blade::ERROR)
                    {
                        pollState = myBlade.raiseBladePoll();
                        if(myButton.read())
                        {
                            pollState = Head::ERROR;
                            break;
                        }
                    }
                    if (pollState == Blade::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_RAISE_AFTER
                            myMusic.trigger(SND_RAISE_AFTER);
                        #endif // SND_RAISE_AFTER
                        state = WAIT;
                        nextState = HEADRAISE;
                        nextWaitTime = HEAD_RAISE_PAUSE_LONG;
                        #ifdef SND_HEAD_RAISE_BEFORE
                            myMusic.trigger(SND_HEAD_RAISE_BEFORE);
                        #endif // SND_HEAD_RAISE_BEFORE
                    }
                    break;

                case HEADRAISE:
                    #ifdef SND_HEAD_RAISE_ON
                        myMusic.trigger(SND_HEAD_RAISE_ON);
                    #endif // SND_HEAD_RAISE_ON
                    pollState = Head::WORKING;
                    myHead.raiseHeadPoll(Head::RESET);
                    while (pollState != Head::COMPLETE && pollState != Head::ERROR)
                    {
                        pollState = myHead.raiseHeadPoll();
                        if(myButton.read())
                        {
                            pollState = Head::ERROR;
                            break;
                        }
                    }
                    if (pollState == Head::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_HEAD_RAISE_AFTER
                            myMusic.trigger(SND_HEAD_RAISE_AFTER);
                        #endif // SND_HEAD_RAISE_AFTER
                        state = WAIT;
                        nextState = HEADTILT;
                        nextWaitTime = HEAD_TILT_PAUSE_LONG;
                        #ifdef SND_HEAD_TILT_BEFORE
                            myMusic.trigger(SND_HEAD_TILT_BEFORE);
                        #endif // SND_HEAD_TILT_BEFORE
                    }
                    break;

                case HEADTILT:
                    #ifdef SND_HEAD_TILT_ON
                        myMusic.trigger(SND_HEAD_TILT_ON);
                    #endif // SND_HEAD_TILT_ON
                    pollState = Head::WORKING;
                    myHead.tiltHeadUpPoll(Head::RESET);
                    while (pollState != Head::COMPLETE && pollState != Head::ERROR)
                    {
                        pollState = myHead.tiltHeadUpPoll();
                        if(myButton.read())
                        {
                            pollState = Head::ERROR;
                            break;
                        }
                    }
                    if (pollState == Head::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_HEAD_TILT_AFTER
                            myMusic.playHold(SND_HEAD_TILT_AFTER, &myButton);
                        #endif // SND_HEAD_TILT_AFTER
                        state = WAIT;
                        nextState = LOWERTILTROD;
                        nextWaitTime = LOWER_TILT_ROD_PAUSE_LONG;
                        #ifdef SND_LOWER_TILT_BEFORE
                            myMusic.trigger(SND_LOWER_TILT_BEFORE);
                        #endif // SND_LOWER_TILT_BEFORE
                    }
                    break;

                case LOWERTILTROD:
                    #ifdef SND_LOWER_TILT_ON
                        myMusic.trigger(SND_LOWER_TILT_ON);
                    #endif // SND_LOWER_TILT_ON
                    pollState = Head::WORKING;
                    myHead.tiltRodDownPoll(Head::RESET);
                    while (pollState != Head::COMPLETE && pollState != Head::ERROR)
                    {
                        pollState = myHead.tiltRodDownPoll();
                        if(myButton.read())
                        {
                            pollState = Head::ERROR;
                            break;
                        }
                    }
                    if (pollState == Head::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_LOWER_TILT_AFTER
                            myMusic.trigger(SND_LOWER_TILT_AFTER);
                        #endif // SND_LOWER_TILT_AFTER
                        state = WAIT;
                        nextState = LOWERHOIST;
                        nextWaitTime = LOWER_HOIST_PAUSE_LONG;
                        #ifdef SND_LOWER_HOIST_BEFORE
                            myMusic.trigger(SND_LOWER_HOIST_BEFORE);
                        #endif // SND_LOWER_HOIST_BEFORE
                    }
                    break;

                case LOWERHOIST:
                    #ifdef SND_LOWER_HOIST_ON
                        myMusic.trigger(SND_LOWER_HOIST_ON);
                    #endif // SND_LOWER_HOIST_ON
                    pollState = Head::WORKING;
                    myHead.lowerHoistPoll(Head::RESET);
                    while (pollState != Head::COMPLETE && pollState != Head::ERROR)
                    {
                        pollState = myHead.lowerHoistPoll();
                        if(myButton.read())
                        {
                            pollState = Head::ERROR;
                            break;
                        }
                    }
                    if (pollState == Head::ERROR) state = ERROR;

                    ////GOTO NEXT STATE AND SETUP NEXT EVENT
                    else
                    {
                        #ifdef SND_LOWER_HOIST_AFTER
                            myMusic.trigger(SND_LOWER_HOIST_AFTER);
                        #endif // SND_LOWER_HOIST_AFTER
                        state = WAIT;
                        nextState = INTERMISSION2;
                        nextWaitTime = INTERMISSION2_PAUSE_LONG;
                        #ifdef SND_INT2_BEFORE
                            myMusic.trigger(SND_INT2_BEFORE);
                        #endif // SND_INT2_BEFORE
                    }
                    break;

                case INTERMISSION2:
                    #ifdef SND_INT2_ON
                        myMusic.trigger(SND_INT2_ON);
                    #endif // SND_INT2_ON

                    myStrobe.strobeOn();
                    myStrobe.strobeOn();
                    pollState = Body::WORKING;
                    myBody.bodyKickPoll(Body::RESET);
                    while (pollState != Body::COMPLETE && pollState != Body::ERROR)
                    {
                        pollState = myBody.bodyKickPoll();
                        if(myButton.read())
                        {
                            pollState = Body::ERROR;
                            break;
                        }
                    }
                    myStrobe.strobeOff();

                    #ifdef SND_INT2_AFTER
                        myMusic.trigger(SND_INT2_AFTER);
                    #endif // SND_INT2_AFTER

                    state = WAIT;
                    nextState = LOWER;
                    nextWaitTime = CHOP_PAUSE_LONG;
                    #ifdef SND_LOWER_BEFORE
                        myMusic.playHold(SND_LOWER_BEFORE, &myButton);
                    #endif // SND_LOWER_BEFORE
                    break;
                }
                break;
            }
            case ERROR:
                if (errorTry <= NUM_OF_ERROR_TRY)
                {
                    errorTry++;
                    #ifdef SND_OOPS
                        myMusic.playHold(SND_OOPS, &myButton);
                    #endif // SND_OOPS
                    state = RUN;
                    break;
                }
                else
                {
                    errorTry = 0;
                    LED_ON();
                    myMusic.stop();
                    myBlade.turnOff();
                    myHead.turnOff();
                    myBody.turnOff();
                    myStrobe.strobeOff();

                    #ifdef SND_ENTERERROR
                        myMusic.playHold(SND_ENTERERROR, &myButton);
                    #endif // SND_ENTERERROR
                    uint8_t checkSerial = 0;

                    while (!myButton.read() && checkSerial != 'D')
                    {
                        if (DBSerial.available())
                        {
                            checkSerial = DBSerial.read();
                        }
                    }
                    if (checkSerial == 'D') debugMode = SERIAL_DEBUG;
                    else state = INIT;
                    #ifdef SND_LEAVEERROR
                        myMusic.playHold(SND_LEAVEERROR, &myButton);
                    #endif // SND_LEAVEERROR
                }
                    break;
        }
            break;

        case SERIAL_DEBUG:
            LED_OFF();
            #ifdef SND_ENTERDEBUG
                myMusic.playHold(SND_ENTERDEBUG, &myButton);
            #endif // SND_ENTERDEBUG

            DBSerial.println(const_cast <char*> ("\n\r[--DBMode--]"));

            myBlade.printDebug(&DBSerial);
            myHead.printDebug(&DBSerial);
            myBody.printDebug(&DBSerial);
            DBSerial.println(const_cast <char*> ("\n\r---"));

            while (debugMode == SERIAL_DEBUG && !myButton.read())
            {
                if (DBSerial.available())
                {
                    switch (DBSerial.read())
                    {
                    case 'd':
                        debugMode = NORMAL;
                        break;

                    case 'e':
                        myBlade.printDebug(&DBSerial);
                        myHead.printDebug(&DBSerial);
                        myBody.printDebug(&DBSerial);
                        DBSerial.println(const_cast <char*> ("\n\r---"));
                        break;

                    case 32: //SPACEBAR
                        DBSerial.println(const_cast <char*> ("[B]lade up / [b]lade down"));
                        DBSerial.println(const_cast <char*> ("[M]ag on / [m]ag off"));
                        DBSerial.println(const_cast <char*> ("[H]ead up / [h]ead down"));
                        DBSerial.println(const_cast <char*> ("h[O]ist down"));
                        DBSerial.println(const_cast <char*> ("[T]ilt up / [t]ilt down"));
                        DBSerial.println(const_cast <char*> ("head [R]elease on / [r]elease off"));
                        DBSerial.println(const_cast <char*> ("bod[Y] on / bod[y] off"));
                        DBSerial.println(const_cast <char*> ("[S]trobe on / [s]trobe off"));
                        DBSerial.println(const_cast <char*> ("[L]ed on / [l]ed off"));
                        DBSerial.println(const_cast <char*> ("m[U]sic on / off"));
                        DBSerial.println(const_cast <char*> ("[N]ext track / [P]rev track"));
                        //DBSerial.println(const_cast <char*> ("[A]rm Pull / [a]reset arm"));
                        DBSerial.println(const_cast <char*> ("d[e]bug info"));

                        break;

/*                     case 'A':
 *                         DBSerial.print(const_cast <char*> ("Arm Pull.."));
 *                         pollState = Guy::WORKING;
 *                         myGuy.pullLeverPoll(Guy::RESET);
 *                         while (pollState != Guy::COMPLETE && pollState != Guy::ERROR) pollState = myGuy.pullLeverPoll();
 *                         if (pollState == Guy::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
 *                         else DBSerial.println(const_cast <char*> ("Error"));
 *                         break;
 *
 *                     case 'a':
 *                         DBSerial.print(const_cast <char*> ("Arm Reset.."));
 *                         pollState = Guy::WORKING;
 *                         myGuy.resetLeverPoll(Guy::RESET);
 *                         while (pollState != Guy::COMPLETE && pollState != Guy::ERROR) pollState = myGuy.resetLeverPoll();
 *                         if (pollState == Guy::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
 *                         else DBSerial.println(const_cast <char*> ("Error"));
 *                         break;
 */

                    case 'B':
                        DBSerial.print(const_cast <char*> ("Blade Up.."));
                        pollState = Blade::WORKING;
                        myBlade.raiseBladePoll(Blade::RESET);
                        while (pollState != Blade::COMPLETE && pollState != Blade::ERROR) pollState = myBlade.raiseBladePoll();
                        if (pollState == Blade::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 'b':
                        DBSerial.print(const_cast <char*> ("Blade Down.."));
                        pollState = Blade::WORKING;
                        myBlade.lowerBladePoll(Blade::RESET);
                        while (pollState != Blade::COMPLETE && pollState != Blade::ERROR) pollState = myBlade.lowerBladePoll();
                        if (pollState == Blade::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 'M':
                        DBSerial.println(const_cast <char*> ("Mag On"));
                        myBlade.mag(1);
                        break;

                    case 'm':
                        DBSerial.println(const_cast <char*> ("Mag Off"));
                        myBlade.mag(0);
                        break;

                    case 'H':
                        DBSerial.print(const_cast <char*> ("Head Up.."));
                        pollState = Head::WORKING;
                        myHead.raiseHeadPoll(Head::RESET);
                        while (pollState != Head::COMPLETE && pollState != Head::ERROR) pollState = myHead.raiseHeadPoll();
                        if (pollState == Head::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 'h':
                        DBSerial.print(const_cast <char*> ("Head Down.."));
                        pollState = Head::WORKING;
                        myHead.lowerHeadPoll(Head::RESET);
                        while (pollState != Head::COMPLETE && pollState != Head::ERROR) pollState = myHead.lowerHeadPoll();
                        if (pollState == Head::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 'O':
                        DBSerial.print(const_cast <char*> ("Hoist Down.."));
                        pollState = Head::WORKING;
                        myHead.lowerHoistPoll(Head::RESET);
                        while (pollState != Head::COMPLETE && pollState != Head::ERROR) pollState = myHead.lowerHoistPoll();
                        if (pollState == Head::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 'T':
                        DBSerial.print(const_cast <char*> ("Tilt Up.."));
                        pollState = Head::WORKING;
                        myHead.tiltHeadUpPoll(Head::RESET);
                        while (pollState != Head::COMPLETE && pollState != Head::ERROR) pollState = myHead.tiltHeadUpPoll();
                        if (pollState == Head::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 't':
                        DBSerial.print(const_cast <char*> ("Tilt Down.."));
                        pollState = Head::WORKING;
                        myHead.tiltRodDownPoll(Head::RESET);
                        while (pollState != Head::COMPLETE && pollState != Head::ERROR) pollState = myHead.tiltRodDownPoll();
                        if (pollState == Head::COMPLETE) DBSerial.println(const_cast <char*> ("Good"));
                        else DBSerial.println(const_cast <char*> ("Error"));
                        break;

                    case 'R':
                        DBSerial.println(const_cast <char*> ("Solenoid On"));
                        myHead.sol(1);
                        break;

                    case 'r':
                        DBSerial.println(const_cast <char*> ("Solenoid Off"));
                        myHead.sol(0);
                        break;

                    case 'Y':
                        DBSerial.println(const_cast <char*> ("Body On.."));
                        //myBody.bodyTwitch();
                        myBody.bodyOn();
                        break;

                    case 'y':
                        DBSerial.println(const_cast <char*> ("Body Off.."));
                        myBody.turnOff();
                        break;

                    case 'S':
                        DBSerial.println(const_cast <char*> ("Strobe On"));
                        myStrobe.strobeOn();
                        break;

                    case 's':
                        DBSerial.println(const_cast <char*> ("Strobe Off"));
                        myStrobe.strobeOff();
                        break;

                    case 'L':
                        DBSerial.println(const_cast <char*> ("LED On"));
                        LED_ON();
                        break;

                    case 'l':
                        DBSerial.println(const_cast <char*> ("LED Off"));
                        LED_OFF();
                        break;

                    case 'U':
                        DBSerial.println(const_cast <char*> ("Music Toggle"));
                        myMusic.togglePlay();
                        break;

                    case 'N':
                        DBSerial.println(const_cast <char*> ("Next Track"));
                        myMusic.nextTrack();
                        break;

                    case 'P':
                        DBSerial.println(const_cast <char*> ("Prev Track"));
                        myMusic.prevTrack();
                        break;
                    }
                }
            }
            #ifdef SND_LEAVEDEBUG
                myMusic.playHold(SND_LEAVEDEBUG, &myButton);
            #endif // SND_LEAVEDEBUG
            state = INIT;
            debugMode = NORMAL;
            DBSerial.println(const_cast <char*> ("Exit"));
            break;
        }
    }
}
Example #22
0
File: rf1a.c Project: alkin/tidecc
// *************************************************************************************************
// @fn          ResetRadioCore
// @brief       Software reset radio core.
// @param       none
// @return      none
// *************************************************************************************************
void ResetRadioCore(void)
{
   Strobe(RF_SRES);             // Reset the Radio Core
   Strobe(RF_SNOP);             // Reset Radio Pointer
}
Example #23
0
void RADIOClass::SetReceive(void)
{
	Strobe(RADIO_SRX);
}
Example #24
0
int main(void)
{ 
   // Stop watchdog timer
   DoWatchdog(0);
   
   // sET UP aclk
   BCSCTL3 |= LFXT1S_2;
   
   // Set all pins to output to stop floating
   P1DIR = 0xFF;
   P2DIR = 0xFF;
   P3DIR = 0xFF;
    
  DoPWM();
  
  _EINT();
  
  // Determine pulse direction
  RX_PORT_DIR &= ~(RX_PIN);
  
  // leave two rx inputs
  P2DIR = (BIT1 | BIT3 | BIT4 | BIT5 | BIT6 | BIT7);
  
  P2OUT = 0xff;
  
  // red light
  P3OUT = BIT2;


  nR = nG = nB = 0x2FFF;
    
  
  // green light
  P3OUT = BIT3;
  
  while (1)
  {
    DelayMS(90);
    DoWatchdog(1);
       
    unsigned int nSig = GetWidth();

    if (nSig == 1)
    {
      P3OUT = BIT2;
      if (nCount > 10)
      {
        nMode++;
        if (nCount > 140)
        {
          nMode = 0;
        }
      }
      nCount = 0;
    }
    else
    {
       P3OUT = BIT3;
      nCount++;
    }
    
    if (nMode > 11)
    {
      nMode = 1;
    }
    
    switch (nMode)
    {
    case 0:       
      nR = nG = nB = 50;
      Headlight(0);
      break;
    case 1:
      Light(0xfe00, 0xfe00, 0xfe00, 1);
      break;
    case 2:
      Light(0xfe00, 50, 50, 0);
      break;
    case 3:
      Light(50, 0xfe00, 50, 0);
      break;
    case 4:
      Light(50, 50, 0xfe00, 0);
      break;
    case 5:
      LoopColour(); 
      break;
      
    case 6:
      ColourChange();
      break;
    case 7:
      Police(); 
      break;
    case 8:
      Strobe();
      break;
    case 9:
      Strobe2();
      break;
    case 10:
      GoMental(); 
      break;
    case 11:
      Chase();
      break;
    }   
    
  }
}
Example #25
0
void main( void )
{
  // Stop watchdog timer to prevent time out reset
  WDTCTL = WDTPW + WDTHOLD;

  // Increase PMMCOREV level to 2 in order to avoid low voltage error
  // when the RF core is enabled
  SetVCore(2);

  InitRadio();
  InitButtonLeds();
  
  Strobe( RF_SIDLE );
  Strobe(RF_SRX); 

  P2DIR |= BIT6;            // P2.6 output
  P2SEL |= BIT6;            // P2.6 select

  //add P2.0 for GD02 - clock sync to TXDATA
  P2DIR |= BIT0;            // P2.0 output
  P2SEL |= BIT0;            // P2.6 select

  //map P1.0 to GDO1 - high if RSSI above threshold
  P1DIR |= BIT0;            // P1.0 output
  P1SEL |= BIT0;            // P1. select

  PMAPPWD = 0x02D52;             // Get write-access to port mapping regs
  P2MAP6 = PM_RFGDO0;            // Map GDO0 to P2.6   
//  P2MAP0 = PM_RFGDO2;            // Map GDO2 to P2.0   
//  P1MAP0 = PM_RFGDO1;            // Map GDO1 to P1.0   
  PMAPPWD = 0x00;                // Lock Port mapping  

  // Enable timer interrupts to see if input is visible
  TA1CTL = TASSEL__SMCLK + MC_2 + TACLR;
  TA1CCTL0 = CM_3 + CCIS_1 + CAP + CCIE;

  __bis_SR_register(GIE);

  while(1);
#elif defined TEST_ASYNC_TX_MODE

  // Should serve as internal timer output (toggle rate 19.2 kHz)
  // to Radio TX input when IOCFG0 = 0x2E (high-Z)
  // NOTE: SMARTF_CC430 IOCFG0 should = 0x2E so asynchronous signal is taken from
  // the timer and not GDO0


//  TA1CCR0 = 27;
//  TA1CCR1 = 27;

  TA1CCR0 = 26;
  TA1CCR1 = 26;


  TA1CCTL0 = OUTMOD_4;
  TA1CCTL1 = OUTMOD_4;
  TA1CTL = TASSEL__SMCLK + MC_1 + TACLR;

  P2SEL |= BIT2;
  P2DIR |= BIT2;
  PMAPPWD = 0x02D52;                        // Get write-access to port mapping regs
  P2MAP2 = PM_TA1CCR0A;                       // Map CBOUT output to P2.2
  PMAPPWD = 0x00;                           // Lock Port mapping

  Strobe( RF_SIDLE );
  Strobe( RF_STX );

  //Transmit the TX waveform asynchronously
  while(1);


 #endif

  // ************NOT USED IN THIS LAB*****************************
  // Using function generator to generate asynchronous TX signal

  /*

  P2OUT |= BIT0;
  P2DIR |= BIT0;
  P2SEL |= BIT6;

  //add P2.0 for GD02 - clock sync to TXDATA
  P2DIR |= BIT0;            // P2.0 output
  P2SEL |= BIT0;            // P2.6 select


  PMAPPWD = 0x02D52;                        // Get write-access to port mapping regs
  P2MAP6 = PM_RFGDO0;                       // Map CBOUT output to P1.6

  P2MAP0 = PM_RFGDO2;            // Map GDO2 to P2.0


  PMAPPWD = 0x00;                           // Lock Port mapping
  // NOTE: SMARTRF_CC430 IOCFG0 shoud = 0x2D so asynchronous signal is taken from
  // GDO0 and not the internal timer connection

  */

}