YAPI (Yoctopuce Java API 1.10.29543-SNAPSHOT API)

java.lang.Object
- com.yoctopuce.YoctoAPI.YAPI

```
public class YAPI
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`YAPI.CalibrationHandlerCallback`
`static interface`	`YAPI.DeviceArrivalCallback`
`static interface`	`YAPI.DeviceChangeCallback`
`static interface`	`YAPI.DeviceRemovalCallback`
`static interface`	`YAPI.HubDiscoveryCallback`
`static interface`	`YAPI.LogCallback`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DefaultCacheValidity`
`static int`	`DETECT_ALL`
`static int`	`DETECT_NET`
`static int`	`DETECT_NONE`
`static int`	`DETECT_USB`
`static int`	`DEVICE_BUSY`
`static int`	`DEVICE_NOT_FOUND`
`static int`	`DOUBLE_ACCES`
`static int`	`EXHAUSTED`
`static int`	`FILE_NOT_FOUND`
`static int`	`HASH_BUF_SIZE`
`static int`	`INVALID_ARGUMENT`
`static double`	`INVALID_DOUBLE`
`static int`	`INVALID_INT`
`static long`	`INVALID_LONG`
`static String`	`INVALID_STRING`
`static int`	`INVALID_UINT`
`static int`	`IO_ERROR`
`static int`	`NO_MORE_DATA`
`static int`	`NOT_INITIALIZED`
`static int`	`NOT_SUPPORTED`
`static int`	`RESEND_MISSING_PKT`
`static int`	`RTC_NOT_READY`
`static int`	`SUCCESS`
`static int`	`TIMEOUT`
`static int`	`UNAUTHORIZED`
`static int`	`VERSION_MISMATCH`
`static String`	`YOCTO_API_BUILD_STR`
`static int`	`YOCTO_API_VERSION_BCD`
`static String`	`YOCTO_API_VERSION_STR`
`static int`	`YOCTO_BASE_SERIAL_LEN`
`static int`	`YOCTO_DEVID_BOOTLOADER`
`static int`	`YOCTO_DEVID_FACTORYBOOT`
`static int`	`YOCTO_FIRMWARE_LEN`
`static int`	`YOCTO_FUNCTION_LEN`
`static int`	`YOCTO_LOGICAL_LEN`
`static int`	`YOCTO_MANUFACTURER_LEN`
`static int`	`YOCTO_PRODUCTNAME_LEN`
`static int`	`YOCTO_SERIAL_LEN`
`static int`	`YOCTO_VENDORID`

Constructor Summary

Constructors
Constructor and Description

YAPI()

