We’ll probably do a series of power consumption / range tests later on, let me know if there are any setups in particular that you’d be interested in seeing test cases for.
Raw data, firmware and post processing scripts are here on GitHub:
https://github.com/Scottapotamas/embedded-wireless-latency-e...
I'll try to find something for the planned range/interference tests. Morse Micro is also an Australian company so I'll probably look into their parts first unless there's any recommendation?
If one wanted to do something like that one would probably start by reading that article I guess.
Thanks for this very thorough work.
Several months ago, I built a project using USB host mode on a Raspberry Pi Pico, which uses a USB numpad to pass messages to an MQTT server. This uses the Rp2040's USB host mode https://gitlab.com/baiyibai/pico-w-usb-host-mqtt-numpad
https://github.com/adafruit/Adafruit_TinyUSB_Arduino
My implementation plugs in much higher into the stack and doesn't read the full USB bit mask output, which indicates how many keys are pressed/released.
From my limited understand ing, it should be possible to pass these USB messages from HID client to HID host and vice-versa. Then it's only a matter of sending this information over a TCP/UDP interface. However, from my research, it seems the TinyUSB library doesn't provide the full bitmask resolution necessary for all devices. The YouTuber Wendell from LevelOneTechs has also talked about the troubles of getting some devices working with his KVM products, so it may not be as simple as I'm suggesting here.
Overall though, a $15/endpoint is very attractive.
Maybe I read the README a little to quickly, but you seem to be using standard WiFi for communication. As stated in other comments in this thread, this solution already exists. USB through Ethernet extension are well established and you can already connect this to a WiFi extender.
What I was thinking was to achieve this with a simple radio connection that do not need configuration or even a WiFi network to function. Just plug it in and it works. Here's a sketch of the high level concept I had in mind: https://ibb.co/VD2d9XM
Is your point that once you can do that with Wi-Fi it is trivial to do it with any type of radio connection?
> From my limited understanding, it should be possible to pass these USB messages from HID client to HID host and vice-versa.
Someone did this here using Etherkey and an ATmega32u4: https://www.sjoerdlangkemper.nl/2022/11/16/running-etherkey-...
> it seems the TinyUSB library doesn't provide the full bitmask resolution necessary
If my understanding is correct, Arduino already provides low level USB controls: https://shorturl.at/joSWZ.
All in all, it seems to me that there is an opportunity here but unfortunately this requires skills in electronic, radio and USB protocol that I do not possesses and seems fairly rare.
You would need drivers on the computer and I don't know about latency.
For this reason, we use the nRF52 radio peripheral directly (i.e. barebones C) which means we know exactly when the packet was sent and - at the other end - when it was received. Details are in the Production Specification document, which also shows how long it takes for the transmit to spin up (turn on, transmit pre-amble and so on).
Here's a perspective from a guitarist's viewpoint. Most wireless guitar systems boast latencies below 3ms, with the better ones being closer to 1ms.
Latency is important here because even small delays can be felt by the player. Since sound travels at ~1 ft per 1ms, a delay on the order of BLE is equivalent to playing with the amplifier ~25ft away from you, which is pretty bad.
It is surprising that the best system is actually nrf24, given how old it is (or maybe because of that ?). It also seems to have enough bandwidth to transfer a 24-bit/48kHz signal.
A pure analogue approach (modulated RF) on the other hand shouldn't have any human-detectable delay - it's effectively distance/speed of light with a bit of a phase shift (addtional delay) introduced by the electronics - should be only a handful of microseconds in total.
I’ve done some similar, but not as thorough, tests with 2.4ghz WiFi and 915MHz LoRa before. My goal is to sync time across multiple devices that go in and out of range of each other to play 60fps light animations and sound within half a frame of each other (8ms), with spare time for some computation.
I’ve been surprised at how bad some oscillators (or voltage regulators) can be and their effect on consistent latency.
I was having fun experimenting, but this will be really useful to get me back to actually implementing my project.
What I would like to see is better support from the cloud providers for UDP based protocols such as MQTT-SN.