Beispiel #1
0
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;
}
Beispiel #2
0
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");
        }
    }
}
Beispiel #3
0
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;
}
Beispiel #4
0
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);
    }
}
Beispiel #5
0
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;
    }
}
Beispiel #6
0
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;
}
Beispiel #7
0
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;
}
Beispiel #8
0
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;
}
Beispiel #9
0
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;
}
Beispiel #10
0
/**************************************************************************************************
 * 					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;
}
Beispiel #11
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);
    }
}
Beispiel #12
0
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);
}
Beispiel #14
0
/**
 * 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;
}
Beispiel #15
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;
}
Beispiel #16
0
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;
}
Beispiel #17
0
Datei: mac.c Projekt: fjrk/RIOT
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");
        }
    }
}
Beispiel #18
0
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;
}
Beispiel #19
0
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;
}
Beispiel #20
0
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;
}
Beispiel #21
0
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, &params);

    /* 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;
}
Beispiel #22
0
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);
    }
}
Beispiel #23
0
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;
        }
    }
}
Beispiel #24
0
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);
}
Beispiel #26
0
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);
    }
}
Beispiel #27
0
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;
}
Beispiel #28
0
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;
}
Beispiel #29
0
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);
    }
}
Beispiel #30
0
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");
                }
        }
    }
}