Skip to content

TargetService

Method LWM2M request Description
clearComStats POST /1027//11
alias: /target/com-stats		 Clear communication stats
connect POST /1027//3
alias: /target/connect		 Connect to target
disconnect POST /1027//4
alias: /target/disconnect		 Disconnect from target
getAvailableProtocols GET /1027//20
alias: /target/available-protocols		 List available target protocols
getComStats GET /1027//11
alias: /target/com-stats		 Get communication stats
getCoreType GET /1027//2
alias: /target/core-type		 Get core type
getFirmwareVersion GET /1027//6
alias: /target/firmware-version		 Get firmware version
getMaxVoltage GET /1027//9
alias: /target/max-voltage		 Get max voltage
getMinVoltage GET /1027//8
alias: /target/min-voltage		 Get min voltage
getPageSize GET /1027//10
alias: /target/page-size		 Get page size
getProtocol GET /1027//1
alias: /target/protocol		 Get target protocol
getProtocolConfiguration GET /1027//21
alias: /target/protocol-configuration		 Données de config du protocole (baudrate MODBus, chainage JTAG, etc.) Taille variable, fixée au premier write après le reset factory.
getReceivedCount GET /1027//43
alias: /target/received-count		 Get byte length received in buffer (when using serial communication)
getRegisterAccess GET /1027//32
alias: /target/register-access		 Register access
getSubProtocol GET /1027//40
alias: /target/sub-protocol		 Get current sub protocol
getUARTSettings GET /1027//21
alias: /target/uart/settings		 Données de config du protocole (baudrate MODBus, chainage JTAG, etc.) Taille variable, fixée au premier write après le reset factory.
getVcc GET /1027//7
alias: /target/vcc		 Get vcc
isConnected GET /1027//3
alias: /target/connect		 Check if target is connected
modbusRead GET /1027//38
alias: /target/modbus/read		 Generic modbus read
modbusWrite POST /1027//37
alias: /target/modbus/write		 Generic modbus write
postRegisterAccess POST /1027//32
alias: /target/register-access		 Write register value
postResetKeep POST /1027//30
alias: /target/reset-keep		 Reset target
putCoreType PUT /1027//2
alias: /target/core-type		 Write core type
putFirmwareVersion PUT /1027//6
alias: /target/firmware-version		 Write firmware version
putMaxVoltage PUT /1027//9
alias: /target/max-voltage		 Write max voltage value
putMinVoltage PUT /1027//8
alias: /target/min-voltage		 Write min voltage value
putPageSize PUT /1027//10
alias: /target/page-size		 Write page size
putProtocol PUT /1027//1
alias: /target/protocol		 Configure target protocol
putProtocolConfiguration PUT /1027//21
alias: /target/protocol-configuration		 Update protocol configuration
readAddress GET /1027//33
alias: /target/read-address		 Read memory at given address on the target application
readBytes GET /1027//35
alias: /target/transparent/read-bytes		 Read data transparent mode with limit
readDebug GET /1027//31
alias: /target/debug-access		 Debug access
reset POST /1027//5
alias: /target/reset		 Reset target
send POST /1027//34
alias: /target/transparent/send		 Transparent send
sendReceive GET /1027//34
alias: /target/transparent/send-receive		 Transparent send and receive
setProtocol POST /1027//1
alias: /target/protocol		 Write target protocol
setProtocolConfiguration POST /1027//21
alias: /target/protocol-configuration		 Temporary update configuration
setSubProtocol POST /1027//40
alias: /target/sub-protocol		 Set current sub protocol
setUARTSettings POST /1027//21
alias: /target/uart/settings		 Temporary update configuration
writeAddress POST /1027//33
alias: /target/read-address		 Write into memory on target
writeDebug POST /1027//31
alias: /target/debug-access		 Write address
writeUARTSettings PUT /1027//21
alias: /target/uart/settings		 Update configuration

clearComStats

Minimal Tap Firmware version: >= 1.0

Clear communication stats

Example

let myService = new TargetService();

