dtn7zero 0.0.1

No project description provided

dtn7zero

This is a DTN7 python implementation (work-in-progress) with NetworkZero like API.

The current features are:

• a full bundle protocol agent (without fragment or CRC support)
• a minimal TCP convergence layer
• a dtn7rs REST convergence layer
• an ipnd module
• a standalone 'external' endpoint (which connects to a dtn7rs)
• a simplified NetworkZero like API to easily get started
• full MicroPython support (tested on an ESP32-GENERIC)
• (currently uses epidemic routing and in-memory storage managing)
• (with extendability for new convergence layer adapters, routing algorithms, and storage managers)

Getting Started

To use dtn7zero in your CPython environment, simply install it via pip (or pip3 on linux):
(currently the package is only available on the test instance)

$ pip install -i https://test.pypi.org/simple/ --upgrade dtn7zero

Development Mode

You can install this project locally to directly reflect code changes in your environment. Simply run this in the project root folder (requires at least pip v21.1):

$ pip install --editable .

MicroPython Installation Guide

This whole project was tested on an ESP32 (GENERIC) and this installation guide is tailored for the ESP32. If you plan to use another microcontroller you might need to do adjustments (most certainly the MicroPython installation, and the MPY_MARCH in esp-deployment.py).

Important note for linux: it may be that mpremote assumes another USB device with higher priority than the ESP32. In that case all mpremote commands (especially inside esp-deployment.py) will fail as no communication is possible. Check all USB devices mpremote considers in priority order with mpremote devs.

First Time MicroPython Installation For ESP32 (GENERIC)

1. download the newest firmware
2. install the esp flash tool: pip install esptool
3. connect your ESP32 via USB and start a terminal at the location of the downloaded firmware
4. start the following command (with the correct USB port), then hold boot until it starts erasing:
   esptool --chip esp32 --port /dev/ttyUSB0 erase_flash
5. start the following command (with the correct USB port and firmware name), then hold boot until it starts flashing:
   esptool --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-20220618-v1.19.1.bin
6. done, you may now connect to it via: mpremote (installation via pip: pip install mpremote)

Update To New MicroPython Version

1. download the newest firmware
2. start the following command (with the correct USB port and firmware name), then hold boot until it starts flashing:
   esptool --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 esp32-20220618-v1.19.1.bin
3. done

First Time dtn7zero Deployment

1. make sure you check out the repository and the submodules (especially py-dtn7)
2. install the mpremote tool: pip install mpremote
3. install the mpy-cross compiler tool: pip install mpy-cross
4. populate wlan.json with an appropriate hostname and at least one ssid -> password mapping
5. check your connection to the ESP32 with: mpremote
6. copy wlan.json to your ESP32: mpremote fs cp wlan.json :wlan.json
7. copy boot.py to your ESP32: mpremote fs cp boot.py :boot.py
8. deploy the dtn7zero and dependencies onto the ESP32 (this can take a while): python scripts/esp-deployment.py
9. done

Continuous dtn7zero Deployment

1. check your connection to the ESP32 with: mpremote
2. deploy the changes of dtn7zero and dependencies onto the ESP32 (this can take a while): python scripts/esp-deployment.py
3. done

First dtn7zero Functionality Check On MicroPython

1. you may check that wlan is connecting correctly (connect via mpremote and press enable for a soft reset)
2. you may also check that you can import dtn7zero (connect via mpremote and import dtn7zero)
3. you can also check that everything works (run the test script mpremote run scripts/test-bundle-protocol-agent.py)

Useful Links

the DTN7 website: https://dtn7.github.io
dtn7 go implementation: https://github.com/dtn7/dtn7-go
dtn7 rust implementation: https://github.com/dtn7/dtn7-rs
dtn7 python bundle implementation and dtn7rs-rest-api access: https://github.com/teschmitt/py-dtn7

Bundle Protocol 7 RFC: https://datatracker.ietf.org/doc/html/rfc9171
Bundle Protocol Security (BPSec) RFC: https://datatracker.ietf.org/doc/html/rfc9172
Default Security Contexts for BPSec RFC: https://datatracker.ietf.org/doc/html/rfc9173
TCP Convergence-Layer Protocol Version 4 RFC: https://datatracker.ietf.org/doc/html/rfc9174
Minimal TCP Convergence-Layer Protocol RFC (draft): https://datatracker.ietf.org/doc/html/draft-ietf-dtn-mtcpcl-01
UDP Convergence Layer RFC (draft): https://datatracker.ietf.org/doc/html/draft-sipos-dtn-udpcl-01

Outdated Standards:
DTN URI Scheme: https://www.ietf.org/archive/id/draft-irtf-dtnrg-dtn-uri-scheme-00.html

Further Research

This is some information gathered about future mesh extensions:

1. ESP-Mesh(ESP-WIFI-Mesh)

   • a special mesh standard which is based of Wi-Fi and uses the special AP_STA mode
   • no micropython implementation known

2. ESP-NOW

   • a special p2p mode, which is based of Wi-Fi and can send data to neighbouring devices via MAC addressing
   • no mesh protocol, but broadcast is possible, looks promising to build an esp32-dtn-mesh
   • non-official, but tested micropython library available, as well as builds with the current firmware

3. Alternative: AP_STA mode for simultaneous AP and STA without explicit ESP-MESH usage

   • only available for Arduino+C
   • painlessMesh also uses this mode to build its mesh

Open End Topics / Known Issues

• interface between router and cla is inconsistent (different responsibilities for send and receive)
• dtn7rs-rest-cla and in-memory storage together use too much RAM (therefore the rest-cla is disabled in the simple API)
• additional group (for example: "dtn://group/~news") registration on singleton endpoints (can there be registrations from multiple local endpoints on the same group?)