kRPC

https://krpc.github.io/krpc/
Admin
kRPC is a mod for Kerbal Space Program that allows external scripts to control the game, exposing...
Tokens:514,814
Snippets:4,740
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install krpctools

Source: https://krpc.github.io/krpc/0.6.0/extending.html

Install the required tools for generating client code via pip.

```bash
pip install krpctools
```

--------------------------------

### Install Dependencies on Ubuntu

Source: https://krpc.github.io/krpc/0.6.0/_sources/cpp/client.rst.txt

Command to install required system packages for building the C++ client on Ubuntu.

```bash
apt-get install libasio-dev \
    libprotobuf-dev protobuf-compiler
```

--------------------------------

### Install C-nano via vcpkg

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/client.rst.txt

Commands to install the C-nano client using the vcpkg package manager on different operating systems.

```bash
vcpkg install krpc-cnano
```

```bash
vcpkg install krpc-cnano:x64-windows
```

--------------------------------

### Install kRPC Library

Source: https://krpc.github.io/krpc/0.6.0/_sources/python/client.rst.txt

Use pip to install the kRPC Python client.

```bash
pip install krpc
```

--------------------------------

### Build C-nano with Custom Install Prefix

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/client.rst.txt

Commands to build and install the library to a specific directory path using CMake.

```bash
cmake -B build -DCMAKE_INSTALL_PREFIX=/install/path
cmake --build build
cmake --install build
```

--------------------------------

### Install kRPC via vcpkg

Source: https://krpc.github.io/krpc/0.6.0/_sources/cpp/client.rst.txt

Commands to install the kRPC client on Linux or Windows using vcpkg.

```bash
vcpkg install krpc
```

```bash
vcpkg install krpc:x64-windows
```

--------------------------------

### Install Lua client via LuaRocks

Source: https://krpc.github.io/krpc/0.6.0/_sources/lua/client.rst.txt

Use this command to install the kRPC Lua client and its dependencies.

```bash
luarocks install krpc
```

--------------------------------

### Example Output of Attachment Mode Traversal

Source: https://krpc.github.io/krpc/0.6.0/cnano/api/space-center/parts.html

The expected console output when running the part traversal code on the example vessel.

```text
Command Pod Mk1 - axial
 TR-18A Stack Decoupler - axial
  FL-T400 Fuel Tank - axial
   LV-909 Liquid Fuel Engine - axial
    TR-18A Stack Decoupler - axial
     FL-T800 Fuel Tank - axial
      LV-909 Liquid Fuel Engine - axial
      TT-70 Radial Decoupler - radial
       FL-T400 Fuel Tank - radial
        TT18-A Launch Stability Enhancer - radial
        FTX-2 External Fuel Duct - radial
        LV-909 Liquid Fuel Engine - axial
        Aerodynamic Nose Cone - axial
      TT-70 Radial Decoupler - radial
       FL-T400 Fuel Tank - radial
        TT18-A Launch Stability Enhancer - radial
        FTX-2 External Fuel Duct - radial
        LV-909 Liquid Fuel Engine - axial
        Aerodynamic Nose Cone - axial
   LT-1 Landing Struts - radial
   LT-1 Landing Struts - radial
 Mk16 Parachute - axial
```

--------------------------------

### krpc_SpaceCenter_ResourceConverter_Start

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/space-center/parts.rst.txt

Starts the specified resource converter.

```APIDOC
## krpc_SpaceCenter_ResourceConverter_Start

### Description
Starts the resource converter at the specified index.

### Parameters
- **connection** (krpc_connection_t) - The active kRPC connection.
- **index** (int32_t) - The index of the converter.
```

--------------------------------

### krpc_Drawing_Line_Start / krpc_Drawing_Line_set_Start

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/drawing/line.rst.txt

Get or set the start position of the line.

```APIDOC
## krpc_Drawing_Line_Start

### Description
Retrieves the start position of the line.

### Signature
`krpc_error_t krpc_Drawing_Line_Start(krpc_connection_t connection, krpc_tuple_double_double_double_t * result)`

## krpc_Drawing_Line_set_Start

### Description
Sets the start position of the line.

### Signature
`void krpc_Drawing_Line_set_Start(const krpc_tuple_double_double_double_t * value)`
```

--------------------------------

### Launch into Orbit Setup

Source: https://krpc.github.io/krpc/0.6.0/tutorials/launch-into-orbit.html

Initializes a connection to the kRPC server, sets up telemetry streams, and prepares the vessel for launch.

```C
#include <math.h>
#include <unistd.h>
#include <krpc_cnano.h>
#include <krpc_cnano/services/space_center.h>

int main() {
  krpc_connection_t conn;
  krpc_open(&conn, "COM0");
  krpc_connect(conn, "Launch into orbit");

  krpc_SpaceCenter_Vessel_t vessel;
  krpc_SpaceCenter_ActiveVessel(conn, &vessel);

  float turn_start_altitude = 250;
  float turn_end_altitude = 45000;
  float target_altitude = 150000;

  krpc_SpaceCenter_Flight_t flight;
  krpc_SpaceCenter_Vessel_Flight(conn, &flight, vessel, KRPC_NULL);
  krpc_SpaceCenter_Orbit_t orbit;
  krpc_SpaceCenter_Vessel_Orbit(conn, &orbit, vessel);
  krpc_SpaceCenter_Stage_t stage_2;
  krpc_SpaceCenter_Vessel_DecoupleStageAt(conn, &stage_2, vessel, 2);
  krpc_SpaceCenter_Resources_t stage_2_resources;
  krpc_SpaceCenter_Stage_Resources(conn, &stage_2_resources, stage_2, false);

  krpc_SpaceCenter_Control_t control;
  krpc_SpaceCenter_Vessel_Control(conn, &control, vessel);
  krpc_SpaceCenter_AutoPilot_t auto_pilot;
  krpc_SpaceCenter_Vessel_AutoPilot(conn, &auto_pilot, vessel);

  krpc_SpaceCenter_Control_set_SAS(conn, control, false);
  krpc_SpaceCenter_Control_set_RCS(conn, control, false);
  krpc_SpaceCenter_Control_set_Throttle(conn, control, 1);

  printf("3...\n");
  sleep(1);
  printf("2...\n");
  sleep(1);
  printf("1...\n");
  sleep(1);
  printf("Launch!\n");
```

