VibHub Wiki - User contributions [en-gb]

CE

2026-03-31T14:35:36Z

Jasx: Created page with "Todo: CE Declaration of conformity."

Todo: CE Declaration of conformity.

Product Comparison

2026-03-26T21:09:42Z

Jasx: Created page with "There are currently two available VibHub dev kits. {| class="wikitable" |+ !Feature !VibHub Micro !VibHub Classic 4xAA |- |Release Year |2026 |2020 |- |USB Outputs |2x USB-A |4x USB-A |- |Wireless Protocol |WiFi 2.4GHz |WiFi 2.4Ghz |- |Input Port |USB-C |USB Micro |- |Microcontroller |ESP32-S3 |ESP32 |- |Battery |Built in 1500mAh lithium |External 4x AA batteries |- |Size |77x45x20mm (3.03x1.77x0.79 in) |80x106x28mm (3.15x4.17x1.10 in) |- |Weight (Incl Batteries) |68g (2..."

There are currently two available VibHub dev kits.
{| class="wikitable"
|+
!Feature
!VibHub Micro
!VibHub Classic 4xAA
|-
|Release Year
|2026
|2020
|-
|USB Outputs
|2x USB-A
|4x USB-A
|-
|Wireless Protocol
|WiFi 2.4GHz
|WiFi 2.4Ghz
|-
|Input Port
|USB-C
|USB Micro
|-
|Microcontroller
|ESP32-S3
|ESP32
|-
|Battery
|Built in 1500mAh lithium
|External 4x AA batteries
|-
|Size
|77x45x20mm (3.03x1.77x0.79 in)
|80x106x28mm (3.15x4.17x1.10 in)
|-
|Weight (Incl Batteries)
|68g (2.4oz)
|222g (7.8oz)
|-
|Max PWM Resolution
|12 bit
|8 bit
|-
|Capabilities
|PWM, Programs, Battery Status, Serial Control
|PWM, Programs
|}

Wago Adapter

2026-03-26T20:54:43Z

Jasx:

[[File:Wago adapter.jpg|thumb|The Wago Adapter is a cheap way to turn most dumb 5V vibrators into smart ones.]]
The VibHub Wago adapter is a little bare circuit adapter that lets you convert most dumb 5V vibrators into smart ones by cutting and stripping the cable.

=== Basic Use ===
First off you need a vibrator that's capable. Check the [[Compatible toys|Compatible Toys]] page for more info!

In this tutorial, we'll be using a common 2-in-one vibrator from AliExpress. At the time of writing, these sell for like $4 per pair, so they're almost cheap enough to be considered disposable. A cheap egg vibrator is a good starting point in case you don't know what you're doing. But connecting a simple wire-remote device to a VibHub is very easy.

''Before you begin, '''please note that the process is destructive''', as you'll be cutting the cord! Don't convert a vibrator if you want to restore it at a later date!''

Also note that you can do one vibrator per adapter, don't cram multiple cords in there!
[[File:ExampleProduct.jpg|thumb|Example of a cheap vibrator that can be used.]]
[[File:Step00.jpg|frameless]]

'''Step 1:''' Cut the cord. You want a lead connected directly to the vibrator!

[[File:Step01.jpg|frameless]]

