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
getModbusSubProtocol GET /1027//40
alias: /target/modbus/sub-protocol
Get current sub protocol
getPageSize GET /1027//10
alias: /target/page-size
Get page size
getProtocol GET /1027//1
alias: /target/protocol
Get target protocol
getRegisterAccess GET /1027//32
alias: /target/register-access
Register access
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
modbusRead GET /1027//38
alias: /target/modbus/read
Generic modbus read
modbusWrite GET /1027//37
alias: /target/modbus/write
Generic modbus write
postAdpAction POST /1027//39
alias: /target/adp/action
Perform actions to ADP target.
postModbusSubProtocol POST /1027//40
alias: /target/modbus/sub-protocol
Set current sub protocol
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
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
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

getModbusSubProtocol

Minimal Tap Firmware version: >= 1.0

Get current sub protocol

Example

let myService = new TargetService();

try{
    let call = myService.getModbusSubProtocol();
    let value = (await call).body();
    console.log(`getModbusSubProtocol: ${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.getModbusSubProtocol();
    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#getModbusSubProtocol");
    e.printStackTrace();
}
import TapDeviceClient
let tap: TapDevice = // ...

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

Parameters

This endpoint does not need any parameter.

Return type

Bytes

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

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

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

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

postAdpAction

Minimal Tap Firmware version: >= 1.0

Perform actions to ADP target.

Example

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

try{
    let call = myService.postAdpAction(data);
    let value = (await call).body();
    console.log(`postAdpAction: ${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<Void> call = myService.postAdpAction(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#postAdpAction");
    e.printStackTrace();
}
import TapDeviceClient
let tap: TapDevice = // ...

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

Parameters

Name Type Description Notes
data BytesBytes

Return type

null (empty response body)

Authorization

No authorization required

postModbusSubProtocol

Minimal Tap Firmware version: >= 1.0

Set current sub protocol

Example

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

try{
    let call = myService.postModbusSubProtocol(data);
    let value = (await call).body();
    console.log(`postModbusSubProtocol: ${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<Void> call = myService.postModbusSubProtocol(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#postModbusSubProtocol");
    e.printStackTrace();
}
import TapDeviceClient
let tap: TapDevice = // ...

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

Parameters

Name Type Description Notes
data BytesBytes

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

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

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