memorySelection DLL

CloudAir Selection DLL

Fan selection inside your own program — on a laptop on a building site, without a network.

The DLL answers the same calls as the Selection API, with the same parameters and the same JSON: catalogue, series, products with curves and sound data, and Select fans — the working point computed exactly as in the CloudAir selection software. It reads an encrypted database of the catalogue and a signed licence, both downloaded with your DLL key.

What you get

• One library for Windows 10+ — 64-bit and 32-bit, about 1.6 MB, no installer, no runtime to install.
• Six functions: open, call, free, close, version, last error. Callable from C#, C/C++, Python, VBA, Delphi and anything that loads a DLL.
• The same answers as the API. The DLL carries the selection engine of the Selection API and the CloudAir selection software; both are tested to give identical numbers.
• Only your part of the catalogue. The database holds the series, products and languages your key covers, nothing else.

menu_bookGuide

Quick start

1. Get a DLL key (ca_dll_…) from the company whose catalogue you integrate. No key yet? Use Try the demo on the download page.
2. Download three files at sdk.cloudair.tech/download: the DLL package (DLL-<catalogue>-v1.zip), your database (.cadb) and your licence (.calic). Unzip the package — it has empty folders database\ and licence\ for the other two.
3. Put all three in the folder of your program's .exe — the DLL from win-x64 for a 64-bit program, win-x86 for a 32-bit one. Details: Where to put the files.
4. Open with the paths of the database and the licence, then call:

using var dll = CloudAir.Selection.Open(@"C:\MyApp\demo-2026.10.27.cadb", @"C:\MyApp\demo-sdk-download-demo.calic");
string json = dll.Call("select_fan", "{\"volume\":3000,\"pressure\":300}");

The package has a ready console example. In csharp\Example run it with the paths of your two files — it prints the five best fans:

DLL-Demo-Cloudair-v1\
    database\     ← copy the .cadb here
    licence\      ← copy the .calic here
    win-x64\  win-x86\  include\  csharp\  README.txt

cd DLL-Demo-Cloudair-v1\csharp\Example
dotnet run

The example finds the two files in database\ and licence\ by itself. Or give the paths: dotnet run -- C:\Downloads\demo-2026.10.27.cadb C:\Downloads\demo-sdk-download-demo.calic.

menu_bookGuide

The three files

• The database opens only with the licence of the same key. A database or licence changed by even one byte is refused.
• Where they go: Where to put the files.
• The previous database version keeps working until its own date, so users can update in their own time.

menu_bookGuide

Where to put the files

The DLL goes next to your program's .exe. The database and the licence go wherever you like — your program gives their paths to ca_open.

Nothing is installed or registered: no installer, no registry, no fixed folder. The simplest setup — everything in one folder:

C:\MyApp\
    MyApp.exe
    cloudair-selection.dll            ← from win-x64 (64-bit program) or win-x86 (32-bit)
    acme-2026.10.27.cadb              ← the database
    acme-sdk-acme.calic               ← the licence

using var dll = CloudAir.Selection.Open(
    Path.Combine(AppContext.BaseDirectory, "acme-2026.10.27.cadb"),
    Path.Combine(AppContext.BaseDirectory, "acme-sdk-acme.calic"));

• File names do not matter. Rename them as you like, e.g. catalogue.cadb and catalogue.calic — the DLL checks what is inside, not the name. A fixed name makes updates simple: the new database replaces the old file.
• Relative paths ("demo.cadb") are read from the current folder of the process, which is not always the .exe folder. Use full paths.
• 64 or 32 bit follows your program, not Windows: 32-bit Office on 64-bit Windows needs win-x86. The wrong one fails to load (BadImageFormatException in .NET, error 48 in VBA).
• Several catalogues — one DLL, a pair of files per catalogue; open each pair with its own ca_open.

Excel / VBA

Excel looks for DLLs next to EXCEL.EXE, not next to the workbook. Keep all three files next to the workbook and switch to its folder before the first call:

ChDrive ThisWorkbook.Path
ChDir ThisWorkbook.Path            ' now Excel finds cloudair-selection.dll here
If ca_open(ThisWorkbook.Path & "\catalogue.cadb", ThisWorkbook.Path & "\catalogue.calic", h) <> 0 Then …