```C#
using System;
using System.Collections.Generic;
using System.Net;
using KRPC.Client;
using KRPC.Client.Services.SpaceCenter;

class LaunchIntoOrbit
{
    public static void Main ()
    {
        var conn = new Connection ("Launch into orbit");
        var vessel = conn.SpaceCenter ().ActiveVessel;

        float turnStartAltitude = 250;
        float turnEndAltitude = 45000;
        float targetAltitude = 150000;

        // Set up streams for telemetry
        var ut = conn.AddStream (() => conn.SpaceCenter ().UT);
        var flight = vessel.Flight ();
        var altitude = conn.AddStream (() => flight.MeanAltitude);
        var apoapsis = conn.AddStream (() => vessel.Orbit.ApoapsisAltitude);
        var stage2Resources =
            vessel.DecoupleStageAt (stage: 2).Resources (cumulative: false);

        var srbFuel = conn.AddStream(() => stage2Resources.Amount("SolidFuel"));

        // Pre-launch setup
        vessel.Control.SAS = false;
        vessel.Control.RCS = false;
        vessel.Control.Throttle = 1;

        // Countdown...
        Console.WriteLine ("3...");
        System.Threading.Thread.Sleep (1000);
        Console.WriteLine ("2...");
        System.Threading.Thread.Sleep (1000);
        Console.WriteLine ("1...");
        System.Threading.Thread.Sleep (1000);
        Console.WriteLine ("Launch!");
```

```C++
#include <iostream>
#include <chrono>
#include <cmath>
#include <thread>
#include <krpc.hpp>
#include <krpc/services/space_center.hpp>

int main() {
  krpc::Client conn = krpc::connect("Launch into orbit");
  krpc::services::SpaceCenter space_center(&conn);
  auto vessel = space_center.active_vessel();

  float turn_start_altitude = 250;
  float turn_end_altitude = 45000;
  float target_altitude = 150000;

  // Set up streams for telemetry
  auto ut = space_center.ut_stream();
  auto altitude = vessel.flight().mean_altitude_stream();
  auto apoapsis = vessel.orbit().apoapsis_altitude_stream();
  auto stage_2_resources = vessel.decouple_stage_at(2).resources(false);
  auto srb_fuel = stage_2_resources.amount_stream("SolidFuel");

  // Pre-launch setup
  vessel.control().set_sas(false);
  vessel.control().set_rcs(false);
  vessel.control().set_throttle(1);

  // Countdown...
  std::cout << "3..." << std::endl;
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::cout << "2..." << std::endl;
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::cout << "1..." << std::endl;
  std::this_thread::sleep_for(std::chrono::seconds(1));
  std::cout << "Launch!" << std::endl;
```

--------------------------------

### Create and manage UI elements with Java

Source: https://krpc.github.io/krpc/0.6.0/tutorials/user-interface.html

Demonstrates initializing the UI service, adding a panel with a button and text, and updating the UI based on vessel telemetry using Java.

```java
import krpc.client.Connection;
import krpc.client.RPCException;
import krpc.client.Stream;
import krpc.client.StreamException;
import krpc.client.services.SpaceCenter;
import krpc.client.services.SpaceCenter.Vessel;
import krpc.client.services.UI;
import krpc.client.services.UI.Button;
import krpc.client.services.UI.Canvas;
import krpc.client.services.UI.Panel;
import krpc.client.services.UI.RectTransform;
import krpc.client.services.UI.Text;

import org.javatuples.Pair;
import org.javatuples.Triplet;

import java.io.IOException;

public class UserInterface {
    public static void main(String[] args)
        throws IOException, RPCException, InterruptedException, StreamException {
        Connection connection = Connection.newInstance("User Interface Example");
        SpaceCenter spaceCenter = SpaceCenter.newInstance(connection);
        UI ui = UI.newInstance(connection);
        Canvas canvas = ui.getStockCanvas();

        // Get the size of the game window in pixels
        Pair<Double, Double> screenSize = canvas.getRectTransform().getSize();

        // Add a panel to contain the UI elements
        Panel panel = canvas.addPanel(true);

        // Position the panel on the left of the screen
        RectTransform rect = panel.getRectTransform();
        rect.setSize(new Pair<Double,Double>(200.0, 100.0));
        rect.setPosition(
          new Pair<Double,Double>((110-(screenSize.getValue0())/2), 0.0));

        // Add a button to set the throttle to maximum
        Button button = panel.addButton("Full Throttle", true);
        button.getRectTransform().setPosition(new Pair<Double,Double>(0.0, 20.0));

        // Add some text displaying the total engine thrust
        Text text = panel.addText("Thrust: 0 kN", true);
        text.getRectTransform().setPosition(new Pair<Double,Double>(0.0, -20.0));
        text.setColor(new Triplet<Double,Double,Double>(1.0, 1.0, 1.0));
        text.setSize(18);

        // Set up a stream to monitor the throttle button
        Stream<Boolean> buttonClicked = connection.addStream(button, "getClicked");

        Vessel vessel = spaceCenter.getActiveVessel();
        while (true) {
            // Handle the throttle button being clicked
            if (buttonClicked.get ()) {
                vessel.getControl().setThrottle(1);
                button.setClicked(false);
            }

            // Update the thrust text
            text.setContent(String.format("Thrust: %.0f kN", (vessel.getThrust()/1000)));

            Thread.sleep(1000);
        }
    }
}
```

