u8 findNodesInBootloaderMode (IEEEAddr *eui64, u8 maxEUI64)
{
u8 status;
u8 reply[3];
u8 count = 0;
txBufferInit(TRUE);
rxBufferInit();
status = bootloadCommand(GET_VERSION, NULL, sizeof(reply), reply);
if (status == BOOTLOAD_COMMAND_SUCCESS) {
if (count < maxEUI64) {
halCommonMemCopy(eui64[count++], &rxBuffer.srcEui64, sizeof(IEEEAddr));
}
while (count < maxEUI64) {
u32 startTime;
u8 found = FALSE;
startTime = TIME_CurrentTime();
while (TIME_ELAPSED(startTime) < 1000000) {
if (rxBuffer.packetReceived) {
halCommonMemCopy(eui64[count++], &rxBuffer.srcEui64, sizeof(IEEEAddr));
rxBuffer.packetReceived = FALSE;
found = TRUE;
break;
}
}
if (! found)
break;
}
}
return count;
}
static void txBufferInit(u8 broadcast)
{
if (broadcast) {
txBufferControl.broadcast = TRUE;
txBufferControl.retries = 0;
txBroadcastBuffer.length = 0;
txBroadcastBuffer.fc = 0xc801;
txBroadcastBuffer.dstPanID = 0xFFFF;
txBroadcastBuffer.dstShortAddr = 0xFFFF;
txBroadcastBuffer.srcPanID = IAP_BOOTLOADER_PAN_ID;
} else {
txBufferControl.broadcast = FALSE;
txBufferControl.retries = MAC_ACK_RETRIES;
txBuffer.length = 0;
txBuffer.fc = 0xcc61;
txBuffer.dstPanID = IAP_BOOTLOADER_PAN_ID;
}
halCommonMemCopy ((void *) TX_BUFFER(srcEui64), ST_RadioGetEui64(), 8);
txBufferControl.retryNumber = 0;
txBufferControl.status = TX_SUCCESS;
txBufferControl.pointer = 0;
}
static u8 transmitByte(u8 *data, u8 lastByte)
{
u8 returnValue = TX_SUCCESS;
txBufferControl.payload[txBufferControl.pointer++] = *data;
if (lastByte) {
if (txBufferControl.broadcast) {
txBroadcastBuffer.length = txBufferControl.pointer + 19;
txBroadcastBuffer.seqNo = txBufferControl.sequenceCounter++;
} else {
txBuffer.length = txBufferControl.pointer + 23;
txBuffer.seqNo = txBufferControl.sequenceCounter++;
}
txBufferControl.status = TX_PENDING;
txBufferControl.retryNumber = 0;
halCommonMemCopy(TX_BUFFER(payload), txBufferControl.payload, txBufferControl.pointer);
returnValue = ST_RadioTransmit((u8 *) TX_BUFFER_GET_POINTER(length));
if (returnValue != TX_SUCCESS) {
txBufferControl.status = TX_FAILED;
}
/* Wait for transmission to complete */
while (txBufferControl.status == TX_PENDING);
returnValue = txBufferControl.status;
txBufferControl.pointer = 0;
}
return returnValue;
}
/**
* @brief This function allows to transmit the data
* @param lenght: lenght of the data
* @param data: data to be transmitted
* @param type: type of data (serial or button)
* @retval None
*/
void sendData(uint8_t length, uint8_t *data, uint8_t type)
{
while (txComplete == FALSE);
txPacket[8] = type;
halCommonMemCopy(txPacket+9, data, length);
txPacket[0] = length + 2 + 7 + 1;
txPacket[3]++; /* increment sequence number */
txComplete = FALSE;
ST_RadioTransmit(txPacket);
}
/*******************************************************************************
* Function Name : sendSerialData
* Description : It allows to transmit the data
* Input : - lenght of the data
* - data to be transmitted
* Output : None
* Return : None
*******************************************************************************/
void sendSerialData(u8 length, u8 *data)
{
while (txComplete == FALSE);
halCommonMemCopy(txPacket+8, data, length);
txPacket[0] = length + 2 + 7;
txPacket[3]++; /* increment sequence number */
txComplete = FALSE;
ST_RadioTransmit(txPacket);
}/* end sendSerialData() */
/*******************************************************************************
* Function Name : ST_RadioReceiveIsrCallback
* Description : Radio Receiver callback function
* Input : - packet: received packet
* - ackFramePendingSet: frame pending bit in the received packet
* - time: MAC timer when the SFD was received
* - errors: numbers of correlator erros in the packet
* - rssi: energy detected in the packet
* Output : None
* Return : None
*******************************************************************************/
void ST_RadioReceiveIsrCallback(u8 *packet,
boolean ackFramePendingSet,
u32 time,
u16 errors,
s8 rssi)
{
rxBufferType *packetReceived = (rxBufferType *) packet;
/* note this is executed from interupt context */
/* Copy the packet to a buffer that can be accessed from the main loop;
don't do the copy if there is already a packet there being processed */
if ((packetReceived->seqNo != rxBuffer.lastSequenceNumber) &&
(packetReceived->fc == 0xCC61)) {
if(rxBuffer.packetReceived == FALSE) {
halCommonMemCopy(&rxBuffer, packet, packet[0] + 1);
rxBuffer.packetReceived = TRUE;
rxBuffer.payloadPointer = 0;
rxBuffer.payloadLength = rxBuffer.length - 21;
} else {
// This should not happen according to the protocol definition
}
rxBuffer.lastSequenceNumber = packetReceived->seqNo;
}
}/* end ST_RadioReceiveIsrCallback() */
int8u halCommonWriteToNvm(const void *data, int32u offset, int16u length)
{
halCommonMemCopy(((int8u *) calibrationData) + offset, data, length);
return ST_SUCCESS;
}
int8u halCommonReadFromNvm(void *data, int32u offset, int16u length)
{
halCommonMemCopy(data, ((int8u *) calibrationData) + offset, length);
return ST_SUCCESS;
}