Or give the full path in the declaration: Lib "C:\MyTools\cloudair-selection.dll".

functionReference

Functions

Six functions, __stdcall, the same undecorated names in 64-bit and 32-bit builds. Strings are UTF-8. Header: include/cloudair_selection.h.

swap_horizReference

Calls and answers

Every Selection API endpoint is a DLL call with the same name, parameters and answer. The endpoint goes without /v1; parameters go as a JSON object instead of the query string:

API:  GET /v1/select_fan?volume=3000&pressure=300&motor=EC&min.efficiencyStatic=60
DLL:  ca_call(h, "select_fan", "{\"volume\":3000,\"pressure\":300,\"motor\":\"EC\",\"min.efficiencyStatic\":60}")

API:  GET /v1/products/6832?lang=de
DLL:  ca_call(h, "products/6832", "{\"lang\":\"de\"}")

The answer wraps the API body with the status the API would send:

{ "status": 200, "body": { "data": [ … ], "meta": { … } } }
{ "status": 404, "body": { "error": { "code": "NOT_FOUND", "message": "No such product." } } }

Every call has its own page in the menu on the left — parameters, answer fields and examples, and the panel on the right runs it on the demo catalogue. Variables lists every key used in answers and filters.

errorReference

Errors

Opening — ca_open

ca_last_error() says it in words, with the reason code where there is one, e.g. LICENCE_EXPIRED: The licence expired on 2027-10-24…

Calls — ca_call

The same refusals as the API, in body.error: NOT_FOUND, FIELD_VALUE, NO_POINT, UNKNOWN_VARIABLE, LANGUAGE_NOT_INCLUDED… — see Responses and errors. Key, address and daily-limit refusals do not exist in the DLL: the licence was checked when the database was opened.

menu_bookGuide

Updates

• New database version — the catalogue owner publishes it; the technical e-mail of your key gets a message with the download link. Replace the .cadb next to your program; the licence stays.
• New licence — after the owner extends your key or changes what it covers. Download it again.
• New DLL — listed on the download page with its version. The database and licence stay.

Automatic updates

Your program can check and download by itself, with your DLL key, when it is online — the same files as the download page:

GET https://selection-api.cloudair.tech/v1/dll             → current database version, licence and DLL version
GET https://selection-api.cloudair.tech/v1/dll/database    → the current database (.cadb)
GET https://selection-api.cloudair.tech/v1/dll/licence     → your licence (.calic)
GET https://selection-api.cloudair.tech/v1/dll/engine      → the DLL package (.zip)

Header: X-Api-Key: ca_dll_…

Compare data.database.version with the version you have; download when it is newer.

menu_bookGuide

Threads and memory

• One handle, calls in turn. Calls on one handle are queued by the library — safe from several threads, one at a time.
• In parallel: open one handle per thread. Each holds its own copy of the database in memory — tens of MB for a large catalogue.
• Open once, call many times. Opening takes 50–200 ms; a selection over a whole catalogue 100–300 ms; a product or list a few ms.
• Free every answer with ca_free (the .NET wrapper does it for you).
• No network. The DLL never connects anywhere; it reads the two files you give it.

codeExamples

Code samples

The same selection in five languages. The .NET wrapper and a C# console example are in the package.

// cloudair-selection.dll next to your program; CloudAirSelection.cs from the package.
using CloudAir;

using var dll = Selection.Open(@"C:\Data\demo-2026.10.27.cadb", @"C:\Data\demo.calic");

string json = dll.Call("select_fan", new Dictionary<string, object>
{
    ["volume"] = 3000,        // m³/h
    ["pressure"] = 300,       // Pa
    ["limit"] = 5,
});
// {"status":200,"body":{"data":[ { "product": {...}, "point": {...} }, ... ], "meta": {...}}}

try { Selection.Open("old.cadb", "my.calic"); }
catch (SelectionException e) { Console.WriteLine(e.Code + ": " + e.Message); }

#include <stdio.h>
#include "cloudair_selection.h"   /* link with cloudair-selection.lib */

int main(void) {
    ca_handle *h = NULL;
    if (ca_open("demo-2026.10.27.cadb", "demo.calic", &h) != 0) {
        fprintf(stderr, "%s\n", ca_last_error());
        return 1;
    }
    const char *json = ca_call(h, "select_fan", "{\"volume\":3000,\"pressure\":300,\"limit\":5}");
    if (json) { puts(json); ca_free(json); }
    ca_close(h);
    return 0;
}