--------------------------------

### Establish TCP/IP Connection and Stream Data

Source: https://krpc.github.io/krpc/0.6.0/communication-protocols/tcpip.html

Demonstrates setting up RPC and stream sockets, sending connection requests, and processing stream updates using protobuf.

```python
import binascii
import socket
from google.protobuf.internal.encoder import _VarintEncoder
from google.protobuf.internal.decoder import _DecodeVarint
from krpc.schema import KRPC_pb2 as KRPC


def encode_varint(value):
    """Encode an int as a protobuf varint"""
    data = []
    _VarintEncoder()(data.append, value, False)
    return b"".join(data)


def decode_varint(data):
    """Decode a protobuf varint to an int"""
    return _DecodeVarint(data, 0)[0]


def send_message(conn, msg):
    """Send a message, prefixed with its size, to a TPC/IP socket"""
    data = msg.SerializeToString()
    size = encode_varint(len(data))
    conn.sendall(size + data)


def recv_message(conn, msg_type):
    """Receive a message, prefixed with its size, from a TCP/IP socket"""
    # Receive the size of the message data
    data = b""
    while True:
        try:
            data += conn.recv(1)
            size = decode_varint(data)
            break
        except IndexError:
            pass
    # Receive the message data
    data = conn.recv(size)
    # Decode the message
    msg = msg_type()
    msg.ParseFromString(data)
    return msg


# Open a TCP/IP socket to the RPC server
rpc_conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
rpc_conn.connect(("127.0.0.1", 50000))

# Send an RPC connection request
request = KRPC.ConnectionRequest()
request.type = KRPC.ConnectionRequest.RPC
request.client_name = "Jeb"
send_message(rpc_conn, request)

# Receive the connection response
response = recv_message(rpc_conn, KRPC.ConnectionResponse)

# Check the connection was successful
if response.status != KRPC.ConnectionResponse.OK:
    raise RuntimeError("Connection failed: " + response.message)
print("Connected to RPC server")

# Print out the clients identifier
print(
    "RPC client idenfitier = %s"
    % binascii.hexlify(bytearray(response.client_identifier)).decode("utf8")
)

# Open a TCP/IP socket to the Stream server
stream_conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
stream_conn.connect(("127.0.0.1", 50001))

# Send a stream connection request, containing the clients identifier
request = KRPC.ConnectionRequest()
request.type = KRPC.ConnectionRequest.STREAM
request.client_identifier = response.client_identifier
send_message(stream_conn, request)

# Receive the connection response
response = recv_message(stream_conn, KRPC.ConnectionResponse)

# Check the connection was successful
if response.status != KRPC.ConnectionResponse.OK:
    raise RuntimeError("Connection failed: " + response.message)
print("Connected to stream server")

# Build a KRPC.GetStatus call to be streamed
stream_call = KRPC.ProcedureCall()
stream_call.service = "KRPC"
stream_call.procedure = "GetStatus"

# Call KRPC.AddStream to add the stream
call = KRPC.ProcedureCall()
call.service = "KRPC"
call.procedure = "AddStream"
arg = KRPC.Argument()
arg.position = 0
arg.value = stream_call.SerializeToString()
call.arguments.extend([arg])
request = KRPC.Request()
request.calls.extend([call])
send_message(rpc_conn, request)

# Receive the response
response = recv_message(rpc_conn, KRPC.Response)

# Check for an error in the response
if response.HasField("error"):
    raise RuntimeError("ERROR: " + str(response.error))

# Check for an error in the results
assert len(response.results) == 1
if response.results[0].HasField("error"):
    raise RuntimeError("ERROR: " + str(response.results[0].error))

# Decode the return value as a Stream message
stream = KRPC.Stream()
stream.ParseFromString(response.results[0].value)

# Repeatedly receive stream updates from the stream server
while True:
    update = recv_message(stream_conn, KRPC.StreamUpdate)
    assert len(update.results) == 1
    assert stream.id == update.results[0].id
    # Decode and print the return value
    status = KRPC.Status()
    status.ParseFromString(update.results[0].result.value)
    print(status)
```

--------------------------------

### Create and manage UI elements with C++

Source: https://krpc.github.io/krpc/0.6.0/tutorials/user-interface.html

Demonstrates initializing the UI service, adding a panel with a button and text, and updating the UI based on vessel telemetry.

```cpp
#include <chrono>
#include <thread>
#include <krpc.hpp>
#include <krpc/services/space_center.hpp>
#include <krpc/services/ui.hpp>

int main() {
  krpc::Client conn = krpc::connect("User Interface Example");
  krpc::services::SpaceCenter space_center(&conn);
  krpc::services::UI ui(&conn);
  auto canvas = ui.stock_canvas();

  // Get the size of the game window in pixels
  auto screen_size = canvas.rect_transform().size();

  // Add a panel to contain the UI elements
  auto panel = canvas.add_panel();

  // Position the panel on the left of the screen
  auto rect = panel.rect_transform();
  rect.set_size(std::make_tuple(200, 100));
  rect.set_position(std::make_tuple(110-(std::get<0>(screen_size)/2), 0));

  // Add a button to set the throttle to maximum
  auto button = panel.add_button("Full Throttle");
  button.rect_transform().set_position(std::make_tuple(0, 20));

  // Add some text displaying the total engine thrust
  auto text = panel.add_text("Thrust: 0 kN");
  text.rect_transform().set_position(std::make_tuple(0, -20));
  text.set_color(std::make_tuple(1, 1, 1));
  text.set_size(18);

  // Set up a stream to monitor the throttle button
  auto button_clicked = button.clicked_stream();

  auto vessel = space_center.active_vessel();
  while (true) {
    // Handle the throttle button being clicked
    if (button_clicked()) {
      vessel.control().set_throttle(1);
      button.set_clicked(false);
    }

    // Update the thrust text
    text.set_content("Thrust: " + std::to_string((int)(vessel.thrust()/1000)) + " kN");

    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
}
```

