dn_ipmt.c

00001 /*
00002 Copyright (c) 2015, Dust Networks. All rights reserved.
00003 
00004 C library to connect to a SmartMesh IP Mote.
00005 
00006 \license See attached DN_LICENSE.txt.
00007 */
00008 
00009 #include "dn_ipmt.h"
00010 #include "dn_lock.h"
00011 #include "dn_serial_mt.h"
00012 
00013 //=========================== variables =======================================
00014 
00015 typedef struct {
00016    // sending requests
00017    uint8_t              outputBuf[MAX_FRAME_LENGTH];
00018    bool                 busyTx;
00019    uint8_t              cmdId;
00020    uint8_t              paramId;
00021    // receiving replies
00022    dn_ipmt_reply_cbt    replyCb;
00023    uint8_t*             replyContents;
00024    // receiving notifications
00025    dn_ipmt_notif_cbt    notifCb;
00026    uint8_t*             notifBuf;
00027    uint8_t              notifBufLen;
00028 } dn_ipmt_vars_t;
00029 
00030 dn_ipmt_vars_t dn_ipmt_vars;
00031 
00032 //=========================== prototypes ======================================
00033 
00034 // API
00035 void dn_ipmt_setParameter_macAddress_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00036 void dn_ipmt_setParameter_joinKey_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00037 void dn_ipmt_setParameter_networkId_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00038 void dn_ipmt_setParameter_txPower_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00039 void dn_ipmt_setParameter_joinDutyCycle_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00040 void dn_ipmt_setParameter_eventMask_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00041 void dn_ipmt_setParameter_OTAPLockout_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00042 void dn_ipmt_setParameter_routingMode_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00043 void dn_ipmt_setParameter_powerSrcInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00044 void dn_ipmt_setParameter_advKey_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00045 void dn_ipmt_setParameter_autoJoin_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00046 void dn_ipmt_getParameter_macAddress_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00047 void dn_ipmt_getParameter_networkId_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00048 void dn_ipmt_getParameter_txPower_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00049 void dn_ipmt_getParameter_joinDutyCycle_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00050 void dn_ipmt_getParameter_eventMask_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00051 void dn_ipmt_getParameter_moteInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00052 void dn_ipmt_getParameter_netInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00053 void dn_ipmt_getParameter_moteStatus_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00054 void dn_ipmt_getParameter_time_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00055 void dn_ipmt_getParameter_charge_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00056 void dn_ipmt_getParameter_testRadioRxStats_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00057 void dn_ipmt_getParameter_OTAPLockout_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00058 void dn_ipmt_getParameter_moteId_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00059 void dn_ipmt_getParameter_ipv6Address_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00060 void dn_ipmt_getParameter_routingMode_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00061 void dn_ipmt_getParameter_appInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00062 void dn_ipmt_getParameter_powerSrcInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00063 void dn_ipmt_getParameter_autoJoin_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00064 void dn_ipmt_join_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00065 void dn_ipmt_disconnect_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00066 void dn_ipmt_reset_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00067 void dn_ipmt_lowPowerSleep_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00068 void dn_ipmt_testRadioRx_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00069 void dn_ipmt_clearNV_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00070 void dn_ipmt_requestService_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00071 void dn_ipmt_getServiceInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00072 void dn_ipmt_openSocket_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00073 void dn_ipmt_closeSocket_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00074 void dn_ipmt_bindSocket_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00075 void dn_ipmt_sendTo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00076 void dn_ipmt_search_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00077 void dn_ipmt_testRadioTxExt_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00078 void dn_ipmt_zeroize_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00079 void dn_ipmt_socketInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len);
00080 
00081 // serial RX
00082 void dn_ipmt_rxSerialRequest(uint8_t cmdId, uint8_t flags, uint8_t* payload, uint8_t len);
00083 
00084 //=========================== public ==========================================
00085 
00086 //========== admin
00087 
00088 /**
00089 \brief Setting up the instance.
00090 */
00091 void dn_ipmt_init(dn_ipmt_notif_cbt notifCb, uint8_t* notifBuf, uint8_t notifBufLen, dn_ipmt_reply_cbt replyCb) {
00092    
00093    // reset local variables
00094    memset(&dn_ipmt_vars,0,sizeof(dn_ipmt_vars));
00095    
00096    // store params
00097    dn_ipmt_vars.notifCb         = notifCb;
00098    dn_ipmt_vars.notifBuf        = notifBuf;
00099    dn_ipmt_vars.notifBufLen     = notifBufLen;
00100    dn_ipmt_vars.replyCb         = replyCb;
00101    
00102    // initialize the serial connection
00103    dn_serial_mt_init(dn_ipmt_rxSerialRequest);
00104 }
00105 
00106 void dn_ipmt_cancelTx() {
00107    
00108    // lock the module
00109    dn_lock();
00110    
00111    dn_ipmt_vars.busyTx=FALSE;
00112    
00113    // unlock the module
00114    dn_unlock();
00115 }
00116 
00117 
00118 
00119 //========== API
00120 
00121 //===== setParameter_macAddress
00122 
00123 /**
00124 This command allows user to overwrite the manufacturer-assigned MAC address of 
00125 the mote. The new value takes effect after the mote resets. 
00126 */
00127 dn_err_t dn_ipmt_setParameter_macAddress(uint8_t* macAddress, dn_ipmt_setParameter_macAddress_rpt* reply) {
00128    uint8_t    extraFlags;
00129    dn_err_t   rc;
00130    
00131    // lock the module
00132    dn_lock();
00133    
00134    // verify no ongoing transmissions
00135    if (dn_ipmt_vars.busyTx) {
00136       // unlock the module
00137       dn_unlock();
00138       
00139       // return
00140       return DN_ERR_BUSY;
00141    }
00142    
00143    // store callback information
00144    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00145    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00146    dn_ipmt_vars.paramId        = PARAMID_MACADDRESS;
00147    
00148    // extraFlags
00149    extraFlags = 0x00;
00150    
00151    // build outputBuf
00152    dn_ipmt_vars.outputBuf[0] = PARAMID_MACADDRESS;
00153    memcpy(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_MACADDRESS_REQ_OFFS_MACADDRESS],macAddress,8);
00154    
00155    // send outputBuf
00156    rc = dn_serial_mt_sendRequest(
00157       CMDID_SETPARAMETER,                                       // cmdId
00158       extraFlags,                                               // extraFlags
00159       dn_ipmt_vars.outputBuf,                                   // payload
00160       DN_SETPARAMETER_MACADDRESS_REQ_LEN,                       // length
00161       dn_ipmt_setParameter_macAddress_reply                     // replyCb
00162    );
00163    
00164    if (rc==DN_ERR_NONE) {
00165       // I'm now busy transmitting
00166       dn_ipmt_vars.busyTx         = TRUE;
00167    }
00168    
00169    // unlock the module
00170    dn_unlock();
00171    
00172    return rc;
00173    
00174 }
00175 
00176 void dn_ipmt_setParameter_macAddress_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00177    dn_ipmt_setParameter_macAddress_rpt* reply;
00178    uint8_t paramId;
00179    
00180    // verify I'm expecting this answer
00181    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00182       return;
00183    }
00184    
00185    // verify I'm expecting this paramId
00186    paramId = payload[0];
00187    if (paramId!=dn_ipmt_vars.paramId) {
00188       return;
00189    }
00190    
00191    // verify length
00192    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_MACADDRESS_REPLY_LEN) {
00193       return;
00194    }
00195    
00196    // cast the replyContent
00197    reply = (dn_ipmt_setParameter_macAddress_rpt*)dn_ipmt_vars.replyContents;
00198    
00199    // store RC
00200    reply->RC = rc;
00201    
00202    // parse returned value (iff RC==0)
00203    if (rc==DN_SERIAL_RC_OK) {
00204       
00205    }
00206    
00207    // call the callback
00208    dn_ipmt_vars.replyCb(cmdId);
00209    
00210    // I'm not busy transmitting anymore
00211    dn_ipmt_vars.busyTx=FALSE;
00212 }
00213 
00214 //===== setParameter_joinKey
00215 
00216 /**
00217 The setParameter<joinKey> command may be used to set the join key in mote's 
00218 persistent storage. Join keys are used by motes to establish secure connection 
00219 with the network. The join key is used at next join.
00220 
00221 Reading the joinKey parameter is prohibited for security reasons. 
00222 */
00223 dn_err_t dn_ipmt_setParameter_joinKey(uint8_t* joinKey, dn_ipmt_setParameter_joinKey_rpt* reply) {
00224    uint8_t    extraFlags;
00225    dn_err_t   rc;
00226    
00227    // lock the module
00228    dn_lock();
00229    
00230    // verify no ongoing transmissions
00231    if (dn_ipmt_vars.busyTx) {
00232       // unlock the module
00233       dn_unlock();
00234       
00235       // return
00236       return DN_ERR_BUSY;
00237    }
00238    
00239    // store callback information
00240    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00241    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00242    dn_ipmt_vars.paramId        = PARAMID_JOINKEY;
00243    
00244    // extraFlags
00245    extraFlags = 0x00;
00246    
00247    // build outputBuf
00248    dn_ipmt_vars.outputBuf[0] = PARAMID_JOINKEY;
00249    memcpy(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_JOINKEY_REQ_OFFS_JOINKEY],joinKey,16);
00250    
00251    // send outputBuf
00252    rc = dn_serial_mt_sendRequest(
00253       CMDID_SETPARAMETER,                                       // cmdId
00254       extraFlags,                                               // extraFlags
00255       dn_ipmt_vars.outputBuf,                                   // payload
00256       DN_SETPARAMETER_JOINKEY_REQ_LEN,                          // length
00257       dn_ipmt_setParameter_joinKey_reply                        // replyCb
00258    );
00259    
00260    if (rc==DN_ERR_NONE) {
00261       // I'm now busy transmitting
00262       dn_ipmt_vars.busyTx         = TRUE;
00263    }
00264    
00265    // unlock the module
00266    dn_unlock();
00267    
00268    return rc;
00269    
00270 }
00271 
00272 void dn_ipmt_setParameter_joinKey_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00273    dn_ipmt_setParameter_joinKey_rpt* reply;
00274    uint8_t paramId;
00275    
00276    // verify I'm expecting this answer
00277    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00278       return;
00279    }
00280    
00281    // verify I'm expecting this paramId
00282    paramId = payload[0];
00283    if (paramId!=dn_ipmt_vars.paramId) {
00284       return;
00285    }
00286    
00287    // verify length
00288    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_JOINKEY_REPLY_LEN) {
00289       return;
00290    }
00291    
00292    // cast the replyContent
00293    reply = (dn_ipmt_setParameter_joinKey_rpt*)dn_ipmt_vars.replyContents;
00294    
00295    // store RC
00296    reply->RC = rc;
00297    
00298    // parse returned value (iff RC==0)
00299    if (rc==DN_SERIAL_RC_OK) {
00300       
00301    }
00302    
00303    // call the callback
00304    dn_ipmt_vars.replyCb(cmdId);
00305    
00306    // I'm not busy transmitting anymore
00307    dn_ipmt_vars.busyTx=FALSE;
00308 }
00309 
00310 //===== setParameter_networkId
00311 
00312 /**
00313 This command may be used to set the Network ID of the mote. This setting is 
00314 persistent and is used on next join attempt.
00315 
00316 As of version 1.4.x, a network ID of 0xFFFF can be used to indicate that the 
00317 mote should join the first network heard.
00318 
00319 0xFFFF is never used over the air as a valid network ID - you should not set 
00320 the Manager's network ID to 0xFFFF. 
00321 */
00322 dn_err_t dn_ipmt_setParameter_networkId(uint16_t networkId, dn_ipmt_setParameter_networkId_rpt* reply) {
00323    uint8_t    extraFlags;
00324    dn_err_t   rc;
00325    
00326    // lock the module
00327    dn_lock();
00328    
00329    // verify no ongoing transmissions
00330    if (dn_ipmt_vars.busyTx) {
00331       // unlock the module
00332       dn_unlock();
00333       
00334       // return
00335       return DN_ERR_BUSY;
00336    }
00337    
00338    // store callback information
00339    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00340    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00341    dn_ipmt_vars.paramId        = PARAMID_NETWORKID;
00342    
00343    // extraFlags
00344    extraFlags = 0x00;
00345    
00346    // build outputBuf
00347    dn_ipmt_vars.outputBuf[0] = PARAMID_NETWORKID;
00348    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_NETWORKID_REQ_OFFS_NETWORKID],networkId);
00349    
00350    // send outputBuf
00351    rc = dn_serial_mt_sendRequest(
00352       CMDID_SETPARAMETER,                                       // cmdId
00353       extraFlags,                                               // extraFlags
00354       dn_ipmt_vars.outputBuf,                                   // payload
00355       DN_SETPARAMETER_NETWORKID_REQ_LEN,                        // length
00356       dn_ipmt_setParameter_networkId_reply                      // replyCb
00357    );
00358    
00359    if (rc==DN_ERR_NONE) {
00360       // I'm now busy transmitting
00361       dn_ipmt_vars.busyTx         = TRUE;
00362    }
00363    
00364    // unlock the module
00365    dn_unlock();
00366    
00367    return rc;
00368    
00369 }
00370 
00371 void dn_ipmt_setParameter_networkId_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00372    dn_ipmt_setParameter_networkId_rpt* reply;
00373    uint8_t paramId;
00374    
00375    // verify I'm expecting this answer
00376    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00377       return;
00378    }
00379    
00380    // verify I'm expecting this paramId
00381    paramId = payload[0];
00382    if (paramId!=dn_ipmt_vars.paramId) {
00383       return;
00384    }
00385    
00386    // verify length
00387    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_NETWORKID_REPLY_LEN) {
00388       return;
00389    }
00390    
00391    // cast the replyContent
00392    reply = (dn_ipmt_setParameter_networkId_rpt*)dn_ipmt_vars.replyContents;
00393    
00394    // store RC
00395    reply->RC = rc;
00396    
00397    // parse returned value (iff RC==0)
00398    if (rc==DN_SERIAL_RC_OK) {
00399       
00400    }
00401    
00402    // call the callback
00403    dn_ipmt_vars.replyCb(cmdId);
00404    
00405    // I'm not busy transmitting anymore
00406    dn_ipmt_vars.busyTx=FALSE;
00407 }
00408 
00409 //===== setParameter_txPower
00410 
00411 /**
00412 The setParameter<txPower> command sets the mote output power. This setting is 
00413 persistent. The command may be issued at any time and takes effect on next 
00414 transmission. Refer to product datasheets for supported RF output power values. 
00415 For example, if the mote has a typical RF output power of +8 dBm when the power 
00416 amplifier (PA) is enabled, then set the txPower parameter to 8 to enable the 
00417 PA. Similarly, if the mote has a typical RF output power of 0 dBm when the PA 
00418 is disabled, then set the txPower parameter to 0 to turn off the PA. 
00419 */
00420 dn_err_t dn_ipmt_setParameter_txPower(int8_t txPower, dn_ipmt_setParameter_txPower_rpt* reply) {
00421    uint8_t    extraFlags;
00422    dn_err_t   rc;
00423    
00424    // lock the module
00425    dn_lock();
00426    
00427    // verify no ongoing transmissions
00428    if (dn_ipmt_vars.busyTx) {
00429       // unlock the module
00430       dn_unlock();
00431       
00432       // return
00433       return DN_ERR_BUSY;
00434    }
00435    
00436    // store callback information
00437    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00438    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00439    dn_ipmt_vars.paramId        = PARAMID_TXPOWER;
00440    
00441    // extraFlags
00442    extraFlags = 0x00;
00443    
00444    // build outputBuf
00445    dn_ipmt_vars.outputBuf[0] = PARAMID_TXPOWER;
00446    dn_ipmt_vars.outputBuf[DN_SETPARAMETER_TXPOWER_REQ_OFFS_TXPOWER] = (int8_t)txPower;
00447    
00448    // send outputBuf
00449    rc = dn_serial_mt_sendRequest(
00450       CMDID_SETPARAMETER,                                       // cmdId
00451       extraFlags,                                               // extraFlags
00452       dn_ipmt_vars.outputBuf,                                   // payload
00453       DN_SETPARAMETER_TXPOWER_REQ_LEN,                          // length
00454       dn_ipmt_setParameter_txPower_reply                        // replyCb
00455    );
00456    
00457    if (rc==DN_ERR_NONE) {
00458       // I'm now busy transmitting
00459       dn_ipmt_vars.busyTx         = TRUE;
00460    }
00461    
00462    // unlock the module
00463    dn_unlock();
00464    
00465    return rc;
00466    
00467 }
00468 
00469 void dn_ipmt_setParameter_txPower_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00470    dn_ipmt_setParameter_txPower_rpt* reply;
00471    uint8_t paramId;
00472    
00473    // verify I'm expecting this answer
00474    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00475       return;
00476    }
00477    
00478    // verify I'm expecting this paramId
00479    paramId = payload[0];
00480    if (paramId!=dn_ipmt_vars.paramId) {
00481       return;
00482    }
00483    
00484    // verify length
00485    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_TXPOWER_REPLY_LEN) {
00486       return;
00487    }
00488    
00489    // cast the replyContent
00490    reply = (dn_ipmt_setParameter_txPower_rpt*)dn_ipmt_vars.replyContents;
00491    
00492    // store RC
00493    reply->RC = rc;
00494    
00495    // parse returned value (iff RC==0)
00496    if (rc==DN_SERIAL_RC_OK) {
00497       
00498    }
00499    
00500    // call the callback
00501    dn_ipmt_vars.replyCb(cmdId);
00502    
00503    // I'm not busy transmitting anymore
00504    dn_ipmt_vars.busyTx=FALSE;
00505 }
00506 
00507 //===== setParameter_joinDutyCycle
00508 
00509 /**
00510 The setParameter<joinDutyCycle> command allows the microprocessor to control 
00511 the ratio of active listen time to doze time (a low-power radio state) during 
00512 the period when the mote is searching for the network. If you desire a faster 
00513 join time at the risk of higher power consumption, use the 
00514 setParameter<joinDutyCycle> command to increase the join duty cycle up to 100%. 
00515 This setting is persistent and takes effect immediately if the device is 
00516 searching for network. 
00517 */
00518 dn_err_t dn_ipmt_setParameter_joinDutyCycle(uint8_t dutyCycle, dn_ipmt_setParameter_joinDutyCycle_rpt* reply) {
00519    uint8_t    extraFlags;
00520    dn_err_t   rc;
00521    
00522    // lock the module
00523    dn_lock();
00524    
00525    // verify no ongoing transmissions
00526    if (dn_ipmt_vars.busyTx) {
00527       // unlock the module
00528       dn_unlock();
00529       
00530       // return
00531       return DN_ERR_BUSY;
00532    }
00533    
00534    // store callback information
00535    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00536    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00537    dn_ipmt_vars.paramId        = PARAMID_JOINDUTYCYCLE;
00538    
00539    // extraFlags
00540    extraFlags = 0x00;
00541    
00542    // build outputBuf
00543    dn_ipmt_vars.outputBuf[0] = PARAMID_JOINDUTYCYCLE;
00544    dn_ipmt_vars.outputBuf[DN_SETPARAMETER_JOINDUTYCYCLE_REQ_OFFS_DUTYCYCLE] = dutyCycle;
00545    
00546    // send outputBuf
00547    rc = dn_serial_mt_sendRequest(
00548       CMDID_SETPARAMETER,                                       // cmdId
00549       extraFlags,                                               // extraFlags
00550       dn_ipmt_vars.outputBuf,                                   // payload
00551       DN_SETPARAMETER_JOINDUTYCYCLE_REQ_LEN,                    // length
00552       dn_ipmt_setParameter_joinDutyCycle_reply                  // replyCb
00553    );
00554    
00555    if (rc==DN_ERR_NONE) {
00556       // I'm now busy transmitting
00557       dn_ipmt_vars.busyTx         = TRUE;
00558    }
00559    
00560    // unlock the module
00561    dn_unlock();
00562    
00563    return rc;
00564    
00565 }
00566 
00567 void dn_ipmt_setParameter_joinDutyCycle_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00568    dn_ipmt_setParameter_joinDutyCycle_rpt* reply;
00569    uint8_t paramId;
00570    
00571    // verify I'm expecting this answer
00572    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00573       return;
00574    }
00575    
00576    // verify I'm expecting this paramId
00577    paramId = payload[0];
00578    if (paramId!=dn_ipmt_vars.paramId) {
00579       return;
00580    }
00581    
00582    // verify length
00583    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_JOINDUTYCYCLE_REPLY_LEN) {
00584       return;
00585    }
00586    
00587    // cast the replyContent
00588    reply = (dn_ipmt_setParameter_joinDutyCycle_rpt*)dn_ipmt_vars.replyContents;
00589    
00590    // store RC
00591    reply->RC = rc;
00592    
00593    // parse returned value (iff RC==0)
00594    if (rc==DN_SERIAL_RC_OK) {
00595       
00596    }
00597    
00598    // call the callback
00599    dn_ipmt_vars.replyCb(cmdId);
00600    
00601    // I'm not busy transmitting anymore
00602    dn_ipmt_vars.busyTx=FALSE;
00603 }
00604 
00605 //===== setParameter_eventMask
00606 
00607 /**
00608 The setParameter<eventMask> command allows the microprocessor to selectively 
00609 subscribe to event notifications. The default value of eventMask at mote reset 
00610 is all 1s - all events are enabled. This setting is not persistent.
00611 
00612 New event type may be added in future revisions of mote software. It is 
00613 recommended that the client code only subscribe to known events and gracefully 
00614 ignore all unknown events. 
00615 */
00616 dn_err_t dn_ipmt_setParameter_eventMask(uint32_t eventMask, dn_ipmt_setParameter_eventMask_rpt* reply) {
00617    uint8_t    extraFlags;
00618    dn_err_t   rc;
00619    
00620    // lock the module
00621    dn_lock();
00622    
00623    // verify no ongoing transmissions
00624    if (dn_ipmt_vars.busyTx) {
00625       // unlock the module
00626       dn_unlock();
00627       
00628       // return
00629       return DN_ERR_BUSY;
00630    }
00631    
00632    // store callback information
00633    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00634    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00635    dn_ipmt_vars.paramId        = PARAMID_EVENTMASK;
00636    
00637    // extraFlags
00638    extraFlags = 0x00;
00639    
00640    // build outputBuf
00641    dn_ipmt_vars.outputBuf[0] = PARAMID_EVENTMASK;
00642    dn_write_uint32_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_EVENTMASK_REQ_OFFS_EVENTMASK],eventMask);
00643    
00644    // send outputBuf
00645    rc = dn_serial_mt_sendRequest(
00646       CMDID_SETPARAMETER,                                       // cmdId
00647       extraFlags,                                               // extraFlags
00648       dn_ipmt_vars.outputBuf,                                   // payload
00649       DN_SETPARAMETER_EVENTMASK_REQ_LEN,                        // length
00650       dn_ipmt_setParameter_eventMask_reply                      // replyCb
00651    );
00652    
00653    if (rc==DN_ERR_NONE) {
00654       // I'm now busy transmitting
00655       dn_ipmt_vars.busyTx         = TRUE;
00656    }
00657    
00658    // unlock the module
00659    dn_unlock();
00660    
00661    return rc;
00662    
00663 }
00664 
00665 void dn_ipmt_setParameter_eventMask_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00666    dn_ipmt_setParameter_eventMask_rpt* reply;
00667    uint8_t paramId;
00668    
00669    // verify I'm expecting this answer
00670    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00671       return;
00672    }
00673    
00674    // verify I'm expecting this paramId
00675    paramId = payload[0];
00676    if (paramId!=dn_ipmt_vars.paramId) {
00677       return;
00678    }
00679    
00680    // verify length
00681    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_EVENTMASK_REPLY_LEN) {
00682       return;
00683    }
00684    
00685    // cast the replyContent
00686    reply = (dn_ipmt_setParameter_eventMask_rpt*)dn_ipmt_vars.replyContents;
00687    
00688    // store RC
00689    reply->RC = rc;
00690    
00691    // parse returned value (iff RC==0)
00692    if (rc==DN_SERIAL_RC_OK) {
00693       
00694    }
00695    
00696    // call the callback
00697    dn_ipmt_vars.replyCb(cmdId);
00698    
00699    // I'm not busy transmitting anymore
00700    dn_ipmt_vars.busyTx=FALSE;
00701 }
00702 
00703 //===== setParameter_OTAPLockout
00704 
00705 /**
00706 This command allows the microprocessor to control whether Over-The-Air 
00707 Programming (OTAP) of motes is allowed. This setting is persistent and takes 
00708 effect immediately. 
00709 */
00710 dn_err_t dn_ipmt_setParameter_OTAPLockout(bool mode, dn_ipmt_setParameter_OTAPLockout_rpt* reply) {
00711    uint8_t    extraFlags;
00712    dn_err_t   rc;
00713    
00714    // lock the module
00715    dn_lock();
00716    
00717    // verify no ongoing transmissions
00718    if (dn_ipmt_vars.busyTx) {
00719       // unlock the module
00720       dn_unlock();
00721       
00722       // return
00723       return DN_ERR_BUSY;
00724    }
00725    
00726    // store callback information
00727    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00728    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00729    dn_ipmt_vars.paramId        = PARAMID_OTAPLOCKOUT;
00730    
00731    // extraFlags
00732    extraFlags = 0x00;
00733    
00734    // build outputBuf
00735    dn_ipmt_vars.outputBuf[0] = PARAMID_OTAPLOCKOUT;
00736    dn_ipmt_vars.outputBuf[DN_SETPARAMETER_OTAPLOCKOUT_REQ_OFFS_MODE] = mode;
00737    
00738    // send outputBuf
00739    rc = dn_serial_mt_sendRequest(
00740       CMDID_SETPARAMETER,                                       // cmdId
00741       extraFlags,                                               // extraFlags
00742       dn_ipmt_vars.outputBuf,                                   // payload
00743       DN_SETPARAMETER_OTAPLOCKOUT_REQ_LEN,                      // length
00744       dn_ipmt_setParameter_OTAPLockout_reply                    // replyCb
00745    );
00746    
00747    if (rc==DN_ERR_NONE) {
00748       // I'm now busy transmitting
00749       dn_ipmt_vars.busyTx         = TRUE;
00750    }
00751    
00752    // unlock the module
00753    dn_unlock();
00754    
00755    return rc;
00756    
00757 }
00758 
00759 void dn_ipmt_setParameter_OTAPLockout_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00760    dn_ipmt_setParameter_OTAPLockout_rpt* reply;
00761    uint8_t paramId;
00762    
00763    // verify I'm expecting this answer
00764    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00765       return;
00766    }
00767    
00768    // verify I'm expecting this paramId
00769    paramId = payload[0];
00770    if (paramId!=dn_ipmt_vars.paramId) {
00771       return;
00772    }
00773    
00774    // verify length
00775    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_OTAPLOCKOUT_REPLY_LEN) {
00776       return;
00777    }
00778    
00779    // cast the replyContent
00780    reply = (dn_ipmt_setParameter_OTAPLockout_rpt*)dn_ipmt_vars.replyContents;
00781    
00782    // store RC
00783    reply->RC = rc;
00784    
00785    // parse returned value (iff RC==0)
00786    if (rc==DN_SERIAL_RC_OK) {
00787       
00788    }
00789    
00790    // call the callback
00791    dn_ipmt_vars.replyCb(cmdId);
00792    
00793    // I'm not busy transmitting anymore
00794    dn_ipmt_vars.busyTx=FALSE;
00795 }
00796 
00797 //===== setParameter_routingMode
00798 
00799 /**
00800 This command allows the microprocessor to control whether the mote will become 
00801 a router once joined the network. If disabled, the manager will keep the mote a 
00802 leaf node. 
00803 */
00804 dn_err_t dn_ipmt_setParameter_routingMode(bool mode, dn_ipmt_setParameter_routingMode_rpt* reply) {
00805    uint8_t    extraFlags;
00806    dn_err_t   rc;
00807    
00808    // lock the module
00809    dn_lock();
00810    
00811    // verify no ongoing transmissions
00812    if (dn_ipmt_vars.busyTx) {
00813       // unlock the module
00814       dn_unlock();
00815       
00816       // return
00817       return DN_ERR_BUSY;
00818    }
00819    
00820    // store callback information
00821    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00822    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00823    dn_ipmt_vars.paramId        = PARAMID_ROUTINGMODE;
00824    
00825    // extraFlags
00826    extraFlags = 0x00;
00827    
00828    // build outputBuf
00829    dn_ipmt_vars.outputBuf[0] = PARAMID_ROUTINGMODE;
00830    dn_ipmt_vars.outputBuf[DN_SETPARAMETER_ROUTINGMODE_REQ_OFFS_MODE] = mode;
00831    
00832    // send outputBuf
00833    rc = dn_serial_mt_sendRequest(
00834       CMDID_SETPARAMETER,                                       // cmdId
00835       extraFlags,                                               // extraFlags
00836       dn_ipmt_vars.outputBuf,                                   // payload
00837       DN_SETPARAMETER_ROUTINGMODE_REQ_LEN,                      // length
00838       dn_ipmt_setParameter_routingMode_reply                    // replyCb
00839    );
00840    
00841    if (rc==DN_ERR_NONE) {
00842       // I'm now busy transmitting
00843       dn_ipmt_vars.busyTx         = TRUE;
00844    }
00845    
00846    // unlock the module
00847    dn_unlock();
00848    
00849    return rc;
00850    
00851 }
00852 
00853 void dn_ipmt_setParameter_routingMode_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00854    dn_ipmt_setParameter_routingMode_rpt* reply;
00855    uint8_t paramId;
00856    
00857    // verify I'm expecting this answer
00858    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00859       return;
00860    }
00861    
00862    // verify I'm expecting this paramId
00863    paramId = payload[0];
00864    if (paramId!=dn_ipmt_vars.paramId) {
00865       return;
00866    }
00867    
00868    // verify length
00869    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_ROUTINGMODE_REPLY_LEN) {
00870       return;
00871    }
00872    
00873    // cast the replyContent
00874    reply = (dn_ipmt_setParameter_routingMode_rpt*)dn_ipmt_vars.replyContents;
00875    
00876    // store RC
00877    reply->RC = rc;
00878    
00879    // parse returned value (iff RC==0)
00880    if (rc==DN_SERIAL_RC_OK) {
00881       
00882    }
00883    
00884    // call the callback
00885    dn_ipmt_vars.replyCb(cmdId);
00886    
00887    // I'm not busy transmitting anymore
00888    dn_ipmt_vars.busyTx=FALSE;
00889 }
00890 
00891 //===== setParameter_powerSrcInfo
00892 
00893 /**
00894 This command allows the microprocessor to configure power source information on 
00895 the device. This setting is persistent and is used at network join time. 
00896 */
00897 dn_err_t dn_ipmt_setParameter_powerSrcInfo(uint16_t maxStCurrent, uint8_t minLifetime, uint16_t currentLimit_0, uint16_t dischargePeriod_0, uint16_t rechargePeriod_0, uint16_t currentLimit_1, uint16_t dischargePeriod_1, uint16_t rechargePeriod_1, uint16_t currentLimit_2, uint16_t dischargePeriod_2, uint16_t rechargePeriod_2, dn_ipmt_setParameter_powerSrcInfo_rpt* reply) {
00898    uint8_t    extraFlags;
00899    dn_err_t   rc;
00900    
00901    // lock the module
00902    dn_lock();
00903    
00904    // verify no ongoing transmissions
00905    if (dn_ipmt_vars.busyTx) {
00906       // unlock the module
00907       dn_unlock();
00908       
00909       // return
00910       return DN_ERR_BUSY;
00911    }
00912    
00913    // store callback information
00914    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
00915    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
00916    dn_ipmt_vars.paramId        = PARAMID_POWERSRCINFO;
00917    
00918    // extraFlags
00919    extraFlags = 0x00;
00920    
00921    // build outputBuf
00922    dn_ipmt_vars.outputBuf[0] = PARAMID_POWERSRCINFO;
00923    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_MAXSTCURRENT],maxStCurrent);
00924    dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_MINLIFETIME] = minLifetime;
00925    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_CURRENTLIMIT_0],currentLimit_0);
00926    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_DISCHARGEPERIOD_0],dischargePeriod_0);
00927    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_RECHARGEPERIOD_0],rechargePeriod_0);
00928    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_CURRENTLIMIT_1],currentLimit_1);
00929    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_DISCHARGEPERIOD_1],dischargePeriod_1);
00930    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_RECHARGEPERIOD_1],rechargePeriod_1);
00931    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_CURRENTLIMIT_2],currentLimit_2);
00932    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_DISCHARGEPERIOD_2],dischargePeriod_2);
00933    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_POWERSRCINFO_REQ_OFFS_RECHARGEPERIOD_2],rechargePeriod_2);
00934    
00935    // send outputBuf
00936    rc = dn_serial_mt_sendRequest(
00937       CMDID_SETPARAMETER,                                       // cmdId
00938       extraFlags,                                               // extraFlags
00939       dn_ipmt_vars.outputBuf,                                   // payload
00940       DN_SETPARAMETER_POWERSRCINFO_REQ_LEN,                     // length
00941       dn_ipmt_setParameter_powerSrcInfo_reply                   // replyCb
00942    );
00943    
00944    if (rc==DN_ERR_NONE) {
00945       // I'm now busy transmitting
00946       dn_ipmt_vars.busyTx         = TRUE;
00947    }
00948    
00949    // unlock the module
00950    dn_unlock();
00951    
00952    return rc;
00953    
00954 }
00955 
00956 void dn_ipmt_setParameter_powerSrcInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
00957    dn_ipmt_setParameter_powerSrcInfo_rpt* reply;
00958    uint8_t paramId;
00959    
00960    // verify I'm expecting this answer
00961    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
00962       return;
00963    }
00964    
00965    // verify I'm expecting this paramId
00966    paramId = payload[0];
00967    if (paramId!=dn_ipmt_vars.paramId) {
00968       return;
00969    }
00970    
00971    // verify length
00972    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_POWERSRCINFO_REPLY_LEN) {
00973       return;
00974    }
00975    
00976    // cast the replyContent
00977    reply = (dn_ipmt_setParameter_powerSrcInfo_rpt*)dn_ipmt_vars.replyContents;
00978    
00979    // store RC
00980    reply->RC = rc;
00981    
00982    // parse returned value (iff RC==0)
00983    if (rc==DN_SERIAL_RC_OK) {
00984       
00985    }
00986    
00987    // call the callback
00988    dn_ipmt_vars.replyCb(cmdId);
00989    
00990    // I'm not busy transmitting anymore
00991    dn_ipmt_vars.busyTx=FALSE;
00992 }
00993 
00994 //===== setParameter_advKey
00995 
00996 /**
00997 Sets the Advertisement MIC key - this key is used to authenticate 
00998 advertisements, and can be set per vendor/installation to prevent unauthorized 
00999 devices from being able to respond to advertisements. If changed, it must match 
01000 that set on the corresponding AP (using mset on the manager CLI) in order for 
01001 the mote to join. It can be reset to default via the clearNV command. 
01002 */
01003 dn_err_t dn_ipmt_setParameter_advKey(uint8_t* advKey, dn_ipmt_setParameter_advKey_rpt* reply) {
01004    uint8_t    extraFlags;
01005    dn_err_t   rc;
01006    
01007    // lock the module
01008    dn_lock();
01009    
01010    // verify no ongoing transmissions
01011    if (dn_ipmt_vars.busyTx) {
01012       // unlock the module
01013       dn_unlock();
01014       
01015       // return
01016       return DN_ERR_BUSY;
01017    }
01018    
01019    // store callback information
01020    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
01021    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01022    dn_ipmt_vars.paramId        = PARAMID_ADVKEY;
01023    
01024    // extraFlags
01025    extraFlags = 0x00;
01026    
01027    // build outputBuf
01028    dn_ipmt_vars.outputBuf[0] = PARAMID_ADVKEY;
01029    memcpy(&dn_ipmt_vars.outputBuf[DN_SETPARAMETER_ADVKEY_REQ_OFFS_ADVKEY],advKey,16);
01030    
01031    // send outputBuf
01032    rc = dn_serial_mt_sendRequest(
01033       CMDID_SETPARAMETER,                                       // cmdId
01034       extraFlags,                                               // extraFlags
01035       dn_ipmt_vars.outputBuf,                                   // payload
01036       DN_SETPARAMETER_ADVKEY_REQ_LEN,                           // length
01037       dn_ipmt_setParameter_advKey_reply                         // replyCb
01038    );
01039    
01040    if (rc==DN_ERR_NONE) {
01041       // I'm now busy transmitting
01042       dn_ipmt_vars.busyTx         = TRUE;
01043    }
01044    
01045    // unlock the module
01046    dn_unlock();
01047    
01048    return rc;
01049    
01050 }
01051 
01052 void dn_ipmt_setParameter_advKey_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01053    dn_ipmt_setParameter_advKey_rpt* reply;
01054    uint8_t paramId;
01055    
01056    // verify I'm expecting this answer
01057    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01058       return;
01059    }
01060    
01061    // verify I'm expecting this paramId
01062    paramId = payload[0];
01063    if (paramId!=dn_ipmt_vars.paramId) {
01064       return;
01065    }
01066    
01067    // verify length
01068    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_ADVKEY_REPLY_LEN) {
01069       return;
01070    }
01071    
01072    // cast the replyContent
01073    reply = (dn_ipmt_setParameter_advKey_rpt*)dn_ipmt_vars.replyContents;
01074    
01075    // store RC
01076    reply->RC = rc;
01077    
01078    // parse returned value (iff RC==0)
01079    if (rc==DN_SERIAL_RC_OK) {
01080       
01081    }
01082    
01083    // call the callback
01084    dn_ipmt_vars.replyCb(cmdId);
01085    
01086    // I'm not busy transmitting anymore
01087    dn_ipmt_vars.busyTx=FALSE;
01088 }
01089 
01090 //===== setParameter_autoJoin
01091 
01092 /**
01093 This command allows the microprocessor to change between automatic and manual 
01094 joining by the mote's networking stack. In manual mode, an explicit join 
01095 command from the application is required to initiate joining. This setting is 
01096 persistent and takes effect after mote reset.
01097 
01098 Note that auto join mode must not be set if the application is also configured 
01099 to join (e.g combining 'auto join' with 'master' mode will result in mote not 
01100 joining). 
01101 */
01102 dn_err_t dn_ipmt_setParameter_autoJoin(bool mode, dn_ipmt_setParameter_autoJoin_rpt* reply) {
01103    uint8_t    extraFlags;
01104    dn_err_t   rc;
01105    
01106    // lock the module
01107    dn_lock();
01108    
01109    // verify no ongoing transmissions
01110    if (dn_ipmt_vars.busyTx) {
01111       // unlock the module
01112       dn_unlock();
01113       
01114       // return
01115       return DN_ERR_BUSY;
01116    }
01117    
01118    // store callback information
01119    dn_ipmt_vars.cmdId          = CMDID_SETPARAMETER;
01120    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01121    dn_ipmt_vars.paramId        = PARAMID_AUTOJOIN;
01122    
01123    // extraFlags
01124    extraFlags = 0x00;
01125    
01126    // build outputBuf
01127    dn_ipmt_vars.outputBuf[0] = PARAMID_AUTOJOIN;
01128    dn_ipmt_vars.outputBuf[DN_SETPARAMETER_AUTOJOIN_REQ_OFFS_MODE] = mode;
01129    
01130    // send outputBuf
01131    rc = dn_serial_mt_sendRequest(
01132       CMDID_SETPARAMETER,                                       // cmdId
01133       extraFlags,                                               // extraFlags
01134       dn_ipmt_vars.outputBuf,                                   // payload
01135       DN_SETPARAMETER_AUTOJOIN_REQ_LEN,                         // length
01136       dn_ipmt_setParameter_autoJoin_reply                       // replyCb
01137    );
01138    
01139    if (rc==DN_ERR_NONE) {
01140       // I'm now busy transmitting
01141       dn_ipmt_vars.busyTx         = TRUE;
01142    }
01143    
01144    // unlock the module
01145    dn_unlock();
01146    
01147    return rc;
01148    
01149 }
01150 
01151 void dn_ipmt_setParameter_autoJoin_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01152    dn_ipmt_setParameter_autoJoin_rpt* reply;
01153    uint8_t paramId;
01154    
01155    // verify I'm expecting this answer
01156    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01157       return;
01158    }
01159    
01160    // verify I'm expecting this paramId
01161    paramId = payload[0];
01162    if (paramId!=dn_ipmt_vars.paramId) {
01163       return;
01164    }
01165    
01166    // verify length
01167    if (rc==DN_SERIAL_RC_OK && len<DN_SETPARAMETER_AUTOJOIN_REPLY_LEN) {
01168       return;
01169    }
01170    
01171    // cast the replyContent
01172    reply = (dn_ipmt_setParameter_autoJoin_rpt*)dn_ipmt_vars.replyContents;
01173    
01174    // store RC
01175    reply->RC = rc;
01176    
01177    // parse returned value (iff RC==0)
01178    if (rc==DN_SERIAL_RC_OK) {
01179       
01180    }
01181    
01182    // call the callback
01183    dn_ipmt_vars.replyCb(cmdId);
01184    
01185    // I'm not busy transmitting anymore
01186    dn_ipmt_vars.busyTx=FALSE;
01187 }
01188 
01189 //===== getParameter_macAddress
01190 
01191 /**
01192 This command returns the MAC address of the device. By default, the MAC address 
01193 returned is the EUI64 address of the device assigned by mote manufacturer, but 
01194 it may be overwritten using the setParameter<macAddress> command. 
01195 */
01196 dn_err_t dn_ipmt_getParameter_macAddress(dn_ipmt_getParameter_macAddress_rpt* reply) {
01197    uint8_t    extraFlags;
01198    dn_err_t   rc;
01199    
01200    // lock the module
01201    dn_lock();
01202    
01203    // verify no ongoing transmissions
01204    if (dn_ipmt_vars.busyTx) {
01205       // unlock the module
01206       dn_unlock();
01207       
01208       // return
01209       return DN_ERR_BUSY;
01210    }
01211    
01212    // store callback information
01213    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01214    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01215    dn_ipmt_vars.paramId        = PARAMID_MACADDRESS;
01216    
01217    // extraFlags
01218    extraFlags = 0x00;
01219    
01220    // build outputBuf
01221    dn_ipmt_vars.outputBuf[0] = PARAMID_MACADDRESS;
01222    
01223    // send outputBuf
01224    rc = dn_serial_mt_sendRequest(
01225       CMDID_GETPARAMETER,                                       // cmdId
01226       extraFlags,                                               // extraFlags
01227       dn_ipmt_vars.outputBuf,                                   // payload
01228       DN_GETPARAMETER_MACADDRESS_REQ_LEN,                       // length
01229       dn_ipmt_getParameter_macAddress_reply                     // replyCb
01230    );
01231    
01232    if (rc==DN_ERR_NONE) {
01233       // I'm now busy transmitting
01234       dn_ipmt_vars.busyTx         = TRUE;
01235    }
01236    
01237    // unlock the module
01238    dn_unlock();
01239    
01240    return rc;
01241    
01242 }
01243 
01244 void dn_ipmt_getParameter_macAddress_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01245    dn_ipmt_getParameter_macAddress_rpt* reply;
01246    uint8_t paramId;
01247    
01248    // verify I'm expecting this answer
01249    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01250       return;
01251    }
01252    
01253    // verify I'm expecting this paramId
01254    paramId = payload[0];
01255    if (paramId!=dn_ipmt_vars.paramId) {
01256       return;
01257    }
01258    
01259    // verify length
01260    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_MACADDRESS_REPLY_LEN) {
01261       return;
01262    }
01263    
01264    // cast the replyContent
01265    reply = (dn_ipmt_getParameter_macAddress_rpt*)dn_ipmt_vars.replyContents;
01266    
01267    // store RC
01268    reply->RC = rc;
01269    
01270    // parse returned value (iff RC==0)
01271    if (rc==DN_SERIAL_RC_OK) {
01272       
01273       memcpy(&reply->macAddress[0],&payload[DN_GETPARAMETER_MACADDRESS_REPLY_OFFS_MACADDRESS],8);
01274    }
01275    
01276    // call the callback
01277    dn_ipmt_vars.replyCb(cmdId);
01278    
01279    // I'm not busy transmitting anymore
01280    dn_ipmt_vars.busyTx=FALSE;
01281 }
01282 
01283 //===== getParameter_networkId
01284 
01285 /**
01286 This command returns the network id stored in mote's persistent storage. 
01287 */
01288 dn_err_t dn_ipmt_getParameter_networkId(dn_ipmt_getParameter_networkId_rpt* reply) {
01289    uint8_t    extraFlags;
01290    dn_err_t   rc;
01291    
01292    // lock the module
01293    dn_lock();
01294    
01295    // verify no ongoing transmissions
01296    if (dn_ipmt_vars.busyTx) {
01297       // unlock the module
01298       dn_unlock();
01299       
01300       // return
01301       return DN_ERR_BUSY;
01302    }
01303    
01304    // store callback information
01305    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01306    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01307    dn_ipmt_vars.paramId        = PARAMID_NETWORKID;
01308    
01309    // extraFlags
01310    extraFlags = 0x00;
01311    
01312    // build outputBuf
01313    dn_ipmt_vars.outputBuf[0] = PARAMID_NETWORKID;
01314    
01315    // send outputBuf
01316    rc = dn_serial_mt_sendRequest(
01317       CMDID_GETPARAMETER,                                       // cmdId
01318       extraFlags,                                               // extraFlags
01319       dn_ipmt_vars.outputBuf,                                   // payload
01320       DN_GETPARAMETER_NETWORKID_REQ_LEN,                        // length
01321       dn_ipmt_getParameter_networkId_reply                      // replyCb
01322    );
01323    
01324    if (rc==DN_ERR_NONE) {
01325       // I'm now busy transmitting
01326       dn_ipmt_vars.busyTx         = TRUE;
01327    }
01328    
01329    // unlock the module
01330    dn_unlock();
01331    
01332    return rc;
01333    
01334 }
01335 
01336 void dn_ipmt_getParameter_networkId_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01337    dn_ipmt_getParameter_networkId_rpt* reply;
01338    uint8_t paramId;
01339    
01340    // verify I'm expecting this answer
01341    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01342       return;
01343    }
01344    
01345    // verify I'm expecting this paramId
01346    paramId = payload[0];
01347    if (paramId!=dn_ipmt_vars.paramId) {
01348       return;
01349    }
01350    
01351    // verify length
01352    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_NETWORKID_REPLY_LEN) {
01353       return;
01354    }
01355    
01356    // cast the replyContent
01357    reply = (dn_ipmt_getParameter_networkId_rpt*)dn_ipmt_vars.replyContents;
01358    
01359    // store RC
01360    reply->RC = rc;
01361    
01362    // parse returned value (iff RC==0)
01363    if (rc==DN_SERIAL_RC_OK) {
01364       
01365       dn_read_uint16_t(&reply->networkId,&payload[DN_GETPARAMETER_NETWORKID_REPLY_OFFS_NETWORKID]);
01366    }
01367    
01368    // call the callback
01369    dn_ipmt_vars.replyCb(cmdId);
01370    
01371    // I'm not busy transmitting anymore
01372    dn_ipmt_vars.busyTx=FALSE;
01373 }
01374 
01375 //===== getParameter_txPower
01376 
01377 /**
01378 Get the radio output power in dBm, excluding any antenna gain. 
01379 */
01380 dn_err_t dn_ipmt_getParameter_txPower(dn_ipmt_getParameter_txPower_rpt* reply) {
01381    uint8_t    extraFlags;
01382    dn_err_t   rc;
01383    
01384    // lock the module
01385    dn_lock();
01386    
01387    // verify no ongoing transmissions
01388    if (dn_ipmt_vars.busyTx) {
01389       // unlock the module
01390       dn_unlock();
01391       
01392       // return
01393       return DN_ERR_BUSY;
01394    }
01395    
01396    // store callback information
01397    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01398    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01399    dn_ipmt_vars.paramId        = PARAMID_TXPOWER;
01400    
01401    // extraFlags
01402    extraFlags = 0x00;
01403    
01404    // build outputBuf
01405    dn_ipmt_vars.outputBuf[0] = PARAMID_TXPOWER;
01406    
01407    // send outputBuf
01408    rc = dn_serial_mt_sendRequest(
01409       CMDID_GETPARAMETER,                                       // cmdId
01410       extraFlags,                                               // extraFlags
01411       dn_ipmt_vars.outputBuf,                                   // payload
01412       DN_GETPARAMETER_TXPOWER_REQ_LEN,                          // length
01413       dn_ipmt_getParameter_txPower_reply                        // replyCb
01414    );
01415    
01416    if (rc==DN_ERR_NONE) {
01417       // I'm now busy transmitting
01418       dn_ipmt_vars.busyTx         = TRUE;
01419    }
01420    
01421    // unlock the module
01422    dn_unlock();
01423    
01424    return rc;
01425    
01426 }
01427 
01428 void dn_ipmt_getParameter_txPower_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01429    dn_ipmt_getParameter_txPower_rpt* reply;
01430    uint8_t paramId;
01431    
01432    // verify I'm expecting this answer
01433    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01434       return;
01435    }
01436    
01437    // verify I'm expecting this paramId
01438    paramId = payload[0];
01439    if (paramId!=dn_ipmt_vars.paramId) {
01440       return;
01441    }
01442    
01443    // verify length
01444    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_TXPOWER_REPLY_LEN) {
01445       return;
01446    }
01447    
01448    // cast the replyContent
01449    reply = (dn_ipmt_getParameter_txPower_rpt*)dn_ipmt_vars.replyContents;
01450    
01451    // store RC
01452    reply->RC = rc;
01453    
01454    // parse returned value (iff RC==0)
01455    if (rc==DN_SERIAL_RC_OK) {
01456       
01457       reply->txPower = (int8_t)payload[DN_GETPARAMETER_TXPOWER_REPLY_OFFS_TXPOWER];
01458    }
01459    
01460    // call the callback
01461    dn_ipmt_vars.replyCb(cmdId);
01462    
01463    // I'm not busy transmitting anymore
01464    dn_ipmt_vars.busyTx=FALSE;
01465 }
01466 
01467 //===== getParameter_joinDutyCycle
01468 
01469 /**
01470 This command allows user to retrieve current value of joinDutyCycle parameter. 
01471 */
01472 dn_err_t dn_ipmt_getParameter_joinDutyCycle(dn_ipmt_getParameter_joinDutyCycle_rpt* reply) {
01473    uint8_t    extraFlags;
01474    dn_err_t   rc;
01475    
01476    // lock the module
01477    dn_lock();
01478    
01479    // verify no ongoing transmissions
01480    if (dn_ipmt_vars.busyTx) {
01481       // unlock the module
01482       dn_unlock();
01483       
01484       // return
01485       return DN_ERR_BUSY;
01486    }
01487    
01488    // store callback information
01489    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01490    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01491    dn_ipmt_vars.paramId        = PARAMID_JOINDUTYCYCLE;
01492    
01493    // extraFlags
01494    extraFlags = 0x00;
01495    
01496    // build outputBuf
01497    dn_ipmt_vars.outputBuf[0] = PARAMID_JOINDUTYCYCLE;
01498    
01499    // send outputBuf
01500    rc = dn_serial_mt_sendRequest(
01501       CMDID_GETPARAMETER,                                       // cmdId
01502       extraFlags,                                               // extraFlags
01503       dn_ipmt_vars.outputBuf,                                   // payload
01504       DN_GETPARAMETER_JOINDUTYCYCLE_REQ_LEN,                    // length
01505       dn_ipmt_getParameter_joinDutyCycle_reply                  // replyCb
01506    );
01507    
01508    if (rc==DN_ERR_NONE) {
01509       // I'm now busy transmitting
01510       dn_ipmt_vars.busyTx         = TRUE;
01511    }
01512    
01513    // unlock the module
01514    dn_unlock();
01515    
01516    return rc;
01517    
01518 }
01519 
01520 void dn_ipmt_getParameter_joinDutyCycle_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01521    dn_ipmt_getParameter_joinDutyCycle_rpt* reply;
01522    uint8_t paramId;
01523    
01524    // verify I'm expecting this answer
01525    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01526       return;
01527    }
01528    
01529    // verify I'm expecting this paramId
01530    paramId = payload[0];
01531    if (paramId!=dn_ipmt_vars.paramId) {
01532       return;
01533    }
01534    
01535    // verify length
01536    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_JOINDUTYCYCLE_REPLY_LEN) {
01537       return;
01538    }
01539    
01540    // cast the replyContent
01541    reply = (dn_ipmt_getParameter_joinDutyCycle_rpt*)dn_ipmt_vars.replyContents;
01542    
01543    // store RC
01544    reply->RC = rc;
01545    
01546    // parse returned value (iff RC==0)
01547    if (rc==DN_SERIAL_RC_OK) {
01548       
01549       reply->joinDutyCycle = payload[DN_GETPARAMETER_JOINDUTYCYCLE_REPLY_OFFS_JOINDUTYCYCLE];
01550    }
01551    
01552    // call the callback
01553    dn_ipmt_vars.replyCb(cmdId);
01554    
01555    // I'm not busy transmitting anymore
01556    dn_ipmt_vars.busyTx=FALSE;
01557 }
01558 
01559 //===== getParameter_eventMask
01560 
01561 /**
01562 getParameter<eventMask> allows the microprocessor to read the currently 
01563 subscribed-to event types. 
01564 */
01565 dn_err_t dn_ipmt_getParameter_eventMask(dn_ipmt_getParameter_eventMask_rpt* reply) {
01566    uint8_t    extraFlags;
01567    dn_err_t   rc;
01568    
01569    // lock the module
01570    dn_lock();
01571    
01572    // verify no ongoing transmissions
01573    if (dn_ipmt_vars.busyTx) {
01574       // unlock the module
01575       dn_unlock();
01576       
01577       // return
01578       return DN_ERR_BUSY;
01579    }
01580    
01581    // store callback information
01582    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01583    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01584    dn_ipmt_vars.paramId        = PARAMID_EVENTMASK;
01585    
01586    // extraFlags
01587    extraFlags = 0x00;
01588    
01589    // build outputBuf
01590    dn_ipmt_vars.outputBuf[0] = PARAMID_EVENTMASK;
01591    
01592    // send outputBuf
01593    rc = dn_serial_mt_sendRequest(
01594       CMDID_GETPARAMETER,                                       // cmdId
01595       extraFlags,                                               // extraFlags
01596       dn_ipmt_vars.outputBuf,                                   // payload
01597       DN_GETPARAMETER_EVENTMASK_REQ_LEN,                        // length
01598       dn_ipmt_getParameter_eventMask_reply                      // replyCb
01599    );
01600    
01601    if (rc==DN_ERR_NONE) {
01602       // I'm now busy transmitting
01603       dn_ipmt_vars.busyTx         = TRUE;
01604    }
01605    
01606    // unlock the module
01607    dn_unlock();
01608    
01609    return rc;
01610    
01611 }
01612 
01613 void dn_ipmt_getParameter_eventMask_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01614    dn_ipmt_getParameter_eventMask_rpt* reply;
01615    uint8_t paramId;
01616    
01617    // verify I'm expecting this answer
01618    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01619       return;
01620    }
01621    
01622    // verify I'm expecting this paramId
01623    paramId = payload[0];
01624    if (paramId!=dn_ipmt_vars.paramId) {
01625       return;
01626    }
01627    
01628    // verify length
01629    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_EVENTMASK_REPLY_LEN) {
01630       return;
01631    }
01632    
01633    // cast the replyContent
01634    reply = (dn_ipmt_getParameter_eventMask_rpt*)dn_ipmt_vars.replyContents;
01635    
01636    // store RC
01637    reply->RC = rc;
01638    
01639    // parse returned value (iff RC==0)
01640    if (rc==DN_SERIAL_RC_OK) {
01641       
01642       dn_read_uint32_t(&reply->eventMask,&payload[DN_GETPARAMETER_EVENTMASK_REPLY_OFFS_EVENTMASK]);
01643    }
01644    
01645    // call the callback
01646    dn_ipmt_vars.replyCb(cmdId);
01647    
01648    // I'm not busy transmitting anymore
01649    dn_ipmt_vars.busyTx=FALSE;
01650 }
01651 
01652 //===== getParameter_moteInfo
01653 
01654 /**
01655 The getParameter<moteInfo> command returns static information about the 
01656 moteshardware and network stack software. 
01657 */
01658 dn_err_t dn_ipmt_getParameter_moteInfo(dn_ipmt_getParameter_moteInfo_rpt* reply) {
01659    uint8_t    extraFlags;
01660    dn_err_t   rc;
01661    
01662    // lock the module
01663    dn_lock();
01664    
01665    // verify no ongoing transmissions
01666    if (dn_ipmt_vars.busyTx) {
01667       // unlock the module
01668       dn_unlock();
01669       
01670       // return
01671       return DN_ERR_BUSY;
01672    }
01673    
01674    // store callback information
01675    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01676    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01677    dn_ipmt_vars.paramId        = PARAMID_MOTEINFO;
01678    
01679    // extraFlags
01680    extraFlags = 0x00;
01681    
01682    // build outputBuf
01683    dn_ipmt_vars.outputBuf[0] = PARAMID_MOTEINFO;
01684    
01685    // send outputBuf
01686    rc = dn_serial_mt_sendRequest(
01687       CMDID_GETPARAMETER,                                       // cmdId
01688       extraFlags,                                               // extraFlags
01689       dn_ipmt_vars.outputBuf,                                   // payload
01690       DN_GETPARAMETER_MOTEINFO_REQ_LEN,                         // length
01691       dn_ipmt_getParameter_moteInfo_reply                       // replyCb
01692    );
01693    
01694    if (rc==DN_ERR_NONE) {
01695       // I'm now busy transmitting
01696       dn_ipmt_vars.busyTx         = TRUE;
01697    }
01698    
01699    // unlock the module
01700    dn_unlock();
01701    
01702    return rc;
01703    
01704 }
01705 
01706 void dn_ipmt_getParameter_moteInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01707    dn_ipmt_getParameter_moteInfo_rpt* reply;
01708    uint8_t paramId;
01709    
01710    // verify I'm expecting this answer
01711    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01712       return;
01713    }
01714    
01715    // verify I'm expecting this paramId
01716    paramId = payload[0];
01717    if (paramId!=dn_ipmt_vars.paramId) {
01718       return;
01719    }
01720    
01721    // verify length
01722    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_MOTEINFO_REPLY_LEN) {
01723       return;
01724    }
01725    
01726    // cast the replyContent
01727    reply = (dn_ipmt_getParameter_moteInfo_rpt*)dn_ipmt_vars.replyContents;
01728    
01729    // store RC
01730    reply->RC = rc;
01731    
01732    // parse returned value (iff RC==0)
01733    if (rc==DN_SERIAL_RC_OK) {
01734       
01735       reply->apiVersion = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_APIVERSION];
01736       memcpy(&reply->serialNumber[0],&payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_SERIALNUMBER],8);
01737       reply->hwModel = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_HWMODEL];
01738       reply->hwRev = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_HWREV];
01739       reply->swVerMajor = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_SWVERMAJOR];
01740       reply->swVerMinor = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_SWVERMINOR];
01741       reply->swVerPatch = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_SWVERPATCH];
01742       dn_read_uint16_t(&reply->swVerBuild,&payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_SWVERBUILD]);
01743       reply->bootSwVer = payload[DN_GETPARAMETER_MOTEINFO_REPLY_OFFS_BOOTSWVER];
01744    }
01745    
01746    // call the callback
01747    dn_ipmt_vars.replyCb(cmdId);
01748    
01749    // I'm not busy transmitting anymore
01750    dn_ipmt_vars.busyTx=FALSE;
01751 }
01752 
01753 //===== getParameter_netInfo
01754 
01755 /**
01756 The getParameter<networkInfo> command may be used to retrieve the mote's 
01757 network-related parameters. 
01758 */
01759 dn_err_t dn_ipmt_getParameter_netInfo(dn_ipmt_getParameter_netInfo_rpt* reply) {
01760    uint8_t    extraFlags;
01761    dn_err_t   rc;
01762    
01763    // lock the module
01764    dn_lock();
01765    
01766    // verify no ongoing transmissions
01767    if (dn_ipmt_vars.busyTx) {
01768       // unlock the module
01769       dn_unlock();
01770       
01771       // return
01772       return DN_ERR_BUSY;
01773    }
01774    
01775    // store callback information
01776    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01777    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01778    dn_ipmt_vars.paramId        = PARAMID_NETINFO;
01779    
01780    // extraFlags
01781    extraFlags = 0x00;
01782    
01783    // build outputBuf
01784    dn_ipmt_vars.outputBuf[0] = PARAMID_NETINFO;
01785    
01786    // send outputBuf
01787    rc = dn_serial_mt_sendRequest(
01788       CMDID_GETPARAMETER,                                       // cmdId
01789       extraFlags,                                               // extraFlags
01790       dn_ipmt_vars.outputBuf,                                   // payload
01791       DN_GETPARAMETER_NETINFO_REQ_LEN,                          // length
01792       dn_ipmt_getParameter_netInfo_reply                        // replyCb
01793    );
01794    
01795    if (rc==DN_ERR_NONE) {
01796       // I'm now busy transmitting
01797       dn_ipmt_vars.busyTx         = TRUE;
01798    }
01799    
01800    // unlock the module
01801    dn_unlock();
01802    
01803    return rc;
01804    
01805 }
01806 
01807 void dn_ipmt_getParameter_netInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01808    dn_ipmt_getParameter_netInfo_rpt* reply;
01809    uint8_t paramId;
01810    
01811    // verify I'm expecting this answer
01812    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01813       return;
01814    }
01815    
01816    // verify I'm expecting this paramId
01817    paramId = payload[0];
01818    if (paramId!=dn_ipmt_vars.paramId) {
01819       return;
01820    }
01821    
01822    // verify length
01823    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_NETINFO_REPLY_LEN) {
01824       return;
01825    }
01826    
01827    // cast the replyContent
01828    reply = (dn_ipmt_getParameter_netInfo_rpt*)dn_ipmt_vars.replyContents;
01829    
01830    // store RC
01831    reply->RC = rc;
01832    
01833    // parse returned value (iff RC==0)
01834    if (rc==DN_SERIAL_RC_OK) {
01835       
01836       memcpy(&reply->macAddress[0],&payload[DN_GETPARAMETER_NETINFO_REPLY_OFFS_MACADDRESS],8);
01837       dn_read_uint16_t(&reply->moteId,&payload[DN_GETPARAMETER_NETINFO_REPLY_OFFS_MOTEID]);
01838       dn_read_uint16_t(&reply->networkId,&payload[DN_GETPARAMETER_NETINFO_REPLY_OFFS_NETWORKID]);
01839       dn_read_uint16_t(&reply->slotSize,&payload[DN_GETPARAMETER_NETINFO_REPLY_OFFS_SLOTSIZE]);
01840    }
01841    
01842    // call the callback
01843    dn_ipmt_vars.replyCb(cmdId);
01844    
01845    // I'm not busy transmitting anymore
01846    dn_ipmt_vars.busyTx=FALSE;
01847 }
01848 
01849 //===== getParameter_moteStatus
01850 
01851 /**
01852 The getParameter<moteStatus> command is used to retrieve current mote state 
01853 andother dynamic information. 
01854 */
01855 dn_err_t dn_ipmt_getParameter_moteStatus(dn_ipmt_getParameter_moteStatus_rpt* reply) {
01856    uint8_t    extraFlags;
01857    dn_err_t   rc;
01858    
01859    // lock the module
01860    dn_lock();
01861    
01862    // verify no ongoing transmissions
01863    if (dn_ipmt_vars.busyTx) {
01864       // unlock the module
01865       dn_unlock();
01866       
01867       // return
01868       return DN_ERR_BUSY;
01869    }
01870    
01871    // store callback information
01872    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01873    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01874    dn_ipmt_vars.paramId        = PARAMID_MOTESTATUS;
01875    
01876    // extraFlags
01877    extraFlags = 0x00;
01878    
01879    // build outputBuf
01880    dn_ipmt_vars.outputBuf[0] = PARAMID_MOTESTATUS;
01881    
01882    // send outputBuf
01883    rc = dn_serial_mt_sendRequest(
01884       CMDID_GETPARAMETER,                                       // cmdId
01885       extraFlags,                                               // extraFlags
01886       dn_ipmt_vars.outputBuf,                                   // payload
01887       DN_GETPARAMETER_MOTESTATUS_REQ_LEN,                       // length
01888       dn_ipmt_getParameter_moteStatus_reply                     // replyCb
01889    );
01890    
01891    if (rc==DN_ERR_NONE) {
01892       // I'm now busy transmitting
01893       dn_ipmt_vars.busyTx         = TRUE;
01894    }
01895    
01896    // unlock the module
01897    dn_unlock();
01898    
01899    return rc;
01900    
01901 }
01902 
01903 void dn_ipmt_getParameter_moteStatus_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
01904    dn_ipmt_getParameter_moteStatus_rpt* reply;
01905    uint8_t paramId;
01906    
01907    // verify I'm expecting this answer
01908    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
01909       return;
01910    }
01911    
01912    // verify I'm expecting this paramId
01913    paramId = payload[0];
01914    if (paramId!=dn_ipmt_vars.paramId) {
01915       return;
01916    }
01917    
01918    // verify length
01919    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_MOTESTATUS_REPLY_LEN) {
01920       return;
01921    }
01922    
01923    // cast the replyContent
01924    reply = (dn_ipmt_getParameter_moteStatus_rpt*)dn_ipmt_vars.replyContents;
01925    
01926    // store RC
01927    reply->RC = rc;
01928    
01929    // parse returned value (iff RC==0)
01930    if (rc==DN_SERIAL_RC_OK) {
01931       
01932       reply->state = payload[DN_GETPARAMETER_MOTESTATUS_REPLY_OFFS_STATE];
01933       reply->reserved_0 = payload[DN_GETPARAMETER_MOTESTATUS_REPLY_OFFS_RESERVED_0];
01934       dn_read_uint16_t(&reply->reserved_1,&payload[DN_GETPARAMETER_MOTESTATUS_REPLY_OFFS_RESERVED_1]);
01935       reply->numParents = payload[DN_GETPARAMETER_MOTESTATUS_REPLY_OFFS_NUMPARENTS];
01936       dn_read_uint32_t(&reply->alarms,&payload[DN_GETPARAMETER_MOTESTATUS_REPLY_OFFS_ALARMS]);
01937       reply->reserved_2 = payload[DN_GETPARAMETER_MOTESTATUS_REPLY_OFFS_RESERVED_2];
01938    }
01939    
01940    // call the callback
01941    dn_ipmt_vars.replyCb(cmdId);
01942    
01943    // I'm not busy transmitting anymore
01944    dn_ipmt_vars.busyTx=FALSE;
01945 }
01946 
01947 //===== getParameter_time
01948 
01949 /**
01950 The getParameter<time> command may be used to request the current time on the 
01951 mote. The mote reports time at the moment it is processing the command, so the 
01952 information includes variable delay. For more precise time information consider 
01953 using TIMEn pin (see timeIndication). 
01954 */
01955 dn_err_t dn_ipmt_getParameter_time(dn_ipmt_getParameter_time_rpt* reply) {
01956    uint8_t    extraFlags;
01957    dn_err_t   rc;
01958    
01959    // lock the module
01960    dn_lock();
01961    
01962    // verify no ongoing transmissions
01963    if (dn_ipmt_vars.busyTx) {
01964       // unlock the module
01965       dn_unlock();
01966       
01967       // return
01968       return DN_ERR_BUSY;
01969    }
01970    
01971    // store callback information
01972    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
01973    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
01974    dn_ipmt_vars.paramId        = PARAMID_TIME;
01975    
01976    // extraFlags
01977    extraFlags = 0x00;
01978    
01979    // build outputBuf
01980    dn_ipmt_vars.outputBuf[0] = PARAMID_TIME;
01981    
01982    // send outputBuf
01983    rc = dn_serial_mt_sendRequest(
01984       CMDID_GETPARAMETER,                                       // cmdId
01985       extraFlags,                                               // extraFlags
01986       dn_ipmt_vars.outputBuf,                                   // payload
01987       DN_GETPARAMETER_TIME_REQ_LEN,                             // length
01988       dn_ipmt_getParameter_time_reply                           // replyCb
01989    );
01990    
01991    if (rc==DN_ERR_NONE) {
01992       // I'm now busy transmitting
01993       dn_ipmt_vars.busyTx         = TRUE;
01994    }
01995    
01996    // unlock the module
01997    dn_unlock();
01998    
01999    return rc;
02000    
02001 }
02002 
02003 void dn_ipmt_getParameter_time_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02004    dn_ipmt_getParameter_time_rpt* reply;
02005    uint8_t paramId;
02006    
02007    // verify I'm expecting this answer
02008    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02009       return;
02010    }
02011    
02012    // verify I'm expecting this paramId
02013    paramId = payload[0];
02014    if (paramId!=dn_ipmt_vars.paramId) {
02015       return;
02016    }
02017    
02018    // verify length
02019    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_TIME_REPLY_LEN) {
02020       return;
02021    }
02022    
02023    // cast the replyContent
02024    reply = (dn_ipmt_getParameter_time_rpt*)dn_ipmt_vars.replyContents;
02025    
02026    // store RC
02027    reply->RC = rc;
02028    
02029    // parse returned value (iff RC==0)
02030    if (rc==DN_SERIAL_RC_OK) {
02031       
02032       dn_read_uint32_t(&reply->upTime,&payload[DN_GETPARAMETER_TIME_REPLY_OFFS_UPTIME]);
02033       memcpy(&reply->utcSecs[0],&payload[DN_GETPARAMETER_TIME_REPLY_OFFS_UTCSECS],8);
02034       dn_read_uint32_t(&reply->utcUsecs,&payload[DN_GETPARAMETER_TIME_REPLY_OFFS_UTCUSECS]);
02035       memcpy(&reply->asn[0],&payload[DN_GETPARAMETER_TIME_REPLY_OFFS_ASN],5);
02036       dn_read_uint16_t(&reply->asnOffset,&payload[DN_GETPARAMETER_TIME_REPLY_OFFS_ASNOFFSET]);
02037    }
02038    
02039    // call the callback
02040    dn_ipmt_vars.replyCb(cmdId);
02041    
02042    // I'm not busy transmitting anymore
02043    dn_ipmt_vars.busyTx=FALSE;
02044 }
02045 
02046 //===== getParameter_charge
02047 
02048 /**
02049 The getParameter<charge> command retrieves the charge consumption of the 
02050 motesince the last reset. 
02051 */
02052 dn_err_t dn_ipmt_getParameter_charge(dn_ipmt_getParameter_charge_rpt* reply) {
02053    uint8_t    extraFlags;
02054    dn_err_t   rc;
02055    
02056    // lock the module
02057    dn_lock();
02058    
02059    // verify no ongoing transmissions
02060    if (dn_ipmt_vars.busyTx) {
02061       // unlock the module
02062       dn_unlock();
02063       
02064       // return
02065       return DN_ERR_BUSY;
02066    }
02067    
02068    // store callback information
02069    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02070    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02071    dn_ipmt_vars.paramId        = PARAMID_CHARGE;
02072    
02073    // extraFlags
02074    extraFlags = 0x00;
02075    
02076    // build outputBuf
02077    dn_ipmt_vars.outputBuf[0] = PARAMID_CHARGE;
02078    
02079    // send outputBuf
02080    rc = dn_serial_mt_sendRequest(
02081       CMDID_GETPARAMETER,                                       // cmdId
02082       extraFlags,                                               // extraFlags
02083       dn_ipmt_vars.outputBuf,                                   // payload
02084       DN_GETPARAMETER_CHARGE_REQ_LEN,                           // length
02085       dn_ipmt_getParameter_charge_reply                         // replyCb
02086    );
02087    
02088    if (rc==DN_ERR_NONE) {
02089       // I'm now busy transmitting
02090       dn_ipmt_vars.busyTx         = TRUE;
02091    }
02092    
02093    // unlock the module
02094    dn_unlock();
02095    
02096    return rc;
02097    
02098 }
02099 
02100 void dn_ipmt_getParameter_charge_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02101    dn_ipmt_getParameter_charge_rpt* reply;
02102    uint8_t paramId;
02103    
02104    // verify I'm expecting this answer
02105    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02106       return;
02107    }
02108    
02109    // verify I'm expecting this paramId
02110    paramId = payload[0];
02111    if (paramId!=dn_ipmt_vars.paramId) {
02112       return;
02113    }
02114    
02115    // verify length
02116    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_CHARGE_REPLY_LEN) {
02117       return;
02118    }
02119    
02120    // cast the replyContent
02121    reply = (dn_ipmt_getParameter_charge_rpt*)dn_ipmt_vars.replyContents;
02122    
02123    // store RC
02124    reply->RC = rc;
02125    
02126    // parse returned value (iff RC==0)
02127    if (rc==DN_SERIAL_RC_OK) {
02128       
02129       dn_read_uint32_t(&reply->qTotal,&payload[DN_GETPARAMETER_CHARGE_REPLY_OFFS_QTOTAL]);
02130       dn_read_uint32_t(&reply->upTime,&payload[DN_GETPARAMETER_CHARGE_REPLY_OFFS_UPTIME]);
02131       reply->tempInt = (int8_t)payload[DN_GETPARAMETER_CHARGE_REPLY_OFFS_TEMPINT];
02132       reply->tempFrac = payload[DN_GETPARAMETER_CHARGE_REPLY_OFFS_TEMPFRAC];
02133    }
02134    
02135    // call the callback
02136    dn_ipmt_vars.replyCb(cmdId);
02137    
02138    // I'm not busy transmitting anymore
02139    dn_ipmt_vars.busyTx=FALSE;
02140 }
02141 
02142 //===== getParameter_testRadioRxStats
02143 
02144 /**
02145 The getParameter<testRadioRxStats> command retrieves statistics for the latest 
02146 radio test performed using the testRadioRx command. The statistics show the 
02147 number of good and bad packets (CRC failures) received during the test 
02148 */
02149 dn_err_t dn_ipmt_getParameter_testRadioRxStats(dn_ipmt_getParameter_testRadioRxStats_rpt* reply) {
02150    uint8_t    extraFlags;
02151    dn_err_t   rc;
02152    
02153    // lock the module
02154    dn_lock();
02155    
02156    // verify no ongoing transmissions
02157    if (dn_ipmt_vars.busyTx) {
02158       // unlock the module
02159       dn_unlock();
02160       
02161       // return
02162       return DN_ERR_BUSY;
02163    }
02164    
02165    // store callback information
02166    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02167    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02168    dn_ipmt_vars.paramId        = PARAMID_TESTRADIORXSTATS;
02169    
02170    // extraFlags
02171    extraFlags = 0x00;
02172    
02173    // build outputBuf
02174    dn_ipmt_vars.outputBuf[0] = PARAMID_TESTRADIORXSTATS;
02175    
02176    // send outputBuf
02177    rc = dn_serial_mt_sendRequest(
02178       CMDID_GETPARAMETER,                                       // cmdId
02179       extraFlags,                                               // extraFlags
02180       dn_ipmt_vars.outputBuf,                                   // payload
02181       DN_GETPARAMETER_TESTRADIORXSTATS_REQ_LEN,                 // length
02182       dn_ipmt_getParameter_testRadioRxStats_reply               // replyCb
02183    );
02184    
02185    if (rc==DN_ERR_NONE) {
02186       // I'm now busy transmitting
02187       dn_ipmt_vars.busyTx         = TRUE;
02188    }
02189    
02190    // unlock the module
02191    dn_unlock();
02192    
02193    return rc;
02194    
02195 }
02196 
02197 void dn_ipmt_getParameter_testRadioRxStats_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02198    dn_ipmt_getParameter_testRadioRxStats_rpt* reply;
02199    uint8_t paramId;
02200    
02201    // verify I'm expecting this answer
02202    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02203       return;
02204    }
02205    
02206    // verify I'm expecting this paramId
02207    paramId = payload[0];
02208    if (paramId!=dn_ipmt_vars.paramId) {
02209       return;
02210    }
02211    
02212    // verify length
02213    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_TESTRADIORXSTATS_REPLY_LEN) {
02214       return;
02215    }
02216    
02217    // cast the replyContent
02218    reply = (dn_ipmt_getParameter_testRadioRxStats_rpt*)dn_ipmt_vars.replyContents;
02219    
02220    // store RC
02221    reply->RC = rc;
02222    
02223    // parse returned value (iff RC==0)
02224    if (rc==DN_SERIAL_RC_OK) {
02225       
02226       dn_read_uint16_t(&reply->rxOk,&payload[DN_GETPARAMETER_TESTRADIORXSTATS_REPLY_OFFS_RXOK]);
02227       dn_read_uint16_t(&reply->rxFailed,&payload[DN_GETPARAMETER_TESTRADIORXSTATS_REPLY_OFFS_RXFAILED]);
02228    }
02229    
02230    // call the callback
02231    dn_ipmt_vars.replyCb(cmdId);
02232    
02233    // I'm not busy transmitting anymore
02234    dn_ipmt_vars.busyTx=FALSE;
02235 }
02236 
02237 //===== getParameter_OTAPLockout
02238 
02239 /**
02240 This command reads the current state of OTAP lockout, i.e. whether over-the-air 
02241 upgrades of software are permitted on this mote. 
02242 */
02243 dn_err_t dn_ipmt_getParameter_OTAPLockout(dn_ipmt_getParameter_OTAPLockout_rpt* reply) {
02244    uint8_t    extraFlags;
02245    dn_err_t   rc;
02246    
02247    // lock the module
02248    dn_lock();
02249    
02250    // verify no ongoing transmissions
02251    if (dn_ipmt_vars.busyTx) {
02252       // unlock the module
02253       dn_unlock();
02254       
02255       // return
02256       return DN_ERR_BUSY;
02257    }
02258    
02259    // store callback information
02260    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02261    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02262    dn_ipmt_vars.paramId        = PARAMID_OTAPLOCKOUT;
02263    
02264    // extraFlags
02265    extraFlags = 0x00;
02266    
02267    // build outputBuf
02268    dn_ipmt_vars.outputBuf[0] = PARAMID_OTAPLOCKOUT;
02269    
02270    // send outputBuf
02271    rc = dn_serial_mt_sendRequest(
02272       CMDID_GETPARAMETER,                                       // cmdId
02273       extraFlags,                                               // extraFlags
02274       dn_ipmt_vars.outputBuf,                                   // payload
02275       DN_GETPARAMETER_OTAPLOCKOUT_REQ_LEN,                      // length
02276       dn_ipmt_getParameter_OTAPLockout_reply                    // replyCb
02277    );
02278    
02279    if (rc==DN_ERR_NONE) {
02280       // I'm now busy transmitting
02281       dn_ipmt_vars.busyTx         = TRUE;
02282    }
02283    
02284    // unlock the module
02285    dn_unlock();
02286    
02287    return rc;
02288    
02289 }
02290 
02291 void dn_ipmt_getParameter_OTAPLockout_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02292    dn_ipmt_getParameter_OTAPLockout_rpt* reply;
02293    uint8_t paramId;
02294    
02295    // verify I'm expecting this answer
02296    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02297       return;
02298    }
02299    
02300    // verify I'm expecting this paramId
02301    paramId = payload[0];
02302    if (paramId!=dn_ipmt_vars.paramId) {
02303       return;
02304    }
02305    
02306    // verify length
02307    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_OTAPLOCKOUT_REPLY_LEN) {
02308       return;
02309    }
02310    
02311    // cast the replyContent
02312    reply = (dn_ipmt_getParameter_OTAPLockout_rpt*)dn_ipmt_vars.replyContents;
02313    
02314    // store RC
02315    reply->RC = rc;
02316    
02317    // parse returned value (iff RC==0)
02318    if (rc==DN_SERIAL_RC_OK) {
02319       
02320       reply->mode = payload[DN_GETPARAMETER_OTAPLOCKOUT_REPLY_OFFS_MODE];
02321    }
02322    
02323    // call the callback
02324    dn_ipmt_vars.replyCb(cmdId);
02325    
02326    // I'm not busy transmitting anymore
02327    dn_ipmt_vars.busyTx=FALSE;
02328 }
02329 
02330 //===== getParameter_moteId
02331 
02332 /**
02333 This command retrieves the mote's Mote ID. If the mote is not in the network, 
02334 value of 0 is returned. 
02335 */
02336 dn_err_t dn_ipmt_getParameter_moteId(dn_ipmt_getParameter_moteId_rpt* reply) {
02337    uint8_t    extraFlags;
02338    dn_err_t   rc;
02339    
02340    // lock the module
02341    dn_lock();
02342    
02343    // verify no ongoing transmissions
02344    if (dn_ipmt_vars.busyTx) {
02345       // unlock the module
02346       dn_unlock();
02347       
02348       // return
02349       return DN_ERR_BUSY;
02350    }
02351    
02352    // store callback information
02353    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02354    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02355    dn_ipmt_vars.paramId        = PARAMID_MOTEID;
02356    
02357    // extraFlags
02358    extraFlags = 0x00;
02359    
02360    // build outputBuf
02361    dn_ipmt_vars.outputBuf[0] = PARAMID_MOTEID;
02362    
02363    // send outputBuf
02364    rc = dn_serial_mt_sendRequest(
02365       CMDID_GETPARAMETER,                                       // cmdId
02366       extraFlags,                                               // extraFlags
02367       dn_ipmt_vars.outputBuf,                                   // payload
02368       DN_GETPARAMETER_MOTEID_REQ_LEN,                           // length
02369       dn_ipmt_getParameter_moteId_reply                         // replyCb
02370    );
02371    
02372    if (rc==DN_ERR_NONE) {
02373       // I'm now busy transmitting
02374       dn_ipmt_vars.busyTx         = TRUE;
02375    }
02376    
02377    // unlock the module
02378    dn_unlock();
02379    
02380    return rc;
02381    
02382 }
02383 
02384 void dn_ipmt_getParameter_moteId_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02385    dn_ipmt_getParameter_moteId_rpt* reply;
02386    uint8_t paramId;
02387    
02388    // verify I'm expecting this answer
02389    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02390       return;
02391    }
02392    
02393    // verify I'm expecting this paramId
02394    paramId = payload[0];
02395    if (paramId!=dn_ipmt_vars.paramId) {
02396       return;
02397    }
02398    
02399    // verify length
02400    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_MOTEID_REPLY_LEN) {
02401       return;
02402    }
02403    
02404    // cast the replyContent
02405    reply = (dn_ipmt_getParameter_moteId_rpt*)dn_ipmt_vars.replyContents;
02406    
02407    // store RC
02408    reply->RC = rc;
02409    
02410    // parse returned value (iff RC==0)
02411    if (rc==DN_SERIAL_RC_OK) {
02412       
02413       dn_read_uint16_t(&reply->moteId,&payload[DN_GETPARAMETER_MOTEID_REPLY_OFFS_MOTEID]);
02414    }
02415    
02416    // call the callback
02417    dn_ipmt_vars.replyCb(cmdId);
02418    
02419    // I'm not busy transmitting anymore
02420    dn_ipmt_vars.busyTx=FALSE;
02421 }
02422 
02423 //===== getParameter_ipv6Address
02424 
02425 /**
02426 This command allows the microprocessor to read IPV6 address assigned to the 
02427 mote. Before the mote has an assigned address it will return all 0s. 
02428 */
02429 dn_err_t dn_ipmt_getParameter_ipv6Address(dn_ipmt_getParameter_ipv6Address_rpt* reply) {
02430    uint8_t    extraFlags;
02431    dn_err_t   rc;
02432    
02433    // lock the module
02434    dn_lock();
02435    
02436    // verify no ongoing transmissions
02437    if (dn_ipmt_vars.busyTx) {
02438       // unlock the module
02439       dn_unlock();
02440       
02441       // return
02442       return DN_ERR_BUSY;
02443    }
02444    
02445    // store callback information
02446    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02447    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02448    dn_ipmt_vars.paramId        = PARAMID_IPV6ADDRESS;
02449    
02450    // extraFlags
02451    extraFlags = 0x00;
02452    
02453    // build outputBuf
02454    dn_ipmt_vars.outputBuf[0] = PARAMID_IPV6ADDRESS;
02455    
02456    // send outputBuf
02457    rc = dn_serial_mt_sendRequest(
02458       CMDID_GETPARAMETER,                                       // cmdId
02459       extraFlags,                                               // extraFlags
02460       dn_ipmt_vars.outputBuf,                                   // payload
02461       DN_GETPARAMETER_IPV6ADDRESS_REQ_LEN,                      // length
02462       dn_ipmt_getParameter_ipv6Address_reply                    // replyCb
02463    );
02464    
02465    if (rc==DN_ERR_NONE) {
02466       // I'm now busy transmitting
02467       dn_ipmt_vars.busyTx         = TRUE;
02468    }
02469    
02470    // unlock the module
02471    dn_unlock();
02472    
02473    return rc;
02474    
02475 }
02476 
02477 void dn_ipmt_getParameter_ipv6Address_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02478    dn_ipmt_getParameter_ipv6Address_rpt* reply;
02479    uint8_t paramId;
02480    
02481    // verify I'm expecting this answer
02482    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02483       return;
02484    }
02485    
02486    // verify I'm expecting this paramId
02487    paramId = payload[0];
02488    if (paramId!=dn_ipmt_vars.paramId) {
02489       return;
02490    }
02491    
02492    // verify length
02493    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_IPV6ADDRESS_REPLY_LEN) {
02494       return;
02495    }
02496    
02497    // cast the replyContent
02498    reply = (dn_ipmt_getParameter_ipv6Address_rpt*)dn_ipmt_vars.replyContents;
02499    
02500    // store RC
02501    reply->RC = rc;
02502    
02503    // parse returned value (iff RC==0)
02504    if (rc==DN_SERIAL_RC_OK) {
02505       
02506       memcpy(&reply->ipv6Address[0],&payload[DN_GETPARAMETER_IPV6ADDRESS_REPLY_OFFS_IPV6ADDRESS],16);
02507    }
02508    
02509    // call the callback
02510    dn_ipmt_vars.replyCb(cmdId);
02511    
02512    // I'm not busy transmitting anymore
02513    dn_ipmt_vars.busyTx=FALSE;
02514 }
02515 
02516 //===== getParameter_routingMode
02517 
02518 /**
02519 This command allows the microprocessor to retrieve the current routing mode of 
02520 the mote. 
02521 */
02522 dn_err_t dn_ipmt_getParameter_routingMode(dn_ipmt_getParameter_routingMode_rpt* reply) {
02523    uint8_t    extraFlags;
02524    dn_err_t   rc;
02525    
02526    // lock the module
02527    dn_lock();
02528    
02529    // verify no ongoing transmissions
02530    if (dn_ipmt_vars.busyTx) {
02531       // unlock the module
02532       dn_unlock();
02533       
02534       // return
02535       return DN_ERR_BUSY;
02536    }
02537    
02538    // store callback information
02539    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02540    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02541    dn_ipmt_vars.paramId        = PARAMID_ROUTINGMODE;
02542    
02543    // extraFlags
02544    extraFlags = 0x00;
02545    
02546    // build outputBuf
02547    dn_ipmt_vars.outputBuf[0] = PARAMID_ROUTINGMODE;
02548    
02549    // send outputBuf
02550    rc = dn_serial_mt_sendRequest(
02551       CMDID_GETPARAMETER,                                       // cmdId
02552       extraFlags,                                               // extraFlags
02553       dn_ipmt_vars.outputBuf,                                   // payload
02554       DN_GETPARAMETER_ROUTINGMODE_REQ_LEN,                      // length
02555       dn_ipmt_getParameter_routingMode_reply                    // replyCb
02556    );
02557    
02558    if (rc==DN_ERR_NONE) {
02559       // I'm now busy transmitting
02560       dn_ipmt_vars.busyTx         = TRUE;
02561    }
02562    
02563    // unlock the module
02564    dn_unlock();
02565    
02566    return rc;
02567    
02568 }
02569 
02570 void dn_ipmt_getParameter_routingMode_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02571    dn_ipmt_getParameter_routingMode_rpt* reply;
02572    uint8_t paramId;
02573    
02574    // verify I'm expecting this answer
02575    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02576       return;
02577    }
02578    
02579    // verify I'm expecting this paramId
02580    paramId = payload[0];
02581    if (paramId!=dn_ipmt_vars.paramId) {
02582       return;
02583    }
02584    
02585    // verify length
02586    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_ROUTINGMODE_REPLY_LEN) {
02587       return;
02588    }
02589    
02590    // cast the replyContent
02591    reply = (dn_ipmt_getParameter_routingMode_rpt*)dn_ipmt_vars.replyContents;
02592    
02593    // store RC
02594    reply->RC = rc;
02595    
02596    // parse returned value (iff RC==0)
02597    if (rc==DN_SERIAL_RC_OK) {
02598       
02599       reply->routingMode = payload[DN_GETPARAMETER_ROUTINGMODE_REPLY_OFFS_ROUTINGMODE];
02600    }
02601    
02602    // call the callback
02603    dn_ipmt_vars.replyCb(cmdId);
02604    
02605    // I'm not busy transmitting anymore
02606    dn_ipmt_vars.busyTx=FALSE;
02607 }
02608 
02609 //===== getParameter_appInfo
02610 
02611 /**
02612 Get the application (as opposed to the network stack) version information. 
02613 */
02614 dn_err_t dn_ipmt_getParameter_appInfo(dn_ipmt_getParameter_appInfo_rpt* reply) {
02615    uint8_t    extraFlags;
02616    dn_err_t   rc;
02617    
02618    // lock the module
02619    dn_lock();
02620    
02621    // verify no ongoing transmissions
02622    if (dn_ipmt_vars.busyTx) {
02623       // unlock the module
02624       dn_unlock();
02625       
02626       // return
02627       return DN_ERR_BUSY;
02628    }
02629    
02630    // store callback information
02631    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02632    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02633    dn_ipmt_vars.paramId        = PARAMID_APPINFO;
02634    
02635    // extraFlags
02636    extraFlags = 0x00;
02637    
02638    // build outputBuf
02639    dn_ipmt_vars.outputBuf[0] = PARAMID_APPINFO;
02640    
02641    // send outputBuf
02642    rc = dn_serial_mt_sendRequest(
02643       CMDID_GETPARAMETER,                                       // cmdId
02644       extraFlags,                                               // extraFlags
02645       dn_ipmt_vars.outputBuf,                                   // payload
02646       DN_GETPARAMETER_APPINFO_REQ_LEN,                          // length
02647       dn_ipmt_getParameter_appInfo_reply                        // replyCb
02648    );
02649    
02650    if (rc==DN_ERR_NONE) {
02651       // I'm now busy transmitting
02652       dn_ipmt_vars.busyTx         = TRUE;
02653    }
02654    
02655    // unlock the module
02656    dn_unlock();
02657    
02658    return rc;
02659    
02660 }
02661 
02662 void dn_ipmt_getParameter_appInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02663    dn_ipmt_getParameter_appInfo_rpt* reply;
02664    uint8_t paramId;
02665    
02666    // verify I'm expecting this answer
02667    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02668       return;
02669    }
02670    
02671    // verify I'm expecting this paramId
02672    paramId = payload[0];
02673    if (paramId!=dn_ipmt_vars.paramId) {
02674       return;
02675    }
02676    
02677    // verify length
02678    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_APPINFO_REPLY_LEN) {
02679       return;
02680    }
02681    
02682    // cast the replyContent
02683    reply = (dn_ipmt_getParameter_appInfo_rpt*)dn_ipmt_vars.replyContents;
02684    
02685    // store RC
02686    reply->RC = rc;
02687    
02688    // parse returned value (iff RC==0)
02689    if (rc==DN_SERIAL_RC_OK) {
02690       
02691       dn_read_uint16_t(&reply->vendorId,&payload[DN_GETPARAMETER_APPINFO_REPLY_OFFS_VENDORID]);
02692       reply->appId = payload[DN_GETPARAMETER_APPINFO_REPLY_OFFS_APPID];
02693       memcpy(&reply->appVer[0],&payload[DN_GETPARAMETER_APPINFO_REPLY_OFFS_APPVER],5);
02694    }
02695    
02696    // call the callback
02697    dn_ipmt_vars.replyCb(cmdId);
02698    
02699    // I'm not busy transmitting anymore
02700    dn_ipmt_vars.busyTx=FALSE;
02701 }
02702 
02703 //===== getParameter_powerSrcInfo
02704 
02705 /**
02706 This command allows the microprocessor to read a mote's power source settings. 
02707 */
02708 dn_err_t dn_ipmt_getParameter_powerSrcInfo(dn_ipmt_getParameter_powerSrcInfo_rpt* reply) {
02709    uint8_t    extraFlags;
02710    dn_err_t   rc;
02711    
02712    // lock the module
02713    dn_lock();
02714    
02715    // verify no ongoing transmissions
02716    if (dn_ipmt_vars.busyTx) {
02717       // unlock the module
02718       dn_unlock();
02719       
02720       // return
02721       return DN_ERR_BUSY;
02722    }
02723    
02724    // store callback information
02725    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02726    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02727    dn_ipmt_vars.paramId        = PARAMID_POWERSRCINFO;
02728    
02729    // extraFlags
02730    extraFlags = 0x00;
02731    
02732    // build outputBuf
02733    dn_ipmt_vars.outputBuf[0] = PARAMID_POWERSRCINFO;
02734    
02735    // send outputBuf
02736    rc = dn_serial_mt_sendRequest(
02737       CMDID_GETPARAMETER,                                       // cmdId
02738       extraFlags,                                               // extraFlags
02739       dn_ipmt_vars.outputBuf,                                   // payload
02740       DN_GETPARAMETER_POWERSRCINFO_REQ_LEN,                     // length
02741       dn_ipmt_getParameter_powerSrcInfo_reply                   // replyCb
02742    );
02743    
02744    if (rc==DN_ERR_NONE) {
02745       // I'm now busy transmitting
02746       dn_ipmt_vars.busyTx         = TRUE;
02747    }
02748    
02749    // unlock the module
02750    dn_unlock();
02751    
02752    return rc;
02753    
02754 }
02755 
02756 void dn_ipmt_getParameter_powerSrcInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02757    dn_ipmt_getParameter_powerSrcInfo_rpt* reply;
02758    uint8_t paramId;
02759    
02760    // verify I'm expecting this answer
02761    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02762       return;
02763    }
02764    
02765    // verify I'm expecting this paramId
02766    paramId = payload[0];
02767    if (paramId!=dn_ipmt_vars.paramId) {
02768       return;
02769    }
02770    
02771    // verify length
02772    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_POWERSRCINFO_REPLY_LEN) {
02773       return;
02774    }
02775    
02776    // cast the replyContent
02777    reply = (dn_ipmt_getParameter_powerSrcInfo_rpt*)dn_ipmt_vars.replyContents;
02778    
02779    // store RC
02780    reply->RC = rc;
02781    
02782    // parse returned value (iff RC==0)
02783    if (rc==DN_SERIAL_RC_OK) {
02784       
02785       dn_read_uint16_t(&reply->maxStCurrent,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_MAXSTCURRENT]);
02786       reply->minLifetime = payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_MINLIFETIME];
02787       dn_read_uint16_t(&reply->currentLimit_0,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_CURRENTLIMIT_0]);
02788       dn_read_uint16_t(&reply->dischargePeriod_0,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_DISCHARGEPERIOD_0]);
02789       dn_read_uint16_t(&reply->rechargePeriod_0,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_RECHARGEPERIOD_0]);
02790       dn_read_uint16_t(&reply->currentLimit_1,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_CURRENTLIMIT_1]);
02791       dn_read_uint16_t(&reply->dischargePeriod_1,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_DISCHARGEPERIOD_1]);
02792       dn_read_uint16_t(&reply->rechargePeriod_1,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_RECHARGEPERIOD_1]);
02793       dn_read_uint16_t(&reply->currentLimit_2,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_CURRENTLIMIT_2]);
02794       dn_read_uint16_t(&reply->dischargePeriod_2,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_DISCHARGEPERIOD_2]);
02795       dn_read_uint16_t(&reply->rechargePeriod_2,&payload[DN_GETPARAMETER_POWERSRCINFO_REPLY_OFFS_RECHARGEPERIOD_2]);
02796    }
02797    
02798    // call the callback
02799    dn_ipmt_vars.replyCb(cmdId);
02800    
02801    // I'm not busy transmitting anymore
02802    dn_ipmt_vars.busyTx=FALSE;
02803 }
02804 
02805 //===== getParameter_autoJoin
02806 
02807 /**
02808 This command allows the microprocessor to retrieve the current autoJoin 
02809 setting. 
02810 */
02811 dn_err_t dn_ipmt_getParameter_autoJoin(dn_ipmt_getParameter_autoJoin_rpt* reply) {
02812    uint8_t    extraFlags;
02813    dn_err_t   rc;
02814    
02815    // lock the module
02816    dn_lock();
02817    
02818    // verify no ongoing transmissions
02819    if (dn_ipmt_vars.busyTx) {
02820       // unlock the module
02821       dn_unlock();
02822       
02823       // return
02824       return DN_ERR_BUSY;
02825    }
02826    
02827    // store callback information
02828    dn_ipmt_vars.cmdId          = CMDID_GETPARAMETER;
02829    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02830    dn_ipmt_vars.paramId        = PARAMID_AUTOJOIN;
02831    
02832    // extraFlags
02833    extraFlags = 0x00;
02834    
02835    // build outputBuf
02836    dn_ipmt_vars.outputBuf[0] = PARAMID_AUTOJOIN;
02837    
02838    // send outputBuf
02839    rc = dn_serial_mt_sendRequest(
02840       CMDID_GETPARAMETER,                                       // cmdId
02841       extraFlags,                                               // extraFlags
02842       dn_ipmt_vars.outputBuf,                                   // payload
02843       DN_GETPARAMETER_AUTOJOIN_REQ_LEN,                         // length
02844       dn_ipmt_getParameter_autoJoin_reply                       // replyCb
02845    );
02846    
02847    if (rc==DN_ERR_NONE) {
02848       // I'm now busy transmitting
02849       dn_ipmt_vars.busyTx         = TRUE;
02850    }
02851    
02852    // unlock the module
02853    dn_unlock();
02854    
02855    return rc;
02856    
02857 }
02858 
02859 void dn_ipmt_getParameter_autoJoin_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02860    dn_ipmt_getParameter_autoJoin_rpt* reply;
02861    uint8_t paramId;
02862    
02863    // verify I'm expecting this answer
02864    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02865       return;
02866    }
02867    
02868    // verify I'm expecting this paramId
02869    paramId = payload[0];
02870    if (paramId!=dn_ipmt_vars.paramId) {
02871       return;
02872    }
02873    
02874    // verify length
02875    if (rc==DN_SERIAL_RC_OK && len<DN_GETPARAMETER_AUTOJOIN_REPLY_LEN) {
02876       return;
02877    }
02878    
02879    // cast the replyContent
02880    reply = (dn_ipmt_getParameter_autoJoin_rpt*)dn_ipmt_vars.replyContents;
02881    
02882    // store RC
02883    reply->RC = rc;
02884    
02885    // parse returned value (iff RC==0)
02886    if (rc==DN_SERIAL_RC_OK) {
02887       
02888       reply->autoJoin = payload[DN_GETPARAMETER_AUTOJOIN_REPLY_OFFS_AUTOJOIN];
02889    }
02890    
02891    // call the callback
02892    dn_ipmt_vars.replyCb(cmdId);
02893    
02894    // I'm not busy transmitting anymore
02895    dn_ipmt_vars.busyTx=FALSE;
02896 }
02897 
02898 //===== join
02899 
02900 /**
02901 The join command requests that mote start searching for the network and attempt 
02902 to join.The mote must be in the Idle state or the Promiscuous Listen state(see 
02903 search) for this command to be valid. Note that the join time will be affected 
02904 by the maximum current setting. 
02905 */
02906 dn_err_t dn_ipmt_join(dn_ipmt_join_rpt* reply) {
02907    uint8_t    extraFlags;
02908    dn_err_t   rc;
02909    
02910    // lock the module
02911    dn_lock();
02912    
02913    // verify no ongoing transmissions
02914    if (dn_ipmt_vars.busyTx) {
02915       // unlock the module
02916       dn_unlock();
02917       
02918       // return
02919       return DN_ERR_BUSY;
02920    }
02921    
02922    // store callback information
02923    dn_ipmt_vars.cmdId          = CMDID_JOIN;
02924    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
02925    
02926    // extraFlags
02927    extraFlags = 0x00;
02928    
02929    // build outputBuf
02930    
02931    // send outputBuf
02932    rc = dn_serial_mt_sendRequest(
02933       CMDID_JOIN,                                               // cmdId
02934       extraFlags,                                               // extraFlags
02935       dn_ipmt_vars.outputBuf,                                   // payload
02936       DN_JOIN_REQ_LEN,                                          // length
02937       dn_ipmt_join_reply                                        // replyCb
02938    );
02939    
02940    if (rc==DN_ERR_NONE) {
02941       // I'm now busy transmitting
02942       dn_ipmt_vars.busyTx         = TRUE;
02943    }
02944    
02945    // unlock the module
02946    dn_unlock();
02947    
02948    return rc;
02949    
02950 }
02951 
02952 void dn_ipmt_join_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
02953    dn_ipmt_join_rpt* reply;
02954    
02955    // verify I'm expecting this answer
02956    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
02957       return;
02958    }
02959    
02960    // do NOT verify length (no return fields expected)
02961    
02962    // cast the replyContent
02963    reply = (dn_ipmt_join_rpt*)dn_ipmt_vars.replyContents;
02964    
02965    // store RC
02966    reply->RC = rc;
02967    
02968    // parse returned value (iff RC==0)
02969    if (rc==DN_SERIAL_RC_OK) {
02970       
02971    }
02972    
02973    // call the callback
02974    dn_ipmt_vars.replyCb(cmdId);
02975    
02976    // I'm not busy transmitting anymore
02977    dn_ipmt_vars.busyTx=FALSE;
02978 }
02979 
02980 //===== disconnect
02981 
02982 /**
02983 The disconnect command requests that the mote initiate disconnection from the 
02984 network. After disconnection completes, the mote will generate a disconnected 
02985 event, and proceed to reset. If the mote is not in the network, the 
02986 disconnected event will be generated immediately. This command may be issued at 
02987 any time. 
02988 */
02989 dn_err_t dn_ipmt_disconnect(dn_ipmt_disconnect_rpt* reply) {
02990    uint8_t    extraFlags;
02991    dn_err_t   rc;
02992    
02993    // lock the module
02994    dn_lock();
02995    
02996    // verify no ongoing transmissions
02997    if (dn_ipmt_vars.busyTx) {
02998       // unlock the module
02999       dn_unlock();
03000       
03001       // return
03002       return DN_ERR_BUSY;
03003    }
03004    
03005    // store callback information
03006    dn_ipmt_vars.cmdId          = CMDID_DISCONNECT;
03007    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03008    
03009    // extraFlags
03010    extraFlags = 0x00;
03011    
03012    // build outputBuf
03013    
03014    // send outputBuf
03015    rc = dn_serial_mt_sendRequest(
03016       CMDID_DISCONNECT,                                         // cmdId
03017       extraFlags,                                               // extraFlags
03018       dn_ipmt_vars.outputBuf,                                   // payload
03019       DN_DISCONNECT_REQ_LEN,                                    // length
03020       dn_ipmt_disconnect_reply                                  // replyCb
03021    );
03022    
03023    if (rc==DN_ERR_NONE) {
03024       // I'm now busy transmitting
03025       dn_ipmt_vars.busyTx         = TRUE;
03026    }
03027    
03028    // unlock the module
03029    dn_unlock();
03030    
03031    return rc;
03032    
03033 }
03034 
03035 void dn_ipmt_disconnect_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03036    dn_ipmt_disconnect_rpt* reply;
03037    
03038    // verify I'm expecting this answer
03039    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03040       return;
03041    }
03042    
03043    // do NOT verify length (no return fields expected)
03044    
03045    // cast the replyContent
03046    reply = (dn_ipmt_disconnect_rpt*)dn_ipmt_vars.replyContents;
03047    
03048    // store RC
03049    reply->RC = rc;
03050    
03051    // parse returned value (iff RC==0)
03052    if (rc==DN_SERIAL_RC_OK) {
03053       
03054    }
03055    
03056    // call the callback
03057    dn_ipmt_vars.replyCb(cmdId);
03058    
03059    // I'm not busy transmitting anymore
03060    dn_ipmt_vars.busyTx=FALSE;
03061 }
03062 
03063 //===== reset
03064 
03065 /**
03066 The reset command initiates a soft-reset of the device. The device will 
03067 initiate the reset sequence shortly after sending out the response to this 
03068 command. Resetting a mote directly can adversely impact its descendants; to 
03069 disconnect gracefully from the network, use the disconnect command 
03070 */
03071 dn_err_t dn_ipmt_reset(dn_ipmt_reset_rpt* reply) {
03072    uint8_t    extraFlags;
03073    dn_err_t   rc;
03074    
03075    // lock the module
03076    dn_lock();
03077    
03078    // verify no ongoing transmissions
03079    if (dn_ipmt_vars.busyTx) {
03080       // unlock the module
03081       dn_unlock();
03082       
03083       // return
03084       return DN_ERR_BUSY;
03085    }
03086    
03087    // store callback information
03088    dn_ipmt_vars.cmdId          = CMDID_RESET;
03089    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03090    
03091    // extraFlags
03092    extraFlags = 0x00;
03093    
03094    // build outputBuf
03095    
03096    // send outputBuf
03097    rc = dn_serial_mt_sendRequest(
03098       CMDID_RESET,                                              // cmdId
03099       extraFlags,                                               // extraFlags
03100       dn_ipmt_vars.outputBuf,                                   // payload
03101       DN_RESET_REQ_LEN,                                         // length
03102       dn_ipmt_reset_reply                                       // replyCb
03103    );
03104    
03105    if (rc==DN_ERR_NONE) {
03106       // I'm now busy transmitting
03107       dn_ipmt_vars.busyTx         = TRUE;
03108    }
03109    
03110    // unlock the module
03111    dn_unlock();
03112    
03113    return rc;
03114    
03115 }
03116 
03117 void dn_ipmt_reset_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03118    dn_ipmt_reset_rpt* reply;
03119    
03120    // verify I'm expecting this answer
03121    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03122       return;
03123    }
03124    
03125    // do NOT verify length (no return fields expected)
03126    
03127    // cast the replyContent
03128    reply = (dn_ipmt_reset_rpt*)dn_ipmt_vars.replyContents;
03129    
03130    // store RC
03131    reply->RC = rc;
03132    
03133    // parse returned value (iff RC==0)
03134    if (rc==DN_SERIAL_RC_OK) {
03135       
03136    }
03137    
03138    // call the callback
03139    dn_ipmt_vars.replyCb(cmdId);
03140    
03141    // I'm not busy transmitting anymore
03142    dn_ipmt_vars.busyTx=FALSE;
03143 }
03144 
03145 //===== lowPowerSleep
03146 
03147 /**
03148 The lowPowerSleep command shuts down all peripherals and places the mote into 
03149 deep sleep mode. The command executes after the mote sends its response. The 
03150 mote enters deep sleep within two seconds after the command executes. The 
03151 command may be issued at any time and will cause the mote to interrupt all 
03152 in-progress network operation. To achieve a graceful disconnect, use the 
03153 disconnect command before using the lowPowerSleep command. A hardware reset is 
03154 required to bring a mote out of deep sleep mode. 
03155 */
03156 dn_err_t dn_ipmt_lowPowerSleep(dn_ipmt_lowPowerSleep_rpt* reply) {
03157    uint8_t    extraFlags;
03158    dn_err_t   rc;
03159    
03160    // lock the module
03161    dn_lock();
03162    
03163    // verify no ongoing transmissions
03164    if (dn_ipmt_vars.busyTx) {
03165       // unlock the module
03166       dn_unlock();
03167       
03168       // return
03169       return DN_ERR_BUSY;
03170    }
03171    
03172    // store callback information
03173    dn_ipmt_vars.cmdId          = CMDID_LOWPOWERSLEEP;
03174    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03175    
03176    // extraFlags
03177    extraFlags = 0x00;
03178    
03179    // build outputBuf
03180    
03181    // send outputBuf
03182    rc = dn_serial_mt_sendRequest(
03183       CMDID_LOWPOWERSLEEP,                                      // cmdId
03184       extraFlags,                                               // extraFlags
03185       dn_ipmt_vars.outputBuf,                                   // payload
03186       DN_LOWPOWERSLEEP_REQ_LEN,                                 // length
03187       dn_ipmt_lowPowerSleep_reply                               // replyCb
03188    );
03189    
03190    if (rc==DN_ERR_NONE) {
03191       // I'm now busy transmitting
03192       dn_ipmt_vars.busyTx         = TRUE;
03193    }
03194    
03195    // unlock the module
03196    dn_unlock();
03197    
03198    return rc;
03199    
03200 }
03201 
03202 void dn_ipmt_lowPowerSleep_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03203    dn_ipmt_lowPowerSleep_rpt* reply;
03204    
03205    // verify I'm expecting this answer
03206    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03207       return;
03208    }
03209    
03210    // do NOT verify length (no return fields expected)
03211    
03212    // cast the replyContent
03213    reply = (dn_ipmt_lowPowerSleep_rpt*)dn_ipmt_vars.replyContents;
03214    
03215    // store RC
03216    reply->RC = rc;
03217    
03218    // parse returned value (iff RC==0)
03219    if (rc==DN_SERIAL_RC_OK) {
03220       
03221    }
03222    
03223    // call the callback
03224    dn_ipmt_vars.replyCb(cmdId);
03225    
03226    // I'm not busy transmitting anymore
03227    dn_ipmt_vars.busyTx=FALSE;
03228 }
03229 
03230 //===== testRadioRx
03231 
03232 /**
03233 The testRadioRx command clears all previously collected statistics and 
03234 initiates a test of radio reception for the specified channel and duration. 
03235 During the test, the mote keeps statistics about the number of packets received 
03236 (with and without error). The test results may be retrieved using the 
03237 getParameter<testRadioRxStats> command. The testRadioRx command may only be 
03238 issued in Idle mode. The mote must be reset (either hardware or software reset) 
03239 after radio tests are complete and prior to joining.
03240 
03241 Station ID is available in IP mote >= 1.4, and WirelessHART mote >= 1.1.2. The 
03242 station ID is a user selectable value used to isolate traffic if multiple tests 
03243 are running in the same radio space. It must be set to match the station ID 
03244 used by the transmitter.
03245 
03246 
03247 
03248 Channel numbering is 0-15, corresponding to IEEE 2.4 GHz channels 11-26. 
03249 */
03250 dn_err_t dn_ipmt_testRadioRx(uint16_t channelMask, uint16_t time, uint8_t stationId, dn_ipmt_testRadioRx_rpt* reply) {
03251    uint8_t    extraFlags;
03252    dn_err_t   rc;
03253    
03254    // lock the module
03255    dn_lock();
03256    
03257    // verify no ongoing transmissions
03258    if (dn_ipmt_vars.busyTx) {
03259       // unlock the module
03260       dn_unlock();
03261       
03262       // return
03263       return DN_ERR_BUSY;
03264    }
03265    
03266    // store callback information
03267    dn_ipmt_vars.cmdId          = CMDID_TESTRADIORX;
03268    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03269    
03270    // extraFlags
03271    extraFlags = 0x00;
03272    
03273    // build outputBuf
03274    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIORX_REQ_OFFS_CHANNELMASK],channelMask);
03275    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIORX_REQ_OFFS_TIME],time);
03276    dn_ipmt_vars.outputBuf[DN_TESTRADIORX_REQ_OFFS_STATIONID] = stationId;
03277    
03278    // send outputBuf
03279    rc = dn_serial_mt_sendRequest(
03280       CMDID_TESTRADIORX,                                        // cmdId
03281       extraFlags,                                               // extraFlags
03282       dn_ipmt_vars.outputBuf,                                   // payload
03283       DN_TESTRADIORX_REQ_LEN,                                   // length
03284       dn_ipmt_testRadioRx_reply                                 // replyCb
03285    );
03286    
03287    if (rc==DN_ERR_NONE) {
03288       // I'm now busy transmitting
03289       dn_ipmt_vars.busyTx         = TRUE;
03290    }
03291    
03292    // unlock the module
03293    dn_unlock();
03294    
03295    return rc;
03296    
03297 }
03298 
03299 void dn_ipmt_testRadioRx_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03300    dn_ipmt_testRadioRx_rpt* reply;
03301    
03302    // verify I'm expecting this answer
03303    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03304       return;
03305    }
03306    
03307    // do NOT verify length (no return fields expected)
03308    
03309    // cast the replyContent
03310    reply = (dn_ipmt_testRadioRx_rpt*)dn_ipmt_vars.replyContents;
03311    
03312    // store RC
03313    reply->RC = rc;
03314    
03315    // parse returned value (iff RC==0)
03316    if (rc==DN_SERIAL_RC_OK) {
03317       
03318    }
03319    
03320    // call the callback
03321    dn_ipmt_vars.replyCb(cmdId);
03322    
03323    // I'm not busy transmitting anymore
03324    dn_ipmt_vars.busyTx=FALSE;
03325 }
03326 
03327 //===== clearNV
03328 
03329 /**
03330 The clearNV command resets the motes non-volatile memory (NV) to its 
03331 factory-default state. See User Guide for detailed information about the 
03332 default values. Since many parameters are read by the mote only at power-up, 
03333 this command should be followed up by mote reset. 
03334 */
03335 dn_err_t dn_ipmt_clearNV(dn_ipmt_clearNV_rpt* reply) {
03336    uint8_t    extraFlags;
03337    dn_err_t   rc;
03338    
03339    // lock the module
03340    dn_lock();
03341    
03342    // verify no ongoing transmissions
03343    if (dn_ipmt_vars.busyTx) {
03344       // unlock the module
03345       dn_unlock();
03346       
03347       // return
03348       return DN_ERR_BUSY;
03349    }
03350    
03351    // store callback information
03352    dn_ipmt_vars.cmdId          = CMDID_CLEARNV;
03353    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03354    
03355    // extraFlags
03356    extraFlags = 0x00;
03357    
03358    // build outputBuf
03359    
03360    // send outputBuf
03361    rc = dn_serial_mt_sendRequest(
03362       CMDID_CLEARNV,                                            // cmdId
03363       extraFlags,                                               // extraFlags
03364       dn_ipmt_vars.outputBuf,                                   // payload
03365       DN_CLEARNV_REQ_LEN,                                       // length
03366       dn_ipmt_clearNV_reply                                     // replyCb
03367    );
03368    
03369    if (rc==DN_ERR_NONE) {
03370       // I'm now busy transmitting
03371       dn_ipmt_vars.busyTx         = TRUE;
03372    }
03373    
03374    // unlock the module
03375    dn_unlock();
03376    
03377    return rc;
03378    
03379 }
03380 
03381 void dn_ipmt_clearNV_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03382    dn_ipmt_clearNV_rpt* reply;
03383    
03384    // verify I'm expecting this answer
03385    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03386       return;
03387    }
03388    
03389    // do NOT verify length (no return fields expected)
03390    
03391    // cast the replyContent
03392    reply = (dn_ipmt_clearNV_rpt*)dn_ipmt_vars.replyContents;
03393    
03394    // store RC
03395    reply->RC = rc;
03396    
03397    // parse returned value (iff RC==0)
03398    if (rc==DN_SERIAL_RC_OK) {
03399       
03400    }
03401    
03402    // call the callback
03403    dn_ipmt_vars.replyCb(cmdId);
03404    
03405    // I'm not busy transmitting anymore
03406    dn_ipmt_vars.busyTx=FALSE;
03407 }
03408 
03409 //===== requestService
03410 
03411 /**
03412 The requestService command may be used to request a new or changed service 
03413 level to a destination device in the mesh. This command may only be used to 
03414 update the service to a device with an existing connection (session).
03415 
03416 Whenever a change in bandwidth assignment occurs, the application receives a 
03417 serviceChanged event that it can use as a trigger to read the new service 
03418 allocation. 
03419 */
03420 dn_err_t dn_ipmt_requestService(uint16_t destAddr, uint8_t serviceType, uint32_t value, dn_ipmt_requestService_rpt* reply) {
03421    uint8_t    extraFlags;
03422    dn_err_t   rc;
03423    
03424    // lock the module
03425    dn_lock();
03426    
03427    // verify no ongoing transmissions
03428    if (dn_ipmt_vars.busyTx) {
03429       // unlock the module
03430       dn_unlock();
03431       
03432       // return
03433       return DN_ERR_BUSY;
03434    }
03435    
03436    // store callback information
03437    dn_ipmt_vars.cmdId          = CMDID_REQUESTSERVICE;
03438    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03439    
03440    // extraFlags
03441    extraFlags = 0x00;
03442    
03443    // build outputBuf
03444    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_REQUESTSERVICE_REQ_OFFS_DESTADDR],destAddr);
03445    dn_ipmt_vars.outputBuf[DN_REQUESTSERVICE_REQ_OFFS_SERVICETYPE] = serviceType;
03446    dn_write_uint32_t(&dn_ipmt_vars.outputBuf[DN_REQUESTSERVICE_REQ_OFFS_VALUE],value);
03447    
03448    // send outputBuf
03449    rc = dn_serial_mt_sendRequest(
03450       CMDID_REQUESTSERVICE,                                     // cmdId
03451       extraFlags,                                               // extraFlags
03452       dn_ipmt_vars.outputBuf,                                   // payload
03453       DN_REQUESTSERVICE_REQ_LEN,                                // length
03454       dn_ipmt_requestService_reply                              // replyCb
03455    );
03456    
03457    if (rc==DN_ERR_NONE) {
03458       // I'm now busy transmitting
03459       dn_ipmt_vars.busyTx         = TRUE;
03460    }
03461    
03462    // unlock the module
03463    dn_unlock();
03464    
03465    return rc;
03466    
03467 }
03468 
03469 void dn_ipmt_requestService_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03470    dn_ipmt_requestService_rpt* reply;
03471    
03472    // verify I'm expecting this answer
03473    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03474       return;
03475    }
03476    
03477    // do NOT verify length (no return fields expected)
03478    
03479    // cast the replyContent
03480    reply = (dn_ipmt_requestService_rpt*)dn_ipmt_vars.replyContents;
03481    
03482    // store RC
03483    reply->RC = rc;
03484    
03485    // parse returned value (iff RC==0)
03486    if (rc==DN_SERIAL_RC_OK) {
03487       
03488    }
03489    
03490    // call the callback
03491    dn_ipmt_vars.replyCb(cmdId);
03492    
03493    // I'm not busy transmitting anymore
03494    dn_ipmt_vars.busyTx=FALSE;
03495 }
03496 
03497 //===== getServiceInfo
03498 
03499 /**
03500 The getServiceInfo command returns information about the service currently 
03501 allocated to the mote. 
03502 */
03503 dn_err_t dn_ipmt_getServiceInfo(uint16_t destAddr, uint8_t type, dn_ipmt_getServiceInfo_rpt* reply) {
03504    uint8_t    extraFlags;
03505    dn_err_t   rc;
03506    
03507    // lock the module
03508    dn_lock();
03509    
03510    // verify no ongoing transmissions
03511    if (dn_ipmt_vars.busyTx) {
03512       // unlock the module
03513       dn_unlock();
03514       
03515       // return
03516       return DN_ERR_BUSY;
03517    }
03518    
03519    // store callback information
03520    dn_ipmt_vars.cmdId          = CMDID_GETSERVICEINFO;
03521    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03522    
03523    // extraFlags
03524    extraFlags = 0x00;
03525    
03526    // build outputBuf
03527    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_GETSERVICEINFO_REQ_OFFS_DESTADDR],destAddr);
03528    dn_ipmt_vars.outputBuf[DN_GETSERVICEINFO_REQ_OFFS_TYPE] = type;
03529    
03530    // send outputBuf
03531    rc = dn_serial_mt_sendRequest(
03532       CMDID_GETSERVICEINFO,                                     // cmdId
03533       extraFlags,                                               // extraFlags
03534       dn_ipmt_vars.outputBuf,                                   // payload
03535       DN_GETSERVICEINFO_REQ_LEN,                                // length
03536       dn_ipmt_getServiceInfo_reply                              // replyCb
03537    );
03538    
03539    if (rc==DN_ERR_NONE) {
03540       // I'm now busy transmitting
03541       dn_ipmt_vars.busyTx         = TRUE;
03542    }
03543    
03544    // unlock the module
03545    dn_unlock();
03546    
03547    return rc;
03548    
03549 }
03550 
03551 void dn_ipmt_getServiceInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03552    dn_ipmt_getServiceInfo_rpt* reply;
03553    
03554    // verify I'm expecting this answer
03555    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03556       return;
03557    }
03558    
03559    // verify length
03560    if (rc==DN_SERIAL_RC_OK && len<DN_GETSERVICEINFO_REPLY_LEN) {
03561       return;
03562    }
03563    
03564    // cast the replyContent
03565    reply = (dn_ipmt_getServiceInfo_rpt*)dn_ipmt_vars.replyContents;
03566    
03567    // store RC
03568    reply->RC = rc;
03569    
03570    // parse returned value (iff RC==0)
03571    if (rc==DN_SERIAL_RC_OK) {
03572       
03573       dn_read_uint16_t(&reply->destAddr,&payload[DN_GETSERVICEINFO_REPLY_OFFS_DESTADDR]);
03574       reply->type = payload[DN_GETSERVICEINFO_REPLY_OFFS_TYPE];
03575       reply->state = payload[DN_GETSERVICEINFO_REPLY_OFFS_STATE];
03576       dn_read_uint32_t(&reply->value,&payload[DN_GETSERVICEINFO_REPLY_OFFS_VALUE]);
03577    }
03578    
03579    // call the callback
03580    dn_ipmt_vars.replyCb(cmdId);
03581    
03582    // I'm not busy transmitting anymore
03583    dn_ipmt_vars.busyTx=FALSE;
03584 }
03585 
03586 //===== openSocket
03587 
03588 /**
03589 The openSocket command creates an endpoint for IP communication and returns an 
03590 ID for the socket. 
03591 */
03592 dn_err_t dn_ipmt_openSocket(uint8_t protocol, dn_ipmt_openSocket_rpt* reply) {
03593    uint8_t    extraFlags;
03594    dn_err_t   rc;
03595    
03596    // lock the module
03597    dn_lock();
03598    
03599    // verify no ongoing transmissions
03600    if (dn_ipmt_vars.busyTx) {
03601       // unlock the module
03602       dn_unlock();
03603       
03604       // return
03605       return DN_ERR_BUSY;
03606    }
03607    
03608    // store callback information
03609    dn_ipmt_vars.cmdId          = CMDID_OPENSOCKET;
03610    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03611    
03612    // extraFlags
03613    extraFlags = 0x00;
03614    
03615    // build outputBuf
03616    dn_ipmt_vars.outputBuf[DN_OPENSOCKET_REQ_OFFS_PROTOCOL] = protocol;
03617    
03618    // send outputBuf
03619    rc = dn_serial_mt_sendRequest(
03620       CMDID_OPENSOCKET,                                         // cmdId
03621       extraFlags,                                               // extraFlags
03622       dn_ipmt_vars.outputBuf,                                   // payload
03623       DN_OPENSOCKET_REQ_LEN,                                    // length
03624       dn_ipmt_openSocket_reply                                  // replyCb
03625    );
03626    
03627    if (rc==DN_ERR_NONE) {
03628       // I'm now busy transmitting
03629       dn_ipmt_vars.busyTx         = TRUE;
03630    }
03631    
03632    // unlock the module
03633    dn_unlock();
03634    
03635    return rc;
03636    
03637 }
03638 
03639 void dn_ipmt_openSocket_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03640    dn_ipmt_openSocket_rpt* reply;
03641    
03642    // verify I'm expecting this answer
03643    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03644       return;
03645    }
03646    
03647    // verify length
03648    if (rc==DN_SERIAL_RC_OK && len<DN_OPENSOCKET_REPLY_LEN) {
03649       return;
03650    }
03651    
03652    // cast the replyContent
03653    reply = (dn_ipmt_openSocket_rpt*)dn_ipmt_vars.replyContents;
03654    
03655    // store RC
03656    reply->RC = rc;
03657    
03658    // parse returned value (iff RC==0)
03659    if (rc==DN_SERIAL_RC_OK) {
03660       
03661       reply->socketId = payload[DN_OPENSOCKET_REPLY_OFFS_SOCKETID];
03662    }
03663    
03664    // call the callback
03665    dn_ipmt_vars.replyCb(cmdId);
03666    
03667    // I'm not busy transmitting anymore
03668    dn_ipmt_vars.busyTx=FALSE;
03669 }
03670 
03671 //===== closeSocket
03672 
03673 /**
03674 Close the previously open socket. 
03675 */
03676 dn_err_t dn_ipmt_closeSocket(uint8_t socketId, dn_ipmt_closeSocket_rpt* reply) {
03677    uint8_t    extraFlags;
03678    dn_err_t   rc;
03679    
03680    // lock the module
03681    dn_lock();
03682    
03683    // verify no ongoing transmissions
03684    if (dn_ipmt_vars.busyTx) {
03685       // unlock the module
03686       dn_unlock();
03687       
03688       // return
03689       return DN_ERR_BUSY;
03690    }
03691    
03692    // store callback information
03693    dn_ipmt_vars.cmdId          = CMDID_CLOSESOCKET;
03694    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03695    
03696    // extraFlags
03697    extraFlags = 0x00;
03698    
03699    // build outputBuf
03700    dn_ipmt_vars.outputBuf[DN_CLOSESOCKET_REQ_OFFS_SOCKETID] = socketId;
03701    
03702    // send outputBuf
03703    rc = dn_serial_mt_sendRequest(
03704       CMDID_CLOSESOCKET,                                        // cmdId
03705       extraFlags,                                               // extraFlags
03706       dn_ipmt_vars.outputBuf,                                   // payload
03707       DN_CLOSESOCKET_REQ_LEN,                                   // length
03708       dn_ipmt_closeSocket_reply                                 // replyCb
03709    );
03710    
03711    if (rc==DN_ERR_NONE) {
03712       // I'm now busy transmitting
03713       dn_ipmt_vars.busyTx         = TRUE;
03714    }
03715    
03716    // unlock the module
03717    dn_unlock();
03718    
03719    return rc;
03720    
03721 }
03722 
03723 void dn_ipmt_closeSocket_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03724    dn_ipmt_closeSocket_rpt* reply;
03725    
03726    // verify I'm expecting this answer
03727    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03728       return;
03729    }
03730    
03731    // do NOT verify length (no return fields expected)
03732    
03733    // cast the replyContent
03734    reply = (dn_ipmt_closeSocket_rpt*)dn_ipmt_vars.replyContents;
03735    
03736    // store RC
03737    reply->RC = rc;
03738    
03739    // parse returned value (iff RC==0)
03740    if (rc==DN_SERIAL_RC_OK) {
03741       
03742    }
03743    
03744    // call the callback
03745    dn_ipmt_vars.replyCb(cmdId);
03746    
03747    // I'm not busy transmitting anymore
03748    dn_ipmt_vars.busyTx=FALSE;
03749 }
03750 
03751 //===== bindSocket
03752 
03753 /**
03754 Bind a previously opened socket to a port. When a socket is created, it is only 
03755 given a protocol family, but not assigned a port. This association must be 
03756 performed before the socket can accept connections from other hosts. 
03757 */
03758 dn_err_t dn_ipmt_bindSocket(uint8_t socketId, uint16_t port, dn_ipmt_bindSocket_rpt* reply) {
03759    uint8_t    extraFlags;
03760    dn_err_t   rc;
03761    
03762    // lock the module
03763    dn_lock();
03764    
03765    // verify no ongoing transmissions
03766    if (dn_ipmt_vars.busyTx) {
03767       // unlock the module
03768       dn_unlock();
03769       
03770       // return
03771       return DN_ERR_BUSY;
03772    }
03773    
03774    // store callback information
03775    dn_ipmt_vars.cmdId          = CMDID_BINDSOCKET;
03776    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03777    
03778    // extraFlags
03779    extraFlags = 0x00;
03780    
03781    // build outputBuf
03782    dn_ipmt_vars.outputBuf[DN_BINDSOCKET_REQ_OFFS_SOCKETID] = socketId;
03783    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_BINDSOCKET_REQ_OFFS_PORT],port);
03784    
03785    // send outputBuf
03786    rc = dn_serial_mt_sendRequest(
03787       CMDID_BINDSOCKET,                                         // cmdId
03788       extraFlags,                                               // extraFlags
03789       dn_ipmt_vars.outputBuf,                                   // payload
03790       DN_BINDSOCKET_REQ_LEN,                                    // length
03791       dn_ipmt_bindSocket_reply                                  // replyCb
03792    );
03793    
03794    if (rc==DN_ERR_NONE) {
03795       // I'm now busy transmitting
03796       dn_ipmt_vars.busyTx         = TRUE;
03797    }
03798    
03799    // unlock the module
03800    dn_unlock();
03801    
03802    return rc;
03803    
03804 }
03805 
03806 void dn_ipmt_bindSocket_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03807    dn_ipmt_bindSocket_rpt* reply;
03808    
03809    // verify I'm expecting this answer
03810    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03811       return;
03812    }
03813    
03814    // do NOT verify length (no return fields expected)
03815    
03816    // cast the replyContent
03817    reply = (dn_ipmt_bindSocket_rpt*)dn_ipmt_vars.replyContents;
03818    
03819    // store RC
03820    reply->RC = rc;
03821    
03822    // parse returned value (iff RC==0)
03823    if (rc==DN_SERIAL_RC_OK) {
03824       
03825    }
03826    
03827    // call the callback
03828    dn_ipmt_vars.replyCb(cmdId);
03829    
03830    // I'm not busy transmitting anymore
03831    dn_ipmt_vars.busyTx=FALSE;
03832 }
03833 
03834 //===== sendTo
03835 
03836 /**
03837 Send a packet into the network. If the command returns RC_OK, the mote has 
03838 accepted the packet and hasqueuedit up for transmission. A txDone notification 
03839 will be issued when the packet has been sent, if and only if the packet ID 
03840 passed in this command is different from 0xffff. You can set the packet ID to 
03841 any value. The notification will contain the packet ID of the packet just sent, 
03842 allowing association of the notification with a particular packet. The 
03843 destination port should be in the range 0xF0B8-F0BF (61624-61631) to maximize 
03844 payload. 
03845 */
03846 dn_err_t dn_ipmt_sendTo(uint8_t socketId, uint8_t* destIP, uint16_t destPort, uint8_t serviceType, uint8_t priority, uint16_t packetId, uint8_t* payload, uint8_t payloadLen, dn_ipmt_sendTo_rpt* reply) {
03847    uint8_t    extraFlags;
03848    dn_err_t   rc;
03849    
03850    // lock the module
03851    dn_lock();
03852    
03853    // verify no ongoing transmissions
03854    if (dn_ipmt_vars.busyTx) {
03855       // unlock the module
03856       dn_unlock();
03857       
03858       // return
03859       return DN_ERR_BUSY;
03860    }
03861    
03862    // store callback information
03863    dn_ipmt_vars.cmdId          = CMDID_SENDTO;
03864    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03865    
03866    // extraFlags
03867    extraFlags = 0x00;
03868    
03869    // build outputBuf
03870    dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_SOCKETID] = socketId;
03871    memcpy(&dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_DESTIP],destIP,16);
03872    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_DESTPORT],destPort);
03873    dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_SERVICETYPE] = serviceType;
03874    dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_PRIORITY] = priority;
03875    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_PACKETID],packetId);
03876    memcpy(&dn_ipmt_vars.outputBuf[DN_SENDTO_REQ_OFFS_PAYLOAD],payload,payloadLen);
03877    
03878    // send outputBuf
03879    rc = dn_serial_mt_sendRequest(
03880       CMDID_SENDTO,                                             // cmdId
03881       extraFlags,                                               // extraFlags
03882       dn_ipmt_vars.outputBuf,                                   // payload
03883       DN_SENDTO_REQ_LEN+payloadLen,                             // length
03884       dn_ipmt_sendTo_reply                                      // replyCb
03885    );
03886    
03887    if (rc==DN_ERR_NONE) {
03888       // I'm now busy transmitting
03889       dn_ipmt_vars.busyTx         = TRUE;
03890    }
03891    
03892    // unlock the module
03893    dn_unlock();
03894    
03895    return rc;
03896    
03897 }
03898 
03899 void dn_ipmt_sendTo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03900    dn_ipmt_sendTo_rpt* reply;
03901    
03902    // verify I'm expecting this answer
03903    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03904       return;
03905    }
03906    
03907    // do NOT verify length (no return fields expected)
03908    
03909    // cast the replyContent
03910    reply = (dn_ipmt_sendTo_rpt*)dn_ipmt_vars.replyContents;
03911    
03912    // store RC
03913    reply->RC = rc;
03914    
03915    // parse returned value (iff RC==0)
03916    if (rc==DN_SERIAL_RC_OK) {
03917       
03918    }
03919    
03920    // call the callback
03921    dn_ipmt_vars.replyCb(cmdId);
03922    
03923    // I'm not busy transmitting anymore
03924    dn_ipmt_vars.busyTx=FALSE;
03925 }
03926 
03927 //===== search
03928 
03929 /**
03930 The search command requests that mote start listening for advertisements and 
03931 report those heard from any network withoutattempting to join. This is called 
03932 the Promiscuous Listen state. The mote must be in the Idle state for this 
03933 command to be valid. The search state can be exited by issuing the join command 
03934 or the reset command. 
03935 */
03936 dn_err_t dn_ipmt_search(dn_ipmt_search_rpt* reply) {
03937    uint8_t    extraFlags;
03938    dn_err_t   rc;
03939    
03940    // lock the module
03941    dn_lock();
03942    
03943    // verify no ongoing transmissions
03944    if (dn_ipmt_vars.busyTx) {
03945       // unlock the module
03946       dn_unlock();
03947       
03948       // return
03949       return DN_ERR_BUSY;
03950    }
03951    
03952    // store callback information
03953    dn_ipmt_vars.cmdId          = CMDID_SEARCH;
03954    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
03955    
03956    // extraFlags
03957    extraFlags = 0x00;
03958    
03959    // build outputBuf
03960    
03961    // send outputBuf
03962    rc = dn_serial_mt_sendRequest(
03963       CMDID_SEARCH,                                             // cmdId
03964       extraFlags,                                               // extraFlags
03965       dn_ipmt_vars.outputBuf,                                   // payload
03966       DN_SEARCH_REQ_LEN,                                        // length
03967       dn_ipmt_search_reply                                      // replyCb
03968    );
03969    
03970    if (rc==DN_ERR_NONE) {
03971       // I'm now busy transmitting
03972       dn_ipmt_vars.busyTx         = TRUE;
03973    }
03974    
03975    // unlock the module
03976    dn_unlock();
03977    
03978    return rc;
03979    
03980 }
03981 
03982 void dn_ipmt_search_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
03983    dn_ipmt_search_rpt* reply;
03984    
03985    // verify I'm expecting this answer
03986    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
03987       return;
03988    }
03989    
03990    // do NOT verify length (no return fields expected)
03991    
03992    // cast the replyContent
03993    reply = (dn_ipmt_search_rpt*)dn_ipmt_vars.replyContents;
03994    
03995    // store RC
03996    reply->RC = rc;
03997    
03998    // parse returned value (iff RC==0)
03999    if (rc==DN_SERIAL_RC_OK) {
04000       
04001    }
04002    
04003    // call the callback
04004    dn_ipmt_vars.replyCb(cmdId);
04005    
04006    // I'm not busy transmitting anymore
04007    dn_ipmt_vars.busyTx=FALSE;
04008 }
04009 
04010 //===== testRadioTxExt
04011 
04012 /**
04013 The testRadioTxExt command allows the microprocessor to initiate a radio 
04014 transmission test. This command may only be issued prior to the mote joining 
04015 the network. Three types of transmission tests are supported:
04016 
04017 - Packet transmission
04018 - Continuous modulation
04019 - Continuous wave (unmodulated signal)
04020 
04021 In a packet transmission test, the mote generates a repeatCnt number of packet 
04022 sequences. Each sequence consists of up to 10 packets with configurable size 
04023 and delays. Each packet starts with a PHY preamble (5 bytes), followed by a PHY 
04024 length field (1 byte), followed by data payload of up to 125 bytes, and finally 
04025 a 2-byte 802.15.4 CRC at the end. Byte 0 of the payload contains stationId of 
04026 the sender. Bytes 1 and 2 contain the packet number (in big-endian format) that 
04027 increments with every packet transmitted. Bytes 3..N contain a counter (from 
04028 0..N-3) that increments with every byte inside payload. Transmissions occur on 
04029 the set of channels defined by chanMask , selected inpseudo-randomorder.
04030 
04031 In a continuous modulation test, the mote generates continuous pseudo-random 
04032 modulated signal, centered at the specified channel. The test is stopped by 
04033 resetting the mote.
04034 
04035 In a continuous wave test, the mote generates an unmodulated tone, centered at 
04036 the specified channel. The test tone is stopped by resetting the mote.
04037 
04038 The testRadioTxExt command may only be issued when the mote is in Idle mode, 
04039 prior to its joining the network. The mote must be reset (either hardware or 
04040 software reset) after radio tests are complete and prior to joining.
04041 
04042 The station ID is a user selectable value. It is used in packet tests so that a 
04043 receiver can identify packets from this device in cases where there may be 
04044 multiple tests running in the same radio space. This field is not used for CM 
04045 or CW tests. See testRadioRX (SmartMesh IP) or testRadioRxExt (SmartMesh WirelessHART).
04046 
04047 
04048 
04049 Channel numbering is 0-15, corresponding to IEEE 2.4 GHz channels 11-26. 
04050 */
04051 dn_err_t dn_ipmt_testRadioTxExt(uint8_t testType, uint16_t chanMask, uint16_t repeatCnt, int8_t txPower, uint8_t seqSize, uint8_t pkLen_1, uint16_t delay_1, uint8_t pkLen_2, uint16_t delay_2, uint8_t pkLen_3, uint16_t delay_3, uint8_t pkLen_4, uint16_t delay_4, uint8_t pkLen_5, uint16_t delay_5, uint8_t pkLen_6, uint16_t delay_6, uint8_t pkLen_7, uint16_t delay_7, uint8_t pkLen_8, uint16_t delay_8, uint8_t pkLen_9, uint16_t delay_9, uint8_t pkLen_10, uint16_t delay_10, uint8_t stationId, dn_ipmt_testRadioTxExt_rpt* reply) {
04052    uint8_t    extraFlags;
04053    dn_err_t   rc;
04054    
04055    // lock the module
04056    dn_lock();
04057    
04058    // verify no ongoing transmissions
04059    if (dn_ipmt_vars.busyTx) {
04060       // unlock the module
04061       dn_unlock();
04062       
04063       // return
04064       return DN_ERR_BUSY;
04065    }
04066    
04067    // store callback information
04068    dn_ipmt_vars.cmdId          = CMDID_TESTRADIOTXEXT;
04069    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
04070    
04071    // extraFlags
04072    extraFlags = 0x00;
04073    
04074    // build outputBuf
04075    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_TESTTYPE] = testType;
04076    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_CHANMASK],chanMask);
04077    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_REPEATCNT],repeatCnt);
04078    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_TXPOWER] = (int8_t)txPower;
04079    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_SEQSIZE] = seqSize;
04080    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_1] = pkLen_1;
04081    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_1],delay_1);
04082    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_2] = pkLen_2;
04083    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_2],delay_2);
04084    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_3] = pkLen_3;
04085    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_3],delay_3);
04086    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_4] = pkLen_4;
04087    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_4],delay_4);
04088    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_5] = pkLen_5;
04089    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_5],delay_5);
04090    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_6] = pkLen_6;
04091    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_6],delay_6);
04092    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_7] = pkLen_7;
04093    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_7],delay_7);
04094    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_8] = pkLen_8;
04095    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_8],delay_8);
04096    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_9] = pkLen_9;
04097    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_9],delay_9);
04098    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_PKLEN_10] = pkLen_10;
04099    dn_write_uint16_t(&dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_DELAY_10],delay_10);
04100    dn_ipmt_vars.outputBuf[DN_TESTRADIOTXEXT_REQ_OFFS_STATIONID] = stationId;
04101    
04102    // send outputBuf
04103    rc = dn_serial_mt_sendRequest(
04104       CMDID_TESTRADIOTXEXT,                                     // cmdId
04105       extraFlags,                                               // extraFlags
04106       dn_ipmt_vars.outputBuf,                                   // payload
04107       DN_TESTRADIOTXEXT_REQ_LEN,                                // length
04108       dn_ipmt_testRadioTxExt_reply                              // replyCb
04109    );
04110    
04111    if (rc==DN_ERR_NONE) {
04112       // I'm now busy transmitting
04113       dn_ipmt_vars.busyTx         = TRUE;
04114    }
04115    
04116    // unlock the module
04117    dn_unlock();
04118    
04119    return rc;
04120    
04121 }
04122 
04123 void dn_ipmt_testRadioTxExt_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
04124    dn_ipmt_testRadioTxExt_rpt* reply;
04125    
04126    // verify I'm expecting this answer
04127    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
04128       return;
04129    }
04130    
04131    // do NOT verify length (no return fields expected)
04132    
04133    // cast the replyContent
04134    reply = (dn_ipmt_testRadioTxExt_rpt*)dn_ipmt_vars.replyContents;
04135    
04136    // store RC
04137    reply->RC = rc;
04138    
04139    // parse returned value (iff RC==0)
04140    if (rc==DN_SERIAL_RC_OK) {
04141       
04142    }
04143    
04144    // call the callback
04145    dn_ipmt_vars.replyCb(cmdId);
04146    
04147    // I'm not busy transmitting anymore
04148    dn_ipmt_vars.busyTx=FALSE;
04149 }
04150 
04151 //===== zeroize
04152 
04153 /**
04154 Zeroize (zeroise) command erases flash area that is used to store configuration 
04155 parameters, such as join keys. This command is intended to satisfy zeroization 
04156 requirement of FIPS-140 standard. After the command executes, the mote should 
04157 be reset. Available in mote >= 1.4.x
04158 
04159 The zeroize command will render the mote inoperable. It must be re-programmed 
04160 via SPI or JTAG in order to be useable. 
04161 */
04162 dn_err_t dn_ipmt_zeroize(dn_ipmt_zeroize_rpt* reply) {
04163    uint8_t    extraFlags;
04164    dn_err_t   rc;
04165    
04166    // lock the module
04167    dn_lock();
04168    
04169    // verify no ongoing transmissions
04170    if (dn_ipmt_vars.busyTx) {
04171       // unlock the module
04172       dn_unlock();
04173       
04174       // return
04175       return DN_ERR_BUSY;
04176    }
04177    
04178    // store callback information
04179    dn_ipmt_vars.cmdId          = CMDID_ZEROIZE;
04180    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
04181    
04182    // extraFlags
04183    extraFlags = 0x00;
04184    
04185    // build outputBuf
04186    
04187    // send outputBuf
04188    rc = dn_serial_mt_sendRequest(
04189       CMDID_ZEROIZE,                                            // cmdId
04190       extraFlags,                                               // extraFlags
04191       dn_ipmt_vars.outputBuf,                                   // payload
04192       DN_ZEROIZE_REQ_LEN,                                       // length
04193       dn_ipmt_zeroize_reply                                     // replyCb
04194    );
04195    
04196    if (rc==DN_ERR_NONE) {
04197       // I'm now busy transmitting
04198       dn_ipmt_vars.busyTx         = TRUE;
04199    }
04200    
04201    // unlock the module
04202    dn_unlock();
04203    
04204    return rc;
04205    
04206 }
04207 
04208 void dn_ipmt_zeroize_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
04209    dn_ipmt_zeroize_rpt* reply;
04210    
04211    // verify I'm expecting this answer
04212    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
04213       return;
04214    }
04215    
04216    // do NOT verify length (no return fields expected)
04217    
04218    // cast the replyContent
04219    reply = (dn_ipmt_zeroize_rpt*)dn_ipmt_vars.replyContents;
04220    
04221    // store RC
04222    reply->RC = rc;
04223    
04224    // parse returned value (iff RC==0)
04225    if (rc==DN_SERIAL_RC_OK) {
04226       
04227    }
04228    
04229    // call the callback
04230    dn_ipmt_vars.replyCb(cmdId);
04231    
04232    // I'm not busy transmitting anymore
04233    dn_ipmt_vars.busyTx=FALSE;
04234 }
04235 
04236 //===== socketInfo
04237 
04238 /**
04239 Retrieve information about a socket. (Available in IP Mote >= 1.4.0) 
04240 */
04241 dn_err_t dn_ipmt_socketInfo(uint8_t index, dn_ipmt_socketInfo_rpt* reply) {
04242    uint8_t    extraFlags;
04243    dn_err_t   rc;
04244    
04245    // lock the module
04246    dn_lock();
04247    
04248    // verify no ongoing transmissions
04249    if (dn_ipmt_vars.busyTx) {
04250       // unlock the module
04251       dn_unlock();
04252       
04253       // return
04254       return DN_ERR_BUSY;
04255    }
04256    
04257    // store callback information
04258    dn_ipmt_vars.cmdId          = CMDID_SOCKETINFO;
04259    dn_ipmt_vars.replyContents  = (uint8_t*)reply;
04260    
04261    // extraFlags
04262    extraFlags = 0x00;
04263    
04264    // build outputBuf
04265    dn_ipmt_vars.outputBuf[DN_SOCKETINFO_REQ_OFFS_INDEX] = index;
04266    
04267    // send outputBuf
04268    rc = dn_serial_mt_sendRequest(
04269       CMDID_SOCKETINFO,                                         // cmdId
04270       extraFlags,                                               // extraFlags
04271       dn_ipmt_vars.outputBuf,                                   // payload
04272       DN_SOCKETINFO_REQ_LEN,                                    // length
04273       dn_ipmt_socketInfo_reply                                  // replyCb
04274    );
04275    
04276    if (rc==DN_ERR_NONE) {
04277       // I'm now busy transmitting
04278       dn_ipmt_vars.busyTx         = TRUE;
04279    }
04280    
04281    // unlock the module
04282    dn_unlock();
04283    
04284    return rc;
04285    
04286 }
04287 
04288 void dn_ipmt_socketInfo_reply(uint8_t cmdId, uint8_t rc, uint8_t* payload, uint8_t len) {
04289    dn_ipmt_socketInfo_rpt* reply;
04290    
04291    // verify I'm expecting this answer
04292    if (dn_ipmt_vars.busyTx==FALSE || dn_ipmt_vars.cmdId!=cmdId) {
04293       return;
04294    }
04295    
04296    // verify length
04297    if (rc==DN_SERIAL_RC_OK && len<DN_SOCKETINFO_REPLY_LEN) {
04298       return;
04299    }
04300    
04301    // cast the replyContent
04302    reply = (dn_ipmt_socketInfo_rpt*)dn_ipmt_vars.replyContents;
04303    
04304    // store RC
04305    reply->RC = rc;
04306    
04307    // parse returned value (iff RC==0)
04308    if (rc==DN_SERIAL_RC_OK) {
04309       
04310       reply->index = payload[DN_SOCKETINFO_REPLY_OFFS_INDEX];
04311       reply->socketId = payload[DN_SOCKETINFO_REPLY_OFFS_SOCKETID];
04312       reply->protocol = payload[DN_SOCKETINFO_REPLY_OFFS_PROTOCOL];
04313       reply->bindState = payload[DN_SOCKETINFO_REPLY_OFFS_BINDSTATE];
04314       dn_read_uint16_t(&reply->port,&payload[DN_SOCKETINFO_REPLY_OFFS_PORT]);
04315    }
04316    
04317    // call the callback
04318    dn_ipmt_vars.replyCb(cmdId);
04319    
04320    // I'm not busy transmitting anymore
04321    dn_ipmt_vars.busyTx=FALSE;
04322 }
04323 
04324 //========== serialRX
04325 
04326 void dn_ipmt_rxSerialRequest(uint8_t cmdId, uint8_t flags, uint8_t* payload, uint8_t len) {
04327    dn_ipmt_timeIndication_nt* notif_timeIndication;
04328    dn_ipmt_events_nt* notif_events;
04329    dn_ipmt_receive_nt* notif_receive;
04330    dn_ipmt_macRx_nt* notif_macRx;
04331    dn_ipmt_txDone_nt* notif_txDone;
04332    dn_ipmt_advReceived_nt* notif_advReceived;
04333    
04334    // parse notification
04335    switch(cmdId) {
04336       case CMDID_TIMEINDICATION:
04337          
04338          // verify length payload received
04339          if (len<23) {
04340             return;
04341          }
04342          
04343          // verify length notifBuf
04344          if (len>dn_ipmt_vars.notifBufLen) {
04345             return;
04346          }
04347          
04348          // cast notifBuf
04349          notif_timeIndication = (dn_ipmt_timeIndication_nt*)dn_ipmt_vars.notifBuf;
04350          
04351          // parse the notification
04352          dn_read_uint32_t(&notif_timeIndication->uptime,&payload[DN_TIMEINDICATION_NOTIF_OFFS_UPTIME]);
04353          memcpy(&notif_timeIndication->utcSecs[0],&payload[DN_TIMEINDICATION_NOTIF_OFFS_UTCSECS],8);
04354          dn_read_uint32_t(&notif_timeIndication->utcUsecs,&payload[DN_TIMEINDICATION_NOTIF_OFFS_UTCUSECS]);
04355          memcpy(&notif_timeIndication->asn[0],&payload[DN_TIMEINDICATION_NOTIF_OFFS_ASN],5);
04356          dn_read_uint16_t(&notif_timeIndication->asnOffset,&payload[DN_TIMEINDICATION_NOTIF_OFFS_ASNOFFSET]);
04357          break;
04358       case CMDID_EVENTS:
04359          
04360          // verify length payload received
04361          if (len<9) {
04362             return;
04363          }
04364          
04365          // verify length notifBuf
04366          if (len>dn_ipmt_vars.notifBufLen) {
04367             return;
04368          }
04369          
04370          // cast notifBuf
04371          notif_events = (dn_ipmt_events_nt*)dn_ipmt_vars.notifBuf;
04372          
04373          // parse the notification
04374          dn_read_uint32_t(&notif_events->events,&payload[DN_EVENTS_NOTIF_OFFS_EVENTS]);
04375          notif_events->state = payload[DN_EVENTS_NOTIF_OFFS_STATE];
04376          dn_read_uint32_t(&notif_events->alarmsList,&payload[DN_EVENTS_NOTIF_OFFS_ALARMSLIST]);
04377          break;
04378       case CMDID_RECEIVE:
04379          
04380          // verify length payload received
04381          if (len<19) {
04382             return;
04383          }
04384          
04385          // verify length notifBuf
04386          if (len>dn_ipmt_vars.notifBufLen) {
04387             return;
04388          }
04389          
04390          // cast notifBuf
04391          notif_receive = (dn_ipmt_receive_nt*)dn_ipmt_vars.notifBuf;
04392          
04393          // parse the notification
04394          notif_receive->socketId = payload[DN_RECEIVE_NOTIF_OFFS_SOCKETID];
04395          memcpy(&notif_receive->srcAddr[0],&payload[DN_RECEIVE_NOTIF_OFFS_SRCADDR],16);
04396          dn_read_uint16_t(&notif_receive->srcPort,&payload[DN_RECEIVE_NOTIF_OFFS_SRCPORT]);
04397          notif_receive->payloadLen = len-DN_RECEIVE_NOTIF_OFFS_PAYLOAD;
04398          memcpy(&notif_receive->payload[0],&payload[DN_RECEIVE_NOTIF_OFFS_PAYLOAD],len-DN_RECEIVE_NOTIF_OFFS_PAYLOAD);
04399          break;
04400       case CMDID_MACRX:
04401          
04402          // verify length notifBuf
04403          if (len>dn_ipmt_vars.notifBufLen) {
04404             return;
04405          }
04406          
04407          // cast notifBuf
04408          notif_macRx = (dn_ipmt_macRx_nt*)dn_ipmt_vars.notifBuf;
04409          
04410          // parse the notification
04411          memcpy(&notif_macRx->payload[0],&payload[DN_MACRX_NOTIF_OFFS_PAYLOAD],len-DN_MACRX_NOTIF_OFFS_PAYLOAD);
04412          break;
04413       case CMDID_TXDONE:
04414          
04415          // verify length payload received
04416          if (len<3) {
04417             return;
04418          }
04419          
04420          // verify length notifBuf
04421          if (len>dn_ipmt_vars.notifBufLen) {
04422             return;
04423          }
04424          
04425          // cast notifBuf
04426          notif_txDone = (dn_ipmt_txDone_nt*)dn_ipmt_vars.notifBuf;
04427          
04428          // parse the notification
04429          dn_read_uint16_t(&notif_txDone->packetId,&payload[DN_TXDONE_NOTIF_OFFS_PACKETID]);
04430          notif_txDone->status = payload[DN_TXDONE_NOTIF_OFFS_STATUS];
04431          break;
04432       case CMDID_ADVRECEIVED:
04433          
04434          // verify length payload received
04435          if (len<6) {
04436             return;
04437          }
04438          
04439          // verify length notifBuf
04440          if (len>dn_ipmt_vars.notifBufLen) {
04441             return;
04442          }
04443          
04444          // cast notifBuf
04445          notif_advReceived = (dn_ipmt_advReceived_nt*)dn_ipmt_vars.notifBuf;
04446          
04447          // parse the notification
04448          dn_read_uint16_t(&notif_advReceived->netId,&payload[DN_ADVRECEIVED_NOTIF_OFFS_NETID]);
04449          dn_read_uint16_t(&notif_advReceived->moteId,&payload[DN_ADVRECEIVED_NOTIF_OFFS_MOTEID]);
04450          notif_advReceived->rssi = (int8_t)payload[DN_ADVRECEIVED_NOTIF_OFFS_RSSI];
04451          notif_advReceived->joinPri = payload[DN_ADVRECEIVED_NOTIF_OFFS_JOINPRI];
04452          break;
04453       default:
04454          // unknown cmdID
04455          return;
04456    }
04457    
04458    // call the callback
04459    dn_ipmt_vars.notifCb(cmdId,DN_SUBCMDID_NONE);
04460 }
04461 
04462 //=========================== helpers =========================================
04463 
04464