register in cc2520 in which the SPI sends the value in TIMAC

pratap yenubari

Other Parts Discussed in Thread: TIMAC, CC2520, CC2430, CC2420, CC2530

hi,

i am working with TIMAC and i want to send ADC data.

can someone tell me the spi flow through which the ADC data is being passed through the SPI to the transmission buffer in the CC2520.

i have searched the mac_spi.c file also.

it has two functions which tells about

1)Write value to radio register.(void macSpiWriteRamUint16(uint16 ramAddr, uint16 data))

2)Write unsigned 16-bit value to radio RAM(

void macSpiWriteReg(uint8 regAddr, uint8 regValue))

i am not clear in which register the values from the SPI gets stored in the CC2520 for transmission.

)

over 9 years ago

0 Suyash Jain over 9 years ago

TI__Genius 10650 points

Hello Pratap,

You should be able to populate the data in the MSA_McpsDataReq() as done by the sample application and instead of using the sample application data you can add the ADC data and pass the pointer to the function for this. Below the declaration for the MSA_McpsDataReq():

void MSA_McpsDataReq(uint8* data, uint8 dataLength, bool directMsg, uint16 dstShortAddr);

Do you see that you have issues with this? is the data is not going out? Or can you please describe your requirement a little more.

Regards,

0 pratap yenubari over 9 years ago in reply to Suyash Jain

Expert 2305 points

hello ,

we are doing exactly the way you have explained.

we are able to send single byte of data msa_Data1[4] ,but when we try to send even one more byte it is not working.

actually we are using a function generator to obtain an analog sine wave of around say 150hz which we are passing as input to the ADC(8 bit) ,the output of which are being passed to msa_Data1[ ] ,the transmission packet .

the problem we are facing is we are able to reconstruct the sine wave at the receiver end of up to 30 hz even though we are taking sampling frequency of 870Khz. we have tried for other lower sampling frequencies also but no change.this is for singlr byte of data msa_Data1[4].

the system clock is of 12 MHz,

SPI clock is 6MHz,

i am pasting our code also.

/**************************************************************************************************
Filename: msa.c
Revised: $Date: 2013-02-25 14:58:47 -0800 (Mon, 25 Feb 2013) $
Revision: $Revision: 33292 $

Description: This file contains the sample application that can be use to test
the functionality of the MAC, HAL and low level.

IMPORTANT: Your use of this Software is limited to those specific rights
granted under the terms of a software license agreement between the user
who downloaded the software, his/her employer (which must be your employer)
and Texas Instruments Incorporated (the "License"). You may not use this
Software unless you agree to abide by the terms of the License. The License
limits your use, and you acknowledge, that the Software may not be modified,
copied or distributed unless embedded on a Texas Instruments microcontroller
or used solely and exclusively in conjunction with a Texas Instruments radio
frequency transceiver, which is integrated into your product. Other than for
the foregoing purpose, you may not use, reproduce, copy, prepare derivative
works of, modify, distribute, perform, display or sell this Software and/or
its documentation for any purpose.

YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
(INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.

Should you have any questions regarding your right to use this Software,
contact Texas Instruments Incorporated at www.TI.com.
**************************************************************************************************/

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

Description:

KEY UP (or S1)
- Non Beacon
- First board in the network will be setup as the coordinator
- Any board after the first one will be setup as the device
|
KEY LEFT | KEY RIGHT(or S2)
----+----- - Start transmitting
|
|
KEY DOWN

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

/**************************************************************************************************
* Includes
**************************************************************************************************/

/* Hal Driver includes */
#include "hal_types.h"
#include "hal_key.h"
#include "hal_timer.h"
#include "hal_drivers.h"
#include "hal_led.h"
#include "hal_adc.h"
#include "hal_lcd.h"
#include<stdio.h>
#include<string.h>

/* OS includes */
#include "OSAL.h"
#include "OSAL_Tasks.h"
#include "OSAL_PwrMgr.h"

/* Application Includes */
#include "OnBoard.h"

/* For Random numbers */
#include "mac_radio_defs.h"

/* MAC Application Interface */
#include "mac_api.h"
#include "mac_main.h"

#ifdef FEATURE_MAC_SECURITY
#include "mac_spec.h"

/* MAC Sceurity */
#include "mac_security_pib.h"
#include "mac_security.h"
#endif /* FEATURE_MAC_SECURITY */

/* Application */
#include "msa.h"

/**************************************************************************************************
* Constant
**************************************************************************************************/

#define MSA_DEV_SHORT_ADDR 0x0000 /* Device initial short address - This will change after association */

#define MSA_HEADER_LENGTH 4 /* Header includes DataLength + DeviceShortAddr + Sequence */
#define MSA_ECHO_LENGTH 8 /* Echo packet */

#define MSA_MAC_MAX_RESULTS 5 /* Maximun number of scan result that will be accepted */
#define MSA_MAX_DEVICE_NUM 50 /* Maximun number of devices can associate with the coordinator */

#if defined (HAL_BOARD_CC2420DB)
#define MSA_HAL_ADC_CHANNEL HAL_ADC_CHANNEL_0 /* AVR - Channel 0 and Resolution 10 */
#define MSA_HAL_ADC_RESOLUTION HAL_ADC_RESOLUTION_10
#elif defined (HAL_BOARD_DZ1611) || defined (HAL_BOARD_DZ1612) || defined (HAL_BOARD_DRFG4618) || defined (HAL_BOARD_F2618)
#define MSA_HAL_ADC_CHANNEL HAL_ADC_CHANNEL_0 /* DZ1611 and DZ1612 - Channel 0 and Resolution 12 */
#define MSA_HAL_ADC_RESOLUTION HAL_ADC_RESOLUTION_12
#else
#define MSA_HAL_ADC_CHANNEL HAL_ADC_CHANNEL_7 /* CC2430 EB & DB - Channel 7 and Resolution 14 */
#define MSA_HAL_ADC_RESOLUTION HAL_ADC_RESOLUTION_14
#endif

#define MSA_EBR_PERMITJOINING TRUE
#define MSA_EBR_LINKQUALITY 1
#define MSA_EBR_PERCENTFILTER 0xFF