Constructors
Constructor and Description
`YAPI()`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`CheckLogicalName(String name)` Checks if a given string is valid as logical name for a module or a function.
`static void`	`EnableUSBHost(Object osContext)` This function is used only on Android.
`static void`	`FreeAPI()` Frees dynamically allocated memory blocks used by the Yoctopuce library.
`static String`	`GetAPIVersion()` Returns the version identifier for the Yoctopuce library in use.
`static long`	`GetTickCount()` Returns the current value of a monotone millisecond-based time counter.
`static int`	`HandleEvents()` Maintains the device-to-library communication channel.
`static int`	`InitAPI(int mode)` Initializes the Yoctopuce programming library explicitly.
`static int`	`PreregisterHub(String url)` Fault-tolerant alternative to RegisterHub().
`static int`	`PreregisterHubWebSocketCallback(Object session)`
`static int`	`PreregisterHubWebSocketCallback(Object session, String user, String pass)`
`static void`	`RegisterDeviceArrivalCallback(YAPI.DeviceArrivalCallback arrivalCallback)` Register a callback function, to be called each time a device is plugged.
`static void`	`RegisterDeviceChangeCallback(YAPI.DeviceChangeCallback changeCallback)`
`static void`	`RegisterDeviceRemovalCallback(YAPI.DeviceRemovalCallback removalCallback)` Register a callback function, to be called each time a device is unplugged.
`static int`	`RegisterHub(String url)` Setup the Yoctopuce library to use modules connected on a given machine.
`static int`	`RegisterHub(String url, InputStream request, OutputStream response)`
`static void`	`RegisterHubDiscoveryCallback(YAPI.HubDiscoveryCallback hubDiscoveryCallback)` Register a callback function, to be called each time an Network Hub send an SSDP message.
`static void`	`RegisterLogFunction(YAPI.LogCallback logfun)` Registers a log callback function.
`static void`	`SetThreadSpecificMode()`
`static void`	`SetUSBPacketAckMs(int pktAckDelay)` Enables the acknowledge of every USB packet received by the Yoctopuce library.
`static int`	`Sleep(long ms_duration)` Pauses the execution flow for a specified duration.
`static int`	`TestHub(String url, int mstimeout)` Test if the hub is reachable.
`static int`	`TriggerHubDiscovery()` Force a hub discovery, if a callback as been registered with yRegisterHubDiscoveryCallback it will be called for each net work hub that will respond to the discovery.
`static void`	`UnregisterHub(String url)` Setup the Yoctopuce library to no more use modules connected on a previously registered machine with RegisterHub.
`static void`	`UnregisterHubWebSocketCallback(Object session)`
`static int`	`UpdateDeviceList()` Triggers a (re)detection of connected Yoctopuce modules.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DefaultCacheValidity
```
public static int DefaultCacheValidity
```
  - INVALID_STRING
```
public static final String INVALID_STRING
```
    See Also:
    Constant Field Values
  - INVALID_DOUBLE
```
public static final double INVALID_DOUBLE
```
    See Also:
    Constant Field Values
  - INVALID_INT
```
public static final int INVALID_INT
```
    See Also:
    Constant Field Values
  - INVALID_LONG
```
public static final long INVALID_LONG
```
    See Also:
    Constant Field Values
  - INVALID_UINT
```
public static final int INVALID_UINT
```
    See Also:
    Constant Field Values
  - YOCTO_API_VERSION_STR
```
public static final String YOCTO_API_VERSION_STR
```
    See Also:
    Constant Field Values
  - YOCTO_API_BUILD_STR
```
public static final String YOCTO_API_BUILD_STR
```
    See Also:
    Constant Field Values
  - YOCTO_API_VERSION_BCD
```
public static final int YOCTO_API_VERSION_BCD
```
    See Also:
    Constant Field Values
  - YOCTO_VENDORID
```
public static final int YOCTO_VENDORID
```
    See Also:
    Constant Field Values
  - YOCTO_DEVID_FACTORYBOOT
```
public static final int YOCTO_DEVID_FACTORYBOOT
```
    See Also:
    Constant Field Values
  - YOCTO_DEVID_BOOTLOADER
```
public static final int YOCTO_DEVID_BOOTLOADER
```
    See Also:
    Constant Field Values
  - HASH_BUF_SIZE
```
public static final int HASH_BUF_SIZE
```
    See Also:
    Constant Field Values
  - SUCCESS
```
public static final int SUCCESS
```
    See Also:
    Constant Field Values
  - NOT_INITIALIZED
```
public static final int NOT_INITIALIZED
```
    See Also:
    Constant Field Values
  - INVALID_ARGUMENT
```
public static final int INVALID_ARGUMENT
```
    See Also:
    Constant Field Values
  - NOT_SUPPORTED
```
public static final int NOT_SUPPORTED
```
    See Also:
    Constant Field Values
  - DEVICE_NOT_FOUND
```
public static final int DEVICE_NOT_FOUND
```
    See Also:
    Constant Field Values
  - VERSION_MISMATCH
```
public static final int VERSION_MISMATCH
```
    See Also:
    Constant Field Values
  - DEVICE_BUSY
```
public static final int DEVICE_BUSY
```
    See Also:
    Constant Field Values
  - TIMEOUT
