Piconet allows modern computers (MacOS, PC and Linux) to talk to Acorn Econet networks using a board which interfaces the ADF10 Econet module (BBC Master/Archimedes Econet board) to a Raspberry Pi Pico. The Pico can then be connected to your machine via USB.

Piconet is theoretically capable of supporting anything you can dream up which runs over Econet: file transfer utilities, file servers, D&D servers etc.

This project provides the purple boxes in the above diagram: the hardware design of the Piconet board, the firmware which executes on the Pico, and the drivers which talk to it.

• ecoclient — a command-line utility for performing Econet operations
• NodeJS driver — see this subproject for docs and code samples to build your own Econet apps

This project is still under development. Currently:

• The only driver available today is based on Node.js. Contributions of drivers based on other languages are welcome (Python, Golang etc) — please get in touch if interested! It is also possible to write apps which communicate with the board directly over a serial connection. See the protocol documentation below.
• Most development has been carried out on a Mac, although Windows and Linux have been tested too.
• Interoperability testing has been carried out with Acorn Level 3 (BBC Micro) and Level 4 (Archimedes) fileservers only. User feedback on Filestores has been positive.

It's still early days - expect weirdness!

1. Acquire or build the Piconet board
2. Download the .uf2 image from the releases page
3. Connect the Pico to your machine with a USB cable whilst holding down the button on the Pico board
4. The Pico should show as a storage device: copy the .uf2 image to it
5. The Pico should reboot automatically when the copy is complete
6. Connect an ADF10 Econet module to the board and hook it up to your Econet network
7. Install an app such as ecoclient or try one of the code examples provided with the driver

• Core 0 handles serial I/O, leaving Core 1 free for more time-sensitive tasks. It does the following:
  • commands received from the host over the serial interface are put onto the command FIFO queue
  • events received from Core 1 on the event FIFO queue are marshalled and sent on to the host
• Core 1 does the following:
  • receives commands from the command FIFO
  • handles the broadcast, transmit and receive Econet primitives and services ADLC interrupts in the econet.c module
  • generates the appropriate signals to read and write from ADLC registers in the adlc.c module
  • generates events and places them on the event FIFO
• The FIFO queues are used to synchronise communication between the two cores and to queue (the sometimes bursty) events coming out of core 1
• Shared Memory is used by a buffer pool to hold data frames in shared memory
• The PIO state machine handles the time-critical signals !CS (a.k.a. !ADLC), R!W and the data bus
  • some information on signal timing may be found here

This assumes you are building on Linux - see Pi Pico C SDK documentation for other platforms.

Install dependencies (Ubuntu/Debian derivatives)

apt install -y git build-essential cmake gcc-arm-none-eabi libnewlib-arm-none-eabi libstdc++-arm-none-eabi-newlib python3
git clone https://github.com/raspberrypi/pico-sdk.git --branch master
cd pico-sdk
git submodule update --init

Run the following from the board directory of this project:

export PICO_SDK_PATH=...  # set to directory created in previous step
cmake --no-warn-unused-cli -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE -DCMAKE_BUILD_TYPE:STRING=Debug -S. -B./build
cmake --build ./build --config Debug --target piconet -j 12 --

A piconet.uf2 for flashing should appear under the build subdirectory.

This section describes the serial protocol between the board and driver.

Piconet protocol overview:

• Serial, text based protocol
  • human-readable
  • base64 encoding used for binary data (a decent trade-off between CPU efficiency (i.e. effort to encode/decode) and informational efficiency (i.e. size of data to exchange vs. that transferred over the wire)
• Commands are sent by host machine such as:
  • status command
  • configuration commands
  • transmit command (e.g. TX)
• Events are sent by board e.g.:
  • TX_RESULT in response to TX commands
  • ...or asynchronously e.g. ERROR, RX_xxx, MONITOR
• One command/event per line
  • aids recovery from reconnection (firmware keeps on running whilst apps start/stop/error)
• Utilises semantic versioning
  • determines compatibility between firmware and drivers/apps
  • allows apps/driver to signal to user that firmware or driver/app needs to upgrade before things get weird

There are three modes of operation:

Thanks to the following projects:

• Base64 encode/decode code taken from: https://github.com/mbrt/libb64
• ADF-10 hardware interfacing and Econet protocol insights: https://github.com/cr12925/PiEconetBridge
• More Econet protocol insights: https://github.com/stardot/ArduinoFilestore
• General discussion on BBC Micro and Econent topics: https://stardot.org.uk