/* Size table for MAC structures */
const CODE uint8 msa_cbackSizeTable [] =
{
0, /* unused */
sizeof(macMlmeAssociateInd_t), /* MAC_MLME_ASSOCIATE_IND */
sizeof(macMlmeAssociateCnf_t), /* MAC_MLME_ASSOCIATE_CNF */
sizeof(macMlmeDisassociateInd_t), /* MAC_MLME_DISASSOCIATE_IND */
sizeof(macMlmeDisassociateCnf_t), /* MAC_MLME_DISASSOCIATE_CNF */
sizeof(macMlmeBeaconNotifyInd_t), /* MAC_MLME_BEACON_NOTIFY_IND */
sizeof(macMlmeOrphanInd_t), /* MAC_MLME_ORPHAN_IND */
sizeof(macMlmeScanCnf_t), /* MAC_MLME_SCAN_CNF */
sizeof(macMlmeStartCnf_t), /* MAC_MLME_START_CNF */
sizeof(macMlmeSyncLossInd_t), /* MAC_MLME_SYNC_LOSS_IND */
sizeof(macMlmePollCnf_t), /* MAC_MLME_POLL_CNF */
sizeof(macMlmeCommStatusInd_t), /* MAC_MLME_COMM_STATUS_IND */
sizeof(macMcpsDataCnf_t), /* MAC_MCPS_DATA_CNF */
sizeof(macMcpsDataInd_t), /* MAC_MCPS_DATA_IND */
sizeof(macMcpsPurgeCnf_t), /* MAC_MCPS_PURGE_CNF */
sizeof(macEventHdr_t), /* MAC_PWR_ON_CNF */
sizeof(macMlmePollInd_t) /* MAC_MLME_POLL_IND */
};

/**************************************************************************************************
* Local Variables
**************************************************************************************************/

/*
Extended address of the device, for coordinator, it will be msa_ExtAddr1
For any device, it will be msa_ExtAddr2 with the last 2 bytes from a ADC read
*/
sAddrExt_t msa_ExtAddr;
sAddrExt_t msa_ExtAddr1 = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
sAddrExt_t msa_ExtAddr2 = {0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0x00, 0x00};

/* Coordinator and Device information */
uint16 msa_PanId = MSA_PAN_ID;
uint16 msa_CoordShortAddr = MSA_COORD_SHORT_ADDR;
uint16 msa_DevShortAddr = MSA_DEV_SHORT_ADDR;

uint8 datasent[2];
uint8 variable = 0;
char sensbuffer[100];

/*
List of short addresses that the coordinator will use
to assign to each the device that associates to it
*/
uint16 msa_DevShortAddrList[] = {0x0001, 0x0002, 0x0003, 0x0004, 0x0005,
0x0006, 0x0007, 0x0008, 0x0009, 0x000A,
0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014,
0x0015, 0x0016, 0x0017, 0x0018, 0x0019,
0x001A, 0x001B, 0x001C, 0x001D, 0x001E,
0x001F, 0x0020, 0x0021, 0x0022, 0x0023,
0x0024, 0x0025, 0x0026, 0x0027, 0x0028,
0x0029, 0x002A, 0x002B, 0x002C, 0x002D,
0x002E, 0x002F, 0x0030, 0x0031, 0x0032};

/* Current number of devices associated to the coordinator */
uint8 msa_NumOfDevices = 0;

#ifdef FEATURE_MAC_SECURITY
/* Current number of devices (including coordinator) communicating to this device */
uint8 msa_NumOfSecuredDevices = 0;
#endif /* FEATURE_MAC_SECURITY */

/* Predefined packet that will be sent out by the coordinator */
uint8 msa_Data1[MSA_PACKET_LENGTH];

/* Predefined packet that will be sent back to the coordinator by the device */
uint8 msa_Data2[MSA_ECHO_LENGTH];

/* TRUE and FALSE value */
bool msa_MACTrue = TRUE;
bool msa_MACFalse = FALSE;

/* Beacon payload, this is used to determine if the device is not zigbee device */
uint8 msa_BeaconPayload[] = {0x22, 0x33, 0x44};
uint8 msa_BeaconPayloadLen = 3;

/* Contains pan descriptor results from scan */
macPanDesc_t msa_PanDesc[MSA_MAC_MAX_RESULTS];

/* flags used in the application */
bool msa_IsCoordinator = FALSE; /* True if the device is started as a Pan Coordinate */
bool msa_IsStarted = FALSE; /* True if the device started, either as Pan Coordinator or device */
bool msa_IsSampleBeacon = FALSE; /* True if the beacon payload match with the predefined */
bool msa_IsDirectMsg = FALSE; /* True if the messages will be sent as direct messages */
uint8 msa_State = MSA_IDLE_STATE; /* Either IDLE state or SEND state */

/* Structure that used for association request */
macMlmeAssociateReq_t msa_AssociateReq;

/* Structure that used for association response */
macMlmeAssociateRsp_t msa_AssociateRsp;

/* Structure that contains information about the device that associates with the coordinator */
typedef struct
{
uint16 devShortAddr;
uint8 isDirectMsg;
}msa_DeviceInfo_t;

/* Array contains the information of the devices */
static msa_DeviceInfo_t msa_DeviceRecord[MSA_MAX_DEVICE_NUM];

uint8 msa_SuperFrameOrder;
uint8 msa_BeaconOrder;

/* Task ID */
uint8 MSA_TaskId;

void UART_outdec(long , unsigned char );
void datasend(void);
void adc(void);
void adctrigger(void);
#ifdef FEATURE_MAC_SECURITY
/**************************************************************************************************
* MAC security related constants
**************************************************************************************************/
#define MSA_KEY_TABLE_ENTRIES 1
#define MSA_KEY_ID_LOOKUP_ENTRIES 1
#define MSA_KEY_DEVICE_TABLE_ENTRIES 8
#define MSA_KEY_USAGE_TABLE_ENTRIES 1
#define MSA_DEVICE_TABLE_ENTRIES 0 /* can grow up to MAX_DEVICE_TABLE_ENTRIES */
#define MSA_SECURITY_LEVEL_ENTRIES 1
#define MSA_MAC_SEC_LEVEL MAC_SEC_LEVEL_ENC_MIC_32
#define MSA_MAC_KEY_ID_MODE MAC_KEY_ID_MODE_1
#define MSA_MAC_KEY_SOURCE {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
#define MSA_MAC_DEFAULT_KEY_SOURCE {0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33}
#define MSA_MAC_KEY_INDEX 3 /* cannot be zero for implicit key identifier */

/* Default MSA Security Parameters for outgoing frames */
bool macSecurity = TRUE;
uint8 msa_securityLevel = MSA_MAC_SEC_LEVEL;
uint8 msa_keyIdMode = MSA_MAC_KEY_ID_MODE;
uint8 msa_keySource[] = MSA_MAC_KEY_SOURCE;
uint8 msa_keyIndex = MSA_MAC_KEY_INDEX;

/**************************************************************************************************
* Security PIBs for outgoing frames
**************************************************************************************************/
const keyIdLookupDescriptor_t msa_keyIdLookupList[] =
{
{
{0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x03}, 0x01 /* index 3, 9 octets */
}
};