import ctypes, json

dll = ctypes.WinDLL("cloudair-selection.dll")          # 64-bit Python → win-x64
dll.ca_open.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
dll.ca_call.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
dll.ca_call.restype = ctypes.c_void_p
dll.ca_free.argtypes = [ctypes.c_void_p]
dll.ca_last_error.restype = ctypes.c_char_p

h = ctypes.c_void_p()
if dll.ca_open(b"demo-2026.10.27.cadb", b"demo.calic", ctypes.byref(h)) != 0:
    raise RuntimeError(dll.ca_last_error().decode())

p = dll.ca_call(h, b"select_fan", json.dumps({"volume": 3000, "pressure": 300}).encode())
answer = json.loads(ctypes.string_at(p).decode("utf-8"))
dll.ca_free(p)
dll.ca_close(h)
print(answer["body"]["meta"]["fitted"], "fans fit")

' Module: Excel 64-bit → win-x64 DLL, 32-bit Office → win-x86. Put the DLL next to the workbook.
Private Declare PtrSafe Function ca_open Lib "cloudair-selection.dll" (ByVal db As String, ByVal lic As String, ByRef h As LongPtr) As Long
Private Declare PtrSafe Function ca_call Lib "cloudair-selection.dll" (ByVal h As LongPtr, ByVal ep As String, ByVal params As String) As LongPtr
Private Declare PtrSafe Sub ca_free Lib "cloudair-selection.dll" (ByVal p As LongPtr)
Private Declare PtrSafe Sub ca_close Lib "cloudair-selection.dll" (ByVal h As LongPtr)
Private Declare PtrSafe Function lstrlenA Lib "kernel32" (ByVal p As LongPtr) As Long
Private Declare PtrSafe Function MultiByteToWideChar Lib "kernel32" (ByVal cp As Long, ByVal flags As Long, ByVal src As LongPtr, ByVal srcLen As Long, ByVal dst As LongPtr, ByVal dstLen As Long) As Long

' UTF-8 text from the DLL → VBA string
Private Function FromUtf8(ByVal p As LongPtr) As String
    Dim n As Long, w As Long
    n = lstrlenA(p)
    If n = 0 Then Exit Function
    w = MultiByteToWideChar(65001, 0, p, n, 0, 0)
    FromUtf8 = String$(w, 0)
    MultiByteToWideChar 65001, 0, p, n, StrPtr(FromUtf8), w
End Function

Sub SelectFans()
    Dim h As LongPtr, p As LongPtr
    ChDrive ThisWorkbook.Path: ChDir ThisWorkbook.Path   ' so Excel finds the DLL next to the workbook
    If ca_open(ThisWorkbook.Path & "\demo.cadb", ThisWorkbook.Path & "\demo.calic", h) <> 0 Then
        MsgBox "Cannot open the database": Exit Sub
    End If
    p = ca_call(h, "select_fan", "{""volume"":3000,""pressure"":300,""limit"":5}")
    Range("A1").Value = FromUtf8(p)   ' JSON — parse with your JSON module
    ca_free p
    ca_close h
End Sub

const DLL = 'cloudair-selection.dll';
function ca_open(db, lic: PAnsiChar; out h: Pointer): Integer; stdcall; external DLL;
function ca_call(h: Pointer; ep, params: PAnsiChar): PAnsiChar; stdcall; external DLL;
procedure ca_free(p: PAnsiChar); stdcall; external DLL;
procedure ca_close(h: Pointer); stdcall; external DLL;
function ca_last_error: PAnsiChar; stdcall; external DLL;

var h: Pointer; p: PAnsiChar; json: string;
begin
  if ca_open(PAnsiChar(UTF8Encode('demo.cadb')), PAnsiChar(UTF8Encode('demo.calic')), h) <> 0 then
    raise Exception.Create(UTF8ToString(ca_last_error));
  p := ca_call(h, 'select_fan', '{"volume":3000,"pressure":300}');
  json := UTF8ToString(p);   // parse with System.JSON
  ca_free(p);
  ca_close(h);
end;