OpenThread port

Makefile.dep

@@ -568,3 +568,29 @@ ifneq (,$(filter random,$(USEMODULE)))
         USEMODULE += tinymt32
     endif
 endif
+
+ifneq (,$(filter openthread,$(USEMODULE)))
+  USEMODULE += openthread_core
+  USEMODULE += openthread_contrib
+  USEPKG += openthread
+  USEMODULE+=xtimer
+
+  FEATURES_REQUIRED += cpp
+  FEATURES_REQUIRED += periph_spi periph_gpio
+endif
+
+ifneq (,$(filter openthread_contrib,$(USEMODULE)))
+  USEMODULE+=openthread_contrib_netdev2
+  USEMODULE+=openthread_contrib_conn
+endif
+
+ifneq (,$(filter openthread_core,$(USEMODULE)))
+  USEMODULE+=openthread_core_common
+  USEMODULE+=openthread_core_coap
+  USEMODULE+=openthread_core_thread
+  USEMODULE+=openthread_core_net
+  USEMODULE+=openthread_core_crypto
+  USEMODULE+=openthread_core_mac
+  USEMODULE+=mbedtls
+  USEMODULE+=mbedtls_lib
+endif

Makefile.pseudomodules

@@ -47,6 +47,7 @@ PSEUDOMODULES += saul_adc
 PSEUDOMODULES += saul_default
 PSEUDOMODULES += saul_gpio
 PSEUDOMODULES += schedstatistics
+PSEUDOMODULES += openthread
 
 # include variants of the AT86RF2xx drivers as pseudo modules
 PSEUDOMODULES += at86rf23%

drivers/at86rf2xx/at86rf2xx_getset.c

@@ -324,6 +324,13 @@ void at86rf2xx_set_cca_threshold(at86rf2xx_t *dev, int8_t value)
     at86rf2xx_reg_write(dev, AT86RF2XX_REG__CCA_THRES, value);
 }
 
+#ifdef MODULE_OPENTHREAD
+bool at86rf2xx_receiver_listening(at86rf2xx_t *dev)
+{
+    return (at86rf2xx_reg_read(dev, AT86RF2XX_REG__RX_SYN) & 0x80) ? false : true;
+}
+#endif
+
 void at86rf2xx_set_option(at86rf2xx_t *dev, uint16_t option, bool state)
 {
     uint8_t tmp;
@@ -366,6 +373,14 @@ void at86rf2xx_set_option(at86rf2xx_t *dev, uint16_t option, bool state)
                 tmp |= AT86RF2XX_IRQ_STATUS_MASK__RX_START;
                 at86rf2xx_reg_write(dev, AT86RF2XX_REG__IRQ_MASK, tmp);
                 break;
+#ifdef MODULE_OPENTHREAD
+            case AT86RF2XX_OPT_RX_LISTENING:
+                DEBUG("[at86rf2xx] opt: enabling listening of pkt\n");
+                tmp = at86rf2xx_reg_read(dev, AT86RF2XX_REG__RX_SYN);
+                tmp &= ~(0x80);
+                at86rf2xx_reg_write(dev, AT86RF2XX_REG__RX_SYN, tmp);
+                break;
+#endif
             default:
                 /* do nothing */
                 break;
@@ -407,6 +422,14 @@ void at86rf2xx_set_option(at86rf2xx_t *dev, uint16_t option, bool state)
                 tmp &= ~AT86RF2XX_IRQ_STATUS_MASK__RX_START;
                 at86rf2xx_reg_write(dev, AT86RF2XX_REG__IRQ_MASK, tmp);
                 break;
+#ifdef MODULE_OPENTHREAD
+            case AT86RF2XX_OPT_RX_LISTENING:
+                DEBUG("[at86rf2xx] opt: disabling listening of pkt\n");
+                tmp = at86rf2xx_reg_read(dev, AT86RF2XX_REG__RX_SYN);
+                tmp |= 0x80;
+                at86rf2xx_reg_write(dev, AT86RF2XX_REG__RX_SYN, tmp);
+                break;
+#endif
             default:
                 /* do nothing */
                 break;

drivers/at86rf2xx/at86rf2xx_netdev.c

@@ -210,6 +210,12 @@ netopt_state_t _get_state(at86rf2xx_t *dev)
         case AT86RF2XX_STATE_SLEEP:
             return NETOPT_STATE_SLEEP;
         case AT86RF2XX_STATE_BUSY_RX_AACK:
+#ifdef MODULE_OPENTHREAD
+            /* Required for OpenThread abstraction */
+            if (at86rf2xx_receiver_listening(dev)) {
+                return NETOPT_STATE_IDLE;
+            }
+#endif
             return NETOPT_STATE_RX;
         case AT86RF2XX_STATE_BUSY_TX_ARET:
         case AT86RF2XX_STATE_TX_ARET_ON:
@@ -367,6 +373,12 @@ static int _get(netdev2_t *netdev, netopt_t opt, void *val, size_t max_len)
             }
             break;
 
