bool XBeeUtil::getRadioAddress(XBee* xbee, int32_t& msb, int32_t& lsb, Stream* debug_stream){ bool toRet = true; XBeeUtil::debug_stream = debug_stream; AtCommandRequest atRequest = AtCommandRequest(); AtCommandResponse atResponse = AtCommandResponse(); uint8_t SH_cmd[] = { 'S', 'H' }; uint8_t SL_cmd[] = { 'S', 'L' }; atRequest.setCommand(SH_cmd); if (XBeeUtil::atCommand(xbee, atRequest, atResponse) && atResponse.getValueLength() == 4 && XBeeUtil::readAtResponseInt(xbee, atResponse, msb)) { } else { toRet = false; } atRequest.setCommand(SL_cmd); if (XBeeUtil::atCommand(xbee, atRequest, atResponse) && atResponse.getValueLength() == 4 && XBeeUtil::readAtResponseInt(xbee, atResponse, lsb)) { } else { toRet = false; } return toRet; }
/** 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; }
bool XBeeUtil::associate(XBee* xbee) { uint8_t AI_cmd[] = { 'A', 'I' }; AtCommandRequest atRequest = AtCommandRequest(); AtCommandResponse atResponse = AtCommandResponse(); atRequest.setCommand(AI_cmd); if (XBeeUtil::atCommand(xbee, atRequest, atResponse) && atResponse.getValueLength() == 1) { return true; } else { return false;; } }
/** 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 { } } }
namespace FireNest { struct Channel { int button_pin; int led_pin; int state; int time; }; Channel channels[] = { {2,8,0,0}, {3,9,0,0}, {4,A3,0,0}, {5,A0,0,0}, {6,A1,0,0}, {7,A2,0,0} }; //prototypes void discover(); boolean checkNDResponse(); void flashAll(int ms); void clearLeds(); void nr(uint8_t nr); uint32_t pack(uint32_t c1, uint32_t c2, uint32_t c3, uint32_t c4); //NewSoftSerial mySerial(12, 13); //used when using first button to fire all channels uint8_t channel_count = 0; uint8_t fired_channels = 0; XBee xbee = XBee(); uint8_t payload[] = { 0 }; // SH + SL Address of receiving XBee uint32_t sh = 0; uint32_t sl = 0; //XBeeAddress64 addr64; //XBeeAddress64(0x0013a200, 0x403141DA); XBeeAddress64 addr64; //XBeeAddress64(0x0013a200, 0x403141DA); ZBTxRequest zbTx; ZBTxStatusResponse txStatus = ZBTxStatusResponse(); //for device discovery uint8_t atCmd[] = {'N','D'}; AtCommandRequest atRequest = AtCommandRequest(atCmd); AtCommandResponse atResponse = AtCommandResponse(); void setupold() { //mySerial.begin(4800); //mySerial.println("Hello world"); for (int i= 0; i<CHANNELS; i++) { pinMode(channels[i].button_pin,INPUT); digitalWrite(channels[i].button_pin,HIGH); //enable internal 20K pullup pinMode(channels[i].led_pin,OUTPUT); //blink leds a bit digitalWrite(channels[i].led_pin,HIGH); delay(200); digitalWrite(channels[i].led_pin,LOW); } //debug led //pinMode(13,OUTPUT); //digitalWrite(13,HIGH); //delay(500); //digitalWrite(13,LOW); xbee.begin(XBEE_BAUD); //discover the other XBEE's address discover(); zbTx = ZBTxRequest(addr64, payload, sizeof(payload)); //send a no-op packet so that the xbees can do their magic and find each other payload[0] = 254; xbee.send(zbTx); //Flash all leds once so the user knows flashAll(500); //mySerial.println("Discovered address"); //mySerial.print("MSB: "); //mySerial.println(addr64.getMsb()); //mySerial.println(addr64.getMsb()==0x0013a200?"Yes!":"NO"); //mySerial.print("LSB: "); //mySerial.println(addr64.getLsb()); //mySerial.println(addr64.getLsb()==0x403141DA?"Yes!":"NO"); } //State 0 == not pressed, waiting for press //State 1 == pressed, debouncing time not up //Fire on press //State 2 == pressed, waiting for release //State 3 == release, debouncing time not up void loopold() { int val; int m; for (uint8_t i= 0; i<CHANNELS; i++) { m = millis(); if (channels[i].state == 0 || channels[i].state == 2) { val = digitalRead(channels[i].button_pin); if (channels[i].state == 0 && val == LOW) { //a press!, fire! uint8_t cc = i; //special case, we can fire all channels by firing the first button repeatably if (i == 0) { cc = channel_count; channel_count = (channel_count + 1) % CHANNELS; } //fire! payload[0] = cc; xbee.send(zbTx); //set as fired fired_channels |= (1 << cc); digitalWrite(channels[cc].led_pin,HIGH); //check if all is fired if (fired_channels == B00111111) { //wait a bit delay(500); //reset all channel_count = 0; fired_channels = 0; for (int j = 0; j<CHANNELS; j++) { channels[j].state = 0; digitalWrite(channels[j].led_pin,LOW); delay(300); } break; } } if ((channels[i].state == 0 && val == LOW) || (channels[i].state == 2 && val == HIGH)) { channels[i].state = (channels[i].state + 1) % 4; //change state channels[i].time = m; } } else if (m - channels[i].time > THRESHHOLD) { channels[i].state = (channels[i].state + 1) % 4; //change state } } } //discover target node void discover() { //mySerial.println("discover"); //if we don't get a address we can't fire while (true) { //send node discovery xbee.send(atRequest); //default value is that responding XBEE can wait up to six seconds before answering //so spamming it with node discoverys might be a bad thing, but waiting so long is booring so //we we'll try it and see if it works... //knight rider on the diodes let's the users know we're looking for (int i=0; i<CHANNELS; i++) { clearLeds(); digitalWrite(channels[i % CHANNELS].led_pin,HIGH); if (checkNDResponse()) { return; } } for (int i=CHANNELS-1; i>=0; i--) { clearLeds(); digitalWrite(channels[i % CHANNELS].led_pin,HIGH); if (checkNDResponse()) { return; } } } } 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; } //flash leds once, variable time void flashAll(int ms) { for (int i=0;i<CHANNELS; i++) { digitalWrite(channels[i].led_pin,HIGH); } delay(ms); clearLeds(); } //clear all leds void clearLeds() { for (int i=0;i<CHANNELS; i++) { digitalWrite(channels[i].led_pin,LOW); } } //light up a nr, binary code void nr(uint8_t nr) { //TODO: smarter code... if (nr & B00000001) { digitalWrite(8,HIGH); } if (nr & B00000010) { digitalWrite(9,HIGH); } if (nr & B00000100) { digitalWrite(A3,HIGH); } if (nr & B00001000) { digitalWrite(A0,HIGH); } if (nr & B00010000) { digitalWrite(A1,HIGH); } if (nr & B00100000) { digitalWrite(A2,HIGH); } } uint32_t pack(uint32_t c1, uint32_t c2, uint32_t c3, uint32_t c4) { return (c1 << 24) | (c2 << 16) | (c3 << 8) | (c4); } }
unsigned char info_XBee_data1[96]; char* simbol_ascii[2]; char cmd; XBeeResponse response = XBeeResponse(); //Это создает экземпляр объекта "response" "ответ" обрабатывать пакеты Xbee ZBRxResponse rx = ZBRxResponse(); //Это создает экземпляр объекта "rx" на процесс Xbee Series 2 API пакеты ModemStatusResponse msr = ModemStatusResponse(); //Это создает экземпляр объекта "msr" процесс associate/disassociate packets (PAN membership) ZBRxIoSampleResponse ioSample = ZBRxIoSampleResponse(); XBeeAddress64 addr64 = XBeeAddress64(XBee_Addr64_MS, XBee_Addr64_LS); // SH + SL Address of receiving XBee ZBTxRequest zbTx = ZBTxRequest(addr64, payload, sizeof(payload)); // Формирует пакет zbTx с адресом отправителя и данными ZBTxStatusResponse txStatus = ZBTxStatusResponse(); // Это создает экземпляр объекта "txStatus" процесс благодарности прислал Xbee Series 2 API пакеты AtCommandRequest atRequest = AtCommandRequest(shCmd); // XBeeAddress64 remoteAddress = XBeeAddress64(XBee_Addr64_MS, XBee_Addr64_LS); AtCommandRequest arRequestMod = AtCommandRequest(command, commandValue, commandValueLength); AtCommandResponse atResponse = AtCommandResponse(); RemoteAtCommandRequest remoteAtRequest = RemoteAtCommandRequest(addr64, irCmd, irValue, sizeof(irValue)); // Create a remote AT request with the IR command RemoteAtCommandResponse remoteAtResponse = RemoteAtCommandResponse(); // Create a Remote AT response object XBeeActive RealXBeeMenu; void XBeeActive::setup() { xbee.begin(Serial1); DEBAG.println("\nXBee setup"); } void XBeeActive::sendAtCommand() { int i10; xbee.send(atRequest); if (xbee.readPacket(5000)) // подождите до 5 секунд для ответа состояния