/*---------------------------------------------------------------------------*/
PROCESS_THREAD(cc2420_process, ev, data)
{
int len;
PROCESS_BEGIN();
PRINTF("cc2420_process: started\n");
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
#if CC2420_TIMETABLE_PROFILING
TIMETABLE_TIMESTAMP(cc2420_timetable, "poll");
#endif /* CC2420_TIMETABLE_PROFILING */
PRINTF("cc2420_process: calling receiver callback\n");
packetbuf_clear();
packetbuf_set_attr(PACKETBUF_ATTR_TIMESTAMP, last_packet_timestamp);
len = cc2420_read(packetbuf_dataptr(), PACKETBUF_SIZE);
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
#if CC2420_TIMETABLE_PROFILING
TIMETABLE_TIMESTAMP(cc2420_timetable, "end");
timetable_aggregate_compute_detailed(&aggregate_time,
&cc2420_timetable);
timetable_clear(&cc2420_timetable);
#endif /* CC2420_TIMETABLE_PROFILING */
}
PROCESS_END();
}
/*
* process rx packet, when process receives poll
*/
static void
pollhandler(void)
{
int len;
do {
/* printf("p(");*/
packetbuf_clear();
len = read_packet(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
/* printf("RDC input %d\n", len);*/
NETSTACK_RDC.input();
}
/* If we received a packet (or parts thereof) while processing the
previous packet, we immediately pull it out from the RX
FIFO. */
/* printf("[");*/
cc1101_rx_interrupt();
/* printf("]");*/
// printf(")\n");
} while(packet_rx_len > 0);
}
/*---------------------------------------------------------------------------*/
void
packetbuf_reference(void *ptr, uint16_t len)
{
packetbuf_clear();
packetbufptr = ptr;
buflen = len;
}
static void recv_uc(struct unicast_conn *c, const rimeaddr_t * from)
{
sec_since_start = clock_seconds();
printf("\n%d - MSG from %d.%d\n", sec_since_start, from->u8[0], from->u8[1]);
msg = (struct unicast_message *)packetbuf_dataptr();
packetbuf_clear();
//printf("MSG TYPE: %d \tCMD: %s \tVALUE: %d\n", msg->type, get_cmd(msg->cmd), msg->value);
switch (msg->cmd) {
case CMD_FAN_ON:
printf("PG:FAN ON\n");
break;
case CMD_FAN_OFF:
printf("PG:FAN OFF\n");
break;
case CMD_HEATER_ON:
printf("PG:HEAT ON\n");
break;
case CMD_HEATER_OFF:
printf("PG:HEAT OFF\n");
break;
case CMD_LIGHT_ON:
printf("PG:LIGHT ON\n");
break;
case CMD_LIGHT_OFF:
printf("PG:LIGHT OFF\n");
break;
default:
printf("\n%s\n", get_cmd(msg->cmd));
}
}
/*---------------------------------------------------------------------------*/
static int
slip_radio_cmd_handler(const uint8_t *data, int len)
{
int i;
if(data[0] == '!') {
/* should send out stuff to the radio - ignore it as IP */
/* --- s e n d --- */
if(data[1] == 'S') {
int pos;
packet_ids[packet_pos] = data[2];
packetbuf_clear();
pos = packetutils_deserialize_atts(&data[3], len - 3);
if(pos < 0) {
PRINTF("slip-radio: illegal packet attributes\n");
return 1;
}
pos += 3;
len -= pos;
if(len > PACKETBUF_SIZE) {
len = PACKETBUF_SIZE;
}
memcpy(packetbuf_dataptr(), &data[pos], len);
packetbuf_set_datalen(len);
PRINTF("slip-radio: sending %u (%d bytes)\n",
data[2], packetbuf_datalen());
/* parse frame before sending to get addresses, etc. */
no_framer.parse();
NETSTACK_MAC.send(packet_sent, &packet_ids[packet_pos]);
packet_pos++;
if(packet_pos >= sizeof(packet_ids)) {
packet_pos = 0;
}
return 1;
} else if(data[1] == 'R' && len == 2) {
#if !CONTIKI_TARGET_CC2538DK
PRINTF("Rebooting\n");
watchdog_reboot();
#endif
return 1;
}
} else if(uip_buf[0] == '?') {
PRINTF("Got request message of type %c\n", uip_buf[1]);
if(data[1] == 'M' && len == 2) {
/* this is just a test so far... just to see if it works */
uip_buf[0] = '!';
uip_buf[1] = 'M';
for(i = 0; i < 8; i++) {
uip_buf[2 + i] = uip_lladdr.addr[i];
}
uip_len = 10;
cmd_send(uip_buf, uip_len);
return 1;
}
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void
send_adv(clock_time_t interval)
{
struct announcement_msg *adata;
struct announcement *a;
packetbuf_clear();
adata = packetbuf_dataptr();
adata->num = 0;
for(a = announcement_list(); a != NULL; a = a->next) {
adata->data[adata->num].id = a->id;
adata->data[adata->num].value = a->value;
adata->num++;
}
packetbuf_set_datalen(ANNOUNCEMENT_MSG_HEADERLEN +
sizeof(struct announcement_data) * adata->num);
PRINTF("%d.%d: sending neighbor advertisement with %d announcements\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], adata->num);
if(adata->num > 0) {
/* Send the packet only if it contains more than zero announcements. */
ipolite_send(&c.c, interval, packetbuf_datalen());
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(stm32w_radio_process, ev, data)
{
int len;
PROCESS_BEGIN();
PRINTF("stm32w_radio_process: started\r\n");
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
PRINTF("stm32w_radio_process: calling receiver callback\r\n");
#if DEBUG > 1
for(uint8_t c = 1; c <= RCVD_PACKET_LEN; c++) {
PRINTF("%x", stm32w_rxbuf[c]);
}
PRINTF("\r\n");
#endif
packetbuf_clear();
len = stm32w_radio_read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
}
if(!RXBUFS_EMPTY()) {
/*
* Some data packet still in rx buffer (this happens because process_poll
* doesn't queue requests), so stm32w_radio_process needs to be called
* again.
*/
process_poll(&stm32w_radio_process);
}
}
PROCESS_END();
}
/**
* \brief Radio RF233 process, infinitely awaits a poll, then checks radio
* state and handles received data.
*/
PROCESS_THREAD(rf233_radio_process, ev, data)
{
int len;
PROCESS_BEGIN();
PRINTF("RF233: started.\n");
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
PRINTF("RF233: polled.\n");
if(interrupt_callback_wants_poll) {
rf233_interrupt_poll();
}
packetbuf_clear();
// packetbuf_set_attr(PACKETBUF_ATTR_TIMESTAMP, last_packet_timestamp);
len = rf233_read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
} else {
PRINTF("RF233: error while reading: %d\n", len);
}
}
PROCESS_END();
}
struct net_buf *l2_buf_get_reserve(uint16_t reserve_head)
#endif
{
struct net_buf *buf;
buf = net_buf_get(&free_l2_bufs, reserve_head);
if (!buf) {
#ifdef DEBUG_L2_BUFS
NET_ERR("Failed to get free L2 buffer (%s():%d)\n",
caller, line);
#else
NET_ERR("Failed to get free L2 buffer\n");
#endif
return NULL;
}
dec_free_l2_bufs(buf);
NET_BUF_CHECK_IF_NOT_IN_USE(buf);
#ifdef DEBUG_L2_BUFS
NET_DBG("[%d] buf %p reserve %u ref %d (%s():%d)\n",
get_free_l2_bufs(), buf, reserve_head, buf->ref,
caller, line);
#else
NET_DBG("buf %p reserve %u ref %d\n", buf, reserve_head, buf->ref);
#endif
packetbuf_clear(buf);
return buf;
}
/*---------------------------------------------------------------------------*/
static void
recv( const struct mac_driver *c)
{
packetbuf_set_attr(PACKETBUF_ATTR_CHANNEL, 34);
int len = c->read();
char cleanString [128];
int cleanLen = 0;
int i;
char* in= (char*)packetbuf_dataptr();
for ( i = 0; i < len; i++)
{
if ( ( in[i] >= ' ' && in[i] <= 'z' ))
{
cleanString[cleanLen] = in[i];
printf("%i %i\n",i,in[i]);
cleanLen++;
}
}
//cleanString[cleanLen] = '\0';
cleanLen++;
printf("message received, len = %d, '%s'\n", cleanLen, cleanString);
//printf("message received, len = %d, '%s'\n", len, (char *)packetbuf_dataptr());
leds_toggle(LEDS_GREEN);
packetbuf_clear();
//packetbuf_attr_clear();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(uz2400_process, ev, data)
{
int len;
PROCESS_BEGIN();
PRINTF("uz2400_process: started\n");
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
//#if UZ2400_TIMETABLE_PROFILING
// TIMETABLE_TIMESTAMP(uz2400_timetable, "poll");
//#endif /* UZ2400_TIMETABLE_PROFILING */
PRINTF("uz2400_process: calling receiver callback\n");
packetbuf_clear();
packetbuf_set_attr(PACKETBUF_ATTR_TIMESTAMP, last_packet_timestamp);
len = uz2400_read(packetbuf_dataptr(), PACKETBUF_SIZE);
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
/* flushrx(); */
//#if UZ2400_TIMETABLE_PROFILING
// TIMETABLE_TIMESTAMP(uz2400_timetable, "end");
// timetable_aggregate_compute_detailed(&aggregate_time,
// &uz2400_timetable);
// timetable_clear(&uz2400_timetable);
//#endif /* UZ2400_TIMETABLE_PROFILING */
//EXTI4_ClearBit();
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
void
rime_init(const struct mac_driver *m)
{
queuebuf_init();
route_init();
packetbuf_clear();
neighbor_init();
announcement_init();
rime_mac = m;
rime_mac->set_receive_function(input);
chameleon_init(&chameleon_bitopt);
#if ! RIME_CONF_NO_POLITE_ANNOUCEMENTS
/* XXX This is initializes the transmission of announcements but it
* is not currently certain where this initialization is supposed to
* be. Also, the times are arbitrarily set for now. They should
* either be configurable, or derived from some MAC layer property
* (duty cycle, sleep time, or something similar). But this is OK
* for now, and should at least get us started with experimenting
* with announcements.
*/
polite_announcement_init(POLITE_ANNOUNCEMENT_CHANNEL,
POLITE_ANNOUNCEMENT_START_TIME,
POLITE_ANNOUNCEMENT_MAX_TIME);
#endif /* ! RIME_CONF_NO_POLITE_ANNOUCEMENTS */
}
/*---------------------------------------------------------------------------*/
static void
send_adv(void *ptr)
{
struct announcement_msg *adata;
struct announcement *a;
packetbuf_clear();
adata = packetbuf_dataptr();
adata->num = 0;
for(a = announcement_list(); a != NULL && a->has_value; a = list_item_next(a)) {
adata->data[adata->num].id = a->id;
adata->data[adata->num].value = a->value;
adata->num++;
}
packetbuf_set_datalen(ANNOUNCEMENT_MSG_HEADERLEN +
sizeof(struct announcement_data) * adata->num);
PRINTF("%d.%d: sending neighbor advertisement with %d announcements\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1], adata->num);
if(adata->num > 0) {
/* Send the packet only if it contains more than zero announcements. */
broadcast_send(&c.c);
}
PRINTF("%d.%d: sending neighbor advertisement with val %d\n",
linkaddr_node_addr.u8[0], linkaddr_node_addr.u8[1],
c.val);
}
/**
* @brief transmit_epidemic
*/
static void transmit_epidemic(){
packetbuf_clear();
data_packet_t *dpkt = (data_packet_t*)packetbuf_dataptr();
if(isAnchorFlag){
dpkt->type = ANCHOR_PKT;
}else{
dpkt->type = PROBE_PKT;
}
//add sender offset.
dpkt->offset = probe_offset;
dpkt->period = get_node_period();
dpkt->src_id = rimeaddr_node_addr.u8[0];
uint8_t pldSize = 0;
if(radio_read_flag == 0){
if(list_access_flag == 0){
list_access_flag = 1;
pldSize = neighs_add2payload(&dpkt->data[0], isAnchorFlag, probe_offset);
list_access_flag = 0;
}
//if(pldSize){
rtimer_clock_t t0;
uint8_t i = 0, pkt_seen = 0, ccaCounter= 0;
//ccaCounter= randomint_between(CCA_COUNT_MAX, CCA_COUNT_MAX_TX);
ccaCounter = /*CCA_COUNT_MAX +*/ random_int(CCA_COUNT_MAX_TX);
//watchdog
watchdog_periodic();
for( i = 0; i < ccaCounter && beacon_2_flag; i++){
//watchdog
watchdog_periodic();
t0 = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)){
//do nothing.. KUNANGA
}
if(NETSTACK_RADIO.channel_clear() == 0){
pkt_seen = 1;
break; // maybe return here .. collision is expected
}
}
if((pkt_seen == 0) && (radio_read_flag == 0)){
NETSTACK_RADIO.send((void*)packetbuf_dataptr(),DATAPKT_HDR_LEN + pldSize);
}
//} //end of pldSize
}
}
/**
* send the broadcast list to the neighbor
*/
void send_br_list(struct broadcast_conn *broadcastConn){
Br_msg_list *br_msg_list;
Br_msg_list *remove;
if(list_length(broadcast_list)>0){
for(br_msg_list = list_head(broadcast_list);br_msg_list!=NULL;){
packetbuf_copyfrom(&br_msg_list->broadcast_msg,sizeof(Broadcast_msg));
printf("[BC] @%d @%u.%u base station@%u.%u\n", clock_seconds(),rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1],
br_msg_list->broadcast_msg.base_station.u8[0],br_msg_list->broadcast_msg.base_station.u8[1]);
broadcast_send(broadcastConn);
packetbuf_clear();
print_br_list();
remove = br_msg_list;
br_msg_list = br_msg_list->next;
if(local_node.sen_type == BASE_STATION && (remove->broadcast_msg.msg_type==SUBSCRIBE||
remove->broadcast_msg.msg_type==UNSUBSCRIBE)){
}else if(remove!=NULL&&list_length(broadcast_list)>1){
list_remove(broadcast_list,remove);
memb_free(&broadcast_list_memb, remove);
printf("[DELET-BR-MSG] msg sub_type %u msg_type %u br list length %u\n",remove->broadcast_msg.subscribe_type,
remove->broadcast_msg.msg_type,list_length(broadcast_list));
remove = NULL;
break;
}
}
}
}
PROCESS_THREAD(rime_udp_process, ev, data)
{
static uip_ipaddr_t ipaddr;
PROCESS_BEGIN();
broadcast_conn = udp_broadcast_new(UIP_HTONS(RIME_UDP_PORT), NULL);
if(broadcast_conn == NULL) {
PRINTF("rime-udp: Failed to allocate a broadcast connection!\n");
}
uip_create_unspecified(&ipaddr);
unicast_conn = udp_new(&ipaddr, UIP_HTONS(RIME_UDP_PORT), NULL);
if(unicast_conn == NULL) {
PRINTF("rime-udp: Failed to allocate a unicast connection!\n");
}
udp_bind(unicast_conn, UIP_HTONS(RIME_UDP_PORT));
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
if(uip_newdata()) {
packetbuf_clear();
memmove(packetbuf_hdrptr(), uip_appdata, uip_datalen());
PRINTF("rime-udp: received %d bytes\n", uip_datalen());
receiver_callback(&rime_udp_driver);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static void
send_rrep(struct route_discovery_conn *c, const rimeaddr_t *dest)
{
struct rrep_hdr *rrepmsg;
struct route_entry *rt;
rimeaddr_t saved_dest;
rimeaddr_copy(&saved_dest, dest);
packetbuf_clear();
dest = &saved_dest;
rrepmsg = packetbuf_dataptr();
packetbuf_set_datalen(sizeof(struct rrep_hdr));
rrepmsg->hops = 0;
rimeaddr_copy(&rrepmsg->dest, dest);
rimeaddr_copy(&rrepmsg->originator, &rimeaddr_node_addr);
rt = route_lookup(dest);
if(rt != NULL)
{
PRINTF("%d.%d: send_rrep to %d.%d via %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
dest->u8[0],dest->u8[1],
rt->nexthop.u8[0],rt->nexthop.u8[1]);
unicast_send(&c->rrepconn, &rt->nexthop);
}
else
{
PRINTF("%d.%d: no route for rrep to %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
dest->u8[0],dest->u8[1]);
}
}
static void
send_announcement(void *ptr)
{
struct cxmac_hdr *hdr;
int announcement_len;
/* Set up the probe header. */
packetbuf_clear();
hdr = packetbuf_dataptr();
announcement_len = format_announcement((char *)hdr +
sizeof(struct cxmac_hdr));
if(announcement_len > 0) {
packetbuf_set_datalen(sizeof(struct cxmac_hdr) + announcement_len);
hdr->dispatch = DISPATCH;
hdr->type = TYPE_ANNOUNCEMENT;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null);
packetbuf_set_attr(PACKETBUF_ATTR_RADIO_TXPOWER, announcement_radio_txpower);
if(NETSTACK_FRAMER.create()) {
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
}
}
}
PROCESS_THREAD(uwb_process, ev, data)
{
int len;
PROCESS_BEGIN();
UWBPROCESSFLAG(01);
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
UWBPROCESSFLAG(02);
if (uwb_fsm != UWB_STATE_RX_PROCESS_POLLED)
PRINTF("uwb: wrong state in process: %u\n",uwb_fsm);
packetbuf_clear();
len = ram_rx_buffer[2];
if ((len > 0) && (len < PACKETBUF_SIZE))
{
memcpy(packetbuf_dataptr(),&ram_rx_buffer[3],len);
packetbuf_set_datalen(len);
UWBPROCESSFLAG(03);
NETSTACK_RDC.input();
}
/* switch back to listen-state */
PRINTF("uwb: enabling rx-mode\r\n");
enable_rx_mode();
PRINTF("uwb: read: %u bytes\n",len);
UWBPROCESSFLAG(04);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static int
format_data(struct rudolph1mh_conn *c, int chunk)
{
struct rudolph1mh_datapacket *p;
packetbuf_clear();
p = packetbuf_dataptr();
p->h.type = TYPE_DATA;
p->h.s_id = c->s_id;
p->h.chunk = chunk;
p->datalen = 0; //read_data(c, p->data, chunk);
if(c->cb->read_chunk) {
p->datalen = c->cb->read_chunk(c, chunk * RUDOLPH1MH_DATASIZE, p->data,
RUDOLPH1MH_DATASIZE);
}
if(p->datalen != RUDOLPH1MH_DATASIZE){
p->h.type = TYPE_FIN;
}
packetbuf_set_datalen(sizeof(struct rudolph1mh_datapacket) - (RUDOLPH1MH_DATASIZE
- p->datalen));
return p->datalen;
}
/**
* the sensor node subscribed will send the data to the base station via the next hop according to the routing table
*/
void publish(struct runicast_conn *runicast){
Ru_msg_list *ru_msg_list;
Rt_table *chosen_route;
if(list_length(runicast_list)>0){
for(ru_msg_list = list_head(runicast_list);ru_msg_list!=NULL;){
chosen_route = find_best_route();
current_route = chosen_route;
if(current_route!=NULL){
packetbuf_copyfrom(&ru_msg_list->runicast_msg, sizeof(Runicast_msg));
printf("[RU] @%d-@%u.%u->@%u.%u\n", clock_seconds(),rimeaddr_node_addr.u8[0],rimeaddr_node_addr.u8[1],
chosen_route->rt_entry.next_hop.u8[0],chosen_route->rt_entry.next_hop.u8[1]);
runicast_send(runicast,&chosen_route->rt_entry.next_hop,MAX_RETRANSMISSIONS);
packetbuf_clear();
Ru_msg_list *to_remove;
to_remove = ru_msg_list;
ru_msg_list = ru_msg_list->next;
// if(ru_send_success == true){
// list_remove(runicast_list,to_remove);
// memb_free(&runicast_list_memb,to_remove);
// printf("[DELET-RU-MSG]\n");
// }
}else{
printf("[ERRO] current route is none");
}
}
}
remove_all_runicast_entry();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(example_collect_process, ev, data)
{
static struct etimer periodic;
static struct etimer et;
PROCESS_BEGIN();
collect_open(&tc, 130, COLLECT_ROUTER, &callbacks);
if(rimeaddr_node_addr.u8[0] == 1 &&
rimeaddr_node_addr.u8[1] == 0) {
printf("I am sink\n");
collect_set_sink(&tc, 1);
}
/* Allow some time for the network to settle. */
etimer_set(&et, 120 * CLOCK_SECOND);
PROCESS_WAIT_UNTIL(etimer_expired(&et));
while(1) {
/* Send a packet every 30 seconds. */
if(etimer_expired(&periodic)) {
etimer_set(&periodic, CLOCK_SECOND * 30);
etimer_set(&et, random_rand() % (CLOCK_SECOND * 30));
}
PROCESS_WAIT_EVENT();
if(etimer_expired(&et)) {
static rimeaddr_t oldparent;
const rimeaddr_t *parent;
printf("Sending\n");
packetbuf_clear();
packetbuf_set_datalen(sprintf(packetbuf_dataptr(),
"%s", "Hello") + 1);
collect_send(&tc, 15);
parent = collect_parent(&tc);
if(!rimeaddr_cmp(parent, &oldparent)) {
//alten parent ausgeben (falls der nicht null war)
if(!rimeaddr_cmp(&oldparent, &rimeaddr_null)) {
printf("#L %d 0\n", oldparent.u8[0]);
}
//neuen parent ausgeben (falls der nicht null ist)
if(!rimeaddr_cmp(parent, &rimeaddr_null)) {
printf("#L %d 1\n", parent->u8[0]);
}
//speichern
rimeaddr_copy(&oldparent, parent);
}
}
}
PROCESS_END();
}
/**
* publish a single message
*/
void single_publish(struct runicast_conn *runicast,Runicast_msg runicast_msg){
packetbuf_copyfrom(&runicast_msg, sizeof(Runicast_msg));
printf("[RU] timestamp @%d seqno %d last hop address %u.%u\n", runicast_msg.timestamp,runicast_msg.seqno,runicast_msg.last_hop.u8[0],runicast_msg.last_hop.u8[1]);
runicast_send(runicast,&find_best_route()->rt_entry.next_hop,MAX_RETRANSMISSIONS);
packetbuf_clear();
}
/*---------------------------------------------------------------------------*/
static void
handle_beacon_send_timer(struct net_buf *buf, void *p)
{
struct net_buf *mbuf;
frame802154_t params;
uint8_t len;
mbuf = l2_buf_get_reserve(0);
if(!mbuf) {
return;
}
/* init to zeros */
memset(¶ms, 0, sizeof(params));
/* use packetbuf for sending ?? */
packetbuf_clear(mbuf);
/* Build the FCF. */
params.fcf.frame_type = FRAME802154_BEACONFRAME;
/* Insert IEEE 802.15.4 (2006) version bits. */
params.fcf.frame_version = FRAME802154_IEEE802154_2006;
/* assume long for now */
params.fcf.src_addr_mode = FRAME802154_LONGADDRMODE;
linkaddr_copy((linkaddr_t *)¶ms.src_addr, &linkaddr_node_addr);
/* Set the source PAN ID to the global variable. */
params.src_pid = panid;
params.fcf.dest_addr_mode = FRAME802154_SHORTADDRMODE;
params.dest_addr[0] = 0xFF;
params.dest_addr[1] = 0xFF;
params.dest_pid = 0xffff;
params.seq = framer_802154_next_seqno();
/* Calculate beacon length and copy it to packetbuf */
beacon_payload_len = handler_802154_calculate_beacon_payload_length(beacon_payload, BEACON_PAYLOAD_BUFFER_SIZE);
packetbuf_copyfrom(mbuf, beacon_payload, beacon_payload_len);
/* Set payload and payload length */
params.payload = packetbuf_dataptr(mbuf);
params.payload_len = packetbuf_datalen(mbuf);
len = frame802154_hdrlen(¶ms);
if(packetbuf_hdralloc(mbuf, len)) {
frame802154_create(¶ms, packetbuf_hdrptr(mbuf), len);
if(NETSTACK_RADIO.send(mbuf, packetbuf_hdrptr(mbuf),
packetbuf_totlen(mbuf)) != RADIO_TX_OK) {
l2_buf_unref(mbuf);
return;
}
HANDLER_802154_STAT(handler_802154_stats.beacons_sent++);
}
}
/*---------------------------------------------------------------------------*/
static void
recv(const struct mac_driver *c)
{
printf("message received '%s'\n", (char *)packetbuf_dataptr());
leds_toggle(LEDS_GREEN);
packetbuf_clear();
packetbuf_attr_clear();
}
/*---------------------------------------------------------------------------*/
static int
read(void)
{
int len;
packetbuf_clear();
len = radio->read(packetbuf_dataptr(), PACKETBUF_SIZE);
packetbuf_set_datalen(len);
return len;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(shell_download_process, ev, data)
{
const char *nextptr;
static rimeaddr_t addr;
int len;
char buf[32];
PROCESS_BEGIN();
/* Parse node addr */
addr.u8[0] = shell_strtolong(data, &nextptr);
if(nextptr == data || *nextptr != '.') {
shell_output_str(&download_command,
"download <node addr> <filename>: need node address", "");
PROCESS_EXIT();
}
++nextptr;
addr.u8[1] = shell_strtolong(nextptr, &nextptr);
/* Get the length of the file, excluding a terminating NUL character. */
while(nextptr[0] == ' ') {
nextptr++;
}
len = strlen(nextptr);
/*snprintf(buf, sizeof(buf), "%d.%d", addr.u8[0], addr.u8[1]);*/
/*shell_output_str(&download_command, "Downloading from: ", buf);*/
if(len > PACKETBUF_SIZE - 32) {
snprintf(buf, sizeof(buf), "%d", len);
shell_output_str(&download_command, "filename too large: ", buf);
PROCESS_EXIT();
}
/*shell_output_str(&download_command, "Downloading file: ", nextptr);*/
/* Send file request */
downloading = 1;
rucb_open(&rucb, RUCB_CHANNEL, &rucb_call);
packetbuf_clear();
*((uint8_t *)packetbuf_dataptr()) = ++req_seq_counter;
memcpy(((char *)packetbuf_dataptr()) + 1, nextptr, len + 1);
packetbuf_set_datalen(len + 2);
PRINTF("requesting '%s'\n", nextptr);
runicast_send(&runicast, &addr, MAX_RETRANSMISSIONS);
/* Wait for download to finish */
leds_on(LEDS_BLUE);
PROCESS_WAIT_UNTIL(!runicast_is_transmitting(&runicast) && !downloading);
leds_off(LEDS_BLUE);
rucb_close(&rucb);
/*shell_output_str(&download_command, "Done!", "");*/
PROCESS_END();
}
void
packet_received(struct broadcast_conn *connection, const rimeaddr_t *from)
{
struct subscription_item *si;
switch(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE)) {
case MWARE_MSG_SUB:
si = subscription_get(&(packetbuf_msg_sub())->id);
if (si != NULL) {
if (subscription_is_unsubscribed(si)) {
subscription_reset_last_shout(si);
} else {
if (!subscription_update(si, from,
(packetbuf_msg_sub())->sub.hops + 1)) {
si = NULL;
}
}
} else if (!subscription_is_too_far(&(packetbuf_msg_sub())->sub)) {
const rimeaddr_t * parent;
parent = (identifier_is_mine(&(packetbuf_msg_sub())->id) ? &rimeaddr_null : from);
si = subscription_insert(
&(packetbuf_msg_sub())->id,
&(packetbuf_msg_sub())->sub,
parent,
(packetbuf_msg_sub())->sub.hops + 1);
}
if (si != NULL) {
subscription_print(si, "rs");
subscription_sync_epoch(si, &(packetbuf_msg_sub())->sub);
wind_item_timer(si, subscription_desync_jitter(si, &(packetbuf_msg_sub())->sub));
}
break;
case MWARE_MSG_PUB:
si = subscription_get(&(packetbuf_msg_pub())->id);
if (si == NULL || subscription_is_unsubscribed(si)) {
break;
}
if (rimeaddr_cmp(&si->next_hop, from)) {
subscription_update_last_heard(si);
} else if (message_is_published_to_me()) {
subscription_data_input(si,
(packetbuf_msg_pub())->data,
(packetbuf_msg_pub())->node_count);
}
break;
case MWARE_MSG_UNSUB:
si = subscription_get(&(packetbuf_msg_unsub())->id);
if (si == NULL) {
break;
}
subscription_print(si, "ru");
subscription_unsubscribe(si);
break;
}
packetbuf_clear();
}
/*---------------------------------------------------------------------------*/
static void
send_ctrl_command(const rimeaddr_t *to, uint8_t command)
{
struct ctrl_msg *msg;
packetbuf_clear();
packetbuf_set_datalen(sizeof(struct ctrl_msg));
msg = packetbuf_dataptr();
msg->command = command;
runicast_send(&ctrl, to, MAX_RETRIES);
}
/*---------------------------------------------------------------------------*/
int
packetbuf_copyfrom(const void *from, uint16_t len)
{
uint16_t l;
packetbuf_clear();
l = len > PACKETBUF_SIZE? PACKETBUF_SIZE: len;
memcpy(packetbufptr, from, l);
buflen = l;
return l;
}