CC430F5137: How to package the temperature data before transmiting?

Ok. Sorry for my mess coding. Now I describe it again in brief.

Step1. I get the temperature by ADC, ...... IntDegC= ((temp-1855)*667)/4096; so the IntDegC is a variable which saves the temperature right? And it is an integer, right? For example,  IntDegC=25.

Step2.  Build a  table:   unsigned char Txbuffer[1];

             Put temperature into table:  Txbuffer[0]=IntDegC;

             Transmit it:        Transmit( (unsigned char*)TxBuffer, sizeof TxBuffer);

Are these steps right?

I had tried to insert a breakpoint to check the IntDegC but it shows cannot read.

Thanks

I insert a  breakpoint below the adc_start().    Then add the IntDegC to the expression.

Since my ultimate goal is to send the temperature data.  I think the temperature measurement is no problem. So, the key is to send the data. For example, temperature=25 which is an integer.  

The original TxBuffer in this example is {OXAA,0XBB,0XCC,0XDD,0XEE}, I can see them at the receiver through ccs debugger.  However, if I change it to {1,2,3,4,5}, I can't see them.   Is that because it can only send data in hex form?  If it is, how to transform the integer to the hex?

#include "RF_Toggle_LED_Demo.h"

#define PACKET_LEN (0x05) // PACKET_LEN <= 61

#define RSSI_IDX (PACKET_LEN) // Index of appended RSSI

#define CRC_LQI_IDX (PACKET_LEN+1) // Index of appended LQI, checksum

#define CRC_OK (BIT7) // CRC_OK bit

#define PATABLE_VAL (0x51) // 0 dBm output

extern RF_SETTINGS rfSettings;

unsigned char packetReceived;

unsigned char packetTransmit;

unsigned char RxBuffer[PACKET_LEN+2];

unsigned char RxBufferLength = 0;

const unsigned char TxBuffer[PACKET_LEN]= {1,2,3,4,5};

unsigned char buttonPressed = 0;

unsigned int i = 0;

unsigned char transmitting = 0;

unsigned char receiving = 0;

void main( void )

{

// Stop watchdog timer to prevent time out reset

WDTCTL = WDTPW + WDTHOLD;

// Increase PMMCOREV level to 2 for proper radio operation

SetVCore(2);

ResetRadioCore();

InitRadio();

InitButtonLeds();

ReceiveOn();

receiving = 1;

while (1)

{

__bis_SR_register( LPM3_bits + GIE );

__no_operation();

if (buttonPressed) // Process a button press->transmit

{

P3OUT |= BIT6; // Pulse LED during Transmit

buttonPressed = 0;

P1IFG = 0;

ReceiveOff();

receiving = 0;

Transmit( (unsigned char*)TxBuffer, sizeof TxBuffer);

transmitting = 1;

P1IE |= BIT7; // Re-enable button press

}

else if(!transmitting)

{

ReceiveOn();

receiving = 1;

}

}

}

void InitButtonLeds(void)

{

// Set up the button as interruptible

P1DIR &= ~BIT7;

P1REN |= BIT7;

P1IES &= BIT7;

P1IFG = 0;

P1OUT |= BIT7;

P1IE |= BIT7;

// Initialize Port J

PJOUT = 0x00;

PJDIR = 0xFF;

// Set up LEDs

P1OUT &= ~BIT0;

P1DIR |= BIT0;

P3OUT &= ~BIT6;

P3DIR |= BIT6;

}

void InitRadio(void)

{

// Set the High-Power Mode Request Enable bit so LPM3 can be entered

// with active radio enabled

PMMCTL0_H = 0xA5;

PMMCTL0_L |= PMMHPMRE_L;

PMMCTL0_H = 0x00;

WriteRfSettings(&rfSettings);

WriteSinglePATable(PATABLE_VAL);

}

#pragma vector=PORT1_VECTOR

__interrupt void PORT1_ISR(void)

{

switch(__even_in_range(P1IV, 16))

{

case 0: break;

case 2: break; // P1.0 IFG

case 4: break; // P1.1 IFG

case 6: break; // P1.2 IFG

case 8: break; // P1.3 IFG

case 10: break; // P1.4 IFG

case 12: break; // P1.5 IFG

case 14: break; // P1.6 IFG

case 16: // P1.7 IFG

P1IE = 0; // Debounce by disabling buttons

buttonPressed = 1;

__bic_SR_register_on_exit(LPM3_bits); // Exit active

break;

}

}

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

}

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 );

}

void ReceiveOff(void)

{

RF1AIE &= ~BIT9; // Disable RX interrupts

RF1AIFG &= ~BIT9; // Clear pending IFG

// It is possible that ReceiveOff is called while radio is receiving a packet.

// Therefore, it is necessary to flush the RX FIFO after issuing IDLE strobe

// such that the RXFIFO is empty prior to receiving a packet.

Strobe( RF_SIDLE );

Strobe( RF_SFRX );

}

#pragma vector=CC1101_VECTOR

__interrupt void CC1101_ISR(void)

{

switch(__even_in_range(RF1AIV,32)) // Prioritizing Radio Core Interrupt

{

case 0: break; // No RF core interrupt pending

case 2: break; // RFIFG0

case 4: break; // RFIFG1

case 6: break; // RFIFG2

case 8: break; // RFIFG3

case 10: break; // RFIFG4

case 12: break; // RFIFG5

case 14: break; // RFIFG6

case 16: break; // RFIFG7

case 18: break; // RFIFG8

case 20: // RFIFG9

if(receiving) // RX end of packet

{

// Read the length byte from the FIFO

RxBufferLength = ReadSingleReg( RXBYTES );

ReadBurstReg(RF_RXFIFORD, RxBuffer, RxBufferLength);

// Stop here to see contents of RxBuffer

__no_operation();

// Check the CRC results

if(RxBuffer[CRC_LQI_IDX] & CRC_OK)

P1OUT ^= BIT0; // Toggle LED1

}

else if(transmitting) // TX end of packet

{

RF1AIE &= ~BIT9; // Disable TX end-of-packet interrupt

P3OUT &= ~BIT6; // Turn off LED after Transmit

transmitting = 0;

}

else while(1); // trap

break;

case 22: break; // RFIFG10

case 24: break; // RFIFG11

case 26: break; // RFIFG12

case 28: break; // RFIFG13

case 30: break; // RFIFG14

case 32: break; // RFIFG15

}

__bic_SR_register_on_exit(LPM3_bits);

}