```
public static final int TIMEOUT
```
    See Also:
    Constant Field Values
  - IO_ERROR
```
public static final int IO_ERROR
```
    See Also:
    Constant Field Values
  - NO_MORE_DATA
```
public static final int NO_MORE_DATA
```
    See Also:
    Constant Field Values
  - EXHAUSTED
```
public static final int EXHAUSTED
```
    See Also:
    Constant Field Values
  - DOUBLE_ACCES
```
public static final int DOUBLE_ACCES
```
    See Also:
    Constant Field Values
  - UNAUTHORIZED
```
public static final int UNAUTHORIZED
```
    See Also:
    Constant Field Values
  - RTC_NOT_READY
```
public static final int RTC_NOT_READY
```
    See Also:
    Constant Field Values
  - FILE_NOT_FOUND
```
public static final int FILE_NOT_FOUND
```
    See Also:
    Constant Field Values
  - YOCTO_MANUFACTURER_LEN
```
public static final int YOCTO_MANUFACTURER_LEN
```
    See Also:
    Constant Field Values
  - YOCTO_SERIAL_LEN
```
public static final int YOCTO_SERIAL_LEN
```
    See Also:
    Constant Field Values
  - YOCTO_BASE_SERIAL_LEN
```
public static final int YOCTO_BASE_SERIAL_LEN
```
    See Also:
    Constant Field Values
  - YOCTO_PRODUCTNAME_LEN
```
public static final int YOCTO_PRODUCTNAME_LEN
```
    See Also:
    Constant Field Values
  - YOCTO_FIRMWARE_LEN
```
public static final int YOCTO_FIRMWARE_LEN
```
    See Also:
    Constant Field Values
  - YOCTO_LOGICAL_LEN
```
public static final int YOCTO_LOGICAL_LEN
```
    See Also:
    Constant Field Values
  - YOCTO_FUNCTION_LEN
```
public static final int YOCTO_FUNCTION_LEN
```
    See Also:
    Constant Field Values
  - DETECT_NONE
```
public static final int DETECT_NONE
```
    See Also:
    Constant Field Values
  - DETECT_USB
```
public static final int DETECT_USB
```
    See Also:
    Constant Field Values
  - DETECT_NET
```
public static final int DETECT_NET
```
    See Also:
    Constant Field Values
  - RESEND_MISSING_PKT
```
public static final int RESEND_MISSING_PKT
```
    See Also:
    Constant Field Values
  - DETECT_ALL
```
public static final int DETECT_ALL
```
    See Also:
    Constant Field Values
- Constructor Detail
  - YAPI
```
public YAPI()
```
- Method Detail
  - SetThreadSpecificMode
```
public static void SetThreadSpecificMode()
                                  throws YAPI_Exception
```
    Throws:
    
    YAPI_Exception
  - SetUSBPacketAckMs
```
public static void SetUSBPacketAckMs(int pktAckDelay)
```
    Enables the acknowledge of every USB packet received by the Yoctopuce library. This function allows the library to run on Android phones that tend to loose USB packets. By default, this feature is disabled because it doubles the number of packets sent and slows down the API considerably. Therefore, the acknowledge of incoming USB packets should only be enabled on phones or tablets that loose USB packets. A delay of 50 milliseconds is generally enough. In case of doubt, contact Yoctopuce support. To disable USB packets acknowledge, call this function with the value 0. Note: this feature is only available on Android.
    
    Parameters:
    pktAckDelay - : then number of milliseconds before the module resend the last USB packet.
  - GetAPIVersion