+#ifdef MODULE_OPENTHREAD
+        case NETOPT_RX_LISTENING:
+            *((bool *)val) = at86rf2xx_receiver_listening(dev) ? true : false;
+            res = sizeof(bool);
+            break;
+#endif
         default:
             res = -ENOTSUP;
     }
@@ -566,6 +578,13 @@ static int _set(netdev2_t *netdev, netopt_t opt, void *val, size_t len)
             }
             break;
 
+#ifdef MODULE_OPENTHREAD
+        case NETOPT_RX_LISTENING:
+            at86rf2xx_set_option(dev, AT86RF2XX_OPT_RX_LISTENING,
+                                 ((bool *)val)[0]);
+            res = sizeof(netopt_enable_t);
+            break;
+#endif
         default:
             break;
     }
@@ -614,9 +633,17 @@ static void _isr(netdev2_t *netdev)
         if (state == AT86RF2XX_STATE_RX_AACK_ON ||
             state == AT86RF2XX_STATE_BUSY_RX_AACK) {
             DEBUG("[at86rf2xx] EVT - RX_END\n");
+
+#ifdef MODULE_OPENTHREAD
+            if (!(dev->netdev.flags & AT86RF2XX_OPT_TELL_RX_END) || !at86rf2xx_receiver_listening(dev)) {
+                return;
+            }
+#else
             if (!(dev->netdev.flags & AT86RF2XX_OPT_TELL_RX_END)) {
                 return;
             }
+#endif
+
             netdev->event_callback(netdev, NETDEV2_EVENT_RX_COMPLETE);
         }
         else if (state == AT86RF2XX_STATE_TX_ARET_ON ||
@@ -633,11 +660,22 @@ static void _isr(netdev2_t *netdev)
 
             if (netdev->event_callback && (dev->netdev.flags & AT86RF2XX_OPT_TELL_TX_END)) {
                 switch (trac_status) {
+#ifdef MODULE_OPENTHREAD
+                    case AT86RF2XX_TRX_STATE__TRAC_SUCCESS:
+                        netdev->event_callback(netdev, NETDEV2_EVENT_TX_COMPLETE);
+                        DEBUG("[at86rf2xx] TX SUCCESS\n");
+                        break;
+                    case AT86RF2XX_TRX_STATE__TRAC_SUCCESS_DATA_PENDING:
+                        netdev->event_callback(netdev, NETDEV2_EVENT_TX_COMPLETE_DATA_PENDING);
+                        DEBUG("[at86rf2xx] TX SUCCESS DATA PENDING\n");
+                        break;
+#else
                     case AT86RF2XX_TRX_STATE__TRAC_SUCCESS:
                     case AT86RF2XX_TRX_STATE__TRAC_SUCCESS_DATA_PENDING:
                         netdev->event_callback(netdev, NETDEV2_EVENT_TX_COMPLETE);
                         DEBUG("[at86rf2xx] TX SUCCESS\n");
                         break;
+#endif
                     case AT86RF2XX_TRX_STATE__TRAC_NO_ACK:
                         netdev->event_callback(netdev, NETDEV2_EVENT_TX_NOACK);
                         DEBUG("[at86rf2xx] TX NO_ACK\n");

drivers/include/at86rf2xx.h

@@ -136,6 +136,9 @@ extern "C" {
                                                      *   start */
 #define AT86RF2XX_OPT_TELL_RX_END    (0x4000)       /**< notify MAC layer on RX
                                                      *   finished */
+#ifdef MODULE_OPENTHREAD
+#define AT86RF2XX_OPT_RX_LISTENING    (0x8000)      /**< detection of reception active */
+#endif
 /** @} */
 
 /**
@@ -260,6 +263,15 @@ void at86rf2xx_set_chan(at86rf2xx_t *dev, uint8_t chan);
  */
 uint8_t at86rf2xx_get_page(at86rf2xx_t *dev);
 
+
+#ifdef MODULE_OPENTHREAD
+/**
+ * @brief   Enable/disable AT86RF2XX receiver
+ *
+ * @param[in] dev           device to change receiver status
+ */
+bool at86rf2xx_receiver_listening(at86rf2xx_t *dev);
+#endif
 /**
  * @brief   Set the channel page of the given device
  *

drivers/include/net/netdev2.h

@@ -74,6 +74,9 @@ typedef enum {
     NETDEV2_EVENT_RX_COMPLETE,      /**< finished receiving a packet */
     NETDEV2_EVENT_TX_STARTED,       /**< started to transfer a packet */
     NETDEV2_EVENT_TX_COMPLETE,      /**< finished transferring packet */
+#ifdef MODULE_OPENTHREAD
+    NETDEV2_EVENT_TX_COMPLETE_DATA_PENDING, /**< finished transferring packet and has data pending flag **/
+#endif
     NETDEV2_EVENT_TX_NOACK,         /**< ACK requested but not received */
     NETDEV2_EVENT_TX_MEDIUM_BUSY,   /**< couldn't transfer packet */
     NETDEV2_EVENT_LINK_UP,          /**< link established */

examples/openthread_posix_example/Makefile

@@ -0,0 +1,47 @@
+APPLICATION = openthread_posix_example
+
+# If no BOARD is found in the environment, use this default:
+BOARD ?= samr21-xpro
+
+# This has to be the absolute path to the RIOT base directory:
+RIOTBASE ?= $(CURDIR)/../..
+
+# Comment this out to disable code in RIOT that does safety checking
+# which is not needed in a production environment but helps in the
+# development process:
+CFLAGS += -DDEVELHELP -Wall
+
+# Change this to 0 show compiler invocation lines by default:
+QUIET ?= 1
+
+USEMODULE+=openthread
+
+ifneq (,$(filter samr21-xpro,$(BOARD)))
+  DRIVER := at86rf233
+endif
+ifneq (,$(filter iotlab-m3 fox,$(BOARD)))
+  DRIVER := at86rf231
+endif
+
+ifneq (,$(filter at86rf2%,$(DRIVER)))
+  FEATURES_REQUIRED = periph_spi periph_gpio
+endif
+
+USEMODULE += $(DRIVER)
+
+USEMODULE+=random
+
+USEMODULE += shell
+USEMODULE += shell_commands
+USEMODULE += ps
+USEMODULE += ipv6_addr
+
+#required for C++ compiling
+CXXEXFLAGS += -fno-rtti
+USEMODULE += cpp11-compat
+
+# Needed by posix_sockets example
+USEMODULE += posix_sockets
+USEMODULE += conn_udp
+
+include $(RIOTBASE)/Makefile.include

examples/openthread_posix_example/README.md

@@ -0,0 +1,57 @@
+# openthread_posix_example
+
+This example shows the `posix_sockets` example running with OpenThread as network stack.  The usage is exactly the same
+as the `posix_sockets` example, but includes 2 extra commands for obtaining node ip address and Thread status.
+
+
+## About Thread stack
+You can find more information about Thread networks in
+http://threadgroup.org/Portals/0/documents/whitepapers/Thread%20Stack%20Fundamentals_v2_public.pdf
+
+## The shell commands
+
+* `ot_state` - shows the Thread state of a node (leader, router, child)
+* `ot_ipaddr` - shows the IP addresses associated to a node (link local, mesh, etc).
+
+## Example setup
+An example usage of this application could be the following setup (tested in IoT-LAB):
+
+1. Flash nodes with `make BOARD=<target> clean all flash`
+2. Wait some seconds.
+3. Write command `ot_state` in each node. If everything went OK, only one node should be `leader`
+   and the reset should be either `router` or `child`
+4. Read the ip address of a single node with `ot_ipaddr`:
+   `ot_ipaddr`
+   `fdde:ad00:beef::ff:fe00:8000`
+   `fe80::ff:fe00:8000`
+   `fdde:ad00:beef:0:946a:c722:a5d9:8481`
+   `fe80::3984:f4eb:d182:5dae`
+   The third address (fdde:ad00:beef:0:946a:c722:a5d9:8481) is the mesh address.
+5. Start posix udp server in port 80:
+   `udp server start fdde:ad00:beef:0:946a:c722:a5d9:8481 80`
+6. Send UDP messages from another node:
+   `udp send fdde:ad00:beef:0:946a:c722:a5d9:8481 80 RIOT`
+   `Success: send 4 byte to fdde:ad00:beef:0:946a:c722:a5d9:8481:80`
+7. You should get a `Received data: RIOT` message in the receiving node.
+   `1470061384.130128;m3-6;> Received data: RIOT`
+8. Enjoy! You can try to setup a big network to test multi-hop features of the Thread network.
+9. Also, you can try disabling some nodes. The network should automatically heal itself (add a new leader, replace
+   children by routers, etc).
+
+
+## Port status
+* Only `conn_udp` supported for the moment (no `conn_ip` yet)
+* `ifconfig` not supported yet (use `ot_ipaddr` for ip addresses)
+* OpenThread and this port are still under development. If you find any bug please report it via Github issues.
+* Only tested with at86rf2xx radios.
+
+## Known issues
+
+* When the network traffic is really high, sometimes some nodes crash silently. 
+* In some cases there are isolated leaders that are not able to recover to the main partition. These won't affect the
+  rest of the network, but this node becomes unreachable.
+
+## Future work
+
+* Add support for Thread Border Router via NEST's Wpantund (https://github.com/openthread/wpantund)
+* Adapt to new conn API.

examples/openthread_posix_example/main.c

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 Martine Lenders <mlenders@inf.fu-berlin.de>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @ingroup     examples
+ * @{
+ *
+ * @file
+ * @brief       Example application for demonstrating the RIOT's POSIX sockets
+ *
+ * @author      Martine Lenders <mlenders@inf.fu-berlin.de>
+ *
+ * @}
+ */
+
+#include <stdio.h>
+
+#include "msg.h"
+#include "shell.h"
+
+#define MAIN_MSG_QUEUE_SIZE (4)
+static msg_t main_msg_queue[MAIN_MSG_QUEUE_SIZE];
+
+extern int udp_cmd(int argc, char **argv);
+
+static const shell_command_t shell_commands[] = {
+    { "udp", "send data over UDP and listen on UDP ports", udp_cmd },
+    { NULL, NULL, NULL }
+};
+
+int main(void)
+{
+    /* a sendto() call performs an implicit bind(), hence, a message queue is
+     * required for the thread executing the shell */
+    msg_init_queue(main_msg_queue, MAIN_MSG_QUEUE_SIZE);
+    puts("RIOT socket example application");
+    /* start shell */
+    puts("All up, running the shell now");
+    char line_buf[SHELL_DEFAULT_BUFSIZE];
+    shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
+
+    /* should be never reached */
+    return 0;
+}