/* Key device list can be modified at run time
*/
keyDeviceDescriptor_t msa_keyDeviceList[] =
{
{0x00, false, false},
{0x00, false, false},
{0x00, false, false},
{0x00, false, false},
{0x00, false, false},
{0x00, false, false},
{0x00, false, false},
{0x00, false, false}
};

const keyUsageDescriptor_t msa_keyUsageList[] =
{
{MAC_FRAME_TYPE_DATA, MAC_DATA_REQ_FRAME}
};

const keyDescriptor_t msa_keyTable[] =
{
{
(keyIdLookupDescriptor_t *)msa_keyIdLookupList, MSA_KEY_ID_LOOKUP_ENTRIES,
(keyDeviceDescriptor_t *)msa_keyDeviceList, MSA_KEY_DEVICE_TABLE_ENTRIES,
(keyUsageDescriptor_t *)msa_keyUsageList, MSA_KEY_USAGE_TABLE_ENTRIES,
{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
}
};

const uint8 msa_keyDefaultSource[] = MSA_MAC_DEFAULT_KEY_SOURCE;

/**************************************************************************************************
* Security PIBs for incoming frames
**************************************************************************************************/

/* Device table can be modified at run time. */
deviceDescriptor_t msa_deviceTable[] =
{
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE},
{0, 0xFFFF, 0, 0, FALSE}
};