--------------------------------

### Create a User Interface with kRPC

Source: https://krpc.github.io/krpc/0.6.0/tutorials/user-interface.html

Examples showing how to add UI elements like panels, buttons, and text to the stock canvas and update them in a loop.

```lua
local krpc = require 'krpc'
local platform = require 'krpc.platform'
local List = require 'pl.List'
local conn = krpc.connect('User Interface Example')
local canvas = conn.ui.stock_canvas

-- Get the size of the game window in pixels
local screen_size = canvas.rect_transform.size

-- Add a panel to contain the UI elements
local panel = canvas:add_panel()

-- Position the panel on the left of the screen
local rect = panel.rect_transform
rect.size = List{200, 100}
rect.position = List{110-(screen_size[1]/2), 0}

-- Add a button to set the throttle to maximum
local button = panel:add_button("Full Throttle")
button.rect_transform.position = List{0, 20}

-- Add some text displaying the total engine thrust
local text = panel:add_text("Thrust: 0 kN")
text.rect_transform.position = List{0, -20}
text.color = List{1, 1, 1}
text.size = 18

local vessel = conn.space_center.active_vessel
while true do
    -- Handle the throttle button being clicked
    if button.clicked then
        vessel.control.throttle = 1
        button.clicked = false
    end

    -- Update the thrust text
    text.content = string.format('Thrust: %.1f kN', vessel.thrust/1000)

    platform.sleep(0.1)
end
```

```python
import time
import krpc

conn = krpc.connect(name="User Interface Example")
canvas = conn.ui.stock_canvas

# Get the size of the game window in pixels
screen_size = canvas.rect_transform.size

# Add a panel to contain the UI elements
panel = canvas.add_panel()

# Position the panel on the left of the screen
rect = panel.rect_transform
rect.size = (200, 100)
rect.position = (110 - (screen_size[0] / 2), 0)

# Add a button to set the throttle to maximum
button = panel.add_button("Full Throttle")
button.rect_transform.position = (0, 20)

# Add some text displaying the total engine thrust
text = panel.add_text("Thrust: 0 kN")
text.rect_transform.position = (0, -20)
text.color = (1, 1, 1)
text.size = 18

# Set up a stream to monitor the throttle button
button_clicked = conn.add_stream(getattr, button, "clicked")

vessel = conn.space_center.active_vessel
while True:
    # Handle the throttle button being clicked
    if button_clicked():
        vessel.control.throttle = 1
        button.clicked = False

    # Update the thrust text
    text.content = "Thrust: %d kN" % (vessel.thrust / 1000)

    time.sleep(0.1)
```

--------------------------------

### Example Output of Part Traversal

Source: https://krpc.github.io/krpc/0.6.0/cnano/api/space-center/parts.html

The console output generated by the depth-first traversal code for the example vessel.

```text
Command Pod Mk1
 TR-18A Stack Decoupler
  FL-T400 Fuel Tank
   LV-909 Liquid Fuel Engine
    TR-18A Stack Decoupler
     FL-T800 Fuel Tank
      LV-909 Liquid Fuel Engine
      TT-70 Radial Decoupler
       FL-T400 Fuel Tank
        TT18-A Launch Stability Enhancer
        FTX-2 External Fuel Duct
        LV-909 Liquid Fuel Engine
        Aerodynamic Nose Cone
      TT-70 Radial Decoupler
       FL-T400 Fuel Tank
        TT18-A Launch Stability Enhancer
        FTX-2 External Fuel Duct
        LV-909 Liquid Fuel Engine
        Aerodynamic Nose Cone
   LT-1 Landing Struts
   LT-1 Landing Struts
 Mk16 Parachute
```

--------------------------------

### Build C-nano with CMake

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/client.rst.txt

Standard commands to configure, build, and install the C-nano library using CMake.

```bash
cmake -B build
cmake --build build
cmake --install build
```

--------------------------------

### Start an event

Source: https://krpc.github.io/krpc/0.6.0/_sources/cpp/client.rst.txt

Initializes the event to begin receiving updates from the server.

```cpp
void start()
```

--------------------------------

### Set up and receive data from a stream

Source: https://krpc.github.io/krpc/0.6.0/communication-protocols/websockets.html

Demonstrates connecting to the RPC server to obtain a client identifier, then establishing a connection to the stream server to receive updates.

```javascript
'use strict'

var websocket = require('ws');
var protobufjs = require('protobufjs')
var proto = protobufjs.loadProtoFile('krpc.proto').build();

console.log('Connecting to RPC server')
let rpcConn = new websocket('ws://127.0.0.1:50000')
rpcConn.binaryType = 'arraybuffer'

rpcConn.onopen = (evnt) => {
  console.log('Successfully connected')
  console.log('Calling KRPC.GetClientID')
  let call = new proto.krpc.schema.ProcedureCall('KRPC', 'GetClientID');
  let request = new proto.krpc.schema.Request([call]);
  rpcConn.send(request.toArrayBuffer());
};

rpcConn.onmessage = (evnt) => {
  let response = proto.krpc.schema.Response.decode(evnt.data);
  response.results[0].value.readVarint32(); // skip size
  let client_identifier = response.results[0].value.toBase64();
  console.log('Client identifier =', client_identifier);

  console.log('Connecting to Stream server');
  let streamConn = new websocket('ws://127.0.0.1:50001?id=' + client_identifier);
  streamConn.binaryType = 'arraybuffer';

  streamConn.onopen = (evnt) => {
    console.log('Successfully connected');

    let call_to_stream = new proto.krpc.schema.ProcedureCall('KRPC', 'GetStatus');
    let arg = new proto.krpc.schema.Argument(0, call_to_stream.toArrayBuffer());
    let call = new proto.krpc.schema.ProcedureCall('KRPC', 'AddStream', [arg]);
    let request = new proto.krpc.schema.Request([call]);
    rpcConn.send(request.toArrayBuffer());
    rpcConn.onmessage = (evnt) => {
      let response = proto.krpc.schema.Response.decode(evnt.data);
      let stream = proto.krpc.schema.Stream.decode(response.results[0].value);
      console.log("added stream id =", stream.id.toString());
    };
  };

  streamConn.onmessage = (evnt) => {
    let value = new proto.krpc.schema.StreamUpdate.decode(evnt.data);
    let status = proto.krpc.schema.Status.decode(value.results[0].result.value)
    console.log(status);
  };
};
```