```
public static String GetAPIVersion()
```
    Returns the version identifier for the Yoctopuce library in use. The version is a string in the form "Major.Minor.Build", for instance "1.01.5535". For languages using an external DLL (for instance C#, VisualBasic or Delphi), the character string includes as well the DLL version, for instance "1.01.5535 (1.01.5439)". If you want to verify in your code that the library version is compatible with the version that you have used during development, verify that the major number is strictly equal and that the minor number is greater or equal. The build number is not relevant with respect to the library compatibility.
    
    Returns:
    a character string describing the library version.
  - InitAPI
```
public static int InitAPI(int mode)
                   throws YAPI_Exception
```
    Initializes the Yoctopuce programming library explicitly. It is not strictly needed to call yInitAPI(), as the library is automatically initialized when calling yRegisterHub() for the first time. When YAPI.DETECT_NONE is used as detection mode, you must explicitly use yRegisterHub() to point the API to the VirtualHub on which your devices are connected before trying to access them.
    
    Parameters:
    mode - : an integer corresponding to the type of automatic device detection to use. Possible values are YAPI.DETECT_NONE, YAPI.DETECT_USB, YAPI.DETECT_NET, and YAPI.DETECT_ALL.
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - FreeAPI
```
public static void FreeAPI()
```
    Frees dynamically allocated memory blocks used by the Yoctopuce library. It is generally not required to call this function, unless you want to free all dynamically allocated memory blocks in order to track a memory leak for instance. You should not call any other library function after calling yFreeAPI(), or your program will crash.
  - RegisterHub
```
public static int RegisterHub(String url)
                       throws YAPI_Exception
```
    Setup the Yoctopuce library to use modules connected on a given machine. The parameter will determine how the API will work. Use the following values: usb: When the usb keyword is used, the API will work with devices connected directly to the USB bus. Some programming languages such a Javascript, PHP, and Java don't provide direct access to USB hardware, so usb will not work with these. In this case, use a VirtualHub or a networked YoctoHub (see below). x.x.x.x or hostname: The API will use the devices connected to the host with the given IP address or hostname. That host can be a regular computer running a VirtualHub, or a networked YoctoHub such as YoctoHub-Ethernet or YoctoHub-Wireless. If you want to use the VirtualHub running on you local computer, use the IP address 127.0.0.1. callback: that keyword make the API run in "HTTP Callback" mode. This a special mode allowing to take control of Yoctopuce devices through a NAT filter when using a VirtualHub or a networked YoctoHub. You only need to configure your hub to call your server script on a regular basis. This mode is currently available for PHP and Node.JS only. Be aware that only one application can use direct USB access at a given time on a machine. Multiple access would cause conflicts while trying to access the USB modules. In particular, this means that you must stop the VirtualHub software before starting an application that uses direct USB access. The workaround for this limitation is to setup the library to use the VirtualHub rather than direct USB access. If access control has been activated on the hub, virtual or not, you want to reach, the URL parameter should look like: http://username:password@address:port You can call RegisterHub several times to connect to several machines.
    
    Parameters:
    url - : a string containing either "usb","callback" or the root URL of the hub to monitor
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - RegisterHub
```
public static int RegisterHub(String url,
              InputStream request,
              OutputStream response)
                       throws YAPI_Exception
```
    Throws:
    
    YAPI_Exception
  - PreregisterHubWebSocketCallback
```
public static int PreregisterHubWebSocketCallback(Object session)
                                           throws YAPI_Exception
```
    Throws:
    
    YAPI_Exception
  - PreregisterHubWebSocketCallback
```
public static int PreregisterHubWebSocketCallback(Object session,
                                  String user,
                                  String pass)
                                           throws YAPI_Exception
```
    Throws:
    
    YAPI_Exception
  - UnregisterHubWebSocketCallback
```
public static void UnregisterHubWebSocketCallback(Object session)
```
  - EnableUSBHost
```
public static void EnableUSBHost(Object osContext)
                          throws YAPI_Exception
```
    This function is used only on Android. Before calling yRegisterHub("usb") you need to activate the USB host port of the system. This function takes as argument, an object of class android.content.Context (or any subclass). It is not necessary to call this function to reach modules through the network.
    
    Parameters:
    osContext - : an object of class android.content.Context (or any subclass).
    
    Throws:
    
    YAPI_Exception - on error
  - PreregisterHub
```
public static int PreregisterHub(String url)
                          throws YAPI_Exception
```
    Fault-tolerant alternative to RegisterHub(). This function has the same purpose and same arguments as RegisterHub(), but does not trigger an error when the selected hub is not available at the time of the function call. This makes it possible to register a network hub independently of the current connectivity, and to try to contact it only when a device is actively needed.
    
    Parameters:
    url - : a string containing either "usb","callback" or the root URL of the hub to monitor
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - UnregisterHub
```
public static void UnregisterHub(String url)
```
    Setup the Yoctopuce library to no more use modules connected on a previously registered machine with RegisterHub.
    
    Parameters:
    url - : a string containing either "usb" or the root URL of the hub to monitor
  - TestHub
```
public static int TestHub(String url,
          int mstimeout)
                   throws YAPI_Exception
```
    Test if the hub is reachable. This method do not register the hub, it only test if the hub is usable. The url parameter follow the same convention as the RegisterHub method. This method is useful to verify the authentication parameters for a hub. It is possible to force this method to return after mstimeout milliseconds.
    
    Parameters:
    url - : a string containing either "usb","callback" or the root URL of the hub to monitor
    mstimeout - : the number of millisecond available to test the connection.
    
    Returns:
    YAPI.SUCCESS when the call succeeds. On failure returns a negative error code.
    
    Throws:
    
    YAPI_Exception
  - UpdateDeviceList
```
public static int UpdateDeviceList()
                            throws YAPI_Exception
```
    Triggers a (re)detection of connected Yoctopuce modules. The library searches the machines or USB ports previously registered using yRegisterHub(), and invokes any user-defined callback function in case a change in the list of connected devices is detected. This function can be called as frequently as desired to refresh the device list and to make the application aware of hot-plug events.
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - HandleEvents
```
public static int HandleEvents()
                        throws YAPI_Exception
```
    Maintains the device-to-library communication channel. If your program includes significant loops, you may want to include a call to this function to make sure that the library takes care of the information pushed by the modules on the communication channels. This is not strictly necessary, but it may improve the reactivity of the library for the following commands. This function may signal an error in case there is a communication problem while contacting a module.
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - Sleep
```
public static int Sleep(long ms_duration)
                 throws YAPI_Exception
```
    Pauses the execution flow for a specified duration. This function implements a passive waiting loop, meaning that it does not consume CPU cycles significantly. The processor is left available for other threads and processes. During the pause, the library nevertheless reads from time to time information from the Yoctopuce modules by calling yHandleEvents(), in order to stay up-to-date. This function may signal an error in case there is a communication problem while contacting a module.
    
    Parameters:
    ms_duration - : an integer corresponding to the duration of the pause, in milliseconds.
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - TriggerHubDiscovery
```
public static int TriggerHubDiscovery()
                               throws YAPI_Exception
```
    Force a hub discovery, if a callback as been registered with yRegisterHubDiscoveryCallback it will be called for each net work hub that will respond to the discovery.
    
    Returns:
    YAPI.SUCCESS when the call succeeds.
    
    Throws:
    
    YAPI_Exception - on error
  - GetTickCount
```
public static long GetTickCount()
```
    Returns the current value of a monotone millisecond-based time counter. This counter can be used to compute delays in relation with Yoctopuce devices, which also uses the millisecond as timebase.
    
    Returns:
    a long integer corresponding to the millisecond counter.
  - CheckLogicalName
```
public static boolean CheckLogicalName(String name)
```
    Checks if a given string is valid as logical name for a module or a function. A valid logical name has a maximum of 19 characters, all among A..Z, a..z, 0..9, _, and -. If you try to configure a logical name with an incorrect string, the invalid characters are ignored.
    
    Parameters:
    name - : a string containing the name to check.
    
    Returns:
    true if the name is valid, false otherwise.
  - RegisterDeviceArrivalCallback
```
public static void RegisterDeviceArrivalCallback(YAPI.DeviceArrivalCallback arrivalCallback)
```
    Register a callback function, to be called each time a device is plugged. This callback will be invoked while yUpdateDeviceList is running. You will have to call this function on a regular basis.
    
    Parameters:
    arrivalCallback - : a procedure taking a YModule parameter, or null to unregister a previously registered callback.
  - RegisterDeviceChangeCallback
```
public static void RegisterDeviceChangeCallback(YAPI.DeviceChangeCallback changeCallback)
```
  - RegisterDeviceRemovalCallback
```
public static void RegisterDeviceRemovalCallback(YAPI.DeviceRemovalCallback removalCallback)
```
    Register a callback function, to be called each time a device is unplugged. This callback will be invoked while yUpdateDeviceList is running. You will have to call this function on a regular basis.
    
    Parameters:
    removalCallback - : a procedure taking a YModule parameter, or null to unregister a previously registered callback.
  - RegisterHubDiscoveryCallback
```
public static void RegisterHubDiscoveryCallback(YAPI.HubDiscoveryCallback hubDiscoveryCallback)
```
    Register a callback function, to be called each time an Network Hub send an SSDP message. The callback has two string parameter, the first one contain the serial number of the hub and the second contain the URL of the network hub (this URL can be passed to RegisterHub). This callback will be invoked while yUpdateDeviceList is running. You will have to call this function on a regular basis.
    
    Parameters:
    hubDiscoveryCallback - : a procedure taking two string parameter, the serial number and the hub URL. Use null to unregister a previously registered callback.
  - RegisterLogFunction
```
public static void RegisterLogFunction(YAPI.LogCallback logfun)
```
    Registers a log callback function. This callback will be called each time the API have something to say. Quite useful to debug the API.
    
    Parameters:
    logfun - : a procedure taking a string parameter, or null to unregister a previously registered callback.

Class YAPI

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DefaultCacheValidity

INVALID_STRING

INVALID_DOUBLE

INVALID_INT

INVALID_LONG

INVALID_UINT

YOCTO_API_VERSION_STR

YOCTO_API_BUILD_STR

YOCTO_API_VERSION_BCD

YOCTO_VENDORID

YOCTO_DEVID_FACTORYBOOT

YOCTO_DEVID_BOOTLOADER

HASH_BUF_SIZE

SUCCESS

NOT_INITIALIZED

INVALID_ARGUMENT

NOT_SUPPORTED

DEVICE_NOT_FOUND

VERSION_MISMATCH

DEVICE_BUSY

TIMEOUT

IO_ERROR

NO_MORE_DATA

EXHAUSTED

DOUBLE_ACCES

UNAUTHORIZED

RTC_NOT_READY

FILE_NOT_FOUND

YOCTO_MANUFACTURER_LEN

YOCTO_SERIAL_LEN

YOCTO_BASE_SERIAL_LEN

YOCTO_PRODUCTNAME_LEN

YOCTO_FIRMWARE_LEN

YOCTO_LOGICAL_LEN

YOCTO_FUNCTION_LEN

DETECT_NONE

DETECT_USB

DETECT_NET

RESEND_MISSING_PKT

DETECT_ALL

Constructor Detail

YAPI

Method Detail

SetThreadSpecificMode

SetUSBPacketAckMs

GetAPIVersion

InitAPI

FreeAPI

RegisterHub

RegisterHub

PreregisterHubWebSocketCallback

PreregisterHubWebSocketCallback

UnregisterHubWebSocketCallback

EnableUSBHost

PreregisterHub

UnregisterHub

TestHub

UpdateDeviceList

HandleEvents

Sleep

TriggerHubDiscovery

GetTickCount

CheckLogicalName

RegisterDeviceArrivalCallback

RegisterDeviceChangeCallback

RegisterDeviceRemovalCallback

RegisterHubDiscoveryCallback

RegisterLogFunction