int ccnl_riot_client_new_face(kernel_pid_t relay_pid, char *type, char *faceid, unsigned char *reply_buf) { DEBUGMSG(1, "riot_new_face: mkNewFaceRquest\n"); int len = mkNewFaceRequest(reply_buf, type, NULL, NULL, faceid, NULL); riot_ccnl_msg_t rmsg; rmsg.payload = reply_buf; rmsg.size = len; msg_t m, rep; m.content.ptr = (char *) &rmsg; m.type = CCNL_RIOT_MSG; DEBUGMSG(1, " sending face req to relay\n"); msg_send(&m, relay_pid, 1); /* ######################################################################### */ msg_receive(&rep); DEBUGMSG(1, " received reply from relay\n"); riot_ccnl_msg_t *rmsg_reply = (riot_ccnl_msg_t *) rep.content.ptr; memcpy(reply_buf, rmsg_reply->payload, rmsg_reply->size); int size = rmsg_reply->size; ccnl_free(rmsg_reply); return size; }
void radio(void) { msg_t m; radio_packet_t *p; uint8_t i; msg_init_queue(msg_q, RCV_BUFFER_SIZE); while (1) { msg_receive(&m); if (m.type == PKT_PENDING) { p = (radio_packet_t*) m.content.ptr; printf("Packet waiting, process %p...\n", p); printf("\tLength:\t%u\n", p->length); printf("\tSrc:\t%u\n", p->src); printf("\tDst:\t%u\n", p->dst); printf("\tLQI:\t%u\n", p->lqi); printf("\tRSSI:\t%u\n", p->rssi); for (i = 0; i < p->length; i++) { printf("%02X ", p->data[i]); } p->processing--; printf("\n"); } else if (m.type == ENOBUFFER) { puts("Transceiver buffer full"); } else { puts("Unknown packet received"); } } }
static void esp_now_scan_peers_start (void) { DEBUG("%s\n", __func__); wifi_scan_config_t scan_cfg = { .ssid = NULL, .bssid = NULL, .channel = esp_now_params.channel, .show_hidden = true, .scan_type = WIFI_SCAN_TYPE_ACTIVE, .scan_time.active.min = 0, .scan_time.active.max = 120 /* TODO tune value */ }; esp_wifi_scan_start(&scan_cfg, false); } #define ESP_NOW_EVENT_SCAN_PEERS 1 static kernel_pid_t esp_now_event_handler_pid; char esp_now_event_handler_stack [THREAD_STACKSIZE_DEFAULT]; static void *esp_now_event_handler (void *arg) { msg_t event; while (1) { msg_receive(&event); switch (event.content.value) { case ESP_NOW_EVENT_SCAN_PEERS: esp_now_scan_peers_start (); break; } } return NULL; }
void *udp_packet_handler(void *arg) { (void) arg; msg_t m_recv_ip, m_send_ip, m_recv_udp, m_send_udp; socket_internal_t *udp_socket = NULL; msg_init_queue(udp_msg_queue, UDP_PKT_RECV_BUF_SIZE); while (1) { msg_receive(&m_recv_ip); ipv6_hdr_t *ipv6_header = ((ipv6_hdr_t *)m_recv_ip.content.ptr); udp_hdr_t *udp_header = ((udp_hdr_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN)); uint16_t chksum = ipv6_csum(ipv6_header, (uint8_t*) udp_header, NTOHS(udp_header->length), IPPROTO_UDP); if (chksum == 0xffff) { udp_socket = get_udp_socket(udp_header); if (udp_socket != NULL) { m_send_udp.content.ptr = (char *)ipv6_header; msg_send_receive(&m_send_udp, &m_recv_udp, udp_socket->recv_pid); } else { printf("Dropped UDP Message because no thread ID was found for delivery!\n"); } } else { printf("Wrong checksum (%x)!\n", chksum); } msg_reply(&m_recv_ip, &m_send_ip); } }
int destiny_socket_accept(int s, sockaddr6_t *addr, uint32_t *addrlen) { socket_internal_t *server_socket = get_socket(s); if (is_tcp_socket(s) && (server_socket->socket_values.tcp_control.state == LISTEN)) { socket_internal_t *current_queued_socket = get_waiting_connection_socket(s, NULL, NULL); if (current_queued_socket != NULL) { return handle_new_tcp_connection(current_queued_socket, server_socket, thread_getpid()); } else { /* No waiting connections, waiting for message from TCP Layer */ msg_t msg_recv_client_syn; msg_recv_client_syn.type = UNDEFINED; while (msg_recv_client_syn.type != TCP_SYN) { msg_receive(&msg_recv_client_syn); } current_queued_socket = get_waiting_connection_socket(s, NULL, NULL); return handle_new_tcp_connection(current_queued_socket, server_socket, thread_getpid()); } } else { return -1; } }
int32_t udp_recvfrom(int s, void *buf, uint32_t len, int flags, sockaddr6_t *from, uint32_t *fromlen) { (void) flags; msg_t m_recv, m_send; ipv6_hdr_t *ipv6_header; udp_hdr_t *udp_header; uint8_t *payload; socket_base_get_socket(s)->recv_pid = thread_getpid(); msg_receive(&m_recv); ipv6_header = ((ipv6_hdr_t *)m_recv.content.ptr); udp_header = ((udp_hdr_t *)(m_recv.content.ptr + IPV6_HDR_LEN)); payload = (uint8_t *)(m_recv.content.ptr + IPV6_HDR_LEN + UDP_HDR_LEN); memset(buf, 0, len); /* cppcheck: the memset sets parts of the buffer to 0 even though it will * be overwritten by the next memcpy. However without the memset the buffer * could contain stale data (if the copied data is less then the buffer * length) and setting just the left over part of the buffer to 0 would * introduce overhead (calculation how much needs to be zeroed). */ /* cppcheck-suppress redundantCopy */ memcpy(buf, payload, NTOHS(udp_header->length) - UDP_HDR_LEN); memcpy(&from->sin6_addr, &ipv6_header->srcaddr, 16); from->sin6_family = AF_INET6; from->sin6_flowinfo = 0; from->sin6_port = udp_header->src_port; *fromlen = sizeof(sockaddr6_t); msg_reply(&m_recv, &m_send); return NTOHS(udp_header->length) - UDP_HDR_LEN; }
int ccnl_riot_client_register_prefix(kernel_pid_t relay_pid, char *prefix, char *faceid, unsigned char *reply_buf) { DEBUGMSG(1, "riot_register_prefix: mkPrefixregRequest\n"); int len = mkPrefixregRequest(reply_buf, 1, prefix, faceid); riot_ccnl_msg_t rmsg; rmsg.payload = reply_buf; rmsg.size = len; msg_t m, rep; m.content.ptr = (char *) &rmsg; m.type = CCNL_RIOT_MSG; DEBUGMSG(1, " sending prefix req to relay\n"); msg_send(&m, relay_pid, 1); /* ######################################################################### */ msg_receive(&rep); DEBUGMSG(1, " received reply from relay\n"); riot_ccnl_msg_t *rmsg_reply = (riot_ccnl_msg_t *) rep.content.ptr; memcpy(reply_buf, rmsg_reply->payload, rmsg_reply->size); reply_buf[rmsg_reply->size] = '\0'; int size = rmsg_reply->size; ccnl_free(rmsg_reply); return size; }
void* pir_handler(void *arg) { (void) arg; /* unused */ msg_t msg_q[1]; msg_init_queue(msg_q, 1); #ifndef TEST_PIR_POLLING printf("Registering PIR handler thread... %s\n", pir_register_thread(&pir) == 0 ? "[OK]" : "[Failed]"); #endif msg_t m; while (msg_receive(&m)) { printf("PIR handler got a message: "); switch (m.type) { case PIR_STATUS_HI: puts("something started moving."); gpio_set(led_red); gpio_clear(led_green); break; case PIR_STATUS_LO: puts("the movement has ceased."); gpio_set(led_green); gpio_clear(led_red); break; default: puts("stray message."); break; } } puts("PIR handler: this should not have happened!"); return NULL; }
void *beaconing(void *arg) { (void) arg; xtimer_t status_timer; msg_t msg; msg_t update_msg; kernel_pid_t mypid = thread_getpid(); /* initialize message queue */ msg_init_queue(_beac_msg_q, Q_SZ); /* start periodic timer */ update_msg.type = MSG_UPDATE_EVENT; xtimer_set_msg(&status_timer, UPDATE_INTERVAL, &update_msg, mypid); while(1) { msg_receive(&msg); switch (msg.type) { case MSG_UPDATE_EVENT: xtimer_set_msg(&status_timer, UPDATE_INTERVAL, &update_msg, mypid); send_update(initial_pos, p_buf); break; default: break; } } /* never reached */ return NULL; }
/************************************************************************************************** * sys_sendrec ************************************************************************************************** * <Ring 0> The core routine of system call 'sendrec'. * * @param function SEND, RECEIVE, BOTH * @param src_dest To / From whom the message is transferred * @param msg Pointer to the MESSAGE struct * @param proc The caller process * * @return 0 if success *************************************************************************************************/ PUBLIC int sys_sendrec(int function, int src_dest, MESSAGE* msg, PROCESS* proc){ assert(k_reenter == 0); /* make sure we are not in ring0 */ assert((src_dest >= 0 && src_dest < NR_TASKS + NR_PROCS) || src_dest == ANY || src_dest == INTERRUPT); int ret = 0; int caller = proc2pid(proc); MESSAGE* mla = (MESSAGE*) va2la(caller, msg); mla->source = caller; /* from caller */ assert(mla->source != src_dest); /** * Actually we have the third message type: BOTH. However, it is not allowed to be passed * to the kernel directly. Kernel doesn't know it at all. It is transformed into a SEND * followed by RECEIVE by 'send_recv()'. */ if(function == SEND){ ret = msg_send(proc, src_dest, msg); if(ret != 0){ return ret; } }else if(function == RECEIVE){ ret = msg_receive(proc, src_dest, msg); if(ret != 0){ return ret; } }else{ panic("{sys_sendrec} invalid function: %d (SEND: %d, RECEIVE: %d).", function, SEND, RECEIVE); } return 0; }
void border_process_lowpan(void) { msg_t m; struct ipv6_hdr_t *ipv6_buf; while(1) { msg_receive(&m); ipv6_buf = (struct ipv6_hdr_t *)m.content.ptr; if(ipv6_buf->nextheader == PROTO_NUM_ICMPV6) { struct icmpv6_hdr_t *icmp_buf = (struct icmpv6_hdr_t *)(((uint8_t *)ipv6_buf) + IPV6_HDR_LEN); if(icmp_buf->type == ICMP_REDIRECT) { continue; } if(icmpv6_demultiplex(icmp_buf) == 0) { continue; } /* Here, other ICMPv6 message types for ND may follow. */ } /* TODO: Bei ICMPv6-Paketen entsprechende LoWPAN-Optionen verarbeiten und entfernen */ multiplex_send_ipv6_over_uart(ipv6_buf); } }
int32_t destiny_socket_recvfrom(int s, void *buf, uint32_t len, int flags, sockaddr6_t *from, uint32_t *fromlen) { if (isUDPSocket(s)) { msg_t m_recv, m_send; ipv6_hdr_t *ipv6_header; udp_hdr_t *udp_header; uint8_t *payload; get_socket(s)->recv_pid = thread_getpid(); msg_receive(&m_recv); ipv6_header = ((ipv6_hdr_t *)m_recv.content.ptr); udp_header = ((udp_hdr_t *)(m_recv.content.ptr + IPV6_HDR_LEN)); payload = (uint8_t *)(m_recv.content.ptr + IPV6_HDR_LEN + UDP_HDR_LEN); memset(buf, 0, len); memcpy(buf, payload, udp_header->length - UDP_HDR_LEN); memcpy(&from->sin6_addr, &ipv6_header->srcaddr, 16); from->sin6_family = AF_INET6; from->sin6_flowinfo = 0; from->sin6_port = udp_header->src_port; *fromlen = sizeof(sockaddr6_t); msg_reply(&m_recv, &m_send); return udp_header->length - UDP_HDR_LEN; } else if (is_tcp_socket(s)) { return destiny_socket_recv(s, buf, len, flags); } else { printf("Socket Type not supported!\n"); return -1; } }
static void next_exception_forwarded_reply (struct next_inferior_status *inferior, struct next_exception_data *erequest) { kern_return_t kret; struct next_exception_reply ereply; mach_port_t orig_reply_port = erequest->header.msg_remote_port; erequest->header.msg_remote_port = inferior->saved_exceptions.port; erequest->header.msg_local_port = inferior->exception_reply_port; inferior_debug ("sending exception to old exception port\n"); kret = msg_send (&erequest->header, MSG_OPTION_NONE, 0); MACH_CHECK_ERROR (kret); ereply.header.msg_size = sizeof (struct next_exception_reply); ereply.header.msg_local_port = inferior->exception_reply_port; inferior_debug ("receiving exception reply from old exception port\n"); kret = msg_receive (&ereply.header, RCV_LARGE, 0); MACH_CHECK_ERROR (kret); ereply.header.msg_local_port = PORT_NULL; ereply.header.msg_remote_port = orig_reply_port; inferior_debug ("sending exception reply\n"); kret = msg_send (&ereply.header, MSG_OPTION_NONE, 0); MACH_CHECK_ERROR (kret); }
/** * Function executed by NHDP thread receiving messages in an endless loop */ static void *_nhdp_runner(void *arg) { nhdp_if_entry_t *if_entry; msg_t msg_rcvd, msg_queue[NHDP_MSG_QUEUE_SIZE]; (void)arg; msg_init_queue(msg_queue, NHDP_MSG_QUEUE_SIZE); while (1) { msg_receive(&msg_rcvd); switch (msg_rcvd.type) { case MSG_TIMER: mutex_lock(&send_rcv_mutex); if_entry = (nhdp_if_entry_t *) msg_rcvd.content.ptr; nhdp_writer_send_hello(if_entry); /* TODO: Add jitter */ /* Schedule next sending */ vtimer_set_msg(&if_entry->if_timer, if_entry->hello_interval, thread_getpid(), MSG_TIMER, (void *) if_entry); mutex_unlock(&send_rcv_mutex); break; default: break; } } return 0; }
void* pir_handler(void *arg) { msg_t msg_q[1]; msg_init_queue(msg_q, 1); printf("Registering PIR handler thread... %s\n", pir_register_thread(&dev) == 0 ? "[OK]" : "[Failed]"); msg_t m; while (msg_receive(&m)) { printf("PIR handler got a message: "); switch (m.type) { case PIR_STATUS_HI: puts("something started moving."); break; case PIR_STATUS_LO: puts("the movement has ceased."); break; default: puts("stray message."); break; } } puts("PIR handler: this should not have happened!"); return NULL; }
PUBLIC int sys_sendrec(PROCESS *p, int function, int src_dest, MESSAGE *m) { assert(k_reenter == 0); assert((src_dest >= 0 && src_dest < NR_TASKS + NR_PROCS) || src_dest == ANY || src_dest == INTERRUPT); int ret = 0; int caller = proc2pid(p); MESSAGE *mla = (MESSAGE *)va2la(caller, m); mla->source = caller; assert(mla->source != src_dest); if (function == SEND) { ret = msg_send(p, src_dest, m); } else if (function == RECEIVE) { ret = msg_receive(p, src_dest, m); } else { panic("{sys_sendrec} invalid function: " "%d (SEND:%d, RECEIVE:%d).", function, SEND, RECEIVE); } return ret; }
void recv_ieee802154_frame(void) { msg_t m; radio_packet_t *p; uint8_t hdrlen, length; ieee802154_frame_t frame; msg_init_queue(msg_q, RADIO_RCV_BUF_SIZE); while (1) { msg_receive(&m); if (m.type == PKT_PENDING) { p = (radio_packet_t *) m.content.ptr; hdrlen = read_802154_frame(p->data, &frame, p->length); length = p->length - hdrlen; /* deliver packet to network(6lowpan)-layer */ lowpan_read(frame.payload, length, (ieee_802154_long_t *)&frame.src_addr, (ieee_802154_long_t *)&frame.dest_addr); p->processing--; } else if (m.type == ENOBUFFER) { puts("Transceiver buffer full"); } else { puts("Unknown packet received"); } } }
ipv6_addr_t init_threeway_handshake(void) { border_syn_packet_t *syn; msg_t m; m.content.ptr = NULL; msg_send(&m, border_get_serial_reader(), 1); msg_receive(&m); syn = (border_syn_packet_t *)m.content.ptr; border_conf_header_t *synack = (border_conf_header_t *)get_serial_out_buffer(0); ipv6_addr_t addr; memcpy(&addr, &(syn->addr), sizeof(ipv6_addr_t)); slwin_stat.next_exp = syn->next_seq_num; slwin_stat.last_frame = syn->next_exp - 1; slwin_stat.last_ack = slwin_stat.last_frame; synack->empty = 0; synack->type = BORDER_PACKET_CONF_TYPE; synack->conftype = BORDER_CONF_SYNACK; sending_slot_pid = thread_create(sending_slot_stack, SENDING_SLOT_STACK_SIZE, PRIORITY_MAIN - 1, CREATE_SLEEPING, sending_slot, "sending slot"); flowcontrol_send_over_uart((border_packet_t *)synack, sizeof(border_conf_header_t)); synack_seqnum = synack->seq_num; return addr; }
static void *printer(void *arg) { (void)arg; msg_t msg; msg_t msg_queue[8]; msg_init_queue(msg_queue, 8); while (1) { msg_receive(&msg); int dev = (int)msg.content.value; char c; printf("UART_DEV(%i) RX: ", dev); do { c = (int)ringbuffer_get_one(&(ctx[dev].rx_buf)); if (c == 0) { puts(""); } else if (c >= ' ' && c <= '~') { printf("%c", c); } else { printf("0x%02x", (unsigned char)c); } } while (c != 0); } /* this should never be reached */ return NULL; }
static void *_event_loop(void *arg) { msg_t reply, msg_queue[GNRC_NETTEST_MSG_QUEUE_SIZE]; (void)arg; msg_init_queue(msg_queue, GNRC_NETTEST_MSG_QUEUE_SIZE); reply.type = GNRC_NETAPI_MSG_TYPE_ACK; while (1) { msg_t msg; gnrc_netapi_opt_t *opt; msg_receive(&msg); switch (msg.type) { case GNRC_NETAPI_MSG_TYPE_GET: opt = (gnrc_netapi_opt_t *)msg.content.ptr; reply.content.value = _get_set_opt(_opt_cbs[opt->opt].get, opt->context, opt->data, opt->data_len); break; case GNRC_NETAPI_MSG_TYPE_SET: opt = (gnrc_netapi_opt_t *)msg.content.ptr; reply.content.value = _get_set_opt(_opt_cbs[opt->opt].set, opt->context, opt->data, opt->data_len); break; } msg_reply(&msg, &reply); } return NULL; }
uint8_t semtech_loramac_send(semtech_loramac_t *mac, uint8_t *data, uint8_t len) { mac->link_chk.available = false; if (!_is_mac_joined(mac)) { DEBUG("[semtech-loramac] network is not joined\n"); return SEMTECH_LORAMAC_NOT_JOINED; } /* Correctly set the caller pid */ mac->caller_pid = thread_getpid(); loramac_send_params_t params; params.payload = data; params.len = len; _semtech_loramac_call(_send, ¶ms); /* Wait for TX status information from the MAC */ msg_t msg; msg_receive(&msg); if (msg.type != MSG_TYPE_LORAMAC_TX_STATUS) { return SEMTECH_LORAMAC_TX_ERROR; } return (uint8_t)msg.content.value; }
void udp_packet_handler(void) { msg_t m_recv_ip, m_send_ip, m_recv_udp, m_send_udp; ipv6_hdr_t *ipv6_header; udp_hdr_t *udp_header; uint8_t *payload; socket_internal_t *udp_socket = NULL; uint16_t chksum; while (1) { msg_receive(&m_recv_ip); ipv6_header = ((ipv6_hdr_t *)m_recv_ip.content.ptr); udp_header = ((udp_hdr_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN)); payload = (uint8_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN + UDP_HDR_LEN); chksum = udp_csum(ipv6_header, udp_header); if (chksum == 0xffff) { udp_socket = get_udp_socket(ipv6_header, udp_header); if (udp_socket != NULL) { m_send_udp.content.ptr = (char *)ipv6_header; msg_send_receive(&m_send_udp, &m_recv_udp, udp_socket->recv_pid); } else { printf("Dropped UDP Message because no thread ID was found for delivery!\n"); } } else { printf("Wrong checksum (%x)!\n", chksum); } msg_reply(&m_recv_ip, &m_send_ip); } }
static void riot_ccnl_appserver_ioloop(void) { DEBUGMSG(1, "starting appserver main event and IO loop\n"); if (msg_init_queue(msg_buffer_appserver, APPSERVER_MSG_BUFFER_SIZE) != 0) { DEBUGMSG(1, "msg init queue failed...abording\n"); } msg_t in; riot_ccnl_msg_t *m; while (1) { DEBUGMSG(1, "appserver: waiting for incomming msg\n"); msg_receive(&in); switch (in.type) { case (CCNL_RIOT_MSG): m = (riot_ccnl_msg_t *) in.content.ptr; DEBUGMSG(1, "new msg: size=%" PRIu16 " sender_pid=%" PRIu16 "\n", m->size, in.sender_pid); appserver_handle_interest(m->payload, m->size, in.sender_pid); ccnl_free(m); break; default: DEBUGMSG(1, "received unknown msg type: '%" PRIu16 "' dropping it\n", in.type); break; } } }
void *radio(void *arg) { (void) arg; msg_t m; #if MODULE_AT86RF231 || MODULE_CC2420 || MODULE_MC1322X ieee802154_packet_t *p; #else radio_packet_t *p; radio_packet_length_t i; #endif msg_init_queue(msg_q, RCV_BUFFER_SIZE); while (1) { msg_receive(&m); if (m.type == PKT_PENDING) { #if MODULE_AT86RF231 || MODULE_CC2420 || MODULE_MC1322X p = (ieee802154_packet_t*) m.content.ptr; printf("Got radio packet:\n"); printf("\tLength:\t%u\n", p->length); printf("\tSrc:\t%u\n", p->frame.src_addr[0]); printf("\tDst:\t%u\n", p->frame.dest_addr[0]); printf("\tLQI:\t%u\n", p->lqi); printf("\tRSSI:\t%u\n", p->rssi); printf("Payload Length:%u\n", p->frame.payload_len); printf("Payload:%s\n", p->frame.payload); p->processing--; #else p = (radio_packet_t *) m.content.ptr; printf("Got radio packet:\n"); printf("\tLength:\t%u\n", p->length); printf("\tSrc:\t%u\n", p->src); printf("\tDst:\t%u\n", p->dst); printf("\tLQI:\t%u\n", p->lqi); printf("\tRSSI:\t%u\n", p->rssi); for (i = 0; i < p->length; i++) { printf("%02X ", p->data[i]); } p->processing--; puts("\n"); #endif } else if (m.type == ENOBUFFER) { puts("Transceiver buffer full"); } else { puts("Unknown packet received"); } } }
/* start sending beacons */ void beaconing_start(void) { uint8_t remaining_beacons = DOW_BEACONING_COUNT; bool end_beaconing = false; /* register for RX */ gnrc_netreg_entry_t _ne; _ne.target.pid = sched_active_pid; _ne.demux_ctx = GNRC_NETREG_DEMUX_CTX_ALL; gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &_ne); /* schedule beacon */ msg_t beacon_msg; beacon_msg.type = DOW_MSG_BEACON; xtimer_t beacon_timer; beacon_timer.target = beacon_timer.long_target = 0; /* let's delay the first beacon by DOW_BEACONING_WAIT */ uint32_t tmp = DOW_BEACONING_PERIOD + DOW_BEACONING_WAIT; xtimer_set_msg(&beacon_timer, tmp, &beacon_msg, sched_active_pid); tmp -= DOW_BEACONING_WAIT; uint32_t start = xtimer_now().ticks32; while (1) { msg_t m; msg_receive(&m); switch (m.type) { case DOW_MSG_BEACON: LOG_DEBUG("beaconing: ready to send next beacon\n"); beaconing_send(); tmp = DOW_BEACONING_PERIOD; /* check if we need to do further beaconing */ if (--remaining_beacons > 0) { xtimer_set_msg(&beacon_timer, tmp, &beacon_msg, sched_active_pid); } else { beacon_msg.type = DOW_MSG_BEACON_END; tmp = 2 * DOW_BEACONING_WAIT - (xtimer_now().ticks32 - start); LOG_INFO("beaconing: end beaconing period in %" PRIu32 \ " seconds\n", (tmp / US_PER_SEC)); xtimer_set_msg(&beacon_timer, tmp, &beacon_msg, sched_active_pid); } break; case DOW_MSG_BEACON_END: LOG_INFO("beaconing: end beaconing\n"); end_beaconing = true; break; case GNRC_NETAPI_MSG_TYPE_RCV: LOG_DEBUG("beaconing: received packet, assume that it is a beacon\n"); _handle_beacon((gnrc_pktsnip_t *)m.content.ptr); break; default: LOG_WARNING("beaconing: didn't expect message type %X\n", m.type); break; } if (end_beaconing) { break; } } gnrc_netreg_unregister(GNRC_NETTYPE_UNDEF, &_ne); }
void second_thread(void) { printf("second_thread starting.\n"); msg_t m; while(1) { msg_receive(&m); printf("2nd: got msg from %i\n", m.sender_pid); m.content.value++; msg_reply(&m, &m); } }
static void *_event_loop(void *args) { msg_t msg, reply; (void)args; msg_init_queue(_msg_q, GNRC_RPL_MSG_QUEUE_SIZE); /* preinitialize ACK */ reply.type = GNRC_NETAPI_MSG_TYPE_ACK; trickle_t *trickle; /* start event loop */ while (1) { DEBUG("RPL: waiting for incoming message.\n"); msg_receive(&msg); switch (msg.type) { case GNRC_RPL_MSG_TYPE_LIFETIME_UPDATE: DEBUG("RPL: GNRC_RPL_MSG_TYPE_LIFETIME_UPDATE received\n"); _update_lifetime(); break; case GNRC_RPL_MSG_TYPE_TRICKLE_INTERVAL: DEBUG("RPL: GNRC_RPL_MSG_TYPE_TRICKLE_INTERVAL received\n"); trickle = msg.content.ptr; if (trickle && (trickle->callback.func != NULL)) { trickle_interval(trickle); } break; case GNRC_RPL_MSG_TYPE_TRICKLE_CALLBACK: DEBUG("RPL: GNRC_RPL_MSG_TYPE_TRICKLE_CALLBACK received\n"); trickle = msg.content.ptr; if (trickle && (trickle->callback.func != NULL)) { trickle_callback(trickle); } break; case GNRC_NETAPI_MSG_TYPE_RCV: DEBUG("RPL: GNRC_NETAPI_MSG_TYPE_RCV received\n"); _receive(msg.content.ptr); break; case GNRC_NETAPI_MSG_TYPE_SND: break; case GNRC_NETAPI_MSG_TYPE_GET: case GNRC_NETAPI_MSG_TYPE_SET: DEBUG("RPL: reply to unsupported get/set\n"); reply.content.value = -ENOTSUP; msg_reply(&msg, &reply); break; default: break; } } return NULL; }
int32_t destiny_socket_recv(int s, void *buf, uint32_t len, int flags) { /* Variables */ uint8_t read_bytes; msg_t m_recv, m_send; socket_internal_t *current_int_tcp_socket; /* Check if socket exists */ if (!is_tcp_socket(s)) { printf("INFO: NO TCP SOCKET!\n"); return -1; } current_int_tcp_socket = get_socket(s); /* Setting Thread PID */ current_int_tcp_socket->recv_pid = thread_getpid(); if (current_int_tcp_socket->tcp_input_buffer_end > 0) { return read_from_socket(current_int_tcp_socket, buf, len); } msg_receive(&m_recv); if ((exists_socket(s)) && (current_int_tcp_socket->tcp_input_buffer_end > 0)) { read_bytes = read_from_socket(current_int_tcp_socket, buf, len); net_msg_reply(&m_recv, &m_send, UNDEFINED); return read_bytes; } /* Received FIN */ if (m_recv.type == CLOSE_CONN) { /* Sent FIN_ACK, wait for ACK */ msg_receive(&m_recv); /* Received ACK, return with closed socket!*/ return -1; } /* Received Last ACK (connection closed) or no data to read yet */ return -1; }
void second_thread(void) { //printf("2nd thread started, pid: %i\n", thread_getpid()); msg_t m; while (1) { msg_receive(&m); //printf("2nd: Got msg from %i\n", m.sender_pid); m.content.value++; msg_reply(&m, &m); } }
int main(void) { memset(apps, '\0', sizeof(apps)); apps[0] = clock_app_init(); apps[1] = alarm_app_init(); gpioint_set(2, BUTTON_STAR_PIN, (GPIOINT_RISING_EDGE | GPIOINT_DEBOUNCE), button_star); button_thread = thread_getpid(); int active_app = 0; msg_t m; //buzzer_beep(15, 5000); printf("ukleos\n"); m.type = MSG_ACTIVATE; msg_send(&m, apps[active_app], true); while(1) { msg_receive(&m); switch (m.type) { case MSG_BUTTON_STAR: { m.type = MSG_DEACTIVATE; msg_send(&m, apps[active_app], true); active_app++; if (active_app == (NUM_APPS)) active_app = 0; m.type = MSG_ACTIVATE; msg_send(&m, apps[active_app], true); // buzzer_beep(15, 5000); break; } case MSG_BUTTON_HASH: { m.type = MSG_BUTTON_HASH; msg_send(&m, apps[active_app], true); break; } default: { printf("msg\n"); } } } }