const securityLevelDescriptor_t msa_securityLevelTable[] =
{
{MAC_FRAME_TYPE_DATA, MAC_DATA_REQ_FRAME, MAC_SEC_LEVEL_NONE, FALSE}
};
#else /* FEATURE_MAC_SECURITY */
uint8 msa_securityLevel = MAC_SEC_LEVEL_NONE;
uint8 msa_keyIdMode = MAC_KEY_ID_MODE_NONE;
uint8 msa_keySource[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8 msa_keyIndex = 0;
#endif /* FEATURE_MAC_SECURITY */

/**************************************************************************************************
* Local Function Prototypes
**************************************************************************************************/
/* Setup routines */
void MSA_CoordinatorStartup(void);
void MSA_DeviceStartup(void);

/* MAC related routines */
void MSA_AssociateReq(void);
void MSA_AssociateRsp(macCbackEvent_t* pMsg);
void MSA_McpsDataReq(uint8* data, uint8 dataLength, bool directMsg, uint16 dstShortAddr);
void MSA_McpsPollReq(void);
void MSA_ScanReq(uint8 scanType, uint8 scanDuration);
void MSA_SyncReq(void);

/* Support */
bool MSA_BeaconPayLoadCheck(uint8* pSdu);
bool MSA_DataCheck(uint8* data, uint8 dataLength);

#ifdef FEATURE_MAC_SECURITY
/**************************************************************************************************
*
* @fn MSA_SecurityInit
*
* @brief Initialize the security part of the application
*
* @param none
*
* @return none
*
**************************************************************************************************/
static void MSA_SecurityInit(void)
{
uint8 keyTableEntries = MSA_KEY_TABLE_ENTRIES;
uint8 autoRequestSecLevel = MAC_SEC_LEVEL_NONE;
uint8 securityLevelEntries = MSA_SECURITY_LEVEL_ENTRIES;

/* Write key table PIBs */
MAC_MlmeSetSecurityReq(MAC_KEY_TABLE, (void *)msa_keyTable);
MAC_MlmeSetSecurityReq(MAC_KEY_TABLE_ENTRIES, &keyTableEntries );

/* Write default key source to PIB */
MAC_MlmeSetSecurityReq(MAC_DEFAULT_KEY_SOURCE, (void *)msa_keyDefaultSource);

/* Write security level table to PIB */
MAC_MlmeSetSecurityReq(MAC_SECURITY_LEVEL_TABLE, (void *)msa_securityLevelTable);
MAC_MlmeSetSecurityReq(MAC_SECURITY_LEVEL_TABLE_ENTRIES, &securityLevelEntries);

/* TBD: MAC_AUTO_REQUEST is true on by default
* need to set auto request security PIBs.
* dieable auto request security for now
*/
MAC_MlmeSetSecurityReq(MAC_AUTO_REQUEST_SECURITY_LEVEL, &autoRequestSecLevel);

/* Turn on MAC security */
MAC_MlmeSetReq(MAC_SECURITY_ENABLED, &macSecurity);
}

/**************************************************************************************************
*
* @fn MSA_SecuredDeviceTableUpdate
*
* @brief Update secured device table and key device descriptor handle
*
* @param panID - Secured network PAN ID
* @param shortAddr - Other device's short address
* @param extAddr - Other device's extended address
* @param pNumOfSecuredDevices - pointer to number of secured devices
*
* @return none
*
**************************************************************************************************/
static void MSA_SecuredDeviceTableUpdate(uint16 panID,
uint16 shortAddr,
sAddrExt_t extAddr,
uint8 *pNumOfSecuredDevices)
{
/* Update key device list */
msa_keyDeviceList[*pNumOfSecuredDevices].deviceDescriptorHandle = *pNumOfSecuredDevices;

/* Update device table */
msa_deviceTable[*pNumOfSecuredDevices].panID = panID;
msa_deviceTable[*pNumOfSecuredDevices].shortAddress = shortAddr;
sAddrExtCpy(msa_deviceTable[*pNumOfSecuredDevices].extAddress, extAddr);
MAC_MlmeSetSecurityReq(MAC_DEVICE_TABLE, msa_deviceTable);

/* Increase the number of secured devices */
(*pNumOfSecuredDevices)++;
MAC_MlmeSetSecurityReq(MAC_DEVICE_TABLE_ENTRIES, pNumOfSecuredDevices);
}
#endif /* FEATURE_MAC_SECURITY */

void UART_outdec(long data, unsigned char ndigits){
unsigned char sign, s[6];
unsigned int i;
sign = ' ';
if(data < 0) {
sign='-';
data = -data;
}
i = 0;
do {
s[i++] = data % 10 + '0';
if(i == ndigits) {
s[i++]='.';
}
} while( (data /= 10) > 0);
s[i] = sign;
do {
while(!(UCA1IFG&UCTXIFG));
UCA1TXBUF = s[i];
} while(i--);
}

#pragma vector=ADC12_VECTOR
__interrupt void ADC12_ISR(void)
{

//ADC12CTL0 &= ~ADC12ENC; // Disable ADC12 conversions
//REFCTL0 &= ~REFON; // Disable reference

//msa_Data1[4]=ADC12MEM1;

uint8 index = 4;
datasent[index -4] = LO_UINT16(ADC12MEM1);
index++;
if (index == 6)
{
index = 4;

}

ADC12IFG &= ~ADC12IFG1;
__bic_SR_register_on_exit(LPM0_bits);

}

void adc(void)
{

P7SEL |= BIT5; // Pin 7.6 and 7.7 are inputs from the accelerometer to the ADC => they are configured as inputs to the ADC
P7DIR &= ~BIT5;

//ADC12CTL0 &= ~ADC12ENC; // Disable conversion
ADC12CTL0 = ADC12ON + ADC12SHT0_2 ; //+ ADC12MSC ; // Turn on ADC, Sample once every 256 cycles, Multisample conversion
ADC12CTL1 = ADC12CSTARTADD_1+ ADC12SHP + ADC12CONSEQ_0 + ADC12SSEL_3; //+ ADC12DIV_7 ; // + ADC12DIV_7;//(sampling frequency--1450 hz)
ADC12CTL2 = ADC12RES_0; // Resolution=08 bits, 13 clock cycle conversion timeon time

ADC12MCTL1 = ADC12INCH_13;

//select channel 13(pin 7.5)
ADC12CTL0 |= ADC12ENC;
ADC12IE = BIT1;
__delay_cycles(2000000); // Allowing reference voltage to stabilize

}
void adctrigger(void)
{
//ADC12CTL0 |= ADC12ENC | ADC12SC;
ADC12CTL0 |= ADC12SC;
__bis_SR_register(LPM0_bits+GIE);
// __no_operation();
}

/**************************************************************************************************
*
* @fn MSA_Init
*
* @brief Initialize the application
*
* @param taskId - taskId of the task after it was added in the OSAL task queue
*
* @return none
*
**************************************************************************************************/
void MSA_Init(uint8 taskId)
{
uint8 i;

/* Initialize the task id */
MSA_TaskId = taskId;

/* initialize MAC features */
MAC_InitDevice();
MAC_InitCoord();

/* Initialize MAC beacon */
MAC_InitBeaconDevice();
MAC_InitBeaconCoord();

/* Reset the MAC */
MAC_MlmeResetReq(TRUE);

#ifdef FEATURE_MAC_SECURITY
/* Initialize the security part of the application */
MSA_SecurityInit();
#endif /* FEATURE_MAC_SECURITY */

adc();
/* Initialize the data packet */

/* Initialize the echo packet */

for (i=0; i<MSA_ECHO_LENGTH; i++)
{
msa_Data2[i] = 0xEE;
}

msa_BeaconOrder = MSA_MAC_BEACON_ORDER;
msa_SuperFrameOrder = MSA_MAC_SUPERFRAME_ORDER;

}

/**************************************************************************************************
*
* @fn MSA_ProcessEvent
*
* @brief This routine handles events
*
* @param taskId - ID of the application task when it registered with the OSAL
* events - Events for this task
*
* @return 16bit - Unprocessed events
*
**************************************************************************************************/
uint16 MSA_ProcessEvent(uint8 taskId, uint16 events)
{
uint8* pMsg;
macCbackEvent_t* pData;
uint8 k =0;
uint8 i =4;
#ifdef FEATURE_MAC_SECURITY
uint16 panID;
uint16 panCoordShort;
sAddrExt_t panCoordExtAddr;
#endif /* FEATURE_MAC_SECURITY */

static uint8 index;
static uint8 sequence;

adctrigger();

if (events & SYS_EVENT_MSG)
{
while ((pMsg = osal_msg_receive(MSA_TaskId)) != NULL)
{
switch ( *pMsg )
{
case MAC_MLME_ASSOCIATE_IND:
MSA_AssociateRsp((macCbackEvent_t*)pMsg);
break;

case MAC_MLME_ASSOCIATE_CNF:
/* Retrieve the message */
pData = (macCbackEvent_t *) pMsg;

if ((!msa_IsStarted) && (pData->associateCnf.hdr.status == MAC_SUCCESS))
{
msa_IsStarted = TRUE;

/* Retrieve MAC_SHORT_ADDRESS */

msa_DevShortAddr = pData->associateCnf.assocShortAddress;

/* Setup MAC_SHORT_ADDRESS - obtained from Association */
MAC_MlmeSetReq(MAC_SHORT_ADDRESS, &msa_DevShortAddr);

#ifdef FEATURE_MAC_SECURITY
/* Add the coordinator to device table and key device table for security */
MAC_MlmeGetReq(MAC_PAN_ID, &panID);
MAC_MlmeGetSecurityReq(MAC_PAN_COORD_SHORT_ADDRESS, &panCoordShort);
MAC_MlmeGetSecurityReq(MAC_PAN_COORD_EXTENDED_ADDRESS, &panCoordExtAddr);
MSA_SecuredDeviceTableUpdate(panID, panCoordShort,
panCoordExtAddr, &msa_NumOfSecuredDevices);
#endif /* FEATURE_MAC_SECURITY */

HalLedBlink(HAL_LED_4, 0, 90, 1000);

/* Poll for data if it's not setup for direct messaging */
if (!msa_IsDirectMsg)
{
osal_start_timerEx(MSA_TaskId, MSA_POLL_EVENT, MSA_WAIT_PERIOD);
}
}
break;

case MAC_MLME_COMM_STATUS_IND:
break;

case MAC_MLME_BEACON_NOTIFY_IND:
/* Retrieve the message */
pData = (macCbackEvent_t *) pMsg;

/* Check for correct beacon payload */
if (!msa_IsStarted)
{
msa_IsSampleBeacon = MSA_BeaconPayLoadCheck(pData->beaconNotifyInd.pSdu);

/* If it's the correct beacon payload, retrieve the data for association req */
if (msa_IsSampleBeacon)
{
msa_AssociateReq.logicalChannel = MSA_MAC_CHANNEL;
msa_AssociateReq.coordAddress.addrMode = SADDR_MODE_SHORT;
msa_AssociateReq.coordAddress.addr.shortAddr = pData->beaconNotifyInd.pPanDesc->coordAddress.addr.shortAddr;
msa_AssociateReq.coordPanId = pData->beaconNotifyInd.pPanDesc->coordPanId;
if (msa_IsDirectMsg)
msa_AssociateReq.capabilityInformation = MAC_CAPABLE_ALLOC_ADDR | MAC_CAPABLE_RX_ON_IDLE;
else
msa_AssociateReq.capabilityInformation = MAC_CAPABLE_ALLOC_ADDR;
msa_AssociateReq.sec.securityLevel = MAC_SEC_LEVEL_NONE;

/* Retrieve beacon order and superframe order from the beacon */
msa_BeaconOrder = MAC_SFS_BEACON_ORDER(pData->beaconNotifyInd.pPanDesc->superframeSpec);
msa_SuperFrameOrder = MAC_SFS_SUPERFRAME_ORDER(pData->beaconNotifyInd.pPanDesc->superframeSpec);
}
}

break;

case MAC_MLME_START_CNF:
/* Retrieve the message */
pData = (macCbackEvent_t *) pMsg;
/* Set some indicator for the Coordinator */
if ((!msa_IsStarted) && (pData->startCnf.hdr.status == MAC_SUCCESS))
{
msa_IsStarted = TRUE;
msa_IsCoordinator = TRUE;
HalLedSet (HAL_LED_4, HAL_LED_MODE_ON);
}
break;

case MAC_MLME_SCAN_CNF:
/* Check if there is any Coordinator out there */
pData = (macCbackEvent_t *) pMsg;

/* If there is no other on the channel or no other with sampleBeacon start as coordinator */
if (((pData->scanCnf.resultListSize == 0) && (pData->scanCnf.hdr.status == MAC_NO_BEACON)) || (!msa_IsSampleBeacon))
{
MSA_CoordinatorStartup();
}
else if ((msa_IsSampleBeacon) && pData->scanCnf.hdr.status == MAC_SUCCESS)
{
/* Start the devive up as beacon enabled or not */
MSA_DeviceStartup();

/* Call Associate Req */
MSA_AssociateReq();
}
break;

case MAC_MCPS_DATA_CNF:
pData = (macCbackEvent_t *) pMsg;

/* If last transmission completed, ready to send the next one */
if ((pData->dataCnf.hdr.status == MAC_SUCCESS) ||
(pData->dataCnf.hdr.status == MAC_CHANNEL_ACCESS_FAILURE) ||
(pData->dataCnf.hdr.status == MAC_NO_ACK))
{
osal_start_timerEx(MSA_TaskId, MSA_SEND_EVENT, MSA_WAIT_PERIOD);
}

mac_msg_deallocate((uint8**)&pData->dataCnf.pDataReq);
break;

case MAC_MCPS_DATA_IND:
pData = (macCbackEvent_t*)pMsg;

if (MSA_DataCheck ( pData->dataInd.msdu.p, pData->dataInd.msdu.len ))
{
HalLedSet (HAL_LED_3, HAL_LED_MODE_TOGGLE);

/* Only send the echo back if the received */
if (!msa_IsCoordinator)
{
if (MSA_ECHO_LENGTH >= 4)
{
/* Return the first 4 bytes and the last byte of the received packet */
msa_Data2[0] = pData->dataInd.msdu.p[0];
msa_Data2[1] = pData->dataInd.msdu.p[1];
msa_Data2[2] = pData->dataInd.msdu.p[2];
msa_Data2[3] = pData->dataInd.msdu.p[3];
}

MSA_McpsDataReq(msa_Data2,
MSA_ECHO_LENGTH,
TRUE,
msa_CoordShortAddr );

/////////////////////////////////////////////////////////////////////////////////////////////////////

P5SEL |= BIT6 + BIT7; // P5.6,7 = USCI_A1 TXD/RXD
UCA1CTL1 |= UCSWRST; // **Put state machine in reset**
UCA1CTL1 |= UCSSEL__SMCLK;
UCA1BR0 =34; //
UCA1BR1 = 0; //
UCA1MCTL = UCBRS_6;
UCA1CTL1 &= ~UCSWRST; // **Initialize USCI state machine**
// UCA1IE = UCTXIE;

//for (i=MSA_HEADER_LENGTH; i<MSA_PACKET_LENGTH; i++)

//{

P10DIR |= BIT7;
P10OUT= (pData->dataInd.msdu.p[i]);
UART_outdec( pData->dataInd.msdu.p[i], 0);
i++;
if ( i == 6)
{
i = 4;

}

// }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

}
}
break;
}

/* Deallocate */
mac_msg_deallocate((uint8 **)&pMsg);
}

return events ^ SYS_EVENT_MSG;
}

/* This event handles polling for in-direct message device */
if (events & MSA_POLL_EVENT)
{
MSA_McpsPollReq();
osal_start_timerEx(MSA_TaskId, MSA_POLL_EVENT, MSA_WAIT_PERIOD);

return events ^ MSA_POLL_EVENT;
}

/* This event will blink a LED then send out a DataReq and continue to do so every WAIT_PERIOD */
if (events & MSA_SEND_EVENT)
{

/* Do it again */
if (msa_State == MSA_SEND_STATE)
{
/* Start sending */
if (msa_IsCoordinator)
{
if (MSA_PACKET_LENGTH >= MSA_HEADER_LENGTH)
{
/* Coordinator sending to devices. Use the associated list of device to send out msg */
msa_Data1[0] = MSA_PACKET_LENGTH;
msa_Data1[1] = HI_UINT16(msa_DeviceRecord[index].devShortAddr);
msa_Data1[2] = LO_UINT16(msa_DeviceRecord[index].devShortAddr);
msa_Data1[3] = sequence;
}

MSA_McpsDataReq((uint8*)msa_Data1,
MSA_PACKET_LENGTH,
msa_DeviceRecord[index].isDirectMsg,
msa_DeviceRecord[index].devShortAddr );

/* Reset the index if it reaches the current number of associated devices */
if (++index == msa_NumOfDevices)
{
index = 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////

P5SEL |= BIT6 + BIT7; // P5.6,7 = USCI_A1 TXD/RXD
UCA1CTL1 |= UCSWRST; // **Put state machine in reset**
UCA1CTL1 |= UCSSEL__SMCLK;
UCA1BR0 = 34; //
UCA1BR1 = 0; //
UCA1MCTL = UCBRS_6;
UCA1CTL1 &= ~UCSWRST; // **Initialize USCI state machine**
// UCA1IE = UCTXIE;

//for (i=MSA_HEADER_LENGTH; i<MSA_PACKET_LENGTH; i++)
//{
msa_Data1[i] = datasent[i -4];
P10DIR |= BIT7;
P10OUT= msa_Data1[i];
UART_outdec( msa_Data1[i], 0);
i++;
if ( i == 6)
{
i = 4;

}
/*
sprintf(sensbuffer,"\n\r%d ", msa_Data1[i]);

while(sensbuffer[k])
{
while(!(UCA1IFG&UCTXIFG));
UCA1TXBUF = sensbuffer[k++];
}
*/

//}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

}
else
{
if (MSA_PACKET_LENGTH >= MSA_HEADER_LENGTH)
{
/* Device sending to coordinator */
msa_Data1[0] = MSA_PACKET_LENGTH;
msa_Data1[1] = HI_UINT16(msa_CoordShortAddr);
msa_Data1[2] = LO_UINT16(msa_CoordShortAddr);
msa_Data1[3] = sequence;
}
MSA_McpsDataReq((uint8*)msa_Data1,
MSA_PACKET_LENGTH,
TRUE,
msa_CoordShortAddr );

/////////////////////////////////////////////////////////////////////////////////////////////////////

P5SEL |= BIT6 + BIT7; // P5.6,7 = USCI_A1 TXD/RXD
UCA1CTL1 |= UCSWRST; // **Put state machine in reset**
UCA1CTL1 |= UCSSEL__SMCLK;
UCA1BR0 = 34; //
UCA1BR1 = 0; //
UCA1MCTL = UCBRS_6;
UCA1CTL1 &= ~UCSWRST; // **Initialize USCI state machine**
// UCA1IE = UCTXIE;

}

if (sequence++ == 0xFF)
{
sequence = 0;
}

HalLedSet (HAL_LED_1, HAL_LED_MODE_BLINK);
}

return events ^ MSA_SEND_EVENT;
}
return 0;
}

/**************************************************************************************************
*
* @fn MAC_CbackEvent
*
* @brief This callback function sends MAC events to the application.
* The application must implement this function. A typical
* implementation of this function would allocate an OSAL message,
* copy the event parameters to the message, and send the message
* to the application's OSAL event handler. This function may be
* executed from task or interrupt context and therefore must
* be reentrant.
*
* @param pData - Pointer to parameters structure.
*
* @return None.
*
**************************************************************************************************/
void MAC_CbackEvent(macCbackEvent_t *pData)
{

macCbackEvent_t *pMsg = NULL;

uint8 len = msa_cbackSizeTable[pData->hdr.event];

switch (pData->hdr.event)
{
case MAC_MLME_BEACON_NOTIFY_IND:

len += sizeof(macPanDesc_t) + pData->beaconNotifyInd.sduLength +
MAC_PEND_FIELDS_LEN(pData->beaconNotifyInd.pendAddrSpec);
if ((pMsg = (macCbackEvent_t *) osal_msg_allocate(len)) != NULL)
{
/* Copy data over and pass them up */
osal_memcpy(pMsg, pData, sizeof(macMlmeBeaconNotifyInd_t));
pMsg->beaconNotifyInd.pPanDesc = (macPanDesc_t *) ((uint8 *) pMsg + sizeof(macMlmeBeaconNotifyInd_t));
osal_memcpy(pMsg->beaconNotifyInd.pPanDesc, pData->beaconNotifyInd.pPanDesc, sizeof(macPanDesc_t));
pMsg->beaconNotifyInd.pSdu = (uint8 *) (pMsg->beaconNotifyInd.pPanDesc + 1);
osal_memcpy(pMsg->beaconNotifyInd.pSdu, pData->beaconNotifyInd.pSdu, pData->beaconNotifyInd.sduLength);
}
break;

case MAC_MCPS_DATA_IND:
pMsg = pData;
break;

default:
if ((pMsg = (macCbackEvent_t *) osal_msg_allocate(len)) != NULL)
{
osal_memcpy(pMsg, pData, len);
}
break;
}

if (pMsg != NULL)
{
osal_msg_send(MSA_TaskId, (uint8 *) pMsg);
}
}

/**************************************************************************************************
*
* @fn MAC_CbackCheckPending
*
* @brief Returns the number of indirect messages pending in the application
*
* @param None
*
* @return Number of indirect messages in the application
*
**************************************************************************************************/
uint8 MAC_CbackCheckPending(void)
{
return (0);
}

/**************************************************************************************************
* @fn MAC_CbackQueryRetransmit
*
* @brief This function callback function returns whether or not to continue MAC
* retransmission.
* A return value '0x00' will indicate no continuation of retry and a return value
* '0x01' will indicate to continue retransmission. This callback function shall be
* used to stop continuing retransmission for RF4CE.
* MAC shall call this callback function whenever it finishes transmitting a packet
* for macMaxFrameRetries times.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return 0x00 to stop retransmission, 0x01 to continue retransmission.
**************************************************************************************************
*/
uint8 MAC_CbackQueryRetransmit(void)
{
/* Stub */
return(0);
}

/**************************************************************************************************
*
* @fn MSA_CoordinatorStartup()
*
* @brief Update the timer per tick
*
* @param n/a
*
* @return None
*
**************************************************************************************************/
void MSA_CoordinatorStartup()
{
macMlmeStartReq_t startReq;

/* Setup MAC_EXTENDED_ADDRESS */
sAddrExtCpy(msa_ExtAddr, msa_ExtAddr1);
MAC_MlmeSetReq(MAC_EXTENDED_ADDRESS, &msa_ExtAddr);

/* Setup MAC_SHORT_ADDRESS */
MAC_MlmeSetReq(MAC_SHORT_ADDRESS, &msa_CoordShortAddr);

/* Setup MAC_BEACON_PAYLOAD_LENGTH */
MAC_MlmeSetReq(MAC_BEACON_PAYLOAD_LENGTH, &msa_BeaconPayloadLen);

/* Setup MAC_BEACON_PAYLOAD */
MAC_MlmeSetReq(MAC_BEACON_PAYLOAD, &msa_BeaconPayload);

/* Enable RX */
MAC_MlmeSetReq(MAC_RX_ON_WHEN_IDLE, &msa_MACTrue);

/* Setup MAC_ASSOCIATION_PERMIT */
MAC_MlmeSetReq(MAC_ASSOCIATION_PERMIT, &msa_MACTrue);

/* Fill in the information for the start request structure */
startReq.startTime = 0;
startReq.panId = msa_PanId;
startReq.logicalChannel = MSA_MAC_CHANNEL;
startReq.beaconOrder = msa_BeaconOrder;
startReq.superframeOrder = msa_SuperFrameOrder;
startReq.panCoordinator = TRUE;
startReq.batteryLifeExt = FALSE;
startReq.coordRealignment = FALSE;
startReq.realignSec.securityLevel = FALSE;
startReq.beaconSec.securityLevel = FALSE;

/* Call start request to start the device as a coordinator */
MAC_MlmeStartReq(&startReq);

/* Allow Beacon mode coordinator to sleep */
if (msa_BeaconOrder != 15)
{
/* Power saving */
MSA_PowerMgr (MSA_PWR_MGMT_ENABLED);
}

}

/**************************************************************************************************
*
* @fn MSA_DeviceStartup()
*
* @brief Update the timer per tick
*
* @param beaconEnable: TRUE/FALSE
*
* @return None
*
**************************************************************************************************/
void MSA_DeviceStartup()
{
uint16 AtoD = 0;

#if (defined HAL_ADC) && (HAL_ADC == TRUE)
AtoD = HalAdcRead (MSA_HAL_ADC_CHANNEL, MSA_HAL_ADC_RESOLUTION);
#else
AtoD = MAC_RADIO_RANDOM_WORD();
#endif

/*
Setup MAC_EXTENDED_ADDRESS
*/
#if defined (HAL_BOARD_CC2420DB) || defined (HAL_BOARD_DZ1611) || defined (HAL_BOARD_DZ1612) || \
defined (HAL_BOARD_DRFG4618) || defined (HAL_BOARD_F2618)
/* Use HI and LO of AtoD on CC2420 and MSP430 */
msa_ExtAddr2[6] = HI_UINT16( AtoD );
msa_ExtAddr2[7] = LO_UINT16( AtoD );
#else
/* On CC2430 and CC2530 use current MAC timer */
AtoD = macMcuPrecisionCount();
msa_ExtAddr2[6] = HI_UINT16( AtoD );
msa_ExtAddr2[7] = LO_UINT16( AtoD );
#endif

sAddrExtCpy(msa_ExtAddr, msa_ExtAddr2);
MAC_MlmeSetReq(MAC_EXTENDED_ADDRESS, &msa_ExtAddr);

/* Setup MAC_BEACON_PAYLOAD_LENGTH */
MAC_MlmeSetReq(MAC_BEACON_PAYLOAD_LENGTH, &msa_BeaconPayloadLen);

/* Setup MAC_BEACON_PAYLOAD */
MAC_MlmeSetReq(MAC_BEACON_PAYLOAD, &msa_BeaconPayload);

/* Setup PAN ID */
MAC_MlmeSetReq(MAC_PAN_ID, &msa_PanId);

/* This device is setup for Direct Message */
if (msa_IsDirectMsg)
MAC_MlmeSetReq(MAC_RX_ON_WHEN_IDLE, &msa_MACTrue);
else
MAC_MlmeSetReq(MAC_RX_ON_WHEN_IDLE, &msa_MACFalse);

/* Setup Coordinator short address */
MAC_MlmeSetReq(MAC_COORD_SHORT_ADDRESS, &msa_AssociateReq.coordAddress.addr.shortAddr);

#ifdef FEATURE_MAC_SECURITY
/* Setup Coordinator short address for security */
MAC_MlmeSetSecurityReq(MAC_PAN_COORD_SHORT_ADDRESS, &msa_AssociateReq.coordAddress.addr.shortAddr);
#endif /* FEATURE_MAC_SECURITY */

if (msa_BeaconOrder != 15)
{
/* Setup Beacon Order */
MAC_MlmeSetReq(MAC_BEACON_ORDER, &msa_BeaconOrder);

/* Setup Super Frame Order */
MAC_MlmeSetReq(MAC_SUPERFRAME_ORDER, &msa_SuperFrameOrder);

/* Sync request */
MSA_SyncReq();
}

/* Power saving */
MSA_PowerMgr (MSA_PWR_MGMT_ENABLED);

}

/**************************************************************************************************
*
* @fn MSA_AssociateReq()
*
* @brief
*
* @param None
*
* @return None
*
**************************************************************************************************/
void MSA_AssociateReq(void)
{
MAC_MlmeAssociateReq(&msa_AssociateReq);
}

/**************************************************************************************************
*
* @fn MSA_AssociateRsp()
*
* @brief This routine is called by Associate_Ind inorder to return the response to the device
*
* @param pMsg - pointer to the structure recieved by MAC_MLME_ASSOCIATE_IND
*
* @return None
*
**************************************************************************************************/
void MSA_AssociateRsp(macCbackEvent_t* pMsg)
{
/* Assign the short address for the Device, from pool */
uint16 assocShortAddress = msa_DevShortAddrList[msa_NumOfDevices];

#ifdef FEATURE_MAC_SECURITY
uint16 panID;

/* Add device to device table for security */
MAC_MlmeGetReq(MAC_PAN_ID, &panID);
MSA_SecuredDeviceTableUpdate(panID, assocShortAddress,
pMsg->associateInd.deviceAddress,
&msa_NumOfSecuredDevices);
#endif /* FEATURE_MAC_SECURITY */

/* Build the record for this device */
msa_DeviceRecord[msa_NumOfDevices].devShortAddr = msa_DevShortAddrList[msa_NumOfDevices];
msa_DeviceRecord[msa_NumOfDevices].isDirectMsg = pMsg->associateInd.capabilityInformation & MAC_CAPABLE_RX_ON_IDLE;
msa_NumOfDevices++;

/* If the number of devices are more than MAX_DEVICE_NUM, turn off the association permit */
if (msa_NumOfDevices == MSA_MAX_DEVICE_NUM)
MAC_MlmeSetReq(MAC_ASSOCIATION_PERMIT, &msa_MACFalse);

/* Fill in association respond message */
sAddrExtCpy(msa_AssociateRsp.deviceAddress, pMsg->associateInd.deviceAddress);
msa_AssociateRsp.assocShortAddress = assocShortAddress;
msa_AssociateRsp.status = MAC_SUCCESS;

msa_AssociateRsp.sec.securityLevel = MAC_SEC_LEVEL_NONE;

/* Call Associate Response */
MAC_MlmeAssociateRsp(&msa_AssociateRsp);
}

/**************************************************************************************************
*
* @fn MSA_McpsDataReq()
*
* @brief This routine calls the Data Request
*
* @param data - contains the data that would be sent
* dataLength - length of the data that will be sent
*
* @return None
*
**************************************************************************************************/
void MSA_McpsDataReq(uint8* data, uint8 dataLength, bool directMsg, uint16 dstShortAddr)
{
macMcpsDataReq_t *pData;
static uint8 handle = 0;

if ((pData = MAC_McpsDataAlloc(dataLength, msa_securityLevel, msa_keyIdMode)) != NULL)
{
pData->mac.srcAddrMode = SADDR_MODE_SHORT;
pData->mac.dstAddr.addrMode = SADDR_MODE_SHORT;
pData->mac.dstAddr.addr.shortAddr = dstShortAddr;
pData->mac.dstPanId = msa_PanId;
pData->mac.msduHandle = handle++;
pData->mac.txOptions = MAC_TXOPTION_ACK;

/* MAC security parameters */
osal_memcpy( pData->sec.keySource, msa_keySource, MAC_KEY_SOURCE_MAX_LEN );
pData->sec.securityLevel = msa_securityLevel;
pData->sec.keyIdMode = msa_keyIdMode;
pData->sec.keyIndex = msa_keyIndex;

/* If it's the coordinator and the device is in-direct message */
if (msa_IsCoordinator)
{
if (!directMsg)
{
pData->mac.txOptions |= MAC_TXOPTION_INDIRECT;
}
}

/* Copy data */
osal_memcpy (pData->msdu.p, data, dataLength);

/* Send out data request */
MAC_McpsDataReq(pData);
}

}

/**************************************************************************************************
*
* @fn MSA_McpsPollReq()
*
* @brief Performs a poll request on the coordinator
*
* @param None
*
* @return None
*
**************************************************************************************************/
void MSA_McpsPollReq(void)
{
macMlmePollReq_t pollReq;

/* Fill in information for poll request */
pollReq.coordAddress.addrMode = SADDR_MODE_SHORT;
pollReq.coordAddress.addr.shortAddr = msa_CoordShortAddr;
pollReq.coordPanId = msa_PanId;
pollReq.sec.securityLevel = MAC_SEC_LEVEL_NONE;

/* Call poll reuqest */
MAC_MlmePollReq(&pollReq);
}

/**************************************************************************************************
*
* @fn MacSampelApp_ScanReq()
*
* @brief Performs active scan on specified channel
*
* @param None
*
* @return None
*
**************************************************************************************************/
void MSA_ScanReq(uint8 scanType, uint8 scanDuration)
{
macMlmeScanReq_t scanReq;

/* Fill in information for scan request structure */
scanReq.scanChannels = (uint32) 1 << MSA_MAC_CHANNEL;
scanReq.scanType = scanType;
scanReq.scanDuration = scanDuration;
scanReq.maxResults = MSA_MAC_MAX_RESULTS;
scanReq.permitJoining = MSA_EBR_PERMITJOINING;
scanReq.linkQuality = MSA_EBR_LINKQUALITY;
scanReq.percentFilter = MSA_EBR_PERCENTFILTER;
scanReq.result.pPanDescriptor = msa_PanDesc;
osal_memset(&scanReq.sec, 0, sizeof(macSec_t));

/* Call scan request */
MAC_MlmeScanReq(&scanReq);
}

/**************************************************************************************************
*
* @fn MSA_SyncReq()
*
* @brief Sync Request
*
* @param None
*
* @return None
*
**************************************************************************************************/
void MSA_SyncReq(void)
{
macMlmeSyncReq_t syncReq;

/* Fill in information for sync request structure */
syncReq.logicalChannel = MSA_MAC_CHANNEL;
syncReq.channelPage = MAC_CHANNEL_PAGE_0;
syncReq.trackBeacon = TRUE;

/* Call sync request */
MAC_MlmeSyncReq(&syncReq);
}

/**************************************************************************************************
*
* @fn MSA_BeaconPayLoadCheck()
*
* @brief Check if the beacon comes from MSA but not zigbee
*
* @param pSdu - pointer to the buffer that contains the data
*
* @return TRUE or FALSE
*
**************************************************************************************************/
bool MSA_BeaconPayLoadCheck(uint8* pSdu)
{
uint8 i = 0;
for (i=0; i<msa_BeaconPayloadLen; i++)
{
if (pSdu[i] != msa_BeaconPayload[i])
{
return FALSE;
}
}

return TRUE;
}

/**************************************************************************************************
*
* @fn MSA_DataCheck()
*
* @brief Check if the data match with the predefined data
*
* @param data - pointer to the buffer where the data will be checked against the predefined data
* dataLength - length of the data
*
* @return TRUE if the data matched else it's the response / echo packet
*
**************************************************************************************************/
bool MSA_DataCheck(uint8* data, uint8 dataLength)
{
uint8 i = 0;

if (data[0] == dataLength)
{
for (i=MSA_HEADER_LENGTH; i<(data[0] - 1); i++)
{
if (data[i] != msa_Data1[i])
return FALSE;
}
}
else
{
return FALSE;
}
return TRUE;
}

/**************************************************************************************************
*
* @fn MSA_HandleKeys
*
* @brief Callback service for keys
*
* @param keys - keys that were pressed
* state - shifted
*
* @return void
*
**************************************************************************************************/
void MSA_HandleKeys(uint8 keys, uint8 shift)
{
#ifdef HAL_BOARD_LM3S9B96
static uint8 msa_keyPressCount = 0;

/* LM3S9B96 board has only one switch. For MSA, pressing SW1 once generates HAL_KEY_SW_1 event.
* Pressing SW1 the 2nd time generates HAL_KEY_SW_2 event. Pressing SW1 the 3rd or more time
* also generates HAL_KEY_SW_2 event.
*/
if (msa_keyPressCount == 0)
{
keys = HAL_KEY_SW_1;
msa_keyPressCount++;
}
else
{
keys = HAL_KEY_SW_2;
}
#endif /* HAL_BOARD_LM3S9B96 */

if ( keys & HAL_KEY_SW_1 )
{
/* Start the device as a direct message device and beacon disabled*/
if (!msa_IsStarted)
{
/* Decide if direct or indirect messaging is used */
msa_IsDirectMsg = MSA_DIRECT_MSG_ENABLED;

if (msa_IsDirectMsg)
{
/* Start the device as an DIRECT messaging device */
if (msa_BeaconOrder != 15)
MSA_ScanReq(MAC_SCAN_PASSIVE, MSA_MAC_BEACON_ORDER + 1);
else
MSA_ScanReq(MAC_SCAN_ACTIVE, 3);
}
else
{
/* Start the device as an INDIRECT messaging device and beacon disabled */
/* Beacon network doesn't work with polling */
if (!msa_IsStarted)
{
msa_IsDirectMsg = FALSE;
MSA_ScanReq(MAC_SCAN_ACTIVE, 3);
}
}
}
#ifdef HAL_BOARD_CC2530USB
/* CC2531DK_Dongle has no Reset button - use S1 if msa_IsStarted */
else
{
/* Wait until user releases S1 */
while ( HAL_PUSH_BUTTON1() );
/* Soft reset leaves USB stuff alone */
SystemResetSoft();
}
#endif /* HAL_BOARD_CC2530USB */
}

if ( keys & HAL_KEY_SW_2 )
{
/* Start sending message */
if (msa_IsStarted)
{
/* Set App's state to SEND or IDLE */
if (msa_State == MSA_IDLE_STATE)
msa_State = MSA_SEND_STATE;
else
msa_State = MSA_IDLE_STATE;

/* Send Event to the App to carry out the changes */
osal_start_timerEx(MSA_TaskId, MSA_SEND_EVENT, 100);
}
}
}

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

thank you

0 pratap yenubari over 9 years ago in reply to Suyash Jain

Expert 2305 points

Hi Suyash,

We are doing the same thing as you explained .

When we send the single byte of data msa_Data1[4], it is working fine but when we try to send even one more byte of data msa_Data1[4], msa_Data1[5] then it stops working i.e. we are not able to receive anything.

We took sampling frequency as 857khz, we also tried for other lower frequencies also.

System frequency = 12MHz

SPI frequency= 6MHz

We are trying to send a sine wave from function generator to analog input of msp4305438a and then after passing the analog data through adc(8 bit) the output is stored in msa_Data1[ ] ( transmission buffer)

Also one more thing, even though it works for single byte to data but still we are not able to sine wave of more than 20Hz when our sampling frequency is very high

I am pasting the code , please look into it and suggest where I am going wrong