try {
  let call = myService.clearComStats();
  let value = (await call).body();
  console.log(`clearComStats: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.clearComStats();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#clearComStats");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.clearComStats();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

connect

Minimal Tap Firmware version: >= 1.0

Connect to target

Example

let myService = new TargetService();

try {
  let call = myService.connect();
  let value = (await call).body();
  console.log(`connect: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.connect();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#connect");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.connect();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

disconnect

Minimal Tap Firmware version: >= 1.0

Disconnect from target

Example

let myService = new TargetService();

try {
  let call = myService.disconnect();
  let value = (await call).body();
  console.log(`disconnect: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.disconnect();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#disconnect");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.disconnect();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

getAvailableProtocols

Minimal Tap Firmware version: >= 1.0

List available target protocols

Example

let myService = new TargetService();

try {
  let call = myService.getAvailableProtocols();
  let value = (await call).body();
  console.log(`getAvailableProtocols: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<List> call = myService.getAvailableProtocols();
    Response<List> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getAvailableProtocols");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<List> = try tap.service.target.getAvailableProtocols();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

List

Authorization

No authorization required

getComStats

Minimal Tap Firmware version: >= 1.0

Get communication stats

Get Nb of failed communications and number of successful communications with Target

Example

let myService = new TargetService();

try {
  let call = myService.getComStats();
  let value = (await call).body();
  console.log(`getComStats: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<TargetComStats> call = myService.getComStats();
    Response<TargetComStats> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getComStats");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<TargetComStats> = try tap.service.target.getComStats();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

TargetComStats

Authorization

No authorization required

getCoreType

Minimal Tap Firmware version: >= 1.0

Get core type

Example

let myService = new TargetService();

try {
  let call = myService.getCoreType();
  let value = (await call).body();
  console.log(`getCoreType: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<TargetCoreType> call = myService.getCoreType();
    Response<TargetCoreType> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getCoreType");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<TargetCoreType> = try tap.service.target.getCoreType();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

TargetCoreType

Authorization

No authorization required

getFirmwareVersion

Minimal Tap Firmware version: >= 1.0

Get firmware version

Example

let myService = new TargetService();

try {
  let call = myService.getFirmwareVersion();
  let value = (await call).body();
  console.log(`getFirmwareVersion: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<TapVersion> call = myService.getFirmwareVersion();
    Response<TapVersion> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getFirmwareVersion");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<TapVersion> = try tap.service.target.getFirmwareVersion();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

TapVersion

Authorization

No authorization required

getMaxVoltage

Minimal Tap Firmware version: >= 1.0

Get max voltage

Example

let myService = new TargetService();

try {
  let call = myService.getMaxVoltage();
  let value = (await call).body();
  console.log(`getMaxVoltage: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Integer> call = myService.getMaxVoltage();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getMaxVoltage");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Integer> = try tap.service.target.getMaxVoltage();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Integer

Authorization

No authorization required

getMinVoltage

Minimal Tap Firmware version: >= 1.0

Get min voltage

Example

let myService = new TargetService();

try {
  let call = myService.getMinVoltage();
  let value = (await call).body();
  console.log(`getMinVoltage: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Integer> call = myService.getMinVoltage();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getMinVoltage");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Integer> = try tap.service.target.getMinVoltage();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Integer

Authorization

No authorization required

getPageSize

Minimal Tap Firmware version: >= 1.0

Get page size

Alignement page (TAR)

Example

let myService = new TargetService();

try {
  let call = myService.getPageSize();
  let value = (await call).body();
  console.log(`getPageSize: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Integer> call = myService.getPageSize();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getPageSize");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Integer> = try tap.service.target.getPageSize();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Integer

Authorization

No authorization required

getProtocol

Minimal Tap Firmware version: >= 1.0

Get target protocol

Example

let myService = new TargetService();

try {
  let call = myService.getProtocol();
  let value = (await call).body();
  console.log(`getProtocol: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<TargetProtocol> call = myService.getProtocol();
    Response<TargetProtocol> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getProtocol");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<TargetProtocol> = try tap.service.target.getProtocol();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

TargetProtocol

Authorization

No authorization required

getProtocolConfiguration

Minimal Tap Firmware version: >= 1.0

Données de config du protocole (baudrate MODBus, chainage JTAG, etc.) Taille variable, fixée au premier write après le reset factory.

Example

let myService = new TargetService();

try {
  let call = myService.getProtocolConfiguration();
  let value = (await call).body();
  console.log(`getProtocolConfiguration: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<ProtocolConfiguration> call = myService.getProtocolConfiguration();
    Response<ProtocolConfiguration> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getProtocolConfiguration");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<ProtocolConfiguration> = try tap.service.target.getProtocolConfiguration();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

ProtocolConfiguration

Authorization

No authorization required

getReceivedCount

Minimal Tap Firmware version: >= 1.57

Get byte length received in buffer (when using serial communication)

Example

let myService = new TargetService();

try {
  let call = myService.getReceivedCount();
  let value = (await call).body();
  console.log(`getReceivedCount: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Integer> call = myService.getReceivedCount();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getReceivedCount");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Integer> = try tap.service.target.getReceivedCount();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Integer

Authorization

No authorization required

getRegisterAccess

Minimal Tap Firmware version: >= 1.0

Register access

Access registres (Cortex=>R0...R15) de la cible. Accès conditionné par les ACLs du Bundle Debug (-2)

Example

let myService = new TargetService();

try {
  let call = myService.getRegisterAccess();
  let value = (await call).body();
  console.log(`getRegisterAccess: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Bytes> call = myService.getRegisterAccess();
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getRegisterAccess");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.getRegisterAccess();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Bytes

Authorization

No authorization required

getSubProtocol

Minimal Tap Firmware version: >= 1.0

Get current sub protocol

Example

let myService = new TargetService();

try {
  let call = myService.getSubProtocol();
  let value = (await call).body();
  console.log(`getSubProtocol: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<TargetProtocol> call = myService.getSubProtocol();
    Response<TargetProtocol> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getSubProtocol");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<TargetProtocol> = try tap.service.target.getSubProtocol();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

TargetProtocol

Authorization

No authorization required

getUARTSettings

Minimal Tap Firmware version: >= 1.0

Données de config du protocole (baudrate MODBus, chainage JTAG, etc.) Taille variable, fixée au premier write après le reset factory.

Example

let myService = new TargetService();

try {
  let call = myService.getUARTSettings();
  let value = (await call).body();
  console.log(`getUARTSettings: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<UartSettings> call = myService.getUARTSettings();
    Response<UartSettings> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getUARTSettings");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<UartSettings> = try tap.service.target.getUARTSettings();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

UartSettings

Authorization

No authorization required

getVcc

Minimal Tap Firmware version: >= 1.0

Get vcc

Lit la valeur de la tension de la cible

Example

let myService = new TargetService();

try {
  let call = myService.getVcc();
  let value = (await call).body();
  console.log(`getVcc: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Integer> call = myService.getVcc();
    Response<Integer> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#getVcc");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Integer> = try tap.service.target.getVcc();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Integer

Authorization

No authorization required

isConnected

Minimal Tap Firmware version: >= 1.63

Check if target is connected

Example

let myService = new TargetService();

try {
  let call = myService.isConnected();
  let value = (await call).body();
  console.log(`isConnected: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Boolean> call = myService.isConnected();
    Response<Boolean> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#isConnected");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Boolean> = try tap.service.target.isConnected();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Boolean

Authorization

No authorization required

modbusRead

Minimal Tap Firmware version: >= 1.0

Generic modbus read

Example

let myService = new TargetService();
let data = ; // ModbusOptions |

try{
    let call = myService.modbusRead(data);
    let value = (await call).body();
    console.log(`modbusRead: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


ModbusOptions data = ; // ModbusOptions |
try {
    Call<Bytes> call = myService.modbusRead(data);
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#modbusRead");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.modbusRead(data);
print("Response:" + response.body())

Parameters

Name Type Description Notes
data ModbusOptionsModbusOptions

Return type

Bytes

Authorization

No authorization required

modbusWrite

Minimal Tap Firmware version: >= 1.0

Generic modbus write

Example

let myService = new TargetService();
let data = ; // ModbusWriteOptions |

try{
    let call = myService.modbusWrite(data);
    let value = (await call).body();
    console.log(`modbusWrite: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


ModbusWriteOptions data = ; // ModbusWriteOptions |
try {
    Call<Void> call = myService.modbusWrite(data);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#modbusWrite");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.modbusWrite(data);
print("Response:" + response.body())

Parameters

Name Type Description Notes
data ModbusWriteOptionsModbusWriteOptions

Return type

null (empty response body)

Authorization

No authorization required

postRegisterAccess

Minimal Tap Firmware version: >= 1.0

Write register value

Example

let myService = new TargetService();

try {
  let call = myService.postRegisterAccess();
  let value = (await call).body();
  console.log(`postRegisterAccess: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.postRegisterAccess();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#postRegisterAccess");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.postRegisterAccess();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

postResetKeep

Minimal Tap Firmware version: >= 1.0

Reset target

Reset de la cible (RST=0) et maintient en Reset. Le relachement se fait par Reset (plus haut). Accès conditionné par les ACLs du Bundle réservé Debug (-2) si il existe, sinon Admin seulement

Example

let myService = new TargetService();

try {
  let call = myService.postResetKeep();
  let value = (await call).body();
  console.log(`postResetKeep: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.postResetKeep();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#postResetKeep");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.postResetKeep();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

putCoreType

Minimal Tap Firmware version: >= 1.0

Write core type

Example

let myService = new TargetService();
let value = ; // TargetCoreType | Write core type

try{
    let call = myService.putCoreType(value);
    let value = (await call).body();
    console.log(`putCoreType: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


TargetCoreType value = ; // TargetCoreType | Write core type
try {
    Call<Void> call = myService.putCoreType(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putCoreType");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putCoreType(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value TargetCoreTypeTargetCoreType Write core type

Return type

null (empty response body)

Authorization

No authorization required

putFirmwareVersion

Minimal Tap Firmware version: >= 1.0

Write firmware version

Example

let myService = new TargetService();
let value = ; // TapVersion |

try{
    let call = myService.putFirmwareVersion(value);
    let value = (await call).body();
    console.log(`putFirmwareVersion: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


TapVersion value = ; // TapVersion |
try {
    Call<Void> call = myService.putFirmwareVersion(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putFirmwareVersion");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putFirmwareVersion(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value TapVersionTapVersion

Return type

null (empty response body)

Authorization

No authorization required

putMaxVoltage

Minimal Tap Firmware version: >= 1.0

Write max voltage value

Example

let myService = new TargetService();
let value = 56; // Integer |

try {
  let call = myService.putMaxVoltage(value);
  let value = (await call).body();
  console.log(`putMaxVoltage: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


Integer value = 56; // Integer |
try {
    Call<Void> call = myService.putMaxVoltage(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putMaxVoltage");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putMaxVoltage(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value Integer

Return type

null (empty response body)

Authorization

No authorization required

putMinVoltage

Minimal Tap Firmware version: >= 1.0

Write min voltage value

Example

let myService = new TargetService();
let value = 56; // Integer |

try {
  let call = myService.putMinVoltage(value);
  let value = (await call).body();
  console.log(`putMinVoltage: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


Integer value = 56; // Integer |
try {
    Call<Void> call = myService.putMinVoltage(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putMinVoltage");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putMinVoltage(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value Integer

Return type

null (empty response body)

Authorization

No authorization required

putPageSize

Minimal Tap Firmware version: >= 1.0

Write page size

Example

let myService = new TargetService();
let value = 56; // Integer |

try {
  let call = myService.putPageSize(value);
  let value = (await call).body();
  console.log(`putPageSize: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


Integer value = 56; // Integer |
try {
    Call<Void> call = myService.putPageSize(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putPageSize");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putPageSize(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value Integer

Return type

null (empty response body)

Authorization

No authorization required

putProtocol

Minimal Tap Firmware version: >= 1.0

Configure target protocol

Example

let myService = new TargetService();
let targetProtocol = ; // TargetProtocol | TargetProtocol object to set

try{
    let call = myService.putProtocol(targetProtocol);
    let value = (await call).body();
    console.log(`putProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


TargetProtocol targetProtocol = ; // TargetProtocol | TargetProtocol object to set
try {
    Call<Void> call = myService.putProtocol(targetProtocol);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putProtocol");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putProtocol(targetProtocol);
print("Response:" + response.body())

Parameters

Name Type Description Notes
targetProtocol TargetProtocolTargetProtocol TargetProtocol object to set

Return type

null (empty response body)

Authorization

No authorization required

putProtocolConfiguration

Minimal Tap Firmware version: >= 1.0

Update protocol configuration

Example

let myService = new TargetService();
let value = ; // ProtocolConfiguration |

try{
    let call = myService.putProtocolConfiguration(value);
    let value = (await call).body();
    console.log(`putProtocolConfiguration: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


ProtocolConfiguration value = ; // ProtocolConfiguration |
try {
    Call<Void> call = myService.putProtocolConfiguration(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#putProtocolConfiguration");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.putProtocolConfiguration(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value ProtocolConfigurationProtocolConfiguration

Return type

null (empty response body)

Authorization

No authorization required

readAddress

Minimal Tap Firmware version: >= 1.0

Read memory at given address on the target application

Example

let myService = new TargetService();
let value = ; // MemoryInfo |

try{
    let call = myService.readAddress(value);
    let value = (await call).body();
    console.log(`readAddress: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


MemoryInfo value = ; // MemoryInfo |
try {
    Call<Bytes> call = myService.readAddress(value);
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#readAddress");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.readAddress(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value MemoryInfoMemoryInfo

Return type

Bytes

Authorization

No authorization required

readBytes

Minimal Tap Firmware version: >= 1.0

Read data transparent mode with limit

Lecture de données de la target en mode transparent ou semi-transparent si il y en a, sans attente.

Example

let myService = new TargetService();

try {
  let call = myService.readBytes();
  let value = (await call).body();
  console.log(`readBytes: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Bytes> call = myService.readBytes();
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#readBytes");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.readBytes();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

Bytes

Authorization

No authorization required

readDebug

Minimal Tap Firmware version: >= 1.0

Debug access

Access registres de contrôle (SWD=>APDP) de la cible. Accès conditionné par les ACLs du Bundle Debug (-2)

Example

let myService = new TargetService();
let address = 56; // Integer |

try {
  let call = myService.readDebug(address);
  let value = (await call).body();
  console.log(`readDebug: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


Integer address = 56; // Integer |
try {
    Call<Bytes> call = myService.readDebug(address);
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#readDebug");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.readDebug(address);
print("Response:" + response.body())

Parameters

Name Type Description Notes
address Integer

Return type

Bytes

Authorization

No authorization required

reset

Minimal Tap Firmware version: >= 1.0

Reset target

Reset de la cible. (Reset =0, wait, Reset = 1) utilisé pour relacher le reset après utilisation de ResetKeep. Accès conditionné par les ACLs du Bundle Debug (-2)

Example

let myService = new TargetService();

try {
  let call = myService.reset();
  let value = (await call).body();
  console.log(`reset: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.reset();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#reset");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.reset();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

send

Minimal Tap Firmware version: >= 1.0

Transparent send

Send data to the target application

Example

let myService = new TargetService();
let data = BINARY_DATA_HERE; // Bytes |

try {
  let call = myService.send(data);
  let value = (await call).body();
  console.log(`send: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


Bytes data = BINARY_DATA_HERE; // Bytes |
try {
    Call<Bytes> call = myService.send(data);
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#send");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.send(data);
print("Response:" + response.body())

Parameters

Name Type Description Notes
data BytesBytes

Return type

Bytes

Authorization

No authorization required

sendReceive

Minimal Tap Firmware version: >= 1.0

Transparent send and receive

Send data to the target application and expect response length

Example

let myService = new TargetService();
let data = BINARY_DATA_HERE; // Bytes |

try {
  let call = myService.sendReceive(data);
  let value = (await call).body();
  console.log(`sendReceive: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


Bytes data = BINARY_DATA_HERE; // Bytes |
try {
    Call<Bytes> call = myService.sendReceive(data);
    Response<Bytes> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#sendReceive");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Bytes> = try tap.service.target.sendReceive(data);
print("Response:" + response.body())

Parameters

Name Type Description Notes
data BytesBytes

Return type

Bytes

Authorization

No authorization required

setProtocol

Minimal Tap Firmware version: >= 1.0

Write target protocol

Example

let myService = new TargetService();
let targetProtocol = ; // TargetProtocol | TargetProtocol object to set

try{
    let call = myService.setProtocol(targetProtocol);
    let value = (await call).body();
    console.log(`setProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


TargetProtocol targetProtocol = ; // TargetProtocol | TargetProtocol object to set
try {
    Call<Void> call = myService.setProtocol(targetProtocol);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#setProtocol");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.setProtocol(targetProtocol);
print("Response:" + response.body())

Parameters

Name Type Description Notes
targetProtocol TargetProtocolTargetProtocol TargetProtocol object to set

Return type

null (empty response body)

Authorization

No authorization required

setProtocolConfiguration

Minimal Tap Firmware version: >= 1.0

Temporary update configuration

Configuration will be lost after a tap reboot/reset

Example

let myService = new TargetService();
let value = ; // ProtocolConfiguration |

try{
    let call = myService.setProtocolConfiguration(value);
    let value = (await call).body();
    console.log(`setProtocolConfiguration: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


ProtocolConfiguration value = ; // ProtocolConfiguration |
try {
    Call<Void> call = myService.setProtocolConfiguration(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#setProtocolConfiguration");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.setProtocolConfiguration(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value ProtocolConfigurationProtocolConfiguration

Return type

null (empty response body)

Authorization

No authorization required

setSubProtocol

Minimal Tap Firmware version: >= 1.0

Set current sub protocol

Example

let myService = new TargetService();
let data = ; // TargetProtocol |

try{
    let call = myService.setSubProtocol(data);
    let value = (await call).body();
    console.log(`setSubProtocol: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


TargetProtocol data = ; // TargetProtocol |
try {
    Call<Void> call = myService.setSubProtocol(data);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#setSubProtocol");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.setSubProtocol(data);
print("Response:" + response.body())

Parameters

Name Type Description Notes
data TargetProtocolTargetProtocol

Return type

null (empty response body)

Authorization

No authorization required

setUARTSettings

Minimal Tap Firmware version: >= 1.0

Temporary update configuration

Execute permet de changer la valeur (mais pas la taille) courante de manière temporaire. Elle sera réinitialisée au reset d'après la valeur configurée.

Example

let myService = new TargetService();
let value = ; // UartSettings |

try{
    let call = myService.setUARTSettings(value);
    let value = (await call).body();
    console.log(`setUARTSettings: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


UartSettings value = ; // UartSettings |
try {
    Call<Void> call = myService.setUARTSettings(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#setUARTSettings");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.setUARTSettings(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value UartSettingsUartSettings

Return type

null (empty response body)

Authorization

No authorization required

writeAddress

Minimal Tap Firmware version: >= 1.0

Write into memory on target

Example

let myService = new TargetService();
let value = ; // MemoryWriteInfo |

try{
    let call = myService.writeAddress(value);
    let value = (await call).body();
    console.log(`writeAddress: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


MemoryWriteInfo value = ; // MemoryWriteInfo |
try {
    Call<Void> call = myService.writeAddress(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#writeAddress");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.writeAddress(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value MemoryWriteInfoMemoryWriteInfo

Return type

null (empty response body)

Authorization

No authorization required

writeDebug

Minimal Tap Firmware version: >= 1.0

Write address

Example

let myService = new TargetService();

try {
  let call = myService.writeDebug();
  let value = (await call).body();
  console.log(`writeDebug: ${value}`);
} catch (ex) {
  // No response from device / response error (ie: device is not connected or request timeout)
  console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


try {
    Call<Void> call = myService.writeDebug();
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#writeDebug");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.writeDebug();
print("Response:" + response.body())

Parameters

This endpoint does not need any parameter.

Return type

null (empty response body)

Authorization

No authorization required

writeUARTSettings

Minimal Tap Firmware version: >= 1.0

Update configuration

Put permet de changer la valeur (mais pas la taille) courante de manière permanente

Example

let myService = new TargetService();
let value = ; // UartSettings |

try{
    let call = myService.writeUARTSettings(value);
    let value = (await call).body();
    console.log(`writeUARTSettings: ${value}`);
}
catch (ex){
    // No response from device / response error (ie: device is not connected or request timeout)
    console.error(ex);
}

import .TargetService;

ServiceFactory serviceFactory = ...;
TargetService myService = serviceFactory.create(TargetService.class);


UartSettings value = ; // UartSettings |
try {
    Call<Void> call = myService.writeUARTSettings(value);
    Response<Void> response = call.execute();
    if (response.isSuccessful()){
        System.out.println(response.body());
    }
    else{
        System.out.println(DeviceResponseError.createErrorMessage(response));
    }
} catch (ApiException e) {
    System.err.println("Exception when calling TargetService#writeUARTSettings");
    e.printStackTrace();
}

import TapDeviceClient
let tap: TapDevice = // ...

let ApiResponse<Any> = try tap.service.target.writeUARTSettings(value);
print("Response:" + response.body())

Parameters

Name Type Description Notes
value UartSettingsUartSettings

Return type

null (empty response body)

Authorization

No authorization required