'''Step 2:''' Split and strip a bit at the end of the cord to expose some copper. 5mm (0.2") is enough.

[[File:Step02.jpg|frameless]]

'''Step 3:''' Press down on the "button" on top and slide the cable in. If you give it a gentle tug after, and it doesn't release, you're good!
''Note: The polarity of the wires doesn't matter, you can attach them in any order!''

[[File:Step03.jpg|frameless]]

'''Step 4:''' Repeat with the other wire.

[[File:Step04.jpg|frameless]]

'''Step 5:''' Do the same with the other vibrator if you wish, but that's it! '''You're done!'''

Wago Adapter

2026-03-26T20:54:01Z

Jasx:

[[File:Wago adapter.jpg|thumb|The Wago Adapter is a cheap way to turn most dumb 5V vibrators into smart ones.]]
The VibHub Wago adapter is a little bare circuit adapter that lets you convert most dumb 5V vibrators into smart ones by cutting and stripping the cable.

=== Basic Use ===
First off you need a vibrator that's capable. Check the [[Compatible toys|Compatible Toys]] page for more info!

In this tutorial, we'll be using a common 2-in-one vibrator from AliExpress. At the time of writing, these sell for like $4 per pair, so they're almost cheap enough to be considered disposable. A cheap egg vibrator is a good starting point in case you don't know what you're doing. But connecting a simple wire-remote device to a VibHub is very easy.

''Before you begin, '''please note that the process is destructive''', as you'll be cutting the cord! Don't convert a vibrator if you want to restore it at a later date!''

Also note that you can do one vibrator per adapter, don't cram multiple cords in there!
[[File:ExampleProduct.jpg|thumb|Example of a cheap vibrator that can be used.]]
[[File:Step00.jpg|frameless]]

'''Step 1:''' Cut the cord. You want a lead connected directly to the vibrator!

[[File:Step01.jpg|frameless]]

'''Step 2:''' Split and strip a bit at the end of the cord to expose some copper. 5mm (0.2") is enough.

[[File:Step02.jpg|frameless]]

'''Step 3:''' Press down on the "button" on top and slide the cable in. If you give it a gentle tug after and it doesn't release, you're good!
''Note: The polarity of the wires doesn't matter, you can attach them in any order!''

[[File:Step03.jpg|frameless]]

'''Step 4:''' Repeat with the other wire.

[[File:Step04.jpg|frameless]]

'''Step 5:''' Do the same with the other vibrator if you wish, but that's it! '''You're done!'''

Wago Adapter

2026-03-26T20:53:30Z

Jasx: Created page with "The Wago Adapter is a cheap way to turn most dumb 5V vibrators into smart ones. The VibHub Wago adapter is a little bare circuit adapter that lets you convert most dumb 5V vibrators into smart ones by cutting and stripping the cable. === Basic Use === First off you need a vibrator that's capable. Check the Compatible Toys page for more info! In this tutorial, we'll be using a common 2-in-one vibrator from AliExpress...."

[[File:Wago adapter.jpg|thumb|The Wago Adapter is a cheap way to turn most dumb 5V vibrators into smart ones.]]
The VibHub Wago adapter is a little bare circuit adapter that lets you convert most dumb 5V vibrators into smart ones by cutting and stripping the cable.

=== Basic Use ===
First off you need a vibrator that's capable. Check the [[Compatible toys|Compatible Toys]] page for more info!

In this tutorial, we'll be using a common 2-in-one vibrator from AliExpress. At the time of writing, these sell for like $4 per pair, so they're almost cheap enough to be considered disposable. A cheap egg vibrator is a good starting point in case you don't know what you're doing. But connecting a simple wire-remote device to a VibHub is very easy.

''Before you begin, '''please note that the process is destructive''', as you'll be cutting the cord! Don't convert a vibrator if you want to restore it at a later date!''

Also note that you can do one vibrator per adapter, don't cram multiple cords in there!
[[File:ExampleProduct.jpg|thumb|Example of a cheap vibrator that can be used.]]
[[File:Step00.jpg|frameless]]

'''Step 1:''' Cut the cord. You want a lead connected directly to the vibrator!
[[File:Step01.jpg|frameless]]
'''Step 2:''' Split and strip a bit at the end of the cord to expose some copper. 5mm (0.2") is enough.
[[File:Step02.jpg|frameless]]
'''Step 3:''' Press down on the "button" on top and slide the cable in. If you give it a gentle tug after and it doesn't release, you're good!
''Note: The polarity of the wires doesn't matter, you can attach them in any order!''
[[File:Step03.jpg|frameless]]

'''Step 4:''' Repeat with the other wire.

[[File:Step04.jpg|frameless]]

'''Step 5:''' Do the same with the other vibrator if you wish, but that's it! '''You're done!'''

File:Step04.jpg

2026-03-26T20:52:23Z

Jasx:

Wago

File:Step03.jpg

2026-03-26T20:51:43Z

Jasx:

Connect the other one

File:Step02.jpg

2026-03-26T20:49:58Z

Jasx:

Connect the wago

File:Step01.jpg

2026-03-26T20:48:38Z

Jasx:

Strip the jacket with a scissor

File:Step00.jpg

2026-03-26T20:47:28Z

Jasx:

Cut the cord

File:ExampleProduct.jpg

2026-03-26T20:42:11Z

Jasx:

Example of a vibrator that can be converted with the Wago connector.

File:Wago adapter.jpg

2026-03-26T20:37:27Z

Jasx:

VibHub Wago Adapter

Main Page

2026-03-26T20:31:57Z

Jasx:

User Resources
{| class="wikitable"
|+
!Link
!Description
|-
|[[Product Comparison|VibHub Product Comparison]]
|See which kinds of VibHubs are available, and what their hardware specs are.
|-
|[[User Manual]]
|Learn how to use your VibHub!
|-
|[[Compatible toys|Toy Compatibility]]
|See what kind of toys you can use.
|-
|[[Wago Adapter|Using the VibHub Wago Adapter]]
|A fast snap adapter that lets you turn most 5V vibrators into smart ones.
|}

== Developer Resources ==
Welcome to the VibHub wiki! Before we start, let's go over some terms:
{| class="wikitable"
!Term
!Explanation
|-
|[[Firmware|Device]]
|This is the physical hardware VibHub, and also refers to the firmware.
|-
|[[App]]
|The code that sends vibration instructions to the Device. This is likely what you're here for! See the API documentation below!
|-
|[[Server]]
|This is the server that relays messages between the Device and the App. You can host your own!
|-
|deviceID
|A unique ID for each Device that allows the App to communicate with it
|}

=== Source Code ===
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|-
|[https://github.com/JasXSL/VibHub-Server VibHub Server]
|Host your own VibHub server!
|-
|[https://github.com/JasXSL/VibHub-Browser VibHub Browser]
|Official JS client library. See [[VibHub-Browser]] for documentation.
|-
|[https://github.com/JasXSL/SL-XOBJ/blob/master/xobj_core/classes/jas%20VibHub.lsl XOBJ SL Library]
|Second Life library built on the XOBJ framework
|-
|[https://github.com/JasXSL/VibHub-SocketDemo Browser Example]
|Example browser app that lets you run VibHub locally with just a few lines of code!
|}

=== API ===
{| class="wikitable"
|+
!API Type
!Description
|-
|[[REST]]
|Lets you send vibration programs to a device through simple HTTP requests.
|-
|[[Web Sockets]]
|Much faster than REST requests, recommended if your platform supports it!
|-
|[[Tasks|Tasks Reference]]
|Tasks that your device can handle.
|}

REST

2026-03-26T14:57:22Z

Jasx: /* vib */

The REST API allows you to send a set of tween instructions to a device. This is a good option if you want to send fewer requests that execute a program of pulses, turning on and off etc, or your platform can't do websockets.

To send a program to a device, simply send a GET request to: <code><nowiki>https://vibhub.io/api?id=</nowiki><device_id>&type=<type>&data=<json_data_here></code>

(HTTP is also accepted but should only be used if your app can't use SSL)

Query params explained:
{| class="wikitable"
!Param
!Type
!Explanation
|-
|id
|string
|The deviceID you want to run the program on
|-
|type
|string
|The task to send. See Tasks below.
|-
|data
|varies
|Depends on the type, see below.
|}
Don't forget to URL encode.

= Types =

=== vib ===
The "vib" task expects data to be a URL encoded array of objects with the following params:
{| class="wikitable"
!Param
!Default
!Required
!Type
!Explanation
|-
|stages
|N/A
|Yes
|Array
|An array of stage objects to be tweened beetween. See below for stage objects
|-
|repeats
|0
|No
|integer
|Nr times the animation should repeat. 0 plays it once, 1 plays it twice etc. Use -1 for infinity
|-
|port
|0
|No
|integer
|Bitwise combination of ports to run the program on. 0x1 is the first port, 0x2 second and so forth. 0 or negative values will target ALL ports. Most devices handle this as a 16bit signed int, so you can use up to 15 ports on a device.
|-
|highres
|false
|No
|boolean
|When set, we will use all supported bits in the program. Check the "h" response in whois for max nr of bits the device supports.
|}

=== Stages ===
The stage is an object containing tweening information for that stage of the program. It has the following properties:
{| class="wikitable"
!Param
!Default
!Type
!Explanation
|-
|i
|0
|integer/obj/boolean
|A value between 0 and 255. Higher value = faster vibrations. Or false to use the previous value. Or a RandObject (see below).
|-
|d
|0
|integer/obj
|Time in milliseconds to reach specified intensity. 0 = instant. Or a RandObject (see below).
|-
|e
|"Linear.None"
|string
|A string denoting the tween.js easing type. See this example for the supported types.
|-
|r
|0
|integer/object
|Repeats. 0 = play this stage once, 1 = play this stage twice and so forth. Or a RandObject (see below)
|-
|y
|false
|boolean/truthy/falsy value
|Go back and forth. Requires repeats to work. Repeats of 1 goes back and forth once, repeats of 3 goes back and forth twice etc. An even number such as 2 will go forth, back, forth, and then start at forth on the next stage.
|}

=== RandObject ===
A RandObject can be used in certain places of a vib call. It'll generate a random value. This value will be randomized at the start of each program loop, but not program stage loop.
{| class="wikitable"
!Param
!Default
!Type
!Explanation
|-
|min
|0
|integer
|Min value to randomize
|-
|max
|varying
|integer
|Max value to randomize. The default value for this depends on the stage param you put it in. i=255, d=10000, r=9
|-
|offset
|0
|integer
|Adds an offset to the randomly generated value. Useful in yoyo type steps where you always want an odd number of repeats (combine with multi of 2).
|-
|multi
|1
|integer
|Multiplies the random value by this. Useful together with offset to generate pulses going up and down n times
|}
Example:

<code>{"min":0, "max":3, "offset":1, "multi":2}</code>

This is useful in repeats with yoyo, as it always generates an odd number. In practice, the above line means "generate 1-4 pulses."

=== Examples ===
Run a program on device id "JasTestBullet". The program resets the vibration level to 0, then goes up to 50% and down again 3 times, then resets back to 0.
Request:

<code>GET <nowiki>https://vibhub.io/api/?id=JasTestBullet&type=vib&data=</nowiki>[{"stages":[{"i":0,"d":0},{"i":50,"d":500,"r":5,"y":1},{"i":0,"d":0}]}]</code>

Response:

<code>{"message":"OK","success":true}</code>

== whois ==
Lets you get meta information about a connected device:

=== Examples ===
Request:
<code>GET <nowiki>https://vibhub.io/api/?id=JasTestBullet&type=whois&data=</nowiki>[]</code>

Response:

<code><nowiki>{"message":{"numPorts":4,"version":"0.3.0","hwversion":"esp32","custom":"","capabilities":{"p":true,"ps":true,"vib":"true"}},"success":true}</nowiki></code>

Compatible toys

2026-02-04T15:00:45Z

Jasx:

In general, you can use any toy that's directly '''powered''' with USB. If the device is '''charged''' with USB, it's incompatible unless you manually rebuild it.

Also note that if the toy has a remote on the cable, then it's not going to work unless the remote is analog. However, most cheap toys with a remote can be reworked into a VibHub capable toy with a pair of scissors (note that this is a one way conversion).

== Toys that work directly ==
[[File:Direct pink.jpg|frameless]][[File:Direct black.jpg|frameless]]
These are toys that are '''powered''' directly with USB. They're a bit of rarity these days. But if you can find one, it's by far the easiest option.

== Toys that are easy to use with the screw adapter ==
Using the VibHub Screw Adapter or VibHub Wago Adapter, these devices are budget friendly options. Note that in order to use these with the adapter, you have to manually cut off the wire, strip the end, and screw it in place into the VibHub adapter. This obviously ruins the use of the original remote control, but these toys are super cheap anyhow.

[[File:Eggs cut.jpg|frameless]][[File:Egg remote.jpg|frameless]][[File:Tripple cut.jpg|frameless]]

These devices are super cheap (usually a few dollars), and can be turned into a VibHub toy by cutting the power cord at the base of the remote, stripping away some cord, and using the VibHub Screw/Wago Adapter.
You can find them everywhere on sites like Amazon & AliExpress. Just search for ''usb vibrating egg'' or similar.

== Toys that can be used, but require significant rework ==

[[File:Doable.jpg|frameless]]

Some vibrators with a built in battery ''and are USB-chargeable'' can be reworked into VibHub toys. However, this process involves opening the toy case up, taking out the existing circuitry, and soldering the charge port directly to the vibrator motor. This requires significantly more work, but if you're comfortable around a soldering iron and basic circuitry, you'll have an easy time doing so.
== Toys that are NOT compatible ==
[[File:Incompatible voltage.jpg|left|frameless]]
[[File:Already wireless.jpg|frameless]]

Toys that don't rely on 5V (or thereabouts), or that are already wireless cannot be used.

''Note: Technically you can rework an already wireless toy by taking out the existing circuitry and soldering the motor to the charge port, but doing so is a destructive process, and using a simple toy listed above with the screw adapter is going to be much cheaper and easier.''

File:Already wireless.jpg

2026-02-04T14:58:47Z

Jasx:

Toys that are already wireless cannot be used

File:Incompatible voltage.jpg

2026-02-04T14:58:13Z

Jasx:

Not powered with 5V

File:Doable.jpg

2026-02-04T14:55:38Z

Jasx:

Can be reworked, but requires soldering

Compatible toys

2026-02-04T14:52:56Z

Jasx: Created page with "In general, you can use any toy that's directly '''powered''' with USB. If the device is '''charged''' with USB, it's incompatible unless you manually rebuild it. Also note that if the toy has a remote on the cable, then it's not going to work unless the remote is analog. However, most cheap toys with a remote can be reworked into a VibHub capable toy with a pair of scissors (note that this is a one way conversion). == Toys that work directly == File:Direct pink.jpg|..."

File:Tripple cut.jpg

2026-02-04T14:43:25Z

Jasx:

Cheap device that gives you 3 toys

File:Egg remote.jpg

2026-02-04T14:42:53Z

Jasx:

Cut and attach to adapter

File:Eggs cut.jpg

2026-02-04T14:42:15Z

Jasx:

These toys can be cut and wired into the screw adapter

File:Direct black.jpg

2026-02-04T14:35:41Z

Jasx:

Works directly with VibHub

File:Direct pink.jpg

2026-02-04T14:34:57Z

Jasx:

Works directly with VibHub

Main Page

2026-02-04T12:47:46Z

Jasx:

If you're a user rather than a dev, you may be interested in a [[User Manual]]!

Or maybe you're looking for help finding [[compatible toys]]?

Welcome to the VibHub wiki! Before we start, let's go over some terms:
{| class="wikitable"
!Term
!Explanation
|-
|[[Firmware|Device]]
|This is the physical hardware VibHub, and also refers to the firmware.
|-
|[[App]]
|The code that sends vibration instructions to the Device. This is likely what you're here for! See the API documentation below!
|-
|[[Server]]
|This is the server that relays messages between the Device and the App. You can host your own!
|-
|deviceID
|A unique ID for each Device that allows the App to communicate with it
|}

== Source Code ==
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|-
|[https://github.com/JasXSL/VibHub-Server VibHub Server]
|Host your own VibHub server!
|-
|[https://github.com/JasXSL/VibHub-Browser VibHub Browser]
|Official JS client library. See [[VibHub-Browser]] for documentation.
|-
|[https://github.com/JasXSL/SL-XOBJ/blob/master/xobj_core/classes/jas%20VibHub.lsl XOBJ SL Library]
|Second Life library built on the XOBJ framework
|-
|[https://github.com/JasXSL/VibHub-SocketDemo Browser Example]
|Example browser app that lets you run VibHub locally with just a few lines of code!
|}

== API ==
{| class="wikitable"
|+
!API Type
!Description
|-
|[[REST]]
|Lets you send vibration programs to a device through simple HTTP requests.
|-
|[[Web Sockets]]
|Much faster than REST requests, recommended if your platform supports it!
|-
|[[Tasks|Tasks Reference]]
|Tasks that your device can handle.
|}

User Manual

2026-02-04T12:23:15Z

Jasx:

VibHub is an open source, open hardware vibrator controller. It allows you to turn any non-battery-driven USB vibrator into a smart internet capable one, supporting 2 ports for the VibHub micro, and 4 ports for the classic 4xAA version. This manual is focused on the newer VibHub Micro version, but a lot of what's written here is also true for the older 4x AA version.

=== WARNING ===

* The VibHub USB output ports are ONLY for powering motors or similar simple devices such as lights. '''DO NOT USE THEM TO CHARGE COMPLEX DEVICES, OR YOU MAY CAUSE DAMAGE TO THEM!'''

== First steps ==
# Your device may arrive uncharged or with low charge. Plug the USB port into a charger. A red LED will light up. On charge completion, a green or blue LED will light up next to the charge port.
# On the side of the device (next to the charging port), is an on/off switch. It's recommended to charge with the device being off.
# The charging may take up to 3 hours. ''Footnotes: The reason it takes so long to charge is because the USB spec for computers is limited to 500mA, and the battery size is 1500mAh. Smart charge modules are still quite pricey, so this was a price/user-friendliness tradeoff.''

== Connecting to WiFi ==
The VibHub uses WiFi to communicate. The first time you turn on your device, the status LED (near the USB output ports) will turn a solid blue, indicating that the device is in configuration mode.

Note: You can always enter configuration mode by holding down the configuration button (next to the USB charge port) until the status LED turns blue.

# Use a phone, laptop, or other WiFi device and look for networks. Locate the network called VibHub Micro (or similar for your device), and connect to it.
# On a phone, you usually get the popup "this network requires login" or similar, in which case click that button to enter the captive portal. If not, you can manually open a browser and go to http://192.168.4.1
# '''Make note of the device ID''', which is the random letters and numbers in the yellow box. This is your "key" used to grant applications access to your device. Click the device ID to copy it. If you want to deauthorize all applications, you can generate a new device id (see below).
# Click ''Setup'' to configure WiFi.
# The WiFi page lists detected access points. Click the WiFi you want to connect to.
# Enter the WiFi password.
# Press ''Save''. And wait for the device to reboot.
# If the Status LED turns GREEN, you're ready to start using the device! If it turns blue, reconnect to the device WiFi and make sure you entered the correct WiFi credentials.

== Using an App ==
This comes down to the specific app you'll want to use. But in general, most apps will provide a way to enter your device ID, (and often a minimum value).

=== Socket Demo ===
If you just want to quickly test if your device works, try the socket demo: https://jasxsl.github.io/VibHub-SocketDemo/

# Paste your device ID into the text box. When connected, some sliders will be shown. ''Note: The VibHub cannot be used by an app while in WiFi configuration mode (blue LED).''
# Drag the first two sliders up to max. You should see the blue LEDs on the USB vibrator ports on your device light up (and any vibrator plugged in will start moving).
# Pressing "send pulse" sends a pulse program.
# Pressing "Get Battery" gets a battery voltage reading (if supported).

== Reconfiguring ==

# To reconfigure your device. Turn it on first. Then long-press the config button until the status LED turns a solid blue.
# Connect again via WiFi (see first steps).

=== Change device ID ===
''Note: Changing device ID will de-authorize all apps that have access to your device.''

# After entering the configuration portal, press New Normal ID to replace your current ID
# You can also choose to generate a secure ID. A secure ID is longer and mixes upper and lower case characters.

=== Factory Reset ===
Factory reset will reset all configuration, including WiFi settings and your device ID. This can be useful if you intend to sell or give your device away and want to reset any personal information.

# To perform a factory reset, turn your device off, then hold the config button while starting it. The status LED will flash RED. Upon performing a factory reset, the device will automatically enter WiFi configuration mode when started.

=== Custom Server ===
VibHub is fully open source, so if you want to host your own server, you absolutely can (install instructions here: https://github.com/JasXSL/VibHub-Server/)! Or maybe you just want to connect to someone else's server.

# In config mode, click Setup.
# At the bottom of the page, enter server host and server port. Do ''not'' use http or https:// etc in the server host, just the domain.

== Status indicator ==
The status LED is located toward the USB output ports (where you plug in vibrators).
{| class="wikitable"
|+
!Color
!Status
|-
|Solid Blue
|Device is in WiFi Configuration mode. You can connect to it via WiFi, and configure it at http://192.168.4.1
|-
|Solid Green
|Device is connected and operational!
|-
|Slow flashing green/yellow
|Device is connected and operational, but battery is low.
|-
|Flashing blue/red
|WiFi error, try restarting or reconfiguring.
|-
|Flashign red/green
|Socket error, check if your server (usually vibhub.io) is up?
|-
|Cyan
|Connecting...
|-
|Slow red blink
|Disconnected from server.
|-
|Pink Flash
|A websocket app has connected to our device.
|}

User Manual

2026-02-04T12:14:09Z

Jasx:

VibHub is an open source, open hardware vibrator controller. It allows you to turn any non-battery-driven USB vibrator into a smart internet capable one, supporting 2 ports for the VibHub micro, and 4 ports for the classic 4xAA version. This manual is focused on the newer VibHub Micro version, but a lot of what's written here is also true for the older 4x AA version.

=== WARNING ===

* The VibHub USB output ports are ONLY for powering motors or similar simple devices such as lights. '''DO NOT USE THEM TO CHARGE COMPLEX DEVICES, OR YOU MAY CAUSE DAMAGE TO THEM!'''

== First steps ==
* Your device may arrive uncharged or with low charge. Plug the USB port into a charger. A red LED will light up. On charge completion, a green or blue LED will light up next to the charge port.
* On the side of the device (next to the charging port), is an on/off switch. It's recommended to charge with the device being off.
* The charging may take up to 3 hours. ''Footnotes: The reason it takes so long to charge is because the USB spec for computers is limited to 500mA, and the battery size is 1500mAh. Smart charge modules are still quite pricey, so this was a price/user-friendliness tradeoff.''

== Connecting to WiFi ==
The VibHub uses WiFi to communicate. The first time you turn on your device, the status LED (near the USB output ports) will turn a solid blue, indicating that the device is in configuration mode.

Note: You can always enter configuration mode by holding down the configuration button (next to the USB charge port) until the status LED turns blue.

* Use a phone, laptop, or other WiFi device and look for networks. Locate the network called VibHub Micro (or similar for your device), and connect to it.
* On a phone, you usually get the popup "this network requires login" or similar, in which case click that button to enter the captive portal. If not, you can manually open a browser and go to http://192.168.4.1
* '''Make note of the device ID''', which is the random letters and numbers in the yellow box. This is your "key" used to grant applications access to your device. Click the device ID to copy it. If you want to deauthorize all applications, you can generate a new device id (see below).
* Click ''Setup'' to configure WiFi.
* The WiFi page lists detected access points. Click the WiFi you want to connect to.
* Enter the WiFi password.
* Press ''Save''. And wait for the device to reboot.
* If the Status LED turns GREEN, you're ready to start using the device! If it turns blue, reconnect to the device WiFi and make sure you entered the correct WiFi credentials.

== Using an App ==
This comes down to the specific app you'll want to use. But in general, most apps will provide a way to enter your device ID, (and often a minimum value).

=== Socket Demo ===
If you just want to quickly test if your device works, try the socket demo: https://jasxsl.github.io/VibHub-SocketDemo/

* Paste your device ID into the text box. When connected, some sliders will be shown. ''Note: The VibHub cannot be used by an app while in WiFi configuration mode (blue LED).''
* Drag the first two sliders up to max. You should see the blue LEDs on the USB vibrator ports on your device light up (and any vibrator plugged in will start moving).
* Pressing "send pulse" sends a pulse program.
* Pressing "Get Battery" gets a battery voltage reading (if supported).

== Reconfiguring ==

* To reconfigure your device. Turn it on first. Then long-press the config button until the status LED turns a solid blue.
* Connect again via WiFi (see first steps).

=== Change device ID ===
''Note: Changing device ID will de-authorize all apps that have access to your device.''

* After entering the configuration portal, press New Normal ID to replace your current ID
* You can also choose to generate a secure ID. A secure ID is longer and mixes upper and lower case characters.

=== Factory Reset ===
Factory reset will reset all configuration, including WiFi settings and your device ID. This can be useful if you intend to sell or give your device away and want to reset any personal information.

To perform a factory reset, turn your device off, then hold the config button while starting it. The status LED will flash RED. Upon performing a factory reset, the device will automatically enter WiFi configuration mode when started.

=== Custom Server ===

User Manual

2026-02-04T11:29:43Z

Jasx: Created page with "VibHub is an open source, open hardware vibrator controller. It allows you to turn any non-battery-driven USB vibrator into a smart internet capable one, supporting 2 ports for the VibHub micro, and 4 ports for the classic 4xAA version. This manual is focused on the newer VibHub Micro version, but a lot of what's written here is also true for the older 4x AA version. === WARNING === * The VibHub USB output ports are ONLY for powering motors or similar simple devices su..."

Main Page

2026-02-04T11:06:52Z

Jasx:

If you're a user rather than a dev, you may be interested in a [[User Manual]]!

Welcome to the VibHub wiki! Before we start, let's go over some terms:
{| class="wikitable"
!Term
!Explanation
|-
|[[Firmware|Device]]
|This is the physical hardware VibHub, and also refers to the firmware.
|-
|[[App]]
|The code that sends vibration instructions to the Device. This is likely what you're here for! See the API documentation below!
|-
|[[Server]]
|This is the server that relays messages between the Device and the App. You can host your own!
|-
|deviceID
|A unique ID for each Device that allows the App to communicate with it
|}

== Source Code ==
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|-
|[https://github.com/JasXSL/VibHub-Server VibHub Server]
|Host your own VibHub server!
|-
|[https://github.com/JasXSL/VibHub-Browser VibHub Browser]
|Official JS client library. See [[VibHub-Browser]] for documentation.
|-
|[https://github.com/JasXSL/SL-XOBJ/blob/master/xobj_core/classes/jas%20VibHub.lsl XOBJ SL Library]
|Second Life library built on the XOBJ framework
|-
|[https://github.com/JasXSL/VibHub-SocketDemo Browser Example]
|Example browser app that lets you run VibHub locally with just a few lines of code!
|}

== API ==
{| class="wikitable"
|+
!API Type
!Description
|-
|[[REST]]
|Lets you send vibration programs to a device through simple HTTP requests.
|-
|[[Web Sockets]]
|Much faster than REST requests, recommended if your platform supports it!
|-
|[[Tasks|Tasks Reference]]
|Tasks that your device can handle.
|}

REST

2026-01-29T16:50:41Z

Jasx: /* vib */

The REST API allows you to send a set of tween instructions to a device. This is a good option if you want to send fewer requests that execute a program of pulses, turning on and off etc, or your platform can't do websockets.

To send a program to a device, simply send a GET request to: <code><nowiki>https://vibhub.io/api?id=</nowiki><device_id>&type=<type>&data=<json_data_here></code>

(HTTP is also accepted but should only be used if your app can't use SSL)

Query params explained:
{| class="wikitable"
!Param
!Type
!Explanation
|-
|id
|string
|The deviceID you want to run the program on
|-
|type
|string
|The task to send. See Tasks below.
|-
|data
|varies
|Depends on the type, see below.
|}
Don't forget to URL encode.

= Types =

=== vib ===
The "vib" task expects data to be a URL encoded array of objects with the following params:
{| class="wikitable"
!Param
!Default
!Required
!Type
!Explanation
|-
|stages
|N/A
|Yes
|Array
|An array of stage objects to be tweened beetween. See below for stage objects
|-
|repeats
|0
|No
|integer
|Nr times the animation should repeat. 0 plays it once, 1 plays it twice etc. Use -1 for infinity
|-
|port
|0
|No
|integer
|Bitwise combination of ports to run the program on. 0x1 is the first port, 0x2 second and so forth. 0 or negative values will target ALL ports.
|-
|highres
|false
|No
|boolean
|When set, we will use all supported bits in the program. Check the "h" response in whois for max nr of bits the device supports.
|}

=== Stages ===
The stage is an object containing tweening information for that stage of the program. It has the following properties:
{| class="wikitable"
!Param
!Default
!Type
!Explanation
|-
|i
|0
|integer/obj/boolean
|A value between 0 and 255. Higher value = faster vibrations. Or false to use the previous value. Or a RandObject (see below).
|-
|d
|0
|integer/obj
|Time in milliseconds to reach specified intensity. 0 = instant. Or a RandObject (see below).
|-
|e
|"Linear.None"
|string
|A string denoting the tween.js easing type. See this example for the supported types.
|-
|r
|0
|integer/object
|Repeats. 0 = play this stage once, 1 = play this stage twice and so forth. Or a RandObject (see below)
|-
|y
|false
|boolean/truthy/falsy value
|Go back and forth. Requires repeats to work. Repeats of 1 goes back and forth once, repeats of 3 goes back and forth twice etc. An even number such as 2 will go forth, back, forth, and then start at forth on the next stage.
|}

=== RandObject ===
A RandObject can be used in certain places of a vib call. It'll generate a random value. This value will be randomized at the start of each program loop, but not program stage loop.
{| class="wikitable"
!Param
!Default
!Type
!Explanation
|-
|min
|0
|integer
|Min value to randomize
|-
|max
|varying
|integer
|Max value to randomize. The default value for this depends on the stage param you put it in. i=255, d=10000, r=9
|-
|offset
|0
|integer
|Adds an offset to the randomly generated value. Useful in yoyo type steps where you always want an odd number of repeats (combine with multi of 2).
|-
|multi
|1
|integer
|Multiplies the random value by this. Useful together with offset to generate pulses going up and down n times
|}
Example:

<code>{"min":0, "max":3, "offset":1, "multi":2}</code>

This is useful in repeats with yoyo, as it always generates an odd number. In practice, the above line means "generate 1-4 pulses."

=== Examples ===
Run a program on device id "JasTestBullet". The program resets the vibration level to 0, then goes up to 50% and down again 3 times, then resets back to 0.
Request:

<code>GET <nowiki>https://vibhub.io/api/?id=JasTestBullet&type=vib&data=</nowiki>[{"stages":[{"i":0,"d":0},{"i":50,"d":500,"r":5,"y":1},{"i":0,"d":0}]}]</code>

Response:

<code>{"message":"OK","success":true}</code>

== whois ==
Lets you get meta information about a connected device:

=== Examples ===
Request:
<code>GET <nowiki>https://vibhub.io/api/?id=JasTestBullet&type=whois&data=</nowiki>[]</code>

Response:

<code><nowiki>{"message":{"numPorts":4,"version":"0.3.0","hwversion":"esp32","custom":"","capabilities":{"p":true,"ps":true,"vib":"true"}},"success":true}</nowiki></code>

VibHub-Browser

2026-01-29T13:16:00Z

Jasx:

The library can be cloned from [https://github.com/JasXSL/VibHub-Browser here].

=== Setup ===
Start by importing the library:

<code>import {default as VH, VhProgram as Program, VhStage as Stage} from 'vh-socket.js';</code>

Next you'll want to extend VH with a class of your own.

<code>class App extends VH{</code>

Constructor:<pre>
constructor(...args){
super(...args);
}
</pre>All done for our VibHub manager class! Let's set all ports on our device to max!<pre>
(async () => {
const manager = new App();
manager.onDeviceOnline = function(device){
device.set(1); // Sets all ports on the device to max intensity
};
await manager.addDevice("<your device ID>");
})();
</pre>

== VhSocket ==
VhSocket is the main vibhub manager, allowing you to manage multiple devices from your app!

Versions:

* m - 2026 VibHub Micro
* o - Original VibHub 4x AA battery version.

=== Overridable ===
These methods are meant to be overridden by your extended class or on the fly.
{| class="wikitable"
|+
!Method
!Versions
!Args
!Async
!Description
|-
|onDeviceOnline
|m,o
|VhDevice device
|
|Raised when a device has come online.
|-
|onDeviceOffline
|m,o
|VhDevice device
|
|Raised when a device has gone offline.
|-
|onDeviceBattery
|m
|VhDevice device
|
|Battery status has been updated
|-
|onCustomMessage
|m
|string device_ID, string socket_ID, var data
|
|Raised when a custom message has been received (advanced).
|-
|onConnected
|m,o
|
|
|Raised when the app itself has connected to a VibHub server.
|-
|onDisconnected
|m,o
|
|
|Raised when the app itself has disconnected from the VibHub server.
|-
|onTick
|m,o
|
|
|Raised n times per second (based on what you passed to constructor).
|}

=== Methods ===
{| class="wikitable"
!Method
!Versions
!Args
!Returns
!Async
!Description
|-
|constructor
|m,o
|string appName, string server = "https://vibhub.io", int port = 443, int fps = 30, bool autoHighRes
|VhSocket
|
|Library constructor.
- appName can be anything you'd like to call your app (mainly used for debugging.
- server is the server to connect to.
- port is the port (hurdur). Usually 443 (SSL) or 80
- fps sets a max limit on how often we can send messages to the device. I don't recommend setting this to more than 60.
- autoHighRes tries to automatically enable High Res mode if the device supports it. High Res gives you more granular control.
|-
|begin
|m,o
|
|this
|Yes
|Starts the app, connecting via socket.io and binding events.
|-
|isConnected
|m,o
|
|bool
|
|Returns true if we're connected to the server.
|-
|setName
|m,o
|
|bool
|Yes
|Sends the app name to the server (auto handled in begin). Returns true on success.
|-
|handleNewIndex
|m,o
|array devices
|
|Yes
|Internal handler for the server refreshing our managed devices.
|-
|handleDeviceOnline
|m,o
|array data
|
|
|Internal handler for device data received. Data is an array of: string id, string socketID, var metadata
|-
|handleDeviceOffline
|m,o
|data
|
|
|Internal handler for device disconnect. Data is an array of: string id
|-
|handleDeviceBattery
|m
|data
|
|
|Internal handler for device battery updates. Data is an object with {string id, bool batteryLow, int mv(millivolts), int xv(max millivolts)}
|-
|addDevice
|m,o
|string deviceID
|VhDevice device
|Yes
|Requires an active connection. Tells the server that you want permissions to manage this device by id. Permissions are NOT lost if the device disconnects and reconnects. Permissions ARE lost if your app disconnects.
|-
|remDevice
|m,o
|VhDevice device
|
|Yes
|Requires an active connection. Tells the server that you no longer want to manage a device. Note that devices are automatically disowned when you disconnect the app. But it's good practice to call this if you want to swap devices.
|-
|wipeDevices
|m,o
|
|
|Yes
|Removes all devices from your app.
|-
|getDevice
|m,o
|string deviceID
|VhDevice device OR undefined
|
|Gets a maintained device by ID if it exists, otherwise returns false.
|-
|sendPWM
|m,o
|VhDevice device
|
|
|Updates the vibration value of a device. Use VhDevice set (listed below) instead, as it automatically prevents overloading the device with too many requests.
|-
|sendSingleChannelPWM
|m,o
|VhDevice device, int channel...
|
|
|Same as sendPWM but for specific ports. Use VhDevice set instead.
|-
|sendProgram
|m,o
|VhDevice device, VhProgram program
|
|
|Sends a program. Use VhDevice sendProgram instead.
|-
|getBattery
|m
|VhDevice device
|
|
|Requests a battery update. Use VhDevice getBattery instead. If successful, the onDeviceBattery event will be raised.
|-
|sendCustomMessage
|m
|VhDevice device, var data
|
|
|Emits a dCustom event (advanced).
|-
|tick
|m,o
|
|
|
|Used internally to rate-limit updates and prevent overloading your device with requests.
|-
|_addScript
|m,o
|
|
|
|Used internally to make sure socket.io exists in the browser.
|}

== VhDevice ==
A VhDevice is an object representation of a physical device (your VibHub).

Capability names:

* p : PWM batch updates (all devices support this)
* ps : PWM specific port updates (all devices support this)
* ph : PWM specific high res updates
* vib : REST programs over websockets (all devices support this)
* sb : Battery status updates
* app_offline : The device can tell when the app disconnects
* dCustom : Can handle custom tasks from app
* aCustom : Can send custom data to app
* h : int, how many bits the device supports in high res mode. Usually 10 if high res is supported.

{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|string deviceId, VhSocket parent
|VhDevice
|
|Constructor. Do not call this directly, use addDevice in VhSocket instead.
|-
|setHighRes
|bool on
|this
|
|Toggles high res mode. In high res mode you gain more granularity to your controls (if your device supports it). Note that you can enable autoHighRes in the VhSocket constructor to automatically manage high res. The only drawback to high res is that you need to send a bit more data.
|-
|isHighRes
|
|bool isHighres
|
|Returns true if your device supports high res. Note that the device must be connected first.
|-
|loadMeta
|obj data
|
|
|Used internally to load device metadata. Currently supports:
- string version: Firmware Version
- string custom: Custom data (only used if you customize your firmware)
- string hwversion: Hardware info
- obj capabilities: See Capabilities above
|-
|getChannelval
|int channel
|int val
|
|Used internally to recalculate a float intensity to an integer based on supported device resolution.
|-
|calcMinPwm
|float input
|float output
|
|Used internally to convert a 0-1 value to a range where 0 is where the device just starts to spin, and 1 being max power.
|-
|hasCapPwmBasic
|
|boolean has
|
|Check if device has this capability
|-
|hasCapPwmSpecific
|
|boolean has
|
|Check if device has this capability
|-
|hasCapPrograms
|
|boolean has
|
|Check if device has this capability
|-
|hasCapOffline
|
|boolean has
|
|Check if device has this capability
|-
|hasCustomToDevice
|
|boolean has
|
|Check if device has this capability
|-
|hasCustomToApp
|
|boolean has
|
|Check if device has this capability
|-
|hasBatteryStatus
|
|boolean has
|
|Check if device has this capability
|-
|getHiResBits
|
|int bits
|
|Returns nr bits the device supports for updates.
|-
|getCapabilityNames
|
|array names
|
|Returns a readable array of capability names for the device.
|-
|sendPWM
|
|
|
|Used internally to update the PWM. Use set instead of this.
|-
|sendSingleChannelPWM
|channel...
|
|
|Used internally to update single channel PWM. Use set instead of this.
|-
|sendProgram
|VhProgram program
|
|
|Send a [[REST]] program to run on the device.
|-
|getBattery
|
|
|
|Attempts to fetch battery status. On success, the VhSocket event onDeviceBattery will be raised.
|-
|changed
|bool stash
|
|
|Used internally to prevent messages from being sent each frame if changes have been detected.
|-
|stashChange
|
|
|
|Used internally.
|-
|set
|float val, int channel = -1
|
|
|Sets PWM (vibration intensity) between 0 and 1. If channel is less than 0, all channels will be affected. Otherwise only the specified channel.
|-
|setMinPwm
|amt = 0
|
|
|Sets a minimum value for the device turning on. This is useful since many vibrators don't turn on until 60% power or so. To get this value, keep min PWM to 0 and slowly crank up the intensity until it starts vibrating. Then use that value for 0.
|-
|remove
|
|
|yes
|Removes this device from the parent VhSocket
|}

== VhProgram ==
VhProgram lets you build REST type programs to send to the device. Programs are beneficial if you want to send things like pulses, or ramp vibrations up/down instead of having direct input control.
{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|array ports/int port, repeats = 0
|VhProgram
|
|Ports: Ports to run program on (0 indexed). Can also be an integer to control 1 port.
Repeats: Nr repeats. Use -1 for infinity.
|-
|setPorts
|array ports/int port
|
|
|Lets you change the ports on the fly. Useful if you want to reuse programs.
|-
|addStage
|VhStage ...
|
|
|Add one or more VhStage objects to the program.
|-
|export
|VhDevice device
|object data
|
|Flattens the program into a generic object, with values automatically converted to integers based on device min PWM and high res capabilities.
|}

== VhStage ==
VhStage describes a program stage, setting a value at time.

* Supported easing types: In, Out, InOut, None.
* Supported easing algorithms: Linear, Sine, Quad, Cubic, Quart, Quint, Back, Bounce, Circular, Elastic, Exponential, None.

{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|obj settings
|VhStage
|
|Settings object supports the following keys:
- float intensity: A value between 0 and 1. OR a VhRandObject.
- int duration : Duration in milliseconds. OR a VhRandObject.
- string easing : Easing method. Default "Linear.None"
- int repeats : Nr of times to repeat this stage. OR a VhRandObject.
- bool yoyo : Requires repeats. Makes repeats alternate back and forth.
|-
|exportFloatOrRand
|var value, VhDevice device
|obj randObj OR float
|
|Used internally when flattening to a generic object.
|-
|export
|VhDevice device
|obj data
|
|Flattens the stage into a generic object.
|}

== VhRandObject ==
VhRandObject can be used in a VhStage to add randomness to intensity, duration, and/or repeats.
{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|obj settings
|VhRandObject
|
|Settings object supports the following keys:
- float min: A value between 0 and 1

- float max: A value between 0 and 1

- bool absolute: When true, the min/max values won't be adjusted based on device min val and resolution. Useful for repeats.

- int offset: Primarily used with yoyo and multi.

- int multi: Primarily used with program repeats with yoyo. Multiplies the output value. Such as if you wanted yoyo back and forth 1-3 times you'd set absolute to true, multi to 2, min to 0, max to 2, and offset to 1.
|-
|exportFloatOrRand
|var value, VhDevice device
|obj randObj OR float
|
|Used internally when flattening to a generic object.
|-
|export
|VhDevice device
|obj data
|
|Flattens the stage into a generic object.
|}

Server

2026-01-29T13:12:51Z

Jasx: Created page with "The VibHub server acts as a relay between an App and a Device. The official server is written using vanilla NodeJS, and the source code can be found at https://github.com/JasXSL/VibHub-Server"

The VibHub server acts as a relay between an [[App]] and a [[Device]]. The official server is written using vanilla NodeJS, and the source code can be found at https://github.com/JasXSL/VibHub-Server

App

2026-01-29T13:10:08Z

Jasx: Created page with "An app is basically a controller application for one or more VibHub Devices. Such as a website or Second Life relay. Generally, VibHub communication goes User Input -> App -> Server -> Device. VibHub currently has two methods of interfacing an App with the server: REST and Websockets. Websockets is faster and generally the go-to. But if your application can't handle that, and you're fine with less frequent updates, the REST API..."

An app is basically a controller application for one or more VibHub [[Device|Devices]]. Such as a website or Second Life relay.

Generally, VibHub communication goes User Input -> App -> [[Server]] -> [[Device]].

VibHub currently has two methods of interfacing an App with the server: [[REST]] and [[VibHub-Browser|Websockets]]. Websockets is faster and generally the go-to. But if your application can't handle that, and you're fine with less frequent updates, the REST API is very easy to use!

VibHub-Browser

2026-01-29T13:06:51Z

Jasx:

The library can be cloned from [https://github.com/JasXSL/VibHub-Browser here].

=== Setup ===
Start by importing the library:

<code>import {default as VH, VhProgram as Program, VhStage as Stage} from 'vh-socket.js';</code>

Next you'll want to extend VH with a class of your own.

<code>class App extends VH{</code>

Constructor:<pre>
constructor(...args){
super(...args);
}
</pre>All done for our VibHub manager class! Let's set all ports on our device to max!<pre>
(async () => {
const manager = new App();
manager.onDeviceOnline = function(device){
device.set(1); // Sets all ports on the device to max intensity
};
await manager.addDevice("<your device ID>");
})();
</pre>

== VhSocket ==
VhSocket is the main vibhub manager, allowing you to manage multiple devices from your app!

Versions:

* m - 2026 VibHub Micro
* o - Original VibHub 4x AA battery version.

=== Overridable ===
These methods are meant to be overridden by your extended class or on the fly.
{| class="wikitable"
|+
!Method
!Versions
!Args
!Async
!Description
|-
|onDeviceOnline
|m,o
|VhDevice device
|
|Raised when a device has come online.
|-
|onDeviceOffline
|m,o
|VhDevice device
|
|Raised when a device has gone offline.
|-
|onDeviceBattery
|m
|VhDevice device
|
|Battery status has been updated
|-
|onCustomMessage
|m
|string device_ID, string socket_ID, var data
|
|Raised when a custom message has been received (advanced).
|-
|onConnected
|m,o
|
|
|Raised when the app itself has connected to a VibHub server.
|-
|onDisconnected
|m,o
|
|
|Raised when the app itself has disconnected from the VibHub server.
|-
|onTick
|m,o
|
|
|Raised n times per second (based on what you passed to constructor).
|}

=== Methods ===
{| class="wikitable"
!Method
!Versions
!Args
!Returns
!Async
!Description
|-
|constructor
|m,o
|string appName, string server = "https://vibhub.io", int port = 443, int fps = 30, bool autoHighRes
|VhSocket
|
|Library constructor.
- appName can be anything you'd like to call your app (mainly used for debugging.
- server is the server to connect to.
- port is the port (hurdur). Usually 443 (SSL) or 80
- fps sets a max limit on how often we can send messages to the device. I don't recommend setting this to more than 60.
- autoHighRes tries to automatically enable High Res mode if the device supports it. High Res gives you more granular control.
|-
|begin
|m,o
|
|this
|Yes
|Starts the app, connecting via socket.io and binding events.
|-
|isConnected
|m,o
|
|bool
|
|Returns true if we're connected to the server.
|-
|setName
|m,o
|
|bool
|Yes
|Sends the app name to the server (auto handled in begin). Returns true on success.
|-
|handleNewIndex
|m,o
|array devices
|
|Yes
|Internal handler for the server refreshing our managed devices.
|-
|handleDeviceOnline
|m,o
|array data
|
|
|Internal handler for device data received. Data is an array of: string id, string socketID, var metadata
|-
|handleDeviceOffline
|m,o
|data
|
|
|Internal handler for device disconnect. Data is an array of: string id
|-
|handleDeviceBattery
|m
|data
|
|
|Internal handler for device battery updates. Data is an object with {string id, bool batteryLow, int mv(millivolts), int xv(max millivolts)}
|-
|addDevice
|m,o
|string deviceID
|VhDevice device
|Yes
|Requires an active connection. Tells the server that you want permissions to manage this device by id. Permissions are NOT lost if the device disconnects and reconnects. Permissions ARE lost if your app disconnects.
|-
|remDevice
|m,o
|VhDevice device
|
|Yes
|Requires an active connection. Tells the server that you no longer want to manage a device. Note that devices are automatically disowned when you disconnect the app. But it's good practice to call this if you want to swap devices.
|-
|wipeDevices
|m,o
|
|
|Yes
|Removes all devices from your app.
|-
|getDevice
|m,o
|string deviceID
|VhDevice device OR undefined
|
|Gets a maintained device by ID if it exists, otherwise returns false.
|-
|sendPWM
|m,o
|VhDevice device
|
|
|Updates the vibration value of a device. Use VhDevice set (listed below) instead, as it automatically prevents overloading the device with too many requests.
|-
|sendSingleChannelPWM
|m,o
|VhDevice device, int channel...
|
|
|Same as sendPWM but for specific ports. Use VhDevice set instead.
|-
|sendProgram
|m,o
|VhDevice device, VhProgram program
|
|
|Sends a program. Use VhDevice sendProgram instead.
|-
|getBattery
|m
|VhDevice device
|
|
|Requests a battery update. Use VhDevice getBattery instead. If successful, the onDeviceBattery event will be raised.
|-
|sendCustomMessage
|m
|VhDevice device, var data
|
|
|Emits a dCustom event (advanced).
|-
|tick
|m,o
|
|
|
|Used internally to rate-limit updates and prevent overloading your device with requests.
|-
|_addScript
|m,o
|
|
|
|Used internally to make sure socket.io exists in the browser.
|}

== VhDevice ==
A VhDevice is an object representation of a physical device (your VibHub).

Capability names:

* p : PWM batch updates (all devices support this)
* ps : PWM specific port updates (all devices support this)
* ph : PWM specific high res updates
* vib : REST programs over websockets (all devices support this)
* sb : Battery status updates
* app_offline : The device can tell when the app disconnects
* dCustom : Can handle custom tasks from app
* aCustom : Can send custom data to app
* h : int, how many bits the device supports in high res mode. Usually 10 if high res is supported.

{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|string deviceId, VhSocket parent
|VhDevice
|
|Constructor. Do not call this directly, use addDevice in VhSocket instead.
|-
|setHighRes
|bool on
|this
|
|Toggles high res mode. In high res mode you gain more granularity to your controls (if your device supports it). Note that you can enable autoHighRes in the VhSocket constructor to automatically manage high res. The only drawback to high res is that you need to send a bit more data.
|-
|isHighRes
|
|bool isHighres
|
|Returns true if your device supports high res. Note that the device must be connected first.
|-
|loadMeta
|obj data
|
|
|Used internally to load device metadata. Currently supports:
- string version: Firmware Version
- string custom: Custom data (only used if you customize your firmware)
- string hwversion: Hardware info
- obj capabilities: See Capabilities above
|-
|getChannelval
|int channel
|int val
|
|Used internally to recalculate a float intensity to an integer based on supported device resolution.
|-
|calcMinPwm
|float input
|float output
|
|Used internally to convert a 0-1 value to a range where 0 is where the device just starts to spin, and 1 being max power.
|-
|hasCapPwmBasic
|
|boolean has
|
|Check if device has this capability
|-
|hasCapPwmSpecific
|
|boolean has
|
|Check if device has this capability
|-
|hasCapPrograms
|
|boolean has
|
|Check if device has this capability
|-
|hasCapOffline
|
|boolean has
|
|Check if device has this capability
|-
|hasCustomToDevice
|
|boolean has
|
|Check if device has this capability
|-
|hasCustomToApp
|
|boolean has
|
|Check if device has this capability
|-
|hasBatteryStatus
|
|boolean has
|
|Check if device has this capability
|-
|getHiResBits
|
|int bits
|
|Returns nr bits the device supports for updates.
|-
|getCapabilityNames
|
|array names
|
|Returns a readable array of capability names for the device.
|-
|sendPWM
|
|
|
|Used internally to update the PWM. Use set instead of this.
|-
|sendSingleChannelPWM
|channel...
|
|
|Used internally to update single channel PWM. Use set instead of this.
|-
|sendProgram
|VhProgram program
|
|
|Send a [[REST]] program to run on the device.
|-
|getBattery
|
|
|
|Attempts to fetch battery status. On success, the VhSocket event onDeviceBattery will be raised.
|-
|changed
|bool stash
|
|
|Used internally to prevent messages from being sent each frame if changes have been detected.
|-
|stashChange
|
|
|
|Used internally.
|-
|set
|float val, int channel = -1
|
|
|Sets PWM (vibration intensity) between 0 and 1. If channel is less than 0, all channels will be affected. Otherwise only the specified channel.
|-
|setMinPwm
|amt = 0
|
|
|Sets a minimum value for the device turning on. This is useful since many vibrators don't turn on until 60% power or so. To get this value, keep min PWM to 0 and slowly crank up the intensity until it starts vibrating. Then use that value for 0.
|-
|remove
|
|
|yes
|Removes this device from the parent VhSocket
|}

== VhProgram ==
VhProgram lets you build REST type programs to send to the device. Programs are beneficial if you want to send things like pulses, or ramp vibrations up/down instead of having direct input control.
{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|array ports/int port, repeats = 0
|VhProgram
|
|Ports: Ports to run program on (0 indexed). Can also be an integer to control 1 port.
Repeats: Nr repeats. Use -1 for infinity.
|-
|setPorts
|array ports/int port
|
|
|Lets you change the ports on the fly. Useful if you want to reuse programs.
|-
|addStage
|VhStage ...
|
|
|Add one or more VhStage objects to the program.
|-
|export
|VhDevice device
|object data
|
|Flattens the program into a generic object, with values automatically converted to integers based on device min PWM and high res capabilities.
|}

== VhStage ==
VhStage describes a program stage, setting a value at time.

* Supported easing types: In, Out, InOut, None.
* Supported easing algorithms: Linear, Sine, Quad, Cubic, Quart, Quint, Back, Bounce, Circular, Elastic, Exponential, None.

{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|obj settings
|VhStage
|
|Settings object supports the following keys:
- float intensity: A value between 0 and 1. OR a VhRandObject.
- int duration : Duration in milliseconds. OR a VhRandObject.
- string easing : Easing method. Default "Linear.None"
- int repeats : Nr of times to repeat this stage. OR a VhRandObject.
- bool yoyo : Requires repeats. Makes repeats alternate back and forth.
|-
|exportFloatOrRand
|var value, VhDevice device
|obj randObj OR float
|
|Used internally when flattening to a generic object.
|-
|export
|VhDevice device
|obj data
|
|Flattens the stage into a generic object.
|}

== VhRandObject ==
VhRandObject can be used in a VhStage to add randomness to intensity, duration, and/or repeats.
{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|obj settings
|VhRandObject
|
|Settings object supports the following keys:
- float min: A value between 0 and 1

- float max: A value between 0 and 1

- bool absolute: When true, the min/max values won't be adjusted based on device min val and resolution. Useful for repeats.

- int offset: This is added to the random value. Legacy feature.

- int multi: Primarily used with program repeats with yoyo. Multiplies the output value. Such as if you wanted yoyo back and forth 1-3 times you'd set absolute to true, multi to 2, min to 0 and max to 2.
|-
|exportFloatOrRand
|var value, VhDevice device
|obj randObj OR float
|
|Used internally when flattening to a generic object.
|-
|export
|VhDevice device
|obj data
|
|Flattens the stage into a generic object.
|}

Firmware

2026-01-29T13:01:59Z

Jasx: Created page with "Currently you can locate the firmware here: {| class="wikitable" !Name/Link !Description |- |[https://github.com/JasXSL/VibHub-Micro VibHub Micro] |2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery! |- |[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32] |4xAA Version of the VibHub |} == File Breakdown == {| class="wikitable" |+ !File !Description |- |ApiClient |Handles messages received from VhWifi |- |BatteryReader..."

Currently you can locate the firmware here:
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|}

== File Breakdown ==
{| class="wikitable"
|+
!File
!Description
|-
|ApiClient
|Handles messages received from VhWifi
|-
|BatteryReader
|Used to get approx battery status.
|-
|ConfigButton
|Handles the configuration button.
|-
|Configuration
|Main configuration file for each device model.
|-
|Motor
|Handles PWM for the USB outputs.
|-
|StatusLED
|Handles the status RGB LED.
|-
|TweenEasing
|Easing algorithms for programs.
|-
|TweenProgram
|Manages programs received.
|-
|TweenProgramStage
|Manages program stages.
|-
|TweenRandObject
|Manages random objects.
|-
|UserSettings
|Manages settings set during operation via the web portal.
|-
|VhSerial
|Manages serial communication.
|-
|VhWifi
|Configures the web portal.
|-
|VibHub-<model>
|Main file to compile, links everything together.
|}

VibHub-Browser

2026-01-29T12:55:12Z

Jasx:

The library can be cloned from [https://github.com/JasXSL/VibHub-Browser here].

=== Setup ===
Start by importing the library:

<code>import {default as VH, VhProgram as Program, VhStage as Stage} from 'vh-socket.js';</code>

Next you'll want to extend VH with a class of your own.

<code>class App extends VH{</code>

Constructor:<pre>
constructor(...args){
super(...args);
}
</pre>All done for our VibHub manager class! Let's set all ports on our device to max!<pre>
(async () => {
const manager = new App();
manager.onDeviceOnline = function(device){
device.set(1); // Sets all ports on the device to max intensity
};
await manager.addDevice("<your device ID>");
})();
</pre>

== VhSocket ==
VhSocket is the main vibhub manager, allowing you to manage multiple devices from your app!

Versions:

* m - 2026 VibHub Micro
* o - Original VibHub 4x AA battery version.

=== Overridable ===
These methods are meant to be overridden by your extended class or on the fly.
{| class="wikitable"
|+
!Method
!Versions
!Args
!Async
!Description
|-
|onDeviceOnline
|m,o
|VhDevice device
|
|Raised when a device has come online.
|-
|onDeviceOffline
|m,o
|VhDevice device
|
|Raised when a device has gone offline.
|-
|onDeviceBattery
|m
|VhDevice device
|
|Battery status has been updated
|-
|onCustomMessage
|m
|string device_ID, string socket_ID, var data
|
|Raised when a custom message has been received (advanced).
|-
|onConnected
|m,o
|
|
|Raised when the app itself has connected to a VibHub server.
|-
|onDisconnected
|m,o
|
|
|Raised when the app itself has disconnected from the VibHub server.
|-
|onTick
|m,o
|
|
|Raised n times per second (based on what you passed to constructor).
|}

=== Methods ===
{| class="wikitable"
!Method
!Versions
!Args
!Returns
!Async
!Description
|-
|constructor
|m,o
|string appName, string server = "https://vibhub.io", int port = 443, int fps = 30, bool autoHighRes
|VhSocket
|
|Library constructor.
- appName can be anything you'd like to call your app (mainly used for debugging.
- server is the server to connect to.
- port is the port (hurdur). Usually 443 (SSL) or 80
- fps sets a max limit on how often we can send messages to the device. I don't recommend setting this to more than 60.
- autoHighRes tries to automatically enable High Res mode if the device supports it. High Res gives you more granular control.
|-
|begin
|m,o
|
|this
|Yes
|Starts the app, connecting via socket.io and binding events.
|-
|isConnected
|m,o
|
|bool
|
|Returns true if we're connected to the server.
|-
|setName
|m,o
|
|bool
|Yes
|Sends the app name to the server (auto handled in begin). Returns true on success.
|-
|handleNewIndex
|m,o
|array devices
|
|Yes
|Internal handler for the server refreshing our managed devices.
|-
|handleDeviceOnline
|m,o
|array data
|
|
|Internal handler for device data received. Data is an array of: string id, string socketID, var metadata
|-
|handleDeviceOffline
|m,o
|data
|
|
|Internal handler for device disconnect. Data is an array of: string id
|-
|handleDeviceBattery
|m
|data
|
|
|Internal handler for device battery updates. Data is an object with {string id, bool batteryLow, int mv(millivolts), int xv(max millivolts)}
|-
|addDevice
|m,o
|string deviceID
|VhDevice device
|Yes
|Requires an active connection. Tells the server that you want permissions to manage this device by id. Permissions are NOT lost if the device disconnects and reconnects. Permissions ARE lost if your app disconnects.
|-
|remDevice
|m,o
|VhDevice device
|
|Yes
|Requires an active connection. Tells the server that you no longer want to manage a device. Note that devices are automatically disowned when you disconnect the app. But it's good practice to call this if you want to swap devices.
|-
|wipeDevices
|m,o
|
|
|Yes
|Removes all devices from your app.
|-
|getDevice
|m,o
|string deviceID
|VhDevice device OR undefined
|
|Gets a maintained device by ID if it exists, otherwise returns false.
|-
|sendPWM
|m,o
|VhDevice device
|
|
|Updates the vibration value of a device. Use VhDevice set (listed below) instead, as it automatically prevents overloading the device with too many requests.
|-
|sendSingleChannelPWM
|m,o
|VhDevice device, int channel...
|
|
|Same as sendPWM but for specific ports. Use VhDevice set instead.
|-
|sendProgram
|m,o
|VhDevice device, VhProgram program
|
|
|Sends a program. Use VhDevice sendProgram instead.
|-
|getBattery
|m
|VhDevice device
|
|
|Requests a battery update. Use VhDevice getBattery instead. If successful, the onDeviceBattery event will be raised.
|-
|sendCustomMessage
|m
|VhDevice device, var data
|
|
|Emits a dCustom event (advanced).
|-
|tick
|m,o
|
|
|
|Used internally to rate-limit updates and prevent overloading your device with requests.
|-
|_addScript
|m,o
|
|
|
|Used internally to make sure socket.io exists in the browser.
|}

== VhDevice ==
A VhDevice is an object representation of a physical device (your VibHub).

Capability names:

* p : PWM batch updates (all devices support this)
* ps : PWM specific port updates (all devices support this)
* ph : PWM specific high res updates
* vib : REST programs over websockets (all devices support this)
* sb : Battery status updates
* app_offline : The device can tell when the app disconnects
* dCustom : Can handle custom tasks from app
* aCustom : Can send custom data to app
* h : int, how many bits the device supports in high res mode. Usually 10 if high res is supported.

{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|string deviceId, VhSocket parent
|VhDevice
|
|Constructor. Do not call this directly, use addDevice in VhSocket instead.
|-
|setHighRes
|bool on
|this
|
|Toggles high res mode. In high res mode you gain more granularity to your controls (if your device supports it). Note that you can enable autoHighRes in the VhSocket constructor to automatically manage high res. The only drawback to high res is that you need to send a bit more data.
|-
|isHighRes
|
|bool isHighres
|
|Returns true if your device supports high res. Note that the device must be connected first.
|-
|loadMeta
|obj data
|
|
|Used internally to load device metadata. Currently supports:
- string version: Firmware Version
- string custom: Custom data (only used if you customize your firmware)
- string hwversion: Hardware info
- obj capabilities: See Capabilities above
|-
|getChannelval
|int channel
|int val
|
|Used internally to recalculate a float intensity to an integer based on supported device resolution.
|-
|calcMinPwm
|float input
|float output
|
|Used internally to convert a 0-1 value to a range where 0 is where the device just starts to spin, and 1 being max power.
|-
|hasCapPwmBasic
|
|boolean has
|
|Check if device has this capability
|-
|hasCapPwmSpecific
|
|boolean has
|
|Check if device has this capability
|-
|hasCapPrograms
|
|boolean has
|
|Check if device has this capability
|-
|hasCapOffline
|
|boolean has
|
|Check if device has this capability
|-
|hasCustomToDevice
|
|boolean has
|
|Check if device has this capability
|-
|hasCustomToApp
|
|boolean has
|
|Check if device has this capability
|-
|hasBatteryStatus
|
|boolean has
|
|Check if device has this capability
|-
|getHiResBits
|
|int bits
|
|Returns nr bits the device supports for updates.
|-
|getCapabilityNames
|
|array names
|
|Returns a readable array of capability names for the device.
|-
|sendPWM
|
|
|
|Used internally to update the PWM. Use set instead of this.
|-
|sendSingleChannelPWM
|channel...
|
|
|Used internally to update single channel PWM. Use set instead of this.
|-
|sendProgram
|VhProgram program
|
|
|Send a [[REST]] program to run on the device.
|-
|getBattery
|
|
|
|Attempts to fetch battery status. On success, the VhSocket event onDeviceBattery will be raised.
|-
|changed
|bool stash
|
|
|Used internally to prevent messages from being sent each frame if changes have been detected.
|-
|stashChange
|
|
|
|Used internally.
|-
|set
|float val, int channel = -1
|
|
|Sets PWM (vibration intensity) between 0 and 1. If channel is less than 0, all channels will be affected. Otherwise only the specified channel.
|-
|setMinPwm
|amt = 0
|
|
|Sets a minimum value for the device turning on. This is useful since many vibrators don't turn on until 60% power or so. To get this value, keep min PWM to 0 and slowly crank up the intensity until it starts vibrating. Then use that value for 0.
|-
|remove
|
|
|yes
|Removes this device from the parent VhSocket
|}

== VhProgram ==
VhProgram lets you build REST type programs to send to the device. Programs are beneficial if you want to send things like pulses, or ramp vibrations up/down instead of having direct input control.
{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|array ports/int port, repeats = 0
|VhProgram
|
|Ports: Ports to run program on (0 indexed). Can also be an integer to control 1 port.
Repeats: Nr repeats. Use -1 for infinity.
|-
|setPorts
|array ports/int port
|
|
|Lets you change the ports on the fly. Useful if you want to reuse programs.
|-
|addStage
|VhStage ...
|
|
|Add one or more VhStage objects to the program.
|-
|export
|VhDevice device
|object data
|
|Flattens the program into a generic object, with values automatically converted to integers based on device min PWM and high res capabilities.
|}

== VhStage ==
VhStage describes a program stage, setting a value at time.

* Supported easing types: In, Out, InOut, None.
* Supported easing algorithms: Linear, Sine, Quad, Cubic, Quart, Quint, Back, Bounce, Circular, Elastic, Exponential, None.

{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|obj settings
|VhStage
|
|Settings object supports the following keys:
- float intensity: A value between 0 and 1. OR a VhRandObject.
- int duration : Duration in milliseconds. OR a VhRandObject.
- string easing : Easing method. Default "Linear.None"
- int repeats : Nr of times to repeat this stage. OR a VhRandObject.
- bool yoyo : Requires repeats. Makes repeats alternate back and forth.
|-
|exportFloatOrRand
|var value, VhDevice device
|obj randObj OR float
|
|Used internally when flattening to a generic object.
|-
|export
|VhDevice device
|obj data
|
|Flattens the stage into a generic object.
|}

== VhRandObject ==
VhRandObject can be used in a VhStage to add randomness to intensity, duration, and/or repeats.
{| class="wikitable"
!Method
!Args
!Returns
!Async
!Description
|-
|constructor
|obj settings
|VhRandObject
|
|Settings object supports the following keys:
- float min : A value between 0 and 1
- float max : A value between 0 and 1
|-
|exportFloatOrRand
|var value, VhDevice device
|obj randObj OR float
|
|Used internally when flattening to a generic object.
|-
|export
|VhDevice device
|obj data
|
|Flattens the stage into a generic object.
|}

VibHub-Browser

2026-01-29T12:33:39Z

Jasx:

VibHub-Browser

2026-01-29T12:09:59Z

Jasx:

VibHub-Browser

2026-01-29T11:58:16Z

Jasx:

VibHub-Browser

2026-01-29T11:39:07Z

Jasx:

Tasks

2026-01-29T11:21:17Z

Jasx: Created page with "All communications between a Device, Server, and App are done through tasks. {| class="wikitable" !Task !Args !REST !Websocket !Sender -> Receiver !Description |- |p |(string)hex_bytes | |X |App -> Server, Server -> Device |Sends a hex string to set the intensity of all motors. When sent from app to server, the first byte is the device to target. When sent to the device, each byte is a motor, big endian. Ex: Device -> Server <code>00FFAA00FF</code> sets the first control..."

All communications between a Device, Server, and App are done through tasks.
{| class="wikitable"
!Task
!Args
!REST
!Websocket
!Sender -> Receiver
!Description
|-
|p
|(string)hex_bytes
|
|X
|App -> Server, Server -> Device
|Sends a hex string to set the intensity of all motors. When sent from app to server, the first byte is the device to target. When sent to the device, each byte is a motor, big endian. Ex: Device -> Server <code>00FFAA00FF</code> sets the first controlled device's motors to Motor1: FF, motor2: AA, Motor3: 00, Motor4 FF
|-
|ps
|(string)hex_bytes
|
|X
|App -> Server, Server -> Device
|Similar to above, but you send blocks of 2 bytes where the first byte is the motor and the second byte is the PWM value. When sent from the device, the first value is the device to target. Ex: Device -> Server <code>0001FF03AA</code> targets the first controlled device and sets its second port to FF and 4th port to AA.
|-
|vib
|(obj)program
|X
|X
|Server -> Device
|Sends a vib program object to the device.
|-
|id
|(str)deviceID / (obj){id:(str)deviceID, ...meta_keys}
|
|X
|Device -> Server
|Sent from a device to the server to list itself on the server.
|-
|app
|(str)name
|
|X
|App -> Server, Server -> Device
|Sent by an app to a server to list itself. When an app claims a device, this is also sent to the device, but with two args: (str)app_name, (str)app_connection_id
|-
|whois
|(str)deviceID
|X
|
|App -> Server
|Request info about a connected device by deviceID. See [Device
|-
|app_offline
|(str)name, (str)connectionID
|
|X
|Server -> Device
|Sent to a device when an app that had connected to it has gone offline
|-
|hookup
|(str)deviceID / (arr)deviceIDs
|
|X
|App -> Server
|Sent by the app to start controlling one or many devices. Sends a callback with a list of all hooked up deviceIDs. The index of this list is used in p / ps calls.
|-
|hookdown
|(str)deviceID / (arr)deviceIDs
|
|X
|App -> Server
|Sent by the app to stop controlling one or may devices. Sends a callback with a list of all hooked up deviceIDs. The index of this list is used in p / ps calls.
|-
|dev_online
|(str)deviceID, (str)socketID, (obj)meta
|
|X
|Server -> App
|Sent to the app when a device comes online.
|-
|dev_offline
|(str)deviceID, (str)socketID
|
|X
|Server -> App
|Sent to the app when a device goes offline.
|-
|dCustom
|(str)deviceID, (var)customData / (str)appName, (str)socketID, (var)customData
|
|X
|App -> Server, Server -> Device
|Relays a custom message to a device. When sending from App to Server, you use deviceID and the custom data. The Device receives appName, the device's socket ID, and the custom data
|-
|aCustom
|(str)socketID, (var)customData / (str)deviceID, (str)socketID, (var)customData
|
|X
|Device -> Server, Server -> App
|Relays a custom message from a Device to an App. When sending from Device to Server, you use the socketID (which you can get from the "app" event or dCustom when an app requests data from a device). The app then receives (str)deviceID, (str)socketID_of_device, (var)customData
|-
|GET
|(obj){id:(str)deviceID, type:(str)type, data:(obj)data}
|
|X
|App -> Server
|Emulates a call to the [[REST]] endpoint with websockets.
|}

Main Page

2026-01-29T11:20:20Z

Jasx: /* Source Code */

Welcome to the VibHub developer wiki! Before we start, let's go over some terms:
{| class="wikitable"
!Term
!Explanation
|-
|[[Firmware|Device]]
|This is the physical hardware VibHub, and also refers to the firmware.
|-
|[[App]]
|The code that sends vibration instructions to the Device. This is likely what you're here for! See the API documentation below!
|-
|[[Server]]
|This is the server that relays messages between the Device and the App. You can host your own!
|-
|deviceID
|A unique ID for each Device that allows the App to communicate with it
|}

== Source Code ==
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|-
|[https://github.com/JasXSL/VibHub-Server VibHub Server]
|Host your own VibHub server!
|-
|[https://github.com/JasXSL/VibHub-Browser VibHub Browser]
|Official JS client library. See [[VibHub-Browser]] for documentation.
|-
|[https://github.com/JasXSL/SL-XOBJ/blob/master/xobj_core/classes/jas%20VibHub.lsl XOBJ SL Library]
|Second Life library built on the XOBJ framework
|-
|[https://github.com/JasXSL/VibHub-SocketDemo Browser Example]
|Example browser app that lets you run VibHub locally with just a few lines of code!
|}

== API ==
{| class="wikitable"
|+
!API Type
!Description
|-
|[[REST]]
|Lets you send vibration programs to a device through simple HTTP requests.
|-
|[[Web Sockets]]
|Much faster than REST requests, recommended if your platform supports it!
|-
|[[Tasks|Tasks Reference]]
|Tasks that your device can handle.
|}

VibHub-Browser

2026-01-29T11:19:32Z

Jasx: Created page with "The library can be clone from [https://github.com/JasXSL/VibHub-Browser here]."

The library can be clone from [https://github.com/JasXSL/VibHub-Browser here].

Web Sockets

2026-01-29T11:18:41Z

Jasx: Created page with "If you want to control the level directly from an app by sending many update requests every second, you can use the websocket API. In this code we'll use the device id "JasTestBullet", replace that with your own. == Install socket.io == Add the socket.io client to your website in your preferred fashion (such as NPM or websockets). After the page loads, connect to the socket: let socket = io('<nowiki>https://vibhub.io'</nowiki>); socket.on('connect', () => { // CO..."

If you want to control the level directly from an app by sending many update requests every second, you can use the websocket API. In this code we'll use the device id "JasTestBullet", replace that with your own.

== Install socket.io ==
Add the socket.io client to your website in your preferred fashion (such as NPM or websockets).
After the page loads, connect to the socket:
let socket = io('<nowiki>https://vibhub.io'</nowiki>);
socket.on('connect', () => {
// CODE GOES HERE
});
This sets up a connection and an event listener for connection established. Let's set up a channel so we can push messages to the device. Replace the <code>// CODE GOES HERE</code> bit with:
console.log("Socket connection established, setting up a channel");
socket.emit('app', "JasTestApp", (success) => {
if( !success )
return;
socket.emit('hookup', 'JasTestBullet', (response) => {
let devices = response;
if( !devices.length )
return;
let hex =
'00'+
'FF'+
'AA'+
'10'+
'00'
;
socket.emit('p', hex);
});
});

=== Explanation: ===
<code>socket.emit('app', "JasTestApp", (success) => {</code>
This sets our connected socket to an app with the name JasTestApp. The name is generally only needed for debugging and in custom events. You can skip that step and directly hookup if you don't want to customize your VibHub device behavior.

<code>socket.emit('hookup', 'JasTestBullet', (response) => {})</code>

* 'hookup' is a task meaning we'll want to set up a channel to start pushing data. The opposite is hookdown if you want to remove a device. This needs to be sent if you get disconnected and reconnect as well, since all channels are cleared on disconnect.
* 'JasTestBullet' is the ID of our device. Replace it with the user's device ID.
* (response) => {} Sets up a callback function

let devices = response;
if( !devices.length )
return;
The response contains an array of connected devices. So if you hook up device A 'JasTestBullet' and device B 'JasTestRing', the response will most likely be ['JasTestBullet', 'JasTestRing']. You should generally save this array somewhere.

The second part makes sure that at least one device is connected. In our case, devices will be ['JasTestBullet']. Keep in mind here that JasTestBullet resides on index 0 of the array. This index is what we use to send the task that sets the power of the device:
let hex =
'00'+
'FF'+
'AA'+
'10'+
'00'
;
This sets up a hex value to send to the server in order:

* '00' = Target device index 0 ("JasTestBullet")
* 'FF' = Set port 0 to max (255)
* 'AA' = Set port 1 to AA (170)
* '10' = Set port 2
* '00' = Turn off port 3

<code>socket.emit('p', buffer);</code>

This sends the command to the server. 'p' is always the task used for socket send, so you can just leave it as 'p'.

== Better practices ==
Store devices as an array somewhere, and whenever you want to send a new intensity value to the device, check for the device ID in the devices array. For an instance:
let index = devices.indexOf('JasTestBullet');
For a full list of tasks and their documentation, see Tasks.

== Or just our JavaScript Library ==
See [[VibHub-Browser]] for documentation!

REST

2026-01-29T11:15:28Z

Jasx: Created page with "The REST API allows you to send a set of tween instructions to a device. This is a good option if you want to send fewer requests that execute a program of pulses, turning on and off etc, or your platform can't do websockets. To send a program to a device, simply send a GET request to: <code><nowiki>https://vibhub.io/api?id=</nowiki><device_id>&type=<type>&data=<json_data_here></code> (HTTP is also accepted but should only be used if your app can't use SSL) Query para..."

The REST API allows you to send a set of tween instructions to a device. This is a good option if you want to send fewer requests that execute a program of pulses, turning on and off etc, or your platform can't do websockets.

To send a program to a device, simply send a GET request to: <code><nowiki>https://vibhub.io/api?id=</nowiki><device_id>&type=<type>&data=<json_data_here></code>

(HTTP is also accepted but should only be used if your app can't use SSL)

Query params explained:
{| class="wikitable"
!Param
!Type
!Explanation
|-
|id
|string
|The deviceID you want to run the program on
|-
|type
|string
|The task to send. See Tasks below.
|-
|data
|varies
|Depends on the type, see below.
|}
Don't forget to URL encode.

= Types =

=== vib ===
The "vib" task expects data to be a URL encoded array of objects with the following params:
{| class="wikitable"
!Param
!Default
!Required
!Type
!Explanation
|-
|stages
|N/A
|Yes
|Array
|An array of stage objects to be tweened beetween. See below for stage objects
|-
|repeats
|0
|No
|integer
|Nr times the animation should repeat. 0 plays it once, 1 plays it twice etc. Use -1 for infinity
|-
|port
|0
|No
|integer
|Bitwise combination of ports to run the program on. 0x1 is the first port, 0x2 second and so forth. 0 or negative values will target ALL ports.
|}

=== Stages ===
The stage is an object containing tweening information for that stage of the program. It has the following properties:
{| class="wikitable"
!Param
!Default
!Type
!Explanation
|-
|i
|0
|integer/obj/boolean
|A value between 0 and 255. Higher value = faster vibrations. Or false to use the previous value. Or a RandObject (see below).
|-
|d
|0
|integer/obj
|Time in milliseconds to reach specified intensity. 0 = instant. Or a RandObject (see below).
|-
|e
|"Linear.None"
|string
|A string denoting the tween.js easing type. See this example for the supported types.
|-
|r
|0
|integer/object
|Repeats. 0 = play this stage once, 1 = play this stage twice and so forth. Or a RandObject (see below)
|-
|y
|false
|boolean/truthy/falsy value
|Go back and forth. Requires repeats to work. Repeats of 1 goes back and forth once, repeats of 3 goes back and forth twice etc. An even number such as 2 will go forth, back, forth, and then start at forth on the next stage.
|}

=== RandObject ===
A RandObject can be used in certain places of a vib call. It'll generate a random value. This value will be randomized at the start of each program loop, but not program stage loop.
{| class="wikitable"
!Param
!Default
!Type
!Explanation
|-
|min
|0
|integer
|Min value to randomize
|-
|max
|varying
|integer
|Max value to randomize. The default value for this depends on the stage param you put it in. i=255, d=10000, r=9
|-
|offset
|0
|integer
|Adds an offset to the randomly generated value. Useful in yoyo type steps where you always want an odd number of repeats (combine with multi of 2).
|-
|multi
|1
|integer
|Multiplies the random value by this. Useful together with offset to generate pulses going up and down n times
|}
Example:

<code>{"min":0, "max":3, "offset":1, "multi":2}</code>

This is useful in repeats with yoyo, as it always generates an odd number. In practice, the above line means "generate 1-4 pulses."

=== Examples ===
Run a program on device id "JasTestBullet". The program resets the vibration level to 0, then goes up to 50% and down again 3 times, then resets back to 0.
Request:

<code>GET <nowiki>https://vibhub.io/api/?id=JasTestBullet&type=vib&data=</nowiki>[{"stages":[{"i":0,"d":0},{"i":50,"d":500,"r":5,"y":1},{"i":0,"d":0}]}]</code>

Response:

<code>{"message":"OK","success":true}</code>

== whois ==
Lets you get meta information about a connected device:

=== Examples ===
Request:
<code>GET <nowiki>https://vibhub.io/api/?id=JasTestBullet&type=whois&data=</nowiki>[]</code>

Response:

<code><nowiki>{"message":{"numPorts":4,"version":"0.3.0","hwversion":"esp32","custom":"","capabilities":{"p":true,"ps":true,"vib":"true"}},"success":true}</nowiki></code>

Main Page

2026-01-29T11:13:03Z

Jasx:

Welcome to the VibHub developer wiki! Before we start, let's go over some terms:
{| class="wikitable"
!Term
!Explanation
|-
|[[Firmware|Device]]
|This is the physical hardware VibHub, and also refers to the firmware.
|-
|[[App]]
|The code that sends vibration instructions to the Device. This is likely what you're here for! See the API documentation below!
|-
|[[Server]]
|This is the server that relays messages between the Device and the App. You can host your own!
|-
|deviceID
|A unique ID for each Device that allows the App to communicate with it
|}

== Source Code ==
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|-
|[https://github.com/JasXSL/VibHub-Server VibHub Server]
|Host your own VibHub server!
|-
|[https://github.com/JasXSL/VibHub-Browser VibHub Browser]
|Official JS client library
|-
|[https://github.com/JasXSL/SL-XOBJ/blob/master/xobj_core/classes/jas%20VibHub.lsl XOBJ SL Library]
|Second Life library built on the XOBJ framework
|-
|[https://github.com/JasXSL/VibHub-SocketDemo Browser Example]
|Example browser app that you can run locally
|}

== API ==
{| class="wikitable"
|+
!API Type
!Description
|-
|[[REST]]
|Lets you send vibration programs to a device through simple HTTP requests.
|-
|[[Web Sockets]]
|Much faster than REST requests, recommended if your platform supports it!
|-
|[[Tasks|Tasks Reference]]
|Tasks that your device can handle.
|}

Main Page

2026-01-29T11:07:58Z

Jasx:

Welcome to the VibHub developer wiki! Before we start, let's go over some terms:
{| class="wikitable"
!Term
!Explanation
|-
|Device
|This is the physical hardware VibHub
|-
|App
|The code that sends vibration instructions to the Device
|-
|Server
|This is the server that relays messages between the Device and the App
|-
|deviceID
|A unique ID for each Device that allows the App to communicate with it
|}

== Source Code ==
{| class="wikitable"
!Name/Link
!Description
|-
|[https://github.com/JasXSL/VibHub-Micro VibHub Micro]
|2026 Revision of the board. Featuring high res commands, 2 ports, and a built in rechargeable battery!
|-
|[https://github.com/JasXSL/VibHub-ESP32 VibHub ESP32]
|4xAA Version of the VibHub
|-
|[https://github.com/JasXSL/VibHub-Server VibHub Server]
|Host your own VibHub server!
|-
|[https://github.com/JasXSL/VibHub-Browser VibHub Browser]
|Official JS client library
|-
|[https://github.com/JasXSL/SL-XOBJ/blob/master/xobj_core/classes/jas%20VibHub.lsl XOBJ SL Library]
|Second Life library built on the XOBJ framework
|-
|[https://github.com/JasXSL/VibHub-SocketDemo Browser Example]
|Example browser app that you can run locally
|}