--------------------------------

### get

Source: https://krpc.github.io/krpc/0.6.0/cpp/api/krpc/expressions.html

Accesses an element in a collection.

```APIDOC
## static Expression get(Client &connection, Expression arg, Expression index)

### Description
Access an element in a tuple, list or dictionary.

### Parameters
- **connection** (Client&) - Required - The kRPC client connection.
- **arg** (Expression) - Required - The tuple, list or dictionary.
- **index** (Expression) - Required - The index of the element to access (integer for tuple/list, key for dictionary).

### Returns
- **Expression** - The accessed element.
```

--------------------------------

### Connect to kRPC on Arduino

Source: https://krpc.github.io/krpc/0.6.0/cnano/client.html

Example showing how to initialize a connection to the kRPC server using the Arduino serial port.

```cpp
#include <krpc_cnano.h>
#include <krpc_cnano/services/krpc.h>

HardwareSerial * conn;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);

  conn = &Serial;
  // Open the serial port connection
  krpc_open(&conn, NULL);
  // Set up communication with the server
  krpc_connect(conn, "Arduino Example");

  // Indicate successful connection by lighting the on-board LED
  digitalWrite(LED_BUILTIN, HIGH);
}

void loop() {
}
```

--------------------------------

### krpc_SpaceCenter_Part_Children

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/space-center/parts.rst.txt

Get the children of the part.

```APIDOC
## krpc_SpaceCenter_Part_Children

### Description
Returns a list of the part's children. This can be used in conjunction with `krpc_SpaceCenter_Part_Parent` to traverse the vessel's parts tree.

### Signature
- `krpc_error_t krpc_SpaceCenter_Part_Children(krpc_connection_t connection, krpc_list_object_t * result)`
```

--------------------------------

### Launch Into Orbit C Example

Source: https://krpc.github.io/krpc/0.6.0/_downloads/71483a7e91188bec1cf97ee3cd8b7e6b/LaunchIntoOrbit.c

This script connects to a kRPC server, performs a gravity turn, separates SRBs, and executes a circularization burn.

