/** EXPERT FUNCTION: Sends an ATCommand and returns the response as a 32-bit integer.
If you specify a value of waitForResponse, the program will wait
for the amount of ms specified by waitForResponse and immediately
process the AT response. If you don't specify a value or specify 0
the program will call the general readXbee() and process the response
there and write it to the corresponding variables.
This function will then return 0. **/
uint32_t LithneClass::sendATCommand( uint8_t * cmd, uint16_t waitForResponse )
{
uint32_t atAnswer = 0;
/* Create a new AtComand Request and Response */
AtCommandRequest atRequest = AtCommandRequest();
/* Set the specific command you want to send to the XBee in the atRequest */
atRequest.setCommand( cmd );
/* Send this request to the xbee */
xbee.send( atRequest );
/* The processing of the AT response is handled in the readXBee().
We thus call this function. If we manually tell this function to
wait for a response, it will skip this and attempt to read the
information at this point. */
if( waitForResponse == 0 )
{
readXbee();
}
else
{
if ( xbee.readPacket(waitForResponse) )
{
AtCommandResponse atResponse = AtCommandResponse();
/* If the packet is indeed an AT_COMMAND_RESPONSE, we write it to the atResponse. */
if (xbee.getResponse().getApiId() == AT_COMMAND_RESPONSE)
{
xbee.getResponse().getAtCommandResponse(atResponse);
/* If the atResponse is correct (does not return an error code), we can process it. */
if (atResponse.isOk())
{
if (atResponse.getValueLength() > 0)
{
for (int i = 0; i < atResponse.getValueLength(); i++)
{
atAnswer = (atAnswer << 8) + atResponse.getValue()[i];
}
}
}
}
}
else
{
// at command failed
if (xbee.getResponse().isError())
{
// Serial.print("Error reading packet. Error code: ");
// Serial.println(xbee.getResponse().getErrorCode());
}
else
{
// Serial.print("No response from radio");
}
}
}
return atAnswer;
}
void ConnectOneAdapter::handleAtCommand(XBeeResponse &aResponse)
{
LOCK(sSendLock);
AtCommandResponse cmd;
aResponse.getAtCommandResponse(cmd);
if (cmd.isOk())
{
uint8_t *cp = cmd.getCommand();
if (cp[0] == 'N' && cp[1] == 'P')
{
uint16_t v = ntohs(*((uint16_t*) cmd.getValue()));
mXBee.setMaxSize(v);
gLogger->debug("Maximum payload = %d", v);
// Set the PAN ID
{
uint8_t command[] = { 'I', 'D' };
uint8_t value[] = { 0x11, 0x11 };
AtCommandRequest request(command, value, sizeof(value));
mXBee.send(request);
}
}
else if (cp[0] == 'I' && cp[1] == 'D')
{
// Send a discovery request
uint8_t command[] = { 'N', 'D' };
uint8_t value[] = { 0 };
AtCommandRequest request(command, value, 0);
mXBee.send(request);
}
else if (cp[0] == 'N' && cp[1] == 'D')
{
uint8_t *response = cmd.getValue();
XBeeAddress64 addr(ntohl(*((uint32_t*) (response + 2))),
ntohl(*((uint32_t*) (response + 6))));
getOrCreateDevice(addr);
}
}
UNLOCK(sSendLock);
}
boolean checkNDResponse() {
//mySerial.println("checkNDResponse");
// wait a small bit so the animation looks good
if (xbee.readPacket(ND_WAIT_TIME / 6)) {
// got a response!
// should be an AT command response
if (xbee.getResponse().getApiId() == AT_COMMAND_RESPONSE) {
xbee.getResponse().getAtCommandResponse(atResponse);
if (atResponse.isOk()) {
if (atResponse.getCommand()[0] == atCmd[0] && atResponse.getCommand()[1] == atCmd[1] && atResponse.getValueLength() > 3) {
//mySerial.println(pack(atResponse.getValue()[2],atResponse.getValue()[3],atResponse.getValue()[4],atResponse.getValue()[5]));
//mySerial.println(pack(atResponse.getValue()[6],atResponse.getValue()[7],atResponse.getValue()[8],atResponse.getValue()[9]));
addr64 = XBeeAddress64( pack(atResponse.getValue()[2],atResponse.getValue()[3],atResponse.getValue()[4],atResponse.getValue()[5]),pack(atResponse.getValue()[6],atResponse.getValue()[7],atResponse.getValue()[8],atResponse.getValue()[9]) );
return true;
}
}
else {
//nss.print("Command return error code: ");
//nss.println(atResponse.getStatus(), HEX);
nr(1);
}
} else {
//nss.print("Expected AT response but got ");
//nss.print(xbee.getResponse().getApiId(), HEX);
nr(2);
}
} else {
// at command failed
if (xbee.getResponse().isError()) {
//nss.print("Error reading packet. Error code: ");
//nss.println(xbee.getResponse().getErrorCode());
nr(3);
}
else {
//nss.print("No response from radio");
nr(4);
}
}
return false;
}
bool XBeeMACLayer::getResponseMAC(){
if (atResponse.getValueLength() == 4) {
for (int i = 0; i < atResponse.getValueLength(); i++) {
my_mac.addr[mac_position++] = atResponse.getValue()[i];
}
return true;
}
return false;
}
bool XBeeMACLayer::getResponseCCAFailure(){
if (atResponse.getValueLength() == 2) {
for (int i = 0; i < atResponse.getValueLength(); i++) {
((char*)(&cca_retries))[1] = atResponse.getValue()[0];
((char*)(&cca_retries))[0] = atResponse.getValue()[1];
}
return true;
}
return false;
}
bool XBeeUtil::readAtResponseInt(XBee* xbee, AtCommandResponse& response, int32_t &value) {
if (response.getValueLength() == 4) {
int_packer val;
for (int i = 0, j = 3; i < 4; i++, j--) {
val.data[j] = response.getValue()[i];
}
value = val.value;
return true;
}
return false;
}
void printResponseCb(AtCommandResponse& at, uintptr_t data) {
Print *p = (Print*)data;
p->println("AtCommandResponse received:");
p->print(F(" Command: "));
p->write(at.getCommand(), 2);
p->println();
printField(p, F(" Status: 0x"), at.getStatus());
if (at.getValueLength()) {
p->print(F(" Value: "));
printHex(*p, at.getValue(), at.getValueLength(), F(" "), NULL);
p->println();
}
}
/** This function takes care of all processing when a message is received.
It is called after Lithne.available();
This section is based on examples in the XBee library by Andrew Rapp**/
void LithneClass::readXbee()
{
/*DONT EDIT IF YOU DON'T KNOW WHAT YOU'RE DOING!!! */
/* Reads all available serial bytes until a packet is parsed, an error occurs, or the buffer is empty. */
xbee.readPacket();
if( newXBeePacket ) { newXBeePacket = false; } // Set this flag to false; only raise it if we receive a message
if (xbee.getResponse().isAvailable()) //Returns a reference to the current response Note: once readPacket is called again this response will be overwritten!
{
newXBeePacket = true;
int responseType = xbee.getResponse().getApiId();
if (responseType == ZB_RX_RESPONSE)
{ //Call with instance of ZBRxResponse class only if getApiId() == ZB_RX_RESPONSE to populate response.
/* Indicate we have received a new message */
newMessage = true; // set flag
/* Clear the old received message */
incomingMessage.clearArguments();
xbee.getResponse().getZBRxResponse(rx);
/* Retrieve the sender from the packet and store it in the message */
XBeeAddress64 addr64 = rx.getRemoteAddress64();
uint16_t addr16 = rx.getRemoteAddress16();
/* if the 16 bit add shows this is the coordinator, we store the default
coordinator address 0x0 0x0 instead of the hardware address */
if (addr16 == 0)
{
addr64 = XBeeAddress64(0x0, 0x0);
}
// Serial.println("-----------");
// for( uint16_t i = 0; i <rx.getDataLength(); i++ )
// {
// Serial.print( rx.getData(i) );
// Serial.print( " " );
// }
// Serial.println("");
// Serial.println("-----------");
incomingMessage.setSender( addr16, addr64 );
/* The scope of the message is stored in the first two bytes
of the payload. Here we retrieve this and write it to the
incoming message */
incomingMessage.setScope( (rx.getData(Message::SCOPE_MSB) << 8) + rx.getData(Message::SCOPE_LSB) );
/* The function identifier (1 byte) is stored in the third
byte of the payload. Here we retrieve this and write it to
the incoming message */
incomingMessage.setFunction((rx.getData(Message::FUNCTION_MSB) << 8) + rx.getData(Message::FUNCTION_LSB) );
/* The remainder of the payload contains our arguments. Here
we retrieve the number of arguments, by subtracting the
first three bytes (which contain the scope and the function
ID) and dividing the number of bytes by two, since we send
16-bit values and not 8-bit values (2x 8-bits = 1x 16bits) */
uint16_t numOfBytes = (rx.getDataLength()-Message::MSG_HEADER_SIZE);
/* Store the arguments in the incomingMessage */
for( uint16_t i = 0; i < numOfBytes; i++ )
{
uint16_t pos = i + Message::MSG_HEADER_SIZE;
incomingMessage.addByte( rx.getData(pos) );
}
/* Here we always overwrite the 16-bit address. The received address
is directly taken from the header information and thus correct. */
Node * senderNode = getNodeBy64( addr64 );
if (senderNode != NULL)
{
senderNode->setAddress16( addr16 );
}
// delete senderNode;
/* If the sender(!) of the message got an acknowledgement, this code is executed */
if (rx.getOption() == ZB_PACKET_ACKNOWLEDGED)
{
}
/* If not, something strange has happened, because we got the message, but
the sender did not receive an acknowledgement */
else
{
//we got it (obviously) but sender didn't get an ACK
}
}
/* If the packet is indeed an AT_COMMAND_RESPONSE, we write it to the atResponse. */
else if (responseType == AT_COMMAND_RESPONSE)
{
AtCommandResponse atResponse = AtCommandResponse();
uint32_t atAnswer = 0;
xbee.getResponse().getAtCommandResponse( atResponse );
/* If the atResponse is correct (does not return an error code), we can process it. */
if (atResponse.isOk())
{
newATMessage = true;
if (atResponse.getValueLength() > 0)
{
for (int i = 0; i < atResponse.getValueLength(); i++)
{
atAnswer = (atAnswer << 8) + atResponse.getValue()[i];
}
}
/* If we got a Serial High ('S','H') */
if( atResponse.getCommand()[0] == atSH[0] &&
atResponse.getCommand()[1] == atSH[1] )
{
myAddress64.setMsb( atAnswer );
}
/* If we got a Serial LOW ('S','L') */
if( atResponse.getCommand()[0] == atSL[0] &&
atResponse.getCommand()[1] == atSL[1] )
{
myAddress64.setLsb( atAnswer );
}
/* If we got my 16-bit address ('M','Y') */
if( atResponse.getCommand()[0] == atMY[0] &&
atResponse.getCommand()[1] == atMY[1] )
{
myAddress16 = atAnswer & 0xFFFF;
}
/* If we got my 16-bit address ('M','Y') */
if( atResponse.getCommand()[0] == atID[0] &&
atResponse.getCommand()[1] == atID[1] )
{
myPANid = atAnswer & 0xFFFF;
}
/* If we got my 16-bit address ('M','Y') */
if( atResponse.getCommand()[0] == atAI[0] &&
atResponse.getCommand()[1] == atAI[1] )
{
myAssStat = atAnswer & 0xFFFF;
}
}
else { }
}
/* NODE JOINING/LEAVING THE NETWORK */
else if( responseType == MODEM_STATUS_RESPONSE )
{
xbee.getResponse().getModemStatusResponse(msr);
if (msr.getStatus() == ASSOCIATED)
{
/* A new node has joined the network.
Here we add the node if it is not yet known and store the
64-bit and 16-bit address
*/
// xbee.getResponse().;
}
else if (msr.getStatus() == DISASSOCIATED)
{
/* Node leaves the network
*/
}
}
/* DB MEASUREMENT RESPONSE */
else if( responseType == REMOTE_AT_COMMAND_RESPONSE ) //REMOTE_AT_COMMAND_RESPONSE
{
// Serial.println("Received Remote AT Command Response");
xbee.getResponse().getRemoteAtCommandResponse(rATcmd);
if (rATcmd.isOk())
{
if ( rATcmd.getCommand()[0] == atDB[0] &&
rATcmd.getCommand()[1] == atDB[1] )
{
newRemoteATMessage = true;
XBeeAddress64 rAddress64 = rATcmd.getRemoteAddress64();
uint16_t rAddress16 = rATcmd.getRemoteAddress16();
// Serial.print("AT DB from ");
// Serial.print(rAddress64.getMsb(), HEX);
// Serial.println(rAddress64.getLsb(), HEX);
// This is now done at the end of this section
//getNodeBy64( rAddress64 )->addDBMeasurement( rATcmd.getValue()[0] );
/* The line above replaces this section
for (int i = 0; i < numNodes; i++)
{
if( nodes[i]->getID() == remoteId )
{
nodes[i]->addDBMeasurement( rATcmd.getValue()[0] );
}
}
*/
/* we use this function also to relate 16 bit addresses to 64 bit addresses */
if( !nodeKnown16( rAddress16 ) && nodeKnown64( rAddress64 ) )
{
getNodeBy64( rAddress64 )->setAddress16( rAddress16 );
// Serial.println("We know the 64-bit address, but not the 16-bit - now setting");
}
/* If we receive a message from the coordinator; it has 16-bit add 0. We related this to the node with 64 bit address 0x0 0x0; the coordinator. */
else if ( rAddress16 == 0 && !nodeKnown16( rAddress16 ) )
{
Node * defaultCoordinator = getNodeBy64( XBeeAddress64(0x0,0x0) );
if (defaultCoordinator != NULL)
{
defaultCoordinator->setAddress16( rAddress16 );
}
/*Serial.print("Set 16 bit add of coordinator to ");
Serial.print( getNodeBy64( XBeeAddress64(0x0,0x0) )->getAddress16( ) );
Serial.print(" which is Node ID ");
Serial.print( getNodeBy64( XBeeAddress64(0x0,0x0) )->getID( ) ); */
}
/*Serial.print("Received Remote DB from nodeId ");
Serial.print( getNodeBy16( rAddress16 )->getID() );
Serial.print(" (64b: ");
Serial.print( rAddress64.getLsb(), HEX );
Serial.print(", 16b: ");
Serial.print( rAddress16, DEC );
Serial.print( ") DB val: ");
Serial.println( rATcmd.getValue()[0] ); */
Node * remoteNode = getNodeBy16( rAddress16 );
if ( remoteNode != NULL)
{
remoteNode->addDBMeasurement( rATcmd.getValue()[0] );
}
}
/* Here we can add other remote AT command responses
else if( rATcmd.getCommand()[0] == atSH[0] &&
rATcmd.getCommand()[1] == atSH[1] )
{
}
*/
}
}
/* Confirmation on transmitted package. This is received
everytime a message is transmitted and has details
whether the package is received or not.
*/
else if (responseType == ZB_TX_STATUS_RESPONSE)
{
// Serial.println("Received ZBTxStatusResponse");
xbee.getResponse().getZBTxStatusResponse(txStatus);
if (txStatus.getDeliveryStatus() == SUCCESS)
{
/* Als we hier zijn aangekomen, hebben we een berichtje gestuurd,
dat is goed aangekomen. Deze response geeft echter alleen een
16-bit address terug en geen 64-bit, dus die kunnen we niet aan
een node koppelen.
Nu willen we kijken of de 16-bit bekend is in onze node lijst.
Als dat zo is, dan hoeven we niets te doen, we kennen deze node.
Als dat NIET zo is, dan willen we van deze node ook het 64-bit
address opvragen, zodat we 16-bit en 64-bit op kunnen slaan.
*/
uint16_t rAddress16 = txStatus.getRemoteAddress(); //Stores the 16-bit address
setMessageDelivered( true );
if( !nodeKnown16( rAddress16 ) )
{
/*Here we send something that requests data from the remote node
We can link the two addresses in the returned data (remote at command response)*/
sendDBRequest16( rAddress16 );
}
}
else
{
/* the remote XBee did not receive our packet.
If this is because the 16 bit address is outdated; we wish to reset that */
uint16_t rAddress16 = txStatus.getRemoteAddress(); //Get the 16-bit address
if( nodeKnown16( rAddress16 ) ) // If we know that address, but the message was not received
{
Node * remoteNode = getNodeBy16( rAddress16 );
if ( remoteNode != NULL)
{
remoteNode->setAddress16( UNKNOWN_16B ); // We reset the 16 bit address so it will use the 64 bit again
}
}
}
}
//Something occured that is unknown, or we do not care about
else
{
}
}
}
void XBeeActive::search_XBee()
{
d0Value[0] = 0xFE;
commandValueLength = 0x1;
atRequest.setCommand(NTCmd);
sendAtCommand();
delay(250);
arRequestMod.clearCommandValue();
delay(100);
atRequest.setCommand(NDCmd);
int search_list = 0;
int i10;
Serial.println("\nSending command search XBee");
xbee.send(atRequest);
while (true)
{
if (xbee.readPacket(5000)) // подождите до 5 секунд для ответа состояния
{
if (xbee.getResponse().getApiId() == AT_COMMAND_RESPONSE) // Должна быть команда отклика AT
{
xbee.getResponse().getAtCommandResponse(atResponse);
if (atResponse.isOk())
{
Serial.print("Command [");
Serial.print(atResponse.getCommand()[0]);
Serial.print(atResponse.getCommand()[1]);
Serial.println("] was successful!");
if (atResponse.getValueLength() > 0)
{
Len_XBee = atResponse.getValueLength();
Serial.print("Command value length is - ");
Serial.println(atResponse.getValueLength(), DEC);
Serial.print("Command value: ");
for (i10 = 0; i10 < atResponse.getValueLength(); i10++)
{
info_XBee_data[i10] = atResponse.getValue()[i10];
Serial.print(info_XBee_data[i10], HEX);
Serial.print(" ");
}
Serial.println("");
search_list++;
}
}
else
{
Serial.print("Command return error code: ");
Serial.println(atResponse.getStatus(), HEX);
}
}
else
{
Serial.print("Expected AT response but got ");
Serial.println(xbee.getResponse().getApiId(), HEX);
}
}
else
{
if (xbee.getResponse().isError()) // at command failed
{
Serial.print("Error reading packet. Error code: ");
Serial.println(xbee.getResponse().getErrorCode());
}
else
{
Serial.println("\nNo response from radio1");
return;
}
}
}
}
void XBeeActive::sendAtCommand_ar()
{
int i10;
Serial.println("\nSending command sendAtCommand_ar to the XBee");
xbee.send(arRequestMod); // send the command
// wait up to 5 seconds for the status response
if (xbee.readPacket(5000))
{
// should be an AT command response
if (xbee.getResponse().getApiId() == AT_COMMAND_RESPONSE)
{
xbee.getResponse().getAtCommandResponse(atResponse);
if (atResponse.isOk())
{
//myGLCD.setColor(255 , 0, 0);
// Serial.print("Command [");
// Serial.print(atResponse.getCommand()[0]);
// Serial.print(atResponse.getCommand()[1]);
// Serial.println("] was successful!");
if (atResponse.getValueLength() > 0)
{
Len_XBee = atResponse.getValueLength();
// Serial.print("Command value length is ");
// Serial.println(atResponse.getValueLength(), DEC);
// Serial.print("Command value: ");
int i11 = Len_XBee - 1;
info_XBee_data1[0] = 0;
info_XBee_data1[1] = 0;
info_XBee_data1[2] = 0;
info_XBee_data1[3] = 0;
for (i10 = 0; i10 < atResponse.getValueLength(); i10++)
{
info_XBee_data[i10] = atResponse.getValue()[i10];
Serial.print(info_XBee_data[i10], HEX);
info_XBee_data1[i11] = info_XBee_data[i10];
i11--;
}
// Serial.println("");
}
}
else
{
Serial.print("Command return error code: ");
Serial.println(atResponse.getStatus(), HEX);
//myGLCD.setColor(255, 0, 0);
//myGLCD.fillRoundRect(278, 92, 318, 132);
//myGLCD.setColor(255, 255, 255);
//myGLCD.drawRoundRect(278, 92, 318, 132);
//myGLCD.setBackColor(0, 0, 0);
//delay(200);
////XBee_alarm();
//delay(1000);
//myGLCD.setColor(0, 0, 0);
//myGLCD.fillRoundRect(278, 92, 318, 132);
//myGLCD.setColor(0, 0, 0);
//myGLCD.drawRoundRect(278, 92, 318, 132);
// mcp_Out1.digitalWrite(Beep, LOW); //
delay(300);
}
}
else
{
Serial.print("Expected AT response but got ");
Serial.println(xbee.getResponse().getApiId(), HEX);
}
}
else
{
// at command failed
if (xbee.getResponse().isError())
{
Serial.print("Error reading packet. Error code: ");
Serial.println(xbee.getResponse().getErrorCode());
}
else
{
Serial.println("No response from radio2");
}
}
}
void XBeeActive::sendAtCommand()
{
int i10;
xbee.send(atRequest);
if (xbee.readPacket(5000)) // подождите до 5 секунд для ответа состояния
{
if (xbee.getResponse().getApiId() == AT_COMMAND_RESPONSE) // Должна быть команда отклика AT
{
xbee.getResponse().getAtCommandResponse(atResponse);
if (atResponse.isOk())
{
//DEBAG.print("Command [");
//DEBAG.print(atResponse.getCommand()[0]);
//DEBAG.print(atResponse.getCommand()[1]);
//DEBAG.println("] was successful!");
if (atResponse.getValueLength() > 0)
{
Len_XBee = atResponse.getValueLength();
//DEBAG.print("\nCommand value length is - ");
//DEBAG.println(atResponse.getValueLength(), DEC);
//DEBAG.print("Command value: ");
int i11 = Len_XBee - 1;
info_XBee_data1[0] = 0;
info_XBee_data1[1] = 0;
info_XBee_data1[2] = 0;
info_XBee_data1[3] = 0;
for (i10 = 0; i10 < atResponse.getValueLength(); i10++)
{
info_XBee_data[i10] = atResponse.getValue()[i10];
//DEBAG.print(info_XBee_data[i10], HEX);
//DEBAG.print(" ");
info_XBee_data1[i11] = info_XBee_data[i10];
i11--;
}
//DEBAG.println("");
}
}
else
{
//DEBAG.print("Command return error code: ");
//DEBAG.println(atResponse.getStatus(), HEX);
}
}
else
{
//DEBAG.print("Expected AT response but got ");
//DEBAG.println(xbee.getResponse().getApiId(), HEX);
}
}
else
{
if (xbee.getResponse().isError()) // at command failed
{
//DEBAG.print("Error reading packet. Error code: ");
//DEBAG.println(xbee.getResponse().getErrorCode());
}
else
{
//DEBAG.println("No response from radio1");
}
}
delay(200);
}
