void udprand_task(){
OpenQueueEntry_t* pkt;
// don't run if not synch
if (ieee154e_isSynch() == FALSE) return;
// don't run on dagroot
if (idmanager_getIsDAGroot()) {
opentimers_stop(udprand_vars.timerId);
return;
}
//prepare packet
pkt = openqueue_getFreePacketBuffer(COMPONENT_UDPRAND);
if (pkt==NULL) {
openserial_printError(COMPONENT_UDPRAND,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
return;
}
pkt->creator = COMPONENT_UDPRAND;
pkt->owner = COMPONENT_UDPRAND;
pkt->l4_protocol = IANA_UDP;
pkt->l4_sourcePortORicmpv6Type = WKP_UDP_RAND;
pkt->l4_destination_port = WKP_UDP_RAND;
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&pkt->l3_destinationAdd.addr_128b[0],&ipAddr_motedata,16);
packetfunctions_reserveHeaderSize(pkt,2);
((uint8_t*)pkt->payload)[0] = openrandom_get16b()%0xff;
((uint8_t*)pkt->payload)[1] = openrandom_get16b()%0xff;
//send packet
if ((openudp_send(pkt))==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
}
void macpong_initSend(void) {
if (idmanager_getIsDAGroot()==TRUE) {
return;
}
if (ieee154e_isSynch()==TRUE && neighbors_getNumNeighbors()==1) {
// send packet
//poipoimacpong_send(0);
// cancel timer
opentimers_stop(macpong_vars.timerId);
}
}
error_t rt_receive(OpenQueueEntry_t* msg,
coap_header_iht* coap_header,
coap_option_iht* coap_options) {
error_t outcome;
uint8_t rawdata[SENSITIVE_ACCEL_TEMPERATURE_DATALEN];
if (coap_header->Code==COAP_CODE_REQ_POST) {
// start/stop the data generation to data server
if (msg->payload[0]=='1') {
opentimers_restart(rt_vars.timerId);
} else {
opentimers_stop(rt_vars.timerId);
}
// reset packet payload
msg->payload = &(msg->packet[127]);
msg->length = 0;
// CoAP header
coap_header->OC = 0;
coap_header->Code = COAP_CODE_RESP_VALID;
outcome = E_SUCCESS;
} else if (coap_header->Code==COAP_CODE_REQ_GET) {
// return current sensor value
// reset packet payload
msg->payload = &(msg->packet[127]);
msg->length = 0;
// CoAP payload (2 bytes of temperature data)
packetfunctions_reserveHeaderSize(msg,2);
sensitive_accel_temperature_get_measurement(&rawdata[0]);
msg->payload[0] = rawdata[8];
msg->payload[1] = rawdata[9];
// set the CoAP header
coap_header->OC = 0;
coap_header->Code = COAP_CODE_RESP_CONTENT;
outcome = E_SUCCESS;
} else {
// return an error message
outcome = E_FAIL;
}
return outcome;
}
void uinject_task_cb() {
OpenQueueEntry_t* pkt;
// don't run if not synch
if (ieee154e_isSynch() == FALSE) return;
// don't run on dagroot
if (idmanager_getIsDAGroot()) {
opentimers_stop(uinject_vars.timerId);
return;
}
// if you get here, send a packet
// get a free packet buffer
pkt = openqueue_getFreePacketBuffer(COMPONENT_UINJECT);
if (pkt==NULL) {
openserial_printError(
COMPONENT_UINJECT,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
return;
}
pkt->owner = COMPONENT_UINJECT;
pkt->creator = COMPONENT_UINJECT;
pkt->l4_protocol = IANA_UDP;
pkt->l4_destination_port = WKP_UDP_INJECT;
pkt->l4_sourcePortORicmpv6Type = WKP_UDP_INJECT;
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&pkt->l3_destinationAdd.addr_128b[0],uinject_dst_addr,16);
packetfunctions_reserveHeaderSize(pkt,sizeof(uint16_t));
*((uint16_t*)&pkt->payload[0]) = uinject_vars.counter++;
if ((openudp_send(pkt))==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
}
void cexample_task_cb() {
OpenQueueEntry_t* pkt;
owerror_t outcome;
uint8_t numOptions;
uint8_t i;
uint16_t x_int = 0;
uint16_t sum = 0;
uint16_t avg = 0;
uint8_t N_avg = 10;
// don't run if not synch
if (ieee154e_isSynch() == FALSE) return;
// don't run on dagroot
if (idmanager_getIsDAGroot()) {
opentimers_stop(cexample_vars.timerId);
return;
}
for (i = 0; i < N_avg; i++) {
sum += x_int;
}
avg = sum/N_avg;
// create a CoAP RD packet
pkt = openqueue_getFreePacketBuffer(COMPONENT_CEXAMPLE);
if (pkt==NULL) {
openserial_printError(
COMPONENT_CEXAMPLE,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
openqueue_freePacketBuffer(pkt);
return;
}
// take ownership over that packet
pkt->creator = COMPONENT_CEXAMPLE;
pkt->owner = COMPONENT_CEXAMPLE;
// CoAP payload
packetfunctions_reserveHeaderSize(pkt,PAYLOADLEN);
for (i=0;i<PAYLOADLEN;i++) {
pkt->payload[i] = i;
}
avg = openrandom_get16b();
pkt->payload[0] = (avg>>8)&0xff;
pkt->payload[1] = (avg>>0)&0xff;
numOptions = 0;
// location-path option
packetfunctions_reserveHeaderSize(pkt,sizeof(cexample_path0)-1);
memcpy(&pkt->payload[0],&cexample_path0,sizeof(cexample_path0)-1);
packetfunctions_reserveHeaderSize(pkt,1);
pkt->payload[0] = ((COAP_OPTION_NUM_URIPATH) << 4) | (sizeof(cexample_path0)-1);
numOptions++;
// content-type option
packetfunctions_reserveHeaderSize(pkt,2);
pkt->payload[0] = (COAP_OPTION_NUM_CONTENTFORMAT << 4) | 1;
pkt->payload[1] = COAP_MEDTYPE_APPOCTETSTREAM;
numOptions++;
// metadata
pkt->l4_destination_port = WKP_UDP_COAP;
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&pkt->l3_destinationAdd.addr_128b[0],&ipAddr_motesEecs,16);
// send
outcome = opencoap_send(
pkt,
COAP_TYPE_NON,
COAP_CODE_REQ_PUT,
numOptions,
&cexample_vars.desc
);
// avoid overflowing the queue if fails
if (outcome==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
return;
}
void table_update_task_cb() {
OpenQueueEntry_t* pkt;
owerror_t outcome;
// don't run if not synch
if (ieee154e_isSynch() == FALSE ) return;
// don't run on dagroot
if (idmanager_getIsDAGroot()) {
opentimers_stop(table_update_vars.timerId);
return;
}
// create a CoAP RD packet
pkt = openqueue_getFreePacketBuffer(COMPONENT_TABLE_UPDATE);
if (pkt==NULL) {
openserial_printError(
COMPONENT_TABLE_UPDATE,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
openqueue_freePacketBuffer(pkt);
return;
}
// take ownership over that packet
pkt->creator = COMPONENT_TABLE_UPDATE;
pkt->owner = COMPONENT_TABLE_UPDATE;
// CoAP payload
packetfunctions_reserveHeaderSize(pkt,PAYLOADLEN);
//construct packet
int index = 0;
pkt->payload[index++] = 255;//1
pkt->payload[index++] = action;//2
//pkt->payload[index++] = count++;
pkt->payload[index++] = i;//3
//used
pkt->payload[index++] = tableEntry->neighborEntry.used;//4
//parentRef
pkt->payload[index++] = tableEntry->neighborEntry.parentPreference;//5
//stableNeighbor
pkt->payload[index++] = tableEntry->neighborEntry.stableNeighbor;//6
//switchStability
pkt->payload[index++] = tableEntry->neighborEntry.switchStabilityCounter;//7
//address type
pkt->payload[index++] = tableEntry->neighborEntry.addr_64b.type;//8
// the address itself
open_addr_t addr =tableEntry->neighborEntry.addr_64b;//16
memcpy(&pkt->payload[index],&addr.addr_64b,8);
index = index+8;
//dagrank
pkt->payload[index++] = tableEntry->neighborEntry.DAGrank;//17
//rssi
pkt->payload[index] = tableEntry->neighborEntry.rssi;//19
index = index+2;
//numRx
pkt->payload[index++] = tableEntry->neighborEntry.numRx;//20
//numTx
pkt->payload[index++] = tableEntry->neighborEntry.numTx;//21
//numTxACK
pkt->payload[index++] = tableEntry->neighborEntry.numTxACK;//22
//numWraps
pkt->payload[index++] = tableEntry->neighborEntry.numWraps;//23
//asn
pkt->payload[index++] = tableEntry->neighborEntry.asn.byte4;//24
pkt->payload[index] = tableEntry->neighborEntry.asn.bytes2and3;//26
index = index+2;
pkt->payload[index] = tableEntry->neighborEntry.asn.bytes0and1;//28
index = index+2;
//joinPrio
pkt->payload[index] = tableEntry->neighborEntry.joinPrio;//29
// metadata
pkt->l4_destination_port = WKP_UDP_COAP;
pkt->l3_destinationAdd.type = ADDR_128B;
//uint8_t* DODAGID = get_icmpv6rpl_vars()->dio.DODAGID;
uint8_t manager_full_address[16];
// retrieve my prefix and EUI64
memcpy(&manager_full_address[0],idmanager_getMyID(ADDR_PREFIX)->prefix,8); // prefix
memcpy(&manager_full_address[8],&manager_address,8); // manager address
memcpy(&pkt->l3_destinationAdd.addr_128b[0],&manager_full_address,16);
//free some memory
free(tableEntry);
// send
outcome = opencoap_send(
pkt,
COAP_TYPE_NON,
COAP_CODE_RESP_CONTENT,
1,
&table_update_vars.desc
);
// avoid overflowing the queue if fails
if (outcome==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
return;
}
void bbk_task_cb() {
OpenQueueEntry_t* pkt;
error_t outcome;
uint8_t numOptions;
demo_t demoPayload;
// create a CoAP RD packet
pkt = openqueue_getFreePacketBuffer(0xcc);
if (pkt==NULL) {
openserial_printError(0xcc,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
openqueue_freePacketBuffer(pkt);
return;
}
// take ownership over that packet
pkt->creator = COMPONENT_BBK; //just a number randomly picked for this temp app
pkt->owner = COMPONENT_BBK;
// CoAP payload
packetfunctions_reserveHeaderSize(pkt,sizeof(demo_t));
construct_demo(&demoPayload);
memcpy((pkt->payload),&demoPayload,sizeof(demo_t));
numOptions = 0;
// location-path option
packetfunctions_reserveHeaderSize(pkt,sizeof(bbk_path0)-1);
memcpy(&pkt->payload[0],&bbk_path0,sizeof(bbk_path0)-1);
packetfunctions_reserveHeaderSize(pkt,1);
pkt->payload[0] = (COAP_OPTION_LOCATIONPATH-COAP_OPTION_CONTENTTYPE) << 4 |
sizeof(bbk_path0)-1;
numOptions++;
// content-type option
packetfunctions_reserveHeaderSize(pkt,2);
pkt->payload[0] = COAP_OPTION_CONTENTTYPE << 4 |
1;
pkt->payload[1] = COAP_MEDTYPE_APPOCTETSTREAM;
numOptions++;
// metadata
//pkt->l4_destination_port = WKP_UDP_COAP;
pkt->l4_destination_port = WKP_UDP_HDL;
pkt->l3_destinationORsource.type = ADDR_128B;
memcpy(&pkt->l3_destinationORsource.addr_128b[0],&ipAddr_local,16);
// send
if(bbk_vars.sequence<SAMPLE){
bbk_vars.sequence++;
/*outcome = opencoap_send(pkt,
COAP_TYPE_NON,
COAP_CODE_REQ_PUT,
numOptions,
&bbk_vars.desc);*/
outcome = openudp_send(pkt); //call UDP directly bypassing CoAP
} else{
opentimers_stop(bbk_vars.timerId);
bbk_vars.sequence=0;
openqueue_freePacketBuffer(pkt);
}
// avoid overflowing the queue if fails
if (outcome==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
return;
}
void singleChanStop(){
opentimers_stop(bbk_vars.timerId);
}