```c
#include <math.h>
#include <unistd.h>
#include <krpc_cnano.h>
#include <krpc_cnano/services/space_center.h>

int main() {
  krpc_connection_t conn;
  krpc_open(&conn, "COM0");
  krpc_connect(conn, "Launch into orbit");

  krpc_SpaceCenter_Vessel_t vessel;
  krpc_SpaceCenter_ActiveVessel(conn, &vessel);

  float turn_start_altitude = 250;
  float turn_end_altitude = 45000;
  float target_altitude = 150000;

  krpc_SpaceCenter_Flight_t flight;
  krpc_SpaceCenter_Vessel_Flight(conn, &flight, vessel, KRPC_NULL);
  krpc_SpaceCenter_Orbit_t orbit;
  krpc_SpaceCenter_Vessel_Orbit(conn, &orbit, vessel);
  krpc_SpaceCenter_Stage_t stage_2;
  krpc_SpaceCenter_Vessel_DecoupleStageAt(conn, &stage_2, vessel, 2);
  krpc_SpaceCenter_Resources_t stage_2_resources;
  krpc_SpaceCenter_Stage_Resources(conn, &stage_2_resources, stage_2, false);

  krpc_SpaceCenter_Control_t control;
  krpc_SpaceCenter_Vessel_Control(conn, &control, vessel);
  krpc_SpaceCenter_AutoPilot_t auto_pilot;
  krpc_SpaceCenter_Vessel_AutoPilot(conn, &auto_pilot, vessel);

  krpc_SpaceCenter_Control_set_SAS(conn, control, false);
  krpc_SpaceCenter_Control_set_RCS(conn, control, false);
  krpc_SpaceCenter_Control_set_Throttle(conn, control, 1);

  printf("3...\n");
  sleep(1);
  printf("2...\n");
  sleep(1);
  printf("1...\n");
  sleep(1);
  printf("Launch!\n");

  krpc_SpaceCenter_Control_ActivateNextStage(conn, NULL, control);
  krpc_SpaceCenter_AutoPilot_set_Engaged(conn, auto_pilot, true);
  krpc_SpaceCenter_AutoPilot_TargetPitchAndHeading(conn, auto_pilot, 90, 90);

  bool srbs_separated = false;
  double turn_angle = 0;
  while (true) {
    double altitude;
    krpc_SpaceCenter_Flight_MeanAltitude(conn, &altitude, flight);
    double apoapsis;
    krpc_SpaceCenter_Orbit_ApoapsisAltitude(conn, &apoapsis, orbit);

    if (altitude > turn_start_altitude && altitude < turn_end_altitude) {
      double frac = (altitude - turn_start_altitude) / (turn_end_altitude - turn_start_altitude);
      double new_turn_angle = frac * 90.0;
      if (fabs(new_turn_angle - turn_angle) > 0.5) {
        turn_angle = new_turn_angle;
        krpc_SpaceCenter_AutoPilot_TargetPitchAndHeading(conn, auto_pilot, 90 - turn_angle, 90);
      }
    }

    if (!srbs_separated) {
      float srb_fuel;
      krpc_SpaceCenter_Resources_Amount(conn, &srb_fuel, stage_2_resources, "SolidFuel");
      if (srb_fuel < 0.1) {
        krpc_SpaceCenter_Control_ActivateNextStage(conn, NULL, control);
        srbs_separated = true;
        printf("SRBs separated\n");
      }
    }

    if (apoapsis > target_altitude * 0.9) {
      printf("Approaching target apoapsis\n");
      break;
    }
  }

  krpc_SpaceCenter_Control_set_Throttle(conn, control, 0.25);
  while (true) {
    double apoapsis;
    krpc_SpaceCenter_Orbit_ApoapsisAltitude(conn, &apoapsis, orbit);
    if (apoapsis >= target_altitude)
      break;
  }
  printf("Target apoapsis reached\n");
  krpc_SpaceCenter_Control_set_Throttle(conn, control, 0);

  printf("Coasting out of atmosphere\n");
  while (true) {
    double altitude;
    krpc_SpaceCenter_Flight_MeanAltitude(conn, &altitude, flight);
    if (altitude >= 70500)
      break;
  }

  printf("Planning circularization burn\n");
  krpc_SpaceCenter_CelestialBody_t body;
  krpc_SpaceCenter_Orbit_Body(conn, &body, orbit);
  double mu;
  krpc_SpaceCenter_CelestialBody_GravitationalParameter(conn, &mu, body);
  double r;
  krpc_SpaceCenter_Orbit_Apoapsis(conn, &r, orbit);
  double a1;
  krpc_SpaceCenter_Orbit_SemiMajorAxis(conn, &a1, orbit);
  double a2 = r;
  double v1 = sqrt(mu * ((2.0 / r) - (1.0 / a1)));
  double v2 = sqrt(mu * ((2.0 / r) - (1.0 / a2)));
  double delta_v = v2 - v1;
  double ut;
  krpc_SpaceCenter_UT(conn, &ut);
  double time_to_apoapsis;
  krpc_SpaceCenter_Orbit_TimeToApoapsis(conn, &time_to_apoapsis, orbit);
  krpc_SpaceCenter_Node_t node;
  krpc_SpaceCenter_Control_AddNode(conn, &node, control, ut + time_to_apoapsis, delta_v, 0, 0);

  float F;
  krpc_SpaceCenter_Vessel_AvailableThrust(conn, &F, vessel);
  float isp;
  krpc_SpaceCenter_Vessel_SpecificImpulse(conn, &isp, vessel);
  double Isp = isp * 9.82;
  float m0;
  krpc_SpaceCenter_Vessel_Mass(conn, &m0, vessel);
  double m1 = m0 / exp(delta_v / Isp);
  double flow_rate = F / Isp;
  double burn_time = (m0 - m1) / flow_rate;

  printf("Orientating ship for circularization burn\n");
  krpc_SpaceCenter_ReferenceFrame_t node_ref;
  krpc_SpaceCenter_Node_ReferenceFrame(conn, &node_ref, node);
  krpc_SpaceCenter_AutoPilot_set_ReferenceFrame(conn, auto_pilot, node_ref);
  krpc_tuple_double_double_double_t burn_direction = {0, 1, 0};
  krpc_SpaceCenter_AutoPilot_set_TargetDirection(conn, auto_pilot, &burn_direction);
  krpc_SpaceCenter_AutoPilot_Wait(conn, auto_pilot, -1);
}
```

--------------------------------

### up

Source: https://krpc.github.io/krpc/0.6.0/_sources/cpp/api/space-center/control.rst.txt

Get or set the up translational control.

```APIDOC
## float up()

### Description
Returns the current up translational control input. Note: The getter returns the combined input from kRPC, keyboard, SAS, and trim.

## void set_up(float value)

### Description
Sets the up translational control input (value between -1 and 1). Equivalent to i and k keys.
```

--------------------------------

### Launch Sequence Implementation

Source: https://krpc.github.io/krpc/0.6.0/tutorials/launch-into-orbit.html

Examples of implementing a launch loop that manages gravity turns and booster separation across different programming languages.

```C
  krpc_SpaceCenter_Control_ActivateNextStage(conn, NULL, control);
  krpc_SpaceCenter_AutoPilot_set_Engaged(conn, auto_pilot, true);
  krpc_SpaceCenter_AutoPilot_TargetPitchAndHeading(conn, auto_pilot, 90, 90);

  bool srbs_separated = false;
  double turn_angle = 0;
  while (true) {
    double altitude;
    krpc_SpaceCenter_Flight_MeanAltitude(conn, &altitude, flight);
    double apoapsis;
    krpc_SpaceCenter_Orbit_ApoapsisAltitude(conn, &apoapsis, orbit);

    if (altitude > turn_start_altitude && altitude < turn_end_altitude) {
      double frac = (altitude - turn_start_altitude) / (turn_end_altitude - turn_start_altitude);
      double new_turn_angle = frac * 90.0;
      if (fabs(new_turn_angle - turn_angle) > 0.5) {
        turn_angle = new_turn_angle;
        krpc_SpaceCenter_AutoPilot_TargetPitchAndHeading(conn, auto_pilot, 90 - turn_angle, 90);
      }
    }

    if (!srbs_separated) {
      float srb_fuel;
      krpc_SpaceCenter_Resources_Amount(conn, &srb_fuel, stage_2_resources, "SolidFuel");
      if (srb_fuel < 0.1) {
        krpc_SpaceCenter_Control_ActivateNextStage(conn, NULL, control);
        srbs_separated = true;
        printf("SRBs separated\n");
      }
    }

    if (apoapsis > target_altitude * 0.9) {
      printf("Approaching target apoapsis\n");
      break;
    }
  }
```

