I2c-USB-hub: An i2C Controllable USB 2.0 Hub
github.com
github.com
- Most USB hub chips can be strapped/hard wired configured, or controllable by i2c already directly. Funnily enough this chip isn't, but is extremely cheap (less than 24 cents!).
- The "port enable" feature on this design only controls VBUS (power pin of each connector), not the hub itself, so on a self-powered device it may not actually disconnect the device if it doesn't need VBUS to operate.
[1]: https://www.lcsc.com/product-detail/USB-ICs_CoreChips-SL2-1A...
I do a lot of firmware development and am constantly having to unplug/replug devices during the process .. for this reason I have an I-Tec 16-port Charging Hub, which has individual switches for each port - and this works fine, as long as I get the druthers to launch out of my chair and turn things off and on again... however being able to do all of this remotely, with software, would mean I could a) automate the hell out of a lot of things that requires monkey-tapping, and b) put the whole mess in a closet where it belongs, away from my coffee cup.
So I'm quite eager to see this project proceed - especially if there is a way the port capacities can be expanded (16-port would be ideal) .. so please consider officially reporting any issues in the design that you see!
It works on a pretty limited set of hubs, because most cheap out on including the switches.
https://github.com/mvp/uhubctl
Of the USB 3 options on the list, several were EOL or impossible to find, and when I ordered one each of the remainder, there was only one I could get working, and it wasn't reliable about being able to reset a device that had frozen to the point where Linux no longer had sysfs entries for it.
We ended up instead using a hub with an internal jumper to disable bus power, and then putting the self power line through a separately-controllable relay.
I wrote simple scripts to switch my monitor inputs with keyboard shortcuts (even simpler with Lunar, amazing new Mac app — https://lunar.fyi), which saved me from having to press annoying input-source buttons.
But I couldn't for the life of me find a simple, suitable software controllable KVM switch. That still requires the hardware button to be controlled, so frustrating.
Dough (formerly Eve) Spectrum monitors have this feature. They are also great all-round monitors.
Dell monitors all support DDC, I'm not sure if KVM switching can be controlled over DDC but it's likely.
Somewhat unrelated, but some of the Dell monitors also have USB-C support, where a single USB-C cable connects to your laptop and: charges it (Power Delivery from the monitor), hooks up the display (DP alt mode), and connects to the USB hub on the monitor. So if you use a wireless kb/mouse with receivers plugged into the monitor, you'll have literally just 2 cables on your desk - a power cable for your monitor, and a USB-C cable between the monitor and laptop.
- the laptop to the side is awkwardly positioned for zoom chat, so you probably want a webcam as well
- audio is a problem. If you use bluetooth and swap lots of things over then you keep needing to re-pair which is a pain. The model I have (Dell UltraSharp 27 USB-C Hub Monitor - U2722DE) has an audio jack but this is for connecting to soundbars not headphones, and the soundbars Dell offered that are compatible with that monitor don't support headphones. So, I ended up using a USB headset. You can use bluetooth with a usb soundcard dongle to avoid swapping, but bidirectional sound is an issue with that so you'll want to use the mic on the webcam (if you got one like that)
My keyboard/trackball are wired to the monitor, there doesn't seem to be much point to having wireless to attach something that's only a foot away anyway.
Either way, it's one connection to the laptop, but 4-5 other things need to connect to the monitor too. Still pretty good and not too much clutter tho
I have a desktop Linux PC but I often need to switch to my MacBook. If I plug the MacBook in, all my peripherals automatically switch to it. If I unplug, everything switch he's back to the Linux PC.
You can definitely use DDC to switch inputs, and the KVM is linked to the selected input. On MacOS I use Better Display which lets me switch inputs from a menu bar app. On linux there is ddcui (which is more like a proof of concept than a polished app, but it works). It's rare that I need to use this though since the auto-switching is usually all I need.
They do. Here's my shell function that helps me switch between DisplayPort-1 + USB uplink cable to the host AND USB-C cable with DisplayPort Alt Mode+Charging+uplink to display's USB hub.
# x0f: DisplayPort-1
# x1b: USB-C
DDC_SOURCES=("x0f" "x1b")
switchkvm() {
local vcp_input_src="x60"
local current next src
current=$(ddcutil -t getvcp ${vcp_input_src} | awk '{ print $4 }')
for src in "${DDC_SOURCES[@]}"; do
if [[ ${src} != "${current}" ]]; then
next=${src}
fi
done
if [[ -z ${next} ]]; then
echo "No eligible alternate input in \$DDC_SOURCES" >&2
echo "\$DDC_SOURCES=(${DDC_SOURCES[*]}); current=${current}"
return 1
fi
ddcutil setvcp "${vcp_input_src}" "${next}"
}I had a KVM switch with a wired button (place KVM out of the way, put small button on your desk). The button was connected via a 3.5mm "audio" jack. I never measured the interface, but I bet it just connected two rings of the jack.
Using a switch like that, you can build your own control for it without opening the KVM. Either with an ESP for wifi control (MQTT would be my choice) or a smaller board for USB/serial control (Cortex-M dev board). Short the proper rings via an optocoupler controlled by the MCU and it will behave as if you pressed the button.
Like sibling comment, I have a 4-port USB switch with a remote that connects via micro-usb, it was quite easy to hack a custom remote that I keep next to my keyboard.
https://www.aliexpress.com/item/1005005149590635.html
is probably what you need. It has a USB port linked to a USB serial internally that you send strings to switch. It was designed to be used with the Pi KVM/BLIKVM KVM over IP solution but works for other things as well.
Not opensource hardware, but available immediately for order and ESPHome/Tasmota can be used as a firmwre.
The available features vary though.
You can't have a USB hub that can't be controlled over USB, it wouldn't be able to work at all. The spec requires hubs to be active devices that show up on the bus and that can handle requests from the host, such as selective suspend or port power control.
Whether your hub actually offers a physical ability to turn off power of individual ports is another matter. The spec allows port power to be ganged (all ports being disabled at once after all of them have been requested to be disabled) and for all ports to be always powered - you can find out which mode the hub implements by reading wHubCharacteristics field in the hub descriptor.
Irrelevant in this context.
>Whether your hub actually offers a physical ability to turn off power of individual ports is another matter.
And the only matter that counts when it comes to "controllable" USB hubs. If I can't "control" the USB hub with uhubctl (or any other tool) it's not controllable.
All hubs have means to control them via USB in-band (there are other things to control there than power too), and hubs that do support power switching can be controlled this way, so there's no need to use external interfaces like I2C unless you want to control such hub externally (not from the USB host), which is what this thread was about.
Yes. An interface. Because not all hubs can be controlled in-band. Maybe you have a different definition of "control".
>All hubs have means to control them via USB in-band (there are other things to control there than power too), and hubs that do support power switching can be controlled this way, so there's no need to use external interfaces like I2C unless you want to control such hub externally (not from the USB host), which is what this thread was about.
This is wrong though. I can't control my hub. Doesn't matter that there are some other stuff I could theoretically control. (or the OS does without my intervention)
Yes. The Github link is about how to control a USB hub via I2C. From the description:
>Have you ever wanted to control USB devices using an Arduino, ESP32, or Raspberry Pi? with the i2C USB Hub, you can! Turn on or off ports of the USB hub using i2c, as well as control indicator lights and set current limits per-port.
So you saying, that you could do that in-band is wrong, because not all hubs can be controlled in-band.
Or the easy definition: no port control == not controllable.
Nothing's wrong there and you're just playing with semantics to not admit your misunderstanding. All hubs have an in-band control interface available that can be used by them to implement port power control, period.
> The Github link is about how to control a USB hub via I2C.
No, it points to a hardware design for a very specific hub that implemented its port power control via I2C. Usually hubs don't have any I2C interface at all as they don't need one, regardless of whether they do port control or not.
You want to make it about semantics because you think that "control" means something different then what it means. There are hubs that can't be controlled that way. Period.
./uhubctl
No compatible devices detected!
Run with -h to get usage info.
Feel free to tell me how I can get those uncontrollable hubs compatible.>USB hubs are controllable via USB, so I guess this is for cases where your hub is connected to a device you don't control.
This is not a generally true. I gave an example of an uncontrollable hub you deemed irrelevant.
What is control if it's not controlling the USB hub? It's not "the kernel does something which requires no user input".
Every USB hub has a control channel over USB and it's true regardless of how you may want to redefine the word "control". My post attempted to answer a question that popped into my mind when looking at this submission: "why would I want a USB hub that implements power control via I2C instead of USB?" (another answer could be "because it's easier to retrofit such functionality on top of a hub chip that doesn't do power control", although that one is only relevant for the designer and not for the user of such device).
Meanwhile, I just sent a command to a USB hub in my mobile phone in order to suspend a modem connected to it - something every USB hub is capable of doing and what can be controlled by the user (yes, it's a function of the hub, not of the device). But you do you, enjoy your world.
uhubctl doesn't concern itself with all those features, but technically there's nothing preventing it from implementing them alongside power control.
I have spent more time reading USB specs and debugging USB connection troubles than I wish I had to.
So many issues with USB during development can be resolved if you can just get the device reset during the dev process. Being able to hard-reset a device during compile/debug phases is going to save me huge amounts of time and effort ...
A DIY hub that uses a chip with PPPS support can be found here for example: https://oshwlab.com/iamseer/ch335-hub
The support for commands themselves (SET/CLEAR_FEATURE) is mandated by the spec, so all hubs support it. However, some hubs don't feature port power control at all (are physically unable to selectively turn off power - you can only turn them all off or not at all), but for those it doesn't matter how you control them ;)
Although it would be more convenient to integrate it directly on board.
It was very expensive but works reliable. You can use API to control it.