ClimateGateway API

Default

controlAllDevices

Control all devices (set heat, cool, fan levels)

/devices/control

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://192.168.1.1/devices/control" \
 -d '{
  "Heat" : 56.373768,
  "Fan" : 70.61401,
  "Cool" : 23.021358
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        ClimateSetpointPercentage climateSetpointPercentage = ; // ClimateSetpointPercentage | 

        try {
            apiInstance.controlAllDevices(climateSetpointPercentage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#controlAllDevices");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ClimateSetpointPercentage climateSetpointPercentage = new ClimateSetpointPercentage(); // ClimateSetpointPercentage | 

try {
    final result = await api_instance.controlAllDevices(climateSetpointPercentage);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->controlAllDevices: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ClimateSetpointPercentage climateSetpointPercentage = ; // ClimateSetpointPercentage | 

        try {
            apiInstance.controlAllDevices(climateSetpointPercentage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#controlAllDevices");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ClimateSetpointPercentage *climateSetpointPercentage = ; // 

// Control all devices (set heat, cool, fan levels)
[apiInstance controlAllDevicesWith:climateSetpointPercentage
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var climateSetpointPercentage = ; // {ClimateSetpointPercentage} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.controlAllDevices(climateSetpointPercentage, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class controlAllDevicesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var climateSetpointPercentage = new ClimateSetpointPercentage(); // ClimateSetpointPercentage | 

            try {
                // Control all devices (set heat, cool, fan levels)
                apiInstance.controlAllDevices(climateSetpointPercentage);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.controlAllDevices: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$climateSetpointPercentage = ; // ClimateSetpointPercentage | 

try {
    $api_instance->controlAllDevices($climateSetpointPercentage);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->controlAllDevices: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $climateSetpointPercentage = WWW::OPenAPIClient::Object::ClimateSetpointPercentage->new(); # ClimateSetpointPercentage | 

eval {
    $api_instance->controlAllDevices(climateSetpointPercentage => $climateSetpointPercentage);
};
if ($@) {
    warn "Exception when calling DefaultApi->controlAllDevices: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
climateSetpointPercentage =  # ClimateSetpointPercentage | 

try:
    # Control all devices (set heat, cool, fan levels)
    api_instance.control_all_devices(climateSetpointPercentage)
except ApiException as e:
    print("Exception when calling DefaultApi->controlAllDevices: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let climateSetpointPercentage = ; // ClimateSetpointPercentage

    let mut context = DefaultApi::Context::default();
    let result = client.controlAllDevices(climateSetpointPercentage, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
climateSetpointPercentage *

Responses

Schema

Schema

controlSingleDevice

Control a single device (set heat, cool, fan levels)

/devices/control/{serial}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://192.168.1.1/devices/control/{serial}" \
 -d '{
  "Heat" : 56.373768,
  "Fan" : 70.61401,
  "Cool" : 23.021358
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Long serial = 789; // Long | 
        ClimateSetpointPercentage climateSetpointPercentage = ; // ClimateSetpointPercentage | 

        try {
            apiInstance.controlSingleDevice(serial, climateSetpointPercentage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#controlSingleDevice");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long serial = new Long(); // Long | 
final ClimateSetpointPercentage climateSetpointPercentage = new ClimateSetpointPercentage(); // ClimateSetpointPercentage | 

try {
    final result = await api_instance.controlSingleDevice(serial, climateSetpointPercentage);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->controlSingleDevice: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Long serial = 789; // Long | 
        ClimateSetpointPercentage climateSetpointPercentage = ; // ClimateSetpointPercentage | 

        try {
            apiInstance.controlSingleDevice(serial, climateSetpointPercentage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#controlSingleDevice");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Long *serial = 789; //  (default to null)
ClimateSetpointPercentage *climateSetpointPercentage = ; // 

// Control a single device (set heat, cool, fan levels)
[apiInstance controlSingleDeviceWith:serial
    climateSetpointPercentage:climateSetpointPercentage
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var serial = 789; // {Long} 
var climateSetpointPercentage = ; // {ClimateSetpointPercentage} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.controlSingleDevice(serial, climateSetpointPercentage, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class controlSingleDeviceExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var serial = 789;  // Long |  (default to null)
            var climateSetpointPercentage = new ClimateSetpointPercentage(); // ClimateSetpointPercentage | 

            try {
                // Control a single device (set heat, cool, fan levels)
                apiInstance.controlSingleDevice(serial, climateSetpointPercentage);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.controlSingleDevice: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$serial = 789; // Long | 
$climateSetpointPercentage = ; // ClimateSetpointPercentage | 

try {
    $api_instance->controlSingleDevice($serial, $climateSetpointPercentage);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->controlSingleDevice: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $serial = 789; # Long | 
my $climateSetpointPercentage = WWW::OPenAPIClient::Object::ClimateSetpointPercentage->new(); # ClimateSetpointPercentage | 

eval {
    $api_instance->controlSingleDevice(serial => $serial, climateSetpointPercentage => $climateSetpointPercentage);
};
if ($@) {
    warn "Exception when calling DefaultApi->controlSingleDevice: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
serial = 789 # Long |  (default to null)
climateSetpointPercentage =  # ClimateSetpointPercentage | 

try:
    # Control a single device (set heat, cool, fan levels)
    api_instance.control_single_device(serial, climateSetpointPercentage)
except ApiException as e:
    print("Exception when calling DefaultApi->controlSingleDevice: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let serial = 789; // Long
    let climateSetpointPercentage = ; // ClimateSetpointPercentage

    let mut context = DefaultApi::Context::default();
    let result = client.controlSingleDevice(serial, climateSetpointPercentage, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
serial*	Long (int64) Required

Body parameters

Name	Description
climateSetpointPercentage *

Responses

Schema

Schema

getDevices

Get list of all devices and their status

/devices

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://192.168.1.1/devices"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[DeviceStatus] result = apiInstance.getDevices();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDevices");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getDevices();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDevices: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[DeviceStatus] result = apiInstance.getDevices();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getDevices");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get list of all devices and their status
[apiInstance getDevicesWithCompletionHandler: 
              ^(array[DeviceStatus] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDevices(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getDevicesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Get list of all devices and their status
                array[DeviceStatus] result = apiInstance.getDevices();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getDevices: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->getDevices();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getDevices: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->getDevices();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getDevices: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Get list of all devices and their status
    api_response = api_instance.get_devices()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getDevices: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.getDevices(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

getModbusDatapoints

Get list of all modbus datapoints

/modbus

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://192.168.1.1/modbus"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[ModbusDatapoint] result = apiInstance.getModbusDatapoints();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getModbusDatapoints");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getModbusDatapoints();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getModbusDatapoints: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[ModbusDatapoint] result = apiInstance.getModbusDatapoints();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getModbusDatapoints");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get list of all modbus datapoints
[apiInstance getModbusDatapointsWithCompletionHandler: 
              ^(array[ModbusDatapoint] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getModbusDatapoints(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getModbusDatapointsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Get list of all modbus datapoints
                array[ModbusDatapoint] result = apiInstance.getModbusDatapoints();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getModbusDatapoints: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->getModbusDatapoints();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getModbusDatapoints: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->getModbusDatapoints();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getModbusDatapoints: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Get list of all modbus datapoints
    api_response = api_instance.get_modbus_datapoints()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getModbusDatapoints: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.getModbusDatapoints(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

Schema

getUpdateStatus

Get information about Climate update status

/update

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://192.168.1.1/update"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[UpdateStatus] result = apiInstance.getUpdateStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUpdateStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getUpdateStatus();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUpdateStatus: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[UpdateStatus] result = apiInstance.getUpdateStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUpdateStatus");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get information about Climate update status
[apiInstance getUpdateStatusWithCompletionHandler: 
              ^(array[UpdateStatus] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUpdateStatus(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUpdateStatusExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Get information about Climate update status
                array[UpdateStatus] result = apiInstance.getUpdateStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUpdateStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->getUpdateStatus();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUpdateStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->getUpdateStatus();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUpdateStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Get information about Climate update status
    api_response = api_instance.get_update_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUpdateStatus: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.getUpdateStatus(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

Schema

modbusSettingsGet

Get current Modbus communication parameters

/settings/modbus

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://192.168.1.1/settings/modbus"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[ModbusSettings] result = apiInstance.modbusSettingsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modbusSettingsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.modbusSettingsGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->modbusSettingsGet: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[ModbusSettings] result = apiInstance.modbusSettingsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modbusSettingsGet");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get current Modbus communication parameters
[apiInstance modbusSettingsGetWithCompletionHandler: 
              ^(array[ModbusSettings] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.modbusSettingsGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class modbusSettingsGetExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Get current Modbus communication parameters
                array[ModbusSettings] result = apiInstance.modbusSettingsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.modbusSettingsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->modbusSettingsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->modbusSettingsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->modbusSettingsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->modbusSettingsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Get current Modbus communication parameters
    api_response = api_instance.modbus_settings_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->modbusSettingsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.modbusSettingsGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

Schema

modbusSettingsPost

Write Modbus communication parameters

/settings/modbus

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://192.168.1.1/settings/modbus" \
 -d '{
  "Address" : 154,
  "Dataformat" : "Dataformat",
  "Baudrate" : 18056
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        ModbusSettings modbusSettings = ; // ModbusSettings | 

        try {
            apiInstance.modbusSettingsPost(modbusSettings);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modbusSettingsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ModbusSettings modbusSettings = new ModbusSettings(); // ModbusSettings | 

try {
    final result = await api_instance.modbusSettingsPost(modbusSettings);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->modbusSettingsPost: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ModbusSettings modbusSettings = ; // ModbusSettings | 

        try {
            apiInstance.modbusSettingsPost(modbusSettings);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#modbusSettingsPost");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ModbusSettings *modbusSettings = ; // 

// Write Modbus communication parameters
[apiInstance modbusSettingsPostWith:modbusSettings
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var modbusSettings = ; // {ModbusSettings} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.modbusSettingsPost(modbusSettings, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class modbusSettingsPostExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var modbusSettings = new ModbusSettings(); // ModbusSettings | 

            try {
                // Write Modbus communication parameters
                apiInstance.modbusSettingsPost(modbusSettings);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.modbusSettingsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$modbusSettings = ; // ModbusSettings | 

try {
    $api_instance->modbusSettingsPost($modbusSettings);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->modbusSettingsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $modbusSettings = WWW::OPenAPIClient::Object::ModbusSettings->new(); # ModbusSettings | 

eval {
    $api_instance->modbusSettingsPost(modbusSettings => $modbusSettings);
};
if ($@) {
    warn "Exception when calling DefaultApi->modbusSettingsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
modbusSettings =  # ModbusSettings | 

try:
    # Write Modbus communication parameters
    api_instance.modbus_settings_post(modbusSettings)
except ApiException as e:
    print("Exception when calling DefaultApi->modbusSettingsPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let modbusSettings = ; // ModbusSettings

    let mut context = DefaultApi::Context::default();
    let result = client.modbusSettingsPost(modbusSettings, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
modbusSettings *

Responses

Schema

Schema

startUpdateAllDevices

Start update ALL devices

/update/start

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://192.168.1.1/update/start"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.startUpdateAllDevices();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#startUpdateAllDevices");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.startUpdateAllDevices();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startUpdateAllDevices: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.startUpdateAllDevices();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#startUpdateAllDevices");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Start update ALL devices
[apiInstance startUpdateAllDevicesWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.startUpdateAllDevices(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class startUpdateAllDevicesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Start update ALL devices
                apiInstance.startUpdateAllDevices();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.startUpdateAllDevices: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->startUpdateAllDevices();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->startUpdateAllDevices: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    $api_instance->startUpdateAllDevices();
};
if ($@) {
    warn "Exception when calling DefaultApi->startUpdateAllDevices: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Start update ALL devices
    api_instance.start_update_all_devices()
except ApiException as e:
    print("Exception when calling DefaultApi->startUpdateAllDevices: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.startUpdateAllDevices(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

startUpdateSpecificDevice

Start update on specific device

/update/start/{serial}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://192.168.1.1/update/start/{serial}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Long serial = 789; // Long | 

        try {
            apiInstance.startUpdateSpecificDevice(serial);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#startUpdateSpecificDevice");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long serial = new Long(); // Long | 

try {
    final result = await api_instance.startUpdateSpecificDevice(serial);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startUpdateSpecificDevice: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Long serial = 789; // Long | 

        try {
            apiInstance.startUpdateSpecificDevice(serial);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#startUpdateSpecificDevice");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Long *serial = 789; //  (default to null)

// Start update on specific device
[apiInstance startUpdateSpecificDeviceWith:serial
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ClimateGatewayApi = require('climate_gateway_api');

// Create an instance of the API class
var api = new ClimateGatewayApi.DefaultApi()
var serial = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.startUpdateSpecificDevice(serial, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class startUpdateSpecificDeviceExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var serial = 789;  // Long |  (default to null)

            try {
                // Start update on specific device
                apiInstance.startUpdateSpecificDevice(serial);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.startUpdateSpecificDevice: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$serial = 789; // Long | 

try {
    $api_instance->startUpdateSpecificDevice($serial);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->startUpdateSpecificDevice: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $serial = 789; # Long | 

eval {
    $api_instance->startUpdateSpecificDevice(serial => $serial);
};
if ($@) {
    warn "Exception when calling DefaultApi->startUpdateSpecificDevice: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
serial = 789 # Long |  (default to null)

try:
    # Start update on specific device
    api_instance.start_update_specific_device(serial)
except ApiException as e:
    print("Exception when calling DefaultApi->startUpdateSpecificDevice: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let serial = 789; // Long

    let mut context = DefaultApi::Context::default();
    let result = client.startUpdateSpecificDevice(serial, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
serial*	Long (int64) Required

Responses

Schema

ClimateGateway API

API and SDK Documentation

Default

controlAllDevices

Usage and SDK Samples

Scopes

Parameters

Responses

controlSingleDevice

Usage and SDK Samples

Scopes

Parameters

Responses

getDevices

Usage and SDK Samples

Scopes

Parameters

Responses

getModbusDatapoints

Usage and SDK Samples

Scopes

Parameters

Responses

getUpdateStatus

Usage and SDK Samples

Scopes

Parameters

Responses

modbusSettingsGet

Usage and SDK Samples

Scopes

Parameters

Responses

modbusSettingsPost

Usage and SDK Samples

Scopes

Parameters

Responses

startUpdateAllDevices

Usage and SDK Samples

Scopes

Parameters

Responses

startUpdateSpecificDevice

Usage and SDK Samples

Scopes

Parameters

Responses