```C#
        // Activate the first stage
        vessel.Control.ActivateNextStage ();
        vessel.AutoPilot.Engaged = true;
        vessel.AutoPilot.TargetPitchAndHeading (90, 90);

        // Main ascent loop
        bool srbsSeparated = false;
        double turnAngle = 0;
        while (true) {

            // Gravity turn
            if (altitude.Get () > turnStartAltitude &&
                altitude.Get () < turnEndAltitude) {
                double frac = (altitude.Get () - turnStartAltitude)
                              / (turnEndAltitude - turnStartAltitude);
                double newTurnAngle = frac * 90.0;
                if (Math.Abs (newTurnAngle - turnAngle) > 0.5) {
                    turnAngle = newTurnAngle;
                    vessel.AutoPilot.TargetPitchAndHeading (
                        (float)(90 - turnAngle), 90);
                }
            }

            // Separate SRBs when finished
            if (!srbsSeparated) {
                if (srbFuel.Get () < 0.1) {
                    vessel.Control.ActivateNextStage ();
                    srbsSeparated = true;
                    Console.WriteLine ("SRBs separated");
                }
            }

            // Decrease throttle when approaching target apoapsis
            if (apoapsis.Get () > targetAltitude * 0.9) {
                Console.WriteLine ("Approaching target apoapsis");
                break;
            }
        }
```

```C++
  // Activate the first stage
  vessel.control().activate_next_stage();
  vessel.auto_pilot().set_engaged(true);
  vessel.auto_pilot().target_pitch_and_heading(90, 90);

  // Main ascent loop
  bool srbs_separated = false;
  double turn_angle = 0;
  while (true) {
    // Gravity turn
    if (altitude() > turn_start_altitude && altitude() < turn_end_altitude) {
      double frac = (altitude() - turn_start_altitude)
                    / (turn_end_altitude - turn_start_altitude);
      double new_turn_angle = frac * 90.0;
      if (std::abs(new_turn_angle - turn_angle) > 0.5) {
        turn_angle = new_turn_angle;
        vessel.auto_pilot().target_pitch_and_heading(90.0 - turn_angle, 90.0);
      }
    }

    // Separate SRBs when finished
    if (!srbs_separated) {
      if (srb_fuel() < 0.1) {
        vessel.control().activate_next_stage();
        srbs_separated = true;
        std::cout << "SRBs separated" << std::endl;
      }
    }

    // Decrease throttle when approaching target apoapsis
    if (apoapsis() > target_altitude * 0.9) {
      std::cout << "Approaching target apoapsis" << std::endl;
      break;
    }
  }
```

--------------------------------

### krpc_SpaceCenter_Orbit_Inclination

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/space-center/orbit.rst.txt

Gets the orbital inclination.

```APIDOC
## krpc_SpaceCenter_Orbit_Inclination

### Description
The inclination of the orbit, in radians.

### Signature
`krpc_error_t krpc_SpaceCenter_Orbit_Inclination(krpc_connection_t connection, double * result)`
```

--------------------------------

### Engine.thrust_reversed

Source: https://krpc.github.io/krpc/0.6.0/python/api/space-center/parts.html

Gets or sets the engine's thrust reverser state. Raises an exception if the engine does not support thrust reversal.

```APIDOC
## Engine.thrust_reversed

### Description
Gets or sets whether the engine's thrust reverser is engaged. If the engine does not support thrust reversal, an exception is raised.

### Type
bool (Read/Write)
```

--------------------------------

### krpc_SpaceCenter_Orbit_Eccentricity

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/space-center/orbit.rst.txt

Gets the orbital eccentricity.

```APIDOC
## krpc_SpaceCenter_Orbit_Eccentricity

### Description
The eccentricity of the orbit.

### Signature
`krpc_error_t krpc_SpaceCenter_Orbit_Eccentricity(krpc_connection_t connection, double * result)`
```

--------------------------------

### Access custom service from Python

Source: https://krpc.github.io/krpc/0.6.0/extending.html

Demonstrates how to connect to the kRPC server and invoke the custom methods and properties defined in the LaunchControl service.

```python
import krpc

conn = krpc.connect()
conn.launch_control.throttle = 1
conn.launch_control.activate_stage()
```

--------------------------------

### krpc_SpaceCenter_Orbit_Period

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/space-center/orbit.rst.txt

Gets the orbital period.

```APIDOC
## krpc_SpaceCenter_Orbit_Period

### Description
The orbital period, in seconds.

### Signature
`krpc_error_t krpc_SpaceCenter_Orbit_Period(krpc_connection_t connection, double * result)`
```

--------------------------------

### getAvailable()

Source: https://krpc.github.io/krpc/0.6.0/_sources/java/api/remote-tech/remote-tech.rst.txt

Checks if the RemoteTech mod is installed.

```APIDOC
### boolean getAvailable()

Returns whether RemoteTech is installed.
```

--------------------------------

### Create a new alarm using C

Source: https://krpc.github.io/krpc/0.6.0/cnano/api/kerbal-alarm-clock.html

Demonstrates initializing a connection and creating a raw alarm set to trigger 10 seconds in the future with a custom message.

```c
#include <krpc_cnano.h>
#include <krpc_cnano/services/space_center.h>
#include <krpc_cnano/services/kerbal_alarm_clock.h>

int main() {
  krpc_connection_t conn;
  krpc_open(&conn, "COM0");
  krpc_connect(conn, "Kerbal Alarm Clock Example");

  double ut;
  krpc_SpaceCenter_UT(conn, &ut);
  krpc_KerbalAlarmClock_Alarm_t alarm;
  krpc_KerbalAlarmClock_CreateAlarm(
    conn, &alarm, KRPC_KERBALALARMCLOCK_ALARMTYPE_RAW, "My New Alarm", ut+10);

  krpc_KerbalAlarmClock_Alarm_set_Notes(
    conn, alarm, "10 seconds have now passed since the alarm was created.");
  krpc_KerbalAlarmClock_Alarm_set_Action(
    conn, alarm, KRPC_KERBALALARMCLOCK_ALARMACTION_MESSAGEONLY);
}
```

