/*Operation:
***********************************************************************************/
/***********************************************************************************
* INCLUDES
*/
#include "ioCCxx10_bitdef.h"
#include <hal_types.h>
#include <hal_defs.h>
#include <hal_cc8051.h>
#include <ioCC2510.h>
#include "bsp.h"
#include "mrfi.h"
#include "nwk_types.h"
#include "nwk_api.h"
#include "bsp_leds.h"
#include "bsp_buttons.h"
#include "bsp_extended.h"
// Define size of allocated UART RX/TX buffer (just an example)
#define SIZE_OF_UART_RX_BUFFER 50
#define SIZE_OF_UART_TX_BUFFER SIZE_OF_UART_RX_BUFFER
#define UART_TST_CHAR_1 0xA5
#define UART_TST_CHAR_2 0xB5
// Test definitions
#define UART_TST_MODE_RX
#define UART_TST_MODE_TX
// Baudrate = 57.6 kbps (U0BAUD.BAUD_M = 34, U0GCR.BAUD_E = 11)
#define UART_BAUD_M 34
#define UART_BAUD_E 11
/***********************************************************************************
* LOCAL VARIABLES
*/
// Buffer for UART RX/TX
static uint16 __xdata uartRxBuffer[SIZE_OF_UART_RX_BUFFER];
static uint16 __xdata uartTxBuffer[SIZE_OF_UART_TX_BUFFER];
// Variable for buffer indexing
static uint16 __xdata i;
// Prototype for local functions
void uart0Send(uint16* uartTxBuf, uint16 uartTxBufLength);
void uart0Receive(uint16* uartRxBuf, uint16 uartRxBufLength);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////
#define SPIN_ABOUT_QUARTER_A_SECOND NWK_DELAY(250)
#define SPIN_ABOUT_100_MS NWK_DELAY(100)
#define NUM_TX_RETRIES 3
#define NO_ACK_THRESHOLD 50
#define RSSI_UPPER_THRESHOLD -40
#define RSSI_LOWER_THRESHOLD -70
#define MINIMUM_OUTPUT_POWER 0
#define MEDIUM_OUTPUT_POWER 1
#define MAXIMUM_OUTPUT_POWER 2
#define SLEEP_31_25_US_RESOLUTION 0
#define SLEEP_1_MS_RESOLUTION 1
#define SLEEP_32_MS_RESOLUTION 2
#define SLEEP_1_S_RESOLUTION 3
#define MASTER_BUTTON 1
#define SLAVE_BUTTON 2
#define BOTH_BUTTONS 3
/***********************************************************************************
* LOCAL VARIABLES
*/
static linkID_t sLinkID;
static volatile uint8_t sSemaphore;
static uint8_t sCurrentPwrLevel;
static uint8_t sRequestPwrLevel;
static uint8_t sNoAckCount = 0;
/***********************************************************************************
* LOCAL FUNCTIONS
*/
static uint8_t sRxCallback(linkID_t);
static void sMaster(void);
static void sSlave(void);
/***********************************************************************************
* @fn main
*
* @brief This is the main entry of the SMPL link application. It sets
* random addresses for the nodes, initalises and runs
* MASTER and SLAVE tasks sequentially in an endless loop.
*
* @return none
*/
void main (void)
{
uint8_t buttonPushed;
BSP_Init();
/* Create and set random address for this device. */
addr_t lAddr;
BSP_createRandomAddress(&lAddr);
SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &lAddr);
/* Initialize SimpliciTI and provide Callback function */
SMPL_Init(sRxCallback);
/* Turn on LEDs indicating power on */
BSP_TURN_ON_LED1();
BSP_TURN_ON_LED2();
BSP_SleepFor( POWER_MODE_2, SLEEP_1_MS_RESOLUTION, 1000);
BSP_TURN_OFF_LED1();
BSP_TURN_OFF_LED2();
/* Enter PM3 until a button is pushed */
buttonPushed = BSP_SleepUntilButton( POWER_MODE_3, BOTH_BUTTONS);
if(buttonPushed==1)
sMaster();
if(buttonPushed==2)
sSlave();
while (1);
}
/***********************************************************************************
* LOCAL FUNCTIONS
*/
/***********************************************************************************
* @fn sMaster
*
* @brief Sends a packet and waits for ACK from slave.
* Blinking green led indicates packet acknowledged
* Blinking red led indicates packet not acknowledged
* Adjust output power dynamically
*
* @param none
*
* @return none
*/
static void sMaster(void)
{
uint8_t radioMsg[2], len,msg;
ioctlRadioSiginfo_t info;
sCurrentPwrLevel = MAXIMUM_OUTPUT_POWER;
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SETPWR, &sCurrentPwrLevel);
/* Continue to try to link until success */
while (SMPL_SUCCESS != SMPL_Link(&sLinkID))
{
BSP_TOGGLE_LED1();
BSP_TOGGLE_LED2();
}
BSP_TURN_OFF_LED1();
BSP_TURN_OFF_LED2();
while (1)
{
/* If SLAVE button pushed, lit both LEDs for 1 second */
if( BSP_BUTTON2() )
{
BSP_TURN_ON_LED2();
BSP_SleepFor( POWER_MODE_2, SLEEP_1_MS_RESOLUTION, 5000);
BSP_TURN_OFF_LED1();
BSP_TURN_OFF_LED2() ;
BSP_TURN_ON_LED1();
}
// Configure USART0 for Alternative 1 => Port P0 (PERCFG.U0CFG = 0)
// To avoid potential I/O conflict with USART1:
// configure USART1 for Alternative 2 => Port P1 (PERCFG.U1CFG = 1)
PERCFG = (PERCFG & ~PERCFG_U0CFG) | PERCFG_U1CFG;
// Configure relevant Port P0 pins for peripheral function:
// P0SEL.SELP0_2/3/4/5 = 1 => RX = P0_2, TX = P0_3, CT = P0_4, RT = P0_5
P0SEL |= BIT5 | BIT4 | BIT3 | BIT2;
/***************************************************************************
* Configure UART
*
* The system clock source used is the HS XOSC at 26 MHz speed.
*/
// Set system clock source to 26 Mhz XSOSC to support maximum transfer speed,
// ref. [clk]=>[clk_xosc.c]
SLEEP &= ~SLEEP_OSC_PD;
while( !(SLEEP & SLEEP_XOSC_S) );
CLKCON = (CLKCON & ~(CLKCON_CLKSPD | CLKCON_OSC)) | CLKSPD_DIV_1;
while (CLKCON & CLKCON_OSC);
SLEEP |= SLEEP_OSC_PD;
// Initialise bitrate = 57.6 kbps (U0BAUD.BAUD_M = 34, U0GCR.BAUD_E = 11)
U0BAUD = UART_BAUD_M;
U0GCR = (U0GCR&~U0GCR_BAUD_E) | UART_BAUD_E;
// Initialise UART protocol (start/stop bit, data bits, parity, etc.):
// USART mode = UART (U0CSR.MODE = 1)
U0CSR |= U0CSR_MODE;
// Start bit level = low => Idle level = high (U0UCR.START = 0)
U0UCR &= ~U0UCR_START;
// Stop bit level = high (U0UCR.STOP = 1)
U0UCR |= U0UCR_STOP;
// Number of stop bits = 1 (U0UCR.SPB = 0)
U0UCR &= ~U0UCR_SPB;
// Parity = disabled (U0UCR.PARITY = 0)
U0UCR &= ~U0UCR_PARITY;
// 9-bit data enable = 8 bits transfer (U0UCR.BIT9 = 0)
U0UCR &= ~U0UCR_BIT9;
// Level of bit 9 = 0 (U0UCR.D9 = 0), used when U0UCR.BIT9 = 1
// Level of bit 9 = 1 (U0UCR.D9 = 1), used when U0UCR.BIT9 = 1
// Parity = Even (U0UCR.D9 = 0), used when U0UCR.PARITY = 1
// Parity = Odd (U0UCR.D9 = 1), used when U0UCR.PARITY = 1
U0UCR &= ~U0UCR_D9;
// Flow control = disabled (U0UCR.FLOW = 0)
U0UCR &= ~U0UCR_FLOW;
// Bit order = LSB first (U0GCR.ORDER = 0)
U0GCR &= ~U0GCR_ORDER;
/***************************************************************************
* Transfer UART data
*/
uint16 uartRxIndex;
// Enable UART0 RX (U0CSR.RE = 1)
U0CSR |= U0CSR_RE;
// Clear any pending RX interrupt request (set U0CSR.RX_BYTE = 0)
U0CSR &= ~U0CSR_RX_BYTE;
// Loop: receive each UART0 sample from the UART0 RX line
BSP_TURN_OFF_LED1();
BSP_TURN_OFF_LED2() ;
// Wait until data received (U0CSR.RX_BYTE = 1)
while( !(U0CSR&U0CSR_RX_BYTE) );
BSP_TURN_OFF_LED1();
BSP_TURN_ON_LED2() ;
// Read UART0 RX buffer
/* Build the message */
msg=U0DBUF;
for( uint8_t x = 0; x < NUM_TX_RETRIES; x++ )
{
SMPL_Send(sLinkID, &msg, sizeof(msg));
/* Turn on RX. default is RX Idle. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
if( sSemaphore )
break;
}
/* Radio IDLE to save power */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXIDLE, 0);
}
}
/***********************************************************************************
* @fn sSlave
*
* @brief Waits for packet from Master and acknowledge this.
* Red led lit means linked to master
* Blinking green led indicates packet received
* Adjust output power dynamically
*
* @param none
*
* @return none
*/
static void sSlave(void)
{
P0DIR=0xC3;
uint8_t radioMsg[2], len,msg;
ioctlRadioSiginfo_t info;
sCurrentPwrLevel = MAXIMUM_OUTPUT_POWER;
sRequestPwrLevel = MAXIMUM_OUTPUT_POWER;
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SETPWR, &sCurrentPwrLevel);
/* Listen for link forever... */
BSP_TURN_ON_LED1();
BSP_TURN_ON_LED2();
while (SMPL_LinkListen(&sLinkID) != SMPL_SUCCESS)
{
BSP_TOGGLE_LED1();
BSP_TOGGLE_LED2();
}
/* Turning on LED2 to show that we have link*/
BSP_TURN_OFF_LED1();
BSP_TURN_ON_LED2();
/* turn on RX. default is RX off. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0 );
while (1)
{
if( sSemaphore ) /* Acknowledge successfully received */
{
/* Radio IDLE to save power */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXIDLE, 0);
BSP_TURN_ON_LED2();
BSP_TURN_ON_LED1();
SMPL_Receive(sLinkID, &msg, &len);
BSP_TURN_OFF_LED2();
BSP_TURN_OFF_LED1();
sSemaphore = 0;
/* Build and send acknowledge */
SMPL_Send(sLinkID, &msg, sizeof(msg));
/***********************************************************************************
* CONSTANTS
*/
uint16 uartRxIndex;
// Clear any pending TX interrupt request (set U0CSR.TX_BYTE = 0)
U0CSR &= ~U0CSR_TX_BYTE;
//Configure USART0 for Alternative 1 => Port P0 (PERCFG.U0CFG = 0)
// To avoid potential I/O conflict with USART1:
//configure USART1 for Alternative 2 => Port P1 (PERCFG.U1CFG = 1)
PERCFG = (PERCFG & ~PERCFG_U0CFG) | PERCFG_U1CFG;
// Configure relevant Port P0 pins for peripheral function:
// P0SEL.SELP0_2/3/4/5 = 1 => RX = P0_2, TX = P0_3, CT = P0_4, RT = P0_5
P0SEL |= BIT5 | BIT4 | BIT3 | BIT2;
/***************************************************************************
* Configure UART
*
* The system clock source used is the HS XOSC at 26 MHz speed.
*/
// Set system clock source to 26 Mhz XSOSC to support maximum transfer speed,
// ref. [clk]=>[clk_xosc.c]
SLEEP &= ~SLEEP_OSC_PD;
while( !(SLEEP & SLEEP_XOSC_S) );
CLKCON = (CLKCON & ~(CLKCON_CLKSPD | CLKCON_OSC)) | CLKSPD_DIV_1;
while (CLKCON & CLKCON_OSC);
SLEEP |= SLEEP_OSC_PD;
// Initialise bitrate = 57.6 kbps (U0BAUD.BAUD_M = 34, U0GCR.BAUD_E = 11)
U0BAUD = UART_BAUD_M;
U0GCR = (U0GCR&~U0GCR_BAUD_E) | UART_BAUD_E;
// Initialise UART protocol (start/stop bit, data bits, parity, etc.):
// USART mode = UART (U0CSR.MODE = 1)
U0CSR |= U0CSR_MODE;
// Start bit level = low => Idle level = high (U0UCR.START = 0)
U0UCR &= ~U0UCR_START;
// Stop bit level = high (U0UCR.STOP = 1)
U0UCR |= U0UCR_STOP;
// Number of stop bits = 1 (U0UCR.SPB = 0)
U0UCR &= ~U0UCR_SPB;
// Parity = disabled (U0UCR.PARITY = 0)
U0UCR &= ~U0UCR_PARITY;
// 9-bit data enable = 8 bits transfer (U0UCR.BIT9 = 0)
U0UCR &= ~U0UCR_BIT9;
// Level of bit 9 = 0 (U0UCR.D9 = 0), used when U0UCR.BIT9 = 1
// Level of bit 9 = 1 (U0UCR.D9 = 1), used when U0UCR.BIT9 = 1
// Parity = Even (U0UCR.D9 = 0), used when U0UCR.PARITY = 1
// Parity = Odd (U0UCR.D9 = 1), used when U0UCR.PARITY = 1
U0UCR &= ~U0UCR_D9;
// Flow control = disabled (U0UCR.FLOW = 0)
U0UCR &= ~U0UCR_FLOW;
// Bit order = LSB first (U0GCR.ORDER = 0)
U0GCR &= ~U0GCR_ORDER;
// Loop: send each UART0 sample on the UART0 TX line
U0DBUF = msg;//uartTxBuf[uartTxIndex]
while(! (U0CSR&U0CSR_TX_BYTE) );
/* Turn on RX. default is RX off. */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);
}
}
}
/***********************************************************************************
* @fn sRxCallback
*
* @brief
*
* @param lid - link id message receive at
*
* @return 0 - frame left for application to read
* 1 - frame could be overwritten
*/
static uint8_t sRxCallback(linkID_t lid)
{
if(lid)
{
sSemaphore = 1;
/* Radio IDLE to save power */
SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXIDLE, 0);
}
/* Leave frame to be read by application. */
return 0;
}
Hello Texas Instruments,
I are trying to transmit data between two computers. First I used UART to get data into the transmitter of CC2510 module and then data is transmitted through RF(Wireless). The receiver is also programmed with UART which is connected to other computer .(Please find the program attached).
I am not able to realize the output in the receiver as fast as I input my data in the transmitter. (The output was verified using HyperTerminal with proper Baud Rate selected)
If multiple bytes are transmitted together every 11th byte is received. However if these bytes are inputted at a slower rate then data transfer is successful.