net/unicoap: Unified and Modular CoAP stack: Messaging and Minimal Server (pt 2)

examples/networking/coap/unicoap_message/main.c

@@ -26,10 +26,10 @@
 
 static void _example_handle_message(const unicoap_message_t* message)
 {
-    /* Use unicoap_message_is_request, unicoap_message_is_response, unicoap_message_is_signal
-     * to determine what class of message you are dealing with.
+    /* Use unicoap_message_code_is_request, unicoap_message_code_is_response,
+     * unicoap_message_code_is_signal to determine what class of message you are dealing with.
      * In this case, we expect a request. */
-    assert(unicoap_message_is_request(message->code));
+    assert(unicoap_message_code_is_request(message->code));
 
     /* The unicoap message type supports different typed views of the CoAP message code:
      * message->method, message->status, and message->signal.

examples/networking/coap/unicoap_server/Makefile

@@ -0,0 +1,63 @@
+# Default Makefile, for simple unicoap server sample application
+
+# name of your application
+APPLICATION = unicoap_server
+
+# If no BOARD is found in the environment, use this default:
+BOARD ?= native
+
+# This has to be the absolute path to the RIOT base directory:
+RIOTBASE ?= $(CURDIR)/../../../..
+
+# Include packages that pull up and auto-init the link layer.
+# NOTE: 6LoWPAN will be included if IEEE802.15.4 devices are present
+USEMODULE += netdev_default
+
+# use GNRC by default
+LWIP_IPV4 ?= 0
+LWIP_IPV6 ?= 0
+
+ifeq (,$(filter 1, $(LWIP_IPV4) $(LWIP_IPV6)))
+  USEMODULE += auto_init_gnrc_netif
+  # Specify the mandatory networking modules
+  USEMODULE += gnrc_ipv6_default
+  # Additional networking modules that can be dropped if not needed
+  USEMODULE += gnrc_icmpv6_echo
+else
+  ifeq (1,$(LWIP_IPV4))
+    USEMODULE += ipv4_addr
+
+    USEMODULE += lwip_arp
+    USEMODULE += lwip_ipv4
+    USEMODULE += lwip_dhcp_auto
+    CFLAGS += -DETHARP_SUPPORT_STATIC_ENTRIES=1
+  endif
+
+  ifeq (1,$(LWIP_IPV6))
+    USEMODULE += ipv6_addr
+
+    USEMODULE += lwip_ipv6
+    USEMODULE += lwip_ipv6_autoconfig
+  endif
+endif
+
+USEMODULE += unicoap
+USEMODULE += unicoap_resources_xfa
+
+# This module is needed for CoAP over UDP
+USEMODULE += unicoap_driver_udp
+
+# This module is needed for CoAP over DTLS
+USEMODULE += unicoap_driver_dtls
+
+# It is okay to import only either of the CoAP over UDP and CoAP over DTLS drivers.
+
+# 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:
+DEVELHELP ?= 1
+
+# Change this to 0 show compiler invocation lines by default:
+QUIET ?= 1
+
+include $(RIOTBASE)/Makefile.include

examples/networking/coap/unicoap_server/Makefile.ci

@@ -0,0 +1,58 @@
+BOARD_INSUFFICIENT_MEMORY := \
+    airfy-beacon \
+    arduino-duemilanove \
+    arduino-leonardo \
+    arduino-mega2560 \
+    arduino-nano \
+    arduino-uno \
+    atmega1284p \
+    atmega328p \
+    atmega328p-xplained-mini \
+    atmega8 \
+    atxmega-a3bu-xplained \
+    blackpill-stm32f103c8 \
+    bluepill-stm32f030c8 \
+    bluepill-stm32f103c8 \
+    calliope-mini \
+    derfmega128 \
+    hifive1 \
+    hifive1b \
+    i-nucleo-lrwan1 \
+    im880b \
+    mega-xplained \
+    microbit \
+    microduino-corerf \
+    msb-430 \
+    msb-430h \
+    nrf51dongle \
+    nucleo-c031c6 \
+    nucleo-f030r8 \
+    nucleo-f031k6 \
+    nucleo-f042k6 \
+    nucleo-f070rb \
+    nucleo-f072rb \
+    nucleo-f302r8 \
+    nucleo-f303k8 \
+    nucleo-f334r8 \
+    nucleo-l011k4 \
+    nucleo-l031k6 \
+    nucleo-l053r8 \
+    olimex-msp430-h1611 \
+    olimex-msp430-h2618 \
+    samd10-xmini \
+    saml10-xpro \
+    saml11-xpro \
+    slstk3400a \
+    stk3200 \
+    stm32f030f4-demo \
+    stm32f0discovery \
+    stm32f7508-dk \
+    stm32g0316-disco \
+    stm32l0538-disco \
+    stm32mp157c-dk2 \
+    telosb \
+    weact-g030f6 \
+    yunjia-nrf51822 \
+    z1 \
+    zigduino \
+    #

examples/networking/coap/unicoap_server/README.md

@@ -0,0 +1,31 @@
+# Sample Server Application With `unicoap`
+
+This a sample application demonstrating how you can define CoAP resources using `unicoap`,
+the unified and modular CoAP suite in RIOT. Visit the
+[`unicoap` server tutorial on doc.riot-os.org](http://doc.riot-os.org/group__net__unicoap__server__tutorial.html)
+for a detailed code-level instructions.
+
+## Running the Example on RIOT's Native Board
+
+Create a tap interface (to which RIOT will connect):
+
+```
+$ sudo ip tuntap add tap0 mode tap user ${USER}
+$ sudo ip link set tap0 up
+```
+
+To try this example on your host, run:
+```sh
+BOARD=native make flash term
+```
+This will compile and run the application.
+The application will print a network-layer address.
+
+In a second terminal session, you can run
+
+```sh
+python3 client.py -m GET -u "coap://[fe80::c0:ff:ee%tap0]/greeting?name=RIOTer"
+```
+
+to send a CoAP request through the tap interface to the CoAP server where `fe80::c0:ff:ee`
+is the link-layer address printed by the application.

examples/networking/coap/unicoap_server/app.config

@@ -0,0 +1,3 @@
+CONFIG_UNICOAP_DEBUG_LOGGING=n
+CONFIG_UNICOAP_ASSIST=n
+CONFIG_UNICOAP_CREATE_THREAD=y

examples/networking/coap/unicoap_server/client.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+
+import logging
+import asyncio
+from argparse import ArgumentParser
+
+from aiocoap import CON, NON, GET, PUT, POST, DELETE, PATCH, iPATCH, FETCH, Context, Message
+import aiocoap.resource as resource
+from aiocoap.transports.tinydtls import DTLSClientConnection
+
+logging.basicConfig(level=logging.DEBUG)
+
+print(
+    "usage: client.py" +
+    " -m <GET|PUT|POST|DELETE|PATCH|iPATCH|FETCH>" +
+    " -u <URI>" +
+    " [--type <NON|CON>] [--observe] [-p <PAYLOAD>]")
+
+
+def _get(_list, i, default):
+    return _list[i] if len(_list) > i else default
+
+
+def message_type(arg):
+    return {"CON": CON, "NON": NON}[arg]
+
+
+def method(arg):
+    return {
+        "GET": GET,
+        "PUT": PUT,
+        "POST": POST,
+        "DELETE": DELETE,
+        "PATCH": PATCH,
+        "iPATCH": iPATCH,
+        "FETCH": FETCH
+    }[arg]
+
+
+async def main():
+    parser = ArgumentParser()
+
+    parser.add_argument(
+        "-m", "--method",
+        help='GET|PUT|POST|DELETE|PATCH|iPATCH|FETCH',
+        required=True)
+
+    parser.add_argument(
+        "-u", "--uri",
+        help='URI',
+        required=True)
+
+    parser.add_argument(
+        "-mt", "--type",
+        help='NON|CON',
+        default="NON")
+
+    parser.add_argument(
+        "--observe",
+        action="store_true",
+        help='Register for notifications',
+        default=False)
+
+    parser.add_argument(
+        "--observe-cancel",
+        action="store_true",
+        help='Cancel notifications',
+        default=False)
+
+    parser.add_argument(
+        "-p", "--payload",
+        help='Payload',
+        default=None)
+
+    parser.add_argument(
+        "-to", "--timeout",
+        type=float,
+        help='Request timeout',
+        default="4")
+
+    args = parser.parse_args()
+
+    observeValue = None
+
+    if args.observe and args.observe_cancel:
+        raise ValueError("cannot register for and cancel notifications")
+
+    if args.observe:
+        observeValue = 0
+
+    elif args.observe_cancel:
+        observeValue = 1
+
+    print(f"using {message_type(args.type)} {method(args.method)} request")
+    print(f"timeout set to {args.timeout}s")
+
+    port = 5600
+    protocol = await Context.create_server_context(bind=("::", port), site=resource.Site())
+    protocol.client_credentials.load_from_dict({
+        '*': {
+            'dtls': {
+                'psk': b'secretPSK',
+                'client-identity': b'Client_identity',
+            }
+        }
+    })
+
+    request = Message(
+        mtype=message_type(args.type),
+        code=method(args.method),
+        uri=args.uri,
+        payload=bytes(args.payload, 'utf-8') if args.payload else "",
+        observe=observeValue
+    )
+
+    try:
+        pr = protocol.request(request)
+
+        async with asyncio.timeout(args.timeout):
+            r = await pr.response
+            print("response: %s\n%r" % (r.code, r.payload))
+
+        if args.observe:
+            print("waiting for resource notifications")
+
+            async for r in pr.observation:
+                print("notification: %s\n%r" % (r, r.payload))
+                break
+
+        await protocol.shutdown()
+
+    except TimeoutError:
+        print(f"error: timeout exceeded after waiting {args.timeout}s")
+
+    except Exception as e:
+        print("error:")
+        print(e)
+
+if __name__ == "__main__":
+    asyncio.run(main())