--------------------------------

### RemoteTech.Available

Source: https://krpc.github.io/krpc/0.6.0/_sources/csharp/api/remote-tech/remote-tech.rst.txt

Checks if the RemoteTech mod is installed.

```APIDOC
## Property: Available

### Description
Returns a boolean indicating whether RemoteTech is installed.

### Type
bool

### Access
Read-only
```

--------------------------------

### ready()

Source: https://krpc.github.io/krpc/0.6.0/_sources/cpp/api/infernal-robotics/infernal-robotics.rst.txt

Checks if the Infernal Robotics API is ready for use.

```APIDOC
## bool ready()

### Description
Returns whether the Infernal Robotics API is ready. This is typically used in the Flight scene.

### Returns
- **bool** - True if ready, false otherwise.
```

--------------------------------

### Connect to kRPC on POSIX

Source: https://krpc.github.io/krpc/0.6.0/cnano/client.html

Example program for Linux or other POSIX systems to connect to the server and retrieve the version.

```cpp
#include <krpc_cnano.h>
#include <krpc_cnano/services/krpc.h>

int main() {
  krpc_connection_t conn;
  krpc_open(&conn, "COM0");
  krpc_connect(conn, "Basic example");
  krpc_schema_Status status;
  krpc_KRPC_GetStatus(conn, &status);
  printf("Connected to kRPC server version %s\n", status.version);
}
```

--------------------------------

### krpc_SpaceCenter_Expansions

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/space-center/space-center.rst.txt

Retrieves the names of the installed expansions.

```APIDOC
## krpc_SpaceCenter_Expansions

### Description
Returns a list of the names of the installed expansions, such as "Serenity" or "MakingHistory".

### Parameters
- **connection** (krpc_connection_t) - Required - The active kRPC connection.
- **result** (krpc_list_string_t*) - Required - Pointer to store the list of expansion names.
```

--------------------------------

### krpc_RemoteTech_Available

Source: https://krpc.github.io/krpc/0.6.0/_sources/cnano/api/remote-tech/remote-tech.rst.txt

Checks if the RemoteTech mod is installed.

```APIDOC
## krpc_RemoteTech_Available

### Description
Checks whether the RemoteTech mod is installed.

### Signature
`krpc_error_t krpc_RemoteTech_Available(krpc_connection_t connection, bool * result)`
```

--------------------------------

### LaunchSite Class

Source: https://krpc.github.io/krpc/0.6.0/_sources/cpp/api/space-center/space-center.rst.txt

Methods for interacting with a launch site.

```APIDOC
## std::string name()

### Description
Returns the name of the launch site.

## CelestialBody body()

### Description
Returns the celestial body the launch site is located on.

## EditorFacility editor_facility()

### Description
Returns the editor facility normally used for this launch site.
```

--------------------------------

### krpc_Drawing_Polygon_Color

Source: https://krpc.github.io/krpc/0.6.0/cnano/api/drawing/polygon.html

Get or set the color of the polygon.

```APIDOC
## krpc_Drawing_Polygon_Color

### Description
Retrieves the color of the polygon.

### Signature
`krpc_error_t krpc_Drawing_Polygon_Color(krpc_connection_t connection, krpc_tuple_double_double_double_t *result)`

## krpc_Drawing_Polygon_set_Color

### Description
Sets the color of the polygon.

### Signature
`void krpc_Drawing_Polygon_set_Color(const krpc_tuple_double_double_double_t *value)`
```

--------------------------------

### Control Infernal Robotics Servos in Java

Source: https://krpc.github.io/krpc/0.6.0/java/api/infernal-robotics.html

Demonstrates how to connect to the kRPC server, retrieve a specific servo group from the active vessel, and execute movement commands.

```java
import krpc.client.Connection;
import krpc.client.RPCException;
import krpc.client.services.InfernalRobotics;
import krpc.client.services.InfernalRobotics.Servo;
import krpc.client.services.InfernalRobotics.ServoGroup;
import krpc.client.services.SpaceCenter;
import krpc.client.services.SpaceCenter.Vessel;

import java.io.IOException;

public class InfernalRoboticsExample {
    public static void main(String[] args) throws IOException, RPCException, InterruptedException {
        Connection connection = Connection.newInstance("InfernalRobotics Example");
        Vessel vessel = SpaceCenter.newInstance(connection).getActiveVessel();
        InfernalRobotics ir = InfernalRobotics.newInstance(connection);

        ServoGroup group = ir.servoGroupWithName(vessel, "MyGroup");
        if (group == null) {
            System.out.println("Group not found");
            return;
        }

        for (Servo servo : group.getServos()) {
            System.out.println(servo.getName() + " " + servo.getPosition());
        }

        group.moveRight();
        Thread.sleep(1000);
        group.stop();
        connection.close();
    }
}
```

--------------------------------

### krpc_Drawing_Polygon_Visible

Source: https://krpc.github.io/krpc/0.6.0/cnano/api/drawing/polygon.html

Get or set the visibility of the polygon.

```APIDOC
## krpc_Drawing_Polygon_Visible

### Description
Checks if the polygon is currently visible.

### Signature
`krpc_error_t krpc_Drawing_Polygon_Visible(krpc_connection_t connection, bool *result)`

## krpc_Drawing_Polygon_set_Visible

### Description
Sets the visibility of the polygon.

### Signature
`void krpc_Drawing_Polygon_set_Visible(bool value)`
```
Tokens:
Raw